#include <regularizers.hpp>

Static Public Member Functions
static double	l1_regularization (const std::vector< double > &weights, double lambda)
	Computes L1 regularization penalty (Lasso regression) More...

static double	l2_regularization (const std::vector< double > &weights, double lambda)
	Computes L2 regularization penalty (Ridge regression) More...

static double	elastic_net_regularization (const std::vector< double > &weights, double lambda1, double lambda2)
	Computes Elastic Net regularization penalty. More...

static double	dropout_regularization (double dropout_rate, int num_neurons)
	Computes Dropout regularization penalty. More...

static bool	early_stopping (double current_val_loss, double &best_val_loss, int patience, int epoch)
	Performs early stopping based on validation loss. More...

static std::vector< double >	ensemble_predictions (const std::vector< std::vector< double >> &predictions)
	Combines predictions from multiple models using ensembling. More...

static void	max_norm_regularization (std::vector< double > &weights, double max_norm)
	Applies max norm regularization to the weights. More...

static void	weight_decay_regularization (std::vector< double > &weights, double lambda)
	Applies weight decay regularization to the weights. More...

static std::vector< std::vector< double > >	batch_normalization (const std::vector< std::vector< double >> &input_data, double epsilon=1e-5, double scale=1.0, double shift=0.0)
	Applies batch normalization to the input data. More...

static std::vector< std::vector< double > >	data_augmentation (const std::vector< std::vector< double >> &input_data, int augmentation_factor)
	Applies data augmentation to the input data. More...

Detailed Description

Definition at line 43 of file regularizers.hpp.

Member Function Documentation

◆ batch_normalization()

std::vector< std::vector< double > > gpmp::ml::Regularize::batch_normalization	(	const std::vector< std::vector< double >> &	input_data,
		double	epsilon = `1e-5`,
		double	scale = `1.0`,
		double	shift = `0.0`
	)

static

Applies batch normalization to the input data.

Parameters

input_data	The input data matrix
epsilon	A small value added to variance to avoid division by zero
scale	The scale parameter
shift	The shift parameter

Returns: The normalized input data matrix

Definition at line 127 of file regularizers.cpp.

                   {
     std::vector<std::vector<double>> normalized_data;
     for (const auto &instance : input_data) {
         double mean = 0.0;
         for (double val : instance) {
             mean += val;
         }
         mean /= instance.size();
  
         double variance = 0.0;
         for (double val : instance) {
             variance += (val - mean) * (val - mean);
         }
         variance /= instance.size();
  
         double std_dev = sqrt(variance + epsilon);
  
         std::vector<double> normalized_instance;
         for (double val : instance) {
             double normalized_val = scale * ((val - mean) / std_dev) + shift;
             normalized_instance.push_back(normalized_val);
         }
         normalized_data.push_back(normalized_instance);
     }
     return normalized_data;
 }

◆ data_augmentation()

std::vector< std::vector< double > > gpmp::ml::Regularize::data_augmentation	(	const std::vector< std::vector< double >> &	input_data,
		int	augmentation_factor
	)

static

Applies data augmentation to the input data.

Parameters

input_data	The input data matrix
augmentation_factor	The factor by which to augment the data (eg, 2 for doubling the data)

Returns: The augmented input data matrix

Definition at line 158 of file regularizers.cpp.

                              {
     std::vector<std::vector<double>> augmented_data;
     std::random_device rd;
     std::mt19937 gen(rd());
  
     for (const auto &instance : input_data) {
         augmented_data.push_back(instance);
         for (int i = 1; i < augmentation_factor; ++i) {
             std::vector<double> augmented_instance = instance;
             std::shuffle(augmented_instance.begin(),
                          augmented_instance.end(),
                          gen);
             augmented_data.push_back(augmented_instance);
         }
     }
     return augmented_data;
 }

◆ dropout_regularization()

double gpmp::ml::Regularize::dropout_regularization	(	double	dropout_rate,
		int	num_neurons
	)

static

Computes Dropout regularization penalty.

Parameters

dropout_rate	The dropout rate
num_neurons	The number of neurons in the layer

Returns: The Dropout regularization penalty

Definition at line 67 of file regularizers.cpp.

                                                                      {
     return 0.5 * dropout_rate * num_neurons;
 }

◆ early_stopping()

bool gpmp::ml::Regularize::early_stopping	(	double	current_val_loss,
		double &	best_val_loss,
		int	patience,
		int	epoch
	)

static

Performs early stopping based on validation loss.

Parameters

current_val_loss	The current validation loss
best_val_loss	The best validation loss observed so far
patience	The number of epochs to wait before stopping if validation loss doesn't improve
epoch	The current epoch number

Returns: True if early stopping criterion is met, False otherwise

Definition at line 72 of file regularizers.cpp.

                                                      {
     if (current_val_loss < best_val_loss) {
         best_val_loss = current_val_loss;
         patience = epoch + patience; // Reset patience
     } else {
         if (epoch >= patience) {
             return true; // Stop training
         }
     }
     return false; // Continue training
 }

◆ elastic_net_regularization()

double gpmp::ml::Regularize::elastic_net_regularization	(	const std::vector< double > &	weights,
		double	lambda1,
		double	lambda2
	)

static

Computes Elastic Net regularization penalty.

Parameters

weights	The weights of the model
lambda1	The L1 regularization parameter
lambda2	The L2 regularization parameter

Returns: The Elastic Net regularization penalty

Definition at line 58 of file regularizers.cpp.

                     {
     double l1_penalty = l1_regularization(weights, lambda1);
     double l2_penalty = l2_regularization(weights, lambda2);
     return l1_penalty + l2_penalty;
 }

◆ ensemble_predictions()

std::vector< double > gpmp::ml::Regularize::ensemble_predictions ( const std::vector< std::vector< double >> & predictions )

static

Combines predictions from multiple models using ensembling.

Parameters

predictions Vector of prediction vectors from individual models

Returns: Ensemble prediction vector

Definition at line 87 of file regularizers.cpp.

                                                      {
     std::vector<double> ensemble;
     if (!predictions.empty()) {
         ensemble.resize(predictions.front().size(), 0.0);
         for (const auto &prediction : predictions) {
             for (size_t i = 0; i < prediction.size(); ++i) {
                 ensemble[i] += prediction[i];
             }
         }
         for (auto &val : ensemble) {
             val /= predictions.size();
         }
     }
     return ensemble;
 }

◆ l1_regularization()

double gpmp::ml::Regularize::l1_regularization	(	const std::vector< double > &	weights,
		double	lambda
	)

static

Computes L1 regularization penalty (Lasso regression)

Parameters

weights	The weights of the model
lambda	The regularization parameter

Returns: The L1 regularization penalty

Definition at line 39 of file regularizers.cpp.

                                                        {
     double penalty = 0.0;
     for (double weight : weights) {
         penalty += std::abs(weight);
     }
     return lambda * penalty;
 }

◆ l2_regularization()

double gpmp::ml::Regularize::l2_regularization	(	const std::vector< double > &	weights,
		double	lambda
	)

static

Computes L2 regularization penalty (Ridge regression)

Parameters

weights	The weights of the model
lambda	The regularization parameter

Returns: The L2 regularization penalty

Definition at line 49 of file regularizers.cpp.

                                                        {
     double penalty = 0.0;
     for (double weight : weights) {
         penalty += weight * weight;
     }
     return 0.5 * lambda * penalty;
 }

◆ max_norm_regularization()

void gpmp::ml::Regularize::max_norm_regularization	(	std::vector< double > &	weights,
		double	max_norm
	)

static

Applies max norm regularization to the weights.

Parameters

weights	The weights of the model
max_norm	The maximum norm value

Definition at line 104 of file regularizers.cpp.

                                                                     {
     double norm = 0.0;
     for (double &weight : weights) {
         norm += weight * weight;
     }
     norm = sqrt(norm);
     if (norm > max_norm) {
         double factor = max_norm / norm;
         for (double &weight : weights) {
             weight *= factor;
         }
     }
 }

◆ weight_decay_regularization()

void gpmp::ml::Regularize::weight_decay_regularization	(	std::vector< double > &	weights,
		double	lambda
	)

static

Applies weight decay regularization to the weights.

Parameters

weights	The weights of the model
lambda	The regularization parameter

Definition at line 119 of file regularizers.cpp.

                    {
     for (double &weight : weights) {
         weight *= (1.0 - lambda);
     }
 }

The documentation for this class was generated from the following files:

include/openGPMP/ml/regularizers.hpp
modules/ml/regularizers.cpp

Static Public Member Functions

Detailed Description

Member Function Documentation

◆ batch_normalization()

◆ data_augmentation()

◆ dropout_regularization()

◆ early_stopping()

◆ elastic_net_regularization()

◆ ensemble_predictions()

◆ l1_regularization()

◆ l2_regularization()

◆ max_norm_regularization()

◆ weight_decay_regularization()