Perceptron é a rede neural mais simples—apenas um neurônio. Para tarefas mais complexas, utiliza-se o perceptron multicamadas (MLP), que contém uma ou mais camadas ocultas que permitem à rede aprender padrões mais ricos.

Um MLP consiste em:

1. Camada de entrada — recebe os dados;
2. Camadas ocultas — extraem padrões;
3. Camada de saída — produz previsões.

Cada camada possui múltiplos neurônios; a saída de uma camada torna-se a entrada da próxima.

Pesos e Bias das Camadas

Anteriormente, um neurônio armazenava seus pesos como um vetor e o bias como um escalar. Uma camada, entretanto, contém vários neurônios, então seus pesos tornam-se uma matriz, onde cada linha armazena os pesos de um neurônio. Os bias de todos os neurônios formam um vetor.

Para uma camada com 3 entradas e 2 neurônios:

Aqui, $W_{ij}$ é o peso da $j$-ésima entrada para o $i$-ésimo neurônio; $b_i$ é o bias do neurônio $i$.

Propagação Direta

A propagação direta ativa cada neurônio ao calcular uma soma ponderada, adicionar o bias e aplicar a função de ativação.

Anteriormente, um único neurônio utilizava:

[ z = W \cdot x + b ]

Agora, como cada linha de (W) é o vetor de pesos de um neurônio, realizar a multiplicação de matrizes entre a matriz de pesos e o vetor de entrada calcula automaticamente as somas ponderadas de todos os neurônios de uma vez.

Para adicionar os vieses às saídas dos respectivos neurônios, um vetor de vieses também deve ser somado:

Por fim, a função de ativação é aplicada ao resultado — sigmoid ou ReLU, neste caso. A fórmula resultante para a propagação direta na camada é a seguinte:

onde $a$ é o vetor de ativações dos neurônios (saídas).

Classe Layer

Como MLPs são compostas por camadas, definimos uma classe dedicada Layer. Seus atributos:

• inputs: vetor de entrada (elementos n_inputs);
• outputs: saídas brutas dos neurônios (elementos n_neurons);
• weights: matriz de pesos;
• biases: vetor de vieses;
• activation_function: função de ativação utilizada na camada.

Pesos e vieses são inicializados com valores aleatórios de uma distribuição uniforme em ([-1, 1]). inputs e outputs são inicializados como arrays NumPy preenchidos com zeros para garantir formatos consistentes para a retropropagação posterior.

class Layer:
    def __init__(self, n_inputs, n_neurons, activation_function):
        self.inputs = np.zeros((n_inputs, 1))
        self.outputs = np.zeros((n_neurons, 1))
        self.weights = ...
        self.biases = ...
        self.activation = activation_function

Método Forward

A propagação direta para uma camada calcula as saídas brutas e aplica a ativação:

def forward(self, inputs):
    self.inputs = np.array(inputs).reshape(-1, 1)
    # Raw outputs: weighted sum + bias
    self.outputs = ...
    # Apply activation
    return ...

Redimensionar a entrada para um vetor coluna garante a multiplicação correta com a matriz de pesos e mantém as dimensões esperadas em toda a rede.