¿Qué es el SDK de Azure Machine Learning v1 para Python?

Los científicos de datos y los desarrolladores de inteligencia artificial usan el SDK de Azure Machine Learning v1 para Python para compilar y ejecutar flujos de trabajo de aprendizaje automático con la Azure Machine Learning Service. Puede interactuar con el servicio en cualquier entorno de Python, incluidos jupyter Notebooks, Visual Studio Codeo su IDE de Python favorito.

Entre las áreas clave del SDK se incluyen:

• Explore, prepare y administre el ciclo de vida de los conjuntos de datos usados en experimentos de aprendizaje automático.
• Administre los recursos en la nube para supervisar, registrar y organizar los experimentos de aprendizaje automático.
• Entrene modelos localmente o mediante recursos en la nube, incluido el entrenamiento de modelos acelerados por GPU.
• Use el aprendizaje automático automatizado, que acepta parámetros de configuración y datos de entrenamiento. Itera automáticamente a través de algoritmos y configuraciones de hiperparámetros para encontrar el mejor modelo para ejecutar predicciones.
• Implemente servicios web para convertir los modelos entrenados en servicios RESTful que se pueden consumir en cualquier aplicación.

Para ver un tutorial paso a paso sobre cómo empezar, pruebe el tutorial de .

Las secciones siguientes son información general de algunas de las clases más importantes del SDK y patrones de diseño comunes para su uso. Para obtener el SDK, consulte la guía de instalación de .

Estable frente a experimental

El SDK de Azure Machine Learning para Python proporciona características estables y experimentales en el mismo SDK.

Las características experimentales se etiquetan mediante una sección de nota en la referencia del SDK y se indican mediante texto como, por ejemplo, (versión preliminar) en documentación de Azure Machine Learning.

Área de trabajo

espacio de nombres: azureml.core.workspace.Workspace

La clase Workspace es un recurso fundamental en la nube que se usa para experimentar, entrenar e implementar modelos de aprendizaje automático. Vincula la suscripción de Azure y el grupo de recursos a un objeto fácilmente consumido.

Vea todos los parámetros del método create Workspace para reutilizar las instancias existentes (Storage, Key Vault, App-Insights y Azure Container Registry-ACR), así como modificar opciones adicionales, como la configuración del punto de conexión privado y el destino de proceso.

Importe la clase y cree un área de trabajo mediante el código siguiente. Establezca create_resource_group en False si tiene un grupo de recursos de Azure existente que desea usar para el área de trabajo. Algunas funciones pueden solicitar credenciales de autenticación de Azure.

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

Use la misma área de trabajo en varios entornos escribiendo primero en un archivo JSON de configuración. Esto guarda los datos de nombre de suscripción, recurso y área de trabajo.

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

Cargue el área de trabajo leyendo el archivo de configuración.

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

Como alternativa, use el método estático get() para cargar un área de trabajo existente sin usar archivos de configuración.

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

La variable ws representa un objeto Workspace en los ejemplos de código siguientes.

Experimento

espacio de nombres: azureml.core.experiment.Experiment

La clase Experiment es otro recurso fundamental en la nube que representa una colección de pruebas (ejecuciones de modelos individuales). El código siguiente captura un objeto Experiment desde Workspace por nombre, o crea un nuevo objeto Experiment si el nombre no existe.

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

Ejecute el código siguiente para obtener una lista de todos los objetos Experiment contenidos en Workspace.

list_experiments = Experiment.list(ws)

Use la función get_runs para recuperar una lista de objetos de Run (pruebas) de Experiment. El código siguiente recupera las ejecuciones e imprime cada identificador de ejecución.

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

Hay dos maneras de ejecutar una prueba de experimento. Si experimenta interactivamente en un cuaderno de Jupyter Notebook, use la función start_logging. Si va a enviar un experimento desde un entorno estándar de Python, use la función submit. Ambas funciones devuelven un objeto Run. La variable experiment representa un objeto Experiment en los ejemplos de código siguientes.

Correr

espacio de nombres: azureml.core.run.Run

Una ejecución representa una sola versión de prueba de un experimento. Run es el objeto que se usa para supervisar la ejecución asincrónica de una prueba, almacenar la salida de la prueba, analizar los resultados y acceder a los artefactos generados. Use Run dentro del código de experimentación para registrar métricas y artefactos en el servicio Historial de ejecución. La funcionalidad incluye:

• Almacenamiento y recuperación de métricas y datos.
• Uso de etiquetas y la jerarquía secundaria para una búsqueda sencilla de ejecuciones anteriores.
• Registro de archivos de modelo almacenados para la implementación.
• Almacenar, modificar y recuperar propiedades de una ejecución.

Cree un objeto Run enviando un objeto de Experiment con un objeto de configuración de ejecución . Use el parámetro tags para adjuntar etiquetas y categorías personalizadas a las ejecuciones. Puede encontrarlos y recuperarlos más adelante desde Experiment.

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

Use la función de list estática para obtener una lista de todos los objetos de Run de Experiment. Especifique el parámetro tags para filtrar por la etiqueta creada anteriormente.

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

Use la función get_details para recuperar la salida detallada de la ejecución.

run_details = run.get_details()

La salida de esta función es un diccionario que incluye:

• Identificador de ejecución
• Estado
• Hora de inicio y finalización
• Destino de proceso (local frente a nube)
• Dependencias y versiones usadas en la ejecución
• Datos específicos del entrenamiento (difieren en función del tipo de modelo)

Para obtener más ejemplos de cómo configurar y supervisar ejecuciones, consulte el procedimientos.

Modelo

espacio de nombres: azureml.core.model.Model

La clase Model se usa para trabajar con representaciones en la nube de modelos de aprendizaje automático. Los métodos ayudan a transferir modelos entre entornos de desarrollo local y el objeto Workspace en la nube.

Puede usar el registro de modelos para almacenar y versionar los modelos en la nube de Azure, en el área de trabajo. Los modelos registrados se identifican por nombre y versión. Cada vez que registra un modelo con el mismo nombre que uno existente, el registro incrementa la versión. Azure Machine Learning admite cualquier modelo que se pueda cargar a través de Python 3, no solo modelos de Azure Machine Learning.

En el ejemplo siguiente se muestra cómo crear un modelo de clasificación local sencillo con scikit-learn, registrar el modelo en Workspacey descargar el modelo desde la nube.

Cree un clasificador simple, clf, para predecir la renovación del cliente en función de su edad. A continuación, volque el modelo a un archivo .pkl en el mismo directorio.

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

Use la función register para registrar el modelo en el área de trabajo. Especifique la ruta de acceso del modelo local y el nombre del modelo. El registro del mismo nombre más de una vez creará una nueva versión.

from azureml.core.model import Model

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

Ahora que el modelo está registrado en el área de trabajo, es fácil administrar, descargar y organizar los modelos. Para recuperar un objeto de modelo (por ejemplo, en otro entorno) de Workspace, use el constructor de clase y especifique el nombre del modelo y los parámetros opcionales. A continuación, use la función download para descargar el modelo, incluida la estructura de carpetas en la nube.

from azureml.core.model import Model
import os

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

Use la función delete para quitar el modelo de Workspace.

model.delete()

Después de tener un modelo registrado, implementarlo como servicio web es un proceso sencillo. En primer lugar, crear y registrar una imagen. Este paso configura el entorno de Python y sus dependencias, junto con un script para definir los formatos de solicitud y respuesta del servicio web. Después de crear una imagen, crear una configuración de implementación que establece los núcleos de CPU y los parámetros de memoria para el destino de proceso. A continuación, adjunta la imagen.

ComputeTarget, RunConfiguration y ScriptRunConfig

espacio de nombres: azureml.core.compute.ComputeTarget
espacio de nombres: azureml.core.runconfig.RunConfiguration
espacio de nombres: azureml.core.script_run_config.ScriptRunConfig

La clase ComputeTarget es la clase primaria abstracta para crear y administrar destinos de proceso. Un destino de proceso representa una variedad de recursos en los que puede entrenar los modelos de aprendizaje automático. Un destino de proceso puede ser una máquina local o un recurso en la nube, como Proceso de Azure Machine Learning, Azure HDInsight o una máquina virtual remota.

Use destinos de proceso para aprovechar las eficaces máquinas virtuales para el entrenamiento del modelo y configurar destinos de proceso persistentes o destinos invocados en tiempo de ejecución temporales. Para obtener una guía completa sobre cómo configurar y administrar destinos de proceso, consulte la procedimientos.

En el código siguiente se muestra un ejemplo sencillo de configuración de un destino de AmlCompute (clase secundaria de ComputeTarget). Este destino crea un recurso de proceso remoto en tiempo de ejecución en el objeto Workspace. El recurso se escala automáticamente cuando se envía un trabajo. Se elimina automáticamente cuando finaliza la ejecución.

Vuelva a usar el modelo de renovación de scikit-learn simple y cántelo en su propio archivo, train.py, en el directorio actual. Al final del archivo, cree un directorio denominado outputs. Este paso crea un directorio en la nube (el área de trabajo) para almacenar el modelo entrenado que joblib.dump() serializado.

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

A continuación, cree el destino de proceso creando una instancia de un objeto RunConfiguration y estableciendo el tipo y el tamaño. En este ejemplo se usa el tamaño de recurso más pequeño (1 núcleo de CPU, 3,5 GB de memoria). La variable list_vms contiene una lista de máquinas virtuales admitidas y sus tamaños.

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"

Cree dependencias para el entorno de Python del recurso de proceso remoto mediante la clase CondaDependencies. El archivo train.py usa scikit-learn y numpy, que deben instalarse en el entorno. También puede especificar versiones de dependencias. Use el objeto dependencies para establecer el entorno en 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

Ahora está listo para enviar el experimento. Use la clase ScriptRunConfig para adjuntar la configuración de destino de proceso y para especificar la ruta de acceso o archivo al script de entrenamiento train.py. Envíe el experimento especificando el parámetro config de la función submit(). Llame a wait_for_completion en la ejecución resultante para ver la salida de ejecución asincrónica a medida que se inicializa el entorno y se entrena el modelo.

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)

Una vez finalizada la ejecución, el archivo de modelo entrenado churn-model.pkl está disponible en el área de trabajo.

Medio ambiente

espacio de nombres: azureml.core.environment

Los entornos de Azure Machine Learning especifican los paquetes de Python, las variables de entorno y la configuración de software en torno a los scripts de entrenamiento y puntuación. Además de Python, también puede configurar PySpark, Docker y R para entornos. Internamente, los entornos generan imágenes de Docker que se usan para ejecutar los procesos de entrenamiento y puntuación en el destino de proceso. Los entornos son entidades administradas y con versiones dentro del área de trabajo de Machine Learning que permiten flujos de trabajo de aprendizaje automático reproducibles, auditables y portátiles en una variedad de destinos de proceso y tipos de proceso.

Puede usar un objeto Environment para:

• Desarrolle el script de entrenamiento.
• Vuelva a usar el mismo entorno en Proceso de Azure Machine Learning para el entrenamiento de modelos a escala.
• Implemente el modelo con ese mismo entorno sin estar vinculado a un tipo de proceso específico.

El código siguiente importa la clase Environment desde el SDK y crea instancias de un objeto de entorno.

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

Agregue paquetes a un entorno mediante archivos conda, pip o rueda privada. Especifique cada dependencia de paquete mediante la clase CondaDependency para agregarla al PythonSectiondel entorno.

En el ejemplo siguiente se agrega al entorno. Agrega la versión 1.17.0 de numpy. También agrega el paquete de pillow al entorno, myenv. En el ejemplo se usa 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

Para enviar una ejecución de entrenamiento, debe combinar el entorno, destino de procesoy 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.

Al enviar 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. El servicio almacena en caché los entornos. Por lo tanto, siempre que la definición del entorno permanezca sin cambios, incurre en el tiempo de configuración completo solo una vez.

En el ejemplo siguiente se muestra dónde 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")

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

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

Consulte la sección Implementación de modelos para usar entornos para implementar un servicio web.

Canalización, PythonScriptStep

espacio de nombres: azureml.pipeline.core.pipeline.Pipeline
espacio de nombres: azureml.pipeline.steps.python_script_step.PythonScriptStep

Una canalización de Azure Machine Learning es un flujo de trabajo automatizado de una tarea de aprendizaje automático completa. Las subtareas se encapsulan como una serie de pasos dentro de la canalización. Una canalización de Azure Machine Learning puede ser tan simple como un paso que llama a un script de Python. Las canalizaciones incluyen funcionalidad para:

• Preparación de datos, incluida la importación, validación y limpieza, transformación y transformación, normalización y almacenamiento provisional
• Configuración de entrenamiento, incluidos argumentos de parametrización, rutas de archivo y configuraciones de registro o informes
• Entrenamiento y validación eficaz y repetible, lo que puede incluir especificar subconjuntos de datos específicos, diferentes recursos de proceso de hardware, procesamiento distribuido y supervisión del progreso
• Implementación, incluido el control de versiones, el escalado, el aprovisionamiento y el control de acceso
• Publicación de una canalización en un punto de conexión REST para volver a ejecutar desde cualquier biblioteca HTTP

Un PythonScriptStep es un paso básico integrado para ejecutar un script de Python en un destino de proceso. Toma un nombre de script y otros parámetros opcionales, como argumentos para el script, el destino de proceso, las entradas y las salidas. El código siguiente es un ejemplo sencillo de un PythonScriptStep. Para obtener un ejemplo de un script de train.py, consulte la sección tutorial.

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
)

Después de crear al menos un paso, los pasos se pueden vincular y publicar como una canalización automatizada sencilla.

from azureml.pipeline.core import Pipeline

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

Para obtener un ejemplo completo de creación de un flujo de trabajo de canalización, siga el tutorial avanzado .

Patrón para crear y usar canalizaciones

Una canalización de Azure Machine Learning está asociada a un área de trabajo de Azure Machine Learning y un paso de canalización está asociado a un destino de proceso disponible en esa área de trabajo. Para obtener más información, consulte este artículo de sobre las áreas de trabajo o esta explicación de los destinos de proceso de .

Un patrón común para los pasos de canalización es:

1. Especificación del área de trabajo, el proceso y el almacenamiento
2. Configuración de los datos de entrada y salida mediante
   1. conjunto de datos que pone a disposición un almacén de datos de Azure existente
   2. PipelineDataset que encapsula los datos tabulares con tipo
   3. PipelineData que se usa para datos intermedios de archivos o directorios escritos por un paso y destinados a ser consumidos por otro
3. Definición de uno o varios pasos de canalización
4. Creación de instancias de una canalización mediante el área de trabajo y los pasos
5. Creación de un experimento al que se envía la canalización
6. Supervisión de los resultados del experimento

Este cuaderno es un buen ejemplo de este patrón. trabajo

Para obtener más información sobre las canalizaciones de Azure Machine Learning y, en particular, cómo son diferentes de otros tipos de canalizaciones, consulte este artículo de .

AutoMLConfig

espacio de nombres: azureml.train.automl.automlconfig.AutoMLConfig

Use la clase AutoMLConfig para configurar parámetros para el aprendizaje automático automatizado. El aprendizaje automático automatizado recorre en iteración muchas combinaciones de algoritmos de aprendizaje automático y configuración de hiperparámetros. A continuación, encuentra el modelo más adecuado en función de la métrica de precisión elegida. La configuración permite especificar:

• Tipo de tarea (clasificación, regresión, previsión)
• Número de iteraciones de algoritmo y tiempo máximo por iteración
• Métrica de precisión para optimizar
• Algoritmos para la lista de bloqueados o la lista de permitidos
• Número de validaciones cruzadas
• Destinos de proceso
• Datos de entrenamiento

Para obtener guías detalladas y ejemplos de configuración de experimentos de aprendizaje automático automatizado, consulte el tutorial de y procedimientos.

En el código siguiente se muestra cómo crear un objeto de configuración de aprendizaje automático automatizado para un modelo de clasificación y usarlo al enviar un experimento.

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
                            )

Use el objeto automl_config para enviar un experimento.

from azureml.core.experiment import Experiment

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

Después de enviar el experimento, la salida muestra la precisión del entrenamiento para cada iteración a medida que finaliza. Una vez finalizada la ejecución, se devuelve un objeto AutoMLRun (que extiende la clase Run). Obtenga el modelo más adecuado mediante la función get_output() para devolver un objeto Model.

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

Implementación de modelos

espacio de nombres: azureml.core.model.InferenceConfig
espacio de nombres: azureml.core.webservice.webservice.Webservice

La clase InferenceConfig es para las opciones de configuración que describen el entorno necesario para hospedar el modelo y el servicio web.

Webservice es la clase primaria abstracta para crear e implementar servicios web para los modelos. Para obtener una guía detallada sobre cómo preparar la implementación de modelos e implementar servicios web, consulte este procedimientos.

Puede usar entornos al implementar el modelo como servicio web. Los entornos permiten un flujo de trabajo conectado reproducible, donde puede implementar el modelo mediante las mismas bibliotecas tanto en el proceso de entrenamiento como en el proceso de inferencia. Internamente, los entornos se implementan como imágenes de Docker. Puede usar imágenes proporcionadas por Microsoft o usar sus propias imágenes personalizadas de Docker. Si anteriormente usaba la clase ContainerImage para la implementación, consulte la clase DockerSection para lograr un flujo de trabajo similar con entornos.

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().

En el ejemplo siguiente, se supone que ya ha completado una ejecución de entrenamiento mediante el entorno, myenvy quiere implementar ese modelo en 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)

En este ejemplo se crea un servicio web de Azure Container Instances, que es mejor para las pruebas a pequeña escala y las implementaciones rápidas. Para implementar el modelo como un servicio web a escala de producción, use Azure Kubernetes Service (AKS). Para obtener más información, vea clase AksCompute.

Conjunto de datos

espacio de nombres: azureml.core.dataset.Dataset
espacio de nombres: azureml.data.file_dataset.FileDataset
espacio de nombres: azureml.data.tabular_dataset.TabularDataset

La clase Dataset es un recurso fundamental para explorar y administrar datos en Azure Machine Learning. Puede explorar los datos con estadísticas de resumen y guardar el conjunto de datos en el área de trabajo de AML para obtener funcionalidades de control de versiones y reproducibilidad. Los modelos consumen fácilmente los conjuntos de datos durante el entrenamiento. Para obtener ejemplos de uso detallados, consulte la guía de procedimientos de .

• TabularDataset representa los datos en un formato tabular creado mediante el análisis de un archivo o una lista de archivos.
• FileDataset hace referencia a uno o varios archivos en almacenes de datos o desde direcciones URL públicas.

En el ejemplo siguiente se muestra cómo crear un objeto TabularDataset que apunte a una única ruta de acceso en un almacén de datos.

from azureml.core import Dataset

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

En el ejemplo siguiente se muestra cómo crear un FileDataset hacer referencia a varias direcciones URL de archivo.

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)

Pasos siguientes

Pruebe estos pasos siguientes para aprender a usar el SDK de Azure Machine Learning para Python:

• Siga el tutorial para aprender a compilar, entrenar e implementar un modelo en Python.

• Busque clases y módulos en la documentación de referencia de este sitio mediante la tabla de contenido de la izquierda.