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.
# Gestion des modèles de chat et des tokeniseurs personnalisés
Les modèles de chat et les tokeniseurs personnalisés sont des composants essentiels pour formater correctement les entrées conversationnelles et gérer la génération de jetons dans vos modèles importés. L'importation de modèles personnalisés permet d'importer des modèles avec des modèles de chat personnalisés qui définissent la manière dont les conversations à plusieurs tours sont structurées et tokenisées.
## Importation de modèles avec des modèles de chat personnalisés
Lorsque vous importez un modèle avec des modèles de chat personnalisés, assurez-vous de suivre les meilleures pratiques décrites dans la documentation principale d'importation de modèles personnalisés, notamment en introduisant les poids des modèles au format de tenseurs sécurisés et en fournissant tous les fichiers de configuration nécessaires.
### Exigences relatives au format du modèle de chat
Si votre modèle utilise un modèle de chat personnalisé et que vous souhaitez utiliser ce modèle avec Amazon Bedrock, vous devez inclure le fichier du modèle de chat dans l'un des formats suivants :
+ **`chat_template.jinja`**— Un fichier modèle basé sur Jinja2 qui définit la façon dont les messages sont formatés.
+ **`chat_template.json`**— Un fichier JSON contenant le modèle de chat sous forme de chaîne.
+ **`tokenizer_config.json`avec modèle de chat intégré** — Vous pouvez également inclure le modèle de chat directement dans votre `tokenizer_config.json` fichier sous forme de `chat_template` champ. Pour un exemple, consultez le fichier [tokenizer\$1config.json d'Hermes-2-Pro sur Hugging Face](https://huggingface.co/NousResearch/Hermes-2-Pro-Llama-3-8B/blob/main/tokenizer_config.json#L2059).
L'importation de modèles personnalisés traitera automatiquement ces fichiers et les inclura dans les répertoires appropriés pendant le processus d'importation.
#### Priorité du modèle de chat
Si vous fournissez plusieurs sources de modèles de chat, Amazon Bedrock applique les règles de priorité suivantes :
1. Les **fichiers de modèles de discussion distincts ont priorité** : si vous incluez à la fois un fichier de modèle de discussion distinct (`chat_template.jinja`ou`chat_template.json`) ET un `chat_template` champ dans votre fichier`tokenizer_config.json`, le fichier distinct sera utilisé et le modèle intégré `tokenizer_config.json` sera ignoré.
1. **Modèle intégré comme solution de rechange** — Si vous ne fournissez pas de fichier de modèle de chat distinct, Amazon Bedrock utilisera le `chat_template` champ que vous utilisez `tokenizer_config.json` s'il est présent.
**Avertissement**
**Choisissez une approche :** pour éviter toute confusion et garantir un comportement prévisible, nous vous recommandons vivement de n'utiliser qu'UNE seule des approches suivantes :
**Option 1 :** Fournissez des fichiers de modèles de chat séparés (`chat_template.jinja`ou`chat_template.json`) sans inclure de `chat_template` champ dans votre`tokenizer_config.json`.
**Option 2 :** Incluez le `chat_template` champ directement dans votre fichier modèle `tokenizer_config.json` et ne fournissez pas de fichiers modèles distincts.
Si vous avez des modèles d'outils personnalisés ou des configurations de modèles de chat complexes, nous vous recommandons d'utiliser l'option 2 (intégration du modèle`tokenizer_config.json`) car elle vous permet de définir plusieurs modèles nommés (tels que « default » et « tool\$1use ») dans un seul fichier de configuration.
**Note**
Le fichier de modèle de chat doit respecter le format Hugging Face et les conventions de dénomination. Assurez-vous que votre modèle est compatible avec la Transformers bibliothèque.
#### Exemples de formats de modèles de chat
Voici des exemples des deux formats de modèles de chat pris en charge :
------
#### [ Jinja Format (chat\$1template.jinja) ]
Exemple simplifié de modèle de chat basé sur Jinja2 :
```
{% for message in messages %}
{% if loop.first and message['role'] != 'system' %}
<|im_start|>system
You are a helpful assistant.<|im_end|>
{% endif %}
<|im_start|>{{ message['role'] }}
{{ message['content'] }}<|im_end|>
{% endfor %}
{% if add_generation_prompt %}
<|im_start|>assistant
{% endif %}
```
Pour un exemple complet, consultez le [modèle de GPT-OSS chat](https://huggingface.co/openai/gpt-oss-20b/blob/main/chat_template.jinja) sur Hugging Face.
------
#### [ JSON Format (chat\$1template.json) ]
Exemple simplifié de modèle de chat basé sur JSON avec prise en charge de la vision :
```
{
"chat_template": "{% for message in messages %}{% if loop.first and message['role'] != 'system' %}<|im_start|>system\nYou are a helpful assistant.<|im_end|>\n{% endif %}<|im_start|>{{ message['role'] }}\n{% if message['content'] is string %}{{ message['content'] }}<|im_end|>\n{% else %}{% for content in message['content'] %}{% if content['type'] == 'image' %}<|vision_start|><|image_pad|><|vision_end|>{% elif 'text' in content %}{{ content['text'] }}{% endif %}{% endfor %}<|im_end|>\n{% endif %}{% endfor %}{% if add_generation_prompt %}<|im_start|>assistant\n{% endif %}"
}
```
Pour un exemple complet de support multimodal, consultez le [modèle de Qwen2-VL chat](https://huggingface.co/Qwen/Qwen2-VL-72B-Instruct/blob/main/chat_template.json) sur Hugging Face.
------
**Important**
Assurez-vous que votre fichier de modèle de chat respecte exactement la convention de dénomination (`chat_template.jinja`ou`chat_template.json`) et le format indiqués dans les exemples ci-dessus. Les modèles mal formatés peuvent entraîner des échecs d'importation ou d'inférence.
## Invoquer des modèles avec des modèles de chat personnalisés
Une fois que vous avez importé un modèle avec un modèle de chat personnalisé, deux options s'offrent à vous pour appeler le modèle avec des entrées de conversation correctement formatées :
### Utilisation de l' ChatCompletion API OpenAI avec des messages
Si vous fournissez des entrées au format du schéma des messages, vous devez utiliser l'API **OpenAI ChatCompletion **. Lorsque vous utilisez ce format d'API avec un modèle doté d'un modèle de chat téléchargé (`chat_template.jinja`ou`chat_template.json`), Amazon Bedrock convertit automatiquement vos messages d'entrée dans le format approprié à l'aide du modèle de chat.
C'est l'approche recommandée car elle fournit l'intégration la plus fluide possible et permet à Amazon Bedrock de gérer automatiquement l'application de modèle de chat.
**Exemple : utilisation de l' ChatCompletion API OpenAI avec un modèle de chat personnalisé**
```
import json
import boto3
# Initialize Bedrock Runtime client
client = boto3.client('bedrock-runtime', region_name='us-east-1')
# Define the model ARN for your imported model with custom chat template
model_id = 'arn:aws:bedrock:us-east-1:123456789012:imported-model/your-model-id'
# Prepare the request payload using messages format
payload = {
"messages": [
{
"role": "system",
"content": "You are a helpful assistant."
},
{
"role": "user",
"content": "Hello, how are you?"
}
],
"max_tokens": 150,
"temperature": 0.7
}
# Invoke the model
response = client.invoke_model(
modelId=model_id,
body=json.dumps(payload),
accept='application/json',
contentType='application/json'
)
# Parse and display the response
response_body = json.loads(response['body'].read())
print(json.dumps(response_body, indent=2))
```
Dans cet exemple, Amazon Bedrock appliquera automatiquement votre modèle de chat personnalisé au tableau de messages, le convertissant au format approprié pour votre modèle.
### Approche de tokenisation manuelle
Si vous préférez avoir un contrôle total sur l'application du modèle de chat et le processus de tokenisation, vous pouvez également appliquer manuellement le modèle de chat à votre conversation, puis utiliser l'**API de complétion** (non ChatCompletion) avec le texte préformaté.
Cette approche est utile lorsque vous devez personnaliser la logique de l'application modèle ou lorsque vous travaillez avec des exigences de tokenisation spécialisées.
#### Étape 1 : Appliquer le modèle de chat localement
Utilisez l'extrait de code suivant pour charger votre modèle de chat personnalisé et l'appliquer à une conversation en local :
```
from transformers import AutoTokenizer
# Configuration paths - update these with your actual paths
TOKENIZER_PATH = "" # Path to tokenizer directory
# Load tokenizer with updated chat template
tokenizer = AutoTokenizer.from_pretrained(TOKENIZER_PATH)
# Test chat template with sample conversation
chat_history = [
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": "Hello, how are you?"},
]
# Apply chat template and display formatted output to make sure chat template works as expected
formatted_chat = tokenizer.apply_chat_template(chat_history, tokenize=False)
print(formatted_chat)
```
Ce code montre comment :
1. Chargez la configuration de votre tokenizer à partir des fichiers modèles
1. Ajoutez le modèle de chat personnalisé à la configuration du tokenizer
1. Appliquer le modèle de chat à l'historique des conversations
1. Générez le texte formaté qui peut être envoyé au modèle
#### Étape 2 : Invoquer avec l'API de complétion
Après avoir appliqué le modèle de chat localement, utilisez le texte formaté avec l'API Completion :
```
import json
import boto3
# Initialize Bedrock Runtime client
client = boto3.client('bedrock-runtime', region_name='us-east-1')
# Define the model ARN for your imported model
model_id = 'arn:aws:bedrock:us-east-1:123456789012:imported-model/your-model-id'
# Use the formatted_chat output from Step 1 as the prompt
payload = {
"prompt": formatted_chat,
"max_tokens": 150,
"temperature": 0.7
}
# Invoke the model using Completion format (not ChatCompletion)
response = client.invoke_model(
modelId=model_id,
body=json.dumps(payload),
accept='application/json',
contentType='application/json'
)
# Parse and display the response
response_body = json.loads(response['body'].read())
print(json.dumps(response_body, indent=2))
```
**Avertissement**
**Toujours utiliser le `max_tokens` paramètre :** lorsque vous utilisez l'API de complétion avec des importations de modèles personnalisés, utilisez toujours le `max_tokens` paramètre pour garantir la compatibilité du schéma de complétion OpenAI. Cela permet d'éviter toute confusion de traduction et de garantir un comportement cohérent entre les différentes implémentations du SDK. N'utilisez pas de noms de paramètres spécifiques au modèle, tels que `max_gen_len` des variantes similaires.
**Important**
Lorsque vous utilisez l'approche de tokenisation manuelle, vous devez utiliser le format de l'**API de complétion** (avec `prompt` champ), et non le format de l' ChatCompletion API (avec `messages` champ). L' ChatCompletion API attend des messages bruts et tentera à nouveau d'appliquer le modèle de chat, ce qui entraînera un formatage incorrect.
### Bonnes pratiques
+ **Utilisez ChatCompletion l'API lorsque cela est possible** — L' ChatCompletion API OpenAI avec format de messages fournit l'expérience la plus fluide possible et permet à Amazon Bedrock de gérer automatiquement les applications de modèles de chat.
+ **Validez votre modèle de chat** : avant d'importer votre modèle, testez votre modèle de chat localement à l'aide de la Transformers bibliothèque pour vous assurer qu'il produit le format de sortie attendu.
+ **Inclure tous les jetons spéciaux** — Assurez-vous que votre modèle de chat inclut tous les jetons spéciaux nécessaires (tels que beginning-of-sequence, end-of-sequence, et les marqueurs de rôle) attendus par votre modèle.
+ **Testez avec des conversations à plusieurs tours** : vérifiez que votre modèle de chat gère correctement les conversations à plusieurs tours en alternant les messages de l'utilisateur et de l'assistant.
+ **Envisagez le support visuel** : si votre modèle prend en charge les entrées multimodales, assurez-vous que votre modèle de chat inclut une logique de gestion des marqueurs de contenu image et vidéo.
**Avertissement**
Des modèles de discussion mal formatés peuvent entraîner des performances médiocres du modèle, des sorties inattendues ou des échecs d'inférence. Testez toujours soigneusement votre modèle de chat avant de le déployer en production.