梯度算法的心得体会

⑴ 如何直观形象的理解梯度，散度，旋度

我认为这是三个不同的概念。但是都可以用来表示空间立体思维。运用一下这些知识，还可以更加丰富思维的东西。

旋度：这类向量的运算，计算结果是向量。对象的作用是旋转矢量场，直接使用上面的例子：如果分散的人在放屁的方向相反，当你看到这些人的线是一个标准辐射，但事实上，每个人都不知道他们什么时候闻到屁的味道。因为这只是一个空间概念。

⑵ 梯度法和laplacian算子在检测边缘时有何相同与不同

相同点：都是用于指代微分几何中的联络。

区别：

1、性质不同：梯度下降是迭代法的一种，可以用于求解最小二乘问题(线性和非线性都可以)。Laplacian 算子是n维欧几里德空间中的一个二阶微分算子，定义为梯度grad的散度div。

2、特点不同：Laplacian算子可使用运算模板来运算这定理定律。梯度法在求解机器学习算法的模型参数，即无约束优化问题时，梯度下降是最常采用的方法之一，另一种常用的方法是最小二乘法。

3、原理不同：梯度对应一阶导数，对于一个连续图像函数f(x,y)，在点f(x,y)处的梯度是一个矢量。laplacian算子的系数K与扩散效应有关。图像f(x,y)经拉普拉斯运算后得到检测出边缘的图像g（x,y）。

(2)梯度算法的心得体会扩展阅读：

注意事项：

1、不同的起始点，可能导致最后得到的局部最小值点不同。

2、同时更新：以代价函数J(θ0,θ1)为例，目的就是要同时迭代更新θ0和θ1，直到下面这个式子收敛，这也是梯度下降法的核心。

3、梯度检验不能与dropout同时使用，因为每次迭代过程中，dropout会随机消除隐藏层单元的不同子集，难以计算dropout在梯度下降上的代价函数J。建议关闭dropout，用梯度检验进行双重检查。

⑶ 实践·pytorch梯度计算

pytorch梯度机制，计算梯度注意事项

pytorch，autograd，tensor，自动微分，张量，梯度

  在一些优化算法中，常常需要计算函数的梯度，在pytorch可以借助autograd机制来自动计算梯度值。

  假设 ，关于 的梯度记为 ， 是关于变量 的函数，其梯度 是随着 的值变化而变化的，决定梯度的除了 自身的值以外还有施加在 上的运算。因此，关注梯度就是关注两个东西，求哪个 变量 的梯度，该变量上被施加了哪种 运算 。

  首先看 变量 ：在pytorch中把梯度作为一个固有属性结合进张量(tensor)，任何一个tensor类型的变量都有梯度(grad)属性，再结合一般场景下的需要，pytorch把 tensor 类型定义为一个对象，包括5个属性，分别对应 data （变量本身的值）， grad （梯度值）， requires_grad （是否需要梯度，很多场景都不需要求变量的微分）， grad_fn （生成该变量结果的运算，即这个值通过什么运算来的）， is_leaf （是否叶子节点，叶子才帮你算梯度）。

  接着看 运算 ：在pytorch中没有显式的给出梯度函数表达，而是算出梯度值，存放在tensor类型变量的grad属性中，那么运算也一样用结果来表达，假设 ，这里的 就承载了运算的结果，因此需要求 的梯度值时就对 使用 backward() 方法来计算 的梯度。

  上面提到计算梯度的两个要素： 变量 和 运算 ，对应的pytorch机制是 tensor 对象和 backward 方法。因此计算梯度就是学会怎么用这俩货。具体的例子这边不写，各位大神写的很多了，不当搬运工了，推荐 参考资料3 ， 参考资料2 。这里说明两点，然后总结个过程。

  （1）可求梯度的条件

  从上面的叙述知道，一个变量有5个属性，要求这个变量可以求梯度，需要满足2个属性为真，requires_grad=True，is_leaf=True。在声明变量的时候声明requires_grad=True就可以了。在实践过程中如果发现梯度没法计算，要查一下这两个属性。

  （2）回传结果类型

  大部分情况是对标量求梯度，也是在 中， 是标量的情况，如果 向量或矩阵，也可以求梯度，此时本质上也是按分量一个一个来，因此要给backward()加个参数，一般情况下该参数的形状和 一样，每一个位置的值指示每个分量的梯度权重，多数情况就是全部设置为1。

  （3）一般过程

  仍然假设求 的关于 的梯度，首先设置声明tensor类型变量 ，声明的时候需要设置参数requires_grad=True；接下来计算出 ，这里的 是用来表示函数运算过程，最后使用 ，如果 非标量，就加个参数，假设为 ， 的形状与 相同，此时使用的是 ，要的梯度值可以通过 获得。

  单独写个注意事项，计算变量 的梯度时， 的属性有可能会变化，比如需要对 进行迭代，假设为 ，那么 的requires_grad和is_leaf属性会变化，变得不可求梯度，那怎么办呢，其实程序迭代时只需要改变值就好了，使用 就可以了。

[1] https://pytorch.org/docs/1.3.1/index.html
[2] https://blog.csdn.net/qq_27825451/article/details/89393332
[3] https://www.cnblogs.com/marsggbo/p/11549631.html

⑷ 如何理解近端梯度算法

（这里指的是模式识别中的梯度法求最小值的问题）简单地说就是，当你的类分对时会有WtX>0,你要寻找的权应该满足这个关系，而你的准则函数应该具有的性质是：准则函数有唯一的最小值，且这个最小指发生在WtX>0时。也就是说当你的准则函数取到最小值时会有WtX>0，而这不正是我们要的权吗？所以我们将求满足WtX>0的权转换成了求准则函数的最小值问题，两者在这里是等价的。

⑸ 什么是梯度，如何计算梯度

梯度的计算公式：gra=aₓ（∂u/∂x）+aᵧ（∂u/∂y）+az（∂u/∂z）

梯度是一个向量（矢量），表示某一函数在该点处的方向导数沿着该方向取得最大值，即函数在该点处沿着该方向（此梯度的方向）变化最快，变化率最大（为该梯度的模）。

梯度是雅可比矩阵的一种特殊形式：

当m=1时函数的雅可比矩阵就是梯度，这个概念原是为场论设定的，任何场都可以用来理解梯度，后来被引用到数学中用来指明函数在指定点的变量率最快的方向和大小，是一种变化效率的数字抽象。

举一个降维的例子，在修建一个通向山顶的缆车时，从山顶到山底一条直线中间可能有山峰阻拦，一昧的修高山顶的到达站不仅不安全还会增加施工效率，在调整修建缆车的角度时的角度变化率就是梯度，角度太低了通不到山顶这个梯度方向角度就是零，方向导数就也是零。

⑹ 如何理解近端梯度算法

L1正则化是一种常用的获取稀疏解的手段，同时L1范数也是L0范数的松弛范数。求解L1正则化问题最常用的手段就是通过加速近端梯度算法来实现的。

考虑一个这样的问题：

minx f(x)+λg(x)

x∈Rn，f(x)∈R，这里f(x)是一个二阶可微的凸函数，g(x)是一个凸函数（或许不可导），如上面L1的正则化||x||。

此时，只需要f(x)满足利普希茨（Lipschitz）连续条件，即对于定义域内所有向量x,y，存在常数M使得||f'(y)-f'(x)||<=M·||y-x||，那么这个模型就可以通过近端梯度算法来进行求解了。

ps：下面涉及很多数学知识，不想了解数学的朋友请跳到结论处，个人理解，所以也不能保证推理很严谨，如有问题，请一定帮忙我告诉我。

利普希茨连续条件的几何意义可以认为是函数在定义域内任何点的梯度都不超过M（梯度有上限），也就是说不会存在梯度为正负无穷大的情况。

因而，我们有下图所示的推算：

我们可以用f(y) = f(x)+f'(x)(y-x)+M/2*||y-x||2来近似的表示f(y)，也可以认为是高维下的泰勒分解，取到二次项。

我们换一种写法，f(xk+1) = f(xk)+f'(xk)(xk+1-xk)+M/2*||xk+1-xk||2，也就是说可以直接迭代求minx f(x)，就是牛顿法辣。

再换一种写法，f(xk+1)=(M/2)(xk+1-(xk+(1/M)f'(xk)))2+CONST，其中CONST是一个与xk+1无关的常数，也就是说，此时我们可以直接写出这个条件下xk+1的最优取值就是xk+1=xk+(1/M)f'(xk)。令z=xk+(1/M)f'(xk)。

回到原问题，minx f(x)+λg(x)，此时问题变为了求解minx (M/2)||x-z||2+λg(x)。

实际上在求解这个问题的过程中，x的每一个维度上的值是互不影响的，可以看成n个独立的一维优化问题进行求解，最后组合成一个向量就行。

如果g(x)=||x||1，就是L1正则化，那么最后的结论可以通过收缩算子来表示。

即xk+1=shrink(z,λ/M)。具体来说，就是Z向量的每一个维度向原点方向移动λ/M的距离（收缩，很形象），对于xk+1的第i个维度xi=sgn(zi)*max(|zi|-λ/M,0)，其中sgn()为符号函数，正数为1，负数为-1。

一直迭代直到xk收敛吧。

⑺ 优化神经网络梯度算法——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)

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

⑻ 浅谈策略梯度（PG）算法

Policy Optimization（策略优化）是强化学习中的一大类算法，其基本思路区别于Value-based的算法。因此，很多教科书都将model-free RL分成两大类，Policy Optimization和Value-based。本系列博客将会参考OpenAI发布的入门教程 Spinning Up [1] ，Spinning Up系列是入门Policy Optimization的非常好的教材，特别适合初学者。Policy Gradient（策略梯度，简称PG）算法是策略优化中的核心概念，本章我们就将从最简单的PG推导开始，一步步揭开策略优化算法的神秘面纱。

如果用一句话来表达 策略梯度 的直观解释，那就是“如果动作使得最终回报变大，那么增加这个动作出现的概率，反之，减少这个动作出现的概率”。这句话表达了两个含义：

本节我们将一步步推导出策略梯度的基础公式，这一小节非常重要，理解了推导过程，就基本上理解了策略梯度的核心思想。所以，一定要耐心的把这一小节的内容全部看懂，最好能够达到自行推导的地步。

我们用参数化的神经网络表示我们的策略 ，那我们的目标，就可以表示为调整 ，使得 期望回报 最大，用公式表示：

在公式(1)中， 表示从开始到结束的一条完整路径。通常，对于最大化问题，我们可以使用梯度上升算法来找到最大值。

为了能够一步步得到最优参数，我们需要得到 ，然后利用梯度上升算法即可，核心思想就是这么简单。

关键是求取最终的 回报函数 关于 的梯度，这个就是 策略梯度 （policy gradient），通过优化策略梯度来求解RL问题的算法就叫做 策略梯度算法 ，我们常见的PPO，TRPO都是属于策略梯度算法。下面我们的目标就是把公式（2）逐步展开，公式（2）中最核心的部分就是 ，这也是这篇博客最核心的地方。





在以上的推导中，用到了log求导技巧： 关于 的导数是 。因此，我们可以得到以下的公式：

所以，才有公式（5）到公式（6），接下来我们把公式（7）进一步展开，主要是把 展开。先来看看

加入log，化乘法为加法：

计算log函数的梯度，并且约去一些常量：


因此，结合公式（7）和公式（9），我们得到了最终的表达式

公式（10）就是PG算法的核心表达式了，从这个公式中可以看出，我们要求取的策略梯度其实是一个期望，具体工程实现可以采用蒙特卡罗的思想来求取期望，也就是采样求均值来近似表示期望。我们收集一系列的 ,其中每一条轨迹都是由agent采用策略 与环境交互采样得到的，那策略梯度可以表示为：

其中， 表示采样的轨迹的数量。现在，我们完成了详细的策略梯度的推导过程，长舒一口气，接下来的工作就比较轻松了，就是在公式（10）的基础上修修改改了。

再进行简单修改之前，我们再总结一下公式（10），毕竟这个公式是PG算法最核心的公式：

我们继续观察公式（10），对于公式中的 ，表示整个轨迹的回报，其实并不合理。对于一条轨迹中的所有动作，均采用相同的回报，就相当于对于轨迹中的每一个动作都赋予相同的权重。显然，动作序列中的动作有好有坏，都采取相同的回报，无法达到奖惩的目的，那我们该怎么表示 “某个状态下，执行某个动作” 的回报呢？

一种比较直观思路是，当前的动作将会影响后续的状态，并且获得即时奖励（reward），那么我们只需要使用 折扣累计回报 来表示当前动作的回报就行了，用公式表示为：

这在spinning up中叫做reward to go，所以，公式（10）可以表示为：

当然，使用reward to go的权重分配还是相当初级，我们可以使用更加高级的权重分配方式，进一步减少回报分配的方差，限于篇幅原因，我们后续再聊。

本章我们花了大量的篇幅推导了策略梯度（PG）的核心公式，得到了关键表达式（10），理解该公式对于我们后续理解整个PG算法族非常有帮助，希望大家能够认真的理解这一公式推导过程。

我们是行者AI，我们在“AI＋游戏”中不断前行。

如果你也对游戏感兴趣，对AI充满好奇，就快来加入我们吧~

⑼ 什么是梯度法为什么在接近目标函数的极值点时，梯度法的收敛速度会变慢

梯度下降法是一个最优化算法，通常也称为最速下降法。最速下降法是求解无约束优化问题最简单和最古老的方法之一，虽然现在已经不具有实用性，但是许多有效算法都是以它为基础进行改进和修正而得到的。最速下降法是用负梯度方向为搜索方向的，最速下降法越接近目标值，步长越小，前进越慢。

⑽ 梯度下降法原理和步骤

一、梯度法思想
梯度法思想的三要素：出发点、下降方向、下降步长。
机器学习中常用的权重更新表达式为
：，这里的λ就是学习率，本文从这个式子出发来把机器学习中的各种“梯度”下降法阐释清楚。
机器学习目标函数，一般都是凸函数，什么叫凸函数？限于篇幅，我们不做很深的展开，在这儿我们做一个形象的比喻，凸函数求解问题，可以把目标损失函数想象成一口锅，来找到这个锅的锅底。非常直观的想法就是，我们沿着初始某个点的函数的梯度方向往下走（即梯度下降）。在这儿，我们再作个形象的类比，如果把这个走法类比为力，那么完整的三要素就是步长（走多少）、方向、出发点，这样形象的比喻，让我们对梯度问题的解决豁然开朗，出发点很重要，是初始化时重点要考虑的，而方向、步长就是关键。事实上不同梯度的不同就在于这两点的不同！
梯度方向是

，步长设为常数Δ，这时就会发现，如果用在梯度较大的时候，离最优解比较远，W的更新比较快；然而到了梯度较小的时候，也就是较靠近最优解的时候，W的更新竟然也保持着跟原来一样的速率，这样会导致W很容易更新过度反而远离了最优解，进而出现在最优解附近来回震荡。所以，既然在远离最优解的时候梯度大，在靠近最优解的时候梯度小，我们让步长随着这个律动，于是我我们就用λ|W|来代替Δ，最后得到了我们熟悉的式子：

所以说这时的λ是随着坡度的陡缓而变化的，别看它是个常数。
二、全量梯度下降法（Batch gradient descent）
全量梯度下降法每次学习都使用整个训练集，因此每次更新都会朝着正确的方向进行，最后能够保证收敛于极值点，凸函数收敛于全局极值点，非凸函数可能会收敛于局部极值点，缺陷就是学习时间太长，消耗大量内存。
第二、随机梯度下降法（Stochastic Gradient Descent）
SGD一轮迭代只用一条随机选取的数据，尽管SGD的迭代次数比BGD大很多，但一次学习时间非常快。
SGD的缺点在于每次更新可能并不会按照正确的方向进行，参数更新具有高方差，从而导致损失函数剧烈波动。不过，如果目标函数有盆地区域，SGD会使优化的方向从当前的局部极小值点跳到另一个更好的局部极小值点，这样对于非凸函数，可能最终收敛于一个较好的局部极值点，甚至全局极值点。
缺点是，出现损失函数波动，并且无法判断是否收敛。