Snabbstart: Kom igång med Azure Machine Learning

Artikel
10/16/2024

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

Den här självstudien är en introduktion till några av de mest använda funktionerna i Azure Machine Learning-tjänsten. I den skapar, registrerar och distribuerar du en modell. Den här självstudien hjälper dig att bekanta dig med huvudbegreppen i Azure Machine Learning och deras vanligaste användning.

Du lär dig hur du kör ett träningsjobb på en skalbar beräkningsresurs, distribuerar den och slutligen testar distributionen.

Du skapar ett träningsskript för att hantera förberedelse av data, träna och registrera en modell. När du har tränat modellen distribuerar du den som en slutpunkt och anropar sedan slutpunkten för slutsatsdragning.

De steg du utför är:

Konfigurera en referens till din Azure Machine Learning-arbetsyta
Skapa ditt träningsskript
Skapa en skalbar beräkningsresurs, ett beräkningskluster
Skapa och kör ett kommandojobb som kör träningsskriptet i beräkningsklustret, konfigurerat med lämplig jobbmiljö
Visa utdata från träningsskriptet
Distribuera den nyligen tränade modellen som en slutpunkt
Anropa Azure Machine Learning-slutpunkten för slutsatsdragning

Titta på den här videon för en översikt över stegen i den här snabbstarten.

Förutsättningar

Om du vill använda Azure Machine Learning behöver du en arbetsyta. Om du inte har någon slutför du Skapa resurser som du behöver för att komma igång med att skapa en arbetsyta och lära dig mer om hur du använder den.
Logga in i studion och välj din arbetsyta om den inte redan är öppen.
Öppna eller skapa en notebook-fil på din arbetsyta:
- Om du vill kopiera och klistra in kod i celler skapar du en ny notebook-fil.
- Eller öppna självstudier/komma igång-notebooks/quickstart.ipynb från avsnittet Exempel i studio. Välj sedan Klona för att lägga till anteckningsboken i dina filer. Information om hur du hittar exempelanteckningsböcker finns i Learn from sample notebooks (Lär dig från exempelanteckningsböcker).

Ange kerneln och öppna i Visual Studio Code (VS Code)

I det övre fältet ovanför den öppnade notebook-filen skapar du en beräkningsinstans om du inte redan har en.
Om beräkningsinstansen har stoppats väljer du Starta beräkning och väntar tills den körs.
Vänta tills beräkningsinstansen körs. Kontrollera sedan 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.

Om du inte ser den här kerneln kontrollerar du att beräkningsinstansen körs. I så fall väljer du knappen Uppdatera längst upp till höger i anteckningsboken.
Om du ser en banderoll som säger att du måste autentiseras väljer du Autentisera.
Du kan köra notebook-filen här eller öppna den i VS Code för en fullständig integrerad utvecklingsmiljö (IDE) med kraften i Azure Machine Learning-resurser. Välj Öppna i VS Code och välj sedan antingen webb- eller skrivbordsalternativet. När du startar på det här sättet kopplas VS Code till beräkningsinstansen, kerneln och arbetsytans filsystem.

Viktigt!

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

Skapa handtag till arbetsyta

Innan vi går in i koden behöver du ett sätt att referera till din 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.

Du skapar ml_client för en referens till arbetsytan. Du använder ml_client sedan för att hantera resurser och jobb.

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

I det övre högra Azure Machine Learning-studio verktygsfältet väljer du namnet på arbetsytan.
Kopiera värdet för arbetsyta, resursgrupp och prenumerations-ID till koden.
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 i det övre högra hörnet i verktygsfältet.

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

Kommentar

Att skapa MLClient ansluter inte till arbetsytan. Klientinitieringen är lat, den väntar första gången den behöver göra ett anrop (detta sker i nästa kodcell).

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

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, delar upp dem i test och tränar data. 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 parametrarna och måtten under pipelinekörningen.

Cellen nedan använder IPython-magi 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_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")
    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.

Du kan behöva välja Uppdatera för att se den nya mappen och skriptet i dina filer.

Skärmbild som visar uppdateringsikonen.

Konfigurera kommandot

Nu när du har ett skript som kan utföra önskade uppgifter och ett beräkningskluster för att köra skriptet använder du ett kommando för generell användning som kan köra kommandoradsåtgärder. Den här kommandoradsåtgärden kan anropa systemkommandon direkt eller 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 en miljö som definierar program- och körningsbibliotek som behövs för träningsskriptet. Azure Machine Learning tillhandahåller många utvalda eller färdiga miljöer som är användbara för vanliga tränings- och slutsatsdragningsscenarier. Du använder en av dessa miljöer här. I Självstudie: Träna en modell i Azure Machine Learning får du lära dig hur du skapar en anpassad miljö.
Konfigurera själva kommandoradsåtgärden – python main.py i det här fallet. Indata/utdata är tillgängliga i kommandot via notationen ${{ ... }} .
I det här exemplet får vi åtkomst till data från en fil på Internet.
Eftersom en beräkningsresurs inte har angetts körs skriptet på ett serverlöst beräkningskluster som skapas automatiskt.

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

Skicka jobbet

Nu är det dags att skicka jobbet som ska köras i Azure Machine Learning. Den här gången använder create_or_update du på ml_client.

ml_client.create_or_update(job)

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

Visa jobbet i Azure Machine Learning-studio genom att välja länken i utdata från föregående cell.

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

Skärmbild som visar översiktssidan för jobbet.

Viktigt!

Vänta tills jobbets status är klar innan du återgår till den här notebook-filen för att fortsätta. Det tar 2 till 3 minuter att köra jobbet. 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.

Om du vill distribuera en maskininlärningstjänst använder du den modell som du registrerade.

Skapa en ny onlineslutpunkt

Nu när du har en registrerad modell ä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]

Skapa slutpunkten:

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

Kommentar

Förvänta dig att det tar några minuter att skapa slutpunkten.

När slutpunkten har skapats 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 valde ett färgnamn för distributionen, till exempel blå, grön, röd distribution, vilket är godtyckligt.

Du kan kontrollera sidan Modeller på Azure Machine Learning-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)]
)
print(f'Latest model is version "{latest_model_version}" ')

Distribuera den senaste versionen av modellen.

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

Kommentar

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

När distributionen är klar är du redo att testa den.

Testa med en exempelfråga

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

Skapa en exempelbegärandefil efter 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.

Kommentar

Förvänta dig att den fullständiga borttagningen tar cirka 20 minuter.

ml_client.online_endpoints.begin_delete(name=online_endpoint_name)

Stoppa beräkningsinstans

Om du inte ska använda den nu stoppar du beräkningsinstansen:

Välj Beräkning i det vänstra navigeringsområdet i studion.
På de översta flikarna väljer du Beräkningsinstanser
Välj beräkningsinstansen i listan.
I det övre verktygsfältet väljer du Stoppa.

Ta bort alla resurser

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 har skapat tar du bort dem så att du inte debiteras några avgifter:

I Azure Portal i sökrutan anger du Resursgrupper och väljer dem i resultatet.
I listan väljer du den resursgrupp som du skapade.
På sidan Översikt väljer du Ta bort resursgrupp.
Ange resursgruppsnamnet. Välj sedan ta bort.

Nästa steg

Nu när du har en uppfattning om vad som ingår i träning och distribution av en modell kan du läsa mer om processen i de här självstudierna:

Självstudie	beskrivning
Ladda upp, komma åt och utforska dina data i Azure Machine Learning	Lagra stora data i molnet och hämta dem från notebook-filer och skript
Modellutveckling på en molnarbetsstation	Starta prototyper och utveckla maskininlärningsmodeller
Träna en modell i Azure Machine Learning	Gå in på information om hur du tränar en modell
Distribuera en modell som en onlineslutpunkt	Gå in på information om hur du distribuerar en modell
Skapa maskininlärningspipelines för produktion	Dela upp en fullständig maskininlärningsuppgift i ett arbetsflöde med flera steg.

Dela via

Snabbstart: Kom igång med Azure Machine Learning

Förutsättningar

Ange kerneln och öppna i Visual Studio Code (VS Code)

Skapa handtag till arbetsyta

Skapa träningsskript

Konfigurera kommandot

Skicka jobbet

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

Distribuera modellen som en onlineslutpunkt

Skapa en ny onlineslutpunkt

Distribuera modellen till slutpunkten

Testa med en exempelfråga

Rensa resurser

Stoppa beräkningsinstans

Ta bort alla resurser

Nästa steg

Feedback

Ytterligare resurser