DenoisingAutoEncoder class, a derived class from AutoEncoder. More...

#include <encoder.hpp>

Inheritance diagram for gpmp::ml::DenoisingAutoEncoder:

Public Member Functions
	DenoisingAutoEncoder (int input_size, int hidden_size, int output_size, double learning_rate, double corruption_level)
	Constructor for the DenoisingAutoEncoder class. More...

void	train (const std::vector< std::vector< double >> &training_data, int epochs) override
	Adds noise to the input data and trains the denoising autoencoder. More...

Public Member Functions inherited from gpmp::ml::AutoEncoder
	AutoEncoder (int input_size, int hidden_size, int output_size, double learning_rate)
	Constructor for the AutoEncoder class. More...

std::vector< double >	sigmoid (const std::vector< double > &x)
	Sigmoid activation function. More...

std::vector< double >	forward (const std::vector< double > &input)
	Forward pass through the autoencoder. More...

void	lrate_set (double initial_rate)
	Set the initial learning rate. More...

virtual void	lrate_update (int epoch)
	Update the learning rate based on a schedule. More...

void	display ()
	Print the weights of the autoencoder. More...

virtual void	save (const std::string &filename) const
	Save the model weights to a file. More...

virtual void	load (const std::string &filename)
	Load model weights from a file. More...

Public Attributes
double	corruption_level
	Probability of setting an input value to zero during training (dropout rate) More...

Public Attributes inherited from gpmp::ml::AutoEncoder
int	input_size
	Size of the input layer. More...

int	hidden_size
	Size of the hidden layer. More...

int	output_size
	Size of the output layer. More...

double	learning_rate
	Learning rate for training the autoencoder. More...

std::vector< std::vector< double > >	weights_input_hidden
	Weights from the input layer to the hidden layer. More...

std::vector< std::vector< double > >	weights_hidden_output
	Weights from the hidden layer to the output layer. More...

Detailed Description

DenoisingAutoEncoder class, a derived class from AutoEncoder.

Definition at line 237 of file encoder.hpp.

Constructor & Destructor Documentation

◆ DenoisingAutoEncoder()

gpmp::ml::DenoisingAutoEncoder::DenoisingAutoEncoder	(	int	input_size,
		int	hidden_size,
		int	output_size,
		double	learning_rate,
		double	corruption_level
	)

Constructor for the DenoisingAutoEncoder class.

Parameters

input_size	The size of the input layer
hidden_size	The size of the hidden layer
output_size	The size of the output layer
learning_rate	The learning rate for training
corruption_level	The probability of setting an input value to zero during training

Definition at line 283 of file encoder.cpp.

     : AutoEncoder(in_size, h_size, out_size, l_rate),
       corruption_level(c_level) {
 }

Member Function Documentation

◆ train()

void gpmp::ml::DenoisingAutoEncoder::train	(	const std::vector< std::vector< double >> &	training_data,
		int	epochs
	)

overridevirtual

Adds noise to the input data and trains the denoising autoencoder.

Overrides the train method in the base class for denoising

Parameters

training_data	The training data
epochs	The number of training epochs

Reimplemented from gpmp::ml::AutoEncoder.

Definition at line 292 of file encoder.cpp.

                 {
     std::srand(std::time(0));
  
     for (int epoch = 0; epoch < epochs; ++epoch) {
         for (const auto &input : training_data) {
             // add noise to the input data
             std::vector<double> noisy_input = input;
             for (double &val : noisy_input) {
                 if ((std::rand() / (RAND_MAX + 1.0)) < corruption_level) {
                     // set to zero with probability corruption_level
                     val = 0.0;
                 }
             }
  
             // forward pass
             std::vector<double> hidden = forward(noisy_input);
  
             // backward pass (gradient descent)
             for (int i = 0; i < output_size; ++i) {
                 for (int j = 0; j < hidden_size; ++j) {
                     weights_hidden_output[j][i] -=
                         learning_rate * (hidden[i] - input[i]) * hidden[j];
                 }
             }
  
             for (int i = 0; i < hidden_size; ++i) {
                 for (int j = 0; j < input_size; ++j) {
                     double error = 0;
                     for (int k = 0; k < output_size; ++k) {
                         error += (hidden[k] - input[k]) *
                                  weights_hidden_output[i][k];
                     }
                     weights_input_hidden[j][i] -= learning_rate * error *
                                                   noisy_input[j] *
                                                   (1 - hidden[i]) * hidden[i];
                 }
             }
         }
     }
 }

Referenced by main().

Member Data Documentation

◆ corruption_level

double gpmp::ml::DenoisingAutoEncoder::corruption_level

Probability of setting an input value to zero during training (dropout rate)

Definition at line 243 of file encoder.hpp.

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

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

Public Member Functions