Penjelasan terperinci tentang algoritma keturunan kecerunan dalam Python

Keturunan kecerunan ialah algoritma pengoptimuman yang biasa digunakan dan digunakan secara meluas dalam pembelajaran mesin. Python ialah bahasa pengaturcaraan yang hebat untuk sains data, dan terdapat banyak perpustakaan siap sedia untuk melaksanakan algoritma penurunan kecerunan. Artikel ini akan memperkenalkan algoritma keturunan kecerunan dalam Python secara terperinci, termasuk konsep dan pelaksanaan.

1. Definisi keturunan kecerunan
Keturunan kecerunan ialah algoritma berulang yang digunakan untuk mengoptimumkan parameter fungsi. Dalam pembelajaran mesin, kami biasanya menggunakan keturunan kecerunan untuk meminimumkan fungsi kehilangan. Oleh itu, keturunan kecerunan boleh dianggap sebagai kaedah meminimumkan fungsi. Algoritma keturunan kecerunan boleh digunakan dalam mana-mana sistem di mana kecerunan boleh dikira, termasuk regresi linear, regresi logistik, rangkaian saraf dan banyak lagi.

2. Prinsip keturunan kecerunan
Prinsip asas algoritma keturunan kecerunan ialah mencari nilai minimum bagi sesuatu fungsi. Kita biasanya menganggap nilai minimum fungsi sebagai nilai minimum dalam fungsi parameter fungsi (parameter merujuk kepada pembolehubah yang perlu kita optimumkan Oleh itu, kita perlu mengira derivatif fungsi parameter). Kami menggunakan derivatif untuk menentukan cerun semasa fungsi dan mendarabkannya dengan kadar pembelajaran untuk menentukan arah mana yang perlu kami tuju seterusnya. Apabila terbitan bagi suatu fungsi ialah sifar, kami telah menemui nilai minimum bagi fungsi tersebut. Dalam aplikasi praktikal, kami tidak perlu menjamin bahawa minimum global fungsi boleh ditemui, kami hanya perlu mencari minimum tempatannya.

3. Langkah algoritma penurunan kecerunan
1. Kita perlu menetapkan parameter yang diperlukan untuk fungsi pengoptimuman kepada nilai awal, sebagai contoh, tetapkan parameter kepada sifar atau nombor rawak.
2. Kira fungsi kerugian. Mengira fungsi kehilangan menggunakan parameter yang diberikan.
3. Kira kecerunan. Kira kecerunan fungsi kehilangan. Kecerunan menunjukkan cerun fungsi di bawah parameter semasa.
4. Kemas kini parameter. Kemas kini parameter berdasarkan kecerunan. Parameter yang dikemas kini akan membawa fungsi kehilangan lebih dekat kepada penyelesaian optimum.
5. Ulang langkah 2 hingga 4 sehingga syarat berhenti dipenuhi. Keadaan berhenti boleh mencapai bilangan lelaran tertentu atau mencapai tahap pengoptimuman tertentu.

4. Python melaksanakan keturunan kecerunan (keturunan kecerunan kelompok)
Seterusnya, kami akan memperkenalkan cara untuk melaksanakan algoritma keturunan kecerunan kelompok dalam Python Algoritma keturunan kecerunan kelompok ialah satu bentuk algoritma keturunan kecerunan, dan Andaikan kita mempunyai ingatan yang mencukupi untuk memproses semua sampel latihan sekaligus.

Penyediaan data
Kami menggunakan set data sklearn terbina dalam set data IRIS sebagai data sampel untuk pelaksanaan turunan kecerunan kelompok kami. Berikut ialah pakej Python yang perlu kami gunakan dan kod untuk mengimport set data:

from sklearn.datasets import load_iris
import numpy as np

iris = load_iris()
X = iris.data
y = iris.target

Prapemprosesan data
Sebelum melakukan penurunan kecerunan kelompok, kami perlu menormalkan data kami. Ini boleh dilakukan dengan mengira min dan sisihan piawai bagi setiap ciri.

mean = np.mean(X,axis=0)
std = np.std(X,axis=0)
X = (X - mean)/std

Tentukan fungsi kehilangan
Kami akan menggunakan fungsi ralat kuasa dua sebagai fungsi kehilangan model. Fungsi kehilangan kami ialah:

def loss_function(X,y,theta):
    m = len(y)
    predictions = np.dot(X,theta)
    cost = (1/(2*m)) * np.sum((predictions-y)**2)
    return cost

Tentukan fungsi latihan
Seterusnya kami mentakrifkan fungsi untuk melaksanakan algoritma penurunan kecerunan kelompok.

def gradient_descent(X,y,theta,learning_rate,num_iterations):
    m = len(y)
    cost_history = np.zeros(num_iterations)
    theta_history = np.zeros((num_iterations,theta.shape[0]))
    for i in range(num_iterations):
        prediction = np.dot(X,theta)
        theta = theta - (1/m)*learning_rate*(X.T.dot((prediction - y)))
        theta_history[i,:] = theta.T
        cost_history[i]  = loss_function(X,y,theta)
        
    return theta, cost_history, theta_history

Jalankan fungsi latihan
Kami kini menjalankan fungsi latihan model dan mengeluarkan kos dan nilai parameter model akhir, dan kemudian menyesuaikan data latihan dengan model.

theta = np.zeros(X.shape[1])
learning_rate = 0.1
num_iterations = 1000
theta,cost_history,theta_history = gradient_descent(X,y,theta,learning_rate,num_iterations)

print('Theta: ',theta)
print('Final cost/MSE: ',cost_history[-1])

5. Ringkasan
Dalam artikel ini, kami menerangkan algoritma penurunan kecerunan dalam Python, termasuk konsep dan pelaksanaan. Kami mula-mula memperkenalkan definisi dan prinsip algoritma keturunan kecerunan, dan kemudian menerangkan langkah-langkah algoritma keturunan kecerunan secara terperinci. Akhir sekali, kami melaksanakan penurunan kecerunan kelompok dan menjalankan set data sampel untuk mendapatkan model terlatih dan kosnya.

Algoritma keturunan kecerunan ialah titik pengetahuan penting dalam pembelajaran mesin, dan Python ialah salah satu bahasa pengaturcaraan yang paling banyak digunakan dalam sains data, jadi adalah sangat penting untuk mempelajari algoritma keturunan kecerunan dalam Python. Saya harap artikel ini berguna untuk anda mempelajari algoritma penurunan kecerunan dalam Python.

Atas ialah kandungan terperinci Penjelasan terperinci tentang algoritma keturunan kecerunan dalam Python. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!