Condividi tramite

Che cos'è Azure Machine Learning SDK per Python?

  • Articolo

I data scientist e gli sviluppatori per intelligenza artificiale usano SDK di Azure Machine Learning per Python al fine di compilare ed eseguire flussi di lavoro di machine learning con il servizio di Azure Machine Learning. È possibile interagire con il servizio in qualsiasi ambiente Python, incluso Jupyter Notebook, Visual Studio Code o l'ambiente di sviluppo integrato di Python preferito.

Le aree principali dell'SDK includono:

  • Esplorazione, preparazione e gestione del ciclo di vita dei set di dati usati negli esperimenti di machine learning.
  • Gestione delle risorse cloud per il monitoraggio, la registrazione e l'organizzazione degli esperimenti di machine learning.
  • Training dei modelli in locale o tramite risorse cloud, incluso il training di modelli con accelerazione GPU.
  • Uso del Machine Learning automatizzato, che accetta i parametri di configurazione e i dati di training. Scorre automaticamente gli algoritmi e le impostazioni degli iperparametri per trovare il modello migliore per l'esecuzione delle stime.
  • Distribuzione dei servizi Web per convertire i modelli con training in servizi RESTful che possano essere utilizzati in qualsiasi applicazione.

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

Le sezioni seguenti offrono una panoramica di alcune delle classi più importanti dell'SDK e una descrizione dei modelli di progettazione comuni per l'uso di tali classi. Per ottenere l'SDK, vedere la guida all'installazione.

Differenze tra versione stabile e versione sperimentale

Azure Machine Learning SDK per Python include sia funzionalità stabili che sperimentali nello stesso SDK.

Stato funzionalità/funzionalità Descrizione
Funzionalità stabili Pronto per la produzione

Queste funzionalità sono consigliate per la maggior parte dei casi d'uso e degli ambienti di produzione. Vengono aggiornate con minore frequenza rispetto alle funzionalità sperimentali.
Funzionalità sperimentali Sviluppo

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

Come indica il nome, le funzionalità sperimentali (anteprima) sono destinate all'esperimento e non sono considerate prive di bug o stabili. Per questo motivo, le funzionalità sperimentali sono consigliate solo agli utenti esperti che vogliono provare in anticipo aggiornamenti e funzionalità e sono disposti a segnalare bug e problemi.

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

Area di lavoro

Spazio dei nomi: azureml.core.workspace.Workspace

La classe Workspace è una risorsa cloud di base usata per eseguire gli esperimenti, il training e la distribuzione di modelli di Machine Learning. Collega la sottoscrizione e il gruppo di risorse di Azure a un oggetto di facile utilizzo.

Visualizzare tutti i parametri del metodo create Workspace per riutilizzare le istanze esistenti (Archiviazione, Key Vault, App-Insights e Registro Azure Container-Registro Azure Container) 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 ha un gruppo di risorse di Azure già 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 di tutto in un file JSON di configurazione, in modo da salvare i dati relativi a sottoscrizione, risorsa e 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 statico get() per caricare un'area di lavoro esistente senza usare file di configurazione.

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

Negli esempi di codice riportati di seguito, la variabile ws rappresenta un oggetto Workspace.

Esperimento

Spazio dei nomi: azureml.core.experiment.Experiment

La classe Experiment è un'altra risorsa cloud di base che rappresenta una raccolta di prove, ossia singole esecuzioni del modello. Il codice seguente recupera un oggetto Experiment da Workspace in base al nome o 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 (prove) da Experiment. Il codice seguente recupera le esecuzioni e visualizza ogni ID esecuzione.

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

È possibile eseguire una prova di esperimento in due modi. Se si sta eseguendo un esperimento interattivo in un notebook di Jupyter, usare la funzione start_logging. Se si sta inviando un esperimento da un ambiente Python standard, usare la funzione submit. Entrambe le funzioni restituiscono un oggetto Run. Negli esempi di codice riportati di seguito, la variabile experiment rappresenta un oggetto Experiment.

Esegui

Spazio dei nomi: azureml.core.run.Run

Un'esecuzione (run) rappresenta una singola prova di un esperimento. Run è l'oggetto usato per monitorare l'esecuzione asincrona di una prova, archiviare l'output della prova, analizzare i risultati e accedere agli artefatti generati. Si usa Run all'interno del codice di sperimentazione per registrare le metriche e gli artefatti nel servizio di cronologia di esecuzione. Le funzionalità includono:

  • Archiviazione e recupero di metriche e dati.
  • Uso dei tag e della gerarchia figlio per semplificare la ricerca delle esecuzioni passate.
  • 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 dell'esecuzione. Usare il parametro tags per associare etichette e categorie personalizzate alle esecuzioni. È così possibile trovarle e recuperarle facilmente in un secondo momento da Experiment.

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

Usare la funzione statica list per ottenere un elenco di tutti gli oggetti Run da Experiment. Specificare il parametro tags per 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 dell'esecuzione.

run_details = run.get_details()

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

  • ID esecuzione
  • Stato
  • Ora di inizio e ora di fine
  • Destinazione di calcolo (locale o cloud)
  • Dipendenze e versioni usate nell'esecuzione
  • Dati specifici del training (dipendono dal tipo di modello)

Per altri esempi su come configurare e monitorare le esecuzioni, vedere la guida pratica.

Modello

Spazio dei nomi: azureml.core.model.Model

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

È possibile usare la registrazione dei modelli per archiviare i modelli e creare le relative versioni nel cloud di Azure, all'interno della propria 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 uno esistente, il registro incrementa la versione. Azure Machine Learning supporta qualsiasi modello che possa essere caricato tramite Python 3, non solo i modelli del servizio stesso.

L'esempio seguente illustra come compilare un modello di classificazione locale semplice con scikit-learn, registrare il modello in Workspace e scaricarlo dal cloud.

Creare un classificatore semplice, clf, per stimare l'abbandono 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. Se si registra lo stesso nome più volte viene creata ogni volta 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 oggetto 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()

Quando un modello è registrato, distribuirlo come servizio Web è un processo semplice. Prima di tutto occorre 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, occorre compilare una configurazione di distribuzione che imposta i core CPU e i parametri di memoria per la destinazione di calcolo. A questo punto si associa 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 di destinazioni di calcolo. Una destinazione di calcolo rappresenta una varietà 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, come un ambiente di calcolo di Machine Learning, Azure HDInsight o una macchina virtuale remota.

Usare le destinazioni di calcolo per sfruttare le potenti macchine virtuali per il training dei modelli e configurare destinazioni di calcolo permanenti o destinazioni temporanee richiamate dal runtime. Per indicazioni complete sulla configurazione e la gestione delle destinazioni di calcolo, vedere la guida pratica.

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 eliminata automaticamente al termine dell'esecuzione.

Riutilizzare il semplice modello di stima dell'abbandono dei clienti scikit-learn e compilarlo nel suo stesso file, train.py, nella directory corrente. Alla fine del file creare una nuova directory denominata outputs. Questo passaggio crea una directory nel cloud (l'area di lavoro) in cui archiviare il modello con training serializzato da joblib.dump().

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

Creare quindi la destinazione di calcolo creando un'istanza di un oggetto RunConfiguration e impostando il tipo e le dimensioni. Questo esempio usa le dimensioni più piccole della risorsa (1 core CPU, 3,5 GB di memoria). La variabile list_vms contiene un elenco delle macchine virtuali supportate con 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 remoto usando la classe CondaDependencies. Il file train.py usa scikit-learn e numpy, che devono essere installati nell'ambiente. È anche possibile specificare le versioni delle dipendenze. Usare 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 punto si è pronti per inviare l'esperimento. Usare la classe ScriptRunConfig per associare la configurazione della destinazione di calcolo e per specificare il percorso o il file dello script di training train.py. Inviare l'esperimento specificando il parametro config della funzione submit(). Chiamare wait_for_completion sull'esecuzione risultante per vedere l'output dell'esecuzione asincrona mentre viene inizializzato l'ambiente e viene eseguito il training del modello.

Avviso

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

  • I "caratteri , $, ;e \ vengono preceduti dal back-end, poiché sono considerati caratteri riservati per la separazione dei comandi bash.
  • I (caratteri , %), !>&^<e | vengono preceduti da un carattere 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 churn-model.pkl del modello con training è disponibile nell'area di lavoro.

Environment

Spazio dei nomi: azureml.core.environment

Gli ambienti Azure Machine Learning specificano i pacchetti Python, le variabili di ambiente e le impostazioni software per gli script di training e assegnazione di 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 di punteggi nella destinazione di calcolo. Gli ambienti sono entità gestite e con versione all'interno dell'area di lavoro di Machine Learning che consentono flussi di lavoro riproducibili, controllabili e portabili in un'ampia gamma di tipi e destinazioni di calcolo.

È possibile usare un oggetto Environment per:

  • Sviluppare lo script di training.
  • Riutilizzare lo stesso ambiente nell'ambiente di calcolo di Machine Learning per il training dei modelli su larga scala.
  • Distribuire il modello con lo stesso ambiente senza essere vincolati 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 i pacchetti a un ambiente usando Conda, pip o file wheel privati. Specificare ogni dipendenza del pacchetto usando la classe CondaDependency per aggiungerla all'elemento PythonSectiondell'ambiente.

L'esempio seguente esegue aggiunte nell'ambiente. Aggiunge la versione 1.17.0 di numpy. Aggiunge anche il pacchetto di pillow all'ambiente, myenv. Vengono usati 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, la destinazione di calcolo e 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, lo sviluppo di un nuovo ambiente può richiedere diversi minuti. La durata dipende dalle dimensioni delle dipendenze richieste. Gli ambienti vengono memorizzati nella cache dal servizio. Finché la definizione dell'ambiente rimane invariata, la configurazione completa verrà eseguita una sola volta.

L'esempio seguente mostra 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 Distribuzione di modelli per informazioni sull'uso degli 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à sono incapsulate come una serie di passaggi all'interno della pipeline. Una pipeline di Azure Machine Learning può anche essere un unico 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/report
  • Operazioni efficienti e ripetibili di training e convalida, che possono includere la specifica di subset di dati specifici, risorse di calcolo hardware diverse, elaborazione distribuita e monitoraggio dello stato di avanzamento
  • Distribuzione, inclusi controllo delle versioni, ridimensionamento, provisioning e controllo degli accessi
  • Pubblicazione di una pipeline in un endpoint REST da rieseguire da qualsiasi libreria HTTP

Un PythonScriptStep è un passaggio predefinito di base per l'esecuzione di uno script Python in una destinazione di calcolo. Accetta un nome di script e altri parametri facoltativi come gli argomenti per lo script, la destinazione di calcolo, input e output. Il codice seguente è un semplice esempio di PythonScriptStep. Per un esempio di script train.py, vedere la sottosezione dell'esercitazione.

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 che è stato creato almeno un passaggio, i passaggi possono essere collegati tra loro 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 di compilazione 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, mentre 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 di pipeline è il seguente:

  1. Specificare l'area di lavoro, la destinazione di calcolo e la risorsa di archiviazione
  2. Configurare i dati di input e di output usando:
    1. Dataset, che rende disponibile un archivio dati di Azure esistente
    2. PipelineDataset , che incapsula i dati tabulari tipizzati
    3. PipelineData , usato per i dati intermedi di file o directory scritti da un passaggio e destinati a essere utilizzati da un altro passaggio
  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 valido esempio di questo modello. processo

Per altre informazioni sulle pipeline di Azure Machine Learning, e in particolare sulle differenze rispetto ad 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 di Machine Learning automatizzato. Il Machine Learning automatizzato scorre numerose combinazioni di algoritmi di machine learning e impostazioni di 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 di algoritmi e tempo massimo per iterazione
  • Metrica di accuratezza da ottimizzare
  • Algoritmi da bloccare/elenco di elementi consentiti
  • Numero di convalide incrociate
  • Destinazioni di calcolo
  • Dati di training

Nota

Usare l'oggetto automl aggiuntivo nell'installazione per usare il Machine Learning automatizzato.

Per indicazioni dettagliate ed esempi relativi alla configurazione di esperimenti di Machine Learning automatizzato, vedere l'esercitazione e la guida pratica.

Il codice seguente illustra come creare un oggetto di configurazione di Machine Learning automatizzato per un modello di classificazione e come usarlo per inviare 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
                            )

Usare 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 subito dopo il completamento. Al termine dell'esecuzione, viene restituito un oggetto AutoMLRun (che estende la classe Run). Ottenere il modello più appropriato usando la funzione get_output() per restituire un oggetto Model.

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

Distribuzione di modelli

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

La classe InferenceConfig serve per configurare le impostazioni 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 indicazioni dettagliate su come preparare la distribuzione di modelli e servizi Web, vedere questa guida pratica.

È possibile usare gli 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 oppure immagini Docker personalizzate. Se in precedenza si usa 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 di inferenza, lo script di assegnazione di punteggi e il modello registrato nell'oggetto di distribuzione, deploy().

Nell'esempio seguente si presuppone che sia già stata completata un'esecuzione di training usando l'ambiente myenv e si vuole distribuire il 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 i test su scala ridotta e le distribuzioni rapide. Per distribuire il modello come servizio Web a livello di produzione, usare il servizio Azure Kubernetes. Per altre informazioni, vedere Classe AksCompute.

Set di dati

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 di Azure Machine Learning per ottenere funzionalità di controllo delle versioni e riproducibilità. I set di dati vengono utilizzati con facilità dai modelli durante il training. Per esempi di utilizzo dettagliati, vedere la guida pratica.

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

L'esempio seguente illustra come creare un 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()

L'esempio seguente mostra 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

Eseguire i passaggi seguenti per imparare a usare Azure Machine Learning SDK per Python:

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

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