def model(X, Y, learning_rate=0.05, num_iterations=100000, print_cost=True, lambd=0): grads = {} costs = [] m = X.shape[1] layers_dims = [X.shape[0], 50, 20, 1] #print(layers_dims) parameters = initialize_parameters(layers_dims) #print(parameters) for i in range(0, num_iterations): a3, cache = forward_propagation(X, parameters) cost = compute_cost_with_regularization(a3, Y, parameters, lambd) grads = backward_propagation_with_regularization(X, Y, cache, lambd) parameters = update_parameters(parameters, grads, learning_rate) if print_cost and i % 1000 == 0: print("Cost after iteration {}: {}".format(i, cost)) if print_cost and i % 10 == 0: costs.append(cost) # plot the cost plt.plot(costs) plt.ylabel('cost') plt.xlabel('iterations (x1,000)') plt.title("Learning rate =" + str(learning_rate)) plt.show() return parameters
def model(X, Y, learning_rate=0.3, num_iterations=30000, print_cost=True, is_plot=True, lambd=0, keep_prob=1): grads = {} costs = [] #params = {} m = X.shape[0] layer_dims = [X.shape[0], 20, 3, 1] # initialize parameters params = reg_utils.initialize_parameters(layer_dims) # Training for i in range(num_iterations): # Forward Prop if keep_prob == 1: a3, cache = reg_utils.forward_propagation(X, params) elif keep_prob < 1: a3, cache = forward_propagation_with_dropout(X, params, keep_prob) else: print("Wrong keep_prob value. Try again.") exit # Compute cost if lambd == 0: cost = reg_utils.compute_cost(a3, Y) else: cost = compute_cost_with_regularization(a3, Y, params, lambd) # Back prop if (lambd == 0 and keep_prob == 1): grads = reg_utils.backward_propagation(X, Y, cache) elif lambd != 0: grads = backward_propagation_with_regularization( X, Y, cache, lambd) elif keep_prob < 1: grads = backward_propagation_with_dropout(X, Y, cache, keep_prob) # update parameters params = reg_utils.update_parameters(params, grads, learning_rate) # print cost if (i % 1000 == 0): costs.append(cost) if (print_cost and i % 10000) == 0: print("Iteration " + str(i) + ": " + str(cost)) # Plot cost curve if is_plot: plt.plot(costs) plt.ylabel('cost') plt.xlabel('#iterations') plt.title('learning rate=' + str(learning_rate)) plt.show() return params
def model(X, Y, learning_rate=0.3, num_iterations=30000, print_cost=True, lambd=0, keep_prob=1): grads = {} costs = [] # to keep track of the cost m = X.shape[1] # number of examples layers_dims = [X.shape[0], 20, 3, 1] # Initialize parameters dictionary. parameters = initialize_parameters(layers_dims) # Loop (gradient descent) for i in range(0, num_iterations): # Forward propagation: LINEAR -> RELU -> LINEAR -> RELU -> LINEAR -> SIGMOID. if keep_prob == 1: a3, cache = forward_propagation(X, parameters) elif keep_prob < 1: a3, cache = forward_propagation_with_dropout( X, parameters, keep_prob) # Cost function if lambd == 0: cost = compute_cost(a3, Y) else: cost = compute_cost_with_regularization(a3, Y, parameters, lambd) # Backward propagation. assert (lambd == 0 or keep_prob == 1 ) # it is possible to use both L2 regularization and dropout, # but this assignment will only explore one at a time if lambd == 0 and keep_prob == 1: grads = backward_propagation(X, Y, cache) elif lambd != 0: grads = backward_propagation_with_regularization( X, Y, cache, lambd) elif keep_prob < 1: grads = backward_propagation_with_dropout(X, Y, cache, keep_prob) # Update parameters. parameters = update_parameters(parameters, grads, learning_rate) # Print the loss every 10000 iterations if print_cost and i % 10000 == 0: print("Cost after iteration {}: {}".format(i, cost)) if print_cost and i % 1000 == 0: costs.append(cost) # plot the cost plt.plot(costs) plt.ylabel('cost') plt.xlabel('iterations (x1,000)') plt.title("Learning rate =" + str(learning_rate)) plt.show() return parameters
def model(X,Y,learning_rate=0.3,num_iterations=30000,print_cost=True,is_plot=True,lambd=0,keep_prob=1): """ 实现一个三层神经网络:LINEAR->RELU->LINEAR->RELU->LINEAR->SIGMOID 参数: X -输入的数据,维度(2,训练/测试的数量) Y -标签[0(蓝色)|1(红色)],维度为(1,对应输入数据的标签) lambd -正则化的超参数,实数 keep_prob 随机删除节点的概率 返回: parameters -学习后的参数 """ grads={} costs=[] m=X.shape[0] layers_dims=[X.shape[0],20,3,1] parameters=reg_utils.initialize_parameters(layers_dims) for i in range(0,num_iterations): #forward propagation if keep_prob==1: a3,cache=reg_utils.forward_propagation(X,parameters) elif keep_prob<1: a3,cache=forward_propagation_with_dropout(X,parameters,keep_prob) else: print("keep_prob error,quit!") exit if lambd==0: cost=reg_utils.compute_cost(a3,Y) else: cost=compute_cost_with_regularization(a3,Y,parameters,lambd) #backward propagation assert(lambd==0 or keep_prob==1) if(lambd==0 and keep_prob==1): grads=reg_utils.backward_propagation(X,Y,cache) elif lambd!=0: grads=backward_propagation_with_regularization(X,Y,cache,lambd) elif keep_prob<1: grads=backward_propagation_with_dropout(X,Y,cache,keep_prob) parameters=reg_utils.update_parameters(parameters,grads,learning_rate) if i%1000==0:# print cost costs.append(cost) if(print_cost and i%10000==0): print("number time"+str(i)+" cost is "+str(cost)) if is_plot: plt.plot(costs) plt.ylabel('cost') plt.xlabel('iterations(*1000)') plt.title('Learing rate='+str(learning_rate)) plt.show() return parameters
def model(X, Y, learning_rate = 0.3, num_iterations = 30000, print_cost = True, lambd = 0, keep_prob = 1): """ Implements a three-layer neural network: LINEAR->RELU->LINEAR->RELU->LINEAR->SIGMOID. Arguments: X -- input data, of shape (input size, number of examples) Y -- true "label" vector (1 for blue dot / 0 for red dot), of shape (output size, number of examples) learning_rate -- learning rate of the optimization num_iterations -- number of iterations of the optimization loop print_cost -- If True, print the cost every 10000 iterations lambd -- regularization hyperparameter, scalar keep_prob - probability of keeping a neuron active during drop-out, scalar. Returns: parameters -- parameters learned by the model. They can then be used to predict. """ grads = {} layers_dims = [X.shape[0], 20, 3, 1] parameters = initialize_parameters(layers_dims) for i in range(0, num_iterations): if keep_prob == 1: a3, cache = forward_propagation(X, parameters) elif keep_prob < 1: a3, cache = forward_propagation_with_dropout(X, parameters, keep_prob) if lambd == 0: cost = compute_cost(a3, Y) else: cost = compute_cost_with_regularization(a3, Y, parameters, lambd) if lambd == 0 and keep_prob == 1: grads = backward_propagation(X, Y, cache) elif lambd != 0: grads = backward_propagation_with_regularization(X, Y, cache, lambd) elif keep_prob < 1: grads = backward_propagation_with_dropout(X, Y, cache, keep_prob) parameters = update_parameters(parameters, grads, learning_rate) if print_cost and i % 10000 == 0: print("Cost after iteration {}: {}".format(i, cost)) if print_cost and i % 1000 == 0: costs.append(cost) plt.plot(costs) plt.ylabel('cost') plt.xlabel('iterations (x1,000)') plt.title("Learning rate =" + str(learning_rate)) plt.show() return parameters
def model(X, Y, learning_rate=0.3, num_iterations=30000, print_cost=True, is_plot=True, lambd=0, keep_prob=1): losses = [] layers_dims = [X.shape[0], 20, 3, 1] # 选择初始化参数的类型 parameters = reg_utils.initialize_parameters(layers_dims) for i in range(num_iterations): # 前向传播 if keep_prob == 1: A3, cache = reg_utils.forward_propagation(X, parameters) else: A3, cache = regulation.forward_propagation_drop( X, parameters, keep_prob) # 计算Loss if lambd == 0: loss = reg_utils.compute_cost(A3, Y) else: loss = regulation.compute_cost_l2(A3, Y, parameters, lambd) # 反向传播 if keep_prob == 1 and lambd == 0: gradients = reg_utils.backward_propagation(X, Y, cache) elif keep_prob != 1: gradients = regulation.backward_propagation_drop( X, Y, cache, keep_prob) elif lambd != 0: gradients = regulation.backward_propagation_l2(X, Y, cache, lambd) # 更新权重 parameters = reg_utils.update_parameters(parameters, gradients, learning_rate) if i % 1000 == 0: losses.append(loss) # 打印成本 if (print_cost and i % 10000 == 0): print("第" + str(i) + "次迭代,成本值为:" + str(loss)) # 学习完毕,绘制成本曲线 if is_plot: plt.plot(losses) plt.ylabel('cost') plt.xlabel('iterations (per hundreds)') plt.title("Learning rate =" + str(learning_rate)) plt.show() # 返回学习完毕后的参数 return parameters
def model(X, Y, learning_rate=0.3, num_iterations=30000, print_cost=True, lambd=0, keep_prob=1): grads = {} costs = [] m = X.shape[1] layers_dims = [X.shape[0], 20, 3, 1] parameters = initialize_parameters(layers_dims) for i in range(0, num_iterations): if keep_prob == 1: a3, cache = forward_propagation(X, parameters) elif keep_prob < 1: a3, cache = forward_propagation_with_dropout( X, parameters, keep_prob) if lambd == 0: cost = compute_cost(a3, Y) else: cost = compute_cost_with_regularization(a3, Y, parameters, lambd) assert (lambd == 0 or keep_prob == 1) if lambd == 0 and keep_prob == 1: grads = backward_propagation(X, Y, cache) elif lambd != 0: grads = backward_propagation_with_regularization( X, Y, cache, lambd) elif keep_prob < 1: grads = backward_propagation_with_dropout(X, Y, cache, keep_prob) parameters = update_parameters(parameters, grads, learning_rate) if print_cost and i % 10000 == 0: print("Cost after iteration {}: {}".format(i, cost)) if print_cost and i % 1000 == 0: costs.append(cost) plt.plot(costs) plt.ylabel('cost') plt.xlabel('iterations (x1,000)') plt.title("Learning rate =" + str(learning_rate)) plt.show() return parameters
def model(X, Y, layer_dims, keep_prob, lamda, learning_rate, num_iteration, norm=False): parameters = initialize_parameters(layer_dims) if norm == False and keep_prob == 1: for i in range(num_iteration): AL, cache = forward_propagation(X, parameters) grads = backward_propagation(X, Y, cache) parameters = update_parameters(parameters, grads, learning_rate) if i % 1000 == 0: cost = compute_cost(AL, Y) print(f'cost after {i} iteration:{cost}') return parameters if norm == False and keep_prob != 1: for i in range(num_iteration): AL, cache = drop_forward(X, parameters, keep_prob) grads = back_dropout(Y, AL, cache, keep_prob) parameters = update_parameters(parameters, grads, learning_rate) if i % 1000 == 0: cost = compute_cost(AL, Y) print(f'cost after{i} iterations:{cost}') return parameters if norm == True and keep_prob == 1: for i in range(num_iteration): AL, cache = forward_propagation(X, parameters) grads = l2_back_propagation(X, Y, AL, cache, lamda) parameters = update_parameters(parameters, grads, learning_rate) if i % 1000 == 0: cost = compute_l2_cost(AL, Y, parameters, lamda) print(f'cost after {i} iteration:{cost}') return parameters
def model(X,Y,learning_rate=0.3,num_iterations=30000,print_cost=True,is_plot=True,lambd=0,keep_prob=1): grads={} costs=[] m=X.shape[1] layers_dims=[X.shape[0],20,3,1] # 每一层的维度 parameters=reg_utils.initialize_parameters(layers_dims) for i in range(0,num_iterations): # 前向传播,计算A3 if keep_prob==1: # 执行正常的前向传播 a3,cache=reg_utils.forward_propagation(X,parameters) elif keep_prob<1: # 执行dropout,随机失活结点 a3,cache=forward_propagation_with_dropout(X,parameters,keep_prob) else : print("keep_prob参数错误,程序退出") exit # 计算Cost if lambd==0: # 不使用正则化 cost=reg_utils.compute_cost(a3,Y) else: # 使用L2正则化 cost=compute_cost_with_regularization(a3,Y,parameters,lambd) assert(lambd==0 or keep_prob==1) # 反向传播,计算梯度 if (lambd==0 and keep_prob==1): # 不使用L2正则化和Dropout grads=reg_utils.backward_propagation(X,Y,cache) elif lambd!=0:# 使用L2正则化,不使用随机删除结点 grads=backward_propagation_with_regularization(X,Y,cache,lambd) elif keep_prob<1: # 使用dropout随机删除结点,不使用L2正则化 grads=backward_propagation_with_dropout(X,Y,cache,keep_prob) # 更新参数 parameters=reg_utils.update_parameters(parameters,grads,learning_rate) if i % 1000==0: costs.append(cost) if print_cost: print("第"+str(i)+"次迭代,成本值为"+str(cost)) if is_plot: plt.plot(costs) plt.ylabel('cost') plt.xlabel('iteration (per 100)') plt.title('learning_rate='+str(learning_rate)) plt.show() return parameters
def model(X, Y, learning_rate = 0.3, num_iterations = 30000, print_cost = True, lambd = 0, keep_prob = 1): """ Implements a three-layer neural network: LINEAR->RELU->LINEAR->RELU->LINEAR>SIGMOID. Arguments: X -- input data, of shape (input size, number of examples) Y -- true "label" vector (1 for blue dot / 0 for red dot), of shape (output size, number of examples) learning_rate -- learning rate of the optimization num_iterations -- number of iterations of the optimization loop print_cost -- If True, print the cost every 10000 iterations lambd -- regularization hyperparameter, scalar lambd -- regularization hyperparameter, scalar keep_prob - probability of keeping a neuron active during drop-out, scalar. Returns: parameters -- parameters learned by the model. They can then be used to pred ict. """ grads = {} costs = [] # to keep track of the cost m = X.shape[1] # number of examples layers_dims = [X.shape[0], 20, 3, 1] # Initialize parameters dictionary. parameters = initialize_parameters(layers_dims) # Loop (gradient descent) for i in range(0, num_iterations): # Forward propagation: LINEAR -> RELU -> LINEAR -> RELU -> LINEAR -> SIG MOID. if keep_prob == 1: a3, cache = forward_propagation(X, parameters) elif keep_prob < 1: a3, cache = forward_propagation_with_dropout(X, parameters, keep_prob) # Cost function if lambd == 0: cost = compute_cost(a3, Y) else: cost = compute_cost_with_regularization(a3, Y, parameters, lambd) # Backward propagation. assert(lambd==0 or keep_prob==1) # it is possible to use both L2 regu larization and dropout, # but this assignment will only expl ore one at a time if lambd == 0 and keep_prob == 1: grads = backward_propagation(X, Y, cache) elif lambd != 0: grads = backward_propagation_with_regularization(X, Y, cache, lambd) elif keep_prob < 1: grads = backward_propagation_with_dropout(X, Y, cache, keep_prob) # Update parameters. parameters = update_parameters(parameters, grads, learning_rate) # Print the loss every 10000 iterations if print_cost and i % 10000 == 0: print("Cost after iteration {}: {}".format(i, cost)) if print_cost and i % 1000 == 0: costs.append(cost) # plot the cost plt.plot(costs) plt.ylabel('cost') plt.xlabel('iterations (x1,000)') plt.title("Learning rate =" + str(learning_rate)) plt.show() return parameters
def model(X, Y, learning_rate=0.3, num_iterations=30000, print_cost=True, lambd=0, keep_prob=1): grads = {} costs = [] m = X.shape[1] layer_dims = [X.shape[0], 20, 3, 1] parameters = initialize_parameters(layer_dims) for i in range(num_iterations): if keep_prob == 1: A3, cache = forward_propagation(X, parameters) elif keep_prob < 1: A3, cache = forward_propagation_with_dropout( X, parameters, keep_prob) if lambd == 0: cost = compute_cost(A3, Y) else: cost = compute_cost_with_regulations(A3, Y, parameters, lambd) assert (lambd == 0 or keep_prob == 1) if lambd == 0 and keep_prob == 1: grads = backward_propagation(X, Y, cache) elif lambd != 0: grads = backward_propagation_with_regularization( X, Y, cache, lambd) elif keep_prob < 1: grads = backward_propagation_with_dropout(X, Y, cache, keep_prob) parameters = update_parameters(parameters, grads, learning_rate) if print_cost and i % 1000 == 0: print("Cost After iterations {} : {}".format(i, cost)) costs.append(cost) plt.plot(costs) plt.title("Learning rate = " + str(learning_rate)) plt.ylabel("Cost") plt.xlabel("iterations(x1,000)") #plt.show() plt.savefig('/home/guanlingh/local2server/homework6/image/h6-2.jpg') return parameters
def model(X, Y, learning_rate = 0.3, num_iterations = 30000, print_cost = True, lambd = 0, keep_prob = 1): """ Implements a three-layer neural network: LINEAR->RELU->LINEAR->RELU->LINEAR->SIGMOID. Arguments: X -- input data, of shape (input size, number of examples) Y -- true "label" vector (1 for blue dot / 0 for red dot), of shape (output size, number of examples) learning_rate -- learning rate of the optimization num_iterations -- number of iterations of the optimization loop print_cost -- If True, print the cost every 10000 iterations lambd -- regularization hyperparameter, scalar keep_prob - probability of keeping a neuron active during drop-out, scalar. Returns: parameters -- parameters learned by the model. They can then be used to predict. """ grads = {} costs = [] # to keep track of the cost m = X.shape[1] # number of examples layers_dims = [X.shape[0], 20, 3, 1] # Initialize parameters dictionary. parameters = initialize_parameters(layers_dims) # Loop (gradient descent) for i in range(0, num_iterations): # Forward propagation: LINEAR -> RELU -> LINEAR -> RELU -> LINEAR -> SIGMOID. if keep_prob == 1: a3, cache = forward_propagation(X, parameters) elif keep_prob < 1: a3, cache = forward_propagation_with_dropout(X, parameters, keep_prob) # Cost function if lambd == 0: cost = compute_cost(a3, Y) else: cost = compute_cost_with_regularization(a3, Y, parameters, lambd) # Backward propagation. assert(lambd==0 or keep_prob==1) # it is possible to use both L2 regularization and dropout, # but this assignment will only explore one at a time if lambd == 0 and keep_prob == 1: grads = backward_propagation(X, Y, cache) elif lambd != 0: grads = backward_propagation_with_regularization(X, Y, cache, lambd) elif keep_prob < 1: grads = backward_propagation_with_dropout(X, Y, cache, keep_prob) # Update parameters. parameters = update_parameters(parameters, grads, learning_rate) # Print the loss every 10000 iterations if print_cost and i % 10000 == 0: print("Cost after iteration {}: {}".format(i, cost)) if print_cost and i % 1000 == 0: costs.append(cost) # plot the cost plt.plot(costs) plt.ylabel('cost') plt.xlabel('iterations (x1,000)') plt.title("Learning rate =" + str(learning_rate)) plt.show() return parameters
"db1": db1 } return gradients parameters = model(train_X, train_Y, lambd=0.3) print("On the training set:") predictions_train = predict(train_X, train_Y, parameters) xx = np.arange(-10, 20.1, 0.05) yy = np.arange(-10, 20.1, 0.05) X, Y = np.meshgrid(xx, yy) strain_a = np.reshape(X, (-1, 1)) strain_b = np.reshape(Y, (-1, 1)) test_X = np.append(strain_a, strain_b, axis=1).T a3, cache = forward_propagation(test_X, parameters) Z = (a3 > 0.5) Z = Z.reshape(X.shape) #plt.title("Intersection contour of 1T' and 1T ") plt.ylabel('b(%)') plt.xlabel('a(%)') plt.contourf(X, Y, Z, cmap=plt.cm.Spectral) plt.scatter(train_X[0, :], train_X[1, :], c=np.reshape(train_Y, (-1, )), cmap=plt.cm.Spectral) plt.show() #print(parameters['W1'])
def model(X,Y,learning_rate = 0.3,num_iterations = 30000,print_cost = True,is_plot = True,lambd = 0,keep_prob = 1): ''' 实现一个三层的神经网络:linear->relu->linear->relu->linear->sigmoid :param X: 输入的数据,维度为(2,要训练/测试的数量) :param Y: 标签,[0(蓝色)|1(红色)],维度为(1,对应的是输入的数据的标签) :param learing_rate: 学习速率 :param num_iterations: 迭代次数 :param print_cost: 是否打印成本值 :param lambd: 正则化的超参数,实数 :param keep_prob: 随机删除节点的概率 :return: parameters-学习后的参数 ''' grads = {} costs = [] m = X.shape[1] layers_dims = [X.shape[0],20,3,1] #初始化参数 parameters = reg_utils.initialize_parameters(layers_dims) #开始学习 for i in range(0,num_iterations): #前向传播 ##是否删除随机节点 if keep_prob == 1: ###不删除随机节点 a3,cache = reg_utils.forward_propagation(X,parameters) elif keep_prob<1: ###随即删除节点 a3 , cache = forward_propagation_with_dropout(X,parameters,keep_prob) else: print('keep_prob参数错误,程序退出.') exit #计算成本 ##是否使用二范数 if lambd == 0: ###不使用L2正则化 cost = reg_utils.compute_cost(a3,Y) else: ###使用L2正则化 cost = compute_cost_with_regularization(a3,Y,parameters,lambd) ##反向传播 ##可以同时使用L2正则化和随机删除节点,但本次实验不同时使用 assert(lambd == 0 or keep_prob == 1) ##两个参数的使用情况 if(lambd == 0 and keep_prob == 1): ###不适用L2正则化和不使用随即删除节点 grads = reg_utils.backward_propagation(X,Y,cache) elif lambd!=0: ###使用L2正则化,不使用随即删除节点 grads = backward_propagation_with_regularization(X,Y,cache,lambd) elif keep_prob<1: ###使用随即删除节点,不使用L2正则化 grads = backward_propagation_with_dropout(X,Y,cache,keep_prob) #更新参数 parameters = reg_utils.update_parameters(parameters,grads,learning_rate) #记录并打印成本 if i%1000 == 0: ##记录成本 costs.append(cost) if(print_cost and i%10000==0): #打印成本 print('第'+str(i)+'次迭代,成本值为:'+str(cost)) #是否绘制成本曲线图 if is_plot: plt.plot(costs) plt.ylabel('cost') plt.xlabel('iterations(x1,000)') plt.title('Learning rate = '+str(learning_rate)) plt.show() #返回学习后的参数 return parameters
def model(X, Y, learning_rate = 0.3, num_iterations = 30000, print_cost = True, is_plot = True, lambd = 0, keep_prob = 1): """ 实现一个三层的神经网络:ReLU->ReLU->Sigmoid :param lambd:正则化的超参数 :param keep_prob:随机删除结点的概率 :return: parameters - 学习后的参数 """ parameter = {} grads = {} costs = [] m = X.shape[1] layers_dims = [X.shape[0], 20, 3, 1] # 初始化参数 parameters = reg_utils.initialize_parameters(layers_dims) for l in range(num_iterations): # 前向传播 # 是否随机删除结点 if keep_prob == 1: # 前向传播 a3, cache = reg_utils.forward_propagation(X, parameters) elif keep_prob < 1: a3, cache = forward_propagation_with_dropout(X, parameters, keep_prob) else: print("keep_prob参数错误!程序退出") exit() # 计算成本 # 是否使用正则化 if lambd == 0: cost = reg_utils.compute_cost(a3, Y) else: cost = compute_cost_with_regularization(a3, Y, parameters, lambd) if l % 1000 == 0: costs.append(cost) if print_cost: print(f'第{l}次迭代,成本值为:{cost}') # 反向传播 # 可以同时使用L2正则化和随机删除节点,但本次实验不同时使用 assert(lambd == 0 or keep_prob == 1) if lambd == 0 and keep_prob == 1: # 不使用L2正则化和随机删除节点 grads = reg_utils.backward_propagation(X, Y, cache) elif lambd != 0: # 使用L2正则化,不使用dropout grads = backward_propagation_with_regularization(X, Y, cache, lambd) elif keep_prob < 1: # 使用dropout,不使用L2正则化 grads = backward_propagation_with_dropout(X, Y, cache, keep_prob) # 更新参数 parameters = reg_utils.update_parameters(parameters, grads, learning_rate) if is_plot: plt.plot(costs) plt.ylabel('cost') plt.xlabel('iterations (x1,000)') plt.title("Learning rate =" + str(learning_rate)) plt.show() return parameters
def model(X, Y, learning_rate=0.3, num_iterations=30000, print_cost=True, is_plot=True, lambd=0, keep_prob=1): """ 实现一个三层的神经网络:LINEAR ->RELU -> LINEAR -> RELU -> LINEAR -> SIGMOID 参数: X - 输入的数据,维度为(2, 要训练/测试的数量) Y - 标签,【0(蓝色) | 1(红色)】,维度为(1,对应的是输入的数据的标签) learning_rate - 学习速率 num_iterations - 迭代的次数 print_cost - 是否打印成本值,每迭代10000次打印一次,但是每1000次记录一个成本值 is_polt - 是否绘制梯度下降的曲线图 lambd - 正则化的超参数,实数 keep_prob - 随机删除节点的概率 返回 parameters - 学习后的参数 """ grads = {} costs = [] m = X.shape[1] layers_dims = [X.shape[0], 20, 3, 1] # 初始化参数 parameters = reg_utils.initialize_parameters(layers_dims) # 开始学习 for i in range(0, num_iterations): # 前向传播 ##是否随机删除节点 if keep_prob == 1: ###不随机删除节点 a3, cache = reg_utils.forward_propagation(X, parameters) elif keep_prob < 1: ###随机删除节点 a3, cache = reg_utils.forward_propagation_with_dropout(X, parameters, keep_prob) else: print("keep_prob参数错误!程序退出。") exit # 计算成本 ## 是否使用二范数 if lambd == 0: ###不使用L2正则化 cost = reg_utils.compute_cost(a3, Y) else: ###使用L2正则化 cost = reg_utils.compute_cost_with_regularization(a3, Y, parameters, lambd) # 反向传播 ##可以同时使用L2正则化和随机删除节点,但是本次实验不同时使用。 assert (lambd == 0 or keep_prob == 1) ##两个参数的使用情况 if (lambd == 0 and keep_prob == 1): ### 不使用L2正则化和不使用随机删除节点 grads = reg_utils.backward_propagation(X, Y, cache) elif lambd != 0: ### 使用L2正则化,不使用随机删除节点 grads = reg_utils.backward_propagation_with_regularization(X, Y, cache, lambd) elif keep_prob < 1: ### 使用随机删除节点,不使用L2正则化 grads =reg_utils. backward_propagation_with_dropout(X, Y, cache, keep_prob) # 更新参数 parameters = reg_utils.update_parameters(parameters, grads, learning_rate) # 记录并打印成本 if i % 1000 == 0: ## 记录成本 costs.append(cost) if (print_cost and i % 10000 == 0): # 打印成本 print("第" + str(i) + "次迭代,成本值为:" + str(cost)) # 是否绘制成本曲线图 if is_plot: plt.plot(costs) plt.ylabel('cost') plt.xlabel('iterations (x1,000)') plt.title("Learning rate =" + str(learning_rate)) plt.show() # 返回学习后的参数 return parameters
def model(X, Y, learning_rate=0.3, num_iterations=30000, print_cost=True, lambd=0, keep_prob=1): """ 实现一个三层神经网络模型: LINEAR->RELU->LINEAR->RELU->LINEAR->SIGMOID. 可以:-- 不使用正则化 -- 使用 L2 正则化 -- 使用 dropout 正则化 :param X: 输入数据, of shape (input size, number of examples) :param Y: 正确的标签向量 (1 for blue dot / 0 for red dot), of shape (output size, number of examples) :param learning_rate: 优化的学习率 :param num_iterations: 优化循环的迭代次数 :param print_cost: If True, print the cost every 10000 iterations :param lambd: 正则化的超参数 λ :param keep_prob: drop-out 正则化中随机保留节点的概率 Returns: parameters -- 神经网络模型学习得到的参数,可以用来预测 """ grads = {} costs = [] # to keep track of the cost m = X.shape[1] # number of examples layers_dims = [X.shape[0], 20, 3, 1] # 初始化参数字典 parameters = initialize_parameters(layers_dims) # 学习循环(梯度下降) for i in range(0, num_iterations): # 前向传播: LINEAR -> RELU -> LINEAR -> RELU -> LINEAR -> SIGMOID. # 不使用 dropout 正则化 if keep_prob == 1: a3, cache = forward_propagation(X, parameters) # 使用 dropout 正则化 elif keep_prob < 1: a3, cache = forward_propagation_with_dropout( X, parameters, keep_prob) # 计算 cost # 不使用 L2 正则化 if lambd == 0: cost = compute_cost(a3, Y) # 使用 L2 正则化 else: cost = compute_cost_with_regularization(a3, Y, parameters, lambd) # 后向传播 assert (lambd == 0 or keep_prob == 1 ) # 可以同时使用 L2 正则化和 dropout, 但是本程序只使用其中一个或不使用正则化 # 不使用正则化 if lambd == 0 and keep_prob == 1: grads = backward_propagation(X, Y, cache) # 使用 L2 正则化 elif lambd != 0: grads = backward_propagation_with_regularization( X, Y, cache, lambd) # 使用 dropout 正则化 elif keep_prob < 1: grads = backward_propagation_with_dropout(X, Y, cache, keep_prob) # 更新参数 parameters = update_parameters(parameters, grads, learning_rate) # Print the loss every 10000 iterations if print_cost and i % 10000 == 0: print("Cost after iteration {}: {}".format(i, cost)) if print_cost and i % 1000 == 0: costs.append(cost) # 绘制 cost 变化曲线图 plt.plot(costs) plt.ylabel('cost') plt.xlabel('iterations (x1,000)') plt.title("Learning rate =" + str(learning_rate)) plt.show() return parameters
def model(X, Y, learning_rate=0.3, num_iterations=30000, print_cost=True, lambd=0, keep_prob=1): """ implements a three layer neural network: linear -> relu -> linear -> relu -> linear -> sigmoid arguments: X -- input data, shape(input size,number of examples) Y -- true label vector, shape(output size,number of examples) learning_rate -- learn rate of the optimization num_iterations -- number of iterations of the optimization loop print_cost -- if true, print the cost every 10000 iterations lambd -- regularization hhyperparameter keep_prob -- probability of keeping a neuron activa during drop-out returns: parameters -- parameters learned by the model, they can then be used to predict """ grads = {} costs = [] m = X.shape[1] layers_dims = [X.shape[0], 20, 3, 1] #initialize parameters dictionary parameters = initialize_parameters(layers_dims) #loop for i in range(0, num_iterations): #forward if keep_prob == 1: a3, cache = forward_propagation(X, parameters) elif keep_prob < 1: a3, cache = forward_propagation_with_dropout( X, parameters, keep_prob) #cost function if lambd == 0: cost = compute_cost(a3, Y) else: cost = compute_cost_with_regularization(a3, Y, parameters, lambd) # assert (lambd == 0 or keep_prob == 1) if lambd == 0 and keep_prob == 1: grads = backward_propagation(X, Y, cache) elif lambd != 0: grads = backward_propagation_with_regularization( X, Y, cache, lambd) elif keep_prob < 1: grads = backward_propagation_with_dropout(X, Y, cache, keep_prob) #update parameters parameters = update_parameters(parameters, grads, learning_rate) #print the loss every 1000 iterations if print_cost and i % 10000 == 0: print("Cost after iteration {}: {}".format(i, cost)) if print_cost and i % 100 == 0: costs.append(cost) #plot the cost plt.figure(2) plt.plot(costs) plt.ylabel('cost') plt.xlabel('iterations (x1,000)') plt.title('learning rate = ' + str(learning_rate)) plt.show() return parameters
def model2(X, Y, learning_rate=0.3, num_iterations=30000, print_cost=True, is_plot=True, lambd=0, keep_prob=1): grads = {} costs = [] m = X.shape[1] layers_dims = [X.shape[0], 20, 3, 1] parameters = reg_utils.initialize_parameters(layers_dims) for i in range(0, num_iterations): # 前向传播 # 询问是否删除节点 if keep_prob == 1: # 不随机删除节点 a3, cache = reg_utils.forward_propagation(X, parameters) elif keep_prob < 1: # 随即删除节点 a3, cache = forward_propagation_with_dropout( X, parameters, keep_prob) else: print("keep_prob参数错误!程序退出") exit # 计算成本 # 是否正则化 if lambd == 0: cost = reg_utils.compute_cost(a3, Y) else: cost = compute_cost_with_regularization(a3, Y, parameters, lambd) # 本次实验不同时使用正则化和随即删除节点 assert (lambd == 0 or keep_prob == 1) if (lambd == 0 and keep_prob == 1): grads = reg_utils.backward_propagation(X, Y, cache) elif lambd != 0: grads = backward_propagation_with_regularization( X, Y, cache, lambd) elif keep_prob < 1: grads = backward_propagation_with_dropout(X, Y, cache, keep_prob) # 更新参数 parameters = reg_utils.update_parameters(parameters, grads, learning_rate) if i % 1000 == 0: # 要记录的 costs.append(cost) if (print_cost and i % 10000 == 0): # 要输出的 print("第" + str(i) + "次迭代, 成本为:" + str(cost)) if is_plot: plt.plot(costs) plt.ylabel('cost') plt.xlabel('iterations(x1,000)') plt.title("learning rate =" + str(learning_rate)) plt.show() return parameters
def model(X, Y, learning_rate=0.3, num_iterations=30000, print_cost=True, is_plot=True, lambd=0, keep_prob=1): ''' 实现一个三层的神经网络:linear->relu->linear->relu->linear->sigmoid :param X: 输入的数据,维度为(2,要训练/测试的数量) :param Y: 标签,[0(蓝色)|1(红色)],维度为(1,对应的是输入的数据的标签) :param learing_rate: 学习速率 :param num_iterations: 迭代次数 :param print_cost: 是否打印成本值 :param lambd: 正则化的超参数,实数 :param keep_prob: 随机删除节点的概率 :return: parameters-学习后的参数 ''' grads = {} costs = [] m = X.shape[1] layers_dims = [X.shape[0], 20, 3, 1] #初始化参数 parameters = reg_utils.initialize_parameters(layers_dims) #开始学习 for i in range(0, num_iterations): #前向传播 ##是否删除随机节点 if keep_prob == 1: ###不删除随机节点 a3, cache = reg_utils.forward_propagation(X, parameters) elif keep_prob < 1: ###随即删除节点 a3, cache = forward_propagation_with_dropout( X, parameters, keep_prob) else: print('keep_prob参数错误,程序退出.') exit #计算成本 ##是否使用二范数 if lambd == 0: ###不使用L2正则化 cost = reg_utils.compute_cost(a3, Y) else: ###使用L2正则化 cost = compute_cost_with_regularization(a3, Y, parameters, lambd) ##反向传播 ##可以同时使用L2正则化和随机删除节点,但本次实验不同时使用 assert (lambd == 0 or keep_prob == 1) ##两个参数的使用情况 if (lambd == 0 and keep_prob == 1): ###不适用L2正则化和不使用随即删除节点 grads = reg_utils.backward_propagation(X, Y, cache) elif lambd != 0: ###使用L2正则化,不使用随即删除节点 grads = backward_propagation_with_regularization( X, Y, cache, lambd) elif keep_prob < 1: ###使用随即删除节点,不使用L2正则化 grads = backward_propagation_with_dropout(X, Y, cache, keep_prob) #更新参数 parameters = reg_utils.update_parameters(parameters, grads, learning_rate) #记录并打印成本 if i % 1000 == 0: ##记录成本 costs.append(cost) if (print_cost and i % 10000 == 0): #打印成本 print('第' + str(i) + '次迭代,成本值为:' + str(cost)) #是否绘制成本曲线图 if is_plot: plt.plot(costs) plt.ylabel('cost') plt.xlabel('iterations(x1,000)') plt.title('Learning rate = ' + str(learning_rate)) plt.show() #返回学习后的参数 return parameters