Avvio rapido: Iniziare a usare il servizio Azure Machine Learning

SI APPLICA A: Python SDK azure-ai-ml v2 (corrente)

Questa esercitazione fornisce un'introduzione ad alcune delle funzionalità più usate del servizio Azure Machine Learning. Viene creato, registrato e distribuito un modello. Questa esercitazione consente di acquisire familiarità con i concetti di base di Azure Machine Learning e i metodi di utilizzo più comuni.

Si apprenderà come eseguire un processo di training in una risorsa di calcolo scalabile, quindi distribuirlo e infine testare la distribuzione.

Viene creato uno script di training per gestire la preparazione dei dati, eseguire il training e registrare un modello. Dopo aver eseguito il training, il modello viene distribuito in un endpoint, quindi viene chiamato l'endpoint per l'inferenza.

I passaggi da eseguire sono:

Per una panoramica dei passaggi di questo argomento di avvio rapido, guardare questo video.

Prerequisiti

1. Per usare Azure Machine Learning, è necessaria un'area di lavoro. Se non è disponibile, completare Creare le risorse necessarie per iniziare creare un'area di lavoro e ottenere maggiori informazioni su come usarla.

   Importante

   Se l'area di lavoro di Azure Machine Learning è configurata con una rete virtuale gestita, potrebbe essere necessario aggiungere regole in uscita per consentire l'accesso ai repository di pacchetti Python pubblici. Per altre informazioni, vedere Scenario: Accedere ai pacchetti di Machine Learning pubblici.

2. Accedere allo studio e selezionare l'area di lavoro, se non è già aperta.

3. Aprire o creare un notebook nell'area di lavoro:

   • Se si vuole copiare e incollare il codice nelle celle, creare un nuovo notebook.
   • In alternativa, aprire tutorials/get-started-notebooks/quickstart.ipynb dalla sezione Esempi dello studio. Selezionare quindi Clona per aggiungere il notebook in File. Per trovare notebook di esempio, vedere Learn from sample notebooks (Informazioni sui notebook di esempio).

Impostare il kernel e aprirlo in Visual Studio Code (VS Code)

1. Nella barra superiore sopra il notebook aperto creare un'istanza di ambiente di calcolo, se non ne è già disponibile una.

   

2. Se l'istanza di ambiente di calcolo viene arrestata, selezionare Avviare ambiente di calcolo e attendere fino a quando non è in esecuzione.

   

3. Attendere che l'istanza di calcolo sia in esecuzione. Assicurarsi quindi che il kernel, trovato in alto a destra, sia Python 3.10 - SDK v2. In caso contrario, usare l'elenco a discesa per selezionare questo kernel.

   

   Se questo kernel non viene visualizzato, verificare che l'istanza di calcolo sia in esecuzione. In caso affermativo, selezionare il pulsante Aggiorna in alto a destra del notebook.

4. Se viene visualizzato un banner che indica che è necessario eseguire l'autenticazione, selezionare Autentica.

5. È possibile eseguire il notebook qui o aprirlo in VS Code per usare un ambiente di sviluppo integrato (IDE) completo con la potenza delle risorse di Azure Machine Learning. Selezionare Apri in VS Code, quindi selezionare l'opzione Web o desktop. Quando viene avviato in questo modo, VS Code viene collegato all'istanza di ambiente di calcolo, al kernel e al file system dell'area di lavoro.

   

Creare un handle all'area di lavoro

Prima di approfondire il codice, è necessario un modo per fare riferimento all'area di lavoro. L'area di lavoro è la risorsa di primo livello per Azure Machine Learning, che fornisce una posizione centralizzata da cui gestire tutti gli artefatti creati quando si usa Azure Machine Learning.

Verrà creato ml_client per un handle nell'area di lavoro. Sarà quindi possibile usare ml_client per gestire le risorse e i processi.

Nella cella successiva immettere l'ID sottoscrizione, il nome del gruppo di risorse e il nome dell'area di lavoro. Per trovare questi valori:

1. In alto a destra nella barra degli strumenti dello studio di Azure Machine Learning selezionare il nome dell'area di lavoro.
2. Copiare i valori per l'area di lavoro, il gruppo di risorse e l'ID sottoscrizione nel codice.
3. È necessario copiare un valore, chiudere l'area e incollarlo, quindi tornare indietro per quello successivo.

from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential

# authenticate
credential = DefaultAzureCredential()

SUBSCRIPTION = "<SUBSCRIPTION_ID>"
RESOURCE_GROUP = "<RESOURCE_GROUP>"
WS_NAME = "<AML_WORKSPACE_NAME>"
# Get a handle to the workspace
ml_client = MLClient(
    credential=credential,
    subscription_id=SUBSCRIPTION,
    resource_group_name=RESOURCE_GROUP,
    workspace_name=WS_NAME,
)

# Verify that the handle works correctly.
# If you ge an error here, modify your SUBSCRIPTION, RESOURCE_GROUP, and WS_NAME in the previous cell.
ws = ml_client.workspaces.get(WS_NAME)
print(ws.location, ":", ws.resource_group)

Creare lo script di training

Per iniziare, creare lo script di training, ovvero il file Python main.py.

Creare prima di tutto una cartella di origine per lo script:

import os

train_src_dir = "./src"
os.makedirs(train_src_dir, exist_ok=True)

Lo script gestisce la pre-elaborazione dei dati, suddividendoli in dati di test e di training. Usa quindi i dati per eseguire il training di un modello basato su albero e restituire il modello di output.

Viene usato MLFlow per registrare i parametri e le metriche durante l'esecuzione della pipeline.

La cella seguente usa un magic IPython per scrivere lo script di training nella directory appena creata.

%%writefile {train_src_dir}/main.py
import os
import argparse
import pandas as pd
import mlflow
import mlflow.sklearn
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.metrics import classification_report
from sklearn.model_selection import train_test_split

def main():
    """Main function of the script."""

    # input and output arguments
    parser = argparse.ArgumentParser()
    parser.add_argument("--data", type=str, help="path to input data")
    parser.add_argument("--test_train_ratio", type=float, required=False, default=0.25)
    parser.add_argument("--n_estimators", required=False, default=100, type=int)
    parser.add_argument("--learning_rate", required=False, default=0.1, type=float)
    parser.add_argument("--registered_model_name", type=str, help="model name")
    args = parser.parse_args()
   
    # Start Logging
    mlflow.start_run()

    # enable autologging
    mlflow.sklearn.autolog()

    ###################
    #<prepare the data>
    ###################
    print(" ".join(f"{k}={v}" for k, v in vars(args).items()))

    print("input data:", args.data)
    
    credit_df = pd.read_csv(args.data, header=1, index_col=0)

    mlflow.log_metric("num_samples", credit_df.shape[0])
    mlflow.log_metric("num_features", credit_df.shape[1] - 1)

    train_df, test_df = train_test_split(
        credit_df,
        test_size=args.test_train_ratio,
    )
    ####################
    #</prepare the data>
    ####################

    ##################
    #<train the model>
    ##################
    # Extracting the label column
    y_train = train_df.pop("default payment next month")

    # convert the dataframe values to array
    X_train = train_df.values

    # Extracting the label column
    y_test = test_df.pop("default payment next month")

    # convert the dataframe values to array
    X_test = test_df.values

    print(f"Training with data of shape {X_train.shape}")

    clf = GradientBoostingClassifier(
        n_estimators=args.n_estimators, learning_rate=args.learning_rate
    )
    clf.fit(X_train, y_train)

    y_pred = clf.predict(X_test)

    print(classification_report(y_test, y_pred))
    ###################
    #</train the model>
    ###################

    ##########################
    #<save and register model>
    ##########################
    # Registering the model to the workspace
    print("Registering the model via MLFlow")

    # pin numpy
    conda_env = {
        'name': 'mlflow-env',
        'channels': ['conda-forge'],
        'dependencies': [
            'python=3.10.15',
            'pip<=21.3.1',
            {
                'pip': [
                    'mlflow==2.17.0',
                    'cloudpickle==2.2.1',
                    'pandas==1.5.3',
                    'psutil==5.8.0',
                    'scikit-learn==1.5.2',
                    'numpy==1.26.4',
                ]
            }
        ],
    }

    mlflow.sklearn.log_model(
        sk_model=clf,
        registered_model_name=args.registered_model_name,
        artifact_path=args.registered_model_name,
        conda_env=conda_env,
    )

    # Saving the model to a file
    mlflow.sklearn.save_model(
        sk_model=clf,
        path=os.path.join(args.registered_model_name, "trained_model"),
    )
    ###########################
    #</save and register model>
    ###########################
    
    # Stop Logging
    mlflow.end_run()

if __name__ == "__main__":
    main()

Come si può notare nello script, una volta eseguito il training del modello, il file del modello viene salvato e registrato nell'area di lavoro. È ora possibile usare il modello registrato negli endpoint di inferenza.

Potrebbe essere necessario selezionare Aggiorna per visualizzare la nuova cartella e lo script in File.

Configurare il comando

Ora che è disponibile uno script che può eseguire le attività desiderate e di un cluster di elaborazione per eseguire lo script, viene usato un comando per utilizzo generico che può eseguire le azioni della riga di comando. Questa azione della riga di comando può chiamare direttamente comandi di sistema o eseguire uno script.

In questo caso vengono create variabili di input per specificare i dati di input, il rapporto di suddivisione, la velocità di apprendimento e il nome del modello registrato. Lo script di comando eseguirà le operazioni seguenti:

• Utilizzo di un ambiente che definisce le librerie software e di runtime necessarie per lo script di training. Azure Machine Learning fornisce molti ambienti curati o pronti, utili per scenari di training e inferenza comuni. In questo caso si userà uno di questi ambienti. Nell'Esercitazione: Eseguire il training di un modello in Azure Machine Learning si apprenderà come creare un ambiente personalizzato.
• Configurerà l'azione della riga di comando stessa, in questo caso python main.py. Gli input/output sono accessibili nel comando tramite la notazione ${{ ... }}.
• In questo esempio si accede ai dati da un file in Internet.
• Poiché non è stata specificata una risorsa di calcolo, lo script verrà eseguito in un cluster di elaborazione serverless creato automaticamente.

from azure.ai.ml import command
from azure.ai.ml import Input

registered_model_name = "credit_defaults_model"

job = command(
    inputs=dict(
        data=Input(
            type="uri_file",
            path="https://azuremlexamples.blob.core.windows.net/datasets/credit_card/default_of_credit_card_clients.csv",
        ),
        test_train_ratio=0.2,
        learning_rate=0.25,
        registered_model_name=registered_model_name,
    ),
    code="./src/",  # location of source code
    command="python main.py --data ${{inputs.data}} --test_train_ratio ${{inputs.test_train_ratio}} --learning_rate ${{inputs.learning_rate}} --registered_model_name ${{inputs.registered_model_name}}",
    environment="azureml://registries/azureml/environments/sklearn-1.5/labels/latest",
    display_name="credit_default_prediction",
)

Inviare il processo

È ora possibile inviare il processo per l'esecuzione in Azure Machine Learning. Questa volta si userà create_or_update in ml_client.

ml_client.create_or_update(job)

Visualizzare l'output del processo e attendere il completamento del processo

Visualizzare il processo nello studio di Azure Machine Learning selezionando il collegamento nell'output della cella precedente.

L'output di questo processo sarà simile al seguente in Azure Machine Learning Studio. Esplorare le schede per visualizzare diversi dettagli, ad esempio metriche, output e così via. Al termine, la processo registra un modello nell'area di lavoro come risultato del training.

Distribuire il modello come endpoint online

Distribuire ora il modello di Machine Learning come servizio Web nel cloud Azure, come oggetto online endpoint.

Per distribuire un servizio Machine Learning, viene usato il modello registrato.

Creare un nuovo endpoint online

Ora che si dispone di un modello registrato, è possibile creare l'endpoint online. Il nome dell'endpoint deve essere univoco all'interno dell'area di Azure. Per questa esercitazione, viene creato un nome univoco usando UUID.

import uuid

# Creating a unique name for the endpoint
online_endpoint_name = "credit-endpoint-" + str(uuid.uuid4())[:8]

Creare l'endpoint:

# Expect the endpoint creation to take a few minutes
from azure.ai.ml.entities import (
    ManagedOnlineEndpoint,
    ManagedOnlineDeployment,
    Model,
    Environment,
)

# create an online endpoint
endpoint = ManagedOnlineEndpoint(
    name=online_endpoint_name,
    description="this is an online endpoint",
    auth_mode="key",
    tags={
        "training_dataset": "credit_defaults",
        "model_type": "sklearn.GradientBoostingClassifier",
    },
)

endpoint = ml_client.online_endpoints.begin_create_or_update(endpoint).result()

print(f"Endpoint {endpoint.name} provisioning state: {endpoint.provisioning_state}")

Dopo aver creato l'endpoint, è possibile recuperarlo come indicato di seguito:

endpoint = ml_client.online_endpoints.get(name=online_endpoint_name)

print(
    f'Endpoint "{endpoint.name}" with provisioning state "{endpoint.provisioning_state}" is retrieved'
)

Distribuire il modello nell'endpoint

Una volta creato l'endpoint, distribuire il modello con lo script di immissione. Un endpoint batch può avere più distribuzioni. È possibile specificare che il traffico venga diretto a queste distribuzioni usando le regole. In questo caso viene creata una singola distribuzione che gestisce il 100% del traffico in ingresso. È stato scelto un nome colore per la distribuzione, ad esempio distribuzioni blu, verde, rossa, arbitrariamente.

È possibile esaminare la pagina Modelli nello studio di Azure Machine Learning per identificare la versione più recente del modello registrato. In alternativa, il codice seguente consente di recuperare il numero dell'ultima versione da usare.

# Let's pick the latest version of the model
latest_model_version = max(
    [int(m.version) for m in ml_client.models.list(name=registered_model_name)]
)
print(f'Latest model is version "{latest_model_version}" ')

Distribuire la versione più recente del modello.

# picking the model to deploy. Here we use the latest version of our registered model
model = ml_client.models.get(name=registered_model_name, version=latest_model_version)

# Expect this deployment to take approximately 6 to 8 minutes.
# create an online deployment.
# if you run into an out of quota error, change the instance_type to a comparable VM that is available.
# Learn more on https://azure.microsoft.com/pricing/details/machine-learning/.
blue_deployment = ManagedOnlineDeployment(
    name="blue",
    endpoint_name=online_endpoint_name,
    model=model,
    instance_type="Standard_DS3_v2",
    instance_count=1,
)

blue_deployment = ml_client.begin_create_or_update(blue_deployment).result()

Al termine della distribuzione, sarà possibile testarla.

Eseguire test con una query di esempio

Dopo aver distribuito il modello nell'endpoint, è possibile eseguire l'inferenza.

Creare un file di richiesta di esempio seguendo la progettazione prevista nel metodo run nello script di punteggio.

deploy_dir = "./deploy"
os.makedirs(deploy_dir, exist_ok=True)

%%writefile {deploy_dir}/sample-request.json
{
  "input_data": {
    "columns": [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22],
    "index": [0, 1],
    "data": [
            [20000,2,2,1,24,2,2,-1,-1,-2,-2,3913,3102,689,0,0,0,0,689,0,0,0,0],
            [10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 10, 9, 8]
        ]
  }
}

# test the blue deployment with some sample data
ml_client.online_endpoints.invoke(
    endpoint_name=online_endpoint_name,
    request_file="./deploy/sample-request.json",
    deployment_name="blue",
)

Pulire le risorse

Se non si prevede di usare l'endpoint, eliminarlo per interrompere l'uso della risorsa. Prima di eliminare l'endpoint, assicurarsi che nessun'altra distribuzione lo stia usando.

ml_client.online_endpoints.begin_delete(name=online_endpoint_name)

Arrestare l'istanza di ambiente di calcolo

Se non si prevede di usare subito l'istanza di ambiente di calcolo, arrestarla:

1. Nell'area di spostamento a sinistra nello studio selezionare Ambiente di calcolo.
2. Nelle schede in alto selezionare Istanze di ambiente di calcolo
3. Selezionare l'istanza di ambiente di calcolo nell'elenco.
4. Sulla barra degli strumenti in alto selezionare Arresta.

Eliminare tutte le risorse

Se le risorse create non servono più, eliminarle per evitare addebiti:

1. Nella casella di ricerca della portale di Azure immettere Gruppi di risorse e selezionarlo nei risultati.

2. Nell'elenco selezionare il gruppo di risorse creato.

3. Nella pagina Panoramica selezionare Elimina gruppo di risorse.

   

4. Immettere il nome del gruppo di risorse. Quindi seleziona Elimina.

Passaggi successivi

Ora che si ha un'idea delle operazioni associate al training e alla distribuzione di un modello, è possibile eseguire queste esercitazioni per altre informazioni sul processo: