parallel Pacote

Referência

Classes

ParallelJob	Trabalho paralelo.
RunFunction	Executar Função.

Funções

parallel_run_function

Crie um objeto Parallel que pode ser usado dentro de dsl.pipeline como uma função e também pode ser criado como um trabalho paralelo autônomo.

Para obter um exemplo de como usar ParallelRunStep, consulte o notebook https://aka.ms/parallel-example-notebook


   from azure.ai.ml import Input, Output, parallel

   parallel_run = parallel_run_function(
       name="batch_score_with_tabular_input",
       display_name="Batch Score with Tabular Dataset",
       description="parallel component for batch score",
       inputs=dict(
           job_data_path=Input(
               type=AssetTypes.MLTABLE,
               description="The data to be split and scored in parallel",
           ),
           score_model=Input(
               type=AssetTypes.URI_FOLDER, description="The model for batch score."
           ),
       ),
       outputs=dict(job_output_path=Output(type=AssetTypes.MLTABLE)),
       input_data="${{inputs.job_data_path}}",
       max_concurrency_per_instance=2,  # Optional, default is 1
       mini_batch_size="100",  # optional
       mini_batch_error_threshold=5,  # Optional, allowed failed count on mini batch items, default is -1
       logging_level="DEBUG",  # Optional, default is INFO
       error_threshold=5,  # Optional, allowed failed count totally, default is -1
       retry_settings=dict(max_retries=2, timeout=60),  # Optional
       task=RunFunction(
           code="./src",
           entry_script="tabular_batch_inference.py",
           environment=Environment(
               image="mcr.microsoft.com/azureml/openmpi3.1.2-ubuntu18.04",
               conda_file="./src/environment_parallel.yml",
           ),
           program_arguments="--model ${{inputs.score_model}}",
           append_row_to="${{outputs.job_output_path}}",  # Optional, if not set, summary_only
       ),
   )

parallel_run_function(*, name: str | None = None, description: str | None = None, tags: Dict | None = None, properties: Dict | None = None, display_name: str | None = None, experiment_name: str | None = None, compute: str | None = None, retry_settings: BatchRetrySettings | None = None, environment_variables: Dict | None = None, logging_level: str | None = None, max_concurrency_per_instance: int | None = None, error_threshold: int | None = None, mini_batch_error_threshold: int | None = None, task: RunFunction | None = None, mini_batch_size: str | None = None, partition_keys: List | None = None, input_data: str | None = None, inputs: Dict | None = None, outputs: Dict | None = None, instance_count: int | None = None, instance_type: str | None = None, docker_args: str | None = None, shm_size: str | None = None, identity: ManagedIdentity | AmlToken | None = None, is_deterministic: bool = True, **kwargs) -> Parallel

Parâmetros

name: str

Nome do trabalho paralelo ou componente criado.

description: str

Uma descrição amigável do paralelo.

tags: Dict

Marcas a serem anexadas a esse paralelo.

properties: Dict

O dicionário de propriedades do ativo.

display_name: str

Um nome amigável.

experiment_name: str

Nome do experimento em que o trabalho será criado, se Nenhum for fornecido, o padrão será definido como nome do diretório atual. Será ignorado como uma etapa de pipeline.

compute: str

O nome da computação em que o trabalho paralelo é executado (não será usado se o paralelo for usado como um componente/função).

retry_settings: BatchRetrySettings

Tentativa de execução de componente paralelo com falha

environment_variables: Dict[str, str]

Um dicionário de valores e nomes de variáveis de ambiente. Essas variáveis de ambiente são definidas no processo em que o script do usuário está sendo executado.

logging_level: str

Uma cadeia de caracteres do nome do nível de registros em log, que é definido em 'logging'. Os valores possíveis são 'WARNING', 'INFO' e 'DEBUG'. (opcional, o valor padrão é 'INFO'.) Esse valor pode ser definido por meio do PipelineParameter.

max_concurrency_per_instance: int

O paralelismo máximo que cada instância de computação tem.

error_threshold: int

O número de falhas de registro para o Conjunto de Dados Tabular e falhas de arquivo para o Conjunto de Dados de Arquivo que devem ser ignoradas durante o processamento. Se a contagem de erros ultrapassar esse valor, o trabalho será anulado. O limite de erro é para toda a entrada em vez do minilote individual enviado para o método run(). O intervalo é [-1, int.max]. -1 indica ignorar todas as falhas durante o processamento

mini_batch_error_threshold: int

O número de falhas de processamento em mini lote deve ser ignorado

task: RunFunction

A tarefa paralela

mini_batch_size: str

Para entrada FileDataset, esse campo é o número de arquivos que um script do usuário pode processar em uma chamada run(). Para entrada TabularDataset, esse campo é o tamanho aproximado dos dados que o script do usuário pode processar em uma chamada run(). Os valores de exemplo são 1024, 1024 KB, 10 MB e 1 GB. (opcional, o valor padrão é 10 arquivos para FileDataset e 1MB para TabularDataset.) Esse valor pode ser definido por meio de PipelineParameter.

partition_keys: List

As chaves usadas para particionar o conjuntos de dados em minilotes. Se especificado, os dados com a mesma chave serão particionados no mesmo minilote. Se partition_keys e mini_batch_size forem especificados, as chaves de partição entrarão em vigor. As entradas devem ser conjuntos de dados particionados e o partition_keys deve ser um subconjunto das chaves de cada conjunto de dados de entrada para que isso funcione

input_data: str

Os dados de entrada.

inputs: Dict

Um dict de entradas usado por esse paralelo.

outputs: Dict

As saídas desse paralelo

instance_count: int

Número opcional de instâncias ou nós usados pelo destino de computação. O valor padrão é 1

instance_type: str

Tipo opcional de VM usada como suporte pelo destino de computação..

docker_args: str

Argumentos adicionais a serem passados para o comando docker run. Isso substituiria todos os parâmetros que já foram definidos pelo sistema ou nesta seção. Esse parâmetro só tem suporte para tipos de computação do Azure ML.

shm_size: str

Tamanho do bloco de memória compartilhada do contêiner do Docker. Isso deve estar no formato de (número)(unidade), em que o número é maior que 0 e a unidade pode ser um dos b(bytes), k(kilobytes), m(megabytes) ou g(gigabytes).

identity: Union[ <xref:azure.ai.ml._restclient.v2022_02_01_preview.models.ManagedIdentity>, <xref:azure.ai.ml._restclient.v2022_02_01_preview.models.AmlToken>]

Identidade que o trabalho de treinamento usará durante a execução na computação.

is_deterministic: bool

Especifique se o paralelo retornará a mesma saída considerando a mesma entrada. Se um paralelo (componente) for determinístico, ao usá-lo como um nó/etapa em um pipeline, ele reutilizará os resultados de um trabalho enviado anteriormente no workspace atual que tem as mesmas entradas e configurações. Nesse caso, essa etapa não usará nenhum recurso de computação. O padrão é True, especifique is_deterministic=False se quiser evitar esse comportamento de reutilização, o padrão é True.

Retornos

O nó paralelo

Tipo de retorno

Parallel

Comentários

Para usar parallel_run_function:

Crie um <xref:azure.ai.ml.entities._builders.Parallel> objeto para especificar como a execução paralela é executada, com parâmetros para controlar o tamanho do lote, o número de nós por destino de computação e uma referência ao script python personalizado.
Criar pipeline com o objeto paralelo como uma função. define entradas e saídas para a etapa.
Somar o pipeline a ser executado.

Compartilhar via