Trabalhar com tabelas no Azure Machine Learning

APLICA-SE A:Extensão ml da CLI do Azure v2 (atual)SDK de 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 plano que define como carregar arquivos de dados na memória como um quadro de dados Pandas ou Spark. Neste artigo você aprende:

Pré-requisitos

• Uma subscrição do Azure. Se ainda não tiver uma subscrição do Azure, crie uma conta gratuita antes de começar. Experimente a versão gratuita ou paga do Azure Machine Learning

• O SDK do Azure Machine Learning para Python

• Uma área de trabalho do Azure Machine Learning

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

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 aplicar 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 baseia-se em Rust para garantir elevada 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.

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

Neste guia de início rápido, vai criar uma tabela (mltable) dos Dados dos Táxis Verdes de NYC a partir do Azure Open Datasets. Os dados têm formato Parquet e abrangem o período de 2008 a 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 estes dados, precisa de os carregar para um data frame do Pandas:

• Apenas os ficheiros Parquet dos anos 2015-19
• Uma amostra aleatória dos dados
• Apenas linhas com uma distância do percurso superior a 0
• Colunas relevantes para Machine Learning
• Novas colunas - ano e mês - com base na informação do 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 uma canalização ETL com uma sobrecarga elevada.

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 notebook de arranque rápido ou crie um novo notebook/script

Se usar uma instância de computação do Azure Machine Learning, crie um caderno. 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 dos táxis verdes de Nova Iorque para uma tabela do Azure Machine Learning, tem de ter o SDK de Python mltable e pandas instalados no seu ambiente Python, com o seguinte 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)

# take 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/nyc_taxi", 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("./nyc_taxi")

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

Podes guardar o teu ficheiro MLTable no disco, o que pode dificultar a partilha com os membros da equipa. Quando crias um asset de dados no Azure Machine Learning, carregas o teu MLTable para armazenamento na cloud e "marcas" nos favoritos. Os membros da sua equipa podem aceder ao MLTable usando 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

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)

Ler o recurso de dados numa 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:
      - mltable
      - azureml-dataprep[pandas]

Você enviaria o trabalho usando:

# 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-ubuntu22.04:latest
  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-ubuntu22.04:latest",
        conda_file="./job-env/conda_dependencies.yml",
    ),
    code="./src",
)

ml_client.jobs.create_or_update(job)

Criação de ficheiros 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:

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:

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 em Delta Lake, pode introduzir o carimbo de data/hora atual em timestamp_as_of.

import mltable
import time

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

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

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

Exemplos adicionais

Os exemplos no repositório do GitHub de exemplos do Azure Machine Learning tornaram-se a base para os excertos 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

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

Os exemplos seguintes descrevem como trabalhar com ficheiros de texto delimitados e ficheiros Parquet, e como criar um recurso de dados.

Usar arquivos delimitados

Esses exemplos usam o popular conjunto de dados do Titanic (12 variáveis, 891 linhas) usado para modelar previsões de sobrevivência. 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
# Using a public dataset for easier access
paths = [{"file": "https://raw.githubusercontent.com/datasciencedojo/datasets/master/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 - this dataset is small so it's safe to load
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/")

Para compartilhar esse MLTable com os membros da equipe, você pode criar um ativo de dados no Azure Machine Learning. Consulte Criar um recurso de dados de imagem de um animal de estimação para mais detalhes.

Usar arquivos de 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": "wasb://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 recurso de dados de imagens de animais de estimação

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

• Aceder a dados numa tarefa
• Criar e gerenciar ativos de dados
• Importar recursos de dados (pré-visualização)
• Administração de dados