机器学习提纲挈领-（2）贝叶斯的sklearn使用，理论及推导，python实现，实践

一、介绍

朴素贝叶斯分类是一种直观而强大的分类任务算法。朴素贝叶斯分类是在应用贝叶斯定理的基础上进行的，特征之间具有很强的独立性假设。朴素贝叶斯分类用于文本数据分析(如自然语言处理)时，产生了良好的结果。朴素贝叶斯模型也被称为简单贝叶斯或独立贝叶斯。这些都是贝叶斯定理在分类器决策规则中的应用。朴素贝叶斯分类器将贝叶斯定理应用于实际。另一方面，尽管朴素贝叶斯被认为是一种相当不错的分类器，但却不是好的估计器(estimator)，所以不能太过于重视从 predict_proba 输出的概率。

二、GaussianNB分类简单实践

import numpy as np
import matplotlib.pyplot as plt
from dask import datasets
from matplotlib.colors import ListedColormap
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import GaussianNB



# import some data to play with
iris = load_iris()
# we only take the first two features. We could avoid this ugly
# slicing by using a two-dim dataset
X = iris.data[:, :2]
y = iris.target

h = .02  # step size in the mesh

# Create color maps
cmap_light = ListedColormap(['orange', 'cyan', 'cornflowerblue'])
cmap_bold = ListedColormap(['darkorange', 'c', 'darkblue'])

gnb = GaussianNB()
gnb.fit(X, y)

# Plot the decision boundary. For that, we will assign a color to each
# point in the mesh [x_min, x_max]x[y_min, y_max].
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
                     np.arange(y_min, y_max, h))
Z = gnb.predict(np.c_[xx.ravel(), yy.ravel()])

# Put the result into a color plot
Z = Z.reshape(xx.shape)
plt.figure()
plt.pcolormesh(xx, yy, Z, cmap=cmap_light)

# Plot also the training points
plt.scatter(X[:, 0], X[:, 1], c=y, cmap=cmap_bold,
            edgecolor='k', s=20)
plt.xlim(xx.min(), xx.max())
plt.ylim(yy.min(), yy.max())
plt.title("GaussianNB 3-Class classification")

plt.savefig("GaussianNB.jpg", dpi=100)

三、理论

1）公式及概念

朴素贝叶斯法通过训练数据集学习联合概率分布 $P(X,Y)$。
朴素贝叶斯法分类时，对给定的输入x，通过学习到的模型计算后验概率分布$P(Y=c_k|X=x)$，将后验概率最大的类作为$x$的类输出。
后验概率计算：
$$P\left(Y=c_k|X=x\right)=\frac{P\left(X=x|Y=c_k\right)P\left(Y=c_k\right)}{{\sum }_{k}P\left(X=x|Y=c_k\right)P\left(Y=c_k\right)}$$

而条件概率的计算：
$$P\left(X=x|Y=c_k\right)=P\left(X^{(1)}=x^{(1)},\cdots ,X^{(n)}=x^{(n)}|Y=c_k\right),k=1,2,\cdots ,K$$

但是，朴素贝叶斯法对条件概率分布作了条件独立性的假设。由于这是一个较强的假设，朴素贝叶斯法也由此得名。 这个条件独立性假设是：
$$\begin{array}{rl}P\left(X=x|Y=c_k\right)& =P\left(X^{(1)}=x^{(1)},\cdots ,X^{(n)}=x^{(n)}|Y=c_k\right)\\ & =\prod _{j=1}^{n}P\left(X^{(j)}=x^{(j)}|Y=c_k\right)\end{array}$$
也可以写为：
$$P(x_i|y,x_1,\dots ,x_{i-1},x_{i+1},\dots ,x_n)=P(x_i|y)$$
朴素贝叶斯法实际上学习到生成数据的机制，所以属于生成模型。条件独立假设等于是说用于分类的特征在类确定的条件下都是条件独立的。这一假设使朴素贝叶斯法变得简单，但有时会牺牲一定的分类准确率。
后验概率变为：
$$P\left(Y=c_k|X=x\right)=\frac{P\left(Y=c_k\right){\prod }_{j}P\left(X^{(j)}=x^{(j)}|Y=c_k\right)}{{\sum }_{k}P\left(Y=c_k\right){\prod }_{j}P\left(X^{(j)}=x^{(j)}|Y=c_k\right)},k=1,2,\cdots ,K$$
朴素贝叶斯分类器可表示为：
$$y=f(x)=\arg \underset{c_k}{\max }\frac{P\left(Y=c_k\right){\prod }_{j}P\left(X^{(j)}=x^{(j)}|Y=c_k\right)}{{\sum }_{k}P\left(Y=c_k\right){\prod }_{j}P\left(X^{(j)}=x^{(j)}|Y=c_k\right)}$$

其实其分母是：$$P(x_1,\dots ,x_n)$$
对所有$c_k$都是相同的，所以：
$$y=\arg \underset{c_k}{\max }P\left(Y=c_k\right)\prod _{j}P\left(X^{(j)}=x^{(j)}|Y=c_k\right)$$
使用最大后验概率(Maximum A Posteriori, MAP) 来估计$P\left(Y=c_k\right)$

各种各样的的朴素贝叶斯分类器的差异大部分来自于处理 $P(x_i\mid y)$分布时的所做的假设不同。

高斯朴素贝叶斯算法的特征的可能性(即概率)假设为高斯分布:
$$P(x_i\mid y)=\frac{1}{\sqrt{2\pi {\sigma }_y^2}}\exp \left(-\frac{(x_i-{\mu }_y{)}^2}{2{\sigma }_y^2}\right)$$
参数 ${\sigma }_y$ 和 ${\mu }_y$ 使用最大似然法估计。

2）朴素贝叶斯法的参数估计

A、极大似然估计

• 先验概率$P(Y=c_k)$的极大似然估计是:
  $$P\left(Y=c_k\right)=\frac{{\sum }_{i=1}^{N}I\left(y_i=c_k\right)}{N},k=1,2,\cdots ,K$$
  设第 $j$ 个特征$x^{(j)}$ 可能取值的集合为$$\left\{a_{j1},a_{j2},\cdots ,a_{j{S}_j}\right\}$$
• 条件概率$P(x^{(j)}=a_{jl}|Y=c_k)$的极大似然估计是:
  $$\begin{array}{rl}& P\left(X^{(j)}=a_{jl}|Y=c_k\right)=\frac{{\sum }_{i=1}^{N}I\left(x_i^{(j)}=a_{jl},y_i=c_k\right)}{{\sum }_{i=1}^{N}I\left(y_i=c_k\right)}\\ & j=1,2,\cdots ,n;l=1,2,\cdots ,S_j;k=1,2,\cdots ,K\end{array}$$

B、贝叶斯估计

• 先验概率的贝叶斯估计是:
  $$P_{\lambda }\left(Y=c_k\right)=\frac{{\sum }_{i=1}^{N}I\left(y_i=c_k\right)+\lambda }{N+K\lambda }$$
  按照拉普拉斯平滑估计概率，即取$\lambda =1$。
• 条件概率的贝叶斯估计是:
  $$P_{\lambda }\left(X^{(j)}=a_{jl}|Y=c_k\right)=\frac{{\sum }_{i=1}^{N}I\left(x_i^{(j)}=a_{jl},y_i=c_k\right)+\lambda }{{\sum }_{i=1}^{N}I\left(y_i=c_k\right)+S_j\lambda }$$

3）例子

• 使用极大似然估计
  
  

• 使用贝叶斯估计
  同解上题。
  按照拉普拉斯平滑估计概率，即取$\lambda =1$。
  $x^{(1)}$有3个特征值，$x^{(2)}$有3个特征值，$y$有2个分类值，分子、分母对应加上相应$\lambda$倍数。
  
  

四、python实现

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

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

from collections import Counter
import math

# data
def create_data():
    iris = load_iris()
    df = pd.DataFrame(iris.data, columns=iris.feature_names)
    df['label'] = iris.target
    df.columns = ['sepal length', 'sepal width', 'petal length', 'petal width', 'label']
    data = np.array(df.iloc[:100, :])
    # print(data)
    return data[:,:-1], data[:,-1]

#%%

X, y = create_data()
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)

class NaiveBayes:
    def __init__(self):
        self.model = None

    # 数学期望
    @staticmethod
    def mean(X):
        return sum(X) / float(len(X))

    # 标准差（方差）
    def stdev(self, X):
        avg = self.mean(X)
        return math.sqrt(sum([pow(x-avg, 2) for x in X]) / float(len(X)))

    # 概率密度函数
    def gaussian_probability(self, x, mean, stdev):
        exponent = math.exp(-(math.pow(x-mean,2)/(2*math.pow(stdev,2))))
        return (1 / (math.sqrt(2*math.pi) * stdev)) * exponent

    # 处理X_train
    def summarize(self, train_data):
        summaries = [(self.mean(i), self.stdev(i)) for i in zip(*train_data)]
        return summaries

    # 分类别求出数学期望和标准差
    def fit(self, X, y):
        labels = list(set(y))
        data = {label:[] for label in labels}
        for f, label in zip(X, y):
            data[label].append(f)
        self.model = {label: self.summarize(value) for label, value in data.items()}
        return 'gaussianNB train done!'

    # 计算概率
    def calculate_probabilities(self, input_data):
        # summaries:{0.0: [(5.0, 0.37),(3.42, 0.40)], 1.0: [(5.8, 0.449),(2.7, 0.27)]}
        # input_data:[1.1, 2.2]
        probabilities = {}
        for label, value in self.model.items():
            probabilities[label] = 1
            for i in range(len(value)):
                mean, stdev = value[i]
                probabilities[label] *= self.gaussian_probability(input_data[i], mean, stdev)
        return probabilities

    # 类别
    def predict(self, X_test):
        # {0.0: 2.9680340789325763e-27, 1.0: 3.5749783019849535e-26}
        label = sorted(self.calculate_probabilities(X_test).items(), key=lambda x: x[-1])[-1][0]
        return label

    def score(self, X_test, y_test):
        right = 0
        for X, y in zip(X_test, y_test):
            label = self.predict(X)
            if label == y:
                right += 1

        return right / float(len(X_test))

model = NaiveBayes()

model.fit(X_train, y_train)

print(model.predict([4.4,  3.2,  1.3,  0.2]))

model.score(X_test, y_test)

0.0
1.0

五、在scikit-learn中

高斯朴素贝叶斯：GaussianNB
多项分布朴素贝叶斯：MultinomialNB
补充朴素贝叶斯：ComplementNB
伯努利朴素贝叶斯：BernoulliNB