SimpleSVM.h

Go to the documentation of this file.

// Copyright (c) 2002-present, OpenMS Inc. -- EKU Tuebingen, ETH Zurich, and FU Berlin
// SPDX-License-Identifier: BSD-3-Clause
//
// --------------------------------------------------------------------------
// $Maintainer: Hendrik Weisser $
// $Authors: Hendrik Weisser $
// --------------------------------------------------------------------------
 
#pragma once
 
#include <OpenMS/DATASTRUCTURES/DefaultParamHandler.h>
 
#include <svm.h>
 
#include <map>
#include <vector>
#include <utility> // for "pair"
#include <tuple>
 
namespace OpenMS
{
  class OPENMS_DLLAPI SimpleSVM :
    public DefaultParamHandler
  {
 
  public:
    typedef std::map<String, std::vector<double> > PredictorMap;
 
    typedef std::map<String, std::pair<double, double> > ScaleMap;
 
    struct Prediction
    {
      double outcome;
 
      std::map<double, double> probabilities;
    };
 
    SimpleSVM();
 
    ~SimpleSVM() override;
 
    void setup(PredictorMap& predictors, const std::map<Size, double>& outcomes, bool classification = true);
 
    void predict(std::vector<Prediction>& predictions,
                 std::vector<Size> indexes = std::vector<Size>()) const;
 
    void predict(PredictorMap& predictors, std::vector<Prediction>& predictions) const;
 
    void getFeatureWeights(std::map<String, double>& feature_weights) const;
 
    void writeXvalResults(const String& path) const;
 
    const ScaleMap& getScaling() const;
 
  protected:
    void clear_();
 
    typedef std::vector<std::vector<std::vector<double>>> SVMPerformance;
 
    std::vector<std::vector<struct svm_node> > nodes_;
 
    struct svm_problem data_;
 
    struct svm_parameter svm_params_;
 
    struct svm_model* model_;
 
    std::vector<String> predictor_names_;
 
    Size n_parts_;
 
    std::vector<double> log2_C_, log2_gamma_, log2_p_;
 
    ScaleMap scaling_;
 
    SVMPerformance performance_;
 
    static void printNull_(const char*) {}
 
    void scaleData_(PredictorMap& predictors);
 
    void convertData_(const PredictorMap& predictors);
 
    std::tuple<double, double, double> chooseBestParameters_(bool higher_better) const;
 
    void optimizeParameters_(bool classification);
  };
}