朴素贝叶斯——对侮辱性言论分类（易上手，易懂，代码运行可用，亲测，python3）另有用handle 分词

因为里面有很详细的解释，所以就不做过多阐释：
  1 from pyhanlp import *
  2 import numpy as np
  3 import re
  4 
  5 '''创建数据集：单词列表postingList, 所属类别classVec'''
  6 def Handle_data(content):
  7     reg = "[^0-9A-Za-zu4e00-u9fa5]"
  8     CustomDictionary.add("傻缺", "nr 300")
  9     CustomDictionary.insert("语音识别", "nz 1024")
 10     CustomDictionary.add("巨大成功", "nz 1024 n 1")
 11     CustomDictionary.add("深度学习", "nz 1025")
 12     content=re.sub(reg, '', content)
 13     Get_value = HanLP.segment(content)
 14     lists=[]
 15     for term in Get_value:
 16         lists.append(term.word)
 17     return lists
 18 def loadDataSet():
 19     Train = [
 20         "你个傻缺",
 21         "今天天气真的很好，我要开始新的一天去学习",
 22         "我太不开心了，我日",
 23         "每一个太阳都很大",
 24         "你真是个傻缺",
 25         "你太狗了",
 26         "加油，我最棒"
 27     ]
 28     Train_y = [
 29         1, 0, 1, 0, 1, 1, 0
 30     ]
 31     Train_x = []
 32     for n in Train:
 33         a = Handle_data(n)
 34         Train_x.append(a)
 35     return Train_x, Train_y
 36 
 37 '''获取所有单词的集合:返回不含重复元素的单词列表'''
 38 def createVocabList(dataSet):
 39     vocabSet = set([])
 40 
 41     for document in dataSet:
 42         vocabSet = vocabSet | set(document)  # 操作符 | 用于求两个集合的并集
 43     #print(vocabSet,"PPPPPPP")
 44     return list(vocabSet)
 45 
 46 '''词集模型构建数据矩阵'''
 47 def setOfWords2Vec(vocabList, inputSet):
 48     # 创建一个和词汇表等长的向量，并将其元素都设置为0
 49     returnVec = [0] * len(vocabList)
 50     # 遍历文档中的所有单词，如果出现了词汇表中的单词，则将输出的文档向量中的对应值设为1
 51     for word in inputSet:
 52         if word in vocabList:
 53             returnVec[vocabList.index(word)] = 1
 54         else:
 55             print("单词: %s 不在词汇表之中!" % word)
 56     #print(returnVec)
 57     return returnVec
 58 '''文档词袋模型构建数据矩阵'''
 59 def bagOfWords2VecMN(vocabList, inputSet):
 60     returnVec = [0] * len(vocabList)
 61     for word in inputSet:
 62         if word in vocabList:
 63             returnVec[vocabList.index(word)] += 1
 64     #print(returnVec)
 65     return returnVec
 66 
 67 '''朴素贝叶斯分类器训练函数'''
 68 def _trainNB0(trainMatrix, trainCategory):
 69     numTrainDocs = len(trainMatrix) # 文件数
 70     numWords = len(trainMatrix[0]) # 单词数
 71     # 侮辱性文件的出现概率，即trainCategory中所有的1的个数，
 72     # 代表的就是多少个侮辱性文件，与文件的总数相除就得到了侮辱性文件的出现概率
 73     pAbusive = sum(trainCategory) / float(numTrainDocs)
 74 
 75     # 构造单词出现次数列表
 76     p0Num = np.zeros(numWords) # [0,0,0,.....]
 77     p1Num = np.zeros(numWords) # [0,0,0,.....]
 78     p0Denom = 0.0;p1Denom = 0.0 # 整个数据集单词出现总数
 79     for i in range(numTrainDocs):
 80         # 遍历所有的文件，如果是侮辱性文件，就计算此侮辱性文件中出现的侮辱性单词的个数
 81         if trainCategory[i] == 1:
 82             p1Num += trainMatrix[i] #[0,1,1,....]->[0,1,1,...]
 83             p1Denom += sum(trainMatrix[i])
 84         else:
 85             # 如果不是侮辱性文件，则计算非侮辱性文件中出现的侮辱性单词的个数
 86             p0Num += trainMatrix[i]
 87             p0Denom += sum(trainMatrix[i])
 88     # 类别1，即侮辱性文档的[P(F1|C1),P(F2|C1),P(F3|C1),P(F4|C1),P(F5|C1)....]列表
 89     # 即 在1类别下，每个单词出现次数的占比
 90     p1Vect = p1Num / p1Denom# [1,2,3,5]/90->[1/90,...]
 91     # 类别0，即正常文档的[P(F1|C0),P(F2|C0),P(F3|C0),P(F4|C0),P(F5|C0)....]列表
 92     # 即 在0类别下，每个单词出现次数的占比
 93     p0Vect = p0Num / p0Denom
 94     return p0Vect, p1Vect, pAbusive
 95 '''训练数据优化版本'''
 96 def trainNB0(trainMatrix, trainCategory):
 97     numTrainDocs = len(trainMatrix) # 总文件数
 98     numWords = len(trainMatrix[0]) # 总单词数
 99     pAbusive = sum(trainCategory) / float(numTrainDocs) # 侮辱性文件的出现概率
100     # 构造单词出现次数列表,p0Num 正常的统计,p1Num 侮辱的统计
101     # 避免单词列表中的任何一个单词为0，而导致最后的乘积为0，所以将每个单词的出现次数初始化为 1
102     p0Num = np.ones(numWords)#[0,0......]->[1,1,1,1,1.....],ones初始化1的矩阵
103     p1Num = np.ones(numWords)
104 
105     # 整个数据集单词出现总数，2.0根据样本实际调查结果调整分母的值（2主要是避免分母为0，当然值可以调整）
106     # p0Denom 正常的统计
107     # p1Denom 侮辱的统计
108     p0Denom = 2.0
109     p1Denom = 2.0
110     for i in range(numTrainDocs):
111         if trainCategory[i] == 1:
112             p1Num += trainMatrix[i]  # 累加辱骂词的频次
113             p1Denom += sum(trainMatrix[i]) # 对每篇文章的辱骂的频次 进行统计汇总
114         else:
115             p0Num += trainMatrix[i]
116             p0Denom += sum(trainMatrix[i])
117     # 类别1，即侮辱性文档的[log(P(F1|C1)),log(P(F2|C1)),log(P(F3|C1)),log(P(F4|C1)),log(P(F5|C1))....]列表,取对数避免下溢出或浮点舍入出错
118     p1Vect = np.log(p1Num / p1Denom)
119     # 类别0，即正常文档的[log(P(F1|C0)),log(P(F2|C0)),log(P(F3|C0)),log(P(F4|C0)),log(P(F5|C0))....]列表
120     p0Vect = np.log(p0Num / p0Denom)
121     return p0Vect, p1Vect, pAbusive
122 
123 '''分类'''
124 def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
125     # 计算公式  log(P(F1|C))+log(P(F2|C))+....+log(P(Fn|C))+log(P(C))
126     # 使用 NumPy 数组来计算两个向量相乘的结果，这里的相乘是指对应元素相乘，即先将两个向量中的第一个元素相乘，然后将第2个元素相乘，以此类推。这里的 vec2Classify * p1Vec 的意思就是将每个词与其对应的概率相关联起来
127     p1 = sum(vec2Classify * p1Vec) + np.log(pClass1)
128     p0 = sum(vec2Classify * p0Vec) + np.log(1.0 - pClass1)
129     if p1 > p0:
130         return 1
131     else:
132         return 0
133 
134 def classifyPrint(i):
135     if(i==1):
136         return "侮辱性"
137     else:
138         return "正常"
139 
140 if __name__ == '__main__':
141     #获取数据
142     Train_x, Train_y=loadDataSet()
143     #获得单词集合
144     Value=createVocabList(Train_x)
145     #获取每一句话中所有的出现频率
146     Translat_x=[]
147     for n in Train_x:
148         m=setOfWords2Vec(Value,n)
149         Translat_x.append(m)
150 
151     #训练数据
152     p0Vect, p1Vect, pAbusive=trainNB0(Translat_x,Train_y)
153     print("在1类别下，每个单词出现次数的占比:
",p1Vect)
154     print("在0类别下，每个单词出现次数的占比:
", p0Vect)
155     print("代表的就是多少个侮辱性文件，与文件的总数相除就得到了侮辱性文件的出现概率:
", pAbusive)
156 
157     #测试
158     test="你真是个傻缺"
159     testEntry=Handle_data(test)
160     thisDoc = np.array(setOfWords2Vec(Value, testEntry))
161     i=classifyNB(thisDoc, p0Vect, p1Vect, pAbusive)
162 
163     print(testEntry, '分类结果是: ',classifyPrint(i))