统计学习方法笔记---朴素贝叶斯

朴素贝叶斯

机器学习实战代码详见：https://editor.csdn.net/md?articleId=105165351

优缺点

优点：

1. 在数据较少的情况下仍然有效；
2. 可以处理多类别问题

缺点：

1. 对于输入数据的准备方式较为敏感？

适用数据类型： 标称型数据

本章概要

1. 朴素贝叶斯是典型的生成模型。生成方法由训练数据学习联合概率分布$P(X,Y)$，然后求得后验概率分布$P(Y|X)$，具体来说，利用训练数据$P(X|Y)$和$P(Y)$的估计，得到联合概率分布：
   $$P(X,Y)=P(Y)P(X|Y)$$
   概率估计方法可以是极大似然估计或贝叶斯估计。具体证明见以公式证明1,2。

2. 朴素贝叶斯法的基本假设是条件独立性：
   $$\begin{gathered} P(X=x|Y=c_k)=P(X^{(1)}=x^{(1)},...,X^{(n)}=x^{(n)}|Y=c_k) \\ =\prod _{j=1}^{n}P(X^{(j)}=x^{(j)}|Y=c_k) \end{gathered}$$
   这是一个较强的假设，由于这一假设，模型包含的条件概率的数量大为减少，朴素贝叶斯法的学习与预测大为简化。因为朴素贝叶斯高效，且易于实现。其缺点是分类的性能不一定很高。

3. 朴素贝叶斯利用贝叶斯定理与学到的联合概率模型进行分类预测。
   $$\begin{gathered} 后验概率：P(Y|X)=\frac{P(X,Y)}{P(X)}=\frac{P(Y)P(X|Y)}{{\sum }_{Y}P(Y)P(X|Y)} \\ P(Y=c_k|X=x)=\frac{P(Y=c_k){\prod }_{j=1}^{n}P(X_j=x^{(j)}|Y=c_k)}{{\sum }_{k}P(Y=c_k){\prod }_{j=1}^{n}P(X_j=x^{(j)}|Y=c_k)} \end{gathered}$$
   将输入x分到后验概率最大的类y。
   $$y=argma{x}_{c_k}P(Y=c_k)\prod _{j=1}^{n}P(X_j=x^{(j)}|Y=c_k)$$

4. 后验概率最大等价于0-1损失函数时的期望风险最小化。

算法流程

1. 计算先验概率和条件概率：
   
2. 对于给定的实例$x＝(x^{(}1),x^{(}2),\dots ,x^{(}n){)}^T$，计算:
   
3. 确定实例x的类
   
   这里需要关注的是当训练集较小时，$P(X^{(}j)=a_{jl}|Y=c_k)=\frac{{\sum }_{i=1}^{N}I(x_i^{(j)}=a_{jl},y_i=c_k)}{{\sum }_{i=1}^{N}I(y_i=c_k)}$ 可能等于0， 导致后验概率也为0，所以加上$lambda$，即使用贝叶斯估计计算的概率估计方式，能够避免这种情况的出现。
   贝叶斯估计法计算出的概率估计如下：
   先验概率：
   
   条件概率：
   

公式推导（仅用于理解，不严谨）

1. 用极大似然估计法推出朴素贝叶斯法中的概率估计公式
   $Y\in \{C_1,C_2,...,C_k\}$服从多项分布，对于每一个$C_i$都有对应的概率：
   $$\begin{gathered} C_1,C2,...,C_k \\ {\theta }_1,{\theta }_2,...,{\theta }_k(\sum _{i=1}^k{\theta }_i=1) \end{gathered}$$
   将 $k$ 个 ${\theta }_i$ 记为一个向量$\Theta$ = $({\theta }_1,{\theta }_2,...,{\theta }_k)$
   $Y$的分布则为：
   $$P(Y=y|\Theta )={\theta }_1^{I(y=c_1)}\cdot {\theta }_2^{I(y=c_2)}\cdot ...\cdot {\theta }_k^{I(y=c_k)}={\theta }_i(如果y=c_i)$$
   现有样本：$y_1,y_2,...,y_N$
   联合概率分布：
   $$\begin{gathered} P(y_1,y_2,...,y_N)=P(y_1|\Theta )P(y_2|\Theta )...P(y_N|\Theta )={\theta }_1^{m_1}\cdot {\theta }_2^{m_2}\cdot ...\cdot {\theta }_k^{m_k} \\ (m_1+m_2+...+m_k=N) \\ (m_i表示y=c_i的次数) \end{gathered}$$
   极大似然估计就是极大化联合概率分布，即
   $$\begin{gathered} maxP(y_1,y_2,...,y_N)|\Theta ) \\ =>maxlnP(\cdot )=m_{1}ln{\theta }_1+m_{2}ln{\theta }_2+...+m_{k}ln{\theta }_{k}s.t{\theta }_1+...+{\theta }_k=1 \\ =>max{m}_{1}ln({\theta }_1)+m_{2}ln({\theta }_2)+...+m_{k}ln({\theta }_k)+\lambda ({\theta }_1+...+{\theta }_k) \end{gathered}$$
   分别对${\theta }_1,...,thet{a}_k$求导：
   $$\begin{gathered} \frac{m_1}{{\theta }_1}+\lambda =0=>{\theta }_1=-\frac{m_1}{\lambda }=\frac{m_1}{N} \\ \frac{m_2}{{\theta }_2}+\lambda =0=>{\theta }_2=-\frac{m_2}{\lambda }=\frac{m_1}{N} \\ ... \\ \frac{m_k}{{\theta }_k}+\lambda =0=>{\theta }_k=-\frac{m_k}{\lambda }=\frac{m_1}{N} \\ -\frac{m_1+m_2+...+m_k}{\lambda }=1=>\lambda =-(m_1+m_2+...+m_k)=-N \end{gathered}$$
2. 用贝叶斯估计法推出朴素贝叶斯法中的概率估计公式
   $Y\in \{C_1,C_2,...,C_k\}$服从多项分布，对于每一个$C_i$都有对应的概率：
   $$\begin{gathered} C_1,C2,...,C_k \\ {\theta }_1,{\theta }_2,...,{\theta }_k(\sum _{i=1}^k{\theta }_i=1) \end{gathered}$$

$\Theta$的先验：（狄利克雷分布？）
$$\begin{gathered} P(\Theta )=\frac{r({\alpha }_1+...+{\alpha }_k)}{r({\alpha }_1)+...+r({\alpha }_k)}{\theta }_1^{{\alpha }_1-1}{\theta }_2^{{\alpha }_2-1}...{\theta }_k^{{\alpha }_k-1} \\ 令{\alpha }_1={\alpha }_2=...={\alpha }_k=\alpha \\ P(\Theta |y_1,y_2,...y_N)=\frac{P(\Theta ,y_1,y_2,...y_N)}{P(y_1,y_2,...y_N)} \\ \propto P(\Theta )P((y_1,y_2,...y_N) \\ \propto {\theta }_1^{\alpha -1}{\theta }_2^{\alpha -1}...{\theta }_k^{\alpha -1}{\theta }_1^{m_1}{\theta }_2^{m_2}...{\theta }_k^{m_k} \\ \propto {\theta }_1^{m_1+\alpha -1}{\theta }_2^{m_2+\alpha -1}...{\theta }_k^{m_k+\alpha -1} \\ P(\Theta |y_1,y_2,...,y_N)=\frac{r(m_1+\alpha +m_2+\alpha +...+m_k+\alpha )}{r(m_1+\alpha )r(m_2+\alpha )...r(m_k+\alpha )}{\theta }_1^{m_1+\alpha -1}{\theta }_2^{m_2+\alpha -1}...{\theta }_k^{m_k+\alpha -1} \\ 因为我们需要的是最大化后验概率，所以系数可忽略，即： \\ max({\theta }_1^{m_1+\alpha -1}{\theta }_2^{m_2+\alpha -1}...{\theta }_k^{m_k+\alpha -1}) \\ 求得： \\ {\theta }_1=\frac{m_1+\alpha -1}{m_1+\alpha -1+m_2+\alpha -1+...+m_k+\alpha -1} \\ =\frac{m_1+\alpha -1}{N+k\alpha -k} \\ {\theta }_i=\frac{m_i+\alpha -1}{N+k(\alpha -1)}(\lambda =\alpha -1) \end{gathered}$$

代码实现

（1）自编程实现

import numpy as np
import pandas as pd
from collections import Counter
"""def main():
    x_train = np.array([[1,'S'],[1,'M'],[1,'M'],[1,'S'],[1,'S'],[2,'S'],[2,'M'],[2,'M'],[2,'L'],[2,'L'],[3,'L'],[3,'M'],[3,'M'],[3,'L'],[3,'L']])
    y_train = np.array([-1,-1,1,1,-1,-1,-1,1,1,1,1,1,1,1,-1])
    c = [1,-1]
    A = np.array([[1,2,3],['S','M','L']])
    s = np.array([2,'S'])
    landa = 1
    NB = neiveByeis(x_train,y_train, c, A, landa)
    prediction = NB.predict(s)
    
    print("s{}被分类为：{}".format(s,prediction))

class neiveByeis():
    def __init__(self, x_train, y_train, c, A, landa):
        self.x_train = x_train
        self.y_train = y_train
        self.A = A
        self.c = c
        self.landa = landa
    
    def predict(self,s):
        # 首先需要计算 p(y=c1), p(y=c2)...
        prediction_y = Counter(self.y_train)
        res = dict()
        p_c = []
        
        for i in range(len(self.c)):
            count = [0] * len(s)
            p_c.append((prediction_y[self.c[i]] + self.landa) / (len(self.y_train) + (self.landa * len(self.c))))
            res[self.c[i]] = p_c[i]

            for j in range(len(self.x_train)):
                if self.y_train[j] == self.c[i]:
                    for k in range(len(s)):
                        if self.x_train[j][k] == s[k]:
                            count[k] += 1 
            print("count:", count)

            for n in range(len(s)):
                res[self.c[i]] *=  ((count[n] + self.landa) / (prediction_y[self.c[i]] + (self.landa * len(self.A[i]))))
            
            print("{} 的概率为：{}".format(self.c[i],res[self.c[i]]))
        return max(res, key=res.get)
            
if __name__=="__main__":
    main()
              """      
                
# 优化版本：
class NaiveBayes():
    def __init__(self, lambda_):
        self.lambda_ = lambda_
        self.y_types_count = None # y的（类型：数量）
        self.y_types_proba = None # y的（类型：概率）
        self.x_types_proba = dict() # （xi 的编号，xi的取值， y的类型）：概率

    def fit(self, x_train, y_train):
        self.y_types = np.unique(y_train) # y的所有取值类型[1,2,3]
        X = pd.DataFrame(x_train)         # 转化为pandas DataFrame数据格式，下同
        y = pd.DataFrame(y_train)

        # y 的（类型：数量）统计
        self.y_types_count = y[0].value_counts()
        # y 的（类型：概率）计算
        self.y_types_proba = (self.y_types_count+self.lambda_) / (y.shape[0] + len(self.y_types) * self.lambda_)

        # (xi 的编号， xi的取值， y的类型): 概率的计算
        for idx in X.columns: # 遍历Xi
            print("第 {} 个特征： ".format(idx))
            for j in self.y_types: # 选取每一行的y的类型
                p_x_y = X[(y==j).values][idx].value_counts() # 选择所有y==j为真的数据点的idx个特征的值
                print("在 y = {} 时，对样本第 {} 个特征的频次的统计：\n {}".format(j, idx, p_x_y))
                for i in p_x_y.index: # 计算（xi的编号，xi的取值， y的类型）：概率
                    # print("第 {} 个特征的值为：{}".format(idx, i))
                    # 存储在y = j的情况下，第idx个特征的值为i的样本出现的概率（贝叶斯估计）
                    self.x_types_proba[(idx,i,j)] = (p_x_y[i]+self.lambda_)/(self.y_types_count[j]+p_x_y.shape[0])
            print("--------------")

    def predict(self,X_new):
        res = []
        for y in self.y_types: # 遍历y的可能取值
            p_y = self.y_types_proba[y] # 获取y的模型P(Y=Ck)
            p_xy = 1
            for idx, x in enumerate(X_new):
                p_xy *= self.x_types_proba[(idx,x,y)] # 计算P(X=(x1,x2...)/Y=Ck)
            res.append(p_y*p_xy)
        for i in range(len(self.y_types)):
            print("[{}]对应的概率：{:.2%}".format(self.y_types[i],res[i]))
        # 返回最大后验概率对应的y值
        return self.y_types[np.argmax(res)]

def main():
    x_train = np.array([[1,'S'],[1,'M'],[1,'M'],[1,'S'],[1,'S'],[2,'S'],[2,'M'],[2,'M'],[2,'L'],[2,'L'],[3,'L'],[3,'M'],[3,'M'],[3,'L'],[3,'L']])
    y_train = np.array([-1,-1,1,1,-1,-1,-1,1,1,1,1,1,1,1,-1])

    clf = NaiveBayes(lambda_ = 0.2)
    clf.fit(x_train, y_train)
    clf.fit(x_train, y_train)
    X_new = np.array([2,'S'])
    y_predict = clf.predict(X_new)
    print("{} 被分类为：{}".format(X_new, y_predict))

if __name__=="__main__":
    main()

（2）调用sklearn

def main():
    x_train = np.array([[1,'S'],[1,'M'],[1,'M'],[1,'S'],[1,'S'],[2,'S'],[2,'M'],[2,'M'],[2,'L'],[2,'L'],[3,'L'],[3,'M'],[3,'M'],[3,'L'],[3,'L']])
    y_train = np.array([-1,-1,1,1,-1,-1,-1,1,1,1,1,1,1,1,-1])
    x_new = np.array([[2,'S']])
    landa = 1

    # 对数据进行预处理
    enc = preprocessing.OneHotEncoder(categories='auto')
    enc.fit(x_train)
    x_train = enc.transform(x_train).toarray()

    clf = MultinomialNB(alpha=0.0000001)
    clf.fit(x_train, y_train)
    x_new = enc.transform(x_new).toarray()

    y_prediction = clf.predict(x_new)
    print("s {} 被分类为：{}".format(x_new, y_prediction))
    print("属于不同分类的概率：{}".format(clf.predict_proba(x_new)))

if __name__=="__main__":
    main()