mlp_net.hpp

Go to the documentation of this file.

/*************************************************************************
 *
 *  Project
 *                         _____ _____  __  __ _____
 *                        / ____|  __ \|  \/  |  __ \
 *  ___  _ __   ___ _ __ | |  __| |__) | \  / | |__) |
 * / _ \| '_ \ / _ \ '_ \| | |_ |  ___/| |\/| |  ___/
 *| (_) | |_) |  __/ | | | |__| | |    | |  | | |
 * \___/| .__/ \___|_| |_|\_____|_|    |_|  |_|_|
 *      | |
 *      |_|
 *
 * Copyright (C) Akiel Aries, <akiel@akiel.org>, et al.
 *
 * This software is licensed as described in the file LICENSE, which
 * you should have received as part of this distribution. The terms
 * among other details are referenced in the official documentation
 * seen here : https://akielaries.github.io/openGPMP/ along with
 * important files seen in this project.
 *
 * You may opt to use, copy, modify, merge, publish, distribute
 * and/or sell copies of the Software, and permit persons to whom
 * the Software is furnished to do so, under the terms of the
 * LICENSE file. As this is an Open Source effort, all implementations
 * must be of the same methodology.
 *
 *
 *
 * This software is distributed on an AS IS basis, WITHOUT
 * WARRANTY OF ANY KIND, either express or implied.
 *
 ************************************************************************/
 
#ifndef MLP_NETWORK_HPP
#define MLP_NETWORK_HPP
#include "../linalg.hpp"
#include "../linalg/mtx_tmpl.hpp"
 
#include <cassert>
#include <fstream>
#include <random>
#include <stdio.h>
#include <utility>
#include <vector>
 
namespace gpmp {
 
namespace ml {
 
/*
 * TODO
 * Think of using extended or derived classes
 *
 * Weights : MLP
 *
 */
struct neuron {
    // exit
    long double sortir;
    // error
    long double err;
    // weight
    long double *wt;
    // last weight
    long double *wt_last;
    // saved weight
    long double *wt_saved;
};
 
struct layer {
    int64_t num_neurons;
    neuron *neuron_ptr;
};
 
class PrimaryMLP {
    /* initialize random values for the network */
    void rand_init();
    /* check that random is an integer */
    int64_t rand_int(int64_t low, int64_t hi);
    /*check random is a real number */
    long double rand_real(long double low, long double hi);
    /*return the number of layers in the network */
    int64_t num_layers;
    layer *layer_ptr;
    long double _MSE;
    long double _MAE;
 
    void set_signal_in(long double *input);
    void get_signal_out(long double *output);
 
    void weights_save();
    void weights_rand();
    void weights_restore();
    /*adjust weights */
    void weights_adjust();
 
    /* propogate given the signal */
    void prop_signal();
    /* returns the computed output error */
    void output_err(long double *target);
    /* returns the computed error from backwards propogation */
    void back_prop_err();
    /* simulate the Multi-Layer Perceptron Neual Network */
    void simulate(long double *input,
                  long double *output,
                  long double *target,
                  bool training);
 
  public:
    long double _Eta;
    long double _Alpha;
    long double _Gain;
    long double _AvgTestError;
 
    /* CONSTRUCT */
    PrimaryMLP(int64_t nl, int64_t npl[]);
    /* DECONSTRUCT */
    ~PrimaryMLP();
 
    /* method to train the network given data*/
    int64_t train(const char *fnames);
    /* method to test given data*/
    int64_t test(const char *fname);
    int64_t evaluate();
 
    void run(const char *fname, const int64_t &max_iters);
};
 
template <typename T> class SecondaryMLP {
  public:
    void log(auto &file, const auto &x, const auto &y, const auto &y_hat) {
        // mean squared error
        auto mse = (y.data[0] - y_hat.data[0]);
        mse = mse * mse;
        file << mse << " " << x.data[0] << " " << y.data[0] << " "
             << y_hat.data[0] << " \n";
    }
 
    inline long double sigmoid_activ(long double x) {
        return 1.0f / (1 + exp(-x));
    }
 
    inline long double sigmoid_deriv(long double x) {
        return (x * (1 - x));
    }
 
    std::vector<size_t> layer_units;
    std::vector<gpmp::linalg::Matrix<T>> bias_vectors;
    std::vector<gpmp::linalg::Matrix<T>> wt_mtx;
    std::vector<gpmp::linalg::Matrix<T>> activations;
 
    long double lr;
 
    explicit SecondaryMLP(std::vector<size_t> _layer_units,
                          long double _lr = .001)
        : layer_units(_layer_units), wt_mtx(), bias_vectors(), lr(_lr) {
        // traverse the elements
        for (size_t i = 0; i < layer_units.size() - 1; ++i) {
            // size of inputs
            size_t inputs{layer_units[i]};
            // size of outputs
            size_t outputs{layer_units[i + 1]};
 
            // set to random Guassian Noise related values
            // weights
            auto gauss_wt = gpmp::linalg::mtx<T>::randn(outputs, inputs);
            wt_mtx.push_back(gauss_wt);
            // biases
            auto bias_wt = gpmp::linalg::mtx<T>::randn(outputs, 1);
            bias_vectors.push_back(bias_wt);
            // activation function
            activations.resize(layer_units.size());
        }
    }
    auto prop_forwards(gpmp::linalg::Matrix<T> x) {
        assert(std::get<0>(x.shape) == layer_units[0] && std::get<1>(x.shape));
        // input = to previously declared acitvations method
        activations[0] = x;
        gpmp::linalg::Matrix prev(x);
 
        // traverse layer units
        for (uint64_t i = 0; i < layer_units.size() - 1; ++i) {
            gpmp::linalg::Matrix y = wt_mtx[i].mult(prev);
            y = y + bias_vectors[i];
            y = y.apply_function(&SecondaryMLP::sigmoid_activ);
            activations[i + 1] = y;
            prev = y;
        }
        return prev;
    }
    void prop_backwards(gpmp::linalg::Matrix<T> target) {
        assert(std::get<0>(target.shape) == layer_units.back());
        // calculate the error, target - ouput
        auto y = target;
        auto y_hat = activations.back();
        auto err = target - y_hat;
        // back propagate the error calculated from output to input
        // and step the weights
        for (int64_t i = wt_mtx.size() - 1; i >= 0; --i) {
            // calculate errors for previous layer
            auto wt = wt_mtx[i].T();
            auto prior_errs = wt.mult(err);
            auto outputs_d =
                activations[i + 1].apply_function(&SecondaryMLP::sigmoid_deriv);
            auto gradients = err.hadamard(outputs_d);
            gradients = gradients.scalar_mult(lr);
            auto trans_a = activations[i].T();
            auto gradients_wt = gradients.mult(trans_a);
 
            // adjust the networks weights based on propagation
            // technique
            bias_vectors[i] = bias_vectors[i].add(gradients);
            wt_mtx[i] = wt_mtx[i].add(gradients_wt);
            err = prior_errs;
        }
    }
};
 
} // namespace ml
 
} // namespace gpmp
 
#endif