# Exemplos de fórmula de avaliação
O Amazon Nova oferece quatro tipos de fórmulas de avaliação, que estão disponíveis no repositório de fórmulas do SageMaker HyperPod no GitHub.
## Fórmulas gerais de referência de texto
Essas fórmulas permitem que você avalie as capacidades fundamentais dos modelos do Amazon Nova em um conjunto abrangente de referências somente de texto. Elas são fornecidas no formato `xxx_general_text_benchmark_eval.yaml`.
## Fórmulas de referência de traga seu próprio conjunto de dados
Essas fórmulas permitem que você traga seu próprio conjunto de dados para fins de avaliação comparativa e compare os resultados do modelo com as respostas de referência usando diferentes tipos de métrica. Elas são fornecidas no formato `xxx_bring_your_own_dataset_eval.yaml`.
A seguir são apresentados os requisitos para trazer seu próprio conjunto de dados:
+ Requisitos de formato de arquivo
+ Você deve incluir um único arquivo `gen_qa.jsonl` contendo exemplos de avaliação.
+ Seu conjunto de dados deve ser carregado em um local do S3 onde a tarefa de treinamento do SageMaker possa acessá-lo.
+ O arquivo deve seguir o formato de esquema exigido para um conjunto de dados geral de perguntas e respostas.
+ Requisitos de formato de esquema: cada linha do arquivo JSONL deve ser um objeto JSON com os seguintes campos:
+ `query`: (obrigatório) string contendo a pergunta ou instrução que precisa de uma resposta.
+ `response`: (obrigatório) string contendo a saída esperada do modelo.
+ `system`: (opcional) string contendo o prompt do sistema que define o comportamento, o perfil ou a personalidade do modelo de IA antes de processar a consulta.
+ `metadata`: (opcional) string contendo metadados associados à entrada para fins de marcação.
Este é um exemplo de entrada para trazer seu próprio conjunto de dados.
```
{
"system":"You are a english major with top marks in class who likes to give minimal word responses: ",
"query":"What is the symbol that ends the sentence as a question",
"response":"?"
}
{
"system":"You are a pattern analysis specialist that provides succinct answers: ",
"query":"What is the next number in this series? 1, 2, 4, 8, 16, ?",
"response":"32"
}
{
"system":"You have great attention to detail that follows instructions accurately: ",
"query":"Repeat only the last two words of the following: I ate a hamburger today and it was kind of dry",
"response":"of dry"
}
```
Para usar seu conjunto de dados personalizado, modifique sua fórmula de avaliação com os campos obrigatórios a seguir. Não altere nenhum conteúdo.
```
evaluation:
task: gen_qa
strategy: gen_qa
metric: all
```
As limitações a seguir se aplicam a:
+ Somente um arquivo JSONL é permitido por avaliação.
+ O arquivo deve seguir rigorosamente o esquema definido.
+ Limite de tamanho do contexto: para cada amostra no conjunto de dados, o tamanho do contexto (incluindo prompts do sistema \$1 consulta) deve ser inferior a 3,5 mil.
## Fórmulas de referência de LLM como avaliador do Nova
O LLM como avaliador do Amazon Nova é um recurso de avaliação de modelo que permite aos clientes comparar a qualidade das respostas de um modelo com a resposta de um modelo de referência em um conjunto de dados personalizado. Ele usa um conjunto de dados com prompts, respostas de referência e respostas do contestador e usa um modelo avaliador do Nova para fornecer uma métrica de taxa de acertos com base na [probabilidade de Bradley-Terry](https://en.wikipedia.org/wiki/Bradley%E2%80%93Terry_model) com comparações de pares.
As fórmulas são fornecidas no formato `xxx_llm_judge_eval.yaml`.
Estes são os requisitos do LLM como avaliador:
+ Requisitos de formato de arquivo
+ Inclua um único arquivo `llm_judge.jsonl` contendo exemplos de avaliação. O nome do arquivo deve ser `llm_judge.jsonl`.
+ Seu conjunto de dados deve ser carregado em um local do S3 que o [RIG do SageMaker AI SageMaker HyperPod](https://docs.aws.amazon.com/sagemaker/latest/dg/nova-hp-cluster.html) possa acessar.
+ O arquivo deve seguir o formato de esquema exigido para o conjunto de dados `llm_judge.jsonl`.
+ O conjunto de dados de entrada deve garantir que todos os registros tenham menos de 12 mil de comprimento de contexto.
+ Requisitos de formato de esquema: cada linha do arquivo JSONL deve ser um objeto JSON com os seguintes campos:
+ `prompt`: (obrigatório) uma string contendo o prompt para a resposta gerada.
+ `response_A`: uma string contendo a resposta de referência.
+ `response_B`: uma string contendo a resposta alternativa a ser comparada com a resposta de referência.
Este é um exemplo de entrada de LLM como avaliador.
```
{
"prompt": "What is the most effective way to combat climate change?",
"response_A": "The most effective way to combat climate change is through a combination of transitioning to renewable energy sources and implementing strict carbon pricing policies. This creates economic incentives for businesses to reduce emissions while promoting clean energy adoption.",
"response_B": "We should focus on renewable energy. Solar and wind power are good. People should drive electric cars. Companies need to pollute less."
}
{
"prompt": "Explain how a computer's CPU works",
"response_A": "CPU is like brain of computer. It does math and makes computer work fast. Has lots of tiny parts inside.",
"response_B": "A CPU (Central Processing Unit) functions through a fetch-execute cycle, where instructions are retrieved from memory, decoded, and executed through its arithmetic logic unit (ALU). It coordinates with cache memory and registers to process data efficiently using binary operations."
}
{
"prompt": "How does photosynthesis work?",
"response_A": "Plants do photosynthesis to make food. They use sunlight and water. It happens in leaves.",
"response_B": "Photosynthesis is a complex biochemical process where plants convert light energy into chemical energy. They utilize chlorophyll to absorb sunlight, combining CO2 and water to produce glucose and oxygen through a series of chemical reactions in chloroplasts."
}
```
Para usar seu conjunto de dados personalizado, modifique a fórmula de avaliação com os campos obrigatórios a seguir. Não altere nenhum conteúdo.
```
evaluation:
task: llm_judge
strategy: judge
metric: all
```
As limitações a seguir se aplicam a:
+ Somente um arquivo JSONL é permitido por avaliação.
+ O arquivo deve seguir rigorosamente o esquema definido.
+ Os modelos avaliadores do Amazon Nova são os mesmos em todas as especificações da família de modelos (ou seja, Lite, Micro e Pro).
+ No momento, não é possível usar modelos avaliadores.
+ Limite de tamanho do contexto: para cada amostra no conjunto de dados, o tamanho do contexto (incluindo prompts do sistema \$1 consulta) deve ser inferior a 7 mil.
## LLM como avaliador do Nova para fórmulas de avaliações comparativas multimodais (imagem)
O LLM como avaliador do Nova para multimodais (imagem), ou simplesmente Nova MM\$1LLM Judge, é um recurso de avaliação de modelos que permite que você compare a qualidade das respostas de um modelo com as respostas de um modelo de linha de base usando um conjunto de dados personalizado. Ele aceita um conjunto de dados contendo prompts, respostas de linha de base, respostas do desafiante e imagens no formato de string codificada em Base64, e depois usa um modelo avaliador do Nova para fornecer uma métrica de taxa de acertos com base na probabilidade de [Bradley-Terry](https://en.wikipedia.org/wiki/Bradley%E2%80%93Terry_model) por meio de comparações de pares. Formato da fórmula: `xxx_mm_llm_judge _eval.yaml`.
**Requisitos do conjunto de dados do LLM do Nova**
Formato do arquivo:
+ Um único arquivo `mm_llm_judge.jsonl` contendo exemplos de avaliação. O nome do arquivo deve ser exatamente `llm_judge.jsonl`.
+ Você deve fazer upload de seu conjunto de dados em um local do S3 que as tarefas de treinamento do SageMaker possam acessar.
+ O arquivo deve seguir o formato de esquema exigido para o conjunto de dados `mm_llm_judge`.
+ O conjunto de dados de entrada deve garantir que todos os registros estejam dentro do limite de 12 mil de contexto, excluindo o atributo da imagem.
Formato do esquema: cada linha no arquivo `.jsonl` deve ser um objeto JSON com os campos a seguir.
+ Campos obrigatórios.
`prompt`: string contendo o prompt para a resposta gerada.
`images`: matriz contendo uma lista de objetos com atributos de dados (os valores são strings de imagens codificadas em Base64).
`response_A`: string contendo a resposta de referência.
`response_B`: string contendo a resposta alternativa a ser comparada com a resposta de referência.
Exemplo de entrada
Para facilitar a leitura, o exemplo a seguir inclui novas linhas e recuo, mas no conjunto de dados real, cada registro deve estar em uma única linha.
```
{
"prompt": "what is in the image?",
"images": [
{
"data": "data:image/jpeg;Base64,/9j/2wBDAAQDAwQDAwQEAwQFBAQFBgo..."
}
],
"response_A": "a dog.",
"response_B": "a cat.",
}
{
"prompt": "how many animals in echo of the images?",
"images": [
{
"data": "data:image/jpeg;Base64,/9j/2wBDAAQDAwQDAwQEAwQFBAQFBgo..."
},
{
"data": "data:image/jpeg;Base64,/DKEafe3gihn..."
}
],
"response_A": "The first image contains one cat and the second image contains one dog",
"response_B": "The first image has one aminal and the second has one animal",
}
```
Para usar seu conjunto de dados personalizado, modifique a fórmula de avaliação com os campos obrigatórios a seguir. Não altere nenhum conteúdo.
```
evaluation:
task: mm_llm_judge
strategy: judge
metric: all
```
**Limitações**
+ Somente um arquivo `.jsonl` é permitido por avaliação.
+ O arquivo deve seguir rigorosamente o esquema definido.
+ Os modelos Nova MM Judge são compatíveis apenas com a referência de imagem.
+ Os modelos avaliadores MM são os mesmos nas especificações do Amazon Nova Lite.
+ No momento, não há compatibilidade para modelos avaliadores.
+ O URI de imagem do Amazon S3 não é compatível.
+ O conjunto de dados de entrada deve garantir que todos os registros estejam dentro do limite de 12 mil de contexto, excluindo o atributo de imagens.
## Rubric Based Judge
O Rubric Judge é um modelo aprimorado de avaliação LLM como avaliador criado no Nova 2.0 Lite. Ao contrário do [modelo original do avaliador](https://aws.amazon.com/blogs/machine-learning/evaluating-generative-ai-models-with-amazon-nova-llm-as-a-judge-on-amazon-sagemaker-ai/), que fornece apenas veredictos de preferência (A>B, B>A ou empate), o Rubric Judge gera dinamicamente critérios de avaliação personalizados para cada prompt e atribui pontuações granulares em várias dimensões.
Principais recursos:
+ **Geração dinâmica de critérios**: cria automaticamente dimensões de avaliação relevantes com base no prompt de entrada
+ **Pontuação ponderada**: atribui pesos de importância a cada critério para refletir sua significância relativa
+ **Avaliação granular**: fornece pontuações detalhadas em uma base binária (true/false) ou em escala (1–5) para cada critério
+ **Métricas de qualidade**: calcula pontuações de qualidade contínuas (escala 0–1) que quantificam a magnitude das diferenças entre as respostas
Exemplo de critério gerado pelo modelo:
```
price_validation:
description: "The response includes validation to ensure price is a positive value."
type: "scale"
weight: 0.3
```
O modelo avalia as duas respostas em relação a todos os critérios gerados e, em seguida, usa essas pontuações em nível de critério para informar sua decisão final de preferência.
**Topics**
+ [Configuração de fórmula](#nova-hp-evaluate-rubric-judge-recipe)
+ [Formato do conjunto de dados de entrada](#nova-hp-evaluate-rubric-judge-input)
+ [Resultado da avaliação](#nova-hp-evaluate-rubric-judge-output)
+ [Suporte ao modelo de raciocínio](#nova-hp-evaluate-rubric-judge-reasoning)
### Configuração de fórmula
**Fórmula do Rubric Judge**
Habilite o Rubric Judge definindo `task: rubric_llm_judge` em sua fórmula:
```
run:
name: nova-eval-job-name # [MODIFIABLE] Unique identifier for your evaluation job
model_type: amazon.nova-2-lite-v1:0:256k # [FIXED] Rubric Judge model type
model_name_or_path: "nova-lite-2/prod" # [FIXED] Path to model checkpoint or identifier
replicas: 1 # [MODIFIABLE] Number of replicas for SageMaker Training job
data_s3_path: "" # [FIXED] Leave empty for SageMaker Training job
output_s3_path: "" # [FIXED] Leave empty for SageMaker Training job
evaluation:
task: rubric_llm_judge # [FIXED] Evaluation task - enables Rubric Judge
strategy: judge # [FIXED] Evaluation strategy
metric: all # [FIXED] Metric calculation method
inference:
max_new_tokens: 12000 # [MODIFIABLE] Maximum tokens to generate
top_k: -1 # [MODIFIABLE] Top-k sampling parameter
top_p: 1.0 # [MODIFIABLE] Nucleus sampling parameter
temperature: 0 # [MODIFIABLE] Sampling temperature (0 = deterministic)
```
**Fórmula original do LLM como avaliador (para comparação)**
O modelo original do avaliador usa `task: llm_judge`:
```
run:
name: eval-job-name # [MODIFIABLE] Unique identifier for your evaluation job
model_type: amazon.nova-micro-v1:0:128k # [FIXED] Model type
model_name_or_path: "nova-micro/prod" # [FIXED] Path to model checkpoint or identifier
replicas: 1 # [MODIFIABLE] Number of replicas for SageMaker Training job
data_s3_path: "" # [FIXED] Leave empty for SageMaker Training job
output_s3_path: "" # [FIXED] Leave empty for SageMaker Training job
evaluation:
task: llm_judge # [FIXED] Original judge task
strategy: judge # [FIXED] Evaluation strategy
metric: all # [FIXED] Metric calculation method
inference:
max_new_tokens: 12000 # [MODIFIABLE] Maximum tokens to generate
top_k: -1 # [MODIFIABLE] Top-k sampling parameter
top_p: 1.0 # [MODIFIABLE] Nucleus sampling parameter
temperature: 0 # [MODIFIABLE] Sampling temperature (0 = deterministic)
```
### Formato do conjunto de dados de entrada
O formato do conjunto de dados de entrada é idêntico ao [modelo original do avaliador](https://aws.amazon.com/blogs/machine-learning/evaluating-generative-ai-models-with-amazon-nova-llm-as-a-judge-on-amazon-sagemaker-ai/):
**Campos obrigatórios:**
+ `prompt`: string contendo o prompt de entrada e as instruções
+ `response_A`: string contendo a saída de linha de base do modelo
+ `response_B`: string contendo a saída personalizada do modelo
**Exemplo de conjunto de dados (formato JSONL):**
```
{"prompt": "What is the most effective way to combat climate change?", "response_A": "The most effective way to combat climate change is through a combination of transitioning to renewable energy sources and implementing strict carbon pricing policies. This creates economic incentives for businesses to reduce emissions while promoting clean energy adoption.", "response_B": "We should focus on renewable energy. Solar and wind power are good. People should drive electric cars. Companies need to pollute less."}
{"prompt": "Explain how a computer's CPU works", "response_A": "CPU is like brain of computer. It does math and makes computer work fast. Has lots of tiny parts inside.", "response_B": "A CPU (Central Processing Unit) functions through a fetch-execute cycle, where instructions are retrieved from memory, decoded, and executed through its arithmetic logic unit (ALU). It coordinates with cache memory and registers to process data efficiently using binary operations."}
{"prompt": "How does photosynthesis work?", "response_A": "Plants do photosynthesis to make food. They use sunlight and water. It happens in leaves.", "response_B": "Photosynthesis is a complex biochemical process where plants convert light energy into chemical energy. They utilize chlorophyll to absorb sunlight, combining CO2 and water to produce glucose and oxygen through a series of chemical reactions in chloroplasts."}
```
**Requisitos de formato:**
+ Cada entrada deve ser um objeto JSON de linha única
+ Entradas separadas com novas linhas
+ Siga a nomenclatura exata do campo, conforme mostrado nos exemplos
### Resultado da avaliação
**Estrutura de saída**
O Rubric Judge gera métricas de avaliação aprimoradas em comparação com o modelo original do avaliador:
```
{
"config_general": {
"lighteval_sha": "string",
"num_fewshot_seeds": "int",
"max_samples": "int | null",
"job_id": "int",
"start_time": "float",
"end_time": "float",
"total_evaluation_time_secondes": "string",
"model_name": "string",
"model_sha": "string",
"model_dtype": "string | null",
"model_size": "string"
},
"results": {
"custom|rubric_llm_judge_judge|0": {
"a_scores": "float",
"a_scores_stderr": "float",
"b_scores": "float",
"b_scores_stderr": "float",
"ties": "float",
"ties_stderr": "float",
"inference_error": "float",
"inference_error_stderr": "float",
"score": "float",
"score_stderr": "float",
"weighted_score_A": "float",
"weighted_score_A_stderr": "float",
"weighted_score_B": "float",
"weighted_score_B_stderr": "float",
"score_margin": "float",
"score_margin_stderr": "float",
"winrate": "float",
"lower_rate": "float",
"upper_rate": "float"
}
},
"versions": {
"custom|rubric_llm_judge_judge|0": "int"
}
}
```
**Novas métricas no Rubric Judge**
As seis métricas abaixo são exclusivas do Rubric Judge e fornecem uma avaliação granular da qualidade:
| Métrica | Descrição |
| --- |--- |
| weighted\$1score\$1A | Pontuação média de qualidade normalizada para response\$1A em todos os critérios de avaliação gerados pelo modelo. As pontuações são ponderadas pela importância do critério e normalizadas para a escala 0–1 (maior = melhor qualidade) |
| weighted\$1score\$1A\$1stderr | Erro padrão da média para weighted\$1score\$1A, indicando incerteza estatística |
| weighted\$1score\$1B | Pontuação média de qualidade normalizada para response\$1B em todos os critérios de avaliação gerados pelo modelo. As pontuações são ponderadas pela importância do critério e normalizadas para a escala 0–1 (maior = melhor qualidade) |
| weighted\$1score\$1B\$1stderr | Erro padrão da média para weighted\$1score\$1B, indicando incerteza estatística |
| score\$1margin | Diferença entre as pontuações ponderadas (calculada como weighted\$1score\$1A - weighted\$1score\$1B). Intervalo: de -1,0 a 1,0. Positivo = response\$1A é melhor; negativo = response\$1B é melhor; próximo de zero = qualidade similar |
| score\$1margin\$1stderr | Erro padrão da média para score\$1margin, indicando incerteza na medição da diferença de qualidade |
**Noções básicas sobre as métricas de pontuação ponderada**
**Objetivo**: pontuações ponderadas fornecem medições de qualidade contínuas que complementam os veredictos de preferência binária, permitindo uma visão mais profunda sobre a performance do modelo.
**Principais diferenças em relação ao avaliador original**:
+ **Avaliador original**: gera apenas preferências discretas (A>B, B>A, A=B)
+ **Rubric Judge**: gera preferências e pontuações de qualidade contínuas (escala 0–1) com base em critérios personalizados
**Interpretação de score\$1margin**:
+ `score_margin = -0.128`: response\$1B obteve 12,8 pontos percentuais a mais do que response\$1A
+ `|score_margin| < 0.1`: diferença de qualidade mínima (decisão acirrada)
+ `|score_margin| > 0.2`: diferença clara de qualidade (decisão confiante)
**Casos de uso**:
+ **Melhoria do modelo**: identifique áreas específicas em que seu modelo tem uma performance inferior
+ **Quantificação da qualidade**: avalie a magnitude das lacunas de performance, não apenas as taxas de ganhos/perdas
+ **Avaliação de confiança**: faça a distinção entre decisões acirradas e diferenças claras de qualidade
**Importante**
Os veredictos finais ainda são baseados nos rótulos de preferência explícitos do modelo do avaliador para preservar o raciocínio holístico e garantir a mitigação adequada do viés de posição por meio de avaliação progressiva e retroativa. As pontuações ponderadas servem como ferramentas de observabilidade, não como substitutas do veredicto primário.
**Metodologia de cálculo**
As pontuações ponderadas são calculadas usando o seguinte processo:
+ **Extrair dados do critério**: analise a saída YAML do avaliador para extrair pontuações e pesos do critério
+ **Normalize as pontuações**:
+ Critérios do tipo de escala (1–5): normalize para 0–1 calculando `(score - 1) / 4`
+ Critérios binários (true/false): converter para 1,0/0,0
+ **Aplique pesos**: multiplique cada pontuação normalizada pelo peso do critério
+ **Agregado**: soma todas as pontuações ponderadas para cada resposta
+ **Calcular margem**: calcular `score_margin = weighted_score_A - weighted_score_B`
**Exemplo**: se response\$1A tiver uma soma ponderada de 0,65, e response\$1B tiver 0,78, `score_margin` seria -0,13, indicando que response\$1B tem 13 pontos percentuais a mais em qualidade em todos os critérios ponderados.
### Suporte ao modelo de raciocínio
O suporte ao modelo de raciocínio permite a avaliação com modelos Nova capazes de raciocinar que realizam raciocínio interno explícito antes de gerar respostas finais. Esse recurso usa o controle em nível de API por meio do parâmetro `reasoning_effort` para habilitar ou desabilitar dinamicamente a funcionalidade de raciocínio, melhorando potencialmente a qualidade da resposta para tarefas analíticas complexas.
**Modelos compatíveis**:
+ amazon.nova-2-lite-v1:0:256k
**Configuração de fórmula**
Habilite o raciocínio adicionando o parâmetro `reasoning_effort` à seção `inference` da sua fórmula:
```
run:
name: eval-job-name # [MODIFIABLE] Unique identifier for your evaluation job
model_type: amazon.nova-2-lite-v1:0:256k # [FIXED] Must be a reasoning-supported model
model_name_or_path: nova-lite-2/prod # [FIXED] Path to model checkpoint or identifier
replicas: 1 # [MODIFIABLE] Number of replicas for SageMaker Training job
data_s3_path: "" # [MODIFIABLE] Leave empty for SageMaker Training job; optional for job
output_s3_path: "" # [MODIFIABLE] Output path for job (not compatible with SageMaker Training jobs)
evaluation:
task: mmlu # [MODIFIABLE] Evaluation task
strategy: generate # [MODIFIABLE] Evaluation strategy
metric: all # [MODIFIABLE] Metric calculation method
inference:
reasoning_effort: high # [MODIFIABLE] Enables reasoning mode; options: low/medium/high or null to disable
max_new_tokens: 200 # [MODIFIABLE] Maximum tokens to generate
top_k: 50 # [MODIFIABLE] Top-k sampling parameter
top_p: 1.0 # [MODIFIABLE] Nucleus sampling parameter
temperature: 0 # [MODIFIABLE] Sampling temperature (0 = deterministic)
```
**Uso do parâmetro reasoning\$1effort**
O parâmetro `reasoning_effort` controla o comportamento do raciocínio para modelos capazes de raciocinar.
**Pré-requisitos**:
+ **Compatibilidade do modelo**: defina `reasoning_effort` somente quando `model_type` especificar um modelo capaz de raciocínio (atualmente `amazon.nova-2-lite-v1:0:256k`)
+ **Tratamento de erros**: o uso de `reasoning_effort` com modelos não compatíveis falhará com `ConfigValidationError: "Reasoning mode is enabled but model '{model_type}' does not support reasoning. Please use a reasoning-capable model or disable reasoning mode."`
**Opções disponíveis**:
| Opção | Comportamento | Limite de tokens | Caso de uso |
| --- |--- |--- |--- |
| null (padrão) | Desabilita o modo de raciocínio | N/D | Avaliação padrão sem sobrecarga de raciocínio |
| low | Permite o raciocínio com restrições | 4 mil tokens para raciocínio interno | Cenários que exigem raciocínio conciso; otimiza em termos de velocidade e custo |
| high | Permite o raciocínio sem restrições | Nenhum limite de token no raciocínio interno | Problemas complexos que exigem análise extensiva e raciocínio passo a passo |
**Quando habilitar o raciocínio**
**Use o modo de raciocínio (`low`, `medium` ou `high`) para**:
+ Tarefas complexas de resolução de problemas (cálculo, quebra-cabeças lógicos, codificação)
+ Perguntas analíticas de várias etapas que exigem raciocínio intermediário
+ Tarefas em que explicações detalhadas ou o raciocínio passo a passo melhoram a precisão
+ Cenários em que a qualidade da resposta é priorizada em relação à velocidade
**Use o modo sem raciocínio (omita o parâmetro) para**:
+ Perguntas e respostas simples ou consultas factuais
+ Tarefas de escrita criativa
+ Quando tempos de resposta mais rápidos são essenciais
+ Avaliação comparativa de performance em que a sobrecarga de raciocínio deve ser excluída
+ Otimização de custos quando o raciocínio não melhora a performance da tarefa
**Solução de problemas**
**Erro: “o modo de raciocínio está habilitado, mas o modelo não é compatível com ele"**
**Causa**: o parâmetro `reasoning_effort` está definido como um valor não nulo, mas o `model_type` especificado não é compatível com o raciocínio.
**Resolução**:
+ Verifique se o tipo de modelo é `amazon.nova-2-lite-v1:0:256k`
+ Se estiver usando um modelo diferente, mude para um modelo capaz de raciocinar ou remova o parâmetro `reasoning_effort` da sua fórmula