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

  • Artykuł

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

W tym artykule dowiesz się, jak trenować, dostrajać hiperparametry i wdrażać model PyTorch przy użyciu zestawu Azure Machine Edukacja Python SDK w wersji 2.

Użyjesz przykładowych skryptów 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 PyTorch uczenia głębokiego od podstaw, czy wprowadzasz istniejący model do chmury, możesz użyć usługi Azure Machine Edukacja do skalowania zadań szkoleniowych typu open source przy użyciu elastycznych zasobów obliczeniowych w chmurze. Modele klasy produkcyjnej można tworzyć, wdrażać, wersje i monitorować za pomocą usługi Azure Machine Edukacja.

Wymagania wstępne

Możesz również znaleźć ukończoną wersję notesu Jupyter w tym przewodniku na stronie przykładów usługi GitHub.

Przed uruchomieniem kodu w tym artykule w celu utworzenia klastra procesora GPU należy zażądać zwiększenia limitu przydziału dla obszaru roboczego.

Konfigurowanie zadania

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

Połączenie do obszaru roboczego

Najpierw musisz nawiązać połączenie z obszarem roboczym usługi Azure Machine Edukacja. 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 Edukacja.

Używamy DefaultAzureCredential polecenia , aby uzyskać dostęp do obszaru roboczego. To poświadczenie powinno być w stanie obsługiwać większość scenariuszy uwierzytelniania zestawu Azure SDK.

Jeśli DefaultAzureCredential nie zadziała, zobacz 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()

Jeśli wolisz używać przeglądarki do logowania się i uwierzytelniania, usuń komentarz z poniższego kodu i użyj go zamiast tego.

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

# Authentication package
# 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 azure Machine Edukacja Studio.
  2. Wybierz nazwę obszaru roboczego, aby wyświetlić grupę zasobów i identyfikator subskrypcji.
  3. Skopiuj wartości dla 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.

Uwaga

Tworzenie MLClient nie łączy klienta z obszarem roboczym. Inicjowanie klienta jest leniwe i czeka po raz pierwszy, aby wykonać wywołanie. W tym artykule dzieje się tak podczas tworzenia zasobów obliczeniowych.

Tworzenie zasobu obliczeniowego w celu uruchomienia zadania

Usługa Azure Machine Edukacja potrzebuje zasobu obliczeniowego do uruchomienia zadania. Ten zasób może być maszynami z jednym lub wieloma węzłami z systemem operacyjnym Linux lub Windows albo określoną siecią szkieletową obliczeniową, taką jak Spark.

W poniższym przykładowym skryscie aprowizujemy klaster obliczeniowy z systemem Linux. Aby uzyskać pełną listę rozmiarów i cen maszyn wirtualnych, zobacz stronę cennika usługi Azure Machine Edukacja. Ponieważ w tym przykładzie potrzebujemy klastra gpu, wybierzmy model i utworzymy maszynę STANDARD_NC6 azure Edukacja obliczeniową.

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_NC6s_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 Edukacja, potrzebne jest środowisko. Środowisko usługi Azure Machine Edukacja hermetyzuje zależności (takie jak środowisko uruchomieniowe oprogramowania i biblioteki) wymagane 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 Edukacja umożliwia korzystanie ze środowiska wyselekcjonowanych (lub gotowych) albo tworzenia środowiska niestandardowego przy użyciu obrazu platformy Docker lub konfiguracji conda. W tym artykule użyjesz ponownie wyselekcjonowanych środowisk AzureML-pytorch-1.9-ubuntu18.04-py37-cuda11-gpuusługi Azure Machine Edukacja . Użyj najnowszej wersji tego środowiska przy użyciu @latest dyrektywy .

curated_env_name = "AzureML-pytorch-1.9-ubuntu18.04-py37-cuda11-gpu@latest"

Konfigurowanie i przesyłanie zadania szkoleniowego

W tej sekcji zaczniemy od wprowadzenia danych do trenowania. Następnie omówimy sposób uruchamiania zadania szkoleniowego przy użyciu udostępnionego przez nas skryptu szkoleniowego. Dowiesz się, jak utworzyć zadanie trenowania, konfigurując polecenie do uruchamiania skryptu szkoleniowego. Następnie prześlesz zadanie szkoleniowe do uruchomienia w usłudze Azure Machine Edukacja.

Uzyskiwanie danych treningowych

Możesz użyć zestawu danych w tym spakowany plik. Ten zestaw danych składa się z około 120 obrazów treningowych dla dwóch klas (indyków i kurczaków) z 100 obrazami weryfikacji 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 udostępniliśmy skrypt szkoleniowy pytorch_train.py. W praktyce powinno być możliwe użycie dowolnego niestandardowego skryptu szkoleniowego i uruchomienie go za pomocą usługi Azure Machine Edukacja 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, nadszedł czas, aby skompilować go przy użyciu zestawu Azure Machine Edukacja Python SDK w wersji 2. W tym przykładzie utworzymy element command.

Usługa Azure Machine Edukacja command to zasób określający 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. Zawiera command informacje umożliwiające wykonanie pojedynczego polecenia.

Konfigurowanie polecenia

Użyjesz 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, szybkość nauki, pęd 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 AzureML-pytorch-1.9-ubuntu18.04-py37-cuda11-gpu , 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ą akcję 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, gdzie 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 Edukacja Studio.

Przesyłanie zadania

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

ml_client.jobs.create_or_update(job)

Po zakończeniu zadanie rejestruje model w obszarze roboczym (w wyniku trenowania) i wyświetla link do wyświetlania zadania w usłudze Azure Machine Edukacja Studio.

Ostrzeżenie

Usługa Azure Machine Edukacja uruchamia skrypty szkoleniowe, kopiując cały katalog źródłowy. Jeśli masz poufne dane, które nie chcesz przekazywać, użyj pliku .ignore lub nie dołącz go do katalogu źródłowego.

Co się dzieje podczas wykonywania zadania

Po wykonaniu zadania przechodzi on przez następujące etapy:

  • Przygotowywanie: obraz platformy Docker jest tworzony zgodnie ze zdefiniowanym środowiskiem. Obraz jest przekazywany do rejestru kontenerów obszaru roboczego i buforowany w celu późniejszego uruchomienia. Dzienniki są również przesyłane strumieniowo do historii zadań i można je wyświetlić w celu monitorowania postępu. Jeśli zostanie określone wyselekcjonowane środowisko, używany jest buforowany obraz obsługujący wyselekcjonowane środowisko.

  • 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: wszystkie skrypty w folderze skryptu src są przekazywane do docelowego obiektu obliczeniowego, magazyny danych są instalowane lub kopiowane, a skrypt jest wykonywany. Dane wyjściowe z pliku stdout i folderu ./logs są przesyłane strumieniowo do historii zadań i mogą służyć do monitorowania zadania.

Dostrajanie hiperparametrów modelu

Wytrenujesz model przy użyciu jednego zestawu parametrów, sprawdźmy teraz, czy możesz jeszcze bardziej poprawić dokładność modelu. Hiperparametry modelu można dostroić i zoptymalizować przy użyciu funkcji usługi Azure Machine Edukacjasweep.

Aby dostroić hiperparametry modelu, zdefiniuj przestrzeń parametrów, w której mają być wyszukiwane podczas trenowania. W tym celu należy zastąpić niektóre parametry przekazane do zadania trenowania specjalnymi danymi wejściowymi z azure.ml.sweep pakietu.

Ponieważ skrypt trenowania używa harmonogramu szybkości nauki, aby rozkładać tempo nauki co kilka epok, możesz dostroić początkową szybkość nauki i parametry tempa nauki.

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 można skonfigurować 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 użyjemy losowego próbkowania, aby wypróbować różne zestawy konfiguracji hiperparametrów w celu zmaksymalizowania podstawowej metryki . best_val_acc

Definiujemy również zasady wczesnego kończenia, czyli BanditPolicy, aby zakończyć działania o niskiej wydajności na wczesnym etapie. Element BanditPolicy kończy przebieg, który nie mieści się w ramach współczynnika slack naszej podstawowej metryki oceny. Te zasady są stosowane w każdej epoki (ponieważ raportujemy naszą best_val_acc metryką w każdej epoce i evaluation_interval=1). Zwróć uwagę, że opóźniamy pierwszą ocenę zasad aż po pierwszych 10 epokach (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 możesz przesłać 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 można znaleźć 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
        )
    )

Wdrażanie modelu jako punktu końcowego 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 zadaniu trenowania.
  • Niektóre kod do uruchomienia jako usługa. Kod wykonuje model na danym żądaniu wejściowym (skrypt wpisu). Ten skrypt wpisu odbiera dane przesyłane do wdrożonej usługi internetowej i przekazuje je do modelu. Po przetworzeniu danych przez model skrypt zwraca odpowiedź modelu na klienta. 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 Edukacja 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 utworzysz 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 można go pobrać 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'
)

Wdrażanie modelu w punkcie końcowym

Teraz możesz wdrożyć model za pomocą skryptu wejścia. Punkt końcowy może mieć wiele wdrożeń. Korzystając z reguł, punkt końcowy może następnie kierować ruch do tych wdrożeń.

W poniższym kodzie utworzysz pojedyncze wdrożenie, które obsługuje 100% ruchu przychodzącego. Określono dowolną nazwę koloru aci-blue dla wdrożenia. Możesz również użyć dowolnej innej nazwy, takiej jak aci-green lub aci-red 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 środowiska wyselekcjonowanych (określonego wcześniej) 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_NC6s_v3",
    instance_count=1,
)

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

Uwaga

Spodziewaj się, że ukończenie tego wdrożenia zajmie trochę czasu.

Testowanie wdrożonego modelu

Po wdrożeniu modelu w punkcie końcowym można przewidzieć dane wyjściowe wdrożonego modelu przy użyciu invoke metody w punkcie końcowym.

Aby przetestować punkt końcowy, użyjmy przykładowego obrazu do przewidywania. Najpierw wyświetlmy 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)

Następnie możesz wywołać punkt końcowy za pomocą tego kodu JSON i wyświetlić 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. Przed usunięciem punktu końcowego upewnij się, że żadne inne wdrożenia nie korzystają z niego.

ml_client.online_endpoints.begin_delete(name=online_endpoint_name)

Uwaga

Spodziewaj się, że wykonanie tego oczyszczania zajmie trochę czasu.

Następne kroki

W tym artykule wytrenujesz i zarejestrowano sieć neuronową uczenia głębokiego przy użyciu rozwiązania PyTorch w usłudze Azure Machine Edukacja. Model został również wdrożony w punkcie końcowym online. Zobacz inne artykuły, aby dowiedzieć się więcej o usłudze Azure Machine Edukacja.