朴素贝叶斯算法

import numpy as np
import pandas as pd
lis = [
    ["dog", "cat", "fish"],
    ["lion", "tiger"],
    ["cat", "fish"],
    ["dog"],
]
bags = list(set([word for row in lis for word in row]))
vsm = np.zeros([len(lis), len(bags)])
for i, row in enumerate(lis):
    for word in row:
        vsm[i, bags.index(word)] += 1
vsm = pd.DataFrame(vsm, columns=bags)
print(vsm)

import numpy as np
import pandas as pd

class LoadDataSet(object):
    def get_dataSet(self):
        """lis是一行行文字切词后的文档集合，内容是斑点犬评论"""
        lis = [
            ["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"],
        ]
        vec= [0, 1, 0, 1, 0, 1]  # 1代表侮辱性文字，0代表正常言论；对应lis的6行数据
        return lis, vec

class NavieBayes(object):
    def __init__(self):
        self.Pcates = {}
        self.vocabulary  = None
        self.tf = None
    def train(self, trainSet, classVec):
        """训练集计算"""
        self.Pcates = {
            label:{
                "prob": classVec.count(label)/len(classVec),  # 记录P("属于某类")
                "tdm": None                                   # 记录p("具有某特征"|"属于某类")
            } for label in set(classVec)
}  # 计算每个类别的先验概率，保存成字典格式
        self.vocabulary = list(set([word for doc in trainSet for word in doc]))  # 生成词袋
        self.tf = self._tf_idf(trainSet)
        self._bulid_tdm(trainSet, classVec)
    
    def _tf_idf(self, trainSet):
        """生成tf和idf"""
        # 心中要有tf-idf矩阵
        vocLength = len(self.vocabulary)
        docLength = len(trainSet)
        idf = np.zeros([1, vocLength])  # 因为vocabulary是特征向量,所以写1 x N的向量,用以表示一个文档向量中葛格慈的频率
        tf = np.zeros([docLength, vocLength])  # tf矩阵：每个词的词频矩阵
        for i, doc in enumerate(trainSet):
            for word in doc:   # 统计每一行中的每个词在该行中出现的次数
                tf[i, self.vocabulary.index(word)] += 1  # 遍历每个词，计算其出现的次数并写到tf矩阵对应的位置
            tf[i] = tf[i] / len(trainSet[i])
            # 这一行的tf除以该行文件中的词总数(实际上就是row长度)以消除长短句的影响
            for singleword in set(doc):
                idf[0, self.vocabulary.index(singleword)] += 1  # 统计每个文档里的词在所有文档里出现的次数
            idf = np.log(len(trainSet) / (idf + 1))   # +1是为了防止0除
        return np.multiply(tf, idf)
    
    def _bulid_tdm(self, trainSet, classVec):
        """计算每个类别下每个词出现的概率"""
        tf_labels = np.c_[self.tf, labels]  # 在权重矩阵后面增加一列labels
        for label in self.Pcates.keys():
            label_tf_group = tf_labels[tf_labels[:, -1] == label][:, :-1]  # 获取label类对应的tf子矩阵
            label_tf = np.sum(label_tf_group, axis=0)/np.sum(label_tf_group)  # 行累加除以总值
            self.Pcates[label]["tdm"] = label_tf  # p("具有某特征"|"属于某类")
    
    def predict(self, test_wordList):
        """测试分类数据"""
        # 首先根据word_list生成词向量
        test_wordArray = np.zeros([1, len(self.vocabulary)])
        for word in test_wordList:
            test_wordArray[0, self.vocabulary.index(word)] += 1
        # 其次计算p("具有某特征"|"属于某类") * p("属于某类")
        # 不计算p("具有某特征")是因为假定对于每个测试的样本，它们具有的特征是完全随机的，都是一样的概率。
        pred_prob = 0
        pred_label = None
        for label, val in self.Pcates.items():
            test_prob = np.sum(test_wordArray * val["tdm"] * val["prob"])
            if test_prob > pred_prob:
                pred_prob = test_prob
                pred_label = label
        return {"predict_probability": round(pred_prob,4), "predict_label": pred_label}

load = LoadDataSet()
trainSet, labels = load.get_dataSet()
bayes = NavieBayes()
bayes.train(trainSet, labels)
bayes.predict(trainSet[0])

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

trainSet, labels = LoadDataSet().get_dataSet()
trainSet = [" ".join(row) for row in trainSet]

vectorizer = CountVectorizer()     # 用拼接的句子输入，它要生成svm，不接受长短不一的列表
transformer = TfidfTransformer()   # tf-idf权重矩阵

vsm = vectorizer.fit_transform(trainSet)  # 训练vsm模型
# print(vsm.toarray())  
# 更多方法请参阅 http://scikit-learn.org/stable/modules/feature_extraction.html#common-vectorizer-usage
tfidf = transformer.fit_transform(svm)    # 转换成tf-idf模型

# 生成测试用的数据
test = vectorizer.transform([trainSet[0]])
test = transformer.transform(test)

# 这里用混合贝叶斯模型；有兴趣的可以看伯努利模型、高斯模型
bys = naive_bayes.MultinomialNB()
bys.fit(tfidf, labels)

testData = trainSet[0]
bys.predict(test)