精华内容
下载资源
问答
  • 朴素Bayes

    2015-04-03 23:24:34
    下面是朴素bayes做男女名字分类的例子 部分女性名字 Abagael Abagail Abbe Abbey Abbi Abbie Abby Abigael 部分男性名字 Aamir Aaron Abbey Abbie Abbot Abbott Abby Abdel 目标是给一个名字如Bob然后输出...

    基本思想

    朴素贝叶斯法是基于贝叶斯定理与特征条件独立假设的分类方法。算法的基础是概率问题,分类原理是通过某对象的先验概率,利用贝叶斯公式计算出其后验概率,即该对象属于某一类的概率,选择具有最大后验概率的类作为该对象所属的类。朴素贝叶斯假设是约束性很强的假设,假设特征条件独立,但朴素贝叶斯算法简单,快速,具有较小的出错率。

    算法流程

    假设某个体有n项特征(Feature),分别为F1、F2、...、Fn。现有m个类别(Category),分别为C1、C2、...、Cm。贝叶斯分类器就是计算出概率最大的那个分类,也就是求下面这个算式的最大值:

    P(C|F1F2...Fn) 
      = P(F1F2...Fn|C)P(C) / P(F1F2...Fn)

    由于 P(F1F2...Fn) 对于所有的类别都是相同的,可以省略,问题就变成了求

    P(F1F2...Fn|C)P(C)

    的最大值。
    朴素贝叶斯分类器则是更进一步,假设所有特征都彼此独立,因此

    P(F1F2...Fn|C)P(C) 
      = P(F1|C)P(F2|C) ... P(Fn|C)P(C)

    贝叶斯定理之所以有用,是因为我们在生活中经常遇到这种情况:我们可以很容易直接得出P(A|B),P(B|A)则很难直接得出,但我们更关心P(B|A),贝叶斯定理就为我们打通从P(A|B)获得P(B|A)的道路。



    总结

    Bayes模型假设属性之间相互独立,这个假设在实际应用中往往是不成立的,这给Bayes模型的正确分类带来了一定影响。在属性个数比较多或者属性之间相关性较大时,Bayes模型的分类效率比不上决策树模型。而在属性相关性较小时,Bayes模型的性能良好。

    Bayes分类算法实现数字识别




    /******************************************************************
    *   函数名称:BayesErzhishuju()
    *   函数类型:int 
    *   函数功能:基于二值数据的Bayes分类器 ,返回手写数字的类别
    ******************************************************************/
    int Classification::BayesErzhishuju()
    {
    	double Pw[10];//先验概率P(wj)=Nj/N
    	double P[10][25];//Pj(wi)wi:wi类,j:第j个特征
    	double PXw[10];//类条件概率P(X|wj)
    	double PwX[10];//后验概率P(wj|X)
    
    	int i,j;
    
    	//求先验概率
    	int n[10];//各类样品数
    	int N=0;//样品总数
    	for(i=0;i<10;i++)
    	{
    		//各数字类别样品数
    		n[i]=pattern[i].number;
    		N+=n[i];//样品总数
    	}
    	for(i=0;i<10;i++)
    		Pw[i]=(double)n[i]/(double)N;//先验概率
    	
    	//求类条件概率
    	for(i=0;i<10;i++)
    	{
    		for(j=0;j<25;j++)
    		{
    			int numof1=0;//二值数据中1的个数
    			for(int k=0;k<pattern[i].number;k++)
    				numof1+=pattern[i].feature[k][j]>0.1?1:0;
    			P[i][j]=(double)(numof1+1)/(double)(n[i]+2);
    		}
    	}
    
    	for(i=0;i<10;i++)
    	{
    		double p=1;
    		for(int j=0;j<25;j++)
    		{
    			p*=(testsample[j]>0.1)?P[i][j]:1-P[i][j];
    		}
    		PXw[i]=p;
    	}
    
    	//求后验概率
    	double PX=0.0,maxP=0.0;
    	int number;
    	for(i=0;i<10;i++)
    	{
    		PX+=Pw[i]*PXw[i];
    	}
    
    	for(i=0;i<10;i++)
    	{
    		PwX[i]=Pw[i]*PXw[i]/PX;
    		if(PwX[i]>maxP)
    		{
    			maxP=PwX[i];
    			number=i;
    		}
    	}
    	return number;
    }
    
    /******************************************************************
    *   函数名称:BayesLeasterror()
    *   函数类型:int 
    *   函数功能:最小错误概率的Bayes分类器 ,返回手写数字的类别
    ******************************************************************/
    int Classification::BayesLeasterror()
    {
    	double X[25];//待测样品
    	double Xmeans[25];//样品的均值
    	double S[25][25];//协方差矩阵
    	double S_[25][25];//S的逆矩阵
    	double Pw;//先验概率
    	double hx[10];//判别函数
    	
    	int i,j,k,n;
    	
    	for(n=0;n<10;n++)//循环类别0~9
    	{
    		int num=pattern[n].number;//样品个数
    		//求样品平均值
    		for(i=0;i<25;i++)
    			Xmeans[i]=0.0;
    		for(k=0;k<num;k++)
    		{
    			for(i=0;i<25;i++)
    				Xmeans[i]+=pattern[n].feature[k][i]>0.10?1.0:0.0;
    		}
    		for(i=0;i<25;i++)
    			Xmeans[i]/=(double)num;
    		//求协方差矩阵
    		double mode[200][25];
    		for(i=0;i<num;i++)
    			for(j=0;j<25;j++)
    				mode[i][j]=pattern[n].feature[i][j]>0.10?1.0:0.0;
    		for(i=0;i<25;i++)
    		for(j=0;j<25;j++)
    		{
    			double s=0.0;
    			for(k=0;k<num;k++)
    				s=s+(mode[k][i]-Xmeans[i])*(mode[k][j]-Xmeans[j]);
    			s=s/(double)(num-1);
    			S[i][j]=s;
    		}
    		//求先验概率
    		int total=0;
    		for(i=0;i<10;i++)
    			total+=pattern[i].number;
    		Pw=(double)num/(double)total;
    		//求S的逆矩阵
    		for(i=0;i<25;i++)
    			for(j=0;j<25;j++)
    				S_[i][j]=S[i][j];
    
    		double(*p)[25]=S_;
    
    		brinv(*p,25);//S的逆矩阵
    		//求S的行列式
    		double (*pp)[25]=S;
    		double DetS;
    		DetS=bsdet(*pp,25);//S的行列式
    		//求判别函数
    		for(i=0;i<25;i++)
    			X[i]=testsample[i]>0.10?1.0:0.0;
    		for(i=0;i<25;i++)
    			X[i]-=Xmeans[i];
    		double t[25];
    		for(i=0;i<25;i++)
    			t[i]=0;
    		brmul(X,S_,25,t);
    		double t1=brmul(t,X,25);
    		double t2=log(Pw);
    		double t3=log(DetS+1);
    		hx[n]=-t1/2+t2-t3/2;
    	}
    
    	double maxval=hx[0];
    	int number=0;
    	//判别函数的最大值
    	for(n=1;n<10;n++)
    	{
    		if(hx[n]>maxval)
    		{
    			maxval=hx[n];
    			number=n;
    		}
    	}
    	return number;
    }
    
    /******************************************************************
    *   函数名称:BayesLeastRisk(double loss[10][10])
    *   函数类型:double*
    *   参数说明:double loss[10][10]:损失
    *   函数功能:最小风险的Bayes分类器 ,返回各类的风险值
    ******************************************************************/
    double* Classification::BayesLeastRisk(double loss[10][10])
    {
    	double X[25];//待测样品
    	double Xmeans[25];//样品的均值
    	double S[25][25];//协方差矩阵S
    	double S_[25][25];//S的逆矩阵
    	double P[10];//后验概率
    	double Pw;//先验概率
    	double hx[10];//判别函数
    	
    	int i,j,k,n;
    	
    	for(n=0;n<10;n++)//
    	{
    		int num=pattern[n].number;//样品个数
    		//求样品均值
    		for(i=0;i<25;i++)
    			Xmeans[i]=0.0;
    		for(k=0;k<num;k++)
    		{
    			for(i=0;i<25;i++)
    				Xmeans[i]+=pattern[n].feature[k][i]>0.2?1.0:0.0;
    		}
    		for(i=0;i<25;i++)
    			Xmeans[i]/=(double)num;
    		//求协方差矩阵
    		double mode[200][25];
    		for(i=0;i<num;i++)
    			for(j=0;j<25;j++)
    				mode[i][j]=pattern[n].feature[i][j]>0.2?1.0:0.0;
    		for(i=0;i<25;i++)
    		for(j=0;j<25;j++)
    		{
    			double s=0.0;
    			for(k=0;k<num;k++)
    				s=s+(mode[k][i]-Xmeans[i])*(mode[k][j]-Xmeans[j]);
    			s=s/(double)(num-1);
    			S[i][j]=s;
    		}
    		//求先验概率
    		int total=0;//样品总数
    		for(i=0;i<10;i++)
    			total+=pattern[i].number;
    		Pw=(double)num/(double)total;
    		//求S的逆矩阵
    		for(i=0;i<25;i++)
    			for(j=0;j<25;j++)
    				S_[i][j]=S[i][j];
    
    		double(*p)[25]=S_;
    
    		brinv(*p,25);//S的逆矩阵
    		//求S的行列式
    		double (*pp)[25]=S;
    		double DetS;
    		DetS=bsdet(*pp,25);//S的行列式
    		//求判别函数
    		for(i=0;i<25;i++)
    			X[i]=testsample[i]>0.2?1.0:0.0;
    		for(i=0;i<25;i++)
    			X[i]-=Xmeans[i];
    		double t[25];
    		for(i=0;i<25;i++)
    			t[i]=0;
    		brmul(X,S_,25,t);
    		double t1=brmul(t,X,25);
    		double t2=log(Pw);
    		double t3=log(DetS+1);
    		P[n]=-t1/2+t2-t3/2;
    	}
    	
    	for(n=0;n<10;n++)
    	{
    		double t=0.0;
    		for(i=0;i<10;i++)
    			t+=loss[n][i]*P[i];
    		hx[n]=t;
    	}
    	
    	return (double*)hx;
    }
    


    下面是朴素bayes做男女名字分类的例子
    部分女性名字
    Abagael
    Abagail
    Abbe
    Abbey
    Abbi
    Abbie
    Abby
    Abigael
    部分男性名字
    Aamir
    Aaron
    Abbey
    Abbie
    Abbot
    Abbott
    Abby
    Abdel

    目标是给一个名字如Bob然后输出是男的名字还是女的名字。

    #coding: utf-8
    import math
    import random
    from os.path import*
    def get_features(data, letters="abcdefghijklmnopqrstuvwxyz"):
            """Based on NLTK's names_demo_features."""
            name = data.lower()
            features = {}
            for letter in letters:
                features["startswith(%s)" % letter] = name[0] == letter
                features["endswith(%s)" % letter] = name[-1] == letter
                features["has(%s)" % letter] = letter in name
            features["length(%d)"%len(name)] = len(name)
            return features
    
    #x=[a1,a2,...,am]为一个待分类项,而每个a为x的一个特征属性
    #类别集合{y1,...,yn}
    
    class NaiveBayes:
        """A naïve Bayes classifier."""
        def __init__(self):
            self.wordPro = {}
            self.dicCount = {}
            self.wordCount = {}
            self.attri = set()
            self.priorScore = {}
     
        #计算每个label的数目
        def getdicCount(self, label):
            if label in self.dicCount.keys():
                self.dicCount[label] = self.dicCount[label] + 1
            else:
                self.dicCount[label] = 1
                
        #统计(yi,aj)数目
        def calculateWordPro(self, label, feature):
            
            for f in feature.items():
                #pro = {[label, word], num}
                if (label, f) in self.attri:
                    self.wordPro[(label, f)] = self.wordPro[(label, f)] + 1
                else:
                    self.attri.add((label, f))
                    self.wordPro[(label, f)] = 1
                
                if label in self.wordCount:
                    self.wordCount[label] = self.wordCount[label] + 1
                else:
                    self.wordCount[label] = 1
                
        #计算p(aj|yi)
        def getWordPro(self):
            for key in self.wordPro.keys():
                self.wordPro[key] = float(self.wordPro[key])/(self.wordCount[key[0]])
        #得到男、女名字的先验概率p(yi),这里取log
        def getPrior(self):
            for key in self.dicCount.keys():
                self.priorScore[key] = math.log(self.dicCount[key]/float(self.totalNum))
    
        def train(self, instances):
            #instance为元组,(label,name)
            self.totalNum = 0
            for instance in instances:
                self.totalNum =self.totalNum + 1        
                label = instance[0]
                self.getdicCount(label)                 
                feature = get_features(instance[1])           
                self.calculateWordPro(label, feature)        
            self.getPrior()                                
            self.getWordPro()                               
            self.sumValue = sum(self.wordCount.itervalues())     
            self.smooth = math.log((float(1))/self.sumValue)     
            print self.wordCount
    
        def classify(self, instance): 
            result = []
            #计算p(x|yi)*p(yi)
            for key in self.dicCount.keys():
                tempScore = self.priorScore[key]
                features=get_features(instance[1])
                for f in features.items():
                    if (key, f) in self.attri:
                        tempScore = tempScore +math.log(self.wordPro[key, f]) 
                    else:
                        tempScore = tempScore + self.smooth        #Laplace校准
                result.append((tempScore, key))
            #取最大作为分类类别
            return max(result)[1]
    
        def classify1(self, name): 
            result = []
            #计算p(x|yi)*p(yi)
            for key in self.dicCount.keys():
                tempScore = self.priorScore[key]
                features=get_features(name)
                for f in features.items():
                    if (key, f) in self.attri:
                        tempScore = tempScore +math.log(self.wordPro[key, f]) 
                    else:
                        tempScore = tempScore + self.smooth        #Laplace校准
                result.append((tempScore, key))
            #取最大作为分类类别
            return max(result)[1]
    
    def accuracy(classifier, test):
        correct = [classifier.classify(x) == x[0] for x in test]
        return float(sum(correct)) / len(correct)
    
    
    def load_data(namelist,datafile="names/*.txt"):
            label = splitext(basename(datafile))[0]
            with open(datafile, "r") as file:
                for line in file:
                    data = line.strip()
                    namelist.append((label,data))
    
    def test_names_nltk(namelist):
            """Classify names using NLTK features"""
            print "\ntest_names_nltk"
            load_data(namelist,"names/male.txt")
            load_data(namelist,"names/female.txt")
            random.seed(hash("names"))
            random.shuffle(namelist)
            train, test = namelist[:6000], namelist[6000:]
            classifier = NaiveBayes()
            classifier.train(train)
            print accuracy(classifier, test)
            s=''
            while s!='q':
                  s=raw_input("input a name \n")
                  print classifier.classify1(s)
    if __name__=="__main__":
       namelist=[]
       test_names_nltk(namelist)
    

    训练完成你可以试着输入几个名字试试看,准确率还可以

    参考:http://www.cnblogs.com/leoo2sk/archive/2010/09/17/naive-bayesian-classifier.html

    朴素贝叶斯理论推导与三种常见模型 - wepon的专栏 - 博客频道 - CSDN.NET


    贝叶斯学习及共轭先验




    展开全文
  • 朴素Bayes分类器是一种简单有效的机器学习工具. 本文用朴素Bayes分类器的原理推导出“朴素Bayes组合”公式, 并构造相应的分类器. 经过测试, 该分类器有较好的分类性能和实用性, 克服了朴素Bayes分类器精确度差的缺点...
  • 本文用朴素Bayes分类器的原理推导出“朴素Bayes组合”公式,并构造相应的分类器。经过测试,该分类器有较好的分类性能,克服了朴素Bayes分类器精确度差的缺点。 关键字 朴素 Bayes 公式 导言 朴素Bayes分类器是一种...

    源码和论文:

    Github源码

    论文已经发表。请多多指教。

    Markdown手稿

    基于朴素 Bayes 组合的集成分类器

    摘要

    朴素Bayes分类器是一种简单有效的机器学习工具。本文用朴素Bayes分类器的原理推导出“朴素Bayes组合”公式,并构造相应的分类器。经过测试,该分类器有较好的分类性能,克服了朴素Bayes分类器精确度差的缺点。

    关键字 朴素 Bayes 公式

    导言

    朴素Bayes分类器是一种简单易用的分类器,在文本分类方面表现出色。垃圾邮件过滤是它最为成功的商业应用。朴素Bayes分类器建立在条件独立假设的基础上,
    c(x)=argmaxcp(cx),p(cx)ip(xic)p(c). c(x)=\arg\max_c p(c|x), p(c|x)\sim \prod_ip(x_i|c)p(c).
    而这个假设比较强,通常无法被满足;计算出的后验概率和实际值也相差较大。不过,朴素Bayes分类器却不会因此而受太大影响。实际上,朴素Bayes分类器是一种可加模型,即有下述分解
    f(x)=i=1nfi(xi),x=(x1,x2,,xn). f(x)=\sum_{i=1}^nf_i(x_i), x=(x_1,x_2,\dots,x_n).
    和其他的机器学习方法一样,人们在原来的基础上提出了各种改进版本。本文提出的改进方法解决了朴素Bayes分类器的两个问题。

    1. 通常朴素Bayes分类器要么解决连续型的,要么解决离散型的,即p(xic)p(x_i|c)的分布类型是同一的。而本文的方法不受此限制。
    2. 在很多方面神经网络等机器学习算法和Bayes分类器是互补的。本文方法可以以非常简单的方式将两者结合起来。

    符号约定:若求和范围不会引起歧义,累加符号就简单写作i\sum_i,累乘符号写作i\prod_ip(xic)p(x_i|c)表示XXii个分量XiX_ixix_i是的条件概率,严格的写法是P(Xi=xic)P(X_i=x_i|c)

    朴素 Bayes 组合分类器

    本节主要推导朴素 Bayes 组合公式,并简述分类器的构造。

    朴素 Bayes 组合公式

    x=(x1,x2,,xm)x=(x_1,x_2,\cdots,x_m),即输入变量被分解成mm部分,在条件独立假设的基础上,通过简单变形即可得

    p(cx)ip(xic)p(c)ip(cxi)p(c)1m. p(c|x)\sim \prod_ip(x_i|c)p(c)\sim \prod_ip(c|x_i)p(c)^{1-m}.\\

    在算法设计上,下面的等价公式会比较好用
    lnp(cx)ilnp(cxi)+(1m)lnp(c). \ln p(c|x)\sim \sum_i\ln p(c|x_i) + (1-m)\ln p(c).
    作为分量,xix_i不必是1维;p(cxi)p(c|x_i)都是独立计算的,互不干扰,而且也不是每一个都必须用Bayes估计。如果第ii项使用分类器fif_i进行估计的,那么
    lnp(cx)ifi,c(xi)+(1m)lnp(c), \ln p(c|x)\sim \sum_i f_{i,c}(x_i) + (1-m)\ln p(c),
    其中fi,cf_{i,c}表示fif_icc上的分量。这就是说,我们只要用不同部分的数据独立训练多个训练分类器,然后简单求和就可以得到一个不错的分类器。这些分类器被称为基分类器(相当于线性代数中的基向量)。这是一种特殊的可加模型,也可以看成一种简单的集成机器学习,即把fi(xi)f_i(x_i)看成是fi(Pix)f_i(P_ix),其中PiP_ixxxix_i的投影。我们把这个公式叫做朴素Bayes组合公式,对应的分类器为朴素Bayes组合分类器。

    本文的方法最初是为了改进朴素Bayes分类器而提出的,允许任意组合不同的朴素Bayes分类器,如当面对包含连续变量和连续变量的机器学习问题时,可以组合基于Gauss分布和基于多项式的朴素Bayes分类器。但 (4) 式确实不是非要用朴素Bayes分类器计算p(cxi)p(c|x_i),而且实验也支持用其他分类器能大大提高精确度。此时,严格地说它不再是朴素Bayes分类器。

    分类器的推广

    作为加性模型的特殊形式,(5) 的一种简单推广是增加系数:
    lnp(cx)iαi(c)lnfi,c(xi)+β(c), \ln p(c|x)\sim \sum_i\alpha_i(c)\ln f_{i,c}(x_i) + \beta(c),
    这些系数可以通过遗传算法获得,而初始种群可根据(5)合理设置。这个推广将在以后的研究中实现。

    该分类器还可以对缺失型数据进行分类,比如,只知道x=(x1,x2,,xl)x=(x_1,x_2,\cdots,x_l),则只需
    lnp(cx)i=1llnfi,c(xi)+(1l)lnp(c), \ln p(c|x)\sim \sum_{i=1}^{l}\ln f_{i,c}(x_i) + (1-l)\ln p(c),

    算法设计

    算法基于公式 (5)。输入变量XX会被分解成mm部分,第ii部分作为第ii个基分类器的输入;这些分类器的输出则是共同的。根据分割后的样本,分类器被独立训练。具体的流程如下。

    算法

    1. 读入样本集 X,Y
    2. 构造朴素Bayes组合分类器,即选取一组基分类器
    3. 对输入进行分割,X1, X2,…,Xm
    4. 模型i拟合Xi,Y,i=1,2,…,m;
    5. 利用朴素Bayes组合公式(5),对任意输入xx计算概率值p(cx)p(c|x)
    6. 根据概率值给出预测值

    其中第3步根据属性的数据类型进行分割,基本原则是分离离散与连续变量;第4步可以并行计算,可获得较快的速度。

    离散型和连续型的分别通常是相对的。一般多数观测值的频率都比较小时,就应该被看作连续变量。

    实现

    算法的实现也非常简便。本文采用Python实现。主要依赖scikit-learn机器学习库。本文算法基于和朴素Bayes分类器一样的公式,因此它的实现只需继承scikit-learn提供的实现朴素Bayes算法的抽象类即可。

    源码上传到GitHub

    实验

    实验数据来自CCF人工智能竞赛平台https://www.datafountain.cn/competitions/337。为了使它成为一个分类问题,已经把输出变量分成三类。总共5000条数据,抽出30%作为测试数据。

    根据数据,输入变量被大致分为三个部分:0-1型,整数型,实数型。关键的原则依然是看数据的频数。选取适合的基分类器。集成的分类器将和这些基分类器(单独使用)进行比较。

    实验结果复合预期。无论耗时还是精确度,朴素Bayes组合分类器都是介于朴素Bayes分类器和其他分类器之间。该算法适用于那些允许牺牲一定精确度来节省时间的分类问题。

    结语

    本文利用本朴素Bayes组合公式设计出一种新的分类器,它是一种非常简便的集成机器学习方法。实验结果表明,算法在不是去太多精确度的情况下,可以提高算法性能。如果需要在精确度和计算时间之间权衡,那么可以使用本算法。

    如果基分类器都是朴素Bayes分类器,那么朴素Bayes组合的结果当然也是朴素Bayes分类器。这样就可以轻易组合出能处理混合不同分布类型的数据集,如本文中的实验数据,存在至少三种类型的分布。因为基分类器并不限于朴素Bayes分类器,所以对条件独立性的假设的依赖也减轻了,从而提高了精确度。

    由于,本分类器以依然保留了不完全的条件独立假设,因此精确度的提升也是有限的,不能和某些成熟的算法的竞争。但是,它的设计灵活而简单,并具有并行性,和那些“成熟算法”相比,适当的设置可以大大缩减计算时间,而不会显著降低精确度。因此,这个算法适合那些对计算时间有较高要求的领域。

    文献

    [1]Hastie, Trevor, Tibshirani. THE ELEMENTS OF STATISTICAL LEARNING: DATA MINING, INFERENCE, AND PREDICTION, SECOND EDITION[M]. Springer, 2001.

    [2] 李航. 统计学习方法[M]. 清华大学出版社, 北京, 2012.

    [3] 刘长龙. 从机器学习到深度学习 基于scikit-learn与TensorFlow的高效开发实战[M], 电子工业出版社,2019.

    Zhang H . The Optimality of Naive Bayes[C]// Seventeenth International Florida Artificial Intelligence Research Society Conference. 2004.

    I Rish, An Empirical Study of the Naïve Bayes Classifier[J], IJCAI 2001 Work Empir Methods Artif Intell, 2001,1(3).

    展开全文
  • 朴素Bayes方法

    2018-04-27 23:08:14
    朴素Bayes方法是一个经典的生成学习方法,基本思想也是对P(x | y)这个后验概率进行建模。这里我们先说明一下什么是先验概率,以及什么是后验概率。 先验概率 谈先验概率之前有必要了解一下先验概率分布,不敢说...

    朴素Bayes方法是一个经典的生成学习方法,基本思想也是对P(x | y)这个后验概率进行建模。这里我们先说明一下什么是先验概率,以及什么是后验概率。

    先验概率

    谈先验概率之前有必要了解一下先验概率分布,不敢说本质,笔者对先验概率分布的了解如下:

    先验概率分布就是我们对一个事件所发生的概率分布假设。比如:抛硬币实验,我们认为在抛硬币实验进行前,硬币的出现结果服从:出现正面1和出现反面0的二项分布。

    当然,看官们可能认为这是常识,但是,我们依然可以对抛硬币实验做另外一个不同的结果分布假设,硬币的出现结果服从:出现正面1和出现反面0,和出现‘硬币立起来’的多项式分布。
    这里的二项分布和多项式分布均为人为假设的先验概率分布。

    什么是先验概率?
    我们应该知道,‘某一个具体事件’是否发生是一个未来事件。比如,给你一枚硬币,在你没抛出硬币之前,这时候,你根据以往经验得知,我们抛硬币的先验概率分布是2项分布,出现正面朝上的概率为12。这里正面朝上的概率为p(A)=12就是先验概率。p(A)是怎样来的呢?我们说是已有经验。在机器学习中,经验表示的显然是Training set。

    举个栗子:
    给定一组训练数据{xi,yi}i=1n独立同分布,yi{0,1},那么显然,我们目标变量的先验概率分布就是二项分布。p(y=0)p(y=1)就是先验概率,而先验概率是根据经验得到的!所以,学习算法根据训练集,估计

    p(y=0)=i=1nI{yi=0}np(y=1)=1p(y=0)

    你说这玩意儿准不准?由Bernouli大数定律可知,当训练集样本比较多的时候就准。

    这一句是个人理解:注意!这里你完全可以附加一个你认为的先验概率!这是完全OK的!!!举个栗子,你在给学习算法一些训练数据之前,你给他一个Knowledge:p(y=1)=p(y=0)=12

    但是,没办法啊,如果你不给学习算法这个/这些Knowledge。那么学习算法在我们看来就是一个刚出生的婴儿。你要给它训练数据,它才有经验,才可能给你做一些你想要的决策。至于经验(训练数据)的多少,这个自己就看着办了。当然,数据多了,学习算法对p(y)的估计就越准。

    同理,p(x)我们也认为是先验概率,x服从的概率分布也是人为假设或者由训练样本去估计的先验概率分布。

    再举个栗子:

    两个人:A君和B君。A用多元高斯分布产生一组随机自变量的值;然后A把这些值给B,并告诉B这组值是独立同分布的,但不告诉B这组随机自变量的值服从什么分布。那么,B有两种方法猜测这个未知分布。
    1. 直接问A;
    2. 用训练数据估计概率分布。

    第一种方法就对应的是人为假设!第2种方法对应的就是估计。当然,对于第一种办法:B问A的话,A完全有可能欺骗B,这时候,人为假设就会出错!对于第二种办法:估计就比较麻烦了,得看数据的特性,画出直方图等等一系列辅助我们做估计的东西。然后看它像哪种分布。

    一般情况下都是第一种办法,也就是人为假设数据服从一种具体的分布。比如,我们假设x ~ N(μ,σ2)这种正态分布,至于其中的参数μσ,一种是直接给定,一般情况下是通过数据进行估计。

    后验概率

    嘛是后验概率?咱们从字面意思理解:后面去验证的概率。机器学习的目标就是由自变量的值去预测因变量的值。在我们拿到一个自变量之后,去预测这个自变量对应的因变量值出现的概率,这就是后验概率。也就是说,后验概率其实是机器学习的一般目标。稍微正式一点的描述如下:

    x是自变量,y是预测目标。后验概率是一种条件概率:p(y|x):即在给定自变量条件下,某个因变量的值出现的概率。

    条件概率

    我们在上一章说到,后验概率是一种条件概率。那么条件概率是什么呢?假设两个事件A和B,在B发生的条件下,求A发生的概率P(A | B)即为条件概率。若事件A和事件B相互独立,那么P(A) = P(A | B)。举个栗子:若事件A表示第一次掷硬币出现正面朝上,事件B表示第2次掷硬币出现正面朝上。那么显然,事件A和事件B是相互独立的。

    再扯飘一点:量子纠缠理论出现后,鬼知道宇宙中任意两个事件是不是相互独立的。

    Naive Bayes

    朴素Bayes是一种经典的生成学习方法,它的基本假设是条件独立性假设。
    对后验概率P(x|y)建模,然后利用贝叶斯公式
    P(y|x)=P(x|y)P(y)P(x)得到后验概率。

    条件独立性假设是指条件属性之间相互独立,那么

    P(x|y)=i=1mP(xi|y)
    其中xi表示样本x的第i个属性上的取值。
    (xi,yi)i=1n为训练集,其中yi{1,,k}D={D1,,Dk},其中Di表示第i个类别的样本集合。
    先验概率的估计:P(y=c)=|Dc|n
    对离散型的条件属性来说,条件概率的估计 P(xi|y=c)=|Dc,xi||Dc|,其中Dc,xi表示第c个类别中样本x在第i个属性上的取值为xi的样本集合。
    对连续型的条件属性来说,考虑概率密度函数,条件概率的估计
    P(xi|y=c)=12πσc,xie(xiμc,xi)22σc,i2

    然后选择使得后验概率最大的决策属性作为一个新样本的分类决策,即
    c=argmaxc{1,,k}P(y=c|x)=argmaxc{1,,k}P(x|y=c)P(y=c)
    =argmaxc{1,,k}P(y=c)i=1mP(xi|y=c)

    为了避免因数太小导致运行时溢出,实践中经常将连乘转化为对数连加的方法。

    展开全文
  • 极大似然估计&朴素bayes

    极大似然估计&朴素bayes
    这里写图片描述
    这里写图片描述
    这里写图片描述

    展开全文
  • BAYES和朴素BAYES

    2018-05-14 23:28:00
     朴素贝叶斯算法仍然是流行的十大挖掘算法之一,该算法是有监督的学习算法,解决的是分类问题,如客户是否流失、是否值得投资、信用等级评定等多分类问题。该算法的优点在于简单易懂、学习效率高、在某些领域的分类...
  • 朴素bayes 算法

    2017-12-03 16:30:14
    贝叶斯算法 bayes
  • 朴素bayes实现

    2019-06-24 09:55:50
    朴素贝叶斯理解 参考:https://www.cnblogs.com/marc01in/p/4775440.html 实验流程 代码实现 main.py #coding:utf-8 #朴素贝叶斯算法 贝叶斯估计, λ=1 K=2, S=3; λ=1 拉普拉斯平滑 import pandas ...
  • 以下对决策树、最近邻、朴素Bayes、单层神经网络和线性支持向量机稍作介绍。 决策树是可以实现分类和回归的树形结构,根节点是所有样本,内部节点是其父节点对应集合符合或不符合某个属性的子集,叶节点是已分好...
  • 朴素bayes实战

    2017-05-18 15:00:45
    ###朴素bayes分类函数########## def classifyNB (vec2Classify, p0Vec, p1Vec, pClass1) : p1 = sum(vec2Classify * p1Vec) + log(pClass1) #element-wise mult p0 = sum(vec2Classify * p0Vec) + log( ...
  • 朴素Bayes分类实践

    2018-09-25 17:39:00
    一、回顾概率论  1、条件概率,这个公式说白了就是不同样本空间下的概率问题!  2、全概率公式,证明不难。  3、贝叶斯公式,这个公式可厉害了,根据原有的数据,由因知果,再执果索因。根据上述公式,推导...
  • 2019独角兽企业重金招聘Python工程师标准>>> ...
  • 朴素贝叶斯是贝叶斯分类中最简单的一种,而贝叶斯定理是关于随机事件A和B的一则定理。即为P(A|B)实在B发生情况下A发生的可能性。 朴素贝叶斯算法特点 优点:在数据较少的情况下仍然有效,可以处理多类问题。 缺点...
  • 算法杂货铺——分类算法之朴素贝叶斯分类(Naive Bayesian classification): http://www.cnblogs.com/leoo2sk/archive/2010/09/17/naive-bayesian-classifier.html 里面包含 离散和连续型数据两种的处理方式. ...
  • 1、算法基本原理我是这样理解的,通过已知的训练数据及其对应的类别,利用...另外,该算法中的“朴素”二字说明此方法存在一个很强的假设:用于分类的特征,即特征向量的每一维度间,在类别确定的条件下是相互独立的。
  • 朴素bayes公式分类器

    2009-12-25 16:22:50
    朴素贝叶斯文本分类模型分为两种: * 文档型 * 词频型 都是使用下式计算进行分类: cNB=arg Max( P(cj) * ∏1C P(xi|cj) ) 其中,P(cj)为类别j的先验概率,P(xi|cj)为特征量 xi在类别cj的类条件概率 ...
  • 朴素贝叶斯(Naive Bayes)原理+编程实现拉普拉斯修正的朴素贝叶斯分类器,以西瓜数据集3.0为训练集,对“测1”样本进行判别。
  • 朴素贝叶斯Naive Bayes

    2019-09-29 18:53:53
    1.朴素贝叶斯Naive Bayes Bayes是一个宗教信徒,他试图证明神的存在,他本身不naive,然而他的算法很naive 1.1GaussianNB算法使用示例 >>> import numpy as np >>> X = np.array([[-1, ...
  • 朴素贝叶斯 Naive Bayes

    2019-10-06 21:06:36
    朴素贝叶斯分类器是一种典型的监督学习的算法,其英文是Naive Bayes。所谓Naive,就是天真的意思,当然这里翻译为朴素显得更学术化。 其核心思想就是利用贝叶斯公式来计算各个类别的概率,最后从中选择概率最大的...
  • naivebayes分类

    2017-06-20 16:00:25
    尽管matlab提供了朴素bayes的函数,但要理解朴素bayes还是自己编程实现为好。这是以IRIS数据集为例,用朴素bayes方法分类的程序。 文件列表: iris_te.mat iris_tr.mat naivebayes.m
  • 朴素贝叶斯NaiveBayes以及python实现
  • 朴素贝叶斯:bayes

    2018-10-04 16:38:59
      朴素贝叶斯分类是一种常用的分类算法,他根据研究对象的某些特征,来推断出该研究对象属于该研究领域的哪个类别。 1. 概述   要了解朴素贝叶斯分类,就需要先知道贝叶斯分类定理,这就离不开条件概率,下面...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,379
精华内容 951
关键字:

朴素bayes