机器学习算法实现（三）----朴素贝叶斯

1.朴素贝叶斯法是典型的生成学习方法，利用训练数据学习P(X|Y)和P(Y)的估计，得到联合概率分布：
P(X,Y)=P(Y)P(X|Y)
2.概率估计方法：极大似然估计或贝叶斯估计
3.朴素贝叶斯法的基本假设：条件独立性

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

from collections import Counter
import math
# 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]

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

class NaiveBayes:
    def __init__(self):
        self.model=None
    def mean(self,x):
        return sum(x)/float(len(x))
    def stdev(self,x):  #方差
        avg =self.mean(x)
        mid_var = sum([pow(i-avg,2) for i in x])/float(len(x))
        return math.sqrt(mid_var)
    #概率密度函数  特征的可能性被假设为高斯
    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
    def summarize(self,data_train):
        summaries = [(self.mean(i),self.stdev(i)) for i in zip(*data_train)]    
        #zip(*data) 前面加*号表示对data的列进行迭代打包  不加表示对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 "train done"
    def caculate_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)
        return probabilities
    
    
    def predict(self, x_test):
        label = sorted(self.caculate_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))
#测试
model=NaiveBayes()
model.fit(X_train,y_train)
model.score(X_test,y_test)

sklearn 实现：

from sklearn.naive_bayes import GaussianNB
clf = GaussianNB()
clf.fit(X_train, y_train)、
clf.score(X_test, y_test)
from sklearn.naive_bayes import BernoulliNB, MultinomialNB # 伯努利模型和多项式模型