vault backup: 2024-12-11 13:29:42
This commit is contained in:
parent
f358dcd161
commit
c26179e4fe
16 changed files with 427 additions and 59 deletions
|
|
@ -35,9 +35,9 @@ A questo punto io vorrei massimizzare $$\log\ p(x) = \log\ \int p(x,z) \, dz$$
|
|||
ma come faccio se non posso calcolare l'integrale esatto (mica conosco quelle distribuzioni) e non posso semplificarlo ulteriormente? Posso provare a definire un lower bound (un qualcosa che è sempre minore di $log\ p(x)$ e che però posso calcolarlo).
|
||||
Posso usare un trick e moltiplicare $\frac{q_\phi(z \mid x)}{q_\phi(z \mid x)} = 1$ dentro l'integrale: $$\log p(x) = \log \int p(x,z) \frac{q_\phi(z \mid x)}{q_\phi(z \mid x)} \, dz$$
|
||||
Interpretandola notiamo che $\int q_\phi(z \mid x)\ dz$ non è altro che il valore atteso di quella distribuzione: $$log\ p(x) = \log \mathbb{E}_{{q_{\phi}(z|x)}}\left[ \frac{p(x, z)}{q_{\phi}(z|x)} \right]$$
|
||||
Usando la disuguaglianza di Jensen, sposto il log dentro e ottengo: $$log\ p(x) = \mathbb{E}_{{q_{\phi}(z|x)}}\left[\log \frac{p(x, z)}{q_{\phi}(z|x)} \right]$$
|
||||
Ora uso la formula di Bayes per sostituire $p(x,z)$ come descritto prima: $$log\ p(x) = \mathbb{E}_{{q_{\phi}(z|x)}}\left[\log \frac{p(x∣z)p(z)}{q_{\phi}(z|x)} \right]$$
|
||||
Ora splitto in due il logaritmo (uso le proprietà solite dei logaritmi): $$log\ p(x) = \mathbb{E}_{{q_{\phi}(z|x)}}\left[\log p(x∣z) + \log \frac{p(z)}{q_{\phi}(z|x)} \right]$$
|
||||
Usando la disuguaglianza di Jensen, sposto il log dentro e ottengo: $$log\ p(x) \geq \mathbb{E}_{{q_{\phi}(z|x)}}\left[\log \frac{p(x, z)}{q_{\phi}(z|x)} \right]$$
|
||||
Ora uso la formula di Bayes per sostituire $p(x,z)$ come descritto prima: $$log\ p(x) \geq \mathbb{E}_{{q_{\phi}(z|x)}}\left[\log \frac{p(x∣z)p(z)}{q_{\phi}(z|x)} \right]$$
|
||||
Ora splitto in due il logaritmo (uso le proprietà solite dei logaritmi): $$log\ p(x) \geq \mathbb{E}_{{q_{\phi}(z|x)}}\left[\log p(x∣z) + \log \frac{p(z)}{q_{\phi}(z|x)} \right]$$
|
||||
$$= \mathbb{E}_{{q_{\phi}(z|x)}}\left[\log p(x∣z)\right] + \mathbb{E}_{{q_{\phi}(z|x)}}\left[\log \frac{p(z)}{q_{\phi}(z|x)} \right]$$
|
||||
Ma hey, la seconda parte è la formula della KL divergenza! $$= \mathbb{E}_{{q_{\phi}(z|x)}}\left[\log p(x∣z)\right] + D_{KL}(q_{\phi}(x|z)||p(z))$$
|
||||
Ora possiamo usare questa come funzione loss. La prima parte ci indica quanto bene il modello (decoder) genera l'immagine x dato il vettore z nello spazio latente, è quindi una misura della qualità della ricostruzione dei dati, dovrà essere ottimizzata per migliorare la capacità del modello di ricostruire correttamente gli input x.
|
||||
|
|
|
|||
39
Foundation of data science/notes/9 Decision tree.md
Normal file
39
Foundation of data science/notes/9 Decision tree.md
Normal file
|
|
@ -0,0 +1,39 @@
|
|||
L'algoritmo non è altro che una serie di condizioni if/else che vanno a formare un albero di decisione.
|
||||
Questo albero ci divide il nostro spazio con i dati di training in una griglia.
|
||||
![[Pasted image 20241208151358.png|120]]![[Pasted image 20241208151418.png|200]]
|
||||
|
||||
Un decision tree fatto bene fa in modo che la griglia divida perfettamente tutte le classi. Non è sempre possibile, nei casi in cui nella stessa "cella" si trovano più classi, si va a voto di maggioranza.
|
||||
|
||||
Tutto bello, ma come si traina sto coso?
|
||||
|
||||
#### Training
|
||||
Il processo di training di un _decision tree_ si basa sulla scelta iterativa delle condizioni di splitting, ovvero i criteri che permettono di dividere i dati in due o più sottoinsiemi. Questo processo avviene nodo per nodo, partendo dalla radice fino a raggiungere i nodi foglia.
|
||||
|
||||
1. **Scegliere lo splitting ottimale:**
|
||||
Per ciascun nodo, si seleziona la condizione di splitting che massimizza il _information gain_ (guadagno informativo) o, in alternativa, minimizza una misura di impurità. Le metriche comuni includono:
|
||||
- **Gini Impurity:** misura quanto è probabile classificare in modo errato un campione scelto casualmente.
|
||||
- **Entropy:** derivata dalla teoria dell'informazione, misura il livello di disordine o incertezza in un nodo. Nel nostro caso, è un valore che sarà 0 se un dataset (in our case, il sottoinsieme dato dalla condizione di splitting che stiamo esaminando) contiene solo punti di una classe, sarà 1 se invece è uniformemente distribuito:$$H(D) = \Sigma^n _{i=1}\;p_{i}\; log_{2}(p_{i})$$
|
||||
, nella formula, $p_i$ rappresenta la proporzione di punti appartenenti alla classe $i$.
|
||||
A questo punto si calcola l'**information gain**, considerando l'entropia.
|
||||
La maggior parte delle implementazioni fa uso di alberi binari. In questo caso ogni possibile condizione di splitting divide i dati in due sotto-dataset. Calcoliamo l'entropia $H(D_{1})$ e $H(D_{2})$ dei due sotto-dataset, e definiamo $|D_{1}|$ e $|D_{2}|$ come le loro cardinalità, mentre $|D|$ è la cardinalità del dataset parent (sia $D_{1}$ che $D_{2}$), a questo punto possiamo calcolare il gain come $H(D)-\frac{D_{1}}{D}H(D_{1})-\frac{D_{2}}{D}H(D_{2})$ , più generalmente la formula diventa: $$H(D) - \Sigma^V_{v=1} \frac{|D_{v}|}{|D|}H (D_{v})$$
|
||||
- **Variance Reduction (per problemi di regressione):** misura quanto la divisione riduce la varianza dei valori nei sottoinsiemi.
|
||||
|
||||
2. **Applicare lo splitting:**
|
||||
Una volta scelta la condizione ottimale, il nodo corrente si divide in due o più figli, separando i dati in base alla condizione di splitting.
|
||||
|
||||
3. **Ripetere ricorsivamente:**
|
||||
Il processo viene ripetuto per ciascun nodo figlio, finché:
|
||||
- Non si raggiunge una condizione di stop (ad esempio, una profondità massima dell'albero o un numero minimo di campioni in un nodo).
|
||||
- Il nodo non contiene solo dati di una singola classe (nodo puro).
|
||||
- Non si ottiene un guadagno informativo significativo dallo splitting.
|
||||
|
||||
4. **Gestione dell'overfitting:**
|
||||
Gli alberi di decisione tendono a crescere troppo, creando divisioni molto specifiche per adattarsi perfettamente ai dati di training, il che può portare a sovradattamento. Per evitarlo, si utilizzano tecniche come:
|
||||
- **Pruning (potatura):** rimuovere rami non significativi dopo che l'albero è stato costruito.
|
||||
- **Early Stopping:** fermare la crescita dell'albero quando si raggiunge una soglia predefinita.
|
||||
- **Impostare limiti:** come profondità massima o numero minimo di campioni per nodo.
|
||||
|
||||
5. **Assegnare la classe alle foglie:**
|
||||
Nei nodi foglia, la classe predetta è quella con la maggioranza relativa dei campioni presenti nel nodo (per classificazione). Nei problemi di regressione, invece, la predizione è in genere la media dei valori nei dati del nodo.
|
||||
|
||||
Esistono vari tipi di decision tree, lascio il link: https://www.geeksforgeeks.org/decision-tree-algorithms/
|
||||
107
Foundation of data science/notes/9 Gradient Boosting.md
Normal file
107
Foundation of data science/notes/9 Gradient Boosting.md
Normal file
|
|
@ -0,0 +1,107 @@
|
|||
Il _Gradient Boosting_ è un algoritmo di apprendimento supervisionato basato sull’idea di creare un modello forte combinando molti modelli deboli (solitamente alberi decisionali poco profondi), migliorandoli iterativamente.
|
||||
|
||||
---
|
||||
|
||||
### **Idea Principale**
|
||||
|
||||
A differenza di tecniche come il _bagging_ (ad esempio la Random Forest), che costruiscono modelli indipendenti, il _boosting_ costruisce i modelli in sequenza. Ogni modello successivo cerca di correggere gli errori del modello precedente, utilizzando il **gradiente dell'errore** come guida.
|
||||
|
||||
---
|
||||
|
||||
### **Fasi del Training**
|
||||
|
||||
1. **Inizializzazione:**
|
||||
- Il modello parte con una predizione iniziale, spesso la media dei valori target nel caso della regressione.
|
||||
|
||||
2. **Costruzione iterativa:**
|
||||
- Ad ogni passo mm:
|
||||
1. Si calcola il **residuo** o il gradiente dell'errore per il modello corrente: $$r_i^{(m)} = y_i - F_{m-1}(x_i) \quad \text{(Regressione)} \quad \text{oppure} \quad \nabla L(F_{m-1}, y_i) \quad \text{(Generale)}$$ Dove $F_{m-1}$ è il modello fino all'iterazione precedente.
|
||||
|
||||
2. Si addestra un nuovo modello debole (ad esempio un albero decisionale poco profondo) per predire i residui o il gradiente.
|
||||
|
||||
3. Si aggiorna il modello combinando il modello precedente con il nuovo: $F_m(x) = F_{m-1}(x) + \eta \cdot h_m(x)$ Dove:
|
||||
- $h_m(x)$ è il modello addestrato sui residui.
|
||||
- $\eta$ è il **learning rate**, che controlla l'impatto di $h_m(x)$.
|
||||
|
||||
3. **Ripetizione:**
|
||||
- Il processo si ripete per MM iterazioni, fino a che l'errore non è sufficientemente basso o si raggiunge il numero massimo di modelli.
|
||||
|
||||
---
|
||||
|
||||
### **Vantaggi del Gradient Boosting**
|
||||
|
||||
1. **Alta Accuratezza:**
|
||||
|
||||
- È uno degli algoritmi più potenti, capace di adattarsi a problemi complessi.
|
||||
2. **Flessibilità:**
|
||||
|
||||
- Può gestire obiettivi di regressione, classificazione e anche metriche personalizzate.
|
||||
3. **Controllo di Overfitting:**
|
||||
|
||||
- Parametri come la profondità degli alberi, il numero di iterazioni (MM) e il _learning rate_ (η\eta) aiutano a bilanciare bias e varianza.
|
||||
|
||||
---
|
||||
|
||||
### **Parametri Importanti**
|
||||
|
||||
#### **1. Numero di Iterazioni (n_estimators):**
|
||||
- Numero di alberi o modelli deboli da creare.
|
||||
- Un valore troppo alto può causare overfitting.
|
||||
|
||||
#### **2. Learning Rate ($\eta$):**
|
||||
- Determina la velocità di apprendimento. Valori tipici sono tra 0.01 e 0.2.
|
||||
- Un valore basso richiede più iterazioni, ma migliora la generalizzazione.
|
||||
|
||||
#### **3. Profondità degli Alberi (max_depth):**
|
||||
- Profondità massima degli alberi. Valori bassi (ad esempio, 3-5) sono comuni per mantenere gli alberi "deboli".
|
||||
|
||||
#### **4. Subsample:**
|
||||
- Percentuale di campioni usati per addestrare ogni albero. Valori inferiori a 1 (ad esempio, 0.8) introducono casualità e migliorano la robustezza.
|
||||
|
||||
#### **5. Regolarizzazione ($\lambda, \gamma$):**
|
||||
- Penalizzazioni sull'importanza dei nodi o sulla complessità degli alberi per prevenire overfitting.
|
||||
|
||||
---
|
||||
|
||||
### **Complessità Computazionale**
|
||||
|
||||
- **Training:**
|
||||
Per un albero: O(d⋅nlogn)O(d \cdot n \log n), dove dd è il numero di feature e nn il numero di campioni.
|
||||
Per MM iterazioni: O(M⋅d⋅nlogn)O(M \cdot d \cdot n \log n).
|
||||
|
||||
- **Predizione:**
|
||||
Predire su un campione richiede O(M⋅depth)O(M \cdot \text{depth}), dove depth\text{depth} è la profondità degli alberi.
|
||||
|
||||
|
||||
---
|
||||
|
||||
### **Vantaggi e Svantaggi**
|
||||
|
||||
**Vantaggi:**
|
||||
- Molto accurato su molti dataset.
|
||||
- Flessibile con metriche di errore personalizzate.
|
||||
- In grado di gestire outlier (con algoritmi robusti come Huber loss).
|
||||
|
||||
**Svantaggi:**
|
||||
- Può essere lento da addestrare, soprattutto per grandi dataset.
|
||||
- Richiede ottimizzazione attenta dei parametri per evitare overfitting.
|
||||
- Sensibile al rumore nei dati.
|
||||
|
||||
---
|
||||
|
||||
### **Gradient Boosting vs Random Forest**
|
||||
|
||||
|**Caratteristica**|**Random Forest**|**Gradient Boosting**|
|
||||
|---|---|---|
|
||||
|Costruzione|Alberi indipendenti (in parallelo).|Alberi sequenziali (in serie).|
|
||||
|Tolleranza al rumore|Più robusto al rumore.|Sensibile al rumore nei dati.|
|
||||
|Tempo di training|Più veloce (parallelizzabile).|Più lento, ma ottimizzabile.|
|
||||
|Overfitting|Meno incline.|Maggiore rischio se non regolato.|
|
||||
|
||||
---
|
||||
|
||||
### **Versioni Avanzate**
|
||||
|
||||
1. **XGBoost:** Ottimizza Gradient Boosting con parallelizzazione e tecniche avanzate di regularizzazione.
|
||||
2. **LightGBM:** Usa tecniche di crescita dell'albero basate su foglie, più rapido per dataset molto grandi.
|
||||
3. **CatBoost:** Ottimizzato per feature categoriche, riduce la necessità di pre-elaborazione.
|
||||
38
Foundation of data science/notes/9 K-Nearest Neighbors.md
Normal file
38
Foundation of data science/notes/9 K-Nearest Neighbors.md
Normal file
|
|
@ -0,0 +1,38 @@
|
|||
Algoritmo che può essere usato sia per regression che per classification.
|
||||
|
||||
#### Classificazione
|
||||
ho dei dati di training in un determinato spazio vettoriale in base al numero di feature.
|
||||
Quando voglio classificare un nuovo dato, vedo quali sono i k data point più vicini al dato che voglio classificare sulla base della distanza (tipicamente distanza euclidea).
|
||||
Poi ordino questi k data point (anche detti i k nearest neighbors, ovvero i primi k vicini), e osservo le classi di questi k. Al nuovo data point darò semplicemente la classe maggioritaria che ho osservato tra i neighbors.
|
||||
|
||||
![[Pasted image 20241208150705.png|300]]
|
||||
|
||||
Come scelgo il valore migliore per k? Con la Cross Validation (Grid-Search):
|
||||
- **k piccolo:** poco bias ma tanta varianza: overfitting
|
||||
![[Pasted image 20241208143835.png|100]]
|
||||
- **k grande:** poca varianza ma bias alto: underfitting
|
||||
![[Pasted image 20241208143917.png|100]]
|
||||
- **un buon k** è un trade-off tra i due
|
||||
![[Pasted image 20241208144009.png|100]]
|
||||
|
||||
#### Regression
|
||||
Invece di vedere la classe di maggioranza (anche perché in regression non ci sono le classi), calcolo il valore medio dei neighbors, semplicemente sommo tutti i data point e divido per k.
|
||||
|
||||
#### Metriche per la distanza
|
||||
Si possono usare varie metriche
|
||||
|
||||
##### Distanza euclidea
|
||||
La classica distanza cartesiana, la linea che unisce due punti su un piano.
|
||||
$$d(x,y) = \sum_{j=1}^d \sqrt{(x_j - y_{j})^2}$$
|
||||
##### Distanza di Manhattan
|
||||
Misura la somma delle differenze assolute tra le coordinate. Più robusta ai dati con outlier rispetto alla distanza euclidea. Tendenzialmente alla distanza euclidea se la dimensionalità è alta
|
||||
$$d(x,y) = \sum_{i=1}^n |x_i - y_i|$$
|
||||
##### Distanza di Minkowski
|
||||
La possiamo vedere come una forma più "generale", se vario il parametro $p$
|
||||
- per $p=1$ ho la distanza di Manhattan
|
||||
- per $p=2$ ho la distanza euclidea
|
||||
$$d(x,y) = \left( \sum_{i=1}^n |x_i - y_i|^p \right)^{\frac{1}{p}}$$
|
||||
##### Cosine similarity
|
||||
Quando ci interessa l'angolo tra i vettori più che la distanza, è il coseno dell'angolo tra due vettori. Si usa spesso con vettori di embedding.
|
||||
|
||||
Si possono usare tante altre metriche, io ho riportato le più comuni, per approfondire: https://scikit-learn.org/stable/modules/generated/sklearn.metrics.DistanceMetric.html
|
||||
110
Foundation of data science/notes/9 Random Forest.md
Normal file
110
Foundation of data science/notes/9 Random Forest.md
Normal file
|
|
@ -0,0 +1,110 @@
|
|||
Una _Random Forest_ è un potente algoritmo di apprendimento supervisionato basato sull'idea di combinare molti alberi decisionali (_ensemble learning_). È utile sia per problemi di classificazione che di regressione.
|
||||
|
||||
---
|
||||
|
||||
### **Idea Principale**
|
||||
|
||||
L'algoritmo costruisce molti alberi decisionali su sottoinsiemi casuali del dataset e combina le loro predizioni per ottenere un modello più robusto e preciso.
|
||||
|
||||
- **Classificazione:** Si usa il _voto di maggioranza_ (modalità delle predizioni degli alberi).
|
||||
- **Regressione:** Si usa la _media_ delle predizioni degli alberi.
|
||||
|
||||
---
|
||||
|
||||
### **Fasi del Training**
|
||||
|
||||
1. **Bootstrap Aggregating (Bagging):**
|
||||
|
||||
- Viene creato un sottoinsieme casuale (con rimpiazzo) del dataset originale per ogni albero. Questo approccio riduce l'_overfitting_.
|
||||
2. **Random Subspace (Feature Bagging):**
|
||||
|
||||
- Ad ogni split di un albero, viene considerato un sottoinsieme casuale delle feature. Questo introduce ulteriore diversità tra gli alberi.
|
||||
3. **Crescita degli Alberi:**
|
||||
|
||||
- Ogni albero è costruito indipendentemente dagli altri, senza potatura, quindi può raggiungere la massima profondità.
|
||||
|
||||
---
|
||||
|
||||
### **Vantaggi di Random Forest**
|
||||
|
||||
1. **Robustezza:**
|
||||
|
||||
- La combinazione di più alberi riduce il rischio di overfitting rispetto a un singolo albero.
|
||||
- Resiste al rumore nei dati.
|
||||
2. **Efficienza:**
|
||||
|
||||
- È scalabile e può essere parallelizzato, poiché gli alberi sono indipendenti.
|
||||
3. **Gestione delle Feature:**
|
||||
|
||||
- È efficace anche con dataset ad alta dimensionalità.
|
||||
- Può calcolare l'importanza relativa delle feature, utile per interpretare il modello.
|
||||
4. **Flessibilità:**
|
||||
|
||||
- Funziona bene sia per problemi di classificazione che di regressione.
|
||||
|
||||
---
|
||||
|
||||
### **Parametri Importanti**
|
||||
|
||||
#### **1. Numero di Alberi (n_estimators):**
|
||||
|
||||
- Un valore più alto migliora la robustezza, ma aumenta il tempo di calcolo.
|
||||
- Valore tipico: 100-500.
|
||||
|
||||
#### **2. Numero Massimo di Feature (max_features):**
|
||||
|
||||
- Numero di feature da considerare per ogni split.
|
||||
- Valori comuni:
|
||||
- **Classificazione:** $\sqrt{d}$, dove dd è il numero totale di feature.
|
||||
- **Regressione:** $d/3$.
|
||||
|
||||
#### **3. Profondità Massima dell'Albero (max_depth):**
|
||||
|
||||
- Limita la profondità degli alberi per prevenire overfitting.
|
||||
- Se non specificata, gli alberi cresceranno fino a che ogni nodo foglia contiene meno di `min_samples_split` campioni.
|
||||
|
||||
#### **4. Dimensione del Campione (max_samples):**
|
||||
|
||||
- Percentuale del dataset usata per creare ogni albero.
|
||||
- Di default, è il 100% con rimpiazzo (bagging completo).
|
||||
|
||||
---
|
||||
|
||||
### **Complessità Computazionale**
|
||||
|
||||
- **Training:**
|
||||
Per un singolo albero: $O(d \cdot n \log n)$, dove dd è il numero di feature e nn il numero di campioni.
|
||||
Con TT alberi: $O(T \cdot d \cdot n \log n)$.
|
||||
|
||||
- **Predizione:**
|
||||
Predire su un campione richiede $O(T \cdot \text{depth})$, dove la profondità ($\text{depth}$) è proporzionale a $\log n$.
|
||||
|
||||
|
||||
---
|
||||
|
||||
### **Limiti**
|
||||
|
||||
1. **Lentezza:**
|
||||
|
||||
- L'addestramento può essere costoso con molti alberi o dataset molto grandi.
|
||||
2. **Interpretabilità:**
|
||||
|
||||
- Anche se le singole feature possono essere analizzate, il modello complessivo è meno interpretabile di un singolo albero.
|
||||
3. **Overfitting su Dati Rumorosi:**
|
||||
|
||||
- Se i dati contengono molto rumore, una Random Forest potrebbe comunque sovradattarsi, anche se meno di un singolo albero.
|
||||
|
||||
---
|
||||
|
||||
### **Applicazioni**
|
||||
|
||||
1. **Classificazione:** Diagnosi mediche, analisi di frodi, riconoscimento di immagini.
|
||||
2. **Regressione:** Previsione dei prezzi, analisi delle serie temporali.
|
||||
3. **Selezione di Feature:** Grazie all'analisi dell'importanza delle feature.
|
||||
|
||||
---
|
||||
|
||||
### **Punti Chiave**
|
||||
|
||||
- **Differenza con Bagging:** La Random Forest aggiunge il sottoinsieme casuale di feature al bagging per rendere ogni albero più indipendente.
|
||||
- **Differenza con Gradient Boosting:** La Random Forest crea alberi in parallelo, mentre il Gradient Boosting li costruisce in sequenza ottimizzando errori residui.
|
||||
Loading…
Add table
Add a link
Reference in a new issue