离散型朴素贝叶斯实现

MultinomialNB的实现与评估

对于离散型朴素贝叶斯模型的实现，由于核心算法都是在进行“计数”工作，所以问题的关键就转换为了如何进行计数。

幸运的是，Numpy中的一个方法：bincount就是专门明来计数的，它能够非常快速地数出一个数组中各个数字出现的频率；

而且由于它是 Numpy自带的方法，其速度比 Python标准库 collections中的计数器 Counter还要快上非常多，

不幸的是，该方法有如下两个缺点：

• 只能处理非负整数型的数组
• 向量中的最大值即为返回的数组的长度,换句话说，如果用 bincount方法对一个长度为1、元素为1000的数组计数，返回的结果就是999个0加1个1

所以做数据预处理时就要充分考虑到这两点，具体代码如下：

#导入基本架构
from Basic import *

class MultinomialNB(NaiveBayes):
    #定义预处理数据的方法
    def feed_data(self,x,y,sample_weight=None):
        #分情况将输入向量x进行转置
        if isinstance(x,list):
            features = map(list,zip(*x))
        else:
            features = x.T

        #利用python中内置的高级数据结构----集合，获取各个维度的特征和类别种类
        #为了利用bincount方法来优化算法，将所有特征从0开始数值化
        #PS:需要将数值化过程中的转换关系记录成字典，否则无法对新数据进行判断
        features = [set(feat) for feat in features]
        feat_dics = [{_l: i for i,_l in enumerate(feats)} for feats in features]
        label_dic = {_l: i for i ,_l in enumerate(set(y))}

        #利用转换字典更新训练集
        x = np.array([[feat_dics[i][_l] for i,_l in enumerate(sample)] for sample in x])
        y = np.array([label_dic[yy] for yy in y])

        #利用numpy中的bincounter方法，获得各类别的数据的个数
        cat_counter = np.bincounter(y)
        #记录各维度特征的取值个数
        n_possibilities = [len(feats) for feats in features]
        #获得各类别数据的下标
        labels = [y == value for value in range(len(cat_counter))]
        #利用下标获取记录按类别分开后的输入数据的数组
        labelled_x = [x[ci].T for ci in labels]

        #更新模型的各个属性
        self._X , self_y = x,y
        self._labelled_x , self._label_zip = labelled_x,list(zip(labels,labelled_x))
        (self._cat_counter, self._feat_dics, self._n_possibilities) = (
            cat_counter, feat_dics, n_possibilities)
        self.label_dic = {i: _l for _l, i in label_dic.items()}

        #调用处理样本权重的函数，以更新记录条件概率的数组
        self.feed_samle_weight(sample_weight)

    #定义处理样本权重的函数
    def feed_samle_weight(self,sample_weight=None):
        self._con_counter = []
        #利用numpy的bincounter方法获取带权重的条件概率的极大似然估计
        for dim, _p in enumerate(self._n_possibilities):
            if sample_weight is None:
                self._con_counter.append([np.bincount(xx[dim], minlength=_p) for xx in self._labelled_x])
            else:
                self._con_counter.append([
                    np.bincount(xx[dim], weights=sample_weight[label] / sample_weight[label].mean(), minlenght= _p)
                    for label, xx in self._label_zip])

PS:这样做会让训练过程加速很多但是同时也会使预测过程的速度下降一些（原因在于预测时要先将输入数据数值化）；视具体情况不同，数据预处理可以有不同实现。

由于在数据预处理这一块做了大量工作，核心函数就变为调用与整合数据预处理时记录下来的信息的过程：

#定义核心训练函数
    def _fit(self,lb):
        n_dim = len(self._n_possibilities)
        n_category = len(self._cat_counter)
        p_category = self.get_prior_probability(lb)
        #data即为存储加了平滑项后的条件概率的数组
        data = [None] * n_dim
        for dim, n_possibilities in enumerate(self._n_possibilities):
            data[dim] = [[
                (self._con_counter[dim][c][p] + lb) / (self._cat_counter[c] + lb * n_possibilities)
                for p in range(n_possibilities)
                ]for c in range(n_category)]
        self._data = [np.array(dim.info) for dim_info in data]

        #利用data生成决策函数
        def func(input_x, tar_category):
            rs = 1
            #遍历各个维度，利用data和条件独立性假设计算联合条件概率
            for d, xx in enumerate(input_x):
                rs *= data[d][tar_category][xx]
            #利用先验概率和联合条件概率计算后验概率
            return rs * p_category[tar_category]
        #返回决策函数
        return func

    #定义数值化数据的函数
    def _transfer_x(self,x):
        #遍历每个元素，利用转换字典进行数值化
        for j,char in enumerate(x):
            x[j] = self._feat_dics[j][char]
        return x

至此，第一个能用的朴素贝叶斯模型就完全搭建完毕了，可以拿气球数据集1.0和1.5来简单的评估模型。

接下来定义一个能够将文件中的数据转化为python数组的类：

class DataUtil:
    #定义一个方法使其能从文件中读取数据
    #该方法接受五个参数：
    #数据集的名字、数据集的路径、训练样本数、类别所在列、是否打乱数据
    def get_dataset(name,path,train_num=None,tar_idx=None,shuffle=True):
        x = []
        #将编码设为，以便读入中文等特殊字符
        #...
        with open(path,'r') as file:
            if 'balloon' in name:
                for sample in file:
                    x.append(sample.strip().split(','))
        #默认打乱数据
        if shuffle:
            np.random.shuffle(x)
        #默认类别在最后一列
        tar_idx = -1 if tar_idx is None else tar_idx
        y = np.array([xx.pop(tar_idx) for xx in x])
        x = np.array(x)
        #默认全部是训练样本
        if train_num is None:
            return x,y
        #若传入训练样本数，则切分为训练集和测试集
        return (x[:train_num],y[:train_num]),(x[train_num],y[train_num])

接下来就是评估用的代码：

if __name__ == '__main__':
    #导入标准库time以计时，导入DataUtil类以获取数据
    import time
    from Util import DataUtil
    #遍历1.0、1.5两个版本的气球数据集
    for dataset in (' balloon1.0.txt','balloon1.5.txt'):
        #读入数据
        _x, _y = DataUtil.get_dataset(dataset, "{}".format(dataset))
        #实例化模型并进行训练、同时记录整个过程花费的时间
        learning_time = time.time()
        nb = MultinomialNB()
        nb.fit(_x,_y)
        learning_time = time.time()

        #评估模型的表现，同时记录评估过程花费的时间
        estimation_time = time.time() - estimation_time

        #将记录下来的耗时输出
        print(
            'Model building : {:12.6} s
'
            'Estimation     : {:12.6} s
'
            'Total          : {:12.6} s'.format(
                learning_time, estimation_time, learning_time + estimation_time)
        )