Python 朴素贝叶斯的算法

朴素贝叶斯算法python实现
朴素贝叶斯是一种十分简单的分类算法，称其朴素是因为其思想基础的简单性，就文本分类而言，他认为词袋中的两两词之间的关系是相互独立的，即一个对象的特征向量中的每个维度都是互相独立的。这是朴素贝叶斯理论的思想基础。

朴素贝叶斯分类的正式定义：

设x={}为一个待分类项，而每个a为x的一个特征属性
有类别集合C={}
计算P(|x)，P(|x)，…，P(|x)
如果P(|x)=max{ P(|x)，P(|x)，…，P(|x)}，则x
那么关键就是如何计算第三步中的各个条件概率，我们可以这样计算：

找到一个已知分类的待分类项集合，即训练集
统计得到在各类别下各个特征属性的条件概率估计，即：
P()，P()，…，P()

P()，P()，…，P()

P()，P()，…，P()

如果各个特征属性是条件独立的（或者假设他们之间是相互独立的），根据贝叶斯定理，有如下推导：

因为分母对于所有类别为常数，只要将分子最大化即可，又因为各特征属性是条件独立的，根据上述分析，朴素贝叶斯分类的流程可以表示如下：
训练数据生成样本集：TF-IDF
对每个类别计算P()
对每个特征属性计算所有划分的条件概率
对每个类别计算P(x|)P()
以P(x|)P()的最大项作为x的所属类别
朴素贝叶斯的算法实现
首先创建一个Nbayes_pre.py文件来编写导入的数据和朴素贝叶斯类的代码:

#高斯朴素贝耶斯 
import numpy as np 
from sklearn.model_selection import train_test_split
import pandas as pd
from sklearn.naive_bayes import GaussianNB 
from sklearn.naive_bayes import BernoulliNB #伯努利分布
from sklearn.naive_bayes import MultinomialNB 
from sklearn.neighbors import KNeighborsClassifier
clf = GaussianNB().fit(X, Y) 
clf_pf = GaussianNB().partial_fit(X, Y, np.unique(Y)) 
##伯努利分布 
clf = BernoulliNB() 
clf.fit(train_data, train_target) 
BernoulliNB(alpha=1.0, binarize=0.0, class_prior=None, fit_prior=True)
#多项式分布
from sklearn.naive_bayes import MultinomialNB 
clf = MultinomialNB().fit(x_train, y_train) 
def getdatafromcsv():
data=pd.read_csv('iris .csv')
cols=['Sepal.Length','Sepal.Width','Petal.Length','Petal.Width']
train_target=data['Species']
train_data=data[cols]
return train_data,train_target
#第一个为身高，第二个值为体重(kg),第三个为性别,1为男，2为女
x_train = [[160, 60, 1], [155, 80, 1], [178, 53, 2], [158, 53, 2], [166, 45, 2], [170, 50, 2], [156, 56, 2], 
[166, 50, 1], [175, 55, 1], [188, 68, 1], [159, 41, 2], [166, 70, 1], [175, 85, 1], [188, 98, 1], 
[159, 61, 2]] 
#1为胖，0为瘦
y_train = [1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1] 
x_test = [[166, 45, 2], [172, 52, 1], [156, 60, 1], [150, 70, 2],[166,60,1]] 
train_data,train_target=getdatafromcsv()
x_train,x_test,y_train,y_test=train_test_split(train_data,train_target,test_size=0.1)
def predcitbyts(train_data,train_target,test_data):
clf = GaussianNB().fit(train_data,train_target) 
predict=clf.predict(test_data)
print("高斯贝耶斯结果:",predict)
clf_pf = GaussianNB().partial_fit(train_data, train_target, np.unique(train_target)) 
predict1=clf_pf.predict(test_data)
print("高斯贝耶斯结果partial_fit:",predict1)
def predictknn(train_data,train_target,test_data):
knn = KNeighborsClassifier()
knn.fit(train_data, train_target)
iris_y_predict = knn.predict(test_data)
print("KNN结果：",iris_y_predict)
def Bernoulli(train_data,train_target,test_data):
clf = BernoulliNB() 
clf.fit(train_data, train_target) 
BernoulliNB(alpha=1.0, binarize=0.0, class_prior=None, fit_prior=True) 
predict=clf.predict(test_data)
print(predict)
#多项式
def Multinomial(train_data,train_target,test_data):
clf = MultinomialNB().fit(x_train, y_train) 
predict=clf.predict(test_data)
print(predict)
Multinomial(x_train,y_train,x_test)
print(y_test)

例子：屏蔽社区留言板的侮辱性言论

"""
贝叶斯公式
p(xy)=p(x|y)p(y)=p(y|x)p(x)
p(x|y)=p(y|x)p(x)/p(y)
"""
import numpy as np
# 屏蔽社区留言板的侮辱性言论

class SpeechJudgment(object):
    def load_data_set(self):
        # 单词列表
        posting_list = [
            ['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', 'gar e'],
            ['mr', 'licks', 'ate', 'my', 'steak', 'how', 'to', 'stop', 'him'],
            ['quit', 'buying', 'worthless', 'dog', 'food', 'stupid']]
        # 属性类别列表 1 -> 侮辱性的文字, 0 -> not
        class_vec = [0, 1, 0, 1, 0, 1]
        return posting_list, class_vec

    def create_vocab_list(self, data_set):
        vocab_set = set()
        for item in data_set:
            vocab_set = vocab_set | set(item)
        # 不含重复元素的单词列表
        return list(vocab_set)

    def set_of_words2vec(self, vocab_list, input_set):
        result = [0] * len(vocab_list)
        for word in input_set:
            if word in vocab_list:
                # 如单词在输入文档出现过，则标记为1，否则为0
                result[vocab_list.index(word)] = 1
        return result

    def train_naive_bayes(self, train_mat, train_category):
        train_doc_num = len(train_mat)
        words_num = len(train_mat[0])
        pos_abusive = np.sum(train_category) / train_doc_num
        # 创建一个长度为words_num的都是1的列表
        p0num = np.ones(words_num)
        p1num = np.ones(words_num)
        p0num_all = 2.0
        p1num_all = 2.0
        for i in range(train_doc_num):
            if train_category[i] == 1:
                p1num += train_mat[i]
                p1num_all += np.sum(train_mat[i])
            else:
                p0num += train_mat[i]
                p0num_all += np.sum(train_mat[i])
        p1vec = np.log(p1num / p1num_all)
        p0vec = np.log(p0num / p0num_all)
        return p0vec, p1vec, pos_abusive

    def classify_naive_bayes(self, vec_to_classify, p0vec, p1vec, p_class1):
        p1 = np.sum(vec_to_classify * p1vec) + np.log(p_class1)
        p0 = np.sum(vec_to_classify * p0vec) + np.log(1 - p_class1)
        if p1 > p0:
            return 1
        else:
            return 0

    def bag_words_to_vec(self, vocab_list, input_set):
        result = [0] * len(vocab_list)
        for word in input_set:
            if word in vocab_list:
                result[vocab_list.index(word)] += 1
            else:
                print('the word: {} is not in my vocabulary'.format(word))
        return result

    def testing_naive_bayes(self):
        list_post, list_classes = self.load_data_set()
        vocab_list = self.create_vocab_list(list_post)
        train_mat = []
        for post_in in list_post:
            train_mat.append(self.set_of_words_to_vec(vocab_list, post_in))
        p0v, p1v, p_abusive = self.train_naive_bayes(np.array(train_mat), np.array(list_classes))
        test_one = ['love', 'my', 'dalmation']
        test_one_doc = np.array(self.set_of_words2vec(vocab_list, test_one))
        print('the result is: {}'.format(self.classify_naive_bayes(test_one_doc, p0v, p1v, p_abusive)))
        test_two = ['stupid', 'garbage']
        test_two_doc = np.array(self.set_of_words2vec(vocab_list, test_two))
        print('the result is: {}'.format(self.classify_naive_bayes(test_two_doc, p0v, p1v, p_abusive)))