Trabalhando com tabelas no Azure Machine Learning

  • Artigo

APLICA-SE A:Extensão de ML da CLI do Azure v2 (atual)SDK do Python azure-ai-ml v2 (atual)

O Azure Machine Learning dá suporte a um tipo de tabela (mltable). Isso permite a criação de um blueprint que define como carregar arquivos de dados na memória como um dataframe do Pandas ou Spark. Neste artigo, você aprende:

  • Quando usar as Tabelas do Azure Machine Learning em vez de Arquivos ou Pastas
  • Como instalar o SDK da mltable
  • Como definir um blueprint de carregamento de dados usando um arquivo da mltable
  • Exemplos mostrando como a mltable é usada no Azure Machine Learning
  • Como usar a mltable durante o desenvolvimento interativo (por exemplo, em um notebook).

Pré-requisitos

Importante

Verifique se você tem o pacote mltable mais recente instalado no seu ambiente Python:

pip install -U mltable azureml-dataprep[pandas]

Clone o repositório de exemplos

Os snippets de código deste artigo são baseados nos exemplos do Repositório GitHub de exemplos do Azure Machine Learning. Para clonar o repositório para seu ambiente de desenvolvimento, use este comando:

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

Dica

Use --depth 1 para clonar apenas o commit mais recente para o repositório. Isso reduz o tempo necessário para concluir a operação.

Você pode encontrar exemplos relevantes para as Tabelas do Azure Machine Learning nessa pasta do repositório clonado:

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

Introdução

As Tabelas do Azure Machine Learning (mltable) permite definir como você deseja carregar seus arquivos de dados na memória, como um dataframe do Pandas e/ou Spark. As tabelas têm dois recursos principais:

  1. Um arquivo MLTable. Um arquivo baseado em YAML que define o blueprint de carregamento de dados. No arquivo MLTable, você pode especificar:
    • O local ou locais de armazenamento dos dados: no local, na nuvem ou em um servidor http(s) público.
    • Padrões de glob sobre o armazenamento em nuvem. Esses locais podem especificar conjuntos de nomes de arquivo com caracteres curinga (*).
    • transformação de leitura – por exemplo, o tipo de formato de arquivo (texto delimitado, Parquet, Delta, json), delimitadores, cabeçalhos etc.
    • Conversões de tipo de coluna (para implementar o esquema).
    • Criação de novas colunas usando informações da estrutura de pastas – por exemplo, criar uma coluna de ano e mês usando a estrutura de pastas {year}/{month} no caminho.
    • Subconjuntos de dados a serem carregados - por exemplo, filtrar linhas, manter/remover colunas, obter amostras aleatórias.
  2. Um mecanismo rápido e eficiente para carregar os dados em um dataframe, de acordo com o blueprint definido no arquivo MLTable. O mecanismo depende de Rust para obter alta velocidade e eficiência de memória.

As Tabelas do Azure Machine Learning são úteis nos seguintes cenários:

  • Você precisa usar o padrão glob sobre os locais de armazenamento.
  • Você precisa criar uma tabela usando dados de diferentes locais de armazenamento (por exemplo, contêineres de blob diferentes).
  • O caminho contém informações relevantes que você deseja capturar em seus dados (por exemplo, data e hora).
  • O esquema de dados é alterado com frequência.
  • Você deseja facilitar a reprodutibilidade das etapas de carregamento de dados.
  • Você só precisa de um subconjunto de dados grandes.
  • Seus dados contêm locais de armazenamento que você deseja transmitir para a sessão do Python. Por exemplo, você deseja transmitir path na seguinte estrutura de linhas JSON: [{"path": "abfss://fs@account.dfs.core.windows.net/my-images/cats/001.jpg", "label":"cat"}].
  • Você deseja treinar modelos de ML usando o AutoML do Azure Machine Learning.

Dica

No caso de dados tabulares, o Azure Machine Learning não requer o uso de Tabelas de Machine Learning do Azure (mltable). Você pode usar os tipos de arquivo (uri_file) e pasta (uri_folder) do Azure Machine Learning, e sua própria lógica de análise carregará os dados em um quadro de dados do Pandas ou do Spark.

No caso de um arquivo CSV simples ou de uma pasta Parquet, é mais fácil usar os Arquivos/Pastas do Azure Machine Learning em vez de Tabelas.

Início Rápido das Tabelas do Azure Machine Learning

Neste início rápido, você criará uma Tabela (mltable) dos Dados de Corridas de Táxis Verdes de Nova York do Azure Open Datasets. Os dados têm um formato de parquet e abrangem os anos 2008 a 2021. Em uma conta de armazenamento de blobs publicamente acessível, os arquivos de dados têm a seguinte estrutura de pastas:

/
└── 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

Com esses dados, você precisa carregá-los em um dataframe do Pandas:

  • Somente os arquivos parquet para os anos 2015 a 2019
  • Uma amostra aleatória dos dados
  • Somente linhas com uma distância de RIP maior que 0
  • Colunas relevantes para o Machine Learning
  • Novas colunas — ano e mês — usando as informações de caminho (puYear=X/puMonth=Y)

O código de Pandas lida com isso. No entanto, alcançar a reprodutibilidade se tornaria difícil porque você deve:

  • Compartilhar código, o que significa que, se o esquema for alterado (por exemplo, pode ser que um nome de coluna mude), todos os usuários precisarão atualizar seu código
  • Escrever um pipeline de ETL que tenha uma sobrecarga pesada

As tabelas do Machine Learning do Azure fornecem um mecanismo leve para serializar (salvar) as etapas de carregamento de dados em um arquivo MLTable. Em seguida, você e os membros de sua equipe podem reproduzir o quadro de dados do Pandas. Se o esquema for alterado, você só atualizará o arquivo MLTable, em vez de atualizações em muitos locais que envolvem o código de carregamento de dados do Python.

Clonar o notebook de início rápido ou criar um novo notebook/script

Se você usar uma instância de computação do Azure Machine Learning, Crie um novo notebook. Se usar um IDE, você deverá criar um novo script do Python.

Além disso, o notebook de início rápido está disponível no repositório GitHub de exemplos do Azure Machine Learning. Use este código para clonar e acessar o Notebook:

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

Instalar o SDK do Python mltable

Para carregar os dados de corridas de táxis verde de Nova York em uma Table ado Azure Machine Learning, você deve ter o SDK do Python mltable e pandas instalados em seu ambiente do Python, com este comando:

pip install -U mltable azureml-dataprep[pandas]

Criar um arquivo MLTable

Use o SDK do Python mltable para criar um arquivo MLTable para documentar o blueprint de carregamento de dados. Para fazer isso, copie e cole o seguinte código em seu Notebook/Script e execute esse 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, você pode optar por carregar o objeto MLTable no Pandas, usando:

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

Salvar as etapas de carregamento de dados

Em seguida, salve todas as etapas de carregamento de dados em um arquivo MLTable. Salvar suas etapas de carregamento de dados em um arquivo MLTable permite que você reproduza seu quadro de dados do Pandas posteriormente, sem a necessidade de redefinir o código a cada vez.

Você pode salvar o arquivo yaml da MLTable em um recurso de armazenamento em nuvem ou em recursos de um caminho 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

  • Se colocalizados == True, copiaremos os dados para a mesma pasta com o arquivo yaml da MLTable; se não estiverem colocalizados no momento, usaremos caminhos relativos no yaml da MLTable.
  • Se colocalizados == False, não migraremos os dados e usaremos caminhos absolutos para os dados de nuvem; para dados locais, usaremos caminhos relativos.
  • Não damos suporte a essa combinação de parâmetros: os dados estão armazenados em um recurso local; colocalizados == False; path tem como destino um diretório de nuvem. Carregue seus dados locais na nuvem e, em vez disso, use os caminhos de dados de nuvem para a MLTable.

Reproduzir etapas de carregamento de dados

Agora que serializou as etapas de carregamento de dados em um arquivo, você pode reproduzi-las em diversos pontos no tempo com o método load(). Dessa forma, você não precisa redefinir as etapas de carregamento de dados no código e pode compartilhar o arquivo com mais facilidade.

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

Criar um ativo de dados para ajudar no compartilhamento e na reprodutibilidade

Talvez você tenha seu arquivo da MLTable salvo em disco no momento, o que dificulta o compartilhamento com os membros da equipe. Quando você cria um ativo de dados no Azure Machine Learning, a MLTable é carregada no armazenamento em nuvem e “adicionada aos favoritos”, o que permite que seja acessada por membros da equipe com um nome amigável. Além disso, o ativo de dados tem controle de versão.

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

Observação

O caminho aponta para a pasta que contém o arquivo MLTable.

Ler o ativo de dados em uma sessão interativa

Agora que a sua MLTable está armazenada na nuvem, você e os membros da equipe podem acessá-la com um nome amigável em uma sessão interativa (por exemplo, um notebook):

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

Ler o ativo de dados em um trabalho

Se você ou um membro da equipe quiser acessar a Tabela em um trabalho, seu script de treinamento em Python conterá:

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

Seu trabalho precisa de um arquivo Conda que inclua as dependências do pacote do Python:

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

Você enviaria o trabalho usando:

Crie o seguinte arquivo YAML de trabalho:

# 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

Na CLI, crie o trabalho:

az ml job create -f mltable-job.yml

Criação de arquivos MLTable

Para criar o arquivo da MLTable diretamente, sugerimos que você use o SDK do Python damltable para criar os arquivos da sua MLTable — conforme mostrado no Início Rápido das Tabelas do Azure Machine Learning —, em vez de um editor de texto. Nesta seção, descrevemos os recursos no SDK do Python mltable.

Tipos de arquivo com suporte

Você pode criar uma MLTable usando uma série de tipos de arquivo diferentes:

Tipo de arquivo SDK do Python MLTable
Texto delimitado
(por exemplo, arquivo 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')
Linhas JSON from_json_lines_files(paths=[path])
Caminhos
(Criar uma tabela com uma coluna de caminhos para transmitir)		 from_paths(paths=[path])

Para obter mais informações, leia o recurso de referência da MLTable

Definir caminhos

Para texto delimitado, parquet, linhas JSON e caminhos, defina uma lista de dicionários do Python que defina os caminhos que devem ser lidos:

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)

A MLTable dá suporte aos seguintes tipos de caminho:

Localização Exemplos
Um caminho no computador local ./home/username/data/my_data
Um caminho em um servidor https(s) público https://raw.githubusercontent.com/pandas-dev/pandas/main/doc/data/titanic.csv
Um caminho no Armazenamento do Azure wasbs://<container_name>@<account_name>.blob.core.windows.net/<path>
abfss://<file_system>@<account_name>.dfs.core.windows.net/<path>
Um armazenamento de dados contínuo do Azure Machine Learning azureml://subscriptions/<subid>/resourcegroups/<rgname>/workspaces/<wsname>/datastores/<name>/paths/<path>

Observação

A mltable cuida da passagem de credenciais do usuário para os caminhos no Armazenamento do Azure e nos armazenamentos de dados do Azure Machine Learning. Se você não tiver permissão para os dados no armazenamento subjacente, não poderá acessar os dados.

Uma observação sobre como definir caminhos para Tabelas do Delta Lake

Quando comparada a outros tipos de arquivos, a opção de definir caminhos para ler tabelas do Delta Lake é diferente. Para tabelas do Delta Lake, o caminho aponta para apenas uma pasta (normalmente no ADLS gen2) que contém a pasta "_delta_log" e arquivos de dados. Há suporte para viagem no tempo. O código a seguir mostrar como definir um caminho para uma tabela do 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'
)

Se quiser obter a última versão dos dados do Delta Lake, você poderá repassar o carimbo de data e hora atual para 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

Limitação: a mltable não dá suporte à extração de chaves de partição ao ler dados do Delta Lake. A transformação mltableextract_columns_from_partition_format não funcionará quando você estiver lendo dados do Delta Lake por meio de mltable.

Importante

A mltable cuida da passagem de credenciais do usuário para os caminhos no Armazenamento do Azure e nos armazenamentos de dados do Azure Machine Learning. Se você não tiver permissão para os dados no armazenamento subjacente, não poderá acessar os dados.

Arquivos, pastas e globs

As Tabelas do Azure Machine Learning dão suporte à leitura de:

  • arquivos, por exemplo: abfss://<file_system>@<account_name>.dfs.core.windows.net/my-csv.csv
  • pastas, por exemplo: abfss://<file_system>@<account_name>.dfs.core.windows.net/my-folder/
  • padrões de glob, por exemplo: abfss://<file_system>@<account_name>.dfs.core.windows.net/my-folder/*.csv
  • uma combinação de arquivos, pastas e padrões glob

Transformações de carregamento de dados com suporte

Encontre detalhes completos e atualizados das transformações de carregamento de dados com suporte na documento de referência do MLTable.

Exemplos

Os exemplos no repositório do GitHub de exemplos do Azure Machine Learning tornaram-se a base para os trechos de código deste artigo. Use este comando para clonar o repositório para seu ambiente de desenvolvimento:

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

Dica

Use --depth 1 para clonar apenas o commit mais recente para o repositório. Isso reduz o tempo necessário para concluir a operação.

Essa pasta de repositório de clones hospeda os exemplos relevantes para as Tabelas do Azure Machine Learning:

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

Arquivos delimitados

Primeiro, crie um MLTable a partir de um arquivo CSV com 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)

Salvar as etapas de carregamento de dados

Em seguida, salve todas as etapas de carregamento de dados em um arquivo MLTable. Ao salvar suas etapas de carregamento de dados em um arquivo da MLTable, você pode reproduzir seu data frame do Pandas mais tarde, sem necessidade de redefinir o código a cada vez.

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

Reproduzir etapas de carregamento de dados

Agora que o arquivo tem as etapas de carregamento de dados serializadas, você pode reproduzi-las a qualquer momento com o método load(). Dessa forma, você não precisa redefinir as etapas de carregamento de dados no código e pode compartilhar o arquivo com mais facilidade.

import mltable

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

Criar um ativo de dados para ajudar no compartilhamento e na reprodutibilidade

Talvez você tenha seu arquivo da MLTable salvo em disco no momento, o que dificulta o compartilhamento com os membros da equipe. Quando você cria um ativo de dados no Azure Machine Learning, sua MLTable é carregada no armazenamento em nuvem e “adicionada aos favoritos”. A seguir, os membros da sua equipe podem acessar a MLTable com um nome amigável. Além disso, o ativo de dados tem controle de versão.

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)

Agora que a sua MLTable está armazenada na nuvem, você e os membros da equipe podem acessá-la com um nome amigável em uma sessão interativa (por exemplo, um notebook):

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)

Você também pode acessar facilmente o ativo de dados em um trabalho.

Arquivos Parquet

O Início Rápido das Tabelas do Azure Machine Learning explica como ler arquivos parquet.

Caminhos: criar uma tabela de arquivos de imagem

Você pode criar uma tabela que contém os caminhos no armazenamento em nuvem. Este exemplo tem várias imagens de cachorros e gatos localizadas no armazenamento em nuvem, na seguinte estrutura de pastas:

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

Omltable pode criar uma tabela que contém os caminhos de armazenamento dessas imagens e seus nomes de pasta (rótulos), que podem ser usados para transmitir as imagens. Esse código cria a 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")

Esse código mostra como abrir o local de armazenamento no data frame do Pandas e plotar as imagens:

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

Criar um ativo de dados para ajudar no compartilhamento e na reprodutibilidade

Talvez você tenha seu arquivo da mltable salvo em disco no momento, o que dificulta o compartilhamento com os membros da equipe. Quando você cria um ativo de dados no Azure Machine Learning, a mltable é carregada no armazenamento em nuvem e “adicionada aos favoritos”. A seguir, os membros da equipe podem acessar a mltable com um nome amigável. Além disso, o ativo de dados tem controle de versão.

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)

Agora que a sua mltable está armazenada na nuvem, você e os membros da equipe podem acessá-la com um nome amigável em uma sessão interativa (por exemplo, um notebook):

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

Você também pode carregar os dados em seu trabalho.

Próximas etapas