AI distributed training job creation - Platform For AI - Centro de documentación de Alibaba Cloud

PAI-DLC le permite crear rápidamente trabajos de entrenamiento en un solo nodo o distribuidos. Kubernetes aprovisiona automáticamente los nodos de cómputo en segundo plano, lo que elimina la necesidad de comprar máquinas manualmente o configurar entornos de ejecución. Admite TensorFlow, PyTorch y otros framework populares de aprendizaje profundo, con opciones flexibles de configuración de recursos.

Inicio rápido

Con el reconocimiento de dígitos manuscritos MNIST como ejemplo, esta guía le muestra cómo ejecutar entrenamientos en un solo nodo con una GPU y entrenamientos distribuidos en varios nodos con múltiples GPU mediante DLC. Para más detalles, consulte Get started with Deep Learning Containers (DLC).

Referencia de parámetros de la consola

Información básica

Parámetro	Descripción
Job Name	Establezca un nombre fácil de identificar para el trabajo.
Tag	Aplique etiquetas estandarizadas a sus trabajos. Las etiquetas son la base para archivar trabajos por etiqueta, analizar su distribución y rastrear el consumo de recursos. Se aplican las siguientes restricciones: Restricciones de clave: no debe comenzar con `aliyun` ni con `acs:`. No debe contener `http://` ni `https://`. Longitud máxima: 128 caracteres. Las claves solo pueden contener letras, números, guiones (-), guiones bajos (_) y puntos (.). Restricciones de valor: no debe contener `http://` ni `https://`. Longitud máxima: 256 caracteres. Separe varios valores con comas. Para obtener orientación sobre el etiquetado estandarizado, consulte Standardize tagging for DLC, DSW, and EAS.
Task Description	Utilice este campo para describir el propósito, el contexto u otra información relevante del trabajo.

Información del entorno

Parámetro	Descripción
Image Configuration	Además de la opción Alibaba Cloud Image, se admiten los siguientes tipos de imagen: Custom Image: use imágenes personalizadas agregadas a PAI. El repositorio de imágenes debe configurarse como público o la imagen debe almacenarse en Alibaba Cloud Container Registry (ACR). Para más detalles, consulte Custom images. Nota Si selecciona recursos Lingjun y utiliza una imagen personalizada, debe instalar manualmente los controladores RDMA para aprovechar al máximo la red RDMA de alto rendimiento. Para más detalles, consulte RDMA: distributed training with a high-performance network. Image Address: admite la configuración de direcciones de imágenes oficiales o personalizadas con acceso público. Para direcciones de imágenes privadas, haga clic en Enter credentials y configure el nombre de usuario y la contraseña del repositorio de imágenes. Para mejorar la velocidad de descarga de imágenes, consulte Image acceleration.
Mount dataset	Los conjuntos de datos proporcionan los archivos de datos necesarios para el entrenamiento del modelo. Se admiten los dos tipos siguientes: Custom Dataset: puede create a custom dataset para almacenar los archivos de datos necesarios para el entrenamiento. Puede habilitar el modo Read-only y seleccionar una versión del conjunto de datos en la lista de versiones. Public Dataset: PAI proporciona conjuntos de datos públicos integrados que solo admiten montaje de lectura. Mount Path: es la ruta donde se monta el conjunto de datos en el contenedor DLC, por ejemplo, `/mnt/data`. Puede acceder al conjunto de datos mediante esta ruta en su código. Para más detalles sobre la configuración de montaje, consulte Use cloud storage. Importante Si utiliza un conjunto de datos CPFS, debe configurar una VPC para DLC que coincida con la VPC de CPFS. De lo contrario, el trabajo enviado podría permanecer en el estado Preparing environment durante un periodo prolongado.
Mount storage	También puede montar rutas de origen de datos directamente para leer los datos requeridos o almacenar archivos intermedios y de resultados. Tipos de origen de datos compatibles: OSS, General-purpose NAS, Extreme NAS, CPFS y BMCPFS (disponible solo con recursos Lingjun). Advanced Settings: los distintos tipos de origen de datos admiten capacidades específicas mediante configuraciones avanzadas. Por ejemplo: OSS: establezca `{"mountType":"ossfs"}` en la configuración avanzada para montar el almacenamiento de OSS mediante ossfs. General-purpose NAS y CPFS: configure el parámetro nconnect en la configuración avanzada para mejorar el rendimiento de NAS desde el contenedor DLC. Para más detalles, consulte How do I improve NAS performance on Linux?. Por ejemplo, `{"nconnect":"<sample value>"}`, donde `<sample value>` se reemplaza por un número entero positivo específico. Para más información, consulte Use cloud storage.
Startup Command	Establezca el comando de inicio del trabajo. Se admiten comandos de shell. DLC inyecta automáticamente common PyTorch and TensorFlow environment variables como `MASTER_ADDR` y `WORLD_SIZE`. Puede hacer referencia a ellas mediante `$VARIABLE_NAME`. A continuación se muestran ejemplos de comandos de inicio: Ejecutar Python: `python -c "print('Hello World')"` Entrenamiento distribuido de PyTorch en varios nodos y múltiples 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` Especificar la ruta de un script de shell como comando de inicio: `/ml/input/config/launch.sh` Importante La ruta de montaje configurada para el código (como /mnt/data) es la ubicación de sus archivos de código dentro del contenedor DLC. Su comando de inicio debe hacer referencia a los archivos de código mediante esta ruta. Por ejemplo, si la ruta de montaje del código es /mnt/data y su archivo de código es train.py, el comando de inicio debe ser: python /mnt/data/train.py

Expanda para ver más configuraciones: variables de entorno, bibliotecas de terceros y configuración de código

Environment Variable

Además de las common PyTorch and TensorFlow environment variables inyectadas automáticamente, puede proporcionar variables de entorno personalizadas con el formato Key:Value. Se admiten hasta 20 variables de entorno.

Third-party Libraries

Si a la imagen del contenedor le faltan algunas bibliotecas de terceros, puede agregarlas mediante Third-party Libraries. Se admiten dos métodos:

Select from List: introduzca los nombres de las bibliotecas directamente en el cuadro de texto siguiente. Separe varios nombres con espacios, por ejemplo, griffon numpy pandas.
Directory of requirements.txt: agregue las bibliotecas a un archivo requirements.txt, cárguelo al contenedor DLC mediante la configuración de código, el conjunto de datos o un montaje directo, y luego especifique la ruta del archivo en el contenedor dentro del cuadro de texto.

Code Builds

Cargue los archivos de código necesarios para el entrenamiento en el contenedor DLC. Se admiten dos métodos de configuración:

Online configuration: si cuenta con un repositorio Git existente y tiene permisos de acceso, puede vincularlo mediante Create a code configuration para que DLC recupere el código del trabajo.
Local Upload: haga clic en el botón para cargar archivos de código locales. Después de una carga exitosa, configure Mount path con una ruta específica dentro del contenedor, por ejemplo, /mnt/data.

Información de recursos

Parámetro	Descripción
Resource Type	El valor predeterminado es General Computing. La opción Lingjun Intelligence Resources está disponible en las siguientes regiones: China (Ulanqab), Singapore, China (Shenzhen), China (Beijing), China (Shanghai), China (Hangzhou), China (Guangzhou), China (Hong Kong), Malaysia, Germany y Atlanta.
Source	Public Resources: Modelo de facturación: pay-as-you-go. Recomendado para cargas de trabajo con trabajos poco frecuentes y sin requisitos estrictos de tiempo. Los recursos públicos podrían requerir espera en cola. Límites de recursos: hasta 2 GPU y 8 núcleos de CPU. Para superar estos límites, comuníquese con su administrador de cuenta y solicite un aumento de cuota. Resource Quota: incluye recursos de cómputo de uso general o recursos Lingjun. Modelo de facturación: suscripción. Más indicado para escenarios con un alto volumen de trabajos que requieren recursos estables garantizados. Parámetros especiales: Resource Quota: establezca la cantidad de GPU, CPU y otros recursos. Para saber cómo preparar cuotas de recursos, consulte Create a resource quota. Priority: indica la prioridad de ejecución de los trabajos que se ejecutan simultáneamente. Rango de valores: [1, 9], donde 1 es la prioridad más baja. Comprobación previa: verifica automáticamente la compatibilidad entre el modelo de GPU y la imagen antes de enviar el trabajo. Esto detecta errores de configuración de forma temprana y evita fallos en el trabajo. Preemptible Resources: Modelo de facturación: pay-as-you-go. Diseñado para escenarios sensibles a los costos. El precio de los recursos spot es menor que el de pay-as-you-go. No hay garantía de disponibilidad. Es posible que los recursos no estén disponibles de inmediato o que se reclamen. Para más información, consulte Use a preemptible job.
Framework	Se admiten los siguientes framework y herramientas de entrenamiento de aprendizaje profundo: TensorFlow, PyTorch, ElasticBatch, XGBoost, OneFlow, MPIJob, Ray, Custom, DataJuicer y MPI. Nota Cuando Resource Quota se establece en recursos Lingjun, solo se admiten trabajos de TensorFlow, PyTorch, ElasticBatch, MPIJob y Ray.
Job Resource	Según el Framework seleccionado, puede configurar recursos para los tipos de nodo Worker, PS, Chief, Evaluator y GraphLearn. Si utiliza el framework Ray, haga clic en Add Role para personalizar roles de Worker, lo que permite la ejecución combinada de recursos heterogéneos. Uso de recursos públicos: se pueden configurar los siguientes parámetros: Number of Nodes: la cantidad de nodos que ejecutan el trabajo de DLC. Resource Type: seleccione el tipo de instancia. La consola muestra el precio correspondiente. Para más información sobre facturación, consulte DLC billing. Uso de cuotas de recursos: puede configurar la cantidad de nodos, núcleos de CPU, GPU, memoria (GiB) y memoria compartida (GiB) para cada tipo de nodo. También están disponibles los siguientes parámetros especiales: Node-Specific Scheduling: ejecute trabajos en nodos de cómputo específicos. Idle Resources: cuando se utilizan recursos en periodos de inactividad, los trabajos pueden ejecutarse en la capacidad ociosa de otras cuotas, lo que mejora el aprovechamiento de los recursos. Sin embargo, cuando la cuota original necesita esos recursos, los trabajos en inactividad se finalizan automáticamente y los recursos se devuelven. Para más información, consulte Use idle-time resources. CPU Affinity: habilite la afinidad de CPU para vincular procesos a núcleos específicos. Esto reduce los fallos de caché y los cambios de contexto para mejorar el rendimiento. Recomendado cuando se tienen altos requisitos de rendimiento y de tiempo real. Uso de recursos spot: además de la cantidad de nodos y el tipo de instancia, puede configurar el parámetro Bid Price, que establece la oferta máxima para los recursos spot. Haga clic en el botón para seleccionar un método de oferta: Por descuento: el precio máximo se basa en el precio de mercado del tipo de instancia, con opciones discretas del 10 % al 90 % del precio de mercado que representan el límite de la oferta. Los recursos spot se asignan cuando la oferta máxima es mayor o igual al precio de mercado y hay capacidad suficiente disponible. Por precio: el rango de la oferta máxima se encuentra dentro del rango del precio de mercado.
Scheduling Policy	Puede personalizar la estrategia de programación de recursos del contenedor según sus escenarios de negocio y las características del trabajo: Intelligent: los trabajos de GPU se consolidan en la menor cantidad posible de nodos GPU, mientras que los trabajos de CPU se distribuyen entre los nodos CPU. Esta es la estrategia predeterminada. Centralized: los trabajos se consolidan en la menor cantidad posible de nodos. Esta estrategia ayuda a reducir la fragmentación de recursos y es ideal para el entrenamiento de modelos con GPU. Spread: los trabajos se distribuyen entre los nodos. Esta estrategia mejora la tasa de éxito al sacar trabajos de la cola y es ideal para trabajos distribuidos de CPU.

Nota

DLC no admite modificar directamente el tipo de instancia de un trabajo ya enviado. Para cambiar el tipo de instancia (por ejemplo, para cambiar a una instancia compatible con redes de alto rendimiento eRDMA, como ecs.ebmgn8v.48xlarge), utilice la función Clone Job para crear un nuevo trabajo, seleccione el tipo de instancia deseado y envíelo. La plataforma habilita automáticamente las redes de alto rendimiento y configura los parámetros relacionados con NCCL. Para cambiar la versión del controlador de NVIDIA y de CUDA de una instancia, utilice la función de configuración de instancias para modificar la versión del controlador (por ejemplo, a la versión 580). La plataforma descarga automáticamente la imagen de DLC correspondiente según la nueva configuración para actualizar el entorno de ejecución, lo que completa el cambio de controlador, la actualización de CUDA o el reemplazo del controlador de GPU.

Expanda para ver más configuraciones: duración máxima de ejecución, periodo de retención y configuración avanzada del framework

Maximum Duration	Establezca la duración máxima de ejecución de un trabajo. Los trabajos que superen este límite se detienen automáticamente. Valor predeterminado: 30 días.
Retention Period	Configure durante cuánto tiempo se conservan los trabajos completados o con errores. Tenga en cuenta que la retención sigue consumiendo recursos. Los trabajos que superen este periodo se eliminan. Importante Los trabajos de DLC eliminados no se pueden restaurar. Proceda con precaución.
Start Developer Machine	Cuando el origen de los recursos es una cuota de recursos, puede iniciar una instancia DSW para depurar en línea. En el área de lista de instancias de la página de descripción general del trabajo, haga clic en DSW en la columna Actions para acceder a la instancia.
Advanced Framework Configuration	Para consultar la lista de parámetros configurables y sus valores, consulte Advanced parameter list. Los parámetros `ReleaseResourcePolicy`, `EnableNvidiaIBGDA`, `EnableNvidiaGDRCopy`, `EnablePaiNUMACoreBinding` y `EnableResourcePreCheck` son compatibles con todos los framework. Cuando el framework es PyTorch, los parámetros admitidos son: `createSvcForAllWorkers`, `customPortList` y `customPortNumPerWorker`. Importante Dado que los recursos Lingjun no ofrecen la capacidad de puertos personalizados, el parámetro customPortNumPerWorker no se admite al enviar trabajos de DLC con recursos Lingjun. Cuando el framework es Ray, los parámetros admitidos son: `RayRuntimeEnv`, `RayRedisAddress`, `RayRedisUsername`, `RayRedisPassword`, `RaySubmitterBackoffLimit` y `RayObjectStoreMemoryBytes`. Tenga en cuenta que las variables de entorno y las configuraciones de bibliotecas de terceros serán sobrescritas por la configuración de RayRuntimeEnv. Se admiten los siguientes formatos de configuración: Texto sin formato: configure como una cadena separada por comas (,) donde cada entrada sigue el formato `key=value`. La clave es un parámetro avanzado admitido y el valor es el valor correspondiente del parámetro. JSON Escenarios de configuración típicos: Escenario 1: configuración avanzada de PyTorch Los parámetros de configuración avanzada permiten la conectividad de red entre los Worker, lo que posibilita enfoques de entrenamiento más flexibles. Por ejemplo, puede usar los puertos adicionales expuestos para iniciar un framework como Ray dentro del contenedor DLC y combinarlo con PyTorch para lograr un entrenamiento distribuido avanzado. Ejemplo de configuración: `createSvcForAllWorkers=true,customPortNumPerWorker=100` Luego puede utilizar el Startup Command para configurar las variables de entorno `$JOB_NAME` y `$CUSTOM_PORTS`, obtener el nombre de dominio y los números de puerto disponibles, e iniciar y conectar framework como Ray. Escenario 2: configurar manualmente RayRuntimeEnv para el framework Ray (incluidas dependencias y variables de entorno) Ejemplo de configuración: `{"RayRuntimeEnv": "{pip: requirements.txt, env_vars: {key: value}}"}` Escenario 3: política personalizada de liberación de recursos Actualmente, la única política de liberación admitida es pod-exit, que libera automáticamente los recursos cuando su Pod finaliza. Ejemplo de configuración: `{ "ReleaseResourcePolicy": "pod-exit" }`

Configuración de VPC

Si no se configura ninguna VPC, se utilizan la red pública y la puerta de enlace pública. Dado que la puerta de enlace pública tiene un ancho de banda limitado, los trabajos pueden experimentar lentitud o no ejecutarse correctamente.
Configurar una VPC y seleccionar el vSwitch y el security group correspondientes mejora el ancho de banda, la estabilidad y la seguridad de la red. Además, el clúster que ejecuta sus trabajos puede acceder directamente a los servicios dentro de esta VPC.
Importante
- Cuando utilice una VPC, asegúrese de que las instancias del resource group del trabajo, el almacenamiento del conjunto de datos (OSS) y el repositorio de código se encuentren en la misma VPC dentro de la misma región, y de que exista conectividad de red.
- Cuando utilice un conjunto de datos CPFS, debe configurar una VPC que coincida con la VPC de CPFS. De lo contrario, el trabajo de entrenamiento de DLC enviado podría permanecer en el estado Preparing environment durante un periodo prolongado.
- Cuando envíe trabajos de DLC con recursos spot de Lingjun, debe configurar una VPC.
Además, puede configurar la Internet Access Gateway. Se admiten las dos opciones siguientes:
- Public Gateway: el ancho de banda es limitado. Durante periodos de alta concurrencia o al descargar archivos grandes, es posible que la velocidad de la red no cubra la demanda.
- Private Gateway: para superar la limitación de ancho de banda de la puerta de enlace pública, cree una puerta de enlace NAT en la VPC de DLC, asocie una EIP y configure entradas SNAT. Para más detalles, consulte Improve internet access with a private gateway.

Tolerancia a fallos y diagnósticos

Parámetro	Descripción
Automatic Fault Tolerance	Después de habilitar la función Automatic Fault Tolerance y configurar los parámetros correspondientes, el sistema ofrece capacidades de monitoreo y control de trabajos. Detecta errores a nivel de algoritmo en tiempo real y toma medidas correctivas, lo que mejora el uso de la GPU. Para más detalles, consulte AIMaster: An elastic and automatic fault tolerance engine. Nota Cuando se habilita la tolerancia automática a fallos, el sistema inicia una instancia AIMaster junto con las instancias del trabajo, lo que consume recursos de cómputo adicionales. Detalles del uso de recursos de la instancia AIMaster: Cuota de recursos: 1 núcleo de CPU y 1 GiB de memoria. Recursos públicos: utiliza el tipo de instancia ecs.c6.large.
Sanity Check	Tras habilitar la función Sanity Check, la comprobación de estado inspecciona a fondo los recursos involucrados en el entrenamiento, aísla automáticamente los nodos defectuosos y activa operaciones automatizadas en segundo plano. Esto reduce de manera efectiva la probabilidad de problemas durante las etapas iniciales del entrenamiento y mejora su tasa de éxito. Para más detalles, consulte SanityCheck: Compute health checks. Nota La función de comprobación de estado solo se admite para trabajos de entrenamiento de PyTorch enviados con cuotas de recursos Lingjun y cuando la cantidad de GPU es mayor que 0.

Roles y permisos

A continuación se describe la configuración del rol RAM de la instancia. Para más detalles, consulte Configure a RAM role for DLC.

Rol RAM de la instancia	Descripción
Default Role of PAI	Opera con base en el rol de servicio AliyunPAIDLCDefaultRole, que solo tiene acceso a MaxCompute y OSS, con permisos más detallados. Credenciales temporales emitidas con base en el rol predeterminado de PAI: Al acceder a tablas de MaxCompute, tiene los mismos permisos que el propietario de la instancia DLC. Al acceder a OSS, solo puede acceder al bucket de OSS predeterminado configurado para el espacio de trabajo actual.
Custom Role	Seleccione o especifique un rol RAM personalizado. Al acceder a servicios en la nube desde la instancia mediante credenciales temporales STS, los permisos coinciden con los del rol personalizado.
Does Not Associate Role	No se asocia ningún rol RAM con el trabajo de DLC. Esta es la opción predeterminada.

Documentación relacionada

Consulte la información básica del trabajo, las vistas de recursos y los registros de operación. Para más detalles, consulte View training job details.
Consulte los detalles de facturación de la ejecución del trabajo. Para más detalles, consulte Billing details.
Para conocer los problemas comunes de los trabajos de DLC y sus soluciones, consulte FAQ about DLC.
Para consultar casos de uso de DLC, consulte DLC use cases.

Preguntas frecuentes

P: ¿Qué debo hacer si recibo un error BadRequest al seleccionar un origen de datos NAS con un destino de montaje cuando creo un trabajo de entrenamiento?

Este error ocurre cuando al origen de datos NAS le falta un destino de montaje. Cree un nuevo destino de montaje en la consola de NAS, luego selecciónelo como origen de datos en la configuración de Mount dataset o Mount storage al crear el trabajo de entrenamiento y vuelva a enviar el trabajo.

P: ¿Los trabajos de entrenamiento de DLC pueden exportar métricas a Weights & Biases (W&B)?

Sí, DLC admite la exportación de métricas de entrenamiento a W&B, pero deben cumplirse los siguientes requisitos previos:

Conectividad de red: asegúrese de que los nodos de entrenamiento de PAI puedan acceder al endpoint público api.wandb.ai. Si utiliza una VPC, configure una puerta de enlace NAT.
Gestión de claves: inyecte la clave de API de W&B mediante variables de entorno. No la incluya de forma codificada en su código.
Cumplimiento: cargue únicamente métricas escalares no confidenciales. No cargue datos sin procesar ni detalles confidenciales del modelo.

P: ¿Un trabajo de DLC con errores sigue apareciendo en la lista de trabajos?

Su aparición depende del motivo del error:

Los trabajos que fallan por falta de recursos aparecen temporalmente en la lista de trabajos de la consola de DLC y se eliminan después de borrarlos.
Cuando la API devuelve un error directamente (con un RequestID) debido a parámetros de solicitud no válidos, no se guarda ningún registro en la lista de trabajos. El mensaje de error solo se muestra en la página de operación.

P: ¿Qué debo hacer si veo un mensaje de "account security protection triggered" o "resource allocation suspended" al crear un trabajo de DLC?

Este mensaje suele activarse por las políticas de control de riesgos de la cuenta. Utilice la herramienta de diagnóstico de autoservicio de Alibaba Cloud (https://smartservice.console.alibabacloud.com/service/self-service-center/search?questionId=27591) para diagnosticar por qué no se puede continuar con el pago o la asignación de recursos, y envíe una apelación. Una vez aprobada la apelación, podrá intentar crear el trabajo nuevamente.

Apéndice

Crear un trabajo mediante el SDK o CLI

Python SDK

Paso 1: Instalar la herramienta Alibaba Cloud Credentials

Cuando llama a OpenAPI mediante un SDK de Alibaba Cloud para gestionar recursos, debe instalar la herramienta Credentials para configurar sus credenciales. Requisitos:

Versión de Python >= 3.7.
Utilice los SDK de Alibaba Cloud V2.0.

pip install alibabacloud_credentials

Paso 2: Obtener el AccessKey de su cuenta

Este ejemplo utiliza la información de AccessKey (AK) para configurar las credenciales de acceso. Para evitar la filtración de credenciales, se recomienda almacenar su AccessKey en variables de entorno. Los nombres de las variables de entorno para el ID y el secreto son ALIBABA_CLOUD_ACCESS_KEY_ID y ALIBABA_CLOUD_ACCESS_KEY_SECRET.

Para obtener información sobre cómo conseguir un AccessKey, consulte Create an AccessKey.
Para obtener información sobre cómo configurar variables de entorno, consulte Configure environment variables.
Para conocer otros métodos de configuración de credenciales, consulte Manage access credentials.

Paso 3: Instalar el SDK de Python

Instale el SDK del espacio de trabajo.

pip install alibabacloud_aiworkspace20210204==3.0.1

Instale el SDK de DLC.

pip install alibabacloud_pai_dlc20201203==1.4.17

Paso 4: Enviar un trabajo

Envío de un trabajo mediante recursos públicos

A continuación se muestra un código de ejemplo que indica cómo crear y enviar un trabajo:

Código de ejemplo para crear y enviar un trabajo

#!/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()

Envío de un trabajo mediante una cuota de recursos de suscripción

Inicie sesión en la PAI console.
Consulte el identificador del espacio de trabajo: en el panel de navegación izquierdo, haga clic en Workspace List. Busque el espacio de trabajo deseado, haga clic en el icono ⓘ junto a su nombre y copie el valor de Workspace ID en el panel de información que aparece.
Consulte el identificador de la cuota de recursos de su resource group dedicado. En el panel de navegación izquierdo, elija AI Computing Resources > Resource Quota. Haga clic en la pestaña General Computing Resources y obtenga el identificador de la cuota de recursos deseada en la columna Name/ID de la lista.

Utilice el siguiente código para crear y enviar un trabajo. Para consultar la lista de imágenes públicas disponibles, consulte Step 2: Prepare an 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

Envío de un trabajo mediante recursos spot

SpotDiscountLimit (descuento 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 (precio 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}')

La siguiente tabla describe las configuraciones clave:

Parámetro	Descripción
SpotStrategy	Estrategia de puja. El tipo de puja solo surte efecto cuando este parámetro se establece en SpotWithPriceLimit.
SpotDiscountLimit	Usa el descuento spot como método de puja. Nota No es posible configurar SpotDiscountLimit y SpotPriceLimit al mismo tiempo. Para los recursos spot de Lingjun, solo se admite SpotDiscountLimit como tipo de puja.
SpotPriceLimit	Usa el precio spot como método de puja.
UserVpc	Obligatorio cuando se envía un trabajo con recursos spot de Lingjun. Configure la VPC, el vSwitch y el identificador del security group de la región donde se ejecuta el trabajo.

Nota

Cuando crea un trabajo de DLC mediante una llamada a la API o un SDK (createJob), no es posible cargar archivos de código local directamente. Primero debe subir el código a alguna de las siguientes ubicaciones:

Repositorio Git: cree una configuración de código en AI Assets Management y vincúlela a la URL del repositorio Git.
Almacenamiento OSS: después de cargar el código en OSS, póngalo a disposición del trabajo al montarlo como un conjunto de datos.
Imagen personalizada: empaquete el código en una imagen Docker.

Línea de comandos

Paso 1: Descargar el cliente y completar la autenticación de usuario

Descargue la herramienta cliente para Linux de 64 bits o para Mac según su sistema operativo y complete la autenticación de usuario. Para obtener más detalles, consulte Preparations.

Paso 2: Enviar un trabajo

Inicie sesión en la PAI console.
Siga estas instrucciones para consultar el identificador de su espacio de trabajo (WorkspaceID) en la página de lista de espacios de trabajo.

En el panel de navegación izquierdo, haga clic en Workspace List. Busque el espacio de trabajo deseado, haga clic en el icono ⓘ a la derecha de su nombre y consulte el valor de Workspace ID en el panel de información que aparece.
Siga estas instrucciones para consultar el identificador de su cuota de recursos.

En el panel de navegación izquierdo, elija AI Computing Resources > Resource Quota. Seleccione la pestaña correspondiente al tipo de recurso deseado (por ejemplo, General Computing Resources) y obtenga el identificador de la cuota de recursos en la columna Name/ID de la lista.

Prepare un archivo de parámetros con base en el siguiente contenido tfjob.params. Para obtener más información sobre cómo configurar el archivo de parámetros, consulte Submit commands.

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>

Utilice el siguiente código de ejemplo para pasar el parámetro params_file. Esto envía el trabajo de DLC al espacio de trabajo y a la cuota de recursos especificados.
```
./dlc submit tfjob --job_file  ./tfjob.params
```
Ejecute el siguiente comando para consultar el trabajo de DLC que envió.
```
./dlc get job <jobID>
```

Lista de parámetros avanzados

Parámetro (clave)	Tipos de framework compatibles	Descripción	Valor del parámetro
`ReleaseResourcePolicy`	ALL	Configura una política personalizada de liberación de recursos. Este parámetro es opcional. Si no lo configura, todos los recursos de Pod se liberan cuando finaliza el trabajo. Si lo configura, el único valor admitido es `pod-exit`, que libera los recursos de un Pod cuando este termina.	pod-exit
`EnableJumboFrame`	ALL	Indica si se habilitan los jumbo frames. Solo es compatible con AI Computing Resources - General Computing 2.0. El valor predeterminado es `false`, lo que significa que están deshabilitados.	`true` o `false`
`EnableNvidiaIBGDA`	ALL	Indica si se habilita IBGDA cuando se carga el controlador de GPU.	`true` o `false`
`EnableNvidiaGDRCopy`	ALL	Indica si se instala el módulo de kernel GDRCopy. La versión instalada actualmente es la 2.4.4.	`true` o `false`
`EnablePaiNUMACoreBinding`	ALL	Indica si se habilita NUMA.	`true` o `false`
`EnableResourcePreCheck`	ALL	Cuando se envía un trabajo, este parámetro comprueba si los recursos totales (especificaciones de nodo) de la cuota cumplen con las especificaciones de todos los roles del trabajo.	`true` o `false`
`createSvcForAllWorkers`	PyTorch	Indica si se permite la conectividad de red entre workers. Si se establece en `true`, todos los workers de PyTorch pueden comunicarse entre sí por la red. Si se establece en `false` o no se configura, de forma predeterminada solo se puede acceder al master. Una vez habilitado, el nombre de dominio de cada worker coincide con su nombre, por ejemplo, `dlcxxxxx-master-0`. Después, el nombre del trabajo (`dlcxxxxx`) se pasa al worker mediante la variable de entorno `JOB_NAME`. Así es posible determinar el nombre de dominio del worker específico al que desea acceder.	`true` o `false`
`customPortList`	PyTorch	Permite definir los puertos de red expuestos en cada worker. Puede usar este parámetro junto con `createSvcForAllWorkers` para habilitar la conectividad de red entre workers. Si no se configura, de forma predeterminada solo se expone el puerto 23456 en el master. Asegúrese de no incluir el puerto 23456 en esta lista personalizada. Importante Este parámetro es mutuamente excluyente con `customPortNumPerWorker`. No configure ambos al mismo tiempo.	Un conjunto de cadenas separadas por punto y coma, donde cada cadena es un número de puerto individual o un rango de puertos unidos por un guion, como `10000;10001-10010` (que se convierte en 11 números de puerto consecutivos del 10000 al 10010).
`customPortNumPerWorker`	PyTorch	Permite solicitar una cantidad específica de puertos de red para exponer en cada worker. Puede usar este parámetro junto con `createSvcForAllWorkers` para habilitar la conectividad de red entre workers. Si no se configura, de forma predeterminada solo se expone el puerto 23456 en el master. DLC asigna puertos aleatorios a los workers según la cantidad definida en el parámetro. Los números de puerto asignados se pasan al worker mediante la variable de entorno `CUSTOM_PORTS` para que pueda consultarlos. El formato es un conjunto de números de puerto separados por punto y coma. Importante Este parámetro es mutuamente excluyente con `customPortList`. No configure ambos al mismo tiempo. Los recursos de cómputo de Lingjun no admiten puertos personalizados. Por lo tanto, cuando envíe un trabajo de DLC con estos recursos, el parámetro `customPortNumPerWorker` no será compatible.	Entero (máximo: 65536)
`RayRuntimeEnv`	Ray	Cuando el framework es Ray, puede configurar manualmente RayRuntimeEnv para definir el entorno de ejecución. Importante Las variables de entorno y las configuraciones de bibliotecas de terceros se sobrescriben con esta configuración.	Configure las variables de entorno y las bibliotecas de terceros (`{pip: requirements.txt, env_vars: {key: value}}`)
`RayRedisAddress`	Ray	Dirección externa de Redis para GCS.	Cadena
`RayRedisUsername`	Ray	Nombre de usuario externo de Redis para GCS.	Cadena
`RayRedisPassword`	Ray	Contraseña externa de Redis para GCS.	Cadena
`RaySubmitterBackoffLimit`	Ray	Número de reintentos para el submitter.	Entero positivo (int)
`RayObjectStoreMemoryBytes`	Ray	Configura la memoria compartida de un nodo. Por ejemplo, para asignar 1 GiB de memoria compartida a cada nodo, utilice la siguiente configuración: `{ "RayObjectStoreMemoryBytes": "1073741824" }`	Entero positivo (int)