Merge branch 'dev' into dev

Author: mrava87

CHANGELOG.md

@@ -1,12 +1,24 @@
+# 0.5.0
+
+:vertical_traffic_light: :vertical_traffic_light: This is the latest release supporting PyLops v1.
+:vertical_traffic_light: :vertical_traffic_light:
+
+* Added  ``pyproximal.proximal.Log1`` operator
+* Allow ``radius`` parameter of ``pyproximal.optimization.primal.L0`` to be a function
+* Allow ``tau`` parameter of ``pyproximal.optimization.primal.HQS`` to be a vector
+  and change over iterations
+* Added ``z0`` to ``pyproximal.optimization.primal.HQS``
+* Added ``factorize`` option to ``densesolver`` of ``pyproximal.proximal.L2``
+
 # 0.4.0
 * Added ``pyproximal.optimization.primal.ADMML2``,
-  ``pyproximal.optimization.primal.HQS``,
+  `pyproximal.optimization.primal.HQS`,
   and ``pyproximal.optimization.pnp.PlugAndPlay`` solvers
 * Added ``pyproximal.proximal.ETP``, ``pyproximal.proximal.Geman``,
-  ``pyproximal.proximal.L0``, ``pyproximal.proximal.Log``,
+  ``pyproximal.proximal.L0`, ``pyproximal.proximal.Log``,
   ``pyproximal.proximal.QuadraticEnvelopeCard``, ``pyproximal.proximal.SCAD``
   operators.
-* Allow `tau` parameter of proximal operators to be a vector to handle problems with
+* Allow ``tau`` parameter of proximal operators to be a vector to handle problems with
   multiple right-hand sides.
 
 # 0.3.0

docs/source/changelog.rst

@@ -3,6 +3,20 @@
 Changelog
 =========
 
+Version 0.5.0
+--------------
+*Released on: 20/08/2022*
+
+|:vertical_traffic_light:| |:vertical_traffic_light:| This is the latest release supporting PyLops v1.
+|:vertical_traffic_light:| |:vertical_traffic_light:|
+
+* Added :py:class:`pyproximal.proximal.Log1` operator
+* Allow ``radius`` parameter of :py:class:`pyproximal.optimization.primal.L0` to be a function
+* Allow ``tau`` parameter of :py:class:`pyproximal.optimization.primal.HQS` to be a vector
+  and change over iterations
+* Added ``z0`` to :py:class:`pyproximal.optimization.primal.HQS`
+* Added ``factorize`` option to ``densesolver`` of :py:class:`pyproximal.proximal.L2`
+
 Version 0.4.0
 --------------
 *Released on: 05/06/2022*
@@ -14,7 +28,7 @@ Version 0.4.0
   :py:class:`pyproximal.proximal.L0`, :py:class:`pyproximal.proximal.Log`,
   :py:class:`pyproximal.proximal.QuadraticEnvelopeCard`, :py:class:`pyproximal.proximal.SCAD`
   operators.
-* Allow `tau` parameter of proximal operators to be a vector to handle problems with
+* Allow ``tau`` parameter of proximal operators to be a vector to handle problems with
   multiple right-hand sides.
 
 Version 0.3.0

docs/source/conf.py

@@ -23,7 +23,7 @@
     'numpydoc',
     'nbsphinx',
     'sphinx_gallery.gen_gallery',
-    #'sphinx.ext.napoleon',
+    'sphinxemoji.sphinxemoji',
 ]
 
 # intersphinx configuration
@@ -66,7 +66,9 @@
     # Modules for which function level galleries are created.
     'doc_module': 'pyproximal',
     # Insert links to documentation of objects in the examples
-    'reference_url': {'pyproximal': None}
+    'reference_url': {'pyproximal': None},
+    # Allow animations
+    'matplotlib_animations': True,
 }
 
 # Always show the source code that generates a plot

environment-dev.yml

@@ -23,4 +23,5 @@ dependencies:
     - sphinx-rtd-theme
     - sphinx-gallery
     - nbsphinx
-    - image
+    - image
+    - sphinxemoji

environment.yml

@@ -5,4 +5,4 @@ dependencies:
   - python>=3.8.12
   - numpy>=1.15.0
   - scipy>=1.8.0
-  - pylops>=2.0.0
+  - pylops>=2.0.0

pyproximal/optimization/primal.py

@@ -183,7 +183,7 @@ def ProximalGradient(proxf, proxg, x0, tau=None, beta=0.5,
     \nabla f(\mathbf{y})^T (\mathbf{x} - \mathbf{y}) +
     1/(2\tau)||\mathbf{x} - \mathbf{y}||_2^2`.
 
-    Different accellerations are provided:
+    Different accelerations are provided:
 
     - ``acceleration=None``: :math:`\omega^k = 0`;
     - `acceleration=vandenberghe`` [1]_: :math:`\omega^k = k / (k + 3)` for `
@@ -211,10 +211,10 @@ def ProximalGradient(proxf, proxg, x0, tau=None, beta=0.5,
               '---------------------------------------------------------\n'
               'Proximal operator (f): %s\n'
               'Proximal operator (g): %s\n'
-              'tau = %10e\tbeta=%10e\n'
+              'tau = %s\tbeta=%10e\n'
               'epsg = %s\tniter = %d\t'
               'niterback = %d\n' % (type(proxf), type(proxg),
-                                    0 if tau is None else tau, beta,
+                                    'Adaptive' if tau is None else str(tau), beta,
                                     epsg_print, niter, niterback))
         head = '   Itn       x[0]          f           g       J=f+eps*g'
         print(head)

pyproximal/optimization/segmentation.py

@@ -68,7 +68,7 @@ def Segment(y, cl, sigma, alpha, clsigmas=None, z=None, niter=10, x0=None,
     :math:`\mathbf{\sigma}=[\sigma_1, ..., \sigma_{N_{cl}}]^T` are vectors
     representing the optimal mean and standard deviations for each class.
 
-    .. [1] Chambolle, and A., Pock, "A first-order primal-dual algorithm for
+    .. [1] Chambolle, and A., Pock, "A first-order primal-dual algorithm for
         convex problems with applications to imaging", Journal of Mathematical
         Imaging and Vision, 40, 8pp. 120–145. 2011.
 

pyproximal/utils/bilinear.py

@@ -11,6 +11,8 @@ class BilinearOperator():
       :math:`\nabla_x H`
     - ``grady``: a method evaluating the gradient over :math:`\mathbf{y}`:
       :math:`\nabla_y H`
+    - ``grad``: a method returning the stacked gradient vector over
+      :math:`\mathbf{x},\mathbf{y}`: :math:`[\nabla_x H`, [\nabla_y H]`
     - ``lx``: Lipschitz constant of :math:`\nabla_x H`
     - ``ly``: Lipschitz constant of :math:`\nabla_y H`
 
@@ -33,6 +35,9 @@ def gradx(self, x):
     def grady(self, y):
         pass
 
+    def grad(self, y):
+        pass
+
     def lx(self, x):
         pass
 
@@ -100,7 +105,9 @@ def __init__(self, X, Y, d, Op=None):
         self.shapex = (self.n * self.m, self.n * self.k)
         self.shapey = (self.n * self.m, self.m * self.k)
 
-    def __call__(self, x, y):
+    def __call__(self, x, y=None):
+        if y is None:
+            x, y = x[:self.n * self.k],  x[self.n * self.k:]
         xold = self.x.copy()
         self.updatex(x)
         res = self.d - self._matvecy(y)
@@ -159,3 +166,11 @@ def grady(self, y):
             r = r.reshape(self.n, self.m)
         g = -self.x.reshape(self.n, self.k).T @ r
         return g.ravel()
+
+    def grad(self, x):
+        self.updatex(x[:self.n * self.k])
+        self.updatey(x[self.n * self.k:])
+        gx = self.gradx(x[:self.n * self.k])
+        gy = self.grady(x[self.n * self.k:])
+        g = np.hstack([gx, gy])
+        return g

requirements-dev.txt

@@ -15,4 +15,5 @@ sphinx-rtd-theme
 sphinx-gallery
 numpydoc
 nbsphinx
-image
+image
+sphinxemoji