Arquitetura MLP em Redes Neurais: camadas densas, capacidade e representações

Construindo uma MLP a partir de neurônios: visão de camadas

Uma MLP (Multi-Layer Perceptron) é uma rede formada por camadas densas (fully connected), onde cada neurônio de uma camada se conecta a todos os neurônios da camada seguinte. Em vez de pensar em neurônios isolados, é mais útil pensar em operações matriciais: cada camada densa aplica uma transformação linear (matriz de pesos e vetor de vieses) seguida de uma função não linear (ativação).

Em uma MLP típica para classificação ou regressão, organizamos as camadas assim:

• Camada de entrada: representa as features (variáveis) do dado. Não tem parâmetros treináveis; ela define a dimensão do vetor de entrada.
• Camadas ocultas: uma ou mais camadas densas que aprendem representações intermediárias.
• Camada de saída: produz a predição final (por exemplo, logits para classes ou um valor contínuo).

Notação de tensores (batch-first)

Vamos adotar a convenção mais comum: o primeiro eixo é o tamanho do lote (batch). Assim, um lote de entradas é um tensor X com forma (B, D_in), onde B é o número de exemplos no lote e D_in é o número de features por exemplo.

Uma camada densa que mapeia D_in para D_out pode ser escrita como:

Z = X @ W + b

com:

Continue em nosso aplicativo e ...

• Ouça o áudio com a tela desligada
• Ganhe Certificado após a conclusão
• + de 5000 cursos para você explorar!

ou continue lendo abaixo...

Baixar o aplicativo

• X: (B, D_in)
• W (pesos): (D_in, D_out)
• b (vieses): (D_out,) (broadcast para (B, D_out))
• Z (pré-ativação): (B, D_out)

Depois aplicamos a ativação (por exemplo, ReLU, tanh etc.) elemento a elemento:

A = activation(Z)

e A mantém a mesma forma de Z: (B, D_out).

Dimensão dos tensores e número de parâmetros

Uma das habilidades mais importantes ao projetar MLPs é calcular rapidamente:

• as formas (shapes) das ativações em cada camada;
• o número de parâmetros treináveis;
• o custo aproximado (memória e computação) ao aumentar largura/profundidade.

Parâmetros de uma camada densa

Para uma camada densa com D_in entradas e D_out saídas:

• Pesos: D_in × D_out
• Vieses: D_out
• Total: D_in × D_out + D_out

Exemplo: D_in=100, D_out=64:

• Pesos: 100×64 = 6400
• Vieses: 64
• Total: 6464

Parâmetros totais de uma MLP

Para uma MLP com dimensões D0 → D1 → D2 → ... → DK (onde D0 é a entrada e DK a saída), o total de parâmetros é:

sum_{i=0..K-1} (Di × D(i+1) + D(i+1))

Isso mostra um ponto crucial: em MLPs, o número de parâmetros cresce principalmente com o produto entre dimensões consecutivas. Aumentar a largura de uma camada pode aumentar muito o total de parâmetros.

Profundidade vs. largura: capacidade e risco de overfitting

A capacidade de uma MLP está ligada à sua habilidade de aproximar funções complexas. Em termos práticos, você controla a capacidade principalmente por:

• Largura: número de neurônios por camada (dimensão D das camadas ocultas).
• Profundidade: número de camadas ocultas.

O que muda ao aumentar a largura

• Mais parâmetros por camada: cresce aproximadamente proporcional a D_in × D_out.
• Representações mais “ricas” em uma única etapa: a camada pode capturar mais combinações das features.
• Maior risco de overfitting se o conjunto de dados for pequeno ou ruidoso, porque o modelo pode memorizar padrões específicos do treino.

Exemplo numérico: suponha entrada D0=200 e uma camada oculta com D1=512. Só essa camada tem 200×512 + 512 = 103. 0 0 0+512 (isto é, 102400+512=102912) parâmetros. Se você dobrar a largura para 1024, os parâmetros quase dobram: 200×1024 + 1024 = 205824.

O que muda ao aumentar a profundidade

• Composição de representações: cada camada pode aprender transformações progressivamente mais abstratas (composições de funções).
• Parâmetros podem crescer de forma controlada se você mantiver larguras moderadas, mas ainda assim aumentam a cada nova conexão entre camadas.
• Treinamento pode ficar mais delicado: mais camadas significam mais etapas de transformação e mais ativações intermediárias para armazenar durante o treino.

Uma intuição útil: largura tende a aumentar “capacidade por camada”; profundidade tende a aumentar “capacidade por composição”. Em muitos problemas, várias camadas moderadas podem representar certas funções de forma mais eficiente do que uma única camada extremamente larga.

Capacidade vs. generalização (por que overfitting aparece)

Quando a capacidade é alta em relação à quantidade/qualidade de dados, a MLP pode ajustar não apenas padrões gerais, mas também peculiaridades do conjunto de treino. Sinais comuns:

• erro de treino continua caindo enquanto o erro de validação para de melhorar ou piora;
• predições muito confiantes em exemplos fora do padrão;
• sensibilidade excessiva a pequenas variações de entrada.

Na prática, você controla esse risco combinando arquitetura (largura/profundidade) com regularização (por exemplo, weight decay, dropout) e boas práticas de validação. Aqui, o foco é entender como a arquitetura influencia o número de parâmetros e as formas dos tensores.

Seção prática: rastreamento de formas (shape tracing)

Rastrear formas significa acompanhar, camada a camada, o tamanho dos tensores de ativações. Isso evita erros comuns (dimensões incompatíveis) e ajuda a estimar memória e custo computacional.

Passo a passo: como fazer shape tracing

• Passo 1: escreva a forma da entrada do lote: (B, D0).
• Passo 2: para cada camada densa Di → D(i+1), a saída terá forma (B, D(i+1)).
• Passo 3: ativações não mudam a forma (apenas valores).
• Passo 4: repita até a camada de saída.

Exemplo guiado 1: MLP para classificação com 3 camadas densas

Suponha:

• Tamanho do lote: B=32
• Entrada: D0=20 features
• Ocultas: D1=64, D2=32
• Saída: D3=10 classes (logits)

Agora conte parâmetros:

• Camada 1 (20→64): 20×64 + 64 = 1344
• Camada 2 (64→32): 64×32 + 32 = 2080
• Camada 3 (32→10): 32×10 + 10 = 330
• Total: 1344 + 2080 + 330 = 3754

Exemplo guiado 2: como a largura explode parâmetros

Mantenha a mesma entrada e saída, mas aumente as ocultas para D1=256, D2=256:

• Camada 1 (20→256): 20×256 + 256 = 5376
• Camada 2 (256→256): 256×256 + 256 = 65792
• Camada 3 (256→10): 256×10 + 10 = 2570
• Total: 73738

Note que a camada 256→256 domina o total. Em MLPs, camadas largas consecutivas são as que mais “custam” em parâmetros.

Checklist rápido de shape tracing (para evitar erros)

• O último eixo do tensor de entrada da camada deve bater com D_in da camada.
• Após uma densa Di→D(i+1), o último eixo vira D(i+1).
• Vieses sempre têm tamanho D_out.
• Se você “achatar” (flatten) uma entrada (por exemplo, imagem), calcule D0 como o produto das dimensões achatadas.

Miniestudo de caso: classificação simples com MLP

Vamos considerar um problema de classificação binária simples: prever se um cliente vai cancelar um serviço com base em 20 atributos numéricos já pré-processados. A saída é 2 classes (cancelou / não cancelou). O objetivo aqui é comparar arquiteturas e entender o que muda ao adicionar camadas.

Arquitetura A: MLP rasa (uma camada oculta)

Definição:

• Entrada: D0=20
• Oculta: D1=32
• Saída: D2=2 (logits)

Shape tracing (com lote B):

• X: (B, 20)
• A1: (B, 32)
• logits: (B, 2)

Parâmetros:

• (20→32): 20×32 + 32 = 672
• (32→2): 32×2 + 2 = 66
• Total: 738

Interpretação prática: é um modelo leve, rápido e com menor risco de overfitting. Porém, pode ter dificuldade se a fronteira de decisão exigir múltiplas etapas de transformação (composições) para separar bem as classes.

Arquitetura B: MLP mais profunda (três camadas ocultas)

Definição:

• Entrada: 20
• Ocultas: 64 → 32 → 16
• Saída: 2

Shape tracing:

• X: (B, 20)
• A1: (B, 64)
• A2: (B, 32)
• A3: (B, 16)
• logits: (B, 2)

Parâmetros:

• (20→64): 20×64 + 64 = 1344
• (64→32): 64×32 + 32 = 2080
• (32→16): 32×16 + 16 = 528
• (16→2): 16×2 + 2 = 34
• Total: 3986

Discussão: o que muda ao adicionar mais camadas

• Representações intermediárias: em vez de ir direto de 20 features para uma separação quase final, a rede cria etapas: 64 “detectores” iniciais, depois combinações em 32, depois compressão em 16 antes da decisão. Isso pode capturar interações entre variáveis de forma mais estruturada.
• Capacidade e flexibilidade: a arquitetura B tem mais parâmetros e mais composições, então tende a ajustar padrões mais complexos.
• Risco de overfitting: se o dataset for pequeno, a arquitetura B pode aprender detalhes específicos do treino. Um sinal prático é a validação piorar enquanto o treino melhora.
• Custo: mais camadas aumentam computação e memória (mais ativações intermediárias por lote).

Exercício prático (para o aluno)

Considere uma MLP com entrada D0=50, ocultas D1=128, D2=64 e saída D3=5.

• Faça o shape tracing para um lote B=16.
• Calcule o número de parâmetros de cada camada e o total.
• Depois, altere apenas D1 de 128 para 256 e recalcule. Identifique qual termo do total mais cresce e por quê.