Model.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//

#ifndef BALL_QSAR_MODEL_H
#define BALL_QSAR_MODEL_H


#ifndef BALL_QSAR_VALIDATION_H
#include <BALL/QSAR/validation.h>
#endif

#ifndef BALL_QSAR_QSARDATA_H
#include <BALL/QSAR/QSARData.h>
#endif

#ifndef BALL_QSAR_EXCEPTION_H
#include <BALL/QSAR/exception.h>
#endif

#ifndef BALL_MATHS_PARSEDFUNCTION_H
#include <BALL/MATHS/parsedFunction.h>
#endif

#include <vector>
#include <set>

#include <Eigen/Core>

namespace BALL
{
  namespace QSAR
  {
    class BALL_EXPORT Model
    {
      public:
        Model(const QSARData& q);

        virtual ~Model();

        virtual void operator=(const Model& m);

        EIGEN_MAKE_ALIGNED_OPERATOR_NEW


        void copyData(const Model& m);
        
        void copyDescriptorIDs(const Model& m);


        void readTrainingData();
        
        
        virtual Eigen::VectorXd predict(const vector<double>& substance, bool transform) =0; 
        
        void deleteDescriptorIDs();
      
        virtual void train() =0;
        
        
        virtual bool optimizeParameters(int /*k*/, int /*no_steps*/){return 0;};
        
        bool optimizeParameters(int k);
        
        virtual double calculateStdErr()
        {return -1.0;};
        
        virtual void setParameters(vector<double>& /*v*/){};
        
        virtual vector<double> getParameters() const;

        std::multiset<unsigned int>* getDescriptorIDs();
        
        void setDataSource(const QSARData* q);
        
        virtual void saveToFile(string filename) = 0;
        
        virtual void readFromFile(string filename) = 0;
        
        const Eigen::MatrixXd* getDescriptorMatrix();
        
        const vector<string>* getSubstanceNames();
        
        const vector<string>* getDescriptorNames();

        const Eigen::MatrixXd getDescriptorTransformations();

        const Eigen::MatrixXd getYTransformations();

        const Eigen::MatrixXd* getY();
        
        void setDescriptorIDs(const std::multiset<unsigned int>& sl);
        
        const string* getType();
        
        void getUnnormalizedFeatureValue(int compound, int feature, double& return_value);
        
        void getUnnormalizedResponseValue(int compound, int response, double& return_value);
        
        
        const QSARData* data;
        
        Validation* model_val;
        
        
      protected:
        
        int default_no_opt_steps_; 
      
        Eigen::VectorXd getSubstanceVector(const vector<double>& substance, bool transform);
        
        Eigen::VectorXd getSubstanceVector(const Eigen::VectorXd& substance, bool transform);
        
        void backTransformPrediction(Eigen::VectorXd& pred);
        
        void addLambda(Eigen::MatrixXd& matrix, double& lambda);
        
        void readDescriptorInformation();
        
        
        void readMatrix(Eigen::MatrixXd& mat, std::ifstream& in, unsigned int lines, unsigned int col);
        
        void readVector(Eigen::RowVectorXd& vec, std::ifstream& in, unsigned int no_cells, bool column_vector);
        
        void readModelParametersFromFile(std::ifstream& in);
        void saveModelParametersToFile(std::ofstream& out);
        
        
        virtual void saveDescriptorInformationToFile(std::ofstream& out);
        virtual void readDescriptorInformationFromFile(std::ifstream& in, int no_descriptors, bool transformation);
        
        void readResponseTransformationFromFile(std::ifstream& in, int no_y);
        void saveResponseTransformationToFile(std::ofstream& out);
        
        
        Eigen::MatrixXd descriptor_matrix_;
          
        vector<string> substance_names_;
  
        vector<string> descriptor_names_;
        
        Eigen::MatrixXd descriptor_transformations_;
        
        Eigen::MatrixXd y_transformations_;
        
        Eigen::MatrixXd Y_;

        String type_;
        
        std::multiset<unsigned int> descriptor_IDs_;      
        
        friend class Validation;
        friend class RegressionValidation;
        friend class ClassificationValidation;
        friend class PCRModel;
        friend class KPCRModel;
        friend class FeatureSelection;
    };
    
    BALL_EXPORT Model* createNewModelFromFile(String model_file, const QSARData& q);
  }
}

#endif // BALL_QSAR_MODEL_H