Co to jest zestaw SDK usługi Azure Machine Learning dla języka Python?What is the Azure Machine Learning SDK for Python?

Analitycy danych i deweloperzy AI używają zestawu SDK usługi Azure Machine Learning dla języka Python do kompilowania i uruchamiania przepływów pracy uczenia maszynowego za pomocą usługi Azure Machine Learning.Data scientists and AI developers use the Azure Machine Learning SDK for Python to build and run machine learning workflows with the Azure Machine Learning service. Z tej usługi można korzystać w dowolnym środowisku języka Python, takim jak notesy programu Jupyter, program Visual Studio Code lub ulubione środowisko IDE języka Python.You can interact with the service in any Python environment, including Jupyter Notebooks, Visual Studio Code, or your favorite Python IDE.

Kluczowe obszary zestawu SDK są następujące:Key areas of the SDK include:

  • Eksplorowanie i przygotowywanie cyklu życia zestawów danych używanych w eksperymentach uczenia maszynowego i zarządzanie nimi.Explore, prepare and manage the lifecycle of your datasets used in machine learning experiments.
  • Zarządzanie zasobami w chmurze na potrzeby monitorowania, rejestrowania i organizowania eksperymentów uczenia maszynowego.Manage cloud resources for monitoring, logging, and organizing your machine learning experiments.
  • Trenowanie modeli lokalnie lub przy użyciu zasobów w chmurze, w tym trenowanie modeli przyśpieszone za pomocą procesora GPU.Train models either locally or by using cloud resources, including GPU-accelerated model training.
  • Użyj automatycznej uczenia maszynowego, które akceptuje parametry konfiguracji i dane szkoleniowe.Use automated machine learning, which accepts configuration parameters and training data. Automatycznie wykonuje ono iterację po algorytmach i ustawieniach hiperparametrów, aby znaleźć najlepszy model do uruchamiania przewidywań.It automatically iterates through algorithms and hyperparameter settings to find the best model for running predictions.
  • Wdrażanie usług internetowych w celu konwertowania wytrenowanych modeli na usługi RESTful, które mogą być wykorzystywane w dowolnych aplikacjach.Deploy web services to convert your trained models into RESTful services that can be consumed in any application.

Aby zapoznać się z przewodnikiem krok po kroku ułatwiającym rozpoczęcie pracy, skorzystaj z samouczka.For a step-by-step walkthrough of how to get started, try the tutorial.

Poniższe sekcje zawierają omówienie najważniejszych klas w zestawie SDK oraz typowe wzorce projektowe na potrzeby ich używania.The following sections are overviews of some of the most important classes in the SDK, and common design patterns for using them. Aby uzyskać zestaw SDK, zobacz przewodnik po instalacji.To get the SDK, see the installation guide.

Stabilny w porównaniu z eksperymentalnymStable vs experimental

Zestaw Azure Machine Learning SDK dla języka Python zapewnia stabilne i eksperymentalne funkcje w tym samym zestawie SDK.The Azure Machine Learning SDK for Python provides both stable and experimental features in the same SDK.

Stabilne funkcjeStable features

Stabilne funkcje są zalecane w przypadku większości przypadków użycia i środowisk produkcyjnych.The stable features are recommended for most use cases and production environments. Są one aktualizowane rzadziej, a następnie funkcje eksperymentalne.They are updated less frequently then experimental features.

Funkcje eksperymentalne (Programowanie)Experimental features (developmental)

Eksperymentalne funkcje są nowo opracowanymi możliwościami & aktualizacje, które mogą nie być gotowe lub w pełni przetestowane pod kątem użycia produkcyjnego.The experimental features are newly developed capabilities & updates that may not be ready or fully tested for production usage. Chociaż funkcje są zwykle funkcjonalne, mogą obejmować pewne istotne zmiany.While the features are typically functional, they can include some breaking changes. Funkcje eksperymentalne są używane do odrywania usterek związanych z rdzeniami SDK i będą otrzymywać tylko aktualizacje na czas trwania okresu testowego.Experimental features are used to iron out SDK breaking bugs, and will only receive updates for the duration of the testing period.

Jako że nazwa wskazuje, eksperymentalne funkcje są przeznaczone do eksperymentowania i nie są uznawane za wolne ani stabilne.As the name indicates, the experimental features are for experimenting and is not considered bug free or stable. Z tego powodu firma Microsoft zaleca tylko eksperymentalne funkcje dla zaawansowanych użytkowników, którzy chcą wypróbować wczesne wersje możliwości i aktualizacji oraz chcieć uczestniczyć w raportowaniu usterek i błędów.For this reason, we only recommend experimental features to advanced users who wish to try out early versions of capabilities and updates, and intend to participate in the reporting of bugs and glitches.

Funkcje eksperymentalne są etykietowane przez sekcję Uwagi w Kompendium zestawu SDK.Experimental features are labelled by a note section in the SDK reference.

WorkspaceWorkspace

Przestrzeń nazw:azureml.core.workspace.WorkspaceNamespace: azureml.core.workspace.Workspace

Klasa Workspace to podstawowy zasób w chmurze umożliwiający eksperymentowanie z modelami uczenia maszynowego, ich trenowanie oraz wdrażanie.The Workspace class is a foundational resource in the cloud that you use to experiment, train, and deploy machine learning models. Łączy ona Twoją subskrypcję i grupę zasobów platformy Azure z łatwym w użyciu obiektem.It ties your Azure subscription and resource group to an easily consumed object.

Zaimportuj klasę i utwórz nowy obszar roboczy przy użyciu następującego kodu.Import the class and create a new workspace by using the following code. Dla elementu create_resource_group ustaw wartość False, jeśli masz już istniejącą grupę zasobów platformy Azure, której chcesz użyć dla tego obszaru roboczego.Set create_resource_group to False if you have a previously existing Azure resource group that you want to use for the workspace. Niektóre funkcje mogą monitować o poświadczenia uwierzytelniania platformy Azure.Some functions might prompt for Azure authentication credentials.

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

Aby użyć tego samego obszaru roboczego w wielu środowiskach, należy najpierw zapisać go w pliku JSON z konfiguracją.Use the same workspace in multiple environments by first writing it to a configuration JSON file. Spowoduje to zapisanie danych dotyczących subskrypcji, zasobu i nazwy obszaru roboczego.This saves your subscription, resource, and workspace name data.

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

Aby załadować obszar roboczy, odczytaj plik konfiguracji.Load your workspace by reading the configuration file.

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

Alternatywnie możesz użyć statycznej metody get(), aby załadować istniejący obszar roboczy bez używania plików konfiguracji.Alternatively, use the static get() method to load an existing workspace without using configuration files.

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

W poniższych przykładach kodu zmienna ws reprezentuje obiekt Workspace.The variable ws represents a Workspace object in the following code examples.

ExperimentExperiment

Przestrzeń nazw:azureml.core.experiment.ExperimentNamespace: azureml.core.experiment.Experiment

Klasa Experiment jest kolejnym podstawowym zasobem w chmurze, który reprezentuje kolekcję prób (poszczególne przebiegi modeli).The Experiment class is another foundational cloud resource that represents a collection of trials (individual model runs). Poniższy kod pobiera obiekt Experiment z klasy Workspace według nazwy lub tworzy nowy obiekt Experiment, jeśli nazwa nie istnieje.The following code fetches an Experiment object from within Workspace by name, or it creates a new Experiment object if the name doesn't exist.

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

Uruchom poniższy kod, aby uzyskać listę wszystkich obiektów Experiment zawartych w klasie Workspace.Run the following code to get a list of all Experiment objects contained in Workspace.

list_experiments = Experiment.list(ws)

Użyj funkcji get_runs, aby pobrać listę obiektów Run (prób) z klasy Experiment.Use the get_runs function to retrieve a list of Run objects (trials) from Experiment. Poniższy kod pobiera przebiegi i drukuje identyfikator każdego przebiegu.The following code retrieves the runs and prints each run ID.

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

Istnieją dwa sposoby wykonania próby eksperymentu.There are two ways to execute an experiment trial. Jeśli eksperymentujesz interaktywnie w notesie programu Jupyter, użyj funkcji start_logging.If you're interactively experimenting in a Jupyter notebook, use the start_logging function. Jeśli przesyłasz eksperyment ze standardowego środowiska języka Python, użyj funkcji submit.If you're submitting an experiment from a standard Python environment, use the submit function. Obie funkcje zwracają obiekt Run.Both functions return a Run object. W poniższych przykładach kodu zmienna experiment reprezentuje obiekt Experiment.The experiment variable represents an Experiment object in the following code examples.

UruchomRun

Przestrzeń nazw:azureml.core.run.RunNamespace: azureml.core.run.Run

Przebieg reprezentuje pojedynczą próbę eksperymentu.A run represents a single trial of an experiment. Run jest obiektem, który służy do monitorowania asynchronicznego wykonywania próby, przechowywania danych wyjściowych próby, analizowania wyników i uzyskiwania dostępu do wygenerowanych artefaktów.Run is the object that you use to monitor the asynchronous execution of a trial, store the output of the trial, analyze results, and access generated artifacts. Użyj obiektu Run w kodzie eksperymentu, aby rejestrować metryki i artefakty w usłudze Run History (Historia przebiegu).You use Run inside your experimentation code to log metrics and artifacts to the Run History service. Oferuje ona m.in. następujące funkcje:Functionality includes:

  • Przechowywanie i pobieranie metryk i danych.Storing and retrieving metrics and data.
  • Używanie tagów i hierarchii podrzędnej w celu łatwego wyszukiwania przeszłych przebiegów.Using tags and the child hierarchy for easy lookup of past runs.
  • Rejestrowanie przechowywanych plików modeli na potrzeby wdrożenia.Registering stored model files for deployment.
  • Przechowywanie, modyfikowanie i pobieranie właściwości przebiegu.Storing, modifying, and retrieving properties of a run.

Utwórz obiekt Run, przesyłając obiekt Experiment za pomocą obiektu konfiguracji przebiegu.Create a Run object by submitting an Experiment object with a run configuration object. Użyj parametru tags, aby dołączyć do przebiegów niestandardowe kategorie i etykiety.Use the tags parameter to attach custom categories and labels to your runs. Możesz je potem łatwo znaleźć i pobrać z klasy Experiment.You can easily find and retrieve them later from Experiment.

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

Użyj statycznej funkcji list, aby uzyskać listę wszystkich obiektów Run z klasy Experiment.Use the static list function to get a list of all Run objects from Experiment. Określ parametr tags, aby filtrować według utworzonego wcześniej tagu.Specify the tags parameter to filter by your previously created tag.

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

Użyj funkcji get_details, aby pobrać szczegółowe dane wyjściowe dla przebiegu.Use the get_details function to retrieve the detailed output for the run.

run_details = run.get_details()

Dane wyjściowe tej funkcji to słownik zawierający następujące elementy:Output for this function is a dictionary that includes:

  • Identyfikator przebieguRun ID
  • StanStatus
  • Godzina rozpoczęcia i zakończeniaStart and end time
  • Docelowy obiekt obliczeniowy (lokalny i w chmurze)Compute target (local versus cloud)
  • Zależności i wersje użyte w przebieguDependencies and versions used in the run
  • Dane specyficzne dla trenowania (różnią się w zależności od typu modelu)Training-specific data (differs depending on model type)

Aby uzyskać więcej przykładów dotyczących konfigurowania i monitorowania przebiegów, zobacz instrukcje.For more examples of how to configure and monitor runs, see the how-to.

ModelModel

Przestrzeń nazw:azureml.core.model.ModelNamespace: azureml.core.model.Model

Klasa Model jest używana do pracy z reprezentacją w chmurze modeli uczenia maszynowego.The Model class is used for working with cloud representations of machine learning models. Metody ułatwiają transferowanie modeli między lokalnymi środowiskami deweloperskimi a obiektem Workspace w chmurze.Methods help you transfer models between local development environments and the Workspace object in the cloud.

Rejestracja modelu umożliwia przechowywanie modeli i ich wersji w chmurze platformy Azure, w swoim obszarze roboczym.You can use model registration to store and version your models in the Azure cloud, in your workspace. Zarejestrowane modele są identyfikowane za pomocą nazwy i wersji.Registered models are identified by name and version. Za każdym razem, gdy rejestrujesz model o takiej samej nazwie, jaką ma już istniejący model, rejestr zwiększa wersję.Each time you register a model with the same name as an existing one, the registry increments the version. Azure Machine Learning obsługuje dowolny model, który może być ładowany za poorednictwem języka Python 3, a nie tylko Azure Machine Learning modele.Azure Machine Learning supports any model that can be loaded through Python 3, not just Azure Machine Learning models.

Poniższy przykład pokazuje, jak utworzyć prosty lokalny model klasyfikacji za pomocą funkcji scikit-learn, zarejestrować model w klasie Workspace i pobrać ten model z chmury.The following example shows how to build a simple local classification model with scikit-learn, register the model in Workspace, and download the model from the cloud.

Utwórz prosty klasyfikator, clf, aby przewidzieć rezygnacje klientów na podstawie ich wieku.Create a simple classifier, clf, to predict customer churn based on their age. Następnie zrzuć model do pliku .pkl w tym samym katalogu.Then dump the model to a .pkl file in the same directory.

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

Użyj funkcji register, aby zarejestrować model w obszarze roboczym.Use the register function to register the model in your workspace. Określ ścieżkę modelu lokalnego i nazwę modelu.Specify the local model path and the model name. Zarejestrowanie tej samej nazwy więcej niż raz spowoduje utworzenie nowej wersji.Registering the same name more than once will create a new version.

from azureml.core.model import Model

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

Teraz, gdy model został zarejestrowany w obszarze roboczym, można łatwo zarządzać modelami oraz pobierać je i organizować.Now that the model is registered in your workspace, it's easy to manage, download, and organize your models. Aby pobrać obiekt modelu (na przykład w innym środowisku) z klasy Workspace, należy użyć konstruktora klasy i określić nazwę modelu oraz wszelkie parametry opcjonalne.To retrieve a model (for example, in another environment) object from Workspace, use the class constructor and specify the model name and any optional parameters. Następnie należy użyć funkcji download, aby pobrać model wraz ze strukturą folderów w chmurze.Then, use the download function to download the model, including the cloud folder structure.

from azureml.core.model import Model
import os

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

Użyj funkcji delete, aby usunąć model z klasy Workspace.Use the delete function to remove the model from Workspace.

model.delete()

Po zarejestrowaniu modelu wdrożenie go jako usługi internetowej jest prostym procesem.After you have a registered model, deploying it as a web service is a straightforward process. Najpierw należy utworzyć i zarejestrować obraz.First you create and register an image. Ten krok umożliwia skonfigurowanie środowiska języka Python wraz z jego zależnościami oraz skryptu do definiowania formatów żądań i odpowiedzi usługi internetowej.This step configures the Python environment and its dependencies, along with a script to define the web service request and response formats. Po utworzeniu obrazu należy utworzyć konfigurację wdrożenia, która określa rdzenie procesora CPU i parametry pamięci dla docelowego obiektu obliczeniowego.After you create an image, you build a deploy configuration that sets the CPU cores and memory parameters for the compute target. Następnie należy dołączyć obraz.You then attach your image.

ComputeTarget, RunConfiguration i ScriptRunConfigComputeTarget, RunConfiguration, and ScriptRunConfig

Przestrzeń nazw:azureml.core.compute.ComputeTargetNamespace: azureml.core.compute.ComputeTarget
Przestrzeń nazw:azureml.core.runconfig.RunConfigurationNamespace: azureml.core.runconfig.RunConfiguration
Przestrzeń nazw:azureml.core.script_run_config.ScriptRunConfigNamespace: azureml.core.script_run_config.ScriptRunConfig

Klasa ComputeTarget jest abstrakcyjną klasą nadrzędną do tworzenia docelowych obiektów obliczeniowych i zarządzania nimi.The ComputeTarget class is the abstract parent class for creating and managing compute targets. Docelowy obiekt obliczeniowy reprezentuje różnorodne zasoby, w których można trenować modele uczenia maszynowego.A compute target represents a variety of resources where you can train your machine learning models. Docelowym obiektem obliczeniowym może być komputer lokalny lub zasób w chmurze, taki jak środowisko obliczeniowe usługi Azure Machine Learning, usługa Azure HDInsight lub zdalna maszyna wirtualna.A compute target can be either a local machine or a cloud resource, such as Azure Machine Learning Compute, Azure HDInsight, or a remote virtual machine.

Użyj docelowych obiektów obliczeniowych, aby wykorzystać zalety zaawansowanych maszyn wirtualnych do trenowania modeli, i skonfiguruj trwałe docelowe obiekty obliczeniowe lub tymczasowe docelowe obiekty obliczeniowe wywoływane przez środowisko uruchomieniowe.Use compute targets to take advantage of powerful virtual machines for model training, and set up either persistent compute targets or temporary runtime-invoked targets. Aby zapoznać się z kompleksowym przewodnikiem po konfigurowaniu docelowych obiektów obliczeniowych i zarządzaniu nimi, zobacz instrukcje.For a comprehensive guide on setting up and managing compute targets, see the how-to.

Poniższy kod przedstawia prosty przykład konfigurowania obiektu docelowego AmlCompute (klasa podrzędna klasy ComputeTarget).The following code shows a simple example of setting up an AmlCompute (child class of ComputeTarget) target. Ten obiekt docelowy tworzy zasób obliczeniowy zdalnego środowiska uruchomieniowego w obiekcie Workspace.This target creates a runtime remote compute resource in your Workspace object. Zasób jest skalowany automatycznie po przesłaniu zadania.The resource scales automatically when a job is submitted. Jest on usuwany automatycznie po zakończeniu przebiegu.It's deleted automatically when the run finishes.

Użyj ponownie prostego modelu rezygnacji scikit-learn i skompiluj go w jego własnym pliku, train.py, w bieżącym katalogu.Reuse the simple scikit-learn churn model and build it into its own file, train.py, in the current directory. Na końcu pliku utwórz nowy katalog o nazwie outputs.At the end of the file, create a new directory called outputs. Ten krok powoduje utworzenie katalogu w chmurze (Twój obszar roboczy) do przechowywania wytrenowanego modelu serializowanego za pomocą funkcji joblib.dump().This step creates a directory in the cloud (your workspace) to store your trained model that joblib.dump() serialized.

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

Następnie utwórz docelowy obiekt obliczeniowy, tworząc wystąpienie obiektu RunConfiguration i ustawiając typ oraz rozmiar.Next you create the compute target by instantiating a RunConfiguration object and setting the type and size. W tym przykładzie użyto najmniejszego rozmiaru zasobu (1 rdzeń procesora CPU, 3,5 GB pamięci).This example uses the smallest resource size (1 CPU core, 3.5 GB of memory). Zmienna list_vms zawiera listę obsługiwanych maszyn wirtualnych i ich rozmiarów.The list_vms variable contains a list of supported virtual machines and their sizes.

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"

Utwórz zależności dla środowiska Python zdalnego zasobu obliczeniowego, używając klasy CondaDependencies.Create dependencies for the remote compute resource's Python environment by using the CondaDependencies class. Plik train.py używa narzędzi scikit-learn i numpy, które należy zainstalować w środowisku.The train.py file is using scikit-learn and numpy, which need to be installed in the environment. Możesz również określić wersje zależności.You can also specify versions of dependencies. Użyj obiektu dependencies, aby ustawić środowisko w elemencie compute_config.Use the dependencies object to set the environment in 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

Teraz możesz przesłać eksperyment.Now you're ready to submit the experiment. Użyj klasy ScriptRunConfig, aby dołączyć konfigurację docelowego obiektu obliczeniowego i określić ścieżkę/plik do skryptu treningowego train.py.Use the ScriptRunConfig class to attach the compute target configuration, and to specify the path/file to the training script train.py. Prześlij eksperyment, określając parametr config funkcji submit().Submit the experiment by specifying the config parameter of the submit() function. Wywołaj funkcję wait_for_completion w wynikowym przebiegu, aby wyświetlić dane wyjściowe przebiegu asynchronicznego po zainicjowaniu środowiska i wytrenowaniu modelu.Call wait_for_completion on the resulting run to see asynchronous run output as the environment is initialized and the model is trained.

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 zakończeniu przebiegu plik wytrenowanego modelu churn-model.pkl będzie dostępny w obszarze roboczym.After the run finishes, the trained model file churn-model.pkl is available in your workspace.

ŚrodowiskoEnvironment

Przestrzeń nazw:azureml.core.environmentNamespace: azureml.core.environment

Środowiska Azure Machine Learning określają pakiety języka Python, zmienne środowiskowe i ustawienia oprogramowania wokół skryptów szkoleń i oceniania.Azure Machine Learning environments specify the Python packages, environment variables, and software settings around your training and scoring scripts. Oprócz języka Python można także skonfigurować PySpark, Docker i R dla środowisk.In addition to Python, you can also configure PySpark, Docker and R for environments. Wewnętrznie środowiska powodują tworzenie obrazów platformy Docker, które są używane do uruchamiania procesów szkolenia i oceniania w elemencie docelowym obliczeń.Internally, environments result in Docker images that are used to run the training and scoring processes on the compute target. Środowiska są zarządzane i obsługiwane przez program w obszarze roboczym Machine Learning, które umożliwiają powtarzalny, z inspekcją i przenośne przepływy pracy uczenia maszynowego w różnych obiektach docelowych obliczeń i typach obliczeń.The environments are managed and versioned entities within your Machine Learning workspace that enable reproducible, auditable, and portable machine learning workflows across a variety of compute targets and compute types.

Możesz użyć obiektu, Environment Aby:You can use an Environment object to:

  • Opracowywanie skryptu szkoleniowego.Develop your training script.
  • Ponownie Użyj tego samego środowiska na Azure Machine Learning COMPUTE na potrzeby szkolenia modeli na dużą skalę.Reuse the same environment on Azure Machine Learning Compute for model training at scale.
  • Wdróż model przy użyciu tego samego środowiska bez konieczności powiązania z określonym typem obliczenia.Deploy your model with that same environment without being tied to a specific compute type.

Poniższy kod importuje Environment klasę z zestawu SDK i tworzy wystąpienie obiektu środowiska.The following code imports the Environment class from the SDK and to instantiates an environment object.

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

Dodaj pakiety do środowiska przy użyciu plików Conda, PIP lub Private koła.Add packages to an environment by using Conda, pip, or private wheel files. Określ każdą zależność pakietu przy użyciu CondaDependency klasy, aby dodać ją do środowiska PythonSection .Specify each package dependency by using the CondaDependency class to add it to the environment's PythonSection.

Poniższy przykład dodaje do środowiska.The following example adds to the environment. Dodaje wersję 1.17.0 numpy .It adds version 1.17.0 of numpy. Dodaje również pillow pakiet do środowiska, myenv .It also adds the pillow package to the environment, myenv. W przykładzie zastosowano add_conda_package() odpowiednio metodę i add_pip_package() metodę.The example uses the add_conda_package() method and the add_pip_package() method, respectively.

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

Aby przesłać przebieg szkolenia, należy połączyć środowisko, obiekt docelowy obliczeńi Twój szkoleniowy skrypt w języku Python do konfiguracji uruchomieniowej.To submit a training run, you need to combine your environment, compute target, and your training Python script into a run configuration. Ta konfiguracja jest obiektem otoki używanym do przesyłania przebiegów.This configuration is a wrapper object that's used for submitting runs.

Podczas przesyłania przebiegu szkoleniowego Kompilowanie nowego środowiska może potrwać kilka minut.When you submit a training run, the building of a new environment can take several minutes. Czas trwania zależy od rozmiaru wymaganych zależności.The duration depends on the size of the required dependencies. Środowiska są buforowane przez usługę.The environments are cached by the service. Tak długo, jak definicja środowiska pozostaje niezmieniona, ponosisz pełny czas instalacji tylko raz.So as long as the environment definition remains unchanged, you incur the full setup time only once.

Poniższy przykład pokazuje, gdzie używać ScriptRunConfig jako obiektu otoki.The following example shows where you would use ScriptRunConfig as your wrapper object.

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)

Jeśli nie określisz środowiska w konfiguracji uruchomieniowej przed przesłaniem przebiegu, zostanie utworzone środowisko domyślne.If you don't specify an environment in your run configuration before you submit the run, then a default environment is created for you.

Zapoznaj się z sekcją Wdrażanie modelu , aby użyć środowisk do wdrożenia usługi sieci Web.See the Model deploy section to use environments to deploy a web service.

Pipeline, PythonScriptStepPipeline, PythonScriptStep

Przestrzeń nazw:azureml.pipeline.core.pipeline.PipelineNamespace: azureml.pipeline.core.pipeline.Pipeline
Przestrzeń nazw:azureml.pipeline.steps.python_script_step.PythonScriptStepNamespace: azureml.pipeline.steps.python_script_step.PythonScriptStep

Potok usługi Azure Machine Learning to zautomatyzowany przepływ pracy kompletnego zadania uczenia maszynowego.An Azure Machine Learning pipeline is an automated workflow of a complete machine learning task. Podzadania są zamknięte jako serie kroków w potoku.Subtasks are encapsulated as a series of steps within the pipeline. Potok usługi Azure Machine Learning może być tak prosty, jak jeden krok, który wywołuje skrypt języka Python.An Azure Machine Learning pipeline can be as simple as one step that calls a Python script. Potoki zawierają następujące funkcje:Pipelines include functionality for:

  • Przygotowywanie danych, takie jak importowanie, weryfikowanie i czyszczenie, zniekształcanie i przekształcanie, normalizacja i przemieszczanieData preparation including importing, validating and cleaning, munging and transformation, normalization, and staging
  • Konfigurowanie trenowania obejmujące parametryzację argumentów, ścieżki plików i konfiguracje rejestrowania/raportowaniaTraining configuration including parameterizing arguments, filepaths, and logging / reporting configurations
  • Wydajne i wielokrotne trenowanie i weryfikowanie, które może obejmować określanie konkretnych podzestawów danych, różne sprzętowe zasoby obliczeniowe, przetwarzanie rozproszone i monitorowanie postępuTraining and validating efficiently and repeatably, which might include specifying specific data subsets, different hardware compute resources, distributed processing, and progress monitoring
  • Wdrażanie, w tym przechowywanie wersji, skalowanie, aprowizowanie i kontrola dostępuDeployment, including versioning, scaling, provisioning, and access control
  • Publikowanie potoku w punkcie końcowym REST w celu ponownego uruchomienia z dowolnej biblioteki HTTPPublishing a pipeline to a REST endpoint to rerun from any HTTP library

Klasa PythonScriptStep to podstawowy, wbudowany krok umożliwiający uruchomienie skryptu języka Python na docelowym obiekcie obliczeniowym.A PythonScriptStep is a basic, built-in step to run a Python Script on a compute target. Pobiera ona nazwę skryptu i inne parametry opcjonalne, takie jak argumenty dla skryptu, docelowy obiekt obliczeniowy, dane wejściowe i wyjściowe.It takes a script name and other optional parameters like arguments for the script, compute target, inputs and outputs. Poniższy kod jest prostym przykładem klasy PythonScriptStep.The following code is a simple example of a PythonScriptStep. Aby zapoznać się z przykładem skryptu train.py, zobacz podsekcję samouczek.For an example of a train.py script, see the tutorial sub-section.

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 utworzeniu co najmniej jednego kroku można połączyć ze sobą kroki i opublikować je jako prosty, zautomatyzowany potok.After at least one step has been created, steps can be linked together and published as a simple automated pipeline.

from azureml.pipeline.core import Pipeline

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

Aby zapoznać się z kompleksowym przykładem tworzenia przepływu pracy potoku, zobacz zaawansowany samouczek.For a comprehensive example of building a pipeline workflow, follow the advanced tutorial.

Wzorzec tworzenia i używania potokówPattern for creating and using pipelines

Potok Azure Machine Learning jest skojarzony z obszarem roboczym Azure Machine Learning, a krok potoku jest skojarzony z elementem docelowym obliczeń dostępnym w tym obszarze roboczym.An Azure Machine Learning pipeline is associated with an Azure Machine Learning workspace and a pipeline step is associated with a compute target available within that workspace. Aby uzyskać więcej informacji, zobacz ten artykuł dotyczący obszarów roboczych lub to objaśnienie docelowych obiektów obliczeniowych.For more information, see this article about workspaces or this explanation of compute targets.

Typowy wzorzec dla kroków potoku jest następujący:A common pattern for pipeline steps is:

  1. Określenie obszaru roboczego, zasobów obliczeniowych i magazynuSpecify workspace, compute, and storage
  2. Skonfigurowanie danych wejściowych i wyjściowych przy użyciu następujących klas:Configure your input and output data using
    1. Zestaw danych , który udostępnia istniejącą usługę Azure datastoreDataset which makes available an existing Azure datastore
    2. PipelineDataset, która zawiera typizowane dane tabelarycznePipelineDataset which encapsulates typed tabular data
    3. PipelineData, która jest używana na potrzeby pośrednich danych pliku lub katalogu zapisywanych w jednym kroku i przeznaczonych do użycia w innymPipelineData which is used for intermediate file or directory data written by one step and intended to be consumed by another
  3. Zdefiniowanie co najmniej jednego kroku potokuDefine one or more pipeline steps
  4. Utworzenie wystąpienia potoku przy użyciu obszaru roboczego i krokówInstantiate a pipeline using your workspace and steps
  5. Utworzenie eksperymentu, do którego zostanie przesłany potokCreate an experiment to which you submit the pipeline
  6. Monitorowanie wyników eksperymentuMonitor the experiment results

Ten notes jest dobrym przykładem takiego wzorca.This notebook is a good example of this pattern. zleceńjob

Aby uzyskać więcej informacji na temat potoków usługi Azure Machine Learning, a w szczególności o tym, jak różnią się one od innych typów potoków, zobacz ten artykuł.For more information about Azure Machine Learning Pipelines, and in particular how they are different from other types of pipelines, see this article.

AutoMLConfigAutoMLConfig

Przestrzeń nazw:azureml.train.automl.automlconfig.AutoMLConfigNamespace: azureml.train.automl.automlconfig.AutoMLConfig

Użyj klasy AutoMLConfig, aby skonfigurować parametry automatycznego trenowania uczenia maszynowego.Use the AutoMLConfig class to configure parameters for automated machine learning training. Zautomatyzowane uczenie maszynowe iteruje po wielu kombinacjach algorytmów uczenia maszynowego i ustawieniach hiperparametrów.Automated machine learning iterates over many combinations of machine learning algorithms and hyperparameter settings. Następnie znajduje najlepiej dopasowany model na podstawie wybranej metryki dokładności.It then finds the best-fit model based on your chosen accuracy metric. Konfiguracja umożliwia określenie następujących elementów:Configuration allows for specifying:

  • Typ zadania (klasyfikacja, regresja, prognozowanie)Task type (classification, regression, forecasting)
  • Liczba iteracji algorytmu i maksymalny czas na iteracjęNumber of algorithm iterations and maximum time per iteration
  • Metryka dokładności na potrzeby optymalizacjiAccuracy metric to optimize
  • Algorytmy do umieszczenia na liście niedozwolonych/dozwolonychAlgorithms to blacklist/whitelist
  • Liczba weryfikacji krzyżowychNumber of cross-validations
  • Docelowe obiekty obliczenioweCompute targets
  • Dane szkolenioweTraining data

Uwaga

Użyj dodatkowej funkcji automl w swojej instalacji, aby użyć zautomatyzowanego uczenia maszynowego.Use the automl extra in your installation to use automated machine learning.

Aby zapoznać się z szczegółowymi wskazówkami i przykładami konfigurowania eksperymentów zautomatyzowanego uczenia maszynowego, zapoznaj się z samouczkiem i instrukcjami.For detailed guides and examples of setting up automated machine learning experiments, see the tutorial and how-to.

Poniższy kod ilustruje kompilowanie obiektu konfiguracji zautomatyzowanego uczenia maszynowego dla modelu klasyfikacji i używanie go podczas przesyłania eksperymentu.The following code illustrates building an automated machine learning configuration object for a classification model, and using it when you're submitting an experiment.

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
                            )

Użyj obiektu automl_config, aby przesłać eksperyment.Use the automl_config object to submit an experiment.

from azureml.core.experiment import Experiment

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

Po przesłaniu eksperymentu dane wyjściowe pokazują dokładność trenowania dla każdej iteracji po jej zakończeniu.After you submit the experiment, output shows the training accuracy for each iteration as it finishes. Po zakończeniu przebiegu zostanie zwrócony obiekt AutoMLRun (rozszerzający klasę Run).After the run is finished, an AutoMLRun object (which extends the Run class) is returned. Uzyskaj optymalny model, używając funkcji get_output() w celu zwrócenia obiektu Model.Get the best-fit model by using the get_output() function to return a Model object.

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

Wdrażanie modeluModel deploy

Przestrzeń nazw:azureml.core.model.InferenceConfigNamespace: azureml.core.model.InferenceConfig
Przestrzeń nazw:azureml.core.webservice.webservice.WebserviceNamespace: azureml.core.webservice.webservice.Webservice

InferenceConfigKlasa jest dla ustawień konfiguracji, które opisują środowisko konieczne do hostowania modelu i usługi sieci Web.The InferenceConfig class is for configuration settings that describe the environment needed to host the model and web service.

Webservice jest abstrakcyjną klasą nadrzędną na potrzeby tworzenia i wdrażania usług internetowych dla modeli.Webservice is the abstract parent class for creating and deploying web services for your models. Szczegółowy przewodnik dotyczący przygotowania do wdrożenia modelu i wdrażania usług sieci Web znajduje się w temacie jak to zrobić.For a detailed guide on preparing for model deployment and deploying web services, see this how-to.

Środowiska można używać podczas wdrażania modelu jako usługi sieci Web.You can use environments when you deploy your model as a web service. Środowiska umożliwiają przekształcenie połączonego przepływu pracy, w którym można wdrożyć model przy użyciu tych samych bibliotek zarówno w ramach obliczeń szkoleniowych, jak i obliczeń wnioskowania.Environments enable a reproducible, connected workflow where you can deploy your model using the same libraries in both your training compute and your inference compute. Wewnętrznie środowiska są implementowane jako obrazy platformy Docker.Internally, environments are implemented as Docker images. Możesz użyć dowolnego obrazu dostarczonego przez firmę Microsoft lub użyć własnych niestandardowych obrazów platformy Docker.You can use either images provided by Microsoft, or use your own custom Docker images. Jeśli wcześniej używasz ContainerImage klasy dla danego wdrożenia, zapoznaj się z DockerSection klasą w celu osiągnięcia podobnego przepływu pracy w środowiskach.If you were previously using the ContainerImage class for your deployment, see the DockerSection class for accomplishing a similar workflow with environments.

Aby wdrożyć usługę sieci Web, Połącz środowisko, obliczenia wnioskowania, skrypt oceniania i zarejestrowany model w obiekcie wdrożenia deploy() .To deploy a web service, combine the environment, inference compute, scoring script, and registered model in your deployment object, deploy().

W poniższym przykładzie przyjęto założenie, że zostało już wykonane uruchomienie szkolenia przy użyciu środowiska, myenv i chcesz wdrożyć ten model do Azure Container Instances.The following example, assumes you already completed a training run using environment, myenv, and want to deploy that model to 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)

W tym przykładzie tworzymy usługę internetową Azure Container Instances, która najlepiej nadaje się do testowania na małą skalę i szybkich wdrożeń.This example creates an Azure Container Instances web service, which is best for small-scale testing and quick deployments. Aby wdrożyć model jako usługę internetową w skali produkcyjnej, użyj usługi Azure Kubernetes Service (AKS).To deploy your model as a production-scale web service, use Azure Kubernetes Service (AKS). Aby uzyskać więcej informacji, zobacz Klasa AksCompute.For more information, see AksCompute class.

DatasetDataset

Przestrzeń nazw:azureml.core.dataset.DatasetNamespace: azureml.core.dataset.Dataset
Przestrzeń nazw:azureml.data.file_dataset.FileDatasetNamespace: azureml.data.file_dataset.FileDataset
Przestrzeń nazw:azureml.data.tabular_dataset.TabularDatasetNamespace: azureml.data.tabular_dataset.TabularDataset

Klasa Dataset jest podstawowym zasobem na potrzeby eksplorowania danych i zarządzania nimi w usłudze Azure Machine Learning.The Dataset class is a foundational resource for exploring and managing data within Azure Machine Learning. Możesz eksplorować dane przy użyciu statystyk podsumowujących i zapisywać zestawy danych w obszarze roboczym usługi AML, aby uzyskać dostęp do funkcji przechowywania wersji i odtwarzania.You can explore your data with summary statistics, and save the Dataset to your AML workspace to get versioning and reproducibility capabilities. Modele z łatwością wykorzystują zestawy danych podczas trenowania.Datasets are easily consumed by models during training. Aby uzyskać szczegółowe przykłady użycia, zobacz przewodnik z instrukcjami.For detailed usage examples, see the how-to guide.

  • TabularDatasetreprezentuje dane w formacie tabelarycznym utworzonym przez analizowanie pliku lub listy plików.TabularDataset represents data in a tabular format created by parsing a file or list of files.
  • Element FileDataset odwołuje się do jednego lub wielu plików w magazynach danych lub z publicznych adresów URL.FileDataset references single or multiple files in datastores or from public URLs.

Poniższy przykład pokazuje, jak utworzyć element TabularDataset wskazujący pojedynczą ścieżkę w magazynie danych.The following example shows how to create a TabularDataset pointing to a single path in a datastore.

from azureml.core import Dataset

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

Poniższy przykład pokazuje, jak utworzyć odwołanie do FileDataset wielu adresów URL plików.The following example shows how to create a FileDataset referencing multiple file URLs.

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)

Następne krokiNext steps

Skorzystaj z poniższych następnych kroków, aby dowiedzieć się, jak używać zestawu SDK usługi Azure Machine Learning dla języka Python:Try these next steps to learn how to use the Azure Machine Learning SDK for Python:

  • Wykonaj samouczek, aby dowiedzieć się, jak tworzyć, trenować i wdrażać model w języku Python.Follow the tutorial to learn how to build, train, and deploy a model in Python.

  • Wyszukaj klasy i moduły w dokumentacji referencyjnej w tej witrynie, korzystając ze spisu treści po lewej stronie.Look up classes and modules in the reference documentation on this site by using the table of contents on the left.