pointsource_algs: comparison src/experiments.rs

-:c5d8bd1a7728
+:6316d68b58af
 use alg_tools::bisection_tree::*;
 use alg_tools::error::DynResult;
 use alg_tools::norms::Linfinity;
-use crate::ExperimentOverrides;
+use crate::{ExperimentOverrides, AlgorithmOverrides};
 use crate::kernels::*;
 use crate::kernels::SupportProductFirst as Prod;
-use crate::pdps::PDPSConfig;
 use crate::types::*;
 use crate::run::{
 RunnableExperiment,
 ExperimentV2,
 ExperimentBiased,
 Named,
 DefaultAlgorithm,
-AlgorithmConfig,
-ProxTerm
 };
 //use crate::fb::FBGenericConfig;
 use crate::rand_distr::{SerializableNormal, SaltAndPepper};
 use crate::regularisation::Regularisation;
 use alg_tools::euclidean::Euclidean;
 #[clap(name = "2d_l1")]
 Experiment2D_L1,
 /// Two dimensions, “fast” spread, 1-norm data fidelity
 #[clap(name = "2d_l1_fast")]
 Experiment2D_L1_Fast,
 /// One dimension, “fast” spread, 2-norm-squared data fidelity with extra TV-regularised bias
 #[clap(name = "1d_tv_fast")]
 Experiment1D_TV_Fast,
+/// Two dimensions, “fast” spread, 2-norm-squared data fidelity with extra TV-regularised bias
+#[clap(name = "2d_tv_fast")]
+Experiment2D_TV_Fast,
 }
 macro_rules! make_float_constant {
 ($name:ident = $value:expr) => {
 #[derive(Debug, Copy, Eq, PartialEq, Clone, Serialize, Deserialize)]
 make_float_constant!(CutOff1 = 0.15);
 make_float_constant!(Hat1 = 0.16);
 make_float_constant!(HatBias = 0.05);
 // We use a different step length for PDPS in 2D experiments
-let pdps_2d = || {
+// let pdps_2d = (DefaultAlgorithm::PDPS,
-let τ0 = 3.0;
+//     AlgorithmOverrides {
-PDPSConfig {
+//         tau0 : Some(3.0),
-τ0,
+//         sigma0 : Some(0.99 / 3.0),
-σ0 : 0.99 / τ0,
+//         .. Default::default()
+//     }
+// );
+// let radon_pdps_2d = (DefaultAlgorithm::RadonPDPS,
+//     AlgorithmOverrides {
+//         tau0 : Some(3.0),
+//         sigma0 : Some(0.99 / 3.0),
+//         .. Default::default()
+//     }
+// );
+let sliding_fb_cut_gaussian = (DefaultAlgorithm::SlidingFB,
+AlgorithmOverrides {
+theta0 : Some(0.3),
 .. Default::default()
 }
-};
+);
-let defaults_2d = HashMap::from([
+// let higher_cpos = |alg| (alg,
-(DefaultAlgorithm::PDPS, AlgorithmConfig::PDPS(pdps_2d(), ProxTerm::Wave)),
+//     AlgorithmOverrides {
-(DefaultAlgorithm::RadonPDPS, AlgorithmConfig::PDPS(pdps_2d(), ProxTerm::RadonSquared))
+//         transport_tolerance_pos : Some(1000.0),
-]);
+//         .. Default::default()
+//     }
+// );
+let higher_cpos_merging = |alg| (alg,
+AlgorithmOverrides {
+transport_tolerance_pos : Some(1000.0),
+merge : Some(true),
+fitness_merging : Some(true),
+.. Default::default()
+}
+);
+let much_higher_cpos_merging_steptune = |alg| (alg,
+AlgorithmOverrides {
+transport_tolerance_pri : Some(1000.0),
+transport_tolerance_pos : Some(10000.0),
+sigma0 : Some(0.15),
+theta0 : Some(0.3),
+merge : Some(true),
+fitness_merging : Some(true),
+.. Default::default()
+}
+);
 //  We add a hash of the experiment name to the configured
 // noise seed to not use the same noise for different experiments.
 let mut h = DefaultHasher::new();
 name.hash(&mut h);
 let noise_seed = cli.noise_seed.unwrap_or(BASE_SEED) + h.finish();
+let default_merge_radius = 0.01;
 use DefaultExperiment::*;
 Ok(match self {
 Experiment1D => {
 let base_spread = Gaussian { variance : Variance1 };
 let spread_cutoff = BallIndicator { r : CutOff1, exponent : Linfinity };
 Box::new(Named { name, data : ExperimentV2 {
 domain : [[0.0, 1.0]].into(),
 sensor_count : [N_SENSORS_1D],
-regularisation : Regularisation::NonnegRadon(cli.alpha.unwrap_or(0.09)),
+regularisation : Regularisation::NonnegRadon(cli.alpha.unwrap_or(0.08)),
 noise_distr : SerializableNormal::new(0.0, cli.variance.unwrap_or(0.2))?,
 dataterm : DataTerm::L2Squared,
 μ_hat : MU_TRUE_1D_BASIC.into(),
 sensor : BallIndicator { r : SensorWidth1D, exponent : Linfinity },
 spread : Prod(spread_cutoff, base_spread),
 kernel : Prod(AutoConvolution(spread_cutoff), base_spread),
 kernel_plot_width,
 noise_seed,
-algorithm_defaults: HashMap::new(),
+default_merge_radius,
+algorithm_overrides: HashMap::from([
+sliding_fb_cut_gaussian,
+higher_cpos_merging(DefaultAlgorithm::RadonFB),
+higher_cpos_merging(DefaultAlgorithm::RadonSlidingFB),
+]),
 }})
 },
 Experiment1DFast => {
 let base_spread = HatConv { radius : Hat1 };
 Box::new(Named { name, data : ExperimentV2 {
 sensor : BallIndicator { r : SensorWidth1D, exponent : Linfinity },
 spread : base_spread,
 kernel : base_spread,
 kernel_plot_width,
 noise_seed,
-algorithm_defaults: HashMap::new(),
+default_merge_radius,
+algorithm_overrides: HashMap::from([
+higher_cpos_merging(DefaultAlgorithm::RadonFB),
+higher_cpos_merging(DefaultAlgorithm::RadonSlidingFB),
+]),
 }})
 },
 Experiment2D => {
 let base_spread = Gaussian { variance : Variance1 };
 let spread_cutoff = BallIndicator { r : CutOff1, exponent : Linfinity };
 sensor : BallIndicator { r : SensorWidth2D, exponent : Linfinity },
 spread : Prod(spread_cutoff, base_spread),
 kernel : Prod(AutoConvolution(spread_cutoff), base_spread),
 kernel_plot_width,
 noise_seed,
-algorithm_defaults: defaults_2d,
+default_merge_radius,
+algorithm_overrides: HashMap::from([
+sliding_fb_cut_gaussian,
+higher_cpos_merging(DefaultAlgorithm::RadonFB),
+higher_cpos_merging(DefaultAlgorithm::RadonSlidingFB),
+// pdps_2d,
+// radon_pdps_2d
+]),
 }})
 },
 Experiment2DFast => {
 let base_spread = HatConv { radius : Hat1 };
 Box::new(Named { name, data : ExperimentV2 {
 sensor : BallIndicator { r : SensorWidth2D, exponent : Linfinity },
 spread : base_spread,
 kernel : base_spread,
 kernel_plot_width,
 noise_seed,
-algorithm_defaults: defaults_2d,
+default_merge_radius,
+algorithm_overrides: HashMap::from([
+// pdps_2d,
+// radon_pdps_2d
+higher_cpos_merging(DefaultAlgorithm::RadonFB),
+higher_cpos_merging(DefaultAlgorithm::RadonSlidingFB),
+]),
 }})
 },
 Experiment1D_L1 => {
 let base_spread = Gaussian { variance : Variance1 };
 let spread_cutoff = BallIndicator { r : CutOff1, exponent : Linfinity };
 sensor : BallIndicator { r : SensorWidth1D, exponent : Linfinity },
 spread : Prod(spread_cutoff, base_spread),
 kernel : Prod(AutoConvolution(spread_cutoff), base_spread),
 kernel_plot_width,
 noise_seed,
-algorithm_defaults: HashMap::new(),
+default_merge_radius,
+algorithm_overrides: HashMap::new(),
 }})
 },
 Experiment1D_L1_Fast => {
 let base_spread = HatConv { radius : Hat1 };
 Box::new(Named { name, data : ExperimentV2 {
 sensor : BallIndicator { r : SensorWidth1D, exponent : Linfinity },
 spread : base_spread,
 kernel : base_spread,
 kernel_plot_width,
 noise_seed,
-algorithm_defaults: HashMap::new(),
+default_merge_radius,
+algorithm_overrides: HashMap::new(),
 }})
 },
 Experiment2D_L1 => {
 let base_spread = Gaussian { variance : Variance1 };
 let spread_cutoff = BallIndicator { r : CutOff1, exponent : Linfinity };
 sensor : BallIndicator { r : SensorWidth2D, exponent : Linfinity },
 spread : Prod(spread_cutoff, base_spread),
 kernel : Prod(AutoConvolution(spread_cutoff), base_spread),
 kernel_plot_width,
 noise_seed,
-algorithm_defaults: defaults_2d,
+default_merge_radius,
+algorithm_overrides: HashMap::from([
+// pdps_2d,
+// radon_pdps_2d
+]),
 }})
 },
 Experiment2D_L1_Fast => {
 let base_spread = HatConv { radius : Hat1 };
 Box::new(Named { name, data : ExperimentV2 {
 sensor : BallIndicator { r : SensorWidth2D, exponent : Linfinity },
 spread : base_spread,
 kernel : base_spread,
 kernel_plot_width,
 noise_seed,
-algorithm_defaults: defaults_2d,
+default_merge_radius,
+algorithm_overrides: HashMap::from([
+// pdps_2d,
+// radon_pdps_2d
+]),
 }})
 },
 Experiment1D_TV_Fast => {
 let base_spread = HatConv { radius : HatBias };
 Box::new(Named { name, data : ExperimentBiased {
 sensor : BallIndicator { r : SensorWidth1D, exponent : Linfinity },
 spread : base_spread,
 kernel : base_spread,
 kernel_plot_width,
 noise_seed,
-algorithm_defaults: HashMap::new(),
+default_merge_radius,
+algorithm_overrides: HashMap::from([
+higher_cpos_merging(DefaultAlgorithm::RadonForwardPDPS),
+higher_cpos_merging(DefaultAlgorithm::RadonSlidingPDPS),
+]),
+},
+}})
+},
+Experiment2D_TV_Fast => {
+let base_spread = HatConv { radius : Hat1 };
+Box::new(Named { name, data : ExperimentBiased {
+λ : 0.005,
+bias : MappingSum::new([
+Weighted::new(1.0, BallCharacteristic{ center : [0.3, 0.3].into(), radius : 0.2 }),
+Weighted::new(0.5, BallCharacteristic{ center : [0.6, 0.6].into(), radius : 0.3 }),
+]),
+base : ExperimentV2 {
+domain : [[0.0, 1.0]; 2].into(),
+sensor_count : [N_SENSORS_2D; 2],
+regularisation : Regularisation::NonnegRadon(cli.alpha.unwrap_or(0.06)),
+noise_distr : SerializableNormal::new(0.0, cli.variance.unwrap_or(0.15))?, //0.25
+dataterm : DataTerm::L2Squared,
+μ_hat : MU_TRUE_2D_BASIC.into(),
+sensor : BallIndicator { r : SensorWidth2D, exponent : Linfinity },
+spread : base_spread,
+kernel : base_spread,
+kernel_plot_width,
+noise_seed,
+default_merge_radius,
+algorithm_overrides: HashMap::from([
+much_higher_cpos_merging_steptune(DefaultAlgorithm::RadonForwardPDPS),
+much_higher_cpos_merging_steptune(DefaultAlgorithm::RadonSlidingPDPS),
+]),
 },
 }})
 },
 })
 }

Mercurial > repos > pointsource_algs / file comparison

comparison: src/experiments.rs

src/experiments.rs