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

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

  • Cikk

Fontos

Ez a cikk az Azure Machine Learning SDK 1-ről szól, amely nem az aktuális SDK. Az SDK jelenlegi verziója az Azure Machine Learning Python SDK v2. Az SDK-verziók közötti különbségekről a Frissítés 2-című témakörben olvashat.

Az adattudósok és az AI-fejlesztők az Azure Machine Learning SDK v1 for Python használatával hozhatnak létre és futtathatnak gépi tanulási munkafolyamatokat az Azure Machine Learning szolgáltatás. A szolgáltatást bármely Python-környezetben használhatja, beleértve a Jupyter Notebookokat, Visual Studio Codevagy a kedvenc Python IDE-et.

Az SDK főbb területei a következők:

  • A gépi tanulási kísérletekben használt adathalmazok életciklusának megismerése, előkészítése és kezelése.
  • 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.
  • Modellek betanítása helyileg vagy felhőbeli erőforrások használatával, beleértve a GPU-gyorsított modell betanítását.
  • Használjon automatizált gépi tanulást, amely elfogadja a konfigurációs paramétereket és a betanítási adatokat. Automatikusan iterál algoritmusokkal és hiperparaméter-beállításokkal, hogy megtalálja a legjobb modellt az előrejelzések futtatásához.
  • Webszolgáltatások üzembe helyezése a betanított modellek RESTful-szolgáltatásokká alakításához, amelyek bármely alkalmazásban felhasználhatók.

Az első lépések részletes útmutatójához próbálja ki a oktatóanyagot.

Az alábbi szakaszok áttekintést nyújtanak az SDK néhány legfontosabb osztályáról, valamint a használatuk gyakori tervezési mintáiról. Az SDK beszerzéséhez tekintse meg a telepítési útmutatóját.

Stabil és 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 Leírás
Stabil funkciók Üzemkész

Ezek a funkciók a legtöbb használati esethez és éles környezethez ajánlottak. Ezek ritkábban frissülnek, mint a kísérleti funkciók.
Kísérleti funkciók Fejlesztési

Ezek a funkciók olyan újonnan kifejlesztett képességek, & olyan frissítések, amelyek nem á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ő módosítá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óbanfunkcióknak is nevezik.

Ahogy a név is jelzi, a kísérleti (előzetes verzió) funkciók kísérletezéshez használhatók, és nem tekinthető 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 szöveggel jelöli, például (előzetes verzió)Azure Machine Learning dokumentációjában.

Munkaterület

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

A Workspace osztály egy alapvető erőforrás a felhőben, amelyet gépi tanulási modellek kísérletezésére, betanítására és üzembe helyezésére használ. Az Azure-előfizetést és az erőforráscsoportot egy könnyen felhasznált objektumhoz konfigurálja.

Tekintse meg munkaterület-létrehozási módszer ö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ója és a számítási cél módosítása.

Importálja az osztályt, és hozzon létre egy új munkaterületet az alábbi kód használatával. Állítsa create_resource_groupFalse, ha a munkaterülethez korábban már használt Azure-erőforráscsoportot szeretne használni. Egyes függvények kérhetik az Azure-hitelesítési hitelesítő adatokat.

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. Ez menti az előfizetés, az erőforrás és a munkaterület névadatait.

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

Töltse be a munkaterületet a konfigurációs fájl olvasásával.

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

Másik lehetőségként használja a statikus get() metódust egy meglévő munkaterület konfigurációs fájlok használata nélküli betöltéséhez.

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

A ws változó egy Workspace objektumot jelöl az alábbi kód példákban.

Kísérlet

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

A Experiment osztály egy másik alapszintű felhőerőforrás, amely próbaverziók gyűjteményét jelöli (egyéni modellfuttatások). Az alábbi kód egy Experiment objektumot hív le Workspace név alapján, vagy létrehoz egy új Experiment objektumot, 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 Workspacetalálható Experiment objektumok listájának lekéréséhez.

list_experiments = Experiment.list(ws)

A get_runs függvénnyel lekérheti Run objektumok (kísérletek) listáját Experiment. Az alábbi kód lekéri a futtatásokat, és kinyomtatja az egyes futtatási azonosítókat.

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

A kísérlet próbaverziója kétféleképpen hajtható végre. Ha interaktívan kísérletezik egy Jupyter-jegyzetfüzetben, használja a start_logging függvényt. Ha standard Python-környezetből küld be kísérletet, használja a submit függvényt. Mindkét függvény egy Run objektumot ad vissza. A experiment változó egy Experiment objektumot jelöl az alábbi kód példákban.

Fut

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

A futtatás egy kísérlet egyetlen próbaverzióját jelenti. Run a próbaverzió aszinkron végrehajtásának figyeléséhez, a próbaverzió kimenetének tárolásához, az eredmények elemzéséhez és a létrehozott összetevők eléréséhez használt objektum. A kísérletezési kódban Run használatával naplózhatja a metrikákat és összetevőket a Futtatási előzmények szolgáltatásban. A funkciók a következők:

  • Metrikák és adatok tárolása és lekérése.
  • Címkék és gyermekhierarchia használata a korábbi futtatások egyszerű kereséséhez.
  • Tárolt modellfájlok regisztrálása üzembe helyezéshez.
  • Futtatás tulajdonságainak tárolása, módosítása és beolvasása.

Hozzon létre egy Run objektumot úgy, hogy elküld egy Experiment objektumot egy futtatási konfigurációs objektummal. A tags paraméter használatával egyéni kategóriákat és címkéket csatolhat a futtatásokhoz. Később könnyen megtalálhatja és lekérheti őket Experiment.

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

A statikus list függvénnyel lekérheti az összes Run objektum listáját Experiment. Adja meg a korábban létrehozott címke alapján szűrni kívánt tags paramétert.

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

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

run_details = run.get_details()

A függvény kimenete egy szótár, amely a következőket tartalmazza:

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

A futtatások konfigurálására és monitorozására vonatkozó további példákért tekintse meg a útmutatót.

Modell

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

A Model osztály a gépi tanulási modellek felhőbeli reprezentációinak kezelésére szolgál. A metódusok segítenek a modellek átvitelében a helyi fejlesztési környezetek és a felhőben található Workspace objektum között.

A modellregisztrációval a modelleket az Azure-felhőben, a munkaterületen tárolhatja és verziószámezheti. A regisztrált modelleket név és verzió alapján azonosítjuk. Minden alkalommal, amikor egy meglévővel azonos nevű modellt regisztrál, a beállításjegyzék növeli a verziót. Az Azure Machine Learning minden olyan modellt támogat, amely a Python 3-on keresztül tölthető be, nem csak az Azure Machine Learning-modelleket.

Az alábbi példa bemutatja, hogyan hozhat létre egyszerű helyi besorolási modellt scikit-learn, hogyan regisztrálhatja a modellt a Workspace, és hogyan töltheti le a modellt a felhőből.

Hozzon létre egy egyszerű osztályozót, clf, hogy előrejelezhesse az ügyfelek változását az életkoruk alapján. Ezután a modellt egy .pkl fájlba kell kiképezni ugyanabban 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")

A register függvénnyel regisztrálhatja a modellt a munkaterületen. Adja meg a helyi modell elérési útját és a modell nevét. Ha többször regisztrálja ugyanazt a nevet, új verziót hoz létre.

from azureml.core.model import Model

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

Most, hogy a modell regisztrálva lett a munkaterületen, egyszerűen kezelheti, letöltheti és rendszerezheti a modelleket. Ha egy modellobjektumot (például egy másik környezetben) szeretne lekérni Workspace, használja az osztálykonstruktort, és adja meg a modell nevét és a választható paramétereket. Ezután töltse le a modellt a download függvénnyel, beleértve a felhőmappa struktúráját is.

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énnyel távolítsa el a modellt a Workspace.

model.delete()

Miután regisztrált egy modellt, a webszolgáltatásként való üzembe helyezés egyszerű folyamat. Először létrehozni és regisztrálni egy lemezképet. Ez a lépés konfigurálja a Python-környezetet és annak függőségeit, valamint egy szkriptet a webszolgáltatás kéréseinek és válaszformátumainak meghatározásához. A rendszerkép létrehozása után létrehozni egy üzembe helyezési konfigurációs, amely beállítja a számítási cél processzormagjait és memóriaparamétereit. Ezután csatolja a ké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ára és kezelésére szolgáló absztrakt szülőosztály. A számítási célok számos olyan erőforrást jelölnek, amelyek betanítása lehetővé teszi a gépi tanulási modellek betanítása. A számítási cél lehet helyi gép vagy felhőerőforrás, például Azure Machine Learning Compute, Azure HDInsight vagy távoli virtuális gép.

Számítási célok használatával kihasználhatja a hatékony virtuális gépek előnyeit a modell betanításához, és állandó számítási célokat vagy ideiglenes futásidejű meghívású célokat állíthat be. A számítási célok beállításával és kezelésével kapcsolatos átfogó útmutatóért tekintse meg a útmutatót.

Az alábbi kód egy egyszerű példát mutat be egy AmlCompute (ComputeTargetgyermekosztálya) cél beállítására. Ez a cél létrehoz egy futtatókörnyezeti távoli számítási erőforrást a Workspace objektumban. Az erőforrás automatikusan skálázódik egy feladat elküldésekor. A futtatás befejezésekor a rendszer automatikusan törli.

Használja újra az egyszerű scikit-learn adatváltozási modellt, és hozza létre saját fájljába, train.pyaz aktuális könyvtárban. A fájl végén hozzon létre egy új, outputsnevű könyvtárat. Ez a lépés létrehoz egy könyvtárat a felhőben (a munkaterületen) a betanított modell tárolásához, amely joblib.dump() szerializált.

# 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 egy 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 használja (1 processzormag, 3,5 GB memória). A list_vms változó a támogatott virtuális gépek listáját és azok méretét tartalmazza.

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"

Függőségek létrehozása a távoli számítási erőforrás Python-környezetéhez a CondaDependencies osztály használatával. A train.py fájl scikit-learn és numpyhasznál, amelyeket telepíteni kell a környezetben. A függőségek verzióit is megadhatja. A dependencies objektummal állítsa be a környezetet compute_config.

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élkonfigurációt, és adja meg a betanítási szkript elérési útját/fájlját train.py. Küldje el a kísérletet a submit() függvény config paraméterének megadásával. Hívja meg az wait_for_completion az eredményül kapott futtatáson, hogy lássa az aszinkron futtatási kimenetet a környezet inicializálása és a modell betanítása során.

Figyelmeztetés

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

  • A ", $, ;és \ karaktereket a háttér feloldja, mivel a bash-parancsok elválasztására fenntartott karaktereknek minősülnek.
  • A (, ), %, !, ^, <, >, &és | karakterek a Windows helyi futtatásaihoz kerülnek.
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 befejezése után a betanított modellfájl churn-model.pkl elérhető 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 PySpark, a Docker és az R környezetekhez is konfigurálható. A környezetek belsőleg Docker-rendszerké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, amelyek reprodukálható, naplózható és hordozható gépi tanulási munkafolyamatokat tesznek lehetővé számos számítási cél és számítási típus között.

Egy Environment objektumot a következőhöz használhat:

  • 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 a Environment osztályt az SDK-ból, és létrehoz egy környezeti objektumot.

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

Csomagok hozzáadása egy környezethez Conda-, pip- vagy magánkerekes fájlok használatával. Az egyes csomagfüggőségeket a CondaDependency osztály használatával adhatja hozzá a környezet PythonSection.

Az alábbi példa hozzáadja a környezetet. Hozzáadja a numpy1.17.0-s verzióját. Emellett hozzáadja a pillow csomagot a környezethez, myenv. A példa a 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élé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álatos.

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örnyezetdefiníció változatlan marad, a teljes beállítási időt csak egyszer kell megadnia.

Az alábbi példa bemutatja, hogy 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.

Tekintse meg a modell üzembe helyezésének szakaszát, amely környezeteket használ a webszolgáltatás üzembe helyezéséhez.

Folyamat, 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 altevékenységek lépéssorozatként vannak beágyazva a folyamaton belül. Az Azure Machine Learning-folyamat egy olyan egyszerű lépés lehet, amely Python-szkripteket hív meg. A folyamatok a következők funkcióit tartalmazzák:

  • Adatelőkészítés, beleértve az importálást, az érvényesítést és a tisztítást, a mungingot és az átalakítást, a normalizálást és az előkészítést
  • Betanítási konfiguráció, beleértve a paraméterezés argumentumait, a filepathst és a naplózási/jelentéskészítési konfigurációkat
  • Hatékony és megismételhető betanítás és ellenőrzés, amely magában foglalhatja adott adathalmazok megadását, a különböző hardveres számítási erőforrásokat, az elosztott feldolgozást és a folyamatfigyelést
  • Üzembe helyezés, beleértve a verziószámozást, a skálázá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ódtárból való újrafuttatáshoz

A PythonScriptStep egy alapszintű, beépített lépés egy Python-szkript számítási célon való futtatásához. A parancsprogram neve és egyéb választható paraméterek, például a szkript argumentumai, a számítási cél, a bemenetek és a kimenetek. Az alábbi kód egy egyszerű példa egy PythonScriptStep. Példa egy train.py szkriptre, lásd az oktatóanyagot alszakaszban.

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ések összekapcsolhatók és közzétehetők egyszerű automatizált folyamatként.

from azureml.pipeline.core import Pipeline

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

A folyamat-munkafolyamatok létrehozásának átfogó példájáért kövesse a speciális oktatóanyagot.

Folyamatok létrehozásának és használatának mintája

Az Azure Machine Learning-folyamat egy Azure Machine Learning-munkaterülethez van társítva, a folyamatlépés pedig az adott munkaterületen elérhető számítási célhoz van társítva. További információkért tekintse meg ezt a cikket a munkaterületekről, vagy számítási célokmagyarázatát.

A folyamatlépések gyakori mintája a következő:

  1. Munkaterület, számítás és tárolás megadása
  2. A bemeneti és kimeneti adatok konfigurálása
    1. adatkészlet, amely egy meglévő Azure-adattárat tesz elérhetővé
    2. PipelineDataset, amely a beírt táblázatos adatokat foglalja magában
    3. PipelineData-, amelyet az egyik lépésben írt köztes fájl- vagy címtáradatokhoz használnak, és amelyeket egy másik használ fel
  3. Egy vagy több folyamatlépés definiálása
  4. Folyamat példányosítása a munkaterület és a lépések használatával
  5. Kísérlet létrehozása, amelyhez elküldi a folyamatot
  6. A kísérlet eredményeinek figyelése

Ez a jegyzetfüzet jó példa erre a mintára. foglalkozás

Az Azure Machine Learning Pipelinesról és különösen arról, hogy miben különböznek más típusú folyamatoktól, olvassa el ezt a cikket.

AutoMLConfig

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

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

  • Tevékenység típusa (besorolás, regresszió, előrejelzés)
  • Az algoritmus-iterációk száma és az iterációnkénti maximális idő
  • Pontossági metrika az optimalizáláshoz
  • A tiltólistára/engedélyezésre használt algoritmusok
  • Keresztérvényesítések száma
  • Számítási célok
  • Betanítási adatok

Jegyzet

A telepítés automl extra használatával automatizálhatja a gépi tanulást.

Az automatizált gépi tanulási kísérletek beállítására vonatkozó részletes útmutatókért és példákért tekintse meg az oktatóanyagot és útmutatót.

Az alábbi kód bemutatja, hogy egy automatikus gépi tanulási konfigurációs objektumot kell létrehozni egy besorolási modellhez, és azt használni egy 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 a 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 betanítási pontosságát jeleníti meg a befejezéskor. A futtatás befejezése után a rendszer visszaad egy AutoMLRun objektumot (amely kibővíti a Run osztályt). A legjobban illeszkedő modellt a get_output() függvénnyel szerezheti be egy Model objektum visszaadásához.

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

A 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ásokhoz készült.

Webservice a modellek webszolgáltatásainak létrehozására és üzembe helyezésére szolgáló absztrakt szülőosztály. A modell üzembe helyezésének és a webszolgáltatások üzembe helyezésének előkészítésével kapcsolatos részletes útmutatóért tekintse meg ezt a útmutatót.

A modell webszolgáltatásként való üzembe helyezésekor környezeteket is használhat. A környezetek egy reprodukálható, csatlakoztatott munkafolyamatot tesznek lehetővé, 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 a ContainerImage osztályt használta az üzembe helyezéshez, tekintse meg a DockerSection osztályt, amely hasonló munkafolyamatot hajt végre környezetekkel.

Webszolgáltatás üzembe helyezéséhez kombinálja a környezetet, a következteté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 környezettel, myenv, és ezt a modellt szeretné üzembe helyezni az Azure Container Instancesben.

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 létrehoz egy Azure Container Instances webszolgáltatást, amely a legjobb a kis léptékű teszteléshez és a gyors üzembe helyezéshez. A modell éles szintű webszolgáltatásként való üzembe helyezéséhez használja az Azure Kubernetes Service-t (AKS). További információ: AksCompute osztály.

Adatkészlet

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 az Azure Machine Learningben található adatok feltárásának és kezelésének alapvető erőforrása. Az adatok összegzési statisztikákkal való feltárásával és az adathalmaz AML-munkaterületre való mentésével verziószámozási és reprodukálhatósági képességeket kaphat. Az adathalmazokat a modellek egyszerűen felhasználhatják a betanítás során. Részletes használati példákért tekintse meg a útmutatót.

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

Az alábbi példa bemutatja, hogyan hozhat létre egyetlen elérési útra mutató TabularDatasetet egy adattárban.

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 több fájl URL-címére hivatkozó FileDataset.

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

A következő lépésekkel megtudhatja, hogyan használhatja a Pythonhoz készült Azure Machine Learning SDK-t:

  • Kövesse az oktatóanyagot, amelyből megtudhatja, hogyan hozhat létre, taníthat be és helyezhet üzembe modelleket a Pythonban.

  • Osztályokat és modulokat kereshet a webhelyen található referenciadokumentációban a bal oldali tartalomjegyzék használatával.