Enviar trabalhos do Spark no Azure Machine Learning

  • Artigo

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

O Azure Machine Learning dá suporte ao envio de trabalhos autônomos de aprendizado de máquina e à criação de pipelines de aprendizado de máquina que envolvem várias etapas de fluxo de trabalho de aprendizado de máquina. O Azure Machine Learning cuida da criação de trabalhos autônomos do Spark e da criação de componentes reutilizáveis do Spark que podem ser usados pelos pipelines do Azure Machine Learning. Neste artigo, você aprenderá a enviar trabalhos do Spark usando:

  • Interface do usuário do Estúdio do Azure Machine Learning
  • CLI do Azure Machine Learning
  • SDK do Azure Machine Learning

Para obter mais informações sobre conceitos do Apache Spark no Azure Machine Learning, confira este recurso.

Pré-requisitos

APLICA-SE A:Extensão de ML da CLI do Azure v2 (atual)

Observação

  • Para saber mais sobre o acesso a recursos ao usar a computação do Spark sem servidor do Microsoft Azure Machine Learning e o pool do Synapse Spark anexado, consulte Garantir acesso a recursos para trabalhos do Spark.
  • O Azure Machine Learning fornece um pool de cota compartilhada do qual todos os usuários podem acessar a cota de computação para executar testes por um tempo limitado. Quando você usa a computação do Spark sem servidor, o Azure Machine Learning permite que você acesse essa cota compartilhada por um curto período de tempo.

Anexar identidade gerenciada atribuída pelo usuário usando a CLI v2

  1. Crie um arquivo YAML que define a identidade gerenciada atribuída pelo usuário que deve ser anexada ao workspace: 
    identity:
  type: system_assigned,user_assigned
  tenant_id: <TENANT_ID>
  user_assigned_identities:
    '/subscriptions/<SUBSCRIPTION_ID/resourceGroups/<RESOURCE_GROUP>/providers/Microsoft.ManagedIdentity/userAssignedIdentities/<AML_USER_MANAGED_ID>':
      {}
  2. Com o parâmetro --file, use o arquivo YAML no comando az ml workspace update para anexar a identidade gerenciada atribuída pelo usuário: 
    az ml workspace update --subscription <SUBSCRIPTION_ID> --resource-group <RESOURCE_GROUP> --name <AML_WORKSPACE_NAME> --file <YAML_FILE_NAME>.yaml

Anexe a identidade gerenciada atribuída pelo usuário usando ARMClient

  1. Instale o ARMClient, uma ferramenta de linha de comando simples que invoca a API do Azure Resource Manager.
  2. Crie um arquivo JSON que define a identidade gerenciada atribuída pelo usuário que deve ser anexada ao workspace: 
    {
    "properties":{
    },
    "location": "<AZURE_REGION>",
    "identity":{
        "type":"SystemAssigned,UserAssigned",
        "userAssignedIdentities":{
            "/subscriptions/<SUBSCRIPTION_ID/resourceGroups/<RESOURCE_GROUP>/providers/Microsoft.ManagedIdentity/userAssignedIdentities/<AML_USER_MANAGED_ID>": { }
        }
    }
}
  3. Para anexar a identidade gerenciada atribuída pelo usuário ao workspace, execute o comando a seguir no prompt do PowerShell ou no prompt de comando. 
    armclient PATCH https://management.azure.com/subscriptions/<SUBSCRIPTION_ID>/resourceGroups/<RESOURCE_GROUP>/providers/Microsoft.MachineLearningServices/workspaces/<AML_WORKSPACE_NAME>?api-version=2022-05-01 '@<JSON_FILE_NAME>.json'

Observação

Enviar um trabalho autônomo do Spark

Depois que forem feitas as alterações necessárias para a parametrização do script do Python, um script do Python desenvolvido pela estruturação de dados interativa poderá ser usado para enviar um trabalho em lotes, a fim de processar um volume maior de dados. Um trabalho em lotes de estruturação de dados simples pode ser enviado como um trabalho autônomo do Spark.

Um trabalho do Spark exige um script Python que usa argumentos, que podem ser desenvolvidos com a modificação do código Python criado com base na estruturação de dados interativa. Uma amostra de script Python é mostrada aqui.

# titanic.py
import argparse
from operator import add
import pyspark.pandas as pd
from pyspark.ml.feature import Imputer

parser = argparse.ArgumentParser()
parser.add_argument("--titanic_data")
parser.add_argument("--wrangled_data")

args = parser.parse_args()
print(args.wrangled_data)
print(args.titanic_data)

df = pd.read_csv(args.titanic_data, index_col="PassengerId")
imputer = Imputer(inputCols=["Age"], outputCol="Age").setStrategy(
    "mean"
)  # Replace missing values in Age column with the mean value
df.fillna(
    value={"Cabin": "None"}, inplace=True
)  # Fill Cabin column with value "None" if missing
df.dropna(inplace=True)  # Drop the rows which still have any missing value
df.to_csv(args.wrangled_data, index_col="PassengerId")

Observação

Este exemplo de código Python usa pyspark.pandas. Somente a versão 3.2 do runtime do Spark ou posterior dá suporte a isso.

O script acima usa dois argumentos --titanic_data e --wrangled_data, que passam o caminho dos dados de entrada e da pasta de saída, respectivamente.

APLICA-SE A:Extensão de ML da CLI do Azurev2 (atual)

Para criar um trabalho, um trabalho autônomo do Spark pode ser definido como um arquivo de especificação YAML, que pode ser usado no comando az ml job create, com o parâmetro --file. Defina essas propriedades no arquivo YAML:

Propriedades YAML na especificação de trabalho do Spark

  • type é definido como spark.

  • code – define o local da pasta que contém o código-fonte e os scripts para esse trabalho.

  • entry – define o ponto de entrada para o trabalho. Ele deve abordar uma destas propriedades:

    • file – define o nome do script Python que serve como um ponto de entrada para o trabalho.

  • py_files – define uma lista de arquivos .zip, .egg ou .py que serão colocados no PYTHONPATH, para obter a execução bem-sucedida do trabalho. Essa propriedade é opcional.

  • jars – define uma lista de arquivos .jar a serem incluídos no driver do Spark e no executor CLASSPATH para obter a execução bem-sucedida do trabalho. Essa propriedade é opcional.

  • files – define uma lista de arquivos que devem ser copiados para o diretório de trabalho de cada executor, para obter a execução bem-sucedida do trabalho. Essa propriedade é opcional.

  • archives – define uma lista de arquivos que devem ser extraídos para o diretório de trabalho de cada executor, para obter a execução bem-sucedida do trabalho. Essa propriedade é opcional.

  • conf – define estas propriedades de driver e executor do Spark:

    • spark.driver.cores: o número de núcleos para o driver do Spark.
    • spark.driver.memory: memória alocada para o driver do Spark, em gigabytes (GB).
    • spark.executor.cores: o número de núcleos para o executor do Spark.
    • spark.executor.memory: a alocação de memória para o executor do Spark, em gigabytes (GB).
    • spark.dynamicAllocation.enabled – se os executores devem ou não ser alocados dinamicamente, como um valor True ou False.
    • Se a alocação dinâmica de executores estiver habilitada, defina estas propriedades:
      • spark.dynamicAllocation.minExecutors – o número mínimo de instâncias de executores do Spark, para alocação dinâmica.
      • spark.dynamicAllocation.maxExecutors – o número máximo de instâncias de executores do Spark, para alocação dinâmica.
    • Se a alocação dinâmica de executores estiver desabilitada, defina esta propriedade:
      • spark.executor.instances – o número de instâncias do executor do Spark.

  • environment – um ambiente do Azure Machine Learning para executar o trabalho.

  • args – Os argumentos da linha de comando que devem ser passados para a classe ou o script Python do ponto de entrada do trabalho. Confira o arquivo de especificação YAML fornecido aqui para ver um exemplo.

  • resources - essa propriedade define os recursos a serem usados por uma computação do Spark sem servidor do Azure Machine Learning. Ela usa as propriedades a seguir:

    • instance_type – o tipo de instância de computação a ser usado para o Pool do Spark. No momento, há suporte para os seguintes tipos de instância:
      • standard_e4s_v3
      • standard_e8s_v3
      • standard_e16s_v3
      • standard_e32s_v3
      • standard_e64s_v3
    • runtime_version – define a versão de runtime do Spark. Atualmente, há suporte para as seguintes versões de runtime do Spark:
      • 3.2
      • 3.3

        Importante

        Runtime do Azure Synapse para o Apache Spark: Comunicados

        • Runtime do Azure Synapse para Apache Spark 3.2:
          • Data do Comunicado EOLA: 8 de julho de 2023
          • Data do Término do Suporte: 8 de julho de 2024. Após essa data, o runtime será desabilitado.
        • Para obter suporte contínuo e desempenho ideal, recomendamos a migração para o Apache Spark 3.3.

    Este é um exemplo:

    resources:
  instance_type: standard_e8s_v3
  runtime_version: "3.3"

  • compute – essa propriedade define o nome de um pool do Spark do Synapse anexado, conforme mostrado neste exemplo:

    compute: mysparkpool

  • inputs – essa propriedade define entradas para o trabalho do Spark. As entradas para um trabalho do Spark podem ser um valor literal ou dados armazenados em um arquivo ou pasta.

    • Um valor literal pode ser um número, um valor booliano ou uma cadeia de caracteres. Alguns exemplos são mostrados aqui: 
      inputs:
  sampling_rate: 0.02 # a number
  hello_number: 42 # an integer
  hello_string: "Hello world" # a string
  hello_boolean: True # a boolean value
    • Os dados armazenados em um arquivo ou pasta devem ser definidos usando estas propriedades:
      • type – defina essa propriedade como uri_file ou uri_folder, para dados de entrada presentes em um arquivo ou em uma pasta, respectivamente.
      • path – o URI dos dados de entrada, como azureml://, abfss:// ou wasbs://.
      • mode – defina esta propriedade como direct. Este exemplo mostra a definição de uma entrada de trabalho, que pode ser chamada de $${inputs.titanic_data}}: 
        inputs:
  titanic_data:
    type: uri_file
    path: azureml://datastores/workspaceblobstore/paths/data/titanic.csv
    mode: direct

  • outputs – essa propriedade define as saídas de trabalho do Spark. As saídas de um trabalho do Spark podem ser gravadas em um arquivo ou em um local de pasta, que é definido usando as três propriedades a seguir:

    • type – essa propriedade pode ser definida como uri_file ou uri_folder para gravar dados de saída em um arquivo ou uma pasta, respectivamente.
    • path – essa propriedade define o URI do local de saída, como azureml://, abfss:// ou wasbs://.
    • mode – defina esta propriedade como direct. Este exemplo mostra a definição de uma saída de trabalho, que pode ser chamada de ${{outputs.wrangled_data}}: 
      outputs:
  wrangled_data:
    type: uri_folder
    path: azureml://datastores/workspaceblobstore/paths/data/wrangled/
    mode: direct

  • identity – essa propriedade opcional define a identidade usada para enviar esse trabalho. Ela pode ter valores user_identity e managed. Se a especificação YAML não definir uma identidade, o trabalho do Spark usará a identidade padrão.

Trabalho autônomo do Spark

Esse exemplo de especificação YAML mostra um trabalho autônomo do Spark. Ele usa uma computação do Spark sem servidor do Azure Machine Learning:

$schema: http://azureml/sdk-2-0/SparkJob.json
type: spark

code: ./ 
entry:
  file: titanic.py

conf:
  spark.driver.cores: 1
  spark.driver.memory: 2g
  spark.executor.cores: 2
  spark.executor.memory: 2g
  spark.executor.instances: 2

inputs:
  titanic_data:
    type: uri_file
    path: azureml://datastores/workspaceblobstore/paths/data/titanic.csv
    mode: direct

outputs:
  wrangled_data:
    type: uri_folder
    path: azureml://datastores/workspaceblobstore/paths/data/wrangled/
    mode: direct

args: >-
  --titanic_data ${{inputs.titanic_data}}
  --wrangled_data ${{outputs.wrangled_data}}

identity:
  type: user_identity

resources:
  instance_type: standard_e4s_v3
  runtime_version: "3.3"

Observação

Para usar um pool anexado do Synapse Spark, defina a propriedade compute no arquivo de especificação YAML de exemplo mostrado acima, em vez da propriedade resources.

Os arquivos YAML mostrados anteriormente podem ser usados no comando az ml job create, com o parâmetro --file, para criar um trabalho autônomo do Spark, conforme mostrado:

az ml job create --file <YAML_SPECIFICATION_FILE_NAME>.yaml --subscription <SUBSCRIPTION_ID> --resource-group <RESOURCE_GROUP> --workspace-name <AML_WORKSPACE_NAME>

Você pode executar o comando acima no:

Componente do Spark em um trabalho de pipeline

Um componente do Spark oferece a flexibilidade de usar o mesmo componente em vários pipelines do Azure Machine Learning, como uma etapa de pipeline.

APLICA-SE A:Extensão de ML da CLI do Azure v2 (atual)

A sintaxe YAML para um componente do Spark é semelhante à sintaxe YAML para especificação de trabalho do Spark em muitos aspectos. Essas propriedades são definidas de forma diferente na especificação YAML de componente do Spark:

  • name – o nome do componente do Spark.

  • version – a versão do componente do Spark.

  • display_name – o nome do componente do Spark a ser exibido na interface do usuário e em outro lugar.

  • description – a descrição do componente do Spark.

  • inputs – Essa propriedade é semelhante à propriedade inputs descrita na sintaxe do YAML para a especificação de trabalho do Spark, com a exceção de que ela não define a propriedade path. Este snippet de código mostra um exemplo da propriedade inputs do componente do Spark:

    inputs:
  titanic_data:
    type: uri_file
    mode: direct

  • outputs – Essa propriedade é semelhante à propriedade outputs descrita na sintaxe do YAML para a especificação de trabalho do Spark, com a exceção de que ela não define a propriedade path. Este snippet de código mostra um exemplo da propriedade outputs do componente do Spark:

    outputs:
  wrangled_data:
    type: uri_folder
    mode: direct

Observação

Um componente do Spark não define propriedadesidentity, compute ou resources. O arquivo de especificação YAML do pipeline define essas propriedades.

Este arquivo de especificação YAML fornece um exemplo de um componente do Spark:

$schema: http://azureml/sdk-2-0/SparkComponent.json
name: titanic_spark_component
type: spark
version: 1
display_name: Titanic-Spark-Component
description: Spark component for Titanic data

code: ./src
entry:
  file: titanic.py

inputs:
  titanic_data:
    type: uri_file
    mode: direct

outputs:
  wrangled_data:
    type: uri_folder
    mode: direct

args: >-
  --titanic_data ${{inputs.titanic_data}}
  --wrangled_data ${{outputs.wrangled_data}}

conf:
  spark.driver.cores: 1
  spark.driver.memory: 2g
  spark.executor.cores: 2
  spark.executor.memory: 2g
  spark.dynamicAllocation.enabled: True
  spark.dynamicAllocation.minExecutors: 1
  spark.dynamicAllocation.maxExecutors: 4

O componente do Spark definido no arquivo de especificação YAML mencionado pode ser usado em um trabalho de pipeline do Azure Machine Learning. Consulte esquema YAML do trabalho de pipeline para saber mais sobre a sintaxe YAML que define um trabalho de pipeline. Esse exemplo mostra um arquivo de especificação YAML para um trabalho de pipeline, com um componente Spark e uma computação Spark sem servidor do Azure Machine Learning:

$schema: http://azureml/sdk-2-0/PipelineJob.json
type: pipeline
display_name: Titanic-Spark-CLI-Pipeline
description: Spark component for Titanic data in Pipeline

jobs:
  spark_job:
    type: spark
    component: ./spark-job-component.yaml
    inputs:
      titanic_data: 
        type: uri_file
        path: azureml://datastores/workspaceblobstore/paths/data/titanic.csv
        mode: direct

    outputs:
      wrangled_data:
        type: uri_folder
        path: azureml://datastores/workspaceblobstore/paths/data/wrangled/
        mode: direct

    identity:
      type: managed

    resources:
      instance_type: standard_e8s_v3
      runtime_version: "3.3"

Observação

Para usar um pool anexado do Synapse Spark, defina a propriedade compute no exemplo de arquivo de especificação YAML mostrado acima em vez da propriedade resources.

O arquivo de especificação YAML mencionado pode ser usado no comando az ml job create com o parâmetro --file para criar um trabalho de pipeline, conforme mostrado:

az ml job create --file <YAML_SPECIFICATION_FILE_NAME>.yaml --subscription <SUBSCRIPTION_ID> --resource-group <RESOURCE_GROUP> --workspace-name <AML_WORKSPACE_NAME>

Você pode executar o comando acima no:

Solução de problemas de trabalhos do Spark

Para solucionar problemas de um trabalho do Spark, você pode acessar os logs gerados para o respectivo trabalho no Estúdio do Azure Machine Learning. Para exibir os logs de um trabalho do Spark:

  1. Navegue até Trabalhos no painel esquerdo na interface do usuário do Estúdio do Azure Machine Learning
  2. Selecione a guia Todos os trabalhos
  3. Selecione o valor Nome de exibição para o trabalho
  4. Na página de detalhes do trabalho, selecione a guia Saída + logs
  5. No explorador de arquivos, expanda a pasta logs e em seguida expanda a pasta azureml
  6. Acessar os logs de trabalho do Spark dentro das pastas do driver e gerenciador de biblioteca

Observação

Para solucionar problemas de trabalhos do Spark criados durante a estruturação interativa de dados em uma sessão de notebook, selecione Detalhes do trabalho no canto superior direito da interface do usuário do notebook. Um trabalho do Spark de uma sessão interativa de notebook é criado sob o nome de experimento notebook-runs.

Próximas etapas