Freigeben über

Bedarfsorientiertes Trainieren von TensorFlow-Modellen mit Azure Machine Learning SDK (v1)

  • Artikel

GILT FÜR: Python SDK azureml v1

In diesem Artikel erfahren Sie, wie Sie Ihre TensorFlow-Trainingsskripts mithilfe von Azure Machine Learning bedarfsorientiert ausführen.

In diesem Beispiel wird ein TensorFlow-Modell trainiert und registriert, um handschriftliche Ziffern mithilfe eines Deep Neural Network (DNN) zu klassifizieren.

Unabhängig davon, ob Sie ein TensorFlow-Modell von Grund auf entwickeln oder ob Sie ein vorhandenes Modell in die Cloud bringen, können Sie Azure Machine Learning zum Aufskalieren von Open-Source-Trainingsaufträgen verwenden, um für die Produktion geeignete Modelle zu erstellen, bereitzustellen und zu überwachen sowie ihre Versionen zu verwalten.

Voraussetzungen

Führen Sie diesen Code in einer dieser Umgebungen aus:

Bevor Sie den Code in diesem Artikel ausführen können, um einen GPU-Cluster zu erstellen, müssen Sie für Ihren Arbeitsbereich eine Kontingenterhöhung anfordern.

Einrichten des Experiments

In diesem Abschnitt wird das Trainingsexperiment eingerichtet, indem die erforderlichen Python-Pakete geladen, ein Arbeitsbereich initialisiert, das Computeziel erstellt und die Trainingsumgebung definiert wird.

Importieren von Paketen

Importieren Sie zunächst die erforderlichen Python-Bibliotheken.

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

Initialisieren eines Arbeitsbereichs

Der Azure Machine Learning-Arbeitsbereich ist die Ressource der obersten Ebene für den Dienst. Er stellt den zentralen Ort für die Arbeit mit allen erstellten Artefakten dar. Im Python SDK können Sie auf die Arbeitsbereichsartefakte zugreifen, indem Sie ein workspace-Objekt erstellen.

Erstellen Sie ein Arbeitsbereichsobjekt aus der Datei config.json, die im Abschnitt „Voraussetzungen“ erstellt wurde.

ws = Workspace.from_config()

Erstellen eines Dateidatasets (FileDataset)

Ein FileDataset-Objekt verweist auf Dateien in Ihrem Arbeitsbereichsdatenspeicher oder unter öffentlichen URLs. Die Dateien können ein beliebiges Format haben, und die Klasse ermöglicht es Ihnen, die Dateien in Ihre Computeinstanz herunterzuladen oder einzubinden. Durch Erstellen eines FileDataset-Objekts erstellen Sie einen Verweis auf den Speicherort der Datenquelle. Wenn Sie Transformationen auf das Dataset angewendet haben, werden diese ebenfalls im Dataset gespeichert. Die Daten verbleiben an ihrem Speicherort, sodass keine zusätzlichen Speicherkosten anfallen. Weitere Informationen zum Dataset-Paket finden Sie im Artikel Erstellen von Registrierungsdatasets.

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)

Verwenden Sie die register()-Methode, um das Dataset in Ihrem Arbeitsbereich zu registrieren, damit es für andere Benutzer freigegeben und für unterschiedliche Experimente wiederverwendet werden kann, und damit in Ihrem Trainingsskript über den Namen auf es verwiesen werden kann.

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()

Erstellen eines Computeziels

Erstellen Sie ein Computeziel, auf dem der TensorFlow-Auftrag ausgeführt werden soll. In diesem Beispiel erstellen Sie einen GPU-fähigen Azure Machine Learning-Computercluster.

Wichtig

Bevor Sie einen GPU-Cluster erstellen können, müssen Sie für Ihren Arbeitsbereich eine Kontingenterhöhung anfordern.

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)

Weitere Informationen zu Computezielen finden Sie im Artikel Was ist ein Computeziel?.

Definieren der Umgebung

Um die Azure Machine Learning-Umgebung zu definieren, die die Abhängigkeiten Ihres Trainingsskripts kapselt, können Sie entweder eine benutzerdefinierte Umgebung definieren oder eine von Azure Machine Learning kuratierte Umgebung verwenden.

Verwenden einer zusammengestellten Umgebung

Optional stellt Azure Machine Learning vordefinierte, kuratierte Umgebungen bereit, falls Sie keine eigene Umgebung definieren möchten. Azure Machine Learning bietet mehrere kuratierte CPU- und GPU-Umgebungen für TensorFlow, die verschiedenen Versionen von TensorFlow entsprechen. Sie können die neueste Version dieser Umgebung mithilfe der @latest-Anweisung verwenden. Weitere Informationen finden Sie unter Azure Machine Learning – zusammengestellte Umgebungen.

Wenn Sie eine kuratierte Umgebung verwenden möchten, ähnelt der Code dem folgenden Beispiel:

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

Um die Pakete anzuzeigen, die in der zusammengestellten Umgebung enthalten sind, können Sie die Conda-Abhängigkeiten auf den Datenträger schreiben:


tf_env.save_to_directory(path=curated_env_name)

Stellen Sie sicher, dass die zusammengestellte Umgebung alle Abhängigkeiten enthält, die von Ihrem Trainingsskript benötigt werden. Wenn dies nicht der Fall ist, müssen Sie die Umgebung so ändern, dass die fehlenden Abhängigkeiten eingeschlossen werden. Wenn die Umgebung geändert wird, müssen Sie ihr einen neuen Namen geben, da das Präfix „AzureML“ für zusammengestellte Umgebungen reserviert ist. Wenn Sie die YAML-Datei für Conda-Abhängigkeiten geändert haben, können Sie daraus eine neue Umgebung mit einem neuen Namen erstellen. Beispiel:


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

Wenn Sie das Objekt der zusammengestellten Umgebung stattdessen direkt geändert haben, können Sie diese Umgebung mit einem neuen Namen klonen:


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

Erstellen einer benutzerdefinierten Umgebung

Sie können auch eine eigene Azure Machine Learning-Umgebung erstellen, die die Abhängigkeiten Ihres Trainingsskripts kapselt.

Definieren Sie zunächst Ihre Conda-Abhängigkeiten in einer YAML-Datei. In diesem Beispiel trägt die Datei den Namen conda_dependencies.yml.

channels:
- conda-forge
dependencies:
- python=3.7
- pip:
  - azureml-defaults
  - tensorflow-gpu==2.2.0

Erstellen Sie anhand dieser Conda-Umgebungsspezifikation eine Azure Machine Learning-Umgebung. Die Umgebung wird zur Laufzeit in einen Docker-Container gepackt.

Wenn kein Basisimage angegeben wird, verwendet Azure Machine Learning standardmäßig das CPU-Image azureml.core.environment.DEFAULT_CPU_IMAGE als Basisimage. Da das Training in diesem Beispiel auf einem GPU-Cluster ausgeführt wird, müssen Sie ein GPU-Basisimage mit den erforderlichen GPU-Treibern und -Abhängigkeiten angeben. Für Azure Machine Learning wird in Microsoft Container Registry (MCR) eine Reihe Basisimages veröffentlicht, die Sie verwenden können. Weitere Informationen finden Sie im GitHub-Repository „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'

Tipp

Optional können Sie einfach alle ihre Abhängigkeiten direkt in einem benutzerdefinierten Docker-Image oder in einer Dockerfile-Datei erfassen und Ihre Umgebung daraus erstellen. Weitere Informationen finden Sie unter Trainieren mit einem benutzerdefinierten Image.

Weitere Informationen zum Erstellen und Verwenden von Umgebungen finden Sie unter Erstellen und Verwenden von Softwareumgebungen in Azure Machine Learning.

Konfigurieren und Übermitteln Ihrer Trainingsausführung

Erstellen eines ScriptRunConfig-Elements

Erstellen Sie ein ScriptRunConfig- Objekt, um die Konfigurationsdetails Ihres Trainingsauftrags anzugeben, einschließlich Ihres Trainingsskripts, der zu verwendenden Umgebung und des Computeziels für die Ausführung. Alle Argumente des Trainingsskripts werden über die Befehlszeile übergeben, wenn sie im arguments Parameter angegeben sind.

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)

Warnung

Zum Ausführen von Trainingsskripts wird von Azure Machine Learning das gesamte Quellverzeichnis kopiert. Sind vertrauliche Daten vorhanden, die nicht hochgeladen werden sollen, verwenden Sie die IGNORE-Datei, oder platzieren Sie sie nicht im Quellverzeichnis. Greifen Sie stattdessen über ein Azure Machine Learning-Dataset auf Ihre Daten zu.

Weitere Informationen zum Konfigurieren von Aufträgen mit ScriptRunConfig finden Sie unter Konfigurieren und Übermitteln von Trainingsausführungen.

Warnung

Wenn Sie zuvor den TensorFlow-Schätzer zum Konfigurieren Ihrer TensorFlow-Trainingsaufträge verwendet haben, beachten Sie, dass der Schätzer mit der Veröffentlichung von Release 1.19.0 des SDK als veraltet eingestuft wurde. Beim Azure Machine Learning SDK 1.15.0 oder höher ist ScriptRunConfig die empfohlene Vorgehensweise zum Konfigurieren von Trainingsaufträgen, einschließlich derjenigen, die Deep Learning-Frameworks verwenden. Allgemeine Fragen zur Migration finden Sie im Leitfaden zur Migration vom Schätzer zu ScriptRunConfig.

Initiieren einer Ausführung

Das Run-Objekt bildet die Schnittstelle zum Ausführungsverlauf, während der Auftrag ausgeführt wird und nachdem er abgeschlossen wurde.

run = Experiment(workspace=ws, name='Tutorial-TF-Mnist').submit(src)
run.wait_for_completion(show_output=True)

Was passiert während der Ausführung

Die Ausführung durchläuft die folgenden Phasen:

  • Vorbereitung: Ein Docker-Image wird entsprechend der definierten Umgebung erstellt. Das Image wird in die Containerregistrierung des Arbeitsbereichs hochgeladen und für spätere Ausführungen zwischengespeichert. Darüber hinaus werden Protokolle in den Ausführungsverlauf gestreamt, mit deren Hilfe der Status überwacht werden kann. Wenn stattdessen eine zusammengestellte Umgebung angegeben wird, wird das zwischengespeicherte Image verwendet, das diese zusammengestellte Umgebung unterstützt.

  • Skalierung: Der Cluster versucht ein Hochskalieren, wenn der Batch KI-Cluster mehr Knoten zur Ausführung benötigt, als derzeit verfügbar sind.

  • Wird ausgeführt: Alle Skripts im Skriptordner werden auf das Computeziel hochgeladen, Datenspeicher werden bereitgestellt oder kopiert, und script wird ausgeführt. Ausgaben aus „stdout“ und dem Ordner ./logs werden in den Ausführungsverlauf gestreamt und können zur Überwachung der Ausführung verwendet werden.

  • Nachbearbeitung: Der Ordner ./outputs der Ausführung wird in den Ausführungsverlauf kopiert.

Registrieren oder Herunterladen eines Modells

Sobald Sie das Modell trainiert haben, können Sie es in Ihrem Arbeitsbereich registrieren. Die Modellregistrierung bietet die Möglichkeit, Ihre Modelle in Ihrem Arbeitsbereich zu speichern und zu versionieren, um die Modellverwaltung und -bereitstellung zu vereinfachen.

Optional: Durch die Angabe der Parameter model_framework, model_framework_version und resource_configuration wird die Modellimplementierung ohne Code verfügbar. Auf diese Weise können Sie Ihr Modell direkt als Webdienst aus dem registrierten Modell bereitstellen, und das Objekt ResourceConfiguration definiert die Computeressource für den Webdienst.

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))

Mit dem Run-Objekt können Sie auch eine lokale Kopie des Modells herunterladen. Im Trainingsskript tf_mnist.py wird das Modell durch ein saver-Objekt von TensorFlow persistent in einem lokalen Ordner (lokal für das Computeziel) gespeichert. Sie können das Run-Objekt verwenden, um eine Kopie herunterzuladen.

# 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)

Verteiltes Training

Azure Machine Learning unterstützt auch verteilte TensorFlow-Aufträge auf mehreren Knoten, sodass Sie Ihre Trainingworkloads skalieren können. Sie können ganz einfach verteilte TensorFlow-Aufträge ausführen. Azure Machine Learning verwaltet die Orchestrierung für Sie.

Azure Machine Learning unterstützt die Ausführung verteilter TensorFlow-Aufträge sowohl mit Horovod als auch mit der integrierten API für verteiltes Training von TensorFlow.

Weitere Informationen zum verteilten Training finden Sie im Leitfaden für das verteilte GPU-Training.

Bereitstellen eines TensorFlow-Modells

Die Schrittanleitung zur Bereitstellung enthält einen Abschnitt zur Registrierung von Modellen, aber Sie können direkt zu Erstellen eines Computeziels für die Bereitstellung springen, da Sie bereits über ein registriertes Modell verfügen.

(Vorschau) Modellimplementierung ohne Code

Wichtig

Dieses Feature ist zurzeit als öffentliche Preview verfügbar. Diese Vorschauversion wird ohne Vereinbarung zum Servicelevel bereitgestellt und ist nicht für Produktionsworkloads vorgesehen. Manche Features werden möglicherweise nicht unterstützt oder sind nur eingeschränkt verwendbar.

Weitere Informationen finden Sie unter Zusätzliche Nutzungsbestimmungen für Microsoft Azure-Vorschauen.

Anstelle der herkömmlichen Bereitstellungsroute können Sie auch die Bereitstellung ohne Code (Vorschau) für TensorFlow verwenden. Indem Sie Ihr Modell wie oben gezeigt mit den Parametern model_framework, model_framework_version und resource_configuration registrieren, können Sie die statische Funktion deploy() verwenden, um Ihr Modell bereitzustellen.

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

Die vollständige Schrittanleitung behandelt die Bereitstellung in Azure Machine Learning eingehender.

Nächste Schritte

In diesem Artikel haben Sie ein TensorFlow-Modell trainiert und registriert und sich über Bereitstellungsoptionen informiert. Weitere Informationen zu Azure Machine Learning finden Sie in den folgenden Artikeln.