精华内容
下载资源
问答
  • 朴素贝叶斯算法

    2018-08-21 09:23:13
    朴素贝叶斯算法实例,python3可运行,每行代码均有详细解释,适用初学贝叶斯者.
  • 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))
    
    展开全文
  • 机器学习朴素贝叶斯算法 朴素贝叶斯算法 (Naive Bayes Algorithm) Naive Bayes is basically used for text learning. Using this algorithm we trained machine from text. 朴素贝叶斯基本上用于文本学习。 使用此...

    机器学习朴素贝叶斯算法

    朴素贝叶斯算法 (Naive Bayes Algorithm)

    Naive Bayes is basically used for text learning. Using this algorithm we trained machine from text.

    朴素贝叶斯基本上用于文本学习。 使用此算法,我们从文本中训练了机器。

    Let’s understand it with an example:

    让我们通过一个例子来理解它:

    Question:

    题:

    There are two writers SARA and CHRIS .The probability of writing the word "LOVE" ,"DEAL" and "LIFE" is 0.1,0.8 and 0.1 respectively by CHRIS and 0.5,0.2 and 0.3 by SARA. The probability of sending mail by CHRIS and SARA is 0.5, and then answer this question:

    SARA和CHRIS有两个作者。CHRIS的单词“ LOVE”,“ DEAL”和“ LIFE”的书写概率分别为SARA和0.5、0.2和0.3,分别为0.1,0.8和0.1。 CHRIS和SARA发送邮件的概率为0.5,然后回答以下问题:

    1. Who will more likely send the mail "LOVE LIFE"?

      谁更有可能发送邮件“ LOVE LIFE”?

    2. What is the probability that "LOVE LIFE" is send by CHRIS?

      CHRIS发送“ LOVE LIFE”的可能性是多少?

    Solution:

    解:

    Ans 1)

    答1)

    P(CHRIS,"LOVE LIFE")=P(CHRIS) *P("LOVE LIFE"|CHRIS)
        = 0.5 * (0.1 *0.1) =0.005
    P(SARA,"LOVE LIFE")=P(SARA) * P("LOVE LIFE"|SARA)
        = 0.5 * (0.5 * 0.3)
        = 0.075
    
    Hence, SARA is more likely to send mail "LOVE LIFE".
    
    

    Ans 2)

    答2)

    Normalize:
    P("LOVE LIFE")=P(CHRIS,"LOVE LIFE")+P(SARA,"LOVE LIFE") = 0.005+0.075 = 0.08 Probability of sending mail "LOVE LIFE" by CHRIS (P(CHRIS|"LOVE LIFE")) = P(CHRIS,"LOVE LIFE")/P("LOVE LIFE") = 0.005/0.08 = 0.0625

    Similarly for probability of sending mail by SARA we can divide 0.075 by the total of two i.e. 0.08.

    同样,对于通过SARA发送邮件的可能性,我们可以将0.075除以2的总和,即0.08。

    HENCE THIS PROCESS IS THE ALGORITHM FOR BAYES RULE.

    因此,此过程是贝叶斯规则的算法。

    翻译自: https://www.includehelp.com/ml-ai/naive-bayes-algorithm.aspx

    机器学习朴素贝叶斯算法

    展开全文
  • 朴素贝叶斯算法是一种有监督学习算法,用于解决分类问题。 “朴素”是因为整个形式化过程只做最原始、最简单的假设。 朴素贝叶斯的优缺点: 优点: – 在数据较少的情况下仍然有效,可以处理多类别问题。 – ...

    朴素贝叶斯算法是一种有监督学习算法,用于解决分类问题。

    “朴素”是因为整个形式化过程只做最原始、最简单的假设。


    朴素贝叶斯的优缺点:

    • 优点:
      – 在数据较少的情况下仍然有效,可以处理多类别问题。
      – 简单易懂、学习效率高、在某些领域的分类问题中能够与决策树、神经网络相媲美。
    • 缺点:
      – 对于输入数据的准备方式较为敏感。
    • 适用数据类型:标称型数据。

    朴素贝叶斯是贝叶斯决策理论的一部分。

    >>> 贝叶斯决策理论:

    假设现在有一个数据集,它由两类数据组成,数据分布如下图所示:

    现在用 p1(x,y)p1(x,y) 表示数据点 (x,y)(x,y) 属于类别1(图中红色圆点表示的类别)的概率,用 p2(x,y)p2(x,y) 表示数据点 (x,y)(x,y) 属于类别2(图中蓝色三角形表示的类别)的概率,那么对于一个新数据点 (x,y)(x,y),可以用下面的规则来判断它的类别:

    • 如果 p1(x,y)>p2(x,y)p1(x,y)>p2(x,y),那么类别为1
    • 如果 p1(x,y)<p2(x,y)p1(x,y)<p2(x,y),那么类别为2

    也就是说,我们会选择高概率对应的类别。这就是贝叶斯决策理论的核心思想,即选择具有最高概率的决策。


    在学习如何计算p1和p2概率之前,我们必须对条件概率有所了解。


    参考资料:《机器学习实战》

    展开全文
  • 数据挖掘-朴素贝叶斯算法

    万次阅读 2020-12-02 17:52:20
    今天把总结朴素贝叶斯算法(NaiveBayes)的学习心得。 Bayes是谁 Thomas Bayes,英国数学家。约1701年出生于伦敦,做过神甫。1742年成为英国皇家学会会员。1761年4月7日逝世。贝叶斯在数学方面主要研究概率论。他...

    微信搜索:“二十同学” 公众号,欢迎关注一条不一样的成长之路

    我个人认为,在数据挖掘领域,分类算法是最为重要。它根据以往的数据来对新的数据做预测。垃圾邮件判断,潜在用户挖掘等都会用到分类算法。今天把总结朴素贝叶斯算法(NaiveBayes)的学习心得。

     


    Bayes是谁
    Thomas Bayes,英国数学家。约1701年出生于伦敦,做过神甫。1742年成为英国皇家学会会员。1761年4月7日逝世。贝叶斯在数学方面主要研究概率论。他首先将归纳推理法用于概率论基础理论,并创立了贝叶斯统计理论,对于统计决策函数、统计推断、统计的估算等做出了贡献。

    Bayes定理
    通俗来说就是:
    已知事件B的发生概率P(B)
    已知在事件B已经发生的情况下,事件A发生的概率P(A|B)
    则可根据Bayes定理,计算事件A发生的条件下,事件B发生的概率P(B|A)。
    计算方法为:
    P(B|A)=P(A|B)× P(B)/ P(A)

    NaiveBayes分类算法实例
    门诊部一共就诊了6位患者,情况如下:

     

    这时,来了第七位患者,一位“打喷嚏的工人”,请推断他得了啥病。

    这就是一个分类问题。现状把所有患者分成了三类“感冒”“过敏”“脑震荡”,我们的目的是把“打喷嚏的工人”分到这三类中的一类中。具体做法为:根据Bayes定理,计算这个“打喷嚏的工人”患三种疾病的概率。

    P(感冒|打喷嚏&工人)
    = P(打喷嚏&工人|感冒)×P(感冒) / P(打喷嚏&工人)
    = P(打喷嚏|感冒)× P(工人|感冒)× P(感冒) / P(打喷嚏)× P(工人)
    = (2/3 × 1/3 × 1/2)/ (1/2 × 1/3)
    = 66.7%

    解释:

    • '&'项可以分成两个,是因为“症状”变量和“职业”变量是相互独立的,没什么联系
    • 感冒的有3个,其中打喷嚏的2个,所以P(打喷嚏|感冒)=2/3
    • 感冒的有3个,其中工人1个,所以P(工人|感冒)=1/3
    • 一共六个人,感冒3个,所以P(感冒)=1/2
    • 一共六个人,打喷嚏的3个,所以P(打喷嚏)=1/2
    • 一共六个人,其中工人2个,所以P(工人)=1/3

    按照这个方法,计算“打喷嚏的工人”另外两种疾病的概率;

    P(过敏|打喷嚏&工人)
    = P(打喷嚏&工人|过敏)×P(过敏) / P(打喷嚏&工人)
    = P(打喷嚏|过敏)× P(工人|过敏)× P(过敏) / P(打喷嚏)× P(工人)
    = (1 × 0 × 1/6)/ (1/2 × 1/3)
    = 0%
    P(脑震荡|打喷嚏&工人)
    = P(打喷嚏&工人|脑震荡)×P(脑震荡) / P(打喷嚏&工人)
    = P(打喷嚏|脑震荡)× P(工人|脑震荡)× P(脑震荡) / P(打喷嚏)× P(工人)
    = (0 × 1/2 × 1/3)/ (1/2 × 1/3)
    = 0%

    可见,“打喷嚏的工人”患感冒概率66.7%,初步判断应该是感冒。但是一般的分类器都要根据具体业务设置阈值,对于人命关天的事,最好严格一些,比如95%以上才做出判断,那么这里最好的答案应该是“机器无法判断,建议去让医生看看”。

    补充说明

    • 算法叫做朴素贝叶斯(NaiveBayes),是因为算法是在太简单了
    • ‘&’能分开两个概率相乘是因为变量的独立性,如果不独立的话,这样计算会有误差
    • 分母项 P(打喷嚏)× P(工人)在每次计算中都一样,可以只互相比较分子计算的结果作出判断
    • 例子中最初的6个病人的数据叫做训练集

    训练集样本较小情况下的概率调整
    P(打喷嚏|过敏)和P(工人|过敏)分别为1,0,实际中不可能是这样的,因为没有什么是一定不发生,也没有什么100%发生。出现这种情况是因为我们的样本太少,如果样本足够多,概率会相对靠谱。
    在起步阶段,样本就是很少,为了避免0,1这种极端概率,需要人为做一些数学变换。
    比如,对过敏来说,每个症状的初始概率都为50%,当来了一个过敏病人,如果出现打喷嚏,那么P(打喷嚏|过敏)的概率就提升一点点,反之如果不打喷嚏,则P(打喷嚏|过敏)的概率就下降一点点。
    这样使得每一个概率都变得在(0,1)之间平滑变化,对其他的变量也这样处理。
    在《Programming Collective Intelligence》这本书中给出了这个变换的公式,我套用到过敏来说就是:

    P(打喷嚏|过敏)调整 =(1×0.5 + 打喷嚏数 × P(打喷嚏|过敏)) / (1+打喷嚏数)
    所以调整后的概率为:
    P(打喷嚏|过敏)调整 = (0.5 + 3 ×1 )/(1+3 )=87.5%
    P(工人|过敏)调整 = (0.5 + 2 ×0)/ (1+2)=16.7%

    所以,在上例中计算第二种疾病的时候,如果用调整后的概率结果如下:

    P(过敏|打喷嚏&工人)
    = P(打喷嚏&工人|过敏)×P(过敏) / P(打喷嚏&工人)
    = P(打喷嚏|过敏)× P(工人|过敏)× P(过敏) / P(打喷嚏)× P(工人)
    = (87.5% × 16.7% × 1/6)/ (1/2 × 1/3)

    = 14.6%

    连续变量处理
    对于上例来说,不论是职业还是症状,都是离散变量,也就是取值数有限,这样都可以通过数个数的方式来计算概率(古典概率模型),但是如果出现连续型变量就不能靠数个数了,比如身高,可以有175cm 176cm 176.1cm 176.11cm,无穷尽……

    1. 处理方式一:离散化
      身高来说,可以就精确到cm,那么基于现实世界从40cm(婴儿)到230cm(姚明)基本就够用了,可以数个数。要么就分段【小于100cm】【100-150cm】【150-180cm】……这样也可以。
    2. 处理方式二:利用变量的分布来计算概率
      一般来说自然界中的大部分变量都是符合正态分布的,正态分布是一个钟型曲线,概率意义是,一次实验取到均值附近概率最大,去到远离均值的值的概率越来越小。那么可以计算样本的均值和标准差,利用Z值【(实际值-均值)/标准差】,查标准正态分布表,查出取到每个样本值的概率。
      当然,如果明确知道变量属于某个其他分布,如泊松分布,那么就直接用分布函数求概率即可。

    数学表达以备装B之需

     

    非常感谢:点赞收藏评论

    微信搜索:“二十同学” 公众号,或者直接扫一扫,关注一条不一样的成长之路

    展开全文
  • 朴素贝叶斯算法.pptx

    2020-05-03 00:30:19
    朴素贝叶斯算法;算法流程图;朴素贝叶斯算法原理;朴素贝叶斯算法原理;条件概率 表示事件B已经发生的前提下事件A发生的概率叫做事件B发生下事件A的条件概率其基本求解公式为 为了得出 我们不加证明的给出贝叶斯定理 ;...
  • 分类算法-朴素贝叶斯算法C语言实现
  • 朴素贝叶斯算法文本分类算法 分类算法-朴素贝叶斯 (Classification Algorithms - Naïve Bayes) Advertisements 广告 Previous Page 上一页 Next Page 下一页 朴素贝叶斯算法简介 (Introduction to ...
  • 主要介绍了Java实现的朴素贝叶斯算法,结合实例形式分析了基于java的朴素贝叶斯算法定义及样本数据训练操作相关使用技巧,需要的朋友可以参考下

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 35,161
精华内容 14,064
关键字:

朴素贝叶斯算法