Platform For AI:Envie um job de treinamento

from pai.estimator import Estimator

est = Estimator(
    command="<LaunchCommand>",
    source_dir="<SourceCodeDirectory>",
    image_uri="<TrainingImageUri>",
    instance_type="<TrainingInstanceType>",
    hyperparameters={
        "n_estimators": 500,
        "max_depth": 5,
    },
)

est.fit(
    inputs={
        "train_data": "oss://<YourOssBucket>/path/to/train/data/",
    }
)

# Get the OSS path of the output model.
print(est.model_data())

Etapa 1: Prepare seu script de treinamento

Escreva seu script de treinamento localmente. O PAI provisiona o ambiente na nuvem e executa o script. Para integrar-se ao runtime do PAI, o script deve seguir estas convenções.

Variáveis de ambiente disponíveis no contêiner de treinamento

O PAI injeta as seguintes variáveis de ambiente em todos os contêineres de treinamento. Referencie-as no seu script de treinamento ou no comando de inicialização.

Carregue hiperparâmetros

Ao definir hyperparameters no Estimator, o PAI grava os valores em {PAI_CONFIG_DIR}/hyperparameters.json (caminho padrão: /ml/input/config/hyperparameters.json).

Leia os hiperparâmetros deste arquivo:

import json
import os

def load_hyperparameters():
    hps_path = os.path.join(os.environ["PAI_CONFIG_DIR"], "hyperparameters.json")
    with open(hps_path) as f:
        return json.load(f)

Por exemplo, hyperparameters={"batch_size": 32, "learning_rate": 0.01} gera:

{
  "batch_size": "32",
  "learning-rate": "0.01"
}

Como alternativa, use PAI_USER_ARGS para encaminhar todos os hiperparâmetros ao seu script como argumentos de linha de comando:

est = Estimator(
    command="python train.py $PAI_USER_ARGS",
    hyperparameters={
        "epochs": 10,
        "batch-size": 32,
        "learning-rate": 0.001,
    },
    # ...
)

Analise os argumentos no script de treinamento usando argparse.

Para hyperparameters={"epochs": 10, "batch-size": 32, "train.learning_rate": 0.001}, o PAI gera:

PAI_HPS_EPOCHS=10
PAI_HPS_BATCH_SIZE=32
PAI_HPS_TRAIN_LEARNING_RATE=0.001

Carregue dados de entrada

Passe os dados de entrada pelo parâmetro inputs de Estimator.fit(). Cada entrada é um par chave-valor, onde a chave é o nome do canal e o valor é um caminho do OSS ou do File Storage NAS (NAS):

est.fit(
    inputs={
        "train": "oss://<YourOssBucket>/train/data/train.csv",
        "test": "oss://<YourOssBucket>/test/data/",
    }
)

O PAI monta os dados em /ml/input/data/{channel_name}/. Obtenha o caminho de montagem usando PAI_INPUT_{CHANNEL_NAME}:

train_data = os.environ["PAI_INPUT_TRAIN"]   # /ml/input/data/train/
test_data  = os.environ["PAI_INPUT_TEST"]    # /ml/input/data/test/

Se o caminho do OSS terminar com / , a variável de ambiente aponta para um diretório. Se terminar com um nome de arquivo, ela aponta para esse arquivo específico.

Salve o modelo de saída

Salve o modelo treinado no caminho especificado por PAI_OUTPUT_MODEL (padrão: /ml/output/model/). O PAI faz upload automático de qualquer conteúdo gravado nesse local para o OSS.

import os

def save_model(model, model_dir=None):
    if model_dir is None:
        model_dir = os.environ["PAI_OUTPUT_MODEL"]
    # Write your model files to model_dir.
    # Example: torch.save(model.state_dict(), os.path.join(model_dir, "model.pth"))

Exemplo completo de script

import json
import os

def load_hyperparameters():
    hps_path = os.path.join(os.environ["PAI_CONFIG_DIR"], "hyperparameters.json")
    with open(hps_path) as f:
        return json.load(f)

def train(hps, train_data, test_data):
    """Add your model training code here."""
    pass

def save_model(model):
    output_path = os.environ["PAI_OUTPUT_MODEL"]
    # Write the model to output_path.
    pass

def run():
    # 1. Load hyperparameters.
    hps = load_hyperparameters()

    # 2. Load input data from mounted paths.
    train_data = os.environ["PAI_INPUT_TRAIN"]
    test_data  = os.environ["PAI_INPUT_TEST"]

    model = train(hps, train_data, test_data)

    # 3. Save the output model.
    save_model(model)

if __name__ == "__main__":
    run()

Adicione dependências de terceiros

Se seu script exigir pacotes Python não incluídos na imagem de treinamento, adicione um arquivo requirements.txt no mesmo diretório do script. O PAI instala os pacotes listados antes de executar o script.

Organize seu diretório de código da seguinte forma:

train_src/
├── requirements.txt   # Third-party dependencies
├── train.py           # Entry point; run with: python train.py
└── utils.py

Defina source_dir="train_src" no Estimator para empacotar e enviar este diretório ao PAI.

Etapa 2: Escolha uma imagem de treinamento

Especifique uma imagem de contêiner que inclua seu framework e dependências de biblioteca. Use uma imagem pré-construída do PAI ou uma imagem personalizada do Container Registry (ACR).

Use uma imagem pré-construída do PAI

from pai.image import retrieve, list_images, ImageScope

# List all PAI images for PyTorch.
for image_info in list_images(framework_name="PyTorch"):
    print(image_info)

# Get the TensorFlow 2.3 image for CPU training.
tf_image = retrieve(framework_name="TensorFlow", framework_version="2.3")

# Get the latest TensorFlow image for GPU training.
tf_gpu_image = retrieve(
    framework_name="TensorFlow",
    framework_version="latest",
    accelerator_type="GPU",
)

# Get the PyTorch 1.12 image for GPU training.
torch_gpu_image = retrieve(framework_name="PyTorch", framework_version="1.12",
                           accelerator_type="GPU")

Para obter uma lista das bibliotecas de terceiros pré-instaladas nas imagens do PAI, consulte Imagens públicas .

Etapa 3: Envie o job

Crie uma instância de Estimator e chame fit() para enviar o job. Após o envio, o PAI exibe a URL da página de detalhes do job e transmite os logs até que o job seja concluído com sucesso, falhe ou pare.

from pai.estimator import Estimator
from pai.image import retrieve

torch_image_uri = retrieve("PyTorch", framework_version="1.12").image_uri

est = Estimator(
    command="python train.py",
    source_dir="./train_src/",
    image_uri=torch_image_uri,
    instance_type="ecs.c6.large",
    hyperparameters={
        "n_estimators": 500,
        "objective": "reg:squarederror",
        "max_depth": 5,
    },
    base_job_name="example_train_job",
)

est.fit()

# Get the OSS path of the output model.
print(est.model_data())

Parâmetros principais:

• command — Comando de inicialização que o PAI executa dentro do contêiner (por exemplo, python train.py).

• source_dir — Diretório local contendo seu script de treinamento e dependências. O PAI empacota e envia seu conteúdo. Também aceita um caminho do OSS para um arquivo TAR (por exemplo, oss://<YourOssBucket>/source.tar.gz). Se requirements.txt existir neste diretório, as dependências serão instaladas automaticamente antes da execução do job.

• image_uri — URI da imagem de contêiner. Use retrieve() para obter a URI de uma imagem pré-construída do PAI ou forneça a URI de uma imagem personalizada do ACR.

• instance_type — Tipo de instância ECS para treinamento (por exemplo, ecs.c6.large).

• hyperparameters — Pares chave-valor passados ao script de treinamento. Os valores são gravados em hyperparameters.json e também expostos como variáveis de ambiente.

• base_job_name — Prefixo para o nome do job. O nome completo segue o formato {base_job_name}_{submitted-datetime}.

Após o retorno de fit(), chame est.model_data() para obter o caminho do OSS do modelo salvo.

Depure localmente

A depuração na nuvem pode ser lenta. Execute e depure um job de treinamento localmente definindo instance_type="local". O job roda em um contêiner Docker local.

est = Estimator(
    command="python train.py",
    source_dir="./train_src/",
    image_uri=torch_image_uri,
    instance_type="local",
)

est.fit(
    inputs={
        # OSS data is downloaded and mounted into the container.
        "train": "oss://<BucketName>/path-to-data/",
        # Local paths are mounted directly.
        "test": "/data/to/test/data",
    }
)

print(est.model_data())

/ml
├── usercode/               # Your code files (PAI_WORKING_DIR)
│   ├── requirements.txt
│   └── train.py
├── input/
│   ├── config/             # Job configuration (PAI_CONFIG_DIR)
│   │   └── hyperparameters.json
│   └── data/               # Input channels
│       ├── train/
│       │   └── train.csv
│       └── test/
│           └── test.csv
└── output/                 # Output channels
    ├── model/              # PAI_OUTPUT_MODEL
    └── checkpoints/        # PAI_OUTPUT_CHECKPOINTS