Création de tâches d'entraînement distribué IA - Platform For AI

PAI-DLC permet de créer rapidement des tâches d'entraînement sur nœud unique ou distribuées. Kubernetes provisionne automatiquement les nœuds de calcul en arrière-plan, évitant ainsi l'achat manuel de machines ou la configuration d'environnements d'exécution. Le service prend en charge TensorFlow, PyTorch et d'autres frameworks populaires de deep learning, tout en offrant des options flexibles de configuration des ressources.

Démarrage rapide

Prenant l'exemple de la reconnaissance de chiffres manuscrits MNIST, ce guide détaille l'entraînement sur un seul nœud avec un seul GPU ainsi que l'entraînement distribué multi-nœuds et multi-GPU avec DLC. Pour plus d'informations, consultez Premiers pas avec Deep Learning Containers (DLC).

Référence des paramètres de la console

Informations de base

Paramètre	Description
Job Name	Définissez un nom facilement identifiable pour la tâche.
Tag	Appliquez des tags standardisés à vos tâches. Les tags constituent la base pour archiver les tâches par libellé, analyser leur répartition et suivre la consommation des ressources. Les contraintes suivantes s'appliquent : Contraintes de clé : Ne doit pas commencer par `aliyun` ou `acs:`. Ne doit pas contenir `http://` ou `https://`. Longueur maximale : 128 caractères. Les clés ne peuvent contenir que des lettres, des chiffres, des traits d'union (-), des underscores (_) et des points (.). Contraintes de valeur : Ne doit pas contenir `http://` ou `https://`. Longueur maximale : 256 caractères. Séparez les valeurs multiples par des virgules. Pour obtenir des conseils sur le balisage standardisé, reportez-vous à Standardiser le balisage pour DLC, DSW et EAS.
Task Description	Utilisez ce champ pour décrire l'objectif, le contexte ou toute autre information pertinente concernant la tâche.

Informations sur l'environnement

Paramètre	Description
Image Configuration	Outre l'Alibaba Cloud Image, les types d'images suivants sont pris en charge : Custom Image : Utilisez des images personnalisées ajoutées à PAI. Le référentiel d'images doit être public ou stocké dans Alibaba Cloud Container Registry (ACR). Pour plus de détails, consultez Images personnalisées. Remarque Si vous sélectionnez des ressources Lingjun et utilisez une image personnalisée, installez manuellement les pilotes RDMA pour tirer pleinement parti du réseau RDMA haute performance. Pour plus de détails, consultez RDMA : Réseau haute performance pour l'entraînement distribué. Image Address : Permet de configurer des adresses d'images personnalisées ou officielles accessibles publiquement. Pour les adresses d'images privées, cliquez sur Enter credentials et configurez le nom d'utilisateur et le mot de passe du référentiel d'images. Pour accélérer le téléchargement des images, consultez Accélération des images.
Mount dataset	Les jeux de données fournissent les fichiers nécessaires à l'entraînement du modèle. Deux types de jeux de données sont pris en charge : Custom Dataset : Vous pouvez créer un jeu de données personnalisé pour stocker les fichiers nécessaires à l'entraînement. Activez le mode Read-only et sélectionnez une version de jeu de données dans la liste des versions. Public Dataset : PAI fournit des jeux de données publics intégrés, qui ne prennent en charge que le montage en lecture seule. Mount Path : Chemin où le jeu de données est monté dans le conteneur DLC, par exemple `/mnt/data`. Accédez au jeu de données via ce chemin dans votre code. Pour plus de détails sur la configuration du montage, consultez Utiliser le stockage cloud. Important Si vous utilisez un jeu de données CPFS, configurez pour DLC un VPC correspondant au VPC du CPFS. Sinon, la tâche soumise risque de rester bloquée longtemps à l'état Preparing environment.
Mount storage	Vous pouvez également monter directement des chemins de source de données pour lire les données requises ou stocker des fichiers intermédiaires et de résultats. Types de sources de données pris en charge : OSS, NAS à usage général, NAS extrême, CPFS et BMCPFS (disponible uniquement avec les ressources Lingjun). Advanced Settings : Différents types de sources de données offrent des capacités spécifiques via les paramètres avancés. Par exemple : OSS : Définissez `{"mountType":"ossfs"}` dans les paramètres avancés pour monter le stockage OSS à l'aide d'ossfs. NAS à usage général et CPFS : Définissez le paramètre nconnect dans les paramètres avancés pour améliorer le débit NAS depuis le conteneur DLC. Pour plus de détails, consultez Comment améliorer les performances NAS sous Linux ?. Par exemple, `{"nconnect":"<sample value>"}`, où `<sample value>` est remplacé par un entier positif spécifique. Pour plus d'informations, consultez Utiliser le stockage cloud.
Startup Command	Définissez la commande de démarrage de la tâche. Les commandes Shell sont prises en charge. DLC injecte automatiquement des variables d'environnement courantes pour PyTorch et TensorFlow telles que `MASTER_ADDR` et `WORLD_SIZE`. Référez-y-vous en utilisant `$VARIABLE_NAME`. Exemples de commandes de démarrage : Exécuter Python : `python -c "print('Hello World')"` Entraînement distribué PyTorch multi-nœuds et multi-GPU : `python -m torch.distributed.launch \ --nproc_per_node=2 \ --master_addr=${MASTER_ADDR} \ --master_port=${MASTER_PORT} \ --nnodes=${WORLD_SIZE} \ --node_rank=${RANK} \ train.py --epochs=100` Spécifier un chemin de script shell comme commande de démarrage : `/ml/input/config/launch.sh` Important Le chemin de montage configuré pour le code (tel que /mnt/data) correspond à l'emplacement de vos fichiers de code dans le conteneur DLC. Votre commande de démarrage doit référencer les fichiers de code en utilisant ce chemin. Par exemple, si le chemin de montage du code est /mnt/data et que votre fichier de code est train.py, la commande de démarrage doit être : python /mnt/data/train.py

Développer pour plus de paramètres : variables d'environnement, bibliothèques tierces, configuration du code

Environment Variable

En plus des variables d'environnement courantes pour PyTorch et TensorFlow injectées automatiquement, vous pouvez fournir des variables d'environnement personnalisées au format Key:Value. Jusqu'à 20 variables d'environnement sont prises en charge.

Third-party Libraries

Si certaines bibliothèques tierces manquent dans l'image du conteneur, ajoutez-les via Third-party Libraries. Deux méthodes sont disponibles :

Select from List : Saisissez directement les noms des bibliothèques dans la zone de texte ci-dessous. Séparez les noms multiples par des espaces, par exemple griffon numpy pandas.
Directory of requirements.txt : Ajoutez les bibliothèques à un fichier requirements.txt, chargez-le dans le conteneur DLC via la configuration du code, un jeu de données ou un montage direct, puis spécifiez le chemin du fichier dans le conteneur dans la zone de texte.

Code Builds

Chargez les fichiers de code nécessaires à l'entraînement dans le conteneur DLC. Deux méthodes de configuration sont prises en charge :

Online configuration : Si vous disposez d'un référentiel Git existant et des permissions d'accès, liez-le en utilisant Créer une configuration de code afin que DLC puisse récupérer le code de la tâche.
Local Upload : Cliquez sur le bouton pour charger des fichiers de code locaux. Après un chargement réussi, configurez le Mount path vers un chemin spécifique dans le conteneur, par exemple /mnt/data.

Informations sur les ressources

Paramètre	Description
Resource Type	La valeur par défaut est General Computing. Les Lingjun Intelligence Resources sont disponibles dans les régions suivantes : Chine (Ulanqab), Singapour, Chine (Shenzhen), Chine (Pékin), Chine (Shanghai), Chine (Hangzhou), Chine (Guangzhou), Chine (Hong Kong), Malaisie, Allemagne et Atlanta.
Source	Public Resources : Modèle de facturation : Paiement à l'utilisation. Convient aux charges de travail avec des tâches peu fréquentes et sans exigences strictes de délais. Les ressources publiques peuvent nécessiter une mise en file d'attente. Limites de ressources : Jusqu'à 2 GPU et 8 cœurs CPU. Pour dépasser ces limites, contactez votre gestionnaire de compte afin d'augmenter le quota. Resource Quota : Inclut des ressources de calcul à usage général ou des ressources Lingjun. Modèle de facturation : Abonnement. Recommandé pour les scénarios à volume élevé de tâches nécessitant des ressources stables et garanties. Paramètres spécifiques : Resource Quota : Définissez la quantité de GPU, CPU et autres ressources. Pour savoir comment préparer les quotas de ressources, consultez Créer un quota de ressources. Priority : Indique la priorité d'exécution des tâches s'exécutant simultanément. Plage de valeurs : [1, 9], où 1 correspond à la priorité la plus basse. Pré-vérification : Vérifie automatiquement la compatibilité du modèle de GPU et de l'image avant la soumission de la tâche, permettant de détecter les erreurs de configuration en amont et d'éviter les échecs. Preemptible Resources : Modèle de facturation : Paiement à l'utilisation. Conçu pour les scénarios sensibles aux coûts. La tarification des ressources spot est inférieure à celle du paiement à l'utilisation. Aucune garantie de disponibilité. Les ressources peuvent ne pas être immédiatement disponibles ou être récupérées. Pour plus d'informations, consultez Utiliser une tâche préemptible.
Framework	Les frameworks et outils d'entraînement de deep learning suivants sont pris en charge : TensorFlow, PyTorch, ElasticBatch, XGBoost, OneFlow, MPIJob, Ray, Custom, DataJuicer et MPI. Remarque Lorsque le Resource Quota est défini sur les ressources Lingjun, seules les tâches TensorFlow, PyTorch, ElasticBatch, MPIJob et Ray sont prises en charge.
Job Resource	Selon le Framework sélectionné, configurez les ressources pour les types de nœuds Worker, PS, Chief, Evaluator et GraphLearn. Avec le framework Ray, cliquez sur Add Role pour personnaliser les rôles Worker, permettant ainsi l'exécution mixte de ressources hétérogènes. Avec des ressources publiques : Les paramètres suivants sont configurables : Number of Nodes : Nombre de nœuds exécutant la tâche DLC. Resource Type : Sélectionnez le type d'instance. La console affiche le prix correspondant. Pour plus d'informations sur la facturation, consultez Facturation DLC. Avec des quotas de ressources : Configurez le nombre de nœuds, les cœurs CPU, les GPU, la mémoire (GiB) et la mémoire partagée (GiB) pour chaque type de nœud. Les paramètres spéciaux suivants sont également disponibles : Node-Specific Scheduling : Exécutez les tâches sur des nœuds de calcul spécifiques. Idle Resources : Lors de l'utilisation de ressources en temps d'inactivité, les tâches peuvent s'exécuter sur la capacité inutilisée d'autres quotas, améliorant ainsi l'utilisation des ressources. Cependant, lorsque le quota d'origine a besoin de ces ressources, les tâches en temps d'inactivité sont automatiquement arrêtées et les ressources restituées. Pour plus d'informations, consultez Utiliser des ressources en temps d'inactivité. CPU Affinity : Activez l'affinité CPU pour lier les processus à des cœurs CPU spécifiques, réduisant ainsi les défauts de cache et les changements de contexte pour améliorer les performances. Adapté aux scénarios exigeant des performances élevées et du temps réel. Avec des ressources spot : Outre le nombre de nœuds et le type d'instance, configurez le paramètre Bid Price, qui définit l'enchère maximale pour les ressources spot. Cliquez sur le bouton pour sélectionner une méthode d'enchère : Par remise : Le prix maximum est basé sur le prix du marché du type d'instance, avec des options discrètes allant de 10 % à 90 % du prix du marché, représentant le plafond de l'enchère. Les ressources spot sont allouées lorsque l'enchère maximale est supérieure ou égale au prix du marché et qu'une capacité suffisante est disponible. Par prix : La plage d'enchère maximale se situe dans la fourchette des prix du marché.
Scheduling Policy	Personnalisez la stratégie de planification des ressources du conteneur en fonction de vos scénarios métier et des caractéristiques de la tâche : Intelligent : Les tâches GPU sont consolidées sur le moins de nœuds GPU possible, tandis que les tâches CPU sont réparties sur les nœuds CPU. Il s'agit de la stratégie par défaut. Centralized : Les tâches sont consolidées sur le moins de nœuds possible. Cette stratégie aide à réduire la fragmentation des ressources et est idéale pour l'entraînement de modèles GPU. Spread : Les tâches sont réparties sur plusieurs nœuds. Cette stratégie améliore le taux de succès de sortie de file d'attente des tâches et est idéale pour les tâches CPU distribuées.

Remarque

DLC ne prend pas en charge la modification directe du type d'instance d'une tâche soumise. Pour changer le type d'instance (par exemple, pour passer à une instance prenant en charge le réseau haute performance eRDMA, telle que ecs.ebmgn8v.48xlarge), utilisez la fonctionnalité Clone Job pour créer une nouvelle tâche, sélectionnez le type d'instance cible et soumettez-la. La plateforme active automatiquement le réseau haute performance et configure les paramètres liés à NCCL. Pour modifier le pilote NVIDIA et la version CUDA d'une instance, utilisez la fonctionnalité de configuration d'instance pour changer la version du pilote (par exemple, vers la version 580). La plateforme télécharge automatiquement l'image DLC correspondante en fonction de la nouvelle configuration pour mettre à jour l'environnement d'exécution, complétant ainsi le changement de pilote, la mise à niveau CUDA ou le remplacement du pilote GPU.

Développer pour plus de paramètres : durée d'exécution maximale, période de rétention, paramètres avancés du framework

Maximum Duration	Définissez la durée maximale pendant laquelle une tâche peut s'exécuter. Les tâches dépassant cette durée sont automatiquement arrêtées. Valeur par défaut : 30 jours.
Retention Period	Configurez la durée de conservation des tâches terminées ou ayant échoué. Notez que la conservation continue de consommer des ressources. Les tâches dépassant cette durée sont supprimées. Important Les tâches DLC supprimées ne peuvent pas être restaurées. Procédez avec prudence.
Start Developer Machine	Lorsque la source de ressources est un quota de ressources, lancez une instance DSW pour le débogage en ligne. Dans la zone de liste des instances de la page de vue d'ensemble de la tâche, cliquez sur DSW dans la colonne Actions pour accéder à l'instance.
Advanced Framework Configuration	Pour la liste des paramètres configurables et leurs valeurs, consultez Liste des paramètres avancés. Les paramètres `ReleaseResourcePolicy`, `EnableNvidiaIBGDA`, `EnableNvidiaGDRCopy`, `EnablePaiNUMACoreBinding` et `EnableResourcePreCheck` sont pris en charge par tous les frameworks. Lorsque le framework est PyTorch, les paramètres pris en charge sont : `createSvcForAllWorkers`, `customPortList` et `customPortNumPerWorker`. Important Étant donné que les ressources Lingjun ne fournissent pas de capacité de port personnalisé, le paramètre customPortNumPerWorker n'est pas pris en charge lors de la soumission de tâches DLC avec des ressources Lingjun. Lorsque le framework est Ray, les paramètres pris en charge sont : `RayRuntimeEnv`, `RayRedisAddress`, `RayRedisUsername`, `RayRedisPassword`, `RaySubmitterBackoffLimit` et `RayObjectStoreMemoryBytes`. Notez que les variables d'environnement et les configurations de bibliothèques tierces seront remplacées par la configuration RayRuntimeEnv. Les formats de configuration suivants sont pris en charge : Texte brut : Configurez sous forme de chaîne séparée par des virgules (,) où chaque entrée suit le format `key=value`. La clé est un paramètre avancé pris en charge et la valeur est la valeur correspondante du paramètre. JSON Scénarios de configuration typiques : Scénario 1 : Configuration avancée PyTorch Les paramètres de configuration avancée permettent d'établir une connectivité réseau entre les Workers, autorisant des approches d'entraînement plus flexibles. Par exemple, utilisez les ports exposés supplémentaires pour démarrer un framework comme Ray à l'intérieur du conteneur DLC et le combiner avec PyTorch pour un entraînement distribué avancé. Exemple de configuration : `createSvcForAllWorkers=true,customPortNumPerWorker=100` Utilisez ensuite la Startup Command pour configurer les variables d'environnement `$JOB_NAME` et `$CUSTOM_PORTS` afin d'obtenir le nom de domaine et les numéros de port disponibles, puis démarrer et vous connecter à des frameworks comme Ray. Scénario 2 : Configurer manuellement RayRuntimeEnv pour le framework Ray (y compris les dépendances et les variables d'environnement) Exemple de configuration : `{"RayRuntimeEnv": "{pip: requirements.txt, env_vars: {key: value}}"}` Scénario 3 : Politique de libération des ressources personnalisée Actuellement, la seule politique de libération prise en charge est pod-exit, qui libère automatiquement les ressources lorsque votre Pod se termine. Exemple de configuration : `{ "ReleaseResourcePolicy": "pod-exit" }`

Configuration VPC

Si aucun VPC n'est configuré, le réseau public et la passerelle publique sont utilisés. Étant donné que la passerelle publique dispose d'une bande passante limitée, les tâches peuvent subir des ralentissements ou ne pas s'exécuter correctement.
Configurer un VPC et sélectionner le vSwitch et le groupe de sécurité correspondants améliore la bande passante réseau, la stabilité et la sécurité. Le cluster exécutant vos tâches peut également accéder directement aux services au sein de ce VPC.
Important
- Lors de l'utilisation d'un VPC, assurez-vous que les instances du groupe de ressources de la tâche, le stockage des jeux de données (OSS) et le référentiel de code se trouvent tous dans le même VPC et la même région, et que la connectivité réseau est établie.
- Lors de l'utilisation d'un jeu de données CPFS, configurez un VPC correspondant au VPC du CPFS. Sinon, la tâche d'entraînement DLC soumise risque de rester bloquée longtemps à l'état Preparing environment.
- Lors de la soumission de tâches DLC utilisant des ressources spot Lingjun, configurez un VPC.
De plus, configurez l'Internet Access Gateway. Les deux options suivantes sont prises en charge :
- Public Gateway : La bande passante est limitée. En période de forte concurrence ou lors du téléchargement de fichiers volumineux, la vitesse du réseau peut ne pas répondre à la demande.
- Private Gateway : Pour contourner la limitation de bande passante de la passerelle publique, créez une passerelle NAT dans le VPC DLC, associez une EIP et configurez des entrées SNAT. Pour plus de détails, consultez Améliorer l'accès Internet avec une passerelle privée.

Tolérance aux pannes et diagnostics

Paramètre	Description
Automatic Fault Tolerance	Après avoir activé la fonctionnalité Automatic Fault Tolerance et configuré les paramètres pertinents, le système fournit des capacités de surveillance et de contrôle des tâches. Il détecte les erreurs au niveau algorithmique en temps réel et prend des mesures correctives, améliorant ainsi l'utilisation des GPU. Pour plus de détails, consultez AIMaster : Moteur élastique de tolérance aux pannes automatique. Remarque Lorsque la tolérance aux pannes automatique est activée, le système lance une instance AIMaster parallèlement aux instances de la tâche, ce qui consomme des ressources de calcul supplémentaires. Détails de l'utilisation des ressources de l'instance AIMaster : Quota de ressources : 1 cœur CPU et 1 GiB de mémoire. Ressources publiques : Utilise le type d'instance ecs.c6.large.
Sanity Check	Après l'activation de la fonctionnalité Sanity Check, le contrôle de santé inspecte minutieusement les ressources impliquées dans l'entraînement, isole automatiquement les nœuds défectueux et déclenche des opérations automatisées en arrière-plan. Cela réduit efficacement la probabilité de problèmes lors des premières étapes de l'entraînement et améliore le taux de réussite. Pour plus de détails, consultez SanityCheck : Contrôles de santé du calcul. Remarque La fonctionnalité de contrôle de santé n'est prise en charge que pour les tâches d'entraînement PyTorch soumises avec des quotas de ressources Lingjun et lorsque le nombre de GPU est supérieur à 0.

Rôles et permissions

La configuration du rôle RAM d'instance est décrite ci-dessous. Pour plus de détails, consultez Configurer un rôle RAM pour DLC.

Rôle RAM d'instance	Description
Default Role of PAI	Fonctionne sur la base du rôle de service AliyunPAIDLCDefaultRole, qui n'a accès qu'à MaxCompute et OSS, avec des permissions plus granulaires. Identifiants temporaires délivrés sur la base du rôle par défaut PAI : Lors de l'accès aux tables MaxCompute, il dispose des mêmes permissions que le propriétaire de l'instance DLC. Lors de l'accès à OSS, il ne peut accéder qu'au bucket OSS par défaut configuré pour l'espace de travail actuel.
Custom Role	Sélectionnez ou spécifiez un rôle RAM personnalisé. Lors de l'accès aux services cloud depuis l'instance à l'aide d'identifiants temporaires STS, les permissions sont cohérentes avec celles du rôle personnalisé.
Does Not Associate Role	Aucun rôle RAM n'est associé à la tâche DLC. Il s'agit de l'option par défaut.

Documentation connexe

Consultez les informations de base sur la tâche, les vues des ressources et les journaux d'opérations. Pour plus de détails, reportez-vous à Détails de l'entraînement.
Consultez les détails de facturation pour l'exécution de la tâche. Pour plus de détails, reportez-vous à Détails de facturation.
Pour les problèmes courants liés aux tâches DLC et leurs solutions, consultez FAQ sur DLC.
Pour les cas d'utilisation de DLC, consultez Cas d'utilisation DLC.

FAQ

Q : Que faire si j'obtiens une erreur BadRequest concernant la sélection d'une source de données NAS avec une cible de montage lors de la création d'une tâche d'entraînement ?

Cette erreur survient lorsque la source de données NAS ne possède pas de cible de montage. Créez une nouvelle cible de montage dans la console NAS, puis sélectionnez-la comme source de données dans la configuration Mount dataset ou Mount storage lors de la création de la tâche d'entraînement, et resoumettez la tâche.

Q : Les tâches d'entraînement DLC peuvent-elles exporter des métriques vers Weights & Biases (W&B) ?

Oui, DLC prend en charge l'exportation des métriques d'entraînement vers W&B, mais les conditions préalables suivantes doivent être remplies :

Connectivité réseau : Assurez-vous que les nœuds d'entraînement PAI peuvent accéder à l'endpoint public api.wandb.ai. Si vous utilisez un VPC, configurez une passerelle NAT.
Gestion des clés : Injectez la clé API W&B via des variables d'environnement. Ne la codez pas en dur dans votre code.
Conformité : Téléchargez uniquement des métriques scalaires non sensibles. Ne téléchargez pas de données brutes ou de détails sensibles sur le modèle.

Q : Une tâche DLC ayant échoué apparaît-elle toujours dans la liste des tâches ?

Son apparition dépend de la raison de l'échec :

Les tâches qui échouent en raison de ressources insuffisantes apparaissent temporairement dans la liste des tâches de la console DLC et sont supprimées après effacement.
Lorsque l'API renvoie directement une erreur (avec un RequestID) en raison de paramètres de requête invalides, aucun enregistrement n'est conservé dans la liste des tâches. Le message d'erreur s'affiche uniquement sur la page d'opération.

Q : Que faire si je vois un message « protection de sécurité du compte déclenchée » ou « allocation de ressources suspendue » lors de la création d'une tâche DLC ?

Ce message est généralement déclenché par des politiques de contrôle des risques du compte. Utilisez l'outil de diagnostic en libre-service d'Alibaba Cloud (https://smartservice.console.alibabacloud.com/service/self-service-center/search?questionId=27591) pour diagnostiquer pourquoi le paiement ou l'allocation de ressources ne peut pas se poursuivre, et soumettez une demande de recours. Une fois le recours approuvé, vous pourrez réessayer de créer la tâche.

Annexe

Créer une tâche à l'aide du SDK ou de la CLI

Python SDK

Étape 1 : Installer l'outil Alibaba Cloud Credentials

Lorsque vous appelez OpenAPI à l'aide d'un SDK Alibaba Cloud pour gérer des ressources, installez l'outil Credentials pour configurer vos identifiants. Prérequis :

Version Python >= 3,7.
Utilisez les SDK Alibaba Cloud V2.0.

pip install alibabacloud_credentials

Étape 2 : Obtenir l'AccessKey de votre compte

Cet exemple utilise les informations AccessKey (AK) pour configurer les identifiants d'accès. Pour éviter toute fuite d'identifiants, nous vous recommandons de stocker votre AccessKey dans des variables d'environnement. Les noms des variables d'environnement pour l'ID et le secret sont ALIBABA_CLOUD_ACCESS_KEY_ID et ALIBABA_CLOUD_ACCESS_KEY_SECRET.

Pour savoir comment obtenir un AccessKey, consultez Créer un AccessKey.
Pour savoir comment configurer des variables d'environnement, consultez Configurer des variables d'environnement.
Pour d'autres méthodes de configuration des identifiants, consultez Installer l'outil Credentials.

Étape 3 : Installer le SDK Python

Installez le SDK de l'espace de travail.

pip install alibabacloud_aiworkspace20210204==3.0.1

Installez le SDK DLC.

pip install alibabacloud_pai_dlc20201203==1.4.17

Étape 4 : Soumettre une tâche

Soumettre une tâche en utilisant des ressources publiques

L'exemple de code suivant montre comment créer et soumettre une tâche :

Exemple de code pour créer et soumettre une tâche

#!/usr/bin/env python3

from __future__ import print_function

import json
import time

from alibabacloud_tea_openapi.models import Config
from alibabacloud_credentials.client import Client as CredClient
from alibabacloud_pai_dlc20201203.client import Client as DLCClient
from alibabacloud_pai_dlc20201203.models import (
    ListJobsRequest,
    ListEcsSpecsRequest,
    CreateJobRequest,
    GetJobRequest,
)

from alibabacloud_aiworkspace20210204.client import Client as AIWorkspaceClient
from alibabacloud_aiworkspace20210204.models import (
    ListWorkspacesRequest,
    CreateDatasetRequest,
    ListDatasetsRequest,
    ListImagesRequest,
    ListCodeSourcesRequest
)

def create_nas_dataset(client, region, workspace_id, name,
                       nas_id, nas_path, mount_path):
    '''Create a NAS dataset.
    '''
    response = client.create_dataset(CreateDatasetRequest(
        workspace_id=workspace_id,
        name=name,
        data_type='COMMON',
        data_source_type='NAS',
        property='DIRECTORY',
        uri=f'nas://{nas_id}.{region}{nas_path}',
        accessibility='PRIVATE',
        source_type='USER',
        options=json.dumps({
            'mountPath': mount_path
        })
    ))
    return response.body.dataset_id

def create_oss_dataset(client, region, workspace_id, name,
                       oss_bucket, oss_endpoint, oss_path, mount_path):
    '''Create an OSS dataset.
    '''
    response = client.create_dataset(CreateDatasetRequest(
        workspace_id=workspace_id,
        name=name,
        data_type='COMMON',
        data_source_type='OSS',
        property='DIRECTORY',
        uri=f'oss://{oss_bucket}.{oss_endpoint}{oss_path}',
        accessibility='PRIVATE',
        source_type='USER',
        options=json.dumps({
            'mountPath': mount_path
        })
    ))
    return response.body.dataset_id

def wait_for_job_to_terminate(client, job_id):
    while True:
        job = client.get_job(job_id, GetJobRequest()).body
        print('job({}) is {}'.format(job_id, job.status))
        if job.status in ('Succeeded', 'Failed', 'Stopped'):
            return job.status
        time.sleep(5)
    return None

def main():

    # Please make sure that your primary account has authorized DLC and has sufficient permissions.
    region_id = 'cn-hangzhou'
    # The Alibaba Cloud account AccessKey has access permissions to all APIs. It is recommended to use RAM users for API access or daily operations and maintenance.
    # It is highly recommended not to save AccessKey ID and AccessKey Secret directly in the project code to prevent leak risks, which could threaten the security of all resources under your account.
    # This example uses the Credentials SDK to read the AccessKey from environment variables by default for identity authentication.
    cred = CredClient()

    # 1. create client;
    workspace_client = AIWorkspaceClient(
        config=Config(
            credential=cred,
            region_id=region_id,
            endpoint="aiworkspace.{}.aliyuncs.com".format(region_id),
        )
    )

    dlc_client = DLCClient(
         config=Config(
            credential=cred,
            region_id=region_id,
            endpoint='pai-dlc.{}.aliyuncs.com'.format(region_id),
         )
    )

    print('------- Workspaces -----------')
    # Get the list of workspaces. You can also specify the workspace name you created in the workspace_name parameter.
    workspaces = workspace_client.list_workspaces(ListWorkspacesRequest(
        page_number=1, page_size=1, workspace_name='',
        module_list='PAI'
    ))
    for workspace in workspaces.body.workspaces:
        print(workspace.workspace_name, workspace.workspace_id,
              workspace.status, workspace.creator)

    if len(workspaces.body.workspaces) == 0:
        raise RuntimeError('found no workspaces')

    workspace_id = workspaces.body.workspaces[0].workspace_id

    print('------- Images ------------')
    # Get the list of images.
    images = workspace_client.list_images(ListImagesRequest(
        labels=','.join(['system.supported.dlc=true',
                         'system.framework=Tensorflow 1.15',
                         'system.pythonVersion=3.6',
                         'system.chipType=CPU'])))
    for image in images.body.images:
        print(json.dumps(image.to_map(), indent=2))

    image_uri = images.body.images[0].image_uri

    print('------- Datasets ----------')
    # Get the dataset.
    datasets = workspace_client.list_datasets(ListDatasetsRequest(
        workspace_id=workspace_id,
        name='example-nas-data', properties='DIRECTORY'))
    for dataset in datasets.body.datasets:
        print(dataset.name, dataset.dataset_id, dataset.uri, dataset.options)

    if len(datasets.body.datasets) == 0:
        # Create the dataset if the current dataset does not exist.
        dataset_id = create_nas_dataset(
            client=workspace_client,
            region=region_id,
            workspace_id=workspace_id,
            name='example-nas-data',
            # NAS file system ID.
            # General-purpose NAS: 31a8e4****.
            # Extreme NAS: Must start with "extreme-", e.g., extreme-0015****.
            # CPFS: Must start with "cpfs-", e.g., cpfs-125487****.
            nas_id='***',
            nas_path='/',
            mount_path='/mnt/data/nas')
        print('create dataset with id: {}'.format(dataset_id))
    else:
        dataset_id = datasets.body.datasets[0].dataset_id

    print('------- Code Sources ----------')
    # Get the list of code sources.
    code_sources = workspace_client.list_code_sources(ListCodeSourcesRequest(
        workspace_id=workspace_id))
    for code_source in code_sources.body.code_sources:
        print(code_source.display_name, code_source.code_source_id, code_source.code_repo)

    print('-------- ECS SPECS ----------')
    # Get the list of ECS specifications for DLC.
    ecs_specs = dlc_client.list_ecs_specs(ListEcsSpecsRequest(page_size=100, sort_by='Memory', order='asc'))
    for spec in ecs_specs.body.ecs_specs:
        print(spec.instance_type, spec.cpu, spec.memory, spec.memory, spec.gpu_type)

    print('-------- Create Job ----------')
    # Create a DLC job.
    create_job_resp = dlc_client.create_job(CreateJobRequest().from_map({
        'WorkspaceId': workspace_id,
        'DisplayName': 'sample-dlc-job',
        'JobType': 'TFJob',
        'JobSpecs': [
            {
                "Type": "Worker",
                "Image": image_uri,
                "PodCount": 1,
                "EcsSpec": ecs_specs.body.ecs_specs[0].instance_type,
            },
        ],
        "UserCommand": "echo 'Hello World' && ls -R /mnt/data/ && sleep 30 && echo 'DONE'",
        'DataSources': [
            {
                "DataSourceId": dataset_id,
            },
        ],
    }))
    job_id = create_job_resp.body.job_id

    wait_for_job_to_terminate(dlc_client, job_id)

    print('-------- List Jobs ----------')
    # Get the list of DLC jobs.
    jobs = dlc_client.list_jobs(ListJobsRequest(
        workspace_id=workspace_id,
        page_number=1,
        page_size=10,
    ))
    for job in jobs.body.jobs:
        print(job.display_name, job.job_id, job.workspace_name,
              job.status, job.job_type)
    pass

if __name__ == '__main__':
    main()

Soumettre une tâche en utilisant un quota de ressources par abonnement

Connectez-vous à la console PAI.
Consultez l'ID de l'espace de travail : Dans le volet de navigation de gauche, cliquez sur Workspace List. Trouvez l'espace de travail cible, cliquez sur l'icône ⓘ à côté de son nom, puis consultez et copiez l'Workspace ID dans le panneau d'informations qui s'affiche.
Consultez l'ID du quota de ressources de votre groupe de ressources dédié. Dans le volet de navigation de gauche, choisissez AI Computing Resources > Resource Quota. Cliquez sur l'onglet General Computing Resources, et obtenez l'ID du quota de la cible dans la colonne Name/ID de la liste des quotas de ressources.

Utilisez le code suivant pour créer et soumettre une tâche. Pour la liste des images publiques utilisables, consultez Étape 2 : Préparer une image.

from alibabacloud_pai_dlc20201203.client import Client
from alibabacloud_credentials.client import Client as CredClient
from alibabacloud_tea_openapi.models import Config
from alibabacloud_pai_dlc20201203.models import (
    CreateJobRequest,
    JobSpec,
    ResourceConfig, GetJobRequest
)

# Initialize a Client to access the DLC API.
region = 'cn-hangzhou'
# The Alibaba Cloud account AccessKey has access permissions to all APIs. It is recommended to use RAM users for API access or daily operations and maintenance.
# It is highly recommended not to save AccessKey ID and AccessKey Secret directly in the project code to prevent leak risks, which could threaten the security of all resources under your account.
# This example uses the Credentials SDK to read the AccessKey from environment variables by default for identity authentication.
cred = CredClient()
client = Client(
    config=Config(
        credential=cred,
        region_id=region,
        endpoint=f'pai-dlc.{region}.aliyuncs.com',
    )
)

# Declare the resource configuration for the job. For image selection, refer to the public image list in the documentation, or you can pass in your own image address.
spec = JobSpec(
    type='Worker',
    image=f'registry-vpc.cn-hangzhou.aliyuncs.com/pai-dlc/tensorflow-training:1.15-cpu-py36-ubuntu18.04',
    pod_count=1,
    resource_config=ResourceConfig(cpu='1', memory='2Gi')
)

# Declare the execution content of the job.
req = CreateJobRequest(
        resource_id='<Replace with your own resource quota ID>',
        workspace_id='<Replace with your own WorkspaceID>',
        display_name='sample-dlc-job',
        job_type='TFJob',
        job_specs=[spec],
        user_command='echo "Hello World"',
)

# Submit the job.
response = client.create_job(req)
# Get the job ID.
job_id = response.body.job_id

# Query the job status.
job = client.get_job(job_id, GetJobRequest()).body
print('job status:', job.status)

# View the command executed by the job.
job.user_command

Soumettre une tâche en utilisant des ressources spot

SpotDiscountLimit (Remise Spot)

#!/usr/bin/env python3

from alibabacloud_tea_openapi.models import Config
from alibabacloud_credentials.client import Client as CredClient

from alibabacloud_pai_dlc20201203.client import Client as DLCClient
from alibabacloud_pai_dlc20201203.models import CreateJobRequest

region_id = '<region-id>'  # The region ID where the DLC job is located, for example, cn-hangzhou for China (Hangzhou).
cred = CredClient()
workspace_id = '12****'  # The workspace ID where the DLC job is located.

dlc_client = DLCClient(
    Config(credential=cred,
           region_id=region_id,
           endpoint='pai-dlc.{}.aliyuncs.com'.format(region_id),
           protocol='http'))

create_job_resp = dlc_client.create_job(CreateJobRequest().from_map({
    'WorkspaceId': workspace_id,
    'DisplayName': 'sample-spot-job',
    'JobType': 'PyTorchJob',
    'JobSpecs': [
        {
            "Type": "Worker",
            "Image": "dsw-registry-vpc.<region-id>.cr.aliyuncs.com/pai/pytorch-training:1.12-cpu-py39-ubuntu20.04",
            "PodCount": 1,
            "EcsSpec": 'ecs.g7.xlarge',
            "SpotSpec": {
                "SpotStrategy": "SpotWithPriceLimit",
                "SpotDiscountLimit": 0.4,
            }
        },
    ],
    'UserVpc': {
        "VpcId": "vpc-0jlq8l7qech3m2ta2****",
        "SwitchId": "vsw-0jlc46eg4k3pivwpz8****",
        "SecurityGroupId": "sg-0jl4bd9wwh5auei9****",
    },
    "UserCommand": "echo 'Hello World' && ls -R /mnt/data/ && sleep 30 && echo 'DONE'",
}))
job_id = create_job_resp.body.job_id
print(f'jobId is {job_id}')

SpotPriceLimit (Prix Spot)

#!/usr/bin/env python3

from alibabacloud_tea_openapi.models import Config
from alibabacloud_credentials.client import Client as CredClient

from alibabacloud_pai_dlc20201203.client import Client as DLCClient
from alibabacloud_pai_dlc20201203.models import CreateJobRequest

# The region ID where the DLC job is located, for example, cn-hangzhou.
region_id = '<region-id>'
# Initialize the credentials client to handle authentication.
cred = CredClient()
# The workspace ID where the DLC job is located.
workspace_id = '12****'

# Initialize the DLC client with the required configuration.
dlc_client = DLCClient(
    Config(credential=cred,
           region_id=region_id,
           endpoint='pai-dlc.{}.aliyuncs.com'.format(region_id),
           protocol='http'))

# Create a DLC job with spot instance configuration (SpotWithPriceLimit).
create_job_resp = dlc_client.create_job(CreateJobRequest().from_map({
    'WorkspaceId': workspace_id,
    'DisplayName': 'sample-spot-job',
    'JobType': 'PyTorchJob',
    'JobSpecs': [
        {
            "Type": "Worker",
            "Image": "dsw-registry-vpc.<region-id>.cr.aliyuncs.com/pai/pytorch-training:1.12-cpu-py39-ubuntu20.04",
            "PodCount": 1,
            "EcsSpec": 'ecs.g7.xlarge',
            "SpotSpec": {
                "SpotStrategy": "SpotWithPriceLimit",
                "SpotPriceLimit": 0.011,
            }
        },
    ],
    'UserVpc': {
        "VpcId": "vpc-0jlq8l7qech3m2ta2****",
        "SwitchId": "vsw-0jlc46eg4k3pivwpz8****",
        "SecurityGroupId": "sg-0jl4bd9wwh5auei9****",
    },
    "UserCommand": "echo 'Hello World' && ls -R /mnt/data/ && sleep 30 && echo 'DONE'",
}))

# Get and print the created job ID.
job_id = create_job_resp.body.job_id
print(f'jobId is {job_id}')

Les configurations clés sont décrites ci-dessous :

Paramètre	Description
SpotStrategy	Stratégie d'enchère. Le type d'enchère ne prend effet que lorsque ce paramètre est défini sur SpotWithPriceLimit.
SpotDiscountLimit	Utilise la remise spot comme méthode d'enchère. Remarque SpotDiscountLimit et SpotPriceLimit ne peuvent pas être définis simultanément. Pour les ressources spot Lingjun, seul SpotDiscountLimit est pris en charge comme type d'enchère.
SpotPriceLimit	Utilise le prix spot comme méthode d'enchère.
UserVpc	Obligatoire lorsque vous soumettez une tâche en utilisant des ressources spot Lingjun. Configurez le VPC, le vSwitch et l'ID du groupe de sécurité de la région où la tâche s'exécute.

Remarque

Lorsque vous créez une tâche DLC en appelant une API ou en utilisant un SDK (createJob), vous ne pouvez pas charger directement des fichiers de code locaux. Chargez d'abord votre code dans l'un des emplacements suivants :

Référentiel Git : Créez une configuration de code dans AI Assets Management et liez-la à l'URL du référentiel Git.
Stockage OSS : Après avoir chargé le code dans OSS, rendez-le disponible pour la tâche en le montant comme un jeu de données.
Image personnalisée : Empaquetez le code dans une image Docker.

Ligne de commande

Étape 1 : Télécharger le client et compléter l'authentification utilisateur

Téléchargez l'outil client Linux 64 bits ou Mac selon votre système d'exploitation, et complétez l'authentification utilisateur. Pour plus de détails, consultez Avant de commencer.

Étape 2 : Soumettre une tâche

Connectez-vous à la console PAI.
Suivez ces instructions pour afficher votre ID d'espace de travail (WorkspaceID) sur la page de liste des espaces de travail.

Dans le volet de navigation de gauche, cliquez sur Workspace List. Trouvez l'espace de travail cible, cliquez sur l'icône ⓘ à droite de son nom, et consultez l'Workspace ID dans le panneau d'informations qui s'affiche.
Suivez ces instructions pour afficher votre ID de quota de ressources.

Dans le volet de navigation de gauche, choisissez AI Computing Resources > Resource Quota. Sélectionnez l'onglet correspondant à votre type de ressource cible (tel que General Computing Resources), et obtenez l'ID du quota de ressources dans la colonne Name/ID de la liste des quotas de ressources.

Préparez un fichier de paramètres basé sur le contenu suivant tfjob.params. Pour plus d'informations sur la configuration du fichier de paramètres, consultez Commandes utilisées pour soumettre des tâches.

name=test_cli_tfjob_001
workers=1
worker_cpu=4
worker_gpu=0
worker_memory=4Gi
worker_shared_memory=4Gi
worker_image=registry-vpc.cn-beijing.aliyuncs.com/pai-dlc/tensorflow-training:1.12.2PAI-cpu-py27-ubuntu16.04
command=echo good && sleep 120
resource_id=<your_resource_quota_id>
workspace_id=<your_workspace_id>

Utilisez l'exemple de code suivant pour transmettre le paramètre params_file. Cela soumet la tâche DLC à l'espace de travail et au quota de ressources spécifiés.
```
./dlc submit tfjob --job_file  ./tfjob.params
```
Utilisez la commande suivante pour afficher la tâche DLC que vous avez soumise.
```
./dlc get job <jobID>
```

Liste des paramètres avancés

Paramètre (clé)	Types de frameworks pris en charge	Description	Valeur du paramètre
`ReleaseResourcePolicy`	TOUS	Configure une politique de libération des ressources personnalisée. Ce paramètre est facultatif. Si vous ne le configurez pas, toutes les ressources Pod sont libérées à la fin de la tâche. Si vous le configurez, la seule valeur prise en charge est pod-exit, qui libère les ressources d'un Pod lorsque celui-ci se termine.	pod-exit
`EnableJumboFrame`	TOUS	Spécifie s'il faut activer les trames jumbo. Ce paramètre n'est pris en charge que par AI Computing Resources - General Computing 2.0. La valeur par défaut est false, ce qui signifie désactivé.	`true` ou `false`
`EnableNvidiaIBGDA`	TOUS	Spécifie s'il faut activer IBGDA lorsque le pilote GPU est chargé.	`true` ou `false`
`EnableNvidiaGDRCopy`	TOUS	Spécifie s'il faut installer le module noyau GDRCopy. La version actuellement installée est la 2.4.4.	`true` ou `false`
`EnablePaiNUMACoreBinding`	TOUS	Spécifie s'il faut activer NUMA.	`true` ou `false`
`EnableResourcePreCheck`	TOUS	Lorsque vous soumettez une tâche, ce paramètre vérifie si les ressources totales (spécifications de nœud) dans le quota correspondent aux spécifications de tous les rôles de la tâche.	`true` ou `false`
`createSvcForAllWorkers`	PyTorch	Spécifie s'il faut autoriser la connectivité réseau entre les workers. Si défini sur `true`, tous les workers PyTorch peuvent communiquer entre eux via le réseau. Si défini sur `false` ou laissé non configuré, seul le maître est accessible par défaut. Une fois cette option activée, le nom de domaine de chaque worker correspond au nom du worker, tel que `dlcxxxxx-master-0`. Le nom de la tâche (`dlcxxxxx`) est ensuite transmis au worker via la variable d'environnement `JOB_NAME`. Vous pouvez alors déterminer le nom de domaine du worker spécifique auquel vous souhaitez accéder.	`true` ou `false`
`customPortList`	PyTorch	Vous permet de définir les ports réseau exposés sur chaque worker. Vous pouvez utiliser ce paramètre conjointement avec `createSvcForAllWorkers` pour activer la connectivité réseau entre les workers. Si non configuré, seul le port 23456 est exposé sur le maître par défaut. Assurez-vous de ne pas inclure le port 23456 dans cette liste de ports personnalisés. Important Ce paramètre est mutuellement exclusif avec `customPortNumPerWorker`. Ne les définissez pas simultanément.	Un ensemble de chaînes séparées par des points-virgules, où chaque chaîne est un numéro de port unique ou une plage de ports reliée par un trait d'union, tel que `10000;10001-10010` (qui est converti en 11 numéros de port consécutifs de 10000 à 10010).
`customPortNumPerWorker`	PyTorch	Vous permet de demander un nombre de ports réseau à exposer sur chaque worker. Vous pouvez utiliser ce paramètre conjointement avec `createSvcForAllWorkers` pour activer la connectivité réseau entre les workers. Si non configuré, seul le port 23456 est exposé sur le maître par défaut. DLC attribue aléatoirement des ports aux workers en fonction du nombre de ports défini dans le paramètre. Les numéros de port attribués sont transmis au worker via la variable d'environnement `CUSTOM_PORTS` pour consultation. Le format est un ensemble de numéros de port séparés par des points-virgules. Important Ce paramètre est mutuellement exclusif avec `customPortList`. Ne les définissez pas simultanément. Les ressources de calcul Lingjun ne prennent pas en charge les ports personnalisés. Par conséquent, lorsque vous soumettez une tâche DLC en utilisant des ressources de calcul Lingjun, le paramètre customPortNumPerWorker n'est pas pris en charge.	Entier (maximum : 65536)
`RayRuntimeEnv`	Ray	Lorsque le framework est Ray, vous pouvez configurer manuellement RayRuntimeEnv pour définir l'environnement d'exécution. Important Les variables d'environnement et les configurations de bibliothèques tierces sont remplacées par cette configuration.	Configurer les variables d'environnement et les bibliothèques tierces (`{pip: requirements.txt, env_vars: {key: value}}`)
`RayRedisAddress`	Ray	Adresse Redis GCS externe.	Chaîne
`RayRedisUsername`	Ray	Nom d'utilisateur Redis GCS externe.	Chaîne
`RayRedisPassword`	Ray	Mot de passe Redis GCS externe.	Chaîne
`RaySubmitterBackoffLimit`	Ray	Nombre de tentatives pour le soumetteur.	Entier positif (int)
`RayObjectStoreMemoryBytes`	Ray	Configure la mémoire partagée pour un nœud. Par exemple, pour configurer 1 GiB de mémoire partagée pour chaque nœud, utilisez la configuration suivante : `{ "RayObjectStoreMemoryBytes": "1073741824" }`	Entier positif (int)