AI Prompt Engineering · Aula

Diagnosticando resultados inesperados

Classifique modos de falha: resposta errada, formato errado, fora do tópico ou alucinação.

Aula 1 de 413 etapas

Diagnosticando resultados inesperados é uma aula grátis de AI Prompt Engineering no CoddyKit. Esta é a aula 1 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.

Quando as Instruções Falham

Mesmo instruções cuidadosamente elaboradas produzem resultados incorretos. Diagnosticar falhas exige uma taxonomia — uma classificação do tipo de falha ocorrido. Sem classificação, a depuração vira tentativa e erro. As quatro principais categorias de falha são: resposta incorreta, formato incorreto, resposta fora do tema e alucinação.

Falha 1: Resposta Incorreta

Uma resposta incorreta é um erro factual — o modelo forneceu uma resposta no formato correto e sobre o tema correto, mas o conteúdo está incorreto.

Exemplos: datas, estatísticas, nomes, código que contém um erro de lógica. Esta é a falha mais difícil de detectar automaticamente porque a saída parece correta superficialmente.

Causa: limite temporal dos dados de treinamento, fato raro ou erro de raciocínio em várias etapas
Detecção: comparação com uma resposta correta de referência, revisão humana ou uma chamada de LLM para verificação

# Example: wrong answer failure
prompt = 'What year was Python first released?'
response = 'Python was first released in 1994.'  # Wrong — it was 1991

# Ground truth check
GROUND_TRUTH = '1991'
correct = GROUND_TRUTH in response
print(f'Correct: {correct}')  # False

Falha 2: Formato Incorreto

Uma falha de formato incorreto ocorre quando o modelo responde à pergunta certa com as informações corretas, mas ignora a instrução de formatação.

Exemplos: retornou texto simples quando JSON foi solicitado, adicionou markdown quando texto simples era exigido, retornou uma lista quando um único valor foi solicitado.

Causa: instrução de formatação escondida em uma instrução longa, instruções conflitantes, modelo ignorando instruções de baixa prioridade
Detecção: erro de análise de JSON, incompatibilidade com expressão regular, falha na validação do esquema

import json

response_text = 'Sure! Here is the result: {"name": "Alice", "age": 30}'

try:
    data = json.loads(response_text)
    print('Format OK:', data)
except json.JSONDecodeError as e:
    print(f'FORMAT FAILURE: {e}')
    # 'Sure! Here is the result:' prefix broke JSON parsing

Falha 3: Resposta Fora do Tema

Uma falha fora do tema significa que o modelo respondeu a uma pergunta diferente da que foi feita. A resposta pode estar correta do ponto de vista factual e bem formatada, mas não aborda a intenção real do usuário.

Exemplos: foi solicitada uma função em Python, mas recebeu uma função em JavaScript; foi solicitada uma resposta de uma linha, mas recebeu um ensaio completo; foi solicitado que corrigisse um erro, mas recebeu uma explicação do erro em vez da correção.

Causa: instrução ambígua, contexto conflitante, desvio da tarefa em conversas longas

# Off-topic example
prompt = 'Write a Python function that reverses a list.'
response = '''
In JavaScript, you can reverse an array like this:
const reversed = arr.reverse();
'''

# Detection: check that output contains the correct language keyword
def check_language(response, expected_lang='def '):
    if expected_lang not in response:
        print(f'OFF-TOPIC FAILURE: expected {expected_lang} in response')
        return False
    return True

check_language(response)  # False — no Python def

Falha 4: Alucinação

Alucinação é a falha mais perigosa: o modelo inventa fatos que não existem. Eles parecem plausíveis e são apresentados com confiança, o que dificulta sua identificação.

Exemplos: citações fabricadas (o título do artigo parece real, mas não existe), pontos de acesso de API inventados, estatísticas falsas, pessoas inexistentes.

Causa: o modelo preenche lacunas de conhecimento com texto plausível baseado em padrões
Detecção: verificação factual em fontes confiáveis, referências cruzadas das citações, execução de chamadas à API

# Hallucination detection via external verification
import requests

def verify_doi(doi):
    url = f'https://doi.org/{doi}'
    resp = requests.head(url, allow_redirects=True, timeout=5)
    return resp.status_code == 200

# Model claimed this paper exists:
fabricated_doi = '10.1234/fake.paper.2023.99999'
if not verify_doi(fabricated_doi):
    print('HALLUCINATION DETECTED: DOI does not exist')

A Taxonomia de Falhas na Prática

Quando uma falha for observada, classifique-a primeiro antes de tentar corrigi-la. O tipo de falha determina a estratégia de correção:

Resposta incorreta: adicione contexto, use recuperação ou mude para um modelo mais capaz
Formato incorreto: fortaleça a instrução de formato, adicione exemplos de saída, use saídas estruturadas / chamada de funções
Fora do tema: reescreva a instrução para torná-la mais específica, simplifique a instrução
Alucinação: adicione contexto de fundamentação, instrua o modelo a dizer 'Não sei', habilite citações

Registro Estruturado de Falhas

Registre toda falha com sua classificação. Com o tempo, surgem padrões: uma seção específica da instrução causa a maioria dos erros de formato incorreto, ou um tema específico provoca alucinações frequentes. Registros estruturados permitem uma depuração orientada por dados.

import json
from datetime import datetime

def log_failure(prompt, response, failure_type, details=''):
    entry = {
        'timestamp': datetime.utcnow().isoformat(),
        'failure_type': failure_type,  # wrong_answer | wrong_format | off_topic | hallucination
        'prompt_hash': hash(prompt),
        'response_snippet': response[:200],
        'details': details
    }
    with open('prompt_failures.jsonl', 'a') as f:
        f.write(json.dumps(entry) + '\n')

log_failure(
    prompt=my_prompt,
    response=bad_response,
    failure_type='wrong_format',
    details='JSON prefix text broke parsing'
)

Classificação Automatizada de Falhas

Para testes em larga escala, use uma chamada de LLM para classificação a fim de rotular automaticamente cada resposta com um tipo de falha. Isso permite a avaliação em lote de centenas de casos de teste.

def classify_failure(prompt, expected, actual):
    classification_prompt = (
        f'You are a QA evaluator for LLM outputs.\n'
        f'Prompt: {prompt}\n'
        f'Expected behavior: {expected}\n'
        f'Actual output: {actual}\n\n'
        'Classify the failure as one of: CORRECT, WRONG_ANSWER, WRONG_FORMAT, OFF_TOPIC, HALLUCINATION.\n'
        'Reply with only the label.'
    )
    resp = client.chat.completions.create(
        model='gpt-4o-mini',
        messages=[{'role': 'user', 'content': classification_prompt}]
    )
    return resp.choices[0].message.content.strip()

Matriz de Gravidade

Nem todas as falhas têm o mesmo impacto. Uma matriz de gravidade ajuda a priorizar correções:

Alucinação em contexto médico/jurídico: crítica — corrija imediatamente
Formato incorreto em ferramenta interna: alta — interrompe a análise subsequente
Resposta incorreta em caso extremo raro: média — monitore a frequência
Fora do tema em entrada ambígua: baixa — aceitável se for pouco frequente

Acompanhe as taxas de falha por tipo a cada semana. Um aumento repentino em qualquer categoria indica uma regressão que requer atenção.

Criando um Painel de Falhas

Um painel simples de falhas lê o registro de falhas e informa as contagens por tipo e por seção da instrução:

import json
from collections import Counter

def failure_report(log_path='prompt_failures.jsonl'):
    entries = []
    with open(log_path) as f:
        for line in f:
            entries.append(json.loads(line))

    counts = Counter(e['failure_type'] for e in entries)
    total = len(entries)

    print(f'Total failures: {total}')
    for ftype, count in counts.most_common():
        pct = 100 * count / total
        print(f'  {ftype}: {count} ({pct:.1f}%)')

failure_report()

Prevenção Proativa de Falhas

Estratégias proativas para reduzir cada tipo de falha antes que ocorram:

Resposta incorreta: forneça texto de referência na instrução (RAG); peça ao modelo que cite sua fonte
Formato incorreto: use o modo JSON ou chamada de funções; forneça um exemplo de formato na instrução
Fora do tema: coloque a tarefa na primeira frase; evite preâmbulos longos que diluam a intenção
Alucinação: instrua 'Use somente as informações fornecidas abaixo'; adicione 'Se não tiver certeza, diga que não sei'

Verificação de Conhecimento

Qual tipo de falha ocorre quando o modelo inventa fatos que não existem, como fabricar uma citação ou um ponto de acesso de API inexistente?

Responda na aula interativa

Recapitulação: Diagnóstico de Saídas Inesperadas

Os quatro tipos de falha de LLM e suas principais características:

Resposta incorreta: formato correto, tema correto, conteúdo incorreto — verifique os fatos em relação à resposta correta de referência
Formato incorreto: conteúdo correto, instrução de formato ignorada — a validação do esquema detecta isso
Fora do tema: formato correto, respondeu a uma pergunta diferente — verifique a correspondência entre idioma e tarefa
Alucinação: fatos inventados — verifique-os em fontes externas

Registre e classifique toda falha. Acompanhe as taxas por tipo ao longo do tempo. Próxima lição: análise de causa raiz para descobrir qual parte da instrução causou a falha.

Grátis para começar

Aprenda AI Prompt Engineering com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 53
Aulas: 199

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “Diagnosticando resultados inesperados” é grátis?

Sim — o texto completo de “Diagnosticando resultados inesperados” é 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 “Diagnosticando resultados inesperados”?

Classifique modos de falha: resposta errada, formato errado, fora do tópico ou alucinação. 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 1 de 4.

Quanto tempo leva a aula “Diagnosticando resultados inesperados”?

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

← Voltar para AI Prompt Engineering