朴素贝叶斯python代码实现
朴素贝叶斯分类器详解及中文文本舆情分析（附代码实践）
朴素贝叶斯分类器详解及中⽂⽂本舆情分析（附代码实践）本⽂主要讲述朴素贝叶斯分类算法并实现中⽂数据集的舆情分析案例，希望这篇⽂章对⼤家有所帮助，提供些思路。
内容包括：1.朴素贝叶斯数学原理知识2.naive_bayes⽤法及简单案例3.中⽂⽂本数据集预处理4.朴素贝叶斯中⽂⽂本舆情分析本篇⽂章为基础性⽂章，希望对你有所帮助，如果⽂章中存在错误或不⾜之处，还请海涵。
同时，推荐⼤家阅读我以前的⽂章了解基础知识。
▌⼀. 朴素贝叶斯数学原理知识朴素贝叶斯（Naive Bayesian）是基于贝叶斯定理和特征条件独⽴假设的分类⽅法，它通过特征计算分类的概率，选取概率⼤的情况，是基于概率论的⼀种机器学习分类（监督学习）⽅法，被⼴泛应⽤于情感分类领域的分类器。
下⾯简单回顾下概率论知识：1.什么是基于概率论的⽅法？通过概率来衡量事件发⽣的可能性。
概率论和统计学是两个相反的概念，统计学是抽取部分样本统计来估算总体情况，⽽概率论是通过总体情况来估计单个事件或部分事情的发⽣情况。
概率论需要已知数据去预测未知的事件。
例如，我们看到天⽓乌云密布，电闪雷鸣并阵阵狂风，在这样的天⽓特征(F)下，我们推断下⾬的概率⽐不下⾬的概率⼤，也就是p(下⾬)>p(不下⾬)，所以认为待会⼉会下⾬，这个从经验上看对概率进⾏判断。
⽽⽓象局通过多年长期积累的数据，经过计算，今天下⾬的概率p(下⾬)=85%、p(不下⾬)=15%，同样的 p(下⾬)>p(不下⾬)，因此今天的天⽓预报肯定预报下⾬。
这是通过⼀定的⽅法计算概率从⽽对下⾬事件进⾏判断。
2.条件概率若Ω是全集，A、B是其中的事件（⼦集），P表⽰事件发⽣的概率，则条件概率表⽰某个事件发⽣时另⼀个事件发⽣的概率。
假设事件B发⽣后事件A发⽣的概率为：设P(A)>0，则有 P(AB) = P(B|A)P(A) = P(A|B)P(B)。
设A、B、C为事件，且P(AB)>0，则有 P(ABC) = P(A)P(B|A)P(C|AB)。
朴素贝叶斯算法及其代码实现
朴素贝叶斯算法及其代码实现朴素贝叶斯朴素贝叶斯是经典的机器学习算法之⼀，也是为数不多的基于概率论的分类算法。
在机器学习分类算法中，朴素贝叶斯和其他绝多⼤的分类算法都不同，⽐如决策树，KNN,逻辑回归，⽀持向量机等，他们都是判别⽅法，也就是直接学习出特征输出Y和特征X之间的关系，要么是决策函数，要么是条件分布。
但是朴素贝叶斯却是⽣成⽅法，这种算法简单，也易于实现。
1.基本概念朴素贝叶斯：贝叶斯分类是⼀类分类算法的总称，这类算法均以贝叶斯定理为基础，故统称为贝叶斯分类。
⽽朴素贝叶斯分类时贝叶斯分类中最简单，也是最常见的⼀种分类⽅法。
贝叶斯公式：先验概率P(X)：先验概率是指根据以往经验和分析得到的概率。
后验概率P(Y|X)：事情已经发⽣，要求这件事情发⽣的原因是由某个因素引起的可能性的⼤⼩，后验分布P(Y|X)表⽰事件X已经发⽣的前提下，事件Y发⽣的概率，叫做事件X发⽣下事件Y的条件概率。
后验概率P(X|Y)：在已知Y发⽣后X的条件概率，也由于知道Y的取值⽽被称为X的后验概率。
朴素：朴素贝叶斯算法是假设各个特征之间相互独⽴，也是朴素这词的意思，那么贝叶斯公式中的P(X|Y)可写成：朴素贝叶斯公式：2，贝叶斯算法简介 贝叶斯⽅法源域它⽣前为解决⼀个“逆概”问题写的⼀篇⽂章。
其要解决的问题： 正向概率：假设袋⼦⾥⾯有N个⽩球，M个⿊球，你伸⼿进去摸⼀把，摸出⿊球的概率是多⼤ 逆向概率：如果我们事先不知道袋⼦⾥⾯⿊⽩球的⽐例，⽽是闭着眼睛摸出⼀个（或者好⼏个）球，观察这些取出来的球的颜⾊之后，那么我们可以就此对袋⼦⾥⾯的⿊⽩球的⽐例做出什么样的推测。
那么什么是贝叶斯呢？1，现实世界本⾝就是不确定的，⼈类的观察能⼒是有局限性的2，我们⽇常观察到的只是事物表明上的结果，因此我们需要提供⼀个猜测 NaiveBayes算法，⼜称朴素贝叶斯算法。
朴素：特征条件独⽴；贝叶斯：基于贝叶斯定理。
属于监督学习的⽣成模型，实现监督，没有迭代，并有坚实的数学理论（即贝叶斯定理）作为⽀撑。
机器学习：贝叶斯分类器（二）——高斯朴素贝叶斯分类器代码实现
机器学习：贝叶斯分类器（⼆）——⾼斯朴素贝叶斯分类器代码实现⼀⾼斯朴素贝叶斯分类器代码实现⽹上搜索不调⽤sklearn实现的朴素贝叶斯分类器基本很少，即使有也是结合⽂本分类的多项式或伯努利类型，因此⾃⼰写了⼀遍能直接封装的⾼斯类型NB分类器，当然与真正的源码相⽐少了很多属性和⽅法，有兴趣的可以⾃⼰添加。
代码如下（有详细注释）：class NaiveBayes():'''⾼斯朴素贝叶斯分类器'''def __init__(self):self._X_train = Noneself._y_train = Noneself._classes = Noneself._priorlist = Noneself._meanmat = Noneself._varmat = Nonedef fit(self, X_train, y_train):self._X_train = X_trainself._y_train = y_trainself._classes = np.unique(self._y_train) # 得到各个类别priorlist = []meanmat0 = np.array([[0, 0, 0, 0]])varmat0 = np.array([[0, 0, 0, 0]])for i, c in enumerate(self._classes):# 计算每个种类的平均值，⽅差，先验概率X_Index_c = self._X_train[np.where(self._y_train == c)] # 属于某个类别的样本组成的“矩阵”priorlist.append(X_Index_c.shape[0] / self._X_train.shape[0]) # 计算类别的先验概率X_index_c_mean = np.mean(X_Index_c, axis=0, keepdims=True) # 计算该类别下每个特征的均值，结果保持⼆维状态[[3 4 6 2 1]]X_index_c_var = np.var(X_Index_c, axis=0, keepdims=True) # ⽅差meanmat0 = np.append(meanmat0, X_index_c_mean, axis=0) # 各个类别下的特征均值矩阵罗成新的矩阵，每⾏代表⼀个类别。
朴素贝叶斯原理、实例与Python实现
朴素贝叶斯原理、实例与Python实现初步理解⼀下：对于⼀组输⼊，根据这个输⼊，输出有多种可能性，需要计算每⼀种输出的可能性，以可能性最⼤的那个输出作为这个输⼊对应的输出。
那么，如何来解决这个问题呢？贝叶斯给出了另⼀个思路。
根据历史记录来进⾏判断。
思路是这样的：1、根据贝叶斯公式：P（输出|输⼊）=P（输⼊|输出）*P（输出）/P（输⼊）2、P（输⼊）=历史数据中，某个输⼊占所有样本的⽐例；3、P（输出）=历史数据中，某个输出占所有样本的⽐例；4、P（输⼊|输出）=历史数据中，某个输⼊，在某个输出的数量占所有样本的⽐例，例如：30岁，男性，中午吃⾯条，其中【30岁，男性就是输⼊】，【中午吃⾯条】就是输出。
⼀、条件概率的定义与贝叶斯公式⼆、朴素贝叶斯分类算法朴素贝叶斯是⼀种有监督的分类算法，可以进⾏⼆分类，或者多分类。
⼀个数据集实例如下图所⽰：现在有⼀个新的样本， X = (年龄：<=30, 收⼊：中，是否学⽣：是，信誉：中)，⽬标是利⽤朴素贝叶斯分类来进⾏分类。
假设类别为C(c1=是或 c2=否)，那么我们的⽬标是求出P(c1|X)和P(c2|X)，⽐较谁更⼤，那么就将X分为某个类。
下⾯，公式化朴素贝叶斯的分类过程。
三、实例下⾯，将下⾯这个数据集作为训练集，对新的样本X = (年龄：<=30, 收⼊：中，是否学⽣：是，信誉：中) 作为测试样本，进⾏分类。
我们可以将这个实例中的描述属性和类别属性，与公式对应起来，然后计算。
参考python实现代码#coding:utf-8# 极⼤似然估计朴素贝叶斯算法import pandas as pdimport numpy as npclass NaiveBayes(object):def getTrainSet(self):dataSet = pd.read_csv('F://aaa.csv')dataSetNP = np.array(dataSet) #将数据由dataframe类型转换为数组类型trainData = dataSetNP[:,0:dataSetNP.shape[1]-1] #训练数据x1,x2labels = dataSetNP[:,dataSetNP.shape[1]-1] #训练数据所对应的所属类型Yreturn trainData, labelsdef classify(self, trainData, labels, features):#求labels中每个label的先验概率labels = list(labels) #转换为list类型labelset = set(labels)P_y = {} #存⼊label的概率for label in labelset:P_y[label] = labels.count(label)/float(len(labels)) # p = count(y) / count(Y)print(label,P_y[label])#求label与feature同时发⽣的概率P_xy = {}for y in P_y.keys():y_index = [i for i, label in enumerate(labels) if label == y] # labels中出现y值的所有数值的下标索引for j in range(len(features)): # features[0] 在trainData[:,0]中出现的值的所有下标索引x_index = [i for i, feature in enumerate(trainData[:,j]) if feature == features[j]]xy_count = len(set(x_index) & set(y_index)) # set(x_index)&set(y_index)列出两个表相同的元素pkey = str(features[j]) + '*' + str(y)P_xy[pkey] = xy_count / float(len(labels))print(pkey,P_xy[pkey])#求条件概率P = {}for y in P_y.keys():for x in features:pkey = str(x) + '|' + str(y)P[pkey] = P_xy[str(x)+'*'+str(y)] / float(P_y[y]) #P[X1/Y] = P[X1Y]/P[Y]print(pkey,P[pkey])#求[2,'S']所属类别F = {} #[2,'S']属于各个类别的概率for y in P_y:F[y] = P_y[y]for x in features:F[y] = F[y]*P[str(x)+'|'+str(y)] #P[y/X] = P[X/y]*P[y]/P[X]，分母相等，⽐较分⼦即可，所以有F=P[X/y]*P[y]=P[x1/Y]*P[x2/Y]*P[y] print(str(x),str(y),F[y])features_label = max(F, key=F.get) #概率最⼤值对应的类别return features_labelif__name__ == '__main__':nb = NaiveBayes()# 训练数据trainData, labels = nb.getTrainSet()# x1,x2features = [8]# 该特征应属于哪⼀类result = nb.classify(trainData, labels, features)print(features,'属于',result)#coding:utf-8#朴素贝叶斯算法贝叶斯估计，λ=1 K=2， S=3；λ=1 拉普拉斯平滑import pandas as pdimport numpy as npclass NavieBayesB(object):def__init__(self):self.A = 1 # 即λ=1self.K = 2self.S = 3def getTrainSet(self):trainSet = pd.read_csv('F://aaa.csv')trainSetNP = np.array(trainSet) #由dataframe类型转换为数组类型trainData = trainSetNP[:,0:trainSetNP.shape[1]-1] #训练数据x1,x2labels = trainSetNP[:,trainSetNP.shape[1]-1] #训练数据所对应的所属类型Yreturn trainData, labelsdef classify(self, trainData, labels, features):labels = list(labels) #转换为list类型#求先验概率P_y = {}for label in labels:P_y[label] = (labels.count(label) + self.A) / float(len(labels) + self.K*self.A)#求条件概率P = {}for y in P_y.keys():y_index = [i for i, label in enumerate(labels) if label == y] # y在labels中的所有下标y_count = labels.count(y) # y在labels中出现的次数for j in range(len(features)):pkey = str(features[j]) + '|' + str(y)x_index = [i for i, x in enumerate(trainData[:,j]) if x == features[j]] # x在trainData[:,j]中的所有下标 xy_count = len(set(x_index) & set(y_index)) #x y同时出现的次数P[pkey] = (xy_count + self.A) / float(y_count + self.S*self.A) #条件概率#features所属类F = {}for y in P_y.keys():F[y] = P_y[y]for x in features:F[y] = F[y] * P[str(x)+'|'+str(y)]features_y = max(F, key=F.get) #概率最⼤值对应的类别return features_yif__name__ == '__main__':nb = NavieBayesB()# 训练数据trainData, labels = nb.getTrainSet()# x1,x2features = [10]# 该特征应属于哪⼀类result = nb.classify(trainData, labels, features)print(features,'属于',result)参考链接：https:///ten_sory/article/details/81237169。
朴素贝叶斯文本分类代码（详解）
朴素贝叶斯⽂本分类代码（详解）1from numpy import zeros,array2from math import log34def loadDataSet():5#词条切分后的⽂档集合，列表每⼀⾏代表⼀个email6 postingList=[['your','mobile','number','is','award','bonus','prize'],7 ['new','car','and','house','for','my','parents'],8 ['my','dalmation','is','so','cute','I','love','him'],9 ['today','voda','number','prize', 'receive','award'],10 ['get','new','job','in','company','how','to','get','that'],11 ['free','prize','buy','winner','receive','cash']]12#由⼈⼯标注的每篇⽂档的类标签13 classVec=[1,0,0,1,0,1] #1-spam, 0-ham14return postingList,classVec15 postingList,classVec = loadDataSet()161718#统计所有⽂档中出现的词条列表19def createVocabList(dataSet):20 vocabSet=set([])21#遍历⽂档集合中的每⼀篇⽂档22for document in dataSet:23 vocabSet=vocabSet|set(document)24return list(vocabSet)25 vocabSet = createVocabList(postingList)262728#根据词条列表中的词条是否在⽂档中出现(出现1，未出现0)，将⽂档转化为词条向量29def setOfWords2Vec(vocabSet,inputSet):30#新建⼀个长度为vocabSet的列表，并且各维度元素初始化为031 returnVec=[0]*len(vocabSet)32#遍历⽂档中的每⼀个词条33for word in inputSet:34#如果词条在词条列表中出现35if word in vocabSet:36#通过列表获取当前word的索引(下标)37#将词条向量中的对应下标的项由0改为138 returnVec[vocabSet.index(word)]=139else: print('the word: %s is not in my vocabulary! '%'word')40#返回inputet转化后的词条向量41return returnVec4243 trainMatrix = [setOfWords2Vec(vocabSet,inputSet) for inputSet in postingList]444546#训练算法，从词向量计算概率p(w0|ci)...及p(ci)47#@trainMatrix：由每篇⽂档的词条向量组成的⽂档矩阵48#@trainCategory:每篇⽂档的类标签组成的向量49def trainNB0(trainMatrix,trainCategory):50#获取⽂档矩阵中⽂档的数⽬51 numTrainDocs=len(trainMatrix)52#获取词条向量的长度53 numWords=len(trainMatrix[0])54#所有⽂档中属于类1所占的⽐例p(c=1)55 pAbusive=sum(trainCategory)/float(numTrainDocs)56#创建⼀个长度为词条向量等长的列表57 p0Num=zeros(numWords) #ham58 p1Num=zeros(numWords) #spam59 p0Denom=0.060 p1Denom=0.061#遍历每⼀篇⽂档的词条向量62for i in range(numTrainDocs):63#如果该词条向量对应的标签为164if trainCategory[i]==1:65#统计所有类别为1的词条向量中各个词条出现的次数66 p1Num+=trainMatrix[i]67#统计类别为1的词条向量中出现的所有词条的总数68#即统计类1所有⽂档中出现单词的数⽬69 p1Denom+=sum(trainMatrix[i])70else:71#统计所有类别为0的词条向量中各个词条出现的次数72 p0Num+=trainMatrix[i]73#统计类别为0的词条向量中出现的所有词条的总数74#即统计类0所有⽂档中出现单词的数⽬75 p0Denom+=sum(trainMatrix[i])76print(p1Num, p1Denom, p0Num,p0Denom )77#利⽤NumPy数组计算p(wi|c1)78 p1Vect=p1Num/p1Denom #为避免下溢出问题，需要改为log()79#利⽤NumPy数组计算p(wi|c0)80 p0Vect=p0Num/p0Denom #为避免下溢出问题，需要改为log()81return p0Vect,p1Vect,pAbusive8283 p0Vect,p1Vect,pAbusive= trainNB0(trainMatrix,classVec)848586#朴素贝叶斯分类函数87#@vec2Classify:待测试分类的词条向量88#@p0Vec:类别0所有⽂档中各个词条出现的频数p(wi|c0)89#@p0Vec:类别1所有⽂档中各个词条出现的频数p(wi|c1)90#@pClass1:类别为1的⽂档占⽂档总数⽐例91def classifyNB(vec2Classify,p0Vec,p1Vec,pClass1):92#根据朴素贝叶斯分类函数分别计算待分类⽂档属于类1和类0的概率93 p1=sum(vec2Classify*p1Vec)+log(pClass1)94 p0=sum(vec2Classify*p0Vec)+log(1.0-pClass1)95if p1>p0:96return'spam'97else:98return'not spam'99100101102 testEntry=['love','my','job']103 thisDoc=array(setOfWords2Vec(vocabSet,testEntry))104print(testEntry,'classified as:',classifyNB(thisDoc,p0Vect,p1Vect,pAbusive))。
朴素贝叶斯分类器基本代码n折交叉优化
朴素贝叶斯分类器基本代码n折交叉优化⾃⼰也是刚刚⼊门。
没脸把⾃⼰的代码放上去，先⽤别⼈的。
加上⾃⼰的解析，挺全⾯的，希望有⽤。
import reimport pandas as pdimport numpy as npfrom sklearn.metrics import roc_auc_scorefrom sklearn.feature_extraction.text import TfidfVectorizerfrom sklearn.naive_bayes import MultinomialNB as MNB #朴素贝叶斯公式from sklearn.model_selection import cross_val_scoredef proces(review):#把review转成词序列review_text=re.sub("[^a-zA-Z]","",review) #⾮⼤⼩写字母的字符替换成空格#re.sub是正则表达式的函数，实现⽐普通字符串更强⼤的替换功能#print(review_text)words=review_text.lower().split() #全转换为⼩写后，根据空格分割单词#print(words)return wordstrain=pd.read_csv('train.csv',lineterminator='\n') #使⽤pandas的read读取⽂件，以换⾏符号为⽌为⼀段数据'''官⽅⽂件：pandas.read_csv(filepath_or_buffer, sep=', ', delimiter=None, header='infer',names=None, index_col=None, usecols=None, squeeze=False, prefix=None,mangle_dupe_cols=True, dtype=None, engine=None, converters=None,true_values=None, false_values=None, skipinitialspace=False,skiprows=None, nrows=None, na_values=None, keep_default_na=True,na_filter=True, verbose=False, skip_blank_lines=True,parse_dates=False, infer_datetime_format=False, keep_date_col=False,date_parser=None, dayfirst=False, iterator=False, chunksize=None,compression='infer', thousands=None, decimal=b'.', lineterminator=None,quotechar='"', quoting=0, escapechar=None, comment=None, encoding=None,dialect=None, tupleize_cols=None, error_bad_lines=True, warn_bad_lines=True,skipfooter=0, doublequote=True, delim_whitespace=False,low_memory=True, memory_map=False, float_precision=None）https:///sinat_35562946/article/details/81058221这个博客讲的还⾏'''print(train.head(5))x=train['review']#print(x)y=train['label']#print(y)'''x与y分离train中的记录和标签'''class_mapping = {'Negative': 0, 'Positive': 1}y=y.map(class_mapping)#把label中的Negative,Positive转换成0,1标签test=pd.read_csv('test.csv', lineterminator='\n')z=test['review']w=test['label']'''x与y分离test中的记录和标签'''w=w.map(class_mapping)train_data=[]for i in range(len(x)):train_data.append(''.join(proces(x[i]))) #⽤空格将train.data的list⾥的words串联在⼀起passtest_data=[]for i in range(len(z)):test_data.append(''.join(proces(z[i]))) #⽤空格将test_data的list⾥的words串联在⼀起passdata_all=train_data+test_data #所有词合并成⼤表data#print(data_all)#TF-IDF倾向于过滤掉常见的词语，保留重要的词语。
python库中的5种贝叶斯算法
python库中的5种贝叶斯算法Python是一种广泛使用的编程语言，拥有丰富的库和工具包，其中包括了多种贝叶斯算法。
贝叶斯算法是一类基于贝叶斯定理的统计学方法，可以用于分类、聚类、概率估计等任务。
在Python中，我们可以使用以下5种常见的贝叶斯算法来解决不同的问题。
1. 朴素贝叶斯算法（Naive Bayes）朴素贝叶斯算法是一种简单而有效的分类算法，它假设所有特征之间相互独立。
在文本分类、垃圾邮件过滤等任务中得到了广泛应用。
在Python中，我们可以使用scikit-learn库中的`sklearn.naive_bayes`模块来实现朴素贝叶斯算法。
该模块提供了多种朴素贝叶斯分类器的实现，如高斯朴素贝叶斯、多项式朴素贝叶斯和伯努利朴素贝叶斯。
2. 高斯朴素贝叶斯算法（Gaussian Naive Bayes）高斯朴素贝叶斯算法假设特征的概率分布服从高斯分布。
它常用于处理连续型特征的分类问题。
在Python中，我们可以使用scikit-learn库中的`sklearn.naive_bayes.GaussianNB`类来实现高斯朴素贝叶斯算法。
该类提供了`fit`和`predict`等方法，可以用于拟合模型和进行预测。
3. 多项式朴素贝叶斯算法（Multinomial Naive Bayes）多项式朴素贝叶斯算法适用于处理离散型特征的分类问题，如文本分类中的词频统计。
在Python中，我们可以使用scikit-learn库中的`sklearn.naive_bayes.MultinomialNB`类来实现多项式朴素贝叶斯算法。
该类同样提供了`fit`和`predict`等方法，可以用于拟合模型和进行预测。
4. 伯努利朴素贝叶斯算法（Bernoulli Naive Bayes）伯努利朴素贝叶斯算法适用于处理二值型特征的分类问题，如文本分类中的二进制词袋模型。
在Python中，我们可以使用scikit-learn库中的`sklearn.naive_bayes.BernoulliNB`类来实现伯努利朴素贝叶斯算法。
基于朴素贝叶斯的新闻分类算法设计与实现
3. 模型训练
使用提取的特征和对 应的标签训练朴素贝 叶斯分类器。在训练 过程中，我们需要根 据训练数据计算每个 特征的条件概率和类 先验概率
算法设计
4. 模型评估与优化
算法设计
训练完成后，我们使 用测试数据集评估模 型的性能。常见的评 估指标有准确率、召 回率和F1得分。如果 模型的性能不理想， 我们可以调整模型参 数或使用其他优化方 法
Part 2
算法实现
算法实现
在Python中，我们可以使用scikit-learn库实现朴素贝叶斯新闻分类算法。以下是一个简 单的示例代码
-
THANKS !
20XX
基于朴素贝叶斯的新闻 分类算法设计与实现
演讲者：xxx
-
1 算法设计 2 算法实现
基于朴素贝叶斯的新闻分类算法设计与实现
在筛选新闻变得越来越重要
朴素贝叶斯分类器是一种基于贝叶斯定理的简 单概率分类器，具有高效、准确、易于理解等
优点，适用于文本分类任务
Part 1
算法设计
算法设计
1. 数据预处理
首先，我们需要对新闻数据进行预处理。 这包括分词、去除停用词、去除特殊符号 等步骤，以便提取出新闻的主题和内容
算法设计
2. 特征提取
在预处理之后，我们需要从新闻 文本中提取特征。常见的特征包 括词频、TF-IDF等。这些特征可 以反映新闻的主题和内容
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
朴素贝叶斯优点：在数据较少的情况下仍然有效，可以处理多类别问题缺点：对于输入数据的准备方式较为敏感适用数据类型：标称型数据贝叶斯准则：使用朴素贝叶斯进行文档分类朴素贝叶斯的一般过程（1）收集数据：可以使用任何方法。
本文使用RSS源（2）准备数据：需要数值型或者布尔型数据（3）分析数据：有大量特征时，绘制特征作用不大，此时使用直方图效果更好（4）训练算法：计算不同的独立特征的条件概率（5）测试算法：计算错误率（6）使用算法：一个常见的朴素贝叶斯应用是文档分类。
可以在任意的分类场景中使用朴素贝叶斯分类器，不一定非要是文本。
准备数据：从文本中构建词向量摘自机器学习实战。
[['my','dog','has','flea','problems','help','please'], 0['maybe','not','take','him','to','dog','park','stupid'], 1['my','dalmation','is','so','cute','I','love','him'], 0['stop','posting','stupid','worthless','garbage'], 1['mr','licks','ate','my','steak','how','to','stop','him'], 0['quit','buying','worthless','dog','food','stupid']] 1以上是六句话，标记是0句子的表示正常句，标记是1句子的表示为粗口。
我们通过分析每个句子中的每个词，在粗口句或是正常句出现的概率，可以找出那些词是粗口。
在bayes.py文件中添加如下代码：[python]view plaincopy1.# coding=utf-82.3.def loadDataSet():4. postingList = [['my', 'dog', 'has', 'flea', 'problems', 'help', 'please'],5. ['maybe', 'not', 'take', 'him', 'to', 'dog', 'park', 'stupid'],6. ['my', 'dalmation', 'is', 'so', 'cute', 'I', 'love', 'him'],7. ['stop', 'posting', 'stupid', 'worthless', 'garbage'],8. ['mr', 'licks', 'ate', 'my', 'steak', 'how', 'to', 'stop', 'him'],9. ['quit', 'buying', 'worthless', 'dog', 'food', 'stupid']]10. classVec = [0, 1, 0, 1, 0, 1] # 1代表侮辱性文字，0代表正常言论11.return postingList, classVec12.13.def createVocabList(dataSet):14. vocabSet = set([])15.for document in dataSet:16. vocabSet = vocabSet | set(document)17.return list(vocabSet)18.19.def setOfWords2Vec(vocabList, inputSet):20. returnVec = [0] * len(vocabList)21.for word in inputSet:22.if word in vocabList:23. returnVec[vocabList.index(word)] = 124.else:25.print"the word: %s is not in my Vocabulary!" % word26.return returnVec运行结果：训练算法：从词向量计算概率[python]view plaincopy1.# 朴素贝叶斯分类器训练函数2.# trainMatrix: 文档矩阵， trainCategory: 由每篇文档类别标签所构成的向量3.def trainNB0(trainMatrix, trainCategory):4. numTrainDocs = len(trainMatrix)5. numWords = len(trainMatrix[0])6. pAbusive = sum(trainCategory) / float(numTrainDocs)7. p0Num = zeros(numWords);8. p1Num = zeros(numWords);9. p0Denom = 0.0;10. p1Denom = 0.0;11.for i in range(numTrainDocs):12.if trainCategory[i] == 1:13. p1Num += trainMatrix[i]14. p1Denom += sum(trainMatrix[i])15.else:16. p0Num += trainMatrix[i]17. p0Denom += sum(trainMatrix[i])18. p1Vect = p1Num / p1Denom19. p0Vect = p0Num / p1Denom20.return p0Vect, p1Vect, pAbusive运行结果：测试算法：根据现实情况修改分类器上一节中的trainNB0函数中修改几处：p0Num = ones(numWords);p1Num = ones(numWords);p0Denom = 2.0;p1Denom = 2.0;p1Vect = log(p1Num / p1Denom)p0Vect = log(p0Num / p1Denom)[python]view plaincopy1.# 朴素贝叶斯分类器训练函数2.# trainMatrix: 文档矩阵， trainCategory: 由每篇文档类别标签所构成的向量3.def trainNB0(trainMatrix, trainCategory):4. numTrainDocs = len(trainMatrix)5. numWords = len(trainMatrix[0])6. pAbusive = sum(trainCategory) / float(numTrainDocs)7. p0Num = ones(numWords);8. p1Num = ones(numWords);9. p0Denom = 2.0;10. p1Denom = 2.0;11.for i in range(numTrainDocs):12.if trainCategory[i] == 1:13. p1Num += trainMatrix[i]14. p1Denom += sum(trainMatrix[i])15.else:16. p0Num += trainMatrix[i]17. p0Denom += sum(trainMatrix[i])18. p1Vect = log(p1Num / p1Denom)19. p0Vect = log(p0Num / p1Denom)20.return p0Vect, p1Vect, pAbusive21.22.# 朴素贝叶斯分类函数23.def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):24. p1 = sum(vec2Classify * p1Vec) + log(pClass1)25. p0 = sum(vec2Classify * p0Vec) + log(1.0 - pClass1)26.if p1 > p0:27.return 128.else:29.return 030.31.def testingNB():32. listOPosts, listClasses = loadDataSet()33. myVocabList = createVocabList(listOPosts)34. trainMat = []35.for postinDoc in listOPosts:36. trainMat.append(setOfWords2Vec(myVocabList, postinDoc))37.38. p0V, p1V, pAb = trainNB0(array(trainMat), array(listClasses))39.40. testEntry = ['love', 'my', 'dalmation']41. thisDoc = array(setOfWords2Vec(myVocabList, testEntry))42.print testEntry, 'classified as: ', classifyNB(thisDoc, p0V, p1V, pAb)43.44. testEntry = ['stupid', 'garbage']45. thisDoc = array(setOfWords2Vec(myVocabList, testEntry))46.print testEntry, 'classified as: ', classifyNB(thisDoc, p0V, p1V, pAb) 运行结果：准备数据：文档词袋模型词集模型（set-of-words model）：每个词是否出现，每个词只能出现一次词袋模型（bag-of-words model）：一个词可以出现不止一次[python]view plaincopy1.# 朴素贝叶斯词袋模型2.def bagOfWords2VecMN(vocabList, inputSet):3. returnVec = [0] * len(vocabList)4.for word in inputSet:5.if word in vocabList:6. returnVec[vocabList.index(word)] += 17.return returnVec示例：使用朴素贝叶斯过滤垃圾邮件（1）收集数据：提供文本文件（2）准备数据：将文本文件解析成词条向量（3）分析数据：检查词条确保解析的正确性（4）训练算法：使用我们之前建立的trainNB0()函数（5）测试算法：使用classifyNB()，并且构建一个新的测试函数来计算文档集的错误率（6）使用算法：构建一个完整的程序对一组文档进行分类，将错分的文档输出到屏幕上准备数据：切分文本使用正则表达式切分句子测试算法：使用朴素贝叶斯进行交叉验证[python]view plaincopy1.# 该函数接受一个大写字符的字串，将其解析为字符串列表2.# 该函数去掉少于两个字符的字符串，并将所有字符串转换为小写3.def textParse(bigString):4.import re5. listOfTokens = re.split(r'\W*', bigString)6.return [tok.lower() for tok in listOfTokens if len(tok) > 2]7.8.# 完整的垃圾邮件测试函数9.def spamTest():10. docList = []11. classList = []12. fullText = []13.# 导入并解析文本文件14.for i in range(1, 26):15. wordList = textParse(open('email/spam/%d.txt' % i).read())16. docList.append(wordList)17. fullText.extend(wordList)18. classList.append(1)19.20. wordList = textParse(open('email/ham/%d.txt' % i).read())21. docList.append(wordList)22. fullText.extend(wordList)23. classList.append(0)24.25. vocabList = createVocabList(docList)26. trainingSet = range(50)27. testSet = []28.# 随机构建训练集29.for i in range(10):30. randIndex = int(random.uniform(0, len(trainingSet)))31. testSet.append(trainingSet[randIndex])32.del(trainingSet[randIndex])33.34. trainMat = []35. trainClasses = []36.for docIndex in trainingSet:37. trainMat.append(setOfWords2Vec(vocabList, docList[docIndex]))38. trainClasses.append(classList[docIndex])39.40. p0V, p1V, pSpam = trainNB0(array(trainMat), array(trainClasses))41. errorCount = 042.# 对测试集分类43.for docIndex in testSet:44. wordVector = setOfWords2Vec(vocabList, docList[docIndex])45.if classifyNB(array(wordVector), p0V, p1V, pSpam) != classList[docIndex]:46. errorCount += 147.print"classification error",docList[docIndex]48.print'the error rate is: ', float(errorCount) / len(testSet)运行结果：因为这些电子邮件是随机选择的，所以每次输出的结果可能会不一样。