deep_learning_month2_week2_Optimization_methods

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

deep_learning_month2_week2_Optimization_methods

标签： 机器学习深度学习

代码已上传github:
https://github.com/PerfectDemoT/my_deeplearning_homework

---

这次的题目是优化算法，即使用 monmentum方法以及RMSprop方法，然后最终使用Adam方法(其实Adam算法更像是结合了前面两种算法)

其中很重要的一点是对于$v_{dw}$以及$s_{dw}$的初始化以及迭代运算，另外还有$\beta_1$与$\beta_2$的选取(虽然我们会谈到这两个值一般可以不进行筛选，因为其实有两个”通用”的值，一般都直接用这两个值)

最后，我们还将：普通mini-batch下降 ， 用momentum的mini-batch梯度下降 ， 用Adma的mini-batch梯度下降。三个进行了比较（当然，这里主要是比较其对最后的预测准确度的影响，虽然平常这三种方法往往是看对训练速度的影响）

下面我们来看看实现过程：

---

1. 我们先导入包

import numpy as np
import matplotlib.pyplot as plt
import scipy.io
import math
import sklearn
import sklearn.datasetsfrom opt_utils import load_params_and_grads, initialize_parameters, forward_propagation, backward_propagation
from opt_utils import compute_cost, predict, predict_dec, plot_decision_boundary, load_dataset
from testCases import *

在这里我还是建议在自己实现时，去看看有些写好的功能函数，并且里面其实有需要改动的地方(有几个地方直接用会报错的，是矩阵的大小不对等问题，如果你自己实现的话，一定会遇到，此不赘述)

2.就像之前说的，我们最后是对三种方法的训练效果进行比较。我们实现普通的参数更新操作

#首先是更新参数的函数
# GRADED FUNCTION: update_parameters_with_gd
def update_parameters_with_gd(parameters, grads, learning_rate):"""Update parameters using one step of gradient descentArguments:parameters -- python dictionary containing your parameters to be updated:parameters['W' + str(l)] = Wlparameters['b' + str(l)] = blgrads -- python dictionary containing your gradients to update each parameters:grads['dW' + str(l)] = dWlgrads['db' + str(l)] = dbllearning_rate -- the learning rate, scalar.Returns:parameters -- python dictionary containing your updated parameters"""L = len(parameters) // 2  # number of layers in the neural networks# Update rule for each parameterfor l in range(L):### START CODE HERE ### (approx. 2 lines)parameters["W" + str(l + 1)] = parameters["W" + str(l + 1)] - learning_rate * grads["dW" + str(l + 1)]parameters["b" + str(l + 1)] = parameters["b" + str(l + 1)] - learning_rate * grads["db" + str(l + 1)]### END CODE HERE ###return parameters

输出测试一下：

#下面来输出看看
parameters, grads, learning_rate = update_parameters_with_gd_test_case()parameters = update_parameters_with_gd(parameters, grads, learning_rate)
print("W1 = " + str(parameters["W1"]))
print("b1 = " + str(parameters["b1"]))
print("W2 = " + str(parameters["W2"]))
print("b2 = " + str(parameters["b2"]))
print("=====================================")

结果是这样：

W1 = [[ 1.63535156 -0.62320365 -0.53718766][-1.07799357  0.85639907 -2.29470142]]
b1 = [[ 1.74604067][-0.75184921]]
W2 = [[ 0.32171798 -0.25467393  1.46902454][-2.05617317 -0.31554548 -0.3756023 ][ 1.1404819  -1.09976462 -0.1612551 ]]
b2 = [[-0.88020257][ 0.02561572][ 0.57539477]]

3. 接下来我们实现mini-batch算法，另外，在实现这个算法时，我们需要了解一下这些：(批量梯度下降和随机梯度下降不严格的说，其实就是mini-batch的特殊情况)

#批量梯度下降和随机梯度下降(其实也就是B=1的mini-batch下法)的伪代码在.ipynb文件里
# - ** (Batch)
#
# ``` python
# X = data_input
# Y = labels
# parameters = initialize_parameters(layers_dims)
# for i in range(0, num_iterations):
#     # Forward propagation
#     a, caches = forward_propagation(X, parameters)
#     # Compute cost.
#     cost = compute_cost(a, Y)
#     # Backward propagation.
#     grads = backward_propagation(a, caches, parameters)
#     # Update parameters.
#     parameters = update_parameters(parameters, grads)
#
# ```
## - ** Stochastic
#
# ```python
# X = data_input
# Y = labels
# parameters = initialize_parameters(layers_dims)
# for i in range(0, num_iterations):
#     for j in range(0, m):
#         # Forward propagation
#         a, caches = forward_propagation(X[:, j], parameters)
#         # Compute cost
#         cost = compute_cost(a, Y[:, j])
#         # Backward propagation
#         grads = backward_propagation(a, caches, parameters)
#         # Update parameters.
#         parameters = update_parameters(parameters, grads)
# ```

接下来我们来看看Mini-batch的代码

#下面我们来实现mini-batch
# GRADED FUNCTION: random_mini_batches
def random_mini_batches(X, Y, mini_batch_size=64, seed=0):"""Creates a list of random minibatches from (X, Y)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 (1, number of examples)mini_batch_size -- size of the mini-batches, integerReturns:mini_batches -- list of synchronous (mini_batch_X, mini_batch_Y)"""np.random.seed(seed)  # To make your "random" minibatches the same as oursm = X.shape[1]  # number of training examplesmini_batches = []# Step 1: Shuffle (X, Y) 打乱顺序permutation = list(np.random.permutation(m))shuffled_X = X[:, permutation]shuffled_Y = Y[:, permutation].reshape((1, m))# Step 2: Partition (shuffled_X, shuffled_Y). Minus the end case.num_complete_minibatches = math.floor(m / mini_batch_size)  # number of mini batches of size mini_batch_size in your partitionningfor k in range(0, num_complete_minibatches):### START CODE HERE ### (approx. 2 lines)mini_batch_X = shuffled_X[: , (k * mini_batch_size) : ((k + 1) * mini_batch_size)]mini_batch_Y = shuffled_Y[: , (k * mini_batch_size) : ((k + 1) * mini_batch_size)]### END CODE HERE ###mini_batch = (mini_batch_X, mini_batch_Y)mini_batches.append(mini_batch)# Handling the end case (last mini-batch < mini_batch_size)if m % mini_batch_size != 0:### START CODE HERE ### (approx. 2 lines)mini_batch_X = shuffled_X[: , (num_complete_minibatches * mini_batch_size) : ]mini_batch_Y = shuffled_Y[: , (num_complete_minibatches * mini_batch_size) : ]### END CODE HERE ###mini_batch = (mini_batch_X, mini_batch_Y)mini_batches.append(mini_batch)return mini_batches

下面我们来简单说明一下上方算法：

上面的思路是，先把X , Y 数据集打乱，然后根据每一个$batch$的大小，将m个数据分为$\frac{m}{mini\_batch\_size}$个大小为$mini\_catch\_size$的块，分的方法是用矩阵的划分。然后用$mini\_batch$将$mini\_batch\_X$ 与$mini\_batch\_Y$装在一起，再用语句mini_batches.append(mini_batch)把所有变量装在一个$mini\_batches$里

现在可以测试一下：

#下面来输出看看效果
X_assess, Y_assess, mini_batch_size = random_mini_batches_test_case()
mini_batches = random_mini_batches(X_assess, Y_assess, mini_batch_size)print ("shape of the 1st mini_batch_X: " + str(mini_batches[0][0].shape))
print ("shape of the 2nd mini_batch_X: " + str(mini_batches[1][0].shape))
print ("shape of the 3rd mini_batch_X: " + str(mini_batches[2][0].shape))
print ("shape of the 1st mini_batch_Y: " + str(mini_batches[0][1].shape))
print ("shape of the 2nd mini_batch_Y: " + str(mini_batches[1][1].shape))
print ("shape of the 3rd mini_batch_Y: " + str(mini_batches[2][1].shape))
print ("mini batch sanity check: " + str(mini_batches[0][0][0][0:3]))
print("=================================================")

结果是：

shape of the 1st mini_batch_X: (12288, 64)
shape of the 2nd mini_batch_X: (12288, 64)
shape of the 3rd mini_batch_X: (12288, 20)
shape of the 1st mini_batch_Y: (1, 64)
shape of the 2nd mini_batch_Y: (1, 64)
shape of the 3rd mini_batch_Y: (1, 20)
mini batch sanity check: [ 0.90085595 -0.7612069   0.2344157 ]

4. 这里我改变一下原来的代码顺序(注意，这一段应该放在最后，只能在预测函数前面)

1. 这里写一下model函数，就是最后预测函数调用的汇总函数，先看代码，然后再讲解注意的地方

#下面来看看这个model函数
def model(X, Y, layers_dims, optimizer, learning_rate=0.0007, mini_batch_size=64, beta=0.9,beta1=0.9, beta2=0.999, epsilon=1e-8, num_epochs=10000, print_cost=True):"""3-layer neural network model which can be run in different optimizer modes.Arguments:X -- input data, of shape (2, number of examples)Y -- true "label" vector (1 for blue dot / 0 for red dot), of shape (1, number of examples)layers_dims -- python list, containing the size of each layerlearning_rate -- the learning rate, scalar.mini_batch_size -- the size of a mini batchbeta -- Momentum hyperparameterbeta1 -- Exponential decay hyperparameter for the past gradients estimatesbeta2 -- Exponential decay hyperparameter for the past squared gradients estimatesepsilon -- hyperparameter preventing division by zero in Adam updatesnum_epochs -- number of epochsprint_cost -- True to print the cost every 1000 epochsReturns:parameters -- python dictionary containing your updated parameters"""L = len(layers_dims)  # number of layers in the neural networkscosts = []  # to keep track of the costt = 0  # initializing the counter required for Adam updateseed = 10  # For grading purposes, so that your "random" minibatches are the same as ours# Initialize parametersparameters = initialize_parameters(layers_dims)# Initialize the optimizerif optimizer == "gd":pass  # no initialization required for gradient descentelif optimizer == "momentum":v = initialize_velocity(parameters)elif optimizer == "adam":v, s = initialize_adam(parameters)# Optimization loopfor i in range(num_epochs):# Define the random minibatches. We increment the seed to reshuffle differently the dataset after each epochseed = seed + 1minibatches = random_mini_batches(X, Y, mini_batch_size, seed)for minibatch in minibatches:# Select a minibatch(minibatch_X, minibatch_Y) = minibatch# Forward propagationa3, caches = forward_propagation(minibatch_X, parameters)# Compute costcost = compute_cost(a3, minibatch_Y)# Backward propagationgrads = backward_propagation(minibatch_X, minibatch_Y, caches)# Update parametersif optimizer == "gd":parameters = update_parameters_with_gd(parameters, grads, learning_rate)elif optimizer == "momentum":parameters, v = update_parameters_with_momentum(parameters, grads, v, beta, learning_rate)elif optimizer == "adam":t = t + 1  # Adam counterparameters, v, s = update_parameters_with_adam(parameters, grads, v, s,t, learning_rate, beta1, beta2, epsilon)# Print the cost every 1000 epochif print_cost and i % 1000 == 0:print("Cost after epoch %i: %f" % (i, cost))if print_cost and i % 100 == 0:costs.append(cost)# plot the costplt.plot(costs)plt.ylabel('cost')plt.xlabel('epochs (per 100)')plt.title("Learning rate = " + str(learning_rate))plt.show()return parameters

没错，这个函数就更新参数用的，然后由于会用于三种方法，所以里面有选择语句(比如32到38行)。
另外，还需要注意的地方是，mini-batch的前向传播与反向传播(47到69行)。47行上方的mini-batchs参数的划分，然后对每一个batch循环来更新参数paramrter。

2. 然后记住，跑model函数之前需要先导入数据

#跑一下这个model函数
#先导入数据
train_X, train_Y = load_dataset()

3. 现在来看看普通的mini-batch算法，同样，这里我调换了一下顺序

其实就是调用之前写的函数(model)，直接先上代码（注意，这里要先导入数据，上方model函数的后面写了导入代码）

#普通mini-batch下降
# train 3-layer model
layers_dims = [train_X.shape[0], 5, 2, 1]
parameters = model(train_X, train_Y, layers_dims, optimizer = "gd")# Predict
predictions = predict(train_X, train_Y, parameters)# Plot decision boundary
plt.title("Model with Gradient Descent optimization")
axes = plt.gca()
axes.set_xlim([-1.5,2.5])
axes.set_ylim([-1,1.5])
plot_decision_boundary(lambda x: predict_dec(parameters, x.T), train_X, train_Y)
print("=================================")

大家可以看到，就是调用model函数得到参数，然后调用predict函数来得到易看懂的结果,结果如下

Cost after epoch 0: 0.690736
Cost after epoch 1000: 0.685273
Cost after epoch 2000: 0.647072
Cost after epoch 3000: 0.619525
Cost after epoch 4000: 0.576584
Cost after epoch 5000: 0.607243
Cost after epoch 6000: 0.529403
Cost after epoch 7000: 0.460768
Cost after epoch 8000: 0.465586
Cost after epoch 9000: 0.464518
Accuracy: 0.796666666667

cost曲线为

然后我们来看看边界划分：

5. 现在我们开始写monmentum(动态梯度下降)算法

1.首先进行参数初始化

# GRADED FUNCTION: initialize_velocity
def initialize_velocity(parameters):"""Initializes the velocity as a python dictionary with:- keys: "dW1", "db1", ..., "dWL", "dbL"- values: numpy arrays of zeros of the same shape as the corresponding gradients/parameters.Arguments:parameters -- python dictionary containing your parameters.parameters['W' + str(l)] = Wlparameters['b' + str(l)] = blReturns:v -- python dictionary containing the current velocity.v['dW' + str(l)] = velocity of dWlv['db' + str(l)] = velocity of dbl"""L = len(parameters) // 2  # number of layers in the neural networksv = {}# Initialize velocityfor l in range(L):### START CODE HERE ### (approx. 2 lines)v["dW" + str(l + 1)] = np.zeros((parameters["W" + str(l + 1)]).shape)v["db" + str(l + 1)] = np.zeros((parameters["b" + str(l + 1)]).shape)### END CODE HERE ###return v

没有什么惊奇的地方，初始化时v,b都为0(就不上输出结果了，一大堆0)，如果要输出看看，代码是这样的

#输出看看效果
parameters = initialize_velocity_test_case()v = initialize_velocity(parameters)
print("v[\"dW1\"] = " + str(v["dW1"]))
print("v[\"db1\"] = " + str(v["db1"]))
print("v[\"dW2\"] = " + str(v["dW2"]))
print("v[\"db2\"] = " + str(v["db2"]))
print("==================================")

2. 参数初始化完毕后，现在开始用momentum算法的更新参数W , b的值(注意，这里还有v的计算)

# GRADED FUNCTION: update_parameters_with_momentum
def update_parameters_with_momentum(parameters, grads, v, beta, learning_rate):"""Update parameters using MomentumArguments:parameters -- python dictionary containing your parameters:parameters['W' + str(l)] = Wlparameters['b' + str(l)] = blgrads -- python dictionary containing your gradients for each parameters:grads['dW' + str(l)] = dWlgrads['db' + str(l)] = dblv -- python dictionary containing the current velocity:v['dW' + str(l)] = ...v['db' + str(l)] = ...beta -- the momentum hyperparameter, scalarlearning_rate -- the learning rate, scalarReturns:parameters -- python dictionary containing your updated parametersv -- python dictionary containing your updated velocities"""L = len(parameters) // 2  # number of layers in the neural networks# Momentum update for each parameterfor l in range(L):### START CODE HERE ### (approx. 4 lines)# compute velocitiesv["dW" + str(l + 1)] = beta * v["dW" + str(l + 1)] + (1 - beta) * grads["dW" + str(l + 1)]v["db" + str(l + 1)] = beta * v["db" + str(l + 1)] + (1 - beta) * grads["db" + str(l + 1)]# update parametersparameters["W" + str(l + 1)] = parameters["W" + str(l + 1)] - learning_rate * v["dW" + str(l + 1)]parameters["b" + str(l + 1)] = parameters["b" + str(l +1 )] - learning_rate * v["db" + str(l + 1)]### END CODE HERE ###return parameters, v

现在来看看执行效果

#现在来看看效果
parameters, grads, v = update_parameters_with_momentum_test_case()parameters, v = update_parameters_with_momentum(parameters, grads, v, beta = 0.9, learning_rate = 0.01)
print("W1 = " + str(parameters["W1"]))
print("b1 = " + str(parameters["b1"]))
print("W2 = " + str(parameters["W2"]))
print("b2 = " + str(parameters["b2"]))
print("v[\"dW1\"] = " + str(v["dW1"]))
print("v[\"db1\"] = " + str(v["db1"]))
print("v[\"dW2\"] = " + str(v["dW2"]))
print("v[\"db2\"] = " + str(v["db2"]))
#其实v["dW"]啥的，都是在一次次循环里更新的，，，确实就是只要初始化为0他的更新是和parameters里的W与b一起的
print("================================")

输出长这样：

W1 = [[ 1.62544598 -0.61290114 -0.52907334][-1.07347112  0.86450677 -2.30085497]]
b1 = [[ 1.74493465][-0.76027113]]
W2 = [[ 0.31930698 -0.24990073  1.4627996 ][-2.05974396 -0.32173003 -0.38320915][ 1.13444069 -1.0998786  -0.1713109 ]]
b2 = [[-0.87809283][ 0.04055394][ 0.58207317]]
v["dW1"] = [[-0.11006192  0.11447237  0.09015907][ 0.05024943  0.09008559 -0.06837279]]
v["db1"] = [[-0.01228902][-0.09357694]]
v["dW2"] = [[-0.02678881  0.05303555 -0.06916608][-0.03967535 -0.06871727 -0.08452056][-0.06712461 -0.00126646 -0.11173103]]
v["db2"] = [[ 0.02344157][ 0.16598022][ 0.07420442]]

3. 好了，现在开始用momentum的mini-batch梯度下降

代码如下：

# train 3-layer model
layers_dims = [train_X.shape[0], 5, 2, 1]
parameters = model(train_X, train_Y, layers_dims, beta = 0.9, optimizer = "momentum")# Predict
predictions = predict(train_X, train_Y, parameters)# Plot decision boundary
plt.title("Model with Momentum optimization")
axes = plt.gca()
axes.set_xlim([-1.5,2.5])
axes.set_ylim([-1,1.5])
plot_decision_boundary(lambda x: predict_dec(parameters, x.T), train_X, train_Y)
print("======================================")

输出长这样：

Cost after epoch 0: 0.690741
Cost after epoch 1000: 0.685341
Cost after epoch 2000: 0.647145
Cost after epoch 3000: 0.619594
Cost after epoch 4000: 0.576665
Cost after epoch 5000: 0.607324
Cost after epoch 6000: 0.529476
Cost after epoch 7000: 0.460936
Cost after epoch 8000: 0.465780
Cost after epoch 9000: 0.464740
Accuracy: 0.796666666667

cost曲线

然后现在看看边界划分

6. 接下来看Adam优化方法(则种方法像结合monmentum方法以及RMSprop方法，所以这里没有单独谈RMSprop方法)

1. 同样，先是初始化参数(全都为0)

# GRADED FUNCTION: initialize_adam
def initialize_adam(parameters):"""Initializes v and s as two python dictionaries with:- keys: "dW1", "db1", ..., "dWL", "dbL"- values: numpy arrays of zeros of the same shape as the corresponding gradients/parameters.Arguments:parameters -- python dictionary containing your parameters.parameters["W" + str(l)] = Wlparameters["b" + str(l)] = blReturns:v -- python dictionary that will contain the exponentially weighted average of the gradient.v["dW" + str(l)] = ...v["db" + str(l)] = ...s -- python dictionary that will contain the exponentially weighted average of the squared gradient.s["dW" + str(l)] = ...s["db" + str(l)] = ..."""L = len(parameters) // 2  # number of layers in the neural networksv = {}s = {}# Initialize v, s. Input: "parameters". Outputs: "v, s".for l in range(L):### START CODE HERE ### (approx. 4 lines)v["dW" + str(l+1)] = np.zeros(parameters["W" + str(l+1)].shape)v["db" + str(l+1)] = np.zeros(parameters["b" + str(l+1)].shape)s["dW" + str(l+1)] = np.zeros(parameters["W" + str(l+1)].shape)s["db" + str(l+1)] = np.zeros(parameters["b" + str(l+1)].shape)### END CODE HERE ###return v, s

和之前类似，输代码是(这里就不输出了，全是0)：

#上面是为Adam算法进行了v["dW"],v["db"],s["dW"],s["sb"]的初始化
#来看看效果
parameters = initialize_adam_test_case()v, s = initialize_adam(parameters)
print("v[\"dW1\"] = " + str(v["dW1"]))
print("v[\"db1\"] = " + str(v["db1"]))
print("v[\"dW2\"] = " + str(v["dW2"]))
print("v[\"db2\"] = " + str(v["db2"]))
print("s[\"dW1\"] = " + str(s["dW1"]))
print("s[\"db1\"] = " + str(s["db1"]))
print("s[\"dW2\"] = " + str(s["dW2"]))
print("s[\"db2\"] = " + str(s["db2"]))
print("==============================")

2. 接下来是更新Adam算法的参数

主要是注意s参数的更新，v的更新和之前的类似

# GRADED FUNCTION: update_parameters_with_adam
def update_parameters_with_adam(parameters, grads, v, s, t, learning_rate=0.01,beta1=0.9, beta2=0.999, epsilon=1e-8):"""Update parameters using AdamArguments:parameters -- python dictionary containing your parameters:parameters['W' + str(l)] = Wlparameters['b' + str(l)] = blgrads -- python dictionary containing your gradients for each parameters:grads['dW' + str(l)] = dWlgrads['db' + str(l)] = dblv -- Adam variable, moving average of the first gradient, python dictionarys -- Adam variable, moving average of the squared gradient, python dictionarylearning_rate -- the learning rate, scalar.beta1 -- Exponential decay hyperparameter for the first moment estimatesbeta2 -- Exponential decay hyperparameter for the second moment estimatesepsilon -- hyperparameter preventing division by zero in Adam updatesReturns:parameters -- python dictionary containing your updated parametersv -- Adam variable, moving average of the first gradient, python dictionarys -- Adam variable, moving average of the squared gradient, python dictionary"""L = len(parameters) // 2  # number of layers in the neural networksv_corrected = {}  # Initializing first moment estimate, python dictionarys_corrected = {}  # Initializing second moment estimate, python dictionary# Perform Adam update on all parametersfor l in range(L):# Moving average of the gradients. Inputs: "v, grads, beta1". Output: "v".### START CODE HERE ### (approx. 2 lines)v["dW" + str(l + 1)] = beta1 * v["dW" + str(l + 1)] + (1 - beta1) * grads["dW" + str(l + 1)]v["db" + str(l + 1)] = beta1 * v["db" + str(l + 1)] + (1 - beta1) * grads["db" + str(l + 1)]### END CODE HERE #### Compute bias-corrected first moment estimate. Inputs: "v, beta1, t". Output: "v_corrected".### START CODE HERE ### (approx. 2 lines)#下面进行偏差修正v_corrected["dW" + str(l + 1)] = v["dW" + str(l + 1)] / (1 - beta1)v_corrected["db" + str(l + 1)] = v["db" + str(l + 1)] / (1 - beta1)# 这里有个疑问，和Ng课上讲的不太一样感觉，beta2不用该有一个t次方么？### END CODE HERE #### Moving average of the squared gradients. Inputs: "s, grads, beta2". Output: "s".### START CODE HERE ### (approx. 2 lines)s["dW" + str(l + 1)] = beta2 * s["dW" + str(l + 1)] + (1 - beta2) * grads["dW" + str(l + 1)]**2s["db" + str(l + 1)] = beta2 * s["db" + str(l + 1)] + (1 - beta2) * grads["db" + str(l + 1)]**2### END CODE HERE #### Compute bias-corrected second raw moment estimate. Inputs: "s, beta2, t". Output: "s_corrected".### START CODE HERE ### (approx. 2 lines)s_corrected["dW" + str(l + 1)] = s["dW" + str(l + 1)] / (1 - beta2)s_corrected["db" + str(l + 1)] = s["db" + str(l + 1)] / (1 - beta2)#这里有个疑问，和Ng课上讲的不太一样感觉，beta2不用该有一个t次方么？### END CODE HERE #### Update parameters. Inputs: "parameters, learning_rate, v_corrected, s_corrected, epsilon". Output: "parameters".### START CODE HERE ### (approx. 2 lines)parameters["W" + str(l + 1)] = parameters["W" + str(l + 1)] - learning_rate * (v_corrected["dW" + str(l + 1)] / (np.sqrt(s_corrected["dW" + str(l + 1)]) + epsilon))parameters["b" + str(l + 1)] = parameters["b" + str(l + 1)] - learning_rate * (v_corrected["db" + str(l + 1)] / (np.sqrt(s_corrected["db" + str(l + 1)]) + epsilon))### END CODE HERE ###return parameters, v, s

另外说明一点，对于42,43,55,56行是在进行偏差修正。
还有就是，就像我57行中注释的一样，在课程中讲到过有一个beta2^t，但是这里却没有这个，我还没有找到为什么，但是由于课程中页提到，偏差修正很多时候不进行，对最后结果一般也没有太大影响，所以这里我貌似没有发现什么问题。

现在我们来看看检测代码：

#测试一下
parameters, grads, v, s = update_parameters_with_adam_test_case()
parameters, v, s  = update_parameters_with_adam(parameters, grads, v, s, t = 2)print("W1 = " + str(parameters["W1"]))
print("b1 = " + str(parameters["b1"]))
print("W2 = " + str(parameters["W2"]))
print("b2 = " + str(parameters["b2"]))
print("v[\"dW1\"] = " + str(v["dW1"]))
print("v[\"db1\"] = " + str(v["db1"]))
print("v[\"dW2\"] = " + str(v["dW2"]))
print("v[\"db2\"] = " + str(v["db2"]))
print("s[\"dW1\"] = " + str(s["dW1"]))
print("s[\"db1\"] = " + str(s["db1"]))
print("s[\"dW2\"] = " + str(s["dW2"]))
print("s[\"db2\"] = " + str(s["db2"]))
print("=============================")

测试结果是这样：

W1 = [[ 1.63434536 -0.62175641 -0.53817175][-1.08296862  0.85540763 -2.2915387 ]]
b1 = [[ 1.75481176][-0.7512069 ]]
W2 = [[ 0.3290391  -0.25937038  1.47210794][-2.05014071 -0.3124172  -0.37405435][ 1.14376944 -1.08989128 -0.16242821]]
b2 = [[-0.88785842][ 0.03221375][ 0.57281521]]
v["dW1"] = [[-0.11006192  0.11447237  0.09015907][ 0.05024943  0.09008559 -0.06837279]]
v["db1"] = [[-0.01228902][-0.09357694]]
v["dW2"] = [[-0.02678881  0.05303555 -0.06916608][-0.03967535 -0.06871727 -0.08452056][-0.06712461 -0.00126646 -0.11173103]]
v["db2"] = [[ 0.02344157][ 0.16598022][ 0.07420442]]
s["dW1"] = [[ 0.00121136  0.00131039  0.00081287][ 0.0002525   0.00081154  0.00046748]]
s["db1"] = [[  1.51020075e-05][  8.75664434e-04]]
s["dW2"] = [[  7.17640232e-05   2.81276921e-04   4.78394595e-04][  1.57413361e-04   4.72206320e-04   7.14372576e-04][  4.50571368e-04   1.60392066e-07   1.24838242e-03]]
s["db2"] = [[  5.49507194e-05][  2.75494327e-03][  5.50629536e-04]]

3. 现在放大招，开始用Adma的mini-batch梯度下降(同样，不要忘记导入数据哦)

# train 3-layer model
layers_dims = [train_X.shape[0], 5, 2, 1]
parameters = model(train_X, train_Y, layers_dims, optimizer = "adam")# Predict
predictions = predict(train_X, train_Y, parameters)# Plot decision boundary
plt.title("Model with Adam optimization")
axes = plt.gca()
axes.set_xlim([-1.5,2.5])
axes.set_ylim([-1,1.5])
plot_decision_boundary(lambda x: predict_dec(parameters, x.T), train_X, train_Y)

结果是这样：

Cost after epoch 0: 0.690468
Cost after epoch 1000: 0.325328
Cost after epoch 2000: 0.223535
Cost after epoch 3000: 0.109833
Cost after epoch 4000: 0.140489
Cost after epoch 5000: 0.111570
Cost after epoch 6000: 0.128548
Cost after epoch 7000: 0.036306
Cost after epoch 8000: 0.128252
Cost after epoch 9000: 0.211592
Accuracy: 0.943333333333

cost曲线

边界图片

感叹一下，这个优化方法真的让分类效果好了不止一点点。

7. 总结一下：

三种方法，分类准确度一个比一个高，最后，Adam算法胜出，前两个都是：
0.796666666667
到了Adam算法，直接飙升到：
0.943333333333
可见优化算法不止对训练速度有大大的改善，还对分类效果有不小的影响。

这篇关于deep_learning_month2_week2_Optimization_methods的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---