记录维维的每一篇Hello World

9.jpg

朴素贝叶斯公式

朴素贝叶斯判断西瓜好坏 - 图2

西瓜数据

复制保存为csv文件格式

  1. 色泽,根蒂,敲声,纹理,脐部,触感,好瓜
  2. 青绿,蜷缩,浊响,清晰,凹陷,硬滑,是
  3. 乌黑,蜷缩,沉闷,清晰,凹陷,硬滑,是
  4. 乌黑,蜷缩,浊响,清晰,凹陷,硬滑,是
  5. 青绿,蜷缩,沉闷,清晰,凹陷,硬滑,是
  6. 浅白,蜷缩,浊响,清晰,凹陷,硬滑,是
  7. 青绿,稍蜷,浊响,清晰,稍凹,软粘,是
  8. 乌黑,稍蜷,浊响,稍糊,稍凹,软粘,是
  9. 乌黑,稍蜷,浊响,清晰,稍凹,硬滑,是
  10. 乌黑,稍蜷,沉闷,稍糊,稍凹,硬滑,否
  11. 青绿,硬挺,清脆,清晰,平坦,软粘,否
  12. 浅白,硬挺,清脆,模糊,平坦,硬滑,否
  13. 浅白,蜷缩,浊响,模糊,平坦,软粘,否
  14. 青绿,稍蜷,浊响,稍糊,凹陷,硬滑,否
  15. 浅白,稍蜷,沉闷,稍糊,凹陷,硬滑,否
  16. 乌黑,稍蜷,浊响,清晰,稍凹,软粘,否
  17. 浅白,蜷缩,浊响,模糊,平坦,硬滑,否
  18. 青绿,蜷缩,沉闷,稍糊,稍凹,硬滑,否

实现理论

假设事件西瓜是好瓜为Y，是坏瓜为N，
属性色泽，根蒂，敲声，纹理，脐部，触感，分别为a，b，c，d，e，f，

在已知西瓜属性的情况下西瓜是好瓜的概率为：

朴素贝叶斯判断西瓜好坏 - 图3
又有：
朴素贝叶斯判断西瓜好坏 - 图4

在已知西瓜属性的情况下西瓜不是好瓜的概率为：

朴素贝叶斯判断西瓜好坏 - 图5
又有：
朴素贝叶斯判断西瓜好坏 - 图6

两个相除，得到
朴素贝叶斯判断西瓜好坏 - 图7
当其大于1是，可以判断西瓜是好瓜
朴素贝叶斯判断西瓜好坏 - 图8

在计算过程中，有可能出现值为0或者值过于小的情况，所以进行log处理
朴素贝叶斯判断西瓜好坏 - 图9
=
朴素贝叶斯判断西瓜好坏 - 图10
=
朴素贝叶斯判断西瓜好坏 - 图11
=
朴素贝叶斯判断西瓜好坏 - 图12
=
朴素贝叶斯判断西瓜好坏 - 图13

为了防止0的情况出现，所以我们进行全部加1来进行比较
朴素贝叶斯判断西瓜好坏 - 图14

代码实现

需要安装的工具包

  1. import numpy
  2. import pandas

数据预处理

  1. import json
  2. import pandas as pd
  4. # 导入数据/生成数据表
  5. dataSheet = pd.read_csv("E:\\Data\\西瓜\\123.csv", encoding="utf-8")
  6. # print(dataSheet)
  7. # 预数据
  8. data_proba = {}
  9. # 标签/列名称
  10. header = dataSheet.columns
  11. # 案例个数/行数
  12. length = dataSheet.shape[0]
  13. # 数据表值
  14. values = dataSheet.values
  15. # 最后一列的不重复数据
  16. end_unique = dataSheet[header[-1]].unique()
  17. # 遍历
  18. for end in end_unique:
  19.     # [header[-1]==end]时end出现的次数
  20.     end_sum = dataSheet[dataSheet[header[-1]].isin([end])].shape[0]
  21.     # [header[-1]==end]时end出现的频率
  22.     end_proba = dataSheet[dataSheet[header[-1]].isin([end])].shape[0] / length
  23.     # 预保存
  24.     data_proba[end] = {'proba': end_proba, 'data': {}}
  25.     # 遍历标签/列名称
  26.     for head in header[:-1]:
  27.         # 初始化
  28.         data_proba[end]['data'][head] = {}
  29.         # 该标签/名称下不重复值
  30.         head_unique = dataSheet[head].unique()
  31.         # 遍历属性
  32.         for head_val in head_unique:
  33.             # [header[-1]==end]时head_val出现的次数
  34.             head_val_sum = dataSheet[dataSheet[head].isin([head_val]) & dataSheet[header[-1]].isin([end])].shape[0]
  35.             # [header[-1]==end]时head_val出现的频率
  36.             head_val_proba = head_val_sum / end_sum
  37.             # 预保存
  38.             data_proba[end]['data'][head][head_val] = head_val_proba
  41. # 打印结果
  42. print(json.dumps(data_proba, indent=4, ensure_ascii=False))

数据预测

  1. import numpy as np
  3. # 创建一个存放判断结果的数组
  4. new = np.empty((length, 1), str)
  6. # 遍历values的每一行
  7. for val_num in np.arange(length):
  8.     judge = {}
  9.     # 遍历最后一列不重复数据
  10.     for end in end_unique:
  11.         # 标签/列名称除最后一列的数量
  12.         header_sum = len(header[:-1])
  13.         # 创建一个临时存放数据的数组
  14.         tempor = np.empty(header_sum + 1, float)
  15.         # 最后一个标签/列名称的属性对应的先验概率
  16.         end_proba = data_proba[end]['proba']
  17.         # 加1处理
  18.         end_proba += 1
  19.         # 临时保存
  20.         tempor[-1] = end_proba
  21.         # 遍历除最后一行的标签/列名称
  22.         for head_num in np.arange(header_sum):
  23.             # 标签/列名称
  24.             head = header[head_num]
  25.             # 该标签/列名称下的属性
  26.             val = values[val_num][head_num]
  27.             # 属性对应的先验概率
  28.             head_val_proba = data_proba[end]['data'][head][val]
  29.             # 加1处理
  30.             head_val_proba += 1
  31.             # 临时保存
  32.             tempor[head_num] = head_val_proba
  33.         # 对数据log处理并求和保存
  34.         temp = np.log(tempor).sum()
  35.         judge[temp] = end
  36.     # 提取后验概率较大的值
  37.     judge_max = np.max(list(judge.keys()))
  38.     # 保存预测结果
  39.     new[val_num] = judge[judge_max]
  41. # 将预测结果添加到数据表新列
  42. dataSheet['new'] = new
  43. # 预测正确的数量
  44. rate = dataSheet[dataSheet[header[-1]] == dataSheet['new']].shape[0]
  45. # 打印数据表
  46. print(dataSheet)
  47. # 准确率
  48. print('准确率: {rate:.7f}%'.format(rate=100 * rate / length))

完整代码

  1. import json
  2. import numpy as np
  3. import pandas as pd
  5. # 导入数据/生成数据表
  6. dataSheet = pd.read_csv("E:\\Data\\西瓜\\123.csv", encoding="utf-8")
  7. # print(dataSheet)
  8. # 预数据
  9. data_proba = {}
  10. # 标签/列名称
  11. header = dataSheet.columns
  12. # 案例个数/行数
  13. length = dataSheet.shape[0]
  14. # 数据表值
  15. values = dataSheet.values
  16. # 最后一列的不重复数据
  17. end_unique = dataSheet[header[-1]].unique()
  18. # 遍历
  19. for end in end_unique:
  20.     # [header[-1]==end]时end出现的次数
  21.     end_sum = dataSheet[dataSheet[header[-1]].isin([end])].shape[0]
  22.     # [header[-1]==end]时end出现的频率
  23.     end_proba = dataSheet[dataSheet[header[-1]].isin([end])].shape[0] / length
  24.     # 预保存
  25.     data_proba[end] = {'proba': end_proba, 'data': {}}
  26.     # 遍历标签/列名称
  27.     for head in header[:-1]:
  28.         # 初始化
  29.         data_proba[end]['data'][head] = {}
  30.         # 该标签/名称下不重复值
  31.         head_unique = dataSheet[head].unique()
  32.         # 遍历属性
  33.         for head_val in head_unique:
  34.             # [header[-1]==end]时head_val出现的次数
  35.             head_val_sum = dataSheet[dataSheet[head].isin([head_val]) & dataSheet[header[-1]].isin([end])].shape[0]
  36.             # [header[-1]==end]时head_val出现的频率
  37.             head_val_proba = head_val_sum / end_sum
  38.             # 预保存
  39.             data_proba[end]['data'][head][head_val] = head_val_proba
  42. # 打印结果
  43. # print(json.dumps(data_proba, indent=4, ensure_ascii=False))
  45. # 创建一个存放判断结果的数组
  46. new = np.empty((length, 1), str)
  48. # 遍历values的每一行
  49. for val_num in np.arange(length):
  50.     judge = {}
  51.     # 遍历最后一列不重复数据
  52.     for end in end_unique:
  53.         # 标签/列名称除最后一列的数量
  54.         header_sum = len(header[:-1])
  55.         # 创建一个临时存放数据的数组
  56.         tempor = np.empty(header_sum + 1, float)
  57.         # 最后一个标签/列名称的属性对应的先验概率
  58.         end_proba = data_proba[end]['proba']
  59.         # 加1处理
  60.         end_proba += 1
  61.         # 临时保存
  62.         tempor[-1] = end_proba
  63.         # 遍历除最后一行的标签/列名称
  64.         for head_num in np.arange(header_sum):
  65.             # 标签/列名称
  66.             head = header[head_num]
  67.             # 该标签/列名称下的属性
  68.             val = values[val_num][head_num]
  69.             # 属性对应的先验概率
  70.             head_val_proba = data_proba[end]['data'][head][val]
  71.             # 加1处理
  72.             head_val_proba += 1
  73.             # 临时保存
  74.             tempor[head_num] = head_val_proba
  75.         # 对数据log处理并求和保存
  76.         temp = np.log(tempor).sum()
  77.         judge[temp] = end
  78.     # 提取后验概率较大的值
  79.     judge_max = np.max(list(judge.keys()))
  80.     # 保存预测结果
  81.     new[val_num] = judge[judge_max]
  83. # 将预测结果添加到数据表新列
  84. dataSheet['new'] = new
  85. # 预测正确的数量
  86. rate = dataSheet[dataSheet[header[-1]] == dataSheet['new']].shape[0]
  87. # 打印数据表
  88. print(dataSheet)
  89. # 准确率
  90. print('准确率: {rate:.7f}%'.format(rate=100 * rate / length))

未修改代码

  1. import json
  2. import numpy as np
  3. import pandas as pd
  5. dataTrain = pd.read_csv("E:\\Data\\西瓜\\123.csv", encoding="utf-8")
  6. # print(dataTrain)
  7. data = {}
  8. header = dataTrain.columns
  9. length = dataTrain.shape[0]
  10. values = dataTrain.values
  11. for i in dataTrain[header[-1]].unique():
  12.     data[i] = {'proba': dataTrain[dataTrain[header[-1]].isin([i])].shape[0] / length, 'data': {}}
  13.     for j in header[:-1]:
  14.         data[i]['data'][j] = {}
  15.         for n in dataTrain[j].unique():
  16.             data[i]['data'][j][n] = \
  17.                 dataTrain[dataTrain[j].isin([n]) & dataTrain[header[-1]].isin([i])].shape[0] / \
  18.                 dataTrain[dataTrain[header[-1]].isin([i])].shape[0]
  20. # print(json.dumps(data, indent=4, ensure_ascii=False))
  22. r = np.empty((length, 1), str)
  23. for v in np.arange(values.shape[0]):
  24.     a_l = {}
  25.     for i in dataTrain[header[-1]].unique():
  26.         a = np.log([data[i]['data'][header[j]][values[v][j]] + 1
  27.                     for j in np.arange(len(header[:-1]))]).sum()
  28.         a_l[a + np.log(data[i]['proba']+1)] = i
  29.     r[v] = a_l[np.max(list(a_l.keys()))]
  31. dataTrain['new'] = r
  32. rate = dataTrain[dataTrain[header[-1]] == dataTrain['new']].shape[0]
  33. print('准确率: {rate:.7f}%'.format(rate=100 * rate / length))

注意事项

1、根据数据预测正确率为88.24%

2、没有弄数据错误的处理，需要自行优化

python环境

电脑：Windows10

python：3.10.4