Extra Inteligência Artificial • Trilha Progressiva em 4 Níveis

🧭 Navegação Pedagógica

🎯 Nível 1: Fundamentos

Problema 19.1 — Cálculo da Métrica de Fidelidade (Faithfulness Score)

Contexto: Construir uma métrica algorítmica para avaliar se as afirmações contidas na resposta gerada pelo LLM estão estritamente contidas no contexto fornecido.

Requisitos de Execução:

  1. Criar a função calcular_fidelidade(afirmacoes_resposta, contexto_base).
  2. Verificar cada afirmação: se ela for dedutível a partir do contexto, é considerada verdadeira; caso contrário, conta como alucinação.
  3. Retornar a pontuação de 0.0 a 1.0.

Resultado Esperado

Avaliação da RAG Triad:
Afirmações verificadas: 3
Afirmações fundamentadas: 2
Fidelidade (Faithfulness Score): 0.67 (Alucinação detectada!)

📤 Instruções de Entrega (Microsoft Teams)

  1. Salve o arquivo como: Atividade_19_1_SeuNome
  2. Envie na tarefa: Atividade Cap 19 - Avaliação e LLMOps
🔑 Gabarito de Código & Solução Comentada 
# rag_faithfulness.py
def calcular_fidelidade(afirmacoes, contexto):
    fundamentadas = 0
    c_lower = contexto.lower()
    for af in afirmacoes:
        palavras = set(af.lower().split())
        # Checagem simplificada de contenção de termos chave
        intersecao = [w for w in palavras if w in c_lower]
        if len(intersecao) / max(len(palavras), 1) >= 0.7:
            fundamentadas += 1
            
    score = fundamentadas / len(afirmacoes) if afirmacoes else 0.0
    print("Avaliação da RAG Triad:")
    print(f"Afirmações verificadas: {len(afirmacoes)}")
    print(f"Afirmações fundamentadas: {fundamentadas}")
    msg = "Alucinação detectada!" if score < 1.0 else "Resposta 100% fiel ao contexto!"
    print(f"Fidelidade (Faithfulness Score): {score:.2f} ({msg})")
    return score

if __name__ == "__main__":
    ctx = "A empresa TechCorp foi fundada em 2018 em Florianópolis e desenvolve soluções em computação em nuvem."
    claims = [
        "A empresa TechCorp foi fundada em 2018",
        "A sede da empresa fica em Florianópolis",
        "A TechCorp abriu escritório em Tóquio em 2024" # Alucinação
    ]
    calcular_fidelidade(claims, ctx)

🎯 Nível 2: Prática

Problema 19.2 — Rastreador de Consumo de Tokens e Custo Financeiro

Crie uma classe TokenCostTracker que receba os tokens de entrada e saída de cada requisição e calcule o custo acumulado em dólares com base em tabelas de preços por 1k tokens.

🔑 Gabarito de Código & Solução Comentada 
# token_tracker.py
class TokenCostTracker:
    def __init__(self, preco_input_1k=0.0015, preco_output_1k=0.002):
        self.preco_in = preco_input_1k
        self.preco_out = preco_output_1k
        self.total_in = 0
        self.total_out = 0

    def registrar(self, tokens_in, tokens_out):
        self.total_in += tokens_in
        self.total_out += tokens_out

    def custo_total(self):
        cin = (self.total_in / 1000) * self.preco_in
        cout = (self.total_out / 1000) * self.preco_out
        return cin + cout

🎯 Nível 3: Integração

Problema 19.3 — Implementação do Padrão LLM-as-a-Judge com Prompt Estruturado

Construa uma função de julgamento que envie para um modelo avaliador a pergunta, o contexto e a resposta, solicitando que o juiz atribua notas de 1 a 5 com justificativa técnica.

🔑 Gabarito de Código & Solução Comentada 
# llm_as_judge.py
def montar_prompt_juiz(pergunta, contexto, resposta):
    prompt_juiz = f"""Você é um avaliador neutro e implacável de qualidade de sistemas RAG.
Analise a interação abaixo e atribua uma nota de 1 a 5 para 'Groundedness' (se a resposta se apoia no contexto sem alucinações).

[PERGUNTA]: {pergunta}
[CONTEXTO]: {contexto}
[RESPOSTA GERADA]: {resposta}

Responda em formato JSON:
{{
    "nota_fidelidade": 1 a 5,
    "justificativa": "Razão detalhada"
}}"""
    return prompt_juiz

🎯 Nível 4: Desafio

Problema 19.4 — Pipeline de Tracing Distribuído Estilo OpenTelemetry para LLMs

Implemente um decorador de observabilidade que meça o tempo de execução, tokens gastos, erros e gere um identificador de trace (Trace ID e Span ID) compatível com LangSmith/OpenTelemetry.

🔑 Gabarito de Código & Solução Comentada 
# llm_tracing.py
import time
import uuid
from functools import wraps

def trace_llm_span(nome_operacao):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            span_id = str(uuid.uuid4())[:8]
            t0 = time.time()
            try:
                res = func(*args, **kwargs)
                duracao_ms = (time.time() - t0) * 1000
                print(f"[TRACE {span_id}] {nome_operacao} concluído em {duracao_ms:.2f}ms | Status: SUCESSO")
                return res
            except Exception as e:
                duracao_ms = (time.time() - t0) * 1000
                print(f"[TRACE {span_id}] {nome_operacao} FALHOU em {duracao_ms:.2f}ms | Erro: {e}")
                raise
        return wrapper
    return decorator