Criar jobs de treinamento distribuído de IA - Platform For AI: Central de Documentação do Alibaba Cloud

Início rápido

Para um tutorial baseado em MNIST sobre treinamento distribuído com GPU única ou multi-nó e multi-GPU, consulte o Início Rápido de Treinamento Distribuído DLC.

Parâmetros do console

Informações básicas

Configure o Job Name e a Tag.

Informações de ambiente

Parâmetro	Descrição
Image Configuration	Além de selecionar uma Alibaba Cloud Image, você pode usar os seguintes tipos de imagem: Custom Image: Use uma imagem personalizada adicionada ao PAI. A imagem deve estar armazenada no Container Registry (ACR) ou em um repositório acessível publicamente. Imagens personalizadas. Nota Ao usar uma imagem personalizada com recursos de computação Lingjun AI, instale manualmente o RDMA para aproveitar totalmente a rede RDMA de alto desempenho. RDMA: Uso de rede de alto desempenho para treinamento distribuído. Image Address: Especifique a URL de uma imagem personalizada ou oficial acessível pela internet. Para uma URL de imagem privada, clique em Input Username and Password e insira o nome de usuário e a senha do repositório. Para acelerar o pull da imagem, consulte Aceleração de imagem.
Mount dataset	Os datasets fornecem os arquivos de dados necessários para o treinamento do modelo. O PAI oferece suporte a dois tipos de datasets: Custom Dataset: Crie um dataset personalizado para armazenar seus dados de treinamento. Defina o dataset como Read-only e selecione uma versão na lista de versões. Public Dataset: O PAI fornece datasets públicos. Apenas o modo de montagem somente leitura é suportado. Mount Path: Caminho no contêiner DLC onde o dataset é montado, por exemplo, `/mnt/data`. Acesse o dataset a partir desse caminho em seu código. Detalhes da configuração de montagem: Uso de armazenamento em nuvem. Importante Se você configurar um dataset CPFS, configure uma VPC para o DLC e garanta que ela seja a mesma VPC do sistema de arquivos CPFS. Caso contrário, o job enviado poderá permanecer no estado "Preparing" por um longo período.
Mount storage	Também é possível montar um caminho de origem de dados para ler informações ou armazenar arquivos intermediários e resultados. Tipos de origem de dados suportados: Object Storage Service (OSS), NAS de uso geral, NAS Extreme, CPFS e BMCPFS (disponível apenas para recursos de computação Lingjun AI). Advanced Settings: As configurações avançadas permitem habilitar recursos específicos para diferentes tipos de origem de dados. Exemplos: OSS: Nas configurações avançadas, defina `{"mountType":"ossfs"}` para montar o armazenamento OSS usando ossfs. NAS de uso geral e CPFS: Nas configurações avançadas, defina o parâmetro nconnect para melhorar o throughput quando o contêiner DLC acessa o NAS. Para mais informações, consulte Como resolvo o baixo desempenho ao acessar o NAS a partir de um SO Linux?. Exemplo: `{"nconnect":"<example_value>"}`. Substitua <example_value> por um número inteiro positivo. Uso de armazenamento em nuvem.
Startup Command	Defina o comando de inicialização do job. Comandos Shell são suportados. O DLC injeta automaticamente variáveis de ambiente comuns para PyTorch e TensorFlow, como `MASTER_ADDR` e `WORLD_SIZE`. Acesse-as usando o formato `$variable_name`. Os exemplos a seguir mostram comandos de inicialização comuns: Executar Python: `python -c "print('Hello World')"` Treinamento distribuído PyTorch multi-nó e 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` Definir um caminho de arquivo shell como comando de inicialização: `/ml/input/config/launch.sh`

Configurações avançadas

Environment Variable

Além das variáveis de ambiente comuns para PyTorch e TensorFlow injetadas automaticamente, você pode fornecer variáveis de ambiente personalizadas no formato Key:Value. Há suporte para até 20 variáveis de ambiente.

Third-party Libraries

Caso a imagem do contêiner configurada não possua bibliotecas de terceiros, adicione-as na seção Third-party Libraries. Dois métodos são suportados:

Select from List: Insira os nomes das bibliotecas de terceiros na caixa de texto.
Directory of requirements.txt: Adicione as bibliotecas de terceiros a um arquivo requirements.txt, faça upload do arquivo para o contêiner DLC via Code Builds, dataset ou montagem direta e, em seguida, especifique o caminho do arquivo no contêiner.

Code Builds

Faça upload do seu código de treinamento para o contêiner DLC. Dois métodos são suportados:

Online configuration: Se você tiver acesso a um repositório Git, associe-o criando uma origem de código. Isso permite que o DLC obtenha o código do job.
Local Upload: Clique no botão para fazer upload de arquivos de código locais. Após concluir o upload, defina o Mount path para um caminho específico dentro do contêiner, por exemplo, /mnt/data.

Informações de recursos

Parâmetro	Descrição
Resource Type	O valor padrão é General Computing. Os Lingjun Intelligence Resources estão disponíveis nas seguintes regiões: China (Ulanqab), Singapura, China (Shenzhen), China (Pequim), China (Xangai), China (Hangzhou), China (Guangzhou), China (Hong Kong), Malásia (Kuala Lumpur), Alemanha (Frankfurt) e Atlanta.
Source	Public Resources: Método de faturamento: pagamento conforme o uso. Cenários: Ideal para jobs de baixo volume e sem sensibilidade a tempo. Podem ocorrer atrasos na fila. Limites: 2 GPUs e 8 núcleos de CPU. Entre em contato com seu gerente de contas para aumentar o limite. Resource Quota: Inclui recursos de computação de uso geral ou recursos de computação Lingjun AI. Método de faturamento: assinatura. Cenários: Recomendado para jobs de alto volume que exigem execução confiável. Parâmetros específicos: Resource Quota: Defina a quantidade de recursos, como GPUs e CPUs. Para criar uma cota de recursos, consulte Adicionar uma cota de recursos. Priority: Prioridade de execução para jobs concorrentes. O valor pode ser um número inteiro de 1 a 9, onde 1 representa a menor prioridade. Pré-verificação: Valida a compatibilidade entre recursos e imagens oficiais antes do início do job, evitando falhas causadas por erros de configuração. Preemptible Resources: Método de faturamento: pagamento conforme o uso. Cenários: Reduz custos com recursos descontados. Limites: A disponibilidade não é garantida — os recursos podem não estar imediatamente disponíveis ou podem ser recuperados. Uso de jobs preemptíveis.
Framework	Frameworks e ferramentas de treinamento de deep learning suportados: TensorFlow, PyTorch, ElasticBatch, XGBoost, OneFlow, MPIJob, Ray, Custom, DataJuicer e MPI. Nota Ao selecionar Resource Quota e usar recursos de computação Lingjun AI, envie apenas jobs TensorFlow, PyTorch, ElasticBatch, MPIJob e Ray.
Job Resource	Com base no Framework selecionado, configure recursos para os tipos de nó Worker, PS, Chief, Evaluator e GraphLearn. Se escolher o framework Ray, clique em Add Role para personalizar funções de Worker e executar jobs em recursos heterogêneos. Uso de recursos públicos: Configure os seguintes parâmetros: Number of Nodes: Quantidade de nós para o job DLC. Resource Type: Selecione uma especificação de recurso. O console exibe o preço correspondente. Detalhes de faturamento: Faturamento do DLC. Uso de cota de recursos: Configure o número de nós, CPU (núcleos), GPU (placas), Memória (GiB) e Memória Compartilhada (GiB) para cada tipo de nó. Também é possível configurar os seguintes parâmetros: Node-Specific Scheduling: Execute o job em nós de computação específicos. Idle Resources: Permite que jobs sejam executados em recursos ociosos de outras cotas para melhorar a utilização. Se a cota original precisar desses recursos, o job será encerrado e os recursos devolvidos automaticamente. Uso de recursos ociosos. CPU Affinity: Vincula processos em um contêiner ou pod a núcleos de CPU específicos, reduzindo cache misses e trocas de contexto. Adequado para cargas de trabalho sensíveis a desempenho e em tempo real. Uso de recursos preemptíveis: Além do número de nós e da especificação de recursos, configure o parâmetro Bid Price, que define o preço máximo para solicitar recursos preemptíveis. Clique no botão para selecionar um método de lance: By Discount: O lance máximo baseia-se no preço de mercado da especificação do recurso, com opções discretas de desconto de 10% a 90%. Isso indica o limite superior para lances. Solicite um recurso preemptível se o seu lance máximo estiver igual ou acima do preço de mercado e houver estoque suficiente. By Price: O lance máximo está dentro da faixa de preço de mercado.

Configurações avançadas

Maximum Duration	Duração máxima de execução de um job. Jobs que excederem essa duração serão interrompidos. Padrão: 30 dias.
Retention Period	Período de retenção para jobs concluídos. Jobs retidos continuam ocupando recursos e são excluídos após o vencimento. Importante Jobs DLC excluídos não podem ser recuperados. Proceda com cautela.
Start Developer Machine	Se a origem do recurso for uma cota de recursos, inicie uma Developer Machine (DSW) para depuração online. Na página de visão geral do job, acesse a lista de instâncias e clique em Developer Machine (DSW) na coluna Actions.
Advanced Framework Configuration	Para obter uma lista de parâmetros suportados e descrições, consulte a Lista de parâmetros avançados. Os parâmetros `ReleaseResourcePolicy`, `EnableNvidiaIBGDA`, `EnableNvidiaGDRCopy`, `EnablePaiNUMACoreBinding` e `EnableResourcePreCheck` são suportados por todos os frameworks. Se o Framework for PyTorch, os seguintes parâmetros estarão disponíveis: `createSvcForAllWorkers`, `customPortList` e `customPortNumPerWorker`. Importante Os recursos de computação Lingjun AI não fornecem capacidades de porta personalizada. Portanto, não configure o parâmetro customPortNumPerWorker ao enviar um job DLC que utilize recursos de computação Lingjun AI. Se o Framework for Ray, os seguintes parâmetros estarão disponíveis: `RayRuntimeEnv`, `RayRedisAddress`, `RayRedisUsername`, `RayRedisPassword`, `RaySubmitterBackoffLimit` e `RayObjectStoreMemoryBytes`. Observação: As configurações de variáveis de ambiente e bibliotecas de terceiros são substituídas pela configuração RayRuntimeEnv. Os seguintes formatos de configuração são suportados: Texto simples: Insira uma lista de strings separadas por vírgulas, onde cada string segue o formato `key=value`. A chave é um parâmetro avançado suportado e o valor é o valor do parâmetro. JSON Cenários típicos de configuração: Cenário 1: Configuração avançada do PyTorch Use parâmetros de configuração avançada para habilitar a comunicação de rede entre Workers. Por exemplo, abra portas extras para iniciar frameworks como Ray no contêiner DLC e coordenar com o PyTorch para treinamento distribuído avançado. Exemplo de configuração: `createSvcForAllWorkers=true,customPortNumPerWorker=100` Em seguida, no Startup Command, use as variáveis de ambiente `$JOB_NAME` e `$CUSTOM_PORTS` para obter o nome de domínio e os números de porta disponíveis para iniciar e conectar-se a frameworks como o Ray. Cenário 2: Configurar manualmente o RayRuntimeEnv para o framework Ray (incluindo bibliotecas dependentes e variáveis de ambiente) Exemplo de configuração: `{"RayRuntimeEnv": "{pip: requirements.txt, env_vars: {key: value}}"}` Cenário 3: Regra personalizada de liberação de recursos Atualmente, apenas a política de liberação pod-exit é suportada, liberando automaticamente os recursos quando o pod é encerrado. Exemplo de configuração: `{ "ReleaseResourcePolicy": "pod-exit" }`

Configuração de VPC

Sem uma VPC, o job utiliza um Public Gateway com largura de banda limitada, o que pode tornar o job lento ou causar falhas.
Configure uma VPC com vSwitch e grupo de segurança para melhorar a largura de banda, a estabilidade e a segurança. O cluster do job pode acessar diretamente serviços dentro da VPC.
Importante
- Se utilizar uma VPC, garanta que as instâncias do grupo de recursos do job e o armazenamento de datasets (OSS) estejam em uma VPC na mesma região e que a VPC esteja conectada à rede do repositório de código.
- Se utilizar um dataset CPFS, configure uma VPC e garanta que a VPC selecionada seja a mesma do sistema de arquivos CPFS. Caso contrário, o job de treinamento DLC enviado poderá permanecer no estado "Preparing" por um longo período.
- Configure uma VPC ao enviar um job DLC que utilize recursos de computação Lingjun AI preemptíveis.
Também é possível configurar um Internet Access Gateway usando um dos seguintes métodos:
- Public Gateway: Possui largura de banda limitada que pode ser insuficiente durante acessos de alta concorrência ou downloads de arquivos grandes.
- Private Gateway: Para superar os limites de largura de banda do Public Gateway, crie um NAT Gateway de Internet na VPC do DLC, vincule um EIP e configure entradas SNAT. Melhorar a velocidade de acesso à rede pública usando um gateway privado.

Tolerância a falhas e diagnóstico

Parâmetro	Descrição
Automatic Fault Tolerance	Ative a Automatic Fault Tolerance e configure os parâmetros necessários para detectar e mitigar erros no nível do algoritmo, melhorando a utilização da GPU. AIMaster: Um mecanismo elástico de tolerância a falhas automáticas. Nota Ao ativar a tolerância automática a falhas, uma instância AIMaster é iniciada e executada junto com a instância do job. Isso consome uma quantidade específica de recursos de computação. A instância AIMaster utiliza os seguintes recursos: Cota de recursos: 1 núcleo de CPU e 1 GiB de memória. Recursos públicos: Utiliza a especificação ecs.c6.large.
Sanity Check	Ative o Sanity Check para verificar abrangentemente os recursos de treinamento, isolar nós com falha e acionar processos automatizados de O&M no backend. Reduz falhas iniciais e melhora a taxa de sucesso. SanityCheck: Verificação de integridade de recursos de computação. Nota O recurso de verificação de integridade é suportado apenas para jobs de treinamento PyTorch enviados usando uma cota de recursos de computação Lingjun AI e que possuam contagem de GPU maior que 0.

Funções e permissões

Configurações de função RAM da instância. Configurar uma função RAM do DLC.

Função RAM da instância	Descrição
Default Role of PAI	A função padrão do PAI concede as seguintes permissões via credenciais temporárias STS: Ao acessar uma tabela MaxCompute, você tem as mesmas permissões que o proprietário da instância DLC. Ao acessar o OSS, você só pode acessar o bucket OSS padrão configurado para o workspace atual.
Custom Role	Selecione ou insira uma função RAM personalizada. A instância assume as permissões dessa função ao acessar serviços em nuvem através de credenciais temporárias STS.
Does Not Associate Role	Nenhuma função RAM é associada ao job DLC. Esta é a opção padrão.

Tópicos relacionados

Detalhes do job, uso de recursos e logs de operação: Visualize detalhes do treinamento.
Detalhes de faturamento: Detalhes da fatura.
Problemas comuns e soluções: FAQ do DLC.
Casos de uso: Casos de uso do DLC.

Apêndice

Criar um job via SDK ou CLI

Python SDK

Etapa 1: Instale a ferramenta Credentials

Instale a ferramenta Credentials para autenticação do SDK. Requisitos:

Python 3.7 ou posterior.
Alibaba Cloud SDK série 2.0.

pip install alibabacloud_credentials

Etapa 2: Obter um AccessKey

Este exemplo usa um par de AccessKey. Armazene os valores do AccessKey como variáveis de ambiente para evitar riscos de segurança. A variável de ambiente para o AccessKey ID é ALIBABA_CLOUD_ACCESS_KEY_ID, e a variável de ambiente para o segredo do AccessKey é ALIBABA_CLOUD_ACCESS_KEY_SECRET.

Obter um par de AccessKey: Criar um AccessKey.
Definir variáveis de ambiente: Configurar variáveis de ambiente.
Outros métodos de credencial: Instale a ferramenta Credentials.

Etapa 3: Instale os SDKs Python

Instale o SDK do workspace.

pip install alibabacloud_aiworkspace20210204==3.0.1

Instale o SDK do DLC.

pip install alibabacloud_pai_dlc20201203==1.4.17

Etapa 4: Envie o job

Recursos públicos

O código de exemplo a seguir cria e envia um job.

Código de exemplo para criar e enviar um job

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

    # Make sure that your Alibaba Cloud account is authorized to use DLC and has sufficient permissions.
    region_id = 'cn-hangzhou'
    # An AccessKey pair provides full API access. For security purposes, we recommend that you use a RAM user for API access and daily O&M.
    # Do not hard-code your AccessKey ID and AccessKey secret in your code. This may lead to AccessKey leakage and compromise the security of all resources in your account.
    # This example shows how to use the Credentials SDK to read the AccessKey from environment variables for authentication.
    cred = CredClient()

    # 1. Create clients;
    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 -----------')
    # Obtain the list of workspaces. You can also specify your workspace name 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 ------------')
    # Obtain 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 ----------')
    # Obtain the datasets.
    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:
        # If the dataset does not exist, create one.
        dataset_id = create_nas_dataset(
            client=workspace_client,
            region=region_id,
            workspace_id=workspace_id,
            name='example-nas-data',
            # The ID of the NAS file system.
            # General-purpose NAS: 31a8e4****.
            # Extreme NAS: Must start with extreme-, for example, extreme-0015****.
            # CPFS: Must start with cpfs-, for example, 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 ----------')
    # Obtain 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 ----------')
    # Obtain the list of DLC node specifications.
    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 ----------')
    # Obtain 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()

Cota de recursos por assinatura

Faça login no PAI console.
Para visualizar o ID do seu workspace: No painel de navegação à esquerda, clique em Workspaces. Localize o workspace desejado, clique no ícone ⓘ ao lado do nome e visualize/copie o Workspace ID no cartão de informações exibido.
Para visualizar o ID da sua cota de recursos para o grupo de recursos dedicados: No painel de navegação à esquerda, escolha AI Computing Resources > Resource Quotas. Clique na aba General-purpose Computing Resources e obtenha o Quota ID na coluna Name/ID da lista de cotas de recursos.

Use o código a seguir para criar e enviar um job. Para obter uma lista de imagens públicas disponíveis, consulte Etapa 2: Preparar uma imagem.

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'
# An AccessKey pair provides full API access. For security purposes, we recommend that you use a RAM user for API access and daily O&M.
# Do not hard-code your AccessKey ID and AccessKey secret in your code. This may lead to AccessKey leakage and compromise the security of all resources in your account.
# This example shows how to use the Credentials SDK to read the AccessKey from environment variables for 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, you can refer to the public image list in the documentation or provide your own image URL.
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 job's execution details.
req = CreateJobRequest(
        resource_id='<Replace with the ID of your resource quota>',
        workspace_id='<Replace with your 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

Instâncias Spot

SpotDiscountLimit (desconto 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 ID of the region in which the DLC job resides, such as cn-hangzhou. 
cred = CredClient()
workspace_id = '12****'  # The ID of the workspace to which the DLC job belongs. 

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 (preço 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>'
cred = CredClient()
workspace_id = '12****'

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",
                "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'",
}))
job_id = create_job_resp.body.job_id
print(f'jobId is {job_id}')

A tabela a seguir descreve os parâmetros principais.

Parâmetro	Descrição
SpotStrategy	Política de lance. Os parâmetros de tipo de lance só entram em vigor se você definir este parâmetro como SpotWithPriceLimit.
SpotDiscountLimit	Tipo de lance por desconto spot. Nota Não é possível especificar os parâmetros SpotDiscountLimit e SpotPriceLimit simultaneamente. O parâmetro SpotDiscountLimit é válido apenas para recursos Lingjun.
SpotPriceLimit	Tipo de lance por preço spot.
UserVpc	Este parâmetro é obrigatório ao usar recursos Lingjun para enviar jobs. Configure a VPC, o vSwitch e o ID do grupo de segurança para a região onde o job reside.

CLI

Etapa 1: Baixe o cliente e autenticar

Baixe a ferramenta cliente para Linux (64 bits) ou macOS e conclua a autenticação. Preparações.

Etapa 2: Envie o job

Faça login no PAI console.
Para visualizar o ID do seu workspace:

No painel de navegação à esquerda, clique em Workspaces. Localize o workspace desejado, clique no ícone ⓘ ao lado do nome e visualize o Workspace ID no cartão de informações exibido.
Para visualizar o ID da sua cota de recursos:

No painel de navegação à esquerda, escolha AI Computing Resources > Resource Quotas. Selecione a aba do tipo de recurso desejado, como General-purpose Computing Resources, e obtenha o ID da cota de recursos na coluna Name/ID.

Crie um arquivo de parâmetros chamado tfjob.params com o seguinte conteúdo. Detalhes do arquivo de parâmetros: Comando de envio.

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=<Replace with your resource quota ID> 
workspace_id=<Replace with your WorkspaceID>

Execute o comando a seguir para enviar o job DLC para um workspace e cota de recursos especificados, usando o parâmetro '--job_file' para indicar o caminho do seu arquivo de parâmetros.
```
./dlc submit tfjob --job_file  ./tfjob.params
```
Execute o comando a seguir para visualizar o job DLC que você enviou.
```
./dlc get job <jobID>
```

Parâmetros avançados

Parâmetro	Frameworks suportados	Descrição	Valor
`ReleaseResourcePolicy`	ALL	Por padrão, todos os recursos do pod são liberados após a conclusão do job. O único outro valor suportado é 'pod-exit', que libera os recursos de um pod assim que ele é encerrado.	pod-exit
`EnableNvidiaIBGDA`	ALL	Especifica se o recurso IBGDA deve ser ativado quando o driver da GPU é carregado.	`true` ou `false`
`EnableNvidiaGDRCopy`	ALL	Especifica se o módulo de kernel GDRCopy deve ser instalado. (Versão: 2.4.4)	`true` ou `false`
`EnablePaiNUMACoreBinding`	ALL	Especifica se o vínculo de núcleo NUMA deve ser ativado.	`true` ou `false`
`EnableResourcePreCheck`	ALL	Especifica se deve verificar se o total de recursos (especificações de nó) na cota pode atender às especificações de todas as funções no job durante o envio.	`true` ou `false`
`createSvcForAllWorkers`	PyTorch	Especifica se a comunicação de rede entre workers é permitida. Se definido como `true`, a comunicação de rede é permitida entre todos os workers PyTorch. Se o valor for `false` ou não estiver configurado, apenas o master pode ser acessado por padrão. Após ativar este recurso, o nome de domínio de cada worker será igual ao seu nome de worker, como `dlcxxxxx-master-0`. O nome do job, como `dlcxxxxx`, é passado para o worker através da variável de ambiente `JOB_NAME`. Você pode então determinar o nome de domínio do worker específico que deseja acessar.	`true` ou `false`
`customPortList`	PyTorch	Permite especificar as portas de rede a serem abertas em cada worker, podendo ser usado com `createSvcForAllWorkers` para habilitar a comunicação de rede entre workers. Se este parâmetro não for configurado, apenas a porta 23456 no worker master será aberta por padrão. Portanto, certifique-se de que a porta 23456 não esteja incluída nesta lista de portas personalizadas. Importante Este parâmetro e `customPortNumPerWorker` são mutuamente exclusivos e não devem ser definidos simultaneamente.	Um conjunto de strings separadas por ponto e vírgula, onde cada string é um número de porta ou um intervalo de portas conectado por um hífen, como `10000;10001-10010` (que representa os 11 números de porta consecutivos de 10000 a 10010).
`customPortNumPerWorker`	PyTorch	Permite solicitar várias portas de rede para cada worker e pode ser usado com `createSvcForAllWorkers` para habilitar a comunicação de rede entre workers. Se esta configuração não for definida, apenas a porta 23456 será aberta no nó master por padrão. O DLC atribui portas aleatoriamente aos nós worker com base na quantidade de portas especificada. Os números de porta atribuídos são passados para os nós worker através da variável de ambiente `CUSTOM_PORTS`, que você pode consultar. O valor desta variável é uma lista de números de porta separados por ponto e vírgula. Importante Este parâmetro e `customPortList` são mutuamente exclusivos. Não os defina simultaneamente. Os recursos do Serviço de Computação Lingjun AI não fornecem o recurso de porta personalizada. Portanto, o parâmetro customPortNumPerWorker não é suportado ao enviar um job DLC que utilize recursos do Serviço de Computação Lingjun AI.	Um número inteiro até 65536.
`RayRuntimeEnv`	Ray	Quando o framework é Ray, configure manualmente o RayRuntimeEnv para definir o ambiente de execução. Importante Esta configuração substitui outras definições de variáveis de ambiente e bibliotecas de terceiros.	Configure variáveis de ambiente e bibliotecas de terceiros (`{pip: requirements.txt, env_vars: {key: value}}`)
`RayRedisAddress`	Ray	Endereço do servidor Redis GCS externo.	String
`RayRedisUsername`	Ray	Nome de usuário para o servidor Redis GCS externo.	String
`RayRedisPassword`	Ray	Senha para o servidor Redis GCS externo.	String
`RaySubmitterBackoffLimit`	Ray	Número de tentativas do submitter.	Inteiro positivo (int)
`RayObjectStoreMemoryBytes`	Ray	Configura memória compartilhada para um nó. Por exemplo, para configurar 1 GiB de memória compartilhada para cada nó, use a seguinte configuração: `{ "RayObjectStoreMemoryBytes": "1073741824" }`	Inteiro positivo (int)