gpmp::ml::VariationalAutoEncoder Class Reference

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

#include <encoder.hpp>

Inheritance diagram for gpmp::ml::VariationalAutoEncoder:

Public Member Functions
double	sample_dist ()
	Samples from a standard normal distribution. More...
double	reparameterize (double mean, double log_variance)
	Reparameterization trick for variational autoencoders. More...
std::vector< double >	encoder (const std::vector< double > &input)
	Performs the forward pass for the encoder and returns hidden activations. More...
std::vector< double >	decoder (const std::vector< double > &hidden_sampled)
	Performs the forward pass for the decoder and returns output activations. More...
void	gradient_descent (const std::vector< double > &input, const std::vector< double > &output, const std::vector< double > &hidden_sampled)
	Performs the backward pass (gradient descent) updating weights. More...
	VariationalAutoEncoder (int input_size, int hidden_size, int output_size, double learning_rate)
	Constructor for the VariationalAutoEncoder class. More...
virtual void	train (const std::vector< std::vector< double >> &training_data, int epochs) override
	Trains the Variational autoencoder on the given training data. 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< double >	hidden_mean
	keeps track of hidden means More...
std::vector< double >	hidden_log_variance
	keeps track of hidden log variance 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

VariationalAutoEncoder class, a derived class from AutoEncoder.

Definition at line 390 of file encoder.hpp.

Constructor & Destructor Documentation

VariationalAutoEncoder()

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

Constructor for the VariationalAutoEncoder 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 470 of file encoder.cpp.

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

Member Function Documentation

decoder()

std::vector< double > gpmp::ml::VariationalAutoEncoder::decoder

(

const std::vector< double > &

hidden_sampled

)

Performs the forward pass for the decoder and returns output activations.

Parameters

hidden_sampled

The sampled hidden values.

Returns

The output activations.

Definition at line 504 of file encoder.cpp.

                                             {
    std::vector<double> output(output_size);
 
    for (int i = 0; i < output_size; ++i) {
        output[i] = 0;
        for (int j = 0; j < hidden_size; ++j) {
            output[i] += hidden_sampled[j] * weights_hidden_output[j][i];
        }
        output[i] = sigmoid({output[i]})[0];
    }
 
    return output;
}

encoder()

std::vector< double > gpmp::ml::VariationalAutoEncoder::encoder

(

const std::vector< double > &

input

)

Performs the forward pass for the encoder and returns hidden activations.

Parameters

input

The input data.

Returns

The hidden activations.

Definition at line 490 of file encoder.cpp.

                                                                    {
    std::vector<double> hidden(hidden_size);
 
    for (int i = 0; i < hidden_size; ++i) {
        hidden[i] = 0;
        for (int j = 0; j < input_size; ++j) {
            hidden[i] += input[j] * weights_input_hidden[j][i];
        }
        hidden[i] = sigmoid({hidden[i]})[0];
    }
 
    return hidden;
}

gradient_descent()

void gpmp::ml::VariationalAutoEncoder::gradient_descent	(	const std::vector< double > &	input,
		const std::vector< double > &	output,
		const std::vector< double > &	hidden_sampled
	)

Performs the backward pass (gradient descent) updating weights.

Parameters

input	The input data.
output	The output activations.
hidden_sampled	The sampled hidden values.

Definition at line 519 of file encoder.cpp.

                                             {
    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_sampled[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];
            }
            double hidden_gradient =
                hidden_sampled[i] * (1 - hidden_sampled[i]);
            // derivative of softplus
            double log_variance_gradient =
                1.0 / (1.0 + exp(-hidden_log_variance[i]));
            weights_input_hidden[j][i] -=
                learning_rate *
                (error * hidden_gradient +
                 (hidden_sampled[i] - hidden_mean[i]) * hidden_gradient +
                 (hidden_log_variance[i] - log_variance_gradient) *
                     hidden_gradient) *
                input[j];
        }
    }
}

reparameterize()

double gpmp::ml::VariationalAutoEncoder::reparameterize	(	double	mean,
		double	log_variance
	)

Reparameterization trick for variational autoencoders.

Parameters

mean	The mean of the distribution
log_variance	The log variance of the distribution

Returns

A sample from the specified distribution

Definition at line 483 of file encoder.cpp.

                                                                             {
    double standard_normal_sample = sample_dist();
    return mean + exp(0.5 * log_variance) * standard_normal_sample;
}

sample_dist()

double gpmp::ml::VariationalAutoEncoder::sample_dist

(

)

Samples from a standard normal distribution.

Returns

A sample from the standard normal distribution.

Definition at line 477 of file encoder.cpp.

                                                 {
    static std::default_random_engine generator;
    static std::normal_distribution<double> distribution(0.0, 1.0);
    return distribution(generator);
}

train()

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

overridevirtual

Trains the Variational autoencoder on the given training data.

Overrides the train method in the base class with Variational autoencoder specifics

Parameters

training_data	The training data
epochs	The number of training epochs

Reimplemented from gpmp::ml::AutoEncoder.

Definition at line 552 of file encoder.cpp.

                {
    std::default_random_engine generator;
    std::normal_distribution<double> normal_distribution(0.0, 1.0);
    std::vector<double> hidden_sampled;
 
    for (int epoch = 0; epoch < epochs; ++epoch) {
        for (const auto &input : training_data) {
            // forward pass (encoder)
            hidden_mean = encoder(input);
            hidden_log_variance = encoder(input);
 
            for (int i = 0; i < hidden_size; ++i) {
                hidden_sampled.push_back(
                    reparameterize(hidden_mean[i], hidden_log_variance[i]));
            }
 
            // forward pass (decoder)
            std::vector<double> output = decoder(hidden_sampled);
 
            // backward pass (gradient descent)
            gradient_descent(input, output, hidden_sampled);
        }
    }
}

Member Data Documentation

hidden_log_variance

std::vector<double> gpmp::ml::VariationalAutoEncoder::hidden_log_variance

keeps track of hidden log variance

Definition at line 399 of file encoder.hpp.

hidden_mean

std::vector<double> gpmp::ml::VariationalAutoEncoder::hidden_mean

keeps track of hidden means

Definition at line 395 of file encoder.hpp.

---

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

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