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

Mi az a Pythonhoz készült Azure Machine Learning SDK?

  • Cikk

Az adattudósok és AI-fejlesztők a Pythonhoz készült Azure Machine Learning SDK-t használják gépi tanulási munkafolyamatok létrehozására és futtatására az Azure Machine Learning szolgáltatással. A szolgáltatást bármilyen Python-környezetben használhatja, beleértve a Jupyter Notebooksot, a Visual Studio Code-ot vagy a kedvenc Python IDE-ét.

Az SDK legfontosabb területei:

  • A gépi tanulási kísérletekben használt adathalmazok életciklusának áttekintése, előkészítése és felügyelete.
  • Felhőbeli erőforrások kezelése a gépi tanulási kísérletek monitorozásához, naplózásához és rendszerezéséhez.
  • A modelleket helyileg vagy felhőalapú erőforrásokkal, például GPU-gyorsítással rendelkező modellbetanítással is betaníthatja.
  • Használjon automatizált gépi tanulást, amely konfigurációs paramétereket és betanítási adatokat fogad el. Ez a megoldás algoritmusok és hiperparaméter-beállítások automatikus iterációjával keresi meg az előrejelzések futtatásához legalkalmasabb modellt.
  • A webszolgáltatások üzembe helyezésével a betanított modelleket olyan RESTful szolgáltatásokká konvertálhatja, amelyek bármely alkalmazásban felhasználhatók.

Az első lépések lépésenkénti útmutatóját a kapcsolódó oktatóanyagban találja.

Az alábbi szakaszok az SDK legfontosabb osztályairól, illetve a használatukhoz kapcsolódó, általános tervezési mintákról nyújtanak áttekintést. Az SDK beszerzésének módját lásd a telepítési útmutatóban.

Stabil vagy kísérleti

A Pythonhoz készült Azure Machine Learning SDK stabil és kísérleti funkciókat is biztosít ugyanabban az SDK-ban.

Funkció/képesség állapota Description
Stabil funkciók Éles üzemre kész

Ezek a funkciók a legtöbb használati esetben és éles környezetben ajánlottak. Ezeket ritkábban frissítik, mint a kísérleti funkciókat.
Kísérleti funkciók Fejlődési

Ezek a funkciók olyan újonnan fejlesztett képességek, & frissítések, amelyek nem feltétlenül állnak készen vagy nem tesztelhetők teljes mértékben éles használatra. Bár a funkciók általában működőképesek, néhány kompatibilitástörő változást is tartalmazhatnak. A kísérleti funkciók az SDK kompatibilitástörő hibáinak kivédésére szolgálnak, és csak a tesztelési időszak alatt kapnak frissítéseket. A kísérleti funkciókat előzetes verziójú funkcióknak is nevezik.

Ahogy a neve is mutatja, a kísérleti (előzetes verzió) funkciók kísérletezéshez használhatók, és nem tekinthetők hibamentesnek vagy stabilnak. Ezért csak azoknak a haladó felhasználóknak ajánljuk a kísérleti funkciókat, akik szeretnék kipróbálni a képességek és frissítések korai verzióit, és részt kívánnak venni a hibák és hibák jelentésében.

A kísérleti funkciókat az SDK-referencia megjegyzés szakasza jelöli, és az Azure Machine Learning dokumentációjában például (előzetes verzió) szövegként jelöli.

Munkaterület

Névtér: azureml.core.workspace.Workspace

A Workspace osztály alapvető fontosságú felhőbeli erőforrás a gépi tanulási modellekkel való kísérletezéshez, illetve azok betanításához és üzembe helyezéséhez. Ez az Ön által használt Azure-előfizetést és -erőforráscsoportot egy egyszerűen használható objektumhoz kapcsolja.

Tekintse meg a Create Workspace metódus összes paraméterét a meglévő példányok (Storage, Key Vault, App-Insights és Azure Container Registry-ACR) újrafelhasználásához, valamint további beállítások, például a privát végpont konfigurációjának és a számítási célnak a módosításához.

Az alábbi kóddal importálhatja az osztályt és létrehozhat egy új munkaterületet. A create_resource_group értéke legyen False, ha már rendelkezik egy meglévő Azure-erőforráscsoporttal, amelyet a munkaterület esetében használni szeretne. Egyes függvények hitelesítő adatokat kérhetnek az Azure-beli hitelesítéshez.

from azureml.core import Workspace
ws = Workspace.create(name='myworkspace',
                      subscription_id='<azure-subscription-id>',
                      resource_group='myresourcegroup',
                      create_resource_group=True,
                      location='eastus2'
                     )

Ugyanazt a munkaterületet több környezetben is használhatja, ha először egy konfigurációs JSON-fájlba írja. Ezzel elmentheti az előfizetés, az erőforrás és a munkaterület nevének adatait.

ws.write_config(path="./file-path", file_name="ws_config.json")

A konfigurációs fájl beolvasásával töltheti be a munkaterületet.

from azureml.core import Workspace
ws_other_environment = Workspace.from_config(path="./file-path/ws_config.json")

Azt is megteheti, hogy a statikus get() metódus használatával betölt egy meglévő munkaterületet a konfigurációs fájlok használata nélkül.

from azureml.core import Workspace
ws = Workspace.get(name="myworkspace", subscription_id='<azure-subscription-id>', resource_group='myresourcegroup')

Az alábbi kódpéldákban a ws változó egy Workspace objektumot jelképez.

Experiment

Névtér: azureml.core.experiment.Experiment

Az Experiment osztály egy további alapvető fontosságú felhőbeli erőforrás, amely a próbaverziók (egyedi modellfuttatások) gyűjteményét jelöli. Az alábbi kód egy Experiment objektumot kér le a Workspace osztályból név alapján, vagy új Experiment objektumot hoz létre, ha a név nem létezik.

from azureml.core.experiment import Experiment
experiment = Experiment(workspace=ws, name='test-experiment')

Futtassa az alábbi kódot a Workspace osztály összes Experiment objektuma listájának lekéréséhez.

list_experiments = Experiment.list(ws)

A get_runs függvénnyel Run objektumok (próbaverziók) listáját kérdezheti le a következőből: Experiment. Az alábbi kód lekérdezi a futtatásokat, majd megjeleníti az egyes futtatások azonosítóit.

list_runs = experiment.get_runs()
for run in list_runs:
    print(run.id)

A kísérletet kétféleképpen futtathatja. Ha interaktív módon kísérletezik egy Jupyter notebookban, használja a start_logging függvényt. Ha standard Python-környezetből küld el egy kísérletet, használja a submit függvényt. Mindkét függvény Run objektumot ad vissza. Az alábbi kódpéldákban az experiment változó egy Experiment objektumot jelképez.

Futtatás

Névtér: azureml.core.run.Run

A futtatások egy-egy kísérletnek felelnek meg. Run az az objektum, amelyet a próba aszinkron végrehajtásának monitorozására, a próba kimenetének tárolására, az eredmények elemzésére és a létrehozott összetevők elérésére használ. A kísérleti kódban a Run objektumot a metrikák és az összetevők naplózására használhatja a futtatási előzmények szolgáltatásba. Az elérhető funkciók:

  • Metrikák és adatok tárolása és lekérdezése.
  • Címkék és gyermekhierarchia használata a korábbi futtatások egyszerű kereséséhez.
  • A tárolt modell fájljainak regisztrálása az üzembe helyezéshez.
  • Futtatási tulajdonságok tárolása, módosítása és lekérdezése.

Hozzon létre egy Run objektumot egy Experiment objektum futtatási konfigurációs objektummal együtt való elküldésével. Használja a tags paramétert egyéni kategóriák és címkék csatolásához a futtatásokhoz. A későbbiekben egyszerűen megkeresheti és lekérheti őket az Experiment osztályból.

tags = {"prod": "phase-1-model-tests"}
run = experiment.submit(config=your_config_object, tags=tags)

Használja a statikus list függvényt az Experiment osztály összes Run objektuma listájának lekéréséhez. Adja meg a tags paramétert a korábban létrehozott címkék szűréséhez.

from azureml.core.run import Run
filtered_list_runs = Run.list(experiment, tags=tags)

Használja a get_details függvényt a futtatás részletes kimenetének lekérdezéséhez.

run_details = run.get_details()

E függvény esetében a kimenet egy olyan könyvtár, amely a következőket tartalmazza:

  • Futtatási azonosító
  • Állapot
  • Kezdési és befejezési időpont
  • Számítási cél (helyi vagy felhőbeli)
  • A futtatás során használt függőségek és verziók
  • Képzésspecifikus adatok (a modell típusától függően eltérőek)

A futtatások konfigurálásával és monitorozásával kapcsolatban további példákat az útmutatóban talál.

Modellezés

Névtér: azureml.core.model.Model

A Model osztály a gépi tanulási modellek felhőbeli megfelelőivel való munkavégzéshez használatos. Olyan metódusok, amelyek segítségével modelleket vihet át a helyi fejlesztői környezet és a felhőbeli Workspace objektum között.

A modell regisztrálását követően a modelleket az Azure-felhőben tárolhatja és verziószámozhatja a saját munkaterületén. A regisztrált modelleket a név és a verziószám azonosítja. Ha egy modellt egy már létező néven regisztrál, a beállításjegyzék megnöveli annak verziószámát. Az Azure Machine Learning támogatja a Python 3-on keresztül betölthető modelleket, nem csak az Azure Machine Learning-modelleket.

Az alábbi példa bemutatja egy egyszerű helyi besorolási modell létrehozását scikit-learn használatával, regisztrálja a modellt a Workspace osztályban, és letölti a modellt a felhőből.

Hozzon létre egy egyszerű osztályozót (clf) az ügyfél-lemorzsolódás kor alapján történő előrejelzéséhez. Ezután állítsa vissza a modellt a biztonsági másolatból egy .pkl fájlba ugyanebben a könyvtárban.

from sklearn import svm
import joblib
import numpy as np

# customer ages
X_train = np.array([50, 17, 35, 23, 28, 40, 31, 29, 19, 62])
X_train = X_train.reshape(-1, 1)
# churn y/n
y_train = ["yes", "no", "no", "no", "yes", "yes", "yes", "no", "no", "yes"]

clf = svm.SVC(gamma=0.001, C=100.)
clf.fit(X_train, y_train)

joblib.dump(value=clf, filename="churn-model.pkl")

Regisztrálja a függvényt a munkaterületen a register függvény használatával. Adja meg a modell helyi elérési útját és a modell nevét. Ha egynél többször regisztrálja ugyanazt a modellt, azzal egy új verziót fog létrehozni.

from azureml.core.model import Model

model = Model.register(workspace=ws, model_path="churn-model.pkl", model_name="churn-model-test")

Most, hogy regisztrálta a modellt a munkaterületen, egyszerűen kezelheti, töltheti le és rendszerezheti a modelleket. Ha a Workspace munkaterületről szeretne lekérni egy modellobjektumot (amely például másik környezetben található), használja az osztálykonstruktort a modell nevének és az esetleges opcionális paraméterek megadásához. Ezután a download függvénnyel töltse le a modellt, a felhőbeli mappastruktúrával együtt.

from azureml.core.model import Model
import os

model = Model(workspace=ws, name="churn-model-test")
model.download(target_dir=os.getcwd())

A delete függvény használatával távolítsa el a modellt a Workspace munkaterületről.

model.delete()

Most, hogy regisztrálta a modellt, annak webalkalmazásként való üzembe helyezése egyszerű folyamat. Először hozzon létre és regisztráljon egy rendszerképet. Ez a lépés konfigurálja a Python-környezetet és annak függőségeit, valamint egy szkriptet, amely meghatározza a webszolgáltatási kérések és válaszok formátumát. A rendszerkép létrehozása után hozzon létre egy üzembehelyezési konfigurációt, amely meghatározza a processzormagokat és a memóriaparamétereket a számítási cél esetében. Ezután csatolja a rendszerképet.

ComputeTarget, RunConfiguration és ScriptRunConfig

Névtér: azureml.core.compute.ComputeTarget
Névtér: azureml.core.runconfig.RunConfiguration
Névtér: azureml.core.script_run_config.ScriptRunConfig

A ComputeTarget osztály a számítási célok létrehozásának és kezelésének absztrakt szülőosztálya. Számítási cél alatt különböző olyan erőforrásokat értünk, ahol gépi tanulási modelleket taníthat be. Számítási cél lehet egy helyi gép vagy felhőerőforrás, például az Azure Machine Learning Compute, az Azure HDInsight vagy egy távoli virtuális gép.

Számítási célok használatával kihasználhatja a virtuális gépek hatékonyságát a modellek betanítása terén, továbbá beállíthat állandó számítási célokat és ideiglenes, futtatókörnyezet által meghívott célokat is. A számítási célok beállításának és kezelésének átfogó ismertetését az útmutatóban találja.

Az alábbi kód egyszerű példát mutat egy AmlCompute cél (a ComputeTarget gyermekosztályának) beállítására. Ez a cél egy távoli, futásidejű számítási erőforrást hoz létre a Workspace objektumban. Feladat elküldésekor az erőforrás automatikusan elvégzi a skálázást. A futtatás végeztével az erőforrás automatikusan törlődik.

Használja ismét az egyszerű scikit-learn lemorzsolódási modellt, és buildelje azt a saját fájljába (train.py) az aktuális könyvtárban. A fájl buildelését követően hozzon létre egy új könyvtárat outputs néven. Ez a lépés létrehoz egy könyvtárat a felhőben (a munkaterületen) a joblib.dump() által szerializált, betanított modell tárolásához.

# train.py

from sklearn import svm
import numpy as np
import joblib
import os

# customer ages
X_train = np.array([50, 17, 35, 23, 28, 40, 31, 29, 19, 62])
X_train = X_train.reshape(-1, 1)
# churn y/n
y_train = ["yes", "no", "no", "no", "yes", "yes", "yes", "no", "no", "yes"]

clf = svm.SVC(gamma=0.001, C=100.)
clf.fit(X_train, y_train)

os.makedirs("outputs", exist_ok=True)
joblib.dump(value=clf, filename="outputs/churn-model.pkl")

Ezután létrehoz a számítási célt egy RunConfiguration objektum példányosításával, valamint a típus és a méret beállításával. Ez a példa a legkisebb erőforrásméretet (1 processzormag, 3,5 GB memória) használja. A list_vms változó tartalmazza a támogatott virtuális gépek és azok méreteinek listáját.

from azureml.core.runconfig import RunConfiguration
from azureml.core.compute import AmlCompute
list_vms = AmlCompute.supported_vmsizes(workspace=ws)

compute_config = RunConfiguration()
compute_config.target = "amlcompute"
compute_config.amlcompute.vm_size = "STANDARD_D1_V2"

Hozza létre a távoli számítási erőforrás Python-környezetének függőségeit a CondaDependencies osztály használatával. A train.py fájl a scikit-learn és a numpy függvényeket használja, amelyeknek telepítve kell lenniük a környezetben. Lehetőség van függőségverziók megadására is. A dependencies objektumot használja a környezet beállítására a compute_config esetében.

from azureml.core.conda_dependencies import CondaDependencies

dependencies = CondaDependencies()
dependencies.add_pip_package("scikit-learn")
dependencies.add_pip_package("numpy==1.15.4")
compute_config.environment.python.conda_dependencies = dependencies

Most már készen áll a kísérlet elküldésére. A ScriptRunConfig osztály használatával csatolja a számítási cél konfigurációját, és adja meg a train.py betanítási szkripthez tartozó elérési útvonalat vagy fájlt. Küldje el a kísérletet a submit() függvény config paraméterének megadásával. Az eredményül kapott futtatás esetében hívja meg a wait_for_completion függvényt az aszinkron futtatási kimenet megtekintéséhez, ha a környezet inicializálása és a modell betanítása megtörtént.

Figyelmeztetés

Az alábbiakban a paraméterekben ScriptRunConfig használt konkrét karakterekre vonatkozó korlátozásokat ismertetjük:

  • A ", $, ;és \ karaktereket a háttér feloldja, mivel fenntartott karaktereknek minősülnek a Bash-parancsok elválasztására.
  • A (, ), %, !, ^, <>, &, és | karakterek feloldódnak a windowsos helyi futtatásokhoz.
from azureml.core.experiment import Experiment
from azureml.core import ScriptRunConfig

script_run_config = ScriptRunConfig(source_directory=os.getcwd(), script="train.py", run_config=compute_config)
experiment = Experiment(workspace=ws, name="compute_target_test")
run = experiment.submit(config=script_run_config)
run.wait_for_completion(show_output=True)

A futtatás végeztével a betanított modellfájl (churn-model.pkl) elérhető lesz a munkaterületen.

Környezet

Névtér: azureml.core.environment

Az Azure Machine Learning-környezetek meghatározzák a Python-csomagokat, a környezeti változókat és a szoftverbeállításokat a betanítási és pontozási szkriptek körül. A Python mellett a PySparkot, a Dockert és az R-t is konfigurálhatja környezetekhez. A környezetek belsőleg Docker-lemezképeket eredményeznek, amelyek a számítási cél betanítási és pontozási folyamatainak futtatására szolgálnak. A környezetek felügyelt és verziószámozott entitások a Machine Learning-munkaterületen belül, amelyek reprodukálható, naplózható és hordozható gépi tanulási munkafolyamatokat tesznek lehetővé különböző számítási célok és számítási típusok között.

Az objektumokat a következő objektumokhoz használhatja Environment :

  • A betanítási szkript fejlesztése.
  • Használja újra ugyanazt a környezetet az Azure Machine Learning Compute-ben a nagy léptékű modellbetanításhoz.
  • Helyezze üzembe a modellt ugyanazzal a környezettel anélkül, hogy egy adott számítási típushoz kötődik.

Az alábbi kód importálja az osztályt Environment az SDK-ból, és létrehoz egy környezeti objektumot.

from azureml.core.environment import Environment
Environment(name="myenv")

Csomagok hozzáadása környezethez a Conda, a pip vagy a privát kerék fájlok használatával. Adja meg az egyes csomagfüggőségeket a CondaDependency osztály használatával, hogy hozzáadja azt a környezethez PythonSection.

Az alábbi példa hozzáadja a környezetet. Hozzáadja a 1.17.0-s verzióját.numpy Emellett hozzáadja a csomagot a pillow környezethez is. myenv A példa a metódust add_conda_package() és a add_pip_package() metódust használja.

from azureml.core.environment import Environment
from azureml.core.conda_dependencies import CondaDependencies

myenv = Environment(name="myenv")
conda_dep = CondaDependencies()

# Installs numpy version 1.17.0 conda package
conda_dep.add_conda_package("numpy==1.17.0")

# Installs pillow package
conda_dep.add_pip_package("pillow")

# Adds dependencies to PythonSection of myenv
myenv.python.conda_dependencies=conda_dep

A betanítási futtatás elküldéséhez a környezetet, a számítási célt és a betanítási Python-szkriptet egy futtatási konfigurációban kell kombinálnia. Ez a konfiguráció egy burkolóobjektum, amely futtatások küldéséhez használható.

A betanítási futtatás elküldésekor egy új környezet kiépítése több percet is igénybe vehet. Az időtartam a szükséges függőségek méretétől függ. A környezeteket a szolgáltatás gyorsítótárazza. Tehát amíg a környezeti definíció változatlan marad, a teljes beállítási idő csak egyszer jelentkezik.

Az alábbi példa bemutatja, hol használná ScriptRunConfig burkolóobjektumként.

from azureml.core import ScriptRunConfig, Experiment
from azureml.core.environment import Environment

exp = Experiment(name="myexp", workspace = ws)
# Instantiate environment
myenv = Environment(name="myenv")

# Add training script to run config
runconfig = ScriptRunConfig(source_directory=".", script="train.py")

# Attach compute target to run config
runconfig.run_config.target = "local"

# Attach environment to run config
runconfig.run_config.environment = myenv

# Submit run 
run = exp.submit(runconfig)

Ha a futtatás elküldése előtt nem ad meg környezetet a futtatási konfigurációban, akkor a rendszer létrehoz egy alapértelmezett környezetet.

A környezetek webszolgáltatás üzembe helyezéséhez tekintse meg a Modell üzembe helyezése című szakaszt.

Pipeline, PythonScriptStep

Névtér: azureml.pipeline.core.pipeline.Pipeline
Névtér: azureml.pipeline.steps.python_script_step.PythonScriptStep

Az Azure Machine Learning-folyamat egy teljes gépi tanulási feladat automatizált munkafolyamata. Az alfeladatok lépések sorozataként vannak beágyazva a folyamatba. Az Azure Machine Learning-folyamat akár egyetlen lépésből is állhat, amely egy Python-szkriptet hív meg. A folyamatok funkciói:

  • Adat-előkészítés, beleértve az importálást, az érvényesítést és a tisztítást, a kezelést és az átalakítást, a normalizálást és az előkészítést
  • Betanítás konfigurálása, beleértve az argumentumok, a fájlok elérési útvonalai és a naplózási/jelentéskészítési konfigurációk paraméterezését
  • Hatékony és ismételhető betanítás és érvényesítés, amely konkrét adatrészhalmazokat, különböző hardveres számítási erőforrásokat, elosztott feldolgozást és előrehaladás-monitorozást is magában foglalhat
  • Üzembe helyezés, beleértve a verziószámozást, a méretezést, a kiépítést és a hozzáférés-vezérlést
  • Folyamat közzététele REST-végponton bármely HTTP-könyvtárból való ismételt futtatáshoz

PythonScriptStep: alapszintű, beépített lépés egy Python-szkript számítási célon való futtatásához. A szkript nevét és egyéb opcionális paramétereket (például a szkript, a számítási cél, a bemenetek és kimenetek argumentumait) használja. Az alábbi kód egyszerű példát mutat a PythonScriptStep használatára. A train.py szkript használatára példát az oktatóanyag alszakaszban talál.

from azureml.pipeline.steps import PythonScriptStep

train_step = PythonScriptStep(
    script_name="train.py",
    arguments=["--input", blob_input_data, "--output", output_data1],
    inputs=[blob_input_data],
    outputs=[output_data1],
    compute_target=compute_target,
    source_directory=project_folder
)

Legalább egy lépés létrehozása után a lépéseket összekapcsolhatja, és egyszerű, automatizált folyamatként teheti közzé.

from azureml.pipeline.core import Pipeline

pipeline = Pipeline(workspace=ws, steps=[train_step])
pipeline_run = experiment.submit(pipeline)

A folyamat-munkafolyamatok létrehozására átfogó példát a haladó szintű oktatóanyagban talál.

Minta folyamatok létrehozásához és használatához

Az Azure Machine Learning-folyamat egy Azure Machine Learning-munkaterülethez van társítva, és egy folyamatlépés az adott munkaterületen elérhető számítási célhoz van társítva. További információkért tekintse meg a munkaterületeket ismertető cikket, illetve a számítási célok itt szereplő ismertetését.

A folyamatlépések általános mintája:

  1. A munkaterület, a számítási és a tárolási erőforrás megadása
  2. A bemeneti és kimeneti adatok konfigurálása a következők használatával:
    1. Adatkészlet , amely elérhetővé tesz egy meglévő Azure-adattárat
    2. PipelineDataset, amely a típussal ellátott, táblázatos adatokat foglalja magában
    3. PipelineData, amely az egyik lépés által írt, majd egy másik által felhasználandó köztes fájlhoz vagy könyvtáradatokhoz használható
  3. Legalább egy folyamatlépés meghatározása
  4. Folyamat példányosítása a munkaterülettel és a lépésekkel
  5. Kísérlet létrehozása, amelybe elküldi a folyamatot
  6. A kísérlet eredményeinek monitorozása

Ez a jegyzet jó példát mutat be erre a mintára. feladat

Ebben a cikkben talál további információt az Azure Machine Learning-folyamatokkal, és különösen azzal kapcsolatban, hogy azok miben különböznek más folyamattípusoktól.

AutoMLConfig

Névtér: azureml.train.automl.automlconfig.AutoMLConfig

Az AutoMLConfig osztály használatával az automatizált gépi tanulás betanítási paramétereit lehet konfigurálni. Az automatizált gépi tanulás gépi tanulási algoritmusok és hiperparaméter-beállítások számos kombinációját veszi számba. Ezután megkeresi a legalkalmasabb modellt a választott pontossági mutató alapján. A konfiguráció lehetővé teszi a következők megadását:

  • Feladat típusa (besorolás, regresszió, előrejelzés)
  • Az algoritmusiterációk száma és az egyes iterációk maximális időtartama
  • Optimalizálandó pontossági mutató
  • Algoritmusok a tiltólistára/engedélyezési listára
  • Keresztvalidálások száma
  • Számítási célok
  • Betanítási adatok

Megjegyzés

Az automatizált gépi tanuláshoz használja a telepített példány automl kiegészítőjét.

Az automatizált gépi tanulási kísérletek beállításával kapcsolatos részletes útmutatókat és példákat az oktatóanyagban és az útmutatóban talál.

Az alábbi kód bemutatja, hogyan hozhat létre automatizált gépi tanulási konfigurációs objektumot egy besorolási modellhez, és hogyan használhatja azt a kísérlet elküldésekor.

from azureml.train.automl import AutoMLConfig

automl_config = AutoMLConfig(task="classification",
                             X=your_training_features,
                             y=your_training_labels,
                             iterations=30,
                             iteration_timeout_minutes=5,
                             primary_metric="AUC_weighted",
                             n_cross_validations=5
                            )

A kísérlet elküldéséhez használja az automl_config objektumot.

from azureml.core.experiment import Experiment

experiment = Experiment(ws, "automl_test_experiment")
run = experiment.submit(config=automl_config, show_output=True)

A kísérlet elküldése után a kimenet az egyes iterációk végső betanítási pontosságát jeleníti meg. A futtatás befejezése után a rendszer (a Run osztályt kiterjesztő) AutoMLRun objektumot ad vissza. A legalkalmasabb modell megkereséséhez használja a get_output() függvényt, amely Model objektumot ad vissza.

best_model = run.get_output()
y_predict = best_model.predict(X_test)

Modell üzembe helyezése

Névtér: azureml.core.model.InferenceConfig
Névtér: azureml.core.webservice.webservice.Webservice

Az InferenceConfig osztály a modell és a webszolgáltatás üzemeltetéséhez szükséges környezetet leíró konfigurációs beállításokra szolgál.

A Webservice egy absztrakt szülőosztály a modellek webszolgáltatásainak létrehozásához és üzembe helyezéséhez. A modell üzembe helyezésére és a webszolgáltatások üzembe helyezésére való felkészülésről szóló részletes útmutatóért tekintse meg ezt az útmutatót.

A környezeteket akkor használhatja, ha a modellt webszolgáltatásként helyezi üzembe. A környezetek lehetővé teszik a reprodukálható, csatlakoztatott munkafolyamatot, ahol a modellt ugyanazon kódtárak használatával helyezheti üzembe a betanítási számításban és a következtetési számításban is. A környezetek belsőleg Docker-rendszerképekként vannak implementálva. Használhatja a Microsoft által biztosított képeket, vagy használhatja saját egyéni Docker-rendszerképeit. Ha korábban az osztályt használta az ContainerImage üzembe helyezéshez, tekintse meg az DockerSection osztályt egy hasonló munkafolyamat környezetekkel való végrehajtásához.

Webszolgáltatás üzembe helyezéséhez kombinálja a környezetet, a számítási számítást, a pontozási szkriptet és a regisztrált modellt az üzembehelyezési objektumban( deploy()).

Az alábbi példa feltételezi, hogy már végzett egy betanítási futtatáson a környezet használatával, myenvés ezt a modellt szeretné üzembe helyezni Azure Container Instances.

from azureml.core.model import InferenceConfig, Model
from azureml.core.webservice import AciWebservice, Webservice

# Register the model to deploy
model = run.register_model(model_name = "mymodel", model_path = "outputs/model.pkl")

# Combine scoring script & environment in Inference configuration
inference_config = InferenceConfig(entry_script="score.py",
                                   environment=myenv)

# Set deployment configuration
deployment_config = AciWebservice.deploy_configuration(cpu_cores = 1,
                                                       memory_gb = 1)

# Define the model, inference, & deployment configuration and web service name and location to deploy
service = Model.deploy(workspace = ws,
                       name = "my_web_service",
                       models = [model],
                       inference_config = inference_config,
                       deployment_config = deployment_config)

Ez a példa egy Azure Container Instances-webszolgáltatást hoz létre, amely kisebb léptékű teszteléshez és gyors üzembe helyezéshez ideális. A modell éles környezetben használható webszolgáltatásként történő üzembe helyezéshez használja az Azure Kubernetes Service (AKS) szolgáltatást. További információt az AksCompute osztályt ismertető cikkben talál.

Adathalmaz

Névtér: azureml.core.dataset.Dataset
Névtér: azureml.data.file_dataset.FileDataset
Névtér: azureml.data.tabular_dataset.TabularDataset

A Dataset osztály alapvető fontosságú erőforrás az adatok áttekintéséhez és kezeléséhez az Azure Machine Learningben. Az adatokat összegző statisztika segítségével tekintheti át, az adathalmazt pedig az AML-munkaterületre mentheti a verziószámozási és megismételhetőségi képességek igénybevételéhez. A betanítás során a modellek egyszerűen felhasználhatják az adathalmazokat. Részletes használati példákért tekintse meg az útmutatót.

  • TabularDataset egy fájl vagy fájllista elemzésével létrehozott táblázatos formátumban jeleníti meg az adatokat.
  • A FileDataset adathalmaz az adattárakban található vagy nyilvános URL-címeken elérhető egy vagy több fájlra hivatkozik.

Az alábbi példa bemutatja, hogyan hozható létre az adattár adott útvonalára mutató táblázatos adathalmaz.

from azureml.core import Dataset

dataset = Dataset.Tabular.from_delimited_files(path = [(datastore, 'train-dataset/tabular/iris.csv')])
dataset.take(3).to_pandas_dataframe()

Az alábbi példa bemutatja, hogyan hozhat létre FileDataset hivatkozásokat több fájl URL-címére.

from azureml.core.dataset import Dataset

url_paths = [
            'http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz',
            'http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz',
            'http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz',
            'http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz'
            ]
dataset = Dataset.File.from_files(path=url_paths)

Következő lépések

Próbálkozzon ezekkel a további lépésekkel a Pythonhoz készült Azure Machine Learning SDK használatának megismeréséhez:

  • Kövesse az oktatóanyagot a modellek Pythonban történő létrehozásának, betanításának és üzembe helyezésének megismeréséhez.

  • A bal oldalon található tartalomjegyzéket használva keresse meg az osztályokat és modulokat a jelen webhelyen található referenciadokumentációban.