Python ：MNIST手写数据集识别 + 手写板程序 最详细，直接放心，大胆地抄！跑不通找我，我包教！

目录

一、背景与总概

二、研究对象

三、数据表示与结构

四、选择的模型

五、效果展示 

六、画板部分

七、直接抄，直接方向跑！

---

所有的工程文件百度云连接，包含模型！

链接：https://pan.baidu.com/s/1RlS0aVPOFwmNBPBHmcF0SQ 
提取码：MATR 
--来自百度网盘超级会员V3的分享

注意：人工智能预测的闪退问题是在main文件同目录下没有image_rgzn的文件夹，添加就好。

一、背景与总概

        利用Python语言编写和调试一个识别手写数字图像的三层深度前馈网络，包括数据预处理，网络模型构建，模型参数初始化和正向推理，反向梯度下降参数寻优，最后模型预测的功能。目的是学会基本的深度网络模型建立、训练和推理过程，理解深度网络的实现原理。

        通过自己学习人工智能之后，发现了三个的重要经验和总结，第一个是你对你研究事物本质的理解；第二个是，将你研究事物进行数据化，找到一个合理的数据表示以及数据的结构；第三个是，寻找与这个数据表示的形式和结构合适的“模型”（即模型算法等）。依据上面数据到模型的这个思路，对下文进行一个描写

        首先，介绍一下MNIST手写数据集，这就是我们研究的事物了。该数据集包含60,000个用于训练的示例和10,000个用于测试的示例。数据集包含了0-9共10类手写数字图片,每张图片都做了尺寸归一化，都是28x28大小的灰度图。

训练集图像：train-images-idx3-ubyte.gz（9.9MB，包含60000个样本）
训练集标签：train-labels-idx1-ubyte.gz（29KB，包含60000个标签）
测试集图像：t10k-images-idx3-ubyte.gz（1.6MB，包含10000个样本）
测试集标签：t10k-labels-idx1-ubyte.gz（5KB，包含10000个标签）

下图展示一些具体例子：

        其次是手写板程序，在PyQt5实例 画板小程序_pyqt5画图板_CreatorGG的博客-CSDN博客的程序基础之上添加了，1人工智能预测，2预测结果展示的文本框。

        传统机器学习的问题与缺陷随着深度学习的发展被得到解决，深度学习也可以说是神经网络的重命名，他是建立在多层非线性的神经网络结构之上，对数据表示进行抽象的一系列机器学习。深度学习的出现使得图像，语言得到突破性的发展。本此处理的数据为图像，所以最后我本次选用的模型是人工智能深度神经网络（一般的神经网络）。你也可以使用卷积神经网络模型，卷积神经网络是对将局部的特征十分的敏感，正确率会更高。

二、研究对象

        在你的PycharmIDE里创建一个function.py的文件，在里面定义如下函数：

         1：jiexi_image（path），此函数需要一个字符串对象的输入，是两个训练集和测试集的图像文件地址，返回的对象是一个numpy.array的对象。

1. def jiexi_image(path):
2. # 用二进制读取
3. data = open(path, 'rb').read()
4. offset = 0
5. fmt_header = '>iiii'
6. magic_number, num_images, num_rows, num_cols = struct.unpack_from(fmt_header, data, offset)
7. print('魔数:%d, 图片数量: %d张, 图片大小: %d*%d' % (magic_number, num_images, num_rows, num_cols))
8. image_size = num_rows * num_cols
9. offset += struct.calcsize(fmt_header)
10. fmt_image = '>' + str(image_size) + 'B'
11. images = np.empty((num_images, num_rows, num_cols))
12. for i in range(num_images):
13. if (i + 1) % 10000 == 0:
14. print('已解析 %d' % (i + 1) + '张')
15. images[i] = np.array(struct.unpack_from(fmt_image, data, offset)).reshape((num_rows, num_cols))
16. offset += struct.calcsize(fmt_image)
17. return images

        2： jiexi_label(path) ，传入参数是训练集和测试集的两个label标签文件地址，是一个字符串对象，返回的也是一个numpy.array的对象。

1. def jiexi_label(path):
2. data = open(path, 'rb').read()
3. offset = 0
4. fmt_header = '>ii'
5. magic_number, num_images = struct.unpack_from(fmt_header, data, offset)
6. print('魔数:%d, 图片数量: %d张' % (magic_number, num_images))
7. # 解析数据集
8. offset += struct.calcsize(fmt_header)
9. fmt_image = '>B'
10. labels = np.empty(num_images)
11. for i in range(num_images):
12. if (i + 1) % 10000 == 0:
13. print('已解析 %d' % (i + 1) + '张')
14. labels[i] = struct.unpack_from(fmt_image, data, offset)[0]
15. offset += struct.calcsize(fmt_image)
16. return labels

        3：plot_data(images,labels,n,issave = False)，传入图像，image是一个numpy.array对象；传入的标签，labels是一个numpy.array对象；传入的issave是一个判断逻辑值，如果是真就保存图片，但是一般是不保存的。

1. def plot_data(images,labels,n,issave = False):
2. for i in range(n):
3. print(labels[i])
4. plt.imshow(images[i], cmap='gray')
5. plt.show()
6. # if(issave == True):
7. # plt.savefig(fname = "save"+str(datetime.datetime.now())+".jpg")
8. print('done')

         接下来在你的工程文件夹下建立一个train.py 文件，在里面利用function.py里你设定的函数来解析训练集图像和测试集图像，训练集标签和测试集标签，然后利用plot_data函数打印数据，查看是否对应。

1. import function
2. #start1 = time.time()
3. train_image_path = './MNIST/train-images-idx3-ubyte/train-images.idx3-ubyte'
4. train_lable_path = './MNIST/train-labels-idx1-ubyte/train-labels.idx1-ubyte'
5. teat_image_path = './MNIST/t10k-images-idx3-ubyte/t10k-images.idx3-ubyte'
6. teat_lable_path = './MNIST/t10k-labels-idx1-ubyte/t10k-labels.idx1-ubyte'
7. # #加载数据
8. train_image = function.jiexi_image(train_image_path)
9. train_lable = function.jiexi_label(train_lable_path)
10. teat_image = function.jiexi_image(teat_image_path)
11. test_lable = function.jiexi_label(teat_lable_path)
12. # print(train_image.shape)
14. function.plot_data(train_image, train_lable, 10, True)

        最终效果：

                      

        可以看出是正确的。 

三、数据表示与结构

        既然train_image， train_lable， teat_image ， test_lable 是numpy.array对象，那么我们就可以对他进行操作，对他进行打印输出，print（train_image）：

         什么也看不出来，那我们打印一下他的维度来看看， ​​​，是一个三维数组。

        打印train_image[0]来看：

         然后可以推知，我们要处理的对象结构是如下图所示。

四、选择的模型

        传统机器学习的问题与缺陷随着深度学习的发展被得到解决，深度学习也可以说是神经网络的重命名，他是建立在多层非线性的神经网络结构之上，对数据表示进行抽象的一系列机器学习。深度学习的出现使得图像，语言得到突破性的发展。本此处理的数据为图像，所以最后我本次选用的模型是人工智能深度神经网络（一般的神经网络）。你也可以使用卷积神经网络模型，卷积神经网络是对将局部的特征十分的敏感，正确率会更高。

        在你的工程文件下创建一个DeepNET.py的文件，里面是深度神经网络所需要的各种函数。从零开始，从理论到代码实现无论是在研究和学习都是十分有帮助的，希望我和各位读者都保持住这个习惯。

        本次，假设你已经有一定的知识储备了，如梯度下降法的本质，神经网络结构基本清楚，如果不清楚就十分推荐，deeplearning的吴大师的视频教程 [双语字幕]吴恩达深度学习deeplearning.ai_哔哩哔哩_bilibili 教的非常细致。

        第一步，导入库，在DeepNET.py的文件里完善搭建深度神经网络所需要的函数。

        深度神经网络概述，Deep Neural Networks， 深度神经网络，以下简称DNN。DNN里最基本的单元是神经元模型。每个神经元与其他神经元相连，当他“兴奋”时，就会向相连的神经元发送物质，改变神经元的电位。如果某个神经元的电位超过了一个阀值，那么它就会被激活。结果抽象可以得到沿用至今的M_P神经元模型。

        线性部分，是简单的相乘相加，激活部分是利用激活函数处理得到输出。常见的激活函数有sigmoid，relu等，本次采用的激活函数是relu函数。

        由神经元组成的多层神经网络，如图所示。有输入层，输出层以及中间隐含层。每一个输入线性求合，通过激活函数，传到下一个神经元，我们大可不必一个个的去算，我们可以使用向量化来使得我们的程序更加简洁。

        梯度下降法：

 

  

（下面为了简单我以输入的对象是28*28规格图片，第一层隐含单元有200个，第二层隐含单元是100个，输出层为10个的网络结构阐述。）

一般的构造网络的流程：

        初始化超参数（包括启动深度神经网络的权值w，偏执b）--》向前传播（线性部分+激活函数）--》 计算代价 --》 反向传播 （激活函数反向，线性部分反向）--》更新超参数.

基础部分和总概 网络结构为 [28*28 200 100 10]

        学习人工智能，应该理论应用于实践，应该多动手进行数学演算，将演算用代码实现，最后进行总结于改进。

（1）对这个网络的结构要有一个清楚的认识

        在草稿本上进行矩阵维数的测试 

 

下面是对于想要了解代码一个个看清楚流程的去看，如果想直接跑通，代码在最后！

1、导入库，是导入一些必要的库

1. import matplotlib.pyplot as plt
2. import numpy as np
3. import datetime
4. import os
5. import sys
6. import h5py

2、定义所需要的softmax函数

1. def sigmoid(Z):
2. A = 1/(1+np.exp(-Z))
3. cache = Z
4. return A, cache
6. def sigmoid_backward(dA, cache):
7. Z = cache
8. s = 1/(1+np.exp(-Z))
9. dZ = dA * s * (1-s)
10. return dZ
13. # relu函数 和反向求导
14. def relu(Z):
15. A = np.maximum(0,Z)
16. cache = Z
17. return A, cache
19. def relu_backward(dA, cache):
20. Z = cache
21. dZ = np.array(dA, copy=True)
22. dZ[Z <= 0] = 0
23. return dZ
26. # Softmax
27. def softmax(Z):
28. A = np.exp(Z)/np.sum(np.exp(Z),axis=0)
29. cache = Z
30. return A, cache

        在此我把relu和sigmoid函数也给出，方便读者后续的使用，可以利用这个去做逻辑回归啊什么什么的，增加泛用性。

3、初始化参数

        使用梯度下降法的首要步骤就是初始化参数，这个点是随机的。        

        输入的是 layers_dims是一个向量，是你的网络结构。返回的是一个字典对象parameters，里面有超参数w和b。、

        恭喜你，走出了第一步，完成了初始化参数的步骤。

1. def init_W(layers_dims):
2. np.random.seed(3)
3. parameters = {}
4. L = len(layers_dims)
5. for l in range(1, L):
6. parameters["W" + str(l)] = np.random.randn(layers_dims[l], layers_dims[l - 1]) / np.sqrt(layers_dims[l - 1])
7. parameters["b" + str(l)] = np.zeros((layers_dims[l], 1))
8. return parameters

4.1、向前传播之线性部分

        

（2）模型保存情况 h5数据情况

 最终效果

 

         综合来说，没有加优化正确率也是不错的，感兴趣的可以对网络进行优化。

六、画板部分

      这里参考的是(311条消息) PyQt5实例 画板小程序_pyqt5画图板_CreatorGG的博客-CSDN博客

对qtpy5感兴趣的可以去学习一下。

        整个手绘板加训练的程序在最后给出。

七、直接抄，直接方向跑！

训练网络，运行train.py。

训练出自己的网络后，使用main.py运行利用使用你的模型。

文件结构和目录：

         创建我红线的文件。

（1）function.py代码：

1. #此文件是一些函数 有加载数据模块
2. import datetime
3. import struct
4. import numpy as np
5. import matplotlib.pyplot as plt
6. from PIL import Image
7. import os
10. def jiexi_image(path):
11. # 用二进制读取
12. data = open(path, 'rb').read()
13. offset = 0
14. fmt_header = '>iiii'
15. magic_number, num_images, num_rows, num_cols = struct.unpack_from(fmt_header, data, offset)
16. print('魔数:%d, 图片数量: %d张, 图片大小: %d*%d' % (magic_number, num_images, num_rows, num_cols))
17. image_size = num_rows * num_cols
18. offset += struct.calcsize(fmt_header)
19. fmt_image = '>' + str(image_size) + 'B'
20. images = np.empty((num_images, num_rows, num_cols))
21. for i in range(num_images):
22. if (i + 1) % 10000 == 0:
23. print('已解析 %d' % (i + 1) + '张')
24. images[i] = np.array(struct.unpack_from(fmt_image, data, offset)).reshape((num_rows, num_cols))
25. offset += struct.calcsize(fmt_image)
26. return images
28. def jiexi_label(path):
29. data = open(path, 'rb').read()
30. offset = 0
31. fmt_header = '>ii'
32. magic_number, num_images = struct.unpack_from(fmt_header, data, offset)
33. print('魔数:%d, 图片数量: %d张' % (magic_number, num_images))
34. # 解析数据集
35. offset += struct.calcsize(fmt_header)
36. fmt_image = '>B'
37. labels = np.empty(num_images)
38. for i in range(num_images):
39. if (i + 1) % 10000 == 0:
40. print('已解析 %d' % (i + 1) + '张')
41. labels[i] = struct.unpack_from(fmt_image, data, offset)[0]
42. offset += struct.calcsize(fmt_image)
43. return labels
45. def plot_data(images,labels,n,issave = False):
46. for i in range(n):
47. print(labels[i])
48. plt.imshow(images[i], cmap='gray')
49. plt.show()
50. # if(issave == True):
51. # plt.savefig(fname = "save"+str(datetime.datetime.now())+".jpg")
53. print('done')
59. ## 说明：输入原始图像路径和新建图像文件夹名称 默认修改出长度宽度为64*64
60. def stdimage(pathorg, name, pathnew=None, width=64, length=64):
61. # 检查文件是否建立
62. if pathnew == None: # 如果没有手动创建
63. tage = os.path.exists(os.getcwd() + '\\' + name) # 检查一下是否属实
64. if not tage: # 没有整个新文件夹
65. os.mkdir(os.getcwd() + "\\" + name) # 创建文件夹，name
66. image_path = os.getcwd() + "\\" + name + "\\"
67. else: # 已经手动创建
68. tage = os.path.exists(pathnew + "\\" + name)
69. if not tage:
70. path = os.getcwd()
71. os.mkdir(path + "\\" + name)
72. image_path = path + "\\" + name + "\\"
74. ## 开始处理
75. i = 1 # 从一开始
76. list_name = os.listdir(pathorg) # 获取图片名称列表
77. for item in list_name:
78. # 检查是否有图片
79. tage = os.path.exists(pathorg + str(i) + '.png')
80. if not tage:
81. image = Image.open(pathorg + '\\' + item)
82. std = image.resize((width, length), Image.ANTIALIAS)
83. ## 模式为RGB
84. if not std.mode == "RGB":
85. std = std.convert('RGB')
86. std.save(image_path + str(i) + '.png')
87. i += 1
92. def label_init(lable):
93. n = lable.shape[0]
94. label_Y = np.zeros([10, n])
95. res = lable.astype(int)
96. for i in range(0, label_Y.shape[1]):
97. label_Y[res[i], i] = 1
98. return label_Y
103. def get_X(path):
104. im_name_list = os.listdir(path)
105. all_data = []
106. for item in im_name_list:
107. try:
108. all_data.append(plt.imread(path + '\\' + item).tolist())
109. except:
110. print(item + " open error ")
111. return all_data

（2）DeepNet.py

2. import matplotlib.pyplot as plt
3. import numpy as np
4. import datetime
5. import os
6. import sys
7. import h5py
9. # sigmoid
10. def sigmoid(Z):
11. A = 1/(1+np.exp(-Z))
12. cache = Z
13. return A, cache
15. def sigmoid_backward(dA, cache):
16. Z = cache
17. s = 1/(1+np.exp(-Z))
18. dZ = dA * s * (1-s)
19. return dZ
22. # relu函数 和反向求导
23. def relu(Z):
24. A = np.maximum(0,Z)
25. cache = Z
26. return A, cache
28. def relu_backward(dA, cache):
29. Z = cache
30. dZ = np.array(dA, copy=True)
31. dZ[Z <= 0] = 0
32. return dZ
35. # Softmax
36. def softmax(Z):
37. A = np.exp(Z)/np.sum(np.exp(Z),axis=0)
38. cache = Z
39. return A, cache
40. # 初始化w
41. # def INIT_W(n_x,n_h1,n_h2,n_y):
42. # W1 = np.random.randn(n_h1, n_x ) * 0.01
43. # b1 = np.zeros((n_h1, 1))
44. # W2 = np.random.randn(n_h2,n_h1)*0.01
45. # b2 = np.zeros((n_h2,1))
46. # W3 = np.random.randn(n_y, n_h2) * 0.01
47. # b3 = np.zeros((n_y, 1))
48. # INIT = {
49. # "W1" : W1,
50. # "b1" : b1,
51. # "W2" : W2,
52. # "b2" : b2,
53. # "W3" : W3,
54. # "b3" : b3
55. # }
56. # return INIT
59. def init_W(layers_dims):
60. np.random.seed(3)
61. parameters = {}
62. L = len(layers_dims)
63. for l in range(1, L):
64. parameters["W" + str(l)] = np.random.randn(layers_dims[l], layers_dims[l - 1]) / np.sqrt(layers_dims[l - 1])
65. parameters["b" + str(l)] = np.zeros((layers_dims[l], 1))
66. return parameters
70. # 向前
71. def L_forword_sum(W,A,b):
72. Z = np.dot(W,A)+b
73. cache = (A,W,b)
74. return Z,cache
76. def L_activate_forworld(A_prev,W,b,activation):
77. if activation == "relu":
78. Z ,linear_cache = L_forword_sum(W,A_prev,b)
79. A, activation_cache = relu(Z)
80. elif activation == "sigmoid":
81. Z, linear_cache = L_forword_sum(W, A_prev, b)
82. A, activation_cache = sigmoid(Z)
83. elif activation == "softmax":
84. Z, linear_cache = L_forword_sum(W, A_prev, b)
85. A, activation_cache = softmax(Z)
86. cache = (linear_cache, activation_cache)
87. return A,cache
90. def L_forword(X, parameters):
91. caches = []
92. A = X
93. L = len(parameters) // 2
94. for l in range(1, L):
95. A_prev = A
96. A, cache = L_activate_forworld(A_prev, parameters['W' + str(l)], parameters['b' + str(l)], "relu")
97. caches.append(cache)
98. # 最后一层使用softmax
99. AL, cache = L_activate_forworld(A, parameters['W' + str(L)], parameters['b' + str(L)], "softmax")
100. caches.append(cache)
101. return AL, caches
103. #计算代价
104. def cost(Y_out,Y):
105. cost = -np.sum(np.multiply(np.log(Y_out), Y)) / Y_out.shape[1]
106. cost = np.squeeze(cost)
107. return cost
109. #线性返回
110. def linear_backward(dZ, cache):
111. A_prev, W, b = cache
112. m = A_prev.shape[1]
113. dW = np.dot(dZ, A_prev.T) / m
114. db = np.sum(dZ, axis=1, keepdims=True) / m
115. dA_prev = np.dot(W.T, dZ)
116. return dA_prev, dW, db
119. def linear_activation_backward(dA, cache, Y,activation="relu"):
120. linear_cache, activation_cache = cache
121. if activation == "relu":
122. dZ = relu_backward(dA, activation_cache)
123. dA_prev, dW, db = linear_backward(dZ, linear_cache)
124. elif activation == "sigmoid":
125. dZ = sigmoid_backward(dA, activation_cache)
126. dA_prev, dW, db = linear_backward(dZ, linear_cache)
127. elif activation == "softmax":
128. dZ = dA - Y
129. dA_prev, dW, db = linear_backward(dZ, linear_cache)
130. return dA_prev, dW, db
133. def L_model_backward(AL, Y, caches,case):
134. grads = {}
135. L = len(caches)
136. m = AL.shape[1]
137. Y = Y.reshape(AL.shape)
138. dAL = - (np.divide(Y, AL) - np.divide(1 - Y, 1 - AL))
139. if case == "softmax":
140. current_cache = caches[L - 1]
141. grads["dA" + str(L)], grads["dW" + str(L)], grads["db" + str(L)] = linear_activation_backward(AL, current_cache,Y,"softmax")
143. elif case == "sigmoid":
144. current_cache = caches[L - 1]
145. grads["dA" + str(L)], grads["dW" + str(L)], grads["db" + str(L)] = linear_activation_backward(AL, current_cache,Y, "sigmoid")
147. for l in reversed(range(L - 1)):
148. current_cache = caches[l]
149. dA_prev_temp, dW_temp, db_temp = linear_activation_backward(grads["dA" + str(l + 2)], current_cache, Y ,"relu")
150. grads["dA" + str(l + 1)] = dA_prev_temp
151. grads["dW" + str(l + 1)] = dW_temp
152. grads["db" + str(l + 1)] = db_temp
153. return grads
156. def update_parameters(parameters, grads, learning_rate):
157. L = len(parameters) // 2 # 整除
158. for l in range(L):
159. parameters["W" + str(l + 1)] = parameters["W" + str(l + 1)] - learning_rate * grads["dW" + str(l + 1)]
160. parameters["b" + str(l + 1)] = parameters["b" + str(l + 1)] - learning_rate * grads["db" + str(l + 1)]
161. return parameters
168. def deepnet(X, Y,net_layers,learning_rate=0.0075, num_iterations=3000,step =1, print_cost=False, isPlot=True):
169. np.random.seed(1) #设计种子
170. costs = [] #用于画图
171. parameters = init_W(net_layers)
172. for i in range(0, num_iterations):
173. # 迭代
174. AL, caches = L_forword(X, parameters)
176. costi = cost(AL, Y) #这里的Y是标准化的Y
178. grads = L_model_backward(AL, Y, caches,"softmax")
180. parameters = update_parameters(parameters, grads, learning_rate)
182. if i % step == 0:
183. # 记录成本
184. costs.append(costi)
185. # 是否打印成本值
186. if print_cost:
187. print("第", i, "次迭代，成本值为：", np.squeeze(costi))
190. if isPlot:
191. plt.plot(np.squeeze(costs))
192. plt.ylabel('cost')
193. plt.xlabel('iterations (per tens)')
194. plt.title("Learning rate =" + str(learning_rate))
195. plt.show()
196. # plt.savefig(fnme = "cast"+str(datetime.datetime.now())+".jig")
197. return parameters
200. def predict(X, y, parameters,Y_org):
202. m = X.shape[1]
203. n = len(parameters) // 2 # 神经网络的层数
204. p = np.zeros((1, m))
206. # 根据参数前向传播
207. probas, caches = L_forword(X, parameters)
208. p = np.argmax(probas,axis=0)
209. zql = float(np.sum((p == Y_org)) / m)
210. print("准确度为: " + str(float(np.sum((p == Y_org)) / m)))
212. error_list = []
213. for i in range(m):
214. if p[i] != Y_org[i]:
215. error_list.append(i)
216. return p,error_list,zql
219. def save_model(parameters):
220. np.set_printoptions(threshold=sys.maxsize)
222. model_number = 0
223. f = open("model/model" + str(model_number) + ".txt", "a+")
224. f.write(str(datetime.datetime.now()) + "\n")
225. f.write("model_number " + str(model_number) + "\n")
226. for i, j in parameters.items():
227. f.write(str(i) + "\n")
228. f.write(str(j) + "\n")
229. f.close()
230. return 0
232. #保存为h5数据格式
233. def save_h5(data,layers,zql):
234. str1 = "./model/model"+str(datetime.datetime.now().strftime("%Y%m%d%H%M%S"))+".h5"
235. f = h5py.File(str1, "w")
236. ID = ["model layer "]
237. f.create_dataset("layers",data = layers)
238. i = len(data) // 2
239. for j in range(i):
240. f.create_dataset("W"+str(j+1),data = data["W"+str(j+1)])
241. f.create_dataset("b"+str(j+1),data = data["b"+str(j+1)])
242. f.create_dataset("accuracy",data = zql)
243. f.close()
249. def predict1(X, parameters):
250. # 根据参数前向传播
251. probas, caches = L_forword(X, parameters)
252. p = np.argmax(probas,axis=0)
253. return p
255. def read_ccs(path):
256. w = h5py.File(path, "r")
257. layers = w["layers"][:]
258. l = len(layers)
259. p = {}
260. # print(l)
261. for i in range(1, l):
262. p["W" + str(i)] = w["W" + str(i)][:]
263. p["b" + str(i)] = w["b" + str(i)][:]
264. return p, layers

(3)train.py

2. import DeepNET
3. import time
5. import function
9. if __name__ == '__main__':
10. # 计时开始
11. start1 = time.time()
12. train_image_path = './MNIST/train-images-idx3-ubyte/train-images.idx3-ubyte'
13. train_lable_path = './MNIST/train-labels-idx1-ubyte/train-labels.idx1-ubyte'
14. teat_image_path = './MNIST/t10k-images-idx3-ubyte/t10k-images.idx3-ubyte'
15. teat_lable_path = './MNIST/t10k-labels-idx1-ubyte/t10k-labels.idx1-ubyte'
16. # #加载数据
17. train_image = function.jiexi_image(train_image_path)
18. train_lable = function.jiexi_label(train_lable_path)
19. teat_image = function.jiexi_image(teat_image_path)
20. test_lable = function.jiexi_label(teat_lable_path)
21. # print(train_image.shape)
23. function.plot_data(train_image,train_lable,10,True)
25. train_image = train_image.reshape(train_image.shape[0], -1).T / 255
26. teat_image = teat_image.reshape(teat_image.shape[0], -1).T / 255
27. train_lable1 = function.label_init(train_lable)
28. test_lable1 = function.label_init(test_lable)
30. print(train_image.shape)
32. end1 = time.time()
34. start2 = time.time()
35. layers = [784, 200, 150, 10]
36. parameters = DeepNET.deepnet(train_image, train_lable1,layers , learning_rate=0.0075, num_iterations=3000,
37. step=100, print_cost=True, isPlot=True)
38. end2 = time.time()
40. p ,error_list_train,zql1 = DeepNET.predict(train_image, train_lable1, parameters, train_lable)
41. p0 ,error_list_test ,zql2 = DeepNET.predict(teat_image,test_lable1,parameters,test_lable)
42. zql = [[zql1],[zql2]]
43. print("数据加载时间：",end1-start1," 秒")
44. print("模型训练时间：",end2-start2," 秒")
46. DeepNET.save_h5(parameters,layers,zql)

(4) main.py

2. # 加载库
3. from MainWidget import MainWidget
4. from PyQt5.QtWidgets import QApplication
5. import sys
7. def main():
8. app = QApplication(sys.argv)
10. mainWidget = MainWidget() # 新建一个主界面
11. mainWidget.show() # 显示主界面
13. exit(app.exec_()) # 进入消息循环
16. if __name__ == '__main__':
17. main()

(5)mainwidget.py

使用画板程序之前得跟该你的模型路径名字。就是红色部分。

def yuce(self):
        # #标准化图片 获取Y
        savePath = "./image_rgzn/test.png"
        image = self.__paintBoard.GetContentAsQImage()
        image.save(savePath)
        img = Image.open(savePath)
        img = img.convert("I")
        img = img.resize((28, 28))
        x = np.array(img)
        train_image = x.reshape(1, -1).T / 255
        w,layer = DeepNET.read_ccs("./model/model20221119225104.h5")
        p = DeepNET.predict1(train_image,w)
        self.__text_out.setText(str(p[0]))
        print(p)
        # print("hello")
        # res = QMessageBox.information(self,"人工智能判断为：",str(p),QMessageBox.Yes|QMessageBox.No)
        # res.exec_()
        # 读取数据权重

        # 预测并输出

1. '''
2. Created on 2018年8月8日
4. @author: Freedom
5. '''
6. from PyQt5.Qt import QWidget, QColor, QPixmap, QIcon, QSize, QCheckBox
7. from PyQt5.QtWidgets import QHBoxLayout, QVBoxLayout, QPushButton, QSplitter, \
8. QComboBox, QLabel, QSpinBox, QFileDialog,QTextEdit
9. from PaintBoard import PaintBoard
10. import numpy as np
11. from PIL import Image
12. import DeepNET
15. class MainWidget(QWidget):
17. def __init__(self, Parent=None):
18. '''
19. Constructor
20. '''
21. super().__init__(Parent)
23. self.__InitData() # 先初始化数据，再初始化界面
24. self.__InitView()
26. def __InitData(self):
27. '''
28. 初始化成员变量
29. '''
30. self.__paintBoard = PaintBoard(self)
31. # 获取颜色列表(字符串类型)
32. self.__colorList = QColor.colorNames()
34. def __InitView(self):
35. '''
36. 初始化界面
37. '''
38. self.setFixedSize(640, 480)
39. self.setWindowTitle("PaintBoard Example PyQt5")
41. # 新建一个水平布局作为本窗体的主布局
42. main_layout = QHBoxLayout(self)
43. # 设置主布局内边距以及控件间距为10px
44. main_layout.setSpacing(10)
46. # 在主界面左侧放置画板
47. main_layout.addWidget(self.__paintBoard)
49. # 新建垂直子布局用于放置按键
50. sub_layout = QVBoxLayout()
52. # 设置此子布局和内部控件的间距为10px
53. sub_layout.setContentsMargins(10, 10, 10, 10)
55. self.__btn_Clear = QPushButton("清空画板")
56. self.__btn_Clear.setParent(self) # 设置父对象为本界面
57. # 将按键按下信号与画板清空函数相关联
58. self.__btn_Clear.clicked.connect(self.__paintBoard.Clear)
59. sub_layout.addWidget(self.__btn_Clear)
61. self.__btn_yuce = QPushButton("人工智能预测")
62. self.__btn_yuce.setParent(self) # 设置父对象为本界面
63. self.__btn_yuce.clicked.connect(lambda:self.yuce())
64. sub_layout.addWidget(self.__btn_yuce)
67. self.__text_out = QTextEdit(self)
68. self.__text_out.setParent(self)
69. self.__text_out.setObjectName("预测结果为：")
70. sub_layout.addWidget(self.__text_out)
73. self.__btn_Quit = QPushButton("退出")
74. self.__btn_Quit.setParent(self) # 设置父对象为本界面
75. self.__btn_Quit.clicked.connect(self.Quit)
76. sub_layout.addWidget(self.__btn_Quit)
78. self.__btn_Save = QPushButton("保存作品")
79. self.__btn_Save.setParent(self)
80. self.__btn_Save.clicked.connect(self.on_btn_Save_Clicked)
81. sub_layout.addWidget(self.__btn_Save)
83. self.__cbtn_Eraser = QCheckBox(" 使用橡皮擦")
84. self.__cbtn_Eraser.setParent(self)
85. self.__cbtn_Eraser.clicked.connect(self.on_cbtn_Eraser_clicked)
86. sub_layout.addWidget(self.__cbtn_Eraser)
88. splitter = QSplitter(self) # 占位符
89. sub_layout.addWidget(splitter)
91. self.__label_penThickness = QLabel(self)
92. self.__label_penThickness.setText("画笔粗细")
93. self.__label_penThickness.setFixedHeight(20)
94. sub_layout.addWidget(self.__label_penThickness)
96. self.__spinBox_penThickness = QSpinBox(self)
97. self.__spinBox_penThickness.setMaximum(40)
98. self.__spinBox_penThickness.setMinimum(2)
99. self.__spinBox_penThickness.setValue(20) # 默认粗细为10
100. self.__spinBox_penThickness.setSingleStep(2) # 最小变化值为2
101. self.__spinBox_penThickness.valueChanged.connect(
102. self.on_PenThicknessChange) # 关联spinBox值变化信号和函数on_PenThicknessChange
103. sub_layout.addWidget(self.__spinBox_penThickness)
105. self.__label_penColor = QLabel(self)
106. self.__label_penColor.setText("画笔颜色")
107. self.__label_penColor.setFixedHeight(20)
108. sub_layout.addWidget(self.__label_penColor)
110. self.__comboBox_penColor = QComboBox(self)
111. self.__fillColorList(self.__comboBox_penColor) # 用各种颜色填充下拉列表
112. self.__comboBox_penColor.currentIndexChanged.connect(
113. self.on_PenColorChange) # 关联下拉列表的当前索引变更信号与函数on_PenColorChange
114. sub_layout.addWidget(self.__comboBox_penColor)
116. main_layout.addLayout(sub_layout) # 将子布局加入主布局
118. def __fillColorList(self, comboBox):
120. index_black = 0
121. index = 0
122. for color in self.__colorList:
123. if color == "black":
124. index_black = index
125. index += 1
126. pix = QPixmap(70, 20)
127. pix.fill(QColor(color))
128. comboBox.addItem(QIcon(pix), None)
129. comboBox.setIconSize(QSize(70, 20))
130. comboBox.setSizeAdjustPolicy(QComboBox.AdjustToContents)
132. comboBox.setCurrentIndex(index_black)
134. def on_PenColorChange(self):
135. color_index = self.__comboBox_penColor.currentIndex()
136. color_str = self.__colorList[color_index]
137. self.__paintBoard.ChangePenColor(color_str)
139. def on_PenThicknessChange(self):
140. penThickness = self.__spinBox_penThickness.value()
141. self.__paintBoard.ChangePenThickness(penThickness)
143. def on_btn_Save_Clicked(self):
144. savePath = QFileDialog.getSaveFileName(self, 'Save Your Paint', '.\\', '*.png')
145. print(savePath)
146. if savePath[0] == "":
147. print("Save cancel")
148. return
149. image = self.__paintBoard.GetContentAsQImage()
150. image.save(savePath[0])
152. def on_cbtn_Eraser_clicked(self):
153. if self.__cbtn_Eraser.isChecked():
154. self.__paintBoard.EraserMode = True # 进入橡皮擦模式
155. else:
156. self.__paintBoard.EraserMode = False # 退出橡皮擦模式
158. def Quit(self):
159. self.close()
162. def yuce(self):
163. # #标准化图片 获取Y
164. savePath = "./image_rgzn/test.png"
165. image = self.__paintBoard.GetContentAsQImage()
166. image.save(savePath)
167. img = Image.open(savePath)
168. img = img.convert("I")
169. img = img.resize((28, 28))
170. x = np.array(img)
171. train_image = x.reshape(1, -1).T / 255
172. w,layer = DeepNET.read_ccs("./model/model20221119225104.h5")
173. p = DeepNET.predict1(train_image,w)
174. self.__text_out.setText(str(p[0]))
175. print(p)
176. # print("hello")
177. # res = QMessageBox.information(self,"人工智能判断为：",str(p),QMessageBox.Yes|QMessageBox.No)
178. # res.exec_()
179. # 读取数据权重
181. # 预测并输出

(6)paintboard.py

1. '''
2. Created on 2018年8月9日
4. @author: Freedom
5. '''
6. from PyQt5.QtWidgets import QWidget
7. from PyQt5.Qt import QPixmap, QPainter, QPoint, QPaintEvent, QMouseEvent, QPen, \
8. QColor, QSize
9. from PyQt5.QtCore import Qt
12. class PaintBoard(QWidget):
14. def __init__(self, Parent=None):
15. '''
16. Constructor
17. '''
18. super().__init__(Parent)
20. self.__InitData() # 先初始化数据，再初始化界面
21. self.__InitView()
23. def __InitData(self):
25. self.__size = QSize(280, 280)
27. # 新建QPixmap作为画板，尺寸为__size
28. self.__board = QPixmap(self.__size)
29. self.__board.fill(Qt.black) # 用白色填充画板
31. self.__IsEmpty = True # 默认为空画板
32. self.EraserMode = False # 默认为禁用橡皮擦模式
34. self.__lastPos = QPoint(0, 0) # 上一次鼠标位置
35. self.__currentPos = QPoint(0, 0) # 当前的鼠标位置
37. self.__painter = QPainter() # 新建绘图工具
39. self.__thickness = 10 # 默认画笔粗细为10px
40. self.__penColor = QColor("white") # 设置默认画笔颜色为黑色
41. self.__colorList = QColor.colorNames() # 获取颜色列表
43. def __InitView(self):
44. # 设置界面的尺寸为__size
45. self.setFixedSize(self.__size)
47. def Clear(self):
48. # 清空画板
49. self.__board.fill(Qt.black)
50. self.update()
51. self.__IsEmpty = True
53. def ChangePenColor(self, color="black"):
54. # 改变画笔颜色
55. self.__penColor = QColor(color)
57. def ChangePenThickness(self, thickness=10):
58. # 改变画笔粗细
59. self.__thickness = thickness
61. def IsEmpty(self):
62. # 返回画板是否为空
63. return self.__IsEmpty
65. def GetContentAsQImage(self):
66. # 获取画板内容（返回QImage）
67. image = self.__board.toImage()
68. return image
70. def paintEvent(self, paintEvent):
71. # 绘图事件
72. # 绘图时必须使用QPainter的实例，此处为__painter
73. # 绘图在begin()函数与end()函数间进行
74. # begin(param)的参数要指定绘图设备，即把图画在哪里
75. # drawPixmap用于绘制QPixmap类型的对象
76. self.__painter.begin(self)
77. # 0,0为绘图的左上角起点的坐标，__board即要绘制的图
78. self.__painter.drawPixmap(0, 0, self.__board)
79. self.__painter.end()
81. def mousePressEvent(self, mouseEvent):
82. # 鼠标按下时，获取鼠标的当前位置保存为上一次位置
83. self.__currentPos = mouseEvent.pos()
84. self.__lastPos = self.__currentPos
86. def mouseMoveEvent(self, mouseEvent):
87. # 鼠标移动时，更新当前位置，并在上一个位置和当前位置间画线
88. self.__currentPos = mouseEvent.pos()
89. self.__painter.begin(self.__board)
91. if self.EraserMode == False:
92. # 非橡皮擦模式
93. self.__painter.setPen(QPen(self.__penColor, self.__thickness)) # 设置画笔颜色，粗细
94. else:
95. # 橡皮擦模式下画笔为纯白色，粗细为10
96. self.__painter.setPen(QPen(Qt.white, 10))
98. # 画线
99. self.__painter.drawLine(self.__lastPos, self.__currentPos)
100. self.__painter.end()
101. self.__lastPos = self.__currentPos
103. self.update() # 更新显示
105. def mouseReleaseEvent(self, mouseEvent):
106. self.__IsEmpty = False # 画板不再为空

        感谢看完的读者，希望你们都可以对编程产生热爱！