Learn AI with Python · Lezione

Archiviazione e interrogazione dei risultati del machine learning

Persistenza delle predizioni dei modelli, dei log degli esperimenti e dei dati delle feature nei database relazionali.

Archiviazione e interrogazione dei risultati del machine learning è una lezione Learn AI with Python gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Learn AI with Python, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Learn AI with Python include 4 lezioni in totale.

Tracciare gli esperimenti di ML

Durante l'addestramento dei modelli si producono decine di esecuzioni con impostazioni e punteggi diversi. Senza un sistema di tracciamento, si perde l'informazione su quale configurazione abbia funzionato meglio.

Un piccolo database degli esperimenti registra ogni esecuzione, così può eseguire query, fare confronti e riprodurre quella migliore.

Progettare una tabella degli esperimenti

Uno schema valido registra l'identità dell'esecuzione, il modello, gli iperparametri principali, la metrica e un timestamp. Memorizzi gli iperparametri flessibili in una colonna di testo JSON.

import sqlite3

conn = sqlite3.connect("experiments.db")
conn.execute("""
CREATE TABLE IF NOT EXISTS runs (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    model TEXT NOT NULL,
    params TEXT,
    accuracy REAL,
    f1 REAL,
    created_at TEXT DEFAULT (datetime("now"))
)
""")
conn.commit()

Perché servono un timestamp e un ID

L'id con incremento automatico fornisce a ogni esecuzione un riferimento stabile, mentre created_at consente di ordinare le esecuzioni nel tempo o trovare quella più recente.

DEFAULT (datetime("now")) compila automaticamente il timestamp durante l'inserimento.

Registrare un'esecuzione

Dopo l'addestramento, inserisca i risultati. Serializzi il dizionario degli iperparametri in JSON, così lo schema rimane flessibile tra modelli diversi.

import json, sqlite3

params = {"n_estimators": 200, "max_depth": 8}
conn.execute(
    "INSERT INTO runs (model, params, accuracy, f1) VALUES (?, ?, ?, ?)",
    ("random_forest", json.dumps(params), 0.913, 0.902),
)
conn.commit()

Un helper log_run riutilizzabile

Raccolga l'inserimento in una funzione da chiamare al termine di ogni script di addestramento. La registrazione coerente è ciò che rende possibili i confronti successivi.

def log_run(conn, model, params, accuracy, f1):
    conn.execute(
        "INSERT INTO runs (model, params, accuracy, f1) VALUES (?, ?, ?, ?)",
        (model, json.dumps(params), accuracy, f1),
    )
    conn.commit()

Selezionare le esecuzioni migliori

Trovi i modelli migliori ordinandoli in base alla metrica. ORDER BY accuracy DESC insieme a LIMIT restituisce i primi risultati.

cur = conn.execute(
    "SELECT model, accuracy, f1 FROM runs ORDER BY accuracy DESC LIMIT 5"
)
for row in cur.fetchall():
    print(row)

Filtrare per modello o soglia

Restringa i confronti con WHERE: solo una famiglia di modelli oppure solo le esecuzioni al di sopra di un punteggio obiettivo.

cur = conn.execute(
    "SELECT model, accuracy FROM runs WHERE model = ? AND accuracy > ? ORDER BY accuracy DESC",
    ("random_forest", 0.90),
)
print(cur.fetchall())

Aggregare più esecuzioni

Le funzioni di aggregazione SQL riassumono molte esecuzioni in una volta sola: il valore migliore, la media e il conteggio per modello con GROUP BY.

cur = conn.execute("""
SELECT model,
       COUNT(*) AS n,
       MAX(accuracy) AS best,
       AVG(accuracy) AS mean
FROM runs
GROUP BY model
ORDER BY best DESC
""")
print(cur.fetchall())

Caricare i risultati in pandas

Per un confronto più approfondito, carichi la tabella in un DataFrame e la analizzi con pandas: ordini, crei pivot e grafici.

import pandas as pd
from sqlalchemy import create_engine

engine = create_engine("sqlite:///experiments.db")
df = pd.read_sql("SELECT * FROM runs", engine)
print(df.sort_values("accuracy", ascending=False).head())

Confrontare gli esperimenti in pandas

Espanda i parametri JSON in colonne per correlare gli iperparametri con la metrica: è proprio ciò che guiderà il prossimo esperimento.

import json, pandas as pd

params_df = df["params"].apply(json.loads).apply(pd.Series)
full = pd.concat([df, params_df], axis=1)
print(full.groupby("max_depth")["accuracy"].mean())

Riprodurre il modello migliore

Poiché ogni esecuzione ha memorizzato i propri iperparametri, riprodurre il modello migliore significa semplicemente leggere la sua riga e ricrearlo con quei parametri.

best = df.sort_values("accuracy", ascending=False).iloc[0]
import json
best_params = json.loads(best["params"])
print("Reproduce", best["model"], "with", best_params)

Verifica rapida: esecuzioni migliori

Vuole ottenere dalla tabella le cinque esecuzioni con la precisione più alta.

Riepilogo: memorizzazione e interrogazione dei risultati ML

Ha creato un flusso di lavoro per il tracciamento degli esperimenti:

Una tabella runs con modello, parametri JSON, metriche e timestamp
Un helper log_run per registrare ogni esecuzione di addestramento
ORDER BY ... DESC LIMIT per trovare le esecuzioni migliori e WHERE per filtrare
Aggregazioni con GROUP BY e pandas per un confronto più approfondito
I parametri memorizzati rendono riproducibile il risultato vincente

Prossimo argomento: database vettoriali per la ricerca tramite embedding.

Domande Frequenti

La lezione «Archiviazione e interrogazione dei risultati del machine learning» è gratuita?

Sì — il testo completo di «Archiviazione e interrogazione dei risultati del machine learning» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Learn AI with Python, passa a CoddyKit PRO. Il corso Learn AI with Python include 4 lezioni in totale.

Cosa imparerò in «Archiviazione e interrogazione dei risultati del machine learning»?

Persistenza delle predizioni dei modelli, dei log degli esperimenti e dei dati delle feature nei database relazionali. Eserciti Learn AI with Python con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Learn AI with Python?

Non è richiesta alcuna esperienza precedente. Learn AI with Python su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Archiviazione e interrogazione dei risultati del machine learning»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Learn AI with Python?

Sì. Ogni lezione Learn AI with Python include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

SQLite con il modulo sqlite3 di Python
Integrazione tra Pandas e SQL
Archiviazione e interrogazione dei risultati del machine learning
Introduzione ai database vettoriali

← Torna a Learn AI with Python