Machine Learning con Python: Crea il Tuo Primo Modello in 10 Minuti

Introduzione

Il Machine Learning è una branca dell'intelligenza artificiale che permette ai computer di imparare dai dati e fare previsioni o prendere decisioni senza essere programmati in modo esplicito per ogni compito. Oggi ti guiderò passo passo nella creazione del tuo primo modello di Machine Learning utilizzando Python e alcune librerie potenti come scikit-learn e pandas. Questo tutorial è pensato per essere semplice e pratico, adatto ai principianti. Entro 10 minuti, sarai in grado di creare il tuo primo modello di previsione!

Cosa Ti Serve per Iniziare

Per seguire questo tutorial, avrai bisogno di alcune basi di Python e di installare alcune librerie fondamentali. Se non le hai già, puoi installarle facilmente con pip, il gestore di pacchetti di Python. Apri il terminale o il prompt dei comandi e inserisci i seguenti comandi:

pip install pandas scikit-learn matplotlib

Queste librerie ti permetteranno di lavorare con dati, creare il tuo modello di Machine Learning e visualizzare i risultati. Pandas è una libreria per la manipolazione dei dati, scikit-learn contiene molti algoritmi di Machine Learning pronti all'uso, e matplotlib ti permetterà di creare grafici.

1. Caricare e Esplorare i Dati

Prima di creare il modello, è importante avere dei dati su cui lavorare. Per questo tutorial, utilizzeremo un dataset predefinito incluso in scikit-learn: il dataset dei fiori iris, che contiene informazioni su diverse specie di fiori con le loro caratteristiche (ad esempio, lunghezza e larghezza dei petali) e la specie corrispondente. Il nostro obiettivo sarà prevedere la specie di un fiore in base alle sue caratteristiche.

Per prima cosa, carichiamo i dati e diamo un'occhiata veloce per capire cosa contengono. Aggiungi questo codice al tuo file Python:

import pandas as pd
from sklearn.datasets import load_iris

# Carica il dataset Iris
iris = load_iris()
# Creare un DataFrame per visualizzare i dati in modo chiaro
df = pd.DataFrame(data=iris.data, columns=iris.feature_names)

# Aggiungiamo la colonna della specie (target)
df['species'] = iris.target

# Mostra le prime righe del dataset
print(df.head())

Questo codice carica il dataset Iris e lo trasforma in un DataFrame di pandas, che rende facile visualizzare e manipolare i dati. La funzione print(df.head()) mostrerà le prime cinque righe del dataset, permettendoti di vedere le varie caratteristiche (come lunghezza e larghezza dei petali) e la specie del fiore.

Descrizione del Dataset

sepal length (cm): Lunghezza del sepalo in centimetri
sepal width (cm): Larghezza del sepalo in centimetri
petal length (cm): Lunghezza del petalo in centimetri
petal width (cm): Larghezza del petalo in centimetri
species: La specie del fiore, rappresentata con numeri (0, 1, 2)

2. Dividere i Dati in Addestramento e Test

Nel Machine Learning, è importante dividere i dati in due gruppi: i dati di addestramento e quelli di test. Il modello impara dai dati di addestramento, e successivamente valutiamo quanto è preciso utilizzando i dati di test (dati che non ha mai visto prima). Scikit-learn ci offre una funzione chiamata train_test_split per fare questo in modo automatico. Aggiungi questo codice al tuo file:

from sklearn.model_selection import train_test_split

# Dividiamo i dati in X (caratteristiche) e y (target/specie)
X = iris.data
y = iris.target

# Dividiamo in 80% per l'addestramento e 20% per il test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

print(f"Numero di dati di addestramento: {len(X_train)}")
print(f"Numero di dati di test: {len(X_test)}")

Questo codice divide i dati in modo che l'80% venga utilizzato per addestrare il modello e il restante 20% per testare la sua accuratezza. Impostiamo random_state=42 per garantire che i risultati siano riproducibili (ciò significa che ogni volta che esegui il codice, otterrai lo stesso set di addestramento e test).

3. Creare un Modello di Machine Learning

Ora che abbiamo diviso i dati, è il momento di creare il nostro modello di Machine Learning! Utilizzeremo un algoritmo molto popolare chiamato k-Nearest Neighbors (k-NN), che classifica un nuovo dato in base ai dati più vicini nel set di addestramento. È un algoritmo semplice ma potente, perfetto per iniziare.

Aggiungi questo codice per creare e addestrare il modello:

from sklearn.neighbors import KNeighborsClassifier

# Creiamo il modello k-NN con k=3
model = KNeighborsClassifier(n_neighbors=3)

# Addestriamo il modello sui dati di addestramento
model.fit(X_train, y_train)

# Facciamo previsioni sui dati di test
y_pred = model.predict(X_test)

# Mostriamo alcune previsioni
print("Previsioni per i dati di test:", y_pred)
print("Valori reali delle specie:", y_test)

In questo codice, creiamo un modello k-NN con 3 vicini (n_neighbors=3), che significa che ogni volta che il modello deve fare una previsione, considera i tre dati più vicini e decide quale specie assegnare in base alla maggioranza. Una volta addestrato il modello sui dati di addestramento, usiamo i dati di test per verificare le previsioni.

4. Valutare il Modello

Ora che il modello ha fatto delle previsioni, dobbiamo valutare quanto è stato accurato. Usiamo la matrice di confusione e la precisione per misurare l'efficacia del modello. La precisione indica la percentuale di previsioni corrette, mentre la matrice di confusione mostra il confronto tra le previsioni corrette e quelle sbagliate.

from sklearn.metrics import accuracy_score, confusion_matrix

# Calcoliamo la precisione del modello
accuracy = accuracy_score(y_test, y_pred)
print(f"Precisione del modello: {accuracy * 100:.2f}%")

# Mostriamo la matrice di confusione
conf_matrix = confusion_matrix(y_test, y_pred)
print("Matrice di confusione:")
print(conf_matrix)

Questo codice calcola la precisione del modello e stampa la matrice di confusione, che ci aiuta a capire quali specie il modello ha classificato correttamente e quali ha confuso. Se ottieni una precisione superiore al 90%, significa che il modello ha fatto un ottimo lavoro!

5. Visualizzare i Risultati

Infine, possiamo visualizzare i risultati del nostro modello con un grafico. Usiamo matplotlib per creare una visualizzazione semplice che mostri le differenze tra le specie previste e quelle reali.

import matplotlib.pyplot as plt
import numpy as np

# Creiamo una mappa dei colori per le specie
species_colors = np.array(['red', 'green', 'blue'])

# Visualizziamo i primi 20 dati di test e le loro previsioni
plt.scatter(range(20), y_test[:20], color=species_colors[y_test[:20]], label="Valori Reali")
plt.scatter(range(20), y_pred[:20], color=species_colors[y_pred[:20]], marker="x", label="Previsioni")

plt.title("Confronto tra Previsioni e Valori Reali")
plt.xlabel("Indice dei Dati di Test")
plt.ylabel("Specie")
plt.legend()
plt.show()

Questo grafico visualizza le specie reali e quelle previste per i primi 20 campioni di dati di test. Ogni punto rappresenta un campione, e se le previsioni sono corrette, vedrai le X e i cerchi allineati (ovvero i valori reali e quelli previsti saranno uguali).

Conclusione

Congratulazioni! In meno di 10 minuti, hai caricato un dataset, diviso i dati in set di addestramento e test, creato un modello di Machine Learning e lo hai valutato. Il Machine Learning può sembrare complicato all'inizio, ma seguendo questi passaggi, puoi iniziare a creare i tuoi modelli e imparare man mano. Con Python e librerie come scikit-learn, hai tutto ciò che ti serve per sviluppare modelli sempre più complessi e accurati.