Acessar dados em um trabalho

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

Neste artigo, você aprende:

Pré-requisitos

• Uma assinatura do Azure. Caso não tenha uma assinatura 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 v2.

• Um Workspace do Azure Machine Learning

Início Rápido

Antes de explorar as opções detalhadas disponíveis para você ao acessar dados, primeiro descrevemos os snippets de código relevantes para acesso a dados.

Ler dados do armazenamento do Azure em um trabalho do Azure Machine Learning

Neste exemplo, você envia um trabalho do Azure Machine Learning que acessa dados de uma conta de armazenamento de blob pública. No entanto, você pode adaptar o snippet para acessar seus próprios dados em uma conta privada do Armazenamento do Azure. Atualize o caminho conforme descrito aqui. O Azure Machine Learning lida perfeitamente com a autenticação no armazenamento em nuvem usando a passagem do Microsoft Entra. Ao enviar um trabalho, você pode escolher:

• Identidade do usuário: passe sua identidade do Microsoft Entra para acessar os dados
• Identidade gerenciada: use a identidade gerenciada do destino de computação para acessar dados
• Nenhum: não especifique uma identidade para acessar os dados. Use Nenhum ao usar armazenamentos de dados baseados em credenciais (chave/token SAS) ou ao acessar dados públicos

from azure.ai.ml import command, Input, MLClient, UserIdentityConfiguration, ManagedIdentityConfiguration
from azure.ai.ml.entities import Data
from azure.ai.ml.constants import AssetTypes, InputOutputModes
from azure.identity import DefaultAzureCredential

# Set your subscription, resource group and workspace name:
subscription_id = "<SUBSCRIPTION_ID>"
resource_group = "<RESOURCE_GROUP>"
workspace = "<AML_WORKSPACE_NAME>"

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

# ==============================================================
# Set the URI path for the data.
# Supported `path` formats for input include:
# local: `./<path>
# Blob: wasbs://<container_name>@<account_name>.blob.core.windows.net/<path>
# ADLS: abfss://<file_system>@<account_name>.dfs.core.windows.net/<path>
# Datastore: azureml://datastores/<data_store_name>/paths/<path>
# Data Asset: azureml:<my_data>:<version>
# Supported `path` format for output is:
# Datastore: azureml://datastores/<data_store_name>/paths/<path>
# We set the input path to a file on a public blob container
# ==============================================================
path = "wasbs://data@azuremlexampledata.blob.core.windows.net/titanic.csv"


# ==============================================================
# What type of data does the path point to? Options include:
# data_type = AssetTypes.URI_FILE # a specific file
# data_type = AssetTypes.URI_FOLDER # a folder
# data_type = AssetTypes.MLTABLE # an mltable
# The path we set above is a specific file
# ==============================================================
data_type = AssetTypes.URI_FILE

# ==============================================================
# Set the mode. The popular modes include:
# mode = InputOutputModes.RO_MOUNT # Read-only mount on the compute target
# mode = InputOutputModes.DOWNLOAD # Download the data to the compute target
# ==============================================================
mode = InputOutputModes.RO_MOUNT

# ==============================================================
# You can set the identity you want to use in a job to access the data. Options include:
# identity = UserIdentityConfiguration() # Use the user's identity
# identity = ManagedIdentityConfiguration() # Use the compute target managed identity
# ==============================================================
# This example accesses public data, so we don't need an identity.
# You also set identity to None if you use a credential-based datastore
identity = None

# Set the input for the job:
inputs = {
    "input_data": Input(type=data_type, path=path, mode=mode)
}

# This command job uses the head Linux command to print the first 10 lines of the file
job = command(
    command="head ${{inputs.input_data}}",
    inputs=inputs,
    environment="azureml://registries/azureml/environments/sklearn-1.1/versions/4",
    compute="cpu-cluster",
    identity=identity,
)

# Submit the command
ml_client.jobs.create_or_update(job)

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json

# ==============================================================
# Set the URI path for the data.
# Supported `path` formats for input include:
# local: `./<path>
# Blob: wasbs://<container_name>@<account_name>.blob.core.windows.net/<path>
# ADLS: abfss://<file_system>@<account_name>.dfs.core.windows.net/<path>
# Datastore: azureml://datastores/<data_store_name>/paths/<path>
# Data Asset: azureml:<my_data>:<version>
# Supported `path` format for output is:
# Datastore: azureml://datastores/<data_store_name>/paths/<path>
# ==============================================================

# ==============================================================
# What type of data does the path point to? Options include:
# type: uri_file # a specific file
# type: uri_folder # a folder
# type: mltable # an mltable
# ==============================================================

# ==============================================================
# Set the mode. The popular modes include:
# mode: ro_mount # Read-only mount on the compute target
# mode: download # Download the data to the compute target
# ==============================================================

# ==============================================================
# You can set the identity you want to use in a job to access the data. Options include:
# identity:
#   type: user_identity
# identity:
#   type: managed_identity
# ==============================================================
# This example accesses public data, so we don't need an identity.
# You don't need to set an identity to if you use a credential-based datastore

# This command job prints the first 10 lines of the file

type: command
command: head ${{inputs.input_data}}
compute: azureml:cpu-cluster
environment: azureml://registries/azureml/environments/sklearn-1.1/versions/4
inputs:
  input_data:
    mode: ro_mount
    path: azureml:wasbs://data@azuremlexampledata.blob.core.windows.net/titanic.csv
    type: uri_file

az ml job create -f <file-name>.yml

Grave dados de seu trabalho do Azure Machine Learning no Armazenamento do Azure

Nesse exemplo, envie um trabalho do Azure Machine Learning que grava dados no armazenamento de dados do Azure Machine Learning padrão. Opcionalmente, você pode definir o valor name de seu ativo de dados para criar um ativo de dados na saída.

from azure.ai.ml import command, Input, Output, MLClient
from azure.ai.ml.constants import AssetTypes, InputOutputModes
from azure.identity import DefaultAzureCredential

# Set your subscription, resource group and workspace name:
subscription_id = "<SUBSCRIPTION_ID>"
resource_group = "<RESOURCE_GROUP>"
workspace = "<AML_WORKSPACE_NAME>"

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

# ==============================================================
# Set the URI path for the data.
# Supported `path` formats for input include:
# local: `./<path>
# Blob: wasbs://<container_name>@<account_name>.blob.core.windows.net/<path>
# ADLS: abfss://<file_system>@<account_name>.dfs.core.windows.net/<path>
# Datastore: azureml://datastores/<data_store_name>/paths/<path>
# Data Asset: azureml:<my_data>:<version>
# Supported `path` format for output is:
# Datastore: azureml://datastores/<data_store_name>/paths/<path>
# As an example, we set the input path to a file on a public blob container
# As an example, we set the output path to a folder in the default datastore
# ==============================================================
input_path = "wasbs://data@azuremlexampledata.blob.core.windows.net/titanic.csv"
output_path = "azureml://datastores/workspaceblobstore/paths/quickstart-output/titanic.csv"

# ==============================================================
# What type of data are you pointing to?
# AssetTypes.URI_FILE (a specific file)
# AssetTypes.URI_FOLDER (a folder)
# AssetTypes.MLTABLE (a table)
# The path we set above is a specific file
# ==============================================================
data_type = AssetTypes.URI_FILE

# ==============================================================
# Set the input mode. The most commonly-used modes:
# InputOutputModes.RO_MOUNT
# InputOutputModes.DOWNLOAD
# Set the mode to Read Only (RO) to mount the data
# ==============================================================
input_mode = InputOutputModes.RO_MOUNT

# ==============================================================
# Set the output mode. The most commonly-used modes:
# InputOutputModes.RW_MOUNT
# InputOutputModes.UPLOAD
# Set the mode to Read Write (RW) to mount the data
# ==============================================================
output_mode = InputOutputModes.RW_MOUNT

# Set the input and output for the job:
inputs = {
    "input_data": Input(type=data_type, path=input_path, mode=input_mode)
}

outputs = {
    "output_data": Output(type=data_type, 
                          path=output_path, 
                          mode=output_mode,
                          # optional: if you want to create a data asset from the output, 
                          # then uncomment `name` (`name` can be set without setting `version`, and in this way, we will set `version` automatically for you)
                          # name = "<name_of_data_asset>", # use `name` and `version` to create a data asset from the output
                          # version = "<version>",
                  )
}

# This command job copies the data to your default Datastore
job = command(
    command="cp ${{inputs.input_data}} ${{outputs.output_data}}",
    inputs=inputs,
    outputs=outputs,
    environment="azureml://registries/azureml/environments/sklearn-1.1/versions/4",
    compute="cpu-cluster",
)

# Submit the command
ml_client.jobs.create_or_update(job)

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json

# path: Set the URI path for the data. Supported paths include
# local: `./<path>
# Blob: wasbs://<container_name>@<account_name>.blob.core.windows.net/<path>
# ADLS: abfss://<file_system>@<account_name>.dfs.core.windows.net/<path>
# Datastore: azureml://datastores/<data_store_name>/paths/<path>
# Data Asset: azureml:<my_data>:<version>

# type: What type of data are you pointing to?
# uri_file (a specific file)
# uri_folder (a folder)
# mltable (a table)

# mode: Set INPUT mode:
# ro_mount (read-only mount)
# download (download from storage to node)
# mode: Set the OUTPUT mode
# rw_mount (read-write mount)
# upload (upload data from node to storage)

type: command
command: cp ${{inputs.input_data}} ${{outputs.output_data}}
compute: azureml:cpu-cluster
environment: azureml://registries/azureml/environments/sklearn-1.1/versions/4
inputs:
  input_data:
    mode: ro_mount
    path: azureml:wasbs://data@azuremlexampledata.blob.core.windows.net/titanic.csv
    type: uri_file
outputs:
  output_data:
    mode: rw_mount
    path: azureml://datastores/workspaceblobstore/paths/quickstart-output/titanic.csv
    type: uri_file
    # optional: if you want to create a data asset from the output, 
    # then uncomment `name` (`name` can be set without setting `version`, and in this way, we will set `version` automatically for you)
    # name: <name_of_data_asset> # use `name` and `version` to create a data asset from the output
    # version: <version>

az ml job create --file <file-name>.yml

O runtime de dados do Azure Machine Learning

Quando você envia um trabalho, o runtime de dados do Azure Machine Learning controla a carga de dados, do local de armazenamento até o destino de computação. O runtime de dados do Azure Machine Learning está otimizado para velocidade e eficiência das tarefas de aprendizado de máquina. Os principais benefícios incluem:

• As cargas de dados são gravadas na linguagem Rust, uma linguagem conhecida pela alta velocidade e alta eficiência de memória. Para downloads simultâneos de dados, o Rust evita problemas de Bloqueio do Interpretador Global (GIL) do Python
• Peso leve; o Rust não possui nenhuma dependência de outras tecnologias, por exemplo, JVM. Consequentemente, o runtime é instalado rapidamente e não drena recursos extras (CPU, memória) no destino de computação
• Carregamento de dados de vários processos (paralelos)
• Faz pré-busca de dados como uma tarefa em segundo plano na(s) CPU(s), para permitir uma melhor utilização da(s) GPU(s) ao fazer aprendizado profundo
• Tratamento contínuo de autenticação no armazenamento em nuvem
• Fornece opções para montar dados (fluxo) ou baixar todos os dados. Para obter mais informações, visite as seções Montagem (streaming) e Download.
• Integração perfeita com fsspec: uma interface pitônica unificada para sistemas de arquivos locais, remotos e incorporados e armazenamento de bytes.

Caminhos

Ao fornecer uma entrada/saída de dados para um trabalho, você deve especificar um parâmetro path que aponte para o local dos dados. Esta tabela mostra os diferentes locais de dados com suporte ao Azure Machine Learning e também mostra path exemplos de parâmetros:

Modos

Ao executar um trabalho com entradas/saídas de dados, você pode selecionar entre essas opções de modo:

• ro_mount: Montar o local de armazenamento como somente leitura no destino de computação do disco local (SSD).

• rw_mount: Montar o local de armazenamento como leitura e gravação no destino de computação do disco local (SSD).

• download: Baixe os dados do local de armazenamento para o destino de computação do disco local (SSD).

• upload: faça upload dos dados do destino de computação para o local de armazenamento.

• eval_mount/eval_download:Esses modos são exclusivos do MLTable. Em alguns cenários, um MLTable pode produzir arquivos que podem estar localizados em uma conta de armazenamento diferente da conta de armazenamento que hospeda o arquivo MLTable. Ou, um MLTable pode fazer subconjunto ou embaralhar os dados localizados no recurso de armazenamento. Essa exibição do subconjunto/embaralhamento só se torna visível se o runtime de dados do Azure Machine Learning realmente avaliar o arquivo MLTable. Por exemplo, este diagrama mostra como um MLTable usado com eval_mount ou eval_download pode obter imagens de dois contêineres de armazenamento diferentes e um arquivo de anotações localizado em uma conta de armazenamento diferente e, em seguida, montar/baixar para o sistema de arquivos do destino de computação remota.

  

  A pasta camera1, a pasta camera2 e o arquivo annotations.csv ficam acessíveis no sistema de arquivos do destino de computação na estrutura de pastas:

  /INPUT_DATA
  ├── account-a
  │   ├── container1
  │   │   └── camera1
  │   │       ├── image1.jpg
  │   │       └── image2.jpg
  │   └── container2
  │       └── camera2
  │           ├── image1.jpg
  │           └── image2.jpg
  └── account-b
      └── container1
          └── annotations.csv
  

• direct: convém ler dados diretamente de um URI através de outras APIs, em vez de passar pelo runtime de dados do Azure Machine Learning. Por exemplo, talvez você queira acessar dados em um bucket s3 (com uma URL https de estilo hospedada virtualmente ou de estilo de caminho) usando o cliente boto s3. Você pode obter o URI da entrada como uma cadeia de caracteres com o modo direct. Você vê o uso do modo direto nos Trabalhos do Spark, porque os métodos spark.read_*() sabem como processar os URIs. Para trabalhos que não são do Spark, é sua responsabilidade gerenciar as credenciais de acesso. Por exemplo, você deve utilizar explicitamente o MSI de computação ou, de outra forma, o acesso do agente.

Essa tabela mostra os possíveis modos para diferentes combinações de tipo/modo/entrada/saída:

Baixar

No modo de download, todos os dados de entrada são copiados para o disco local (SSD) do destino de computação. O runtime de dados do Azure Machine Learning inicia o script de treinamento do usuário, uma vez que todos os dados são copiados. Quando o script do usuário é iniciado, ele lê os dados do disco local, como qualquer outro arquivo. Quando o trabalho é concluído, os dados são removidos do disco do destino de computação.

Quando usar o download

• Os dados são pequenos o suficiente para caber no disco do destino de computação sem interferência com outros treinamentos
• O treinamento usa a maior parte ou todo o conjunto de dados
• O treinamento lê arquivos de um conjunto de dados mais de uma vez
• O treinamento deve saltar para posições aleatórias de um arquivo grande
• Não há problema em esperar até que todos os dados sejam baixados antes de iniciar o treinamento

Configurações de download disponíveis

Você pode ajustar as configurações de download com essas variáveis de ambiente em seu trabalho:

Em seu trabalho, você pode alterar os padrões acima definindo as variáveis de ambiente, por exemplo:

from azure.ai.ml import command

env_var = {
"RSLEX_DOWNLOADER_THREADS": 64,
"AZUREML_DATASET_HTTP_RETRY_COUNT": 10
}

job = command(
        environment_variables=env_var
)

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json

environment_variables:
    RSLEX_DOWNLOADER_THREADS: 64
    AZUREML_DATASET_HTTP_RETRY_COUNT: 10

Download das métricas de desempenho

O tamanho da VM do destino de computação afeta o tempo de download dos dados. Especificamente:

• O número de núcleos. Quanto mais núcleos disponíveis, maior a simultaneidade e, portanto, maior a velocidade do download.
• A largura de banda de rede esperada. Cada VM no Azure tem uma taxa de transferência máxima da NIC (placa do adaptador de rede).

Esta tabela mostra o desempenho de download que o runtime de dados do Azure Machine Learning pode suportar para um arquivo de 100 GB em uma VM Standard_D15_v2 (20 núcleos, taxa de transferência de rede de 25 Gbit/s):

Podemos ver que um arquivo maior, dividido em arquivos menores, pode melhorar o desempenho do download devido ao paralelismo. Recomendamos evitar arquivos que se tornem muito pequenos (menos de 4 MB) porque o tempo necessário para o envio de solicitações de armazenamento aumenta em relação ao tempo gasto no download da carga útil. Para obter mais informações, leia Problema com muitos arquivos pequenos.

Montagem (streaming)

No modo de montagem, o recurso de dados do Azure Machine Learning usa o recurso FUSE (sistema de arquivos no espaço do usuário) do Linux para criar um sistema de arquivos emulado. Em vez de fazer o download de todos os dados para o disco local (SSD) do destino de computação, o runtime pode reagir às ações do script do usuário em tempo real. Por exemplo, "abrir arquivo","ler parte de 2 KB da posição X", "listar conteúdo do diretório".

Quando usar a montagem

• Os dados são grandes e não cabem no disco local de destino da computação.
• Cada nó de computação individual em um cluster não precisa ler todo o conjunto de dados (arquivo aleatório ou linhas na seleção do arquivo csv etc.).
• Os atrasos na espera pelo download de todos os dados antes do início do treinamento podem se tornar um problema (tempo de GPU ocioso).

Configurações de montagem disponíveis

Você pode ajustar as configurações de montagem com essas variáveis de ambiente em seu trabalho:

Em seu trabalho, você pode alterar os padrões acima definindo as variáveis de ambiente, por exemplo:

from azure.ai.ml import command

env_var = {
"DATASET_MOUNT_BLOCK_FILE_CACHE_ENABLED": True
}

job = command(
        environment_variables=env_var
)

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json

environment_variables:
    DATASET_MOUNT_BLOCK_FILE_CACHE_ENABLED: true

Modo de abertura baseado em blocos

No modo de abertura baseado em blocos, cada arquivo é dividido em blocos de tamanho predefinido (exceto o último bloco). Uma solicitação de leitura de uma posição especificada solicita um bloco correspondente do armazenamento e retorna os dados solicitados imediatamente. Uma leitura também dispara a pré-busca em segundo plano de N blocos seguintes, usando vários threads (otimizados para leitura sequencial). Os blocos baixados são armazenados em cache de duas camadas (RAM e disco local).

Quando usar o modo de abertura baseado em blocos

Recomendado para a maioria dos cenários, exceto ao precisar de leituras rápidas de locais de arquivos aleatórios. Nesses casos, use o modo de abertura do cache de arquivo inteiro.

Modo de abertura do cache de arquivo inteiro

Quando um arquivo em uma pasta de montagem é aberto (por exemplo, f = open(path, args)) no modo de arquivo inteiro, a chamada é bloqueada até que o arquivo inteiro seja baixado para uma pasta de cache de destino de computação no disco. Todas as chamadas de leitura subsequentes redirecionam para o arquivo em cache, portanto, não é necessária nenhuma interação com o armazenamento. Se o cache não tiver espaço disponível suficiente para acomodar o arquivo atual, a montagem tentará remover o arquivo usado menos recentemente do cache. Nos casos em que o arquivo não cabe no disco (em relação às configurações de cache), o runtime dos dados volta ao modo de streaming.

Quando usar isso

Quando leituras aleatórias são necessárias para arquivos relativamente grandes que excedem 128 MB.

Uso

Defina a variável de ambiente DATASET_MOUNT_BLOCK_BASED_CACHE_ENABLED como false em seu trabalho:

from azure.ai.ml import command

env_var = {
"DATASET_MOUNT_BLOCK_BASED_CACHE_ENABLED": False
}

job = command(
        environment_variables=env_var
)

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json

environment_variables:
    DATASET_MOUNT_BLOCK_BASED_CACHE_ENABLED: false

Montagem: listar arquivos

Ao trabalhar com milhões de arquivos, evite uma listagem recursiva, por exemplo, ls -R /mnt/dataset/folder/. Uma listagem recursiva dispara várias chamadas para listar o conteúdo do diretório pai. Em seguida, é necessária uma chamada recursiva separada para cada diretório interno, em todos os níveis filhos. Normalmente, o Armazenamento do Azure permite que apenas 5.000 elementos sejam retornados por solicitação de lista única. Como resultado, uma listagem recursiva de 1 milhão de pastas contendo 10 arquivos cada uma requer 1,000,000 / 5000 + 1,000,000 = 1,000,200 solicitações ao armazenamento. Em comparação, 1.000 pastas com 10.000 arquivos precisariam apenas de 1001 solicitações para armazenamento para uma listagem recursiva.

A montagem do Azure Machine Learning lida com a listagem de maneira lenta. Portanto, para listar muitos arquivos pequenos, é melhor usar uma chamada iterativa da biblioteca do cliente (por exemplo, os.scandir() em Python) em vez de uma chamada da biblioteca do cliente que retorna a lista completa (por exemplo, os.listdir() em Python). Uma chamada iterativa à biblioteca cliente retorna um gerador, o que significa que não é necessário esperar até que a lista inteira seja carregada. Assim, ele pode prosseguir mais rapidamente.

Essa tabela compara o tempo necessário para que o Python e as funções os.scandir() e os.listdir() listem uma pasta quem contém cerca de 4 milhões de arquivos em uma estrutura plana:

Configurações de montagem ideais para cenários comuns

Para determinados cenários comuns, mostramos as configurações de montagem ideais que você precisa definir em seu trabalho do Azure Machine Learning.

Leitura de arquivo grande sequencialmente uma vez (processamento de linhas em arquivo csv)

Inclua essas configurações de montagem na seção environment_variables do trabalho do Azure Machine Learning:

from azure.ai.ml import command

env_var = {
  "DATASET_MOUNT_BLOCK_BASED_CACHE_ENABLED": True, # Enable block-based caching
  "DATASET_MOUNT_BLOCK_FILE_CACHE_ENABLED": False, # Disable caching on disk
  "DATASET_MOUNT_MEMORY_CACHE_SIZE": 0, # Disabling in-memory caching

  # Increase the number of blocks used for prefetch. This leads to use of more RAM (2 MB * #value set).
  # Can adjust up and down for fine-tuning, depending on the actual data processing pattern.
  # An optimal setting based on our test ~= the number of prefetching threads (#CPU_CORES * 4 by default)
  "DATASET_MOUNT_READ_BUFFER_BLOCK_COUNT": 80,
}

job = command(
        environment_variables=env_var
)

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json

environment_variables:
  DATASET_MOUNT_BLOCK_BASED_CACHE_ENABLED: true # Enable block-based caching
  DATASET_MOUNT_BLOCK_FILE_CACHE_ENABLED: false # Disable caching on disk
  DATASET_MOUNT_MEMORY_CACHE_SIZE: 0 # Disabling in-memory caching

  # Increase the number of blocks used for prefetch. This leads to use of more RAM (2 MB * #value set).
  # Can adjust up and down for fine-tuning, depending on the actual data processing pattern.
  # An optimal setting based on our test ~= the number of prefetching threads (#CPU_CORES * 4 by default)
  DATASET_MOUNT_READ_BUFFER_BLOCK_COUNT: 80

Leitura de um arquivo grande de uma só vez em vários threads (processamento de arquivo csv particionado em vários threads)

Inclua essas configurações de montagem na seção environment_variables do trabalho do Azure Machine Learning:

from azure.ai.ml import command

env_var = {
  "DATASET_MOUNT_BLOCK_BASED_CACHE_ENABLED": True, # Enable block-based caching
  "DATASET_MOUNT_BLOCK_FILE_CACHE_ENABLED": False, # Disable caching on disk
  "DATASET_MOUNT_MEMORY_CACHE_SIZE": 0, # Disabling in-memory caching
}

job = command(
        environment_variables=env_var
)

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json

environment_variables:
  DATASET_MOUNT_BLOCK_BASED_CACHE_ENABLED: true # Enable block-based caching
  DATASET_MOUNT_BLOCK_FILE_CACHE_ENABLED: false # Disable caching on disk
  DATASET_MOUNT_MEMORY_CACHE_SIZE: 0 # Disabling in-memory caching

Leitura de milhões de arquivos pequenos (imagens) de vários threads de uma só vez (treinamento de época única em imagens)

Inclua essas configurações de montagem na seção environment_variables do trabalho do Azure Machine Learning:

from azure.ai.ml import command

env_var = {
  "DATASET_MOUNT_BLOCK_BASED_CACHE_ENABLED": True, # Enable block-based caching
  "DATASET_MOUNT_BLOCK_FILE_CACHE_ENABLED": False, # Disable caching on disk
  "DATASET_MOUNT_MEMORY_CACHE_SIZE": 0, # Disabling in-memory caching
}

job = command(
        environment_variables=env_var
)

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json

environment_variables:
  DATASET_MOUNT_BLOCK_BASED_CACHE_ENABLED: true # Enable block-based caching
  DATASET_MOUNT_BLOCK_FILE_CACHE_ENABLED: false # Disable caching on disk
  DATASET_MOUNT_MEMORY_CACHE_SIZE: 0 # Disabling in-memory caching

Leitura de milhões de arquivos pequenos (imagens) de vários threads várias vezes (treinamento de várias épocas em imagens)

Inclua essas configurações de montagem na seção environment_variables do trabalho do Azure Machine Learning:

from azure.ai.ml import command

env_var = {
  "DATASET_MOUNT_BLOCK_BASED_CACHE_ENABLED": True, # Enable block-based caching
}

job = command(
        environment_variables=env_var
)

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json

environment_variables:
  DATASET_MOUNT_BLOCK_BASED_CACHE_ENABLED: true # Enable block-based caching

Leitura de arquivos grandes com buscas aleatórias (como servir banco de dados de arquivos a partir de uma pasta montada)

Inclua essas configurações de montagem na seção environment_variables do trabalho do Azure Machine Learning:

from azure.ai.ml import command

env_var = {
  "DATASET_MOUNT_BLOCK_BASED_CACHE_ENABLED": False, # Disable block-based caching
}

job = command(
        environment_variables=env_var
)

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json

environment_variables:
  DATASET_MOUNT_BLOCK_BASED_CACHE_ENABLED: false # Disable block-based caching

Diagnosticar e resolver gargalos no carregamento de dados

Quando um trabalho do Azure Machine Learning é executado com dados, o mode de uma entrada determina como os bytes são lidos no armazenamento e armazenados em cache no disco SSD local do destino de computação. Para o modo de download, todos os dados são armazenados em cache no disco, antes do código do usuário iniciar sua execução. Portanto, fatores como

• número de threads paralelos
• o número de arquivos
• tamanho de arquivo

têm efeito sobre as velocidades máximas de download. Para montar, o código do usuário deve começar a abrir arquivos antes que os dados comecem a ser armazenados em cache. Diferentes configurações de montagem resultam em diferentes comportamentos de leitura e cache. Vários fatores afetam a velocidade de carregamento dos dados do armazenamento:

• Localidade dos dados para computação: os locais de destino do armazenamento e da computação devem ser os mesmos. Se seu armazenamento e destino de computação estiverem localizados em regiões diferentes, o desempenho será prejudicado porque os dados precisam ser transferidos entre as regiões. Para obter mais informações sobre como garantir que seus dados sejam colocados com computação, visite Colocar dados com computação.
• O tamanho do destino de computação: Computações pequenas têm menor número de núcleos (menos paralelismo) e menor largura de banda de rede esperada em comparação com computações maiores; ambos os fatores afetam o desempenho do carregamento de dados.
  • Por exemplo, se você usar uma VM de tamanho pequeno, como Standard_D2_v2 (2 núcleos, NIC de 1500 Mbps), e tentar carregar 50.000 MB (50 GB) de dados, o melhor tempo de carregamento de dados possível seria de aproximadamente 270 segundos (supondo que você sature a NIC com uma taxa de transferência de 187,5 MB/s). Por outro lado, um Standard_D5_v2 (16 núcleos, 12.000 Mbps) carregaria os mesmos dados em aproximadamente 33 segundos (supondo que você sature a NIC com uma taxa de transferência de 1.500 MB/s).
• Camada de armazenamento: para a maioria dos cenários, incluindo LLM (modelos de linguagem grande), o armazenamento padrão oferece o melhor perfil de custo/desempenho. No entanto, se você tiver muitos arquivos pequenos, o armazenamento premium oferece um melhor perfil de custo/desempenho. Para obter mais informações, leia Opções de armazenamento do Azure.
• Carga de armazenamento: se a conta de armazenamento estiver sob alta carga, por exemplo, muitos nós de GPU em um cluster solicitando dados, você corre o risco de atingir a capacidade de saída do armazenamento. Para obter mais informações, leia Carga de armazenamento. Se você tiver muitos arquivos pequenos que precisam ser acessados em paralelo, poderá atingir os limites de solicitação de armazenamento. Leia informações atualizadas sobre os limites da capacidade de saída e das solicitações de armazenamento em Destinos de escala para contas de armazenamento padrão.
• Padrão de acesso a dados no código do usuário: ao usar o modo de montagem, os dados são buscados com base nas ações de abertura/leitura no código. Por exemplo, ao ler seções aleatórias de um arquivo grande, as configurações padrão de pré-busca de dados das montagens podem levar a downloads de blocos que não serão lidos. Talvez seja necessário ajustar algumas configurações para atingir a taxa de transferência máxima. Para obter mais informações, leia Configurações de montagem ideais para cenários comuns.

Uso de registros para diagnosticar problemas

Para acessar os logs do runtime de dados do trabalho:

1. Selecione a guia Saídas+Logs na página do trabalho.
2. Selecione a pasta system_logs, seguida da pasta data_capability.
3. Você deverá ver dois arquivos de registro:

O arquivo de log data-capability.log mostra as informações de alto nível sobre o tempo gasto nas principais tarefas de carregamento de dados. Por exemplo, ao fazer download de dados, o runtime registra os horários de início e término da atividade de download:

INFO 2023-05-18 17:14:47,790 sdk_logger.py:44 [28] - ActivityStarted, download
INFO 2023-05-18 17:14:50,295 sdk_logger.py:44 [28] - ActivityCompleted: Activity=download, HowEnded=Success, Duration=2504.39 [ms]

Se a taxa de transferência de download for uma fração da largura de banda de rede esperada para o tamanho da VM, você poderá inspecionar o arquivo de log rslex.log.<TIMESTAMP>. Esse arquivo contém todo o registro em log refinado do runtime baseado em Rust; por exemplo, paralelização:

2023-05-18T14:08:25.388670Z  INFO copy_uri:copy_uri:copy_dataset:write_streams_to_files:collect:reduce:reduce_and_combine:reduce:get_iter: rslex::prefetching: close time.busy=23.2µs time.idle=1.90µs sessionId=012ea46a-341c-4258-8aba-90bde4fdfb51 source=Dataset[Partitions: 1, Sources: 1] file_name_column=None break_on_first_error=true skip_existing_files=false parallelization_degree=4 self=Dataset[Partitions: 1, Sources: 1] parallelization_degree=4 self=Dataset[Partitions: 1, Sources: 1] parallelization_degree=4 self=Dataset[Partitions: 1, Sources: 1] parallelization_degree=4 i=0 index=0
2023-05-18T14:08:25.388731Z  INFO copy_uri:copy_uri:copy_dataset:write_streams_to_files:collect:reduce:reduce_and_combine:reduce: rslex::dataset_crossbeam: close time.busy=90.9µs time.idle=9.10µs sessionId=012ea46a-341c-4258-8aba-90bde4fdfb51 source=Dataset[Partitions: 1, Sources: 1] file_name_column=None break_on_first_error=true skip_existing_files=false parallelization_degree=4 self=Dataset[Partitions: 1, Sources: 1] parallelization_degree=4 self=Dataset[Partitions: 1, Sources: 1] parallelization_degree=4 self=Dataset[Partitions: 1, Sources: 1] parallelization_degree=4 i=0
2023-05-18T14:08:25.388762Z  INFO copy_uri:copy_uri:copy_dataset:write_streams_to_files:collect:reduce:reduce_and_combine:combine: rslex::dataset_crossbeam: close time.busy=1.22ms time.idle=9.50µs sessionId=012ea46a-341c-4258-8aba-90bde4fdfb51 source=Dataset[Partitions: 1, Sources: 1] file_name_column=None break_on_first_error=true skip_existing_files=false parallelization_degree=4 self=Dataset[Partitions: 1, Sources: 1] parallelization_degree=4 self=Dataset[Partitions: 1, Sources: 1] parallelization_degree=4 self=Dataset[Partitions: 1, Sources: 1] parallelization_degree=4

O arquivo rslex.log fornece detalhes sobre todas as cópias de arquivos, independentemente de você ter escolhido ou não os modos de montagem ou download. Ele também descreve as configurações (variáveis de ambiente) usadas. Para iniciar a depuração, verifique se você definiu as Configurações de montagem ideais para cenários comuns .

Monitoramento do armazenamento do Azure

No portal do Azure, você pode selecionar sua conta de Armazenamento e, em seguida, Métricas, para ver as métricas de armazenamento:

Em seguida, plote SuccessE2ELatency com SuccessServerLatency. Se as métricas mostrarem alta SuccessE2ELatency e baixa SuccessServerLatency, se os threads disponíveis forem limitados ou se houver poucos recursos, como CPU, memória ou largura de banda de rede, você deverá:

• Use a exibição de monitoramento no Estúdio do Azure Machine Learning para verificar a utilização da CPU e da memória do trabalho. Se você estiver com pouca CPU e memória, considere aumentar o tamanho da VM de destino de computação.
• Considere aumentar RSLEX_DOWNLOADER_THREADS se estiver fazendo download e não utilizar a CPU e a memória. Se você usar a montagem, deverá aumentar DATASET_MOUNT_READ_BUFFER_BLOCK_COUNT para fazer mais pré-busca e aumentar DATASET_MOUNT_READ_THREADS para mais threads de leitura.

Se as métricas mostrarem SuccessE2ELatency baixa e SuccessServerLatency baixa, mas o cliente tiver alta latência, você tem um atraso na solicitação de armazenamento que chega ao serviço. Você deve verificar:

• Se o número de threads usados para montagem/download (DATASET_MOUNT_READ_THREADS/RSLEX_DOWNLOADER_THREADS) está definido como muito baixo, em relação ao número de núcleos disponíveis no destino de computação. Se a configuração estiver muito baixa, aumente o número de threads.
• Se o número de tentativas de download (AZUREML_DATASET_HTTP_RETRY_COUNT) está definido como muito alto. Se for o caso, diminua o número de novas tentativas.

Monitoramento do uso do disco durante um trabalho

No Estúdio do Azure Machine Learning, você também pode monitorar a E/S do disco de destino de computação e o uso durante a execução do trabalho. Navegue até seu trabalho e selecione a guia Monitoramento. Essa guia fornece insights sobre os recursos do seu trabalho, em uma base sem interrupção de 30 dias. Por exemplo:

O runtime de dados do Azure Machine Learning não usa os últimos RESERVED_FREE_DISK_SPACE bytes do espaço em disco para manter a integridade da computação (o valor padrão é 150MB). Se o disco estiver cheio, seu código está gravando arquivos no disco sem declarar os arquivos como saída. Portanto, verifique seu código para garantir que os dados não estejam sendo gravados erroneamente no disco temporário. Se for necessário gravar arquivos no disco temporário e esse recurso estiver ficando cheio, considere:

• Aumentar o tamanho da VM para uma que tenha um disco temporário maior
• Definir um TTL nos dados armazenados em cache (DATASET_MOUNT_ATTRIBUTE_CACHE_TTL), para limpar seus dados do disco

Colocação de dados no local com computação

Se seus dados e o Workspace do Azure Machine Learning estiverem armazenados em regiões diferentes, recomendamos que você copie os dados para uma conta de armazenamento na mesma região com o utilitário azcopy. O AzCopy usa APIs de servidor para servidor, portanto, os dados são copiados diretamente nos servidores de armazenamento. Essas operações de cópia não usam a largura de banda de rede do computador. Você pode aumentar a taxa de transferência dessas operações com a variável de ambiente AZCOPY_CONCURRENCY_VALUE. Para saber mais, confira Aumentar a simultaneidade.

Carga de armazenamento

Uma única conta de armazenamento pode ser limitada quando estiver sob alta carga, quando:

• Seu trabalho usa muitos nós de GPU
• Sua conta de armazenamento tem muitos usuários/aplicativos simultâneos que acessam os dados enquanto você executa o trabalho

Esta seção mostra os cálculos para determinar se a limitação pode se tornar um problema para a carga de trabalho e como abordar reduções de limitação.

Calcular limites de largura de banda

Uma conta do Armazenamento do Azure tem um limite de saída padrão de 120 Gbit/s. As VMs do Azure têm larguras de banda de rede diferentes, que afetam o número teórico de nós de computação necessários para atingir a capacidade máxima de saída padrão do armazenamento:

Ambas as SKUs A100 e V100 têm uma largura de banda de rede máxima por nó de 24 Gbit/s. Se cada nó que lê dados de uma única conta puder ler perto do máximo teórico de 24 Gbit/s, a capacidade de saída ocorreria com cinco nós. O uso de seis ou mais nós de computação começaria a degradar a taxa de transferência de dados em todos os nós.

Dimensionamento em várias contas de armazenamento

Você pode exceder a capacidade máxima de saída do armazenamento e/ou atingir os limites de taxa de solicitação. Se esses problemas ocorrerem, sugerimos que você entre em contato primeiro com o suporte para aumentar esses limites na conta de armazenamento.

Se não for possível aumentar a capacidade máxima de saída ou o limite da taxa de solicitação, considere a possibilidade de replicar os dados em várias contas de armazenamento. Copie os dados para várias contas com o Azure Data Factory, o Gerenciador de Armazenamento do Azure ou azcopy, e monte todas as contas em seu trabalho de treinamento. Somente os dados acessados em uma montagem são baixados. Portanto, seu código de treinamento pode ler RANK a partir da variável de ambiente para escolher qual das várias montagens de entrada deve ser lida. Sua definição de trabalho passa em uma lista de contas de armazenamento:

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
code: src
command: >-
  python train.py
  --epochs ${{inputs.epochs}}
  --learning-rate ${{inputs.learning_rate}}
  --data ${{inputs.cifar_storage1}}, ${{inputs.cifar_storage2}}
inputs:
  epochs: 1
  learning_rate: 0.2
  cifar_storage1:
    type: uri_folder
    path: azureml://datastores/storage1/paths/cifar
  cifar_storage2:
    type: uri_folder
    path: azureml://datastores/storage2/paths/cifar
environment: azureml:AzureML-pytorch-1.9-ubuntu18.04-py37-cuda11-gpu@latest
compute: azureml:gpu-cluster
distribution:
  type: pytorch
  process_count_per_instance: 1
resources:
  instance_count: 2
display_name: pytorch-cifar-distributed-example
experiment_name: pytorch-cifar-distributed-example
description: Train a basic convolutional neural network (CNN) with PyTorch on the CIFAR-10 dataset, distributed via PyTorch.

Seu código Python de treinamento pode então usar RANK para obter a conta de armazenamento específica para esse nó:

import argparse
import os

parser = argparse.ArgumentParser()
parser.add_argument('--data', nargs='+')
args = parser.parse_args()

world_size = int(os.environ["WORLD_SIZE"])
rank = int(os.environ["RANK"])
local_rank = int(os.environ["LOCAL_RANK"])

data_path_for_this_rank = args.data[rank]

Problema com muitos arquivos pequenos

A leitura de arquivos do armazenamento envolve fazer solicitações para cada arquivo. A contagem de solicitações por arquivo varia de acordo com o tamanho do arquivo e as configurações do software que processa as leituras de arquivo.

Os arquivos geralmente são lidos em blocos de 1 a 4 MB. Arquivos menores que um bloco são lidos com uma única solicitação (GET file.jpg 0-4MB) e arquivos maiores que um bloco têm uma solicitação feita por bloco (GET file.jpg 0-4MB, GET file.jpg 4-8 MB). Essa tabela mostra que arquivos menores que um bloco de 4 MB resultam em mais solicitações de armazenamento em comparação com arquivos maiores:

Para arquivos pequenos, o intervalo de latência envolve principalmente o tratamento das solicitações ao armazenamento, em vez de transferências de dados. Portanto, oferecemos estas recomendações para aumentar o tamanho do arquivo:

• Para dados não estruturados (imagens, texto, vídeo etc.), arquive (zip/tar) pequenos arquivos juntos, para armazená-los como um arquivo maior que possa ser lido em várias partes. Esses arquivos maiores arquivados podem ser abertos no recurso de computação e DataPipes de Arquivo PyTorch podem extrair os arquivos menores.
• Para dados estruturados (CSV, parquet etc.), examine o processo de ETL para garantir que ele una os arquivos para aumentar o tamanho. O Spark tem métodos repartition() e coalesce() para ajudar a aumentar o tamanho dos arquivos.

Se não for possível aumentar o tamanho dos arquivos, explore as opções de Armazenamento do Azure.

Opções de Armazenamento do Azure

O Armazenamento do Azure oferece duas camadas: standard e premium:

Ler ativos de dados da v1

Esta seção explica como ler entidades de dados FileDataset e TabularDataset da v1 em um trabalho da v2.

Ler um FileDataset

from azure.ai.ml import command
from azure.ai.ml.entities import Data
from azure.ai.ml import Input
from azure.ai.ml.constants import AssetTypes, InputOutputModes
from azure.ai.ml import MLClient

ml_client = MLClient.from_config(credential=DefaultAzureCredential())

filedataset_asset = ml_client.data.get(name="<filedataset_name>", version="<version>")

my_job_inputs = {
    "input_data": Input(
            type=AssetTypes.MLTABLE,
            path=filedataset_asset.id,
            mode=InputOutputModes.EVAL_MOUNT
    )
}

job = command(
    code="./src",  # Local path where the code is stored
    command="ls ${{inputs.input_data}}",
    inputs=my_job_inputs,
    environment="<environment_name>:<version>",
    compute="cpu-cluster",
)

# Submit the command
returned_job = ml_client.jobs.create_or_update(job)
# Get a URL for the job status
returned_job.services["Studio"].endpoint

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json

command: |
  ls ${{inputs.my_data}}
code: <folder where code is located>
inputs:
  my_data:
    type: mltable
    mode: eval_mount
    path: azureml:<filedataset_name>@latest
environment: azureml:<environment_name>@latest
compute: azureml:cpu-cluster

az ml job create -f <file-name>.yml

Ler um TabularDataset

from azure.ai.ml import command
from azure.ai.ml.entities import Data
from azure.ai.ml import Input
from azure.ai.ml.constants import AssetTypes, InputOutputModes
from azure.ai.ml import MLClient

ml_client = MLClient.from_config(credential=DefaultAzureCredential())

filedataset_asset = ml_client.data.get(name="<tabulardataset_name>", version="<version>")

my_job_inputs = {
    "input_data": Input(
            type=AssetTypes.MLTABLE,
            path=filedataset_asset.id,
            mode=InputOutputModes.DIRECT
    )
}

job = command(
    code="./src",  # Local path where the code is stored
    command="python train.py --inputs ${{inputs.input_data}}",
    inputs=my_job_inputs,
    environment="<environment_name>:<version>",
    compute="cpu-cluster",
)

# Submit the command
returned_job = ml_client.jobs.create_or_update(job)
# Get a URL for the status of the job
returned_job.services["Studio"].endpoint

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json

command: |
  ls ${{inputs.my_data}}
code: <folder where code is located>
inputs:
  my_data:
    type: mltable
    mode: direct
    path: azureml:<tabulardataset_name>@latest
environment: azureml:<environment_name>@latest
compute: azureml:cpu-cluster

az ml job create -f <file-name>.yml

Próximas etapas

• Treinar modelos
• Tutorial: criar pipelines de ML de produção com o SDK do Python v2
• Saiba mais sobre Dados no Azure Machine Learning