Risoluzione di equazioni matematiche di base utilizzando RNN [con esempio di codifica]

Se la vita ti dà RNN, crea una calcolatrice

Una rete neurale ricorrente è una delle classiche reti neurali artificiali, in cui le connessioni tra i nodi formano un grafo sequenziale diretto. Gli RNN sono famosi per applicazioni come il riconoscimento vocale, il riconoscimento della grafia, ecc. a causa della loro memoria di stato interna per l'elaborazione di sequenze di lunghezza variabile.

Gli RNN sono ulteriormente classificati in due tipi. Il primo è un impulso finito la cui rete neurale ha la forma di un grafo aciclico diretto in cui un nodo può essere connesso con uno o più nodi che sono avanti senza alcun ciclo visibile nella rete. Un altro è un impulso infinito la cui rete neurale ha la forma di un grafo ciclico diretto che non può essere svolto in una rete neurale feed-forward.

Cosa faremo?

Costruiamo un modello che predice l'output di un'espressione aritmetica. Ad esempio, se fornisco un input "11+88", il modello dovrebbe prevedere la parola successiva nella sequenza come "99". L'input e l'output sono una sequenza di caratteri poiché un RNN si occupa di dati sequenziali.

Ora la progettazione dell'architettura del modello sembra un compito semplice rispetto alla raccolta di set di dati. La generazione di dati o la raccolta di set di dati è un compito faticoso perché i modelli di intelligenza artificiale per la fame di dati richiedono una discreta quantità di dati per un'accuratezza accettabile.

Quindi questo modello può essere implementato in 6 passaggi fondamentali:

1. Generazione di dati
2. Costruire un modello
3. Vettorizzazione e Devettorizzazione dei dati
4. Realizzazione di un set di dati
5. Allenare il modello
6. Testare il modello

Prima di immergerci nell'implementazione del modello, importiamo semplicemente tutte le librerie richieste.

1. Generazione di dati

Definiamo una stringa di caratteri contenente tutti i caratteri necessari per scrivere un'equazione aritmetica di base. Quindi, la stringa è composta da tutti i caratteri da 0 a 9 e da tutti gli operatori aritmetici come /, *, +, -, .(decimale).

Non possiamo inserire direttamente i dati numerici nel nostro modello, dobbiamo passare i dati sotto forma di tensori. La conversione della stringa nei dati in un vettore codificato one-hot ci darà prestazioni del modello ottimizzate. Un vettore codificato one-hot è un array con una lunghezza uguale alla lunghezza della nostra stringa di caratteri, ogni vettore one-hot ne ha uno solo al rispettivo indice di carattere presente in ciascuna stringa.

Ad esempio, supponiamo che la nostra stringa di caratteri sia '0123456789', e se vogliamo codificare una stringa come '12', il vettore one-hot sarebbe [ [0,1,0,0,0,0,0,0 ,0,0], [0,0,1,0,0,0,0,0,0,0] ]. Per fare ciò dobbiamo creare due dizionari con un indice come chiavi e caratteri come valori e l'altro come viceversa.

Ora scriviamo una funzione che restituisce un'equazione aritmetica casuale insieme al risultato di tale equazione.

Leggi anche: Idee interessanti per progetti di reti neurali

2. Costruire un modello

Il modello avrà un codificatore e un decoder. L'encoder è un semplice modello RNN con forma di input come (Nessuno,num_chars) e 128 unità nascoste, il motivo per cui scegliamo unità nascoste come 32,64,128, ecc è dovuto alle migliori prestazioni della CPU o della GPU con unità nascoste come potenze di 2.

Il nostro codificatore sarà una rete completamente connessa e l'output di questi verrà reimmesso nella rete, ecco come funziona un RNN. Un livello RNN utilizza l'attivazione "tanh" per impostazione predefinita, non cambieremo perché si adatta meglio all'encoder. L'output di questo livello sarà un singolo vettore e per ottenere un singolo vettore dell'intero output utilizzeremo il livello RepeatVector() con il numero di volte richiesto come parametro.

Ora il vettore di output avrà l'essenza dell'input fornito e questo vettore verrà inserito nel decodificatore.

Il decodificatore è composto da un semplice livello RNN e questo genererà la sequenza di output poiché abbiamo bisogno del livello RNN per restituire la sequenza prevista che contrassegneremo 'return_sequences' come True. Assegnando 'return_sequences' come True, il livello RNN restituirà la sequenza prevista per ogni passaggio temporale (da molti a molti RNN).

L'output di questo livello RNN viene inserito in uno strato Denso con il numero 'num_chars' di unità nascoste e useremo l'attivazione softmax poiché abbiamo bisogno della probabilità di ogni carattere. Prima di distribuire un livello Dense, è necessario ridurre questo livello in un livello TimeDistributed perché è necessario distribuire il livello Dense per l'output di ogni passaggio temporale.

L'architettura del modello sarà quella mostrata sopra

Da leggere: Tutorial sulle reti neurali

3. Vettorizzazione e Devettorizzazione dei Dati

Definiamo le funzioni per vettorizzare e devettorizzare i dati.

Ecco la funzione per vettorizzare insieme l'espressione aritmetica e il risultato.

def vettorizzare (arith, res): x = np.zeros((max_time_steps, num_chars)) y = np.zeros((max_time_steps, num_chars)) x_remaining = max_time_steps – len (arith) y_remaining = max_time_steps – len (res) per i, c in enumerare (arit): x[x_rimanente + i, da_carattere a_indice[c]] = 1 per i nell'intervallo (x_remaining) : x[i, carattere_a_indice[ ' 0 ' ]] = 1 per i, c in enumerare (res): y[y_remaining + i, character_to_index[c]] = 1 per i nell'intervallo (y_remaining) : y[i, carattere_a_indice[ ' 0 ' ]] = 1 restituire x, y

Allo stesso modo ecco la funzione per de-vettorizzare la stringa. Poiché l'output che riceviamo è un vettore di probabilità, utilizzeremo np.argmax() per selezionare il carattere con la probabilità più alta. Ora il dizionario index_to_character viene utilizzato per risalire al carattere in quell'indice.

Ora il vincolo che abbiamo con la funzione 'devectorize' è che riempirà i caratteri finali con zeri. Ad esempio, se il vettore di input è ('1-20', '-19'), l'output devettorizzato sarà ('01-20', '00-19'). Dobbiamo prenderci cura di questi zeri extra imbottiti. Scriviamo una funzione per lo stripping della stringa.

4. Creazione di un set di dati

Ora che abbiamo finito di definire una funzione per generare i dati, usiamo quella funzione e creiamo un set di dati con molte di queste coppie (espressione aritmetica, risultato).

5. Formazione del Modello

Creiamo un set di dati di 50.000 campioni che è un numero equo per addestrare il nostro modello di fame di dati, utilizzeremo il 25% di questi dati per la convalida. Inoltre, creiamo una richiamata per l'interruzione intelligente dell'allenamento se la precisione rimane invariata per 8 epoche. Questo può essere ottenuto impostando il parametro pazienza su 8.

6. Testare il Modello

Ora testiamo il nostro modello creando un set di dati della dimensione 30.

L'output sarà il seguente

Possiamo vedere che la precisione è un po' scarsa qui, comunque possiamo ottimizzarla modificando alcuni iperparametri come il numero di unità nascoste, la divisione di convalida, il numero di epoche, ecc.

Conclusione

Abbiamo compreso il flusso di lavoro di base di un RNN, capito che gli RNN sono più adatti per dati sequenziali, generato un set di dati di equazioni aritmetiche casuali, sviluppato un modello sequenziale per prevedere l'output di un'espressione aritmetica di base, addestrato quel modello con il set di dati che abbiamo creato e infine testato quel modello con un piccolo set di dati che il modello non aveva mai visto prima.

Se sei interessato a saperne di più su RNN, machine learning, dai un'occhiata al Diploma PG di IIIT-B e upGrad in Machine Learning e AI, progettato per i professionisti che lavorano e offre oltre 450 ore di formazione rigorosa, oltre 30 casi di studio e incarichi, Status di Alumni IIIT-B, oltre 5 progetti pratici pratici e assistenza sul lavoro con le migliori aziende.