La discesa del gradiente in Python

La discesa del gradiente è un algoritmo che ci aiuta a trovare l'errore minimo o dove il valore della perdita è inferiore. Scegliamo qualsiasi punto sulla funzione e quindi ci spostiamo lentamente verso la direzione negativa in modo da poter ottenere l'errore minimo. Ma mentre ci muoviamo, ci preoccupiamo anche del valore di errore, che è il valore che viene sottratto dalla previsione e dal valore della verità. Inoltre, non dovrebbe diventare negativo.

Possiamo capirlo meglio dal seguente esempio:

Supponiamo che una macchina converti i chilometri in miglia.

Ma non abbiamo la formula per convertire i chilometri in miglia. Sappiamo che entrambi i valori sono lineari, il che significa che se raddoppiamo le miglia, quindi anche i chilometri.

La formula è presentata in questo modo:

Miglia = chilometri * c

Qui, C è una costante e non conosciamo il valore esatto della costante.

Abbiamo un valore di verità universale come indizio. La tabella della verità è riportata di seguito:

Ora useremo un valore casuale di C e determineremo il risultato.

Quindi, stiamo usando il valore di C come 0.5 e il valore dei chilometri è 100. Questo ci dà 50 come risposta. Come sappiamo molto bene, secondo la tabella della verità, il valore dovrebbe essere 62.137. Quindi l'errore che dobbiamo scoprire come di seguito:

errore = verità - calcolato

= 62.137 - 50

= 12.137

Allo stesso modo, possiamo vedere il risultato nell'immagine seguente:

Ora abbiamo un errore di 12.137. Come precedentemente discusso, il rapporto tra miglia e chilometri è lineare. Quindi, se aumentiamo il valore della costante casuale C, potremmo ricevere meno errori.

Questa volta, cambiamo il valore di C da 0.5 a 0.6 e raggiungere il valore di errore di 2.137, come mostrato nell'immagine qui sotto:

Ora, il nostro tasso di errore migliora da 12.317 a 2.137. Possiamo ancora migliorare l'errore usando più ipotesi sul valore di C. Supponiamo che il valore di C sarà 0.6 a 0.7 e abbiamo raggiunto l'errore di output di -7.863.

Questa volta l'errore attraversa la tabella della verità e il valore effettivo. Quindi, attraversiamo l'errore minimo. Quindi, dall'errore, possiamo dire che il nostro risultato di 0.6 (errore = 2.137) era meglio di 0.7 (errore = -7.863).

Perché non abbiamo provato con i piccoli cambiamenti o il tasso di apprendimento del valore costante di C? Cambieremo il valore c da 0.6 a 0.61, non 0.7.

Il valore di c = 0.61, ci dà un errore minore di 1.137 che è meglio dello 0.6 (errore = 2.137).

Ora abbiamo il valore di C, che è 0.61 e dà un errore di 1.137 solo dal valore corretto di 62.137.

Questo è l'algoritmo di discesa gradiente che aiuta a scoprire l'errore minimo.

Codice Python:

Convertiamo lo scenario sopra in programmazione Python. Inizializziamo tutte le variabili di cui abbiamo bisogno per questo programma Python. Definiamo anche il metodo kilo_mile, in cui passiamo un parametro C (costante).

Nel codice seguente, definiamo solo le condizioni di arresto e la massima iterazione. Come accennato, il codice si fermerà o quando è stata raggiunta l'iterazione massima o il valore di errore maggiore della precisione. Di conseguenza, il valore costante raggiunge automaticamente il valore di 0.6213, che ha un errore minore. Quindi la nostra discesa per gradiente funzionerà anche in questo modo.

Discesa gradiente in Python

Importiamo i pacchetti richiesti e insieme ai set di dati integrati Sklearn. Quindi impostiamo il tasso di apprendimento e diverse iterazioni come mostrato di seguito nell'immagine:

Abbiamo mostrato la funzione sigmoide nell'immagine sopra. Ora, lo convertiamo in una forma matematica, come mostrato nell'immagine seguente. Importiamo anche il set di dati integrato Sklearn, che ha due funzionalità e due centri.

Ora, possiamo vedere i valori di X e forma. La forma mostra che il numero totale di righe è 1000 e le due colonne come impostato prima.

Aggiungiamo una colonna alla fine di ogni riga X per utilizzare la distorsione come valore addestrabile, come mostrato di seguito. Ora, la forma di X è di 1000 righe e tre colonne.

Rimodiamo anche la Y, e ora ha 1000 righe e una colonna come mostrato di seguito:

Definiamo la matrice di peso anche con l'aiuto della forma della X come mostrato di seguito:

Ora, abbiamo creato il derivato del sigmoide e abbiamo ipotizzato che il valore di X sarebbe stato dopo aver attraversato la funzione di attivazione del sigmoide, che abbiamo mostrato prima.

Quindi ci avviciniamo fino al numero di iterazioni che abbiamo già impostato è stato raggiunto. Scopriamo le previsioni dopo aver attraversato le funzioni di attivazione del sigmoideo. Calcoliamo l'errore e calcoliamo il gradiente per aggiornare i pesi come mostrato di seguito nel codice. Salviamo anche la perdita su ogni epoca nell'elenco della cronologia per visualizzare il grafico delle perdite.

Ora possiamo vederli ad ogni epoca. L'errore sta diminuendo.

Ora, possiamo vedere che il valore dell'errore sta riducendo continuamente. Quindi questo è un algoritmo di discesa a gradiente.