python 三層神經網絡搭建

時間 2019-11-09

原文原文鏈接

三層神經網絡，訓練0到9十個數字並測試：node

  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)

驗證碼的數字和字母識別：git

  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')

製做訓練和測試數據：web

  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