PercolatorReset.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: Timo Sachsenberg $
// $Authors: Oliver Kohlbacher $
// --------------------------------------------------------------------------
 
#pragma once
 
#include <OpenMS/CONCEPT/Types.h>
#include <OpenMS/DATASTRUCTURES/TypeAliases.h>
 
#include <cstdint>
#include <optional>
#include <string>
#include <vector>
 
namespace OpenMS
{
  class OPENMS_DLLAPI PercolatorReset
  {
  public:
    struct Input
    {
      std::vector<std::vector<double>> features;
      std::vector<double> feature_matrix;
      std::vector<std::string> feature_names;    
      std::vector<bool> is_decoy;                
      std::vector<double> search_scores;         
      std::vector<Size> spectrum;                
      std::vector<std::string> stems;            
      std::vector<char> decoy_set;
 
      Size rowCount() const
      {
        return features.empty() && !feature_matrix.empty() ? is_decoy.size() : features.size();
      }
 
      const double* row(Size i) const
      {
        return !features.empty() ? features[i].data() : feature_matrix.data() + i * feature_names.size();
      }
    };
 
    struct Options
    {
      std::optional<std::uint64_t> salt;
      int iterations = 25;              
      double train_fdr = 0.01;          
      std::vector<double> c_values = {0.1, 1.0, 10.0}; 
      std::string learner = "svm";      
      std::string representative = "model";
      bool audit = false;               
      int decoy_databases = 1;
      std::vector<std::string> zero_features = {"enzInt"}; 
      int threads = 1;                  
      int mlp_members = 8;              
      int mlp_hidden = 16;              
      int mlp_epochs = 30;              
      int mlp_warm_epochs = 3;
      bool mlp_crossfit = true;
      int mlp_norm_min_decoys = 1000;
    };
 
    enum class Role : int { TARGET = 0, ESTIMATING_DECOY = 1, TRAINING_DECOY = 2 };
 
    struct Stem
    {
      std::string stem;           
      Size representative = 0;    
      bool decoy = false;         
      Role role = Role::TARGET;
      bool considered = false;    
      double search_score = 0.0;  
      double score = 0.0;         
      double q_value = 1.0;       
    };
 
    struct AuditFeature
    {
      std::string name;
      double auc = 0.5;  
      double ks = 0.0;   
      bool flagged = false;
    };
 
    struct Output
    {
      std::vector<double> scores;
      std::vector<double> psm_q_values;
      std::vector<double> psm_peps;
      std::vector<double> stem_q_values;
      std::vector<Role> roles;
      std::vector<Stem> stems;
      std::vector<AuditFeature> audit;
      double audit_multivariate_auc = 0.5;
      bool audit_flagged = false;
      double audit_proxy_ratio = 0.0; 
      Size audit_decoys = 0, audit_proxy = 0; 
      std::vector<std::string> rounds;
      Size target_stems = 0, decoy_stems = 0, training_decoys = 0, estimating_decoys = 0;
      Size decoy_stems_second_set = 0, decoy_stems_both_sets = 0;
      Size discoveries_1pct = 0;  
      std::vector<std::string> used_features; 
      std::vector<double> weights;            
      std::uint64_t salt = 0;                 
      std::string learner;
      std::string learner_settings;           
    };
 
    static Output run(const Input& input, const Options& options);
 
    static std::vector<double> seqStepQValues(const std::vector<bool>& is_decoy, double factor, double plus_one);
 
    static bool isTrainingDecoy(std::uint64_t salt, const std::string& stem);
  };
}