优点：在数据较少的情况下仍然有效，可以处理多类别问题。
缺点：对于输入数据的准备方式较为敏感。
适用数据类型：标称型数据(也就是只有两类结果的数据)。
(1) 收集数据：可以使用任何方法。
(2) 准备数据：需要数值型或者布尔型数据。
(3) 分析数据：有大量特征时，绘制特征作用不大，此时使用直方图效果更好。
(4) 训练算法：计算不同的独立特征的条件概率。
(5) 测试算法：计算错误率。
(6) 使用算法：一个常见的朴素贝叶斯应用是文档分类。可以在任意的分类场景中使用朴
素贝叶斯分类器，不一定非要是文本。
# from numpy import *
# import re
# import operator
#
#
# # 加载数据,创建了一些实验样本
# def load_data_set():
# posting_list = [
# ['my', 'dog', 'has', 'flea', 'problems', 'help', 'please'],
# ['maybe', 'not', 'take', 'him', 'to', 'dog', 'park', 'stupid'],
# ['my', 'dalmation', 'is', 'so', 'cute', 'I', 'love', 'him'],
# ['stop', 'posting', 'stupid', 'worthless', 'garbage'],
# ['mr', 'licks', 'ate', 'my', 'steak', 'how', 'to', 'stop', 'him'],
# ['quit', 'buying', 'worthless', 'dog', 'food', 'stupid']
# ]
#
# # 1代表侮辱性文字， 0代表正常言论
# class_vec = [0, 1, 0, 1, 0, 1]
#
# return posting_list, class_vec
#
#
# # 创建一个包含在所有文档中出现的不重复的列表
# def create_vocab_list(data_set):
#
# # 创建一个空集
# vocab_set = set([])
#
# for document in data_set:
# vocab_set = vocab_set | set(document)#依次找到所有的并集
# # print(vocabset)
#
# # 创建两个集合的并集
# return list(sorted(vocab_set))
#
#
# # 输入参数是一个文档，输出的是文档向量
# def set_of_word_vec(vocab_list, input_set):
#
# # 创建一个所含向量都为0的向量
# vec = [0] * len(vocab_list)
#
# for word in input_set:
# if word in vocab_list:
# vec[vocab_list.index(word)] = 1
# else:
# print("The word:%s is not in my vocalulary!" % word)
#
# return vec
#
# listoposts ,listclasses = load_data_set()
# myvocablist = create_vocab_list(listoposts)
# print(myvocablist)
# set_of_word_vec(myvocablist,listoposts[0])
# # print(set_of_word_vec(myvocablist,listoposts[0]))
# # print(set_of_word_vec(myvocablist,listoposts[1]))
#
# # 朴素贝叶斯分类器的训练
# def train(train_matrix, train_category):
# num_train_docs = len(train_matrix)#一共有6个文本
# num_words = len(train_matrix[0])#每个文本由32个词袋向量组成
# p_abusive = sum(train_category) / float(num_train_docs)
#
# # 初始化概率
# p0_num = ones(num_words)
# p1_num = ones(num_words)
# p0_denom = 2.0
# p1_denom = 2.0
#
# # 向量相加
# for i in range(num_train_docs):
# if train_category[i] == 1:
# p1_num += train_matrix[i]
# p1_denom += sum(train_matrix[i])
# else:#第一个文本判断为侮辱性文字
# p0_num += train_matrix[i]
# p0_denom += sum(train_matrix[i])
#
# # 对每个元素做除法
# p1_vec = log(p0_num / p1_denom)
# p0_vec = log(p0_num / p0_denom)
# return p0_vec, p1_vec, p_abusive
#
# train_mat = []
# for i in listoposts:
# train_mat.append(set_of_word_vec(myvocablist,i))
# print(train_mat)
# p0v,p1v,pAB = train(train_mat,listclasses)
# print()
# coding=utf-8
# Author:Dodo
# Date:2018-11-17
# Email:lvtengchao@pku.edu.cn
'''
数据集：Mnist
训练集数量：60000
测试集数量：10000
------------------------------
运行结果：
正确率：84.3%
运行时长：103s
'''
import numpy as np
import time
def loadData(fileName):
'''
加载文件
:param fileName:要加载的文件路径
:return: 数据集和标签集
'''
# 存放数据及标记
dataArr = [];
labelArr = []
# 读取文件
fr = open(fileName)
# 遍历文件中的每一行
for line in fr.readlines():
# 获取当前行，并按“，”切割成字段放入列表中
# strip：去掉每行字符串首尾指定的字符（默认空格或换行符）
# split：按照指定的字符将字符串切割成每个字段，返回列表形式
curLine = line.strip().split(',')
# 将每行中除标记外的数据放入数据集中（curLine[0]为标记信息）
# 在放入的同时将原先字符串形式的数据转换为整型
# 此外将数据进行了二值化处理，大于128的转换成1，小于的转换成0，方便后续计算
dataArr.append([int(int(num) > 128) for num in curLine[1:]])
# 将标记信息放入标记集中
# 放入的同时将标记转换为整型
labelArr.append(int(curLine[0]))
# 返回数据集和标记
return dataArr, labelArr
def NaiveBayes(Py, Px_y, x):
'''
通过朴素贝叶斯进行概率估计
:param Py: 先验概率分布
:param Px_y: 条件概率分布
:param x: 要估计的样本x
:return: 返回所有label的估计概率
'''
# 设置特征数目
featrueNum = 784
# 设置类别数目
classNum = 10
# 建立存放所有标记的估计概率数组
P = [0] * classNum
# 对于每一个类别，单独估计其概率
for i in range(classNum):
# 初始化sum为0，sum为求和项。
# 在训练过程中对概率进行了log处理，所以这里原先应当是连乘所有概率，最后比较哪个概率最大
# 但是当使用log处理时，连乘变成了累加，所以使用sum
sum = 0
# 获取每一个条件概率值，进行累加
for j in range(featrueNum):#找到y等于1这个类别下，特征1，以及特征取值0或者1的概率，x是我们传进来的预测值
sum += Px_y[i][j][x[j]]
# 最后再和先验概率相加（也就是式4.7中的先验概率乘以后头那些东西，乘法因为log全变成了加法）
P[i] = sum + Py[i]
# max(P)：找到概率最大值
# P.index(max(P))：找到该概率最大值对应的所有（索引值和标签值相等）
return P.index(max(P))
def test(Py, Px_y, testDataArr, testLabelArr):
'''
对测试集进行测试
:param Py: 先验概率分布
:param Px_y: 条件概率分布
:param testDataArr: 测试集数据
:param testLabelArr: 测试集标记
:return: 准确率
'''
# 错误值计数
errorCnt = 0
# 循环遍历测试集中的每一个样本
for i in range(len(testDataArr)):
# 获取预测值
presict = NaiveBayes(Py, Px_y, testDataArr[i])
# 与答案进行比较
if presict != testLabelArr[i]:
# 若错误 错误值计数加1
errorCnt += 1
# 返回准确率
return 1 - (errorCnt / len(testDataArr))
def getAllProbability(trainDataArr, trainLabelArr):
'''
通过训练集计算先验概率分布和条件概率分布
:param trainDataArr: 训练数据集
:param trainLabelArr: 训练标记集
:return: 先验概率分布和条件概率分布
'''
# 设置样本特诊数目，数据集中手写图片为28*28，转换为向量是784维。
# （我们的数据集已经从图像转换成784维的形式了，CSV格式内就是）
featureNum = 784
# 设置类别数目，0-9共十个类别
classNum = 10
# 初始化先验概率分布存放数组，后续计算得到的P(Y = 0)放在Py[0]中，以此类推
# 数据长度为10行1列的数组
Py = np.zeros((classNum, 1))
# 对每个类别进行一次循环，分别计算它们的先验概率分布
# 计算公式为书中"4.2节 朴素贝叶斯法的参数估计 公式4.8"
for i in range(classNum):
# 下方式子拆开分析
# np.mat(trainLabelArr) == i：将标签转换为矩阵形式，里面的每一位与i比较，若相等，该位变为Ture，反之False
# np.sum(np.mat(trainLabelArr) == i):计算上一步得到的矩阵中Ture的个数，进行求和(直观上就是找所有label中有多少个
# 为i的标记，求得4.8式P（Y = Ck）中的分子)
# np.sum(np.mat(trainLabelArr) == i)) + 1：参考“4.2.3节 贝叶斯估计”，例如若数据集总不存在y=1的标记，也就是说
# 手写数据集中没有1这张图，那么如果不加1，由于没有y=1，所以分子就会变成0，那么在最后求后验概率时这一项就变成了0，再
# 和条件概率乘，结果同样为0，不允许存在这种情况，所以分子加1，分母加上K（K为标签可取的值数量，这里有10个数，取值为10）
# 参考公式4.11
# (len(trainLabelArr) + 10)：标签集的总长度+10.
# ((np.sum(np.mat(trainLabelArr) == i)) + 1) / (len(trainLabelArr) + 10)：最后求得的先验概率
# 一句话解释也就是从类别标签列表里找出来一共每个类别占总行数的比例
Py[i] = ((np.sum(np.mat(trainLabelArr) == i)) + 1) / (len(trainLabelArr) + 10)
# 转换为log对数形式
# log书中没有写到，但是实际中需要考虑到，原因是这样：
# 最后求后验概率估计的时候，形式是各项的相乘（“4.1 朴素贝叶斯法的学习” 式4.7），这里存在两个问题：1.某一项为0时，结果为0.
# 这个问题通过分子和分母加上一个相应的数可以排除，前面已经做好了处理。2.如果特诊特别多（例如在这里，需要连乘的项目有784个特征
# 加一个先验概率分布一共795项相乘，所有数都是0-1之间，结果一定是一个很小的接近0的数。）理论上可以通过结果的大小值判断， 但在
# 程序运行中很可能会向下溢出无法比较，因为值太小了。所以人为把值进行log处理。log在定义域内是一个递增函数，也就是说log（x）中，
# x越大，log也就越大，单调性和原数据保持一致。所以加上log对结果没有影响。此外连乘项通过log以后，可以变成各项累加，简化了计算。
# 在似然函数中通常会使用log的方式进行处理
Py = np.log(Py)
# 计算条件概率 Px_y=P（X=x|Y = y）
# 计算条件概率分成了两个步骤，下方第一个大for循环用于累加，参考书中“4.2.3 贝叶斯估计 式4.10”，下方第一个大for循环内部是
# 用于计算式4.10的分子，至于分子的+1以及分母的计算在下方第二个大For内
# 初始化为全0矩阵，用于存放所有情况下的条件概率
Px_y = np.zeros((classNum, featureNum, 2))#就是一个三维数组，【【【】】】
# 对标记集进行遍历
for i in range(len(trainLabelArr)):#遍历所有的数据，然后计算每个y标签下，每个特征的数量
# 获取当前循环所使用的标记
label = trainLabelArr[i]#拿到第一行的标签，也就是y
# 获取当前要处理的样本
x = trainDataArr[i]#拿到第一行的样本数据，也就是x
# 对第一行样本的每一维特征进行遍历
for j in range(featureNum):#对x进行遍历
# 在矩阵中对应位置加1
# 这里还没有计算条件概率，先把所有数累加，全加完以后，在后续步骤中再求对应的条件概率，x[j]只有两种取值，一种是0，一种是1
Px_y[label][j][x[j]] += 1#代表是在哪个标签里，第j个特征里
# 第二个大for，计算式4.10的分母，以及分子和分母之间的除法
# 循环每一个标记（共10个）
for label in range(classNum):
# 循环每一个标记对应的每一个特征
for j in range(featureNum):
# 获取y=label，第j个特诊为0的个数
Px_y0 = Px_y[label][j][0]
# 获取y=label，第j个特诊为1的个数
Px_y1 = Px_y[label][j][1]
# 对式4.10的分子和分母进行相除，再除之前依据贝叶斯估计，分母需要加上2（为每个特征可取值个数）
# 分别计算对于y= label，x第j个特征为0和1的条件概率分布
Px_y[label][j][0] = np.log((Px_y0 + 1) / (Px_y0 + Px_y1 + 2))
Px_y[label][j][1] = np.log((Px_y1 + 1) / (Px_y0 + Px_y1 + 2))
# 返回先验概率分布和条件概率分布
return Py, Px_y
if __name__ == "__main__":
start = time.time()
# 获取训练集
print('start read transSet')
train_path= r"F:\机器学习入门\统计学习\Statistical-Learning-Method_Code-master\Mnist\mnist_train.csv"
trainDataArr, trainLabelArr = loadData(train_path)
# 获取测试集
print('start read testSet')
test_path = r"F:\机器学习入门\统计学习\Statistical-Learning-Method_Code-master\Mnist\mnist_test\mnist_test.csv"
testDataArr, testLabelArr = loadData(test_path)
# 开始训练，学习先验概率分布和条件概率分布
print('start to train')
Py, Px_y = getAllProbability(trainDataArr, trainLabelArr)
print(Py,Px_y)
# 使用习得的先验概率分布和条件概率分布对测试集进行测试
print('start to test')
accuracy = test(Py, Px_y, testDataArr, testLabelArr)
# 打印准确率
print('the accuracy is:', accuracy)
# 打印时间
print('time span:', time.time() - start)
