PAI-DLC vous 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, ce qui élimine le besoin d'acheter manuellement des machines ou de configurer les environnements d'exécution. Il prend en charge TensorFlow, PyTorch et d'autres frameworks d'apprentissage profond populaires, avec des options de configuration des ressources flexibles.
Démarrage rapide
En prenant la reconnaissance de chiffres manuscrits MNIST comme exemple, ce guide vous accompagne dans la réalisation d'un entraînement sur nœud unique avec un seul GPU et d'un entraînement distribué multi-nœuds avec plusieurs GPUs via DLC. Pour plus de détails, consultez Prise en main de Deep Learning Containers (DLC).
Instructions
Lisez le contenu pour comprendre CE qui doit être communiqué
Rédigez le texte en français À PARTIR DE ZÉRO — oubliez la structure de phrase anglaise
Conservez exactement tout le formatage markdown, les blocs de code, les liens et les images
Balises xref (
<a data-tag="xref" ...>texte</a>) — conservez la balise ENTIERE avec tous ses attributs dans l'ordre et la casse d'origine, traduisez UNIQUEMENT le texte visible entre > etAppliquez strictement toutes les règles linguistiques spécifiques
Appliquez les règles de stopwords avec une tolérance zéro
Utilisez l'impératif dans les étapes numérotées et les listes à puces procédurales
Assurez la cohérence terminologique — un même terme doit avoir la même traduction partout
Variez les débuts de phrase dans les listes/tableaux — aucun début ne doit être répété 3 fois ou plus
-
Renvoyez UNIQUEMENT le document markdown en français, sans explication
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 de l'archivage des tâches par libellé, de l'analyse de la distribution des tâches et du suivi de la consommation des ressources. Les contraintes suivantes s'appliquent :
Contraintes relatives aux clés : Ne doivent pas commencer par
aliyunouacs:. Ne doivent pas contenirhttp://ouhttps://. Longueur maximale : 128 caractères. Les clés ne peuvent contenir que des lettres, des chiffres, des traits d'union (-), des traits de soulignement (_) et des points (.).Contraintes relatives aux valeurs : Ne doivent pas contenir
http://ouhttps://. Longueur maximale : 256 caractères. Séparez plusieurs valeurs par des virgules.
Pour obtenir des conseils sur le balisage standardisé, consultez la rubrique Standardiser le balisage pour DLC, DSW et EAS.
Task Description
Utilisez ce champ pour décrire l'objectif, le contexte ou toute autre information relative à 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 dépôt d'images doit être défini comme public, ou l'image doit être stockée dans Alibaba Cloud Container Registry (ACR). Pour plus de détails, consultez la rubrique Images personnalisées.
RemarqueLorsque vous sélectionnez des ressources Lingjun et utilisez une image personnalisée, vous devez installer manuellement les pilotes RDMA pour tirer pleinement parti du réseau haute performance RDMA. Pour plus de détails, consultez la rubrique RDMA : entraînement distribué avec un réseau haute performance.
Image Address : Prend en charge la configuration d'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 dépôt d'images.
Pour améliorer la vitesse de récupération des images, consultez la rubrique Accélération des images.
Mount dataset
Les jeux de données fournissent les fichiers de données nécessaires à l'entraînement des modèles. Les deux types de jeux de données suivants sont pris en charge :
Custom Dataset : Vous pouvez créer un jeu de données personnalisé pour stocker les fichiers de données nécessaires à l'entraînement. Vous pouvez activer le mode Read-only et sélectionner 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. Vous pouvez accéder au jeu de données via ce chemin dans votre code. Pour plus de détails sur la configuration du montage, consultez la rubrique Utiliser le stockage cloud.ImportantSi vous utilisez un jeu de données CPFS, vous devez configurer un VPC pour DLC correspondant au VPC CPFS. Sinon, la tâche soumise peut rester longtemps dans l'état Preparing environment.
Mount storage
Vous pouvez également monter directement des chemins de sources de données pour lire les données requises ou stocker des fichiers intermédiaires et des résultats.
Types de sources de données pris en charge : OSS, General-purpose NAS, Extreme NAS, CPFS et BMCPFS (disponible uniquement avec les ressources Lingjun).
Advanced Settings : Différents types de sources de données prennent en charge des fonctionnalité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.General-purpose NAS 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 la rubrique 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 la rubrique 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 PyTorch et TensorFlow telles que
MASTER_ADDRetWORLD_SIZE. Vous pouvez les référencer en utilisant$VARIABLE_NAME. Exemples de commandes de démarrage :Exécuter Python :
python -c "print('Hello World')"Entraînement distribué multi-nœuds et multi-GPU PyTorch :
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=100Spécifier un chemin de script shell comme commande de démarrage :
/ml/input/config/launch.sh
ImportantLe 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
Environment Variable
Outre les variables d'environnement courantes 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 l'image du conteneur ne contient pas certaines bibliothèques tierces, vous pouvez les ajouter via Third-party Libraries. Deux méthodes sont prises en charge :
Select from List : Saisissez directement les noms des bibliothèques dans la zone de texte ci-dessous. Séparez plusieurs noms de bibliothèques par des espaces, par exemple
griffon numpy pandas.Directory of requirements.txt : Ajoutez les bibliothèques à un fichier requirements.txt, téléchargez-le dans le conteneur DLC via la configuration du code, le jeu de données ou le montage direct, puis spécifiez le chemin du fichier dans le conteneur dans la zone de texte.
Code Builds
Télé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 dépôt Git existant et que vous avez les autorisations d'accès, vous pouvez le lier 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 télécharger les fichiers de code locaux. Après un télé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.
Adapté aux charges de travail avec des tâches peu fréquentes et sans exigences strictes en matière de calendrier. 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 pour augmenter le quota.
Resource Quota : Comprend des ressources de calcul généralistes ou des ressources Lingjun.
Modèle de facturation : Abonnement.
Adapté aux scénarios à fort volume de tâches nécessitant des ressources stables garanties.
Paramètres spéciaux :
Resource Quota : Définissez la quantité de ressources GPU, CPU et autres. Pour savoir comment préparer les quotas de ressources, consultez la rubrique Créer un quota de ressources.
Priority : Indique la priorité d'exécution des tâches exécutées simultanément. Plage de valeurs : [1, 9], où 1 est la priorité la plus basse.
Pré-vérification : Vérifie automatiquement la compatibilité du modèle GPU et de l'image avant la soumission de la tâche, détectant ainsi les erreurs de configuration tôt et évitant les échecs de tâche.
Preemptible Resources :
Modèle de facturation : Paiement à l'utilisation.
Adapté aux scénarios sensibles aux coûts. Le prix des ressources Spot est inférieur à celui du paiement à l'utilisation.
Aucune garantie de disponibilité. Les ressources peuvent ne pas être immédiatement disponibles ou peuvent être récupérées. Pour plus d'informations, consultez la rubrique Utiliser une tâche préemptible.
Framework
Les frameworks et outils d'entraînement d'apprentissage profond suivants sont pris en charge : TensorFlow, PyTorch, ElasticBatch, XGBoost, OneFlow, MPIJob, Ray, Custom, DataJuicer et MPI.
RemarqueLorsque 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
En fonction du Framework sélectionné, vous pouvez configurer les ressources pour les types de nœuds Worker, PS, Chief, Evaluator et GraphLearn. Lors de l'utilisation du framework Ray, vous pouvez cliquer sur Add Role pour personnaliser les rôles Worker, permettant l'exécution mixte de ressources hétérogènes.
Utilisation des ressources publiques : Les paramètres suivants peuvent être configurés :
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 la rubrique Facturation DLC.
Utilisation des quotas de ressources : Vous pouvez configurer 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 des tâches sur des nœuds de calcul spécifiques.
Idle Resources : Lors de l'utilisation de ressources inactives, les tâches peuvent s'exécuter sur la capacité inactive d'autres quotas, améliorant ainsi l'utilisation des ressources. Toutefois, lorsque le quota d'origine a besoin de ces ressources, les tâches inactives sont automatiquement arrêtées et les ressources sont restituées. Pour plus d'informations, consultez la rubrique Utiliser les ressources inactives.
CPU Affinity : Activez l'affinité CPU pour lier les processus à des cœurs CPU spécifiques, réduisant ainsi les échecs de cache et les changements de contexte pour améliorer les performances. Adapté aux scénarios ayant des exigences élevées en matière de performances et de temps réel.
Utilisation des ressources Spot : En plus du nombre de nœuds et du type d'instance, vous pouvez configurer 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 :By discount : 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 d'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.
By price : La plage d'enchère maximale se situe dans la plage de prix du marché.
Scheduling Policy
Vous pouvez personnaliser 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 distribuées 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 permet de 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 les nœuds. Cette stratégie améliore le taux de réussite de la sortie de file d'attente des tâches et est idéale pour les tâches CPU distribuées.
RemarqueDLC 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 la mise en 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 la mise en réseau haute performance et configure les paramètres liés à NCCL. Pour modifier le NVIDIA driver et la version CUDA d'une instance, utilisez la fonctionnalité de configuration de l'instance pour changer la version du pilote (par exemple, vers la version 580). La plateforme récupère 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.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 a une bande passante limitée, les tâches peuvent subir des ralentissements ou ne pas s'exécuter correctement pendant l'exécution.
-
La configuration d'un VPC et la sélection du vSwitch et du groupe de sécurité correspondants améliorent la bande passante, la stabilité et la sécurité du réseau. Le cluster exécutant vos tâches peut également accéder directement aux services au sein de ce VPC.
ImportantLors 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 dépôt de code se trouvent tous dans le même VPC dans la même région, et que la connectivité réseau est établie.
Lors de l'utilisation d'un jeu de données CPFS, vous devez configurer un VPC correspondant au VPC CPFS. Sinon, la tâche d'entraînement DLC soumise peut rester longtemps dans l'état Preparing environment.
Lors de la soumission de tâches DLC utilisant des ressources Spot Lingjun, vous devez configurer un VPC.
De plus, vous pouvez configurer la Internet Access Gateway. Les deux options suivantes sont prises en charge :
Public Gateway : La bande passante est limitée. Pendant les périodes 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 surmonter la limitation de la bande passante de la passerelle publique, vous pouvez créer une passerelle NAT dans le VPC DLC, associer une EIP et configurer des entrées SNAT. Pour plus de détails, consultez la rubrique 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 peut détecter les erreurs au niveau de l'algorithme en temps réel et prendre des mesures correctives, améliorant ainsi l'utilisation des GPU. Pour plus de détails, consultez la rubrique AIMaster : Un moteur de tolérance aux pannes élastique et automatique.
RemarqueLorsque 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 avoir activé la fonctionnalité Sanity Check, la vérification de l'état inspecte minutieusement les ressources impliquées dans l'entraînement, isole automatiquement les nœuds défaillants 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 de l'entraînement. Pour plus de détails, consultez la rubrique SanityCheck : Vérifications de l'état du calcul.
RemarqueLa fonctionnalité de vérification de l'état est prise en charge uniquement 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 autorisations
La configuration du rôle RAM de l'instance est décrite ci-dessous. Pour plus de détails, consultez la rubrique Configurer un rôle RAM pour DLC.
## Documentation connexeRôle RAM de l'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 autorisations plus granulaires. Identifiants temporaires émis sur la base du rôle par défaut PAI :
Lors de l'accès aux tables MaxCompute, il dispose des mêmes autorisations 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 autorisations 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.
Consultez les informations de base de la tâche, les vues des ressources et les journaux d'opérations. Pour plus de détails, reportez-vous à la rubrique Afficher les détails d'une tâche d'entraînement.
Consultez les détails de facturation liés à l'exécution de la tâche. Pour en savoir plus, voir Détails de facturation.
Pour résoudre les problèmes courants rencontrés avec les tâches DLC, consultez la rubrique FAQ sur DLC.
Découvrez les cas d'utilisation de DLC dans la section Cas d'utilisation de DLC.
Connectivité réseau : Assurez-vous que les nœuds d'entraînement PAI peuvent accéder au 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 ni de détails sensibles du modèle.
Les tâches qui échouent en raison d'un manque de ressources apparaissent temporairement dans la liste des tâches de la console DLC et sont supprimées après leur 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.
Version de Python >= 3,7.
Utilisez les SDK Alibaba Cloud V2.0.
Pour savoir comment obtenir une AccessKey, consultez la rubrique Créer une AccessKey.
Pour savoir comment configurer les variables d'environnement, reportez-vous à la section Configurer les variables d'environnement.
Pour découvrir d'autres méthodes de configuration des identifiants, consultez la rubrique Gérer les identifiants d'accès.
Installez le SDK workspace. ``
shell pip install alibabacloud_aiworkspace20210204==3.0.1``Installez le SDK DLC. ``
shell pip install alibabacloud_pai_dlc20201203==1.4.17``#### Soumettre une tâche en utilisant un quota de ressources par abonnementExemple de code pour créer et soumettre une tâche
```python #!/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() ```Connectez-vous à la console PAI.
Consultez l'ID de l'espace de travail : Dans le volet de navigation de gauche, cliquez sur Workspace List. Localisez 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 ressources cible depuis 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 disponibles, reportez-vous à la section Étape 2 : Préparer une image. ``
python 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``SpotDiscountLimit (Remise spot) ``
python #!/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) ``
python #!/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}')``Paramètre
Description
SpotStrategy
La stratégie d'enchères. Le type d'enchère prend effet uniquement 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
Requis lors de la soumission d'une tâche 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.
RemarqueLorsque vous créez une tâche DLC en appelant une API ou en utilisant un SDK (createJob), vous ne pouvez pas télécharger directement des fichiers de code locaux. Téléchargez d'abord votre code à l'un des emplacements suivants :
Dépôt Git : Créez une configuration de code dans AI Assets Management et liez-la à l'URL du dépôt Git.
Stockage OSS : Après avoir téléchargé le code sur OSS, rendez-le disponible pour la tâche en le montant en tant que jeu de données.
Image personnalisée : Emballez le code dans une image Docker.
Ligne de commande
Étape 1 : Télécharger le client et effectuer l'authentification utilisateur
Téléchargez l'outil client Linux 64 bits ou Mac selon votre système d'exploitation, et effectuez l'authentification utilisateur. Pour plus de détails, consultez la rubrique Préparatifs.
Étape 2 : Soumettre une tâche
Connectez-vous à la console PAI.
-
Suivez ces instructions pour afficher l'ID de votre espace de travail (WorkspaceID) sur la page de liste des espaces de travail.
Dans le volet de navigation de gauche, cliquez sur Workspace List. Localisez 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 l'ID de votre 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 depuis 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, reportez-vous à la rubrique Commandes de soumission.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
ReleaseResourcePolicyALL
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
EnableJumboFrameALL
Indique s'il faut activer les trames Jumbo. Ce paramètre est pris en charge uniquement par les ressources de calcul IA - General Computing 2.0. La valeur par défaut est false, ce qui signifie que l'option est désactivée.
trueoufalseEnableNvidiaIBGDAALL
Indique s'il faut activer IBGDA lors du chargement du pilote GPU.
trueoufalseEnableNvidiaGDRCopyALL
Indique s'il faut installer le module noyau GDRCopy. La version actuellement installée est la 2.4.4.
trueoufalseEnablePaiNUMACoreBindingALL
Indique s'il faut activer NUMA.
trueoufalseEnableResourcePreCheckALL
Lorsque vous envoyez une tâche, ce paramètre vérifie si les ressources totales (spécifications des nœuds) dans le quota correspondent aux spécifications de tous les rôles de la tâche.
trueoufalsecreateSvcForAllWorkersPyTorch
Indique s'il faut autoriser la connectivité réseau entre les workers.
Si la valeur est définie sur
true, tous les workers PyTorch peuvent communiquer entre eux via le réseau.Si la valeur est définie sur
falseou laissée non configurée, seul le master est accessible par défaut.
Une fois cette option activée, le nom de domaine de chaque worker correspond au nom du worker, par exemple
dlcxxxxx-master-0. Le nom de la tâche (dlcxxxxx) est ensuite transmis au worker via la variable d'environnementJOB_NAME. Vous pouvez ainsi déterminer le nom de domaine du worker spécifique auquel vous souhaitez accéder.trueoufalsecustomPortListPyTorch
Vous permet de définir les ports réseau exposés sur chaque worker. Utilisez ce paramètre conjointement avec
createSvcForAllWorkerspour activer la connectivité réseau entre les workers.S'il n'est pas configuré, seul le port 23456 est exposé sur le master par défaut. Veillez à ne pas inclure le port 23456 dans cette liste de ports personnalisée.
ImportantCe 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, par exemple
10000;10001-10010(ce qui est converti en 11 numéros de port consécutifs de 10000 à 10010).customPortNumPerWorkerPyTorch
Vous permet de demander un certain nombre de ports réseau à exposer sur chaque worker. Utilisez ce paramètre conjointement avec
createSvcForAllWorkerspour activer la connectivité réseau entre les workers.S'il n'est pas configuré, seul le port 23456 est exposé sur le master 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_PORTSpour consultation. Le format est un ensemble de numéros de port séparés par des points-virgules.ImportantCe 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 envoyez une tâche DLC en utilisant des ressources de calcul Lingjun, le paramètre customPortNumPerWorker n'est pas pris en charge.
Entier (maximum : 65536)
RayRuntimeEnvRay
Lorsque le framework est Ray, vous pouvez configurer manuellement RayRuntimeEnv pour définir l'environnement d'exécution.
ImportantLes variables d'environnement et les configurations de bibliothèques tierces sont remplacées par cette configuration.
Configurez les variables d'environnement et les bibliothèques tierces (
{pip: requirements.txt, env_vars: {key: value}})RayRedisAddressRay
Adresse Redis GCS externe.
Chaîne
RayRedisUsernameRay
Nom d'utilisateur Redis GCS externe.
Chaîne
RayRedisPasswordRay
Mot de passe Redis GCS externe.
Chaîne
RaySubmitterBackoffLimitRay
Nombre de tentatives pour le submitter.
Entier positif (int)
RayObjectStoreMemoryBytesRay
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)