PercolatorReset.h File Reference

#include <OpenMS/CONCEPT/Types.h>
#include <OpenMS/DATASTRUCTURES/TypeAliases.h>
#include <cstdint>
#include <optional>
#include <string>
#include <vector>

Go to the source code of this file.

Classes
class	PercolatorReset
	Percolator-RESET: semi-supervised rescoring with FDR control at the peptide (stem) level. More...
struct	PercolatorReset::Input
	Rows: one per PSM (all hits of all spectra), in any order. More...
struct	PercolatorReset::Options
struct	PercolatorReset::Stem
	One considered or dropped stem. More...
struct	PercolatorReset::AuditFeature
struct	PercolatorReset::Output

Namespaces
namespace	OpenMS
	Main OpenMS namespace.

---

Class Documentation

OpenMS::PercolatorReset::Options

struct OpenMS::PercolatorReset::Options

Class Members
bool	audit = false	run the feature-symmetry audit
vector< double >	c_values = {0.1, 1.0, 10.0}	grid for C+ and C- (all pairs)
int	decoy_databases = 1	decoy databases searched: 1 (default) or 2 (two-decoy mode, see the class description; needs Input::decoy_set)
int	iterations = 25	training rounds (5 in the paper; they do not converge on DIA data)
string	learner = "svm"	"svm" (linear) or "mlp" (small MLP ensemble, experimental)
bool	mlp_crossfit = true	MLP cross-fitting: the stems (folds fixed by a hash of salt and sequence) are scored by the ensemble of the chosen C pair that did not train on their fold, in every round and at the end (no final fit); otherwise one final ensemble trained on all training stems scores everything, which ranks the training decoys it trained on too low
int	mlp_epochs = 30	MLP training epochs (the first round, or every round without warm starts)
int	mlp_hidden = 16	MLP hidden units (two hidden layers)
int	mlp_members = 8	MLP ensemble size.
int	mlp_norm_min_decoys = 1000	MLP cross-fitting: the fold ensembles' scores are normalized (as Percolator's folds: the fold's score at train_fdr against its training decoys -> 0, its median training decoy -> -1) only if every fold has at least this many training decoys (0 = always)
int	mlp_warm_epochs = 3	MLP warm starts: > 0 = the networks of each cross-validation task and of the final model continue from the previous round for this many epochs (a stem keeps its fold over the rounds); 0 = trained afresh every round
string	representative = "model"	"model" (default): after each round a stem is represented by its PSM with the best score under the new model; "search": by its PSM with the best search engine score (the paper). With "model" masking holds, but the FDR also needs null targets and decoys to be exchangeable over their whole PSM collections, including their sizes (a null target with many more PSMs than a decoy gains from the maximum); entrapment validation decides.
optional< uint64_t >	salt	coin salt (never pick the best of several salts); unset = a fresh random salt, recorded in Output::salt
int	threads = 1	threads for the cross-validation solves
double	train_fdr = 0.01	FDR for the positive set and for the cross-validation counts.
vector< string >	zero_features = {"enzInt"}	features set to 0 (target-biased, as in the paper)

OpenMS::PercolatorReset::Stem

struct OpenMS::PercolatorReset::Stem

One considered or dropped stem.

Class Members
bool	considered = false	ranked (always true: PSM-only protocol; kept for the stem table format)
bool	decoy = false	label of the search-score representative; fixed (masking) even if representative "model" later picks a PSM of the other label
double	q_value = 1.0	RESET q-value (1 for training decoys and stems not considered)
Size	representative = 0	row of the stem's best PSM (by search engine score)
Role	role = Role::TARGET
double	score = 0.0	final model score of the representative
double	search_score = 0.0	search engine score of the representative
string	stem	unmodified sequence

OpenMS::PercolatorReset::AuditFeature

struct OpenMS::PercolatorReset::AuditFeature

Class Members
double	auc = 0.5	P(training decoy > null proxy) + P(=) / 2.
bool	flagged = false
double	ks = 0.0	Kolmogorov-Smirnov statistic.
string	name

OpenMS::PercolatorReset::Output

struct OpenMS::PercolatorReset::Output

Class Members
vector< AuditFeature >	audit
Size	audit_decoys = 0
bool	audit_flagged = false
double	audit_multivariate_auc = 0.5
Size	audit_proxy = 0	audit group sizes (training decoys, null proxy)
double	audit_proxy_ratio = 0.0	null-proxy stems per training decoy in the audit (about 3 if all null)
Size	decoy_stems = 0
Size	decoy_stems_both_sets = 0
Size	decoy_stems_second_set = 0	two-decoy mode: considered decoy stems whose representative is a decoy of the second set (about half of decoy_stems if the two sets are exchangeable), and those whose representative is in both sets (Input::decoy_set 3; should be rare: a decoy sequence shared by the sets is one decoy, not two, for its spectra)
Size	discoveries_1pct = 0	target stems with q <= 0.01
Size	estimating_decoys = 0
string	learner
string	learner_settings	learner "mlp": its settings (for reports); empty for "svm"
vector< double >	psm_peps	per row, heuristic PSM-level posterior error probability: f p / (1 - p) (at most 1; f = 2, or 1 in two-decoy mode, where shared decoy stems count twice), with p the estimating-decoy fraction of the ranked PSMs by isotonic (antitonic in score) regression. 1 where q is 1 by definition (other hits, training decoys).
vector< double >	psm_q_values	per row, heuristic PSM-level q-value: per spectrum, the hit with the best search engine score is the PSM (the competition that selects the stems' PSMs, so a stem's representative is always reported); PSMs of training-decoy sequences (decoy rows whose sequence's coin is "training") are dropped, and the remaining PSMs (targets, estimating decoys) get q = min over lower ranks of 2 (D_est + 1) / max(T, 1) (two-decoy mode: (D_est + 1) / max(T, 1); with shared decoy stems, as the final ranking, (sum of the decoy weights + 2) / max(T, 1)). 1 for the other hits and for training decoys. Not FDR-controlled (multiplicity of PSMs per peptide).
vector< Role >	roles	per row: role of the row's stem
vector< string >	rounds	training summary per round: chosen C+, C-, held-out discoveries, positives
uint64_t	salt = 0	the effective salt and the learner (for reports)
vector< double >	scores	per row: score of the final model (all rows, also those that lost a competition)
vector< double >	stem_q_values	per row: q-value of the row's stem (Stem::q_value)
vector< Stem >	stems	all stems (considered or not)
Size	target_stems = 0
Size	training_decoys = 0
vector< string >	used_features	features the learner used (non-constant, not zeroed)
vector< double >	weights	linear learner: raw-feature weights of the final model, bias last