Nel mondo del deep learning, le reti neurali sono costruite utilizzando una varietà di strati (layers), ciascuno progettato per svolgere compiti specifici. PyTorch, un popolare framework per il machine learning, offre una vasta gamma di strati nel modulo torch.nn, che permettono di costruire modelli complessi e adattabili. Questa guida esplora tutti gli strati disponibili in PyTorch, fornendo una spiegazione dettagliata, parametri chiave ed esempi di codice per ogni strato.
1. Strati Lineari (Linear Layers)
Gli strati lineari sono i mattoni fondamentali delle reti neurali. Essi effettuano una trasformazione lineare degli input.
Esempio:
import torch
import torch.nn as nn
# Creazione di uno strato lineare con 5 feature in ingresso e 3 in uscita
linear_layer = nn.Linear(5, 3)
# Eseguo l'inferenza su un input casuale
input_tensor = torch.randn(1, 5)
output = linear_layer(input_tensor)
print("Output shape:", output.shape) # Shape atteso: torch.Size([1, 3])
2. Strati Convolutivi (Conv Layers)
Gli strati convolutivi sono essenziali nell'elaborazione delle immagini.
Esempio con Conv2d:
# Parametri: in_canali, out_canali, kernel_size, stride, padding
conv_layer = nn.Conv2d(1, 10, kernel_size=5, stride=2, padding=2)
input_tensor = torch.randn(1, 1, 28, 28) # Batch size 1, canale singolo, dimensioni 28x28
output = conv_layer(input_tensor)
print("Output shape:", output.shape)3. Strati Transposti Convolutivi (Transposed Conv Layers)
Utilizzati per aumentare le dimensioni spaziali di un'immagine.
Esempio con ConvTranspose2d:
transp_conv_layer = nn.ConvTranspose2d(1, 1, kernel_size=2, stride=2)
input_tensor = torch.randn(1, 1, 16, 16)
output = transp_conv_layer(input_tensor)
print("Output shape:", output.shape)4. Strati di Massimo Raggruppamento (Max Pooling Layers)
Riducono le dimensioni spaziali dell'input mantenendo le caratteristiche più importanti.
Esempio con MaxPool2d:
max_pool = nn.MaxPool2d(kernel_size=2, stride=2)
input_tensor = torch.randn(1, 1, 32, 32)
output = max_pool(input_tensor)
print("Output shape:", output.shape)5. Strati di Media Raggruppamento (Average Pooling Layers)
Simili al max pooling ma utilizzano la media come funzione di raggruppamento.
Esempio con AvgPool2d:
avg_pool = nn.AvgPool2d(kernel_size=2, stride=2)
input_tensor = torch.randn(1, 1, 32, 32)
output = avg_pool(input_tensor)
print("Output shape:", output.shape)6. Dropout
Regolarizza il modello disattivando casualmente alcuni neuroni durante l'addestramento.
Esempio:
dropout_layer = nn.Dropout(p=0.5)
input_tensor = torch.randn(1, 10)
output = dropout_layer(input_tensor)
print("Output shape:", output.shape)7. Batch Normalization
Normalizza l'input prima di applicare l'attivazione, accelerando l'addestramento.
Esempio:
bn_layer = nn.BatchNorm1d(10) # Per input a una dimensione
input_tensor = torch.randn(1, 10)
output = bn_layer(input_tensor)
print("Output shape:", output.shape)8. Strati Ricorrenti (RNN, LSTM, GRU)
Elaborano dati sequenziali come testo o serie temporali.
Esempio con LSTM:
lstm_layer = nn.LSTM(input_size=10, hidden_size=20, num_layers=1, batch_first=True)
input_tensor = torch.randn(1, 5, 10) # Batch size 1, sequenza di 5 passi, input size 10
output, (hn, cn) = lstm_layer(input_tensor)
print("Output shape:", output.shape) # (1, 5, 20)9. Transformer Layers
Includono meccanismi di attenzione multi-testa per processi sequenziali.
Esempio con MultiheadAttention:
import torch.nn.functional as F
attention_layer = nn.MultiheadAttention(embed_dim=10, num_heads=2)
query = torch.randn(1, 5, 10) # batch_size=1, seq_len=5, embed_dim=10
key = torch.randn(1, 5, 10)
value = torch.randn(1, 5, 10)
output, _ = attention_layer(query, key, value)
print("Output shape:", output.shape) # (1, 5, 10)10. Upsample Layers
Aumentano le dimensioni spaziali di un'immagine.
Esempio con Upsample:
upsample_layer = nn.Upsample(scale_factor=2, mode='nearest')
input_tensor = torch.randn(1, 1, 16, 16)
output = upsample_layer(input_tensor)
print("Output shape:", output.shape) # (1, 1, 32, 32)11. Strati di Incorporamento (Embedding Layers)
Mappano indici discreti in vettori densi.
Esempio:
embedding_layer = nn.Embedding(num_embeddings=10, embedding_dim=5)
input_tensor = torch.randint(0, 10, (1, 3)) # Batch size 1, sequenza di 3 elementi
output = embedding_layer(input_tensor)
print("Output shape:", output.shape) # (1, 3, 5)12. Layer Normalization
Normalizza l'input lungo un certo insieme di dimensioni.
Esempio:
ln_layer = nn.LayerNorm(10)
input_tensor = torch.randn(1, 10)
output = ln_layer(input_tensor)
print("Output shape:", output.shape)13. Group Normalization
Normalizza l'input dividendo i canali in gruppi.
Esempio:
gn_layer = nn.GroupNorm(num_groups=2, num_channels=10)
input_tensor = torch.randn(1, 10, 5, 5)
output = gn_layer(input_tensor)
print("Output shape:", output.shape)14. Adaptive Max Pooling
Applica raggruppamento adattivo per mantenere dimensioni di uscita fisse.
Esempio con AdaptiveMaxPool2d:
adaptive_max_pool = nn.AdaptiveMaxPool2d((3, 3))
input_tensor = torch.randn(1, 1, 6, 6)
output = adaptive_max_pool(input_tensor)
print("Output shape:", output.shape)15. Softmax
Utilizzato come ultima attivazione per ottenere probabilità nella classe di uscita.
Esempio:
softmax_layer = nn.Softmax(dim=1)
input_tensor = torch.randn(1, 5)
output = softmax_layer(input_tensor)
print("Output shape:", output.shape)Conclusione
Ogni strato in PyTorch è progettato per specifiche funzionalità, permettendo ai modelli di adattarsi a vari compiti. Comprendere questi strati è essenziale per costruire reti neurali efficaci. Questa guida fornisce una base solida per esplorare ulteriormente le potenzialità di PyTorch nel deep learning.
Per un approfondimento, si consiglia di consultare la documentazione ufficiale di PyTorch e sperimentare con diversi modelli per vedere come questi strati possano essere combinati per risolvere problemi reali.