Oktatóanyag: Modell betanítása az Azure Machine Tanulás
A KÖVETKEZŐKRE VONATKOZIK: Python SDK azure-ai-ml v2 (aktuális)
Megtudhatja, hogyan tanít be egy modellt egy adattudós az Azure Machine Tanulás használatával. Ebben a példában a társított hitelkártya-adatkészlet használatával mutatjuk be, hogyan használhatja az Azure Machine Tanulás besorolási probléma esetén. A cél annak előrejelzése, hogy az ügyfél nagy valószínűséggel fizet-e hitelkártyás fizetést.
A betanítási szkript kezeli az adatelőkészítést, majd betanít és regisztrál egy modellt. Ez az oktatóanyag végigvezeti egy felhőalapú betanítási feladat (parancsfeladat) beküldésének lépésein. Ha többet szeretne megtudni az adatok Azure-ba való betöltéséről, tekintse meg az Azure Machine Tanulás adatainak feltöltését, elérését és felderítését ismertető oktatóanyagot. A lépések a következők:
- Fogópont lekérése az Azure Machine Tanulás-munkaterületre
- Számítási erőforrás- és feladatkörnyezet létrehozása
- Betanítási szkript létrehozása
- Hozza létre és futtassa a parancsfeladatot a betanítási szkript futtatásához a számítási erőforráson, a megfelelő feladatkörnyezettel és az adatforrással konfigurálva
- A betanítási szkript kimenetének megtekintése
- Az újonnan betanított modell üzembe helyezése végpontként
- Az Azure Machine Tanulás végpontjának meghívása a következtetéshez
Ez a videó bemutatja, hogyan kezdheti el az Azure Machine Tanulás Studióban, hogy követni tudja az oktatóanyag lépéseit. A videó bemutatja, hogyan hozhat létre jegyzetfüzetet, hozhat létre számítási példányt, és klónozhatja a jegyzetfüzetet. A lépéseket a következő szakaszokban is ismertetjük.
Előfeltételek
-
Az Azure Machine Tanulás használatához először munkaterületre lesz szüksége. Ha nem rendelkezik ilyen erőforrással, végezze el a munkaterület létrehozásához szükséges erőforrások létrehozását, és tudjon meg többet a használatáról.
-
Jelentkezzen be a stúdióba , és válassza ki a munkaterületet, ha még nincs megnyitva.
-
Jegyzetfüzet megnyitása vagy létrehozása a munkaterületen:
- Hozzon létre egy új jegyzetfüzetet, ha kódot szeretne másolni/beilleszteni a cellákba.
- Vagy nyisson meg oktatóanyagokat/get-started-notebooks/train-model.ipynb-t a Studio Minták szakaszából. Ezután válassza a Klónozás lehetőséget a jegyzetfüzet fájlokhoz való hozzáadásához. (Lásd a minták helyét.)
A kernel beállítása
A megnyitott jegyzetfüzet fölötti felső sávon hozzon létre egy számítási példányt, ha még nem rendelkezik ilyenrel.
Ha a számítási példány le van állítva, válassza a Számítás indítása lehetőséget, és várja meg, amíg fut.
Győződjön meg arról, hogy a jobb felső sarokban található kernel az
Python 3.10 - SDK v2
. Ha nem, a legördülő menüben válassza ki ezt a kernelt.Ha megjelenik egy szalagcím, amely azt jelzi, hogy hitelesíteni kell, válassza a Hitelesítés lehetőséget.
Fontos
Az oktatóanyag többi része az oktatóanyag-jegyzetfüzet celláit tartalmazza. Másolja vagy illessze be őket az új jegyzetfüzetbe, vagy váltson most a jegyzetfüzetre, ha klónozta.
Modell betanítása parancsfeladat használatával az Azure Machine Tanulás
A modell betanítása érdekében be kell küldenie egy feladatot. Az oktatóanyagban elküldeni kívánt feladat típusa egy parancsfeladat. Az Azure Machine Tanulás számos különböző típusú feladatot kínál a modellek betanítása érdekében. A felhasználók a modell összetettsége, az adatméret és a betanítási sebesség követelményei alapján választhatják ki a betanítási módszerüket. Ebben az oktatóanyagban megtanulhatja, hogyan küldhet be egy parancsfeladatotegy betanítási szkript futtatásához.
A parancsfeladatok olyan függvények, amelyekkel egyéni betanítási szkriptet küldhet be a modell betanításához. Ez egyéni betanítási feladatként is definiálható. Az Azure Machine Tanulás parancsfeladata olyan feladattípus, amely szkriptet vagy parancsot futtat egy adott környezetben. A parancsfeladatok segítségével modelleket taníthat be, adatokat dolgozhat fel vagy bármely más egyéni kódot, amelyet a felhőben szeretne végrehajtani.
Ebben az oktatóanyagban egy parancsfeladat használatával hozunk létre egy egyéni betanítási feladatot, amelyet egy modell betanítására fogunk használni. Minden egyéni betanítási feladathoz az alábbi elemek szükségesek:
- környezet
- adatok
- parancsfeladat
- betanítási szkript
Ebben az oktatóanyagban az alábbi elemeket mutatjuk be a példánkhoz: osztályozót hozunk létre, amely előrejelzi azokat az ügyfeleket, akiknek nagy a valószínűsége, hogy a hitelkártyás fizetések alapértelmezettek.
Leíró létrehozása munkaterületre
Mielőtt belemerülnénk a kódba, szüksége lesz egy módszerre a munkaterületre való hivatkozáshoz. Létre fog hozni ml_client
egy leírót a munkaterületen. Ezután ml_client
erőforrásokat és feladatokat fog kezelni.
A következő cellában adja meg az előfizetés azonosítóját, az erőforráscsoport nevét és a munkaterület nevét. Az alábbi értékek megkeresése:
- A jobb felső Azure Machine Tanulás studio eszköztáron válassza ki a munkaterület nevét.
- Másolja a munkaterület, az erőforráscsoport és az előfizetés azonosítójának értékét a kódba.
- Ki kell másolnia egy értéket, be kell zárnia a területet és be kell illesztenie, majd vissza kell térnie a következőhöz.
from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential
# authenticate
credential = DefaultAzureCredential()
SUBSCRIPTION="<SUBSCRIPTION_ID>"
RESOURCE_GROUP="<RESOURCE_GROUP>"
WS_NAME="<AML_WORKSPACE_NAME>"
# Get a handle to the workspace
ml_client = MLClient(
credential=credential,
subscription_id=SUBSCRIPTION,
resource_group_name=RESOURCE_GROUP,
workspace_name=WS_NAME,
)
Feljegyzés
Az MLClient létrehozása nem fog csatlakozni a munkaterülethez. Az ügyfél inicializálása lusta, az első alkalommal várakozik, amikor hívást kell kezdeményeznie (ez a következő kódcellában történik).
# Verify that the handle works correctly.
# If you ge an error here, modify your SUBSCRIPTION, RESOURCE_GROUP, and WS_NAME in the previous cell.
ws = ml_client.workspaces.get(WS_NAME)
print(ws.location,":", ws.resource_group)
Feladatkörnyezet létrehozása
Az Azure Machine Tanulás feladat számítási erőforráson való futtatásához környezetre van szükség. A környezet felsorolja azokat a szoftveres futtatókörnyezeteket és kódtárakat, amelyeket telepíteni szeretne a számításra, ahol betanítást fog végezni. Hasonló a helyi gépen lévő Python-környezethez.
Az Azure Machine Tanulás számos válogatott vagy kész környezetet biztosít, amelyek hasznosak a gyakori betanítási és következtetési forgatókönyvekhez.
Ebben a példában egy egyéni Conda-környezetet fog létrehozni a feladatokhoz egy conda yaml-fájl használatával.
Először hozzon létre egy könyvtárat a fájl tárolásához.
import os
dependencies_dir = "./dependencies"
os.makedirs(dependencies_dir, exist_ok=True)
Az alábbi cella az IPython magic használatával írja be a conda fájlt az imént létrehozott könyvtárba.
%%writefile {dependencies_dir}/conda.yaml
name: model-env
channels:
- conda-forge
dependencies:
- python=3.8
- numpy=1.21.2
- pip=21.2.4
- scikit-learn=1.0.2
- scipy=1.7.1
- pandas>=1.1,<1.2
- pip:
- inference-schema[numpy-support]==1.3.0
- mlflow==2.8.0
- mlflow-skinny==2.8.0
- azureml-mlflow==1.51.0
- psutil>=5.8,<5.9
- tqdm>=4.59,<4.60
- ipykernel~=6.0
- matplotlib
A specifikáció tartalmaz néhány szokásos csomagot, amelyeket a feladatban fog használni (numpy, pip).
Erre a yaml-fájlra hivatkozva hozza létre és regisztrálja ezt az egyéni környezetet a munkaterületen:
from azure.ai.ml.entities import Environment
custom_env_name = "aml-scikit-learn"
custom_job_env = Environment(
name=custom_env_name,
description="Custom environment for Credit Card Defaults job",
tags={"scikit-learn": "1.0.2"},
conda_file=os.path.join(dependencies_dir, "conda.yaml"),
image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest",
)
custom_job_env = ml_client.environments.create_or_update(custom_job_env)
print(
f"Environment with name {custom_job_env.name} is registered to workspace, the environment version is {custom_job_env.version}"
)
Betanítási feladat konfigurálása a parancsfüggvény használatával
Létrehozhat egy Azure Machine Tanulás parancsfeladatot, amely betanít egy modellt a hitel alapértelmezett előrejelzéséhez. A parancsfeladat egy betanítási szkriptet futtat egy megadott környezetben egy adott számítási erőforráson. Már létrehozta a környezetet és a számítási fürtöt. Ezután létrehozza a betanítási szkriptet. A konkrét esetben betanítja az adathalmazt, hogy egy osztályozót állítsunk elő a GradientBoostingClassifier
modell használatával.
A betanítási szkript kezeli a betanított modell adatelőkészítését, betanítását és regisztrálását. A metódus train_test_split
kezeli az adathalmaz tesztelési és betanítási adatokra való felosztását. Ebben az oktatóanyagban egy Python-betanítási szkriptet fog létrehozni.
A parancsfeladatok parancssori felületről, Python SDK-ból vagy stúdiófelületről futtathatók. Ebben az oktatóanyagban az Azure Machine Tanulás Python SDK v2 használatával fogja létrehozni és futtatni a parancsfeladatot.
Betanítási szkript létrehozása
Először hozzuk létre a betanítási szkriptet – a main.py Python-fájlt.
Először hozzon létre egy forrásmappát a szkripthez:
import os
train_src_dir = "./src"
os.makedirs(train_src_dir, exist_ok=True)
Ez a szkript kezeli az adatok előfeldolgozását, a tesztelési és betanítási adatokra való felosztását. Ezután ezeket az adatokat felhasználja egy faalapú modell betanítása és a kimeneti modell visszaadása érdekében.
Az MLFlow használatával naplózhatja a paramétereket és metrikákat a feladat során. Az MLFlow csomag lehetővé teszi, hogy nyomon kövesse az egyes Modellek Azure-beli vonatainak metrikáit és eredményeit. Az MLFlow használatával először a legjobb modellt kapjuk meg az adatainkhoz, majd az Azure Studióban tekintjük meg a modell metrikáit.
%%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_csv(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)
#Split train and test datasets
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()
Ebben a szkriptben a modell betanítása után a rendszer menti és regisztrálja a modellfájlt a munkaterületen. A modell regisztrálása lehetővé teszi, hogy a modelleket az Azure-felhőben, a munkaterületen tárolja és verziószámozza. A modell regisztrálása után az összes többi regisztrált modellt egy helyen találja meg az Azure Studióban, a modellregisztrációs adatbázisban. A modellregisztrációs adatbázis segít a betanított modellek rendszerezésében és nyomon követésében.
A parancs konfigurálása
Most, hogy rendelkezik egy szkripttel, amely képes elvégezni a besorolási feladatot, használja az általános célú parancsot , amely parancssori műveleteket futtathat. Ez a parancssori művelet lehet közvetlenül rendszerparancsok hívása vagy szkript futtatása.
Itt bemeneti változókat hozhat létre a bemeneti adatok, a felosztási arány, a tanulási sebesség és a regisztrált modellnév megadásához. A parancsszkript a következő lesz:
- Használja a korábban létrehozott környezetet – a
@latest
jelölés használatával jelezheti a környezet legújabb verzióját a parancs futtatásakor. - Konfigurálja magát a parancssori műveletet –
python main.py
ebben az esetben. A bemenetek/kimenetek a jelölésen keresztül érhetők el a${{ ... }}
parancsban. - Mivel nincs megadva számítási erőforrás, a szkript egy automatikusan létrehozott kiszolgáló nélküli számítási fürtön fog futni.
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://azuremlexamples.blob.core.windows.net/datasets/credit_card/default_of_credit_card_clients.csv",
),
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",
display_name="credit_default_prediction",
)
Feladat küldése
Itt az ideje, hogy elküldje a feladatot az Azure Machine Tanulás Studióban való futtatáshoz. Ezúttal a következőt ml_client
fogja használnicreate_or_update
: . ml_client
Egy ügyfélosztály, amely lehetővé teszi az Azure-előfizetéshez való csatlakozást a Python használatával, valamint az Azure Machine Tanulás szolgáltatásokkal való interakciót. ml_client
Lehetővé teszi a feladatok Python használatával történő elküldését.
ml_client.create_or_update(job)
Feladat kimenetének megtekintése és várakozás a feladat befejezésére
Tekintse meg a feladatot az Azure Machine Tanulás Studióban az előző cella kimenetében található hivatkozás kiválasztásával. A feladat kimenete így fog kinézni az Azure Machine Tanulás studióban. A különböző részletek, például metrikák, kimenetek stb. megismeréséhez tekintse meg a lapokat. Miután végzett, a feladat betanítás eredményeként regisztrál egy modellt a munkaterületen.
Fontos
Várjon, amíg a feladat állapota befejeződik, mielőtt visszatér ehhez a jegyzetfüzethez a folytatáshoz. A feladat futtatása 2–3 percet vesz igénybe. Ha a számítási fürt nullára van skálázva, és az egyéni környezet még mindig épül, több időt is igénybe vehet (akár 10 perc is).
A cella futtatásakor a jegyzetfüzet kimenete egy hivatkozást jelenít meg a feladat részleteinek oldalára az Azure Studióban. Másik lehetőségként a bal oldali navigációs menüBen a Feladatok lehetőséget is választhatja. A feladatok egy adott szkriptből vagy kódrészletből származó számos futtatás csoportosítását képezik. A futtatásra vonatkozó információk a feladat alatt lesznek tárolva. A részletek oldal áttekintést nyújt a feladatról, a futtatás idejéről, a létrehozásuk időpontjáról stb. A lapon lapfülek találhatók a feladat egyéb információihoz, például metrikákhoz, kimenetekhez és naplókhoz és kódhoz. Az alábbiakban a feladat részleteinek oldalán elérhető lapok láthatók:
- Áttekintés: Az áttekintés szakasz alapvető információkat tartalmaz a feladatról, beleértve az állapotát, a kezdési és befejezési időpontokat, valamint a futtatott feladat típusát
- Bemenetek: A bemeneti szakasz felsorolja a feladat bemeneteként használt adatokat és kódot. Ez a szakasz tartalmazhat adatkészleteket, szkripteket, környezeti konfigurációkat és a betanítás során használt egyéb erőforrásokat.
- Kimenetek + naplók: A Kimenetek + naplók lap a feladat futtatása közben létrehozott naplókat tartalmazza. Ez a lap segítséget nyújt a hibaelhárításhoz, ha bármi baj van a betanítási szkripttel vagy a modell létrehozásával.
- Metrikák: A Metrikák lap a modell főbb teljesítménymetrikáit mutatja be, például a betanítási pontszámot, az f1 pontszámot és a pontossági pontszámot.
Az erőforrások eltávolítása
Ha most más oktatóanyagokra szeretne továbblépni, ugorjon a Következő lépésekre.
Számítási példány leállítása
Ha most nem fogja használni, állítsa le a számítási példányt:
- A stúdió bal oldali navigációs területén válassza a Számítás lehetőséget.
- A felső lapokban válassza a Számítási példányok lehetőséget
- Válassza ki a számítási példányt a listában.
- A felső eszköztáron válassza a Leállítás lehetőséget.
Az összes erőforrás törlése
Fontos
A létrehozott erőforrások előfeltételként használhatók más Azure Machine-Tanulás oktatóanyagokhoz és útmutatókhoz.
Ha nem tervezi használni a létrehozott erőforrások egyikét sem, törölje őket, hogy ne járjon költséggel:
Az Azure Portalon válassza az Erőforráscsoportok lehetőséget a bal szélen.
A listából válassza ki a létrehozott erőforráscsoportot.
Válassza az Erőforráscsoport törlése elemet.
Adja meg az erőforráscsoport nevét. Ezután válassza a Törlés elemet.
Következő lépések
Tudnivalók a modell üzembe helyezéséről
Modell üzembe helyezése.
Ez az oktatóanyag egy online adatfájlt használt. Az adatok elérésének egyéb módjairól a következő oktatóanyagban olvashat bővebben: Adatok feltöltése, elérése és feltárása az Azure Machine-Tanulás.
Ha többet szeretne megtudni az Azure Machine Tanulás modelljeinek betanítása különböző módjairól, olvassa el az Automatizált gépi tanulás (AutoML) című témakört. Az automatizált gépi tanulás egy kiegészítő eszköz, amely csökkenti az adatelemzők által az adataikkal legjobban működő modell megtalálásával töltött időt.
Ha az oktatóanyaghoz hasonló további példákat szeretne, tekintse meg a Studio Minták szakaszát. Ezek a minták a GitHub-példák oldalán érhetők el . Ilyenek például a teljes Python-jegyzetfüzetek, amelyeket kód futtatásával és modell betanítása során ismerhet meg. A mintákból módosíthatja és futtathatja a meglévő szkripteket, beleértve a besorolást, a természetes nyelvi feldolgozást és az anomáliadetektálást.