for sent in neg_docs:
data.append([self.handle(sent), 'neg'])
# 读入正样本
for sent in pos_docs:
data.append([self.handle(sent), 'pos'])
# 调用的是Bayes模型的训练方法
self.classifier.train(data)
def classify(self, sent):
# 1、调用sentiment类中的handle方法
# 2、调用Bayes类中的classify方法
ret, prob = self.classifier.classify(self.handle(sent)) # 调用贝叶斯中的classify方法
if ret == 'pos':
return prob
return 1-prob
从上述的代码中，`classify`函数和`train`函数是两个核心的函数，其中，`train`函数用于训练一个情感分类器，`classify`函数用于预测。在这两个函数中，都同时使用到的`handle`函数，`handle`函数的主要工作为：
1. 对输入文本分词
2. 去停用词
情感分类的基本模型是贝叶斯模型`Bayes`，对于贝叶斯模型，可以参见文章[简单易学的机器学习算法——朴素贝叶斯](https://gitee.com/vip204888)。对于有两个类别
c1
c
1
c\_1和
c2
c
2
c\_2的分类问题来说，其特征为
w1,⋯,wn
w
1
,
⋯
,
w
n
w\_1,\cdots ,w\_n，特征之间是相互独立的，属于类别
c1
c
1
c\_1的贝叶斯模型的基本过程为：
P(c1∣w1,⋯,wn)=P(w1,⋯,wn∣c1)⋅P(c1)P(w1,⋯,wn)
P
(
c
1
∣
w
1
,
⋯
,
w
n
)
=
P
(
w
1
,
⋯
,
w
n
∣
c
1
)
⋅
P
(
c
1
)
P
(
w
1
,
⋯
,
w
n
)
P\left ( c\_1\mid w\_1,\cdots ,w\_n \right )=\frac{P\left ( w\_1,\cdots , w\_n\mid c\_1 \right )\cdot P(c\_1)}{P\left ( w\_1,\cdots ,w\_n \right )}
其中：
P(w1,⋯,wn)=P(w1,⋯,wn∣c1)⋅P(c1)+P(w1,⋯,wn∣c2)⋅P(c2)
P
(
w
1
,
⋯
,
w
n
)
=
P
(
w
1
,
⋯
,
w
n
∣
c
1
)
⋅
P
(
c
1
)
+
P
(
w
1
,
⋯
,
w
n
∣
c
2
)
⋅
P
(
c
2
)
P\left ( w\_1,\cdots ,w\_n \right )=P\left ( w\_1,\cdots ,w\_n\mid c\_1 \right )\cdot P\left ( c\_1 \right )+P\left ( w\_1,\cdots ,w\_n\mid c\_2\right )\cdot P\left ( c\_2\right )
### 3.1、贝叶斯模型的训练
贝叶斯模型的训练过程实质上是在统计每一个特征出现的频次，其核心代码如下：
def train(self, data): # data 中既包含正样本，也包含负样本 for d in data: # data中是list # d[0]:分词的结果，list # d[1]:正/负样本的标记 c = d[1] if c not in self.d: self.d[c] = AddOneProb() # 类的初始化 for word in d[0]: # 分词结果中的每一个词 self.d[c].add(word, 1) # 返回的是正类和负类之和 self.total = sum(map(lambda x: self.d[x].getsum(), self.d.keys())) # 取得所有的d中的sum之和
这使用到了`AddOneProb`类，`AddOneProb`类如下所示：
class AddOneProb(BaseProb):
def \_\_init\_\_(self):
self.d = {}
self.total = 0.0
self.none = 1 # 默认所有的none为1
# 这里如果value也等于1，则当key不存在时，累加的是2
def add(self, key, value):
self.total += value
# 不存在该key时，需新建key
if not self.exists(key):
self.d[key] = 1
self.total += 1
self.d[key] += value
注意：
1. none的默认值为1
2. 当key不存在时，total和对应的d[key]累加的是1+value，这在后面预测时需要用到
>
> `AddOneProb`类中的total表示的是正类或者负类中的所有值；train函数中的total表示的是正负类的total之和。
>
>
>
当统计好了训练样本中的total和每一个特征key的d[key]后，训练过程就构建完成了。
### 3.2、贝叶斯模型的预测
预测的过程使用到了上述的公式，即：
P(c1∣w1,⋯,wn)=P(w1,⋯,wn∣c1)⋅P(c1)P(w1,⋯,wn∣c1)⋅P(c1)+P(w1,⋯,wn∣c2)⋅P(c2)
P
(
c
1
∣
w
1
,
⋯
,
w
n
)
=
P
(
w
1
,
⋯
,
w
n
∣
c
1
)
⋅
P
(
c
1
)
P
(
w
1
,
⋯
,
w
n
∣
c
1
)
⋅
P
(
c
1
)
+
P
(
w
1
,
⋯
,
w
n
∣
c
2
)
⋅
P
(
c
2
)
P\left ( c\_1\mid w\_1,\cdots ,w\_n \right )=\frac{P\left ( w\_1,\cdots , w\_n\mid c\_1 \right )\cdot P(c\_1)}{P\left ( w\_1,\cdots ,w\_n\mid c\_1 \right )\cdot P\left ( c\_1 \right )+P\left ( w\_1,\cdots ,w\_n\mid c\_2\right )\cdot P\left ( c\_2\right )}
对上述的公式简化：
P(c1∣w1,⋯,wn)=P(w1,⋯,wn∣c1)⋅P(c1)P(w1,⋯,wn∣c1)⋅P(c1)+P(w1,⋯,wn∣c2)⋅P(c2)=11+P(w1,⋯,wn∣c2)⋅P(c2)P(w1,⋯,wn∣c1)⋅P(c1)=11+exp[log(P(w1,⋯,wn∣c2)⋅P(c2)P(w1,⋯,wn∣c1)⋅P(c1))]=11+exp[log(P(w1,⋯,wn∣c2)⋅P(c2))−log(P(w1,⋯,wn∣c1)⋅P(c1))]
P
(
c
1
∣
w
1
,
⋯
,
w
n
)
=
P
(
w
1
,
⋯
,
w
n
∣
c
1
)
⋅
P
(
c
1
)
P
(
w
1
,
⋯
,
w
n
∣
c
1
)
⋅
P
(
c
1
)
+
P
(
w
1
,
⋯
,
w
n
∣
c
2
)
⋅
P
(
c
2
)
=
1
1
+
P
(
w
1
,
⋯
,
w
n
∣
c
2
)
⋅
P
(
c
2
)
P
(
w
1
,
⋯
,
w
n
∣
c
1
)
⋅
P
(
c
1
)
=
1
1
+
e
x
p
[ l o g ( P ( w 1 , ⋯ , w n ∣ c 2 ) ⋅ P ( c 2 ) P ( w 1 , ⋯ , w n ∣ c 1 ) ⋅ P ( c 1 ) ) ]
=
1
1
+
e
x
p
[ l o g ( P ( w 1 , ⋯ , w n ∣ c 2 ) ⋅ P ( c 2 ) ) − l o g ( P 
**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Go语言开发知识点，真正体系化！**
**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**
**[如果你需要这些资料，可以戳这里获取](https://gitee.com/vip204888)**
