Bagaimana untuk melaksanakan algoritma keturunan kecerunan dalam Python untuk mencari minima tempatan?

Keturunan kecerunan ialah kaedah pengoptimuman penting dalam pembelajaran mesin, digunakan untuk meminimumkan fungsi kehilangan model. Dalam istilah awam, ia memerlukan berulang kali menukar parameter model sehingga julat nilai ideal yang meminimumkan fungsi kehilangan ditemui. Kaedah ini berfungsi dengan mengambil langkah-langkah kecil ke arah kecerunan negatif fungsi kehilangan, atau lebih khusus, di sepanjang laluan keturunan paling curam. Kadar pembelajaran ialah hiperparameter yang mengawal pertukaran antara kelajuan dan ketepatan algoritma, dan ia mempengaruhi saiz saiz langkah. Banyak kaedah pembelajaran mesin, termasuk regresi linear, regresi logistik dan rangkaian saraf, untuk menamakan beberapa, menggunakan keturunan kecerunan. Aplikasi utamanya ialah latihan model, di mana matlamatnya adalah untuk meminimumkan perbezaan antara nilai jangkaan dan sebenar pembolehubah sasaran. Dalam artikel ini, kita akan melihat pelaksanaan turunan kecerunan dalam Python untuk mencari minima setempat.

Kini tiba masanya untuk melaksanakan keturunan kecerunan dalam Python. Berikut ialah penjelasan asas tentang cara kami melaksanakannya -

• Pertama, kami mengimport perpustakaan yang diperlukan.

• Tentukan fungsinya dan derivatifnya.

• Seterusnya, kami akan menggunakan fungsi penurunan kecerunan.

• Selepas menggunakan fungsi, kami akan menetapkan parameter untuk mencari minimum setempat,

• Akhir sekali, kami akan merancang output.

Melaksanakan Gradient Descent dalam Python

Import perpustakaan

import numpy as np
import matplotlib.pyplot as plt

Kemudian kita takrifkan fungsi f(x) dan terbitannya f'(x) -

def f(x):
   return x**2 - 4*x + 6

def df(x):
   return 2*x - 4

F(x) ialah fungsi yang mesti dikurangkan dan df ialah terbitannya (x). Kaedah penurunan kecerunan menggunakan derivatif untuk membimbing dirinya ke arah minimum dengan mendedahkan kecerunan fungsi di sepanjang jalan.

Kemudian tentukan fungsi penurunan kecerunan.

def gradient_descent(initial_x, learning_rate, num_iterations):
   x = initial_x
   x_history = [x]
  
   for i in range(num_iterations):
       gradient = df(x)
       x = x - learning_rate * gradient
       x_history.append(x)
      
   return x, x_history

Nilai permulaan

x, kadar pembelajaran dan bilangan lelaran yang diperlukan dihantar ke fungsi penurunan kecerunan. Untuk menyimpan nilai x selepas setiap lelaran, ia memulakan x kepada nilai asalnya dan menjana senarai kosong. Kaedah kemudiannya melakukan penurunan kecerunan untuk bilangan lelaran yang disediakan, menukar x dalam setiap lelaran mengikut persamaan x = x - kadar pembelajaran * kecerunan. Fungsi ini menjana senarai nilai x untuk setiap lelaran dan nilai akhir x.

Fungsi penurunan kecerunan kini boleh digunakan untuk mencari minimum setempat f(x) -

Contoh

initial_x = 0
learning_rate = 0.1
num_iterations = 50

x, x_history = gradient_descent(initial_x, learning_rate, num_iterations)

print("Local minimum: {:.2f}".format(x))

Output

Local minimum: 2.00

Dalam angka ini, x pada mulanya ditetapkan kepada 0, kadar pembelajaran ialah 0.1, dan 50 lelaran dijalankan. Akhir sekali, kami menerbitkan nilai x, yang sepatutnya hampir dengan minimum tempatan pada x=2.

Memplot fungsi f(x) dan nilai x untuk setiap lelaran membolehkan kita melihat proses penurunan kecerunan dalam tindakan -

Contoh

# Create a range of x values to plot
x_vals = np.linspace(-1, 5, 100)

# Plot the function f(x)
plt.plot(x_vals, f(x_vals))

# Plot the values of x at each iteration
plt.plot(x_history, f(np.array(x_history)), 'rx')

# Label the axes and add a title
plt.xlabel('x')
plt.ylabel('f(x)')
plt.title('Gradient Descent')

# Show the plot
plt.show()

Output

Kesimpulan

Ringkasnya, untuk mencari minimum setempat bagi sesuatu fungsi, Python menggunakan proses pengoptimuman yang cekap yang dipanggil keturunan kecerunan. Keturunan kecerunan berfungsi dengan mengira derivatif fungsi pada setiap langkah, mengemas kini nilai input berulang kali ke arah penurunan paling curam sehingga nilai terendah dicapai. Melaksanakan keturunan kecerunan dalam Python memerlukan menentukan fungsi yang akan dioptimumkan dan terbitannya, memulakan nilai input dan menentukan kadar pembelajaran dan bilangan lelaran algoritma. Selepas pengoptimuman selesai, kaedah boleh dinilai dengan menjejaki langkahnya ke tahap minimum dan melihat cara ia mencapai matlamat tersebut. Keturunan kecerunan ialah teknik yang berguna dalam pembelajaran mesin dan aplikasi pengoptimuman kerana Python boleh mengendalikan set data yang besar dan fungsi yang kompleks.

Atas ialah kandungan terperinci Bagaimana untuk melaksanakan algoritma keturunan kecerunan dalam Python untuk mencari minima tempatan?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!