gpmp::ml::RecurrentAutoEncoder Class Reference

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

#include <encoder.hpp>

Inheritance diagram for gpmp::ml::RecurrentAutoEncoder:

Public Member Functions
	RecurrentAutoEncoder (int input_size, int hidden_size, int output_size, double learning_rate)
	Constructor for the RecurrentAutoEncoder class. More...
virtual void	train (const std::vector< std::vector< double >> &training_data, int epochs) override
	Trains the recurrent autoencoder on the given sequential data. More...
std::vector< double >	recurr_fwd (const std::vector< double > &input, const std::vector< double > &previous_hidden)
	Performs a forward pass through the recurrent layer. 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
std::vector< std::vector< double > >	weights_recurrent
	Weight matrix for the recurrent connections. 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

RecurrentAutoEncoder class, a derived class from AutoEncoder.

Definition at line 475 of file encoder.hpp.

Constructor & Destructor Documentation

RecurrentAutoEncoder()

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

Constructor for the RecurrentAutoEncoder 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

Definition at line 579 of file encoder.cpp.

    : AutoEncoder(in_size, h_size, out_size, l_rate),
      weights_recurrent(h_size, std::vector<double>(h_size, 0.0)) {
}

Member Function Documentation

recurr_fwd()

std::vector< double > gpmp::ml::RecurrentAutoEncoder::recurr_fwd	(	const std::vector< double > &	input,
		const std::vector< double > &	previous_hidden
	)

Performs a forward pass through the recurrent layer.

Parameters

input	The input vector
previous_hidden	The hidden state from the previous time step

Returns

The hidden state for the current time step

Definition at line 633 of file encoder.cpp.

                                              {
    std::vector<double> recurrent_input(hidden_size, 0.0);
 
    // sum the weighted contributions from the current input and the previous
    // hidden state
    for (int i = 0; i < hidden_size; ++i) {
        recurrent_input[i] = 0.0;
        for (int j = 0; j < input_size; ++j) {
            recurrent_input[i] += weights_input_hidden[j][i] * input[j];
        }
        for (int j = 0; j < hidden_size; ++j) {
            recurrent_input[i] += weights_recurrent[j][i] * previous_hidden[j];
        }
        // activation function
        // recurrent_input[i] = 1.0 / (1.0 + std::exp(-recurrent_input[i]));
        recurrent_input[i] = sigmoid({recurrent_input[i]})[0];
    }
 
    return recurrent_input;
}

train()

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

overridevirtual

Trains the recurrent autoencoder on the given sequential data.

Overrides the train method in the base class for handling temporal dependencies

Parameters

training_data	The training data, which is a sequence of input vectors
epochs	The number of training epochs

Reimplemented from gpmp::ml::AutoEncoder.

Definition at line 587 of file encoder.cpp.

                {
    for (int epoch = 0; epoch < epochs; ++epoch) {
        std::vector<double> previous_hidden(hidden_size, 0.0);
 
        for (const auto &input : training_data) {
            // forward pass
            std::vector<double> hidden = recurr_fwd(input, previous_hidden);
            std::vector<double> output = forward(hidden);
 
            // 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 * (output[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 += (output[k] - input[k]) *
                                 weights_hidden_output[i][k];
                    }
                    weights_input_hidden[j][i] -= learning_rate * error *
                                                  input[j] * (1 - hidden[i]) *
                                                  hidden[i];
                }
            }
 
            // recurrent weights update
            for (int i = 0; i < hidden_size; ++i) {
                for (int j = 0; j < hidden_size; ++j) {
                    weights_recurrent[j][i] -=
                        learning_rate * (hidden[i] - previous_hidden[i]) *
                        hidden[j];
                }
            }
 
            previous_hidden = hidden;
        }
    }
}

Referenced by main().

Member Data Documentation

weights_recurrent

std::vector<std::vector<double> > gpmp::ml::RecurrentAutoEncoder::weights_recurrent

Weight matrix for the recurrent connections.

Definition at line 480 of file encoder.hpp.

---

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

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