神经网络基础常识（mini_batch梯度下降，指数加权平均、动量梯度下降、RMSPROP算法、Adam优化算法、学习率衰减）

lvkuozi

mini_batch梯度下降算法

在训练网络时，如果训练数据非常复杂，那么把所有训练数据都输入一次神经网络需要非常长的时间，此外，这些数据可能底子无法一次性装入内存。为了加快训练速度
batch梯度下降：每次迭代都需要遍历整个训练集，可以预期每次迭代损掉城市下降。
随机梯度下降：每次迭代中，只会使用1个样本。当训练集较大时，随机梯度下降可以更快，但是参数会向最小值摆动，而不是平稳的收敛。
mini_batch:把大的训练集分成多个小的子集（mini_batch），每次迭代就取一个子集（mini_batch），所以每次迭代都是在训练分歧的样本(（mini_batch),其损掉会有震荡，但是总体趋势是下降的。
数据量斗劲小的化（小于2000），一般采用batch梯度下降。
样本量斗劲大的情况，一般采用mini_batch ，mini_batch一般设置为2的n次方，一般是2的6次方到2的9次方之间。
指数加权平均值

具体参考：
优化算法之指数加权平均详解_修炼之路的博客-CSDN博客
以气温为例
局部平均值：
V_{t}=\beta*V_{t-1} +(1-\beta)*\theta_{t}  
\theta 暗示当天的温度，V暗示局部平均值， V_{t} 暗示第t天的局部平均温度， \theta_{t} 暗示第t天的温度。当 \beta =0.9时， V_{t} 可看作是1/(1- \beta )=10天的平均温度。
如果你想要计算10天局部温度的平均值，你需要保留比来10天的温度，此刻，在计算局部平均值的时候，你只需要保留前一个的加权平均值，相对于直接计算平均值，精确度没有那么高。
修正偏差
通过 V_{t}=1/(1-\beta_{t}) 来修正指数加权平均的误差，随着t的增大，1- \beta_{t} 会趋近于1， \beta_{t} 趋近于0，所以偏差修正对于后期的指数加权平均没有影响。
注意：如果你对前期的局部的平均值的精度没有要求，可以使用偏差修正，偏差修正主要修正的是前期的局部平均值的误差。
动量梯度下降

普通的梯度下降法：
w=w-\alpha *dw
采用动量梯度下降之后
V_{dw}=\beta dw +（1-\beta）dw
更新参数时：
w=w-\alpha V_{dw}
颠末实践证明：
\beta 取0.9时成果斗劲好
RMSPROP算法

RMSPROP 算法，全称 root mean square prop。为了进一步优化损掉函数在更新中的存在摆动幅度更大的问题，而且进一步加快函数的收敛速度。RMSPROP算法对权重w和偏置b的梯度使用微分平方和加权平均数。
在第t轮的迭代中
dw的平方和是 dw^{2} ，db的平方是 db^{2} ，如果严谨些，防止分母为0，在分数下加一个非常小的值 \varepsilon ，凡是取为 10^{-8}
S_{dw}=\beta* S_{dw}+(1-\beta)dw^{2}
S_{db}=\beta* S_{db}+(1-\beta)db^{2}
w=w-\alpha\frac{dw}{\sqrt{\sqrt{S_{dw}}}+\varepsilon}
b=b-\alpha\frac{db}{\sqrt{\sqrt{S_{db}}}+\varepsilon}
这样的作法 有利于消除摆动幅度大的标的目的，用来修正摆动幅度，是的各个维度的摆动幅度都斗劲小，另一方面也使得网络函数的收敛速度更快，比如dw和db有一个值斗劲大的时候，那么我们更新权重或者偏置的时候，除以之前累积的梯度的平方根，这样就使得更新的幅度更小。
Adam优化算法：结合了Momentum和RMSprop算法
V_{dw}=0         S_{dw}=0 V_{db}=0      S_{db}=0
compute dw,db using  min_batch
     V_{dw}=\beta_{1}*V_{dw} + (1-\beta_{1})dw
     V_{db}=\beta_{1}*V_{db} + (1-\beta_{1})db
     S_{dw}=\beta_{2}*V_{dw} + (1-\beta_{2})dw^{2}
     S_{db}=\beta_{2}*V_{db} + (1-\beta_{2})db^{2}
V_{dw}^{corrected}=\frac{V_{dw}}{(1-\beta_{1}^{t})}
V_{db}^{corrected}=\frac{V_{db}}{(1-\beta_{1}^{t})}
S_{dw}^{corrected}=\frac{S_{dw}}{(1-\beta_{2}^{t})}
S_{db}^{corrected}=\frac{S_{db}}{(1-\beta_{2}^{t})}
w=w-\alpha*\frac{V_{dw}^{corrected}}{\sqrt{S_{dw}^{corrected}+\varepsilon}}
b=b-\alpha*\frac{V_{db}^{corrected}}{\sqrt{S_{db}^{corrected}+\varepsilon}}
\alpha 为学习
\beta_{1}  为0.9  dw
\beta_{2} 为0.999   dw^{2}
\varepsilon 为 10^{-8}
学习率衰减

慢慢减少 \alpha 的本质在于，在学习初期，你能承受较大的法式，当开始收敛时，小一些的学习率能让 法式小一些。
方式1： \alpha=\frac{1}{(1+decayrate+epochnum)}*\alpha_{0}
此中，decayrate是衰减率，epochnum是迭代次数， \alpha_{0} 是初始学习率
方式2： \alpha=0.95^{epochnum}\alpha_{0}
方式3： \alpha=\frac{k}{epochnum}*\alpha_{0} 或 \frac{k}{\sqrt{t}}    t为mini_batch
方式4：离散学习率，某个法式某个学习率，一会之后学习率减半，然后再减半。
方式5：手动调。
代码来自：【中文】【吴恩达课后编程作业】Course 2 - 改善深层神经网络 - 第二周作业_何宽的博客-CSDN博客

1. import numpy as  np
2. import matplotlib.pyplot as plt
3. import scipy.io
5. import math
6. import sklearn
7. import sklearn.datasets
8. import opt_utils
9. import testCase
11. plt.rcParams['figure.figsize']=(7.0,4.0)
12. plt.rcParams[”image.interpolation”]='nearest'
14. plt.rcParams['image.cmap']='gray'
16. #梯度下降
18. def update_parameters_with_gd(parameters,grads,learning_rate):
19.     ”””
20.     使用梯度下降更新参数
21.     参数
22.     :param parameters: 字典，包含了要更新的参数
23.     parameter['W'+str(l)]=Wl
24.     parameter['b'+str(l)]=bl
26.     grads -字典，包含了每一个梯度值用以更新参数
27.     :param grads:
28.     grads['dw'+str(l)]=dwl
29.     grads['db'+str(l)]=dbl
30.     :param learning_rate: 学习率
31.     :return:
32.     返回值：
33.     :parameter-字典，包含了更新后的参数
36.     ”””
37.     L=len(parameters)//2 #神经网络的层数
38.     #更新每个参数
39.     for l in range(L):
40.         parameters[”W”+str(l+1)]=parameters[”W”+str(l+1)]-learning_rate*grads[”dW”+str(l+1)]
41.         parameters[”b”+str(l+1)]=parameters[”b”+str(l+1)]-learning_rate*grads[”db”+str(l+1)]
42.     return parameters
44. # #测试
45. # print(”------------------------------------测试update_parameters_with_gd-------------------------------”)
46. # parameters,grads,learning_rate=testCase.update_parameters_with_gd_test_case()
47. # parameters=update_parameters_with_gd(parameters,grads,learning_rate)
48. #
49. # print(”W1=”+str(parameters[”W1”]))
50. # print(”b1=”+str(parameters[”b1”]))
51. # print(”W2=”+str(parameters[”W2”]))
52. # print(”b2=”+str(parameters[”b2”]))
54. # #随机梯度下降
55. # X=data_input
56. # Y=labels
57. # parameters=initialize_parameters(layers_dims)
58. # for i in range(0,num_iterations):
59. #     #前向传布
60. #     A,cache=forward_propagation(X,parameters)
61. #     #计算损掉
62. #     cost=copmute_cost(A,Y)
63. #     #反向传布
64. #     grads=backward_propagation(X,Y,cache)
65. #     #更新参数
66. #     parameters=update_parameters(parameters,grads)
67. #
68. # #随机梯度下降
69. # X=data_input
70. # Y=labels
71. # parameters=initialize_parameters(layers_dims)
72. # for i in (0,num_iteration):
73. #     for j in  m:
74. #         #前向传布
75. #          A,cache=forward_propagation(X,parameters)
76. #         #计算成本
77. #          cost=compute_cost(A,Y)
78. #         #后向传布
79. #     grads=backward_propagation(X,Y,cache)
80. #     #更新参数
81. #     parameters=update_parameters(parameters,grads)
83. #mini_batch
85. # #第一个mini_batch
86. # first_mini_batch_X=shuffled_X[:,0:mini_batch_size]
87. # #第二个mini-batch
88. # second_mini_batch_X=shuffled_X[:,mini_batch_size:2*mini_batch_size]
91. def random_mini_batches(X,Y,mini_batch_size=64,seed=0):
92.     ”””
93.     从(X,Y)中创建一个随机的mini_batch列表
94.     :param X: 输入数据，维度为(输入节点数，样本的数量)
95.     :param Y: 对应的是X的标签，[1|0](蓝，红)，样本的数量
96.     :param mini_batch_size: 每个mini-batch的样本数量
97.     :return:
98.     mini-batchs-一个同步列表，维度为（mini_batch_X,mini_batch_Y）
99.     ”””
101.     np.random.seed(seed) #指定随机种子
102.     m=X.shape[1]
103.     mini_batchs=[]
106.     #第一步打乱挨次
107.     permutation=list(np.random.permutation(m)) #它会返回一个长为m的随机数，且里面的数是从0到m-1
108.     shuffled_X=X[:,permutation] #将每一列的数据按permutation的挨次从头摆列
109.     shuffled_Y=Y[:,permutation].reshape((1,m))
111.     #第二步，分割
112.     num_complete_minibatches=math.floor(m/mini_batch_size) #把你的训练集分割成多少份，如果是99.99，则返回值是99，剩下的0.99会被舍弃
113.     for k in range(0,num_complete_minibatches+1):
114.         mini_batch_X=shuffled_X[:,k*mini_batch_size:(k+1)*mini_batch_size]
115.         mini_batch_Y=shuffled_Y[:,k*mini_batch_size:(k+1)*mini_batch_size]
116.         # print(”mini_batch_X.shape[1]”,mini_batch_X.shape[1])
117.         mini_batch = (mini_batch_X, mini_batch_Y)
118.         mini_batchs.append(mini_batch)
119.         #如果训练集的大小刚好是mini_batch_size的整数倍，那么这里已经措置完。
120.         #如果训练集的大小不是mini_batch_size的整数倍，那么最后必定会剩下一些。
122.     if m % mini_batch_size!=0:
123.         #获取最后残剩的部门
124.         mini_batch_X=shuffled_X[:,mini_batch_size*num_complete_minibatches:]
125.         mini_batch_Y=shuffled_Y[:,mini_batch_size*num_complete_minibatches:]
126.         mini_batch=(mini_batch_X,mini_batch_Y)
127.         mini_batchs.append(mini_batch)
129.     return mini_batchs
131. # print(”-------------测试random_mini_batches------------------------------------------------”)
132. # X_aasess,Y_assess,mini_batch_size=testCase.random_mini_batches_test_case()
133. # print(X_aasess.shape[1])
134. # print(mini_batch_size)
135. # mini_batchs=random_mini_batches(X_aasess,Y_assess,mini_batch_size)
136. #
137. # print(”第1个mini_batch_X的维度为：”,mini_batchs[0][0].shape)
138. # print(”第1个min_batch_Y的维度为”,mini_batchs[0][1].shape)
139. # print(”第2个mini_batch_X的维度为：”, mini_batchs[1][0].shape)
140. # print(”第2个min_batch_Y的维度为”, mini_batchs[1][1].shape)
141. # print(”第3个mini_batch_X的维度为：”, mini_batchs[2][0].shape)
142. # print(”第3个min_batch_Y的维度为”, mini_batchs[2][1].shape)
144. #包含动量的梯度下降
145. def initialze_velocity(parameters):
146.     ”””
147.     初始化速度，velocity 是一个字典
148.     -keys:”dw1”,”db1”,....,”dWL”,”dbL”
149.     -values:与相应的梯度/参数维度不异的值为0的矩阵
150.     参数：
151.     :parameters -一个字典，包含了以下参数
152.         :parameter[”W”+str(1)]=W1
153.         :parameter[”b”+str(1)]=b1
154.     返回：
155.     v- 一个字典变量，包含了 以下参数
156.       v[”dw”+str(1)]=dw1的速度
157.       v[”db”+str(1)]=db1的速度
158.     ”””
160.     L=len(parameters)//2
161.     v={}
162.     for l in range(L):
163.         v[”dW”+str(l+1)]=np.zeros_like(parameters[”W”+str(l+1)])
164.         v[”db”+str(l+1)]=np.zeros_like(parameters[”b”+str(l+1)])
165.     return v
166. #测试一下
167. #
168. # print(”------------------测试initialize_velocity---------------------------”)
169. # parameters=testCase.initialize_velocity_test_case()
170. # v=initialze_velocity(parameters)
171. #
172. # print('v[”dW1”]=' +str(v[”dW1”]))
173. # print('v[”db1”]=' +str(v[”db1”]))
174. # print('v[”dW2”]=' +str(v[”dW2”]))
175. # print('v[”db2”]='  +str(v[”db2”]))
178. def update_parameters_with_momentun(parameters,grads,v,beta,learning_rate):
179.     ”””
180.     使用动量更新参数
181.     :param parameters: 一个字典的变量，包含了 以下字段：
182.         :parameter[”W”+str(1)]=W1
183.         parameter[”b”+str(1)]=b1
184.     :param grads: 一个包含梯度值的字典变量，具有以下字段
185.         grads[”dW”+str(l)]=dW1
186.         grads[”db”+str(l)]=db1
187.     :param v: 包含当前速度的字典变量，具有以下字段:
188.            v[”dW”+str(l)]=...
189.            v[”db”+str(l)]=
190.     :param beta: 超参数，动量，实数
191.     :param learning_rate: 学习率，实数
192.     :return:
193.         :parameter 更新后的参数字典
194.         v-包含了更新后的速度变量
195.     ”””
196.     L=len(parameters)//2
197.     for l in  range(L):
198.         #计算速度
199.         v[”dW”+str(l+1)]=beta*v[”dW”+str(l+1)]+(1-beta)*grads[”dW”+str(l+1)]
200.         v[”db” + str(l + 1)] = beta * v[”db” + str(l + 1)] + (1 - beta) * grads[”db” + str(l + 1)]
202.         #更新参数
203.         parameters[”W”+str(l+1)]=parameters[”W”+str(l+1)]-learning_rate*v['dW'+str(l+1)]
204.         parameters[”b” + str(l + 1)] = parameters[”b” + str(l + 1)] - learning_rate * v['db' + str(l + 1)]
206.     return  parameters,v
207. #测试
209. # print(”------------------测试update_parametes_with_momentun-------------------------”)
210. # parameters,grads,v=testCase.update_parameters_with_momentum_test_case()
211. # update_parameters_with_momentun(parameters,grads,v,beta=0.9,learning_rate=0.01)
213. # print(”W1=”+str(parameters[”W1”]))
214. # print(”b1=”+str(parameters[”b1”]))
215. #
216. # print(”W2=”+str(parameters[”W2”]))
217. # print(”b2=”+str(parameters[”b2”]))
218. #
219. # print('v[”dW1”]='+str(v[”dW1”]))
220. # print('v[”db1”]='+str(v[”db1”]))
221. #
222. # print('v[”dW2”]='+str(v[”dW2”]))
223. # print('v[”db2”]='+str(v[”db2”]))
225. #Adam算法
227. def initialize_adam(parameters):
228.     ”””
229.     初始化v和s，它们都是字典类型的变量，都包含了以下字段
230.     -keys：”dW1”,”db1“,...,”dWL”,”dbL”
231.     :param paramters: 包含了以下参数的字典变量
233.        :parameter[”W”+str(l)]=Wl
234.         :parameter[”b”+str(l)]=bl
235.     :return:
237.     v -包含梯度的指数加权平均值，字段如下
238.      V[”dW”+str(l)]=
239.      v[”db”+str(l)]=
240.     s- 包含平方梯度的指数加权平均值，字段如下
241.        s[”dW”+str(l)]=
242.        s[”db”+str(l)]=
243.     ”””
245.     L=len(parameters)//2
246.     v={}
247.     s={}
248.     for l in  range(L):
249.         v[”dW”+str(l+1)]=np.zeros_like(parameters[”W”+str(l+1)])
250.         v[”db” + str(l + 1)] = np.zeros_like(parameters[”b” + str(l + 1)])
252.         s[”dW” + str(l + 1)] = np.zeros_like(parameters[”W” + str(l + 1)])
253.         s[”db” + str(l + 1)] = np.zeros_like(parameters[”b” + str(l + 1)])
255.     return (v,s)
257. # print(”--------------------------测试initalize_adam-----------------------------------”)
258. # parameters=testCase.initialize_adam_test_case()
259. # v,s=initialize_adam(parameters)
261. # print('v[”dW1”]='+str(v[”dW1”]))
262. # print('v[”db1”]='+str(v[”db1”]))
263. # print('v[”dW2”]='+str(v[”dW2”]))
264. # print('v[”db2”]='+str(v[”db2”]))
265. #
266. # print('s[”dW1”]='+str(s[”dW1”]))
267. # print('s[”db1”]='+str(s[”db1”]))
268. # print('s[”dW2”]='+str(s[”dW2”]))
269. # print('s[”db2”]='+str(s[”db2”]))
271. def upadate_parameters_with_adam(parameters,grads,v,s,t,learning_rate=0.01,beta1=0.9,beta2=0.999,epsilon=1e-8):
272.     ”””
273.     使用Adam更新参数
274.     :param parameters:
275.           :parameter['W'+str(l)]=Wl
276.           :parameter['B'+str(l)]=b1
277.     :param grads: 包含了梯度值的字典，有以下key值
278.           grads['dW'+str(l)]=dW1
279.           grads['db'+str(l)]=db1
281.     :param v: Adam变量，第一个梯度的移动平均值，是一个字典类型的变量
282.     :param s: Adam变量，平方梯度的移动平均值，是一个字典类型的变量
283.     :param t: 当前迭代的次数
284.     :param learning_rate: 学习率
285.     :param beta1: 动量，超参数，用于第一阶段，使用的曲线Y值不从0开始
286.     :param beta2: RMSprop的一个参数，超参数
287.     :param epsilon: 防止除0操作(分母为0)
288.     :return:
290.     :parameters-更新后的参数
291.     v 第一个梯度的移动平均值，是一个字典类型的变量
292.     s 平均梯度的移动平均值，是一个字典类型的变量
293.     ”””
295.     L=len(parameters)//2
296.     v_corrected={}
297.     s_corrected={}
299.     for l in range(L):
300.         #梯度的移动平均值，输入v,grads,beta1,输出：”V“
301.         v[”dW” + str(l+1)]=beta1 * v[”dW”+ str(l+1)]+(1-beta1)* grads[”dW”+str(l+1)]
302.         v[”db”+str(l+1)] = beta1 * v[”db”+str(l+1)] +(1-beta1)*grads[”db”+str(l + 1)]
304.         #计算第一阶段的偏差修成后的估计值，输入”v,beta1,t”,输出：”v_corrected”
305.         v_corrected[”dW”+str(l+1)]=v[”dW”+str(l+1)]/(1-np.power(beta1,t))
306.         v_corrected[”db” + str(l + 1)] = v[”db” + str(l + 1)] / (1 - np.power(beta1, t))
309.         #计算平方梯度的移动平均值，输入：”s,grads,beta2“,输出”s“
310.         s[”dW”+str(l+1)]=beta2*s[”dW”+str(l+1)]+(1-beta2)*np.square(grads[”dW”+str(l+1)])
311.         s[”db” + str(l + 1)] = beta2 * s[”db” + str(l + 1)] + (1 - beta2) * np.square(grads[”db” + str(l + 1)])
314.         #计算第二极端的偏差修正后的估计值，输入：”s,grads,beta2,t”,输出s_corrected
315.         s_corrected[”dW”+str(l+1)]=s[”dW”+str(l+1)]/(1-np.power(beta2,t))
316.         s_corrected[”db” + str(l + 1)] = s[”db” + str(l + 1)] / (1 - np.power(beta2, t))
318.         #更新参数，输入”parameters，learning_rate,v_corrected,s_corrected,eplsion”,输出“parameters”
319.         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))
320.         parameters[”W” + str(l + 1)] = parameters[”W” + str(l + 1)] - learning_rate * (
321.                     v_corrected[”dW” + str(l + 1)] / np.sqrt(s_corrected[”dW” + str(l + 1)] + epsilon))
323.     return (parameters,v,s)
326. # #测试一下
327. # print(”---------------------------------------测试update_with_parameters_with_adam----------------------------------------”)
328. # parameters,grads,v,s=testCase.update_parameters_with_adam_test_case()
329. # upadate_parameters_with_adam(parameters,grads,v,s,t=2)
331. # print(”W1=”+str(parameters[”W1”]))
332. # print(”b1=”+str(parameters[”b1”]))
333. #
334. # print(”W2=”+str(parameters[”W2”]))
335. # print(”b2=”+str(parameters[”b2”]))
336. #
337. # print('v[”dW1”]='+str(v[”dW1”]))
338. # print('v[”db1”]='+str(v[”db1”]))
339. # print('v[”dW2”]='+str(v[”dW2”]))
340. # print('v[”db2”]='+str(v[”db2”]))
341. #
342. # print('s[”dW1”]='+str(s[”dW1”]))
343. # print('s[”db1”]='+str(s[”db1”]))
344. # print('s[”dW2”]='+str(s[”dW2”]))
345. # print('s[”db2”]='+str(s[”db2”]))
346. #
348. 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,is_plot=True):
349.     ”””
350.     可以运行在分歧优化器模式下的3层神经网络
351.     参数
352.     :param X: 输入数据，维度为(2,输入的数据集里面样本数量)
353.     :param Y: 与X对应的标签
354.     :param layers_dims: 包含层数和节点数量的列表
355.     :param optimizer: 字符串类型的参数，用于选择优化类型，[”gd”|”momentum”|”adam”]
356.     :param learning_rate: 学习率
357.     :param mini_batch_size: 每个小批量数据集的大小
358.     :param beta: 用于动量优化的一个超参数
359.     :param beta1: 用于计算梯度后的指数衰减的估计的超参数
360.     :param beta2: 用于计算梯度后的指数衰减的估计的超参数
361.     :param epsilon: 用于Adam中避免除0的超参数，一般不更改
362.     :param num_epochs:整个训练集的遍历次数
363.     :param print_cost:是否打印误差值，每遍历1000次数据集打印一次，但是每100次记录一个误差值，又称每1000次代打印一次
364.     :param is_plot:是否绘制出曲线图
365.     :return:
366.     :parameters -包含了学习后的参数
367.     ”””
369.     L=len(layers_dims)
370.     costs=[]
371.     t=0 #每学习完一个mini_batch就增加1
372.     seed=10 #随机种子
374.     #初始化参数
375.     parameters=opt_utils.initialize_parameters(layers_dims)
377.     #选择优化器
378.     if optimizer=='gd':
379.         pass
380.     elif optimizer==”momentum”:
381.         v=initialze_velocity(parameters) #使用动量
382.     elif optimizer ==”adam”:
383.         v,s=initialize_adam(parameters) #使用Adam优化
384.     else:
385.         print(”optimizer 参数错误，法式退出”)
386.         exit(1)
388.     #开始学习
389.     for i in range(num_epochs):
390.         #定义随机minibatches，我们在每次遍历数据集之后增加种子以从头摆列数据集
391.         seed=seed+1
392.         minibatches=random_mini_batches(X,Y,mini_batch_size,seed)
394.         for minibatch in minibatches:
395.             #选择一个minibatch
396.             (minibatch_X,minibatch_Y)=minibatch
398.             #前向传布
399.             A3,cache=opt_utils.forward_propagation(minibatch_X,parameters)
401.             #计算误差
402.             cost=opt_utils.compute_cost(A3,minibatch_Y)
403.             #反向传布
404.             grads=opt_utils.backward_propagation(minibatch_X,minibatch_Y,cache)
406.             #更新参数
407.             if optimizer ==”gd”:
408.                 parameters=update_parameters_with_gd(parameters,grads,learning_rate)
409.             elif optimizer==”momentum”:
410.                 parameters,v=update_parameters_with_momentun(parameters,grads,v,beta,learning_rate)
411.             elif optimizer==”adam”:
412.                 t=t+1
413.                 parameters,v,s=upadate_parameters_with_adam(parameters,grads,v,s,t,learning_rate,beta1,beta2,epsilon)
415.             #记录误差值
416.         if i % 100 == 0:
417.             costs.append(cost)
418.             #是否打印误差值
419.         if print_cost and i % 1000 == 0:
420.             # print(i)
421.             print(”第”+str(i)+”次遍历整个数据集，当前误差值：”+str(cost))
423.             #是否绘制曲线图
424.     if is_plot:
425.         plt.plot(costs)
426.         plt.ylabel('cost')
428.         plt.xlabel('epochs(per 100)')
430.         plt.title(”Learning rate=”+str(learning_rate))
431.         plt.show()
433.     return parameters
436. train_X,train_Y=opt_utils.load_dataset(is_plot=False)
438. #梯度下降测试
439. # layers_dims=[train_X.shape[0],5,2,1]
440. # parameters=model(train_X,train_Y,layers_dims,optimizer=”gd”,is_plot=True)
441. # #
442. # #我们来绘制分类情况
443. # #预测
444. # predictions=opt_utils.predict(train_X,train_Y,parameters)
445. # # print(predictions)
446. # plt.title(”Model with Gradient Decent optimization”)
447. # axes=plt.gca()
448. # axes.set_xlim([-1.5,2.5])
449. # axes.set_ylim([-1,1.5])
450. # opt_utils.plot_decision_boundary(lambda x:opt_utils.predict_dec(parameters,x.T),train_X,train_Y)
452. #使用动量梯度下降
453. # layers_dims=[train_X.shape[0],5,2,1]
454. # parameters=model(train_X,train_Y,layers_dims,optimizer=”momentum”,is_plot=True)
455. #
456. # #我们来绘制分类情况
457. #预测
458. # predictions=opt_utils.predict(train_X,train_Y,parameters)
459. # # print(predictions)
460. # plt.title(”Model with Gradient Decent optimization”)
461. # axes=plt.gca()
462. # axes.set_xlim([-1.5,2.5])
463. # axes.set_ylim([-1,1.5])
464. # opt_utils.plot_decision_boundary(lambda x:opt_utils.predict_dec(parameters,x.T),train_X,train_Y)
466. #Adam优化后的梯度下降
468. layers_dims=[train_X.shape[0],5,2,1]
469. parameters=model(train_X,train_Y,layers_dims,optimizer=”adam”,is_plot=True)

复制代码