梯度演算法的心得體會

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

我認為這是三個不同的概念。但是都可以用來表示空間立體思維。運用一下這些知識，還可以更加豐富思維的東西。

旋度：這類向量的運算，計算結果是向量。對象的作用是旋轉矢量場，直接使用上面的例子：如果分散的人在放屁的方向相反，當你看到這些人的線是一個標准輻射，但事實上，每個人都不知道他們什麼時候聞到屁的味道。因為這只是一個空間概念。

⑵ 梯度法和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會使優化的方向從當前的局部極小值點跳到另一個更好的局部極小值點，這樣對於非凸函數，可能最終收斂於一個較好的局部極值點，甚至全局極值點。
缺點是，出現損失函數波動，並且無法判斷是否收斂。