292 lines
No EOL
14 KiB
Markdown
292 lines
No EOL
14 KiB
Markdown
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. |