机器学习：sklearn实现k邻近、朴素贝叶斯

• 1.认识机器学习
• 2.scikit-learn库介绍
• 3.算法介绍
• 4.sklearn数据集介绍
• 5.K近邻算法原理
• 6.使用sklearn实现K近邻
• 7.K近邻预测约会是否受欢迎
• 8.标准化原理和代码实现
• 9.K近邻总结和作业
• 10.朴素贝叶斯公式详解
• 11.朴素贝叶斯文档分类原理
• 12.特征抽取-CountVectorizer
• 13.朴素贝叶斯文章分类实战
• 14.多项式、高斯、伯努利模型

认识机器学习

机器学习介绍

什么是机器学习：

机器学习是一门多领域交叉学科，涉及概率论、统计学、算法复杂度理论等多门学科。专门研究计算机怎样模拟或实现人类的学习行为，以获取新的知识或技能，重新组织已有的知识结构使之不断改善自身的性能。即：通过根据已有的数据使用算法获取这些数据的特性（模型），然后预测未知数据的走向。

机器学习应用案例：

如今因为数据量的增加，硬件条件越来越好，给机器学习提供了非常多的发展空间。目前在很多领域都用到了机器学习，比如：计算机识别、抖音推荐算法、360异常流量监控、信用卡欺诈检测、AI游戏玩家、医学诊断等都有很多非常成功的案例。

机器学习程序开发流程：

1. 获取数据：

机器学习最核心的东西，还是大量的数据作为基本基础。数据可以通过多个渠道获取，比如通过网络爬虫抓取，通过公司自有产品收集，通过与第三方公司合作等。

2. 清洗数据：

获取到数据后，可能存在很多问题，比如字段缺失，比如数据格式不一致，异常数据等，这时候需要将数据进行清洗，然后再送到机器学习程序进行训练。

3. 训练模型：

在这一步通过一定的算法，对数据进行建模，然后不断的调整各个参数的值已达到最优的训练模型。

4. 测试模型：

使用其他的数据对这个模型进行测试，看下这个模型的准确率，如果准确率偏低，则重复第3步，直至最优的模型。

5. 投入使用：

将做好的机器学习模型和算法转化为可以在生产环境中使用的产品。比如提供一个网站，或者一个app，通过接口的方式访问机器学习程序。在这个过程中也要不断的循环3、4来测试和优化模型。

开发环境：

Anaconda3（python3.7+jupyter notebook5.7）
其中用到的包：numpy 1.15.4、pandas 0.24.1、scikit-learn 0.20.2。

scikit-learn库介绍

Scikit-Learn库介绍：

scikit-learn是基于Python语言的机器学习工具，具有以下特点：

1. 简单高效的数据挖掘和数据分析工具。
2. 可供大家在各种环境中重复使用。
3. 建立在NumPy，SciPy和matplotlib上。
4. 开源，可商业使用 - BSD许可证

由来：

对Python语言有所了解的科研人员可能都知道SciPy——一个开源的基于Python的科学计算工具包。基于SciPy，目前开发者们针对不同的应用领域已经发展出了为数众多的分支版本，它们被统一称为Scikits，即SciPy工具包的意思。而在这些分支版本中，最有名，也是专门面向机器学习的一个就是Scikit-learn。
Scikit-learn项目最早由数据科学家David Cournapeau在2007 年发起，需要NumPy和SciPy等其他包的支持，是Python语言中专门针对机器学习应用而发展起来的一款开源框架。
它的维护也主要依靠开源社区。

特点

作为专门面向机器学习的Python开源框架，Scikit-learn可以在一定范围内为开发者提供非常好的帮助。它内部实现了各种各样成熟的算法，容易安装和使用，样例丰富，而且教程和文档也非常详细。

另一方面，Scikit-learn也有缺点。例如它不支持深度学习和强化学习，这在今天已经是应用非常广泛的技术。此外，它也不支持图模型和序列预测，不支持Python之外的语言，不支持PyPy，也不支持GPU加速。

看到这里可能会有人担心Scikit-learn的性能表现，这里需要指出的是：如果不考虑多层神经网络的相关应用，Scikit-learn的性能表现是非常不错的。究其原因，一方面是因为其内部算法的实现十分高效，另一方面或许可以归功于Cython编译器；通过Cython在Scikit-learn框架内部生成C语言代码的运行方式，Scikit-learn消除了大部分的性能瓶颈。

主要功能：

Scikit-learn的基本功能主要被分为六大部分：分类，回归，聚类，数据降维，模型选择和数据预处理（特征工程）等。

官方文档：

https://scikit-learn.org/stable/

算法介绍

机器学习算法

数据类型：

不同类型的数据集采用的算法是不一样的。总体来说，生活场景中只有两种类型的数据，一种是离散型，一种是连续型：

1. 离散型数据：由记录不同类别个体的数目所得到的数据，又称计数数据，所有这些数据全部都是整数，而且不能再细分，也不能进一步提高他们的精确度。比如分类就是离散型数据。
2. 连续型数据：变量可以在某个范围内取任一数，即变量的取值可以是连续的。如，长度、时间、质量值等，这类数通常是非整数，含有小数部分。

可用数据集：

1. Kaggle：一个大数据竞赛平台，上面的数据都是真实的，并且有很多数据集。网址是https://www.kaggle.com/datasets
2. UCI：收录了360个数据集，覆盖了科学、生活、经济等领域。网址是http://archive.ics.uci.edu/ml/
3. scikit-learn数据集：用于学习的数据集，数据量比较小，但是方便获取和学习。网址http://scikit-learn.org/stable/datasets/index.html#datasets。

监督学习和无监督学习：

1. 监督学习（英语：Supervised learning），可以由输入数据中学到或建立一个模型，并依此模式推测新的结果。输入数据是由输入特征值和目标值所组成。函数的输出可以是一个连续的值（称为回归），或是输出是有限个离散值（称作分类）。
2. 无监督学习（英语：Supervised learning），可以由输入数据中学到或建立一个模型，并依此模式推测新的结果。输入数据是由输入特征值所组成。

算法分类：

1. 监督学习：
   • 分类：K近邻算法、贝叶斯分类、决策树与随机森林、逻辑回归、神经网络。
   • 回归：线性回归、岭回归。
2. 无监督学习：
   • 聚类：k-means。

sklearn数据集介绍

scikit-learn数据集：

from sklearn import datasets
import sklearn

boston=datasets.load_boston()
type(boston)
dir(boston)   # ['DESCR', 'data', 'feature_names', 'filename', 'target']
# print(boston.DESCR)
# print(boston.data)
# print(boston.target)
# print(boston.filename)
print(boston.feature_names)

# 下载在哪里
datasets.fetch_20newsgroups(data_home="./newsgroups.csv")

获取数据集：

xxx.fit()  训练
xxx.score()  验证
xxx.predict()  预测

sklearn内部提供了一些数据集，用于学习使用。在使用他之前，首先对他进行一些了解。

获取数据集方式：

获取数据集的方式有两种，有load_*和fetch_*。以下：

1. sklearn.datasets.load_*()：获取小规模的数据集，数据集已经随着scikit-learn安装而下载了。
2. sklearn.datasets.fetch_*(data_home=None)：用于从远程获取大规模的数据集，函数的第一个参数是data_home，表示数据集下载的目录,默认是~/scikit_learn_data/。

两种方式返回的结果都是sklearn.utils.Bunch类型，这种数据类型有以下方法和属性：

1. data：特征数据数组，是[n_samples * n_features]的二维numpy.ndarray数组。
2. target：标签数组，是n_samples的一维numpy.ndarray数组。
3. DESCR：数据描述。
4. feature_names：特征名，新闻数据、手写数字、回归数据集没有。
5. target_names：标签名，回归数据集没有。

数据集的划分：

我们拿到数据集后，一般会采用75%的用于训练，25%的用来测试。因此在把数据进行训练之前，先要对数据进行划分。我们可以使用sklearn.model_selection.train_test_split进行分割，train_test_split中的常用参数如下：

# 永远都是x先写完，先训练再测试
x_train,x_test,y_train,y_test = train_test_split(boston.data,boston.target,test_size=0.25)
print("测试集：",x_train,y_train)

1. x：数据集的特征值。
2. y：数据集的目标值。
3. test_size：测试的数据的占比，用小数表示。

返回值如下：

1. x_train：训练部分的特征值。
2. x_test：测试部分的特征值。
3. y_train：训练部分的特征值。
4. y_test：测试部分的目标值。

示例代码如下：

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

def dataset_split():
  li = load_iris()
  x_train,x_test,y_train,y_test = train_test_split(li.data,li.target,test_size=0.25)
  print("训练集的数据：",x_train,y_train)
  print("测试集的数据：",x_train,x_test)

本地数据集：

分类数据集：

1. load_iris：鸢尾花花瓣数据集。
2. load_digits：手写数字数据集。
3. load_wine：红酒数据集。
4. load_breast_cancer：乳腺癌数据集。

回归数据集：

1. load_boston：波士顿房价数据集。
2. load_diabetes：糖尿病数据集。
3. load_linnerud：体能训练数据集。

以上所有的数据集的网址为：https://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_boston.html#sklearn.datasets.数据集函数名。

远程数据集：

远程数据集是一些真实的数据，一般都比较大，因此在需要的时候进行加载即可。

分类数据集：

1. fetch_olivetti_faces：面孔数据集。
2. fetch_20newsgroups：20个新闻组数据集。
3. fetch_lfw_people：户外人脸识别数据集。
4. fetch_lfw_pairs：户外人脸对（同一个人两个图片）数据集。
5. fetch_covtype：美国一块30*30m的森林斑块土地，上面覆盖了不同类型的树木。
6. fetch_rcv1：路透社文集I (RCV1)。由路透社有限公司为研究目的提供的80多万篇手动分类的新闻专线报道的存档。
7. fetch_california_housing：加利福尼亚房子数据集。

K近邻算法原理

K近邻算法：

K近邻算法原理：

计算预判点与所有点之间的距离，将距离排序，前k个点中，那种类别的点多就属于哪一种

K近邻算法是如果一个样本在特征空间中的K个最相似(即特征空间中最邻近)的样本中的大多数属于某一个类别，则该样本也属于这个类别。
他的原理就是求两点之间的距离，看距离谁是最近的，以此来区分我们要预测的这个数据是属于哪个分类：

比如有两点，要求他们的距离，a(a1,a2,a3),b(b1,b2,b3)，则计算公式为：

√((𝑎1−𝑏1)^2+(𝑎2−𝑏2)^2+(𝑎3−𝑏3)^2)

这个公式叫做欧式距离公式。

使用sklearn实现K近邻算法：

sklearn.neighbors.KNeighborsClassifier(n_neighbors=5,algorithm='auto')：

1. n_neighbors：int，可选（默认= 5），k_neighbors查询默认使用的邻居数。

2. algorithm：可选用于计算最近邻居的算法。

   • ball_tree：将会使用BallTree。
   • kd_tree：将使用KDTree。
   • auto：将尝试根据传递给fit方法的值来决定最合适的算法。 (不同实现方式影响效率)

案例：

使用FaceBook生成的一个选址的数据集为例。
网站为：https://www.kaggle.com/c/facebook-v-predicting-check-ins/data。

代码如下：

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import StandardScaler

train_data = pd.read_csv("data/FBlocation/train.csv")
time_value = pd.to_datetime(train_data['time'],unit='s')
time_value = pd.DatetimeIndex(time_value)

# 将时间戳变成周几，几点。因为不同的时间可能会影响选址
train_data['week'] = time_value.week
train_data['hour'] = time_value.hour

place_count = train_data.groupby("place_id").count()
temp_data = place_count[place_count['row_id'] > 10].reset_index().head()
train_data = train_data[train_data['place_id'].isin(temp_data['place_id'])]
train_data = train_data.reset_index().drop(['index','row_id'],axis=1)

y = train_data['place_id']
x = train_data.drop(['place_id'],axis=1)


x_train,x_test,y_train,y_test = train_test_split(x,y,test_size=0.25)
# 因为不同的数据大小单位不一样，为了避免造成太大的影响，都做一个标准化。
scaler = StandardScaler()
x_train = scaler.fit_transform(x_train)
x_test = scaler.fit_transform(x_test)

knn = KNeighborsClassifier(n_neighbors=5)
knn.fit(x_train,y_train)
y_predict = knn.predict(x_test)
# print("预测的位置：",y_predict)
print("预测的准确率：",knn.score(x_test,y_test))

其中正确率达到98%。

K（也就是n_neighbors）值该去多大？

K值不能取太少，也不能取太多。如果取太少，则容易受异常点的影响，如果取太多，则容易产生过拟合的现象，也会影响分类的准确性。因此要不断的调参数，来看下参数对最终结果的影响。

K近邻算法的优缺点：

1. 优点：简单，易于理解，无需估计参数，无需训练。
2. 缺点：懒惰算法，对测试样本分类时的计算量大，内存开销大。K值要不断的调整来达到最优的效果。

基于以上优缺点，在小数据场景，几千~几万的数据量的时候，可以使用K近邻算法。

作业：

使用sklearn自带的数据集load_wine，来预测酒的分类。

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_wine

# 加载数据
wine = load_wine()

# 标准化
scaler = StandardScaler()
features = scaler.fit_transform(wine.data)
targets = wine.target

# 训练数据求得分
X_train,X_test,y_train,y_test = train_test_split(features,targets,test_size=0.25)
knn = KNeighborsClassifier()
knn.fit(X_train,y_train)
knn.score(X_test,y_test)

使用sklearn实现K近邻

```python
from sklearn.neighbors import KNeighborsClassifier
import pandas as pd
import seaborn as sns
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

values = np.array([
    [0,0],
    [0.1,0.2],
    [1,1],
    [1.1,0.9]
])
lables = ['A','A','B','B']
df = pd.DataFrame(values,lables)
axis = sns.scatterplot(values[:,0],values[:,1])
for value,label in zip(values,lables):
    axis.text(value[0],value[1],label)

knn = KNeighborsClassifier(n_neighbors=3)
knn.fit(values,lables)
knn.predict([[0.85,0.9]])

<h2 id=7>K近邻预测约会是否受欢迎<h2>

```python
df = pd.read_csv("data/datingTestSet.txt",sep="\t",names=['flight','icecream','game','type'])
df.head()


features = df.drop(columns=['type'],axis=0)
targets = df['type']
X_train,X_test,y_train,y_test = train_test_split(features,targets,test_size=0.25)
knn = KNeighborsClassifier()
knn.fit(X_train,y_train)
# knn.predict(X_test)
knn.score(X_test,y_test)
# knn.predict([[40000,10,0.5]])

标准化原理和代码实现

scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.fit_transform(X_test)
knn.fit(X_train,y_train)
knn.score(X_test,y_test)

特征预处理：

差别：

特征预处理是采用特定的统计方法（数学方法）将数据转化成算法要求的数字。

1. 数值型数据：
   • 归一化（将原始数据变换到[0,1]之间）
   • 标准化（把数据转化到均值为0，标准差为1范围内，满足标准正态分布）
   • 缺失值（将缺失值处理成均值、中位数等）
2. 类别型数据：
   • 降维（将多指标转化为少数几个综合指标）
   • PCA（降维的一种）
3. 时间类型：
   • 时间的切分

归一化：

归一化首先在特征（维度）非常多的时候，可以防止某一维或某几维对数据影响过大，也是为了把不同来源的数据统一到一个参考区间下，这样比较起来才有意义，其次可以程序可以运行更快。 例如：一个人的身高和体重两个特征，假如体重50kg，身高175cm,由于两个单位不一样，数值大小不一样。如果比较两个人的体型差距时，那么身高的影响结果会比较大，因此在做计算之前需要先进行归一化操作。归一化的公式为：

X'=(x−min)/(max​−min)
​​X" = X'*(mx-mi)+mi

其中max和min分别代表的是某列中的最大值和最小值，x为归一化之前的值。mx和mi为要归一化的区间，默认为[0,1]。
示例代码如下：

from sklearn.preprocessing import MinMaxScaler

def normalize():
  data = [
    [180,75,25],
    [175,80,19],
    [159,50,40],
    [160, 60, 32]
  ]
  scaler = MinMaxScaler(feature_range=(0,2))
  result = scaler.fit_transform(data)
  print(result)

归一化因为非常容易受到最大值和最小值的影响，因此如果数据集中存在一些异常点，结果将发生很大的改变，因此这种方法鲁棒性（稳定性）比较差，只适合数据量比较精确，比较小的情况。

标准化：

常用的方法是z-score标准化，经过处理后的数据均值为0，标准差为1，满足标准正太分布，标准正太分布如下：

处理公式为：

X' = (x-μ)/σ

其中μ是样本的均值，σ是样本的标准差，它们可以通过现有的样本进行估计，在已有的样本足够多的情况下比较稳定，适合嘈杂的数据场景。

标准差的求法是先求方差，方差std的求法如下：

𝑠𝑡𝑑=((𝑥1−𝑚𝑒𝑎𝑛)^2+(𝑥2−𝑚𝑒𝑎𝑛)^2+…)/(𝑛(每个特征的样本数))

然后标准差𝜎则开根号：

𝜎=√std

方差和标准差越趋近于0，则表示数据越集中，如果越大，则表示数据越离散。

def standard():
  data = [
    [180, 75, 25],
    [175, 80, 19],
    [159, 50, 40],
    [160, 60, 32]
  ]
  scaler = StandardScaler()
  result = scaler.fit_transform(data)
  print(result)
  print("="*10) 
  print("="*10)
  print(scaler.var_)

缺失值处理：

缺失值一般有两种处理方式。第一种是直接进行删除，第二种是进行替换。除非缺失值占总数据集的比例非常少，才推荐使用删除的方式，否则建议使用“平均值”、“中位数”的方式进行替换。在scikit-learn中，有专门的缺失值处理方式，叫做sklearn.preprocessing.Imputer。示例代码如下：

from sklearn.impute import SimpleImputer
def missing():
  im = SimpleImputer()
  data = im.fit_transform([
    [1,2],
    [np.NAN,4],
    [9,1]
  ])
  print(data)

K近邻总结和作业

K（也就是n_neighbors）值该去多大？

K值不能取太少，也不能取太多。如果取太少，则容易受异常点的影响，如果取太多，则容易产生过拟合的现象，也会影响分类的准确性。因此要不断的调参数，来看下参数对最终结果的影响。

K近邻算法的优缺点：

1. 优点：简单，易于理解，无需估计参数，无需训练。
2. 缺点：懒惰算法，对测试样本分类时的计算量大，内存开销大。K值要不断的调整来达到最优的效果。

基于以上优缺点，在小数据场景，几千~几万（20万以内）的数据量的时候，可以使用K近邻算法。

作业：

使用sklearn自带的数据集load_wine，来预测酒的分类。

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_wine

# 加载数据
wine = load_wine()

# 标准化
scaler = StandardScaler()
features = scaler.fit_transform(wine.data)
targets = wine.target

# 训练数据求得分
X_train,X_test,y_train,y_test = train_test_split(features,targets,test_size=0.25)
knn = KNeighborsClassifier()
knn.fit(X_train,y_train)
knn.score(X_test,y_test)

朴素贝叶斯公式详解

朴素贝叶斯

贝叶斯：

贝叶斯全名托马斯·贝叶斯（Thomas Bayes，1702-1761），是一名英国数学家，贝叶斯公式是源于他生前写的一篇“逆概率”问题的文章。贝叶斯公式在生前并不被认可，在去世后被他的朋友整理才公诸于世被世人所认可。

概率计算小案例：

在学习朴素贝叶斯基础之前，先要学习一下数学中关于概率的计算。比如有以下表：

症状	职业	疾病
打喷嚏	护士	感冒
打喷嚏	农夫	过敏
头痛	建筑工人	脑震荡
头痛	建筑工人	感冒
打喷嚏	教师	感冒
头痛	教师	脑震荡

根据以上数据，回答以下问题：

1. 得感冒的人概率是多少？(3/6)
2. 有头痛症状，并且是教师的概率是多少？(1/6)
3. 在感冒的疾病中，是护士的概率是多少？(1/3)
4. 在感冒的疾病中，打喷嚏并且是护士的概率是多少？((1/3)*(2/3)=2/9)

联合概率和条件概率：

联合概率：

联合概率是包含多个条件，且所有的条件同时成立的概率，以上第二点就是联合概率。这种概率计算的方式有专门的公式，记作P(AB)，其中P(A)表示A这个特征出现的概率，同理P(B)也是，在特征条件独立的情况下存在公式P(AB)=P(A)*P(B)。所以以上第二题的答案是：P(头痛)*P(教师)=(3/6)*(2/6)=1/6。

条件概率：

条件概率就是事件A在另外一个事件B已经发生的前提下发生的概率。计算的公式为：P(A|B)，如果有多个条件，那记作P(A1,A2|B)=P(A1|B)*P(A2|B)。所以以上第四题的答案是：P(打喷嚏|感冒)*P(护士|感冒)=(2/3)*(1/3)=2/9。

注意：以上的计算公式，是在以各个特征是条件独立的基础之上才成立的！

朴素贝叶斯公式：

推导过程：

# 因为在概率论中有一个乘法定理
P(AB) = P(A|B)*P(B)
# 这个公式同样适合B在A条件下发生的概率，因此： 
P(AB) = P(B|A)*P(A)
# 以上两个等式相等，所以
P(A|B) = P(B|A)*P(A)/P(B)

贝叶斯公式例子：

假如现在学校有N个学生，男生占60%，女生占40%，其中男生都穿长裤，女生有一半是穿长裤，一半是穿裙子，那么以下两个问题：

1. 随机选择一个学生，知道性别的前提下，他（她）穿长裤的概率是多少？（男：1，女：0.5）
2. 走来一个学生，只看到他穿长裤，求他是男生的概率是多少？（3/4=0.75）

朴素贝叶斯文档分类原理

文档分类：

以上便是朴素贝叶斯的公式。一般朴素贝叶斯经常用到文档分类上，文档分类是根据已经分类的文档中提取关键词，在以后遇到新的文档分类的时候，就从这些关键词中预测是属于哪个类别。在文档分类中可以把贝叶斯公式改成以下：

针对每个进行一个讲解：

1. P(C|W)：某个关键词属于某个分类的概率。
2. P(W|C)：某个分类下，某个关键词出现的概率。
3. P(C)：某个类别的概率（某个类别的文档个数/总文档数）。
4. P(W)：这个关键词在需要预测的文档中出现的概率。

朴素贝叶斯预测文档分类的原理是：根据以上公式，可以计算出某篇文档下出现得比较多的词，然后把这些词去每个分类下求下概率，在哪个分类下的概率高，那么就意味着这篇文章是属于哪个分类。

比如现在有以下表格：
数字代表的是出现的次数

特征	科技类	娱乐类	汇总
明星	9	51	60
影院	8	56	64
云计算	63	0	63
支付宝	20	15	35
汇总	100	121	221

假如现在有一篇文章包含“影院”、“支付宝”、“云计算”，要计算属于科技类和娱乐类的概率。计算方式如下：

出现`影院,支付宝,云计算`三个关键词，文章属于科技类别的概率
P(科技|影院,支付宝,云计算)=P(影院,支付宝,云计算|科技)*P(科技) = 
(8/100)*(20/100)*(63/100)*(100/221)

出现`影院,支付宝,云计算`三个关键词，文章属于娱乐类别的概率
P(娱乐|影院,支付宝,云计算)=P(影院,支付宝,云计算|娱乐)*P(娱乐) =
(8/121)*(15/121)*(0/121)*(121/221)

拉普拉斯平滑系数：

为了避免出现0的情况，可以使用拉普拉斯系数

可以看到上面的演示中，娱乐类在计算完成后，概率为0，这肯定是不对的，因为他只要里面包含了任何一个跟娱乐相关的词，都有可能是属于娱乐。因此为了避免出现0的情况，可以使用拉普拉斯系数，将P(W|C)改为如下：

𝑃(W│𝐶)=(𝑁𝑖+𝛼)/(𝑁+𝛼𝑚)

其中

1. 𝑁𝑖为该W词在C类别所有文档中出现的次数。
2. N为所属类别C下的文档所有词出现的次数和。
3. 𝛼就是为指定的系数，一般为1。
4. m为训练文档中统计出的特征词个数。

这样计算出来虽然结果稍微有些不同，但是不会影响每个词对文档分类的概率大小，大小没改变，那么分类结果也不会被改变。

特征抽取-CountVectorizer

文章分类实战：

可以使用sklearn.navie_bayes.MultinomialNB(alpha=0.1)来实现。

我们用sklearn库中提供的fetch_20newsgroups来做分类，这个数据总共有20个类别，总共有18000篇新闻。

from sklearn.feature_extraction.text import CountVectorizer
from sklearn.datasets import fetch_20newsgroups
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import MultinomialNB,GaussianNB
import pandas as pd

word1 = "life is short,i need python"
word2 = "i love python,it makes me happy"
vect = CountVectorizer()
words = vect.fit_transform([word1,word2])
names = vect.get_feature_names()
print(names)
print(words.toarray()) # 每个单词出现的次数
print(type(words))

from sklearn.feature_extraction.text import CountVectorizer
from sklearn.datasets import fetch_20newsgroups
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import MultinomialNB,GaussianNB
import pandas as pd

newsgroups = fetch_20newsgroups(data_home="./data")
X_train,X_test,y_train,y_test = train_test_split(newsgroups.data,newsgroups.target,test_size=0.25)
news_vect = CountVectorizer()
X_train = news_vect.fit_transform(X_train)
X_test = news_vect.transform(X_test)
nb = MultinomialNB()
nb.fit(X_train,y_train)
nb.score(X_test,y_test)

朴素贝叶斯文章分类实战

朴素贝叶斯模型：

针对不同的数据，我们有不同的朴素贝叶斯模型来进行分类。如果特征是离散型数据，比如文本这些，那么推荐使用多项式模型来实现；如果特征是连续型数据，比如具体的数字，那么推荐使用高斯模型来实现；如果特征是连续型数据并且值只有0和1两种情况，那么推荐使用伯努利模型。虽然模型不同，但是原理都是朴素贝叶斯公式，只不过不同的模型，在计算概率的时候采用的方式不一样，比如高斯模型，那么是通过高斯分布函数来计算而已。

from sklearn.feature_extraction.text import CountVectorizer
from sklearn.datasets import fetch_20newsgroups
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import MultinomialNB,GaussianNB
import pandas as pd

newsgroups = fetch_20newsgroups(data_home="./data")
X_train,X_test,y_train,y_test = train_test_split(newsgroups.data,newsgroups.target,test_size=0.25)
news_vect = CountVectorizer()
X_train = news_vect.fit_transform(X_train)
X_test = news_vect.transform(X_test)
nb = MultinomialNB()
nb.fit(X_train,y_train)
nb.score(X_test,y_test)

多项式、高斯、伯努利模型

from sklearn.naive_bayes import MultinomialNB
from sklearn.datasets import fetch_20newsgroups
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.model_selection import train_test_split

newsgroups = fetch_20newsgroups(data_home="./data")
X_train,X_test,y_train,y_test = train_test_split(newsgroups.data,newsgroups.target,test_size=0.25)
tf = CountVectorizer()
X_train = tf.fit_transform(X_train)
X_test = tf.transform(X_test)

mnb = MultinomialNB()
mnb.fit(X_train,y_train)
mnb.score(X_test,y_test)

多项式模型：

离散型数据应该使用多项式模型来实现。比如文档分类、垃圾邮件识别等。使用的类是sklearn.navie_bayes.MultinomialNB。

高斯模型：

连续型数据应该使用高斯模型来实现。公式依然是使用之前的朴素贝叶斯公式，但是在计算条件概率的时候用的是高斯分布函数：

在sklearn中，使用的类是sklearn.navie_bayes.GaussianNB来实现的。比如有一组心脏病患者的数据，心脏病患者的一些特性，都是具体的数值，也就是连续型数据，因此这种情况下应该使用高斯模型。示例代码如下：

from sklearn.feature_extraction.text import CountVectorizer
from sklearn.datasets import fetch_20newsgroups
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import MultinomialNB,GaussianNB
import pandas as pd

hearts = pd.read_csv("data/heart.csv")
features = hearts.drop(columns=['target'],axis=0)
targets = hearts['target']
X_train,X_test,y_train,y_test = train_test_split(features,targets,test_size=0.25)
gaus = GaussianNB()
gaus.fit(X_train,y_train)
gaus.score(X_test,y_test)

伯努利模型：

伯努利模型，一般在特征的值，都是0和1的情况下使用。在sklearn中，使用的类是sklearn.navie_bayes.BernoulliNB来实现。

朴素贝叶斯算法总结：

优点：

1. 朴素贝叶斯发源于古典数学，有稳定的分类效率。
2. 对数据缺失不太敏感，算法也比较简单，常用于文本分类。
3. 分类准确度高，速度快。

缺点：

由于使用了样本特性条件独立性，如果样本特性有关联的时候，会影响算法的效果。