TensorFlow se škálováním modelů pomocí Azure Machine LearningTrain TensorFlow models at scale with Azure Machine Learning

V tomto článku se naučíte, jak spustit školicí skripty TensorFlow ve velkém měřítku pomocí Azure Machine Learning.In this article, learn how to run your TensorFlow training scripts at scale using Azure Machine Learning.

V tomto příkladu se navlacích a registruje TensorFlow model pro klasifikaci psaných číslic pomocí neuronové sítě (DNN).This example trains and registers a TensorFlow model to classify handwritten digits using a deep neural network (DNN).

Bez ohledu na to, jestli vyvíjíte model TensorFlow z provozu nebo přenášíte existující model do cloudu, můžete použít Azure Machine Learning k horizontálnímu navýšení kapacity Open-Source školicích úloh pro sestavování, nasazování, správu a monitorování modelů produkčního prostředí.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.

PožadavkyPrerequisites

Spusťte tento kód v jednom z těchto prostředí:Run this code on either of these environments:

Nastavení experimentuSet up the experiment

Tato část nastavuje experimenty školení načtením požadovaných balíčků Pythonu, inicializací pracovního prostoru, vytvořením cíle výpočtů a definováním školicího prostředí.This section sets up the training experiment by loading the required Python packages, initializing a workspace, creating the compute target, and defining the training environment.

Import balíčkůImport packages

Nejdřív importujte nezbytné knihovny Pythonu.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 import Environment

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

Inicializovat pracovní prostorInitialize a workspace

Azure Machine Learning pracovní prostor je prostředek nejvyšší úrovně pro službu.The Azure Machine Learning workspace is the top-level resource for the service. Poskytuje centralizované místo pro práci se všemi artefakty, které vytvoříte.It provides you with a centralized place to work with all the artifacts you create. V sadě Python SDK máte přístup k artefaktům pracovního prostoru vytvořením workspace objektu.In the Python SDK, you can access the workspace artifacts by creating a workspace object.

Vytvořte objekt pracovního prostoru ze config.json souboru vytvořeného v části požadavky.Create a workspace object from the config.json file created in the prerequisites section.

ws = Workspace.from_config()

Vytvoření datové sady souborůCreate a file dataset

FileDatasetObjekt odkazuje na jeden nebo více souborů v úložišti dat pracovního prostoru nebo veřejných adresách URL.A FileDataset object references one or multiple files in your workspace datastore or public urls. Soubory mohou být libovolného formátu a třída poskytuje možnost stahovat nebo připojovat soubory do výpočtů.The files can be of any format, and the class provides you with the ability to download or mount the files to your compute. Vytvořením vytvoříte FileDataset odkaz na umístění zdroje dat.By creating a FileDataset, you create a reference to the data source location. Pokud jste v sadě dat použili jakékoli transformace, budou uloženy i v datové sadě.If you applied any transformations to the data set, they will be stored in the data set as well. Data zůstanou ve svém stávajícím umístění, takže se neúčtují žádné dodatečné náklady na úložiště.The data remains in its existing location, so no extra storage cost is incurred. Další informace najdete v průvodci vytvořením Dataset balíčku.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)

Pomocí register() metody zaregistrujete datovou sadu do svého pracovního prostoru, aby bylo možné je sdílet s ostatními, znovu použít v různých experimentech a v rámci školicího skriptu, na které se odkazuje pomocí názvu.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()

Vytvořit cíl výpočtůCreate a compute target

Vytvořte výpočetní cíl pro úlohu TensorFlow, na které se má spustit.Create a compute target for your TensorFlow job to run on. V tomto příkladu vytvoříte výpočetní cluster Azure Machine Learning s podporou GPU.In this example, create a GPU-enabled Azure Machine Learning compute cluster.

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)

Poznámka

Můžete použít virtuální počítače s nízkou prioritou ke spuštění některých nebo všech úloh.You may choose to use low-priority VMs to run some or all of your workloads. Podívejte se, jak vytvořit virtuální počítač s nízkou prioritou.See how to create a low-priority VM.

Další informace o výpočetních cílech najdete v článku co je cílový výpočetní cíl .For more information on compute targets, see the what is a compute target article.

Definice prostředíDefine your environment

Pokud chcete definovat prostředí Azure ml, které zapouzdřuje závislosti školicího skriptu, můžete buď definovat vlastní prostředí, nebo použít prostředí Azure ml s využitím.To define the Azure ML Environment that encapsulates your training script's dependencies, you can either define a custom environment or use an Azure ML curated environment.

Použití spravovaného prostředíUse a curated environment

Azure ML poskytuje předem vytvořená a poduspořádaná prostředí, pokud nechcete definovat vlastní prostředí.Azure ML provides prebuilt, curated environments if you don't want to define your own environment. Azure ML obsahuje několik PROCESORových a procesorových prostředí GPU pro TensorFlow, která odpovídají různým verzím TensorFlow.Azure ML has several CPU and GPU curated environments for TensorFlow corresponding to different versions of TensorFlow. Další informace najdete tady.For more info, see here.

Pokud chcete použít konkrétní prostředí, můžete místo toho spustit následující příkaz:If you want to use a curated environment, you can run the following command instead:

curated_env_name = 'AzureML-TensorFlow-2.2-GPU'
tf_env = Environment.get(workspace=ws, name=curated_env_name)

Pokud chcete zobrazit balíčky zahrnuté ve spravovaném prostředí, můžete na disk zapsat závislosti conda:To see the packages included in the curated environment, you can write out the conda dependencies to disk:

tf_env.save_to_directory(path=curated_env_name)

Ujistěte se, že ve spravovaném prostředí jsou všechny závislosti vyžadované školicím skriptem.Make sure the curated environment includes all the dependencies required by your training script. V takovém případě budete muset upravit prostředí tak, aby obsahovalo chybějící závislosti.If not, you will have to modify the environment to include the missing dependencies. Všimněte si, že pokud je prostředí upraveno, budete ho muset dát novému názvu, protože předpona ' AzureML ' je vyhrazena pro prostředí, která jsou v něm uspořádaná.Note that if the environment is modified, you will have to give it a new name, as the 'AzureML' prefix is reserved for curated environments. Pokud jste změnili soubor conda závislosti YAML, můžete z něj vytvořit nové prostředí s novým názvem, třeba:If you modified the conda dependencies YAML file, you can create a new environment from it with a new name, e.g.:

tf_env = Environment.from_conda_specification(name='tensorflow-2.2-gpu', file_path='./conda_dependencies.yml')

Pokud jste místo toho změnili objekt s podmnožinou prostředí přímo, můžete toto prostředí klonovat pomocí nového názvu:If you had instead modified the curated environment object directly, you can clone that environment with a new name:

tf_env = tf_env.clone(new_name='tensorflow-2.2-gpu')

Vytvoření vlastního prostředíCreate a custom environment

Můžete také vytvořit vlastní prostředí Azure ML, které zapouzdřuje závislosti školicího skriptu.You can also create your own Azure ML environment that encapsulates your training script's dependencies.

Nejprve v souboru YAML definujte závislosti conda; v tomto příkladu je soubor pojmenován conda_dependencies.yml .First, define your conda dependencies in a YAML file; in this example the file is named conda_dependencies.yml.

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

Vytvořte prostředí Azure ML z této specifikace prostředí conda.Create an Azure ML environment from this conda environment specification. Prostředí se zabalí do kontejneru Docker za běhu.The environment will be packaged into a Docker container at runtime.

Ve výchozím nastavení, pokud není zadaná žádná základní image, Azure ML použije image procesoru azureml.core.environment.DEFAULT_CPU_IMAGE jako základní image.By default if no base image is specified, Azure ML will use a CPU image azureml.core.environment.DEFAULT_CPU_IMAGE as the base image. Vzhledem k tomu, že tento příklad spustí školení v clusteru GPU, budete muset zadat základní image GPU, která má potřebné ovladače a závislosti GPU.Since this example runs training on a GPU cluster, you will need to specify a GPU base image that has the necessary GPU drivers and dependencies. Azure ML udržuje sadu základních imagí publikovaných v Microsoft Container Registry (MCR), které můžete použít, další informace najdete v úložišti GitHub Azure/AzureML-Containers .Azure ML maintains a set of base images published on Microsoft Container Registry (MCR) that you can use, see the Azure/AzureML-Containers GitHub repo for more information.

tf_env = Environment.from_conda_specification(name='tensorflow-2.2-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'

Tip

Volitelně můžete zachytit všechny závislosti přímo ve vlastní imagi Docker nebo v souboru Dockerfile a vytvořit prostředí z něj.Optionally, you can just capture all your dependencies directly in a custom Docker image or Dockerfile, and create your environment from that. Další informace najdete v tématu výuka s vlastní imagí.For more information, see Train with custom image.

Další informace o vytváření a používání prostředí najdete v tématu vytváření a používání softwarových prostředí v Azure Machine Learning.For more information on creating and using environments, see Create and use software environments in Azure Machine Learning.

Konfigurace a odeslání školicích běhůConfigure and submit your training run

Vytvoření ScriptRunConfigCreate a ScriptRunConfig

Vytvořte objekt ScriptRunConfig a zadejte podrobnosti o konfiguraci školicí úlohy, včetně vašeho školicího skriptu, prostředí, které se má použít, a výpočetní cíl, který se má spustit.Create a ScriptRunConfig object to specify the configuration details of your training job, including your training script, environment to use, and the compute target to run on. Jakékoli argumenty školicího skriptu budou předány prostřednictvím příkazového řádku, pokud je zadáno v arguments parametru.Any arguments to your training script will be passed via command line if specified in the arguments parameter.

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)

Upozornění

Azure Machine Learning spouští školicí skripty zkopírováním celého zdrojového adresáře.Azure Machine Learning runs training scripts by copying the entire source directory. Pokud máte citlivá data, která nechcete nahrávat, použijte soubor. Ignore nebo ho nezahrnujte do zdrojového adresáře.If you have sensitive data that you don't want to upload, use a .ignore file or don't include it in the source directory . Místo toho ke svým datům dostanete přístup pomocí datové sadyAzure ml.Instead, access your data using an Azure ML dataset.

Další informace o konfiguraci úloh pomocí ScriptRunConfig najdete v tématu Konfigurace a odeslání školicích běhů.For more information on configuring jobs with ScriptRunConfig, see Configure and submit training runs.

Upozornění

Pokud jste dříve používali TensorFlow Estimator ke konfiguraci školicích úloh TensorFlow, Upozorňujeme, že odhady byly zastaralé jako verze sady 1.19.0 SDK.If you were previously using the TensorFlow estimator to configure your TensorFlow training jobs, please note that Estimators have been deprecated as of the 1.19.0 SDK release. S Azure ML SDK >= 1.15.0, ScriptRunConfig je doporučeným způsobem konfigurace školicích úloh, včetně těch, které používají architekturu pro hloubkové učení.With Azure ML SDK >= 1.15.0, ScriptRunConfig is the recommended way to configure training jobs, including those using deep learning frameworks. Běžné otázky týkající se migrace najdete v Průvodci migrací Estimator do ScriptRunConfig.For common migration questions, see the Estimator to ScriptRunConfig migration guide.

Odeslat běhSubmit a run

Objekt Run poskytuje rozhraní k historii spuštění, když je úloha spuštěná a po jejím dokončení.The Run object provides the interface to the run history while the job is running and after it has completed.

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

Co se stane při spuštěníWhat happens during run execution

Po spuštění se spustí v následujících fázích:As the run is executed, it goes through the following stages:

  • Příprava: image Docker se vytvoří podle definovaného prostředí.Preparing: A docker image is created according to the environment defined. Obrázek se nahraje do registru kontejneru v pracovním prostoru a v mezipaměti pro pozdější spuštění.The image is uploaded to the workspace's container registry and cached for later runs. Protokoly se také streamují do historie spuštění a dají se zobrazit ke sledování průběhu.Logs are also streamed to the run history and can be viewed to monitor progress. Pokud je místo toho zadáno spravované prostředí, bude použit obrázek uložený v mezipaměti, který bude toto prostředí obsahovat.If a curated environment is specified instead, the cached image backing that curated environment will be used.

  • Škálování: cluster se pokusí o horizontální navýšení kapacity, pokud Batch AI cluster vyžaduje více uzlů pro spuštění běhu, než je aktuálně k dispozici.Scaling: The cluster attempts to scale up if the Batch AI cluster requires more nodes to execute the run than are currently available.

  • Spuštěno: všechny skripty ve složce skriptu se nahrají do cílového výpočetního prostředí, úložiště dat se připojí nebo zkopírují a script spustí se.Running: All scripts in the script folder are uploaded to the compute target, data stores are mounted or copied, and the script is executed. Výstupy z stdout a složky ./logs se streamují do historie spuštění a dají se použít k monitorování běhu.Outputs from stdout and the ./logs folder are streamed to the run history and can be used to monitor the run.

  • Následné zpracování: složka ./Outputs se v běhu kopíruje do historie spuštění.Post-Processing: The ./outputs folder of the run is copied over to the run history.

Registrace nebo stažení modeluRegister or download a model

Po proškolení modelu ho můžete zaregistrovat do svého pracovního prostoru.Once you've trained the model, you can register it to your workspace. Registrace modelu umožňuje ukládat a modelovat vaše modely do svého pracovního prostoru, aby bylo možné zjednodušit správu modelů a nasazení.Model registration lets you store and version your models in your workspace to simplify model management and deployment. Volitelné: zadáním parametrů model_framework , model_framework_version , a resource_configuration , nasazení modelu bez kódu bude k dispozici.Optional: by specifying the parameters model_framework, model_framework_version, and resource_configuration, no-code model deployment becomes available. To vám umožní přímo nasadit model jako webovou službu z registrovaného modelu a ResourceConfiguration objekt definuje výpočetní prostředek pro webovou službu.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-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))

Místní kopii modelu můžete také stáhnout pomocí objektu run.You can also download a local copy of the model by using the Run object. Ve školicím skriptu tf_mnist.py objekt TensorFlow spořiče uchovává model do místní složky (místní k cíli výpočtů).In the training script tf_mnist.py, a TensorFlow saver object persists the model to a local folder (local to the compute target). Kopii můžete stáhnout pomocí objektu spustit.You can use the Run object to download a copy.

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

Distribuované trénováníDistributed training

Azure Machine Learning podporuje také distribuované úlohy TensorFlow s více uzly, abyste mohli škálovat školicí úlohy.Azure Machine Learning also supports multi-node distributed TensorFlow jobs so that you can scale your training workloads. Můžete snadno spouštět distribuované úlohy TensorFlow a Azure ML bude spravovat orchestraci za vás.You can easily run distributed TensorFlow jobs and Azure ML will manage the orchestration for you.

Azure ML podporuje spouštění distribuovaných úloh TensorFlow s integrovaným rozhraním API pro distribuované školení Horovod a TensorFlow.Azure ML supports running distributed TensorFlow jobs with both Horovod and TensorFlow's built-in distributed training API.

HorovodHorovod

Horovod je open source, což snižuje rámec pro distribuované školení vyvinuté pomocí Uber.Horovod is an open-source, all reduce framework for distributed training developed by Uber. Nabízí snadnou cestu k psaní distribuovaného TensorFlow kódu pro školení.It offers an easy path to writing distributed TensorFlow code for training.

Školicí kód bude nutné instrumentovat s Horovod pro distribuované školení.Your training code will have to be instrumented with Horovod for distributed training. Další informace o použití Horovod s TensorFlow najdete v dokumentaci Horovod:For more information using Horovod with TensorFlow, refer to Horovod documentation:

Další informace o použití Horovod s TensorFlow najdete v dokumentaci Horovod:For more information on using Horovod with TensorFlow, refer to Horovod documentation:

Navíc se ujistěte, že vaše školicí prostředí obsahuje balíček horovod .Additionally, make sure your training environment includes the horovod package. Pokud používáte TensorFlowé prostředí, horovod už je součástí jedné ze závislostí.If you are using a TensorFlow curated environment, horovod is already included as one of the dependencies. Pokud používáte vlastní prostředí, ujistěte se, že je zahrnutá závislost horovod, například:If you are using your own environment, make sure the horovod dependency is included, for example:

channels:
- conda-forge
dependencies:
- python=3.6.2
- pip:
  - azureml-defaults
  - tensorflow-gpu==2.2.0
  - horovod==0.19.5

Aby bylo možné spustit distribuovanou úlohu pomocí MPI/Horovod v Azure ML, je nutné zadat MpiConfiguration do distributed_job_config parametru konstruktoru ScriptRunConfig.In order to execute a distributed job using MPI/Horovod on Azure ML, you must specify an MpiConfiguration to the distributed_job_config parameter of the ScriptRunConfig constructor. Níže uvedený kód nakonfiguruje distribuovanou úlohu se dvěma uzly se spuštěným jedním procesem na jeden uzel.The below code will configure a 2-node distributed job running one process per node. Pokud chcete spustit více procesů na jeden uzel (tj. Pokud má SKU clusteru více GPU), zadejte také process_count_per_node parametr v MpiConfiguration (výchozí nastavení je 1 ).If you would also like to run multiple processes per node (i.e. if your cluster SKU has multiple GPUs), additionally specify the process_count_per_node parameter in MpiConfiguration (the default is 1).

from azureml.core import ScriptRunConfig
from azureml.core.runconfig import MpiConfiguration

src = ScriptRunConfig(source_directory=project_folder,
                      script='tf_horovod_word2vec.py',
                      arguments=['--input_data', dataset.as_mount()],
                      compute_target=compute_target,
                      environment=tf_env,
                      distributed_job_config=MpiConfiguration(node_count=2))

Úplný kurz pro spouštění distribuovaných TensorFlow s Horovod v Azure ML najdete v tématu Distributed TensorFlow with Horovod.For a full tutorial on running distributed TensorFlow with Horovod on Azure ML, see Distributed TensorFlow with Horovod.

TF. Distributetf.distribute

Pokud používáte nativní distribuované TensorFlow v kódu školení, např. TensorFlow 2. x tf.distribute.Strategy rozhraní API, můžete také spustit distribuovanou úlohu prostřednictvím Azure ml.If you are using native distributed TensorFlow in your training code, e.g. TensorFlow 2.x's tf.distribute.Strategy API, you can also launch the distributed job via Azure ML.

Provedete to tak, že zadáte TensorflowConfiguration do distributed_job_config parametru konstruktoru ScriptRunConfig.To do so, specify a TensorflowConfiguration to the distributed_job_config parameter of the ScriptRunConfig constructor. Pokud používáte tf.distribute.experimental.MultiWorkerMirroredStrategy , zadejte worker_count v TensorflowConfiguration odpovídající počtu uzlů pro vaši úlohu školení.If you are using tf.distribute.experimental.MultiWorkerMirroredStrategy, specify the worker_count in the TensorflowConfiguration corresponding to the number of nodes for your training job.

import os
from azureml.core import ScriptRunConfig
from azureml.core.runconfig import TensorflowConfiguration

distr_config = TensorflowConfiguration(worker_count=2, parameter_server_count=0)

model_path = os.path.join("./outputs", "keras-model")

src = ScriptRunConfig(source_directory=source_dir,
                      script='train.py',
                      arguments=["--epochs", 30, "--model-dir", model_path],
                      compute_target=compute_target,
                      environment=tf_env,
                      distributed_job_config=distr_config)

V TensorFlow TF_CONFIG je proměnná prostředí nutná pro školení na více počítačích.In TensorFlow, the TF_CONFIG environment variable is required for training on multiple machines. Azure ML TF_CONFIG před spuštěním školicího skriptu nakonfiguruje a nastaví proměnnou odpovídajícím způsobem pro každý pracovní proces.Azure ML will configure and set the TF_CONFIG variable appropriately for each worker before executing your training script. TF_CONFIGPokud potřebujete přes, můžete získat přístup ze školicího skriptu os.environ['TF_CONFIG'] .You can access TF_CONFIG from your training script if you need to via os.environ['TF_CONFIG'].

Příklad struktury TF_CONFIG sady pro hlavní pracovní uzel:Example structure of TF_CONFIG set on a chief worker node:

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

Pokud váš školicí skript používá strategii serveru parametrů pro distribuované školení, tj. pro starší verze TensorFlow 1. x, bude také potřeba zadat počet serverů parametrů, které mají být v úloze použity, např. distr_config = TensorflowConfiguration(worker_count=2, parameter_server_count=1) .If your training script uses the parameter server strategy for distributed training, i.e. for legacy TensorFlow 1.x, you will also need to specify the number of parameter servers to use in the job, e.g. distr_config = TensorflowConfiguration(worker_count=2, parameter_server_count=1).

Nasazení modelu TensorFlowDeploy a TensorFlow model

Postup nasazení obsahuje část týkající se registrace modelů, ale můžete přeskočit přímo na Vytvoření výpočetního cíle pro nasazení, protože již máte registrovaný model.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.

Tisk Nasazení modelu bez kódu(Preview) No-code model deployment

Místo tradičního postupu nasazení můžete také použít funkci nasazení bez kódu (Preview) pro TensorFlow.Instead of the traditional deployment route, you can also use the no-code deployment feature (preview) for TensorFlow. Registrací modelu, jak je uvedeno výše, model_framework pomocí model_framework_version parametrů, a resource_configuration můžete jednoduše použít deploy() statickou funkci pro nasazení modelu.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])

Úplný postup pokrývá nasazení v Azure Machine Learning s větší hloubkou.The full how-to covers deployment in Azure Machine Learning in greater depth.

Další krokyNext steps

V tomto článku jste si naučili a zaregistrovali model TensorFlow a seznámili jste se s možnostmi nasazení.In this article, you trained and registered a TensorFlow model, and learned about options for deployment. Další informace o Azure Machine Learning najdete v těchto článcích.See these other articles to learn more about Azure Machine Learning.