Perceptrons multicamada e não linearidade

01 · Conceito

Conceito

A lição 2.1 terminou num muro: XOR. Quatro pontos, duas classes, e nenhuma reta que os separe. O dispositivo não podia ser ajustado até virar solução porque não conseguia expressar uma. Então a pergunta prática que esta lição responde é estreita e concreta — qual é a menor mudança no perceptron que torna o XOR representável, e essa mudança escala para algo maior?

A mudança é empilhar. Alimente a entrada em várias unidades tipo perceptron ao mesmo tempo, passe o score de cada unidade por uma função não linear, e deixe uma segunda camada de unidades ler essas saídas em vez da entrada bruta. Para uma matriz de batch $X$ cujas linhas são exemplos e colunas são features, uma rede de uma camada oculta computa

onde $\phi$ atua elemento a elemento. Isso é um perceptron multicamada, ou MLP.

Tudo depende de $\phi$ estar realmente ali. Apague-a e a álgebra colapsa: $(XW_1+b_1)W_2+b_2$ se rearranja em $XW+b$ com $W=W_1W_2$ e $b=b_1W_2+b_2$. Dez camadas, cem camadas, qualquer número — ainda um único mapa afim, ainda um hiperplano, ainda exatamente tão impotente no XOR quanto o perceptron isolado era. Profundidade sem não linearidade não é uma versão mais fraca de profundidade; é uma forma mais cara de escrever a mesma função.

Veja o conserto funcionar no próprio XOR, à mão, sem treinamento nenhum. Use duas unidades ocultas com ReLU, que mantém valores positivos e zera os negativos: $h_1=\operatorname{ReLU}(x_1+x_2)$ e $h_2=\operatorname{ReLU}(x_1+x_2-1)$. Avalie os quatro cantos, um por vez. Em $(0,0)$: $h_1=0$ e $h_2=\operatorname{ReLU}(-1)=0$. Em $(0,1)$ e em $(1,0)$: $h_1=1$ e $h_2=\operatorname{ReLU}(0)=0$. Em $(1,1)$: $h_1=2$ e $h_2=\operatorname{ReLU}(1)=1$. Agora deixe a unidade de saída computar $y=h_1-2h_2-0.5$. Os cantos dão $-0.5$, depois $+0.5$ e $+0.5$, depois $2-2-0.5=-0.5$. Positivo exatamente nos dois cantos “diferentes”, negativo exatamente nos dois cantos “iguais”: XOR, resolvido.

Olhe o que aconteceu geometricamente. Nas novas coordenadas $(h_1,h_2)$ os quatro pontos ficam em $(0,0)$, $(1,0)$, $(1,0)$ e $(2,1)$. Os dois cantos de entradas diferentes, positivos no XOR, colapsam no mesmo ponto oculto $(1,0)$, enquanto os dois cantos de entradas iguais, negativos no XOR, ficam em $(0,0)$ e $(2,1)$. Uma única fronteira reta agora separa o ponto positivo compartilhado dos dois pontos negativos. A unidade de saída ainda é um perceptron, inalterada em relação à lição 2.1. A camada oculta mudou aquilo para o que ela está olhando.

Essa é a ideia duradoura: camadas ocultas aprendem uma representação, e a classificação acontece no espaço aprendido em vez do espaço bruto. Engenharia manual de features vira construção aprendida de features.

Largura é quantas unidades uma camada tem; profundidade é quantas transformações sucessivas existem. Largura compra mais features num estágio; profundidade permite que estágios posteriores reaproveitem features anteriores de forma composicional, o que pode representar algumas funções de modo muito mais compacto que uma única camada enorme. Nenhuma das duas garante nada sozinha.

Agora a razão pela qual isso importa para um curso sobre modelos de linguagem. Toda camada de um Transformer contém um MLP, convencionalmente chamado de feed-forward network, e ele não é um componente menor. No Qwen3.8-27B o hidden state carrega 5120 números por token; o bloco feed-forward expande isso para uma largura intermediária de 17.408, aplica uma ativação com gate que a lição 2.3 disseca, e projeta de volta para 5120 (Qwen3.8-27B Model Card, 2026). Uma matriz de shape 5120 por 17.408 dá cerca de 89,1 milhões de multiply-adds para um único token. O bloco com gate completo — projeções gate, up e down juntas — soma aproximadamente 267 milhões de parâmetros por camada, e o modelo tem 64 camadas, então só os blocos feed-forward respondem por algo da ordem de 17 bilhões dos 27 bilhões de parâmetros do modelo.

Existe aqui uma divisão de trabalho real que vale fixar cedo. O bloco feed-forward nunca olha para outros tokens. Ele recebe um vetor de 5120 dimensões, o transforma, e devolve um vetor do mesmo tamanho. Tudo o que ele sabe sobre o resto da frase chegou via attention antes de ele rodar.

Treinar um MLP segue o mesmo loop em toda parte: definir uma loss (lição 2.4), computar gradientes através de cada operação (lição 2.5), atualizar parâmetros (lição 2.7). Para classificação, a camada final emite logits, não decisões, e cross-entropy fornece um objetivo diferenciável; converter logits em uma ação é uma questão separada de política que pertence à implantação, não ao treinamento.

Depure um MLP pedindo a ele que memorize um batch minúsculo que deveria ajustar trivialmente. Confira todo shape de tensor, confirme que a loss cai para perto de zero, e inspecione se alguma ativação ou gradiente é inteiramente zero ou não finito. Esse teste não prova nada sobre generalização, mas falhar nele revela um bug de ligação, de objetivo ou de otimização antes que uma execução longa o enterre. Depois compare contra uma baseline linear simples: se a profundidade extra não acrescenta valor fora da amostra, ela não estava ganhando seus parâmetros.