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 personnalisés et des tokeniseurs
Les modèles de chat personnalisés et les tokeniseurs 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 discussion personnalisés qui définissent la manière dont les conversations à plusieurs tours sont structurées et symbolisées.
## Importer des 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 sur l'importation de modèles personnalisés, notamment en introduisant les pondérations des modèles dans un format de tenseurs sécurisé 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`**— Fichier Jinja2-based modèle qui définit la mise en forme des messages.
+ **`chat_template.json`**— Un fichier JSON contenant le modèle de chat sous forme de valeur 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 en tant que `chat_template` champ. Pour un exemple, consultez le fichier [ Hermes-2-Pro ](https://huggingface.co/NousResearch/Hermes-2-Pro-Llama-3-8B/blob/main/tokenizer_config.json#L2059) tokenizer\_config.json sur Hugging Face.
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é des modèles de chat
Si vous fournissez plusieurs sources de modèles de chat, Amazon Bedrock applique les règles de priorité suivantes :
1. **Les fichiers modèles de chat distincts ont la priorité ** — Si vous incluez à la fois un fichier modèle de chat 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 avez créé, `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 de ces approches :
**Option 1 : ** Fournissez des fichiers 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 séparés.
Si vous disposez de modèles d'outils personnalisés ou de configurations de modèles de chat complexes, nous vous recommandons d'utiliser l'Option 2 (intégrer le modèle`tokenizer_config.json`) car elle vous permet de définir plusieurs modèles nommés (tels que « default » et « tool\_use ») dans un seul fichier de configuration.
**Note**
Le fichier 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\_template.jinja) ]
Exemple simplifié de modèle de Jinja2-based chat :
```
{% 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\_template.json) ]
Voici un exemple simplifié de modèle de JSON-based chat avec vision support :
```
{
"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 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. Des 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 invoquer le modèle avec des entrées conversationnelles correctement formatées :
### Utilisation de l' ChatCompletion API OpenAI avec des messages
Si vous fournissez des entrées au format de schéma de messages, vous devez utiliser l' ChatCompletion API ** ** OpenAI. Lorsque vous utilisez ce format d'API avec un modèle pour lequel un modèle de chat a été 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.
Il s'agit de 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 dans le format approprié à votre modèle.
### Approche de tokenisation manuelle
Sinon, 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 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 devez répondre à des exigences spécifiques en matière de tokenisation.
#### É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 mis en forme 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 évite toute confusion en matière de traduction et garantit 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` ou 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îne un formatage incorrect.
### Bonnes pratiques
+ **Utilisez ChatCompletion l'API lorsque cela est possible ** — L' ChatCompletion API OpenAI avec format de messages offre l'expérience la plus fluide et permet à Amazon Bedrock de gérer automatiquement l'application de modèle 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.
+ **Incluez tous les jetons spéciaux ** : assurez-vous que votre modèle de chat inclut tous les jetons spéciaux nécessaires (tels que les marqueurs de début de séquence, de fin de séquence et de rôle) que votre modèle attend.
+ **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 l'assistance visuelle ** : si votre modèle prend en charge les entrées multimodales, assurez-vous que votre modèle de chat inclut une logique pour gérer les marqueurs de contenu des images et des vidéos.
**Avertissement**
Des modèles de chat mal formatés peuvent entraîner de mauvaises performances du modèle, des résultats inattendus ou des échecs d'inférence. Testez toujours minutieusement votre modèle de chat avant de le déployer en production.