Platform For AI:Envío de un trabajo de entrenamiento

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())

Paso 1: Preparación del script de entrenamiento

Escriba su script de entrenamiento de forma local. PAI aprovisiona el entorno en la nube y lo ejecuta. El script debe seguir estas convenciones para integrarse con el entorno de ejecución de PAI.

Variables de entorno disponibles en el contenedor de entrenamiento

PAI inyecta las siguientes variables de entorno en cada contenedor de entrenamiento. Puede hacer referencia a ellas en su script de entrenamiento o en el comando de inicio.

Carga de hiperparámetros

Cuando establece hyperparameters en Estimator, PAI escribe los valores en {PAI_CONFIG_DIR}/hyperparameters.json (ruta predeterminada: /ml/input/config/hyperparameters.json).

Lea los hiperparámetros desde este archivo:

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 ejemplo, hyperparameters={"batch_size": 32, "learning_rate": 0.01} genera:

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

Como alternativa, utilice PAI_USER_ARGS para pasar todos los hiperparámetros a su script como argumentos de línea de comandos:

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

Analícelos sintácticamente en el script de entrenamiento mediante argparse.

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

PAI_HPS_EPOCHS=10
PAI_HPS_BATCH_SIZE=32
PAI_HPS_TRAIN_LEARNING_RATE=0.001

Carga de datos de entrada

Pase los datos de entrada mediante el parámetro inputs de Estimator.fit(). Cada entrada es un par clave-valor donde la clave es el nombre del canal y el valor es una ruta de OSS o de File Storage NAS (NAS):

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

PAI monta los datos en /ml/input/data/{channel_name}/. Obtenga la ruta de montaje mediante 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/

Si la ruta de OSS termina con / , la variable de entorno apunta a un directorio. Si termina con un nombre de archivo, apunta a dicho archivo.

Guardado del modelo de salida

Guarde el modelo entrenado en la ruta especificada por PAI_OUTPUT_MODEL (predeterminada: /ml/output/model/). PAI carga automáticamente en OSS cualquier contenido escrito en esa ubicación.

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"))

Ejemplo 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()

Incorporación de dependencias de terceros

Si su script requiere paquetes de Python no incluidos en la imagen de entrenamiento, agregue un archivo requirements.txt en el mismo directorio que su script. PAI instala los paquetes listados antes de ejecutar el script.

Organice su directorio de código de la siguiente manera:

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

Establezca source_dir="train_src" en Estimator para empaquetar y cargar este directorio en PAI.

Paso 2: Elección de una imagen de entrenamiento

Especifique una imagen de contenedor que incluya su framework y las dependencias de bibliotecas. Utilice una imagen precompilada de PAI o una imagen personalizada de Container Registry (ACR).

Uso de una imagen precompilada de 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 consultar la lista de bibliotecas de terceros preinstaladas en las imágenes de PAI, consulte Public images .

Paso 3: Envío del trabajo

Cree una instancia de Estimator y llame a fit() para enviar el trabajo. Tras el envío, PAI muestra la URL de la página de detalles del trabajo y transmite los registros hasta que el trabajo se completa correctamente, falla o se detiene.

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 clave:

• command — El comando de inicio que PAI ejecuta dentro del contenedor (por ejemplo, python train.py).

• source_dir — Directorio local que contiene su script de entrenamiento y sus dependencias. PAI empaqueta y carga su contenido. También acepta una ruta de OSS a un archivo TAR (por ejemplo, oss://<YourOssBucket>/source.tar.gz). Si existe requirements.txt en este directorio, las dependencias se instalan automáticamente antes de ejecutar el trabajo.

• image_uri — URI de la imagen de contenedor. Utilice retrieve() para obtener la URI de una imagen precompilada de PAI o proporcione la URI de una imagen personalizada de ACR.

• instance_type — Tipo de instancia ECS para el entrenamiento (por ejemplo, ecs.c6.large).

• hyperparameters — Pares clave-valor que se pasan al script de entrenamiento. Los valores se escriben en hyperparameters.json y también se exponen como variables de entorno.

• base_job_name — Prefijo para el nombre del trabajo. El nombre completo sigue el formato {base_job_name}_{submitted-datetime}.

Después de que fit() finalice, llame a est.model_data() para obtener la ruta de OSS del modelo guardado.

Depuración local

La depuración en la nube puede ser lenta. Ejecute y depure un trabajo de entrenamiento localmente estableciendo instance_type="local". El trabajo se ejecuta en un contenedor de 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