Machine Learning con Python Lezione #01

Corso di Machine Learning con Python: dalle basi agli algoritmi avanzati, deep learning, NLP e deployment. Teoria, pratica e casi reali.

Per approfondire queste conoscenze segui il corso in aula di Machine Learning con Python

Introduzione al Machine learning

• Cos'è il machine learning?
  • Definizione e panoramica
  • Contesto storico ed evoluzione
  • Applicazioni chiave in diversi ambiti
• Le basi di Python per il machine learning
  • Introduzione a Python
  • Librerie chiave per il machine learning
  • Configurazione dell'ambiente
• Tipi di machine learning
  • Apprendimento supervisionato
  • Apprendimento non supervisionato
  • Apprendimento per rinforzo
  • Apprendimento semi-supervisionato
• Pre-elaborazione dei dati
  • Comprendere i tipi di dati
  • Gestione dei valori mancanti
  • Normalizzazione e standardizzazione dei dati
  • Codifica dei dati categorici
• Ingegneria delle caratteristiche
  • Selezione delle caratteristiche
  • Estrazione delle caratteristiche
  • Analisi delle componenti principali (PCA)
  • Tecniche di riduzione della dimensionalità

Cos'è il machine learning?

Definizione e panoramica

Il machine learning (ML) è un sottoinsieme dell'intelligenza artificiale (IA) incentrato sullo sviluppo di algoritmi e modelli statistici che consentono ai computer di apprendere dai dati e di prendere decisioni o formulare previsioni basandosi su di essi. Invece di essere programmati esplicitamente per eseguire un compito specifico, gli algoritmi di ML individuano schemi, apprendono dalle osservazioni e migliorano le proprie prestazioni nel tempo. In termini più semplici, il machine learning permette ai sistemi di evolversi e adattarsi a nuovi scenari senza intervento umano, apprendendo dai dati passati. Questa capacità di auto-miglioramento ha reso il machine learning uno strumento potente per risolvere problemi complessi in svariati ambiti.

Esistono tre tipi principali di apprendimento automatico:

1. Apprendimento supervisionato: prevede l'addestramento di un modello su dati etichettati, in cui le coppie input-output sono fornite esplicitamente. Il modello apprende una funzione di mappatura e la applica a dati mai visti in precedenza. Tra gli esempi figurano la regressione, la classificazione e la previsione di serie temporali.
2. Apprendimento non supervisionato: opera su dati non etichettati per individuare pattern o strutture nascosti. Tecniche come il clustering e la riduzione della dimensionalità rientrano in questa categoria.
3. Apprendimento per rinforzo (Reinforcement Learning): prevede l'addestramento di agenti a prendere decisioni interagendo con un ambiente e ricevendo feedback sotto forma di ricompense o penalità. Questo metodo è comunemente utilizzato nella robotica e negli algoritmi per i giochi.

Il machine learning sfrutta concetti provenienti dalla matematica, dalla statistica e dall'informatica, configurandosi come una disciplina multidisciplinare. I recenti progressi nella potenza di calcolo, nella disponibilità dei dati e nella progettazione degli algoritmi ne hanno notevolmente accelerato l'adozione e le potenzialità.

Contesto storico ed evoluzione

Le origini del machine learning risalgono alla metà del XX secolo, ma le sue radici affondano in concetti fondamentali della matematica, della statistica e dell'informatica. Di seguito è riportata una cronologia delle tappe fondamentali nell'evoluzione del machine learning:

• Le basi iniziali
  • Anni '40 e '50: Il concetto di apprendimento automatico (machine learning) è emerso dagli studi sull'intelligenza artificiale. Alan Turing, spesso considerato il padre dell'informatica, propose l'idea di una "macchina capace di apprendere" nel suo saggio del 1950 intitolato "Computing Machinery and Intelligence".
  • 1952: Arthur Samuel sviluppò uno dei primi programmi di apprendimento automatico, un algoritmo per il gioco della dama che migliorava le proprie prestazioni attraverso l'auto-apprendimento (giocando contro se stesso).
• Algoritmi iniziali e progressi teorici (anni '60 e '70)
  • Modello del perceptron (1958): Frank Rosenblatt introdusse il perceptron, una rete neurale elementare capace di effettuare classificazioni binarie. Sebbene presentasse dei limiti, gettò le basi per le reti neurali.
  • 1967: Furono sviluppati gli algoritmi del "vicino più prossimo" (Nearest Neighbor), consentendo l'impiego di modelli semplici per il riconoscimento di pattern.
  • Anni '70: l'interesse per le reti neurali diminuì a causa dell'«inverno dell'IA», dovuto in parte alle critiche mosse ai limiti del perceptron, dovuti alla sua architettura che permette di tracciare esclusivamente confini di decisione rettilinei.
• L'ascesa dei metodi statistici (anni '80)
  • Il machine learning ha iniziato a incorporare metodi statistici, rendendo i modelli matematicamente più rigorosi.
  • Alberi di decisione e metodi di ensemble: Algoritmi come ID3 e metodi come il bagging e il boosting hanno iniziato a prendere piede.
  • Retropropagazione (1986): Geoffrey Hinton e altri hanno ravvivato l'interesse per le reti neurali introducendo l'algoritmo di backpropagation, che ha reso possibile un addestramento più efficiente delle reti neurali multistrato.
• Sviluppi moderni (anni '90-2010)
  • Macchine a vettori di supporto (SVM): Negli anni '90, le SVM sono emerse come strumenti potenti per attività di classificazione e regressione, in grado di gestire sia dati linearmente separabili che dati non linearmente separabili.
  • L'era dei Big Data: I primi anni 2000 hanno visto un'esplosione nella generazione di dati, trainata da Internet e dalla digitalizzazione, che ha alimentato i progressi nel machine learning.
  • Deep Learning (anni 2010): I progressi nel deep learning, in particolare nelle reti neurali convoluzionali (CNN) e nelle reti neurali ricorrenti (RNN), hanno reso possibili risultati straordinari nel riconoscimento delle immagini, nell'elaborazione del parlato e nella comprensione del linguaggio naturale.
• Presente e futuro (anni 2020 e oltre)
  • Transformers: Modelli come GPT (Generative Pre-trained Transformer) e BERT hanno rivoluzionato l'elaborazione del linguaggio naturale (NLP).
  • Espansione interdisciplinare: Il machine learning è ormai integrato in svariati settori, tra cui la sanità, la finanza, i sistemi autonomi e altri ancora.
  • Etica e spiegabilità: Le crescenti preoccupazioni riguardo a bias, trasparenza e responsabilità nel machine learning hanno dato impulso a nuove ricerche sull'interpretabilità e sull'equità.

Applicazioni chiave in diversi ambiti

Il machine learning ha trovato applicazioni in quasi tutti i settori industriali. La sua capacità di analizzare grandi quantità di dati, individuare schemi ed effettuare previsioni ha trasformato il modo in cui le aziende operano e risolvono i problemi. Di seguito sono riportate alcune applicazioni significative in diversi ambiti:

1. Assistenza sanitaria
   • Diagnostica e diagnostica per immagini: I modelli di machine learning analizzano immagini mediche (ad esempio radiografie e risonanze magnetiche) per rilevare patologie quali cancro, retinopatia diabetica e malattie cardiovascolari.
   • Scoperta di farmaci: La modellazione predittiva accelera l'identificazione di potenziali candidati farmaci, riducendo i costi e i tempi di sviluppo.
   • Medicina personalizzata: Il machine learning personalizza i piani di trattamento sulla base di dati specifici del paziente, come le informazioni genetiche e la storia clinica.
   • Analisi predittiva: Gli ospedali utilizzano il machine learning per prevedere i ricoveri dei pazienti, ottimizzare l'allocazione delle risorse e identificare i pazienti a rischio.
2. Finanza
   • Rilevamento delle frodi: Gli algoritmi di machine learning individuano anomalie nelle transazioni finanziarie per identificare potenziali frodi.
   • Algorithmic Trading: Le società finanziarie utilizzano il machine learning per analizzare le tendenze di mercato, prevedere i movimenti dei prezzi ed eseguire operazioni nei momenti ottimali.
   • Credit scoring: I modelli di machine learning valutano l'affidabilità creditizia analizzando un'ampia gamma di dati relativi al mutuatario.
   • Gestione del rischio: Le istituzioni finanziarie sfruttano il machine learning per identificare e mitigare i rischi associati a investimenti e prestiti.
3. Vendita al dettaglio ed E-commerce
   • Sistemi di raccomandazione: Piattaforme come Amazon e Netflix utilizzano il machine learning per fornire consigli personalizzati su prodotti e contenuti.
   • Previsione della domanda: I rivenditori utilizzano modelli predittivi per ottimizzare la gestione delle scorte e ridurre le rotture di stock.
   • Analisi del sentiment dei clienti: Le aziende analizzano il feedback e le recensioni dei clienti per migliorare prodotti e servizi.
   • Prezzi dinamici: Il machine learning consente di adeguare i prezzi in tempo reale in base alla domanda, alla concorrenza e ad altri fattori.
4. Trasporti e sistemi autonomi
   • Auto a guida autonoma: Il machine learning è un pilastro della tecnologia dei veicoli autonomi, poiché consente alle auto di riconoscere oggetti, navigare e prendere decisioni in tempo reale.
   • Gestione del traffico: Le città utilizzano il machine learning per ottimizzare il flusso del traffico e ridurre la congestione.
   • Manutenzione predittiva: Le aziende di trasporto sfruttano il machine learning per prevedere quando i veicoli o le infrastrutture necessitano di manutenzione, riducendo al minimo i tempi di inattività.
5. Produzione
   • Controllo qualità: I modelli di machine learning rilevano difetti nei prodotti tramite l'analisi delle immagini e il rilevamento di anomalie.
   • Ottimizzazione della catena di approvvigionamento: L'analisi predittiva ottimizza la pianificazione della produzione, la gestione delle scorte e la logistica.
   • Robotica: Il machine learning potenzia le capacità dei robot industriali, rendendoli più adattabili ed efficienti.
6. Energia e Ambiente
   • Previsione della produzione di energia rinnovabile: Il machine learning prevede la produzione di energia da fonti rinnovabili come il solare e l'eolico.
   • Reti intelligenti: Il machine learning ottimizza la distribuzione dell'energia, riduce gli sprechi e migliora l'affidabilità della rete.
   • Monitoraggio ambientale: I modelli analizzano i dati provenienti da sensori e satelliti per monitorare i cambiamenti climatici, prevedere disastri naturali e tenere sotto controllo la fauna selvatica.
7. Intrattenimento e media
   • Creazione di contenuti: Il machine learning contribuisce alla generazione di musica, arte e video. Strumenti basati sull'IA, come DALL-E e ChatGPT, ne dimostrano le applicazioni creative.
   • Approfondimenti sul pubblico: Le aziende dei media utilizzano il machine learning per analizzare le preferenze degli spettatori e personalizzare i contenuti.
   • Sviluppo di videogiochi: Il machine learning potenzia i comportamenti dei personaggi non giocanti (NPC), la generazione procedurale di contenuti e le analisi di gioco. Gli NPC analizzano le tue mosse e imparano dai tuoi schemi d'attacco.
8. Istruzione
   • Apprendimento personalizzato: Il machine learning adatta i contenuti didattici alle esigenze dei singoli studenti, aiutandoli ad apprendere secondo i propri ritmi.
   • Valutazione automatizzata: Il machine learning automatizza la valutazione di compiti e test, facendo risparmiare tempo agli insegnanti.
   • Traduzione linguistica: Strumenti come Google Translate consentono una comunicazione fluida tra lingue diverse.
9. Sicurezza e sorveglianza
   • Rilevamento delle minacce: Il machine learning potenzia la sicurezza informatica identificando potenziali minacce, come malware e attacchi di phishing.
   • Riconoscimento facciale: I sistemi di sicurezza utilizzano il machine learning per la verifica dell'identità e il controllo degli accessi.
   • Il machine learning automatizza l'analisi dei filmati di sorveglianza, rilevando attività o comportamenti insoliti.
10. Agricoltura
    • Agricoltura di precisione: Il machine learning aiuta gli agricoltori a ottimizzare l'irrigazione, la fertilizzazione e la lotta ai parassiti analizzando i dati provenienti da sensori e droni.
    • Previsione della resa: I modelli predittivi stimano le rese delle colture, agevolando la pianificazione e l'allocazione delle risorse.
    • Monitoraggio del suolo e delle condizioni meteorologiche: Il machine learning analizza la qualità del suolo e le condizioni meteorologiche per migliorare le pratiche agricole.

La versatilità e l'efficacia del machine learning ne fanno una tecnologia indispensabile nel mondo moderno. Dalla promozione di progressi medici salvavita allo stimolo di innovazioni nell'intrattenimento e in altri settori, il suo potenziale continua a crescere man mano che emergono nuove tecniche e applicazioni. Con l'evolversi del settore, affrontare sfide quali la privacy dei dati, i pregiudizi algoritmici e le questioni etiche sarà fondamentale per realizzarne appieno le potenzialità.

Le basi di Python per il machine learning

Introduzione a Python

Python è un linguaggio di programmazione versatile e ampiamente utilizzato, divenuto un pilastro del machine learning e della data science. La sua semplicità, il vasto ecosistema di librerie e il forte supporto della comunità lo rendono una scelta ideale sia per i principianti che per i professionisti. Il machine learning consiste nella creazione di modelli capaci di apprendere dai dati per effettuare previsioni o prendere decisioni. Python semplifica questo processo grazie alla sua sintassi intuitiva e a una vasta gamma di librerie specializzate. Che si tratti di analizzare dati, visualizzare tendenze o sviluppare algoritmi predittivi, Python offre gli strumenti necessari per raggiungere i propri obiettivi.

Tra i motivi principali per cui Python è preferito per il machine learning figurano:

1. Facilità d'uso La sintassi semplice di Python consente agli sviluppatori di concentrarsi sulla risoluzione dei problemi anziché sugli errori di sintassi.
2. Supporto alla comunità Una comunità ampia e attiva significa che puoi trovare risposte a quasi tutti i problemi che incontri.
3. Librerie vaste Le librerie di Python, come NumPy, pandas, Matplotlib e scikit-learn, forniscono tutte le funzionalità necessarie per l'analisi dei dati e il machine learning.
4. Interoperabilità Python può integrarsi facilmente con altri linguaggi e strumenti, rendendolo estremamente adattabile a diversi flussi di lavoro.
5. Scalabilità: Python è in grado di gestire qualsiasi cosa, dai prototipi su piccola scala ai sistemi di machine learning su larga scala.

Questa lezione ti introdurrà alle basi di Python, metterà in evidenza le librerie chiave per il machine learning e fornirà le istruzioni per configurare il tuo ambiente.

Librerie chiave per il machine learning

L'ecosistema di Python comprende diverse librerie potenti che costituiscono le fondamenta del machine learning. Qui presentiamo quattro librerie essenziali: NumPy, pandas, Matplotlib e scikit-learn.

1. NumPy

   NumPy (Numerical Python) è una libreria per il calcolo numerico. Offre supporto per array multidimensionali e una raccolta di funzioni matematiche per operare su tali array. Le caratteristiche principali di NumPy includono:

   • Manipolazione efficiente di array: Gli array NumPy (ndarray) sono più veloci e più efficienti nell'uso della memoria rispetto alle liste Python.
   • Operazioni matematiche: Include operazioni quali la moltiplicazione di matrici, i calcoli statistici e l'algebra lineare.
   • Generazione di numeri casuali: Utile per creare dataset sintetici e inizializzare i pesi del modello.
   001 base

   Primi passi con NumPy e array

   Creazione, indicizzazione e operazioni vettoriali di base su array numerici.

   Download

   import numpy as np
   
   # Crea un array
   arr = np.array([1, 2, 3, 4])
   print(arr)
   # Esegue le operazioni
   print(arr + 2) # Aggiunge 2 a ciascun elemento
   print(np.mean(arr)) # Calcola la media

   [1 2 3 4]
   [3 4 5 6]
   2.5

2. pandas

   pandas è una libreria per la manipolazione e l'analisi dei dati. Offre strutture dati come DataFrame e Series che rendono la gestione dei dati strutturati semplice e intuitiva.

   • DataFrame: Strutture dati tabellari con assi etichettati (righe e colonne).
   • Pulizia dei dati: Funzioni per la gestione dei dati mancanti, il filtraggio e la ristrutturazione dei dataset.
   • Integrazione Funziona perfettamente con NumPy, Matplotlib e altre librerie.
   002 base

   Primi passi con pandas e DataFrame

   Creazione, indicizzazione e operazioni di base su DataFrame.

   Download

   import pandas as pd
   
   # Crea un DataFrame
   data = {
   'Name': ['Alice', 'Bob', 'Charlie'],
   'Age': [25, 30, 35],
   'Salary': [50000, 60000, 70000]
   }
   df = pd.DataFrame(data)
   
   print(df)
   # Analizza data
   print(df.describe()) # Statistiche di sintesi
   print(df[df['Age'] > 28]) # Filtra righe

         Name  Age  Salary
   0    Alice   25   50000
   1      Bob   30   60000
   2  Charlie   35   70000
           Age   Salary
   count   3.0      3.0
   mean   30.0  60000.0
   std     5.0  10000.0
   min    25.0  50000.0
   25%    27.5  55000.0
   50%    30.0  60000.0
   75%    32.5  65000.0
   max    35.0  70000.0
         Name  Age  Salary
   1      Bob   30   60000
   2  Charlie   35   70000

3. Matplotlib

   Matplotlib è una libreria di plotting utilizzata per creare visualizzazioni statiche, interattive e animate. Viene spesso impiegata per esplorare i dati e comunicare i risultati in modo efficace.

   • Grafici 2D: Grafici a linee, grafici a barre, istogrammi, grafici a dispersione, ecc..
   • Personalizzazione: Controllo su ogni aspetto di un grafico (titoli, etichette, legende, ecc.).
   • Integrazione: Funziona bene con pandas e NumPy.
   003 base

   Primi passi con matplotlib e visualizzazione dei dati

   Creazione di grafici e visualizzazioni per analizzare i dati.

   Download

   import matplotlib.pyplot as plt
   
   # Crea data
   x = [1, 2, 3, 4]
   y = [10, 20, 25, 30]
   
   # Crea un Grafico
   plt.plot(x, y, label= 'Trend', color= 'blue', marker='o')
   plt.title('Esempio di Grafico con Matplotlib')
   plt.xlabel('X-asse')
   plt.ylabel('Y-asse')
   plt.legend()
   plt.show()

   
4. scikit-learn

   scikit-learn è una libreria di machine learning che offre strumenti semplici ed efficienti per il data mining e l'analisi dei dati. Supporta sia l'apprendimento supervisionato che quello non supervisionato e si integra bene con altre librerie Python.

   • Algoritmi: Implementa algoritmi quali regressione lineare, alberi di decisione, clustering e macchine a vettori di supporto.
   • Pre-elaborazione: Strumenti per il ridimensionamento delle caratteristiche, la codifica e la suddivisione dei dati.
   • Valutazione del modello: Funzioni per la convalida incrociata e le metriche di prestazione.
   004 base

   Apprendimento supervisionato con scikit-learn

   Machine learning supervisionato: training, test ed errore MSE.

   Download

   # Importazione delle librerie necessarie da scikit-learn
   from sklearn.model_selection import train_test_split
   from sklearn.linear_model import LinearRegression
   from sklearn.metrics import mean_squared_error
   
   # Definizione dei dati
   # X sono le caratteristiche in ingresso (le "domande")
   X = [[1], [2], [3], [4]] # Features
   # y sono i valori target corretti (le "risposte")
   y = [10, 20, 30, 40] # Target
   
   # Suddivisione dei dati in training set e test set
   # l'80% dei dati viene usato per l'addestramento, il 20% per il test
   X_train, X_test, y_train, y_test = train_test_split(
       X, y, test_size=0.2, random_state=42
   )
   
   # Creazione e addestramento del modello di regressione lineare
   model = LinearRegression()
   model.fit(X_train, y_train)
   
   # Step 4: Predizione sui dati di test e valutazione dell'errore
   predictions = model.predict(X_test)
   print(f'Mean Squared Error: {mean_squared_error(y_test, predictions)}')

   Mean Squared Error: 1.262177448353619e-29

   004 Apprendimento supervisionato con scikit-learn

   Lezione 01

   Primo esempio di apprendimento supervisionato con scikit-learn: alleniamo un modello di regressione lineare su pochi dati etichettati e ne valutiamo l'errore di previsione su dati mai visti.

   1. Importazione delle librerie

   from sklearn.model_selection import train_test_split
   from sklearn.linear_model import LinearRegression
   from sklearn.metrics import mean_squared_error

   Il primo passo consiste nell'importare gli strumenti necessari da scikit-learn: la funzione per dividere i dati, il modello di regressione lineare e la metrica per valutarne gli errori.

   • train_test_split e LinearRegression gestiscono rispettivamente la suddivisione dei dati e l'algoritmo di apprendimento
   • mean_squared_error calcola l'errore quadratico medio tra previsioni e valori reali

   Queste tre funzioni provengono da moduli diversi di scikit-learn, la libreria di riferimento per il machine learning classico in Python.

   2. Definizione dei dati (X e y)

   X = [[1], [2], [3], [4]] # Features
   y = [10, 20, 30, 40] # Target

   X rappresenta le caratteristiche in ingresso, mentre y contiene i valori target che il modello deve imparare a prevedere. In questo esempio la relazione è lineare e perfetta: ogni valore di y è dieci volte il corrispondente valore di X.

   • X sono i dati in ingresso, organizzati come una lista di liste.
   • y sono i risultati corretti associati a ciascun valore di X.

   La doppia parentesi quadra in X è necessaria perché scikit-learn si aspetta sempre una tabella di dati, anche con una sola caratteristica per riga.

   3. Suddivisione dei dati in training e test

   X_train, X_test, y_train, y_test = train_test_split(
       X, y, test_size=0.2, random_state=42
   )

   I dati vengono divisi in due gruppi: uno usato per addestrare il modello e uno tenuto da parte per verificarne le prestazioni su dati mai visti.

   • test_size=0.2 riserva il 20% dei dati al test
   • random_state=42 rende la suddivisione riproducibile ad ogni esecuzione.

   Con soli 4 esempi il 20% corrisponde a un solo dato di test: sufficiente per capire il meccanismo, ma non rappresentativo di un caso reale.

   4. Addestramento del modello

   model = LinearRegression()
   model.fit(X_train, y_train)

   Viene creata un'istanza del modello di regressione lineare e la si addestra sui dati di training tramite il metodo fit, che cerca la retta che meglio approssima i punti forniti.

   • LinearRegression() crea il modello, ancora privo di conoscenza.
   • fit() avvia il processo di apprendimento vero e proprio.

   Dato che la relazione tra X e y è perfettamente lineare (y = 10x), il modello troverà una retta praticamente esatta.

   5. Predizione e valutazione dell'errore

   predictions = model.predict(X_test)
   print(f'Mean Squared Error: {mean_squared_error(y_test, predictions)}')

   Il modello addestrato viene usato per prevedere il valore del dato di test, e la previsione viene confrontata con il valore reale tramite il Mean Squared Error, che misura l'errore medio al quadrato.

   • predict() restituisce la stima del modello sui dati di test.
   • mean_squared_error() calcola quanto la previsione si discosta dal valore reale.

   Trattandosi di una relazione perfetta e senza rumore, ci si aspetta un MSE prossimo allo zero.

   Punto chiave da sottolineare

   In questo esempio i dati non contengono rumore: la relazione tra X e y è esatta (y = 10x). Questo rende il modello quasi perfetto, ma non è realistico: nei problemi reali i dati contengono sempre variazioni casuali, e l'MSE sarà un valore significativo, non prossimo a zero.

   In poche parole...

   Il codice mostra un flusso completo di apprendimento supervisionato: si definiscono i dati etichettati, si dividono in training e test, si addestra un modello di regressione lineare e se ne valuta l'errore di previsione. Questo schema (dati, split, fit, predict, evaluate) è alla base della maggior parte degli algoritmi di ML supervisionato.

Configurazione dell'ambiente

Per iniziare a usare Python per il machine learning, dovrai configurare il tuo ambiente. Segui questi passaggi per iniziare:

1. Installare Python

   Scarica e installa Python dal sito ufficiale python.org. Si consiglia di utilizzare Python 3.10 o versioni successive per garantire la compatibilità con le librerie più recenti.

2. Scegli un IDE o un editor di testo

   Alcune opzioni popolari includono:

   • Visual Studio Code VS Code è leggero ma completo: con l'estensione Python ufficiale offre autocompletamento, debug integrato, supporto per ambienti virtuali e Jupyter Notebook. Gratuito, multipiattaforma ed estendibile, è ideale per imparare Python senza la complessità di un IDE pesante.
   • PyCharm IDE ricco di funzionalità per lo sviluppo in Python.
   • Jupyter Notebook Ambiente interattivo basato sul web, ideale per l'esplorazione e la visualizzazione dei dati.
3. Crea un ambiente virtuale

   Gli ambienti virtuali aiutano a gestire le dipendenze e a evitare conflitti tra i progetti.

   # Crea un ambiente virtuale
   python -m venv .venv
   
   # attiva manualmente l'ambiente
   .venv\Scripts\activate
   
   # macOS/Linux
   source .venv/bin/activate
   
   # Seleziona l'interprete Python corretto in VS Code:
   Ctrl+Shift+P
   Python: Select Interpreter
   seleziona l'interprete dentro .venv
   

4. Installa le librerie essenziali

   Usa pip (il gestore di pacchetti di Python) per installare le librerie. Ad esempio:

   #Installa le librerie all'interno dell'ambiente
   python -m pip install numpy pandas scikit-learn matplotlib
   

   In alternativa, prendi in considerazione l'utilizzo di Anaconda, una distribuzione che include numerose librerie preinstallate e un gestore di pacchetti.

5. Verifica la tua configurazione

   Crea uno script di test per verificare che tutto funzioni:

   005 base

   Librerie essenziali per il machine learning

   NumPy, pandas, matplotlib e scikit-learn.

   Download

   import numpy as np
   import pandas as pd
   import matplotlib.pyplot as plt
   from sklearn.linear_model import LinearRegression
   
   print("All libraries imported successfully!")

   All libraries imported successfully!

   Esegui lo script per verificare che non si verifichino errori. Queste nozioni fondamentali ti prepareranno ad approfondire le potenzialità di Python per il machine learning. Una volta predisposto l'ambiente e acquisita familiarità con queste librerie, potrai iniziare a esplorare argomenti avanzati come il deep learning, l'elaborazione del linguaggio naturale e la computer vision.

Tipi di machine learning

Il machine learning (ML) è un sottoinsieme dell'intelligenza artificiale (AI) che consente ai sistemi di apprendere e prendere decisioni basandosi sui dati. In linea generale, il machine learning può essere suddiviso in quattro tipologie principali: apprendimento supervisionato, apprendimento non supervisionato, apprendimento per rinforzo e apprendimento semi-supervisionato. Ciascuna tipologia assolve a scopi specifici e trova impiego in diverse applicazioni, a seconda della natura del problema e dei dati disponibili.

Apprendimento supervisionato

L'apprendimento supervisionato è una delle tipologie più comuni di apprendimento automatico. In questo approccio, il modello viene addestrato utilizzando dati etichettati, per i quali vengono forniti sia le caratteristiche di input che i corrispondenti output (target). L'obiettivo è apprendere una funzione di mappatura che metta in relazione input e output, consentendo al modello di effettuare previsioni accurate su dati nuovi e mai visti in precedenza.

Concetti chiave

• Dati etichettati: Ogni esempio di addestramento include sia le caratteristiche di input che l'output corretto (etichetta).
• Addestramento e test: Il dataset è suddiviso in un training set per l'apprendimento e un testing set per la valutazione delle prestazioni.
• Obbiettivo: Ridurre al minimo l'errore tra gli output previsti e quelli effettivi.

Algoritmi comuni

1. Regressione lineare: Utilizzato per prevedere valori continui (ad es. i prezzi delle case).
2. Regressione logistica: Utilizzato per problemi di classificazione binaria (ad es. rilevamento di spam).
3. Alberi di decisione: Modelli non lineari che suddividono i dati in base ai valori delle caratteristiche.
4. Macchine a vettori di supporto (SVM): Trova un iperpiano che separa le classi con il massimo margine.
5. Reti neurali: Replica il funzionamento del cervello umano; utile per schemi complessi.

Applicazioni

• Rilevamento delle frodi: Identificare le transazioni fraudolente sulla base dei dati storici.
• Assistenza sanitaria: Prevedere malattie o esiti sulla base dei dati dei pazienti.
• Previsione del prezzo delle azioni: Prevedere le tendenze finanziarie utilizzando dati storici di mercato.

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error

# Sample data
X = [[1], [2], [3], [4], [5]] # Input features
y = [2, 4, 6, 8, 10] # Target values

# Split data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2,
                                                    random_state=42)

# Show the split
print(f'Dati di training: {X_train} -> {y_train}')
print(f'Dati di test: {X_test} -> {y_test}')

# Train a linear regression model
model = LinearRegression()
model.fit(X_train, y_train)

# Show the relationship the model has learned (y = coef * x + intercept)
print(f'Relazione trovata: y = {model.coef_[0]:.2f} * x + '
+ f'{model.intercept_:.2f}')

# Make predictions on the test set
predictions = model.predict(X_test)
print(f'Mean Squared Error: {mean_squared_error(y_test, predictions)}')

# Use the model on a brand-new, never-seen value
nuovo_valore = [[10]]
previsione = model.predict(nuovo_valore)
print(f'Previsione per x=10: {previsione[0]:.2f}')

Dati di training: [[5], [3], [1], [4]] -> [10, 6, 2, 8]
Dati di test: [[2]] -> [4]
Relazione trovata: y = 2.00 * x + 0.00
Mean Squared Error: 0.0
Previsione per x=10: 20.00

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error

X = [[1], [2], [3], [4], [5]] # Input features
y = [2, 4, 6, 8, 10] # Target values

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

print(f'Dati di training: {X_train} -> {y_train}')
print(f'Dati di test: {X_test} -> {y_test}')

model = LinearRegression()
model.fit(X_train, y_train)

print(f'Relazione trovata: y = {model.coef_[0]:.2f} * x + {model.intercept_:.2f}')

predictions = model.predict(X_test)
print(f'Mean Squared Error: {mean_squared_error(y_test, predictions)}')

nuovo_valore = [[10]]
previsione = model.predict(nuovo_valore)
print(f'Previsione per x=10: {previsione[0]:.2f}')

Un caso reale

• Prevedere il prezzo di affitto di un locale commerciale conoscendo solo i suoi metri quadri.

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error

# ---------------------------------------------------------
# 1. CREIAMO I DATI
# ---------------------------------------------------------
# Simuliamo, ad esempio, i mq di un locale (X) e il suo prezzo di affitto
# mensile in euro (y). Aggiungiamo un po' di "rumore" casuale, perché
# nella realtà i dati non stanno mai perfettamente su una linea retta.

np.random.seed(42)  # fissiamo il seed per risultati riproducibili

n_campioni = 30
X = np.array([[i] for i in range(20, 20 + n_campioni)])  # mq da 20 a 49
rumore = np.random.normal(loc=0, scale=15, size=n_campioni)
y = 25 * X.flatten() + 100 + rumore  # relazione lineare + rumore

# ---------------------------------------------------------
# 2. DIVIDIAMO I DATI IN TRAINING E TEST
# ---------------------------------------------------------
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# ---------------------------------------------------------
# 3. ADDESTRIAMO IL MODELLO
# ---------------------------------------------------------
modello = LinearRegression()
modello.fit(X_train, y_train)

print(f"Relazione trovata: prezzo = {modello.coef_[0]:.2f} * mq "
      f"+ {modello.intercept_:.2f}")

# ---------------------------------------------------------
# 4. FACCIAMO PREVISIONI E VALUTIAMO L'ERRORE
# ---------------------------------------------------------
previsioni = modello.predict(X_test)
mse = mean_squared_error(y_test, previsioni)
print(f"Mean Squared Error: {mse:.2f}")

# ---------------------------------------------------------
# 5. USIAMO IL MODELLO SU UN DATO NUOVO
# ---------------------------------------------------------
nuovo_mq = [[35]]
prezzo_stimato = modello.predict(nuovo_mq)
print(f"Stima per un locale di 35 mq: {prezzo_stimato[0]:.2f} euro/mese")

Relazione trovata: prezzo = 24.42 * mq + 116.84
Mean Squared Error: 111.27
Stima per un locale di 35 mq: 971.66 euro/mese

n_campioni = 30
X = np.array([[i] for i in range(20, 20 + n_campioni)])  # mq da 20 a 49
y = 25 * X.flatten() + 100 + rumore  # relazione lineare + rumore

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

modello = LinearRegression()
modello.fit(X_train, y_train)
print(f"Relazione trovata: prezzo = {modello.coef_[0]:.2f} * mq + {modello.intercept_:.2f}")

previsioni = modello.predict(X_test)
mse = mean_squared_error(y_test, previsioni)
print(f"Mean Squared Error: {mse:.2f}")

nuovo_mq = [[35]]
prezzo_stimato = modello.predict(nuovo_mq)
print(f"Stima per un locale di 35 mq: {prezzo_stimato[0]:.2f} euro/mese")

Apprendimento non supervisionato

Nell'apprendimento non supervisionato, il modello viene addestrato su dati privi di output etichettati. L'obiettivo è individuare pattern, strutture o relazioni nascosti all'interno dei dati. Questo tipo di apprendimento è utile quando il dataset è sprovvisto di etichette o categorie predefinite.

Concetti chiave

• Dati non etichettati: Vengono fornite solo le caratteristiche di input e non esistono output target.
• Clustering e riduzione della dimensionalità: Dividere un insieme di dati in gruppi (chiamati cluster) e semplificare i dati riducendo il numero di variabili (caratteristiche o colonne) da analizzare, sono compiti comuni nell'apprendimento non supervisionato.
• Obbiettivo: Scoprire schemi o raggruppamenti significativi nei dati.

Algoritmi comuni

1. Clustering K-Means: Suddivide i dati in k cluster in base alla somiglianza.
2. Clustering gerarchico: Costruisce una struttura a albero di cluster.
3. Analisi delle componenti principali (PCA): Riduce la dimensionalità preservando la varianza.
4. t-SNE: Visualizza dati ad alta dimensionalità in uno spazio 2D o 3D.

Applicazioni

• Segmentazione della clientela: Raggruppa i clienti in base al comportamento d'acquisto.
• Rilevamento di anomalie: Identifica valori anomali nel traffico di rete o nelle transazioni finanziarie.
• Sistemi di raccomandazione: Suggerisce prodotti o contenuti in base alle preferenze dell'utente.

from sklearn.cluster import KMeans
import numpy as np

# Dati di esempio: 6 punti nello spazio 2D (coordinate x, y)
# Nota: NON forniamo etichette/categorie ai dati -> apprendimento NON supervisionato
X = np.array([[1, 2], [1, 4], [1, 0], [10, 2], [10, 4], [10, 0]])

# Creiamo il modello K-Means chiedendo di trovare 2 gruppi (cluster)
# random_state=42 fissa il seed casuale per ottenere risultati riproducibili
kmeans = KMeans(n_clusters=2, random_state=42)

# Addestriamo il modello: l'algoritmo analizza i dati e trova da solo
# la struttura sottostante, senza che gli venga detto "questo è giusto/sbagliato"
kmeans.fit(X)

# Stampiamo l'etichetta di cluster assegnata a ciascun punto (0 oppure 1)
# L'ordine corrisponde all'ordine dei punti in X
print(kmeans.labels_)

[0 0 0 1 1 1]

from sklearn.cluster import KMeans
import numpy as np

X = np.array([[1, 2], [1, 4], [1, 0], [10, 2], [10, 4], [10, 0]])

kmeans = KMeans(n_clusters=2, random_state=42)
kmeans.fit(X)

print(kmeans.labels_)

Un caso reale

• La segmentazione clienti, un classico esempio di clustering nel mondo business.

from sklearn.cluster import KMeans  # Importiamo l'algoritmo di clustering
import numpy as np  # Importiamo numpy per gestire gli array

# Definiamo i dati dei clienti (spesa media mensile, numero di visite al mese)
# Nessuna etichetta "tipo cliente" viene fornita al modello
X = np.array([
    [15, 2],   # cliente occasionale
    [18, 3],
    [12, 1],
    [90, 15],  # cliente affezionato
    [95, 18],
    [88, 14],
    [50, 8],   # cliente intermedio
    [55, 9],
])

# Creiamo il modello KMeans chiedendo di trovare 3 gruppi di clienti
# n_init=10 fa ripartire l'algoritmo 10 volte da centri diversi e
# tiene il risultato migliore
kmeans = KMeans(n_clusters=3, random_state=42, n_init=10)

# Addestriamo il modello sui dati, assegnando ogni cliente a un cluster
kmeans.fit(X)

# Visualizziamo i risultati ottenuti
print("Cluster assegnati a ciascun cliente:", kmeans.labels_)
print("Centro di ciascun gruppo (spesa media, visite medie):\n",
      kmeans.cluster_centers_)

Cluster assegnati a ciascun cliente: [0 0 0 1 1 1 2 2]
Centro di ciascun gruppo (spesa media, visite medie):
 [[15.          2.        ]
 [91.         15.66666667]
 [52.5         8.5       ]]

from sklearn.cluster import KMeans
import numpy as np

X = np.array([
    [15, 2],   # cliente occasionale
    [18, 3],
    [12, 1],
    [90, 15],  # cliente affezionato
    [95, 18],
    [88, 14],
    [50, 8],   # cliente intermedio
    [55, 9],
])

kmeans = KMeans(n_clusters=3, random_state=42, n_init=10)

kmeans.fit(X)

print("Cluster assegnati a ciascun cliente:", kmeans.labels_)
print("Centro di ciascun gruppo (spesa media, visite medie):\n", 
      kmeans.cluster_centers_)

Apprendimento per rinforzo

L'apprendimento per rinforzo (RL) è una tipologia di apprendimento automatico in cui un agente interagisce con un ambiente per apprendere una sequenza di azioni che massimizzano una ricompensa cumulativa. A differenza dell'apprendimento supervisionato e non supervisionato, l'RL non si basa su dataset predefiniti, ma apprende attraverso tentativi ed errori.

Concetti chiave

• Agente: Il discente o il decisore.
• Ambiente: Il sistema con cui l'agente interagisce.
• Azioni: Scelte a disposizione dell'agente.
• Ricompensa: Segnale di feedback che indica l'esito positivo di un'azione.
• Politica: Strategia che l'agente segue per decidere le azioni.

Algoritmi comuni

1. Q-Learning: Un metodo basato sul valore che apprende la qualità delle azioni.
2. Deep Q-Network (DQN): Combinano il Q-learning con le reti neurali profonde.
3. Metodi di gradiente della policy: Ottimizzano direttamente la policy.

Applicazioni

• Gioco: Agenti di IA come AlphaGo e il DQN di DeepMind.
• Robotica: Addestrare i robot a eseguire compiti come afferrare oggetti.
• Prezzi dinamici: Adeguare i prezzi in modo dinamico in base a domanda e offerta.

import numpy as np

# STEP 1: Definisce il problema: 3 leve con probabilità di successo nascoste
n_arms = 3
q_values = np.zeros(n_arms)     # Stima corrente del valore di ogni leva
counts = np.zeros(n_arms)       # Numero di volte che ogni leva è stata scelta
true_rewards = [0.2, 0.5, 0.8]  # Probabilità reali di successo
                                # (sconosciute all'agente)

epsilon = 0.1
episodes = 1000

for i in range(episodes):
    # STEP 2: Sceglie la leva con strategia epsilon-greedy
    if np.random.uniform(0, 1) < epsilon:
        action = np.random.randint(n_arms)   # Esplorazione: leva casuale
    else:
        action = np.argmax(q_values)         # Sfruttamento: leva migliore nota

    # STEP 3: Osserva la ricompensa ottenuta tirando la leva scelta
    reward = 1 if np.random.uniform(0, 1) < true_rewards[action] else 0

    # STEP 4: Aggiorna la stima della leva
    # con la media incrementale delle ricompense
    counts[action] += 1
    q_values[action] += (reward - q_values[action]) / counts[action]

print("Stime finali:", q_values)
print("Leva ritenuta migliore:", np.argmax(q_values))

Stime finali: [0.22033898 0.52941176 0.79823594]
Leva ritenuta migliore: 2

import numpy as np
# STEP 1: Definisce il problema: 3 leve con probabilità di successo nascoste
n_arms = 3
q_values = np.zeros(n_arms)     # Stima corrente del valore di ogni leva
counts = np.zeros(n_arms)       # Numero di volte che ogni leva è stata scelta
true_rewards = [0.2, 0.5, 0.8]  # Probabilità reali di successo
                                # (sconosciute all'agente)
epsilon = 0.1
episodes = 1000

if np.random.uniform(0, 1) < epsilon:
    action = np.random.randint(n_arms)   # Esplorazione: leva casuale
else:
    action = np.argmax(q_values)         # Sfruttamento: leva migliore nota

reward = 1 if np.random.uniform(0, 1) < true_rewards[action] else 0

counts[action] += 1
q_values[action] += (reward - q_values[action]) / counts[action]

Apprendimento semi-supervisionato

L'apprendimento semi-supervisionato è un approccio ibrido che sfrutta una piccola quantità di dati etichettati insieme a una grande quantità di dati non etichettati. Questo approccio è utile quando l'etichettatura dei dati è costosa o richiede molto tempo, ma i dati non etichettati sono abbondanti.

Concetti chiave

• Combinazione di dati etichettati e non etichettati: Utilizza entrambi i tipi di dati per addestrare il modello.
• Obbiettivo: Migliora le prestazioni del modello utilizzando dati non etichettati.
• Assunzione: I dati non etichettati forniscono informazioni utili sulla distribuzione dei dati.

Algoritmi comuni

1. Auto-formazione: Il modello viene addestrato su dati etichettati e successivamente utilizzato per etichettare dati non etichettati in modo iterativo.
2. Formazione congiunta: Due modelli vengono addestrati su set di caratteristiche diversi e contribuiscono a etichettare i dati l'uno dell'altro.
3. Metodi basati su grafi: Sfrutta le strutture a grafo per propagare le etichette tra i punti dati.

Applicazioni

• Riconoscimento vocale: Utilizza un set ridotto di audio trascritto insieme a grandi quantità di dati non trascritti.
• Diagnostica per immagini: Combina alcune scansioni etichettate con un ampio set di scansioni non etichettate.
• Elaborazione del linguaggio naturale: Addestra modelli utilizzando dataset di testo parzialmente etichettati.

from sklearn.semi_supervised import LabelPropagation
import numpy as np

# STEP 2: dataset misto - tre punti etichettati (classe 0) e tre
# non etichettati (-1)
X = np.array([[1, 2], [1, 4], [1, 0], [10, 2], [10, 4], [10, 0]])
y = np.array([0, 0, 0, -1, -1, -1])  # -1 = dato non etichettato

# STEP 3: creazione e addestramento del modello di label propagation
model = LabelPropagation()
model.fit(X, y)

# STEP 4: etichette finali dedotte per tutti i punti
# (compresi quelli non etichettati)
print("Etichette propagate:", model.transduction_)

# Bonus: livello di confidenza del modello per ogni etichetta assegnata
print("Distribuzione di probabilita\':")
print(model.label_distributions_)

Etichette propagate: [0 0 0 0 0 0]
Distribuzione di probabilita':
[[1.]
 [1.]
 [1.]
 [0.]
 [0.]
 [0.]]

from sklearn.semi_supervised import LabelPropagation
import numpy as np

X = np.array([[1, 2], [1, 4], [1, 0], [10, 2], [10, 4], [10, 0]])
y = np.array([0, 0, 0, -1, -1, -1])  # -1 = dato non etichettato

model = LabelPropagation()
model.fit(X, y)

print("Etichette propagate:", model.transduction_)

print("Distribuzione di probabilita\':")
print(model.label_distributions_)

Un caso reale

• Apprendimento Semi-supervisionato su un dataset più "realistico" (digits).

from sklearn.datasets import load_digits
from sklearn.semi_supervised import LabelSpreading
import numpy as np

# Caricamento del dataset digits (immagini 8x8 di cifre manoscritte)
digits = load_digits()
X = digits.data                # Feature: pixel delle immagini appiattiti
y = np.copy(digits.target)     # Copia delle etichette reali,
                               # per poterle modificare

# Simulazione di uno scenario con pochi dati etichettati
# Generatore casuale riproducibile
rng = np.random.RandomState(42)
# Selezioniamo il 90% dei campioni da "nascondere"
mask = rng.rand(len(y)) < 0.9
# -1 indica etichetta sconosciuta per scikit-learn
y[mask] = -1

n_labeled = np.sum(~mask)
print("Campioni etichettati disponibili:", n_labeled, "su", len(y))

# STEP 3: Creazione e addestramento del modello di propagazione delle etichette
model = LabelSpreading(kernel='knn', n_neighbors=7)
model.fit(X, y)

# STEP 4: Valutazione dell'accuratezza sui campioni originariamente nascosti
accuracy = (model.transduction_[mask] == digits.target[mask]).mean()
print("Accuratezza sui dati originariamente nascosti:", accuracy)

Campioni etichettati disponibili: 181 su 1797
Accuratezza sui dati originariamente nascosti: 0.9665841584158416

from sklearn.datasets import load_digits
from sklearn.semi_supervised import LabelSpreading
import numpy as np

# STEP 1: Caricamento del dataset digits (immagini 8x8 di cifre manoscritte)
digits = load_digits()
X = digits.data                # Feature: pixel delle immagini appiattiti
y = np.copy(digits.target)     # Copia delle etichette reali, per poterle modificare

# STEP 2: Simulazione di uno scenario con pochi dati etichettati
rng = np.random.RandomState(42)        # Generatore casuale riproducibile
mask = rng.rand(len(y)) < 0.9          # Selezioniamo il 90% dei campioni da "nascondere"
y[mask] = -1                           # -1 indica etichetta sconosciuta per scikit-learn

n_labeled = np.sum(~mask)
print("Campioni etichettati disponibili:", n_labeled, "su", len(y))

# Creazione e addestramento del modello di propagazione delle etichette
model = LabelSpreading(kernel='knn', n_neighbors=7)
model.fit(X, y)

# Valutazione dell'accuratezza sui campioni originariamente nascosti
accuracy = (model.transduction_[mask] == digits.target[mask]).mean()
print("Accuratezza sui dati originariamente nascosti:", accuracy)

Pre-elaborazione dei dati

La pre-elaborazione dei dati è una fase cruciale nella pipeline di machine learning. Essa garantisce che i dati utilizzati per addestrare un modello siano puliti, coerenti e strutturati in modo adeguato, migliorando così le prestazioni e l'accuratezza del modello stesso. Approfondiamo quattro aspetti fondamentali della pre-elaborazione dei dati:

1. Comprendere i tipi di dati
2. Gestione dei valori mancanti
3. Normalizzazione e standardizzazione dei dati
4. Codifica dei dati categorici

Comprendere i tipi di dati

I dati si presentano in varie forme e comprendere le tipologie di dati con cui si ha a che fare è fondamentale per scegliere le tecniche di pre-elaborazione e gli algoritmi di machine learning più adeguati.

Tipi di dati

1. Dati numerici:

   Rappresentano grandezze misurabili.

   • Dati continui: i valori possono assumere qualsiasi numero all'interno di un intervallo (ad es. altezza, temperatura).
   • Dati discreti: I valori sono numerabili e finiti (ad esempio, il numero di studenti in una classe).
2. Dati categorici:
   • Rappresentano categorie o gruppi.
   • Esempi includono il genere (maschio/femmina) e il colore (rosso/verde/blu/nero).
3. Dati ordinali:
   • Un tipo di dati categorici in cui le categorie presentano un ordine o una classificazione significativa.
   • Tra gli esempi figurano il livello di istruzione (scuola superiore, laurea di primo livello, laurea magistrale)
4. Dati testuali:
   • Dati non strutturati sotto forma di testo (ad es. recensioni dei clienti, post sui social media).
5. Dati di serie storiche:
   • Punti dati raccolti o registrati a intervalli di tempo specifici.
   • Tra gli esempi figurano i prezzi delle azioni e i dati meteorologici.
6. Dati booleani:
   • Rappresentano risultati binari (Vero/Falso, 0/1).

Importanza dei tipi di dati nella pre-elaborazione

• Identificare i tipi di dati garantisce l'applicazione delle trasformazioni corrette.
• Ad esempio, la normalizzazione è adatta ai dati continui, ma non a quelli categorici.
• Una gestione errata dei tipi di dati può portare a prestazioni del modello fuorvianti e a errori durante l'addestramento.

import pandas as pd

# Dataset di esempio con valori mancanti e tipi eterogenei
data = {
    'Age': [25, 30, 35, None],
    'Gender': ['Male', 'Female', 'Male', 'Female'],
    'Salary': [50000, 60000, 70000, None],
    'Married': [True, False, True, None]
}

# Creazione del DataFrame
df = pd.DataFrame(data)

# Ispezione dei tipi di dati inferiti automaticamente da pandas
print("Tipi di dati originali:")
print(df.dtypes)
print()

# Conversione ai tipi di dati "nullable"
# Intero che supporta NaN (pd.NA)
df['Age'] = df['Age'].astype('Int64')
# Categoria per valori discreti ripetuti
df['Gender'] = df['Gender'].astype('category')
# Float nullable esplicito
df['Salary'] = df['Salary'].astype('Float64')
# Booleano che supporta NaN (pd.NA)
df['Married'] = df['Married'].astype('boolean')

# Verifica dei tipi dopo la conversione
print("Tipi di dati dopo la conversione:")
print(df.dtypes)
print()
print(df)

Tipi di dati originali:
Age        float64
Gender      object
Salary     float64
Married     object
dtype: object

Tipi di dati dopo la conversione:
Age           Int64
Gender     category
Salary      Float64
Married     boolean
dtype: object

    Age  Gender   Salary  Married
0    25    Male  50000.0     True
1    30  Female  60000.0    False
2    35    Male  70000.0     True
3    Female          

# Dataset di esempio con valori mancanti e tipi eterogenei
data = {
    'Age': [25, 30, 35, None],
    'Gender': ['Male', 'Female', 'Male', 'Female'],
    'Salary': [50000, 60000, 70000, None],
    'Married': [True, False, True, None]
}

# Creazione del DataFrame
df = pd.DataFrame(data)

# Ispezione dei tipi di dati inferiti automaticamente da pandas
print("Tipi di dati originali:")
print(df.dtypes)

# Conversione ai tipi di dati "nullable"
df['Age'] = df['Age'].astype('Int64')            # Intero che supporta NaN (pd.NA)
df['Gender'] = df['Gender'].astype('category')   # Categoria per valori discreti ripetuti
df['Salary'] = df['Salary'].astype('Float64')    # Float nullable esplicito
df['Married'] = df['Married'].astype('boolean')  # Booleano che supporta NaN (pd.NA)

# Verifica dei tipi dopo la conversione
print("Tipi di dati dopo la conversione:")
print(df.dtypes)
print()
print(df)

Gestione dei valori mancanti

I valori mancanti rappresentano un problema comune nei dataset e possono influire in modo significativo sulle prestazioni di un modello di machine learning. Una gestione adeguata dei valori mancanti è fondamentale per costruire modelli robusti.

Cause dei valori mancanti

1. Errori di inserimento dati
2. Malfunzionamento dell'apparecchiatura
3. Preoccupazioni relative alla privacy che portano a risposte incomplete
4. Problemi di unione dei dati

Identificazione dei valori mancanti

• Utilizza librerie Python come pandas per individuare i valori mancanti.
• Metodi:
  • isnull() o notnull()
  • info() per un riepilogo dei valori mancanti

import pandas as pd

# Dataset di esempio con valori mancanti e tipi eterogenei
data = {
    'Age': [25, 30, 35, None],
    'Gender': ['Male', 'Female', 'Male', 'Female'],
    'Salary': [50000, 60000, 70000, None],
    'Married': [True, False, True, None]
}

# Creazione del DataFrame a partire dal dizionario
df = pd.DataFrame(data)
print("DataFrame originale:")
print(df)

# Identificazione dei valori mancanti: matrice booleana True/False
print("\nMatrice dei valori mancanti:")
print(df.isnull())

# Conteggio dei valori mancanti per ciascuna colonna
print("\nConteggio valori mancanti per colonna:")
print(df.isnull().sum())

# Rimozione delle righe con almeno un valore mancante
df_dropped = df.dropna()
print("\nDataFrame dopo dropna():")
print(df_dropped)

# Sostituzione dei valori mancanti con strategie differenziate per colonna
# Sostituzione dei valori mancanti con valori di default
df_filled = df.copy()
df_filled['Age'] = df_filled['Age'].fillna(df_filled['Age'].mean())
df_filled['Salary'] = df_filled['Salary'].fillna(df_filled['Salary'].median())
# Conversione esplicita al tipo nullable 'boolean' prima del fillna
# per evitare il FutureWarning sul downcasting implicito di pandas
df_filled['Married'] = df_filled['Married'].astype('boolean').fillna(False)
print(df_filled)

DataFrame originale:
    Age  Gender   Salary Married
0  25.0    Male  50000.0    True
1  30.0  Female  60000.0   False
2  35.0    Male  70000.0    True
3   NaN  Female      NaN    None

Matrice dei valori mancanti:
     Age  Gender  Salary  Married
0  False   False   False    False
1  False   False   False    False
2  False   False   False    False
3   True   False    True     True

Conteggio valori mancanti per colonna:
Age        1
Gender     0
Salary     1
Married    1
dtype: int64

DataFrame dopo dropna():
    Age  Gender   Salary Married
0  25.0    Male  50000.0    True
1  30.0  Female  60000.0   False
2  35.0    Male  70000.0    True
    Age  Gender   Salary  Married
0  25.0    Male  50000.0     True
1  30.0  Female  60000.0    False
2  35.0    Male  70000.0     True
3  30.0  Female  60000.0    False

import pandas as pd

# Dataset di esempio con valori mancanti e tipi eterogenei
data = {
    'Age': [25, 30, 35, None],
    'Gender': ['Male', 'Female', 'Male', 'Female'],
    'Salary': [50000, 60000, 70000, None],
    'Married': [True, False, True, None]
}

# Creazione del DataFrame a partire dal dizionario
df = pd.DataFrame(data)
print("DataFrame originale:")
print(df)

# Identificazione dei valori mancanti: matrice booleana True/False
print("\nMatrice dei valori mancanti:")
print(df.isnull())

# Conteggio dei valori mancanti per ciascuna colonna
print("\nConteggio valori mancanti per colonna:")
print(df.isnull().sum())

# Rimozione delle righe con almeno un valore mancante
df_dropped = df.dropna()
print("\nDataFrame dopo dropna():")
print(df_dropped)

# Sostituzione dei valori mancanti con strategie differenziate per colonna
# Sostituzione dei valori mancanti con valori di default
df_filled = df.copy()
df_filled['Age'] = df_filled['Age'].fillna(df_filled['Age'].mean())
df_filled['Salary'] = df_filled['Salary'].fillna(df_filled['Salary'].median())
# Conversione esplicita al tipo nullable 'boolean' prima del fillna
# per evitare il FutureWarning sul downcasting implicito di pandas
df_filled['Married'] = df_filled['Married'].astype('boolean').fillna(False)
print(df_filled)

Strategie per gestire i valori mancanti

1. Rimuovere valori mancanti:
   • Eliminare righe o colonne con dati mancanti.
   • Indicato quando la percentuale di dati mancanti è ridotta.

   # Elimina le righe con valori mancanti
   df_cleaned = df.dropna()

2. Imputazione:
   • Sostituire i valori mancanti con sostituti appropriati.
   • Tecniche:
     • Imputazione basata su media, mediana o moda per dati numerici.
     • Valore costante o categoria più frequente per i dati categorici.

     # Riempire i valori numerici mancanti con la media
     df['Age'] = df['Age'].fillna(df['Age'].mean())

     Il metodo mean() calcola la media aritmetica dei valori non nulli della colonna 'Age', e fillna() la usa per sostituire ogni valore mancante.

     # Riempire i valori categorici mancanti con la moda
     df['Gender'] = df['Gender'].fillna(df['Gender'].mode()[0])

     mode() restituisce tutti i valori più frequenti della colonna sotto forma di Series; per questo si usa [0] per prendere il primo valore modale e passarlo a fillna()

3. Tecniche avanzate di imputazione:
   • Utilizzare algoritmi di apprendimento automatico per prevedere i valori mancanti.
   • Librerie come sklearn.impute offrono strumenti quali KNNImputer.

Normalizzazione e standardizzazione dei dati

La normalizzazione e la standardizzazione sono tecniche utilizzate per scalare le caratteristiche numeriche, in modo che contribuiscano in misura uguale a un modello di machine learning. Ciò è particolarmente importante per gli algoritmi sensibili all'ordine di grandezza delle caratteristiche.

Normalizzazione

La normalizzazione scala i dati in un intervallo specifico, solitamente [0, 1]. È utile quando si desidera che tutte le caratteristiche abbiano la stessa scala, senza distorcere le differenze all'interno dell'intervallo.

import numpy as np
from sklearn.preprocessing import MinMaxScaler

# Dati di esempio: due feature con scale molto diverse tra loro
# Colonna 1: valori piccoli (1-5), Colonna 2: valori grandi (900-1800)
dati = np.array([
    [1, 1000],
    [2, 1500],
    [3, 1200],
    [4, 1800],
    [5, 900]
])

# Creazione dello scaler con range di normalizzazione esplicito [0, 1]
scaler = MinMaxScaler(feature_range=(0, 1))

# fit: calcola min e max per colonna
# transform: applica la formula (x - min) / (max - min)
dati_normalizzati = scaler.fit_transform(dati)

print("Dati originali:\n", dati)
print("\nDati normalizzati:\n", dati_normalizzati)

# Verifica: è possibile tornare ai valori originali grazie ai parametri
# appresi durante il fit (min e max di ogni colonna)
dati_originali_ricostruiti = scaler.inverse_transform(dati_normalizzati)
print("\nDati ricostruiti (inverse_transform):\n", dati_originali_ricostruiti)

Dati originali:
 [[   1 1000]
 [   2 1500]
 [   3 1200]
 [   4 1800]
 [   5  900]]

Dati normalizzati:
 [[0.         0.11111111]
 [0.25       0.66666667]
 [0.5        0.33333333]
 [0.75       1.        ]
 [1.         0.        ]]

Dati ricostruiti (inverse_transform):
 [[1.0e+00 1.0e+03]
 [2.0e+00 1.5e+03]
 [3.0e+00 1.2e+03]
 [4.0e+00 1.8e+03]
 [5.0e+00 9.0e+02]]

import numpy as np
from sklearn.preprocessing import MinMaxScaler

# Dati di esempio: due feature con scale molto diverse tra loro
# Colonna 1: valori piccoli (1-5), Colonna 2: valori grandi (900-1800)
dati = np.array([
    [1, 1000],
    [2, 1500],
    [3, 1200],
    [4, 1800],
    [5, 900]
])

# Creazione dello scaler con range di normalizzazione esplicito [0, 1]
scaler = MinMaxScaler(feature_range=(0, 1))

# fit: calcola min e max per colonna
# transform: applica la formula (x - min) / (max - min)
dati_normalizzati = scaler.fit_transform(dati)

print("Dati originali:\n", dati)
print("\nDati normalizzati:\n", dati_normalizzati)

# Verifica: è possibile tornare ai valori originali grazie ai parametri
# appresi durante il fit (min e max di ogni colonna)
dati_originali_ricostruiti = scaler.inverse_transform(dati_normalizzati)
print("\nDati ricostruiti (inverse_transform):\n", dati_originali_ricostruiti)

Standardizzazione

La standardizzazione scala i dati in modo che abbiano una media pari a 0 e una deviazione standard pari a 1. È utile quando i dati seguono una distribuzione gaussiana o quando gli algoritmi presuppongono una distribuzione normale standard.

from sklearn.preprocessing import StandardScaler
import numpy as np

# Dati di esempio: punteggi ottenuti da 5 studenti in un test (scala 0-100)
data = [[50], [60], [70], [80], [90]]

# Convertiamo in array numpy per calcolare statistiche descrittive
data_array = np.array(data)

# Calcoliamo media e deviazione standard originali,
# utili per il confronto successivo
print(f"Media originale: {data_array.mean():.2f}")
print(f"Deviazione standard originale: {data_array.std():.2f}")

# Creiamo l'oggetto StandardScaler, che si occuperà di standardizzare i dati
scaler = StandardScaler()

# fit_transform calcola media e deviazione standard dai dati (fit)
# e applica subito la trasformazione (transform)
standardized_data = scaler.fit_transform(data)

print("Dati standardizzati:")
print(standardized_data)

# Verifichiamo che i dati standardizzati abbiano media 0 e
# deviazione standard 1
print(f"Media dopo standardizzazione: {standardized_data.mean():.2f}")
print(f"Deviazione standard dopo standardizzazione:" +
  f"{standardized_data.std():.2f}")

Media originale: 70.00
Deviazione standard originale: 14.14
Dati standardizzati:
[[-1.41421356]
 [-0.70710678]
 [ 0.        ]
 [ 0.70710678]
 [ 1.41421356]]
Media dopo standardizzazione: 0.00
Deviazione standard dopo standardizzazione:1.00

from sklearn.preprocessing import StandardScaler
import numpy as np

# Convertiamo in array numpy per calcolare facilmente statistiche descrittive
data_array = np.array(data)

# Calcoliamo media e deviazione standard originali, utili per il confronto successivo
print(f"Media originale: {data_array.mean():.2f}")
print(f"Deviazione standard originale: {data_array.std():.2f}")

# Creiamo l'oggetto StandardScaler, che si occuperà di standardizzare i dati
scaler = StandardScaler()

# fit_transform calcola media e deviazione standard dai dati (fit) e applica subito la trasformazione (transform)
standardized_data = scaler.fit_transform(data)

print("Dati standardizzati:")
print(standardized_data)

# Verifichiamo che i dati standardizzati abbiano media 0 e deviazione standard 1
print(f"Media dopo standardizzazione: {standardized_data.mean():.2f}")
print(f"Deviazione standard dopo standardizzazione: {standardized_data.std():.2f}")

Quando utilizzare la Normalizzazione e la Standardizzazione

• Utilizza la normalizzazione quando le caratteristiche hanno intervalli diversi e desideri che vengano scalate proporzionalmente.
• Utilizza la standardizzazione per algoritmi come SVM o PCA, che sono sensibili alla scala delle feature.

Codifica dei dati categorici

I modelli di machine learning operano con dati numerici; pertanto, i dati categorici devono essere codificati in formato numerico. Esistono diverse tecniche di codifica, ciascuna adatta a specifiche tipologie di dati.

1. Codifica delle etichette
   • Assegna un valore numerico univoco a ciascuna categoria.
   • Adatto per dati ordinali.
   017 base

   Codifica delle Etichette con LabelEncoder: Trasformare Categorie in Numeri

   Download

   from sklearn.preprocessing import LabelEncoder
   
   # Preparazione dei dati
   # Definiamo una lista di dati categorici testuali (genere), tipico esempio
   # di variabile nominale che deve essere convertita in formato numerico
   # prima di essere utilizzata da un algoritmo di Machine Learning
   generi = ['Male', 'Female', 'Female', 'Male']
   
   # Creazione dell'encoder
   # Istanziamo l'oggetto LabelEncoder. In questa fase l'oggetto non ha
   # ancora appreso nulla: non conosce ancora le categorie presenti nei dati
   label_encoder = LabelEncoder()
   
   # Addestramento e trasformazione
   # fit_transform esegue due operazioni in un unico passaggio:
   # 1) fit: individua le categorie uniche e le ordina alfabeticamente
   # 2) transform: assegna a ciascuna categoria un numero intero progressivo
   etichette_codificate = label_encoder.fit_transform(generi)
   print("Etichette codificate:", etichette_codificate)
   
   # L'attributo classes_ mostra le categorie originali nell'ordine
   # utilizzato per la codifica (ordine alfabetico crescente)
   print("Classi individuate:", label_encoder.classes_)
   
   # Mappatura leggibile e decodifica inversa
   # Costruiamo un dizionario esplicito per rendere subito chiara
   # la corrispondenza tra ciascuna categoria testuale e il relativo codice numerico
   mappatura = dict(zip(label_encoder.classes_, label_encoder.transform(label_encoder.classes_)))
   print("Mappatura classe -> numero:", mappatura)
   
   # inverse_transform riporta i valori numerici alle etichette testuali originali
   # operazione fondamentale per interpretare le predizioni di un modello
   decodificato = label_encoder.inverse_transform(etichette_codificate)
   print("Valori decodificati:", decodificato)
   
   # Nota didattica: con solo due categorie l'ordine numerico non crea ambiguità,
   # ma con tre o più categorie nominali (es. 'Rosso', 'Verde', 'Blu') l'ordine
   # alfabetico implicito potrebbe essere erroneamente interpretato come una
   # relazione d'ordine dall'algoritmo: in quei casi è preferibile OneHotEncoder

   Etichette codificate: [1 0 0 1]
   Classi individuate: ['Female' 'Male']
   Mappatura classe -> numero: {np.str_('Female'): np.int64(0), np.str_('Male'): np.int64(1)}
   Valori decodificati: ['Male' 'Female' 'Female' 'Male']

   017 Codifica delle Etichette con LabelEncoder: Trasformare Categorie in Numeri

   Lezione 01

   Molti algoritmi di Machine Learning richiedono input numerici e non sono in grado di lavorare direttamente con valori testuali. LabelEncoder di scikit-learn risolve questo problema trasformando le categorie testuali in numeri interi. Vedremo come applicarlo e come interpretarne correttamente i risultati.

   1. Importazione e preparazione dei dati

   from sklearn.preprocessing import LabelEncoder
   
   generi = ['Male', 'Female', 'Female', 'Male']

   Importiamo la classe LabelEncoder dal modulo di preprocessing di scikit-learn e definiamo una lista di dati categorici testuali, in questo caso valori relativi al genere.

   • LabelEncoder è una classe pensata per trasformare etichette categoriche in valori numerici interi.
   • generi è una lista Python contenente stringhe ripetute, che rappresentano le categorie da codificare.

   I dati testuali sono comuni nei dataset reali, ma la maggior parte degli algoritmi di Machine Learning richiede input numerici per poter effettuare calcoli.

   Prima di applicare qualsiasi codifica è buona norma osservare quali e quante categorie distinte sono presenti nei dati.

   2. Creazione dell'encoder

   # Creazione dell'oggetto LabelEncoder
   label_encoder = LabelEncoder()

   Creiamo un'istanza di LabelEncoder. In questa fase l'oggetto non ha ancora appreso nulla dai dati: si tratta semplicemente dell'inizializzazione dello strumento che utilizzeremo per la codifica.

   • label_encoder è l'oggetto che memorizzerà la corrispondenza tra categorie e numeri una volta addestrato.
   • LabelEncoder() non richiede parametri: la logica di codifica è sempre la stessa, basata sull'ordine alfabetico delle categorie.

   Come per molti trasformatori di scikit-learn, la creazione dell'oggetto e il suo addestramento sono due fasi distinte e separate.

   3. Addestramento e trasformazione con fit_transform

   # Addestramento e trasformazione in un unico passaggio
   etichette_codificate = label_encoder.fit_transform(generi)
   print("Etichette codificate:", etichette_codificate)
   
   # Visualizzazione delle classi individuate, in ordine alfabetico
   print("Classi individuate:", label_encoder.classes_)

   Il metodo fit_transform esegue due operazioni in sequenza: apprende le categorie uniche presenti nei dati (fit) e le converte immediatamente in numeri interi (transform).

   • fit_transform assegna un numero intero crescente a ciascuna categoria unica, seguendo l'ordine alfabetico.
   • classes_ è un attributo che, dopo l'addestramento, contiene l'elenco delle categorie originali nell'ordine usato per la codifica.

   Nel nostro esempio 'Female' viene mappato a 0 e 'Male' a 1, semplicemente perché F precede M nell'ordine alfabetico.

   È importante ricordare che l'ordine numerico assegnato non riflette alcuna gerarchia reale tra le categorie: è puramente convenzionale.

   4. Mappatura leggibile e decodifica inversa

   # Creazione di un dizionario di mappatura per maggiore chiarezza
   mappatura = dict(zip(label_encoder.classes_, label_encoder.transform(label_encoder.classes_)))
   print("Mappatura classe -> numero:", mappatura)
   
   # Decodifica: trasformazione inversa da numero a categoria originale
   decodificato = label_encoder.inverse_transform(etichette_codificate)
   print("Valori decodificati:", decodificato)

   Costruiamo un dizionario esplicito per rendere subito visibile la corrispondenza tra ciascuna categoria e il numero assegnato, e utilizziamo inverse_transform per tornare dai numeri alle etichette originali.

   • mappatura è un dizionario che associa ogni categoria testuale al proprio codice numerico, utile a scopo didattico e di debug.
   • inverse_transform permette di recuperare i valori testuali originali a partire dai numeri codificati, operazione utile quando si interpretano le predizioni di un modello.

   Questa operazione è particolarmente importante quando LabelEncoder viene usato sulla variabile target: dopo la predizione occorre spesso ridecodificare il risultato in un'etichetta leggibile.

   Con più di due categorie, l'ordine numerico implicito da LabelEncoder può indurre un algoritmo a interpretare una relazione d'ordine inesistente tra le classi.

   Punto chiave da sottolineare

   LabelEncoder assegna numeri interi seguendo l'ordine alfabetico delle categorie, senza alcun significato ordinale reale. È ideale per variabili binarie o per la codifica della variabile target, ma va usato con cautela sulle feature con più di due categorie nominali, dove è preferibile OneHotEncoder.

   In poche parole...

   Abbiamo importato e istanziato LabelEncoder, applicato fit_transform per codificare dati testuali in numeri, ispezionato le classi individuate tramite classes_ e infine utilizzato inverse_transform per tornare ai valori originali, un passaggio chiave per interpretare correttamente i risultati di un modello.

2. Codifica One-Hot
   • Converte ciascuna categoria in un vettore binario.
   • Adatto per dati nominali (non ordinali).
   018 base

   Codifica delle Variabili Categoriche con OneHotEncoder

   OneHotEncoder gestisce valori testuali trasformando ogni categoria in un vettore binario.

   Download

   from sklearn.preprocessing import OneHotEncoder
   import numpy as np
   
   # Dati di esempio
   # Colore di alcuni prodotti: variabile categorica nominale (nessun ordine)
   dati = np.array(['Rosso', 'Blu', 'Verde', 'Blu'])[:, None]  # reshape a colonna 2D
   
   # Creazione e addestramento dell'encoder
   one_hot_encoder = OneHotEncoder(sparse_output=False)
   one_hot_encoder.fit(dati)  # apprende le categorie uniche presenti nei dati
   
   # Trasformazione e ispezione del risultato
   dati_codificati = one_hot_encoder.transform(dati)
   nomi_colonne = one_hot_encoder.get_feature_names_out(['colore'])
   
   print("Colonne generate:", nomi_colonne)
   print("Dati codificati:\n", dati_codificati)
   
   # Gestione di categorie sconosciute in nuovi dati
   encoder_robusto = OneHotEncoder(sparse_output=False, handle_unknown='ignore')
   encoder_robusto.fit(dati)
   
   nuovi_dati = np.array(['Giallo'])[:, None]  # categoria mai vista in training
   print("Categoria sconosciuta codificata:\n", encoder_robusto.transform(nuovi_dati))

   Colonne generate: ['colore_Blu' 'colore_Rosso' 'colore_Verde']
   Dati codificati:
    [[0. 1. 0.]
    [1. 0. 0.]
    [0. 0. 1.]
    [1. 0. 0.]]
   Categoria sconosciuta codificata:
    [[0. 0. 0.]]

   018 Codifica delle Variabili Categoriche con OneHotEncoder

   Lezione 01

   Molti algoritmi di machine learning richiedono input numerici e non sanno gestire direttamente valori testuali come "Rosso" o "Blu". OneHotEncoder risolve il problema trasformando ogni categoria in un vettore binario, senza introdurre relazioni d'ordine inesistenti tra i valori.

   1. Preparazione dei dati di esempio

   from sklearn.preprocessing import OneHotEncoder
   import numpy as np
   
   # Dati di esempio: il colore di alcuni prodotti in magazzino
   dati = np.array(['Rosso', 'Blu', 'Verde', 'Blu'])[:, None]

   Partiamo da una variabile categorica nominale, cioè priva di un ordine naturale tra i valori. L'operazione [:, None] trasforma l'array monodimensionale in una colonna a due dimensioni, formato richiesto da scikit-learn per le trasformazioni.

   • Variabile nominale: i colori non hanno una gerarchia, "Verde" non è maggiore o minore di "Rosso".
   • Reshape a due dimensioni: [:, None] converte l'array da forma (4,) a (4, 1), come richiesto dall'encoder.

   Abbiamo inserito il valore "Blu" due volte per rendere l'esempio più realistico: nei dati reali le categorie si ripetono spesso.

   2. Creazione e addestramento dell'encoder

   one_hot_encoder = OneHotEncoder(sparse_output=False)
   one_hot_encoder.fit(dati)

   Il metodo fit analizza i dati e memorizza l'elenco delle categorie uniche presenti, senza ancora produrre alcuna trasformazione. Questo passaggio separato rende esplicito cosa l'encoder ha effettivamente imparato.

   • sparse_output=False: richiede in output un array denso, più semplice da leggere e ispezionare rispetto a una matrice sparsa.
   • fit: apprende le categorie senza trasformare i dati, a differenza di fit_transform che fa entrambe le cose insieme.

   Dopo il fit, l'attributo one_hot_encoder.categories_ contiene l'elenco delle categorie apprese, ordinate alfabeticamente.

   3. Trasformazione dei dati e nomi delle colonne

   dati_codificati = one_hot_encoder.transform(dati)
   nomi_colonne = one_hot_encoder.get_feature_names_out(['colore'])
   
   print(nomi_colonne)
   print(dati_codificati)

   Il metodo transform converte ogni valore categorico in un vettore binario, dove un solo elemento vale 1 (la categoria presente) e tutti gli altri valgono 0.

   • get_feature_names_out: restituisce i nomi leggibili delle nuove colonne generate, ad esempio colore_Rosso.
   • Vettore binario: ogni riga della matrice risultante rappresenta una categoria con un unico 1 nella colonna corrispondente.

   A differenza di una semplice codifica numerica (0, 1, 2), il one-hot non suggerisce alcun ordine o distanza tra le categorie.

   Questo è essenziale per modelli come la regressione lineare, che interpreterebbero erroneamente numeri consecutivi come valori ordinabili.

   4. Gestione di categorie sconosciute

   encoder_robusto = OneHotEncoder(sparse_output=False, handle_unknown='ignore')
   encoder_robusto.fit(dati)
   
   nuovi_dati = np.array(['Giallo'])[:, None]
   print(encoder_robusto.transform(nuovi_dati))

   In produzione può capitare di incontrare categorie mai viste durante l'addestramento. Il parametro handle_unknown='ignore' evita che l'encoder generi un errore in questi casi.

   • handle_unknown='ignore': le categorie sconosciute vengono codificate con un vettore di soli zeri, invece di bloccare l'esecuzione.
   • Robustezza in produzione: fondamentale quando i nuovi dati potrebbero contenere valori non presenti nel training set.

   Per impostazione predefinita OneHotEncoder solleva un errore su categorie sconosciute: una scelta di sicurezza che va disattivata consapevolmente.

   Punto chiave da sottolineare

   OneHotEncoder trasforma variabili categoriche nominali in vettori binari indipendenti, evitando di introdurre relazioni d'ordine inesistenti. È indispensabile per algoritmi che richiedono input numerici e va sempre gestito con attenzione per categorie non previste in fase di addestramento.

   In poche parole...

   Abbiamo visto come preparare dati categorici per OneHotEncoder, addestrare l'encoder, trasformare i dati in vettori binari leggibili con get_feature_names_out, e gestire in modo robusto categorie sconosciute con handle_unknown='ignore'.

3. Codifica di destinazione
   • Sostituisce le categorie con la media della variabile target per ciascuna categoria.
   • Utilizzato in situazioni in cui è fondamentale preservare la relazione con il destinatario.
4. Codifica binaria
   • Combina i vantaggi della codifica one-hot e della codifica delle etichette (label encoding).
   • Converte le categorie in rappresentazioni binarie.
   019 base

   Codifica binaria con BinaryEncoder: ridurre la dimensionalità delle variabili categoriali

   Quando una variabile categoriale ha molte categorie BinaryEncoder codifica le categorie in forma binaria, riducendo drasticamente la dimensionalità

   Download

   # pip install category_encoders
   import pandas as pd
   from category_encoders import BinaryEncoder
   
   # Creiamo un dataset di esempio con una variabile categoriale nominale
   data = pd.DataFrame({'Colore': ['Rosso', 'Blu', 'Verde', 'Giallo', 'Viola']})
   print("Dataset originale:")
   print(data)
   print()
   
   # Inizializziamo il BinaryEncoder specificando esplicitamente la colonna da trasformare
   # Questo evita trasformazioni indesiderate su altre colonne numeriche eventualmente presenti
   binary_encoder = BinaryEncoder(cols=['Colore'])
   
   # Addestriamo l'encoder sui dati e trasformiamo il dataset in un'unica operazione
   # fit: assegna un codice intero progressivo a ogni categoria unica
   # transform: converte il codice intero nella sua rappresentazione binaria distribuita su più colonne
   encoded_data = binary_encoder.fit_transform(data)
   print("Dataset codificato con BinaryEncoder:")
   print(encoded_data)
   print()
   
   # Confrontiamo il numero di colonne generate dal BinaryEncoder
   # con quelle che avrebbe generato un One-Hot Encoding sullo stesso dataset
   numero_categorie = data['Colore'].nunique()
   colonne_generate = len(encoded_data.columns)
   
   print(f"Numero di categorie uniche: {numero_categorie}")
   print(f"Colonne generate dal BinaryEncoder: {colonne_generate}")
   print(f"Colonne che genererebbe il One-Hot Encoding: {numero_categorie}")

   Dataset originale:
      Colore
   0   Rosso
   1     Blu
   2   Verde
   3  Giallo
   4   Viola
   
   Dataset codificato con BinaryEncoder:
      Colore_0  Colore_1  Colore_2
   0         0         0         1
   1         0         1         0
   2         0         1         1
   3         1         0         0
   4         1         0         1
   
   Numero di categorie uniche: 5
   Colonne generate dal BinaryEncoder: 3
   Colonne che genererebbe il One-Hot Encoding: 5

   019 Codifica binaria con BinaryEncoder: ridurre la dimensionalità delle variabili categoriali

   Lezione 01

   Quando una variabile categoriale ha molte categorie, il One-Hot Encoding genera troppe colonne. Il BinaryEncoder risolve il problema codificando le categorie in forma binaria, riducendo drasticamente la dimensionalità.

   1. Creazione del dataset di esempio

   import pandas as pd
   from category_encoders import BinaryEncoder
   
   # Creiamo un dataset di esempio con una variabile categoriale nominale
   data = pd.DataFrame({'Colore': ['Rosso', 'Blu', 'Verde', 'Giallo', 'Viola']})
   print(data)

   Costruiamo un semplice DataFrame con una colonna categoriale nominale composta da cinque valori distinti, così da avere abbastanza categorie da rendere evidente il funzionamento del BinaryEncoder.

   • Variabile nominale: i colori non hanno un ordine naturale tra loro.
   • Cinque categorie: numero sufficiente per apprezzare il vantaggio della codifica binaria.

   Con poche categorie il vantaggio del BinaryEncoder rispetto al One-Hot Encoding è marginale: la differenza diventa significativa all'aumentare del numero di valori distinti.

   2. Inizializzazione del BinaryEncoder

   # Inizializziamo il BinaryEncoder specificando la colonna da trasformare
   binary_encoder = BinaryEncoder(cols=['Colore'])

   Creiamo un'istanza di BinaryEncoder indicando esplicitamente su quale colonna operare tramite il parametro cols. Questo è utile quando il dataset contiene più colonne e si vuole codificarne solo alcune.

   • cols: elenco delle colonne categoriali da trasformare.
   • Comportamento di default: senza specificare cols, l'encoder trasforma automaticamente tutte le colonne di tipo object o category.

   Specificare sempre esplicitamente le colonne da codificare è una buona pratica: evita trasformazioni indesiderate su colonne numeriche presenti nello stesso DataFrame.

   3. Addestramento e trasformazione dei dati

   # Addestriamo l'encoder sui dati e trasformiamo il dataset
   encoded_data = binary_encoder.fit_transform(data)
   print("Dataset codificato con BinaryEncoder:")
   print(encoded_data)

   Il metodo fit_transform apprende la mappatura tra ciascuna categoria e un valore intero progressivo, poi converte quell'intero nella sua rappresentazione binaria distribuita su più colonne.

   • fit: assegna un codice intero a ogni categoria unica.
   • transform: converte il codice intero in cifre binarie, una per colonna.

   A differenza del One-Hot Encoding, qui ogni riga avrà più valori diversi da zero contemporaneamente, poiché la codifica binaria combina più bit per rappresentare una categoria.

   4. Confronto della dimensionalità generata

   # Confrontiamo il numero di colonne generate dal BinaryEncoder
   # con quelle che avrebbe generato un One-Hot Encoding sullo stesso dataset
   numero_categorie = data['Colore'].nunique()
   colonne_generate = len(encoded_data.columns)
   
   print(f"Numero di categorie uniche: {numero_categorie}")
   print(f"Colonne generate dal BinaryEncoder: {colonne_generate}")
   print(f"Colonne che genererebbe il One-Hot Encoding: {numero_categorie}")

   Verifichiamo concretamente il vantaggio del BinaryEncoder confrontando il numero di colonne prodotte con quelle che avrebbe generato un One-Hot Encoding sullo stesso dataset.

   • One-Hot Encoding: genererebbe 5 colonne, una per categoria.
   • BinaryEncoder: ne genera solo 3, sufficienti a rappresentare 5 valori distinti in binario.

   Con dataset che contengono decine o centinaia di categorie, questa riduzione diventa fondamentale per contenere il numero di feature e la complessità computazionale del modello.

   Punto chiave da sottolineare

   Il BinaryEncoder converte ogni categoria in un codice intero e poi in cifre binarie distribuite su più colonne, riducendo drasticamente la dimensionalità rispetto al One-Hot Encoding. È particolarmente utile con variabili nominali ad alta cardinalità.

   In poche parole...

   Abbiamo creato un dataset con una variabile categoriale a cinque valori, applicato il BinaryEncoder e confrontato il numero di colonne generate rispetto al One-Hot Encoding. La codifica binaria offre un buon compromesso tra compattezza ed espressività.

Scegliere la tecnica di codifica corretta

• Utilizza la Codifica delle etichette (label encoding) per i dati ordinali.
• Utilizza la Codifica one-hot per dati nominali con un numero ridotto di categorie.
• Utilizza la Codifica binaria o la Codifica di destinazione per le variabili categoriche ad alta cardinalità.

La pre-elaborazione dei dati è alla base del successo dei progetti di machine learning. Comprendendo i tipi di dati, gestendo i valori mancanti, normalizzando i dati numerici e codificando i dati categorici, è possibile preparare efficacemente i dataset per l'addestramento di modelli robusti e accurati.

Ingegneria delle caratteristiche

• Selezione delle caratteristiche
• Estrazione delle caratteristiche
• Analisi delle componenti principali (PCA)
• Tecniche di riduzione della dimensionalità

Selezione delle caratteristiche

Il feature engineering è un processo fondamentale nel flusso di lavoro del machine learning, incentrato sulla selezione, trasformazione e creazione di feature a partire dai dati grezzi per migliorare le prestazioni del modello. Feature di alta qualità potenziano la capacità del modello di effettuare previsioni accurate e riducono la complessità dell'addestramento. Il presente documento esamina i principali aspetti del feature engineering:

Tipologie di selezione delle caratteristiche

• Metodi di filtraggio
  • Valuta le caratteristiche sulla base di misure statistiche come la correlazione o la varianza.
  • Le caratteristiche vengono selezionate indipendentemente dal modello di apprendimento automatico.
  • Tecniche comuni:
    • Matrice di correlazione: selezionare le caratteristiche con bassa multicollinearità.
    • Test del chi-quadrato: misura la dipendenza tra variabili categoriche.
    • Soglia di varianza: rimuove le caratteristiche a bassa varianza.
• Metodi wrapper
  • Selezionare o rimuovere iterativamente le caratteristiche in base alle prestazioni del modello.
  • Costoso dal punto di vista computazionale, ma spesso più preciso.
  • Tecniche comuni:
    • Selezione in avanti: si parte senza funzionalità, aggiungendole una alla volta in base alle prestazioni.
    • Eliminazione a ritroso: inizia con tutte le funzionalità, rimuovendone una alla volta.
    • Eliminazione ricorsiva delle caratteristiche (RFE): elimina le caratteristiche in modo ricorsivo in base all'importanza.
• Metodi integrati
  • La selezione delle caratteristiche avviene nell'ambito del processo di addestramento del modello.
  • Esempi:
    • LASSO (regolarizzazione L1)
    • Modelli basati su alberi decisionali (ad esempio, Random Forest, XGBoost)

Passaggi per la selezione delle funzionalità

1. Comprendere il dominio: conosci i dati e il problema che stai risolvendo.
2. Visualizzare le relazioni: utilizza diagrammi a dispersione, mappe di calore e confronti a coppie.
3. Applicare tecniche di selezione: scegli un metodo adatto ai tuoi dati e al tuo modello.

# =============================================================
# Ingegneria delle caratteristiche:
# Selezione delle feature più informative con SelectKBest e chi2
# =============================================================

import pandas as pd
from sklearn.feature_selection import SelectKBest, chi2

# ---------------------------------------------------------------
# Creazione del dataset di esempio
# ---------------------------------------------------------------
# Simuliamo un piccolo dataset che descrive dieci studenti tramite
# tre caratteristiche numeriche non negative (ore di studio, numero
# di esercizi svolti, numero di assenze) e l'esito finale (promosso
# o non promosso). Il test chi-quadro richiede valori non negativi,
# quindi tutte le feature sono state scelte rispettando questo vincolo.
data = pd.DataFrame({
    'Ore_Studio':      [2, 4, 6, 8, 3, 7, 5, 9, 1, 6],
    'Numero_Esercizi': [1, 1, 2, 3, 2, 4, 3, 5, 0, 3],
    'Assenze':         [8, 6, 4, 1, 7, 2, 5, 0, 9, 3],
    'Promosso':        [0, 0, 1, 1, 0, 1, 1, 1, 0, 1]
})

print("Dataset originale:")
print(data)

# ---------------------------------------------------------------
# Separazione tra feature (X) e target (y)
# ---------------------------------------------------------------
# X contiene le variabili indipendenti, y la variabile da prevedere.
# Questo passo è comune a qualunque tecnica di selezione delle feature.
X = data[['Ore_Studio', 'Numero_Esercizi', 'Assenze']]
y = data['Promosso']

# ---------------------------------------------------------------
# Selezione delle feature migliori con SelectKBest e chi2
# ---------------------------------------------------------------
# SelectKBest mantiene solo le k feature con il punteggio più alto
# secondo la funzione di scoring indicata. Qui usiamo il test
# chi-quadro (chi2), adatto a feature numeriche non negative.
selector = SelectKBest(score_func=chi2, k=2)
X_new = selector.fit_transform(X, y)

# ---------------------------------------------------------------
# Analisi dei punteggi e delle feature selezionate
# ---------------------------------------------------------------
# Recuperiamo i punteggi chi-quadro, i p-value e la maschera booleana
# che indica quali feature sono state effettivamente mantenute.
punteggi = selector.scores_
p_values = selector.pvalues_
feature_selezionate = X.columns[selector.get_support()]

riepilogo_punteggi = pd.DataFrame({
    'Feature': X.columns,
    'Punteggio_Chi2': punteggi,
    'P_value': p_values,
    'Selezionata': selector.get_support()
}).sort_values(by='Punteggio_Chi2', ascending=False)

print("\nPunteggi Chi-quadro per ciascuna feature:")
print(riepilogo_punteggi)

# ---------------------------------------------------------------
# Costruzione del dataset ridotto
# ---------------------------------------------------------------
# Ricostruiamo un DataFrame con i soli nomi delle feature selezionate,
# pronto per essere utilizzato nell'addestramento di un modello.
X_new_df = pd.DataFrame(X_new, columns=feature_selezionate)

print("\nFeature selezionate:", list(feature_selezionate))
print("\nDataset ridotto:")
print(X_new_df)

Dataset originale:
   Ore_Studio  Numero_Esercizi  Assenze  Promosso
0           2                1        8         0
1           4                1        6         0
2           6                2        4         1
3           8                3        1         1
4           3                2        7         0
5           7                4        2         1
6           5                3        5         1
7           9                5        0         1
8           1                0        9         0
9           6                3        3         1

Punteggi Chi-quadro per ciascuna feature:
           Feature  Punteggio_Chi2   P_value  Selezionata
2          Assenze       13.333333  0.000261         True
0       Ore_Studio        8.836601  0.002952         True
1  Numero_Esercizi        5.444444  0.019631        False

Feature selezionate: ['Ore_Studio', 'Assenze']

Dataset ridotto:
   Ore_Studio  Assenze
0           2        8
1           4        6
2           6        4
3           8        1
4           3        7
5           7        2
6           5        5
7           9        0
8           1        9
9           6        3

data = pd.DataFrame({
    'Ore_Studio':      [2, 4, 6, 8, 3, 7, 5, 9, 1, 6],
    'Numero_Esercizi': [1, 1, 2, 3, 2, 4, 3, 5, 0, 3],
    'Assenze':         [8, 6, 4, 1, 7, 2, 5, 0, 9, 3],
    'Promosso':        [0, 0, 1, 1, 0, 1, 1, 1, 0, 1]
})

X = data[['Ore_Studio', 'Numero_Esercizi', 'Assenze']]
y = data['Promosso']

selector = SelectKBest(score_func=chi2, k=2)
X_new = selector.fit_transform(X, y)

punteggi = selector.scores_
p_values = selector.pvalues_
feature_selezionate = X.columns[selector.get_support()]

riepilogo_punteggi = pd.DataFrame({
    'Feature': X.columns,
    'Punteggio_Chi2': punteggi,
    'P_value': p_values,
    'Selezionata': selector.get_support()
}).sort_values(by='Punteggio_Chi2', ascending=False)

X_new_df = pd.DataFrame(X_new, columns=feature_selezionate)

Estrazione delle caratteristiche

L'estrazione di caratteristiche trasforma i dati grezzi in caratteristiche significative che catturano i modelli sottostanti. È particolarmente utile per i dati non strutturati come testo, immagini e audio.

Tecniche per l'estrazione di caratteristiche

1. Dati testuali:
   • TF-IDF (Frequenza del termine - Frequenza inversa del documento): evidenzia i termini importanti in un documento.
   • Incorporamento di parole: converte le parole in vettori utilizzando modelli come Word2Vec, GloVe o BERT.
2. Dati di immagine:
   • Caratteristiche dei pixel: estrarre i valori di intensità dei pixel.
   • Caratteristiche convoluzionali: utilizzare reti neurali convoluzionali (CNN) per estrarre caratteristiche spaziali.
3. Dati di serie temporali:
   • Trasformata di Fourier: estrae le componenti di frequenza dalle serie temporali.
   • Autocorrelazione: cattura le relazioni temporali
021 base

Estrazione delle Caratteristiche da Testo con TF-IDF

Trasformazione di un corpus testuale in una matrice numerica di pesi TF-IDF, utile per confrontare l'importanza delle parole nei documenti in attività di machine learning.

Download

# Estrazione delle caratteristiche da testo con TF-IDF
# ---------------------------------------------------------------------
# Obiettivo: trasformare un insieme di frasi (corpus) in una matrice
# numerica che rappresenti l'importanza di ogni parola in ciascun
# documento, utilizzando la tecnica TF-IDF (Term Frequency - Inverse
# Document Frequency).

import pandas as pd
from sklearn.feature_extraction.text import TfidfVectorizer

# Preparazione del corpus di testo
# Il corpus e' l'insieme dei documenti (frasi) che vogliamo analizzare.
# Sono stati aggiunti termini ripetuti ("machine", "learning", "is") e
# termini unici ("fascinating", "crucial", "deep", "subset") per
# mostrare come TF-IDF distingua le parole comuni da quelle rare.
corpus = [
    "Machine learning is fascinating and powerful.",
    "Feature engineering is crucial for machine learning.",
    "Deep learning is a subset of machine learning."
]

# Creazione del vettorizzatore TF-IDF e trasformazione del corpus
# TfidfVectorizer calcola automaticamente sia la frequenza dei termini
# (TF) sia la frequenza inversa di documento (IDF), combinandole in
# un unico punteggio per ogni parola in ogni documento.
vectorizer = TfidfVectorizer()
X = vectorizer.fit_transform(corpus)

# Esplorazione del vocabolario
# Il vocabolario contiene tutte le parole uniche individuate nel corpus,
# ciascuna associata a un indice di colonna nella matrice risultante.
feature_names = vectorizer.get_feature_names_out()
print("Vocabolario individuato:")
print(feature_names)

# Rappresentazione tabellare con pandas
# Convertiamo la matrice sparsa in un DataFrame per rendere i valori
# TF-IDF piu' leggibili, con le parole come colonne e i documenti come righe.
df_tfidf = pd.DataFrame(X.toarray(), columns=feature_names)
df_tfidf.index = [f"Documento {i + 1}" for i in range(len(corpus))]
print("\nMatrice TF-IDF:")
print(df_tfidf.round(3))

# Interpretazione dei valori TF-IDF
# Confrontiamo il peso medio delle parole che compaiono in piu' documenti
# rispetto a quelle rare, per verificare che TF-IDF penalizzi i termini comuni.
parole_comuni = ["learning", "machine", "is"]
parole_rare = ["fascinating", "crucial", "subset"]

peso_medio_comuni = df_tfidf[parole_comuni].mean().mean()
peso_medio_rare = df_tfidf[parole_rare].mean().mean()

print(f"\nPeso medio parole comuni: {peso_medio_comuni:.3f}")
print(f"Peso medio parole rare: {peso_medio_rare:.3f}")

Vocabolario individuato:
['and' 'crucial' 'deep' 'engineering' 'fascinating' 'feature' 'for' 'is'
 'learning' 'machine' 'of' 'powerful' 'subset']

Matrice TF-IDF:
               and  crucial   deep  engineering  fascinating  feature    for     is  learning  machine     of  powerful  subset
Documento 1  0.497    0.000  0.000        0.000        0.497    0.000  0.000  0.294     0.294    0.294  0.000     0.497   0.000
Documento 2  0.000    0.445  0.000        0.445        0.000    0.445  0.445  0.263     0.263    0.263  0.000     0.000   0.000
Documento 3  0.000    0.000  0.443        0.000        0.000    0.000  0.000  0.262     0.523    0.262  0.443     0.000   0.443

Peso medio parole comuni: 0.302
Peso medio parole rare: 0.154

021 Estrazione delle Caratteristiche da Testo con TF-IDF

Lezione 01

Il machine learning non lavora direttamente con il testo, ma con numeri. La tecnica TF-IDF converte un insieme di frasi in una matrice numerica, assegnando a ogni parola un peso che riflette quanto essa sia rilevante e distintiva all'interno dei singoli documenti.

1. Preparazione del corpus di testo

corpus = [
    "Machine learning is fascinating and powerful.",
    "Feature engineering is crucial for machine learning.",
    "Deep learning is a subset of machine learning."
]

Il corpus è l'insieme dei documenti testuali da analizzare. Sono state usate tre frasi, alcune contenenti le stesse parole chiave e altre con termini unici, per rendere più evidente il comportamento di TF-IDF.

• Parole ripetute: "machine", "learning" e "is" compaiono in più frasi e avranno quindi un peso IDF più basso.
• Parole uniche: "fascinating", "crucial" e "subset" compaiono una sola volta e otterranno un peso più alto.

Un corpus con almeno tre documenti permette di osservare in modo più realistico l'effetto della frequenza inversa di un documento rispetto a un corpus con sole due frasi.

2. Creazione del vettorizzatore TF-IDF

vectorizer = TfidfVectorizer()
X = vectorizer.fit_transform(corpus)

TfidfVectorizer calcola automaticamente due componenti: la frequenza del termine nel documento (TF) e la frequenza inversa di documento (IDF), combinandole in un unico punteggio.

• fit: analizza il corpus e costruisce il vocabolario delle parole uniche.
• transform: converte ogni documento in un vettore numerico di pesi TF-IDF.

Il risultato X e una matrice sparsa, formato efficiente per rappresentare dati testuali dove la maggior parte delle parole del vocabolario non compare in ogni singolo documento.

3. Esplorazione del vocabolario

feature_names = vectorizer.get_feature_names_out()
print("Vocabolario individuato:")
print(feature_names)

Il metodo get_feature_names_out restituisce l'elenco ordinato di tutte le parole uniche individuate nel corpus, ciascuna corrispondente a una colonna della matrice TF-IDF.

Conoscere il vocabolario è fondamentale per interpretare correttamente i valori numerici: ogni colonna della matrice rappresenta infatti una parola specifica.

4. Rappresentazione tabellare con pandas

df_tfidf = pd.DataFrame(X.toarray(), columns=feature_names)
df_tfidf.index = [f"Documento {i + 1}" for i in range(len(corpus))]
print("\nMatrice TF-IDF:")
print(df_tfidf.round(3))

Convertire la matrice sparsa in un DataFrame pandas rende i valori TF-IDF molto più leggibili, associando ogni parola alla propria colonna e ogni documento alla propria riga.

• toarray(): trasforma la matrice sparsa in un array denso leggibile.
• round(3): arrotonda i pesi per facilitarne il confronto visivo.

Questa tabella permette di vedere a colpo d'occhio quali parole pesano di più in ciascun documento, rendendo concreto un concetto altrimenti astratto.

5. Interpretazione dei valori TF-IDF

parole_comuni = ["learning", "machine", "is"]
parole_rare = ["fascinating", "crucial", "subset"]

peso_medio_comuni = df_tfidf[parole_comuni].mean().mean()
peso_medio_rare = df_tfidf[parole_rare].mean().mean()

print(f"\nPeso medio parole comuni: {peso_medio_comuni:.3f}")
print(f"Peso medio parole rare: {peso_medio_rare:.3f}")

Confrontando il peso medio delle parole comuni con quello delle parole rare si verifica empiricamente il comportamento atteso di TF-IDF: le parole diffuse in più documenti ricevono un peso inferiore.

• Parole comuni: peso medio più basso, poiché presenti in più documenti (IDF ridotto).
• Parole rare: peso medio più alto, poiché distintive di un singolo documento (IDF elevato).

Questo meccanismo è ciò che rende TF-IDF particolarmente utile per individuare le parole realmente caratterizzanti di un testo, escludendo termini troppo generici.

Punto chiave da sottolineare

TF-IDF assegna un peso a ogni parola combinando quanto essa sia frequente in un documento (TF) con quanto essa sia rara nell'intero corpus (IDF). Le parole comuni a molti documenti ricevono un peso basso, mentre le parole distintive di un solo documento ricevono un peso alto, rendendo questa tecnica utile per identificare i termini realmente significativi.

In poche parole...

In questo esempio abbiamo trasformato un corpus di frasi in una matrice numerica TF-IDF con TfidfVectorizer, esplorato il vocabolario generato, rappresentato i risultati in un DataFrame pandas per maggiore leggibilità e confrontato il peso di parole comuni rispetto a parole rare, verificando il comportamento atteso della tecnica.

Analisi delle componenti principali (PCA)

Torna all’indice

L'analisi delle componenti principali (PCA) è una popolare tecnica di riduzione della dimensionalità utilizzata per proiettare dati ad alta dimensionalità in uno spazio a dimensionalità inferiore, preservando al contempo la maggior parte possibile della varianza.

• Come funziona la PCA
  1. Calcola la matrice di covarianza: calcola la matrice di covarianza del dataset per comprendere le relazioni tra le caratteristiche.
  2. Calcola autovalori e autovettori: gli autovettori determinano la direzione del nuovo spazio delle caratteristiche, e gli autovalori rappresentano l'entità della varianza in quella direzione.
  3. Componenti della classifica: seleziona le componenti principali che spiegano la maggior parte della varianza.
• Passaggi per eseguire la PCA
  1. Normalizzare i dati.
  2. Calcolare la matrice di covarianza.
  3. Eseguire la propria decomposizione.
  4. Proiettare i dati sui primi k componenti.
• Vantaggi della PCA
  • Riduce la dimensionalità, velocizzando l'addestramento.
  • Aiuta a visualizzare dati ad alta dimensionalità.
  • Elimina il rumore concentrandosi sugli schemi principali.
022 base

Riduzione della dimensionalità con la PCA (Principal Component Analysis)

Applica la PCA a un dataset di due feature correlate, riducendolo a una sola componente principale dopo averlo standardizzato con StandardScaler.

Download

# Riduzione della dimensionalità con la PCA (Principal Component Analysis)
# ============================================================
# Importazione delle librerie e creazione del dataset
# ============================================================
import numpy as np
import pandas as pd
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler

# Creiamo un dataset di esempio con 2 feature correlate tra loro,
# ad esempio "ore di studio" e "punteggio esame" ottenuto
data = np.array([
    [2.5, 2.4],
    [0.5, 0.7],
    [2.2, 2.9],
    [1.9, 2.2],
    [3.1, 3.0],
    [2.3, 2.7],
    [2.0, 1.6],
    [1.0, 1.1],
    [1.5, 1.6],
    [1.1, 0.9]
])

# Convertiamo in DataFrame per una lettura più chiara delle feature
df = pd.DataFrame(data, columns=["Ore di studio", "Punteggio esame"])
print("Dataset originale:")
print(df)

# ============================================================
# Standardizzazione dei dati
# ============================================================
# La PCA è sensibile alla scala delle feature: variabili con range
# più ampi dominerebbero artificialmente le componenti principali.
# Standardizziamo quindi i dati a media 0 e deviazione standard 1.
scaler = StandardScaler()
data_scaled = scaler.fit_transform(df)

df_scaled = pd.DataFrame(data_scaled, columns=df.columns)
print("\nDataset standardizzato:")
print(df_scaled)

# ============================================================
# Applicazione della PCA
# ============================================================
# Riduciamo le 2 feature originali a 1 sola componente principale,
# che cattura la maggior parte della varianza presente nei dati.
pca = PCA(n_components=1)
transformed_data = pca.fit_transform(data_scaled)

print("\nDati trasformati (1 componente principale):")
print(transformed_data)

# ============================================================
# Analisi della varianza spiegata
# ============================================================
# explained_variance_ratio_ indica quanta informazione (varianza)
# del dataset originale è stata conservata dalla componente principale.
varianza_spiegata = pca.explained_variance_ratio_
print(f"\nVarianza spiegata dalla prima componente: {varianza_spiegata[0]:.2%}")

# ============================================================
# Ricostruzione approssimata dei dati originali
# ============================================================
# Con inverse_transform torniamo allo spazio originale a 2 dimensioni,
# osservando quanta informazione è andata persa nella riduzione.
data_reconstructed = pca.inverse_transform(transformed_data)

df_reconstructed = pd.DataFrame(data_reconstructed, columns=df.columns)
print("\nDati ricostruiti dopo la riduzione dimensionale:")
print(df_reconstructed)

# Calcoliamo l'errore quadratico medio di ricostruzione rispetto
# ai dati standardizzati originali
errore_ricostruzione = np.mean((data_scaled - data_reconstructed) ** 2)
print(f"\nErrore quadratico medio di ricostruzione: {errore_ricostruzione:.4f}")

Dataset originale:
   Ore di studio  Punteggio esame
0            2.5              2.4
1            0.5              0.7
2            2.2              2.9
3            1.9              2.2
4            3.1              3.0
5            2.3              2.7
6            2.0              1.6
7            1.0              1.1
8            1.5              1.6
9            1.1              0.9

Dataset standardizzato:
   Ore di studio  Punteggio esame
0       0.926279         0.610169
1      -1.758587        -1.506743
2       0.523549         1.232790
3       0.120819         0.361120
4       1.731739         1.357314
5       0.657792         0.983741
6       0.255062        -0.386025
7      -1.087371        -1.008646
8      -0.416154        -0.386025
9      -0.953127        -1.257695

Dati trasformati (1 componente principale):
[[ 1.08643242]
 [-2.3089372 ]
 [ 1.24191895]
 [ 0.34078247]
 [ 2.18429003]
 [ 1.16073946]
 [-0.09260467]
 [-1.48210777]
 [-0.56722643]
 [-1.56328726]]

Varianza spiegata dalla prima componente: 96.30%

Dati ricostruiti dopo la riduzione dimensionale:
   Ore di studio  Punteggio esame
0       0.768224         0.768224
1      -1.632665        -1.632665
2       0.878169         0.878169
3       0.240970         0.240970
4       1.544526         1.544526
5       0.820767         0.820767
6      -0.065481        -0.065481
7      -1.048008        -1.048008
8      -0.401090        -0.401090
9      -1.105411        -1.105411

Errore quadratico medio di ricostruzione: 0.0370

022 Riduzione della dimensionalità con la PCA (Principal Component Analysis)

Lezione 01

La PCA (Principal Component Analysis) è una tecnica che riduce il numero di feature di un dataset conservando la maggior parte dell'informazione. In questo esempio vedremo come applicarla correttamente, passando anche per la standardizzazione dei dati.

1. Creazione del dataset di esempio

data = np.array([
    [2.5, 2.4],
    [0.5, 0.7],
    [2.2, 2.9],
    [1.9, 2.2],
    [3.1, 3.0],
    [2.3, 2.7],
    [2.0, 1.6],
    [1.0, 1.1],
    [1.5, 1.6],
    [1.1, 0.9]
])
df = pd.DataFrame(data, columns=["Ore di studio", "Punteggio esame"])

Costruiamo un dataset con due feature correlate tra loro: ore di studio e punteggio esame. Abbiamo ampliato l'esempio originale da 4 a 10 righe per rendere più stabile e realistica l'analisi della varianza.

• Correlazione tra feature: le due colonne tendono a crescere insieme, condizione ideale per mostrare l'utilità della PCA.
• DataFrame con nomi di colonna: rende il dataset leggibile e più vicino a un caso d'uso reale.

Con solo 4 osservazioni, come nel codice originale, la varianza spiegata sarebbe poco affidabile e didatticamente poco significativa.

2. Standardizzazione dei dati

scaler = StandardScaler()
data_scaled = scaler.fit_transform(df)

df_scaled = pd.DataFrame(data_scaled, columns=df.columns)

Prima di applicare la PCA, standardizziamo i dati a media 0 e deviazione standard 1. Questo passaggio, assente nel codice originale, è fondamentale per un'analisi corretta.

• Sensibilità alla scala: la PCA calcola le componenti principali in base alla varianza, quindi feature con range più ampi la dominerebbero senza motivo.
• StandardScaler: riporta ogni feature sulla stessa scala, rendendo il confronto tra le variabili equo.

Saltare questa fase è uno degli errori più comuni quando si applica la PCA a dataset con feature di scale diverse.

3. Applicazione della PCA

pca = PCA(n_components=1)
transformed_data = pca.fit_transform(data_scaled)

Riduciamo le due feature originali a un'unica componente principale, che riassume la direzione di massima varianza nei dati standardizzati.

• n_components=1: specifica quante dimensioni finali vogliamo ottenere.
• fit_transform: calcola le componenti principali e proietta i dati su di esse in un unico passaggio.

Il risultato è un array monodimensionale: ogni osservazione originale è ora rappresentata da un solo valore numerico.

4. Analisi della varianza spiegata

varianza_spiegata = pca.explained_variance_ratio_
print(f"\nVarianza spiegata dalla prima componente: {varianza_spiegata[0]:.2%}")

La proprietà explained_variance_ratio_ indica quale percentuale dell'informazione originale è stata conservata dalla componente principale scelta.

• Valore vicino a 1: significa che la componente cattura quasi tutta la variabilità del dataset originale.
• Valore basso: segnala che una sola componente non è sufficiente a rappresentare bene i dati.

Questo indicatore è cruciale per decidere quante componenti mantenere in dataset reali con molte più feature.

5. Ricostruzione approssimata dei dati originali

data_reconstructed = pca.inverse_transform(transformed_data)
errore_ricostruzione = np.mean((data_scaled - data_reconstructed) ** 2)

Con inverse_transform torniamo allo spazio a due dimensioni originario, per visualizzare concretamente quanta informazione è stata persa nella riduzione.

• inverse_transform: ricostruisce un'approssimazione dei dati standardizzati a partire dalla componente principale.
• Errore quadratico medio: quantifica numericamente la differenza tra dati originali e dati ricostruiti.

Un errore basso conferma che la componente principale scelta rappresenta fedelmente il dataset originale, giustificando la riduzione dimensionale operata.

Punto chiave da sottolineare

La PCA richiede dati standardizzati per funzionare correttamente, altrimenti le feature con scale maggiori dominano ingiustamente le componenti principali. La varianza spiegata quantifica quanta informazione viene conservata, mentre l'inverse_transform rende visibile quanta se ne perde nella riduzione dimensionale.

In poche parole...

In questo esempio abbiamo applicato la PCA a un dataset di due feature correlate, standardizzandole preventivamente con StandardScaler. Abbiamo ridotto i dati a una sola componente principale, analizzato la varianza spiegata e ricostruito i dati originali con inverse_transform, misurando l'errore di ricostruzione introdotto dalla riduzione.

Tecniche di riduzione della dimensionalità

Torna all’indice

La riduzione della dimensionalità diminuisce il numero di caratteristiche in un dataset mantenendo le informazioni importanti. Può migliorare l'efficienza computazionale, ridurre l'overfitting e migliorare l'interpretabilità del modello.

• Tecniche
  1. Selezione delle funzionalità (rivista sopra)
     • Mantiene un sottoinsieme delle caratteristiche originali.
  2. Estrazione delle caratteristiche (rivista sopra)
     • Crea nuove funzionalità basate su trasformazioni.
  3. Tecniche lineari
     • Analisi delle componenti principali (PCA): i dati dei progetti sono lineari.
     • Analisi discriminante lineare (LDA): massimizza la separabilità delle classi.
  4. Tecniche non lineari
     • t-SNE (t-Distributed Stochastic Neighbor Embedding): proietta i dati in 2D/3D per la visualizzazione.
     • UMAP (Uniform Manifold Approximation and Projection): mantiene la struttura globale e locale ai fini della visualizzazione e dell'analisi.
     • Autoencoder: reti neurali progettate per la riduzione non supervisionata della dimensionalità.
• Scegliere la tecnica giusta
  • Utilizza l'analisi delle componenti principali (PCA) per dati numerici ad alta dimensionalità.
  • Utilizzare t-SNE o UMAP per la visualizzazione.
  • Utilizza gli Autoencoder per l'estrazione di caratteristiche basata sul deep learning.
023 base
Riduzione della dimensionalità con t-SNE per la visualizzazione dei dati
Applica l'algoritmo t-SNE per ridurre un dataset ad alta dimensionalità a due componenti, permettendo di visualizzare cluster e pattern nascosti nei dati in modo intuitivo.
Download
# =============================================================
# Riduzione della dimensionalità con t-SNE
# =============================================================

# Importazione delle librerie e caricamento del dataset
# Importiamo le librerie necessarie per il preprocessing, il modello
# t-SNE e la visualizzazione dei risultati
import numpy as np
import matplotlib.pyplot as plt
from sklearn.manifold import TSNE
from sklearn.datasets import load_digits
from sklearn.preprocessing import StandardScaler

# Carichiamo il dataset digits: 1797 immagini 8x8 di cifre scritte
# a mano (da 0 a 9), gia trasformate in vettori di 64 feature (pixel)
digits = load_digits()
X = digits.data      # matrice delle feature: 1797 campioni x 64 feature
y = digits.target    # etichette delle cifre (0-9), usate solo per colorare il grafico


# Esplorazione della struttura del dataset
# Verifichiamo le dimensioni del dataset originale, per capire
# perche una visualizzazione diretta non e possibile
print("Forma dei dati (campioni, feature):", X.shape)
print("Numero di classi (cifre 0-9):", len(np.unique(y)))
print("Esempio di vettore feature (prima immagine, 64 valori):")
print(X[0])


# Standardizzazione delle feature
# Portiamo tutte le feature sulla stessa scala, poiche t-SNE si basa
# su distanze tra punti ed e sensibile a differenze di scala tra le feature
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)


# Configurazione dell'algoritmo t-SNE
# Impostiamo il modello t-SNE per ridurre le 64 dimensioni originali
# a sole 2 dimensioni, adatte alla visualizzazione su un grafico 2D
tsne = TSNE(
    n_components=2,     # numero di dimensioni di output desiderate
    perplexity=30,      # bilancia l'attenzione tra struttura locale e globale
    max_iter=1000,      # numero massimo di iterazioni di ottimizzazione
                        # (nelle versioni di scikit-learn precedenti alla 1.5
                        # questo parametro si chiamava n_iter)
    random_state=42     # garantisce la riproducibilita dei risultati
)


# Trasformazione dei dati in due dimensioni
# Applichiamo fit_transform per calcolare le nuove coordinate 2D
# Nota: t-SNE non dispone di un metodo transform separato, quindi
# non puo essere riutilizzato su nuovi dati non visti in fase di addestramento
X_tsne = tsne.fit_transform(X_scaled)

print("\nForma dei dati dopo la riduzione con t-SNE:", X_tsne.shape)
print("Prime 5 coordinate 2D calcolate:")
print(X_tsne[:5])


# Visualizzazione del risultato
# Creiamo uno scatter plot colorato in base alla cifra rappresentata,
# per verificare visivamente se t-SNE ha separato correttamente i gruppi
plt.figure(figsize=(10, 8))
scatter = plt.scatter(X_tsne[:, 0], X_tsne[:, 1], c=y, cmap="tab10", s=15)
plt.colorbar(scatter, label="Cifra")
plt.title("Visualizzazione t-SNE del dataset digits")
plt.xlabel("Componente t-SNE 1")
plt.ylabel("Componente t-SNE 2")
plt.show()
Forma dei dati (campioni, feature): (1797, 64)
Numero di classi (cifre 0-9): 10
Esempio di vettore feature (prima immagine, 64 valori):
[ 0.  0.  5. 13.  9.  1.  0.  0.  0.  0. 13. 15. 10. 15.  5.  0.  0.  3.
 15.  2.  0. 11.  8.  0.  0.  4. 12.  0.  0.  8.  8.  0.  0.  5.  8.  0.
  0.  9.  8.  0.  0.  4. 11.  0.  1. 12.  7.  0.  0.  2. 14.  5. 10. 12.
  0.  0.  0.  0.  6. 13. 10.  0.  0.  0.]

Forma dei dati dopo la riduzione con t-SNE: (1797, 2)
Prime 5 coordinate 2D calcolate:
[[-38.777     -30.429148 ]
 [-15.336499   -2.7883544]
 [  5.937756  -14.502025 ]
 [ 28.00608     2.9412334]
 [-36.394794    2.6174462]]


023 Riduzione della dimensionalità con t-SNE per la visualizzazione dei dati

Lezione 01

Quando un dataset ha decine di feature diventa impossibile visualizzarlo direttamente. t-SNE è una tecnica non lineare che proietta i dati in 2 o 3 dimensioni, preservando le relazioni di vicinanza tra i punti.

1. Importazione delle librerie e caricamento del dataset

import numpy as np
import matplotlib.pyplot as plt
from sklearn.manifold import TSNE
from sklearn.datasets import load_digits
from sklearn.preprocessing import StandardScaler

# Carichiamo il dataset digits: 1797 immagini 8x8 di cifre scritte
# a mano (da 0 a 9), gia trasformate in vettori di 64 feature (pixel)
digits = load_digits()
X = digits.data      # matrice delle feature: 1797 campioni x 64 feature
y = digits.target    # etichette delle cifre (0-9), usate solo per colorare il grafico

Sostituiamo il piccolo array di esempio con il dataset digits, composto da 1797 immagini di cifre scritte a mano rappresentate come vettori di 64 pixel. Questo dataset è uno standard per dimostrare la riduzione della dimensionalità, perché ha una struttura reale su cui t-SNE può lavorare.

• load_digits carica un dataset con 64 feature per campione, troppe per essere visualizzate direttamente.
• y contiene le etichette delle cifre, usate solo per colorare il grafico finale, non per l'addestramento di t-SNE.

Il codice originale utilizzava solo 4 punti bidimensionali, un caso non realistico per t-SNE, che è pensato per dataset con molte più feature e osservazioni.

t-SNE è un algoritmo non supervisionato: non usa le etichette per calcolare la proiezione, ma solo la struttura interna dei dati.

2. Esplorazione della struttura del dataset

print("Forma dei dati (campioni, feature):", X.shape)
print("Numero di classi (cifre 0-9):", len(np.unique(y)))
print("Esempio di vettore feature (prima immagine, 64 valori):")
print(X[0])

Prima di applicare qualsiasi trasformazione è utile ispezionare la forma dei dati, per capire quante dimensioni stiamo cercando di ridurre e quante classi sono presenti nel dataset.

• X.shape restituisce 1797 righe e 64 colonne: 64 è la dimensionalità originale da ridurre.
• np.unique(y) conferma che le classi sono 10, una per ogni cifra da 0 a 9.

Con 64 dimensioni è impossibile realizzare un grafico a dispersione tradizionale: servono al massimo 2 o 3 assi per un grafico leggibile.

3. Standardizzazione delle feature

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

Standardizziamo le feature per portarle sulla stessa scala, così che nessun pixel domini il calcolo delle distanze solo perché ha valori numerici più grandi.

• StandardScaler trasforma ogni feature con media 0 e deviazione standard 1.
• fit_transform calcola i parametri di scaling e applica la trasformazione in un solo passaggio.

t-SNE si basa sul calcolo di distanze tra punti, quindi è buona pratica standardizzare i dati come già visto negli esempi precedenti sul preprocessing.

4. Configurazione dell'algoritmo t-SNE

tsne = TSNE(
    n_components=2,     # numero di dimensioni di output desiderate
    perplexity=30,      # bilancia l'attenzione tra struttura locale e globale
    max_iter=1000,      # numero massimo di iterazioni di ottimizzazione
                        # (nelle versioni di scikit-learn precedenti alla 1.5
                        # questo parametro si chiamava n_iter)
    random_state=42     # garantisce la riproducibilita dei risultati
)

Configuriamo il modello specificando quante dimensioni di output vogliamo e alcuni parametri che influenzano la qualità della proiezione finale.

• perplexity bilancia l'attenzione tra la struttura locale e quella globale dei dati; valori tipici vanno da 5 a 50.
• max_iter definisce il numero massimo di iterazioni di ottimizzazione; nelle versioni di scikit-learn precedenti alla 1.5 questo parametro si chiamava n_iter.

Cambiare la perplexity può modificare sensibilmente la forma dei cluster risultanti: è un parametro da esplorare, non da fissare a priori.

5. Trasformazione dei dati in due dimensioni

X_tsne = tsne.fit_transform(X_scaled)

print("\nForma dei dati dopo la riduzione con t-SNE:", X_tsne.shape)
print("Prime 5 coordinate 2D calcolate:")
print(X_tsne[:5])

Applichiamo fit_transform per ottenere le nuove coordinate bidimensionali di ogni campione, pronte per essere visualizzate su un grafico.

• fit_transform è l'unico metodo disponibile: t-SNE non offre un transform separato per nuovi dati.
• X_tsne.shape conferma che ogni campione ora è rappresentato da sole 2 coordinate.

A differenza di StandardScaler o PCA, t-SNE non può essere applicato a dati mai visti prima: ogni nuova proiezione richiede un nuovo addestramento completo.

6. Visualizzazione del risultato

plt.figure(figsize=(10, 8))
scatter = plt.scatter(X_tsne[:, 0], X_tsne[:, 1], c=y, cmap="tab10", s=15)
plt.colorbar(scatter, label="Cifra")
plt.title("Visualizzazione t-SNE del dataset digits")
plt.xlabel("Componente t-SNE 1")
plt.ylabel("Componente t-SNE 2")
plt.show()

Rappresentiamo i punti su un piano cartesiano, colorando ogni punto in base alla cifra che rappresenta, per verificare se t-SNE ha raggruppato correttamente le cifre simili.

• c=y colora i punti solo a scopo illustrativo: t-SNE non ha usato questa informazione per calcolare la proiezione.
• cmap="tab10" assegna un colore distinto a ciascuna delle 10 cifre.

Nonostante sia un algoritmo non supervisionato, il grafico mostra tipicamente gruppi ben separati per ogni cifra, a conferma che le distanze nello spazio originale contenevano informazione utile.

Punto chiave da sottolineare

t-SNE preserva la struttura locale dei dati ma non ha un metodo transform per nuovi campioni, non offre inverse_transform ed è pensato per l'esplorazione visiva, non come step riutilizzabile in una pipeline di produzione.

In poche parole...

Abbiamo caricato il dataset digits, standardizzato le feature, applicato t-SNE per ridurre 64 dimensioni a 2 e visualizzato il risultato con uno scatter plot colorato, osservando come cifre simili si raggruppino naturalmente nello spazio ridotto.

L'ingegneria delle caratteristiche, che comprende selezione, estrazione, analisi delle componenti principali (PCA) e riduzione della dimensionalità, è la pietra angolare della creazione di modelli di apprendimento automatico efficaci. Essa colma il divario tra i dati grezzi e le informazioni utili, garantendo che i modelli vengano addestrati sulle informazioni più rilevanti e significative.

Test finale lezione 01

Hai completato la Lezione 01! Prima di passare alla Lezione 02 mettiti alla prova con il test finale: copre pre-elaborazione dei dati, encoding, selezione ed estrazione delle caratteristiche, PCA e t-SNE. Il superamento concorre a sbloccare la lezione successiva e il risultato concorre al certificato di competenze rilasciato al termine del corso.

Per ottenere le chiavi di accesso alla lezione successiva devi anche spiegare a voce una scelta fatta nel tuo esercizio e risolvere una piccola variante al momento.

Ti viene fornito il seguente dataset che descrive 12 studenti. Scrivi uno script Python che esegua, nell'ordine, i passaggi indicati sotto. Carica il file .py risultante nell'apposito campo di consegna.

import pandas as pd

data = {
    'Ore_Studio':        [5, 3, None, 8, 6, 2, 7, 4, None, 9, 1, 6],
    'Assenze':           [2, 5, 3, 0, 1, 8, 0, 4, 6, 0, 9, 1],
    'Voto_Precedente':   [7.5, 6.0, 5.5, None, 8.0, 4.5, 7.0, 6.5, 5.0, 9.0, 4.0, 7.5],
    'Materia_Preferita': ['Matematica', 'Storia', 'Scienze', 'Matematica', 'Arte', 'Storia',
                           'Scienze', 'Arte', 'Matematica', 'Scienze', 'Storia', 'Arte'],
    'Promosso':          [1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1]
}
df = pd.DataFrame(data)

1. Correggi i tipi di dato inferiti automaticamente da pandas, usando i tipi "nullable" appropriati per ciascuna colonna.
2. Gestisci i valori mancanti nelle colonne numeriche con una strategia a tua scelta, motivando la scelta in un commento.
3. Codifica la colonna Materia_Preferita con la tecnica di encoding più adatta, motivando la scelta rispetto alle alternative viste a lezione.
4. Separa le feature (X) dal target (Promosso, y) e usa SelectKBest con chi2 per selezionare le 3 feature più informative. Presta attenzione all'ordine delle operazioni rispetto al punto successivo.
5. Standardizza le feature selezionate con StandardScaler, stampando media e deviazione standard prima e dopo la trasformazione.
6. (Bonus, facoltativo) Applica una PCA a 1 componente sulle feature standardizzate e stampa la varianza spiegata.

Articolo in aggiornamento
Ultimo aggiornamento: 23 agosto 2026

Carlo Mainardi