Sdílet prostřednictvím

Co je sada Azure Machine Learning SDK pro Python?

  • Článek

Odborníci na data a vývojáři umělé inteligence používají sadu Azure Machine Learning SDK pro Python k vytváření a spouštění pracovních postupů strojového učení pomocí služby Azure Machine Learning. Se službou můžete pracovat v libovolném prostředí Pythonu, včetně aplikací Jupyter Notebook, Visual Studio Code nebo vašeho oblíbeného prostředí IDE Pythonu.

Mezi klíčové oblasti sady SDK patří:

  • Zkoumání, příprava a správa životního cyklu datových sad používaných v experimentech strojového učení
  • Správa cloudových prostředků pro monitorování, protokolování a organizaci experimentů strojového učení
  • Trénování modelů v místním prostředí nebo s využitím cloudových prostředků, včetně zrychleného trénování modelů s využitím GPU
  • Použijte automatizované strojové učení, které přijímá konfigurační parametry a trénovací data. Automaticky iteruje algoritmy a nastaveními hyperparametrů a hledá nejlepší model pro spouštění predikcí.
  • Nasazování webových služeb pro převod natrénovaných modelů na služby RESTful, které můžou využívat jakékoli aplikace.

Podrobný návod do začátku najdete v tomto kurzu.

Následující části obsahují přehled několika nejdůležitějších tříd sady SDK a běžných vzorů návrhu pro jejich použití. Pokud chcete získat sadu SDK, projděte si průvodce instalací.

Stabilní vs. experimentální

Sada Azure Machine Learning SDK pro Python poskytuje stabilní i experimentální funkce ve stejné sadě SDK.

Stav funkcí nebo schopností Description
Stabilní funkce Připraveno pro produkční prostředí

Tyto funkce se doporučují pro většinu případů použití a produkčních prostředí. Aktualizují se méně často než experimentální funkce.
Experimentální funkce Vývojové

Tyto funkce jsou nově vyvinuté funkce & aktualizace, které nemusí být připravené nebo plně otestované pro použití v produkčním prostředí. I když jsou tyto funkce obvykle funkční, můžou obsahovat některé zásadní změny. Experimentální funkce se používají k vymýšlení chyb sady SDK a budou dostávat aktualizace pouze po dobu trvání testování. Experimentální funkce se také označují jako funkce, které jsou ve verzi Preview.

Jak název naznačí, experimentální funkce (Preview) slouží k experimentování a nepovažují se za stabilní ani bez chyb. Z tohoto důvodu doporučujeme experimentální funkce pouze pokročilým uživatelům, kteří chtějí vyzkoušet starší verze funkcí a aktualizací a chtějí se podílet na hlášení chyb a závad.

Experimentální funkce jsou v dokumentaci ke službě Azure Machine Learning označené oddílem poznámky v referenčních informacích k sadě SDK a označeny textem, například (Preview).

Pracovní prostor

Obor názvů: azureml.core.workspace.Workspace

Třída Workspace je základním prostředkem v cloudu, který můžete využít k experimentování, trénování a nasazování modelů strojového učení. Tato třída spojí vaše předplatné a skupinu prostředků Azure do snadno použitelného objektu.

Zobrazte všechny parametry metody create Workspace pro opakované použití existujících instancí (Storage, Key Vault, App-Insights a Azure Container Registry-ACR) a upravte další nastavení, jako je konfigurace privátního koncového bodu a cílový výpočetní objekt.

K importu této třídy a vytvoření nového pracovního prostoru použijte následující kód. Pokud již máte skupinu prostředků Azure, kterou chcete pro pracovní prostor použít, nastavte create_resource_group na hodnotu False. Některé funkce můžou vyžadovat zadání přihlašovacích údajů pro ověření v Azure.

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

Pokud chcete stejný pracovní prostor používat ve více prostředích, zapište ho nejprve do konfiguračního souboru JSON. Tím se uloží údaje o vašem předplatném, prostředku a názvu pracovního prostoru.

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

Pracovní prostor nahrajete načtením konfiguračního souboru.

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

Případně můžete použít statickou metodu get() a nahrát stávající pracovní prostor bez použití konfiguračních souborů.

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

Proměnná ws v následujících příkladech kódu představuje objekt Workspace.

Experiment

Obor názvů: azureml.core.experiment.Experiment

Třída Experiment je dalším základním cloudovým prostředkem, který představuje kolekci zkoušek (jednotlivých spuštění modelu). Následující kód načte podle názvu objekt Experiment z objektu Workspace, nebo vytvoří nový objekt Experiment, pokud zadaný název neexistuje.

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

Spuštěním následujícího kódu získáte seznam všech objektů Experiment v objektu Workspace.

list_experiments = Experiment.list(ws)

Pomocí funkce get_runs načtete seznam objektů Run (zkoušek) z objektu Experiment. Následující kód načte spuštění a vypíše ID jednotlivých spuštění.

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

Zkoušku experimentu je možné spustit dvěma způsoby. Pokud interaktivně experimentujete v poznámkovém bloku Jupyter, použijte funkci start_logging. Pokud experiment odesíláte ze standardního prostředí Pythonu, použijte funkci submit. Obě funkce vrací objekt Run. Proměnná experiment v následujících příkladech kódu představuje objekt Experiment.

Spustit

Obor názvů: azureml.core.run.Run

Spuštění představuje jednu zkoušku experimentu. Objekt Run slouží k monitorování asynchronního spuštění zkoušky, uložení výstupu zkoušky, analýze výsledků a přístupu k vygenerovaným artefaktům. Objekt Run můžete použít v experimentálním kódu k protokolování metrik a artefaktů do služby Historie spuštění. Mezi dostupné funkce patří:

  • Ukládání a načítání metrik a dat
  • Používání značek a hierarchie podřízených objektů umožňujících snadné vyhledání předchozích spuštění
  • Registrace uložených souborů modelů pro účely nasazení
  • Ukládání, úpravy a načítání vlastností spuštění

Objekt Run vytvoříte odesláním objektu Experiment s objektem konfigurace spuštění. Pomocí parametru tags můžete ke spuštěním připojit vlastní kategorie a popisky. Později je můžete snadno vyhledat a načíst z objektu Experiment.

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

K získání seznamu všech objektů Run z objektu Experiment použijte statickou funkci list. Pokud chcete filtrovat podle dříve vytvořených značek, zadejte parametr tags.

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

Pokud chcete načíst podrobný výstup spuštění, použijte funkci get_details.

run_details = run.get_details()

Výstupem této funkce je slovník, který obsahuje:

  • ID spuštění
  • Stav
  • Počáteční a koncový čas
  • Cílový výpočetní objekt (místní nebo cloudový)
  • Závislosti a verze použité ve spuštění
  • Data specifická pro trénování (liší se podle typu modelu)

Další příklady konfigurace a monitorování spuštění najdete v návodu.

Modelování

Obor názvů: azureml.core.model.Model

Třída Model se používá k práci s cloudovými reprezentacemi modelů strojového učení. S přenosem modelů mezi místními vývojovými prostředími a objektem Workspace v cloudu pomáhají metody.

K ukládání a správě verzí modelů ve vašem pracovním prostoru v cloudu Azure můžete využít registraci modelů. Registrované modely se identifikují prostřednictvím názvu a verze. Vždy, když zaregistrujete model se stejným názvem, který již používá existující model, v registru se zvýší jeho verze. Azure Machine Learning podporuje jakýkoli model, který je možné načíst prostřednictvím Pythonu 3, nejen modely Azure Machine Learning.

Následující příklad znázorňuje sestavení jednoduchého místního modelu klasifikace pomocí scikit-learn, registraci modelu v objektu Workspace a stažení modelu z cloudu.

Vytvořte jednoduchý klasifikátor clf pro předpověď výpovědi zákazníků na základě jejich věku. Pak model zálohujte do souboru .pkl ve stejném adresáři.

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")

Pomocí funkce register zaregistrujte model ve svém pracovním prostoru. Zadejte místní cestu k modelu a název modelu. Když zaregistrujete stejný název více než jednou, vytvoří se nová verze.

from azureml.core.model import Model

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

Když je teď model zaregistrovaný ve vašem pracovním prostoru, můžete modely snadno spravovat, stahovat a organizovat. Pokud chcete načíst objekt modelu (například v jiném prostředí) z objektu Workspace, použijte konstruktor třídy a zadejte název modelu a případně volitelné parametry. Pak pomocí funkce download model stáhněte, a to včetně cloudové struktury složek.

from azureml.core.model import Model
import os

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

K odebrání modelu z objektu Workspace použijte funkci delete.

model.delete()

Po registraci modelu je jeho nasazení jako webové služby jednoduché. Nejprve vytvoříte a zaregistrujete image. V tomto kroku se nakonfiguruje prostředí Pythonu a jeho závislosti, a také skript, který definuje formáty požadavků a odpovědí webové služby. Po vytvoření image vytvoříte konfiguraci nasazení, která nastaví parametry počtu jader procesoru a velikosti paměti pro cílový výpočetní objekt. Pak image připojíte.

ComputeTarget, RunConfiguration a ScriptRunConfig

Obor názvů: azureml.core.compute.ComputeTarget
Obor názvů: azureml.core.runconfig.RunConfiguration
Obor názvů: azureml.core.script_run_config.ScriptRunConfig

K vytváření a správě cílových výpočetních objektů slouží abstraktní nadřazená třída ComputeTarget. Cílový výpočetní objekt představuje různé prostředky, ve kterých můžete trénovat modely strojového učení. Cílovým výpočetním objektem může být místní počítač nebo cloudový prostředek, jako jsou výpočetní prostředky služby Azure Machine Learning, Azure HDInsight nebo vzdálený virtuální počítač.

Díky cílovým výpočetním objektům můžete k trénování modelů využívat výkonné virtuální počítače. Můžete nastavit trvalé cílové výpočetní objekty nebo dočasné cíle volané modulem runtime. Komplexní pokyny k nastavení a správě cílových výpočetních objektů najdete v návodu.

Následující kód ukazuje jednoduchý příklad nastavení cíle AmlCompute (podřízená třída třídy ComputeTarget). Tento cíl vytvoří v objektu Workspace vzdálený výpočetní prostředek modulu runtime. Prostředek se po odeslání úlohy automaticky škáluje. Po dokončení spuštění se automaticky odstraní.

Znovu použijte jednoduchý model výpovědi scikit-learn a integrujte ho do vlastního souboru train.py v aktuálním adresáři. Na konci souboru vytvořte nový adresář outputs. V tomto kroku se vytvoří adresář v cloudu (ve vašem pracovním prostoru), do kterého se uloží natrénovaný model serializovaný funkcí joblib.dump().

# 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")

Pak vytvoříte cílový výpočetní objekt tím, že vytvoříte instanci objektu RunConfiguration a nastavíte typ a velikost. V tomto příkladu se používá nejmenší velikost prostředku (1 jádro procesoru a 3,5 GB paměti). Proměnná list_vms obsahuje seznam podporovaných virtuálních počítačů a jejich velikostí.

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"

Pomocí třídy CondaDependencies vytvořte závislosti pro prostředí Pythonu vzdáleného výpočetního prostředku. V souboru train.py se používají nástroje scikit-learn a numpy, které je potřeba v prostředí nainstalovat. Můžete zadat také verze závislostí. Pomocí objektu dependencies nastavte prostředí v objektu 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

Teď jste připraveni experiment odeslat. Pomocí třídy ScriptRunConfig připojte konfiguraci cílového výpočetního objektu a zadejte cestu k souboru trénovacího skriptu train.py. Zadáním parametru config funkce submit() experiment odešlete. Zavoláním metody wait_for_completion pro výsledné spuštění můžete zobrazit výstup asynchronního spuštění během inicializace prostředí a trénování modelu.

Upozornění

Tady jsou omezení týkající se konkrétních znaků při použití v ScriptRunConfig parametrech:

  • Znaky ", $, ;a \ jsou řídicími znaky back-endu, protože se považují za vyhrazené znaky pro oddělení příkazů Bash.
  • Znaky (, , ), %, ^>&!<a | se pro místní spuštění ve Windows označují řídicími znaky.
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)

Po dokončení spuštění bude ve vašem pracovním prostoru k dispozici soubor natrénovaného modelu churn-model.pkl.

Prostředí

Obor názvů: azureml.core.environment

Prostředí Azure Machine Learning určují balíčky Pythonu, proměnné prostředí a nastavení softwaru kolem trénovacích a bodovacích skriptů. Kromě Pythonu můžete pro prostředí nakonfigurovat také PySpark, Docker a R. Prostředí interně vedou k vytváření imagí Dockeru, které se používají ke spouštění procesů trénování a bodování na cílovém výpočetním objektu. Prostředí jsou spravované entity a entity s verzemi v rámci pracovního prostoru Machine Learning, které umožňují reprodukovatelné, auditovatelné a přenosné pracovní postupy strojového učení napříč různými cílovými výpočetními objekty a typy výpočetních prostředků.

Objekt můžete použít Environment k:

  • Vytvořte svůj trénovací skript.
  • Opakovaně používejte stejné prostředí ve službě Azure Machine Learning Compute pro trénování modelů ve velkém měřítku.
  • Nasaďte model se stejným prostředím, aniž byste ho vázali na konkrétní typ výpočetních prostředků.

Následující kód importuje Environment třídu ze sady SDK a vytvoří instanci objektu prostředí.

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

Přidejte balíčky do prostředí pomocí souborů Conda, pip nebo private wheel. Zadejte každou závislost balíčku pomocí CondaDependency třídy , která ji přidá do prostředí PythonSection.

Následující příklad přidá do prostředí . Přidává verzi 1.17.0 nástroje numpy. Také přidá pillow balíček do prostředí myenv. Příklad používá metodu add_conda_package() a metodu add_pip_package() .

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

Pokud chcete odeslat trénovací spuštění, musíte zkombinovat prostředí, cílový výpočetní objekt a trénovací skript Pythonu do konfigurace spuštění. Tato konfigurace je objekt obálky, který se používá k odesílání spuštění.

Když odešlete trénovací běh, může vytváření nového prostředí trvat několik minut. Doba trvání závisí na velikosti požadovaných závislostí. Prostředí jsou uložená v mezipaměti službou. Pokud tedy definice prostředí zůstane beze změny, doba úplného nastavení se zobrazí pouze jednou.

Následující příklad ukazuje, kde byste použili ScriptRunConfig jako objekt obálky.

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)

Pokud před odesláním spuštění nezadáte prostředí v konfiguraci spuštění, vytvoří se výchozí prostředí pro vás.

Informace o použití prostředí k nasazení webové služby najdete v části Nasazení modelu .

Pipeline, PythonScriptStep

Obor názvů: azureml.pipeline.core.pipeline.Pipeline
Obor názvů: azureml.pipeline.steps.python_script_step.PythonScriptStep

Kanál služby Azure Machine Learning je automatizovaný pracovní postup kompletní úlohy strojového učení. Dílčí úlohy jsou v rámci kanálu zapouzdřené do série kroků. Kanál služby Azure Machine Learning může tvořit i pouze jeden krok, ve kterém se volá skript Pythonu. Kanály zahrnují funkce pro:

  • Přípravu dat, včetně importu, ověřování a čištění, transformace a nedefinované transformace, normalizace a fázování
  • Konfiguraci trénování, včetně parametrizace argumentů, cest k souborům a konfigurací protokolování a generování sestav
  • Efektivní a opakovatelné trénování a ověřování, které může zahrnovat určení konkrétních podmnožin dat, různé hardwarové výpočetní prostředky, distribuované zpracování a sledování průběhu
  • Nasazení, včetně správy verzí, škálování, zřizování a řízení přístupu
  • Publikování kanálu v koncovém bodu REST umožňující opětovné spouštění z jakékoli knihovny HTTP

PythonScriptStep je základní předdefinovaný krok umožňující spuštění skriptu Pythonu v cílovém výpočetním objektu. Přebírá název skriptu a další volitelné parametry, jako jsou argumenty pro skript, cílový výpočetní objekt, vstupy a výstupy. Následující kód představuje jednoduchý příklad kroku PythonScriptStep. Příklad skriptu train.py najdete v příslušné podsekci kurzu.

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
)

Po vytvoření alespoň jednoho kroku je možné kroky propojit a publikovat jako jednoduchý automatizovaný kanál.

from azureml.pipeline.core import Pipeline

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

Komplexní příklad vytvoření pracovního postupu kanálu najdete v pokročilém kurzu.

Vzor vytváření a používání kanálů

Kanál Služby Azure Machine Learning je přidružený k pracovnímu prostoru Azure Machine Learning a krok kanálu je přidružený k cílovému výpočetnímu objektu, který je v tomto pracovním prostoru k dispozici. Další informace najdete v tomto článku o pracovních prostorech nebo v tomto vysvětlení cílových výpočetních objektů.

Běžný vzor pro kroky kanálu je následující:

  1. Určení pracovního prostoru, výpočetních prostředků a úložiště
  2. Konfigurace vstupních a výstupních dat pomocí
    1. Datová sada , která zpřístupňuje existující úložiště dat Azure
    2. objektu PipelineDataset, který zapouzdřuje zadaná tabulková data
    3. objektu PipelineData, který se používá pro dočasná data souborů nebo adresářů, která jeden krok zapíše a jiný krok je má použít
  3. Definování jednoho nebo několika kroků kanálu
  4. Vytvoření instance kanálu s použitím příslušného pracovního prostoru a kroků
  5. Vytvoření experimentu, do kterého se kanál odešle
  6. Monitorování výsledků experimentu

Dobrým příkladem tohoto vzoru je tento poznámkový blok. úloha

Další informace o kanálech služby Azure Machine Learning, zejména o rozdílech mezi nimi a dalšími typy kanálů, najdete v tomto článku.

AutoMLConfig

Obor názvů: azureml.train.automl.automlconfig.AutoMLConfig

Pomocí třídy AutoMLConfig můžete konfigurovat parametry pro automatizované trénování strojového učení. Automatizované strojové učení iteruje velkým množstvím kombinací algoritmů strojového učení a nastavení hyperparametrů. Pak na základě zvolené metriky přesnosti najde nejvhodnější model. V konfiguraci můžete zadat:

  • Typ úlohy (klasifikace, regrese, prognózování)
  • Počet iterací algoritmů a maximální čas na iteraci
  • Metriku přesnosti pro optimalizaci
  • Algoritmy na seznam blokovaných nebo povolených
  • Počet křížových ověření
  • Cílové výpočetní objekty
  • Data pro trénink

Poznámka

Pokud chcete využívat automatizované strojové učení, použijte při instalaci doplněk automl.

Podrobné pokyny a příklady nastavení experimentů automatizovaného strojového učení najdete v příslušném kurzu a návodu.

Následující kód znázorňuje vytvoření objektu konfigurace automatizovaného strojového učení pro model klasifikace a jeho použití při odeslání experimentu.

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
                            )

K odeslání experimentu použijte objekt automl_config.

from azureml.core.experiment import Experiment

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

Po odeslání experimentu se ve výstupu zobrazí přesnost trénování v jednotlivých dokončených iteracích. Po dokončení spuštění se vrátí objekt AutoMLRun (který rozšiřuje třídu Run). Pokud chcete získat nejvhodnější model, použijte funkci get_output(), která vrací objekt Model.

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

Nasazení modelu

Obor názvů: azureml.core.model.InferenceConfig
Obor názvů: azureml.core.webservice.webservice.Webservice

Třída InferenceConfig je určená pro nastavení konfigurace, která popisují prostředí potřebné k hostování modelu a webové služby.

Webservice je abstraktní nadřazená třída pro vytváření a nasazování webových služeb pro modely. Podrobného průvodce přípravou na nasazení modelu a nasazením webových služeb najdete v tomto postupu.

Prostředí můžete použít při nasazování modelu jako webové služby. Prostředí umožňují reprodukovatelný a propojený pracovní postup, ve kterém můžete model nasadit pomocí stejných knihoven v trénovacích výpočetních prostředcích i výpočetních prostředcích odvozování. Interně se prostředí implementují jako image Dockeru. Můžete použít buď image od Microsoftu, nebo vlastní image Dockeru. Pokud jste dříve používali ContainerImage třídu pro vaše nasazení, podívejte se na DockerSection třídu pro provedení podobného pracovního postupu s prostředími.

Pokud chcete nasadit webovou službu, zkombinujte v objektu deploy()nasazení prostředí, výpočetní výkon, bodovací skript a registrovaný model.

V následujícím příkladu se předpokládá, že jste už dokončili trénovací běh pomocí prostředí myenva chcete tento model nasadit do 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)

V tomto příkladu se vytvoří webová služba Azure Container Instances, která je ideální pro méně rozsáhlé testování a rychlá nasazení. K nasazení modelu jako webové služby v produkčním měřítku použijte službu Azure Kubernetes Service (AKS). Další informace najdete v tématu věnovaném třídě AksCompute.

Datová sada

Obor názvů: azureml.core.dataset.Dataset
Obor názvů: azureml.data.file_dataset.FileDataset
Obor názvů: azureml.data.tabular_dataset.TabularDataset

Třída Dataset je základním prostředkem pro zkoumání a správu dat ve službě Azure Machine Learning. Můžete zkoumat data s využitím souhrnných statistik a uložením datové sady do pracovního prostoru AML získat možnosti správy verzí a reprodukovatelnosti. Datové sady jsou pro modely snadno použitelné během trénování. Podrobné příklady použití najdete v praktickém průvodci.

  • TabularDataset představuje data v tabulkovém formátu vytvořená analýzou souboru nebo seznamu souborů.
  • Objekt FileDataset odkazuje na jeden nebo několik souborů v úložištích dat nebo z veřejných adres URL.

Následující příklad ukazuje, jak vytvořit objekt TabularDataset odkazující na jednu cestu v úložišti dat.

from azureml.core import Dataset

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

Následující příklad ukazuje, jak vytvořit FileDataset odkazující na adresy URL více souborů.

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)

Další kroky

Pokud se chcete naučit používat sadu Azure Machine Learning SDK pro Python, vyzkoušejte tyto další kroky:

  • Postupujte podle kurzu a zjistěte, jak vytvořit, natrénovat a nasadit model v Pythonu.

  • Vyhledejte semináře a moduly v referenční dokumentaci na tomto webu pomocí obsahu vlevo.