吴恩达课后作业学习2-week1-1 初始化
参考:https://blog.csdn.net/u013733326/article/details/79847918
希望大家直接到上面的网址去查看代码,下面是本人的笔记
初始化、正则化、梯度校验
1. 初始化参数:
1.1:使用0来初始化参数。
1.2:使用随机数来初始化参数。
1.3:使用抑梯度异常初始化参数(参见视频中的梯度消失和梯度爆炸)。
2. 正则化模型:
2.1:使用二范数对二分类模型正则化——L2正则化方法,尝试避免过拟合。
2.2:使用随机删除节点的方法——dropout正则化方法精简模型,同样是为了尝试避免过拟合。
3. 梯度校验 :对模型使用梯度校验,检测它是否在梯度下降的过程中出现误差过大的情况。
1.导入相关的库
import numpy as np import matplotlib.pyplot as plt import sklearn import sklearn.datasets import init_utils #第一部分,初始化 import reg_utils #第二部分,正则化 import gc_utils #第三部分,梯度校验 #%matplotlib inline #如果你使用的是Jupyter Notebook,请取消注释。 plt.rcParams['figure.figsize'] = (7.0, 4.0) # set default size of plots plt.rcParams['image.interpolation'] = 'nearest' plt.rcParams['image.cmap'] = 'gray'
警告:
/Users/user/pytorch/jupyter/2-week1/reg_utils.py:61: SyntaxWarning: assertion is always true, perhaps remove parentheses? assert(parameters['W' + str(l)].shape == layer_dims[l], layer_dims[l-1]) /Users/user/pytorch/jupyter/2-week1/reg_utils.py:62: SyntaxWarning: assertion is always true, perhaps remove parentheses? assert(parameters['W' + str(l)].shape == layer_dims[l], 1)
2.导入数据
train_X, train_Y, test_X, test_Y = init_utils.load_dataset(is_plot=True)
执行返回图示:
该神经网络目标:建立一个分类器将蓝点和红点分开,建立一个三层网络LINEAR ->RELU -> LINEAR -> RELU -> LINEAR -> SIGMOID
3.初始化参数
首先可见神经网络模型为:
def model(X,Y,learning_rate=0.01,num_iterations=15000,print_cost=True,initialization="he",is_polt=True): """ 实现一个三层的神经网络:LINEAR ->RELU -> LINEAR -> RELU -> LINEAR -> SIGMOID 参数: X - 输入的数据,维度为(2, 要训练/测试的数量) Y - 标签,表示输入为红点还是蓝点【0 | 1】,维度为(1,对应的是输入的数据的标签) learning_rate - 学习速率 num_iterations - 迭代的次数 print_cost - 是否打印成本值,每迭代1000次打印一次 initialization - 字符串类型,初始化的类型【"zeros" | "random" | "he"】 is_polt - 是否绘制梯度下降的曲线图 返回 parameters - 学习后的参数 """ grads = {} costs = [] m = X.shape[1] #训练/测试的数量 layers_dims = [X.shape[0],10,5,1] #设置神经网络层数 #选择初始化参数的类型 if initialization == "zeros": parameters = initialize_parameters_zeros(layers_dims) elif initialization == "random": parameters = initialize_parameters_random(layers_dims) elif initialization == "he": parameters = initialize_parameters_he(layers_dims) else : print("错误的初始化参数!程序退出") exit #开始学习 for i in range(0,num_iterations): #前向传播 a3 , cache = init_utils.forward_propagation(X,parameters) #计算成本 cost = init_utils.compute_loss(a3,Y) #反向传播 grads = init_utils.backward_propagation(X,Y,cache) #更新参数 parameters = init_utils.update_parameters(parameters,grads,learning_rate) #记录成本 if i % 1000 == 0: costs.append(cost) #打印成本 if print_cost: print("第" + str(i) + "次迭代,成本值为:" + str(cost)) #学习完毕,绘制成本曲线 if is_polt: plt.plot(costs) plt.ylabel('cost') plt.xlabel('iterations (per hundreds)') plt.title("Learning rate =" + str(learning_rate)) plt.show() #返回学习完毕后的参数 return parameters
1)初始化为0
在输入参数中全部初始化为0,参数名为initialization = “zeros”,核心代码:
parameters['W' + str(l)] = np.zeros((layers_dims[l], layers_dims[l - 1]))
代码为:
def initialize_parameters_zeros(layers_dims): """ 将模型的参数全部设置为0 参数: layers_dims - 列表,模型的层数和对应每一层的节点的数量 返回 parameters - 包含了所有W和b的字典 W1 - 权重矩阵,维度为(layers_dims[1], layers_dims[0]) b1 - 偏置向量,维度为(layers_dims[1],1) ··· WL - 权重矩阵,维度为(layers_dims[L], layers_dims[L -1]) bL - 偏置向量,维度为(layers_dims[L],1) """ parameters = {} L = len(layers_dims) #网络层数 for l in range(1,L): #即每一层的参数w,b都设置为0 parameters["W" + str(l)] = np.zeros((layers_dims[l],layers_dims[l-1])) parameters["b" + str(l)] = np.zeros((layers_dims[l],1)) #使用断言确保我的数据格式是正确的 assert(parameters["W" + str(l)].shape == (layers_dims[l],layers_dims[l-1])) assert(parameters["b" + str(l)].shape == (layers_dims[l],1)) return parameters
测试:
parameters = initialize_parameters_zeros([3,2,1]) #三层神经元数量 print("W1 = " + str(parameters["W1"])) print("b1 = " + str(parameters["b1"])) print("W2 = " + str(parameters["W2"])) print("b2 = " + str(parameters["b2"]))
返回:
W1 = [[0. 0. 0.] [0. 0. 0.]] b1 = [[0.] [0.]] W2 = [[0. 0.]] b2 = [[0.]]
可以看到W和b全部被初始化为0了,那么我们使用这些参数来训练模型,结果会怎样呢?
parameters = model(train_X, train_Y, initialization = "zeros",is_polt=True)
返回:
第0次迭代,成本值为:0.6931471805599453 第1000次迭代,成本值为:0.6931471805599453 第2000次迭代,成本值为:0.6931471805599453 第3000次迭代,成本值为:0.6931471805599453 第4000次迭代,成本值为:0.6931471805599453 第5000次迭代,成本值为:0.6931471805599453 第6000次迭代,成本值为:0.6931471805599453 第7000次迭代,成本值为:0.6931471805599453 第8000次迭代,成本值为:0.6931471805599453 第9000次迭代,成本值为:0.6931471805599453 第10000次迭代,成本值为:0.6931471805599455 第11000次迭代,成本值为:0.6931471805599453 第12000次迭代,成本值为:0.6931471805599453 第13000次迭代,成本值为:0.6931471805599453 第14000次迭代,成本值为:0.6931471805599453
可见成本基本没有变化,说明这个模型根本没有学习
图示为:
查看下预测结果:
print ("训练集:") predictions_train = init_utils.predict(train_X, train_Y, parameters) print ("测试集:") predictions_test = init_utils.predict(test_X, test_Y, parameters)
返回:
训练集: Accuracy: 0.5 测试集: Accuracy: 0.5
性能确实很差,而且成本并没有真正降低,算法的性能也比随机猜测要好。为什么?让我们看看预测和决策边界的细节:
这里调用init_utils.plot_decision_boundary()函数的时候还是会遇见问题(运行再jupyter notebook时):
'c' argument has 1 elements, which is not acceptable for use with 'x' with ...
在init_utils.py函数中更改为:
def plot_decision_boundary(model, X, y): # Set min and max values and give it some padding x_min, x_max = X[0, :].min() - 1, X[0, :].max() + 1 y_min, y_max = X[1, :].min() - 1, X[1, :].max() + 1 h = 0.01 # Generate a grid of points with distance h between them xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h)) # Predict the function value for the whole grid Z = model(np.c_[xx.ravel(), yy.ravel()]) Z = Z.reshape(xx.shape) # Plot the contour and training examples plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral) plt.ylabel('x2') plt.xlabel('x1') plt.scatter(X[0, :], X[1, :], c=np.squeeze(y), cmap=plt.cm.Spectral) #更改这里的y plt.show()
也没有效果,将该函数直接在jupyter中声明,然后直接调用直接plot_decision_boundary()就不会有问题了
细节检测为:
print("predictions_train = " + str(predictions_train)) print("predictions_test = " + str(predictions_test)) plt.title("Model with Zeros initialization") axes = plt.gca() axes.set_xlim([-1.5, 1.5]) axes.set_ylim([-1.5, 1.5]) plot_decision_boundary(lambda x: init_utils.predict_dec(parameters, x.T), train_X, train_Y)
返回:
predictions_train = [[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]] predictions_test = [[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]]
图示:
分类失败,该模型预测每个都为0。通常来说,零初始化都会导致神经网络无法打破对称性,最终导致的结果就是无论网络有多少层,最终只能得到和Logistic函数相同的效果。
2)随机初始化
把输入参数设置为随机值,权重初始化为大的随机值。参数名为initialization = “random”,核心代码:
parameters['W' + str(l)] = np.random.randn(layers_dims[l], layers_dims[l - 1]) * 10
为了打破对称性,我们可以随机地把参数赋值。在随机初始化之后,每个神经元可以开始学习其输入的不同功能,这里设置比较大的参数值,因为乘于10,看看会发生什么。
代码:
def initialize_parameters_random(layers_dims): """ 参数: layers_dims - 列表,模型的层数和对应每一层的节点的数量 返回 parameters - 包含了所有W和b的字典 W1 - 权重矩阵,维度为(layers_dims[1], layers_dims[0]) b1 - 偏置向量,维度为(layers_dims[1],1) ··· WL - 权重矩阵,维度为(layers_dims[L], layers_dims[L -1]) b1 - 偏置向量,维度为(layers_dims[L],1) """ np.random.seed(3) # 指定随机种子 parameters = {} L = len(layers_dims) # 层数 for l in range(1, L): parameters['W' + str(l)] = np.random.randn(layers_dims[l], layers_dims[l - 1]) * 10 #使用10倍缩放 parameters['b' + str(l)] = np.zeros((layers_dims[l], 1)) #b仍初始化为0 #使用断言确保我的数据格式是正确的 assert(parameters["W" + str(l)].shape == (layers_dims[l],layers_dims[l-1])) assert(parameters["b" + str(l)].shape == (layers_dims[l],1)) return parameters
测试:
parameters = initialize_parameters_random([3, 2, 1]) print("W1 = " + str(parameters["W1"])) print("b1 = " + str(parameters["b1"])) print("W2 = " + str(parameters["W2"])) print("b2 = " + str(parameters["b2"]))
返回:
W1 = [[ 17.88628473 4.36509851 0.96497468] [-18.63492703 -2.77388203 -3.54758979]] b1 = [[0.] [0.]] W2 = [[-0.82741481 -6.27000677]] b2 = [[0.]]
看起来这些参数都是比较大的,我们来看看实际运行会怎么样:
parameters = model(train_X, train_Y, initialization = "random",is_polt=True) print("训练集:") predictions_train = init_utils.predict(train_X, train_Y, parameters) print("测试集:") predictions_test = init_utils.predict(test_X, test_Y, parameters) print(predictions_train) print(predictions_test)
警告:
/Users/user/pytorch/jupyter/2-week1/init_utils.py:50: RuntimeWarning: divide by zero encountered in log logprobs = np.multiply(-np.log(a3),Y) + np.multiply(-np.log(1 - a3), 1 - Y) /Users/user/pytorch/jupyter/2-week1/init_utils.py:50: RuntimeWarning: invalid value encountered in multiply logprobs = np.multiply(-np.log(a3),Y) + np.multiply(-np.log(1 - a3), 1 - Y)
返回:
第0次迭代,成本值为:inf 第1000次迭代,成本值为:0.6250676215287511 第2000次迭代,成本值为:0.5981418252875961 第3000次迭代,成本值为:0.563858109377261 第4000次迭代,成本值为:0.5501823050061752 第5000次迭代,成本值为:0.5444756668990652 第6000次迭代,成本值为:0.5374638179631746 第7000次迭代,成本值为:0.4770885368883873 第8000次迭代,成本值为:0.397834663330821 第9000次迭代,成本值为:0.3934832163377203 第10000次迭代,成本值为:0.39203323866307854 第11000次迭代,成本值为:0.3892818629893498 第12000次迭代,成本值为:0.3861521882410713 第13000次迭代,成本值为:0.38499297516135134 第14000次迭代,成本值为:0.38280470097181446 训练集: Accuracy: 0.83 测试集: Accuracy: 0.86 [[1 0 1 1 0 0 1 1 1 1 1 0 1 0 0 1 0 1 1 0 0 0 1 0 1 1 1 1 1 1 0 1 1 0 0 1 1 1 1 1 1 1 1 0 1 1 1 1 0 1 0 1 1 1 1 0 0 1 1 1 1 0 1 1 0 1 0 1 1 1 1 0 0 0 0 0 1 0 1 0 1 1 1 0 0 1 1 1 1 1 1 0 0 1 1 1 0 1 1 0 1 0 1 1 0 1 1 0 1 0 1 1 0 0 1 0 0 1 1 0 1 1 1 0 1 0 0 1 0 1 1 1 1 1 1 1 0 1 1 0 0 1 1 0 0 0 1 0 1 0 1 0 1 1 1 0 0 1 1 1 1 0 1 1 0 1 0 1 1 0 1 0 1 1 1 1 0 1 1 1 1 0 1 0 1 0 1 1 1 1 0 1 1 0 1 1 0 1 1 0 1 0 1 1 1 0 1 1 1 0 1 0 1 0 0 1 0 1 1 0 1 1 0 1 1 0 1 1 1 0 1 1 1 1 0 1 0 0 1 1 0 1 1 1 0 0 0 1 1 0 1 1 1 1 0 1 1 0 1 1 1 0 0 1 0 0 0 1 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1 0 0 1 1 1 1 1 1 1 0 0 0 1 1 1 1 0]] [[1 1 1 1 0 1 0 1 1 0 1 1 1 0 0 0 0 1 0 1 0 0 1 0 1 0 1 1 1 1 1 0 0 0 0 1 0 1 1 0 0 1 1 1 1 1 0 1 1 1 0 1 0 1 1 0 1 0 1 0 1 1 1 1 1 1 1 1 1 0 1 0 1 1 1 1 1 0 1 0 0 1 0 0 0 1 1 0 1 1 0 0 0 1 1 0 1 1 0 0]]
图示:
我们来把图绘制出来,看看分类的结果是怎样的。
plt.title("Model with large random initialization") axes = plt.gca() axes.set_xlim([-1.5, 1.5]) axes.set_ylim([-1.5, 1.5]) plot_decision_boundary(lambda x: init_utils.predict_dec(parameters, x.T), train_X, train_Y)
图示:
初始化参数如果没有很好地话会导致梯度消失、爆炸,这也会减慢优化算法。如果我们对这个网络进行更长时间的训练,我们将看到更好的结果,但是使用过大的随机数初始化会减慢优化的速度。
3)抑梯度异常(即梯度爆炸或梯度消失)初始化——最好选择该方法
参见梯度消失和梯度爆炸的那一个视频,参数名为initialization = “he”,核心代码:
parameters['W' + str(l)] = np.random.randn(layers_dims[l], layers_dims[l - 1]) * np.sqrt(2 / layers_dims[l - 1])
代码:
def initialize_parameters_he(layers_dims): """ 参数: layers_dims - 列表,模型的层数和对应每一层的节点的数量 返回 parameters - 包含了所有W和b的字典 W1 - 权重矩阵,维度为(layers_dims[1], layers_dims[0]) b1 - 偏置向量,维度为(layers_dims[1],1) ··· WL - 权重矩阵,维度为(layers_dims[L], layers_dims[L -1]) b1 - 偏置向量,维度为(layers_dims[L],1) """ np.random.seed(3) # 指定随机种子 parameters = {} L = len(layers_dims) # 层数 for l in range(1, L): parameters['W' + str(l)] = np.random.randn(layers_dims[l], layers_dims[l - 1]) * np.sqrt(2 / layers_dims[l - 1]) parameters['b' + str(l)] = np.zeros((layers_dims[l], 1)) #使用断言确保我的数据格式是正确的 assert(parameters["W" + str(l)].shape == (layers_dims[l],layers_dims[l-1])) assert(parameters["b" + str(l)].shape == (layers_dims[l],1)) return parameters
测试:
parameters = initialize_parameters_he([2, 4, 1]) print("W1 = " + str(parameters["W1"])) print("b1 = " + str(parameters["b1"])) print("W2 = " + str(parameters["W2"])) print("b2 = " + str(parameters["b2"]))
返回:
W1 = [[ 1.78862847 0.43650985] [ 0.09649747 -1.8634927 ] [-0.2773882 -0.35475898] [-0.08274148 -0.62700068]] b1 = [[0.] [0.] [0.] [0.]] W2 = [[-0.03098412 -0.33744411 -0.92904268 0.62552248]] b2 = [[0.]]
这样就基本把参数W初始化到了1附近,我们来实际运行一下看看效果:
parameters = model(train_X, train_Y, initialization = "he",is_polt=True) print("训练集:") predictions_train = init_utils.predict(train_X, train_Y, parameters) print("测试集:") init_utils.predictions_test = init_utils.predict(test_X, test_Y, parameters)
返回:
第0次迭代,成本值为:0.8830537463419761 第1000次迭代,成本值为:0.6879825919728063 第2000次迭代,成本值为:0.6751286264523371 第3000次迭代,成本值为:0.6526117768893807 第4000次迭代,成本值为:0.6082958970572938 第5000次迭代,成本值为:0.5304944491717495 第6000次迭代,成本值为:0.4138645817071794 第7000次迭代,成本值为:0.3117803464844441 第8000次迭代,成本值为:0.23696215330322556 第9000次迭代,成本值为:0.18597287209206836 第10000次迭代,成本值为:0.15015556280371817 第11000次迭代,成本值为:0.12325079292273551 第12000次迭代,成本值为:0.09917746546525935 第13000次迭代,成本值为:0.08457055954024278 第14000次迭代,成本值为:0.07357895962677366 训练集: Accuracy: 0.9933333333333333 测试集: Accuracy: 0.96
图示:
可见效果很好,绘制预测情况:
plt.title("Model with He initialization") axes = plt.gca() axes.set_xlim([-1.5, 1.5]) axes.set_ylim([-1.5, 1.5]) plot_decision_boundary(lambda x: init_utils.predict_dec(parameters, x.T), train_X, train_Y)
图示:
总结:
- 不同的初始化方法可能导致性能最终不同
- 随机初始化有助于打破对称,使得不同隐藏层的单元可以学习到不同的参数。
- 初始化时,初始值不宜过大。
- He初始化搭配ReLU激活函数常常可以得到不错的效果。
在深度学习中,如果数据集没有足够大的话,可能会导致一些过拟合的问题。过拟合导致的结果就是在训练集上有着很高的精确度,但是在遇到新的样本时,精确度下降会很严重。
为了避免过拟合的问题,接下来我们要讲解的方式就是正则化。
接下来可见吴恩达课后作业学习2-week1-2正则化—不发布