Desafio: Treinamento do Perceptron

Antes de prosseguir com o treinamento do perceptron, lembre-se de que ele utiliza a função de perda de entropia cruzada binária discutida anteriormente. O último conceito-chave antes de implementar o backpropagation é a fórmula para a derivada dessa função de perda em relação às ativações de saída, $a^n$. Abaixo estão as fórmulas para a função de perda e sua derivada:

onde $a^n = \hat{y}$

Para verificar se o perceptron está sendo treinado corretamente, o método fit() também exibe a perda média em cada época. Isso é calculado pela média da perda em todos os exemplos de treinamento naquela época:

for epoch in range(epochs):
    loss = 0

    for i in range(training_data.shape[0]):
        loss += -(target * np.log(output) + (1 - target) * np.log(1 - output))

average_loss = loss[0, 0] / training_data.shape[0]
print(f'Loss at epoch {epoch + 1}: {average_loss:.3f}')

Por fim, as fórmulas para calcular os gradientes em cada camada são as seguintes:

Detalhes de Implementação para Lembrar

Ao traduzir essas fórmulas para código Python no método backward(), lembre-se das operações NumPy discutidas nos capítulos anteriores:

• O operador $\odot$ denota multiplicação elemento a elemento, que é feita usando o operador padrão * em Python.
• O operador $\cdot$ denota o produto escalar, implementado usando a função np.dot().
• O sobrescrito $T$ denota a transposição de matriz, tratada pelo atributo .T.
• Para calcular $f'^l(z^l)$, é possível chamar dinamicamente a derivada da função de ativação da camada usando self.activation.derivative(self.outputs).

Isso faz com que a estrutura geral do método backward() seja assim:

def backward(self, da, learning_rate):
    dz = ... # using da and self.activation.derivative()
    d_weights = ... # using np.dot() and .T
    d_biases = ...
    da_prev = ...

    self.weights -= learning_rate * d_weights
    self.biases -= learning_rate * d_biases

    return da_prev

Da mesma forma, ao reunir tudo no método fit(), lembre-se de que é necessário iterar pela rede de trás para frente para propagar o erro. A estrutura geral é a seguinte:

def fit(self, training_data, labels, epochs, learning_rate):
    # ... (Epoch loop and data shuffling) ...
            # Forward propagation
            output = ...

            # Computing the gradient of the loss function w.r.t. output (da^n)
            da = ...

            # Backward propagation through all layers
            for layer in self.layers[::-1]:
                da = ... # Call the backward() method of the layer

Os dados de treinamento de exemplo (X_train) juntamente com os rótulos correspondentes (y_train) estão armazenados como arrays NumPy no arquivo utils.py. Além disso, as instâncias das funções de ativação também estão definidas lá:

relu = ReLU()
sigmoid = Sigmoid()