Apprendimento automatico e Reti Neurali - pagina 68
Ti stai perdendo delle opportunità di trading:
- App di trading gratuite
- Oltre 8.000 segnali per il copy trading
- Notizie economiche per esplorare i mercati finanziari
Registrazione
Accedi
Accetti la politica del sito e le condizioni d’uso
Se non hai un account, registrati
4.6 Generatori di numeri casuali NumPy (L04: Calcolo scientifico in Python)
4.6 Generatori di numeri casuali NumPy (L04: Calcolo scientifico in Python)
In questo video, forniremo una breve panoramica dei generatori di numeri casuali in NumPy. Sebbene non tratteremo tutti i diversi metodi per generare numeri casuali in NumPy, il nostro obiettivo sarà comprendere i generatori di numeri casuali e la loro utilità pratica.
Iniziamo con un semplice esempio. Inizieremo importando NumPy, che è la libreria che useremo per la generazione di numeri casuali. NumPy ha un modulo casuale che contiene varie funzioni per disegnare numeri casuali. Sebbene la documentazione a cui faremo riferimento sia un po' datata, fornisce un utile elenco di diverse funzioni e le relative descrizioni.
Una funzione comunemente usata è random.rand, che genera campioni casuali da una distribuzione uniforme. Specificando la forma dell'array desiderato (ad esempio, 2x3), questa funzione produrrà un array bidimensionale riempito con numeri casuali da una distribuzione uniforme.
NumPy offre anche altre funzioni, come random.random, che genera float casuali nell'intervallo semiaperto [0, 1). Puoi anche estrarre campioni casuali da diverse distribuzioni, come la distribuzione normale standard, usando la funzione random.randn.
A volte, potremmo voler assicurarci che il nostro codice produca gli stessi risultati casuali ogni volta che viene eseguito. Questo è utile per la riproducibilità, soprattutto quando si condivide codice o si confrontano metodi diversi. Per raggiungere questo obiettivo, possiamo impostare un seme casuale all'inizio del nostro codice o notebook. Il seme è un numero arbitrario che assicura che ogni volta venga generata la stessa sequenza di numeri casuali.
Impostando un seme casuale, i numeri casuali generati rimarranno costanti durante più esecuzioni del codice. Tuttavia, è importante notare che se estraiamo un altro campione casuale, i risultati saranno diversi perché si tratta ancora di un processo casuale.
Avere risultati coerenti può essere particolarmente utile nelle applicazioni di apprendimento automatico, come lo shuffling dei dati o il test delle implementazioni. Ad esempio, quando si suddivide un set di dati, l'impostazione di un seme casuale garantisce che la suddivisione sia sempre la stessa. Ciò consente un confronto e una valutazione accurati di diversi metodi.
Per gestire la casualità in modo più granulare, possiamo utilizzare un oggetto di stato casuale in NumPy. L'oggetto stato casuale ha il proprio generatore di numeri casuali, che consente un controllo granulare su dove viene applicata la casualità. Creando più oggetti di stato casuali, possiamo avere diverse fonti di casualità nel nostro codice. Ciò è particolarmente vantaggioso quando vogliamo che alcune parti del codice producano risultati coerenti mentre altre parti generano numeri casuali variabili.
Sebbene la vecchia classe random_state sia ancora ampiamente utilizzata, la comunità NumPy ora consiglia di utilizzare il nuovo generatore casuale. Questo nuovo generatore utilizza un metodo diverso per generare numeri casuali, ma per la maggior parte delle applicazioni semplici, la scelta tra i due non farà una differenza notevole. Ciò che conta di più è impostare un seme casuale per la riproducibilità.
È importante ricordare che i generatori di numeri casuali nel codice non sono veramente casuali ma pseudo-casuali. Usano algoritmi per produrre sequenze di numeri che imitano la casualità. Nel nostro contesto, l'attenzione è rivolta alla coerenza e alla riproducibilità piuttosto che all'algoritmo specifico utilizzato per la generazione di numeri casuali.
In conclusione, quando si lavora con generatori di numeri casuali in NumPy, la scelta del generatore stesso non è critica. Ciò che è essenziale è impostare un seme casuale per garantire risultati coerenti e riproducibili. Ciò diventa particolarmente prezioso quando si condivide codice, si inviano incarichi o si confrontano metodi diversi.
4.7 Rimodellamento degli array NumPy (L04: Calcolo scientifico in Python)
4.7 Rimodellamento degli array NumPy (L04: Calcolo scientifico in Python)
Infine, ci stiamo avvicinando alla conclusione della serie NumPy. Con solo tre video rimanenti, abbiamo raggiunto un argomento importante: rimodellare gli array NumPy. Rimodellare gli array è fondamentale quando dobbiamo trasformare i nostri dati nella forma desiderata, come convertire una matrice in un vettore o viceversa. Ho accennato brevemente a questo concetto nella lezione introduttiva, dove ho discusso di MNIST. Per illustrare questo processo, consideriamo un esempio semplificato.
Immagina di avere un array con dimensioni 28 per 28, che rappresenta un'immagine. Normalmente, ogni elemento nell'array corrisponderebbe a un valore in pixel. Tuttavia, per semplicità, supponiamo che ogni elemento sia solo una singola cifra. Quindi abbiamo un array 28 per 28 che rappresenta un'immagine di cifre. Tuttavia, se vogliamo utilizzare questo array come vettore di caratteristiche per un classificatore, dobbiamo rimodellarlo in un singolo vettore lungo con 784 elementi (28 * 28). Ogni esempio di formazione sarà un'immagine e ogni immagine avrà 784 caratteristiche.
Il rimodellamento di un array può essere eseguito utilizzando la funzione di rimodellamento in NumPy. Ad esempio, possiamo rimodellare un vettore 1, 2, 3, 4, 5, 6 in una matrice 2 per 3:
Quando si rimodella una matrice, viene creata una visualizzazione della memoria anziché una nuova matrice. Questa visualizzazione della memoria ci consente di manipolare l'array rimodellato senza duplicare i dati. Per verificarlo, possiamo utilizzare la funzione np.may_share_memory, anche se potrebbe non fornire sempre un risultato accurato al 100%.
L'uso di -1 come dimensione nel rimodellamento è una funzionalità utile in NumPy. Funge da segnaposto, consentendo al metodo di determinare la dimensione appropriata in base al numero totale di elementi. Ad esempio, se abbiamo un vettore con sei elementi e lo rimodelliamo utilizzando -1, 2, il -1 verrà sostituito con 3 poiché esiste un solo modo per disporre tre righe con due colonne per ottenere sei elementi. Questo concetto di segnaposto funziona con un numero arbitrario di dimensioni.
Inoltre, possiamo usare la funzione reshape per appiattire un array. Specificando un singolo valore come dimensione (ad esempio, reshape(6)), possiamo trasformare l'array in un vettore unidimensionale. In pratica, l'uso di -1 è più conveniente in quanto elimina la necessità di ricordare la dimensione. Ad esempio, reshape(-1) ottiene lo stesso risultato di reshape(6) per un array di sei elementi.
Esistono diversi modi per appiattire un array in NumPy. La funzione reshape con -1 crea una visualizzazione della memoria, mentre la funzione flatten appiattisce anche un array ma ne crea una copia. Un'altra funzione, ravel, viene utilizzata anche per appiattire gli array. Determinare le differenze tra queste funzioni sarebbe un buon quiz di autovalutazione.
Infine, possiamo concatenare gli array in NumPy, combinandoli lungo gli assi specificati. Quando si concatenano gli array lungo il primo asse, è simile all'aggiunta di elementi negli elenchi Python. Ad esempio, se abbiamo due array con un asse, concatenandoli lungo quell'asse si impileranno uno sotto l'altro.
Rimodellare gli array NumPy è essenziale per manipolare i dati nella forma desiderata. Comprendere i vari metodi, i segnaposto e le tecniche di concatenazione ci consente di lavorare efficacemente con gli array e di ottimizzare il nostro codice. Nel prossimo video parlerò degli operatori di confronto e delle maschere di NumPy, che sono strumenti potenti se combinati con il rimodellamento.
4.8 Operatori e maschere di confronto NumPy (L04: Calcolo scientifico in Python)
4.8 Operatori e maschere di confronto NumPy (L04: Calcolo scientifico in Python)
In NumPy, gli operatori di confronto e le maschere di selezione offrono molta flessibilità e possono essere abbastanza divertenti con cui lavorare. In un video precedente, abbiamo introdotto le maschere e gli operatori di confronto, ma ora esploriamo alcuni trucchi aggiuntivi che puoi utilizzare quando lavori con essi.
Iniziamo con un semplice esempio. Supponiamo di avere un array NumPy [1, 2, 3, 4] per semplicità. Possiamo definire una maschera per selezionare determinati valori dall'array. Questa maschera sarà un array booleano, il che significa che conterrà valori True o False. Possiamo creare la maschera specificando una condizione, ad esempio selezionando valori maggiori di due. L'array mask risultante avrà la stessa forma dell'array originale, con i valori True che indicano le posizioni in cui la condizione è vera e i valori False che indicano le posizioni in cui la condizione è falsa.
In Python esiste una comoda relazione tra valori booleani e numeri interi: True equivale a 1 e False equivale a 0. Questa relazione ci consente di eseguire operazioni interessanti. Ad esempio, possiamo usare l'istruzione if per verificare se una condizione è vera semplicemente scrivendo if condition:. Possiamo anche usare l'operatore not per verificare se una condizione è falsa scrivendo if not condition:. Questi approcci forniscono un codice più leggibile rispetto al confronto esplicito della condizione con True o False.
Un'altra caratteristica utile è la possibilità di contare il numero di elementi in un array che soddisfano una determinata condizione. Applicando l'operatore somma a una maschera, possiamo contare il numero di valori True nella maschera. Ad esempio, se abbiamo una maschera che seleziona valori maggiori di due, possiamo contare il numero di tali valori chiamando sum(mask). Allo stesso modo, possiamo contare il numero di valori False sottraendo la somma dal numero totale di elementi nell'array.
Per contare il numero di valori negativi in un array, possiamo utilizzare la funzione NumPy invert, che capovolge i valori booleani nella maschera. Applicando invert a una maschera e poi chiamando sum, possiamo contare il numero di valori False (che ora rappresentano i valori negativi).
Binarizzare un array, cioè convertirlo in una rappresentazione binaria, è un'altra operazione comune. Possiamo ottenere ciò assegnando un valore specifico alle posizioni in cui una condizione è vera e un altro valore alle posizioni in cui la condizione è falsa. Tuttavia, digitare l'intera operazione può essere noioso. Fortunatamente, NumPy fornisce la funzione where, che semplifica questo processo. La funzione where accetta una condizione e per le posizioni in cui la condizione è vera assegna il primo valore e per le posizioni in cui la condizione è falsa assegna il secondo valore. Usando where, possiamo facilmente binarizzare un array con una sola riga di codice.
Oltre agli operatori di confronto, NumPy offre operatori logici come and, or, xor e not. Questi operatori possono essere combinati con maschere per creare condizioni più complesse. Ad esempio, possiamo selezionare valori maggiori di tre o minori di due utilizzando l'operatore o. Combinando più condizioni utilizzando operatori logici, possiamo creare complesse maschere di selezione che soddisfano le nostre esigenze.
Queste maschere booleane, operatori logici e operatori di confronto in NumPy sono incredibilmente utili quando si lavora con i set di dati e si implementano le regole dell'albero decisionale. Esploreremo ulteriormente questi concetti nei prossimi video. Nel prossimo video, approfondiremo i concetti di base dell'algebra lineare in NumPy. Rimani sintonizzato!
4.9 Nozioni di base sull'algebra lineare di NumPy (L04: Calcolo scientifico in Python)
4.9 Nozioni di base sull'algebra lineare di NumPy (L04: Calcolo scientifico in Python)
In questo video, vorrei approfondire alcuni concetti fondamentali dell'algebra lineare, in particolare nel contesto di NumPy. Anche se in questo corso non utilizzeremo ampiamente l'algebra lineare, è fondamentale comprendere operazioni di base come i prodotti punto vettoriali e la moltiplicazione di matrici. Come accennato in precedenza, l'utilizzo della notazione dell'algebra lineare ci consente di scrivere codice più efficiente e conciso.
Iniziamo considerando un array unidimensionale come un vettore riga. In alternativa, possiamo definirlo come un vettore costituito da una singola riga con più elementi. D'altra parte, un vettore colonna può essere creato rimodellando il vettore riga per avere una colonna e più elementi. In sostanza, rappresenta la rappresentazione del vettore colonna. In particolare, l'uso delle parentesi quadre non è necessario in questo contesto.
Invece di rimodellare esplicitamente il vettore, possiamo ottenere lo stesso risultato aggiungendo un nuovo asse usando la funzione newaxis di NumPy. Aggiungendo due nuovi assi, possiamo persino creare un tensore 3D. Un altro approccio consiste nell'utilizzare la parola chiave None, che ha lo stesso scopo di newaxis. Questi tre metodi, vale a dire reshaping, newaxis e None, raggiungono tutti l'obiettivo di aggiungere un asse aggiuntivo quando necessario.
Andando avanti, incontriamo la notazione di algebra lineare di base per la moltiplicazione di matrici. In algebra lineare, la moltiplicazione di matrici equivale al calcolo di più prodotti punto. Ad esempio, se abbiamo i vettori [1, 2, 3] e [1, 2, 3], il loro prodotto scalare risulta 14. Allo stesso modo, il prodotto scalare di [4, 5, 6] e [1, 2, 3] restituisce 32. In NumPy, possiamo eseguire la moltiplicazione di matrici utilizzando la funzione matmul. In alternativa, l'operatore @ può essere utilizzato per comodità. Tuttavia, è importante notare che in algebra lineare non possiamo moltiplicare direttamente matrici e vettori. Tuttavia, possiamo considerare un vettore colonna come una matrice, in particolare una matrice 3x1. Questo approccio ci consente di moltiplicare una matrice per un vettore, cosa non possibile in algebra lineare rigorosa. Pertanto, NumPy offre maggiore flessibilità rispetto all'algebra lineare tradizionale.
Inoltre, NumPy fornisce la funzione punto per la moltiplicazione di matrici, che è ampiamente consigliata grazie alla sua efficiente implementazione sulla maggior parte delle macchine. Questa funzione ci consente di scrivere codice in modo più conveniente, soprattutto quando si tratta di vettori riga. Serve come scorciatoia o sovraccarico dell'operatore per la moltiplicazione di matrici in NumPy. Vale la pena notare che la funzione punto può gestire varie combinazioni di matrici e vettori, eseguendo prodotti scalari o moltiplicazioni di matrici in base alle forme di input.
Per quanto riguarda le prestazioni, entrambe le funzioni matmul e dot hanno una velocità simile. La scelta tra di loro potrebbe dipendere dalla macchina specifica. Tuttavia, la funzione punto è generalmente favorita nella pratica. Inoltre, l'operazione di trasposizione svolge un ruolo simile all'operazione di trasposizione nell'algebra lineare, capovolgendo efficacemente la matrice. Invece di usare esplicitamente la funzione transpose, possiamo utilizzare l'attributo T per brevità.
Sebbene NumPy includa un tipo di matrice per array bidimensionali, non è comunemente usato all'interno della comunità NumPy. Gli array multidimensionali regolari servono allo scopo nella maggior parte dei casi. Il tipo di matrice è limitato a due dimensioni e introduce una complessità non necessaria. Si consiglia di evitarne l'utilizzo se non espressamente richiesto.
Infine, tocchiamo brevemente SciPy, un'impressionante libreria che comprende un'ampia gamma di funzionalità aggiuntive oltre a NumPy. Questa libreria contiene numerosi algoritmi specializzati per il calcolo scientifico, come operazioni di algebra lineare, trasformate di Fourier, tecniche di interpolazione, algoritmi di ottimizzazione, funzioni statistiche e altro ancora. Sebbene sia basato su NumPy, SciPy funge da estensione, fornendo strumenti specializzati per vari calcoli scientifici. In questo corso, esploreremo algoritmi specifici all'interno di SciPy in caso di necessità. Non è necessario memorizzare tutti i dettagli; Introdurrò e spiegherò gli algoritmi rilevanti man mano che li incontriamo.
Con questo, concludiamo la nostra discussione su NumPy e SciPy per il calcolo scientifico in Python. Nel prossimo video, continueremo il nostro viaggio nel calcolo scientifico esplorando matplotlib, una potente libreria di plottaggio.
4.10 Matplotlib (L04: Calcolo scientifico in Python)
4.10 Matplotlib (L04: Calcolo scientifico in Python)
Finalmente siamo giunti alla fine della quarta lezione, che è stata piuttosto lunga. Tuttavia, spero che i concetti discussi su NumPy ti siano stati utili. In futuro, utilizzeremo ampiamente NumPy nei nostri compiti a casa per implementare algoritmi di apprendimento automatico. Pertanto, è fondamentale per te diventare esperto e familiare con NumPy a questo punto.
Passando all'ultimo argomento della lezione quattro, esploreremo matplotlib, che è una popolare libreria di plottaggio per Python. Sebbene al giorno d'oggi siano disponibili diverse librerie di plottaggio, matplotlib rimane la più utilizzata. Personalmente è anche la mia libreria di plottaggio preferita e il suo nome è ispirato a Metalab. La sintassi di matplotlib è abbastanza simile a MATLAB, che alcune persone apprezzano mentre altre no. Ad esempio, non mi piaceva usare MATLAB durante il mio periodo all'università, ma trovo che matplotlib sia un ottimo strumento.
Anche se non sei un fan di MATLAB, credo che matplotlib sia relativamente facile da usare. Inoltre, si integra perfettamente con NumPy, il che rappresenta un ulteriore vantaggio. Quindi, iniziamo con matplotlib. Dovrei menzionarlo personalmente, non memorizzo tutti i modi speciali per eseguire attività in matplotlib perché è una libreria di basso livello. Ciò significa che offre un alto livello di opzioni di personalizzazione, ma non tutte sono intuitive. Quindi, mi ritrovo spesso a cercare le cose. Quando devo fare qualcosa di specifico, visito la galleria matplotlib, che mostra vari esempi. Ad esempio, se voglio creare uno stem plot, lo cerco semplicemente nella galleria, trovo l'esempio e lo adatto ai miei dati. Questo approccio è solitamente sufficiente per le mie esigenze. Tuttavia, se preferisci tutorial più dettagliati, puoi anche esplorare il sito Web matplotlib.org, che offre tutorial esplicativi su diversi aspetti di matplotlib.
Per cominciare, quando si lavora con matplotlib in Jupyter Lab o Jupyter Notebooks, è possibile utilizzare la funzione inline per visualizzare i grafici all'interno del notebook stesso. Ciò significa che i grafici verranno visualizzati direttamente nel notebook, evitando la necessità di una finestra separata. Sebbene esistano modi alternativi per raggiungere questo obiettivo, personalmente raccomando di utilizzare l'approccio in linea poiché è più affidabile su computer diversi. Per attivare la modalità inline, puoi usare il seguente comando magico: %matplotlib inline. In alternativa, puoi aggiungere un punto e virgola alla fine delle dichiarazioni della trama, che di solito ottiene lo stesso risultato. Tuttavia, è consigliabile utilizzare plt.show() per visualizzare i grafici, poiché il trucco del punto e virgola potrebbe non funzionare bene su alcuni computer.
Ora tuffiamoci nella creazione di alcuni semplici grafici usando matplotlib. Ad esempio, possiamo iniziare tracciando una curva sinusoidale. Per fare ciò, possiamo utilizzare la funzione np.linspace per generare 100 valori compresi tra zero e dieci, quindi tracciare questi valori rispetto a np.sin, che è la funzione seno. Il modo più semplice per creare un grafico è utilizzare la funzione plt.plot, dove plt è l'abbreviazione di matplotlib.pyplot. Possiamo regolare gli intervalli degli assi del grafico utilizzando le funzioni plt.xlim e plt.ylim per impostare rispettivamente i limiti per l'asse x e l'asse y. Inoltre, possiamo aggiungere etichette all'asse x e all'asse y utilizzando le funzioni plt.xlabel e plt.ylabel. Infine, per visualizzare il grafico, possiamo utilizzare la funzione plt.show() o aggiungere un punto e virgola alla fine delle istruzioni del grafico per sopprimere l'output indesiderato.
Oltre a una singola trama, possiamo anche creare più trame all'interno della stessa figura. Ad esempio, possiamo tracciare sia una curva seno che una curva coseno in sottotrame separate. Per ottenere ciò, possiamo creare due figure utilizzando la funzione plt.subplots e quindi tracciare le rispettive curve seno e coseno in ciascuna sottotrama. La funzione plt.subplots restituisce un oggetto figure e un array di oggetti axis, che possiamo usare per personalizzare individualmente ogni sottotrama.
Ecco un frammento di codice di esempio che dimostra la creazione di più sottotrame:
In questo esempio, utilizziamo la funzione plt.subplots per creare una figura con 2 sottotrame disposte verticalmente (2, 1). La funzione restituisce un oggetto figure fig e un array di oggetti axis axs con dimensioni corrispondenti al layout della sottotrama specificato. Possiamo accedere a ciascuna sottotrama indicizzando l'array axs.All'interno dei blocchi di codice specifici della sottotrama, utilizziamo la funzione plot per tracciare le rispettive curve, quindi personalizziamo il titolo di ciascuna sottotrama, l'etichetta dell'asse x e l'etichetta dell'asse y utilizzando rispettivamente le funzioni set_title, set_xlabel e set_ylabel.
La funzione tight_layout viene chiamata per regolare la spaziatura tra le sottotrame, garantendo una migliore leggibilità. Infine, usiamo plt.show() per visualizzare la figura contenente le sottotrame.
Puoi provare a eseguire questo codice nell'ambiente Jupyter Notebook o Jupyter Lab per visualizzare la figura risultante con le curve seno e coseno visualizzate in sottotrame separate.
Questo è solo un esempio di base della creazione di sottotrame e ci sono molte altre opzioni di personalizzazione disponibili in matplotlib per rendere le tue trame più informative e visivamente accattivanti. Puoi esplorare la documentazione e la galleria di matplotlib per ulteriori esempi e spiegazioni dettagliate.
5.1 Lettura di un set di dati da un file di testo tabulare (L05: Machine Learning con Scikit-Learn)
5.1 Lettura di un set di dati da un file di testo tabulare (L05: Machine Learning con Scikit-Learn)
Ciao a tutti! Spero che abbiate passato una settimana fantastica e che abbiate avuto la possibilità di elaborare tutto il materiale di NumPy. Questa settimana ci concentreremo sull'elaborazione dei dati e sull'apprendimento automatico con scikit-learn, quindi è essenziale avere una buona conoscenza di NumPy. Credo che sia incredibilmente utile esercitarsi nella programmazione e applicare i concetti che apprendiamo in esempi di vita reale, motivo per cui faremo un po' di programmazione in anticipo in questa lezione. Ci avvantaggerà più avanti nella classe quando utilizzeremo ampiamente questi strumenti. A proposito, non c'è molto altro da aggiungere per questa lezione, tranne che ho caricato il primo grande compito a casa, che ti metterà alla prova sui concetti che abbiamo trattato nelle lezioni precedenti, incluso l'apprendimento supervisionato e gli esempi di codice usando NumPy. È una grande opportunità per fare esperienza pratica con l'algoritmo K-nearest neighbor ed esplorare ulteriormente NumPy e scikit-learn.
Ora, mentre ti immergi nei video, completi i compiti e rispondi al quiz di autovalutazione, voglio ricordarti di divertirti e divertirti. L'autunno, la mia stagione preferita, è appena iniziata qui in Wisconsin e adoro il clima più freddo e i bellissimi colori delle foglie che cambiano. A proposito, sono davvero emozionato perché lo scorso fine settimana sono già andato in un campo di zucche e ho preso delle zucche che non vedo l'ora di scolpire per Halloween. Allora, cominciamo con la lezione così posso tornare alle mie piccole zucche e prepararle per Halloween.
Bene, siamo arrivati alla terza parte delle lezioni sui fondamenti computazionali. In questa lezione tratteremo diversi argomenti, a partire dalla lettura in un set di dati da un file di testo tabulare, come un file CSV, che è il formato di file più comune per le tradizionali attività di machine learning. Discuteremo quindi delle tecniche di gestione dei dati di base, inclusa la modellazione dei dati per gli algoritmi di apprendimento automatico e le procedure di addestramento.
Successivamente, ci immergeremo nell'apprendimento automatico con scikit-learn. Ma prima di farlo, voglio ricapitolare brevemente le classi Python e la programmazione orientata agli oggetti. Negli esercizi precedenti vi ho chiesto di prepararvi per Python o di comprenderne meglio i concetti. È importante avere una buona conoscenza della programmazione orientata agli oggetti perché scikit-learn fa molto affidamento su di essa. Quindi, la comprensione della programmazione orientata agli oggetti è necessaria per comprendere come funziona scikit-learn.
Andando avanti, discuteremo della preparazione dei dati di addestramento utilizzando l'API del trasformatore di scikit-learn. Tratteremo anche la definizione di pipeline scikit-learn, che ci aiutano a concatenare diverse operazioni, come la preparazione del set di dati, il ridimensionamento, la normalizzazione, la riduzione della dimensionalità e il classificatore stesso. Utilizzando le pipeline, possiamo creare flussi di lavoro di formazione efficienti che collegano vari aspetti del processo di apprendimento automatico, rendendo le cose più convenienti. Questo è uno dei punti di forza significativi di scikit-learn.
Per questa lezione, ho deciso di utilizzare di nuovo le diapositive. Sebbene Jupiter Lab sia uno strumento fantastico, trovo più facile spiegare alcuni concetti annotando esempi di codice con una penna o una matita. Quindi, in queste diapositive, ho catturato screenshot da Jupiter Lab e Jupiter Notebook, che annoterò durante la conferenza. Tuttavia, ho anche caricato l'intero blocco appunti del codice su GitHub, dove puoi trovare ulteriori spiegazioni. Considera questo documento come un corso facoltativo o appunti di lezione per il tuo riferimento.
Ricapitoliamo velocemente a che punto siamo in questo corso. Abbiamo iniziato con un'introduzione all'apprendimento automatico, coperto le basi ed esplorato come funziona scikit-learn. Quindi, abbiamo approfondito Python, imparando a conoscere NumPy e il calcolo scientifico. Ora stiamo entrando nella fase dell'elaborazione dei dati e dell'apprendimento automatico con scikit-learn. Nella prossima lezione, torneremo ai concetti fondamentali dell'apprendimento automatico come gli alberi decisionali, i metodi di ensemble e la valutazione del modello. Sebbene questa sia l'ultima parte delle lezioni sui fondamenti computazionali, non significa che sia la fine del corso. Dopo aver completato le lezioni sui fondamenti computazionali, passeremo ad argomenti più avanzati nell'apprendimento automatico, incluso il deep learning e le reti neurali.
Ora, tuffiamoci nel primo argomento di questa lezione: lettura in un set di dati da un file di testo tabulare. Quando si lavora con l'apprendimento automatico, è normale che i dati vengano archiviati in formati tabulari come i file CSV (Comma-Separated Values). Questi file contengono righe e colonne di dati, con ciascuna riga che rappresenta un campione o un'istanza e ciascuna colonna che rappresenta una caratteristica o un attributo.
Per leggere in un file CSV in Python, possiamo usare la libreria Pandas. Pandas fornisce potenti strumenti di manipolazione e analisi dei dati, rendendolo una scelta popolare per lavorare con dati tabulari in Python. Diamo un'occhiata a un esempio:
In questo esempio, per prima cosa importiamo la libreria pandas e la alias come pd per comodità. Quindi, utilizziamo la funzione read_csv() per leggere il file CSV data.csv in un DataFrame, che è una struttura di dati tabellare bidimensionale fornita da Pandas. Il DataFrame è memorizzato nella variabile data.
Dopo aver letto i dati, possiamo utilizzare la funzione head() per visualizzare le prime righe del DataFrame. Questo ci consente di ispezionare rapidamente i dati e verificare che siano stati letti correttamente.
Pandas offre una vasta gamma di funzioni e metodi per manipolare e analizzare i dati. Possiamo eseguire varie operazioni come filtrare righe, selezionare colonne, aggregare dati e molto altro. Se non conosci Pandas, ti incoraggio a esplorare la sua documentazione e sperimentare da solo diverse operazioni.
Ora che sappiamo come leggere i dati, passiamo all'argomento successivo: le tecniche di base per la gestione dei dati. Quando si lavora con i dati per l'apprendimento automatico, è essenziale preelaborare e preparare i dati in modo appropriato. Ciò include attività come la gestione dei valori mancanti, la codifica delle variabili categoriche, il ridimensionamento delle caratteristiche numeriche e la suddivisione dei dati in insiemi di addestramento e test.
Una fase di pre-elaborazione comune è la gestione dei valori mancanti. I valori mancanti sono spesso rappresentati come valori NaN (Not a Number) o NULL nei dati. Questi valori mancanti possono causare problemi durante l'addestramento dei modelli di machine learning, quindi è necessario gestirli in modo appropriato. Pandas fornisce diverse funzioni per gestire i valori mancanti, come isna() per verificare la presenza di valori mancanti, fillna() per riempire i valori mancanti con un valore specificato e dropna() per rimuovere righe o colonne con valori mancanti.
La codifica delle variabili categoriali è un altro passo importante. I modelli di machine learning in genere funzionano con dati numerici, quindi è necessario convertire le variabili categoriche in una rappresentazione numerica. Una tecnica di codifica comune è la codifica one-hot, in cui creiamo colonne binarie per ogni categoria e indichiamo la presenza o l'assenza di una categoria rispettivamente con 1 o 0.
Il ridimensionamento delle caratteristiche numeriche è un'altra fase di pre-elaborazione comune. Molti algoritmi di apprendimento automatico sono sensibili alla scala delle funzionalità. Se le feature hanno scale diverse, ciò può influire sulle prestazioni del modello. Per risolvere questo problema, possiamo ridimensionare le funzionalità a un intervallo standard, ad esempio da 0 a 1 o da -1 a 1. Pandas fornisce le classi MinMaxScaler e StandardScaler nel modulo sklearn.preprocessing per eseguire il ridimensionamento delle funzionalità.
Infine, la suddivisione dei dati in set di addestramento e test è fondamentale per valutare le prestazioni dei modelli di machine learning. In genere dividiamo i dati in due set: un set di addestramento utilizzato per addestrare il modello e un set di test utilizzato per valutarne le prestazioni. Pandas fornisce la funzione train_test_split() nel modulo sklearn.model_selection per suddividere i dati in set di addestramento e test.
Successivamente, utilizziamo la funzione train_test_split() per suddividere i dati in set di addestramento e test. Passiamo le caratteristiche X e le etichette y, specifichiamo la dimensione del test desiderata (ad esempio, 0,2 per un set di test del 20%) e impostiamo uno stato casuale per la riproducibilità.
Dopo aver suddiviso i dati, possiamo utilizzare il set di addestramento (X_train e y_train) per addestrare il nostro modello di machine learning e valutarne le prestazioni sul set di test (X_test e y_test).
Queste sono alcune tecniche di gestione dei dati di base nell'apprendimento automatico utilizzando la libreria Pandas in Python. Ricorda, la preelaborazione e la preparazione dei dati sono passaggi essenziali nella pipeline di machine learning e sono disponibili molte più tecniche e strumenti a seconda dei requisiti specifici del tuo progetto.
5.2 Gestione dei dati di base (L05: Machine Learning con Scikit-Learn)
5.2 Gestione dei dati di base (L05: Machine Learning con Scikit-Learn)
Nel video precedente, abbiamo discusso su come leggere un file di testo tabulare come set di dati. In particolare, ci siamo concentrati sul lavoro con un file CSV e, più specificamente, il set di dati Iris. Abbiamo importato il set di dati Iris da un file CSV in un DataFrame Pandas.
In questo video, approfondiremo la preparazione dei dati nel formato appropriato per l'apprendimento automatico utilizzando scikit-learn. Esploreremo le tecniche di gestione dei dati di base utilizzando Pandas e NumPy per trasformare i dati in un formato adatto all'apprendimento automatico. Ma prima di procedere, ricapitoliamo brevemente il concetto di funzioni Python, poiché sarà utile quando discutiamo della trasformazione dei valori in un DataFrame Pandas.
Qui abbiamo una semplice funzione Python chiamata "some_func". Prende un singolo argomento di input, "x", e lo converte in una stringa. Quindi concatena il valore convertito con la stringa fissa "hello world". Se forniamo un numero intero, ad esempio 123, come input, verrà convertito in una stringa ("123") e concatenato con "ciao mondo", risultando nella stringa finale. Questa è una panoramica di base su come funzionano le funzioni Python, con i due punti che indicano il corpo della funzione e un'istruzione return che specifica l'output. Sebbene possano esserci più righe di codice all'interno della funzione, l'istruzione return segna la fine.
Un altro concetto degno di nota sono le funzioni lambda. Le funzioni lambda sono un modo abbreviato per definire piccole funzioni senza nominarle esplicitamente. Sono comunemente usati quando è necessario salvare righe di codice e scrivere rapidamente funzioni. Nel contesto delle trasformazioni dei dati nelle colonne Pandas, vengono spesso utilizzate le funzioni lambda. Sebbene le funzioni lambda offrano una sintassi più concisa, essenzialmente eseguono le stesse operazioni delle normali funzioni. Sono particolarmente utili se combinati con il metodo apply su una colonna Pandas DataFrame.
Nella lezione precedente, abbiamo letto il set di dati Iris in un DataFrame Pandas dal file CSV. Il set di dati Iris è composto da 150 righe, ma mostriamo solo le prime cinque righe per brevità. Il set di dati include una colonna ID, che non è essenziale, seguita dalle caratteristiche rappresentate dalla matrice di progettazione X. Abbiamo anche le etichette di classe, tipicamente indicate come y. Tradizionalmente, scikit-learn e altre librerie non gestivano le variabili stringa come etichette di classe, quindi era pratica comune convertirle in numeri interi. Ad esempio, "Iris setosa" verrebbe convertito nell'intero 0, "Iris versicolor" in 1 e "Iris virginica" in 2. Questa conversione era necessaria perché molti algoritmi erano progettati per funzionare con etichette di classi intere piuttosto che con etichette di stringhe.
Tuttavia, scikit-learn ora supporta le etichette delle classi di stringhe nella maggior parte delle funzioni, eliminando la necessità di una conversione esplicita. Internamente, la conversione viene gestita automaticamente. Tuttavia, alcuni strumenti potrebbero non gestire correttamente i dati delle stringhe, quindi si consiglia comunque di convertire le etichette delle classi in numeri interi. In questo modo, garantisci la compatibilità con vari strumenti e riduci la probabilità di riscontrare errori.
Per illustrare il processo di conversione, utilizzeremo la funzione lambda insieme al metodo apply. Applicando una funzione lambda alla colonna delle specie del DataFrame, possiamo convertire le etichette della classe stringa in etichette intere. Tuttavia, vale la pena ricordare che l'utilizzo di un dizionario di mappatura è spesso un approccio migliore. Fornisce una migliore leggibilità e consente una più facile interpretazione delle trasformazioni delle etichette di classe. Inoltre, se in un secondo momento è necessario recuperare le etichette di classe originali, è possibile definire un dizionario inverso e utilizzarlo per mappare le etichette di numeri interi alle loro rappresentazioni di stringa originali.
Per dimostrare la conversione, ricarichiamo il set di dati nel suo stato originale. Quindi, invece di utilizzare apply, utilizziamo la funzione map per convertire le etichette delle stringhe in numeri interi utilizzando il dizionario di mappatura. Mostriamo anche l'uso dell'attributo values, che accede all'array NumPy sottostante. Lavorare con gli array NumPy.
Lavorare con gli array NumPy può essere vantaggioso per diversi motivi. Gli array NumPy sono più efficienti in termini di memoria rispetto ai Pandas DataFrame, rendendoli ideali per set di dati di grandi dimensioni. Inoltre, molti algoritmi di apprendimento automatico in scikit-learn si aspettano che i dati di input siano sotto forma di array NumPy.
Per convertire i nostri Pandas DataFrame in array NumPy, possiamo semplicemente accedere all'attributo values del DataFrame. Vediamo un esempio:
Allo stesso modo, accediamo alla colonna 'species' del DataFrame utilizzando l'operatore di indicizzazione [] e lo convertiamo in un array NumPy, assegnandolo alla variabile y.
Ora, la variabile X contiene la matrice delle caratteristiche come matrice NumPy e la variabile y contiene le etichette di classe come matrice NumPy. Possiamo utilizzare questi array come input per vari algoritmi di apprendimento automatico.
Supponiamo di voler suddividere il nostro set di dati in set di addestramento e test per la valutazione del modello. Scikit-learn fornisce una funzione di utilità chiamata train_test_split che semplifica questo compito. Ecco un esempio:
Dopo aver chiamato train_test_split, otteniamo quattro array: X_train e y_train contengono i dati di addestramento, mentre X_test e y_test contengono i dati di test.
Ora puoi utilizzare gli array X_train e y_train per addestrare il tuo modello di machine learning e valutarne le prestazioni utilizzando gli array X_test e y_test.
In sintesi, convertendo Pandas DataFrame in array NumPy, possiamo sfruttare i vantaggi di NumPy, come l'efficienza della memoria e la compatibilità con gli algoritmi di machine learning. Inoltre, scikit-learn fornisce comode funzioni come train_test_split per suddividere i dati in set di addestramento e test.
5.3 Programmazione orientata agli oggetti e classi Python (L05: Machine Learning con Scikit-Learn)
5.3 Programmazione orientata agli oggetti e classi Python (L05: Machine Learning con Scikit-Learn)
Prima di approfondire l'argomento dell'apprendimento automatico con scikit-learn nella prossima lezione, prendiamoci un momento per discutere la programmazione orientata agli oggetti, in particolare le classi Python. La comprensione delle classi sarà molto importante poiché scikit-learn si basa fortemente su concetti di programmazione orientati agli oggetti. Verso la fine di questo video, dimostrerò l'implementazione di K-nearest neighbor utilizzando l'API scikit-learn, che è l'approccio utilizzato da scikit-learn per implementare stimatori come i classificatori.
Quindi, iniziamo discutendo delle classi Python. Per comprendere meglio l'API scikit-learn, è importante comprendere le basi delle classi. In termini semplici, una classe può essere pensata come un progetto per la creazione di oggetti. Gli oggetti sono istanze di una classe e possono essere visualizzati come diverse varianti della stessa forma di cookie cutter utilizzata per creare i cookie. La classe stessa funge da modello di cookie cutter, mentre i cookie rappresentano gli oggetti creati dalla classe.
In Python, definiamo una classe usando la parola chiave class, seguita dal nome della classe. All'interno della classe, definiamo diversi metodi di classe. I metodi di classe sono simili alle funzioni, ma hanno un primo argomento obbligatorio chiamato self, che fa riferimento all'oggetto stesso. Questo argomento self ci consente di accedere agli attributi e ai metodi dell'oggetto. In altre parole, ci permette di interagire con i dati e il comportamento dell'oggetto.
Nel contesto dell'esempio del veicolo, consideriamo una semplice classe di veicoli ingenua. Questa classe rappresenta diversi tipi di veicoli come auto, moto o camion. La classe ha vari metodi per definire il suo comportamento. Il primo metodo è il metodo __init__, noto anche come costruttore. Questo metodo viene eseguito automaticamente quando viene creato un nuovo oggetto dalla classe. Accetta l'argomento self e qualsiasi argomento aggiuntivo richiesto per inizializzare l'oggetto.
Nel metodo __init__, definiamo un attributo chiamato potenza, a cui viene assegnato il valore fornito come argomento. Questo attributo rappresenta la potenza del veicolo. Quando viene creato un nuovo oggetto, avrà un attributo di potenza a cui è possibile accedere per recuperare il valore di potenza.
Oltre al metodo __init__, possiamo definire altri metodi che modificano gli attributi dell'oggetto. Ad esempio, il metodo tune_motor raddoppia l'attributo di potenza del veicolo, simulando una messa a punto del motore. Chiamando questo metodo sull'oggetto veicolo, il suo attributo cavalli verrà modificato di conseguenza.
Inoltre, possiamo definire metodi che restituiscono valori basati sugli attributi dell'oggetto. Nell'esempio, il metodo horsepower_to_torque calcola il valore della coppia in base alla potenza dell'oggetto e al valore RPM fornito. Questo metodo dimostra come gli attributi dell'oggetto possono essere utilizzati per eseguire calcoli e restituire risultati utili.
Vale la pena notare che in Python esistono convenzioni per indicare la visibilità dei metodi. I metodi con un singolo prefisso di sottolineatura, ad esempio _private_method, sono considerati privati e non sono destinati all'uso diretto da parte degli utenti della classe. Tuttavia, gli utenti possono ancora accedere e chiamare questi metodi, anche se in genere è sconsigliato. I metodi con un prefisso con doppia sottolineatura, come __very_private_method, sono ancora più limitati e richiedono una sintassi specifica per accedervi.
Inoltre, Python supporta l'ereditarietà delle classi, permettendoci di creare classi figlie che ereditano proprietà e metodi da una classe genitore. Questo concetto ci consente di creare classi specializzate con attributi e comportamenti aggiuntivi sfruttando al contempo la funzionalità esistente definita nella classe genitore. Ad esempio, potremmo creare una classe Car specializzata che eredita dalla classe Vehicle e aggiunge un attributo number_of_wheels specifico per le auto.
Per illustrare i concetti discussi, viene fornito un esempio di classificatore K-nearest neighbors. Questa implementazione segue le convenzioni dell'API di scikit-learn e dimostra l'uso di una classe di stima in scikit-learn. Ecco un'implementazione semplificata:
In questo esempio, KNNClassifier è una classe che rappresenta un classificatore K-nearest neighbors. Il costruttore accetta un parametro k, che specifica il numero di vicini più vicini da considerare.
Il metodo fit viene utilizzato per addestrare il classificatore. Accetta due argomenti: X_train (i dati di addestramento) e y_train (le etichette corrispondenti). Il metodo archivia semplicemente i dati di addestramento e le etichette negli attributi dell'oggetto per un uso successivo.
Il metodo predict viene utilizzato per effettuare previsioni su nuovi dati. Prende X_test (i dati del test) come argomento e restituisce le etichette previste per i dati del test. Per ogni punto dati in X_test, il metodo calcola le distanze da tutti i punti dati nel set di training utilizzando il metodo _calculate_distance. Quindi seleziona i k vicini più vicini e determina la classe maggioritaria utilizzando il metodo _majority_vote. L'etichetta prevista viene aggiunta all'elenco delle previsioni.
Il metodo _calculate_distance è un metodo privato (indicato dal carattere di sottolineatura iniziale) che calcola la distanza tra due punti dati. Questa potrebbe essere la distanza euclidea o qualsiasi altra metrica di distanza adatta al problema.
Il metodo _majority_vote è un altro metodo privato che determina la classe di maggioranza tra un insieme di vicini. Questo può essere fatto contando le occorrenze di ogni etichetta di classe e selezionando l'etichetta con il conteggio più alto.
Questo esempio dimostra la struttura di base di una classe di stima in scikit-learn. Naturalmente, scikit-learn fornisce un'implementazione più sofisticata e ottimizzata dei vicini K più vicini nella classe KNeighborsClassifier, ma questa versione semplificata illustra i principi sottostanti.
5.4 Introduzione a Scikit-learn (L05: Apprendimento automatico con Scikit-Learn)
5.4 Introduzione a Scikit-learn (L05: Apprendimento automatico con Scikit-Learn)
In questo video relativamente breve, l'obiettivo è introdurre l'apprendimento automatico con scikit-learn. Scikit-learn è una libreria di apprendimento automatico ampiamente utilizzata in Python che fornisce un set completo di strumenti e algoritmi per varie attività di apprendimento automatico. Anche se potresti aver già visto scikit-learn nel contesto delle lezioni k-nearest neighbor (KNN), questo video mira a fare un passo indietro e presentare correttamente la biblioteca.
Dopo questo breve video, ci sarà un video più lungo che approfondisce la preparazione del set di dati di addestramento utilizzando scikit-learn. Questo riguarderà le tecniche e gli strumenti che rendono la preparazione dei dati più conveniente ed efficiente rispetto agli approcci tradizionali.
Nel video successivo, esploreremo alcuni dei concetti interessanti di scikit-learn, come la combinazione di tecniche di pre-elaborazione, adattamento del classificatore di machine learning e formazione, utilizzando le pipeline di scikit-learn. Ciò consente un flusso di lavoro più snello ed efficiente.
Ora, discutiamo più dettagliatamente dell'apprendimento automatico con scikit-learn. Scikit-learn è ampiamente considerata la principale libreria di apprendimento automatico per Python grazie alla sua reputazione consolidata, all'ampia base di utenti e alla natura user-friendly. È una libreria ben progettata che offre un'API coerente e intuitiva. Scikit-learn viene inoltre gestito attivamente e aggiornato regolarmente, con numerosi contributori che lo rendono una scelta robusta e affidabile per le attività di machine learning.
È importante notare che scikit-learn si concentra principalmente sulle tradizionali tecniche di machine learning e non è pensato per il deep learning. Il deep learning è un campo separato con le proprie librerie specializzate. Per il deep learning, in genere vengono utilizzate altre librerie come TensorFlow o PyTorch. Tuttavia, per le tradizionali attività di apprendimento automatico, scikit-learn è spesso la libreria di riferimento.
Scikit-learn esiste da un po' di tempo, con la sua versione iniziale che risale al 2007. Nonostante la sua età, rimane una libreria popolare e mantenuta attivamente. È iniziato come un progetto Google Summer of Code di David Cournapeau e nel tempo ha ottenuto il contributo di molti altri sviluppatori. Con oltre 1.875 collaboratori su GitHub e quasi 150.000 utenti, è evidente che scikit-learn è una libreria molto apprezzata con un sostanziale supporto da parte della comunità.
È possibile trovare il sito Web ufficiale di scikit-learn, che include documentazione, tutorial e altre risorse utili. Se usi scikit-learn nei tuoi progetti di ricerca, è buona norma citare la biblioteca come riferimento, riconoscendo gli sforzi profusi nel suo sviluppo.
Per comprendere l'API Estimator di scikit-learn, approfondiamo i suoi componenti principali. L'API Estimator viene utilizzata per le attività di apprendimento supervisionato e include regressori per l'analisi della regressione e classificatori per le attività di classificazione. Quando si utilizza scikit-learn, in genere si inizializza uno stimatore con iperparametri specifici, impostati nel costruttore della classe.
Il processo di adattamento è cruciale per uno stimatore. Dopo l'inizializzazione, è necessario chiamare il metodo fit, fornendo i dati di addestramento (funzionalità) e le etichette corrispondenti. Il metodo di adattamento addestra lo stimatore sui dati forniti, consentendogli di fare previsioni in seguito. Durante il processo di adattamento, alcuni attributi vengono assegnati allo stimatore, indicati da un carattere di sottolineatura finale, a indicare che sono stati creati durante l'adattamento del modello.
Una volta adattato il modello, è possibile utilizzare il metodo predict per effettuare previsioni su nuovi dati. Il metodo predict accetta i dati del test (con le stesse funzionalità dei dati di addestramento) come input e restituisce le etichette previste.
Inoltre, scikit-learn fornisce un metodo di punteggio che calcola le prestazioni del modello. Per i classificatori, spesso rappresenta l'accuratezza, mentre per i regressori, in genere calcola il coefficiente di determinazione (punteggio R^2). Questo metodo serve come un modo conveniente per valutare le prestazioni del modello.
Oltre a questi componenti principali, scikit-learn offre anche un'ampia gamma di tecniche e utilità di pre-elaborazione per migliorare il flusso di lavoro di machine learning.
Un aspetto importante dell'apprendimento automatico è la preelaborazione dei dati, che comporta la trasformazione dei dati grezzi in un formato adatto per l'addestramento di un modello. Scikit-learn fornisce vari moduli di pre-elaborazione in grado di gestire attività come il ridimensionamento delle funzionalità, la gestione dei valori mancanti, la codifica delle variabili categoriali e altro ancora.
Ad esempio, la classe StandardScaler può essere utilizzata per standardizzare le funzionalità sottraendo la media e il ridimensionamento alla varianza unitaria. Questo è importante quando si lavora con caratteristiche che hanno scale diverse, poiché aiuta gli algoritmi a convergere più velocemente e a produrre risultati più accurati.
Un'altra utile tecnica di preelaborazione è la gestione dei valori mancanti. La classe SimpleImputer fornisce strategie per sostituire i valori mancanti con alternative adeguate, ad esempio utilizzando la media, la mediana o i valori più frequenti delle caratteristiche corrispondenti.
Quando si tratta di variabili categoriali, scikit-learn offre le classi OneHotEncoder e LabelEncoder. LabelEncoder converte le etichette di categoria in valori numerici, mentre OneHotEncoder trasforma le caratteristiche di categoria in una rappresentazione vettoriale binaria, consentendo agli algoritmi di lavorare efficacemente con i dati di categoria.
Per semplificare il flusso di lavoro di machine learning, scikit-learn fornisce un potente strumento chiamato pipeline. Una pipeline combina più passaggi di pre-elaborazione e un modello di machine learning in un singolo oggetto, semplificando la gestione e l'applicazione coerente dell'intero flusso di lavoro.
Le pipeline assicurano che le stesse fasi di pre-elaborazione vengano applicate in modo coerente sia ai set di dati di addestramento che a quelli di test, evitando fughe di dati e potenziali errori. Semplificano inoltre il processo di distribuzione, in quanto è possibile salvare l'intero oggetto pipeline e riutilizzarlo su nuovi dati senza preoccuparsi dei singoli passaggi di pre-elaborazione.
Utilizzando la funzionalità della pipeline di scikit-learn, puoi concatenare più tecniche di preelaborazione, come il ridimensionamento, l'assegnazione di valori mancanti e la codifica di variabili categoriche, con il modello di machine learning desiderato. Ciò si traduce in un flusso di lavoro più snello ed efficiente, che ti consente di concentrarti sugli aspetti fondamentali del tuo progetto di machine learning.
Scikit-learn supporta un'ampia gamma di algoritmi di apprendimento automatico, tra cui regressione lineare, regressione logistica, macchine vettoriali di supporto, alberi decisionali, foreste casuali, aumento del gradiente e molti altri. Ogni algoritmo è implementato come una classe di stima con metodi coerenti come adattamento, previsione e punteggio.
Per selezionare l'algoritmo appropriato per il tuo compito, scikit-learn fornisce vari strumenti per la selezione e la valutazione del modello. Questi includono tecniche per la convalida incrociata, l'ottimizzazione degli iperparametri e le metriche di valutazione del modello. La convalida incrociata aiuta a valutare le prestazioni del modello suddividendo i dati in più suddivisioni di test di addestramento, addestrando e valutando il modello su diversi sottoinsiemi di dati.
L'ottimizzazione degli iperparametri implica la ricerca dei valori ottimali per gli iperparametri di un modello, che sono parametri che non vengono appresi dai dati ma vengono impostati prima dell'addestramento. Scikit-learn fornisce metodi come la ricerca su griglia e la ricerca casuale per automatizzare il processo di ricerca dei migliori valori di iperparametro.
Le metriche di valutazione del modello, come accuratezza, precisione, richiamo, punteggio F1 e area sotto la curva ROC, sono cruciali per valutare le prestazioni del modello in diverse attività. Scikit-learn offre una vasta gamma di tali metriche che possono essere facilmente calcolate e confrontate.
Scikit-learn è una libreria di apprendimento automatico potente e popolare in Python che fornisce un'ampia gamma di strumenti e algoritmi per varie attività di apprendimento automatico. La sua API intuitiva, l'ampia documentazione e la community attiva lo rendono una scelta eccellente sia per i principianti che per i professionisti esperti. Sia che tu abbia bisogno di preelaborare i tuoi dati, creare pipeline, selezionare modelli o valutare le prestazioni, scikit-learn ha gli strumenti necessari per svolgere il lavoro in modo efficiente ed efficace.
5.5 Scikit-learn Transformer API (L05: Apprendimento automatico con Scikit-Learn)
5.5 Scikit-learn Transformer API (L05: Apprendimento automatico con Scikit-Learn)
Nel video, il relatore approfondisce il processo di preparazione di un set di dati di addestramento utilizzando le utilità di scikit-learn e introduce l'API del trasformatore, che è strettamente correlata all'API dello stimatore discussa in un video precedente. L'API dello stimatore viene utilizzata principalmente per modelli di apprendimento supervisionato come classificatori e modelli di analisi di regressione, mentre l'API del trasformatore è progettata per le trasformazioni dei dati.
Il relatore inizia affrontando i problemi associati al sottocampionamento casuale, che implica la divisione di un set di dati in due sottoinsiemi, in genere un set di addestramento e un set di test. Spiegano che la divisione casuale del set di dati può portare a cambiamenti nella distribuzione delle etichette di classe, con conseguente rappresentazione errata delle classi sia nel set di addestramento che in quello di test. Per superare questa sfida, il relatore suggerisce di utilizzare la suddivisione stratificata, che garantisce il mantenimento della distribuzione delle classi o delle proporzioni nei sottoinsiemi. Procedono dimostrando come ottenere la suddivisione stratificata utilizzando la funzione train_test_split dal sottomodulo model_selection di scikit-learn.
Andando avanti, il presentatore approfondisce il concetto di normalizzazione dei dati, con un focus specifico su due tecniche: ridimensionamento min-max e standardizzazione. Il ridimensionamento min-max comporta il ridimensionamento di una caratteristica in modo che tutti i suoi valori rientrino nell'intervallo da 0 a 1. Il presentatore fornisce la formula per il ridimensionamento min-max, che implica la sottrazione di ogni valore nella colonna della caratteristica per il valore minimo della caratteristica e quindi la divisione dalla differenza tra i valori massimo e minimo della caratteristica.
Al contrario, la standardizzazione implica la trasformazione di una caratteristica in modo che abbia una media pari a zero e una deviazione standard pari a uno. Il presentatore spiega la formula per la standardizzazione, che consiste nel sottrarre ogni valore nella colonna delle caratteristiche per la media della caratteristica e quindi dividerlo per la deviazione standard della caratteristica. Dicono che la standardizzazione è più comunemente usata nell'apprendimento automatico ed è particolarmente utile per alcuni algoritmi di ottimizzazione.
Per illustrare l'applicazione pratica del ridimensionamento e della standardizzazione min-max, il relatore fornisce esempi utilizzando le colonne delle caratteristiche del giocattolo. Sottolineano che la scelta tra l'utilizzo della deviazione standard del campione o della popolazione non ha un impatto significativo sui risultati dell'apprendimento automatico, a condizione che le caratteristiche siano centrate e abbiano approssimativamente una varianza unitaria. Inoltre, sottolineano l'importanza di utilizzare i parametri (media e deviazione standard) calcolati dal set di addestramento per ridimensionare i set di convalida e test poiché i set di convalida e test rappresentano dati non visibili.
Il video procede esplorando varie tecniche per la trasformazione e la gestione dei dati nell'apprendimento automatico. Riconosce che per procedure semplici come la standardizzazione, è possibile eseguire le trasformazioni manualmente senza fare affidamento su librerie separate o tecniche avanzate. Tuttavia, per trasformazioni più complesse come la selezione delle funzionalità, la riduzione della dimensionalità delle funzionalità e l'estrazione delle funzionalità, l'utilizzo di strumenti come l'API Transformer può offrire maggiore praticità ed efficienza.
Successivamente, il presentatore si concentra sulla gestione dei dati categorici. Introducono un set di dati giocattolo comprendente tre colonne di caratteristiche e una colonna di etichette, sottolineando che le variabili categoriali possono essere classificate in due tipi: ordinali e nominali. Le variabili ordinali possiedono un ordine o una gerarchia specifici, mentre le variabili nominali no. A titolo illustrativo, evidenziano la colonna "taglia" come variabile ordinale, dove le taglie delle magliette come M, L e XXL mostrano un ordine chiaro. Per gestire le variabili ordinali, il video consiglia di utilizzare un dizionario di mappatura per trasformare i valori in rappresentazioni numeriche.
D'altra parte, il video presenta le etichette delle classi come esempio di dati categoriali nominali. Poiché non esiste un ordine intrinseco tra le etichette di classe, il relatore suggerisce di utilizzare il codificatore di etichette per assegnare valori interi univoci a ciascuna etichetta. Il codificatore dell'etichetta viene adattato alla colonna dell'etichetta della classe per creare un dizionario di mappatura, che viene quindi utilizzato per trasformare le etichette delle stringhe in etichette intere.
Per le colonne di caratteristiche nominali come "colore", in cui non è implicito alcun ordine, l'utilizzo del codificatore di etichette può introdurre informazioni fuorvianti. In tali casi, il video introduce la codifica one-hot come alternativa adeguata. Questa tecnica prevede la creazione di una nuova colonna delle caratteristiche per ogni valore distinto nella colonna delle caratteristiche nominali e l'assegnazione di 0 e 1 per indicare la presenza o l'assenza di un particolare valore. Si dice che l'eliminazione di una delle colonne delle caratteristiche risultanti può eliminare la ridondanza senza perdere informazioni essenziali.
Il video tocca brevemente i dati mancanti e propone alcuni approcci di base per gestirli. Una strategia prevede l'eliminazione di righe o colonne contenenti valori mancanti se si verificano in modo casuale e non sono indicativi di un problema sistematico. Ciò può essere ottenuto utilizzando il metodo dropna() nella libreria pandas. Un altro approccio consiste nell'imputare i dati mancanti colmando le lacune con misure statistiche come la media o la mediana, utilizzando strumenti come il trasformatore SimpleImputer. Tuttavia, il video avverte che l'imputazione dovrebbe essere attentamente considerata, in quanto potrebbe introdurre pregiudizi involontari.
Inoltre, il video menziona la possibilità di prevedere i valori mancanti trattando il problema come un compito di apprendimento supervisionato. In questo scenario, la colonna della caratteristica mancante può essere considerata la variabile di destinazione e le righe senza dati mancanti possono essere utilizzate come dati di addestramento per adattare un modello di regressione.
Il video fornisce una panoramica completa delle tecniche di trasformazione dei dati, compresa l'importanza di preparare un set di dati di addestramento, l'applicazione della suddivisione stratificata e la normalizzazione dei dati utilizzando il ridimensionamento e la standardizzazione min-max. Copre inoltre la gestione dei dati categorici, la distinzione tra variabili ordinali e nominali e introduce tecniche come dizionari di mappatura, codificatori di etichette e codifica one-hot. Inoltre, il video affronta brevemente i dati mancanti e delinea approcci come l'eliminazione o l'imputazione di valori mancanti, menzionando anche la possibilità di prevedere i valori mancanti attraverso l'apprendimento supervisionato.