Scikit-learn modellek nagy léptékű betanítása az Azure Machine Learning használatával
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 Learning 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 Learning 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 Learning 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 Learning 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 ki a jegyzetfüzet fület az Azure Machine Learning 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ülethez
Először csatlakoznia kell az Azure Machine Learning-munkaterülethez. Az Azure Machine Learning-munkaterület a szolgáltatás legfelső szintű erőforrása. Központosított helyet biztosít az Azure Machine Learning 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:
- Keresse meg az Azure Machine Learning Studio eszköztárának jobb felső sarkában a munkaterület nevét.
- 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.
- 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 Learningnek 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 Learning-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 Learning-feladat futtatásához környezetre van szükség. Az Azure Machine Learning-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 Learning 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 Learningben.
[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 Learningben 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 képesnek kell lennie bármilyen egyéni betanítási szkriptet használni, és anélkül futtatni az Azure Machine Learningben, 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 Learning-futtatásban;
- 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, itt az ideje, hogy az Azure Machine Learning Python SDK 2-s v2 használatával hozza létre. A feladat futtatásához létrehozunk egy command
.
Az Azure Machine Learning command
egy 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 Learning-feladat futtatásához létrehozott egyéni környezetet
sklearn-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 azonos kísérletnévvel elküldött összes feladat egymás mellett szerepelne az Azure Machine Learning Studióban.
- adja meg a parancs futtatásához létrehozott számítási fürtöt
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 Learningben való futtatáshoz. 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 Azure Machine Learning Studióban való megtekintéséhez.
Figyelmeztetés
Az Azure Machine Learning a teljes forráskönyvtár másolásával futtat 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 Learning 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 akernel
penalty
csomagbó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 Learningben. 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 Learningről további információt az alábbi cikkekben talál.