导航:首页 > 源码编译 > 优化分析神经算法

优化分析神经算法

发布时间:2023-03-11 07:04:34

❶ 优化神经网络梯度算法——Adam

"""
Created on Wed Oct 3 21:54:36 2018

@author: ltx
"""

import numpy as np
import matplotlib.pyplot as plt
import scipy.io
import math
import sklearn
import sklearn.datasets

import opt_utils
import testCase
plt.rcParams['figure.figsize'] = (7.0, 4.0) # set default size of plots
plt.rcParams['image.interpolation'] = 'nearest'
plt.rcParams['image.cmap'] = 'gray'

def GetMinibatch(X,Y,batch_number,seed=0):
np.random.seed(seed)#指定随机种子
m=X.shape[1]

print("-------------测试random_mini_batches-------------")
X_assess,Y_assess,mini_batch_size = testCase.random_mini_batches_test_case()
mini_batches = GetMinibatch(X_assess,Y_assess,mini_batch_size)

print("第1个mini_batch_X 的维度为:",mini_batches[0][0].shape)
print("第1个mini_batch_Y 的维度为:",mini_batches[0][1].shape)
print("第2个mini_batch_X 的维度为:",mini_batches[1][0].shape)
print("第2个mini_batch_Y 的维度为:",mini_batches[1][1].shape)
print("第3个mini_batch_X 的维度为:",mini_batches[2][0].shape)
print("第3个mini_batch_Y 的维度为:",mini_batches[2][1].shape)

def Initial_velocity(parameters):
L=len(parameters)//2 #L=4 //除后结果为整数,/除后结果为浮点数
V={}
for l in range(L):

print("-------------测试initialize_velocity-------------")
parameters = testCase.initialize_velocity_test_case()
v = Initial_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"]))

def UpdateWith_velocity (parameters,grads,V,beta,learning_rate):
L=len(parameters)//2
for l in range(L):
V["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)]

print("-------------测试update_parameters_with_momentun-------------")
parameters,grads,v = testCase.update_parameters_with_momentum_test_case()
UpdateWith_velocity (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"]))

def initial_Adam(parameters):
L=len(parameters)//2
S={}
V={}
for l in range(L):
S["dW"+str(1+l)]=np.zeros_like(parameters["W"+str(1+l)])
S["db"+str(1+l)]=np.zeros_like(parameters["b"+str(1+l)])

print("-------------测试initialize_adam-------------")
parameters = testCase.initialize_adam_test_case()
v,s = initial_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"]))

def Update_parameter_Adam(parameters,grads,V,S,t,learning_rate=0.01,beta1=0.9,beta2=0.999,epsilon=1e-8):
L=len(parameters)//2
V_corrected={}
S_corrected={}
for l in range(L):
V["dW"+str(1+l)]=beta1 V["dW"+str(1+l)]+(1-beta1) grads["dW"+str(1+l)]
V["db"+str(1+l)]=beta1 V["db"+str(1+l)]+(1-beta1) grads["db"+str(1+l)]

print("-------------测试update_with_parameters_with_adam-------------")
parameters , grads , v , s = testCase.update_parameters_with_adam_test_case()
Update_parameter_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"]))

def Upadate_parameter(parameters,grads,learing_rate=0.8):
L=len(parameters)//2
for l in range(L):
parameters["W"+str(1+l)]=parameters["W"+str(1+l)]-learing_rate grads["dW"+str(1+l)]
parameters["b"+str(1+l)]=parameters["b"+str(1+l)]-learing_rate
grads["db"+str(1+l)]
return parameters

train_X,train_Y = opt_utils.load_dataset(is_plot=False)

batch_number=64
layer_dims=[train_X.shape[0],5,2,1]

costs = []
parameters=opt_utils.initialize_parameters(layer_dims)

def model (parameters,td="gd",learing_rate=0.0007,beta=0.9,is_plot=True,print_cost=True,iterations=10000):
t = 0
seed = 10
for i in range(iterations):
seed=seed+1
Batches = GetMinibatch(train_X,train_Y ,batch_number,seed)
for batch in Batches :
(bacth_X,batch_Y)=batch
#向前传播
A3,cache=opt_utils.forward_propagation(bacth_X,parameters)
#计算cost
cost=opt_utils.compute_cost(A3,batch_Y)
#向后传播
grads=opt_utils.backward_propagation(bacth_X,batch_Y,cache)
#更新模型参数
if(td=="gd"):
parameters=Upadate_parameter(parameters,grads,learing_rate)
elif(td=="velocity"):
V=Initial_velocity(parameters)
parameters,V=UpdateWith_velocity (parameters,grads,V,beta,learing_rate)
elif(td=="adam"):
V,S=initial_Adam(parameters)
t=t+1
parameters,V,S=Update_parameter_Adam(parameters,grads,V,S,t,learing_rate,beta1=0.9,beta2=0.999,epsilon=1e-8)

parameters = model(parameters,td="gd",is_plot=True)

preditions = opt_utils.predict(train_X,train_Y,parameters)

plt.title("Model with Gradient Descent optimization")
axes = plt.gca()
axes.set_xlim([-1.5, 2.5])
axes.set_ylim([-1, 1.5])
opt_utils.plot_decision_boundary(lambda x: opt_utils.predict_dec(parameters, x.T), train_X, train_Y)

--------------实验结果------------------------------

❷ 智能优化方法中的神经网络算法,要写出神经网络算法的原理,要举实例,要有结论,要求ppt格式,谢谢啦!

不知道啊可能和原理有关

❸ 100维度用什么优化算法

神经网络中常用的优化算法。
优化算法的目的:
1. 跳出局部极值点或鞍点,寻找全局最小值;
2.使训练过程更加稳定,更加容易收敛。
优化算法:深度学习优化学习方法(一阶、二阶)
一阶方法:随机梯度下降(SGD)、动量(Momentum)、牛顿动量法(Nesterov动量)、AdaGrad(自适应梯度)、RMSProp(均方差传播)、Adam、Nadam。
二阶方法:牛顿法、拟牛顿法、共轭梯度法(CG)、BFGS、L-BFGS。
自适应优化算法有哪些?(Adagrad(累积梯度平方)、RMSProp(累积梯度平方的滑动平均)、Adam(带动量的RMSProp,即同时使用梯度的一、二阶矩))。
梯度下降陷入局部最优有什么解决办法?可以用BGD、SGD、MBGD、momentum,RMSprop,Adam等方法来避免陷入局部最优。

❹ 神经网络中自适应的梯度下降优化算法(二)

Adagrad算法可以针对不同的参数自适应的采用不同的更新频率,对低频出现的特征采用低的更新率,对高频出现的特征采用高的更新率,因此,对于稀疏的数据它表现的很好,很好的提升了SGD的鲁棒性,在Google的通过Youtube视频识别猫的神经网络训练中有很好的表现。

梯度更新规则:

g(t,i)表示在t时刻目标函数对θ(i)的偏导数。SGD的每个参数的更新过程如下:

Adagrad的每个参数更新过程如下:

G(t)是一个对角矩阵,对角线上的每个元素是t时刻前所有θ(i)的梯度的平方和。ε通常取值在1e-8量级,它的存在是为了避免除数为0。一个有趣的现象是,如果没有平方根操作,算法的表现就非常糟糕。

Adagrad的主要缺点是,它的分母是平方梯度的累积,它的值会一直增加,最终导致学习率衰减到非常小,从而使得学习算法无法进行下去。

TensorFlow实现:

tf.train.AdagradOptimizer(learning_rate, initial_accumulator_value=0.1, use_locking=False, name='Adagrad')

Adadelta算法主要解决Adagrad的缺陷,它不再累加过去所有的梯度,而是仅累积过去固定个数的梯度。

Adadelta不是采用平方梯度的简单累加,而是采用 历史 平方梯度的衰减的平均。

γ通常等于0.9

分母相当于梯度的均方根(root mean squared, RMS),即将所有值平方求和,求其均值,再开平方,就得到均方根值。

梯度更新规则:

将学习率η设置为

,我们就不需要提前设定学习率。

RMSprop是Geoff Hinton提出的一种自适应学习率的方法,它与Adadelta方法都是为了解决Adagrad学习率急剧下降问题的。它与Adadelta方法是一致的。

梯度更新规则

超参数设定值:

Hinton建议设定γ=0.9, 学习率η=0.001。

TensorFlow实现:

tf.train.RMSPropOptimizer.__init__(learning_rate, decay, momentum=0.0, epsilon=1e-10, use_locking=False, name='RMSProp')

Adam也是对不同的参数自适应设置不同的学习率。它对 历史 梯度和 历史 平方梯度同时采用指数梯度衰减(exponentially decaying average)。

梯度更新规则

Adam作者观察到,如果m(t)和v(t)初始化为零向量,并且衰减率很小时(比如β1和β2都非常接近于1时),在开始的迭代中,m(t)和v(t)总是向零偏移,所以需要做偏移校正。

然后用校正后的值进行梯度更新:

Adam作者建议β1=0.9,β2=0.999,ε=10^{-8}

,在实践中,Adam比其它算法的效果要好。

TensorFlow实现:

tf.train.AdamOptimizer(learning_rate=0.001, beta1=0.9, beta2=0.999, epsilon=1e-08, use_locking=False, name='Adam')

Adam更新规则中的梯度缩放与 历史 梯度的L2范数成反比。

我们可以把这个规则泛化到Lp范数。

当p值增大的时候,Lp的值往往会变得不稳定,所以在实践中L1和L2使用的比较普遍。但是Adamax作者发现L∞可以收敛到一个稳定值。

然后我们可以采用u(t)代替

来更新Adam中的梯度。

同时u(t)不需要做零偏校正。默认取值建议:

❺ 常用优化器算法归纳介绍

优化器是神经网络训练过程中,进行梯度下降以寻找最优解的优化方法。不同方法通过不同方式(如附加动量项,学习率自适应变化等)侧重于解决不同的问题,但最终大都是为了加快训练速度。

这里就介绍几种常见的优化器,包括其原理、数学公式、核心思想及其性能;

核心思想: 即针对每次输入的训练数据,计算输出预测与真值的Loss的梯度;

从表达式来看,网络中参数的更新,是不断向着最小化Loss函数的方向移动的:

优点:
简单易懂,即对于相应的最优解(这里认为是Loss的最小函数),每次变量更新都是沿着局部梯度下降最快的方向,从而最小化损失函数。

缺点:

不同于标准梯度下降法(Gradient Descent)一次计算所有数据样本的Loss并计算相应的梯度,批量梯度下降法(BGD, Batch Gradient Descent)每次只取一个小批次的数据及其真实标签进行训练,称这个批次为mini-batch;

优点:

缺点:
随机梯度下降法的 batch size 选择不当可能导致模型难以收敛;由于这种方法是在一次更新中,就对整个数据集计算梯度,所以计算起来非常慢,遇到很大量的数据集也会非常棘手,而且不能投入新数据实时更新模型。

我们会事先定义一个迭代次数 epoch,首先计算梯度向量 params_grad,然后沿着梯度的方向更新参数 params,learning rate 决定了我们每一步迈多大。

Batch gradient descent 对于凸函数可以收敛到全局极小值,对于非凸函数可以收敛到局部极小值。

和 BGD 的一次用所有数据计算梯度相比,SGD 每次更新时对每个样本进行梯度更新,对于很大的数据集来说,可能会有相似的样本,这样 BGD 在计算梯度时会出现冗余,而 SGD 一次只进行一次更新,就没有冗余,而且比较快,并且可以新增样本。

即训练时,每次只从一批训练样本中随机选取一个样本进行梯度下降;对随机梯度下降来说,只需要一次关注一个训练样本,一点点把参数朝着全局最小值的方向进行修改了。

整体数据集是个循环,其中对每个样本进行一次参数更新

缺点:

梯度下降速度比较慢,而且每次梯度更新时往往只专注与局部最优点,而不会恰好指向全局最优点;

单样本梯度更新时会引入许多噪声(跟训练目标无关的特征也会被归为该样本分类的特征);

SGD 因为更新比较频繁,会造成 cost function 有严重的震荡。

BGD 可以收敛到局部极小值,当然 SGD 的震荡可能会跳到更好的局部极小值处。

当我们稍微减小 learning rate,SGD 和 BGD 的收敛性是一样的。

优点:

当处理大量数据时,比如SSD或者faster-rcnn等目标检测模型,每个样本都有大量候选框参与训练,这时使用随机梯度下降法能够加快梯度的计算。

随机梯度下降是通过每个样本来迭代更新一次,如果样本量很大的情况,那么可能只用其中部分的样本,就已经将 迭代到最优解了,对比上面的批量梯度下降,迭代一次需要用到十几万训练样本,一次迭代不可能最优,如果迭代10次的话就需要遍历训练样本10次。缺点是SGD的噪音较BGD要多,使得SGD并不是每次迭代都向着整体最优化方向。所以虽然训练速度快,但是准确度下降,并不是全局最优。虽然包含一定的随机性,但是从期望上来看,它是等于正确的导数的。

梯度更新规则:

MBGD 每一次利用一小批样本,即 n 个样本进行计算,这样它可以降低参数更新时的方差,收敛更稳定,另一方面可以充分地利用深度学习库中高度优化的矩阵操作来进行更有效的梯度计算。

和 SGD 的区别是每一次循环不是作用于每个样本,而是具有 n 个样本的批次。

超参数设定值: n 一般取值在 50~256

缺点:(两大缺点)

鞍点就是:一个光滑函数的鞍点邻域的曲线,曲面,或超曲面,都位于这点的切线的不同边。例如这个二维图形,像个马鞍:在x-轴方向往上曲,在y-轴方向往下曲,鞍点就是(0,0)。

为了应对上面的两点挑战就有了下面这些算法

核心思想:

不使用动量优化时,每次训练的梯度下降方向,都是按照当前批次训练数据计算的,可能并不能代表整个数据集,并且会有许多噪声,下降曲线波动较大:

添加动量项之后,能够有效减小波动,从而加快训练速度:

当我们将一个小球从山上滚下来时,没有阻力的话,它的动量会越来越大,但是如果遇到了阻力,速度就会变小。
加入的这一项,可以使得梯度方向不变的维度上速度变快,梯度方向有所改变的维度上的更新速度变慢,这样就可以加快收敛并减小震荡。

优点:

通过动量更新,参数向量会在有持续梯度的方向上增加速度;
使梯度下降时的折返情况减轻,从而加快训练速度;

缺点:

如果数据集分类复杂,会导致 和 时刻梯度 向量方向相差较大;在进行向量求和时,得到的 会非常小,反而使训练速度大大下降甚至模型难以收敛。

这种情况相当于小球从山上滚下来时是在盲目地沿着坡滚,如果它能具备一些先知,例如快要上坡时,就知道需要减速了的话,适应性会更好。

目前为止,我们可以做到,在更新梯度时顺应 loss function 的梯度来调整速度,并且对 SGD 进行加速。

核心思想:

自适应学习率优化算法针对于机器学习模型的学习率,采用不同的策略来调整训练过程中的学习率,从而大大提高训练速度。

这个算法就可以对低频的参数做较大的更新,对高频的做较小的更新,也因此,对于稀疏的数据它的表现很好,很好地提高了 SGD 的鲁棒性,例如识别 Youtube 视频里面的猫,训练 GloVe word embeddings,因为它们都是需要在低频的特征上有更大的更新。

Adagrad 的优点是减少了学习率的手动调节

式中, 表示第 个分类, 表示第 迭代同时也表示分类 累计出现的次数。 表示初始的学习率取值(一般为0.01)

AdaGrad的核心思想: 缩放每个参数反比于其所有梯度历史平均值总和的平方根。具有代价函数最大梯度的参数相应地有较大的学习率,而具有小梯度的参数又较小的学习率。

缺点:

它的缺点是分母会不断积累,这样学习率就会收缩并最终会变得非常小。

这个算法是对 Adagrad 的改进,

和 Adagrad 相比,就是分母的 换成了过去的梯度平方的衰减平均值,指数衰减平均值

这个分母相当于梯度的均方根 root mean squared (RMS),在数据统计分析中,将所有值平方求和,求其均值,再开平方,就得到均方根值 ,所以可以用 RMS 简写:

其中 的计算公式如下, 时刻的依赖于前一时刻的平均和当前的梯度:

梯度更新规则:

此外,还将学习率 换成了 RMS[Δθ],这样的话,我们甚至都不需要提前设定学习率了:

超参数设定值: 一般设定为 0.9

RMSprop 是 Geoff Hinton 提出的一种自适应学习率方法。

RMSprop 和 Adadelta 都是为了解决 Adagrad 学习率急剧下降问题的,

梯度更新规则:

RMSprop 与 Adadelta 的第一种形式相同:(使用的是指数加权平均,旨在消除梯度下降中的摆动,与Momentum的效果一样,某一维度的导数比较大,则指数加权平均就大,某一维度的导数比较小,则其指数加权平均就小,这样就保证了各维度导数都在一个量级,进而减少了摆动。允许使用一个更大的学习率η)

超参数设定值:

Hinton 建议设定 为 0.9, 学习率 为 0.001。

这个算法是另一种计算每个参数的自适应学习率的方法。相当于 RMSprop + Momentum

除了像 Adadelta 和 RMSprop 一样存储了过去梯度的平方 vt 的指数衰减平均值 ,也像 momentum 一样保持了过去梯度 mt 的指数衰减平均值:

如果 和 被初始化为 0 向量,那它们就会向 0 偏置,所以做了偏差校正,通过计算偏差校正后的 和 来抵消这些偏差:

梯度更新规则:

超参数设定值:
建议

示例一

示例二

示例三

上面情况都可以看出,Adagrad, Adadelta, RMSprop 几乎很快就找到了正确的方向并前进,收敛速度也相当快,而其它方法要么很慢,要么走了很多弯路才找到。

由图可知自适应学习率方法即 Adagrad, Adadelta, RMSprop, Adam 在这种情景下会更合适而且收敛性更好。

如果数据是稀疏的,就用自适用方法,即 Adagrad, Adadelta, RMSprop, Adam。

RMSprop, Adadelta, Adam 在很多情况下的效果是相似的。

Adam 就是在 RMSprop 的基础上加了 bias-correction 和 momentum,

随着梯度变的稀疏,Adam 比 RMSprop 效果会好。

整体来讲,Adam 是最好的选择。

很多论文里都会用 SGD,没有 momentum 等。SGD 虽然能达到极小值,但是比其它算法用的时间长,而且可能会被困在鞍点。

如果需要更快的收敛,或者是训练更深更复杂的神经网络,需要用一种自适应的算法。

各种优化器Optimizer原理:从SGD到AdamOptimizer

深度学习——优化器算法Optimizer详解(BGD、SGD、MBGD、Momentum、NAG、Adagrad、Adadelta、RMSprop、Adam)

❻ 神经网络算法可以求最优解嘛

神经网络可以做优化问题,但不一定能找到最优解。

逻辑性的思维是指根据逻辑规则进行推理的过程;它先将信息化成概念,并用符号表示,然后,根据符号运算按串行模式进行逻辑推理;这一过程可以写成串行的指令,让计算机执行。

直观性的思维是将分布式存储的信息综合起来,忽然间产生的想法或解决问题的办法。这种思维方式的根本之点在于以下两点:

1、信息是通过神经元上的兴奋模式分布存储在网络上。

2、信息处理是通过神经元之间同时相互作用的动态过程来完成的。

神经网络:

思维学普遍认为,人类大脑的思维分为抽象(逻辑)思维、形象(直观)思维和灵感(顿悟)思维三种基本方式。

人工神经网络就是模拟人思维的第二种方式。这是一个非线性动力学系统,其特色在于信息的分布式存储和并行协同处理。虽然单个神经元的结构极其简单,功能有限,但大量神经元构成的网络系统所能实现的行为却是极其丰富多彩的。

❼ 想知道优化算法是什么

优化算法是通过改善计算方式来最小化或最大化损失函数E(x)。模型内部有些参数是用来计算测试集中目标值Y的真实值和预测值的偏差程度的,基于这些参数就形成了损失函数E(x),比如说,权重(W)和偏差(b)就是这样的内部参数,一般用于计算输出值,在训练神经网络模型时起到主要作用。

优化算法分的分类

一阶优化算法是使用各参数的梯度值来最小化或最大化损失函数E(x),最常用的一阶优化算法是梯度下降。函数梯度导数dy/dx的多变量表达式,用来表示y相对于x的瞬时变化率。

二阶优化算法是使用了二阶导数也叫做Hessian方法来最小化或最大化损失函数,由于二阶导数的计算成本很高,所以这种方法并没有广泛使用。

阅读全文

与优化分析神经算法相关的资料

热点内容
广联达软件加密锁原装芯片 浏览:314
如何打开数据库服务器 浏览:308
kppm是什么app 浏览:536
python多个数组命名 浏览:189
a算法csdn 浏览:21
r720服务器什么年代 浏览:973
本地电脑怎么设置传奇服务器 浏览:1000
安卓10框架怎么制作 浏览:957
程序员退休工资待遇 浏览:607
湛江中文编程数控系统代理 浏览:417
openglandroid书 浏览:170
奇妙组件安卓版叫什么 浏览:729
微信授权什么app权重最高 浏览:11
php循环数组foreach 浏览:78
zip和app有什么区别 浏览:633
乖法快速算法 浏览:872
日本程序员一年工资 浏览:199
出国做程序员怎么样 浏览:736
rar锁定压缩文件 浏览:871
安卓id号码怎么更换 浏览:524