Wyświetlanie kodu trenowania zautomatyzowanego modelu uczenia maszynowego (wersja zapoznawcza)

DOTYCZY:Zestaw SDK języka Python w wersji 1

Ważne

Ta funkcja jest obecnie w publicznej wersji zapoznawczej. Ta wersja zapoznawcza jest udostępniana bez umowy dotyczącej poziomu usług i nie jest zalecana w przypadku obciążeń produkcyjnych. Niektóre funkcje mogą być nieobsługiwane lub ograniczone. Aby uzyskać więcej informacji, zobacz Uzupełniające warunki korzystania z wersji zapoznawczych platformy Microsoft Azure.

Z tego artykułu dowiesz się, jak wyświetlić wygenerowany kod trenowania na podstawie dowolnego zautomatyzowanego wytrenowanego modelu uczenia maszynowego.

Generowanie kodu dla zautomatyzowanych wytrenowanych modeli uczenia maszynowego umożliwia wyświetlenie następujących szczegółów, których zautomatyzowane uczenie maszynowe używa do trenowania i tworzenia modelu dla określonego przebiegu.

  • Przetwarzanie wstępne danych
  • Wybór algorytmu
  • Określanie cech
  • Hiperparametry

Możesz wybrać dowolny zautomatyzowany model trenowany przez uczenie maszynowe, zalecany lub podrzędny oraz wyświetlić wygenerowany kod szkoleniowy języka Python, który utworzył ten konkretny model.

Kod trenowania wygenerowanego modelu umożliwia:

  • Dowiedz się , jakiego procesu cechowania i hiperparametrów używa algorytm modelu.
  • Śledzenie/wersja/inspekcja wytrenowanych modeli. Przechowuj kod w wersji, aby śledzić, jakiego konkretnego kodu szkoleniowego używa się z modelem, który ma zostać wdrożony w środowisku produkcyjnym.
  • Dostosuj kod trenowania przez zmianę hiperparametrów lub zastosowanie umiejętności/doświadczenia w zakresie uczenia maszynowego i algorytmów oraz ponowne trenowanie nowego modelu przy użyciu dostosowanego kodu.

Kod dla eksperymentów zautomatyzowanego uczenia maszynowego można wygenerować przy użyciu klasyfikacji, regresji i prognozowania szeregów czasowych.

Ostrzeżenie

Modele przetwarzania obrazów i modele przetwarzania języka naturalnego w rozwiązaniu AutoML nie obsługują obecnie generowania kodu trenowania modelu.

Na poniższym diagramie pokazano, że można włączyć generowanie kodu dla dowolnego modelu utworzonego przez rozwiązanie AutoML na podstawie interfejsu użytkownika Azure Machine Learning studio lub zestawu SDK usługi Azure Machine Learning. Najpierw wybierz model. Wybrany model zostanie wyróżniony, a następnie usługa Azure Machine Learning kopiuje pliki kodu używane do tworzenia modelu i wyświetla je w folderze udostępnionym notesów. W tym miejscu możesz wyświetlać i dostosowywać kod zgodnie z potrzebami.

Zrzut ekranu przedstawiający kartę modele, a także wybrany model, jak wyjaśniono w powyższym tekście.

Wymagania wstępne

  • Obszar roboczy usługi Azure Machine Learning. Aby utworzyć obszar roboczy, zobacz Tworzenie zasobów obszaru roboczego.

  • W tym artykule przyjęto założenie, że znajomość konfigurowania eksperymentu zautomatyzowanego uczenia maszynowego. Postępuj zgodnie z samouczkiem lub instrukcjami, aby zobaczyć główne wzorce projektowania eksperymentów zautomatyzowanego uczenia maszynowego.

  • Automatyczne generowanie kodu uczenia maszynowego jest dostępne tylko dla eksperymentów uruchamianych na zdalnych docelowych obiektach obliczeniowych usługi Azure ML. Generowanie kodu nie jest obsługiwane w przypadku przebiegów lokalnych.

  • Aby włączyć generowanie kodu za pomocą zestawu SDK, dostępne są następujące opcje:

Generowanie kodu za pomocą zestawu SDK

Domyślnie każdy zautomatyzowany model trenowany przez uczenie maszynowe generuje kod trenowania po zakończeniu trenowania. Zautomatyzowane uczenie maszynowe zapisuje ten kod w eksperymentach outputs/generated_code dla tego konkretnego modelu. Można je wyświetlić w interfejsie użytkownika programu Azure ML Studio na karcie Dane wyjściowe i dzienniki wybranego modelu.

Możesz również jawnie włączyć generowanie kodu dla eksperymentów zautomatyzowanego uczenia maszynowego w obiekcie AutoMLConfig za pomocą parametru enable_code_generation=True . Ten parametr należy ustawić przed przesłaniem eksperymentu.

Upewnij się, że wywołujesz wywołanie experiment.submit() ze środowiska Conda zawierającego najnowszy zestaw AZURE ML SDK z automatycznym uczeniem maszynowym. Dzięki temu generowanie kodu jest wyzwalane prawidłowo dla eksperymentów uruchamianych w zdalnym obiekcie docelowym obliczeniowym.

config = AutoMLConfig( task="classification",
                       training_data=data,
                       label_column_name="label",
                       compute_target=compute_target,
                       enable_code_generation=True
                     )

W niektórych przypadkach rozwiązywania problemów warto wyłączyć generowanie kodu. Przed przesłaniem eksperymentu zautomatyzowanego uczenia maszynowego można wyłączyć generowanie kodu w AutoMLConfig obiekcie za pomocą parametru enable_code_generation=False .

# Disabling Code Generation
config = AutoMLConfig( task="classification", 
                       training_data=data,
                       label_column_name="label",
                       compute_target=compute_target,
                       enable_code_generation=False
                     )

Istnieją dwa główne pliki z wygenerowanym kodem:

  • script.py Jest to kod trenowania modelu, który prawdopodobnie chcesz przeanalizować za pomocą kroków cechowania, określonego używanego algorytmu i hiperparametrów.

  • script_run_notebook.ipynb Notes z kodem kociołowym umożliwiającym uruchamianie kodu szkoleniowego modelu (script.py) w usłudze AzureML za pomocą klas zestawu SDK usługi Azure ML, takich jak ScriptRunConfig.

Pobieranie wygenerowanego kodu i artefaktów modelu

Po zakończeniu przebiegu zautomatyzowanego trenowania uczenia maszynowego można pobrać script.py pliki i script_run_notebook.ipynb . Poniższy kod pobiera najlepszy przebieg podrzędny i pobiera oba pliki.


best_run = remote_run.get_best_child()

best_run.download_file("outputs/generated_code/script.py", "script.py")
best_run.download_file("outputs/generated_code/script_run_notebook.ipynb", "script_run_notebook.ipynb")

Możesz również wyświetlić wygenerowany kod i przygotować go do dostosowania kodu za pośrednictwem interfejsu użytkownika Azure Machine Learning studio.

W tym celu przejdź do karty Modele na nadrzędnej stronie uruchamiania eksperymentu zautomatyzowanego uczenia maszynowego. Po wybraniu jednego z wytrenowanych modeli możesz wybrać przycisk Wyświetl wygenerowany kod (wersja zapoznawcza). Ten przycisk przekierowuje Cię do rozszerzenia portalu Notesy , w którym można wyświetlać, edytować i uruchamiać wygenerowany kod dla danego wybranego modelu.

przycisk generowania kodu w widoku karty nadrzędnych modeli uruchamiania

Alternatywnie możesz również uzyskać dostęp do wygenerowanego kodu modelu w górnej części strony przebiegu podrzędnego po przejściu do strony tego przebiegu podrzędnego określonego modelu.

podrzędny przycisk wygenerowanego kodu w widoku strony przebiegu podrzędnego

script.py

Plik script.py zawiera podstawową logikę wymaganą do wytrenowania modelu przy użyciu wcześniej używanych hiperparametrów. Chociaż ma być wykonywane w kontekście uruchomienia skryptu usługi Azure ML, z pewnymi modyfikacjami kod trenowania modelu może być również uruchamiany autonomicznie we własnym środowisku lokalnym.

Skrypt można podzielić na kilka następujących części: ładowanie danych, przygotowywanie danych, cechowanie danych, preprocesor/specyfikacja algorytmu i trenowanie.

Ładowanie danych

Funkcja get_training_dataset() ładuje wcześniej używany zestaw danych. Przyjęto założenie, że skrypt jest uruchamiany w skrypsie usługi AzureML uruchamianym w tym samym obszarze roboczym co oryginalny eksperyment.

def get_training_dataset(dataset_id):
    from azureml.core.dataset import Dataset
    from azureml.core.run import Run
    
    logger.info("Running get_training_dataset")
    ws = Run.get_context().experiment.workspace
    dataset = Dataset.get_by_id(workspace=ws, id=dataset_id)
    return dataset.to_pandas_dataframe()

Podczas uruchamiania skryptu Run.get_context().experiment.workspace program pobiera prawidłowy obszar roboczy. Jeśli jednak ten skrypt jest uruchamiany wewnątrz innego obszaru roboczego lub jest uruchamiany lokalnie bez użycia ScriptRunConfigpolecenia , należy zmodyfikować skrypt w celu jawnego określenia odpowiedniego obszaru roboczego.

Po pobraniu obszaru roboczego oryginalny zestaw danych jest pobierany przez jego identyfikator. Inny zestaw danych o dokładnie tej samej strukturze może być również określony przez identyfikator lub nazwę odpowiednio z wartością get_by_id() lub get_by_name(). Identyfikator można znaleźć w dalszej części skryptu w podobnej sekcji, jak w poniższym kodzie.

if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument('--training_dataset_id', type=str, default='xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxx', help='Default training dataset id is populated from the parent run')
    args = parser.parse_args()
    
    main(args.training_dataset_id)

Możesz również zastąpić tę całą funkcję własnym mechanizmem ładowania danych; Jedynymi ograniczeniami jest to, że wartość zwracana musi być ramką danych Pandas i że dane muszą mieć taki sam kształt jak w oryginalnym eksperymencie.

Kod przygotowywania danych

Funkcja prepare_data() czyści dane, dzieli funkcję i przykładową wagę kolumn i przygotowuje dane do użycia w trenowaniu. Ta funkcja może się różnić w zależności od typu zestawu danych i typu zadania eksperymentu: klasyfikacja, regresja lub prognozowanie szeregów czasowych.

Poniższy przykład pokazuje, że ogólnie ramka danych z kroku ładowania danych jest przekazywana. Kolumna etykiety i wagi próbek, jeśli zostały pierwotnie określone, są wyodrębniane, a wiersze zawierające NaN są porzucane z danych wejściowych.

def prepare_data(dataframe):
    from azureml.training.tabular.preprocessing import data_cleaning
    
    logger.info("Running prepare_data")
    label_column_name = 'y'
    
    # extract the features, target and sample weight arrays
    y = dataframe[label_column_name].values
    X = dataframe.drop([label_column_name], axis=1)
    sample_weights = None
    X, y, sample_weights = data_cleaning._remove_nan_rows_in_X_y(X, y, sample_weights,
     is_timeseries=False, target_column=label_column_name)
    
    return X, y, sample_weights

Jeśli chcesz wykonać dodatkowe przygotowywanie danych, można to zrobić w tym kroku, dodając niestandardowy kod przygotowywania danych.

Kod cechowania danych

Funkcja generate_data_transformation_config() określa krok cechowania w końcowym potoku scikit-learn. Cechatory z oryginalnego eksperymentu są odtwarzane tutaj wraz z ich parametrami.

Na przykład możliwe przekształcenia danych, które mogą wystąpić w tej funkcji, mogą być oparte na imputerach, takich jak i , lub transformatory, SimpleImputer() takie jak StringCastTransformer() i CatImputer()LabelEncoderTransformer().

Poniżej przedstawiono transformator typu StringCastTransformer() , który może służyć do przekształcania zestawu kolumn. W tym przypadku zestaw wskazuje column_nameswartość .

def get_mapper_c6ba98(column_names):
    # ... Multiple imports to package dependencies, removed for simplicity ...
    
    definition = gen_features(
        columns=column_names,
        classes=[
            {
                'class': StringCastTransformer,
            },
            {
                'class': CountVectorizer,
                'analyzer': 'word',
                'binary': True,
                'decode_error': 'strict',
                'dtype': numpy.uint8,
                'encoding': 'utf-8',
                'input': 'content',
                'lowercase': True,
                'max_df': 1.0,
                'max_features': None,
                'min_df': 1,
                'ngram_range': (1, 1),
                'preprocessor': None,
                'stop_words': None,
                'strip_accents': None,
                'token_pattern': '(?u)\\b\\w\\w+\\b',
                'tokenizer': wrap_in_lst,
                'vocabulary': None,
            },
        ]
    )
    mapper = DataFrameMapper(features=definition, input_df=True, sparse=True)
    
    return mapper

Należy pamiętać, że jeśli masz wiele kolumn, które muszą mieć zastosowaną tę samą cechę/transformację (na przykład 50 kolumn w kilku grupach kolumn), te kolumny są obsługiwane przez grupowanie na podstawie typu.

W poniższym przykładzie zwróć uwagę, że każda grupa ma zastosowany unikatowy maper. Ten maper jest następnie stosowany do każdej z kolumn tej grupy.

def generate_data_transformation_config():
    from sklearn.pipeline import FeatureUnion
    
    column_group_1 = [['id'], ['ps_reg_01'], ['ps_reg_02'], ['ps_reg_03'], ['ps_car_11_cat'], ['ps_car_12'], ['ps_car_13'], ['ps_car_14'], ['ps_car_15'], ['ps_calc_01'], ['ps_calc_02'], ['ps_calc_03']]
    
    column_group_2 = ['ps_ind_06_bin', 'ps_ind_07_bin', 'ps_ind_08_bin', 'ps_ind_09_bin', 'ps_ind_10_bin', 'ps_ind_11_bin', 'ps_ind_12_bin', 'ps_ind_13_bin', 'ps_ind_16_bin', 'ps_ind_17_bin', 'ps_ind_18_bin', 'ps_car_08_cat', 'ps_calc_15_bin', 'ps_calc_16_bin', 'ps_calc_17_bin', 'ps_calc_18_bin', 'ps_calc_19_bin', 'ps_calc_20_bin']
    
    column_group_3 = ['ps_ind_01', 'ps_ind_02_cat', 'ps_ind_03', 'ps_ind_04_cat', 'ps_ind_05_cat', 'ps_ind_14', 'ps_ind_15', 'ps_car_01_cat', 'ps_car_02_cat', 'ps_car_03_cat', 'ps_car_04_cat', 'ps_car_05_cat', 'ps_car_06_cat', 'ps_car_07_cat', 'ps_car_09_cat', 'ps_car_10_cat', 'ps_car_11', 'ps_calc_04', 'ps_calc_05', 'ps_calc_06', 'ps_calc_07', 'ps_calc_08', 'ps_calc_09', 'ps_calc_10', 'ps_calc_11', 'ps_calc_12', 'ps_calc_13', 'ps_calc_14']
    
    feature_union = FeatureUnion([
        ('mapper_ab1045', get_mapper_ab1045(column_group_1)),
        ('mapper_c6ba98', get_mapper_c6ba98(column_group_3)),
        ('mapper_9133f9', get_mapper_9133f9(column_group_2)),
    ])
    return feature_union

Takie podejście umożliwia użycie bardziej usprawnionego kodu, nie mając bloku kodu funkcji przekształcania dla każdej kolumny, co może być szczególnie kłopotliwe, nawet jeśli masz dziesiątki lub setki kolumn w zestawie danych.

W przypadku zadań klasyfikacji i regresji [FeatureUnion] jest używany do cech. W przypadku modeli prognozowania szeregów czasowych wiele cech obsługujących szeregi czasowe jest zbieranych do potoku TimeSeriesTransformerscikit-learn, a następnie opakowane w element . Każdy użytkownik dostarczył cechowania dla modeli prognozowania szeregów czasowych przed tymi dostarczonymi przez zautomatyzowane uczenie maszynowe.

Kod specyfikacji preprocesora

Funkcja generate_preprocessor_config(), jeśli istnieje, określa krok przetwarzania wstępnego, który ma zostać wykonany po cechowaniu w końcowym potoku scikit-learn.

Zwykle ten krok przetwarzania wstępnego składa się tylko z standaryzacji/normalizacji danych, która jest realizowana za pomocą sklearn.preprocessingpolecenia .

Zautomatyzowane uczenie maszynowe określa tylko krok przetwarzania wstępnego dla modeli klasyfikacji i regresji bez zespołu.

Oto przykład wygenerowanego kodu preprocesora:

def generate_preprocessor_config():
    from sklearn.preprocessing import MaxAbsScaler
    
    preproc = MaxAbsScaler(
        copy=True
    )
    
    return preproc

Kod specyfikacji algorytmu i hiperparametrów

Kod specyfikacji algorytmu i hiperparametrów jest prawdopodobnie najbardziej zainteresowany przez wielu specjalistów uczenia maszynowego.

Funkcja generate_algorithm_config() określa rzeczywisty algorytm i hiperparametry do trenowania modelu jako ostatni etap końcowego potoku scikit-learn.

W poniższym przykładzie użyto algorytmu XGBoostClassifier z określonymi hiperparametrami.

def generate_algorithm_config():
    from xgboost.sklearn import XGBClassifier
    
    algorithm = XGBClassifier(
        base_score=0.5,
        booster='gbtree',
        colsample_bylevel=1,
        colsample_bynode=1,
        colsample_bytree=1,
        gamma=0,
        learning_rate=0.1,
        max_delta_step=0,
        max_depth=3,
        min_child_weight=1,
        missing=numpy.nan,
        n_estimators=100,
        n_jobs=-1,
        nthread=None,
        objective='binary:logistic',
        random_state=0,
        reg_alpha=0,
        reg_lambda=1,
        scale_pos_weight=1,
        seed=None,
        silent=None,
        subsample=1,
        verbosity=0,
        tree_method='auto',
        verbose=-10
    )
    
    return algorithm

Wygenerowany kod w większości przypadków używa pakietów i klas oprogramowania open source (OSS). Istnieją wystąpienia, w których klasy otoki pośredniej są używane do uproszczenia bardziej złożonego kodu. Można na przykład zastosować klasyfikator XGBoost i inne powszechnie używane biblioteki, takie jak LightGBM lub Scikit-Learn algorytmy.

Jako specjalista ML możesz dostosować kod konfiguracji tego algorytmu, dostosowując jego hiperparametry zgodnie z potrzebami na podstawie swoich umiejętności i doświadczenia w zakresie tego algorytmu i konkretnego problemu uczenia maszynowego.

W przypadku modeli generate_preprocessor_config_N() grupowych (w razie potrzeby) i generate_algorithm_config_N() są definiowane dla każdego ucznia w modelu zespołowym, gdzie N reprezentuje umieszczanie każdego ucznia na liście modelu zespołu. W przypadku modeli zespołów stosu metauczeń generate_algorithm_config_meta() jest definiowany.

End to end training code (Zakończenie trenowania kodu)

Generowanie kodu emituje build_model_pipeline() i train_model() do definiowania potoku scikit-learn oraz do wywoływania fit() go odpowiednio.

def build_model_pipeline():
    from sklearn.pipeline import Pipeline
    
    logger.info("Running build_model_pipeline")
    pipeline = Pipeline(
        steps=[
            ('featurization', generate_data_transformation_config()),
            ('preproc', generate_preprocessor_config()),
            ('model', generate_algorithm_config()),
        ]
    )
    
    return pipeline

Potok scikit-learn zawiera krok cechowania, preprocesor (jeśli jest używany) oraz algorytm lub model.

W przypadku modeli prognozowania szeregów czasowych potok scikit-learn jest owinięty w element , który ma dodatkową ForecastingPipelineWrapperlogikę potrzebną do prawidłowego obsługi danych szeregów czasowych w zależności od zastosowanego algorytmu. W przypadku wszystkich typów zadań używamy PipelineWithYTransformer w przypadkach, w których kolumna etykiety musi być zakodowana.

Po utworzeniu potoku scikit-Learn wystarczy wywołać metodę fit() trenowania modelu:

def train_model(X, y, sample_weights):
    
    logger.info("Running train_model")
    model_pipeline = build_model_pipeline()
    
    model = model_pipeline.fit(X, y)
    return model

Wartość zwracana z train_model() klasy to model dopasowany/wytrenowany na danych wejściowych.

Główny kod, który uruchamia wszystkie poprzednie funkcje, jest następujący:

def main(training_dataset_id=None):
    from azureml.core.run import Run
    
    # The following code is for when running this code as part of an AzureML script run.
    run = Run.get_context()
    setup_instrumentation(run)
    
    df = get_training_dataset(training_dataset_id)
    X, y, sample_weights = prepare_data(df)
    split_ratio = 0.1
    try:
        (X_train, y_train, sample_weights_train), (X_valid, y_valid, sample_weights_valid) = split_dataset(X, y, sample_weights, split_ratio, should_stratify=True)
    except Exception:
        (X_train, y_train, sample_weights_train), (X_valid, y_valid, sample_weights_valid) = split_dataset(X, y, sample_weights, split_ratio, should_stratify=False)

    model = train_model(X_train, y_train, sample_weights_train)
    
    metrics = calculate_metrics(model, X, y, sample_weights, X_test=X_valid, y_test=y_valid)
    
    print(metrics)
    for metric in metrics:
        run.log(metric, metrics[metric])

Po wytrenowanym modelu można go użyć do przewidywania za pomocą metody predict(). Jeśli eksperyment dotyczy modelu szeregów czasowych, użyj metody forecast() dla przewidywań.

y_pred = model.predict(X)

Na koniec model jest serializowany i zapisywany jako .pkl plik o nazwie "model.pkl":

    with open('model.pkl', 'wb') as f:
        pickle.dump(model, f)
    run.upload_file('outputs/model.pkl', 'model.pkl')

script_run_notebook.ipynb

Notes script_run_notebook.ipynb służy jako łatwy sposób wykonywania w script.py obliczeniach usługi Azure ML. Ten notes jest podobny do istniejących notesów przykładowych zautomatyzowanego uczenia maszynowego, jednak istnieje kilka kluczowych różnic, jak wyjaśniono w poniższych sekcjach.

Środowisko

Zazwyczaj środowisko szkoleniowe dla zautomatyzowanego przebiegu uczenia maszynowego jest automatycznie ustawiane przez zestaw SDK. Jednak w przypadku uruchamiania skryptu niestandardowego, takiego jak wygenerowany kod, zautomatyzowane uczenie maszynowe nie prowadzi już procesu, dlatego należy określić środowisko, aby uruchomienie skryptu zakończyło się pomyślnie.

Generowanie kodu ponownie używa środowiska używanego w oryginalnym zautomatyzowanym eksperymencie uczenia maszynowego, jeśli jest to możliwe. Gwarantuje to, że uruchomienie skryptu trenowania nie zakończy się niepowodzeniem z powodu brakujących zależności i ma korzyść po stronie, która nie wymaga ponownego kompilowania obrazu platformy Docker, co pozwala zaoszczędzić czas i zasoby obliczeniowe.

Jeśli wprowadzisz zmiany script.py , które wymagają dodatkowych zależności lub chcesz użyć własnego środowiska, musisz odpowiednio zaktualizować komórkę Create environmentscript_run_notebook.ipynb .

Aby uzyskać więcej informacji na temat środowisk AzureML, zobacz dokumentację klas środowiska.

Przesyłanie eksperymentu

Ponieważ wygenerowany kod nie jest już oparty na zautomatyzowanym uczeniu maszynowym, zamiast tworzyć element AutoMLConfig , a następnie przekazywać go do experiment.submit()elementu , należy utworzyć ScriptRunConfig kod i podać do niego wygenerowany kod (script.py).

Poniższy przykład zawiera parametry i regularne zależności wymagane do uruchomienia ScriptRunConfigpolecenia , takie jak obliczenia, środowisko itp. Aby uzyskać więcej informacji na temat korzystania ze skryptuRunConfig, zobacz Konfigurowanie i przesyłanie przebiegów trenowania.

from azureml.core import ScriptRunConfig

src = ScriptRunConfig(source_directory=project_folder, 
                      script='script.py', 
                      compute_target=cpu_cluster, 
                      environment=myenv,
                      docker_runtime_config=docker_config)
 
run = experiment.submit(config=src)

Pobieranie i ładowanie serializowanego wytrenowanego modelu w pamięci

Po wytrenowanym modelu można zapisać/serializować go w .pkl pliku za pomocą pickle.dump() elementów i pickle.load(). Można również użyć funkcji joblib.dump() i joblib.load().

W poniższym przykładzie przedstawiono sposób pobierania i ładowania modelu w pamięci, który został wytrenowany w usłudze AzureML compute za pomocą polecenia ScriptRunConfig. Ten kod można uruchomić w tym samym notesie, w którym użyto zestawu Azure ML SDK ScriptRunConfig.

import joblib

# Load the fitted model from the script run.

# Note that if training dependencies are not installed on the machine
# this notebook is being run from, this step can fail.
try:
    # Download the model from the run in the Workspace
    run.download_file("outputs/model.pkl", "model.pkl")

    # Load the model into memory
    model = joblib.load("model.pkl")

except ImportError:
    print('Required dependencies are missing; please run pip install azureml-automl-runtime.')
    raise

Przewidywanie za pomocą modelu w pamięci

Na koniec możesz załadować dane testowe w ramce danych biblioteki Pandas i użyć modelu do przewidywania.

import os
import numpy as np
import pandas as pd

DATA_DIR = "."
filepath = os.path.join(DATA_DIR, 'porto_seguro_safe_driver_test_dataset.csv')

test_data_df = pd.read_csv(filepath)

print(test_data_df.shape)
test_data_df.head(5)

#test_data_df is a Pandas dataframe with test data
y_predictions = model.predict(test_data_df)

W wystąpieniu obliczeniowym usługi Azure ML masz wszystkie zależności zautomatyzowanego uczenia maszynowego, więc możesz załadować model i przewidzieć go z dowolnego notesu w niedawno utworzonym wystąpieniu obliczeniowym.

Jednak aby załadować ten model w notesie w niestandardowym lokalnym środowisku Conda, należy mieć wszystkie zależności pochodzące ze środowiska używanego podczas trenowania (środowisko AutoML).

Następne kroki