【educoder 机器学习】朴素贝叶斯分类器

朴素贝叶斯分类算法是基于贝叶斯理论和属性条件独立假设的分类算法。对于给定的训练集，首先基于属性条件独立假设学习数据的概率分布。然后基于此模型，对于给定的特征数据x，利用贝叶斯定理计算出标签y。朴素贝叶斯分类算法实现简单，预测效率很高，是一种常用的分类算法。

本实训项目的主要内容是基于 Python 语言搭建朴素贝叶斯分类器，并使用sklearn 实现新闻文本进行主题分类的功能。

第1关：条件概率

1.A
2.C

第2关：贝叶斯公式

1.D
2.C

第3关：朴素贝叶斯分类算法流程

任务描述

本关任务：复习教材，填写python代码，完成fit与predict函数，分别实现模型的训练与预测。

import numpy as np


class NaiveBayesClassifier(object):
    def __init__(self):
        '''
        self.label_prob表示每种类别在数据中出现的概率
        例如，{0:0.333, 1:0.667}表示数据中类别0出现的概率为0.333，类别1的概率为0.667
        '''
        self.label_prob = {
    
    }#标签字典
        '''
        self.condition_prob表示每种类别确定的条件下各个特征出现的概率
        例如训练数据集中的特征为 [[2, 1, 1],
                              [1, 2, 2],
                              [2, 2, 2],
                              [2, 1, 2],
                              [1, 2, 3]]
        标签为[1, 0, 1, 0, 1]
        那么当标签为0时第0列的值为1的概率为0.5，值为2的概率为0.5;
        当标签为0时第1列的值为1的概率为0.5，值为2的概率为0.5;
        当标签为0时第2列的值为1的概率为0，值为2的概率为1，值为3的概率为0;
        当标签为1时第0列的值为1的概率为0.333，值为2的概率为0.666;
        当标签为1时第1列的值为1的概率为0.333，值为2的概率为0.666;
        当标签为1时第2列的值为1的概率为0.333，值为2的概率为0.333,值为3的概率为0.333;
        因此self.label_prob的值如下：     
        {
            0:{
                0:{
                    1:0.5
                    2:0.5
                }
                1:{
                    1:0.5
                    2:0.5
                }
                2:{
                    1:0
                    2:1
                    3:0
                }
            }
            1:
            {
                0:{
                    1:0.333
                    2:0.666
                }
                1:{
                    1:0.333
                    2:0.666
                }
                2:{
                    1:0.333
                    2:0.333
                    3:0.333
                }
            }
        }
        '''
        self.condition_prob = {
    
    }#条件特征字典
    def fit(self, feature, label):
        '''
        对模型进行训练，需要将各种概率分别保存在self.label_prob和self.condition_prob中
        :param feature: 训练数据集所有特征组成的ndarray
        :param label:训练数据集中所有标签组成的ndarray
        :return: 无返回
        '''
        row_num = len(feature)#标签行数
        col_num = len(feature[0])#列数
        #计算每个类别的个数
        for c in label:
            if c in self.label_prob:
                self.label_prob[c] += 1
            else:
                self.label_prob[c] = 1
        for key in self.label_prob.keys():
            # 计算每种类别在数据集中出现的概率
            self.label_prob[key] /= row_num
            # 构建self.condition_prob中的key(即标签中的每个类别)
            self.condition_prob[key] = {
    
    }
            #循环每一个特征列、
            #构建标签下边每列特征的字典
            for i in range(col_num):
                self.condition_prob[key][i] = {
    
    }
                #np.unique是去除数组中的重复数字，并进行排序之后输出。
                for k in np.unique(feature[:, i], axis=0):
                    self.condition_prob[key][i][k] = 0#对特征类别进行初始化
        #对概率进行初始化
        for i in range(len(feature)):
            for j in range(len(feature[i])):
                self.condition_prob[label[i]][j][feature[i][j]] += 1
        for label_key in self.condition_prob.keys():
            for k in self.condition_prob[label_key].keys():
                total = 0
                for v in self.condition_prob[label_key][k].values():
                    total += v#计算标签为label_key，第k列的所有特征总数
                #计算每种类别确定的条件下各个特征出现的概率
                #********* Begin *********#
                for kk in self.condition_prob[label_key][k].keys():
                    #获取标签为label_key，第k列的值为kk的数量
                    self.condition_prob[label_key][k][kk] /= total
                #********* End *********#


    def predict(self, feature):
        '''
        对数据进行预测，返回预测结果
        :param feature:测试数据集所有特征组成的ndarray
        :return:
        '''
        # ********* Begin *********#
        result = []
        #对每条测试数据都进行预测
        for i, f in enumerate(feature):
            #可能的类别的概率
            prob = np.zeros(len(self.label_prob.keys()))
            ii = 0
            for label, label_prob in self.label_prob.items():
                #计算概率
                prob[ii] = label_prob
                for j in range(len(feature[0])):
                    prob[ii] *= self.condition_prob[label][j][f[j]]
                ii += 1
            #取概率最大的类别作为结果
            result.append(list(self.label_prob.keys())[np.argmax(prob)])
        return np.array(result)
        #********* End *********#

第4关：拉普拉斯平滑

任务描述

本关任务：填写python代码，完成fit函数，实现模型训练功能。(PS:fit函数中没有平滑处理的话是过不了关的哦)

import numpy as np

class NaiveBayesClassifier(object):
    def __init__(self):
        '''
        self.label_prob表示每种类别在数据中出现的概率
        例如，{0:0.333, 1:0.667}表示数据中类别0出现的概率为0.333，类别1的概率为0.667
        '''
        self.label_prob = {
    
    }
        '''
        self.condition_prob表示每种类别确定的条件下各个特征出现的概率
        例如训练数据集中的特征为 [[2, 1, 1],
                              [1, 2, 2],
                              [2, 2, 2],
                              [2, 1, 2],
                              [1, 2, 3]]
        标签为[1, 0, 1, 0, 1]
        那么当标签为0时第0列的值为1的概率为0.5，值为2的概率为0.5;
        当标签为0时第1列的值为1的概率为0.5，值为2的概率为0.5;
        当标签为0时第2列的值为1的概率为0，值为2的概率为1，值为3的概率为0;
        当标签为1时第0列的值为1的概率为0.333，值为2的概率为0.666;
        当标签为1时第1列的值为1的概率为0.333，值为2的概率为0.666;
        当标签为1时第2列的值为1的概率为0.333，值为2的概率为0.333,值为3的概率为0.333;
        因此self.label_prob的值如下：     
        {
            0:{
                0:{
                    1:0.5
                    2:0.5
                }
                1:{
                    1:0.5
                    2:0.5
                }
                2:{
                    1:0
                    2:1
                    3:0
                }
            }
            1:
            {
                0:{
                    1:0.333
                    2:0.666
                }
                1:{
                    1:0.333
                    2:0.666
                }
                2:{
                    1:0.333
                    2:0.333
                    3:0.333
                }
            }
        }
        '''
        self.condition_prob = {
    
    }

    def fit(self, feature, label):
        '''
        对模型进行训练，需要将各种概率分别保存在self.label_prob和self.condition_prob中
        :param feature: 训练数据集所有特征组成的ndarray
        :param label:训练数据集中所有标签组成的ndarray
        :return: 无返回
        '''
        row_num = len(feature)
        col_num = len(feature[0])
        unique_label_count = len(set(label))
        #计算每个类别的个数
        for c in label:
            if c in self.label_prob:
                self.label_prob[c] += 1
            else:
                self.label_prob[c] = 1
        for key in self.label_prob.keys():
            # 计算每种类别在数据集中出现的概率，拉普拉斯平滑
            # ********* Begin ******#
            self.label_prob[key] += 1
            self.label_prob[key] /= (row_num + unique_label_count)
            #********* End *********#
            # 构建self.condition_prob中的key
            self.condition_prob[key] = {
    
    }
            #循环每一个特征列、
            #构建标签下边每列特征的字典，对特征类别进行初始化
            for i in range(col_num):
                self.condition_prob[key][i] = {
    
    }
                for k in np.unique(feature[:, i], axis=0):
                    self.condition_prob[key][i][k] = 1
        #对概率进行初始化
        for i in range(len(feature)):
            for j in range(len(feature[i])):
                self.condition_prob[label[i]][j][feature[i][j]] += 1
        for label_key in self.condition_prob.keys():
            for k in self.condition_prob[label_key].keys():
                #拉普拉斯平滑
                # ********* Begin ******#
                total = len(self.condition_prob[label_key].keys())
                # ********* End *********#
                for v in self.condition_prob[label_key][k].values():
                    total += v#计算标签为label_key，第k列的所有特征总数
                for kk in self.condition_prob[label_key][k].keys():
                    # 计算每种类别确定的条件下各个特征出现的概率
                    #获取标签为label_key，第k列的值为kk的数量
                    self.condition_prob[label_key][k][kk] /= total
    def predict(self, feature):
        '''
        对数据进行预测，返回预测结果
        :param feature:测试数据集所有特征组成的ndarray
        :return:
        '''
        result = []
        # 对每条测试数据都进行预测
        for i, f in enumerate(feature):
            # 可能的类别的概率
            prob = np.zeros(len(self.label_prob.keys()))
            ii = 0
            for label, label_prob in self.label_prob.items():
                # 计算概率
                prob[ii] = label_prob
                for j in range(len(feature[0])):
                    prob[ii] *= self.condition_prob[label][j][f[j]]
                ii += 1
            # 取概率最大的类别作为结果
            result.append(list(self.label_prob.keys())[np.argmax(prob)])
        return np.array(result)

第5关：新闻文本主题分类

from sklearn.feature_extraction.text import CountVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.feature_extraction.text import TfidfTransformer


def news_predict(train_sample, train_label, test_sample):
    '''
    训练模型并进行预测，返回预测结果
    :param train_sample:原始训练集中的新闻文本，类型为ndarray
    :param train_label:训练集中新闻文本对应的主题标签，类型为ndarray
    :param test_sample:原始测试集中的新闻文本，类型为ndarray
    :return 预测结果，类型为ndarray
    '''

    #********* Begin *********#
    #实例化向量化对象
    vec = CountVectorizer()
    #将训练集中的新闻向量化
    X_train_count_vectorizer = vec.fit_transform(train_sample)
    #将测试集中的新闻向量化
    X_test_count_vectorizer = vec.transform(test_sample)

    #实例化tf-idf对象
    tfidf = TfidfTransformer()
    #将训练集中的词频向量用tf-idf进行转换
    X_train = tfidf.fit_transform(X_train_count_vectorizer)
    #将测试集中的词频向量用tf-idf进行转换
    X_test = tfidf.transform(X_test_count_vectorizer)

    clf = MultinomialNB(alpha = 0.01)
    clf.fit(X_train, train_label)
    result = clf.predict(X_test)
    return result
    #********* End *********#