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

Artikel
11/23/2024

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

I det här exemplet tränas och registreras en TensorFlow-modell för att klassificera handskrivna siffror med hjälp av ett djupt neuralt nätverk (DNN).

Oavsett om du utvecklar en TensorFlow-modell från grunden eller om du tar in en befintlig modell i molnet kan du använda Azure Machine Learning för att skala ut träningsjobb med öppen källkod för att skapa, distribuera, version och övervaka modeller i produktionsklass.

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 notebook-fil genom att gå till den här katalogen: how-to-use-azureml > ml-frameworks > tensorflow > train-hyperparameter-tune-deploy-with-tensorflow folder.
Din egen Jupyter Notebook-server
- Installera Azure Machine Learning SDK (>= 1.15.0).
- Skapa en konfigurationsfil för arbetsytan.
- Ladda ned exempelskriptfilernatf_mnist.py och utils.py
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 de nödvändiga Python-biblioteken.

import os
import urllib
import shutil
import azureml

from azureml.core import Experiment
from azureml.core import Workspace, Run
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()

Skapa en fildatauppsättning

Ett FileDataset objekt refererar till en eller flera filer i arbetsytans datalager eller offentliga URL:er. Filerna kan ha valfritt format och klassen ger dig möjlighet att ladda ned eller montera filerna i din beräkning. Genom att skapa en FileDatasetskapar du en referens till datakällans plats. Om du tillämpar transformeringar på datauppsättningen lagras de även i datauppsättningen. Data finns kvar på den befintliga platsen, så ingen extra lagringskostnad tillkommer. Mer information om paketet finns i Datasetartikeln Så här skapar du registerdatauppsättningar.

from azureml.core.dataset import Dataset

web_paths = [
            'http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz',
            'http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz',
            'http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz',
            'http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz'
            ]
dataset = Dataset.File.from_files(path = web_paths)

register() Använd metoden för att registrera datauppsättningen till din arbetsyta så att de kan delas med andra, återanvändas i olika experiment och refereras till med namn i träningsskriptet.

dataset = dataset.register(workspace=ws,
                           name='mnist-dataset',
                           description='training and test dataset',
                           create_new_version=True)

# list the files referenced by dataset
dataset.to_path()

Skapa ett beräkningsmål

Skapa ett beräkningsmål för ditt TensorFlow-jobb att köra 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.

cluster_name = "gpu-cluster"

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)

    compute_target = ComputeTarget.create(ws, cluster_name, compute_config)

    compute_target.wait_for_completion(show_output=True, min_node_count=None, timeout_in_minutes=20)

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

Definiera din miljö

Om du vill definiera azure machine learning-miljön som kapslar in träningsskriptets 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ö. Azure Machine Learning har flera processor- och GPU-kurerade miljöer för TensorFlow som motsvarar olika versioner av TensorFlow. Du kan använda den senaste versionen av den här miljön med hjälp av @latest direktivet. Mer information finns i Azure Machine Learning-kurerade miljöer.

Om du vill använda en kuraterad miljö liknar koden följande exempel:

curated_env_name = 'AzureML-tensorflow-2.7-ubuntu20.04-py38-cuda11-gpu'
tf_env = Environment.get(workspace=ws, name=curated_env_name)

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


tf_env.save_to_directory(path=curated_env_name)

Kontrollera att den granskade miljön innehåller alla beroenden som krävs av ditt träningsskript. Annars måste du ändra miljön så att den innehåller de beroenden som saknas. Om miljön ändras måste du ge den ett nytt namn eftersom prefixet "AzureML" är reserverat för kurerade 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:


tf_env = Environment.from_conda_specification(name='AzureML-tensorflow-2.7-ubuntu20.04-py38-cuda11-gpu', file_path='./conda_dependencies.yml')

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


tf_env = tf_env.clone(new_name='my-AzureML-tensorflow-2.7-ubuntu20.04-py38-cuda11-gpu')

Skapa en anpassad miljö

Du kan också skapa en egen Azure Machine Learning-miljö som kapslar in träningsskriptets 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:
  - azureml-defaults
  - tensorflow-gpu==2.2.0

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 Azure/AzureML-Containers.

tf_env = Environment.from_conda_specification(name='AzureML-tensorflow-2.7-ubuntu20.04-py38-cuda11-gpu', file_path='./conda_dependencies.yml')

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

Dricks

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 din träningskörning

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 .

from azureml.core import ScriptRunConfig

args = ['--data-folder', dataset.as_mount(),
        '--batch-size', 64,
        '--first-layer-neurons', 256,
        '--second-layer-neurons', 128,
        '--learning-rate', 0.01]

src = ScriptRunConfig(source_directory=script_folder,
                      script='tf_mnist.py',
                      arguments=args,
                      compute_target=compute_target,
                      environment=tf_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 TensorFlow-skattningen för att konfigurera dina TensorFlow-träningsjobb bör du tänka på att skattningsfaktorer har blivit inaktuella från och med SDK-versionen 1.19.0. 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 till ScriptRunConfig.

Skicka en 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(workspace=ws, name='Tutorial-TF-Mnist').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.

Valfritt: genom att ange parametrarna model_framework, model_framework_versionoch resource_configuration, blir modelldistribution utan kod tillgänglig. På så sätt kan du distribuera din modell direkt som en webbtjänst från den registrerade modellen, och ResourceConfiguration objektet definierar beräkningsresursen för webbtjänsten.

from azureml.core import Model
from azureml.core.resource_configuration import ResourceConfiguration

model = run.register_model(model_name='tf-mnist', 
                           model_path='outputs/model',
                           model_framework=Model.Framework.TENSORFLOW,
                           model_framework_version='2.0',
                           resource_configuration=ResourceConfiguration(cpu=1, memory_in_gb=0.5))

Du kan också ladda ned en lokal kopia av modellen med hjälp av kör-objektet. I träningsskriptet tf_mnist.pybevarar ett TensorFlow-spararobjekt 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)
run.download_files(prefix='outputs/model', output_directory='./model', append_prefix=False)

Distribuerad träning

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

Azure Machine Learning stöder körning av distribuerade TensorFlow-jobb med både Horovod och TensorFlows inbyggda API för distribuerad utbildning.

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

Distribuera en TensorFlow-modell

Distributionens instruktioner 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.

(Förhandsversion) Distribution utan kodmodell

Viktigt!

Den här funktionen är för närvarande i allmänt tillgänglig förhandsversion. Den här förhandsversionen tillhandahålls utan ett serviceavtal och vi rekommenderar det inte för produktionsarbetsbelastningar. Vissa funktioner kanske inte stöds eller kan vara begränsade.

Mer information finns i Kompletterande villkor för användning av Microsoft Azure-förhandsversioner.

I stället för den traditionella distributionsvägen kan du också använda funktionen för distribution utan kod (förhandsversion) för TensorFlow. Genom att registrera din modell enligt ovan med parametrarna model_framework, model_framework_versionoch resource_configuration kan du använda den deploy() statiska funktionen för att distribuera din modell.

service = Model.deploy(ws, "tensorflow-web-service", [model])

Den fullständiga instruktioner omfattar distribution i Azure Machine Learning på djupet.

Nästa steg

I den här artikeln har du tränat och registrerat en TensorFlow-modell och lärt dig mer om distributionsalternativ. Mer information om Azure Machine Learning finns i de här andra artiklarna.

Dela via