快捷導(dǎo)航

python實現(xiàn)梯度下降算法

更新時間：2020年03月24日 11:51:19 作者：huahuazhu

這篇文章主要為大家詳細(xì)介紹了python實現(xiàn)梯度下降算法，文中示例代碼介紹的非常詳細(xì)，具有一定的參考價值，感興趣的小伙伴們可以參考一下

梯度下降（Gradient Descent）算法是機(jī)器學(xué)習(xí)中使用非常廣泛的優(yōu)化算法。當(dāng)前流行的機(jī)器學(xué)習(xí)庫或者深度學(xué)習(xí)庫都會包括梯度下降算法的不同變種實現(xiàn)。

本文主要以線性回歸算法損失函數(shù)求極小值來說明如何使用梯度下降算法并給出python實現(xiàn)。若有不正確的地方，希望讀者能指出。

梯度下降

梯度下降原理：將函數(shù)比作一座山，我們站在某個山坡上，往四周看，從哪個方向向下走一小步，能夠下降的最快。

在線性回歸算法中，損失函數(shù)為

在求極小值時，在數(shù)據(jù)量很小的時候，可以使用矩陣求逆的方式求最優(yōu)的θ值。但當(dāng)數(shù)據(jù)量和特征值非常大，例如幾萬甚至上億時，使用矩陣求逆根本就不現(xiàn)實。而梯度下降法就是很好的一個選擇了。

使用梯度下降算法的步驟：

1）對θ賦初始值，這個值可以是隨機(jī)的，也可以讓θ是一個全零的向量。

2）改變θ的值，使得目標(biāo)損失函數(shù)J(θ)按梯度下降的方向進(jìn)行減少。

其中為學(xué)習(xí)率或步長，需要人為指定，若過大會導(dǎo)致震蕩即不收斂，若過小收斂速度會很慢。

3）當(dāng)下降的高度小于某個定義的值，則停止下降。

另外，對上面線性回歸算法損失函數(shù)求梯度，結(jié)果如下：

在實際應(yīng)用的過程中，梯度下降算法有三類，它們不同之處在于每次學(xué)習(xí)(更新模型參數(shù))使用的樣本個數(shù)，每次更新使用不同的樣本會導(dǎo)致每次學(xué)習(xí)的準(zhǔn)確性和學(xué)習(xí)時間不同。下面將分別介紹原理及python實現(xiàn)。

批量梯度下降(Batch gradient descent)

每次使用全量的訓(xùn)練集樣本來更新模型參數(shù)，即給定一個步長，然后對所有的樣本的梯度的和進(jìn)行迭代：

梯度下降算法最終得到的是局部極小值。而線性回歸的損失函數(shù)為凸函數(shù)，有且只有一個局部最小，則這個局部最小一定是全局最小。所以線性回歸中使用批量梯度下降算法，一定可以找到一個全局最優(yōu)解。

優(yōu)點：全局最優(yōu)解；易于并行實現(xiàn)；總體迭代次數(shù)不多
缺點：當(dāng)樣本數(shù)目很多時，訓(xùn)練過程會很慢，每次迭代需要耗費大量的時間。

隨機(jī)梯度下降(Stochastic gradient descent)

隨機(jī)梯度下降算法每次從訓(xùn)練集中隨機(jī)選擇一個樣本來進(jìn)行迭代，即：

隨機(jī)梯度下降算法每次只隨機(jī)選擇一個樣本來更新模型參數(shù)，因此每次的學(xué)習(xí)是非?？焖俚?，并且可以進(jìn)行在線更新。

隨機(jī)梯度下降最大的缺點在于每次更新可能并不會按照正確的方向進(jìn)行，因此可以帶來優(yōu)化波動(擾動)。不過從另一個方面來看，隨機(jī)梯度下降所帶來的波動有個好處就是，對于類似盆地區(qū)域（即很多局部極小值點）那么這個波動的特點可能會使得優(yōu)化的方向從當(dāng)前的局部極小值點跳到另一個更好的局部極小值點，這樣便可能對于非凸函數(shù)，最終收斂于一個較好的局部極值點，甚至全局極值點。

優(yōu)點：訓(xùn)練速度快，每次迭代計算量不大
缺點：準(zhǔn)確度下降，并不是全局最優(yōu)；不易于并行實現(xiàn)；總體迭代次數(shù)比較多。

Mini-batch梯度下降算法

Mini-batch梯度下降綜合了batch梯度下降與stochastic梯度下降，在每次更新速度與更新次數(shù)中間取得一個平衡，其每次更新從訓(xùn)練集中隨機(jī)選擇b,b<m個樣本進(jìn)行學(xué)習(xí)，即：

python代碼實現(xiàn)

批量梯度下降算法

#!/usr/bin/python
#coding=utf-8
import numpy as np
from scipy import stats
import matplotlib.pyplot as plt
 
# 構(gòu)造訓(xùn)練數(shù)據(jù)
x = np.arange(0., 10., 0.2)
m = len(x) # 訓(xùn)練數(shù)據(jù)點數(shù)目
print m
x0 = np.full(m, 1.0)
input_data = np.vstack([x0, x]).T # 將偏置b作為權(quán)向量的第一個分量
target_data = 2 * x + 5 + np.random.randn(m)
 
# 兩種終止條件
loop_max = 10000 # 最大迭代次數(shù)(防止死循環(huán))
epsilon = 1e-3
 
# 初始化權(quán)值
np.random.seed(0)
theta = np.random.randn(2)
 
alpha = 0.001 # 步長(注意取值過大會導(dǎo)致振蕩即不收斂,過小收斂速度變慢)
diff = 0.
error = np.zeros(2)
count = 0 # 循環(huán)次數(shù)
finish = 0 # 終止標(biāo)志
 
while count < loop_max:
 count += 1
 
 # 標(biāo)準(zhǔn)梯度下降是在權(quán)值更新前對所有樣例匯總誤差，而隨機(jī)梯度下降的權(quán)值是通過考查某個訓(xùn)練樣例來更新的
 # 在標(biāo)準(zhǔn)梯度下降中，權(quán)值更新的每一步對多個樣例求和，需要更多的計算
 sum_m = np.zeros(2)
 for i in range(m):
 dif = (np.dot(theta, input_data[i]) - target_data[i]) * input_data[i]
 sum_m = sum_m + dif # 當(dāng)alpha取值過大時,sum_m會在迭代過程中會溢出
 
 theta = theta - alpha * sum_m # 注意步長alpha的取值,過大會導(dǎo)致振蕩
 # theta = theta - 0.005 * sum_m # alpha取0.005時產(chǎn)生振蕩,需要將alpha調(diào)小
 
 # 判斷是否已收斂
 if np.linalg.norm(theta - error) < epsilon:
 finish = 1
 break
 else:
 error = theta
 print 'loop count = %d' % count, '\tw:',theta
print 'loop count = %d' % count, '\tw:',theta
 
# check with scipy linear regression
slope, intercept, r_value, p_value, slope_std_error = stats.linregress(x, target_data)
print 'intercept = %s slope = %s' % (intercept, slope)
 
plt.plot(x, target_data, 'g*')
plt.plot(x, theta[1] * x + theta[0], 'r')
plt.show()

運行結(jié)果截圖：

隨機(jī)梯度下降算法

#!/usr/bin/python
#coding=utf-8
import numpy as np
from scipy import stats
import matplotlib.pyplot as plt
 
# 構(gòu)造訓(xùn)練數(shù)據(jù)
x = np.arange(0., 10., 0.2)
m = len(x) # 訓(xùn)練數(shù)據(jù)點數(shù)目
x0 = np.full(m, 1.0)
input_data = np.vstack([x0, x]).T # 將偏置b作為權(quán)向量的第一個分量
target_data = 2 * x + 5 + np.random.randn(m)
 
# 兩種終止條件
loop_max = 10000 # 最大迭代次數(shù)(防止死循環(huán))
epsilon = 1e-3
 
# 初始化權(quán)值
np.random.seed(0)
theta = np.random.randn(2)
# w = np.zeros(2)
 
alpha = 0.001 # 步長(注意取值過大會導(dǎo)致振蕩,過小收斂速度變慢)
diff = 0.
error = np.zeros(2)
count = 0 # 循環(huán)次數(shù)
finish = 0 # 終止標(biāo)志
######-隨機(jī)梯度下降算法
while count < loop_max:
 count += 1
 
 # 遍歷訓(xùn)練數(shù)據(jù)集，不斷更新權(quán)值
 for i in range(m):
 diff = np.dot(theta, input_data[i]) - target_data[i] # 訓(xùn)練集代入,計算誤差值
 
 # 采用隨機(jī)梯度下降算法,更新一次權(quán)值只使用一組訓(xùn)練數(shù)據(jù)
 theta = theta - alpha * diff * input_data[i]
 
 # ------------------------------終止條件判斷-----------------------------------------
 # 若沒終止，則繼續(xù)讀取樣本進(jìn)行處理，如果所有樣本都讀取完畢了,則循環(huán)重新從頭開始讀取樣本進(jìn)行處理。
 
 # ----------------------------------終止條件判斷-----------------------------------------
 # 注意：有多種迭代終止條件，和判斷語句的位置。終止判斷可以放在權(quán)值向量更新一次后,也可以放在更新m次后。
 if np.linalg.norm(theta - error) < epsilon: # 終止條件：前后兩次計算出的權(quán)向量的絕對誤差充分小
 finish = 1
 break
 else:
 error = theta
print 'loop count = %d' % count, '\tw:',theta
 
 
# check with scipy linear regression
slope, intercept, r_value, p_value, slope_std_error = stats.linregress(x, target_data)
print 'intercept = %s slope = %s' % (intercept, slope)
 
plt.plot(x, target_data, 'g*')
plt.plot(x, theta[1] * x + theta[0], 'r')
plt.show()

運行結(jié)果截圖：

Mini-batch梯度下降

#!/usr/bin/python
#coding=utf-8
import numpy as np
from scipy importstats
import matplotlib.pyplot as plt
 
# 構(gòu)造訓(xùn)練數(shù)據(jù)
x = np.arange(0.,10.,0.2)
m = len(x) # 訓(xùn)練數(shù)據(jù)點數(shù)目
print m
x0 = np.full(m, 1.0)
input_data = np.vstack([x0, x]).T # 將偏置b作為權(quán)向量的第一個分量
target_data = 2 *x + 5 +np.random.randn(m)
 
# 兩種終止條件
loop_max = 10000 #最大迭代次數(shù)(防止死循環(huán))
epsilon = 1e-3
 
# 初始化權(quán)值
np.random.seed(0)
theta = np.random.randn(2)
 
alpha = 0.001 #步長(注意取值過大會導(dǎo)致振蕩即不收斂,過小收斂速度變慢)
diff = 0.
error = np.zeros(2)
count = 0 #循環(huán)次數(shù)
finish = 0 #終止標(biāo)志
minibatch_size = 5 #每次更新的樣本數(shù)
while count < loop_max:
 count += 1
 
 # minibatch梯度下降是在權(quán)值更新前對所有樣例匯總誤差，而隨機(jī)梯度下降的權(quán)值是通過考查某個訓(xùn)練樣例來更新的
 # 在minibatch梯度下降中，權(quán)值更新的每一步對多個樣例求和，需要更多的計算
 
 for i inrange(1,m,minibatch_size):
 sum_m = np.zeros(2)
 for k inrange(i-1,i+minibatch_size-1,1):
  dif = (np.dot(theta, input_data[k]) - target_data[k]) *input_data[k]
  sum_m = sum_m + dif #當(dāng)alpha取值過大時,sum_m會在迭代過程中會溢出
 
 theta = theta- alpha * (1.0/minibatch_size) * sum_m #注意步長alpha的取值,過大會導(dǎo)致振蕩
 
 # 判斷是否已收斂
 if np.linalg.norm(theta- error) < epsilon:
 finish = 1
 break
 else:
 error = theta
 print 'loopcount = %d'% count, '\tw:',theta
print 'loop count = %d'% count, '\tw:',theta
 
# check with scipy linear regression
slope, intercept, r_value, p_value,slope_std_error = stats.linregress(x, target_data)
print 'intercept = %s slope = %s'% (intercept, slope)
 
plt.plot(x, target_data, 'g*')
plt.plot(x, theta[1]* x +theta[0],'r')
plt.show()

運行結(jié)果：