Självstudie: Azure Machine Learning på en dag

GÄLLER FÖR: Python SDK azure-ai-ml v2 (aktuell)

Lär dig hur en dataexpert använder Azure Machine Learning (Azure ML) för att träna en modell och använd sedan modellen för förutsägelse. Den här självstudien hjälper dig att bekanta dig med grundbegreppen i Azure ML och deras vanligaste användning.

Du får lära dig hur du skickar ett kommandojobb för att köra träningsskriptet på en angiven beräkningsresurs, konfigurerad med den jobbmiljö som krävs för att köra skriptet.

Träningsskriptet hanterar dataförberedelserna och tränar och registrerar sedan en modell. När du har modellen distribuerar du den som en slutpunkt och anropar sedan slutpunkten för slutsatsdragning.

De steg du ska vidta är:

  • Ansluta till din Azure ML-arbetsyta
  • Skapa din beräkningsresurs och jobbmiljö
  • Skapa ditt träningsskript
  • Skapa och kör kommandojobbet för att köra träningsskriptet på beräkningsresursen, konfigurerat med lämplig jobbmiljö
  • Visa utdata från träningsskriptet
  • Distribuera den nyligen tränade modellen som en slutpunkt
  • Anropa Azure ML-slutpunkten för slutsatsdragning

Förutsättningar

Kör anteckningsboken

  1. I det övre fältet väljer du den beräkningsinstans som du skapade under snabbstarten: Kom igång med Azure Machine Learning för att använda för att köra notebook-filen.

  2. Kontrollera att kerneln, som finns längst upp till höger, är Python 3.10 - SDK v2. Annars använder du listrutan för att välja den här kerneln.

Skärmbild: Ange kerneln.

Viktigt

Resten av den här självstudien innehåller celler i anteckningsboken för självstudien. Kopiera/klistra in dem i den nya anteckningsboken eller växla till anteckningsboken nu om du klonade den.

Om du vill köra en enda kodcell i en notebook-fil klickar du på kodcellen och trycker på Skift+Retur. Du kan också köra hela anteckningsboken genom att välja Kör alla från det översta verktygsfältet.

Ansluta till arbetsytan

Innan du dyker i koden måste du ansluta till din Azure ML-arbetsyta. Arbetsytan är resursen på den översta nivån i Azure Machine Learning, och är en central plats där du kan arbeta med alla artefakter du skapar när du använder Azure Machine Learning.

Vi använder DefaultAzureCredential för att få åtkomst till arbetsytan. DefaultAzureCredential används för att hantera de flesta Azure SDK-autentiseringsscenarier.

# Handle to the workspace
from azure.ai.ml import MLClient

# Authentication package
from azure.identity import DefaultAzureCredential

credential = DefaultAzureCredential()

I nästa cell anger du ditt prenumerations-ID, resursgruppsnamn och arbetsytenamn. Så här hittar du följande värden:

  1. I det övre högra Azure Machine Learning-studio verktygsfältet väljer du namnet på arbetsytan.
  2. Kopiera värdet för arbetsyta, resursgrupp och prenumerations-ID till koden.
  3. Du måste kopiera ett värde, stänga området och klistra in och sedan komma tillbaka för nästa.

Skärmbild: hitta autentiseringsuppgifterna för koden längst upp till höger i verktygsfältet.

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

Resultatet är en hanterare för arbetsytan som du ska använda för att hantera andra resurser och jobb.

Viktigt

Att skapa MLClient ansluter inte till arbetsytan. Klientinitieringen är lat. Den väntar första gången den behöver göra ett anrop (i notebook-filen nedan, som inträffar när beräkning skapas).

Skapa en beräkningsresurs för att köra jobbet

Du behöver en beräkningsresurs för att köra ett jobb. Det kan vara datorer med en eller flera noder med Linux eller Windows OS, eller en specifik beräkningsinfrastruktur som Spark.

Du etablerar ett Linux-beräkningskluster. Se den fullständiga listan över vm-storlekar och priser .

I det här exemplet behöver du bara ett grundläggande kluster, så du använder en Standard_DS3_v2 modell med 2 vCPU-kärnor, 7 GB RAM-minne och skapa en Azure ML Compute.

from azure.ai.ml.entities import AmlCompute

# Name assigned to the compute cluster
cpu_compute_target = "cpu-cluster"

try:
    # let's see if the compute target already exists
    cpu_cluster = ml_client.compute.get(cpu_compute_target)
    print(
        f"You already have a cluster named {cpu_compute_target}, we'll reuse it as is."
    )

except Exception:
    print("Creating a new cpu compute target...")

    # Let's create the Azure ML compute object with the intended parameters
    cpu_cluster = AmlCompute(
        name=cpu_compute_target,
        # Azure ML Compute is the on-demand VM service
        type="amlcompute",
        # VM Family
        size="STANDARD_DS3_V2",
        # Minimum running nodes when there is no job running
        min_instances=0,
        # Nodes in cluster
        max_instances=4,
        # How many seconds will the node running after the job termination
        idle_time_before_scale_down=180,
        # Dedicated or LowPriority. The latter is cheaper but there is a chance of job termination
        tier="Dedicated",
    )
    print(
        f"AMLCompute with name {cpu_cluster.name} will be created, with compute size {cpu_cluster.size}"
    )
    # Now, we pass the object to MLClient's create_or_update method
    cpu_cluster = ml_client.compute.begin_create_or_update(cpu_cluster)

Skapa en jobbmiljö

Om du vill köra ditt AzureML-jobb på din beräkningsresurs behöver du en miljö. En miljö visar de programkörningar och bibliotek som du vill installera på den beräkning där du ska träna. Det liknar din Python-miljö på den lokala datorn.

AzureML tillhandahåller många utvalda eller färdiga miljöer som är användbara för vanliga tränings- och slutsatsdragningsscenarier. Du kan också skapa egna anpassade miljöer med hjälp av en docker-avbildning eller en conda-konfiguration.

I det här exemplet skapar du en anpassad conda-miljö för dina jobb med hjälp av en conda yaml-fil.

Skapa först en katalog som filen ska lagras i.

import os

dependencies_dir = "./dependencies"
os.makedirs(dependencies_dir, exist_ok=True)

Skapa nu filen i katalogen beroenden. Cellen nedan använder IPython magic för att skriva filen till den katalog som du nyss skapade.

%%writefile {dependencies_dir}/conda.yml
name: model-env
channels:
  - conda-forge
dependencies:
  - python=3.8
  - numpy=1.21.2
  - pip=21.2.4
  - scikit-learn=0.24.2
  - scipy=1.7.1
  - pandas>=1.1,<1.2
  - pip:
    - inference-schema[numpy-support]==1.3.0
    - xlrd==2.0.1
    - mlflow== 1.26.1
    - azureml-mlflow==1.42.0
    - psutil>=5.8,<5.9
    - tqdm>=4.59,<4.60
    - ipykernel~=6.0
    - matplotlib

Specifikationen innehåller några vanliga paket som du använder i ditt jobb (numpy, pip).

Referera till den här yaml-filen för att skapa och registrera den här anpassade miljön på din arbetsyta:

from azure.ai.ml.entities import Environment

custom_env_name = "aml-scikit-learn"

pipeline_job_env = Environment(
    name=custom_env_name,
    description="Custom environment for Credit Card Defaults pipeline",
    tags={"scikit-learn": "0.24.2"},
    conda_file=os.path.join(dependencies_dir, "conda.yml"),
    image="mcr.microsoft.com/azureml/openmpi3.1.2-ubuntu18.04:latest",
)
pipeline_job_env = ml_client.environments.create_or_update(pipeline_job_env)

print(
    f"Environment with name {pipeline_job_env.name} is registered to workspace, the environment version is {pipeline_job_env.version}"
)

Vad är ett kommandojobb?

Du skapar ett Azure ML-kommandojobb för att träna en modell för kreditstandardförutsägelse. Kommandojobbet används för att köra ett träningsskript i en angiven miljö på en angiven beräkningsresurs. Du har redan skapat miljön och beräkningsresursen. Nu ska du skapa träningsskriptet.

Träningsskriptet hanterar förberedelse, träning och registrering av den tränade modellen. I den här självstudien skapar du ett Python-träningsskript.

Kommandojobb kan köras från CLI, Python SDK eller studiogränssnitt. I den här självstudien använder du Azure ML Python SDK v2 för att skapa och köra kommandojobbet.

När du har kört träningsjobbet distribuerar du modellen och använder den för att skapa en förutsägelse.

Skapa träningsskript

Vi börjar med att skapa träningsskriptet – main.py Python-fil.

Skapa först en källmapp för skriptet:

import os

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

Det här skriptet hanterar förbearbetningen av data och delar upp dem i test- och träningsdata. Den använder sedan dessa data för att träna en trädbaserad modell och returnera utdatamodellen.

MLFlow används för att logga parametrar och mått under pipelinekörningen.

Cellen nedan använder IPython magic för att skriva träningsskriptet till den katalog som du nyss skapade.

%%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_excel(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")
    mlflow.sklearn.log_model(
        sk_model=clf,
        registered_model_name=args.registered_model_name,
        artifact_path=args.registered_model_name,
    )

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

Som du ser i det här skriptet sparas modellfilen och registreras på arbetsytan när modellen har tränats. Nu kan du använda den registrerade modellen i slutsatsdragningsslutpunkter.

Konfigurera kommandot

Nu när du har ett skript som kan utföra önskade uppgifter använder du kommandot generell användning som kan köra kommandoradsåtgärder. Den här kommandoradsåtgärden kan vara att anropa systemkommandon direkt eller genom att köra ett skript.

Här skapar du indatavariabler för att ange indata, delningsförhållande, inlärningshastighet och registrerat modellnamn. Kommandoskriptet kommer att:

  • Använd den beräkning som skapades tidigare för att köra det här kommandot.
  • Använd den miljö som skapades tidigare – du kan använda notationen @latest för att ange den senaste versionen av miljön när kommandot körs.
  • Konfigurera vissa metadata som visningsnamn, experimentnamn osv. Ett experiment är en container för alla iterationer som du gör i ett visst projekt. Alla jobb som skickas under samma experimentnamn visas bredvid varandra i Azure ML Studio.
  • Konfigurera själva kommandoradsåtgärden – python main.py i det här fallet. Indata/utdata är tillgängliga i kommandot via notationen ${{ ... }} .
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://archive.ics.uci.edu/ml/machine-learning-databases/00350/default%20of%20credit%20card%20clients.xls",
        ),
        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="aml-scikit-learn@latest",
    compute="cpu-cluster",
    experiment_name="train_model_credit_default_prediction",
    display_name="credit_default_prediction",
)

Skicka jobbet

Nu är det dags att skicka jobbet som ska köras i AzureML. Den här gången ska du använda create_or_updateml_client.jobs.

ml_client.create_or_update(job)

Visa jobbutdata och vänta tills jobbet har slutförts

Visa jobbet i AzureML Studio genom att välja länken i utdata från den föregående cellen.

Utdata för det här jobbet ser ut så här i AzureML-studion. Utforska flikarna för olika detaljer som mått, utdata osv. När jobbet har slutförts registreras en modell på din arbetsyta som ett resultat av träningen.

Skärmbild som visar jobböversikten

Viktigt

Vänta tills jobbets status har slutförts innan du återgår till anteckningsboken för att fortsätta. Jobbet tar 2 till 3 minuter att köra. Det kan ta längre tid (upp till 10 minuter) om beräkningsklustret har skalats ned till noll noder och den anpassade miljön fortfarande skapas.

Distribuera modellen som en onlineslutpunkt

Distribuera nu din maskininlärningsmodell som en webbtjänst i Azure-molnet, en online endpoint.

För att distribuera en maskininlärningstjänst behöver du vanligtvis:

  • De modelltillgångar (fil, metadata) som du vill distribuera. Du har redan registrerat dessa tillgångar i ditt träningsjobb.
  • Kod som ska köras som en tjänst. Koden kör modellen på en angiven indatabegäran. Det här postskriptet tar emot data som skickas till en distribuerad webbtjänst och skickar dem till modellen och returnerar sedan modellens svar till klienten. Skriptet är specifikt för din modell. Inmatningsskriptet måste förstå de data som modellen förväntar sig och returnerar. Med en MLFlow-modell, som i den här självstudien, skapas det här skriptet automatiskt åt dig. Exempel på bedömningsskript finns här.

Skapa en ny onlineslutpunkt

Nu när du har en registrerad modell och ett slutsatsdragningsskript är det dags att skapa din onlineslutpunkt. Slutpunktsnamnet måste vara unikt i hela Azure-regionen. I den här självstudien skapar du ett unikt namn med hjälp av UUID.

import uuid

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

Anteckning

Förvänta dig att det tar cirka 6 till 8 minuter att skapa slutpunkten.

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

När du har skapat en slutpunkt kan du hämta den enligt nedan:

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

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

Distribuera modellen till slutpunkten

När slutpunkten har skapats distribuerar du modellen med postskriptet. Varje slutpunkt kan ha flera distributioner. Direkttrafik till dessa distributioner kan anges med hjälp av regler. Här skapar du en enda distribution som hanterar 100 % av den inkommande trafiken. Vi har valt ett färgnamn för distributionen, till exempel blå, grön, röd distribution, vilket är godtyckligt.

Du kan kontrollera sidan Modeller i Azure ML Studio för att identifiera den senaste versionen av din registrerade modell. Alternativt hämtar koden nedan det senaste versionsnumret som du kan använda.

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

Distribuera den senaste versionen av modellen.

Anteckning

Förvänta dig att den här distributionen tar cirka 6 till 8 minuter.

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


# create an online deployment.
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()

Testa med en exempelfråga

Nu när modellen har distribuerats till slutpunkten kan du köra slutsatsdragning med den.

Skapa en exempelbegärandefil som följer den design som förväntas i körningsmetoden i poängskriptet.

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

Rensa resurser

Om du inte ska använda slutpunkten tar du bort den för att sluta använda resursen. Kontrollera att inga andra distributioner använder en slutpunkt innan du tar bort den.

Anteckning

Förvänta dig att det här steget tar cirka 6 till 8 minuter.

ml_client.online_endpoints.begin_delete(name=online_endpoint_name)

Ta bort allt

Använd de här stegen för att ta bort din Azure Machine Learning-arbetsyta och alla beräkningsresurser.

Viktigt

De resurser som du har skapat kan användas som förutsättningar för andra Azure Machine Learning-självstudier och instruktionsartiklar.

Om du inte planerar att använda någon av de resurser som du skapade tar du bort dem så att du inte debiteras några avgifter:

  1. I Azure-portalen väljer du Resursgrupper längst till vänster.

  2. Välj resursgruppen som du skapade från listan.

  3. Välj Ta bort resursgrupp.

    Skärmbild av valen för att ta bort en resursgrupp i Azure Portal.

  4. Ange resursgruppsnamnet. Välj sedan Ta bort.

Nästa steg