关联文章：
一、垃圾邮件分类：
流程：
1）中文或英文的分词
中文的分词：用到了第三方分词组件jieba参考 https://github.com/fxsjy/jieba
安装过程：关联文章：Anaconda 安装第三方工具包
英文的分词：使用正则表达式切分 import re 参考https://docs.python.org/zh-cn/3/library/re.html
2）构建全部训练集的词列表vocalList（不重复）
3）加载停用词列表or所有的vocaList统计高频词，然后去除高频词或者是去除包含的停用词
停用词获取地址：https://www.ranks.nl/stopwords
4）每篇文档的词列表转换为词向量（01表示）4）每条词向量以及类别划分训练集和测试集
5）训练bayes算法获得先验概率、类0条件概率、类1的条件概率
机器学习实战上的例子搞错了！，参考：
https://blog.csdn.net/qq_27009517/article/details/80044431
https://blog.csdn.net/lming_08/article/details/37542331
朴素贝叶斯方法分为：1）伯努利模型 2）多项式模型 3）高斯模型等
其中的伯努利模型：
P(c)= 类c下文件总数/整个训练样本的文档总数
P(tk|c)=(类c下包含单词tk的文件数+1)/(类c下文档总数+2) 在这里，m=2, p=1/2。
多项式模型：
先验概率P(c)= 类c下单词总数/整个训练样本的单词总数
类条件概率P(tk|c)=(类c下单词tk在各个文档中出现过的次数之和+1)/(类c下单词总数+|V|)
建立联系！
先验分布为高斯分布的Naive Bayes
6）测试算法
伯努利型朴素贝叶斯分类：
导入库：
import numpy as np
import redef spamTest():
docList = []; classList = []; fullText = []
#遍历25个txt文件
for i in range(1, 26):
#读取每个垃圾邮件，大字符串转换成字符列表。
wordList = textParse(open('email/spam/%d.txt' % i, encoding="ISO-8859-1").read())
docList.append(wordList)#不展开列表
fullText.extend(wordList)#展开列表
#标记垃圾邮件，1表示垃圾邮件
classList.append(1)
#读取每个非垃圾邮件，字符串转换为字符列表
wordList = textParse(open('email/ham/%d.txt' % i, encoding="ISO-8859-1").read())
docList.append(wordList)
fullText.extend(wordList)
#标记每个非垃圾邮件，0表示非垃圾邮件
classList.append(0)
#创建词汇表，不重复
vocabList = createVocabList(docList)
#创建存储训练集的索引值的列表
trainingSet =list(range(50));
#创建存储测试集的索引值的列表
testSet= []
#从50个邮件中，随机挑选出40个作为训练集，10个作为测试集
for i in range(10):
#随机选取索引值
randIndex = int(np.random.uniform(0, len(trainingSet)))
#添加测试集的索引值
testSet.append(trainingSet[randIndex])
#在训练集的列表中删除添加到测试集的索引值
del(list(trainingSet)[randIndex])
#创建训练集矩阵和训练集类别标签向量
trainMat = [];
trainClasses = []
#遍历训练集，目前只有40个训练集
for docIndex in trainingSet:
#将生成的词集模型添加到训练矩阵中
trainMat.append(setOfWords2Vec(vocabList, docList[docIndex]))
#将类别标签添加到训练集的类别标签向量中
trainClasses.append(classList[docIndex])
"""
训练朴素贝叶斯模型
"""
#训练朴素贝叶斯模型
p0V, p1V, pSpam = trainNB(np.array(trainMat), np.array(trainClasses))
#错误分类计数
errorCount = 0
#遍历测试集
for docIndex in testSet:
#测试集的词集模型
wordVector = setOfWords2Vec(vocabList, docList[docIndex])
if classifyNB(np.array(wordVector), p0V, p1V, pSpam) != classList[docIndex]:
errorCount += 1
print("classification error", docList[docIndex])
print('the error rate is: ', float(errorCount)/len(testSet))
#将一个大字符串解析为字符列表
def textParse(bigString):
import re
listOfTokens = re.split(r'\W+', bigString)
return [tok.lower() for tok in listOfTokens if len(tok) > 2] #找出长度大于两个字母的单词
#定义创建不重复的列表函数
"""
createVocabList()函数会创建一个包含在所有文档中出现的不重复词的列表
"""
def createVocabList(dataSet):
#创建一个空集
vocabSet = set([])
for document in dataSet:
#再创建一个空集后，将每篇文档返回的新词集合添加到该集合中，再求两个集合的并集
vocabSet = vocabSet | set(document)
return list(vocabSet)
#定义词集模型函数（set-of-words）
def setOfWords2Vec(vocabList, inputSet):
#函数首先创建一个和词汇表等长的向量，并将其元素都设置为0
returnVec = [0]*len(vocabList)
#接着，遍历文档中的所有单词，如果出现了词汇表中的单词，则将输出的文档向量中的对应值设为1。
for word in inputSet:
if word in vocabList:
returnVec[vocabList.index(word)] = 1
else:
print("the word: %s is not in my Vocabulary!" % word)
return returnVec
#定义词袋模型
def bagOfWords2VecMN(vocabList, inputSet):
returnVec = [0]*len(vocabList)
for word in inputSet:
if word in vocabList:
returnVec[vocabList.index(word)] += 1
return returnVec
#定义朴素贝叶斯分类器训练函数
"""
函数说明:朴素贝叶斯分类器训练函数
trainMatrix--训练文档矩阵，即setOfWords2Vec返回的returnVec构成的矩阵；trainCategory--训练类别标签向量
p1Vect--标记为1的类条件概率数组；p0Vect--标记为0的类条件概率数组；pAbusive是标记为1类的先验概率
"""
def trainNB(trainMatrix, trainCategory):
#计算训练的文档数目
numTrainDocs = len(trainMatrix)
#计算每篇文档的词条数 相当于特征数
numWords = len(trainMatrix[0])
#标记为1类的先验概率
pAbusive = sum(trainCategory)/float(numTrainDocs)
"""
创建numpy数组初始化为1，拉普拉斯平滑。
创建numpy.zeros数组,词条出现数初始化为0。分母初始化为2
"""
p0Num = np.ones(numWords); p1Num = np.ones(numWords)
p0Denom = 2.0; p1Denom = 2.0
#计算类条件概率
for i in range(numTrainDocs):
if trainCategory[i] == 1:
p1Num += trainMatrix[i]#矩阵相加
p1Denom += 1#表示类1文档个数
# p1Denom += sum(trainMatrix[i])#有误
else:
p0Num += trainMatrix[i]
p0Denom += 1#表示类0文档个数
#p0Denom += sum(trainMatrix[i])#有误
#由于大部分因子都非常小，防止数值下溢得不到正确答案。于是加log计算，可以使得答案不会过小。
p1Vect = np.log(p1Num/p1Denom) #change to np.log() 类1 为1 的条件概率
p0Vect = np.log(p0Num/p0Denom) #change to np.log() 类0 为0 的条件概率 和后面的计算有一些联系
return p0Vect, p1Vect, pAbusive
#函数说明:朴素贝叶斯分类器分类函数
#vec2Classify--待分类的词条数组; p1Vec--标记为类1的类条件概率数组; p0Vec--标记为类0的类条件概率数组; pClass1--标记为1类的先验概率
"""
博客
https://blog.csdn.net/qq_27009517/article/details/80044431
https://blog.csdn.net/lming_08/article/details/37542331
"""
def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
"""
1.计算待分类词条数组为1类的概率
"""
#寻找vec2Classify测试数组中，元素为0时对应的索引值
index = np.where(vec2Classify==0)#返回一串索引值，相等为true 否则为false 只返回false索引
#遍历元素为0时的索引值，并从p1Vec--1类的条件概率数组中取出对应索引的数值，并存储成列表的形式（p1Vec0=[]）
p1Vec0=[]
for i in index:#index为tuple 取i=0 的tuple 只执行一次
for m in i:
p1Vec0.append(p1Vec[m])
#所有P(vec2Classify=0|1)组成的列表
x0=np.ones(len(p1Vec0))-p1Vec0##？和训练过程得到的p1Vec有关，p1Vec它表示类1下为1的条件概率
#寻找vec2Classify测试数组中，元素为1时对应的索引值
index1= np.where(vec2Classify==1)
#遍历元素为1时的索引值，并从p1Vec--1类的条件概率数组中取出对应索引的数值，并存储成列表的形式（p1Vec1=[]）
p1Vec1=[]
for i in index1:
for m in i:
p1Vec1.append(p1Vec[m])
#所有P(vec2Classify=1|1)组成的列表
x1=p1Vec1
##对应元素相乘。logA * B = logA + logB，所以这里加上log(pClass1)
p1 = sum(x0)+sum(x1) + np.log(pClass1)
"""
2.计算待分类词条数组为0类的概率
"""
#寻找vec2Classify测试数组中，元素为0时对应的索引值
index2 = np.where(vec2Classify==0)
#遍历元素为0时的索引值，并从p0Vec--0类的条件概率数组中取出对应索引的数值，并存储成列表的形式（p0Vec0=[]）
p0Vec0=[]
for i in index2:
for m in i:
p0Vec0.append(p0Vec[m])
#所有P(vec2Classify=0|0)组成的列表
w0=np.ones(len(p0Vec0))-p0Vec0
#寻找vec2Classify测试数组中，元素为1时对应的索引值
index3= np.where(vec2Classify==1)
#遍历元素为1时的索引值，并从p0Vec--0类的条件概率数组中取出对应索引的数值，并存储成列表的形式（p0Vec1=[]）
p0Vec1=[]
for i in index3:
for m in i:
p0Vec1.append(p0Vec[m])
#所有P(vec2Classify=1|0)组成的列表
w1=p0Vec1
##对应元素相乘。logA * B = logA + logB，所以这里加上log(pClass1)
p0 = sum(w0)+sum(w1) + np.log(1.0 - pClass1)
if p1 > p0:
return 1
else:
return 0详细见Github：https://github.com/codehgq/ML-note/tree/master/email%20Classify
欢迎Star ！关注
二、新闻分类：
1）数据集来源，加载并按索引切分（随机打乱数据，先训练样本和类别打包，再打乱，在解压）
2）中文分词
3）不重复的词频统计，并按照词频次数倒序排列 获得所有不重复的词列表
4）剔除无关的词后的特征列表（去掉停用词、词的长度限制，数字限制）得feature_words
5）利用词列表将训练集文档转换为每条条的词向量
6）训练
参考博主：http://blog.csdn.net/c406495762 （写的不错）的文章解读。
以下为代码转载部分：可能稍做了处理以符合自己的学习。（注意代码为Tab缩进方式）
# -*- coding: UTF-8 -*-
from sklearn.naive_bayes import MultinomialNB
import matplotlib.pyplot as plt
import os
import random
import jieba
"""
函数说明:中文文本处理
Parameters:
folder_path - 文本存放的路径
test_size - 测试集占比，默认占所有数据集的百分之20
Returns:
all_words_list - 按词频降序排序的训练集列表
train_data_list - 训练集列表
test_data_list - 测试集列表
train_class_list - 训练集标签列表
test_class_list - 测试集标签列表
Author:
Jack Cui
Blog:
http://blog.csdn.net/c406495762
Modify:
2017-08-22
"""
def TextProcessing(folder_path, test_size = 0.2):
folder_list = os.listdir(folder_path) #查看folder_path下的文件
data_list = [] #数据集数据
class_list = [] #数据集类别
#遍历每个子文件夹
for folder in folder_list:
new_folder_path = os.path.join(folder_path, folder) #根据子文件夹，生成新的路径
files = os.listdir(new_folder_path) #存放子文件夹下的txt文件的列表
j = 1
#遍历每个txt文件
for file in files:
if j > 100: #每类txt样本数最多100个
break
with open(os.path.join(new_folder_path, file), 'r', encoding = 'utf-8') as f: #打开txt文件
raw = f.read()
word_cut = jieba.cut(raw, cut_all = False) #精简模式，返回一个可迭代的generator
word_list = list(word_cut) #generator转换为list
data_list.append(word_list) #添加数据集数据# 不展开
class_list.append(folder) #添加数据集类别
j += 1
print(data_list)
print(class_list)
data_class_list = list(zip(data_list, class_list)) #zip压缩合并，将数据与标签对应压缩 打包成元组 利用 * 号操作符，可以将元组解压为列表
#https://www.runoob.com/python/python-func-zip.html
random.shuffle(data_class_list) #将data_class_list乱序
index = int(len(data_class_list) * test_size) + 1 #训练集和测试集切分的索引值
train_list = data_class_list[index:] #训练集
test_list = data_class_list[:index] #测试集
train_data_list, train_class_list = zip(*train_list) #训练集解压缩
test_data_list, test_class_list = zip(*test_list) #测试集解压缩
all_words_dict = {} #统计训练集词频
for word_list in train_data_list:
for word in word_list:#不重复的统计词频
if word in all_words_dict.keys():
all_words_dict[word] += 1
else:
all_words_dict[word] = 1
#根据键的值倒序排序
all_words_tuple_list = sorted(all_words_dict.items(), key = lambda f:f[1], reverse = True)#True 降序 False 升序
all_words_list, all_words_nums = zip(*all_words_tuple_list) #解压缩
all_words_list = list(all_words_list) #转换成列表
return all_words_list, train_data_list, test_data_list, train_class_list, test_class_list
#文本预处理
folder_path = './SogouC/Sample' #训练集存放地址
TextProcessing(folder_path)
"""
函数说明:读取文件里的内容，并去重
Parameters:
words_file - 文件路径
Returns:
words_set - 读取的内容的set集合
Author:
Jack Cui
Blog:
http://blog.csdn.net/c406495762
Modify:
2017-08-22
"""
def MakeWordsSet(words_file):
words_set = set() #创建set集合
with open(words_file, 'r', encoding = 'utf-8') as f: #打开文件
for line in f.readlines(): #一行一行读取
word = line.strip() #去回车
if len(word) > 0: #有文本，则添加到words_set中
words_set.add(word)
return words_set #返回处理结果
"""
函数说明:根据feature_words将文本向量化
Parameters:
train_data_list - 训练集tuple
test_data_list - 测试集
feature_words - 特征集
Returns:
train_feature_list - 训练集向量化列表
test_feature_list - 测试集向量化列表
Author:
Jack Cui
Blog:
http://blog.csdn.net/c406495762
Modify:
2017-08-22
"""
def TextFeatures(train_data_list, test_data_list, feature_words):
def text_features(text, feature_words): #出现在特征集中，则置1
text_words = set(text)
features = [1 if word in text_words else 0 for word in feature_words]
return features
train_feature_list = [text_features(text, feature_words) for text in train_data_list]
test_feature_list = [text_features(text, feature_words) for text in test_data_list]
return train_feature_list, test_feature_list #返回结果
"""
函数说明:文本特征选取
Parameters:
all_words_list - 训练集所有文本列表
deleteN - 删除词频最高的deleteN个词
stopwords_set - 指定的结束语
Returns:
feature_words - 特征集
Author:
Jack Cui
Blog:
http://blog.csdn.net/c406495762
Modify:
2017-08-22
"""
def words_dict(all_words_list, deleteN, stopwords_set = set()):
feature_words = [] #特征列表
n = 1
for t in range(deleteN, len(all_words_list), 1):
if n > 1000: #feature_words的维度为1000
break
#如果这个词不是数字，并且不是指定的结束语，并且单词长度大于1小于5，那么这个词就可以作为特征词
if not all_words_list[t].isdigit() and all_words_list[t] not in stopwords_set and 1 < len(all_words_list[t]) < 5:
feature_words.append(all_words_list[t])
n += 1
return feature_words
"""
函数说明:新闻分类器
Parameters:
train_feature_list - 训练集向量化的特征文本
test_feature_list - 测试集向量化的特征文本
train_class_list - 训练集分类标签
test_class_list - 测试集分类标签
Returns:
test_accuracy - 分类器精度
Author:
Jack Cui
Blog:
http://blog.csdn.net/c406495762
Modify:
2017-08-22
"""
def TextClassifier(train_feature_list, test_feature_list, train_class_list, test_class_list):
classifier = MultinomialNB().fit(train_feature_list, train_class_list)
test_accuracy = classifier.score(test_feature_list, test_class_list)
return test_accuracy
if __name__ == '__main__':
#文本预处理
folder_path = './SogouC/Sample' #训练集存放地址
all_words_list, train_data_list, test_data_list, train_class_list, test_class_list = TextProcessing(folder_path, test_size=0.2)
# 生成stopwords_set 目的是去除一些数字 一些特点的词语
stopwords_file = './stopwords_cn.txt'
stopwords_set = MakeWordsSet(stopwords_file)
test_accuracy_list = []
deleteNs = range(0, 1000, 20) #0 20 40 60 ... 980
for deleteN in deleteNs:
feature_words = words_dict(all_words_list, deleteN, stopwords_set)#词向量列表
train_feature_list, test_feature_list = TextFeatures(train_data_list, test_data_list, feature_words)
test_accuracy = TextClassifier(train_feature_list, test_feature_list, train_class_list, test_class_list)
test_accuracy_list.append(test_accuracy)
# ave = lambda c: sum(c) / len(c)
# print(ave(test_accuracy_list))
plt.figure()
plt.plot(deleteNs, test_accuracy_list)
plt.title('Relationship of deleteNs and test_accuracy')
plt.xlabel('deleteNs')
plt.ylabel('test_accuracy')
plt.show()三、个人广告获取区域倾向
加载RSS源
下载解析RSS源的包：https://github.com/kurtmckee/feedparser（Universal Feed Parser是Python中最常用的RSS程序库
）
from numpy import *
import numpy as np
import bayes as ba
#从RSS源获取文档数据 计算分类的错误率
testRSS()1）获取RSS源
def testRSS():
import feedparser
ny=feedparser.parse('http://www.nasa.gov/rss/dyn/image_of_the_day.rss')#NASA
sf=feedparser.parse('http://sports.yahoo.com/nba/teams/hou/rss.xml')#Yahoo
vocabList,pSF,pNY = localWords(ny,sf)2）根据RSS源进行文档的解析---转换为剔除停用后的不重复词列表--转换为词向量---划分数据集---训练获得先验概率、条件概率和词列表 --测试计算分类错误率
"""
函数说明:根据RSS源进行文档的解析---转换为剔除停用后的不重复词列表--转换为词向量---划分数据集---训练获得先验概率、条件概率和词列表 --测试计算分类错误率
Parameters:
feed1 - RSS源1
feed0 - RSS源2
Returns:
vocabList -不重复的词列表(去掉停用词)
p0V - 类0的条件概率
p1V - 类1的条件概率
Author:
heda3
Blog:
https://blog.csdn.net/heda3
Modify:
2019-09-30
"""
def localWords(feed1,feed0):
import feedparser
#引入RSS源，并提取相应的词汇-转换为词列表
docList=[]; classList = []; fullText =[]
print('feed1 entries length: ', len(feed1['entries']), '\nfeed0 entries length: ', len(feed0['entries']))
minLen = min(len(feed1['entries']),len(feed0['entries']))
print('\nmin Length: ', minLen)
for i in range(minLen):
wordList = textParse(feed1['entries'][i]['summary'])#英文分词
print('\nfeed1\'s entries[',i,']\'s summary - ','parse text:\n',wordList)
docList.append(wordList)
fullText.extend(wordList)
classList.append(1) #NY is class 1
wordList = textParse(feed0['entries'][i]['summary'])
print('\nfeed0\'s entries[',i,']\'s summary - ','parse text:\n',wordList)
docList.append(wordList)
fullText.extend(wordList)#展开
classList.append(0)
#创建不重复词的列表
vocabList = createVocabList(docList)#create vocabulary
print('\nVocabList is ',vocabList)
#调用停词列表，移除不重复词列表中包含停词列表中的元素
print('\nRemove Stop Word:')
stopWordList = stopWords()
for stopWord in stopWordList:
if stopWord in vocabList:
vocabList.remove(stopWord)#去掉停止词后的词列表
print('Removed: ',stopWord)
#计算最高频次的词--从不重复的词列表中删除掉高频词 这个和前面的停用词表的重复了
#vocabList:不重复的词向量 fullText：所有的词展开
top30Words = ba.calcMostFreq(vocabList,fullText) #remove top 30 words
print('\nTop 30 words: ', top30Words)
for pairW in top30Words:
if pairW[0] in vocabList:
vocabList.remove(pairW[0])
print('\nRemoved: ',pairW[0])
#训练集和测试集划分 并将输入词列表转换为词向量
trainingSet =list(range(2*minLen));#在python3中range返回的是一个range对象，故转换为列表形式
testSet=[] #create test set
print('\n\nBegin to create a test set: \ntrainingSet:',trainingSet,'\ntestSet',testSet)
for i in range(5):
randIndex = int(random.uniform(0,len(trainingSet)))#随机选取在0-n之间的实数
#从trainingSet中随机找出索引值，并将它放置在测试集里，同时删除测试集的值
testSet.append(trainingSet[randIndex])
del(trainingSet[randIndex])
print('random select 5 sets as the testSet:\ntrainingSet:',trainingSet,'\ntestSet',testSet)
trainMat=[]; trainClasses = []
for docIndex in trainingSet:#train the classifier (get probs) trainNB0
#词列表转换为词向量
trainMat.append(bagOfWords2VecMN(vocabList, docList[docIndex]))
trainClasses.append(classList[docIndex])
print('\ntrainMat length:',len(trainMat))
print('\ntrainClasses',trainClasses)
print('\n\ntrainNB0:')
#模型训练
p0V,p1V,pSpam = trainNB0(array(trainMat),array(trainClasses))
#print '\np0V:',p0V,'\np1V',p1V,'\npSpam',pSpam
##返回 条件概率p0V p1V，以及标记为1类的先验概率
#模型测试
errorCount = 0
for docIndex in testSet: #classify the remaining items
#词列表转换为词向量
wordVector = bagOfWords2VecMN(vocabList, docList[docIndex])
classifiedClass = classifyNB(array(wordVector),p0V,p1V,pSpam)
originalClass = classList[docIndex]
result = classifiedClass != originalClass
if result:
errorCount += 1
print('\n',docList[docIndex],'\nis classified as: ',classifiedClass,', while the original class is: ',originalClass,'. --',not result)
print('\nthe error rate is: ',float(errorCount)/len(testSet))
return vocabList,p0V,p1Vdef createVocabList(dataSet):
vocabSet = set([]) #create empty set
for document in dataSet:
vocabSet = vocabSet | set(document) #union of the two sets
return list(vocabSet)
def bagOfWords2Vec(vocabList, inputSet):
returnVec = [0]*len(vocabList)
for word in inputSet:
if word in vocabList:
returnVec[vocabList.index(word)] += 1
else: print("the word: %s is not in my Vocabulary!" % word)
return returnVec
"""
函数说明:词袋模型，依据输入文档是否在词列表中，相应的值累加次数
Parameters:
vocabList - 所有的词列表（所有文档的并集）
inputSet - 输入文档（词列表）
Returns:
returnVec - 输入文档对应的词向量（词频）
Author:
heda3
Blog:
https://blog.csdn.net/heda3
Modify:
2019-10-01
"""
def bagOfWords2VecMN(vocabList, inputSet):
returnVec = [0]*len(vocabList)
for word in inputSet:
if word in vocabList:
returnVec[vocabList.index(word)] += 1
return returnVec训练函数：
#定义朴素贝叶斯分类器训练函数
"""
函数说明:朴素贝叶斯分类器训练函数
trainMatrix--训练文档矩阵，即setOfWords2Vec返回的returnVec构成的矩阵；trainCategory--训练类别标签向量
p1Vect--标记为1的类条件概率数组；p0Vect--标记为0的类条件概率数组；pAbusive是标记为1类的先验概率
"""
def trainNB(trainMatrix, trainCategory):
#计算训练的文档数目
numTrainDocs = len(trainMatrix)
#计算每篇文档的词条数 相当于特征数
numWords = len(trainMatrix[0])
#标记为1类的先验概率
pAbusive = sum(trainCategory)/float(numTrainDocs)
"""
创建numpy数组初始化为1，拉普拉斯平滑。
创建numpy.zeros数组,词条出现数初始化为0。分母初始化为2
"""
p0Num = np.ones(numWords); p1Num = np.ones(numWords)
p0Denom = 2.0; p1Denom = 2.0
#计算类条件概率
for i in range(numTrainDocs):
if trainCategory[i] == 1:
p1Num += trainMatrix[i]#矩阵相加
p1Denom += 1#表示类1文档个数
# p1Denom += sum(trainMatrix[i])#有误
else:
p0Num += trainMatrix[i]
p0Denom += 1#表示类0文档个数
#p0Denom += sum(trainMatrix[i])#有误
#由于大部分因子都非常小，防止数值下溢得不到正确答案。于是加log计算，可以使得答案不会过小。
p1Vect = np.log(p1Num/p1Denom) #change to np.log() 类1 为1 的条件概率
p0Vect = np.log(p0Num/p0Denom) #change to np.log() 类0 为0 的条件概率 和后面的计算有一些联系
return p0Vect, p1Vect, pAbusive 测试函数：
"""
函数说明:朴素贝叶斯分类器预测函数
Parameters:
vec2Classify - 待分类词向量
p0Vec - 类0的条件概率
p1Vec - 类1的条件概率
pClass1 - 先验概率）
Returns:
returnVec - 输入文档对应的词向量（词频）
Author:
heda3
""" #有误
# =============================================================================
# def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
# p1 = sum(vec2Classify * p1Vec) + log(pClass1) #element-wise mult
# p0 = sum(vec2Classify * p0Vec) + log(1.0 - pClass1)
# if p1 > p0:
# return 1
# else:
# return 0
# =============================================================================
def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
"""
1.计算待分类词条数组为1类的概率
"""
#寻找vec2Classify测试数组中，元素为0时对应的索引值
index = np.where(vec2Classify==0)#返回一串索引值，相等为true 否则为false 只返回false索引
#遍历元素为0时的索引值，并从p1Vec--1类的条件概率数组中取出对应索引的数值，并存储成列表的形式（p1Vec0=[]）
p1Vec0=[]
for i in index:#index为tuple 取i=0 的tuple 只执行一次
for m in i:
p1Vec0.append(p1Vec[m])
#所有P(vec2Classify=0|1)组成的列表
x0=np.ones(len(p1Vec0))-p1Vec0##？和训练过程得到的p1Vec有关，p1Vec它表示类1下为1的条件概率
#寻找vec2Classify测试数组中，元素为1时对应的索引值
index1= np.where(vec2Classify==1)
#遍历元素为1时的索引值，并从p1Vec--1类的条件概率数组中取出对应索引的数值，并存储成列表的形式（p1Vec1=[]）
p1Vec1=[]
for i in index1:
for m in i:
p1Vec1.append(p1Vec[m])
#所有P(vec2Classify=1|1)组成的列表
x1=p1Vec1
##对应元素相乘。logA * B = logA + logB，所以这里加上log(pClass1)
p1 = sum(x0)+sum(x1) + np.log(pClass1)
"""
2.计算待分类词条数组为0类的概率
"""
#寻找vec2Classify测试数组中，元素为0时对应的索引值
index2 = np.where(vec2Classify==0)
#遍历元素为0时的索引值，并从p0Vec--0类的条件概率数组中取出对应索引的数值，并存储成列表的形式（p0Vec0=[]）
p0Vec0=[]
for i in index2:
for m in i:
p0Vec0.append(p0Vec[m])
#所有P(vec2Classify=0|0)组成的列表
w0=np.ones(len(p0Vec0))-p0Vec0
#寻找vec2Classify测试数组中，元素为1时对应的索引值
index3= np.where(vec2Classify==1)
#遍历元素为1时的索引值，并从p0Vec--0类的条件概率数组中取出对应索引的数值，并存储成列表的形式（p0Vec1=[]）
p0Vec1=[]
for i in index3:
for m in i:
p0Vec1.append(p0Vec[m])
#所有P(vec2Classify=1|0)组成的列表
w1=p0Vec1
##对应元素相乘。logA * B = logA + logB，所以这里加上log(pClass1)
p0 = sum(w0)+sum(w1) + np.log(1.0 - pClass1)
if p1 > p0:
return 1
else:
return 0超过某个阈值的区域词分布：
def getTopWords(ny,sf):
import operator
#获取训练数据的条件概率 和精选的词列表
vocabList,p0V,p1V=localWords(ny,sf)
topNY=[]; topSF=[]
#返回大于某个阈值（注意概率是取对数后的）的词
for i in range(len(p0V)):
if p0V[i] > -6.0 : topSF.append((vocabList[i],p0V[i]))#获得词以及对应的先验概率（类为0，此词出现的概率）
if p1V[i] > -6.0 : topNY.append((vocabList[i],p1V[i]))
#输出类0下先验概率超过某个阈值的词
sortedSF = sorted(topSF, key=lambda pair: pair[1], reverse=True)
print("SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**")
for item in sortedSF:
print(item[0])
#输出类1下先验概率超过某个阈值的词
sortedNY = sorted(topNY, key=lambda pair: pair[1], reverse=True)
print("NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**")
for item in sortedNY:
print(item[0])详情见Github：https://github.com/codehgq/ML-note/tree/master/Regional%20Tendency
欢迎Star！关注
参考资料
【1】机器学习实战
【2】深度之眼
