Condividi tramite

Che cos'è Azure Machine Learning SDK v1 per Python?

  • Articolo

Importante

Questo articolo riguarda Azure Machine Learning SDK v1, che non è l'SDK corrente. La versione corrente dell'SDK è Azure Machine Learning Python SDK v2. Per informazioni sulle differenze tra le versioni dell'SDK, vedere Eseguire l'aggiornamento alla versione 2.

Gli sviluppatori di data scientist e intelligenza artificiale usano Azure Machine Learning SDK v1 per Python per creare ed eseguire flussi di lavoro di Machine Learning con il servizio Azure Machine Learning . È possibile interagire con il servizio in qualsiasi ambiente Python, inclusi Jupyter Notebook, Visual Studio Codeo l'IDE Python preferito.

Le aree principali dell'SDK includono:

  • Esplorare, preparare e gestire il ciclo di vita dei set di dati usati negli esperimenti di Machine Learning.
  • Gestire le risorse cloud per il monitoraggio, la registrazione e l'organizzazione degli esperimenti di Machine Learning.
  • Eseguire il training dei modelli in locale o usando risorse cloud, incluso il training del modello con accelerazione GPU.
  • Usare Machine Learning automatizzato, che accetta parametri di configurazione e dati di training. Scorre automaticamente gli algoritmi e le impostazioni degli iperparametri per trovare il modello migliore per l'esecuzione di stime.
  • Distribuire servizi Web per convertire i modelli sottoposti a training in servizi RESTful che possono essere utilizzati in qualsiasi applicazione.

Per una procedura dettagliata su come iniziare, provare l'esercitazione .

Le sezioni seguenti sono panoramiche di alcune delle classi più importanti dell'SDK e dei modelli di progettazione comuni per usarle. Per ottenere l'SDK, vedere la guida all'installazione .

Stabile e sperimentale

Azure Machine Learning SDK per Python offre funzionalità stabili e sperimentali nello stesso SDK.

Stato funzionalità/funzionalità Descrizione
Funzionalità stabili Produzione pronta per l'

Queste funzionalità sono consigliate per la maggior parte dei casi d'uso e degli ambienti di produzione. Vengono aggiornate meno frequentemente e quindi le funzionalità sperimentali.
Funzionalità sperimentali di sviluppo

Queste funzionalità sono nuove funzionalità sviluppate & aggiornamenti che potrebbero non essere pronti o completamente testati per l'utilizzo di produzione. Anche se le funzionalità sono in genere funzionali, possono includere alcune modifiche di rilievo. Le funzionalità sperimentali vengono usate per risolvere i bug di interruzione dell'SDK e riceveranno solo gli aggiornamenti per la durata del periodo di test. Le funzionalità sperimentali sono dette anche funzionalità in anteprima.

Come indicato dal nome, le funzionalità sperimentali (anteprima) sono destinate all'esperimento ed è non considerato privo di bug o stabile. Per questo motivo, è consigliabile usare solo funzionalità sperimentali per utenti avanzati che desiderano provare le versioni iniziali di funzionalità e aggiornamenti e che intendono partecipare alla segnalazione di bug e glitch.

Le funzionalità sperimentali sono etichettate da una sezione nota nel riferimento SDK e contrassegnate da testo, ad esempio (anteprima) in documentazione di Azure Machine Learning.

Workspace

spazio dei nomi: azureml.core.workspace.Workspace

La classe Workspace è una risorsa di base nel cloud usata per sperimentare, eseguire il training e distribuire modelli di Machine Learning. Collega la sottoscrizione di Azure e il gruppo di risorse a un oggetto facilmente utilizzato.

Visualizzare tutti i parametri del metodo create Workspace per riutilizzare le istanze esistenti (Storage, Key Vault, App-Insights e Azure Container Registry-ACR) e modificare impostazioni aggiuntive, ad esempio la configurazione dell'endpoint privato e la destinazione di calcolo.

Importare la classe e creare una nuova area di lavoro usando il codice seguente. Impostare create_resource_group su False se si dispone di un gruppo di risorse di Azure esistente che si vuole usare per l'area di lavoro. Alcune funzioni potrebbero richiedere le credenziali di autenticazione di Azure.

from azureml.core import Workspace
ws = Workspace.create(name='myworkspace',
                      subscription_id='<azure-subscription-id>',
                      resource_group='myresourcegroup',
                      create_resource_group=True,
                      location='eastus2'
                     )

Usare la stessa area di lavoro in più ambienti scrivendola prima in un file JSON di configurazione. In questo modo vengono salvati i dati relativi alla sottoscrizione, alla risorsa e al nome dell'area di lavoro.

ws.write_config(path="./file-path", file_name="ws_config.json")

Caricare l'area di lavoro leggendo il file di configurazione.

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

In alternativa, usare il metodo get() statico per caricare un'area di lavoro esistente senza usare i file di configurazione.

from azureml.core import Workspace
ws = Workspace.get(name="myworkspace", subscription_id='<azure-subscription-id>', resource_group='myresourcegroup')

La variabile ws rappresenta un oggetto Workspace negli esempi di codice seguenti.

Rsperimento

spazio dei nomi: azureml.core.experiment.Experiment

La classe Experiment è un'altra risorsa cloud fondamentale che rappresenta una raccolta di versioni di valutazione (esecuzioni di singoli modelli). Il codice seguente recupera un oggetto Experiment dall'interno di Workspace in base al nome oppure crea un nuovo oggetto Experiment se il nome non esiste.

from azureml.core.experiment import Experiment
experiment = Experiment(workspace=ws, name='test-experiment')

Eseguire il codice seguente per ottenere un elenco di tutti gli oggetti Experiment contenuti in Workspace.

list_experiments = Experiment.list(ws)

Usare la funzione get_runs per recuperare un elenco di oggetti Run (versioni di valutazione) da Experiment. Il codice seguente recupera le esecuzioni e stampa ogni ID esecuzione.

list_runs = experiment.get_runs()
for run in list_runs:
    print(run.id)

Esistono due modi per eseguire una versione di valutazione dell'esperimento. Se si sta sperimentando in modo interattivo in un notebook di Jupyter, usare la funzione start_logging. Se si invia un esperimento da un ambiente Python standard, usare la funzione submit. Entrambe le funzioni restituiscono un oggetto Run. La variabile experiment rappresenta un oggetto Experiment negli esempi di codice seguenti.

Correre

spazio dei nomi: azureml.core.run.Run

Un'esecuzione rappresenta una singola versione di valutazione di un esperimento. Run è l'oggetto usato per monitorare l'esecuzione asincrona di una versione di valutazione, archiviare l'output della versione di valutazione, analizzare i risultati e accedere agli artefatti generati. È possibile usare Run all'interno del codice di sperimentazione per registrare metriche e artefatti nel servizio Cronologia di esecuzione. La funzionalità include:

  • Archiviazione e recupero di metriche e dati.
  • Uso di tag e della gerarchia figlio per una ricerca semplice delle esecuzioni precedenti.
  • Registrazione dei file di modello archiviati per la distribuzione.
  • Archiviazione, modifica e recupero delle proprietà di un'esecuzione.

Creare un oggetto Run inviando un oggetto Experiment con un oggetto di configurazione di esecuzione. Usare il parametro tags per associare categorie ed etichette personalizzate alle esecuzioni. È possibile trovarli e recuperarli più avanti da Experiment.

tags = {"prod": "phase-1-model-tests"}
run = experiment.submit(config=your_config_object, tags=tags)

Usare la funzione list statica per ottenere un elenco di tutti gli oggetti Run da Experiment. Specificare il parametro tags da filtrare in base al tag creato in precedenza.

from azureml.core.run import Run
filtered_list_runs = Run.list(experiment, tags=tags)

Usare la funzione get_details per recuperare l'output dettagliato per l'esecuzione.

run_details = run.get_details()

L'output per questa funzione è un dizionario che include:

  • ID esecuzione
  • Stato
  • Ora di inizio e fine
  • Destinazione di calcolo (locale e cloud)
  • Dipendenze e versioni usate nell'esecuzione
  • Dati specifici del training (varia a seconda del tipo di modello)

Per altri esempi di come configurare e monitorare le esecuzioni, vedere la procedura .

Modello

spazio dei nomi: azureml.core.model.Model

La classe Model viene usata per lavorare con le rappresentazioni cloud dei modelli di Machine Learning. I metodi consentono di trasferire modelli tra ambienti di sviluppo locali e l'oggetto Workspace nel cloud.

È possibile usare la registrazione del modello per archiviare e aggiornare i modelli nel cloud di Azure nell'area di lavoro. I modelli registrati sono identificati dal nome e dalla versione. Ogni volta che si registra un modello con lo stesso nome di quello esistente, il Registro di sistema incrementa la versione. Azure Machine Learning supporta qualsiasi modello che può essere caricato tramite Python 3, non solo i modelli di Azure Machine Learning.

L'esempio seguente illustra come creare un semplice modello di classificazione locale con scikit-learn, registrare il modello in Workspacee scaricare il modello dal cloud.

Creare un classificatore semplice, clf, per stimare la varianza dei clienti in base all'età. Eseguire quindi il dump del modello in un file .pkl nella stessa directory.

from sklearn import svm
import joblib
import numpy as np

# customer ages
X_train = np.array([50, 17, 35, 23, 28, 40, 31, 29, 19, 62])
X_train = X_train.reshape(-1, 1)
# churn y/n
y_train = ["yes", "no", "no", "no", "yes", "yes", "yes", "no", "no", "yes"]

clf = svm.SVC(gamma=0.001, C=100.)
clf.fit(X_train, y_train)

joblib.dump(value=clf, filename="churn-model.pkl")

Usare la funzione register per registrare il modello nell'area di lavoro. Specificare il percorso del modello locale e il nome del modello. La registrazione dello stesso nome più di una volta creerà una nuova versione.

from azureml.core.model import Model

model = Model.register(workspace=ws, model_path="churn-model.pkl", model_name="churn-model-test")

Ora che il modello è registrato nell'area di lavoro, è facile gestire, scaricare e organizzare i modelli. Per recuperare un modello (ad esempio, in un altro ambiente) da Workspace, usare il costruttore della classe e specificare il nome del modello ed eventuali parametri facoltativi. Usare quindi la funzione download per scaricare il modello, inclusa la struttura di cartelle cloud.

from azureml.core.model import Model
import os

model = Model(workspace=ws, name="churn-model-test")
model.download(target_dir=os.getcwd())

Usare la funzione delete per rimuovere il modello da Workspace.

model.delete()

Dopo aver registrato un modello, distribuirlo come servizio Web è un processo semplice. Prima di tutto, è creare e registrare un'immagine. Questo passaggio configura l'ambiente Python e le relative dipendenze, insieme a uno script per definire i formati di richiesta e risposta del servizio Web. Dopo aver creato un'immagine, è compilare una configurazione di distribuzione che imposta i core CPU e i parametri di memoria per la destinazione di calcolo. Quindi allegare l'immagine.

ComputeTarget, RunConfiguration e ScriptRunConfig

spazio dei nomi: azureml.core.compute.ComputeTarget
spazio dei nomi: azureml.core.runconfig.RunConfiguration
spazio dei nomi: azureml.core.script_run_config.ScriptRunConfig

La classe ComputeTarget è la classe padre astratta per la creazione e la gestione delle destinazioni di calcolo. Una destinazione di calcolo rappresenta un'ampia gamma di risorse in cui è possibile eseguire il training dei modelli di Machine Learning. Una destinazione di calcolo può essere un computer locale o una risorsa cloud, ad esempio Calcolo di Azure Machine Learning, Azure HDInsight o una macchina virtuale remota.

Usare le destinazioni di calcolo per sfruttare le potenti macchine virtuali per il training del modello e configurare destinazioni di calcolo persistenti o destinazioni di runtime temporanee richiamate. Per una guida completa sulla configurazione e la gestione delle destinazioni di calcolo, vedere le procedure .

Il codice seguente illustra un semplice esempio di configurazione di una destinazione AmlCompute (classe figlio di ComputeTarget). Questa destinazione crea una risorsa di calcolo remota di runtime nell'oggetto Workspace. La risorsa viene ridimensionata automaticamente quando viene inviato un processo. Viene eliminato automaticamente al termine dell'esecuzione.

Riutilizzare il modello di varianza scikit-learn semplice e compilarlo nel proprio file, train.py, nella directory corrente. Alla fine del file creare una nuova directory denominata outputs. Questo passaggio crea una directory nel cloud (area di lavoro) per archiviare il modello sottoposto a training che joblib.dump() serializzato.

# train.py

from sklearn import svm
import numpy as np
import joblib
import os

# customer ages
X_train = np.array([50, 17, 35, 23, 28, 40, 31, 29, 19, 62])
X_train = X_train.reshape(-1, 1)
# churn y/n
y_train = ["yes", "no", "no", "no", "yes", "yes", "yes", "no", "no", "yes"]

clf = svm.SVC(gamma=0.001, C=100.)
clf.fit(X_train, y_train)

os.makedirs("outputs", exist_ok=True)
joblib.dump(value=clf, filename="outputs/churn-model.pkl")

Successivamente, creare la destinazione di calcolo creando un'istanza di un oggetto RunConfiguration e impostando il tipo e le dimensioni. Questo esempio usa le dimensioni delle risorse più piccole (1 core CPU, 3,5 GB di memoria). La variabile list_vms contiene un elenco di macchine virtuali supportate e le relative dimensioni.

from azureml.core.runconfig import RunConfiguration
from azureml.core.compute import AmlCompute
list_vms = AmlCompute.supported_vmsizes(workspace=ws)

compute_config = RunConfiguration()
compute_config.target = "amlcompute"
compute_config.amlcompute.vm_size = "STANDARD_D1_V2"

Creare dipendenze per l'ambiente Python della risorsa di calcolo remota usando la classe CondaDependencies. Il file train.py usa scikit-learn e numpy, che deve essere installato nell'ambiente . È anche possibile specificare versioni delle dipendenze. Utilizzare l'oggetto dependencies per impostare l'ambiente in compute_config.

from azureml.core.conda_dependencies import CondaDependencies

dependencies = CondaDependencies()
dependencies.add_pip_package("scikit-learn")
dependencies.add_pip_package("numpy==1.15.4")
compute_config.environment.python.conda_dependencies = dependencies

A questo momento si è pronti per inviare l'esperimento. Usare la classe ScriptRunConfig per collegare la configurazione della destinazione di calcolo e specificare il percorso o il file allo script di training train.py. Inviare l'esperimento specificando il parametro config della funzione submit(). Chiamare wait_for_completion sull'esecuzione risultante per visualizzare l'output dell'esecuzione asincrona durante l'inizializzazione dell'ambiente e il training del modello.

Avvertimento

Di seguito sono riportate alcune limitazioni relative a caratteri specifici quando vengono usati nei parametri di ScriptRunConfig:

  • I caratteri ", $, ;e \ vengono preceduti da caratteri di escape dal back-end, poiché sono considerati caratteri riservati per la separazione dei comandi bash.
  • I caratteri (, ), %, !, ^, <, >, &e | vengono preceduti da caratteri di escape per le esecuzioni locali in Windows.
from azureml.core.experiment import Experiment
from azureml.core import ScriptRunConfig

script_run_config = ScriptRunConfig(source_directory=os.getcwd(), script="train.py", run_config=compute_config)
experiment = Experiment(workspace=ws, name="compute_target_test")
run = experiment.submit(config=script_run_config)
run.wait_for_completion(show_output=True)

Al termine dell'esecuzione, il file del modello sottoposto a training churn-model.pkl è disponibile nell'area di lavoro.

Ambiente

spazio dei nomi: azureml.core.environment

Gli ambienti di Azure Machine Learning specificano i pacchetti Python, le variabili di ambiente e le impostazioni software per gli script di training e assegnazione dei punteggi. Oltre a Python, è anche possibile configurare PySpark, Docker e R per gli ambienti. Internamente, gli ambienti generano immagini Docker usate per eseguire i processi di training e assegnazione dei punteggi nella destinazione di calcolo. Gli ambienti sono entità gestite e con controllo delle versioni all'interno dell'area di lavoro di Machine Learning che consentono flussi di lavoro riproducibili, controllabili e portabili di Machine Learning in un'ampia gamma di destinazioni di calcolo e tipi di calcolo.

È possibile usare un oggetto Environment per:

  • Sviluppare lo script di training.
  • Riutilizzare lo stesso ambiente nell'ambiente di calcolo di Azure Machine Learning per il training del modello su larga scala.
  • Distribuire il modello con lo stesso ambiente senza essere associato a un tipo di calcolo specifico.

Il codice seguente importa la classe Environment dall'SDK e per creare un'istanza di un oggetto ambiente.

from azureml.core.environment import Environment
Environment(name="myenv")

Aggiungere pacchetti a un ambiente usando file conda, pip o ruote private. Specificare ogni dipendenza del pacchetto usando la classe CondaDependency per aggiungerla al PythonSectiondell'ambiente .

Nell'esempio seguente viene aggiunto all'ambiente . Aggiunge la versione 1.17.0 di numpy. Aggiunge anche il pacchetto di pillow all'ambiente, myenv. Nell'esempio vengono utilizzati rispettivamente il metodo add_conda_package() e il metodo add_pip_package().

from azureml.core.environment import Environment
from azureml.core.conda_dependencies import CondaDependencies

myenv = Environment(name="myenv")
conda_dep = CondaDependencies()

# Installs numpy version 1.17.0 conda package
conda_dep.add_conda_package("numpy==1.17.0")

# Installs pillow package
conda_dep.add_pip_package("pillow")

# Adds dependencies to PythonSection of myenv
myenv.python.conda_dependencies=conda_dep

Per inviare un'esecuzione di training, è necessario combinare l'ambiente, destinazione di calcoloe lo script Python di training in una configurazione di esecuzione. Questa configurazione è un oggetto wrapper usato per l'invio di esecuzioni.

Quando si invia un'esecuzione di training, la compilazione di un nuovo ambiente può richiedere alcuni minuti. La durata dipende dalle dimensioni delle dipendenze necessarie. Gli ambienti vengono memorizzati nella cache dal servizio. A condizione che la definizione dell'ambiente rimanga invariata, il tempo di installazione completo viene eseguito una sola volta.

Nell'esempio seguente viene illustrato dove usare ScriptRunConfig come oggetto wrapper.

from azureml.core import ScriptRunConfig, Experiment
from azureml.core.environment import Environment

exp = Experiment(name="myexp", workspace = ws)
# Instantiate environment
myenv = Environment(name="myenv")

# Add training script to run config
runconfig = ScriptRunConfig(source_directory=".", script="train.py")

# Attach compute target to run config
runconfig.run_config.target = "local"

# Attach environment to run config
runconfig.run_config.environment = myenv

# Submit run 
run = exp.submit(runconfig)

Se non si specifica un ambiente nella configurazione di esecuzione prima di inviare l'esecuzione, viene creato automaticamente un ambiente predefinito.

Vedere la sezione Model deploy per usare gli ambienti per distribuire un servizio Web.

Pipeline, PythonScriptStep

spazio dei nomi: azureml.pipeline.core.pipeline.Pipeline
spazio dei nomi: azureml.pipeline.steps.python_script_step.PythonScriptStep

Una pipeline di Azure Machine Learning è un flusso di lavoro automatizzato di un'attività di Machine Learning completa. Le sottoattività vengono incapsulate come una serie di passaggi all'interno della pipeline. Una pipeline di Azure Machine Learning può essere semplice come un passaggio che chiama uno script Python. Le pipeline includono funzionalità per:

  • Preparazione dei dati, tra cui importazione, convalida e pulizia, munging e trasformazione, normalizzazione e gestione temporanea
  • Configurazione del training, tra cui parametrizzazione di argomenti, percorsi file e configurazioni di registrazione/creazione di report
  • Training e convalida in modo efficiente e ripetibile, che può includere la specifica di subset di dati specifici, risorse di calcolo hardware diverse, elaborazione distribuita e monitoraggio dello stato di avanzamento
  • Distribuzione, tra cui controllo delle versioni, ridimensionamento, provisioning e controllo di accesso
  • Pubblicazione di una pipeline in un endpoint REST da rieseguire da qualsiasi libreria HTTP

Un PythonScriptStep è un passaggio predefinito di base per eseguire uno script Python in una destinazione di calcolo. Accetta un nome di script e altri parametri facoltativi, ad esempio argomenti per lo script, la destinazione di calcolo, gli input e gli output. Il codice seguente è un semplice esempio di PythonScriptStep. Per un esempio di script di train.py, vedere la sezione secondaria tutorial.

from azureml.pipeline.steps import PythonScriptStep

train_step = PythonScriptStep(
    script_name="train.py",
    arguments=["--input", blob_input_data, "--output", output_data1],
    inputs=[blob_input_data],
    outputs=[output_data1],
    compute_target=compute_target,
    source_directory=project_folder
)

Dopo aver creato almeno un passaggio, i passaggi possono essere collegati e pubblicati come una semplice pipeline automatizzata.

from azureml.pipeline.core import Pipeline

pipeline = Pipeline(workspace=ws, steps=[train_step])
pipeline_run = experiment.submit(pipeline)

Per un esempio completo della creazione di un flusso di lavoro della pipeline, seguire l'esercitazione avanzata .

Modello per la creazione e l'uso di pipeline

Una pipeline di Azure Machine Learning è associata a un'area di lavoro di Azure Machine Learning e un passaggio della pipeline è associato a una destinazione di calcolo disponibile all'interno dell'area di lavoro. Per altre informazioni, vedere questo articolo sulle aree di lavoro o questa spiegazione delle destinazioni di calcolo .

Un modello comune per i passaggi della pipeline è:

  1. Specificare l'area di lavoro, il calcolo e l'archiviazione
  2. Configurare i dati di input e output usando
    1. set di dati che rende disponibile un archivio dati di Azure esistente
    2. PipelineDataset che incapsula i dati tabulari tipizzato
    3. pipelineData che viene usata per i dati intermedi di file o directory scritti da un passaggio e destinati a essere utilizzati da un altro
  3. Definire uno o più passaggi della pipeline
  4. Creare un'istanza di una pipeline usando l'area di lavoro e i passaggi
  5. Creare un esperimento a cui inviare la pipeline
  6. Monitorare i risultati dell'esperimento

Questo notebook è un buon esempio di questo modello. lavoro

Per altre informazioni sulle pipeline di Azure Machine Learning e in particolare su come sono diverse da altri tipi di pipeline, vedere questo articolo .

AutoMLConfig

spazio dei nomi: azureml.train.automl.automlconfig.AutoMLConfig

Usare la classe AutoMLConfig per configurare i parametri per il training automatizzato di Machine Learning. Machine Learning automatizzato scorre molte combinazioni di algoritmi di Machine Learning e impostazioni degli iperparametri. Trova quindi il modello più adatto in base alla metrica di accuratezza scelta. La configurazione consente di specificare:

  • Tipo di attività (classificazione, regressione, previsione)
  • Numero di iterazioni degli algoritmi e tempo massimo per iterazione
  • Metrica di accuratezza per ottimizzare
  • Algoritmi per l'elenco di elementi bloccati/allowlist
  • Numero di convalide incrociate
  • Destinazioni di calcolo
  • Dati di training

Nota

Usare il automl aggiuntivo nell'installazione per usare l'apprendimento automatico.

Per guide dettagliate ed esempi di configurazione di esperimenti di Machine Learning automatizzato, vedere l'esercitazione e procedure.

Il codice seguente illustra la creazione di un oggetto di configurazione di Machine Learning automatizzato per un modello di classificazione e l'uso quando si invia un esperimento.

from azureml.train.automl import AutoMLConfig

automl_config = AutoMLConfig(task="classification",
                             X=your_training_features,
                             y=your_training_labels,
                             iterations=30,
                             iteration_timeout_minutes=5,
                             primary_metric="AUC_weighted",
                             n_cross_validations=5
                            )

Utilizzare l'oggetto automl_config per inviare un esperimento.

from azureml.core.experiment import Experiment

experiment = Experiment(ws, "automl_test_experiment")
run = experiment.submit(config=automl_config, show_output=True)

Dopo aver inviato l'esperimento, l'output mostra l'accuratezza del training per ogni iterazione al termine dell'esecuzione. Al termine dell'esecuzione, viene restituito un oggetto AutoMLRun (che estende la classe Run). Ottenere il modello più adatto usando la funzione get_output() per restituire un oggetto Model.

best_model = run.get_output()
y_predict = best_model.predict(X_test)

Distribuzione del modello

spazio dei nomi: azureml.core.model.InferenceConfig
spazio dei nomi: azureml.core.webservice.webservice.Webservice

La classe InferenceConfig è per le impostazioni di configurazione che descrivono l'ambiente necessario per ospitare il modello e il servizio Web.

Webservice è la classe padre astratta per la creazione e la distribuzione di servizi Web per i modelli. Per una guida dettagliata sulla preparazione per la distribuzione di modelli e la distribuzione di servizi Web, vedere questa procedura.

È possibile usare ambienti quando si distribuisce il modello come servizio Web. Gli ambienti consentono un flusso di lavoro riproducibile e connesso in cui è possibile distribuire il modello usando le stesse librerie sia nel calcolo di training che nel calcolo di inferenza. Internamente, gli ambienti vengono implementati come immagini Docker. È possibile usare le immagini fornite da Microsoft o usare immagini Docker personalizzate. Se in precedenza si usava la classe ContainerImage per la distribuzione, vedere la classe DockerSection per eseguire un flusso di lavoro simile con gli ambienti.

Per distribuire un servizio Web, combinare l'ambiente, il calcolo dell'inferenza, lo script di assegnazione dei punteggi e il modello registrato nell'oggetto di distribuzione, deploy().

L'esempio seguente presuppone che sia già stata completata un'esecuzione di training usando l'ambiente, myenve si vuole distribuire tale modello in Istanze di Azure Container.

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

# Register the model to deploy
model = run.register_model(model_name = "mymodel", model_path = "outputs/model.pkl")

# Combine scoring script & environment in Inference configuration
inference_config = InferenceConfig(entry_script="score.py",
                                   environment=myenv)

# Set deployment configuration
deployment_config = AciWebservice.deploy_configuration(cpu_cores = 1,
                                                       memory_gb = 1)

# Define the model, inference, & deployment configuration and web service name and location to deploy
service = Model.deploy(workspace = ws,
                       name = "my_web_service",
                       models = [model],
                       inference_config = inference_config,
                       deployment_config = deployment_config)

Questo esempio crea un servizio Web istanze di Azure Container, ideale per test su scala ridotta e distribuzioni rapide. Per distribuire il modello come servizio Web su scala di produzione, usare il servizio Azure Kubernetes. Per altre informazioni, vedere classe AksCompute.

Dataset

spazio dei nomi: azureml.core.dataset.Dataset
spazio dei nomi: azureml.data.file_dataset.FileDataset
spazio dei nomi: azureml.data.tabular_dataset.TabularDataset

La classe Dataset è una risorsa di base per l'esplorazione e la gestione dei dati all'interno di Azure Machine Learning. È possibile esplorare i dati con statistiche di riepilogo e salvare il set di dati nell'area di lavoro AML per ottenere funzionalità di controllo delle versioni e riproducibilità. I set di dati vengono usati facilmente dai modelli durante il training. Per esempi di utilizzo dettagliati, vedere la guida pratica .

  • TabularDataset rappresenta i dati in un formato tabulare creato analizzando un file o un elenco di file.
  • FileDataset fa riferimento a uno o più file negli archivi dati o da URL pubblici.

Nell'esempio seguente viene illustrato come creare un oggetto TabularDataset che punta a un singolo percorso in un archivio dati.

from azureml.core import Dataset

dataset = Dataset.Tabular.from_delimited_files(path = [(datastore, 'train-dataset/tabular/iris.csv')])
dataset.take(3).to_pandas_dataframe()

Nell'esempio seguente viene illustrato come creare un FileDataset che fa riferimento a più URL di file.

from azureml.core.dataset import Dataset

url_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=url_paths)

Passaggi successivi

Provare questi passaggi successivi per informazioni su come usare Azure Machine Learning SDK per Python:

  • Seguire l'esercitazione per informazioni su come compilare, eseguire il training e distribuire un modello in Python.

  • Cercare classi e moduli nella documentazione di riferimento di questo sito usando il sommario a sinistra.