Python实现朴素贝叶斯(NB)

      这篇文章主要关于朴素贝叶斯算法的用python具体实现，网上关于NB算法的文章很多，大多围绕着《机器学习实战》这本书来着。在此，对于NB算法的原理我大概介绍一下。

贝叶斯定理：

    已知某条件概率，如何得到两个条件交换后的概率。即：已知 求

假设 A,B独立 P(A,B)=P(A)*P(B)

 

朴素贝叶斯原理：

对于给定的待分类像项，求解在此基础上每个类别出现的概率，最大的即作为最终分类的类别。

步骤：

1、 设为待分类项，ai为每个待分类属性

2、 类别集合为

3、 计算的概率

4、 取第3步骤概率值最大的为待分类项的类别。

具体实现步骤：

把上述第3步骤转化成求每个特征的条件概率。

。

因为最终考虑的是在每个类别中概率值的大小，所以去掉除数x，不影响最终分类结果。

 

1、 即转化成

2、 假设各个特征相互独立，则

========================================================

代码：

1、首先实现计算每个类别的概率

2、计算每个特征在不同类下的条件概率（每个特征出现的次数/类别下特征的总个数）

3、计算 

4.判断大小                      

具体代码如下：

# -*- coding: utf-8 -*-
import numpy as np
import glob    
def load_data():
    text=[]
    y=[1,0,1,1,1,0,1]
    with open('e:/a/ceshi.txt','r',encoding='utf-8') as infile:
        for line in infile:
            line=line.strip()
            text.append(line)   
    return text,y

def cteat_dit(alltext):
    term_dict={}
    for doc in alltext:
        for term in doc.split():
            term_dict[term]=1
    term_dict=dict(zip(term_dict.keys(),range(len(term_dict)) ))
    return term_dict
def  get_vec(term_dict,input_data):
    #将词汇转化成向量，简单的词袋模型
    vec=[0]*len(term_dict)
    for i in input_data.split():
        if i in term_dict:
            vec[term_dict[i]]=1
    return vec

def train_NB(text,y,term_dict):
    #===================================================
    #1.  计算y的概率
    
    class_set=sorted(list(set(y)))
    class_dict=dict(zip(class_set,range(len(class_set))))
   # print(class_dict){0: 0, 1: 1}
    class_prob=[0]*len(class_dict)
    class_count=[0]*len(class_dict)
    for i in y:
        class_count[class_dict[i]]+=1
    class_prob=[i/len(y) for i in class_count]
    #==================================================
    # 2. 计算每个词在不同类别下出现的次数 
    term_calss_df=np.zeros((len(term_dict),len(class_dict)))  
    
    for i in  range(len(y)):
        class_index=class_dict[y[i]]
        for term in text[i].split():#针对每一个文档
            term_index=term_dict[term]
            term_calss_df[term_index][class_index]+=1
    tf=term_calss_df
    #避免某一个概率值为0,所有词出现数+1
    tfg=tf+1
    sumh=np.sum(tf,axis=0)
    prob=tfg/sumh
    
    
    return prob,class_prob
def classifyNB(test,prob,class_prob,term_dict):
    '''
    分类函数
    '''
    datavec=[]
    for line in test:
        vec=get_vec(term_dict,line)
        datavec.append(vec)  
    #===================================================
    prob=np.log(prob)#避免下溢，不影响最终分类结果
    class_result=[]
    for i in datavec:
        
        i=np.array(i)
        i=i.reshape(-1,1)
        C_prob=prob*i
        print('############')
        all_prob=np.sum(C_prob,0)+np.log(class_prob)
        class_result.append(all_prob)
    return class_result
        
        
#=========================
#加载测试集

def load():
    text=[]
    with open('e:/a/1.txt','r',encoding='utf-8') as infile:
        for line in infile:
            line=line.strip()
            text.append(line)
    return text

def testNB():
    
    text, y=load_data()
    term_dict=cteat_dit(text)
    
    prob,class_prob =train_NB(text,y,term_dict)
    test=load()
    class_result=classifyNB(test,prob,class_prob,term_dict)
    for all_prob in class_result:
        if all_prob[1] >all_prob[0]:
            print('1') #分类结果
        else: 
            print('0') 
            
if __name__=='__main__':
    
    testNB()