minor: cleaned up TV and added tutorial

Author: mrava87

docs/source/api/index.rst

@@ -141,6 +141,7 @@ Primal
     HQS
     LinearizedADMM
     ProximalGradient
+    AcceleratedProximalGradient
     GeneralizedProximalGradient
     ProximalPoint
     TwIST

pyproximal/optimization/primal.py

@@ -1,4 +1,5 @@
 import time
+import warnings
 import numpy as np
 
 from math import sqrt
@@ -100,9 +101,9 @@ def ProximalPoint(prox, x0, tau, niter=10, callback=None, show=False):
 
 
 def ProximalGradient(proxf, proxg, x0, tau=None, beta=0.5,
-                                epsg=1., niter=10, niterback=100,
-                                acceleration='vandenberghe',
-                                callback=None, show=False):
+                     epsg=1., niter=10, niterback=100,
+                     acceleration=None,
+                     callback=None, show=False):
     r"""Proximal gradient (optionnally accelerated)
 
     Solves the following minimization problem using (Accelerated) Proximal
@@ -131,7 +132,7 @@ def ProximalGradient(proxf, proxg, x0, tau=None, beta=0.5,
         backtracking is used to adaptively estimate the best tau at each
         iteration. Finally note that :math:`\tau` can be chosen to be a vector
         when dealing with problems with multiple right-hand-sides
-    beta : obj:`float`, optional
+    beta : :obj:`float`, optional
         Backtracking parameter (must be between 0 and 1)
     epsg : :obj:`float` or :obj:`np.ndarray`, optional
         Scaling factor of g function
@@ -239,7 +240,7 @@ def ProximalGradient(proxf, proxg, x0, tau=None, beta=0.5,
         # update y
         if acceleration == 'vandenberghe':
             omega = iiter / (iiter + 3)
-        elif acceleration== 'fista':
+        elif acceleration == 'fista':
             told = t
             t = (1. + np.sqrt(1. + 4. * t ** 2)) / 2.
             omega = ((told - 1.) / t)
@@ -264,9 +265,31 @@ def ProximalGradient(proxf, proxg, x0, tau=None, beta=0.5,
         print('---------------------------------------------------------\n')
     return x
 
-def GeneralizedProximalGradient(proxfs, proxgs, x0, tau=None, beta=0.5,
+
+def AcceleratedProximalGradient(proxf, proxg, x0, tau=None, beta=0.5,
+                                epsg=1., niter=10, niterback=100,
+                                acceleration='vandenberghe',
+                                callback=None, show=False):
+    r"""Accelerated Proximal gradient
+
+    This is a thin wrapper around :func:`pyproximal.optimization.primal.ProximalGradient` with
+    ``vandenberghe`` or ``fista``acceleration. See :func:`pyproximal.optimization.primal.ProximalGradient`
+    for details.
+
+    """
+    warnings.warn('AcceleratedProximalGradient has been integrated directly into ProximalGradient '
+                  'from v0.5.0. It is recommended to start using ProximalGradient by selecting the '
+                  'appropriate acceleration parameter as this behaviour will become default in '
+                  'version v1.0.0 and AcceleratedProximalGradient will be removed.', FutureWarning)
+    return ProximalGradient(proxf, proxg, x0, tau=tau, beta=beta,
+                            epsg=epsg, niter=niter, niterback=niterback,
+                            acceleration=acceleration,
+                            callback=callback, show=show)
+
+
+def GeneralizedProximalGradient(proxfs, proxgs, x0, tau=None,
                                 epsg=1., niter=10,
-                                acceleration='None',
+                                acceleration=None,
                                 callback=None, show=False):
     r"""Generalized Proximal gradient
 
@@ -285,9 +308,9 @@ def GeneralizedProximalGradient(proxfs, proxgs, x0, tau=None, beta=0.5,
     Parameters
     ----------
     proxfs : :obj:`List of pyproximal.ProxOperator`
-        Proximal operators of the f_i functions (must have ``grad`` implemented)
+        Proximal operators of the :math:`f_i` functions (must have ``grad`` implemented)
     proxgs : :obj:`List of pyproximal.ProxOperator`
-        Proximal operators of the g_j functions
+        Proximal operators of the :math:`g_j` functions
     x0 : :obj:`numpy.ndarray`
         Initial vector
     tau : :obj:`float` or :obj:`numpy.ndarray`, optional
@@ -296,8 +319,6 @@ def GeneralizedProximalGradient(proxfs, proxgs, x0, tau=None, beta=0.5,
         the Lipschitz constant of :math:`\sum_{i=1}^n \nabla f_i`. When ``tau=None``,
         backtracking is used to adaptively estimate the best tau at each
         iteration.
-    beta : obj:`float`, optional
-        Backtracking parameter (must be between 0 and 1)
     epsg : :obj:`float` or :obj:`np.ndarray`, optional
         Scaling factor of g function
     niter : :obj:`int`, optional
@@ -323,7 +344,7 @@ def GeneralizedProximalGradient(proxfs, proxgs, x0, tau=None, beta=0.5,
     .. math::
         \text{for } j=1,\cdots,n, \\
         ~~~~\mathbf z_j^{k+1} = \mathbf z_j^{k} + \eta_k (prox_{\frac{\tau^k}{\omega_j} g_j}(2 \mathbf{x}^{k} - z_j^{k}) 
-        - \tau^k \sum_{i=1}^n \nabla f_i(\mathbf{x}^{k})) - \mathbf{x}^{k} - \\
+        - \tau^k \sum_{i=1}^n \nabla f_i(\mathbf{x}^{k})) - \mathbf{x}^{k} \\
         \mathbf{x}^{k+1} = \sum_{j=1}^n \omega_j f_j \\
         
     where :math:`\sum_{j=1}^n \omega_j=1`. 
@@ -343,10 +364,10 @@ def GeneralizedProximalGradient(proxfs, proxgs, x0, tau=None, beta=0.5,
               '---------------------------------------------------------\n'
               'Proximal operators (f): %s\n'
               'Proximal operators (g): %s\n'
-              'tau = %10e\tbeta=%10e\nepsg = %s\tniter = %d\n' % ([type(proxf) for proxf in proxfs],
+              'tau = %10e\nepsg = %s\tniter = %d\n' % ([type(proxf) for proxf in proxfs],
                                                          [type(proxg) for proxg in proxgs],
                                                          0 if tau is None else tau,
-                                                         beta, epsg_print, niter))
+                                                         epsg_print, niter))
         head = '   Itn       x[0]          f           g       J=f+eps*g'
         print(head)
 
@@ -373,7 +394,7 @@ def GeneralizedProximalGradient(proxfs, proxgs, x0, tau=None, beta=0.5,
             tmp = 2 * y - zs[i] - tau * grad
             tmp[:] = proxg.prox(tmp, tau *len(proxgs) )
             zs[i] += epsg * (tmp - y)
-            sol += zs[i]/len(proxgs)
+            sol += zs[i] / len(proxgs)
         x[:] = sol.copy()
 
         # update y

pyproximal/proximal/L21.py

@@ -11,7 +11,7 @@ class L21(ProxOperator):
 
     Parameters
     ----------
-    ndims : :obj:`int`
+    ndim : :obj:`int`
         Number of dimensions :math:`N_{dim}`. Used to reshape the input array
         in a matrix of size :math:`N_{dim} \times N'_{x}` where
         :math:`N'_x = \frac{N_x}{N_{dim}}`. Note that the input