Tworzenie & korzystania ze środowisk oprogramowania w programie Azure Machine LearningCreate & use software environments in Azure Machine Learning

W tym artykule dowiesz się, jak tworzyć środowiskaAzure Machine Learning i zarządzać nimi.In this article, learn how to create and manage Azure Machine Learning environments. Używaj środowisk do śledzenia i odtwarzania zależności oprogramowania projektów podczas ich rozwoju.Use the environments to track and reproduce your projects' software dependencies as they evolve.

Zarządzanie zależnościami oprogramowania to typowe zadanie dla deweloperów.Software dependency management is a common task for developers. Chcesz upewnić się, że kompilacje są odtwarzalne bez rozbudowanej ręcznej konfiguracji oprogramowania.You want to ensure that builds are reproducible without extensive manual software configuration. Klasy Azure Machine Learning są Environment kontami dla lokalnych rozwiązań programistycznych, takich jak PIP i Conda i rozbudowane programowanie w chmurze za pomocą możliwości platformy Docker.The Azure Machine Learning Environment class accounts for local development solutions such as pip and Conda and distributed cloud development through Docker capabilities.

W przykładach w tym artykule przedstawiono sposób wykonywania tych operacji:The examples in this article show how to:

  • Utwórz środowisko i określ zależności pakietów.Create an environment and specify package dependencies.
  • Pobierz i zaktualizuj środowiska.Retrieve and update environments.
  • Użyj środowiska do uczenia się.Use an environment for training.
  • Użyj środowiska do wdrożenia usługi sieci Web.Use an environment for web service deployment.

Aby uzyskać ogólne omówienie sposobu działania środowisk w Azure Machine Learning, zobacz co to są środowiska ml?For a high-level overview of how environments work in Azure Machine Learning, see What are ML environments? Informacje o konfigurowaniu środowisk programistycznych znajdują się tutaj.For information about configuring development environments, see here.

Wymagania wstępnePrerequisites

Tworzenie środowiskaCreate an environment

W poniższych sekcjach opisano różne sposoby tworzenia środowiska dla eksperymentów.The following sections explore the multiple ways that you can create an environment for your experiments.

Tworzenie wystąpienia obiektu środowiskaInstantiate an environment object

Aby ręcznie utworzyć środowisko, zaimportuj Environment klasę z zestawu SDK.To manually create an environment, import the Environment class from the SDK. Następnie użyj poniższego kodu, aby utworzyć wystąpienie obiektu środowiska.Then use the following code to instantiate an environment object.

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

Korzystanie z nadzorowanego środowiskaUse a curated environment

Środowiska nadzorowane zawierają kolekcje pakietów języka Python i są domyślnie dostępne w obszarze roboczym.Curated environments contain collections of Python packages and are available in your workspace by default. Te środowiska są obsługiwane przez buforowane obrazy platformy Docker, co zmniejsza koszt przygotowania do uruchomienia.These environments are backed by cached Docker images which reduces the run preparation cost. Możesz wybrać jedno z tych popularnych środowisk nadzorowanych, aby zacząć od:You can select one of these popular curated environments to start with:

  • Środowisko Azure-minimalne zawiera minimalny zestaw pakietów umożliwiających śledzenie uruchamiania i przekazywanie zasobów.The AzureML-Minimal environment contains a minimal set of packages to enable run tracking and asset uploading. Można go użyć jako punktu wyjścia dla własnego środowiska.You can use it as a starting point for your own environment.

  • Środowisko uczenia maszynowego zawiera wspólne pakiety do nauki o danych.The AzureML-Tutorial environment contains common data science packages. Pakiety te obejmują Scikit-uczenie, Pandas, matplotlib i większy zestaw pakietów Azure SDK.These packages include Scikit-Learn, Pandas, Matplotlib, and a larger set of azureml-sdk packages.

Aby zapoznać się z listą środowisk nadzorowanych, zapoznaj się z artykułem środowiska nadzorowane.For a list of curated environments, see the curated environments article.

Użyj Environment.get metody, aby wybrać jedno z nadzorowanych środowisk:Use the Environment.get method to select one of the curated environments:

from azureml.core import Workspace, Environment

ws = Workspace.from_config()
env = Environment.get(workspace=ws, name="AzureML-Minimal")

Można wyświetlić listę środowisk nadzorowanych i ich pakietów przy użyciu następującego kodu:You can list the curated environments and their packages by using the following code:

envs = Environment.list(workspace=ws)

for env in envs:
    if env.startswith("AzureML"):
        print("Name",env)
        print("packages", envs[env].python.conda_dependencies.serialize_to_string())

Ostrzeżenie

Nie uruchamiaj nazwy środowiska z prefiksem platformy Azure .Don't start your own environment name with the AzureML prefix. Ten prefiks jest zarezerwowany dla środowisk nadzorowanych.This prefix is reserved for curated environments.

Korzystanie z Conda zależności lub plików wymagań PIPUse Conda dependencies or pip requirements files

Środowisko można utworzyć na podstawie specyfikacji Conda lub pliku wymagań PIP.You can create an environment from a Conda specification or a pip requirements file. Użyj from_conda_specification() metody lub from_pip_requirements() metody.Use the from_conda_specification() method or the from_pip_requirements() method. W argumencie metody Podaj nazwę środowiska i ścieżkę do pliku, który chcesz.In the method argument, include your environment name and the file path of the file that you want.

# From a Conda specification file
myenv = Environment.from_conda_specification(name = "myenv",
                                             file_path = "path-to-conda-specification-file")

# From a pip requirements file
myenv = Environment.from_pip_requirements(name = "myenv",
                                          file_path = "path-to-pip-requirements-file")                                          

Włącz platformę DockerEnable Docker

Po włączeniu platformy Docker Azure Machine Learning kompiluje obraz platformy Docker i utworzy środowisko Python w tym kontenerze z uwzględnieniem specyfikacji.When you enable Docker, Azure Machine Learning builds a Docker image and creates a Python environment within that container, given your specifications. Obrazy platformy Docker są buforowane i ponownie używane: pierwszy przebieg w nowym środowisku zazwyczaj trwa dłużej, gdy obraz jest kompilowany.The Docker images are cached and reused: the first run in a new environment typically takes longer as the image is build.

DockerSection Environment Klasa Azure Machine Learning umożliwia precyzyjne dostosowywanie i kontrolowanie systemu operacyjnego gościa, w którym jest uruchamiane szkolenie.The DockerSection of the Azure Machine Learning Environment class allows you to finely customize and control the guest operating system on which you run your training. argumentsZmienna może służyć do określania dodatkowych argumentów do przekazania do polecenia Docker Run.The arguments variable can be used to specify extra arguments to pass to the Docker run command.

# Creates the environment inside a Docker container.
myenv.docker.enabled = True

Nowo utworzony obraz platformy Docker jest domyślnie wyświetlany w rejestrze kontenerów skojarzonym z obszarem roboczym.By default, the newly built Docker image appears in the container registry that's associated with the workspace. Nazwa repozytorium ma postać Azure/azureml_ <uuid>.The repository name has the form azureml/azureml_<uuid>. Część unikatowego identyfikatora (UUID) nazwy odpowiada skrótowi obliczonemu na podstawie konfiguracji środowiska.The unique identifier (uuid) part of the name corresponds to a hash that's computed from the environment configuration. Ta zgodność umożliwia usłudze określenie, czy obraz danego środowiska już istnieje do ponownego użycia.This correspondence allows the service to determine whether an image for the given environment already exists for reuse.

Używanie prekompilowanego obrazu platformy DockerUse a prebuilt Docker image

Domyślnie usługa automatycznie używa jednego z obrazów podstawowychopartych na Ubuntu Linux, a w odnoszących się do nich zdefiniowanych przez azureml.core.environment.DEFAULT_CPU_IMAGE .By default, the service automatically uses one of the Ubuntu Linux-based base images, specifically the one defined by azureml.core.environment.DEFAULT_CPU_IMAGE. Następnie instaluje wszystkie określone pakiety języka Python zdefiniowane przez podane środowisko usługi Azure ML.It then installs any specified Python packages defined by the provided Azure ML environment. Inne obrazy bazowe procesora i GPU platformy Azure są dostępne w repozytoriumkontenerów.Other Azure ML CPU and GPU base images are available in the container repository. Istnieje również możliwość użycia niestandardowego obrazu platformy Docker.It is also possible to use a custom Docker base image.

# Specify custom Docker base image and registry, if you don't want to use the defaults
myenv.docker.base_image="your_base-image"
myenv.docker.base_image_registry="your_registry_location"

Ważne

Azure Machine Learning obsługuje tylko obrazy platformy Docker, które udostępniają następujące oprogramowanie:Azure Machine Learning only supports Docker images that provide the following software:

  • Ubuntu 16,04 lub nowszy.Ubuntu 16.04 or greater.
  • Conda 4.5. # lub nowszej.Conda 4.5.# or greater.
  • Python 3.6 +.Python 3.6+.

Korzystanie z własnych pliku dockerfileUse your own Dockerfile

Możesz również określić niestandardowy pliku dockerfile.You can also specify a custom Dockerfile. Najprostszym rozwiązaniem jest rozpoczęcie od jednego z Azure Machine Learning obrazów podstawowych przy użyciu polecenia Docker FROM , a następnie dodanie własnych kroków niestandardowych.It's simplest to start from one of Azure Machine Learning base images using Docker FROM command, and then add your own custom steps. Użyj tej metody, jeśli chcesz zainstalować pakiety inne niż środowisko Python jako zależności.Use this approach if you need to install non-Python packages as dependencies. Pamiętaj, aby ustawić obraz podstawowy na brak.Remember to set the base image to None.

Należy pamiętać, że język Python jest niejawną zależnością w Azure Machine Learning dlatego, że niestandardowe pliku dockerfile muszą mieć zainstalowany język Python.Please note that Python is an implicit dependency in Azure Machine Learning so a custom dockerfile must have Python installed.

# Specify docker steps as a string. 
dockerfile = r"""
FROM mcr.microsoft.com/azureml/base:intelmpi2018.3-ubuntu16.04
RUN echo "Hello from custom container!"
"""

# Set base image to None, because the image is defined by dockerfile.
myenv.docker.base_image = None
myenv.docker.base_dockerfile = dockerfile

# Alternatively, load the string from a file.
myenv.docker.base_image = None
myenv.docker.base_dockerfile = "./Dockerfile"

W przypadku używania niestandardowych obrazów platformy Docker zaleca się Przypinanie wersji pakietów w celu lepszego zapewnienia odtwarzalności.When using custom Docker images, it is recommended that you pin package versions in order to better ensure reproducibility.

Określ własny interpreter języka PythonSpecify your own Python interpreter

W niektórych sytuacjach niestandardowy obraz podstawowy może już zawierać środowisko Python z pakietami, które mają być używane.In some situations, your custom base image may already contain a Python environment with packages that you want to use.

Aby użyć własnych zainstalowanych pakietów i wyłączyć Conda, należy ustawić parametr Environment.python.user_managed_dependencies = True .To use your own installed packages and disable Conda, set the parameter Environment.python.user_managed_dependencies = True. Upewnij się, że obraz podstawowy zawiera interpreter języka Python i ma pakiety, których potrzebuje Twój skrypt szkoleniowy.Ensure that the base image contains a Python interpreter, and has the packages your training script needs.

Na przykład aby uruchomić program w podstawowym środowisku Miniconda z zainstalowanym pakietem NumPy, należy najpierw określić pliku dockerfile z krokiem instalacji pakietu.For example, to run in a base Miniconda environment that has NumPy package installed, first specify a Dockerfile with a step to install the package. Następnie ustaw zależności zarządzane przez użytkownika na True .Then set the user-managed dependencies to True.

Możesz również określić ścieżkę do określonego interpretera języka Python w obrazie, ustawiając Environment.python.interpreter_path zmienną.You can also specify a path to a specific Python interpreter within the image, by setting the Environment.python.interpreter_path variable.

dockerfile = """
FROM mcr.microsoft.com/azureml/base:intelmpi2018.3-ubuntu16.04
RUN conda install numpy
"""

myenv.docker.base_image = None
myenv.docker.base_dockerfile = dockerfile
myenv.python.user_managed_dependencies=True
myenv.python.interpreter_path = "/opt/miniconda/bin/python"

Ostrzeżenie

Jeśli zainstalowano niektóre zależności języka Python w obrazie platformy Docker i zapomnisz ustawić user_managed_dependencies=True , te pakiety nie będą istniały w środowisku wykonywania w taki sposób, aby powodowały błędy środowiska uruchomieniowego.If you install some Python dependencies in your Docker image and forget to set user_managed_dependencies=True, those packages will not exist in the execution environment thus causing runtime failures. Domyślnie platforma Azure ML utworzy środowisko Conda z określonymi zależnościami i wykona przebieg w tym środowisku, zamiast korzystać z bibliotek języka Python zainstalowanych na podstawowym obrazie.By default, Azure ML will build a Conda environment with dependencies you specified, and will execute the run in that environment instead of using any Python libraries that you installed on the base image.

Pobierz szczegóły obrazuRetrieve image details

W przypadku zarejestrowanego środowiska można pobrać szczegóły obrazu przy użyciu następującego kodu, gdzie details jest wystąpieniem DockerImageDetails (azure Python SDK >= 1,11) i zawiera wszystkie informacje o obrazie środowiska, takie jak pliku dockerfile, rejestr i nazwa obrazu.For a registered environment, you can retrieve image details using the following code where details is an instance of DockerImageDetails (AzureML Python SDK >= 1.11) and provides all the information about the environment image such as the dockerfile, registry, and image name.

details = environment.get_image_details(workspace=ws)

Aby uzyskać szczegółowe informacje o obrazie ze środowiska automatycznie zapisanego w ramach wykonywania przebiegu, użyj następującego kodu:To obtain the image details from an environment autosaved from the execution of a run, use the following code:

details = run.get_environment().get_image_details(workspace=ws)

Korzystanie z istniejących środowiskUse existing environments

Jeśli masz istniejące środowisko Conda na komputerze lokalnym, możesz użyć usługi do utworzenia obiektu środowiska.If you have an existing Conda environment on your local computer, then you can use the service to create an environment object. Korzystając z tej strategii, można ponownie użyć lokalnego środowiska interaktywnego na zdalnych uruchomieniach.By using this strategy, you can reuse your local interactive environment on remote runs.

Poniższy kod tworzy obiekt środowiska z istniejącego środowiska Conda mycondaenv .The following code creates an environment object from the existing Conda environment mycondaenv. Używa from_existing_conda_environment() metody.It uses the from_existing_conda_environment() method.

myenv = Environment.from_existing_conda_environment(name="myenv",
                                                    conda_environment_name="mycondaenv")

Definicję środowiska można zapisać w katalogu w łatwo edytowalnym formacie za pomocą save_to_directory() metody.An environment definition can be saved to a directory in an easily editable format with the save_to_directory() method. Po zmodyfikowaniu nowe środowisko można utworzyć wystąpienie przez załadowanie plików z katalogu.Once modified, a new environment can be instantiated by loading files from the directory.

# save the enviroment
myenv.save_to_directory(path="path-to-destination-directory", overwrite=False)
# modify the environment definition
newenv = Environment.load_from_directory(path="path-to-source-directory")

Niejawnie Używaj środowiska domyślnegoImplicitly use the default environment

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

from azureml.core import ScriptRunConfig, Experiment, Environment
# Create experiment 
myexp = Experiment(workspace=ws, name = "environment-example")

# Attach training script and compute target to run config
src = ScriptRunConfig(source_directory=".", script="example.py", compute_target="local")

# Submit the run
run = myexp.submit(config=src)

# Show each step of run 
run.wait_for_completion(show_output=True)

Dodawanie pakietów do środowiskaAdd packages to an environment

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.Specify each package dependency by using the CondaDependency class. Dodaj go do środowiska PythonSection .Add it to the environment's PythonSection.

Pakiety Conda i PIPConda and pip packages

Jeśli pakiet jest dostępny w repozytorium pakietu Conda, zalecamy użycie instalacji programu Conda zamiast instalacji PIP.If a package is available in a Conda package repository, then we recommend that you use the Conda installation rather than the pip installation. Pakiety Conda są zwykle dołączone do wstępnie skompilowanych plików binarnych, które zwiększają niezawodność instalacji.Conda packages typically come with prebuilt binaries that make installation more reliable.

Poniższy przykład dodaje do środowiska myenv .The following example adds to the environment myenv. Dodaje wersję 1.17.0 numpy .It adds version 1.17.0 of numpy. Dodaje również pillow pakiet.It also adds the pillow package. 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

Możesz również dodać zmienne środowiskowe do środowiska.You can also add environment variables to your environment. Stają się one dostępne przy użyciu systemu operacyjnego. environ —. get w skrypcie szkoleniowym.These then become available using os.environ.get in your training script.

myenv.environment_variables = {"MESSAGE":"Hello from Azure Machine Learning"}

Ważne

Jeśli używasz tej samej definicji środowiska dla innego uruchomienia, usługa Azure Machine Learning ponownie używa buforowanego obrazu środowiska.If you use the same environment definition for another run, the Azure Machine Learning service reuses the cached image of your environment. W przypadku tworzenia środowiska z przypiętym zależnością pakietu, na przykład, numpy to środowisko będzie korzystać z zainstalowanej wersji pakietu w momencie tworzenia środowiska.If you create an environment with an unpinned package dependency, for example numpy, that environment will keep using the package version installed at the time of environment creation. Ponadto wszystkie przyszłe środowiska ze zgodną definicją będą nadal używane w starej wersji.Also, any future environment with matching definition will keep using the old version. Aby uzyskać więcej informacji, zobacz Tworzenie środowiska, buforowanie i ponowne użycie.For more information, see Environment building, caching, and reuse.

Prywatne pakiety języka PythonPrivate Python packages

Aby w sposób prywatny i bezpieczny używać pakietów języka Python bez ujawniania ich w publicznej sieci Internet, zapoznaj się z artykułem jak używać prywatnych pakietów języka Python.To use Python packages privately and securely without exposing them to the public internet, see the article How to use private Python packages.

Zarządzanie środowiskamiManage environments

Zarządzaj środowiskami, aby można było je aktualizować, śledzić i ponownie używać w celach obliczeniowych i z innymi użytkownikami obszaru roboczego.Manage environments so that you can update, track, and reuse them across compute targets and with other users of the workspace.

Zarejestruj środowiskaRegister environments

Środowisko jest automatycznie rejestrowane w obszarze roboczym podczas przesyłania uruchomienia lub wdrożenia usługi sieci Web.The environment is automatically registered with your workspace when you submit a run or deploy a web service. Możesz również ręcznie zarejestrować środowisko przy użyciu register() metody.You can also manually register the environment by using the register() method. Ta operacja powoduje, że środowisko jest śledzone i zgodne z wersją w chmurze.This operation makes the environment into an entity that's tracked and versioned in the cloud. Jednostka może być współdzielona między użytkownikami obszaru roboczego.The entity can be shared between workspace users.

Poniższy kod rejestruje środowisko w myenv ws obszarze roboczym.The following code registers the myenv environment to the ws workspace.

myenv.register(workspace=ws)

W przypadku korzystania ze środowiska po raz pierwszy w szkole lub wdrożeniu zostanie ono zarejestrowane w obszarze roboczym.When you use the environment for the first time in training or deployment, it's registered with the workspace. Następnie zostanie skompilowany i wdrożony w miejscu docelowym obliczeń.Then it's built and deployed on the compute target. Usługa buforuje środowiska.The service caches the environments. W przypadku korzystania z pamięci podręcznej trwa znacznie mniej czasu niż w przypadku użycia nowej usługi lub aktualizacji, która została zaktualizowana.Reusing a cached environment takes much less time than using a new service or one that has been updated.

Pobierz istniejące środowiskaGet existing environments

EnvironmentKlasa oferuje metody umożliwiające pobieranie istniejących środowisk w obszarze roboczym.The Environment class offers methods that allow you to retrieve existing environments in your workspace. Możesz pobrać środowiska według nazwy, listy lub określonego przebiegu szkoleniowego.You can retrieve environments by name, as a list, or by a specific training run. Te informacje ułatwiają rozwiązywanie problemów, inspekcję i odtwarzalność.This information is helpful for troubleshooting, auditing, and reproducibility.

Wyświetlanie listy środowiskView a list of environments

Wyświetl środowiska w obszarze roboczym przy użyciu Environment.list(workspace="workspace_name") klasy.View the environments in your workspace by using the Environment.list(workspace="workspace_name") class. Następnie wybierz środowisko do ponownego użycia.Then select an environment to reuse.

Pobieranie środowiska według nazwyGet an environment by name

Możesz również uzyskać określone środowisko według nazwy i wersji.You can also get a specific environment by name and version. Poniższy kod używa get() metody do pobierania wersji 1 myenv środowiska w ws obszarze roboczym.The following code uses the get() method to retrieve version 1 of the myenv environment on the ws workspace.

restored_environment = Environment.get(workspace=ws,name="myenv",version="1")

Uczenie środowiska określonego dla uruchamianiaTrain a run-specific environment

Aby uzyskać środowisko, które zostało użyte do określonego uruchomienia po zakończeniu szkolenia, użyj get_environment() metody w Run klasie.To get the environment that was used for a specific run after the training finishes, use the get_environment() method in the Run class.

from azureml.core import Run
Run.get_environment()

Aktualizowanie istniejącego środowiskaUpdate an existing environment

Załóżmy, że zmienisz istniejące środowisko, na przykład dodając pakiet języka Python.Say you change an existing environment, for example, by adding a Python package. To zajmie czas kompilowania, ponieważ nowa wersja środowiska zostanie utworzona podczas przesyłania przebiegu, wdrażania modelu lub ręcznego rejestrowania środowiska.This will take time to build as a new version of the environment is then created when you submit a run, deploy a model, or manually register the environment. Wersja pozwala przeglądać zmiany środowiska w miarę upływu czasu.The versioning allows you to view the environment's changes over time.

Aby zaktualizować wersję pakietu języka Python w istniejącym środowisku, określ numer wersji tego pakietu.To update a Python package version in an existing environment, specify the version number for that package. Jeśli nie używasz dokładnego numeru wersji, Azure Machine Learning będzie ponownie używać istniejącego środowiska z oryginalnymi wersjami pakietu.If you don't use the exact version number, then Azure Machine Learning will reuse the existing environment with its original package versions.

Debuguj kompilację obrazuDebug the image build

Poniższy przykład używa build() metody do ręcznego tworzenia środowiska jako obrazu platformy Docker.The following example uses the build() method to manually create an environment as a Docker image. Monitoruje dzienniki wyjściowe z kompilacji obrazu przy użyciu wait_for_completion() .It monitors the output logs from the image build by using wait_for_completion(). Utworzony obraz zostanie wyświetlony w wystąpieniu Azure Container Registry obszaru roboczego.The built image then appears in the workspace's Azure Container Registry instance. Te informacje ułatwiają debugowanie.This information is helpful for debugging.

from azureml.core import Image
build = env.build(workspace=ws)
build.wait_for_completion(show_output=True)

Warto najpierw skompilować obrazy lokalnie przy użyciu build_local() metody.It is useful to first build images locally using the build_local() method. Aby skompilować obraz platformy Docker, ustaw opcjonalny parametr useDocker=True .To build a docker image, set the optional parameter useDocker=True. Aby wypchnąć otrzymany obraz do rejestru kontenerów obszaru roboczego platformy Azure, ustaw polecenie pushImageToWorkspaceAcr=True .To push the resulting image into the AzureML workspace container registry, set pushImageToWorkspaceAcr=True.

build = env.build_local(workspace=ws, useDocker=True, pushImageToWorkspaceAcr=True)

Ostrzeżenie

Zmiana kolejności zależności lub kanałów w środowisku spowoduje nowe środowisko i będzie wymagało nowej kompilacji obrazu.Changing the order of dependencies or channels in an environment will result in a new environment and will require a new image build. Ponadto wywoływanie build() metody dla istniejącego obrazu spowoduje zaktualizowanie jego zależności, jeśli są dostępne nowe wersje.In addition, calling the build() method for an existing image will update its dependencies if there are new versions.

Używanie środowisk do szkoleniaUse environments for training

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 lokalnego uruchomienia skryptu pokazuje, gdzie używać ScriptRunConfig jako obiektu otoki.The following local script run 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")

# Configure the ScriptRunConfig and specify the environment
src = ScriptRunConfig(source_directory=".", script="train.py", target="local", environment=myenv)

# Submit run 
run = exp.submit(src)

Uwaga

Aby wyłączyć historię uruchamiania lub uruchamiać migawki, użyj ustawienia w obszarze src.run_config.history .To disable the run history or run snapshots, use the setting under src.run_config.history.

Jeśli nie określisz środowiska w konfiguracji uruchomieniowej, usługa utworzy środowisko domyślne podczas przesyłania przebiegu.If you don't specify the environment in your run configuration, then the service creates a default environment when you submit your run.

Używanie środowisk do wdrażania usług sieci WebUse environments for web service deployment

Ś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. Ta funkcja umożliwia przeodtwarzalny, połączony przepływ pracy.This capability enables a reproducible, connected workflow. W tym przepływie pracy można nauczyć, testować i wdrażać model przy użyciu tych samych bibliotek w ramach obliczeń szkoleniowych i obliczeń wnioskowania.In this workflow, you can train, test, and deploy your model by using the same libraries in both your training compute and your inference compute.

Jeśli definiujesz własne środowisko wdrożenia usługi sieci Web, musisz wyświetlić listę azureml-defaults z wersją >= 1.0.45 jako zależność PIP.If you are defining your own environment for web service deployment, you must list azureml-defaults with version >= 1.0.45 as a pip dependency. Ten pakiet zawiera funkcje, które są konieczne do hostowania modelu jako usługi sieci Web.This package contains the functionality that's needed to host the model as a web service.

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(). Aby uzyskać więcej informacji, zobacz jak i gdzie wdrażać modele.For more information, see How and where to deploy models.

W tym przykładzie przyjęto założenie, że zostało wykonane uruchomienie szkoleniowe.In this example, assume that you've completed a training run. Teraz chcesz wdrożyć ten model do Azure Container Instances.Now you want to deploy that model to Azure Container Instances. Podczas kompilowania usługi sieci Web pliki modelu i oceniania są instalowane na obrazie, a do obrazu zostanie dodany stos wnioskowania Azure Machine Learning.When you build the web service, the model and scoring files are mounted on the image, and the Azure Machine Learning inference stack is added to the image.

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)

NotebooksNotebooks

Ten artykuł zawiera informacje dotyczące sposobu instalowania środowiska Conda jako jądra w notesie.This article provides information about how to install a Conda environment as a kernel in a notebook.

Wdrożenie modelu przy użyciu niestandardowego obrazu podstawowego platformy Docker demonstruje sposób wdrażania modelu przy użyciu niestandardowego obrazu podstawowego platformy Docker.Deploy a model using a custom Docker base image demonstrates how to deploy a model using a custom Docker base image.

W tym przykładowym notesie pokazano, jak wdrożyć model Spark jako usługę sieci Web.This example notebook demonstrates how to deploy a Spark model as a web service.

Tworzenie środowisk i zarządzanie nimi za pomocą interfejsu wiersza poleceniaCreate and manage environments with the CLI

Interfejs wiersza polecenia Azure Machine Learning stanowi odbicie większości funkcji zestawu SDK języka Python.The Azure Machine Learning CLI mirrors most of the functionality of the Python SDK. Służy do tworzenia środowisk i zarządzania nimi.You can use it to create and manage environments. Polecenia omówione w tej sekcji przedstawiają podstawowe funkcje.The commands that we discuss in this section demonstrate fundamental functionality.

Następujące polecenie tworzy szkielet plików dla domyślnej definicji środowiska w określonym katalogu.The following command scaffolds the files for a default environment definition in the specified directory. Te pliki są plikami JSON.These files are JSON files. Działają one podobnie do odpowiedniej klasy w zestawie SDK.They work like the corresponding class in the SDK. Za pomocą tych plików można tworzyć nowe środowiska z ustawieniami niestandardowymi.You can use the files to create new environments that have custom settings.

az ml environment scaffold -n myenv -d myenvdir

Uruchom następujące polecenie, aby zarejestrować środowisko z określonego katalogu.Run the following command to register an environment from a specified directory.

az ml environment register -d myenvdir

Uruchom następujące polecenie, aby wyświetlić listę wszystkich zarejestrowanych środowisk.Run the following command to list all registered environments.

az ml environment list

Pobierz zarejestrowane środowisko przy użyciu następującego polecenia.Download a registered environment by using the following command.

az ml environment download -n myenv -d downloaddir

Następne krokiNext steps