Classificação, entropia cruzada e como não se enganar

A mesma fábrica do Capítulo 1, pergunta mais difícil. Em vez de aceitar ou rejeitar, a pergunta é esta peça está defeituosa — e defeitos são raros, o que torna a metade de medição deste capítulo difícil e a metade de modelagem enganosamente fácil.

import numpy as np

rng = np.random.default_rng(4)
N = 20_000
width  = rng.normal(22.0, 0.9, N)      # millimetres
weight = rng.normal(57.0, 3.0, N)      # grams

z_true = -5.90 + 1.90 * (width - 22.0) + 0.42 * (weight - 57.0)
y = (rng.random(N) < 1 / (1 + np.exp(-z_true))).astype(float)

perm = rng.permutation(N)
train, val, test = perm[:12_000], perm[12_000:16_000], perm[16_000:]

N = 20000  defects = 337  base rate = 0.0169
defects per split = 203 60 74

Três divisões, não duas. O motivo merece uma seção própria e ganha uma abaixo; por enquanto, treine na primeira, ajuste na segunda e não olhe para a terceira.

As features são padronizadas — subtrai-se a média, divide-se pelo desvio padrão — usando apenas as estatísticas de treino, pelo motivo que o Capítulo 1 demonstrou com o limite de convergência do perceptron: dados não centralizados tornam a geometria hostil. De quais linhas você tem permissão para calcular essa média vira uma questão viva mais adiante neste capítulo.

O perceptron retornava um sinal. Um sinal não consegue distinguir rejeitar de rejeitar, mas por pouco, e essa diferença é exatamente o que uma fábrica precisa para decidir quais peças um humano deve reinspecionar primeiro.

Então siga literalmente a receita do Capítulo 2. Escreva o que você afirma sobre como um rótulo é produzido, pegue a verossimilhança, pegue o log, negue, e você tem uma perda. Para um resultado de sim/não, a afirmação é uma distribuição Bernoulli: existe uma probabilidade $p$ de que a peça esteja defeituosa, e

que é só uma forma compacta de escrever "$p$ se $y = 1$, e $1-p$ se $y = 0$". Pegue o log disso e negue, e a perda para um exemplo é

Isso é entropia cruzada binária. Ela não foi escolhida porque é conveniente; é a log-verossimilhança negativa da única distribuição que um cara ou coroa pode ter. Não havia mais nada disponível.

O que ainda falta é de onde vem $p$. O modelo calcula uma soma ponderada $s = \mathbf{w}\cdot\mathbf{x} + b$, que é um número real e percorre a reta inteira, e uma probabilidade precisa viver em $(0,1)$. A função que faz a passagem entre os dois é a sigmoide logística:

logit -4.0  ->  p = 0.0180        loss when y=1 and p=0.9  : 0.1054
logit -1.0  ->  p = 0.2689        loss when y=1 and p=0.5  : 0.6931
logit  0.0  ->  p = 0.5000        loss when y=1 and p=0.01 : 4.6052
logit  4.0  ->  p = 0.9820

Leia a coluna da direita como uma lista de preços. Estar certo com 90% de confiança custa 0,105. Recusar-se a se comprometer custa 0,693 — que é $\log 2$, o preço de dar de ombros. Estar confiantemente errado custa 4,6, quarenta e quatro vezes mais, e o preço cresce sem limite conforme o modelo fica mais certo sobre um erro. A entropia cruzada não apenas conta erros: ela cobra pela arrogância.

O Capítulo 3 disse: para treinar qualquer coisa, obtenha a derivada da perda em relação a cada parâmetro. Faça isso para um exemplo. Com $s = \mathbf{w}\cdot\mathbf{x} + b$ e $p = \sigma(s)$:

Então a atualização é previsão menos verdade, vezes a entrada. Nada mais. Aqui está o treinador inteiro, que é o gradient descent do Capítulo 3 com uma linha alterada:

def sigmoid(z):
    return np.where(z >= 0, 1.0 / (1.0 + np.exp(-z)),
                    np.exp(np.minimum(z, 0)) / (1.0 + np.exp(np.minimum(z, 0))))


def fit_logistic(X, y, lr=0.5, epochs=4000):
    w, b = np.zeros(X.shape[1]), 0.0
    for _ in range(epochs):
        p = sigmoid(X @ w + b)
        g = p - y                        
        w -= lr * (X.T @ g) / len(y)     
        b -= lr * g.sum() / len(y)       
    return w, b

O np.where em sigmoid não é cosmético. Calcular $1/(1+e^{-s})$ diretamente estoura para $s$ negativos grandes; o desvio escolhe a forma algebricamente idêntica que mantém o expoente negativo. Esta é a caixa de ponto flutuante do Capítulo 2 cobrando sua primeira dívida, e ela cobrará uma maior daqui a duas seções.

A explicação padrão para preferir entropia cruzada a erro quadrático é o argumento da verossimilhança acima: erro quadrático é o que você obtém ao assumir ruído gaussiano, rótulos não são gaussianos, portanto não faça isso. Está correto e não convence ninguém, porque você pode escrever $L = (p - y)^2$ sobre uma sigmoide e isso vai treinar.

O argumento que funciona é sobre o gradient. Coloque erro quadrático em cima de uma sigmoide e a regra da cadeia dá

Esse $p(1-p)$ extra é o que cancelou antes. Agora não cancela, e vai a zero sempre que o modelo está confiante — inclusive quando o modelo está confiantemente errado. Avalie os dois em algumas pontuações, para um exemplo cujo rótulo verdadeiro é 1:

Em $s = -8$ o modelo está tão errado quanto é possível estar, e o erro quadrático responde com um gradient 1.491 vezes menor que o da entropia cruzada. Quanto pior o erro, menos o modelo aprende com ele. O gradient da entropia cruzada, enquanto isso, satura em $-1$: maximamente errado produz um sinal maximamente grande, e não maior.

Rode a corrida. Dois mil pontos balanceados, pesos iniciais idênticos escolhidos para estarem confiantemente errados ($\mathbf{w} = [-6, -6]$), taxa de aprendizado idêntica, só a perda muda. As duas execuções são pontuadas com entropia cruzada para que as colunas sejam comparáveis.

A entropia cruzada terminou no epoch 50. O erro quadrático ainda está em 24% de acurácia no epoch 100 — e não tinha saído de 23% no epoch 10 — pior que chutar, porque começou confiantemente errado e o gradient que o resgataria foi multiplicado por 0,0007. Ele escapa por volta do epoch 500 e chega ao mesmo lugar. Então o resumo honesto é que erro quadrático sobre uma sigmoide não é incorreto; ele é lento exatamente onde velocidade mais importa. Em um modelo de dois parâmetros, você perde 450 epochs. Em uma rede com cem camadas, onde alguma unidade em algum lugar está sempre confiantemente errada, você perde a execução de treino.

Três quantidades, necessárias de verdade no Capítulo 8 para perplexidade e no Capítulo 11 para a penalidade que mantém uma política fine-tuned perto de sua referência. Elas são mais fáceis do que a fama sugere.²

Entropia é o número médio de bits que você precisa gastar para comunicar uma amostra de uma distribuição, se usar o melhor código possível para ela:

Entropia cruzada é o que você gasta quando usa um código construído para $q$ em dados que na verdade vêm de $p$:

Divergência KL é o excesso — o desperdício, em bits, causado por acreditar em $q$ quando a verdade é $p$:

Confira as três na esteira:

test defect rate                                = 0.0185
entropy of that coin                            = 0.1329 bits
cross-entropy of the constant predictor on test = 0.1330 bits
KL(test coin || fair coin)                      = 0.8671 bits
H + KL                                          = 1.0000 bits
cross-entropy of the p=0.5 predictor on test    = 1.0000 bits

Duas coisas ficam visíveis ali. Primeiro, um modelo que simplesmente reporta a taxa base de treino, 1,69%, alcança uma entropia cruzada de 0,1330 bits, quase exatamente a entropia dos rótulos de teste — como deve ser, já que ele tem a distribuição certa e nenhuma outra informação. Entropia é o piso que a ignorância sobre o indivíduo compra para você. Segundo, um modelo que dá de ombros e diz 0,5 paga exatamente 1 bit, e a lacuna entre os dois, 0,8671 bits, é precisamente a divergência KL. $H + D_{\mathrm{KL}} = H(p,q)$ não é uma identidade para decorar; é uma conta que você pode ver sendo somada.

E a conexão de volta ao treino: quando o rótulo é uma única classe conhecida, a distribuição “verdadeira” é one-hot, sua entropia é zero, e a entropia cruzada é igual à divergência KL. Minimizar a entropia cruzada e puxar a distribuição do modelo em direção à verdade são o mesmo ato.

Defeituoso não é uma coisa só. Na moldagem, uma peça pode sair com injeção incompleta (material insuficiente), rebarba (material demais, espremido para fora do molde) ou queima. Quatro resultados, portanto quatro logits, e eles precisam virar quatro probabilidades que somam um. Isso é softmax:

Ele tem uma propriedade que parece acidente e na verdade é toda a implementação:

para qualquer constante $c$, porque $e^{z_i + c} = e^{c} e^{z_i}$ e o $e^c$ se cancelam em cima e embaixo. Só diferenças entre logits significam alguma coisa. O nível absoluto não é informação.

Ainda bem, porque o nível absoluto é o que quebra o computador:

logits            = [800. 801. 799.]
naive softmax     = [nan nan nan]
shifted by -max   = [0.2447 0.6652 0.09  ]
same softmax after adding 1000 to every logit: True

$e^{800}$ estoura um float de 64 bits, a soma vira infinito, e infinito dividido por infinito é nan — não um erro, não uma falha, apenas um buraco silencioso onde três probabilidades costumavam estar. Subtrair o maior logit não muda nada matematicamente e muda tudo numericamente, porque o maior expoente se torna exatamente $e^0 = 1$. Este é o truque logsumexp do Capítulo 2 vestindo roupa de trabalho, e toda implementação séria faz isso:

def softmax(Z):
    Z = Z - Z.max(axis=1, keepdims=True)   
    E = np.exp(Z)
    return E / E.sum(axis=1, keepdims=True)


def fit_softmax(X, Y, lr=1.0, epochs=6000):
    W, b = np.zeros((X.shape[1], Y.shape[1])), np.zeros(Y.shape[1])
    for _ in range(epochs):
        G = (softmax(X @ W + b) - Y) / len(X)   
        W -= lr * (X.T @ G)
        b -= lr * G.sum(0)
    return W, b

O gradient é novamente previsão menos verdade, agora com $Y$ one-hot. O caso binário foi um caso especial o tempo todo.

Treinado em 3.000 peças e testado em 1.000, com três medições cada (largura, peso, temperatura de fusão), ele chega a 94,00% de acurácia. Aqui está o que esse número esconde:

O modelo encontra menos da metade das peças com injeção incompleta. A acurácia não consegue ver isso, porque 86% das peças estão boas e acertar essas já basta para carregar a média. Macro F1 — a média dos F1 por classe, que dá a uma classe rara o mesmo peso de uma classe comum — é 0,7983, contra um micro F1 de 0,9400 que por definição é idêntico à acurácia. Sempre que alguém reportar um único número de F1, pergunte qual.

Esse é o fim da modelagem. O resto do capítulo é sobre os números.

Pegue o modelo binário treinado e crie duas variantes multiplicando todo logit por uma constante: 0,35 para uma versão hesitante, 4 para uma superconfiante. Multiplicar por um número positivo não pode mudar nenhum sinal, então os três modelos preveem exatamente o mesmo rótulo para todas as 4.000 peças de teste. A acurácia não consegue diferenciá-los. A entropia cruzada não tem dificuldade nenhuma:

O modelo hesitante paga uma pequena taxa em cada peça, inclusive nas milhares que acerta. O superconfiante é quase gratuito quando acerta e catastrófico quando erra — uma peça nesse conjunto de teste custa sozinha 27,63 nats. Os dois chegam quase ao mesmo total por caminhos opostos, e o modelo treinado, cujas probabilidades são calibradas aos dados, fica três vezes abaixo de ambos.

Esta é a forma mais afiada de declarar a diferença entre uma perda e uma métrica. A perda é o que você otimiza: precisa ser diferenciável, e vê tudo que o modelo disse, inclusive o quanto ele tinha certeza. A métrica é aquilo pelo qual você é julgado: pode ser uma função degrau, uma regra de negócio, uma contagem de defeitos perdidos. Elas não são o mesmo objeto e nem sempre concordam — por isso você define ambas antes de começar, e nunca deixa a perda substituir a métrica só porque ela apareceu na tela.

Antes de qualquer modelo, a exigência: quanto pontua a resposta mais preguiçosa possível? Nesta esteira, sempre diga que está boa:

always-say-fine baseline: accuracy = 0.9815
confusion (tn, fp, fn, tp) = (3926, 0, 74, 0)

98,15%. Agora o modelo logístico treinado, no limiar padrão de 0,5:

logistic @0.5: accuracy=0.9830 precision=0.8000 recall=0.1081 F1=0.1905
confusion (tn, fp, fn, tp) = (3924, 2, 66, 8)

98,30%. Ele bateu o baseline por 0,15 ponto percentual, e qualquer relatório que pare na acurácia chamará isso de vitória. A matriz de confusão diz o que realmente aconteceu:

Ele encontrou 8 peças defeituosas de 74 e deixou 66 passarem. Três números nomeiam as três formas de ler essa tabela:

• Precision $= \mathrm{TP}/(\mathrm{TP}+\mathrm{FP}) = 8/10 = 0.800$. Das peças que ele sinalizou, quantas eram realmente defeituosas. Este é o custo de inspeções desperdiçadas.
• Recall $= \mathrm{TP}/(\mathrm{TP}+\mathrm{FN}) = 8/74 = 0.108$. Das peças defeituosas, quantas ele pegou. Este é o custo de enviar uma peça ruim a um cliente.
• F1 $= 2PR/(P+R) = 0.190$, a média harmônica das duas, que fica perto da menor e portanto se recusa a ser bajulada por uma delas sozinha.

O que importa depende da fábrica, não da matemática: uma inspeção custa alguns segundos e um defeito enviado custa um aviso de recall, então aqui recall domina e 0,108 é uma falha.

Mas o modelo não é o problema. O limiar é, e o limiar não faz parte do modelo — é uma decisão de negócio aplicada depois a uma probabilidade. Faça a varredura:

Leia a coluna de acurácia de cima para baixo. Ela cai o tempo todo — de 98,30% para 65,93% — enquanto o modelo passa de pegar 8 defeitos para pegar 71 de 74. Tudo de útil que este modelo consegue fazer piora sua acurácia. Uma equipe otimizando o número do título enviaria a versão que não encontra nada.

Por que três divisões e não duas? Porque no momento em que você usa um conjunto de exemplos para escolher qualquer coisa — um limiar, uma taxa de aprendizado, qual de seis modelos colocar em produção — esse conjunto foi usado para ajuste, e sua pontuação deixa de ser não enviesada.³ Medido nesta esteira: varrer o limiar no conjunto de validação escolhe 0,196, e o modelo então pontua F1 = 0,4122 no conjunto de teste intocado. Se a varredura tivesse sido feita diretamente no conjunto de teste, o melhor alcançável ali seria 0,4186 — um número que ninguém tem direito de reportar.

A lacuna é pequena aqui, 0,006, porque é um hiperparâmetro varrido uma vez contra 4.000 exemplos de validação. Ela cresce a cada decisão extra e a cada encolhimento do conjunto de validação. Note também que a direção não é garantida em uma única execução: o limiar escolhido pontuou 0,3902 na validação e 0,4122 no teste, então a validação subestimou desta vez. O viés é sistemático ao longo de muitas decisões, não visível em uma só.⁴

Agora o exercício. O log da esteira chega com uma terceira coluna, station_seconds: quanto tempo cada peça passou na estação de inspeção. Adicioná-la é uma mudança de uma linha no pré-processamento. Eis o que ela faz:

Recall vai de 10,8% para 77,0%. F1 mais que quadruplica. E repare no que a acurácia fez: 98,30% → 99,20%, um ganho de nove décimos de ponto, que é o tipo de número arredondado para “cerca de 99% de qualquer jeito” em um slide de resumo. Acurácia não conseguiu ver a falha antes e agora não consegue ver a fraude.

Antes de continuar: o modelo está trapaceando. Descubra como.

station = 1.8 + rng.exponential(0.35, N)                     # a part just passing through
audited = rng.random(N) < 0.006                              # random spot checks
station[audited] += rng.uniform(6.0, 26.0, audited.sum())
station[y == 1] = 9.0 + rng.exponential(7.0, (y == 1).sum())  

A linha destacada é o vazamento: o tempo de permanência de uma peça defeituosa é sorteado de uma distribuição diferente, porque um humano a tirou da esteira. Este é o bug sério mais comum em machine learning aplicado, e tem nome: vazamento do alvo — informação nas features de treino que não estaria disponível no momento em que a previsão precisa ser feita.⁵ Ele não lança exceção. Produz um número melhor. Todo incentivo em um projeto aponta para mantê-lo.

A defesa é uma pergunta, feita a cada coluna: no instante em que preciso desta previsão, este valor já existe? Em uma esteira ao vivo, station_seconds é desconhecido até depois que a peça foi inspecionada — que é justamente o que o modelo deveria substituir.

Suponha que você pontue um modelo em 20 exemplos e ele acerte 17. Você reporta 85%.

17 correct out of 20 -> accuracy 0.8500
  Wilson    95% CI : [0.6396, 0.9476]
  bootstrap 95% CI : [0.7000, 1.0000]
  P(a 65% model scores 17 or more out of 20) = 0.0444
  P(an 85% model scores 17 or more out of 20) = 0.6477

A leitura honesta de 17/20 é algo entre 64% e 95%. Um modelo genuinamente de 65% produz esse resultado 4,4% das vezes — uma execução em vinte e três — e, se você tentou um punhado de prompts e reportou o melhor, você mesmo fabricou essa execução. Dezessete de vinte não conseguem distinguir um modelo de 85% de um de 65%.

Duas formas de colocar um intervalo em uma taxa, e ambas pertencem ao seu kit de ferramentas:

def wilson(k, n, z=1.959963985):
    """95% interval for k successes in n trials. Correct at small n; no simulation."""
    ph, d = k / n, 1 + z * z / n
    centre = (ph + z * z / (2 * n)) / d
    half = z * (ph * (1 - ph) / n + z * z / (4 * n * n)) ** 0.5 / d
    return centre - half, centre + half


def bootstrap_ci(correct, n_resamples=10_000, alpha=0.05, seed=0):
    """95% interval for the mean of any per-example score array. Works on F1 too."""
    rng = np.random.default_rng(seed)
    correct = np.asarray(correct, dtype=float)
    draws = correct[rng.integers(0, len(correct), size=(n_resamples, len(correct)))]
    lo, hi = np.quantile(draws.mean(axis=1), [alpha / 2, 1 - alpha / 2])
    return float(correct.mean()), float(lo), float(hi)

Use Wilson⁶ para uma taxa de sucesso simples; ele se comporta bem em qualquer $n$ e não precisa de aleatoriedade. Note acima que em $n = 20$ a extremidade superior do bootstrap é 1,0000 — reamostrar 20 pontos pode facilmente sortear 20 corretos, então ele não consegue representar um intervalo mais estreito que sua própria granularidade. Use o bootstrap⁷ quando não existe fórmula, que é a maior parte dos casos interessantes: F1, médias macro, BLEU, pass@1, a pontuação de um juiz baseado em rubrica. Nesta esteira, o F1 de 0,4122 do modelo ajustado carrega um intervalo bootstrap de [0,3009, 0,5156] — que é o número que deveria aparecer no relatório, porque a estimativa pontual sozinha convida uma comparação que ela não pode sustentar.

Mais uma medição, porque ela muda como você deve comparar dois modelos. Dois modelos pontuados nos mesmos 500 exemplos:

model A: 0.8580  95% CI [0.8260, 0.8880]
model B: 0.8120  95% CI [0.7780, 0.8460]
the two intervals overlap: True
paired difference A-B: 0.0460  95% CI [0.0260, 0.0680]
they disagree on 31 of 500 examples (A right 27, B right 4)

Seus intervalos se sobrepõem, e a regra popular — barras de erro sobrepostas significam ausência de diferença significativa — chamaria a comparação de inconclusiva. Não é. Os dois modelos rodaram nos mesmos exemplos, então a quantidade certa é a diferença por exemplo, cujo intervalo é [0.0260, 0.0680], confortavelmente acima de zero. Eles discordam em apenas 31 dos 500 itens, e A vence 27 dessas discordâncias; os exemplos compartilhados, fáceis e difíceis, se cancelam em vez de adicionar ruído. Compare modelos de forma pareada, e você chega à mesma conclusão com uma fração dos dados.

Agora você tem um modelo que gera probabilidades calibradas, uma perda derivada de uma afirmação sobre os dados em vez de escolhida por conveniência, um gradient que é literalmente previsão menos verdade, e — mais importante — a maquinaria para descobrir se qualquer uma dessas coisas funciona. O intervalo de Wilson de dez linhas acima é reutilizado literalmente: ele carrega as variantes de prompt no Capítulo 15, as tabelas de recuperação no Capítulo 19 e o conjunto dourado no Capítulo 29. O bootstrap é o que você procura quando não existe fórmula.

Mas o modelo ainda tem uma camada. Ele desenha uma linha, e o Capítulo 1 provou com quatro linhas de XOR que uma linha não basta. A correção é empilhar: uma primeira camada que dobra o espaço, uma segunda que desenha a linha no espaço dobrado.

É aí que o gradient arrumado deste capítulo acaba. Tudo acima funcionou porque $\partial L/\partial s = p - y$ podia ser escrito à mão, uma vez, para um modelo com uma camada entre a entrada e a perda. Coloque uma segunda camada no meio e a pergunta muda de forma: qual é a derivada da perda em relação a um peso que não toca a saída de forma alguma — um peso cuja influência chega apenas por meio de outra camada, possivelmente por vários caminhos ao mesmo tempo?

Essa derivada existe. Calculá-la à mão é inviável para qualquer coisa maior que um brinquedo, e calculá-la um parâmetro por vez é inviável em outra escala. O que é necessário é um procedimento que obtenha cada derivada na rede a partir de uma única passada para trás sobre o mesmo grafo que a passada para frente acabou de percorrer.

Esse é o Capítulo 5, e ele é o motor em que o resto deste curso roda.

Também vale ler junto com este capítulo: Bishop, Pattern Recognition and Machine Learning §1.2, §1.5, §1.6 e §4.3, que cobre probabilidade, teoria da decisão, teoria da informação e classificação linear na ordem que este capítulo segue; Murphy, Probabilistic Machine Learning: An Introduction, capítulos 6 e 10; Prince, Understanding Deep Learning §5.4–5.7; e Saito e Rehmsmeier, The Precision-Recall Plot Is More Informative than the ROC Plot When Evaluating Binary Classifiers on Imbalanced Datasets (PLOS ONE, 2015) — por que a AUC citada acima não deve ser o único número independente de limiar que você olha quando 1,7% das peças são defeituosas.