Träna PyTorch-modeller i stor skala med Azure Machine Learning SDK (v1)

  • Artikel

GÄLLER FÖR:Python SDK azureml v1

I den här artikeln får du lära dig hur du kör dina PyTorch-träningsskript i företagsskala med hjälp av Azure Machine Learning.

Exempelskripten i den här artikeln används för att klassificera kyckling- och kalkonbilder för att skapa ett neuralt nätverk för djupinlärning (DNN) baserat på PyTorchs självstudie om överföringsinlärning. Överföringsinlärning är en teknik som tillämpar kunskap från att lösa ett problem på ett annat men relaterat problem. Överföringsinlärning förkortar träningsprocessen genom att kräva mindre data, tid och beräkningsresurser än träning från grunden. Mer information om överföringsinlärning finns i artikeln djupinlärning kontra maskininlärning .

Oavsett om du tränar en PyTorch-modell för djupinlärning från grunden eller om du för in en befintlig modell i molnet kan du använda Azure Machine Learning för att skala ut träningsjobb med öppen källkod med hjälp av elastiska beräkningsresurser i molnet. Du kan skapa, distribuera, version och övervaka modeller i produktionsklass med Azure Machine Learning.

Förutsättningar

Kör den här koden i någon av dessa miljöer:

  • Azure Machine Learning-beräkningsinstans – inga nedladdningar eller installation krävs

    • Slutför snabbstarten: Kom igång med Azure Machine Learning för att skapa en dedikerad notebook-server som är förinstallerad med SDK och exempellagringsplatsen.
    • I mappen exempel på djupinlärning på notebook-servern hittar du en slutförd och expanderad anteckningsbok genom att navigera till den här katalogen: mappen how-to-use-azureml > ml-frameworks > pytorch > train-hyperparameter-tune-deploy-with-pytorch .

  • Din egen Jupyter Notebook server

    Du hittar också en färdig Jupyter Notebook version av den här guiden på sidan GitHub-exempel. Notebook-filen innehåller utökade avsnitt som omfattar intelligent hyperparameterjustering, modelldistribution och notebook-widgetar.

Innan du kan köra koden i den här artikeln för att skapa ett GPU-kluster måste du begära en kvotökning för din arbetsyta.

Konfigurera experimentet

Det här avsnittet konfigurerar träningsexperimentet genom att läsa in nödvändiga Python-paket, initiera en arbetsyta, skapa beräkningsmålet och definiera träningsmiljön.

Importera paket

Importera först nödvändiga Python-bibliotek.

import os
import shutil

from azureml.core.workspace import Workspace
from azureml.core import Experiment
from azureml.core import Environment

from azureml.core.compute import ComputeTarget, AmlCompute
from azureml.core.compute_target import ComputeTargetException

Initiera en arbetsyta

Azure Machine Learning-arbetsytan är den översta resursen för tjänsten. Det ger dig en central plats där du kan arbeta med alla artefakter som du skapar. I Python SDK kan du komma åt arbetsytans artefakter genom att skapa ett workspace objekt.

Skapa ett arbetsyteobjekt från config.json filen som skapades i avsnittet krav.

ws = Workspace.from_config()

Hämta data

Datamängden består av cirka 120 träningsbilder vardera för kalkoner och kycklingar, med 100 valideringsbilder för varje klass. Vi laddar ned och extraherar datamängden som en del av vårt träningsskript pytorch_train.py. Bilderna är en delmängd av Datauppsättningen Öppna bilder v5. Mer information om hur du skapar en JSONL för att träna med dina egna data finns i den här Jupyter-anteckningsboken.

Förbereda träningsskript

I den här självstudien har träningsskriptet, pytorch_train.py, redan angetts. I praktiken kan du ta valfritt anpassat träningsskript, precis som det är, och köra det med Azure Machine Learning.

Skapa en mapp för dina träningsskript.

project_folder = './pytorch-birds'
os.makedirs(project_folder, exist_ok=True)
shutil.copy('pytorch_train.py', project_folder)

Skapa ett beräkningsmål

Skapa ett beräkningsmål som pytorchjobbet ska köras på. I det här exemplet skapar du ett GPU-aktiverat Azure Machine Learning-beräkningskluster.

Viktigt

Innan du kan skapa ett GPU-kluster måste du begära en kvotökning för din arbetsyta.


# Choose a name for your CPU cluster
cluster_name = "gpu-cluster"

# Verify that cluster does not exist already
try:
    compute_target = ComputeTarget(workspace=ws, name=cluster_name)
    print('Found existing compute target')
except ComputeTargetException:
    print('Creating a new compute target...')
    compute_config = AmlCompute.provisioning_configuration(vm_size='STANDARD_NC6', 
                                                           max_nodes=4)

    # Create the cluster with the specified name and configuration
    compute_target = ComputeTarget.create(ws, cluster_name, compute_config)

    # Wait for the cluster to complete, show the output log
    compute_target.wait_for_completion(show_output=True, min_node_count=None, timeout_in_minutes=20)

Om du i stället vill skapa ett CPU-kluster anger du en annan VM-storlek för parametern vm_size, till exempel STANDARD_D2_V2.

Anteckning

Du kan välja att använda virtuella datorer med låg prioritet för att köra vissa eller alla dina arbetsbelastningar. Se hur du skapar en virtuell dator med låg prioritet.

Mer information om beräkningsmål finns i artikeln vad som är ett beräkningsmål .

Definiera din miljö

Om du vill definiera den Azure Machine Learning-miljö som kapslar in ditt träningsskripts beroenden kan du antingen definiera en anpassad miljö eller använda en Azure Machine Learning-kurerad miljö.

Använda en kuraterad miljö

Azure Machine Learning tillhandahåller fördefinierade, utvalda miljöer om du inte vill definiera din egen miljö. Det finns flera processor- och GPU-kurerade miljöer för PyTorch som motsvarar olika versioner av PyTorch.

Om du vill använda en kuraterad miljö kan du köra följande kommando i stället:

curated_env_name = 'AzureML-PyTorch-1.6-GPU'
pytorch_env = Environment.get(workspace=ws, name=curated_env_name)

Om du vill se paketen som ingår i den organiserade miljön kan du skriva ut conda-beroendena till disken:

pytorch_env.save_to_directory(path=curated_env_name)

Kontrollera att den organiserade miljön innehåller alla beroenden som krävs av träningsskriptet. Annars måste du ändra miljön så att den inkluderar de beroenden som saknas. Om miljön ändras måste du ge den ett nytt namn eftersom prefixet "AzureML" är reserverat för utvalda miljöer. Om du har ändrat YAML-filen conda-beroenden kan du skapa en ny miljö från den med ett nytt namn, till exempel:

pytorch_env = Environment.from_conda_specification(name='pytorch-1.6-gpu', file_path='./conda_dependencies.yml')

Om du i stället hade ändrat det granskade miljöobjektet direkt kan du klona den miljön med ett nytt namn:

pytorch_env = pytorch_env.clone(new_name='pytorch-1.6-gpu')

Skapa en anpassad miljö

Du kan också skapa en egen Azure Machine Learning-miljö som kapslar in ditt träningsskripts beroenden.

Definiera först dina conda-beroenden i en YAML-fil. I det här exemplet heter conda_dependencies.ymlfilen .

channels:
- conda-forge
dependencies:
- python=3.7
- pip=21.3.1
- pip:
  - azureml-defaults
  - torch==1.6.0
  - torchvision==0.7.0
  - future==0.17.1
  - pillow

Skapa en Azure Machine Learning-miljö från den här conda-miljöspecifikationen. Miljön paketeras i en Docker-container vid körning.

Om ingen basavbildning har angetts använder Azure Machine Learning som standard en CPU-avbildning azureml.core.environment.DEFAULT_CPU_IMAGE som basavbildning. Eftersom det här exemplet kör träning på ett GPU-kluster måste du ange en GPU-basavbildning som har nödvändiga GPU-drivrutiner och beroenden. Azure Machine Learning har en uppsättning basavbildningar publicerade på Microsoft Container Registry (MCR) som du kan använda. Mer information finns i GitHub-lagringsplatsen AzureML-Containers.

pytorch_env = Environment.from_conda_specification(name='pytorch-1.6-gpu', file_path='./conda_dependencies.yml')

# Specify a GPU base image
pytorch_env.docker.enabled = True
pytorch_env.docker.base_image = 'mcr.microsoft.com/azureml/openmpi3.1.2-cuda10.1-cudnn7-ubuntu18.04'

Tips

Du kan också samla in alla dina beroenden direkt i en anpassad Docker-avbildning eller Dockerfile och skapa din miljö från den. Mer information finns i Träna med anpassad avbildning.

Mer information om hur du skapar och använder miljöer finns i Skapa och använda programvarumiljöer i Azure Machine Learning.

Konfigurera och skicka träningskörningen

Skapa en ScriptRunConfig

Skapa ett ScriptRunConfig-objekt för att ange konfigurationsinformationen för ditt träningsjobb, inklusive träningsskriptet, miljön som ska användas och beräkningsmålet som ska köras på. Eventuella argument till träningsskriptet skickas via kommandoraden om de anges i parametern arguments . Följande kod konfigurerar ett PyTorch-jobb med en nod.

from azureml.core import ScriptRunConfig

src = ScriptRunConfig(source_directory=project_folder,
                      script='pytorch_train.py',
                      arguments=['--num_epochs', 30, '--output_dir', './outputs'],
                      compute_target=compute_target,
                      environment=pytorch_env)

Varning

Azure Machine Learning kör träningsskript genom att kopiera hela källkatalogen. Om du har känsliga data som du inte vill ladda upp använder du en .ignore-fil eller tar inte med den i källkatalogen . I stället kan du komma åt dina data med hjälp av en Azure Machine Learning-datauppsättning.

Mer information om hur du konfigurerar jobb med ScriptRunConfig finns i Konfigurera och skicka träningskörningar.

Varning

Om du tidigare använde PyTorch-uppskattningen för att konfigurera dina PyTorch-träningsjobb bör du tänka på att Estimatorer har blivit inaktuella från och med 1.19.0 SDK-versionen. Med Azure Machine Learning SDK >= 1.15.0 är ScriptRunConfig det rekommenderade sättet att konfigurera träningsjobb, inklusive de som använder ramverk för djupinlärning. Vanliga migreringsfrågor finns i migreringsguiden Estimator to ScriptRunConfig.

Skicka din körning

Kör-objektet tillhandahåller gränssnittet till körningshistoriken medan jobbet körs och när det har slutförts.

run = Experiment(ws, name='Tutorial-pytorch-birds').submit(src)
run.wait_for_completion(show_output=True)

Vad händer under körningen

När körningen körs går den igenom följande steg:

  • Förbereder: En docker-avbildning skapas enligt den definierade miljön. Avbildningen laddas upp till arbetsytans containerregister och cachelagras för senare körningar. Loggar strömmas också till körningshistoriken och kan visas för att övervaka förloppet. Om en kuraterad miljö anges i stället används den cachelagrade avbildningsstöd som den kurerade miljön.

  • Skalning: Klustret försöker skala upp om Batch AI-klustret kräver fler noder för att köra körningen än vad som för närvarande är tillgängligt.

  • Körs: Alla skript i skriptmappen laddas upp till beräkningsmålet, datalager monteras eller kopieras och script körs. Utdata från stdout och mappen ./logs strömmas till körningshistoriken och kan användas för att övervaka körningen.

  • Efterbearbetning: Mappen ./outputs för körningen kopieras till körningshistoriken.

Registrera eller ladda ned en modell

När du har tränat modellen kan du registrera den på din arbetsyta. Med modellregistrering kan du lagra och versionshantera dina modeller på din arbetsyta för att förenkla modellhantering och distribution.

model = run.register_model(model_name='pytorch-birds', model_path='outputs/model.pt')

Tips

Distributionsguiden innehåller ett avsnitt om att registrera modeller, men du kan hoppa direkt till att skapa ett beräkningsmål för distribution eftersom du redan har en registrerad modell.

Du kan också ladda ned en lokal kopia av modellen med hjälp av kör-objektet. I träningsskriptet pytorch_train.pybevarar ett PyTorch-sparande objekt modellen till en lokal mapp (lokal för beräkningsmålet). Du kan använda kör-objektet för att ladda ned en kopia.

# Create a model folder in the current directory
os.makedirs('./model', exist_ok=True)

# Download the model from run history
run.download_file(name='outputs/model.pt', output_file_path='./model/model.pt'),

Distribuerad träning

Azure Machine Learning stöder även distribuerade PyTorch-jobb med flera noder så att du kan skala dina träningsarbetsbelastningar. Du kan enkelt köra distribuerade PyTorch-jobb så hanterar Azure Machine Learning orkestreringen åt dig.

Azure Machine Learning stöder körning av distribuerade PyTorch-jobb med både Horovod och PyTorchs inbyggda DistributedDataParallel-modul.

Mer information om distribuerad utbildning finns i utbildningsguiden för distribuerad GPU.

Exportera till ONNX

Om du vill optimera slutsatsdragningen med ONNX Runtime konverterar du din tränade PyTorch-modell till ONNX-formatet. Slutsatsdragning, eller modellbedömning, är fasen där den distribuerade modellen används för förutsägelse, oftast på produktionsdata. Ett exempel finns i självstudien Exportera modell från PyTorch till ONNX.

Nästa steg

I den här artikeln har du tränat och registrerat ett neuralt nätverk för djupinlärning med PyTorch i Azure Machine Learning. Om du vill lära dig hur du distribuerar en modell fortsätter du till vår modelldistributionsartikel.