MLflow - śledzenie eksperymentów

Trzy lekcje temu wytrenowałeś las losowy w scikit-learn, potem karawanę drzew w XGBoost, a na końcu sieć neuronową w PyTorch. Za każdym razem zmieniałeś coś drobnego: raz głębokość drzewa, raz liczbę estymatorów, raz szybkość uczenia. Za każdym razem patrzyłeś na wypisaną trafność i mówiłeś sobie "o, teraz lepiej". A teraz odpowiedz mi bez zaglądania nigdzie, @name: który dokładnie zestaw ustawień dał ten najlepszy wynik? I gdzie leży plik z tamtym modelem?

Znam tę ciszę. Widziałem ją w niejednym obozie badawczym: dwudziestu tropicieli wraca z sawanny, każdy z garścią pomiarów zapisanych na skrawku papieru albo w pamięci, a wieczorem przy ognisku okazuje się, że nikt nie potrafi powtórzyć obserwacji, która wydawała się najciekawsza. Notatka się rozmokła, karta wypadła z kieszeni, a autor pamięta tylko, że "zwierzę było duże". W uczeniu maszynowym rolę rozmokłej kartki gra komórka notatnika, którą nadpisałeś, i zmienna, którą przypisałeś ponownie.

Ta lekcja jest o prowadzeniu dziennika ekspedycji, którego nie da się zgubić. Poznasz MLflow - narzędzie, które przy każdym treningu zapisuje w jednym miejscu trzy rzeczy: parametry, z jakimi model powstał, metryki, jakie osiągnął, oraz sam model jako plik gotowy do wczytania. Zobaczysz, jak zalogować pierwszy eksperyment, jak obejrzeć wyniki w przeglądarce, jak zlecić logowanie automatowi i jak z dwudziestu prób wyłuskać zwycięzcę jedną komendą.

Notes, którego nikt nie prowadzi

Zanim sięgniemy po narzędzie, zobaczmy, jak wygląda śledzenie eksperymentów zrobione ręcznie. Prawie każdy przechodzi przez ten etap: zakładasz zwykłą listę, po każdym treningu dopisujesz do niej słownik z ustawieniami i wynikiem, a na koniec wybierasz najlepszy wpis wbudowaną funkcją

max

key

accuracy

1# reczne sledzenie eksperymentow: lista slownikow
2wyniki = []
3
4wyniki.append({"n_estimators": 100, "max_depth": 10, "accuracy": 0.973})
5wyniki.append({"n_estimators": 300, "max_depth": 6, "accuracy": 0.981})
6
7print(max(wyniki, key=lambda r: r["accuracy"]))
8# {'n_estimators': 300, 'max_depth': 6, 'accuracy': 0.981}

Funkcja

max

Czym MLflow jest, a czym nie jest

MLflow to platforma do śledzenia eksperymentów uczenia maszynowego: zapisuje parametry, metryki i modele. To jedno zdanie jest odpowiedzią na pytanie, po co w ogóle instaluje się to narzędzie, i warto je zapamiętać w takiej właśnie formie - parametry, metryki, modele. Wszystko inne, co MLflow potrafi, wyrasta z tej trójki.

Odsuńmy od razu trzy nieporozumienia, bo krążą wokół tej nazwy uparcie. Po pierwsze, MLflow nie służy tylko do trenowania modeli - on w ogóle nie trenuje. Nie ma w nim ani jednego algorytmu uczącego. Trening dalej robi scikit-learn, XGBoost albo PyTorch, dokładnie tak jak w poprzednich lekcjach, a MLflow stoi obok z notesem i zapisuje, co się wydarzyło. Gdybyś usunął go z projektu, modele powstawałyby dokładnie takie same, tylko nikt by nie zapisał, jak powstały.

Po drugie, MLflow nie służy do tworzenia interfejsów użytkownika. To nieporozumienie jest podstępne, bo za chwilę uruchomimy interfejs webowy MLflow i zobaczysz w przeglądarce tabelę z wynikami. Ten interfejs jest jednak gotowy i niezmienny: to przeglądarka Twoich eksperymentów, a nie narzędzie, którym zbudujesz ekran dla użytkownika swojej aplikacji. Do budowania własnych interfejsów służą zupełnie inne biblioteki, na przykład Streamlit czy Gradio po stronie Pythona.

Po trzecie, MLflow nie służy do pisania testów jednostkowych. Testy jednostkowe sprawdzają, czy funkcja zwraca to, co powinna, i piszesz je w

pytest

unittest

Instalacja i cztery pojęcia na start

MLflow instalujesz jednym poleceniem menedżera pakietów, tak samo jak wcześniej Pandas czy XGBoost. Pakiet jest spory, bo w środku siedzi serwer webowy i baza danych, więc instalacja potrwa dłużej niż zwykle - to normalne.

1pip install mlflow

Po instalacji masz dwie rzeczy naraz: bibliotekę, którą zaimportujesz w kodzie, oraz program uruchamiany z terminala poleceniem

mlflow

Zanim napiszemy pierwszą linię, cztery słowa, które będą wracać do końca lekcji. Run to jedno uruchomienie treningu: jeden komplet parametrów, jeden komplet metryk, jeden model. Eksperyment to nazwany zbiór runów dotyczących tego samego problemu, na przykład wszystkie próby rozpoznawania gatunków. Parametr to liczba lub napis, które ustawiłeś przed treningiem i które opisują konfigurację. Metryka to liczba, która wyszła z treningu i którą mierzysz jakość. Ta różnica między parametrem a metryką nie jest kosmetyczna: MLflow traktuje je inaczej, o czym przekonasz się w sekcji o porównywaniu runów.

Notes terenowy na tę lekcję

Potrzebujemy czegoś do trenowania, ale skromnie - bohaterem tej lekcji jest dziennik, a nie dane. Zbierzemy trzysta okazów trzech gatunków, każdy opisany dwoma pomiarami: masą w kilogramach i prędkością w kilometrach na godzinę. Generator

np.random.default_rng

train_test_split

stratify=y

random_state=42

normal

size=(100, 2)

1import numpy as np
2from sklearn.model_selection import train_test_split
3
4rng = np.random.default_rng(7)
5
6# kazdy gatunek: 100 okazow, kolumny to masa [kg] i predkosc [km/h]
7lew = rng.normal([190, 58], [30, 8], size=(100, 2))
8gepard = rng.normal([55, 110], [10, 12], size=(100, 2))
9hiena = rng.normal([60, 65], [12, 9], size=(100, 2))
10
11X = np.vstack([lew, gepard, hiena])
12y = np.repeat([0, 1, 2], 100)          # 0 = lew, 1 = gepard, 2 = hiena
13
14X_train, X_test, y_train, y_test = train_test_split(
15    X, y, test_size=0.2, random_state=42, stratify=y
16)
17
18print(X_train.shape, X_test.shape)     # (240, 2) (60, 2)

Dwieście czterdzieści zwierząt idzie na trening, sześćdziesiąt czeka na egzamin. Funkcja

np.vstack

np.repeat

Pierwszy run: eksperyment i parametr

Zaczynamy prowadzić dziennik. Trzy wywołania wystarczą na początek. Funkcja

mlflow.set_experiment

mlflow.start_run

with

run_name

mlflow.log_param

1import mlflow
2
3mlflow.set_experiment("safari-proby")
4
5with mlflow.start_run(run_name="las_losowy_v1"):
6    mlflow.log_param("n_estimators", 100)
7    mlflow.log_param("max_depth", 10)
8
9    print(mlflow.active_run().info.run_id)

Po wyjściu z bloku

with

mlruns

Przyjrzyjmy się jeszcze samemu wywołaniu logującemu parametr, bo jego kolejność bywa myląca. Czytane element po elemencie to:

mlflow

.

log_param

(

"n_estimators", 100

)

mlflow.log_param(100, "n_estimators")

'n_estimators'

"n_estimators"

Skoro jesteśmy przy

with

mlflow.start_run()

with

mlflow.end_run()

with

with

with

end_run

Metryka to wynik, parametr to decyzja

Parametry mamy zapisane, ale dziennik bez wyników jest tylko listą życzeń. Do zapisania wyniku służy

mlflow.log_metric

log_param

Wytrenujmy więc las losowy, którego składnię znasz z lekcji o scikit-learn, i zapiszmy jego trafność. Metrykę

accuracy_score

1from sklearn.ensemble import RandomForestClassifier
2from sklearn.metrics import accuracy_score
3
4with mlflow.start_run(run_name="las_losowy_v2"):
5    mlflow.log_param("n_estimators", 100)
6    mlflow.log_param("max_depth", 10)
7
8    model = RandomForestClassifier(
9        n_estimators=100, max_depth=10, random_state=42
10    )
11    model.fit(X_train, y_train)
12
13    trafnosc = accuracy_score(y_test, model.predict(X_test))
14    mlflow.log_metric("accuracy", trafnosc)

Trafność wypadnie w okolicach 98 procent - nie podaję dokładnej liczby w komentarzu, bo zależy ona od wersji scikit-learn, więc uruchom kod i sprawdź u siebie. Ważniejsze jest co innego: zauważ, że trening wygląda dokładnie tak samo jak w lekcji o scikit-learn. Ta sama klasa, te same hiperparametry, ta sama metoda

fit

log_param

Model to też wynik, który warto zapisać

Zostaje trzeci element obiecanej trójki. Model jest obiektem Pythona, więc nie zmieści się ani w parametrze, ani w metryce - do jego zapisania MLflow ma osobne funkcje, po jednej dla każdej biblioteki. Ten podział nazywa się flavor, czyli smak:

mlflow.sklearn

mlflow.xgboost

mlflow.pytorch

mlflow

log_model

1import mlflow.sklearn
2
3with mlflow.start_run(run_name="las_losowy_v3"):
4    model = RandomForestClassifier(n_estimators=100, random_state=42)
5    model.fit(X_train, y_train)
6
7    mlflow.sklearn.log_model(model, "model")

Po tym wywołaniu w katalogu

mlruns

artifact_path

name

model

predict

log_model

Modelem nie kończy się lista rzeczy wartych zachowania. Do runu można dołączyć dowolny plik - wykres ważności cech, plik CSV z pomyłkami, tekstową notatkę - i służy do tego

mlflow.log_artifact

Kompletny run od początku do końca

Zbierzmy teraz wszystko w jeden przepis, bo dokładnie w takiej postaci będziesz go używał w praktyce. Ten fragment jest wart zapamiętania jako szkielet: otwierasz run, logujesz decyzje, trenujesz, mierzysz, logujesz wyniki i zapisujesz model. Nowość jest jedna - funkcja

mlflow.log_params

**

1import mlflow
2import mlflow.sklearn
3from sklearn.ensemble import RandomForestClassifier
4from sklearn.metrics import accuracy_score
5
6parametry = {"n_estimators": 200, "max_depth": 8, "random_state": 42}
7
8mlflow.set_experiment("safari-klasyfikacja")
9
10with mlflow.start_run(run_name="las_losowy_finalny"):
11    mlflow.log_params(parametry)
12    mlflow.log_param("liczba_okazow_treningowych", len(X_train))
13
14    model = RandomForestClassifier(**parametry)
15    model.fit(X_train, y_train)
16
17    trafnosc = accuracy_score(y_test, model.predict(X_test))
18    mlflow.log_metric("accuracy", trafnosc)
19
20    mlflow.sklearn.log_model(model, "model")

To jest komplet: parametry, metryka i model w jednym runie, czyli dokładnie ta trójka, od której zaczęliśmy lekcję. Zwróć uwagę, że wywołanie

set_experiment

parametry

with

mlflow ui - przeglądarka Twoich eksperymentów

Dziennik istnieje, ale jak dotąd oglądasz go tylko przez dziurkę od klucza, czyli przez wydruki w terminalu. Pora otworzyć obozową mapę. Interfejs webowy MLflow uruchamiasz poleceniem

mlflow ui

mlruns

1mlflow ui
2mlflow ui --port 5000

Obie linie robią to samo, bo 5000 to port domyślny - drugą wersję pokazuję po to, żebyś wiedział, czym go zmienić, gdy port będzie zajęty przez inny program. Po uruchomieniu wejdź w przeglądarce pod adres wypisany w terminalu i zobaczysz tabelę runów: nazwa, czas, parametry i metryki w kolumnach. Możesz sortować po metryce, zaznaczyć kilka runów i porównać je na wykresie. Serwer działa, dopóki go nie zatrzymasz, a przerwanie go skrótem klawiszowym niczego nie kasuje - dane siedzą w

mlruns

Trzy inne polecenia, które ludzie próbują wpisać w tym miejscu, nie zadziałają, i warto wiedzieć dlaczego.

python mlflow.py

mlflow.py

import mlflow

mlflow start

mlflow

start

ui

server

run

models

run mlflow

mlflow run

Autolog - kiedy nie chce się pisać log_param

Wróćmy do tej niezręczności z powtarzaniem liczb w dwóch miejscach. Model scikit-learn przecież zna swoje ustawienia - siedzą w nim jako atrybuty - więc przepisywanie ich ręcznie do dziennika jest pracą, którą powinna wykonać maszyna. I wykonuje. Wywołanie

mlflow.sklearn.autolog()

log_param

1import mlflow
2import mlflow.sklearn
3from sklearn.ensemble import RandomForestClassifier
4
5mlflow.sklearn.autolog()
6
7with mlflow.start_run(run_name="las_losowy_auto"):
8    model = RandomForestClassifier(n_estimators=150, max_depth=12)
9    model.fit(X_train, y_train)

W tym runie nie ma ani jednego jawnego wywołania logującego, a mimo to w dzienniku znajdziesz komplet hiperparametrów lasu, metryki policzone na zbiorze treningowym i zapisany model. Mechanizm jest prosty: autolog podmienia metodę

fit

fit

Skoro mowa o granicach tego mechanizmu, wyjaśnijmy, czego on nie robi. Autolog nie czyści danych: brakujące pomiary i błędne wpisy zostaną w tabeli dokładnie tam, gdzie były, a od porządków są metody Pandas, które poznałeś przy notesie terenowym. Autolog nie trenuje modeli - gdybyś usunął linię z

fit

Odpowiedniki dla innych bibliotek nazywają się przewidywalnie:

mlflow.xgboost.autolog()

mlflow.pytorch.autolog()

mlflow.autolog()

Porównywanie runów bez klikania

Interfejs webowy jest wygodny do oglądania, ale gdy runów jest sto pięćdziesiąt, chcesz zadać pytanie kodem, a nie oczami. Do tego służy

mlflow.search_runs

mlflow.get_experiment_by_name

experiment_id

1import mlflow
2
3eksperyment = mlflow.get_experiment_by_name("safari-klasyfikacja")
4runy = mlflow.search_runs(experiment_ids=[eksperyment.experiment_id])
5
6print(runy.shape)
7print(runy[["params.n_estimators", "params.max_depth", "metrics.accuracy"]].head())

Dostajesz zwykłą tabelę: jeden wiersz na run, a w kolumnach wszystko, co zalogowałeś. Nazwy kolumn mają przedrostki -

params.

metrics.

params.

params.n_estimators

metrics.

Skoro metryki są liczbami, znalezienie zwycięzcy to jedno wywołanie

sort_values

ascending=False

iloc[0]

run_id

load_model

runs:/identyfikator/nazwa_podkatalogu

1import mlflow.sklearn
2
3najlepsze = runy.sort_values("metrics.accuracy", ascending=False)
4id_zwyciezcy = najlepsze.iloc[0]["run_id"]
5
6zwyciezca = mlflow.sklearn.load_model(f"runs:/{id_zwyciezcy}/model")
7print(zwyciezca.predict(X_test)[:5])

Wczytany model jest zwyczajnym obiektem scikit-learn i odpowiada na

predict

sort_values

runy

model

log_model

runs:/identyfikator/las

I stąd bierze się praktyczna zasada, o którą warto oprzeć całą swoją dyscyplinę pracy: loguj model w każdym runie, który ma jakąkolwiek szansę wygrać. Gdyby na szczycie posortowanej tabeli wylądował run, w którym zapisałeś samą metrykę - jak nasz rozgrzewkowy "las_losowy_v2" - wczytanie skończyłoby się błędem o braku artefaktu, bo pod tym adresem po prostu nic nie leży. Właśnie dlatego trzymamy próby w osobnym eksperymencie, a w docelowym lądują wyłącznie kompletne runy.

Model Registry - jedno miejsce na model produkcyjny

Adres z identyfikatorem runu jest precyzyjny, ale nieporęczny: nikt nie zapamięta trzydziestu dwóch znaków szesnastkowych, a w kodzie aplikacji taki napis wygląda jak przypadek. Dlatego MLflow ma rejestr modeli - katalog nazwanych modeli z numerowanymi wersjami. Model trafia do rejestru w chwili logowania, jeśli dopiszesz argument

registered_model_name

1with mlflow.start_run(run_name="kandydat_do_rejestru"):
2    model = RandomForestClassifier(n_estimators=200, random_state=42)
3    model.fit(X_train, y_train)
4
5    mlflow.sklearn.log_model(
6        model, "model", registered_model_name="KlasyfikatorSafari"
7    )

Od tej chwili model ma nazwę czytelną dla człowieka i wersję, a w interfejsie webowym pojawia się osobna zakładka z rejestrem. Nic poza tym się nie zmieniło - run wygląda jak każdy inny, parametry i metryki logujesz tak samo, a sam obiekt

model

Wczytanie z rejestru wygląda znajomo, zmienia się tylko przedrostek adresu:

models:

runs:

1zarejestrowany = mlflow.sklearn.load_model("models:/KlasyfikatorSafari/1")
2print(zarejestrowany.predict(X_test)[:5])

Jedynka na końcu to numer wersji, a nie liczba modeli - żeby sięgnąć po nowszą, wpisujesz dwójkę. Kod korzystający z modelu nie musi już wiedzieć nic o runach ani identyfikatorach. W starszych materiałach spotkasz w tym miejscu zapis z nazwą etapu, na przykład

models:/KlasyfikatorSafari/Production

@produkcja

Pętla strojenia z dziennikiem w tle

Na koniec połączmy dziennik ze strojeniem hiperparametrów z poprzedniej lekcji. Przy ręcznym przeglądzie kombinacji MLflow pokazuje pełnię możliwości: każda kombinacja dostaje własny run, więc po skończonej pętli masz gotową tabelę do porównania, zamiast wpatrywać się w przewijający się terminal. Użyjemy

cross_val_score

1import mlflow
2import mlflow.xgboost
3import xgboost as xgb
4from sklearn.model_selection import cross_val_score
5
6mlflow.set_experiment("safari-xgboost-strojenie")
7
8kombinacje = [
9    {"max_depth": 3, "learning_rate": 0.1},
10    {"max_depth": 5, "learning_rate": 0.1},
11    {"max_depth": 3, "learning_rate": 0.05},
12    {"max_depth": 5, "learning_rate": 0.05},
13]
14
15for parametry in kombinacje:
16    with mlflow.start_run():
17        mlflow.log_params(parametry)
18
19        model = xgb.XGBClassifier(**parametry, n_estimators=100, random_state=42)
20        oceny = cross_val_score(model, X_train, y_train, cv=5)
21
22        mlflow.log_metric("cv_srednia", oceny.mean())
23        mlflow.log_metric("cv_odchylenie", oceny.std())
24
25        model.fit(X_train, y_train)
26        mlflow.log_metric("test_accuracy", model.score(X_test, y_test))
27        mlflow.xgboost.log_model(model, "model")

Cztery kombinacje, cztery runy, dwanaście metryk - i ani jednej liczby zapisanej na skrawku papieru. Nie podaję wyników w komentarzach, bo zależą od wersji XGBoost i od danych, a poza tym nie o nie tu chodzi: chodzi o to, że po zakończeniu pętli wystarczy

mlflow.search_runs

with

log_params

max_depth

mlflow.xgboost

mlflow.sklearn

XGBClassifier

Podsumowanie

• MLflow służy do śledzenia eksperymentów ML: zapisuje parametry, metryki i modele. Nie trenuje modeli, nie służy do budowania interfejsów użytkownika i nie zastępuje testów jednostkowych.
• Run to jedno uruchomienie treningu, eksperyment to nazwany zbiór runów. Otwierasz run przez

  with mlflow.start_run():

  - wersja bez

  with

  zostawia run otwarty po każdym wyjątku.
• Parametr logujesz sześcioma elementami:

  mlflow

  ,

  .

  ,

  log_param

  ,

  (

  ,

  "n_estimators", 100

  ,

  )

  - najpierw nazwa, potem wartość. Wiele naraz przyjmuje

  log_params

  ze słownikiem.
• Metryka musi być liczbą i wolno ją zapisywać wielokrotnie w jednym runie; parametr może być czymkolwiek, ale tylko raz.
• Model zapisujesz smakiem właściwym dla biblioteki:

  mlflow.sklearn.log_model

  ,

  mlflow.xgboost.log_model

  ,

  mlflow.pytorch.log_model

  . Dowolny plik dołączasz przez

  log_artifact

  .
• Interfejs webowy uruchamiasz w terminalu poleceniem

  mlflow ui

  , w katalogu z folderem

  mlruns

  . Nie

  python mlflow.py

  , nie

  mlflow start

  , nie

  run mlflow

  .

• mlflow.sklearn.autolog()

  automatycznie loguje parametry i metryki modeli scikit-learn. Nie czyści danych, nie trenuje modeli i nie generuje raportów PDF.

• mlflow.search_runs

  zwraca DataFrame - wartości w kolumnach

  params.

  są napisami, a w

  metrics.

  liczbami.
• Rejestr modeli daje modelowi nazwę i numerowane wersje:

  registered_model_name

  przy zapisie, adres

  models:/Nazwa/1

  przy odczycie.

Przed Tobą trzy projekty zamykające ten moduł: klasyfikator z Pipeline i walidacją krzyżową, XGBoost ze strojeniem hiperparametrów i sieć neuronowa w PyTorch. Zrób każdy z nich wewnątrz

with mlflow.start_run():