Come creare una RNN da zero con PyTorch - Cronologia

Lucia Terenzi il 08:51, 19 mar 2024

2024-03-19T08:51:45Z

← Versione meno recente		Versione delle 08:51, 19 mar 2024
Riga 1:		Riga 1:
	== Obiettivo ==		== Obiettivo ==
	Proviamo a creare una [[Recurrent Neural Network (RNN)]] che, dato un carattere tra a,b,c,d, lo continui secondo il pattern: 'aaaaabbbbbccccacdddddaaaa'		Proviamo a creare una [[Recurrent Neural Network (RNN)]] che, dato un carattere tra a,b,c,d, lo continui secondo il pattern: 'aaaaabbbbbccccacdddddaaaa'.

	[https://colab.research.google.com/drive/19170dxpBowW0tGGDjMThKwDNqxVPlf_p?usp=sharing Qui] trovi il Colab!		[https://colab.research.google.com/drive/19170dxpBowW0tGGDjMThKwDNqxVPlf_p?usp=sharing Qui] trovi il Colab!

Lucia Terenzi il 08:51, 19 mar 2024

2024-03-19T08:51:36Z

← Versione meno recente		Versione delle 08:51, 19 mar 2024
Riga 1:		Riga 1:
	== Obiettivo ==		== Obiettivo ==
	Proviamo a creare una [[Recurrent Neural Network (RNN)]] che, dato un carattere tra a,b,c,d, lo continui secondo il pattern: 'aaaaabbbbbccccacdddddaaaa'		Proviamo a creare una [[Recurrent Neural Network (RNN)]] che, dato un carattere tra a,b,c,d, lo continui secondo il pattern: 'aaaaabbbbbccccacdddddaaaa'

			[https://colab.research.google.com/drive/19170dxpBowW0tGGDjMThKwDNqxVPlf_p?usp=sharing Qui] trovi il Colab!

	== Importiamo le librerie: ==		== Importiamo le librerie: ==

Lucia Terenzi: /* Funzione per generare una sequenza in maniera autoregressiva */

2024-03-15T11:54:33Z

Funzione per generare una sequenza in maniera autoregressiva

← Versione meno recente		Versione delle 11:54, 15 mar 2024
Riga 123:		Riga 123:
	== Funzione per generare una sequenza in maniera autoregressiva ==		== Funzione per generare una sequenza in maniera autoregressiva ==
	def generate_seq(start_char='a', length=20):		def generate_seq(start_char='a', length=20):
			hidden = model.init_hidden()
	hidden = model.init_hidden()		input = char_to_onehot(start_char)

	input = char_to_onehot(start_char)
	Questa è la lista di caratteri in output		Questa è la lista di caratteri in output
	output_seq = start_char		output_seq = start_char
			for i in range(length-1):
	for i in range(length-1):
	Anche qui unsqueeze:		Anche qui unsqueeze:
	input_tensor = input.unsqueeze(0).unsqueeze(0)		input_tensor = input.unsqueeze(0).unsqueeze(0)
			output, hidden = model(input_tensor, hidden)
	output, hidden = model(input_tensor, hidden)
	Prendiamo direttamente la posizione col valore massimo dei logit		Prendiamo direttamente la posizione col valore massimo dei logit
	predicted_char_idx = torch.argmax(output).item()		predicted_char_idx = torch.argmax(output).item()
			predicted_char = ix_to_char[predicted_char_idx]
	predicted_char = ix_to_char[predicted_char_idx]
	Accodiamo il carattere alla sequenza		Accodiamo il carattere alla sequenza
	output_seq += predicted_char		output_seq += predicted_char

Lucia Terenzi: /* Inizializzazione dell'Architettura */

2024-03-15T11:53:47Z

Inizializzazione dell'Architettura

Mostra modifiche

Lucia Terenzi: /* Prepariamo l'input */

2024-03-13T16:22:29Z

Prepariamo l'input

← Versione meno recente		Versione delle 16:22, 13 mar 2024
Riga 45:		Riga 45:
	# <code>sequence[:-1]</code>: Questo prende tutti i caratteri della sequenza tranne l'ultimo. Se la sequenza fosse "abcde", diventerebbe "abcd". Questo è perché si vuole prevedere il carattere successivo in ogni punto della sequenza, quindi l'ultimo carattere non può essere usato come input.		# <code>sequence[:-1]</code>: Questo prende tutti i caratteri della sequenza tranne l'ultimo. Se la sequenza fosse "abcde", diventerebbe "abcd". Questo è perché si vuole prevedere il carattere successivo in ogni punto della sequenza, quindi l'ultimo carattere non può essere usato come input.
	# <code>char_to_onehot(ch)</code>: Per ogni carattere nella sequenza troncata, questa funzione lo trasforma in un vettore "one-hot". Immagina di avere un alfabeto di solo 5 lettere (a, b, c, d, e). La lettera "a" potrebbe essere rappresentata come [1, 0, 0, 0, 0], la "b" come [0, 1, 0, 0, 0], e così via. Ogni carattere diventa un vettore dove un "1" indica quel carattere, e tutto il resto è "0".		# <code>char_to_onehot(ch)</code>: Per ogni carattere nella sequenza troncata, questa funzione lo trasforma in un vettore "one-hot". Immagina di avere un alfabeto di solo 5 lettere (a, b, c, d, e). La lettera "a" potrebbe essere rappresentata come [1, 0, 0, 0, 0], la "b" come [0, 1, 0, 0, 0], e così via. Ogni carattere diventa un vettore dove un "1" indica quel carattere, e tutto il resto è "0".
	# <code>torch.stack([...])</code>: Dopo aver trasformato ogni carattere in un vettore one-hot, <code>torch.stack</code> mette tutti questi vettori uno sopra l'altro in un unico array (o tensore), creando una sorta di "lista di liste" ma in forma di tensore, che è il formato richiesto per lavorare con PyTorch.		# <code>torch.stack([...])</code>: Dopo aver trasformato ogni carattere in un vettore one-hot, <code>torch.stack</code> mette tutti questi vettori uno sopra l'altro in un unico array (o tensore), creando una sorta di "lista di liste" ma in forma di tensore, che è il formato richiesto per lavorare con PyTorch. Tutti i tensori per essere concatenati in un'unico tensore devono avere la stessa dimensione.

	Quando si usa [[CrossEntropyLoss]] di [[PyTorch]], l'output atteso è l'indice della classe target, non la rappresentazione one-hot.		Quando si usa [[CrossEntropyLoss]] di [[PyTorch]], l'output atteso è l'indice della classe target, non la rappresentazione one-hot.

Lucia Terenzi: /* Prepariamo l'input */

2024-03-13T15:58:49Z

Prepariamo l'input

← Versione meno recente		Versione delle 15:58, 13 mar 2024
Riga 41:		Riga 41:
	Creiamo una lista di M (numero di CAMPIONI di training) x N (Numero di token nel vocabolario one-hot)		Creiamo una lista di M (numero di CAMPIONI di training) x N (Numero di token nel vocabolario one-hot)
	inputs = torch.stack([char_to_onehot(ch) for ch in sequence[:-1]])		inputs = torch.stack([char_to_onehot(ch) for ch in sequence[:-1]])
			Quello che fa questa riga di codice in breve è richiamare la funzione che converte gli elementi della sequenza in one-hot, prendere tutti gli elementi della sequenza meno l'ultimo carattere e convertirli quindi in one hot. Torch.stack

			# <code>sequence[:-1]</code>: Questo prende tutti i caratteri della sequenza tranne l'ultimo. Se la sequenza fosse "abcde", diventerebbe "abcd". Questo è perché si vuole prevedere il carattere successivo in ogni punto della sequenza, quindi l'ultimo carattere non può essere usato come input.
			# <code>char_to_onehot(ch)</code>: Per ogni carattere nella sequenza troncata, questa funzione lo trasforma in un vettore "one-hot". Immagina di avere un alfabeto di solo 5 lettere (a, b, c, d, e). La lettera "a" potrebbe essere rappresentata come [1, 0, 0, 0, 0], la "b" come [0, 1, 0, 0, 0], e così via. Ogni carattere diventa un vettore dove un "1" indica quel carattere, e tutto il resto è "0".
			# <code>torch.stack([...])</code>: Dopo aver trasformato ogni carattere in un vettore one-hot, <code>torch.stack</code> mette tutti questi vettori uno sopra l'altro in un unico array (o tensore), creando una sorta di "lista di liste" ma in forma di tensore, che è il formato richiesto per lavorare con PyTorch.

	Quando si usa [[CrossEntropyLoss]] di [[PyTorch]], l'output atteso è l'indice della classe target, non la rappresentazione one-hot.		Quando si usa [[CrossEntropyLoss]] di [[PyTorch]], l'output atteso è l'indice della classe target, non la rappresentazione one-hot.

Lucia Terenzi il 15:11, 13 mar 2024

2024-03-13T15:11:15Z

← Versione meno recente		Versione delle 15:11, 13 mar 2024
Riga 38:		Riga 38:
	[0., 0., 0., 0., 1.],		[0., 0., 0., 0., 1.],

			== Prepariamo l'input ==
	Creiamo una lista di M (numero di CAMPIONI di training) x N (Numero di token nel vocabolario one-hot)		Creiamo una lista di M (numero di CAMPIONI di training) x N (Numero di token nel vocabolario one-hot)
	inputs = torch.stack([char_to_onehot(ch) for ch in sequence[:-1]])		inputs = torch.stack([char_to_onehot(ch) for ch in sequence[:-1]])

Lucia Terenzi il 14:47, 13 mar 2024

2024-03-13T14:47:17Z

← Versione meno recente		Versione delle 14:47, 13 mar 2024
Riga 38:		Riga 38:
	[0., 0., 0., 0., 1.],		[0., 0., 0., 0., 1.],

			Creiamo una lista di M (numero di CAMPIONI di training) x N (Numero di token nel vocabolario one-hot)
			inputs = torch.stack([char_to_onehot(ch) for ch in sequence[:-1]])
	Quando si usa [[CrossEntropyLoss]] di [[PyTorch]], l'output atteso è l'indice della classe target, non la rappresentazione one-hot.		Quando si usa [[CrossEntropyLoss]] di [[PyTorch]], l'output atteso è l'indice della classe target, non la rappresentazione one-hot.

	CrossEntropyLoss combina LogSoftmax e NLLLoss (Negative Log Likelihood Loss) in un'unica classe. Questa funzione si aspetta ~~logits~~ non normalizzati come input (cioè, l'output grezzo del modello prima dell'applicazione di una funzione di attivazione come [[Softmax]] e l'indice della classe come target. PyTorch gestisce internamente la conversione degli indici in una rappresentazione one-hot e l'applicazione della Softmax per calcolare la perdita, il che rende l'uso di CrossEntropyLoss più efficiente dal punto di vista computazionale rispetto al calcolo manuale di Softmax seguito da una funzione di perdita come NLLLoss su output one-hot.		CrossEntropyLoss combina LogSoftmax e NLLLoss (Negative Log Likelihood Loss) in un'unica classe. Questa funzione si aspetta [[Logit (Reti Neurali)\|Logit]] non normalizzati come input (cioè, l'output grezzo del modello prima dell'applicazione di una funzione di attivazione come [[Softmax]]) e l'indice della classe come target. PyTorch gestisce internamente la conversione degli indici in una rappresentazione one-hot e l'applicazione della Softmax per calcolare la perdita, il che rende l'uso di CrossEntropyLoss più efficiente dal punto di vista computazionale rispetto al calcolo manuale di Softmax seguito da una funzione di perdita come NLLLoss su output one-hot.
			targets = torch.tensor([char_to_ix[ch] for ch in sequence[1:]], dtype=torch.long)
			tensor([4, 4, 4, 4, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 1])

	== Inizializzazione dell'Architettura ==		== Inizializzazione dell'Architettura ==

Lucia Terenzi: /* Mappatura Caratteri-indici: */

2024-03-13T12:03:30Z

Mappatura Caratteri-indici:

← Versione meno recente		Versione delle 12:03, 13 mar 2024
Riga 19:		Riga 19:
	char_to_ix = {ch: i for i, ch in enumerate(chars)} # {'b': 0, 's': 1, 'c': 2, 'd': 3, 'a': 4}		char_to_ix = {ch: i for i, ch in enumerate(chars)} # {'b': 0, 's': 1, 'c': 2, 'd': 3, 'a': 4}
	ix_to_char = {i: ch for i, ch in enumerate(chars)} # {0: 'b', 1: 's', 2: 'c', 3: 'd', 4: 'a'}		ix_to_char = {i: ch for i, ch in enumerate(chars)} # {0: 'b', 1: 's', 2: 'c', 3: 'd', 4: 'a'}
	~~Creazione~~ di due dizionari per convertire i caratteri in indici e viceversa.		Questa porzione di codice va a creare due dizionari per convertire i caratteri in indici e viceversa.

	Questo è utile per manipolare i caratteri in forma numerica, facilitando le operazioni matematiche sui dati. <code>char_to_ix</code> mappa ogni carattere unico a un indice intero univoco, e <code>ix_to_char</code> fa l'opposto.		Questo è utile per manipolare i caratteri in forma numerica, facilitando le operazioni matematiche sui dati. <code>char_to_ix</code> mappa ogni carattere unico a un indice intero univoco, e <code>ix_to_char</code> fa l'opposto.

Lucia Terenzi: /* Importiamo le librerie: */

2024-03-13T12:02:11Z

Importiamo le librerie:

← Versione meno recente		Versione delle 12:02, 13 mar 2024
Riga 2:		Riga 2:
	Proviamo a creare una [[Recurrent Neural Network (RNN)]] che, dato un carattere tra a,b,c,d, lo continui secondo il pattern: 'aaaaabbbbbccccacdddddaaaa'		Proviamo a creare una [[Recurrent Neural Network (RNN)]] che, dato un carattere tra a,b,c,d, lo continui secondo il pattern: 'aaaaabbbbbccccacdddddaaaa'

	=== Importiamo le librerie: ===		== Importiamo le librerie: ==
	import torch		import torch
	import torch.nn as nn		import torch.nn as nn
Riga 13:		Riga 13:
	* <code>torch.optim</code>: modulo per gli ottimizzatori, usato per aggiornare i pesi della rete durante l'addestramento.		* <code>torch.optim</code>: modulo per gli ottimizzatori, usato per aggiornare i pesi della rete durante l'addestramento.

	=== Mappatura Caratteri-indici: ===		== Mappatura Caratteri-indici: ==
	# Funzioni di utilità per convertire da carattere a intero e viceversa		# Funzioni di utilità per convertire da carattere a intero e viceversa