Quickstart: Aan de slag met Azure Machine Learning

VAN TOEPASSING OP: Python SDK azure-ai-ml v2 (actueel)

Deze zelfstudie is een inleiding tot enkele van de meest gebruikte functies van de Azure Machine Learning-service. Hierin maakt, registreert en implementeert u een model. Deze zelfstudie helpt u vertrouwd te raken met de belangrijkste concepten van Azure Machine Learning en hun meest voorkomende gebruik.

U leert hoe u een trainingstaak uitvoert op een schaalbare rekenresource, deze vervolgens implementeert en ten slotte de implementatie test.

U maakt een trainingsscript voor het afhandelen van de gegevensvoorbereiding, het trainen en registreren van een model. Zodra u het model hebt getraind, implementeert u het als eindpunt en roept u het eindpunt aan voor deductie.

De stappen die u gaat uitvoeren zijn:

  • Een ingang instellen voor uw Azure Machine Learning-werkruimte
  • Uw trainingsscript maken
  • Een schaalbare rekenresource maken, een rekencluster
  • Een opdrachttaak maken en uitvoeren waarmee het trainingsscript op het rekencluster wordt uitgevoerd, geconfigureerd met de juiste taakomgeving
  • De uitvoer van uw trainingsscript weergeven
  • Het nieuw getrainde model implementeren als eindpunt
  • Het Azure Machine Learning-eindpunt aanroepen voor deductie

Bekijk deze video voor een overzicht van de stappen in deze quickstart.

Vereisten

  1. Als u Azure Machine Learning wilt gebruiken, hebt u eerst een werkruimte nodig. Als u er nog geen hebt, voltooit u Resources maken die u nodig hebt om aan de slag te gaan met het maken van een werkruimte en meer informatie over het gebruik ervan.

  2. Meld u aan bij de studio en selecteer uw werkruimte als deze nog niet is geopend.

  3. Open of maak een notitieblok in uw werkruimte:

    • Maak een nieuw notitieblok als u code wilt kopiëren/plakken in cellen.
    • Of open zelfstudies/get-started-notebooks/quickstart.ipynb in de sectie Samples van studio. Selecteer Vervolgens Klonen om het notitieblok toe te voegen aan uw bestanden. (Zie waar u voorbeelden kunt vinden.)

Uw kernel instellen

  1. Maak op de bovenste balk boven het geopende notitieblok een rekenproces als u er nog geen hebt.

    Screenshot shows how to create a compute instance.

  2. Als het rekenproces is gestopt, selecteert u Rekenproces starten en wacht u totdat het wordt uitgevoerd.

    Screenshot shows how to start compute if it is stopped.

  3. Zorg ervoor dat de kernel, die zich rechtsboven bevindt, is Python 3.10 - SDK v2. Als dit niet het probleem is, gebruikt u de vervolgkeuzelijst om deze kernel te selecteren.

    Screenshot shows how to set the kernel.

  4. Als u een banner ziet met de melding dat u moet worden geverifieerd, selecteert u Verifiëren.

Belangrijk

De rest van deze zelfstudie bevat cellen van het zelfstudienotitieblok. Kopieer of plak deze in uw nieuwe notitieblok of ga nu naar het notitieblok als u het hebt gekloond.

Greep maken voor werkruimte

Voordat we in de code duiken, hebt u een manier nodig om naar uw werkruimte te verwijzen. De werkruimte is de resource op het hoogste niveau voor Azure Machine Learning en biedt een gecentraliseerde werkplek met alle artefacten die u maakt in Azure Machine Learning.

U maakt ml_client een ingang voor de werkruimte. Vervolgens gebruikt ml_client u om resources en taken te beheren.

Voer in de volgende cel uw abonnements-id, resourcegroepnaam en werkruimtenaam in. Deze waarden zoeken:

  1. Selecteer in de rechterbovenhoek Azure Machine Learning-studio werkbalk de naam van uw werkruimte.
  2. Kopieer de waarde voor werkruimte, resourcegroep en abonnements-id in de code.
  3. U moet één waarde kopiëren, het gebied sluiten en plakken en vervolgens terugkomen voor de volgende waarde.

Screenshot: find the credentials for your code in the upper right of the toolbar.

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

Notitie

Het maken van MLClient maakt geen verbinding met de werkruimte. De initialisatie van de client is lui. Het wacht op de eerste keer dat de client een aanroep moet doen (dit gebeurt in de volgende codecel).

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

Trainingsscript maken

Laten we beginnen met het maken van het trainingsscript: het main.py Python-bestand.

Maak eerst een bronmap voor het script:

import os

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

Dit script verwerkt de voorverwerking van de gegevens, waarbij deze worden gesplitst in test- en traingegevens. Vervolgens worden deze gegevens gebruikt om een model op basis van een structuur te trainen en het uitvoermodel te retourneren.

MLFlow wordt gebruikt om de parameters en metrische gegevens te registreren tijdens de pijplijnuitvoering.

In de onderstaande cel wordt IPython magic gebruikt om het trainingsscript te schrijven naar de map die u zojuist hebt gemaakt.

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

Zoals u in dit script kunt zien, wordt het modelbestand opgeslagen en geregistreerd bij de werkruimte zodra het model is getraind. U kunt nu het geregistreerde model gebruiken in deductie-eindpunten.

Mogelijk moet u Vernieuwen selecteren om de nieuwe map en het nieuwe script in uw bestanden weer te geven.

Screenshot shows the refresh icon.

De opdracht configureren

Nu u een script hebt dat de gewenste taken kan uitvoeren en een rekencluster om het script uit te voeren, gebruikt u een opdracht voor algemeen gebruik waarmee opdrachtregelacties kunnen worden uitgevoerd. Met deze opdrachtregelactie kunt u systeemopdrachten rechtstreeks aanroepen of een script uitvoeren.

Hier maakt u invoervariabelen om de invoergegevens, de splitsingsverhouding, de leersnelheid en de geregistreerde modelnaam op te geven. Het opdrachtscript doet het volgende:

  • Gebruik een omgeving die software- en runtimebibliotheken definieert die nodig zijn voor het trainingsscript. Azure Machine Learning biedt veel gecureerde of kant-en-klare omgevingen, die nuttig zijn voor algemene trainings- en deductiescenario's. U gebruikt hier een van deze omgevingen. In de zelfstudie: Een model trainen in Azure Machine Learning leert u hoe u een aangepaste omgeving maakt.
  • Configureer de opdrachtregelactie zelf, python main.py in dit geval. De invoer/uitvoer is toegankelijk in de opdracht via de ${{ ... }} notatie.
  • In dit voorbeeld hebben we toegang tot de gegevens uit een bestand op internet.
  • Omdat er geen rekenresource is opgegeven, wordt het script uitgevoerd op een serverloos rekencluster dat automatisch wordt gemaakt.
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-sklearn-1.0-ubuntu20.04-py38-cpu@latest",
    display_name="credit_default_prediction",
)

De taak verzenden

Het is nu tijd om de taak in te dienen om te worden uitgevoerd in Azure Machine Learning. Deze keer gebruikt create_or_update u op ml_client.

ml_client.create_or_update(job)

Taakuitvoer weergeven en wachten op voltooiing van de taak

Bekijk de taak in Azure Machine Learning-studio door de koppeling te selecteren in de uitvoer van de vorige cel.

De uitvoer van deze taak ziet er als volgt uit in de Azure Machine Learning-studio. Verken de tabbladen voor verschillende details, zoals metrische gegevens, uitvoer, enzovoort. Zodra de taak is voltooid, wordt er een model in uw werkruimte geregistreerd als gevolg van training.

Screenshot shows the overview page for the job.

Belangrijk

Wacht totdat de status van de taak is voltooid voordat u teruggaat naar dit notitieblok om door te gaan. Het uitvoeren van de taak duurt 2 tot 3 minuten. Het kan langer duren (maximaal 10 minuten) als het rekencluster omlaag is geschaald naar nul knooppunten en er nog steeds aangepaste omgeving wordt gebouwd.

Het model implementeren als een online-eindpunt

Implementeer nu uw machine learning-model als een webservice in de Azure-cloud, een online endpoint.

Als u een machine learning-service wilt implementeren, gebruikt u het model dat u hebt geregistreerd.

Een nieuw online-eindpunt maken

Nu u een geregistreerd model hebt, is het tijd om uw online-eindpunt te maken. De eindpuntnaam moet uniek zijn in de hele Azure-regio. Voor deze zelfstudie maakt u een unieke naam met behulp van UUID.

import uuid

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

Maak het eindpunt:

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

Notitie

Verwacht dat het maken van het eindpunt enkele minuten duurt.

Zodra het eindpunt is gemaakt, kunt u het ophalen zoals hieronder:

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

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

Het model implementeren op het eindpunt

Nadat het eindpunt is gemaakt, implementeert u het model met het invoerscript. Elk eindpunt kan meerdere implementaties hebben. Verkeer naar deze implementaties kan worden opgegeven met behulp van regels. Hier maakt u één implementatie die 100% van het binnenkomende verkeer verwerkt. We hebben een kleurnaam gekozen voor de implementatie, bijvoorbeeld blauwe, groene, rode implementaties, die willekeurig zijn.

U kunt de pagina Modellen op Azure Machine Learning-studio controleren om de nieuwste versie van uw geregistreerde model te identificeren. U kunt ook met de onderstaande code het meest recente versienummer ophalen dat u kunt gebruiken.

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

Implementeer de nieuwste versie van het model.

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

Notitie

Verwacht dat deze implementatie ongeveer 6 tot 8 minuten duurt.

Wanneer de implementatie is voltooid, kunt u deze testen.

Testen met een voorbeeldquery

Zodra het model is geïmplementeerd op het eindpunt, kunt u er deductie mee uitvoeren.

Maak een voorbeeldaanvraagbestand volgens het ontwerp dat wordt verwacht in de uitvoeringsmethode in het scorescript.

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

Resources opschonen

Als u het eindpunt niet gaat gebruiken, verwijdert u het om te stoppen met het gebruik van de resource. Zorg ervoor dat er geen andere implementaties een eindpunt gebruiken voordat u het verwijdert.

Notitie

Verwacht dat de volledige verwijdering ongeveer 20 minuten duurt.

ml_client.online_endpoints.begin_delete(name=online_endpoint_name)

Rekenproces stoppen

Als u deze nu niet gaat gebruiken, stopt u het rekenproces:

  1. Selecteer Compute in het linkernavigatiegebied in de studio.
  2. Selecteer op de bovenste tabbladen Rekeninstanties
  3. Selecteer het rekenproces in de lijst.
  4. Selecteer Stoppen op de bovenste werkbalk.

Alle resources verwijderen

Belangrijk

De resources die u hebt gemaakt, kunnen worden gebruikt als de vereisten voor andere Azure Machine Learning-zelfstudies en artikelen met procedures.

Als u niet van plan bent om een van de resources te gebruiken die u hebt gemaakt, verwijdert u deze zodat er geen kosten in rekening worden gebracht:

  1. Selecteer Resourcegroepen links in Azure Portal.

  2. Selecteer de resourcegroep die u hebt gemaakt uit de lijst.

  3. Selecteer Resourcegroep verwijderen.

    Screenshot of the selections to delete a resource group in the Azure portal.

  4. Voer de naam van de resourcegroup in. Selecteer daarna Verwijderen.

Volgende stappen

Nu u een idee hebt van wat betrokken is bij het trainen en implementeren van een model, leert u meer over het proces in deze zelfstudies:

Zelfstudie Beschrijving
Uw gegevens uploaden, openen en verkennen in Azure Machine Learning Grote gegevens opslaan in de cloud en deze ophalen uit notebooks en scripts
Modelontwikkeling op een cloudwerkstation Beginnen met het maken van prototypen en het ontwikkelen van machine learning-modellen
Een model trainen in Azure Machine Learning Duik in de details van het trainen van een model
Een model implementeren als een online-eindpunt Duik in de details van het implementeren van een model
Machine Learning-pijplijnen voor productie maken Splits een volledige machine learning-taak in een werkstroom met meerdere stappen.