Learn AI with Python · Leçon

Stocker et interroger les résultats de l’apprentissage automatique

Conserver les prédictions des modèles, les journaux d’expériences et les données de caractéristiques dans des bases relationnelles.

Stocker et interroger les résultats de l’apprentissage automatique est une leçon Learn AI with Python gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Learn AI with Python, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Learn AI with Python comprend 4 leçons au total.

Suivre les expériences de ML

Lorsque vous entraînez des modèles, vous produisez des dizaines d’exécutions avec des réglages et des scores différents. Sans suivi, vous perdez la trace de la configuration la plus performante.

Une petite base de données d’expériences enregistre chaque exécution afin que vous puissiez les interroger, les comparer et reproduire la meilleure.

Concevoir une table d’expériences

Un bon schéma contient l’identité de l’exécution, le modèle, les hyperparamètres importants, la métrique et un horodatage. Stockez les hyperparamètres flexibles dans une colonne de texte 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()

Pourquoi un horodatage et un ID

L’id auto-incrémenté fournit à chaque exécution une référence stable, tandis que created_at vous permet de classer les exécutions dans le temps ou de trouver la plus récente.

Le DEFAULT (datetime("now")) remplit automatiquement l’horodatage lors de l’insertion.

Consigner une exécution

Après l’entraînement, insérez les résultats. Sérialisez le dictionnaire des hyperparamètres en JSON afin que le schéma reste flexible d’un modèle à l’autre.

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()

Une fonction auxiliaire log_run réutilisable

Regroupez l’insertion dans une fonction que vous appelez à la fin de chaque script d’entraînement. Une consignation cohérente permet ensuite de comparer les exécutions.

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()

Sélectionner les meilleures exécutions

Trouvez vos meilleurs modèles en classant les résultats selon la métrique. ORDER BY accuracy DESC avec LIMIT renvoie les meilleurs résultats.

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

Filtrer par modèle ou par seuil

Réduisez les comparaisons avec WHERE : une seule famille de modèles, ou uniquement les exécutions dépassant un score cible.

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

Agréger les résultats des exécutions

Les agrégats SQL résument de nombreuses exécutions à la fois : meilleur résultat, moyenne et nombre d’exécutions pour chaque modèle avec 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())

Charger les résultats dans pandas

Pour une comparaison plus riche, importez la table dans un DataFrame et analysez-la avec pandas : triez, créez des tableaux croisés et représentez les données graphiquement.

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())

Comparer les expériences dans pandas

Développez les paramètres JSON en colonnes afin de mettre en évidence la corrélation entre les hyperparamètres et la métrique — c’est exactement ce qui guide votre prochaine expérience.

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())

Reproduire la meilleure exécution

Puisque chaque exécution a enregistré ses hyperparamètres, reproduire le meilleur modèle consiste simplement à lire sa ligne et à le réinstancier avec ces paramètres.

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

Vérification rapide : meilleures exécutions

Vous voulez obtenir les cinq exécutions affichant la meilleure précision dans la table.

Récapitulatif : stockage et interrogation des résultats ML

Vous avez construit un flux de suivi des expériences :

Une table runs contenant le modèle, les paramètres JSON, les métriques et l’horodatage
Une fonction auxiliaire log_run pour enregistrer chaque exécution d’entraînement
ORDER BY ... DESC LIMIT pour trouver les meilleures exécutions, et WHERE pour filtrer
Les agrégations avec GROUP BY et pandas pour approfondir la comparaison
Le stockage des paramètres rend le meilleur résultat reproductible

Ensuite : les bases de données vectorielles pour la recherche de représentations vectorielles.

Questions Fréquemment Posées

La leçon « Stocker et interroger les résultats de l’apprentissage automatique » est-elle gratuite ?

Oui — le texte complet de « Stocker et interroger les résultats de l’apprentissage automatique » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Learn AI with Python, passe à CoddyKit PRO. Le cours Learn AI with Python comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Stocker et interroger les résultats de l’apprentissage automatique » ?

Conserver les prédictions des modèles, les journaux d’expériences et les données de caractéristiques dans des bases relationnelles. Tu pratiques Learn AI with Python avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Learn AI with Python ?

Aucune expérience préalable n'est requise. Learn AI with Python sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Stocker et interroger les résultats de l’apprentissage automatique » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Learn AI with Python ?

Oui. Chaque leçon Learn AI with Python inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

SQLite avec le module sqlite3 de Python
Intégration de Pandas et SQL
Stocker et interroger les résultats de l’apprentissage automatique
Introduction aux bases de données vectorielles

← Retour à Learn AI with Python