Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Personnalisation à l'aide du SDK SageMaker Python

Le SDK SageMaker Python v3 introduit une API moderne et modulaire pour la formation, le réglage, le déploiement et la gestion de modèles sur. SageMaker Le SDK prend en charge plusieurs méthodes d'entraînement, notamment la pré-formation continue (CPT), le réglage fin supervisé (SFT), l'optimisation des préférences directes (DPO), le réglage fin du renforcement (RFT) et l'apprentissage par renforcement multi-tours (MTRL). Vous pouvez exécuter des tâches de formation sur SageMaker Training Jobs et SageMaker HyperPod.

Liens rapides

Suivez ces étapes pour passer de l'installation à votre premier stage de formation :

Avantages

Exigences

Versions de Python prises en charge

Le SDK SageMaker Python prend en charge Python 3.10 et versions ultérieures.

Installation

Pour installer le SDK SageMaker Python, exécutez la commande suivante :

pip install "sagemaker>=3.19.0"

Modèles et techniques pris en charge

Le SDK prend en charge les modèles et techniques suivants au sein de la famille Amazon Nova :

Multi-turn Résultat de l'apprentissage par renforcement

Un package de modèles restreints (RMP) est un package de modèles d' SageMaker IA qui intègre des artefacts de modèles propriétaires dans un stockage séquestre géré par la plateforme. Les RMP vous permettent d'autoriser et de contrôler l'utilisation de ces modèles par le biais de politiques IAM sans accorder d'accès direct aux artefacts sous-jacents. Les données du modèle ne peuvent pas être téléchargées, exportées ou visualisées directement. Il ne peut être utilisé que dans le cadre AWS des services autorisés. Les RMP existent dans les groupes de packages modèles marqués StorageType: "Restricted" par.

Lorsque vous entraînez un modèle à l'aide de l'apprentissage par renforcement multitour (MTRL) sur SageMaker Training Jobs Serverless, la sortie est fournie sous forme d'ARN RMP au sein d'un groupe de packages de modèles, plutôt que sous forme de chemin S3. Cela diffère des autres méthodes d'entraînement (telles que SFT, DPO ou RFT) dont la sortie est un chemin S3 vers le point de contrôle du modèle.

Pour utiliser MTRL, utilisez la MultiTurnRLTrainer classe. Lorsque vous vous entraînez sur SageMaker Training Jobs Serverless, vous pouvez éventuellement spécifier un output_model_package_group pour contrôler où le RMP de sortie est enregistré. En cas d'omission, le SDK crée automatiquement un groupe de packages de modèles pour vous. Pour plus d'informations et des exemples de code, voir Packages de modèles restreints.

Démarrage

1. Configurez votre infrastructure

Le SDK prend en charge trois plates-formes informatiques. Transmettez la configuration appropriée au compute paramètre de votre entraîneur.

SageMaker HyperPod

from sagemaker.core.training.configs import HyperPodCompute

compute = HyperPodCompute(
    cluster_name="my-hyperpod-cluster",
    instance_type="ml.p5.48xlarge",
    node_count=4,
)

SageMaker Emplois de formation (Serverful)

from sagemaker.core.training.configs import TrainingJobCompute

compute = TrainingJobCompute(
    instance_type="ml.p5.48xlarge",
    instance_count=2,
)

SageMaker Emplois de formation (sans serveur)

Entièrement géré, aucune configuration informatique n'est requise. Si vous omettez le compute paramètre, le SDK utilise le mode serverless par défaut :

# No compute parameter needed as serverless is the default
trainer = SFTTrainer(
    model="nova-textgeneration-lite-v2",
    training_dataset="s3://my-bucket/sft-data.jsonl",
    s3_output_path="s3://my-bucket/output/",
)

2. Entraînement

Commencez la mise au point supervisée avec la SFTTrainer classe. Fournissez votre modèle, votre configuration de calcul, votre jeu de données d'entraînement et votre chemin de sortie.

from sagemaker.train import SFTTrainer
from sagemaker.core.training.configs import HyperPodCompute

compute = HyperPodCompute(
    cluster_name="my-hyperpod-cluster",
    instance_type="ml.p5.48xlarge",
    node_count=4,
)

trainer = SFTTrainer(
    model="nova-textgeneration-lite-v2",
    compute=compute,
    training_dataset="s3://my-bucket/sft-data.jsonl",
    s3_output_path="s3://my-bucket/output/",
)

job = trainer.train(wait=False)

Le SDK permet également de poursuivre l'entraînement préalable, CPTTrainer d'optimiser les préférences directes, DPOTrainer de peaufiner RLVRTrainer les renforcements et d'apprendre par renforcement en plusieurs MultiTurnRLTrainer tours. Chacun suit le même schéma : fournir un modèle, une configuration de calcul, un jeu de données d'entraînement et un chemin de sortie.

3. Surveillance

Suivez la progression de votre entraînement directement depuis le SDK. Utilisez-le stream_logs() pour diffuser CloudWatch les journaux Amazon en temps réel ou show_metrics() pour tracer des indicateurs de formation tels que les pertes et le taux d'apprentissage une fois la tâche terminée.

# Stream CloudWatch logs in real-time (blocks until job completes)
trainer.stream_logs(poll=5)

# Or stream only the last N lines
trainer.stream_logs(tail_lines=50)

# Plot training metrics (training_loss, lr, reward_score)
df = trainer.show_metrics()

4. Evaluer

Évaluez votre modèle entraîné par rapport à des tâches de référence intégrées à l'aide de la BenchMarkEvaluator classe. Les benchmarks pris en charge incluent MMLU (Massive Multitask Language Understanding), BBH (Advanced Reasoning Tasks) et GPQA (Q&A). Graduate-Level Google-Proof Pour d'autres options d'évaluation, voir Évaluateurs.

from sagemaker.train.evaluate import BenchMarkEvaluator, get_benchmarks

# Get the trained model s3 path from the completed training job
s3_path = job.model_artifacts.s3_model_artifacts

Benchmark = get_benchmarks()

evaluator = BenchMarkEvaluator(
    benchmark=Benchmark.MMLU,
    model=s3_path,
    s3_output_path="s3://my-bucket/eval-output/",
)

execution = evaluator.evaluate()

5. Déploiement

Après la formation, déployez votre modèle personnalisé en production. Le SDK SageMaker Python vous permet de déployer sur des points de terminaison d' SageMaker Real-time inférence et Amazon Bedrock. On-Demand Choisissez l'option de déploiement qui correspond le mieux à vos exigences en matière de latence, de débit et de coûts.

SageMaker Real-time Inférence

Déployez sur un point de terminaison d' SageMaker Real-time inférence pour un contrôle total sur les types d'instances, les politiques de dimensionnement et la configuration des terminaux. Utilisez ModelBuilder pour créer et déployer un SageMaker point de terminaison :

from sagemaker.serve import ModelBuilder

# Get the trained model checkpoint path
s3_path = job.model_artifacts.s3_model_artifacts

# Deploy to SageMaker Real-time Inference endpoint
builder = ModelBuilder(
    model=s3_path,
    instance_type="ml.p5.48xlarge",
    env_vars={
        "CONTEXT_LENGTH": "8000",
        "MAX_CONCURRENCY": "2",
    },
)

builder.build().deploy()  # Build the model and deploy to an endpoint

Bedrock On-Demand

On-Demand l'inférence fournit une tarification à l'utilisation sans capacité provisionnée. Cette option s'applique aux LoRA-based personnalisations. À utiliser On-Demand lorsque vous avez des modèles de trafic variables ou imprévisibles :

from sagemaker.serve import BedrockModelBuilder

# Deploy with Bedrock On-Demand
builder = BedrockModelBuilder(
    model=s3_path,
    throughput_type="on-demand",
)

deployment = builder.deploy()

Capacités clés

Priorité d'annulation de la recette

Le SDK SageMaker Python utilise un système de configuration en couches pour les recettes d'entraînement. Lorsque vous lancez une tâche de formation, les paramètres sont résolus dans l'ordre de priorité suivant (du plus élevé au plus bas) :

Par exemple, pour modifier le nombre maximum d'étapes d'entraînement et le taux d'apprentissage tout en utilisant les valeurs par défaut du Hub pour tous les autres paramètres :

from sagemaker.train import SFTTrainer
from sagemaker.core.training.configs import HyperPodCompute

compute = HyperPodCompute(
    cluster_name="my-hyperpod-cluster",
    instance_type="ml.p5.48xlarge",
    node_count=2,
)

trainer = SFTTrainer(
    model="nova-textgeneration-lite-v2",
    training_dataset="s3://my-bucket/sft-data.jsonl",
    s3_output_path="s3://my-bucket/output/",
    base_job_name="my-sft-training-job",
    overrides={
        "training_config.trainer.max_epochs": 1,
        "training_config.model.optim.lr": 1e-5,
    },
)

job = trainer.train(wait=False)

Dans cet exemple, max_epochs et optim.lr sont définis explicitement via des remplacements. Tous les autres paramètres d'entraînement (taille du lot, étapes de préchauffage, modèle parallèle, etc.) sont répercutés sur la recette par défaut du Hub pour le modèle. nova-textgeneration-lite-v2

Support d'infrastructure d'entreprise

Le SDK prend en charge plusieurs plates-formes de calcul et gère automatiquement la configuration, la validation et l'orchestration des tâches de l'infrastructure :

Sur toutes les plateformes, le SDK valide les types d'instances, les configurations de recettes et les formats de jeu de données avant de soumettre les tâches, évitant ainsi les erreurs au début du flux de travail.

Évaluation complète

Évaluez vos modèles personnalisés par rapport à des critères de référence standard. Le SDK fournit les évaluateurs suivants :

Déploiement en production

Le SDK SageMaker Python vous permet de déployer vos modèles personnalisés à l'aide de plusieurs options de déploiement :

Utilisez ModelBuilder nos BedrockModelBuilder classes pour déployer des modèles entraînés.

Mixage de données

Le SDK SageMaker Python fournit la DataMixingConfig classe permettant de configurer le mixage des données.

À utiliser DataMixingConfig avec votre formateur pour spécifier le pourcentage de données clients et la répartition entre les catégories de données Nova :

from sagemaker.train import SFTTrainer
from sagemaker.train.data_mixing_config import DataMixingConfig
from sagemaker.core.training.configs import HyperPodCompute

data_mixing = DataMixingConfig(
    customer_data_percent=70.0,
    nova_data_percentages={
        "code": 40.0,
        "reasoning": 30.0,
        "instruction-following": 30.0,
    },
)

trainer = SFTTrainer(
    model="nova-textgeneration-lite-v2",
    compute=HyperPodCompute(
        cluster_name="my-cluster",
        instance_type="ml.p5.48xlarge",
        node_count=4,
    ),
    training_dataset="s3://my-bucket/sft-data.jsonl",
    s3_output_path="s3://my-bucket/output/",
    data_mixing_config=data_mixing,
)

job = trainer.train(wait=False)

En savoir plus

Êtes-vous prêt à commencer à personnaliser les modèles Nova avec le SDK SageMaker Python ? Pour des guides détaillés, des références d'API et des exemples supplémentaires, consultez https://github.com/aws/sagemaker-python-sdk sagemaker-python-sdk sur. GitHub