Cerco di capire il ruolo della derivata della funzione sigmoidea nelle reti neurali.

Per prima cosa ho tracciato la funzione sigmoide e la derivata di tutti i punti dalla definizione usando Python. Qual è esattamente il ruolo di questo derivato?

import numpy as np
import matplotlib.pyplot as plt

def sigmoid(x):
    return 1 / (1 + np.exp(-x))

def derivative(x, step):
    return (sigmoid(x+step) - sigmoid(x)) / step

x = np.linspace(-10, 10, 1000)

y1 = sigmoid(x)
y2 = derivative(x, 0.0000000000001)

plt.plot(x, y1, label='sigmoid')
plt.plot(x, y2, label='derivative')
plt.legend(loc='upper left')
plt.show()

L'uso di derivati ​​nelle reti neurali è per il processo di addestramento chiamato backpropagation . Questa tecnica utilizza la discesa gradiente per trovare un set ottimale di parametri del modello al fine di minimizzare una funzione di perdita. Nel tuo esempio devi usare la derivata di un sigmoide perché è l'attivazione che usano i tuoi singoli neuroni.

La funzione di perdita

L'essenza dell'apprendimento automatico è l'ottimizzazione di una funzione di costo in modo tale che possiamo minimizzare o massimizzare alcune funzioni target. Questo è in genere chiamato la funzione di perdita o costo. In genere vogliamo ridurre al minimo questa funzione. La funzione di costo, , associa una certa penalità in base agli errori risultanti quando si passano i dati attraverso il modello in funzione dei parametri del modello.$C$

Diamo un'occhiata all'esempio in cui proviamo ad etichettare se un'immagine contiene un gatto o un cane. Se abbiamo un modello perfetto, possiamo dare una foto al modello e ci dirà se è un gatto o un cane. Tuttavia, nessun modello è perfetto e farà errori.

Quando formiamo il nostro modello per poter inferire il significato dai dati di input, vogliamo ridurre al minimo la quantità di errori che commette. Quindi usiamo un set di addestramento, questi dati contengono molte immagini di cani e gatti e abbiamo l'etichetta di verità di base associata a quell'immagine. Ogni volta che eseguiamo un'iterazione di addestramento del modello calcoliamo il costo (la quantità di errori) del modello. Vorremmo ridurre al minimo questo costo.

Esistono molte funzioni di costo ognuna con il proprio scopo. Una funzione di costo comune utilizzata è il costo quadratico definito come

.$C = \frac{1}{N} \sum_{i=0}^{N}(\hat{y} - y)^2$

Questo è il quadrato della differenza tra l'etichetta prevista e l'etichetta di verità di base per le immagini cui ci siamo allenati. Vorremmo minimizzare questo in qualche modo.$N$

Ridurre al minimo una funzione di perdita

In effetti, la maggior parte dell'apprendimento automatico è semplicemente una famiglia di framework in grado di determinare una distribuzione minimizzando alcune funzioni di costo. La domanda che possiamo porre è "come possiamo minimizzare una funzione"?

Riduciamo al minimo la seguente funzione

.$y = x^2-4x+6$

Se tracciamo questo, possiamo vedere che esiste un minimo in . Per fare questo analiticamente possiamo prendere la derivata di questa funzione come$x = 2$

$\frac{dy}{dx} = 2x - 4 = 0$

.$x = 2$

Tuttavia, spesso non è possibile trovare analiticamente un minimo globale. Quindi invece utilizziamo alcune tecniche di ottimizzazione. Qui esistono anche molti modi diversi come: Newton-Raphson, ricerca della griglia, ecc. Tra questi c'è la discesa del gradiente . Questa è la tecnica utilizzata dalle reti neurali.

Discesa a gradiente

Usiamo un'analogia notoriamente usata per capirlo. Immagina un problema di minimizzazione 2D. Ciò equivale a fare un'escursione montuosa nel deserto. Vuoi tornare al villaggio che sai essere nel punto più basso. Anche se non conosci le direzioni cardinali del villaggio. Tutto quello che devi fare è continuare a scendere sempre più ripido e alla fine arriverai al villaggio. Quindi scenderemo lungo la superficie in base alla pendenza del pendio.

Assumiamo la nostra funzione

$y = x^2-4x+6$

determineremo la per la quale y è ridotta a icona. L'algoritmo di discesa gradiente dice innanzitutto che sceglieremo un valore casuale per x . Inizializziamo su x = 8 . Quindi l'algoritmo farà iterativamente quanto segue fino a raggiungere la convergenza.$x$$y$$x$$x=8$

$x^{new} = x^{old} - \nu \frac{dy}{dx}$

dove è il tasso di apprendimento, possiamo impostarlo su qualunque valore desideriamo. Tuttavia, esiste un modo intelligente per scegliere questo. Troppo grande e non raggiungeremo mai il nostro valore minimo, e troppo grande perderemo moltissimo tempo prima di arrivarci. È analogo alla dimensione dei gradini che si desidera percorrere per il ripido pendio. Piccoli passi e morirai sulla montagna, non scenderai mai. Troppo grande di un passo e rischi di sparare al villaggio e finire dall'altra parte della montagna. La derivata è il mezzo con cui percorriamo questa pendenza verso il nostro minimo.$\nu$

$\frac{dy}{dx} = 2x - 4$

$\nu = 0.1$

Iterazione 1:

x n e w = 6.8 - 0.1 ( 2 ∗ 6.8 - 4 ) = 5.84 x n e w = 5.84 - 0.1 ( 2 ∗ 5.84 - 4 ) = 5,07 x n e w = 5,07 - $x^{new} = 8 - 0.1(2 * 8 - 4) = 6.8$
$x^{new} = 6.8 - 0.1(2 * 6.8 - 4) = 5.84$
$x^{new} = 5.84 - 0.1(2 * 5.84 - 4) = 5.07$
x n e w = 4.45 - 0.1 ( 2 ∗ 4.45 - 4 ) = 3.96 x n e w = 3.96 - 0.1 ( 2 ∗ 3.96 - 4 ) = 3.57 x n e w = 3.57 - 0,1 ( 2 ∗ 3,57 - 4 $x^{new} = 5.07 - 0.1(2 * 5.07 - 4) = 4.45$
$x^{new} = 4.45 - 0.1(2 * 4.45 - 4) = 3.96$
$x^{new} = 3.96 - 0.1(2 * 3.96 - 4) = 3.57$
x n e w = 3.25 - 0.1 ( 2 ∗ 3.25 - 4 ) = 3.00 x n e w = 3.00 - 0.1 ( 2 ∗ 3.00 - 4 ) = 2.80 x n e w = 2.80 - 0.1 ( 2 ∗ 2.80 - 4 ) = 2,64 x n e w$x^{new} = 3.57 - 0.1(2 * 3.57 - 4) = 3.25$
$x^{new} = 3.25 - 0.1(2 * 3.25 - 4) = 3.00$
$x^{new} = 3.00 - 0.1(2 * 3.00 - 4) = 2.80$
$x^{new} = 2.80 - 0.1(2 * 2.80 - 4) = 2.64$
x n e w = 2.51 - 0.1 ( 2 ∗ 2.51 - 4 ) = 2.41 x n e w = 2.41 - 0.1 ( 2 ∗ 2.41 - 4 ) = 2.32 x n e w = 2,32 - 0,1 ( 2 ∗ $x^{new} = 2.64 - 0.1(2 * 2.64 - 4) = 2.51$
$x^{new} = 2.51 - 0.1(2 * 2.51 - 4) = 2.41$
$x^{new} = 2.41 - 0.1(2 * 2.41 - 4) = 2.32$
x n e w = 2,26 - 0,1 ( 2 ∗ 2,26 - 2 ∗ 2,06 - 4 ) = 2,05 x n e w = 2,05 - 0,1 ( 2,02 x n e w$x^{new} = 2.32 - 0.1(2 * 2.32 - 4) = 2.26$
x n e w = 2,21 - 0,1 ( 2 ∗ 2,21 - 4 ) = 2,16 x n e w = 2,16 - 0,1 ( 2 ∗ 2,16 - 4 ) = 2,13 x $x^{new} = 2.26 - 0.1(2 * 2.26 - 4) = 2.21$
$x^{new} = 2.21 - 0.1(2 * 2.21 - 4) = 2.16$
$x^{new} = 2.16 - 0.1(2 * 2.16 - 4) = 2.13$
x n e w =2,10-0,1(2*2,10-4)=2,08 x n e w =2.08-0,1(2*2.08-4)=2.06 x n e w =2,06-0,1$x^{new} = 2.13 - 0.1(2 * 2.13 - 4) = 2.10$
$x^{new} = 2.10 - 0.1(2 * 2.10 - 4) = 2.08$
$x^{new} = 2.08 - 0.1(2 * 2.08 - 4) = 2.06$
$x^{new} = 2.06 - 0.1(2 * 2.06 - 4) = 2.05$
x n e w = 2,04 - 0,1 ( 2 ∗ 2,04 - 4 ) = 2,03 x n e w = 2,03 - 0,1 ( 2 ∗ 2,03 - 4 ) $x^{new} = 2.05 - 0.1(2 * 2.05 - 4) = 2.04$
$x^{new} = 2.04 - 0.1(2 * 2.04 - 4) = 2.03$
$x^{new} = 2.03 - 0.1(2 * 2.03 - 4) = 2.02$
- 0,1 ( 2 ∗ 2,01 - 4 ) = 2,01 x n e w = 2,01 - $x^{new} = 2.02 - 0.1(2 * 2.02 - 4) = 2.02$
x n e w = 2,01 - 0,1 ( 2 ∗ 2,01 - 4 ) = 2,01 x n e w = $x^{new} = 2.02 - 0.1(2 * 2.02 - 4) = 2.01$
$x^{new} = 2.01 - 0.1(2 * 2.01 - 4) = 2.01$
$x^{new} = 2.01 - 0.1(2 * 2.01 - 4) = 2.01$
x n e w = 2,00 - 0,1 ( 2 ∗ 2,00 - 4 ) = 2,00 x n e w = 2,00 - 0,1 ( 2 ∗ 2,00 $x^{new} = 2.01 - 0.1(2 * 2.01 - 4) = 2.00$
$x^{new} = 2.00 - 0.1(2 * 2.00 - 4) = 2.00$
x n e w = 2,00 - 0,1 ( 2 ∗ 2,00 - 4 ) = 2,00 x n e w = 2,00 - 0,1 ( 2 ∗ 2,00 - 4 ) = $x^{new} = 2.00 - 0.1(2 * 2.00 - 4) = 2.00$
$x^{new} = 2.00 - 0.1(2 * 2.00 - 4) = 2.00$
$x^{new} = 2.00 - 0.1(2 * 2.00 - 4) = 2.00$

E vediamo che l'algoritmo converge in ! Abbiamo trovato il minimo.$x = 2$

Applicato alle reti neurali

Le prime reti neurali aveva solo un singolo neurone che prese in alcuni input e quindi fornire un'uscita y . Una funzione comune utilizzata è la funzione sigmoide$x$$\hat{y}$

$\sigma(z) = \frac{1}{1+exp(z)}$

$\hat{y}(w^Tx) = \frac{1}{1+exp(w^Tx + b)}$

dove è il peso associato per ogni input x e abbiamo una propensione b . Vogliamo quindi ridurre al minimo la nostra funzione di costo$w$$x$$b$

.$C = \frac{1}{2N} \sum_{i=0}^{N}(\hat{y} - y)^2$

Come addestrare la rete neurale?

Useremo discesa del gradiente di formare i pesi base all'output della funzione sigmoide ed useremo qualche funzione di costo e treno su lotti di dati di dimensione N .$C$$N$

$C = \frac{1}{2N} \sum_i^N (\hat{y} - y)^2$

è la classe prevista ottenuto dalla funzione sigmoide edyè l'etichetta verità a terra. Useremo la discesa gradiente per ridurre al minimo la funzione di costo rispetto ai pesiw. Per semplificare la vita, divideremo la derivata come segue$\hat{y}$$y$$w$

.$\frac{\partial C}{\partial w} = \frac{\partial C}{\partial \hat{y}} \frac{\partial \hat{y}}{\partial w}$

$\frac{\partial C}{\partial \hat{y}} = \hat{y} - y$

e abbiamo che y = σ ( w T x ) e la derivata della funzione sigmoide è ∂ σ ( z )$\hat{y} = \sigma(w^Tx)$quindi abbiamo,$\frac{\partial \sigma(z)}{\partial z} = \sigma(z)(1-\sigma(z))$

$\frac{\partial \hat{y}}{\partial w} = \frac{1}{1+exp(w^Tx + b)} (1 - \frac{1}{1+exp(w^Tx + b)})$

Quindi possiamo quindi aggiornare i pesi tramite discesa gradiente come

$w^{new} = w^{old} - \eta \frac{\partial C}{\partial w}$

$\eta$

$X$$W \cdot X + b$$σ(W \cdot X + b)$

$\hat y$$y$ $L(y, \hat y)=L\left(y, σ(W \cdot X + b)\right)$$W$$b$

$W$$b$

Uno dei motivi per cui la funzione sigmoide è popolare tra le reti neurali, è perché il suo derivato è facile da calcolare .

In parole semplici:

Il derivato mostra la capacità del neurone di apprendere su particolari input.

Ad esempio, se l'input è 0 o 1 o -2 , la derivata (la "capacità di apprendimento") è alta e la propagazione all'indietro migliorerà notevolmente i pesi dei neuroni per questo campione.

D'altra parte, se l'input è 20 , la derivata sarà molto vicina a 0 . Significa che la retro-propagazione su questo campione non "insegnerà" a questo neurone a produrre un risultato migliore.

Le cose sopra sono valide per un singolo campione.

Diamo un'occhiata al quadro più grande, per tutti i campioni nel set di allenamento. Qui abbiamo diverse situazioni:

• Se la derivata è 0 per tutti i campioni nel tuo set di allenamento, il neurone produce sempre risultati errati , significa che il neurone è saturo (stupido) e non migliorerà.

• Se il derivato è 0 per tutti i campioni nel tuo set di allenamento E il neurone produce sempre risultati corretti - significa che il neurone ha studiato davvero bene e già il più intelligente possibile (nota a margine: questo caso è buono ma può indicare un potenziale overfitting, che non va bene)

• Se il derivato è 0 su alcuni campioni, diverso da 0 su altri campioni E il neurone produce risultati contrastanti - indica che questo neurone sta facendo un buon lavoro e potenzialmente può migliorare da un ulteriore allenamento (anche se non necessariamente poiché dipende da altri neuroni e dai dati di allenamento che avere)

Quindi, quando stai guardando il diagramma derivato, puoi vedere quanto il neurone si è preparato per apprendere e assorbire le nuove conoscenze, dato un input particolare.

Il derivato che vedi qui è importante nelle reti neurali. È il motivo per cui le persone generalmente preferiscono qualcos'altro come l'unità lineare rettificata .

Vedi il calo derivativo per le due estremità? Cosa succede se la tua rete si trova sul lato sinistro, ma deve spostarsi sul lato destro? Immagina di essere su -10.0 ma vuoi 10.0. Il gradiente sarà troppo piccolo per consentire alla tua rete di convergere rapidamente. Non vogliamo aspettare, vogliamo una convergenza più rapida. RLU non ha questo problema.

Chiamiamo questo problema " Saturazione della rete neurale ".

Si prega di consultare https://www.quora.com/What-is-special-about-rectifier-neural-units-used-in-NN-learning