Python贝叶斯文本分类模型从原理到实现
朴素贝叶斯原理、实例与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。
机器学习之贝叶斯算法原理及实现详解
机器学习之贝叶斯算法原理及实现详解贝叶斯算法是一种基于概率统计的机器学习算法，能够在给定特征和目标变量的情况下，对未知样本进行分类或预测。
它基于贝叶斯定理和条件独立性假设，通过计算后验概率来进行决策。
贝叶斯定理是概率论中的一个重要定理，用于计算在给定其中一事件发生的条件下，另一事件发生的概率。
设A和B是两个事件，P(A)和P(B)分别表示它们独立发生的概率，P(A，B)表示在事件B发生的条件下事件A发生的概率，则贝叶斯定理可以表示为：P(A，B)=P(B，A)*P(A)/P(B)其中，P(B，A)是条件概率，表示在事件A发生的条件下事件B发生的概率。
P(A，B)是后验概率，表示在事件B发生的条件下事件A发生的概率。
P(A)是先验概率，表示事件A在考虑事件B前的概率。
P(B)是归一化常量，用于确保概率总和为1在贝叶斯分类中，我们将训练数据集表示为{(x1, y1), (x2,y2), ..., (xn, yn)}，其中xi是特征向量，yi是对应的目标变量。
目标是根据已知的特征向量x，对新的样本进行分类，即找到一个最优的类别y。
根据贝叶斯定理，我们可以将问题转化为计算后验概率P(y，x)，即在给定特征x的情况下，类别y发生的概率。
为了实现这一点，我们需要对类别y进行建模。
贝叶斯算法的核心思想是条件独立性假设，即假设每个特征在给定类别情况下是独立的。
基于这一假设，我们可以将后验概率P(y，x)表示为每个特征的条件概率的乘积。
P(y，x) ∝ P(y) * P(x，y) = P(y) * P(x1，y) * P(x2，y) * ... * P(xn，y)其中，P(y)是先验概率，表示在没有任何特征信息的情况下，类别y发生的概率。
P(xi，y)是条件概率，表示在类别y的条件下，特征xi发生的概率。
实现贝叶斯算法的关键是构建条件概率模型，即统计训练数据集中每个特征在不同类别下的概率分布。
对于离散特征，可以通过计算每个特征值的频率来估计概率。
Bayes分类器原理分析以及实现
Bayes分类器原理分析以及实现编程环境：python 3.7jupyter notebook⽂章说明：这⾥只是贝叶斯分类器的原理进⾏分析以及实现，重点关注其中的数学原理和逻辑步骤，在测试等阶段直接调⽤了python机器学习的库。
基本步骤：输⼊类数,特征数,待分样本数输⼊训练样本数和训练样本集计算先验概率计算各类条件概率密度计算各类的后验概率若按最⼩错误率原则分类,则根据后验概率判定若按最⼩风险原则分类,则计算各样本属于各类时的风险并判定# 导⼊基本库import pandas as pdimport numpy as npimport mathimport matplotlib.pyplot as plt%matplotlib inline%config InlineBackend.figure_format = 'png'数据预处理colume_names = ['','gender','height','weight','size']df= pd.read_excel('data/gender.xlsx',index_col=0,names=colume_names)df.head(5)gender height weight size1⼥163.062.036.02⼥158.042.036.03男168.067.042.04男180.067.041.05男180.075.046.0df.shape(571, 4)这⾥可以看到数据有4个维度，分别为性别、⾝⾼、体重、鞋码，共有571条记录。
下⾯做⼀些简单的处理：# 性别数据转换df.replace('男',1,inplace=True)df.replace('⼥',2,inplace=True)df.head(5)gender height weight size12163.062.036.022158.042.036.031168.067.042.041180.067.041.0gender height weight size 51180.075.046.0# 男⽣⼥⽣数据分开male_df = df.loc[df['gender']==1]female_df = df.loc[df['gender']==2]female_df.head(5)gender height weight size 12163.062.036.022158.042.036.092160.045.036.0102163.048.037.0112161.045.036.01、单个特征——⾝⾼为了更加深⼊得理解贝叶斯分类器原理，我们从简单的⼀维特征开始。
bayes分类的算法代码
bayes分类的算法代码Bayes分类算法是一种常用的机器学习算法，它基于贝叶斯定理，通过计算样本的条件概率来进行分类。
本文将介绍Bayes分类算法的基本原理和实现代码。
一、Bayes分类算法原理Bayes分类算法是一种概率模型，它基于贝叶斯定理，通过计算样本的条件概率来进行分类。
其基本原理如下：1. 假设有N个类别，C1、C2、...、CN，每个类别对应的样本集合为D1、D2、...、DN。
2. 对于待分类样本X，根据贝叶斯定理，可以计算出该样本属于每个类别的概率。
即P(Ci|X) = P(X|Ci) * P(Ci) / P(X)，其中P(Ci|X)表示样本X属于类别Ci的概率，P(X|Ci)表示在样本属于类别Ci的条件下，样本X出现的概率，P(Ci)表示类别Ci出现的概率，P(X)表示样本X出现的概率。
3. 根据贝叶斯定理，可以将P(X)看做一个常数，因此只需要比较P(X|Ci) * P(Ci)的大小即可确定样本X的类别。
二、Bayes分类算法实现下面是一个简单的Bayes分类算法的实现代码：```pythonimport numpy as npdef bayes_classify(train_data, train_labels, test_data):# 计算每个类别的先验概率labels = list(set(train_labels))prior_prob = {}for label in labels:prior_prob[label] = np.sum(np.array(train_labels) == label) / len(train_labels)# 计算每个特征在每个类别下的条件概率conditional_prob = {}for label in labels:label_data = train_data[np.array(train_labels) == label]for i in range(len(label_data[0])):feature_values = set(label_data[:, i])for value in feature_values:if (i, value, label) not in conditional_prob:conditional_prob[(i, value, label)] = np.sum(label_data[:, i] == value) / len(label_data)# 对测试样本进行分类test_labels = []for test_sample in test_data:max_prob = -1max_label = ''for label in labels:prob = prior_prob[label]for i in range(len(test_sample)):if (i, test_sample[i], label) in conditional_prob:prob *= conditional_prob[(i, test_sample[i], label)]if prob > max_prob:max_prob = probmax_label = labeltest_labels.append(max_label)return test_labels```三、代码解析上述代码中，我们首先计算了每个类别的先验概率，即P(Ci)，然后计算了每个特征在每个类别下的条件概率，即P(X|Ci)。
使用贝叶斯分类的流程
使用贝叶斯分类的流程1. 简介贝叶斯分类是一种基于贝叶斯定理的机器学习算法，常用于文本分类、垃圾邮件过滤、垃圾短信过滤等领域。
在贝叶斯分类中，我们使用统计方法来计算给定输入数据下某个类别的概率，并选择具有最高概率的类别作为预测结果。
2. 贝叶斯分类的原理贝叶斯分类基于贝叶斯定理，该定理可以表示如下：P(C|X) = (P(X|C) * P(C)) / P(X)其中，P(C|X)是给定输入X的条件下事件C发生的概率；P(X|C)是事件C发生的条件下X的概率；P(C)是事件C的先验概率；P(X)是输入X的先验概率。
贝叶斯分类的核心思想就是通过计算输入数据在各个类别下的条件概率，然后选择具有最高概率的类别作为预测结果。
3. 贝叶斯分类的流程贝叶斯分类的流程主要包括以下几个步骤：3.1 收集训练数据首先，我们需要收集一定量的训练数据。
训练数据应包含已知类别的样本，以及每个样本对应的特征数据。
3.2 数据预处理在进行贝叶斯分类之前，我们通常需要对数据进行预处理。
预处理包括去除噪声、填充缺失值、标准化等操作，以提高分类器的性能。
3.3 计算先验概率在贝叶斯分类中，先验概率指的是每个类别的概率。
在训练数据中，我们可以通过统计各个类别的样本数量，然后将其除以总样本数量得到先验概率。
3.4 计算条件概率在贝叶斯分类中，条件概率指的是给定输入数据下各个类别发生的概率。
对于离散特征，我们可以通过统计每个特征值在每个类别下的出现次数，然后除以该类别下的总样本数得到条件概率。
对于连续特征，我们通常使用概率密度函数（PDF）来估计其条件概率。
3.5 进行分类预测在计算完先验概率和条件概率之后，我们可以根据贝叶斯定理计算出给定输入数据下各个类别的后验概率。
我们选择具有最高后验概率的类别作为分类预测结果。
3.6 评估分类器性能最后，我们需要评估贝叶斯分类器的性能。
常用的评估指标包括准确率、精确率、召回率、F1分数等。
4. 示例代码以下是一个简单的使用贝叶斯分类的示例代码：from sklearn.naive_bayes import GaussianNB# 初始化贝叶斯分类器clf = GaussianNB()# 训练分类器clf.fit(X_train, y_train)# 进行分类预测y_pred = clf.predict(X_test)# 评估分类器性能accuracy = clf.score(X_test, y_test)以上代码使用scikit-learn库中的GaussianNB类实现了贝叶斯分类器的训练和预测，通过score方法可以计算分类器的准确率。
python pymc3实例
Python是一种强大的编程语言，被广泛应用于数据分析、科学计算、人工智能等领域。
而pymc3则是一个Python库，用于概率编程和贝叶斯统计建模。
它以贝叶斯方法为基础，为用户提供了建立概率模型和进行贝叶斯推断的工具，可以用于解决复杂的统计问题。
本文将通过介绍pymc3的基本原理和实际应用，帮助读者了解如何使用pymc3进行概率编程和贝叶斯统计建模，并提供一些实际案例来演示pymc3的强大功能。
一、pymc3的基本原理pymc3是一个概率编程的工具，它基于Python语言，利用贝叶斯统计方法来进行概率建模和推断。
其基本原理可以归纳为以下几点：1. 概率建模：pymc3允许用户使用Python代码来构建概率模型，包括随机变量、概率分布和模型参数等。
用户可以根据具体的统计问题构建相应的概率模型，并使用pymc3提供的工具进行建模和推断。
2. 贝叶斯推断：通过概率建模，pymc3可以实现贝叶斯推断，即根据观测数据和先验知识来推断模型参数的后验分布。
这样可以获得更准确的估计结果，并量化参数估计的不确定性。
3. MCMC采样：pymc3使用马尔科夫链蒙特卡罗(MCMC)方法来进行参数估计和后验推断。
MCMC是一种基于随机采样的方法，它可以从参数的后验分布中抽取样本，并用这些样本来估计参数的分布特征。
二、pymc3的实际应用pymc3可以应用于各种统计问题，包括回归分析、时间序列分析、分类模型等。
接下来，我们将通过几个实际案例来演示pymc3的应用。
1. 线性回归模型假设我们要建立一个线性回归模型，用于预测某个因变量Y与若干自变量X之间的关系。
我们可以使用pymc3来构建一个贝叶斯线性回归模型，并进行参数估计和预测分析。
我们需要定义模型的参数和先验分布。
假设Y服从正态分布，且均值与X之间存上线性关系，我们可以定义参数β和σ来描述这一关系。
我们可以利用pymc3提供的工具来构建模型，并使用MCMC方法来进行参数估计。
Python与朴素贝叶斯分类的应用
Python与朴素贝叶斯分类的应用导言Python是一种高级的、内容丰富的编程语言，最早由荷兰人Guido van Rossum在1989年创造。
Python与许多其他编程语言一样，可以用于各种任务，例如Web开发、数据分析、科学计算等等。
Python还广泛应用于人工智能领域，朴素贝叶斯分类就是Python中常用的一种算法。
朴素贝叶斯分类是一个简单而高效的机器学习模型，用于处理分类问题。
该算法的核心思想是基于特征和类别的条件概率对未知数据进行分类。
本文将探讨Python与朴素贝叶斯分类的应用，介绍朴素贝叶斯算法的基本概念，以及如何使用Python实现朴素贝叶斯算法进行分类。
朴素贝叶斯算法的基本概念朴素贝叶斯算法是一种基于贝叶斯定理的分类算法，该算法假设数据集中所有特征都是独立的，从而简化了计算。
算法的核心思想是，根据先验概率和条件概率，计算出后验概率，以此来判断数据属于哪个类别。
在朴素贝叶斯算法中，我们需要计算先验概率、条件概率和后验概率。
其中，先验概率是在不知道数据属于哪个类别的情况下，每种类别的概率。
条件概率是在已知某种类别的情况下，数据拥有某个特征的概率。
后验概率是在知道特征和类别的情况下，数据属于某个类别的概率。
贝叶斯定理将这些概率联系在一起：P(Y|X) = P(X|Y) * P(Y) / P(X)其中，P(Y|X)是后验概率，即在已知特征和类别的情况下，数据属于某个类别的概率；P(X|Y)是条件概率，即在已知某种类别的情况下，数据拥有某个特征的概率；P(Y)是先验概率，即每种类别的概率；P(X)是样本空间中数据拥有某个特征的概率。
在分类问题中，我们需要计算出所有类别的后验概率，然后选择最大值作为分类结果。
因为贝叶斯定理假设每个特征是独立的，所以朴素贝叶斯算法的名称中含有“朴素”这个词。
如何使用Python实现朴素贝叶斯算法进行分类Python中有多个库可用于机器学习，其中就包括用于分类的朴素贝叶斯算法。
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`类来实现伯努利朴素贝叶斯算法。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
Python贝叶斯文本分类模型从原理到实现朴素贝叶斯分类器是一种有监督学习，常见有两种模型，多项式模型(multinomial model)即为词频型和伯努利模型(Bernoulli model)即文档型。
二者的计算粒度不一样，多项式模型以单词为粒度，伯努利模型以文件为粒度，因此二者的先验概率和类条件概率的计算方法都不同。
计算后验概率时，对于一个文档d，多项式模型中，只有在d中出现过的单词，才会参与后验概率计算，伯努利模型中，没有在d中出现，但是在全局单词表中出现的单词，也会参与计算，不过是作为“反方”参与的（避免消除测试文档时类条件概率中有为0现象而做的取对数等问题）。
一、数据集数据集是有8个分类的文本数据集，使用了结巴分词对每个文本分词，每个单词当作特征，再利用二元词串构造更多特征，然后去掉停用词，去掉出现次数太多和太少的特征，得到了19630个特征。
取1998个样本用于训练，509个用于测试。
基于词袋模型的思路将每个文本转换为向量，训练集和测试集分别转换为矩阵，并用python numpy模块将其保存为npy格式。
数据集共使用了19630个单词作为特征，特征值是词在文本中出现的次数。
8个分类，分别是1、2、...、8。
训练集共1998个样本，测试集共509个样本。
二、朴素贝叶斯分类器划分邮件算法朴素贝叶斯分类器，基于贝叶斯定理，是一个表现良好的分类方法。
1、公式原理推导主要根据事件间的相互影响进行公式推断。
1.1、条件概率:P(A|B) = P(A,B)/P(B)A和B是随机事件，P(A|B)也就是在事件B发生的前提下事件A发生的概率。
P(A,B)表示A、B都发生的概率。
这样一来，我们可以通过统计结果计算条件概率。
例如假设有1000封邮件，垃圾邮件有300封，出现单词购买的邮件为50封，而即是垃圾邮件又同时出现了购买这个单词的邮件共有20封。
如果把垃圾邮件看成事件A，邮件里出现单词购买看成事件B，那么P(A)是指垃圾邮件出现的概率，因为没考虑其他的因素对A的影响，也可以将P(A)看做A的先验概率，这里：P(A) = 300/1000 = 0.3同理，P(B) = 50/1000 = 0.05P(A,B)是指A和B同时发生的概率，P(A,B) = 20/1000 = 0.02根据条件概率的公式，能够得到P(A|B) = 0.02 / 0.05 = 0.4因为有B的影响，P(A|B)也叫做A的后验概率。
1.2、相互独立事件如果事件A和B是相互独立的，代表着A发生的可能性对B发生的可能性没有影响，B也对A没有影响，在这种情况下：P(A,B) = P(A)*P(B)。
既然A和B之间没有相互影响，那么：P(A|B) = P(A,B)/P(B) = P(A)P(B|A) = P(A,B)/P(A) = P(B)1.3、贝叶斯定理由P(A|B) = P(A,B)/P(B)很容易推出：P(A|B) = P(B|A)*P(A)/P(B)这也就是贝叶斯公式了。
1.4、朴素贝叶斯分类器（naive Bayes classifier）首先有以下定理：如果B、C相互独立，那么P(B|C,A) = P(B|A)。
设有事件A、B1、B2，那么在B1、B2同时发生的前提下，A发生的概率是：P(A|B1,B2) = P(B1,B2|A)*P(A) / P(B1,B2)如果B1和B2相互独立，那么有P(B1,B2|A) = P（B1|B2,A)*P(B2|A)= P(B1|A)*P(B2|A)于是，P(A|B1,B2) = P(B1,B2|A)*P(A) / P(B1,B2)= P(B1|A)*P(B2|A)*P(A) / P(B1,B2)根据实际需求，假设某个体有n项特征（可以看着邮件中出现的词语），分别为F1、F2、…、Fn。
现有m个类别（可以看着邮件的分类），分别为C1、C2、…、Cm。
贝叶斯分类器就是计算出概率最大的那个分类，也就是求下面这个算式的最大值（即算出每个分类的概率，以最大概率为最终分类）：P(C|F1,F2,...,Fn)= P(F1,F2,...,Fn|C)*P(C) / P(F1,F2,...,Fn)由于P(F1,F2,...,Fn)对于所有的类别都是相同的，可以省略，问题就变成了求P(F1,F2,...,Fn|C)*P(C)的最大值。
朴素贝叶斯分类器则是更进一步，假设所有特征都彼此独立，因此P(F1,F2,...,Fn|C)*P(C)= P(F1|C)*P(F2|C)* ... *P(Fn|C)*P(C)朴素贝叶斯分类器假设所有特征都彼此独立存在一定的不合理性，不过该分类器一般能取得很好的分类效果。
2、判断邮件是否为垃圾邮件假定我们现在有1000封被标识的邮件作为训练集，训练集一般是人工标识，分为“垃圾邮件”、“正常邮件”。
注意，训练集不宜人为地从大量邮件中有意挑拣，而应随机挑拣。
然后我们从邮件中选取特征，例如我们把单词“购买”是否出现在邮件中看作是该邮件的一个特征，训练时候应该记录含有单词“购买”的垃圾邮件有多少封，含有单词“购买”的正常邮件有多少封，按照这个思路，我们得到以下表格：特征词统计正常邮件垃圾邮件汇总“购买”10 50 60“淘宝”8 56 64“开心”60 3 63“编程”20 15 35汇总98 124 222好了，现在有一封邮件需要分类，假设它有购买、淘宝、开心、编程四个特征，那么其属于正常邮件的可能性是：10/98 * 8/98 * 60/98 * 20/98 * 98/222= 0.000459属于垃圾邮件的可能性是：50/124 * 56/124 * 3/124 * 15/124 * 124/222= 0.00029768结果是该邮件更有可能是正常邮件。
如果邮件只有有开心和编程两个特征，那么其属于正常邮件的可能性是：60/98 * 20/98 * 98/222= 0.0551571属于垃圾邮件的可能性是：3/124 * 15/124 * 124/222= 0.0016346992153443768结果是该邮件更有可能是正常邮件。
3、让分类器更合理如果我们的统计结果是这样的：特征词统计正常邮件垃圾邮件汇总（求和）“购买”10 50 60“淘宝”8 56 64“开心”63 0 63“编程”20 15 35汇总(求和) 101 121 222具有特征开心的垃圾邮件有0封。
如果某封邮件具有购买、淘宝、开心这三个特征，按照上面的思路，该邮件属于正常邮件的可能性是：10/101 * 8/101 * 63/101 * 101/222= 0.00222553属于垃圾邮件的可能性是：50/121 * 56/121 * 0/121 * 121/222= 0这意味着，只要邮件里有“开心”，那么它就不是垃圾邮件（属于垃圾邮件的可能性为0），这显然是不合理的。
对此，我们可以对P(F1|C)（以及P(F2|C)、P(F3|C)等）做如下处理（加权平均）：P2(F1|C) = (1*0.5 + sum(F1)*P(F1|C)) / (1 + sum(F1))= (0.5 + sum(F1)*P(F1|C)) / (1 + sum(F1))其中，若F1是开心，那么sum(F1) = 63+0 = 63。
于是，属于正常邮件的可能性是：((0.5 + 10/101 * 60) / 61) * ((0.5 + 8/101 * 64) / 65) * ((0.5 + 63/101 * 63) / 64) * 101/222=0.0025593104680632236属于垃圾邮件的可能性是：((0.5 + 50/121 * 60) / 61) * ((0.5 + 56/121 * 64) / 65) * ((0.5 + 0/121 * 63) / 64) * 121/222= 0.0008181611103439531这封邮件还是倾向于正常邮件，不过计算方式更合理了。
另外我们也可以通过取对数的方式进行优化。
这样更合理，因为对数的相乘可以变成相加。
4、如何由计算结果判断类别如果计算出一封邮件属于正常邮件的概率是0.05，属于垃圾邮件的概率是0.006，基本可以肯定这是一封正常邮件。
不过，如果一封邮件属于正常邮件的概率是0.05，属于垃圾邮件的概率是0.049，那么这封邮件是否该划分为垃圾邮件？也许在这个时候就要在训练之后再填上一个分类了——不确定分类。
首先，设定一个阈值T（大于1），待标注数据D，两个分类C0和C1，如果：P(C0|D) / P(C1|D) > T那么，D属于类别C0。
如果：P(C1|D) / P(C0|D) > T那么，D属于类别C1。
5、如果有多个类别对于朴素贝叶斯分类器而言，多个分类和二分类没什么差别，就是训练的时候多加个分类而已。
三、贝叶斯模型实现朴素贝叶斯的三个常用模型：高斯、多项式、伯努利朴素贝叶斯的基本若一个样本有n个特征，分别用x1,x2,…,xn表示，将其划分到类yk的可能性P(yk|x1,x2,…,xn)为：P(yk|x1,x2,…,xn)=P(x1|yk)*P(x2|yk)…*P(xn|yk)*P(yk)上式中等号右侧的各个值可以通过训练得到。
根据上面的公式可以求的某个数据属于各个分类的可能性（这些可能性之和不一定是1），该数据应该属于具有最大可能性的分类中。
一般来说，如果一个样本没有特征xi，那么P(xi|yk)将不参与计算。
不过下面的伯努利模型除外。
高斯模型有些特征可能是连续型变量，比如说人的身高，物体的长度，这些特征可以转换成离散型的值，比如如果身高在160cm以下，特征值为1；在160cm和170cm之间，特征值为2；在170cm之上，特征值为3。
也可以这样转换，将身高转换为3个特征，分别是f1、f2、f3，如果身高是160cm以下，这三个特征的值分别是1、0、0，若身高在170cm之上，这三个特征的值分别是0、0、1。
不过这些方式都不够细腻，高斯模型可以解决这个问题。
高斯模型假设这些一个特征的所有属于某个类别的观测值符合高斯分布(正态分布)，也就是：下面看一个sklearn中的示例:（需要安装sklearn包）>>> from sklearn import datasets>>> iris = datasets.load_iris()>>> iris.feature_names # 四个特征的名字['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)']>>> iris.dataarray([[ 5.1, 3.5, 1.4, 0.2],[ 4.9, 3. , 1.4, 0.2],[ 4.7, 3.2, 1.3, 0.2],[ 4.6, 3.1, 1.5, 0.2],[ 5. , 3.6, 1.4, 0.2],[ 5.4, 3.9, 1.7, 0.4],[ 4.6, 3.4, 1.4, 0.3],[ 5. , 3.4, 1.5, 0.2],......[ 6.5, 3. , 5.2, 2. ],[ 6.2, 3.4, 5.4, 2.3],[ 5.9, 3. , 5.1, 1.8]]) #类型是numpy.array>>> iris.data.size600 #共600/4=150个样本>>> iris.target_namesarray(['setosa', 'versicolor', 'virginica'], dtype='|S10')>>> iris.targetarray([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,....., 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ......, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2])>>> iris.target.size150>>> from sklearn.naive_bayes import GaussianNB>>> clf = GaussianNB()>>> clf.fit(iris.data, iris.target)>>> clf.predict(iris.data[0])array([0]) # 预测正确>>> clf.predict(iris.data[149])array([2]) # 预测正确>>> data = numpy.array([6,4,6,2])>>> clf.predict(data)array([2]) # 预测结果很合理伯努利模型伯努利模型中，对于一个样本来说，其特征用的是全局的特征。