TensorFlow mély tanulási modellt készíthet Azure Machine LearningBuild a TensorFlow deep learning model at scale with Azure Machine Learning

A következőkre vonatkozik: igen alapszintű                   kiadás   igenEnterprise Edition   Upgrade to Enterprise edition(frissítés az Enterprise kiadásra)         APPLIES TO: yesBasic edition yesEnterprise edition                    (Upgrade to Enterprise edition)

Ebből a cikkből megtudhatja, hogyan futtathatja a TensorFlow -betanítási szkripteket Azure Machine learning TensorFlow kalkulátor -osztályának használatával.This article shows you how to run your TensorFlow training scripts at scale using Azure Machine Learning's TensorFlow estimator class. Ez a példa egy TensorFlow-modellt vezet be, és regisztrálja a kézzel írt számjegyeket egy mély neurális hálózat (DNN) használatával.This example trains and registers a TensorFlow model to classify handwritten digits using a deep neural network (DNN).

Függetlenül attól, hogy a TensorFlow-modellt fejleszti az alapoktól, vagy egy meglévő modellt hoz létre a felhőbe, a Azure Machine learning használatával kibővítheti a nyílt forráskódú képzési feladatokat az éles modellek létrehozásához, üzembe helyezéséhez, verzióhoz és figyeléséhez.Whether you're developing a TensorFlow model from the ground-up or you're bringing an existing model into the cloud, you can use Azure Machine Learning to scale out open-source training jobs to build, deploy, version, and monitor production-grade models.

További információ a Deep learning és a Machine learningszolgáltatásról.Learn more about deep learning vs machine learning.

ElőfeltételekPrerequisites

Futtassa ezt a kódot ezen környezetek bármelyikén:Run this code on either of these environments:

A kísérlet beállításaSet up the experiment

Ez a szakasz a betanítási kísérletet a szükséges Python-csomagok betöltésével, egy munkaterület inicializálásával, egy kísérlet létrehozásával, valamint a betanítási adat és a betanítási parancsfájlok feltöltésével állítja be.This section sets up the training experiment by loading the required Python packages, initializing a workspace, creating an experiment, and uploading the training data and training scripts.

Csomagok importálásaImport packages

Először importálja a szükséges Python-kódtárakat.First, import the necessary Python libraries.

import os
import urllib
import shutil
import azureml

from azureml.core import Experiment
from azureml.core import Workspace, Run

from azureml.core.compute import ComputeTarget, AmlCompute
from azureml.core.compute_target import ComputeTargetException
from azureml.train.dnn import TensorFlow

Munkaterület inicializálásaInitialize a workspace

A Azure Machine learning munkaterület a szolgáltatás legfelső szintű erőforrása.The Azure Machine Learning workspace is the top-level resource for the service. Központi helyet biztosít az összes létrehozott összetevővel való együttműködéshez.It provides you with a centralized place to work with all the artifacts you create. A Python SDK-ban egy workspace objektum létrehozásával érheti el a munkaterület összetevőit.In the Python SDK, you can access the workspace artifacts by creating a workspace object.

Hozzon létre egy munkaterület- config.json objektumot az Előfeltételek szakaszbanlétrehozott fájlból.Create a workspace object from the config.json file created in the prerequisites section.

ws = Workspace.from_config()

Mélyreható tanulási kísérlet létrehozásaCreate a deep learning experiment

Hozzon létre egy kísérletet és egy mappát a betanítási szkriptek tárolásához.Create an experiment and a folder to hold your training scripts. Ebben a példában hozzon létre egy "TF-mnist" nevű kísérletet.In this example, create an experiment called "tf-mnist".

script_folder = './tf-mnist'
os.makedirs(script_folder, exist_ok=True)

exp = Experiment(workspace=ws, name='tf-mnist')

Fájl adatkészletének létrehozásaCreate a file dataset

Egy FileDataset objektum egy vagy több fájlra hivatkozik a munkaterület adattárában vagy a nyilvános URL-címekben.A FileDataset object references one or multiple files in your workspace datastore or public urls. A fájlok bármilyen formátumúak lehetnek, és a osztály lehetővé teszi a fájlok letöltését vagy csatlakoztatását a számítási feladatokhoz.The files can be of any format, and the class provides you with the ability to download or mount the files to your compute. A FileDatasetlétrehozásával létrehoz egy hivatkozást az adatforrás helyére.By creating a FileDataset, you create a reference to the data source location. Ha az adatkészletbe átalakításokat alkalmazott, azokat az adatkészletben is tárolja a rendszer.If you applied any transformations to the data set, they will be stored in the data set as well. Az adattárolók a meglévő helyükön maradnak, így nem merülnek fel extra tárolási költségek.The data remains in its existing location, so no extra storage cost is incurred. További információért tekintse Dataset meg a csomag útmutatóját .See the how-to guide on the Dataset package for more information.

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)

A register() módszer használatával regisztrálja az adatkészletet a munkaterületen, hogy másokkal is megoszthatók legyenek, újra felhasználható a különböző kísérletekben, és nevük szerint a képzési szkriptben.Use the register() method to register the data set to your workspace so they can be shared with others, reused across various experiments, and referred to by name in your training script.

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

Számítási cél létrehozásaCreate a compute target

Hozzon létre egy számítási célt a TensorFlow-feladatokhoz a futtatásához.Create a compute target for your TensorFlow job to run on. Ebben a példában hozzon létre egy GPU-kompatibilis Azure Machine Learning számítási fürtöt.In this example, create a GPU-enabled Azure Machine Learning compute cluster.

cluster_name = "gpucluster"

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)

A számítási célokkal kapcsolatos további információkért tekintse meg a Mi az a számítási cél című cikket.For more information on compute targets, see the what is a compute target article.

TensorFlow-kalkulátor létrehozásaCreate a TensorFlow estimator

A TensorFlow kalkulátor egyszerű módszert kínál a TensorFlow-betanítási feladatok számítási célra való elindítására.The TensorFlow estimator provides a simple way of launching a TensorFlow training job on a compute target.

A TensorFlow kalkulátor az általános estimator osztályon keresztül valósul meg, amely bármely keretrendszer támogatásához használható.The TensorFlow estimator is implemented through the generic estimator class, which can be used to support any framework. További információ a képzési modellekről az általános kalkulátor használatával: modellek betanítása Azure Machine learning a kalkulátor használatávalFor more information about training models using the generic estimator, see train models with Azure Machine Learning using estimator

Ha a képzési szkriptnek további pip-vagy Conda-csomagokat kell futtatnia, akkor az eredményül kapott Docker-rendszerképre is telepítheti a csomagokat pip_packages , conda_packages ha a és az argumentumokat át szeretné adni a nevüknek.If your training script needs additional pip or conda packages to run, you can have the packages installed on the resulting Docker image by passing their names through the pip_packages and conda_packages arguments.

script_params = {
    '--data-folder': dataset.as_named_input('mnist').as_mount(),
    '--batch-size': 50,
    '--first-layer-neurons': 300,
    '--second-layer-neurons': 100,
    '--learning-rate': 0.01
}

est = TensorFlow(source_directory=script_folder,
                 entry_script='tf_mnist.py',
                 script_params=script_params,
                 compute_target=compute_target,
                 use_gpu=True,
                 pip_packages=['azureml-dataprep[pandas,fuse]'])

Tipp

A Tensorflow 2,0 támogatása a Tensorflow kalkulátor osztályhoz lett hozzáadva.Support for Tensorflow 2.0 has been added to the Tensorflow estimator class. További információt a blogbejegyzésben talál.See the blog post for more information.

A Python-környezet testreszabásával kapcsolatos további információkért lásd: környezetek létrehozása és kezelése képzéshez és üzembe helyezéshez.For more information on customizing your Python environment, see Create and manage environments for training and deployment.

Futtatás küldéseSubmit a run

A Run objektum biztosítja a felületet a futtatási előzményekhez, miközben a feladatot futtatja, és a művelet befejeződött.The Run object provides the interface to the run history while the job is running and after it has completed.

run = exp.submit(est)
run.wait_for_completion(show_output=True)

A Futtatás végrehajtásakor a következő szakaszokon halad végig:As the Run is executed, it goes through the following stages:

  • Előkészítés: a Docker-rendszerkép létrehozása a TensorFlow-kalkulátor alapján történik.Preparing: A Docker image is created according to the TensorFlow estimator. A rendszer feltölti a rendszerképet a munkaterület tároló-Hivatalához, és a gyorsítótárba helyezi a későbbi futtatásokhoz.The image is uploaded to the workspace's container registry and cached for later runs. A naplók a futtatási előzményekre is továbbítva lesznek, és a folyamat figyelésére is megtekinthetők.Logs are also streamed to the run history and can be viewed to monitor progress.

  • Skálázás: a fürt akkor kísérli meg a skálázást, ha a Batch AI fürthöz több csomópont szükséges a jelenleg elérhető futtatáshoz.Scaling: The cluster attempts to scale up if the Batch AI cluster requires more nodes to execute the run than are currently available.

  • Futtatás: a rendszer a parancsfájl mappájában lévő összes parancsfájlt feltölti a számítási célra, az adattárakat csatlakoztatja vagy másolja, és a entry_script végre lesz hajtva.Running: All scripts in the script folder are uploaded to the compute target, data stores are mounted or copied, and the entry_script is executed. Az stdout és a./Logs mappa kimeneteit a rendszer a futtatási előzményekre továbbítja, és a Futtatás figyelésére használható.Outputs from stdout and the ./logs folder are streamed to the run history and can be used to monitor the run.

  • Utómunka: a Futtatás./outputs mappáját a rendszer átmásolja a futtatási előzményekbe.Post-Processing: The ./outputs folder of the run is copied over to the run history.

Modell regisztrálása vagy letöltéseRegister or download a model

A modell kiképzése után regisztrálhatja azt a munkaterületre.Once you've trained the model, you can register it to your workspace. A modell regisztrálása lehetővé teszi a modellek tárolását és verzióját a munkaterületen a modell kezelésének és üzembe helyezésénekegyszerűsítése érdekében.Model registration lets you store and version your models in your workspace to simplify model management and deployment. A paraméterek model_framework, model_framework_versiona és resource_configurationa, a kód nélküli üzembe helyezés lehetőség megadásával elérhetővé válik.By specifying the parameters model_framework, model_framework_version, and resource_configuration, no-code model deployment becomes available. Ez lehetővé teszi a modell közvetlen üzembe helyezését webszolgáltatásként a regisztrált modellből, és az ResourceConfiguration objektum meghatározza a webszolgáltatás számítási erőforrását.This allows you to directly deploy your model as a web service from the registered model, and the ResourceConfiguration object defines the compute resource for the web service.

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

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

A modell helyi másolatát a Run objektum használatával is letöltheti.You can also download a local copy of the model by using the Run object. A betanítási mnist-tf.pyparancsfájlban egy TensorFlow-megtakarító objektum megőrzi a modellt egy helyi mappába (helyi a számítási célra).In the training script mnist-tf.py, a TensorFlow saver object persists the model to a local folder (local to the compute target). A Futtatás objektum használatával letöltheti a másolatokat.You can use the Run object to download a copy.

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

for f in run.get_file_names():
    if f.startswith('outputs/model'):
        output_file_path = os.path.join('./model', f.split('/')[-1])
        print('Downloading from {} to {} ...'.format(f, output_file_path))
        run.download_file(name=f, output_file_path=output_file_path)

Elosztott betanításDistributed training

A TensorFlow kalkulátor a CPU-és a GPU-fürtökön egyaránt támogatja az elosztott képzést.The TensorFlow estimator also supports distributed training across CPU and GPU clusters. Könnyedén futtathatja az elosztott TensorFlow-feladatokat, és Azure Machine Learning felügyeli az Ön számára.You can easily run distributed TensorFlow jobs and Azure Machine Learning will manage the orchestration for you.

A Azure Machine Learning a TensorFlow-ben az elosztott képzés két módszerét támogatja:Azure Machine Learning supports two methods of distributed training in TensorFlow:

HorovodHorovod

A Horovod egy nyílt forráskódú keretrendszer az Über által fejlesztett elosztott képzésekhez.Horovod is an open-source framework for distributed training developed by Uber. Az elosztott GPU TensorFlow feladatok egyszerű elérési útját kínálja.It offers an easy path to distributed GPU TensorFlow jobs.

A Horovod használatához meg kell adnia MpiConfiguration egy objektumot a distributed_training paraméterhez a TensorFlow konstruktorban.To use Horovod, specify an MpiConfiguration object for the distributed_training parameter in the TensorFlow constructor. Ez a paraméter biztosítja, hogy a Horovod-függvénytár telepítve legyen a betanítási parancsfájlban.This parameter ensures that Horovod library is installed for you to use in your training script.

from azureml.core.runconfig import MpiConfiguration
from azureml.train.dnn import TensorFlow

# Tensorflow constructor
estimator= TensorFlow(source_directory=project_folder,
                      compute_target=compute_target,
                      script_params=script_params,
                      entry_script='script.py',
                      node_count=2,
                      process_count_per_node=1,
                      distributed_training=MpiConfiguration(),
                      framework_version='1.13',
                      use_gpu=True,
                      pip_packages=['azureml-dataprep[pandas,fuse]'])

Paraméter-kiszolgálóParameter server

Futtathat olyan natív elosztott TensorFlowis, amely a paraméter-kiszolgálói modellt használja.You can also run native distributed TensorFlow, which uses the parameter server model. Ebben a metódusban a paraméter-kiszolgálók és a feldolgozók fürtje között kell betanítania.In this method, you train across a cluster of parameter servers and workers. A dolgozók kiszámítják a színátmeneteket a betanítás során, míg a paraméter-kiszolgálók összesítik a színátmeneteket.The workers calculate the gradients during training, while the parameter servers aggregate the gradients.

A paraméter-kiszolgáló metódus használatához a TensorFlow konstruktorban meg kell adni egy TensorflowConfiguration objektumot a distributed_training paraméterhez.To use the parameter server method, specify a TensorflowConfiguration object for the distributed_training parameter in the TensorFlow constructor.

from azureml.train.dnn import TensorFlow

distributed_training = TensorflowConfiguration()
distributed_training.worker_count = 2

# Tensorflow constructor
tf_est= TensorFlow(source_directory=project_folder,
                      compute_target=compute_target,
                      script_params=script_params,
                      entry_script='script.py',
                      node_count=2,
                      process_count_per_node=1,
                      distributed_training=distributed_training,
                      use_gpu=True,
                      pip_packages=['azureml-dataprep[pandas,fuse]'])

# submit the TensorFlow job
run = exp.submit(tf_est)

Adja meg a fürt specifikációit a következőben: "TF_CONFIG"Define cluster specifications in 'TF_CONFIG`

Szükség van a fürt hálózati címeire és portjaira is tf.train.ClusterSpec, így Azure Machine learning beállítja a TF_CONFIG környezeti változót.You also need the network addresses and ports of the cluster for the tf.train.ClusterSpec, so Azure Machine Learning sets the TF_CONFIG environment variable for you.

A TF_CONFIG környezeti változó egy JSON-karakterlánc.The TF_CONFIG environment variable is a JSON string. Íme egy példa a paraméter-kiszolgáló változóra:Here is an example of the variable for a parameter server:

TF_CONFIG='{
    "cluster": {
        "ps": ["host0:2222", "host1:2222"],
        "worker": ["host2:2222", "host3:2222", "host4:2222"],
    },
    "task": {"type": "ps", "index": 0},
    "environment": "cloud"
}'

A TensorFlow magas szintű tf.estimator API-ja esetében a TensorFlow elemzi TF_CONFIG a változót, és létrehozza a fürt specifikációját.For TensorFlow's high level tf.estimator API, TensorFlow parses the TF_CONFIG variable and builds the cluster spec for you.

A TensorFlow alsóbb szintű alapszintű API-jai a betanításhoz, a TF_CONFIG változó tf.train.ClusterSpec elemzéséhez és a betanítási kódban való létrehozásához.For TensorFlow's lower-level core APIs for training, parse the TF_CONFIG variable and build the tf.train.ClusterSpec in your training code.

import os, json
import tensorflow as tf

tf_config = os.environ.get('TF_CONFIG')
if not tf_config or tf_config == "":
    raise ValueError("TF_CONFIG not found.")
tf_config_json = json.loads(tf_config)
cluster_spec = tf.train.ClusterSpec(cluster)

TensorFlow-modell üzembe helyezéseDeploy a TensorFlow model

A korábban regisztrált modell ugyanúgy helyezhető üzembe, mint bármely más regisztrált modell Azure Machine Learningban, függetlenül attól, hogy milyen kalkulátort használt a betanításhoz.The model you just registered can be deployed the exact same way as any other registered model in Azure Machine Learning, regardless of which estimator you used for training. Az üzembe helyezési útmutató egy szakaszt tartalmaz a modellek regisztrálásához, de közvetlenül kihagyhatja a központi telepítéshez szükséges számítási cél létrehozását , mivel már rendelkezik regisztrált modellel.The deployment how-to contains a section on registering models, but you can skip directly to creating a compute target for deployment, since you already have a registered model.

Előnézet Nem kód modell telepítése(Preview) No-code model deployment

A hagyományos üzembe helyezési útvonal helyett a kód nélküli üzembe helyezési funkciót (előzetes verzió) is használhatja a Tensorflow.Instead of the traditional deployment route, you can also use the no-code deployment feature (preview) for Tensorflow. Ha a fentiekben látható módon regisztrálja a modellt model_framework, model_framework_versionés resource_configuration a paramétereket is használja, egyszerűen használhatja a deploy() statikus függvényt a modell üzembe helyezéséhez.By registering your model as shown above with the model_framework, model_framework_version, and resource_configuration parameters, you can simply use the deploy() static function to deploy your model.

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

A teljes körű útmutató a Azure Machine learning nagyobb részletességgel történő üzembe helyezését ismerteti.The full how-to covers deployment in Azure Machine Learning in greater depth.

További lépésekNext steps

Ebben a cikkben egy TensorFlow-modellt oktatott és regisztrált, és megismerte az üzembe helyezési lehetőségeket.In this article, you trained and registered a TensorFlow model, and learned about options for deployment. Ezekről a cikkekről további tudnivalókat talál a Azure Machine Learningról.See these other articles to learn more about Azure Machine Learning.