Trabalhar com tabelas no Azure Machine Learning

  • Artigo

APLICA-SE A:Azure CLI ml extension v2 (current)Python SDK azure-ai-ml v2 (current)

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

  • Quando usar as Tabelas do Aprendizado de Máquina do Azure em vez de Arquivos ou Pastas
  • Como instalar o mltable SDK
  • Como definir um plano de carregamento de dados usando um mltable arquivo
  • Exemplos que mostram como mltable é usado no Azure Machine Learning
  • Como usar o durante o mltable desenvolvimento interativo (por exemplo, em um bloco de anotações)

Pré-requisitos

Importante

Certifique-se de ter o pacote mais recente mltable instalado em seu ambiente Python:

pip install -U mltable azureml-dataprep[pandas]

Clone o repositório de exemplos

Os trechos de código neste artigo são baseados em exemplos no repositório GitHub de exemplos do Aprendizado de Máquina do Azure. Para clonar o repositório para seu ambiente de desenvolvimento, use este comando:

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

Gorjeta

Use --depth 1 para clonar apenas a confirmação 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 de Aprendizado de Máquina do Azure nesta pasta do repositório clonado:

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

Introdução

As Tabelas de Aprendizagem de Máquina do Azure (mltable) permitem-lhe definir como pretende carregar os seus ficheiros de dados na memória, como um quadro de dados Pandas e/ou Spark. As tabelas têm duas características principais:

  1. Um arquivo MLTable. Um arquivo baseado em YAML que define o esquema de carregamento de dados. No arquivo MLTable, você pode especificar:
    • O local ou locais de armazenamento dos dados - local, na nuvem ou em um servidor http(s) público.
    • Padrões de globbing sobre armazenamento em nuvem. Esses locais podem especificar conjuntos de nomes de arquivos, 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 impor o esquema).
    • Criação de nova coluna, usando informações de estrutura de pastas - por exemplo, criação de uma coluna de ano e mês, usando a {year}/{month} estrutura de pastas no caminho.
    • Subconjuntos de dados para carregar - por exemplo, filtrar linhas, manter/soltar colunas, colher amostras aleatórias.
  2. Um mecanismo rápido e eficiente para carregar os dados em um dataframe Pandas ou Spark, de acordo com o plano definido no arquivo MLTable. O motor depende de Rust para alta velocidade e eficiência de memória.

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

  • Você precisa examinar os locais de armazenamento.
  • Você precisa criar uma tabela usando dados de diferentes locais de armazenamento (por exemplo, diferentes contêineres de blob).
  • O caminho contém informações relevantes que você deseja capturar em seus dados (por exemplo, data e hora).
  • O esquema de dados muda com freqüência.
  • Você quer fácil reprodutibilidade de suas 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 sua sessão 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 Azure Machine Learning AutoML.

Gorjeta

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

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

Guia de início rápido das tabelas do Azure Machine Learning

Neste início rápido, você cria uma Tabela (mltable) dos Dados de Táxi Verde de NYC dos Conjuntos de Dados Abertos do Azure. Os dados têm um formato parquet e abrangem os anos de 2008-2021. Em uma conta de armazenamento de blob acessível publicamente, os arquivos de dados têm esta 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 carregar em um quadro de dados Pandas:

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

O código Pandas lida com isso. No entanto, alcançar a reprodutibilidade tornar-se-ia difícil porque é necessário:

  • Compartilhar código, o que significa que, se o esquema for alterado (por exemplo, um nome de coluna pode mudar), todos os usuários deverão atualizar seu código
  • Escreva um pipeline ETL, que tem sobrecarga pesada

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

Clone o bloco de anotações de início rápido ou crie um novo bloco de anotações/script

Se você usar uma instância de computação do Azure Machine Learning, crie um novo bloco de anotações. Se você usar um IDE, deverá criar um novo script Python.

Além disso, o bloco de anotações 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 Bloco de Anotações:

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

Instalar o SDK do mltable Python

Para carregar os Dados de Táxi Verde de Nova York em uma Tabela de Aprendizado de Máquina do Azure, você deve ter o SDK do mltable Python instalado pandas em seu ambiente Python, com este comando:

pip install -U mltable azureml-dataprep[pandas]

Criar um arquivo MLTable

Use o SDK do mltable Python para criar um arquivo MLTable, para documentar o esquema de carregamento de dados. Para isso, copie e cole o seguinte código em seu Notebook/Script e, em seguida, 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 Pandas em um momento posterior, sem a necessidade de redefinir o código a cada vez.

Você pode salvar o arquivo yaml MLTable em um recurso de armazenamento em nuvem ou salvá-lo em recursos de 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 colocalizado == True, então copiaremos os dados para a mesma pasta com o arquivo yaml MLTable se eles não estiverem atualmente colocalizados, e usaremos caminhos relativos no yaml MLTable.
  • Se colocalizado == False, não moveremos os dados, usaremos caminhos absolutos para dados na nuvem e usaremos caminhos relativos para dados locais.
  • Não suportamos esta combinação de parâmetros: os dados são armazenados em um recurso local, colocalizado == False, path tem como alvo um diretório de nuvem. Carregue seus dados locais para a nuvem e use os caminhos de dados na nuvem para MLTable.

Reproduzir etapas de carregamento de dados

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

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

Você pode ter seu arquivo MLTable atualmente salvo no disco, o que dificulta o compartilhamento com os membros da equipe. Quando você cria um ativo de dados no Azure Machine Learning, seu MLTable é carregado no armazenamento em nuvem e "marcado". Os membros da sua equipe podem acessar o MLTable com um nome amigável. Além disso, o ativo de dados é versionado.

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

Nota

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

Leia o ativo de dados em uma sessão interativa

Agora que você tem seu MLTable armazenado na nuvem, você e os membros da equipe podem acessá-lo com um nome amigável em uma sessão interativa (por exemplo, um bloco de anotações):

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 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 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 diretamente o arquivo MLTable, sugerimos que você use o SDK do mltable Python para criar seus arquivos MLTable - conforme mostrado no Guia de início rápido das Tabelas de Aprendizado de Máquina do Azure - em vez de um editor de texto. Nesta seção, descrevemos os recursos no SDK do mltable Python.

Tipos de ficheiro suportados

Você pode criar um MLTable com uma variedade de diferentes tipos de arquivos:

File Type MLTable Python SDK
Texto delimitado
(por exemplo, ficheiros 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 streaming)		 from_paths(paths=[path])

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

Definição de caminhos

Para texto delimitado, parquet, linhas JSON e caminhos, defina uma lista de dicionários Python que define o caminho ou caminhos a partir dos quais ler:

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)

O MLTable suporta estes tipos de caminho:

Location Exemplos
Um caminho no computador local ./home/username/data/my_data
Um caminho em um servidor http(s) público(s) 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 de longo prazo do Azure Machine Learning azureml://subscriptions/<subid>/resourcegroups/<rgname>/workspaces/<wsname>/datastores/<name>/paths/<path>

Nota

mltable lida com a passagem de credenciais do usuário para caminhos no Armazenamento do Azure e nos armazenamentos de dados do Aprendizado de Máquina do Azure. Se você não tiver permissão para os dados no armazenamento subjacente, não poderá acessar os dados.

Uma nota sobre a definição de caminhos para as Tabelas Delta Lake

Em comparação com os outros tipos de arquivo, definir caminhos para ler tabelas Delta Lake é diferente. Para tabelas Delta Lake, o caminho aponta para uma única pasta (normalmente no ADLS gen2) que contém a pasta "_delta_log" e arquivos de dados. A viagem no tempo é suportada. O código a seguir mostra como definir um caminho para uma tabela 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 obter a versão mais recente dos dados do Delta Lake, você pode passar o carimbo de data/hora atual para timestamp_as_ofo .

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: mltable não suporta extração de chave de partição ao ler dados do Delta Lake. A mltable transformação extract_columns_from_partition_format não funcionará quando você estiver lendo os dados do Delta Lake via mltable.

Importante

mltable lida com a passagem de credenciais do usuário para caminhos no Armazenamento do Azure e nos armazenamentos de dados do Aprendizado de Máquina do Azure. Se você não tiver permissão para os dados no armazenamento subjacente, não poderá acessar os dados.

Ficheiros, pastas e globs

As Tabelas do Azure Machine Learning suportam a leitura de:

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

Transformações de carregamento de dados suportadas

Encontre detalhes completos e atualizados das transformações de carregamento de dados suportadas na documentação de referência do MLTable.

Exemplos

Exemplos nos exemplos do Azure Machine Learning, o repositório GitHub tornou-se a base para os trechos de código neste artigo. Use este comando para clonar o repositório para seu ambiente de desenvolvimento:

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

Gorjeta

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

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

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

Ficheiros 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. Quando você salva suas etapas de carregamento de dados em um arquivo MLTable, você pode reproduzir seu quadro de dados Pandas em um momento posterior, sem a 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 serializados, você pode reproduzi-los a qualquer momento com o load() método. Dessa forma, você não precisa redefinir suas etapas de carregamento de dados no código e pode compartilhar o arquivo mais facilmente.

import mltable

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

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

Você pode ter seu arquivo MLTable atualmente salvo no disco, o que dificulta o compartilhamento com os membros da equipe. Quando você cria um ativo de dados no Azure Machine Learning, seu MLTable é carregado no armazenamento em nuvem e "marcado". Os membros da sua equipe podem acessar o MLTable com um nome amigável. Além disso, o ativo de dados é versionado.

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 você tem seu MLTable armazenado na nuvem, você e os membros da equipe podem acessá-lo com um nome amigável em uma sessão interativa (por exemplo, um bloco de anotações):

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.

Ficheiros Parquet

O Guia de início rápido das Tabelas de Aprendizado de Máquina do Azure explica como ler arquivos de parquet.

Caminhos: Criar uma tabela de arquivos de imagem

Você pode criar uma tabela contendo os caminhos no armazenamento em nuvem. Este exemplo tem várias imagens de cães e gatos localizadas no armazenamento em nuvem, na seguinte estrutura de pastas:

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

O mltable pode construir 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. Este código cria o 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")

Este código mostra como abrir o local de armazenamento no quadro de dados 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

Você pode ter seu mltable arquivo atualmente salvo no disco, o que dificulta o compartilhamento com os membros da equipe. Quando você cria um ativo de dados no Azure Machine Learning, o mltable é carregado no armazenamento em nuvem e "marcado". Os membros da sua equipe podem acessar o mltable com um nome amigável. Além disso, o ativo de dados é versionado.

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 o mltable está armazenado na nuvem, você e os membros da sua equipe podem acessá-lo com um nome amigável em uma sessão interativa (por exemplo, um bloco de anotações):

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óximos passos