朴素贝叶斯

1.模型概述
2.后验最大化
3.参数估计
  3.1 最大似然估计
  3.2 贝叶斯估计
4.代码实现

模型概述

朴素贝叶斯（naive bayes) 是一种基于贝叶斯定理以及假设特征之间独立的分类算法。属于监督学习的一种。对于此模型，重点是基于两个理论，贝叶斯定理，后验最大概率估计。
贝叶斯定理： $P(Y|X) = \frac{P(X|Y)P(Y)}{P(X)}$
最大后验估计： $y = {\underset {c_k}{\operatorname {arg\max} }}\ P(c_k|X = x)$
给定x条件下，y的条件分布当中找一个使得y出现的概率最大的类别，然后用该类别作为预测结果，在这个预测过程中，分别计算出y等于每一个类别的概率，在求这些概率的时候，分母对于不同的类别取值是不变的，最大化条件概率就是最大化分子的值。 $P(Y|X) \rightarrow P(X|Y)P(Y)$ 贝叶斯公式里面，分子这一项有一个条件独立性的假设，来拆成N项的乘积(假设有N个特征） $P(X|Y) = \prod_{i=1}^{N}P(X^{(1)} = x^{(1)}|Y=c_k)$ 最终通过后验概率最大来进行分类，在这个模型里面，需要估计的参数是这两部分 $P(X|Y)$ , $P(Y)$ ，方法有极大似然估计，和贝叶斯估计。
极大似然估计里面可能出现一个比较尴尬的问题就是，某个条件的情况为0，训练集上数据比较少，分类的类别又比较多，其中一种类别，训练集没有相对应的实例。
贝叶斯估计为了使得不为0，在所有分子加上一项 $\lambda$ 。对于贝叶斯估计，对每一个参数给一个先验分布，Dirichlet分布，是beta分布在多维上的一个推广。

后验最大化

朴素贝叶斯中利用到了最大后验估计的原理，这里证明 $y = {\underset {c_k}{\operatorname {arg\max} }}\ P(c_k|X = x)$ 的等号成立的过程。
假设模型使用的是0-1损失函数 $L(Y,f(X)) = \begin{cases} 1, & Y \neq f(X)\\ 0, & Y {=} f(X) \end{cases}$
分类器的任务是使得期望风险函数最小 $min E \ L(Y,f(X))$

推导过程

参数估计

在模型里面，需要估计的是两部分 $P(Y = c_k)$ 和 $P(X = x|Y=c_k)$

极大似然估计

$P(Y = c_i) = \frac{\# \{y_j = c_i\}}{N},i = 1,2,...k$
$P(X^{(i)} = x^{(i)}|y = c_i) = \frac{\# \{y_j = c_i,X^{(i)} = x^{(i)} \}}{\# \{y_j = c_i \}}$

贝叶斯估计

极大似然估计的化可能会出现某些参数的值为0。使用贝叶斯估计可以避免这一情况，但是相应的也会复杂一些。
$Y \in \{ c_1,c_2,...,c_k\}$
对于每一个类别的概率的参数记作 $\theta ,\sum_{i = 1}^k \theta = 1$

当时，也叫拉普拉斯修正。

代码实现

class NaiveBayes():
    def __init__(self):
        self.lam = lam
    
    def fit(self,X,y):
        #prior 
        self.prior = {}
        counts_y = list(Counter(y).values())
        values = counts_y / np.sum(counts_y)
        keys = list(Counter(y).keys())
        for i in range(len(values)):
            self.prior[keys[i]] = values[i]
                
        #likelihood
        self.likelihood = {}
        for i in range(np.shape(X)[1]):
            x = X[:,i]
            counts_x = list(Counter(x).values())
            values = counts_x / (np.sum(counts_x) 
            keys = list(Counter(x).keys())
            for i in range(len(values)):
                self.likelihood[keys[i]] = values[i]
        
    def predict(self,X):
        posterioris = []
        
        for j in range(len(self.prior)):
            posteriori = 1
            for i in range(len(X)):     
                posteriori *= self.likelihood[X[i]]
            posteriori *= list(self.prior.values())[j]
            posterioris.append(posteriori)
            
        index = posterioris.index(max(posterioris))
        return list(prior.keys())[index]

朴素贝叶斯