CR-Sparse: XLA accelerated algorithms for inverse problems in sparse representations and compressive sensing

[shailesh1729]

Submitting Author: Shailesh Kumar (@shailesh1729)
Package Name: CR-Sparse
One-Line Description of Package: XLA accelerated algorithms for inverse problems in sparse representations and compressive sensing
Repository Link (if existing): https://github.com/carnotresearch/cr-sparse
Documentation: https://carnotresearch.github.io/cr-sparse/

---

Description

This library aims to provide XLA/JAX based Python implementations for
various algorithms related to:

• Sparse approximation
• Compressive sensing

The library also provides

• Various simple dictionaries and sensing matrices
• Sample data generation utilities
• Framework for evaluation of sparse recovery algorithms

Addition information

• An evaluation of the sparse recovery performance of algorithms included in the package
• Some speed benchmarks

Scope

• Please indicate which category or categories this package falls under:

  • Data retrieval
  • Data extraction
  • Data munging
  • Data deposition
  • Data visualization
  • Reproducibility
  • Geospatial
  • Education
  • Unsure/Other (explain below)

• Explain how the and why the package falls under these categories (briefly, 1-2 sentences). Please note any areas you are unsure of:

The sparse recovery algorithms reconstruct sparse representations of a signal or a set of measurements in a dictionary (which is an overcomplete basis). The closest category I can think of is data munging.

• Who is the target audience and what are the scientific applications of this package?

Compressive sensing has applications in areas like photography, holography, facial recognition, magnetic resonance imaging, etc.
Sparse representations have applications in areas like image deblurring, denoising, dictionary learning, image compression, inpainting etc.

• Are there other Python packages that accomplish the same thing? If so, how does yours differ?

scikit-learn contains linear models which include implementations of algorithms like orthogonal matching pursuit (OMP), LASSO, LARS, OLS, etc.

CR-Sparse implements these algorithms using a functional programming paradigm built on top of JAX. This enables it to use immense optimization opportunities provided by the XLA compiler. In addition, the code can be deployed on GPUs and TPUs without any modification. These are significant advantages compared to the scikit-learn implementation.

The coverage of greedy sparse recovery algorithms in this package is bigger. E.g. it includes implementations of hard thresholding pursuit, compressive sampling matching pursuit, iterative hard thresholding, etc. in a single package.

We are also adding implementations for L1 minimization (convex optimization) based algorithms.

• Any other questions or issues we should be aware of?:

This is a pre-submission enquiry to understand if the CR-sparse package described below fits the submission criteria for pyOpenSci. Please do let us know what more should be done.

P.S. *Have feedback/comments about our review process? Leave a comment here

[NickleDave]

Hi @shailesh1729 thank you for your interest in pyOpenSci.

I actually work with compressive sensing in my day job and think it's great to see some work on this in the Python space.

I do think this is out of scope for pyOpenSci though.
We are mainly focused on tooling for open science.
E.g., if you built a tool that made it easier to download datasets from a repository of MRI images, say, to test compressive sensing algorithms or whatever else you wanted to do with it, that would be in scope (that would be "data retrieval").

Have you considered submission at JOSS?
https://joss.theoj.org/

[NickleDave]

This is off-topic for the question of scope, but some related repos just in case you're not aware of them already:

• https://github.com/nikcleju/pyCSalgos
• https://github.com/SebastianSemper/camiba
• https://github.com/SIP-AAU/Magni
• https://github.com/ngcthuong/Reproducible-Deep-Compressive-Sensing
• https://github.com/dedupeio/pylbfgs <-- nice Python wrapper around LBFGS that let's you solve L1-constrained problems with OWL-QN

I get that you have different goals than most of them--building on top of XLA/JAX, which is great--but you might be curious about previous attempts at APIs, algorithms, etc.

[palacio-tech]

@NickleDave Thank you for your feedback. Now I better understand the scope of pyOpenSci. I will try to submit it to JOSS.

Thank you for the references for previous works. Yes, I am slowly implementing these ideas in XLA/JAX. I was aware of some of the previous work but not all of them. This will be helpful.

[NickleDave]

Happy I could help!

I'll go ahead and close for now.

[lwasser]

thank you both!