Trenowanie modeli platformy PyTorch na dużą skalę przy użyciu usługi Azure Machine Learning

DOTYCZY: Python SDK azure-ai-ml w wersji 2 (aktualna)

Z tego artykułu dowiesz się, jak trenować, dostrajać hiperparametry i wdrażać model PyTorch przy użyciu zestawu SDK języka Python usługi Azure Machine Learning w wersji 2.

Przykładowe skrypty służą do klasyfikowania obrazów kurczaka i indyka w celu utworzenia sieci neuronowej uczenia głębokiego (DNN) na podstawie samouczka uczenia transferowego PyTorch. Uczenie transferowe to technika, która stosuje wiedzę uzyskaną od rozwiązania jednego problemu do innego, ale powiązanego problemu. Uczenie transferowe skraca proces trenowania, wymagając mniej danych, czasu i zasobów obliczeniowych niż trenowanie od podstaw. Aby dowiedzieć się więcej na temat uczenia transferowego, zobacz Uczenie głębokie a uczenie maszynowe.

Niezależnie od tego, czy trenujesz model uczenia głębokiego PyTorch od podstaw, czy wprowadzasz istniejący model do chmury, użyj usługi Azure Machine Learning, aby skalować zadania szkoleniowe typu open source przy użyciu elastycznych zasobów obliczeniowych w chmurze. Za pomocą usługi Azure Machine Learning można tworzyć, wdrażać, wersję i monitorować modele klasy produkcyjnej.

Wymagania wstępne

• Subskrypcja platformy Azure. Jeśli jeszcze go nie masz, utwórz bezpłatne konto.
• Python 3.10 lub nowszy.
• Uruchom kod w tym artykule przy użyciu wystąpienia obliczeniowego usługi Azure Machine Learning lub własnego notesu Jupyter.
  • Wystąpienie obliczeniowe usługi Azure Machine Learning — brak pobierania ani instalacji:
    • Ukończ przewodnik Quickstart: Azure Machine Learning w celu utworzenia dedykowanego serwera notebooków wstępnie załadowanego zestawem SDK i przykładowym repozytorium.
    • Na karcie Przykłady w sekcji Notesy obszaru roboczego znajdź ukończony i rozwinięty notes, przechodząc do tego katalogu: SDK v2/sdk/python/jobs/single-step/pytorch/train-hyperparameter-tune-deploy-with-pytorch
  • Serwer notatnika Jupyter:
    • Zainstaluj zestaw AZURE Machine Learning SDK (wersja 2).
    • Pobierz plik skryptu trenowania pytorch_train.py.

Możesz również znaleźć ukończoną wersję notatnika Jupyter tego przewodnika na stronie z przykładami GitHub.

Konfigurowanie zadania

Ta sekcja konfiguruje zadanie trenowania przez załadowanie wymaganych pakietów Python, nawiązanie połączenia z obszarem roboczym, utworzenie zasobu obliczeniowego w celu uruchomienia zadania typu command i utworzenie środowiska do uruchomienia zadania.

Nawiązywanie połączenia z obszarem roboczym

Najpierw połącz się z obszarem roboczym usługi Azure Machine Learning. Obszar roboczy to zasób najwyższego poziomu dla usługi. Zapewnia scentralizowane miejsce do pracy ze wszystkimi artefaktami tworzonymi podczas korzystania z usługi Azure Machine Learning.

Użyj polecenia DefaultAzureCredential , aby uzyskać dostęp do obszaru roboczego. To poświadczenie obsługuje większość scenariuszy uwierzytelniania zestawu Azure SDK.

Jeśli DefaultAzureCredential nie działa, sprawdź pakiet azure.identity lub Konfigurowanie uwierzytelniania, aby uzyskać więcej dostępnych poświadczeń.

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

# Authentication package
from azure.identity import DefaultAzureCredential

credential = DefaultAzureCredential()

from azure.identity import InteractiveBrowserCredential
credential = InteractiveBrowserCredential()

Następnie uzyskaj dojście do obszaru roboczego, podając identyfikator subskrypcji, nazwę grupy zasobów i nazwę obszaru roboczego. Aby znaleźć następujące parametry:

1. Wyszukaj nazwę obszaru roboczego w prawym górnym rogu paska narzędzi usługi Azure Machine Learning Studio.
2. Wybierz nazwę obszaru roboczego, aby wyświetlić grupę zasobów i identyfikator subskrypcji.
3. Skopiuj wartości z grupy zasobów i identyfikatora subskrypcji do kodu.

# 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 uruchomienia tego skryptu jest uchwyt obszaru roboczego, którego można użyć do zarządzania innymi zasobami i zadaniami.

Tworzenie zasobu obliczeniowego w celu uruchomienia zadania

Usługa Azure Machine Learning wymaga zasobu obliczeniowego do uruchomienia zadania. Ten zasób może być pojedynczymi lub wielowęźnymi maszynami z systemem operacyjnym Linux lub Windows albo określoną siecią szkieletową obliczeniową, taką jak Spark.

W poniższym przykładowym skryscie aprowizujesz klaster obliczeniowy systemu Linux. Aby uzyskać pełną listę rozmiarów i cen maszyn wirtualnych, zobacz stronę cennika usługi Azure Machine Learning . Ponieważ w tym przykładzie potrzebujesz klastra GPU, wybierz Standard_NC4as_T4_v3 model i utwórz klaster obliczeniowy Azure Machine Learning.

from azure.ai.ml.entities import AmlCompute

gpu_compute_target = "gpu-cluster"

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

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

    # Let's create the Azure ML compute object with the intended parameters
    gpu_cluster = AmlCompute(
        # Name assigned to the compute cluster
        name="gpu-cluster",
        # Azure ML Compute is the on-demand VM service
        type="amlcompute",
        # VM Family
        size="STANDARD_NC4AS_T4_V3",
        # 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",
    )

    # Now, we pass the object to MLClient's create_or_update method
    gpu_cluster = ml_client.begin_create_or_update(gpu_cluster).result()

print(
    f"AMLCompute with name {gpu_cluster.name} is created, the compute size is {gpu_cluster.size}"
)

Tworzenie środowiska zadań

Aby uruchomić zadanie usługi Azure Machine Learning, potrzebne jest środowisko. Środowisko usługi Azure Machine Learning hermetyzuje zależności, takie jak środowisko uruchomieniowe oprogramowania i biblioteki, potrzebne do uruchomienia skryptu trenowania uczenia maszynowego na zasobie obliczeniowym. To środowisko jest podobne do środowiska języka Python na komputerze lokalnym.

Usługa Azure Machine Learning umożliwia korzystanie ze środowiska przygotowanego (lub gotowego) albo tworzenie środowiska niestandardowego przy użyciu obrazu platformy Docker lub konfiguracji Conda. W tym artykule ponownie użyjesz wyselekcjonowanego środowiska usługi Azure Machine Learning AzureML-acpt-pytorch-2.8-cuda12.6. Aby użyć najnowszej wersji tego środowiska, skorzystaj z dyrektywy @latest.

curated_env_name = "AzureML-acpt-pytorch-2.8-cuda12.6@latest"

Konfigurowanie i przesyłanie zadania szkoleniowego

W tej sekcji przedstawiono dane na potrzeby trenowania. Następnie omówiono sposób uruchamiania zadania szkoleniowego przy użyciu podanego skryptu szkoleniowego. Dowiesz się, jak skompilować zadanie trenowania, konfigurując polecenie do uruchamiania skryptu szkoleniowego. Następnie przesyłasz zadanie szkoleniowe do uruchomienia w usłudze Azure Machine Learning.

Uzyskiwanie danych treningowych

Możesz użyć zestawu danych w tym plik ZIP. Ten zbiór danych składa się z około 120 obrazów treningowych dla dwóch klas (indyków i kurczaków), ze 100 obrazami walidacyjnymi dla każdej klasy. Obrazy są podzbiorem zestawu danych Open Images w wersji 5. Skrypt szkoleniowy pytorch_train.py pobiera i wyodrębnia zestaw danych.

Przygotowywanie skryptu szkoleniowego

W sekcji wymagań wstępnych podano skrypt szkoleniowy pytorch_train.py. W praktyce powinno być możliwe użycie dowolnego niestandardowego skryptu szkoleniowego w następujący sposób i uruchomienie go za pomocą usługi Azure Machine Learning bez konieczności modyfikowania kodu.

Podany skrypt szkoleniowy pobiera dane, trenuje model i rejestruje model.

Tworzenie zadania szkoleniowego

Teraz, gdy masz wszystkie zasoby wymagane do uruchomienia zadania, skompiluj je przy użyciu zestawu SDK języka Python usługi Azure Machine Learning w wersji 2. W tym przykładzie utwórz element command.

Usługa Azure Machine Learning command to zasób, który określa wszystkie szczegóły potrzebne do wykonania kodu szkoleniowego w chmurze. Te szczegóły obejmują dane wejściowe i wyjściowe, typ sprzętu do użycia, oprogramowanie do zainstalowania i sposób uruchamiania kodu. command zawiera informacje umożliwiające wykonanie pojedynczego polecenia.

Konfigurowanie polecenia

Użyj ogólnego przeznaczenia command , aby uruchomić skrypt trenowania i wykonać żądane zadania. Utwórz obiekt, command aby określić szczegóły konfiguracji zadania trenowania.

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

job = command(
    inputs=dict(
        num_epochs=30, learning_rate=0.001, momentum=0.9, output_dir="./outputs"
    ),
    compute=gpu_compute_target,
    environment=curated_env_name,
    code="./src/",  # location of source code
    command="python pytorch_train.py --num_epochs ${{inputs.num_epochs}} --output_dir ${{inputs.output_dir}}",
    experiment_name="pytorch-birds",
    display_name="pytorch-birds-image",
)

• Dane wejściowe dla tego polecenia obejmują liczbę epok, współczynnik uczenia się, momentum i katalog wyjściowy.
• Dla wartości parametrów:
  1. Podaj klaster gpu_compute_target = "gpu-cluster" obliczeniowy utworzony na potrzeby uruchamiania tego polecenia.
  2. Podaj wyselekcjonowane środowisko, które zainicjowano wcześniej.
  3. Jeśli nie używasz ukończonego notesu w folderze Samples, określ lokalizację pliku pytorch_train.py .
  4. Skonfiguruj samą operację wiersza polecenia. W tym przypadku polecenie to python pytorch_train.py. Dostęp do danych wejściowych i wyjściowych można uzyskać w poleceniu ${{ ... }} za pośrednictwem notacji.
  5. Skonfiguruj metadane, takie jak nazwa wyświetlana i nazwa eksperymentu. Eksperyment jest kontenerem dla wszystkich iteracji, które wykonujesz w określonym projekcie. Wszystkie zadania przesyłane pod tą samą nazwą eksperymentu są wyświetlane obok siebie w usłudze Azure Machine Learning Studio.

Przesyłanie zadania

Teraz prześlij zadanie do uruchomienia w usłudze Azure Machine Learning. Tym razem użyj create_or_update na ml_client.jobs.

ml_client.jobs.create_or_update(job)

Po zakończeniu zadania rejestruje model w obszarze roboczym jako wynik procesu treningowego. Zwraca również link, który umożliwia wyświetlenie zadania w usłudze Azure Machine Learning Studio.

Co się dzieje podczas wykonywania zadania

W miarę wykonywania zadania przechodzi on przez następujące etapy:

• Przygotowywanie: proces tworzy obraz platformy Docker zgodnie ze zdefiniowanym środowiskiem. Przekazuje obraz do rejestru kontenerów obszaru roboczego i buforuje go do późniejszego uruchomienia. Proces przesyła strumieniowo dzienniki do historii zadań, dzięki czemu można je wyświetlić w celu monitorowania postępu. Jeśli określisz wyselekcjonowane środowisko, proces używa buforowanego obrazu, który jest kopią zapasową środowiska wyselekcjonowanego.

• Skalowanie: klaster próbuje skalować w górę, jeśli wymaga więcej węzłów do wykonania przebiegu, niż są obecnie dostępne.

• Uruchomione: proces przekazuje wszystkie skrypty w folderze skryptów src do docelowego obiektu obliczeniowego. Instaluje lub kopiuje magazyny danych. Wykonuje skrypt. Proces przesyła strumieniowo dane wyjściowe z pliku stdout i folderu ./logs do historii zadań. Możesz użyć tych danych wyjściowych do monitorowania zadania.

Dostrajanie hiperparametrów modelu

Model został wytrenowany przy użyciu jednego zestawu parametrów. Teraz sprawdź, czy możesz jeszcze bardziej poprawić dokładność modelu. Dostrajanie i optymalizowanie hiperparametrów modelu przy użyciu funkcji usługi Azure Machine Learning sweep .

Aby dostroić hiperparametry modelu, zdefiniuj przestrzeń parametrów do wyszukania podczas trenowania. Zastąp niektóre parametry przekazane do zadania trenowania specjalnymi danymi wejściowymi z pakietu azure.ml.sweep.

Ponieważ skrypt treningowy używa harmonogramu tempa uczenia się, aby zmniejszać tempo co kilka epok, możesz dostosować początkowe tempo uczenia się i parametry momentum.

from azure.ai.ml.sweep import Uniform

# we will reuse the command_job created before. we call it as a function so that we can apply inputs
job_for_sweep = job(
    learning_rate=Uniform(min_value=0.0005, max_value=0.005),
    momentum=Uniform(min_value=0.9, max_value=0.99),
)

Następnie skonfiguruj zamiatanie zadania polecenia przy użyciu niektórych parametrów specyficznych dla zamiatania, takich jak metryka podstawowa do obserwowania i algorytm próbkowania do użycia.

W poniższym kodzie losowe próbkowanie próbuje różnych zestawów konfiguracji hiperparametrów w celu zmaksymalizowania podstawowej metryki . best_val_acc

Należy również zdefiniować politykę wczesnego zakończenia, czyli BanditPolicy, aby zakończyć zadania o słabej wydajności na wczesnym etapie. Element BanditPolicy kończy przebieg, który nie mieści się w ramach współczynnika slack podstawowej metryki oceny. Stosujesz tę politykę w każdej epoce (ponieważ best_val_acc metryka jest raportowana co epokę i evaluation_interval=1). Pierwsza ewaluacja polityki zostaje opóźniona, aż do zakończenia pierwszych 10 epok (delay_evaluation=10).

from azure.ai.ml.sweep import BanditPolicy

sweep_job = job_for_sweep.sweep(
    compute="gpu-cluster",
    sampling_algorithm="random",
    primary_metric="best_val_acc",
    goal="Maximize",
    max_total_trials=8,
    max_concurrent_trials=4,
    early_termination_policy=BanditPolicy(
        slack_factor=0.15, evaluation_interval=1, delay_evaluation=10
    ),
)

Teraz prześlij to zadanie tak jak wcześniej. Tym razem uruchamiasz zadanie zamiatania, które zamiata nad zadaniem pociągu.

returned_sweep_job = ml_client.create_or_update(sweep_job)

# stream the output and wait until the job is finished
ml_client.jobs.stream(returned_sweep_job.name)

# refresh the latest status of the job after streaming
returned_sweep_job = ml_client.jobs.get(name=returned_sweep_job.name)

Zadanie można monitorować za pomocą linku interfejsu użytkownika studio przedstawionego podczas uruchamiania zadania.

Znajdowanie najlepszego modelu

Po zakończeniu wszystkich przebiegów znajdź przebieg, który wygenerował model z najwyższą dokładnością.

from azure.ai.ml.entities import Model

if returned_sweep_job.status == "Completed":

    # First let us get the run which gave us the best result
    best_run = returned_sweep_job.properties["best_child_run_id"]

    # lets get the model from this run
    model = Model(
        # the script stores the model as "outputs"
        path="azureml://jobs/{}/outputs/artifacts/paths/outputs/".format(best_run),
        name="run-model-example",
        description="Model created from run.",
        type="custom_model",
    )

else:
    print(
        "Sweep job status: {}. Please wait until it completes".format(
            returned_sweep_job.status
        )
    )

Wdróż model jako punkt końcowy online

Teraz możesz wdrożyć model jako punkt końcowy online — czyli jako usługę internetową w chmurze platformy Azure.

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

• Zasoby modelu, które chcesz wdrożyć. Te zasoby obejmują plik i metadane modelu, które zostały już zarejestrowane w Twoim zadaniu trenowania.
• Kod do uruchomienia jako usługa. Kod wykonuje model na podstawie podanego żądania wejściowego (skryptu startowego). Ten skrypt odbiera dane przesyłane do wdrożonej usługi internetowej i przekazuje je do modelu. Po przetworzeniu danych przez model skrypt zwraca odpowiedź modelu klientowi. Skrypt jest specyficzny dla modelu i musi zrozumieć dane, których model oczekuje i zwraca. W przypadku korzystania z modelu MLFlow usługa Azure Machine Learning automatycznie tworzy ten skrypt.

Aby uzyskać więcej informacji na temat wdrażania, zobacz Deploy and score a machine learning model with managed online endpoint using Python SDK v2 (Wdrażanie i ocenianie modelu uczenia maszynowego za pomocą zarządzanego punktu końcowego online przy użyciu zestawu SDK języka Python w wersji 2).

Tworzenie nowego punktu końcowego online

Pierwszym krokiem do wdrożenia modelu jest utworzenie punktu końcowego online. Nazwa punktu końcowego musi być unikatowa w całym regionie świadczenia usługi Azure. W tym artykule utwórz unikatową nazwę przy użyciu uniwersalnego unikatowego identyfikatora (UUID).

import uuid

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

from azure.ai.ml.entities import ManagedOnlineEndpoint

# create an online endpoint
endpoint = ManagedOnlineEndpoint(
    name=online_endpoint_name,
    description="Classify turkey/chickens using transfer learning with PyTorch",
    auth_mode="key",
    tags={"data": "birds", "method": "transfer learning", "framework": "pytorch"},
)

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

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

Po utworzeniu punktu końcowego pobierz go w następujący sposób:

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

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

"Wdrożenie modelu do punktu końcowego"

Wdróż model przy użyciu skryptu wejścia. Punkt końcowy może mieć wiele wdrożeń. Punkt końcowy może kierować ruch do tych wdrożeń, korzystając z reguł.

W poniższym kodzie utworzysz pojedyncze wdrożenie, które obsługuje 100% ruchu przychodzącego. Kod używa dowolnej nazwy koloru niebieskiego dla wdrożenia. Możesz również użyć dowolnej innej nazwy, takiej jak zielona lub czerwona dla wdrożenia.

Kod do wdrożenia modelu w punkcie końcowym:

• Wdraża najlepszą wersję zarejestrowanego wcześniej modelu.
• Ocenia model przy użyciu pliku score.py .
• Używa wcześniej określonego wyspecjalizowanego środowiska do wnioskowania.

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

online_deployment_name = "aci-blue"

# create an online deployment.
blue_deployment = ManagedOnlineDeployment(
    name=online_deployment_name,
    endpoint_name=online_endpoint_name,
    model=model,
    environment=curated_env_name,
    code_configuration=CodeConfiguration(code="./score/", scoring_script="score.py"),
    instance_type="STANDARD_NC4AS_T4_V3",
    instance_count=1,
)

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

Testowanie wdrożonego modelu

Po wdrożeniu modelu w punkcie końcowym użyj invoke metody w punkcie końcowym, aby przewidzieć dane wyjściowe wdrożonego modelu.

Aby przetestować punkt końcowy, użyj przykładowego obrazu do przewidywania. Najpierw wyświetl obraz.

# install pillow if PIL cannot imported
%pip install pillow
import json
from PIL import Image
import matplotlib.pyplot as plt

%matplotlib inline
plt.imshow(Image.open("test_img.jpg"))

Utwórz funkcję do formatowania i zmieniania rozmiaru obrazu.

# install torch and torchvision if needed
%pip install torch
%pip install torchvision

import torch
from torchvision import transforms


def preprocess(image_file):
    """Preprocess the input image."""
    data_transforms = transforms.Compose(
        [
            transforms.Resize(256),
            transforms.CenterCrop(224),
            transforms.ToTensor(),
            transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
        ]
    )

    image = Image.open(image_file)
    image = data_transforms(image).float()
    image = torch.tensor(image)
    image = image.unsqueeze(0)
    return image.numpy()

Sformatuj obraz i przekonwertuj go na plik JSON.

image_data = preprocess("test_img.jpg")
input_data = json.dumps({"data": image_data.tolist()})
with open("request.json", "w") as outfile:
    outfile.write(input_data)

Wywołaj punkt końcowy za pomocą tego kodu JSON i wyświetl wynik.

# test the blue deployment
result = ml_client.online_endpoints.invoke(
    endpoint_name=online_endpoint_name,
    request_file="request.json",
    deployment_name=online_deployment_name,
)

print(result)

Czyszczenie zasobów

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

ml_client.online_endpoints.begin_delete(name=online_endpoint_name)

Powiązana zawartość

W tym artykule wytrenowałeś i zarejestrowałeś sieć neuronową uczenia głębokiego przy użyciu PyTorch w usłudze Azure Machine Learning. Model został również wdrożony do punktu końcowego online. Aby dowiedzieć się więcej o usłudze Azure Machine Learning, zobacz następujące artykuły:

• Śledzenie metryk przebiegu podczas trenowania
• Dostrajanie hiperparametrów
• Architektura referencyjna do trenowania rozproszonego uczenia głębokiego na platformie Azure