Rete neurale artificiale - Guida rapida

Le reti neurali sono dispositivi di calcolo parallelo, che è fondamentalmente un tentativo di creare un modello computerizzato del cervello. L'obiettivo principale è sviluppare un sistema per eseguire vari compiti computazionali più velocemente rispetto ai sistemi tradizionali. Queste attività includono il riconoscimento e la classificazione dei modelli, l'approssimazione, l'ottimizzazione e il raggruppamento dei dati.

Cos'è la rete neurale artificiale?

Artificial Neural Network (ANN) è un efficiente sistema di calcolo il cui tema centrale è preso in prestito dall'analogia delle reti neurali biologiche. Le ANN sono anche chiamate "sistemi neurali artificiali" o "sistemi di elaborazione distribuita parallela" o "sistemi connessionisti". ANN acquisisce una vasta collezione di unità che sono interconnesse in un modello per consentire la comunicazione tra le unità. Queste unità, chiamate anche nodi o neuroni, sono semplici processori che operano in parallelo.

Ogni neurone è connesso con un altro neurone tramite un collegamento di connessione. Ogni collegamento di connessione è associato a un peso che contiene informazioni sul segnale di ingresso. Questa è l'informazione più utile per i neuroni per risolvere un particolare problema perché il peso di solito eccita o inibisce il segnale che viene comunicato. Ogni neurone ha uno stato interno, chiamato segnale di attivazione. I segnali di uscita, che vengono prodotti dopo aver combinato i segnali di ingresso e la regola di attivazione, possono essere inviati ad altre unità.

Una breve storia di ANN

La storia di ANN può essere suddivisa nelle seguenti tre epoche:

ANN durante gli anni Quaranta e Sessanta

Alcuni sviluppi chiave di questa era sono i seguenti:

  • 1943 - Si è ipotizzato che il concetto di rete neurale sia iniziato con il lavoro del fisiologo Warren McCulloch e del matematico Walter Pitts, quando nel 1943 modellarono una semplice rete neurale usando circuiti elettrici per descrivere come potrebbero funzionare i neuroni nel cervello .

  • 1949- Il libro di Donald Hebb, The Organization of Behaviour , sottolinea il fatto che l'attivazione ripetuta di un neurone da parte di un altro ne aumenta la forza ogni volta che vengono utilizzati.

  • 1956 - Una rete di memoria associativa è stata introdotta da Taylor.

  • 1958 - Un metodo di apprendimento per il modello neuronale di McCulloch e Pitts denominato Perceptron è stato inventato da Rosenblatt.

  • 1960 - Bernard Widrow e Marcian Hoff hanno sviluppato modelli chiamati "ADALINE" e "MADALINE".

ANN durante gli anni '60 e '80

Alcuni sviluppi chiave di questa era sono i seguenti:

  • 1961 - Rosenblatt ha tentato senza successo, ma ha proposto lo schema di "backpropagation" per reti multistrato.

  • 1964 - Taylor ha costruito un circuito vincente prendi tutto con inibizioni tra le unità di output.

  • 1969 - Multilayer perceptron (MLP) è stato inventato da Minsky e Papert.

  • 1971 - Kohonen ha sviluppato memorie associative.

  • 1976 - Stephen Grossberg e Gail Carpenter hanno sviluppato la teoria della risonanza adattiva.

ANN dagli anni '80 ad oggi

Alcuni sviluppi chiave di questa era sono i seguenti:

  • 1982 - Lo sviluppo principale è stato l'approccio energetico di Hopfield.

  • 1985 - La macchina Boltzmann è stata sviluppata da Ackley, Hinton e Sejnowski.

  • 1986 - Rumelhart, Hinton e Williams hanno introdotto la regola delta generalizzata.

  • 1988 - Kosko ha sviluppato Binary Associative Memory (BAM) e ha anche fornito il concetto di Fuzzy Logic in ANN.

La rassegna storica mostra che sono stati compiuti progressi significativi in ​​questo campo. Stanno emergendo chip basati su reti neurali e sono in fase di sviluppo applicazioni per problemi complessi. Sicuramente, oggi è un periodo di transizione per la tecnologia delle reti neurali.

Neurone biologico

Una cellula nervosa (neurone) è una cellula biologica speciale che elabora le informazioni. Secondo una stima, il numero di neuroni è enorme, circa 10 11 con numerose interconnessioni, circa 10 15 .

Diagramma schematico

Lavoro di un neurone biologico

Come mostrato nel diagramma sopra, un tipico neurone è costituito dalle seguenti quattro parti con l'aiuto delle quali possiamo spiegarne il funzionamento:

  • Dendrites- Sono rami simili ad alberi, responsabili della ricezione delle informazioni da altri neuroni a cui è collegato. In un altro senso, possiamo dire che sono come le orecchie del neurone.

  • Soma - È il corpo cellulare del neurone ed è responsabile dell'elaborazione delle informazioni ricevute dai dendriti.

  • Axon - È proprio come un cavo attraverso il quale i neuroni inviano le informazioni.

  • Synapses - È la connessione tra l'assone e altri dendriti neuronali.

ANN rispetto a BNN

Prima di dare un'occhiata alle differenze tra Artificial Neural Network (ANN) e Biological Neural Network (BNN), diamo uno sguardo alle somiglianze basate sulla terminologia tra questi due.

Rete neurale biologica (BNN) Rete neurale artificiale (ANN)
Soma Nodo
Dendriti Ingresso
Sinapsi Pesi o interconnessioni
Axon Produzione

La tabella seguente mostra il confronto tra ANN e BNN sulla base di alcuni criteri citati.

Criteri BNN ANN
Processing Massicciamente parallela, lenta ma superiore a ANN Massicciamente parallelo, veloce ma inferiore a BNN
Size 10 11 neuroni e 10 15 interconnessioni 10 da 2 a 10 4 nodi (dipende principalmente dal tipo di applicazione e dal progettista di rete)
Learning Possono tollerare l'ambiguità Sono necessari dati molto precisi, strutturati e formattati per tollerare l'ambiguità
Fault tolerance Le prestazioni peggiorano con danni anche parziali È in grado di offrire prestazioni robuste, quindi ha il potenziale per essere tollerante ai guasti
Storage capacity Memorizza le informazioni nella sinapsi Memorizza le informazioni in posizioni di memoria continue

Modello di rete neurale artificiale

Il diagramma seguente rappresenta il modello generale di ANN seguito dalla sua elaborazione.

Per il modello generale di rete neurale artificiale di cui sopra, l'input netto può essere calcolato come segue:

$$ y_ {in} \: = \: x_ {1} .w_ {1} \: + \: x_ {2} .w_ {2} \: + \: x_ {3} .w_ {3} \: \ dotso \: x_ {m} .w_ {m} $$

cioè, input netto $ y_ {in} \: = \: \ sum_i ^ m \: x_ {i} .w_ {i} $

L'uscita può essere calcolata applicando la funzione di attivazione sull'ingresso netto.

$$ Y \: = \: F (y_ {in}) $$

Output = funzione (input netto calcolato)

L'elaborazione di ANN dipende dai seguenti tre elementi costitutivi:

  • Topologia di rete
  • Aggiustamenti di pesi o apprendimento
  • Funzioni di attivazione

In questo capitolo, discuteremo in dettaglio di questi tre elementi costitutivi di ANN

Topologia di rete

Una topologia di rete è la disposizione di una rete insieme ai suoi nodi e alle linee di collegamento. Secondo la topologia, ANN può essere classificato come i seguenti tipi:

Rete feedforward

È una rete non ricorrente avente unità / nodi di elaborazione a strati e tutti i nodi in un livello sono collegati con i nodi dei livelli precedenti. La connessione ha pesi diversi su di loro. Non vi è alcun ciclo di feedback significa che il segnale può fluire solo in una direzione, dall'ingresso all'uscita. Può essere suddiviso nei seguenti due tipi:

  • Single layer feedforward network- Il concetto è di RNA feedforward con un solo strato ponderato. In altre parole, possiamo dire che il livello di input è completamente connesso al livello di output.

  • Multilayer feedforward network- Il concetto è di RNA feedforward con più di uno strato ponderato. Poiché questa rete ha uno o più livelli tra il livello di input e quello di output, viene chiamato livelli nascosti.

Rete di feedback

Come suggerisce il nome, una rete di feedback ha percorsi di feedback, il che significa che il segnale può fluire in entrambe le direzioni utilizzando i loop. Questo lo rende un sistema dinamico non lineare, che cambia continuamente fino a raggiungere uno stato di equilibrio. Può essere suddiviso nei seguenti tipi:

  • Recurrent networks- Sono reti di feedback con circuiti chiusi. Di seguito sono riportati i due tipi di reti ricorrenti.

  • Fully recurrent network - È l'architettura di rete neurale più semplice perché tutti i nodi sono collegati a tutti gli altri nodi e ogni nodo funziona sia come input che come output.

  • Jordan network - È una rete ad anello chiuso in cui l'uscita andrà di nuovo all'ingresso come feedback come mostrato nel diagramma seguente.

Aggiustamenti di pesi o apprendimento

L'apprendimento, nella rete neurale artificiale, è il metodo per modificare i pesi delle connessioni tra i neuroni di una rete specifica. L'apprendimento in ANN può essere classificato in tre categorie: apprendimento supervisionato, apprendimento non supervisionato e apprendimento di rinforzo.

Apprendimento supervisionato

Come suggerisce il nome, questo tipo di apprendimento viene svolto 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 fornirà un vettore di output. Questo vettore di output viene confrontato con il vettore di output desiderato. Viene generato un segnale di errore, se c'è una differenza tra l'uscita effettiva e il vettore di uscita desiderato. Sulla base di questo segnale di errore, i pesi vengono regolati fino a quando l'uscita effettiva non corrisponde all'uscita desiderata.

Apprendimento senza supervisione

Come suggerisce il nome, questo tipo di apprendimento viene svolto senza la supervisione di un insegnante. Questo processo di apprendimento è indipendente.

Durante l'addestramento di ANN sotto apprendimento non supervisionato, i vettori di input di tipo simile vengono combinati per formare cluster. Quando viene applicato un nuovo pattern di input, la rete neurale fornisce una risposta di output che indica la classe a cui appartiene il pattern di input.

Non ci sono feedback dall'ambiente su quale dovrebbe essere l'output desiderato e se è corretto o errato. Quindi, in questo tipo di apprendimento, la rete stessa deve scoprire i modelli e le caratteristiche dai dati di input, e la relazione per i dati di input sull'output.

Insegnamento rafforzativo

Come suggerisce il nome, questo tipo di apprendimento viene utilizzato per rafforzare o rafforzare la rete su alcune informazioni critiche. Questo processo di apprendimento è simile all'apprendimento supervisionato, tuttavia potremmo avere molte meno informazioni.

Durante la formazione della rete sotto apprendimento per rinforzo, la rete riceve alcuni feedback dall'ambiente. Questo lo rende in qualche modo simile all'apprendimento supervisionato. Tuttavia, il feedback ottenuto qui è valutativo non istruttivo, il che significa che non c'è nessun insegnante come nell'apprendimento supervisionato. Dopo aver ricevuto il feedback, la rete esegue le regolazioni dei pesi per ottenere migliori informazioni critiche in futuro.

Funzioni di attivazione

Può essere definito come la forza o lo sforzo extra applicato sull'input per ottenere un output esatto. In ANN, possiamo anche applicare funzioni di attivazione sull'input per ottenere l'output esatto. Di seguito sono riportate alcune funzioni di attivazione di interesse:

Funzione di attivazione lineare

Viene anche chiamata funzione di identità poiché non esegue alcuna modifica dell'input. Può essere definito come -

$$ F (x) \: = \: x $$

Funzione di attivazione del sigmoide

È di due tipi come segue:

  • Binary sigmoidal function- Questa funzione di attivazione esegue la modifica dell'ingresso tra 0 e 1. È di natura positiva. È sempre limitato, il che significa che il suo output non può essere minore di 0 e maggiore di 1. È anche di natura strettamente crescente, il che significa che più l'input più alto sarebbe l'output. Può essere definito come

    $$ F (x) \: = \: sigm (x) \: = \: \ frac {1} {1 \: + \: exp (-x)} $$

  • Bipolar sigmoidal function- Questa funzione di attivazione esegue la modifica dell'ingresso tra -1 e 1. Può essere di natura positiva o negativa. È sempre limitato, il che significa che il suo output non può essere inferiore a -1 e maggiore di 1. È anche di natura strettamente crescente come la funzione sigmoide. Può essere definito come

    $$ F (x) \: = \: sigm (x) \: = \: \ frac {2} {1 \: + \: exp (-x)} \: - \: 1 \: = \: \ frac {1 \: - \: exp (x)} {1 \: + \: exp (x)} $$

Come affermato in precedenza, ANN è completamente ispirato al modo in cui funziona il sistema nervoso biologico, cioè il cervello umano. La caratteristica più impressionante del cervello umano è imparare, quindi la stessa caratteristica viene acquisita da ANN.

Che cos'è l'apprendimento in ANN?

Fondamentalmente, imparare significa fare e adattare il cambiamento in sé come e quando c'è un cambiamento nell'ambiente. ANN è un sistema complesso o più precisamente possiamo dire che è un sistema adattivo complesso, che può cambiare la sua struttura interna in base alle informazioni che lo attraversano.

Perché è importante?

Essendo un sistema adattivo complesso, l'apprendimento in ANN implica che un'unità di elaborazione è in grado di modificare il proprio comportamento di input / output a causa del cambiamento nell'ambiente. L'importanza dell'apprendimento in ANN aumenta a causa della funzione di attivazione fissa e del vettore di input / output, quando viene costruita una particolare rete. Ora per modificare il comportamento di input / output, dobbiamo regolare i pesi.

Classificazione

Può essere definito come il processo di apprendimento per distinguere i dati di campioni in classi diverse trovando caratteristiche comuni tra i campioni delle stesse classi. Ad esempio, per eseguire l'addestramento di ANN, abbiamo alcuni campioni di addestramento con caratteristiche uniche e per eseguire i suoi test abbiamo alcuni campioni di prova con altre caratteristiche uniche. La classificazione è un esempio di apprendimento supervisionato.

Regole di apprendimento della rete neurale

Sappiamo che, durante l'apprendimento ANN, per modificare il comportamento di input / output, dobbiamo regolare i pesi. Quindi, è necessario un metodo con l'aiuto del quale è possibile modificare i pesi. Questi metodi sono chiamati regole di apprendimento, che sono semplicemente algoritmi o equazioni. Di seguito sono riportate alcune regole di apprendimento per la rete neurale:

Regola di apprendimento di Hebbian

Questa regola, una delle più antiche e semplici, è stata introdotta da Donald Hebb nel suo libro The Organization of Behavior nel 1949. È una sorta di apprendimento feed-forward e non supervisionato.

Basic Concept - Questa regola si basa su una proposta data da Hebb, che ha scritto -

"Quando un assone della cellula A è abbastanza vicino da eccitare una cellula B e prende parte ripetutamente o persistentemente alla sua attivazione, in una o entrambe le cellule si verifica un processo di crescita o un cambiamento metabolico in modo tale che l'efficienza di A, come una delle cellule che attivano B , è aumentato."

Dal postulato di cui sopra, possiamo concludere che le connessioni tra due neuroni potrebbero essere rafforzate se i neuroni si attivano contemporaneamente e potrebbero indebolirsi se si attivano in momenti diversi.

Mathematical Formulation - Secondo la regola di apprendimento di Hebbian, di seguito è riportata la formula per aumentare il peso della connessione ad ogni passo temporale.

$$ \ Delta w_ {ji} (t) \: = \: \ alpha x_ {i} (t) .y_ {j} (t) $$

Qui, $ \ Delta w_ {ji} (t) $ ⁡ = incremento di cui il peso della connessione aumenta al passo temporale t

$ \ alpha $ = il tasso di apprendimento positivo e costante

$ x_ {i} (t) $ = il valore di input dal neurone pre-sinaptico al passo temporale t

$ y_ {i} (t) $ = l'uscita del neurone pre-sinaptico allo stesso passo temporale t

Regola di apprendimento di Perceptron

Questa regola è un errore che corregge l'algoritmo di apprendimento supervisionato di reti feedforward a strato singolo con funzione di attivazione lineare, introdotto da Rosenblatt.

Basic Concept- Essendo di natura controllata, per calcolare l'errore, ci sarebbe un confronto tra l'uscita desiderata / target e l'uscita effettiva. Se viene rilevata una differenza, è necessario modificare i pesi della connessione.

Mathematical Formulation - Per spiegare la sua formulazione matematica, supponiamo di avere un numero 'n' di vettori di input finiti, x (n), insieme al suo vettore di output desiderato / target t (n), dove n = 1 a N.

Ora l'output 'y' può essere calcolato, come spiegato in precedenza sulla base dell'input netto, e la funzione di attivazione applicata su tale input netto può essere espressa come segue:

$$ y \: = \: f (y_ {in}) \: = \: \ begin {case} 1, & y_ {in} \:> \: \ theta \\ 0, & y_ {in} \: \ leqslant \: \ theta \ end {cases} $$

Dove θ è la soglia.

L'aggiornamento del peso può essere effettuato nei seguenti due casi:

Case I - quando t ≠ y, poi

$$ w (nuovo) \: = \: w (vecchio) \: + \; tx $$

Case II - quando t = y, poi

Nessun cambiamento di peso

Regola di apprendimento delta (regola di Widrow-Hoff)

Viene introdotto da Bernard Widrow e Marcian Hoff, chiamato anche metodo Least Mean Square (LMS), per ridurre al minimo l'errore su tutti i modelli di allenamento. È una specie di algoritmo di apprendimento supervisionato con funzione di attivazione continua.

Basic Concept- La base di questa regola è l'avvicinamento in discesa in pendenza, che continua per sempre. La regola delta aggiorna i pesi sinaptici in modo da ridurre al minimo l'input netto all'unità di output e il valore target.

Mathematical Formulation - Per aggiornare i pesi sinaptici, la regola delta è data da

$$ \ Delta w_ {i} \: = \: \ alpha \ :. x_ {i} .e_ {j} $$

Qui $ \ Delta w_ {i} $ = cambio di peso per i- esimo ⁡pattern;

$ \ alpha $ = il tasso di apprendimento positivo e costante;

$ x_ {i} $ = il valore di input dal neurone pre-sinaptico;

$ e_ {j} $ = $ (t \: - \: y_ {in}) $, la differenza tra l'output desiderato / target e l'output effettivo ⁡ $ y_ {in} $

La regola delta sopra è solo per una singola unità di output.

L'aggiornamento del peso può essere effettuato nei seguenti due casi:

Case-I - quando t ≠ y, poi

$$ w (nuovo) \: = \: w (vecchio) \: + \: \ Delta w $$

Case-II - quando t = y, poi

Nessun cambiamento di peso

Regola di apprendimento competitivo (il vincitore prende tutto)

Riguarda l'addestramento non supervisionato in cui i nodi di output cercano di competere tra loro per rappresentare il modello di input. Per comprendere questa regola di apprendimento, dobbiamo comprendere la rete competitiva che viene fornita come segue:

Basic Concept of Competitive Network- Questa rete è proprio come una rete feedforward a livello singolo con connessione di feedback tra le uscite. Le connessioni tra le uscite sono di tipo inibitorio, indicate da linee tratteggiate, il che significa che i concorrenti non si sostengono mai.

Basic Concept of Competitive Learning Rule- Come detto in precedenza, ci sarà una competizione tra i nodi di output. Quindi, il concetto principale è che durante l'allenamento, l'unità di output con l'attivazione più alta per un dato pattern di input, sarà dichiarata vincitrice. Questa regola è anche chiamata Vincitore prende tutto perché solo il neurone vincente viene aggiornato e il resto dei neuroni rimane invariato.

Mathematical formulation - Di seguito sono riportati i tre fattori importanti per la formulazione matematica di questa regola di apprendimento -

  • Condition to be a winner - Supponiamo che se un neurone $ y_ {k} $ ⁡ ⁡ voglia essere il vincitore, allora ci sarebbe la seguente condizione:

    $$ y_ {k} \: = \: \ begin {case} 1 & if \: v_ {k} \:> \: v_ {j} \: for \: all \: j, \: j \: \ neq \: k \\ 0 & altrimenti \ end {cases} $$

Significa che se un neurone, diciamo $ y_ {k} $ ⁡, vuole vincere, allora il suo campo locale indotto (l'output dell'unità di somma), diciamo $ v_ {k} $, deve essere il più grande tra tutti gli altri neuroni nella rete.

  • Condition of sum total of weight - Un altro vincolo sulla regola dell'apprendimento competitivo è che la somma totale dei pesi per un particolare neurone di output sarà 1. Ad esempio, se consideriamo il neurone k poi -

    $$ \ displaystyle \ sum \ limits_ {j} w_ {kj} \: = \: 1 \: \: \: \: \: \: \: \: \: for \: all \: k $$

  • Change of weight for winner- Se un neurone non risponde al pattern di input, non avviene alcun apprendimento in quel neurone. Tuttavia, se un particolare neurone vince, i pesi corrispondenti vengono regolati come segue

    $$ \ Delta w_ {kj} \: = \: \ begin {cases} - \ alpha (x_ {j} \: - \: w_ {kj}), & if \: neuron \: k \: wins \\ 0, & if \: neuron \: k \: loss \ end {cases} $$

Qui $ \ alpha $ è il tasso di apprendimento.

Questo mostra chiaramente che stiamo favorendo il neurone vincente regolando il suo peso e se c'è una perdita di neuroni, non dobbiamo preoccuparci di riadattare il suo peso.

Regola di apprendimento Outstar

Questa regola, introdotta da Grossberg, riguarda l'apprendimento supervisionato perché i risultati desiderati sono noti. È anche chiamato apprendimento Grossberg.

Basic Concept- Questa regola viene applicata sui neuroni disposti in uno strato. È appositamente progettato per produrre l'output desideratod dello strato di p neuroni.

Mathematical Formulation - Le regolazioni del peso in questa regola vengono calcolate come segue

$$ \ Delta w_ {j} \: = \: \ alpha \ :( d \: - \: w_ {j}) $$

Qui d è l'output neuronale desiderato e $ \ alpha $ è il tasso di apprendimento.

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: è costituito da 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 di 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 \: to \: 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 \: to \: 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 yj ≠ tj poi,

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

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

Case 2 - se yj = tj 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 si verificherà quando non ci saranno 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 \: to \: 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 \: to \: 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 Qj 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 Qk 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 sarebbero cambiamenti 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 xi 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 b0j è il pregiudizio sull'unità nascosta, vij è 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 b0k È il bias sull'unità di output, wjk è 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 (ykk = 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 (zjj = 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'output target corrisponde all'output effettivo.

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 sul livello Nascosto così come sul livello 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 zj 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 effettuato 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} $$

Come suggerisce il nome, questo tipo di apprendimento viene svolto senza la supervisione di un insegnante. Questo processo di apprendimento è indipendente. Durante l'addestramento di ANN sotto apprendimento non supervisionato, i vettori di input di tipo simile vengono combinati per formare cluster. Quando viene applicato un nuovo pattern di input, la rete neurale fornisce una risposta di output che indica la classe a cui appartiene il pattern di input. In questo, non ci sarebbe alcun feedback dall'ambiente su quale dovrebbe essere l'output desiderato e se è corretto o errato. Quindi, in questo tipo di apprendimento, la rete stessa deve scoprire i modelli, le caratteristiche dai dati di input e la relazione per i dati di input sull'output.

Winner-Takes-All Networks

Questi tipi di reti si basano sulla regola dell'apprendimento competitivo e useranno la strategia in cui sceglie il neurone con il maggior numero di input totali come vincitore. Le connessioni tra i neuroni di output mostrano la competizione tra loro e uno di loro sarebbe "ON", il che significa che sarebbe il vincitore e gli altri sarebbero "OFF".

Di seguito sono riportate alcune delle reti basate su questo semplice concetto che utilizzano l'apprendimento senza supervisione.

Rete di Hamming

Nella maggior parte delle reti neurali che utilizzano l'apprendimento non supervisionato, è essenziale calcolare la distanza ed eseguire confronti. Questo tipo di rete è la rete di Hamming, dove per ogni dato vettore di input, sarebbe raggruppato in diversi gruppi. Di seguito sono riportate alcune importanti caratteristiche di Hamming Networks:

  • Lippmann ha iniziato a lavorare sulle reti di Hamming nel 1987.

  • È una rete a livello singolo.

  • Gli ingressi possono essere binari {0, 1} o bipolari {-1, 1}.

  • I pesi della rete sono calcolati dai vettori esemplari.

  • È una rete di pesi fissi, il che significa che i pesi rimarrebbero gli stessi anche durante l'allenamento.

Max Net

Anche questa è una rete a peso fisso, che funge da sottorete per la selezione del nodo con l'ingresso più alto. Tutti i nodi sono completamente interconnessi ed esistono pesi simmetrici in tutte queste interconnessioni ponderate.

Architettura

Utilizza il meccanismo che è un processo iterativo e ogni nodo riceve input inibitori da tutti gli altri nodi attraverso le connessioni. Il singolo nodo il cui valore è massimo sarebbe attivo o vincitore e le attivazioni di tutti gli altri nodi sarebbero inattive. Max Net utilizza la funzione di attivazione dell'identità con $$ f (x) \: = \: \ begin {cases} x & if \: x> 0 \\ 0 & if \: x \ leq 0 \ end {cases} $$

Il compito di questa rete è svolto dal peso di autoeccitazione di +1 e dalla grandezza di mutua inibizione, che è impostata come [0 <ɛ <$ \ frac {1} {m} $] dove “m” è il numero totale dei nodi.

Apprendimento competitivo in ANN

Riguarda l'addestramento non supervisionato in cui i nodi di output cercano di competere tra loro per rappresentare il modello di input. Per comprendere questa regola di apprendimento dovremo comprendere la rete competitiva che viene spiegata come segue:

Concetto di base di rete competitiva

Questa rete è proprio come una rete feed-forward a livello singolo con connessione di feedback tra le uscite. Le connessioni tra le uscite sono di tipo inibitorio, che è mostrato da linee tratteggiate, il che significa che i concorrenti non si sostengono mai.

Concetto di base della regola di apprendimento competitivo

Come detto in precedenza, ci sarebbe competizione tra i nodi di output, quindi il concetto principale è: durante l'addestramento, l'unità di output che ha l'attivazione più alta per un dato pattern di input, sarà dichiarata vincitrice. Questa regola è anche chiamata Vincitore prende tutto perché viene aggiornato solo il neurone vincente e il resto dei neuroni rimane invariato.

Formulazione matematica

Di seguito sono riportati i tre fattori importanti per la formulazione matematica di questa regola di apprendimento:

  • Condizione per essere un vincitore

    Supponi se un neurone yk vuole essere il vincitore, allora ci sarebbe la seguente condizione

    $$ y_ {k} \: = \: \ begin {case} 1 & if \: v_ {k}> v_ {j} \: for \: all \: \: j, \: j \: \ neq \ : k \\ 0 & altrimenti \ end {cases} $$

    Significa che se qualche neurone, diciamo, yk vuole vincere, quindi il suo campo locale indotto (l'output dell'unità di somma), diciamo vk, deve essere il più grande tra tutti gli altri neuroni nella rete.

  • Condizione della somma totale del peso

    Un altro vincolo sulla regola dell'apprendimento competitivo è che la somma totale dei pesi di un particolare neurone di output sarà 1. Ad esempio, se consideriamo il neurone k poi

    $$ \ displaystyle \ sum \ limits_ {k} w_ {kj} \: = \: 1 \: \: \: \: for \: all \: \: k $$

  • Cambio di peso per il vincitore

    Se un neurone non risponde al pattern di input, non avviene alcun apprendimento in quel neurone. Tuttavia, se un particolare neurone vince, i pesi corrispondenti vengono regolati come segue:

    $$ \ Delta w_ {kj} \: = \: \ begin {case} - \ alpha (x_ {j} \: - \: w_ {kj}), & if \: neuron \: k \: wins \\ 0 & if \: neuron \: k \: loss \ end {cases} $$

    Qui $ \ alpha $ è il tasso di apprendimento.

    Questo mostra chiaramente che stiamo favorendo il neurone vincente regolando il suo peso e se un neurone viene perso, non dobbiamo preoccuparci di riadattare il suo peso.

K-significa algoritmo di clustering

K-means è uno degli algoritmi di clustering più popolari in cui usiamo il concetto di procedura di partizione. Iniziamo con una partizione iniziale e spostiamo ripetutamente i pattern da un cluster all'altro, fino a ottenere un risultato soddisfacente.

Algoritmo

Step 1 - Seleziona kpunti come i centroidi iniziali. Inizializzarek prototipi (w1,…,wk), ad esempio possiamo identificarli con vettori di input scelti a caso -

$$ W_ {j} \: = \: i_ {p}, \: \: \: dove \: j \: \ in \ lbrace1, ...., k \ rbrace \: e \: p \: \ in \ lbrace1, ...., n \ rbrace $$

Ogni cluster Cj è associato al prototipo wj.

Step 2 - Ripetere i passaggi 3-5 finché E non diminuisce più o l'appartenenza al cluster non cambia più.

Step 3 - Per ogni vettore di input ip dove p ∈ {1,…,n}, mettere ip nel cluster Cj* con il prototipo più vicino wj* avendo la seguente relazione

$$ | i_ {p} \: - \: w_ {j *} | \: \ leq \: | i_ {p} \: - \: w_ {j} |, \: j \: \ in \ lbrace1, ...., k \ rbrace $$

Step 4 - Per ogni cluster Cj, dove j ∈ { 1,…,k}, aggiorna il prototipo wj essere il centroide di tutti i campioni attualmente in Cj , così che

$$ w_ {j} \: = \: \ sum_ {i_ {p} \ in C_ {j}} \ frac {i_ {p}} {| C_ {j} |} $$

Step 5 - Calcola l'errore di quantizzazione totale come segue -

$$ E \: = \: \ sum_ {j = 1} ^ k \ sum_ {i_ {p} \ in w_ {j}} | i_ {p} \: - \: w_ {j} | ^ 2 $$

Neocognitron

Si tratta di una rete feedforward multistrato, sviluppata da Fukushima negli anni '80. Questo modello si basa sull'apprendimento supervisionato e viene utilizzato per il riconoscimento visivo di schemi, principalmente caratteri scritti a mano. È fondamentalmente un'estensione della rete Cognitron, sviluppata anche da Fukushima nel 1975.

Architettura

Si tratta di una rete gerarchica, che comprende molti livelli e in questi livelli esiste un modello di connettività locale.

Come abbiamo visto nel diagramma sopra, il neocognitron è diviso in diversi strati collegati e ogni strato ha due celle. La spiegazione di queste celle è la seguente:

S-Cell - Si chiama cellula semplice, che è addestrata a rispondere a uno schema particolare oa un gruppo di schemi.

C-Cell- Si chiama cella complessa, che combina l'output della cella S e contemporaneamente riduce il numero di unità in ciascun array. In un altro senso, la cellula C sposta il risultato della cellula S.

Algoritmo di formazione

Si è scoperto che l'addestramento del neocognitron è progredito strato dopo strato. I pesi dal livello di input al primo livello vengono addestrati e congelati. Quindi vengono allenati i pesi dal primo al secondo e così via. I calcoli interni tra S-cell e Ccell dipendono dai pesi provenienti dagli strati precedenti. Quindi, possiamo dire che l'algoritmo di addestramento dipende dai calcoli su cellule S e cellule C.

Calcoli in S-cell

La cella S possiede il segnale eccitatorio ricevuto dallo strato precedente e possiede segnali inibitori ottenuti all'interno dello stesso strato.

$$ \ theta = \: \ sqrt {\ sum \ sum t_ {i} c_ {i} ^ 2} $$

Qui, ti è il peso fisso e ci è l'uscita dalla cella C.

L'ingresso in scala della cella S può essere calcolato come segue:

$$ x \: = \: \ frac {1 \: + \: e} {1 \: + \: vw_ {0}} \: - \: 1 $$

Qui $ e \: = \: \ sum_i c_ {i} w_ {i} $

wi è il peso regolato dalla cella C alla cella S.

w0 è il peso regolabile tra l'ingresso e la cella S.

v è l'input eccitatorio dalla cellula C.

L'attivazione del segnale di uscita è,

$$ s \: = \: \ begin {cases} x, & if \: x \ geq 0 \\ 0, & if \: x <0 \ end {cases} $$

Calcoli in C-cell

L'input netto dello strato C è

$$ C \: = \: \ displaystyle \ sum \ limits_i s_ {i} x_ {i} $$

Qui, si è l'output di S-cell e xi è il peso fisso dalla cellula S alla cellula C.

L'output finale è il seguente:

$$ C_ {out} \: = \: \ begin {cases} \ frac {C} {a + C}, & if \: C> 0 \\ 0, & altrimenti \ end {cases} $$

Qui ‘a’ è il parametro che dipende dalle prestazioni della rete.

Learning Vector Quantization (LVQ), diverso da Vector quantization (VQ) e Kohonen Self-Organizing Maps (KSOM), fondamentalmente è una rete competitiva che utilizza l'apprendimento supervisionato. Possiamo definirlo come un processo di classificazione dei modelli in cui ogni unità di output rappresenta una classe. Poiché utilizza l'apprendimento supervisionato, la rete riceverà una serie di modelli di formazione con classificazione nota insieme a una distribuzione iniziale della classe di output. Dopo aver completato il processo di addestramento, LVQ classificherà un vettore di input assegnandolo alla stessa classe di quella dell'unità di output.

Architettura

La figura seguente mostra l'architettura di LVQ che è abbastanza simile all'architettura di KSOM. Come possiamo vedere, ci sono“n” numero di unità di input e “m”numero di unità di output. Gli strati sono completamente interconnessi con i pesi su di essi.

Parametri utilizzati

Di seguito sono riportati i parametri utilizzati nel processo di addestramento LVQ e nel diagramma di flusso

  • x= vettore di allenamento (x 1 , ..., x i , ..., x n )

  • T = classe per vettore di addestramento x

  • wj = vettore peso per jth unità di uscita

  • Cj = classe associata a jth unità di uscita

Algoritmo di formazione

Step 1 - Inizializza i vettori di riferimento, operazione che può essere eseguita come segue:

  • Step 1(a) - Dal set di vettori di addestramento fornito, prendi il primo "m"(Numero di cluster) vettori di allenamento e usali come vettori di peso. I vettori rimanenti possono essere utilizzati per l'allenamento.

  • Step 1(b) - Assegna il peso iniziale e la classificazione in modo casuale.

  • Step 1(c) - Applicare il metodo di clustering K-means.

Step 2 - Inizializza il vettore di riferimento $ \ alpha $

Step 3 - Continuare con i passaggi 4-9, se la condizione per l'arresto di questo algoritmo non è soddisfatta.

Step 4 - Segui i passaggi 5-6 per ogni vettore di input di addestramento x.

Step 5 - Calcola il quadrato della distanza euclidea per j = 1 to m e i = 1 to n

$$ D (j) \: = \: \ displaystyle \ sum \ limits_ {i = 1} ^ n \ displaystyle \ sum \ limits_ {j = 1} ^ m (x_ {i} \: - \: w_ {ij }) ^ 2 $$

Step 6 - Ottieni l'unità vincente J dove D(j) è minimo.

Step 7 - Calcola il nuovo peso dell'unità vincente con la seguente relazione -

Se T = Cj quindi $ w_ {j} (nuovo) \: = \: w_ {j} (vecchio) \: + \: \ alpha [x \: - \: w_ {j} (vecchio)] $

Se T ≠ Cj quindi $ w_ {j} (nuovo) \: = \: w_ {j} (vecchio) \: - \: \ alpha [x \: - \: w_ {j} (vecchio)] $

Step 8 - Riduci il tasso di apprendimento $ \ alpha $.

Step 9- Test per la condizione di arresto. Potrebbe essere il seguente:

  • Numero massimo di epoche raggiunto.
  • Tasso di apprendimento ridotto a un valore trascurabile.

Diagramma di flusso

Varianti

Altre tre varianti, ovvero LVQ2, LVQ2.1 e LVQ3, sono state sviluppate da Kohonen. La complessità in tutte queste tre varianti, dovuta al concetto che il vincitore così come il secondo classificato impareranno, è maggiore che in LVQ.

LVQ2

Come discusso, il concetto di altre varianti di LVQ sopra, la condizione di LVQ2 è formata da finestra. Questa finestra si baserà sui seguenti parametri:

  • x - il vettore di input corrente

  • yc - il vettore di riferimento più vicino a x

  • yr - l'altro vettore di riferimento, quello più vicino a x

  • dc - la distanza da x per yc

  • dr - la distanza da x per yr

Il vettore di input x cade nella finestra, se

$$ \ frac {d_ {c}} {d_ {r}} \:> \: 1 \: - \: \ theta \: \: e \: \: \ frac {d_ {r}} {d_ {c }} \:> \: 1 \: + \: \ theta $$

Qui $ \ theta $ è il numero di campioni di addestramento.

L'aggiornamento può essere effettuato con la seguente formula:

$ y_ {c} (t \: + \: 1) \: = \: y_ {c} (t) \: + \: \ alpha (t) [x (t) \: - \: y_ {c} (t)] $ (belongs to different class)

$ y_ {r} (t \: + \: 1) \: = \: y_ {r} (t) \: + \: \ alpha (t) [x (t) \: - \: y_ {r} (t)] $ (belongs to same class)

Qui $ \ alpha $ è il tasso di apprendimento.

LVQ2.1

In LVQ2.1, prenderemo i due vettori più vicini, vale a dire yc1 e yc2 e la condizione per la finestra è la seguente:

$$ Min \ begin {bmatrix} \ frac {d_ {c1}} {d_ {c2}}, \ frac {d_ {c2}} {d_ {c1}} \ end {bmatrix} \:> \ :( 1 \ : - \: \ theta) $$

$$ Max \ begin {bmatrix} \ frac {d_ {c1}} {d_ {c2}}, \ frac {d_ {c2}} {d_ {c1}} \ end {bmatrix} \: <\ :( 1 \ : + \: \ theta) $$

L'aggiornamento può essere effettuato con la seguente formula:

$ y_ {c1} (t \: + \: 1) \: = \: y_ {c1} (t) \: + \: \ alpha (t) [x (t) \: - \: y_ {c1} (t)] $ (belongs to different class)

$ y_ {c2} (t \: + \: 1) \: = \: y_ {c2} (t) \: + \: \ alpha (t) [x (t) \: - \: y_ {c2} (t)] $ (belongs to same class)

Qui $ \ alpha $ è il tasso di apprendimento.

LVQ3

In LVQ3, prenderemo i due vettori più vicini, vale a dire yc1 e yc2 e la condizione per la finestra è la seguente:

$$ Min \ begin {bmatrix} \ frac {d_ {c1}} {d_ {c2}}, \ frac {d_ {c2}} {d_ {c1}} \ end {bmatrix} \:> \ :( 1 \ : - \: \ theta) (1 \: + \: \ theta) $$

Qui $ \ theta \ circa 0,2 $

L'aggiornamento può essere effettuato con la seguente formula:

$ y_ {c1} (t \: + \: 1) \: = \: y_ {c1} (t) \: + \: \ beta (t) [x (t) \: - \: y_ {c1} (t)] $ (belongs to different class)

$ y_ {c2} (t \: + \: 1) \: = \: y_ {c2} (t) \: + \: \ beta (t) [x (t) \: - \: y_ {c2} (t)] $ (belongs to same class)

Qui $ \ beta $ è il multiplo del tasso di apprendimento $ \ alpha $ e $\beta\:=\:m \alpha(t)$ per ogni 0.1 < m < 0.5

Questa rete è stata sviluppata da Stephen Grossberg e Gail Carpenter nel 1987. Si basa sulla concorrenza e utilizza un modello di apprendimento senza supervisione. Le reti di Adaptive Resonance Theory (ART), come suggerisce il nome, sono sempre aperte a un nuovo apprendimento (adattivo) senza perdere i vecchi schemi (risonanza). Fondamentalmente, la rete ART è un classificatore di vettori che accetta un vettore di input e lo classifica in una delle categorie a seconda di quale dei pattern memorizzati assomiglia di più.

Principal Operativo

L'operazione principale della classificazione ART può essere suddivisa nelle seguenti fasi:

  • Recognition phase- Il vettore di input viene confrontato con la classificazione presentata in ogni nodo nel livello di output. L'output del neurone diventa "1" se meglio corrisponde alla classificazione applicata, altrimenti diventa "0".

  • Comparison phase- In questa fase, viene effettuato un confronto del vettore di input con il vettore del livello di confronto. La condizione per il ripristino è che il grado di somiglianza sia inferiore al parametro di vigilanza.

  • Search phase- In questa fase, la rete cercherà il ripristino e la corrispondenza effettuata nelle fasi precedenti. Quindi, se non ci fosse alcun reset e la partita fosse abbastanza buona, la classifica sarebbe finita. Altrimenti, il processo verrebbe ripetuto e l'altro modello memorizzato deve essere inviato per trovare la corrispondenza corretta.

ART1

È un tipo di ART, progettato per raggruppare i vettori binari. Possiamo capirlo con l'architettura di esso.

Architettura di ART1

Si compone delle seguenti due unità:

Computational Unit - È composto da:

  • Input unit (F1 layer) - Ha inoltre le seguenti due porzioni:

    • F1(a) layer (Input portion)- In ART1, non ci sarebbe elaborazione in questa porzione piuttosto che avere solo i vettori di input. È collegato al livello F 1 (b) (porzione di interfaccia).

    • F1(b) layer (Interface portion)- Questa porzione combina il segnale dalla porzione di ingresso con quello dello strato F 2 . Lo strato F 1 (b) è collegato allo strato F 2 tramite pesi dal basso verso l'altobije lo strato F 2 è collegato allo strato F 1 (b) tramite pesi dall'alto in bassotji.

  • Cluster Unit (F2 layer)- Questo è un livello competitivo. L'unità con l'ingresso netto più grande viene selezionata per apprendere lo schema di input. L'attivazione di tutte le altre unità cluster è impostata su 0.

  • Reset Mechanism- Il lavoro di questo meccanismo si basa sulla somiglianza tra il peso top-down e il vettore di input. Ora, se il grado di questa somiglianza è inferiore al parametro di vigilanza, al gruppo non è consentito apprendere lo schema e avverrebbe una pausa.

Supplement Unit - In realtà il problema con il meccanismo di ripristino è che il livello F2deve essere inibito in determinate condizioni e deve anche essere disponibile quando avviene un apprendimento. Ecco perché due unità supplementari vale a dire,G1 e G2 viene aggiunto insieme all'unità di ripristino, R. Sono chiamatigain control units. Queste unità ricevono e inviano segnali alle altre unità presenti nella rete.‘+’ indica un segnale eccitatorio, mentre ‘−’ indica un segnale inibitorio.

Parametri utilizzati

Vengono utilizzati i seguenti parametri:

  • n - Numero di componenti nel vettore di input

  • m - Numero massimo di cluster che possono essere formati

  • bij- Peso da F 1 (b) a F 2 strato, cioè pesi dal basso verso l'alto

  • tji- Peso da F 2 a F 1 (b) strato, cioè pesi dall'alto verso il basso

  • ρ - Parametro di vigilanza

  • ||x|| - Norma del vettore x

Algoritmo

Step 1 - Inizializza la velocità di apprendimento, il parametro di vigilanza e i pesi come segue:

$$ \ alpha \:> \: 1 \: \: e \: \: 0 \: <\ rho \: \ leq \: 1 $$

$$ 0 \: <\: b_ {ij} (0) \: <\: \ frac {\ alpha} {\ alpha \: - \: 1 \: + \: n} \: \: e \: \: t_ {ij} (0) \: = \: 1 $$

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

Step 3 - Continua i passaggi 4-6 per ogni input di formazione.

Step 4- Impostare le attivazioni di tutte le unità F 1 (a) e F 1 come segue

F2 = 0 and F1(a) = input vectors

Step 5- Il segnale di ingresso da F 1 (a) a F 1 (b) deve essere inviato come

$$ s_ {i} \: = \: x_ {i} $$

Step 6- Per ogni nodo F 2 inibito

$ y_ {j} \: = \: \ sum_i b_ {ij} x_ {i} $ la condizione è yj ≠ -1

Step 7 - Eseguire i passaggi 8-10, quando il ripristino è vero.

Step 8 - Trova J per yJ ≥ yj per tutti i nodi j

Step 9- Calcola nuovamente l'attivazione su F 1 (b) come segue

$$ x_ {i} \: = \: sitJi $$

Step 10 - Ora, dopo aver calcolato la norma del vettore x e vettoriale s, dobbiamo controllare la condizione di ripristino come segue:

Se ||x||/ ||s|| <parametro di vigilanza ρ, Quindi ⁡inhibit ⁡node J e vai al passaggio 7

Else If ||x||/ ||s|| ≥ parametro di vigilanza ρ, quindi procedi oltre.

Step 11 - Aggiornamento del peso per il nodo J può essere fatto come segue -

$$ b_ {ij} (nuovo) \: = \: \ frac {\ alpha x_ {i}} {\ alpha \: - \: 1 \: + \: || x ||} $$

$$ t_ {ij} (nuovo) \: = \: x_ {i} $$

Step 12 - La condizione di arresto dell'algoritmo deve essere verificata e può essere la seguente:

  • Non subire variazioni di peso.
  • Il ripristino non viene eseguito per le unità.
  • Numero massimo di epoche raggiunto.

Supponiamo di avere un modello di dimensioni arbitrarie, tuttavia, ne abbiamo bisogno in una o due dimensioni. Quindi il processo di mappatura delle caratteristiche sarebbe molto utile per convertire l'ampio spazio del modello in uno spazio tipico delle caratteristiche. Ora, sorge la domanda: perché abbiamo bisogno di una mappa delle caratteristiche auto-organizzata? Il motivo è che, oltre alla capacità di convertire le dimensioni arbitrarie in 1-D o 2-D, deve anche avere la capacità di preservare la topologia adiacente.

Topologie del vicino in Kohonen SOM

Possono esserci varie topologie, tuttavia le due topologie seguenti vengono utilizzate di più:

Topologia a griglia rettangolare

Questa topologia ha 24 nodi nella griglia distanza 2, 16 nodi nella griglia distanza 1 e 8 nodi nella griglia distanza 0, il che significa che la differenza tra ciascuna griglia rettangolare è di 8 nodi. L'unità vincente è indicata da #.

Topologia a griglia esagonale

Questa topologia ha 18 nodi nella griglia distanza 2, 12 nodi nella griglia distanza 1 e 6 nodi nella griglia distanza 0, il che significa che la differenza tra ogni griglia rettangolare è di 6 nodi. L'unità vincente è indicata da #.

Architettura

L'architettura di KSOM è simile a quella della rete competitiva. Con l'aiuto dei programmi di vicinato, discussi in precedenza, la formazione può svolgersi nella regione estesa della rete.

Algoritmo per la formazione

Step 1 - Inizializza i pesi, il tasso di apprendimento α e lo schema topologico di vicinato.

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

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

Step 4 - Calcola il quadrato della distanza euclidea per j = 1 to m

$$ D (j) \: = \: \ displaystyle \ sum \ limits_ {i = 1} ^ n \ displaystyle \ sum \ limits_ {j = 1} ^ m (x_ {i} \: - \: w_ {ij }) ^ 2 $$

Step 5 - Ottieni l'unità vincente J dove D(j) è minimo.

Step 6 - Calcola il nuovo peso dell'unità vincente con la seguente relazione -

$$ w_ {ij} (nuovo) \: = \: w_ {ij} (vecchio) \: + \: \ alpha [x_ {i} \: - \: w_ {ij} (vecchio)] $$

Step 7 - Aggiorna il tasso di apprendimento α dalla seguente relazione -

$$ \ alpha (t \: + \: 1) \: = \: 0.5 \ alpha t $$

Step 8 - Ridurre il raggio dello schema topologico.

Step 9 - Verificare le condizioni di arresto della rete.

Questi tipi di reti neurali funzionano sulla base dell'associazione di modelli, il che significa che possono memorizzare diversi modelli e al momento di fornire un output possono produrre uno dei modelli memorizzati abbinandoli al modello di input specificato. Questi tipi di ricordi sono anche chiamatiContent-Addressable Memory(CAMERA). La memoria associativa esegue una ricerca parallela con i modelli memorizzati come file di dati.

Di seguito sono riportati i due tipi di ricordi associativi che possiamo osservare:

  • Memoria auto associativa
  • Memoria etero associativa

Memoria auto associativa

Questa è una rete neurale a livello singolo in cui il vettore di addestramento di input ei vettori di destinazione di output sono gli stessi. I pesi sono determinati in modo che la rete memorizzi una serie di modelli.

Architettura

Come mostrato nella figura seguente, l'architettura della rete di memoria Auto Associative ha ‘n’ numero di vettori di addestramento in ingresso e simili ‘n’ numero di vettori target di output.

Algoritmo di formazione

Per la formazione, questa rete utilizza la regola di apprendimento Hebb o Delta.

Step 1 - Inizializza tutti i pesi a zero come wij = 0 (i = 1 to n, j = 1 to n)

Step 2 - Eseguire i passaggi 3-4 per ogni vettore di input.

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

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

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

$$ y_ {j} \: = \: s_ {j} \ :( j \: = \: 1 \: a \: n) $$

Step 5 - Regolare i pesi come segue -

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

Algoritmo di test

Step 1 - Imposta i pesi ottenuti durante l'allenamento per la regola di Hebb.

Step 2 - Eseguire i passaggi 3-5 per ogni vettore di input.

Step 3 - Impostare l'attivazione delle unità di input uguale a quella del vettore di input.

Step 4 - Calcola l'input netto per ciascuna unità di output j = 1 to n

$$ y_ {inj} \: = \: \ displaystyle \ sum \ limits_ {i = 1} ^ n x_ {i} w_ {ij} $$

Step 5 - Applicare la seguente funzione di attivazione per calcolare l'uscita

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

Memoria etero associativa

Simile alla rete Auto Associative Memory, anche questa è una rete neurale a livello singolo. Tuttavia, in questa rete il vettore di addestramento in ingresso e i vettori di destinazione in uscita non sono gli stessi. I pesi sono determinati in modo che la rete memorizzi una serie di modelli. La rete etero associativa è di natura statica, quindi non ci sarebbero operazioni non lineari e di ritardo.

Architettura

Come mostrato nella figura seguente, l'architettura della rete Hetero Associative Memory ha ‘n’ numero di vettori di addestramento in ingresso e ‘m’ numero di vettori target di output.

Algoritmo di formazione

Per la formazione, questa rete utilizza la regola di apprendimento Hebb o Delta.

Step 1 - Inizializza tutti i pesi a zero come wij = 0 (i = 1 to n, j = 1 to m)

Step 2 - Eseguire i passaggi 3-4 per ogni vettore di input.

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

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

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

$$ y_ {j} \: = \: s_ {j} \ :( j \: = \: 1 \: to \: m) $$

Step 5 - Regolare i pesi come segue -

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

Algoritmo di test

Step 1 - Imposta i pesi ottenuti durante l'allenamento per la regola di Hebb.

Step 2 - Eseguire i passaggi 3-5 per ogni vettore di input.

Step 3 - Impostare l'attivazione delle unità di input uguale a quella del vettore di input.

Step 4 - Calcola l'input netto per ciascuna unità di output j = 1 to m;

$$ y_ {inj} \: = \: \ displaystyle \ sum \ limits_ {i = 1} ^ n x_ {i} w_ {ij} $$

Step 5 - Applicare la seguente funzione di attivazione per calcolare l'uscita

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

La rete neurale di Hopfield è stata inventata dal Dr. John J. Hopfield nel 1982. È costituita da un singolo strato che contiene uno o più neuroni ricorrenti completamente connessi. La rete Hopfield viene comunemente utilizzata per attività di associazione automatica e ottimizzazione.

Rete Hopfield discreta

Una rete Hopfield che opera in modo a linee discrete o, in altre parole, si può dire che i modelli di input e output sono vettori discreti, che possono essere di natura binaria (0,1) o bipolare (+1, -1). La rete ha pesi simmetrici senza auto-connessioni, ovvero,wij = wji e wii = 0.

Architettura

Di seguito sono riportati alcuni punti importanti da tenere a mente sulla rete Hopfield discreta:

  • Questo modello è costituito da neuroni con un'uscita invertente e una non invertente.

  • L'output di ogni neurone dovrebbe essere l'input di altri neuroni ma non l'input del sé.

  • Il peso / forza della connessione è rappresentato da wij.

  • Le connessioni possono essere eccitatorie oltre che inibitorie. Sarebbe eccitatorio, se l'uscita del neurone fosse uguale all'input, altrimenti inibitorio.

  • I pesi dovrebbero essere simmetrici, cioè wij = wji

L'uscita da Y1 andando a Y2, Yi e Yn avere i pesi w12, w1i e w1nrispettivamente. Allo stesso modo, altri archi hanno i pesi su di essi.

Algoritmo di formazione

Durante l'allenamento della rete Hopfield discreta, i pesi verranno aggiornati. Come sappiamo, possiamo avere vettori di input binari e vettori di input bipolari. Quindi, in entrambi i casi, gli aggiornamenti del peso possono essere effettuati con la seguente relazione

Case 1 - Modelli di input binari

Per un insieme di modelli binari s(p), p = 1 to P

Qui, s(p) = s1(p), s2(p),..., si(p),..., sn(p)

La matrice del peso è data da

$$ w_ {ij} \: = \: \ sum_ {p = 1} ^ P [2s_ {i} (p) - \: 1] [2s_ {j} (p) - \: 1] \: \: \: \: \: per \: i \: \ neq \: j $$

Case 2 - Pattern di input bipolari

Per un insieme di modelli binari s(p), p = 1 to P

Qui, s(p) = s1(p), s2(p),..., si(p),..., sn(p)

La matrice del peso è data da

$$ w_ {ij} \: = \: \ sum_ {p = 1} ^ P [s_ {i} (p)] [s_ {j} (p)] \: \: \: \: \: for \ : i \: \ neq \: j $$

Algoritmo di test

Step 1 - Inizializza i pesi, che si ottengono dall'algoritmo di addestramento utilizzando il principio di Hebbian.

Step 2 - Eseguire i passaggi 3-9, se le attivazioni della rete non sono consolidate.

Step 3 - Per ogni vettore di input X, eseguire i passaggi 4-8.

Step 4 - Rendere l'attivazione iniziale della rete uguale al vettore di input esterno X come segue -

$$ y_ {i} \: = \: x_ {i} \: \: \: per \: i \: = \: 1 \: a \: n $$

Step 5 - Per ogni unità Yi, eseguire i passaggi 6-9.

Step 6 - Calcola l'ingresso netto della rete come segue -

$$ y_ {ini} \: = \: x_ {i} \: + \: \ displaystyle \ sum \ limits_ {j} y_ {j} w_ {ji} $$

Step 7 - Applicare l'attivazione come segue sull'input netto per calcolare l'output -

$$ y_ {i} \: = \ begin {cases} 1 & if \: y_ {ini} \:> \: \ theta_ {i} \\ y_ {i} & if \: y_ {ini} \: = \: \ theta_ {i} \\ 0 & if \: y_ {ini} \: <\: \ theta_ {i} \ end {cases} $$

Qui $ \ theta_ {i} $ è la soglia.

Step 8 - Trasmetti questo output yi a tutte le altre unità.

Step 9 - Testare la rete per la congiunzione.

Valutazione della funzione energetica

Una funzione energetica è definita come una funzione che è funzione legata e non crescente dello stato del sistema.

Funzione energetica Ef⁡, ⁡ chiamato anche Lyapunov function determina la stabilità della rete Hopfield discreta ed è caratterizzato come segue:

$$ E_ {f} \: = \: - \ frac {1} {2} \ displaystyle \ sum \ limits_ {i = 1} ^ n \ displaystyle \ sum \ limits_ {j = 1} ^ n y_ {i} y_ {j} w_ {ij} \: - \: \ displaystyle \ sum \ limits_ {i = 1} ^ n x_ {i} y_ {i} \: + \: \ displaystyle \ sum \ limits_ {i = 1} ^ n \ theta_ {i} y_ {i} $$

Condition - In una rete stabile, ogni volta che lo stato del nodo cambia, la funzione energetica di cui sopra diminuirà.

Supponiamo che quando node i ha cambiato stato da $ y_i ^ {(k)} $ a $ y_i ^ {(k \: + \: 1)} $ ⁡quindi la variazione di energia $ \ Delta E_ {f} $ è data dalla seguente relazione

$$ \ Delta E_ {f} \: = \: E_ {f} (y_i ^ {(k + 1)}) \: - \: E_ {f} (y_i ^ {(k)}) $$

$$ = \: - \ left (\ begin {array} {c} \ displaystyle \ sum \ limits_ {j = 1} ^ n w_ {ij} y_i ^ {(k)} \: + \: x_ {i} \: - \: \ theta_ {i} \ end {array} \ right) (y_i ^ {(k + 1)} \: - \: y_i ^ {(k)}) $$

$$ = \: - \ :( net_ {i}) \ Delta y_ {i} $$

Qui $ \ Delta y_ {i} \: = \: y_i ^ {(k \: + \: 1)} \: - \: y_i ^ {(k)} $

La variazione di energia dipende dal fatto che solo un'unità alla volta può aggiornare la sua attivazione.

Rete continua di Hopfield

In confronto alla rete discreta di Hopfield, la rete continua ha il tempo come variabile continua. Viene anche utilizzato nell'associazione automobilistica e nei problemi di ottimizzazione come il problema del venditore in viaggio.

Model - Il modello o l'architettura possono essere costruiti aggiungendo componenti elettrici come amplificatori che possono mappare la tensione di ingresso alla tensione di uscita su una funzione di attivazione del sigmoide.

Valutazione della funzione energetica

$$ E_f = \ frac {1} {2} \ displaystyle \ sum \ limits_ {i = 1} ^ n \ sum _ {\ substack {j = 1 \\ j \ ne i}} ^ n y_i y_j w_ {ij} - \ displaystyle \ sum \ limits_ {i = 1} ^ n x_i y_i + \ frac {1} {\ lambda} \ displaystyle \ sum \ limits_ {i = 1} ^ n \ sum _ {\ substack {j = 1 \\ j \ ne i}} ^ n w_ {ij} g_ {ri} \ int_ {0} ^ {y_i} a ^ {- 1} (y) dy $$

Qui λ è il parametro di guadagno e gri conduttanza di ingresso.

Questi sono processi di apprendimento stocastici con struttura ricorrente e sono la base delle prime tecniche di ottimizzazione utilizzate in ANN. La Boltzmann Machine è stata inventata da Geoffrey Hinton e Terry Sejnowski nel 1985. Si può osservare una maggiore chiarezza nelle parole di Hinton su Boltzmann Machine.

“Una caratteristica sorprendente di questa rete è che utilizza solo le informazioni disponibili localmente. Il cambiamento di peso dipende solo dal comportamento delle due unità che collega, anche se il cambiamento ottimizza una misura globale ”- Ackley, Hinton 1985.

Alcuni punti importanti sulla Boltzmann Machine -

  • Usano la struttura ricorrente.

  • Sono costituiti da neuroni stocastici, che hanno uno dei due stati possibili, 1 o 0.

  • Alcuni dei neuroni in questo sono adattivi (stato libero) e alcuni sono bloccati (stato congelato).

  • Se applichiamo la ricottura simulata su una rete Hopfield discreta, allora diventerebbe Boltzmann Machine.

Obiettivo della Boltzmann Machine

Lo scopo principale di Boltzmann Machine è ottimizzare la soluzione di un problema. È compito di Boltzmann Machine ottimizzare i pesi e la quantità relativi a quel particolare problema.

Architettura

Il diagramma seguente mostra l'architettura della macchina Boltzmann. È chiaro dal diagramma che si tratta di una matrice bidimensionale di unità. Qui, i pesi sulle interconnessioni tra le unità sono–p dove p > 0. I pesi delle auto-connessioni sono dati dab dove b > 0.

Algoritmo di formazione

Poiché sappiamo che le macchine Boltzmann hanno pesi fissi, quindi non ci sarà alcun algoritmo di addestramento poiché non è necessario aggiornare i pesi nella rete. Tuttavia, per testare la rete dobbiamo impostare i pesi e trovare la funzione di consenso (CF).

La macchina Boltzmann ha una serie di unità Ui e Uj e ha connessioni bidirezionali su di essi.

  • Stiamo considerando il peso fisso diciamo wij.

  • wij ≠ 0 Se Ui e Uj sono collegati.

  • Esiste anche una simmetria nell'interconnessione ponderata, ad es wij = wji.

  • wii esiste anche, cioè ci sarebbe l'auto-connessione tra le unità.

  • Per qualsiasi unità Ui, il suo stato ui potrebbe essere 1 o 0.

L'obiettivo principale di Boltzmann Machine è massimizzare la funzione di consenso (CF) che può essere data dalla seguente relazione

$$ CF \: = \: \ displaystyle \ sum \ limits_ {i} \ displaystyle \ sum \ limits_ {j \ leqslant i} w_ {ij} u_ {i} u_ {j} $$

Ora, quando lo stato cambia da 1 a 0 o da 0 a 1, il cambiamento di consenso può essere dato dalla seguente relazione:

$$ \ Delta CF \: = \ :( 1 \: - \: 2u_ {i}) (w_ {ij} \: + \: \ displaystyle \ sum \ limits_ {j \ neq i} u_ {i} w_ { ij}) $$

Qui ui è lo stato attuale di Ui.

La variazione del coefficiente (1 - 2ui) è dato dalla seguente relazione -

$$ (1 \: - \: 2u_ {i}) \: = \: \ begin {case} +1, & U_ {i} \: is \: currently \: off \\ - 1, & U_ {i } \: è \: attualmente \: on \ end {case} $$

Generalmente, unit Uinon cambia il proprio stato, ma in tal caso le informazioni risiederebbero localmente nell'unità. Con quel cambiamento, ci sarebbe anche un aumento del consenso della rete.

La probabilità della rete di accettare il cambiamento di stato dell'unità è data dalla seguente relazione:

$$ AF (i, T) \: = \: \ frac {1} {1 \: + \: exp [- \ frac {\ Delta CF (i)} {T}]} $$

Qui, Tè il parametro di controllo. Diminuirà quando la CF raggiunge il valore massimo.

Algoritmo di test

Step 1 - Inizializza quanto segue per iniziare la formazione -

  • Pesi che rappresentano il vincolo del problema
  • Parametro di controllo T

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

Step 3 - Eseguire i passaggi 4-7.

Step 4 - Supponi che uno degli stati abbia modificato il peso e scegli il numero intero I, J come valori casuali tra 1 e n.

Step 5 - Calcola la variazione del consenso come segue -

$$ \ Delta CF \: = \ :( 1 \: - \: 2u_ {i}) (w_ {ij} \: + \: \ displaystyle \ sum \ limits_ {j \ neq i} u_ {i} w_ { ij}) $$

Step 6 - Calcola la probabilità che questa rete accetti il ​​cambiamento di stato

$$ AF (i, T) \: = \: \ frac {1} {1 \: + \: exp [- \ frac {\ Delta CF (i)} {T}]} $$

Step 7 - Accetta o rifiuta questa modifica come segue -

Case I - se R < AF, accetta la modifica.

Case II - se R ≥ AF, rifiuta la modifica.

Qui, R è il numero casuale compreso tra 0 e 1.

Step 8 - Ridurre il parametro di controllo (temperatura) come segue -

T(new) = ⁡0.95T(old)

Step 9 - Verifica delle condizioni di arresto che possono essere le seguenti:

  • La temperatura raggiunge un valore specificato
  • Non vi è alcun cambiamento di stato per un numero specificato di iterazioni

La rete neurale Brain-State-in-a-Box (BSB) è una rete neurale auto-associativa non lineare e può essere estesa all'etero-associazione con due o più strati. È anche simile alla rete Hopfield. È stato proposto da JA Anderson, JW Silverstein, SA Ritz e RS Jones nel 1977.

Alcuni punti importanti da ricordare sulla rete BSB -

  • È una rete completamente connessa con il numero massimo di nodi a seconda della dimensionalità n dello spazio di input.

  • Tutti i neuroni vengono aggiornati contemporaneamente.

  • I neuroni assumono valori compresi tra -1 e +1.

Formulazioni matematiche

La funzione nodo utilizzata nella rete BSB è una funzione rampa, che può essere definita come segue:

$$ f (net) \: = \: min (1, \: max (-1, \: net)) $$

Questa funzione di rampa è limitata e continua.

Poiché sappiamo che ogni nodo cambierebbe il suo stato, può essere fatto con l'aiuto della seguente relazione matematica:

$$ x_ {t} (t \: + \: 1) \: = \: f \ left (\ begin {array} {c} \ displaystyle \ sum \ limits_ {j = 1} ^ n w_ {i, j } x_ {j} (t) \ end {array} \ right) $$

Qui, xi(t) è lo stato di ith nodo alla volta t.

Pesi da ith nodo a jth nodo può essere misurato con la seguente relazione -

$$ w_ {ij} \: = \: \ frac {1} {P} \ displaystyle \ sum \ limits_ {p = 1} ^ P (v_ {p, i} \: v_ {p, j}) $$

Qui, P è il numero di modelli di allenamento, che sono bipolari.

L'ottimizzazione è un'azione per rendere qualcosa come il design, la situazione, la risorsa e il sistema il più efficace possibile. Utilizzando una somiglianza tra la funzione di costo e la funzione di energia, possiamo utilizzare neuroni altamente interconnessi per risolvere problemi di ottimizzazione. Un tale tipo di rete neurale è la rete di Hopfield, che consiste in un singolo strato contenente uno o più neuroni ricorrenti completamente connessi. Questo può essere utilizzato per l'ottimizzazione.

Punti da ricordare durante l'utilizzo della rete Hopfield per l'ottimizzazione -

  • La funzione energetica deve essere minima della rete.

  • Troverà una soluzione soddisfacente piuttosto che selezionarne uno tra i modelli memorizzati.

  • La qualità della soluzione trovata dalla rete Hopfield dipende in modo significativo dallo stato iniziale della rete.

Problema del commesso viaggiatore

Trovare il percorso più breve percorso dal venditore è uno dei problemi di calcolo, che può essere ottimizzato utilizzando la rete neurale di Hopfield.

Concetto di base di TSP

Il problema del venditore in viaggio (TSP) è un classico problema di ottimizzazione in cui un venditore deve viaggiare ncittà, che sono collegate tra loro, mantenendo al minimo il costo e la distanza percorsa. Ad esempio, il venditore deve viaggiare un set di 4 città A, B, C, D e l'obiettivo è trovare il tour circolare più breve, ABC – D, in modo da ridurre al minimo il costo, che include anche il costo del viaggio da l'ultima città D alla prima città A.

Rappresentazione a matrice

In realtà ogni tour di n-città TSP può essere espresso come n × n matrice cui ith riga descrive il ithposizione della città. Questa matrice,M, per 4 città A, B, C, D può essere espresso come segue:

$$ M = \ begin {bmatrix} A: & 1 & 0 & 0 & 0 \\ B: & 0 & 1 & 0 & 0 \\ C: & 0 & 0 & 1 & 0 \\ D: & 0 & 0 & 0 & 1 \ end {bmatrix} $$

Soluzione di Hopfield Network

Pur considerando la soluzione di questo TSP da parte della rete Hopfield, ogni nodo della rete corrisponde a un elemento nella matrice.

Calcolo della funzione energetica

Per essere la soluzione ottimizzata, la funzione energetica deve essere minima. Sulla base dei seguenti vincoli, possiamo calcolare la funzione energetica come segue:

Vincolo-I

Il primo vincolo, sulla base del quale calcoleremo la funzione energetica, è che un elemento deve essere uguale a 1 in ogni riga della matrice M e gli altri elementi in ogni riga devono essere uguali a 0perché ogni città può trovarsi in una sola posizione nel tour TSP. Questo vincolo può essere matematicamente scritto come segue:

$$ \ displaystyle \ sum \ limits_ {j = 1} ^ n M_ {x, j} \: = \: 1 \: for \: x \: \ in \: \ lbrace1, ..., n \ rbrace $ $

Ora la funzione energetica da minimizzare, in base al vincolo di cui sopra, conterrà un termine proporzionale a -

$$ \ displaystyle \ sum \ limits_ {x = 1} ^ n \ left (\ begin {array} {c} 1 \: - \: \ displaystyle \ sum \ limits_ {j = 1} ^ n M_ {x, j } \ end {array} \ right) ^ 2 $$

Vincolo-II

Come sappiamo, in TSP una città può trovarsi in qualsiasi posizione del tour quindi in ogni colonna della matrice M, un elemento deve essere uguale a 1 e gli altri elementi devono essere uguali a 0. Questo vincolo può essere matematicamente scritto come segue:

$$ \ displaystyle \ sum \ limits_ {x = 1} ^ n M_ {x, j} \: = \: 1 \: for \: j \: \ in \: \ lbrace1, ..., n \ rbrace $ $

Ora la funzione energetica da minimizzare, in base al vincolo di cui sopra, conterrà un termine proporzionale a -

$$ \ displaystyle \ sum \ limits_ {j = 1} ^ n \ left (\ begin {array} {c} 1 \: - \: \ displaystyle \ sum \ limits_ {x = 1} ^ n M_ {x, j } \ end {array} \ right) ^ 2 $$

Calcolo della funzione di costo

Supponiamo che una matrice quadrata di (n × n) denotato da C denota la matrice dei costi di TSP per n città dove n > 0. Di seguito sono riportati alcuni parametri durante il calcolo della funzione di costo:

  • Cx, y - L'elemento della matrice dei costi indica il costo del viaggio dalla città x per y.

  • L'adiacenza degli elementi di A e B può essere mostrata dalla seguente relazione:

$$ M_ {x, i} \: = \: 1 \: \: e \: \: M_ {y, i \ pm 1} \: = \: 1 $$

Come sappiamo, in Matrix il valore di output di ogni nodo può essere 0 o 1, quindi per ogni coppia di città A, B possiamo aggiungere i seguenti termini alla funzione energia -

$$ \ displaystyle \ sum \ limits_ {i = 1} ^ n C_ {x, y} M_ {x, i} (M_ {y, i + 1} \: + \: M_ {y, i-1}) $$

Sulla base della funzione di costo e del valore di vincolo di cui sopra, la funzione energetica finale E può essere dato come segue:

$$ E \: = \: \ frac {1} {2} \ displaystyle \ sum \ limits_ {i = 1} ^ n \ displaystyle \ sum \ limits_ {x} \ displaystyle \ sum \ limits_ {y \ neq x} C_ {x, y} M_ {x, i} (M_ {y, i + 1} \: + \: M_ {y, i-1}) \: + $$

$$ \: \ begin {bmatrix} \ gamma_ {1} \ displaystyle \ sum \ limits_ {x} \ left (\ begin {array} {c} 1 \: - \: \ displaystyle \ sum \ limits_ {i} M_ {x, i} \ end {array} \ right) ^ 2 \: + \: \ gamma_ {2} \ displaystyle \ sum \ limits_ {i} \ left (\ begin {array} {c} 1 \: - \ : \ displaystyle \ sum \ limits_ {x} M_ {x, i} \ end {array} \ right) ^ 2 \ end {bmatrix} $$

Qui, γ1 e γ2 sono due costanti di pesatura.

Tecnica di discesa in gradiente iterata

La discesa del gradiente, nota anche come la discesa più ripida, è un algoritmo di ottimizzazione iterativo per trovare un minimo locale di una funzione. Pur riducendo al minimo la funzione, ci preoccupiamo del costo o dell'errore da minimizzare (Ricorda il problema del venditore in viaggio). È ampiamente utilizzato nell'apprendimento profondo, utile in un'ampia varietà di situazioni. Il punto da ricordare qui è che ci occupiamo di ottimizzazione locale e non di ottimizzazione globale.

Idea di lavoro principale

Possiamo comprendere l'idea di lavoro principale della discesa del gradiente con l'aiuto dei seguenti passaggi:

  • Innanzitutto, inizia con un'ipotesi iniziale della soluzione.

  • Quindi, prendi il gradiente della funzione in quel punto.

  • Successivamente, ripetere il processo portando la soluzione nella direzione negativa del gradiente.

Seguendo i passaggi precedenti, l'algoritmo finirà per convergere dove il gradiente è zero.

Concetto matematico

Supponiamo di avere una funzione f(x)e stiamo cercando di trovare il minimo di questa funzione. Di seguito sono riportati i passaggi per trovare il minimo dif(x).

  • Innanzitutto, dai un valore iniziale $ x_ {0} \: for \: x $

  • Ora prendi il gradiente $ \ nabla f $ ⁡ della funzione, con l'intuizione che il gradiente darà la pendenza della curva in quel punto x e la sua direzione punterà all'aumento della funzione, per trovare la direzione migliore per minimizzarla.

  • Ora cambia x come segue -

    $$ x_ {n \: + \: 1} \: = \: x_ {n} \: - \: \ theta \ nabla f (x_ {n}) $$

Qui, θ > 0 è la frequenza di allenamento (dimensione del passo) che forza l'algoritmo a fare piccoli salti.

Stima della dimensione del passo

In realtà una dimensione del passo sbagliata θpotrebbe non raggiungere la convergenza, quindi un'attenta selezione degli stessi è molto importante. I seguenti punti devono essere ricordati durante la scelta della dimensione del gradino

  • Non scegliere una dimensione del gradino troppo grande, altrimenti avrà un impatto negativo, ovvero divergerà anziché convergere.

  • Non scegliere dimensioni del gradino troppo piccole, altrimenti ci vuole molto tempo per convergere.

Alcune opzioni per quanto riguarda la scelta della dimensione del gradino -

  • Un'opzione è scegliere una dimensione del passo fissa.

  • Un'altra opzione è scegliere una dimensione del passo diversa per ogni iterazione.

Ricottura simulata

Il concetto di base della ricottura simulata (SA) è motivato dalla ricottura nei solidi. Nel processo di ricottura, se riscaldiamo un metallo al di sopra del suo punto di fusione e lo raffreddiamo, le proprietà strutturali dipenderanno dalla velocità di raffreddamento. Possiamo anche dire che SA simula il processo metallurgico di ricottura.

Utilizzare in ANN

SA è un metodo computazionale stocastico, ispirato all'analogia di Annealing, per approssimare l'ottimizzazione globale di una data funzione. Possiamo usare SA per addestrare reti neurali feed-forward.

Algoritmo

Step 1 - Genera una soluzione casuale.

Step 2 - Calcola il suo costo utilizzando alcune funzioni di costo.

Step 3 - Genera una soluzione adiacente casuale.

Step 4 - Calcola il nuovo costo della soluzione con la stessa funzione di costo.

Step 5 - Confronta il costo di una nuova soluzione con quello di una vecchia soluzione come segue -

Se CostNew Solution < CostOld Solution quindi passare alla nuova soluzione.

Step 6 - Test per la condizione di arresto, che può essere il numero massimo di iterazioni raggiunto o ottenere una soluzione accettabile.

La natura è sempre stata una grande fonte di ispirazione per tutta l'umanità. Gli algoritmi genetici (GA) sono algoritmi basati sulla ricerca basati sui concetti di selezione naturale e genetica. Gli GA sono un sottoinsieme di un ramo di calcolo molto più ampio noto comeEvolutionary Computation.

GA è stato sviluppato da John Holland e dai suoi studenti e colleghi presso l'Università del Michigan, in particolare David E. Goldberg, e da allora è stato provato su vari problemi di ottimizzazione con un alto grado di successo.

In GA, abbiamo un pool o una popolazione di possibili soluzioni al problema dato. Queste soluzioni poi subiscono ricombinazione e mutazione (come nella genetica naturale), producendo nuovi bambini, e il processo si ripete su varie generazioni. Ad ogni individuo (o soluzione candidata) viene assegnato un valore di fitness (in base al valore della sua funzione oggettiva) e agli individui più in forma viene data una maggiore possibilità di accoppiarsi e produrre individui più “in forma”. Ciò è in linea con la teoria darwiniana della "sopravvivenza del più adatto".

In questo modo, continuiamo a “far evolvere” individui o soluzioni migliori nel corso delle generazioni, fino a raggiungere un criterio di arresto.

Gli algoritmi genetici sono di natura sufficientemente casuale, tuttavia si comportano molto meglio della ricerca locale casuale (in cui proviamo solo varie soluzioni casuali, tenendo traccia delle migliori finora), poiché sfruttano anche le informazioni storiche.

Vantaggi delle GA

Gli GA hanno diversi vantaggi che li hanno resi immensamente popolari. Questi includono:

  • Non richiede alcuna informazione derivata (che potrebbe non essere disponibile per molti problemi del mondo reale).

  • È più veloce ed efficiente rispetto ai metodi tradizionali.

  • Ha ottime capacità parallele.

  • Ottimizza sia le funzioni continue e discrete che i problemi multi-obiettivo.

  • Fornisce un elenco di soluzioni "buone" e non solo una singola soluzione.

  • Ottiene sempre una risposta al problema, che migliora nel tempo.

  • Utile quando lo spazio di ricerca è molto ampio e il numero di parametri coinvolti è elevato.

Limitazioni di GA

Come ogni tecnica, anche le GA soffrono di alcune limitazioni. Questi includono:

  • Le GA non sono adatte a tutti i problemi, specialmente i problemi che sono semplici e per i quali sono disponibili informazioni derivate.

  • Il valore della forma fisica viene calcolato ripetutamente, il che potrebbe essere costoso dal punto di vista computazionale per alcuni problemi.

  • Essendo stocastico, non ci sono garanzie sull'ottimalità o sulla qualità della soluzione.

  • Se non implementato correttamente, GA potrebbe non convergere verso la soluzione ottimale.

GA - Motivazione

Gli algoritmi genetici hanno la capacità di fornire una soluzione "abbastanza buona" "abbastanza veloce". Ciò rende il gas interessante per la risoluzione dei problemi di ottimizzazione. I motivi per cui sono necessari GA sono i seguenti:

Risolvere problemi difficili

Nell'informatica, c'è una vasta serie di problemi, che sono NP-Hard. Ciò significa essenzialmente che anche i sistemi informatici più potenti impiegano molto tempo (anche anni!) Per risolvere il problema. In uno scenario del genere, le GA dimostrano di essere uno strumento efficiente da fornireusable near-optimal solutions in un breve lasso di tempo.

Fallimento dei metodi basati sul gradiente

I metodi tradizionali basati sul calcolo funzionano partendo da un punto casuale e muovendosi nella direzione del gradiente, fino a raggiungere la cima della collina. Questa tecnica è efficiente e funziona molto bene per le funzioni obiettivo a picco singolo come la funzione di costo nella regressione lineare. Tuttavia, nella maggior parte delle situazioni del mondo reale, abbiamo un problema molto complesso chiamato paesaggi, fatto di molti picchi e molte valli, che causa il fallimento di tali metodi, poiché soffrono di una tendenza intrinseca a rimanere bloccati all'ottimo locale come mostrato nella figura seguente.

Ottenere rapidamente una buona soluzione

Alcuni problemi difficili come il problema del venditore in viaggio (TSP), hanno applicazioni del mondo reale come la ricerca di percorsi e la progettazione VLSI. Ora immagina di utilizzare il tuo sistema di navigazione GPS e ci vogliono pochi minuti (o anche poche ore) per calcolare il percorso "ottimale" dalla sorgente alla destinazione. Il ritardo in tali applicazioni del mondo reale non è accettabile e quindi una soluzione "abbastanza buona", che viene fornita "velocemente" è ciò che è richiesto.

Come utilizzare GA per problemi di ottimizzazione?

Sappiamo già che l'ottimizzazione è un'azione per rendere qualcosa come il design, la situazione, la risorsa e il sistema il più efficace possibile. Il processo di ottimizzazione è mostrato nel diagramma seguente.

Fasi del meccanismo GA per il processo di ottimizzazione

Le seguenti sono le fasi del meccanismo GA quando viene utilizzato per l'ottimizzazione dei problemi.

  • Genera la popolazione iniziale in modo casuale.

  • Seleziona la soluzione iniziale con i migliori valori di fitness.

  • Ricombinare le soluzioni selezionate utilizzando operatori di mutazione e crossover.

  • Inserire la prole nella popolazione.

  • Ora, se la condizione di arresto è soddisfatta, restituisci la soluzione con il miglior valore di fitness. Altrimenti, vai al passaggio 2.

Prima di studiare i campi in cui la RNA è stata ampiamente utilizzata, dobbiamo capire perché la RNA sarebbe la scelta di applicazione preferita.

Perché le reti neurali artificiali?

Dobbiamo comprendere la risposta alla domanda precedente con un esempio di essere umano. Da bambini imparavamo le cose con l'aiuto dei nostri anziani, compresi i nostri genitori o insegnanti. Poi in seguito, tramite l'autoapprendimento o la pratica, continuiamo ad imparare per tutta la vita. Scienziati e ricercatori stanno anche rendendo la macchina intelligente, proprio come un essere umano, e la ANN svolge un ruolo molto importante nella stessa per i seguenti motivi:

  • Con l'aiuto delle reti neurali, possiamo trovare la soluzione di tali problemi per i quali il metodo algoritmico è costoso o non esiste.

  • Le reti neurali possono apprendere con l'esempio, quindi non abbiamo bisogno di programmarle molto.

  • Le reti neurali hanno la precisione e una velocità notevolmente elevata rispetto alla velocità convenzionale.

Aree di applicazione

Di seguito sono riportate alcune delle aree in cui viene utilizzata ANN. Suggerisce che ANN abbia un approccio interdisciplinare nello sviluppo e nelle applicazioni.

Riconoscimento vocale

La parola occupa un ruolo di primo piano nell'interazione uomo-uomo. Pertanto, è naturale che le persone si aspettino interfacce vocali con i computer. Nell'era attuale, per comunicare con le macchine, gli esseri umani hanno ancora bisogno di linguaggi sofisticati che sono difficili da imparare e da usare. Per allentare questa barriera di comunicazione, una soluzione semplice potrebbe essere, la comunicazione in una lingua parlata che è possibile per la macchina capire.

Sono stati fatti grandi progressi in questo campo, tuttavia, tali tipi di sistemi stanno ancora affrontando il problema del vocabolario o della grammatica limitati insieme al problema della riqualificazione del sistema per diversi parlanti in condizioni diverse. L'ANN sta giocando un ruolo importante in questo settore. Le seguenti ANN sono state utilizzate per il riconoscimento vocale:

  • Reti multistrato

  • Reti multistrato con connessioni ricorrenti

  • Mappa delle caratteristiche auto-organizzanti di Kohonen

La rete più utile per questo è la mappa delle funzioni auto-organizzanti Kohonen, che ha il suo ingresso come brevi segmenti della forma d'onda del parlato. Mapperà lo stesso tipo di fonemi dell'array di output, chiamato tecnica di estrazione delle caratteristiche. Dopo aver estratto le caratteristiche, con l'aiuto di alcuni modelli acustici come elaborazione di back-end, riconoscerà l'enunciato.

Riconoscimento dei caratteri

È un problema interessante che rientra nell'area generale del Pattern Recognition. Molte reti neurali sono state sviluppate per il riconoscimento automatico dei caratteri scritti a mano, lettere o cifre. Di seguito sono riportate alcune ANN che sono state utilizzate per il riconoscimento dei caratteri:

  • Reti neurali multistrato come reti neurali di backpropagation.
  • Neocognitron

Sebbene le reti neurali di retro propagazione abbiano diversi livelli nascosti, lo schema di connessione da uno strato a quello successivo è localizzato. Allo stesso modo, il neocognitron ha anche diversi strati nascosti e la sua formazione viene eseguita strato per strato per questo tipo di applicazioni.

Domanda di verifica della firma

Le firme sono uno dei modi più utili per autorizzare e autenticare una persona nelle transazioni legali. La tecnica di verifica della firma è una tecnica non basata sulla visione.

Per questa applicazione, il primo approccio consiste nell'estrarre la feature o piuttosto l'insieme di feature geometriche che rappresenta la firma. Con questi set di funzionalità, dobbiamo addestrare le reti neurali utilizzando un algoritmo di rete neurale efficiente. Questa rete neurale addestrata classificherà la firma come autentica o falsificata durante la fase di verifica.

Riconoscimento del volto umano

È uno dei metodi biometrici per identificare il viso dato. È un compito tipico a causa della caratterizzazione delle immagini "senza volto". Tuttavia, se una rete neurale è ben addestrata, può essere divisa in due classi, ovvero immagini con volti e immagini che non hanno volti.

Innanzitutto, tutte le immagini di input devono essere preelaborate. Quindi, la dimensionalità di quell'immagine deve essere ridotta. E, infine, deve essere classificato utilizzando l'algoritmo di addestramento della rete neurale. Le seguenti reti neurali vengono utilizzate per scopi di addestramento con immagini preelaborate:

  • Rete neurale feed-forward multistrato completamente connessa addestrata con l'aiuto dell'algoritmo di propagazione all'indietro.

  • Per la riduzione della dimensionalità, viene utilizzata l'analisi dei componenti principali (PCA).