Platform For AI:Soumettre une tâche d'entraînement

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

Étape 1 : Préparer votre script d'entraînement

Rédigez votre script d'entraînement en local. PAI provisionne l'environnement cloud et l'exécute. Le script doit respecter les conventions suivantes pour s'intégrer au runtime PAI.

Variables d'environnement disponibles dans le conteneur d'entraînement

PAI injecte les variables d'environnement suivantes dans chaque conteneur d'entraînement. Référencez-les dans votre script d'entraînement ou votre commande de démarrage.

Charger les hyperparamètres

Lorsque vous définissez hyperparameters sur l'objet Estimator, PAI écrit les valeurs dans {PAI_CONFIG_DIR}/hyperparameters.json (chemin par défaut : /ml/input/config/hyperparameters.json).

Lisez les hyperparamètres à partir de ce fichier :

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)

Par exemple, hyperparameters={"batch_size": 32, "learning_rate": 0.01} produit :

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

Vous pouvez également utiliser PAI_USER_ARGS pour transmettre tous les hyperparamètres à votre script sous forme d'arguments de ligne de commande :

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

Analysez-les dans le script d'entraînement à l'aide de argparse.

Pour hyperparameters={"epochs": 10, "batch-size": 32, "train.learning_rate": 0.001}, PAI génère :

PAI_HPS_EPOCHS=10
PAI_HPS_BATCH_SIZE=32
PAI_HPS_TRAIN_LEARNING_RATE=0.001

Charger les données d'entrée

Transmettez les données d'entrée via le paramètre inputs de Estimator.fit(). Chaque entrée est une paire clé-valeur où la clé correspond au nom du canal et la valeur à un chemin OSS ou File Storage NAS (NAS) :

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

PAI monte les données à l'emplacement /ml/input/data/{channel_name}/. Lisez le chemin de montage à l'aide de 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 le chemin OSS se termine par / , la variable d'environnement pointe vers un répertoire. S'il se termine par un nom de fichier, elle pointe vers ce fichier.

Enregistrer le modèle de sortie

Enregistrez le modèle entraîné dans le chemin spécifié par PAI_OUTPUT_MODEL (par défaut : /ml/output/model/). PAI télécharge automatiquement vers OSS tout élément écrit dans cet emplacement.

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

Exemple de script complet

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

Ajouter des dépendances tierces

Si votre script nécessite des packages Python non inclus dans l'image d'entraînement, ajoutez un fichier requirements.txt dans le même répertoire que votre script. PAI installe les packages répertoriés avant d'exécuter le script.

Organisez votre répertoire de code comme suit :

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

Définissez source_dir="train_src" sur l'objet Estimator pour empaqueter et télécharger ce répertoire vers PAI.

Étape 2 : Choisir une image d'entraînement

Spécifiez une image de conteneur incluant votre framework et les dépendances de bibliothèque. Utilisez une image prédéfinie PAI ou une image personnalisée depuis Container Registry (ACR).

Utiliser une image prédéfinie 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")

Pour obtenir la liste des bibliothèques tierces préinstallées dans les images PAI, consultez la page Images publiques .

Étape 3 : Soumettre la tâche

Créez une instance Estimator et appelez fit() pour soumettre la tâche. Après la soumission, PAI affiche l'URL de la page des détails de la tâche et diffuse les journaux jusqu'à ce que la tâche réussisse, échoue ou s'arrête.

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

Paramètres clés :

• command — La commande de démarrage que PAI exécute à l'intérieur du conteneur (par exemple, python train.py).

• source_dir — Répertoire local contenant votre script d'entraînement et ses dépendances. PAI empaquette et télécharge son contenu. Accepte également un chemin OSS vers une archive TAR (par exemple, oss://<YourOssBucket>/source.tar.gz). Si requirements.txt existe dans ce répertoire, les dépendances sont installées automatiquement avant l'exécution de la tâche.

• image_uri — URI de l'image de conteneur. Utilisez retrieve() pour obtenir l'URI d'une image prédéfinie PAI, ou fournissez l'URI d'une image ACR personnalisée.

• instance_type — Type d'instance ECS pour l'entraînement (par exemple, ecs.c6.large).

• hyperparameters — Paires clé-valeur transmises au script d'entraînement. Les valeurs sont écrites dans hyperparameters.json et également exposées sous forme de variables d'environnement.

• base_job_name — Préfixe du nom de la tâche. Le nom complet suit le format {base_job_name}_{submitted-datetime}.

Une fois que fit() a retourné un résultat, appelez est.model_data() pour obtenir le chemin OSS du modèle enregistré.

Déboguer en local

Le débogage dans le cloud peut être lent. Exécutez et déboguez une tâche d'entraînement localement en définissant instance_type="local". La tâche s'exécute dans un conteneur 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