Visualisasi langkah demi langkah proses membuat keputusan bagi algoritma penggalak kecerunan

Algoritma penggalak kecerunan ialah salah satu teknik pembelajaran mesin ensemble yang paling biasa digunakan Model ini menggunakan jujukan pepohon keputusan yang lemah untuk membina pelajar yang kuat. Ini juga merupakan asas teori model XGBoost dan LightGBM, jadi dalam artikel ini, kami akan membina model peningkatan kecerunan dari awal dan menggambarkannya.

Pengenalan kepada Algoritma Peningkatan Kecerunan

Algoritma Peningkatan Kecerunan ialah algoritma pembelajaran ensemble yang meningkatkan prestasi dengan membina berbilang pengelas lemah dan kemudian menggabungkannya menjadi pengelas yang kukuh Ketepatan ramalan model.

Prinsip algoritma penggalak kecerunan boleh dibahagikan kepada langkah berikut:

1. Memulakan model: Secara umumnya, kita boleh menggunakan model mudah (seperti pepohon keputusan) sebagai pengelas awal.
2. Kira kecerunan negatif fungsi kehilangan: Kira kecerunan negatif fungsi kehilangan di bawah model semasa untuk setiap titik sampel. Ini bersamaan dengan meminta pengelas baharu untuk memuatkan ralat di bawah model semasa.
3. Latih pengelas baharu: Gunakan kecerunan negatif ini sebagai pembolehubah sasaran untuk melatih pengelas lemah baharu. Pengelas lemah ini boleh menjadi sebarang pengelas, seperti pepohon keputusan, model linear, dsb.
4. Kemas kini model: Tambahkan pengelas baharu pada model asal dan gabungkannya menggunakan purata wajaran atau kaedah lain.
5. Ulangi lelaran: Ulang langkah di atas sehingga bilangan pratetap lelaran dicapai atau ketepatan pratetap dicapai.

Memandangkan algoritma penggalak kecerunan ialah algoritma bersiri, kelajuan latihannya mungkin lebih perlahan Mari kita perkenalkan dengan contoh praktikal:

Andaikan kita mempunyai ciri Diberikan satu set

Setiap langkah kita mahu menjadikan F_m(x) lebih dekat dengan y|x.

Pada setiap langkah, kami mahu F_m(x) menjadi anggaran yang lebih baik bagi y diberi x.

Pertama, kita mentakrifkan fungsi kehilangan

Kemudian, kita bergerak ke arah di mana fungsi kehilangan berkurangan paling cepat berbanding dengan pelajar Fm Hadapan:

Kami tidak tahu nilai tepat kecerunan ini kerana kami tidak boleh mengira y untuk setiap x, tetapi untuk setiap x_i, kecerunan adalah betul-betul sama dengan baki langkah m: r_i!

Jadi kita boleh menggunakan pepohon regresi lemah h_m untuk menganggarkan fungsi kecerunan g_m dan melatih baki:

Kemudian, kami mengemas kini pelajar

Ini adalah peningkatan kecerunan, kami tidak menggunakan fungsi kehilangan relatif kepada semasa Kecerunan sebenar g_m pelajar digunakan untuk mengemas kini pelajar semasa F_{m}, tetapi pepohon regresi yang lemah h_m digunakan untuk mengemas kininya.

Iaitu, ulangi langkah berikut

1 Kira baki:

2. . Pasangkan pokok regresi h_m pada sampel latihan dan sisanya (x_i, r_i)

3 Kemas kini model dengan langkah alpha

Tonton Ia rumit. , kan? Mari kita bayangkan proses ini dan ia akan menjadi sangat jelas

Visualisasi proses membuat keputusan

Di sini kita menggunakan set data bulan sklearn, kerana ini ialah Data Kategori tak linear klasik

Mari kita bayangkan data:

下图可以看到，该数据集是可以明显的区分出分类的边界的，但是因为他是非线性的，所以使用线性算法进行分类时会遇到很大的困难。

那么我们先编写一个简单的梯度增强模型:

def makeiteration(i:int):
"""Takes the dataframe ith f_i and r_i and approximated r_i from the features, then computes f_i+1 and r_i+1"""
clf = tree.DecisionTreeRegressor(max_depth=1)
clf.fit(X=df[['x','y']].values, y = df[f'r{i-1}'])
df[f'r{i-1}hat'] = clf.predict(df[['x','y']].values)
 
eta = 0.9
df[f'f{i}'] = df[f'f{i-1}'] + eta*df[f'r{i-1}hat']
df[f'r{i}'] = df['z'] - df[f'f{i}']
rmse = (df[f'r{i}']**2).sum()
clfs.append(clf)
rmses.append(rmse)

上面代码执行3个简单步骤:

将决策树与残差进行拟合:

clf.fit(X=df[['x','y']].values, y = df[f'r{i-1}'])
 df[f'r{i-1}hat'] = clf.predict(df[['x','y']].values)

然后，我们将这个近似的梯度与之前的学习器相加:

df[f'f{i}'] = df[f'f{i-1}'] + eta*df[f'r{i-1}hat']

最后重新计算残差:

df[f'r{i}'] = df['z'] - df[f'f{i}']

步骤就是这样简单，下面我们来一步一步执行这个过程。

第1次决策

Tree Split for 0 and level 1.563690960407257

第2次决策

Tree Split for 1 and level 0.5143677890300751

第3次决策

Tree Split for 0 and level -0.6523728966712952

第4次决策

Tree Split for 0 and level 0.3370491564273834

第5次决策

Tree Split for 0 and level 0.3370491564273834

第6次决策

Tree Split for 1 and level 0.022058885544538498

第7次决策

Tree Split for 0 and level -0.3030575215816498

第8次决策

Tree Split for 0 and level 0.6119407713413239

第9次决策

可以看到通过9次的计算，基本上已经把上面的分类进行了区分

我们这里的学习器都是非常简单的决策树，只沿着一个特征分裂!但整体模型在每次决策后边的越来越复杂，并且整体误差逐渐减小。

plt.plot(rmses)

这也就是上图中我们看到的能够正确区分出了大部分的分类

如果你感兴趣可以使用下面代码自行实验：

​​https://www.php.cn/link/bfc89c3ee67d881255f8b097c4ed2d67​​

Atas ialah kandungan terperinci Visualisasi langkah demi langkah proses membuat keputusan bagi algoritma penggalak kecerunan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!