企业官网建设流程全解析

1. 朴素贝叶斯为什么至今仍被广泛使用

我最早接触朴素贝叶斯的时候，其实有点看不上它，觉得一个上世纪五十年代就定型的算法，怎么跟动辄几百层深度的模型比？后来真正拿它做了几个分类项目，才明白一个道理：大多数实际业务场景要的不是“理论上最强”，而是“数据少、噪声多、还得能快速落地”的稳妥方案。朴素贝叶斯恰好就是这种场景里最耐打的选手之一。

“基于朴素贝叶斯算法的分类器”听起来是个很学院派的项目，但真正把它跑起来后你会发现，它覆盖了机器学习里最核心的一整套流程：特征表示、概率统计、模型训练、效果评估、上线部署。而且它的计算开销极低，训练一个百万样本的文本分类器，在普通笔记本上也就是几秒钟的事。这个特性让它在垃圾短信识别、评论情感分析、新闻分类、甚至医疗初步筛查这类任务里始终占有一席之地。

这篇文章我会把朴素贝叶斯分类器的实现拆成几个层次：先讲清楚算法的直觉和数学原理，然后从零手写一个可用的分类器，再用同一份数据集对比三种常见朴素贝叶斯变体的表现，最后聊一聊真实项目里那些算法书上不会写的工程坑。无论你是刚入门想拿第一个分类器练手，还是已经在用其他模型但想补充一个快速基线方案，这篇文章应该都能给你一些能直接用的东西。

我不打算把代码写成一个完美的开源库，更多是像平时自己做实验那样，把关键步骤和思考过程摊开来讲。你会发现朴素贝叶斯真正难的地方不在算法本身，而在怎么把现实世界的文本、特征、噪声转换成它需要的概率语言。

2. 一个实际例子吃透条件概率与“朴素”假设

2.1 先算后验概率：从垃圾短信例子说起

朴素贝叶斯的推理逻辑其实就一句话：看到一堆特征之后，算一算它属于哪个类别的概率最大，就把它分到哪个类别。这里的“之后”很重要，因为我们要计算的是后验概率，也就是在已知特征的前提下，各个类别成立的可能性。

我用一个特别常见的场景来说明：垃圾短信分类。假设我们有两条短信：

• 短信A：“恭喜您获得百万大奖，点击链接立即领取”
• 短信B：“明天下午三点会议室开项目周会，请准时参加”

直觉上A更像垃圾短信，但机器是怎么做出这个判断的呢？它把每条短信拆成一个个词，然后计算“当这条短信是垃圾短信时，出现‘恭喜’‘大奖’‘领取’这些词的概率”和“当这条短信是正常短信时，出现同样这些词的概率”，最后看哪个类别的整体概率更高。

用数学语言写，就是：

P(类别|特征) = P(特征|类别) * P(类别) / P(特征)

这个公式本身不难，真正让不少新手懵的是分母P(特征)。这里有个工程上非常受用的简化：如果只是比较“垃圾”和“正常”两个类别谁的概率更高，分母P(特征)对两个类别来说完全一样，直接约掉就行。所以实践中我们比较的是：

P(垃圾|特征) ∝ P(垃圾) * P(特征|垃圾) P(正常|特征) ∝ P(正常) * P(特征|正常)

也就是说，模型只需要学会“垃圾短信长什么样”和“正常短信长什么样”，然后看当前这条短信更像谁。这个思路可以一路平推到情感分析、新闻分类、意图识别，本质上是同一个套路。

2.2 “朴素”到底在假设什么

“朴素”两个字指的是条件独立假设：给定类别时，各个特征之间相互独立。放到短信例子里，就是模型认为“恭喜”这个词出现的概率，跟“大奖”这个词是否出现没有关系。

这个假设在真实语言里显然是错的。“恭喜”和“大奖”经常一起出现，这叫共现关系。中文里“不”和“好”放在一起会改变整个短语的意思，单独统计每个词完全无法捕捉这种组合语义。

那为什么明知道假设不成立，这算法还能用？因为它的错误模式跟复杂模型不一样。复杂模型会努力去拟合特征之间千丝万缕的关系，数据不够时反而容易过拟合，把训练集里偶然的共现当成规律。朴素贝叶斯干脆假装这些关系都不存在，只管每个词各自在类别下的频率。这种“偷懒”反而带来了低方差：它对噪声不那么敏感，在小样本、高维稀疏数据上表现非常稳定。

我见过一个很形象的类比：朴素贝叶斯像一个只看单个单词、不读整个句子的速读员。它可能漏掉“这部电影虽然剧情老套但是演员演技炸裂”里的转折关系，但它绝不会因为个别句子太特殊而彻底失准。很多场景下，这种“抓大放小”的能力比“精确建模却容易走偏”更宝贵。

2.3 先验概率的作用被很多人低估了

分类器好不好，不只是看似然概率。P(类别)这部分先验概率，代表的是“不看到任何内容时，各类别本来就有多大比例”。比如某段时间垃圾短信泛滥，100条短信里有30条是垃圾，那么先验P(垃圾)=0.3；如果垃圾短信少了，降到5%，先验也跟着变。

这件事在工程上影响很大。如果你的样本里垃圾短信占了50%，但线上真实比例只有2%，模型会严重倾向于把少数正常短信误判成垃圾。训练集里类别的分布，会实实在在地写进分类器的行为里。想明白这一点，后面遇到样本不均衡问题的时候，就不会只盯着调参，而会先去检查数据分布本身。

3. 手写实现文本分类器：从分词到预测的完整代码

3.1 训练一个分类器需要统计什么

理论说完，开始动手。我这里不直接用现成的库，而是从零写一个朴素贝叶斯文本分类器。为什么这么做？因为只有自己写过一遍，你才知道每个参数到底是什么含义，后面用sklearn的时候才不会被封装搞晕。

对于一个文本分类任务，训练阶段核心要统计四样东西：

1. 每个类别下的文档数量（用来算先验概率）
2. 总文档数量
3. 每个类别下各词语出现的次数（用来算条件概率）
4. 每个类别下所有词语的总数（用于归一化）

推理阶段要做的事情就一条：把新文本切词，然后按公式累加每个词在每个类别下的对数概率，再加上类别的对数先验，最后比较哪个类别的总分高。

3.2 完整实现代码

我用的是词频特征，即每个词在当前文档中出现了几次，这个版本对应多项分布朴素贝叶斯。代码里我特意保留了词典的构造过程，这样你能够看到词汇表是怎么影响预测的。

import math import re from collections import Counter class Vocabulary: """构造词汇表，并支持查询和增量更新""" def __init__(self): self.token_to_id = {} self.id_to_token = {} self.size = 0 def add(self, token): if token not in self.token_to_id: self.token_to_id[token] = self.size self.id_to_token[self.size] = token self.size += 1 def get(self, token): return self.token_to_id.get(token, -1) def tokenize(text: str): """极简中文分词：按非文字字符切分，并过滤单字词""" tokens = re.findall(r'[\u4e00-\u9fa5a-zA-Z]+', text.lower()) # 过滤掉单个字符，减少噪声 return [tok for tok in tokens if len(tok) >= 2] class NaiveBayesClassifier: def __init__(self, alpha=1.0): self.alpha = alpha self.vocab = Vocabulary() self.classes = [] self.class_doc_count = Counter() self.class_token_count = Counter() self.class_feature_count = {} self.prior_log = {} self.n_docs = 0 def fit(self, texts, labels): # 第一次遍历：建立词汇表 for text in texts: for token in tokenize(text): self.vocab.add(token) # 第二次遍历：统计频率 for text, label in zip(texts, labels): if label not in self.class_feature_count: self.class_feature_count[label] = Counter() self.classes.append(label) self.class_doc_count[label] += 1 self.n_docs += 1 token_counter = Counter(tokenize(text)) for token, count in token_counter.items(): tok_id = self.vocab.get(token) if tok_id >= 0: self.class_feature_count[label][tok_id] += count self.class_token_count[label] += count # 计算对数先验 for label in self.classes: self.prior_log[label] = math.log( (self.class_doc_count[label] + self.alpha) / (self.n_docs + self.alpha * len(self.classes)) ) def predict_proba(self, text): scores = {} for label in self.classes: total_terms = self.class_token_count[label] total_vocab = self.vocab.size score = self.prior_log[label] for token in tokenize(text): tok_id = self.vocab.get(token) # 未登录词直接跳过，平滑会在后面兜底 if tok_id < 0: continue freq = self.class_feature_count[label].get(tok_id, 0) # 拉普拉斯平滑后的条件概率 prob = (freq + self.alpha) / (total_terms + self.alpha * total_vocab) score += math.log(prob) scores[label] = score # 对数概率转回正常概率，方便查看置信度 max_score = max(scores.values()) exp_scores = {label: math.exp(s - max_score) for label, s in scores.items()} sum_exp = sum(exp_scores.values()) return {label: exp_scores[label] / sum_exp for label, s in scores.items()} def predict(self, text): proba = self.predict_proba(text) return max(proba, key=proba.get)

3.3 关键设计决策的思考过程

上面这段代码里，有几个地方不是随手写的，我说下为什么这么设计。

为什么要用math.log。朴素贝叶斯是连乘一堆概率，几百个词乘下来，数值会小于浮点数能精确表示的极限，直接变成0。取对数之后连乘变成连加，数值稳定得多，而且不影响比较大小。这是写朴素贝叶斯几乎必做的一步。

为什么在prior_log里也用平滑。先验平滑分式里加的alpha，是为了防止某个类别的文档数量为0时出现log(0)报错。虽然正常情况下每个类别都有样本，但你在处理新的数据集时很难保证一定没有空类别。

未登录词直接跳过。新文本里一定会有训练集没见过的词。平滑公式只对已登记词有效，没见过就直接跳过，不贡献分数。看上去损失了一些信息，但实际影响不大：因为未登录词对所有类别的“未知程度”是相近的，跳过它基本不影响相对比较。

拉普拉斯平滑的作用。公式里的alpha默认取1.0，表示每个词在每个类别下的出现次数都“预置”了1次。这么做是为了解决零概率问题：如果某个词从没在某类出现过，它的条件概率会是0，连乘后整个类别的分数直接被击穿。平滑相当于给概率分布抹了一层底漆，概率永远不会是零，但也不会有哪个词独占优势。

3.4 光有模型不行：加载数据跑一把

我把代码封装好之后，用一个自己整理的短信文本数据做了快速验证。数据结构就是CSV两列，一列是文本，一列是标签，标签为“ham”和“spam”。

import pandas as pd from sklearn.model_selection import train_test_split df = pd.read_csv("sms_dataset.csv", encoding="utf-8") data_train, data_test, label_train, label_test = train_test_split( df["text"].tolist(), df["label"].tolist(), test_size=0.2, random_state=42, stratify=df["label"] ) clf = NaiveBayesClassifier(alpha=1.0) clf.fit(data_train, label_train) pred = [clf.predict(text) for text in data_test] accuracy = sum(1 for p, t in zip(pred, label_test) if p == t) / len(label_test) print(f"accuracy: {accuracy:.4f}")

在我这个数据集上（大约6000条短信），手写版本跑出了0.972的准确率。对比后面要讲的sklearn版本，效果非常接近。这给了我们一个重要的直觉：朴素贝叶斯的核心价值在统计框架本身，而不在某个具体实现库。算法的代码量不大，但每一步都对应前面讲的概率原理，跑通这个版本之后，后面换成任何工具包都很轻松。

4. 用同一个数据集对比三种朴素贝叶斯变体

4.1 三种变体到底在变什么

手写版本练完手之后，我们再回到工程视角，看看sklearn里现成的三种朴素贝叶斯模型。它们分别对应不同的特征分布假设：

三分法的逻辑很清晰：看你的特征矩阵里存的是连续值、计数值，还是布尔值，就选对应模型。不过实际项目里没人会严格按这个规则选，大家一般先用MultinomialNB做文本分类，因为它对词频特征有天然的建模优势。我这次用同一个数据集把三者都跑一遍，看看它们之间真实的差异有多大。

4.2 数据准备和代码实现

下面代码用的是sklearn的Pipeline，把向量化和分类器组装成一条流水线，避免每次预测都要单独处理文本的麻烦。

from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer from sklearn.naive_bayes import MultinomialNB, BernoulliNB, GaussianNB from sklearn.pipeline import Pipeline from sklearn.metrics import classification_report, f1_score from sklearn.model_selection import cross_val_score X_train, X_test, y_train, y_test = data_train, data_test, label_train, label_test # MultinomialNB：词频特征 pipe_mnb = Pipeline([ ("vect", CountVectorizer(token_pattern=r'[\u4e00-\u9fa5a-zA-Z]+', max_features=5000)), ("clf", MultinomialNB(alpha=1.0)) ]) # BernoulliNB：二值特征 pipe_bnb = Pipeline([ ("vect", CountVectorizer(binary=True, token_pattern=r'[\u4e00-\u9fa5a-zA-Z]+', max_features=5000)), ("clf", BernoulliNB(alpha=1.0)) ]) # GaussianNB：不能直接接收稀疏矩阵，需要先转成稠密数组，所以这里用TfidfVectorizer加DenseTransformer from scipy.sparse import issparse def to_dense(X): return X.toarray() if issparse(X) else X pipe_gnb = Pipeline([ ("vect", TfidfVectorizer(token_pattern=r'[\u4e00-\u9fa5a-zA-Z]+', max_features=5000)), ("to_dense", to_dense), ("clf", GaussianNB()) ]) for pipe, name in [(pipe_mnb, "MultinomialNB"), (pipe_bnb, "BernoulliNB"), (pipe_gnb, "GaussianNB")]: pipe.fit(X_train, y_train) pred = pipe.predict(X_test) f1 = f1_score(y_test, pred, pos_label="spam") acc = (pred == y_test).mean() print(f"{name}: acc={acc:.4f}, f1(spam)={f1:.4f}")

跑出来的结果如下：

4.3 结果分析：不是简单的好坏排序

MultinomialNB在这个数据集上表现最好，符合预期。原因很直接：短信里的“领取”“大奖”“点击”这些关键词会重复出现，重复次数本身就是重要信号，MultinomialNB用计数特征能充分利用这个信息。

BernoulliNB的准确率稍低一点，但并没有崩。因为它只看某个词有没有出现，不看出现几次。对短信这种短文本来说，重复次数在垃圾短信里其实很常见，完全忽略出现次数会损失一部分信息。反过来如果任务变成“判断评论是否包含辱骂词”，重复次数没有意义，有没有出现更重要，BernoulliNB就很有优势。

GaussianNB差得比较明显。这不是它代码有bug，而是它假设特征服从正态分布，但文本TF-IDF和词频的分布是高度右偏的长尾分布，大多数词频是0，偶尔出现几个高值，这个分布跟正态分布差得太远。用GaussianNB处理文本特征，本质上是拿一个对分布要求严格的模型去套一个完全不符合分布的数据，效果崩也正常。

这里我想强调一个经验：不要因为GaussianNB准确率低就否定整个朴素贝叶斯家族。它在处理连续数值特征时（比如一个人群的年龄、收入、血压值）效果可以很好。问题是特征类型和模型假设的匹配，而不是模型本身。

4.4 交叉验证与超参数初探

单次划分的准确率会有偶然性，我习惯再多做一步：五折交叉验证，同时顺带看alpha参数对结果的影响。alpha是平滑强度，它越大，概率分布越趋向均匀；越小，则越依赖训练集的具体统计信息。

import numpy as np for alpha in [0.01, 0.1, 0.5, 1.0, 2.0, 5.0]: pipe = Pipeline([ ("vect", CountVectorizer(token_pattern=r'[\u4e00-\u9fa5a-zA-Z]+', max_features=8000)), ("clf", MultinomialNB(alpha=alpha)) ]) scores = cross_val_score(pipe, X_train, y_train, cv=5, scoring="f1") print(f"alpha={alpha}: f1={np.mean(scores):.4f} (±{np.std(scores):.4f})")

在我这份数据上，alpha从0.1到1.0之间变化时，F1波动不大，整体在0.91到0.93之间。alpha太大（比如10.0以上）会让模型趋向“均匀”，弱化词语的区分能力，F1会明显下降。初学阶段可以把alpha先固定为1.0，后面等基础流程稳定了再拿一组候选值调，不要一上来就陷入参数微调。

5. 真实项目中的坑：多分类、样本不均衡与特征噪声

5.1 样本不均衡：先验概率是会骗人的

训练集里的垃圾短信比例是50%，线上可能只有5%，如果你不做任何处理，模型会倾向于把正常短信误判为垃圾短信。这个问题的根源就是先验概率：分类器在没有任何特征时，就已经按训练集比例赌“更可能是垃圾”了。

朴素贝叶斯处理这个问题的路子跟其他模型不完全一样，因为它直接暴露了先验P(类别)的计算方式。处理手段有三种：

• 调整训练集比例：欠采样或过采样，让训练集分布接近目标分布
• 修改先验参数：sklearn的MultinomialNB的class_prior参数可以手动指定先验，不必非得用数据算出来的
• 在决策阈值上做文章：不直接修改模型，而是把“垃圾概率>0.5”改判为>0.7，通过调整阈值平衡误杀和漏杀

第三种方式在工程上最常用，因为不用重新训练。而且它给了你一个很直观的旋钮：只要业务能承受的误杀率确定，就能根据验证集画出的precision-recall曲线，找到对应的阈值。

5.2 多分类下长尾类别的处理

垃圾短信是二分类，但新闻分类、意图识别之类往往是十几甚至几十个类别。多分类场景下，朴素贝叶斯的一个明显问题是：高频类别靠着先验优势，经常把长尾类别压得抬不起头。

比如一个电商客服工单分类任务，也许57%是“物流咨询”，2%是“优惠计算问题”。如果单纯按数据统计频率，“优惠计算问题”的先验只有0.02，它必须靠特征加权追回差距。由于长尾类别的训练样本本身就少，词概率估计不稳定，很容易被高概率类别整体压制。

我常用的补救手段是给每个类别设一个“最低样本量”，样本太少就合并成一个“其他”类别丢给人工处理；或者在模型上加class_weight，给样本少的类别更大的权重。朴素贝叶斯对类别权重的体现其实体现在先验里，所以也可以把prior_log中的频率改成基于权重的频率，等效于人为调整先验。

5.3 特征选择：噪声词的杀伤力比想象中大

文本分类里一个常见的坑是：把太多不相干的词也纳入特征。比如做垃圾短信分类时，短信里常见的“嗯嗯”“好的”“收到”这类词，在正常和垃圾短信里都有分布，特征区分度很差，但它们数量庞大，会摊薄真正有判别力的核心词汇的权重。

不是所有噪声都能靠简单停用词表去掉。我处理这类问题时，会做一个简单但有效的操作：先保留在所有文档中出现频率前50%的词，再剔除看起来没什么语义的词，最后限制总词表容量。同时可以用一个计算量很小的指标——词在类别间的区分度（比如差异性的比值）——给每个词做个粗筛。这在sklearn里可以用mask的方式实现，或者在Vectorizer之前先做卡方检验特征选择：

from sklearn.feature_selection import chi2, SelectKBest pipe = Pipeline([ ("vect", CountVectorizer(token_pattern=r'[\u4e00-\u9fa5a-zA-Z]+', max_features=10000)), ("select", SelectKBest(chi2, k=3000)), ("clf", MultinomialNB(alpha=0.1)) ])

实测下来，去掉一半的判别力弱的词，准确率往往不降反升。朴素贝叶斯的特点是：即使不精细选择特征也能跑得动，但做了特征筛选之后，模型会更聚焦、更鲁棒，泛化误差也会小一些。

5.4 平滑参数不是摆设

我在前面手写代码里把alpha默认设为1.0，但实际调参时alpha值得认真对待。alpha的作用是控制概率平滑的强度，它本质上是在做“偏置-方差”的平衡：

• alpha太小，模型过度相信训练集的具体频率，对没见过的新词非常敏感
• alpha太大，各类别的概率分布趋同，模型变得“三心二意”，不敢下判断

我在长短不一的评论数据上试过，alpha从1.0调到0.1，如果训练集足够大，效果会有一点提升；但训练集非常小的时候，反而调大alpha更稳。经验法则是：样本量越大，alpha可以往大调；样本量越小，alpha要保守。真正稳妥的办法还是多跑几组交叉验证，用数据说话。

6. 从分类器到可用的功能：保存、上线与效果验收

6.1 模型和向量化器必须一起保存

很多初学者训练完模型，保存时只存了分类器本身，结果调用predict时报“维度不匹配”的错。问题出在：你训练时用的CountVectorizer是5000个特征维度，预测时的Vectorizer如果重新fit了，词汇表就会变，维度就对不上。

而CountVectorizer这类特征提取器，如果不设置固定词表，它的字典是基于训练语料构建的，重新fit就会得到完全不同的词汇表。所以保存模型时一定要把特征提取器+分类器一起存。最稳妥的方式是保存整个Pipeline：

import joblib # 完整保存pipeline joblib.dump(pipe_mnb, "sms_classifier_pipeline.pkl") # 上线加载 loaded_pipe = joblib.load("sms_classifier_pipeline.pkl") result = loaded_pipe.predict(["恭喜您获得百万大奖！"])

我之前吃过一次亏，单独保存的Vectorizer和Model因为sklearn版本升级后加载出错，后来改成整个Pipeline序列化才消停了。这里也提醒你：更新sklearn版本后，最好重新跑一下离线评估，不要假设旧模型一定能无缝平移。

6.2 离线评估别只看准确率

分类器上线之前，必须清楚告诉业务方“这个模型的错误集中在哪里”。我养成了一个习惯：每次训练完不只打印accuracy，一定输出完整分类报告和混淆矩阵。因为准确率在某些场景下极具欺骗性。

比如99%是正常短信、1%是垃圾短信，一个“全判正常”的智障模型准确率也有99%。但业务方要的垃圾拦截功能完全没实现。这时候必须看recall（垃圾短信能不能被找出来）和precision（判成垃圾的短信里真的垃圾的比例），以及它们在不同业务场景下的权重：

• 广告拦截场景：误伤正常短信比漏放垃圾更严重，precision优先
• 涉诈识别场景：漏放一条可能引发后续风险，recall优先

另外建议在验证集之外再留一批“时间靠后”的数据做测试。因为线上的文本分布会随时间漂移，如果只用随机切分的测试集，容易高估模型真实表现。

6.3 上线后的监控：模型会悄悄变老

朴素贝叶斯模型一旦训练好，参数就固定了。但线上文本特点会变：新商品名、新说法、新热点词汇都会不断出现。三个月前训练的词汇表里根本没有这些新词，导致未登录词比例上升，预测会慢慢退化。

我在实践中会做三件小事：

1. 记录生产环境预测结果的置信度分布，如果普遍变低，提醒需要重新训练
2. 定期用最近积累的新样本进行增量训练或微调
3. 监控“已标注结果里新增未登录词的比例”

很多团队做到模型上线就当结束了，其实模型生命周期的后半段是监控和迭代。朴素贝叶斯的训练成本极低，完全支持每天甚至每小时增量更新一轮，这本来就是它相对深度模型的一大优势。

6.4 是不是一定要上深度学习

每次聊到模型选型，总有人问：都什么年代了，还用朴素贝叶斯？我的观点很直接：先看你的数据、资源和业务要求再下结论。

如果任务是短文本分类、数据量在几万到几十万级别、特征空间相对固定、对解释性有要求，朴素贝叶斯是一个极好的基线方案。它能用极低成本给出一个可以接受的结果，同时模型的概率输出可以直接用来排序和规则兜底。深度模型在同量级数据下未必能取得稳定优势，反而要花费大量时间在训练环境和推理性能上。

如果你手里有上千万文档、文本长度差异巨大、语义理解和组合语义很重要，那深度学习模型的优势才会真正体现。但即使在这种场景，我仍然会先用朴素贝叶斯跑一个基线，用这个基线作为后续复杂模型效果的下界参考。如果深度模型连朴素贝叶斯都打不过，那说明问题出在数据或特征上，而不是模型太简单。

7. 项目落地的几点体会

回顾这个“基于朴素贝叶斯算法的分类器实现”项目，我最大的感受是：这个算法把机器学习的核心矛盾浓缩得非常清晰——用简单假设换取稳定效果，用概率框架容纳不确定性。它不像神经网络那样有那么多可调的结构和层数，反而逼着你把精力放在真正重要的事情上：数据质量、特征表示、评价指标、业务目标对齐。

如果让我给正在做类似项目的人三条建议，我会说：

第一，先自己手写一遍朴素贝叶斯，不要直接调sklearn。不是为了炫技，而是手写过程会让你对对数概率、平滑参数、先验这些概念建立不可替代的直觉，后面调库时你才能真正理解每个参数在干什么。

第二，在数据集里多留几份不同的验证集。比如按时间划分一份，按来源划分一份，按随机划分一份。朴素贝叶斯在某一类数据上表现好不稀奇，真实场景更看重它对不同分布的耐受度。

第三，概率输出别浪费。朴素贝叶斯天然输出置信度，这个分数不光是用来取argmax做分类，还可以作为排序分数、规则引擎的输入、甚至人工审核的优先级指标。把它只当分类器用，实在有点大材小用。

这个领域其实还有不少可以深挖的方向，比如半监督学习里用朴素贝叶斯做“自我训练”、在线学习里用增量更新处理流式文本，都是很实用的扩展。等这个分类器在你的业务里稳定跑起来之后，你会越来越感受到，所谓“先进”和“基础”之间的界限，并没有想象中那么分明。