Creación y uso de entornos de software en Azure Machine Learning

SE APLICA A:Azure ML del SDK de Python v1

En este artículo, aprenda a crear y administrar entornos de Azure Machine Learning. Use los entornos para realizar un seguimiento de las dependencias de software de sus proyectos y reproducirlas a medida que evolucionan.

La administración de dependencias de software es una tarea común para los desarrolladores. Quiere asegurarse de que las compilaciones se puedan reproducir sin demasiada configuración manual del software. La clase Environment de Azure Machine Learning representa las soluciones para el desarrollo local, como PIP y Conda, y el desarrollo en la nube de Conda y distribuido mediante funcionalidades de Docker.

En los ejemplos de este artículo se muestran los siguientes procedimientos:

  • Crear un entorno y especificar las dependencias de paquetes.
  • Recuperar y actualizar los entornos.
  • Usar un entorno para entrenamiento.
  • Usar un entorno para la implementación de servicios web.

Para obtener información general de alto nivel sobre cómo funcionan los entornos Azure Machine Learning, consulte ¿Qué son los entornos de Azure Machine Learning? Para obtener información sobre cómo administrar entornos en Azure ML Studio, consulte Administración de entornos de software en Azure Machine Learning Studio. Para obtener información sobre cómo configurar entornos de desarrollo, consulte Configuración de un entorno de desarrollo de Python para Azure Machine Learning.

Prerrequisitos

Creación de un entorno

En las secciones siguientes se exploran las diversas formas en que puede crear un entorno para sus experimentos.

Creación de instancias de un objeto de entorno

Para crear manualmente un entorno, importe la clase Environment desde el SDK. A continuación, use el siguiente código para crear instancias de un objeto de entorno.

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

Uso de un entorno mantenido

Los entornos seleccionados contienen colecciones de paquetes de Python y están disponibles en el área de trabajo de forma predeterminada. Estos entornos están respaldados por imágenes de Docker en caché, lo que reduce el costo de preparación de la ejecución. Para empezar, puede elegir uno de los entornos seleccionados populares:

  • El entorno AzureML-lightgbm-3.2-ubuntu18.04-py37-cpu contiene Scikit-learn, LightGBM, XGBoost, Dask, así como otros SDK de Python de AzureML y paquetes adicionales.

  • El entorno AzureML-sklearn-0.24-ubuntu18.04-py37-cpu contiene paquetes de ciencia de datos comunes. Estos paquetes incluyen Scikit-Learn, Pandas, Matplotlib y un conjunto mayor de paquetes de azureml-sdk.

Para obtener una lista de los entornos seleccionados, consulte el artículo sobre entornos seleccionados.

Use el método Environment.get para seleccionar uno de los entornos mantenidos:

from azureml.core import Workspace, Environment

ws = Workspace.from_config()
env = Environment.get(workspace=ws, name="AzureML-sklearn-0.24-ubuntu18.04-py37-cpu")

Puede enumerar los entornos mantenidos y sus paquetes mediante el código siguiente:

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 empiece el nombre de su propio entorno con el prefijo AzureML. Este prefijo está reservado para entornos mantenidos.

Para personalizar un entorno mantenido, clone y cambie el nombre del entorno.

env = Environment.get(workspace=ws, name="AzureML-sklearn-0.24-ubuntu18.04-py37-cpu")
curated_clone = env.clone("customize_curated")

Uso de dependencias de Conda o archivos de requisitos de PIP

Puede crear un entorno a partir de una especificación de Conda o de un archivo de requisitos de PIP. Use el método from_conda_specification() o el método from_pip_requirements(). En el argumento del método, incluya el nombre del entorno y la ruta de acceso del archivo que desee.

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

Habilitación de Docker

Azure Machine Learning compila una imagen de Docker y crea un entorno de Python en ese contenedor de acuerdo con las especificaciones. Las imágenes de Docker se almacenan en caché y se reutilizan: la primera vez que se ejecutan en un entorno nuevo suele tardar más, ya que la imagen debe compilarse. En las ejecuciones locales, especifique Docker en RunConfiguration.

De manera predeterminada, la imagen de Docker recién creada aparece en el registro de contenedor que está asociado al área de trabajo. El nombre del repositorio tiene el formato azureml/azureml_<uuid> . La parte del identificador único (uuid) del nombre corresponde a un hash calculado a partir de la configuración del entorno. Esta correspondencia permite que el servicio determine si ya existe para reutilizar una imagen del entorno dado.

Uso de una imagen de Docker precompilada

De forma predeterminada, el servicio usa automáticamente una de las imágenes base basadas en Ubuntu Linux, en particular la definida por azureml.core.environment.DEFAULT_CPU_IMAGE. A continuación, instala los paquetes de Python especificados definidos por el entorno de Azure ML proporcionado. Hay otras imágenes base de GPU y CPU de Azure ML disponibles en el repositorio de contenedor. También es posible usar una imagen base de Docker personalizada.

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

Importante

Azure Machine Learning solo admite imágenes de Docker que proporcionan el software siguiente:

  • Ubuntu 18.04 o posterior.
  • Conda 4.7.# o posterior.
  • Python 3.6+.
  • Se requiere un shell compatible con POSIX disponible en /bin/sh en cualquier imagen de contenedor usada para el entrenamiento.

Uso de un Dockerfile propio

También puede especificar un Dockerfile personalizado. Es más sencillo empezar a partir de una de las imágenes base de Azure Machine Learning mediante el comando FROM de Docker y, después, agregar sus propios pasos personalizados. Use este enfoque si necesita instalar paquetes que no son de Python como dependencias. Recuerde establecer la imagen base en None.

Tenga en cuenta que Python es una dependencia implícita en Azure Machine Learning por lo que un dockerfile personalizado debe tener Python instalado.

# Specify docker steps as a string. 
dockerfile = r"""
FROM mcr.microsoft.com/azureml/openmpi3.1.2-ubuntu18.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"

Cuando se utilizan imágenes de Docker personalizadas, se recomienda anclar las versiones del paquete para garantizar mejor la reproducibilidad.

Especificación de un intérprete de Python propio

En algunas situaciones, es posible que la imagen base personalizada ya contenga un entorno de Python con paquetes que quiera usar.

Para usar sus propios paquetes instalados y deshabilitar Conda, establezca el parámetro Environment.python.user_managed_dependencies = True. Asegúrese de que la imagen base contenga un intérprete de Python, así como los paquetes que necesita el script de entrenamiento.

Por ejemplo, para trabajar en un entorno base de Miniconda que tenga instalado el paquete NumPy, especifique primero un Dockerfile con un paso para instalar el paquete. A continuación, establezca las dependencias administradas por el usuario en True.

También puede especificar una ruta de acceso a un intérprete de Python específico dentro de la imagen mediante el establecimiento de la variable Environment.python.interpreter_path.

dockerfile = """
FROM mcr.microsoft.com/azureml/openmpi3.1.2-ubuntu18.04:20210615.v1
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"

Advertencia

Si instala algunas dependencias de Python en la imagen de Docker y olvida definir user_managed_dependencies=True, dichos paquetes no existirán en el entorno de ejecución, lo que provocará errores en tiempo de ejecución. De forma predeterminada, Azure ML creará un entorno de Conda con las dependencias especificadas y realizará la ejecución en ese entorno en lugar de usar las bibliotecas de Python que haya instalado en la imagen base.

Recuperación de los detalles de la imagen

En el caso de un entorno registrado, se pueden recuperar los detalles de la imagen mediante el código siguiente, donde details es una instancia de DockerImageDetails (SDK de AzureML para Python >= 1.11) y proporciona toda la información sobre la imagen del entorno, como el dockerfile, el registro y el nombre de la imagen.

details = environment.get_image_details(workspace=ws)

Para obtener los detalles de la imagen de un entorno autoguardado a partir de una ejecución, use el código siguiente:

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

Uso de entornos existentes

Si tiene un entorno de Conda en el equipo local, puede usar el servicio para crear un objeto de entorno. Mediante esta estrategia, puede volver a usar el entorno interactivo local en ejecuciones remotas.

En el código siguiente se crea un objeto de entorno a partir del entorno Conda existente mycondaenv. Utiliza el método from_existing_conda_environment().

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

Una definición de entorno se puede guardar en un directorio en un formato fácilmente editable con el método save_to_directory(). Una vez modificado, se pueden crear instancias de un nuevo entorno mediante la carga de archivos desde el directorio.

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

Uso implícito del entorno predeterminado

Si no especifica un entorno en la configuración de ejecución del script antes de enviar la ejecución, se crea un entorno predeterminado de manera automática.

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)

Adición de paquetes a un entorno

Agregue paquetes a un entorno con los archivos de Conda, pip o Private Wheel. Especifique cada dependencia del paquete mediante la clase CondaDependency. Agréguelo a PythonSection del entorno.

Paquetes Conda y pip

Si hay un paquete disponible en un repositorio de paquetes Conda, se recomienda usar la instalación de Conda en lugar de la instalación de pip. Los paquetes de Conda suelen incluir archivos binarios pregenerados que hacen que la instalación sea más confiable.

En el ejemplo siguiente se agrega al entorno myenv. Agrega la versión 1.17.0 de numpy. También se agrega el paquete de pillow. En el ejemplo se usan el método add_conda_package() y el método add_pip_package(), respectivamente.

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

Importante

Si usa la misma definición de entorno para otra ejecución, Azure Machine Learning Service vuelve a usar la imagen almacenada en caché de su entorno. Si crea un entorno con una dependencia de paquete desanclada (por ejemplo, numpy), ese entorno seguirá usando la versión del paquete instalada en el momento de la creación del entorno. Además, cualquier entorno futuro con una definición coincidente seguirá usando la versión anterior. Para más información, consulte Compilación, almacenamiento en caché y reutilización de entornos.

Paquetes privados de Python

Para usar paquetes de Python de forma privada y segura sin exponerlos a la red pública de Internet, consulte el artículo Cómo usar paquetes privados de Python.

Administración de entornos

Administre los entornos para que pueda actualizarlos, realizarles un seguimiento y reutilizarlos en todos los destinos de proceso y con otros usuarios del área de trabajo.

Registro de entornos

El entorno se registra automáticamente en el área de trabajo cuando se envía una ejecución o se implementa un servicio web. También puede registrar manualmente el entorno mediante el método register(). Esta operación convierte el entorno en una entidad con control de versiones y de la que se realiza el seguimiento en la nube. La entidad se puede compartir entre los usuarios del área de trabajo.

En el código siguiente se registra el entorno myenv en el área de trabajo ws.

myenv.register(workspace=ws)

Cuando se usa el entorno por primera vez en el entrenamiento o la implementación, se registra en el área de trabajo. A continuación, se compila e implementa en el destino de proceso. El servicio almacena los entornos en caché. 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.

Obtención de los entornos existentes

La clase Environment ofrece métodos que le permiten recuperar entornos existentes en el área de trabajo. Puede recuperar entornos por nombre, como lista, por ejecución de entrenamiento específica. Esta información es útil para la solución de problemas, la auditoría y la reproducibilidad.

Visualización de una lista de entornos

Vea los entornos en el área de trabajo mediante la clase Environment.list(workspace="workspace_name"). A continuación, seleccione un entorno para reutilizar.

Obtención de un entorno por nombre

También puede obtener un entorno específico por nombre y versión. En el código siguiente se usa el método get() para recuperar la versión 1 del entorno myenv del área de trabajo ws.

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

Entrenamiento de un entorno específico de la ejecución

Para obtener el entorno que se usó para una ejecución específica una vez finalizado el entrenamiento, use el método get_environment() en la clase Run.

from azureml.core import Run
Run.get_environment()

Actualización de un entorno existente

Imagine que cambia un entorno existente, por ejemplo, al agregar un paquete de Python. Tardará un tiempo en compilarse, ya que, después, se crea una nueva versión del entorno cuando envía una ejecución, implementa un modelo o registra manualmente el entorno. El control de versiones le permite ver los cambios en el entorno a lo largo del tiempo.

Para actualizar la versión de un paquete de Python en un entorno existente, especifique el número de versión de ese paquete. Si no usa el número de versión exacto, Azure Machine Learning volverá a usar el entorno existente con sus versiones de paquete originales.

Depuración de la compilación de la imagen

En el ejemplo siguiente se usa el método build() para crear manualmente un entorno como imagen de Docker. Supervisa los registros de salida de la compilación de imágenes mediante wait_for_completion(). La imagen compilada aparece después en la instancia de Azure Container Registry del área de trabajo. Esta información resulta útil para la depuración.

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

Resulta útil compilar imágenes de forma local mediante el método build_local(). Para compilar una imagen de Docker, establezca el parámetro opcional useDocker=True. Para insertar la imagen resultante en el registro de contenedor del área de trabajo de AzureML, establezca pushImageToWorkspaceAcr=True.

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

Advertencia

Si se cambia el orden de las dependencias o de los canales de un entorno, se generará un nuevo entorno y, por tanto, será necesario volver a compilar la imagen. Además, al llamar al método build() de una imagen existente se actualizarán sus dependencias si hay nuevas versiones.

Uso de Azure Container Registry (ACR) sin administración con una red virtual

Ya no es necesario que los usuarios tengan habilitado el modo de administración en su área de trabajo asociada a ACR en escenarios de red virtual. Asegúrese de que el tiempo de compilación de la imagen derivada en el proceso sea inferior a 1 hora para habilitar la compilación correcta. Una vez que la imagen se inserta en la instancia de ACR del área de trabajo, ahora solo se puede acceder a esta imagen con una identidad de proceso. Para más información sobre la configuración, vea Uso de identidades administradas con Azure Machine Learning.

Uso de entornos para el entrenamiento

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. Esta configuración es un objeto contenedor que se usa para enviar ejecuciones.

Cuando envía una ejecución de entrenamiento, la compilación de un nuevo entorno puede tardar varios minutos. La duración depende del tamaño de las dependencias necesarias. Los entornos se almacenan en caché en el servicio. Por tanto, siempre y cuando la definición del entorno permanezca inalterada, incurrirá en el tiempo de configuración completo una sola vez.

A continuación se proporciona un ejemplo de ejecución de script local en el que se usaría ScriptRunConfig como objeto contenedor.

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", compute_target="local", environment=myenv)

# Submit run 
run = exp.submit(src)

Nota

Para deshabilitar el historial de ejecución o ejecutar instantáneas, use el valor de src.run_config.history.

Importante

Use las SKU de CPU para cualquier compilación de imagen en el proceso.

Si no especifica el entorno en la configuración de ejecución, el servicio crea un entorno predeterminado cuando envía la ejecución.

Uso de entornos para la implementación de servicios web

Puede usar entornos al implementar el modelo como servicio web. Esta funcionalidad permite un flujo de trabajo conectado y reproducible. En este flujo de trabajo, puede entrenar, probar e implementar el modelo con las mismas bibliotecas tanto en el proceso de entrenamiento como en el proceso de inferencia.

Si va a definir su propio entorno para la implementación del servicio web, tendrá que enumerar azureml-defaults con la versión >= 1.0.45 como dependencia PIP. Este paquete contiene la funcionalidad necesaria para hospedar el modelo como un servicio web.

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(). Para obtener más información, consulte How and where to deploy models (Cómo y dónde implementar modelos).

En este ejemplo, supongamos que ha completado una ejecución de entrenamiento. Ahora desea implementar ese modelo en Azure Container Instances. 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.

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)

Cuaderno

Los ejemplos de código de este artículo también se incluyen en el cuaderno sobre el uso de los entornos.

Para instalar un entorno de Conda como kernel en un cuaderno, consulte Adición de un nuevo kernel de Jupyter.

En Implementación de un modelo mediante una imagen base personalizada de Docker, se muestra cómo implementar un modelo mediante una imagen base personalizada de Docker.

En este cuaderno de ejemplo se muestra cómo implementar un modelo de Spark como servicio web.

Creación y administración de entornos con la CLI de Azure

Para obtener información sobre el uso de la CLI v2, consulte Administración de entornos con la CLI v2.

Creación y administración de entornos con Visual Studio Code

Con la extensión de Azure Machine Learning, puede crear y administrar entornos en Visual Studio Code. Para más información, consulte Administración de recursos de Azure Machine Learning con la extensión de VS Code (versión preliminar).

Pasos siguientes