Megosztás a következőn keresztül:

Gépi tanulási folyamatok létrehozása és futtatása az Azure Machine Learning SDK-val

  • Cikk

A KÖVETKEZŐKRE VONATKOZIK: Python SDK azureml v1

Ebből a cikkből megtudhatja, hogyan hozhat létre és futtathat gépi tanulási folyamatokat az Azure Machine Learning SDK használatával. Az ML-folyamatok használatával olyan munkafolyamatot hozhat létre, amely összefűzi a különböző ML-fázisokat. Ezután tegye közzé ezt a folyamatot későbbi hozzáféréshez vagy másokkal való megosztáshoz. Kövesse nyomon az ML-folyamatokat, hogy lássa, hogyan teljesít a modell a valós világban, és észlelje az adateltolódást. Az ML-folyamatok ideálisak kötegelt pontozási forgatókönyvekhez, különböző számítások használatával, a lépések újrahasználatával ahelyett, hogy újrafuttatják őket, és megosztanák az ML-munkafolyamatokat másokkal.

Ez a cikk nem oktatóanyag. Az első folyamat létrehozásával kapcsolatos útmutatásért tekintse meg az oktatóanyagot: Azure Machine Learning-folyamat létrehozása kötegelt pontozáshoz vagy Automatizált gépi tanulás használata Azure Machine Learning-folyamatokban Pythonban.

Bár az ML-feladatok CI/CD-automatizálásához használhat egy másik típusú, Azure Pipeline nevű folyamatot, ez a folyamattípus nem lesz tárolva a munkaterületen. Hasonlítsa össze ezeket a különböző folyamatokat.

A létrehozott ML-folyamatok láthatók az Azure Machine Learning-munkaterület tagjai számára.

Az ML-folyamatok számítási célokon futnak (lásd : Mik azok a számítási célok az Azure Machine Learningben). A folyamatok adatokat olvashatnak és írhatnak a támogatott Azure Storage-helyekre és onnan.

Ha még nincs Azure-előfizetése, kezdés előtt hozzon létre egy ingyenes fiókot. Próbálja ki az Azure Machine Learning ingyenes vagy fizetős verzióját.

Előfeltételek

Először csatolja a munkaterületet:

import azureml.core
from azureml.core import Workspace, Datastore

ws = Workspace.from_config()

Gépi tanulási erőforrások beállítása

Hozza létre az ML-folyamat futtatásához szükséges erőforrásokat:

  • Állítson be egy adattárat a folyamat lépéseiben szükséges adatok eléréséhez.

  • Konfiguráljon egy objektumot Dataset , amely egy adattárban található vagy elérhető állandó adatokra mutat. Konfiguráljon egy objektumot OutputFileDatasetConfig a folyamatlépések között átadott ideiglenes adatokhoz.

  • Állítsa be azokat a számítási célokat , amelyeken a folyamat lépései futni fognak.

Adattár beállítása

Egy adattár tárolja a folyamat eléréséhez szükséges adatokat. Minden munkaterület rendelkezik egy alapértelmezett adattárkal. További adattárakat is regisztrálhat.

A munkaterület létrehozásakor az Azure Files és az Azure Blob Storage a munkaterülethez lesz csatolva. A rendszer regisztrál egy alapértelmezett adattárat az Azure Blob Storage-hoz való csatlakozáshoz. További információ: Az Azure Files, az Azure Blobs vagy az Azure Disks használatának eldöntése.

# Default datastore 
def_data_store = ws.get_default_datastore()

# Get the blob storage associated with the workspace
def_blob_store = Datastore(ws, "workspaceblobstore")

# Get file storage associated with the workspace
def_file_store = Datastore(ws, "workspacefilestore")

A lépések általában adatokat használnak fel, és kimeneti adatokat hoznak létre. A lépések olyan adatokat hozhatnak létre, mint például egy modell, egy modell- és függő fájlokat tartalmazó könyvtár, vagy ideiglenes adatok. Ezek az adatok a folyamat későbbi szakaszaiban további lépésekhez is elérhetők. Ha többet szeretne megtudni a folyamat adatokhoz való csatlakoztatásáról, olvassa el az Adatok elérése és az Adathalmazok regisztrálása című témakört.

Adatok konfigurálása objektumokkal és OutputFileDatasetConfig objektumokkal Dataset

A folyamat adatainak elsődlegesen adathalmaz-objektumként szolgálnak. Az Dataset objektum olyan adatokra mutat, amelyek egy adattárban vagy egy webes URL-címen találhatók vagy érhetők el. Az Dataset osztály absztrakt, ezért egy (egy vagy több fájlra hivatkozó) vagy TabularDataset egy vagy több, tagolt adatoszlopokkal rendelkező fájlból létrehozott példányt FileDataset fog létrehozni.

Olyan metódusokat Dataset hozhat létre, mint a from_files vagy a from_delimited_files.

from azureml.core import Dataset

my_dataset = Dataset.File.from_files([(def_blob_store, 'train-images/')])

A köztes adatokat (vagy egy lépés kimenetét) egy OutputFileDatasetConfig objektum jelöli. output_data1 egy lépés kimeneteként jön létre. Igény szerint ezek az adatok regisztrálhatók adathalmazként a hívással register_on_complete. Ha egy lépésben hoz létre egy OutputFileDatasetConfig lépést, és egy másik lépés bemeneteként használja, a lépések közötti adatfüggőség implicit végrehajtási sorrendet hoz létre a folyamatban.

OutputFileDatasetConfig az objektumok egy könyvtárat ad vissza, és alapértelmezés szerint a kimenetet a munkaterület alapértelmezett adattárába írja.

from azureml.data import OutputFileDatasetConfig

output_data1 = OutputFileDatasetConfig(destination = (datastore, 'outputdataset/{run-id}'))
output_data_dataset = output_data1.register_on_complete(name = 'prepared_output_data')

Fontos

A használatával OutputFileDatasetConfig tárolt köztes adatokat az Azure nem törli automatikusan. A folyamatfuttatás végén programozott módon törölje a köztes adatokat, használjon egy rövid adatmegőrzési szabályzattal rendelkező adattárat, vagy rendszeresen végezze el a manuális törlést.

Tipp.

Csak az adott feladathoz kapcsolódó fájlokat töltsön fel. Az adatkönyvtárban található fájlok minden változása okként jelenik meg a lépés ismételt futtatásához a folyamat következő futtatásakor még akkor is, ha az ismételt használat meg lett adva.

Számítási cél beállítása

Az Azure Machine Learningben a számítás (vagy számítási cél) kifejezés azokra a gépekre vagy fürtökre vonatkozik, amelyek a gépi tanulási folyamat számítási lépéseit hajtják végre. A számítási célok modellbetanítását a számítási célok teljes listájához, valamint a számítási célok létrehozásához és a munkaterülethez való csatolásához tekintse meg. A számítási cél létrehozásának és csatolásának folyamata ugyanaz, akár modell betanítása, akár folyamatlépés futtatása. A számítási cél létrehozása és csatolása után használja az ComputeTarget objektumot a folyamatlépésben.

Fontos

A számítási célokon végzett felügyeleti műveletek távoli feladatokon belül nem támogatottak. Mivel a gépi tanulási folyamatokat távoli feladatként küldi el a rendszer, ne használjon a számítási célokra irányuló felügyeleti műveleteket a folyamatból.

Azure Machine Learning-számítás

Létrehozhat egy Azure Machine Learning-számítást a lépések futtatásához. Más számítási célok kódja hasonló, a típustól függően kissé eltérő paraméterekkel.

from azureml.core.compute import ComputeTarget, AmlCompute

compute_name = "aml-compute"
vm_size = "STANDARD_NC6"
if compute_name in ws.compute_targets:
    compute_target = ws.compute_targets[compute_name]
    if compute_target and type(compute_target) is AmlCompute:
        print('Found compute target: ' + compute_name)
else:
    print('Creating a new compute target...')
    provisioning_config = AmlCompute.provisioning_configuration(vm_size=vm_size,  # STANDARD_NC6 is GPU-enabled
                                                                min_nodes=0,
                                                                max_nodes=4)
    # create the compute target
    compute_target = ComputeTarget.create(
        ws, compute_name, provisioning_config)

    # Can poll for a minimum number of nodes and for a specific timeout.
    # If no min node count is provided it will use the scale settings for the cluster
    compute_target.wait_for_completion(
        show_output=True, min_node_count=None, timeout_in_minutes=20)

    # For a more detailed view of current cluster status, use the 'status' property
    print(compute_target.status.serialize())

A betanítási futtatás környezetének konfigurálása

A következő lépés annak biztosítása, hogy a távoli betanítási futtatás rendelkezik a betanítási lépésekhez szükséges összes függőségsel. A függőségek és a futtatókörnyezet egy RunConfiguration objektum létrehozásával és konfigurálásával állíthatók be.

from azureml.core.runconfig import RunConfiguration
from azureml.core.conda_dependencies import CondaDependencies
from azureml.core import Environment 

aml_run_config = RunConfiguration()
# `compute_target` as defined in "Azure Machine Learning compute" section above
aml_run_config.target = compute_target

USE_CURATED_ENV = True
if USE_CURATED_ENV :
    curated_environment = Environment.get(workspace=ws, name="AzureML-sklearn-0.24-ubuntu18.04-py37-cpu")
    aml_run_config.environment = curated_environment
else:
    aml_run_config.environment.python.user_managed_dependencies = False
    
    # Add some packages relied on by data prep step
    aml_run_config.environment.python.conda_dependencies = CondaDependencies.create(
        conda_packages=['pandas','scikit-learn'], 
        pip_packages=['azureml-sdk', 'azureml-dataset-runtime[fuse,pandas]'], 
        pin_sdk_version=False)

A fenti kód két lehetőséget mutat a függőségek kezelésére. A bemutatott USE_CURATED_ENV = Truemódon a konfiguráció egy válogatott környezeten alapul. A válogatott környezetek "előre vannak adva" a közös, egymástól függő kódtárakkal, és gyorsabbak lehetnek az online használathoz. A válogatott környezetek előre összeállított Docker-rendszerképekkel rendelkeznek a Microsoft Container Registryben. További információkért lásd az Azure Machine Learning válogatott környezeteit.

A függőségek explicit beállítására szolgáló minta megjelenítésekor USE_CURATED_ENV False megadott elérési út. Ebben a forgatókönyvben egy új egyéni Docker-rendszerkép jön létre és regisztrálva lesz egy Azure Container Registryben az erőforráscsoporton belül (lásd: Bevezetés a privát Docker-tárolóregisztrációs adatbázisokba az Azure-ban). A kép létrehozása és regisztrálása eltarthat néhány percig.

A folyamat lépéseinek létrehozása

Miután létrehozta a számítási erőforrást és a környezetet, készen áll a folyamat lépéseinek meghatározására. Az Azure Machine Learning SDK-n keresztül számos beépített lépés érhető el, ahogy a csomag referenciadokumentációjában azureml.pipeline.steps is látható. A legrugalmasabb osztály a PythonScriptStep, amely Python-szkriptet futtat.

from azureml.pipeline.steps import PythonScriptStep
dataprep_source_dir = "./dataprep_src"
entry_point = "prepare.py"
# `my_dataset` as defined above
ds_input = my_dataset.as_named_input('input1')

# `output_data1`, `compute_target`, `aml_run_config` as defined above
data_prep_step = PythonScriptStep(
    script_name=entry_point,
    source_directory=dataprep_source_dir,
    arguments=["--input", ds_input.as_download(), "--output", output_data1],
    compute_target=compute_target,
    runconfig=aml_run_config,
    allow_reuse=True
)

A fenti kód egy tipikus kezdeti folyamatlépést mutat be. Az adatelőkészítési kód egy alkönyvtárban található (ebben a példában "prepare.py" a könyvtárban "./dataprep.src"). A folyamatlétrehozás folyamatának részeként a könyvtár tömörítve lesz, és fel lesz töltve a compute_target mappába, és a lépés a megadott szkriptet futtatja a következő értékként script_name: .

Az arguments értékek határozzák meg a lépés bemeneteit és kimeneteit. A fenti példában az alapadatok az my_dataset adathalmaz. A megfelelő adatok le lesznek töltve a számítási erőforrásba, mivel a kód a következőképpen határozza meg azokat as_download(). A szkript prepare.py minden adatátalakítási feladatot végrehajt, amely megfelel az adott feladatnak, és az adatokat output_data1típus szerint OutputFileDatasetConfigadja ki. További információ: Adatok áthelyezése az ML-folyamat lépéseibe és között (Python). A lépés a konfigurációval compute_targetaml_run_configmeghatározott gépen fog futni.

A korábbi eredmények (allow_reuse) újrafelhasználása kulcsfontosságú a folyamatok együttműködésen alapuló környezetben történő használatakor, mivel a szükségtelen újrafuttatások kiküszöbölése rugalmasságot biztosít. Az újrafelhasználás az alapértelmezett viselkedés, ha a script_name, a bemenetek és a lépés paraméterei változatlanok maradnak. Ha az újrahasználat engedélyezett, a rendszer azonnal elküldi az előző futtatás eredményeit a következő lépésre. Ha allow_reuse be van állítva False, a folyamat végrehajtása során mindig létrejön egy új futtatás ehhez a lépéshez.

Létrehozhat egy folyamatot egyetlen lépéssel, de szinte mindig úgy dönt, hogy a teljes folyamatot több lépésre osztja. Előfordulhat például, hogy rendelkezik az adatok előkészítésének, betanításának, a modell összehasonlításának és üzembe helyezésének lépéseivel. Tegyük fel például, hogy a fentiek után a data_prep_step következő lépés a betanítás:

train_source_dir = "./train_src"
train_entry_point = "train.py"

training_results = OutputFileDatasetConfig(name = "training_results",
    destination = def_blob_store)

    
train_step = PythonScriptStep(
    script_name=train_entry_point,
    source_directory=train_source_dir,
    arguments=["--prepped_data", output_data1.as_input(), "--training_results", training_results],
    compute_target=compute_target,
    runconfig=aml_run_config,
    allow_reuse=True
)

A fenti kód hasonló az adatelőkészítési lépésben szereplő kódhoz. A betanítási kód az adatelőkészítési kódtól eltérő könyvtárban található. Az OutputFileDatasetConfig adatelőkészítési lépés output_data1 kimenete a betanítási lépés bemenete. Létrejön egy új OutputFileDatasetConfig objektum, training_results amely egy későbbi összehasonlítási vagy üzembe helyezési lépés eredményeit tárolja.

További példakódokért tekintse meg, hogyan hozhat létre kétlépéses ML-folyamatot , és hogyan írhat vissza adatokat az adattárakba a futtatás befejezésekor.

A lépések definiálása után néhány vagy az összes lépéssel elkészítheti a folyamatot.

Feljegyzés

A lépések meghatározásakor vagy a folyamat létrehozásakor a rendszer nem tölt fel fájlokat vagy adatokat az Azure Machine Learningbe. A fájlok feltöltése az Experiment.submit() hívásakor történik.

# list of steps to run (`compare_step` definition not shown)
compare_models = [data_prep_step, train_step, compare_step]

from azureml.pipeline.core import Pipeline

# Build the pipeline
pipeline1 = Pipeline(workspace=ws, steps=[compare_models])

Adatkészlet használata

Az Azure Blob Storage, az Azure Files, az Azure Data Lake Storage Gen1, az Azure Data Lake Storage Gen2, az Azure SQL Database és az Azure Database for PostgreSQL-ből létrehozott adatkészletek bármely folyamatlépés bemeneteként használhatók. Írhat kimenetet DataTransferStepbe, DatabricksStepbe, vagy ha adatokat szeretne írni egy adott adattárba az OutputFileDatasetConfig használatával.

Fontos

A kimeneti adatoknak az adattárba a OutputFileDatasetConfig használatával történő visszaírása csak az Azure-blobok, az Azure-fájlmegosztás, valamint az ADLS Gen 1 és Gen 2 adattárai esetén támogatott.

dataset_consuming_step = PythonScriptStep(
    script_name="iris_train.py",
    inputs=[iris_tabular_dataset.as_named_input("iris_data")],
    compute_target=compute_target,
    source_directory=project_folder
)

Ezután a Run.input_datasets szótár használatával lekéri a folyamat adatkészletét.

# iris_train.py
from azureml.core import Run, Dataset

run_context = Run.get_context()
iris_dataset = run_context.input_datasets['iris_data']
dataframe = iris_dataset.to_pandas_dataframe()

A sort Run.get_context() érdemes kiemelni. Ez a függvény lekéri Run az aktuális kísérleti futtatásnak egy reprezentáló elemét. A fenti mintában egy regisztrált adatkészlet lekérésére használjuk. Az objektum egy másik gyakori használata Run a kísérlet lekérése, és a munkaterület, amelyben a kísérlet található:

# Within a PythonScriptStep

ws = Run.get_context().experiment.workspace

További részletekért, beleértve az adatok átadásának és elérésének alternatív módjait, olvassa el az Adatok áthelyezése az ML-folyamat lépéseibe és között (Python) című témakört.

Gyorsítótárazás és újrafelhasználás

A folyamatok viselkedésének optimalizálásához és testreszabásához végezhet néhány dolgot a gyorsítótárazás és az újrafelhasználás körül. Megteheti például a következőket:

  • Kapcsolja ki a lépésfuttatás kimenetének alapértelmezett újrafelhasználását a lépésdefiníció beállításával allow_reuse=False . Az újrahasználat kulcsfontosságú a folyamatok együttműködésen alapuló környezetben való használatakor, mivel a szükségtelen futtatások kiküszöbölése rugalmasságot biztosít. Azonban kikapcsolhatja az újrahasználatot.
  • Kimeneti regeneráció kényszerítése a futtatás minden lépéséhez a következővel : pipeline_run = exp.submit(pipeline, regenerate_outputs=True)

Alapértelmezés szerint a lépések engedélyezve vannak, allow_reuse és a source_directory lépésdefinícióban megadott kivonat. Ha tehát egy adott lépés szkriptje ugyanaz marad (script_namebemenetek és paraméterek), és semmi más nem változott az előző lépésben source_directory , az előző lépés kimenete újra felhasználható, a feladat nem lesz elküldve a számítási feladatnak, és az előző futtatás eredményei azonnal elérhetők lesznek a következő lépésben.

step = PythonScriptStep(name="Hello World",
                        script_name="hello_world.py",
                        compute_target=aml_compute,
                        source_directory=source_directory,
                        allow_reuse=False,
                        hash_paths=['hello_world.ipynb'])

Feljegyzés

Ha az adatbemenetek neve megváltozik, a lépés újrafut, még akkor is, ha a mögöttes adatok nem változnak. Explicit módon kell beállítania a name bemeneti adatok mezőjét (data.as_input(name=...)). Ha nem állítja be explicit módon ezt az értéket, a name mező véletlenszerű guid értékre lesz állítva, és a lépés eredményei nem lesznek újra felhasználhatók.

A folyamat elküldése

A folyamat elküldésekor az Azure Machine Learning ellenőrzi az egyes lépések függőségeit, és feltölt egy pillanatképet a megadott forráskönyvtárról. Ha nincs megadva forráskönyvtár, a rendszer feltölti az aktuális helyi könyvtárat. A pillanatképet a munkaterületen található kísérlet részeként is tárolja a rendszer.

Fontos

Ha meg szeretné akadályozni, hogy a szükségtelen fájlok bekerüljenek a pillanatképbe, hozzon létre egy figyelmen kívül hagyott fájlt (.gitignore vagy .amlignore) a könyvtárban. Adja hozzá a kizárni kívánt fájlokat és könyvtárakat ehhez a fájlhoz. A fájlban használandó szintaxissal kapcsolatos további információkért lásd a szintaxist és a minták helyét .gitignore. A .amlignore fájl ugyanazt a szintaxist használja. Ha mindkét fájl létezik, a rendszer a .amlignore fájlt használja, és a .gitignore fájl nincs használatban.

További információ: Pillanatképek.

from azureml.core import Experiment

# Submit the pipeline to be run
pipeline_run1 = Experiment(ws, 'Compare_Models_Exp').submit(pipeline1)
pipeline_run1.wait_for_completion()

Amikor először futtat egy folyamatot, az Azure Machine Learning:

  • Letölti a projekt pillanatképét a számítási célra a munkaterülethez társított Blob Storage-ból.

  • A folyamat minden lépésének megfelelő Docker-rendszerképet hoz létre.

  • Letölti az egyes lépések Docker-rendszerképét a számítási célhoz a tárolóregisztrációs adatbázisból.

  • Konfigurálja a Dataset hozzáférést és OutputFileDatasetConfig az objektumokat. Hozzáférési mód esetén as_mount() a FUSE a virtuális hozzáférés biztosítására szolgál. Ha a csatlakoztatás nem támogatott, vagy ha a felhasználó a hozzáférést a as_upload()következőképpen adta meg, a rendszer ehelyett a számítási célba másolja az adatokat.

  • A lépést a lépésdefinícióban megadott számítási célban futtatja.

  • Olyan összetevőket hoz létre, mint a naplók, az stdout és az stderr, a metrikák és a lépés által megadott kimenet. Ezeket az összetevőket ezután a rendszer feltölti és megőrzi a felhasználó alapértelmezett adattárában.

Kísérlet folyamatként való futtatásának diagramja

További információ: Kísérletosztály referenciája.

Folyamatparaméterek használata következtetési időpontban változó argumentumokhoz

Előfordulhat, hogy a folyamat egyes lépéseinek argumentumai a fejlesztési és betanítási időszakhoz kapcsolódnak: például a betanítási arányokhoz és a lendülethez, vagy az adatok vagy konfigurációs fájlok elérési útjaihoz. A modell üzembe helyezésekor azonban dinamikusan át kell adnia azokat az argumentumokat, amelyekre következtetni szeretne (vagyis a modellre válaszként létrehozott lekérdezést!). Ezeket az argumentumtípusokat folyamatparaméterekként kell megadnia. Ehhez használja az osztályt a azureml.pipeline.core.PipelineParameter Pythonban az alábbi kódrészletben látható módon:

from azureml.pipeline.core import PipelineParameter

pipeline_param = PipelineParameter(name="pipeline_arg", default_value="default_val")
train_step = PythonScriptStep(script_name="train.py",
                            arguments=["--param1", pipeline_param],
                            target=compute_target,
                            source_directory=project_folder)

A Python-környezetek működése folyamatparaméterekkel

A betanítási futtatás környezetének konfigurálása, a környezet állapota és a Python-kódtár függőségei objektum Environment használatával vannak megadva. Egy meglévőt Environment általában a nevére és egy verzióra hivatkozva adhat meg:

aml_run_config = RunConfiguration()
aml_run_config.environment.name = 'MyEnvironment'
aml_run_config.environment.version = '1.0'

Ha azonban úgy dönt, hogy PipelineParameter objektumokkal dinamikusan állítja be a változókat futásidőben a folyamat lépéseihez, akkor nem használhatja ezt a módszert egy meglévőre Environmentvaló hivatkozáshoz. Ehelyett, ha objektumokat szeretne használni PipelineParameter , a environment mező értékét RunConfiguration egy Environment objektumra kell állítania. Az Ön felelőssége annak biztosítása, hogy az Environment ilyen csomagok megfelelően legyenek beállítva a külső Python-csomagoktól.

Folyamat eredményeinek megtekintése

Tekintse meg az összes folyamat listáját és azok futtatási részleteit a studióban:

  1. Jelentkezzen be az Azure Machine Learning Studióba.

  2. A munkaterület megtekintése.

  3. A bal oldalon válassza a Folyamatok lehetőséget az összes folyamatfuttatás megtekintéséhez. gépi tanulási folyamatok listája

  4. Válasszon ki egy adott folyamatot a futtatási eredmények megtekintéséhez.

Git nyomon követése és integrációja

Amikor elindít egy betanítási futtatásokat, ahol a forráskönyvtár egy helyi Git-adattár, a rendszer a futtatási előzményekben tárolja az adattár adatait. További információ: Git-integráció az Azure Machine Learninghez.

Következő lépések