Regularisasi

Mar 01 2023

Regularisasi adalah teknik luas yang digunakan dalam banyak model pembelajaran mesin untuk mengontrol kompleksitas model dan dengan demikian meningkatkan kemampuan generalisasinya. Pada artikel ini saya akan menjelaskan konsep regularisasi secara mendalam, dan mendemonstrasikan penggunaannya dalam beberapa model pembelajaran mesin.

Regularisasi adalah teknik luas yang digunakan dalam banyak model pembelajaran mesin untuk mengontrol kompleksitas model dan dengan demikian meningkatkan kemampuan generalisasinya.

Pada artikel ini saya akan menjelaskan konsep regularisasi secara mendalam, dan mendemonstrasikan penggunaannya dalam beberapa model pembelajaran mesin.

Apa itu Regularisasi?

Regularisasi adalah teknik untuk mencegah overfitting dengan menghukum model yang kompleks. Idenya adalah menambahkan istilah penalti ke fungsi biaya model, sehingga menjadi tergantung pada dua faktor:

Biaya( h ) = Kesalahan Pelatihan( h ) + λ Kompleksitas( h )

λ adalah hyperparameter (disebut koefisien regularisasi ) yang mengontrol tradeoff antara bias dan varians (untuk diskusi tentang tradeoff bias-varians lihat artikel saya sebelumnya ). λ yang lebih tinggi akan menyebabkan penalti yang lebih besar pada kompleksitas model, dan dengan demikian akan menghasilkan model yang lebih sederhana dengan kesalahan yang lebih tinggi pada set pelatihan tetapi dengan varians yang lebih kecil.

Kompleksitas model dapat diukur dengan berbagai cara. Misalnya, dalam model yang terdiri dari vektor parameter (bobot) w , seperti regresi linier atau jaringan saraf, kami menggunakan ukuran parameter (norma vektor w ) sebagai ukuran kompleksitas model.

Dalam model seperti itu, ada dua jenis regularisasi yang umum, bergantung pada norma vektor w yang kita gunakan:

regularisasi L1 . Dalam hal ini, kami menggunakan norma L1 dari vektor w , yaitu jumlah nilai absolut dari bobot.
Misalnya, dalam regresi linier, jika kita memiliki m fitur dalam kumpulan data kita, maka model tersebut akan memiliki m parameter (bobot) ditambah istilah bias, sehingga kita dapat menulis norma L1 dari w sebagai:
|| w ||₁ = |w₀| + |w₁| + … + |w ₘ |
regularisasi L2 . Dalam hal ini, kami menggunakan norma L2 dari vektor w (kuadrat ) , yaitu jumlah kuadrat dari bobot:
|| w ||₂² = w₀² + w₁² + … + w ₘ ²

Regresi Punggungan

Ketika regularisasi L2 diterapkan pada regresi linier, kami menyebut model ini sebagai regresi ridge .

Sebagai pengingat, dalam regresi linier, kita diberikan sekumpulan titik latihan D = {( x ₁, y ₁), ( x ₂, y ₂), … , ( x ₙ, yₙ )}, di mana x ᵢ mewakili fitur titik i dan yᵢ merepresentasikan label titik tersebut. x ᵢ adalah vektor yang terdiri dari m fitur, yaitu x ᵢ = ( xᵢ ₁, xᵢ ₂, …, xᵢₘ ).

Tujuan kami adalah untuk menemukan garis (atau hyperplane) yang berjalan sedekat mungkin melalui semua titik data, atau dengan kata lain fungsi yang coba dipelajari oleh model kami (disebut hipotesis model ) adalah:

Kami ingin prediksi model sedekat mungkin dengan label sebenarnya dari titik-titik tersebut, atau dengan kata lain, kami ingin meminimalkan kerugian kuadrat terkecil :

Dalam regresi ridge, kita menambahkan fungsi biaya suatu suku penalti yang bergantung pada norma L2 dari vektor bobot:

Di Scikit-Learn, Anda dapat menggunakan kelas Ridge untuk melakukan regresi ridge, yaitu untuk menemukan bobot yang meminimalkan fungsi biaya di atas. Secara default, λ (yang disebut alpha di Scikit-Learn) diatur ke 1.0, tetapi Anda dapat mengubah nilainya di konstruktor kelas.

Sebagai contoh, mari kita periksa apa yang terjadi ketika kita mencoba menyesuaikan polinomial dengan kumpulan titik tertentu menggunakan regresi ridge. Asumsikan bahwa set pelatihan kami terdiri dari 50 titik data yang diambil sampelnya dari fungsi f ( x ) = sin ( x ) dalam interval [0, 10] dengan beberapa noise acak.

Kode Python berikut menghasilkan titik-titik ini dan memplotnya:

def make_data(n=50):
    rng = np.random.RandomState(0)
    X = rng.rand(n, 1) * 10
    err = rng.normal(size=n) * 0.3
    y = np.sin(X).ravel() + err
    return X, y

def plot_data(X, y):
    plt.scatter(X, y, color='k')
    plt.xlabel('$x$')
    plt.ylabel('$y$')

X, y = make_data()
plot_data(X, y)

      
                
                    
                    
       The given data points

Kami pertama-tama mendefinisikan model kami sebagai pipa yang terdiri dari 3 langkah:

Transformator StandardScaler yang menormalkan data. Saat menggunakan regularisasi, penting untuk menormalkan data Anda, karena kami menerapkan koefisien regularisasi λ yang sama untuk semua fitur.
Transformator Fitur Polinomial yang menambahkan fitur polinomial dengan derajat kurang dari atau sama dengan 10 ke kumpulan data kami.
Regresi Ridge itu sendiri.

from sklearn.preprocessing import PolynomialFeatures, StandardScaler
from sklearn.linear_model import Ridge
from sklearn.pipeline import Pipeline

def RidgePolynomialRegression(degree=10, alpha=1):
    return Pipeline([('scaler', StandardScaler()),
                     ('polyfeatures', PolynomialFeatures(degree)),
                     ('ridge', Ridge(alpha))])

X_test = np.linspace(0, 10, 100).reshape(-1, 1)
fig, axes = plt.subplots(2, 5, figsize=(10, 4))
plt.subplots_adjust(hspace=0.5)
alpha = 0.00001

for ax in axes.flat:
    reg = RidgePolynomialRegression(alpha=alpha)
    reg.fit(X, y)
    y_test = reg.predict(X_test)
    ax.plot(X_test, y_test, color='r')
    ax.set_title(f'$\lambda = ${alpha}')
    ax.scatter(X, y, color='k', s=5)
    alpha *= 10

Regresi punggungan

Jika kita memeriksa apa yang terjadi pada bobot saat kita meningkatkan λ , kita dapat melihat bahwa bobot menjadi semakin kecil:

alpha = 0.00001
for i in range(10):
    reg = RidgePolynomialRegression(degree=10, alpha=alpha)
    reg.fit(X, y)
    coef = reg.named_steps['ridge'].coef_[1:]
    print(coef)
    alpha *= 10
[-0.34255958  4.65041874  1.52936947 -4.40599301 -1.90098186  2.23311211
  0.88066028 -0.67051191 -0.1365452   0.08475464]
[-0.33965761  4.63580242  1.51570516 -4.36588145 -1.88217563  2.19393547
  0.87079965 -0.65469155 -0.13481568  0.08249219]
[-0.31363162  4.50439571  1.39332345 -4.00624119 -1.71391192  1.84322694
  0.78264629 -0.51321344 -0.11936373  0.06227446]
[-0.19071657  3.87021122  0.82356155 -2.31939344 -0.9393007   0.22556941
  0.38056787  0.13218128 -0.04939819 -0.02922885]
[-0.04619268  3.00037721  0.25566347 -0.6695211  -0.28744623 -0.98332127
  0.09608197  0.51757036 -0.00745002 -0.07428806]
[ 0.04317733  1.66557129 -0.03687544  0.17571591 -0.11153223 -0.41803515
  0.12726457 -0.02719409 -0.03157695  0.03059514]
[ 0.0125075   0.60775006  0.01115537  0.34194187 -0.01115688  0.0516252
 -0.02478579 -0.1976274   0.01210612  0.03770911]
[-0.00213858  0.13360357 -0.00969971  0.11558718 -0.02610679  0.0725844
 -0.03817568  0.00108649  0.0228815  -0.01947446]
[-0.00410878  0.02199911 -0.0053407   0.02588268 -0.00708055  0.02730288
 -0.00661614  0.02012954  0.00397905 -0.01315045]
[-0.00054706  0.00266053 -0.00068137  0.00342859 -0.00092493  0.00400394
 -0.00119852  0.00334012 -0.00161305 -0.00245165]

from sklearn.model_selection import GridSearchCV

param_grid = {
    'polyfeatures__degree': np.arange(1, 11),
    'ridge__alpha': np.logspace(-5, 4, num=10)
}

grid = GridSearchCV(RidgePolynomialRegression(), param_grid, n_jobs=-1)
grid.fit(X, y)

print(grid.best_params_)

{'polyfeatures__degree': 8, 'ridge__alpha': 0.01}

Regresi Lasso

Regresi laso sangat mirip dengan regresi ridge, kecuali bahwa kami menggunakan regularisasi L1, bukan regularisasi L2. Oleh karena itu, fungsi biaya memiliki bentuk sebagai berikut:

Secara umum, regularisasi L1 merupakan bentuk regularisasi yang lebih kuat daripada L2,

Mari jalankan regresi Lasso alih-alih regresi Ridge pada kumpulan data yang sama yang dijelaskan sebelumnya. Yang perlu kita lakukan adalah mengganti kelas Ridge dengan kelas Lasso di saluran kami:

from sklearn.preprocessing import PolynomialFeatures, StandardScaler
from sklearn.linear_model import Lasso
from sklearn.pipeline import Pipeline

def LassoPolynomialRegression(degree=10, alpha=1):
    return Pipeline([('scaler', StandardScaler()),
                     ('polyfeatures', PolynomialFeatures(degree)),
                     ('lasso', Lasso(alpha))])

X_test = np.linspace(0, 10, 100).reshape(-1, 1)
fig, axes = plt.subplots(2, 5, figsize=(10, 4))
plt.subplots_adjust(hspace=0.5)
alpha = 0.00001

for ax in axes.flat:
    reg = LassoPolynomialRegression(alpha=alpha)
    reg.fit(X, y)
    y_test = reg.predict(X_test)
    ax.plot(X_test, y_test, color='r')
    ax.set_title(f'$\lambda = ${alpha}')
    ax.scatter(X, y, color='k', s=5)
    alpha *= 10

Regresi laso

Kita dapat dengan jelas melihat bahwa regularisasi memiliki efek yang jauh lebih kuat pada model daripada regresi ridge.

Mari kita periksa apa yang terjadi pada bobot model saat kita meningkatkan λ :

alpha = 0.00001
for i in range(10):
    reg = LassoPolynomialRegression(degree=10, alpha=alpha)
    reg.fit(X, y)
    coef = reg.named_steps['lasso'].coef_[1:]
    print(coef)
    alpha *= 10
[ 1.46823703e+00  2.63999643e+00 -1.16846632e+00 -1.37767850e+00
  1.91631342e-02  1.35144644e-01  4.17104620e-02  2.77956760e-02
  6.25525954e-03 -1.33167094e-03]
[ 1.46587728e+00  2.62935208e+00 -1.16566855e+00 -1.36644025e+00
  1.95947992e-02  1.32103252e-01  4.09351664e-02  2.76081239e-02
  6.36955259e-03 -1.23628815e-03]
[ 1.44081438e+00  2.52202831e+00 -1.13306732e+00 -1.25259396e+00
  2.06435112e-02  1.00689833e-01  3.37898859e-02  2.59250307e-02
  7.53377577e-03 -2.70373324e-04]
[ 1.19046738e+00  1.52316023e+00 -8.09126923e-01 -2.99714326e-01
 -0.00000000e+00 -1.09742383e-01 -0.00000000e+00  2.25379843e-04
  9.26904439e-03  6.37664693e-03]
[ 2.33325641e-01  3.68424685e-01  0.00000000e+00  0.00000000e+00
 -0.00000000e+00  2.20183217e-02 -4.03913628e-02  0.00000000e+00
 -3.60328411e-04 -8.72522225e-03]
[ 0.          0.         -0.          0.         -0.          0.
 -0.          0.         -0.00310639 -0.00095184]
[-0.00000000e+00  0.00000000e+00 -0.00000000e+00  0.00000000e+00
 -0.00000000e+00  0.00000000e+00 -0.00000000e+00  0.00000000e+00
 -0.00000000e+00  1.20777566e-05]
[-0.  0. -0.  0. -0.  0. -0.  0. -0.  0.]
[-0.  0. -0.  0. -0.  0. -0.  0. -0.  0.]
[-0.  0. -0.  0. -0.  0. -0.  0. -0.  0.]

Regresi Elastis-Bersih

Jaring elastis adalah regresi jalan tengah antara regresi ridge dan laso. Ini menggabungkan penalti L1 dan L2 menggunakan parameter pencampuran yang dilambangkan dengan r (0 ≤ r ≤ 1):

Saat r = 0, Elastic-Net menjadi sama dengan regresi ridge, dan saat r = 1, Elastic-Net menjadi sama dengan regresi laso.

Di Scikit-Learn, Anda dapat menggunakan kelas ElasticNet untuk melakukan regresi jaringan elastis. Konstruktornya mengambil dua parameter: alpha yang mewakili koefisien regularisasi λ (secara default diatur ke 1.0), dan l1_ratio yang mewakili parameter pencampuran r (secara default diatur ke 0.5).

Mari kita periksa apa yang terjadi ketika kita menjalankan Elastic-Net dengan λ = 1.0, dan berbagai nilai r (l1_ratio) pada kumpulan data yang sama:

Regresi Elastis-Net

Seperti dapat dilihat, peningkatan r menginduksi regularisasi yang lebih kuat pada model, hingga menjadi hampir rata.

Catatan Akhir

Anda dapat menemukan semua contoh kode yang disebutkan dalam artikel ini di repositori github saya:https://github.com/roiyeho/medium/tree/main/regularization