Kurz: Azure Machine Learning za den

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

Zjistěte, jak datový vědec používá Azure Machine Learning (Azure ML) k trénování modelu a pak ho používá k predikci. Tento kurz vám pomůže seznámit se se základními koncepty Azure ML a jejich nejběžnějším používáním.

Dozvíte se, jak odeslat úlohu příkazu ke spuštění trénovacího skriptu na zadaném výpočetním prostředku s nakonfigurovaným prostředím úloh potřebným ke spuštění skriptu.

Trénovací skript zpracovává přípravu dat a pak trénuje a zaregistruje model. Jakmile budete mít model, nasadíte ho jako koncový bod a pak zavoláte koncový bod pro odvození.

Kroky, které provedete, jsou následující:

  • Připojení k pracovnímu prostoru Azure ML
  • Vytvoření výpočetního prostředku a prostředí úloh
  • Vytvoření trénovacího skriptu
  • Vytvořte a spusťte úlohu příkazu ke spuštění trénovacího skriptu na výpočetním prostředku nakonfigurovaného s odpovídajícím prostředím úloh.
  • Zobrazení výstupu trénovacího skriptu
  • Nasazení nově natrénovaného modelu jako koncového bodu
  • Volání koncového bodu Azure ML pro odvozování

Požadavky

Spuštění poznámkového bloku

  1. Na horním panelu vyberte výpočetní instanci, kterou jste vytvořili během rychlého startu: Začínáme se službou Azure Machine Learning pro spuštění poznámkového bloku.

  2. Ujistěte se, ž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 v rozevíracím seznamu.

Snímek obrazovky: Nastavení jádra

Důležité

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

Pokud chcete v poznámkovém bloku spustit jednu buňku kódu, klikněte na buňku s kódem a stiskněte Shift+Enter. Nebo spusťte celý poznámkový blok tak, že na horním panelu nástrojů vyberete Spustit vše .

Připojení k pracovnímu prostoru

Než se do kódu ponoříte, budete se muset připojit k pracovnímu prostoru Azure ML. 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.

Používáme DefaultAzureCredential k získání přístupu k pracovnímu prostoru. DefaultAzureCredential se používá ke zpracování většiny scénářů ověřování v sadě Azure SDK.

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

# Authentication package
from azure.identity import DefaultAzureCredential

credential = DefaultAzureCredential()

Do další buňky zadejte ID předplatného, název skupiny prostředků a název pracovního prostoru. Vyhledání těchto hodnot:

  1. V pravém horním studio Azure Machine Learning panelu nástrojů vyberte název pracovního prostoru.
  2. Do kódu zkopírujte hodnotu pro pracovní prostor, skupinu prostředků a ID předplatného.
  3. Budete muset zkopírovat jednu hodnotu, zavřít oblast a vložit a pak se vrátit k další hodnotě.
# 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>",
)

Výsledkem je obslužná rutina pracovního prostoru, kterou použijete ke správě dalších prostředků a úloh.

Důležité

Vytvoření MLClient se nepřipojí k pracovnímu prostoru. Inicializace klienta je líná a bude čekat na první volání (v následujícím poznámkovém bloku, ke kterému dojde při vytváření výpočetních prostředků).

Vytvoření výpočetního prostředku pro spuštění úlohy

Ke spuštění úlohy budete potřebovat výpočetní prostředek. Může se jednat o počítače s jedním nebo více uzly s operačním systémem Linux nebo Windows nebo konkrétní výpočetní prostředky infrastruktury, jako je Spark.

Zřídíte výpočetní cluster s Linuxem. Projděte si úplný seznam velikostí a cen virtuálních počítačů .

V tomto příkladu potřebujete jenom základní cluster, takže použijete Standard_DS3_v2 model se 2 jádry vCPU, 7 GB paměti RAM a vytvoříte výpočetní prostředí Azure ML.

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

    # Now, we pass the object to MLClient's create_or_update method
    cpu_cluster = ml_client.compute.begin_create_or_update(cpu_cluster)

print(
    f"AMLCompute with name {cpu_cluster.name} is created, the compute size is {cpu_cluster.size}"
)

Vytvoření prostředí úloh

Ke spuštění úlohy AzureML na výpočetním prostředku budete potřebovat prostředí. Prostředí obsahuje seznam modulu runtime softwaru a knihoven, které chcete nainstalovat do výpočetních prostředků, kde budete trénovat. Podobá se prostředí Pythonu na místním počítači.

AzureML 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í. Můžete také vytvořit vlastní prostředí pomocí image Dockeru nebo konfigurace Conda.

V tomto příkladu vytvoříte vlastní prostředí Conda pro vaše úlohy pomocí souboru conda yaml.

Nejprve vytvořte adresář pro uložení souboru.

import os

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

Teď vytvořte soubor v adresáři závislostí.

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

Specifikace obsahuje některé obvyklé balíčky, které budete ve své úloze používat (numpy, pip).

Projděte si tento soubor yaml a vytvořte a zaregistrujte toto vlastní prostředí ve vašem pracovním prostoru:

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

Co je úloha příkazu?

Vytvoříte úlohu příkazu Azure ML, která vytrénuje model pro predikci výchozího kreditu. Úloha příkazu se používá ke spuštění trénovacího skriptu v zadaném prostředí na zadaném výpočetním prostředku. Už jste vytvořili prostředí a výpočetní prostředek. Dále vytvoříte trénovací skript.

Trénovací skript zpracovává přípravu dat, trénování a registraci natrénovaného modelu. V tomto kurzu vytvoříte trénovací skript Pythonu.

Úlohy příkazů je možné spouštět z rozhraní příkazového řádku, sady Python SDK nebo rozhraní studia. V tomto kurzu použijete sadu Azure ML Python SDK v2 k vytvoření a spuštění úlohy příkazu.

Po spuštění trénovací úlohy nasadíte model a pak ho použijete k vytvoření předpovědi.

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ředzpracování dat a rozděluje je na testovací a trénovací data. Potom tato data využívá k trénování modelu založeného na stromové struktuře a vrácení výstupního modelu.

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

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

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

Konfigurace příkazu

Teď, když máte skript, který dokáže provádět požadované úlohy, 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 spuštěním skriptu.

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. Příkazový skript:

  • Ke spuštění tohoto příkazu použijte výpočetní prostředky vytvořené dříve.
  • Použijte prostředí vytvořené dříve – při spuštění příkazu můžete použít @latest notaci k označení nejnovější verze prostředí.
  • Nakonfigurujte některá metadata, jako je zobrazovaný název, název experimentu atd. Experiment je kontejner pro všechny iterace, které provádíte v určitém projektu. Všechny úlohy odeslané pod stejným názvem experimentu by byly ve studiu Azure ML uvedené vedle sebe.
  • V tomto případě nakonfigurujte samotnou python main.py akci příkazového řádku. Vstupy a výstupy jsou přístupné v příkazu prostřednictvím zápisu ${{ ... }} .
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",
)

Odeslání úlohy

Teď je čas odeslat úlohu ke spuštění v AzureML. Tentokrát použijete create_or_update na ml_client.jobs.

ml_client.create_or_update(job)

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

Zobrazte úlohu v nástroji AzureML Studio tak, že vyberete odkaz ve výstupu předchozí buňky.

Výstup této úlohy bude ve studiu AzureML vypadat takto. Prozkoumejte karty, kde najdete různé podrobnosti, jako jsou metriky, výstupy atd. Po dokončení úloha zaregistruje model ve vašem pracovním prostoru jako výsledek trénování.

Snímek obrazovky s přehledem úlohy

Důležité

Počkejte, až se stav úlohy dokončí, a teprve pak se vraťte do tohoto poznámkového bloku a pokračujte. Spuštění úlohy bude trvat 2 až 3 minuty. Pokud došlo k vertikálnímu snížení kapacity výpočetního clusteru na nula uzlů a vlastní prostředí se 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 online endpointučení jako webovou službu v cloudu Azure .

K nasazení služby strojového učení obvykle potřebujete:

  • Prostředky modelu (soubor, metadata), které chcete nasadit. Tyto prostředky jste už zaregistrovali ve své trénovací úloze.
  • Nějaký kód, který se má spustit jako služba. Kód spustí model na daném vstupním požadavku. Tento vstupní skript přijme data odeslaná do nasazené webové služby a předá je do modelu a pak vrátí odpověď modelu klientovi. Skript je specifický pro váš model. Vstupní skript musí rozumět datům, která model očekává a vrací. V případě modelu MLFlow se tento skript vytvoří automaticky pro vás, stejně jako v tomto kurzu. Ukázky hodnoticích skriptů najdete tady.

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

Teď, když máte zaregistrovaný model a odvozovací skript, 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]

Poznámka

Počítejte s tím, že vytvoření koncového bodu bude trvat přibližně 6 až 8 minut.

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

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í zaváděcího skriptu. Každý koncový bod může mít několik nasazení. Pomocí pravidel je možné určit přímý provoz do těchto nasazení. Tady vytvoříte jedno nasazení, které bude zpracovávat 100 % příchozího provozu. Pro nasazení jsme zvolili barevný název, například modré, zelené nebo červené nasazení, což je libovolné.

Nejnovější verzi zaregistrovaného modelu můžete zjistit na stránce Modely ve studiu Azure ML. Případně kód níže načte nejnovější číslo 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)]
)

Nasaďte nejnovější verzi modelu.

Poznámka

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

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

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

Teď, když 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 používat nechcete, odstraňte ho, aby se prostředek přestal používat. Před odstraněním koncového bodu se ujistěte, že žádná jiná nasazení koncový bod nepoužívají.

Poznámka

Počítejte s tím, že tento krok bude trvat přibližně 6 až 8 minut.

ml_client.online_endpoints.begin_delete(name=online_endpoint_name)

Odstranit všechno

Pomocí těchto kroků můžete odstranit pracovní prostor Služby Azure Machine Learning a všechny výpočetní prostředky.

Důležité

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

Pokud žádný z prostředků, které jste vytvořili, neplánujete používat, odstraňte je, aby se vám neúčtovaly žádné poplatky:

  1. Úplně nalevo na webu Azure Portal vyberte Skupiny prostředků.

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

  3. Vyberte Odstranit skupinu prostředků.

    Snímek obrazovky s výběry k odstranění skupiny prostředků na portálu Azure Portal.

  4. Zadejte název skupiny prostředků. Vyberte Odstranit.

Další kroky