精华内容
下载资源
问答
  • 朴素贝叶斯算法python
    2018-01-19 15:44:03

    本代码实现了朴素贝叶斯分类器(假设了条件独立的版本),常用于垃圾邮件分类,进行了拉普拉斯平滑

    关于朴素贝叶斯算法原理可以参考博客中原理部分的博文。

    #!/usr/bin/python
    # -*- coding: utf-8 -*-
    from math import log
    from numpy import*
    import operator
    import matplotlib
    import matplotlib.pyplot as plt
    from os import listdir
    def loadDataSet():
        postingList=[['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']]
        classVec = [0,1,0,1,0,1]
        return postingList,classVec
    def createVocabList(dataSet):
        vocabSet = set([])  #create empty set
        for document in dataSet:
            vocabSet = vocabSet | set(document) #union of the two sets
        return list(vocabSet)
    
    def setOfWords2Vec(vocabList, inputSet):
        returnVec = [0]*len(vocabList)
        for word in inputSet:
            if word in vocabList:
                returnVec[vocabList.index(word)] = 1
            else: print "the word: %s is not in my Vocabulary!" % word
        return returnVec
    def trainNB0(trainMatrix,trainCategory):   #训练模型
        numTrainDocs = len(trainMatrix)
        numWords = len(trainMatrix[0])
        pAbusive = sum(trainCategory)/float(numTrainDocs)
        p0Num = ones(numWords); p1Num = ones(numWords)    #拉普拉斯平滑
        p0Denom = 0.0+2.0; p1Denom = 0.0 +2.0           #拉普拉斯平滑
        for i in range(numTrainDocs):
            if trainCategory[i] == 1:
                p1Num += trainMatrix[i]
                p1Denom += sum(trainMatrix[i])
            else:
                p0Num += trainMatrix[i]
                p0Denom += sum(trainMatrix[i])
        p1Vect = log(p1Num/p1Denom)        #用log()是为了避免概率乘积时浮点数下溢
        p0Vect = log(p0Num/p0Denom)
        return p0Vect,p1Vect,pAbusive
    
    def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
        p1 = sum(vec2Classify * p1Vec) + log(pClass1)
        p0 = sum(vec2Classify * p0Vec) + log(1.0 - pClass1)
        if p1 > p0:
            return 1
        else:
            return 0
    
    def bagOfWords2VecMN(vocabList, inputSet):
        returnVec = [0] * len(vocabList)
        for word in inputSet:
            if word in vocabList:
                returnVec[vocabList.index(word)] += 1
        return returnVec
    
    def testingNB():   #测试训练结果
        listOPosts, listClasses = loadDataSet()
        myVocabList = createVocabList(listOPosts)
        trainMat = []
        for postinDoc in listOPosts:
            trainMat.append(setOfWords2Vec(myVocabList, postinDoc))
        p0V, p1V, pAb = trainNB0(array(trainMat), array(listClasses))
        testEntry = ['love', 'my', 'dalmation']
        thisDoc = array(setOfWords2Vec(myVocabList, testEntry))
        print testEntry, 'classified as: ', classifyNB(thisDoc, p0V, p1V, pAb)
        testEntry = ['stupid', 'garbage']
        thisDoc = array(setOfWords2Vec(myVocabList, testEntry))
        print testEntry, 'classified as: ', classifyNB(thisDoc, p0V, p1V, pAb)
    
    def textParse(bigString):  # 长字符转转单词列表
        import re
        listOfTokens = re.split(r'\W*', bigString)
        return [tok.lower() for tok in listOfTokens if len(tok) > 2]
    
    def spamTest():    #测试垃圾文件 需要数据
        docList = [];
        classList = [];
        fullText = []
        for i in range(1, 26):
            wordList = textParse(open('email/spam/%d.txt' % i).read())
            docList.append(wordList)
            fullText.extend(wordList)
            classList.append(1)
            wordList = textParse(open('email/ham/%d.txt' % i).read())
            docList.append(wordList)
            fullText.extend(wordList)
            classList.append(0)
        vocabList = createVocabList(docList)  
        trainingSet = range(50);
        testSet = [] 
        for i in range(10):
            randIndex = int(random.uniform(0, len(trainingSet)))
            testSet.append(trainingSet[randIndex])
            del (trainingSet[randIndex])
        trainMat = [];
        trainClasses = []
        for docIndex in trainingSet:  
            trainMat.append(bagOfWords2VecMN(vocabList, docList[docIndex]))
            trainClasses.append(classList[docIndex])
        p0V, p1V, pSpam = trainNB0(array(trainMat), array(trainClasses))
        errorCount = 0
        for docIndex in testSet: 
            wordVector = bagOfWords2VecMN(vocabList, docList[docIndex])
            if classifyNB(array(wordVector), p0V, p1V, pSpam) != classList[docIndex]:
                errorCount += 1
                print "classification error", docList[docIndex]
        print 'the error rate is: ', float(errorCount) / len(testSet)
    
    
    
    listOPosts,listClasses=loadDataSet()
    myVocabList=createVocabList(listOPosts)
    print myVocabList,'\n'
    # print setOfWords2Vec(myVocabList,listOPosts[0]),'\n'
    trainMat=[]
    for postinDoc in listOPosts:
        trainMat.append(setOfWords2Vec(myVocabList,postinDoc))
    print trainMat
    p0V,p1V,pAb=trainNB0(trainMat,listClasses)
    print pAb
    print p0V,'\n',p1V
    testingNB()
    



    更多相关内容
  • 本文实例讲述了朴素贝叶斯算法python实现方法。分享给大家供大家参考。具体实现方法如下: 朴素贝叶斯算法优缺点 优点:在数据较少的情况下依然有效,可以处理多类别问题 缺点:对输入数据的准备方式敏感 适用数据...
  • 本文实例讲述了朴素贝叶斯分类算法原理与Python实现与使用方法。分享给大家供大家参考,具体如下: 朴素贝叶斯分类算法 1、朴素贝叶斯分类算法原理 1.1、概述 贝叶斯分类算法是一大类分类算法的总称 贝叶斯分类算法...
  • 从底层实现了朴素贝叶斯分类代码,适用于各种分类数据:数值/字符、连续/离散
  • 朴素贝叶斯分类算法python实现,有需要的同学可以自取。如果积分涨得过高请联系我,我随时可以下调
  • 内容包括朴素贝叶斯算法python实现代码,实现对iris分类,包含iris的txt格式的数据集。
  • 朴素贝叶斯算法就是在牺牲一定准确率的情况下强制特征x满足独立条件,求解P(x|y)就更为方便了 但基本上现实生活中,没有任何关系的两个特征几乎是不存在的,故朴素贝叶斯不适合那些关系密切的特征 from ...
  • 主要介绍了Python实现的朴素贝叶斯算法,结合实例形式详细分析了Python实现与使用朴素贝叶斯算法的具体操作步骤与相关实现技巧,需要的朋友可以参考下
  • 朴素贝叶斯算法有三种类型,分别是贝努利朴素贝叶斯、高斯贝叶斯、多项式朴素贝叶斯。

    朴素贝叶斯算法有三种类型,分别是贝努利朴素贝叶斯、高斯贝叶斯、多项式朴素贝叶斯。

     贝叶斯公式

    贝努利朴素贝叶斯

    适合于符合贝努利分布的数据集,贝努利分布也称为“二项分布”或者是“0-1分布”。
    Python代码实现

    import matplotlib.pyplot as plt
    x_min, x_max = X[:,0].min()-0.5, X[:,0].max()+0.5
    y_min, y_max = X[:,1].min()-0.5, X[:,1].max()+0.5
    xx,yy = np.meshgrid(np.arange(x_min, x_max,.02),
                        np.arange(y_min, y_max, .02))
    z = nb.predict(np.c_[(xx.ravel(),yy.ravel())]).reshape(xx.shape)
    plt.pcolormesh(xx,yy,z,cmap=plt.cm.Pastel1)
    plt.scatter(X_train[:,0],X_train[:,1],c=y_train,cmap=plt.cm.cool,edgecolor='k')
    plt.scatter(X_test[:,0],X_test[:,1],c=y_test,cmap=plt.cm.cool,marker='*',
                edgecolor='k')
    plt.xlim(xx.min(),xx.max())
    plt.ylim(yy.min(),yy.max())
    plt.title('Classifier: BernoulliNB')
    plt.show()

     

    高斯贝叶斯

    高斯贝叶斯是假设样本的特征符合高斯分布,或者说符合正态分布时所用的算法。
    Python代码实现

    z = gnb.predict(np.c_[(xx.ravel(),yy.ravel())]).reshape(xx.shape)
    plt.pcolormesh(xx,yy,z,cmap=plt.cm.Pastel1)
    plt.scatter(X_train[:,0],X_train[:,1],c=y_train,cmap=plt.cm.cool,edgecolor='k')
    plt.scatter(X_test[:,0],X_test[:,1],c=y_test,cmap=plt.cm.cool,marker='*',
                edgecolor='k')
    plt.xlim(xx.min(),xx.max())
    plt.ylim(yy.min(),yy.max())
    plt.title('Classifier: GaussianNB')
    plt.show()

    多项式朴素贝叶斯

    多项式朴素贝叶斯主要用于拟合多项式分布的数据集,只适合用来对非负离散数值特征进行分类。
    Python代码实现

    z = mnb.predict(np.c_[(xx.ravel(),yy.ravel())]).reshape(xx.shape)
    plt.pcolormesh(xx,yy,z,cmap=plt.cm.Pastel1)
    plt.scatter(X_train[:,0],X_train[:,1],c=y_train,cmap=plt.cm.cool,edgecolor='k')
    plt.scatter(X_test[:,0],X_test[:,1],c=y_test,cmap=plt.cm.cool,marker='*',
                edgecolor='k')
    plt.xlim(xx.min(),xx.max())
    plt.ylim(yy.min(),yy.max())
    plt.title('Classifier: MultinomialNB')
    plt.show()

     由于不让放链接,想要完整代码的朋友,请关注我私信回复“算法笔记7”免费获取

    展开全文
  • 朴素贝叶斯算法原理与Python实现

    千次阅读 热门讨论 2021-06-05 17:24:35
    朴素贝叶斯法是基于贝叶斯定理与特征条件独立假设的分类方法[1]。 最为广泛的两种分类模型是决策树模型(Decision Tree Model)和朴素贝叶斯模型(Naive Bayesian Model,NBM)。和决策树模型相比,朴素贝叶斯分类器...

    1 算法介绍

    朴素贝叶斯法是基于贝叶斯定理与特征条件独立假设的分类方法。

    最为广泛的两种分类模型是决策树模型(Decision Tree Model)和朴素贝叶斯模型(Naive Bayesian Model,NBM)。和决策树模型相比,朴素贝叶斯分类器(Naive Bayes Classifier 或 NBC)发源于古典数学理论,有着坚实的数学基础,以及稳定的分类效率。同时,NBC模型所需估计的参数很少,对缺失数据不太敏感,算法也比较简单。理论上,NBC模型与其他分类方法相比具有最小的误差率。但是实际上并非总是如此,这是因为NBC模型假设属性之间相互独立,这个假设在实际应用中往往是不成立的,这给NBC模型的正确分类带来了一定影响。

    朴素贝叶斯公式如下:

    P(A_{i}|B) = \frac{P(B|A_{i})P(A_{i})}{\sum_{j}^{}P(B|A_{j})P(A_{j})}

    这个是什么意思呢?该如何用呢?相信大家有一定的概率知识基础的同学,对先验概率及条件概率都比较清楚,在这里简单的说一下这条公式的含义:

    1、首先P(A_{i}|B)代表的意思就是在B条件发生的情况下,Ai发生的概率

    2、\sum{}_{j}^{}P(B|A_{j})P(A_{j})这公式代表的意思就是,在所有A类的结果中,B发生的概率之和,也就是B的概率

    3、所以在这个公式,表达的意思就是(B条件发生的情况下,Ai发生的概率=Ai与B同时发生的概率占整个B发生的概率的多少)

     于是这个公式就可以转化为P(A_{i}|B) = \frac{P(B|A_{i})P(A_{i})}{P(B)} = \frac{P(A_{i}B)}{P(B)},(加上后面这个公式,是为了让我们更好的理解,实际上的使用,一般只用第一个等式的公式)

    4、因此,由于P(B)是固定得,所以P(A_{i}|B)发生得概率与分子P(B|A_{i})P(A_{i})相关,也就是分子越大,概率越高

    5、推导过程如下:

    P(A_{i}|B) = \frac{P(A_{i}B) }{P(B)} = \frac{P(A_{i}B) }{\sum_{j}^{}P(A_{j}B)} = \frac{P(B|A_{i})P(A_{i})}{\sum_{j}^{}P(B|A_{j})P(A_{j})}

    仔细品了一下这个公式,也确实发现其很适合用在分类的算法中;对于这个贝叶斯公式来说,就像是求B属于Ai的概率,运用在分类中,就得先求出B属于每一类中的可能,找出最大的,这就是朴素贝叶斯的算法思路。

    由此得到朴素贝叶斯分类算法流程:

    1. 利用贝叶斯公式,求出预测得结果属于每一种类别得可能
    2. 找出最大值

    2 案例介绍

    有房婚姻状况拖欠贷款
    单身no
    已婚no
    单身no
    已婚no
    离婚yes
    已婚no
    离婚no
    单身yes
    已婚no
    单身yes
    已婚no
    已婚no
    已婚yes

    基于上面的数据,希望预测没房、单身的人,会不会拖欠贷款??? 

    代码流程:

    1. 先将样本数据处理成字典,并统计每一类发生得个数(第一个函数)
    2. 将待预测得样本写入,并根据之前得样本数据,对分类结果进行求概率,得出最大概率得分类结果

    代码如下: 

    import pandas as pd
    
    
    def handle_data(data):
        """
        将数据处理成字典,用于保存样本数据中的类别数据存储情况
        :param data: dataframe 数据源
        :return:样本数据中的类别数据字典,分类结果字典
        """
        # 初始化类别数据字典
        cate_dict = {}
        # 数据集表头列表(各个条件及分类结果)
        header_list = data.columns.tolist()
        # 条件列表
        factor_list = header_list[:-1]
        # 分类结果所在位置
        k = len(header_list) - 1
    
        # result_dict 为分类的结果类型字典
        result_dict = dict(data.iloc[:, k].value_counts())
        # 或使用如下语句:
        # result_dict = dict(data.iloc[:, -1].value_counts())
        result_dict_key = result_dict.keys()
    
        # 将每个分类结果写入 cate_dict
        # 循环各个分类结果
        for result_key in result_dict_key:
            # 如果类别数据字典不存在该分类结果,默认设置空字典
            if result_key not in cate_dict:
                # dict.setdefault(key, default=None)  键不存在于字典中,将会添加键并将值设为默认值
                cate_dict.setdefault(result_key, {})
            # 在该分类结果下,循环各个条件(因素)
            for factor in factor_list:
                # 如果该分类结果字典不存在该条件(因素),默认设置空字典
                if factor not in cate_dict[result_key]:
                    cate_dict[result_key].setdefault(factor, {})
                # 获取该条件的分类列表
                factor_key_list = data[factor].value_counts().index.tolist()
                # 循环获取该条件的各个分类数量
                for key in factor_key_list:
                    # 获取该分类结果下,该因素中某个分类的数量
                    number = data[(data[header_list[k]] == result_key) & (data[factor] == key)].shape[0]
                    if key not in cate_dict[result_key][factor]:
                        cate_dict[result_key][factor].setdefault(key, number)
        return cate_dict, result_dict
    
    
    def calculate(cate_dict, result_dict, new_data):
        """
        对每个待预测得结果进行贝叶斯公式得计算,并得出预测类别与概率
        :param cate_dict: 样本数据中的类别数据字典
        :param result_dict: 分类结果字典
        :param new_data: 待预测的数据集
        :return: 预测结果列表
        """
        # 获取数据集的各个条件(因素)列表
        factor_list = new_data.columns.tolist()
        # 初始化预测结果列表
        result_list = []
        # 分类结果列表
        result_key_list = cate_dict.keys()
    
        # 循环预测新数据
        for i in range(len(new_data)):
            new_result_dict = {}
            # 循环计算各个分类指标的概率
            for result_key in result_key_list:
                # 该分类结果在所有分类结果中的占比
                all_ratio = result_dict[result_key] / sum(list(result_dict.values()))
    
                # 循环获取该分类结果下,该因素中各个 分类 在 该分类结果 中的占比
                for factor in factor_list:
                    ratio = cate_dict[result_key][factor][new_data.iloc[i, factor_list.index(factor)]] / result_dict[result_key]
                    # 总占比 乘以 该因素下的各个分类占比
                    all_ratio *= ratio
                new_result_dict.setdefault(result_key, all_ratio)
    
            print(new_result_dict)
            # 获取占比最大的分类结果
            max_result_key = max(new_result_dict, key=new_result_dict.get)
            # 获取占比最大的分类结果的占比
            max_value = new_result_dict[max_result_key]
    
            result_list.append([max_result_key, max_value])
        return result_list
    
    
    if __name__ == '__main__':
        file_path = "./朴素贝叶斯数据集.xlsx"
        data = pd.read_excel(file_path)
        print("数据源\n", data)
        # 待预测数据
        new_data = pd.DataFrame({"有房": "是", "婚姻状况": "已婚"}, index=[0])
        cate_dict, result_dict = handle_data(data)
        print(cate_dict)
        print(result_dict)
        result = calculate(cate_dict, result_dict, new_data)
        print(result)

    运行结果:

    数据源
        有房 婚姻状况 拖欠贷款
    0   是   单身   no
    1   否   已婚   no
    2   否   单身   no
    3   是   已婚   no
    4   否   离婚  yes
    5   否   已婚   no
    6   是   离婚   no
    7   否   单身  yes
    8   否   已婚   no
    9   否   单身  yes
    10  是   已婚   no
    11  是   已婚   no
    12  是   已婚  yes
    {'no': {'有房': {'否': 4, '是': 5}, '婚姻状况': {'已婚': 6, '单身': 2, '离婚': 1}}, 'yes': {'有房': {'否': 3, '是': 1}, '婚姻状况': {'已婚': 1, '单身': 2, '离婚': 1}}}
    {'no': 9, 'yes': 4}
    {'no': 0.2564102564102564, 'yes': 0.019230769230769232}
    [['no', 0.2564102564102564]]

    所以得出结果为NO!

    展开全文
  • python实现朴素贝叶斯算法

    千次阅读 2021-12-08 16:53:26
    · 朴素贝叶斯算法是应用最为广泛的分类算法之一。 · 给定训练数据集X,其类别为Y,则有: 其中,P(Y|X)为后验概率,即测试集文本X取类别Y的概率。对于文本Xi,对每个类别Yi计算概率,得到P(Y1|Xi)、P(Y2|Xi...

    本次实验的任务是文本分类,所用数据集为20news_bydate
    实验流程主要如下:
    一、算法介绍
    · 朴素贝叶斯算法是应用最为广泛的分类算法之一。
    · 给定训练数据集X,其类别为Y,则有:
    在这里插入图片描述
    其中,P(Y|X)为后验概率,即测试集文本X取类别Y的概率。对于文本Xi,对每个类别Yi计算概率,得到P(Y1|Xi)、P(Y2|Xi)、……、P(Yn|Xi),概率最大的类别则为预测类别。

    上式中:
    · P(Y)为每个类别的先验概率,计算方式为:
    每个类别单词总数 / 训练集所有单词总数。

    · P(X | Y)= P(x1,x2,……,xn | Y),xi为文本的特征。
    朴素贝叶斯“朴素”地将各个特征视作相互独立,因此:
    P(X | Y) = P(x1 | Y)× P(x2 | Y)× P(x3 | Y)…… × P(xn | Y)。
    这里,文本的特征xi即为文本预处理、分词后得到的全部词汇。
    计算方式(以 P(xi | Yj)为例):
    单词xi在训练集Yj类别下所有文档中出现的总次数 / 训练集Yj类别下所有文档包含的单词总数

    · P(X)始终不变,可以忽略不计。

    综上,实验主要步骤为:
    数据集获取 -》 数据预处理,得到分词后的语料和词袋 -》 遍历计算P(X)、P(X|Y) -》
    max( P(X) × P(X|Y) )对应的类别即为预测类别

    二、数据集获取
    20newsgroups数据集可以直接从sklearn模块导入:

    from sklearn.datasets import fetch_20newsgroups #导入模块
    news_data = fetch_20newsgroups(subset="all") #读取数据
    

    也可以手动下载:
    链接:https://pan.baidu.com/s/1YO-Je1lT_y-MbGRpSwHQSA
    提取码:qwer

    三、数据预处理

    import os
    # string nltk 用于文本预处理
    import string
    import nltk
    from nltk.corpus import stopwords
    import pickle
    
    class Textprocess():
        def __init__(self):
        	# 存放原始语料库路径
            self.corpus = ''
            # 分词后的路径
            self.segment = ''
            # 存储分词、去重后的结果
            self.word_list = ''
            self.label_list = ''
            # 存储训练集分词结果,处理测试集时相关代码注释
            self.ori_words_list = ''
    	
    	# 在原始路径下创建train_segment,test_segment两个文件夹
    	# 存储预处理、分词后的结果
        def preprocess(self):
            mydir = os.listdir(self.corpus)
            for dir in mydir:
                create_dir = self.corpus + '/' + dir + '_segment'
                os.makedirs(create_dir)
                dir_path = self.corpus + '/' + dir
                news_list = os.listdir(dir_path)
                # 每个类别的文档集
                for news in news_list:
                    path = create_dir + '/' + news
                    os.makedirs(path)
                    news_path = dir_path + '/' + news
                    files = os.listdir(news_path)
                    # 每个文本文件
                    for file in files:
                        file_path = news_path + '/' + file
                        with open(file_path,'r',encoding='utf-8', errors='ignore') as f1:
                            content = f1.read()
                            clean_content = self.data_clean(content)
                            new_file_path = path + '/' + file
                            with open(new_file_path, 'w', encoding = 'utf-8', errors='ignore') as f2:
                                f2.write(clean_content)
    
        def data_clean(self, data):
            # 大写转换为小写
            data1 = data.lower()
            # 去除标点符号
            remove = str.maketrans('','',string.punctuation)
            data2 = data1.translate(remove)
            # 分词
            data3 = nltk.word_tokenize(data2)
            # 去除停用词和非英文词汇
            data4 = [w for w in data3 if (w not in stopwords.words('english')) and (w.isalpha()) and (len(w) < 15)]
            data_str = ' '.join(data4)
            return data_str
    
        def create_non_repeated_words:(self):
            self.content_list = []
            self.labels_list = []
            # self.ori_list = []
            mydir = sorted(os.listdir(self.segment))
            label = 0
            for dir in mydir:
                dir_path = self.segment + '/' + dir
                files = sorted(os.listdir(dir_path))
                for file in files:
                    file_path = dir_path + '/' + file
                    with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
                        line = f.read()
                        line1 = line.strip('\n')
                        line2 = line1.split()
                        # 将分词后的结果存入列表,处理测试集时注释
                        # self.ori_list.append(line2)
                        # 列表去重,并去掉仅出现一次的单词
                        line3 = []
                        once_word = []
                        for i in line2:
                            if i not in once_word:
                                once_word.append(i)
                            else:
                                if i not in line3:
                                    line3.append(i)
                        self.content_list.append(line3)
                        self.labels_list.append(label)
                label += 1
    
            self.data_dump(self.word_list, self.content_list)
            self.data_dump(self.label_list, self.labels_list)
            # self.data_dump(self.ori_words_list, self.ori_list)
    
        def data_dump(self, path, data):
            f = open(path, 'wb')
            pickle.dump(data, f)
            f.close()
    
        def data_load(self, path):
            f = open(path, 'rb')
            data = pickle.load(f)
            return data
        
    text = Textprocess()
    text.corpus = r'.\20news-bydate'
    text.segment = r'.\20news-bydate\20news-bydate-train_segment'
    text.word_list = 'train_words'
    text.label_list = 'train_labels'
    text.ori_words_list = 'original_bag'
    text.preprocess()
    text.create_non_repeated_words()
    
    
    test = Textprocess()
    test.corpus = r'.\20news-bydate'
    test.segment = r'.\20news-bydate\20news-bydate-test_segment'
    test.word_list = 'test_words'
    test.label_list = 'test_labels'
    test.create_non_repeated_words()
    

    四、朴素贝叶斯算法的实现

    #encoding=utf-8
    import textprocess_detail as tp
    import numpy as np
    from sklearn import metrics
    ori_words = tp.Textprocess().data_load('original_bag')
    train_labels = tp.Textprocess().data_load('train_labels')
    test_words = tp.Textprocess().data_load('test_words')
    test_labels = tp.Textprocess().data_load('test_labels')
    
    # 计算每个类别包含的单词总数
    def words_sum():
        sum = [0 for i in range(20)]
        for i in range(len(ori_words)):
            count = len(ori_words[i])
            sum[train_labels[i]] += count
        return sum
    
    # 计算每个类别的先验概率
    def category_probability(list):
        sum = 0
        cp = []
        for i in list:
            sum += i
        for j in list:
            cp.append(j / sum)
        return cp
    
    # p(x1|y) * p(x2|y) * …… * p(y)
    def predict(sum, cp):
        precision = []
        for doc in range(len(test_words)):
            p_list = []
            for predict_label in range(20):
                p = 1
                word_sum = sum[predict_label]
                for word in test_words[doc]:
                    count = 0
                    # 遍历训练集文档
                    for i in range(len(ori_words)):
                        if train_labels[i] == predict_label:
                            count += ori_words[i].count(word)
                    p *= (count + 1) / (word_sum + 20)
                p *= cp[predict_label]
                p_list.append(p)
            precision.append(p_list)
        tp.Textprocess().data_dump('precision', precision)
        print(precision)
        return precision
    
    count_list = words_sum()
    cp = category_probability(count_list)
    precision = predict(count_list, cp)
    probability = tp.Textprocess().data_load('precision')
    a = np.array(probability)
    precision = np.argmax(a, axis = 1)
    
    true_label = tp.Textprocess().data_load('test_labels')
    m_precision = metrics.accuracy_score(true_label,precision)
    print("%.2f"%m_precision)
    

    最终正确率在0.7左右

    展开全文
  • 朴素贝叶斯朴素贝叶斯法是基于贝叶斯定理与特征条件独立假设的分类方法。前提各个特征条件独立,也是“朴素”之名的来历。 1. 概率公式 联合概率:包含多个条件,且所有条件同时成立的概率 记作:P(A,B) = P(A)P...
  • 本文主要介绍了python中如何使用朴素贝叶斯算法的相关知识。具有很好的参考价值。下面跟着小编一起来看下吧
  • 1. 什么是朴素贝叶斯朴素贝叶斯(naive Bayes)法是基于贝叶斯定理与特征条件独立假设的分类方法。对于给定的训练数据集,首先基于特征条件独立假设学习输入输出的联合概率分布;然后基于此模型,对给定的输入x,...
  • 使用朴素贝叶斯算法实现MNIST数据集的训练预测,精度较高,主要是参考统考学习李航一书和github上相关作者思路进行实现。
  • 简单的朴素贝叶斯垃圾邮件分类算法python实现),另外上传的有垃圾邮件训练数据集,供大家下载。
  • 朴素贝叶斯算法算法原理对数据的要求算法的优缺点算法需要注意的点算法实现(python)(待更.......) 算法原理 P(Ck∣xi)=p(xi∣ck)∗p(ck)p(xi)=p(x1∣ck)∗p(x2∣ck)....p(ck)p(x1)p(x2)....P(C_k|x_i)=\frac{p(x...
  • 首先介绍以下贝叶斯公式:这个是什么意思呢?该如何用呢?相信大家有一定的概率知识基础的同学,对先验概率及条件概率都比较清楚,在这里简单的说一下这条公式的含义:1、首先代表的意思就是在B条件发生的情况下,Ai...
  • 主要为大家详细介绍了python实现基于朴素贝叶斯的垃圾分类算法,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 压缩包中包括python脚本和一个PPT。 在UtralEdit中打开这两个脚本NBayes_lib.py和NBayes_...PPT详解了朴素贝叶斯算法的原理以及这个文本分类器的程序思想和运行结果详解,希望对你能够有帮助,如果有任何问题,请留言!
  • 朴素贝叶斯算法python

    2019-06-23 18:53:50
    朴素贝叶斯算法的工作原理主要是概率论和数理统计 通过属性对分类的影响程度,所展现不同的结果 二.简单运用 import numpy as np X= np.array([ [0,1,0,1], [1,1,1,0], [0,1,1,0], [0,0,0,1], [0,1,1,0], ...
  • 各位同学好,今天我向大家介绍python机器学习中的朴素贝叶斯算法。内容有:算法的基本原理;案例实战--新闻文档的分类预测。 案例简介:新闻数据有20个主题,有10万多篇文章,每篇文章对应不同的主题,要求是任意...
  • 1.伯努利朴素贝叶斯 常用于文档分类 2.构建词向量 侮辱性(1)非侮辱性(0) 3.此案例所有函数 4. reduce 函数 reduce() 函数会对参数序列中元素进行累积。 函数将一个数据集合(链表,元组等)中的所有数据进行...
  • 朴素贝叶斯估计 朴素贝叶斯是基于贝叶斯定理与特征条件独立分布假设的分类方法。首先根据特征条件独立的假设学习输入/输出的联合概率分布,然后基于此模型,对给定的输入x,利用贝叶斯定理求出后验概率最大的输出y。...
  • 《机器学习》算法实例-朴素贝叶斯算法-屏蔽社区留言板的侮辱言论 构建一个快速过滤器来屏蔽在线社区留言板上的侮辱性言论。如果某条留言使用了负面或者侮辱性的语言,那么就将该留言标识为内容不当。对此问题建立两...
  • 目录前置知识1、概念2、算法原理2.1、条件概率朴素贝叶斯分类算法1、构建数据集2、分类概率3、条件概率4、先验概率 前置知识 1、概念 上一片我们讲到的决策树算法,是反映了一种非常明确、固定的判断选择过程,即某...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 16,107
精华内容 6,442
关键字:

朴素贝叶斯算法python