pointsource_algs: comparison src/main.rs

-:c5d8bd1a7728
+:6316d68b58af
 #![feature(dec2flt)]
 use clap::Parser;
 use serde::{Serialize, Deserialize};
 use serde_json;
+use serde_with::skip_serializing_none;
 use itertools::Itertools;
 use std::num::NonZeroUsize;
 use alg_tools::parallelism::{
 set_num_threads,
 PlotLevel,
 Named,
 AlgorithmConfig,
 };
 use experiments::DefaultExperiment;
-use measures::merging::SpikeMergingMethod;
 use DefaultExperiment::*;
 use DefaultAlgorithm::*;
 /// Command line parameters
-#[derive(Parser, Debug, Serialize)]
+#[skip_serializing_none]
+#[derive(Parser, Debug, Serialize, Default, Clone)]
 #[clap(
 about = env!("CARGO_PKG_DESCRIPTION"),
 author = env!("CARGO_PKG_AUTHORS"),
 version = env!("CARGO_PKG_VERSION"),
 after_help = "Pass --help for longer descriptions.",
 /// Default algorithm configration(s) to use on the experiments.
 ///
 /// Not all algorithms are available for all the experiments.
 /// In particular, only PDPS is available for the experiments with L¹ data term.
 #[arg(value_enum, value_name = "ALGORITHM", long, short = 'a',
-default_values_t = [FB, FISTA, PDPS, SlidingFB, FW, FWRelax])]
+default_values_t = [FB, PDPS, SlidingFB, FW, RadonFB])]
 algorithm : Vec<DefaultAlgorithm>,
 /// Saved algorithm configration(s) to use on the experiments
 #[arg(value_name = "JSON_FILE", long)]
 saved_algorithm : Vec<String>,
 #[arg(long, help_heading = "Multi-threading")]
 /// Number of threads. Overrides the maximum number.
 num_threads : Option<usize>,
+#[arg(long, default_value_t = false)]
+/// Load saved value ranges (if exists) to do partial update.
+load_valuerange : bool,
 #[clap(flatten, next_help_heading = "Experiment overrides")]
 /// Experiment setup overrides
 experiment_overrides : ExperimentOverrides<float>,
 #[clap(flatten, next_help_heading = "Algorithm overrides")]
 /// Algorithm parametrisation overrides
 algoritm_overrides : AlgorithmOverrides<float>,
 }
 /// Command line experiment setup overrides
-#[derive(Parser, Debug, Serialize, Deserialize)]
+#[skip_serializing_none]
+#[derive(Parser, Debug, Serialize, Deserialize, Default, Clone)]
 pub struct ExperimentOverrides<F : ClapFloat> {
 #[arg(long)]
 /// Regularisation parameter override.
 ///
 /// Only use if running just a single experiment, as different experiments have different
 /// Noise seed
 noise_seed : Option<u64>,
 }
 /// Command line algorithm parametrisation overrides
-#[derive(Parser, Debug, Serialize, Deserialize)]
+#[skip_serializing_none]
+#[derive(Parser, Debug, Serialize, Deserialize, Default, Clone)]
 pub struct AlgorithmOverrides<F : ClapFloat> {
 #[arg(long, value_names = &["COUNT", "EACH"])]
 /// Override bootstrap insertion iterations for --algorithm.
 ///
 /// The first parameter is the number of bootstrap insertion iterations, and the second
 #[arg(long)]
 /// Normalised transport step length for sliding methods.
 theta0 : Option<F>,
 #[arg(long)]
-/// Transport toleranced wrt. ω
+/// A priori transport tolerance multiplier (C_pri)
-transport_tolerance_omega : Option<F>,
+transport_tolerance_pri : Option<F>,
 #[arg(long)]
-/// Transport toleranced wrt. ∇v
+/// A posteriori transport tolerance multiplier (C_pos)
-transport_tolerance_dv : Option<F>,
+transport_tolerance_pos : Option<F>,
 #[arg(long)]
 /// Transport adaptation factor. Must be in (0, 1).
 transport_adaptation : Option<F>,
 /// Merging frequency, if merging enabled (every n iterations)
 ///
 /// Only affects FB, FISTA, and PDPS.
 merge_every : Option<usize>,
-#[arg(value_enum, long)]//, value_parser = SpikeMergingMethod::<float>::value_parser())]
+#[arg(long)]
-/// Merging strategy
+/// Enable merging (default: determined by algorithm)
-///
+merge : Option<bool>,
-/// Either the string "none", or a radius value for heuristic merging.
-merging : Option<SpikeMergingMethod<F>>,
+#[arg(long)]
+/// Merging radius (default: determined by experiment)
-#[arg(value_enum, long)]//, value_parser = SpikeMergingMethod::<float>::value_parser())]
+merge_radius : Option<F>,
-/// Final merging strategy
-///
+#[arg(long)]
-/// Either the string "none", or a radius value for heuristic merging.
+/// Interpolate when merging (default : determined by algorithm)
-/// Only affects FB, FISTA, and PDPS.
+merge_interp : Option<bool>,
-final_merging : Option<SpikeMergingMethod<F>>,
+#[arg(long)]
+/// Enable final merging (default: determined by algorithm)
+final_merging : Option<bool>,
+#[arg(long)]
+/// Enable fitness-based merging for relevant FB-type methods.
+/// This has worse convergence guarantees that merging based on optimality conditions.
+fitness_merging : Option<bool>,
 #[arg(long, value_names = &["ε", "θ", "p"])]
 /// Set the tolerance to ε_k = ε/(1+θk)^p
 tolerance : Option<Vec<F>>,
 for experiment_shorthand in cli.experiments.iter().unique() {
 let experiment = experiment_shorthand.get_experiment(&cli.experiment_overrides).unwrap();
 let mut algs : Vec<Named<AlgorithmConfig<float>>>
 = cli.algorithm
 .iter()
-.map(|alg| alg.to_named(
+.map(|alg| {
-experiment.algorithm_defaults(*alg)
+let cfg = alg.default_config()
-.unwrap_or_else(|| alg.default_config())
+.cli_override(&experiment.algorithm_overrides(*alg))
-.cli_override(&cli.algoritm_overrides)
+.cli_override(&cli.algoritm_overrides);
-))
+alg.to_named(cfg)
+})
 .collect();
 for filename in cli.saved_algorithm.iter() {
 let f = std::fs::File::open(filename).unwrap();
 let alg = serde_json::from_reader(f).unwrap();
 algs.push(alg);

Mercurial > repos > pointsource_algs / file comparison

comparison: src/main.rs

src/main.rs