python gradientboostingregressor可以做預(yù)測嗎

可以

我們提供的服務(wù)有：成都做網(wǎng)站、成都網(wǎng)站設(shè)計、成都外貿(mào)網(wǎng)站建設(shè)、微信公眾號開發(fā)、網(wǎng)站優(yōu)化、網(wǎng)站認(rèn)證、申扎ssl等。為成百上千企事業(yè)單位解決了網(wǎng)站和推廣的問題。提供周到的售前咨詢和貼心的售后服務(wù)，是有科學(xué)管理、有技術(shù)的申扎網(wǎng)站制作公司

最近項目中涉及基于Gradient Boosting Regression 算法擬合時間序列曲線的內(nèi)容，利用python機(jī)器學(xué)習(xí)包?scikit-learn 中的GradientBoostingRegressor完成

因此就學(xué)習(xí)了下Gradient Boosting算法，在這里分享下我的理解

Boosting 算法簡介

Boosting算法，我理解的就是兩個思想：

1）“三個臭皮匠頂個諸葛亮”，一堆弱分類器的組合就可以成為一個強(qiáng)分類器；

2）“知錯能改，善莫大焉”，不斷地在錯誤中學(xué)習(xí)，迭代來降低犯錯概率

當(dāng)然，要理解好Boosting的思想，首先還是從弱學(xué)習(xí)算法和強(qiáng)學(xué)習(xí)算法來引入：

1）強(qiáng)學(xué)習(xí)算法：存在一個多項式時間的學(xué)習(xí)算法以識別一組概念，且識別的正確率很高；

2）弱學(xué)習(xí)算法：識別一組概念的正確率僅比隨機(jī)猜測略好；

Kearns Valiant證明了弱學(xué)習(xí)算法與強(qiáng)學(xué)習(xí)算法的等價問題，如果兩者等價，只需找到一個比隨機(jī)猜測略好的學(xué)習(xí)算法，就可以將其提升為強(qiáng)學(xué)習(xí)算法。

那么是怎么實現(xiàn)“知錯就改”的呢？

Boosting算法，通過一系列的迭代來優(yōu)化分類結(jié)果，每迭代一次引入一個弱分類器，來克服現(xiàn)在已經(jīng)存在的弱分類器組合的shortcomings

在Adaboost算法中，這個shortcomings的表征就是權(quán)值高的樣本點

而在Gradient Boosting算法中,這個shortcomings的表征就是梯度

無論是Adaboost還是Gradient Boosting，都是通過這個shortcomings來告訴學(xué)習(xí)器怎么去提升模型，也就是“Boosting”這個名字的由來吧

Adaboost算法

Adaboost是由Freund 和 Schapire在1997年提出的，在整個訓(xùn)練集上維護(hù)一個分布權(quán)值向量W,用賦予權(quán)重的訓(xùn)練集通過弱分類算法產(chǎn)生分類假設(shè)（基學(xué)習(xí)器）y(x),然后計算錯誤率,用得到的錯誤率去更新分布權(quán)值向量w,對錯誤分類的樣本分配更大的權(quán)值,正確分類的樣本賦予更小的權(quán)值。每次更新后用相同的弱分類算法產(chǎn)生新的分類假設(shè),這些分類假設(shè)的序列構(gòu)成多分類器。對這些多分類器用加權(quán)的方法進(jìn)行聯(lián)合,最后得到?jīng)Q策結(jié)果。

其結(jié)構(gòu)如下圖所示：

前一個學(xué)習(xí)器改變權(quán)重w，然后再經(jīng)過下一個學(xué)習(xí)器，最終所有的學(xué)習(xí)器共同組成最后的學(xué)習(xí)器。

如果一個樣本在前一個學(xué)習(xí)器中被誤分，那么它所對應(yīng)的權(quán)重會被加重，相應(yīng)地，被正確分類的樣本的權(quán)重會降低。

這里主要涉及到兩個權(quán)重的計算問題：

1）樣本的權(quán)值

1 沒有先驗知識的情況下,初始的分布應(yīng)為等概分布,樣本數(shù)目為n,權(quán)值為1/n

2 每一次的迭代更新權(quán)值，提高分錯樣本的權(quán)重

2）弱學(xué)習(xí)器的權(quán)值

1 最后的強(qiáng)學(xué)習(xí)器是通過多個基學(xué)習(xí)器通過權(quán)值組合得到的。

2 通過權(quán)值體現(xiàn)不同基學(xué)習(xí)器的影響,正確率高的基學(xué)習(xí)器權(quán)重高。實際上是分類誤差的一個函數(shù)

Gradient Boosting

和Adaboost不同，Gradient Boosting 在迭代的時候選擇梯度下降的方向來保證最后的結(jié)果最好。

損失函數(shù)用來描述模型的“靠譜”程度，假設(shè)模型沒有過擬合，損失函數(shù)越大，模型的錯誤率越高

如果我們的模型能夠讓損失函數(shù)持續(xù)的下降，則說明我們的模型在不停的改進(jìn)，而最好的方式就是讓損失函數(shù)在其梯度方向上下降。

下面這個流程圖是Gradient Boosting的經(jīng)典圖了，數(shù)學(xué)推導(dǎo)并不復(fù)雜，只要理解了Boosting的思想，不難看懂

這里是直接對模型的函數(shù)進(jìn)行更新，利用了參數(shù)可加性推廣到函數(shù)空間。

訓(xùn)練F0-Fm一共m個基學(xué)習(xí)器，沿著梯度下降的方向不斷更新ρm和am

GradientBoostingRegressor實現(xiàn)

python中的scikit-learn包提供了很方便的GradientBoostingRegressor和GBDT的函數(shù)接口，可以很方便的調(diào)用函數(shù)就可以完成模型的訓(xùn)練和預(yù)測

GradientBoostingRegressor函數(shù)的參數(shù)如下：

class sklearn.ensemble.GradientBoostingRegressor(loss='ls', learning_rate=0.1, n_estimators=100, subsample=1.0, min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_depth=3, init=None, random_state=None, max_features=None, alpha=0.9, verbose=0, max_leaf_nodes=None, warm_start=False, presort='auto')[source]?

loss: 選擇損失函數(shù)，默認(rèn)值為ls(least squres)

learning_rate: 學(xué)習(xí)率，模型是0.1

n_estimators: 弱學(xué)習(xí)器的數(shù)目，默認(rèn)值100

max_depth: 每一個學(xué)習(xí)器的最大深度，限制回歸樹的節(jié)點數(shù)目，默認(rèn)為3

min_samples_split: 可以劃分為內(nèi)部節(jié)點的最小樣本數(shù)，默認(rèn)為2

min_samples_leaf: 葉節(jié)點所需的最小樣本數(shù)，默認(rèn)為1

……

可以參考

官方文檔里帶了一個很好的例子，以500個弱學(xué)習(xí)器，最小平方誤差的梯度提升模型，做波士頓房價預(yù)測，代碼和結(jié)果如下：

1 import numpy as np 2 import matplotlib.pyplot as plt 3 ?4 from sklearn import ensemble 5 from sklearn import datasets 6 from sklearn.utils import shuffle 7 from sklearn.metrics import mean_squared_error 8 ?9 ###############################################################################10 # Load data11 boston = datasets.load_boston()12 X, y = shuffle(boston.data, boston.target, random_state=13)13 X = X.astype(np.float32)14 offset = int(X.shape[0] * 0.9)15 X_train, y_train = X[:offset], y[:offset]16 X_test, y_test = X[offset:], y[offset:]17 18 ###############################################################################19 # Fit regression model20 params = {'n_estimators': 500, 'max_depth': 4, 'min_samples_split': 1,21 ? ? ? ? ? 'learning_rate': 0.01, 'loss': 'ls'}22 clf = ensemble.GradientBoostingRegressor(**params)23 24 clf.fit(X_train, y_train)25 mse = mean_squared_error(y_test, clf.predict(X_test))26 print("MSE: %.4f" % mse)27 28 ###############################################################################29 # Plot training deviance30 31 # compute test set deviance32 test_score = np.zeros((params['n_estimators'],), dtype=np.float64)33 34 for i, y_pred in enumerate(clf.staged_predict(X_test)):35 ? ? test_score[i] = clf.loss_(y_test, y_pred)36 37 plt.figure(figsize=(12, 6))38 plt.subplot(1, 2, 1)39 plt.title('Deviance')40 plt.plot(np.arange(params['n_estimators']) + 1, clf.train_score_, 'b-',41 ? ? ? ? ?label='Training Set Deviance')42 plt.plot(np.arange(params['n_estimators']) + 1, test_score, 'r-',43 ? ? ? ? ?label='Test Set Deviance')44 plt.legend(loc='upper right')45 plt.xlabel('Boosting Iterations')46 plt.ylabel('Deviance')47 48 ###############################################################################49 # Plot feature importance50 feature_importance = clf.feature_importances_51 # make importances relative to max importance52 feature_importance = 100.0 * (feature_importance / feature_importance.max())53 sorted_idx = np.argsort(feature_importance)54 pos = np.arange(sorted_idx.shape[0]) + .555 plt.subplot(1, 2, 2)56 plt.barh(pos, feature_importance[sorted_idx], align='center')57 plt.yticks(pos, boston.feature_names[sorted_idx])58 plt.xlabel('Relative Importance')59 plt.title('Variable Importance')60 plt.show()

可以發(fā)現(xiàn)，如果要用Gradient Boosting 算法的話，在sklearn包里調(diào)用還是非常方便的，幾行代碼即可完成，大部分的工作應(yīng)該是在特征提取上。

感覺目前做數(shù)據(jù)挖掘的工作，特征設(shè)計是最重要的，據(jù)說現(xiàn)在kaggle競賽基本是GBDT的天下，優(yōu)劣其實還是特征上，感覺做項目也是，不斷的在研究數(shù)據(jù)中培養(yǎng)對數(shù)據(jù)的敏感度。

OpenCV-Python系列四：圖像分割(2)--梯度

上一期提到的圖像閾值處理，不僅可以實現(xiàn)獲取你想要的目標(biāo)區(qū)域(作為mask使用)，還可以幫你獲取圖像的邊緣信息，那關(guān)于圖像邊緣，本期將從另外的角度來處理。

對邊緣信息與背景差異較大的場景，你也可以使用threshold分割，不過若閾值不好選取，Laplacian梯度算子就不失為一直嘗試方案，而且上網(wǎng)看看，關(guān)于Laplacian算子還可以用來判斷圖像的模糊程度，這個在相機(jī)的自動對焦當(dāng)中，是否可以嘗試判斷下？

不過處理的效果并不理想，圖像低灰階部分邊緣信息丟失嚴(yán)重。

對于sobel，laplacian算子我們可以使用cv2.filter2D()來實現(xiàn)，配置相應(yīng)的核模板即可，如實現(xiàn)提取水平方向邊緣信息：

你可以依據(jù)實際的應(yīng)用需求來配置提取邊緣的角度信息，這里以45度角(垂直向下逆時針旋轉(zhuǎn)45度)為例：

對此，你可以采用下面的方式來解決：

如何使用python計算常微分方程？

常用形式

odeint(func, y0, t,args,Dfun)

一般這種形式就夠用了。

下面是官方的例子，求解的是

D(D(y1))-t*y1=0

為了方便，采取D=d/dt。如果我們令初值

y1(0) = 1.0/3**(2.0/3.0)/gamma(2.0/3.0)

D(y1)(0) = -1.0/3**(1.0/3.0)/gamma(1.0/3.0)

這個微分方程的解y1=airy(t)。

令D(y1)=y0，就有這個常微分方程組。

D(y0)=t*y1

D(y1)=y0

Python求解該微分方程。

from scipy.integrate import odeint

from scipy.special import gamma, airy

y1_0 = 1.0/3**(2.0/3.0)/gamma(2.0/3.0)

y0_0 = -1.0/3**(1.0/3.0)/gamma(1.0/3.0)

y0 = [y0_0, y1_0]

def func(y, t):

... return [t*y[1],y[0]]

def gradient(y,t):

... return [[0,t],[1,0]]

x = arange(0,4.0, 0.01)

t = x

ychk = airy(x)[0]

y = odeint(func, y0, t)

y2 = odeint(func, y0, t, Dfun=gradient)

print ychk[:36:6]

[ 0.355028 0.339511 0.324068 0.308763 0.293658 0.278806]

print y[:36:6,1]

[ 0.355028 0.339511 0.324067 0.308763 0.293658 0.278806]

print y2[:36:6,1]

[ 0.355028 0.339511 0.324067 0.308763 0.293658 0.278806]

得到的解與精確值相比，誤差相當(dāng)小。

=======================================================================================================

args是額外的參數(shù)。

用法請參看下面的例子。這是一個洛侖茲曲線的求解，并且用matplotlib繪出空間曲線圖。（來自《python科學(xué)計算》）

from scipy.integrate import odeint

import numpy as np

def lorenz(w, t, p, r, b):

# 給出位置矢量w，和三個參數(shù)p, r, b 計算出

# dx/dt, dy/dt, dz/dt 的值

x, y, z = w

# 直接與lorenz 的計算公式對應(yīng)

return np.array([p*(y-x), x*(r-z)-y, x*y-b*z])

t = np.arange(0, 30, 0.01) # 創(chuàng)建時間點

# 調(diào)用ode 對lorenz 進(jìn)行求解, 用兩個不同的初始值

track1 = odeint(lorenz, (0.0, 1.00, 0.0), t, args=(10.0, 28.0, 3.0))

track2 = odeint(lorenz, (0.0, 1.01, 0.0), t, args=(10.0, 28.0, 3.0))

# 繪圖

from mpl_toolkits.mplot3d import Axes3D

import matplotlib.pyplot as plt

fig = plt.figure()

ax = Axes3D(fig)

ax.plot(track1[:,0], track1[:,1], track1[:,2])

ax.plot(track2[:,0], track2[:,1], track2[:,2])

plt.show()

===========================================================================

scipy.integrate.odeint(func, y0, t, args=(), Dfun=None, col_deriv=0, full_output=0, ml=None, mu=None, rtol=None, atol=None, tcrit=None, h0=0.0, hmax=0.0, hmin=0.0, ixpr=0, mxstep=0, mxhnil=0, mxordn=12, mxords=5, printmessg=0)

計算常微分方程（組）

使用 FORTRAN庫odepack中的lsoda解常微分方程。這個函數(shù)一般求解初值問題。

參數(shù)：

func : callable(y, t0, ...) 計算y在t0 處的導(dǎo)數(shù)。

y0 : 數(shù)組 y的初值條件（可以是矢量）

t : 數(shù)組 為求出y，這是一個時間點的序列。初值點應(yīng)該是這個序列的第一個元素。

args : 元組 func的額外參數(shù)

Dfun : callable(y, t0, ...) 函數(shù)的梯度(Jacobian)。即雅可比多項式。

col_deriv : boolean. True，Dfun定義列向?qū)?shù)（更快），否則Dfun會定義橫排導(dǎo)數(shù)

full_output : boolean 可選輸出，如果為True 則返回一個字典，作為第二輸出。

printmessg : boolean 是否打印convergence 消息。

返回： y : array, shape (len(y0), len(t))

數(shù)組，包含y值，每一個對應(yīng)于時間序列中的t。初值y0 在第一排。

infodict : 字典，只有full_output == True 時，才會返回。

字典包含額為的輸出信息。

鍵值：

‘hu’ vector of step sizes successfully used for each time step.

‘tcur’ vector with the value of t reached for each time step. (will always be at least as large as the input times).

‘tolsf’ vector of tolerance scale factors, greater than 1.0, computed when a request for too much accuracy was detected.

‘tsw’ value of t at the time of the last method switch (given for each time step)

‘nst’ cumulative number of time steps

‘nfe’ cumulative number of function evaluations for each time step

‘nje’ cumulative number of jacobian evaluations for each time step

‘nqu’ a vector of method orders for each successful step.

‘imxer’index of the component of largest magnitude in the weighted local error vector (e / ewt) on an error return, -1 otherwise.

‘lenrw’ the length of the double work array required.

‘leniw’ the length of integer work array required.

‘mused’a vector of method indicators for each successful time step: 1: adams (nonstiff), 2: bdf (stiff)

其他參數(shù)，官方網(wǎng)站和文檔都沒有明確說明。相關(guān)的資料，暫時也找不到。

Python怎么做最優(yōu)化

一、概觀

scipy中的optimize子包中提供了常用的最優(yōu)化算法函數(shù)實現(xiàn)。我們可以直接調(diào)用這些函數(shù)完成我們的優(yōu)化問題。optimize中函數(shù)最典型的特點就是能夠從函數(shù)名稱上看出是使用了什么算法。下面optimize包中函數(shù)的概覽：

1.非線性最優(yōu)化

fmin -- 簡單Nelder-Mead算法

fmin_powell -- 改進(jìn)型Powell法

fmin_bfgs -- 擬Newton法

fmin_cg -- 非線性共軛梯度法

fmin_ncg -- 線性搜索Newton共軛梯度法

leastsq -- 最小二乘

2.有約束的多元函數(shù)問題

fmin_l_bfgs_b ---使用L-BFGS-B算法

fmin_tnc ---梯度信息

fmin_cobyla ---線性逼近

fmin_slsqp ---序列最小二乘法

nnls ---解|| Ax - b ||_2 for x=0

3.全局優(yōu)化

anneal ---模擬退火算法

brute --強(qiáng)力法

4.標(biāo)量函數(shù)

fminbound

brent

golden

bracket

5.擬合

curve_fit-- 使用非線性最小二乘法擬合

6.標(biāo)量函數(shù)求根

brentq ---classic Brent (1973)

brenth ---A variation on the classic Brent（1980）ridder ---Ridder是提出這個算法的人名

bisect ---二分法

newton ---牛頓法

fixed_point

7.多維函數(shù)求根

fsolve ---通用

broyden1 ---Broyden’s first Jacobian approximation.

broyden2 ---Broyden’s second Jacobian approximationnewton_krylov ---Krylov approximation for inverse Jacobiananderson ---extended Anderson mixing

excitingmixing ---tuned diagonal Jacobian approximationlinearmixing ---scalar Jacobian approximationdiagbroyden ---diagonal Broyden Jacobian approximation8.實用函數(shù)

line_search ---找到滿足強(qiáng)Wolfe的alpha值

check_grad ---通過和前向有限差分逼近比較檢查梯度函數(shù)的正確性二、實戰(zhàn)非線性最優(yōu)化

fmin完整的調(diào)用形式是：

fmin(func, x0, args=(), xtol=0.0001, ftol=0.0001, maxiter=None, maxfun=None, full_output=0, disp=1, retall=0, callback=None)不過我們最常使用的就是前兩個參數(shù)。一個描述優(yōu)化問題的函數(shù)以及初值。后面的那些參數(shù)我們也很容易理解。如果您能用到，請自己研究。下面研究一個最簡單的問題，來感受這個函數(shù)的使用方法：f(x)=x**2-4*x+8，我們知道，這個函數(shù)的最小值是4，在x=2的時候取到。

from scipy.optimize import fmin #引入優(yōu)化包def myfunc(x):

return x**2-4*x+8 #定義函數(shù)

x0 = [1.3] #猜一個初值

xopt = fmin(myfunc, x0) #求解

print xopt #打印結(jié)果

運行之后，給出的結(jié)果是：

Optimization terminated successfully.

Current function value: 4.000000

Iterations: 16

Function evaluations: 32

[ 2.00001953]

程序準(zhǔn)確的計算得出了最小值，不過最小值點并不是嚴(yán)格的2，這應(yīng)該是由二進(jìn)制機(jī)器編碼誤差造成的。

除了fmin_ncg必須提供梯度信息外，其他幾個函數(shù)的調(diào)用大同小異，完全類似。我們不妨做一個對比：

from scipy.optimize import fmin,fmin_powell,fmin_bfgs,fmin_cgdef myfunc(x):

return x**2-4*x+8

x0 = [1.3]

xopt1 = fmin(myfunc, x0)

print xopt1

print

xopt2 = fmin_powell(myfunc, x0)

print xopt2

print

xopt3 = fmin_bfgs(myfunc, x0)

print xopt3

print

xopt4 = fmin_cg(myfunc,x0)

print xopt4

給出的結(jié)果是：

Optimization terminated successfully.

Current function value: 4.000000

Iterations: 16

Function evaluations: 32

[ 2.00001953]

Optimization terminated successfully.

Current function value: 4.000000

Iterations: 2

Function evaluations: 53

1.99999999997

Optimization terminated successfully.

Current function value: 4.000000

Iterations: 2

Function evaluations: 12

Gradient evaluations: 4

[ 2.00000001]

Optimization terminated successfully.

Current function value: 4.000000

Iterations: 2

Function evaluations: 15

Gradient evaluations: 5

[ 2.]

我們可以根據(jù)給出的消息直觀的判斷算法的執(zhí)行情況。每一種算法數(shù)學(xué)上的問題，請自己看書學(xué)習(xí)。個人感覺，如果不是純研究數(shù)學(xué)的工作，沒必要搞清楚那些推導(dǎo)以及定理云云。不過，必須了解每一種算法的優(yōu)劣以及能力所及。在使用的時候，不妨多種算法都使用一下，看看效果分別如何，同時，還可以互相印證算法失效的問題。

在from scipy.optimize import fmin之后，就可以使用help(fmin)來查看fmin的幫助信息了。幫助信息中沒有例子，但是給出了每一個參數(shù)的含義說明，這是調(diào)用函數(shù)時候的最有價值參考。

有源碼研究癖好的，或者當(dāng)你需要改進(jìn)這些已經(jīng)實現(xiàn)的算法的時候，可能需要查看optimize中的每種算法的源代碼。在這里：https:/ / github. com/scipy/scipy/blob/master/scipy/optimize/optimize.py聰明的你肯定發(fā)現(xiàn)了，順著這個鏈接往上一級、再往上一級，你會找到scipy的幾乎所有源碼！

網(wǎng)頁名稱：python梯度函數(shù) python求梯度函數(shù)
URL標(biāo)題：http://www.chinadenli.net/article44/dooghee.html

成都網(wǎng)站建設(shè)公司_創(chuàng)新互聯(lián)，為您提供外貿(mào)網(wǎng)站建設(shè)、網(wǎng)站營銷、企業(yè)建站、網(wǎng)站收錄、網(wǎng)站制作、定制網(wǎng)站

廣告

聲明：本網(wǎng)站發(fā)布的內(nèi)容（圖片、視頻和文字）以用戶投稿、用戶轉(zhuǎn)載內(nèi)容為主，如果涉及侵權(quán)請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網(wǎng)站立場，如需處理請聯(lián)系客服。電話：028-86922220；郵箱：631063699@qq.com。內(nèi)容未經(jīng)允許不得轉(zhuǎn)載，或轉(zhuǎn)載時需注明來源： 創(chuàng)新互聯(lián)