机器学习之朴素贝叶斯（naive Bayes）算法

优缺点和适用范围

优点：

小量样本就可以训练好
可以处理多元集

缺点：

对数据过于敏感

适用范围：

非数值型数据

朴素贝叶斯概率模型

条件概率：
$p(C|F_1,F_2,F_3,....)$
其中C为类别， $F_1 F_2 F_3....$ 为不同的特征， $p(C|F_1, F_2, F_3,...)$ 为在已知 $F_1 F_2 F_3....$ 分别是什么的情况下C取某个值的概率
根据贝叶斯定理可知：
$p(C|F_1, F_2, F_3,...) = \frac{p(C)p(F_1, F_2, F_3,....|C)}{p(F_1, F_2, F_3,....)}$
而 $p(C)p(F_1, F_2, F_3,...|C)$
$\propto p(C)p(F_1|C)p(F_2, F_3, F_4,...|C, F_1)$
$\propto p(C)p(F_1|C)p(F_2|C)p(F_3, F_4,...|C, F_1, F_2)$
$\propto....$
$\propto p(C)p(F_1|C)p(F_2|C)....p(F_{n-1}|C)p(F_n|C, F_1, F_2, F_3,..., F_{n-1})$
由于条件独立假设（即，认为 $F_1 F_2 F_3...$ 之间相互独立，互不干扰，或者可以解释为当 $i \ne j$ 时 $p(F_i|F_j)=p(F_i)$ ）：
因此易得 $p(F_i|C, F_1, F_2, F_3,....) = p(F_i|C)$
从而可知:
$p(C)p(F_1, F_2, F_3,...|C) = p(C)p(F_1|C)p(F_2|C)....p(F_n|C)$
设 $Z = p(F_1, F_2, F_3,...,F_n)$

那么： $p(C|F_1, F_2, F_3,...) = \frac{1}{Z}p(C)p(F_1|C)p(F_2|C)....p(F_n|C)$

朴素贝叶斯分类器原理

总的分类类别有 $C:c_1, c_2, c_3....c_m$
首先我们使用第一个测试样本数据 $(f_1,f_2,f_3,...,f_n)$
计算 $p(C|F_1, F_2, F_3,...,F_n)$ , 更具体的：
$p(C=c_1|F_1=f_1, F_2=f_2, F_3=f_3,....,F_n=f_n)$
$p(C=c_2|F_1=f_1, F_2=f_2, F_3=f_3,....,F_n=f_n)$
$p(C=c_3|F_1=f_1, F_2=f_2, F_3=f_3,....,F_n=f_n)$
....
$p(C=c_m|F_1=f_1, F_2=f_2, F_3=f_3,....,F_n=f_n)$
从这些概率的值中挑选最大的那一个，对应的C的取值即为这个

比较好理解。
代码：

import numpy as np


def load_posts():
    """
    假装从邮件里加载了数据
    :return: 邮件里的数据， 相应文件的分类
    """
    posts = [['my', 'dog', 'has', 'flea', 'problems', 'help', 'please'],
             ['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 posts, class_vec


def create_corpus(posts):
    """
    创建语料库
    :param posts: 将加载的邮件中出现的所有词汇都加入到语料库中
    :return: 语料库
    :rtype: list
    """
    corpus = set([])
    for i in posts:
        corpus = corpus | set(i)
    return list(corpus)


def words_to_vec(corpus, words):
    """
    将词汇对应着语料库形成相应的向量
    :param corpus: 语料库
    :param words: 要"翻译" 的词汇
    :return: "翻译"后的向量
    """
    vec = [0] * len(corpus)
    for word in words:
        if word in corpus:
            vec[corpus.index(word)] = 1
        else:
            print("this word does not exist in corpus")
    return vec


def training(posts_matrix, class_matrix):
    """
    训练过程，实际上就是计算，P(C) P(F_1|C) P(F_2|C).. P(F_n|C)
    :param posts_matrix:
    :param class_matrix:
    :return:
    """
    length_of_posts = len(posts_matrix)
    length_of_words = len(posts_matrix[0])
    prob = sum(class_matrix)/float(length_of_posts)
    prob_class_0 = np.zeros(length_of_words)
    prob_class_1 = np.zeros(length_of_words)
    nums_class_0 = 0.0
    nums_class_1 = 0.0
    for i in range(0, length_of_posts):
        if class_matrix[i] == 1:
            prob_class_1 += posts_matrix[i]
            nums_class_1 += sum(posts_matrix[i])
        else:
            prob_class_0 += posts_matrix[i]
            nums_class_0 += (length_of_words - sum(posts_matrix[i]))
    prob_class_1 /= nums_class_1
    prob_class_0 /= nums_class_0
    return prob_class_0, prob_class_1, prob


def classify(prob_class_0, prob_class_1, prob, sample_vec):
    """
    进行分类，分别计算，已知特征的情况下 C 为0 或 1 的概率，比较，哪一个概率更大
    :param prob_class_0: P(F1|C=0) P(F2|C=0)... P(Fn|C=0)
    :param prob_class_1: P(F1|C=1) P(F2|C=1)... P(Fn|C=1)
    :param prob: P(C=1)
    :param sample_vec: 用于分类的样本
    :return: 分类结果
    """
    prob_0 = sum(prob_class_0 * sample_vec) + np.log(1.0 - prob)  # 挑出自己有的特征，进行乘法，取log
    prob_1 = sum(prob_class_1 * sample_vec) + np.log(prob)
    if prob_1 > prob_0:
        return 1
    else:
        return 0


posts, class_vec = load_posts()
corpus = create_corpus(posts)
posts_list = []
for i in posts:
    posts_list.append(words_to_vec(corpus, i))
prob_class_0, prob_class_1, prob = training(np.array(posts_list), np.array(class_vec))
sample = ['dog', 'my', 'stupid']
res = classify(prob_class_0, prob_class_1, prob, words_to_vec(corpus, sample))
print(res)

结果：