朴素貝葉斯算法--python實現

朴素貝葉斯算法要理解一下基礎：    【朴素：特征條件獨立   貝葉斯：基於貝葉斯定理】

1朴素貝葉斯的概念【聯合概率分布、先驗概率、 條件概率**、全概率公式】【條件獨立性假設、】   極大似然估計

2優缺點    

【優點： 分類效率穩定；對缺失數據不敏感，算法比較簡單，常用於 文本分類；在屬性相關性較小時，該算法性能最好    缺點：假設屬性之間相互獨立；先驗概率多取決於假設；對輸入數據的表達形式很敏感】

3先驗概率、后驗概率

先驗概率的計算比較簡單，沒有使用貝葉斯公式；

而后驗概率的計算，要使用貝葉斯公式，而且在利用樣本資料計算邏輯概率時，還要使用理論概率分布，需要更多的數理統計知識。

4朴素貝葉斯的參數估計：

①極大似然估計（可能出現概率為0的情況）②貝葉斯估計（加入常數，拉普拉斯平滑）

 

參考：

教你明白啥是朴素貝葉斯分類器    有助於理解朴素貝葉斯算法

《統計學習方法》-朴素貝葉斯法筆記和python源碼     理論總結得很全*   

 

前提python2.7     數據來源：  http://pan.baidu.com/s/1pLoKUMJ

 # 極大似然估計  朴素貝葉斯算法

#coding:utf-8
# 極大似然估計  朴素貝葉斯算法
import pandas as pd
import numpy as np

class NaiveBayes(object):
    def getTrainSet(self):
        dataSet = pd.read_csv('C://pythonwork//practice_data//naivebayes_data.csv')
        dataSetNP = np.array(dataSet)  #將數據由dataframe類型轉換為數組類型
        trainData = dataSetNP[:,0:dataSetNP.shape[1]-1]   #訓練數據x1,x2
        labels = dataSetNP[:,dataSetNP.shape[1]-1]        #訓練數據所對應的所屬類型Y
        return trainData, labels

    def classify(self, trainData, labels, features):
        #求labels中每個label的先驗概率
        labels = list(labels)    #轉換為list類型
        P_y = {}       #存入label的概率
        for label in labels:
            P_y[label] = labels.count(label)/float(len(labels))   # p = count(y) / count(Y)

        #求label與feature同時發生的概率
        P_xy = {}
        for y in P_y.keys():
            y_index = [i for i, label in enumerate(labels) if label == y]  # labels中出現y值的所有數值的下標索引
            for j in range(len(features)):      # features[0] 在trainData[:,0]中出現的值的所有下標索引
                x_index = [i for i, feature in enumerate(trainData[:,j]) if feature == features[j]]
                xy_count = len(set(x_index) & set(y_index))   # set(x_index)&set(y_index)列出兩個表相同的元素
                pkey = str(features[j]) + '*' + str(y)
                P_xy[pkey] = xy_count / float(len(labels))

        #求條件概率
        P = {}
        for y in P_y.keys():
            for x in features:
                pkey = str(x) + '|' + str(y)
                P[pkey] = P_xy[str(x)+'*'+str(y)] / float(P_y[y])    #P[X1/Y] = P[X1Y]/P[Y]

        #求[2,'S']所屬類別
        F = {}   #[2,'S']屬於各個類別的概率
        for y in P_y:
            F[y] = P_y[y]
            for x in features:
                F[y] = F[y]*P[str(x)+'|'+str(y)]     #P[y/X] = P[X/y]*P[y]/P[X]，分母相等，比較分子即可，所以有F=P[X/y]*P[y]=P[x1/Y]*P[x2/Y]*P[y]

        features_label = max(F, key=F.get)  #概率最大值對應的類別
        return features_label


if __name__ == '__main__':
    nb = NaiveBayes()
    # 訓練數據
    trainData, labels = nb.getTrainSet()
    # x1,x2
    features = [2,'S']
    # 該特征應屬於哪一類
    result = nb.classify(trainData, labels, features)
    print features,'屬於',result

 

#朴素貝葉斯算法   貝葉斯估計， λ=1  K=2， S=3； λ=1 拉普拉斯平滑

#coding:utf-8
#朴素貝葉斯算法   貝葉斯估計， λ=1  K=2， S=3； λ=1 拉普拉斯平滑
import pandas as pd
import numpy as np

class NavieBayesB(object):
    def __init__(self):
        self.A = 1    # 即λ=1
        self.K = 2
        self.S = 3

    def getTrainSet(self):
        trainSet = pd.read_csv('C://pythonwork//practice_data//naivebayes_data.csv')
        trainSetNP = np.array(trainSet)     #由dataframe類型轉換為數組類型
        trainData = trainSetNP[:,0:trainSetNP.shape[1]-1]     #訓練數據x1,x2
        labels = trainSetNP[:,trainSetNP.shape[1]-1]          #訓練數據所對應的所屬類型Y
        return trainData, labels

    def classify(self, trainData, labels, features):
        labels = list(labels)    #轉換為list類型
        #求先驗概率
        P_y = {}
        for label in labels:
            P_y[label] = (labels.count(label) + self.A) / float(len(labels) + self.K*self.A)

        #求條件概率
        P = {}
        for y in P_y.keys():
            y_index = [i for i, label in enumerate(labels) if label == y]   # y在labels中的所有下標
            y_count = labels.count(y)     # y在labels中出現的次數
            for j in range(len(features)):
                pkey = str(features[j]) + '|' + str(y)
                x_index = [i for i, x in enumerate(trainData[:,j]) if x == features[j]]   # x在trainData[:,j]中的所有下標
                xy_count = len(set(x_index) & set(y_index))   #x y同時出現的次數
                P[pkey] = (xy_count + self.A) / float(y_count + self.S*self.A)   #條件概率

        #features所屬類
        F = {}
        for y in P_y.keys():
            F[y] = P_y[y]
            for x in features:
                F[y] = F[y] * P[str(x)+'|'+str(y)]

        features_y = max(F, key=F.get)   #概率最大值對應的類別
        return features_y


if __name__ == '__main__':
    nb = NavieBayesB()
    # 訓練數據
    trainData, labels = nb.getTrainSet()
    # x1,x2
    features = [2,'S']
    # 該特征應屬於哪一類
    result = nb.classify(trainData, labels, features)
    print features,'屬於',result