【人工智能课程实验】 - 利用贝叶斯分类器实现手写数字的识别

读入数据与预处理

因为老师给的文件无法直接读取，故从官网导入数据：

官网链接：http://www.cs.nyu.edu/~roweis/data.html

导入数据之后要对MATLAB文件进行读入：

data=sio.loadmat(trainfile)

对文件type一下：

type(data)
Out[118]: dict

将data中的train部分，完全复制到tr中：

for i in range(10) :trstr.append('train'+str(i))
for i in range():print(trstr[i])tr = dict.fromkeys(trstr)
for i in range(10):tr[trstr[i]]=data[trstr[i]]

将其中一个小图像赋值给tmp，进行如下练习操作：

输出一下第一张“0”的图像：

tmp = tr[trstr[0]][0]
tmp = tmp.reshape(28,28)
im = Image.fromarray(tmp)
plt.imshow(im)
plt.show()'''
plt.figure("Image") # 图像窗口名称
plt.imshow(tmp)
plt.axis('on') # 关掉坐标轴为 off
plt.title('image') # 图像题目
plt.show()
'''

图像输出如下：

运行如下代码：

tmp = tmp.reshape(14,2*28)
im = Image.fromarray(tmp)
plt.imshow(im)
plt.show()

则输出图像如下：（可以思考一下原因，为什么会出现了两个零，而不是被拉宽了的一个零）

答：模拟一下输出像素点的过程不难发现，相当于左右两侧的图像几乎是一样的像素点，所以输出的图像应该是大致相同的。

进行01二值化：

tmp = tr[trstr[0]][0].copy()
tmp = tmp.reshape(28*28)
for i in range(tmp.size) :if tmp[i] > 10 :tmp[i] = 1else :tmp[i] = 0tmp = tmp.reshape(28,28)im = Image.fromarray(np.uint8(tmp))
plt.imshow(im)

（ps：注意输出图像的时候，传入的参数需要是unsigned int类型的，不然有可能输出的图像是一种颜色的。）

定义一个数组out来进行降维（将28*28的图像降维到7*7）

out=np.zeros((7,7))
tmp=tmp.reshape(28,28)for i in range(7) :for j in range(7) :out[i][j] = np.sum(tmp[i*4:i*4+4,j*4:j*4+4])
print(out.size)
print(out.shape)
for i in range(7):for j in range(7):if(out[i][j] > 5) :out[i][j]=1else :out[i][j]=0
im = Image.fromarray(np.uint8(out))
plt.imshow(im)
plt.show()

输出的图像如下：

对单幅图像的操作练习到此结束了。接下来是对原训练集的二值化和降维。

将训练集字典dict进行二值化和降维：

先建立字典：

tr = dict.fromkeys(trstr)
jwtr = dict.fromkeys(trstr)
for i in range(10):#处理测试集tr[trstr[i]]=data[trstr[i]].copy()jwtr[trstr[i]] = np.zeros((data[trstr[i]].shape[0],7,7))

进行二值化：

for i in range(10):# 枚举所有数字print(i)for j in range(tr[trstr[i]].shape[0]): # 枚举所有行for k in range(28*28):if(tr[trstr[i]][j][k] > 0):tr[trstr[i]][j][k] = 1

将字典的值（不是键值key哈，是指值value，这里的值是个目前是二维数组）更改为三维数组，即将784分为28*28

for i in range(10):# 枚举所有数字tr[trstr[i]] = tr[trstr[i]].reshape(tr[trstr[i]].shape[0],28,28)
#    错误写法！
#    for j in range(tr[trstr[i]].shape[0]): # 枚举所有行                
#        tr[trstr[i]][j] = tr[trstr[i]][j].reshape(28,28)

注意这里不能像注释的这样写！因为他是整个的数组，需要保持形状一致，所以不能只更改第一维取某一个值的时候的第二维。也就是你可以对字典的某一个键，修改对应的value，但是不能对数组的某一维的某一个值，去修改其他维度，要改就整个数组都改。

↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑至此，得到了训练集的所有数字的所有行的28*28的矩阵。↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑

下面处理得到对应的降维矩阵：

for i in range(10):# 枚举所有数字for j in range(tr[trstr[i]].shape[0]):# 枚举所有行(此时每一行是28*28的二值化矩阵)for k in range(7):for kk in range(7):jwtr[trstr[i]][j][k][kk] = np.sum(tr[trstr[i]][j][k*4:k*4+4,kk*4:kk*4+4])if(jwtr[trstr[i]][j][k][kk] > 5):jwtr[trstr[i]][j][k][kk]=1else:jwtr[trstr[i]][j][k][kk]=0jwtr[trstr[i]] = jwtr[trstr[i]].reshape((tr[trstr[i]].shape[0],49))

处理得到先验概率：

P = np.zeros(10,dtype = float)
Nsum = 0
for i in range(10):Nsum += tr[trstr[i]].shape[0]for i in range(10):P[i] = tr[trstr[i]].shape[0]/Nsum
PP = np.zeros((49,10),dtype = float)
for i in range(49):for j in range(10):PP[i][j] = (sum(jwtr[trstr[j]][0:jwtr[trstr[j]].shape[0],i:i+1])+1)/(jwtr[trstr[j]].shape[0]+2)

↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑至此，PP[i][j]代表第i个特征，组成的数字为j的概率 ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑

也就是我们训练出了一个二维矩阵，接下来要用这个矩阵来预测验证集了。

首先处理一下验证集:

test_str = [] # 验证集
for i in range(10) :test_str.append('test'+str(i))
test_image = dict.fromkeys(test_str)
jw_test_image = dict.fromkeys(test_str)
for i in range(10):#处理验证集test_image[test_str[i]] = data[test_str[i]].copy()jw_test_image[test_str[i]] = np.zeros((data[test_str[i]].shape[0],7,7))

接下来的01二值化和降维的过程和训练集一致：

for i in range(10):# 枚举所有数字print(i)for j in range(test_image[test_str[i]].shape[0]): # 枚举所有行for k in range(28*28):if(test_image[test_str[i]][j][k] > 0):test_image[test_str[i]][j][k] = 1
for i in range(10):# 枚举所有数字test_image[test_str[i]] = test_image[test_str[i]].reshape(test_image[test_str[i]].shape[0],28,28)for i in range(10):# 枚举所有数字for j in range(test_image[test_str[i]].shape[0]):# 枚举所有行(此时每一行是28*28的二值化矩阵)for k in range(7):for kk in range(7):jw_test_image[test_str[i]][j][k][kk] = np.sum(test_image[test_str[i]][j][k*4:k*4+4,kk*4:kk*4+4])if(jw_test_image[test_str[i]][j][k][kk] > 5):jw_test_image[test_str[i]][j][k][kk]=1else:jw_test_image[test_str[i]][j][k][kk]=0jw_test_image[test_str[i]] = jw_test_image[test_str[i]].reshape((test_image[test_str[i]].shape[0],49))

↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑至此，我们将原始验证集处理成降维二值化矩阵jw_test_image字典 ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑

备份一份给操作数组

opr_test_image = dict.fromkeys(test_str)
for i in range(10):opr_test_image[test_str[i]] = jw_test_image[test_str[i]].copy()

↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑至此，我们接下来的操作矩阵就是opr_test_image字典 ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑

利用贝叶斯公式求后验概率，并进行预测，概率最大的值对应的数字就是通过PP矩阵预测得到的数字。

注意两点：

①根据贝叶斯公式，发现分母均为同样的正值，由于我们这里只需要关注值之间的大小关系，所以不需要计算分母，只需要比较分子即可。

②因为引用的是numpy包，所以每一个元素都是float类型，所以不能直接相乘，精度不够。但是由于我们这里只需要关注值之间的大小关系，所以可以取个log变成加法运算，保证了大小关系。

Phou = np.ones(10,dtype =float) # 后验概率初始数组
ans = np.zeros(10,dtype =float)
for dig in range(10):for col in range(opr_test_image[test_str[dig]].shape[0]):tmp = opr_test_image[test_str[dig]][col] #得到49个参数Phou = np.zeros(10,dtype =float) # 后验概率初始数组    for i in range(49):for j in range(10):if(tmp[i] != 0): # 若为1Phou[j] = Phou[j]+np.log(PP[i][j])else :Phou[j] = Phou[j]+np.log((1-PP[i][j]))for j in range(10): # 枚举每一个数字Phou[j] = Phou[j] * P[j]if(dig == np.argmax(Phou)):ans[dig] = ans[dig]+1
#    print(ans[dig])ans[dig] = ans[dig] / opr_test_image[test_str[dig]].shape[0]print("数字%d: "%(dig))print(ans[dig])

输出结果：

数字0: 
0.8306122448979592
数字1: 
0.9092511013215859
数字2: 
0.685077519379845
数字3: 
0.6514851485148515
数字4: 
0.6924643584521385
数字5: 
0.7365470852017937
数字6: 
0.7494780793319415
数字7: 
0.7334630350194552
数字8: 
0.6098562628336756
数字9: 
0.7205153617443013np.mean(ans)
Out[205]: 0.7318750196697547

完整代码：

trainfile = "C:\\Users\\...\\mnist_all"import numpy as np
import pandas as pd
import scipy.io as sio
from matplotlib import pyplot as plt
from PIL import Image# df = pd.DataFrame(pd.read_csv(train_data,header=1)'''
data=sio.loadmat(trainfile)
trstr = []
jwtr = []
test_str = [] # 验证集
for i in range(10) :trstr.append('train'+str(i))
for i in range(10) :test_str.append('test'+str(i))tr = dict.fromkeys(trstr)
jwtr = dict.fromkeys(trstr)test_image = dict.fromkeys(test_str)
jw_test_image = dict.fromkeys(test_str)
for i in range(10):#处理测试集tr[trstr[i]]=data[trstr[i]].copy()jwtr[trstr[i]] = np.zeros((data[trstr[i]].shape[0],7,7))#处理验证集test_image[test_str[i]] = data[test_str[i]].copy()jw_test_image[test_str[i]] = np.zeros((data[test_str[i]].shape[0],7,7))'''for i in range(10):# 枚举所有数字print(i)for j in range(tr[trstr[i]].shape[0]): # 枚举所有行for k in range(28*28):if(tr[trstr[i]][j][k] > 0):tr[trstr[i]][j][k] = 1for i in range(10):# 枚举所有数字tr[trstr[i]] = tr[trstr[i]].reshape(tr[trstr[i]].shape[0],28,28)
#    错误写法！
#    for j in range(tr[trstr[i]].shape[0]): # 枚举所有行                
#        tr[trstr[i]][j] = tr[trstr[i]][j].reshape(28,28)'''
↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑至此，得到了训练集的所有数字的所有行的28*28的矩阵。↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑
'''for i in range(10):# 枚举所有数字for j in range(tr[trstr[i]].shape[0]):# 枚举所有行(此时每一行是28*28的二值化矩阵)for k in range(7):for kk in range(7):jwtr[trstr[i]][j][k][kk] = np.sum(tr[trstr[i]][j][k*4:k*4+4,kk*4:kk*4+4])if(jwtr[trstr[i]][j][k][kk] > 5):jwtr[trstr[i]][j][k][kk]=1else:jwtr[trstr[i]][j][k][kk]=0jwtr[trstr[i]] = jwtr[trstr[i]].reshape((tr[trstr[i]].shape[0],49))P = np.zeros(10,dtype = float)
Nsum = 0
for i in range(10):Nsum += tr[trstr[i]].shape[0]for i in range(10):P[i] = tr[trstr[i]].shape[0]/Nsum
PP = np.zeros((49,10),dtype = float)
for i in range(49):for j in range(10):PP[i][j] = (sum(jwtr[trstr[j]][0:jwtr[trstr[j]].shape[0],i:i+1])+1)/(jwtr[trstr[j]].shape[0]+2)'''
至此，PP[i][j]代表第i个特征，组成的数字为j的概率
'''# 处理验证集       for i in range(10):# 枚举所有数字print(i)for j in range(test_image[test_str[i]].shape[0]): # 枚举所有行for k in range(28*28):if(test_image[test_str[i]][j][k] > 0):test_image[test_str[i]][j][k] = 1
for i in range(10):# 枚举所有数字test_image[test_str[i]] = test_image[test_str[i]].reshape(test_image[test_str[i]].shape[0],28,28)for i in range(10):# 枚举所有数字for j in range(test_image[test_str[i]].shape[0]):# 枚举所有行(此时每一行是28*28的二值化矩阵)for k in range(7):for kk in range(7):jw_test_image[test_str[i]][j][k][kk] = np.sum(test_image[test_str[i]][j][k*4:k*4+4,kk*4:kk*4+4])if(jw_test_image[test_str[i]][j][k][kk] > 5):jw_test_image[test_str[i]][j][k][kk]=1else:jw_test_image[test_str[i]][j][k][kk]=0jw_test_image[test_str[i]] = jw_test_image[test_str[i]].reshape((test_image[test_str[i]].shape[0],49))#得到二值化降维矩阵   jw_test_image'''
接下来，将降维矩阵赋值给操作数组
'''opr_test_image = dict.fromkeys(test_str)
for i in range(10):opr_test_image[test_str[i]] = jw_test_image[test_str[i]].copy()#得到操作数组  opr_test_imagePhou = np.ones(10,dtype =float) # 后验概率初始数组
ans = np.zeros(10,dtype =float)
for dig in range(10):for col in range(opr_test_image[test_str[dig]].shape[0]):tmp = opr_test_image[test_str[dig]][col] #得到49个参数Phou = np.zeros(10,dtype =float) # 后验概率初始数组    for i in range(49):for j in range(10):if(tmp[i] != 0): # 若为1Phou[j] = Phou[j]+np.log(PP[i][j])else :Phou[j] = Phou[j]+np.log((1-PP[i][j]))for j in range(10): # 枚举每一个数字Phou[j] = Phou[j] * P[j]if(dig == np.argmax(Phou)):ans[dig] = ans[dig]+1
#    print(ans[dig])ans[dig] = ans[dig] / opr_test_image[test_str[dig]].shape[0]print("数字%d: "%(dig))print(ans[dig])'''
下面是对测试集的一个图像的处理样例：''''''
tmp = tr[trstr[0]][0].copy()
tmp = tmp.reshape(28,28)
im = Image.fromarray(tmp)
plt.imshow(im)plt.figure("Image") # 图像窗口名称
plt.imshow(tmp)
plt.axis('on') # 关掉坐标轴为 off
plt.title('image') # 图像题目
plt.show()
''' '''
tmp = tr[trstr[0]][0].copy()
tmp = tmp.reshape(28*28)
for i in range(tmp.size) :if tmp[i] > 10 :tmp[i] = 1else :tmp[i] = 0tmp = tmp.reshape(28,28)im = Image.fromarray(np.uint8(tmp))
plt.imshow(im)
''''''
out=np.zeros((7,7))
tmp=tmp.reshape(28,28)for i in range(7) :for j in range(7) :out[i][j] = np.sum(tmp[i*4:i*4+4,j*4:j*4+4])
print(out.size)
print(out.shape)
for i in range(7):for j in range(7):if(out[i][j] > 5) :out[i][j]=1else :out[i][j]=0
im = Image.fromarray(np.uint8(out))
plt.imshow(im)
plt.show()
'''

update：(20191201)

发现对于降维到7*7的矩阵，可以做到平均73%的准确率。那么思考降维到14*14的矩阵，保留的特征会更多一些，那么准确率会不会更高一些呢？于是继续写了下面的代码（其实是在上面这个代码上进行了增加，并没有改变原来的东西，也就是说下面这个代码和上面这个代码有很多重复的地方，在注释中也有标注）

实验结果：（为了防止放到下面看不到，这里就放到上面一起写了）

平均预测率为75%左右，也就是说虽然参数变多了，但是预测率的提升并不明显。

#  -*- coding: utf-8 -*-
"""
Spyder EditorThis is a temporary script file.
"""trainfile = "D:\\mystudy\\大三上学期作业\\人工智能\\数字识别相关\\mnist_all"
import numpy as np
import pandas as pd
import scipy.io as sio
from matplotlib import pyplot as plt
from PIL import Image
from pylab import *# df = pd.DataFrame(pd.read_csv(train_data,header=1)'''
data=sio.loadmat(trainfile)
trstr = []
jwtr = []
test_str = [] # 验证集
for i in range(10) :trstr.append('train'+str(i))
for i in range(10) :test_str.append('test'+str(i))tr = dict.fromkeys(trstr)
jwtr = dict.fromkeys(trstr)test_image = dict.fromkeys(test_str)
jw_test_image = dict.fromkeys(test_str)
for i in range(10):#处理测试集tr[trstr[i]]=data[trstr[i]].copy()jwtr[trstr[i]] = np.zeros((data[trstr[i]].shape[0],7,7))#处理验证集test_image[test_str[i]] = data[test_str[i]].copy()jw_test_image[test_str[i]] = np.zeros((data[test_str[i]].shape[0],7,7))'''for i in range(10):# 枚举所有数字print(i)for j in range(tr[trstr[i]].shape[0]): # 枚举所有行for k in range(28*28):if(tr[trstr[i]][j][k] > 0):tr[trstr[i]][j][k] = 1for i in range(10):# 枚举所有数字tr[trstr[i]] = tr[trstr[i]].reshape(tr[trstr[i]].shape[0],28,28)
#    错误写法！
#    for j in range(tr[trstr[i]].shape[0]): # 枚举所有行                
#        tr[trstr[i]][j] = tr[trstr[i]][j].reshape(28,28)'''
↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑至此，得到了训练集的所有数字的所有行的28*28的矩阵。↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑
'''for i in range(10):# 枚举所有数字for j in range(tr[trstr[i]].shape[0]):# 枚举所有行(此时每一行是28*28的二值化矩阵)for k in range(7):for kk in range(7):jwtr[trstr[i]][j][k][kk] = np.sum(tr[trstr[i]][j][k*4:k*4+4,kk*4:kk*4+4])if(jwtr[trstr[i]][j][k][kk] > 5):jwtr[trstr[i]][j][k][kk]=1else:jwtr[trstr[i]][j][k][kk]=0jwtr[trstr[i]] = jwtr[trstr[i]].reshape((tr[trstr[i]].shape[0],49))P = np.zeros(10,dtype = float)
Nsum = 0
for i in range(10):Nsum += tr[trstr[i]].shape[0]for i in range(10):P[i] = tr[trstr[i]].shape[0]/Nsum
PP = np.zeros((49,10),dtype = float)
for i in range(49):for j in range(10):PP[i][j] = (sum(jwtr[trstr[j]][0:jwtr[trstr[j]].shape[0],i:i+1])+1)/(jwtr[trstr[j]].shape[0]+2)'''
至此，PP[i][j]代表第i个特征，组成的数字为j的概率
'''# 处理验证集       for i in range(10):# 枚举所有数字print(i)for j in range(test_image[test_str[i]].shape[0]): # 枚举所有行for k in range(28*28):if(test_image[test_str[i]][j][k] > 0):test_image[test_str[i]][j][k] = 1
for i in range(10):# 枚举所有数字test_image[test_str[i]] = test_image[test_str[i]].reshape(test_image[test_str[i]].shape[0],28,28)for i in range(10):# 枚举所有数字for j in range(test_image[test_str[i]].shape[0]):# 枚举所有行(此时每一行是28*28的二值化矩阵)for k in range(7):for kk in range(7):jw_test_image[test_str[i]][j][k][kk] = np.sum(test_image[test_str[i]][j][k*4:k*4+4,kk*4:kk*4+4])if(jw_test_image[test_str[i]][j][k][kk] > 5):jw_test_image[test_str[i]][j][k][kk]=1else:jw_test_image[test_str[i]][j][k][kk]=0jw_test_image[test_str[i]] = jw_test_image[test_str[i]].reshape((test_image[test_str[i]].shape[0],49))#得到二值化降维矩阵   jw_test_image'''
接下来，将降维矩阵赋值给操作数组
'''opr_test_image = dict.fromkeys(test_str)
for i in range(10):opr_test_image[test_str[i]] = jw_test_image[test_str[i]].copy()#得到操作数组  opr_test_imagePhou = np.ones(10,dtype =float) # 后验概率初始数组
ans = np.zeros(10,dtype =float)
for dig in range(10):for col in range(opr_test_image[test_str[dig]].shape[0]):tmp = opr_test_image[test_str[dig]][col] #得到49个参数Phou = np.zeros(10,dtype =float) # 后验概率初始数组    for i in range(49):for j in range(10):if(tmp[i] != 0): # 若为1Phou[j] = Phou[j]+np.log(PP[i][j])else :Phou[j] = Phou[j]+np.log((1-PP[i][j]))for j in range(10): # 枚举每一个数字Phou[j] = Phou[j] * P[j]if(dig == np.argmax(Phou)):ans[dig] = ans[dig]+1
#    print(ans[dig])ans[dig] = ans[dig] / opr_test_image[test_str[dig]].shape[0]print("数字%d: "%(dig))print(ans[dig])print(np.mean(ans))'''
↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓降维到14*14的答案↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓
'''    for i in range(10):
#    test_image[test_str[i]] = data[test_str[i]].copy()#处理测试集jwtr[trstr[i]] = np.zeros((data[trstr[i]].shape[0],14,14))#处理验证集jw_test_image[test_str[i]] = np.zeros((data[test_str[i]].shape[0],14,14))for i in range(10):# 枚举所有数字print(i)for j in range(tr[trstr[i]].shape[0]):# 枚举所有行(此时每一行是28*28的二值化矩阵)for k in range(14):for kk in range(14):jwtr[trstr[i]][j][k][kk] = np.sum(tr[trstr[i]][j][k*2:k*2+2,kk*2:kk*2+2])if(jwtr[trstr[i]][j][k][kk] > 2):jwtr[trstr[i]][j][k][kk]=1else:jwtr[trstr[i]][j][k][kk]=0jwtr[trstr[i]] = jwtr[trstr[i]].reshape((tr[trstr[i]].shape[0],14*14))P = np.zeros(10,dtype = float)
Nsum = 0
for i in range(10):Nsum += tr[trstr[i]].shape[0]for i in range(10):P[i] = tr[trstr[i]].shape[0]/Nsum
PP = np.zeros((14*14,10),dtype = float)
for i in range(14*14):for j in range(10):PP[i][j] = (sum(jwtr[trstr[j]][0:jwtr[trstr[j]].shape[0],i:i+1])+1)/(jwtr[trstr[j]].shape[0]+2)'''
至此，PP[i][j]代表第i个特征，组成的数字为j的概率
'''# 处理验证集       for i in range(10):# 枚举所有数字print(i)for j in range(test_image[test_str[i]].shape[0]): # 枚举所有行for k in range(28*28):if(test_image[test_str[i]][j][k] > 0):test_image[test_str[i]][j][k] = 1
for i in range(10):# 枚举所有数字test_image[test_str[i]] = test_image[test_str[i]].reshape(test_image[test_str[i]].shape[0],28,28)for i in range(10):# 枚举所有数字for j in range(test_image[test_str[i]].shape[0]):# 枚举所有行(此时每一行是28*28的二值化矩阵)for k in range(14):for kk in range(14):jw_test_image[test_str[i]][j][k][kk] = np.sum(test_image[test_str[i]][j][k*2:k*2+2,kk*2:kk*2+2])if(jw_test_image[test_str[i]][j][k][kk] > 2):#注意这里也要修改！！！jw_test_image[test_str[i]][j][k][kk]=1else:jw_test_image[test_str[i]][j][k][kk]=0
for i in range(10): jw_test_image[test_str[i]] = jw_test_image[test_str[i]].reshape((test_image[test_str[i]].shape[0],14*14))#得到二值化降维矩阵   jw_test_image'''
接下来，将降维矩阵赋值给操作数组
'''opr_test_image = dict.fromkeys(test_str)
for i in range(10):opr_test_image[test_str[i]] = jw_test_image[test_str[i]].copy()#得到操作数组  opr_test_imagePhou = np.zeros(10,dtype =float) # 后验概率初始数组
ans = np.zeros(10,dtype =float)
for dig in range(10):for col in range(opr_test_image[test_str[dig]].shape[0]):tmp = opr_test_image[test_str[dig]][col] #得到14*14个参数Phou = np.zeros(10,dtype =float) # 后验概率初始数组    for i in range(14*14):for j in range(10):if(tmp[i] != 0): # 若为1Phou[j] = Phou[j]+np.log(PP[i][j])else :Phou[j] = Phou[j]+np.log((1-PP[i][j]))for j in range(10): # 枚举每一个数字Phou[j] = Phou[j] * P[j]if(dig == np.argmax(Phou)):ans[dig] = ans[dig]+1
#    print(ans[dig])ans[dig] = ans[dig] / opr_test_image[test_str[dig]].shape[0]print("数字%d: "%(dig))print(ans[dig])print(np.mean(ans))    for dig in range(10):im = Image.fromarray(np.uint8(opr_test_image[test_str[dig]][0].reshape(14,14)))plt.imshow(im)plt.show()'''
↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑降维到14*14的答案↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑
'''   '''
输出准确率图像：
'''  
def autolabel(rects):for rect in rects:height = rect.get_height()plt.text(rect.get_x()+rect.get_width()/2.- 0.2, 1.03*height, '%.2f' % (height))name_list = ['0', '1', '2', '3', '4', '5', '6', '7','8','9',]
num_list = [0.8306122448979592,0.9092511013215859,0.685077519379845,0.6514851485148515,0.6924643584521385,0.7365470852017937,0.7494780793319415,0.7334630350194552,0.6098562628336756,0.7205153617443013]
autolabel(plt.bar(range(len(num_list)), num_list, color='rgb', tick_label=name_list))
plt.show()'''
下面是对测试集的一个图像的处理样例：''''''
tmp = tr[trstr[0]][0].copy()
tmp = tmp.reshape(28,28)
im = Image.fromarray(tmp)
plt.imshow(im)plt.figure("Image") # 图像窗口名称
plt.imshow(tmp)
plt.axis('on') # 关掉坐标轴为 off
plt.title('image') # 图像题目
plt.show()
''' '''
tmp = tr[trstr[0]][0].copy()
tmp = tmp.reshape(28*28)
for i in range(tmp.size) :if tmp[i] > 10 :tmp[i] = 1else :tmp[i] = 0tmp = tmp.reshape(28,28)im = Image.fromarray(np.uint8(tmp))
plt.imshow(im)
''''''
out=np.zeros((7,7))
tmp=tmp.reshape(28,28)for i in range(7) :for j in range(7) :out[i][j] = np.sum(tmp[i*4:i*4+4,j*4:j*4+4])
print(out.size)
print(out.shape)
for i in range(7):for j in range(7):if(out[i][j] > 5) :out[i][j]=1else :out[i][j]=0
im = Image.fromarray(np.uint8(out))
plt.imshow(im)
plt.show()
''''''
dd = pd.date_range(end = '20191115',periods = 6,)
print(dd)
df1=pd.DataFrame({"id":[1001,1002,1003,1004,1005,1006,1007,1008], 
"gender":['male','female','male','female','male','female','male','female'],
"pay":['Y','N','Y','Y','N','Y','N','Y',],
"m-point":[10,12,20,40,40,40,30,20]})
print(df1)
'''