Você já viu a mágica acontecer: o aplicativo do banco lê o número escrito à mão no formulário, o celular transcreve o que você fala, o compu...
Em julho de 1958, o New York Times anunciou ao mundo que a Marinha norte-americana havia apresentado o embrião de um computador capaz de aprender sozinho. O aparelho ainda nem existia direito — era um programa rodando num computador de válvulas — mas a manchete já prometia máquinas que andariam, falariam, veriam, escreveriam e teriam consciência da própria existência (PROFESSOR'S…, 2019). O responsável pela demonstração era um psicólogo de Cornell chamado Frank Rosenblatt, e sua invenção tinha um nome que atravessaria quase setenta anos: perceptron.
"NOVO DISPOSITIVO DA MARINHA APRENDE FAZENDO: psicólogo apresenta o embrião de um computador projetado para ler e ficar mais sábio."
Manchete do New York Times, julho de 1958, na tradução do autor (PROFESSOR'S…, 2019)
A imprensa exagerou — como exagera até hoje. Mas havia algo de novo e verdadeiro naquela demonstração: pela primeira vez, uma máquina ajustava sozinha os próprios parâmetros a partir de exemplos, sem que ninguém escrevesse a regra. Este post é a autópsia carinhosa dessa ideia. Vamos do neurônio mais simples que existe até a retropropagação — o algoritmo que sustenta praticamente toda a inteligência artificial moderna — e terminar reconhecendo algarismos numa grade de pixels. Nenhum pré-requisito além de saber que uma reta pode separar dois grupos de pontos num plano.
Sinapse 01
O neurônio de papel: três entradas, três pesos, uma decisão
O neurônio artificial é uma caricatura deliberada do biológico: soma sinais de entrada e dispara se o total passar de um limiar. Ilustração do autor (2026)
Em 1943, o neurofisiologista Warren McCulloch e o lógico Walter Pitts propuseram uma simplificação radical do neurônio: uma unidade que recebe sinais, soma tudo e dispara se a soma ultrapassar um limiar. Com essas unidades, mostraram eles, era possível construir qualquer expressão da lógica proposicional (McCULLOCH; PITTS, 1943). O modelo era rígido: não tinha pesos ajustáveis, não aprendia nada. Seis anos depois, o psicólogo Donald Hebb propôs o ingrediente que faltava — a conexão entre dois neurônios que se ativam juntos repetidamente tende a se fortalecer (HEBB, 1949). Faltava só alguém juntar as duas metades.
Rosenblatt juntou. O perceptron é um neurônio de McCulloch e Pitts em que cada conexão tem um peso ajustável, e existe um procedimento automático para ajustá-lo (ROSENBLATT, 1958). Traduzindo para o português de todo dia, ele faz três coisas:
É isso. Um perceptron é uma soma ponderada seguida de um "sim ou não". A parte interessante não está na conta — está em de onde vêm os pesos. E é aqui que entra a palavra aprendizado: em vez de o programador escolher os pesos, a máquina os descobre a partir de exemplos com gabarito. Na definição clássica de Tom Mitchell, um programa aprende com a experiência se seu desempenho numa tarefa melhora à medida que a experiência se acumula (MITCHELL, 1997).
Matemática · nível 1 A conta exata que o neurônio faz
Para n entradas, a soma ponderada é:
z = w1·x1 + w2·x2 + … + wn·xn + b
Em notação vetorial, com w = (w1, …, wn) e x = (x1, …, xn):
z = w · x + b
A saída aplica a função degrau:
ŷ = 1, se z ≥ 0
ŷ = 0, se z < 0
O que isso quer dizer geometricamente. A equação w·x + b = 0 descreve uma reta (em duas dimensões), um plano (em três) ou um hiperplano (em muitas). O vetor w aponta perpendicularmente a essa fronteira, na direção do lado "sim"; o viés b desloca a fronteira em relação à origem (a distância entre as duas vale |b|/‖w‖). Treinar um perceptron é, literalmente, girar e deslocar uma reta até que ela separe os exemplos certos dos errados.
Exemplo numérico. Ao final do treinamento do "ou" no tutorial em Python (Código · nível 1), os pesos ficam em w1 = 0,5, w2 = 0,5 e b = −0,5. A fronteira é 0,5·x1 + 0,5·x2 − 0,5 = 0, ou seja, x1 + x2 = 1. Traduzindo: "responda sim quando a soma das entradas chegar a 1". É exatamente a definição do "ou" — e ninguém escreveu essa regra: ela foi encontrada.
Sinapse 02
Errar, medir, corrigir: a regra de aprendizado em cinco linhas
Cada exemplo errado empurra a reta um pouquinho. A soma dos empurrões é o aprendizado. Ilustração do autor (2026)
O procedimento de Rosenblatt é de uma simplicidade quase constrangedora. Para cada exemplo do conjunto de treinamento, faça o seguinte: mostre a entrada ao perceptron, compare a resposta dele com o gabarito e, se houver diferença, empurre cada peso na direção que teria produzido a resposta certa. O tamanho do empurrão é controlado por um número pequeno chamado taxa de aprendizado.
novo peso = peso antigo + taxa × erro × entrada
Note a elegância: se o erro for zero, nada muda — exemplos que a rede já acerta não mexem em nada. Se o perceptron respondeu 0 quando devia responder 1, o erro é +1 e todos os pesos ligados a entradas ativas aumentam, deixando o neurônio mais propenso a disparar naquele caso. Se respondeu 1 quando devia responder 0, o erro é −1 e os pesos diminuem. A entrada que não estava ativa não recebe correção nenhuma: quem não participou do erro não paga por ele. Uma passagem completa por todos os exemplos chama-se época.
Em 1960, Bernard Widrow e Marcian Hoff publicaram uma variação que trocava o degrau por uma saída contínua e minimizava o erro quadrático — a chamada regra delta, base do Adaline (WIDROW; HOFF, 1960). Guarde essa mudança de "acertou/errou" para "errou por quanto": ela é a ponte que nos levará, mais adiante, à retropropagação.
Matemática · nível 2 Por que o empurrão sempre vai na direção certa
A regra de atualização, escrita formalmente, é:
wi ← wi + η · (y − ŷ) · xi
b ← b + η · (y − ŷ)
em que y é o gabarito, ŷ é a resposta do perceptron e η (eta) é a taxa de aprendizado, um número positivo pequeno.
A garantia. Suponha que o perceptron errou respondendo 0 quando devia responder 1 — ou seja, z = w·x + b era negativo e precisava ser positivo. O erro vale +1, então os novos parâmetros são w' = w + ηx e b' = b + η. Recalculando a soma para o mesmo exemplo:
z' = (w + ηx)·x + b + η = z + η·(‖x‖² + 1)
Como η > 0 e ‖x‖² + 1 é sempre positivo, z' é necessariamente maior que z: a correção move a soma na direção certa, sempre. O mesmo vale, com sinal trocado, para o erro de −1.
O teorema da convergência. Se existir alguma reta capaz de separar perfeitamente as duas classes — isto é, se o problema for linearmente separável —, o procedimento encontra uma solução em um número finito de passos. A garantia vale qualquer que seja o ponto de partida e qualquer que seja a taxa de aprendizado (o número de passos, esse sim, depende dos dois e da folga entre as classes). A demonstração aparece em Principles of neurodynamics (ROSENBLATT, 1962) e, de forma independente, no limite clássico de Novikoff, do mesmo ano. É uma garantia forte e rara em aprendizado de máquina. O problema, como veremos, está na condição: se existir.
A pegadinha. Quando o problema não é linearmente separável, o algoritmo não avisa: ele simplesmente nunca para. Dentro de cada época os pesos se mexem — corrigem um exemplo e estragam outro —, mas as correções acabam se anulando e, no fim da volta, tudo volta ao ponto de partida. É um ciclo fechado, não uma aproximação lenta: você vai ver isso acontecer no "Experimente" do tutorial de código nível 1.
Sinapse 03
Laboratório: treine um perceptron aqui, agora
Quadro 1 — Tabelas-verdade das portas lógicas E, OU e OU EXCLUSIVO
| x1 | x2 | E (ambos) | OU (pelo menos um) | OU EXCLUSIVO (um só) |
|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 |
| 0 | 1 | 0 | 1 | 1 |
| 1 | 0 | 0 | 1 | 1 |
| 1 | 1 | 1 | 1 | 0 |
Fonte: elaborado pelo autor.Nota: o "ou" da lógica é inclusivo — basta que uma das condições seja verdadeira. O "ou exclusivo" corresponde ao "ou isto, ou aquilo, mas não os dois" da linguagem coloquial.
Chega de teoria. Abaixo está um perceptron de verdade, rodando no seu navegador, com os quatro exemplos das portas lógicas. Escolha a operação, clique em treinar e observe a reta se mexendo: cada época empurra os pesos, e a área colorida mostra a região em que o neurônio responde 1. Comece pelo OU. Depois, quando estiver convencido, clique em OU EXCLUSIVO e veja o que acontece.
Época0
Erros—
| x1 | x2 | alvo | saída |
|---|---|---|---|
| 0 | 0 | 0 | — |
| 1 | 0 | 1 | — |
| 0 | 1 | 1 | — |
| 1 | 1 | 1 | — |
w1 = 0,90 · w2 = −0,70 · viés = 0,20
Escolha uma porta lógica e clique em treinar.
Repare no que aconteceu. No OU e no E, a reta encontra rapidamente uma posição que separa os pontos claros dos escuros, os erros vão a zero e o treinamento para sozinho — exatamente como o teorema da convergência promete. No OU EXCLUSIVO, a reta gira, oscila, tenta de todos os ângulos e nunca chega lá. Não é falta de paciência nem de máquina: é impossível, e a impossibilidade tem demonstração.
Sinapse 04
O muro de 1969: quando uma reta não basta
À esquerda, uma reta resolve. À direita, as classes se cruzam na diagonal e nenhuma reta dá conta. Ilustração do autor (2026)
Desenhe os quatro casos do "ou exclusivo" num plano: (0,0) e (1,1) respondem 0; (0,1) e (1,0) respondem 1. As duas classes ficam em diagonais cruzadas, como as casas pretas e brancas de um tabuleiro. Não existe reta no plano que ponha as duas diagonais em lados opostos — é uma questão de geometria, não de esforço computacional.
Em 1969, Marvin Minsky e Seymour Papert publicaram Perceptrons, um livro que demonstrava com rigor matemático os limites do perceptron de camada única, usando justamente o problema da paridade, do qual o "ou exclusivo" é o caso mínimo (MINSKY; PAPERT, 1969). O efeito foi devastador: o financiamento à área secou e as redes neurais entraram numa hibernação de mais de uma década. Rosenblatt não viu o degelo — morreu em 1971, num acidente de barco, no dia em que completava 43 anos (PROFESSOR'S…, 2019).
O inverno das redes neurais: o muro existia mesmo — mas havia uma escada encostada nele. Ilustração do autor (2026)
Matemática · nível 3 A demonstração de que o "ou exclusivo" é impossível
Suponha, por absurdo, que existam pesos w1, w2 e viés b que resolvam o "ou exclusivo" com a regra "responda 1 quando w1x1 + w2x2 + b ≥ 0". Os quatro exemplos impõem quatro condições:
(0,0) → 0 ⟹ b < 0 (i)
(1,0) → 1 ⟹ w1 + b ≥ 0 (ii)
(0,1) → 1 ⟹ w2 + b ≥ 0 (iii)
(1,1) → 0 ⟹ w1 + w2 + b < 0 (iv)
Somando (ii) e (iii):
w1 + w2 + 2b ≥ 0 ⟹ w1 + w2 ≥ −2b
Mas (iv) diz que w1 + w2 < −b. Juntando as duas:
−2b ≤ w1 + w2 < −b ⟹ −2b < −b ⟹ b > 0
O que contradiz frontalmente a condição (i), que exigia b < 0. Logo, não existem pesos que resolvam o problema. O perceptron de camada única não fracassa no "ou exclusivo" por ser mal treinado: ele fracassa por ser uma reta diante de um problema que não é retilíneo.
Generalizando. O mesmo argumento vale para qualquer conjunto de pontos cujas classes não possam ser separadas por um hiperplano. E, no mundo real, quase nada é linearmente separável: reconhecer um rosto, um algarismo ou um sentimento em uma frase são todos problemas curvos.
Sinapse 05
A escada: uma camada escondida muda o problema de lugar
Com dois neurônios intermediários, o problema é reescrito em coordenadas novas — e volta a caber numa reta. Ilustração do autor (2026)
A saída do muro é quase óbvia depois que alguém a mostra: se uma reta não basta, use duas. Coloque entre a entrada e a saída uma camada escondida — neurônios que não falam diretamente com o mundo, apenas com os vizinhos. Cada um deles traça a sua própria reta e o neurônio de saída combina os resultados.
No caso do "ou exclusivo", bastam dois neurônios escondidos: um que detecta "pelo menos um está ligado" (o velho OU) e outro que detecta "os dois estão ligados" (o E). O neurônio de saída, então, só precisa responder uma pergunta simples — "o primeiro disse sim e o segundo disse não?" —, e essa pergunta já é separável por uma reta. O problema não ficou mais fácil: ele foi reescrito em coordenadas novas, inventadas pela própria rede. É essa solução que vamos montar peça por peça, com os pesos na mesa, na próxima seção.
Essa não é uma esperteza de um caso particular. Em 1989, George Cybenko provou que uma rede com uma única camada escondida, com neurônios suficientes e uma ativação em forma de "S", consegue aproximar, com a precisão que se queira, qualquer função contínua definida num pedaço limitado e fechado do espaço (CYBENKO, 1989); no mesmo ano, Kurt Hornik e colegas generalizaram o resultado para uma classe ampla de ativações (HORNIK; STINCHCOMBE; WHITE, 1989). É o chamado teorema da aproximação universal. Ele diz que a rede pode representar quase tudo — mas, atenção, não diz como encontrar os pesos certos. Essa é a próxima pergunta, e a mais difícil de todas.
Sinapse 06
Três perceptrons, um circuito: o "ou exclusivo" resolvido na mão
Antes de treinar qualquer coisa, vale montar a solução com a chave de fenda — porque, quando os pesos são escolhidos por nós, dá para ver exatamente por que funciona. Precisamos de três perceptrons, cada um deles idêntico ao da Sinapse 01: soma ponderada, viés e função degrau. Nenhuma mágica nova; só fiação.
Os três perceptrons e os pesos exatos que resolvem o "ou exclusivo". Ilustração do autor (2026)
O peso negativo é a peça-chave. Quando as duas entradas estão ligadas, o P1 dispara (contribuindo +1) mas o P2 também (contribuindo −2), e o −2 anula com folga a contribuição positiva. Traduzindo o circuito para o português: responda sim quando pelo menos uma entrada estiver ligada, exceto se as duas estiverem. Que é, palavra por palavra, a definição do "ou exclusivo".
Quadro 2 — Cálculo do circuito de três perceptrons para cada entrada do "ou exclusivo"
| x1 | x2 | P1: x1+x2−0,5 | h1 | P2: x1+x2−1,5 | h2 | P3: h1−2h2−0,5 | y | Alvo |
|---|---|---|---|---|---|---|---|---|
| 0 | 0 | −0,5 < 0 | 0 | −1,5 < 0 | 0 | −0,5 < 0 | 0 | 0 ✓ |
| 0 | 1 | +0,5 ≥ 0 | 1 | −0,5 < 0 | 0 | +0,5 ≥ 0 | 1 | 1 ✓ |
| 1 | 0 | +0,5 ≥ 0 | 1 | −0,5 < 0 | 0 | +0,5 ≥ 0 | 1 | 1 ✓ |
| 1 | 1 | +1,5 ≥ 0 | 1 | +0,5 ≥ 0 | 1 | −1,5 < 0 | 0 | 0 ✓ |
Fonte: elaborado pelo autor.Nota: cada perceptron aplica a função degrau — dispara (1) quando a soma é maior ou igual a zero e permanece em repouso (0) caso contrário. Os quatro casos foram conferidos por execução do código apresentado adiante.
O gráfico que explica por que agora dá certo
Aqui está a pergunta que interessa: se nenhuma reta resolve o "ou exclusivo", e cada um desses três perceptrons continua sendo apenas uma reta, como o conjunto consegue? A resposta não está em nenhum dos três — está no mapa em que o terceiro trabalha. O P3 não enxerga x1 e x2; ele enxerga h1 e h2. E, nesse novo par de coordenadas, os pontos ocupam posições completamente diferentes.
O truque inteiro em uma imagem: dois casos que estavam em cantos opostos passam a ocupar a mesma posição, e o problema vira separável. Esquema do autor (2026)
Olhe o painel da direita com calma. Os quatro casos entraram, mas só três posições distintas saíram: (0,1) e (1,0) produzem exatamente o mesmo par (h1, h2) = (1, 0), porque em ambos há uma entrada ligada (P1 dispara) e não há duas (P2 fica quieto). Do ponto de vista do P3, esses dois casos viraram o mesmo caso — e nada mais natural, já que ambos devem receber a mesma resposta.
Foi exatamente a diagonal cruzada que sumiu. No plano original, os dois pontos de alvo 1 estavam em cantos opostos, com os dois pontos de alvo 0 na outra diagonal: qualquer reta que abraçasse um ponto verde deixava o outro de fora. No plano da camada escondida, o par de alvo 1 se fundiu numa posição só, e os dois pontos de alvo 0 ficaram nas extremidades — uma configuração que uma reta separa com sobra. A camada escondida não resolveu o problema: ela mudou o mapa até que o problema coubesse na única ferramenta que o perceptron tem, que é a reta.
Vale registrar o que isso custa e o que isso rende. Custa uma camada a mais — e, com ela, o problema de descobrir os pesos dessa camada, que a regra de Rosenblatt não sabe resolver (é o que veremos a seguir). Rende a capacidade de dobrar o espaço quantas vezes forem necessárias: com mais neurônios escondidos, a rede recorta o plano em mais regiões; com mais camadas, recorta o espaço já recortado. O teorema da aproximação universal é a versão formal dessa intuição (CYBENKO, 1989).
Sinapse 07
Retropropagação: o erro que anda para trás
Duas viagens por época: a informação vai, o erro volta. Ilustração do autor (2026)
Com uma camada escondida, a regra de Rosenblatt trava. Ela sabe corrigir um neurônio quando conhece o gabarito da resposta dele — mas qual é o gabarito de um neurônio do meio? Ninguém sabe qual deveria ser a saída "certa" de h1. Esse é o problema da atribuição de crédito: quando a rede erra, de quem é a culpa?
A resposta veio em duas etapas. Paul Werbos descreveu o método na sua tese de doutorado em Harvard, em 1974, e o mundo praticamente não notou (WERBOS, 1974). Doze anos depois, David Rumelhart, Geoffrey Hinton e Ronald Williams publicaram na Nature um artigo de quatro páginas que fez a área inteira acordar (RUMELHART; HINTON; WILLIAMS, 1986). A ideia se chama retropropagação do erro (backpropagation) e funciona em duas viagens:
A ferramenta matemática que faz essa repartição de culpa é a regra da cadeia do cálculo — a mesma que você viu em Cálculo I para derivar funções compostas. E o objetivo é sempre o mesmo: encontrar, para cada peso, a direção que mais reduz o erro, e dar um passinho nessa direção. É a descida do gradiente, que vale a pena imaginar assim: você está numa encosta, no meio de uma neblina, e só consegue sentir a inclinação do chão sob os pés; a estratégia é dar um passo para o lado que desce mais e repetir milhões de vezes.
Duas consequências práticas dessa metáfora explicam quase todo o folclore do treinamento de redes. Primeira: se os passos forem grandes demais, você atravessa o vale e sobe do outro lado — por isso taxas de aprendizado altas fazem o erro explodir. Segunda: a neblina não deixa ver o mapa inteiro, então é perfeitamente possível parar numa depressão rasa achando que é o fundo do vale — o famoso mínimo local. Você vai encontrar um desses ao vivo no tutorial de nível 2, e a saída é banal: reinicie com outros pesos e tente de novo. Mas metáfora boa é metáfora que se aposenta: na próxima seção, a encosta deixa de ser figura de linguagem — você vai construí-la a partir de um modelo de verdade e pilotar a descida com as próprias mãos.
Matemática · nível 4 A retropropagação em quatro equações
Notação. Para a camada l, seja W(l) a matriz de pesos, b(l) o vetor de vieses, a(l) o vetor de ativações e σ a função de ativação. O passo para frente é:
z(l) = W(l) a(l−1) + b(l)
a(l) = σ(z(l))
Com a perda quadrática E = ½‖a(L) − y‖², define-se o erro local da camada como δ(l) = ∂E/∂z(l). As quatro equações são:
(1) δ(L) = (a(L) − y) ⊙ σ′(z(L))
(2) δ(l) = (W(l+1)⊤ δ(l+1)) ⊙ σ′(z(l))
(3) ∂E/∂W(l) = δ(l) (a(l−1))⊤
(4) ∂E/∂b(l) = δ(l)
O símbolo ⊙ indica multiplicação elemento a elemento. A equação (2) é o coração do método: o erro de uma camada é o erro da camada seguinte, empurrado de volta pela transposta da matriz de pesos — daí o nome retropropagação. A atualização final é a descida do gradiente:
W(l) ← W(l) − η · ∂E/∂W(l)
Derivadas úteis. Para a sigmoide σ(z) = 1/(1 + e−z), vale a identidade conveniente σ′(z) = σ(z)·(1 − σ(z)) — por isso o código guarda a ativação e reaproveita. Para a ReLU, σ(z) = max(0, z), a derivada é 1 quando z > 0 e 0 caso contrário (em z = 0 ela não existe, e adota-se 0 por convenção — é o que o código faz com (Z1 > 0)). O que viabilizou as redes profundas não foi tanto o barateamento da conta, e sim o fato de essa derivada não saturar: na sigmoide, ela vale no máximo 0,25 e encolhe a cada camada, até o gradiente sumir (GOODFELLOW; BENGIO; COURVILLE, 2016).
O atalho da classificação. Quando a última camada usa softmax e a perda é a entropia cruzada, toda a expressão (1) colapsa em δ(L) = a(L) − y. É por isso que, no tutorial de nível 3, a retropropagação começa com uma subtração e nada mais.
Sinapse 08
De onde vem a montanha: a descida do gradiente vista de perto
A metáfora da encosta na neblina esconde uma pergunta que costuma travar todo mundo: de onde veio essa montanha? Ninguém a desenhou. Ela não faz parte do problema — não existe montanha nenhuma dentro das imagens de algarismos. A paisagem nasce do casamento entre o modelo que você escolheu e os dados que você tem: ela é o gráfico do erro em função dos pesos. Mude o modelo, e a montanha muda de forma; mude os dados, e ela muda de novo. Vamos construir uma, do zero, pequena o bastante para caber num gráfico.
Tome o menor problema honesto possível: três medições, (0; 0,4), (1; 1,0) e (2; 2,2), e a tarefa de passar uma reta por elas. O caminho do modelo até a montanha tem sempre os mesmos quatro passos — e vale a pena vê-los de uma vez, porque são exatamente os mesmos numa rede de bilhões de parâmetros:
Agora pilote você. O painel da esquerda mostra o problema (os três pontos e a reta atual); o da direita mostra a montanha (o erro em função de w) com a bolinha na posição atual. São duas fotografias do mesmo instante: quando a bolinha desce um degrau no vale, a reta se ajusta aos pontos — obrigatoriamente, porque uma coisa é a outra. Use "+1 passo" para ver cada movimento em câmera lenta ou "▶ descer" para a reprodução automática (o botão 4× acelera quando a novidade passar).
O problema: reta ŷ = w·x nos 3 pontos
A montanha: erro E em função de w
—
Escolha o passo e clique em descer — ou avance um passo de cada vez.
Três experiências valem a pena antes de seguir. Primeira: com o passo 0,05, a bolinha rasteja — chega, mas a paciência custa. Segunda: com 0,65, ela atravessa o vale, sobe do outro lado mais alto do que estava e vai embora do gráfico: é o erro explodindo, o mesmo desastre que uma taxa de aprendizado grande demais causa numa rede de verdade. Terceira: mude a paisagem para dois vales — essa curva não sai do nosso modelo de reta (que só produz vales únicos, de parábola); é o tipo de relevo que uma rede com camadas escondidas produz, como a do XOR. Reinicie algumas vezes: dependendo do ponto de partida, a bolinha desce para o vale raso da direita e para ali, satisfeita, sem jamais saber que havia um vale mais fundo à esquerda. Você acabou de ver um mínimo local — o mesmo que o tutorial de código nível 2 encontra com a semente 42.
Duas alavancas: o mapa vira mapa de calor
Agora solte o segundo botão do modelo: ŷ = w·x + b. Com dois parâmetros, o erro E(w, b) é uma função de duas variáveis — uma superfície, uma tigela de verdade em três dimensões. Para caber na tela, olhamos a tigela de cima: no mapa abaixo, cada pixel é uma combinação (w, b), e a cor diz a altura do erro naquele ponto — escuro é alto, claro é fundo de vale. Clique em qualquer lugar do mapa para largar a bolinha ali, e mande descer.
O problema: reta ŷ = w·x + b
A montanha vista de cima: E(w, b)
escuro = erro alto · claro = fundo · × = mínimo · clique para largar a bolinha
—
Clique no mapa para escolher o ponto de partida — ou use reiniciar para sortear um.
Observe a trajetória com atenção: ela não vai reta ao fundo. O vale de E(w, b) é alongado — íngreme numa direção, quase plano na outra —, e por isso a bolinha quica em zigue-zague entre as paredes antes de rastejar pelo fundo. Esse desenho, que parece defeito, é um retrato honesto do treinamento real: boa parte da engenharia moderna de otimização (momento, Adam e afins) existe para amaciar exatamente esse zigue-zague (GOODFELLOW; BENGIO; COURVILLE, 2016).
E quando os botões são bilhões?
A escada de dimensões: o desenho acaba em dois parâmetros; a regra, nunca. Ilustração do autor (2026)
Aqui termina o que os olhos alcançam — e é importante dizer isso com todas as letras. Com um parâmetro, o erro é uma curva; com dois, uma superfície que ainda cabe num mapa de calor; com três, precisaríamos de um gráfico em quatro dimensões, e nenhuma tela o desenha. A rede de dígitos do tutorial nível 3 tem 2 410 parâmetros: sua "montanha" mora num espaço de 2 410 dimensões. O GPT-3 tem 175 bilhões (BROWN et al., 2020). Ninguém nunca viu essas paisagens, nem verá.
Mas — e este é o pulo — a matemática não precisa enxergar: em qualquer número de dimensões, o gradiente continua apontando a subida mais íngreme, e o sinal de menos continua descendo. A conta w ← w − η·∇E que você acabou de executar com uma bolinha num gráfico é, símbolo por símbolo, a mesma executada bilhões de vezes no treinamento de um modelo de linguagem. A geometria vira álgebra e segue funcionando onde a intuição visual já desistiu. E a retropropagação, da seção anterior, ganha aqui seu lugar exato na história: ela não é a descida — ela é o jeito barato de calcular, de uma vez, os bilhões de derivadas parciais que a descida consome a cada passo.
Sinapse 09
Da grade de pixels ao algarismo
Para a rede, uma imagem não é uma imagem: é uma lista de 784 números entre 0 e 1. Ilustração do autor (2026)
Agora o exemplo que interessa de verdade. A máquina de Rosenblatt já enxergava: o Mark I Perceptron, projetado no Cornell Aeronautical Laboratory no fim dos anos 1950 com dinheiro da Marinha e da Força Aérea, tinha uma "retina" de fotocélulas ligada por fios a unidades de associação cujos pesos eram literalmente potenciômetros girados por pequenos motores elétricos. A máquina está hoje no acervo do Smithsonian (NATIONAL MUSEUM OF AMERICAN HISTORY, [s. d.]). Os "pixels" daquela retina eram fotocélulas de verdade, dispostas numa grade de 20 por 20 — quatrocentos pontos de luz.
A ideia continua idêntica sessenta e oito anos depois. Pegue uma imagem de 28 × 28 pixels em tons de cinza — o formato do conjunto MNIST, a base de algarismos manuscritos que virou o "arroz com feijão" da área, com 60 mil imagens de treino e 10 mil de teste (LeCUN et al., 1998). Empilhe as linhas uma após a outra e você terá uma lista de 784 números, cada um entre 0 (preto) e 1 (branco). Essa lista é a entrada da rede.
Na saída, dez neurônios — um para cada algarismo. Cada um produz um escore para a sua pergunta: "quanto isso se parece com um 0?", "quanto se parece com um 1?", e assim por diante. A resposta final é o maior escore. Nas redes modernas, esses dez números passam ainda por uma função chamada softmax, que os transforma em dez probabilidades que somam 1 — ou seja, os escores não são independentes: eles competem entre si. Durante o treinamento, o gabarito é escrito no mesmo formato: o algarismo 3 vira a lista (0, 0, 0, 1, 0, 0, 0, 0, 0, 0), técnica que se chama codificação um-de-n — one-hot, em inglês.
E o que, afinal, a rede aprende?
Os pesos de cada saída, desenhados de volta na grade de pixels: moldes fantasmagóricos aprendidos, não programados. Ilustração do autor (2026)
Aqui está a parte bonita — e ela aparece na sua forma mais nítida no caso mais simples de todos, o classificador de uma camada só, com os dez neurônios ligados diretamente aos pixels. Se você pegar os 784 pesos do neurônio responsável pelo algarismo 3 e os desenhar de volta numa grade 28 × 28, verá um fantasma de um 3 — regiões de peso alto onde o traço costuma passar e regiões de peso negativo onde ele nunca passa. O neurônio aprendeu um molde: uma máscara que soma pontos quando a tinta cai onde deveria e desconta pontos quando cai onde não deveria. Ninguém programou como é um 3; a rede destilou isso de milhares de exemplos rabiscados por pessoas diferentes.
Assim que entra uma camada escondida, esse retrato deixa de ser legível: o neurônio de saída do "3" não olha mais para os 784 pixels, e sim para as 32 ou 128 respostas da camada anterior — não há como desenhá-lo numa grade 28 × 28. Em compensação, o mesmo raciocínio passa a se repetir em andares: a primeira camada aprende pedaços de traço e cantos, a segunda combina esses pedaços em laços e hastes, a terceira em algarismos inteiros. É essa hierarquia de representações aprendidas que define o deep learning (LeCUN; BENGIO; HINTON, 2015).
Quanto isso funciona, em números
Em 1989, Yann LeCun e colegas treinaram uma rede com retropropagação para ler códigos postais manuscritos de envelopes reais dos Correios norte-americanos — a primeira aplicação industrial de peso do método (LeCUN et al., 1989). Uma década depois, o artigo que apresentou a LeNet-5 comparou dezenas de abordagens no mesmo conjunto de teste, e os resultados contam a história inteira da área numa coluna só.
Tabela 1 — Taxa de erro no conjunto de teste do MNIST, por método — 1998
| Método | Tipo | Erro (%) |
|---|---|---|
| Classificador linear | 1 camada, sem camada escondida | 12,0 |
| Vizinhos mais próximos (distância euclidiana) | Sem treinamento de pesos | 5,0 |
| Rede de 2 camadas, 300 unidades escondidas | Retropropagação | 4,7 |
| Rede de 3 camadas, 300+100 unidades escondidas | Retropropagação | 3,05 |
| LeNet-1 | Rede convolucional | 1,7 |
| LeNet-5 | Rede convolucional | 0,95 |
| LeNet-4 com reforço (boosting) | Conjunto de redes convolucionais | 0,7 |
Fonte: elaborado pelo autor com base em LeCun et al. (1998).Nota: conjunto de teste com 10 mil imagens de 28 × 28 pixels; o classificador linear da primeira linha foi ajustado por mínimos quadrados, e não pela regra do perceptron, mas seus 12,0% dão a ordem de grandeza do que uma única camada alcança nesta tarefa.
O tamanho do salto, em barras
Fonte: elaborado pelo autor com base em LeCun et al. (1998).Nota: comprimento das barras proporcional ao maior valor da série (12,0%); rótulos numéricos trazem a taxa de erro real.
Leia a tabela de trás para frente e você terá o roteiro deste post: sair de 12% de erro (uma reta só) para menos de 1% (camadas escondidas mais uma arquitetura que respeita a geometria da imagem) foi obra de trinta anos de trabalho. Em 2012, a mesma receita, com muito mais dados e placas de vídeo, venceu o desafio ImageNet e inaugurou a era atual da IA (KRIZHEVSKY; SUTSKEVER; HINTON, 2012). Em 2019, a ACM concedeu o Prêmio Turing de 2018 a Yoshua Bengio, Geoffrey Hinton e Yann LeCun exatamente por isso (ACM, 2019).
Sinapse 10
Decorar não é aprender: treino, teste e a prova surpresa
A partir de certo ponto, continuar treinando piora o desempenho no que importa. Ilustração do autor (2026)
Qualquer professor reconhece o fenômeno: o aluno que decorou as questões da lista tira dez na lista e cinco na prova. Redes neurais fazem exatamente isso, e o nome técnico é sobreajuste (overfitting). Uma rede com parâmetros suficientes consegue memorizar o conjunto de treino inteiro, incluindo os rabiscos tortos e os erros de rotulagem — e, ao memorizar, deixa de generalizar.
Por isso o protocolo é inegociável: separe os dados em treino (o material de estudo) e teste (a prova surpresa, que o modelo nunca viu). O desempenho que vale é o do teste. No tutorial de nível 3, você verá a rede chegar a 100% de acerto no treino e estacionar em torno de 98% no teste — a diferença entre os dois números é, na prática, a decoreba medida em porcentagem (GOODFELLOW; BENGIO; COURVILLE, 2016).
E há um limite mais fundo, que nenhuma arquitetura resolve: a rede só pode aprender aquilo que está nos exemplos, incluindo os vícios de quem os produziu. Se o gabarito for enviesado, o modelo aprende o viés com a mesma diligência com que aprenderia o acerto — assunto do próximo post desta série. (Cuidado com a palavra, que aparece com dois sentidos neste texto: o "viés" do neurônio, lá da Sinapse 01, é um número que desloca a fronteira; o viés dos dados é outra coisa, e bem mais cara de consertar.) (RUSSELL; NORVIG, 2022).
Sinapse 11
Marcos: de 1943 a 2019 em uma página
Quadro 3 — Marcos da história das redes neurais artificiais — 1943-2019
| Ano | Autoria | Contribuição |
|---|---|---|
| 1943 | McCulloch e Pitts | Neurônio lógico de limiar; qualquer função proposicional pode ser montada com essas unidades |
| 1949 | Hebb | Aprendizagem por reforço das conexões coativadas; base biológica do peso ajustável |
| 1958 | Rosenblatt | Perceptron e sua regra de correção de erro; teorema da convergência |
| 1960 | Widrow e Hoff | Adaline e regra delta; troca do "acertou/errou" pelo erro contínuo |
| 1969 | Minsky e Papert | Demonstração dos limites do perceptron de camada única; começo do inverno |
| 1974 | Werbos | Retropropagação descrita em tese de doutorado, sem repercussão imediata |
| 1986 | Rumelhart, Hinton e Williams | Retropropagação publicada na Nature; redes com camadas escondidas viram prática |
| 1989 | Cybenko; Hornik, Stinchcombe e White | Teorema da aproximação universal |
| 1989 | LeCun e colegas | Leitura automática de códigos postais manuscritos; primeira aplicação industrial |
| 1998 | LeCun, Bottou, Bengio e Haffner | LeNet-5 e a consolidação do MNIST como referência |
| 2012 | Krizhevsky, Sutskever e Hinton | AlexNet vence o ImageNet; começa a era do deep learning |
| 2019 | ACM | Prêmio Turing de 2018 a Bengio, Hinton e LeCun |
Fonte: elaborado pelo autor com base em McCulloch e Pitts (1943), Hebb (1949), Rosenblatt (1958), Widrow e Hoff (1960), Minsky e Papert (1969), Werbos (1974), Rumelhart, Hinton e Williams (1986), Cybenko (1989), Hornik, Stinchcombe e White (1989), LeCun et al. (1989; 1998), Krizhevsky, Sutskever e Hinton (2012) e ACM (2019).Nota: o ano indicado é o da publicação de referência; várias ideias circularam antes disso em formas parciais ou independentes.
Sinapse 12
Mão na massa: três tutoriais prontos para o Google Colab
As três seções abaixo formam uma escada. Cada bloco de código é um programa completo: abra o Google Colab, crie um caderno novo, cole o código numa célula e aperte executar. Nada precisa ser instalado — as bibliotecas usadas já vêm no ambiente. Todos os programas foram executados e as saídas mostradas são reais e completas (a única exceção é o bônus em Keras, que depende de baixar o MNIST).
Código · nível 1 Um perceptron do zero, em Python puro, aprendendo o "ou"
Sem bibliotecas, sem mágica: trinta linhas com o mesmo algoritmo do laboratório interativo da Sinapse 03 — aqui com os pesos começando em zero, taxa 0,5 e os exemplos em outra ordem, então os números do caminho não batem com os de lá; o destino, sim.
# ------------------------------------------------------------
# Perceptron do zero: aprendendo a porta logica OU
# ------------------------------------------------------------
dados = [((0, 0), 0), ((0, 1), 1), ((1, 0), 1), ((1, 1), 1)]
pesos = [0.0, 0.0] # w1, w2
vies = 0.0 # b (bias)
taxa = 0.5 # eta: tamanho do passo de correcao
def saida(x):
soma = pesos[0] * x[0] + pesos[1] * x[1] + vies
return 1 if soma >= 0 else 0 # funcao degrau
for epoca in range(1, 11):
erros = 0
for x, alvo in dados:
y = saida(x)
erro = alvo - y # -1, 0 ou +1
if erro != 0:
erros += 1
pesos[0] += taxa * erro * x[0]
pesos[1] += taxa * erro * x[1]
vies += taxa * erro
print("epoca %2d | erros: %d | w1=%.2f w2=%.2f b=%.2f"
% (epoca, erros, pesos[0], pesos[1], vies))
if erros == 0:
print("Convergiu! O perceptron aprendeu o OU.")
break
print("\nTeste final:")
for x, alvo in dados:
print(" %s -> %d (esperado %d)" % (str(x), saida(x), alvo))Saída obtida
epoca 1 | erros: 2 | w1=0.00 w2=0.50 b=0.00
epoca 2 | erros: 2 | w1=0.50 w2=0.50 b=0.00
epoca 3 | erros: 1 | w1=0.50 w2=0.50 b=-0.50
epoca 4 | erros: 0 | w1=0.50 w2=0.50 b=-0.50
Convergiu! O perceptron aprendeu o OU.
Teste final:
(0, 0) -> 0 (esperado 0)
(0, 1) -> 1 (esperado 1)
(1, 0) -> 1 (esperado 1)
(1, 1) -> 1 (esperado 1)Experimente. Na lista dados, troque o último par — ((1, 1), 1) — por ((1, 1), 0): você acabou de transformar o "ou" em "ou exclusivo". Aumente o laço para range(1, 1001) e troque a linha do print por if epoca % 100 == 0 or erros == 0: antes dela (sem esse filtro, o Colab cospe mil linhas iguais e parece travado). O que você vai ver:
epoca 100 | erros: 4 | w1=-0.50 w2=0.00 b=0.00
epoca 200 | erros: 4 | w1=-0.50 w2=0.00 b=0.00
... ate a epoca 1000, sempre igual ...Repare no detalhe: os pesos não ficam balançando, eles congelam. As quatro correções de uma época se anulam entre si e tudo volta ao ponto de partida — um ciclo fechado. O perceptron não está "quase lá": está preso, e ficaria preso por um milhão de épocas.
Código · nível 2 Uma rede 2-2-1 resolvendo o "ou exclusivo", com retropropagação escrita à mão
Antes de treinar, monte na mão. Este primeiro programa não aprende nada: ele apenas executa os três perceptrons da Sinapse 06 com os pesos que escolhemos. Serve para você ver o circuito funcionando e conferir, número a número, o Quadro 2.
# ------------------------------------------------------------
# Os tres perceptrons do OU EXCLUSIVO, com pesos escolhidos a mao
# ------------------------------------------------------------
def degrau(z):
return 1 if z >= 0 else 0
def perceptron(x1, x2, w1, w2, b):
return degrau(w1 * x1 + w2 * x2 + b)
alvos = {(0, 0): 0, (0, 1): 1, (1, 0): 1, (1, 1): 0}
print("x1 x2 | h1(OU) h2(E) | y alvo")
for x1 in (0, 1):
for x2 in (0, 1):
h1 = perceptron(x1, x2, 1, 1, -0.5) # P1: pelo menos um
h2 = perceptron(x1, x2, 1, 1, -1.5) # P2: os dois
y = perceptron(h1, h2, 1, -2, -0.5) # P3: h1 e nao h2
ok = "ok" if y == alvos[(x1, x2)] else "ERRO"
print(" %d %d | %d %d | %d %d %s"
% (x1, x2, h1, h2, y, alvos[(x1, x2)], ok))Saída obtida
x1 x2 | h1(OU) h2(E) | y alvo
0 0 | 0 0 | 0 0 ok
0 1 | 1 0 | 1 1 ok
1 0 | 1 0 | 1 1 ok
1 1 | 1 1 | 0 0 okOlhe a coluna do meio: as linhas de (0, 1) e (1, 0) produzem o mesmo par h1=1, h2=0. É a fusão dos dois pontos que o gráfico da Sinapse 06 mostra — visível aqui em texto puro.
Experimente. Troque o peso -2 do P3 por -1 e rode de novo: a linha (1, 1) passa a responder 1, e o circuito vira um OU comum. Aquele -2 é literalmente a diferença entre o "ou" e o "ou exclusivo".
Agora deixe a rede descobrir sozinha. O programa a seguir não recebe peso nenhum de presente: parte de números aleatórios e chega a uma solução pela retropropagação. Nenhuma biblioteca de aprendizado profundo calcula os gradientes por você aqui — o passo para trás está escrito à mão.
import numpy as np
np.random.seed(1) # troque a semente e veja: as vezes a rede cai num minimo local
# 1) Dados do OU EXCLUSIVO -----------------------------------
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]], dtype=float)
Y = np.array([[0], [1], [1], [0]], dtype=float)
# 2) Arquitetura 2 -> 2 -> 1 ---------------------------------
# O nivel 1 fazia, para UM exemplo por vez: soma = w1*x1 + w2*x2 + b
# Aqui fazemos os 4 exemplos e os 2 neuronios de uma vez so:
# X tem forma 4x2 (4 exemplos, 2 entradas)
# W1 tem forma 2x2 (2 entradas -> 2 neuronios escondidos)
# X @ W1 tem forma 4x2: linha i, coluna j = soma do exemplo i no neuronio j
# + b1 (1x2) soma o mesmo vies nas 4 linhas -- isso se chama broadcasting
W1 = np.random.randn(2, 2) * 0.8 # pesos entrada -> escondida
b1 = np.zeros((1, 2))
W2 = np.random.randn(2, 1) * 0.8 # pesos escondida -> saida
b2 = np.zeros((1, 1))
# Trocamos o degrau pela sigmoide porque o degrau e plano em toda parte:
# sua derivada e zero, e sem derivada nao ha para onde descer.
def sigmoide(z):
return 1.0 / (1.0 + np.exp(-z))
taxa = 1.0 # alta de proposito: sao so 4 exemplos, e a sigmoide ja amortece o passo
for epoca in range(1, 20001):
# ---- passo para frente -------------------------------
Z1 = X @ W1 + b1
A1 = sigmoide(Z1)
Z2 = A1 @ W2 + b2
A2 = sigmoide(Z2) # previsao da rede
# ---- erro --------------------------------------------
perda = np.mean((A2 - Y) ** 2)
# ---- passo para tras (retropropagacao) ---------------
dA2 = 2 * (A2 - Y) / len(X)
dZ2 = dA2 * A2 * (1 - A2) # derivada da sigmoide
dW2 = A1.T @ dZ2
db2 = dZ2.sum(axis=0, keepdims=True)
dA1 = dZ2 @ W2.T
dZ1 = dA1 * A1 * (1 - A1)
dW1 = X.T @ dZ1
db1 = dZ1.sum(axis=0, keepdims=True)
# ---- descida do gradiente ----------------------------
W2 -= taxa * dW2; b2 -= taxa * db2
W1 -= taxa * dW1; b1 -= taxa * db1
if epoca % 4000 == 0:
print("epoca %5d | perda = %.5f" % (epoca, perda))
# recalcula tudo com os pesos finais, ja atualizados
A1 = sigmoide(X @ W1 + b1)
A2 = sigmoide(A1 @ W2 + b2)
print("\nPrevisoes finais:")
for x, p, alvo in zip(X, A2.ravel(), Y.ravel()):
print(" %s -> %.3f (arredondado: %d | esperado: %d)"
% (x, p, round(p), alvo))
print("\nO que cada neuronio escondido aprendeu (h1, h2):")
for x, h in zip(X, np.round(A1, 2)):
print(" %s -> %s" % (x, h))Saída obtida
epoca 4000 | perda = 0.00095
epoca 8000 | perda = 0.00039
epoca 12000 | perda = 0.00024
epoca 16000 | perda = 0.00017
epoca 20000 | perda = 0.00014
Previsoes finais:
[0. 0.] -> 0.011 (arredondado: 0 | esperado: 0)
[0. 1.] -> 0.989 (arredondado: 1 | esperado: 1)
[1. 0.] -> 0.989 (arredondado: 1 | esperado: 1)
[1. 1.] -> 0.014 (arredondado: 0 | esperado: 0)
O que cada neuronio escondido aprendeu (h1, h2):
[0. 0.] -> [1. 0.94]
[0. 1.] -> [0.92 0.02]
[1. 0.] -> [0.92 0.02]
[1. 1.] -> [0.07 0. ]Leia as quatro últimas linhas devagar: é a prova de tudo o que este post afirma. As entradas (0,1) e (1,0) produzem o mesmo par escondido, (0,92 · 0,02). A rede fundiu os dois casos — exatamente o colapso de pontos do esquema da Sinapse 06 —, e a partir daí sobraram três posições que uma reta separa. Ninguém programou isso: caiu do gradiente.
E repare que ela não reinventou o nosso circuito: o h1 aprendido vale 1,00 em (0,0) e 0,07 em (1,1), ou seja, é quase o oposto do OU que escolhemos à mão. A rede achou outro par de retas que serve igualmente bem. A solução da Sinapse 06 é uma entre infinitas — o que importa é que todas elas separam os dois pontos de alvo 0 daquele ponto fundido de alvo 1.
Experimente. Troque np.random.seed(1) por np.random.seed(42) e rode de novo: a perda estaciona perto de 0,125 e duas das quatro respostas ficam em cima do muro, em 0,5. Não há bug nenhum — é um mínimo local, exatamente aquela depressão rasa no meio da neblina. Testei as trinta primeiras sementes: quatro delas caem nessa armadilha, ou seja, mais ou menos uma em cada sete. Nas outras, o vale certo aparece. Esse é, em miniatura, um dos dramas cotidianos de quem treina redes: às vezes a saída é só reiniciar.
Código · nível 3 Reconhecendo algarismos manuscritos numa matriz de pixels
Uma rede 64 → 32 → 10, escrita do zero, construída sobre 1 797 imagens de algarismos manuscritos em grades de 8 × 8 — das quais 1 437 vão para o treino e 360 ficam guardadas para o teste (é o conjunto digits, que já vem com o scikit-learn e roda em segundos). Aqui aparecem, juntos, todos os ingredientes do post: matriz de pixels achatada em vetor, camada escondida, ReLU, softmax, retropropagação, minilotes e — o mais importante — a separação entre treino e teste.
import numpy as np
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
np.random.seed(7)
# 1) Dados: 1797 imagens 8x8 de digitos manuscritos ----------
digitos = load_digits()
X = digitos.data / 16.0 # 64 pixels achatados numa lista, escala 0-1
y = digitos.target # rotulo de 0 a 9
Y = np.eye(10)[y] # um-de-n: 3 -> [0,0,0,1,0,0,0,0,0,0]
# stratify=y: mesma proporcao de cada algarismo no treino e no teste
X_tr, X_te, Y_tr, Y_te, y_tr, y_te = train_test_split(
X, Y, y, test_size=0.2, random_state=7, stratify=y)
print("treino:", X_tr.shape, "| teste:", X_te.shape)
# 2) Rede 64 -> 32 -> 10 -------------------------------------
def inicia(n_ent, n_sai):
# escala de He: mantem o sinal estavel ao atravessar a ReLU
return np.random.randn(n_ent, n_sai) * np.sqrt(2.0 / n_ent)
W1, b1 = inicia(64, 32), np.zeros((1, 32))
W2, b2 = inicia(32, 10), np.zeros((1, 10))
def relu(z):
return np.maximum(0, z)
def softmax(z): # dez escores -> dez probabilidades que somam 1
z = z - z.max(axis=1, keepdims=True)
e = np.exp(z)
return e / e.sum(axis=1, keepdims=True)
def prever(entrada): # o passo para frente inteiro, em uma linha
return softmax(relu(entrada @ W1 + b1) @ W2 + b2)
taxa, lote, epocas = 0.5, 32, 60
for epoca in range(1, epocas + 1):
ordem = np.random.permutation(len(X_tr))
# minilote: em vez de olhar as 1437 imagens de uma vez,
# corrigimos os pesos a cada 32 exemplos
for i in range(0, len(ordem), lote):
idx = ordem[i:i + lote]
xb, yb = X_tr[idx], Y_tr[idx]
# ---- para frente ---------------------------------
Z1 = xb @ W1 + b1
A1 = relu(Z1)
A2 = softmax(A1 @ W2 + b2)
# ---- para tras (retropropagacao) -----------------
dZ2 = (A2 - yb) / len(xb) # gradiente da entropia cruzada
dW2 = A1.T @ dZ2
db2 = dZ2.sum(axis=0, keepdims=True)
dA1 = dZ2 @ W2.T
dZ1 = dA1 * (Z1 > 0) # derivada da ReLU
dW1 = xb.T @ dZ1
db1 = dZ1.sum(axis=0, keepdims=True)
W2 -= taxa * dW2; b2 -= taxa * db2
W1 -= taxa * dW1; b1 -= taxa * db1
if epoca % 15 == 0:
P = prever(X_tr)
perda = -np.mean(np.log(P[np.arange(len(y_tr)), y_tr] + 1e-9))
ac_tr = (P.argmax(axis=1) == y_tr).mean()
ac_te = (prever(X_te).argmax(axis=1) == y_te).mean()
print("epoca %2d | perda %.4f | acerto treino %.3f | acerto teste %.3f"
% (epoca, perda, ac_tr, ac_te))
# 3) Onde a rede erra ----------------------------------------
pred = prever(X_te).argmax(axis=1)
indices_errados = np.where(pred != y_te)[0]
print("\nerrou %d de %d imagens de teste" % (len(indices_errados), len(y_te)))
for i in indices_errados:
print(" imagem %4d: era %d, a rede disse %d" % (i, y_te[i], pred[i]))Saída obtida
treino: (1437, 64) | teste: (360, 64)
epoca 15 | perda 0.0598 | acerto treino 0.980 | acerto teste 0.964
epoca 30 | perda 0.0147 | acerto treino 0.998 | acerto teste 0.983
epoca 45 | perda 0.0073 | acerto treino 1.000 | acerto teste 0.983
epoca 60 | perda 0.0041 | acerto treino 1.000 | acerto teste 0.983
errou 6 de 360 imagens de teste
imagem 6: era 9, a rede disse 5
imagem 22: era 5, a rede disse 9
imagem 27: era 3, a rede disse 5
imagem 199: era 6, a rede disse 1
imagem 212: era 5, a rede disse 4
imagem 326: era 8, a rede disse 5Leia com atenção a linha da época 60. Acerto de 100% no treino e 98,3% no teste: a rede memorizou o material de estudo por completo e ainda assim erra 6 provas de 360. Aquela distância de 1,7 ponto entre os dois números é o sobreajuste que discutimos. E vários dos erros são pares que confundem gente também — 9 com 5, 3 com 5, 8 com 5 —, embora nem todos (6 com 1 é mais difícil de justificar).
Experimente 1 — deixe a decoreba gritar. Troque test_size=0.2 por test_size=0.8 (a rede passa a estudar com só 359 imagens) e epocas para 200. O que sai:
treino: (359, 64) | teste: (1438, 64)
epoca 200 | perda 0.0015 | acerto treino 1.000 | acerto teste 0.935
errou 93 de 1438 imagens de testeA distância entre treino e teste salta de 1,7 para 6,5 pontos, e a perda de treino continua caindo enquanto o acerto de teste não sai do lugar. É a decoreba visível em números: a rede segue melhorando no que já viu e parou de aprender qualquer coisa útil sobre o resto do mundo.
Experimente 2 — olhe a imagem que a rede errou. Três linhas no fim do programa, e a base de dados deixa de ser abstrata:
import matplotlib.pyplot as plt
i = indices_errados[0]
plt.imshow(X_te[i].reshape(8, 8), cmap="gray_r")
plt.title("era %d, a rede disse %d" % (y_te[i], pred[i])); plt.show()O índice impresso (imagem 6, por exemplo) é a posição dentro do conjunto de teste, não dentro da base inteira. E um aviso de reprodutibilidade: os índices exatos podem variar conforme a versão do scikit-learn, que sorteia a divisão treino/teste; os números de acerto, não.
Bônus: as mesmas ideias em dez linhas, com o MNIST completo. Depois de escrever a retropropagação à mão, veja o que uma biblioteca faz por você — e note que a estrutura é rigorosamente a mesma: achatar a imagem, camada escondida com ReLU, dez saídas com softmax.
import tensorflow as tf
(x_tr, y_tr), (x_te, y_te) = tf.keras.datasets.mnist.load_data()
x_tr, x_te = x_tr / 255.0, x_te / 255.0 # 28x28 pixels, escala 0-1
modelo = tf.keras.Sequential([
tf.keras.layers.Input(shape=(28, 28)),
tf.keras.layers.Flatten(), # 28x28 vira 784 numeros
tf.keras.layers.Dense(128, activation="relu"),
tf.keras.layers.Dense(10, activation="softmax"),
])
modelo.compile(optimizer="adam",
loss="sparse_categorical_crossentropy",
metrics=["accuracy"])
modelo.fit(x_tr, y_tr, epochs=5, validation_split=0.1)
perda, acerto = modelo.evaluate(x_te, y_te, verbose=0)
print("acerto no conjunto de teste: %.4f" % acerto)Cinco épocas, menos de um minuto no Colab depois do download do MNIST, e você chega perto de 98% de acerto em 10 mil imagens que a rede nunca viu — sem ter escrito uma única regra sobre o que é um algarismo. Não se assuste se o import tensorflow despejar avisos vermelhos sobre CUDA e oneDNN: são recados sobre placa de vídeo, não erros.
Sinapse 13
Perguntas para o seu contexto
O vocabulário deste post é o mesmo que sustenta as ferramentas que você usa. Marque o que já consegue explicar para um colega — cada item cobre um conceito do texto.
Vale ainda a transposição para a sala de aula. A regra de Rosenblatt é, no fundo, uma teoria do feedback: correção só ensina quando chega ligada ao caso concreto que a produziu e proporcional ao tamanho do erro — nota sem comentário é erro sem gradiente. E o sobreajuste tem tradução direta na avaliação: uma lista de exercícios que vira gabarito decorado mede memória, não aprendizagem. Já a lição da camada escondida é a mais bonita de todas: quando um problema parece impossível, às vezes o que falta não é mais esforço, e sim uma representação melhor do problema.
O tema também já é estatística oficial brasileira: segundo o IBGE, 41,9% das empresas industriais com 100 ou mais pessoas ocupadas usavam inteligência artificial em 2024, contra 16,9% em 2022 (IBGE, 2025). Boa parte do que está por trás desses sistemas é, com poucas variações, o que você acabou de ver aqui.
Convergência
Uma reta, um muro e uma escada
A história que contamos aqui tem uma estrutura quase teatral. Ato um: alguém percebe que uma máquina pode ajustar sozinha os próprios números e a imprensa promete consciência artificial para a semana seguinte. Ato dois: uma demonstração matemática de três linhas mostra que o modelo é uma reta diante de um mundo curvo, e o entusiasmo vira gelo por quase duas décadas. Ato três: descobre-se que bastava empilhar camadas e deixar o erro voltar por elas — e que a matemática necessária já estava pronta desde o século XVII, na regra da cadeia.
Vale reter que o perceptron não estava errado; estava incompleto. E que a solução não veio de uma teoria mais sofisticada, mas de uma mudança de perspectiva: em vez de encontrar a fronteira certa no espaço original, deixe a máquina inventar um espaço em que a fronteira certa seja simples. É essa ideia — não a metáfora do cérebro — que atravessa toda a inteligência artificial contemporânea, dos leitores de cheque aos modelos de linguagem.
No próximo post da série, viramos a lente para o outro lado da equação: se a rede só aprende o que está nos exemplos, quem escolhe os exemplos decide o que a máquina vai pensar. Falaremos de dados, viés, avaliação e do que acontece quando o gabarito está torto. Até lá, fica a pergunta: na sua área, qual é o "ou exclusivo" — aquele problema que parece impossível apenas porque ninguém ainda trocou as coordenadas em que ele é descrito?
Nota do autor: a manchete do New York Times de 1958 é citada aqui na tradução do autor, a partir da reprodução feita pelo Cornell Chronicle (2019), e não do original consultado diretamente. O bordão "neurônios que disparam juntos se conectam" é uma paráfrase popular posterior, não uma frase literal de Hebb (1949) — o texto original fala em fortalecimento da eficiência de uma célula que participa repetidamente da ativação de outra. A configuração da "retina" do Mark I em 20 × 20 fotocélulas é o dado consolidado na literatura técnica sobre a máquina; o registro do Smithsonian descreve as unidades sensoriais, associativas e de resposta sem informar a contagem. Sobre a data da máquina: o registro do Smithsonian a associa a 1958, mas a demonstração daquele ano foi uma simulação em computador de válvulas, e o equipamento físico só ficou operacional por volta de 1960 — daí o "fim dos anos 1950" no texto. Sobre a paternidade da retropropagação: Werbos (1974) é a referência mais antiga habitualmente citada em textos de aprendizado de máquina, mas o método foi redescoberto de forma independente diversas vezes, e a difusão efetiva veio com Rumelhart, Hinton e Williams (1986) — adotamos aqui essa dupla atribuição. O teorema da convergência do perceptron é frequentemente atribuído ao artigo de 1958; a demonstração, porém, está em Rosenblatt (1962) e no limite de Novikoff, do mesmo ano — por isso a citação nesse ponto é a de 1962. A responsabilidade de Minsky e Papert (1969) pelo "inverno" das redes neurais é objeto de disputa historiográfica: o livro demonstra limites reais do modelo de camada única e conjectura, sem provar, que a extensão a múltiplas camadas seria estéril; o corte de financiamento teve outras causas concorrentes. Os valores da Tabela 1 são os publicados por LeCun et al. (1998) para o conjunto de teste do MNIST e não representam o estado da arte atual, hoje bem abaixo de 0,5%. Os programas em Python foram executados pelo autor e as saídas reproduzidas são reais e completas, sem cortes; o exemplo em Keras, por depender de download do MNIST, é apresentado sem saída. O laboratório da descida do gradiente usa, por clareza, um modelo linear com erro quadrático — a única paisagem que uma tela desenha por inteiro; a curva de "dois vales" é sintética, construída para exibir um mínimo local, e não deriva do modelo de reta (cuja paisagem é sempre uma parábola). A contagem de 2 410 parâmetros da rede do nível 3 soma 64×32 + 32 + 32×10 + 10. O circuito de três perceptrons da Sinapse 06 é a solução didática clássica do problema, não a única: como o próprio tutorial de nível 2 mostra, a rede treinada chega a outro par de retas igualmente válido. As ilustrações são esquemas didáticos gerados pelo autor, não reproduções de figuras dos artigos originais; o esquema de dois planos da Sinapse 06 foi desenhado em SVG, com coordenadas calculadas, e não gerado por imagem.
Referências
- ACM — ASSOCIATION FOR COMPUTING MACHINERY. Fathers of the deep learning revolution receive ACM A.M. Turing Award. Nova York: ACM, 2019. Disponível em: https://awards.acm.org/about/2018-turing. Acesso em: 15 ago. 2026.
- BROWN, Tom B. et al. Language models are few-shot learners. In: CONFERENCE ON NEURAL INFORMATION PROCESSING SYSTEMS, 34., 2020. Advances in Neural Information Processing Systems 33. [S. l.]: NeurIPS, 2020. Disponível em: https://arxiv.org/abs/2005.14165. Acesso em: 15 ago. 2026.
- CYBENKO, George. Approximation by superpositions of a sigmoidal function. Mathematics of Control, Signals, and Systems, v. 2, n. 4, p. 303-314, 1989. DOI: 10.1007/BF02551274. Disponível em: https://doi.org/10.1007/BF02551274. Acesso em: 15 ago. 2026.
- GOODFELLOW, Ian; BENGIO, Yoshua; COURVILLE, Aaron. Deep learning. Cambridge: MIT Press, 2016. Disponível em: https://www.deeplearningbook.org/. Acesso em: 15 ago. 2026.
- HEBB, Donald O. The organization of behavior: a neuropsychological theory. Nova York: John Wiley & Sons, 1949.
- HORNIK, Kurt; STINCHCOMBE, Maxwell; WHITE, Halbert. Multilayer feedforward networks are universal approximators. Neural Networks, v. 2, n. 5, p. 359-366, 1989. DOI: 10.1016/0893-6080(89)90020-8. Disponível em: https://doi.org/10.1016/0893-6080(89)90020-8. Acesso em: 15 ago. 2026.
- IBGE — INSTITUTO BRASILEIRO DE GEOGRAFIA E ESTATÍSTICA. De 2022 a 2024, percentual de empresas industriais utilizando inteligência artificial subiu de 16,9% para 41,9%. Agência IBGE Notícias, Rio de Janeiro, set. 2025. Disponível em: https://agenciadenoticias.ibge.gov.br/agencia-noticias/2012-agencia-de-noticias/noticias/44551-de-2022-a-2024-percentual-de-empresas-industriais-utilizando-inteligencia-artificial-subiu-de-16-9-para-41-9. Acesso em: 15 ago. 2026.
- KRIZHEVSKY, Alex; SUTSKEVER, Ilya; HINTON, Geoffrey E. ImageNet classification with deep convolutional neural networks. In: CONFERENCE ON NEURAL INFORMATION PROCESSING SYSTEMS, 26., 2012, Lake Tahoe. Advances in Neural Information Processing Systems 25. [S. l.]: NeurIPS, 2012. p. 1097-1105. Disponível em: https://papers.nips.cc/paper_files/paper/2012/hash/c399862d3b9d6b76c8436e924a68c45b-Abstract.html. Acesso em: 15 ago. 2026.
- LeCUN, Yann et al. Backpropagation applied to handwritten zip code recognition. Neural Computation, v. 1, n. 4, p. 541-551, 1989. DOI: 10.1162/neco.1989.1.4.541. Disponível em: https://doi.org/10.1162/neco.1989.1.4.541. Acesso em: 15 ago. 2026.
- LeCUN, Yann; BOTTOU, Léon; BENGIO, Yoshua; HAFFNER, Patrick. Gradient-based learning applied to document recognition. Proceedings of the IEEE, v. 86, n. 11, p. 2278-2324, 1998. DOI: 10.1109/5.726791. Disponível em: https://doi.org/10.1109/5.726791. Acesso em: 15 ago. 2026.
- LeCUN, Yann; BENGIO, Yoshua; HINTON, Geoffrey. Deep learning. Nature, v. 521, p. 436-444, 2015. DOI: 10.1038/nature14539. Disponível em: https://doi.org/10.1038/nature14539. Acesso em: 15 ago. 2026.
- McCULLOCH, Warren S.; PITTS, Walter. A logical calculus of the ideas immanent in nervous activity. Bulletin of Mathematical Biophysics, v. 5, p. 115-133, 1943. DOI: 10.1007/BF02478259. Disponível em: https://doi.org/10.1007/BF02478259. Acesso em: 15 ago. 2026.
- MINSKY, Marvin; PAPERT, Seymour. Perceptrons: an introduction to computational geometry. Cambridge: MIT Press, 1969.
- MITCHELL, Tom M. Machine learning. Nova York: McGraw-Hill, 1997.
- NATIONAL MUSEUM OF AMERICAN HISTORY. Electronic neural network, Mark I Perceptron. Washington: Smithsonian Institution, [s. d.]. Disponível em: https://americanhistory.si.edu/collections/object/nmah_334414. Acesso em: 15 ago. 2026.
- PROFESSOR'S perceptron paved the way for AI — 60 years too soon. Cornell Chronicle, Ithaca, 25 set. 2019. Disponível em: https://news.cornell.edu/stories/2019/09/professors-perceptron-paved-way-ai-60-years-too-soon. Acesso em: 15 ago. 2026.
- ROSENBLATT, Frank. The perceptron: a probabilistic model for information storage and organization in the brain. Psychological Review, v. 65, n. 6, p. 386-408, 1958. DOI: 10.1037/h0042519. Disponível em: https://doi.org/10.1037/h0042519. Acesso em: 15 ago. 2026.
- ROSENBLATT, Frank. Principles of neurodynamics: perceptrons and the theory of brain mechanisms. Washington: Spartan Books, 1962.
- RUMELHART, David E.; HINTON, Geoffrey E.; WILLIAMS, Ronald J. Learning representations by back-propagating errors. Nature, v. 323, p. 533-536, 1986. DOI: 10.1038/323533a0. Disponível em: https://doi.org/10.1038/323533a0. Acesso em: 15 ago. 2026.
- RUSSELL, Stuart; NORVIG, Peter. Inteligência artificial: uma abordagem moderna. 4. ed. Rio de Janeiro: LTC, 2022.
- WERBOS, Paul J. Beyond regression: new tools for prediction and analysis in the behavioral sciences. 1974. Tese (Doutorado em Matemática Aplicada) — Harvard University, Cambridge, 1974.
- WIDROW, Bernard; HOFF, Marcian E. Adaptive switching circuits. In: IRE WESCON CONVENTION, 1960, Los Angeles. IRE WESCON Convention Record, part 4. Nova York: Institute of Radio Engineers, 1960. p. 96-104.
Comentários