Mercurial > repos > pointsource_algs / file comparison

comparison: src/experiments.rs

src/experiments.rs

changeset 24
d29d1fcf5423
parent 0
eb3c7813b67a
child 25
79943be70720
equal deleted inserted replaced
23:9869fa1e0ccd 24:d29d1fcf5423
18 use crate::kernels::{SupportProductFirst as Prod}; 18 use crate::kernels::{SupportProductFirst as Prod};
19 use crate::pdps::PDPSConfig; 19 use crate::pdps::PDPSConfig;
20 use crate::types::*; 20 use crate::types::*;
21 use crate::run::{ 21 use crate::run::{
22 RunnableExperiment, 22 RunnableExperiment,
23 Experiment, 23 ExperimentV2,
24 Named, 24 Named,
25 DefaultAlgorithm, 25 DefaultAlgorithm,
26 AlgorithmConfig 26 AlgorithmConfig
27 }; 27 };
28 //use crate::fb::FBGenericConfig; 28 //use crate::fb::FBGenericConfig;
29 use crate::rand_distr::{SerializableNormal, SaltAndPepper}; 29 use crate::rand_distr::{SerializableNormal, SaltAndPepper};
30 use crate::regularisation::Regularisation;
30 31
31 /// Experiments shorthands, to be used with the command line parser 32 /// Experiments shorthands, to be used with the command line parser
32 33
33 #[derive(ValueEnum, Debug, Copy, Clone, Eq, PartialEq, Hash, Serialize, Deserialize)] 34 #[derive(ValueEnum, Debug, Copy, Clone, Eq, PartialEq, Hash, Serialize, Deserialize)]
34 #[allow(non_camel_case_types)] 35 #[allow(non_camel_case_types)]
134 use DefaultExperiment::*; 135 use DefaultExperiment::*;
135 Ok(match self { 136 Ok(match self {
136 Experiment1D => { 137 Experiment1D => {
137 let base_spread = Gaussian { variance : Variance1 }; 138 let base_spread = Gaussian { variance : Variance1 };
138 let spread_cutoff = BallIndicator { r : CutOff1, exponent : Linfinity }; 139 let spread_cutoff = BallIndicator { r : CutOff1, exponent : Linfinity };
139 Box::new(Named { name, data : Experiment { 140 Box::new(Named { name, data : ExperimentV2 {
140 domain : [[0.0, 1.0]].into(), 141 domain : [[0.0, 1.0]].into(),
141 sensor_count : [N_SENSORS_1D], 142 sensor_count : [N_SENSORS_1D],
142 α : cli.alpha.unwrap_or(0.09), 143 regularisation : Regularisation::Radon(cli.alpha.unwrap_or(0.09)),
143 noise_distr : SerializableNormal::new(0.0, cli.variance.unwrap_or(0.2))?, 144 noise_distr : SerializableNormal::new(0.0, cli.variance.unwrap_or(0.2))?,
144 dataterm : DataTerm::L2Squared, 145 dataterm : DataTerm::L2Squared,
145 μ_hat : MU_TRUE_1D_BASIC.into(), 146 μ_hat : MU_TRUE_1D_BASIC.into(),
146 sensor : BallIndicator { r : SensorWidth1D, exponent : Linfinity }, 147 sensor : BallIndicator { r : SensorWidth1D, exponent : Linfinity },
147 spread : Prod(spread_cutoff, base_spread), 148 spread : Prod(spread_cutoff, base_spread),
151 algorithm_defaults: HashMap::new(), 152 algorithm_defaults: HashMap::new(),
152 }}) 153 }})
153 }, 154 },
154 Experiment1DFast => { 155 Experiment1DFast => {
155 let base_spread = HatConv { radius : Hat1 }; 156 let base_spread = HatConv { radius : Hat1 };
156 Box::new(Named { name, data : Experiment { 157 Box::new(Named { name, data : ExperimentV2 {
157 domain : [[0.0, 1.0]].into(), 158 domain : [[0.0, 1.0]].into(),
158 sensor_count : [N_SENSORS_1D], 159 sensor_count : [N_SENSORS_1D],
159 α : cli.alpha.unwrap_or(0.06), 160 regularisation : Regularisation::Radon(cli.alpha.unwrap_or(0.06)),
160 noise_distr : SerializableNormal::new(0.0, cli.variance.unwrap_or(0.2))?, 161 noise_distr : SerializableNormal::new(0.0, cli.variance.unwrap_or(0.2))?,
161 dataterm : DataTerm::L2Squared, 162 dataterm : DataTerm::L2Squared,
162 μ_hat : MU_TRUE_1D_BASIC.into(), 163 μ_hat : MU_TRUE_1D_BASIC.into(),
163 sensor : BallIndicator { r : SensorWidth1D, exponent : Linfinity }, 164 sensor : BallIndicator { r : SensorWidth1D, exponent : Linfinity },
164 spread : base_spread, 165 spread : base_spread,
169 }}) 170 }})
170 }, 171 },
171 Experiment2D => { 172 Experiment2D => {
172 let base_spread = Gaussian { variance : Variance1 }; 173 let base_spread = Gaussian { variance : Variance1 };
173 let spread_cutoff = BallIndicator { r : CutOff1, exponent : Linfinity }; 174 let spread_cutoff = BallIndicator { r : CutOff1, exponent : Linfinity };
174 Box::new(Named { name, data : Experiment { 175 Box::new(Named { name, data : ExperimentV2 {
175 domain : [[0.0, 1.0]; 2].into(), 176 domain : [[0.0, 1.0]; 2].into(),
176 sensor_count : [N_SENSORS_2D; 2], 177 sensor_count : [N_SENSORS_2D; 2],
177 α : cli.alpha.unwrap_or(0.19), // 0.18, //0.17, //0.16, 178 regularisation : Regularisation::Radon(cli.alpha.unwrap_or(0.19)),
178 noise_distr : SerializableNormal::new(0.0, cli.variance.unwrap_or(0.25))?, 179 noise_distr : SerializableNormal::new(0.0, cli.variance.unwrap_or(0.25))?,
179 dataterm : DataTerm::L2Squared, 180 dataterm : DataTerm::L2Squared,
180 μ_hat : MU_TRUE_2D_BASIC.into(), 181 μ_hat : MU_TRUE_2D_BASIC.into(),
181 sensor : BallIndicator { r : SensorWidth2D, exponent : Linfinity }, 182 sensor : BallIndicator { r : SensorWidth2D, exponent : Linfinity },
182 spread : Prod(spread_cutoff, base_spread), 183 spread : Prod(spread_cutoff, base_spread),
188 ]), 189 ]),
189 }}) 190 }})
190 }, 191 },
191 Experiment2DFast => { 192 Experiment2DFast => {
192 let base_spread = HatConv { radius : Hat1 }; 193 let base_spread = HatConv { radius : Hat1 };
193 Box::new(Named { name, data : Experiment { 194 Box::new(Named { name, data : ExperimentV2 {
194 domain : [[0.0, 1.0]; 2].into(), 195 domain : [[0.0, 1.0]; 2].into(),
195 sensor_count : [N_SENSORS_2D; 2], 196 sensor_count : [N_SENSORS_2D; 2],
196 α : cli.alpha.unwrap_or(0.12), //0.10, //0.14, 197 regularisation : Regularisation::Radon(cli.alpha.unwrap_or(0.12)),
197 noise_distr : SerializableNormal::new(0.0, cli.variance.unwrap_or(0.15))?, //0.25 198 noise_distr : SerializableNormal::new(0.0, cli.variance.unwrap_or(0.15))?, //0.25
198 dataterm : DataTerm::L2Squared, 199 dataterm : DataTerm::L2Squared,
199 μ_hat : MU_TRUE_2D_BASIC.into(), 200 μ_hat : MU_TRUE_2D_BASIC.into(),
200 sensor : BallIndicator { r : SensorWidth2D, exponent : Linfinity }, 201 sensor : BallIndicator { r : SensorWidth2D, exponent : Linfinity },
201 spread : base_spread, 202 spread : base_spread,
208 }}) 209 }})
209 }, 210 },
210 Experiment1D_L1 => { 211 Experiment1D_L1 => {
211 let base_spread = Gaussian { variance : Variance1 }; 212 let base_spread = Gaussian { variance : Variance1 };
212 let spread_cutoff = BallIndicator { r : CutOff1, exponent : Linfinity }; 213 let spread_cutoff = BallIndicator { r : CutOff1, exponent : Linfinity };
213 Box::new(Named { name, data : Experiment { 214 Box::new(Named { name, data : ExperimentV2 {
214 domain : [[0.0, 1.0]].into(), 215 domain : [[0.0, 1.0]].into(),
215 sensor_count : [N_SENSORS_1D], 216 sensor_count : [N_SENSORS_1D],
216 α : cli.alpha.unwrap_or(0.1), 217 regularisation : Regularisation::NonnegRadon(cli.alpha.unwrap_or(0.1)),
217 noise_distr : SaltAndPepper::new( 218 noise_distr : SaltAndPepper::new(
218 cli.salt_and_pepper.as_ref().map_or(0.6, |v| v[0]), 219 cli.salt_and_pepper.as_ref().map_or(0.6, |v| v[0]),
219 cli.salt_and_pepper.as_ref().map_or(0.4, |v| v[1]) 220 cli.salt_and_pepper.as_ref().map_or(0.4, |v| v[1])
220 )?, 221 )?,
221 dataterm : DataTerm::L1, 222 dataterm : DataTerm::L1,
228 algorithm_defaults: HashMap::new(), 229 algorithm_defaults: HashMap::new(),
229 }}) 230 }})
230 }, 231 },
231 Experiment1D_L1_Fast => { 232 Experiment1D_L1_Fast => {
232 let base_spread = HatConv { radius : Hat1 }; 233 let base_spread = HatConv { radius : Hat1 };
233 Box::new(Named { name, data : Experiment { 234 Box::new(Named { name, data : ExperimentV2 {
234 domain : [[0.0, 1.0]].into(), 235 domain : [[0.0, 1.0]].into(),
235 sensor_count : [N_SENSORS_1D], 236 sensor_count : [N_SENSORS_1D],
236 α : cli.alpha.unwrap_or(0.12), 237 regularisation : Regularisation::NonnegRadon(cli.alpha.unwrap_or(0.12)),
237 noise_distr : SaltAndPepper::new( 238 noise_distr : SaltAndPepper::new(
238 cli.salt_and_pepper.as_ref().map_or(0.6, |v| v[0]), 239 cli.salt_and_pepper.as_ref().map_or(0.6, |v| v[0]),
239 cli.salt_and_pepper.as_ref().map_or(0.4, |v| v[1]) 240 cli.salt_and_pepper.as_ref().map_or(0.4, |v| v[1])
240 )?, 241 )?,
241 dataterm : DataTerm::L1, 242 dataterm : DataTerm::L1,
249 }}) 250 }})
250 }, 251 },
251 Experiment2D_L1 => { 252 Experiment2D_L1 => {
252 let base_spread = Gaussian { variance : Variance1 }; 253 let base_spread = Gaussian { variance : Variance1 };
253 let spread_cutoff = BallIndicator { r : CutOff1, exponent : Linfinity }; 254 let spread_cutoff = BallIndicator { r : CutOff1, exponent : Linfinity };
254 Box::new(Named { name, data : Experiment { 255 Box::new(Named { name, data : ExperimentV2 {
255 domain : [[0.0, 1.0]; 2].into(), 256 domain : [[0.0, 1.0]; 2].into(),
256 sensor_count : [N_SENSORS_2D; 2], 257 sensor_count : [N_SENSORS_2D; 2],
257 α : cli.alpha.unwrap_or(0.35), 258 regularisation : Regularisation::NonnegRadon(cli.alpha.unwrap_or(0.35)),
258 noise_distr : SaltAndPepper::new( 259 noise_distr : SaltAndPepper::new(
259 cli.salt_and_pepper.as_ref().map_or(0.8, |v| v[0]), 260 cli.salt_and_pepper.as_ref().map_or(0.8, |v| v[0]),
260 cli.salt_and_pepper.as_ref().map_or(0.2, |v| v[1]) 261 cli.salt_and_pepper.as_ref().map_or(0.2, |v| v[1])
261 )?, 262 )?,
262 dataterm : DataTerm::L1, 263 dataterm : DataTerm::L1,
271 ]), 272 ]),
272 }}) 273 }})
273 }, 274 },
274 Experiment2D_L1_Fast => { 275 Experiment2D_L1_Fast => {
275 let base_spread = HatConv { radius : Hat1 }; 276 let base_spread = HatConv { radius : Hat1 };
276 Box::new(Named { name, data : Experiment { 277 Box::new(Named { name, data : ExperimentV2 {
277 domain : [[0.0, 1.0]; 2].into(), 278 domain : [[0.0, 1.0]; 2].into(),
278 sensor_count : [N_SENSORS_2D; 2], 279 sensor_count : [N_SENSORS_2D; 2],
279 α : cli.alpha.unwrap_or(0.40), 280 regularisation : Regularisation::NonnegRadon(cli.alpha.unwrap_or(0.40)),
280 noise_distr : SaltAndPepper::new( 281 noise_distr : SaltAndPepper::new(
281 cli.salt_and_pepper.as_ref().map_or(0.8, |v| v[0]), 282 cli.salt_and_pepper.as_ref().map_or(0.8, |v| v[0]),
282 cli.salt_and_pepper.as_ref().map_or(0.2, |v| v[1]) 283 cli.salt_and_pepper.as_ref().map_or(0.2, |v| v[1])
283 )?, 284 )?,
284 dataterm : DataTerm::L1, 285 dataterm : DataTerm::L1,

Mercurial Repository: pointsource_algs

mercurial