Trénování modelů scikit-learn ve velkém měřítku pomocí služby Azure Machine Učení

  • Článek

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

V tomto článku se dozvíte, jak spustit trénovací skripty scikit-learn pomocí sady Azure Machine Učení Python SDK v2.

Ukázkové skripty v tomto článku slouží ke klasifikaci obrázků iris flower k vytvoření modelu strojového učení založeného na datové sadě iris scikit-learn.

Bez ohledu na to, jestli trénujete model scikit-learn strojového učení od základů nebo přenesete existující model do cloudu, můžete pomocí azure Machine Učení škálovat opensourcové trénovací úlohy pomocí výpočetních prostředků elastického cloudu. Pomocí služby Azure Machine Učení můžete vytvářet, nasazovat, nasazovat, verze a monitorovat modely na produkční úrovni.

Požadavky

Kód pro tento článek můžete spustit buď ve výpočetní instanci Azure Machine Učení, nebo ve vlastním poznámkovém bloku Jupyter Notebook.

  • Výpočetní instance Azure Machine Learningu

    • Dokončete vytváření prostředků, abyste mohli začít vytvářet výpočetní instanci. Každá výpočetní instance zahrnuje vyhrazený server poznámkového bloku předem načtený se sadou SDK a ukázkovým úložištěm poznámkových bloků.
    • V studio Azure Machine Learning vyberte kartu poznámkového bloku. Ve složce pro trénování ukázek vyhledejte dokončený a rozbalený poznámkový blok tak, že přejdete do tohoto adresáře: úlohy >> sady SDK v2 > scikit-learn >> train-hyperparameter-tune-deploy-with-sklearn.
    • K dokončení tohoto kurzu můžete použít předem vyplněný kód v ukázkové trénovací složce.

  • Váš server Jupyter Notebook.

Nastavení úlohy

Tato část nastaví úlohu pro trénování načtením požadovaných balíčků Pythonu, připojením k pracovnímu prostoru, vytvořením výpočetního prostředku pro spuštění úlohy příkazu a vytvořením prostředí pro spuštění úlohy.

Připojení do pracovního prostoru

Nejprve se musíte připojit ke svému pracovnímu prostoru Azure Machine Učení. Pracovní prostor Učení Azure je prostředek nejvyšší úrovně služby. Poskytuje centralizované místo pro práci se všemi artefakty, které vytvoříte při použití služby Azure Machine Učení.

Používáme DefaultAzureCredential k získání přístupu k pracovnímu prostoru. Tyto přihlašovací údaje by měly být schopné zpracovávat většinu scénářů ověřování sady Azure SDK.

Pokud DefaultAzureCredential vám nefunguje, podívejte se nebo Set up authentication vyhledejte azure-identity reference documentation další dostupné přihlašovací údaje.

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

# Authentication package
from azure.identity import DefaultAzureCredential

credential = DefaultAzureCredential()

Pokud chcete k přihlášení a ověření použít prohlížeč, měli byste komentáře odebrat v následujícím kódu a místo toho ho použít.

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

# Authentication package
# from azure.identity import InteractiveBrowserCredential
# credential = InteractiveBrowserCredential()

Dále získejte popisovač pracovního prostoru zadáním ID předplatného, názvu skupiny prostředků a názvu pracovního prostoru. Vyhledání těchto parametrů:

  1. Vyhledejte název pracovního prostoru v pravém horním rohu panelu nástrojů studio Azure Machine Learning.
  2. Vyberte název pracovního prostoru, aby se zobrazila vaše skupina prostředků a ID předplatného.
  3. Zkopírujte hodnoty pro skupinu prostředků a ID předplatného do kódu.
# 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 spuštění tohoto skriptu je popisovač pracovního prostoru, který používáte ke správě jiných prostředků a úloh.

Poznámka:

Při vytváření MLClient se klient nepřipojí k pracovnímu prostoru. Inicializace klienta je opožděná a při prvním volání bude čekat. V tomto článku k tomu dojde během vytváření výpočetních prostředků.

Vytvoření výpočetního prostředku

Azure Machine Učení potřebuje výpočetní prostředek ke spuštění úlohy. Tento prostředek může být počítač 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.

V následujícím ukázkovém skriptu zřídíme Linux compute cluster. Azure Machine Learning pricing Zobrazí se stránka s úplným seznamem velikostí a cen virtuálních počítačů. Pro tento příklad potřebujeme pouze základní cluster; proto vybereme model Standard_DS3_v2 s 2 jádry vCPU a 7 GB paměti RAM a vytvoříme výpočetní Učení počítače Azure.

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).result()

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

Vytvoření prostředí úlohy

Ke spuštění úlohy Učení počítače Azure potřebujete prostředí. Prostředí Azure Machine Učení zapouzdřuje závislosti (například modul runtime softwaru a knihovny) potřebné ke spuštění trénovacího skriptu strojového učení na výpočetním prostředku. Toto prostředí se podobá prostředí Pythonu na místním počítači.

Azure Machine Učení umožňuje buď použít kurátorované (nebo připravené) prostředí, nebo vytvořit vlastní prostředí pomocí image Dockeru nebo konfigurace Conda. V tomto článku vytvoříte vlastní prostředí pro vaše úlohy pomocí souboru Conda YAML.

Vytvoření vlastního prostředí

Pokud chcete vytvořit vlastní prostředí, definujete závislosti Conda v souboru YAML. Nejprve vytvořte adresář pro uložení souboru. V tomto příkladu jsme pojmenovali adresář env.

import os

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

Potom vytvořte soubor v adresáři závislostí. V tomto příkladu jsme soubor conda.ymlpojmenovali .

%%writefile {dependencies_dir}/conda.yaml
name: sklearn-env
channels:
  - conda-forge
dependencies:
  - python=3.8
  - pip=21.2.4
  - scikit-learn=0.24.2
  - scipy=1.7.1
  - pip:  
    - azureml-mlflow==1.42.0
    - mlflow-skinny==2.3.2

Specifikace obsahuje některé obvyklé balíčky (například numpy a pip), které používáte ve své úloze.

Dále pomocí souboru YAML vytvořte a zaregistrujte toto vlastní prostředí ve vašem pracovním prostoru. Prostředí se zabalí do kontejneru Dockeru za běhu.

from azure.ai.ml.entities import Environment

custom_env_name = "sklearn-env"

job_env = Environment(
    name=custom_env_name,
    description="Custom environment for sklearn image classification",
    conda_file=os.path.join(dependencies_dir, "conda.yaml"),
    image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest",
)
job_env = ml_client.environments.create_or_update(job_env)

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

Další informace o vytváření a používání prostředí najdete v tématu Vytváření a používání softwarových prostředí v azure machine Učení.

[Volitelné] Vytvoření vlastního prostředí s rozšířením Intel® pro Scikit-Learn

Chcete urychlit skripty scikit-learn na hardwaru Intel? Zkuste do souboru conda yaml přidat Intel® Extension for Scikit-Learn a postupujte podle následujících kroků popsaných výše. Ukážeme vám, jak tyto optimalizace povolit později v tomto příkladu:

%%writefile {dependencies_dir}/conda.yaml
name: sklearn-env
channels:
  - conda-forge
dependencies:
  - python=3.8
  - pip=21.2.4
  - scikit-learn=0.24.2
  - scikit-learn-intelex
  - scipy=1.7.1
  - pip:  
    - azureml-mlflow==1.42.0
    - mlflow-skinny==2.3.2

Konfigurace a odeslání trénovací úlohy

V této části se podíváme, jak spustit trénovací úlohu pomocí trénovacího skriptu, který jsme zadali. Nejprve sestavíte trénovací úlohu konfigurací příkazu pro spuštění trénovacího skriptu. Pak odešlete úlohu trénování, která se spustí na počítači Azure Machine Učení.

Příprava trénovacího skriptu

V tomto článku jsme poskytli trénovací skript train_iris.py. V praxi byste měli být schopni vzít libovolný vlastní trénovací skript tak, jak je, a spouštět ho pomocí služby Azure Machine Učení, aniž byste museli upravovat kód.

Poznámka:

Zadaný trénovací skript provede následující akce:

  • ukazuje, jak protokolovat některé metriky do vašeho počítače Azure Učení spuštění;
  • stáhne a extrahuje trénovací data pomocí iris = datasets.load_iris(); a
  • trénuje model, pak ho uloží a zaregistruje.

Pokud chcete používat a přistupovat k vlastním datům, podívejte se, jak číst a zapisovat data v úloze a zpřístupnit je během trénování.

Pokud chcete použít trénovací skript, nejprve vytvořte adresář, do kterého soubor uložíte.

import os

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

Dále vytvořte soubor skriptu ve zdrojovém adresáři.

%%writefile {src_dir}/train_iris.py
# Modified from https://www.geeksforgeeks.org/multiclass-classification-using-scikit-learn/

import argparse
import os

# importing necessary libraries
import numpy as np

from sklearn import datasets
from sklearn.metrics import confusion_matrix
from sklearn.model_selection import train_test_split

import joblib

import mlflow
import mlflow.sklearn

def main():
    parser = argparse.ArgumentParser()

    parser.add_argument('--kernel', type=str, default='linear',
                        help='Kernel type to be used in the algorithm')
    parser.add_argument('--penalty', type=float, default=1.0,
                        help='Penalty parameter of the error term')

    # Start Logging
    mlflow.start_run()

    # enable autologging
    mlflow.sklearn.autolog()

    args = parser.parse_args()
    mlflow.log_param('Kernel type', str(args.kernel))
    mlflow.log_metric('Penalty', float(args.penalty))

    # loading the iris dataset
    iris = datasets.load_iris()

    # X -> features, y -> label
    X = iris.data
    y = iris.target

    # dividing X, y into train and test data
    X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)

    # training a linear SVM classifier
    from sklearn.svm import SVC
    svm_model_linear = SVC(kernel=args.kernel, C=args.penalty)
    svm_model_linear = svm_model_linear.fit(X_train, y_train)
    svm_predictions = svm_model_linear.predict(X_test)

    # model accuracy for X_test
    accuracy = svm_model_linear.score(X_test, y_test)
    print('Accuracy of SVM classifier on test set: {:.2f}'.format(accuracy))
    mlflow.log_metric('Accuracy', float(accuracy))
    # creating a confusion matrix
    cm = confusion_matrix(y_test, svm_predictions)
    print(cm)

    registered_model_name="sklearn-iris-flower-classify-model"

    ##########################
    #<save and register model>
    ##########################
    # Registering the model to the workspace
    print("Registering the model via MLFlow")
    mlflow.sklearn.log_model(
        sk_model=svm_model_linear,
        registered_model_name=registered_model_name,
        artifact_path=registered_model_name
    )

    # # Saving the model to a file
    print("Saving the model via MLFlow")
    mlflow.sklearn.save_model(
        sk_model=svm_model_linear,
        path=os.path.join(registered_model_name, "trained_model"),
    )
    ###########################
    #</save and register model>
    ###########################
    mlflow.end_run()

if __name__ == '__main__':
    main()

[Volitelné] Povolení rozšíření Intel® pro optimalizace Scikit-Learn pro zajištění vyššího výkonu na hardwaru Intel

Pokud jste nainstalovali Rozšíření Intel® pro Scikit-Learn (jak je znázorněno v předchozí části), můžete optimalizaci výkonu povolit přidáním dvou řádků kódu do horní části souboru skriptu, jak je znázorněno níže.

Další informace o rozšíření Intel® pro Scikit-Learn najdete v dokumentaci k balíčku.

%%writefile {src_dir}/train_iris.py
# Modified from https://www.geeksforgeeks.org/multiclass-classification-using-scikit-learn/

import argparse
import os

# Import and enable Intel Extension for Scikit-learn optimizations
# where possible

from sklearnex import patch_sklearn
patch_sklearn()

# importing necessary libraries
import numpy as np


from sklearn import datasets
from sklearn.metrics import confusion_matrix
from sklearn.model_selection import train_test_split

import joblib

import mlflow
import mlflow.sklearn

def main():
    parser = argparse.ArgumentParser()

    parser.add_argument('--kernel', type=str, default='linear',
                        help='Kernel type to be used in the algorithm')
    parser.add_argument('--penalty', type=float, default=1.0,
                        help='Penalty parameter of the error term')

    # Start Logging
    mlflow.start_run()

    # enable autologging
    mlflow.sklearn.autolog()

    args = parser.parse_args()
    mlflow.log_param('Kernel type', str(args.kernel))
    mlflow.log_metric('Penalty', float(args.penalty))

    # loading the iris dataset
    iris = datasets.load_iris()

    # X -> features, y -> label
    X = iris.data
    y = iris.target

    # dividing X, y into train and test data
    X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)

    # training a linear SVM classifier
    from sklearn.svm import SVC
    svm_model_linear = SVC(kernel=args.kernel, C=args.penalty)
    svm_model_linear = svm_model_linear.fit(X_train, y_train)
    svm_predictions = svm_model_linear.predict(X_test)

    # model accuracy for X_test
    accuracy = svm_model_linear.score(X_test, y_test)
    print('Accuracy of SVM classifier on test set: {:.2f}'.format(accuracy))
    mlflow.log_metric('Accuracy', float(accuracy))
    # creating a confusion matrix
    cm = confusion_matrix(y_test, svm_predictions)
    print(cm)

    registered_model_name="sklearn-iris-flower-classify-model"

    ##########################
    #<save and register model>
    ##########################
    # Registering the model to the workspace
    print("Registering the model via MLFlow")
    mlflow.sklearn.log_model(
        sk_model=svm_model_linear,
        registered_model_name=registered_model_name,
        artifact_path=registered_model_name
    )

    # # Saving the model to a file
    print("Saving the model via MLFlow")
    mlflow.sklearn.save_model(
        sk_model=svm_model_linear,
        path=os.path.join(registered_model_name, "trained_model"),
    )
    ###########################
    #</save and register model>
    ###########################
    mlflow.end_run()

if __name__ == '__main__':
    main()

Sestavení trénovací úlohy

Teď, když máte všechny prostředky potřebné ke spuštění úlohy, je čas ho sestavit pomocí sady Azure Machine Učení Python SDK v2. Pro spuštění úlohy vytvoříme .command

Azure Machine Učení command je prostředek, který určuje všechny podrobnosti potřebné ke spuštění trénovacího kódu v cloudu. Mezi tyto podrobnosti patří vstupy a výstupy, typ hardwaru, který se má použít, software k instalaci a způsob spuštění kódu. Obsahuje command informace pro spuštění jednoho příkazu.

Konfigurace příkazu

Ke spuštění trénovacího skriptu a provádění požadovaných úloh použijete obecný účel command . Vytvořte Command objekt pro zadání podrobností konfigurace vaší trénovací úlohy.

  • Vstupy pro tento příkaz zahrnují počet epoch, rychlost učení, dynamiku a výstupní adresář.
  • Pro hodnoty parametrů:
    • zadejte výpočetní cluster cpu_compute_target = "cpu-cluster" , který jste vytvořili pro spuštění tohoto příkazu;
    • zadejte vlastní prostředísklearn-env, které jste vytvořili pro spuštění úlohy azure machine Učení;
    • nakonfigurujte samotnou akci příkazového řádku – v tomto případě příkaz je python train_iris.py. Ke vstupům a výstupům v příkazu můžete přistupovat prostřednictvím zápisu ${{ ... }} a
    • nakonfigurujte metadata, jako je zobrazovaný název a název experimentu; kde experiment je kontejner pro všechny iterace, které provádí v určitém projektu. Všechny úlohy odeslané pod stejným názvem experimentu se zobrazí vedle sebe v studio Azure Machine Learning.
from azure.ai.ml import command
from azure.ai.ml import Input

job = command(
    inputs=dict(kernel="linear", penalty=1.0),
    compute=cpu_compute_target,
    environment=f"{job_env.name}:{job_env.version}",
    code="./src/",
    command="python train_iris.py --kernel ${{inputs.kernel}} --penalty ${{inputs.penalty}}",
    experiment_name="sklearn-iris-flowers",
    display_name="sklearn-classify-iris-flower-images",
)

Odeslání úlohy

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

ml_client.jobs.create_or_update(job)

Po dokončení úloha zaregistruje v pracovním prostoru model (v důsledku trénování) a vypíše odkaz pro zobrazení úlohy v studio Azure Machine Learning.

Upozorňující

Azure Machine Učení spouští trénovací skripty zkopírováním celého zdrojového adresáře. Pokud máte citlivá data, která nechcete nahrát, použijte soubor .ignore nebo je nezahrňte do zdrojového adresáře.

Co se stane během provádění úlohy

Při spuštění úlohy prochází následujícími fázemi:

  • Příprava: Image Dockeru se vytvoří podle definovaného prostředí. Image se nahraje do registru kontejneru pracovního prostoru a pro pozdější spuštění se ukládá do mezipaměti. Protokoly se také streamují do historie spuštění a dají se zobrazit pro monitorování průběhu. Pokud je zadané kurátorované prostředí, použije se image uložená v mezipaměti, která kurátorované prostředí zálohuje.

  • Škálování: Cluster se pokusí vertikálně navýšit kapacitu, pokud cluster k provedení spuštění vyžaduje více uzlů, než je aktuálně k dispozici.

  • Spuštěno: Všechny skripty ve složce skriptu src se nahrají do cílového výpočetního objektu, úložiště dat se připojí nebo zkopírují a skript se spustí. Výstupy ze stdoutu a složky ./logs se streamují do historie spuštění a lze je použít k monitorování spuštění.

Ladění hyperparametrů modelu

Teď, když jste viděli, jak pomocí sady SDK provést jednoduché trénování Scikit-learn, pojďme se podívat, jestli můžete ještě více zlepšit přesnost modelu. Hyperparametry modelu můžete vyladit a optimalizovat pomocí možností služby Azure Machine Učenísweep.

Pokud chcete vyladit hyperparametry modelu, definujte prostor parametrů, ve kterém se má během trénování hledat. Provedete to tak, že nahradíte některé parametry (kernel a penalty) předané trénovací úloze speciálními vstupy z azure.ml.sweep balíčku.

from azure.ai.ml.sweep import Choice

# we will reuse the command_job created before. we call it as a function so that we can apply inputs
# we do not apply the 'iris_csv' input again -- we will just use what was already defined earlier
job_for_sweep = job(
    kernel=Choice(values=["linear", "rbf", "poly", "sigmoid"]),
    penalty=Choice(values=[0.5, 1, 1.5]),
)

Pak nakonfigurujete uklidit u úlohy příkazu pomocí některých parametrů specifických pro úklid, jako je primární metrika pro sledování a algoritmu vzorkování, který se má použít.

V následujícím kódu použijeme náhodné vzorkování k vyzkoušení různých konfiguračních sad hyperparametrů při pokusu o maximalizaci naší primární metriky Accuracy.

sweep_job = job_for_sweep.sweep(
    compute="cpu-cluster",
    sampling_algorithm="random",
    primary_metric="Accuracy",
    goal="Maximize",
    max_total_trials=12,
    max_concurrent_trials=4,
)

Teď můžete tuto úlohu odeslat jako předtím. Tentokrát spouštíte úlohu uklidení, která přemístit vaši úlohu trénu.

returned_sweep_job = ml_client.create_or_update(sweep_job)

# stream the output and wait until the job is finished
ml_client.jobs.stream(returned_sweep_job.name)

# refresh the latest status of the job after streaming
returned_sweep_job = ml_client.jobs.get(name=returned_sweep_job.name)

Úlohu můžete monitorovat pomocí odkazu uživatelského rozhraní studia, který se zobrazí během spuštění úlohy.

Vyhledání a registrace nejlepšího modelu

Po dokončení všech spuštění můžete najít běh, který vytvořil model s nejvyšší přesností.

from azure.ai.ml.entities import Model

if returned_sweep_job.status == "Completed":

    # First let us get the run which gave us the best result
    best_run = returned_sweep_job.properties["best_child_run_id"]

    # lets get the model from this run
    model = Model(
        # the script stores the model as "sklearn-iris-flower-classify-model"
        path="azureml://jobs/{}/outputs/artifacts/paths/sklearn-iris-flower-classify-model/".format(
            best_run
        ),
        name="run-model-example",
        description="Model created from run.",
        type="custom_model",
    )

else:
    print(
        "Sweep job status: {}. Please wait until it completes".format(
            returned_sweep_job.status
        )
    )

Tento model pak můžete zaregistrovat.

registered_model = ml_client.models.create_or_update(model=model)

Nasazení modelu

Po registraci modelu ho můžete nasadit stejným způsobem jako jakýkoli jiný zaregistrovaný model ve službě Azure Machine Učení. Další informace o nasazení najdete v tématu Nasazení a určení skóre modelu strojového učení pomocí spravovaného online koncového bodu pomocí sady Python SDK v2.

Další kroky

V tomto článku jste natrénovali a zaregistrovali model scikit-learn a dozvěděli jste se o možnostech nasazení. Další informace o službě Azure Machine Učení najdete v těchto dalších článcích.