Duas afirmações de LeCun que viraram experimento: "combine a percepção com o conteúdo de uma memória" e "cada nível de abstração prevê mais longe que o de baixo". As duas foram medidas, e as duas valem para texto — com a escala honesta de um modelo de 7,4 M.
LeCun lista, nas duas falas, a memória persistente como requisito de um sistema inteligente, e a palestra diz onde ela entra: a percepção dá só o estado atual; o estado completo é a percepção combinada com o conteúdo de uma memória. Um modelo de linguagem comum não tem isso — tem a janela de contexto, e o que sai dela deixa de existir.
Um vetor abstrair()) e dobrado na memória:
O modelo de mundo passa a receber
Toda avaliação mede o modelo de mundo três vezes no mesmo lote: com a memória certa, com a memória de outra sequência do lote e sem memória. O ganho de memória é
ganho_memoria = MSE(memória errada) − MSE(memória certa)
Zero quer dizer que
Três janelas contíguas A, B, C. O modelo de mundo prevê dentro de C, que vê inteira. A memória vem de fontes diferentes (model/memory.py):
| Fonte da memória | MSE | ganho vs outra | O que testa |
|---|---|---|---|
| zero | 0,220 | −0,028 | sem passado: o pior de todos |
| outra (A+B de outro texto) | 0,193 | 0 | o controle |
| recente (só B) | 0,173 | +0,019 | o passado imediato |
| longa (A+B) | 0,181 | +0,012 | o passado inteiro: menos que cada metade sozinha |
| só antiga (só A) | 0,174 | +0,019 | persistência: atravessou uma janela inteira e vale tanto quanto a recente |
| piso: copiar | 1,130 | — |
A rodada wm1n2mem-sz1 fechou em 5,6801 (+7,77%, na faixa das outras ponta a ponta), ganho de mapa +0,93, e ganho_memoria +0,014 na validação do treino. No experimento de três janelas, a ordem é a que a hipótese pedia: a memória certa prevê melhor que a de outro texto (0,173 contra 0,193, cerca de 10% do erro do mapa), e a de outro texto prevê melhor que nenhuma (0,220) — o vetor ajuda como viés, e ajuda mais quando é o passado certo. O número que importa é a última linha: a memória só de A, separada de C por uma janela inteira de 256 tokens, vale o mesmo que a de B (+0,019 contra +0,019). O que saiu da janela não deixou de existir. É persistência, não recência.
Uma surpresa: "longa" (A+B) rende menos que cada metade sozinha (+0,012). Dobrar dois blocos de 256 tokens no mesmo vetor de 256 dimensões dilui; a memória como está é um resumo com capacidade fixa, e o excesso custa. É o argumento para a memória consultada em vez de somada (pergunta em aberto abaixo).
"Longa" ≈ "outra" ≈ "zero": a memória não carrega nada, o modelo de mundo aprendeu a ignorá-la. Isso é um resultado possível e não é um bug: com 256 tokens de janela, pode não sobrar informação útil fora dela num texto de validação. Se "recente" ganha e "só antiga" não, a memória é de curto prazo — recência, não persistência.
Nenhuma das duas invalidações aconteceu: "longa" fica entre "recente" e "outra", e "só antiga" empata com "recente". Escala honesta: o ganho é da ordem de 10% do erro do mapa, com 32 sequências e uma semente.
Na geração, a memória funciona da mesma forma: o prompt que não cabe na janela é dobrado antes de gerar, e cada bloco que sai da janela durante a geração é dobrado também. Foi testado com um prompt de 81 tokens numa janela de 64; o número de fumaça (modelo de mundo de dois passos) deu todas as fontes empatadas em 1,46, como deve ser num mapa que ainda não aprendeu nada.
A palestra justifica a hierarquia com uma frase: "cada nível de abstração permite previsões de mais longo alcance que o nível de baixo, ignorando detalhes". É a razão de ser do nível 2, e nunca tinha sido medida aqui. O experimento (model/horizon.py):
abstrair(), contra o mesmo | Horizonte (tokens) | MSE nível 1 | piso | ganho | cos nível 1 | cos piso |
|---|---|---|---|---|---|
| 1 | 0,167 | 1,118 | +0,951 | 0,911 | 0,421 |
| 2 | 0,197 | 1,206 | +1,009 | 0,895 | 0,375 |
| 4 | 0,211 | 1,205 | +0,995 | 0,888 | 0,376 |
| 8 | 0,222 | 1,211 | +0,989 | 0,885 | 0,373 |
| Previsor | MSE | ganho | cos |
|---|---|---|---|
| piso (copiar | 0,171 | 0 | 0,810 |
| nível 1 rolado × 8, abstraído | 0,152 | +0,020 | 0,822 |
| nível 2, um passo | 0,094 | +0,078 | 0,891 |
O nível 1 rolado degrada devagar: de cosseno 0,911 em um passo para 0,885 em oito, enquanto a identidade fica em 0,37–0,42. Oito tokens à frente, sem nunca corrigir o estado imaginado, o mapa ainda está a 0,885 do real. No wm1n2mem-sz1, na régua abstrata, a mesma ordem: piso 0,174 (cos 0,81), nível 1 rolado × 8 0,288 (cos 0,65, pior que o piso), nível 2 num passo 0,102 (cos 0,89). E no wm0.1n2-sz1-lat1o: piso 0,400, nível 1 rolado 0,319, nível 2 0,220 (cos 0,74). E no ζ com o canal fechado (wm1n2z16zd0.5-sz1, ζ = 0): piso 0,195, nível 1 rolado 0,162, nível 2 0,106 (cos 0,87). No modelo de mundo sobre o encoder DINO congelado (wm-sobre-dino, encoder de nível 2 aprendido sem norma): piso 0,066, nível 1 rolado 0,045, nível 2 0,038 (cos 0,44) — o encoder aprendido encolheu de novo (a média crua daria ~0,16), menos que no ponta a ponta, e o nível 2 continua na frente. Em cinco de cinco modelos hierárquicos, o nível 2 prevê o bloco seguinte melhor que o nível 1 rolado.
| Previsor | MSE | ganho | cos |
|---|---|---|---|
| piso (copiar | 0,013 | 0 | 0,274 |
| nível 1 rolado × 8, abstraído | 0,0095 | +0,0035 | 0,194 |
| nível 2, um passo | 0,0068 | +0,0062 | 0,448 |
Com o encoder aprendido, o piso do bloco caiu de 0,171 para 0,013 e o cosseno do piso de 0,810 para 0,274: os estados abstratos encolheram treze vezes e ficaram quase ortogonais entre blocos consecutivos. O nível 2 "ganha" +0,006 sobre um piso de 0,013 — a mesma fração relativa da média crua (cerca de 45%), numa escala em que a MSE do nível 2 é pequena por construção. É o colapso disfarçado de acerto que a apostila 09 escreveu como risco antes da rodada: o encoder aprende a mandar todo bloco para perto do mesmo ponto, e o preditor "acerta". O SigReg nos estados de nível 1 não alcança o nível 2 — a primeira correção tentada foi o mesmo anticolapso aplicado aos estados abstratos (--sigreg-s2 1, rodada wm1n2e-sz1-ss1). Resultado: o piso do bloco subiu de 0,013 para 0,068 (ainda abaixo dos 0,160 da média crua), o nível 2 continua ganhando do nível 1 rolado (0,033 contra 0,050, ganho +0,039 contra +0,021), mas os blocos consecutivos ficaram quase ortogonais — cosseno do piso 0,07, contra 0,81 na média crua — e o gerador pagou +11,32%, o pior custo de todas as rodadas. Gaussianizar os estados abstratos com peso 1,0 impede o encolhimento tornando cada bloco independente do anterior, que é o oposto do que um estado de nível 2 deve ser. A segunda correção foi só de escala (--world-enc2-norm: a saída do encoder mantém a norma da média crua, sem forçar independência; rodada wm1n2en-sz1). Resultado: colapso pela outra porta. Com a norma fixada, o encoder mandou todos os blocos para a mesma direção — cosseno 1,000 entre blocos consecutivos, piso do bloco 0,009, nível 2 "acertando" 0,005 — e o gerador ficou em +6,22%, o mais barato dos encoders aprendidos justamente porque a perda do nível 2 virou trivial. Três tentativas, três atalhos: encolher (média + correção), alinhar (norma fixa), ou perder a continuidade (SigReg). Um encoder de nível 2 aprendido, treinado só pela predição do bloco seguinte, encontra sempre a solução que torna o bloco seguinte fácil de prever — e a mais fácil é a que não muda. É o colapso da palestra em forma pura, e a lição é que o anticolapso do nível 2 precisa fixar escala e variância entre blocos sem destruir a correlação entre vizinhos (um termo de variância, como o do VICReg, sobre os estados abstratos), o que fica em aberto. Neste orçamento, a média crua (wm1n2-sz1) é a abstração honesta, e é a que vale para a afirmação abaixo.
Na régua abstrata, o nível 2 num passo erra 0,094 contra 0,152 do nível 1 rolado oito vezes e abstraído — ganho +0,078 contra +0,020 sobre o piso de copiar o bloco, quatro vezes mais. A abstração prevê mais longe. O nível 1, mesmo prevendo cada token com cosseno 0,89, acumula erro ao longo do bloco e chega ao bloco seguinte mal melhor que a identidade; o nível 2, que nunca viu os tokens individuais, chega mais perto num passo só. É exatamente o "cada nível ignora detalhe para prever mais longe" — medido, num modelo de 7,4 M, com blocos de 8. E é o que faz o nível 2 valer como fonte de subobjetivo para o nível 1 (apostila 09): ele sabe onde o bloco seguinte vai estar melhor do que o nível 1 consegue imaginar.
Se o ganho do nível 2 supera o do nível 1 rolado × 8, a abstração prevê mais longe: a afirmação da palestra vale para texto neste modelo, e o nível 2 compra alcance, não só economia (um passo em vez de oito). Se o nível 1 rolado ganha, o nível 2 não está abstraindo nada útil — e a rodada com o encoder de nível 2 aprendido (wm1n2e-sz1) é a próxima a olhar. O nível 1 rolado deve degradar com
abstrair(). Só faz sentido depois que o segundo provar que prevê mais longe.A apostila 12 mede a outra ponta: com o mapa treinado, qual modo de inferência governa melhor — e a que preço.