class NaiveBayes:
    def __init__(self):
        self.model=None
    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(self,x,mean,stdev):
        #求高斯分布的概率密度函數
        resault=math.exp(-(math.pow(x-mean,2)/(2*math.pow(stdev,2))))
        return=(1/math.sqrt(2*math.pi)*math.pow(stdev,2))*resault
    def summarize(self,train_data):
        summarizes=[(self.mean(i),self.stdev(i)) for i in zip(*train_data)]
        #zip:壓縮;zip(*train_data)：解壓縮。將train_data看作是壓縮之后的元組列表進行解壓
        #eg：若train_data= np.array([[-1, -1], [-2, -1], [-3, -2]])
        #則zip(*train_data)將每個數組的對應位置的元素取出結果為：(-1，-2，-3){一類y的結果對應的每個數組的第0個元素}；
        #(-1,-2,1,2){每個數組的第1個元素}且需做去重處理
        #得到的結果為： [(-2.0, 0.816496580927726), (-1.3333333333333333, 0.4714045207910317)]
    def fit(self,X,y):
        labels=list(set(y))
        #set() 函數創建集合
        #即labels中的元素是y中的所有元素做去重處理得到的
        data={label:[] for label in labels}
        for f,label in zip(X,y):
            data[label].append(f)
        #得到的data是一個集合：key:y中的一個元素，value：包含X中的一些數組
        #將X中的數組劃分為len(labels)種，第一個label對應的value值是X中的前len(X)/len(label)種
        #比如若labels: [1, 2]，X = np.array([[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]])
        #則：因為labels含有2個元素，所以將X中的元素劃分為2類，一個label對應一類
        #結果：{1:[array([-1, -1]),array([-2, -1]),array([-3, -2])],2:[array([1,1]),array([2,1]),array([3,2])]}
        self.model={label:self.summarize(value) for label,value in data.items()}
        #得到的data是集合形式，key:labels的值
        #value：將每個數組的相同位置看作是一類指標的不同取值，這一類指標的均值和方差組成一個元祖作為value
        #延續上面的例子：
        #self.model {1: [(-2.0, 0.816496580927726), (-1.3333333333333333, 0.4714045207910317)], 2: [(2.0, 0.816496580927726), (1.3333333333333333, 0.4714045207910317)]}

        return 'GaussianNB train done'
    def calculate(self,input_data):
        #計算概率
        probabilities={}
        #創建空集合
        for label,value in self.model.items():
            probabilities[label]=1
            for i in range(len(value)):
            #求input_data數組的第一個元素的高斯概率結果
            #再循環一次求input_data數組的下一個元素的高斯概率結果
            #依次循環
                mean,stdev=value[i]
                probabilities[label]*=self.gaussian(input_data[i],mean,stdev)
            return probabilities
    def predict(self,X_test):
        label=sorted(self.calculate(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))

    # 計算概率
    def calculate_probabilities(self, input_data):
        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)
                #先擬合出一個高斯函數
                print('mean',mean)
                print('stdev',stdev)
                print(probabilities[label])
        return probabilities

    # 類別
    def predict(self, X_test):
        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))

思路

import math
import numpy as np
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)]
        for i in zip(*train_data):
            print(i)
        print('summaries:',summaries)
        return summaries

    # 分類別求出數學期望和標準差
    def fit(self, X, y):
        labels = list(set(y))
        print('labels:',labels)
        data = {label:[] for label in labels}
        print('data:',data)
        for f, label in zip(X, y):
            data[label].append(f)
        print('data2:', data)
        self.model = {label: self.summarize(value) for label, value in data.items()}
        print('self.model',self.model)
        return 'GaussianNB train done!'

    # 計算概率
    def calculate_probabilities(self, input_data):
        probabilities = {}
        for label, value in self.model.items():
            probabilities[label] = 1
            for i in range(len(value)):
                print('{}'.format(i))
                mean, stdev = value[i]
                probabilities[label] *= self.gaussian_probability(input_data[i], mean, stdev)
                #先擬合出一個高斯函數
                print('mean', mean)
                print('stdev', stdev)
                print('probabilities{}-{}'.format(label,probabilities[label]))
                print('******---------------------------------------------------*')
            print('probabl:',probabilities)
        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]
        print('sort:',sorted(self.calculate_probabilities(X_test).items(), key=lambda x: x[-1]))
        print('label',label)
        return label
X = np.array([[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]])
Y = np.array([1, 1, 1, 2, 2, 2])
input_data= np.array([1.1, 2.2])
model = NaiveBayes()
model.fit(X, Y)
#model.calculate_probabilities(input_data)
model.predict(input_data)

調用包做：

import numpy as np
import matplotlib.pyplot as plt

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
iris = load_iris()
X = iris.data
Y = iris.target
from sklearn.naive_bayes import GaussianNB

from sklearn.naive_bayes import MultinomialNB
from sklearn.naive_bayes import BernoulliNB
clf=GaussianNB()
clf.fit(X,Y)


iris = load_iris()
X = iris.data
Y = iris.target

X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.4, random_state=0)

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

y_pred = nb.fit(iris.data, iris.target).predict(iris.data)
print("Number of mislabeled points out of a total %d points : %d"% (iris.data.shape[0],(iris.target != y_pred).sum()))

print("Naive Gausian bayes score (sklearn): " +str(nb.score(X_test, y_test)))
nb = MultinomialNB()
#假設Y符合樸素多項式的多項式分布
nb.fit(X_train, y_train)

y_pred = nb.fit(iris.data, iris.target).predict(iris.data)
print("Number of mislabeled points out of a total %d points : %d"% (iris.data.shape[0],(iris.target != y_pred).sum()))

print("Naive MultinomialNB() bayes score (sklearn): " +str(nb.score(X_test, y_test)))

nb = BernoulliNB()
#伯努利分布
nb.fit(X_train, y_train)

y_pred = nb.fit(iris.data, iris.target).predict(iris.data)
print("Number of mislabeled points out of a total %d points : %d"% (iris.data.shape[0],(iris.target != y_pred).sum()))
print("Naive BernoulliNB bayes score (sklearn): " +str(nb.score(X_test, y_test)))