贝叶斯算法原理及实现

（一）原理
设每个数据样本用一个n维特征向量来描述n个属性的值，即：X={x1，x2，…，xn}，假定有m个类，分别用C1, C2,…，Cm表示。给定一个未知的数据样本X（即没有类标号），若朴素贝叶斯分类法将未知的样本X分配给类Ci，则一定是
P(Ci|X)>P(Cj|X) 1≤j≤m，j≠i
根据贝叶斯定理有P(Ci|X)=P(X|Ci)P(Ci)/ P(X)
由于P(X)对于所有类为常数，最大化后验概率P(Ci|X)可转化为最大化先验概率P(X|Ci)P(Ci)。如果训练数据集有许多属性和元组，计算P(X|Ci)的开销可能非常大，为此，通常假设各属性的取值互相独立，这样
先验概率P(x1|Ci)，P(x2|Ci)，…，P(xn|Ci)可以从训练数据集求得。
（二）例子解释

（三）代码实现

from collections import defaultdict
import numpy as np
from sklearn.model_selection import train_test_split
from loguru import logger


class NaiveBayesScratch():
    """朴素贝叶斯算法Scratch实现"""

    def __init__(self):
        // 存储先验概率，即类别为ck的概率 P(Y=ck)
        self._prior_prob = defaultdict(float)
        // 存储似然概率 P(X|Y=ck)
        self._likelihood = defaultdict(defaultdict)
        // 存储每个类别的样本在训练集中出现次数
        self._ck_counter = defaultdict(float)
        // 存储每一个特征可能取值的个数
        self._Sj = defaultdict(float)

    def fit(self, X, y):
        """
        模型训练，参数估计使用贝叶斯估计
        X:
            训练集，每一行表示一个样本，每一列表示一个特征或属性
        y:
            训练集标签
        """
      //样本个数和特征个数
        n_sample, n_feature = X.shape
        // 计算每个类别可能的取值以及每个类别样本个数
        ck, num_ck = np.unique(y, return_counts=True)
        //每个类别出现的次数
        self._ck_counter = dict(zip(ck, num_ck))
        //遍历每个类别出现的次数，然后计算先验概率
        for label, num_label in self._ck_counter.items():
            // 计算先验概率(每个类别出现的概率)，做了拉普拉斯平滑处理
            self._prior_prob[label] = (num_label + 1) / (n_sample + ck.shape[0])

        //记录每个类别样本对应的索引
        ck_idx = []
        for label in ck:
            label_idx = np.squeeze(np.argwhere(y == label))
            ck_idx.append(label_idx)

        // 遍历每个类别,idx为label对应的索引
        for label, idx in zip(ck, ck_idx):
            //得到对应label的样本
            xdata = X[idx]
            // 记录该类别所有特征对应的概率
            label_likelihood = defaultdict(defaultdict)
            // 遍历每个特征
            for i in range(n_feature):
                // 记录该特征每个取值对应的概率
                feature_val_prob = defaultdict(float)
                // 获取该列特征可能的取值和每个取值出现的次数
                feature_val, feature_cnt = np.unique(xdata[:, i], return_counts=True)
                //第i维特征可能的取值的个数
                self._Sj[i] = feature_val.shape[0]
                feature_counter = dict(zip(feature_val, feature_cnt))
                //遍历每一个特征取值和取值的个数
                for fea_val, cnt in feature_counter.items():
                    // 计算该列特征每个取值的概率，做了拉普拉斯平滑
                    feature_val_prob[fea_val] = (cnt + 1) / (self._ck_counter[label] + self._Sj[i])
                //把每一个特征的取值和取值的概率存储到对应的特征中
                label_likelihood[i] = feature_val_prob
            //把每一个类别的每一个特征取值的概率存储到对应的类别中(似然概率)
            self._likelihood[label] = label_likelihood

    def predict(self, x):
        """
        输入样本，输出其类别，本质上是计算后验概率
        **注意计算后验概率的时候对概率取对数**，概率连乘可能导致浮点数下溢，取对数将连乘转化为求和
        """
        // 保存分类到每个类别的后验概率
        post_prob = defaultdict(float)
        // 遍历每个类别计算后验概率
        for label, label_likelihood in self._likelihood.items():
            prob = np.log(self._prior_prob[label])
            // 遍历样本每一维特征
            for i, fea_val in enumerate(x):
                feature_val_prob = label_likelihood[i]
                // 如果该特征值出现在训练集中则直接获取概率
                if fea_val in feature_val_prob:
                    prob += np.log(feature_val_prob[fea_val])
                else:
                    // 如果该特征没有出现在训练集中则采用拉普拉斯平滑计算概率
                    laplace_prob = 1 / (self._ck_counter[label] + self._Sj[i])
                    prob += np.log(laplace_prob)
            post_prob[label] = prob
        prob_list = list(post_prob.items())
        prob_list.sort(key=lambda v: v[1], reverse=True)
        // 返回后验概率最大的类别作为预测类别
        return prob_list[0][0]

def file2matrix(filename):
    fr = open(filename)
    arrayOLines = fr.readlines()
    numberOfLines = len(arrayOLines)
    returnMat = np.zeros((numberOfLines,4))
    classLabelVector = []
    index = 0
    for line in arrayOLines:
        line = line.strip()
        listFromLine = line.split(',')
        returnMat[index, :] = listFromLine[0:4]
        if listFromLine[-1] == 'Iris-setosa':
             classLabelVector.append(1)
        elif listFromLine[-1] == 'Iris-versicolor':
             classLabelVector.append(2)
        elif listFromLine[-1] == 'Iris-virginica':
             classLabelVector.append(3)
        index += 1
    return returnMat, classLabelVector

def main():
    filename='../datanotdill/Iris.csv'
    X, y = file2matrix(filename)
    xtrain, xtest, ytrain, ytest = train_test_split(X, y, train_size=0.8, shuffle=True)

    model = NaiveBayesScratch()
    model.fit(xtrain, ytrain)

    n_test = xtest.shape[0]
    n_right = 0
    for i in range(n_test):
        y_pred = model.predict(xtest[i])
        if y_pred == ytest[i]:
            n_right += 1
        else:
            logger.info("该样本真实标签为：{}，但是Scratch模型预测标签为：{}".format(ytest[i], y_pred))
    logger.info("Scratch模型在测试集上的准确率为：{}%".format(n_right * 100 / n_test))

if __name__ == "__main__":
    main()