机器学习实战 朴素贝叶斯分类器

基于概率论的分类方法： 朴素贝叶斯

我的微信公众号： s406205391; 欢迎大家一起学习，一起进步！！！

        k-近邻算法和决策树会给出“该数据属于哪一类”的明确回答。不过，分类器有时会产生错误结果，这是可以要求分类器给出一个最优的类别的猜测结果，同事给出这个猜测的概率估计值。

        朴素贝叶斯就是一个概率分类器。我们称之为“朴素”，是因为整个形式化的过程只做最原始、最简单的假设。朴素贝叶斯的优点：在数据较少的情况下仍然有效，可以处理多类别问题。缺点：对于输入数据的准备方式较为敏感。适用数据类型：标称型数据.贝叶斯决策理论的核心思想就是，选择高概率对应的类别。这里会应用到一种有效计算条件概率的方法，称为贝叶斯准则。

数据准备：构建词向量

        在应用贝叶斯分类算法之前，构建输入向量是很重要的一项。

        机器学习的一个重要应用就是文档的自动分类。在文档分类中，整个文档（如一封电子邮件）是实例，而电子邮件中的某些原色则构成特征。虽然电子邮件是一种会不断增加的文本，但我们同样也可以对新闻报道、用户留言、政府公文等其他任意类型的文本进行分类。我们可以观察文档中出现的词，并把每个词的出现或者不出现作为一个特征，这样得到的特征数目就会跟词汇表中的词数目一样多。

朴素贝叶斯的一般过程：

1. 收集数据：可以使用任何方法。

2. 准备数据：需要数值型或者布尔型数据

3. 分析数据：有大量特征时，绘制特征作用不大，此时使用直方图效果更好

4. 训练算法：计算不同的独立特征的条件概率

5. 测试算法：计算错误率

6. 使用算法：一个常见的朴素贝叶斯应用是文档分类。可以在任意的分类场景中使用朴素贝叶斯分类器，不一定非要是文本。

        朴素贝叶斯有一个很重要的假设，每个特征同等重要。

         现在我们通过如下函数去构建词向量。load_data_set()函数创建了一些实验样本，其中posting_list表示不同的文本，class_vec表示该文本的分类，0表示正常，1表示侮辱性文本。我们在处理真实文本时，首先也会把文本拆分成一个个单词组成的列表。create_vocab_list()函数会将词向量中的所有词，整合为不含重复词的列表。set_of _words_2_vec()函数会统计不含重复词的词向量在我们待统计的词向量中出现的次数。即最后我们会得到一个长度等于不含重复词的词向量的一个数值向量，其中的数值表示该词出现的次数。

def load_data_set():
    """构建模拟的词列表和标签"""

    posting_list = [['my', 'dog', 'has', 'flea', 'problems', 'help', 'pleas'],
                    ['maybe', 'not', 'take', 'him', 'to', 'dog', 'park', 'stupid'],
                    ['my', 'dalmation', 'is', 'so', 'cute', 'I', 'love', 'him'],
                    ['stop', 'posting', 'stupid', 'worthless', 'garbage'],
                    ['mr', 'licks', 'ate', 'my', 'steak', 'how', 'to', 'stop', 'him'],
                    ['quit', 'buying', 'worthless', 'dog', 'food', 'stupid']]
    class_vec = [0, 1, 0, 1, 0, 1]  # 1表示属于侮辱性词汇
    return posting_list, class_vec


def create_vocab_list(data_set):
    """将词矩阵中的所有词整合为不含重复词的列表"""

    vocab_set = reduce(lambda x, y: set(x) | set(y), data_set)
    return list(vocab_set)


def set_of_words_2_vec(vocab_list, input_set):
    """ 统计vocab_list中的词在input_set中出现的次数。
    
    :param vocab_list: 需要统计的词的列表
    :param input_set: 生成的不带重复词的词向量
    :return: 返回一个数字矩阵，0表示该词在vocab_list中未出现，3表示该次在vocab_list中出现了三次
    """
    
    return_vec = [0] * len(vocab_list)
    for word in input_set:
        if word in vocab_list:
            return_vec[vocab_list.index(word)] += 1
    return return_vec

训练算法：从词向量计算概率

        我们可以根据贝叶斯准则来计算文本属于侮辱性文本的概率。

w表示所有词的一个向量。

        p(c_i)表示文档属于侮辱性文档的概率，我们可以通过侮辱性文档的数量，除以文档总数，很方便的求的。p(w|c_i)表示每一个词在侮辱性文档中出现的概率，根据朴素贝叶斯假设，我们可以将w展开为一个个独立的特征,那么我们就可以将上述概率写作p(w₀|c_i)p(w₁|c_i)p(w₂|c_i)...p(w_n|c_i)来计算上述概率。

基本过程如下：

计算每个类别中的文档数目

对每篇训练文档：

        对每个类别：

                如果词条出现杂文档中，那么增加该词条的计数值

                增加所有词条的计数值

对每个类别：

        对每个词条：

​                将该词条的数目除以总词条数目得到条件概率

返回每个类别的条件概率

        我们在利用贝叶斯分类器对文档进行分类时，要计算多个概率的乘积，如果其中一个概率为0，那么最后的乘积也为0。为降低这种影响，我们将所有词的出现数初始化为1，并将分母初始化为2。另外一个问题是下溢，当很多很小的概率相乘时，程序会下溢，得不到正确答案。因此这里把概率转换成自然对数。

def train_nb(train_matrix, train_category):
    """ 计算训练矩阵中，每一个词属于不同分类的概率
    
    :param train_matrix:  待计算的词矩阵 
    :param train_category:  每一个文档的分类标签
    :return:  返回每个文档中每个词属于不同分类文档的概率
    """

    # 计算训练数据集中，侮辱性文本的概率
    num_train_docs = len(train_matrix)
    num_words = len(train_matrix[0])
    p_abusive = sum(train_category) / num_train_docs
    
    # 计算每个词属于不同分类文本的概率
    p0_num = np.ones(num_words)
    p1_num = np.ones(num_words)
    p0_denom = 2
    p1_denom = 2  # 分母为2，初始分子为0，为了防止概率过小导致概率为0
    for i in range(num_train_docs):
        if train_category[i] == 1:
            p1_num += train_matrix[i]
            p1_denom += sum(train_matrix[i])
        else:
            p0_num += train_matrix[i]
            p0_denom += sum(train_matrix[i])
    p1_vect = log(p1_num / p1_denom)
    p0_vect = log(p0_num / p0_denom)
    return p0_vect, p1_vect, p_abusive

构建朴素贝叶斯分类器

        在准备好上述函数后，就可以进行贝叶斯分类了。

def classify_nb(vec_2_classify, p0_vec, p1_vec, p_class):
    p1 = sum(vec_2_classify * p1_vec) + np.log(p_class)
    p0 = sum(vec_2_classify * p0_vec) + np.log(1 - p_class)
    if p1 > p0:
        return 1
    else:
        return 0

示例：使用朴素贝叶斯过滤垃圾邮件

        在email(提取码：lael)文件夹中，有两个子文件，分别表示垃圾邮件和正常邮件。我们首先将所有文件都整合成词向量矩阵，然后再随机取40封邮件作为训练数据集，10封邮件作为测试数据集。

#!/usr/bin/env python3
# coding: utf-8
# Author：Shen Yi
# Date ：2020/2/16 1:05

"""机器学习实战 朴素贝叶斯"""

from functools import reduce
from glob import glob
import numpy as np
import re


def load_data_set():
    """构建模拟的词列表和标签"""

    posting_list = [['my', 'dog', 'has', 'flea', 'problems', 'help', 'pleas'],
                    ['maybe', 'not', 'take', 'him', 'to', 'dog', 'park', 'stupid'],
                    ['my', 'dalmation', 'is', 'so', 'cute', 'I', 'love', 'him'],
                    ['stop', 'posting', 'stupid', 'worthless', 'garbage'],
                    ['mr', 'licks', 'ate', 'my', 'steak', 'how', 'to', 'stop', 'him'],
                    ['quit', 'buying', 'worthless', 'dog', 'food', 'stupid']]
    class_vec = [0, 1, 0, 1, 0, 1]
    return posting_list, class_vec


def create_vocab_list(data_set):
    """将词矩阵中的所有词整合为不含重复词的列表"""

    vocab_set = reduce(lambda x, y: set(x) | set(y), data_set)
    return list(vocab_set)


def set_of_words_2_vec(vocab_list, input_set):
    """ 统计vocab_list中的词在input_set中出现的次数。

    :param vocab_list: 需要统计的词的列表
    :param input_set: 生成的不带重复词的词向量
    :return: 返回一个数字矩阵，0表示该词在vocab_list中未出现，3表示该次在vocab_list中出现了三次
    """
    return_vec = [0] * len(vocab_list)
    for word in input_set:
        if word in vocab_list:
            return_vec[vocab_list.index(word)] += 1
    return return_vec


def train_nb(train_matrix, train_category):
    """ 计算训练矩阵中，每一个词属于不同分类的概率

    :param train_matrix:  待计算的词矩阵
    :param train_category:  每一个文档的分类标签
    :return:  返回每个文档中每个词属于不同分类文档的概率
    """

    num_train_docs = len(train_matrix)
    num_words = len(train_matrix[0])
    p_abusive = sum(train_category) / num_train_docs
    p0_num = np.ones(num_words)
    p1_num = np.ones(num_words)
    p0_denom = 2
    p1_denom = 2
    for i in range(num_train_docs):
        if train_category[i] == 1:
            p1_num += train_matrix[i]
            p1_denom += sum(train_matrix[i])
        else:
            p0_num += train_matrix[i]
            p0_denom += sum(train_matrix[i])
    p1_vect = np.log(p1_num / p1_denom)
    p0_vect = np.log(p0_num / p0_denom)
    return p0_vect, p1_vect, p_abusive


def classify_nb(vec_2_classify, p0_vec, p1_vec, p_class):
    p1 = sum(vec_2_classify * p1_vec) + np.log(p_class)
    p0 = sum(vec_2_classify * p0_vec) + np.log(1 - p_class)
    if p1 > p0:
        return 1
    else:
        return 0


def demo_filter_email():
    """示例：朴素贝叶斯过滤垃圾邮件"""
    
    # 生成词向量矩阵
    doc_list = []
    class_list = []
    full_text = []
    emails = glob('data\\Ch04\\email\\*\\*.txt')
    for email in emails:
        word_list = re.split(r'\W+', open(email).read())
        word_list = [word.lower() for word in word_list if len(word) > 2]
        doc_list.append(word_list)
        full_text.extend(word_list)
        if 'spam' in email:
            class_list.append(1)
        else:
            class_list.append(0)
    
    # 得到不重复的词向量
    vocab_list = create_vocab_list(doc_list)

    # 随机选取10封作为测试数据集
    training_set = list(range(50))
    test_set = []
    for i in range(10):
        rand_index = int(np.random.uniform(0, len(training_set)))
        test_set.append(training_set[rand_index])
        del(training_set[rand_index])

    # 对训练数据集进行训练
    train_mat = []
    train_classes = []
    for doc_index in training_set:
        train_mat.append(set_of_words_2_vec(vocab_list, doc_list[doc_index]))
        train_classes.append(class_list[doc_index])
    p0_vect, p1_vect, p_spam = train_nb(np.array(train_mat), np.array(train_classes))

    # 利用测试数据集，计算错误率
    error_count = 0
    for doc_index in test_set:
        word_vector = set_of_words_2_vec(vocab_list, doc_list[doc_index])
        if classify_nb(np.array(word_vector), p0_vect, p1_vect, p_spam) != class_list[doc_index]:
            error_count += 1
    print(f'the error rate is: {error_count / len(test_set)}')


if __name__ == '__main__':
    
    demo_filter_email()