regressionValidation.h

Go to the documentation of this file.

/* regressionValidation.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 REGVALIDATION
#define REGVALIDATION

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

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

#include <gsl/gsl_randist.h>
#include <gsl/gsl_cdf.h>
#include <iterator>


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



namespace BALL
{ 
  namespace QSAR
  {
    class RegressionModel;
    class BALL_EXPORT RegressionValidation : public Validation
    { 
      public:
        RegressionValidation(RegressionModel* m);

        ~RegressionValidation();
        
        
        void crossValidation(int k, bool restore=1);
        
        void crossValidation(int k, vector<BALL::Matrix<double> >* results, bool restore=1);
        
        
        void bootstrap(int k, bool restore=1);
        
        void bootstrap(int k, vector<BALL::Matrix<double> >* results, bool restore=1);
        
        void bootstrap1(int k, vector<BALL::Matrix<double> >* results, bool restore=1);
        
        const BALL::Matrix<double>& yRandomizationTest(int runs, int k);
        
        double getQ2();
        
        double getR2();   
        
        double getFregr();
            
        double getFcv();
        
        double getCVRes();
        
        double getFitRes();
        
        double getMaxError();
        
        void setCVRes(double d);
    
        void setQ2(double d);
        
        void testInputData(bool transform=0);
        
        void selectStat(int s);
        
        void calculateCoefficientStdErrors(int k, bool b=1);
      
        const BALL::Matrix<double>* getCoefficientStdErrors();
        
        void setCoefficientStdErrors(const BALL::Matrix<double>* stddev);
        
        void saveToFile(string filename) const;
        
        void saveToFile(string filename, const double& r2, const double& q2, const Matrix<double>& coefficient_stddev, const Matrix<double>& yRand_results) const;
        
        void readFromFile(string filename);
        
  
      private:
        
        struct BackupData
        {
          Matrix<double> descriptor_matrix;
          Matrix<double> training_result;
          Matrix<double> Y;
          Matrix<double> K;
          Matrix<double> latent_variables;
          Matrix<double> loadings;
          Matrix<double> weights;
        };
        
        
        void testAllSubstances(bool transform);
        
        void backupTrainingResults();
        
        void restoreTrainingResults();
        
        
        
        double ssR_;
        
        double ssE_;
        
        double ssY_;
        
        double std_err_;
  
        double Q2_;
  
        double F_cv_;
        
        double F_regr_;
  
        double R2_;
        
        double max_error_;
        
        double quality_;
        
        double (RegressionValidation::* predQualFetcher_)();
        
        double (RegressionValidation::* fitQualFetcher_)();
        
        void calculateQOF();
        
        BALL::Matrix<double> coefficient_stderr_;
        
        RegressionModel* regr_model_;
        
        BackupData backup_data_;
        
        void (RegressionValidation::* qualCalculation)();
        
    };
  }
}



#endif // REGVALIDATION