Traduttore con LSTM

Ecco i Passi del codice

• importare i moduli necessari




• creare un vocabolario

  qui molto limitato, ma si possono aggiungere tutte le parole che si vuole



• tokenizzazione del vocabolario

  La funzione tokenizer_eng.texts_to_sequences(vocabolario['Inglese']) converte la lista delle parole inglesi nel vocabolario in una lista di sequenze di numeri interi corrispondenti alle parole.
  
  Ad esempio, se abbiamo un Tokenizer con il seguente dizionario delle parole:

  
  {'hello': 1, 'world': 2, 'cat': 3, ...}
  
   

  
  Passando una lista di testi ['hello', 'cat'], la funzione texts_to_sequences restituirà la lista [1, 3], poiché 'hello' ha l'indice 1 nel dizionario e 'cat' ha l'indice 3.



• Padding delle sequenze

  L'istruzione X = pad_sequences(X, maxlen=maxlen, padding='post') esegue il padding delle sequenze nell'array X in modo che abbiano tutte la stessa lunghezza. Ad esempio, se abbiamo la seguente matrice X prima del padding:
  

  
  
  
  [[1, 2, 3],
   [4, 5],
   [6, 7, 8, 9]]
   
  
  

  
  L'istruzione X = pad_sequences(X, maxlen=maxlen, padding='post') esegue il padding delle sequenze nell'array X in modo che abbiano tutte la stessa lunghezza.

  
  [[1, 2, 3, 0],
   [4, 5, 0, 0],
   [6, 7, 8, 9]]
  
  
  




• Codifica one-hot per l'output

  y è una matrice di sequenze di numeri interi, dove ogni numero intero rappresenta l'indice di una parola nel vocabolario italiano.
  np.eye(vocab_size_ita)[y], sostituisce ogni numero intero in y con la riga corrispondente dalla matrice identità.
  In pratica, converte ogni indice di parola in una rappresentazione one-hot della parola.
  
  Ad esempio, supponiamo che abbiamo il seguente array y prima della codifica one-hot:
  

  
  [[2],
   [5],
   [3]]
  
      

  
  l'istruzione lo modifica
  

  
  [[0, 0, 1, 0, 0, 0, 0],
   [0, 0, 0, 0, 0, 1, 0],
   [0, 0, 0, 1, 0, 0, 0]]
  
  
      




• Definizione del modello LSTM,valutazione dati test

  
  Ecco una spiegazione più dettagliata delle istruzioni nel codice relative al modello LSTM:
  

  Embedding Layer

  - L'istruzione `model.add(Embedding(vocab_size_eng, embedding_dim, input_length=maxlen))` aggiunge un layer di embedding alla rete neurale.
  - Questo layer converte gli indici delle parole in vettori densi di dimensione `embedding_dim`.
  - `vocab_size_eng` è la dimensione del vocabolario inglese, ovvero il numero totale di parole nel vocabolario.
  - `embedding_dim` è la dimensione dello spazio di embedding, ovvero la dimensione dei vettori di embedding.
  - `input_length=maxlen` specifica la lunghezza massima delle sequenze di input, ovvero la lunghezza delle sequenze di parole dopo il padding.
  
  

  LSTM Layer

  - L'istruzione `model.add(LSTM(128, return_sequences=True))` aggiunge uno strato LSTM alla rete neurale.
  - Questo strato contiene 128 unità LSTM e restituisce le sequenze di output per ciascun passaggio temporale (`return_sequences=True`).
  - Le unità LSTM gestiscono il flusso di informazioni e mantengono lo stato interno della rete durante l'elaborazione delle sequenze.
  
  

  Dense Layer

  - L'istruzione `model.add(Dense(vocab_size_ita, activation='softmax'))` aggiunge uno strato denso alla rete neurale.
  - Questo strato ha un numero di nodi pari alla dimensione del vocabolario italiano (`vocab_size_ita`).
  - L'attivazione softmax viene utilizzata per ottenere una distribuzione di probabilità sugli output possibili, consentendo al modello di generare previsioni sulla parola italiana corrispondente.
  
  

  Compilazione del Modello

  - L'istruzione `model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])` compila il modello.
  - Si specifica l'ottimizzatore `'adam'`, la funzione di perdita `'categorical_crossentropy'` e la metrica di valutazione `'accuracy'`.
  
  

  Addestramento del Modello

  - L'istruzione `history = model.fit(X_train, y_train, epochs=50, validation_data=(X_test, y_test), verbose=2)` addestra il modello.
  - Il modello viene addestrato sui dati di training `X_train` e `y_train` per 50 epoche.
  - I dati di validazione `X_test` e `y_test` vengono utilizzati per monitorare le prestazioni del modello durante l'addestramento.
  - L'argomento `verbose=2` specifica il livello di verbosità durante l'addestramento, stampando dettagli su ogni epoca.
  



• Predizione della traduzione di una parola italiana inserita
  

  L'istruzione word = input().lower() è utilizzata per acquisire una parola dall'input dell'utente tramite la funzione input().
  La funzione lower() applicata alla stringa risultante converte tutte le lettere della parola in minuscolo
  
  
  • `word_seq = tokenizer_ita.texts_to_sequences([word])[0]`:
    - `tokenizer_ita.texts_to_sequences([word])` converte la parola italiana (`word`) in una sequenza di numeri interi utilizzando il tokenizer italiano.
    - `[0]` viene utilizzato per accedere alla prima sequenza nella lista risultante. Poiché `texts_to_sequences` restituisce una lista di sequenze, ma qui viene trattata solo una parola, possiamo accedere direttamente alla sequenza usando l'indice 0.
    Il risultato è una sequenza di token che rappresenta la parola italiana.
    
  
  
  • `word_seq = pad_sequences([word_seq], maxlen=maxlen, padding='post')`:
    - `pad_sequences` viene utilizzato per aggiungere il padding alla sequenza di token italiana.
    - `[word_seq]` è una lista contenente la sequenza di token italiana.
    - `maxlen` è la lunghezza massima delle sequenze, che è stata utilizzata anche durante l'addestramento del modello per garantire che tutte le sequenze abbiano la stessa lunghezza.
    - `padding='post'` specifica che il padding viene aggiunto alla fine della sequenza.
    Il risultato è una sequenza di token italiana con il padding applicato.
    
  
  
  • `translated_seq = model.predict(word_seq)`:
    - `model.predict` viene utilizzato per fare una previsione sulla traduzione della parola italiana.
    - `word_seq` è la sequenza di token italiana con il padding applicato.
    Il risultato è una distribuzione di probabilità sugli output possibili, che rappresenta la traduzione prevista della parola italiana in termini di token inglese.
    
  
  
  • `translated_word = tokenizer_eng.sequences_to_texts(np.argmax(translated_seq, axis=-1))[0]`:
    - `np.argmax(translated_seq, axis=-1)` viene utilizzato per ottenere l'indice del token con la probabilità più alta per ciascuna parola nella sequenza prevista.
    - `tokenizer_eng.sequences_to_texts` viene utilizzato per convertire gli indici dei token in parole inglesi utilizzando il tokenizer inglese.
    - `[0]` viene utilizzato per accedere alla prima parola nella lista risultante, poiché qui viene tradotta solo una parola italiana.
    Il risultato è la traduzione prevista della parola italiana in inglese.