O treinamento de uma rede neural envolve um processo iterativo no qual o modelo melhora gradualmente ao ajustar seus pesos e vieses para minimizar a função de perda. Esse processo é conhecido como otimização baseada em gradiente e segue um algoritmo estruturado.

Algoritmo Geral

O conjunto de dados é inicialmente passado pela rede várias vezes em um loop, onde cada passagem completa é chamada de época. Durante cada época, os dados são embaralhados para evitar que o modelo aprenda padrões baseados na ordem dos exemplos de treinamento. O embaralhamento ajuda a introduzir aleatoriedade, resultando em um modelo mais robusto.

Para cada exemplo de treinamento, o modelo realiza a propagação direta, em que as entradas passam pela rede, camada por camada, produzindo uma saída. Essa saída é então comparada ao valor alvo real para calcular a perda.

Em seguida, o modelo aplica a retropropagação e atualiza os pesos e vieses em cada camada para reduzir a perda.

Esse processo se repete por múltiplas épocas, permitindo que a rede refine seus parâmetros gradualmente. À medida que o treinamento avança, a rede aprende a fazer previsões cada vez mais precisas. No entanto, o ajuste cuidadoso de hiperparâmetros como a taxa de aprendizado é fundamental para garantir um treinamento estável e eficiente.

A taxa de aprendizado ($\alpha$) determina o tamanho do passo nas atualizações dos pesos. Se for muito alta, o modelo pode ultrapassar os valores ideais e não convergir. Se for muito baixa, o treinamento se torna lento e pode ficar preso em uma solução subótima. A escolha de uma taxa de aprendizado adequada equilibra velocidade e estabilidade durante o treinamento. Valores típicos variam de 0.001 a 0.1, dependendo do problema e do tamanho da rede.

O gráfico abaixo mostra como uma taxa de aprendizado apropriada permite que a perda diminua de forma constante em um ritmo ideal:

Por fim, o gradiente descendente estocástico (SGD) desempenha um papel fundamental na eficiência do treinamento. Em vez de calcular as atualizações dos pesos após processar todo o conjunto de dados, o SGD atualiza os parâmetros após cada exemplo individual. Isso torna o treinamento mais rápido e introduz pequenas variações nas atualizações, o que pode ajudar o modelo a escapar de mínimos locais e alcançar uma solução geral melhor.

O método fit()

O método fit() na classe Perceptron é responsável por treinar o modelo utilizando o gradiente descendente estocástico.

def fit(self, training_data, labels, epochs, learning_rate):
    # Iterating over multiple epochs
    for epoch in range(epochs):
        # Shuffling the data  
        indices = np.random.permutation(training_data.shape[0])
        training_data = training_data[indices]
        labels = labels[indices]
        # Iterating through each training example
        for i in range(training_data.shape[0]):
            inputs = training_data[i, :].reshape(-1, 1)
            target = labels[i, :].reshape(-1, 1)

            # Forward propagation
            output = ...

            # Computing the gradient of the loss function w.r.t. output
            da = ...

            # Backward propagation through all layers
            for layer in self.layers[::-1]:
                da = ...