一.實驗目的

1.理解樸素貝葉斯演算法原理，掌握樸素貝葉斯演算法框架；
2.掌握常見的高斯模型，多項式模型和伯努利模型；
3.能根據不同的資料型別，選擇不同的概率模型實現樸素貝葉斯演算法；
4.針對特定應用場景及資料，能應用樸素貝葉斯解決實際問題。

二.實驗內容

1.實現高斯樸素貝葉斯演算法。
2.熟悉sklearn庫中的樸素貝葉斯演算法；
3.針對iris資料集，應用sklearn的樸素貝葉斯演算法進行類別預測。
4.針對iris資料集，利用自編樸素貝葉斯演算法進行類別預測。

三、實驗報告要求

1.對照實驗內容，撰寫實驗過程、演算法及測試結果；
2.程式碼規範化：命名規則、註釋；
3.分析核心演算法的複雜度；
4.查閱文獻，討論各種樸素貝葉斯演算法的應用場景；
5.討論樸素貝葉斯演算法的優缺點。

四.實驗過程及結果

實驗程式碼及註釋

（1）、

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
%matplotlib inline
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from collections import Counter
import math
 

（2）、

# data
def create_data():
    iris = load_iris()
    df = pd.DataFrame(iris.data, columns=iris.feature_names)
    df['label'] = iris.target
    df.columns = [
        'sepal length', 'sepal width', 'petal length', 'petal width', 'label'
    ]
    data = np.array(df.iloc[:100, :])
    # print(data)
    return data[:, :-1], data[:, -1]
 

（3）、

X, y = create_data()
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)

（4）、

X_test[0], y_test[0]

（5）、

class NaiveBayes:
    def __init__(self):
        self.model = None
    # 數學期望
    @staticmethod
    def mean(X):
        return sum(X) / float(len(X))
    # 標準差（方差）
    def stdev(self, X):
        avg = self.mean(X)
        return math.sqrt(sum([pow(x - avg, 2) for x in X]) / float(len(X)))
    # 概率密度函式
    def gaussian_probability(self, x, mean, stdev):
        exponent = math.exp(-(math.pow(x - mean, 2) /
                              (2 * math.pow(stdev, 2))))
        return (1 / (math.sqrt(2 * math.pi) * stdev)) * exponent
    # 處理X_train
    def summarize(self, train_data):
        summaries = [(self.mean(i), self.stdev(i)) for i in zip(*train_data)]
        return summaries
    # 分類別求出數學期望和標準差
    def fit(self, X, y):
        labels = list(set(y))
        data = {label: [] for label in labels}
        for f, label in zip(X, y):
            data[label].append(f)
        self.model = {
            label: self.summarize(value)
            for label, value in data.items()
        }
        return 'gaussianNB train done!'
    # 計算概率
    def calculate_probabilities(self, input_data):
        # summaries:{0.0: [(5.0, 0.37),(3.42, 0.40)], 1.0: [(5.8, 0.449),(2.7, 0.27)]}
        # input_data:[1.1, 2.2]
        probabilities = {}
        for label, value in self.model.items():
            probabilities[label] = 1
            for i in range(len(value)):
                mean, stdev = value[i]
                probabilities[label] *= self.gaussian_probability(
                    input_data[i], mean, stdev)
        return probabilities
    # 類別
    def predict(self, X_test):
        # {0.0: 2.9680340789325763e-27, 1.0: 3.5749783019849535e-26}
        label = sorted(
            self.calculate_probabilities(X_test).items(),
            key=lambda x: x[-1])[-1][0]
        return label
    def score(self, X_test, y_test):
        right = 0
        for X, y in zip(X_test, y_test):
            label = self.predict(X)
            if label == y:
                right += 1
        return right / float(len(X_test))

（6）、

model = NaiveBayes()

（7）、

model.fit(X_train, y_train)

輸出：

（8）、

print(model.predict([4.4, 3.2, 1.3, 0.2]))

（9）、

model.score(X_test, y_test)

（10）

from sklearn.naive_bayes import GaussianNB

（11）、

clf = GaussianNB()
clf.fit(X_train, y_train)

輸出：

（12）、

clf.score(X_test, y_test)

（13）、

clf.predict([[4.4, 3.2, 1.3, 0.2]])

（14）、

from sklearn.naive_bayes import BernoulliNB, MultinomialNB # 伯努利模型和多項式模型

五.實驗小結

通過此次試驗瞭解了樸素貝葉斯演算法，知道樸素貝葉斯是一種簡單的分類演算法，稱它“樸素”是因為，整個形式化過程只做最原始 最簡單的假設。樸素貝葉斯的核心思想是：對於待分類項，求解此待分類項在各個類別中出現的概率，哪個類別概率最大，則認為此待分類項就屬於那個類別。