parallel Paquete

Referencia

Clases

ParallelJob	Trabajo paralelo.
RunFunction	Ejecutar función.

Funciones

parallel_run_function

Cree un objeto Parallel que se pueda usar dentro de dsl.pipeline como función y también se puede crear como un trabajo paralelo independiente.

Para obtener un ejemplo de uso de ParallelRunStep, consulte el cuaderno. 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

Nombre del trabajo paralelo o componente creado.

description: str

Descripción sencilla del paralelo.

tags: Dict

Etiquetas que se van a adjuntar a este paralelo.

properties: Dict

Diccionario de propiedades de recurso.

display_name: str

Un nombre descriptivo.

experiment_name: str

Nombre del experimento en el que se creará el trabajo, si se proporciona Ninguno, el valor predeterminado se establecerá en el nombre del directorio actual. Se omitirá como paso de canalización.

compute: str

Nombre del proceso donde se ejecuta el trabajo paralelo (no se usará si el paralelo se usa como componente o función).

retry_settings: BatchRetrySettings

Error al reintentar la ejecución de componentes paralelos

environment_variables: Dict[str, str]

Diccionario de nombres y valores de variables de entorno. Estas variables de entorno se establecen en el proceso donde se ejecuta el script de usuario.

logging_level: str

Cadena del nombre del nivel de registro, que se define en "logging". Los valores posibles son "WARNING", "INFO" y "DEBUG". (opcional, el valor predeterminado es "INFO"). Este valor se puede establecer a través de PipelineParameter.

max_concurrency_per_instance: int

Paralelismo máximo que tiene cada instancia de proceso.

error_threshold: int

Número de errores de registro para el conjunto de datos tabular y los errores de archivo para el conjunto de datos de archivos que se deben omitir durante el procesamiento. Si el recuento de errores está por encima de este valor, se anulará el trabajo. El umbral de error es para toda la entrada en lugar del miniproceso individual enviado al método run(). El intervalo es [-1, int.max]. -1 indica que se omiten todos los errores durante el procesamiento.

mini_batch_error_threshold: int

Se debe omitir el número de errores de procesamiento por lotes mínimos.

task: RunFunction

Tarea paralela

mini_batch_size: str

Para la entrada FileDataset, este campo es el número de archivos que un script de usuario puede procesar en una llamada a run(). Para la entrada TabularDataset, este campo es el tamaño aproximado de los datos que el script de usuario puede procesar en una llamada a run(). Los valores de ejemplo son 1024, 1024 KB, 10 MB y 1 GB. (opcional, el valor predeterminado es 10 archivos para FileDataset y 1MB para TabularDataset). Este valor se puede establecer a través de PipelineParameter.

partition_keys: List

Claves usadas para particionar el conjunto de datos en minilotes. Si se especifica, los datos con la misma clave se dividirán en el mismo minilote. Si se especifican partition_keys y mini_batch_size, las claves de partición surtirán efecto. Las entradas deben ser conjuntos de datos con particiones y el partition_keys debe ser un subconjunto de las claves de cada conjunto de datos de entrada para que funcione.

input_data: str

Los datos de entrada.

inputs: Dict

Un diccionario de entradas usadas por este paralelo.

outputs: Dict

Salidas de este paralelo

instance_count: int

Número opcional de instancias o nodos usados por el destino de proceso. El valor predeterminado es 1.

instance_type: str

Tipo opcional de máquina virtual que se usa como compatible con el destino de proceso.

docker_args: str

Argumentos adicionales para pasar al comando de ejecución de Docker. Esto invalidaría los parámetros ya establecidos por el sistema o en esta sección. Este parámetro solo se admite para los tipos de proceso de Azure ML.

shm_size: str

Tamaño del bloque de memoria compartida del contenedor de Docker. Debe estar en el formato de (número)(unidad) donde el número como mayor que 0 y la unidad puede ser uno de b(bytes), k(kilobytes), m(megabytes) o 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>]

Identidad que usará el trabajo de entrenamiento mientras se ejecuta en proceso.

is_deterministic: bool

Especifique si el paralelo devolverá la misma salida dada la misma entrada. Si un paralelo (componente) es determinista, cuando se usa como nodo o paso en una canalización, reutilizará los resultados de un trabajo enviado anteriormente en el área de trabajo actual que tiene las mismas entradas y configuraciones. En este caso, este paso no usará ningún recurso de proceso. El valor predeterminado es True, especifique is_deterministic=False si desea evitar este comportamiento de reutilización, el valor predeterminado es True.

Devoluciones

Nodo paralelo

Tipo de valor devuelto

Parallel

Comentarios

Para usar parallel_run_function:

Cree un <xref:azure.ai.ml.entities._builders.Parallel> objeto para especificar cómo se realiza la ejecución en paralelo, con parámetros para controlar el tamaño del lote, el número de nodos por destino de proceso y una referencia al script de Python personalizado.
Canalización de compilación con el objeto paralelo como una función. define entradas y salidas para el paso.
Sumbit la canalización que se va a ejecutar.

Compartir a través de