Apprendimento supervisionato

Come suggerisce il nome, supervised learningsi svolge sotto la supervisione di un insegnante. Questo processo di apprendimento dipende. Durante l'addestramento di ANN sotto apprendimento supervisionato, il vettore di input viene presentato alla rete, che produrrà un vettore di output. Questo vettore di output viene confrontato con il vettore di output desiderato / target. Un segnale di errore viene generato se c'è una differenza tra l'uscita effettiva e il vettore di uscita desiderato / target. Sulla base di questo segnale di errore, i pesi verrebbero regolati fino a quando l'uscita effettiva non corrisponderà all'uscita desiderata.

Perceptron

Sviluppato da Frank Rosenblatt utilizzando il modello McCulloch e Pitts, il perceptron è l'unità operativa di base delle reti neurali artificiali. Utilizza la regola di apprendimento supervisionato ed è in grado di classificare i dati in due classi.

Caratteristiche operative del percettrone: consiste in un singolo neurone con un numero arbitrario di input insieme a pesi regolabili, ma l'uscita del neurone è 1 o 0 a seconda della soglia. Consiste anche in un bias il cui peso è sempre 1. La figura seguente fornisce una rappresentazione schematica del perceptron.

Perceptron ha quindi i seguenti tre elementi di base:

• Links - Avrebbe una serie di collegamenti di connessione, che porta un peso incluso un bias avente sempre un peso 1.

• Adder - Aggiunge l'input dopo che sono stati moltiplicati per i rispettivi pesi.

• Activation function- Limita l'uscita del neurone. La funzione di attivazione più basilare è una funzione passo Heaviside che ha due possibili uscite. Questa funzione restituisce 1, se l'ingresso è positivo, e 0 per qualsiasi ingresso negativo.

Algoritmo di formazione

La rete Perceptron può essere addestrata sia per unità di output singole che per più unità di output.

Algoritmo di addestramento per unità di uscita singola

Step 1 - Inizializza quanto segue per iniziare la formazione -

• Weights
• Bias
• Tasso di apprendimento $ \ alpha $

Per un facile calcolo e semplicità, pesi e bias devono essere impostati pari a 0 e il tasso di apprendimento deve essere impostato uguale a 1.

Step 2 - Continuare il passaggio 3-8 quando la condizione di arresto non è vera.

Step 3 - Continua i passaggi 4-6 per ogni vettore di allenamento x.

Step 4 - Attivare ciascuna unità di ingresso come segue -

$$ x_ {i} \: = \: s_ {i} \ :( i \: = \: 1 \: a \: n) $$

Step 5 - Ora ottieni l'input netto con la seguente relazione -

$$ y_ {in} \: = \: b \: + \: \ displaystyle \ sum \ limits_ {i} ^ n x_ {i}. \: w_ {i} $$

Qui ‘b’ è bias e ‘n’ è il numero totale di neuroni di input.

Step 6 - Applicare la seguente funzione di attivazione per ottenere l'uscita finale.

$$ f (y_ {in}) \: = \: \ begin {case} 1 & if \: y_ {in} \:> \: \ theta \\ 0 & if \: - \ theta \: \ leqslant \ : y_ {in} \: \ leqslant \: \ theta \\ - 1 & if \: y_ {in} \: <\: - \ theta \ end {case} $$

Step 7 - Regolare il peso e il bias come segue:

Case 1 - se y ≠ t poi,

$$ w_ {i} (nuovo) \: = \: w_ {i} (vecchio) \: + \: \ alpha \: tx_ {i} $$

$$ b (nuovo) \: = \: b (vecchio) \: + \: \ alpha t $$

Case 2 - se y = t poi,

$$ w_ {i} (nuovo) \: = \: w_ {i} (vecchio) $$

$$ b (nuovo) \: = \: b (vecchio) $$

Qui ‘y’ è l'output effettivo e ‘t’ è l'output desiderato / target.

Step 8 - Test per la condizione di arresto, che si verificherebbe quando non ci sono variazioni di peso.

Algoritmo di addestramento per più unità di output

Il diagramma seguente è l'architettura di perceptron per più classi di output.

Step 1 - Inizializza quanto segue per iniziare la formazione -

• Weights
• Bias
• Tasso di apprendimento $ \ alpha $

Per un facile calcolo e semplicità, pesi e bias devono essere impostati pari a 0 e il tasso di apprendimento deve essere impostato uguale a 1.

Step 2 - Continuare il passaggio 3-8 quando la condizione di arresto non è vera.

Step 3 - Continua i passaggi 4-6 per ogni vettore di allenamento x.

Step 4 - Attivare ciascuna unità di ingresso come segue -

$$ x_ {i} \: = \: s_ {i} \ :( i \: = \: 1 \: a \: n) $$

Step 5 - Ottieni l'input netto con la seguente relazione -

$$ y_ {in} \: = \: b \: + \: \ displaystyle \ sum \ limits_ {i} ^ n x_ {i} \: w_ {ij} $$

Qui ‘b’ è bias e ‘n’ è il numero totale di neuroni di input.

Step 6 - Applicare la seguente funzione di attivazione per ottenere l'uscita finale per ciascuna unità di uscita j = 1 to m -

$$ f (y_ {in}) \: = \: \ begin {case} 1 & if \: y_ {inj} \:> \: \ theta \\ 0 & if \: - \ theta \: \ leqslant \ : y_ {inj} \: \ leqslant \: \ theta \\ - 1 & if \: y_ {inj} \: <\: - \ theta \ end {cases} $$

Step 7 - Regola il peso e il bias per x = 1 to n e j = 1 to m come segue -

Case 1 - se y_j ≠ t_j poi,

$$ w_ {ij} (nuovo) \: = \: w_ {ij} (vecchio) \: + \: \ alpha \: t_ {j} x_ {i} $$

$$ b_ {j} (nuovo) \: = \: b_ {j} (vecchio) \: + \: \ alpha t_ {j} $$

Case 2 - se y_j = t_j poi,

$$ w_ {ij} (nuovo) \: = \: w_ {ij} (vecchio) $$

$$ b_ {j} (nuovo) \: = \: b_ {j} (vecchio) $$

Qui ‘y’ è l'output effettivo e ‘t’ è l'output desiderato / target.

Step 8 - Test per la condizione di arresto, che accadrà quando non ci sono variazioni di peso.

Neurone lineare adattivo (Adaline)

Adaline, che sta per Adaptive Linear Neuron, è una rete con una singola unità lineare. È stato sviluppato da Widrow e Hoff nel 1960. Alcuni punti importanti su Adaline sono i seguenti:

• Utilizza la funzione di attivazione bipolare.

• Utilizza la regola delta per l'addestramento per ridurre al minimo l'errore medio quadrato (MSE) tra l'output effettivo e l'output desiderato / target.

• I pesi e il bias sono regolabili.

Architettura

La struttura di base di Adaline è simile al perceptron con un ciclo di feedback aggiuntivo con l'aiuto del quale l'output effettivo viene confrontato con l'output desiderato / target. Dopo il confronto sulla base dell'algoritmo di addestramento, i pesi e il bias verranno aggiornati.

Algoritmo di formazione

Step 1 - Inizializza quanto segue per iniziare la formazione -

• Weights
• Bias
• Tasso di apprendimento $ \ alpha $

Per un facile calcolo e semplicità, pesi e bias devono essere impostati pari a 0 e il tasso di apprendimento deve essere impostato uguale a 1.

Step 2 - Continuare il passaggio 3-8 quando la condizione di arresto non è vera.

Step 3 - Continua i passaggi 4-6 per ogni coppia di allenamento bipolare s:t.

Step 4 - Attivare ciascuna unità di ingresso come segue -

$$ x_ {i} \: = \: s_ {i} \ :( i \: = \: 1 \: a \: n) $$

Step 5 - Ottieni l'input netto con la seguente relazione -

$$ y_ {in} \: = \: b \: + \: \ displaystyle \ sum \ limits_ {i} ^ n x_ {i} \: w_ {i} $$

Qui ‘b’ è bias e ‘n’ è il numero totale di neuroni di input.

Step 6 - Applicare la seguente funzione di attivazione per ottenere l'uscita finale -

$$ f (y_ {in}) \: = \: \ begin {case} 1 & if \: y_ {in} \: \ geqslant \: 0 \\ - 1 & if \: y_ {in} \: < \: 0 \ end {case} $$

Step 7 - Regolare il peso e il bias come segue:

Case 1 - se y ≠ t poi,

$$ w_ {i} (nuovo) \: = \: w_ {i} (vecchio) \: + \: \ alpha (t \: - \: y_ {in}) x_ {i} $$

$$ b (nuovo) \: = \: b (vecchio) \: + \: \ alpha (t \: - \: y_ {in}) $$

Case 2 - se y = t poi,

$$ w_ {i} (nuovo) \: = \: w_ {i} (vecchio) $$

$$ b (nuovo) \: = \: b (vecchio) $$

Qui ‘y’ è l'output effettivo e ‘t’ è l'output desiderato / target.

$ (t \: - \; y_ {in}) $ è l'errore calcolato.

Step 8 - Test per la condizione di arresto, che si verificherà quando non vi è alcuna variazione di peso o la variazione di peso massima verificatasi durante l'allenamento è inferiore alla tolleranza specificata.

Multiple Adaptive Linear Neuron (Madaline)

Madaline, che sta per Multiple Adaptive Linear Neuron, è una rete composta da molte Adaline in parallelo. Avrà un'unica unità di output. Alcuni punti importanti su Madaline sono i seguenti:

• È proprio come un perceptron multistrato, dove Adaline agirà come un'unità nascosta tra l'input e lo strato Madaline.

• I pesi e il bias tra i livelli di input e Adaline, come vediamo nell'architettura Adaline, sono regolabili.

• I livelli Adaline e Madaline hanno pesi fissi e bias di 1.

• L'addestramento può essere svolto con l'aiuto della regola Delta.

Architettura

L'architettura di Madaline è composta da “n” neuroni dello strato di input, “m”neuroni dello strato di Adaline e 1 neurone dello strato di Madaline. Il livello Adaline può essere considerato come il livello nascosto in quanto si trova tra il livello di input e il livello di output, ovvero il livello Madaline.

Algoritmo di formazione

Ormai sappiamo che devono essere regolati solo i pesi e il bias tra l'input e il livello Adaline, e i pesi e il bias tra il livello Adaline e il livello Madaline sono fissi.

Step 1 - Inizializza quanto segue per iniziare la formazione -

• Weights
• Bias
• Tasso di apprendimento $ \ alpha $

Per un facile calcolo e semplicità, pesi e bias devono essere impostati pari a 0 e il tasso di apprendimento deve essere impostato uguale a 1.

Step 2 - Continuare il passaggio 3-8 quando la condizione di arresto non è vera.

Step 3 - Continua i passaggi 4-6 per ogni coppia di allenamento bipolare s:t.

Step 4 - Attivare ciascuna unità di ingresso come segue -

$$ x_ {i} \: = \: s_ {i} \ :( i \: = \: 1 \: a \: n) $$

Step 5 - Ottieni l'input netto in ogni livello nascosto, cioè il livello Adaline con la seguente relazione -

$$ Q_ {inj} \: = \: b_ {j} \: + \: \ displaystyle \ sum \ limits_ {i} ^ n x_ {i} \: w_ {ij} \: \: \: j \: = \: 1 \: a \: m $$

Qui ‘b’ è bias e ‘n’ è il numero totale di neuroni di input.

Step 6 - Applicare la seguente funzione di attivazione per ottenere l'output finale al livello Adaline e Madaline -

$$ f (x) \: = \: \ begin {cases} 1 & if \: x \: \ geqslant \: 0 \\ - 1 & if \: x \: <\: 0 \ end {cases} $ $

Uscita all'unità nascosta (Adaline)

$$ Q_ {j} \: = \: f (Q_ {inj}) $$

Output finale della rete

$$ y \: = \: f (y_ {in}) $$

i.e. $ \: \: y_ {inj} \: = \: b_ {0} \: + \: \ sum_ {j = 1} ^ m \: Q_ {j} \: v_ {j} $

Step 7 - Calcola l'errore e regola i pesi come segue -

Case 1 - se y ≠ t e t = 1 poi,

$$ w_ {ij} (nuovo) \: = \: w_ {ij} (vecchio) \: + \: \ alpha (1 \: - \: Q_ {inj}) x_ {i} $$

$$ b_ {j} (nuovo) \: = \: b_ {j} (vecchio) \: + \: \ alpha (1 \: - \: Q_ {inj}) $$

In questo caso, i pesi verrebbero aggiornati Q_j dove l'input netto è vicino a 0 perché t = 1.

Case 2 - se y ≠ t e t = -1 poi,

$$ w_ {ik} (nuovo) \: = \: w_ {ik} (vecchio) \: + \: \ alpha (-1 \: - \: Q_ {ink}) x_ {i} $$

$$ b_ {k} (nuovo) \: = \: b_ {k} (vecchio) \: + \: \ alpha (-1 \: - \: Q_ {ink}) $$

In questo caso, i pesi verrebbero aggiornati Q_k dove l'input netto è positivo perché t = -1.

Qui ‘y’ è l'output effettivo e ‘t’ è l'output desiderato / target.

Case 3 - se y = t poi

Non ci sarebbe alcun cambiamento nei pesi.

Step 8 - Test per la condizione di arresto, che si verificherà quando non vi è alcuna variazione di peso o la variazione di peso massima verificatasi durante l'allenamento è inferiore alla tolleranza specificata.

Back Propagation Neural Networks

Back Propagation Neural (BPN) è una rete neurale multistrato composta da un livello di input, almeno uno nascosto e uno di output. Come suggerisce il nome, la propagazione indietro avverrà in questa rete. L'errore calcolato al livello di output, confrontando l'output di destinazione e l'output effettivo, verrà propagato indietro verso il livello di input.

Architettura

Come mostrato nel diagramma, l'architettura di BPN ha tre livelli interconnessi con pesi su di essi. Anche il livello nascosto e il livello di output hanno un bias, il cui peso è sempre 1, su di essi. Come si evince dallo schema, il funzionamento di BPN è in due fasi. Una fase invia il segnale dallo strato di input allo strato di output e l'altra fase indietro propaga l'errore dallo strato di output allo strato di input.

Algoritmo di formazione

Per l'addestramento, BPN utilizzerà la funzione di attivazione binaria del sigmoide. La formazione di BPN avrà le seguenti tre fasi.

• Phase 1 - Fase Feed Forward

• Phase 2 - Indietro Propagazione dell'errore

• Phase 3 - Aggiornamento dei pesi

Tutti questi passaggi si concluderanno nell'algoritmo come segue

Step 1 - Inizializza quanto segue per iniziare la formazione -

• Weights
• Tasso di apprendimento $ \ alpha $

Per un facile calcolo e semplicità, prendi alcuni piccoli valori casuali.

Step 2 - Continuare i passaggi 3-11 quando la condizione di arresto non è vera.

Step 3 - Continua i passaggi 4-10 per ogni coppia di allenamento.

Fase 1

Step 4 - Ciascuna unità di ingresso riceve il segnale di ingresso x_i e lo invia all'unità nascosta per tutti i = 1 to n

Step 5 - Calcola l'input netto all'unità nascosta utilizzando la seguente relazione -

$$ Q_ {inj} \: = \: b_ {0j} \: + \: \ sum_ {i = 1} ^ n x_ {i} v_ {ij} \: \: \: \: j \: = \ : 1 \: to \: p $$

Qui b_0j è il pregiudizio sull'unità nascosta, v_ij è il peso j unità dello strato nascosto proveniente da i unità dello strato di input.

Ora calcola la produzione netta applicando la seguente funzione di attivazione

$$ Q_ {j} \: = \: f (Q_ {inj}) $$

Invia questi segnali di uscita delle unità del livello nascosto alle unità del livello di uscita.

Step 6 - Calcola l'input netto nell'unità del livello di output utilizzando la seguente relazione:

$$ y_ {ink} \: = \: b_ {0k} \: + \: \ sum_ {j = 1} ^ p \: Q_ {j} \: w_ {jk} \: \: k \: = \ : 1 \: to \: m $$

Qui b_0k È il bias sull'unità di output, w_jk è il peso k unità dello strato di output proveniente da j unità dello strato nascosto.

Calcolare la produzione netta applicando la seguente funzione di attivazione

$$ y_ {k} \: = \: f (y_ {ink}) $$

Fase 2

Step 7 - Calcolare il termine di correzione dell'errore, in corrispondenza del pattern target ricevuto su ciascuna unità di uscita, come segue -

$$ \ delta_ {k} \: = \ :( t_ {k} \: - \: y_ {k}) f ^ {'} (y_ {ink}) $$

Su questa base, aggiorna il peso e il bias come segue:

$$ \ Delta v_ {jk} \: = \: \ alpha \ delta_ {k} \: Q_ {ij} $$

$$ \ Delta b_ {0k} \: = \: \ alpha \ delta_ {k} $$

Quindi, rimanda $ \ delta_ {k} $ al livello nascosto.

Step 8 - Ora ogni unità nascosta sarà la somma dei suoi input delta dalle unità di output.

$$ \ delta_ {inj} \: = \: \ displaystyle \ sum \ limits_ {k = 1} ^ m \ delta_ {k} \: w_ {jk} $$

Il termine di errore può essere calcolato come segue:

$$ \ delta_ {j} \: = \: \ delta_ {inj} f ^ {'} (Q_ {inj}) $$

Su questa base, aggiorna il peso e il bias come segue:

$$ \ Delta w_ {ij} \: = \: \ alpha \ delta_ {j} x_ {i} $$

$$ \ Delta b_ {0j} \: = \: \ alpha \ delta_ {j} $$

Fase 3

Step 9 - Ogni unità di output (y_kk = 1 to m) aggiorna il peso e il bias come segue:

$$ v_ {jk} (nuovo) \: = \: v_ {jk} (vecchio) \: + \: \ Delta v_ {jk} $$

$$ b_ {0k} (nuovo) \: = \: b_ {0k} (vecchio) \: + \: \ Delta b_ {0k} $$

Step 10 - Ogni unità di output (z_jj = 1 to p) aggiorna il peso e il bias come segue:

$$ w_ {ij} (nuovo) \: = \: w_ {ij} (vecchio) \: + \: \ Delta w_ {ij} $$

$$ b_ {0j} (nuovo) \: = \: b_ {0j} (vecchio) \: + \: \ Delta b_ {0j} $$

Step 11 - Verificare la condizione di arresto, che può essere il numero di epoche raggiunte o l'uscita target corrisponde all'uscita effettiva.

Regola di apprendimento delta generalizzato

La regola delta funziona solo per il livello di output. D'altra parte, la regola delta generalizzata, chiamata anche comeback-propagation regola, è un modo per creare i valori desiderati del livello nascosto.

Formulazione matematica

Per la funzione di attivazione $ y_ {k} \: = \: f (y_ {ink}) $ la derivazione dell'input netto sullo strato Nascosto così come sullo strato di output può essere data da

$$ y_ {ink} \: = \: \ displaystyle \ sum \ limits_i \: z_ {i} w_ {jk} $$

E $ \: \: y_ {inj} \: = \: \ sum_i x_ {i} v_ {ij} $

Ora l'errore che deve essere minimizzato è

$$ E \: = \: \ frac {1} {2} \ displaystyle \ sum \ limits_ {k} \: [t_ {k} \: - \: y_ {k}] ^ 2 $$

Usando la regola della catena, abbiamo

$$ \ frac {\ partial E} {\ partial w_ {jk}} \: = \: \ frac {\ partial} {\ partial w_ {jk}} (\ frac {1} {2} \ displaystyle \ sum \ limits_ {k} \: [t_ {k} \: - \: y_ {k}] ^ 2) $$

$$ = \: \ frac {\ partial} {\ partial w_ {jk}} \ lgroup \ frac {1} {2} [t_ {k} \: - \: t (y_ {ink})] ^ 2 \ rgroup $$

$$ = \: - [t_ {k} \: - \: y_ {k}] \ frac {\ partial} {\ partial w_ {jk}} f (y_ {ink}) $$

$$ = \: - [t_ {k} \: - \: y_ {k}] f (y_ {inchiostro}) \ frac {\ partial} {\ partial w_ {jk}} (y_ {ink}) $$

$$ = \: - [t_ {k} \: - \: y_ {k}] f ^ {'} (y_ {ink}) z_ {j} $$

Ora diciamo $ \ delta_ {k} \: = \: - [t_ {k} \: - \: y_ {k}] f ^ {'} (y_ {ink}) $

I pesi sulle connessioni all'unità nascosta z_j può essere dato da -

$$ \ frac {\ partial E} {\ partial v_ {ij}} \: = \: - \ displaystyle \ sum \ limits_ {k} \ delta_ {k} \ frac {\ partial} {\ partial v_ {ij} } \ :( y_ {ink}) $$

Mettendo il valore di $ y_ {ink} $ otterremo quanto segue

$$ \ delta_ {j} \: = \: - \ displaystyle \ sum \ limits_ {k} \ delta_ {k} w_ {jk} f ^ {'} (z_ {inj}) $$

L'aggiornamento del peso può essere eseguito come segue:

Per l'unità di uscita -

$$ \ Delta w_ {jk} \: = \: - \ alpha \ frac {\ partial E} {\ partial w_ {jk}} $$

$$ = \: \ alpha \: \ delta_ {k} \: z_ {j} $$

Per l'unità nascosta -

$$ \ Delta v_ {ij} \: = \: - \ alpha \ frac {\ partial E} {\ partial v_ {ij}} $$

$$ = \: \ alpha \: \ delta_ {j} \: x_ {i} $$