Logga och visa mått och loggfiler v1

Artikel
06/10/2023

Logga realtidsinformation med både python-standardloggningspaketet och Azure Machine Learning Python SDK-specifika funktioner. Du kan logga lokalt och skicka loggar till din arbetsyta i portalen.

Med loggarna kan du diagnostisera fel och varningar, eller spåra prestandamått som parametrar och modellprestanda. I den här artikeln får du lära dig hur du aktiverar loggning i följande scenarier:

Loggkörningsmått
Interaktiva träningssessioner
Skicka träningsjobb med ScriptRunConfig
Inbyggda logging-inställningar i Python
Loggning från fler källor

Dricks

Den här artikeln visar hur du övervakar modellträningsprocessen. Om du är intresserad av att övervaka resursanvändning och händelser från Azure Machine Learning, till exempel kvoter, slutförda träningskörningar eller slutförda modelldistributioner, kan du läsa Övervaka Azure Machine Learning.

Datatyper

Du kan logga flera datatyper, inklusive skalära värden, listor, tabeller, bilder, kataloger med mera. Mer information och Python-kodexempel för olika datatyper finns på referenssidan Körningsklass.

Loggningskörningsmått

Använd följande metoder i loggnings-API:erna för att påverka måttvisualiseringarna. Observera tjänstgränserna för dessa loggade mått.

Loggat värde	Exempelkod	Formatera i portalen
Logga en matris med numeriska värden	`run.log_list(name='Fibonacci', value=[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89])`	linjediagram med en variabel
Logga ett enskilt numeriskt värde med samma måttnamn som används upprepade gånger (till exempel inifrån en for-loop)	`for i in tqdm(range(-10, 10)): run.log(name='Sigmoid', value=1 / (1 + np.exp(-i))) angle = i / 2.0`	Linjediagram med en variabel
Logga en rad med 2 numeriska kolumner upprepade gånger	`run.log_row(name='Cosine Wave', angle=angle, cos=np.cos(angle)) sines['angle'].append(angle) sines['sine'].append(np.sin(angle))`	Linjediagram med två variabler
Loggtabell med 2 numeriska kolumner	`run.log_table(name='Sine Wave', value=sines)`	Linjediagram med två variabler
Loggbild	`run.log_image(name='food', path='./breadpudding.jpg', plot=None, description='desert')`	Använd den här metoden för att logga en bildfil eller ett matplotlib-diagram till körningen. Dessa avbildningar kommer att vara synliga och jämförbara i körningsposten

Loggning med MLflow

Vi rekommenderar att du loggar dina modeller, mått och artefakter med MLflow eftersom det är öppen källkod och det stöder lokalt läge till molnportabilitet. Följande tabell- och kodexempel visar hur du använder MLflow för att logga mått och artefakter från dina träningskörningar. Läs mer om MLflows loggningsmetoder och designmönster.

Se till att installera och azureml-mlflow pip-paketen mlflow på din arbetsyta.

pip install mlflow
pip install azureml-mlflow

Ställ in URI:n för MLflow-spårning så att den pekar på Azure Machine Learning-serverdelen för att säkerställa att dina mått och artefakter loggas till din arbetsyta.

from azureml.core import Workspace
import mlflow
from mlflow.tracking import MlflowClient

ws = Workspace.from_config()
mlflow.set_tracking_uri(ws.get_mlflow_tracking_uri())

mlflow.create_experiment("mlflow-experiment")
mlflow.set_experiment("mlflow-experiment")
mlflow_run = mlflow.start_run()

Loggat värde	Exempelkod	Kommentar
Logga ett numeriskt värde (int eller flyttal)	`mlflow.log_metric('my_metric', 1)`
Logga ett booleskt värde	`mlflow.log_metric('my_metric', 0)`	0 = Sant, 1 = Falskt
Logga en sträng	`mlflow.log_text('foo', 'my_string')`	Loggad som en artefakt
Logga numpy-mått eller PIL-bildobjekt	`mlflow.log_image(img, 'figure.png')`
Loggmatlotlib-diagram eller bildfil	`mlflow.log_figure(fig, "figure.png")`

Visa körningsmått via SDK

Du kan visa måtten för en tränad modell med hjälp av run.get_metrics().

from azureml.core import Run
run = Run.get_context()
run.log('metric-name', metric_value)

metrics = run.get_metrics()
# metrics is of type Dict[str, List[float]] mapping metric names
# to a list of the values for that metric in the given run.

metrics.get('metric-name')
# list of metrics in the order they were recorded

Du kan också komma åt körningsinformation med hjälp av MLflow via körningsobjektets data- och informationsegenskaper. Mer information finns i dokumentationen om MLflow.entities.Run-objekt .

När körningen är klar kan du hämta den med hjälp av MlFlowClient().

from mlflow.tracking import MlflowClient

# Use MlFlow to retrieve the run that was just completed
client = MlflowClient()
finished_mlflow_run = MlflowClient().get_run(mlflow_run.info.run_id)

Du kan visa mått, parametrar och taggar för körningen i datafältet för körningsobjektet.

metrics = finished_mlflow_run.data.metrics
tags = finished_mlflow_run.data.tags
params = finished_mlflow_run.data.params

Kommentar

Måttordlistan under mlflow.entities.Run.data.metrics returnerar endast det senast loggade värdet för ett visst måttnamn. Om du till exempel loggar i ordning, 1, sedan 2, sedan 3, sedan 4 till ett mått med namnet sample_metric, finns endast 4 i måttordlistan för sample_metric.

Om du vill få alla mått loggade för ett visst måttnamn kan du använda MlFlowClient.get_metric_history().

Visa körningsmått i studiogränssnittet

Du kan bläddra bland slutförda körningsposter, inklusive loggade mått, i Azure Machine Learning-studio.

Gå till fliken Experiment . Om du vill visa alla körningar i arbetsytan mellan experiment väljer du fliken Alla körningar . Du kan öka detaljnivån för körningar för specifika experiment genom att använda experimentfiltret i den översta menyraden.

För den enskilda experimentvyn väljer du fliken Alla experiment . På instrumentpanelen för experimentkörning kan du se spårade mått och loggar för varje körning.

Du kan också redigera tabellen för körningslistan för att välja flera körningar och visa antingen det sista, lägsta eller högsta loggade värdet för dina körningar. Anpassa dina diagram för att jämföra de loggade måttvärdena och aggregeringarna mellan flera körningar. Du kan rita flera mått på y-axeln i diagrammet och anpassa x-axeln för att rita dina loggade mått.

Visa och ladda ner loggfiler för en körning

Loggfiler är en viktig resurs för felsökning av Azure Machine Learning-arbetsbelastningar. När du har skickat ett träningsjobb kan du öka detaljnivån till en specifik körning för att visa loggar och utdata:

Gå till fliken Experiment .
Välj runID för en specifik körning.
Välj Utdata och loggar överst på sidan.
Välj Ladda ned alla för att ladda ned alla loggar till en zip-mapp.
Du kan också ladda ned enskilda loggfiler genom att välja loggfilen och välja Ladda ned

Screenshot of Output and logs section of a run.

user_logs mapp

Den här mappen innehåller information om de användargenererade loggarna. Den här mappen är öppen som standard och loggen std_log.txt är markerad. Den std_log.txt är där kodens loggar (till exempel utskriftsuttryck) visas. Den här filen innehåller stdout loggar och stderr loggar från kontrollskriptet och träningsskriptet, en per process. I de flesta fall övervakar du loggarna här.

system_logs mapp

Den här mappen innehåller loggarna som genereras av Azure Machine Learning och stängs som standard. Loggarna som genereras av systemet grupperas i olika mappar, baserat på fasen för jobbet i körningen.

Andra mappar

För jobbträning i flera beräkningskluster finns loggar för varje nod-IP. Strukturen för varje nod är densamma som jobb med en enda nod. Det finns ytterligare en loggmapp för övergripande körnings-, stderr- och stdout-loggar.

Azure Machine Learning loggar information från olika källor under träningen, till exempel AutoML eller Docker-containern som kör träningsjobbet. Många av dessa loggar är inte dokumenterade. Om du stöter på problem och kontaktar Microsofts support kan de kanske använda dessa loggar under felsökningen.

Interaktiv loggningssession

Interaktiva loggningssessioner används vanligtvis i miljöer med notebook-filer. Metoden Experiment.start_logging() startar en interaktiv loggningssession. Alla mått som loggas under sessionen läggs till i körningsposten i experimentet. Metoden run.complete() avslutar sessionerna och markerar körningen som slutförd.

ScriptRun-loggar

I det här avsnittet lär du dig att lägga till loggningskod i körningar som skapas vid konfiguration med ScriptRunConfig. Du kan använda ScriptRunConfig-klassen till att kapsla in skript och miljöer för upprepningsbara körningar. Du kan också använda det här alternativet till att visa widgeten för Jupyter Notebooks vid övervakning.

I det här exemplet utförs en parameterrensning av alfavärden och resultaten samlas in med hjälp av metoden run.log().

Skapa ett träningsskript som innehåller loggningslogiken train.py.

# Copyright (c) Microsoft. All rights reserved.
# Licensed under the MIT license.

from sklearn.datasets import load_diabetes
from sklearn.linear_model import Ridge
from sklearn.metrics import mean_squared_error
from sklearn.model_selection import train_test_split
from azureml.core.run import Run
import os
import numpy as np
import mylib
# sklearn.externals.joblib is removed in 0.23
try:
    from sklearn.externals import joblib
except ImportError:
    import joblib

os.makedirs('./outputs', exist_ok=True)

X, y = load_diabetes(return_X_y=True)

run = Run.get_context()

X_train, X_test, y_train, y_test = train_test_split(X, y,
                                                    test_size=0.2,
                                                    random_state=0)
data = {"train": {"X": X_train, "y": y_train},
        "test": {"X": X_test, "y": y_test}}

# list of numbers from 0.0 to 1.0 with a 0.05 interval
alphas = mylib.get_alphas()

for alpha in alphas:
    # Use Ridge algorithm to create a regression model
    reg = Ridge(alpha=alpha)
    reg.fit(data["train"]["X"], data["train"]["y"])

    preds = reg.predict(data["test"]["X"])
    mse = mean_squared_error(preds, data["test"]["y"])
    run.log('alpha', alpha)
    run.log('mse', mse)

    model_file_name = 'ridge_{0:.2f}.pkl'.format(alpha)
    # save model in the outputs folder so it automatically get uploaded
    with open(model_file_name, "wb") as file:
        joblib.dump(value=reg, filename=os.path.join('./outputs/',
                                                     model_file_name))

    print('alpha is {0:.2f}, and mse is {1:0.2f}'.format(alpha, mse))

Skicka train.py-skriptet för körning i en användarhanterad miljö. Hela skriptmappen skickas för träningen.
```
from azureml.core import ScriptRunConfig

src = ScriptRunConfig(source_directory='./scripts', script='train.py', environment=user_managed_env)
```
```
run = exp.submit(src)
```
Parametern show_output aktiverar utförlig loggning så att du kan se information från träningsprocessen, samt information om eventuella fjärresurser eller beräkningsmål. Använd följande kod för att aktivera utförlig loggning när du skickar experimentet.
```
run = exp.submit(src, show_output=True)
```
Du kan också använda samma parameter i funktionen wait_for_completion för den resulterande körningen.
```
run.wait_for_completion(show_output=True)
```

Intern Python-loggning

Vissa loggar i SDK:n kan innehålla ett fel som uppmanar dig att ange loggningsnivån DEBUG. Om du ska ange loggningsnivån lägger du till nedanstående kod i skriptet.

import logging
logging.basicConfig(level=logging.DEBUG)

Andra loggningskällor

Azure Machine Learning kan också logga information från andra källor under träningen, till exempel automatiserade maskininlärningskörningar eller Docker-containrar som kör jobben. Dessa loggar dokumenteras inte, men om du stöter på problem och kontaktar Microsofts support kan de använda loggarna vid felsökning.

Information om loggning av mått i Azure Machine Learning-designern finns i Loggning av mått i designern

Exempelnotebook-filer

Följande notebook-filer demonstrerar begreppen i den här artikeln:

Lär dig att köra notebook-filer genom att följa artikeln Använda Jupyter-notebooks till att utforska tjänsten.

Nästa steg

Läs de här artiklarna om du vill lära dig mer om att använda Azure Machine Learning:

Se ett exempel på hur du registrerar den bästa modellen och distribuerar den i självstudien Träna en bildklassificeringsmodell med Azure Machine Learning.