優化分析神經演算法

❶ 優化神經網路梯度演算法——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方法來最小化或最大化損失函數，由於二階導數的計算成本很高，所以這種方法並沒有廣泛使用。