master-degree-notes/Foundation of data science/notes/5 Neural Networks.md

292 lines
14 KiB
Markdown
Raw Normal View History

2024-12-26 04:24:44 +01:00
Certamente, ecco gli appunti dettagliati in formato Markdown per il tuo blocco note Obsidian, basati sui PDF forniti:
### Reti Neurali
* **Funzione Score Lineare:**
* $f = Wx$
* **Rete Neurale a 2-layer:**
* $f = W₂ max(0, W₁x)$
### Fully Connected Neural Net
* **Problema:**
* Spatial correlation locale
* Molti parametri: 10^12 per una immagine 1000x1000 con 1M hidden units
* Meglio usare le risorse altrove
### Locally Connected Neural Net
* **Soluzione:**
* Input connessi localmente.
* Meno parametri.
* 100M per una immagine 1000x1000 con 1M hidden units e filter size 10x10
* **Problema:** Staticità dei parametri.
### Convolutional Neural Net
* **Soluzione:**
* Condivide i parametri su diverse locazioni
* Convolution con learned kernels
* Impara multipli filtri,
* Esempio con 100 filtri e dimensione 10x10, si hanno 10k parametri.
* **Motivazioni:**
* Le reti standard crescono quadraticamente con la dimensione dell'input.
* Non sfruttano la staticità.
* Connette ogni unità nascosta con un piccolo input patch.
* Condivide i pesi.
### Pooling
* **Scopo:** Filtra risposte a diverse locazioni, ottenendo robustezza.
* Max e Average.
### Neural Nets for Vision
* Connessione hidden layer a patch dell'input, condividendo i pesi.
* **Cnn:** convolutional network.
### Layer Fully Connected
* Si applica dopo la fase di feature extraction.
* Output lineare: $Wx$
* Output è un numero se si applica $Wx$
### Layer Convoluzionale
* Preserva la struttura spaziale
* Dimensione filtro tipica 5x5x3.
* Applica la convoluzione tra filtro e chunk di immagine.
### Layer Convoluzionale Multiplo
* Si possono usare più filtri, ottenendo più mappe di attivazione.
* Si stackano le mappe di attivazione.
* Ogni mappa è un nuovo channel.
### ConvNet
* Sequenza di convolutional layers, alternate da funzioni di attivazione (RELU).
### VGG-16
* Bassi livelli: low level features.
* Medio livello: mid level features.
* Alti livelli: high level features.
* Dopo i vari layers la classificazione è lineare.
### CONV layer in Pytorch
* `torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True)`
* **Input:** N (batch size), C(channel), H(height) e W(width).
* **Output:** N, Cout, Hout, Wout.
* $out(N, C) = bias(Cout) + sum_{k=0}^{C_in-1} weight(Cout, k) * input(N, k)$
* **Parametri:** $kernel_size, stride, padding, dilation$ sono parametri int o tuple.
* **Hyperparameters:**
* Numero di filtri $K$
* Dimensione dei filtri $F$
* Stride $S$
* Padding $P$
### Pooling Layer
* Rende la rappresentazione più piccola e gestibile.
* Opera indipendentemente per ogni mappa di attivazione.
* **Downsampling:**
* 224 diventa 112.
### Max Pooling
* **No learnable parameters.**
* Introduce spatial invariance.
### Struttura tipica CNN
* CONV -> RELU -> POOL (più volte) -> FC (linear) -> Softmax.
* Struttura di base: $[(CONV-RELU)*N-POOL?]*M-(FC-RELU)*K,SOFTMAX$
Spero che questi appunti ti siano utili. Buono studio per il tuo esame! Se hai altre domande, non esitare a chiedere.
## Appunti su Reti Neurali e Convoluzionali
### Dropout
* **Definizione:** Tecnica di regolarizzazione per prevenire l'overfitting in reti neurali.
* **Funzionamento (Training):**
* Disattiva casualmente una frazione di neuroni durante ogni iterazione di training.
* I neuroni disattivati (dropped-out) hanno attivazione zero.
* La probabilità di dropout è controllata dall'iperparametro *p* (dropout rate), dove 0 ≤ *p* < 1.
* I pesi dei neuroni attivi vengono aggiornati normalmente con backpropagation.
* I neuroni disattivati non contribuiscono al forward o backward pass.
* Formula: $h = r ⊙ x$, dove $rᵢ ~ Bernoulli(1-p)$ e $⊙$ è la moltiplicazione elemento per elemento.
* **Funzionamento (Inferenza):**
* Nessun neurone viene disattivato.
* Le attivazioni vengono scalate in base al dropout rate (*p*). Tipicamente si moltiplica per 1-*p* per compensare la minore attività dei neuroni in training.
* Formula: $h = (1-p)x$
* **Inverse Dropout:**
* La scalatura delle attivazioni viene fatta durante il training, non l'inferenza.
* Assicura la consistenza dei valori delle attivazioni tra training e inferenza.
* Formula: $h = (r ⊙ x) / (1-p)$
* **Obiettivo:** Forzare la rete a imparare caratteristiche robuste che non dipendono da neuroni specifici.
* **Efficacia:** Non è sempre efficace.
### Connessioni Residue (Residual Connections)
* **Definizione:** Introdotte nelle Residual Networks (ResNets) per affrontare il problema del vanishing gradient.
* **Funzionamento:**
* Aggiungono l'input di un layer direttamente al suo output, "saltando" uno o più layer.
* Formula: $h = F(x) + x$
* Ogni layer aggiunge un "residuo" al valore precedente.
* **Backpropagation:**
* Se i parametri sono tali che $F(x) = 0$, allora l'input passa inalterato (funzione identità).
* I derivati non si annullano grazie alla forma $F(x) + x$.
* **Deep Residual Networks:**
* Consistono in molti layer con unità residue.
* Per la visione, F sono tipicamente 2-3 layer convolution nets.
* Performance migliore con profondità maggiori rispetto alle reti normali.
* **Esempio ImageNet:**
* ResNet 152 layers: errore top-5 4.49%
* Ensemble ResNet: 3.57%
* Precedente SOTA: 6.6% (GoogLeNet)
* Umani: 5.1%
* ResNets fino a 1000 layers, ma le performance si stabilizzano a 150 layer.
### Normalizzazione
* **Standard Scaling:**
* Preprocessa i dati in modo che ogni feature (colonna) abbia media zero e varianza unitaria.
* Formula: $X' = (X - μ) / sqrt(σ²)$
* $μ$: media della feature, calcolata come $μⱼ = (1/n) Σᵢ Xᵢⱼ$
* $σ²$: varianza della feature, calcolata come $σ²ⱼ = (1/n) Σᵢ (Xᵢⱼ - μⱼ)²$
* **Batch Normalization (BN):**
* Normalizza gli output di ogni layer o blocco in una rete neurale.
* Obiettivo: imparare media e varianza ottimali per ogni unità del layer durante il training.
* La media e la varianza di un layer cambiano durante l'ottimizzazione.
* Calcola media e varianza su un mini-batch anziché sull'intero dataset.
* Formula: $H' = (H - μ) / (sqrt(σ²) + ε)$
* BN(H) imposta una nuova media e varianza: $BN(H) = αH'ᵢⱼ + βⱼ$
* $α$ e $β$ sono trainati via gradient descent.
* **Inferenza:**
* **Post-Training Stats:** Calcola media e varianza sull'intero dataset e le usa fisse.
* **Moving Average:** Mantiene medie mobili di media e varianza durante il training, le usa fisse in inferenza.
* **BN Convoluzioni:**
* Media e varianza sono calcolate *per canale*, non per feature.
* **Sfide:**
* **Mini-batch dependencies:** Limita l'efficacia in scenari come distributed optimization.
* **High variance:** Con batch piccoli, la stima di media e varianza è poco affidabile.
* **Layer Normalization (LN):**
* Normalizza gli input a un layer *attraverso le features* (non mini-batch).
* Comunemente usata in forecasting con time series e transformers (batch size variabile o spesso = 1).
* Vengono allenate le variabili alfa e beta.
### Data Augmentation
* **Definizione:** Tecnica per aumentare la dimensione del training set applicando trasformazioni casuali ai dati.
* **Funzionamento:**
1. Campiona un mini-batch dal dataset.
2. Applica una o più trasformazioni casuali (flipping, cropping, rotazione...).
3. Allena il modello sul mini-batch trasformato.
* **Benefici:** Previene overfitting e migliora la robustezza del modello.
* **Trasformazioni Geometriche:**
* Flipping (orizzontale/verticale)
* Rotazione (angoli casuali)
* Traslazione (shift in x/y)
* Scaling (ridimensionamento)
* Cropping (ritaglio)
* Zooming
* Affine (combinazione di altre)
* **Trasformazioni Colore/Luce:**
* Brightness/Contrast/Saturation/Hue
* Color Jittering
* Grayscale
* **Noise and Distortion:**
* Gaussian Noise
* Salt-and-Pepper Noise
* Elastic Deformations
* **Cutout/Masking:**
* Cutout
* Random Erasing
* **Combinazione Tecniche:**
* Mixup
* CutMix
### Convoluzioni 1D
* **Definizione:** Usata per dati *time series* dove l'informazione è ordinata in sequenza.
* **Obiettivo:** Estrarre feature locali o pattern che evolvono nel tempo.
* **Input:** Time series di n passi, $x₀, x₁,..., xₙ₋₁$, dove ogni passo ha c features.
* Rappresentata come matrice $X (n, c)$: ogni riga è un timestep, ogni colonna è una feature.
* **Convoluzione 1D:** Definità da un receptive field di dimensione 2k:
* $Hᵢ = φ( Σⱼ₌₋ₖᵏ Σ₂₁ᶜ Wⱼ₊ₖ,₂ * Xᵢ₊ⱼ,₂)$
* **Scopi:**
* **Local Pattern Detection:** Catturare dipendenze locali nei time series.
* **Parameter Sharing:** Stesso filtro applicato a tutti i passi, riducendo i parametri.
* **Translation Invariance:** Robustezza a shift nel tempo.
* **Applicazioni:**
* Forecasting
* Anomaly Detection
* Classification
* Signal Processing
* **Causal Convolution:**
* L'output a un tempo i dipende solo dai passi precedenti (non futuri).
* Utile per forecasting e modelli che non devono "vedere" il futuro.
* $Hᵢ = φ( Σⱼ₌₀ᵏ Σ₂₁ᶜ Wⱼ,₂ * Xᵢ₋ⱼ,₂)$
### Causal Model
* **Forecasting:** Prevedere il passo successivo nei time series.
* **Opzioni:**
* Poola l'output $H$ e applica un regressor per predire $xₙ$.
* Definisce un target $Y = [x₁, x₂,..., xₙ]$ e allena il modello in modo che $Hᵢ ≈ Hᵢ₊₁$
* Quest'ultimo funziona solo con modelli causali.
### Autoregressive Generation
* Modelli allenati a prevedere il passo successivo possono essere usati per generazione autoregressiva.
* **Funzionamento:**
1. Inizia con una sequenza iniziale come prompt.
2. Il modello predice il passo successivo.
3. Aggiungi la predizione all'input e ripeti.
### Self-Attention
* **Scopo:** Modellare sequenze.
* **Confronto con 1D Convolution:**
* **1D Convolution:** Filtro a dimensione fissa, cattura pattern locali.
* **Self-Attention:** Calcola le interazioni tra ogni elemento della sequenza, imparando le dipendenze globali.
* **Funzionamento:**
* Calcola gli "attention scores" tra tutti gli elementi di una sequenza.
* L'output è la somma pesata degli elementi, dove i pesi sono gli attention scores.
* **Q, K, V Matrices:**
* Ogni token viene trasformato in 3 vettori: Query (Q), Key (K), Value (V).
* **Analogia web search:**
* Query (Q): la search term
* Key (K): titoli delle pagine web
* Value (V): contenuto delle pagine web.
* Il modello usa Q, K, V per calcolare gli attention scores.
* **Masked Self-Attention:**
* **Attention Score:** $dot product$ di Q e K.
* **Masking:** Blocca i token futuri (upper triangle) ponendo i loro scores a $-inf$.
* **Softmax:** Converte gli scores in probabilità.
* **Multi-Head Attention:**
* Multipli self-attention heads, ognuno cattura relazioni diverse tra i tokens.
* Output concatenati e passati per una proiezione lineare.
* **MLPs:**
* I risultati del multi-head self-attention vengono elaborati da un Multilayer Perceptron.
* **Transformer Block:**
* $Add \& Norm$: connessione residua, layer normalization.
* Layernorm applicato prima di MHA e MLP
* Il blocco si ripete "Nx" volte.
### Text Embeddings
* **Tokens:** Il testo viene diviso in unità più piccole (parole o subwords).
* **Embeddings:** I tokens sono convertiti in vettori numerici.
* **Problematiche con encoders a livello di parola:**
* Difficoltà a gestire le boundaries delle parole.
* Parole con forme simili trattate come separate.
* **Char encoders:** Riducono la complessità ma sono difficili da usare.
* **Subword Encoders (Byte Pair Encoding):**
* Algoritmo che parte dal vocabolario base con tutti i caratteri.
* Conta la frequenza delle coppie di caratteri.
* Unisce la coppia più frequente in un nuovo simbolo.
* Aggiunge il simbolo al vocabolario, re-tokenizza i dati.
* Si ferma dopo un numero di step.
* GPT-2 utilizza BPE su byte e aggiunge regole per il merging process.
### Positional Encoding
* **Problema:** I transformers processano i tokens simultaneamente, perdendo informazione di sequenza.
* **Positional Encoding:** Aggiunge informazione di posizione ai token vectors, consentendo al modello di differenziarli.
* **Sinusoidal Embeddings:**
* $$p(t)ᵢ= { sin(ωₖ * t) se i = 2k
cos(ωₖ * t) se i = 2k+1
ωₖ = 1/10000^(2k/d)$$
* **Relative Positional Embeddings:**
* Considera la distanza *relativa* $i-j$ tra i tokens, non la posizione assoluta.
* Es. ALiBi (Attention with Linear Biases): bᵢⱼ aggiunto basato sulla distanza relativa.
* In ALiBi non si usano positional embeddings all'inizio.
* **Output del Transformer:**
* L'output è proiettato nello spazio 50,257 dimensionale (grandezza vocabolario).
* Ogni valore è un logit, raw score del token.
* **Softmax:** i logits vengono trasformati in probabilità (distribuzione), si sceglie il token più probabile.
* **Temperature:**
* Iperparametro che controlla la randomicità della generazione.
* Temp = 1: nessun effetto.
* Temp < 1: distribuisce "sharper", più deterministico.
* Temp > 1: distribuisce "softer", più casuale, più creativa.