O que são os pesos de um modelo?

Um modelo de IA moderno consegue escrever Python, reconhecer um cachorro, traduzir japonês, resumir um contrato, imitar Shakespeare e, de vez em quando, dizer algo completamente errado com a confiança de um homem que nunca sequer pensou em conferir nada no Google.

Por trás de toda essa sofisticação há algo surpreendentemente comum:

números.

Bilhões deles.

Quando você vê um modelo descrito como 8B, 30B ou 70B, o B significa bilhões de parâmetros.

Esses parâmetros são valores numéricos aprendidos dentro da rede neural. A maioria fica em enormes estruturas matemáticas chamadas matrizes de pesos.

Esses números são o que as pessoas normalmente querem dizer quando falam nos pesos de um modelo.

Eles não são pequenas frases guardadas em algum lugar do computador.

Não existe uma linha escondida dizendo:

França → Paris

Não existe uma pasta chamada:

Coisas que sei sobre cachorros

E nenhum peso individual tem um cargo como:

Vice-presidente sênior de Sarcasmo.

O conhecimento de uma rede neural está distribuído por enormes padrões de números.

Isso parece misterioso.

A ideia básica não é.

Na verdade, a história começa há mais de oitenta anos.

Antes de a IA ser descolada — ou sequer eletrônica

Em 1943, o neurofisiologista Warren McCulloch e o matemático Walter Pitts publicaram um influente modelo matemático de um neurônio artificial.

Foi antes da IA moderna.

Antes das GPUs.

Antes do Python.

Antes mesmo da invenção do transistor.

A pergunta deles era ousadamente simples:

Algo inspirado em um neurônio biológico poderia ser representado matematicamente como uma unidade de computação?

O neurônio artificial deles era extremamente primitivo pelos padrões atuais. Recebia entradas e produzia uma saída segundo regras matemáticas.

Mas uma ideia importante havia surgido:

talvez comportamentos complexos pudessem emergir de grandes quantidades de unidades de computação simples conectadas entre si.

As redes neurais modernas são muito mais sofisticadas.

Mas aquela ideia ancestral continua reconhecível por baixo delas.

Comece com um neurônio artificial

Esqueça por um momento os oito bilhões de parâmetros.

Vamos construir um único neurônio artificial minúsculo.

Suponha que ele receba três entradas numéricas:

A letra $x$ significa simplesmente entrada.

Essas entradas poderiam representar, no fim das contas, quase qualquer coisa: números de um conjunto de dados financeiros, partes de uma imagem ou representações numéricas internas da linguagem.

Cada entrada é multiplicada por outro número:

A letra $w$ representa o peso.

Um peso determina quanto aquela entrada contribui para o cálculo do neurônio.

O neurônio combina os valores assim:

A fórmula parece mais intimidadora do que a operação.

Em linguagem comum, ela diz:

Multiplique cada entrada por seu peso, some os resultados e acrescente outro número ajustável chamado viés.

O viés é:

Ele permite ao neurônio deslocar seu resultado para cima ou para baixo independentemente dos valores recebidos.

Depois de calcular a soma ponderada, uma rede neural normalmente passa o resultado por uma função não linear:

Aqui, $f$ significa simplesmente:

Aplique outra transformação matemática ao resultado.

Para que esse trabalho?

Porque, sem funções não lineares, empilhar muitas camadas ainda se comportaria matematicamente como uma única transformação linear gigante.

A não linearidade permite à rede representar relações muito mais complicadas.

Portanto, o caminho básico é:

entradas → pesos → soma ponderada → transformação não linear → próxima camada

Um neurônio artificial não vai escrever seu relatório trimestral.

Bilhões de parâmetros aprendidos, organizados em camadas sofisticadas, ficam consideravelmente mais interessantes.

O perceptron chega — e o exagero em torno da IA também

No fim dos anos 1950, o psicólogo Frank Rosenblatt desenvolveu o perceptron, um dos primeiros sistemas de rede neural treináveis.

A palavra importante é treinável.

Em vez de um programador escolher explicitamente cada valor interno útil, a máquina podia ajustar a força das próprias conexões com base em exemplos.

Essas forças de conexão eram pesos.

A ideia básica parecia surpreendentemente moderna:

Faça uma previsão.
Descubra se ela estava errada.
Ajuste os números.
Tente de novo.

Os jornais ficaram extremamente empolgados.

O que prova que as redes sociais não inventaram o exagero em torno da IA.

Os computadores eram um pouco menos convenientes.

Hoje você pode rodar modelos com bilhões de parâmetros em um equipamento debaixo da mesa.

Rosenblatt trabalhava em uma época em que computadores ocupavam uma parte considerável de uma sala e faziam muito menos do que o seu celular.

Às vezes o progresso é cruel com o hardware antigo.

A mesa de som gigante

Uma forma útil de imaginar os pesos é uma enorme mesa de mixagem de áudio.

Um sinal entra.

Um controle reforça parte dele.

Outro enfraquece alguma coisa.

Outro influencia como vários sinais se combinam.

Agora imagine não vinte controles.

Nem vinte mil.

Bilhões.

O comportamento final depende das configurações combinadas deles.

Mas essa analogia traz um aviso importante.

Um peso específico normalmente não corresponde de forma exata a um conceito humano.

Você não pode abrir um modelo 8B, encontrar o parâmetro número 4.827.112.391 e anunciar:

“Excelente. Achamos a orelha esquerda do cachorro.”

Redes neurais modernas usam representações distribuídas.

Um conceito como cachorro, ironia, JavaScript, gravidade ou uma forma educada de dizer a um cliente que a arte dele está horrível pode depender de padrões envolvendo enormes quantidades de parâmetros e estados internos temporários.

O significado está distribuído.

A inteligência está no padrão.

Não em um botão mágico.

Antes do treinamento: um idiota muito caro

Quando uma rede neural é inicializada, seus pesos geralmente começam como pequenos valores numéricos escolhidos segundo um método de inicialização.

Nesse momento, a rede tem uma arquitetura.

Tem bilhões de lugares onde conhecimento poderia vir a ser representado.

Mas ainda não aprendeu relações úteis.

Você poderia construir um modelo enorme e ainda assim ter algo quase inútil.

Vale lembrar disso quando a contagem de parâmetros começa a hipnotizar as pessoas.

Um galpão com dez bilhões de cadernos em branco não contém automaticamente mais conhecimento do que uma biblioteca.

É preciso escrever alguma coisa nos cadernos.

O treinamento é o processo que muda os números.

Não escrevendo frases neles.

Mas criando relações numéricas úteis.

Deixe um neurônio cometer um erro

Agora vamos observar um pequeno exemplo de treinamento com números simples o bastante para acompanhar à mão.

Suponha que nosso neurônio receba duas entradas.

A primeira entrada é:

A segunda é:

Assim, o primeiro sinal tem valor numérico de um, enquanto o segundo vale meio.

O primeiro peso atual é:

O segundo é:

E o viés é:

Agora usamos o cálculo da soma ponderada:

Em vez de ficar olhando para a fórmula, vamos dividi-la em partes.

A primeira entrada contribui com:

A segunda entrada contribui com:

E o viés acrescenta:

Some as três partes:

Portanto, nosso neurônio produz:

O pequeno chapéu sobre $y$ significa:

a previsão do modelo

Agora suponha que o alvo correto nesse exemplo de treinamento seja:

O modelo previu:

O resultado correto era:

Portanto, a previsão ficou abaixo por:

O neurônio está errado.

Isso é uma excelente notícia.

Os erros são, basicamente, o sistema educacional das redes neurais.

Sem um erro, o processo de treinamento não tem um sinal indicando o que precisa melhorar.

Perda: um medidor matemático de vergonha

O sistema de treinamento agora precisa de uma forma formal de responder:

O quanto essa previsão estava errada?

Esse é o trabalho de uma função de perda.

Para nosso exemplo de brinquedo, podemos usar uma perda simples de erro quadrático:

Vamos traduzir cada símbolo.

$L$ significa perda.

$\hat y$ significa a previsão do modelo.

$y$ significa o alvo correto.

Portanto, a fórmula diz:

Subtraia a resposta correta da previsão e eleve a diferença ao quadrado.

Nossa previsão é:

O alvo é:

Subtraia:

Agora eleve esse resultado ao quadrado:

Portanto, nossa perda é:

Por que elevar o erro ao quadrado?

Entre outros motivos, não queremos que erros em sentidos opostos se anulem.

Ficar 0.30 abaixo ainda é um erro.

Elevar ao quadrado nos dá uma quantidade positiva que a otimização pode tentar reduzir.

Pense na perda como um medidor matemático de vergonha.

Perda alta:

Isso deu errado.

Perda menor:

Menos constrangedor.

Um modelo de linguagem moderno normalmente usa outra função de perda para prever o próximo token, em geral uma forma de perda de entropia cruzada.

Vamos conhecê-la mais adiante.

Por enquanto, a ideia essencial é:

previsão → medir o erro

A próxima pergunta é mais difícil.

Nosso pequeno exemplo tem só dois pesos.

Um modelo real pode ter bilhões.

Quais pesos foram responsáveis pelo erro?

E em que direção eles devem se mover?

1986: a matemática aprende a distribuir a culpa

Uma das ferramentas centrais para responder a essa pergunta é a retropropagação.

As ideias matemáticas por trás dela têm uma história mais longa, mas um trabalho influente de David Rumelhart, Geoffrey Hinton e Ronald Williams, em 1986, ajudou a tornar a retropropagação central no treinamento moderno de redes neurais.

O problema é simples de enunciar.

A saída estava errada.

Mas muitas camadas e muitos parâmetros participaram da sua produção.

Como determinar quais mudanças melhorariam a saída?

A retropropagação percorre a rede de trás para frente e calcula a sensibilidade do erro final a cada parâmetro treinável.

Você pode imaginá-la como um departamento de contabilidade extraordinariamente eficiente.

Um erro aconteceu.

Agora a contribuição de todo mundo é calculada.

Ninguém pode dizer:

“Tenho quase certeza de que foi a camada 17.”

O cálculo tem os comprovantes.

Retropropagação: o que a fórmula significa?

Uma das expressões que você vai encontrar é:

Se você estudou cálculo vinte anos atrás e passou todo esse tempo conseguindo evitá-lo, a notação pode causar danos emocionais desnecessários.

A ideia é bem mais simples do que o símbolo.

Ela pergunta:

Se eu mudasse esse peso específico só um pouquinho, como a perda mudaria?

Esse valor faz parte do que chamamos de gradiente.

Suponha que aumentar um peso um pouco aumente o erro.

Informação útil.

Suponha que aumentá-lo diminua o erro.

Também útil.

A derivada, portanto, informa ao otimizador algo sobre direção e sensibilidade.

A retropropagação usa a regra da cadeia do cálculo para calcular essas relações de forma eficiente através de muitas camadas.

A rede não está pensando:

“Confundi o cachorro com um gato porque prestei atenção demais no pelo.”

Não está acontecendo nada tão literário.

Ela está calculando como mudanças em números afetam outros números.

Muitos números.

Descida do gradiente: agora vá ladeira abaixo

Depois que a retropropagação calcula os gradientes, o otimizador tem algo em que se basear para agir.

Uma atualização simplificada de peso se parece com isto:

Mais uma vez, vamos traduzir antes de usar.

$w_{\text{old}}$ é o peso que temos agora.

$w_{\text{new}}$ é o peso depois da etapa de treinamento.

O gradiente:

nos diz como a perda muda quando esse peso muda.

E a letra grega:

pronunciada eta, é a taxa de aprendizado.

A taxa de aprendizado determina o tamanho do passo que o otimizador deve dar.

Portanto, a fórmula inteira significa:

Comece com o peso atual.
Descubra qual direção aumenta o erro.
Ande uma distância controlada na direção oposta.

Por que a direção oposta?

Porque o objetivo é fazer a perda diminuir.

Imagine estar em uma montanha sob neblina intensa.

Você não consegue ver o vale.

Mas consegue descobrir em que direção o terreno sobe.

Se a meta é descer, caminhe para o outro lado.

Essa é a intuição básica por trás da descida do gradiente.

A paisagem real de otimização de uma rede neural moderna pode ter bilhões de dimensões.

Isso torna um pouco difícil desenhar a montanha em um guardanapo.

Se você consegue visualizar tranquilamente uma paisagem de setenta bilhões de dimensões, talvez tenha outros problemas.

O treinamento moderno costuma usar otimizadores mais sofisticados, como Adam ou AdamW, que acompanham informações adicionais e ajustam o processo de atualização de forma inteligente.

Mas a ideia central continua sendo:

calcular como os parâmetros afetam o erro e movê-los em uma direção que se espera que o reduza.

Agora vamos fazer isso de verdade.

Uma pequena atualização — com as contas de verdade

Nosso neurônio de brinquedo recebeu anteriormente:

e:

Seus pesos eram:

e:

O viés era:

O neurônio previu:

O resultado desejado era:

Nesta demonstração, vamos usar a soma ponderada diretamente como previsão para deixar todas as contas visíveis. Uma rede real também pode conter uma função de ativação cuja derivada entra na retropropagação.

Nosso erro de previsão com sinal é:

O sinal negativo nos diz:

A previsão do modelo está abaixo do alvo.

Nossa perda de erro quadrático era:

portanto:

Agora calculamos como essa perda responde a cada peso.

Encontrando o gradiente do primeiro peso

Para esse neurônio simples, o gradiente da perda em relação ao primeiro peso é:

Parece técnico.

Mas todos os valores já são conhecidos.

O erro é:

A primeira entrada é:

Substitua esses valores:

Multiplique:

O que significa menos 0.60?

Isso nos diz que, nesse ponto, aumentar $w_1$ deve reduzir a perda.

O gradiente aponta para o aumento do erro.

A descida do gradiente segue na direção oposta.

Encontrando o gradiente do segundo peso

Agora faça o mesmo com o segundo peso:

O erro continua sendo:

Mas a segunda entrada é apenas:

Substitua:

o que resulta em:

Observe algo útil.

A magnitude do segundo gradiente é só metade da do primeiro.

Por quê?

Porque a segunda entrada:

é metade da primeira:

Neste pequeno exemplo, mudar o primeiro peso tem um efeito maior no resultado final.

É exatamente esse tipo de dependência que a retropropagação calcula automaticamente.

Escolhendo uma taxa de aprendizado

Agora sabemos a direção.

Ainda precisamos decidir o tamanho do passo.

Para nossa demonstração, escolha:

Isso significa que o otimizador vai se mover um décimo da magnitude do gradiente nessa etapa simplificada.

É um número redondo conveniente para ensinar.

Sistemas de treinamento reais escolhem e programam taxas de aprendizado com muito mais cuidado.

Pequena demais, e o aprendizado pode ficar dolorosamente lento.

Grande demais, e o otimizador pode saltar por cima de boas soluções e começar a quicar pela paisagem como alguém tentando descer uma montanha de botas de esqui.

Atualizando o primeiro peso

A regra de atualização é:

Para o primeiro peso:

Primeiro multiplique a taxa de aprendizado pelo gradiente:

Portanto:

Subtrair um número negativo significa somar:

E agora sabemos exatamente de onde veio 0.26.

Ninguém escolheu esse número porque parecia bonito.

Nenhum engenheiro digitou:

Vamos tentar 0.26.

O gradiente e a taxa de aprendizado o produziram.

Atualizando o segundo peso

Agora repita exatamente o mesmo processo para $w_2$:

Multiplique:

Portanto:

o que resulta em:

É daí que veio 0.43.

Neste exemplo didático, vamos deixar o viés inalterado em:

Em uma rede real, um viés treinável normalmente teria seu próprio gradiente e poderia ser atualizado pelo mesmo processo geral.

Execute o neurônio de novo

As entradas não mudaram.

A primeira ainda é:

Mas seu peso agora é:

Sua contribuição, portanto, é:

A segunda entrada continua sendo:

Seu novo peso é:

Assim, sua contribuição se torna:

O viés continua sendo:

Some tudo:

A nova previsão do neurônio é:

Antes da etapa de treinamento, ele previa:

Agora prevê:

O alvo continua sendo:

Ele ainda está errado.

Mas veja o que aconteceu.

Antes da atualização, a distância até o alvo era:

Depois da atualização:

O erro ficou menor.

Também podemos calcular a nova perda quadrática:

Primeiro:

Depois eleve ao quadrado:

Portanto, a perda caiu de:

para:

Neste exemplo deliberadamente simples, uma etapa de descida do gradiente reduziu bastante a perda.

Isso não significa que um grande modelo de linguagem real melhore na mesma porcentagem a cada etapa de treinamento.

A otimização real é ruidosa, complicada e tem muito mais dimensões.

Mas nosso pequeno exemplo mostrou uma etapa completa de aprendizado sem esconder nada:

Em palavras:

O neurônio fez uma previsão.
A perda mediu o erro.
O cálculo determinou como os pesos contribuíram para o erro.
O otimizador mudou os pesos.
A nova previsão se aproximou do alvo.
A perda diminuiu.

Nada de mágico aconteceu.

A matemática mudou os números.

Então o sistema faz isso de novo.

E de novo.

E de novo.

Nosso exemplo usa dois pesos porque dois pesos ainda cabem confortavelmente em uma página.

Uma rede neural real pode ajustar milhões ou bilhões de parâmetros treináveis.

É aí que a computação em escala industrial entra na história.

Como um modelo de linguagem aprende com isso?

Um grande modelo de linguagem normalmente não é treinado recebendo uma tabela gigantesca de regras explícitas como:

Paris = capital da França

Cachorro = mamífero

Python = indentação importa

Em vez disso, boa parte do pré-treinamento moderno de modelos de linguagem usa um objetivo enganosamente simples:

Prever o próximo token.

Vamos continuar com Paris e acompanhar o exemplo até o fim.

Suponha que o texto de treinamento contenha:

A capital da França é Paris.

Em certo ponto do treinamento, o modelo recebe:

A capital da França é

e precisa prever o próximo token.

Para simplificar, suponha que Paris seja representada por um token. A tokenização real pode dividir algumas palavras em vários tokens, mas esse detalhe não muda o princípio.

No início do treinamento, o modelo poderia produzir probabilidades mais ou menos assim:

Londres — 18%
Paris — 5%
Lyon — 4%
Roma — 3%
Berlim — 2%

A probabilidade restante está espalhada por milhares de outros tokens possíveis.

Mas o texto de treinamento nos diz que o verdadeiro próximo token é:

Paris

Portanto, o modelo fez uma previsão ruim.

Deu apenas cinco por cento de probabilidade a Paris, favorecendo Londres.

Agora o treinamento precisa medir o quanto essa previsão foi ruim.

Entropia cruzada: a perda do modelo de linguagem

Para prever o próximo token, modelos de linguagem costumam usar uma forma de perda de entropia cruzada.

Para um único token correto, a expressão simplificada pode ser escrita assim:

Mais uma vez, traduza antes de calcular.

$P_{\text{correct}}$ significa:

a probabilidade que o modelo atribuiu ao token que realmente veio em seguida

No nosso exemplo:

Cinco por cento escrito como decimal é:

Substitua:

O resultado é aproximadamente:

Você não precisa lembrar de 2.996.

O importante é o que o logaritmo faz.

Uma probabilidade baixa para a resposta correta produz uma perda relativamente alta.

Agora suponha que, bem mais adiante no treinamento, o mesmo tipo de contexto dê a Paris uma probabilidade de setenta por cento:

Então:

o que é aproximadamente:

Portanto:

Paris com 5% → perda relativamente alta

Paris com 70% → perda muito menor

A função de perda não sabe o que é Paris.

Não sabe o que é a França.

Não entende o conceito político de capital.

Ela simplesmente diz:

A probabilidade atribuída ao token correto deveria ter sido maior.

Esse sinal numérico basta.

A retropropagação agora pode fazer o mesmo tipo de trabalho que vimos no nosso neurônio de brinquedo.

Como “Paris” realmente chega aos pesos?

A previsão não veio de um único peso.

As palavras:

A capital da França é

foram primeiro convertidas em representações numéricas de tokens.

Essas representações passaram por muitas camadas Transformer.

Dentro dessas camadas, mecanismos de atenção e redes de propagação direta transformaram repetidamente os números usando matrizes de pesos aprendidas.

Por fim, o modelo produziu pontuações brutas para os possíveis próximos tokens.

Essas pontuações brutas são chamadas de logits.

Imagine uma versão drasticamente simplificada:

Isso ainda não são probabilidades.

São pontuações brutas de preferência.

Uma operação matemática chamada softmax converte os logits em uma distribuição de probabilidades cujos valores somam cem por cento.

Talvez, depois do softmax, tenhamos:

Londres — 18%
Paris — 5%
Lyon — 4%
Roma — 3%

Os dados de treinamento nos dizem:

Paris deveria ter vencido.

A entropia cruzada fornece a perda.

A retropropagação então percorre a rede de trás para frente, calculando como pequenas mudanças nos parâmetros envolvidos afetariam essa perda.

O otimizador os atualiza.

Não uma única mudança gigante.

Enormes quantidades de mudanças microscópicas.

Depois chega outro trecho de texto.

Uma frase não ensina geografia

O modelo não vê:

A capital da França é Paris.

uma única vez e anuncia imediatamente:

“Geografia concluída.”

Seus dados de treinamento também podem conter:

Paris é a capital da França.

A cidade capital da França é Paris.

O governo francês fica em Paris.

Paris é uma grande cidade europeia.

A França é um país da Europa Ocidental.

O Sena passa por Paris.

E enormes quantidades de outros contextos envolvendo França, Paris, cidades, governos, países, idiomas, viagens, história e geografia.

Cada exemplo produz previsões.

Cada previsão produz uma perda.

Cada perda gera gradientes.

Cada etapa de treinamento modifica um pouco os parâmetros.

Com o tempo, relações que se sobrepõem vão sendo tecidas na rede.

Essa palavra — tecidas — é útil.

O fato não é colocado em uma caixa marcada:

França → Paris

Ele passa a fazer parte de um tecido matemático distribuído.

Depois de treinamento suficiente

Com o tempo, o modelo vê:

A capital da França é

e talvez sua distribuição de saída agora seja mais parecida com isto:

Paris — 92%
Lyon — 1.2%
Marselha — 0.7%
Londres — 0.3%

Paris agora vence facilmente.

Então onde o fato está armazenado?

Não em um peso.

Não em um neurônio.

Não em um registro de texto escondido.

A relação está distribuída pela rede.

E é por isso que o modelo também pode responder:

Qual cidade serve como capital da França?

ou:

Qual é a cidade capital da França?

A frase exata mudou.

Mas as relações subjacentes entre os conceitos continuam úteis.

O modelo não está simplesmente procurando a frase exata do treinamento.

Ele está calculando por meio de uma rede aprendida de relações numéricas.

É também por isso que a tarefa aparentemente simples de prever o próximo token pode levar a um comportamento surpreendentemente rico.

Para prever bem a linguagem, ajuda aprender gramática.

Significado.

Fatos.

Relações.

Estilo.

Estrutura.

Padrões de raciocínio.

O objetivo é simples:

Prever o que vem a seguir.

O que o modelo precisa aprender para ficar excepcionalmente bom nessa tarefa não é.

E, no fim das contas, essas relações aprendidas se refletem nos seus pesos.

Cachorros, gatos e por que a “importância das características” pode enganar

Uma explicação comum dos pesos de redes neurais usa a classificação de imagens.

Suponha que um modelo seja treinado para distinguir cachorros de gatos.

Ele pode descobrir que certos padrões visuais envolvendo formato do focinho, orelhas, estrutura do rosto ou formato do corpo são mais úteis do que outros.

É uma intuição útil.

Mas não deve ser levada ao pé da letra.

Uma rede moderna normalmente não contém:

Peso da orelha = 0.84

Peso da cor do pelo = 0.17

As primeiras camadas podem ficar sensíveis a padrões relativamente simples, como bordas.

Camadas posteriores podem combiná-los em texturas e formas.

Representações ainda posteriores podem responder a estruturas cada vez mais complicadas.

A classificação final surge das interações entre muitas camadas e muitos parâmetros.

Portanto, quando dizemos:

o modelo aprendeu que o formato da orelha importa

estamos traduzindo um processo numérico distribuído complexo para a linguagem humana.

Não existe um botão com a etiqueta ORELHA.

2012: a GPU entra na história

Redes neurais já existiam havia décadas.

Por que suas capacidades aceleraram de repente?

Um dos grandes motivos foi o hardware.

Em 2012, Alex Krizhevsky, Ilya Sutskever e Geoffrey Hinton demonstraram o que ficou conhecido como AlexNet, uma rede profunda de reconhecimento de imagens com cerca de sessenta milhões de parâmetros.

Um ingrediente fundamental foi o uso de unidades de processamento gráfico, ou GPUs.

As GPUs evoluíram em grande parte porque a computação gráfica exige enormes quantidades de operações matemáticas semelhantes acontecendo em paralelo.

Os videogames precisavam processar pixels, triângulos, iluminação e texturas rapidamente.

As redes neurais olharam para aquele hardware e, na prática, disseram:

“Essa máquina de multiplicar parece útil.”

A indústria de jogos havia passado anos ajudando, sem querer, a desenvolver a infraestrutura do aprendizado de máquina.

Em algum lugar, um dragão virtual merece parte do crédito pela IA moderna.

De pesos individuais a tensores

Nosso minúsculo neurônio usava valores individuais como:

e:

Uma rede real não consegue administrar confortavelmente bilhões de parâmetros dessa forma.

Em vez disso, os números são organizados em estruturas chamadas tensores.

Uma lista simples de números pode ser vista como um tensor unidimensional.

Uma tabela retangular de números é um tensor bidimensional, normalmente chamado de matriz.

Coleções de dimensões superiores também são tensores.

Grandes partes dos cálculos de redes neurais podem ser expressas de forma compacta, como:

Vamos traduzir esta também.

$X$ representa uma coleção de números de entrada.

$W$ representa uma matriz de pesos aprendidos.

Multiplicar:

significa combinar muitos valores de entrada com muitos pesos aprendidos de acordo com as regras da multiplicação de matrizes.

O resultado:

é uma nova coleção de valores numéricos transformados.

A notação parece minúscula.

O cálculo real pode conter milhões ou bilhões de operações individuais de multiplicação e soma.

É por isso que as GPUs são tão valiosas.

Elas conseguem realizar enormes quantidades dessas contas em paralelo.

Enquanto a IA parece conversar tranquilamente sobre Dostoiévski, a GPU está multiplicando em escala industrial.

A conversa parece intelectual.

O hardware enxerga aritmética.

2017: a atenção muda a arquitetura

Em 2017, o artigo “Attention Is All You Need” apresentou a arquitetura Transformer.

Os Transformers se tornaram a base da maioria dos grandes modelos de linguagem modernos.

A arquitetura introduziu uma forma poderosa de diferentes partes de uma sequência interagirem por meio da atenção.

Mas a chegada da atenção não aboliu os pesos.

Muito pelo contrário.

Transformers contêm grandes matrizes aprendidas por toda a arquitetura.

A atenção usa matrizes de projeção aprendidas.

As camadas de propagação direta usam matrizes aprendidas.

Sistemas de embeddings contêm parâmetros aprendidos.

A arquitetura ficou dramaticamente mais sofisticada.

A moeda básica continuou sendo os números.

2020: 175 bilhões viram manchete

Então veio a escala.

Em 2020, o GPT-3 foi apresentado com:

175 bilhões de parâmetros.

Compare isso com os cerca de sessenta milhões de parâmetros do AlexNet, apenas oito anos antes.

A área havia passado de milhões de valores aprendidos para centenas de bilhões.

A ideia fundamental continuava reconhecível:

Aprender parâmetros numéricos úteis a partir de dados.

Pesquisadores melhoraram a arquitetura.

Os métodos de treinamento melhoraram.

Os conjuntos de dados cresceram.

Os clusters de GPU ficaram enormes.

Então, como costuma acontecer na computação, acrescentamos uma quantidade absurda de zeros.

O que um modelo 8B contém fisicamente?

Agora a contagem de parâmetros deixa de ser abstrata.

Ela vira um problema físico de armazenamento.

Suponha que um modelo contenha:

parâmetros.

Isso significa cerca de oito bilhões de valores numéricos aprendidos.

Suponha que cada parâmetro seja armazenado usando dezesseis bits.

Dezesseis bits equivalem a:

Portanto, o armazenamento bruto aproximado dos parâmetros é:

o que dá:

ou aproximadamente:

De onde vieram esses dezesseis gigabytes?

Nada de misterioso.

Temos oito bilhões de números.

Cada um precisa de dois bytes.

Oito bilhões vezes dois dão cerca de dezesseis bilhões de bytes.

Agora considere um modelo de setenta bilhões de parâmetros na mesma precisão.

O cálculo é:

o que dá aproximadamente:

só para armazenar os parâmetros em bruto.

De repente:

“Modelo 70B”

não é mais apenas um nome de modelo.

É um problema de hardware.

Sua GPU começa a prestar atenção.

A RAM do sistema pode começar a prestar atenção.

No fim, sua carteira começa a prestar atenção.

Quantização: o que estamos realmente diminuindo?

Suponha que dezesseis bits por parâmetro exijam memória demais.

Podemos representar os mesmos valores aprendidos usando menos bits?

Essa é a ideia básica da quantização.

Pegue nosso modelo 8B hipotético.

Com dezesseis bits por parâmetro, o armazenamento bruto idealizado dos parâmetros é de aproximadamente:

Agora suponha que representemos muitos pesos usando cerca de quatro bits.

Quatro bits são meio byte:

Portanto:

dá aproximadamente:

O importante é o que não aconteceu.

Não transformamos um modelo de oito bilhões de parâmetros em um de dois bilhões.

O modelo continua com aproximadamente a mesma quantidade de parâmetros.

Mudamos a precisão numérica usada para representá-los.

Uma intuição simples é o arredondamento numérico.

Você poderia armazenar:

ou:

O segundo número tem menos precisão.

A quantização real de redes neurais é bem mais sofisticada do que simplesmente arredondar casas decimais. Métodos práticos usam fatores de escala, grupos, codificações especializadas e outras técnicas para preservar um comportamento útil enquanto reduzem a memória.

Mas a relação física central continua sendo:

menos bits por peso → menos memória

É por isso que usuários de IA local passam uma parte surpreendente da vida debatendo Q4, Q5, Q6 e Q8.

De longe, parece conversa sobre óleo de motor.

Geralmente é sobre encaixar bilhões de números em uma placa de vídeo.

Pesos não são ativações

Outra distinção importa muito quando falamos de hardware.

Os pesos são persistentes.

São armazenados como parte do modelo.

Desligue a máquina.

Carregue o mesmo modelo amanhã.

Os pesos aprendidos continuam lá.

As ativações são temporárias.

Quando uma entrada percorre a rede, cada camada produz estados numéricos intermediários.

Esses valores dependem da entrada atual.

Mude o prompt e as ativações mudam.

Pense em uma fábrica.

Os pesos são as máquinas instaladas.

As ativações são o material que está passando por essas máquinas agora.

Isso explica por que carregar os pesos na memória da GPU não é toda a necessidade de memória.

O próprio cálculo precisa de espaço de trabalho.

Modelos de linguagem também podem usar bastante memória para um cache de chaves e valores, ou cache KV, que guarda informações intermediárias úteis de tokens já processados.

Conforme o contexto cresce, esse cache também pode crescer.

Portanto:

Os pesos cabem na VRAM

não significa automaticamente:

O modelo consegue trabalhar confortavelmente nessa VRAM.

O sofá pode passar pela porta do apartamento.

Você ainda vai querer algum lugar para ficar em pé.

Os pesos mudam enquanto você conversa com o modelo?

Normalmente:

Não.

Quando um modelo treinado responde a um prompt, ele faz inferência.

Inferência significa:

Usar os parâmetros já aprendidos para calcular uma saída.

Os pesos são lidos.

Normalmente não são reescritos porque você fez uma pergunta.

Ainda bem.

Caso contrário, uma conversa estranha o suficiente poderia remodelar a rede permanentemente.

Uma conversa cria um estado temporário: contexto, ativações, cache KV, resultados de ferramentas e outras informações de trabalho.

Isso é diferente dos parâmetros treinados persistentes.

O resumo mais simples é:

O treinamento muda os pesos. A inferência usa os pesos.

Essa frase explica muita coisa sobre IA.

Ajuste fino: mudando os números de novo

Um modelo pré-treinado pode receber treinamento adicional mais tarde.

Esse processo é chamado de ajuste fino.

Imagine um modelo geral que já entende a linguagem.

Você poderia ajustá-lo com:

material jurídico,

terminologia médica,

exemplos de programação,

conversas de atendimento ao cliente,

análise financeira,

ou outra área especializada.

O treinamento volta a modificar parâmetros para adaptar melhor o modelo à nova tarefa.

O ajuste fino completo pode atualizar enormes quantidades de parâmetros e exigir recursos computacionais consideráveis.

Outros métodos, como a adaptação de baixo posto, ou LoRA, treinam estruturas adicionais de parâmetros muito menores, deixando a maior parte do modelo original inalterada.

A distinção prática é importante.

Dar um PDF ao modelo durante uma conversa normalmente muda seu contexto.

O ajuste fino muda parâmetros aprendidos.

Uma coisa fornece informação temporária.

A outra muda o modelo treinado.

O modelo não é o sistema inteiro

Suponha que duas pessoas baixem exatamente o mesmo modelo.

Mesmo checkpoint.

Mesmos pesos.

Mesma quantização.

Uma constrói um excelente sistema de pesquisa.

A outra produz respostas pouco confiáveis com uma formatação linda.

Como isso pode acontecer?

Porque o modelo é só um componente.

Ao redor dele podem existir prompts, sistemas de recuperação, bancos de dados, memória, ferramentas, navegadores, roteamento, permissões, validação e código de aplicação.

Esse software ao redor às vezes é chamado de harness ou ambiente de agentes.

O harness normalmente não reescreve os pesos do modelo toda vez que chega uma solicitação.

Ele controla quais informações chegam ao modelo, quais ferramentas o modelo pode usar e o que acontece com o resultado.

Mesmos pesos.

Ambiente diferente.

Comportamento diferente.

O motor pode ser idêntico.

O veículo não precisa ser.

O que é um modelo de pesos abertos?

Durante o treinamento, os parâmetros mudam constantemente.

Em momentos úteis, os desenvolvedores salvam seu estado atual.

Esse estado salvo é chamado de checkpoint.

Um checkpoint é, essencialmente, uma fotografia do estado numérico aprendido do modelo em um momento específico.

Se esses arquivos de parâmetros treinados ficam disponíveis para outras pessoas baixarem, o modelo costuma ser descrito como de pesos abertos.

Dependendo da licença, as pessoas podem executá-lo localmente, quantizá-lo, ajustá-lo, estudá-lo, integrá-lo a produtos ou redistribuir versões derivadas.

Mas existe uma distinção importante de terminologia.

Pesos abertos não significam automaticamente código aberto.

Um desenvolvedor pode publicar os pesos e manter privados o conjunto de treinamento, partes do código de treinamento, a receita completa de treinamento ou outros componentes.

As licenças também podem impor restrições.

Portanto, são duas perguntas diferentes:

Posso baixar os pesos treinados?

e:

Todo o processo de desenvolvimento do modelo é aberto?

As respostas podem não ser as mesmas.

As palavras importam.

Especialmente depois que os advogados chegam.

Por que os pesos abertos mudaram o jogo

Treinar um modelo de base poderoso do zero pode exigir recursos enormes:

dados, clusters de GPU, eletricidade, engenharia, tempo e dinheiro.

Baixar pesos treinados permite que outra pessoa comece depois que aquele treinamento caro já aconteceu.

Você recebe o estado numérico aprendido.

Não precisa reproduzir toda a educação.

Para pesquisadores, isso permite o estudo.

Para desenvolvedores, permite implantação local e experimentação.

Para organizações, pode oferecer mais controle.

E para entusiastas e usuários curiosos por tecnologia, cria algo que teria parecido extraordinário até pouco tempo atrás:

Um modelo treinado com infraestrutura em escala industrial pode acabar como arquivos em um computador na sua casa.

O cluster de treinamento pode ocupar um data center.

O checkpoint pronto pode acabar em um SSD debaixo da sua mesa, ao lado de três cabos USB que ninguém lembra de ter comprado.

É uma bela viagem para um tensor.

O que os pesos não são

Depois de tudo isso, fica mais fácil desfazer alguns equívocos.

Pesos não são um banco de dados.

Não existe uma linha contendo:

capital_of_france = Paris

Um peso isolado normalmente não é um conceito legível para uma pessoa.

Encontrar:

dentro de um tensor, por si só, diz muito pouco.

Os pesos normalmente não mudam durante a inferência comum.

O treinamento os modifica.

A inferência os usa.

Um peso geralmente não equivale a uma característica.

O significado está distribuído entre muitos parâmetros e camadas.

Quantidade de parâmetros não é igual a inteligência.

A arquitetura importa.

Os dados de treinamento importam.

A otimização importa.

O pós-treinamento importa.

O tratamento do contexto importa.

O ambiente ao redor importa.

Um idiota com oitenta bilhões de parâmetros ainda seria um idiota.

Só precisaria de uma GPU mais cara.

Pesos versus parâmetros

As pessoas costumam usar as palavras peso e parâmetro quase como sinônimos.

Em uma conversa comum, geralmente não há problema.

Tecnicamente, parâmetro é o termo mais amplo.

Pesos são parâmetros.

Vieses, valores de normalização e outros valores treináveis também podem ser parâmetros.

Portanto, quando alguém diz:

“Este é um modelo 70B”,

o significado mais preciso é:

O modelo contém cerca de setenta bilhões de parâmetros aprendidos.

A maioria desses parâmetros fica em grandes matrizes aprendidas.

As pessoas vão continuar chamando-os de pesos.

A civilização provavelmente vai sobreviver.

O que significa dizer que um modelo “sabe” alguma coisa?

Agora a matemática começa a encostar na filosofia.

Um modelo de linguagem não contém um bibliotecário em miniatura procurando fatos em estantes.

Não existe um minúsculo banco de dados SQL escondido dentro do Transformer.

Em vez disso, o treinamento molda bilhões de relações numéricas para que certos padrões de entrada tendam a produzir padrões de saída úteis.

Pergunte:

A capital da França é —

e a rede aprendida favorece fortemente:

Paris.

Peça código Python e outro padrão de atividade interna aparece.

Pergunte sobre história medieval e aparece outro.

Os mesmos pesos persistentes participam de todos esses comportamentos.

Portanto, quando dizemos que um modelo sabe algo, matematicamente queremos dizer algo mais próximo de:

Seus parâmetros aprendidos chegaram a uma configuração que produz um comportamento compatível com ter aprendido aquela informação ou capacidade.

Se isso merece a mesma palavra conhecimento que usamos para seres humanos é uma questão filosófica muito maior.

Provavelmente é melhor tentar depois do jantar.

A história inteira em dois diagramas

Para quem quer o esqueleto técnico sem repetir toda a jornada, a inferência pode ser resumida assim:

Em linguagem comum:

Dê uma entrada à rede treinada.
Passe-a por camadas que contêm pesos aprendidos.
Gere estados internos temporários.
Produza uma saída.

O treinamento acrescenta um segundo ciclo:

Em linguagem comum:

Faça uma previsão.
Meça o quanto ela estava errada.
Calcule quais mudanças de parâmetros devem reduzir o erro.
Atualize esses parâmetros.

Depois repita.

E repita.

E repita.

Ou, na versão mais curta que ainda é tecnicamente útil:

A inferência usa os números. O treinamento muda os números.

Todo o resto é arquitetura, dados, otimização, hardware e escala.

É verdade que esses quatro assuntos mantiveram um bom número de pesquisadores empregados.

Por que isso importa mesmo se você nunca treinar nada

A maioria das pessoas que rodam IA local nunca vai calcular um gradiente à mão.

Tudo bem.

A maioria das pessoas que dirige também não fabrica o próprio virabrequim.

Mas entender os pesos explica muitas coisas que um usuário de IA curioso por tecnologia acaba encontrando.

Por que um modelo 8B ocupa vários gigabytes?

Porque bilhões de parâmetros numéricos aprendidos precisam ser armazenados fisicamente.

Por que Q4 exige muito menos memória do que a precisão de dezesseis bits?

Porque menos bits são usados para representar muitos desses parâmetros.

Por que a quantização pode mudar um pouco o comportamento?

Porque a precisão numérica mudou.

Por que o ajuste fino pode mudar um modelo?

Porque o treinamento adicional muda parâmetros.

Por que enviar um PDF não ensina o modelo permanentemente?

Porque o PDF muda o contexto atual, não os pesos persistentes.

Por que dois sistemas com os mesmos pesos de modelo podem se comportar de formas muito diferentes?

Porque o modelo é só uma parte do ambiente ao redor dele.

E por que é possível baixar um modelo de IA treinado?

Porque boa parte do que o treinamento produziu pode ser preservada em enormes coleções de parâmetros numéricos aprendidos.

A ideia começou com pequenos neurônios matemáticos.

Depois vieram os perceptrons treináveis.

A retropropagação tornou o aprendizado em várias camadas viável.

As GPUs forneceram quantidades extraordinárias de aritmética em paralelo.

Os Transformers reorganizaram a forma de processar a linguagem.

A quantidade de parâmetros cresceu de milhões para bilhões e além.

A escala mudou a ponto de quase não ser mais reconhecível.

O ciclo central continuou surpreendentemente familiar:

Faça uma previsão.

Meça o erro.

Calcule o que deve mudar.

Mude um pouco os números.

Tente de novo.

Faça isso vezes suficientes, com dados, matemática, hardware e eletricidade suficientes —

e, no fim, os números começam a responder.