Reutilice entornos para entrenamiento e implementación con Azure Machine Learning.Reuse environments for training & deployment with Azure Machine Learning.

Se aplica a: síBasic Edition síEnterprise Edition                    (Actualización a Enterprise Edition)APPLIES TO: yesBasic edition yesEnterprise edition                    (Upgrade to Enterprise edition)

En este artículo, aprenderá a crear y administrar entornos de Azure Machine Learning para que pueda realizar el seguimiento de las dependencias de software de sus proyectos y reproducirlas a medida que evolucionan.In this article, learn how to create and manage Azure Machine Learning environments so you can track and reproduce your projects' software dependencies as they evolve.

La administración de dependencias de software es una tarea común para los desarrolladores.Software dependency management is a common task for developers. Hay que asegurarse de que las compilaciones se puedan reproducir sin mucha configuración manual del software.You want to be able to ensure that builds are reproducible without a lot of manual software configuration. Teniendo en cuenta soluciones para el desarrollo local, como pip y Conda, la clase Environment de Azure Machine Learning ofrece una solución para el desarrollo en la nube local y distribuido.With solutions for local development, such as pip and Conda in mind, the Azure Machine Learning Environments class provides a solution for both local and distributed cloud development.

En los ejemplos de este artículo se muestran los siguientes procedimientos:The examples in this article show how to:

  • Creación de un entorno y especificación de dependencias de paquetesCreate an environment and specify package dependencies
  • Recuperación y actualización de entornosRetrieve and update environments
  • Uso del entorno para el entrenamientoUse environment for training
  • Uso del entorno para la implementación de servicios webUse environment for web service deployment

¿Qué son los entornos?What are environments

Los entornos especifican los paquetes, las variables de entorno y la configuración de software de Python que rodean a los scripts de entrenamiento y puntuación, y los tiempos de ejecución (Python, Spark o Docker).Environments specify the Python packages, environment variables, and software settings around your training and scoring scripts, and run times (Python, Spark, or Docker). Son entidades administradas y con control de versiones en el área de trabajo de Azure Machine Learning que permiten flujos de trabajo de aprendizaje automático reproducibles, auditables y portátiles en distintos destinos de proceso.They are managed and versioned entities within your Azure Machine Learning workspace that enable reproducible, auditable, and portable machine learning workflows across different compute targets.

Puede usar un objeto de entorno en el proceso local para desarrollar el script de entrenamiento, volver a usar ese mismo entorno en Proceso de Machine Learning para el entrenamiento de modelos a escala e incluso implementar el modelo con ese mismo entorno.You can use an environment object on your local compute to develop your training script, reuse that same environment on Azure Machine Learning Compute for model training at scale, and even deploy your model with that same environment.

A continuación se ilustra que el mismo objeto de entorno se puede usar en la configuración de ejecución para el entrenamiento y en la configuración de inferencia e implementación para las implementaciones de servicios web.The following illustrates that the same environment object can be used in both your run configuration for training and in your inference and deployment configuration for web service deployments.

Diagrama del entorno del flujo de trabajo de aprendizaje automático

Tipos de entornosTypes of environments

Los entornos se pueden dividir a grandes rasgos en tres categorías: mantenidos, administrados por el usuario y administrados por el sistema.Environments can broadly be divided into three categories: curated, user-managed and system-managed.

Los entornos mantenidos los proporciona Azure Machine Learning y están disponibles en el área de trabajo de forma predeterminada.Curated environments are provided by Azure Machine Learning and are available in your workspace by default. Contienen colecciones de paquetes de Python y configuraciones que le ayudarán a empezar a usar diferentes marcos de aprendizaje automático.They contain collections of Python packages and settings to help you get started different machine learning frameworks.

Para un entorno administrado por usuarios, es responsable de configurar el entorno e instalar todos los paquetes que necesita el script de entrenamiento en el destino de proceso.For a user-managed environment, you're responsible for setting up your environment and installing every package your training script needs on the compute target. Conda no comprobará el entorno ni instalará nada por usted.Conda will not check your environment or install anything for you.

Use entornos administrados por el sistema cuando quiera que Conda administre el entorno de Python y las dependencias de script.System-managed environments are used when you want Conda to manage the Python environment and the script dependencies for you. El servicio asume el uso de este tipo de entorno de forma predeterminada, debido a su utilidad en destinos de proceso remotos que no se pueden configurar manualmente.The service assumes this type of environment by default, due to its usefulness on remote compute targets that are not manually configurable.

Requisitos previosPrerequisites

Creación de un entornoCreate an environment

Hay varias maneras de crear un entorno para los experimentos.There are multiple ways to create an environment for your experiments.

Uso de entornos mantenidosUse curated environment

Puede seleccionar uno de los entornos mantenidos para empezar.You can select one of the curated environments to start with.

  • El entorno AzureML-minimal contiene un conjunto mínimo de paquetes para habilitar el seguimiento de ejecución y la carga de recursos.The AzureML-Minimal environment contains a minimal set of packages to enable run tracking and asset uploading. Puede utilizarlo como punto inicial para su propio entorno.You can use it as a starting point for your own environment.

  • El entorno AzureML-tutorial contiene paquetes de ciencia de datos comunes, como Scikit-Learn, Pandas y Matplotlib, y un conjunto mayor de paquetes de azureml-SDK.The AzureML-Tutorial environment contains common data science packages, such as Scikit-Learn, Pandas and Matplotlib, and larger set of azureml-sdk packages.

Los entornos mantenidos están respaldados por imágenes de Docker en caché, lo que reduce el costo de preparación de la ejecución.Curated environments are backed by cached Docker images, reducing the run preparation cost.

Use el método Environment.get para seleccionar uno de los entornos mantenidos:Use 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")

Puede enumerar los entornos mantenidos y sus paquetes mediante el código siguiente:You can list the curated environments and their packages using 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())

Advertencia

No inicie el nombre de su propio entorno con el prefijo AzureML.Do not start your own environment name with AzureML prefix. Está reservado para entornos mantenidos.It is reserved for curated environments.

Creación de instancias de un objeto de entornoInstantiate an environment object

Para crear manualmente un entorno, importe la clase Environment desde el SDK y cree una instancia de un objeto de entorno con el código siguiente.To manually create an environment, import the Environment class from the SDK and instantiate an environment object with the following code.

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

Archivos de especificación de Conda y pipConda and pip specification files

También puede crear un entorno a partir de una especificación de Conda o de un archivo de requisitos de pip.You can also create an environment from a Conda specification or a pip requirements file. Use el método from_conda_specification() o from_pip_requirements() e incluya el nombre del entorno y la ruta de acceso del archivo deseado en el argumento del método.Use the from_conda_specification() or the from_pip_requirements() method, and include your environment name and the file path of the desired file in the method argument.

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

Entorno de Conda existenteExisting Conda environment

Si tiene un entorno de Conda en el equipo local, el servicio ofrece una solución para crear un objeto de entorno a partir de él.If you have an existing Conda environment on your local computer, the service offers a solution for creating an environment object from it. De este modo, puede volver a usar el entorno interactivo local en ejecuciones remotas.This way you can reuse your local interactive environment on remote runs.

El código siguiente crea un objeto de entorno fuera del entorno de Conda existente mycondaenv con el método from_existing_conda_environment().The following code creates an environment object out of the existing Conda environment mycondaenv with the from_existing_conda_environment() method.

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

Creación automática de entornosAutomatically create environments

Cree un entorno automáticamente mediante el envío de una ejecución de entrenamiento con el método submit().Automatically create an environment by submitting a training run with the submit() method. Cuando se envía una ejecución de entrenamiento, la creación de un entorno puede tardar varios minutos, según el tamaño de las dependencias necesarias.When you submit a training run, the building of new environment can take several minutes depending on the size of the required dependencies.

Si no especifica un entorno en la configuración de ejecución antes de enviar la ejecución, se crea un entorno predeterminado.If you don't specify an environment in your run configuration prior to submitting the run, a default environment is created for you.

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

# Attaches training script and compute target to run config
runconfig = ScriptRunConfig(source_directory=".", script="example.py")
runconfig.run_config.target = "local"

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

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

Del mismo modo, si usa un objeto Estimator para el entrenamiento, puede enviar la instancia del estimador directamente como una ejecución sin tener que especificar un entorno.Similarly, if you use an Estimator object for training you can submit the estimator instance directly as a run without having to specify an environment. El objeto Estimator ya encapsula el entorno y el destino de proceso.The Estimator object already encapsulates the environment and compute target.

Adición de paquetes a un entornoAdd packages to an environment

Agregue paquetes a un entorno con los archivos de Conda, pip o Private Wheel.Add packages to an environment with Conda, pip, or private wheel files. Especifique cada dependencia de paquete mediante la clase CondaDependency y agréguela a la parte PythonSection del entorno.Specify each package dependency using the CondaDependency class, and add it to the environment's PythonSection.

Paquetes Conda y pipConda and pip packages

Si un paquete está disponible en un repositorio de paquetes de Conda, se recomienda usar la instalación de Conda sobre pip.If a package is available in a Conda package repository, it is recommended to use the Conda over pip installation. La razón es que los paquetes de Conda suelen incluir archivos binarios pregenerados que hacen que la instalación sea más confiable.The reason is that Conda packages typically come with pre-built binaries that make installation more reliable.

En el ejemplo siguiente se agrega scikit-learn, en concreto la versión 0.21.3, y el paquete pillow al entorno, myenv con los métodos add_conda_package() y add_pip_package(), respectivamente.The following example adds scikit-learn, specifically version 0.21.3, and pillow package to the environment, myenv with the add_conda_package() and add_pip_package() methods, respectively.

from azureml.core import Environment
from azureml.core.environment import CondaDependencies

myenv = Environment(name="myenv")
conda_dep = CondaDependencies()

# Installs scikit-learn version 0.21.3 conda package
conda_dep.add_conda_package("scikit-learn==0.21.3")

# Adds dependencies to PythonSection of myenv
myenv.python.conda_dependencies=conda_dep

Archivos de Private WheelPrivate wheel files

Para usar archivos pip de Private Wheel, primero cárguelos en el almacenamiento del área de trabajo mediante el método estático add_private_pip_wheel(), capture luego la dirección URL de almacenamiento y pásela al método add_pip_package().You can use private pip wheel files by first uploading it to your workspace storage by using static add_private_pip_wheel() method, then capturing the storage URL, and passing the URL to the add_pip_package() method

# During environment creation the service replaces the URL by secure SAS URL, so your wheel file is kept private and secure
whl_url = Environment.add_private_pip_wheel(workspace=ws,file_path = "my-custom.whl")
myenv = Environment(name="myenv")
conda_dep = CondaDependencies()
conda_dep.add_pip_package(whl_url)
myenv.python.conda_dependencies=conda_dep

Administración de entornosManage environments

Administre los entornos para que pueda actualizarlos, realizar su seguimiento y reutilizarlos en todos los destinos de proceso y con otros usuarios del área de trabajo.Manage environments so you can update, track, and reuse them across compute targets and with other users of the workspace.

Registro de entornosRegister environments

El entorno se registra automáticamente en el área de trabajo cuando se envía una ejecución o se implementa un servicio web.The environment is automatically registered with your workspace when you submit a run or deploy a web service. También puede registrar manualmente el entorno mediante el método register().You can also manually register the environment using the register() method. Esta operación convierte el entorno en una entidad con control de versiones y de la que se realiza el seguimiento, y que se puede compartir entre los usuarios del área de trabajo.This operation makes the environment into an entity that is tracked and versioned in the cloud, and can be shared between workspace users.

El código siguiente registra el entorno myenv en el área de trabajo ws.The following code registers the environment, myenv, to the workspace, ws.

myenv.register(workspace=ws)

Cuando se usa por primera vez el entorno, en el entrenamiento o la implementación, se registra en el área de trabajo, se compila y se implementa en el destino de proceso.When used for the first time, in training or deployment, the environment is registered with the workspace, built, and deployed on the compute target. Los entornos se almacenan en caché en el servicio.The environments are cached by the service. La reutilización de un entorno almacenado en caché tarda mucho menos tiempo que el uso de un nuevo servicio o uno que se haya actualizado.Reusing a cached environment takes much less time than using a new service or one that has been updated.

Obtención de los entornos existentesGet existing environments

La clase Environment ofrece métodos que permiten recuperar los entornos existentes en el área de trabajo por nombre, en forma de lista o mediante una ejecución de entrenamiento específica con fines de solución de problemas o auditoría y de reproducibilidad.The Environment class offers methods that allow you to retrieve existing environments in your workspace by name, as a list or by specific training run for troubleshooting or auditing purposes, as well as reproducibility.

Visualización de la lista de entornosView list of environments

Vea los entornos del área de trabajo con Environment.list(workspace="workspace_name") y seleccione uno para reutilizarlo.View the environments in your workspace with Environment.list(workspace="workspace_name"), and then select one to reuse.

Obtención del entorno por nombreGet environment by name

También puede obtener un entorno específico por nombre y versión.You can also get a specific environment by name and version. El código siguiente usa el método get() para recuperar la versión 1 del entorno myenv del área de trabajo ws.The following code uses the get() method to retrieve version 1 of the environment, myenv on the ws workspace.

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

Entorno específico de la ejecución de entrenamientoTraining run specific environment

Para obtener el entorno usado en una ejecución concreta después de que se complete el entrenamiento, use el método get_environment() en la clase Run.To get the environment used for a specific run after training completes, use the get_environment() method in the Run class.

from azureml.core import Run
Run.get_environment()

Actualización de un entorno existenteUpdate an existing environment

Si realiza cambios en un entorno existente, como agregar un paquete de Python, se crea una nueva versión de un entorno cuando se envía la ejecución, se implementa el modelo o se registra manualmente el entorno.If you make changes to an existing environment, such as add a Python package, a new version of an environment is created when you either submit run, deploy model, or manually register the environment. El control de versiones le permite ver los cambios en el entorno a lo largo del tiempo.The versioning allows you to view changes to the environment over time.

Para actualizar una versión de paquete de Python de un entorno existente, especifique el número de versión exacto de ese paquete.To update a Python package version of an existing environment, specify the exact version number for that package. De lo contrario, Azure Machine Learning volverá a usar el entorno existente con las versiones de paquete de cuando se creó el entorno.Otherwise, the Azure Machine Learning will reuse the existing environment with package versions from when the environment was created.

Depuración de la compilación de la imagenDebug the image build

En este ejemplo se usa el método build() para crear manualmente un entorno como una imagen de Docker y se supervisan los registros de salida de la compilación de la imagen mediante wait_for_completion().This example uses the build() method to create an environment manually as a Docker image, and monitors the output logs from the image build using wait_for_completion(). La imagen compilada aparece entonces en la instancia de Azure Container Registry del área de trabajo, lo que resulta útil para la depuración.The built image then appears under the workspace Azure Container Registry, which is helpful for debugging.

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

Docker y entornosDocker and environments

DockerSection de la clase Environments de Azure Machine Learning le permite personalizar y controlar en detalle el sistema operativo invitado en el que se ejecuta la ejecución de entrenamiento.The DockerSection of the Azure Machine Learning Environments class, allows you to customize and control in detail the guest operating system in which your training run executes.

Cuando se usa el comando enable para habilitar Docker, el servicio compila una imagen de Docker y crea un entorno de Python con las especificaciones dentro de ese contenedor de Docker.When you enable Docker, the service builds a Docker image and creates a Python environment with your specifications within that Docker container. Este entorno ofrece aislamiento y reproducibilidad adicionales para las ejecuciones de entrenamiento.This provides additional isolation and reproducibility for your training runs.

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

Una vez creada, la imagen de Docker aparece en la instancia de Azure Container Registry que está asociada de forma predeterminada al área de trabajo.Once built, the Docker image appears in the Azure Container Registry that's associated with the workspace, by default. El nombre del repositorio tiene el formato azureml/azureml_<uuid> .The repository name has the form azureml/azureml_<uuid>. La parte del identificador único (uuid) corresponde a un hash calculado a partir de la configuración del entorno.The unique identifier (uuid) part corresponds to a hash computed from the environment configuration. Esto permite que el servicio determine si ya existe una imagen correspondiente al entorno dado para reutilizar.This allows the service to determine whether an image corresponding to the given environment already exists for reuse.

Además, el servicio usa automáticamente una de las imágenes base basadas en Ubuntu Linux e instala los paquetes de Python especificados.Additionally, the service automatically uses one of the Ubuntu Linux-based base images, and installs the specified Python packages. La imagen base tiene versiones de CPU y GPU.The base image has CPU and GPU versions. Azure Machine Learning detecta automáticamente qué versión se va a usar.Azure Machine Learning automatically detects which version to use.

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

Nota

Si especifica environment.python.user_managed_dependencies=False al usar una imagen de Docker personalizada, el servicio creará un entorno de Conda dentro de la imagen y ejecutará la ejecución en ese entorno, en lugar de usar las bibliotecas de Python que puede haber instalado en la imagen base.If you specify environment.python.user_managed_dependencies=False while using a custom Docker image, the service will build a Conda environment within the image and execute the run in that environment, instead of using Python libraries you may have installed on the base image. Establezca el parámetro en True para usar sus propios paquetes instalados.Set the parameter to True to use your own installed packages.

Uso de entornos para el entrenamientoUsing environments for training

Para enviar una ejecución de entrenamiento, debe combinar el entorno, el destino de proceso y el script de Python de entrenamiento en una configuración de ejecución; un objeto contenedor que se usa para el envío de ejecuciones.To submit a training run, you need to combine your environment, compute target and training Python script into a run configuration; a wrapper object used for submitting runs.

Cuando se envía una ejecución de entrenamiento, la creación de un nuevo entorno puede tardar varios minutos, según el tamaño de las dependencias necesarias.When you submit a training run, the building of a new environment can take several minutes depending on the size of the required dependencies. El servicio almacena en caché los entornos, por lo tanto, siempre y cuando la definición del entorno permanezca sin cambios, solo se incurrirá una vez en el tiempo de configuración completo.The environments are cached by the service, therefore as long as the environment definition remains unchanged, the full setup time is incurred only once.

A continuación se proporciona un ejemplo de ejecución de script local en el que se usaría ScriptRunConfig como objeto contenedor.The following local script run example shows where you would use ScriptRunConfig as your wrapper object.

from azureml.core import Environment, ScriptRunConfig, Experiment

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)

Nota

Para deshabilitar el historial de ejecución o ejecutar instantáneas, use el valor de ScriptRunConfig.run_config.history.To disable run history or run snapshots, use the setting under ScriptRunConfig.run_config.history.

Si no especifica el entorno en la configuración de ejecución, el servicio creará un entorno predeterminado cuando envíe la ejecución.If you don't specify the environment in your run configuration, the service will create a default environment for you when you submit your run.

Entrenamiento con un estimadorTrain with an estimator

Si usa un estimador para el entrenamiento, puede enviar simplemente la instancia del estimador directamente, puesto que ya encapsula el entorno y el destino de proceso.If you are using an estimator for training, you can simply submit the estimator instance directly, as it already encapsulates the environment and compute target.

El siguiente código usa un estimador para una ejecución de entrenamiento de un solo nodo en un proceso remoto para un modelo scikit-learn; se supone que hay un objeto de destino de proceso creado previamente, compute_target, y un objeto de almacén de datos, ds.The following code uses an estimator for a single-node training run on a remote compute for a scikit-learn model, and assumes a previously created compute target object, compute_target and datastore object, ds.

from azureml.train.estimator import Estimator

script_params = {
    '--data-folder': ds.as_mount(),
    '--regularization': 0.8
}

sk_est = Estimator(source_directory='./my-sklearn-proj',
                   script_params=script_params,
                   compute_target=compute_target,
                   entry_script='train.py',
                   conda_packages=['scikit-learn'])

# Submit the run 
run = experiment.submit(sk_est)

Uso de entornos para la implementación de servicios webUsing environments for web service deployment

Puede usar entornos al implementar el modelo como un servicio web.You can use environments when deploying your model as a web service. Esto permite un flujo de trabajo reproducible y conectado en el que puede entrenar, probar e implementar el modelo exactamente mediante las mismas bibliotecas en los procesos de entrenamiento e inferencia.This enables a reproducible, connected workflow where you can train, test, and deploy your model using the exact same libraries in both your training and inference computes.

Para implementar un servicio web, combine el entorno, el proceso de inferencia, el script de puntuación y el modelo registrado en el objeto de implementación, deploy().To deploy a web service, combine the environment, inference compute, scoring script, and registered model in your deployment object, deploy(). Más información sobre cómo implementar servicios web.Learn more about deploying web services.

En este ejemplo, suponga que ha completado una ejecución de entrenamiento y quiere implementar ese modelo en Azure Container Instance (ACI).In this example, assume you have completed a training run and want to deploy that model to an Azure Container Instance (ACI). Al compilar el servicio web, los archivos de modelo y puntuación se montan en la imagen y la pila de inferencia de Azure Machine Learning se agrega a la imagen.When building 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)

Cuadernos de ejemploExample notebooks

Este cuaderno de ejemplo amplía los conceptos y métodos que se muestran en este artículo.This example notebook expands upon concepts and methods demonstrated in this article.

Pasos siguientesNext steps