Unity开发者联盟收藏本站
发帖教程新人必读切换到宽版

 找回密码
 立即注册
Unity开发者联盟»论坛 › 3D Answers 技术讨论 › 技术讨论 Technology Answers › 神经网络基础常识（mini_batch梯度下降，指数加权平均、 ...
返回列表 发新帖
查看: 89|回复: 0

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

[复制链接]
发表于 2024-7-15 18:54 | 显示全部楼层 |阅读模式
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)
复制代码
回复

使用道具 举报

返回列表 发新帖
懒得打字嘛，点击右侧快捷回复 【右侧内容，后台自定义】
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

小黑屋|手机版|Unity开发者联盟 ( 粤ICP备20003399号 )

GMT+8, 2024-9-8 09:32 , Processed in 0.121527 second(s), 27 queries .

Powered by Discuz! X3.5 Licensed

© 2001-2024 Discuz! Team.

快速回复 返回顶部 返回列表