三层神经网络，训练0到9十个数字并测试：
1 import numpy 2 import scipy.special 3 # import matplotlib.pyplot 4 import time 5 6 7 class NeuralNetwork: 8 9 # 初始化神经网络 10 def __init__(self, inputnodes, hiddenodes, outputnodes, learningrate): 11 # 设置输入层、隐藏层、输出层的节点数 12 self.inodes = inputnodes 13 self.hnodes = hiddenodes 14 self.onodes = outputnodes 15 16 # 学习因子 17 self.lr = learningrate 18 19 # 输入层、隐藏层、输出层之间的链接权重 20 # self.wih = (numpy.random.rand(self.hnodes, self.inodes) - 0.5) 21 # self.who = (numpy.random.rand(self.onodes, self.inodes) - 0.5) 22 # 利用正态分布采样权重 23 self.wih = numpy.random.normal(0.0, pow(self.hnodes, - 0.5), (self.hnodes, self.inodes)) 24 self.who = numpy.random.normal(0.0, pow(self.onodes, - 0.5), (self.onodes, self.hnodes)) 25 26 # S函数 27 self.activation_function = lambda x: scipy.special.expit(x) 28 pass 29 30 # 训练 31 def train(self, inputs_list, targets_list): 32 # 输入层转矩阵 33 inputs = numpy.array(inputs_list, ndmin=2).T 34 targets = numpy.array(targets_list, ndmin=2).T 35 36 # 隐藏层输入=权重点乘输入层矩阵 37 hidden_inputs = numpy.dot(self.wih, inputs) 38 # 隐藏层应用S函数 39 hidden_outputs = self.activation_function(hidden_inputs) 40 41 # 输出层输入=权重点乘隐藏层输入矩阵 42 final_inputs = numpy.dot(self.who, hidden_outputs) 43 # 输出层输入应用S函数 44 final_outputs = self.activation_function(final_inputs) 45 46 # 计算误差 47 output_errors = targets - final_outputs; 48 # 计算隐藏层误差 49 hidden_errors = numpy.dot(self.who.T, output_errors) 50 # 更新隐藏层和输出层之间的权重 51 self.who += self.lr * numpy.dot((output_errors * final_outputs * (1.0 - final_outputs)), 52 numpy.transpose(hidden_outputs)) 53 # 更新输入层和隐藏层之间的权重 54 self.wih += self.lr * numpy.dot((hidden_errors * hidden_outputs * (1.0 - hidden_outputs)), 55 numpy.transpose(inputs)) 56 57 pass 58 59 # 查询 60 def query(self, inputs_list): 61 # 输入层转矩阵 62 inputs = numpy.array(inputs_list, ndmin=2).T 63 64 # 隐藏层输入=权重点乘输入层矩阵 65 hidden_inputs = numpy.dot(self.wih, inputs) 66 # 隐藏层应用S函数 67 hidden_outputs = self.activation_function(hidden_inputs) 68 69 # 输出层输入=权重点乘隐藏层输入矩阵 70 final_inputs = numpy.dot(self.who, hidden_outputs) 71 # 输出层输入应用S函数 72 final_outputs = self.activation_function(final_inputs) 73 74 return final_outputs 75 76 77 # 输入、隐藏、输出三层节点数 78 input_nodes = 784 79 hidden_nodes = 100 80 output_nodes = 10 81 82 # 学习因子 83 learning_rate = 0.2 84 85 # 创建神经网络 86 n = NeuralNetwork(input_nodes, hidden_nodes, output_nodes, learning_rate) 87 88 # 读取训练数据 89 # training_data_file = open("web/mnist_dataset/mnist_train_100.csv") 90 training_data_file = open("web/mnist_dataset/mnist_train.csv") 91 training_data_list = training_data_file.readlines() 92 training_data_file.close() 93 94 # 世代，所有数据训练一遍为一个世代 95 epochs = 1 96 start = int(time.time()) 97 for e in range(epochs): 98 # 训练神经网络 99 for record in training_data_list: 100 # 按逗号切分成数组 101 all_values = record.split(",") 102 # 缩放并转换成0.01到0.99之间的数组 103 inputs = (numpy.asfarray(all_values[1:]) / 255.0 * 0.99) + 0.01 104 # 构建真实输出数组，除了目标位置是0.99，其他都是0.01 105 targets = numpy.zeros(output_nodes) + 0.01 106 targets[int(all_values[0])] = 0.99 107 n.train(inputs, targets) 108 pass 109 pass 110 end = int(time.time()) 111 print("训练用时=", end - start, "秒") 112 113 # 测试数据 114 # test_data_file = open("web/mnist_dataset/mnist_test_10.csv") 115 test_data_file = open("web/mnist_dataset/mnist_test.csv") 116 test_data_list = test_data_file.readlines() 117 test_data_file.close() 118 # all_values = test_data_list[0].split(",") 119 # image_array = numpy.asfarray(all_values[1:]).reshape((28, 28)) 120 # matplotlib.pyplot.imshow(image_array, cmap='Greys', interpolation='None') 121 # 122 # value = n.query((numpy.asfarray(all_values[1:]) / 255.0 * 0.99) + 0.01) 123 # print(value) 124 125 # 统计分数 126 scorecard = [] 127 128 start = int(time.time()) 129 # 检查所有测试数据 130 for record in test_data_list: 131 all_values = record.split(",") 132 # 正确答案 133 correct_label = int(all_values[0]) 134 # print(correct_label, "正确答案") 135 136 inputs = (numpy.asfarray(all_values[1:]) / 255.0 * 0.99) + 0.01 137 outputs = n.query(inputs) 138 label = numpy.argmax(outputs) 139 # print(label, "神经网络答案") 140 141 if label == correct_label: 142 scorecard.append(1) 143 else: 144 scorecard.append(0) 145 pass 146 end = int(time.time()) 147 print("检查用时=", end - start, "秒") 148 149 # print(scorecard) 150 scorecard_array = numpy.asarray(scorecard) 151 print("正确率=", scorecard_array.sum() / scorecard_array.size)
验证码的数字和字母识别：
1 import numpy 2 import scipy.special 3 import scipy.ndimage.interpolation 4 # import matplotlib.pyplot 5 import time 6 import string 7 from random import shuffle 8 9 import matplotlib.pyplot 10 11 12 13 class NeuralNetwork: 14 15 # 初始化神经网络 16 def __init__(self, inputnodes, hiddenodes, outputnodes, learningrate): 17 # 设置输入层、隐藏层、输出层的节点数 18 self.inodes = inputnodes 19 self.hnodes = hiddenodes 20 self.onodes = outputnodes 21 22 # 学习因子 23 self.lr = learningrate 24 25 # 输入层、隐藏层、输出层之间的链接权重 26 # self.wih = (numpy.random.rand(self.hnodes, self.inodes) - 0.5) 27 # self.who = (numpy.random.rand(self.onodes, self.inodes) - 0.5) 28 # 利用正态分布采样权重 29 self.wih = numpy.random.normal(0.0, pow(self.hnodes, - 0.5), (self.hnodes, self.inodes)) 30 self.who = numpy.random.normal(0.0, pow(self.onodes, - 0.5), (self.onodes, self.hnodes)) 31 32 # S函数 33 self.activation_function = lambda x: scipy.special.expit(x) 34 self.inverse_activation_function = lambda x: scipy.special.logit(x) 35 pass 36 37 # 训练 38 def train(self, inputs_list, targets_list): 39 # 输入层转矩阵 40 inputs = numpy.array(inputs_list, ndmin=2).T 41 targets = numpy.array(targets_list, ndmin=2).T 42 43 # 隐藏层输入=权重点乘输入层矩阵 44 hidden_inputs = numpy.dot(self.wih, inputs) 45 # 隐藏层应用S函数 46 hidden_outputs = self.activation_function(hidden_inputs) 47 48 # 输出层输入=权重点乘隐藏层输入矩阵 49 final_inputs = numpy.dot(self.who, hidden_outputs) 50 # 输出层输入应用S函数 51 final_outputs = self.activation_function(final_inputs) 52 53 # 计算误差 54 output_errors = targets - final_outputs 55 # 计算隐藏层误差 56 hidden_errors = numpy.dot(self.who.T, output_errors) 57 # 更新隐藏层和输出层之间的权重 58 self.who += self.lr * numpy.dot((output_errors * final_outputs * (1.0 - final_outputs)), 59 numpy.transpose(hidden_outputs)) 60 # 更新输入层和隐藏层之间的权重 61 self.wih += self.lr * numpy.dot((hidden_errors * hidden_outputs * (1.0 - hidden_outputs)), 62 numpy.transpose(inputs)) 63 64 pass 65 66 # 查询 67 def query(self, inputs_list): 68 # 输入层转矩阵 69 inputs = numpy.array(inputs_list, ndmin=2).T 70 71 # 隐藏层输入=权重点乘输入层矩阵 72 hidden_inputs = numpy.dot(self.wih, inputs) 73 # 隐藏层应用S函数 74 hidden_outputs = self.activation_function(hidden_inputs) 75 76 # 输出层输入=权重点乘隐藏层输入矩阵 77 final_inputs = numpy.dot(self.who, hidden_outputs) 78 # 输出层输入应用S函数 79 final_outputs = self.activation_function(final_inputs) 80 81 return final_outputs 82 83 def back_query(self, targets_list): 84 # transpose the targets list to a vertical array 85 final_outputs = numpy.array(targets_list, ndmin=2).T 86 87 # calculate the signal into the final output layer 88 final_inputs = self.inverse_activation_function(final_outputs) 89 90 # calculate the signal out of the hidden layer 91 hidden_outputs = numpy.dot(self.who.T, final_inputs) 92 # scale them back to 0.01 to .99 93 hidden_outputs -= numpy.min(hidden_outputs) 94 hidden_outputs /= numpy.max(hidden_outputs) 95 hidden_outputs *= 0.98 96 hidden_outputs += 0.01 97 98 # calculate the signal into the hidden layer 99 hidden_inputs = self.inverse_activation_function(hidden_outputs) 100 101 # calculate the signal out of the input layer 102 inputs = numpy.dot(self.wih.T, hidden_inputs) 103 # scale them back to 0.01 to .99 104 inputs -= numpy.min(inputs) 105 inputs /= numpy.max(inputs) 106 inputs *= 0.98 107 inputs += 0.01 108 109 return inputs 110 111 112 # 验证码,10个数字+26个大小写字母97-122 113 codes = list(string.digits + string.ascii_lowercase) 114 # 输入、隐藏、输出三层节点数 115 input_nodes = 45 * 100 116 # 四位验证码 117 output_nodes = (len(codes)) 118 hidden_nodes = output_nodes * 10 119 120 121 # 学习因子 122 learning_rate = 0.2 123 124 # 创建神经网络 125 n = NeuralNetwork(input_nodes, hidden_nodes, output_nodes, learning_rate) 126 127 # 读取训练数据 128 # training_data_file = open("web/mnist_dataset/mnist_train_100.csv") 129 training_data_file = open("web/train.csv") 130 training_data_list = training_data_file.readlines() 131 shuffle(training_data_list) 132 training_data_file.close() 133 134 135 # 世代，所有数据训练一遍为一个世代 136 epochs = 1 137 print("输入节点=%d，隐藏节点=%d，输出节点=%d，学习因子=%f，时代=%d" % (input_nodes, hidden_nodes, output_nodes, learning_rate, epochs)) 138 print("开始训练...") 139 start = int(time.time()) 140 for e in range(epochs): 141 # 训练神经网络 142 for record in training_data_list: 143 # 按逗号切分成数组 144 all_values = record.split(",") 145 # 缩放并转换成0.01到0.99之间的数组 146 train_inputs = (numpy.asfarray(all_values[1:]) / 255.0 * 0.99) + 0.01 147 # 旋转正负10度 148 train_inputs_plus_10 = scipy.ndimage.interpolation.rotate(train_inputs.reshape(1, 4500), 10, cval=0.01, 149 reshape=False) 150 train_inputs_minus_10 = scipy.ndimage.interpolation.rotate(train_inputs.reshape(1, 4500), -10, cval=0.01, 151 reshape=False) 152 153 # 构建真实输出数组，除了目标位置是0.99，其他都是0.01 154 train_targets = numpy.zeros(output_nodes) + 0.01 155 code = all_values[0] 156 train_targets[codes.index(code)] = 0.99 157 n.train(train_inputs, train_targets) 158 n.train(train_inputs_plus_10, train_targets) 159 n.train(train_inputs_minus_10, train_targets) 160 pass 161 pass 162 end = int(time.time()) 163 print("训练用时=", end - start, "秒") 164 165 # 测试数据 166 # test_data_file = open("web/mnist_dataset/mnist_test_10.csv") 167 # test_data_file = open("web/mnist_dataset/mnist_test.csv") 168 test_data_file = open("web/test.csv") 169 test_data_list = test_data_file.readlines() 170 test_data_file.close() 171 # all_values = test_data_list[0].split(",") 172 # image_array = numpy.asfarray(all_values[1:]).reshape((28, 28)) 173 # matplotlib.pyplot.imshow(image_array, cmap='Greys', interpolation='None') 174 # 175 # value = n.query((numpy.asfarray(all_values[1:]) / 255.0 * 0.99) + 0.01) 176 # print(value) 177 178 # 统计分数 179 scorecard = [] 180 181 print("开始测试...") 182 start = int(time.time()) 183 # 检查所有测试数据 184 for record in test_data_list: 185 all_values = record.split(",") 186 # 正确答案 187 correct_label = (all_values[0]) 188 # print(correct_label, "正确答案") 189 190 verify_inputs = (numpy.asfarray(all_values[1:]) / 255.0 * 0.99) + 0.01 191 verify_outputs = n.query(verify_inputs) 192 # print(verify_outputs) 193 label = codes[numpy.argmax(verify_outputs)] 194 # print(label, "神经网络答案") 195 196 if label == correct_label: 197 scorecard.append(1) 198 else: 199 scorecard.append(0) 200 pass 201 pass 202 end = int(time.time()) 203 print("检查用时=", end - start, "秒") 204 205 # print(scorecard) 206 scorecard_array = numpy.asarray(scorecard) 207 print("正确率=", scorecard_array.sum() / scorecard_array.size) 208 209 label = 0 210 # create the output signals for this label 211 targets = numpy.zeros(output_nodes) + 0.01 212 # all_values[0] is the target label for this record 213 targets[label] = 0.99 214 # print(targets) 215 216 # get image data 217 image_data = n.back_query(targets) 218 # print(image_data) 219 220 # plot image data 221 matplotlib.pyplot.imshow(image_data.reshape(45, 100), cmap='Greys', interpolation='None')
制作训练和测试数据：
1 import csv 2 # import matplotlib.pyplot 3 import os 4 import cv2 5 6 import numpy 7 import scipy.special 8 import string 9 10 11 class NeuralNetwork: 12 13 # 初始化神经网络 14 def __init__(self, inputnodes, hiddenodes, outputnodes, learningrate): 15 # 设置输入层、隐藏层、输出层的节点数 16 self.inodes = inputnodes 17 self.hnodes = hiddenodes 18 self.onodes = outputnodes 19 20 # 学习因子 21 self.lr = learningrate 22 23 # 输入层、隐藏层、输出层之间的链接权重 24 # self.wih = (numpy.random.rand(self.hnodes, self.inodes) - 0.5) 25 # self.who = (numpy.random.rand(self.onodes, self.inodes) - 0.5) 26 # 利用正态分布采样权重 27 self.wih = numpy.random.normal(0.0, pow(self.hnodes, - 0.5), (self.hnodes, self.inodes)) 28 self.who = numpy.random.normal(0.0, pow(self.onodes, - 0.5), (self.onodes, self.hnodes)) 29 30 # S函数 31 self.activation_function = lambda x: scipy.special.expit(x) 32 pass 33 34 # 训练 35 def train(self, inputs_list, targets_list): 36 # 输入层转矩阵 37 inputs = numpy.array(inputs_list, ndmin=2).T 38 targets = numpy.array(targets_list, ndmin=2).T 39 40 # 隐藏层输入=权重点乘输入层矩阵 41 hidden_inputs = numpy.dot(self.wih, inputs) 42 # 隐藏层应用S函数 43 hidden_outputs = self.activation_function(hidden_inputs) 44 45 # 输出层输入=权重点乘隐藏层输入矩阵 46 final_inputs = numpy.dot(self.who, hidden_outputs) 47 # 输出层输入应用S函数 48 final_outputs = self.activation_function(final_inputs) 49 50 # 计算误差 51 output_errors = targets - final_outputs; 52 # 计算隐藏层误差 53 hidden_errors = numpy.dot(self.who.T, output_errors) 54 # 更新隐藏层和输出层之间的权重 55 self.who += self.lr * numpy.dot((output_errors * final_outputs * (1.0 - final_outputs)), 56 numpy.transpose(hidden_outputs)) 57 # 更新输入层和隐藏层之间的权重 58 self.wih += self.lr * numpy.dot((hidden_errors * hidden_outputs * (1.0 - hidden_outputs)), 59 numpy.transpose(inputs)) 60 61 pass 62 63 # 查询 64 def query(self, inputs_list): 65 # 输入层转矩阵 66 inputs = numpy.array(inputs_list, ndmin=2).T 67 68 # 隐藏层输入=权重点乘输入层矩阵 69 hidden_inputs = numpy.dot(self.wih, inputs) 70 # 隐藏层应用S函数 71 hidden_outputs = self.activation_function(hidden_inputs) 72 73 # 输出层输入=权重点乘隐藏层输入矩阵 74 final_inputs = numpy.dot(self.who, hidden_outputs) 75 # 输出层输入应用S函数 76 final_outputs = self.activation_function(final_inputs) 77 78 return final_outputs 79 80 81 # 读取训练数据 82 def convert_img_to_csv(img_dir, csv_file): 83 # 设置需要保存的csv路径 84 with open(r"web/" + csv_file + ".csv", "w", newline="") as f: 85 # 设置csv文件的列名 86 # column_name = ["label"] 87 # column_name.extend(["pixel%d" % i for i in range(32 * 32)]) 88 # 将列名写入到csv文件中 89 writer = csv.writer(f) 90 # writer.writerow(column_name) 91 # 该目录下有9个目录,目录名从0-9 92 # for i in range(1): 93 # 获取目录的路径 94 # img_temp_dir = os.path.join(img_dir, str(i)) 95 # 获取该目录下所有的文件 96 img_list = os.listdir(img_dir) 97 # 遍历所有的文件名称 98 for img_name in img_list: 99 # 判断文件是否为目录,如果为目录则不处理 100 if not os.path.isdir(img_name): 101 # 获取图片的路径 102 img_path = os.path.join(img_dir, img_name) 103 # 因为图片是黑白的，所以以灰色读取图片 104 img = cv2.imread(img_path, cv2.IMREAD_GRAYSCALE) 105 # 图片标签 106 row_data = [img_name[0]] 107 # 获取图片的像素 108 ary = 255.0 - img.flatten() 109 row_data.extend(ary) 110 # 将图片数据写入到csv文件中 111 writer.writerow(row_data) 112 113 114 def split_image(img_dir, save_path): 115 image_save_path_tail = ".jpg" 116 # 获取该目录下所有的文件 117 img_list = os.listdir(img_dir) 118 seq = 1 119 # 遍历所有的文件名称 120 for img_name in img_list: 121 # 判断文件是否为目录,如果为目录则不处理 122 if not os.path.isdir(img_name): 123 # 获取图片的路径 124 img_path = os.path.join(img_dir, img_name) 125 # 因为图片是黑白的，所以以灰色读取图片 126 src_img = cv2.imread(img_path, cv2.IMREAD_GRAYSCALE) 127 # print(src_img) 128 # 180*100 129 for i in range(4): # [1]480*360==15*11---height 130 img_roi = src_img[0:100, (i * 45):((i + 1) * 45)] 131 image_save_path = "%s%s%s%d%s" % (save_path, img_name[(-8 + i)], "_", seq, image_save_path_tail) 132 cv2.imwrite(image_save_path, img_roi) 133 seq = seq + 1 134 pass 135 pass 136 137 138 if __name__ == "__main__": 139 # 将该目录下的图片保存为csv文件 140 # convert_img_to_csv("web/unknownCode", "train-single") 141 # convert_img_to_csv("web/train-single", "train") 142 # convert_img_to_csv("web/test-single", "test") 143 # a = list(string.digits + string.ascii_lowercase) 144 145 # print(ord(a[10])) 146 # print(a.index("a")) 147 148 # 一张图片切四张 149 # split_image("web/train/", "web/train-single/") 150 # convert_img_to_csv("web/train-single", "train") 151 split_image("web/unknownCode/", "web/test-single/") 152 convert_img_to_csv("web/test-single", "test") 153 pass