Distribuire modelli con Azure Machine LearningDeploy models with Azure Machine Learning

Informazioni su come distribuire un modello di machine learning come servizio Web nel cloud di Azure o per Azure IoT Edge dispositivi.Learn how to deploy your machine learning model as a web service in the Azure cloud or to Azure IoT Edge devices.

Il flusso di lavoro è simile indipendentemente da dove si distribuisce il modello:The workflow is similar no matter where you deploy your model:

  1. Registrare il modello.Register the model.
  2. Preparare la distribuzione.Prepare to deploy. (Specificare asset, utilizzo, destinazione di calcolo.)(Specify assets, usage, compute target.)
  3. Distribuire il modello nella destinazione di calcolo.Deploy the model to the compute target.
  4. Testare il modello distribuito, detto anche servizio Web.Test the deployed model, also called a web service.

Per ulteriori informazioni sui concetti relativi al flusso di lavoro di distribuzione, vedere gestire, distribuire e monitorare i modelli con Azure Machine Learning.For more information on the concepts involved in the deployment workflow, see Manage, deploy, and monitor models with Azure Machine Learning.

PrerequisitiPrerequisites

Connettersi all'area di lavoroConnect to your workspace

Il codice seguente illustra come connettersi a un'area di lavoro di Azure Machine Learning usando le informazioni memorizzate nella cache per l'ambiente di sviluppo locale:The following code shows how to connect to an Azure Machine Learning workspace by using information cached to the local development environment:

  • Uso dell'SDKUsing the SDK

    from azureml.core import Workspace
    ws = Workspace.from_config(path=".file-path/ws_config.json")
    

    Per altre informazioni sull'uso dell'SDK per connettersi a un'area di lavoro, vedere la documentazione di Azure Machine Learning SDK per Python .For more information on using the SDK to connect to a workspace, see the Azure Machine Learning SDK for Python documentation.

  • Uso dell'interfaccia della riga di comandoUsing the CLI

    Quando si usa l'interfaccia della riga -w di --workspace-name comando, usare il parametro o per specificare l'area di lavoro per il comando.When using the CLI, use the -w or --workspace-name parameter to specify the workspace for the command.

  • Utilizzo di VS CodeUsing VS Code

    Quando si utilizza VS Code, è possibile selezionare l'area di lavoro utilizzando un'interfaccia grafica.When you use VS Code, you select the workspace by using a graphical interface. Per ulteriori informazioni, vedere la pagina relativa alla distribuzione e gestione dei modelli nella documentazione sull'estensione vs code.For more information, see Deploy and manage models in the VS Code extension documentation.

Registrare il modelloRegister your model

Un modello registrato è un contenitore logico per uno o più file che costituiscono il modello.A registered model is a logical container for one or more files that make up your model. Se, ad esempio, si dispone di un modello archiviato in più file, è possibile registrarli come singolo modello nell'area di lavoro.For example, if you have a model that's stored in multiple files, you can register them as a single model in the workspace. Dopo aver registrato i file, è possibile scaricare o distribuire il modello registrato e ricevere tutti i file registrati.After you register the files, you can then download or deploy the registered model and receive all the files that you registered.

Suggerimento

Quando si registra un modello, si specifica il percorso di una posizione cloud (da un'esecuzione di training) o di una directory locale.When you register a model, you provide the path of either a cloud location (from a training run) or a local directory. Questo percorso consente di individuare solo i file da caricare come parte del processo di registrazione.This path is just to locate the files for upload as part of the registration process. Non è necessario che corrisponda al percorso utilizzato nello script di immissione.It doesn't need to match the path used in the entry script. Per ulteriori informazioni, vedere che cos'è get_model_path?.For more information, see What is get_model_path?.

I modelli di apprendimento automatico vengono registrati nell'area di lavoro Azure Machine Learning.Machine learning models are registered in your Azure Machine Learning workspace. Il modello può provenire da Azure Machine Learning o da un'altra posizione.The model can come from Azure Machine Learning or from somewhere else. Negli esempi seguenti viene illustrato come registrare un modello.The following examples demonstrate how to register a model.

Registrare un modello da un'esecuzione dell'esperimentoRegister a model from an experiment run

I frammenti di codice in questa sezione illustrano come registrare un modello da un'esecuzione di training:The code snippets in this section demonstrate how to register a model from a training run:

Importante

Per usare questi frammenti, è necessario aver eseguito in precedenza un'esecuzione del Run training ed è necessario avere accesso all'oggetto (esempio di SDK) o al valore dell'ID esecuzione (esempio dell'interfaccia della riga di comando).To use these snippets, you need to have previously performed a training run and you need to have access to the Run object (SDK example) or the run ID value (CLI example). Per altre informazioni sui modelli di training, vedere configurare le destinazioni di calcolo per il training del modello.For more information on training models, see Set up compute targets for model training.

  • Uso dell'SDKUsing the SDK

    Quando si usa l'SDK per eseguire il training di un modello, è possibile ricevere un oggetto Run o un oggetto AutoMLRun , a seconda di come è stato eseguito il training del modello.When you use the SDK to train a model, you can receive either a Run object or an AutoMLRun object, depending on how you trained the model. Ogni oggetto può essere usato per registrare un modello creato da un'esecuzione dell'esperimento.Each object can be used to register a model created by an experiment run.

    • Registrare un modello da un azureml.core.Run oggetto:Register a model from an azureml.core.Run object:

      model = run.register_model(model_name='sklearn_mnist', model_path='outputs/sklearn_mnist_model.pkl')
      print(model.name, model.id, model.version, sep='\t')
      

      Il model_path parametro fa riferimento alla posizione cloud del modello.The model_path parameter refers to the cloud location of the model. In questo esempio viene usato il percorso di un singolo file.In this example, the path of a single file is used. Per includere più file nella registrazione del modello, impostare model_path sul percorso di una cartella che contiene i file.To include multiple files in the model registration, set model_path to the path of a folder that contains the files. Per ulteriori informazioni, vedere la documentazione di Run. register_model .For more information, see the Run.register_model documentation.

    • Registrare un modello da un azureml.train.automl.run.AutoMLRun oggetto:Register a model from an azureml.train.automl.run.AutoMLRun object:

          description = 'My AutoML Model'
          model = run.register_model(description = description)
      
          print(run.model_id)
      

      In questo esempio, i metric parametri iteration e non vengono specificati, quindi l'iterazione con la metrica primaria migliore verrà registrata.In this example, the metric and iteration parameters aren't specified, so the iteration with the best primary metric will be registered. Il model_id valore restituito dall'esecuzione viene utilizzato al posto di un nome di modello.The model_id value returned from the run is used instead of a model name.

      Per ulteriori informazioni, vedere la documentazione di AutoMLRun. register_model .For more information, see the AutoMLRun.register_model documentation.

  • Uso dell'interfaccia della riga di comandoUsing the CLI

    az ml model register -n sklearn_mnist  --asset-path outputs/sklearn_mnist_model.pkl  --experiment-name myexperiment --run-id myrunid
    

    Suggerimento

    Se viene visualizzato un messaggio di errore che informa che l'estensione ML non è installata, usare il comando seguente per installarla:If you get an error message stating that the ml extension isn't installed, use the following command to install it:

    az extension add -n azure-cli-ml
    

    Il --asset-path parametro fa riferimento alla posizione cloud del modello.The --asset-path parameter refers to the cloud location of the model. In questo esempio viene usato il percorso di un singolo file.In this example, the path of a single file is used. Per includere più file nella registrazione del modello, impostare --asset-path sul percorso di una cartella che contiene i file.To include multiple files in the model registration, set --asset-path to the path of a folder that contains the files.

  • Utilizzo di VS CodeUsing VS Code

    Registrare i modelli usando i file o le cartelle del modello usando l'estensione vs code .Register models using any model files or folders by using the VS Code extension.

Registrare un modello da un file localeRegister a model from a local file

Per registrare un modello, è possibile fornire il percorso locale del modello.You can register a model by providing the local path of the model. È possibile specificare il percorso di una cartella o di un singolo file.You can provide the path of either a folder or a single file. È possibile utilizzare questo metodo per registrare i modelli sottoposti a training con Azure Machine Learning e quindi scaricarli.You can use this method to register models trained with Azure Machine Learning and then downloaded. È anche possibile usare questo metodo per registrare i modelli sottoposti a training al di fuori della Azure Machine Learning.You can also use this method to register models trained outside of Azure Machine Learning.

Importante

È consigliabile utilizzare solo i modelli creati o ottenuti da un'origine attendibile.You should use only models that you create or obtain from a trusted source. È consigliabile considerare i modelli serializzati come codice, perché le vulnerabilità di sicurezza sono state individuate in diversi formati diffusi.You should treat serialized models as code, because security vulnerabilities have been discovered in a number of popular formats. Inoltre, è possibile che i modelli siano stati intenzionalmente sottoposti a training con finalità dannose per fornire output distorto o non accurato.Also, models might be intentionally trained with malicious intent to provide biased or inaccurate output.

  • Uso di SDK e ONNXUsing the SDK and ONNX

    import os
    import urllib.request
    from azureml.core import Model
    # Download model
    onnx_model_url = "https://www.cntk.ai/OnnxModels/mnist/opset_7/mnist.tar.gz"
    urllib.request.urlretrieve(onnx_model_url, filename="mnist.tar.gz")
    os.system('tar xvzf mnist.tar.gz')
    # Register model
    model = Model.register(workspace = ws,
                            model_path ="mnist/model.onnx",
                            model_name = "onnx_mnist",
                            tags = {"onnx": "demo"},
                            description = "MNIST image classification CNN from ONNX Model Zoo",)
    

    Per includere più file nella registrazione del modello, impostare model_path sul percorso di una cartella che contiene i file.To include multiple files in the model registration, set model_path to the path of a folder that contains the files.

  • Uso dell'interfaccia della riga di comandoUsing the CLI

    az ml model register -n onnx_mnist -p mnist/model.onnx
    

    Per includere più file nella registrazione del modello, impostare -p sul percorso di una cartella che contiene i file.To include multiple files in the model registration, set -p to the path of a folder that contains the files.

Tempo stimato: circa 10 secondi.Time estimate: Approximately 10 seconds.

Per ulteriori informazioni, vedere la documentazione relativa alla classe del modello.For more information, see the documentation for the Model class.

Per ulteriori informazioni sull'utilizzo di modelli sottoposti a training all'esterno di Azure Machine Learning, vedere come distribuire un modello esistente.For more information on working with models trained outside Azure Machine Learning, see How to deploy an existing model.

Scegliere una destinazione di calcoloChoose a compute target

Per ospitare la distribuzione del servizio Web, è possibile usare le seguenti destinazioni di calcolo o risorse di calcolo:You can use the following compute targets, or compute resources, to host your web service deployment:

Destinazione del calcoloCompute target Utilizzato perUsed for Supporto GPUGPU support Supporto per FPGAFPGA support DescrizioneDescription
Servizio Web localeLocal web service Test/debugTesting/debugging     Usare per i test e la risoluzione dei problemi limitati.Use for limited testing and troubleshooting. L'accelerazione hardware dipende dall'uso di librerie nel sistema locale.Hardware acceleration depends on use of libraries in the local system.
Servizio Web  VM notebookNotebook VM web service Test/debugTesting/debugging     Usare per i test e la risoluzione dei problemi limitati.Use for limited testing and troubleshooting.
Servizio Azure KubernetesAzure Kubernetes Service (AKS) Inferenza in tempo realeReal-time inference (distribuzione servizio Web)Yes (web service deployment) Yes Usare per le distribuzioni di produzione su vasta scala.Use for high-scale production deployments. Fornisce tempi di risposta rapidi e scalabilità automatica del servizio distribuito.Provides fast response time and autoscaling of the deployed service. La scalabilità automatica del cluster non è supportata tramite il Azure Machine Learning SDK.Cluster autoscaling isn't supported through the Azure Machine Learning SDK. Per modificare i nodi nel cluster AKS, usare l'interfaccia utente per il cluster AKS nell'portale di Azure.To change the nodes in the AKS cluster, use the UI for your AKS cluster in the Azure portal. AKS è l'unica opzione disponibile per l'interfaccia visiva.AKS is the only option available for the visual interface.
Istanze di Azure ContainerAzure Container Instances Test o sviluppoTesting or development     Usare per carichi di lavoro basati su CPU su scala ridotta che richiedono meno di 48 GB di RAM.Use for low-scale CPU-based workloads that require less than 48 GB of RAM.
Ambiente di calcolo di Machine LearningAzure Machine Learning Compute Anteprima Inferenza batch (Preview) Batch inference (pipeline di machine learning)Yes (machine learning pipeline)   Eseguire il Punteggio batch su calcolo senza server.Run batch scoring on serverless compute. Supporta le macchine virtuali normali e con priorità bassa.Supports normal and low-priority VMs.
Azure IoT EdgeAzure IoT Edge Anteprima  Modulo Internet delle cose(Preview) IoT module     Distribuire e gestire modelli di Machine Learning nei dispositivi Internet.Deploy and serve ML models on IoT devices.
Azure Data Box EdgeAzure Data Box Edge Tramite IoT EdgeVia IoT Edge   Yes Distribuire e gestire modelli di Machine Learning nei dispositivi Internet.Deploy and serve ML models on IoT devices.

Nota

Sebbene le destinazioni di calcolo come macchine virtuali locali, notebook e Azure Machine Learning supportano la GPU per la formazione e la sperimentazione, l'uso della GPU per l'inferenza quando viene distribuito come servizio Web è supportato solo nel servizio Azure Kubernetes.Although compute targets like local, Notebook VM, and Azure Machine Learning Compute support GPU for training and experimentation, using GPU for inference when deployed as a web service is supported only on Azure Kubernetes Service.

L'uso di una GPU per l'inferenza quando il punteggio con una pipeline di Machine Learning è supportato solo nel calcolo Azure Machine Learning.Using a GPU for inference when scoring with a machine learning pipeline is supported only on Azure Machine Learning Compute.

Preparare la distribuzionePrepare to deploy

Per distribuire il modello, sono necessari gli elementi seguenti:To deploy the model, you need the following items:

  • Uno script di immissione.An entry script. Questo script accetta le richieste, assegna un punteggio alle richieste usando il modello e restituisce i risultati.This script accepts requests, scores the requests by using the model, and returns the results.

    Importante

    • Lo script di immissione è specifico del modello.The entry script is specific to your model. Deve comprendere il formato dei dati della richiesta in ingresso, il formato dei dati previsti dal modello e il formato dei dati restituiti ai client.It must understand the format of the incoming request data, the format of the data expected by your model, and the format of the data returned to clients.

      Se i dati della richiesta sono in un formato non utilizzabile dal modello, lo script può trasformarlo in un formato accettabile.If the request data is in a format that's not usable by your model, the script can transform it into an acceptable format. Può anche trasformare la risposta prima di restituirla al client.It can also transform the response before returning it to the client.

    • Il Azure Machine Learning SDK non fornisce un modo per i servizi Web o le distribuzioni IoT Edge per accedere all'archivio dati o ai set di dati.The Azure Machine Learning SDK doesn't provide a way for web services or IoT Edge deployments to access your data store or datasets. Se il modello distribuito deve accedere ai dati archiviati all'esterno della distribuzione, ad esempio i dati in un account di archiviazione di Azure, è necessario sviluppare una soluzione di codice personalizzata usando l'SDK pertinente.If your deployed model needs to access data stored outside the deployment, like data in an Azure storage account, you must develop a custom code solution by using the relevant SDK. Ad esempio, Azure Storage SDK per Python.For example, the Azure Storage SDK for Python.

      Un'alternativa che può funzionare per lo scenario è la stima in batch, che fornisce l'accesso agli archivi dati durante il punteggio.An alternative that might work for your scenario is batch prediction, which does provide access to data stores during scoring.

  • Dipendenze, ad esempio gli script helper o i pacchetti Python/conda necessari per eseguire lo script di immissione o il modello.Dependencies, like helper scripts or Python/Conda packages required to run the entry script or model.

  • Configurazione della distribuzione per la destinazione di calcolo che ospita il modello distribuito.The deployment configuration for the compute target that hosts the deployed model. Questa configurazione descrive elementi quali i requisiti di memoria e CPU necessari per eseguire il modello.This configuration describes things like memory and CPU requirements needed to run the model.

Questi elementi vengono incapsulati in una configurazione di inferenza e una configurazione di distribuzione.These items are encapsulated into an inference configuration and a deployment configuration. La configurazione dell'inferenza fa riferimento allo script di immissione e ad altre dipendenze.The inference configuration references the entry script and other dependencies. Queste configurazioni vengono definite a livello di codice quando si usa l'SDK per eseguire la distribuzione.You define these configurations programmatically when you use the SDK to perform the deployment. Vengono definiti nei file JSON quando si usa l'interfaccia della riga di comando.You define them in JSON files when you use the CLI.

1. Definire lo script di immissione e le dipendenze1. Define your entry script and dependencies

Lo script di immissione riceve i dati inviati a un servizio Web distribuito e li passa al modello.The entry script receives data submitted to a deployed web service and passes it to the model. Riceve quindi la risposta restituita dal modello e la restituisce al client.It then takes the response returned by the model and returns that to the client. Lo script è specifico del modello.The script is specific to your model. Deve comprendere i dati previsti e restituiti dal modello.It must understand the data that the model expects and returns.

Lo script contiene due funzioni che caricano ed eseguono il modello:The script contains two functions that load and run the model:

  • init(): In genere, questa funzione carica il modello in un oggetto globale.init(): Typically, this function loads the model into a global object. Questa funzione viene eseguita una sola volta, quando viene avviato il contenitore Docker per il servizio Web.This function is run only once, when the Docker container for your web service is started.

  • run(input_data): questa funzione usa il modello per stimare un valore in base ai dati di input.run(input_data): This function uses the model to predict a value based on the input data. Gli input e gli output dell'esecuzione usano in genere JSON per la serializzazione e la deserializzazione.Inputs and outputs of the run typically use JSON for serialization and deserialization. È anche possibile usare dati binari non elaborati.You can also work with raw binary data. È possibile trasformare i dati prima di inviarli al modello o prima di restituirli al client.You can transform the data before sending it to the model or before returning it to the client.

Che cos'è get_model_path?What is get_model_path?

Quando si registra un modello, è necessario specificare un nome di modello utilizzato per la gestione del modello nel registro di sistema.When you register a model, you provide a model name that's used for managing the model in the registry. Usare questo nome con il metodo Model. Get _model_path () per recuperare il percorso del file o dei file del modello nel file system locale.You use this name with the Model.get_model_path() method to retrieve the path of the model file or files on the local file system. Se si registra una cartella o una raccolta di file, questa API restituisce il percorso della directory che contiene tali file.If you register a folder or a collection of files, this API returns the path of the directory that contains those files.

Quando si registra un modello, è necessario assegnargli un nome.When you register a model, you give it a name. Il nome corrisponde alla posizione in cui viene inserito il modello, localmente o durante la distribuzione del servizio.The name corresponds to where the model is placed, either locally or during service deployment.

Importante

Se è stato usato Machine Learning automatico per eseguire il training di model_id un modello, viene usato un valore come nome del modello.If you used automated machine learning to train a model, a model_id value is used as the model name. Per un esempio di registrazione e distribuzione di un modello con training automatico, vedere Azure/MachineLearningNotebooks su GitHub.For an example of registering and deploying a model trained with automated machine learning, see Azure/MachineLearningNotebooks on GitHub.

Nell'esempio seguente viene restituito un percorso a un singolo file denominato sklearn_mnist_model.pkl , che è stato registrato con il sklearn_mnistnome:The following example will return a path to a single file called sklearn_mnist_model.pkl (which was registered with the name sklearn_mnist):

model_path = Model.get_model_path('sklearn_mnist')

Opzionale Generazione automatica dello schema(Optional) Automatic schema generation

Per generare automaticamente uno schema per il servizio Web, fornire un esempio di input e/o output nel costruttore per uno degli oggetti tipo definiti.To automatically generate a schema for your web service, provide a sample of the input and/or output in the constructor for one of the defined type objects. Il tipo e l'esempio vengono utilizzati per creare automaticamente lo schema.The type and sample are used to automatically create the schema. Azure Machine Learning quindi crea una specifica openapi (spavalderia) per il servizio Web durante la distribuzione.Azure Machine Learning then creates an OpenAPI (Swagger) specification for the web service during deployment.

Questi tipi sono attualmente supportati:These types are currently supported:

  • pandas
  • numpy
  • pyspark
  • oggetto Python standardStandard Python object

Per usare la generazione dello schema, inference-schema includere il pacchetto nel file dell'ambiente conda.To use schema generation, include the inference-schema package in your Conda environment file.

File delle dipendenze di esempioExample dependencies file

Il seguente YAML è un esempio di file di dipendenze conda per l'inferenza:The following YAML is an example of a Conda dependencies file for inference:

name: project_environment
dependencies:
  - python=3.6.2
  - pip:
    - azureml-defaults
    - scikit-learn==0.20.0
    - inference-schema[numpy-support]

Se si desidera utilizzare la generazione automatica dello schema, è necessario che lo script inference-schema di immissione importi i pacchetti.If you want to use automatic schema generation, your entry script must import the inference-schema packages.

Definire i formati di esempio di input e output input_sample nelle output_sample variabili e, che rappresentano i formati di richiesta e risposta per il servizio Web.Define the input and output sample formats in the input_sample and output_sample variables, which represent the request and response formats for the web service. Usare questi esempi negli elementi Decorator run() della funzione di input e output della funzione.Use these samples in the input and output function decorators on the run() function. Nell'esempio Scikit-learn seguente viene utilizzata la generazione dello schema.The following scikit-learn example uses schema generation.

Script di immissione di esempioExample entry script

L'esempio seguente illustra come accettare e restituire i dati JSON:The following example demonstrates how to accept and return JSON data:

#Example: scikit-learn and Swagger
import json
import numpy as np
from sklearn.externals import joblib
from sklearn.linear_model import Ridge
from azureml.core.model import Model

from inference_schema.schema_decorators import input_schema, output_schema
from inference_schema.parameter_types.numpy_parameter_type import NumpyParameterType


def init():
    global model
    # Note that here "sklearn_regression_model.pkl" is the name of the model registered under.
    # This is a different behavior than before when the code is run locally, even though the code is the same.
    model_path = Model.get_model_path('sklearn_regression_model.pkl')
    # Deserialize the model file back into a sklearn model.
    model = joblib.load(model_path)


input_sample = np.array([[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]])
output_sample = np.array([3726.995])


@input_schema('data', NumpyParameterType(input_sample))
@output_schema(NumpyParameterType(output_sample))
def run(data):
    try:
        result = model.predict(data)
        # You can return any data type, as long as it is JSON serializable.
        return result.tolist()
    except Exception as e:
        error = str(e)
        return error

Nell'esempio seguente viene illustrato come definire i dati di input come <key: value> dizionario usando un frame di dati.The following example demonstrates how to define the input data as a <key: value> dictionary by using a DataFrame. Questo metodo è supportato per l'utilizzo del servizio Web distribuito da Power BI.This method is supported for consuming the deployed web service from Power BI. Per ulteriori informazioni su come utilizzare il servizio Web da Power bi, vedere.(Learn more about how to consume the web service from Power BI.)

import json
import pickle
import numpy as np
import pandas as pd
import azureml.train.automl
from sklearn.externals import joblib
from azureml.core.model import Model

from inference_schema.schema_decorators import input_schema, output_schema
from inference_schema.parameter_types.numpy_parameter_type import NumpyParameterType
from inference_schema.parameter_types.pandas_parameter_type import PandasParameterType


def init():
    global model
    # Replace model_name with your actual model name, if necessary.
    model_path = Model.get_model_path('model_name')
    # Deserialize the model file back into a sklearn model.
    model = joblib.load(model_path)


input_sample = pd.DataFrame(data=[{
    # This is a decimal type sample. Use the data type that reflects this column in your data.
    "input_name_1": 5.1,
    # This is a string type sample. Use the data type that reflects this column in your data.
    "input_name_2": "value2",
    # This is an integer type sample. Use the data type that reflects this column in your data.
    "input_name_3": 3
}])

# This is an integer type sample. Use the data type that reflects the expected result.
output_sample = np.array([0])


@input_schema('data', PandasParameterType(input_sample))
@output_schema(NumpyParameterType(output_sample))
def run(data):
    try:
        result = model.predict(data)
        # You can return any data type, as long as it is JSON serializable.
        return result.tolist()
    except Exception as e:
        error = str(e)
        return error

Per altri esempi, vedere gli script seguenti:For more examples, see the following scripts:

Dati binariBinary data

Se il modello accetta dati binari, ad esempio un'immagine, è necessario modificare score.py il file usato per la distribuzione per accettare richieste HTTP non elaborate.If your model accepts binary data, like an image, you must modify the score.py file used for your deployment to accept raw HTTP requests. Per accettare dati non elaborati, AMLRequest usare la classe nello script di immissione e @rawhttp aggiungere l'elemento Decorator alla run() funzione.To accept raw data, use the AMLRequest class in your entry script and add the @rawhttp decorator to the run() function.

Di seguito è riportato un esempio score.py di un oggetto che accetta dati binari:Here's an example of a score.py that accepts binary data:

from azureml.contrib.services.aml_request import AMLRequest, rawhttp
from azureml.contrib.services.aml_response import AMLResponse


def init():
    print("This is init()")


@rawhttp
def run(request):
    print("This is run()")
    print("Request: [{0}]".format(request))
    if request.method == 'GET':
        # For this example, just return the URL for GETs.
        respBody = str.encode(request.full_path)
        return AMLResponse(respBody, 200)
    elif request.method == 'POST':
        reqBody = request.get_data(False)
        # For a real-world solution, you would load the data from reqBody
        # and send it to the model. Then return the response.

        # For demonstration purposes, this example just returns the posted data as the response.
        return AMLResponse(reqBody, 200)
    else:
        return AMLResponse("bad request", 500)

Importante

La AMLRequest classe si trova azureml.contrib nello spazio dei nomi.The AMLRequest class is in the azureml.contrib namespace. Le entità in questo spazio dei nomi cambiano spesso quando si lavora per migliorare il servizio.Entities in this namespace change frequently as we work to improve the service. Qualsiasi elemento in questo spazio dei nomi deve essere considerato un'anteprima che non è completamente supportata da Microsoft.Anything in this namespace should be considered a preview that's not fully supported by Microsoft.

Se è necessario testarlo nell'ambiente di sviluppo locale, è possibile installare i componenti usando il comando seguente:If you need to test this in your local development environment, you can install the components by using the following command:

pip install azureml-contrib-services

Condivisione di risorse tra le origini (CORS)Cross-origin resource sharing (CORS)

La condivisione delle risorse tra le origini è un modo per consentire la richiesta di risorse in una pagina Web da un altro dominio.Cross-origin resource sharing is a way to allow resources on a web page to be requested from another domain. CORS funziona tramite le intestazioni HTTP inviate con la richiesta del client e restituite con la risposta del servizio.CORS works via HTTP headers sent with the client request and returned with the service response. Per altre informazioni su CORS e sulle intestazioni valide, vedere condivisione di risorse tra le origini in Wikipedia.For more information on CORS and valid headers, see Cross-origin resource sharing in Wikipedia.

Per configurare la distribuzione del modello per il supporto di CORS AMLResponse , usare la classe nello script di immissione.To configure your model deployment to support CORS, use the AMLResponse class in your entry script. Questa classe consente di impostare le intestazioni nell'oggetto risposta.This class allows you to set the headers on the response object.

Nell'esempio seguente viene impostata Access-Control-Allow-Origin l'intestazione per la risposta dallo script di immissione:The following example sets the Access-Control-Allow-Origin header for the response from the entry script:

from azureml.contrib.services.aml_response import AMLResponse

def init():
    print("This is init()")

def run(request):
    print("This is run()")
    print("Request: [{0}]".format(request))
    if request.method == 'GET':
        # For this example, just return the URL for GETs.
        respBody = str.encode(request.full_path)
        return AMLResponse(respBody, 200)
    elif request.method == 'POST':
        reqBody = request.get_data(False)
        # For a real-world solution, you would load the data from reqBody
        # and send it to the model. Then return the response.

        # For demonstration purposes, this example
        # adds a header and returns the request body.
        resp = AMLResponse(reqBody, 200)
        resp.headers['Access-Control-Allow-Origin'] = "http://www.example.com"
        return resp
    else:
        return AMLResponse("bad request", 500)

Importante

La AMLResponse classe si trova azureml.contrib nello spazio dei nomi.The AMLResponse class is in the azureml.contrib namespace. Le entità in questo spazio dei nomi cambiano spesso quando si lavora per migliorare il servizio.Entities in this namespace change frequently as we work to improve the service. Qualsiasi elemento in questo spazio dei nomi deve essere considerato un'anteprima che non è completamente supportata da Microsoft.Anything in this namespace should be considered a preview that's not fully supported by Microsoft.

Se è necessario testarlo nell'ambiente di sviluppo locale, è possibile installare i componenti usando il comando seguente:If you need to test this in your local development environment, you can install the components by using the following command:

pip install azureml-contrib-services

2. Definire il InferenceConfig2. Define your InferenceConfig

Nella configurazione dell'inferenza viene descritto come configurare il modello per eseguire stime.The inference configuration describes how to configure the model to make predictions. Questa configurazione non fa parte dello script di immissione.This configuration isn't part of your entry script. Fa riferimento allo script di immissione e viene usato per individuare tutte le risorse richieste dalla distribuzione.It references your entry script and is used to locate all the resources required by the deployment. Viene usato in un secondo momento, quando si distribuisce il modello.It's used later, when you deploy the model.

La configurazione dell'inferenza può usare ambienti Azure Machine Learning per definire le dipendenze software necessarie per la distribuzione.Inference configuration can use Azure Machine Learning environments to define the software dependencies needed for your deployment. Gli ambienti consentono di creare, gestire e riutilizzare le dipendenze software necessarie per il training e la distribuzione.Environments allow you to create, manage, and reuse the software dependencies required for training and deployment. Nell'esempio seguente viene illustrato il caricamento di un ambiente dall'area di lavoro e la relativa utilizzo con la configurazione dell'inferenza:The following example demonstrates loading an environment from your workspace and then using it with the inference configuration:

from azureml.core import Environment
from azureml.core.model import InferenceConfig

deploy_env = Environment.get(workspace=ws,name="myenv",version="1")
inference_config = InferenceConfig(entry_script="x/y/score.py",
                                   environment=deploy_env)

Per altre informazioni sugli ambienti, vedere creare e gestire ambienti per il training e la distribuzione.For more information on environments, see Create and manage environments for training and deployment.

È anche possibile specificare direttamente le dipendenze senza usare un ambiente.You can also directly specify the dependencies without using an environment. Nell'esempio seguente viene illustrato come creare una configurazione di inferenza che carica le dipendenze software da un file conda:The following example demonstrates how to create an inference configuration that loads software dependencies from a Conda file:

from azureml.core.model import InferenceConfig

inference_config = InferenceConfig(runtime="python",
                                   entry_script="x/y/score.py",
                                   conda_file="env/myenv.yml")

Per ulteriori informazioni, vedere la documentazione relativa alla classe InferenceConfig .For more information, see the InferenceConfig class documentation.

Per informazioni sull'uso di un'immagine Docker personalizzata con una configurazione di inferenza, vedere come distribuire un modello usando un'immagine Docker personalizzata.For information on using a custom Docker image with an inference configuration, see How to deploy a model using a custom Docker image.

Esempio di interfaccia della riga di comando di InferenceConfigCLI example of InferenceConfig

Le voci nel inferenceconfig.json documento vengono mappate ai parametri per la classe InferenceConfig .The entries in the inferenceconfig.json document map to the parameters for the InferenceConfig class. La tabella seguente descrive il mapping tra le entità nel documento JSON e i parametri per il metodo:The following table describes the mapping between entities in the JSON document and the parameters for the method:

Entità JSONJSON entity Parametro del metodoMethod parameter DescrizioneDescription
entryScript entry_script Percorso di un file locale che contiene il codice da eseguire per l'immagine.Path to a local file that contains the code to run for the image.
runtime runtime Runtime da usare per l'immagine.Which runtime to use for the image. I runtime supportati correnti sono spark-py e python.Current supported runtimes are spark-py and python.
condaFile conda_file facoltativo.Optional. Percorso di un file locale che contiene una definizione di ambiente conda da usare per l'immagine.Path to a local file that contains a Conda environment definition to use for the image.
extraDockerFileSteps extra_docker_file_steps facoltativo.Optional. Percorso di un file locale che contiene passaggi aggiuntivi di Docker da eseguire durante la configurazione dell'immagine.Path to a local file that contains additional Docker steps to run when setting up the image.
sourceDirectory source_directory facoltativo.Optional. Percorso delle cartelle che contengono tutti i file per la creazione dell'immagine.Path to folders that contain all files to create the image.
enableGpu enable_gpu facoltativo.Optional. Indica se abilitare il supporto GPU nell'immagine.Whether to enable GPU support in the image. È necessario usare l'immagine GPU in un servizio di Azure, ad esempio istanze di contenitore di Azure, Azure Machine Learning calcolo, macchine virtuali di Azure e il servizio Azure Kubernetes.The GPU image must be used on an Azure service, like Azure Container Instances, Azure Machine Learning Compute, Azure Virtual Machines, and Azure Kubernetes Service. Il valore predefinito è false.The default is False.
baseImage base_image facoltativo.Optional. Immagine personalizzata da usare come immagine di base.Custom image to be used as a base image. Se non viene specificata alcuna immagine di base, l'immagine sarà basata sul parametro di runtime specificato.If no base image is provided, the image will be based on the provided runtime parameter.
baseImageRegistry base_image_registry facoltativo.Optional. Registro immagini che contiene l'immagine di base.Image registry that contains the base image.
cudaVersion cuda_version facoltativo.Optional. Versione di CUDA da installare per le immagini che necessitano del supporto GPU.Version of CUDA to install for images that need GPU support. È necessario usare l'immagine GPU in un servizio di Azure, ad esempio istanze di contenitore di Azure, Azure Machine Learning calcolo, macchine virtuali di Azure e il servizio Azure Kubernetes.The GPU image must be used on an Azure service, like Azure Container Instances, Azure Machine Learning Compute, Azure Virtual Machines, and Azure Kubernetes Service. Le versioni supportate sono 9,0, 9,1 e 10,0.Supported versions are 9.0, 9.1, and 10.0. Se enable_gpu è impostato, il valore predefinito è 9,1.If enable_gpu is set, the default is 9.1.
description description Descrizione dell'immagine.A description for the image.

Il codice JSON seguente è una configurazione di esempio di inferenza da usare con l'interfaccia della riga di comando:The following JSON is an example inference configuration for use with the CLI:

{
    "entryScript": "score.py",
    "runtime": "python",
    "condaFile": "myenv.yml",
    "extraDockerfileSteps": null,
    "sourceDirectory": null,
    "enableGpu": false,
    "baseImage": null,
    "baseImageRegistry": null
}

Il comando seguente illustra come distribuire un modello usando l'interfaccia della riga di comando:The following command demonstrates how to deploy a model by using the CLI:

az ml model deploy -n myservice -m mymodel:1 --ic inferenceconfig.json

In questo esempio, la configurazione specifica le impostazioni seguenti:In this example, the configuration specifies the following settings:

  • Che il modello richieda Python.That the model requires Python.
  • Script di immissioneutilizzato per gestire le richieste Web inviate al servizio distribuito.The entry script, which is used to handle web requests sent to the deployed service.
  • Il file conda che descrive i pacchetti Python necessari per l'inferenza.The Conda file that describes the Python packages needed for inference.

Per informazioni sull'uso di un'immagine Docker personalizzata con una configurazione di inferenza, vedere come distribuire un modello usando un'immagine Docker personalizzata.For information on using a custom Docker image with an inference configuration, see How to deploy a model using a custom Docker image.

3. Definire la configurazione di distribuzione3. Define your deployment configuration

Prima di distribuire il modello, è necessario definire la configurazione della distribuzione.Before deploying your model, you must define the deployment configuration. La configurazione della distribuzione è specifica per la destinazione di calcolo in cui verrà ospitato il servizio Web.The deployment configuration is specific to the compute target that will host the web service. Ad esempio, quando si distribuisce un modello localmente, è necessario specificare la porta in cui il servizio accetta le richieste.For example, when you deploy a model locally, you must specify the port where the service accepts requests. La configurazione della distribuzione non fa parte dello script di immissione.The deployment configuration isn't part of your entry script. Viene usato per definire le caratteristiche della destinazione di calcolo che ospiterà lo script del modello e della voce.It's used to define the characteristics of the compute target that will host the model and entry script.

Potrebbe anche essere necessario creare la risorsa di calcolo, se, ad esempio, non si dispone già di un'istanza di Azure Kubernetes Service (AKS) associata all'area di lavoro.You might also need to create the compute resource, if, for example, you don't already have an Azure Kubernetes Service (AKS) instance associated with your workspace.

La tabella seguente fornisce un esempio di creazione di una configurazione di distribuzione per ogni destinazione di calcolo:The following table provides an example of creating a deployment configuration for each compute target:

Destinazione del calcoloCompute target Esempio di configurazione della distribuzioneDeployment configuration example
LocaleLocal deployment_config = LocalWebservice.deploy_configuration(port=8890)
Istanze di Azure ContainerAzure Container Instances deployment_config = AciWebservice.deploy_configuration(cpu_cores = 1, memory_gb = 1)
Servizio Azure KubernetesAzure Kubernetes Service deployment_config = AksWebservice.deploy_configuration(cpu_cores = 1, memory_gb = 1)

Le classi per local, istanze di contenitore di Azure e servizi Web AKS possono essere importate da azureml.core.webservice:The classes for local, Azure Container Instances, and AKS web services can be imported from azureml.core.webservice:

from azureml.core.webservice import AciWebservice, AksWebservice, LocalWebservice

ProfilaturaProfiling

Prima di distribuire il modello come servizio, è consigliabile profilarlo per determinare i requisiti di CPU e memoria ottimali.Before you deploy your model as a service, you might want to profile it to determine optimal CPU and memory requirements. Per profilare il modello, è possibile usare l'SDK o l'interfaccia della riga di comando.You can use either the SDK or the CLI to profile your model. Negli esempi seguenti viene illustrato come profilare un modello utilizzando SDK.The following examples show how to profile a model by using the SDK.

Importante

Quando si usa la profilatura, la configurazione di inferenza fornita non può fare riferimento a un ambiente Azure Machine Learning.When you use profiling, the inference configuration that you provide can't reference an Azure Machine Learning environment. Definire invece le dipendenze del software utilizzando il conda_file parametro InferenceConfig dell'oggetto.Instead, define the software dependencies by using the conda_file parameter of the InferenceConfig object.

import json
test_sample = json.dumps({'data': [
    [1,2,3,4,5,6,7,8,9,10]
]})

profile = Model.profile(ws, "profilemymodel", [model], inference_config, test_data)
profile.wait_for_profiling(true)
profiling_results = profile.get_results()
print(profiling_results)

Questo codice visualizza un risultato simile all'output seguente:This code displays a result similar to the following output:

{'cpu': 1.0, 'memoryInGB': 0.5}

I risultati della profilatura del modello vengono Run emessi come un oggetto.Model profiling results are emitted as a Run object.

Per informazioni sull'uso della profilatura dall'interfaccia della riga di comando, vedere AZ ml Model Profile.For information on using profiling from the CLI, see az ml model profile.

Per ulteriori informazioni, vedere i documenti seguenti:For more information, see these documents:

Distribuisci nella destinazioneDeploy to target

La distribuzione usa la configurazione di distribuzione per la configurazione dell'inferenza per distribuire i modelli.Deployment uses the inference configuration deployment configuration to deploy the models. Il processo di distribuzione è simile indipendentemente dalla destinazione di calcolo.The deployment process is similar regardless of the compute target. La distribuzione in AKS è leggermente diversa perché è necessario fornire un riferimento al cluster AKS.Deploying to AKS is slightly different because you must provide a reference to the AKS cluster.

Distribuzione localeLocal deployment

Per distribuire un modello localmente, è necessario che Docker sia installato nel computer locale.To deploy a model locally, you need to have Docker installed on your local machine.

Uso dell'SDKUsing the SDK

from azureml.core.webservice import LocalWebservice, Webservice

deployment_config = LocalWebservice.deploy_configuration(port=8890)
service = Model.deploy(ws, "myservice", [model], inference_config, deployment_config)
service.wait_for_deployment(show_output = True)
print(service.state)

Per ulteriori informazioni, vedere la documentazione relativa a LocalWebservice, Model. Deploy ()e WebService.For more information, see the documentation for LocalWebservice, Model.deploy(), and Webservice.

Uso dell'interfaccia della riga di comandoUsing the CLI

Per distribuire un modello usando l'interfaccia della riga di comando, usare il comando seguente.To deploy a model by using the CLI, use the following command. Sostituire mymodel:1 con il nome e la versione del modello registrato:Replace mymodel:1 with the name and version of the registered model:

az ml model deploy -m mymodel:1 --ic inferenceconfig.json --dc deploymentconfig.json

Le voci nel deploymentconfig.json documento vengono mappate ai parametri per LocalWebservice. deploy_configuration.The entries in the deploymentconfig.json document map to the parameters for LocalWebservice.deploy_configuration. La tabella seguente descrive il mapping tra le entità nel documento JSON e i parametri per il metodo:The following table describes the mapping between the entities in the JSON document and the parameters for the method:

Entità JSONJSON entity Parametro del metodoMethod parameter DescrizioneDescription
computeType NDNA La destinazione di calcolo.The compute target. Per le destinazioni locali, il valore deve localessere.For local targets, the value must be local.
port port Porta locale su cui esporre l'endpoint HTTP del servizio.The local port on which to expose the service's HTTP endpoint.

Questo JSON è una configurazione di distribuzione di esempio da usare con l'interfaccia della riga di comando:This JSON is an example deployment configuration for use with the CLI:

{
    "computeType": "local",
    "port": 32267
}

Per ulteriori informazioni, vedere la documentazione AZ ml Model deploy .For more information, see the az ml model deploy documentation.

Servizio Web notebook VM (sviluppo/test)Notebook VM web service (dev/test)

Vedere distribuire un modello nelle VM notebook.See Deploy a model to Notebook VMs.

Istanze di contenitore di Azure (sviluppo/test)Azure Container Instances (dev/test)

Vedere eseguire la distribuzione in istanze di contenitore di Azure.See Deploy to Azure Container Instances.

Servizio Azure Kubernetes (sviluppo/test e produzione)Azure Kubernetes Service (dev/test and production)

Vedere eseguire la distribuzione nel servizio Azure Kubernetes.See Deploy to Azure Kubernetes Service.

Utilizzare i servizi WebConsume web services

Ogni servizio Web distribuito fornisce un'API REST, quindi è possibile creare applicazioni client in un'ampia gamma di linguaggi di programmazione.Every deployed web service provides a REST API, so you can create client applications in a variety of programming languages. Se è stata abilitata l'autenticazione della chiave per il servizio, è necessario specificare una chiave di servizio come token nell'intestazione della richiesta.If you've enabled key authentication for your service, you need to provide a service key as a token in your request header. Se è stata abilitata l'autenticazione basata su token per il servizio, è necessario fornire un token di Azure Machine Learning JWT come bearer token nell'intestazione della richiesta.If you've enabled token authentication for your service, you need to provide an Azure Machine Learning JWT token as a bearer token in your request header.

Suggerimento

È possibile recuperare il documento JSON dello schema dopo la distribuzione del servizio.You can retrieve the schema JSON document after you deploy the service. Utilizzare la Proprietà swagger_uri del servizio Web distribuito (ad esempio, service.swagger_uri) per ottenere l'URI del file di spavalderia del servizio Web locale.Use the swagger_uri property from the deployed web service (for example, service.swagger_uri) to get the URI to the local web service's Swagger file.

Consumo richiesta-rispostaRequest-response consumption

Di seguito è riportato un esempio di come richiamare il servizio in Python:Here's an example of how to invoke your service in Python:

import requests
import json

headers = {'Content-Type': 'application/json'}

if service.auth_enabled:
    headers['Authorization'] = 'Bearer '+service.get_keys()[0]
elif service.token_auth_enabled:
    headers['Authorization'] = 'Bearer '+service.get_token()[0]

print(headers)

test_sample = json.dumps({'data': [
    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
    [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
]})

response = requests.post(
    service.scoring_uri, data=test_sample, headers=headers)
print(response.status_code)
print(response.elapsed)
print(response.json())

Per altre informazioni, vedere creare applicazioni client per l'utilizzo di servizi Web.For more information, see Create client applications to consume web services.

Schema del servizio Web (specifica OpenAPI)Web service schema (OpenAPI specification)

Se è stata usata la generazione automatica dello schema con la distribuzione, è possibile ottenere l'indirizzo della specifica OpenAPI per il servizio usando la Proprietà swagger_uri.If you used automatic schema generation with your deployment, you can get the address of the OpenAPI specification for the service by using the swagger_uri property. ad esempio print(service.swagger_uri). Usare una richiesta GET o aprire l'URI in un browser per recuperare la specifica.(For example, print(service.swagger_uri).) Use a GET request or open the URI in a browser to retrieve the specification.

Il documento JSON seguente è un esempio di schema (OpenAPI Specification) generato per una distribuzione:The following JSON document is an example of a schema (OpenAPI specification) generated for a deployment:

{
    "swagger": "2.0",
    "info": {
        "title": "myservice",
        "description": "API specification for Azure Machine Learning myservice",
        "version": "1.0"
    },
    "schemes": [
        "https"
    ],
    "consumes": [
        "application/json"
    ],
    "produces": [
        "application/json"
    ],
    "securityDefinitions": {
        "Bearer": {
            "type": "apiKey",
            "name": "Authorization",
            "in": "header",
            "description": "For example: Bearer abc123"
        }
    },
    "paths": {
        "/": {
            "get": {
                "operationId": "ServiceHealthCheck",
                "description": "Simple health check endpoint to ensure the service is up at any given point.",
                "responses": {
                    "200": {
                        "description": "If service is up and running, this response will be returned with the content 'Healthy'",
                        "schema": {
                            "type": "string"
                        },
                        "examples": {
                            "application/json": "Healthy"
                        }
                    },
                    "default": {
                        "description": "The service failed to execute due to an error.",
                        "schema": {
                            "$ref": "#/definitions/ErrorResponse"
                        }
                    }
                }
            }
        },
        "/score": {
            "post": {
                "operationId": "RunMLService",
                "description": "Run web service's model and get the prediction output",
                "security": [
                    {
                        "Bearer": []
                    }
                ],
                "parameters": [
                    {
                        "name": "serviceInputPayload",
                        "in": "body",
                        "description": "The input payload for executing the real-time machine learning service.",
                        "schema": {
                            "$ref": "#/definitions/ServiceInput"
                        }
                    }
                ],
                "responses": {
                    "200": {
                        "description": "The service processed the input correctly and provided a result prediction, if applicable.",
                        "schema": {
                            "$ref": "#/definitions/ServiceOutput"
                        }
                    },
                    "default": {
                        "description": "The service failed to execute due to an error.",
                        "schema": {
                            "$ref": "#/definitions/ErrorResponse"
                        }
                    }
                }
            }
        }
    },
    "definitions": {
        "ServiceInput": {
            "type": "object",
            "properties": {
                "data": {
                    "type": "array",
                    "items": {
                        "type": "array",
                        "items": {
                            "type": "integer",
                            "format": "int64"
                        }
                    }
                }
            },
            "example": {
                "data": [
                    [ 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 ]
                ]
            }
        },
        "ServiceOutput": {
            "type": "array",
            "items": {
                "type": "number",
                "format": "double"
            },
            "example": [
                3726.995
            ]
        },
        "ErrorResponse": {
            "type": "object",
            "properties": {
                "status_code": {
                    "type": "integer",
                    "format": "int32"
                },
                "message": {
                    "type": "string"
                }
            }
        }
    }
}

Per ulteriori informazioni, vedere la specifica openapi.For more information, see OpenAPI specification.

Per un'utilità che consente di creare librerie client dalla specifica, vedere spavalderia-codegen.For a utility that can create client libraries from the specification, see swagger-codegen.

Inferenza batchBatch inference

Azure Machine Learning le destinazioni di calcolo vengono create e gestite da Azure Machine Learning.Azure Machine Learning Compute targets are created and managed by Azure Machine Learning. Possono essere usati per la stima in batch da Azure Machine Learning pipeline.They can be used for batch prediction from Azure Machine Learning pipelines.

Per una procedura dettagliata di inferenza batch con Azure Machine Learning calcolo, vedere How to Run batch Predictions.For a walkthrough of batch inference with Azure Machine Learning Compute, see How to run batch predictions.

Inferenza IoT EdgeIoT Edge inference

Il supporto per la distribuzione in Edge è in anteprima.Support for deploying to the edge is in preview. Per altre informazioni, vedere Deploy Azure Machine Learning As an IOT Edge Module.For more information, see Deploy Azure Machine Learning as an IoT Edge module.

Aggiornare i servizi WebUpdate web services

Per aggiornare un servizio Web, utilizzare il update metodo.To update a web service, use the update method. È possibile aggiornare il servizio Web per usare un nuovo modello, un nuovo script di immissione o nuove dipendenze che possono essere specificate in una configurazione di inferenza.You can update the web service to use a new model, a new entry script, or new dependencies that can be specified in an inference configuration. Per ulteriori informazioni, vedere la documentazione relativa a WebService. Update.For more information, see the documentation for Webservice.update.

Importante

Quando si crea una nuova versione di un modello, è necessario aggiornare manualmente ogni servizio che si desidera utilizzare.When you create a new version of a model, you must manually update each service that you want to use it.

Uso dell'SDKUsing the SDK

Il codice seguente illustra come usare l'SDK per aggiornare il modello, l'ambiente e lo script di immissione per un servizio Web:The following code shows how to use the SDK to update the model, environment, and entry script for a web service:

from azureml.core import Environment
from azureml.core.webservice import Webservice
from azureml.core.model import Model, InferenceConfig

# Register new model.
new_model = Model.register(model_path="outputs/sklearn_mnist_model.pkl",
                           model_name="sklearn_mnist",
                           tags={"key": "0.1"},
                           description="test",
                           workspace=ws)

# Use version 3 of the environment.
deploy_env = Environment.get(workspace=ws,name="myenv",version="3")
inference_config = InferenceConfig(entry_script="score.py",
                                   environment=deploy_env)

service_name = 'myservice'
# Retrieve existing service.
service = Webservice(name=service_name, workspace=ws)



# Update to new model(s).
service.update(models=[new_model], inference_config=inference_config)
print(service.state)
print(service.get_logs())

Uso dell'interfaccia della riga di comandoUsing the CLI

È anche possibile aggiornare un servizio Web usando l'interfaccia della riga di comando di ML.You can also update a web service by using the ML CLI. Nell'esempio seguente viene illustrata la registrazione di un nuovo modello e l'aggiornamento di un servizio Web per l'utilizzo del nuovo modello:The following example demonstrates registering a new model and then updating a web service to use the new model:

az ml model register -n sklearn_mnist  --asset-path outputs/sklearn_mnist_model.pkl  --experiment-name myexperiment --output-metadata-file modelinfo.json
az ml service update -n myservice --model-metadata-file modelinfo.json

Suggerimento

In questo esempio viene usato un documento JSON per passare le informazioni sul modello dal comando di registrazione nel comando Update.In this example, a JSON document is used to pass the model information from the registration command into the update command.

Per aggiornare il servizio per l'utilizzo di un nuovo script di immissione o di un ambiente, creare un file di configurazione ic dell' inferenza e specificarlo con il parametro.To update the service to use a new entry script or environment, create an inference configuration file and specify it with the ic parameter.

Per ulteriori informazioni, vedere la documentazione relativa all' aggiornamento del servizio AZ ml .For more information, see the az ml service update documentation.

Distribuzione continua di modelliContinuously deploy models

È possibile distribuire i modelli in modo continuo usando l'estensione Machine Learning per Azure DevOps.You can continuously deploy models by using the Machine Learning extension for Azure DevOps. È possibile usare l'estensione Machine Learning per Azure DevOps per attivare una pipeline di distribuzione quando viene registrato un nuovo modello di apprendimento automatico in un'area di lavoro di Azure Machine Learning.You can use the Machine Learning extension for Azure DevOps to trigger a deployment pipeline when a new machine learning model is registered in an Azure Machine Learning workspace.

  1. Iscriversi a Azure Pipelines, che rende possibile l'integrazione e il recapito continui dell'applicazione in qualsiasi piattaforma o cloud.Sign up for Azure Pipelines, which makes continuous integration and delivery of your application to any platform or cloud possible. Si noti che Azure Pipelines non è uguale Machine Learning pipeline.(Note that Azure Pipelines isn't the same as Machine Learning pipelines.)

  2. Creare un progetto DevOps di Azure.Create an Azure DevOps project.

  3. Installare l' estensione Machine Learning per Azure Pipelines.Install the Machine Learning extension for Azure Pipelines.

  4. Usare le connessioni al servizio per configurare una connessione dell'entità servizio all'area di lavoro Azure Machine Learning in modo che sia possibile accedere agli elementi.Use service connections to set up a service principal connection to your Azure Machine Learning workspace so you can access your artifacts. Passare a Impostazioni progetto, selezionare connessioni al servizioe quindi selezionare Azure Resource Manager:Go to project settings, select Service connections, and then select Azure Resource Manager:

    Selezionare Azure Resource ManagerSelect Azure Resource Manager

  5. Nell'elenco livello ambito selezionare AzureMLWorkspacee quindi immettere il resto dei valori:In the Scope level list, select AzureMLWorkspace, and then enter the rest of the values:

    Seleziona AzureMLWorkspace

  6. Per distribuire continuamente il modello di apprendimento automatico usando Azure Pipelines, in pipeline selezionare versione.To continuously deploy your machine learning model by using Azure Pipelines, under pipelines, select release. Aggiungere un nuovo elemento, quindi selezionare l'elemento del modello AzureML e la connessione del servizio creata in precedenza.Add a new artifact, and then select the AzureML Model artifact and the service connection that you created earlier. Selezionare il modello e la versione per attivare una distribuzione:Select the model and version to trigger a deployment:

    Selezionare il modello AzureMLSelect AzureML Model

  7. Abilitare il trigger del modello nell'elemento del modello.Enable the model trigger on your model artifact. Quando si attiva il trigger, ogni volta che la versione specificata (ovvero la versione più recente) del modello viene registrata nell'area di lavoro, viene attivata una pipeline di rilascio di Azure DevOps.When you turn on the trigger, every time the specified version (that is, the newest version) of that model is registered in your workspace, an Azure DevOps release pipeline is triggered.

    Abilita il trigger del modelloEnable the model trigger

Per altri progetti ed esempi di esempio, vedere questi repository di esempio in GitHub:For more sample projects and examples, see these sample repos in GitHub:

Scaricare un modelloDownload a model

Se si vuole scaricare il modello per usarlo nel proprio ambiente di esecuzione, è possibile eseguire questa operazione con i comandi SDK/CLI seguenti:If you want to download your model to use it in your own execution environment, you can do so with the following SDK / CLI commands:

SDKSDK:

model_path = Model(ws,'mymodel').download()

Interfaccia della riga di comando:CLI:

az ml model download --model-id mymodel:1 --target-dir model_folder

Modelli di pacchettoPackage models

In alcuni casi, potrebbe essere necessario creare un'immagine Docker senza distribuire il modello (se, ad esempio, si prevede di eseguire la distribuzione nel servizio app Azure).In some cases, you might want to create a Docker image without deploying the model (if, for example, you plan to deploy to Azure App Service). In alternativa, potrebbe essere necessario scaricare l'immagine ed eseguirla in un'installazione locale di Docker.Or you might want to download the image and run it on a local Docker installation. Potrebbe anche essere necessario scaricare i file usati per compilare l'immagine, esaminarli, modificarli e compilare l'immagine manualmente.You might even want to download the files used to build the image, inspect them, modify them, and build the image manually.

La creazione di pacchetti di modelli consente di eseguire queste operazioni.Model packaging enables you to do these things. Inserisce tutti gli asset necessari per ospitare un modello come servizio Web e consente di scaricare un'immagine Docker completamente compilata o i file necessari per crearne uno.It packages all the assets needed to host a model as a web service and allows you to download either a fully built Docker image or the files needed to build one. Esistono due modi per usare la creazione di pacchetti di modelli:There are two ways to use model packaging:

Scaricare un modello di pacchetto: Scaricare un'immagine Docker contenente il modello e gli altri file necessari per ospitarla come servizio Web.Download a packaged model: Download a Docker image that contains the model and other files needed to host it as a web service.

Generare un Dockerfile: Scaricare Dockerfile, Model, entry script e altri asset necessari per creare un'immagine docker.Generate a Dockerfile: Download the Dockerfile, model, entry script, and other assets needed to build a Docker image. È quindi possibile ispezionare i file o apportare modifiche prima di compilare l'immagine localmente.You can then inspect the files or make changes before you build the image locally.

Entrambi i pacchetti possono essere usati per ottenere un'immagine Docker locale.Both packages can be used to get a local Docker image.

Suggerimento

La creazione di un pacchetto è simile alla distribuzione di un modello.Creating a package is similar to deploying a model. Si usano un modello registrato e una configurazione di inferenza.You use a registered model and an inference configuration.

Importante

Per scaricare un'immagine completamente compilata o creare un'immagine localmente, è necessario che Docker sia installato nell'ambiente di sviluppo.To download a fully built image or build an image locally, you need to have Docker installed in your development environment.

Scaricare un modello di pacchettoDownload a packaged model

Nell'esempio seguente viene compilata un'immagine, registrata nel registro contenitori di Azure per l'area di lavoro:The following example builds an image, which is registered in the Azure container registry for your workspace:

package = Model.package(ws, [model], inference_config)
package.wait_for_creation(show_output=True)

Dopo aver creato un pacchetto, è possibile usare package.pull() per eseguire il pull dell'immagine nell'ambiente Docker locale.After you create a package, you can use package.pull() to pull the image to your local Docker environment. L'output di questo comando visualizzerà il nome dell'immagine.The output of this command will display the name of the image. Ad esempio:For example:

[https://login.microsoftonline.com/consumers/](Status: Downloaded newer image for myworkspacef78fd10.azurecr.io/package:20190822181338).Status: Downloaded newer image for myworkspacef78fd10.azurecr.io/package:20190822181338.

Dopo aver scaricato il modello, utilizzare il docker images comando per elencare le immagini locali:After you download the model, use the docker images command to list the local images:

REPOSITORY                               TAG                 IMAGE ID            CREATED             SIZE
myworkspacef78fd10.azurecr.io/package    20190822181338      7ff48015d5bd        4 minutes ago       1.43GB

Per avviare un contenitore locale basato su questa immagine, usare il comando seguente per avviare un contenitore denominato dalla shell o dalla riga di comando.To start a local container based on this image, use the following command to start a named container from the shell or command line. Sostituire il <imageid> valore con l'ID immagine restituito docker images dal comando.Replace the <imageid> value with the image ID returned by the docker images command.

docker run -p 6789:5001 --name mycontainer <imageid>

Questo comando avvia la versione più recente dell'immagine denominata myimage.This command starts the latest version of the image named myimage. Esegue il mapping della porta locale 6789 alla porta nel contenitore in cui il servizio Web è in ascolto (5001).It maps local port 6789 to the port in the container on which the web service is listening (5001). Assegna anche il nome mycontainer al contenitore, rendendo più semplice l'arresto del contenitore.It also assigns the name mycontainer to the container, which makes the container easier to stop. Dopo l'avvio del contenitore è possibile inviare richieste a http://localhost:6789/score.After the container is started, you can submit requests to http://localhost:6789/score.

Genera Dockerfile e dipendenzeGenerate a Dockerfile and dependencies

Nell'esempio seguente viene illustrato come scaricare il Dockerfile, il modello e gli altri asset necessari per compilare un'immagine localmente.The following example shows how to download the Dockerfile, model, and other assets needed to build an image locally. Il generate_dockerfile=True parametro indica che si desidera che i file non siano un'immagine completamente compilata.The generate_dockerfile=True parameter indicates that you want the files, not a fully built image.

package = Model.package(ws, [model], inference_config, generate_dockerfile=True)
package.wait_for_creation(show_output=True)
# Download the package.
package.save("./imagefiles")
# Get the Azure container registry that the model/Dockerfile uses.
acr=package.get_container_registry()
print("Address:", acr.address)
print("Username:", acr.username)
print("Password:", acr.password)

Questo codice Scarica i file necessari per compilare l'immagine imagefiles nella directory.This code downloads the files needed to build the image to the imagefiles directory. Il Dockerfile incluso nei file salvati fa riferimento a un'immagine di base archiviata in un registro contenitori di Azure.The Dockerfile included in the saved files references a base image stored in an Azure container registry. Quando si compila l'immagine nell'installazione Docker locale, è necessario usare l'indirizzo, il nome utente e la password per l'autenticazione al registro di sistema.When you build the image on your local Docker installation, you need to use the address, user name, and password to authenticate to the registry. Usare la procedura seguente per compilare l'immagine usando un'installazione locale di Docker:Use the following steps to build the image by using a local Docker installation:

  1. Da una shell o da una sessione della riga di comando, usare il comando seguente per autenticare Docker con il registro contenitori di Azure.From a shell or command-line session, use the following command to authenticate Docker with the Azure container registry. Sostituire <address>, <username> package.get_container_registry()e conivalorirecuperatida<password> .Replace <address>, <username>, and <password> with the values retrieved by package.get_container_registry().

    docker login <address> -u <username> -p <password>
    
  2. Per compilare l'immagine, usare il comando seguente.To build the image, use the following command. Sostituire <imagefiles> con il percorso della directory in cui package.save() sono stati salvati i file.Replace <imagefiles> with the path of the directory where package.save() saved the files.

    docker build --tag myimage <imagefiles>
    

    Questo comando imposta il nome dell'immagine myimagesu.This command sets the image name to myimage.

Per verificare che l'immagine sia compilata, docker images usare il comando.To verify that the image is built, use the docker images command. L' myimage immagine dovrebbe essere visualizzata nell'elenco:You should see the myimage image in the list:

REPOSITORY      TAG                 IMAGE ID            CREATED             SIZE
<none>          <none>              2d5ee0bf3b3b        49 seconds ago      1.43GB
myimage         latest              739f22498d64        3 minutes ago       1.43GB

Per avviare un nuovo contenitore basato su questa immagine, usare il comando seguente:To start a new container based on this image, use the following command:

docker run -p 6789:5001 --name mycontainer myimage:latest

Questo comando avvia la versione più recente dell'immagine denominata myimage.This command starts the latest version of the image named myimage. Esegue il mapping della porta locale 6789 alla porta nel contenitore in cui il servizio Web è in ascolto (5001).It maps local port 6789 to the port in the container on which the web service is listening (5001). Assegna anche il nome mycontainer al contenitore, rendendo più semplice l'arresto del contenitore.It also assigns the name mycontainer to the container, which makes the container easier to stop. Dopo l'avvio del contenitore è possibile inviare richieste a http://localhost:6789/score.After the container is started, you can submit requests to http://localhost:6789/score.

Client di esempio per il test del contenitore localeExample client to test the local container

Il codice seguente è un esempio di un client Python che può essere usato con il contenitore:The following code is an example of a Python client that can be used with the container:

import requests
import json

# URL for the web service.
scoring_uri = 'http://localhost:6789/score'

# Two sets of data to score, so we get two results back.
data = {"data":
        [
            [ 1,2,3,4,5,6,7,8,9,10 ],
            [ 10,9,8,7,6,5,4,3,2,1 ]
        ]
        }
# Convert to JSON string.
input_data = json.dumps(data)

# Set the content type.
headers = {'Content-Type': 'application/json'}

# Make the request and display the response.
resp = requests.post(scoring_uri, input_data, headers=headers)
print(resp.text)

Per i client di esempio in altri linguaggi di programmazione, vedere utilizzo di modelli distribuiti come servizi Web.For example clients in other programming languages, see Consume models deployed as web services.

Arrestare il contenitore DockerStop the Docker container

Per arrestare il contenitore, usare il comando seguente da una shell o riga di comando diversa:To stop the container, use the following command from a different shell or command line:

docker kill mycontainer

Pulire le risorseClean up resources

Per eliminare un servizio Web distribuito, usare service.delete().To delete a deployed web service, use service.delete(). Per eliminare un modello registrato, usare model.delete().To delete a registered model, use model.delete().

Per ulteriori informazioni, vedere la documentazione relativa a WebService. Delete () e Model. Delete ().For more information, see the documentation for WebService.delete() and Model.delete().

Passaggi successiviNext steps