精华内容
下载资源
问答
  • 朴素贝叶斯分类python实现)
    千次阅读
    2022-03-15 14:20:00

    算法优劣

    优点:

    1. 朴素贝叶斯模型发源于古典数学理论,有稳定的分类效率。

    2. 对小规模的数据表现很好,能个处理多分类任务,适合增量式训练,尤其是数据量超出内存时,我们可以一批批的去增量训练。

    3. 对缺失数据不太敏感,算法也比较简单,常用于文本分类。

    缺点

    1. 理论上,朴素贝叶斯模型与其他分类方法相比具有最小的误差率。但是实际上并非总是如此,这是因为朴素贝叶斯模型给定输出类别的情况下,假设属性之间相互独立,这个假设在实际应用中往往是不成立的,在属性个数比较多或者属性之间相关性较大时,分类效果不好。而在属性相关性较小时,朴素贝叶斯性能最为良好。对于这一点,有半朴素贝叶斯之类的算法通过考虑部分关联性适度改进。

    2. 需要知道先验概率,且先验概率很多时候取决于假设,假设的模型可以有很多种,因此在某些时候会由于假设的先验模型的原因导致预测效果不佳。

    3. 由于我们是通过先验和数据来决定后验的概率从而决定分类,所以分类决策存在一定的错误率。

    4. 对输入数据的表达形式很敏感。

    算法实现

    说明

    • scikit-learn中,一共有3个朴素贝叶斯的分类算法类。分别是GaussianNBMultinomialNBBernoulliNB
    • GaussianNB:先验为高斯分布的朴素贝叶斯
    • MultinomialNB:先验为多项式分布的朴素贝叶斯
    • BernoulliNB:先验为伯努利分布的朴素贝叶斯。

    数据准备

    import pandas as pd
    import numpy as np
    X = np.array([[1.14, 1.78],[1.18, 1.96],[1.20, 1.86],[1.26, 2.00],[1.28, 2.00],
                 [1.30, 1.96],[1.24, 1.72],[1.36, 1.74],[1.38, 1.64],[1.38, 1.82],
                 [1.38, 1.90],[1.40, 1.70],[1.48, 1.82],[1.54, 1.82],[1.56, 2.08]])
    Y = np.hstack((np.ones(6), np.ones(9)*2)) #数组合并
    

    GaussianNB预测

    from sklearn.naive_bayes import GaussianNB
    clf_Ga = GaussianNB()
    clf_Ga.fit(X, Y)
    print("预测结果")
    print(clf_Ga.predict([[1.24, 1.80]]))
    print("样本为1类的概率")
    print(clf_Ga.predict_proba([[1.24, 1.80]]))
    print("样本为2类的概率")
    print(clf_Ga.predict_log_proba([[1.24, 1.80]]))
    

    输出:

    预测结果
    [1.]
    样本为1类的概率
    [[0.7236103 0.2763897]]
    样本为2类的概率
    [[-0.3235023  -1.28594344]]
    
    • 样本为1的概率大于样本为2的概率,所以认为该样本为1类
    print("预测结果")
    print(clf_Ga.predict([[1.29, 1.81],[1.43,2.03]]))
    

    输出:

    预测结果
    [2. 2.]
    

    MultinomialNB预测

    • 这里使用GridSearchCV函数进行网格搜索交叉检验调参,评估模型的分数为accuracy即准确率。
    • 调整的参数分别为:alpha(常数 λ \lambda λ),fit_prior(是否考虑先验概率)
    from sklearn.naive_bayes import MultinomialNB
    clf_Mu = MultinomialNB()
    from sklearn.model_selection import GridSearchCV
    param_grid = [{'alpha':np.arange(0.9,1.1,0.1),
                  'fit_prior':['True','False']}]
    grid_search = GridSearchCV(clf_Mu, param_grid, cv = 3,
                              scoring = 'accuracy',
                              return_train_score = True)
    grid_search.fit(X,Y)
    

    输出最优参

    grid_search.best_params_
    

    输出:

    {'alpha': 0.9, 'fit_prior': 'True'}
    

    查看网格搜索模型分数

    cvres = grid_search.cv_results_
    for accuracy,params in zip(cvres["mean_test_score"],cvres["params"]):
        print("{:.2}".format(accuracy),params)
    

    输出:

    0.6 {'alpha': 0.9, 'fit_prior': 'True'}
    0.6 {'alpha': 0.9, 'fit_prior': 'False'}
    0.6 {'alpha': 1.0, 'fit_prior': 'True'}
    0.6 {'alpha': 1.0, 'fit_prior': 'False'}
    0.6 {'alpha': 1.1, 'fit_prior': 'True'}
    0.6 {'alpha': 1.1, 'fit_prior': 'False'}
    
    • 这里可能是因为样本只有15个,导致参数不管如何变化对准确率都没有太大影响。

    预测结果

    final_model = grid_search.best_estimator_
    
    X_test = np.array([[1.24, 1.80],[1.29, 1.81],[1.43,2.03]])
    X_test_prepared = final_model.predict(X_test)
    print("预测结果")
    print(X_test_prepared)
    

    输出:

    预测结果
    [2. 2. 2.]
    

    结语

    • 两种方法在对第1个样本的预测上有不同,这里因为样本数量太少,不做深究。
    更多相关内容
  • 贝叶斯分类算法是统计学的一种分类算法,利用概率统计对数据进行分类,含数据集,Python实现贝叶斯分类算法
  • 一个实现朴素贝叶斯分类器简单的Python
  • 多项式朴素贝叶斯也是多用于文本处理,其原理和计算的流程和伯努利朴素贝叶斯基本一致,唯一的区别在于单词的计数方式,由《伯努利朴素贝叶斯》一文可知,在文本处理的环节中,我们将单词是否出现在词组作为特征,但...
  • 朴素贝叶斯分类器python版)

    热门讨论 2014-08-04 18:06:25
    python写的简单的朴素贝叶斯分类器,一共有两个主文件,nbayes1和nbayes1_run1还有两个训练数据文件,望大家多多指教。
  • #将不同分类的属性进行分别存放,为了可以分别计算均值和标准差 def classfiAttr ( Attr , Label ) : Attr_have = [ ] Attr_no = [ ] for i in range ( len ( Label ) ) : if Label [ i ] == 1 :...
    import xlrd
    import random
    import math
    
    #将表格文件进行导入
    def loaddata(fname):
        file=open(fname)
        data=xlrd.open_workbook(fname) #将表格的内容进行读取
        dataname=data.sheet_names() #生成的是一个列表
        #shxrange=range(data.nsheets)
        #print(shxrange)
        try:
            sh=data.sheet_by_name(dataname[0])
        except:
            print("no sheet %s named Sheet1".format(fname))
        nrows=sh.nrows
        ncols=sh.ncols
        print("nrows {0},ncols {1}".format(nrows,ncols))
    
        datasets=[]
    
        for i in range(nrows):
            datasets.append(sh.row_values(i))
        del datasets[0]
    
        return datasets
    
    #测试程序,用的是自己建立的表格数据
    #dataset=loaddata("E:\\pima_data\\test_data.xlsx")
    #print("dataset",dataset)
    #print(len(dataset))
    
    #训练集和测试集进行分割
    def splitDataset(dataset,splitRatio):
        trainSet=[]
        dataSet_copy=dataset
        trainSize=(len(dataset))*splitRatio
        n=0
        while trainSize>n:
            index=random.randrange(len(dataSet_copy))
            #表示在数据集中任意选择样本,保证样本的随机性
            trainSet.append(dataSet_copy[index])
            dataSet_copy.pop(index)
            n+=1
        testSet=dataSet_copy
    
        return trainSet,testSet  #返回的是包含每一个样本的列表
    
    
    #进行程序的测试
    #(trainSet,testSet)=splitDataset(dataset,0.6)
    #print("trainSet",trainSet)
    #print("testSet",testSet)
    
    #对属性和标签进行分别存放
    def splitAttrLabel(dataSet):
        #对于训练集和测试集是一样的处理,所以使用一个函数就可以进行处理
        Attr=[]
        Label=[]
        num=len(dataSet) #表示数据集中样本的数量
        n_attr=len(dataSet[0])-1  #为了代码的重复利用,不用修改参数
        for i in range(num):
            Attr.append(list(dataSet[i][0:n_attr])) #生成包含每个样本属性的列表属性列表
            Label.append(dataSet[i][n_attr])        #生成包含每个标签的标签列表
    
        return Attr,Label
    
    #属性应该分为有糖尿病的属性是什么,没有糖尿病的属性是什么
    #但是可以不定义函数,直接在程序中写出来
    
    #测试
    #(Attr,Label)=splitAttrLabel(trainSet)
    #print("trainSet Attr",Attr)
    #print("trainSet Label",Label)
    
    #将不同分类的属性进行分别存放,为了可以分别计算均值和标准差
    def classfiAttr(Attr,Label):
        Attr_have=[]
        Attr_no=[]
        for i in range(len(Label)):
            if Label[i]==1:
                Attr_have.append(Attr[i])
            else:
                 Attr_no.append(Attr[i])
        return Attr_have,Attr_no
    
    #测试
    #(Attr_have,Attr_no)=classfiAttr(Attr,Label)
    #print("糖尿病患者属性列表",Attr_have)
    #print("非糖尿病患者属性列表",Attr_no)
    
    
    #因为是连续的数值,
    # 所以使用贝叶斯公式对数值进行处理得到各个属性的类条件概率
    #由最大似然法得到正太分布的均值就是样本均值
    def stmean(Attr):
    
        attr_mean=[]   #将8个属性的平均值都放到这个列表中作为向量使用
        for each_attr in range(len(Attr[0])):
            #print("属性的长度是多少",len(Attr[0]))
            #print(each_attr)
            sum=0
            for each_example in range(len(Attr)):
                #print(Attr[each_example][each_attr])
                sum+=Attr[each_example][each_attr]
            attr_mean.append(sum/len(Attr))
    
            #each_attr_mean=(sum(Attr[:][each_attr]))/(len(Attr))
            #print(Attr[:])
            #attr_mean.append(each_attr_mean)
    
        return attr_mean
    
    #进行测试
    #stmean_no=stmean(Attr_no)
    #print("trainSet stmean_no",stmean_no)
    
    #标准差
    #标准差就是样本的平均标准差
    def stdev(Attr,stmean):
    
        attr_dev=[]   #将8个属性的平均值都放到这个列表中作为向量使用
        for each_attr in range(len(Attr[0])):
            sum=0
            for each_example in range(len(Attr)):
                #print("函数内",stmean[each_attr])
                sum+=pow((Attr[each_example][each_attr]-stmean[each_attr]),2)
            attr_dev.append(math.sqrt(sum/len(Attr)))
    
        return attr_dev
    
    #测试
    #stdev_no=stdev(Attr_no,stmean_no)
    #print("标准差",stdev(Attr_no,stmean_no))
    
    #定义类概率密度函数
    
    def calculateProbability(x, mean, stdev):
      exponent = math.exp(-(math.pow(x-mean,2)/(2*math.pow(stdev,2))))
      return (1 / (math.sqrt(2*math.pi) * stdev)) * exponent
    
    #测试
    #Probability=calculateProbability(4, stmean_no[0], stdev_no[0])
    #print("单个值单属性的类条件概率",Probability)
    
    #计算类别的先验概率
    def calculatepriorprobability(Attr,Attr_have,Attr_no):
        probability_have=(len(Attr_have)+1)/(len(Attr)+2)
        probability_no=(len(Attr_no)+1)/(len(Attr)+2)
        return probability_have,probability_no
    
    #测试
    #(probability_have,probability_no)=calculatepriorprobability(Attr_have,Attr_no)
    #print("有糖尿病的先验概率是:",probability_have)
    #print("没有糖尿病的先验概率是:",probability_no)
    
    #进行测试集的预测
    def predict(priorprobability,Attr_test,mean,stdev):
    
        lateprobability_list=[]
        for each_example in range(len(Attr_test)):
            lateprobability = priorprobability
            for each_attr in range(len(Attr_test[0])):
                lateprobability*=calculateProbability(Attr_test[each_example][each_attr], mean[each_attr], stdev[each_attr])
                #print("测试集的属性值",Attr_test[each_example][each_attr])
                #print(lateprobability)
            lateprobability_list.append(lateprobability)  #生成测试集相同数量的后延概率的列表
        return lateprobability_list
    
    #将有糖尿病和没有糖尿病的预测概率进行比较,谁大就是谁
    def compare(lateprobability_list_have,lateprobability_list_no):
        compare_list=[]
        for i in range(len(lateprobability_list_have)):
            if lateprobability_list_have[i]>=lateprobability_list_no[i]:
                compare_list.append(1)
            else:
                compare_list.append(0)
        return compare_list
    
    #精度函数
    def predict_precision(test_label,compare_list):
        n=0 #表示这个时候没有一个数据正确
        for i in range(len(test_label)):
            if test_label[i]==compare_list[i]:
                n+=1
        print(n)
        precision=n/(len(test_label))
        return precision
    
    #定义主函数
    def main():
        fname="E:\\datasets\\pima_data\\pima.xlsx"
        dataset=loaddata(fname) #将数据集导入
        (trainSet,testSet)=splitDataset(dataset, 0.67) #将数据集进行分割,分割成训练集和测试集
        print("训练集为:",trainSet,"\n训练集数目为:",len(trainSet))
        print("测试集为:", testSet,"\n测试集数目为:",len(testSet))
        (train_attr,train_label)=splitAttrLabel(trainSet) #将训练集的属性和标签进行分割
        (test_attr, test_label) = splitAttrLabel(testSet) #测试集的属性和标签进行单独分割
        print("测试集的标签:",test_label,"\n测试集标签数目为:",len(test_label))
        (train_Attr_have,train_Attr_no)=classfiAttr(train_attr,train_label) #对训练集的属性值进行分别存放
        train_mean_have=stmean(train_Attr_have) #糖尿病人的属性均值
        print("训练集中有糖尿病的均值为",train_mean_have)
        train_mean_no=stmean(train_Attr_no)     #非糖尿病人的属性均值
        print("训练集中没有糖尿病的均值为", train_mean_no)
        train_dev_have=stdev(train_Attr_have, train_mean_have)
        print("训练集中有糖尿病的方差为", train_dev_have)
        train_dev_no=stdev(train_Attr_no, train_mean_no)
        print("训练集中没有糖尿病的方差为", train_dev_no)
        (prior_probability_have, prior_probability_no)=calculatepriorprobability(train_attr,train_Attr_have,train_Attr_no)
        print("训练集中有和没有糖尿病的先验概率为:",prior_probability_have, prior_probability_no)
    
    
        lateprobability_list_have=predict(prior_probability_have, test_attr, train_mean_have, train_dev_have)
        print("有糖尿病的后验概率表",lateprobability_list_have)
        lateprobability_list_no=predict(prior_probability_no, test_attr, train_mean_no, train_dev_no)
        print("没有糖尿病的后验概率表", lateprobability_list_no)
        compare_list=compare(lateprobability_list_have, lateprobability_list_no)
        print("通过比较得出的比较值0,1值",compare_list)
        precision=predict_precision(test_label, compare_list)
        return precision
    
    precision=main()
    print("精度为:",precision)
    

    使用pima数据集作为训练集和测试集,准确率可以达到74.7。

    展开全文
  • 学习笔记-贝叶斯分类器及其python实现

    千次阅读 多人点赞 2021-12-09 23:44:51
    学生朴素贝叶斯学习笔记,如有错误谢谢指出。(来自《统计学习方法》-李航)

    朴素贝叶斯(NB)

    [学生党学习笔记,如有错误谢谢各位大佬指出]
    所用书籍:《统计学习方法》-李航

    一、概述

      朴素贝叶斯模型首先基于特征条件独立假设,学习输入的联合概率分布;然后基于此模型,对给定的输入x,利用贝叶斯定理求出后验概率最大的输出y。
      同时这也表明了朴素贝叶斯是一种生成式模型,是基于概率进行学习并分类的。
      关于生成式模型与判别式模型,大家可以点链接看看这篇文章[戳这里]

      相对于其它分类算法,朴素贝叶斯分类依赖于贝叶斯概率定理来预测未知数据集的类别,它的速度是非常快的。
      贝叶斯定理实际上就是计算”条件概率”的公式。
    条件概率:
    P ( A ∣ B ) = P ( B ∣ A ) ∗ P ( A ) P ( B ) P(A|B)=\frac{P(B|A)*P(A)}{P(B)} P(AB)=P(B)P(BA)P(A)
    在朴素贝叶斯分类器中,上式分别表示:

    • P(A|B)是给定预测变量(B,属性)的类(A,target)的后验概率。【即在看到新数据后,我们要计算的该假设的概率】
    • P(A)是类的先验概率。【即在得到新数据前某一假设的概率】
    • P(B|A)是预测器给定类的概率的可能性。【该假设下得到这一数据的概率,称为似然度】
    • P(B)是预测器的先验概率。【在任何假设下得到这一数据的概率,称为标准化常量】

      朴素贝叶斯分类器假设类中特定特征和其它特征的存在无关,因为前提条件便是基于特征独立的。这也是这个算法被称为“朴素”的原因。

    二、贝叶斯算法数学原理

      这部分我建议大家去看李航老师的《统计学习方法》,我觉得写得很清楚,我这里就不过多赘述(也可能是我懒得打那些复杂的推导公式,我个人习惯在例子中搞明白)。

      这里直接上例题(例子来源于上书):

      例:由下表中的训练数据学习一个NB分类器并确定 x = ( 2 , S ) T x=(2,S)^T x=(2,S)T的类标记y,表中 x ( 1 ) x^{(1)} x(1) x ( 2 ) x^{(2)} x(2)为特征,取值的集合分别为 A 1 A_1 A1={1,2,3}, A 2 A_2 A2={S,M,L},Y为类标记,Y ∈ \in C={1,-1}.

    123456789101112131415
    x ( 1 ) x^{(1)} x(1)111112222233333
    x ( 2 ) x^{(2)} x(2)SMMSSSMMLLLMMLL
    Y Y Y-1-111-1-1-11111111-1

      首先我们分析目标变量(Target)Y:
    P ( Y = 1 ) = 9 15 , P ( Y = − 1 ) = 6 15 P(Y=1)=\frac{9}{15},P(Y=-1)=\frac{6}{15} P(Y=1)=159,P(Y=1)=156
      再看各特征的条件概率:
    P ( x ( 1 ) = 1 ∣ Y = 1 ) = 2 9 , P ( x ( 1 ) = 2 ∣ Y = 1 ) = 3 9 , P ( x ( 1 ) = 3 ∣ Y = 1 ) = 4 9 P(x^{(1)}=1|Y=1)=\frac{2}{9},P(x^{(1)}=2|Y=1)=\frac{3}{9},P(x^{(1)}=3|Y=1)=\frac{4}{9} P(x(1)=1Y=1)=92,P(x(1)=2Y=1)=93,P(x(1)=3Y=1)=94
    P ( x ( 2 ) = S ∣ Y = 1 ) = 1 9 , P ( x ( 2 ) = M ∣ Y = 1 ) = 4 9 , P ( x ( 2 ) = L ∣ Y = 1 ) = 4 9 P(x^{(2)}=S|Y=1)=\frac{1}{9},P(x^{(2)}=M|Y=1)=\frac{4}{9},P(x^{(2)}=L|Y=1)=\frac{4}{9} P(x(2)=SY=1)=91,P(x(2)=MY=1)=94,P(x(2)=LY=1)=94
    P ( x ( 1 ) = 1 ∣ Y = − 1 ) = 3 6 , P ( x ( 1 ) = 2 ∣ Y = − 1 ) = 2 6 , P ( x ( 1 ) = 3 ∣ Y = − 1 ) = 1 6 P(x^{(1)}=1|Y=-1)=\frac{3}{6},P(x^{(1)}=2|Y=-1)=\frac{2}{6},P(x^{(1)}=3|Y=-1)=\frac{1}{6} P(x(1)=1Y=1)=63,P(x(1)=2Y=1)=62,P(x(1)=3Y=1)=61
    P ( x ( 2 ) = S ∣ Y = − 1 ) = 3 6 , P ( x ( 2 ) = M ∣ Y = − 1 ) = 2 6 , P ( x ( 2 ) = L ∣ Y = − 1 ) = 1 6 P(x^{(2)}=S|Y=-1)=\frac{3}{6},P(x^{(2)}=M|Y=-1)=\frac{2}{6},P(x^{(2)}=L|Y=-1)=\frac{1}{6} P(x(2)=SY=1)=63,P(x(2)=MY=1)=62,P(x(2)=LY=1)=61
      再对于给定的 x = ( 2 , S ) T x=(2,S)^T x=(2,S)T:
    P ( Y = 1 ) P ( X ( 1 ) = 2 ∣ Y = 1 ) P ( X ( 2 ) = S ∣ Y = 1 ) = 9 15 ∗ 3 9 ∗ 1 9 = 1 45 P(Y=1)P(X^{(1)}=2|Y=1)P(X^{(2)}=S|Y=1)=\frac{9}{15}*\frac{3}{9}*\frac{1}{9}=\frac{1}{45} P(Y=1)P(X(1)=2Y=1)P(X(2)=SY=1)=1599391=451
    P ( Y = − 1 ) P ( X ( 1 ) = 2 ∣ Y = − 1 ) P ( X ( 2 ) = S ∣ Y = − 1 ) = 6 15 ∗ 2 6 ∗ 3 6 = 1 15 P(Y=-1)P(X^{(1)}=2|Y=-1)P(X^{(2)}=S|Y=-1)=\frac{6}{15}*\frac{2}{6}*\frac{3}{6}=\frac{1}{15} P(Y=1)P(X(1)=2Y=1)P(X(2)=SY=1)=1566263=151
      从这里便可以得出结果,下式概率大于上式,所以预测y=-1。

    贝叶斯估计(使用拉普拉斯平滑)

      如果我们要估计的概率值有为0的情况,这时会影响到后验概率的计算,使模型产生偏差,这时我们便需要进行贝叶斯估计,条件概率的贝叶斯估计式如下:
    P λ = Σ i = 1 N I ( y i = c k ) + λ N + K λ P_{\lambda}=\frac{\Sigma_{i=1}^N{I(y_i=c_k)}+\lambda}{N+K\lambda} Pλ=N+KλΣi=1NI(yi=ck)+λ
    P λ ( X ( j ) = a j i ∣ Y = c k ) = Σ i = 1 N I ( x i ( j ) = a i j , y i = c k ) + λ Σ i = 1 N I ( y i = c k ) + S i λ P_{\lambda}(X^{(j)}=a_{ji}|Y=c_k)=\frac{\Sigma_{i=1}^N{I(x_i^{(j)}=a_{ij},y_i=c_k)}+\lambda}{\Sigma_{i=1}^N{I(y_i=c_k)}+S_i\lambda} Pλ(X(j)=ajiY=ck)=Σi=1NI(yi=ck)+SiλΣi=1NI(xi(j)=aij,yi=ck)+λ
      则同样以例题形式,数据同上表,按照拉普拉斯平滑估计概率,即取 λ = 1 \lambda=1 λ=1
      公式推导我就不多说了,贝叶斯参数估计的公式其实就是在条件概率公式的分子加一个 λ \lambda λ,分母加一个 K λ K\lambda Kλ S i λ S_{i}\lambda Siλ,其中K为y的种类, S i S_i Si为某特征的种类,本题中y=1或-1,所以K=2, x ( 1 ) x^{(1)} x(1)有1,2,3这三种,即 S 1 S_1 S1=3。
      接下来我们来进行计算,同样先计算目标函数y:

    P ( Y = 1 ) = 9 + 1 15 + 2 ∗ 1 = 10 17 , P ( Y = − 1 ) = 6 + 1 15 + 2 ∗ 1 = 7 17 P(Y=1)=\frac{9+1}{15+2*1}=\frac{10}{17},P(Y=-1)=\frac{6+1}{15+2*1}=\frac{7}{17} P(Y=1)=15+219+1=1710,P(Y=1)=15+216+1=177
      再看各特征的条件概率:
    P ( x ( 1 ) = 1 ∣ Y = 1 ) = 2 + 1 9 + 3 = 3 12 P(x^{(1)}=1|Y=1)=\frac{2+1}{9+3}=\frac{3}{12} P(x(1)=1Y=1)=9+32+1=123
      这里分母为什么加3呢,因为这是特征 x ( 1 ) x^{(1)} x(1)有1,2,3这三种,即 S 1 S_1 S1=3,同理 x ( 2 ) x^{(2)} x(2)也有S,M,L三种,因此下面的 S 2 S_2 S2=3.
      计算结果如下:
    P ( x ( 1 ) = 2 ∣ Y = 1 ) = 4 12 , P ( x ( 1 ) = 3 ∣ Y = 1 ) = 5 12 P(x^{(1)}=2|Y=1)=\frac{4}{12},P(x^{(1)}=3|Y=1)=\frac{5}{12} P(x(1)=2Y=1)=124,P(x(1)=3Y=1)=125
    P ( x ( 2 ) = S ∣ Y = 1 ) = 2 12 , P ( x ( 2 ) = M ∣ Y = 1 ) = 5 12 , P ( x ( 2 ) = L ∣ Y = 1 ) = 5 12 P(x^{(2)}=S|Y=1)=\frac{2}{12},P(x^{(2)}=M|Y=1)=\frac{5}{12},P(x^{(2)}=L|Y=1)=\frac{5}{12} P(x(2)=SY=1)=122,P(x(2)=MY=1)=125,P(x(2)=LY=1)=125
    P ( x ( 1 ) = 1 ∣ Y = − 1 ) = 4 9 , P ( x ( 1 ) = 2 ∣ Y = − 1 ) = 3 9 , P ( x ( 1 ) = 3 ∣ Y = − 1 ) = 2 9 P(x^{(1)}=1|Y=-1)=\frac{4}{9},P(x^{(1)}=2|Y=-1)=\frac{3}{9},P(x^{(1)}=3|Y=-1)=\frac{2}{9} P(x(1)=1Y=1)=94,P(x(1)=2Y=1)=93,P(x(1)=3Y=1)=92
    P ( x ( 2 ) = S ∣ Y = − 1 ) = 4 9 , P ( x ( 2 ) = M ∣ Y = − 1 ) = 3 9 , P ( x ( 2 ) = L ∣ Y = − 1 ) = 2 9 P(x^{(2)}=S|Y=-1)=\frac{4}{9},P(x^{(2)}=M|Y=-1)=\frac{3}{9},P(x^{(2)}=L|Y=-1)=\frac{2}{9} P(x(2)=SY=1)=94,P(x(2)=MY=1)=93,P(x(2)=LY=1)=92
      再对于给定的 x = ( 2 , S ) T x=(2,S)^T x=(2,S)T:
    P ( Y = 1 ) P ( X ( 1 ) = 2 ∣ Y = 1 ) P ( X ( 2 ) = S ∣ Y = 1 ) = 10 17 ∗ 4 12 ∗ 2 12 = 5 153 = 0.0327 P(Y=1)P(X^{(1)}=2|Y=1)P(X^{(2)}=S|Y=1)=\frac{10}{17}*\frac{4}{12}*\frac{2}{12}=\frac{5}{153}=0.0327 P(Y=1)P(X(1)=2Y=1)P(X(2)=SY=1)=1710124122=1535=0.0327
    P ( Y = − 1 ) P ( X ( 1 ) = 2 ∣ Y = − 1 ) P ( X ( 2 ) = S ∣ Y = − 1 ) = 7 17 ∗ 3 9 ∗ 4 9 = 28 459 = 0.0610 P(Y=-1)P(X^{(1)}=2|Y=-1)P(X^{(2)}=S|Y=-1)=\frac{7}{17}*\frac{3}{9}*\frac{4}{9}=\frac{28}{459}=0.0610 P(Y=1)P(X(1)=2Y=1)P(X(2)=SY=1)=1779394=45928=0.0610
    因此,预测y=-1。

    三、朴素贝叶斯分类器的优缺点

    优点:

    • 预测测试数据集的类别是容易且快速的,它在多分类预测中也表现良好。
    • 当独立性假设成立时,朴素贝叶斯分类器与逻辑回归等其他模型相比表现更好,而且需要更少的训练数据。
    • 与数值变量相比,该模型在分类输入变量的情况下表现更好。
    • 对缺失数据不敏感,所以常用于文本分类。

    缺点:

    • 如果出现“零概率”时,模型不能进行预测。因此我们需要使用平滑技术。最简单的平滑技术之一是拉普拉斯评估。
    • 另一方面,朴素贝叶斯(Bayes)也被称为不好的估计器,所以来自predict_proba的概率输出不应该被过于重视。
    • 对训练数据的依赖性很强,如果训练数据误差较大,那么预测出来的效果就会不佳。
    • 朴素贝叶斯的另一个局限是独立预测因子的假设。在现实生活中,我们得到一组完全独立的预测变量几乎是不可能的。
      注:我们知道朴素贝叶斯模型中的输入变量都是条件独立的,这是该模型的基本前提,但如果输入变量之间存在概率依存关系,那这时模型就变成了贝叶斯网络。

    四、朴素贝叶斯算法的应用

      实时预测:该模型速度很快。 因此,它可以用于实时预测。

      多分类器:由贝叶斯公式可知,这种算法也是一个多分类器。因此我们可以预测多个目标变量类别的概率。

      文本分类/垃圾邮件过滤/情感分析:该模型被广泛用于垃圾邮件过滤识别和情感分析。可以用于文本分类,成功率很高。

      推荐系统:朴素贝叶斯分类器和协作过滤一起构建推荐系统,该系统使用机器学习和数据挖掘技术来过滤看不见的信息并预测用户是否喜欢给定的资源。

    五、朴素贝叶斯的分类

    sklearn库中有三种类型的朴素贝叶斯模型:

      高斯(Gaussian):它用于分类,它假设特征遵循正态分布,意思就是对连续型数据进行处理。

      多项式(Multinomial):用于离散计数。计算数据的条件概率(使用拉普拉斯估计器进行平滑的一个模型)。

      伯努利(Bernoulli):取值特征是布尔型,即ture或false,在进行文档分类时,就是一个单词有没有在一个文档中出现过。

    六、朴素贝叶斯的调优

    以下是提高Naive Bayes模型功能的一些建议:

    • 如果连续性特征不具有正态分布,则应采用变换或不同的方法将其转换为正态分布。
    • 如果测试数据集具有零频率问题,则应用平滑技术“拉普拉斯修正”来预测测试数据集的类别。
    • 删除相关特征,因为高度相关的特征在模型中被投票两次,并且可能导致过度膨胀的重要性。
    • 朴素贝叶斯是根据训练集进行分类,分类出来的结果基本上就是确定了的。所以是没有超参数可以调整的,只能通过alpha = 1来平滑,alpha值并不算超参数;或者使用fit_prior = [True | False]来学习- 类别先验概率。个人觉得用朴素贝叶斯模型的话要把重点放在数据的预处理和特征选择上。
    • 最后,一些常用的分类器组合技术是没有效果的,如集合,装袋和提高。因为它们的目的是减少变化。而朴素贝叶斯没有任何变化可以最小化。

    七、python实现代码

    直接在下一篇博客中,写之前kaggle竞赛的项目,项目中会用到NB,实现的话用sklearn是很简单的。稍微写一下核心(没有前后文,单独运行肯定是不行的)

    from sklearn.naive_bayes import GaussianNB
    from sklearn.metrics import accuracy_score
    from sklearn.naive_bayes import GaussianNB
    from sklearn.metrics import accuracy_score
    model = GaussianNB()
    # 用训练数据拟合
    model.fit(X_train,y_train)
    # 预测
    predict_train = model.predict(X_train)
    trainaccuracy = accuracy_score(y_train,predict_train)
    print('accuracy_score on train dataset : ', trainaccuracy)
    

    用sklearn库基本上这些机器学习代码就这么多,我只能说开发sklearn的是神。

    展开全文
  • 假定某个局部区域细胞识别中正常P(w1)和异常P(w2)两类先验概率分别为P(w1)=0.9, P(w2)=0.1现有一系列待观察的细胞,其观察值为:-2.67 -3.55 -1.24 -0.98 -0.79 -...依据最小错误率的贝叶斯决策对观察的结果进行分类
  • 伯努利朴素贝叶斯分类器主要用于文本分类,下面我们以一个具体的例子,来讲述下伯努利朴素贝叶斯的原理和实现逻辑。 具体例子: 已知我们有八个句子以及每个句子对应的类别,即中性或侮辱性。那么再给出一个句子,...
  • 朴素贝叶斯分类器

    2016-10-14 13:31:53
    一个简单自己写的朴素贝叶斯分类器
  • 本文实例讲述了Python实现的朴素贝叶斯分类器。分享给大家供大家参考,具体如下: 因工作中需要,自己写了一个朴素贝叶斯分类器。 对于未出现的属性,采取了拉普拉斯平滑,避免未出现的属性的概率为零导致整个条件...
  • 文章代码来自博客贝叶斯分类器,在这篇博客代码的基础上稍作修改 用朴素贝叶斯法实现对水果分类: 代码结构: bayes_classfier. py #贝叶斯分类器 datasets={'banala':{'long':400,'not_long':100,'sweet':350,'...

    文章代码来自博客贝叶斯分类器,在这篇博客代码的基础上稍作修改

    用朴素贝叶斯法实现对水果分类:
    在这里插入图片描述
    文件结构:
    在这里插入图片描述
    bayes_classfier. py

    #贝叶斯分类器
    datasets={'banala':{'long':400,'not_long':100,'sweet':350,'not_sweet':150,'yellow':450,'not_yellow':50},
                'orange':{'long':0,'not_long':300,'sweet':150,'not_sweet':150,'yellow':300,'not_yellow':0},
                'other_fruit':{'long':100,'not_long':100,'sweet':150,'not_sweet':50,'yellow':50,'not_yellow':150}}
    def count_total(data):
        #计算各种水果的总数
        count={}
        total=0
        for fruit in data :
            count[fruit]=data[fruit]['yellow']+data[fruit]['not_yellow']
            total+=count[fruit]
        return count,total
        #{'banala': 500, 'orange': 300, 'other_fruit': 200}   1000
    
    def cal_base_rates(data):
        #计算各种水果的先验概率,不同水果的占比
        categories,total=count_total(data)
        cal_base_rates={}
        for label in categories:
            priori_prob=categories[label]/total
            cal_base_rates[label]=priori_prob
        return cal_base_rates
         #{'banala': 0.5, 'orange': 0.3, 'other_fruit': 0.2}
    
    def likelihold_prob(data):
        #计算各个特征值在已知水果下的概率
         count,_=count_total(data)
         likelihold={}
         for fruit in data:
             attr_prob={}
             for attr in data[fruit]:
                 #计算各个特征值在已知水果下的概率
                 attr_prob[attr]=data[fruit][attr]/count[fruit]
             likelihold[fruit]=attr_prob
         return likelihold
         #{'banala': {'long': 0.8, 'not_long': 0.2, 'sweet': 0.7, 'not_sweet': 0.3, 'yellow': 0.9, 'not_yellow': 0.1}, 'orange': {'long': 0.0, 'not_long': 1.0, 'sweet': 0.5, 'not_sweet': 
         # 0.5, 'yellow': 1.0, 'not_yellow': 0.0}, 'other_fruit': {'long': 0.5, 'not_long': 0.5, 'sweet': 0.75, 'not_sweet': 0.25, 'yellow': 0.25, 'not_yellow': 0.75}}
        
    
    def evidence_prob(data):
        #计算特征的概率对分类结果的影响
        attrs=list(data['banala'].keys())
        count,total=count_total(data)
        evidence_prob={}
        for attr in attrs:
            attr_total=0
            for fruit in data:
                attr_total+=data[fruit][attr]
            evidence_prob[attr]=attr_total/total
        return evidence_prob
        #{'long': 0.5, 'not_long': 0.5, 'sweet': 0.65, 'not_sweet': 0.35, 'yellow': 0.8, 'not_yellow': 0.2}    
    
    class navie_bayes_classifier:
        #初始化贝叶斯分类器,实例化时会调用__ini__函数
        def __init__(self,data=datasets):
            self._data=datasets
            self._labels=[key for key in self._data.keys()]  #不同的水果
            self._priori_prob=cal_base_rates(self._data)   #水果先验概率
            self._likelihole_prob=likelihold_prob(self._data)   #各个特征值下水果的概率
            self._evidence_prob=evidence_prob(self._data)    #各种特征的概率
    
        def get_label(self,length,sweetness,color):
            self._attrs=[length,sweetness,color]
            res={}
            for label in self._labels:
                prob=self._priori_prob[label] #取某水果占比率
                #print(label ,"的占比率:",prob)
                for attr in self._attrs:
                    #单个水果的某个特征概率除以总的某个特征概率 再乘以某水果占比率
                    #print(self._likelihole_prob[label][attr])   
                    #print(self._evidence_prob[attr])
                    #print(self._likelihole_prob[label][attr]/self._evidence_prob[attr])
                    prob*=self._likelihole_prob[label][attr]/self._evidence_prob[attr]
                    #print(prob)
                res[label]=prob
            return res
    
    
    
    

    generate_attires. py

    #随机产生测试数据集来测试贝叶斯分类器的预测能力
    import random
    def rondom_attr(pair):
        #生成0~1之间的随机数
        return pair[random.randint(0,1)]
    
    def gen_attrs():
        #特征值的取值集合
        sets=[('long','not_long'),('sweet','not_sweet'),('yellow','not_yellow')]
        test_datasets=[]
        for i in range(3):
            #使用map函数来生成一组特征值
            test_datasets.append(list(map(rondom_attr,sets)))
        return test_datasets
    
    
    

    classfication. py

    #使用贝叶斯分类器对测试结果进行分类
    import operator
    import bayes_classfier
    import generate_attires
    def  main():
        test_datasets=generate_attires.gen_attrs()
        #print(test_datasets)
        classfier =bayes_classfier.navie_bayes_classifier()
        for data in test_datasets:
            print("特征值:",end='\t')
            print(data)
            print("预测结果:",end='\t')
            res=classfier.get_label(*data)#表示多参传入
            print(res)#预测属于哪种水果的概率
            print('水果类别:',end='\t')
            #对后验概率排序,输出概率最大的标签
            print(sorted(res.items(),key=operator.itemgetter(1),reverse=True)[0][0])
     
    if __name__ =='__main__':
        main()
    

    效果展示:

    在这里插入图片描述

    展开全文
  • 用的模型也是最简单的,就是用贝叶斯定理P(A|B) = P(B|A)*P(A)/P(B),计算每个类别在样本中概率(代码中是pLabel变量) 以及每个类下每个特征的概率(代码中是pNum变量)。 写得比较粗糙,对于某个类下没有此特征的...
  • 频率学派和贝叶斯学派 说起概率统计,不得不提到频率学派和贝叶斯学派,通过对概率的不同理解而演变的两个不同的概率学派。 频率学派 核心思想:需要得到的参数​是一个确定的值,虽然未知,但是不会因为样本的...
  • # -*- coding: utf-8 -*- ''' >>> c = Classy() >... 机器学习之路: python 朴素贝叶斯分类器 MultinomialNB 预测新闻类别 使用python3 学习朴素贝叶斯分类api 设计到字符串提取特征向量 欢迎来到我的git下载源代码: ...
  • 朴素贝叶斯分类器原理解析与python实现

    千次阅读 多人点赞 2020-08-18 15:39:22
    贝叶斯分类器是以贝叶斯原理为基础的分类器的总称,是一种生成式模型,朴素贝叶斯分类器是其中最简单的一种。要高明白贝叶斯分类器的原理,首先得明白一些基本概念。 预备知识 基本概念 先验概率:根据统计/经验...
  • Python实现朴素贝叶斯分类器

    千次阅读 2021-01-14 20:08:48
    我将数据集转成了csv格式方便Python读取: 青绿,蜷缩,浊响,清晰,凹陷,硬滑,0.697,0.46,是 乌黑,蜷缩,沉闷,清晰,凹陷,硬滑,0.774,0.376,是 乌黑,蜷缩,浊响,清晰,凹陷,硬滑,0.634,0.264,是 青绿,蜷缩,沉闷,清晰,凹陷,...
  • 在这篇文章中,我们将使用我最喜欢的机器学习库scikit-learn在Python中实现朴素贝叶斯分类器。接下来,我们将使用经过训练的朴素贝叶斯(监督分类法)模型来预测人口收入。在朴素贝叶斯分类器的文章中我们讨论了贝叶斯...
  • 本文实例讲述了Python实现朴素贝叶斯分类器的方法。分享给大家供大家参考,具体如下: 贝叶斯定理 贝叶斯定理是通过对观测值概率分布的主观判断(即先验概率)进行修正的定理,在概率论中具有重要地位。 先验概率...
  • 贝叶斯分类器以及Python实现

    万次阅读 多人点赞 2017-11-28 20:49:01
    贝叶斯分类器 贝叶斯分类器的分类原理是通过某对象的先验概率,利用贝叶斯公式计算出其后验概率,即该对象属于某一类的概率,选择具有最大后验概率的类作为该对象所属的类。 介绍一下先验概率:是指根据以往经验和...
  • 使用Python实现贝叶斯分类器。 二、实验原理 算法原理 假设y 的取值有y1,y2……yn. x的特征有x1,x2 ……xm. 则朴素贝叶斯及当x={x1i, x2i, ……xmi}时比较y取值概率的大小。 即max(p(y|{x1i, x2i, ……xmi})) 而p...
  • 贝叶斯分类器(Python实现+详细完整源码和原理)

    万次阅读 多人点赞 2018-08-16 17:20:20
    在概率和统计学领域,贝叶斯理论基于对...在机器学习领域,贝叶斯分类器是基于贝叶斯理论并假设各特征相互独立的分类方法, 基本方法是:使用特征向量来表征某个实体,并在该实体上绑定一个标签来代表其所属的类别...
  • 朴素贝叶斯算法步骤:贝叶斯估计代码:# -*- coding:utf-8 -*-# naive Bayes 朴素贝叶斯法#author:Tomator"""算法参考与李航博士《统计学习方法》采用贝叶斯估计(拉普拉斯平滑)计算先验概率和条件概率"""from ...
  • 关键词:Python、机器学习、贝叶斯分类器 一、贝叶斯分类器 在sklearn-learn官方封装好的模块中,已经有了BernoulliNB(伯努利分类器)、GaussianNB(高斯分类器)、MultinomialNB(多项式分类器)、ComplementNB...
  • 朴素贝叶斯分类器python实现

    千次阅读 2019-04-24 18:41:57
    贝叶斯公式概率论的一些基本知识: 条件概率:P(A|B)P(A|B) 联合概率:P(AB)=P(B)∗P(A|B)=P(A)∗P(B|A)P(AB)=P(B)*P(A|B)=P(A)*P(B|A) 从而导出贝叶斯式:P(A|B)=P(AB)|P(B)=P(A)∗P(B|A)/P(B)P(A|B)=P(AB)|P...
  • 朴素贝叶斯分类器朴素贝叶斯分类器的训练速度比线性模型更快。这种高效率所付出的代价是,朴素贝叶斯模型的泛化能力要比线性分类器(如 LogisticRegression 和 LinearSVC)稍差。朴素贝叶斯模型如此高效的原因在于,它...

空空如也

空空如也

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

贝叶斯分类器python