Funções de Perda (Loss)#

As funções de perda (ou funções de custo) atuam como o “juiz” durante o treinamento da rede neural. Elas quantificam matematicamente a discrepância entre as previsões feitas pelo modelo e os rótulos reais (ground truth) dos dados.

O objetivo central de todo o processo de aprendizado de máquina é minimizar o valor escalar retornado por esta função através do cálculo de seus gradientes (Backpropagation) e do reajuste iterativo dos pesos.

Abaixo, detalhamos a arquitetura base e as implementações específicas da biblioteca Turing.

Interface Base (Loss)#

class Loss#

Classe base abstrata para todas as funções de perda (Loss / Cost Functions).

A função de perda atua como a métrica de erro objetivo da rede neural. Ela quantifica a discrepância entre as previsões feitas pelo modelo e os rótulos reais (ground truth). O objetivo de qualquer otimizador é minimizar este valor.
De forma generalizada, para um lote (batch) de $N$ amostras, a perda agregada $L$ entre as previsões $\hat{Y}$ e os alvos reais $Y$ é dada por:
\[L = \frac{1}{N} \sum_{i=1}^{N} \ell(y_i, \hat{y}_i)\]
Onde $\ell$ representa a função de erro individual (como Erro Quadrático Médio ou Entropia Cruzada).

Subclassed by CategoricalCrossEntropy

Public Functions

Loss() = default#: Construtor padrão da classe base de perda.

virtual ~Loss() = default#: Destrutor virtual padrão. Garante a liberação correta de memória caso funções de perda filhas instanciem estruturas de dados próprias no futuro.

virtual void Forward(const Eigen::MatrixXf &predictions, const Eigen::MatrixXf &targets, float &loss) = 0#

Computa o valor escalar da perda (forward pass).

Avalia o erro total do lote (batch) reduzindo as matrizes a um único valor escalar.
\[L = f(\hat{Y}, Y)\]

Parameters:

predictions – Matriz constante contendo as previsões geradas pelo modelo $\hat{Y}$. Suas dimensões geralmente são $(batch_size \times num_classes)$.
targets – Matriz constante contendo os rótulos reais $Y$ correspondentes aos dados de entrada.
loss – Referência para a variável escalar float onde o valor final calculado da perda $L$ será armazenado.

virtual void Backward(const Eigen::MatrixXf &predictions, const Eigen::MatrixXf &targets, Eigen::MatrixXf &grad) = 0#

Computa o gradiente da função de perda (backward pass).

Este método é o ponto de partida exato do algoritmo de Backpropagation. Ele calcula a derivada da função de perda em relação a cada elemento da previsão do modelo, gerando a matriz Jacobiana que será propagada para a última camada da rede:
\[\nabla_{\hat{Y}} L = \frac{\partial L}{\partial \hat{Y}}\]

Parameters:

predictions – Matriz constante contendo as previsões do modelo $\hat{Y}$.
targets – Matriz constante contendo os rótulos reais $Y$.
grad – Matriz passada por referência que armazenará o gradiente calculado $\frac{\partial L}{\partial \hat{Y}}$. Terá exatamente as mesmas dimensões de $\hat{Y}$.

Entropia Cruzada Categórica (CCE)#

class CategoricalCrossEntropy : public Loss #

Implementa a função de perda Entropia Cruzada Categórica (Categorical Cross-Entropy).

Amplamente utilizada em problemas de classificação multiclasse (junto à ativação Softmax). Ela mede a divergência entre a distribuição de probabilidade prevista pelo modelo e a distribuição real dos dados (geralmente representada em one-hot encoding).
A perda média para um lote (batch) de $N$ amostras e $C$ classes é dada por:
\[L = -\frac{1}{N} \sum_{i=1}^{N} \sum_{c=1}^{C} Y_{i,c} \log(\hat{Y}_{i,c} + \epsilon)\]
Onde:
$Y$ é a matriz de alvos reais (targets).
$\hat{Y}$ é a matriz de previsões (predictions).
$\epsilon$ é um valor infinitesimal somado para garantir estabilidade numérica.

Public Functions

CategoricalCrossEntropy() = default#: Construtor padrão da função de perda Entropia Cruzada Categórica.

virtual ~CategoricalCrossEntropy() = default#: Destrutor padrão.

inline virtual void Forward(const Eigen::MatrixXf &predictions, const Eigen::MatrixXf &targets, float &loss) override#

Computa o valor escalar da perda (forward pass).

Aplica o logaritmo natural elemento a elemento nas previsões, pondera pelos alvos reais, e calcula a média ao longo de todo o lote (batch size).

Note

Adicionamos $\epsilon = 10^{-7}$ ( $\text{1e-7f}$) dentro do logaritmo para evitar a indefinição matemática e falha computacional ($\text{NaN}$) ao calcular $\log(0)$.

Parameters:

predictions – Matriz constante contendo as probabilidades previstas $\hat{Y}$.
targets – Matriz constante contendo os rótulos reais $Y$.
loss – Referência para a variável escalar onde o erro médio $L$ será armazenado.

inline virtual void Backward(const Eigen::MatrixXf &predictions, const Eigen::MatrixXf &targets, Eigen::MatrixXf &grad) override#

Computa o gradiente da Entropia Cruzada Categórica (backward pass).

Calcula a derivada da função de perda em relação a cada previsão feita pelo modelo. A matriz resultante representa o ponto de partida do algoritmo de backpropagation. A derivada matemática vetorizada (incluindo o fator de média do batch) é:
\[\frac{\partial L}{\partial \hat{Y}} = -\frac{1}{N} \left( \frac{Y}{\hat{Y} + \epsilon} \right)\]

Parameters:

predictions – Matriz constante contendo as previsões do modelo $\hat{Y}$.
targets – Matriz constante contendo os rótulos reais $Y$.
grad – Matriz passada por referência que armazenará o gradiente calculado $\frac{\partial L}{\partial \hat{Y}}$.

Exemplo de Aplicação#

Abaixo está um exemplo completo de como instanciar e treinar uma rede utilizando a entropia cruzada categórica como função de perdar:

    Model model;

    // Camada Oculta: 784 entradas (pixels 28x28) para 128 neurônios
    model.AddLayer(new DenseLayer(784, 128));
    model.AddLayer(new ReLU());

    // Camada de Saída: 128 entradas para 10 neurônios (classes de 0 a 9)
    model.AddLayer(new DenseLayer(128, 10));
    model.AddLayer(new Softmax());

    /*
     * 3. Configurando a função de perda e o otimizador
     */

    CategoricalCrossEntropy loss_function;
    NAG optimizer(0.01f, 0.01f);

    /*
     * 4. Configurando os parâmetros de treinamento do modelo
     */

    int epochs = 20;
    int batch_size = 64;

    model.Fit(epochs, batch_size, X_train, Y_train, loss_function, optimizer);

    /*

Otimizadores

Métricas