As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Lidando com modelos de bate-papo e tokenizadores personalizados
Modelos de bate-papo e tokenizadores personalizados são componentes essenciais para formatar adequadamente as entradas de conversação e gerenciar a geração de tokens em seus modelos importados. O Custom Model Import suporta a importação de modelos com modelos de bate-papo personalizados que definem como as conversas em vários turnos são estruturadas e tokenizadas.
## Importação de modelos com modelos de bate-papo personalizados
Ao importar um modelo com modelos de bate-papo personalizados, certifique-se de seguir as melhores práticas descritas na documentação principal de importação de modelos personalizados, incluindo incluir pesos do modelo em formato de tensores seguros e fornecer todos os arquivos de configuração necessários.
### Requisitos de formato do modelo de bate-papo
Se seu modelo usa um modelo de bate-papo personalizado e você deseja usar esse modelo com o Amazon Bedrock, você deve incluir o arquivo de modelo de bate-papo em um dos seguintes formatos:
+ **`chat_template.jinja`**— Um arquivo de modelo baseado em Jinja2 que define como as mensagens são formatadas.
+ **`chat_template.json`**— Um arquivo JSON contendo o modelo de bate-papo como um valor de string.
+ **`tokenizer_config.json`com modelo de bate-papo incorporado** — Como alternativa, você pode incluir o modelo de bate-papo diretamente no seu `tokenizer_config.json` arquivo como um `chat_template` campo. Por exemplo, veja o [Hermes-2-Pro tokenizer\$1config.json](https://huggingface.co/NousResearch/Hermes-2-Pro-Llama-3-8B/blob/main/tokenizer_config.json#L2059) em Hugging Face.
O Custom Model Import processará automaticamente esses arquivos e os incluirá nos diretórios corretos durante o processo de importação.
#### Precedência do modelo de bate-papo
Se você fornecer várias fontes de modelos de bate-papo, o Amazon Bedrock aplicará as seguintes regras de precedência:
1. **Arquivos de modelo de bate-papo separados têm precedência** — Se você incluir um arquivo de modelo de bate-papo separado (`chat_template.jinja`ou`chat_template.json`) E um `chat_template` campo no seu`tokenizer_config.json`, o arquivo separado será usado e o modelo incorporado `tokenizer_config.json` será ignorado.
1. **Modelo incorporado como substituto** — Se você não fornecer um arquivo de modelo de bate-papo separado, o Amazon Bedrock usará o `chat_template` campo do seu, `tokenizer_config.json` se estiver presente.
**Atenção**
**Escolha uma abordagem:** para evitar confusão e garantir um comportamento previsível, é altamente recomendável usar apenas UMA dessas abordagens:
**Opção 1:** forneça arquivos de modelo de bate-papo separados (`chat_template.jinja`ou`chat_template.json`) sem incluir um `chat_template` campo no seu`tokenizer_config.json`.
**Opção 2:** inclua o `chat_template` campo diretamente no seu `tokenizer_config.json` e não forneça arquivos de modelo separados.
Se você tiver modelos de ferramentas personalizados ou configurações complexas de modelos de bate-papo, recomendamos usar a Opção 2 (incorporar o modelo`tokenizer_config.json`), pois ela permite definir vários modelos nomeados (como “default” e “tool\$1use”) em um único arquivo de configuração.
**nota**
O arquivo do modelo de bate-papo deve seguir o formato e as convenções de nomenclatura do Hugging Face. Certifique-se de que seu modelo seja compatível com a Transformers biblioteca.
#### Exemplos de formato de modelo de bate-papo
Aqui estão alguns exemplos dos dois formatos de modelo de bate-papo compatíveis:
------
#### [ Jinja Format (chat\$1template.jinja) ]
Um exemplo simplificado de um modelo de bate-papo baseado em 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 %}
```
Para ver um exemplo completo, veja o [modelo de GPT-OSS bate-papo](https://huggingface.co/openai/gpt-oss-20b/blob/main/chat_template.jinja) em Hugging Face.
------
#### [ JSON Format (chat\$1template.json) ]
Um exemplo simplificado de um modelo de bate-papo baseado em JSON com suporte visual:
```
{
"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 %}"
}
```
Para ver um exemplo completo com suporte multimodal, veja o [modelo de Qwen2-VL bate-papo](https://huggingface.co/Qwen/Qwen2-VL-72B-Instruct/blob/main/chat_template.json) em Hugging Face.
------
**Importante**
Certifique-se de que seu arquivo de modelo de bate-papo siga a convenção de nomenclatura (`chat_template.jinja`ou`chat_template.json`) e o formato exatos mostrados nos exemplos acima. Modelos formatados incorretamente podem causar falhas de importação ou inferência.
## Invocando modelos com modelos de bate-papo personalizados
Depois de importar um modelo com um modelo de bate-papo personalizado, você tem duas opções para invocar o modelo com entradas de conversação formatadas corretamente:
### Usando a ChatCompletion API OpenAI com mensagens
**Se você estiver fornecendo entradas no formato de esquema de mensagens, você deve usar a API OpenAI. ChatCompletion ** Quando você usa esse formato de API com um modelo que tem um modelo de bate-papo carregado (`chat_template.jinja`ou`chat_template.json`), o Amazon Bedrock converte automaticamente suas mensagens de entrada no formato correto usando o modelo de bate-papo.
Essa é a abordagem recomendada, pois fornece a integração mais perfeita e permite que o Amazon Bedrock gerencie o aplicativo de modelo de bate-papo automaticamente.
**Exemplo: usando a ChatCompletion API OpenAI com modelo de bate-papo personalizado**
```
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))
```
Neste exemplo, o Amazon Bedrock aplicará automaticamente seu modelo de bate-papo personalizado à matriz de mensagens, convertendo-o no formato apropriado para seu modelo.
### Abordagem de tokenização manual
Como alternativa, se você preferir ter controle total sobre o aplicativo do modelo de bate-papo e o processo de tokenização, você pode aplicar manualmente o modelo de bate-papo à sua conversa e depois usar a **API de conclusão** (não ChatCompletion) com o texto pré-formatado.
Essa abordagem é útil quando você precisa personalizar a lógica do aplicativo de modelo ou ao trabalhar com requisitos especializados de tokenização.
#### Etapa 1: aplicar o modelo de bate-papo localmente
Use o seguinte trecho de código para carregar seu modelo de bate-papo personalizado e aplicá-lo a uma conversa localmente:
```
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)
```
Esse código demonstra como:
1. Carregue sua configuração de tokenizador a partir dos arquivos de modelo
1. Adicione o modelo de bate-papo personalizado à configuração do tokenizer
1. Aplique o modelo de bate-papo a um histórico de conversas
1. Gere o texto formatado que pode ser enviado para o modelo
#### Etapa 2: Invocar com a API de conclusão
Depois de aplicar o modelo de bate-papo localmente, use o texto formatado com a API de conclusão:
```
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))
```
**Atenção**
**Sempre use o `max_tokens` parâmetro:** ao usar a API de conclusão com importações de modelos personalizados, sempre use o `max_tokens` parâmetro para garantir a compatibilidade do esquema de preenchimento do OpenAI. Isso evita qualquer confusão de tradução e garante um comportamento consistente em diferentes implementações de SDK. Não use nomes de parâmetros específicos do modelo, como `max_gen_len` ou variantes semelhantes.
**Importante**
Ao usar a abordagem de tokenização manual, você deve usar o formato da **API de conclusão** (com `prompt` campo), não o formato da ChatCompletion API (com `messages` campo). A ChatCompletion API espera mensagens brutas e tentará aplicar o modelo de bate-papo novamente, resultando em uma formatação incorreta.
### Práticas recomendadas
+ **Use a ChatCompletion API sempre que possível** — A ChatCompletion API OpenAI com formato de mensagens fornece a experiência mais perfeita e permite que o Amazon Bedrock gerencie automaticamente o aplicativo de modelo de bate-papo.
+ **Valide seu modelo de bate-papo** — Antes de importar seu modelo, teste seu modelo de bate-papo localmente usando a Transformers biblioteca para garantir que ele produza o formato de saída esperado.
+ **Inclua todos os tokens especiais** — Certifique-se de que seu modelo de bate-papo inclua todos os tokens especiais necessários (como beginning-of-sequence end-of-sequence, e marcadores de função) que seu modelo espera.
+ **Teste com conversas em vários turnos** — confirme se seu modelo de bate-papo lida corretamente com conversas em vários turnos com mensagens alternadas do usuário e do assistente.
+ **Considere o suporte visual** — Se seu modelo suportar entradas multimodais, certifique-se de que seu modelo de bate-papo inclua lógica para lidar com marcadores de conteúdo de imagem e vídeo.
**Atenção**
Modelos de bate-papo formatados incorretamente podem resultar em baixo desempenho do modelo, resultados inesperados ou falhas de inferência. Sempre teste seu modelo de chat minuciosamente antes de implantá-lo na produção.