精华内容
下载资源
问答
  • 1 概率基础回顾 1。概率的定义:一件事情发生的可能性, P(X) 取值范围为[0,1] ...2 朴素贝叶斯算法 2.1。朴素?假设:特征与特征之间是相互独立 !!! 2.2。贝叶斯公式:P(C|W) = P(W|C)P© / P(W) 注:W 为

    1 概率基础回顾

    1。概率的定义:一件事情发生的可能性, P(X) 取值范围为[0,1]
    2。联合概率:包含多个条件,且所有条件同时成立的概率:P(A, B)
    3。条件概率:就是事件A在另外一个事件B已经发生条件下的发生概率:P(A|B),P(A,C|B)
    4。相互独立:P(A, B) = P(A)P(B) <=> 事件A与事件B相互独立
    

    2 朴素贝叶斯算法

    2.1。朴素?假设:特征与特征之间是相互独立 !!!

    2.2。贝叶斯公式:P(C|W) = P(W|C)P© / P(W) 注:W 为给定文档的特征值(频数统计,预测文档提供),C 为文档类别

            推广到一般公式:P(C|F1,F2,...) = P(F1,F2,...|C)P(C) / P(F1,F2,...)  其中 C 可以是不同类别
                    注:P(F1,F2,...): 为预测文档中,每个词的概率
                       P(C):每个文档类别的概率(某文档的类别数 / 总文档数量)
                       P(W|C) :给定类别特征下(被预测文档中出现的词)的概率
    

    2.3。朴素贝叶斯算法:朴素 + 贝叶斯

    2.4。应用场景:文本分类 单词作为特征

    2.5。拉普拉斯平滑系数:目的:为了防止计算出的分类概率为0: P(F1|C) = (Ni +a) / (N + am)

            注:a 为指定的系数,一般为1, m 为训练文档中统计出的特征词个数
    

    2.6。朴素贝叶斯算法流程: 获取数据、划分数据集、特征工程、文本特征抽取、朴素贝叶斯预估器流程、模型评估

    2.7。朴素贝叶斯算法总结:

        优点:对缺失数据不太敏感,算法也比较简单,常用于文本分类。分类准确度高,速度快
        缺点:由于使用了样本属性独立性的假设,所以如果特征属性有关联时其效果不好
    

    3 文本分类的一个例子

    3.1

                文档ID        文档中的词                       属于 C = CHINA 类 
    训练集         1    Chinese, Beijing, Chinese                  yes
                  2    Chinese,Chinese, Shanghai                  yes
                  3    Chinese Macao                              yes
                  4    Tokyo, Chinese, Japan                      no
    测试集         5    Chinese Chinese Chinese Tokyo Japan        ?
    

    3.2

        P(C|Chinese,Chinese,Chinese,Tokyo,Japan) 
            =  P (Chinese,Chinese,Chinese,Tokyo,Japan|C) * P(C) / P(Chinese,Chinese,Chinese,Tokyo,Japan)    
        
        P (Chinese,Chinese,Chinese,Tokyo,Japan|C) = (P(Chinese|C)^3) * P(Tokyo|C) * P(Japan|C) 
        P(Chinese,Chinese,Chinese,Tokyo,Japan) = (P(Chinese)^3) * P(Tokyo) * P(Japan) = ((6/11)^3) * (1/11) * (1/11)
    * 统一都要加上拉普拉斯平滑系数
        解释:5 + 1 -> 属于 C = CHINA 类的情况下,特征词为 Chinese 的一共有5个;拉普拉斯平滑系数为1*1 = 1
             8 + 6 -> 属于 C = CHINA 类的情况下,总共有8个单词;所有文档下,总共有6种不同的单词 ,即 有6种特征词
        P(C) = 3/4      :4个文档种,共有3个属于 C = CHINA 类 
        P(Chinese|C) = (5+1)/(8+6) = 6/14 = 3/7
        P(Tokyo|C) = (0+1)|(8+6) = 1/14
        P(Japan|C) = (0+1)|(8+6) = 1/14  
    

    3.3

    P(非C|Chinese,Chinese,Chinese,Tokyo,Japan) = P (Chinese,Chinese,Chinese,Tokyo,Japan|非C) * P(非C) / P(Chinese,Chinese,Chinese,Tokyo,Japan)  
    

    4 朴素贝叶斯算法代码原理实现

    import numpy as np
    
    class NaiveBayes_classifier():
        def __init__(self):
            self.classes = None
            self.x_data = None
            self.y_target = None
            # 存储每个类别标签数据集中每个特征中每个特征值的出现概率
            self.parameters = []
    
    
        def fit(self, x_data, y_target):
            self.x_data = x_data
            self.y_target = y_target
            self.classes = np.unique(y_target)
            # 遍历所有类别的数据集,计算每一个类别数据集每个特征中每个特征值的出现概率
            for i in range(len(self.classes)):
                c = self.classes[i]
                # 选出该类别的数据集
                x_where_c = x_data[np.where(y_target == c)]
                self.parameters.append([])
                # 遍历该类别数据的所有特征,计算该类别数据集每个特征中每个特征值的出现概率
                for j in range(x_where_c.shape[1]):
                    feautre_values_where_c_j = np.unique(x_where_c[:, j])
                    parameters = {}
                    # 遍历整个训练数据集该特征的所有特征值(如果遍历该类别数据集x_where_c中该特征的所有特征值,
                    # 则每列的特征值都不全,因此整个数据集X中存在但是不在x_where_c中的特征值将得不到其概率,
                    # feautre_values_where_c_j), 计算该类别数据集该特征中每个特征值的出现概率
                    for feature_value in x_data[:, j]:  # feautre_values_where_c_j
                        n_feature_value = x_where_c[x_where_c[:, j] == feature_value].shape[0]
                        # 用Laplance平滑对概率进行修正, 并且用取对数的方法将累乘转成累加的形式
                        parameters[feature_value] = np.log((n_feature_value + 1) /(x_where_c.shape[0] + len(feautre_values_where_c_j)))
                    self.parameters[i].append(parameters)
            return None
    
    
        # 计算先验概率
        def calculate_prior_probability(self, c):
            x_where_c = self.x_data[np.where(self.y_target == c)]
            n_samples_for_c = x_where_c.shape[0]
            n_samples = self.x_data.shape[0]
            return (n_samples_for_c + 1) / (n_samples + len(self.classes))
    
    
        def classify(self, sample):
            posteriors = []
            # 遍历所有类别
            for i in range(len(self.classes)):
                c = self.classes[i]
                prior = self.calculate_prior_probability(c)
                posterior = np.log(prior)
                # probability = P(Y)*P(x1|Y)*P(x2|Y)*...*P(xN|Y)
                # 遍历所有特征
                for j, params in enumerate(self.parameters[i]):
                    # 取出预测样本的第j个特征
                    sample_feature = sample[j]
                    # 取出参数中第i个类别第j个特征特征值为sample_feature的概率, 如果测试集中的样本
                    # 有特征值没有出现, 则假设该特征值的概率为1/self.X.shape[0]
                    proba = params.get(sample_feature, np.log(1 / self.x_data.shape[0]))
                    # 朴素贝叶斯模型假设特征之间条件独立,即P(x1,x2,x3|Y) = P(x1|Y)*P(x2|Y)*P(x3|Y)
                    posterior += proba
                posteriors.append(posterior)
            # 对概率进行排序
            index_of_max = np.argmax(posteriors)
            max_value = posteriors[index_of_max]
            return self.classes[index_of_max]
    
        # 对数据集进行类别预测
        def predict(self, x_data):
            y_predict = []
            for sample in x_data:
                y = self.classify(sample)
                y_predict.append(y)
            return np.array(y_predict)
    

    4.2 对朴素贝叶算法实现代码进行测试

    import numpy as np
    from my_Preprocessing import train_test_split, accuracy_rate
    from my_NaiveBayes import NaiveBayes_classifier
    
    
    def NaiveBayes_classification():
        x_data = np.array([
            ['M','北京'], ['F', '上海'], ['M' ,'广州'], ['M' ,'北京'], ['F' ,'上海'],
            ['M','北京'], ['F', '上海'], ['M' ,'广州'], ['M' ,'北京'], ['F' ,'上海']])
        y_target = np.array([1,0,1,1,0,
                             1,0,1,1,0])
        x_train, x_test, y_train, y_test = train_test_split(x_data, y_target, test_size=0.3)
        estimator = NaiveBayes_classifier()
        estimator.fit(x_train, y_train)
        y_predict = np.array(estimator.predict(x_test))
        accu = accuracy_rate(y_test, y_predict)
        print('预测准确率 %s' % accu)
        return None
    

    5 朴素贝叶斯算法应用实战

    from sklearn.datasets import load_digits
    from sklearn.model_selection import train_test_split
    from sklearn.naive_bayes import MultinomialNB
    
    
    def naiveBayes_WNR_basics():
        # 1)获取数据
        digits = load_digits()
        # 2) 数据集划分
        x_train, x_test, y_train, y_test = train_test_split(digits.data, digits.target, test_size=0.2,random_state=2)
        # 3)朴素贝叶斯算法预估器流程
        estimator = MultinomialNB()
        estimator.fit(x_train, y_train)
        # 4)模型评估
        print('朴素贝叶斯基础模型准确率为: %s' % estimator.score(x_test, y_test))
    
    展开全文
  • 朴素贝叶斯算法

    万次阅读 多人点赞 2019-07-07 22:32:22
    贝叶斯算法概述 贝叶斯算法的提出: 贝叶斯定理 贝叶斯推导实例 男生、女生穿长裤 拼写纠错实例 贝叶斯算法概述 正向概率:假设袋子里面有N个白球,M个黑球,你伸手进去摸出黑球的概率...

    本文参考唐宇迪的课程,博客https://www.zhoulujun.cn/html/theory/math/2017_0913_8050.html

    目录

    贝叶斯算法概述

         贝叶斯算法的提出:

         贝叶斯定理

    贝叶斯推导实例

         男生、女生穿长裤

         拼写纠错实例

     


    贝叶斯算法概述

    正向概率:假设袋子里面有N个白球,M个黑球,你伸手进去摸出黑球的概率是多大?

    逆向概率:如果我们事先并不知道袋子里面黑白球的比例,而是闭着眼睛摸出一个或者好几个球,观察这些取出来的球的颜色之后,那么我们可以就此对袋子里面的黑白球的比例作出什么样的预测呢?

    关于上面的两个问题,正向概率我们很容易想到如何去解决,但是逆向概率,我们就不知道如何下手了,不过不要担心,贝叶斯就是为了解决“逆概率”而提出的。

         贝叶斯算法的提出:

    长久以来,人们对一件事情发生或不发生的概率,只有固定的0和1,即要么发生,要么不发生,从来不会去考虑某件事情发生的概率有多大,不发生的概率又是多大。而且概率虽然未知,但最起码是一个确定的值。比如如果问那时的人们一个问题:“有一个袋子,里面装着若干个白球和黑球,请问从袋子中取得白球的概率是多少?”他们会想都不用想,会立马告诉你,取出白球的概率就是1/2,要么取到白球,要么取不到白球,即θ只能有一个值,而且不论你取了多少次,取得白球的概率θ始终都是1/2,即不随观察结果X 的变化而变化。

        这种频率派的观点长期统治着人们的观念,但是:

    v2-75b7149ad3a020edcc0b0f3c5aa64de7_b.png

    假设我们有如下的7个球在A,B两个框中,如果我们随便取一个球,已知取到的球来自B框中,那么这个球是白球的概率是多少呢?或者问去除的球是白色,那么取自B框的概率是多少呢?这个问题不是很好解决,直到后来一个名叫Thomas Bayes的人物出现。

      托马斯·贝叶斯Thomas Bayes(1702-1763)在世时,并不为当时的人们所熟知,很少发表论文或出版著作,与当时学术界的人沟通交流也很少,用现在的话来说,贝叶斯就是活生生一民间学术“屌丝”,可这个“屌丝”最终发表了一篇名为“An essay towards solving a problem in the doctrine of chances”,翻译过来则是:机遇理论中一个问题的解。你可能觉得我要说:这篇论文的发表随机产生轰动效应,从而奠定贝叶斯在学术史上的地位。

    20141110191248285 (1).jpg

        回到上面的例子:“有一个袋子,里面装着若干个白球和黑球,请问从袋子中取得白球的概率θ是多少?”贝叶斯认为取得白球的概率是个不确定的值,因为其中含有机遇的成分。比如,一个朋友创业,你明明知道创业的结果就两种,即要么成功要么失败,但你依然会忍不住去估计他创业成功的几率有多大?你如果对他为人比较了解,而且有方法、思路清晰、有毅力、且能团结周围的人,你会不由自主的估计他创业成功的几率可能在80%以上。这种不同于最开始的“非黑即白、非0即1”的思考方式,便是贝叶斯式的思考方式。

        继续深入讲解贝叶斯方法之前,先简单总结下频率派与贝叶斯派各自不同的思考方式:

     

    • 频率派把需要推断的参数θ看做是固定的未知常数,即概率θ虽然是未知的,但最起码是确定的一个值,同时,样本X 是随机的,所以频率派重点研究样本空间,大部分的概率计算都是针对样本X 的分布;

    • 而贝叶斯派的观点则截然相反,他们认为参数θ是随机变量,而样本X 是固定的,由于样本是固定的,所以他们重点研究的是参数θ的分布。

        相对来说,频率派的观点容易理解,所以下文重点阐述贝叶斯派的观点。 贝叶斯派既然把θ看做是一个随机变量,所以要计算θ的分布,便得事先知道θ的无条件分布,即在有样本之前(或观察到X之前),θ有着怎样的分布呢?比如往台球桌上扔一个球,这个球落会落在何处呢?如果是不偏不倚的把球抛出去,那么此球落在台球桌上的任一位置都有着相同的机会,即球落在台球桌上某一位置的概率服从均匀分布。这种在实验之前定下的属于基本前提性质的分布称为先验分布,或者无条件分布。

        至此,贝叶斯及贝叶斯派提出了一个思考问题的固定模式:

                先验分布 π(θ)+ 样本信息χ⇒  后验分布π(θ|x)

    上述思考模式意味着,新观察到的样本信息将修正人们以前对事物的认知。换言之,在得到新的样本信息之前,人们对的认知是先验分布 π(θ),在得到新的样本信息后χ,人们对θ的认知为π(θ|x)。

    而后验分布π(θ|x)一般也认为是在给定样本χ的情况下θ的条件分布,而使达到最大的值称为最大后θMD验估计,类似于经典统计学中的极大似然估计。

        综合起来看,则好比是人类刚开始时对大自然只有少得可怜的先验知识,但随着不断是观察、实验获得更多的样本、结果,使得人们对自然界的规律摸得越来越透彻。所以,贝叶斯方法既符合人们日常生活的思考方式,也符合人们认识自然的规律,经过不断的发展,最终占据统计学领域的半壁江山,与经典统计学分庭抗礼。

        此外,贝叶斯除了提出上述思考模式之外,还特别提出了举世闻名的贝叶斯定理。

         贝叶斯定理

      在引出贝叶斯定理之前,先学习几个定义:

    • 边缘概率(又称先验概率):某个事件发生的概率。边缘概率是这样得到的:在联合概率中,把最终结果中那些不需要的事件通过合并成它们的全概率,而消去它们(对离散随机变量用求和得全概率,对连续随机变量用积分得全概率),这称为边缘化(marginalization),比如A的边缘概率表示为P(A),B的边缘概率表示为P(B)。 

    • 联合概率表示两个事件共同发生的概率。A与B的联合概率表示为P(A∩B)或者P(A,B)。

    • 条件概率(又称后验概率:事件A在另外一个事件B已经发生条件下的发生概率。条件概率表示为P(A|B),读作“在B条件下A的概率”,。

      接着,考虑一个问题:P(A|B)是在B发生的情况下A发生的可能性。

    • 首先,事件B发生之前,我们对事件A的发生有一个基本的概率判断,称为A的先验概率,用P(A)表示;

    • 其次,事件B发生之后,我们对事件A的发生概率重新评估,称为A的后验概率,用P(A|B)表示;

    • 类似的,事件A发生之前,我们对事件B的发生有一个基本的概率判断,称为B的先验概率,用P(B)表示;

    • 同样,事件A发生之后,我们对事件B的发生概率重新评估,称为B的后验概率,用P(B|A)表示。

    贝叶斯定理便是基于下述贝叶斯公式:

    u=239894515,405307697&fm=58.jpeg

    P(A|B)=P(B|A)P(A)/P(B)

    上述公式的推导其实非常简单,就是从条件概率推出。

     根据条件概率的定义,在事件B发生的条件下事件A发生的概率是

    P(A|B)=P(A∩B)/P(B)

    同样地,在事件A发生的条件下事件B发生的概率

    P(B|A)=P(A∩B)/P(A)

     

    整理与合并上述两个方程式,便可以得到:

    P(A|B)P(B)=P(A∩B)=P(B|A)P(A)

        接着,上式两边同除以P(B),若P(B)是非零的,我们便可以得到贝叶斯定理的公式表达式:

    P(A|B)=P(B|A)*P(A)/P(B)

    P(A|B) 和 P(B|A) 之类的经常让人混淆,有人给出了理解的一个关键点,区分出规律和现象,就是将A看成“规律”,B看成“现象”,那么贝叶斯公式看成:

    《这的理解贝叶斯公式吗》、《又一个生活中的贝叶斯应用》也给出了几个通俗易懂的例子,感兴趣的同学可以去看看。

    贝叶斯推断的含义

    然后搜下,发现其实还有更好阐释,比如

    对条件概率公式进行变形,可以得到形式:后验概率 = 先验概率 x 调整因子。

    我们把P(A)称为"先验概率"(Prior probability),即在B事件发生之前,我们对A事件概率的一个判断。P(A|B)称为"后验概率"(Posterior probability),即在B事件发生之后,我们对A事件概率的重新评估。

    P(B|A)/P(B)称为"可能性函数"(Likelyhood),这是一个调整因子,使得预估概率更接近真实概率。

    所以,条件概率可以理解成下面的式子:

    后验概率 = 先验概率 x 调整因子

    这就是贝叶斯推断的含义。我们先预估一个"先验概率",然后加入实验结果,看这个实验到底是增强还是削弱了"先验概率",由此得到更接近事实的"后验概率"。

    在这里,如果"可能性函数"P(B|A)/P(B)>1,意味着"先验概率"被增强,事件A的发生的可能性变大;如果"可能性函数"=1,意味着B事件无助于判断事件A的可能性;如果"可能性函数"<1,意味着"先验概率"被削弱,事件A的可能性变小。

    最后,我们为什么需要贝叶斯呢?1. 现实世界本身就是不确定的,人类的观察能力是有局限性的。​ 2.​ 我们日常所观察到的只是事物表面上的结果,因此我们需要提供一个猜测。

    贝叶斯推导实例

         男生、女生穿长裤

    一个学校的男生、女生比例为6:4,男生总是穿长裤,女生则一半穿长裤一半穿裙子。则正向概率问题是:随机选取一个学生,他(她)穿长裤的概率和穿裙子的概率是多大?逆向概率问题是:迎面走来一个穿长裤的学生,你只看得见他(她)穿的是否长裤,而无法确定他(她)的性别,你能够推断出他(她)是女生的概率是多大吗?

         拼写纠错实例

     

    展开全文
  • 朴素贝叶斯方法是一组基于贝叶斯定理的监督学习算法,其“朴素”假设是:给定类别变量的每一对特征之间条件独立。贝叶斯定理描述了如下关系: 给定类别变量\(y\)以及属性值向量\(x_1\)至\(x_n\): \(P(y \mid x_1, \...

    朴素贝叶斯

    朴素贝叶斯方法是一组基于贝叶斯定理的监督学习算法,其“朴素”假设是:给定类别变量的每一对特征之间条件独立。贝叶斯定理描述了如下关系:
    给定类别变量\(y\)以及属性值向量\(x_1\)\(x_n\)

    \(P(y \mid x_1, \dots, x_n) = \frac{P(y) P(x_1, \dots x_n \mid y)} {P(x_1, \dots, x_n)}\)

    依据朴素条件独立假设可得:

    \(P(x_i \mid y, x_1, \dots, x_{i-1}, x_{i+1}, \dots, x_n) = P(x_i \mid y)\)

    \(i\) 进行遍历,上式可化为:

    \(P(y \mid x_1, \dots, x_n) = \frac{P(y) \prod_{i=1}^{n} P(x_i \mid y)} {P(x_1, \dots, x_n)}\)

    由于输入的\(P(x_1, \dots, x_n)\)是给定的常数值,我们可以得到以下式子:

    \(P(y \mid x_1, \dots, x_n) \propto P(y) \prod_{i=1}^{n} P(x_i \mid y)\)

    \(\hat{y} = \arg\max_y P(y) \prod_{i=1}^{n} P(x_i \mid y)\)

    然后我们可以极大化后验估计(MAP),来估计\(P(y)\)\(P(x_i \mid y)\),前者就是训练集中类别\(y\)的相对频率。

    不同的朴素贝叶斯分类器的区别主要在于它们对\(P(x_i \mid y)\)分布的假设不同。

    尽管它们的假设显然过于简化,但naive Bayes分类器在许多实际情况下都能很好地工作,比如常见的文档分类和垃圾邮件过滤。
    它们需要一些训练数据来估计必要的参数。

    与其他更复杂的方法相比,朴素贝叶斯学习器和分类器执行速度非常快。类别条件特征分布的分解意味着每个分布都可以独立地作为一维分布进行估计。这反过来又有助于缓解组合爆炸的问题。

    另一方面,尽管朴素贝叶斯被认为是一个不错的分类器,但它是一个糟糕的估计器,所以\(predict\_proba\)输出的概率并太靠谱。

    1. 高斯朴素贝叶斯算法

    \(GaussianNB\) 实现了高斯朴素贝叶斯分类算法。假设特征的似然为高斯分布:

    \(P(x_i \mid y) = \frac{1}{\sqrt{2\pi\sigma^2_y}} \exp\left(-\frac{(x_i - \mu_y)^2}{2\sigma^2_y}\right)\)

    参数\(\sigma_y\)\(\mu_y\)采用极大似然估计。

    以鸢尾花分类为例:

    from sklearn.datasets import load_iris
    from sklearn.model_selection import train_test_split
    from sklearn.naive_bayes import GaussianNB
    X, y = load_iris(return_X_y=True)
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.5, random_state=0)
    gnb = GaussianNB()
    y_pred = gnb.fit(X_train, y_train).predict(X_test)
    print("Number of mislabeled points out of a total %d points : %d" % (X_test.shape[0], (y_test != y_pred).sum()))
    Number of mislabeled points out of a total 75 points : 4

    2. 多项式贝叶斯算法

    \(MultinomialNB\)实现了对多项式分布数据的朴素贝叶斯算法,是文本分类中使用的两种经典的朴素贝叶斯变体之一(其中数据通常表示为词向量计数,虽然\(tf-idf\)向量在实践中也很有效)。

    这个分布的每个类别\(y\)的参数向量为\(\theta_y = (\theta_{y1},\ldots,\theta_{yn})\),其中\(n\)是特征数量(在文本分类中是词典大小),\(\theta_{yi}\)是特征\(i\)在类别\(y\)的一个样本中出现的概率\(P(x_i \mid y)\)

    参数\(\theta_y\)由最大似然的平滑版本来估计,即相对频率计数:

    \(\hat{\theta}_{yi} = \frac{ N_{yi} + \alpha}{N_y + \alpha n}\)

    其中\(N_{yi} = \sum_{x \in T} x_i\)是训练集\(T\)上特征\(i\)在类别\(y\)的一个样本中出现的次数。\(N_{y} = \sum_{i=1}^{n} N_{yi}\)是类\(y\)的所有特征的总数。

    平滑先验\(\alpha \ge 0\)让学习样本中不存在的特征占一定的比例,并防止在进一步的计算中出现零概率。

    \(\alpha = 1\)时为拉普拉斯(Laplace)平滑,\(\alpha < 1\)时为李德斯通(Lidstone)平滑。

    以鸢尾花分类为例:

    from sklearn.datasets import load_iris
    from sklearn.model_selection import train_test_split
    from sklearn.naive_bayes import ComplementNB
    X, y = load_iris(return_X_y=True)
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.5, random_state=0)
    cnb = ComplementNB()
    y_pred = cnb.fit(X_train, y_train).predict(X_test)
    print("Number of mislabeled points out of a total %d points : %d" % (X_test.shape[0], (y_test != y_pred).sum()))
    Number of mislabeled points out of a total 75 points : 30

    3. 伯努利贝叶斯算法

    \(BernoulliNB\)是对按多元伯努利分布的数据,实现朴素贝叶斯训练和分类的算法,即,可能有多个特征,但每个特征都被假定为一个二元(伯努利,布尔)变量。因此,该类别要求样本用二值特征向量表示;如果传递任何其他类型的数据,\(BernoulliNB\)的实例可以对该输入进行二值化(取决于二值参数)。

    基于贝叶斯的决策规则:

    \(P(x_i \mid y) = P(i \mid y) x_i + (1 - P(i \mid y)) (1 - x_i)\)

    它与多项式NB规则的不同之处在于,它显式地惩罚了类别\(y\)的指标特征\(i\)的不出现,而多项式贝叶斯变体将简单地忽略一个不出现的特征。

    在文本分类的应用中,可以使用单词出现向量(而不是单词计数向量)来训练和使用这个分类器。BernoulliNB可能在某些数据集上表现得更好,特别是那些文档更短的数据集。如果时间允许,最好对两个模型都进行评估。

    以鸢尾花分类为例:

    from sklearn.datasets import load_iris
    from sklearn.model_selection import train_test_split
    from sklearn.naive_bayes import BernoulliNB
    X, y = load_iris(return_X_y=True)
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.5, random_state=0)
    bnb = BernoulliNB()
    y_pred = bnb.fit(X_train, y_train).predict(X_test)
    print("Number of mislabeled points out of a total %d points : %d" % (X_test.shape[0], (y_test != y_pred).sum()))
    Number of mislabeled points out of a total 75 points : 54

    参考文档

    scikit-learn 1.9.1, 1.9.2, 1.9.4 Gaussian/Multinomial/Complement Naive Bayes

    展开全文
  • 文章目录一、K-近邻算法1.定义2.计算距离公式3.sklearn k-...朴素贝叶斯算法的优缺点三、分类模型评估1.概念2.分类模型评估API3.案例四、模型的选择与调优1.交差验证2.网格搜索-调超参数1)超参数搜索-网格搜索API2)K

    一、K-近邻算法

    1.定义

    定义:如果一个样本在特征空间中的k个最相似(即特征空间中最邻近)的样本中的大多数属于某一个类别,则该样本也属于这个类别。
    通俗来说,就是根据你的邻居来推断你的类别
    来源:KNN算法最早是由Cover和Hart提出的一种分类算法

    2.计算距离公式

    两个样本的距离可以通过如下公式计算,又叫欧式距离
    比如说,a(a1,a2,a3),b(b1,b2,b3)((a1-b1)^2+(a2-b2)^2+(a3-b3)^2 )
    相似的样本,特征值应该是相近的
    
    K-近邻算法需要对数据作标准化处理
    

    3.sklearn k-近邻算法API

    sklearn k-近邻算法API
    
    sklearn.neighbors.KNeighborsClassifier(n_neighbors=5,algorithm='auto')
    # 参数
    n_neighbors:int,可选(默认= 5),k_neighbors查询默认使用的邻居数
    
    algorithm:{‘auto’,‘ball_tree’,‘kd_tree’,‘brute’},可选用于计算最近邻居的算法:
    ‘ball_tree’将会使用 BallTree,‘kd_tree’将使用 KDTree。
    ‘auto’将尝试根据传递给fit方法的值来决定最合适的算法。 (不同实现方式影响效率)
    

    4.K-近邻算法实例-预测入住位置

    在这里插入图片描述

    实例流程:
    1、数据集的处理
    2、分割数据集
    3、对数据集进行标准化
    4、estimator流程进行分类预测
    
    
    数据的处理-由于数据过大,做如下处理
    1、缩小数据集范围
    DataFrame.query()
    2、处理日期数据
    pd.to_datetime
    pd.DatetimeIndex
    3、增加分割的日期数据
    4、删除没用的日期数据
    pd.drop
    5、将签到位置少于n个用户的删除
    place_count =data.groupby('place_id').aggregate(np.count_nonzero)
    tf = place_count[place_count.row_id > 3].reset_index()
    data = data[data['place_id'].isin(tf.place_id)]
    
    # K-近邻算法实例-预测入住位置
    
    from sklearn.neighbors import KNeighborsClassifier
    import pandas as pd
    from sklearn.model_selection import train_test_split
    from sklearn.preprocessing import StandardScaler
    import numpy as np
    
    def knncls():
        '''K-近邻算法-预测用户入住位置
        return None
        '''
        # 一、数据集的处理
        # 读取数据
        data = pd.read_csv(r'C:\Users\admin\Desktop\v-predicting\train.csv')
        # 处理数据
        # 1.缩小数据-缩小数据集范围 DataFrame.query()查询数据筛选
        data = data.query('x>1.0 & x<1.25 & y>2.5 & y<2.75')
    
        # 2.处理时间数据
        time_value = pd.to_datetime(data['time'],unit='s')
    
        # 3、增加分割的日期数据
        # 把日期格式转化成字典格式
        time_value = pd.DatetimeIndex(time_value)
        # 根据时间  构造一些特征
        data.loc[:,'day'] = time_value.day
        data.loc[:,'hour'] = time_value.hour
        data.loc[:,'weekday'] = time_value.weekday
    
    
        # 4、删除没用的日期数据
        # 把时间戳特征删除,axis的重点在于方向而不在于行或列
            # axis = 0表示纵轴表示数据的变化从上至下,体现在行的增加与减少
            # axis = 1表示横轴表示数据的变化从左至右,体现在列的增加与减少
        data = data.drop(labels='time', axis=1)
    
        # 5.将签到位置少于n个用户的删除
        place_count = data.groupby('place_id').count()
        tf = place_count[place_count.row_id > 3].reset_index()
        # 过滤后的表格
        data = data[data['place_id'].isin(tf.place_id)]
    
        # 删除无用的row_id
        data = data.drop(labels='row_id', axis=1)
        print(data)
    
        # 取出数据中的目标值和特征值
        y = data["place_id"]
        x = data.drop(labels = 'place_id',axis=1)
    
        # 二、分割数据集
        # 进行数据的分割-训练集测试集
        x_train, x_test, y_train, y_test = train_test_split(x,y,test_size=0.25)
    
        # 三、对数据集进行标准化
        # 特征工程(标准化)
        std = StandardScaler()
    
        # 对训练集与测试集的特征值进行标准化
        x_train = std.fit_transform(x_train)
        x_test = std.transform(x_test)
    
    
    
        # 四、estimator流程进行分类预测
        # 进行算法流程-estimator流程进行分类预测
        knn = KNeighborsClassifier(n_neighbors=5)
        knn.fit(x_train,y_train)
        # 得到预测结果
        y_predict = knn.predict(x_test)
        print('预测的目标签到位置为:', y_predict)
    
        # 得到预测的准确率-预测值与真实值进行比较
        print('预测的准确率为:',knn.score(x_test,y_test))
    
        return None
    
    
    if __name__ == '__main__':
        knncls()
        
    # 预测的目标签到位置为: [6424972551 1267801529 4932578245 ... 1228935308 4932578245 3992589015]
    # 预测的准确率为: 0.474468085106383
    

    5.通过k-近邻算法对生物物种进行分类——鸢尾花(load_iris)

    # k近邻算法作业-•通过k-近邻算法对生物物种进行分类——鸢尾花(load_iris)
    from sklearn.neighbors import KNeighborsClassifier
    from sklearn.datasets import load_iris
    from sklearn.model_selection import train_test_split
    from sklearn.preprocessing import StandardScaler
    
    def knncls():
        '''通过K-近邻算法对生物物种进行分类'''
        # 一、数据集的处理
        li = load_iris()
    
        # 取数据集特征值与目标值
        x = li.data
        y = li.target
    
        # 二、分割数据集
        x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.25)
    
        # 三、对数据集进行标准化-特征工程
        std = StandardScaler()
    
        # 对训练集与测试集的特征值进行标准化
        x_train = std.fit_transform(x_train)
        x_test = std.transform(x_test)
    
        # 四、estimator流程进行分类预测
        # 超参数n_neighbors,可调
        knn = KNeighborsClassifier(n_neighbors=5)
        knn.fit(x_train,y_train)
        # 得到预测值
        y_predict = knn.predict(x_test)
        print('预测值是:\n',y_predict)
    
        # 预测准确率
        print('预测准确率是:\n',knn.score(x_test,y_test))
        return None
    
    if __name__ == '__main__':
        knncls()
        
    # 预测值是:
    #  [2 2 0 1 1 2 2 2 0 0 1 1 0 2 1 0 0 0 0 0 1 1 1 1 1 2 1 2 2 2 2 2 2 0 0 0 2
    #  2]
    # 预测准确率是:
    #  0.9210526315789473
    

    6.k-近邻算法优缺点

    问题:
    1、k值取多大?有什么影响?
    k值取很小:容易受异常点影响;k值取很大:容易受最近数据太多导致比例变化
    2.性能问题
    
    k-近邻算法优缺点
    优点:简单,易于理解,易于实现,无需估计参数,无需训练
    
    缺点:
    懒惰算法,对测试样本分类时的计算量大,内存开销大
    必须指定K值,K值选择不当则分类精度不能保证
    
    使用场景:小数据场景,几千~几万样本,具体场景具体业务去测试
    

    二、朴素贝叶斯算法

    1.概率基础

    联合概率和条件概率:
    
    联合概率:包含多个条件,且所有条件同时成立的概率,记作:P(A,B)
    
    条件概率:就是事件A在另外一个事件B已经发生条件下的发生概率,记作:P(A|B)
    
    特性:P(A1,A2|B) = P(A1|B)P(A2|B)
    注意:此条件概率的成立,是由于A1,A2相互独立的结果
    

    2.朴素贝叶斯原理介绍-特征相互独立(条件独立)

    朴素贝叶斯-贝叶斯公式
    在这里插入图片描述

    拉普拉斯平滑-解决由于某个特征为0而造成概率为0的情况
    
    解决方法:拉普拉斯平滑系数
    P(F1│C)=(Ni+α)/(N+αm)            
    α为指定的系数一般为1,m为训练文档中统计出的特征词个数
    
    
    sklearn朴素贝叶斯实现API:sklearn.naive_bayes.MultinomialNB
    
    MultinomialNB
    
    sklearn.naive_bayes.MultinomialNB(alpha = 1.0)
    # 朴素贝叶斯分类
    # 参数alpha:拉普拉斯平滑系数
    

    3.朴素贝叶斯算法案例-sklearn20类新闻分类

    朴素贝叶斯案例流程
    20个新闻组数据集包含20个主题的18000个新闻组帖子
    
    1、加载20类新闻数据,并进行分割
    2、生成文章特征词
    3、朴素贝叶斯estimator流程进行预估
    
    # 朴素贝叶斯算法案例-sklearn20类新闻分类
    from sklearn.datasets import fetch_20newsgroups
    from sklearn.model_selection import train_test_split
    from sklearn.feature_extraction.text import TfidfVectorizer
    from sklearn.naive_bayes import MultinomialNB
    def naviebayes():
        '''
        朴素贝叶斯进行文本分类
        :return:
        '''
        # 一、数据集处理
        # 1.加载数据集
        news = fetch_20newsgroups(subset='all')
        # 2.取得数据集的特征值与目标值
        x = news.data
        y = news.target
        # 3.分割数据集
        x_train, x_test, y_train, y_test = train_test_split(x,y,test_size=0.25)
    
        # 二、对数据集进行特征抽取
        tf = TfidfVectorizer()
    
        # 以训练集当中的词的列表进行每篇文章重要性统计
        x_train = tf.fit_transform(x_train)
        # 打印单词列表
        print(tf.get_feature_names())
    
        x_test = tf.transform(x_test)
    
        # 三、朴素贝叶斯estimator流程进行预估
        mlt = MultinomialNB(alpha=1.0)
        print(x_train.toarray())
        mlt.fit(x_train,y_train)
        # 得到预测值
        y_predict = mlt.predict(x_test)
        print('预测值是:',y_predict)
        # 预测准确率
        print("预测准确率是:",mlt.score(x_test,y_test))
    
        return None
    
    if __name__ == '__main__':
        naviebayes()
    

    4.朴素贝叶斯算法的优缺点

    朴素贝叶斯分类优缺点:
    
    优点:
    1.朴素贝叶斯模型发源于古典数学理论,有稳定的分类效率。
    2.对缺失数据不太敏感,算法也比较简单,常用于文本分类。
    3.分类准确度高,速度快
    
    缺点:
    1.训练集误差大时,结果肯定不好;不允许调参
    2.由于使用样本属性独立性的假设,故样本属性有关联时,其效果最好
    

    三、分类模型评估

    1.概念

    分类模型的评估:
        
    estimator.score()
    # 一般最常见使用的是准确率,即预测结果正确的百分比
    
    混淆矩阵
    •在分类任务下,预测结果(Predicted Condition)
    与正确标记(True Condition)之间存在四种不同的组合,构成混淆矩阵(适用于多分类)
    

    在这里插入图片描述

    精确率:预测结果为正例样本中真实为正例的比例(查得准)
    召回率:真实为正例的样本中预测结果为正例的比例(查的全,对正样本的区分能力)
    其他分类标准,F1-score,反映了模型的稳健型
    

    在这里插入图片描述

    2.分类模型评估API

    分类模型评估API:sklearn.metrics.classification_report
    
    # 求每个类别的精确率和召回率
    sklearn.metrics.classification_report(y_true, y_pred, target_names=None)
    # 参数
    y_true:真实目标值
    y_pred:估计器预测目标值
    target_names:目标类别名称
    return:每个类别精确率与召回率
    

    3.案例

    # 精确率与召回率
    from sklearn.datasets import fetch_20newsgroups
    from sklearn.model_selection import train_test_split
    from sklearn.feature_extraction.text import TfidfVectorizer
    from sklearn.naive_bayes import MultinomialNB
    from sklearn.metrics import classification_report
    
    def naviebayes():
        '''
        朴素贝叶斯进行文本分类
        :return:
        '''
        # 一、数据集处理
        # 1.加载数据集
        news = fetch_20newsgroups(subset='all')
        # 2.取得数据集的特征值与目标值
        x = news.data
        y = news.target
        # 3.分割数据集
        x_train, x_test, y_train, y_test = train_test_split(x,y,test_size=0.25)
    
        # 二、对数据集进行特征抽取
        tf = TfidfVectorizer()
    
        # 以训练集当中的词的列表进行每篇文章重要性统计
        x_train = tf.fit_transform(x_train)
        # 打印单词列表
        print(tf.get_feature_names())
    
        x_test = tf.transform(x_test)
    
        # 三、朴素贝叶斯estimator流程进行预估
        mlt = MultinomialNB(alpha=1.0)
        print(x_train.toarray())
        mlt.fit(x_train,y_train)
        # 得到预测值
        y_predict = mlt.predict(x_test)
        print('预测值是:',y_predict)
        # 预测准确率
        print("预测准确率是:",mlt.score(x_test,y_test))
    
        print('每个类别的精确率与召回率分别是:\n',classification_report(y_test,
        y_predict,target_names=news.target_names))
    
        return None
    
    if __name__ == '__main__':
        naviebayes()
        
    # 预测值是: [ 3  2 14 ...  9 15 14]
    # 预测准确率是: 0.8433786078098472
    # 每个类别的精确率与召回率分别是:
    #                            precision    recall  f1-score   support
    # 
    #              alt.atheism       0.87      0.69      0.77       199
    #            comp.graphics       0.89      0.75      0.81       250
    #  comp.os.ms-windows.misc       0.78      0.87      0.82       221
    # comp.sys.ibm.pc.hardware       0.72      0.82      0.77       234
    #    comp.sys.mac.hardware       0.88      0.87      0.87       230
    #           comp.windows.x       0.94      0.86      0.90       251
    #             misc.forsale       0.92      0.66      0.77       255
    #                rec.autos       0.90      0.92      0.91       242
    #          rec.motorcycles       0.95      0.95      0.95       257
    #       rec.sport.baseball       0.94      0.96      0.95       251
    #         rec.sport.hockey       0.93      0.98      0.96       246
    #                sci.crypt       0.85      0.97      0.90       261
    #          sci.electronics       0.89      0.76      0.82       247
    #                  sci.med       0.99      0.88      0.93       260
    #                sci.space       0.88      0.98      0.93       258
    #   soc.religion.christian       0.51      0.98      0.67       234
    #       talk.politics.guns       0.70      0.97      0.81       216
    #    talk.politics.mideast       0.93      0.98      0.95       232
    #       talk.politics.misc       0.98      0.57      0.72       213
    #       talk.religion.misc       1.00      0.17      0.29       155
    # 
    #                micro avg       0.84      0.84      0.84      4712
    #                macro avg       0.87      0.83      0.82      4712
    #             weighted avg       0.87      0.84      0.84      4712
    

    四、模型的选择与调优

    1.交差验证

    交叉验证:为了让被评估的模型更加准确可信
    
    交叉验证过程:
    交叉验证:将拿到的数据,分为训练集和验证集。以下图为例:将数据分成5份,其中一份作为
    验证集。然后经过5()的测试,每次都更换不同的验证集。即得到5组模型的结果,取平
    均值作为最终结果。又称5折交叉验证。
    

    在这里插入图片描述

    2.网格搜索-调超参数

    超参数搜索-网格搜索
    通常情况下,有很多参数是需要手动指定的(如k-近邻算法中的K值),这种叫超参数。
    但是手动过程繁杂,所以需要对模型预设几种超参数组合。每组超参数都采用交叉验证
    来进行评估。最后选出最优参数组合建立模型。
    
    多个超参数时,对模型预设多超参数组合,如,二个参数-两两组合、三个参数-三三组合,
    每组超参数采用交叉验证(一般采用10折交叉验证)来进行评估,最后选出最优参数组合建立模型
    

    1)超参数搜索-网格搜索API

    超参数搜索-网格搜索API:sklearn.model_selection.GridSearchCV
    
    sklearn.model_selection.GridSearchCV(estimator, param_grid=None,cv=None)
    # 对估计器的指定参数值进行详尽搜索
    
    # 参数
    estimator:估计器对象
    param_grid:估计器参数(dict){“n_neighbors”:[1,3,5]}
    cv:指定几折交叉验证
    
    # 方法
    fit:输入训练数据
    score:准确率
    
    #结果分析:
    best_score_:在交叉验证中测试的最好结果
    best_estimator_:最好的参数模型
    cv_results_:每次交叉验证后的测试集准确率结果和训练集准确率结果
    

    2)K-近邻算法调优 交叉验证与网格搜索

    # K-近邻算法调优  交叉验证与网格搜索
    
    from sklearn.neighbors import KNeighborsClassifier
    import pandas as pd
    from sklearn.model_selection import train_test_split,GridSearchCV
    from sklearn.preprocessing import StandardScaler
    
    def knncls():
        '''K-近邻算法-预测用户入住位置
        return None
        '''
        # 一、数据集的处理
        # 读取数据
        data = pd.read_csv(r'C:\Users\admin\Desktop\v-predicting\train.csv')
        # 处理数据
        # 1.缩小数据-缩小数据集范围 DataFrame.query()查询数据筛选
        data = data.query('x>1.0 & x<1.25 & y>2.5 & y<2.75')
    
        # 2.处理时间数据
        time_value = pd.to_datetime(data['time'],unit='s')
    
        # 3、增加分割的日期数据
        # 把日期格式转化成字典格式
        time_value = pd.DatetimeIndex(time_value)
        # 根据时间  构造一些特征
        data.loc[:,'day'] = time_value.day
        data.loc[:,'hour'] = time_value.hour
        data.loc[:,'weekday'] = time_value.weekday
    
    
        # 4、删除没用的日期数据
        # 把时间戳特征删除,axis的重点在于方向而不在于行或列
            # axis = 0表示纵轴表示数据的变化从上至下,体现在行的增加与减少
            # axis = 1表示横轴表示数据的变化从左至右,体现在列的增加与减少
        data = data.drop(labels='time', axis=1)
    
        # 5.将签到位置少于n个用户的删除
        place_count = data.groupby('place_id').count()
        tf = place_count[place_count.row_id > 3].reset_index()
        # 过滤后的表格
        data = data[data['place_id'].isin(tf.place_id)]
    
        # 删除无用的row_id
        data = data.drop(labels='row_id', axis=1)
        print(data)
    
        # 取出数据中的目标值和特征值
        y = data["place_id"]
        x = data.drop(labels = 'place_id',axis=1)
    
        # 二、分割数据集
        # 进行数据的分割-训练集测试集
        x_train, x_test, y_train, y_test = train_test_split(x,y,test_size=0.25)
    
        # 三、对数据集进行标准化
        # 特征工程(标准化)
        std = StandardScaler()
    
        # 对训练集与测试集的特征值进行标准化
        x_train = std.fit_transform(x_train)
        x_test = std.transform(x_test)
    
        # 四、estimator流程进行分类预测
        # 进行算法流程-estimator流程进行分类预测
        knn = KNeighborsClassifier()
    
        # 五、算法调优-网格搜索
        # 构造一些参数的值进行搜索
        param = {'n_neighbors':[3,5,10]}
        gc = GridSearchCV(knn, param_grid=param, cv=2)
    
        gc.fit(x_train, y_train)
    
        # 预测准确率
        print('在测试集上的准确率:\n', gc.score(x_test, y_test))
    
        print('在交叉验证中最好的结果:\n',gc.best_score_)
    
        print('最好的参数模型:\n', gc.best_estimator_)
    
        print('每个超参数每次交叉验证后的结果:\n',gc.cv_results_)
        return None
    
    if __name__ == '__main__':
        knncls()
    
    展开全文
  • 分类算法之朴素贝叶斯算法,贝叶斯定理
  • learn机器学习笔记——朴素贝叶斯算法朴素贝叶斯算法贝叶斯公式拉普拉斯平滑朴素贝叶斯分类优缺点sklearn朴素贝叶斯实现APIMultinomialNB分类模型评估混淆矩阵精确率(Precision)与召回率(Recall)分类模型评估API朴素...
  • 文章目录1 朴素贝叶斯简介2 条件概率与全概率公式3 贝叶斯推断4 引例5 朴素贝叶斯算法分类(1) GaussianNB(2) MultinomialNB(3) BernoulliNB6 朴素贝叶斯算法优缺点7 实验参考资料 1 朴素贝叶斯简介 贝叶斯分类算法...
  • 阅读感受:作者以浅显易懂的语言讲解朴素贝叶斯分类原来,在结合具体实例,让人更加明白朴素贝叶斯算法 1.1、摘要  贝叶斯分类是一类分类算法的总称,这类算法均以贝叶斯定理为基础,故统称为贝叶斯分类。...
  • 自己用scala实现的朴素贝叶斯算法。最近学习machine learning,由于之前学习了spark,于是使用scala尝试写写代码
  • 一文学会朴素贝叶斯并且从头开始用 Python 实现朴素贝叶斯算法朴素贝叶斯算法是简单并且有效的算法,而且应该是你尝试解决分类问题的第一个方法。在这个教...
  • 使用Sklearn学习朴素贝叶斯算法

    千次阅读 2020-10-20 13:32:50
    上一篇文章我向大家介绍了朴素贝叶斯工作的理论部分,需要看的小伙伴请移步:贝叶斯分类器,接下来,我们基于Sklearn机器学习库来使用以下具体的贝叶斯分类器算法。 1,sklearn中的贝叶斯分类器 Sklearn基于数据...
  • 目录一、K-近邻算法1.定义2.计算距离公式(欧氏距离)(重点)3....朴素贝叶斯算法的优缺点三、分类模型评估1.概念2.分类模型评估API3.案例四、模型的选择与调优1.交差验证2.网格搜索-调超参数1)超参数搜索-网格
  • 朴素贝叶斯算法及其实战

    万次阅读 2019-12-15 02:28:08
    贝叶斯方法的特点是结合先验概率后验概率,即避免了只使用先验概率的主观偏见,也避免了单独使用样本信息的过拟合现象。贝叶斯分类算法在数据集较大的情况下表现出较高的准确率,同时算法本身也比...
  • [飞桨机器学习]朴素贝叶斯算法 本篇主要介绍朴素贝叶斯算法及应用案例。 以Tatinic数据集为例进行应用,同时介绍数据处理,数据集的划分,算法效果评估等内容。 一、简介 朴素贝叶斯法是基于贝叶斯定理与特征条件...
  • 朴素贝叶斯算法简介

    2021-04-19 10:57:00
    朴素贝叶斯算法简介 1.2 概率基础复习 1.概率定义 概率定义为一件事情发生的可能性 扔出一个硬币,结果头像朝上 P(X) : 取值在[0, 1] 2.案例:判断女神对你的喜欢情况 在讲这两个概率之前我们通过一个...
  • 关于朴素贝叶斯算法 在本教程中,您将学习Naive Bayes算法,包括它的工作原理以及如何在Python中从头开始实现它。 朴素贝叶斯算法是一种直观的方法,它使用属于每个类的每个属性的概率来进行预测。 如果您想要概率性...
  • Python机器学习 — 朴素贝叶斯算法(Naive Bayes)

    万次阅读 多人点赞 2018-07-10 16:12:42
    一、朴素贝叶斯算法 -- 简介  朴素贝叶斯法是基于贝叶斯定理与特征条件独立假设的分类方法。最为广泛的两种分类模型是决策树模型(Decision Tree Model)朴素贝叶斯模型(Naive Bayesian Model,NBM)。 决策树...
  • 基于Python的朴素贝叶斯算法实现

    千次阅读 2016-05-16 22:37:04
    本文主要介绍了贝叶斯算法的基本原理以及基于Python的朴素贝叶斯分类算法的实现
  • 一、摘要 贝叶斯分类是一类分类算法...最后,通过实例讨论贝叶斯分类中最简单的一种:朴素贝叶斯分类。  二、分类问题综述  对于分类问题,其实谁都不会陌生,说我们每个人每天都在执行分类操作一点都不夸张,只是
  • R语言之朴素贝叶斯算法应用

    千次阅读 2016-08-03 21:11:57
    朴素贝叶斯算法在R语言中的应用,对应klaR包中的NaiveBayes()方法。问题描述:主要通过朴素贝叶斯算法对于测试数据集中的nmkat属性值进行预测,我们使用的数据是KKNN包中的自带数据miete数据。主要对于该数据进行...
  • 概率基础 定义一件事发生的可能性 根据以上训练集,我们要判断,给定小明,产品,超重,是否会获得女神的喜欢...之所以叫朴素贝叶斯的朴树 朴素:特征与特征之间相互独立 朴素贝叶斯 朴素+贝叶斯 多用于文本分类,...
  • 朴素贝叶斯算法 1.定义 2.应用场景 3.实例分析 实例 多项式模型 伯努利模型 对比多项式模型伯努利模型 在Sklearn中的API 多项式分布模型 伯努利模型 高斯模型 实例 总结 贝叶斯公式 如果交换条件...
  • 文章目录一,概述1,条件概率(Condittional probability)2,全概率公式3,贝叶斯推断二,举个“栗子”(手动星标)三,朴素贝叶斯的种类如何选择1,高斯分布的朴素贝叶斯算法GaussianNB在sklearn中的实现2,多项式...
  • 转载请注明作者出处:http://blog.csdn.net/john_bh/ 运行平台: Windows Python版本: Python3.6 IDE: Sublime text3 ...4 朴素贝叶斯推断 41 实例病人分类 三使用朴素贝叶斯进行文档分类 1
  • 算法是核心,数据计算是基础 找准定位 大部分复杂模型的算法设计都是算法工程师在做,而我们 > 分析很多的数据 > 分析具体的业务 > 应用常见的算法 > 特征工程、调参数、优化 我们应该怎么做 1.学会分析...
  • 朴素贝叶斯算法入门

    千次阅读 2012-12-09 22:28:51
    1.1、摘要  贝叶斯分类是一类分类算法的...最后,通过实例讨论贝叶斯分类中最简单的一种:朴素贝叶斯分类。 1.2、分类问题综述 对于分类问题,其实谁都不会陌生,说我们每个人每天都在执行分类操作一点都不夸张,只

空空如也

空空如也

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

朴素贝叶斯算法实例和评估