parallel Paquet

Référence

Classes

ParallelJob	Travail parallèle.
RunFunction	Exécuter la fonction.

Fonctions

parallel_run_function

Créez un objet Parallel qui peut être utilisé dans dsl.pipeline en tant que fonction et peut également être créé en tant que travail parallèle autonome.

Pour obtenir un exemple d’utilisation de ParallelRunStep, consultez le 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

Paramètres

name: str

Nom du travail parallèle ou du composant créé.

description: str

Description conviviale du parallèle.

tags: Dict

Balises à attacher à ce parallèle.

properties: Dict

Dictionnaire de propriétés de ressource.

display_name: str

Un nom convivial.

experiment_name: str

Nom de l’expérience sous laquelle le travail sera créé, si Aucun est fourni, la valeur par défaut est définie sur le nom du répertoire actif. Sera ignoré en tant qu’étape de pipeline.

compute: str

Nom du calcul où le travail parallèle est exécuté (ne sera pas utilisé si le parallèle est utilisé comme composant/fonction).

retry_settings: BatchRetrySettings

Échec de nouvelle tentative d’exécution du composant parallèle

environment_variables: Dict[str, str]

Dictionnaire des noms et valeurs des variables d’environnement. Ces variables d’environnement sont définies sur le processus où le script utilisateur est en cours d’exécution.

logging_level: str

Chaîne du nom du niveau de journalisation, définie dans « Logging ». Les valeurs possibles sont « WARNING », « INFO »et « DEBUG ». (facultatif, la valeur par défaut est « INFO »). Cette valeur peut être définie via PipelineParameter.

max_concurrency_per_instance: int

Parallélisme maximal dont dispose chaque instance de calcul.

error_threshold: int

Nombre d’échecs d’enregistrement pour le jeu de données tabulaire et d’échecs de fichiers pour le jeu de données de fichier qui doivent être ignorés pendant le traitement. Si le nombre d’erreurs dépasse cette valeur, le travail sera interrompu. Le seuil d’erreur concerne l’entrée entière plutôt que le mini-lot individuel envoyé à la méthode run(). La plage est [-1, int.max]. -1 indique ignorer tous les échecs pendant le traitement

mini_batch_error_threshold: int

Le nombre d’échecs de traitement par mini-lots doit être ignoré

task: RunFunction

Tâche parallèle

mini_batch_size: str

Pour une entrée FileDataset, ce champ est le nombre de fichiers que le script utilisateur peut traiter dans un appel à la méthode run(). Pour une entrée TabularDataset, ce champ correspond à la taille approximative des données que le script utilisateur peut traiter dans un appel de la méthode run(). Les exemples de valeurs sont 1 024, 1 024 Ko, 10 Mo et 1 Go. (facultatif, la valeur par défaut est 10 fichiers pour FileDataset et 1 Mo pour TabularDataset.) Cette valeur peut être définie via PipelineParameter.

partition_keys: List

Clés utilisées pour partitionner le jeu de données en mini-lots. Si la valeur est spécifiée, les données avec la même clé sont partitionnées dans le même mini-lot. Si partition_keys et mini_batch_size sont spécifiés, les clés de partition prennent effet. Les entrées doivent être des jeux de données partitionnés, et les partition_keys doivent être un sous-ensemble des clés de chaque jeu de données d’entrée pour que cela fonctionne

input_data: str

Données d'entrée.

inputs: Dict

Dictionnaire d’entrées utilisées par ce parallèle.

outputs: Dict

Sorties de ce parallèle

instance_count: int

Nombre facultatif d’instances ou de nœuds utilisés par la cible de calcul. La valeur par défaut est 1.

instance_type: str

Type facultatif de machine virtuelle utilisé comme pris en charge par la cible de calcul.

docker_args: str

Arguments supplémentaires à transmettre à la commande run de Docker. Cela remplacerait tous les paramètres qui ont déjà été définis par le système ou dans cette section. Ce paramètre est uniquement pris en charge pour les types de calcul Azure ML.

shm_size: str

Taille du bloc de mémoire partagée du conteneur Docker. Cela doit être au format (nombre)(unité) où le nombre doit être supérieur à 0 et l’unité peut être l’une des valeurs b(octets), k(kilo-octets), m(mégaoctets) ou g(gigaoctets).

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

Identité que le travail d’entraînement utilisera lors de l’exécution sur le calcul.

is_deterministic: bool

Spécifiez si le parallèle retourne la même sortie en fonction de la même entrée. Si un parallèle (composant) est déterministe, lorsqu’il est utilisé comme nœud/étape dans un pipeline, il réutilise les résultats d’un travail envoyé précédemment dans l’espace de travail actuel qui a les mêmes entrées et paramètres. Dans ce cas, cette étape n’utilise aucune ressource de calcul. La valeur par défaut est True, spécifiez is_deterministic=False si vous souhaitez éviter ce comportement de réutilisation, la valeur par défaut est True.

Retours

Nœud parallèle

Type de retour

Parallel

Remarques

Pour utiliser parallel_run_function :

Créez un <xref:azure.ai.ml.entities._builders.Parallel> objet pour spécifier la façon dont l’exécution parallèle est effectuée, avec des paramètres pour contrôler la taille du lot, le nombre de nœuds par cible de calcul et une référence à votre script Python personnalisé.
Générer un pipeline avec l’objet parallèle en tant que fonction. définit les entrées et les sorties pour l’étape.
Somme du pipeline à exécuter.

Partager via