Zelfstudie: Azure Machine Learning op een dag

  • Artikel
  • 13 minuten om te lezen

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

Meer informatie over hoe een data scientist Azure Machine Learning gebruikt om een model te trainen en vervolgens het model te gebruiken voor voorspelling. Deze zelfstudie helpt u vertrouwd te raken met de kernconcepten van Azure Machine Learning en hun meest voorkomende gebruik.

U leert hoe u een opdrachttaak verzendt om uw trainingsscript uit te voeren op een opgegeven rekenresource, geconfigureerd met de taakomgeving die nodig is om het script uit te voeren.

Het trainingsscript verwerkt de gegevensvoorbereiding, traint en registreert vervolgens een model. Zodra u het model hebt, implementeert u het als een eindpunt en roept u het eindpunt aan voor deductie.

De stappen die u moet uitvoeren zijn:

  • Verbinding maken met uw Azure Machine Learning-werkruimte
  • Uw rekenresource en taakomgeving maken
  • Uw trainingsscript maken
  • Uw opdrachttaak maken en uitvoeren om het trainingsscript uit te voeren op de rekenresource, geconfigureerd met de juiste taakomgeving
  • De uitvoer van uw trainingsscript weergeven
  • Het zojuist getrainde model implementeren als eindpunt
  • Het Azure Machine Learning-eindpunt aanroepen voor deductie

Vereisten

Uw notebook uitvoeren

  1. Selecteer in de bovenste balk het rekenproces dat u hebt gemaakt tijdens de Quickstart: Aan de slag met Azure Machine Learning om te gebruiken voor het uitvoeren van het notebook.

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

Schermopname: Stel de kernel in.

Belangrijk

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

Als u één codecel in een notebook wilt uitvoeren, klikt u op de codecel en drukt u op Shift+Enter. U kunt ook de hele notebook uitvoeren door Alle uitvoeren te kiezen op de bovenste werkbalk.

Verbinding maken met de werkruimte

Voordat u in de code duikt, moet u verbinding maken met uw Azure Machine Learning-werkruimte. 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.

We gebruiken DefaultAzureCredential om toegang te krijgen tot de werkruimte. DefaultAzureCredential wordt gebruikt voor het afhandelen van de meeste Azure SDK-verificatiescenario's.

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

# Authentication package
from azure.identity import DefaultAzureCredential

credential = DefaultAzureCredential()

Voer in de volgende cel uw abonnements-id, de naam van de resourcegroep en de naam van de werkruimte 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.

Schermopname: zoek de referenties voor uw code in de rechterbovenhoek van de werkbalk. 

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

Het resultaat is een handler voor de werkruimte die u gebruikt voor het beheren van andere resources en taken.

Belangrijk

Als u MLClient maakt, wordt er geen verbinding gemaakt met de werkruimte. De initialisatie van de client is lui. Er wordt gewacht op de eerste keer dat er een aanroep moet worden uitgevoerd (in het onderstaande notebook gebeurt dat tijdens het maken van de rekenkracht).

Een rekenresource maken om uw taak uit te voeren

U hebt een rekenresource nodig om een taak uit te voeren. Dit kunnen machines met één of meerdere knooppunten zijn met linux- of Windows-besturingssysteem, of een specifieke rekeninfrastructuur zoals Spark.

U gaat een Linux-rekencluster inrichten. Zie de volledige lijst met VM-grootten en prijzen .

Voor dit voorbeeld hebt u alleen een basiscluster nodig, dus gebruikt u een Standard_DS3_v2-model met 2 vCPU-kernen, 7 GB RAM en maakt u een Azure Machine Learning 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)

Een taakomgeving maken

Als u uw Azure Machine Learning-taak wilt uitvoeren op uw rekenresource, hebt u een omgeving nodig. Een omgeving bevat de softwareruntime en bibliotheken die u wilt installeren op de berekening waar u gaat trainen. Het is vergelijkbaar met uw Python-omgeving op uw lokale computer.

Azure Machine Learning biedt veel gecureerde of kant-en-klare omgevingen, die handig zijn voor algemene trainings- en deductiescenario's. U kunt ook uw eigen aangepaste omgevingen maken met behulp van een Docker-installatiekopieën of een Conda-configuratie.

In dit voorbeeld maakt u een aangepaste Conda-omgeving voor uw taken met behulp van een Conda Yaml-bestand.

Maak eerst een map om het bestand in op te slaan.

import os

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

Maak nu het bestand in de map met afhankelijkheden. In de onderstaande cel wordt IPython Magic gebruikt om het bestand te schrijven naar de map die u zojuist hebt gemaakt.

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

De specificatie bevat enkele gebruikelijke pakketten, die u in uw taak gaat gebruiken (numpy, pip).

Raadpleeg dit YAML-bestand om deze aangepaste omgeving in uw werkruimte te maken en te registreren:

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

Wat is een opdrachttaak?

U maakt een Azure Machine Learning-opdrachttaak om een model te trainen voor standaardvoorspelling van tegoed. De opdrachttaak wordt gebruikt om een trainingsscript uit te voeren in een opgegeven omgeving op een opgegeven rekenresource. U hebt de omgeving en de rekenresource al gemaakt. Vervolgens maakt u het trainingsscript.

Het trainingsscript verwerkt de gegevensvoorbereiding, training en registratie van het getrainde model. In deze zelfstudie maakt u een Python-trainingsscript.

Opdrachttaken kunnen worden uitgevoerd vanuit cli, Python SDK of studio-interface. In deze zelfstudie gebruikt u de Azure Machine Learning Python SDK v2 om de opdrachttaak te maken en uit te voeren.

Nadat u de trainingstaak hebt uitgevoerd, implementeert u het model en gebruikt u het om een voorspelling te produceren.

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 en splitst deze op in test- en trainingsgegevens. 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 gebruikgemaakt van IPython-magie 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_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()

Zoals u in dit script kunt zien, wordt het modelbestand na het trainen van het model opgeslagen en geregistreerd in de werkruimte. U kunt nu het geregistreerde model gebruiken in eindpunten voor deductie.

De opdracht configureren

Nu u een script hebt waarmee de gewenste taken kunnen worden uitgevoerd, gebruikt u de opdracht voor algemeen gebruik waarmee opdrachtregelacties kunnen worden uitgevoerd. Deze opdrachtregelactie kan systeemopdrachten rechtstreeks aanroepen of door een script uit te voeren.

Hier maakt u invoervariabelen om de invoergegevens, de split ratio, de leersnelheid en de naam van het geregistreerde model op te geven. Het opdrachtscript doet het volgende:

  • Gebruik de rekenkracht die u eerder hebt gemaakt om deze opdracht uit te voeren.
  • Gebruik de omgeving die u eerder hebt gemaakt. U kunt de @latest notatie gebruiken om de nieuwste versie van de omgeving aan te geven wanneer de opdracht wordt uitgevoerd.
  • Configureer bepaalde metagegevens, zoals de weergavenaam, de naam van het experiment, enzovoort. Een experiment is een container voor alle iteraties die u op een bepaald project uitvoert. Alle taken die onder dezelfde experimentnaam zijn ingediend, worden naast elkaar weergegeven in Azure Machine Learning-studio.
  • Configureer in dit geval de opdrachtregelactie zelf python main.py . De invoer/uitvoer is toegankelijk in de opdracht via de ${{ ... }} notatie.
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",
)

De taak verzenden

Het is nu tijd om de taak te verzenden en uit te voeren in Azure Machine Learning. Deze keer gebruikt create_or_update u op ml_client.jobs.

ml_client.create_or_update(job)

Taakuitvoer weergeven en wachten tot de taak is voltooid

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

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 de training.

Schermopname van het taakoverzicht

Belangrijk

Wacht totdat de status van de taak is voltooid voordat u terugkeert 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 een 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.

Voor het implementeren van een machine learning-service hebt u meestal het volgende nodig:

  • De modelassets (bestand, metagegevens) die u wilt implementeren. U hebt deze assets al geregistreerd in uw trainingstaak.
  • Code die moet worden uitgevoerd als een service. Met de code wordt het model uitgevoerd op een bepaalde invoeraanvraag. Dit invoerscript ontvangt gegevens die zijn verzonden naar een geïmplementeerde webservice en geeft deze door aan het model en retourneert vervolgens het antwoord van het model naar de client. Het script is specifiek voor uw model. Het invoerscript moet de gegevens begrijpen die het model verwacht en retourneert. Met een MLFlow-model, zoals in deze zelfstudie, wordt dit script automatisch voor u gemaakt. Voorbeelden van scorescripts vindt u hier.

Een nieuw online-eindpunt maken

Nu u een geregistreerd model en een deductiescript hebt, is het tijd om uw online-eindpunt te maken. De naam van het eindpunt 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]

Notitie

Het maken van het eindpunt duurt ongeveer 6 tot 8 minuten.

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

Nadat u een eindpunt hebt gemaakt, kunt u dit 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

Zodra het eindpunt is gemaakt, implementeert u het model met het invoerscript. Elk eindpunt kan meerdere implementaties hebben. Verkeer omleiden 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 of rode implementaties, wat willekeurig is.

U kunt de pagina Modellen op de Azure Machine Learning-studio controleren om de nieuwste versie van uw geregistreerde model te identificeren. Met de onderstaande code wordt ook het meest recente versienummer opgehaald 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)]
)

Implementeer de nieuwste versie van het model.

Notitie

Verwacht dat deze implementatie ongeveer 6 tot 8 minuten duurt.

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

Testen met een voorbeeldquery

Nu het model is geïmplementeerd op het eindpunt, kunt u hiermee deductie uitvoeren.

Maak een voorbeeldaanvraagbestand volgens het ontwerp dat wordt verwacht in de run-methode 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 de resource niet meer te gebruiken. Zorg ervoor dat er geen andere implementaties gebruikmaken van een eindpunt voordat u het verwijdert.

Notitie

Deze stap duurt ongeveer 6 tot 8 minuten.

ml_client.online_endpoints.begin_delete(name=online_endpoint_name)

Alles verwijderen

Gebruik deze stappen om uw Azure Machine Learning-werkruimte en alle rekenresources te 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.

    Schermopname van de selecties voor het verwijderen van een resourcegroep in de Azure-portal.

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

Volgende stappen