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

Artykuł
12/19/2024

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

Ten samouczek stanowi wprowadzenie do niektórych z najczęściej używanych funkcji usługi Azure Machine Learning Service. W nim tworzysz, rejestrujesz i wdrażasz model. Ten samouczek ułatwia zapoznanie się z podstawowymi pojęciami dotyczącymi usługi Azure Machine Learning 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, trenowania i rejestrowania modelu. Po wytrenowaniu modelu wdrożysz go jako punkt końcowy, a następnie wywołaj punkt końcowy na potrzeby wnioskowania.

Czynności, które należy wykonać, to:

Konfigurowanie dojścia do obszaru roboczego usługi Azure Machine Learning
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 Learning na potrzeby wnioskowania

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

Wymagania wstępne

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.

Ważne

Jeśli obszar roboczy usługi Azure Machine Learning jest skonfigurowany z zarządzaną siecią wirtualną, może być konieczne dodanie reguł ruchu wychodzącego w celu umożliwienia dostępu do publicznych repozytoriów pakietów języka Python. Aby uzyskać więcej informacji, zobacz Scenariusz: Uzyskiwanie dostępu do publicznych pakietów uczenia maszynowego.
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:
- Jeśli chcesz skopiować i wkleić kod do komórek, utwórz nowy notes.
- 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. 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)

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 obliczenia i zaczekaj na jego uruchomienie.
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.
Jeśli zostanie wyświetlony baner z informacją o konieczności uwierzytelnienia, wybierz pozycję Uwierzytelnij.
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.

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.

ml_client Utworzysz dojście do obszaru roboczego. Następnie służy 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:

Na pasku narzędzi usługi Azure Machine Learning Studio w prawym górnym rogu 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.

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

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 służy 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")

    # pin numpy
    conda_env = {
        'name': 'mlflow-env',
        'channels': ['conda-forge'],
        'dependencies': [
            'python=3.10.15',
            'pip<=21.3.1',
            {
                'pip': [
                    'mlflow==2.17.0',
                    'cloudpickle==2.2.1',
                    'pandas==1.5.3',
                    'psutil==5.8.0',
                    'scikit-learn==1.5.2',
                    'numpy==1.26.4',
                ]
            }
        ],
    }

    mlflow.sklearn.log_model(
        sk_model=clf,
        registered_model_name=args.registered_model_name,
        artifact_path=args.registered_model_name,
        conda_env=conda_env,
    )

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

Zrzut ekranu przedstawia ikonę odświeżania.

Konfigurowanie polecenia

Teraz, gdy masz skrypt, który może wykonywać żądane zadania i klaster obliczeniowy do uruchomienia skryptu, należy użyć 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 Learning 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 Learning zawiera informacje na temat tworzenia środowiska niestandardowego.
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 jest uruchamiany 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://registries/azureml/environments/sklearn-1.5/labels/latest",
    display_name="credit_default_prediction",
)

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.

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 Learning Studio, wybierając link w danych wyjściowych poprzedniej komórki.

Dane wyjściowe tego zadania wyglądają następująco w usłudze 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 rejestruje model w obszarze roboczym w wyniku trenowania.

Zrzut ekranu przedstawiający stronę przeglądu 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 , czyli online endpoint.

Aby wdrożyć usługę uczenia maszynowego, należy użyć 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 Learning Studio, aby zidentyfikować najnowszą wersję zarejestrowanego modelu. Alternatywnie poniższy kod pobiera 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 Learning 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 w polu wyszukiwania wprowadź ciąg Grupy zasobów i wybierz je z wyników.
Z listy wybierz utworzoną grupę zasobów.
Na stronie Przegląd 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 i eksplorowanie danych w usłudze Azure Machine Learning	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 Learning	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.

Udostępnij za pośrednictwem

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

Wymagania wstępne

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

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

Opinia

Dodatkowe zasoby