Sdílet prostřednictvím

Rychlý start: Začínáme se službou Azure Machine Learning

  • Článek

PLATÍ PRO: Python SDK azure-ai-ml v2 (aktuální)

Tento kurz je úvodem k některým z nejčastěji používaných funkcí služby Azure Machine Learning. V něm vytvoříte, zaregistrujete a nasadíte model. Tento kurz vám pomůže seznámit se se základními koncepty služby Azure Machine Learning a jejich nejběžnějším využitím.

Naučíte se spustit úlohu trénování u škálovatelného výpočetního prostředku, pak ji nasadit a nakonec otestovat nasazení.

Vytvoříte trénovací skript pro zpracování přípravy, trénování a registrace modelu. Jakmile model vytrénujete, nasadíte ho jako koncový bod a pak zavoláte koncový bod pro odvozování.

Kroky, které provedete, jsou:

  • Nastavení popisovače pro pracovní prostor Služby Azure Machine Learning
  • Vytvoření trénovacího skriptu
  • Vytvoření škálovatelného výpočetního prostředku, výpočetního clusteru
  • Vytvořte a spusťte úlohu příkazu, která spustí trénovací skript ve výpočetním clusteru nakonfigurované s odpovídajícím prostředím úlohy.
  • Zobrazení výstupu trénovacího skriptu
  • Nasazení nově natrénovaného modelu jako koncového bodu
  • Volání koncového bodu služby Azure Machine Learning pro odvozování

V tomto videu najdete přehled kroků v tomto rychlém startu.

Požadavky

  1. Pokud chcete používat Azure Machine Learning, potřebujete pracovní prostor. Pokud ho nemáte, dokončete vytváření prostředků, které potřebujete, abyste mohli začít vytvářet pracovní prostor a získat další informace o jeho používání.

  2. Přihlaste se do studia a vyberte pracovní prostor, pokud ještě není otevřený.

  3. Otevřete nebo vytvořte poznámkový blok v pracovním prostoru:

    • Pokud chcete zkopírovat a vložit kód do buněk, vytvořte nový poznámkový blok.
    • Nebo otevřete kurzy/get-started-notebooks/quickstart.ipynb v části Ukázky studia. Potom vyberte Clone (Klonovat ) a přidejte poznámkový blok do složky Soubory. Ukázkové poznámkové bloky najdete v tématu Výuka z ukázkových poznámkových bloků.

Nastavení jádra a otevření v editoru Visual Studio Code (VS Code)

  1. Na horním panelu nad otevřeným poznámkovým blokem vytvořte výpočetní instanci, pokud ji ještě nemáte.

    Snímek obrazovky ukazuje, jak vytvořit výpočetní instanci.

  2. Pokud je výpočetní instance zastavená, vyberte Spustit výpočetní prostředky a počkejte, až bude spuštěný.

    Snímek obrazovky ukazuje, jak spustit zastavenou výpočetní instanci.

  3. Počkejte na spuštění výpočetní instance. Pak se ujistěte, že jádro, které se nachází v pravém horním rohu, je Python 3.10 - SDK v2. Pokud ne, vyberte toto jádro pomocí rozevíracího seznamu.

    Snímek obrazovky ukazuje, jak nastavit jádro.

    Pokud toto jádro nevidíte, ověřte, že je vaše výpočetní instance spuštěná. Pokud ano, vyberte tlačítko Aktualizovat v pravém horním rohu poznámkového bloku.

  4. Pokud se zobrazí banner s informací, že potřebujete být ověřeni, vyberte Ověřit.

  5. Poznámkový blok můžete spustit tady nebo ho otevřít ve VS Code pro úplné integrované vývojové prostředí (IDE) s využitím prostředků Azure Machine Learning. Vyberte Otevřít v editoru VS Code a pak vyberte možnost Web nebo Desktop. Při spuštění tímto způsobem se VS Code připojí k vaší výpočetní instanci, jádru a systému souborů pracovního prostoru.

    Snímek obrazovky ukazuje, jak otevřít poznámkový blok ve VS Code.

Důležité

Zbytek tohoto kurzu obsahuje buňky poznámkového bloku kurzu. Pokud jste ho naklonovali, zkopírujte je a vložte do nového poznámkového bloku nebo ho teď přepněte do poznámkového bloku.

Vytvoření popisovače do pracovního prostoru

Než se pustíme do kódu, potřebujete způsob, jak odkazovat na váš pracovní prostor. Pracovní prostor je prostředek nejvyšší úrovně pro Azure Machine Learning, který nabízí centralizované místo, kde můžete pracovat se všemi artefakty, které vytvoříte při použití služby Azure Machine Learning.

Vytvoříte ml_client pro popisovač pracovního prostoru. Pak použijete ml_client ke správě prostředků a úloh.

Do další buňky zadejte ID předplatného, název skupiny prostředků a název pracovního prostoru. Tyto hodnoty najdete takto:

  1. V pravém horním studio Azure Machine Learning panelu nástrojů vyberte název pracovního prostoru.
  2. Zkopírujte hodnotu pro pracovní prostor, skupinu prostředků a ID předplatného do kódu.
  3. Potřebujete zkopírovat jednu hodnotu, zavřít oblast a vložit a pak se vrátit k další hodnotě.

Snímek obrazovky: Najděte přihlašovací údaje pro kód v pravém horním rohu panelu nástrojů. 

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

Poznámka:

Vytvoření MLClient se nepřipojí k pracovnímu prostoru. Inicializace klienta je opožděná, bude čekat poprvé, až bude muset provést volání (k tomu dojde v další buňce kódu).

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

Vytvoření trénovacího skriptu

Začněme vytvořením trénovacího skriptu – main.py souboru Pythonu.

Nejprve vytvořte zdrojovou složku pro skript:

import os

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

Tento skript zpracovává předběžné zpracování dat a rozdělí je na testovací a trénovací data. Potom tato data spotřebuje k trénování modelu založeného na stromové struktuře a vrácení výstupního modelu.

MLFlow se používá k protokolování parametrů a metrik během spuštění kanálu.

Následující buňka používá magii IPython k napsání trénovacího skriptu do adresáře, který jste právě vytvořili.

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

Jak vidíte v tomto skriptu, po vytrénování modelu se soubor modelu uloží a zaregistruje do pracovního prostoru. Teď můžete použít zaregistrovaný model při odvozování koncových bodů.

Možná budete muset vybrat Aktualizovat, abyste viděli novou složku a skript ve vašich souborech.

Snímek obrazovky s ikonou aktualizace

Konfigurace příkazu

Teď, když máte skript, který může provádět požadované úlohy a výpočetní cluster ke spuštění skriptu, použijete příkaz pro obecné účely, který může spouštět akce příkazového řádku. Tato akce příkazového řádku může přímo volat systémové příkazy nebo spustit skript.

Tady vytvoříte vstupní proměnné pro zadání vstupních dat, poměru rozdělení, rychlosti učení a názvu registrovaného modelu. Skript příkazu bude:

  • Použijte prostředí, které definuje knihovny softwaru a modulu runtime potřebné pro trénovací skript. Azure Machine Learning poskytuje mnoho kurátorovaných nebo připravených prostředí, která jsou užitečná pro běžné scénáře trénování a odvozování. Tady použijete jedno z těchto prostředí. V kurzu: Vytrénování modelu ve službě Azure Machine Learning se naučíte, jak vytvořit vlastní prostředí.
  • Nakonfigurujte samotnou akci příkazového řádku – python main.py v tomto případě. Vstupy a výstupy jsou v příkazu přístupné prostřednictvím zápisu ${{ ... }} .
  • V této ukázce přistupujeme k datům ze souboru na internetu.
  • Vzhledem k tomu, že výpočetní prostředek nebyl zadán, skript se spustí v bezserverovém výpočetním clusteru , který se automaticky vytvoří.
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",
)

Odeslání úlohy

Teď je čas odeslat úlohu, která se má spustit ve službě Azure Machine Learning. Tentokrát použijete create_or_update na ml_client.

ml_client.create_or_update(job)

Zobrazení výstupu úlohy a čekání na dokončení úlohy

Zobrazte úlohu v studio Azure Machine Learning výběrem odkazu ve výstupu předchozí buňky.

Výstup této úlohy vypadá v studio Azure Machine Learning takto. Prozkoumejte karty pro různé podrobnosti, jako jsou metriky, výstupy atd. Po dokončení úloha zaregistruje v pracovním prostoru model v důsledku trénování.

Snímek obrazovky znázorňující stránku s přehledem úlohy

Důležité

Než se vrátíte do tohoto poznámkového bloku, počkejte, až se stav úlohy dokončí. Spuštění úlohy bude trvat 2 až 3 minuty. Pokud je výpočetní cluster škálovaný na nula uzlů a vlastní prostředí stále vytváří, může to trvat déle (až 10 minut).

Nasazení modelu jako online koncového bodu

Teď nasaďte model strojového učení jako webovou službu v cloudu Azure, tj online endpoint.

K nasazení služby machine learning použijete model, který jste zaregistrovali.

Vytvoření nového online koncového bodu

Teď, když máte zaregistrovaný model, je čas vytvořit online koncový bod. Název koncového bodu musí být jedinečný v celé oblasti Azure. Pro účely tohoto kurzu vytvoříte jedinečný název pomocí UUID.

import uuid

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

Vytvořte koncový bod:

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

Poznámka:

Počítejte s tím, že vytvoření koncového bodu bude trvat několik minut.

Po vytvoření koncového bodu ho můžete načíst následujícím způsobem:

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

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

Nasazení modelu do koncového bodu

Po vytvoření koncového bodu nasaďte model pomocí vstupního skriptu. Každý koncový bod může mít více nasazení. Směrování provozu do těchto nasazení je možné zadat pomocí pravidel. Tady vytvoříte jedno nasazení, které zpracovává 100 % příchozího provozu. Pro nasazení jsme zvolili název barvy, například modré, zelené, červené nasazení, což je libovolné.

Na stránce Modely na studio Azure Machine Learning můžete zkontrolovat nejnovější verzi zaregistrovaného modelu. Případně následující kód načte číslo nejnovější verze, které můžete použít.

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

Nasaďte nejnovější verzi modelu.

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

Poznámka:

Očekáváme, že toto nasazení bude trvat přibližně 6 až 8 minut.

Až se nasazení dokončí, můžete ho otestovat.

Testování pomocí ukázkového dotazu

Jakmile je model nasazený do koncového bodu, můžete s ním spustit odvozování.

Vytvořte ukázkový soubor požadavku podle návrhu očekávaného v metodě spuštění ve skriptu skóre.

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

Vyčištění prostředků

Pokud koncový bod nebudete používat, odstraňte ho, abyste prostředek přestali používat. Před odstraněním se ujistěte, že žádná další nasazení nepoužívají koncový bod.

Poznámka:

Očekáváme, že úplné odstranění bude trvat přibližně 20 minut.

ml_client.online_endpoints.begin_delete(name=online_endpoint_name)

Zastavení výpočetní instance

Pokud ji teď nebudete používat, zastavte výpočetní instanci:

  1. V sadě Studio v levé navigační oblasti vyberte Compute.
  2. Na horních kartách vyberte Výpočetní instance.
  3. V seznamu vyberte výpočetní instanci.
  4. Na horním panelu nástrojů vyberte Zastavit.

Odstranění všech prostředků

Důležité

Prostředky, které jste vytvořili, se dají použít jako předpoklady pro další kurzy a články s postupy pro Azure Machine Learning.

Pokud nemáte v úmyslu používat žádné prostředky, které jste vytvořili, odstraňte je, abyste za ně neúčtovaly žádné poplatky:

  1. Na webu Azure Portal do vyhledávacího pole zadejte skupiny prostředků a vyberte je z výsledků.

  2. V seznamu vyberte skupinu prostředků, kterou jste vytvořili.

  3. Na stránce Přehled vyberte Odstranit skupinu prostředků.

    Snímek obrazovky s výběrem pro odstranění skupiny prostředků na webu Azure Portal

  4. Zadejte název skupiny prostředků. Poté vyberte Odstranit.

Další kroky

Teď, když máte představu o tom, co se týká trénování a nasazení modelu, najdete další informace o procesu v těchto kurzech:

Kurz Popis
Nahrání, přístup k datům a prozkoumání dat ve službě Azure Machine Learning Ukládání velkých dat v cloudu a jejich načtení z poznámkových bloků a skriptů
Vývoj modelů na cloudové pracovní stanici Zahájení vytváření prototypů a vývoj modelů strojového učení
Trénování modelu ve službě Azure Machine Learning Podrobné informace o trénování modelu
Nasazení modelu jako online koncového bodu Podrobné informace o nasazení modelu
Vytváření produkčních kanálů strojového učení Rozdělte kompletní úlohu strojového učení na vícekrokový pracovní postup.