Ricerca nel sito web

Come implementare una discesa del gradiente in Python per trovare un minimo locale?

La discesa del gradiente è un approccio di ottimizzazione importante nel machine learning per ridurre al minimo la funzione di perdita di un modello. In parole povere, ciò comporta la modifica ripetuta dei parametri del modello fino a quando non viene scoperto l'intervallo di valori ideale che minimizza la funzione di perdita. Il metodo opera facendo piccoli passi nella direzione del gradiente negativo della funzione di perdita o, più specificamente, nel percorso di discesa più ripida. Il tasso di apprendimento, un iperparametro che regola il compromesso dell'algoritmo tra velocità e precisione, influisce sulla dimensione dei passaggi. Molti metodi di apprendimento automatico, tra cui la regressione lineare, la regressione logistica e le reti neurali, per citarne alcuni, utilizzano la discesa del gradiente. La sua applicazione principale è nell'addestramento del modello, dove l'obiettivo è ridurre al minimo la differenza tra i valori previsti e quelli effettivi della variabile target. In questo post esamineremo l'implementazione di una discesa del gradiente in Python per trovare un minimo locale.

Ora è il momento di implementare la discesa del gradiente in Python. Di seguito sono riportate le istruzioni di base su come lo implementeremo −

  • Per prima cosa importiamo le librerie necessarie.

  • Definizione delle funzioni e sua derivata.

  • Successivamente, applicheremo la funzione di discesa del gradiente.

  • Dopo aver applicato la funzione, imposteremo i parametri per trovare i minimi locali,

  • Infine, tracceremo il grafico dell'output.

Implementazione della discesa del gradiente in Python

Importazione di librerie

import numpy as np
import matplotlib.pyplot as plt

Definiamo quindi la funzione f(x) e la sua derivata f'(x) −

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

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

F(x) è la funzione da diminuire e df è la sua derivata (x). L'approccio della discesa del gradiente utilizza la derivata per guidarsi verso il minimo rivelando la pendenza della funzione lungo il percorso.

Viene quindi definita la funzione di discesa del gradiente.

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

Il valore iniziale di x, la velocità di apprendimento e il numero desiderato di iterazioni vengono inviati alla funzione di discesa del gradiente. Per salvare i valori di x dopo ogni iterazione, inizializza x al suo valore originale e genera un elenco vuoto. Il metodo esegue quindi la discesa del gradiente per il numero di iterazioni fornito, modificando x ogni iterazione in base all'equazione x=x - tasso di apprendimento * gradiente. La funzione produce un elenco dei valori x di ogni iterazione insieme al valore finale di x.

La funzione di discesa del gradiente può ora essere utilizzata per individuare il minimo locale di f(x) −

Esempio

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))

Produzione

Local minimum: 2.00

In questa illustrazione, x è impostato su 0 all'inizio, con una velocità di apprendimento di 0,1 e vengono eseguite 50 iterazioni. Infine pubblichiamo il valore di x, che dovrebbe essere vicino al minimo locale in x=2.

Tracciare la funzione f(x) e i valori di x per ogni iterazione ci permette di vedere il processo di discesa del gradiente in azione −

Esempio

# 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()

Produzione

Conclusione

In conclusione, per trovare il minimo locale di una funzione, Python utilizza l'effettivo processo di ottimizzazione noto come discesa del gradiente. La discesa del gradiente aggiorna ripetutamente il valore di input nella direzione della caduta più ripida finché non raggiunge il valore più basso calcolando la derivata della funzione ad ogni passaggio. L'implementazione della discesa del gradiente in Python implica specificare la funzione da ottimizzare e la sua derivata, inizializzare il valore di input e determinare la velocità di apprendimento dell'algoritmo e il numero di iterazioni. Una volta terminata l'ottimizzazione, è possibile valutare il metodo ripercorrendo i suoi passi al minimo e vedendo come lo ha raggiunto. La discesa del gradiente può essere una tecnica utile nelle applicazioni di machine learning e ottimizzazione poiché Python può gestire grandi set di dati e funzioni sofisticate.

Articoli correlati: