pointsource_algs: comparison src/run.rs

-:bd13c2ae3450
+:56c8adc32b09
 };
 use alg_tools::logger::Logger;
 use alg_tools::error::DynError;
 use alg_tools::tabledump::TableDump;
 use alg_tools::sets::Cube;
-use alg_tools::mapping::RealMapping;
+use alg_tools::mapping::{RealMapping, Differentiable};
 use alg_tools::nalgebra_support::ToNalgebraRealField;
 use alg_tools::euclidean::Euclidean;
-use alg_tools::norms::L1;
 use alg_tools::lingrid::lingrid;
 use alg_tools::sets::SetOrd;
 use crate::kernels::*;
 use crate::types::*;
 use crate::measures::*;
 use crate::measures::merging::SpikeMerging;
 use crate::forward_model::*;
 use crate::fb::{
 FBConfig,
+FBGenericConfig,
 pointsource_fb_reg,
-FBMetaAlgorithm,
+pointsource_fista_reg,
-FBGenericConfig,
+};
+use crate::sliding_fb::{
+SlidingFBConfig,
+pointsource_sliding_fb_reg
 };
 use crate::pdps::{
 PDPSConfig,
-L2Squared,
 pointsource_pdps_reg,
 };
 use crate::frank_wolfe::{
 FWConfig,
 FWVariant,
 use crate::subproblem::InnerSettings;
 use crate::seminorms::*;
 use crate::plot::*;
 use crate::{AlgorithmOverrides, CommandLineArgs};
 use crate::tolerance::Tolerance;
-use crate::regularisation::{Regularisation, RadonRegTerm, NonnegRadonRegTerm};
+use crate::regularisation::{
+Regularisation,
+RadonRegTerm,
+NonnegRadonRegTerm
+};
+use crate::dataterm::{
+L1,
+L2Squared
+};
+use alg_tools::norms::L2;
 /// Available algorithms and their configurations
 #[derive(Copy, Clone, Debug, Serialize, Deserialize)]
 pub enum AlgorithmConfig<F : Float> {
 FB(FBConfig<F>),
+FISTA(FBConfig<F>),
 FW(FWConfig<F>),
 PDPS(PDPSConfig<F>),
+SlidingFB(SlidingFBConfig<F>),
 }
 fn unpack_tolerance<F : Float>(v : &Vec<F>) -> Tolerance<F> {
 assert!(v.len() == 3);
 Tolerance::Power { initial : v[0], factor : v[1], exponent : v[2] }
 FB(fb) => FB(FBConfig {
 τ0 : cli.tau0.unwrap_or(fb.τ0),
 insertion : override_fb_generic(fb.insertion),
 .. fb
 }),
+FISTA(fb) => FISTA(FBConfig {
+τ0 : cli.tau0.unwrap_or(fb.τ0),
+insertion : override_fb_generic(fb.insertion),
+.. fb
+}),
 PDPS(pdps) => PDPS(PDPSConfig {
 τ0 : cli.tau0.unwrap_or(pdps.τ0),
 σ0 : cli.sigma0.unwrap_or(pdps.σ0),
 acceleration : cli.acceleration.unwrap_or(pdps.acceleration),
 insertion : override_fb_generic(pdps.insertion),
 }),
 FW(fw) => FW(FWConfig {
 merging : cli.merging.clone().unwrap_or(fw.merging),
 tolerance : cli.tolerance.as_ref().map(unpack_tolerance).unwrap_or(fw.tolerance),
 .. fw
-})
+}),
+SlidingFB(sfb) => SlidingFB(SlidingFBConfig {
+τ0 : cli.tau0.unwrap_or(sfb.τ0),
+insertion : override_fb_generic(sfb.insertion),
+.. sfb
+}),
 }
 }
 }
 /// Helper struct for tagging and [`AlgorithmConfig`] or [`Experiment`] with a name.
 #[clap(name = "fwrelax")]
 FWRelax,
 /// The μPDPS primal-dual proximal splitting method
 #[clap(name = "pdps")]
 PDPS,
+/// The Sliding FB method
+#[clap(name = "sliding_fb", alias = "sfb")]
+SlidingFB,
 }
 impl DefaultAlgorithm {
 /// Returns the algorithm configuration corresponding to the algorithm shorthand
 pub fn default_config<F : Float>(&self) -> AlgorithmConfig<F> {
 use DefaultAlgorithm::*;
 match *self {
 FB => AlgorithmConfig::FB(Default::default()),
-FISTA => AlgorithmConfig::FB(FBConfig{
+FISTA => AlgorithmConfig::FISTA(Default::default()),
-meta : FBMetaAlgorithm::InertiaFISTA,
-.. Default::default()
-}),
 FW => AlgorithmConfig::FW(Default::default()),
 FWRelax => AlgorithmConfig::FW(FWConfig{
 variant : FWVariant::Relaxed,
 .. Default::default()
 }),
 PDPS => AlgorithmConfig::PDPS(Default::default()),
+SlidingFB => AlgorithmConfig::SlidingFB(Default::default()),
 }
 }
 /// Returns the [`Named`] algorithm corresponding to the algorithm shorthand
 pub fn get_named<F : Float>(&self) -> Named<AlgorithmConfig<F>> {
 Named<$type<F, NoiseDistr, S, K, P, N>>
 where F : ClapFloat + nalgebra::RealField + ToNalgebraRealField<MixedType=F>,
 [usize; N] : Serialize,
 S : Sensor<F, N> + Copy + Serialize + std::fmt::Debug,
 P : Spread<F, N> + Copy + Serialize + std::fmt::Debug,
-Convolution<S, P>: Spread<F, N> + Bounded<F> + LocalAnalysis<F, Bounds<F>, N> + Copy,
+Convolution<S, P>: Spread<F, N> + Bounded<F> + LocalAnalysis<F, Bounds<F>, N> + Copy
+// TODO: shold not have differentiability as a requirement, but
+// decide availability of sliding based on it.
+//+ for<'b> Differentiable<&'b Loc<F, N>, Output = Loc<F, N>>,
+// TODO: very weird that rust only compiles with Differentiable
+// instead of the above one on references, which is required by
+// poitsource_sliding_fb_reg.
++ Differentiable<Loc<F, N>, Output = Loc<F, N>>
++ Lipschitz<L2>,
+// <DefaultSG<F, S, P, N> as ForwardModel<Loc<F, N>, F>::PreadjointCodomain : for<'b> Differentiable<&'b Loc<F, N>, Output = Loc<F, N>>,
 AutoConvolution<P> : BoundedBy<F, K>,
 K : SimpleConvolutionKernel<F, N> + LocalAnalysis<F, Bounds<F>, N>
 + Copy + Serialize + std::fmt::Debug,
+//+ Differentiable<Loc<F, N>, Output = Loc<F, N>>, // TODO: shouldn't need to assume differentiability
 Cube<F, N>: P2Minimise<Loc<F, N>, F> + SetOrd,
 PlotLookup : Plotting<N>,
 DefaultBT<F, N> : SensorGridBT<F, S, P, N, Depth=DynamicDepth> + BTSearch<F, N>,
 BTNodeLookup: BTNode<F, usize, Bounds<F>, N>,
 DiscreteMeasure<Loc<F, N>, F> : SpikeMerging<F>,
 not_implemented();
 continue
 }
 }
 },
+AlgorithmConfig::FISTA(ref algconfig) => {
+match (regularisation, dataterm) {
+(Regularisation::NonnegRadon(α), DataTerm::L2Squared) => {
+running();
+pointsource_fista_reg(
+&opA, &b, NonnegRadonRegTerm(α), &op𝒟, algconfig,
+iterator, plotter
+)
+},
+(Regularisation::Radon(α), DataTerm::L2Squared) => {
+running();
+pointsource_fista_reg(
+&opA, &b, RadonRegTerm(α), &op𝒟, algconfig,
+iterator, plotter
+)
+},
+_ => {
+not_implemented();
+continue
+}
+}
+},
+AlgorithmConfig::SlidingFB(ref algconfig) => {
+match (regularisation, dataterm) {
+(Regularisation::NonnegRadon(α), DataTerm::L2Squared) => {
+running();
+pointsource_sliding_fb_reg(
+&opA, &b, NonnegRadonRegTerm(α), &op𝒟, algconfig,
+iterator, plotter
+)
+},
+(Regularisation::Radon(α), DataTerm::L2Squared) => {
+running();
+pointsource_sliding_fb_reg(
+&opA, &b, RadonRegTerm(α), &op𝒟, algconfig,
+iterator, plotter
+)
+},
+_ => {
+not_implemented();
+continue
+}
+}
+},
 AlgorithmConfig::PDPS(ref algconfig) => {
 running();
 match (regularisation, dataterm) {
 (Regularisation::NonnegRadon(α), DataTerm::L2Squared) => {
 pointsource_pdps_reg(

Mercurial > repos > pointsource_algs / file comparison

comparison: src/run.rs

src/run.rs