第二章 贝叶斯分类

第二章  贝叶斯分类

2.1.1  scikit—learn 实现高斯朴素贝叶斯分类

代码如下：

import numpy as np

X=np.array([[-1,-1],[-2,-1],[-3,-2],[1,1],[2,1],[3,2]])

Y=np.array([1,1,1,2,2,2])

from sklearn.naive_bayes import GaussianNB

clf=GaussianNB()   #建立GaussianNB分类器

clf.fit(X,Y)       #训练（调用fit方法）clf分类器

print(clf.predict([[-0.8,-1]]))  #预测样本[-0.8,-1]的类别

#测试样本[-0.8,-1]被预测为类别1的概率大于被预测为类别2的概率

print(clf.predict_proba([[-0.8,-1]]))

print(clf.predict_log_proba([[-0.8,-1]]))

输出结果如下：

2.1.2  Python实现iris高斯朴素贝叶斯分类

1.载入数据集，划分为训练集与测试集

代码如下：

import pandas as pd

import numpy as np

iris_df=pd.read_csv('C:/Users/windows/Desktop/iris.csv')[['Sep_len','Sep_wid',

'Pet_len','Pet_wid','Iris_type']]

def splitData(data_list, ratio):

 train_size=int(len(data_list)*ratio)

 np.random.shuffle(data_list)   #打乱data_list的元素顺序

 train_set=data_list[:train_size]

 test_set=data_list[train_size:]

 return train_set,test_set

iris_list=np.array(iris_df).tolist()

trainset,testset=splitData(iris_list,ratio=0.8) #将数据集划分训练集和测试集

print('将{0}样本数据划分为{1}个训练样本和{2}个测试样本'.format(len(iris_df),

len(trainset),len(testset)))

print('训练样本的前5条记录:')

trainset[0:5]

输出结果如下：

2.计算先验概率

先计算数据集中属于各类别的样本分别有多少，然后计算属于每个类别的先验概率。

1）按类别划分数据集

代码如下：

def divideByClass (dataset):

    divide_dict={}  #记录按类别划分的样本

    class_dict={}  #记录每个类别的样本数

    for vector in dataset:

            if vector[-1] not in divide_dict:

               divide_dict[vector[-1]]=[]

               class_dict[vector[-1]]=0

            divide_dict[vector[-1]].append(vector)

            class_dict [vector[-1]]+=1

    return divide_dict,class_dict

train_divided,train_class = divideByClass(trainset)

print('数据集各个类别的样本数:',train＿class)

print('Iris-versicolor 鸢尾花的前5条信息:\n')

train_divided["Iris-versicolor"][:5]

输出结果如下：

2）计算属于每个类别的先验概率

代码如下：

def calulatePriorProb(dataset,class_info):

    prior_prob = {}  #记录属于每个类别的先验概率

    sample_total= len(dataset)  #获取数据集样本总数

    for class_name,sample_nums in class_info.items():

         prior_prob[class_name] = sample_nums/float(sample_total)

    return prior_prob

prior_prob = calulatePriorProb(trainset,train_class)

print("属于每个类别的先验概率:\n",prior_prob)

输出结果如下：

3.计算每个特征下每类的条件概率

1）概率密度函数实现

代码如下：

#均值

def mean(list):

  list = [float(x) for x in list]

  return sum(list)/float(len(list))

#方差

def var(list):

  list = [float(x) for x in list]

  avg = mean(list)

  var = sum([math.pow((x-avg),2) for x in list])/float(len(list)-1)

  return var

#概率密度函数

def calculateProb(x,mean,var):

  exponent =math.exp(math.pow((x-mean),2)/(-2*var))

  p=(1/math.sqrt(2 * math.pi* var)) * exponent

  return p

2）计算每个属性的均值和方差

代码如下：

import math

def calculate_mean_var(dataset):

  dataset = np.delete (dataset,-1,axis=1)  #删除类别

  mean_var = [(mean(attr),var(attr)) for attr in zip(*dataset)]

  return mean_var

mean_var = calculate_mean_var(trainset)

print("每个属性的均值和方差分别是：")

for x in mean_var:

  print(x)

输出结果如下：

3）按类别提取属性特征

代码如下：

def summarizeByClass(dataset):

  divide_dict,class_dict = divideByClass(dataset)

  summarize_by_class={}

  for classValue, vector in divide_dict.items():

    summarize_by_class[classValue] = calculate_mean_var(vector)

  return summarize_by_class

train_Summary_by_class= summarizeByClass(trainset)

print(train_Summary_by_class)

输出结果如下：

4）按类别将每个属性的条件概率相乘

代码如下：

def calculateClassProb(input_data,train_Summary_by_class):

  prob={}

  for class_value, summary in train_Summary_by_class.items():

    prob[class_value]=1

    for i in range(len(summary)):

      mean,var= summary[i]

      x = input_data[i]

      p = calculateProb(x, mean, var)

    prob[class_value]*=p

  return prob

input_vector=testset[1]

input_data=input_vector[:-1]

train_Summary_by_class = summarizeByClass(trainset)

class_prob = calculateClassProb(input_data,train_Summary_by_class)

print("属于每类的概率是：")

for x in class_prob.items():

  print(x)

输出结果如下：

4.先验概率与类的条件概率相乘

代码如下：

def GaussianBayesPredict(input_data):

    prior_prob = calulatePriorProb(trainset,train_class)

    train_Summary_by_class = summarizeByClass(trainset)

    classprob_dict = calculateClassProb(input_data,train_Summary_by_class)

    result={}

    for class_value, class_prob in classprob_dict.items():

        p = class_prob* prior_prob[class_value]

        result[class_value]=p

    return max(result,key=result.get)

5.朴素贝叶斯分类器测试

代码如下：

input_vector=testset[1]

input_data=input_vector[:-1]  #获取样本的属性特征

result = GaussianBayesPredict(input_data)

print("样本所属的类别预测为:{0}".format(result))

输出结果如下：

2.2  多项式朴素贝叶斯分类

代码如下：

import numpy as np

X = np.random.randint(5,size=(6,10))

X

y = np.array( [1,2,3,4,5,6] )

from sklearn.naive_bayes import MultinomialNB

clf = MultinomialNB()  #建立 MultinomialNB分类器

clf.fit(X,y)   #训练（调用fit方法）c1f分类器

print(clf.predict([[1,1,1,2,1,1,1,2,1,0]]))   #预测测试样本的类别

输出结果如下：

2.3  伯努利朴素贝叶斯分类

代码如下：

import numpy as np

from sklearn.naive_bayes import BernoulliNB

X = np.random.randint(2,size=(6,100)) #生成6行100列的二维数组

y = np.array([1, 2,3,4,5,6])

clf=BernoulliNB() #建立分类器

clf.fit(X,y)  #训练分类器

print(clf.predict([X[2]])) #预测样本x［2］的类别

输出结果如下：