01-02-01 — Neurônios Artificiais e Camadas (Intuição Visual)

O Neurônio Biológico como Inspiração

Neurônios biológicos recebem sinais elétricos via dendritos, somam esses sinais no soma, e se a soma ultrapassar um limiar, disparam um pulso pelo axônio para neurônios vizinhos. É um sistema binário com threshold.

O neurônio artificial é uma simplificação matemática desse processo:

• Inputs: números chegando de outros neurônios (ou dos dados de entrada)
• Weights (pesos): cada input tem um peso — quanto aquele sinal importa
• Soma ponderada: multiplica cada input pelo seu peso e soma tudo
• Função de ativação: decide o output — transforma a soma numa saída entre 0 e 1, ou -1 e 1, ou qualquer valor positivo

O Perceptron: O Neurônio Mais Simples

Frank Rosenblatt criou o Perceptron em 1958. Um único neurônio que classifica duas classes: dado um conjunto de inputs, diz "sim" ou "não". Era uma máquina física, não software.

O problema: um único perceptron só resolve problemas linearmente separáveis. Não consegue aprender XOR — uma operação lógica básica. Esse limite, demonstrado por Minsky e Papert em 1969, contribuiu para o primeiro inverno da IA.

A solução: empilhar perceptrons em camadas. Uma rede com camada oculta pode aprender XOR. Com várias camadas, pode aprender qualquer função contínua (Teorema da Aproximação Universal).

Anatomia de uma Rede Neural

Camada de Entrada (Input Layer)

Recebe os dados brutos. Cada neurônio representa uma feature. Para uma imagem 28x28 pixels, a camada de entrada tem 784 neurônios (um por pixel). Para texto tokenizado, tem um neurônio por posição no vocabulário. Não tem pesos próprios — só passa os dados adiante.

Camadas Ocultas (Hidden Layers)

Aqui acontece o aprendizado de representações. As primeiras camadas ocultas aprendem features simples (bordas em imagens, padrões de caracteres em texto). Camadas mais profundas combinam essas features em conceitos mais abstratos (formas → olhos → rosto).

O "deep" em deep learning refere-se ao número de camadas ocultas. Redes com 2–3 camadas são "shallow". Redes modernas têm dezenas ou centenas.

Camada de Saída (Output Layer)

Define o que a rede prediz. Para classificação de 10 categorias: 10 neurônios, cada um com a probabilidade daquela classe. Para regressão (prever um número): 1 neurônio. Para geração de texto: tantos neurônios quanto o tamanho do vocabulário (GPT-4 tem ~100k).

Funções de Ativação: Por que Importam

Sem função de ativação, empilhar camadas lineares resulta numa única camada linear — matematicamente equivalente. A não-linearidade é o que dá poder às redes profundas.

• Sigmoid: comprime output entre 0 e 1. Usada em saídas de probabilidade. Problema: vanishing gradient em redes profundas
• ReLU (Rectified Linear Unit): se input > 0, retorna o input; se ≤ 0, retorna 0. Simples, rápida, e funciona bem em prática. Padrão desde AlexNet
• Softmax: normaliza um vetor de valores para que somem 1 — ideal para camadas de saída de classificação multiclasse

Parâmetros: O que a Rede "Aprende"

Os parâmetros de uma rede são os pesos (weights) e biases de cada neurônio. O número de parâmetros define a "capacidade" da rede.

Exemplo concreto: uma rede simples para classificar emails como spam/não-spam:

• Entrada: 1000 features (palavras mais comuns)
• Camada oculta: 256 neurônios → 1000 × 256 + 256 (bias) = 256.256 parâmetros
• Saída: 1 neurônio → 256 × 1 + 1 = 257 parâmetros
• Total: ~256.513 parâmetros

GPT-4 tem estimados 1,8 trilhão de parâmetros. Phi-4 tem 14 bilhões. A diferença de capacidade é monumental — mas modelos menores com dados melhores frequentemente superam os maiores.

Exemplo Prático: Rede Neural em C#

// ML.NET — criando uma rede neural simples para classificação
var mlContext = new MLContext(seed: 42);

// Pipeline: normalização + rede neural
var pipeline = mlContext.Transforms
    .NormalizeMinMax("Features")
    .Append(mlContext.MulticlassClassification.Trainers.LbfgsMaximumEntropy(
        labelColumnName: "Label",
        featureColumnName: "Features"))
    .Append(mlContext.Transforms.Conversion
        .MapKeyToValue("PredictedLabel"));

// Para redes profundas customizadas, use TensorFlow via ML.NET
// ou PyTorch via ONNX Runtime no .NET:
var session = new InferenceSession("model.onnx");
var inputs = new Dictionary<string, OrtValue>
{
    { "input", OrtValue.CreateTensorValueFromMemory(inputData, new long[] { 1, 784 }) }
};
var outputs = session.Run(inputs);

Desafio