parallel Pacote

Referência

Classes

ParallelJob	Tarefa paralela.
RunFunction	Executar Função.

Funções

parallel_run_function

Crie um objeto Paralelo que pode ser utilizado dentro de dsl.pipeline como uma função e também pode ser criado como uma tarefa paralela autónoma.

Para obter um exemplo de utilização de ParallelRunStep, veja o bloco de notas 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 da tarefa paralela ou componente criado.

description: str

Uma descrição amigável do paralelo.

tags: Dict

Etiquetas a anexar a este paralelo.

properties: Dict

O dicionário da propriedade do recurso.

display_name: str

Um nome amigável.

experiment_name: str

Nome da experimentação em que a tarefa será criada, se Nenhuma for fornecida, a predefinição será definida como nome do diretório atual. Será ignorado como um passo de pipeline.

compute: str

O nome da computação em que a tarefa paralela é executada (não será utilizado se o paralelo for utilizado como componente/função).

retry_settings: BatchRetrySettings

Falha na repetição da execução do componente paralelo

environment_variables: Dict[str, str]

Um dicionário de nomes e valores de variáveis de ambiente. Estas variáveis de ambiente são definidas no processo em que o script de utilizador está a ser executado.

logging_level: str

Uma cadeia do nome do nível de registo, que é definida em "registo". Os valores possíveis são "AVISO", "INFORMAÇÕES" e "DEPURAÇÃO". (opcional, o valor predefinido é "INFO".) Este valor pode ser definido através de 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 registo do Conjunto de Dados Tabular e falhas de ficheiros do Conjunto de Dados de Ficheiros que devem ser ignoradas durante o processamento. Se a contagem de erros for superior a este valor, a tarefa será abortada. O limiar de erro destina-se a toda a entrada em vez do método de mini-lote individual enviado para executar(). 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 lotes deve ser ignorado

task: RunFunction

A tarefa paralela

mini_batch_size: str

Para entrada FileDataset, este campo é o número de ficheiros que um script de utilizador pode processar numa chamada run(). Para a entrada TabularDataset, este campo é o tamanho aproximado dos dados que o script de utilizador pode processar numa chamada run(). Os valores de exemplo são 1024, 1024 KB, 10 MB e 1GB. (opcional, o valor predefinido é 10 ficheiros para FileDataset e 1MB para TabularDataset.) Este valor pode ser definido através de PipelineParameter.

partition_keys: List

As chaves utilizadas para particionar o conjunto de dados em mini-lotes. Se especificado, os dados com a mesma chave serão particionados no mesmo mini-lote. Se forem especificados partition_keys e mini_batch_size, as chaves de partição entrarão em vigor. As entradas têm de ser conjuntos de dados particionados e o partition_keys tem de ser um subconjunto das chaves de cada conjunto de dados de entrada para que isto funcione

input_data: str

Os dados de entrada.

inputs: Dict

Um ditado das entradas utilizadas por este paralelo.

outputs: Dict

As saídas deste paralelo

instance_count: int

Número opcional de instâncias ou nós utilizados pelo destino de computação. Predefinições para 1

instance_type: str

Tipo opcional de VM utilizado como suportado pelo destino de computação..

docker_args: str

Argumentos adicionais para passar para o comando de execução do Docker. Isto substituiria quaisquer parâmetros que já tenham sido definidos pelo sistema ou nesta secção. Este parâmetro só é suportado para tipos de computação do Azure ML.

shm_size: str

Tamanho do bloco de memória partilhado do contentor docker. Deve estar no formato de (número)(unidade) em que o número deve ser superior a 0 e a unidade pode ser um de 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 a tarefa de preparação utilizará durante a execução na computação.

is_deterministic: bool

Especifique se o paralelo devolverá a mesma saída dada a mesma entrada. Se um paralelo (componente) for determinista, quando o utilizar como nó/passo num pipeline, reutilizará os resultados de uma tarefa submetida anterior na área de trabalho atual que tem as mesmas entradas e definições. Neste caso, este passo não utilizará nenhum recurso de computação. Predefinições para Verdadeiro, especifique is_deterministic=Falso se quiser evitar esse comportamento de reutilização, predefinição para Verdadeiro.

Devoluções

O nó paralelo

Tipo de retorno

Parallel

Observações

Para utilizar parallel_run_function:

Crie um <xref:azure.ai.ml.entities._builders.Parallel> objeto para especificar a forma 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.
Crie um pipeline com o objeto paralelo como uma função. define entradas e saídas para o passo.
Sumbite o pipeline a executar.

Partilhar via