Scikit-learn modellek nagy léptékű betanítása az Azure Machine Tanulás

  • Cikk

A KÖVETKEZŐKRE VONATKOZIK: Python SDK azure-ai-ml v2 (aktuális)

Ebből a cikkből megtudhatja, hogyan futtathatja scikit-learn betanítási szkripteit az Azure Machine Tanulás Python SDK 2-vel.

A cikkben szereplő példaszkriptekkel írisz virágképeket osztályozunk, hogy gépi tanulási modellt építsünk ki a scikit-learn íriszadatkészlete alapján.

Akár gépi tanulási scikit-learn modellt tanít be az alapoktól kezdve, akár meglévő modellt hoz a felhőbe, az Azure Machine Tanulás használatával rugalmas felhőalapú számítási erőforrások használatával skálázhatja fel a nyílt forráskódú betanítási feladatokat. Az Azure Machine Tanulás használatával éles üzemű modelleket hozhat létre, helyezhet üzembe, futtathat és monitorozhat.

Előfeltételek

A cikk kódját egy Azure Machine Tanulás számítási példányban vagy a saját Jupyter Notebookban futtathatja.

  • Azure Machine Learning számítási példány

    • Töltse ki az Erőforrások létrehozása elemet a számítási példány létrehozásának első lépéseihez . Minden számítási példány tartalmaz egy dedikált jegyzetfüzet-kiszolgálót, amely előre be van töltve az SDK-val és a jegyzetfüzetek mintaadattárával.
    • Válassza a jegyzetfüzet fület az Azure Machine Tanulás studióban. A mintatanítási mappában keressen egy befejezett és bővített jegyzetfüzetet a következő könyvtárra lépve: v2 > sdk > jobs > single-step > scikit-learn > train-hyperparameter-tune-deploy-with-sklearn.
    • Az oktatóanyag elvégzéséhez használhatja a minta betanítási mappájában található előre feltöltött kódot.

  • A Jupyter notebook-kiszolgálója.

A feladat beállítása

Ez a szakasz betanításra állítja be a feladatot a szükséges Python-csomagok betöltésével, a munkaterülethez való csatlakozással, egy számítási erőforrás létrehozásával egy parancsfeladat futtatásához, valamint a feladat futtatásához szükséges környezet létrehozásával.

Csatlakozás a munkaterületre

Először csatlakoznia kell az Azure Machine Tanulás-munkaterülethez. Az Azure Machine Tanulás munkaterület a szolgáltatás legfelső szintű erőforrása. Központosított helyet biztosít az Azure Machine Tanulás használatakor létrehozott összes összetevővel való munkához.

A munkaterülethez való hozzáférést használjuk DefaultAzureCredential . Ennek a hitelesítő adatnak képesnek kell lennie a legtöbb Azure SDK-hitelesítési forgatókönyv kezelésére.

Ha DefaultAzureCredential nem működik az Ön számára, tekintse meg azure-identity reference documentation vagy Set up authentication keresse meg a további elérhető hitelesítő adatokat.

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

# Authentication package
from azure.identity import DefaultAzureCredential

credential = DefaultAzureCredential()

Ha inkább böngészőt használ a bejelentkezéshez és a hitelesítéshez, távolítsa el a megjegyzéseket a következő kódban, és használja helyette.

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

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

Ezután szerezze be a munkaterület leíróját az előfizetés azonosítójának, az erőforráscsoport nevének és a munkaterület nevének megadásával. A paraméterek megkeresése:

  1. Keresse meg az Azure Machine Tanulás studio eszköztárának jobb felső sarkában a munkaterület nevét.
  2. Válassza ki a munkaterület nevét az erőforráscsoport és az előfizetés azonosítójának megjelenítéséhez.
  3. Másolja az erőforráscsoport és az előfizetés azonosítójának értékeit a kódba.
# 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>",
)

A szkript futtatásának eredménye egy munkaterületi leíró, amellyel más erőforrásokat és feladatokat kezelhet.

Feljegyzés

A létrehozás MLClient nem fogja csatlakoztatni az ügyfelet a munkaterülethez. Az ügyfél inicializálása lusta, és az első alkalommal vár, amikor hívást kell kezdeményeznie. Ebben a cikkben ez a számítás létrehozása során fog történni.

Számítási erőforrás létrehozása

Az Azure Machine Tanulás számítási erőforrásra van szüksége egy feladat futtatásához. Ez az erőforrás lehet egy- vagy többcsomópontos gép Linux vagy Windows operációs rendszerrel, vagy egy adott számítási háló, például a Spark.

A következő példaszkriptben kiépítünk egy Linuxot compute cluster. A virtuális gépek méreteinek és árainak teljes listáját tartalmazó oldal látható Azure Machine Learning pricing . Ehhez a példához csak alapszintű fürtre van szükségünk; Így egy Standard_DS3_v2 modellt választunk 2 vCPU-maggal és 7 GB RAM-mal egy Azure Machine Tanulás számítás létrehozásához.

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

Feladatkörnyezet létrehozása

Azure Machine-Tanulás feladat futtatásához környezetre van szükség. Az Azure Machine Tanulás környezet magában foglalja a számítógép-tanulási betanítási szkript számítási erőforráson való futtatásához szükséges függőségeket (például szoftveres futtatókörnyezetet és kódtárakat). Ez a környezet hasonló a helyi gépen lévő Python-környezethez.

Az Azure Machine Tanulás lehetővé teszi, hogy válogatott (vagy kész) környezetet használjon, vagy egyéni környezetet hozzon létre Docker-rendszerkép vagy Conda-konfiguráció használatával. Ebben a cikkben egy Conda YAML-fájl használatával hoz létre egyéni környezetet a feladatokhoz.

Egyéni környezet létrehozása

Az egyéni környezet létrehozásához meg kell határoznia a Conda-függőségeket egy YAML-fájlban. Először hozzon létre egy könyvtárat a fájl tárolásához. Ebben a példában elneveztük a könyvtárat env.

import os

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

Ezután hozza létre a fájlt a függőségek könyvtárában. Ebben a példában elneveztük a fájlt conda.yml.

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

A specifikáció tartalmaz néhány szokásos csomagot (például numpy és pip), amelyeket a feladatban használ.

Ezután a YAML-fájllal hozza létre és regisztrálja ezt az egyéni környezetet a munkaterületen. A környezet futásidőben egy Docker-tárolóba van csomagolva.

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

További információ a környezetek létrehozásáról és használatáról: Szoftverkörnyezetek létrehozása és használata az Azure Machine Tanulás.

[Nem kötelező] Egyéni környezet létrehozása a Scikit-Learn Intel-bővítményével®

Szeretné felgyorsítani a scikit-learn szkripteket az Intel hardverén? Próbálja meg hozzáadni az Intel® Extension for Scikit-Learn bővítményt a conda yaml-fájlhoz, és kövesse a fenti lépéseket. Az alábbi példában bemutatjuk, hogyan engedélyezheti ezeket az optimalizálásokat:

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

A betanítási feladat konfigurálása és elküldése

Ebben a szakaszban bemutatjuk, hogyan futtathat betanítási feladatokat egy általunk biztosított betanítási szkripttel. Első lépésként hozza létre a betanítási feladatot a betanítási szkript futtatására szolgáló parancs konfigurálásával. Ezután beküldi a betanítási feladatot az Azure Machine Tanulás való futtatáshoz.

A betanítási szkript előkészítése

Ebben a cikkben a betanítási szkriptet train_iris.py. A gyakorlatban bármilyen egyéni betanítási szkriptet használhat, és futtathatja az Azure Machine Tanulás anélkül, hogy módosítania kellene a kódot.

Feljegyzés

A megadott betanítási szkript a következőket teszi:

  • bemutatja, hogyan naplózhat néhány metrikát az Azure Machine-Tanulás futtatásához;
  • a betanítási adatokat iris = datasets.load_iris()letölti és kinyeri; és
  • betanítanak egy modellt, majd menti és regisztrálja.

A saját adatainak használatához és eléréséhez tekintse meg , hogyan olvashat és írhat adatokat egy feladatban az adatok elérhetővé tétele érdekében a betanítás során.

A betanítási szkript használatához először hozzon létre egy könyvtárat, amelyben tárolni fogja a fájlt.

import os

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

Ezután hozza létre a szkriptfájlt a forráskönyvtárban.

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

[Nem kötelező] Az Intel® Extension for Scikit-Learn optimalizálási funkciójának engedélyezése az Intel-hardverek nagyobb teljesítményéhez

Ha telepítette az Intel® Bővítményt a Scikit-Learnhez (ahogy az előző szakaszban is bemutattuk), engedélyezheti a teljesítményoptimalizálást úgy, hogy hozzáadja a két kódsort a szkriptfájl elejéhez, ahogy az alább látható.

A Scikit-Learn Intel-bővítményével® kapcsolatos további információkért tekintse meg a csomag dokumentációját.

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

A betanítási feladat létrehozása

Most, hogy rendelkezik a feladat futtatásához szükséges összes eszközzel, ideje az Azure Machine Tanulás Python SDK v2 használatával létrehozni. A feladat futtatásához létrehozunk egy command.

Az Azure Machine Tanulás command olyan erőforrás, amely megadja a betanítási kód felhőben való végrehajtásához szükséges összes részletet. Ezek a részletek tartalmazzák a bemeneteket és kimeneteket, a használandó hardver típusát, a telepíteni kívánt szoftvereket és a kód futtatásának módját. A command parancsok végrehajtásához szükséges információkat tartalmazza.

A parancs konfigurálása

Az általános célt command használja a betanítási szkript futtatására és a kívánt feladatok végrehajtására. Hozzon létre egy objektumot Command a betanítási feladat konfigurációs adatainak megadásához.

  • A parancs bemenetei közé tartozik az alapidőszakok száma, a tanulási sebesség, a lendület és a kimeneti könyvtár.
  • A paraméterértékek esetében:
    • adja meg a parancs futtatásához létrehozott számítási fürtöt cpu_compute_target = "cpu-cluster" ;
    • adja meg az Azure Machine Tanulás feladat futtatásához létrehozott egyéni környezetetsklearn-env;
    • konfigurálja magát a parancssori műveletet – ebben az esetben a parancs a következő python train_iris.py: . A parancs bemeneteit és kimeneteit a ${{ ... }} jelölésen keresztül érheti el; és
    • konfigurálja a metaadatokat, például a megjelenített nevet és a kísérlet nevét; ahol egy kísérlet egy tároló egy adott projekten végzett összes iterációhoz. Az ugyanazon kísérletnév alatt elküldött összes feladat egymás mellett szerepelne az Azure Machine Tanulás Studióban.
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",
)

Feladat küldése

Itt az ideje, hogy elküldje a feladatot az Azure Machine Tanulás futtatásához. Ezúttal a következőt használja create_or_update : ml_client.jobs.

ml_client.jobs.create_or_update(job)

Miután végzett, a feladat regisztrál egy modellt a munkaterületen (a betanítás eredményeként), és egy hivatkozást ad ki a feladat megtekintéséhez az Azure Machine Tanulás Studióban.

Figyelmeztetés

Az Azure Machine Tanulás a teljes forráskönyvtár másolásával futtatja a betanítási szkripteket. Ha olyan bizalmas adatokkal rendelkezik, amelyeket nem szeretne feltölteni, használjon .ignore fájlt , vagy ne vegye fel azokat a forráskönyvtárba.

Mi történik a feladat végrehajtása során?

A feladat végrehajtása során a következő szakaszokon megy keresztül:

  • Előkészítés: A rendszer létrehoz egy Docker-rendszerképet a megadott környezetnek megfelelően. A rendszerképet a rendszer feltölti a munkaterület tárolóregisztrációs adatbázisára, és gyorsítótárazza a későbbi futtatásokhoz. A naplók a futtatási előzményekbe is streamelhetők, és megtekinthetők a folyamat figyeléséhez. Ha egy válogatott környezet van megadva, a rendszer a gyorsítótárazott rendszerkép-háttérrendszert használja a válogatott környezethez.

  • Skálázás: A fürt megkísérli a vertikális felskálázást, ha a fürtnek több csomópontra van szüksége a futtatás végrehajtásához, mint amennyi jelenleg elérhető.

  • Futtatás: A szkriptmappa src összes szkriptje fel lesz töltve a számítási célba, az adattárak csatlakoztatva vannak vagy másolódnak, és a szkript végrehajtása megtörténik. Az stdout és a ./logs mappa kimenetei a futtatási előzményekbe kerülnek, és a futtatás figyelésére használhatók.

Modell hiperparamétereinek finomhangolása

Most, hogy megismerte, hogyan végezhet el egy egyszerű Scikit-learn betanítást az SDK használatával, nézzük meg, hogy tovább javíthatja-e a modell pontosságát. A modell hiperparamétereit az Azure Machine Tanulás sweep képességeivel hangolhatja és optimalizálhatja.

A modell hiperparamétereinek finomhangolásához adja meg azt a paraméterteret, amelyben a betanítás során keresni szeretne. Ezt úgy teheti meg, hogy lecseréli a betanítási feladatnak átadott paraméterek egy részét akernelpenaltycsomagból származó azure.ml.sweep speciális bemenetekre.

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

Ezután konfigurálja a takarítást a parancsfeladaton bizonyos, takarításra vonatkozó paraméterekkel, például a figyelendő elsődleges metrikával és a használandó mintavételezési algoritmussal.

Az alábbi kódban véletlenszerű mintavételezést használunk a hiperparaméterek különböző konfigurációs készleteinek kipróbálására az elsődleges metrika maximalizálása érdekében. 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,
)

Most már a korábbiakhoz hasonlóan küldheti el ezt a feladatot. Ezúttal egy takarítási feladatot futtat, amely átsöpri a vonatfeladatot.

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)

A feladatot a feladat futtatása során megjelenő studio felhasználói felület hivatkozásával figyelheti.

A legjobb modell megkeresése és regisztrálása

Miután az összes futtatás befejeződött, megtalálhatja a modellt a legnagyobb pontossággal előállító futtatásokat.

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

Ezután regisztrálhatja ezt a modellt.

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

A modell üzembe helyezése

A modell regisztrálása után ugyanúgy telepítheti, mint bármely más regisztrált modellt az Azure Machine Tanulás. További információ az üzembe helyezésről: Gépi tanulási modell üzembe helyezése és pontszáma felügyelt online végponttal Python SDK v2 használatával.

Következő lépések

Ebben a cikkben betanított és regisztrált egy scikit-learn modellt, és megismerkedett az üzembe helyezési lehetőségekkel. Az Azure Machine Tanulás további információért tekintse meg ezeket a cikkeket.