Voltar ao blog
13 de maio de 20263 min de leitura

Entropia como Motor de Aprendizado: Quando a IA Sabe que Não Sabe

pythonaimath

Como uma IA sabe que não sabe algo? Parece filosófico, mas é um problema prático com solução matemática. Se o sistema tem uma crença com 50% de chance de ser A e 50% de ser B, ele está genuinamente incerto. Se tem 95% A e 5% B, está quase certo. A diferença entre esses dois estados é quantificável com uma única métrica: entropia de Shannon. E essa métrica pode ser usada como motor de aprendizado: alta entropia significa "preciso aprender mais sobre isso".

Uso entropia como combustível do sistema de curiosidade, como métrica de maturidade dos mundos, e como indicador de sucesso do aprendizado. Quando a entropia cai ao longo do tempo, o sistema aprendeu. Quando sobe, encontrou controvérsia. Quando fica estável e baixa, está confiante. É a métrica mais honesta que encontrei para medir conhecimento.

Guia de tópicos:

  • Entropia de Shannon: A Matemática da Incerteza
  • Entropia no Contexto de Crenças
  • Como Trigger de Curiosidade
  • Como Métrica de Maturidade
  • Medindo Aprendizado: Redução de Entropia
  • Exemplo Prático em Python
  • Considerações Finais

Entropia de Shannon: A Matemática da Incerteza

A fórmula é simples: H = -Σ p(x) × log2(p(x)). Para uma distribuição com duas hipóteses de 50% cada, H = 1.0 (máxima incerteza para 2 opções). Para uma hipótese com 99% e outra com 1%, H ≈ 0.08 (quase certeza). Para 100%, H = 0 (certeza absoluta, que na prática nunca permito).

A intuição: entropia mede quantos "bits" de informação você precisaria para eliminar a incerteza. Se são 2 opções igualmente prováveis, precisa de 1 bit (uma pergunta sim/não resolve). Se são 8 opções iguais, precisa de 3 bits. Se já sabe a resposta, precisa de 0 bits.

Entropia no Contexto de Crenças

Cada crença no grafo tem sua própria entropia. (Brasil, capital, ?) com distribuição {Brasília: 0.9, Rio: 0.1} tem entropia ≈ 0.47. Baixa, o sistema está confiante. (Plutão, classificação, ?) com {planeta_anão: 0.5, planeta: 0.4, outro: 0.1} tem entropia ≈ 1.36. Alta, genuinamente incerto.

A entropia de um mundo inteiro é a média das entropias de todas as suas crenças. Mundo com média 0.2 é maduro. Mundo com média 0.8 tem muitas incertezas.

Como Trigger de Curiosidade

O sistema de curiosidade usa entropia > 0.7 como threshold. A cada 60 segundos, varre crenças e seleciona as mais incertas para investigação via web. O threshold foi calibrado na prática: abaixo de 0.5 não vale o custo de pesquisar. Acima de 0.9 qualquer informação ajuda. 0.7 é o sweet spot de custo-benefício.

Como Métrica de Maturidade

Maturidade de um mundo = média das confianças dominantes de todas as crenças (correlacionado inversamente com entropia). Mundos maduros exigem similaridade maior para aceitar mensagens novas (threshold dinâmico), mudam menos o centroide (alpha adaptativo), e são priorizados como contexto para respostas.

Medindo Aprendizado: Redução de Entropia

Se o sistema começa com entropia média 0.8 em um mundo e após 10 interações está em 0.3, ele aprendeu. A redução de entropia é a métrica mais honesta de aprendizado: não mede "quantas triplas adicionou" (quantidade), mas "quão mais confiante ficou" (qualidade).

Em benchmarks, o cenário "redução de entropia" testa exatamente isso: fornece informações que deveriam resolver incertezas e verifica se a entropia realmente caiu. É a prova de que o sistema aprende de verdade, não só acumula dados.

Exemplo Prático em Python

import numpy as np

def entropy(distribution: dict[str, float]) -> float:
    """Shannon entropy: measures uncertainty in a distribution."""
    probs = np.array(list(distribution.values()))
    probs = probs[probs > 0]
    return float(-np.sum(probs * np.log2(probs + 1e-12)))


def bayesian_update(dist: dict, evidence: str, likelihood: float) -> dict:
    """Update distribution with new evidence."""
    likelihood = np.clip(likelihood, 0.01, 0.99)
    if evidence not in dist:
        dist[evidence] = max(1.0 - sum(dist.values()), 0.05)

    def p_ev(h):
        return likelihood if h == evidence else (1-likelihood)/max(len(dist)-1, 1)

    unnorm = {h: p_ev(h) * p for h, p in dist.items()}
    total = sum(unnorm.values())
    return {h: v/total for h, v in unnorm.items() if v/total >= 0.02}


def simulate_learning(initial_dist: dict, evidences: list[tuple[str, float]]):
    """Simulate learning process and track entropy reduction."""
    dist = initial_dist.copy()
    print(f"Initial: H={entropy(dist):.3f}")
    print(f"  {dist}\n")

    for i, (obj, lk) in enumerate(evidences):
        dist = bayesian_update(dist, obj, lk)
        h = entropy(dist)
        dominant = max(dist, key=dist.get)
        print(f"Step {i+1}: evidence='{obj}' (lk={lk}) → H={h:.3f}, dominant='{dominant}'")

        # Visual bar
        for hyp, prob in sorted(dist.items(), key=lambda x: -x[1]):
            bar = "█" * int(prob * 30)
            print(f"    {hyp:15s} {bar} {prob:.3f}")
        print()

    return dist


# Demo: entropy decreasing as evidence accumulates
print("=== Learning about Pluto's classification ===\n")
initial = {"planeta_anão": 0.35, "planeta": 0.40, "asteroide": 0.15, "outro": 0.10}

evidences = [
    ("planeta_anão", 0.7),   # IAU says dwarf planet
    ("planeta_anão", 0.8),   # Another source confirms
    ("planeta", 0.4),        # Old textbook says planet (weak)
    ("planeta_anão", 0.85),  # NASA confirms dwarf planet
]

final = simulate_learning(initial, evidences)
print(f"Final entropy: {entropy(final):.3f} (started at {entropy(initial):.3f})")
print(f"Reduction: {entropy(initial) - entropy(final):.3f} bits of uncertainty eliminated")

Considerações Finais

Entropia é a métrica que faltava em sistemas de IA conversacional. Em vez de medir "quantas mensagens processou" ou "quantos fatos armazenou", mede "quão confiante está no que sabe". É qualidade, não quantidade.

Usar entropia como motor de aprendizado cria um loop de feedback positivo: alta entropia → investiga → entropia cai → não investiga mais. O sistema naturalmente foca onde tem mais a ganhar e para quando está satisfeito. É eficiência emergente de uma regra simples.

Links indicativos:

Voltar ao blog