0Pricing
AI Prompt Engineering · Aula

Validação por autocrítica

Saídas verificadas pelo modelo.

Validação por autocrítica é uma aula grátis de AI Prompt Engineering no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de AI Prompt Engineering, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de AI Prompt Engineering inclui 4 aulas no total.

O modelo como seu próprio crítico

A autocrítica usa um LLM para avaliar a saída de um LLM segundo uma rubrica ou política. Ela detecta falhas sutis que validadores determinísticos não conseguem codificar: inconsistência factual, tom, utilidade e violações sutis de políticas.

Ela é o complemento baseado em modelo para os validadores de esquema e de regras.

Separe o crítico do autor

Execute a crítica como uma chamada distinta, com sua própria instrução, e não como uma instrução final na geração. Um crítico com contexto limpo, solicitado apenas a julgar, é muito mais confiável do que pedir ao autor que avalie a si mesmo durante a geração, quando tende a favorecer a própria resposta.

draft = author_model(task_prompt)
verdict = critic_model(
  'You are a strict reviewer. Judge ONLY the answer below against the rubric.\n'
  'Rubric: ' + rubric + '\nAnswer: ' + draft
)

Saída estruturada da crítica

Faça o crítico emitir vereditos estruturados para que o fluxo possa agir programaticamente. Uma crítica em texto livre não pode ser acionada por máquina.

CRITIC_SCHEMA = {
  'type': 'object',
  'properties': {
    'pass': {'type': 'boolean'},
    'violations': {'type': 'array', 'items': {'type': 'string'}},
    'severity': {'type': 'string', 'enum': ['none','minor','major','critical']},
    'fix_hint': {'type': 'string'}
  },
  'required': ['pass','violations','severity','fix_hint'],
  'additionalProperties': False
}

Ciclo de criticar e depois revisar

Combine o crítico com um revisor. O crítico encontra os problemas; o autor revisa usando a crítica; repita até a aprovação ou até esgotar o orçamento. Esse é o equivalente baseado em modelo do ciclo de reparo.

draft = author_model(task)
for _ in range(2):
    c = critic_model(draft)
    if c['pass']:
        break
    draft = author_model(task + '\nRevise to fix: ' + c['fix_hint'])
final = draft

Rubricas tornam a crítica confiável

Uma instrução vaga ('isto está bom?') produz vereditos inconsistentes. Uma rubrica concreta, com critérios explícitos e verificáveis, produz vereditos consistentes. Decomponha-a em perguntas de sim ou não que o crítico responda individualmente.

RUBRIC = [
  'Does the answer directly address the user question?',
  'Are all factual claims supported by the provided context?',
  'Is any disallowed content present?',
  'Is the response within the requested length?'
]

Crítica fundamentada para verificar fatos

Para detectar alucinações, forneça ao crítico o contexto da fonte e peça que sinalize qualquer afirmação que não seja sustentada por ele. Isso transforma a autocrítica em uma verificação de implicação, muito mais forte do que perguntar “isso é verdade?” sem evidências.

verdict = critic_model(
  'For each claim in the ANSWER, state whether the CONTEXT entails it. '
  'Flag any unsupported claim.\nCONTEXT:\n' + ctx + '\nANSWER:\n' + draft
)

Modos de falha do crítico

O crítico é um LLM e também pode falhar:

  • Bajulação — aprovar automaticamente a resposta do autor.
  • Excesso de crítica — sinalizar uma saída correta.
  • Pontos cegos compartilhados — o mesmo modelo deixa passar os mesmos erros.

Reduza esses problemas usando uma família de modelos diferente como crítico, um perfil de revisor rigoroso e limites calibrados.

Use um crítico mais barato ou diferente

O crítico não precisa ser o modelo mais caro. Muitas vezes, um modelo menor com uma rubrica precisa é uma barreira de proteção econômica, e usar uma família de modelos diferente reduz pontos cegos correlacionados. Reserve o modelo mais forte para a elaboração do conteúdo.

Quando confiar e quando verificar

A autocrítica reduz erros, mas não é uma prova. Para conteúdo de baixo risco, uma única rodada de crítica é suficiente. Para saídas de alto risco, combine a autocrítica com validadores determinísticos e revisão humana; nunca permita que um modelo seja o único árbitro de decisões críticas para a segurança.

Custo, latência e armazenamento em cache

A autocrítica aproximadamente dobra o número de chamadas por solicitação. Controle-a: faça a crítica somente depois das verificações determinísticas, criticando apenas o que passou pelo esquema e pelas regras; armazene em cache as críticas de rascunhos idênticos e limite o número de rodadas de revisão. Execute a crítica em paralelo com trabalhos não bloqueantes quando possível.

if deterministic_ok(draft):
    verdict = critic_model(draft)   # only spend critique on viable drafts

Calibre com base em rótulos humanos

Valide o crítico antes de confiar nele. Crie um conjunto de saídas rotuladas por humanos, execute o crítico e meça a concordância, calculando precisão e revocação em relação aos vereditos humanos. Ajuste a rubrica e o perfil até que os julgamentos do crítico se correlacionem com os dos humanos; verifique novamente após atualizações do modelo.

agreement = mean(critic(d)['pass'] == human_label[d] for d in eval_set)
assert agreement > 0.9

Verificação rápida

Você quer que o crítico detecte alucinações com confiabilidade em uma resposta de RAG. O que mais aumenta essa confiabilidade?

Recapitulação

Validação por autocrítica:

  • Um crítico separado, com contexto limpo, avalia a saída do autor.
  • Emita vereditos estruturados; conduza um ciclo de criticar e depois revisar.
  • Rubricas concretas e verificações de implicação fundamentadas aumentam a confiabilidade.
  • Cuidado com a bajulação e os pontos cegos compartilhados; use um modelo de crítico diferente.
  • Controle pelo custo, combine com verificações determinísticas e calibre com base em avaliações humanas.

Você concluiu as barreiras de proteção. Próximo curso: testes de equipe vermelha e avaliação adversarial.

Perguntas Frequentes

A aula “Validação por autocrítica” é grátis?

Sim — o texto completo de “Validação por autocrítica” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de AI Prompt Engineering, atualize para CoddyKit PRO. O curso de AI Prompt Engineering inclui 4 aulas no total.

O que vou aprender em “Validação por autocrítica”?

Saídas verificadas pelo modelo. Você pratica AI Prompt Engineering com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar AI Prompt Engineering?

Nenhuma experiência prévia é necessária. AI Prompt Engineering no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Validação por autocrítica”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de AI Prompt Engineering?

Sim. Cada aula de AI Prompt Engineering inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. O que são barreiras de proteção
  2. Filtragem de entrada e saída
  3. Validadores de esquemas e regras
  4. Validação por autocrítica
← Voltar para AI Prompt Engineering