基于概率论的分类方法:朴素贝叶斯算法实践学习

3	80	82	31	70	34.2	1.292	27	1
10	162	84	0	0	27.7	0.182	54	0
1	199	76	43	0	42.9	1.394	22	1
8	167	106	46	231	37.6	0.165	43	1
9	145	80	46	130	37.9	0.637	40	1
6	115	60	39	0	33.7	0.245	40	1
1	112	80	45	132	34.8	0.217	24	0
4	145	82	18	0	32.5	0.235	70	1
10	111	70	27	0	27.5	0.141	40	1
6	98	58	33	190	34	0.43	43	0

import csv  
def loadCsv(filename):  
    lines = csv.reader(open(filename,"rt"))  
    dataset = list(lines)  
    for i in range(len(dataset)):  
        dataset[i] = [float(x) for x in dataset[i]]  
    return dataset 

#输出并打印样本个数  
filename = ‘pima-indians-diabetes.data.csv‘  
dataset = loadCsv(filename)  
print ((‘Loaded data file {0} with {1} rows‘).format(filename,len(dataset)))  
#运行结果如下

Loaded data file pima-indians-diabetes.data.csv with 768 rows

#将样本数据集划分为用于朴素贝叶斯预测的训练数据集和用于评估模型精度的测试数据集。  
#将样本数据随机划分为包含67%的训练数据集和33%的测试数据集。  
import random  
def splitDataSet(dataSet, splitRation):  
    trainSize = int(len(dataSet) * splitRatio)  
    copy = list(dataSet)  
    trainSet = []  
    while len(trainSet) < trainSize:  
        index = random.randrange(len(copy))  
        trainSet.append(copy.pop(index))  
    return [trainSet,copy]  

# 假设一个有5个样例的样本集，将其分为训练数据集和测试数据集，并打印，看下每个样本数据最终落在哪个集合内。  
dataSet = [[1],[2],[3],[4],[5]]  
splitRatio =0.67  
train,test = splitDataSet(dataSet, splitRatio)  
print ((‘Split {0} rows into train with {1} and test with {2}‘).format(len(dataSet),train,test))    

#按类别划分数据  
#将训练数据集中的样本按照类别进行划分，计算出每个类别的统计数据。创建一个类别到属于此类别的样本列表的映射，并将整个数据集的样本分类到相应的映射列表。  
#separateByClass()函数完成此项任务  
def separateByClass(dataset):  
    separated = {}  
    for i in range(len(dataset)):  
        vector = dataset[i]  
        if (vector[-1] not in separated):  
            separated[vector[-1]] = []  
        separated[vector[-1]].append(vector)  
    return separated  
      
#显然，函数假设样本中最后一个属性[-1]是类别值，返回一个类别值到数据样本列表的映射。

提供一些样本进行查看。  
dataset = [[1,22,0],[2,25,0],[3,28,1],[4,35,0]]  
separated = separateByClass(dataset)  
print (("Separated instances into : {0}").format(separated))  
 

#计算均值和标准差  
#计算每个类中每个属性的均值。均值是数据的中点或数据集中趋势。在计算概率时，用它作为高斯分布中的中值。  
#计算每个类中每个属性的标准差。标准差是数据散布的偏差。在计算概率时，用它来刻画高斯分布中，每个属性所期望的散布。  
#这里采用N-1方法，即 属性值的个数减1。  
import math  
def mean(numbers):  
    return sum(numbers)/float(len(numbers))  
  
def stdev(numbers):  
    avg = mean(numbers)  
    variance = sum([pow(x-avg,2)for x in numbers])/float(len(numbers)-1)  
    return math.sqrt(variance)/float(len(numbers))

#通过计算1到5的5个数的均值和标准差来测试  
numbers = [1,2,3,4,5]  
print((‘Summary :{0} ,mean: {1}, standed_vanriation : {2}‘).format(numbers,mean(numbers),stdev(numbers))) 

#提取数据集特征  
#现在可以提取数据集特征，对于一个给定的样本列表（对应于某个类），可以计算出每个属性的均值和标准差。  
#Zip（）函数可以将数据样本按照属性分组为一个个列表，然后可以对每个属性计算均值和标准差。  
def summarize(dataset):  
    summarizes = [(mean(attribute),stdev(attribute)) for attribute in zip(*dataset)]  
    del summarizes[-1]  
    return summarizes

#可以用一些数据对于summarize（）函数进行测试。  
dataset = [[1,20,0],[2,21,1],[3,22,0]]  
summarizes = summarize(dataset)  
print ((‘Summarizes : {0}‘).format(summarizes))  
 

# 计算所属类的概率  
# 由前面内容可知，我们可以计算一个属性归属某个类的概率，那么合并数据样本中所有属性的概率，则可以得到整个数据样本归属某个类的概率。  
# 使用乘法合并概率，在calculateClassProbabilities（）函数中，给定数据样本，它属于每个类的概率，可以通过将其属性概率相乘得到。并  
#  得到类别值到概率的映射。  
def calculateClassProbabilities(summaries,inputVector):  
    probabilities = {}  
    for classValue, classSummaries in summaries.items():  
        probabilities[classValue] = 1  
        for i in range(len(classSummaries)):  
            mean, stdev = classSummaries[i]  
            x = inputVector[i]  
            probabilities[classValue] *= calculateProbability(x, mean,stdev)  
    return probabilities  

# 利用一些简单数据做测试  
summaries = {0:[(1,0.5)],1:[(20,5.0)]}  
inputVector = [1.1,‘?‘]  
probabilities = calculateClassProbabilities(summaries,inputVector)  
print ((‘Probabilities for each class : {0}‘).format(probabilities))  

# 单一预测  
# 既然可以计算一个数据样本归属每个类的概率，那么就可以找到概率的最大值，并返回关联的类。使用predict（）函数。  
def predict(summaries,inputVector):  
    probabilities = calculateClassProbabilities(summaries,inputVector)  
    bestLabel , bestProb = None, -1  
    for classValue, probability in probabilities.items():  
        if bestProb < probability or classValue is None:  
            bestProb = probability  
            bestLabel = classValue  
    return bestLabel

# 利用一些数据进行测试  
summaries ={‘A‘:[(1,0.5)], ‘B‘:[(20,5.0)]}  
inputVector = [1.1,‘?‘]  
result = predict(summaries,inputVector)  
print ((‘Prediction: {0}‘).format(result))  
 

#多重预测  
# 通过对测试数据中每个数据样本的预测，可以评估模型的精度。getPrediction（）函数可以实现此功能，并返回每个测试数据样本的预测列表。  
def getPredictions(summaries,testSet):  
    predictions = []  
    for i in range(len(testSet)):  
        result = predict(summaries, testSet[i])  
        predictions.append(result)  
    return predictions

#使用一些数据测试  
summaries = {‘A‘:[(1.1,0.5)],‘B‘:[(0,5.0)]}  
testSet =  [[1.1,‘?‘],[19.8,‘?‘]]  
predictions = getPredictions(summaries,testSet)  
print ((‘Predicitons:{0}‘).format(predictions))  
 

#计算精度  
#通过计算得来的预测值与测试数据集中的类别值进行对比，可以得到一个介于0%～100%精确率作为类别的精确度。  
def getAccuracy(testSet,predictions):  
    correct = 0  
    for x in range(len(testSet)):  
        if testSet[x][-1] ==predictions[x]:  
            correct +=1  
    return (correct/(len(testSet)))*100.0  

#使用一些数据进行测试  
testSet = [[1,1,1,‘a‘],[2,2,2,‘a‘],[3,3,3,‘b‘]]  
predictions =[‘a‘,‘a‘,‘a‘]  
accuracy = getAccuracy(testSet, predictions)  
print((‘Accuracy:{0}‘).format(accuracy))   

# Example of Naive Bayes implemented from Scratch in Python  
import csv  
import random  
import math  
   
def loadCsv(filename):  
    lines = csv.reader(open(filename, "rt"))  
    dataset = list(lines)  
    for i in range(len(dataset)):  
        dataset[i] = [float(x) for x in dataset[i]]  
    return dataset  
   
def splitDataset(dataset, splitRatio):  
    trainSize = int(len(dataset) * splitRatio)  
    trainSet = []  
    copy = list(dataset)  
    while len(trainSet) < trainSize:  
        index = random.randrange(len(copy))  
        trainSet.append(copy.pop(index))  
    return [trainSet, copy]  
   
def separateByClass(dataset):  
    separated = {}  
    for i in range(len(dataset)):  
        vector = dataset[i]  
        if (vector[-1] not in separated):  
            separated[vector[-1]] = []  
        separated[vector[-1]].append(vector)  
    return separated  
   
def mean(numbers):  
    return sum(numbers)/float(len(numbers))  
   
def stdev(numbers):  
    avg = mean(numbers)  
    variance = sum([pow(x-avg,2) for x in numbers])/float(len(numbers)-1)  
    return math.sqrt(variance)  
   
def summarize(dataset):  
    summaries = [(mean(attribute), stdev(attribute)) for attribute in zip(*dataset)]  
    del summaries[-1]  
    return summaries  
   
def summarizeByClass(dataset):  
    separated = separateByClass(dataset)  
    summaries = {}  
    for classValue, instances in separated.items():  
        summaries[classValue] = summarize(instances)  
    return summaries  
   
def calculateProbability(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 calculateClassProbabilities(summaries, inputVector):  
    probabilities = {}  
    for classValue, classSummaries in summaries.items():  
        probabilities[classValue] = 1  
        for i in range(len(classSummaries)):  
            mean, stdev = classSummaries[i]  
            x = inputVector[i]  
            probabilities[classValue] *= calculateProbability(x, mean, stdev)  
    return probabilities  
   
def predict(summaries, inputVector):  
    probabilities = calculateClassProbabilities(summaries, inputVector)  
    bestLabel, bestProb = None, -1  
    for classValue, probability in probabilities.items():  
        if bestLabel is None or probability > bestProb:  
            bestProb = probability  
            bestLabel = classValue  
    return bestLabel  
   
def getPredictions(summaries, testSet):  
    predictions = []  
    for i in range(len(testSet)):  
        result = predict(summaries, testSet[i])  
        predictions.append(result)  
    return predictions  
   
def getAccuracy(testSet, predictions):  
    correct = 0  
    for i in range(len(testSet)):  
        if testSet[i][-1] == predictions[i]:  
            correct += 1  
    return (correct/float(len(testSet))) * 100.0  
   
def main():  
    filename = ‘pima-indians-diabetes.data.csv‘  
    splitRatio = 0.67  
    dataset = loadCsv(filename)  
    trainingSet, testSet = splitDataset(dataset, splitRatio)  
    print((‘Split {0} rows into train={1} and test={2} rows‘).format(len(dataset), len(trainingSet), len(testSet)))  
    # prepare model  
    summaries = summarizeByClass(trainingSet)  
    # test model  
    predictions = getPredictions(summaries, testSet)  
    accuracy = getAccuracy(testSet, predictions)  
    print((‘Accuracy: {0}%‘).format(accuracy))  
   
main()</span> 

Split 768 rows into train=514 and test=254 rows  
Accuracy: 74.40944881889764%