Używanie zautomatyzowanego uczenia maszynowego w potoku usługi Azure Machine Learning w języku Python
DOTYCZY: Zestaw SDK języka Python w wersji 1
Funkcja zautomatyzowanego uczenia maszynowego w usłudze Azure Machine Learning 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 Learning można tworzyć możliwe do wdrożenia przepływy pracy, które umożliwiają szybkie odnajdywanie algorytmu, który najlepiej sprawdza się w przypadku 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 Learning już dziś.
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 AutoMLStep
ten 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 AutoMLStep
PipelineOutputTabularDataset
, 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 StepRun
dla 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 Learning. 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 loguje się do obszaru roboczego usługi Azure Machine Learning zdefiniowanego w 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_ds
elementu .
Konfigurowanie magazynu i docelowego obiektu obliczeniowego
Dodatkowe zasoby potrzebne w potoku to magazyn i, ogólnie rzecz biorąc, zasoby obliczeniowe usługi Azure Machine Learning.
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 docelowy obiekt 'cpu-cluster'
obliczeniowy usługi Azure Machine Learning 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 DataFrame
i 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 AutoMLConfig
run_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 type
TrainingOutput
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 ustawionyclassification
na wartość dla tego przykładu. Inne prawidłowe wartości toregression
iforecasting
path
idebug_log
opisz ścieżkę do projektu i plik lokalny, do którego zostaną zapisane informacje debugowaniacompute_target
jest wcześniej zdefiniowanycompute_target
, że w tym przykładzie jest niedrogim komputerem opartym na procesorze CPU. Jeśli używasz obiektów uczenia głębokiego rozwiązania AutoML, chcesz zmienić docelowy obiekt obliczeniowy na oparty na procesorze GPUfeaturization
jest ustawiona naauto
wartość . Więcej szczegółów można znaleźć w sekcji Cechowanie danych w dokumencie automatycznej konfiguracji uczenia maszynowegolabel_column_name
wskazuje, która kolumna jest zainteresowana przewidywaniemtraining_data
jest ustawionaOutputTabularDatasetConfig
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 Run
element . 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 Learning 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 Experiment
obiektu , 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_name
obiektu . 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 Learning 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 Używanie istniejącego modelu z usługą Azure Machine Learning.
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 Workspace
Experiment
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 Learning, aby znaleźć identyfikator przebiegu, w którym cię interesują. 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 StepRun
AutoMLStep
obiektu . 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