Learn AI with Python · Lekcja

Przechowywanie i odpytywanie wyników ML

Utrwalanie predykcji modeli, dzienników eksperymentów i danych cech w relacyjnych bazach danych.

Przechowywanie i odpytywanie wyników ML to bezpłatna lekcja Learn AI with Python na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Learn AI with Python, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Learn AI with Python zawiera 4 lekcji w sumie.

Śledzenie eksperymentów ML

Podczas trenowania modeli powstają dziesiątki uruchomień z różnymi ustawieniami i wynikami. Bez śledzenia trudno ustalić, która konfiguracja działała najlepiej.

Niewielka baza danych eksperymentów rejestruje każde uruchomienie, dzięki czemu można wyszukiwać, porównywać i odtwarzać najlepsze wyniki.

Projektowanie tabeli eksperymentów

Dobry schemat przechowuje identyfikator uruchomienia, model, najważniejsze hiperparametry, metrykę i znacznik czasu. Elastyczne hiperparametry warto przechowywać w kolumnie tekstowej w formacie 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()

Dlaczego znacznik czasu i identyfikator?

Automatycznie zwiększany id zapewnia każdemu uruchomieniu stabilny identyfikator, a created_at pozwala uporządkować uruchomienia w czasie lub znaleźć najnowsze.

DEFAULT (datetime("now")) automatycznie wypełnia znacznik czasu podczas wstawiania rekordu.

Rejestrowanie uruchomienia

Po zakończeniu trenowania należy wstawić wyniki. Słownik hiperparametrów należy przekształcić do formatu JSON, aby schemat pozostał elastyczny dla różnych modeli.

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

Wielokrotnego użytku funkcja log_run

Należy umieścić operację wstawiania w funkcji wywoływanej na końcu każdego skryptu treningowego. Spójne rejestrowanie umożliwia późniejsze porównywanie wyników.

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

Wybieranie najlepszych uruchomień

Najlepsze modele można znaleźć, sortując według metryki. ORDER BY accuracy DESC wraz z LIMIT zwraca liderów.

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

Filtrowanie według modelu lub progu

Porównania można zawężać za pomocą WHERE: do jednej rodziny modeli albo tylko do uruchomień powyżej określonego wyniku.

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

Agregowanie wyników uruchomień

Agregacje SQL podsumowują wiele uruchomień jednocześnie: najlepszy wynik, średnią i liczbę uruchomień dla każdego modelu za pomocą 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())

Wczytywanie wyników do pandas

Aby przeprowadzić dokładniejsze porównanie, należy wczytać tabelę do obiektu DataFrame i przeanalizować ją za pomocą pandas — posortować, przekształcić tabelę przestawną i utworzyć wykres.

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

Porównywanie eksperymentów w pandas

Należy rozwinąć parametry JSON do osobnych kolumn, aby zbadać zależność hiperparametrów od metryki — dokładnie te informacje pomagają zaplanować następny eksperyment.

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

Odtwarzanie najlepszego modelu

Ponieważ hiperparametry każdego uruchomienia zostały zapisane, odtworzenie najlepszego modelu polega tylko na odczytaniu jego wiersza i ponownym utworzeniu modelu z użyciem tych parametrów.

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

Szybkie sprawdzenie: najlepsze przebiegi

Chcą Państwo znaleźć pięć przebiegów o najwyższej dokładności z tabeli.

Podsumowanie: przechowywanie i odpytywanie wyników ML

Zbudowali Państwo potok śledzenia eksperymentów:

Tabela runs zawierająca model, parametry JSON, metryki i znacznik czasu
Pomocnicza funkcja log_run rejestrująca każdy przebieg trenowania
ORDER BY ... DESC LIMIT do znajdowania najlepszych przebiegów oraz WHERE do filtrowania
Agregacje za pomocą GROUP BY i biblioteka pandas do dokładniejszego porównania
Przechowywane parametry umożliwiają odtworzenie najlepszego wyniku

Dalej: wektorowe bazy danych do wyszukiwania za pomocą embeddingów.

Często zadawane pytania

Czy lekcja „Przechowywanie i odpytywanie wyników ML” jest bezpłatna?

Tak — pełny tekst „Przechowywanie i odpytywanie wyników ML” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Learn AI with Python, przejdź na CoddyKit PRO. Kurs Learn AI with Python zawiera 4 lekcji w sumie.

Co nauczysz się w „Przechowywanie i odpytywanie wyników ML”?

Utrwalanie predykcji modeli, dzienników eksperymentów i danych cech w relacyjnych bazach danych. Ćwiczysz Learn AI with Python z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Learn AI with Python?

Nie wymagamy żadnego doświadczenia. Learn AI with Python w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „Przechowywanie i odpytywanie wyników ML”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Learn AI with Python?

Tak. Każda lekcja Learn AI with Python zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Learn AI with Python