Model.hpp

#ifndef MODEL
#define MODEL

#include <boost/filesystem.hpp>

#include<iomanip>
#include<fstream>
#include<iostream>

#include <feature_creation/node/FeatureNode.hpp>

/**
 * @brief Class to store the models found from SISSO
 *
 */
class Model
{
    int _n_samp_train; //!< The number of samples per feature
    int _n_samp_test; //!< The number of test samples per feature
    int _n_dim; //!< Dimension of the model

    std::vector<node_ptr> _feats; //!< List of features in the model

    std::vector<std::vector<double>> _coefs; //!< Coefficients for teh features
    std::vector<double> _prop_train; //!< The property to be modeled
    std::vector<double> _prop_test; //!< The property to be modeled
    std::vector<double> _train_error; //!< The error of the model
    std::vector<double> _test_error; //!< The error of the model
    std::vector<double> _D_train; //!< The Descriptor matrix
    std::vector<double> _D_test; //!< The Descriptor matrix

    std::vector<double> _prop_train_est; //!< The estimated Property
    std::vector<double> _prop_test_est; //!< The estimated Property

    std::vector<int> _task_sizes_train; //!< Number of samples in each task
    std::vector<int> _task_sizes_test; //!< Number of samples in each task
public:
    /**
     * @brief Constructor for the model
     *
     * @param prop The property
     * @param feats The features for the model
     */
    Model(std::vector<double> prop_train, std::vector<double> prop_test, std::vector<node_ptr> feats, std::vector<int> task_sizes_train, std::vector<int> task_sizes_test);


    /**
     * @brief Convert the model to a string

     * @return The string of the model
     */
    std::string toString() const;

    /**
     * @brief Accessor function to _prop_est
     */
    inline std::vector<double>& predict(){return _prop_test_est;}

    /**
     * @brief Accessor function to _prop_est
     */
    inline std::vector<double>& predict_train(){return _prop_train_est;}

    /**
     * @brief Copy the error into a new array
     *
     * @param res pointer to the beginning of the array
     */
    inline void copy_error(double* res){std::copy_n(_train_error.data(), _n_samp_train, res);}

    /**
     * @brief The rmes of the model
     */
    inline double rmse(){return util_funcs::norm(_train_error.data(), _n_samp_train) / std::sqrt(static_cast<double>(_n_samp_train));}
    inline double test_rmse(){return util_funcs::norm(_test_error.data(), _n_samp_test) / std::sqrt(static_cast<double>(_n_samp_test));}

    /**
     * @brief The max Absolute error of the array
     */
    inline double max_ae()
    {
        return std::abs(*std::max_element(_train_error.data(), _train_error.data() + _n_samp_train, [](double d1, double d2){return std::abs(d1) < std::abs(d2);}));
    }

    inline double test_max_ae()
    {
        return std::abs(*std::max_element(_test_error.data(), _test_error.data() + _n_samp_test, [](double d1, double d2){return std::abs(d1) < std::abs(d2);}));
    }


    /**
     * @brief Print model to a file
     */
    void test_to_file(std::string filename, std::vector<int> test_inds);

    /**
     * @brief Print model to a file
     */
    void train_to_file(std::string filename);
};

/**
 * @brief Print a model to an string stream
 *
 * @param outStream The output stream the model is to be printed
 * @param model The model to be printed
 */
std::ostream& operator<< (std::ostream& outStream, const Model& model);

#endif