2019.10.14-2019.10.17学习进度

本文主要是介绍2019.10.14-2019.10.17学习进度，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

2019.10.14学习进度

今天是第16天参与STAR Pro,今天主要完成了深度学习的实用层面的学习以及复习。
主要学了梯度消失与梯度爆炸的缘由以及解决方法————权重初始化，再然后学了怎样用梯度检测调试程序，检验backprop的正确性。
在这里插入图片描述

2019.10.15学习进度

今天是第十七天参与STAR Pro,今天主要完成了第二周“优化算法”2.1-2.5的学习以及深层神经网络编程代码的复习。

优化算法

本周学习几种优化算法来快速训练模型
在这里插入图片描述

补充学习了过度拟合的概念

1.过度拟合(从知乎上看到的)
　　(1)对于机器来说，在使用学习算法学习数据的特征的时候，样本数据的特征可以分为局部特征和全局特征，全局特征就是任何你想学习的那个概念所对应的数据都具备的特征，而局部特征则是你用来训练机器的样本里头的数据专有的特征.
　　(2)在学习算法的作用下，机器在学习过程中是无法区别局部特征和全局特征的，于是机器在完成学习后，除了学习到了数据的全局特征，也可能习得一部分局部特征，而习得的局部特征比重越多，那么新样本中不具有这些局部特征但具有所有全局特征的样本也越多，于是机器无法正确识别符合概念定义的“正确”样本的几率也会上升，也就是所谓的“泛化性”变差，这是过拟合会造成的最大问题.
　　(3)所谓过拟合，就是指把学习进行的太彻底，把样本数据的所有特征几乎都习得了，于是机器学到了过多的局部特征，过多的由于噪声带来的假特征，造成模型的“泛化性”和识别正确率几乎达到谷点，于是你用你的机器识别新的样本的时候会发现就没几个是正确识别的.
　　(4)解决过拟合的方法，其基本原理就是限制机器的学习，使机器学习特征时学得不那么彻底，因此这样就可以降低机器学到局部特征和错误特征的几率，使得识别正确率得到优化.
　　打个形象的比方，给一群天鹅让机器来学习天鹅的特征，经过训练后，知道了天鹅是有翅膀的，天鹅的嘴巴是长长的弯曲的，天鹅的脖子是长长的有点曲度，天鹅的整个体型像一个“2”且略大于鸭子.这时候你的机器已经基本能区别天鹅和其他动物了。
　　然后，很不巧你的天鹅全是白色的，于是机器经过学习后，会认为天鹅的羽毛都是白的，以后看到羽毛是黑的天鹅就会认为那不是天鹅.
　　来分析一下上面这个例子：(1)中的规律都是对的，所有的天鹅都有的特征，是全局特征；然而，(2)中的规律：天鹅的羽毛是白的.这实际上并不是所有天鹅都有的特征，只是局部样本的特征。机器在学习全局特征的同时，又学习了局部特征，这才导致了不能识别黑天鹅的情况.

2019.10.16学习进度

今天是第十八天参与STAR Pro,今天主要学习了“优化算法中的” 几种优化的梯度下降法———动量梯度下降法、RMSprop梯度下降法和两者的结合：Adam优化算法，还学习了学习率衰减，这几种方法在计算cost函数的时候都可以减少噪音，加快梯度下降，并且使下降平稳地进行。
在这里插入图片描述

2019.10.17学习进度

今天是第十九天参与STAR Pro,今天主要完成了一下几点：

1.“深度学习的实用层面”与“优化算法”课程笔记的复习

子曰：“温故而知新，可以为师矣”。再次复习所学内容，我对神经网络的优化层面又有了新的认识。

2.CSDN上查找了关于正则化和权重初始化优化的代码实现

he初始化：

def initialize_parameters_he(layers_dims):np.random.seed(3)parameters = {}L = len(layers_dims) - 1 # integer representing the number of layersfor l in range(1, L + 1):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))return parameters

L2正则化：


def compute_cost_with_regularization(A3, Y, parameters, lambd):m = Y.shape[1]W1 = parameters["W1"]W2 = parameters["W2"]W3 = parameters["W3"]cross_entropy_cost = compute_cost(A3, Y) L2_regularization_cost = (1./m*lambd/2)*(np.sum(np.square(W1)) + np.sum(np.square(W2)) + np.sum(np.square(W3)))cost = cross_entropy_cost + L2_regularization_costreturn cost

def backward_propagation_with_regularization(X, Y, cache, lambd):m = X.shape[1](Z1, A1, W1, b1, Z2, A2, W2, b2, Z3, A3, W3, b3) = cachedZ3 = A3 - YdW3 = 1./m * np.dot(dZ3, A2.T) + lambd/m * W3db3 = 1./m * np.sum(dZ3, axis=1, keepdims = True)dA2 = np.dot(W3.T, dZ3)dZ2 = np.multiply(dA2, np.int64(A2 > 0))dW2 = 1./m * np.dot(dZ2, A1.T) + lambd/m * W2db2 = 1./m * np.sum(dZ2, axis=1, keepdims = True)dA1 = np.dot(W2.T, dZ2)dZ1 = np.multiply(dA1, np.int64(A1 > 0))dW1 = 1./m * np.dot(dZ1, X.T) + lambd/m * W1db1 = 1./m * np.sum(dZ1, axis=1, keepdims = True)gradients = {"dZ3": dZ3, "dW3": dW3, "db3": db3,"dA2": dA2,"dZ2": dZ2, "dW2": dW2, "db2": db2, "dA1": dA1, "dZ1": dZ1, "dW1": dW1, "db1": db1}return gradients

dorpout正则化

def forward_propagation_with_dropout(X, parameters, keep_prob = 0.5):np.random.seed(1)# retrieve parametersW1 = parameters["W1"]b1 = parameters["b1"]W2 = parameters["W2"]b2 = parameters["b2"]W3 = parameters["W3"]b3 = parameters["b3"]Z1 = np.dot(W1, X) + b1A1 = relu(Z1        # Steps 1-4 below correspond to the Steps 1-4 described above. D1 = np.random.rand(A1.shape[0],A1.shape[1])                                         # Step 1: initialize matrix D1 = np.random.rand(..., ...)D1 = D1 < keep_prob                                      # Step 2: convert entries of D1 to 0 or 1 (using keep_prob as the threshold)A1 = A1 * D1                                         # Step 3: shut down some neurons of A1A1 = A1 / keep_prob                                        # Step 4: scale the value of neurons that haven't been shut downZ2 = np.dot(W2, A1) + b2A2 = relu(Z2)D2 = np.random.rand(A2.shape[0],A2.shape[1])                                         # Step 1: initialize matrix D2 = np.random.rand(..., ...)D2 = D2 < keep_prob                                         # Step 2: convert entries of D2 to 0 or 1 (using keep_prob as the threshold)A2 = A2 * D2                                         # Step 3: shut down some neurons of A2A2 = A2 / keep_prob                                      # Step 4: scale the value of neurons that haven't been shut downZ3 = np.dot(W3, A2) + b3A3 = sigmoid(Z3)cache = (Z1, D1, A1, W1, b1, Z2, D2, A2, W2, b2, Z3, A3, W3, b3)return A3, cache

# GRADED FUNCTION: backward_propagation_with_dropoutdef backward_propagation_with_dropout(X, Y, cache, keep_prob):m = X.shape[1](Z1, D1, A1, W1, b1, Z2, D2, A2, W2, b2, Z3, A3, W3, b3) = cachedZ3 = A3 - YdW3 = 1./m * np.dot(dZ3, A2.T)db3 = 1./m * np.sum(dZ3, axis=1, keepdims = True)dA2 = np.dot(W3.T, dZ3)dA2 = dA2 * D2              # Step 1: Apply mask D2 to shut down the same neurons as during the forward propagationdA2 = dA2 / keep_prob           # Step 2: Scale the value of neurons that haven't been dZ2 = np.multiply(dA2, np.int64(A2 > 0))dW2 = 1./m * np.dot(dZ2, A1.T)db2 = 1./m * np.sum(dZ2, axis=1, keepdims = True)dA1 = np.dot(W2.T, dZ2)dA1 = dA1 * D1              # Step 1: Apply mask D1 to shut down the same neurons as during the forward propagationdA1 = dA1 / keep_prob             # Step 2: Scale the value of neurons that haven't been dZ1 = np.multiply(dA1, np.int64(A1 > 0))dW1 = 1./m * np.dot(dZ1, X.T)db1 = 1./m * np.sum(dZ1, axis=1, keepdims = True)gradients = {"dZ3": dZ3, "dW3": dW3, "db3": db3,"dA2": dA2,"dZ2": dZ2, "dW2": dW2, "db2": db2, "dA1": dA1, "dZ1": dZ1, "dW1": dW1, "db1": db1}return gradients

一些numpy常用函数的作用

*一。mean() 函数定义：
numpy.mean(a, axis, dtype, out，keepdims )
mean()函数功能：求取均值
经常操作的参数为axis，以m * n矩阵举例：
1.axis 不设置值，对 mn 个数求均值，返回一个实数
2.axis = 0：压缩行，对各列求均值，返回 1 n 矩阵
3.axis =1 ：压缩列，对各行求均值，返回 m 1 矩阵

二、python assert的作用：

1.根据Python 官方文档解释(https://docs.python.org/3/reference/simple_stmts.html#assert), “Assert statements are a convenient way to insert debugging assertions into a program”.

2.一般的用法是：

assert condition

用来让程序测试这个condition，如果condition为false，那么raise一个AssertionError出来。逻辑上等同于：

if not condition:
raise AssertionError()
3.三、如何为assert断言语句添加异常参数

assert的异常参数，其实就是在断言表达式后添加字符串信息，用来解释断言并更好的知道是哪里出了问题。格式如下：

assert expression [, arguments]
assert 表达式 [, 参数]