Co je sada Azure Machine Learning SDK pro Python?

  • Článek
  • 15 min ke čtení

Odborníci přes data a vývojáři umělé inteligence používají sadu Azure Machine Learning SDK pro Python k vytváření a provozu pracovních postupů strojového učení s využitím služby Azure Machine Learning. S touto službou můžete pracovat v jakémkoli prostředí Pythonu, včetně poznámkových bloků Jupyter, Visual Studio Code nebo oblíbeného integrovaného vývojového prostředí pro Python.

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žívejte automatizované Machine Learning, který přijímá konfigurační parametry a školicí 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 SDK Azure Machine Learning pro Python poskytuje stabilní i experimentální funkce stejné sady SDK.

Stabilní funkce

Stabilní funkce jsou doporučeny pro většinu případů použití a produkčních prostředí. Aktualizují se méně často a pak experimentální funkce.

Experimentální funkce (vývoj)

Experimentální funkce jsou nově vyvíjené možnosti & aktualizace, které nemusí být připravené nebo plně testovány na využití v produkčním prostředí. I když jsou funkce obvykle funkční, můžou zahrnovat některé zásadní změny. Experimentální funkce se používají k přerušení chyb v sadě SDK pro surové součásti a budou dostávat jenom aktualizace po dobu trvání testovacího období.

Jak název označuje, experimentální funkce jsou pro experimentování a nejsou považovány za bezplatné nebo stabilní. Z tohoto důvodu doporučujeme jenom experimentální funkce pokročilým uživatelům, kteří si chtějí vyzkoušet dřívější verze funkcí a aktualizací, a chtěli byste se zúčastnit vytváření sestav chyb a histogramu.

Experimentální funkce jsou označeny oddílem poznámky v odkazu na sadu SDK.

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.

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í
  • Status
  • 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.

Model

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ýkoliv model, který lze načíst prostřednictvím Python 3, nikoli pouze Azure Machine Learning modely.

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.

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

Azure Machine Learning prostředí určují balíčky Pythonu, proměnné prostředí a nastavení softwaru kolem vašich školicích a vyhodnocovacích skriptů. Kromě Pythonu můžete také nakonfigurovat PySpark, Docker a R pro prostředí. Interně prostředí vyplývají z snímků Docker, které se používají ke spouštění procesů školení a bodování na cílovém výpočetním cíli. Prostředí jsou spravována a v rámci vašeho pracovního prostoru Machine Learning entitami se správou verzí, které umožňují reprodukovatelné pracovní postupy, auditovat a přenosné počítače strojového učení napříč různými výpočetními cíli a výpočetními typy.

Můžete použít Environment objekt pro:

  • Vytvořte školicí skript.
  • Používejte stejné prostředí v Azure Machine Learning COMPUTE pro modelové školení ve velkém měřítku.
  • Nasaďte model se stejným prostředím, aniž byste se museli přidružit ke konkrétnímu výpočetnímu typu.

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 privátního kola. Zadejte každou závislost balíčku pomocí třídy, kterou CondaDependency chcete přidat do prostředí PythonSection .

Následující příklad přidá do prostředí. Přidá 1.17.0 verze numpy . Také přidá pillow balíček do prostředí, myenv . V příkladu se používá add_conda_package() Metoda a add_pip_package() metoda, v uvedeném pořadí.

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

Chcete-li odeslat školicí běh, je třeba zkombinovat prostředí, cíl výpočtůa školicí skript Pythonu do konfigurace spuštění. Tato konfigurace je Obálkový objekt, který se používá pro odeslání spuštění.

Když odešlete školicí 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í. Služba ukládá do mezipaměti prostředí. Takže pokud definice prostředí zůstane beze změny, nebudete se zabývat úplným časem nastavení jenom 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í neurčíte prostředí v konfiguraci spuštění, vytvoří se pro vás výchozí prostředí.

Pokud chcete použít prostředí k nasazení webové služby, přečtěte si část 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 Azure Machine Learning je přidružen k pracovnímu prostoru Azure Machine Learning a krok kanálu je přidružen k dostupnému cíli služby COMPUTE v rámci daného pracovního prostoru. 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 stávají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. funkcí

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, které se mají přidat na seznam zakázaný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

InferenceConfigTřída je určena pro nastavení konfigurace, která popisují prostředí potřebné pro 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ý Průvodce přípravou pro nasazení modelu a nasazení webových služeb najdete v tomto postupu.

Prostředí můžete použít při nasazení modelu jako webové služby. Prostředí umožňují reprodukovatelně připojenému pracovnímu postupu, kde můžete model nasadit pomocí stejných knihoven jak v rámci vašeho školicího procesu, tak i ve výpočetním prostředí pro odvození. Interně se prostředí implementují jako image Docker. Můžete použít buď Image poskytované Microsoftem, nebo použít vlastní image Docker. Pokud jste předtím používali ContainerImage třídu pro nasazení, přečtěte si DockerSection třídu pro splnění podobného pracovního postupu s prostředími.

Chcete-li nasadit webovou službu, zkombinujte prostředí, výpočetní výkon, model bodování a registrovaný model do objektu nasazení deploy() .

Následující příklad předpokládá, že jste již dokončili školicí běh pomocí prostředí, myenv a 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.

  • TabularDatasetpředstavuje data v tabulkovém formátu vytvořeném 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 odkazování na více souborů URL.

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.