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

Artikel
05/23/2023

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

Det här exemplet tränar och registrerar 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 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 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 med djupinlärningsexempel på notebook-servern hittar du en slutförd och expanderad notebook-fil genom att navigera 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 slutförd Jupyter Notebook version av den här guiden på sidan Med GitHub-exempel. Notebook-filen innehåller utökade avsnitt som omfattar intelligent justering av hyperparametrar, 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 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 artefakterna för arbetsytan genom att skapa ett workspace -objekt.

Skapa ett arbetsyteobjekt från filen som config.jsonskapades i avsnittet förutsättningar.

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 till din beräkning. Genom att skapa en FileDatasetskapar du en referens till datakällans plats. Om du har tillämpat några 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 Dataset paketet finns i artikeln Så här skapar du registerdatamängder.

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 på 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 som TensorFlow-jobbet 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.

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)

Anteckning

Du kan välja att använda lågprioriterade virtuella datorer 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 är ett beräkningsmål .

Definiera din miljö

Om du vill definiera azure machine learning-miljön som kapslar in ditt träningsskripts beroenden kan du antingen definiera en anpassad miljö eller använda en Azure Machine Learning-granskad miljö.

Använda en granskad miljö

Azure Machine Learning tillhandahåller fördefinierade, organiserade miljöer om du inte vill definiera din egen miljö. Azure Machine Learning har flera processor- och GPU-organiserade 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-organiserade miljöer.

Om du vill använda en granskad miljö ser koden ut ungefär som i 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 organiserade miljön kan du skriva ut conda-beroendena till disken:


tf_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 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 organiserade 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 organiserade miljöobjektet direkt kan du klona 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 anges 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 på 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'

Tips

Du kan också samla in alla dina beroenden direkt i en anpassad Docker-avbildning eller Dockerfile och skapa din miljö utifrån det. 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. 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-uppskattningen för att konfigurera dina TensorFlow-träningsjobb bör du tänka på att beräknare 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 djupinlärningsramverk. Vanliga migreringsfrågor finns i migreringsguiden Estimator till ScriptRunConfig.

Skicka en körning

Run-objektet tillhandahåller gränssnittet för körningshistoriken när 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 vid körning

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 granskad miljö anges i stället används den cachelagrade avbildningsstöd som den organiserade 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

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.

(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 rekommenderas 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 om distributionsalternativ. Mer information om Azure Machine Learning finns i de här andra artiklarna.

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

Förutsättningar

Konfigurera experimentet

Importera paket

Initiera en arbetsyta

Skapa en fildatauppsättning

Skapa ett beräkningsmål

Definiera din miljö

Använda en granskad miljö

Skapa en anpassad miljö

Konfigurera och skicka träningskörningen

Skapa en ScriptRunConfig

Skicka en körning

Vad händer vid körning

Registrera eller ladda ned en modell

Distribuerad träning

Distribuera en TensorFlow-modell

(Förhandsversion) Distribution utan kodmodell

Nästa steg

Ytterligare resurser