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

Los científicos de datos y los desarrolladores de inteligencia artificial usan el SDK de Azure Machine Learning para Python para crear y ejecutar flujos de trabajo de aprendizaje automático con Azure Machine Learning Service. Puede interactuar con el servicio en cualquier entorno de Python, incluidos los cuadernos de Jupyter Notebook, Visual Studio Code o 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 los experimentos de aprendizaje automático.
• Administre los recursos en la nube para la supervisión, registro y organización de los experimentos de aprendizaje automático.
• Entrene modelos localmente o mediante recursos en la nube, incluido el entrenamiento del modelo de aceleración por GPU.
• Use el aprendizaje automático automatizado, que acepta parámetros de configuración y datos de entrenamiento. Automáticamente recorre en iteración los algoritmos y la configuración de hiperparámetros para encontrar el mejor modelo para realizar predicciones.
• Implemente servicios web para convertir los modelos entrenados en servicios RESTful que se pueden consumir en cualquier aplicación.

Para obtener instrucciones paso a paso sobre cómo empezar, pruebe el tutorial.

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

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 (versión preliminar) en toda la documentación de Azure Machine Learning.

Área de trabajo

Espacio de nombres: azureml.core.workspace.Workspace

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

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 configuraciones adicionales, como la configuración del punto de conexión privado y el destino de proceso.

Importe la clase y cree una nueva área de trabajo con el código siguiente. Establezca create_resource_group en False si tiene un grupo de recursos de Azure ya existente que quiera usar para el área de trabajo. Es posible que algunas funciones le soliciten 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'
                     )

Puede usar la misma área de trabajo en varios entornos si la escribe primero en un archivo de configuración JSON. De esta forma, se guardan los datos de la suscripción, el recurso y el nombre del área de trabajo.

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

Lea el archivo de configuración para cargar el área de trabajo.

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

También puede usar 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 siguientes ejemplos de código.

Experimento

Espacio de nombres: azureml.core.experiment.Experiment

La clase Experiment es otro recurso básico de la nube que representa una colección de pruebas (ejecuciones individuales del modelo). 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 incluidos en Workspace.

list_experiments = Experiment.list(ws)

Use la función get_runs para recuperar una lista de objetos Run (pruebas) de Experiment. El código siguiente recupera las ejecuciones e imprime cada Id. 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 está experimentando de forma interactiva 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 siguientes ejemplos de código.

Ejecute

Espacio de nombres: azureml.core.run.Run

Una ejecución representa una prueba única de un experimento. Run es el objeto que se usa para supervisar la ejecución asincrónica de una prueba, almacenar su salida, analizar los resultados y obtener acceso a los artefactos generados. Puede usar Run dentro del código de experimentación para registrar las métricas y artefactos en el servicio del historial de ejecución. Entre las funcionalidades se incluyen:

• Almacenar y recuperar métricas y datos.
• Usar etiquetas y la jerarquía de elementos secundarios para facilitar la búsqueda de ejecuciones anteriores.
• Registrar los archivos de modelo almacenados para la implementación.
• Almacenar, modificar y recuperar propiedades de una ejecución.

Para crear un objeto Run, envíe un objeto Experiment con un objeto de configuración de ejecución. Use el parámetro tags para agregar categorías y etiquetas personalizadas a las ejecuciones. Puede buscarlos y recuperarlos fácilmente más tarde desde Experiment.

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

Use la función estática list para obtener una lista de todos los objetos Run de Experiment. Especifique el parámetro tags para filtrar según 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 el resultado detallado de la ejecución.

run_details = run.get_details()

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

• Ejecutar identificador
• Estado
• Hora de inicio y finalización
• Destino de proceso (local frente a en la nube)
• Dependencias y versiones usadas en la ejecución
• Datos específicos del entrenamiento (varían según el tipo de modelo)

Para obtener más ejemplos de cómo configurar y supervisar las ejecuciones, consulte la guía de procedimiento.

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 le ayudan a transferir modelos entre entornos de desarrollo locales y el objeto Workspace en la nube.

Puede usar el registro del modelo para almacenar y controlar las versiones de los modelos en la nube de Azure, en su área de trabajo. Los modelos registrados se identifican por el nombre y la 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 todos los modelos que se pueden cargar mediante Python 3, no solo los modelos de Azure Machine Learning.

En el ejemplo siguiente se muestra cómo crear un modelo de clasificación local simple con scikit-learn, registrar el modelo en Workspace y descargarlo desde la nube.

Cree un clasificador simple (clf) para predecir el abandono de clientes en función de su edad. A continuación, vuelque el modelo en un archivo .pkl del 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. Si registra el mismo nombre más de una vez, se 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 modelos (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 de 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()

Una vez que tiene un modelo registrado, implementarlo como un servicio web es un proceso sencillo. Primero, cree y registre una imagen. En este paso se configura el entorno de Python y sus dependencias, junto con un script para definir los formatos de la respuesta y solicitud de servicio web. Después de crear una imagen, cree una configuración de implementación que establezca los parámetros de memoria y núcleos de CPU para el destino de proceso. A continuación, adjunte 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 los destinos de proceso. Un destino de proceso representa una variedad de recursos en los que puede entrenar los modelos de Machine Learning. Un destino de proceso puede ser una máquina local o un recurso en la nube, como una instancia de proceso de Azure Machine Learning, Azure HDInsight o una máquina virtual remota.

Use los destinos de proceso para aprovechar máquinas virtuales eficaces para el entrenamiento del modelo y configure destinos de proceso persistentes o destinos invocados en tiempo de ejecución temporales. Para obtener una guía completa sobre la configuración y administración de destinos de proceso, consulte la guía de procedimiento.

En el código siguiente se muestra un ejemplo sencillo de configuración de un destino 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.

Reutilice el modelo de abandono de clientes simple de scikit-learn y compílelo como el archivo train.py en el directorio actual. Al final del archivo, cree un nuevo directorio llamado outputs. En este paso se crea un directorio en la nube (el área de trabajo) para almacenar el modelo entrenado que serializó el método joblib.dump().

# 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 una instancia del objeto RunConfiguration y establezca su tipo y tamaño para crear el destino de proceso. En este ejemplo se usa el tamaño de recursos más pequeño (1 núcleo de CPU, 3,5 GB de memoria). La variable list_vms contiene una lista de las 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 con la clase CondaDependencies. El archivo train.py usa scikit-learn y numpy, que deben instalarse en el entorno. También puede especificar las versiones de las 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 asociar la configuración del destino de proceso y para especificar la ruta de acceso o el archivo del script de entrenamiento train.py. Para enviar el experimento, especifique el parámetro config de la función submit(). Llame a wait_for_completion en la ejecución resultante para ver el resultado de la 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 estará disponible en el área de trabajo.

Entorno

Espacio de nombres: azureml.core.environment

Los entornos de Azure Machine Learning 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. Además de Python, también puede configurar PySpark, Docker y R para entornos. Internamente, los entornos producen 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 control de versiones en el área de trabajo de Machine Learning que permiten flujos de trabajo de aprendizaje automático reproducibles, auditables y portátiles en distintos destinos y tipos de proceso.

Puede utilizar un objeto Environment para:

• Desarrollar el script de aprendizaje.
• Reutilizar el mismo entorno en el Proceso de Azure Machine Learning para el entrenamiento del modelo a escala.
• Implementar el modelo con ese mismo entorno sin estar vinculado a un tipo de proceso específico.

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

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

Agregue paquetes a un entorno con los archivos de Conda, pip o Private Wheel. Especifique cada dependencia del paquete mediante la clase CondaDependency para agregarla a la sección PythonSection del entorno.

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

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

# 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 un entorno predeterminado de manera automática.

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

Canalización y 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 en la canalización. Una canalización de Azure Machine Learning puede ser tan simple como un paso que realiza una llamada a un script de Python. Las canalizaciones incluyen funcionalidades para lo siguiente:

• La preparación de datos, incluida la importación, validación y limpieza, manipulación y transformación, normalización y almacenamiento provisional.
• La configuración del entrenamiento, incluida la parametrización de argumentos, rutas de archivos y configuraciones de registros o informes.
• El entrenamiento y la validación de manera eficaz y repetida, lo que podría incluir la especificación de subconjuntos de datos específicos, distintos recursos de proceso de hardware, procesamiento distribuido y supervisión del progreso.
• La implementación, incluido el control de versiones, escalado, aprovisionamiento y control de acceso.
• La publicación de una canalización en un punto de conexión REST para volver a ejecutarla desde cualquier biblioteca HTTP.

Un elemento 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 siguiente código es un ejemplo sencillo de PythonScriptStep. Para obtener un ejemplo de un script de train.py, consulte la subsección correspondiente del 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 como mínimo un paso, los pasos se pueden vincular y publicarse como una canalización automatizada simple.

from azureml.pipeline.core import Pipeline

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

Para obtener un ejemplo completo de cómo crear 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 la canalización está asociado a un destino de proceso disponible dentro de esa área de trabajo. Para obtener más información, consulte este artículo sobre las áreas de trabajo o esta explicación sobre los destinos de proceso.

El siguiente es un patrón común para los pasos de canalización:

1. Especifique el área de trabajo, proceso y almacenamiento.
2. Configure los datos de entrada y salida mediante
   1. Dataset, que da acceso a un almacén de datos de Azure existente.
   2. PipelineDataset , que encapsula datos tabulares con tipo.
   3. PipelineData , que se usa para los datos intermedios de archivos o directorios escritos por un paso y pensados para que los consuma otro.
3. Defina uno o más pasos de canalización.
4. Cree una instancia de una canalización mediante el área de trabajo y los pasos.
5. Cree un experimento al que enviar la canalización.
6. Supervise los resultados del experimento.

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

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

AutoMLConfig

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

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

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

Para obtener guías detalladas y ejemplos de configuración de los experimentos de aprendizaje automático, consulte el tutorial y la guía de procedimiento.

El código siguiente muestra cómo crear un objeto de configuración de aprendizaje automático automatizado para un modelo de clasificación y cómo usarlo cuando se envía 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 enviarlo, el resultado muestra la precisión del entrenamiento para cada iteración a medida que la finaliza. Una vez finalizada la ejecución, se devuelve un objeto AutoMLRun (que amplía la clase Run). Para obtener el modelo perfecto, use 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 modelo

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 la preparación de la implementación de modelo y la implementación de servicios web, consulte esta guía de procedimiento.

Puede usar entornos al implementar el modelo como servicio web. Los entornos permiten un flujo de trabajo reproducible y conectado en el que puede implementar el modelo mediante las mismas bibliotecas en los procesos de entrenamiento e inferencia. Internamente, los entornos se implementan como imágenes de Docker. Puede usar las imágenes proporcionadas por Microsoft, o bien usar sus propias imágenes de Docker personalizadas. Si antes usaba la clase ContainerImage para la implementación, consulte la clase DockerSection para realizar 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 con el entorno myenv y desea 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 de escala de producción, use Azure Kubernetes Service (AKS). Para obtener más información, consulte Clase AksCompute.

Dataset

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 dentro de Azure Machine Learning. Puede explorar los datos con estadísticas de resumen y guardar el conjunto de datos en el área de trabajo de Azure Machine Learning para obtener las funcionalidades de control de versiones y reproducibilidad. Los modelos pueden consumir fácilmente los conjuntos de datos durante el entrenamiento. Para obtener ejemplos de uso detallados, consulte la guía paso a paso.

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

En el ejemplo siguiente se muestra cómo crear un elemento TabularDataset que apunta a una sola ruta de acceso de 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 elemento FileDataset que hace 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 para saber cómo usar el SDK de Azure Machine Learning para Python:

• Siga el tutorial para obtener información sobre cómo crear, entrenar e implementar un modelo en Python.

• Consulte las clases y módulos en la documentación de referencia de este sitio con ayuda de la tabla de contenido de la izquierda.