Samouczek: usługa Azure Machine Learning w ciągu dnia

  • Artykuł
  • Czas czytania: 11 min

DOTYCZY: Zestaw SDK języka Python azure-ai-ml w wersji 2 (bieżący)

Dowiedz się, jak analityk danych używa usługi Azure Machine Learning do trenowania modelu, a następnie użyj modelu do przewidywania. Ten samouczek pomoże Ci zapoznać się z podstawowymi pojęciami dotyczącymi usługi Azure Machine Learning i ich najczęstszym użyciem.

Dowiesz się, jak przesłać zadanie polecenia w celu uruchomienia skryptu szkoleniowego w określonym zasobie obliczeniowym skonfigurowanym ze środowiskiem zadań niezbędnym do uruchomienia skryptu.

Skrypt szkoleniowy obsługuje przygotowywanie danych, a następnie trenuje i rejestruje model. Po utworzeniu modelu wdrożysz go jako punkt końcowy, a następnie wywołasz punkt końcowy na potrzeby wnioskowania.

Kroki, które wykonasz, to:

  • Nawiązywanie połączenia z obszarem roboczym usługi Azure Machine Learning
  • Tworzenie zasobu obliczeniowego i środowiska zadań
  • Tworzenie skryptu szkoleniowego
  • Utwórz i uruchom zadanie polecenia, aby uruchomić skrypt trenowania w zasobie obliczeniowym skonfigurowanym przy użyciu odpowiedniego środowiska zadań
  • Wyświetlanie danych wyjściowych skryptu szkoleniowego
  • Wdrażanie nowo wytrenowanego modelu jako punktu końcowego
  • Wywoływanie punktu końcowego usługi Azure Machine Learning na potrzeby wnioskowania

Wymagania wstępne

Uruchamianie notesu

  1. Na górnym pasku wybierz wystąpienie obliczeniowe utworzone podczas przewodnika Szybki start: rozpoczynanie pracy z usługą Azure Machine Learning do użycia na potrzeby uruchamiania notesu.

  2. 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.

Zrzut ekranu: ustaw jądro.

Ważne

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

Aby uruchomić pojedynczą komórkę kodu w notesie, kliknij komórkę kodu i naciśnij klawisze Shift+Enter. Możesz też uruchomić cały notes, wybierając pozycję Uruchom wszystko na górnym pasku narzędzi.

Nawiązywanie połączenia z obszarem roboczym

Zanim przejdziesz do kodu, musisz nawiązać połączenie z obszarem roboczym usługi Azure Machine Learning. Obszar roboczy jest zasobem najwyższego poziomu dla usługi Azure Machine Learning, który udostępnia scentralizowane miejsce do pracy z wszystkimi tworzonymi podczas korzystania usługi Azure Machine Learning artefaktami.

DefaultAzureCredential Używamy polecenia , aby uzyskać dostęp do obszaru roboczego. DefaultAzureCredential służy do obsługi większości scenariuszy uwierzytelniania zestawu Azure SDK.

# Handle to the workspace
from azure.ai.ml import MLClient

# Authentication package
from azure.identity import DefaultAzureCredential

credential = DefaultAzureCredential()

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

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

Zrzut ekranu: znajdź poświadczenia kodu w prawym górnym rogu paska narzędzi. 

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

Wynikiem jest procedura obsługi obszaru roboczego, którego będziesz używać do zarządzania innymi zasobami i zadaniami.

Ważne

Tworzenie klienta MLClient nie będzie łączyć się z obszarem roboczym. Inicjowanie klienta jest leniwe, będzie czekać po raz pierwszy, aby wykonać wywołanie (w poniższym notesie, który nastąpi podczas tworzenia obliczeń).

Tworzenie zasobu obliczeniowego do uruchamiania zadania

Do uruchamiania zadania potrzebne będzie zasób obliczeniowy. Może to być pojedyncza lub wielowęźleowa maszyna z systemem operacyjnym Linux lub Windows albo konkretna sieć szkieletowa obliczeniowa, na przykład Spark.

Aprowizujesz klaster obliczeniowy systemu Linux. Zobacz pełną listę rozmiarów i cen maszyn wirtualnych .

W tym przykładzie potrzebujesz tylko podstawowego klastra, więc użyjesz modelu Standard_DS3_v2 z 2 rdzeniami procesorów wirtualnych, 7 GB pamięci RAM i utworzysz usługę Azure Machine Learning Compute.

from azure.ai.ml.entities import AmlCompute

# Name assigned to the compute cluster
cpu_compute_target = "cpu-cluster"

try:
    # let's see if the compute target already exists
    cpu_cluster = ml_client.compute.get(cpu_compute_target)
    print(
        f"You already have a cluster named {cpu_compute_target}, we'll reuse it as is."
    )

except Exception:
    print("Creating a new cpu compute target...")

    # Let's create the Azure ML compute object with the intended parameters
    cpu_cluster = AmlCompute(
        name=cpu_compute_target,
        # Azure ML Compute is the on-demand VM service
        type="amlcompute",
        # VM Family
        size="STANDARD_DS3_V2",
        # Minimum running nodes when there is no job running
        min_instances=0,
        # Nodes in cluster
        max_instances=4,
        # How many seconds will the node running after the job termination
        idle_time_before_scale_down=180,
        # Dedicated or LowPriority. The latter is cheaper but there is a chance of job termination
        tier="Dedicated",
    )
    print(
        f"AMLCompute with name {cpu_cluster.name} will be created, with compute size {cpu_cluster.size}"
    )
    # Now, we pass the object to MLClient's create_or_update method
    cpu_cluster = ml_client.compute.begin_create_or_update(cpu_cluster)

Tworzenie środowiska zadań

Aby uruchomić zadanie usługi Azure Machine Learning w zasobie obliczeniowym, potrzebne jest środowisko. Środowisko zawiera listę środowiska uruchomieniowego oprogramowania i bibliotek, które mają być zainstalowane w środowisku obliczeniowym, w którym będziesz trenować. Jest ona podobna do środowiska języka Python na komputerze lokalnym.

Usługa Azure Machine Learning udostępnia wiele wyselekcjonowanych lub gotowych środowisk, które są przydatne w przypadku typowych scenariuszy trenowania i wnioskowania. Możesz również utworzyć własne środowiska niestandardowe przy użyciu obrazu platformy Docker lub konfiguracji conda.

W tym przykładzie utworzysz niestandardowe ś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. W poniższej komórce użyto magii IPython do zapisania pliku w właśnie utworzonym katalogu.

%%writefile {dependencies_dir}/conda.yml
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== 1.26.1
    - azureml-mlflow==1.42.0
    - psutil>=5.8,<5.9
    - tqdm>=4.59,<4.60
    - ipykernel~=6.0
    - matplotlib

Specyfikacja zawiera kilka zwykłych pakietów, które będą używane w zadaniu (numpy, pip).

Odwołaj się do tego 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.yml"),
    image="mcr.microsoft.com/azureml/openmpi3.1.2-ubuntu18.04:latest",
)
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}"
)

Co to jest zadanie polecenia?

Utworzysz zadanie polecenia usługi Azure Machine Learning, aby wytrenować model na potrzeby przewidywania domyślnego środków. Zadanie polecenia służy do uruchamiania skryptu szkoleniowego w określonym środowisku w określonym zasobie obliczeniowym. Środowisko i zasób obliczeniowy zostały już utworzone. Następnie utworzysz skrypt trenowania.

Skrypt szkoleniowy obsługuje przygotowywanie, trenowanie i rejestrowanie wytrenowanego modelu. W tym samouczku utworzysz skrypt szkoleniowy języka Python.

Zadania poleceń można uruchamiać z poziomu interfejsu wiersza polecenia, zestawu PYTHON SDK lub interfejsu studio. W tym samouczku użyjesz zestawu SDK języka Python usługi Azure Machine Learning w wersji 2, aby utworzyć i uruchomić zadanie polecenia.

Po uruchomieniu zadania szkoleniowego wdrożysz model, a następnie użyjesz go do utworzenia przewidywania.

Tworzenie skryptu szkoleniowego

Zacznijmy od utworzenia skryptu szkoleniowego — main.py pliku języka Python .

Najpierw utwórz folder źródłowy dla skryptu:

import os

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

Ten skrypt obsługuje wstępne przetwarzanie danych, dzieląc je na dane testowe i szkolące. Następnie używa tych danych do trenowania modelu opartego na drzewie i zwracania modelu wyjściowego.

Usługa MLFlow będzie używana do rejestrowania parametrów i metryk podczas uruchamiania potoku.

W poniższej komórce użyto magii IPython do zapisania skryptu szkoleniowego do właśnie utworzonego katalogu.

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

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("--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")
    args = parser.parse_args()
   
    # Start Logging
    mlflow.start_run()

    # enable autologging
    mlflow.sklearn.autolog()

    ###################
    #<prepare the data>
    ###################
    print(" ".join(f"{k}={v}" for k, v in vars(args).items()))

    print("input data:", args.data)
    
    credit_df = pd.read_excel(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)

    train_df, test_df = train_test_split(
        credit_df,
        test_size=args.test_train_ratio,
    )
    ####################
    #</prepare the data>
    ####################

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

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

    # 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))
    ###################
    #</train the model>
    ###################

    ##########################
    #<save and register model>
    ##########################
    # 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.registered_model_name, "trained_model"),
    )
    ###########################
    #</save and register model>
    ###########################
    
    # Stop Logging
    mlflow.end_run()

if __name__ == "__main__":
    main()

Jak widać w tym skrypsie, po wytrenowanym modelu plik modelu zostanie zapisany i zarejestrowany w obszarze roboczym. Teraz możesz użyć zarejestrowanego modelu w wnioskowaniu punktów końcowych.

Konfigurowanie polecenia

Teraz, gdy masz skrypt, który może wykonywać żądane zadania, użyjesz polecenia ogólnego przeznaczenia, które może uruchamiać akcje wiersza polecenia. Ta akcja wiersza polecenia może bezpośrednio wywoływać polecenia systemowe lub uruchamiając skrypt.

W tym miejscu utworzysz zmienne wejściowe, aby określić dane wejściowe, współczynnik podziału, szybkość nauki i zarejestrowaną nazwę modelu. Skrypt polecenia będzie:

  • Użyj utworzonego wcześniej obliczeń, aby uruchomić to polecenie.
  • Użyj utworzonego wcześniej środowiska — możesz użyć @latest notacji, aby wskazać najnowszą wersję środowiska po uruchomieniu polecenia.
  • Skonfiguruj niektóre metadane, takie jak nazwa wyświetlana, nazwa eksperymentu itp. Eksperyment jest kontenerem dla wszystkich iteracji, które wykonujesz w określonym projekcie. Wszystkie zadania przesłane pod tą samą nazwą eksperymentu zostaną wyświetlone obok siebie w Azure Machine Learning studio.
  • Skonfiguruj samą akcję wiersza polecenia — python main.py w tym przypadku. Dane wejściowe/wyjściowe są dostępne w poleceniu za pośrednictwem ${{ ... }} notacji.
from azure.ai.ml import command
from azure.ai.ml import Input

registered_model_name = "credit_defaults_model"

job = command(
    inputs=dict(
        data=Input(
            type="uri_file",
            path="https://archive.ics.uci.edu/ml/machine-learning-databases/00350/default%20of%20credit%20card%20clients.xls",
        ),
        test_train_ratio=0.2,
        learning_rate=0.25,
        registered_model_name=registered_model_name,
    ),
    code="./src/",  # location of source code
    command="python main.py --data ${{inputs.data}} --test_train_ratio ${{inputs.test_train_ratio}} --learning_rate ${{inputs.learning_rate}} --registered_model_name ${{inputs.registered_model_name}}",
    environment="aml-scikit-learn@latest",
    compute="cpu-cluster",
    experiment_name="train_model_credit_default_prediction",
    display_name="credit_default_prediction",
)

Przesyłanie zadania

Nadszedł czas, aby przesłać zadanie do uruchomienia w usłudze Azure Machine Learning. Tym razem użyjesz polecenia create_or_update w usłudze ml_client.jobs.

ml_client.create_or_update(job)

Wyświetlanie danych wyjściowych zadania i oczekiwanie na ukończenie zadania

Wyświetl zadanie w Azure Machine Learning studio, wybierając link w danych wyjściowych poprzedniej komórki.

Dane wyjściowe tego zadania będą wyglądać następująco w Azure Machine Learning studio. Zapoznaj się z kartami, aby uzyskać różne szczegóły, takie jak metryki, dane wyjściowe itp. Po zakończeniu zadanie zarejestruje model w obszarze roboczym w wyniku trenowania.

Zrzut ekranu przedstawiający przegląd zadania

Ważne

Przed powrotem do tego notesu poczekaj, aż stan zadania zostanie ukończony. Uruchomienie zadania potrwa od 2 do 3 minut. Może to potrwać dłużej (do 10 minut), jeśli klaster obliczeniowy został przeskalowany w dół do zera węzłów, a środowisko niestandardowe nadal jest kompilowane.

Wdrażanie modelu jako punktu końcowego online

Teraz wdróż model uczenia maszynowego jako usługę internetową w chmurze platformy Azure — online endpoint.

Aby wdrożyć usługę uczenia maszynowego, zwykle potrzebne są następujące elementy:

  • Zasoby modelu (plik, metadane), które chcesz wdrożyć. Te zasoby zostały już zarejestrowane w zadaniu szkoleniowym.
  • Niektóre kod do uruchomienia jako usługa. Kod wykonuje model na danym żądaniu wejściowym. Ten skrypt wpisu odbiera dane przesyłane do wdrożonej usługi internetowej i przekazuje je do modelu, a następnie zwraca odpowiedź modelu na klienta. Skrypt jest specyficzny dla modelu. Skrypt wpisu musi zrozumieć dane oczekiwane i zwracane przez model. W przypadku modelu MLFlow, podobnie jak w tym samouczku, ten skrypt jest tworzony automatycznie. Przykłady skryptów oceniania można znaleźć tutaj.

Tworzenie nowego punktu końcowego online

Teraz, gdy masz zarejestrowany model i skrypt wnioskowania, nadszedł czas na utworzenie punktu końcowego online. Nazwa punktu końcowego musi być unikatowa w całym regionie świadczenia usługi Azure. W tym samouczku utworzysz unikatową nazwę przy użyciu polecenia UUID.

import uuid

# Creating a unique name for the endpoint
online_endpoint_name = "credit-endpoint-" + str(uuid.uuid4())[:8]

Uwaga

Spodziewaj się, że tworzenie punktu końcowego potrwa około 6 do 8 minut.

from azure.ai.ml.entities import (
    ManagedOnlineEndpoint,
    ManagedOnlineDeployment,
    Model,
    Environment,
)

# create an online endpoint
endpoint = ManagedOnlineEndpoint(
    name=online_endpoint_name,
    description="this is an online endpoint",
    auth_mode="key",
    tags={
        "training_dataset": "credit_defaults",
        "model_type": "sklearn.GradientBoostingClassifier",
    },
)

endpoint = ml_client.online_endpoints.begin_create_or_update(endpoint).result()

print(f"Endpoint {endpoint.name} provisioning state: {endpoint.provisioning_state}")

Po utworzeniu punktu końcowego możesz pobrać go w następujący sposób:

endpoint = ml_client.online_endpoints.get(name=online_endpoint_name)

print(
    f'Endpoint "{endpoint.name}" with provisioning state "{endpoint.provisioning_state}" is retrieved'
)

Wdrażanie modelu w punkcie końcowym

Po utworzeniu punktu końcowego wdróż model za pomocą skryptu wpisu. Każdy punkt końcowy może mieć wiele wdrożeń. Bezpośredni ruch do tych wdrożeń można określić przy użyciu reguł. W tym miejscu utworzysz pojedyncze wdrożenie obsługujące 100% ruchu przychodzącego. Wybraliśmy nazwę koloru wdrożenia, na przykład niebieskie, zielone, czerwone wdrożenia, które są dowolne.

Możesz sprawdzić stronę Modele na Azure Machine Learning studio, aby zidentyfikować najnowszą wersję zarejestrowanego modelu. Alternatywnie poniższy kod pobierze najnowszy numer wersji do użycia.

# Let's pick the latest version of the model
latest_model_version = max(
    [int(m.version) for m in ml_client.models.list(name=registered_model_name)]
)

Wdróż najnowszą wersję modelu.

Uwaga

Spodziewaj się, że wdrożenie potrwa około 6 do 8 minut.

# picking the model to deploy. Here we use the latest version of our registered model
model = ml_client.models.get(name=registered_model_name, version=latest_model_version)


# create an online deployment.
blue_deployment = ManagedOnlineDeployment(
    name="blue",
    endpoint_name=online_endpoint_name,
    model=model,
    instance_type="Standard_DS3_v2",
    instance_count=1,
)

blue_deployment = ml_client.begin_create_or_update(blue_deployment).result()

Testowanie przy użyciu przykładowego zapytania

Po wdrożeniu modelu w punkcie końcowym możesz uruchomić wnioskowanie.

Utwórz przykładowy plik żądania po projekcie oczekiwanym w metodzie run w skrycie oceny.

deploy_dir = "./deploy"
os.makedirs(deploy_dir, exist_ok=True)
%%writefile {deploy_dir}/sample-request.json
{
  "input_data": {
    "columns": [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22],
    "index": [0, 1],
    "data": [
            [20000,2,2,1,24,2,2,-1,-1,-2,-2,3913,3102,689,0,0,0,0,689,0,0,0,0],
            [10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 10, 9, 8]
        ]
  }
}
# test the blue deployment with some sample data
ml_client.online_endpoints.invoke(
    endpoint_name=online_endpoint_name,
    request_file="./deploy/sample-request.json",
    deployment_name="blue",
)

Czyszczenie zasobów

Jeśli nie zamierzasz używać punktu końcowego, usuń go, aby zatrzymać korzystanie z zasobu. Upewnij się, że żadne inne wdrożenia nie używają punktu końcowego przed jego usunięciem.

Uwaga

Ten krok może potrwać około 6 do 8 minut.

ml_client.online_endpoints.begin_delete(name=online_endpoint_name)

Usuń wszystko

Wykonaj następujące kroki, aby usunąć obszar roboczy usługi Azure Machine Learning i wszystkie zasoby obliczeniowe.

Ważne

Utworzone zasoby mogą być używane jako wymagania wstępne dla innych samouczków usługi Azure Machine Learning i artykułów 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 na końcu z lewej strony wybierz pozycję Grupy zasobów.

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

  3. Wybierz pozycję Usuń grupę zasobów.

    Zrzut ekranu przedstawiający opcje usuwania grupy zasobów w witrynie Azure Portal.

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

Następne kroki