Mercurial > repos > pointsource_algs / file comparison
comparison: src/experiments.rs
src/experiments.rs
- changeset 72
- e9a460a0e638
- parent 61
- 4f468d35fa29
equal
deleted
inserted
replaced
| 71:e2953ffd4e0b | 72:e9a460a0e638 |
|---|---|
| 154 } | 154 } |
| 155 } | 155 } |
| 156 | 156 |
| 157 //#[replace_float_literals(F::cast_from(literal))] | 157 //#[replace_float_literals(F::cast_from(literal))] |
| 158 impl DefaultExperiment { | 158 impl DefaultExperiment { |
| 159 // fn default_list() -> Vec<Self> { | |
| 160 // use DefaultExperiment::*; | |
| 161 // [ | |
| 162 // Experiment1D, | |
| 163 // Experiment1DFast, | |
| 164 // Experiment2D, | |
| 165 // Experiment2DFast, | |
| 166 // Experiment1D_L1, | |
| 167 // ] | |
| 168 // .into() | |
| 169 // } | |
| 170 | |
| 171 /// Convert the experiment shorthand into a runnable experiment configuration. | 159 /// Convert the experiment shorthand into a runnable experiment configuration. |
| 172 fn get_experiment( | 160 fn get_experiment( |
| 173 &self, | 161 &self, |
| 174 cli: &DefaultExperimentSetup<f64>, | 162 cli: &DefaultExperimentSetup<f64>, |
| 175 ) -> DynResult<Box<dyn RunnableExperiment<f64>>> { | 163 ) -> DynResult<Box<dyn RunnableExperiment<f64>>> { |
| 191 make_float_constant!(Variance1 = 0.05.powi(2)); | 179 make_float_constant!(Variance1 = 0.05.powi(2)); |
| 192 make_float_constant!(CutOff1 = 0.15); | 180 make_float_constant!(CutOff1 = 0.15); |
| 193 make_float_constant!(Hat1 = 0.16); | 181 make_float_constant!(Hat1 = 0.16); |
| 194 make_float_constant!(HatBias = 0.05); | 182 make_float_constant!(HatBias = 0.05); |
| 195 | 183 |
| 196 // We use a different step length for PDPS in 2D experiments | 184 let basic = |alg| { |
| 197 // let pdps_2d = (DefaultAlgorithm::PDPS, | |
| 198 // AlgorithmOverrides { | |
| 199 // tau0 : Some(3.0), | |
| 200 // sigma0 : Some(0.99 / 3.0), | |
| 201 // .. Default::default() | |
| 202 // } | |
| 203 // ); | |
| 204 // let radon_pdps_2d = (DefaultAlgorithm::RadonPDPS, | |
| 205 // AlgorithmOverrides { | |
| 206 // tau0 : Some(3.0), | |
| 207 // sigma0 : Some(0.99 / 3.0), | |
| 208 // .. Default::default() | |
| 209 // } | |
| 210 // ); | |
| 211 let sliding_fb_cut_gaussian = (DefaultAlgorithm::SlidingFB, AlgorithmOverrides { | |
| 212 theta0: Some(0.3), | |
| 213 ..Default::default() | |
| 214 }); | |
| 215 // let higher_cpos = |alg| (alg, | |
| 216 // AlgorithmOverrides { | |
| 217 // transport_tolerance_pos : Some(1000.0), | |
| 218 // .. Default::default() | |
| 219 // } | |
| 220 // ); | |
| 221 let higher_cpos_merging = |alg| { | |
| 222 (alg, AlgorithmOverrides { | 185 (alg, AlgorithmOverrides { |
| 223 transport_tolerance_pos: Some(1000.0), | 186 gradv_lipest_mult: Some(0.04), |
| 224 merge: Some(true), | 187 transport_tolerance: Some(100.0), |
| 225 fitness_merging: Some(true), | |
| 226 ..Default::default() | 188 ..Default::default() |
| 227 }) | 189 }) |
| 228 }; | 190 }; |
| 229 let higher_cpos_merging_steptune = |alg| { | 191 let radon = |alg| { |
| 230 (alg, AlgorithmOverrides { | 192 (alg, AlgorithmOverrides { |
| 231 transport_tolerance_pos: Some(1000.0), | 193 gradv_lipest_mult: Some(0.04), |
| 232 theta0: Some(0.3), | 194 transport_tolerance: Some(1000.0), |
| 233 merge: Some(true), | |
| 234 fitness_merging: Some(true), | |
| 235 ..Default::default() | 195 ..Default::default() |
| 236 }) | 196 }) |
| 237 }; | 197 }; |
| 238 let much_higher_cpos_merging_steptune = |alg| { | 198 let radon_2dtv = |alg| { |
| 239 (alg, AlgorithmOverrides { | 199 (alg, AlgorithmOverrides { |
| 240 transport_tolerance_pos: Some(10000.0), | 200 gradv_lipest_mult: Some(0.04), |
| 201 transport_tolerance: Some(10000.0), | |
| 241 sigma0: Some(0.15), | 202 sigma0: Some(0.15), |
| 242 theta0: Some(0.3), | |
| 243 merge: Some(true), | |
| 244 fitness_merging: Some(true), | |
| 245 ..Default::default() | 203 ..Default::default() |
| 246 }) | 204 }) |
| 247 }; | 205 }; |
| 206 macro_rules! overrides { | |
| 207 ($a:ident, $b:ident) => { | |
| 208 HashMap::from([ | |
| 209 $a(DefaultAlgorithm::SlidingFB), | |
| 210 $a(DefaultAlgorithm::SlidingPDPS), | |
| 211 $a(DefaultAlgorithm::ForwardPDPS), | |
| 212 $b(DefaultAlgorithm::RadonFB), | |
| 213 $b(DefaultAlgorithm::RadonSlidingFB), | |
| 214 $b(DefaultAlgorithm::RadonSlidingPDPS), | |
| 215 ]) | |
| 216 }; | |
| 217 } | |
| 218 | |
| 248 // We add a hash of the experiment name to the configured | 219 // We add a hash of the experiment name to the configured |
| 249 // noise seed to not use the same noise for different experiments. | 220 // noise seed to not use the same noise for different experiments. |
| 250 let mut h = DefaultHasher::new(); | 221 let mut h = DefaultHasher::new(); |
| 251 name.hash(&mut h); | 222 name.hash(&mut h); |
| 252 let noise_seed = cli.noise_seed.unwrap_or(BASE_SEED) + h.finish(); | 223 let noise_seed = cli.noise_seed.unwrap_or(BASE_SEED) + h.finish(); |
| 271 spread: Prod(spread_cutoff, base_spread), | 242 spread: Prod(spread_cutoff, base_spread), |
| 272 kernel: Prod(AutoConvolution(spread_cutoff), base_spread), | 243 kernel: Prod(AutoConvolution(spread_cutoff), base_spread), |
| 273 kernel_plot_width, | 244 kernel_plot_width, |
| 274 noise_seed, | 245 noise_seed, |
| 275 default_merge_radius, | 246 default_merge_radius, |
| 276 algorithm_overrides: HashMap::from([ | 247 algorithm_overrides: overrides!(basic, radon), |
| 277 sliding_fb_cut_gaussian, | |
| 278 higher_cpos_merging(DefaultAlgorithm::RadonFB), | |
| 279 higher_cpos_merging(DefaultAlgorithm::RadonSlidingFB), | |
| 280 ]), | |
| 281 }, | 248 }, |
| 282 }) | 249 }) |
| 283 } | 250 } |
| 284 Experiment1DFast => { | 251 Experiment1DFast => { |
| 285 let base_spread = HatConv { radius: Hat1 }; | 252 let base_spread = HatConv { radius: Hat1 }; |
| 296 spread: base_spread, | 263 spread: base_spread, |
| 297 kernel: base_spread, | 264 kernel: base_spread, |
| 298 kernel_plot_width, | 265 kernel_plot_width, |
| 299 noise_seed, | 266 noise_seed, |
| 300 default_merge_radius, | 267 default_merge_radius, |
| 301 algorithm_overrides: HashMap::from([ | 268 algorithm_overrides: overrides!(basic, radon), |
| 302 higher_cpos_merging(DefaultAlgorithm::RadonFB), | |
| 303 higher_cpos_merging(DefaultAlgorithm::RadonSlidingFB), | |
| 304 ]), | |
| 305 }, | 269 }, |
| 306 }) | 270 }) |
| 307 } | 271 } |
| 308 Experiment2D => { | 272 Experiment2D => { |
| 309 let base_spread = Gaussian { variance: Variance1 }; | 273 let base_spread = Gaussian { variance: Variance1 }; |
| 321 spread: Prod(spread_cutoff, base_spread), | 285 spread: Prod(spread_cutoff, base_spread), |
| 322 kernel: Prod(AutoConvolution(spread_cutoff), base_spread), | 286 kernel: Prod(AutoConvolution(spread_cutoff), base_spread), |
| 323 kernel_plot_width, | 287 kernel_plot_width, |
| 324 noise_seed, | 288 noise_seed, |
| 325 default_merge_radius, | 289 default_merge_radius, |
| 326 algorithm_overrides: HashMap::from([ | 290 algorithm_overrides: overrides!(basic, radon), |
| 327 sliding_fb_cut_gaussian, | |
| 328 higher_cpos_merging(DefaultAlgorithm::RadonFB), | |
| 329 higher_cpos_merging(DefaultAlgorithm::RadonSlidingFB), | |
| 330 ]), | |
| 331 }, | 291 }, |
| 332 }) | 292 }) |
| 333 } | 293 } |
| 334 Experiment2DFast => { | 294 Experiment2DFast => { |
| 335 let base_spread = HatConv { radius: Hat1 }; | 295 let base_spread = HatConv { radius: Hat1 }; |
| 346 spread: base_spread, | 306 spread: base_spread, |
| 347 kernel: base_spread, | 307 kernel: base_spread, |
| 348 kernel_plot_width, | 308 kernel_plot_width, |
| 349 noise_seed, | 309 noise_seed, |
| 350 default_merge_radius, | 310 default_merge_radius, |
| 351 algorithm_overrides: HashMap::from([ | 311 algorithm_overrides: overrides!(basic, radon), |
| 352 higher_cpos_merging(DefaultAlgorithm::RadonFB), | |
| 353 higher_cpos_merging(DefaultAlgorithm::RadonSlidingFB), | |
| 354 ]), | |
| 355 }, | 312 }, |
| 356 }) | 313 }) |
| 357 } | 314 } |
| 358 Experiment1D_L1 => { | 315 Experiment1D_L1 => { |
| 359 let base_spread = Gaussian { variance: Variance1 }; | 316 let base_spread = Gaussian { variance: Variance1 }; |
| 480 spread: base_spread, | 437 spread: base_spread, |
| 481 kernel: base_spread, | 438 kernel: base_spread, |
| 482 kernel_plot_width, | 439 kernel_plot_width, |
| 483 noise_seed, | 440 noise_seed, |
| 484 default_merge_radius, | 441 default_merge_radius, |
| 485 algorithm_overrides: HashMap::from([ | 442 algorithm_overrides: overrides!(basic, radon), |
| 486 higher_cpos_merging_steptune(DefaultAlgorithm::RadonForwardPDPS), | |
| 487 higher_cpos_merging_steptune(DefaultAlgorithm::RadonSlidingPDPS), | |
| 488 ]), | |
| 489 }, | 443 }, |
| 490 }, | 444 }, |
| 491 }) | 445 }) |
| 492 } | 446 } |
| 493 Experiment2D_TV_Fast => { | 447 Experiment2D_TV_Fast => { |
| 520 spread: base_spread, | 474 spread: base_spread, |
| 521 kernel: base_spread, | 475 kernel: base_spread, |
| 522 kernel_plot_width, | 476 kernel_plot_width, |
| 523 noise_seed, | 477 noise_seed, |
| 524 default_merge_radius, | 478 default_merge_radius, |
| 525 algorithm_overrides: HashMap::from([ | 479 algorithm_overrides: overrides!(basic, radon_2dtv), |
| 526 much_higher_cpos_merging_steptune( | |
| 527 DefaultAlgorithm::RadonForwardPDPS, | |
| 528 ), | |
| 529 much_higher_cpos_merging_steptune( | |
| 530 DefaultAlgorithm::RadonSlidingPDPS, | |
| 531 ), | |
| 532 ]), | |
| 533 }, | 480 }, |
| 534 }, | 481 }, |
| 535 }) | 482 }) |
| 536 } | 483 } |
| 537 }) | 484 }) |
