Zelfstudie: Een model trainen in Azure Machine Learning

Artikel
11/15/2023

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

Meer informatie over hoe een data scientist Azure Machine Learning gebruikt om een model te trainen. In dit voorbeeld gebruiken we de bijbehorende gegevensset met creditcards om te laten zien hoe u Azure Machine Learning kunt gebruiken voor een classificatieprobleem. Het doel is om te voorspellen of een klant een hoge kans heeft op een creditcardbetaling.

Het trainingsscript verwerkt de gegevensvoorbereiding, traint en registreert vervolgens een model. In deze zelfstudie wordt u stapsgewijs begeleid bij het verzenden van een cloudtrainingstaak (opdrachttaak). Als u meer wilt weten over het laden van uw gegevens in Azure, raadpleegt u zelfstudie: Uw gegevens uploaden, openen en verkennen in Azure Machine Learning. Dit zijn de stappen:

Een ingang krijgen voor uw Azure Machine Learning-werkruimte
Uw rekenresource en taakomgeving maken
Uw trainingsscript maken
Maak en voer uw opdrachttaak uit om het trainingsscript op de rekenresource uit te voeren, geconfigureerd met de juiste taakomgeving en de gegevensbron
De uitvoer van uw trainingsscript weergeven
Het nieuw getrainde model implementeren als eindpunt
Het Azure Machine Learning-eindpunt aanroepen voor deductie

In deze video ziet u hoe u aan de slag gaat in Azure Machine Learning-studio, zodat u de stappen in de zelfstudie kunt volgen. In de video ziet u hoe u een notebook maakt, een rekenproces maakt en het notebook kloont. De stappen worden ook beschreven in de volgende secties.

Vereisten

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.
Meld u aan bij de studio en selecteer uw werkruimte als deze nog niet is geopend.
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/train-model.ipynb vanuit 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

Maak op de bovenste balk boven het geopende notitieblok een rekenproces als u er nog geen hebt.
Als het rekenproces is gestopt, selecteert u Rekenproces starten en wacht u totdat het wordt uitgevoerd.
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.
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.

Een opdrachttaak gebruiken om een model te trainen in Azure Machine Learning

Als u een model wilt trainen, moet u een taak indienen. Het type taak dat u in deze zelfstudie verzendt, is een opdrachttaak. Azure Machine Learning biedt verschillende soorten taken voor het trainen van modellen. Gebruikers kunnen hun trainingsmethode selecteren op basis van de complexiteit van het model, de gegevensgrootte en de vereisten voor trainingssnelheid. In deze zelfstudie leert u hoe u een opdrachttaak verzendt om een trainingsscript uit te voeren.

Een opdrachttaak is een functie waarmee u een aangepast trainingsscript kunt verzenden om uw model te trainen. Dit kan ook worden gedefinieerd als een aangepaste trainingstaak. Een opdrachttaak in Azure Machine Learning is een type taak waarmee een script of opdracht in een opgegeven omgeving wordt uitgevoerd. U kunt opdrachttaken gebruiken om modellen te trainen, gegevens te verwerken of andere aangepaste code die u wilt uitvoeren in de cloud.

In deze zelfstudie richten we ons op het gebruik van een opdrachttaak om een aangepaste trainingstaak te maken die we gaan gebruiken om een model te trainen. Voor elke aangepaste trainingstaak zijn de onderstaande items vereist:

omgeving
gegevens
opdrachttaak
trainingsscript

In deze zelfstudie geven we al deze items voor ons voorbeeld op: het maken van een classificatie om klanten te voorspellen die een hoge kans hebben op standaardinstellingen voor creditcardbetalingen.

Greep maken voor werkruimte

Voordat we in de code duiken, hebt u een manier nodig om naar uw werkruimte te verwijzen. 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:

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

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)

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 nuttig zijn voor algemene trainings- en deductiescenario's.

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

Maak eerst een map waarin het bestand moet worden opgeslagen.

import os

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

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

%%writefile {dependencies_dir}/conda.yaml
name: model-env
channels:
  - conda-forge
dependencies:
  - python=3.8
  - numpy=1.21.2
  - pip=21.2.4
  - scikit-learn=1.0.2
  - scipy=1.7.1
  - pandas>=1.1,<1.2
  - pip:
    - inference-schema[numpy-support]==1.3.0
    - mlflow==2.8.0
    - mlflow-skinny==2.8.0
    - azureml-mlflow==1.51.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 (numpy, pip) gaat gebruiken.

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"

custom_job_env = Environment(
    name=custom_env_name,
    description="Custom environment for Credit Card Defaults job",
    tags={"scikit-learn": "1.0.2"},
    conda_file=os.path.join(dependencies_dir, "conda.yaml"),
    image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest",
)
custom_job_env = ml_client.environments.create_or_update(custom_job_env)

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

Een trainingstaak configureren met behulp van de opdrachtfunctie

U maakt een Azure Machine Learning-opdrachttaak om een model te trainen voor standaardvoorspelling voor tegoed. Met de opdrachttaak wordt een trainingsscript uitgevoerd in een opgegeven omgeving op een opgegeven rekenresource. U hebt de omgeving en het rekencluster al gemaakt. Vervolgens maakt u het trainingsscript. In ons specifieke geval trainen we onze gegevensset om een classificatie te produceren met behulp van het GradientBoostingClassifier model.

Het trainingsscript verwerkt de gegevensvoorbereiding, training en registratie van het getrainde model. De methode train_test_split verwerkt het splitsen van de gegevensset in test- en trainingsgegevens. 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.

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 tijdens onze taak te registreren. Met het MLFlow-pakket kunt u metrische gegevens en resultaten bijhouden voor elk azure-model. We gebruiken MLFlow om eerst het beste model voor onze gegevens op te halen. Vervolgens bekijken we de metrische gegevens van het model in Azure Studio.

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

    #Split train and test datasets
    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()

Zodra het model is getraind, wordt het modelbestand in dit script opgeslagen en geregistreerd in de werkruimte. Als u uw model registreert, kunt u uw modellen opslaan en versieren in de Azure-cloud, in uw werkruimte. Zodra u een model hebt geregistreerd, kunt u op één plaats alle andere geregistreerde modellen vinden in Azure Studio, het modelregister genoemd. Het modelregister helpt u bij het organiseren en bijhouden van uw getrainde modellen.

De opdracht configureren

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

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

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 de opdrachtregelactie zelf, python main.py in dit geval. De invoer/uitvoer is toegankelijk in de opdracht via de ${{ ... }} notatie.
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="aml-scikit-learn@latest",
    display_name="credit_default_prediction",
)

De taak verzenden

Het is nu tijd om de taak in te dienen voor uitvoering in Azure Machine Learning-studio. Deze keer gebruikt create_or_update u op ml_client. ml_client is een clientklasse waarmee u verbinding kunt maken met uw Azure-abonnement met behulp van Python en kunt communiceren met Azure Machine Learning-services. ml_client hiermee kunt u uw taken verzenden met behulp van Python.

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.

Wanneer u de cel uitvoert, toont de uitvoer van het notebook een koppeling naar de detailpagina van de taak in Azure Studio. U kunt ook Taken selecteren in het linkernavigatiemenu. Een taak is een groepering van veel uitvoeringen vanuit een opgegeven script of stukje code. Informatie voor de uitvoering wordt onder die taak opgeslagen. De detailpagina geeft een overzicht van de taak, de tijd die nodig was om de taak uit te voeren, wanneer deze is gemaakt, enzovoort. De pagina bevat ook tabbladen naar andere informatie over de taak, zoals metrische gegevens, Uitvoer en logboeken en code. Hieronder vindt u de tabbladen die beschikbaar zijn op de detailpagina van de taak:

Overzicht: De sectie Overzicht bevat basisinformatie over de taak, met inbegrip van de status, begin- en eindtijden en het type taak dat is uitgevoerd
Invoer: De invoersectie bevat de gegevens en code die zijn gebruikt als invoer voor de taak. Deze sectie kan gegevenssets, scripts, omgevingsconfiguraties en andere resources bevatten die tijdens de training zijn gebruikt.
Uitvoer en logboeken: het tabblad Uitvoer en logboeken bevat logboeken die zijn gegenereerd terwijl de taak werd uitgevoerd. Dit tabblad helpt bij het oplossen van problemen als er iets misgaat met het maken van uw trainingsscript of model.
Metrische gegevens: op het tabblad Metrische gegevens worden belangrijke prestatiegegevens van uw model weergegeven, zoals trainingsscore, f1-score en precisiescore.

Resources opschonen

Als u van plan bent om nu door te gaan naar andere zelfstudies, gaat u verder met volgende stappen.

Rekenproces stoppen

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

Selecteer Compute in het linkernavigatiegebied in de studio.
Selecteer op de bovenste tabbladen Rekeninstanties
Selecteer het rekenproces in de lijst.
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:

Selecteer Resourcegroepen links in Azure Portal.
Selecteer de resourcegroep die u hebt gemaakt uit de lijst.
Selecteer Resourcegroep verwijderen.
Voer de naam van de resourcegroup in. Selecteer daarna Verwijderen.

Volgende stappen

Meer informatie over het implementeren van een model

Een model implementeren.

In deze zelfstudie is een onlinegegevensbestand gebruikt. Zie zelfstudie: Uw gegevens uploaden, openen en verkennen in Azure Machine Learning voor meer informatie over andere manieren om toegang te krijgen tot gegevens.

Als u meer wilt weten over verschillende manieren om modellen te trainen in Azure Machine Learning, raadpleegt u Wat is geautomatiseerde machine learning (AutoML)?. Geautomatiseerde ML is een aanvullend hulpprogramma om de hoeveelheid tijd te verminderen die een data scientist besteedt aan het vinden van een model dat het beste werkt met hun gegevens.

Als u meer voorbeelden wilt zien die vergelijkbaar zijn met deze zelfstudie, raadpleegt u de sectie Voorbeelden van studio. Dezelfde voorbeelden zijn beschikbaar op onze GitHub-voorbeeldenpagina. De voorbeelden zijn volledige Python Notebooks waarmee u code kunt uitvoeren en leert hoe u een model traint. U kunt bestaande scripts wijzigen en uitvoeren vanuit de voorbeelden, met scenario's zoals classificatie, verwerking van natuurlijke taal en anomaliedetectie.

Zelfstudie: Een model trainen in Azure Machine Learning

Vereisten

Uw kernel instellen

Een opdrachttaak gebruiken om een model te trainen in Azure Machine Learning

Greep maken voor werkruimte

Een taakomgeving maken

Een trainingstaak configureren met behulp van de opdrachtfunctie

Trainingsscript maken

De opdracht configureren

De taak verzenden

Taakuitvoer weergeven en wachten op voltooiing van de taak

Resources opschonen

Rekenproces stoppen

Alle resources verwijderen

Volgende stappen

Aanvullende resources