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 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 služby Azure Machine Learning a jejich nejběžnějším využití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 Služby Azure Machine Learning
• 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 Služby Azure Machine Learning pro odvozování

Požadavky

• Dokončete rychlý start: Začínáme se službou Azure Machine Learning , abyste:

  • Vytvoření pracovního prostoru.
  • Vytvořte cloudovou výpočetní instanci, která se použije pro vaše vývojové prostředí.

• Vytvořte nový poznámkový blok nebo zkopírujte náš poznámkový blok.

  • Pokud chcete vytvořit nový poznámkový blok, postupujte podle pokynů Rychlý start: Spuštění poznámkového bloku Juypter v studio Azure Machine Learning postupu.
  • Nebo pomocí kroků v rychlém startu naklonujte složku tutorials verze 2 a pak otevřete poznámkový blok ze složky tutorials/azureml-in-a-day/azureml-in-a-day.ipynb v oddílu Soubor .

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.

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 pustíte do kódu, budete se muset připojit k pracovnímu prostoru Azure Machine Learning. 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 Machine Learning.

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)

Vytvoření prostředí úloh

Ke spuštění úlohy Azure Machine Learning 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.

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í. 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í. Buňka níže používá magii IPython k zápisu souboru do adresáře, který jste právě vytvořili.

%%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 Machine Learning pro trénování modelu 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 Machine Learning 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.

Následující buňka používá magii IPythonu k zápisu 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_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 budou uvedeny vedle sebe v studio Azure Machine Learning.
• 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í ve službě Azure Machine Learning. 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 studio Azure Machine Learning výběrem odkazu ve výstupu předchozí buňky.

Výstup této úlohy bude v studio Azure Machine Learning 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í.

Důležité

Počkejte, až se stav úlohy dokončí, a pak se k tomuto poznámkovému bloku vraťte a pokračujte. Spuštění úlohy bude trvat 2 až 3 minuty. Pokud se výpočetní cluster škáluje 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, 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

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

Nejnovější verzi zaregistrovaného modelu můžete zjistit na stránce Modely na studio Azure Machine Learning. Případně následující kód 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 žádosti 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. Než koncový bod odstraníte, ujistěte se, že žádná jiná nasazení koncový bod nepoužívají.

Poznámka

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ů odstraňte pracovní prostor Služby Azure Machine Learning a všechny výpočetní prostředky.

Důležité

Prostředky, které jste vytvořili, můžete 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é z prostředků, které jste vytvořili, 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ů.

   

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

Další kroky

• Převeďte tento kurz na kanál připravený pro produkční prostředí s opakovaně použitelnými komponentami.
• Přečtěte si o všech možnostech nasazení služby Azure Machine Learning.
• Zjistěte, jak ověřit nasazený model.