Uso de tablas en Azure Machine Learning

Artículo
09/03/2024

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:

Cuándo utilizar tablas de Azure Machine Learning en lugar de archivos o carpetas
Cómo instalar el SDK de mltable
Cómo definir un plano técnico de carga de datos mediante un archivo mltable
Ejemplos que muestran cómo se utiliza mltable en Azure Machine Learning
Cómo usar mltable durante el desarrollo interactivo (por ejemplo, en un cuaderno)

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.

Importante

Asegúrese de tener instalado el paquete mltable más reciente en el entorno de Python:

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

Sugerencia

Use --depth 1 para clonar únicamente la última confirmación al repositorio. Esto reduce el tiempo necesario para completar la operación.

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:

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

Sugerencia

Para datos tabulares, Azure Machine Learning no requiere el uso de tablas de Azure Machine Learning (mltable). Puede utilizar los tipos Archivo (uri_file) y Carpeta (uri_folder) de Azure Machine Learning, y su propia lógica de análisis carga los datos en un marco de datos Pandas o Spark.

Para un archivo CSV simple o una carpeta Parquet, es más fácil utilizar archivos/carpetas de Azure Machine Learning en lugar de tablas.

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

Importante

Si colocated == True, entonces copiaremos los datos a la misma carpeta con el archivo yaml de la MLTable, si no están actualmente colocados, y usaremos rutas de acceso relativas en el archivo yaml de la MLTable.
Si colocated == False, no moveremos los datos, usaremos rutas de acceso absolutas para los datos en la nube y rutas de acceso relativas para los datos locales.
No se admite esta combinación de parámetros: los datos se almacenan en un recurso local, si colocated == False, path tiene como destino un directorio en la nube. Cargue los datos locales en la nube y use las rutas de acceso de datos en la nube para MLTable en su lugar.

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

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.

CLI
Python

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

Nota

La ruta de acceso apunta a la carpeta que contiene el archivo MLTable.

Establezca la suscripción, el grupo de recursos y el área de trabajo:

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

Puede crear un recurso de datos en Azure Machine Learning mediante el siguiente código de Python:

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)

Nota

La ruta de acceso apunta a la carpeta que contiene el artefacto de MLTable.

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:

CLI
Python

Cree el siguiente archivo YAML de trabajo:

# 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

En la CLI, cree el trabajo:

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:

Tipo de archivo	Python SDK `MLTable`
Texto delimitado (por ejemplo, archivos CSV)	`from_delimited_files(paths=[path])`
Parquet	`from_parquet_files(paths=[path])`
Delta Lake	`from_delta_lake(delta_table_uri=<uri_pointing_to_delta_table_directory>,timestamp_as_of='2022-08-26T00:00:00Z')`
Líneas JSON	`from_json_lines_files(paths=[path])`
Rutas de acceso (Cree una tabla con una columna de rutas de acceso para transmitir)	`from_paths(paths=[path])`

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:

Ubicación	Ejemplos
Ruta de acceso en la máquina local	`./home/username/data/my_data`
Ruta de acceso en un servidor http(s) público	`https://raw.githubusercontent.com/pandas-dev/pandas/main/doc/data/titanic.csv`
Ruta de acceso en Azure Storage	`wasbs://<container_name>@<account_name>.blob.core.windows.net/<path>` `abfss://<file_system>@<account_name>.dfs.core.windows.net/<path>`
Un almacén de datos de Azure Machine Learning de forma larga	`azureml://subscriptions/<subid>/resourcegroups/<rgname>/workspaces/<wsname>/datastores/<name>/paths/<path>`

Nota:

mltable controla el paso de credenciales de usuario para las rutas de acceso de los almacenes de datos de Azure Storage y Azure Machine Learning. Si no tiene permisos para los datos del almacenamiento subyacente, no podrá acceder a los datos.

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

Importante

Limitación: mltable no admite la extracción de claves de partición al leer datos de Delta Lake. La mltable transformación extract_columns_from_partition_format no funcionará cuando lea los datos de Delta Lake a través de mltable.

Importante

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

Sugerencia

Use --depth 1 para clonar únicamente la última confirmación al repositorio. Esto reduce el tiempo necesario para completar la operación.

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

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

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.

Compartir a través de

Uso de tablas en Azure Machine Learning

Requisitos previos

Clone el repositorio de ejemplos

Introducción

Inicio rápido de tablas de Azure Machine Learning

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

Instalación del SDK para Python `mltable`

Creación de un archivo MLTable

Guardar los pasos de carga de datos

Reproduzca los pasos de carga de datos

Leer el recurso de datos en una sesión interactiva

Leer el recurso de datos en un trabajo

Creación de archivos MLTable

Tipos de archivo admitidos

Definición de rutas de acceso

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

Archivos, carpetas y patrones globales

Transformaciones de carga de datos admitidas

Ejemplos

Archivos delimitados

Guardar los pasos de carga de datos

Reproduzca los pasos de carga de datos

Archivos de Parquet

Rutas de acceso: crear una tabla de archivos de imagen

Pasos siguientes

Comentarios

Recursos adicionales

Compartir a través de

Uso de tablas en Azure Machine Learning

Requisitos previos

Clone el repositorio de ejemplos

Introducción

Inicio rápido de tablas de Azure Machine Learning

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

Instalación del SDK para Python mltable

Creación de un archivo MLTable

Guardar los pasos de carga de datos

Reproduzca los pasos de carga de datos

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

Leer el recurso de datos en una sesión interactiva

Leer el recurso de datos en un trabajo

Creación de archivos MLTable

Tipos de archivo admitidos

Definición de rutas de acceso

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

Archivos, carpetas y patrones globales

Transformaciones de carga de datos admitidas

Ejemplos

Archivos delimitados

Guardar los pasos de carga de datos

Reproduzca los pasos de carga de datos

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

Archivos de Parquet

Rutas de acceso: crear una tabla de archivos de imagen

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

Pasos siguientes

Comentarios

Recursos adicionales

Instalación del SDK para Python `mltable`