Perceptron refere-se ao tipo mais simples de rede neural, que consiste em apenas um neurônio. Para lidar com problemas mais complexos, utiliza-se um modelo conhecido como perceptron multicamadas (MLP). Um perceptron multicamadas contém uma ou mais camadas ocultas que permitem à rede aprender padrões complexos nos dados.

A estrutura de um perceptron multicamadas inclui:

1. Camada de entrada: recebe os dados de entrada;
2. Camadas ocultas: processam os dados e extraem padrões relevantes;
3. Camada de saída: produz a previsão ou classificação final.

Cada camada é composta por múltiplos neurônios, e a saída de uma camada serve como entrada para a próxima camada.

Pesos e Bias das Camadas

Antes de implementar uma camada, é importante entender como armazenar os pesos e bias de cada neurônio nela. No capítulo anterior, foi mostrado como armazenar os pesos de um único neurônio como um vetor e seu bias como um escalar (número único).

Como uma camada é composta por múltiplos neurônios, é natural representar os pesos como uma matriz, onde cada linha corresponde aos pesos de um neurônio específico. Consequentemente, os bias podem ser representados como um vetor, cujo comprimento é igual ao número de neurônios.

Dada uma camada com $3$ entradas e $2$ neurônios, seus pesos serão armazenados em uma matriz $2 \times 3$ $W$ e seus bias serão armazenados em um vetor $2 \times 1$ $b$, que ficam assim:

Aqui, o elemento $W_{ij}$ representa o peso da $j$-ésima entrada para o $i$-ésimo neurônio, então a primeira linha contém os pesos do primeiro neurônio e a segunda linha contém os pesos do segundo neurônio. O elemento $b_i$ representa o bias do $i$-ésimo neurônio (dois neurônios – dois bias).

Propagação Direta

Realizar a propagação direta para cada camada significa ativar cada um de seus neurônios calculando a soma ponderada das entradas, adicionando o viés e aplicando a função de ativação.

Anteriormente, para um único neurônio, você implementou a soma ponderada das entradas calculando o produto escalar entre o vetor de entrada e o vetor de pesos e adicionando o viés.

Como cada linha da matriz de pesos contém o vetor de pesos para um neurônio específico, tudo o que você precisa fazer agora é simplesmente realizar um produto escalar entre cada linha da matriz e o vetor de entrada. Felizmente, isso é exatamente o que a multiplicação de matrizes faz:

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

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

Os blocos fundamentais do perceptron são suas camadas, portanto, faz sentido criar uma classe Layer separada. Seus atributos incluem:

• inputs: um vetor de entradas (n_inputs é o número de entradas);
• outputs: um vetor de valores de saída brutos (antes de aplicar a função de ativação) dos neurônios (n_neurons é o número de neurônios);
• weights: uma matriz de pesos;
• biases: um vetor de bias;
• activation_function: a função de ativação utilizada na camada.

Assim como na implementação de um único neurônio, weights e biases serão inicializados com valores aleatórios entre -1 e 1 extraídos de uma distribuição uniforme.

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

Os atributos inputs e outputs serão utilizados posteriormente na retropropagação, portanto faz sentido inicializá-los como arrays NumPy preenchidos com zeros.

Propagação direta pode ser implementada no método forward(), onde os outputs são calculados com base no vetor inputs utilizando NumPy, seguindo a fórmula acima:

def forward(self, inputs):
    self.inputs = np.array(inputs).reshape(-1, 1)
    # Raw outputs
    self.outputs = ...
    # Applying the activation function
    return ...