人工智能的本質(zhì)就是最優(yōu)化。假設(shè)把任務(wù)比作是一碗飯，
傳統(tǒng)的解決方法，就是根據(jù)數(shù)學(xué)公式，然后一口氣吃完飯，如果飯碗小，數(shù)學(xué)公式還行，如果飯碗大，數(shù)學(xué)公式能一口吃完飯嗎？
人工智能的本質(zhì)就是最優(yōu)化，得益于有很多優(yōu)化算法，優(yōu)化算法等于是一口一口吃飯，再大的飯碗,再多的飯，也能干。
本文以一元線性回歸為例，
通過代碼來感受下神經(jīng)網(wǎng)絡(luò)的優(yōu)化算法。

一.梯度下降算法SGD

梯度下降是一種非常通用的優(yōu)化算法。
假設(shè)在濃霧下，你迷失在了大山中，你只能感受到自己腳下的坡度，為了最快到達(dá)山底，最好的方法就是沿著坡度最陡的地方下山。這就是梯度下降。它計(jì)算誤差函數(shù)關(guān)于參數(shù)θ 的局部梯度，同時它沿著梯度下降的方向進(jìn)行下一次迭代，當(dāng)梯度值為0的時候，就達(dá)到誤差函數(shù)最小值。
具體來說，開始時，需要指定一個隨機(jī)的θ ,然后逐漸去改進(jìn)它，每次變化一小步，每一次都試著降低損失函數(shù)，直到算法收斂到一個最小值。

在梯度下降中一個最重要的參數(shù)就是步長，也叫學(xué)習(xí)率
如果學(xué)習(xí)率太小，則需要多次迭代才能達(dá)到最小值。

如果學(xué)習(xí)率太大，可能跳過最小值，很難收斂。

并不是所有的損失函數(shù)都是一個V型，有的像山脊等各種不規(guī)則地形。如果早早地結(jié)束訓(xùn)練可能會陷入局部最小值，所以這時需要指定訓(xùn)練輪數(shù)，當(dāng)輪數(shù)過大，才有可能得到全局最小值。

線性目標(biāo)函數(shù)為


線性回歸損失函數(shù)為

優(yōu)化函數(shù) 對于一元線性回歸的優(yōu)化函數(shù)為： import numpy as np import matplotlib.pyplot as plt#定義線性回歸 def model(a, b, x):return a*x + b#損失函數(shù) def cost_function(a, b, x, y):n = 5#5個樣本，后面舉例的數(shù)據(jù)為5個樣本return 0.5/n * (np.square(y-a*x-b)).sum()#梯度下降 #梯度下降 def sgd(a,b,x,y):n = 5#5個樣本alpha = 1e-1y_hat = model(a,b,x)#預(yù)測值da = (1.0/n) * ((y_hat-y)*x).sum()db = (1.0/n) * ((y_hat-y).sum())a = a - alpha*dab = b - alpha*dbreturn a, b #定義數(shù)據(jù) 5個樣本 x=np.array([1,2,3,4,5]) y=np.array([2.1,4.2,5.9,7.8,10.2])def train():# 初始化參數(shù)a = np.random.random()b = np.random.random()n_iterations = 10000 # 輪數(shù)print('初始值 a,b', a, b)for i in range(n_iterations):a, b= sgd(a, b, x, y)cost=cost_function(a,b,x,y)if np.abs(cost)<0.01:breakreturn a,b,i a,b,i=train() print('a,b,i',a,b,i)y1=np.dot(x,a)+b plt.scatter(x,y) plt.plot(x,y1,color='red',) plt.show()

梯度下降算法代碼

二.動量優(yōu)化Momentum

梯度下降算法只是通過直接減去損失函數(shù)J(θ)相對于θ的梯度，乘以學(xué)習(xí)率η來更新權(quán)重θ,方程是θ=θ-η?J(θ)。它不關(guān)心早期的梯度是什么，如果局部梯度很小，則會非常緩慢。
動量優(yōu)化Momentum很關(guān)心之前的梯度，在每次迭代時，它將動量矢量m(乘以學(xué)習(xí)率β)與局部梯度相加，并通過簡單地減去或加上該動量矢量來更新權(quán)重。換句話講，梯度作用于加速度，不作用于速度,人為引入了一個初速度βm。

公式為

其中的β類似于摩擦系數(shù)，一般取0.9，m為動量。 import numpy as np import matplotlib.pyplot as plt#定義線性回歸 def model(a, b, x):return a*x + b#損失函數(shù) def cost_function(a, b, x, y):n = 5#5個樣本，后面舉例的數(shù)據(jù)為5個樣本return 0.5/n * (np.square(y-a*x-b)).sum()#動量優(yōu)化 def nesterov(a, b, ma, mb, x, y):n = 5#5個樣本alpha = 1e-1beta = 0.1y_hat = model(a,b,x)da = (1.0/n) * ((y_hat-y)*x).sum()db = (1.0/n) * ((y_hat-y).sum())ma = beta*ma + alpha*da#動量矢量，其中beta*ma 控制速度，alpha*da控制加速度mb = beta*mb + alpha*db#動力矢量a = a - ma#權(quán)重參數(shù)更新b = b - mb#權(quán)重參數(shù)更新return a, b, ma, mb#定義數(shù)據(jù) 5個樣本 x=np.array([1,2,3,4,5]) y=np.array([2.1,4.2,5.9,7.8,10.2])def train():# 初始化參數(shù)a = np.random.random()b = np.random.random()n_iterations = 10000 # 輪數(shù)print('初始值 a,b', a, b)for i in range(n_iterations):a, b, ma, mb = nesterov(a, b, 0.9, 0.9, x, y)cost=cost_function(a,b,x,y)if np.abs(cost)<1:breakreturn a,b,i a,b,i=train() print('a,b,i',a,b,i)y1=np.dot(x,a)+b plt.scatter(x,y) plt.plot(x,y1,color='red',) plt.show()

ma = betama + alphada#動量矢量，其中betama 控制速度，alphada控制加速度
合理選擇速度
數(shù)據(jù)量大還行，數(shù)據(jù)量小我感覺效果不如梯度下降

三.AdaGrad

在圖中，藍(lán)色的為梯度下降，它朝著梯度最大的方向快速前進(jìn)，而不是朝著全局最后前進(jìn)。黃色的是AdaGrad，它指向的是全局最優(yōu)。它的辦法是縮小（scaling down）最大的梯度參數(shù)。

對頻繁出現(xiàn)的參數(shù)采用小的步長（因?yàn)閟a疊加的多），對頻繁出現(xiàn)的參數(shù)采用大的步長（sa疊加次數(shù)少）

import numpy as np import matplotlib.pyplot as plt#定義線性回歸 def model(a, b, x):return a*x + b#損失函數(shù) def cost_function(a, b, x, y):n = 5#5個樣本，后面舉例的數(shù)據(jù)為5個樣本return 0.5/n * (np.square(y-a*x-b)).sum()#ada_grad def ada_grad(a,b,sa, sb, x,y):epsilon=1e-10n = 5#5個樣本alpha = 1e-1y_hat = model(a,b,x)da = (1.0/n) * ((y_hat-y)*x).sum()db = (1.0/n) * ((y_hat-y).sum())sa=sa+da*da + epsilonsb=sb+db*db + epsilon# da,db隨著輪數(shù)變小，sa,sb大趨勢隨著輪數(shù)變大a = a - alpha*da / np.sqrt(sa)b = b - alpha*db / np.sqrt(sb)return a, b, sa, sb#定義數(shù)據(jù) 5個樣本 x=np.array([1,2,3,4,5]) y=np.array([2.1,4.2,5.9,7.8,10.2])def train():# 初始化參數(shù)a = np.random.random()b = np.random.random()n_iterations = 10000 # 輪數(shù)print('初始值 a,b', a, b)for i in range(n_iterations):a, b, sa, sb = ada_grad(a, b, 0.9, 0.9, x, y)cost=cost_function(a,b,x,y)if np.abs(cost)<0.1:breakreturn a,b,i,sa,sb a,b,i,sa,sb=train() print('sa,sb',sa,sb) print('a,b,i',a,b,i)y1=np.dot(x,a)+b plt.scatter(x,y) plt.plot(x,y1,color='red',) plt.show()

解析：

sa=sa+dada + epsilon，sb=sb+dbdb + epsilon 會隨著輪數(shù)越來越大，然后導(dǎo)致學(xué)習(xí)率1/ np.sqrt(sa) 越來越小，權(quán)重更新得越慢。即開始時學(xué)習(xí)率比較大，后面學(xué)習(xí)率較小，學(xué)習(xí)率一直在變，是一種自適應(yīng)學(xué)習(xí)率。

四.RMSProp

盡管AdaGrad的速度變慢了一些，并且從未收斂到全局最優(yōu)。
AdaGrad 權(quán)重更新,學(xué)習(xí)率累積的時訓(xùn)練以來的所以梯度(sa累積的是所有的da，sb累積的是所有的db）

AdaGrad 中
sa=sa+dada + epsilon
sb=sb+dbdb + epsilon
a = a - alphada / np.sqrt(sa)
b = b - alphadb / np.sqrt(sb)
da,db總體上會隨著輪數(shù)越來越小，，sa,sb隨著輪數(shù)變大
1/ np.sqrt(sa)，1/ np.sqrt(sb) 學(xué)習(xí)率隨著輪數(shù)變小，容易陷入局部最小值，（因?yàn)楫?dāng)它局部最小值附近時，da小，學(xué)習(xí)率也小，很難爬出小凹谷）

RMSProp 通過僅累積最近迭代的（da,db）的梯度來修正這個問題，它通過在第一步中使用指數(shù)衰減來實(shí)現(xiàn)。

相比于AdaGrad ,RMSProp就是在AdaGrad基礎(chǔ)上減緩學(xué)習(xí)率[1 / np.sqrt(sa) 和1/ np.sqrt(sb) ]的變化。

import numpy as np import matplotlib.pyplot as plt#定義線性回歸 def model(a, b, x):return a*x + b#損失函數(shù) def cost_function(a, b, x, y):n = 5#5個樣本，后面舉例的數(shù)據(jù)為5個樣本return 0.5/n * (np.square(y-a*x-b)).sum()#rmsprop def rmsprop(a,b,sa, sb, x,y):epsilon=1e-10beta = 0.9n = 5#本文5個樣本數(shù)據(jù)alpha = 1e-1y_hat = model(a,b,x)da = (1.0/n) * ((y_hat-y)*x).sum()db = (1.0/n) * ((y_hat-y).sum())sa=beta*sa+(1-beta)*da*da + epsilonsb=beta*sb+(1-beta)*db*db + epsilon#da,db會隨著輪數(shù)越來越小，sa,sb，大趨勢變小a = a - alpha*da / np.sqrt(sa)b = b - alpha*db / np.sqrt(sb)return a, b, sa, sb#定義數(shù)據(jù) 5個樣本 x=np.array([1,2,3,4,5]) y=np.array([2.1,4.2,5.9,7.8,10.2])def train():# 初始化參數(shù)a = np.random.random()b = np.random.random()n_iterations = 10000 # 輪數(shù)print('初始值 a,b', a, b)for i in range(n_iterations):a, b, sa, sb = rmsprop(a, b, 0.9, 0.9, x, y)cost=cost_function(a,b,x,y)if np.abs(cost)<0.1:breakreturn a,b,i,sa,sb a,b,i,sa,sb=train() print('sa,sb',sa,sb) print('a,b,i',a,b,i)y1=np.dot(x,a)+b plt.scatter(x,y) plt.plot(x,y1,color='red',) plt.show()

解析

sa=betasa+(1-beta)dada + epsilon. beta=0.9,現(xiàn)在=0.9以前的+0.1的現(xiàn)在梯度。
sa=betasa+(1-beta)dada + epsilon
sb=betasb+(1-beta)dbdb + epsilon
#da,db總體上會隨著輪數(shù)越來越小，sa,sb，大趨勢變小。學(xué)習(xí)率1 / np.sqrt(sa)變大
a = a - alphada / np.sqrt(sa)
b = b - alpha*db / np.sqrt(sb)
當(dāng)處于局部最小值附近時，學(xué)習(xí)率足夠大，容易爬出小凹谷。

五.Adam

簡而言之，Adam使用動量和自適應(yīng)學(xué)習(xí)率來加快收斂速度。

Momentum (動量)
在解釋動量時，研究人員和從業(yè)人員都喜歡使用比球滾下山坡而向局部極小值更快滾動的類比法，但從本質(zhì)上講，我們必須知道的是，動量算法在相關(guān)方向上加速了隨機(jī)梯度下降，如 以及抑制振蕩。

為了將動量引入我們的神經(jīng)網(wǎng)絡(luò)，我們將時間元素添加到過去時間步長的更新向量中，并將其添加到當(dāng)前更新向量中。 這樣可以使球的動量增加一定程度。 可以用數(shù)學(xué)表示，如下圖所示。

動量更新方法，其中θ是網(wǎng)絡(luò)的參數(shù)，即權(quán)重，偏差或激活值，η是學(xué)習(xí)率，J是我們要優(yōu)化的目標(biāo)函數(shù)，γ是常數(shù)項(xiàng)，也稱為動量。 Vt-1（注意t-1是下標(biāo)）是過去的時間步長，而Vt（注意t是下標(biāo)）是當(dāng)前的時間步長。

動量項(xiàng)γ通常被初始化為0.9

適應(yīng)性學(xué)習(xí)率
通過將學(xué)習(xí)率降低到我們在AdaGrad，RMSprop，Adam和AdaDelta中看到的預(yù)定義時間表(schedule)，可以將自適應(yīng)學(xué)習(xí)率視為訓(xùn)練階段的學(xué)習(xí)率調(diào)整。這也稱為學(xué)習(xí)率時間表 有關(guān)該主題的更多詳細(xì)信息
在不花太多時間介紹AdaGrad優(yōu)化算法的情況下，這里將解釋RMSprop及其在AdaGrad上的改進(jìn)以及如何隨時間改變學(xué)習(xí)率。

RMSprop（即均方根傳播）其目的是解決AdaGrad的學(xué)習(xí)率急劇下降的問題。 簡而言之，RMSprop更改學(xué)習(xí)速率的速度比AdaGrad慢，但是RMSprop仍可從AdaGrad（更快的收斂速度）中受益-數(shù)學(xué)表達(dá)式請參見下圖

E [g2] t的第一個方程是平方梯度的指數(shù)衰減平均值。 Geoff Hinton建議將γ設(shè)置為0.9，而學(xué)習(xí)率η的默認(rèn)值為0.001

這可以使學(xué)習(xí)率隨著時間的流逝而適應(yīng)，這很重要，因?yàn)檫@種現(xiàn)象也存在于Adam中。 當(dāng)我們將兩者（Momentum 和RMSprop）放在一起時，我們得到了Adam

import numpy as np import matplotlib.pyplot as plt#定義線性回歸 def model(a, b, x):return a*x + b#損失函數(shù) def cost_function(a, b, x, y):n = 5#5個樣本，后面舉例的數(shù)據(jù)為5個樣本return 0.5/n * (np.square(y-a*x-b)).sum()#Adam def adam(a, b, ma, mb, sa, sb, t, x, y):epsilon = 1e-10beta1 = 0.9beta2 = 0.9n = 5#5個樣本alpha = 1e-1y_hat = model(a, b, x)da = (1.0 / n) * ((y_hat - y) * x).sum()#計(jì)算梯度adb = (1.0 / n) * ((y_hat - y).sum())#計(jì)算梯度bma = beta1 * ma - (1 - beta1) * da#計(jì)算動量mamb = beta1 * mb - (1 - beta1) * db#計(jì)算動量mbsa = beta2 * sa + (1 - beta2) * da * da#自適應(yīng)sasb = beta2 * sb + (1 - beta2) * db * db#自適應(yīng)sbma_hat = ma / (1 - beta1 ** t)#動量添加指數(shù)mb_hat = mb / (1 - beta1 ** t)#動量添加指數(shù)sa_hat = sa / (1 - beta2 ** t)#自適應(yīng)添加指數(shù)sb_hat = sb / (1 - beta2 ** t)#自適應(yīng)添加指數(shù)a = a + alpha * ma_hat / np.sqrt(sa_hat)#權(quán)重更新b = b + alpha * mb_hat / np.sqrt(sb_hat)return a, b, ma, mb, sa, sb#定義數(shù)據(jù) 5個樣本 x=np.array([1,2,3,4,5]) y=np.array([2.1,4.2,5.9,7.8,10.2])def train():# 初始化參數(shù)a = np.random.random()b = np.random.random()n_iterations = 10000 # 輪數(shù)print('初始值 a,b', a, b)for i in range(n_iterations):a, b, ma,mb,sa, sb = adam(a, b, 0.05, 0.05, 0.9,0.9,1000,x, y)cost=cost_function(a,b,x,y)if np.abs(cost)<0.1:breakreturn a,b,i,sa,sb a,b,i,sa,sb=train() print('sa,sb',sa,sb) print('a,b,i',a,b,i)y1=np.dot(x,a)+b plt.scatter(x,y) plt.plot(x,y1,color='red',) plt.show()

解析

adam(a, b, ma, mb, sa, sb, t, x, y):
中的ma,mb控制初速度，要不要一來就梯度更新得很快（數(shù)據(jù)量大時可以考慮較大的ma,mb） 做學(xué)習(xí)率的分子
sa,sb控制權(quán)重更新速度，越大更新越慢，做學(xué)習(xí)率的分母

本文主要參考文獻(xiàn)如下，感謝大佬。
1.Adam 優(yōu)化算法詳解

2.https://blog.csdn.net/juwikuang/article/details/108039680

、、、、、、、、、、、、、、、、、、、、、、、、、、、、

常用優(yōu)化算法就這些，還有其他的未列舉。

我也感覺似懂非懂，唉。

電氣工程的計(jì)算機(jī)萌新：余登武。
寫博文不容易，如果你覺得本文對你有用，請點(diǎn)個贊支持下，謝謝。

總結(jié)

以上是生活随笔為你收集整理的人工智能的本质：最优化 （神经网络优化算法python手写实现）的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。