Model.h

Go to the documentation of this file.

/* Model.h
 * 
 * Copyright (C) 2009 Marcel Schumann
 * 
 * This file is part of QuEasy -- A Toolbox for Automated QSAR Model
 * Construction and Validation.
 * QuEasy is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or (at
 * your option) any later version.
 * 
 * QuEasy is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//
//
#ifndef MODEL
#define MODEL

#include <vector>
#include <set>

#include <BALL/MATHS/LINALG/matrix.h>

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

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

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

#include <BALL/MATHS/parsedFunction.h>

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

        virtual ~Model();
        
        virtual void operator=(const Model& m);
        
        
        void copyData(const Model& m);
        
        void copyDescriptorIDs(const Model& m);
        
        
        void readTrainingData();
        
        
        virtual Vector<double> 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 Matrix<double>* getDescriptorMatrix();
        
        const vector<string>* getSubstanceNames();
        
        const vector<string>* getDescriptorNames();
        
        const Matrix<double>* 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_; 
      
        Vector<double> getSubstanceVector(const vector<double>& substance, bool transform);
        
        Vector<double> getSubstanceVector(const Vector<double>& substance, bool transform);
        
        void backTransformPrediction(Vector<double>& pred);
        
        void addLambda(Matrix<double>& matrix, double& lambda);
        
        void readDescriptorInformation();
        
        
        void readMatrix(Matrix<double>& mat, std::ifstream& in, uint lines, uint col);
        
        void readVector(Vector<double>& vec, std::ifstream& in, uint 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);
        
        
        Matrix<double> descriptor_matrix_;
          
        vector<string> substance_names_;
  
        vector<string> descriptor_names_;
        
        Matrix<double> descriptor_transformations_;
        
        Matrix<double> y_transformations_;
        
        Matrix<double> Y_;

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

#endif // MODEL