├── README.md ├── logisticRegression.py ├── multi_layer_neuro_nets.py └── MLP_with_tools.py /README.md: -------------------------------------------------------------------------------- 1 | # DL-course-code 2 | Andrew Ng's new course on DL, 2017. 3 | 4 | 第一课 5 | ------------------ 6 | 第一个程序 一个神经元（逻辑回归）logisticRegression.py 7 | 8 | 按照课程思路实现，比较丑。 9 | 10 | 第二个程序 一个神经网络（多层感知机）multi_layer_neuro_nets.py 11 | 12 | 为扩展方便，写成了面向对象形式，支持任意层网络； 13 | 17.9.8 增加部分注释；改进测试函数；删除debug信息 14 | 15 | 16 | 第二课 17 | ------------------ 18 | Course 2 Week 1 -- MLP_with_tools.py 19 | （在原有多层感知机程序上扩展，但使用新的文件增加新功能） 20 | 21 | 完成数据归一化、数据集划分train/dev集合功能、三种正则化方式：L2,Dropout,Earlystoping 22 | 23 | 17.9.17 增加梯度检查、梯度爆炸/消失预防（完成添加第一周课程提到的全部功能） 24 | 25 | 一个网络可以如下定义： 26 | ``` 27 | def buildNet(): 28 | data = loadData() 29 |    #定义网络，选择是否Earlystop，设定全局L2正则化参数lambda;（可选全局化Dropout: Dropout = neuro_keep_ratio） 30 | #只在Debug时选择 GradCheck = True，非常耗时 31 | net = NeuroNet(data,Earlystop = True,L2 = 20,GradCheck = True) 32 | net.addLayer("first",100,0.01) 33 | net.addLayer("second",80,0.01) 34 | net.addLayer("third",60,0.01) 35 |    #定义某一层（名称，节点数，学习率，Dropout=neuro_keep_ratio） 36 |    net.addLayer("forth",40,0.02,Dropout = 0.8) 37 | net.addLayer("fifth",20,0.01) 38 | net.addLayer("output",1,0.01) 39 | net.initLayers() 40 | return net 41 | 42 | def dothework(): 43 | #创建神经网络 44 | net = buildNet() 45 | #迭代训练n次 46 |   net.train(200000) 47 | ``` 48 | 待续…… 49 | -------------------------------------------------------------------------------- /logisticRegression.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | Created on Sun Sep 03 12:25:30 2017 4 | Following the course of Andrew.Ng, DeepLearning I 5 | First step a single neuron -- logistic regression 6 | @author: Gao 7 | """ 8 | import numpy as np 9 | import pandas as pd 10 | 11 | 12 | def activate(Z): 13 | A = 1.0/(1+np.exp(-Z)) 14 | return A 15 | 16 | def train(epoch_limits, alpha, W, train_set, y): 17 | J = [] 18 | for iter in xrange(epoch_limits): 19 | assert(W.shape[1]==train_set.shape[0]) 20 | Z = np.dot(W,train_set) 21 | A = activate(Z) 22 | 23 | a_first = np.log(A) 24 | a_second = np.log(1-A) 25 | L_first= np.dot(a_first,y) 26 | L_second = np.dot(a_second,1-y) 27 | L = (L_first+L_second)*-1 28 | J.append(L[0][0]) 29 | 30 | dZ = A - y.T 31 | dW = np.dot(dZ,train_set.T)*1.0/train_set.shape[1] 32 | W = W - alpha*(1.0-(1+iter)/epoch_limits)* dW 33 | print("epoch: %05d cost %.02f"%(iter,L[0][0])) 34 | precision = test(train_set,y,W) 35 | print("precision on train set: %.02f"%precision) 36 | return W 37 | 38 | def predict(X,W): 39 | assert(X.shape[0]==W.shape[1]) 40 | y = activate(np.dot(W,X)) 41 | y[y>0.5] = 1 42 | y[y<=0.5] = 0 43 | return y 44 | 45 | def loadData(): 46 | train_set = pd.read_csv("X.csv",header=None) 47 | train_label = pd.read_csv("y.csv",header=None) 48 | test_set = pd.read_csv("Tx.csv",header=None) 49 | test_label = pd.read_csv("Ty.csv",header=None) 50 | return train_set,train_label,test_set,test_label 51 | 52 | def test(val_set,val_label,params): 53 | result = predict(val_set,params) 54 | return sum(result.T==val_label)*1.0/val_set.shape[1] 55 | 56 | def do(): 57 | train_set,train_label,test_set,test_label = loadData() 58 | #add a bias columns 59 | train_set.loc[:,'bias']=pd.Series(np.ones(train_set.shape[0])) 60 | test_set.loc[:,'bias']=pd.Series(np.ones(test_set.shape[0])) 61 | #initial params 62 | W = np.random.randn(1,train_set.shape[1]) 63 | alpha = 0.01 64 | epoch = 40000 65 | W = train(epoch,alpha,W,train_set.values.T,train_label.values) 66 | print("Test precision: %.2f"%test(test_set.values.T,test_label.values,W)) 67 | 68 | if __name__=='__main__': 69 | do() -------------------------------------------------------------------------------- /multi_layer_neuro_nets.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | Created on Mon Sep 04 19:02:19 2017 4 | Following the course of Andrew.Ng, DeepLearning I 5 | Second step a multi-layer neuron nets 6 | @author: Gao 7 | """ 8 | import numpy as np 9 | import pandas as pd 10 | class NeuroLayer: 11 | def __init__(self,name,num_units,alpha): 12 | self.name = name 13 | self.num_units = num_units 14 | self.alpha = alpha 15 | self.weights = "nan" 16 | self.inputs = "nan" 17 | self.act = "nan" 18 | self.derivative_Z = "nan" 19 | self.delta = "nan" 20 | 21 | def activate(self,Z): 22 | A = 1.0/(1+np.exp(-Z)) 23 | return A 24 | 25 | def computeA(self,input_x): 26 | assert(self.weights.shape[1] == input_x.shape[0]) 27 | self.inputs = input_x 28 | z=np.dot(self.weights,input_x) 29 | self.act = self.activate(z) 30 | 31 | def computeDZ(self,input_delta): 32 | derivative_A_on_Z = self.act*(1-self.act) 33 | assert(input_delta.shape == derivative_A_on_Z.shape) 34 | self.derivative_Z = input_delta*derivative_A_on_Z 35 | 36 | def computeLoss(self,input_y): 37 | self.derivative_Z = self.act - input_y.T 38 | 39 | def computeDelta(self): 40 | assert(self.weights.shape[0] == self.derivative_Z.shape[0]) 41 | self.delta = np.dot(self.weights.T,self.derivative_Z) 42 | self.delta = np.delete(self.delta, (-1), axis=0) 43 | 44 | def updataWeights(self): 45 | DW = np.dot(self.derivative_Z,self.inputs.T)*1.0/self.inputs.shape[1] 46 | assert(DW.shape == self.weights.shape) 47 | self.weights = self.weights - self.alpha * DW 48 | 49 | def initParams(self,last_layer_units): 50 | self.weights = np.random.randn(self.num_units,last_layer_units+1) 51 | 52 | 53 | class NeuroNet: 54 | def __init__(self, train_set, train_label, test_set, test_label): 55 | #train/test set is arranged by (num_of_feature, num_of_dataset) 56 | #train/test label is vertical vector, namey (num_of_dataset, 1) 57 | self.train_set = train_set 58 | self.train_label = train_label 59 | self.test_set = test_set 60 | self.test_label = test_label 61 | #useful while initialize the layers 62 | self.num_of_dataset = train_set.shape[1] 63 | self.num_of_feature = train_set.shape[0] 64 | self.layers = [] 65 | def addLayer(self,name,num_units,alpha): 66 | layer = NeuroLayer(name,num_units,alpha) 67 | self.layers.append(layer) 68 | 69 | def initLayers(self): 70 | last_layer_units = self.num_of_feature 71 | for layer in self.layers: 72 | layer.initParams(last_layer_units) 73 | last_layer_units = layer.num_units 74 | 75 | def forward(self,input_x): 76 | feed_data = input_x 77 | for layer in self.layers: 78 | #add bias through augmentation of the Weight-matrix 79 | new_row = np.ones((1,feed_data.shape[1])) 80 | feed_data = np.row_stack((feed_data,new_row)) 81 | layer.computeA(feed_data) 82 | feed_data = layer.act 83 | 84 | def backwark(self,input_y): 85 | layers = self.layers[::-1] 86 | delta = "nan" 87 | for layer in layers: 88 | if layer.name == "output": 89 | layer.computeLoss(input_y) 90 | else: 91 | layer.computeDZ(delta) 92 | layer.computeDelta() 93 | delta = layer.delta 94 | layer.updataWeights() 95 | 96 | def train(self,epoch_limits): 97 | print "training start..." 98 | for i in xrange(epoch_limits): 99 | self.forward(self.train_set) 100 | self.backwark(self.train_label) 101 | print("training %05d epoch: \n\tprecision on train %02.02f \n\tprecision on test %02.02f"%(i+1,self.stats("train"),self.stats("test"))) 102 | 103 | 104 | def stats(self,type_of_dataset): 105 | if type_of_dataset == "train": 106 | data = self.train_set 107 | label = self.train_label 108 | else: 109 | data = self.test_set 110 | label = self.test_label 111 | self.forward(data) 112 | layer = self.layers[-1] 113 | y = layer.act 114 | y[y > 0.5] = 1 115 | y[y <= 0.5] = 0 116 | return sum(y.T==label)*1.0/label.shape[0] 117 | 118 | def predict(self): 119 | self.forward(self.test_set) 120 | layer = self.layers[-1] 121 | y = layer.act 122 | y[y > 0.5] = 1 123 | y[y <= 0.5] = 0 124 | return sum(y.T==self.test_label)*1.0/self.test_label.shape[0],y 125 | 126 | def loadData(): 127 | ''' 128 | 读取数据 129 | -- X为训练集，组织形式：每行一个样本，列个数即特征维度 130 | -- y为训练集标签，与训练集逐行对应 131 | -- Tx,Ty为测试集，同理 132 | ''' 133 | train_set = pd.read_csv("X.csv",header=None) 134 | train_label = pd.read_csv("y.csv",header=None) 135 | test_set = pd.read_csv("Tx.csv",header=None) 136 | test_label = pd.read_csv("Ty.csv",header=None) 137 | return train_set,train_label,test_set,test_label 138 | 139 | def buildNet(): 140 | Train,Ty,test,ty = loadData() 141 | #根据课程内容，将数据集转置，调整成每列一个样本 142 | #标签集保持列向量形式 143 | net = NeuroNet(Train.values.T,Ty.values,test.values.T,ty.values) 144 | #层参数：名称，单元个数，学习率 145 | net.addLayer("first",20,0.01) 146 | net.addLayer("second",10,0.01) 147 | #最后一层请务必叫“output” 148 | net.addLayer("output",1,0.01) 149 | net.initLayers() 150 | return net 151 | 152 | def dothework(): 153 | #创建神经网络 154 | net = buildNet() 155 | print("build success,net have %d layers"%len(net.layers)) 156 | #迭代训练 5000次 157 | net.train(5000) 158 | 159 | if __name__ == "__main__": 160 | dothework() -------------------------------------------------------------------------------- /MLP_with_tools.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | Created on Thu Sep 07 21:39:16 2017 4 | Second course week 1 [S2W1], add tools for training 5 | 1,Data partation 6 | 2,Input Normalization 7 | 3,Regularization(L2,Drop out,Early stopping) 8 | 4,Exploding/vanishing avoidance 9 | 5,Gradient check 10 | @author: Gao 11 | """ 12 | 13 | import numpy as np 14 | import pandas as pd 15 | class DataSet: 16 | def __init__(self,trn_set,trn_lb,tst_set = [],tst_lb=[]): 17 | self.training_set = trn_set 18 | self.training_label = trn_lb 19 | self.test_set = tst_set 20 | self.test_label = tst_lb 21 | self.train = {'data':[],'label':[]} 22 | self.dev = {'data':[],'label':[]} 23 | self.test = {} 24 | self.normalizeRange([0,1]) 25 | #self.normalizeAll() 26 | 27 | def partition(self,partial): 28 | length = self.training_set.shape[1] 29 | len_of_train = int(length * partial) 30 | len_of_dev = length - len_of_train 31 | self.train['data'] = self.training_set[:,:len_of_train] 32 | self.train['label'] = self.training_label[:len_of_train,:] 33 | self.dev['data'] = self.training_set[:,-len_of_dev:] 34 | self.dev['label'] = self.training_label[-len_of_dev:,:] 35 | 36 | def normalizeAll(self): 37 | metrix_X = self.training_set 38 | if len(self.test_set) != 0: 39 | metrix_X = np.concatenate((self.training_set,self.test_set),1) 40 | mean_X = np.sum(metrix_X,1)*1.0/metrix_X.shape[1] 41 | mean_X = mean_X.reshape(metrix_X.shape[0],1) 42 | metrix_X = metrix_X-mean_X 43 | sigma = np.sum(metrix_X**2,1)*1.0/metrix_X.shape[1] 44 | sigma = np.sqrt(sigma).reshape(metrix_X.shape[0],1) 45 | metrix_X = metrix_X/sigma 46 | self.training_set = metrix_X[:,:self.training_set.shape[1]] 47 | if len(self.test_set) != 0: 48 | self.test_set = metrix_X[:,-(self.test_set.shape[1]):] 49 | self.test['data'] = self.test_set 50 | self.test['label'] = self.test_label 51 | 52 | def normalizeRange(self,feature_list): 53 | metrix_X = self.training_set 54 | if len(self.test_set) != 0: 55 | metrix_X = np.concatenate((self.training_set,self.test_set),1) 56 | mean_X = np.sum(metrix_X,1)*1.0/metrix_X.shape[1] 57 | mean_X = mean_X.reshape(metrix_X.shape[0],1) 58 | metrix_X = metrix_X-mean_X 59 | sigma = np.sum(metrix_X**2,1)*1.0/metrix_X.shape[1] 60 | sigma = np.sqrt(sigma).reshape(metrix_X.shape[0],1) 61 | metrix_X = metrix_X/sigma 62 | self.training_set[feature_list,:] = metrix_X[feature_list,:self.training_set.shape[1]] 63 | if len(self.test_set) != 0: 64 | self.test_set = metrix_X[:,-(self.test_set.shape[1]):] 65 | self.test['data'] = self.test_set 66 | self.test['label'] = self.test_label 67 | 68 | class NeuroLayer: 69 | def __init__(self,name,num_units,alpha,**Dropout): 70 | self.name = name 71 | self.num_units = num_units 72 | self.alpha = alpha 73 | self.weights = "nan" 74 | self.inputs = "nan" 75 | self.act = "nan" 76 | self.derivative_Z = "nan" 77 | self.delta = "nan" 78 | #For L2 regularition 79 | self.lmbda = 0.0 80 | #For Dropout regularition 81 | self.keep_ratio = 1.0 82 | #单层dropout入口 83 | if Dropout.get('Dropout') != None: 84 | self.regularizationDropout(Dropout['Dropout']) 85 | else: 86 | self.keep_ratio = 1.0 87 | 88 | def activate(self,Z): 89 | A = 1.0/(1+np.exp(-Z)) 90 | return A 91 | 92 | def computeA(self,input_x): 93 | assert(self.weights.shape[1] == input_x.shape[0]) 94 | self.inputs = input_x 95 | z=np.dot(self.weights,input_x) 96 | self.act = self.activate(z) 97 | #for drop out 98 | dropVec = np.random.rand(self.act.shape[0],self.act.shape[1]) <= self.keep_ratio 99 | self.act = np.multiply(self.act,dropVec)*1.0/self.keep_ratio 100 | 101 | def computeDZ(self,input_delta): 102 | derivative_A_on_Z = self.act*(1-self.act) 103 | assert(input_delta.shape == derivative_A_on_Z.shape) 104 | self.derivative_Z = input_delta*derivative_A_on_Z 105 | 106 | def computeLoss(self,input_y): 107 | self.derivative_Z = self.act - input_y.T 108 | 109 | def computeDelta(self): 110 | assert(self.weights.shape[0] == self.derivative_Z.shape[0]) 111 | self.delta = np.dot(self.weights.T,self.derivative_Z) 112 | self.delta = np.delete(self.delta, (-1), axis=0) 113 | 114 | def updataWeights(self): 115 | DW = np.dot(self.derivative_Z,self.inputs.T)*1.0/self.inputs.shape[1] 116 | # self.DW use for gradient check ONLY 117 | self.DW = DW 118 | assert(DW.shape == self.weights.shape) 119 | self.weights = (1.0 - (self.lmbda/self.inputs.shape[1]))*self.weights - self.alpha * DW 120 | 121 | def initParams(self,last_layer_units,**regularization): 122 | #self.weights = np.random.randn(self.num_units,last_layer_units+1) 123 | #add exploding/vanishing avoidance 124 | self.weights = np.random.randn(self.num_units,last_layer_units+1)*np.sqrt(1.0/last_layer_units) 125 | #全局L2正则 126 | if regularization.get('L2') != None: 127 | self.regularizationL2(regularization['L2']) 128 | #全局dropout入口 129 | if regularization.get('Dropout') != None: 130 | self.regularizationDropout(regularization['Dropout']) 131 | 132 | def regularizationL2(self,lmbda): 133 | self.lmbda = lmbda 134 | 135 | def regularizationDropout(self,keep_ratio): 136 | self.keep_ratio = keep_ratio 137 | 138 | class NeuroNet: 139 | def __init__(self, data, **arguments): 140 | #train/test set is arranged by (num_of_feature, num_of_dataset) 141 | #train/test label is vertical vector, namey (num_of_dataset, 1) 142 | self.train_set = data.train['data'] 143 | self.train_label = data.train['label'] 144 | self.test_set = data.dev['data'] 145 | self.test_label = data.dev['label'] 146 | #useful while initialize the layers 147 | self.num_of_dataset = self.train_set.shape[1] 148 | self.num_of_feature = self.train_set.shape[0] 149 | self.layers = [] 150 | #for regularizaiton 151 | #earlytop for Net only 152 | self.early_stop = False 153 | if arguments.get('Earlystop') != None: 154 | self.early_stop = arguments['Earlystop'] 155 | #for global dropout 156 | self.keep_ratio = 1.0 157 | #for global L2 158 | self.L2 = 0.0 159 | if arguments.get('L2') != None: 160 | self.L2 = arguments['L2'] 161 | #for gradient check 162 | if arguments.get('GradCheck') == True: 163 | self.gradient_check = True 164 | 165 | def addLayer(self,name,num_units,alpha,**arguments): 166 | if arguments.get('Dropout') != None: 167 | self.keep_ratio = arguments['Dropout'] 168 | layer = NeuroLayer(name,num_units,alpha,Dropout = self.keep_ratio) 169 | self.layers.append(layer) 170 | 171 | def initLayers(self): 172 | last_layer_units = self.num_of_feature 173 | for layer in self.layers: 174 | layer.initParams(last_layer_units,L2 = self.L2) 175 | last_layer_units = layer.num_units 176 | 177 | def forward(self,input_x): 178 | #print "forward" 179 | feed_data = input_x 180 | for layer in self.layers: 181 | #add bias 182 | new_row = np.ones((1,feed_data.shape[1])) 183 | feed_data = np.row_stack((feed_data,new_row)) 184 | layer.computeA(feed_data) 185 | feed_data = layer.act 186 | 187 | def backwark(self,input_y): 188 | layers = self.layers[::-1] 189 | delta = "nan" 190 | for layer in layers: 191 | if layer.name == "output": 192 | layer.computeLoss(input_y) 193 | else: 194 | layer.computeDZ(delta) 195 | layer.computeDelta() 196 | delta = layer.delta 197 | layer.updataWeights() 198 | 199 | def train(self,epoch_limits): 200 | print "training start..." 201 | early_stop_counter = 0 202 | for i in xrange(epoch_limits): 203 | if i == 10 and self.gradient_check: 204 | print("gradient diff is %f"%self.gradientCheck()) 205 | break; 206 | self.forward(self.train_set) 207 | self.backwark(self.train_label) 208 | print("training %05d epoch: \n\tprecision on train %02.02f \n\tprecision on test %02.02f"%(i+1,self.stats("train"),self.stats("test"))) 209 | #simple early stop 210 | if self.early_stop == True: 211 | if (self.stats("train") - self.stats("test")) > 0.05*self.stats("test"): 212 | early_stop_counter += 1 213 | if early_stop_counter > 10: 214 | print("Early stop working...stoping train") 215 | break; 216 | else: 217 | early_stop_counter = 0 218 | 219 | 220 | def stats(self,type_of_dataset): 221 | if type_of_dataset == "train": 222 | data = self.train_set 223 | label = self.train_label 224 | else: 225 | data = self.test_set 226 | label = self.test_label 227 | self.forward(data) 228 | layer = self.layers[-1] 229 | y = layer.act 230 | y[y > 0.5] = 1 231 | y[y <= 0.5] = 0 232 | return sum(y.T==label)*1.0/label.shape[0] 233 | 234 | def predict(self): 235 | self.forward(self.test_set) 236 | layer = self.layers[-1] 237 | y = layer.act 238 | y[y > 0.5] = 1 239 | y[y <= 0.5] = 0 240 | print y 241 | return sum(y.T==self.test_label)*1.0/self.test_label.shape[0],y 242 | 243 | def computeCost(self,label): 244 | layer = self.layers[-1] 245 | y = layer.act 246 | # y has shape [N_of_output_layer,Number_of_batch_size] 247 | cost_matrix = np.multiply(label,label - y.T) 248 | cost = np.sum(cost_matrix)*1.0/label.shape[0] 249 | return cost 250 | 251 | def gradientCheck(self): 252 | print("Checking Gradient...") 253 | epsilon = pow(10,-7) 254 | DW_all = {} 255 | DW_Numerical_all = {} 256 | diff = 0.0 257 | num_of_weights = 0 258 | for layer in self.layers: 259 | DW_all[layer.name] = layer.DW 260 | DW_Numerical_all[layer.name] = np.zeros((layer.DW.shape[0],layer.DW.shape[1])) 261 | for layer in self.layers: 262 | for i in range(layer.weights.shape[0]): 263 | for j in range(layer.weights.shape[1]): 264 | num_of_weights = num_of_weights + 1 265 | W_ij = layer.weights[i][j] 266 | layer.weights[i][j] = W_ij + epsilon 267 | self.forward(self.train_set) 268 | Up = self.computeCost(self.train_label)+layer.lmbda*( layer.weights[i][j]**2 )/2.0/self.train_set.shape[1] 269 | layer.weights[i][j] = W_ij - epsilon 270 | self.forward(self.train_set) 271 | Down = self.computeCost(self.train_label)+layer.lmbda*( layer.weights[i][j]**2 )/2.0/self.train_set.shape[1] 272 | DW_Numerical_all[layer.name][i][j] = (Up-Down)/2.0/epsilon 273 | layer.weights[i][j] = W_ij 274 | #add the diff in this layer 275 | diff = diff + np.sum((DW_all[layer.name]-DW_Numerical_all[layer.name])**2) 276 | self.DW_Numerical_all = DW_Numerical_all 277 | self.DW_all = DW_all 278 | return diff/( sum(DW_all**2) ) 279 | 280 | def loadData(): 281 | ''' 282 | 读取数据 283 | -- X为训练集，组织形式：每行一个样本，列个数即特征维度 284 | -- y为训练集标签，与训练集逐行对应 285 | -- Tx,Ty为测试集，同理 286 | ''' 287 | train_set = pd.read_csv("X.csv",header=None) 288 | train_label = pd.read_csv("y.csv",header=None) 289 | test_set = pd.read_csv("Tx.csv",header=None) 290 | test_label = pd.read_csv("Ty.csv",header=None) 291 | data = DataSet(train_set.values.T,train_label.values,test_set.values.T,test_label.values) 292 | data.normalizeRange([0,1]) 293 | data.partition(0.9) 294 | return data 295 | 296 | def buildNet(): 297 | data = loadData() 298 | #根据课程内容，将数据集转置，调整成每列一个样本 299 | #标签集保持列向量形式 300 | #定义网络，选择是否Earlystop，设定全局L2正则化参数lambda;（可选全局化Dropout: Dropout = neuro_keep_ratio） 301 | #只在Debug时选择 GradCheck = True，非常耗时 302 | net = NeuroNet(data,Earlystop = True,L2 = 20,GradCheck = True) 303 | net.addLayer("first",100,0.01) 304 | #net.addLayer("second",80,0.01) 305 | #net.addLayer("third",60,0.01) 306 | #定义某一层（名称，节点数，学习率，Dropout=neuro_keep_ratio） 307 | #net.addLayer("forth",40,0.02,Dropout = 0.8) 308 | net.addLayer("fifth",20,0.01) 309 | net.addLayer("output",1,0.01) 310 | net.initLayers() 311 | return net 312 | 313 | def dothework(): 314 | #创建神经网络 315 | net = buildNet() 316 | print("build success,net have %d layers"%len(net.layers)) 317 | #迭代训练 5000次 318 | net.train(20) 319 | 320 | if __name__ == "__main__": 321 | dothework() 322 | --------------------------------------------------------------------------------