Uso de tablas en Azure Machine Learning

SE APLICA A:Extensión ML de la CLI de Azure v2 (actual)SDK de Python azure-ai-ml v2 (actual)

Azure Machine Learning admite un tipo de tabla (mltable). Esto permite la creación de un plano técnico que define cómo cargar archivos de datos en la memoria como tramas de datos de Pandas o Spark. En este artículo, aprenderá lo siguiente:

Requisitos previos

• Suscripción a Azure. Si aún no tiene una suscripción de Azure, cree una cuenta gratuita antes de comenzar. Pruebe la versión gratuita o de pago de Azure Machine Learning.

• El SDK de Azure Machine Learning para Python

• Un área de trabajo de Azure Machine Learning.

pip install -U mltable azureml-dataprep[pandas]

Clone el repositorio de ejemplos

Los fragmentos de código de este artículo se basan en ejemplos del repositorio de GitHub de ejemplos de Azure Machine Learning. Para clonar el repositorio en su entorno de desarrollo, utilice el siguiente comando:

git clone --depth 1 https://github.com/Azure/azureml-examples

Puede encontrar ejemplos relevantes para las tablas de Azure Machine Learning en esta carpeta del repositorio clonado:

cd azureml-examples/sdk/python/using-mltable

Introducción

Las tablas de Azure Machine Learning (mltable) permiten definir cómo desea cargar los archivos de datos en la memoria, como tramas de datos de Pandas o Spark. Las tablas tienen dos características clave:

1. El archivo MLTable. Un archivo basado en YAML que define el plano técnico de la carga de datos. En el archivo MLTable, puede especificar:
   • La ubicación del almacenamiento o las ubicaciones de los datos: locales, en la nube o en un servidor HTTP(S) público.
   • Patrones globales sobre el almacenamiento en la nube. Estas ubicaciones pueden especificar conjuntos de nombres de archivo con caracteres comodín (*).
   • Transformación de lectura: por ejemplo, el tipo de formato de archivo (texto delimitado, Parquet, Delta, json), delimitadores, encabezados, etc.
   • Conversiones de tipo de columna (para aplicar el esquema).
   • Creación de columnas con información de la estructura de carpetas, por ejemplo, la creación de una columna de año y mes mediante la estructura de carpetas {year}/{month} de la ruta de acceso.
   • Subconjuntos de datos para cargar, por ejemplo, filtrar filas, mantener o quitar columnas, tomar muestras aleatorias.
2. Un motor rápido y eficaz para cargar los datos en un dataframe de Pandas o Spark, según el plano técnico definido en el archivo MLTable. El motor se basa en Rust para lograr una alta velocidad y eficiencia de memoria.

Las tablas de Azure Machine Learning son útiles en los escenarios siguientes:

• Debe hacer patrones globales sobre las ubicaciones de almacenamiento.
• Debe crear una tabla mediante datos de diferentes ubicaciones de almacenamiento (por ejemplo, contenedores de blob diferentes).
• La ruta de acceso contiene información relevante que desea capturar en los datos (por ejemplo, fecha y hora).
• El esquema de datos cambia con frecuencia.
• Desea una reproducibilidad sencilla de los pasos de carga de datos.
• Solo necesita un subconjunto de datos de gran tamaño.
• Los datos contienen ubicaciones de almacenamiento que desea transmitir a la sesión de Python. Por ejemplo, quiere transmitir path en la siguiente estructura de líneas JSON: [{"path": "abfss://fs@account.dfs.core.windows.net/my-images/cats/001.jpg", "label":"cat"}].
• Quiere entrenar modelos de ML mediante AutoML de Azure Machine Learning.

Inicio rápido de tablas de Azure Machine Learning

En este inicio rápido, creará una tabla (mltable) de NYC Green Taxi Data desde Azure Open Datasets. Los datos tienen formato Parquet y abarcan los años 2008-2021. En una cuenta de almacenamiento de blobs de acceso público, los archivos de datos tienen esta estructura de carpetas:

/
└── green
    ├── puYear=2008
    │   ├── puMonth=1
    │   │   ├── _committed_2983805876188002631
    │   │   └── part-XXX.snappy.parquet
    │   ├── ...
    │   └── puMonth=12
    │       ├── _committed_2983805876188002631
    │       └── part-XXX.snappy.parquet
    ├── ...
    └── puYear=2021
        ├── puMonth=1
        │   ├── _committed_2983805876188002631
        │   └── part-XXX.snappy.parquet
        ├── ...
        └── puMonth=12
            ├── _committed_2983805876188002631
            └── part-XXX.snappy.parquet

Con estos datos, debe cargarlos en una trama de datos de Pandas:

• Solo los archivos Parquet de los años 2015-19
• Una muestra aleatoria de los datos
• Solo las filas con una distancia de RIP mayor que 0
• Columnas relevantes para Machine Learning
• Columnas nuevas (año y mes) usando la información de ruta de acceso (puYear=X/puMonth=Y)

El código de Pandas controla esto. Sin embargo, lograr la reproducibilidad sería difícil porque debe:

• Compartir el código, lo que significa que si el esquema cambia (podría cambiar, por ejemplo, un nombre de columna), todos los usuarios deben actualizar su código
• Escribir una canalización ETL, que tiene una sobrecarga elevada

Las tablas de Azure Machine Learning proporcionan un mecanismo ligero para serializar (guardar) los pasos de carga de datos en un archivo MLTable. A continuación, usted y los miembros de su equipo pueden reproducir el marco de datos Pandas. Si el esquema cambia, solo debe actualizar el archivo MLTable, en lugar de hacer actualizaciones en muchos lugares que implican el código de carga de datos de Python.

Clonación del cuaderno de inicio rápido o creación de un nuevo cuaderno o script

Si usa una instancia de proceso de Azure Machine Learning, cree un cuaderno nuevo. Si utiliza un IDE, debe crear un nuevo script Python.

Además, el cuaderno de inicio rápido está disponible en el repositorio de GitHub de ejemplos de Azure Machine Learning. Use este código para clonar y acceder al cuaderno:

git clone --depth 1 https://github.com/Azure/azureml-examples
cd azureml-examples/sdk/python/using-mltable/quickstart

Instalación del SDK para Python mltable

Para cargar NYC Green Taxi Data en una tabla de Azure Machine Learning, debe tener el SDK de Python mltable y pandas instalados en el entorno de Python, con este comando:

pip install -U mltable azureml-dataprep[pandas]

Creación de un archivo MLTable

Use el SDK de Python mltable para crear un archivo MLTable y documentar el plano técnico de carga de datos. Para ello, copie y pegue el código siguiente en el cuaderno o script y, a continuación, ejecute ese código:

import mltable

# glob the parquet file paths for years 2015-19, all months.
paths = [
    {
        "pattern": "wasbs://nyctlc@azureopendatastorage.blob.core.windows.net/green/puYear=2015/puMonth=*/*.parquet"
    },
    {
        "pattern": "wasbs://nyctlc@azureopendatastorage.blob.core.windows.net/green/puYear=2016/puMonth=*/*.parquet"
    },
    {
        "pattern": "wasbs://nyctlc@azureopendatastorage.blob.core.windows.net/green/puYear=2017/puMonth=*/*.parquet"
    },
    {
        "pattern": "wasbs://nyctlc@azureopendatastorage.blob.core.windows.net/green/puYear=2018/puMonth=*/*.parquet"
    },
    {
        "pattern": "wasbs://nyctlc@azureopendatastorage.blob.core.windows.net/green/puYear=2019/puMonth=*/*.parquet"
    },
]

# create a table from the parquet paths
tbl = mltable.from_parquet_files(paths)

# table a random sample
tbl = tbl.take_random_sample(probability=0.001, seed=735)

# filter trips with a distance > 0
tbl = tbl.filter("col('tripDistance') > 0")

# Drop columns
tbl = tbl.drop_columns(["puLocationId", "doLocationId", "storeAndFwdFlag"])

# Create two new columns - year and month - where the values are taken from the path
tbl = tbl.extract_columns_from_partition_format("/puYear={year}/puMonth={month}")

# print the first 5 records of the table as a check
tbl.show(5)

Opcionalmente, puede optar por cargar el objeto MLTable en Pandas mediante:

# You can load the table into a pandas dataframe
# NOTE: The data is in East US region and the data is large, so this will take several minutes (~7mins)
# to load if you are in a different region.

# df = tbl.to_pandas_dataframe()

Guardar los pasos de carga de datos

A continuación, guarde todos los pasos de carga de datos en un archivo MLTable. Guardar los pasos de carga de datos en un fichero MLTable permite reproducir el marco de datos de Pandas en otro momento, sin necesidad de redefinir el código cada vez.

Puede guardar el archivo yaml de la MLTable en un recurso de almacenamiento en la nube o en los recursos de ruta de acceso local.

# save the data loading steps in an MLTable file to a cloud storage resource
# NOTE: the tbl object was defined in the previous snippet.
tbl.save(path="azureml://subscriptions/<subid>/resourcegroups/<rgname>/workspaces/<wsname>/datastores/<name>/paths/titanic", colocated=True, show_progress=True, overwrite=True)

# save the data loading steps in an MLTable file to a local resource
# NOTE: the tbl object was defined in the previous snippet.
tbl.save("./titanic")

Reproduzca los pasos de carga de datos

Ahora que ha serializado los pasos de carga de datos en un archivo, puede reproducirlos en cualquier momento con el método load(). De este modo, no es necesario volver a definir los pasos de carga de datos en el código y así puede compartir más fácilmente el archivo.

import mltable

# load the previously saved MLTable file
tbl = mltable.load("./nyc_taxi/")
tbl.show(5)

# You can load the table into a pandas dataframe
# NOTE: The data is in East US region and the data is large, so this will take several minutes (~7mins)
# to load if you are in a different region.

# load the table into pandas
# df = tbl.to_pandas_dataframe()

# print the head of the data frame
# df.head()
# print the shape and column types of the data frame
# print(f"Shape: {df.shape}")
# print(f"Columns:\n{df.dtypes}")

Creación de un recurso de datos para ayudar a compartir y reproducir

Es posible que tenga el archivo de la MLTable guardado actualmente en el disco, lo que dificulta el uso compartido con los miembros del equipo. Al crear un recurso de datos en Azure Machine Learning, la MLTable se carga en el almacenamiento en la nube y se "marca". Entonces los miembros del equipo acceder a la MLTable con un nombre descriptivo. Además, el recurso de datos tiene versiones.

az ml data create --name green-quickstart --version 1 --path ./nyc_taxi --type mltable

subscription_id = "<SUBSCRIPTION_ID>"
resource_group = "<RESOURCE_GROUP>"
workspace = "<AML_WORKSPACE_NAME>"

from azure.ai.ml import MLClient
from azure.ai.ml.entities import Data
from azure.ai.ml.constants import AssetTypes
from azure.identity import DefaultAzureCredential

# set VERSION variable
VERSION="1"

# connect to the AzureML workspace
# NOTE: the subscription_id, resource_group, workspace variables are set
# in the previous code snippet.
ml_client = MLClient(
    DefaultAzureCredential(), subscription_id, resource_group, workspace
)

my_data = Data(
    path="./nyc_taxi",
    type=AssetTypes.MLTABLE,
    description="A random sample of NYC Green Taxi Data between 2015-19.",
    name="green-quickstart",
    version=VERSION,
)

ml_client.data.create_or_update(my_data)

Leer el recurso de datos en una sesión interactiva

Ahora que tiene la MLTable almacenada en la nube, usted y los miembros del equipo pueden acceder a ella con un nombre descriptivo en una sesión interactiva (por ejemplo, un cuaderno):

import mltable
from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential

# connect to the AzureML workspace
# NOTE: the subscription_id, resource_group, workspace variables are set
# in a previous code snippet.
ml_client = MLClient(
    DefaultAzureCredential(), subscription_id, resource_group, workspace
)

# get the latest version of the data asset
# Note: The version was set in the previous snippet. If you changed the version
# number, update the VERSION variable below.
VERSION="1"
data_asset = ml_client.data.get(name="green-quickstart", version=VERSION)

# create a table
tbl = mltable.load(f"azureml:/{data_asset.id}")
tbl.show(5)

# load into pandas
# NOTE: The data is in East US region and the data is large, so this will take several minutes (~7mins) to load if you are in a different region.
df = tbl.to_pandas_dataframe()

Leer el recurso de datos en un trabajo

Si usted o un miembro de su equipo quieren acceder a la tabla en un trabajo, su script de formación Python contendría:

# ./src/train.py
import argparse
import mltable

# parse arguments
parser = argparse.ArgumentParser()
parser.add_argument('--input', help='mltable to read')
args = parser.parse_args()

# load mltable
tbl = mltable.load(args.input)

# load into pandas
df = tbl.to_pandas_dataframe()

El trabajo necesita un archivo de Conda que incluya las dependencias del paquete de Python:

# ./conda_dependencies.yml
dependencies:
  - python=3.10
  - pip=21.2.4
  - pip:
      - mltable
      - azureml-dataprep[pandas]

Enviaría el trabajo mediante:

# mltable-job.yml
$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json

code: ./src

command: python train.py --input ${{inputs.green}}
inputs:
    green:
      type: mltable
      path: azureml:green-quickstart:1

compute: cpu-cluster

environment:
  image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04
  conda_file: conda_dependencies.yml

az ml job create -f mltable-job.yml

from azure.ai.ml import MLClient, command, Input
from azure.ai.ml.entities import Environment
from azure.identity import DefaultAzureCredential

# connect to the AzureML workspace
ml_client = MLClient(
    DefaultAzureCredential(), subscription_id, resource_group, workspace
)

# get the latest version of the data asset
# Note: the VERSION was set in a previous cell.
data_asset = ml_client.data.get(name="green-quickstart", version=VERSION)

job = command(
    command="python train.py --input ${{inputs.green}}",
    inputs={"green": Input(type="mltable", path=data_asset.id)},
    compute="cpu-cluster",
    environment=Environment(
        image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04",
        conda_file="./job-env/conda_dependencies.yml",
    ),
    code="./src",
)

ml_client.jobs.create_or_update(job)

Creación de archivos MLTable

Para crear directamente el archivo de la MLTable, se recomienda usar el SDK de Python mltable para crear los archivos de la MLTable, como se muestra en el Inicio rápido de tablas de Azure Machine Learning, en lugar de un editor de texto. En esta sección, se describen las funcionalidades del SDK de Python mltable.

Tipos de archivo admitidos

Puede crear una MLTable mediante diferentes tipos de archivo:

Para más información, lea la documentación de referencia de MLTable

Definición de rutas de acceso

Para texto delimitado, formato Parquet, líneas y rutas de acceso JSON, defina una lista de diccionarios de Python que definan las rutas de acceso desde las que se van a leer:

import mltable

# A List of paths to read into the table. The paths are a python dict that define if the path is
# a file, folder, or (glob) pattern.
paths = [
    {
        "file": "<supported_path>"
    }
]

tbl = mltable.from_delimited_files(paths=paths)

# alternatively
# tbl = mltable.from_parquet_files(paths=paths)
# tbl = mltable.from_json_lines_files(paths=paths)
# tbl = mltable.from_paths(paths=paths)

MLTable admite los siguientes tipos de ruta de acceso:

Nota sobre cómo definir rutas de acceso para tablas de Delta Lake

En comparación con los otros tipos de archivo, definir rutas de acceso para leer tablas de Delta Lake es diferente. Para las tablas de Delta Lake, la ruta de acceso apunta a una única carpeta (normalmente en ADLS gen2) que contiene la carpeta "_delta_log" y los archivos de datos. Se admite el viaje en el tiempo. En el código siguiente se muestra cómo definir una ruta de acceso para una tabla de Delta Lake:

import mltable

# define the cloud path containing the delta table (where the _delta_log file is stored)
delta_table = "abfss://<file_system>@<account_name>.dfs.core.windows.net/<path_to_delta_table>"

# create an MLTable. Note the timestamp_as_of parameter for time travel.
tbl = mltable.from_delta_lake(
    delta_table_uri=delta_table,
    timestamp_as_of='2022-08-26T00:00:00Z'
)

Para obtener la versión más reciente de los datos de Delta Lake, puede pasar la marca de tiempo actual a timestamp_as_of.

import mltable

# define the relative path containing the delta table (where the _delta_log file is stored)
delta_table_path = "./working-directory/delta-sample-data"

# get the current timestamp in the required format
current_timestamp = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
print(current_timestamp)
tbl = mltable.from_delta_lake(delta_table_path, timestamp_as_of=current_timestamp)
df = tbl.to_pandas_dataframe()

Archivos, carpetas y patrones globales

Las tablas de Azure Machine Learning admiten la lectura desde:

• archivos, por ejemplo: abfss://<file_system>@<account_name>.dfs.core.windows.net/my-csv.csv
• carpetas, por ejemplo: abfss://<file_system>@<account_name>.dfs.core.windows.net/my-folder/
• patrones globales, por ejemplo: abfss://<file_system>@<account_name>.dfs.core.windows.net/my-folder/*.csv
• una combinación de archivos, carpetas y patrones globales

Transformaciones de carga de datos admitidas

Busque detalles completos y actualizados de las transformaciones de carga de datos admitidas en la documentación de referencia de MLTable.

Ejemplos

Los ejemplos de Ejemplos de Azure Machine Learning repositorio GitHub se convirtieron en la base de los fragmentos de código de este artículo. Use este comando para clonar el repositorio en el entorno de desarrollo:

git clone --depth 1 https://github.com/Azure/azureml-examples

Esta carpeta del repositorio clonado hospeda los ejemplos pertinentes para las tablas de Azure Machine Learning:

cd azureml-examples/sdk/python/using-mltable

Archivos delimitados

En primer lugar, cree una MLTable a partir de un archivo CSV con este código:

import mltable
from mltable import MLTableHeaders, MLTableFileEncoding, DataType

# create paths to the data files
paths = [{"file": "wasbs://data@azuremlexampledata.blob.core.windows.net/titanic.csv"}]

# create an MLTable from the data files
tbl = mltable.from_delimited_files(
    paths=paths,
    delimiter=",",
    header=MLTableHeaders.all_files_same_headers,
    infer_column_types=True,
    include_path_column=False,
    encoding=MLTableFileEncoding.utf8,
)

# filter out rows undefined ages
tbl = tbl.filter("col('Age') > 0")

# drop PassengerId
tbl = tbl.drop_columns(["PassengerId"])

# ensure survived column is treated as boolean
data_types = {
    "Survived": DataType.to_bool(
        true_values=["True", "true", "1"], false_values=["False", "false", "0"]
    )
}
tbl = tbl.convert_column_types(data_types)

# show the first 5 records
tbl.show(5)

# You can also load into pandas...
# df = tbl.to_pandas_dataframe()
# df.head(5)

Guardar los pasos de carga de datos

A continuación, guarde todos los pasos de carga de datos en un archivo MLTable. Cuando guarda los pasos de carga de datos en un archivo de MLTable, puede reproducir el marco de datos de Pandas en otro momento, sin necesidad de redefinir el código cada vez.

# save the data loading steps in an MLTable file
# NOTE: the tbl object was defined in the previous snippet.
tbl.save("./titanic")

Reproduzca los pasos de carga de datos

Ahora que el archivo tiene los pasos de carga de datos serializados, puede reproducirlos en cualquier momento con el método load(). De este modo, no es necesario volver a definir los pasos de carga de datos en el código y así puede compartir más fácilmente el archivo.

import mltable

# load the previously saved MLTable file
tbl = mltable.load("./titanic/")

Creación de un recurso de datos para ayudar a compartir y reproducir

Es posible que tenga el archivo de la MLTable guardado actualmente en el disco, lo que dificulta el uso compartido con los miembros del equipo. Al crear un recurso de datos en Azure Machine Learning, la MLTable se carga en el almacenamiento en la nube y se "marca". Los miembros del equipo pueden acceder a la MLTable con un nombre descriptivo. Además, el recurso de datos tiene versiones.

import time
from azure.ai.ml import MLClient
from azure.ai.ml.entities import Data
from azure.ai.ml.constants import AssetTypes
from azure.identity import DefaultAzureCredential

# Update with your details...
subscription_id = "<SUBSCRIPTION_ID>"
resource_group = "<RESOURCE_GROUP>"
workspace = "<AML_WORKSPACE_NAME>"

# set the version number of the data asset to the current UTC time
VERSION = time.strftime("%Y.%m.%d.%H%M%S", time.gmtime())

# connect to the AzureML workspace
ml_client = MLClient(
    DefaultAzureCredential(), subscription_id, resource_group, workspace
)

my_data = Data(
    path="./titanic",
    type=AssetTypes.MLTABLE,
    description="The titanic dataset.",
    name="titanic-cloud-example",
    version=VERSION,
)

ml_client.data.create_or_update(my_data)

Ahora que tiene la MLTable almacenada en la nube, usted y los miembros del equipo pueden acceder a ella con un nombre descriptivo en una sesión interactiva (por ejemplo, un cuaderno):

import mltable
from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential

# connect to the AzureML workspace
# NOTE:  subscription_id, resource_group, workspace were set in a previous snippet.
ml_client = MLClient(
    DefaultAzureCredential(), subscription_id, resource_group, workspace
)

# get the latest version of the data asset
# Note: The version was set in the previous code cell.
data_asset = ml_client.data.get(name="titanic-cloud-example", version=VERSION)

# create a table
tbl = mltable.load(f"azureml:/{data_asset.id}")

# load into pandas
df = tbl.to_pandas_dataframe()
df.head(5)

También puede acceder fácilmente al recurso de datos en un trabajo.

Archivos de Parquet

En el Inicio rápido de tablas de Azure Machine Learning, se muestra cómo leer archivos Parquet.

Rutas de acceso: crear una tabla de archivos de imagen

Puede crear una tabla que contenga las rutas de acceso en el almacenamiento en la nube. Este ejemplo tiene varias imágenes de perros y gatos ubicadas en el almacenamiento en la nube, en la siguiente estructura de carpetas:

/pet-images
  /cat
    0.jpeg
    1.jpeg
    ...
  /dog
    0.jpeg
    1.jpeg

La mltable puede construir una tabla que contenga las rutas de acceso de almacenamiento de estas imágenes y sus nombres de carpeta (etiquetas), las cuales se pueden usar para transmitir las imágenes. Este código crea la MLTable:

import mltable

# create paths to the data files
paths = [{"pattern": "wasbs://data@azuremlexampledata.blob.core.windows.net/pet-images/**/*.jpg"}]

# create the mltable
tbl = mltable.from_paths(paths)

# extract useful information from the path
tbl = tbl.extract_columns_from_partition_format("{account}/{container}/{folder}/{label}")

tbl = tbl.drop_columns(["account", "container", "folder"])

df = tbl.to_pandas_dataframe()
print(df.head())

# save the data loading steps in an MLTable file
tbl.save("./pets")

El código siguiente muestra cómo abrir la ubicación de almacenamiento en la trama de datos de Pandas y trazar las imágenes:

# plot images on a grid. Note this takes ~1min to execute.
import matplotlib.pyplot as plt
from PIL import Image

fig = plt.figure(figsize=(20, 20))
columns = 4
rows = 5
for i in range(1, columns*rows +1):
    with df.Path[i].open() as f:
        img = Image.open(f)
        fig.add_subplot(rows, columns, i)
        plt.imshow(img)
        plt.title(df.label[i])

Creación de un recurso de datos para ayudar a compartir y reproducir

Es posible que tenga el archivo mltable guardado actualmente en el disco, lo que dificulta el uso compartido con los miembros del equipo. Al crear un recurso de datos en Azure Machine Learning, la mltable se carga en el almacenamiento en la nube y se "marca". Entonces los miembros del equipo podrán acceder a la mltable con un nombre descriptivo. Además, el recurso de datos tiene versiones.

import time
from azure.ai.ml import MLClient
from azure.ai.ml.entities import Data
from azure.ai.ml.constants import AssetTypes
from azure.identity import DefaultAzureCredential

# set the version number of the data asset to the current UTC time
VERSION = time.strftime("%Y.%m.%d.%H%M%S", time.gmtime())

# connect to the AzureML workspace
# NOTE: subscription_id, resource_group, workspace were set in a previous snippet.
ml_client = MLClient(
    DefaultAzureCredential(), subscription_id, resource_group, workspace
)

my_data = Data(
    path="./pets",
    type=AssetTypes.MLTABLE,
    description="A sample of cat and dog images",
    name="pets-mltable-example",
    version=VERSION,
)

ml_client.data.create_or_update(my_data)

Ahora que tiene la mltable almacenada en la nube, usted y los miembros del equipo podrán acceder a ella con un nombre descriptivo en una sesión interactiva (por ejemplo, un cuaderno):

import mltable
from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential

# connect to the AzureML workspace
# NOTE: subscription_id, resource_group, workspace were set in a previous snippet.
ml_client = MLClient(
    DefaultAzureCredential(), subscription_id, resource_group, workspace
)

# get the latest version of the data asset
# Note: the variable VERSION is set in the previous code
data_asset = ml_client.data.get(name="pets-mltable-example", version=VERSION)

# the table from the data asset id
tbl = mltable.load(f"azureml:/{data_asset.id}")

# load into pandas
df = tbl.to_pandas_dataframe()
df.head()

También puede cargar los datos en el trabajo.

Pasos siguientes

• Acceso a datos en un trabajo
• Creación y administración de recursos de datos
• Importar recursos de datos (versión preliminar)
• Administración de datos