Samouczek: tworzenie potoków uczenia maszynowego w środowisku produkcyjnym

DOTYCZY: Zestaw PYTHON SDK azure-ai-ml w wersji 2 (bieżąca)

Uwaga

Aby zapoznać się z samouczkiem korzystającym z zestawu SDK w wersji 1 do kompilowania potoku, zobacz Samouczek: tworzenie potoku usługi Azure Machine Learning na potrzeby klasyfikacji obrazów

Podstawowym elementem potoku uczenia maszynowego jest podzielenie pełnego zadania uczenia maszynowego na wieloetapowy przepływ pracy. Każdy krok jest zarządzanym składnikiem, który można opracowywać, optymalizować, konfigurować i zautomatyzować osobno. Kroki są połączone za pośrednictwem dobrze zdefiniowanych interfejsów. Usługa potoku azure Machine Learning automatycznie organizuje wszystkie zależności między krokami potoku. Korzyści wynikające z używania potoku są ustandaryzowane w praktyce metodyki MLOps, skalowalna współpraca zespołowa, efektywność trenowania i obniżenie kosztów. Aby dowiedzieć się więcej o zaletach potoków, zobacz Co to są potoki usługi Azure Machine Learning.

W tym samouczku użyjesz usługi Azure Machine Learning do utworzenia produkcyjnego gotowego projektu uczenia maszynowego przy użyciu zestawu SDK języka Python usługi Azure Machine Learning w wersji 2.

Oznacza to, że będziesz w stanie wykorzystać zestaw SDK języka Python usługi Azure Machine Learning do:

• Uzyskiwanie dojścia do obszaru roboczego usługi Azure Machine Learning
• Tworzenie zasobów danych usługi Azure Machine Learning
• Tworzenie składników usługi Azure Machine Learning wielokrotnego użytku
• Tworzenie, weryfikowanie i uruchamianie potoków usługi Azure Machine Learning

W tym samouczku utworzysz potok usługi Azure Machine Learning, aby wytrenować model na potrzeby przewidywania domyślnego środków. Potok obsługuje dwa kroki:

1. Przygotowywanie danych
2. Trenowanie i rejestrowanie wytrenowanego modelu

Następny obraz przedstawia prosty potok, który będzie widoczny w programie Azure Studio po przesłaniu.

Dwa kroki to pierwsze przygotowanie danych i drugie szkolenie.

W tym filmie wideo pokazano, jak rozpocząć pracę w usłudze Azure Machine Learning Studio, aby można było wykonać kroki opisane w samouczku. W filmie wideo pokazano, jak utworzyć notes, utworzyć wystąpienie obliczeniowe i sklonować notes. Kroki zostały również opisane w poniższych sekcjach.

Wymagania wstępne

1. Aby korzystać z usługi Azure Machine Learning, potrzebny jest obszar roboczy. Jeśli go nie masz, ukończ tworzenie zasobów, aby rozpocząć tworzenie obszaru roboczego i dowiedz się więcej na temat korzystania z niego.

2. Zaloguj się do programu Studio i wybierz swój obszar roboczy, jeśli jeszcze nie jest otwarty.

3. Ukończ samouczek Przekazywanie, uzyskiwanie dostępu do danych i eksplorowanie ich w celu utworzenia zasobu danych potrzebnego w tym samouczku. Upewnij się, że uruchomiono cały kod, aby utworzyć początkowy zasób danych. Zapoznaj się z danymi i popraw je, jeśli chcesz, ale będziesz potrzebować tylko początkowych danych w tym samouczku.

4. Otwórz lub utwórz notes w obszarze roboczym:

   • Jeśli chcesz skopiować i wkleić kod do komórek, utwórz nowy notes.
   • Możesz też otworzyć plik tutorials/get-started-notebooks/pipeline.ipynb z sekcji Przykłady programu Studio. Następnie wybierz pozycję Klonuj, aby dodać notes do plików. Aby znaleźć przykładowe notesy, zobacz Learn from sample notebooks (Informacje na podstawie przykładowych notesów).

Ustawianie jądra i otwieranie go w programie Visual Studio Code (VS Code)

1. Na górnym pasku powyżej otwartego notesu utwórz wystąpienie obliczeniowe, jeśli jeszcze go nie masz.

   

2. Jeśli wystąpienie obliczeniowe zostanie zatrzymane, wybierz pozycję Uruchom obliczenia i zaczekaj na jego uruchomienie.

   

3. Poczekaj na uruchomienie wystąpienia obliczeniowego. Następnie upewnij się, że jądro znajdujące się w prawym górnym rogu ma wartość Python 3.10 - SDK v2. Jeśli nie, użyj listy rozwijanej, aby wybrać to jądro.

   

   Jeśli to jądro nie jest widoczne, sprawdź, czy wystąpienie obliczeniowe jest uruchomione. Jeśli tak jest, wybierz przycisk Odśwież w prawym górnym rogu notesu.

4. Jeśli zostanie wyświetlony baner z informacją o konieczności uwierzytelnienia, wybierz pozycję Uwierzytelnij.

5. Możesz uruchomić notes tutaj lub otworzyć go w programie VS Code w celu uzyskania pełnego zintegrowanego środowiska projektowego (IDE) z możliwościami zasobów usługi Azure Machine Learning. Wybierz pozycję Otwórz w programie VS Code, a następnie wybierz opcję internetową lub klasyczną. Po uruchomieniu w ten sposób program VS Code jest dołączony do wystąpienia obliczeniowego, jądra i systemu plików obszaru roboczego.

   

Ważne

W pozostałej części tego samouczka znajdują się komórki notesu samouczka. Skopiuj je i wklej do nowego notesu lub przejdź do notesu teraz, jeśli go sklonujesz.

Konfigurowanie zasobów potoku

Platformę Azure Machine Learning można używać z poziomu interfejsu wiersza polecenia, zestawu SDK języka Python lub interfejsu studio. W tym przykładzie użyjesz zestawu SDK języka Python usługi Azure Machine Learning w wersji 2 do utworzenia potoku.

Przed utworzeniem potoku potrzebne są następujące zasoby:

• Zasób danych na potrzeby trenowania
• Środowisko oprogramowania do uruchamiania potoku
• Zasób obliczeniowy, do którego jest uruchamiane zadanie

Tworzenie dojścia do obszaru roboczego

Zanim przejdziemy do kodu, musisz odwołać się do obszaru roboczego. Utworzysz ml_client dojście do obszaru roboczego. Następnie użyjesz narzędzia ml_client do zarządzania zasobami i zadaniami.

W następnej komórce wprowadź identyfikator subskrypcji, nazwę grupy zasobów i nazwę obszaru roboczego. Aby znaleźć następujące wartości:

1. Na pasku narzędzi usługi Azure Machine Learning Studio w prawym górnym rogu wybierz nazwę obszaru roboczego.
2. Skopiuj wartość obszaru roboczego, grupy zasobów i identyfikatora subskrypcji do kodu.
3. Musisz skopiować jedną wartość, zamknąć obszar i wkleić, a następnie wrócić do następnego.

from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential

# authenticate
credential = DefaultAzureCredential()

SUBSCRIPTION = "<SUBSCRIPTION_ID>"
RESOURCE_GROUP = "<RESOURCE_GROUP>"
WS_NAME = "<AML_WORKSPACE_NAME>"
# Get a handle to the workspace
ml_client = MLClient(
    credential=credential,
    subscription_id=SUBSCRIPTION,
    resource_group_name=RESOURCE_GROUP,
    workspace_name=WS_NAME,
)

Uwaga

Utworzenie klasy MLClient nie spowoduje nawiązania połączenia z obszarem roboczym. Inicjowanie klienta jest leniwe, będzie czekać po raz pierwszy, aby wykonać wywołanie (nastąpi to w następnej komórce kodu).

Zweryfikuj połączenie, wykonując wywołanie metody ml_client. Ponieważ jest to pierwszy raz, gdy wykonujesz wywołanie obszaru roboczego, może zostać wyświetlony monit o uwierzytelnienie.

# Verify that the handle works correctly.
# If you ge an error here, modify your SUBSCRIPTION, RESOURCE_GROUP, and WS_NAME in the previous cell.
ws = ml_client.workspaces.get(WS_NAME)
print(ws.location, ":", ws.resource_group)

Uzyskiwanie dostępu do zarejestrowanego zasobu danych

Zacznij od pobrania danych, które zostały wcześniej zarejestrowane w artykule Samouczek: przekazywanie, uzyskiwanie dostępu do danych i eksplorowanie ich w usłudze Azure Machine Learning.

• Usługa Azure Machine Learning używa Data obiektu do rejestrowania definicji danych wielokrotnego użytku i korzystania z danych w potoku.

# get a handle of the data asset and print the URI
credit_data = ml_client.data.get(name="credit-card", version="initial")
print(f"Data asset URI: {credit_data.path}")

Tworzenie środowiska zadań dla kroków potoku

Do tej pory utworzono środowisko programistyczne na wystąpieniu obliczeniowym, maszynie dewelopera. Potrzebne jest również środowisko do użycia dla każdego kroku potoku. Każdy krok może mieć własne środowisko lub można użyć niektórych typowych środowisk na potrzeby wielu kroków.

W tym przykładzie utworzysz środowisko conda dla zadań przy użyciu pliku yaml conda. Najpierw utwórz katalog do przechowywania pliku.

import os

dependencies_dir = "./dependencies"
os.makedirs(dependencies_dir, exist_ok=True)

Teraz utwórz plik w katalogu dependencies.

%%writefile {dependencies_dir}/conda.yaml
name: model-env
channels:
  - conda-forge
dependencies:
  - python=3.8
  - numpy=1.21.2
  - pip=21.2.4
  - scikit-learn=0.24.2
  - scipy=1.7.1
  - pandas>=1.1,<1.2
  - pip:
    - inference-schema[numpy-support]==1.3.0
    - xlrd==2.0.1
    - mlflow== 2.4.1
    - azureml-mlflow==1.51.0

Specyfikacja zawiera kilka zwykłych pakietów używanych w potoku (numpy,) wraz z niektórymi pakietami specyficznymi dla usługi Azure Machine Learning (azureml-mlflow).

Pakiety usługi Azure Machine Learning nie są obowiązkowe do uruchamiania zadań usługi Azure Machine Learning. Jednak dodanie tych pakietów pozwala na interakcję z usługą Azure Machine Learning na potrzeby rejestrowania metryk i rejestrowania modeli— wszystko to w ramach zadania usługi Azure Machine Learning. Będą one używane w skrygcie szkoleniowym w dalszej części tego samouczka.

Użyj pliku yaml, aby utworzyć i zarejestrować to środowisko niestandardowe w obszarze roboczym:

from azure.ai.ml.entities import Environment

custom_env_name = "aml-scikit-learn"

pipeline_job_env = Environment(
    name=custom_env_name,
    description="Custom environment for Credit Card Defaults pipeline",
    tags={"scikit-learn": "0.24.2"},
    conda_file=os.path.join(dependencies_dir, "conda.yaml"),
    image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest",
    version="0.2.0",
)
pipeline_job_env = ml_client.environments.create_or_update(pipeline_job_env)

print(
    f"Environment with name {pipeline_job_env.name} is registered to workspace, the environment version is {pipeline_job_env.version}"
)

Tworzenie potoku trenowania

Teraz, gdy masz wszystkie zasoby wymagane do uruchomienia potoku, nadszedł czas na skompilowanie samego potoku.

Potoki usługi Azure Machine Learning to przepływy pracy uczenia maszynowego wielokrotnego użytku, które zwykle składają się z kilku składników. Typowy okres eksploatacji składnika to:

• Napisz specyfikację yaml składnika lub utwórz go programowo przy użyciu polecenia ComponentMethod.
• Opcjonalnie zarejestruj składnik przy użyciu nazwy i wersji w obszarze roboczym, aby można go było ponownie używać i udostępniać.
• Załaduj ten składnik z kodu potoku.
• Zaimplementuj potok przy użyciu danych wejściowych, wyjściowych i parametrów składnika.
• Prześlij potok.

Istnieją dwa sposoby tworzenia definicji składnika, programowego i yaml. W kolejnych dwóch sekcjach opisano tworzenie składnika na oba sposoby. Możesz utworzyć oba składniki, próbując użyć obu opcji, lub wybrać preferowaną metodę.

Uwaga

W tym samouczku dla uproszczenia używamy tych samych obliczeń dla wszystkich składników. Można jednak ustawić różne obliczenia dla każdego składnika, na przykład dodając wiersz, taki jak train_step.compute = "cpu-cluster". Aby wyświetlić przykład tworzenia potoku z różnymi obliczeniami dla każdego składnika, zobacz sekcję Podstawowe zadanie potoku w samouczku dotyczącym potoku cifar-10.

Tworzenie składnika 1: przygotowywanie danych (przy użyciu definicji programowej)

Zacznijmy od utworzenia pierwszego składnika. Ten składnik obsługuje wstępne przetwarzanie danych. Zadanie przetwarzania wstępnego jest wykonywane w pliku data_prep.py Python.

Najpierw utwórz folder źródłowy dla składnika data_prep:

import os

data_prep_src_dir = "./components/data_prep"
os.makedirs(data_prep_src_dir, exist_ok=True)

Ten skrypt wykonuje proste zadanie dzielenia danych na zestawy danych trenowania i testowania. Usługa Azure Machine Learning instaluje zestawy danych jako foldery do obliczeń, dlatego utworzyliśmy funkcję pomocniczą select_first_file w celu uzyskania dostępu do pliku danych w zainstalowanym folderze wejściowym.

Usługa MLFlow służy do rejestrowania parametrów i metryk podczas uruchamiania potoku.

%%writefile {data_prep_src_dir}/data_prep.py
import os
import argparse
import pandas as pd
from sklearn.model_selection import train_test_split
import logging
import mlflow


def main():
    """Main function of the script."""

    # input and output arguments
    parser = argparse.ArgumentParser()
    parser.add_argument("--data", type=str, help="path to input data")
    parser.add_argument("--test_train_ratio", type=float, required=False, default=0.25)
    parser.add_argument("--train_data", type=str, help="path to train data")
    parser.add_argument("--test_data", type=str, help="path to test data")
    args = parser.parse_args()

    # Start Logging
    mlflow.start_run()

    print(" ".join(f"{k}={v}" for k, v in vars(args).items()))

    print("input data:", args.data)

    credit_df = pd.read_csv(args.data, header=1, index_col=0)

    mlflow.log_metric("num_samples", credit_df.shape[0])
    mlflow.log_metric("num_features", credit_df.shape[1] - 1)

    credit_train_df, credit_test_df = train_test_split(
        credit_df,
        test_size=args.test_train_ratio,
    )

    # output paths are mounted as folder, therefore, we are adding a filename to the path
    credit_train_df.to_csv(os.path.join(args.train_data, "data.csv"), index=False)

    credit_test_df.to_csv(os.path.join(args.test_data, "data.csv"), index=False)

    # Stop Logging
    mlflow.end_run()


if __name__ == "__main__":
    main()

Teraz, gdy masz skrypt, który może wykonać żądane zadanie, utwórz na jego podstawie składnik usługi Azure Machine Learning.

Użyj ogólnego przeznaczenia CommandComponent , które mogą uruchamiać akcje wiersza polecenia. Ta akcja wiersza polecenia może bezpośrednio wywoływać polecenia systemowe lub uruchamiać skrypt. Dane wejściowe/wyjściowe są określane w wierszu polecenia za pośrednictwem ${{ ... }} notacji.

from azure.ai.ml import command
from azure.ai.ml import Input, Output

data_prep_component = command(
    name="data_prep_credit_defaults",
    display_name="Data preparation for training",
    description="reads a .xl input, split the input to train and test",
    inputs={
        "data": Input(type="uri_folder"),
        "test_train_ratio": Input(type="number"),
    },
    outputs=dict(
        train_data=Output(type="uri_folder", mode="rw_mount"),
        test_data=Output(type="uri_folder", mode="rw_mount"),
    ),
    # The source folder of the component
    code=data_prep_src_dir,
    command="""python data_prep.py \
            --data ${{inputs.data}} --test_train_ratio ${{inputs.test_train_ratio}} \
            --train_data ${{outputs.train_data}} --test_data ${{outputs.test_data}} \
            """,
    environment=f"{pipeline_job_env.name}:{pipeline_job_env.version}",
)

Opcjonalnie zarejestruj składnik w obszarze roboczym, aby ponownie użyć go w przyszłości.

# Now we register the component to the workspace
data_prep_component = ml_client.create_or_update(data_prep_component.component)

# Create (register) the component in your workspace
print(
    f"Component {data_prep_component.name} with Version {data_prep_component.version} is registered"
)

Tworzenie składnika 2: trenowanie (przy użyciu definicji yaml)

Drugi utworzony składnik korzysta z danych treningowych i testowych, wytrenuj model oparty na drzewie i zwróci model wyjściowy. Korzystanie z funkcji rejestrowania usługi Azure Machine Learning w celu rejestrowania i wizualizowania postępu nauki.

Użyto klasy do utworzenia CommandComponent pierwszego składnika. Tym razem użyjesz definicji yaml do zdefiniowania drugiego składnika. Każda metoda ma własne zalety. Definicję yaml można zaewidencjonować wraz z kodem i zapewnić czytelne śledzenie historii. Metoda programowa przy użyciu metody CommandComponent może być łatwiejsza dzięki wbudowanej dokumentacji klasy i uzupełnianiu kodu.

Utwórz katalog dla tego składnika:

import os

train_src_dir = "./components/train"
os.makedirs(train_src_dir, exist_ok=True)

Utwórz skrypt szkoleniowy w katalogu:

%%writefile {train_src_dir}/train.py
import argparse
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.metrics import classification_report
import os
import pandas as pd
import mlflow


def select_first_file(path):
    """Selects first file in folder, use under assumption there is only one file in folder
    Args:
        path (str): path to directory or file to choose
    Returns:
        str: full path of selected file
    """
    files = os.listdir(path)
    return os.path.join(path, files[0])


# Start Logging
mlflow.start_run()

# enable autologging
mlflow.sklearn.autolog()

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


def main():
    """Main function of the script."""

    # input and output arguments
    parser = argparse.ArgumentParser()
    parser.add_argument("--train_data", type=str, help="path to train data")
    parser.add_argument("--test_data", type=str, help="path to test data")
    parser.add_argument("--n_estimators", required=False, default=100, type=int)
    parser.add_argument("--learning_rate", required=False, default=0.1, type=float)
    parser.add_argument("--registered_model_name", type=str, help="model name")
    parser.add_argument("--model", type=str, help="path to model file")
    args = parser.parse_args()

    # paths are mounted as folder, therefore, we are selecting the file from folder
    train_df = pd.read_csv(select_first_file(args.train_data))

    # Extracting the label column
    y_train = train_df.pop("default payment next month")

    # convert the dataframe values to array
    X_train = train_df.values

    # paths are mounted as folder, therefore, we are selecting the file from folder
    test_df = pd.read_csv(select_first_file(args.test_data))

    # Extracting the label column
    y_test = test_df.pop("default payment next month")

    # convert the dataframe values to array
    X_test = test_df.values

    print(f"Training with data of shape {X_train.shape}")

    clf = GradientBoostingClassifier(
        n_estimators=args.n_estimators, learning_rate=args.learning_rate
    )
    clf.fit(X_train, y_train)

    y_pred = clf.predict(X_test)

    print(classification_report(y_test, y_pred))

    # Registering the model to the workspace
    print("Registering the model via MLFlow")
    mlflow.sklearn.log_model(
        sk_model=clf,
        registered_model_name=args.registered_model_name,
        artifact_path=args.registered_model_name,
    )

    # Saving the model to a file
    mlflow.sklearn.save_model(
        sk_model=clf,
        path=os.path.join(args.model, "trained_model"),
    )

    # Stop Logging
    mlflow.end_run()


if __name__ == "__main__":
    main()

Jak widać w tym skrypsie trenowania, po wytrenowanym modelu plik modelu jest zapisywany i rejestrowany w obszarze roboczym. Teraz możesz użyć zarejestrowanego modelu w punktach końcowych wnioskowania.

W środowisku tego kroku należy użyć jednego z wbudowanych (wyselekcjonowanych) środowisk usługi Azure Machine Learning. Tag azureml, nakazuje systemowi wyszukiwanie nazwy w nadzorowanych środowiskach. Najpierw utwórz plik yaml opisujący składnik:

%%writefile {train_src_dir}/train.yml
# <component>
name: train_credit_defaults_model
display_name: Train Credit Defaults Model
# version: 1 # Not specifying a version will automatically update the version
type: command
inputs:
  train_data: 
    type: uri_folder
  test_data: 
    type: uri_folder
  learning_rate:
    type: number     
  registered_model_name:
    type: string
outputs:
  model:
    type: uri_folder
code: .
environment:
  # for this step, we'll use an AzureML curate environment
  azureml://registries/azureml/environments/sklearn-1.0/labels/latest
command: >-
  python train.py 
  --train_data ${{inputs.train_data}} 
  --test_data ${{inputs.test_data}} 
  --learning_rate ${{inputs.learning_rate}}
  --registered_model_name ${{inputs.registered_model_name}} 
  --model ${{outputs.model}}
# </component>

Teraz utwórz i zarejestruj składnik. Zarejestrowanie go umożliwia ponowne użycie go w innych potokach. Ponadto każda inna osoba mająca dostęp do obszaru roboczego może używać zarejestrowanego składnika.

# importing the Component Package
from azure.ai.ml import load_component

# Loading the component from the yml file
train_component = load_component(source=os.path.join(train_src_dir, "train.yml"))

# Now we register the component to the workspace
train_component = ml_client.create_or_update(train_component)

# Create (register) the component in your workspace
print(
    f"Component {train_component.name} with Version {train_component.version} is registered"
)

Tworzenie potoku na podstawie składników

Teraz, po zdefiniowaniu i zarejestrowaniu obu składników, możesz rozpocząć implementowanie potoku.

W tym miejscu użyjesz danych wejściowych, współczynnika podziału i zarejestrowanej nazwy modelu jako zmiennych wejściowych. Następnie wywołaj składniki i połącz je za pośrednictwem identyfikatorów danych wejściowych/wyjściowych. Dostęp do danych wyjściowych każdego kroku można uzyskać za pośrednictwem .outputs właściwości .

Funkcje języka Python zwracane przez load_component() pracę jako dowolna zwykła funkcja języka Python, która jest używana w potoku do wywoływania każdego kroku.

Aby kodować potok, należy użyć określonego @dsl.pipeline dekoratora identyfikującego potoki usługi Azure Machine Learning. W dekoratorze można określić opis potoku i domyślne zasoby, takie jak obliczenia i magazyn. Podobnie jak funkcja języka Python, potoki mogą mieć dane wejściowe. Następnie można utworzyć wiele wystąpień pojedynczego potoku z różnymi danymi wejściowymi.

W tym miejscu użyliśmy danych wejściowych, współczynnika podziału i zarejestrowanej nazwy modelu jako zmiennych wejściowych. Następnie wywołujemy składniki i łączymy je za pośrednictwem identyfikatorów danych wejściowych/wyjściowych. Dostęp do danych wyjściowych każdego kroku można uzyskać za pośrednictwem .outputs właściwości .

# the dsl decorator tells the sdk that we are defining an Azure Machine Learning pipeline
from azure.ai.ml import dsl, Input, Output


@dsl.pipeline(
    compute="serverless",  # "serverless" value runs pipeline on serverless compute
    description="E2E data_perp-train pipeline",
)
def credit_defaults_pipeline(
    pipeline_job_data_input,
    pipeline_job_test_train_ratio,
    pipeline_job_learning_rate,
    pipeline_job_registered_model_name,
):
    # using data_prep_function like a python call with its own inputs
    data_prep_job = data_prep_component(
        data=pipeline_job_data_input,
        test_train_ratio=pipeline_job_test_train_ratio,
    )

    # using train_func like a python call with its own inputs
    train_job = train_component(
        train_data=data_prep_job.outputs.train_data,  # note: using outputs from previous step
        test_data=data_prep_job.outputs.test_data,  # note: using outputs from previous step
        learning_rate=pipeline_job_learning_rate,  # note: using a pipeline input as parameter
        registered_model_name=pipeline_job_registered_model_name,
    )

    # a pipeline returns a dictionary of outputs
    # keys will code for the pipeline output identifier
    return {
        "pipeline_job_train_data": data_prep_job.outputs.train_data,
        "pipeline_job_test_data": data_prep_job.outputs.test_data,
    }

Teraz użyj definicji potoku, aby utworzyć wystąpienie potoku z zestawem danych, wybraną szybkość podziału i nazwę wybraną dla modelu.

registered_model_name = "credit_defaults_model"

# Let's instantiate the pipeline with the parameters of our choice
pipeline = credit_defaults_pipeline(
    pipeline_job_data_input=Input(type="uri_file", path=credit_data.path),
    pipeline_job_test_train_ratio=0.25,
    pipeline_job_learning_rate=0.05,
    pipeline_job_registered_model_name=registered_model_name,
)

Przesyłanie zadania

Nadszedł czas na przesłanie zadania do uruchomienia w usłudze Azure Machine Learning. Tym razem użyjesz polecenia create_or_update w systemie ml_client.jobs.

W tym miejscu przekażesz również nazwę eksperymentu. Eksperyment jest kontenerem dla wszystkich iteracji, które wykonuje w określonym projekcie. Wszystkie zadania przesłane pod tą samą nazwą eksperymentu zostaną wyświetlone obok siebie w usłudze Azure Machine Learning Studio.

Po zakończeniu potok rejestruje model w obszarze roboczym w wyniku trenowania.

# submit the pipeline job
pipeline_job = ml_client.jobs.create_or_update(
    pipeline,
    # Project's name
    experiment_name="e2e_registered_components",
)
ml_client.jobs.stream(pipeline_job.name)

Postęp potoku można śledzić przy użyciu linku wygenerowanego w poprzedniej komórce. Po pierwszym wybraniu tego linku może zostać wyświetlony komunikat, że potok jest nadal uruchomiony. Po zakończeniu możesz sprawdzić wyniki poszczególnych składników.

Kliknij dwukrotnie składnik Train Credit Defaults Model (Trenowanie domyślnego modelu środków).

Istnieją dwa ważne wyniki, które warto zobaczyć na temat trenowania:

• Wyświetl dzienniki:

  1. Wybierz kartę Dane wyjściowe+dzienniki .
  2. Otwórz foldery w tej sekcji, aby wyświetlić user_logs>std_log.txt skrypt uruchamiania stdout.

• Wyświetl metryki: wybierz kartę Metryki . W tej sekcji przedstawiono różne zarejestrowane metryki. W tym przykładzie. mlflow autologging, automatycznie zarejestrował metryki trenowania.

  

Wdrażanie modelu jako punktu końcowego online

Aby dowiedzieć się, jak wdrożyć model w punkcie końcowym online, zobacz Samouczek Wdrażanie modelu jako punktu końcowego online.

Czyszczenie zasobów

Jeśli planujesz kontynuować korzystanie z innych samouczków, przejdź do sekcji Następne kroki.

Zatrzymywanie wystąpienia obliczeniowego

Jeśli nie zamierzasz go teraz używać, zatrzymaj wystąpienie obliczeniowe:

1. W programie Studio w obszarze nawigacji po lewej stronie wybierz pozycję Obliczenia.
2. Na pierwszych kartach wybierz pozycję Wystąpienia obliczeniowe
3. Wybierz wystąpienie obliczeniowe na liście.
4. Na górnym pasku narzędzi wybierz pozycję Zatrzymaj.

Usuwanie wszystkich zasobów

Ważne

Utworzone zasoby mogą być używane jako wymagania wstępne w innych samouczkach usługi Azure Machine Learning i artykułach z instrukcjami.

Jeśli nie planujesz korzystać z żadnych utworzonych zasobów, usuń je, aby nie ponosić żadnych opłat:

1. W witrynie Azure Portal w polu wyszukiwania wprowadź ciąg Grupy zasobów i wybierz je z wyników.

2. Z listy wybierz utworzoną grupę zasobów.

3. Na stronie Przegląd wybierz pozycję Usuń grupę zasobów.

   

4. Wpisz nazwę grupy zasobów. Następnie wybierz Usuń.

Następne kroki

Dowiedz się, jak zaplanować zadania potoku uczenia maszynowego