OpenMS
Loading...
Searching...
No Matches
OpenSwathPercolatorScoring

Rescore OpenSWATH OSW / OSWPQ peak groups and transitions with the in-process OpenMS Percolator implementation.

OpenSwathPercolatorScoring operates directly on existing OpenSWATH result containers:

  • SQLite OSW files (.osw)
  • OpenSWATH Parquet archives or directories (.oswpq)

One or more scoring levels can be requested sequentially via level:

  • ms1 rescoring writes SCORE_MS1 or score_ms1_*
  • ms2 rescoring writes SCORE_MS2 or score_ms2_*
  • ms1ms2 combines MS2 and MS1 features and writes SCORE_MS2 or score_ms2_*
  • transition rescoring writes SCORE_TRANSITION or score_transition_*

Rows with missing active VAR_* features are excluded from rescoring rather than being imputed to zero. Peak-group q-values and PEPs are estimated from the top-ranked target/decoy peak groups and then propagated back onto all scored candidates, mirroring PyProphet's OpenSWATH scoring semantics.

If out is empty, the input is updated in place. Otherwise the input is first copied to out and all requested rescoring passes are applied there.

Transition rescoring requires prior precursor-level scores in the same file. Starting from an unscored result, run either -level ms2 transition or -level ms1ms2 transition in one invocation.

The command line parameters of this tool are:

OpenSwathPercolatorScoring -- Rescore OpenSWATH OSW / OSWPQ results with in-process Percolator.
Full documentation: http://www.openms.de/doxygen/nightly/html/TOPP_OpenSwathPercolatorScoring.html
Version: 3.7.0-pre-nightly-2026-11-13 Nov 14 2026, 01:17:51, Revision: 339429f
To cite OpenMS:
 + Pfeuffer, J., Bielow, C., Wein, S. et al.. OpenMS 3 enables reproducible analysis of large-scale mass spec
   trometry data. Nat Methods (2024). doi:10.1038/s41592-024-02197-7.

Usage:
  OpenSwathPercolatorScoring <options>

Options (mandatory options marked with '*'):
  -in <file>*                                     Input OpenSWATH result file (.osw) or OSWPQ parquet archive
                                                  /directory (.oswpq). (valid formats: 'osw', 'oswpq')
  -out <file>                                     Optional output path. If empty, the input is updated in 
                                                  place. (valid formats: 'osw', 'oswpq')
  -level <levels>                                 One or more scoring levels to run sequentially. Use 'ms2 
                                                  transition' or 'ms1ms2 transition' to derive peak-group 
                                                  and transition scores from an unscored input. (default: 
                                                  '[ms1ms2]') (valid: 'ms1', 'ms2', 'ms1ms2', 'transition')
  -training_main_score <text>                     Peak-group score that selects the best peak group of each 
                                                  precursor for the Percolator training set of ms1, ms2 and 
                                                  ms1ms2 rescoring (prefix '-' if lower values are better). 
                                                  The training set holds these peak groups plus all peak grou
                                                  ps of precursors drawn at random, up to percolator:subset_m
                                                  ax_train further peak groups (0: train on all peak groups);
                                                   the model then scores all peak groups. If the score is 
                                                  not among the features, all peak groups are used. (default:
                                                   'var_xcorr_shape')

transition:
  -transition:peakgroup_max_rank <number>         Transition scoring: maximum MS2 peak-group rank retained 
                                                  for transition rescoring. (default: '1') (min: '1')
  -transition:peakgroup_max_pep <value>           Transition scoring: maximum MS2 peak-group PEP retained 
                                                  for transition rescoring. (default: '0.7') (min: '0.0' max:
                                                   '1.0')
  -transition:max_isotope_overlap <value>         Transition scoring: maximum transition isotope-overlap scor
                                                  e retained for rescoring. (default: '0.5') (min: '0.0')
  -transition:min_log_sn <value>                  Transition scoring: minimum log signal-to-noise score retai
                                                  ned for rescoring. (default: '0.0')

percolator:
  -percolator:c_pos <value>                       Positive regularization constant (C+). (default: '0.1') 
                                                  (min: '0.0')
  -percolator:c_neg <value>                       Negative regularization constant (C-). 0 = auto-select. 
                                                  (default: '0.0') (min: '0.0')
  -percolator:test_fdr <value>                    Test FDR threshold for SVM direction selection. (default: 
                                                  '0.01') (min: '0.0' max: '1.0')
  -percolator:train_fdr <value>                   Training FDR for SVM iterations. (default: '0.01') (min: 
                                                  '0.0' max: '1.0')
  -percolator:num_iterations <number>             Number of SVM training iterations. (default: '10') (min: 
                                                  '1')
  -percolator:initial_direction <text>            Feature name to use as the initial scoring direction. Prefi
                                                  x with '-' if LOWER values are more target-like (e.g. 'COME
                                                  T:lnExpect' means higher is better; '-COMET:lnExpect' means
                                                   lower is better). Leave empty (default) to let Percolator 
                                                  auto-select by testing every feature in both directions 
                                                  and picking the one that separates the most targets at trai
                                                  n_fdr.
  -percolator:pep_method <choice>                 Posterior error probability estimator: 'logistic_regression
                                                  ' (target-decoy competition + isotonic fit; legacy name, 
                                                  not actually logistic regression), 'isotonic' (target-q 
                                                  → pep monotone regression), or 'nonparametric' (kernel 
                                                  smoothing). (default: 'logistic_regression') (valid: 'logis
                                                  tic_regression', 'isotonic', 'nonparametric')
  -percolator:seed <number>                       Random seed for CV splitting. (default: '1')
  -percolator:target_decoy_metavalue <text>       Meta-value on PeptideHit indicating target/decoy ('target'/
                                                  'decoy'). (default: 'target_decoy')
  -percolator:normalizer <choice>                 Feature normalizer: 'stdv' (zero-mean, unit-stdv, default),
                                                   'uni' (min/max), or 'none' (no normalization). (default: 
                                                  'stdv') (valid: 'stdv', 'uni', 'none')
  -percolator:train_best_positive <choice>        During TRAINING, use only the best-scoring target PSM per 
                                                  spectrum (file and ScanNr; with cv_group_keys: per group) 
                                                  as a positive example, if it passes train_fdr. Affects the 
                                                  SVM (weights change). Orthogonal to post_processing_tdc. 
                                                  Default is 'true' because typical OpenMS inputs are multi-h
                                                  it-per-spectrum (Comet/MSGF+/Sage top-N, OSW peak groups). 
                                                  Inert on one-hit-per-spectrum inputs. Note: the upstream 
                                                  percolator binary defaults this to off — PercolatorAdapte
                                                  r preserves the CLI contract by mirroring its flag state 
                                                  when writing this param. (default: 'true') (valid: 'true', 
                                                  'false')
  -percolator:post_processing_tdc <choice>        AFTER training, before PEP/q-value calculation, apply Targe
                                                  t-Decoy Competition: keep only the highest-scoring PSM per 
                                                  (scan, mass, charge) and drop the rest from the score set. 
                                                  Does NOT touch the SVM — only the score distribution used
                                                   for FDR. Default is 'true' because without TDC on multi-hi
                                                  t input, q-values count every candidate as an independent 
                                                  'chance' and drift optimistic. Inert on one-hit-per-spectru
                                                  m inputs. Note: the upstream percolator binary defaults 
                                                  this to off — PercolatorAdapter preserves the CLI contrac
                                                  t by mirroring its flag state when writing this param. (def
                                                  ault: 'true') (valid: 'true', 'false')
  -percolator:nested_xval_bins <number>           Number of nested CV bins for grid search of Cpos/Cneg. Upst
                                                  ream default for cross validation is 3; 1 disables nested 
                                                  search. (default: '1') (min: '1')
  -percolator:subset_max_train <number>           Cap on the training set size (0 = use all). Default 100000 
                                                  bounds training time on very large inputs (>1M PSMs) at 
                                                  negligible quality loss. Sampling is reservoir-based, keyed
                                                   by (scan, exp_mass) so all PSMs sharing a spectrum travel 
                                                  together; the trained model is then applied to ALL input 
                                                  rows via a second scoring pass (matches upstream Caller.cpp
                                                   behavior). Inert when the input size is at or below the 
                                                  cap. Note: upstream percolator binary defaults this to 0 
                                                  — PercolatorAdapter preserves the CLI contract by passing
                                                   its own int option (CLI default 0) through to this param. 
                                                  (default: '100000') (min: '0')
  -percolator:subset_mode <choice>                How rescore() trains when subset_max_train caps the trainin
                                                  g set. 'in_sample' (default, as the percolator executable's
                                                   --subset-max-train): the cross-validation runs on the samp
                                                  le, and all rows are scored by the average of the fold mode
                                                  ls, so a sampled row is scored by two models that trained 
                                                  on it. 'out_of_fold': every spectrum (spectrum file, scan) 
                                                  is assigned to one of the cross-validation folds first; a 
                                                  seeded random sample of whole spectra of at most subset_max
                                                  ...
                                                  Inert when the input has at most subset_max_train rows. 
                                                  (default: 'in_sample') (valid: 'in_sample', 'out_of_fold', 
                                                  'out_of_fold_avg', 'learning_curve')
  -percolator:report_as_main_score <choice>       Which Percolator output to stamp as the main PeptideHit 
                                                  score after rescoring. 'none' (default) leaves hit.getScore
                                                  () and the PeptideIdentification score_type untouched — 
                                                  callers who want the original search score preserved (or 
                                                  who run their own post-processing like PercolatorAdapter) 
                                                  rely on this. 'q-value' sets main score to the PSM-level 
                                                  q-value and marks higher_score_better=false. 'pep' sets 
                                                  main score to the PEP and marks higher_score_better=false. 
                                                  ...
                                                   regardless of this setting. (default: 'none') (valid: 'non
                                                  e', 'q-value', 'pep', 'svm')
  -percolator:num_threads <number>                Maximum number of OpenMP threads for cross-validation; neve
                                                  r more than the threads the tool may use (-threads). With 
                                                  the default settings, cross-validation trains 9 models (3 
                                                  folds x 3 Cneg values) in parallel. Default and range match
                                                   upstream. A build without OpenMP tasks (cl.exe) runs the 
                                                  models of each fold as a nested loop and may use up to two 
                                                  threads more than this. (default: '3') (min: '1' max: '128'
                                                  )
  -percolator:use_pi0 <choice>                    Pi0 correction of q-values and PEPs (mix-max): 'true' (defa
                                                  ult here) estimates pi0, as PyProphet does, since a target 
                                                  precursor never competes with a decoy; 'false': pi0 = 1 
                                                  (target-decoy FDR); 'auto': Percolator's default, as the 
                                                  percolator executable (pi0 only without 'post_processing_td
                                                  c', for input from separate target and decoy searches). 
                                                  (default: 'true') (valid: 'auto', 'true', 'false')
  -percolator:calc_mass_feature                   RescorePSMs(): train on the CalcMass column too. 'false' 
                                                  (default): as the percolator executable, which reads it as 
                                                  metadata; 'true': the in-process training before OpenMS 
                                                  #10717.
  -percolator:solver <choice>                     Solver of the SVMs of the cross-validation. 'tron' (default
                                                  ): the trust region Newton method (TRON) of Percolator, 
                                                  from 0 in every step. 'newton': the modified finite Newton 
                                                  method of Keerthi & DeCoste (2005) with the explicit Hessia
                                                  n (one pass over the active PSMs per step) and an exact 
                                                  line search, warm-started from the weights of the step befo
                                                  re, with a looser tolerance in all steps but the last; for 
                                                  a given training set it reaches the same optimum as 'tron' 
                                                  ...
                                                   percolator has no such option. (default: 'tron') (valid: 
                                                  'tron', 'newton', 'lda')
  -percolator:algorithm <choice>                  RescorePSMs(): 'percolator' = Percolator's cross-validated 
                                                  PSM-level FDR (default); 'reset' = Percolator-RESET (Percol
                                                  atorReset): FDR control at the peptide (stem = unmodified 
                                                  sequence) level, PSM-level q-values heuristic. rescore() 
                                                  and train()/score() always use Percolator. (default: 'perco
                                                  lator') (valid: 'percolator', 'reset')
  -percolator:peptide_level                       Rescore(): also estimate peptide-level q-values and PEPs 
                                                  as the percolator executable does without -U (its peptide 
                                                  output): after the target-decoy competition the best PSM 
                                                  of each peptide and label (RescoreInput::peptide_keys, the 
                                                  PIN 'Peptide' string between the flanks) is kept and q-valu
                                                  es (pi0 = 1 with post_processing_tdc, as the executable) 
                                                  and PEPs are computed on these peptides (RescoreOutput::pep
                                                  tide_q_values, peptide_peps). rescorePSMs() then writes 
                                                  ...
                                                  (its own peptide-level q-value) or a scorer.

percolator:reset:
  -percolator:reset:salt <text>                   RESET: salt of the decoy coins (an unsigned 64-bit integer)
                                                  . Empty = a fresh random salt per run (recorded in the log 
                                                  and by ProSE in the search parameters). Never choose the 
                                                  best of several salts.
  -percolator:reset:learner <choice>              RESET: 'svm' = linear L2-SVM (default); 'mlp' = ensemble 
                                                  of small MLPs (experimental). (default: 'svm') (valid: 'svm
                                                  ', 'mlp')
  -percolator:reset:mlp_members <number>          RESET learner 'mlp': networks per ensemble. (default: '8') 
                                                  (min: '1')
  -percolator:reset:mlp_hidden <number>           RESET learner 'mlp': units of each of the two hidden layers
                                                  . (default: '16') (min: '1')
  -percolator:reset:mlp_epochs <number>           RESET learner 'mlp': training epochs of the first round 
                                                  (of every round without warm starts). (default: '30') (min:
                                                   '1')
  -percolator:reset:mlp_warm_epochs <number>      RESET learner 'mlp': > 0 = warm starts: the networks contin
                                                  ue from the previous round for this many epochs; 0 = traine
                                                  d afresh every round. (default: '3') (min: '0')
  -percolator:reset:mlp_crossfit <choice>         RESET learner 'mlp': score each stem by the networks that 
                                                  did not train on it (3 folds by a hash of the sequence, as 
                                                  Percolator's cross-validation); 'false' = one final ensembl
                                                  e scores everything, which ranks the training decoys it 
                                                  learned too low and selects too many positives. (default: 
                                                  'true') (valid: 'true', 'false')
  -percolator:reset:mlp_norm_min_decoys <number>  RESET learner 'mlp', cross-fitted: normalize the fold ensem
                                                  bles' scores (as Percolator's folds) only if every fold 
                                                  has at least this many training decoys (0 = always). (defau
                                                  lt: '1000') (min: '0')
  -percolator:reset:representative <choice>       RESET: the PSM that represents a stem: 'model' = after each
                                                   round, best score under the new model (default; the FDR 
                                                  then also assumes that null targets and decoys are exchange
                                                  able over their whole PSM collections, including their size
                                                  s); 'search' = best search engine score (the paper). (defau
                                                  lt: 'model') (valid: 'search', 'model')
  -percolator:reset:iterations <number>           RESET: training rounds (the paper: 5, which do not converge
                                                   on DIA data). (default: '25') (min: '1')
  -percolator:reset:audit                         RESET: feature-symmetry audit before training (per-feature 
                                                  AUC and KS of training decoys vs low-scoring pseudo-targets
                                                  ), reported in the log.
  -percolator:reset:decoys <choice>               RESET: 'single' = one decoy database (default); 'two' = 
                                                  the two-decoy mode of Percolator-RESET: the PSMs come from 
                                                  a search against the targets and two decoy databases of 
                                                  the same construction (the second with accessions starting 
                                                  with reset:second_decoy_prefix), and the FDR factors change
                                                   from 3 and 2 to 2 and 1 (see PercolatorReset). (default: 
                                                  'single') (valid: 'single', 'two')
  -percolator:reset:second_decoy_prefix <text>    RESET 'two' decoys: accession prefix of the proteins of 
                                                  the second decoy database (a decoy hit is of the second 
                                                  set if all its proteins have this prefix). (default: 'DECOY
                                                  _X_')
  -percolator:reset:stem_table <text>             RESET: if not empty, rescorePSMs() writes every stem (consi
                                                  dered or not) to this tab-separated file: stem, representat
                                                  ive peptidoform, label, role, considered, search engine 
                                                  score, RESET score, q-value (peptide level), spectrum refer
                                                  ence, charge.

                                                  
Common TOPP options:
  -ini <file>                                     Use the given TOPP INI file
  -threads <n>                                    Sets the number of threads allowed to be used by the TOPP 
                                                  tool (0 = all available cores) (default: '1')
  -write_ini <file>                               Writes the default configuration file
  --help                                          Shows options
  --helphelp                                      Shows all options (including advanced)

INI file documentation of this tool:

Legend:
required parameter
advanced parameter

This section lists all parameters supported by the tool. Parameters are organized into hierarchical subsections that group related settings together. Subsections may contain further subsections or individual parameters.

Each parameter entry contains the following information:

  • Name The identifier used in configuration files and on the command line.
  • Default value The value used if the parameter is not explicitly specified.
  • Description A short explanation describing the purpose and behavior of the parameter.
  • Tags Additional metadata associated with the parameter.
  • Restrictions Allowed value ranges for numeric parameters or valid options for string parameters.

Parameter tags provide additional information about how a parameter is used. Some tags indicate whether a parameter is required or intended for advanced configuration, while others may be used internally by OpenMS or workflow tools.

Parameters highlighted as required must be specified for the tool to run successfully. Parameters marked as advanced allow fine-tuning of algorithm behavior and are typically not needed for standard workflows.

+OpenSwathPercolatorScoringRescore OpenSWATH OSW / OSWPQ results with in-process Percolator.
version3.7.0-pre-nightly-2026-11-13 Version of the tool that generated this parameters file.
++1Instance '1' section for 'OpenSwathPercolatorScoring'
in Input OpenSWATH result file (.osw) or OSWPQ parquet archive/directory (.oswpq).input file*.osw, *.oswpq
out Optional output path. If empty, the input is updated in place.output file*.osw, *.oswpq
level[ms1ms2] One or more scoring levels to run sequentially. Use 'ms2 transition' or 'ms1ms2 transition' to derive peak-group and transition scores from an unscored input.ms1, ms2, ms1ms2, transition
training_main_scorevar_xcorr_shape Peak-group score that selects the best peak group of each precursor for the Percolator training set of ms1, ms2 and ms1ms2 rescoring (prefix '-' if lower values are better). The training set holds these peak groups plus all peak groups of precursors drawn at random, up to percolator:subset_max_train further peak groups (0: train on all peak groups); the model then scores all peak groups. If the score is not among the features, all peak groups are used.
log Name of log file (created only when specified)
debug0 Sets the debug level
threads1 Sets the number of threads allowed to be used by the TOPP tool (0 = all available cores)
no_progressfalse Disables progress logging to command linetrue, false
forcefalse Overrides tool-specific checkstrue, false
testfalse Enables the test mode (needed for internal use only)true, false
+++transition
peakgroup_max_rank1 Transition scoring: maximum MS2 peak-group rank retained for transition rescoring.1:∞
peakgroup_max_pep0.7 Transition scoring: maximum MS2 peak-group PEP retained for transition rescoring.0.0:1.0
max_isotope_overlap0.5 Transition scoring: maximum transition isotope-overlap score retained for rescoring.0.0:∞
min_log_sn0.0 Transition scoring: minimum log signal-to-noise score retained for rescoring.
+++percolator
c_pos0.1 Positive regularization constant (C+).0.0:∞
c_neg0.0 Negative regularization constant (C-). 0 = auto-select.0.0:∞
test_fdr0.01 Test FDR threshold for SVM direction selection.0.0:1.0
train_fdr0.01 Training FDR for SVM iterations.0.0:1.0
num_iterations10 Number of SVM training iterations.1:∞
initial_direction Feature name to use as the initial scoring direction. Prefix with '-' if LOWER values are more target-like (e.g. 'COMET:lnExpect' means higher is better; '-COMET:lnExpect' means lower is better). Leave empty (default) to let Percolator auto-select by testing every feature in both directions and picking the one that separates the most targets at train_fdr.
pep_methodlogistic_regression Posterior error probability estimator: 'logistic_regression' (target-decoy competition + isotonic fit; legacy name, not actually logistic regression), 'isotonic' (target-q → pep monotone regression), or 'nonparametric' (kernel smoothing).logistic_regression, isotonic, nonparametric
seed1 Random seed for CV splitting.
target_decoy_metavaluetarget_decoy Meta-value on PeptideHit indicating target/decoy ('target'/'decoy').
normalizerstdv Feature normalizer: 'stdv' (zero-mean, unit-stdv, default), 'uni' (min/max), or 'none' (no normalization).stdv, uni, none
train_best_positivetrue During TRAINING, use only the best-scoring target PSM per spectrum (file and ScanNr; with cv_group_keys: per group) as a positive example, if it passes train_fdr. Affects the SVM (weights change). Orthogonal to post_processing_tdc. Default is 'true' because typical OpenMS inputs are multi-hit-per-spectrum (Comet/MSGF+/Sage top-N, OSW peak groups). Inert on one-hit-per-spectrum inputs. Note: the upstream percolator binary defaults this to off — PercolatorAdapter preserves the CLI contract by mirroring its flag state when writing this param.true, false
post_processing_tdctrue AFTER training, before PEP/q-value calculation, apply Target-Decoy Competition: keep only the highest-scoring PSM per (scan, mass, charge) and drop the rest from the score set. Does NOT touch the SVM — only the score distribution used for FDR. Default is 'true' because without TDC on multi-hit input, q-values count every candidate as an independent 'chance' and drift optimistic. Inert on one-hit-per-spectrum inputs. Note: the upstream percolator binary defaults this to off — PercolatorAdapter preserves the CLI contract by mirroring its flag state when writing this param.true, false
nested_xval_bins1 Number of nested CV bins for grid search of Cpos/Cneg. Upstream default for cross validation is 3; 1 disables nested search.1:∞
subset_max_train100000 Cap on the training set size (0 = use all). Default 100000 bounds training time on very large inputs (>1M PSMs) at negligible quality loss. Sampling is reservoir-based, keyed by (scan, exp_mass) so all PSMs sharing a spectrum travel together; the trained model is then applied to ALL input rows via a second scoring pass (matches upstream Caller.cpp behavior). Inert when the input size is at or below the cap. Note: upstream percolator binary defaults this to 0 — PercolatorAdapter preserves the CLI contract by passing its own int option (CLI default 0) through to this param.0:∞
subset_modein_sample How rescore() trains when subset_max_train caps the training set. 'in_sample' (default, as the percolator executable's --subset-max-train): the cross-validation runs on the sample, and all rows are scored by the average of the fold models, so a sampled row is scored by two models that trained on it. 'out_of_fold': every spectrum (spectrum file, scan) is assigned to one of the cross-validation folds first; a seeded random sample of whole spectra of at most subset_max_train rows is drawn from the entire input (one sample: each fold's model trains on the sampled spectra of the other folds); each fold's model is trained (positive selection and Cpos/Cneg choice inside its training set) without the spectra of its fold, and every row, sampled or not, is scored by the model of its fold only; the folds' scores are merged as in the cross-validation (rescaled per fold). 'out_of_fold_avg': as 'out_of_fold', but the rows of the spectra that are NOT in the sample, which no model has seen, are scored by the average of the fold models (as 'in_sample' scores them; with fewer than 100 targets or decoys there, by their folds' models); the sampled rows only by their own fold's model. Both are out-of-sample for every row, and the targets and decoys of a spectrum always share their scorer (a spectrum is sampled or not as a whole); the four scorers' scores are merged as the folds' (rescaled per scorer). Out-of-fold modes: the model of a fold is also checked (sanity check against the default direction) and gets its Cneg candidates on its own training set only. A spectrum is the rows' (spectrum file, scan): without scan numbers (or cv_group_keys) each row is its own spectrum. Inert when the input has at most subset_max_train rows.in_sample, out_of_fold, out_of_fold_avg, learning_curve
subset_curve_start100000 subset_mode 'learning_curve': rows of the first training sample. The mode trains out-of-fold (folds as 'out_of_fold') on nested whole-spectrum samples of subset_curve_start, twice, four times ... as many rows, up to subset_max_train (if > 0, else subset_curve_max) or all rows but the validation spectra; the validation spectra (the end of the random order, at most subset_curve_validation rows and 20 % of the rows) are never trained on. Fold k's model is measured by the targets at q <= train_fdr among the validation spectra of the OTHER folds; fold k stops at the first doubling that adds less than max(subset_curve_min_gain (relative), 2 standard errors of the paired difference (sqrt of the validation targets accepted by only one of the two models)) and keeps that model; a stopped fold is not trained further. Every row is scored by its fold's model, as 'out_of_fold'. Inert with at most subset_curve_start rows.1:∞
subset_curve_min_gain2.0e-03 subset_mode 'learning_curve': see subset_curve_start.0.0:∞
subset_curve_validation250000 subset_mode 'learning_curve': see subset_curve_start.1:∞
subset_curve_max1000000 subset_mode 'learning_curve': largest sample if subset_max_train is 0 (0 = all rows).0:∞
tron_epsilon1.0e-07 Stopping tolerance of the TRON solver of the SVM training (relative gradient norm). Larger values train faster; the results differ from Percolator's (1e-7).1.0e-15:∞
warm_startfalse Start each SVM training of a cross-validation iteration from the weights its (Cpos, Cneg) pair learned in the previous iteration instead of 0 (faster; the results differ). Not with nested_xval_bins > 1.true, false
single_cnegfalse Without c_neg: only Cneg = 3 x the target/decoy ratio x Cpos instead of selecting among 1, 3 and 10 x by cross-validation (faster; the results differ).true, false
report_as_main_scorenone Which Percolator output to stamp as the main PeptideHit score after rescoring. 'none' (default) leaves hit.getScore() and the PeptideIdentification score_type untouched — callers who want the original search score preserved (or who run their own post-processing like PercolatorAdapter) rely on this. 'q-value' sets main score to the PSM-level q-value and marks higher_score_better=false. 'pep' sets main score to the PEP and marks higher_score_better=false. 'svm' sets main score to the SVM discriminant and marks higher_score_better=true. All three Percolator outputs remain accessible as percolator_{score,q_value,pep} meta values regardless of this setting.none, q-value, pep, svm
num_threads3 Maximum number of OpenMP threads for cross-validation; never more than the threads the tool may use (-threads). With the default settings, cross-validation trains 9 models (3 folds x 3 Cneg values) in parallel. Default and range match upstream. A build without OpenMP tasks (cl.exe) runs the models of each fold as a nested loop and may use up to two threads more than this.1:128
use_pi0true pi0 correction of q-values and PEPs (mix-max): 'true' (default here) estimates pi0, as PyProphet does, since a target precursor never competes with a decoy; 'false': pi0 = 1 (target-decoy FDR); 'auto': Percolator's default, as the percolator executable (pi0 only without 'post_processing_tdc', for input from separate target and decoy searches).auto, true, false
calc_mass_featurefalse rescorePSMs(): train on the CalcMass column too. 'false' (default): as the percolator executable, which reads it as metadata; 'true': the in-process training before OpenMS #10717.true, false
solvertron Solver of the SVMs of the cross-validation. 'tron' (default): the trust region Newton method (TRON) of Percolator, from 0 in every step. 'newton': the modified finite Newton method of Keerthi & DeCoste (2005) with the explicit Hessian (one pass over the active PSMs per step) and an exact line search, warm-started from the weights of the step before, with a looser tolerance in all steps but the last; for a given training set it reaches the same optimum as 'tron' (within the tolerance) in far fewer passes over the data (the looser steps may choose slightly different training sets for the next), and runs the blocks of large training sets on all threads. 'lda': Fisher's linear discriminant of the positives and the decoys in every step (one pass, no optimization; a fast approximation of the SVM). Upstream percolator has no such option.tron, newton, lda
algorithmpercolator rescorePSMs(): 'percolator' = Percolator's cross-validated PSM-level FDR (default); 'reset' = Percolator-RESET (PercolatorReset): FDR control at the peptide (stem = unmodified sequence) level, PSM-level q-values heuristic. rescore() and train()/score() always use Percolator.percolator, reset
peptide_levelfalse rescore(): also estimate peptide-level q-values and PEPs as the percolator executable does without -U (its peptide output): after the target-decoy competition the best PSM of each peptide and label (RescoreInput::peptide_keys, the PIN 'Peptide' string between the flanks) is kept and q-values (pi0 = 1 with post_processing_tdc, as the executable) and PEPs are computed on these peptides (RescoreOutput::peptide_q_values, peptide_peps). rescorePSMs() then writes them to the rescored hits as 'percolator_peptide_q_value' and 'percolator_peptide_pep'. Not with algorithm 'reset' (its own peptide-level q-value) or a scorer.true, false
++++reset
salt RESET: salt of the decoy coins (an unsigned 64-bit integer). Empty = a fresh random salt per run (recorded in the log and by ProSE in the search parameters). Never choose the best of several salts.
learnersvm RESET: 'svm' = linear L2-SVM (default); 'mlp' = ensemble of small MLPs (experimental).svm, mlp
mlp_members8 RESET learner 'mlp': networks per ensemble.1:∞
mlp_hidden16 RESET learner 'mlp': units of each of the two hidden layers.1:∞
mlp_epochs30 RESET learner 'mlp': training epochs of the first round (of every round without warm starts).1:∞
mlp_warm_epochs3 RESET learner 'mlp': > 0 = warm starts: the networks continue from the previous round for this many epochs; 0 = trained afresh every round.0:∞
mlp_crossfittrue RESET learner 'mlp': score each stem by the networks that did not train on it (3 folds by a hash of the sequence, as Percolator's cross-validation); 'false' = one final ensemble scores everything, which ranks the training decoys it learned too low and selects too many positives.true, false
mlp_norm_min_decoys1000 RESET learner 'mlp', cross-fitted: normalize the fold ensembles' scores (as Percolator's folds) only if every fold has at least this many training decoys (0 = always).0:∞
representativemodel RESET: the PSM that represents a stem: 'model' = after each round, best score under the new model (default; the FDR then also assumes that null targets and decoys are exchangeable over their whole PSM collections, including their sizes); 'search' = best search engine score (the paper).search, model
iterations25 RESET: training rounds (the paper: 5, which do not converge on DIA data).1:∞
auditfalse RESET: feature-symmetry audit before training (per-feature AUC and KS of training decoys vs low-scoring pseudo-targets), reported in the log.true, false
decoyssingle RESET: 'single' = one decoy database (default); 'two' = the two-decoy mode of Percolator-RESET: the PSMs come from a search against the targets and two decoy databases of the same construction (the second with accessions starting with reset:second_decoy_prefix), and the FDR factors change from 3 and 2 to 2 and 1 (see PercolatorReset).single, two
second_decoy_prefixDECOY_X_ RESET 'two' decoys: accession prefix of the proteins of the second decoy database (a decoy hit is of the second set if all its proteins have this prefix).
stem_table RESET: if not empty, rescorePSMs() writes every stem (considered or not) to this tab-separated file: stem, representative peptidoform, label, role, considered, search engine score, RESET score, q-value (peptide level), spectrum reference, charge.