Szybki start: rozpoczynanie pracy z usługą Azure Machine Edukacja

Artykuł
11/15/2023

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

Ten samouczek stanowi wprowadzenie do niektórych najczęściej używanych funkcji usługi Azure Machine Edukacja. W nim utworzysz, zarejestrujesz i wdrożysz model. Ten samouczek pomoże Ci zapoznać się z podstawowymi pojęciami dotyczącymi usługi Azure Machine Edukacja i ich najczęstszym użyciem.

Dowiesz się, jak uruchomić zadanie szkoleniowe na skalowalnym zasobie obliczeniowym, a następnie wdrożyć je, a następnie przetestować wdrożenie.

Utworzysz skrypt szkoleniowy do obsługi przygotowywania danych, trenowania i rejestrowania modelu. Po wytrenowaniu modelu wdrożysz go jako punkt końcowy, a następnie wywołasz punkt końcowy na potrzeby wnioskowania.

Kroki, które należy wykonać, to:

Konfigurowanie dojścia do obszaru roboczego usługi Azure Machine Edukacja
Tworzenie skryptu szkoleniowego
Tworzenie skalowalnego zasobu obliczeniowego, klastra obliczeniowego
Utwórz i uruchom zadanie polecenia, które uruchomi skrypt trenowania w klastrze 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 Edukacja w celu wnioskowania

Obejrzyj ten film wideo, aby poznać kroki opisane w tym przewodniku Szybki start.

Wymagania wstępne

Aby korzystać z usługi Azure Machine Edukacja, najpierw potrzebujesz obszaru roboczego. 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.
Zaloguj się do programu Studio i wybierz swój obszar roboczy, jeśli jeszcze nie jest otwarty.
Otwórz lub utwórz notes w obszarze roboczym:
- Utwórz nowy notes, jeśli chcesz skopiować/wkleić kod do komórek.
- Możesz też otworzyć plik tutorials/get-started-notebooks/quickstart.ipynb z sekcji Przykłady w programie Studio. Następnie wybierz pozycję Klonuj, aby dodać notes do plików. (Zobacz, gdzie znaleźć przykłady).

Ustawianie jądra

Na górnym pasku powyżej otwartego notesu utwórz wystąpienie obliczeniowe, jeśli jeszcze go nie masz.
Jeśli wystąpienie obliczeniowe zostanie zatrzymane, wybierz pozycję Uruchom środowisko obliczeniowe i poczekaj na jego uruchomienie.
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 zostanie wyświetlony baner z informacją o konieczności uwierzytelnienia, wybierz pozycję Uwierzytelnij.

Ważne

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

Tworzenie dojścia do obszaru roboczego

Zanim przejdziemy do kodu, musisz odwołać się do obszaru roboczego. 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.

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:

W prawym górnym rogu paska narzędzi Azure Machine Edukacja Studio wybierz nazwę obszaru roboczego.
Skopiuj wartość obszaru roboczego, grupy zasobów i identyfikatora subskrypcji do kodu.
Musisz skopiować jedną wartość, zamknąć obszar i wkleić, a następnie wrócić do następnego.

Screenshot: find the credentials for your code in the upper right of the toolbar.

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

# 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)

Tworzenie skryptu szkoleniowego

Zacznijmy od utworzenia skryptu szkoleniowego — pliku main.py python.

Najpierw utwórz folder źródłowy 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 w właśnie utworzonym 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_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)

    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 jest zapisywany i rejestrowany w obszarze roboczym. Teraz możesz użyć zarejestrowanego modelu w punktach końcowych wnioskowania.

Może być konieczne wybranie pozycji Odśwież, aby wyświetlić nowy folder i skrypt w plikach.

Screenshot shows the refresh icon.

Konfigurowanie polecenia

Teraz, gdy masz skrypt, który może wykonywać żądane zadania i klaster obliczeniowy do uruchomienia skryptu, 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 uruchamiać skrypt.

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

Użyj środowiska definiującego biblioteki oprogramowania i środowiska uruchomieniowego potrzebne do wykonania skryptu szkoleniowego. Usługa Azure Machine Edukacja udostępnia wiele wyselekcjonowanych lub gotowych środowisk, które są przydatne w przypadku typowych scenariuszy trenowania i wnioskowania. W tym miejscu użyjesz jednego z tych środowisk. W artykule Samouczek: trenowanie modelu w usłudze Azure Machine Edukacja dowiesz się, jak utworzyć środowisko niestandardowe.
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.
W tym przykładzie uzyskujemy dostęp do danych z pliku w Internecie.
Ponieważ zasób obliczeniowy nie został określony, skrypt zostanie uruchomiony w klastrze obliczeniowym bezserwerowym, który jest tworzony automatycznie.

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://azuremlexamples.blob.core.windows.net/datasets/credit_card/default_of_credit_card_clients.csv",
        ),
        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="AzureML-sklearn-1.0-ubuntu20.04-py38-cpu@latest",
    display_name="credit_default_prediction",
)

Przesyłanie zadania

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

ml_client.create_or_update(job)

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

Wyświetl zadanie w usłudze Azure Machine Edukacja Studio, wybierając link w danych wyjściowych poprzedniej komórki.

Dane wyjściowe tego zadania będą wyglądać następująco w usłudze Azure Machine Edukacja 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.

Screenshot shows the overview page for the job.

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 , czyli online endpoint.

Aby wdrożyć usługę uczenia maszynowego, użyjesz zarejestrowanego modelu.

Tworzenie nowego punktu końcowego online

Teraz, gdy masz zarejestrowany model, nadszedł czas, aby utworzyć punkt końcowy 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]

Utwórz punkt końcowy:

# Expect the endpoint creation to take a few minutes
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}")

Uwaga

Poczekaj kilka minut na utworzenie punktu końcowego.

Po utworzeniu punktu końcowego możesz go pobrać 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, które obsługuje 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 w usłudze Azure Machine Edukacja 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)]
)
print(f'Latest model is version "{latest_model_version}" ')

Wdróż najnowszą wersję modelu.

# 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)

# Expect this deployment to take approximately 6 to 8 minutes.
# create an online deployment.
# if you run into an out of quota error, change the instance_type to a comparable VM that is available.
# Learn more on https://azure.microsoft.com/pricing/details/machine-learning/.
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()

Uwaga

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

Po zakończeniu wdrażania możesz go przetestować.

Testowanie przy użyciu przykładowego zapytania

Po wdrożeniu modelu w punkcie końcowym można z nim uruchomić wnioskowanie.

Utwórz przykładowy plik żądania zgodnie z projektem oczekiwanym w metodzie run w skryfcie 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. Przed usunięciem punktu końcowego upewnij się, że żadne inne wdrożenia nie korzystają z niego.

Uwaga

Spodziewaj się, że pełne usunięcie potrwa około 20 minut.

ml_client.online_endpoints.begin_delete(name=online_endpoint_name)

Zatrzymywanie wystąpienia obliczeniowego

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

W programie Studio w obszarze nawigacji po lewej stronie wybierz pozycję Obliczenia.
Na pierwszych kartach wybierz pozycję Wystąpienia obliczeniowe
Wybierz wystąpienie obliczeniowe na liście.
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 Edukacja i artykułach z instrukcjami.

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

W witrynie Azure Portal na końcu z lewej strony wybierz pozycję Grupy zasobów.
Z listy wybierz utworzoną grupę zasobów.
Wybierz pozycję Usuń grupę zasobów.
Wpisz nazwę grupy zasobów. Następnie wybierz Usuń.

Następne kroki

Teraz, gdy masz już pomysł na to, co jest związane z trenowaniem i wdrażaniem modelu, dowiedz się więcej o procesie w tych samouczkach:

Samouczek	opis
Przekazywanie, uzyskiwanie dostępu do danych i eksplorowanie ich w usłudze Azure Machine Edukacja	Przechowywanie dużych danych w chmurze i pobieranie ich z notesów i skryptów
Tworzenie modeli na stacji roboczej w chmurze	Rozpoczynanie tworzenia prototypów i opracowywania modeli uczenia maszynowego
Trenowanie modelu w usłudze Azure Machine Edukacja	Szczegółowe informacje na temat trenowania modelu
Wdrażanie modelu jako punktu końcowego online	Szczegółowe informacje na temat wdrażania modelu
Tworzenie produkcyjnych potoków uczenia maszynowego	Podziel pełne zadanie uczenia maszynowego na wieloetapowy przepływ pracy.

Szybki start: rozpoczynanie pracy z usługą Azure Machine Edukacja

Wymagania wstępne

Ustawianie jądra

Tworzenie dojścia do obszaru roboczego

Tworzenie skryptu szkoleniowego

Konfigurowanie polecenia

Przesyłanie zadania

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

Wdrażanie modelu jako punktu końcowego online

Tworzenie nowego punktu końcowego online

Wdrażanie modelu w punkcie końcowym

Testowanie przy użyciu przykładowego zapytania

Czyszczenie zasobów

Zatrzymywanie wystąpienia obliczeniowego

Usuwanie wszystkich zasobów

Następne kroki

Dodatkowe zasoby