Riassunti deep machine learning

Riassunti deep machine learning

Riassunti deep machine learning

Riassunti deep machine learning

Introduzione al Machine Learning e Deep Learning

Agenda

1. Introduzione
2. Informazioni sul corso
3. Revisione e notazione

Definizioni di Apprendimento

• Comportamentismo (Skinner, 1900-1950):
  L’apprendimento è un cambiamento a lungo termine nel comportamento dovuto all’esperienza.

• Cognitivismo (Scuola della Gestalt, 1920-):
  L’apprendimento è un processo mentale interno che integra nuove informazioni in schemi mentali preesistenti e li aggiorna nel tempo.

• Connessionismo (Hebb, 1949):
  L’apprendimento è un processo fisico in cui i neuroni si connettono sviluppando sinapsi tra di loro.

Cos’è il Machine Learning (ML)?

• Definizione di Samuel (1959):
  Il Machine Learning è un campo di studio che offre ai computer la capacità di imparare senza essere esplicitamente programmati.

• Definizione di Mitchell (1997):
  Un programma è detto “apprendente” se la sua prestazione in un compito T, misurata da una metrica P, migliora con l’esperienza E.
  (Sostituisci “dati di addestramento D” per “esperienza \E”).

Tipi di Machine Learning

1. Non Parametrico
   L’apprendimento avviene memorizzando i dati di addestramento (es. k-Nearest Neighbors).

2. Parametrico
   Si utilizza un algoritmo per adattare i parametri di un modello matematico o statistico ai dati di addestramento, ad esempio:
   f_\theta(x) = \sum_{d=1}^D \theta_d x_d $f_\theta(x) = \sum_{d=1}^D \theta_d x_d$

Applicazioni del Machine Learning

Esempi di utilizzo includono:

• Industria: Ottimizzazione dei processi aziendali.
• Medicina: Diagnosi e previsione di malattie.
• Finanza: Previsione di mercati e gestione del rischio.

Rapporto con altri campi

Il Machine Learning è interdisciplinare e si interseca con:

• Intelligenza Artificiale
• Statistica e Probabilità
• Ottimizzazione Numerica
• Scienze Cognitive e Neuroscienze
• Data Science e Big Data

Obiettivi del corso

• Scopo:
  Acquisire competenze per applicare modelli di Machine Learning per risolvere problemi reali.

• Argomenti trattati:

  • Classificazione, regressione, clustering, riduzione della dimensionalità.
  • Selezione del modello, regolarizzazione e valutazione.
  • Reti Neurali, Deep Learning e Reinforcement Learning.

• Non incluso:
  Progettazione di nuovi algoritmi di Machine Learning.

Prerequisiti

• Algebra Lineare
• Calcolo Differenziale
• Probabilità e Statistica
• Algoritmi e Strutture Dati
• Programmazione: Python sarà utilizzato per gli esercizi.

Materiale di riferimento

• Machine Learning:

  • [ISL]: An Introduction to Statistical Learning
  • [ESL]: The Elements of Statistical Learning

• Deep Learning:

  • [DLB]: Deep Learning di Ian Goodfellow et al.

• Letture suggerite:

  • [RL]: Reinforcement Learning di Sutton e Barto.
  • [PRML]: Pattern Recognition and Machine Learning di Christopher Bishop.

Programmazione e Ambiente di Calcolo

• È necessario disporre di un computer (qualsiasi dispositivo recente andrà bene).
• Linguaggi e strumenti:
  • Python 3.x con librerie come NumPy, SciPy e PyTorch.
  • Lezioni di laboratorio tramite Google Colab (è richiesto un account Google).

Apprendimento Supervisionato - Definizioni e Prestazioni

Agenda

1. Cosa intendiamo per apprendimento?
2. Assunzione fondamentale dell’apprendimento.
3. Valutazione dei metodi di classificazione.
4. Misure di classificazione.
5. Misure di prestazione delle funzioni probabilistiche.

Apprendimento Supervisionato

1. I dati:

   • Un insieme di record di dati $X \in \mathcal{X}^k $, detti esempi, istanze o casi.
   • Ogni esempio è descritto da k attributi o caratteristiche x = \{x_1, x_2, ..., x_k\}$x = \{x_1, x_2, ..., x_k\}$.
   • Ogni esempio ha una classe predefinita c \in C$c \in C$.

2. Obiettivo:
   Imparare un modello di classificazione dai dati per prevedere le classi di nuovi esempi non visti.

Processo di apprendimento supervisionato

1. Training:
   Si impara un modello dai dati di addestramento.

2. Testing:
   Si testa il modello usando dati di test non visti per valutare l’accuratezza.

3. Accuratezza:
   \text{Accuratezza} = \frac{\text{Numero di classificazioni corrette}}{\text{Numero totale di casi}} $\text{Accuratezza} = \frac{\text{Numero di classificazioni corrette}}{\text{Numero totale di casi}}$
   L’accuratezza è solo una delle tante misure di prestazione!

4. Importante:
   L’apprendimento riguarda sempre il confronto e l’ottimizzazione di una misura di prestazione.

Pipeline di training

1. Input: Dati di addestramento.
2. Output: Modello appreso.
3. Ottimizzazione:
   Iterare fino a raggiungere la convergenza.

Pipeline di inferenza

1. Input: Dati di test e parametri del modello.
2. Output: Classe prevista.

Definizione di apprendimento

• Dato un dataset D, un compito C e una funzione di prestazione L, un sistema informatico apprende C dai dati D se, dopo aver osservato D, le prestazioni su L migliorano rispetto a una scelta casuale.
• In altre parole, i dati aiutano il sistema a migliorare le sue prestazioni rispetto a non apprendere nulla.

Assunzione fondamentale: i.i.d.

1. Definizione:
   L’apprendimento è possibile solo se training e inferenza si basano su dati provenienti dalla stessa distribuzione x \sim P(X)$x \sim P(X)$.

   • Le osservazioni devono essere indipendenti e identicamente distribuite (i.i.d.).

2. Errore di generalizzazione:

   • Errore reale:
     R(f) = P_{x \sim D}[f(x) \neq c(x)] $R(f) = P_{x \sim D}[f(x) \neq c(x)]$
   • Errore empirico:
     \hat{R}_S(f) = \frac{1}{m} \sum_{i=1}^m 1_{f(x_i) \neq c(x_i)} $\hat{R}_S(f) = \frac{1}{m} \sum_{i=1}^m 1_{f(x_i) \neq c(x_i)}$
     La differenza tra errore reale e empirico è chiamata generalization gap.

3. Caso i.i.d.:
   Sotto l’assunzione i.i.d., l’errore su training e test sarà quasi uguale, o molto vicino.

Valutazione dei metodi di classificazione

1. Accuratezza predittiva:
   \text{Accuratezza} = \frac{\text{Numero di classificazioni corrette}}{\text{Numero totale di casi di test}} $\text{Accuratezza} = \frac{\text{Numero di classificazioni corrette}}{\text{Numero totale di casi di test}}$

2. Efficienza:

   • Tempo necessario per costruire il modello.
   • Tempo necessario per utilizzare il modello.

3. Robustezza: Capacità di gestire rumore e valori mancanti.

4. Scalabilità: Efficienza con grandi dataset.

5. Interpretabilità:
   Capacità di comprendere il modello e i suoi risultati.

6. Compattezza:
   Dimensione dell’albero (per modelli basati su alberi) o numero di regole.

Valutazione del modello

1. Set di holdout:

• Il dataset disponibile D è suddiviso in due insiemi disgiunti:
  • Set di training (Tr): per imparare il modello.
  • Set di test (Te): per valutare il modello.
• Importante:
  • Il training set non deve essere usato per il testing e viceversa.
  • Il test set fornisce una stima imparziale dell’accuratezza.
  • Questo metodo è utile quando il dataset è grande.

Iperparametri

1. Definizione:
   Parametri aggiuntivi di un modello (es. numero di layer in una rete neurale, pesi di regolarizzazione).

   • Non appresi: devono essere scelti prima del training.

2. Impatto:
   Diverse configurazioni degli iperparametri possono cambiare significativamente le prestazioni del modello.

3. Set di validazione:
   Una ulteriore suddivisione del dataset D, usata per:

   • Ottimizzare gli iperparametri.
   • Selezionare il miglior modello.

Ricetta 1: Train-Validation-Test

1. Il dataset D viene diviso casualmente in tre parti:

   • Training set (Tr): per addestrare il modello.
   • Validation set (V): per ottimizzare gli iperparametri.
   • Test set (Te): per misurare le prestazioni finali.

   Divisioni tipiche: 60/20/20 o 80/10/10.

Classificatori Probabilistici e Modelli di Classificazione Lineare

Classificazione Probabilistica

1. Scenario:

   • Supponiamo di conoscere:
     • La probabilità reale che un caso appartenga a una classe c:
       P(Y = c) = \pi_c$P(Y = c) = \pi_c$
     • La densità di probabilità reale di un vettore x \in \mathbb{R}^D$x \in \mathbb{R}^D$ appartenente alla classe c:
       P(X = x | Y = c) = \phi_c(x)$P(X = x | Y = c) = \phi_c(x)$.

2. Obiettivo:
   Calcolare la probabilità che una specifica osservazione x appartenga alla classe c, utilizzando la Regola di Bayes:
   P(Y = c | X = x) = \frac{P(X = x | Y = c) P(Y = c)}{\sum_{c' \in Y} P(X = x, Y = c')} $P(Y = c | X = x) = \frac{P(X = x | Y = c) P(Y = c)}{\sum_{c' \in Y} P(X = x, Y = c')}$
   Equivalente a:
   P(Y = c | X = x) = \frac{\phi_c(x) \pi_c}{\sum_{c' \in Y} \phi_{c'}(x) \pi_{c'}} $P(Y = c | X = x) = \frac{\phi_c(x) \pi_c}{\sum_{c' \in Y} \phi_{c'}(x) \pi_{c'}}$

Definizioni

• Verosimiglianza (P(X = x | Y = c)$P(X = x | Y = c)$):
  Misura quanto è probabile osservare x, dato che la classe è c.

• Probabilità a priori (P(Y = c)$P(Y = c)$):
  Misura la probabilità di c senza alcuna osservazione x.

• Probabilità a posteriori (P(Y = c | X = x)$P(Y = c | X = x)$):
  La probabilità di c, calcolata dopo aver osservato x, utilizzando la regola di Bayes.

Strategie di classificazione

1. Classificazione a massima verosimiglianza:

   • Impara una funzione di verosimiglianza P(x | c)$P(x | c)$ per ogni classe c.
   • Per un’osservazione \hat{x}$\hat{x}$, classifica in base a:
     \hat{c} = \arg \max_c P(\hat{x} | c) $\hat{c} = \arg \max_c P(\hat{x} | c)$

2. Classificazione a massima probabilità a posteriori (MAP):

   • Impara sia:
     • La verosimiglianza P(x | c)$P(x | c)$
     • La probabilità a priori P(c)$P(c)$.
   • Applica la regola di Bayes per calcolare P(c | \hat{x})$P(c | \hat{x})$:
     \hat{c} = \arg \max_c P(c | \hat{x}) $\hat{c} = \arg \max_c P(c | \hat{x})$
   • Differenza principale: MAP utilizza le probabilità a priori.

Stima della densità

1. Caso continuo: Stima parametrica della massima verosimiglianza

   • Si sceglie una funzione di densità parametrica p(x | \Theta)$p(x | \Theta)$.
   • Si apprendono i parametri \Theta$\Theta$ massimizzando la verosimiglianza:
     \hat{\Theta} = \arg \max_\Theta \prod_{x_i \in D} p(x_i | \Theta) $\hat{\Theta} = \arg \max_\Theta \prod_{x_i \in D} p(x_i | \Theta)$
     (Equivalente a massimizzare il logaritmo della verosimiglianza).

2. Caso discreto: Stima non parametrica

   • Si costruisce un istogramma H(x)$H(x)$ contando la frequenza dei valori x.
   • L’istogramma è normalizzato per ottenere una probabilità.

Linear Discriminant Analysis (LDA)

1. Definizione:

   • L’LDA è una tecnica di classificazione introdotta da Fisher negli anni '30.
   • Approssima il classificatore bayesiano ottimale per dati reali.
   • Presuppone che:
     • Le densità condizionali di classe siano normali multivariate.
     • Le classi condividano la stessa matrice di covarianza.

2. Densità condizionale per ogni classe:
   \phi_c(x) = N(x; \mu_c, \Sigma) = \frac{1}{|2\pi \Sigma|^{1/2}} \exp\left(-\frac{1}{2} (x - \mu_c)^T \Sigma^{-1} (x - \mu_c)\right) $\phi_c(x) = N(x; \mu_c, \Sigma) = \frac{1}{|2\pi \Sigma|^{1/2}} \exp\left(-\frac{1}{2} (x - \mu_c)^T \Sigma^{-1} (x - \mu_c)\right)$

   • \mu_c$\mu_c$: media della classe.
   • \Sigma$\Sigma$: matrice di covarianza comune.

3. Classificatore LDA:
   f_{LDA}(x) = \arg \max_{c \in Y} \phi_c(x) \pi_c $f_{LDA}(x) = \arg \max_{c \in Y} \phi_c(x) \pi_c$

Apprendimento per LDA

1. Stima dei parametri:
   • Probabilità della classe:
     \pi_c = \frac{1}{n} \sum_{i=1}^n [y_i = c] $\pi_c = \frac{1}{n} \sum_{i=1}^n [y_i = c]$
   • Media della classe:
     \mu_c = \frac{\sum_{i=1}^n [y_i = c] x_i}{\sum_{i=1}^n [y_i = c]} $\mu_c = \frac{\sum_{i=1}^n [y_i = c] x_i}{\sum_{i=1}^n [y_i = c]}$
   • Covarianza condivisa:
     \Sigma = \frac{1}{n} \sum_{i=1}^n (x_i - \mu_{y_i})(x_i - \mu_{y_i})^T $\Sigma = \frac{1}{n} \sum_{i=1}^n (x_i - \mu_{y_i})(x_i - \mu_{y_i})^T$

Interpretazione geometrica

1. Decision boundary (confine decisionale):

   • Per il caso binario, il confine decisionale si trova nei punti x in cui:
     \log(\pi_0) - \frac{1}{2} \log |2\pi \Sigma| - \frac{1}{2} (x - \mu_0)^T \Sigma^{-1} (x - \mu_0) $\log(\pi_0) - \frac{1}{2} \log |2\pi \Sigma| - \frac{1}{2} (x - \mu_0)^T \Sigma^{-1} (x - \mu_0)$
     è uguale al termine per la classe 1.

2. Conclusione:

   • Il confine decisionale è lineare rispetto a x.

Quadratic Discriminant Analysis (QDA)

1. Definizione:

   • Simile all’LDA, ma rilassa l’assunzione che le classi condividano la stessa matrice di covarianza.
   • Ogni classe ha una matrice di covarianza distinta \Sigma_c$\Sigma_c$.

2. Confine decisionale:

   • È non lineare.

Machine Learning - Apprendimento Non Supervisionato (Clustering)

Clustering: Definizione

• Clustering:
  • Anche chiamato apprendimento non supervisionato, classificazione (in statistica), smistamento (in psicologia) o segmentazione (in marketing).
  • Consiste nell’organizzare i dati in classi in modo che ci sia:
    • Alta somiglianza intra-cluster.
    • Bassa somiglianza inter-cluster.
  • A differenza della classificazione, le etichette delle classi e il numero di classi sono determinati direttamente dai dati.
  • Più informalmente, il clustering identifica raggruppamenti naturali tra gli oggetti.

Il Clustering è soggettivo

• La definizione di “gruppi naturali” può variare in base al contesto e agli obiettivi dell’analisi.

Cosa significa “somiglianza”?

• Somiglianza: Qualità o stato di essere simile; somiglianza o rassomiglianza.

  • È difficile da definire, ma spesso si basa su un criterio soggettivo: “Lo riconosciamo quando lo vediamo”.

• Somiglianza vs Distanza:

  • I due concetti sono correlati ma distinti:
    • Distanza:
      • Deve soddisfare le seguenti proprietà:
        • Simmetria: D(A, B) = D(B, A)$D(A, B) = D(B, A)$
        • Costanza della somiglianza con se stessi: D(A, A) = 0$D(A, A) = 0$
        • Positività: D(A, B) = 0$D(A, B) = 0$ solo se A = B$A = B$
        • Disuguaglianza triangolare: D(A, B) \leq D(A, C) + D(B, C)$D(A, B) \leq D(A, C) + D(B, C)$

Tipi di Clustering

1. Algoritmi Partizionali:

   • Costruiscono diverse partizioni e le valutano in base a un criterio.

2. Algoritmi Gerarchici:

   • Creano una decomposizione gerarchica degli oggetti utilizzando un determinato criterio.

Clustering Gerarchico

• Non è possibile testare tutti i possibili alberi, quindi si utilizza una ricerca euristica:
  • Bottom-Up (agglomerativo):
    • Si inizia con ogni oggetto in un proprio cluster.
    • Si fondono i cluster più simili fino a ottenere un unico cluster.
  • Top-Down (divisivo):
    • Si inizia con tutti i dati in un unico cluster.
    • Si divide il cluster in due, ripetendo il processo per i sottogruppi.

Partenza da una Matrice di Distanze o Similarità

• Il clustering gerarchico inizia da una matrice di distanza che contiene le distanze tra ogni coppia di oggetti nel dataset.

Formazione dei Cluster (Approccio Bottom-Up)

1. Ogni oggetto è inizialmente un cluster a sé stante.
2. Trova la migliore coppia di cluster da unire.
3. Ripeti fino a quando tutti i cluster sono stati fusi.

Strategie di Unione

1. Single Linkage (Vicino più prossimo):

   • La distanza tra due cluster è definita dalla distanza tra gli oggetti più vicini nei cluster.

2. Complete Linkage (Più lontano prossimo):

   • La distanza tra due cluster è definita dalla distanza tra gli oggetti più lontani nei cluster.

3. Group Average Linkage:

   • La distanza tra due cluster è calcolata come media delle distanze tra tutte le coppie di oggetti nei due cluster.

4. Ward’s Linkage:

   • Minimizza la varianza dei cluster fusi.

Sintesi del Clustering Gerarchico

• Vantaggi:

  • Non è necessario specificare il numero di cluster in anticipo.
  • La natura gerarchica riflette bene l’intuizione umana in certi domini.

• Svantaggi:

  • Non scala bene: complessità temporale di almeno O(n^2)$O(n^2)$, dove n è il numero totale di oggetti.
  • Problemi di ottimi locali, tipici delle ricerche euristiche.
  • L’interpretazione dei risultati è altamente soggettiva.

K-means

1. Definizione:

   • Algoritmo non gerarchico, in cui ogni istanza è assegnata a uno dei K cluster non sovrapposti.
   • L’utente deve specificare il numero di cluster K in anticipo.

2. Obiettivo:

   • Dato un insieme di punti (x_1, x_2, ..., x_n)$(x_1, x_2, ..., x_n)$ e K cluster S = \{S_1, S_2, ..., S_k\}$S = \{S_1, S_2, ..., S_k\}$, minimizzare la funzione obiettivo:
     \arg \min_S \sum_{i=1}^k \sum_{x \in S_i} \|x - \mu_i\|^2 $\arg \min_S \sum_{i=1}^k \sum_{x \in S_i} \|x - \mu_i\|^2$
     Dove \mu_i$\mu_i$ è la media dei punti in S_i$S_i$.

3. Equivalenza:

   • L’obiettivo può essere riformulato per minimizzare la varianza intra-cluster o la somma delle distanze intra-cluster.

Procedura Naïve di K-means

1. Inizializza K centri dei cluster casuali.
2. Ripeti fino a quando i centri non si aggiornano o viene raggiunto un numero massimo di iterazioni:
   • Assegna ogni punto al cluster più vicino.
   • Calcola nuovi centroidi come la media dei punti in ciascun cluster.

Reti Neurali Profonde (Deep Neural Networks)

Agenda

1. Introduzione
2. Un passo indietro: Classificatori Lineari
3. Modellazione di un Neurone
4. Reti Neurali
5. Addestramento di una Rete Neurale Profonda
6. Regularizzazione

Introduzione

1. Neural Networks: Non sono una novità

   • Nonostante l’attuale interesse per il Deep Learning, gli algoritmi delle reti neurali non sono nuovi:
     • 1940-1960: Prime teorie sull’apprendimento biologicamente ispirato e modelli pionieristici come il perceptrone (un singolo neurone).
     • 1980-1990: Addestramento di reti con alcuni livelli nascosti tramite backpropagation.
     • 2006-ora: L’attuale ondata di ricerca.

2. Perché adesso?

   • Le idee sottostanti al Deep Learning esistono da tempo, ma solo recentemente le prestazioni sono migliorate, grazie a:
     • Dati più ampi (dataset etichettati).
     • Maggiore potenza computazionale.
     • Addestramento su GPU e architetture distribuite.

La Sfida della Rappresentazione dei Dati

1. Le prestazioni degli algoritmi di apprendimento dipendono fortemente dalla rappresentazione dei dati (feature).
2. Storicamente, le feature erano progettate a mano per ogni compito.
3. Con il Deep Learning, le rappresentazioni possono essere apprese direttamente dai dati.

Modellazione di un Neurone

1. Definizione:

   • Ogni neurone può essere modellato come:
     z = \mathbf{w} \cdot \mathbf{x} + b $z = \mathbf{w} \cdot \mathbf{x} + b$
     Dove:

     • \mathbf{x}$\mathbf{x}$: Input.
     • \mathbf{w}$\mathbf{w}$: Pesi.
     • b: Bias.

   • Applica una funzione di attivazione f:
     y = f(z) $y = f(z)$

2. Funzioni di attivazione:

   • Sigmoid:
     \sigma(x) = \frac{1}{1 + e^{-x}} $\sigma(x) = \frac{1}{1 + e^{-x}}$
     • Vantaggi: Compressa tra 0 e 1.
     • Svantaggi: Saturazione (gradiente quasi nullo per input estremi).
   • Tanh:
     \text{tanh}(x) = 2\sigma(x) - 1 $\text{tanh}(x) = 2\sigma(x) - 1$
     • Output tra -1 e 1.
   • ReLU (Rectified Linear Unit):
     f(x) = \max(0, x) $f(x) = \max(0, x)$
     • Non satura, quindi accelera la convergenza.

Reti Neurali

1. Definizione:

   • Una rete neurale è un insieme di neuroni collegati in un grafo.
   • Struttura:
     • Input Layer: I dati grezzi.
     • Hidden Layers: Rappresentazioni intermedie.
     • Output Layer: Predizioni finali.

2. Perché attivazioni non lineari?

   • Senza di esse, una rete neurale diventa equivalente a un modello lineare.
   • Combinazioni lineari di funzioni lineari rimangono lineari.

Addestramento di Reti Neurali Profonde

1. Funzione di perdita:

   • Per classificazione: Entropia incrociata:
     L = -\sum_{i} y_i \log(p_i) $L = -\sum_{i} y_i \log(p_i)$
     Dove y_i$y_i$ è la classe reale e p_i$p_i$ è la probabilità predetta.

2. Ottimizzazione:

   • Utilizza il Gradient Descent per minimizzare la funzione di perdita.
   • Algoritmi avanzati come Adam combinano il Gradient Descent con tecniche di adattamento del learning rate.

3. Backpropagation:

   • Calcola i gradienti per ogni peso usando la regola della catena.
   • Aggiorna i pesi nella direzione opposta al gradiente della perdita.

Problemi nel Training

1. Overfitting:

   • La rete apprende dettagli specifici dei dati di training, perdendo la capacità di generalizzare.
   • Soluzioni:
     • Regularizzazione L2: Penalizza grandi valori di peso.
       L = L_{\text{originale}} + \lambda \sum w^2 $L = L_{\text{originale}} + \lambda \sum w^2$
     • Dropout: Disattiva casualmente neuroni durante l’addestramento.

2. Vanishing/Exploding Gradients:

   • Gradienti che diventano troppo piccoli o troppo grandi, rendendo difficile l’aggiornamento dei pesi.
   • Soluzioni:
     • Inizializzazione dei pesi con metodi come Xavier o He.
     • Funzioni di attivazione come ReLU.

Classificatore Softmax

1. Definizione:

   • Generalizza la regressione logistica per classificazione multiclasse.
   • La funzione Softmax:
     \text{softmax}_i(z) = \frac{e^{z_i}}{\sum_j e^{z_j}} $\text{softmax}_i(z) = \frac{e^{z_i}}{\sum_j e^{z_j}}$
     Converte un vettore di input in una distribuzione di probabilità.

2. Funzione di perdita:

   • Cross-entropy loss:
     L = -\sum_i y_i \log(\hat{y}_i) $L = -\sum_i y_i \log(\hat{y}_i)$

Regularizzazione

1. Obiettivo:

   • Evitare l’overfitting mantenendo alte le prestazioni di generalizzazione.

2. Tipi principali:

   • L1 (lasso): Penalizza la somma dei valori assoluti dei pesi.
   • L2 (ridge): Penalizza la somma dei quadrati dei pesi.
   • Dropout: Introduce casualità per migliorare la robustezza.

Reti Neurali Convoluzionali (CNN)

Agenda

1. Introduzione
2. Architettura delle CNN
3. Caso studio: Rete VGG
4. Visualizzazione di ciò che le CNN apprendono
5. Transfer Learning

Panoramica sulle CNN

1. Definizione:

   • Le Reti Neurali Convoluzionali sono simili alle reti neurali tradizionali:
     • Costituite da neuroni con pesi e bias apprendibili.
     • Ogni neurone riceve input, esegue un prodotto scalare e applica una non-linearità.
     • L’intera rete esprime una funzione differenziabile.

2. Differenze chiave rispetto alle reti completamente connesse:

   • Le CNN assumono esplicitamente che gli input siano immagini.
   • Questa assunzione consente implementazioni più efficienti e un numero ridotto di parametri da apprendere rispetto alle reti dense.

Architettura delle CNN

1. Struttura 3D:

   • I livelli convolutivi sono organizzati in tre dimensioni:
     • Larghezza (W)
     • Altezza (H)
     • Profondità (C$C$): rappresenta i canali (es. RGB).

2. Livelli:

   • Ogni livello trasforma un volume 3D in un altro volume 3D.

3. Pipeline tipica:

   • Convoluzione → Attivazione → Pooling → Livelli completamente connessi → Output.

Livelli Convolutivi

1. Definizione:

   • Il livello convolutivo è il blocco base delle CNN.
   • Ogni livello applica un insieme di filtri (kernel) apprendibili all’input per produrre mappe di attivazione.
   • Ogni filtro rileva una caratteristica specifica (es. bordi, texture).

2. Parametri principali:

   • Numero di filtri (N): quanti filtri usare.
   • Dimensione del kernel (K): grandezza del filtro (es. 3 \times 3$3 \times 3$, 5 \times 5$5 \times 5$).
   • Stride (S): passo con cui il filtro si muove sull’immagine.
   • Padding (P): aggiunta di bordi per preservare le dimensioni dell’immagine.

3. Operazione di convoluzione:

   • Combina somma e moltiplicazione tra input (I) e kernel (K):
     F(i, j) = \sum_m \sum_n I(i - m, j - n)K(m, n) $F(i, j) = \sum_m \sum_n I(i - m, j - n)K(m, n)$

Local Connectivity e Condivisione dei Parametri

1. Connettività locale:

   • Ogni neurone convolutivo è connesso solo a una piccola regione dell’input (receptive field).
   • Riduce il numero di parametri rispetto alle reti completamente connesse.

2. Condivisione dei parametri:

   • I neuroni di uno stesso filtro condividono i parametri.
   • Questo sfrutta la struttura traslazionale delle immagini, rendendo le CNN efficienti.

Livelli di Pooling

1. Definizione:

   • I livelli di pooling riducono la dimensione spaziale delle mappe di attivazione per migliorare l’efficienza e ridurre l’overfitting.
   • Operano su ciascun canale indipendentemente.

2. Tipi comuni:

   • Max pooling: seleziona il valore massimo in una finestra.
   • Average pooling: calcola la media dei valori nella finestra.

3. Iperparametri:

   • Dimensione finestra (K): es. 2 \times 2$2 \times 2$.
   • Stride (S): passo del pooling.

4. Perché usare il pooling:

   • Robustezza alla posizione delle caratteristiche.
   • Riduzione del costo computazionale.
   • Aumenta il campo recettivo dei livelli successivi.

5. Limitazioni:

   • La perdita di risoluzione spaziale non è sempre vantaggiosa (es. segmentazione semantica).
   • La ricerca attuale mira a rimuovere i livelli di pooling mantenendone i benefici.

Livelli di Attivazione

1. Funzione di attivazione non lineare:

   • Applica una funzione non lineare a ogni valore della mappa di attivazione.
   • Attivazioni comuni:
     • ReLU: f(x) = \max(0, x)$f(x) = \max(0, x)$
     • Sigmoid: \sigma(x) = \frac{1}{1 + e^{-x}}$\sigma(x) = \frac{1}{1 + e^{-x}}$
     • Tanh: \text{tanh}(x) = 2\sigma(x) - 1$\text{tanh}(x) = 2\sigma(x) - 1$

2. ReLU è preferita:

   • Accelera la convergenza rispetto a Sigmoid e Tanh.
   • Facilmente implementabile come soglia.

Calcolo delle Dimensioni di Output

1. Livello convolutivo:
   Dato un input H_1 \times W_1 \times C_1$H_1 \times W_1 \times C_1$, il volume di output ha dimensioni:
   H_2 = \frac{H_1 - K + 2P}{S} + 1, \quad W_2 = \frac{W_1 - K + 2P}{S} + 1, \quad C_2 = N $H_2 = \frac{H_1 - K + 2P}{S} + 1, \quad W_2 = \frac{W_1 - K + 2P}{S} + 1, \quad C_2 = N$

2. Livello di pooling:
   Simile al calcolo convolutivo, con riduzione determinata dalla finestra di pooling e dallo stride.

Caso Studio: Rete VGG

1. Architettura:

   • Progettata per semplicità ed efficacia.
   • Usa filtri convolutivi 3 \times 3$3 \times 3$ con stride 1 e padding 1.
   • Pooling massimo 2 \times 2$2 \times 2$ con stride 2.

2. Punti di forza:

   • Profondità crescente (fino a 19 strati).
   • Prestazioni eccezionali su benchmark come ImageNet.

Transfer Learning

1. Definizione:

   • Riutilizzare una rete pre-addestrata su un nuovo compito.
   • Approccio tipico:
     • Congelare i pesi dei livelli convolutivi.
     • Riaddestrare solo i livelli completamente connessi.

2. Vantaggi:

   • Riduce il tempo di addestramento.
   • Richiede meno dati.

Reti Neurali Ricorrenti (RNN)

Agenda

1. Introduzione
2. RNN “Vanilla”
3. Addestramento di una RNN
4. Architetture RNN Avanzate

Reti Neurali Ricorrenti

1. Definizione:

   • A differenza delle reti neurali feedforward, che hanno un flusso di calcolo diretto dagli input x agli output y tramite i livelli intermedi h, le RNN hanno connessioni di feedback.
   • Questo significa che l’output del modello può essere reintrodotto come input al modello stesso.

2. Specializzazione:

   • Le RNN sono progettate per elaborare sequenze di dati, come testo, audio o serie temporali.
   • Possono gestire sequenze sia in input che in output (es. traduzione automatica).

RNN “Vanilla”

1. Parametri principali:

   • Le RNN “Vanilla” sono definite da tre set di parametri:
     • U: Mappa gli input allo stato nascosto.
     • W: Parametri per la transizione degli stati nascosti.
     • V: Mappa lo stato nascosto all’output.

2. Dinamica del sistema:

   • Lo stato nascosto h(t) è una sintesi delle informazioni passate della sequenza:
     h(t) = \phi(W h(t-1) + U x(t)) $h(t) = \phi(W h(t-1) + U x(t))$
     • Dove \phi$\phi$ è una funzione di attivazione, come \text{tanh}$\text{tanh}$.
   • L’output o(t)$o(t)$:
     o(t) = V h(t) $o(t) = V h(t)$

3. Proprietà dello stato nascosto:

   • Lo stato nascosto h(t)$h(t)$ è una rappresentazione compatta e “perdente” delle informazioni della sequenza passata fino al tempo t.
   • Poiché h(t) è un vettore di dimensioni fisse, non può contenere tutte le informazioni della sequenza, specialmente se questa è lunga.

Unfolding della Computazione

1. Grafi computazionali sequenziali:

   • Le RNN possono essere rappresentate come un grafo computazionale ripetuto nel tempo.
   • Il calcolo di uno stato nascosto al tempo t dipende dagli stati precedenti:
     h(t) = f(h(t-1), x(t); \theta) $h(t) = f(h(t-1), x(t); \theta)$

2. Backpropagation Through Time (BPTT):

   • Addestrare una RNN significa propagare gli errori indietro nel tempo, anziché attraverso i livelli come nelle reti feedforward.
   • Questo approccio è chiamato Backpropagation Through Time (BPTT).

Sfida delle Dipendenze a Lungo Termine

1. Vanishing Gradient Problem:

   • Durante l’addestramento, i gradienti calcolati con la BPTT diminuiscono esponenzialmente mentre si propagano indietro nel tempo.
   • Con funzioni di attivazione come \text{tanh}$\text{tanh}$ o \text{sigmoid}$\text{sigmoid}$, i gradienti tendono a diventare sempre più piccoli, causando una perdita di capacità di apprendere dipendenze a lungo termine.

2. Exploding Gradient Problem:

   • Al contrario, i gradienti possono anche esplodere, diventando numericamente instabili.
   • Soluzioni comuni:
     • Clipping dei gradienti: Limita il valore massimo dei gradienti.
     • Scelta accurata di inizializzazioni dei pesi e funzioni di attivazione.

Architetture Avanzate: LSTM e GRU

1. Problemi delle RNN tradizionali:

   • Le RNN “Vanilla” non gestiscono bene le dipendenze a lungo termine.
   • Soluzione: Architetture avanzate come LSTM (Long Short-Term Memory) e GRU (Gated Recurrent Unit).

2. LSTM:

   • Introducono meccanismi di gating per controllare il flusso di informazioni.
   • Equazioni principali:
     • Cancello di ingresso (i):
       i_t = \sigma(U_i x_t + W_i h_{t-1}) $i_t = \sigma(U_i x_t + W_i h_{t-1})$
     • Cancello di dimenticanza (f):
       f_t = \sigma(U_f x_t + W_f h_{t-1}) $f_t = \sigma(U_f x_t + W_f h_{t-1})$
     • Cancello di output (o):
       o_t = \sigma(U_o x_t + W_o h_{t-1}) $o_t = \sigma(U_o x_t + W_o h_{t-1})$
     • Stato della cella (c_t$c_t$):
       c_t = f_t \odot c_{t-1} + i_t \odot \text{tanh}(U_c x_t + W_c h_{t-1}) $c_t = f_t \odot c_{t-1} + i_t \odot \text{tanh}(U_c x_t + W_c h_{t-1})$
     • Stato nascosto (h_t$h_t$):
       h_t = o_t \odot \text{tanh}(c_t) $h_t = o_t \odot \text{tanh}(c_t)$

3. GRU:

   • Una variante più semplice delle LSTM, con meno parametri.
   • Combinano cancello di ingresso e cancello di dimenticanza in un unico cancello di aggiornamento.

Conclusioni

1. Le RNN sono fondamentali per modellare sequenze temporali, ma hanno limitazioni nella gestione delle dipendenze a lungo termine.
2. Architetture avanzate come LSTM e GRU superano questi problemi con meccanismi di gating.
3. BPTT è l’algoritmo principale per l’addestramento, ma è influenzato dai problemi di vanishing ed exploding gradients.