Déployez un modèle préoptimisé

Certains modèles JumpStart sont préoptimisés par SageMaker, ce qui signifie que vous pouvez déployer des versions optimisées de ces modèles sans créer au préalable une tâche d'optimisation des inférences. Pour la liste des modèles dotés d'options préoptimisées, voirRéférence des modèles pris en charge.

Utilisez la procédure suivante pour déployer un JumpStart modèle préoptimisé à l'aide d'Amazon SageMaker Studio.

Pour déployer un modèle préoptimisé

Dans Studio, dans le menu de navigation de gauche, choisissez JumpStart.
Sur la page Tous les modèles publics, choisissez l'un des modèles préoptimisés.
Sur la page des détails du modèle, choisissez Deploy.
Sur la page de déploiement, certains JumpStart modèles nécessitent que vous signiez un contrat de licence utilisateur final (EULA) avant de pouvoir continuer. Si nécessaire, consultez les termes du contrat de licence dans la section Contrat de licence. Si les conditions sont acceptables pour votre cas d'utilisation, cochez la case « J'accepte les EULA » et lisez les termes et conditions.

Pour de plus amples informations, veuillez consulter Contrats de licence de l'utilisateur final.
Pour le nom du point de terminaison et le nombre d'instances initial, acceptez les valeurs par défaut ou définissez des valeurs personnalisées.
Pour le type d'instance, conservez la valeur par défaut. Dans le cas contraire, vous ne pouvez pas déployer de configuration préoptimisée.
Sous Modèles, développez la configuration du modèle. Studio affiche un tableau qui fournit les configurations préoptimisées parmi lesquelles vous pouvez choisir. Chaque option comporte des métriques de latence et de débit. Choisissez l'option qui répond le mieux aux besoins de votre application.
Choisissez Deploy (Déployer).

Avec Amazon SageMaker PythonSDK, vous pouvez déployer un modèle préoptimisé. Tout d'abord, vous définissez le modèle à l'aide de la ModelBuilder classe. Ensuite, vous créez le modèle. Enfin, vous déployez le modèle à l'aide de la Model classe.

Pour configurer votre projet

Dans le code de votre application, importez les bibliothèques nécessaires. L'exemple suivant importe le SDK for Python (Boto3). Il importe également les modules d'Amazon SageMaker Python SDK que vous utilisez pour définir et utiliser des modèles :
```
import boto3
from sagemaker.serve.builder.model_builder import ModelBuilder
from sagemaker.serve.builder.schema_builder import SchemaBuilder
from sagemaker.session import Session
```
Initialisez une SageMaker session. L'exemple suivant utilise la Session() classe dans Amazon SageMaker Python SDK :
```
sagemaker_session = Session()
```

Pour définir votre modèle

Créez une SchemaBuilder instance et fournissez des échantillons d'entrée et de sortie. Vous fournissez cette instance à la ModelBuilder classe lorsque vous définissez un modèle. Il génère SageMaker automatiquement les fonctions de triage pour la sérialisation et la désérialisation de l'entrée et de la sortie.

Pour plus d'informations sur l'utilisation SchemaBuilder des ModelBuilder classes et, consultezCréez un modèle sur Amazon SageMaker avec ModelBuilder.

L'exemple suivant fournit des exemples de chaînes d'entrée et de sortie à la SchemaBuilder classe :
```
response = "Jupiter is the largest planet in the solar system. It is the fifth planet from the sun."
sample_input = {
    "inputs": "What is the largest planet in the solar system?",
    "parameters": {"max_new_tokens": 128, "top_p": 0.9, "temperature": 0.6},
}
sample_output = [{"generated_text": response}]
schema_builder = SchemaBuilder(sample_input, sample_output)
```
Définissez votre modèle pour SageMaker. L'exemple suivant définit les paramètres pour initialiser une ModelBuilder instance :
```
model_builder = ModelBuilder(
    model="jumpstart-model-id",
    schema_builder=schema_builder,
    sagemaker_session=sagemaker_session,
    role_arn=sagemaker_session.get_caller_identity_arn(),
)
```
Cet exemple utilise un JumpStart modèle. Remplacez jumpstart-model-id par l'ID d'un JumpStart modèle, tel quemeta-textgeneration-llama-3-70b.

Pour récupérer des métriques de référence

Pour déterminer la configuration préoptimisée que vous souhaitez déployer, recherchez les options proposées SageMaker . L'exemple suivant les affiche :


model_builder.display_benchmark_metrics()

Cette display_benchmark_metrics() méthode imprime un tableau comme celui-ci :


| Instance Type   | Config Name   |   Concurrent Users |   Latency, TTFT (P50 in sec) |   Throughput (P50 in tokens/sec/user) |
|:----------------|:--------------|-------------------:|-----------------------------:|--------------------------------------:|
| ml.g5.48xlarge  | lmi-optimized |                  1 |                         2.25 |                                 49.70 |
| ml.g5.48xlarge  | lmi-optimized |                  2 |                         2.28 |                                 21.10 |
| ml.g5.48xlarge  | lmi-optimized |                  4 |                         2.37 |                                 14.10 |
. . .
| ml.p4d.24xlarge | lmi-optimized |                  1 |                         0.10 |                                137.40 |
| ml.p4d.24xlarge | lmi-optimized |                  2 |                         0.11 |                                109.20 |
| ml.p4d.24xlarge | lmi-optimized |                  4 |                         0.13 |                                 85.00 |
. . .

Dans la première colonne, le tableau répertorie les types d'instances potentiels que vous pouvez utiliser pour héberger le JumpStart modèle que vous avez choisi. Pour chaque type d'instance, sousConfig Name, il répertorie les noms des configurations préoptimisées. Les configurations SageMaker fournies sont nomméeslmi-optimized. Pour chaque type d'instance et chaque configuration, le tableau fournit des mesures de référence. Ces mesures indiquent le débit et la latence que votre modèle prendra en charge pour différents nombres d'utilisateurs simultanés.

Sur la base des indicateurs de référence, choisissez le type d'instance et le nom de configuration qui répondent le mieux à vos besoins en matière de performances. Vous utiliserez ces valeurs lorsque vous créerez une configuration de déploiement.

Pour déployer un modèle préoptimisé

Créez une configuration de déploiement. L'exemple suivant utilise une ModelBuilder instance. Il transmet un type d'instance et un nom de configuration à la set_deployment_config() méthode :
```
model_builder.set_deployment_config(
    config_name="config-name", 
    instance_type="instance-type",
)
```
Remplacez nom-configuration avec un nom de configuration issu de la table, tel quelmi-optimized. Remplacez instance-type par un type d'instance figurant dans le tableau, tel queml.p4d.24xlarge.
Construisez votre modèle. L'exemple suivant utilise la .build() méthode de l'ModelBuilderinstance :
```
optimized_model = model_builder.build()
```
La .build() méthode renvoie une Model instance déployable.
Déployez votre modèle sur un point de terminaison d'inférence. L'exemple suivant utilise la .deploy() méthode de l'Modelinstance :
```
predictor = optimized_model.deploy(accept_eula=True)
```
La deploy() méthode renvoie une Predictor instance que vous pouvez utiliser pour envoyer des demandes d'inférence au modèle.

Pour tester votre modèle à l'aide d'une demande d'inférence

Après avoir déployé votre modèle sur un point de terminaison d'inférence, testez les prédictions du modèle. L'exemple suivant envoie une demande d'inférence à l'aide de l'Predictorinstance :
```
predictor.predict(sample_input)
```
Le modèle renvoie le texte qu'il génère avec une réponse comme celle-ci :
```
{'generated_text': ' Jupiter is the largest planet in the solar system. It is the fifth planet from the sun. It is a gas giant with . . .'}
```

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Optimisation de l'inférence du modèle

Création d'une tâche d'optimisation