Camadas (Layers)#

As camadas são os blocos de construção fundamentais de qualquer rede neural profunda. Elas contêm os parâmetros treináveis do modelo (pesos e vieses) e são responsáveis por aplicar transformações geométricas nos dados de entrada.

Na arquitetura da biblioteca Turing, o aprendizado de máquina é tratado como um pipeline modular. O dado flui para frente através das camadas (Forward Pass) para gerar uma previsão, e o erro flui de trás para frente (Backward Pass) ajustando as matrizes de cada camada.

Interface Base (Layer)#

class Layer#

Classe base abstrata para todas as camadas da rede neural.

  • Define o contrato polimórfico que qualquer componente da rede (camadas densas, convolucionais, funções de ativação) deve implementar. Ela garante que o modelo possa orquestrar o fluxo de dados em lote (batch) de forma genérica.

Subclassed by DenseLayer, ReLU, Sigmoid, Softmax, Tanh

Public Functions

inline virtual ~Layer()#

Destrutor virtual padrão.

  • Garante a liberação correta de memória das classes derivadas quando destruídas a partir de um ponteiro da classe base.

virtual void Forward(const Eigen::MatrixXf &input, Eigen::MatrixXf &output) = 0#

Executa o forward pass (propagação direta) da camada.

  • Aplica a transformação matemática específica da camada aos dados de entrada. De forma generalizada, computa:

    \[ Y = f(X) \]
    Onde \( X \) é a entrada e \( f \) é a operação interna da camada.

Parameters:

  • input – Referência constante para a matriz de entrada \( X \).

  • output – Referência para a matriz onde o resultado \( Y \) será armazenado.

virtual void Backward(Eigen::MatrixXf &grad_input, const Eigen::MatrixXf &grad_output) = 0#

Executa o backward pass (retropropagação) da camada.

  • Aplica a Regra da Cadeia para propagar o gradiente do erro. A camada recebe o gradiente da perda em relação à sua saída, \( \frac{\partial L}{\partial Y} \), e calcula o gradiente em relação à sua entrada, \( \frac{\partial L}{\partial X} \), propagando-o para a camada anterior:

    \[ \frac{\partial L}{\partial X} = \frac{\partial L}{\partial Y} \cdot \frac{\partial Y}{\partial X} \]

Parameters:

  • grad_input – Matriz que armazenará o gradiente calculado \( \frac{\partial L}{\partial X} \).

  • grad_output – Matriz contendo o gradiente recebido da camada seguinte \( \frac{\partial L}{\partial Y} \).

inline virtual void UpdateParams(Optimizer *optimizer)#

Atualiza os parâmetros internos da camada (pesos, vieses).

  • Camadas parametrizadas (ex: DenseLayer) devem sobrescrever este método para aplicar os gradientes calculados utilizando o otimizador fornecido.

Note

Camadas sem parâmetros treináveis (ex: ReLU, Softmax) utilizam esta implementação base vazia, ignorando o passo de atualização.

Parameters:

optimizer – Ponteiro para o otimizador que dita a regra de atualização.

inline virtual void SaveParams(std::ofstream &file)#

Serializa os parâmetros da camada em disco.

  • Implementação base vazia. Camadas com estado interno de aprendizado devem sobrescrever este método para persistir suas matrizes.

Parameters:

file – Referência para o fluxo de arquivo de saída onde os dados serão gravados.

Camada Densa (DenseLayer)#

class DenseLayer : public Layer#

Implementa uma camada densa (fully connected) da rede neural.

  • Responsável por aplicar uma transformação linear aos dados de entrada. A operação fundamental desta camada no forward pass é:

    \[ Z = X \cdot W + b \]
    Onde:

  • \( X \) é a matriz de entrada.

  • \( W \) é a matriz de pesos.

  • \( b \) é o vetor de vieses (transmitido para todas as linhas via broadcasting).

Public Functions

inline DenseLayer(const int input_size, const int neurons)#

Construtor da camada densa.

  • Inicializa os pesos a partir de uma distribuição uniforme (escalonada por 0.01 para evitar saturação inicial) e os vieses com zeros.

Parameters:

  • input_size – Número de características (features) da entrada.

  • neurons – Número de neurônios da camada (tamanho da saída).

virtual ~DenseLayer() = default#

Destrutor padrão.

inline virtual void Forward(const Eigen::MatrixXf &input, Eigen::MatrixXf &output) override#

Executa o forward pass da camada densa.

Note

Utiliza broadcasting do Eigen (rowwise()) para somar o vetor de vieses a cada amostra do batch.

Parameters:

  • input – Referência constante para a matriz de entrada de dimensões \( (batch\_size \times input\_size) \).

  • output – Referência para a matriz onde o resultado \( Z \) será armazenado, de dimensões \( (batch\_size \times neurons) \).

inline virtual void Backward(Eigen::MatrixXf &grad_input, const Eigen::MatrixXf &grad_output) override#

Executa o backward pass, calculando os gradientes locais e propagando o erro.

  • A partir do gradiente recebido da camada posterior \( \frac{\partial L}{\partial Z} \), esta função calcula as seguintes derivadas parciais:

  • 1. Gradiente dos pesos:

    \[ \frac{\partial L}{\partial W} = X^T \cdot \frac{\partial L}{\partial Z} \]

  1. Gradiente dos vieses:

    \[ \frac{\partial L}{\partial b} = \sum_{i=1}^{m} \left( \frac{\partial L}{\partial Z} \right)_i \]

  2. Gradiente da entrada (propagado para trás):

    \[ \frac{\partial L}{\partial X} = \frac{\partial L}{\partial Z} \cdot W^T \]

Parameters:

  • grad_input – Matriz que armazenará o gradiente a ser enviado para a camada anterior \( (batch\_size \times input\_size) \).

  • grad_output – Gradiente da perda em relação à saída desta camada \( (batch\_size \times neurons) \).

inline virtual void UpdateParams(Optimizer *optimizer) override#

Atualiza os pesos e vieses da camada.

Parameters:

optimizer – Ponteiro para o otimizador que aplicará a regra de atualização (ex: SGD, Momentum, Adam).

inline virtual void SaveParams(std::ofstream &file) override#

Salva os parâmetros atuais da camada em um arquivo de texto.

Parameters:

file – Referência para o fluxo de arquivo (ofstream) onde os dados serão gravados.

Exemplo de Aplicação#

Abaixo está um exemplo completo de como instanciar e treinar uma rede utilizando a camada densa:

 1    Model model;
 2
 3    // Camada Oculta: 784 entradas (pixels 28x28) para 128 neurônios
 4    model.AddLayer(new DenseLayer(784, 128));
 5    model.AddLayer(new ReLU());
 6
 7    // Camada de Saída: 128 entradas para 10 neurônios (classes de 0 a 9)
 8    model.AddLayer(new DenseLayer(128, 10));
 9    model.AddLayer(new Softmax());
10
11    /*
12     * 3. Configurando a função de perda e o otimizador
13     */
14
15    CategoricalCrossEntropy loss_function;
16    NAG optimizer(0.01f, 0.01f);
17
18    /*
19     * 4. Configurando os parâmetros de treinamento do modelo
20     */
21
22    int epochs = 20;
23    int batch_size = 64;
24
25    model.Fit(epochs, batch_size, X_train, Y_train, loss_function, optimizer);
26
27    /*