精华内容
下载资源
问答
  •  聚类是将数据对象集合分成相似对象类的过程,使得同一个簇(或类)中对象之间具有较高相似性,而不同簇中对象具有较高相异性。即指在对数据集操作时,我们是不知道该数据集包含多少类,我们要做,是...

    简述分类与聚类的联系与区别。

      分类是指在对数据集分类时,我们知道这个数据集是有多少种类的。

      聚类是将数据对象的集合分成相似的对象类的过程,使得同一个簇(或类)中的对象之间具有较高的相似性,而不同簇中的对象具有较高的相异性。即指在对数据集操作时,我们是不知道该数据集包含多少类,我们要做的,是将数据集中相似的数据归纳在一起。

    简述什么是监督学习与无监督学习。

      监督学习是指每个实例都是由一组特征和一个类别结果,拥有标注的数据训练模型,并产生一个推断的功能。对于新的实例,可以用于映射出该实例的类别。

      无监督学习是指我们只知道一些特征,并不知道答案,但不同实例具有一定的相似性,然后把那些相似的聚集在一起。

    2.朴素贝叶斯分类算法 实例

    利用关于心脏情患者的临床数据集,建立朴素贝叶斯分类模型。

    有六个分类变量(分类因子):性别,年龄、KILLP评分、饮酒、吸烟、住院天数

    目标分类变量疾病:–心梗–不稳定性心绞痛

    新的实例:–(性别=‘男’,年龄<70, KILLP=‘I',饮酒=‘是’,吸烟≈‘是”,住院天数<7)

    最可能是哪个疾病?

     

    3、编程实现朴素贝叶斯分类算法

    import pandas as pd
    import numpy as np
     
    dataDF = pd.read_excel(r'data/心脏病患者临床数据.xlsx')
     
    # 数据处理,对男女(男1女0),年龄(<70 -1,70-80 0,>80 1),
    # 住院天数(<7 -1,7-14 0,>14 1)三个列进行处理
    sex = []
    for s in dataDF['性别']:
        if s == '男':
            sex.append(1)
        else:
            sex.append(0)
     
    age = []
    for a in dataDF['年龄']:
        if a == '<70':
            age.append(-1)
        elif a == '70-80':
            age.append(0)
        else:
            age.append(1)
     
    days = []
    for d in dataDF['住院天数']:
        if d == '<7':
            days.append(-1)
        elif d == '7-14':
            days.append(0)
        else:
            days.append(1)
     
    # 另外生成一份处理后的DF
    dataDF2 = dataDF
    dataDF2['性别'] = sex
    dataDF2['年龄'] = age
    dataDF2['住院天数'] = days
     
    # 转为数组用于计算
    dataarr = np.array(dataDF)
    dataarr
     
    # 用贝叶斯模型判断病人属于哪种病:性别=‘男’,年龄<70, KILLP=1,饮酒=‘是’,吸烟=‘是”,住院天数<7
    def beiyesi(sex, age, KILLP, drink, smoke, days):
        # 初始化变量
        x1_y1,x2_y1,x3_y1,x4_y1,x5_y1,x6_y1 = 0,0,0,0,0,0
        x1_y2,x2_y2,x3_y2,x4_y2,x5_y2,x6_y2 = 0,0,0,0,0,0
        y1 = 0
        y2 = 0
         
        for line in dataarr:
            if line[6] == '心梗':# 计算在心梗条件下出现各症状的次数
                y1 += 1
                if line[0] == sex:
                    x1_y1 += 1
                if line[1] == age:
                    x2_y1 += 1
                if line[2] == KILLP:
                    x3_y1 += 1
                if line[3] == drink:
                    x4_y1 += 1
                if line[4] == smoke:
                    x5_y1 += 1
                if line[5] == days:
                    x6_y1 += 1
            else: # 计算不稳定性心绞痛条件下出现各症状的次数
                y2 += 1
                if line[0] == sex:
                    x1_y2 += 1
                if line[1] == age:
                    x2_y2 += 1
                if line[2] == KILLP:
                    x3_y2 += 1
                if line[3] == drink:
                    x4_y2 += 1
                if line[4] == smoke:
                    x5_y2 += 1
                if line[5] == days:
                    x6_y2 += 1
        # print('y1:',y1,' y2:',y2)
                 
                 
        # 计算,转为x|y1, x|y2
        # print('x1_y1:',x1_y1, ' x2_y1:',x2_y1, ' x3_y1:',x3_y1, ' x4_y1:',x4_y1, ' x5_y1:',x5_y1, ' x6_y1:',x6_y1)
        # print('x1_y2:',x1_y2, ' x2_y2:',x2_y2, ' x3_y2:',x3_y2, ' x4_y2:',x4_y2, ' x5_y2:',x5_y2, ' x6_y2:',x6_y2)
        x1_y1, x2_y1, x3_y1, x4_y1, x5_y1, x6_y1 = x1_y1/y1, x2_y1/y1, x3_y1/y1, x4_y1/y1, x5_y1/y1, x6_y1/y1
        x1_y2, x2_y2, x3_y2, x4_y2, x5_y2, x6_y2 = x1_y2/y2, x2_y2/y2, x3_y2/y2, x4_y2/y2, x5_y2/y2, x6_y2/y2
        x_y1 = x1_y1 * x2_y1 * x3_y1 * x4_y1 * x5_y1 * x6_y1
        x_y2 = x1_y2 *  x2_y2 * x3_y2 * x4_y2 * x5_y2 * x6_y2
     
             
        # 计算各症状出现的概率
        x1,x2,x3,x4,x5,x6 = 0,0,0,0,0,0
        for line in dataarr:
            if line[0] == sex:
                x1 += 1
            if line[1] == age:
                x2 += 1
            if line[2] == KILLP:
                x3 += 1
            if line[3] == drink:
                x4 += 1
            if line[4] == smoke:
                x5 += 1
            if line[5] == days:
                x6 += 1
        # print('x1:',x1, ' x2:',x2, ' x3:',x3, ' x4:',x4, ' x5:',x5, ' x6:',x6)
        # 计算
        length = len(dataarr)
        x = x1/length * x2/length * x3/length * x4/length * x5/length * x6/length
        # print('x:',x)
         
        # 分别计算 给定症状下心梗 和 不稳定性心绞痛 的概率
        y1_x = (x_y1)*(y1/length)/x
        # print(y1_x)
        y2_x = (x_y2)*(y2/length)/x
         
        # 判断是哪中疾病的可能性大
        if y1_x > y2_x:
            print('该病人患心梗的可能性较大,可能性为:',y1_x)
        else:
            print('该病人患不稳定性心绞痛的可能性较大,可能性为:',y2_x)
     
    # 判断:性别=‘男’,年龄<70, KILLP=1,饮酒=‘是’,吸烟=‘是”,住院天数<7
    beiyesi(1,-1,1,'是','是',-1)
    

     

    结果为:

     

     

    1.使用朴素贝叶斯模型对iris数据集进行花分类

    尝试使用3种不同类型的朴素贝叶斯:

    高斯分布型

    from sklearn import datasets
    iris = datasets.load_iris()
    
    from sklearn.naive_bayes import GaussianNB
    Gaus = GaussianNB()
    pred = Gaus.fit(iris.data , iris.target)
    G_pred = pred.predict(iris.data)
    
    print(iris.data.shape[0],(iris.target !=G_pred).sum())
    
    print(iris.target)
    

     

    伯努利型

    from sklearn.naive_bayes import BernoulliNB
    from sklearn import datasets
    iris = datasets.load_iris()
    Bern = BernoulliNB()
    pred = Bern.fit(iris.data, iris.target)
    B_pred = pred.predict(iris.data)
    print(iris.data.shape[0],(iris.target !=B_pred).sum())
    print(iris.target)
    print(B_pred)

     

    多项式型

    from sklearn import datasets
    from sklearn.naive_bayes import MultinomialNB
    iris = datasets.load_iris()
    Mult = MultinomialNB()
    pred = Mult.fit(iris.data, iris.target)
    M_pred = pred.predict(iris.data)
    print(iris.data.shape[0],(iris.target !=M_pred).sum())
    print(iris.target)
    print(M_pred)
    print(iris.target !=M_pred)
    

     

    2.使用sklearn.model_selection.cross_val_score(),对模型进行验证。

     

    from sklearn.naive_bayes import GaussianNB
    from sklearn.model_selection import cross_val_score
    gnb = GaussianNB()
    scores = cross_val_score(gnb,iris.data,iris.target,cv=10)
    print("准确率:%.3f"%scores.mean())
    
    from sklearn.naive_bayes import BernoulliNB
    from sklearn.model_selection import cross_val_score
    Bern = BernoulliNB()
    scores = cross_val_score(Bern,iris.data,iris.target,cv=10)
    print("准确率:%.3f"%scores.mean())
    
    from sklearn.naive_bayes import MultinomialNB
    from sklearn.model_selection import cross_val_score
    Mult = MultinomialNB()
    scores = cross_val_score(Mult,iris.data,iris.target,cv=10)
    print("准确率:%.3f"%scores.mean())
    

     

     

    3. 垃圾邮件分类

    数据准备:

    • 用csv读取邮件数据,分解出邮件类别及邮件内容。
    • 对邮件内容进行预处理:去掉长度小于3的词,去掉没有语义的词等

    (1)读取数据集

    import csv
    file_path = r'D:\shuju\SMSSpamCollectionjsn.txt'
    mail = open(file_path,'r',encoding='utf-8')
    mail_data=[]
    mail_label=[]
    csv_reader = csv.reader(mail,delimiter='\t')
    for line in csv_reader:
        mail_data.append(line[1])
        mail_label.append(line[0])
    mail.close()
    mail_data
    

      

     

    (2)邮件预处理

     

    import nltk
    from nltk.corpus import stopwords
    from nltk.stem import WordNetLemmatizer
    from sklearn.naive_bayes import MultinomialNB as MNB  
    
    def preprocessing(text):    
        #text=text.decode("utf-8)
        tokens=[word for sent in nltk.sent_tokenize(text) for word in nltk.word_tokenize(sent)] #nltk进行分词  
        stops=stopwords.words('english')                                  #去掉停用词
        tokens=[token for token in tokens if token not in stops]
        
        tokens=[token.lower() for token in tokens if len(token)>=3]                  #去掉大小写
        lmtzr=WordNetLemmatizer()                                      #词性还原
        tokens=[lmtzr.lemmatize(token) for token in tokens]
        preprocessed_text=' '.join(tokens)
        return preprocessed_text
    

     

    (3)导入数据

    import csv
    file_path=r'H:\作业\py数据挖掘基础算法\2018.12.3\SMSSpamCollectionjsn.txt'
    sms=open(file_path,'r',encoding='utf-8')
    sms_data=[]
    sms_label=[]
    csv_reader=csv.reader(sms,delimiter='\t')
    for line in csv_reader:
        sms_label.append(line[0])
        sms_data.append(preprocessing(line[1]))
    sms.close()
    

      

    (4)训练集与测试集:将先验数据按一定比例进行拆分。

    import numpy as np
    sms_data=np.array(sms_data)
    sms_label=np.array(sms_label)
    
    from sklearn.model_selection import train_test_split
    x_train, x_test, y_train, y_test =train_test_split(sms_data, sms_label, test_size=0.3, random_state=0, stratify=sms_label) #按训练集和测试集0.7:0.3划分
    print(len(sms_data),len(x_train),len(x_test))
    x_train
    

     

    (5)提取数据特征,将文本解析为词向量 。

    from sklearn.feature_extraction.text import TfidfVectorizer
    vectorizer=TfidfVectorizer(min_df=2,ngram_range=(1,2),stop_words='english',strip_accents='unicode',norm='l2')
    X_train=vectorizer.fit_transform(x_train)
    X_test=vectorizer.transform(x_test)
    

     

    (6)训练模型:建立模型,用训练数据训练模型。即根据训练样本集,计算词项出现的概率P(xi|y),后得到各类下词汇出现概率的向量 。

    X_train
    a=X_train.toarray()
    print(a)
    
    for i in range(1000):
        for j in range(5984):
            if a[i,j]!=0:
                print(i,j,a[i,j])
    

     

    (7)

    测试模型:用测试数据集评估模型预测的正确率。

    混淆矩阵

    准确率、精确率、召回率、F值

    from sklearn.naive_bayes import MultinomialNB as MNB
    from sklearn.metrics import confusion_matrix
    from sklearn.metrics import classification_report
    
    clf=MNB().fit(X_train,y_train)
    y_nb_pred=clf.predict(X_test)
    
    print(y_nb_pred.shape, y_nb_pred)
    print('nb_confusion_matrix:')              #混淆矩阵
    cm = confusion_matrix(y_test, y_nb_pred)
    print(cm)                          #准确率、精确率、召回率、F值
    cr = classification_report(y_test, y_nb_pred)
    print(cr)
    
    feature_names = vectorizer.get_feature_names()
    coefs = clf.coef_
    intercept = clf.intercept_
    coefs_with_fns = sorted(zip(coefs[0], feature_names))
    
    n = 10
    top = zip(coefs_with_fns[:n], coefs_with_fns[:-(n + 1):-1])  #
    for (coef_1, fn_1), (coef_2, fn_2) in top:
        print('\t%.4f\t%-15s\t\t%.4f\t%-15s' % (coef_1, fn_1, coef_2, fn_2))
    

     

     

     

     

    转载于:https://www.cnblogs.com/czx98/p/10018475.html

    展开全文
  • 针对朴素贝叶斯分类器在分类过程中不同类别的同一特征量之间由于存在相似性,易导致误分类的现象,提出基于引力模型的朴素贝叶斯分类算法。提出以引力公式中距离变量的平方作为相似距离,应用引力模型来刻画特征与其...
  • 朴素贝叶斯朴素贝叶斯朴素是指假设各个特征之间相互独立,不会互相影响,所以称为朴素贝叶斯。正是因为这个假设,使得算法的模型简单且容易理解,虽然牺牲了一点准确性,但是如果模型训练好,也能得到不错...

    朴素贝叶斯

    朴素贝叶斯中的朴素是指假设各个特征之间相互独立,不会互相影响,所以称为朴素贝叶斯。正是因为这个假设,使得算法的模型简单且容易理解,虽然牺牲了一点准确性,但是如果模型训练的好,也能得到不错的分类效果。

    d55ab3ec82c751aee9d8151719b2c1eb.png

    公式简单推导

    下面我们简单看一下公式的推导过程

    b4090959ccc2fd3386949ba5a7d9e808.png

    评测指标

    我们得出分类的结果后,怎么来评测我们训练的模型的好与不好呢?我们通常「准确度」「精确率」「召回率」这几个指标来进行判断模型的好坏。下边我们用一个简单的例子来说明这几个指标是怎么计算的。

    下面我们看一个表。

    c77175c8a8f175152334373212e81fac.png

    表中表示实际上科技类的文章有 40 篇,财经类的有 30 篇,然而预测的结果科技类的有 35 篇,其中 30 篇预测正确了,有 5 篇预测错误了;预测结果财经类的有 35 篇,其中 25 篇预测正确了,10 篇预测错误了。

    • 准确度

    表示预测正确的文章数比上总的文章数:(30+25)/(40+30)=78%

    • 精确率

    表示每一类预测正确的数量比上预测的该类文章总数量,比如科技类精确率:30/(30+5)=85%

    • 召回率

    表示每一类预测正确的数量比上实际该类的总数量,比如科技类:30/40=75%

    应用实例

    上边我们已经了解了朴素贝叶斯公式及推导过程,下边我们来看一下在实际的新闻分类中的应用。

    元数据的准备,我们的元数据是网上找来的一些各类的新闻,这里为了简单,我们只选取了科技、财经和体育三类数量不等的新闻,并且都已知他们的类别。然后通过中文结巴分词

    对每篇新闻进行分词。这里我们用到的是gihub上的一个开源的python库,有兴趣的可以了解一下。

    下面我们来看一下代码的具体实现。

    首先我们先把汉字的文章转成每个词所对应的数字id的形式,方便我们后边的操作和计算。

    Convert.py

    import osimport sysimport randomimport re​inputPath = sys.argv[1]outputFile = sys.argv[2]#训练集所占百分比trainPercent = 0.8wordDict = {}wordList = []​trainOutputFile = open('%s.train' % outputFile, "w")testOutputFile = open('%s.test' % outputFile, "w")​for fileName in os.listdir(inputPath): tag = 0 if fileName.find('technology') != -1: tag = 1 elif fileName.find('business') != -1: tag = 2 elif fileName.find('sport') != -1: tag = 3​ outFile = trainOutputFile rd = random.random() if rd >= trainPercent: outFile = testOutputFile​ inputFile = open(inputPath+'/'+fileName, "r") content = inputFile.read().strip() content = content.decode('utf-8', 'ignore') content = content.replace('', ' ') r1 = u'[a-zA-Z0-9’!"#$%&'()*+,-./:;<=>?@,。?★、…【】《》?“”‘’![]^_`{|}~]+' content = re.sub(r1, '', content) outFile.write(str(tag)+' ') words = content.split(' ') for word in words: if word not in wordDict: wordList.append(word) wordDict[word] = len(wordList)​ outFile.write(str(wordDict[word]) + ' ')​ inputFile.close()​trainOutputFile.close()testOutputFile.close()

    朴素贝叶斯实现过程

    NB.py

    #Usage:#Training: NB.py 1 TrainingDataFile ModelFile#Testing: NB.py 0 TestDataFile ModelFile OutFile​import sysimport osimport math​​DefaultFreq = 0.1TrainingDataFile = "nb_data.train"ModelFile = "nb_data.model"TestDataFile = "nb_data.test"TestOutFile = "nb_data.out"ClassFeaDic = {}ClassFreq = {}WordDic = {}ClassFeaProb = {}ClassDefaultProb = {}ClassProb = {}​#加载数据def LoadData(): i =0 infile = open(TrainingDataFile, 'r') sline = infile.readline().strip() while len(sline) > 0: pos = sline.find("#") if pos > 0: sline = sline[:pos].strip() words = sline.split(' ') if len(words) < 1: print("Format error!") break classid = int(words[0]) if classid not in ClassFeaDic: ClassFeaDic[classid] = {} ClassFeaProb[classid] = {} ClassFreq[classid] = 0 ClassFreq[classid] += 1 words = words[1:] for word in words: if len(word) < 1: continue wid = int(word) if wid not in WordDic: WordDic[wid] = 1 if wid not in ClassFeaDic[classid]: ClassFeaDic[classid][wid] = 1 else: ClassFeaDic[classid][wid] += 1 i += 1 sline = infile.readline().strip() infile.close() print(i, "instances loaded!") print(len(ClassFreq), "classes!
    展开全文
  • 朴素贝叶斯朴素贝叶斯朴素是指假设各个特征之间相互独立,不会互相影响,所以称为朴素贝叶斯。正是因为这个假设,使得算法的模型简单且容易理解,虽然牺牲了一点准确性,但是如果模型训练好,也能得到不错...

    朴素贝叶斯

    朴素贝叶斯中的朴素是指假设各个特征之间相互独立,不会互相影响,所以称为朴素贝叶斯。正是因为这个假设,使得算法的模型简单且容易理解,虽然牺牲了一点准确性,但是如果模型训练的好,也能得到不错的分类效果。

    c6e2ddd367485b5f2237b518594c452d.png

    公式简单推导

    下面我们简单看一下公式的推导过程

    8d11b024a982b2da4355d45f5a605729.png

    评测指标

    我们得出分类的结果后,怎么来评测我们训练的模型的好与不好呢?我们通常「准确度」「精确率」「召回率」这几个指标来进行判断模型的好坏。下边我们用一个简单的例子来说明这几个指标是怎么计算的。

    下面我们看一个表。

    //预测类别预测类别
    //科技(35)财经(35)
    实际类别科技(40)3010
    实际类别财经(30)525

    表中表示实际上科技类的文章有 40 篇,财经类的有 30 篇,然而预测的结果科技类的有 35 篇,其中 30 篇预测正确了,有 5 篇预测错误了;预测结果财经类的有 35 篇,其中 25 篇预测正确了,10 篇预测错误了。

    • 准确度

    表示预测正确的文章数比上总的文章数:(30+25)/(40+30)=78%

    • 精确率

    表示每一类预测正确的数量比上预测的该类文章总数量,比如科技类精确率:30/(30+5)=85%

    • 召回率

    表示每一类预测正确的数量比上实际该类的总数量,比如科技类:30/40=75%

    应用实例

    上边我们已经了解了朴素贝叶斯公式及推导过程,下边我们来看一下在实际的新闻分类中的应用。

    元数据的准备,我们的元数据是网上找来的一些各类的新闻,这里为了简单,我们只选取了科技、财经和体育三类数量不等的新闻,并且都已知他们的类别。然后通过中文结巴分词

    对每篇新闻进行分词。这里我们用到的是gihub上的一个开源的python库,有兴趣的可以了解一下。

    下面我们来看一下代码的具体实现。

    首先我们先把汉字的文章转成每个词所对应的数字id的形式,方便我们后边的操作和计算。

    Convert.py

    import os

    import sys

    import random

    import re

    inputPath = sys.argv[1]

    outputFile = sys.argv[2]

    #训练集所占百分比

    trainPercent = 0.8

    wordDict = {}

    wordList = []

    trainOutputFile = open('%s.train' % outputFile, "w")

    testOutputFile = open('%s.test' % outputFile, "w")

    for fileName in os.listdir(inputPath):

       tag = 0

       if fileName.find('technology') != -1:

           tag = 1

       elif fileName.find('business') != -1:

           tag = 2

       elif fileName.find('sport') != -1:

           tag = 3

       outFile = trainOutputFile

       rd = random.random()

       if rd >= trainPercent:

           outFile = testOutputFile

       inputFile = open(inputPath+'/'+fileName, "r")

       content = inputFile.read().strip()

       content = content.decode('utf-8', 'ignore')

       content = content.replace('\n', ' ')

       r1 = u'[a-zA-Z0-9’!"#$%&\'()*+,-./:;<=>?@,。?★、…【】《》?“”‘’![\\]^_`{|}~]+'

       content = re.sub(r1, '', content)

       outFile.write(str(tag)+' ')

       words = content.split(' ')

       for word in words:

           if word not in wordDict:

               wordList.append(word)

               wordDict[word] = len(wordList)

           outFile.write(str(wordDict[word]) + ' ')

       inputFile.close()

    trainOutputFile.close()

    testOutputFile.close()

    朴素贝叶斯实现过程

    NB.py

    #Usage:

    #Training: NB.py 1 TrainingDataFile ModelFile

    #Testing: NB.py 0 TestDataFile ModelFile OutFile

    import sys

    import os

    import math

    DefaultFreq = 0.1

    TrainingDataFile = "nb_data.train"

    ModelFile = "nb_data.model"

    TestDataFile = "nb_data.test"

    TestOutFile = "nb_data.out"

    ClassFeaDic = {}

    ClassFreq = {}

    WordDic = {}

    ClassFeaProb = {}

    ClassDefaultProb = {}

    ClassProb = {}

    #加载数据

    def LoadData():

       i =0

       infile = open(TrainingDataFile, 'r')

       sline = infile.readline().strip()

       while len(sline) > 0:

           pos = sline.find("#")

           if pos > 0:

               sline = sline[:pos].strip()

           words = sline.split(' ')

           if len(words) < 1:

               print("Format error!")

               break

           classid = int(words[0])

           if classid not in ClassFeaDic:

               ClassFeaDic[classid] = {}

               ClassFeaProb[classid] = {}

               ClassFreq[classid]  = 0

           ClassFreq[classid] += 1

           words = words[1:]

           for word in words:

               if len(word) < 1:

                   continue

               wid = int(word)

               if wid not in WordDic:

                   WordDic[wid] = 1

               if wid not in ClassFeaDic[classid]:

                   ClassFeaDic[classid][wid] = 1

               else:

                   ClassFeaDic[classid][wid] += 1

           i += 1

           sline = infile.readline().strip()

       infile.close()

       print(i, "instances loaded!")

       print(len(ClassFreq), "classes!", len(WordDic), "words!")

    #计算模型

    def ComputeModel():

       sum = 0.0

       for freq in ClassFreq.values():

           sum += freq

       for classid in ClassFreq.keys():

           ClassProb[classid] = (float)(ClassFreq[classid])/(float)(sum)

       for classid in ClassFeaDic.keys():

           sum = 0.0

           for wid in ClassFeaDic[classid].keys():

               sum += ClassFeaDic[classid][wid]

           newsum = (float)(sum + 1)

           for wid in ClassFeaDic[classid].keys():

               ClassFeaProb[classid][wid] = (float)(ClassFeaDic[classid][wid]+DefaultFreq)/newsum

           ClassDefaultProb[classid] = (float)(DefaultFreq) / newsum

       return

    #保存模型

    def SaveModel():

       outfile = open(ModelFile, 'w')

       for classid in ClassFreq.keys():

           outfile.write(str(classid))

           outfile.write(' ')

           outfile.write(str(ClassProb[classid]))

           outfile.write(' ')

           outfile.write(str(ClassDefaultProb[classid]))

           outfile.write(' ' )

       outfile.write('\n')

       for classid in ClassFeaDic.keys():

           for wid in ClassFeaDic[classid].keys():

               outfile.write(str(wid)+' '+str(ClassFeaProb[classid][wid]))

               outfile.write(' ')

           outfile.write('\n')

       outfile.close()

    #加载模型

    def LoadModel():

       global WordDic

       WordDic = {}

       global ClassFeaProb

       ClassFeaProb = {}

       global ClassDefaultProb

       ClassDefaultProb = {}

       global ClassProb

       ClassProb = {}

       infile = open(ModelFile, 'r')

       sline = infile.readline().strip()

       items = sline.split(' ')

       if len(items) < 6:

           print("Model format error!")

           return

       i = 0

       while i < len(items):

           classid = int(items[i])

           ClassFeaProb[classid] = {}

           i += 1

           if i >= len(items):

               print("Model format error!")

               return

           ClassProb[classid] = float(items[i])

           i += 1

           if i >= len(items):

               print("Model format error!")

               return

           ClassDefaultProb[classid] = float(items[i])

           i += 1

       for classid in ClassProb.keys():

           sline = infile.readline().strip()

           items = sline.split(' ')

           i = 0

           while i < len(items):

               wid  = int(items[i])

               if wid not in WordDic:

                   WordDic[wid] = 1

               i += 1

               if i >= len(items):

                   print("Model format error!")

                   return

               ClassFeaProb[classid][wid] = float(items[i])

               i += 1

       infile.close()

       print(len(ClassProb), "classes!", len(WordDic), "words!")

    #预测类别

    def Predict():

       global WordDic

       global ClassFeaProb

       global ClassDefaultProb

       global ClassProb

       TrueLabelList = []

       PredLabelList = []

       i =0

       infile = open(TestDataFile, 'r')

       outfile = open(TestOutFile, 'w')

       sline = infile.readline().strip()

       scoreDic = {}

       iline = 0

       while len(sline) > 0:

           iline += 1

           if iline % 10 == 0:

               print(iline," lines finished!\r")

           pos = sline.find("#")

           if pos > 0:

               sline = sline[:pos].strip()

           words = sline.split(' ')

           if len(words) < 1:

               print("Format error!")

               break

           classid = int(words[0])

           TrueLabelList.append(classid)

           words = words[1:]

           for classid in ClassProb.keys():

               scoreDic[classid] = math.log(ClassProb[classid])

           for word in words:

               if len(word) < 1:

                   continue

               wid = int(word)

               if wid not in WordDic:

                   continue

               for classid in ClassProb.keys():

                   if wid not in ClassFeaProb[classid]:

                       scoreDic[classid] += math.log(ClassDefaultProb[classid])

                   else:

                       scoreDic[classid] += math.log(ClassFeaProb[classid][wid])

           i += 1

           maxProb = max(scoreDic.values())

           for classid in scoreDic.keys():

               if scoreDic[classid] == maxProb:

                   PredLabelList.append(classid)

           sline = infile.readline().strip()

       infile.close()

       outfile.close()

       print(len(PredLabelList),len(TrueLabelList))

       return TrueLabelList,PredLabelList

    #计算准确度

    def Evaluate(TrueList, PredList):

       accuracy = 0

       i = 0

       while i < len(TrueList):

           if TrueList[i] == PredList[i]:

               accuracy += 1

           i += 1

       accuracy = (float)(accuracy)/(float)(len(TrueList))

       print("Accuracy:",accuracy)

    #计算精确率和召回率

    def CalPreRec(TrueList,PredList,classid):

       correctNum = 0

       allNum = 0

       predNum = 0

       i = 0

       while i < len(TrueList):

           if TrueList[i] == classid:

               allNum += 1

               if PredList[i] == TrueList[i]:

                   correctNum += 1

           if PredList[i] == classid:

               predNum += 1

           i += 1

       return (float)(correctNum)/(float)(predNum),(float)(correctNum)/(float)(allNum)

    #main framework

    if sys.argv[1] == '1':

       print("start training:")

       LoadData()

       ComputeModel()

       SaveModel()

    elif sys.argv[1] == '0':

       print("start testing:")

       LoadModel()

       TList,PList = Predict()

       i = 0

       outfile = open(TestOutFile, 'w')

       while i < len(TList):

           outfile.write(str(TList[i]))

           outfile.write(' ')

           outfile.write(str(PList[i]))

           outfile.write('\n')

           i += 1

       outfile.close()

       Evaluate(TList,PList)

       for classid in ClassProb.keys():

           pre,rec = CalPreRec(TList, PList,classid)

           print("Precision and recall for Class",classid,":",pre,rec)

    else:

       print("Usage incorrect!")


    如果觉得好看,可以点一下 好看 ,如果觉得对你有一点点帮助,可以赞赏作者一点,还可以推荐和分享给你的朋友

    「努力给自己看」

    954f4fed4241b19b2c1e8f99df3e356b.png

    展开全文
  • 来说:当样本特征个数较多或者特征之间相关性较大时,朴素贝叶斯分类效率比不上决策树模型;当各特征相关性较小时,朴素贝叶斯分类性能最为良好。另外朴素贝叶斯计算过程类条件概率等计算彼此是独立,因此...

    摘要:

    朴素贝叶斯分类是贝叶斯分类器的一种,贝叶斯分类算法是统计学的一种分类方法,利用概率统计知识进行分类,其分类原理就是利用贝叶斯公式根据某对象的先验概率计算出其后验概率(即该对象属于某一类的概率),然后选择具有最大后验概率的类作为该对象所属的类。总的来说:当样本特征个数较多或者特征之间相关性较大时,朴素贝叶斯分类效率比不上决策树模型;当各特征相关性较小时,朴素贝叶斯分类性能最为良好。另外朴素贝叶斯的计算过程类条件概率等计算彼此是独立的,因此特别适于分布式计算。本文详述了朴素贝叶斯分类的统计学原理,并在文本分类中实现了该算法。朴素贝叶斯分类器用于文本分类时有多项式模型和贝努利模型两种,本算法实现了这两种模型并分别用于垃圾邮件检测,性能显著。

    Note:个人认为,《机器学习实战》朴素贝叶斯这一章关于文本分类的算法是错误的,无论是其贝努利模型(书中称“词集”)还是多项式模型(书中称“词袋”),因为其计算公式不符合多项式和贝努利模型。详见本文“文本分类的两种模型”。

    (一)认识朴素贝叶斯分类

    决策树算法中提到朴素贝叶斯分类模型是应用最为广泛的分类模型之一,朴素贝叶斯分类是贝叶斯分类器的一种,贝叶斯分类算法是统计学的一种分类方法,利用概率统计知识进行分类,其分类原理就是利用贝叶斯公式根据某对象的先验概率计算出其后验概率(即该对象属于某一类的概率),然后选择具有最大后验概率的类作为该对象所属的类。目前研究较多的贝叶斯分类器主要有四种分别是:朴素贝叶斯分类、TAN(tree augmented Bayes network)算法、BAN(BN Augmented Naive Bayes)分类和GBN(General Bayesian Network)。本文重点详细阐述朴素贝叶斯分类的原理,通过Python实现了该算法,并介绍了朴素贝叶斯分类的一个应用--垃圾邮件检测。

    朴素贝叶斯的思想基础是这样的:根据贝叶斯公式,计算待分类项x出现的条件下各个类别(预先已知的几个类别)出现的概率P(yi|x),最后哪个概率值最大,就判定该待分类项属于哪个类别。训练数据的目的就在于获取样本各个特征在各个分类下的先验概率。之所以称之为“朴素”,是因为贝叶斯分类只做最原始、最简单的假设--1,所有的特征之间是统计独立的;2,所有的特征地位相同。那么假设某样本x有a1,...,aM个属性,那么有:

    P(x)=P(a1,...,aM) = P(a1)*...*P(aM)

    朴素贝叶斯分类发源于古典数学理论,有着坚实的数学基础,以及稳定的分类效率,其优点是算法简单、所需估计参数很少、对缺失数据不太敏感。理论上,朴素贝叶斯分类与其他分类方法相比具有最小的误差率,但实际上并非总是如此,因为朴素贝叶斯分类假设样本各个特征之间相互独立,这个假设在实际应用中往往是不成立的,从而影响分类正确性。因此,当样本特征个数较多或者特征之间相关性较大时,朴素贝叶斯分类效率比不上决策树模型;当各特征相关性较小时,朴素贝叶斯分类性能最为良好。总的来说,朴素贝叶斯分类算法简单有效,对两类、多类问题都适用。另外朴素贝叶斯的计算过程类条件概率等计算彼此是独立的,因此特别适于分布式计算。

    (二)朴素贝叶斯分类数学原理

    1,贝叶斯定理

    贝叶斯定理是关于随机事件A和B的条件概率(或边缘概率)的一则定理。


    其中P(A|B)是在B发生的情况下A发生的可能性。

    在贝叶斯定理中,每个名词都有约定俗成的名称:

    P(A)是A的先验概率边缘概率。之所以称为"先验"是因为它不考虑任何B方面的因素。

    P(A|B)是已知B发生后A的条件概率,也由于得自B的取值而被称作A的后验概率

    P(B|A)是已知A发生后B的条件概率,也由于得自A的取值而被称作B的后验概率

    P(B)是B的先验概率边缘概率,也作标准化常量(normalizing constant).

    2,朴素贝叶斯分类的概率论原理

    2.1 贝叶斯分类概率论描述

    用概率论来表达朴素贝叶斯分类的过程就是:

    1、是一个待分类的项,ai为x的特征属性(地位相同、相互独立),共m个。

    2、有类别集合

    3、计算

    4、如果,则

    显然,问题的关键在于第三步-求出各分类项的后验概率,用到的就是贝叶斯公式。

    则根据贝叶斯定理有如下推导:


    分母对于所有类别来说都是为常数,因此只需计算分子即可。又因为各个特征具有相同的地位且各自出现的概率相互独立,所以有:


    上式中,P(aj|yi)是关键,其含义就是样本各个特征在各个分类下的条件概率,计算各个划分的条件概率是朴素贝叶斯分类的关键性步骤,也就是数据训练阶段的任务所在。至于样本每个特征的概率分布则可能是离散的,也可能是连续的。

    2.2 先验条件概率的计算方法

    由上文看出,计算各个划分的条件概率P(a|y)是朴素贝叶斯分类的关键性步骤,下面说明特征属性为离散分布或者连续分布的计算、处理方法。

    1,离散分布-当特征属性为离散值时,只要统计训练样本中各个划分在每个类别中出现的频率即可用来估计P(a|y)。

    由于贝叶斯分类需要计算多个特征值概率以获得事物项属于某一类的概率,若某一特征值的概率为0则会使整个概率乘积变为0(称为数据稀疏),这破坏了各特征值地位相同的假设条件,使分类准确率大大降低。因此为了降低破坏率,离散分布必须进行校准-如Laplace校准:每个类别下所有特征划分的计数都加1,训练样本集数量足够大,因此并不会对结果产生影响,但却解决了上述概率为0的尴尬局面;另外从运算效率上,加法也比乘法提高了一个量级。

    数据稀疏是机器学习中很大的问题,比拉普拉斯平滑更好的解决数据稀疏的方法是:通过聚类将未出现的词找出系统相关词,根据相关词的概率求一个平均值。如果:系统有“苹果”,“葡萄”等词,但是没有“榴莲”,我们可以根据“苹果”,“葡萄”等平均值作为“榴莲”的概率,这样更合理。

    2,连续分布-当特征属性为连续值时,通常假定其值服从高斯分布(正态分布)。即:


    对于连续分布的样本特征的训练就是计算其均值和方差。

    2.3 算法改进

    实际项目中,概率P往往是值很小的小数,连续的微小小数相乘容易造成下溢出使乘积为0或者得不到正确答案。一种解决办法就是对乘积取自然对数,将连乘变为连加,ln(AB)=lnA+lnB。采用自然对数处理不会带来任何损失,可以避免下溢出或者浮点数舍入导致的错误。下图给出了f(x)和ln(f(x))函数的曲线,对比可以发现:相同区域内两者同增或者同减、在相同点取得极值,因此采用自然对数不会影响最终比较结果。


    因此下式的计算可以转变为其对数的计算,概率的比较也可以转换为概率对数的比较。


    (三)Python实现朴素贝叶斯分类算法

    贝叶斯分类器构造过程中,对于样本大小为N的样本序列常被分为较大数目的训练集和较小数目的测试集两种,训练集用来产生分类器、测试集则用来测试分类器准确率,这种过程称为“留存交叉验证”。测试集中的M个序列是在样本序列中随机选取,余下的作为训练集。

    第四节中通过--文本分类的多项式模型和贝努利模型实现了朴素贝叶斯分类算法,并将其用在了垃圾邮件检测中。

    (四)朴素贝叶斯分类用于文本分类

    1,文本分类的两种模型

    什么是文本分类?所谓文本分类,是指对所给出的文本,给出预定义的一个或多个类别标号,对文本进行准确、高效的分类.它是许多数据管理任务的重要组成部分。新闻类别(财经、体育、教育等)划分、垃圾邮件检测等都属于文本分类。关于文本分类详细的叙述可参考“文本分类概述”。文本分类可以采用Rocchio算法、朴素贝叶斯分类算法、K-近邻算法、决策树算法、神经网络算法和支持向量机算法等,本节就采用朴素贝叶斯完成分本分类任务。

    文本分类的基础是切词,切词是一个很重要的研究方向,英文切词相对自然比较容易--几乎是切成一个个单词即可,中文切词比较麻烦(预处理阶段需要特殊的处理),Python中好用的的中文切词库有(jieba—中文断词工具、SnowNLP —中文文本处理库、loso—另一个中文断词库)。本文的重点是采取朴素贝叶斯进行文本的分类,假设文档已经完成了切词(实际就简单采用了Python string的split方法)。

    文本分类中有两种朴素贝叶斯的概率计算模型可以使用,下面以二分类为模型说明两者类先验概率P(c)和各个词的类条件概率P(tk|c)的具体计算方法,P(tk|c)可以看作是单词tk在证明文本d属于类c上提供了多大的证据,而P(c)则可以认为是类别c在整体上占多大比例(有多大可能性)。

    朴素贝叶斯算法用于文本分类时,特征词的选取是一个很重要的性能因素。若将所有单词作为特征词无疑会消耗巨量的内存,计算性能也会下降。所以特征词的选取策略要根据实际做一些优化,如训练数据先进行人工筛选、只取出现次数大于N(N>=1)的词等。

    (i)多项式模型(multinomial model)即为词频型--根据分类中某词出现的次数计算概率。

    可以说多项式模型概率计算是以“词”为基础单位,设某文本d=(t1,t2,…,tk),tk是该文档中出现过的单词,允许重复,则在多项式模型中类先验概率和各个单词类条件概率的计算方法为:

    先验概率P(c)= 类c下单词总数/整个训练样本的单词总数

    类条件概率P(tk|c) = (类c下单词tk在各个文档中出现过的次数之和+1)/(类c下单词总数+|V|)

    V是训练样本的单词表(即抽取单词,单词出现多次,只算一个),|V|则表示训练样本包含多少种单词。

    多项式模型中各单词类条件概率计算考虑了词出现的次数,相当于考虑了词的权重,这更符合自然语言的特点。另外,根据斯坦福的《Introduction to Information Retrieval 》课件上所说,多项式模型计算准确率更高。待分类项类别判断时仅根据其中出现的单词进行后验概率计算,即:

    P(t1|c)*P(t2|c),...,*P(tk|c)*p(c)    

    (ii)贝努利模型(Bernoulli model)即词集型--根据分类中某词是否出现计算概率。贝努利模型不考虑词在文档中出现的次数,只考虑出不出现,因此在这个意义上相当于假设词是等权重的。

    先看贝努利模型的定义--对随机实验中某事件是否发生,试验的可能结果只有两个,这种只有两个可能结果的实验称为贝努利试验。贝努利模型中甭管哪一类,每个单词只有出现或者不出现两种,因此可以这么理解二分类的贝叶斯贝努利模型--文本中某些词的出现与否决定了该文本的分类,这实际上包含了两部分:一些词出现了,另外一些词没有出现。因此贝努利模型中各个单词类条件概率的计算是:在文本中出现的单词作为“正方”参与计算,没有在文本中出现但在该类全局单词表中出现的单词作为“反方”参与计算。

    贝努利模型概率计算的是以“文本”为基础单位,设某文本d=(t1,t2,…,tk),tk是该文档中出现过的单词,不允许重复,贝努利模型类先验概率和各个单词类条件概率的计算方法为:

    P(c) = 类c下文件总数/整个训练样本的文件总数

    P(tk|c) = (类c下包含某单词tk的文件数+1)/(类c下文件总数+2)

    其中计算P(tk|c)时,分子+1是引入Laplace校准,分母加2是因为词只有出现与否两种情况,估计也是为了数据校准(TBD)。对待分类项进行类别判断计算后验概率时,“正方”的概率就是P(tk|c),“反方”的概率是(1-P(word|c))(word是虽然不在d中,但出现在该类全局单词表上的词。因为Laplace校准的存在,实际上相当于全部的单词都参与计算),即:

    P(t1|c)*P(t2|c),...,*P(tk|c)*(1-P(word0|c)*,..., *(1-P(wordm|c)*p(c)    

    关于两个模型的博文还可以参考‘朴素贝叶斯文本分类算法学习’,本文实现了两种模型。

    2,Python实现

    2.1 naviebayes 对象

    naviebayes模块中定义了一个navieBayes对象,包含的属性如__init__函数所示:

    Source Code:Copy
    1. class navieBayes(object):   
    2.     def __init__(self,vocabSet = None, classPriorP= None, conditionP = None,\   
    3.                  classPriorP_ber= None, conditionP_ber = None,negConditionP_ber = None,lapFactor = 1,\   
    4.                  classlabelList = None, **args):   
    5.         '''modelType is NB model type,'multinomial' or 'bernoulli', the default type is'multinomial' 
    6.            parameters:  
    7.            classPriorP is (1,m)log of class prior probability list, m is class number, multinomial 
    8.            conditionP is (m,n) log of condition probability list, n is the count of vocabulary,mutinomial 
    9.            classPriorP_ber, conditionP_ber, bernoulli 
    10.            negConditionP_ber is the negtive condition probability for bernoulli model, actually log(1-condition probability) 
    11.              
    12.            vocabSet is the vocabulary set   
    13.            lapFactor is the laplace adjust factor 
    14.            classlabelList is the class labels 
    15.         '''  
    16.         obj_list = inspect.stack()[1][-2]   
    17.         self.__name__ = obj_list[0].split('=')[0].strip()   
    18.         #self.modelType = modelType  
    19.         self.classPriorP = array(classPriorP)   
    20.         self.conditionP = array(conditionP)   
    21.         self.classPriorP_ber = array(classPriorP_ber)   
    22.         self.conditionP_ber = array(conditionP_ber)   
    23.         self.negConditionP_ber = array(negConditionP_ber)   
    24.         self.vocabSet = vocabSet   
    25.         if vocabSet:   
    26.             self.vocabsetLen = len(self.vocabSet)   
    27.         self.lapFactor = lapFactor   
    28.         self.classlabelList = classlabelList   

    navieBayes对象的属性Laplace factor是用于Laplace校准的,防止词条的条件概率为0,可以通过调整Laplace factor取值使词库的统计分布更接近实际,从而增强分类性能。在一个包含超大数量的词汇库中,若按照出现次数大于1的条件取特征词,那么LaplaceFactor =1显然就不合理了,为了精确的描述的词的统计分布规律,可取LaplaceFactor =0.0001或者更小的值。

    另外navieBayes对象支持两种分类模型,默认modelType = 'multinomial'多项式模型。因为先验概率和类条件概率都是采用了其对数值,因此若要实现贝努利模型则还要增加一个属性表示‘反方’条件概率log(1-P),在贝努利模型类别判断时作为“反方”参与计算。

    navieBayes包含trainNB和classifyNB等方法,根据modelType类型选取多项式或者贝努利模型的train、classify函数产生相应的朴素贝叶斯分类器。其中trainNB方法的输入数据格式如下所示:

    Source Code:Copy
    1. postingList=[['my', 'dog', 'has', 'flea', 'problems', 'help', 'please'],   
    2. ['maybe', 'not', 'take', 'him', 'to', 'dog', 'park', 'stupid'],   
    3. ['my', 'dalmation', 'is', 'so', 'cute', 'I', 'love', 'him'],   
    4. ['stop', 'posting', 'stupid', 'worthless', 'garbage'],   
    5. ['mr', 'licks', 'ate', 'my', 'steak', 'how', 'to', 'stop', 'him'],   
    6. ['quit', 'buying', 'worthless', 'dog', 'food', 'stupid']]   
    7. classVec = [0,1,0,1,0,1]  or ['a','b','a','b','a','b']//class list  

    2.2,NavieBayes用于标示垃圾邮件测试

    使用朴素贝叶斯解决一些现实生活中的问题时,需要先从文本内容得到字符串列表,然后生成词向量。下面这个例子中,我们将了解朴素贝叶斯的一个最著名的应用:垃圾邮件过滤。

    现有垃圾邮件(spam)和非垃圾邮件(ham)各25封,将其切词后按照navieBayes对象trainNB定义的格式存放在一个列表中,邮件分类则存放于另外一个列表。另外,分类器训练过程中,为了验证训练得到的分类器的有效性,从邮件样本列表中随机抽取10个作为测试数据。

    无论采取多项式模型还是贝努利模型,上述朴素贝叶斯分类器在Laplace factor取值为[1, 0.5, 0.1, 0.01, 0.001, 0.00001]时垃圾邮件识别的错误率都为0。性能如此好,估计是训练数据和测试数据经过抽取后特征词都比较鲜明。

    多项式和贝努利模型的朴素贝叶斯文本分类学习包的下载地址是:

    Machine learning navieBayes algorithm

    另外,“机器学习实战”--第四章:朴素贝叶斯中称其词集型为贝努利模型的说法个人认为是不准确的,因为在类条件概率计算时该程序是按照统计单词数计算的,分类决断时也没有计算"反方"概率。若将其定义为多项式模型也不妥,因为它只统计了词出现与否,对于文中定义的词袋型倒可以称为多项式模型,但是其类条件概率的计算公式也不准确。


    引用

        算法杂货铺——分类算法之朴素贝叶斯分类(Naive Bayesian classification)

        朴素贝叶斯文本分类算法学习

     本文作者Adan,来源于:机器学习经典算法详解及Python实现---朴素贝叶斯分类及其在文本分类、垃圾邮件检测中的应用。转载请注明出处。

    展开全文
  • 基于朴素贝叶斯的兴趣分类

    千次阅读 2017-04-03 11:59:54
    寒假期间使用了朴素贝叶斯算法对用户画像中用户兴趣进行了分类,然而最终...在众多的分类模型中,应用最为广泛两种分类模型是决策树模型(Decision Tree Model)和朴素贝叶斯模型(Naive Bayesian Model,NBC)。 分
  • 朴素贝叶斯分类

    2013-02-25 18:37:48
    分类是将一个未知样本分到几个预先已知类的过程。数据分类问题解决是一个两步过程:第一步,建立一个模型,描述预先数据集或概念集。... 在众多的分类模型中,应用最为广泛两种分类模型是决策树模型(Decision
  • 使用朴素贝叶斯进行文本的分类 引言 朴素贝叶斯由贝叶斯定理延伸而来的简单而强大的概率模型,它根据每个特征的概率确定一个对象属于某一类别的概率。该方法基于一个假设,所有...训练模型的过程可以看作是对相...
  • 引言 朴素贝叶斯由贝叶斯定理延伸而来的简单而强大的概率模型,它根据每个特征的概率确定一个对象属于某一类别的概率。该方法基于一个假设,所有特征...训练模型的过程可以看作是对相关条件概率的计算,它可以用统计
  • 导读:在机器学习一些...比如最朴素的分类模型和最容易理解模型其实是决策树模型,这种模型比较接近我们决策思维。主要思路是根据与我们解决问题相关多个因素逐一确定下一步方案,整个决策过程就像一棵...
  • 朴素贝叶斯

    2013-01-24 14:12:11
    最为广泛两种分类模型是决策树模型(Decision Tree Model)和朴素贝叶斯模型(Naive Bayesian Model,NBC)。 目录 详细内容 应用 模型 编辑本段详细内容 分类是将一个未知样本分到几个...
  • 朴素贝叶斯理论推导与三种常见模型

    万次阅读 多人点赞 2015-09-09 21:41:03
    朴素贝叶斯(Naive Bayes)是一种简单的分类算法,它经典应用案例为人所熟知:文本分类(如垃圾邮件过滤)。很多教材都从这些案例出发,本文就不重复这些内容了,而把重点放在理论推导(其实很浅显,别被“理论”...
  • 从算法原理到实际应用的学习记录过程 1 原理 思想:在给定样本 X 情况下,计算 X 属于每个类别 C 概率。取概率高类别做为 X 预测分类 贝叶斯公式:P(Ci∣X)=P(X∣Ci)P(Ci)P(X)P(C_i|X)=\frac{P(X|C_i)P(C...
  • 文章目录一、朴素贝叶斯是什么二、朴素贝叶斯的思想三、朴素贝叶斯的推导四、参数估计五、朴素贝叶斯算法过程六、朴素贝叶斯模型七、朴素贝叶斯算法分析八、朴素贝叶斯的实际应用场景 一、朴素贝叶斯是什么 朴素...
  • 朴素贝叶斯(Naive Bayes)是一种简单的分类算法,它经典应用案例为人所熟知:文本分类(如垃圾邮件过滤)。很多教材都从这些案例出发,本文就不重复这些内容了,而把重点放在理论推导(其实很浅显,别被“理论”...
  • 朴素贝叶斯分类算法被广泛应用于文本分类场景中、包含垃圾邮件、互联网新闻等分类任务,属于有监督学习算法。它独立考量每一维度特征被分类条件概率,然后综合这些概率对其所在特征向量做出分类预测,即“假设...
  • 贝叶斯分类

    2018-11-19 11:49:11
    不同的朴素贝叶斯分类器主要区别于他们对分布假设  高斯朴素贝叶斯:假设特征可能性是高斯 多项朴素贝叶斯 补充朴素贝叶斯 伯努利朴素贝叶斯 核心外朴素贝叶斯模型拟合 尽管它们显然过于简化了假设,但...
  • 概率->阈值->分类 要求:每个类别,X分量都是相互独立。 有点:优秀、稳健 数据预处理:特征选择过程和主成分分析方法降维后,更合乎假设,一般结果还是不错。...应用:垃圾邮件分类、银行违约分类、精准营销
  • 使用朴素贝叶斯进行垃圾邮件识别

    千次阅读 2018-04-07 22:51:18
    朴素贝叶斯在文本分类、垃圾邮件识别、情感分析等方面有很好的应用。进来就来体验一下,数据借用了点击打开链接,他文件夹里面有分类好的正常邮件,垃圾邮件和测试邮件。也有代码,不过我这个代码我自己写的。 主要...
  • <机器学习实战>--朴素贝叶斯(一)

    千次阅读 2017-10-14 20:06:05
    一 简介 朴素贝叶斯是基于概率论一种分类方法,或者说是...朴素贝叶斯就是一个概率模型, 再分类的过程中, 我们会计算这个样本属于每一个类别概率, 然后求出其中最大值, 最大值所对应概率就是我们所确定类.
  • 当年垃圾邮件分类都是基于朴素贝叶斯分类器识别。 什么是条件概率,我们从一个摸球例子来理解。我们有两个桶:灰色桶和绿色桶,一共有7个小球,4个蓝色3个紫色,分布如下图: 从这7个球中,随机选择1个球是...
  • 这篇文章主要介绍将朴素贝叶斯模型应用到文本分类任务技巧和方法。 词袋模型(The Bag of Words Model) 对于机器学习算法来说,特征选择是一个很重要的过程。那么如何从文本训练集中选出好

空空如也

空空如也

1 2 3 4 5
收藏数 92
精华内容 36
关键字:

朴素贝叶斯分类模型的应用过程