vault backup: 2024-12-11 13:29:42

2024-12-11 13:29:42 +01:00 · 2024-12-11 13:29:42 +01:00 · c26179e4fe
commit c26179e4fe
parent f358dcd161
16 changed files with 427 additions and 59 deletions
--- a/.obsidian/workspace.json
+++ b/.obsidian/workspace.json
@ -4,24 +4,87 @@
    "type": "split",
    "children": [
      {
-        "id": "588a3efa3d0e16de",
+        "id": "10d05f5ce47bfda2",
        "type": "tabs",
        "children": [
          {
-            "id": "029fd45331b34705",
+            "id": "ea6218ee2cf2648c",
            "type": "leaf",
            "state": {
              "type": "markdown",
              "state": {
-                "file": "Foundation of data science/notes/8 Variational Autoencoders.md",
+                "file": "Biometric Systems/notes/12. Iris recognition.md",
                "mode": "source",
                "source": false
              },
              "icon": "lucide-file",
-              "title": "8 Variational Autoencoders"
+              "title": "12. Iris recognition"
+            }
+          },
+          {
+            "id": "21a17cfbfa598cda",
+            "type": "leaf",
+            "state": {
+              "type": "markdown",
+              "state": {
+                "file": "Biometric Systems/notes/3. Recognition Reliability.md",
+                "mode": "source",
+                "source": false
+              },
+              "icon": "lucide-file",
+              "title": "3. Recognition Reliability"
+            }
+          },
+          {
+            "id": "5708c825977190cc",
+            "type": "leaf",
+            "state": {
+              "type": "pdf",
+              "state": {
+                "file": "Biometric Systems/slides/LEZIONE3_Affidabilita_del_riconoscimento.pdf",
+                "page": 40,
+                "left": -20,
+                "top": 349,
+                "zoom": 0.7666666666666667
+              },
+              "icon": "lucide-file-text",
+              "title": "LEZIONE3_Affidabilita_del_riconoscimento"
+            }
+          },
+          {
+            "id": "306ad865c4d76e63",
+            "type": "leaf",
+            "state": {
+              "type": "pdf",
+              "state": {
+                "file": "Biometric Systems/slides/LEZIONE10_Iris recognition.pdf",
+                "page": 33,
+                "left": -4,
+                "top": 44,
+                "zoom": 0.8
+              },
+              "icon": "lucide-file-text",
+              "title": "LEZIONE10_Iris recognition"
+            }
+          },
+          {
+            "id": "aad0ea67df9f4a75",
+            "type": "leaf",
+            "state": {
+              "type": "pdf",
+              "state": {
+                "file": "Biometric Systems/slides/Riassunto_2021_2022.pdf",
+                "page": 1,
+                "left": -154,
+                "top": 846,
+                "zoom": 0.9
+              },
+              "icon": "lucide-file-text",
+              "title": "Riassunto_2021_2022"
            }
          }
-        ]
+        ],
+        "currentTab": 3
      }
    ],
    "direction": "vertical"
@ -52,7 +115,7 @@
            "state": {
              "type": "search",
              "state": {
-                "query": "",
+                "query": "adaboost",
                "matchingCase": false,
                "explainSearch": false,
                "collapseAll": false,
@ -60,7 +123,7 @@
                "sortOrder": "alphabetical"
              },
              "icon": "lucide-search",
-              "title": "Ricerca"
+              "title": "Search"
            }
          },
          {
@ -191,53 +254,53 @@
      "companion:Toggle completion": false
    }
  },
-  "active": "029fd45331b34705",
+  "active": "306ad865c4d76e63",
  "lastOpenFiles": [
-    "Foundation of data science/notes/7 Autoencoders.md",
-    "Foundation of data science/notes/8 Variational Autoencoders.md",
-    "Foundation of data science/images/Pasted image 20241203130242.png",
-    "Foundation of data science/notes/Untitled.md",
+    "Biometric Systems/slides/Biometric_System___Notes.pdf",
+    "Biometric Systems/slides/Riassunto_2021_2022.pdf",
+    "Biometric Systems/slides/LEZIONE3_Affidabilita_del_riconoscimento.pdf",
+    "Biometric Systems/notes/3. Recognition Reliability.md",
+    "Biometric Systems/slides/LEZIONE4_Face introduction and localization.pdf",
+    "Biometric Systems/slides/LEZIONE5_NEW_More about face localization.pdf",
+    "Biometric Systems/slides/LEZIONE1_Introduzione.pdf",
+    "Biometric Systems/slides/LEZIONE2_Indici_di_prestazione.pdf",
+    "Biometric Systems/slides/LEZIONE10_Iris recognition.pdf",
+    "Biometric Systems/notes/12. Iris recognition.md",
+    "Biometric Systems/notes/1. Introduction.md",
+    "Foundation of data science/images/Pasted image 20241208143835.png",
+    "Foundation of data science/images/Pasted image 20241208151418.png",
+    "Foundation of data science/images/Pasted image 20241208151358.png",
+    "Foundation of data science/images/Pasted image 20241208143917.png",
    "Foundation of data science/notes/2 Logistic Regression.md",
+    "Foundation of data science/notes/1 CV Basics.md",
+    "Foundation of data science/notes/3 Multi Class Binary Classification.md",
+    "Foundation of data science/notes/7 Autoencoders.md",
+    "Foundation of data science/notes/9 Gradient Boosting.md",
    "Foundation of data science/notes/6 PCA.md",
+    "Foundation of data science/notes/9 K-Nearest Neighbors.md",
+    "Foundation of data science/notes/9 Decision tree.md",
+    "Foundation of data science/notes/8 Variational Autoencoders.md",
+    "Foundation of data science/notes/9 Random Forest.md",
+    "Biometric Systems/notes/2. Performance indexes.md",
+    "Biometric Systems/notes/dati da considerare.md",
+    "Biometric Systems/slides/lezione1 notes.md",
+    "Foundation of data science/slides/more on nn.pdf",
+    "Pasted image 20241208151757.png",
+    "Foundation of data science/images/Pasted image 20241208150705.png",
+    "Foundation of data science/images/Pasted image 20241208144009.png",
+    "Foundation of data science/notes/Untitled.md",
    "Foundation of data science/notes/4 L1 and L2 normalization.md",
-    "Foundation of data science/notes/5 Neural Networks.md",
+    "Autonomous Networking/notes/5 Drones.md",
+    "Autonomous Networking/notes/6 Internet of Things.md",
+    "Autonomous Networking/notes/3 WSN MAC.md",
+    "Autonomous Networking/notes/4 WSN Routing.md",
+    "Biometric Systems/notes/11. Fingerprints.md",
+    "Biometric Systems/notes/9. Ear recognition.md",
+    "Biometric Systems/notes/8 Face anti spoofing.md",
+    "Foundation of data science/images/Pasted image 20241203130242.png",
    "Foundation of data science/images/Pasted image 20241129142615.png",
    "Foundation of data science/images/Pasted image 20241129150144.png",
-    "Foundation of data science/images/Pasted image 20241129150041.png",
-    "Foundation of data science/images/Pasted image 20241129145900.png",
-    "Pasted image 20241129145845.png",
-    "Foundation of data science/images/Pasted image 20241129144016.png",
-    "Foundation of data science/images/Pasted image 20241129144013.png",
-    "Biometric Systems/images/Pasted image 20241128083519.png",
-    "Biometric Systems/notes/12. Iris recognition.md",
-    "Foundation of data science/slides/Untitled.md",
-    "Biometric Systems/slides/LEZIONE10_Iris recognition.pdf",
-    "Biometric Systems/slides/Riassunto_2021_2022.pdf",
-    "Biometric Systems/slides/Biometric_System___Notes.pdf",
-    "Biometric Systems/images/Pasted image 20241128102138.png",
-    "Biometric Systems/notes/11. Fingerprints.md",
    "Biometric Systems/slides/LEZIONE11_Fingerprints.pdf",
-    "Biometric Systems/notes/9. Ear recognition.md",
-    "Biometric Systems/notes/dati da considerare.md",
-    "Foundation of data science/slides/IP CV Basics.pdf",
-    "Foundation of data science/slides/FDS_backprop_new.pdf",
-    "Foundation of data science/slides/Untitled 1.md",
-    "Foundation of data science/slides/more on nn.pdf",
-    "Autonomous Networking/notes/q&a.md",
-    "Autonomous Networking/notes/presentazione presentante.md",
-    "Biometric Systems/notes/2. Performance indexes.md",
-    "Biometric Systems/slides/LEZIONE9_Ear recognition.pptx.pdf",
-    "Biometric Systems/slides/LEZIONE8_Face antispoofing 1.pdf",
-    "Biometric Systems/notes/8 Face anti spoofing.md",
-    "Biometric Systems/slides/LEZIONE8_Face antispoofing.pdf",
-    "Biometric Systems/notes/7. Face recognition 3D.md",
-    "Autonomous Networking/notes/4 WSN Routing.md",
-    "Autonomous Networking/notes/5 Drones.md",
-    "Biometric Systems/notes/1. Introduction.md",
-    "Biometric Systems/notes/3. Recognition Reliability.md",
-    "Biometric Systems/notes/6. Face recognition 2D.md",
-    "conflict-files-obsidian-git.md",
-    "Autonomous Networking/notes/10 Q-Learning.md",
    "Senza nome.canvas"
  ]
 }
--- a/Systems/notes/1.
+++ b/Systems/notes/1.
@ -13,7 +13,7 @@
 ### Architecture of a Biometric System

 **Enrollment:** processo di cattura dei dati biometrici di un utente, dai quali vengono estratte  *features* ottenendo un feature vector. Aggiungendo informazioni ausiliarie (identità, indirizzo...) otteniamo il template, che viene memorizzato nel *template archive*.
-![[architecture - enrollment.png]]
+![[architecture - recognition.png]]

 **Recognition:** vengono catturati i dati biometrici dell'utente e viene prodotto un template (detto probe), viene fatto un confronto per similarità con i template presenti nell'archive.
 - **verification 1:1** (verifichiamo che l'utente sia chi dice di essere)
@ -23,12 +23,12 @@
 	- Possibili errori:
 		- reject di una probe appartenente ad un soggetto registrato
 		- accept di una probe non appartenente ad un soggetto iscritto
-		- restituzione dell'identtià errata
+		- restituzione dell'identità errata
 - **Closed-Set**:
 	- Possibile errore: restituzione dell'identità errata

 - bisogna definire attentamente una threshold: i sample cambiano nel tempo (es. la mia faccia domani non sarà identica a quella di oggi, e così via...)
-![[architecture - recognition.png]]
+![[architecture - enrollment.png]]

 #### Moduli di un sistema biometrico
 - **sensor module:** acquisisce i dati biometrici
--- a/Systems/notes/12.
+++ b/Systems/notes/12.
@ -67,12 +67,23 @@ The inner contour of the eye may change on illumination changes as pupil dilates
 	- gaze direction can change the relative position of sclera, iris and pupil
 - a normalization procedure is necessary: Rubber Sheet Model
 ![[Pasted image 20241128101031.png]]
-
+L’iris unwrapping è il processo di trasformazione dall'iride circolare in
+coordinate cartesiane in un rettangolo in coordinate pseudopolari.
+Determinare il giusto centro per le coordinate polari è di fondamentale
+importanza, ma la pupilla e l'iride non sono perfettamente concentriche e le
+dimensioni della pupilla possono cambiare a causa dell'illuminazione o di
+condizioni patologiche (ubriachezza o droghe).
 ##### Rubber Sheet Model
 - maps each iris point onto polar coordinates $(r, \theta)$ with $r \in [0, 1]$ and $\theta \in [0, 2\pi]$
 - the model compensates for pupil dilation and size variation by producing a invariant representation
 - does not compensate for rotations. But it is done during matching by translating the templates until alignment
- see slides for the formulas
+
+Il **Rubber Sheet Model** è una tecnica di normalizzazione che si applica in contesti come il riconoscimento dell'iride, dove le distorsioni della pupilla e dell'iride, dovute alla variabilità fisiologica e alla posizione della fotocamera, devono essere correttamente gestite.
+- Si considerano più punti distribuiti lungo ogni raggio che va dal confine della pupilla al confine dell'iride, in modo da normalizzare la distanza che potrebbe essere deformata a causa della dilatazione della pupilla o della deformazione naturale dell'iride.
+- Ogni punto sull'iride viene mappato in un sistema di coordinate polari, con il centro della pupilla che diventa l'origine del sistema di coordinate.
+- La trasformazione avviene tramite una combinazione lineare delle coordinate dei punti sul contorno della pupilla e quelli sul contorno dell'iride, per "distendere" la superficie iridata in modo da correggere le distorsioni.
+
+Questo modello è utile per migliorare l'accuratezza nel riconoscimento dell'iride, poiché permette di ridurre gli effetti di variazioni nella forma e dimensione dell'occhio, garantendo una rappresentazione standardizzata che facilita il confronto tra immagini diverse.

 ##### Daugman: Feature extraction
 - Gabor filters to the image in polar coordinates (formula on slide)
--- a/Systems/notes/2.
+++ b/Systems/notes/2.
@ -63,7 +63,7 @@ each point is paired with the most convenient one. It's not necessarily that poi

 ##### Comparing the results of submitting a template to a Deep Learning model
 - if using deep learning we should use the architecture to extract the embeddings (for both gallery and probe templates): we can delete the classification layer in order to get the embeddings that the architecture would use for the final classification.
- mbeddings can be compard as they were vectors of hand-crafted features.
+- embeddings can be compard as they were vectors of hand-crafted features.

 ### Possible errors: verification
 - Genuine Match (GM, GA): the claimed identity is true and subject is accepted
@ -103,9 +103,9 @@ What if ERR in two systems is the same, but the curves are different?
 We can use ROC curve or DET curve.
 For ROC, we can compute the area below the curve and use it as a metric, the higher the better.

-#### Possible errors: identificaiton - open set
+#### Possible errors: identification - open set
 In an open set identification task, the system determines if the individual's biometric signature matches a signature of someone in the gallery.
-The individual **does not make** and identity claim.
+The individual **does not make** an identity claim.
 - More possible error situations, depending on the matcher and on the threshold
 - A problem may occur if the system returns more possible candidates below the threshold. Who is the right one?
 > [!PDF|yellow] [[LEZIONE2_Indici_di_prestazione.pdf#page=27&selection=0,8,9,8&color=yellow|LEZIONE2_Indici_di_prestazione, p.27]]
--- a/Systems/notes/8
+++ b/Systems/notes/8
@ -125,7 +125,7 @@ Si cerca di individuare i moiré pattern: quel pattern che appare spesso quando

 Possiamo comparare quindi un video reale, dove appaiono solo i pattern della fotocamera che usiamo per acquisire la probe, con il video spoofato dove invece appaiono i moiré pattern.

-I frame del video vengono processati utilizzando MLBT e SIFT, si può fare sia in modo indipendente che combinato.
+I frame del video vengono processati utilizzando MLBP e SIFT, si può fare sia in modo indipendente che combinato.

 Dato un frame, viene diviso in patch di dimensione 32x32 con 16 pixel di overlap tra le patch.

--- a/science/images/Pasted
+++ b/science/images/Pasted
--- a/science/images/Pasted
+++ b/science/images/Pasted
--- a/science/images/Pasted
+++ b/science/images/Pasted
--- a/science/images/Pasted
+++ b/science/images/Pasted
--- a/science/images/Pasted
+++ b/science/images/Pasted
--- a/science/images/Pasted
+++ b/science/images/Pasted
--- a/Autoencoders.md
+++ b/Autoencoders.md
@ -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.
--- a/science/notes/9
+++ b/science/notes/9
@ -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/
--- a/science/notes/9
+++ b/science/notes/9
@ -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⋅nlog⁡n)O(d \cdot n \log n), dove dd è il numero di feature e nn il numero di campioni.  
+    Per MM iterazioni: O(M⋅d⋅nlog⁡n)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.
--- a/science/notes/9
+++ b/science/notes/9
@ -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
--- a/science/notes/9
+++ b/science/notes/9
@ -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.