SVMWrapper.h

Go to the documentation of this file.

// --------------------------------------------------------------------------
//                   OpenMS -- Open-Source Mass Spectrometry
// --------------------------------------------------------------------------
// Copyright The OpenMS Team -- Eberhard Karls University Tuebingen,
// ETH Zurich, and Freie Universitaet Berlin 2002-2023.
//
// This software is released under a three-clause BSD license:
//  * Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//  * Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//  * Neither the name of any author or any participating institution
//    may be used to endorse or promote products derived from this software
//    without specific prior written permission.
// For a full list of authors, refer to the file AUTHORS.
// --------------------------------------------------------------------------
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL ANY OF THE AUTHORS OR THE CONTRIBUTING
// INSTITUTIONS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// --------------------------------------------------------------------------
// $Maintainer: Timo Sachsenberg $
// $Authors: Nico Pfeifer, Chris Bielow $
// --------------------------------------------------------------------------
 
#pragma once
 
#include <OpenMS/CONCEPT/Types.h>
#include <OpenMS/CONCEPT/ProgressLogger.h>
#include <OpenMS/DATASTRUCTURES/String.h>
#include <OpenMS/FORMAT/TextFile.h>
#include <OpenMS/SYSTEM/File.h>
#include <OpenMS/MATH/MISC/MathFunctions.h>
 
#include <string>
#include <vector>
#include <map>
#include <cmath>
 
// forward declare svm types
struct svm_problem;
struct svm_parameter;
struct svm_model;
struct svm_node;
 
namespace OpenMS
{
  struct OPENMS_DLLAPI SVMData
  {
    std::vector<std::vector<std::pair<Int, double> > > sequences;
    std::vector<double> labels;
 
    SVMData();
 
    SVMData(std::vector<std::vector<std::pair<Int, double> > >& seqs, std::vector<double>& lbls);
 
    bool operator==(const SVMData& rhs) const;
 
    bool store(const String& filename) const;
 
    bool load(const String& filename);
 
  };
 
  class OPENMS_DLLAPI SVMWrapper :
    public ProgressLogger
  {
public:
 
    enum SVM_parameter_type
    {
      SVM_TYPE, 
      KERNEL_TYPE, 
      DEGREE, 
      C, 
      NU, 
      P, 
      GAMMA, 
      PROBABILITY, 
      SIGMA, 
      BORDER_LENGTH 
    };
 
    enum SVM_kernel_type
    {
      OLIGO = 19,
      OLIGO_COMBINED
    };
 
    SVMWrapper();
 
    ~SVMWrapper() override;
 
    void setParameter(SVM_parameter_type type, Int value);
 
    void setParameter(SVM_parameter_type type, double value);
 
    Int train(struct svm_problem* problem);
 
    Int train(SVMData& problem);
 
    void saveModel(const std::string& modelFilename) const;
 
    void loadModel(const std::string& modelFilename);
 
    void predict(struct svm_problem* problem, std::vector<double>& predicted_labels);
 
    void predict(const SVMData& problem, std::vector<double>& results);
 
    Int getIntParameter(SVM_parameter_type type);
 
    double getDoubleParameter(SVM_parameter_type type);
 
    void createRandomPartitions(svm_problem* problem, Size number, std::vector<svm_problem*>& partitions);
 
    void createRandomPartitions(const SVMData& problem,
                                       Size number,
                                       std::vector<SVMData>& problems);
    static svm_problem* mergePartitions(const std::vector<svm_problem*>& problems, Size except);
 
    static void mergePartitions(const std::vector<SVMData>& problems,
                                Size                                            except,
                                SVMData& merged_problem);
 
    void predict(const std::vector<svm_node*>& vectors, std::vector<double>& predicted_rts);
 
    static void getLabels(svm_problem* problem, std::vector<double>& labels);
 
    double performCrossValidation(svm_problem* problem_ul,
                                      const SVMData& problem_l,
                                      const bool                                        is_labeled,
                                      const   std::map<SVM_parameter_type, double>& start_values_map,
                                      const   std::map<SVM_parameter_type, double>& step_sizes_map,
                                      const   std::map<SVM_parameter_type, double>& end_values_map,
                                      Size                                                                                number_of_partitions,
                                      Size                                                                                  number_of_runs,
                                      std::map<SVM_parameter_type, double>& best_parameters,
                                      bool                                                                                            additive_step_sizes = true,
                                      bool                                                                                        output = false,
                                      const String&                                                                                      performances_file_name = "performances.txt",
                                      bool                                                                                            mcc_as_performance_measure = false);
 
 
    double getSVRProbability();
 
    static double kernelOligo(const std::vector<std::pair<int, double> >& x,
                                  const std::vector<std::pair<int, double> >& y,
                                  const std::vector<double>& gauss_table,
                                  int                                                                     max_distance = -1);
 
    static double kernelOligo(const svm_node* x, const svm_node* y, const std::vector<double>& gauss_table, double sigma_square = 0, Size    max_distance = 50);
 
    void getSignificanceBorders(svm_problem* data, std::pair<double, double>& borders, double confidence = 0.95, Size number_of_runs = 5, Size number_of_partitions = 5, double step_size = 0.01, Size max_iterations = 1000000);
 
    void getSignificanceBorders(const SVMData& data,
                                std::pair<double, double>& sigmas,
                                double confidence = 0.95,
                                Size number_of_runs = 5,
                                Size number_of_partitions = 5,
                                double step_size = 0.01,
                                Size max_iterations = 1000000);
 
    double getPValue(double sigma1, double sigma2, std::pair<double, double> point);
 
    void getDecisionValues(svm_problem* data, std::vector<double>& decision_values);
 
    void scaleData(svm_problem* data, Int max_scale_value = -1);
 
    static void calculateGaussTable(Size border_length, double sigma, std::vector<double>& gauss_table);
 
    svm_problem* computeKernelMatrix(svm_problem* problem1, svm_problem* problem2);
 
    svm_problem* computeKernelMatrix(const SVMData& problem1, const SVMData& problem2);
 
    void setTrainingSample(svm_problem* training_sample);
 
    void setTrainingSample(SVMData& training_sample);
 
    void getSVCProbabilities(struct svm_problem* problem, std::vector<double>& probabilities, std::vector<double>& prediction_labels);
 
    void setWeights(const std::vector<Int>& weight_labels, const std::vector<double>& weights);
 
private:
    bool nextGrid_(const std::vector<double>& start_values,
                   const std::vector<double>& step_sizes,
                   const std::vector<double>& end_values,
                   const bool additive_step_sizes,
                   std::vector<double>& actual_values);
 
    Size getNumberOfEnclosedPoints_(double m1, double m2, const std::vector<std::pair<double, double> >& points);
 
    void initParameters_();
 
    static void printToVoid_(const char* /*s*/);
 
    svm_parameter* param_; 
    svm_model* model_; 
    double sigma_; 
    std::vector<double> sigmas_; 
    std::vector<double> gauss_table_; 
    std::vector<std::vector<double> > gauss_tables_; 
    Size kernel_type_; 
    Size border_length_; 
    svm_problem* training_set_ = nullptr; 
    svm_problem* training_problem_ = nullptr; 
    SVMData training_data_; 
    Math::RandomShuffler shuffler_; 
  };
 
} // namespace OpenMS