Używanie zautomatyzowanego uczenia maszynowego w potoku usługi Azure Machine Learning w języku Python

Artykuł
12/09/2023

DOTYCZY: Zestaw SDK języka Python azureml w wersji 1

Funkcja zautomatyzowanego uczenia maszynowego w usłudze Azure Machine Edukacja ułatwia odnajdywanie modeli o wysokiej wydajności bez konieczności ponownego wdrażania każdego możliwego podejścia. W połączeniu z potokami usługi Azure Machine Edukacja można tworzyć możliwe do wdrożenia przepływy pracy, które umożliwiają szybkie odnajdywanie algorytmu, który działa najlepiej dla Twoich danych. W tym artykule pokazano, jak efektywnie dołączyć krok przygotowywania danych do kroku zautomatyzowanego uczenia maszynowego. Zautomatyzowane uczenie maszynowe umożliwia szybkie odnajdywanie algorytmu, który działa najlepiej dla Twoich danych, przy jednoczesnym wprowadzeniu metodyki MLOps i operacjonalizacji cyklu życia modelu za pomocą potoków.

Wymagania wstępne

Subskrypcja platformy Azure. Jeśli nie masz subskrypcji platformy Azure, przed rozpoczęciem utwórz bezpłatne konto. Wypróbuj bezpłatną lub płatną wersję usługi Azure Machine Edukacja dzisiaj.
Obszar roboczy usługi Azure Machine Learning. Zobacz Tworzenie zasobów obszaru roboczego.
Znajomość zautomatyzowanego uczenia maszynowego i potoków uczenia maszynowego platformy Azure oraz zestawu SDK.

Przeglądanie klas centralnych zautomatyzowanego uczenia maszynowego

Zautomatyzowane uczenie maszynowe w potoku jest reprezentowane przez AutoMLStep obiekt. Klasa AutoMLStep jest podklasą .PipelineStep Graf PipelineStep obiektów definiuje obiekt Pipeline.

Istnieje kilka podklas .PipelineStep Oprócz programu AutoMLStepten artykuł zawiera informacje PythonScriptStep dotyczące przygotowywania danych i innego elementu do rejestrowania modelu.

Preferowanym sposobem początkowego przenoszenia danych do potoku uczenia maszynowego jest użycie Dataset obiektów. Aby przenieść dane między krokami i możliwymi danymi wyjściowymi danych wyjściowych z przebiegów, preferowanym sposobem jest użycie OutputFileDatasetConfig obiektów i OutputTabularDatasetConfig . Aby można było używać z elementem AutoMLStepPipelineOutputTabularDataset , PipelineData obiekt musi zostać przekształcony w obiekt. Aby uzyskać więcej informacji, zobacz Dane wejściowe i wyjściowe z potoków uczenia maszynowego.

Element AutoMLStep jest konfigurowany za pośrednictwem AutoMLConfig obiektu. AutoMLConfig to elastyczna klasa, jak opisano w temacie Konfigurowanie eksperymentów zautomatyzowanego uczenia maszynowego w języku Python.

Uruchamia Pipeline element w obiekcie Experiment. Run Potok zawiera element podrzędny StepRundla każdego kroku . Dane wyjściowe zautomatyzowanego uczenia maszynowego StepRun to metryki trenowania i model o najwyższej wydajności.

Aby utworzyć konkretne elementy, ten artykuł tworzy prosty potok dla zadania klasyfikacji. Zadanie przewiduje przetrwanie Titanica, ale nie będziemy omawiać danych ani zadań z wyjątkiem przekazywania.

Rozpocznij

Pobieranie początkowego zestawu danych

Często przepływ pracy uczenia maszynowego rozpoczyna się od istniejących danych odniesienia. Jest to dobry scenariusz dla zarejestrowanego zestawu danych. Zestawy danych są widoczne w obszarze roboczym, obsługują przechowywanie wersji i mogą być eksplorowane interaktywnie. Istnieje wiele sposobów tworzenia i wypełniania zestawu danych, zgodnie z opisem w temacie Tworzenie zestawów danych usługi Azure Machine Edukacja. Ponieważ użyjemy zestawu SDK języka Python do utworzenia potoku, użyj zestawu SDK do pobrania danych punktu odniesienia i zarejestrowania go pod nazwą "titanic_ds".

from azureml.core import Workspace, Dataset

ws = Workspace.from_config()
if not 'titanic_ds' in ws.datasets.keys() :
    # create a TabularDataset from Titanic training data
    web_paths = ['https://dprepdata.blob.core.windows.net/demo/Titanic.csv',
                 'https://dprepdata.blob.core.windows.net/demo/Titanic2.csv']
    titanic_ds = Dataset.Tabular.from_delimited_files(path=web_paths)

    titanic_ds.register(workspace = ws,
                                     name = 'titanic_ds',
                                     description = 'Titanic baseline data',
                                     create_new_version = True)

titanic_ds = Dataset.get_by_name(ws, 'titanic_ds')

Kod najpierw rejestruje się w obszarze roboczym usługi Azure Machine Edukacja zdefiniowanym w pliku config.json (aby uzyskać wyjaśnienie, zobacz Tworzenie pliku konfiguracji obszaru roboczego. Jeśli nie ma jeszcze zestawu danych o nazwie 'titanic_ds' zarejestrowane, zostanie utworzony. Kod pobiera dane CSV z sieci Web, używa ich do utworzenia wystąpienia zestawu TabularDataset danych, a następnie rejestruje zestaw danych w obszarze roboczym. Na koniec funkcja przypisuje element Dataset.get_by_name()Dataset do titanic_dselementu .

Konfigurowanie magazynu i docelowego obiektu obliczeniowego

Dodatkowe zasoby potrzebne w potoku to magazyn i, ogólnie rzecz biorąc, usługa Azure Machine Edukacja zasoby obliczeniowe.

from azureml.core import Datastore
from azureml.core.compute import AmlCompute, ComputeTarget

datastore = ws.get_default_datastore()

compute_name = 'cpu-cluster'
if not compute_name in ws.compute_targets :
    print('creating a new compute target...')
    provisioning_config = AmlCompute.provisioning_configuration(vm_size='STANDARD_D2_V2',
                                                                min_nodes=0,
                                                                max_nodes=1)
    compute_target = ComputeTarget.create(ws, compute_name, provisioning_config)

    compute_target.wait_for_completion(
        show_output=True, min_node_count=None, timeout_in_minutes=20)

    # Show the result
    print(compute_target.get_status().serialize())

compute_target = ws.compute_targets[compute_name]

Dane pośrednie między przygotowywaniem danych a zautomatyzowanym krokiem uczenia maszynowego mogą być przechowywane w domyślnym magazynie danych obszaru roboczego, więc nie musimy wykonywać więcej niż wywołania get_default_datastore()Workspace obiektu.

Następnie kod sprawdza, czy maszyna platformy Azure Edukacja obiekt docelowy 'cpu-cluster' obliczeniowy już istnieje. W przeciwnym razie określimy, że chcemy mieć mały docelowy obiekt obliczeniowy oparty na procesorze CPU. Jeśli planujesz używać funkcji uczenia głębokiego zautomatyzowanego uczenia maszynowego (na przykład cechowania tekstu z obsługą sieci DNN), należy wybrać obliczenia z silną obsługą procesora GPU, zgodnie z opisem w artykule Rozmiary maszyn wirtualnych zoptymalizowanych pod kątem procesora GPU.

Kod blokuje się do momentu aprowizacji obiektu docelowego, a następnie wyświetli szczegółowe informacje o właśnie utworzonym obiekcie docelowym obliczeniowym. Na koniec nazwany obiekt docelowy obliczeniowy jest pobierany z obszaru roboczego i przypisany do elementu compute_target.

Konfigurowanie przebiegu trenowania

Kontekst środowiska uruchomieniowego jest ustawiany przez utworzenie i skonfigurowanie RunConfiguration obiektu. W tym miejscu ustawiliśmy docelowy obiekt obliczeniowy.

from azureml.core.runconfig import RunConfiguration
from azureml.core.conda_dependencies import CondaDependencies

aml_run_config = RunConfiguration()
# Use just-specified compute target ("cpu-cluster")
aml_run_config.target = compute_target

# Specify CondaDependencies obj, add necessary packages
aml_run_config.environment.python.conda_dependencies = CondaDependencies.create(
    conda_packages=['pandas','scikit-learn'], 
    pip_packages=['azureml-sdk[automl]', 'pyarrow'])

Przygotowywanie danych do zautomatyzowanego uczenia maszynowego

Pisanie kodu przygotowywania danych

Bazowy zestaw danych Titanic składa się z mieszanych danych liczbowych i tekstowych z brakującymi niektórymi wartościami. Aby przygotować go do zautomatyzowanego uczenia maszynowego, krok potoku przygotowywania danych wykona następujące czynności:

Wypełnij brakujące dane danymi losowymi lub kategorią odpowiadającą wartościom "Nieznany"
Przekształcanie danych kategorii na liczby całkowite
Usuwanie kolumn, których nie zamierzamy używać
Dzielenie danych na zestawy treningowe i testowe
Zapisywanie przekształconych danych do ścieżek wyjściowych OutputFileDatasetConfig

%%writefile dataprep.py
from azureml.core import Run

import pandas as pd 
import numpy as np 
import argparse

RANDOM_SEED=42

def prepare_age(df):
    # Fill in missing Age values from distribution of present Age values 
    mean = df["Age"].mean()
    std = df["Age"].std()
    is_null = df["Age"].isnull().sum()
    # compute enough (== is_null().sum()) random numbers between the mean, std
    rand_age = np.random.randint(mean - std, mean + std, size = is_null)
    # fill NaN values in Age column with random values generated
    age_slice = df["Age"].copy()
    age_slice[np.isnan(age_slice)] = rand_age
    df["Age"] = age_slice
    df["Age"] = df["Age"].astype(int)
    
    # Quantize age into 5 classes
    df['Age_Group'] = pd.qcut(df['Age'],5, labels=False)
    df.drop(['Age'], axis=1, inplace=True)
    return df

def prepare_fare(df):
    df['Fare'].fillna(0, inplace=True)
    df['Fare_Group'] = pd.qcut(df['Fare'],5,labels=False)
    df.drop(['Fare'], axis=1, inplace=True)
    return df 

def prepare_genders(df):
    genders = {"male": 0, "female": 1, "unknown": 2}
    df['Sex'] = df['Sex'].map(genders)
    df['Sex'].fillna(2, inplace=True)
    df['Sex'] = df['Sex'].astype(int)
    return df

def prepare_embarked(df):
    df['Embarked'].replace('', 'U', inplace=True)
    df['Embarked'].fillna('U', inplace=True)
    ports = {"S": 0, "C": 1, "Q": 2, "U": 3}
    df['Embarked'] = df['Embarked'].map(ports)
    return df
    
parser = argparse.ArgumentParser()
parser.add_argument('--output_path', dest='output_path', required=True)
args = parser.parse_args()
    
titanic_ds = Run.get_context().input_datasets['titanic_ds']
df = titanic_ds.to_pandas_dataframe().drop(['PassengerId', 'Name', 'Ticket', 'Cabin'], axis=1)
df = prepare_embarked(prepare_genders(prepare_fare(prepare_age(df))))

df.to_csv(os.path.join(args.output_path,"prepped_data.csv"))

print(f"Wrote prepped data to {args.output_path}/prepped_data.csv")

Powyższy fragment kodu jest kompletnym, ale minimalnym przykładem przygotowywania danych dla danych Titanic. Fragment kodu rozpoczyna się od polecenia "magic" programu Jupyter w celu wyprowadzenia kodu do pliku. Jeśli nie używasz notesu Jupyter, usuń ten wiersz i ręcznie utwórz plik.

Różne prepare_ funkcje w powyższym fragmencie kodu modyfikują odpowiednią kolumnę w wejściowym zestawie danych. Te funkcje działają na danych po zmianie w obiekt Pandas DataFrame . W każdym przypadku brakujące dane są wypełniane reprezentatywnymi danymi losowymi lub danymi kategorialnymi wskazującymi wartość "Nieznany". Dane podzielone na kategorie oparte na tekście są mapowane na liczby całkowite. Nie są już potrzebne kolumny są zastępowane ani porzucane.

Po zdefiniowaniu funkcji przygotowywania danych kod analizuje argument wejściowy, czyli ścieżkę, do której chcemy zapisać dane. (Te wartości będą określane przez OutputFileDatasetConfig obiekty, które zostaną omówione w następnym kroku). Kod pobiera zarejestrowany element 'titanic_cs'Dataset, konwertuje go na bibliotekę Pandas DataFramei wywołuje różne funkcje przygotowywania danych.

output_path Ponieważ element jest katalogiem, wywołanie to_csv() metody określa nazwę pliku prepped_data.csv.

Zapisywanie kroku potoku przygotowywania danych (`PythonScriptStep`)

Kod przygotowywania danych opisany powyżej musi być skojarzony z obiektem PythonScripStep , który ma być używany z potokiem. Ścieżka, do której zapisywane są dane wyjściowe CSV, jest generowana przez OutputFileDatasetConfig obiekt. Zasoby przygotowane wcześniej, takie jak ComputeTarget, RunConfig, i 'titanic_ds' Dataset są używane do ukończenia specyfikacji.

from azureml.data import OutputFileDatasetConfig
from azureml.pipeline.steps import PythonScriptStep

prepped_data_path = OutputFileDatasetConfig(name="output_path")

dataprep_step = PythonScriptStep(
    name="dataprep", 
    script_name="dataprep.py", 
    compute_target=compute_target, 
    runconfig=aml_run_config,
    arguments=["--output_path", prepped_data_path],
    inputs=[titanic_ds.as_named_input('titanic_ds')],
    allow_reuse=True
)

Obiekt prepped_data_path jest typu OutputFileDatasetConfig , który wskazuje katalog. Zwróć uwagę, że jest określony w parametrze arguments . Jeśli przejrzysz poprzedni krok, zobaczysz, że w kodzie przygotowywania danych wartość argumentu '--output_path' to ścieżka katalogu, w której został zapisany plik CSV.

Trenowanie za pomocą rozwiązania AutoMLStep

Konfigurowanie kroku zautomatyzowanego potoku uczenia maszynowego odbywa się przy użyciu AutoMLConfig klasy . Ta elastyczna klasa została opisana w temacie Konfigurowanie eksperymentów zautomatyzowanego uczenia maszynowego w języku Python. Dane wejściowe i wyjściowe to jedyne aspekty konfiguracji, które wymagają szczególnej uwagi w potoku uczenia maszynowego. Dane wejściowe i wyjściowe dla AutoMLConfig potoków zostały szczegółowo omówione poniżej. Poza danymi zaletą potoków uczenia maszynowego jest możliwość używania różnych celów obliczeniowych na potrzeby różnych kroków. Możesz użyć bardziej zaawansowanego ComputeTarget tylko dla zautomatyzowanego procesu uczenia maszynowego. Wykonanie tej czynności jest tak proste, jak przypisanie bardziej zaawansowanego RunConfiguration parametru AutoMLConfigrun_configuration obiektu.

Wysyłanie danych do `AutoMLStep`

W potoku uczenia maszynowego dane wejściowe muszą być obiektem Dataset . Najwyższy sposób zapewniania danych wejściowych OutputTabularDatasetConfig w postaci obiektów. Obiekt tego typu należy utworzyć na read_delimited_files() obiekcie OutputFileDatasetConfig, takim jak prepped_data_path, na przykład prepped_data_path obiekt .

# type(prepped_data) == OutputTabularDatasetConfig
prepped_data = prepped_data_path.read_delimited_files()

Inną opcją jest użycie Dataset obiektów zarejestrowanych w obszarze roboczym:

prepped_data = Dataset.get_by_name(ws, 'Data_prepared')

Porównanie dwóch technik:

Technika	Zalety i wady
`OutputTabularDatasetConfig`	Wyższa wydajność
	Trasa naturalna z `OutputFileDatasetConfig`
	Dane nie są utrwalane po uruchomieniu potoku

Zarejestrowany `Dataset`	Niższa wydajność
	Można wygenerować na wiele sposobów
	Dane są utrwalane i widoczne w całym obszarze roboczym
	Notes przedstawiający zarejestrowaną `Dataset` technikę

Określanie zautomatyzowanych danych wyjściowych uczenia maszynowego

Dane wyjściowe elementu AutoMLStep to końcowe wyniki metryk modelu o wyższej wydajności i sam model. Aby użyć tych danych wyjściowych w dalszych krokach potoku, przygotuj OutputFileDatasetConfig obiekty do ich odbierania.

from azureml.pipeline.core import TrainingOutput, PipelineData

metrics_data = PipelineData(name='metrics_data',
                            datastore=datastore,
                            pipeline_output_name='metrics_output',
                            training_output=TrainingOutput(type='Metrics'))

model_data = PipelineData(name='best_model_data',
                          datastore=datastore,
                          pipeline_output_name='model_output',
                          training_output=TrainingOutput(type='Model'))

Powyższy fragment kodu tworzy dwa PipelineData obiekty dla metryk i danych wyjściowych modelu. Każda nazwa jest nazwana przypisana do domyślnego magazynu danych pobranego wcześniej i skojarzona z określonym typeTrainingOutput elementem z .AutoMLStep Ponieważ przypisujemy pipeline_output_name je do tych PipelineData obiektów, ich wartości będą dostępne nie tylko z poziomu pojedynczego kroku potoku, ale z potoku jako całości, jak opisano poniżej w sekcji "Badanie wyników potoku".

Konfigurowanie i tworzenie kroku zautomatyzowanego potoku uczenia maszynowego

Po zdefiniowaniu danych wejściowych i wyjściowych należy utworzyć element AutoMLConfig i AutoMLStep. Szczegóły konfiguracji będą zależeć od zadania, zgodnie z opisem w temacie Konfigurowanie eksperymentów zautomatyzowanego uczenia maszynowego w języku Python. W przypadku zadania klasyfikacji przetrwania Titanic poniższy fragment kodu przedstawia prostą konfigurację.

from azureml.train.automl import AutoMLConfig
from azureml.pipeline.steps import AutoMLStep

# Change iterations to a reasonable number (50) to get better accuracy
automl_settings = {
    "iteration_timeout_minutes" : 10,
    "iterations" : 2,
    "experiment_timeout_hours" : 0.25,
    "primary_metric" : 'AUC_weighted'
}

automl_config = AutoMLConfig(task = 'classification',
                             path = '.',
                             debug_log = 'automated_ml_errors.log',
                             compute_target = compute_target,
                             run_configuration = aml_run_config,
                             featurization = 'auto',
                             training_data = prepped_data,
                             label_column_name = 'Survived',
                             **automl_settings)

train_step = AutoMLStep(name='AutoML_Classification',
    automl_config=automl_config,
    passthru_automl_config=False,
    outputs=[metrics_data,model_data],
    enable_default_model_output=False,
    enable_default_metrics_output=False,
    allow_reuse=True)

Fragment kodu przedstawia idiom często używany z elementem AutoMLConfig. Argumenty, które są bardziej płynne (hiperparametr-ish) są określane w osobnym słowniku, podczas gdy wartości mniej prawdopodobne do zmiany są określane bezpośrednio w konstruktorze AutoMLConfig . W takim przypadku automl_settings określ krótki przebieg: przebieg zostanie zatrzymany po upływie zaledwie 2 iteracji lub 15 minut, w zależności od tego, co nastąpi wcześniej.

Słownik automl_settings jest przekazywany do konstruktora AutoMLConfig jako kwargs. Inne parametry nie są złożone:

task parametr jest ustawiony classification na wartość dla tego przykładu. Inne prawidłowe wartości to regression i forecasting
path i debug_log opisz ścieżkę do projektu i plik lokalny, do którego zostaną zapisane informacje debugowania
compute_target jest wcześniej zdefiniowany compute_target , że w tym przykładzie jest niedrogim komputerem opartym na procesorze CPU. Jeśli używasz funkcji deep Edukacja rozwiązania AutoML, chcesz zmienić docelowy obiekt obliczeniowy na oparty na procesorze GPU
featurization jest ustawiona na autowartość . Więcej szczegółów można znaleźć w sekcji Cechowanie danych w dokumencie automatycznej konfiguracji uczenia maszynowego
label_column_name wskazuje, która kolumna jest zainteresowana przewidywaniem
training_data jest ustawiona OutputTabularDatasetConfig na obiekty wykonane z danych wyjściowych kroku przygotowywania danych

Sam AutoMLStep obiekt przyjmuje AutoMLConfig wartości i, jako dane wyjściowe, PipelineData obiekty utworzone do przechowywania metryk i danych modelu.

Ważne

Należy ustawić enable_default_model_output parametr i enable_default_metrics_output na True wartość tylko wtedy, gdy używasz polecenia AutoMLStepRun.

W tym przykładzie zautomatyzowany proces uczenia maszynowego przeprowadzi krzyżowe walidacje w obiekcie training_data. Liczbę krzyżowych walidacji można kontrolować za pomocą argumentu n_cross_validations . Jeśli dane szkoleniowe zostały już podzielone w ramach kroków przygotowywania danych, możesz ustawić validation_data na własną wartość Dataset.

Czasami można zobaczyć użycie X funkcji danych i y etykiet danych. Ta technika jest przestarzała i należy jej użyć training_data do wprowadzania danych wejściowych.

Rejestrowanie modelu wygenerowanego przez zautomatyzowane uczenie maszynowe

Ostatnim krokiem w prostym potoku uczenia maszynowego jest zarejestrowanie utworzonego modelu. Dodając model do rejestru modeli obszaru roboczego, będzie on dostępny w portalu i może być w wersji. Aby zarejestrować model, napisz inny PythonScriptStep , który pobiera model_data dane wyjściowe elementu AutoMLStep.

Pisanie kodu w celu zarejestrowania modelu

Model jest zarejestrowany w obiekcie Workspace. Prawdopodobnie wiesz już, jak Workspace.from_config() zalogować się do obszaru roboczego na komputerze lokalnym, ale istnieje inny sposób na pobranie obszaru roboczego z uruchomionego potoku uczenia maszynowego. Element Run.get_context() pobiera aktywny Runelement . Ten run obiekt zapewnia dostęp do wielu ważnych obiektów, w tym używanych Workspace tutaj.

%%writefile register_model.py
from azureml.core.model import Model, Dataset
from azureml.core.run import Run, _OfflineRun
from azureml.core import Workspace
import argparse

parser = argparse.ArgumentParser()
parser.add_argument("--model_name", required=True)
parser.add_argument("--model_path", required=True)
args = parser.parse_args()

print(f"model_name : {args.model_name}")
print(f"model_path: {args.model_path}")

run = Run.get_context()
ws = Workspace.from_config() if type(run) == _OfflineRun else run.experiment.workspace

model = Model.register(workspace=ws,
                       model_path=args.model_path,
                       model_name=args.model_name)

print("Registered version {0} of model {1}".format(model.version, model.name))

Pisanie kodu PythonScriptStep

Ostrzeżenie

Jeśli używasz zestawu Azure Machine Edukacja SDK w wersji 1, a obszar roboczy jest skonfigurowany do izolacji sieci (VNet), może wystąpić błąd podczas wykonywania tego kroku. Aby uzyskać więcej informacji, zobacz HyperdriveStep i AutoMLStep niepowodzenie z izolacją sieci.

Rejestrowanie PythonScriptStep modelu używa PipelineParameter elementu dla jednego z jego argumentów. Parametry potoku to argumenty potoków, które można łatwo ustawić w czasie przesyłania przebiegu. Po zadeklarowaniu są one przekazywane jako normalne argumenty.


from azureml.pipeline.core.graph import PipelineParameter

# The model name with which to register the trained model in the workspace.
model_name = PipelineParameter("model_name", default_value="TitanicSurvivalInitial")

register_step = PythonScriptStep(script_name="register_model.py",
                                       name="register_model",
                                       allow_reuse=False,
                                       arguments=["--model_name", model_name, "--model_path", model_data],
                                       inputs=[model_data],
                                       compute_target=compute_target,
                                       runconfig=aml_run_config)

Tworzenie i uruchamianie zautomatyzowanego potoku uczenia maszynowego

Tworzenie i uruchamianie potoku zawierającego AutoMLStep element nie różni się od normalnego potoku.

from azureml.pipeline.core import Pipeline
from azureml.core import Experiment

pipeline = Pipeline(ws, [dataprep_step, train_step, register_step])

experiment = Experiment(workspace=ws, name='titanic_automl')

run = experiment.submit(pipeline, show_output=True)
run.wait_for_completion()

Powyższy kod łączy kroki przygotowywania danych, zautomatyzowanego uczenia maszynowego i rejestrowania modeli w Pipeline obiekcie. Następnie tworzy Experiment obiekt. Konstruktor Experiment pobierze nazwany eksperyment, jeśli istnieje lub utworzy go w razie potrzeby. Pipeline Przesyła element do Experimentobiektu , tworząc Run obiekt, który będzie asynchronicznie uruchamiał potok. Funkcja wait_for_completion() blokuje działanie do momentu ukończenia przebiegu.

Sprawdzanie wyników potoku

Po zakończeniu run można pobrać PipelineData obiekty, które zostały przypisane do pipeline_output_nameobiektu . Możesz pobrać wyniki i załadować je do dalszego przetwarzania.

metrics_output_port = run.get_pipeline_output('metrics_output')
model_output_port = run.get_pipeline_output('model_output')

metrics_output_port.download('.', show_progress=True)
model_output_port.download('.', show_progress=True)

Pobrane pliki są zapisywane w podkatalogu azureml/{run.id}/. Plik metryk jest sformatowany w formacie JSON i można go przekonwertować na ramkę danych biblioteki Pandas w celu zbadania.

W przypadku przetwarzania lokalnego może być konieczne zainstalowanie odpowiednich pakietów, takich jak Pandas, Pickle, zestaw SDK usługi Azure Machine Edukacja itd. W tym przykładzie prawdopodobnie najlepszy model znaleziony przez zautomatyzowane uczenie maszynowe będzie zależeć od biblioteki XGBoost.

!pip install xgboost==0.90

import pandas as pd
import json

metrics_filename = metrics_output._path_on_datastore
# metrics_filename = path to downloaded file
with open(metrics_filename) as f:
   metrics_output_result = f.read()
   
deserialized_metrics_output = json.loads(metrics_output_result)
df = pd.DataFrame(deserialized_metrics_output)
df

Powyższy fragment kodu przedstawia plik metryk ładowany z lokalizacji w magazynie danych platformy Azure. Możesz również załadować go z pobranego pliku, jak pokazano w komentarzu. Po zdeserializowanym i przekonwertowaniu go na ramkę danych Biblioteki Pandas można zobaczyć szczegółowe metryki dla każdej iteracji kroku zautomatyzowanego uczenia maszynowego.

Plik modelu można zdeserializować w Model obiekt, którego można użyć do wnioskowania, dalszej analizy metryk itd.

import pickle

model_filename = model_output._path_on_datastore
# model_filename = path to downloaded file

with open(model_filename, "rb" ) as f:
    best_model = pickle.load(f)

# ... inferencing code not shown ...

Aby uzyskać więcej informacji na temat ładowania i pracy z istniejącymi modelami, zobacz Use an existing model with Azure Machine Edukacja (Używanie istniejącego modelu z usługą Azure Machine Edukacja).

Pobieranie wyników zautomatyzowanego przebiegu uczenia maszynowego

Jeśli korzystasz z tego artykułu, będziesz mieć wystąpienie run obiektu. Można jednak również pobrać ukończone Run obiekty z WorkspaceExperiment obiektu.

Obszar roboczy zawiera pełny rekord wszystkich eksperymentów i przebiegów. Możesz użyć portalu, aby znaleźć i pobrać dane wyjściowe eksperymentów lub użyć kodu. Aby uzyskać dostęp do rekordów z przebiegu historycznego, użyj usługi Azure Machine Edukacja, aby znaleźć identyfikator przebiegu, w którym cię interesujesz. Za pomocą tego identyfikatora można wybrać określoną wartość run za pomocą elementów Workspace i Experiment.

# Retrieved from Azure Machine Learning web UI
run_id = 'aaaaaaaa-bbbb-cccc-dddd-0123456789AB'
experiment = ws.experiments['titanic_automl']
run = next(run for run in ex.get_runs() if run.id == run_id)

Należy zmienić ciągi w powyższym kodzie na specyfikę przebiegu historycznego. Powyższy fragment kodu zakłada, że przypisano ws element do odpowiedniego Workspace elementu z normalnym from_config()elementem . Eksperyment zainteresowania jest pobierany bezpośrednio, a następnie kod znajduje Run zainteresowanie, pasując do run.id wartości.

Po utworzeniu Run obiektu możesz pobrać metryki i model.

automl_run = next(r for r in run.get_children() if r.name == 'AutoML_Classification')
outputs = automl_run.get_outputs()
metrics = outputs['default_metrics_AutoML_Classification']
model = outputs['default_model_AutoML_Classification']

metrics.get_port_data_reference().download('.')
model.get_port_data_reference().download('.')

Każdy Run obiekt zawiera StepRun obiekty zawierające informacje o przebiegu poszczególnych kroków potoku. Obiekt run jest wyszukiwany dla StepRunAutoMLStepobiektu . Metryki i model są pobierane przy użyciu ich nazw domyślnych, które są dostępne, nawet jeśli nie przekazujesz PipelineData obiektów do outputs parametru AutoMLStep.

Na koniec rzeczywiste metryki i model są pobierane na maszynę lokalną, zgodnie z opisem w powyższej sekcji "Sprawdzanie wyników potoku".

Następne kroki

Uruchom ten notes Jupyter z kompletnym przykładem zautomatyzowanego uczenia maszynowego w potoku , który używa regresji do przewidywania opłat za taksówkę
Tworzenie eksperymentów zautomatyzowanego uczenia maszynowego bez pisania kodu
Poznaj różne notesy Jupyter demonstrujące zautomatyzowane uczenie maszynowe
Przeczytaj o integracji potoku z kompleksowej metodyki MLOps lub zbadaj repozytorium GITHub metodyki MLOps