tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Monotone operator equilibrium networks\n",
    "\n",
    "Monotone operator equilibrium networks (MONs) are a form of Deep Equilibrium Model ([Bai et al. 2019](https://arxiv.org/abs/1909.01377)) which guarantee convergence to a unique fixed-point. \n",
    "\n",
    "Unlike traditional deep networks which explicitly iterate some number of non-linear layers, deep equilibrium models (DEQs) directly solve for the fixed point of an \"infinitely deep\" weight-tied, input-injected  network. For example, given nonlinearity $\\sigma$, network weights $W, U, b$, and input $x$, the network could take the form\n",
    "$$z^{k+1} = \\sigma(W z^k + U x + b)$$\n",
    "where $z^k$ are the hidden units at layer $k$. Here $W,U$ could be dense matrices, or they could correspond to more structured linear operators such as convolutions or multi-tiered convolutional operators (see below).\n",
    "DEQs solve directly for the fixed-point of the iteration\n",
    "$$z^\\star = \\sigma(W z^\\star + U x + b).$$\n",
    "\n",
    "But how can we guarantee that such a fixed point exists, is unique, and that our fixed-point solver will converge to it? In practice, DEQs require extensive tuning in order to obtain stable convergence. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fixed-point solving as operator splitting\n",
    "We recast the problem of finding the network fixed point as a form of _monotone operator splitting problem_, which can be solved using iterative operator splitting methods such as _forward-backward_ or _Peaceman-Rachford_ splitting. For an introduction to monotone operator theory see _\"A primer on monotone operator methods\"_ by Ryu and Boyd (2016) or see Appendix A in [our paper](https://arxiv.org/abs/2006.08591) for a very brief overview.\n",
    "\n",
    "In particular, we show that finding the fixed-point $z^*$ is equivalent to finding a solution to the operator splitting problem $0 \\in (X+Y)(z^\\star)$ with the operators\n",
    "\\begin{equation}\n",
    "X(z) = (I - W)(z) - (Ux + b), \\;\\; Y = \\partial f\n",
    "\\end{equation}\n",
    "so long as $\\sigma$ can be represented as $\\sigma(\\cdot) = \\text{prox}^1_f(\\cdot)$ for some (convex, closed, proper) function $f$. Many common nonlinearities used in deep networks can be represented as proximal operators; for example, the ReLU nonlinearity $\\sigma(x) = [x]_+$ is equal to the proximal operator of the indicator of the positive orthant $f(x) = I\\{x \\geq 0\\}$.\n",
    "\n",
    "Another question is how to backpropagate the loss through the network fixed point. That is, we need to multiply by $\\partial z^\\star / \\partial (\\cdot)$ in order to compute\n",
    "\\begin{equation}\n",
    "\\frac{\\partial \\ell}{\\partial (\\cdot) } = \\frac{\\partial \\ell}{\\partial z^\\star} \\frac{\\partial z^\\star}{\\partial (\\cdot)}.\n",
    "\\end{equation}\n",
    "The challenge here is that $z^\\star$ is not an explicit function of the inputs. As is the case with DEQs, we can do this analytically using the implicit function theorem. In fact, analytical backpropagation through the fixed point can itself be cast as an operator splitting problem. Implementations of splitting methods applied to both fixed-point solving and backpropagation can be found in [splitting.py](splitting.py)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Monotone parameterization\n",
    "\n",
    "The operator splitting methods will be guaranteed to converge to a unique solution provided the network weights obey a certain monotone constraint. We can directly parameterize networks such that this condition holds, by having $W$ take the form\n",
    "$$W = (1-m)I - A^T A + B - B^T$$\n",
    "where $m>0$ and there is no constraint on $A$ or $B$.\n",
    "\n",
    "Implementations for fully-connected, convolutional, and multi-scale convolutional networks can be found in [mon.py](mon.py). \n",
    "\n",
    "For fully-connected networks we can directly parameterize $W$ in the above form with $A,B$ being dense matrices (see class `mon.MONSingleFc`). But this can equally well be achieved when $W$ is a convolution (`mon.MONSingleFc`), or consists of multiple tiers of convolutions at different scales (`mon.MONMultiConv`). In this last case we consider $W$ of the form \n",
    "\n",
    "\\begin{equation} \n",
    "W=\\left(\\begin{array}{ccccc}\n",
    "W_{11} & 0 & 0 & \\cdots & 0\\\\\n",
    "W_{21} & W_{22} & 0 & \\cdots & 0 \\\\\n",
    "0 & W_{32} & W_{33} & \\cdots & 0  \\\\\n",
    "\\vdots & \\vdots & \\vdots & \\ddots & \\vdots \\\\\n",
    "0 & 0 & 0 & \\cdots & W_{LL} \\end{array} \\right)\n",
    "\\end{equation}\n",
    "\n",
    "where $W_{ii}$ denotes an $n_i$ channel to $n_i$ channel convolution, and $W_{i+1,i}$ denotes an $n_i$ to $n_{i+1}$ channel, *strided* convolution. Correspondingly, the hidden states have the structured form\n",
    "\n",
    "\\begin{equation}\n",
    "z=\\left(\\begin{array}{c} z_1\\\\\n",
    "z_2\\\\\n",
    "\\vdots \\\\\n",
    "z_L \n",
    "\\end{array} \\right)\n",
    "\\end{equation}\n",
    "\n",
    "where $z_i$ denotes the hidden units at level $i$. In this case, to ensure that the monotone constraint is met, we need to correctly parameterize each of the $W_{ij}$. It works out that the $W_{ii}$ convolutions will have the form\n",
    "$$W_{ii} = (1-m)I - A_{ii}^T A_{ii} - A_{i+1,i}^T A_{i+1,i} + B_{ii} - B_{ii}^T$$\n",
    "and for the final tier $L$\n",
    "$$W_{LL} = (1-m)I - A_{LL}^T A_{LL} + B_{LL} - B_{LL}^T$$\n",
    "and the subdiagonal convolutions will have the form\n",
    "$$W_{i+1,i} = -2 A_{i+1,i+1}^T A_{i+1,i}.$$\n",
    "\n",
    "The modules such as `mon.MONMultiConv` encapsulate the linear part of the network. That is, the forward method of the modules compute $h = Wz + Ux + b$, where $x$ is a minibatch of examples, and $z$ is an initial set of hidden states. Here is an example of the multi-tier convolutional model in use. Note that $h$ will be a set of hidden units $h_i$ of the same shapes as the $z_i$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "shapes of the z_i:\t {'z_1': [4, 8, 34, 34], 'z_2': [4, 16, 18, 18], 'z_3': [4, 32, 10, 10]}\n",
      "shapes of the h_i:\t {'h_1': [4, 8, 34, 34], 'h_2': [4, 16, 18, 18], 'h_3': [4, 32, 10, 10]}\n"
     ]
    }
   ],
   "source": [
    "import mon\n",
    "import torch\n",
    "\n",
    "linear_module = mon.MONMultiConv(in_channels=3, conv_channels=(8,16,32), \n",
    "                         image_size=34, kernel_size=3, m=1.0)\n",
    "\n",
    "\n",
    "#The module knows the correct shape for it's hidden states z_i at each tier for a given batch size\n",
    "n_batch = 4\n",
    "z_shapes = linear_module.z_shape(n_batch=n_batch)\n",
    "\n",
    "print(\"shapes of the z_i:\\t\", \n",
    "      {\"z_{}\".format(i+1):list(z_i_shape) for i,z_i_shape in enumerate(z_shapes)})\n",
    "\n",
    "z = tuple(torch.randn(*s) for s in z_shapes)\n",
    "x = torch.randn(n_batch,3,34,34)\n",
    "\n",
    "#run the forward method of the module\n",
    "h = linear_module(x, *z) \n",
    "\n",
    "print(\"shapes of the h_i:\\t\", \n",
    "      {\"h_{}\".format(i+1):list(h_i.shape) for i,h_i in enumerate(h)})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The operator splitting methods will also need to be able to perform the multiplications $Wz$ and $W^Tz$, which in the multi-tier case involves applying different convolutions to the different $z_i$. Here we test the implementations of the multiplication and transposed multiplication by computing $y^TWz$ two ways:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "y = tuple(torch.randn(*s) for s in linear_module.z_shape(n_batch))\n",
    "z = tuple(torch.randn(*s) for s in linear_module.z_shape(n_batch))\n",
    "\n",
    "#compute Wz using linear_module.multiply\n",
    "Wz = linear_module.multiply(*z)\n",
    "\n",
    "#compute yT(Wz)\n",
    "yTWz = tuple(yi * Wzi for yi, Wzi in zip(y,Wz))\n",
    "u = sum([t.sum() for t in yTWz])\n",
    "\n",
    "#compute WTy using linear_module.multiply_transpose  \n",
    "WTy = linear_module.multiply_transpose(*y)\n",
    "\n",
    "#compute zT(WTy)\n",
    "zTWTy = tuple(zi * WTyi for zi, WTyi in zip(z,WTy))\n",
    "v = sum([t.sum() for t in zTWTy])\n",
    "\n",
    "#assert equal\n",
    "print(((u-v).abs()/v.abs() < 1e-5).item())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inversion\n",
    "\n",
    "Some splitting methods (e.g. Peaceman-Rachford which we use for our experiments) also require multiplying by the inverse $V := (I + \\alpha(I - W))^{-1}$ and by the inverse transpose $V^T$. How can we achieve this when $W$ has this multi-tier form? As we show in the paper, we can efficiently multiply by the inverse of the convolutions in the frequency domain, by computing the FFT of kernels and the $z_i$. Because this multiplication will occur for each iteration of Peaceman-Rachford, we can precompute the kernel inverses in FFT space. Here we verify the behavior of the inverse and inverse transpose multiplications:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\tinverse undoes multiply : \t\t\t [True, True, True]\n",
      "\tinverse transpose undoes multiply transpose:\t [True, True, True]\n"
     ]
    }
   ],
   "source": [
    "#initialize the inverse (alpha*I + beta*W)^-1 in frequency domain\n",
    "alpha, beta = 2.0, -0.5\n",
    "linear_module.init_inverse(alpha, beta)\n",
    "\n",
    "z = tuple(torch.randn(*s) for s in linear_module.z_shape(n_batch))\n",
    "\n",
    "#verify inverse\n",
    "h = linear_module.multiply(*z)\n",
    "#multiplies by inverse by computing the FFTs of the z_i\n",
    "z_inv = linear_module.inverse(*tuple(beta * h_i + alpha * z_i for h_i, z_i in zip(h,z)))\n",
    "print(\"\\tinverse undoes multiply : \\t\\t\\t\", \n",
    "      [(z_i-z_inv_i).norm().item()/z_inv_i.norm().item() < 1e-5 for z_i, z_inv_i in zip(z,z_inv)])\n",
    "\n",
    "# verify inverse transpose\n",
    "h = linear_module.multiply_transpose(*z)\n",
    "z_inv = linear_module.inverse_transpose(*tuple(beta * h_i + alpha * z_i for h_i, z_i in zip(h,z)))\n",
    "print(\"\\tinverse transpose undoes multiply transpose:\\t\", \n",
    "      [(z_i-z_inv_i).norm().item()/z_inv_i.norm().item() < 1e-5 for z_i, z_inv_i in zip(z,z_inv)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Nonlinearity\n",
    "\n",
    "Now we need to implement the nonlinear portion of the network, the function $\\sigma$. As mentioned, the ReLU operator meets our requirements as it can be represented as a prox operator, and we use it throughout. The modules `mon.MONReLU` or `mon.MONBorderReLU` work with single- or multi-tier MONs by applying the ReLU to each tier individually. The `mon.MONBorderReLU` module zeros out the boarder of each $z_i$, which takes care of a detail we have not yet mentioned: inverting a convolution via the FFT requires that the convolution be circular. To negate the effect of the circular convolution, we zero-pad the input and then enforce the padding after the convolution by zeroing out the border in the ReLU."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operator splitting methods\n",
    "\n",
    "As mentioned, both solving for the network fixed-point as well as backpropagate through the fixed point can be formulated as different operator splitting problems, each of which we can solve using either Peacman-Rachform or forward-backward iterative methods. The details of the iteration for each of the problems and methods is given in the paper. For the purposes of this tutorial we will treat these as black-box modules which simply wrap our linear and nonlinear modules. The forward method of the modules solves a splitting problem in order to find the fixed point, while the backward method solves a splitting problem in order to backpropagate the gradient of the loss.\n",
    "\n",
    "The splitting methods are implemented in the modules `splitting.MONForwardBackwardSplitting` and `splitting.MONPeacemanRachford`. We can specify the error tolerance `tol`, the maximum number of iterations `max_iter`, and the parameter `alpha` which is used in defining the operators and affects the convergence rate of the splitting methods. While Peaceman-Rachford will converge for any $\\alpha>0$, forward-backward will only converge for small enough $\\alpha$ (see paper for details). \n",
    "\n",
    "Example usage:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\tForward\n",
      "\t\titer 1: err 2.1194745020714265\n",
      "\t\titer 2: err 0.7950596914974642\n",
      "\t\titer 3: err 0.23239362009955794\n",
      "\t\titer 4: err 0.0642827444903363\n",
      "\t\titer 5: err 0.017080706637280885\n",
      "\t\titer 6: err 0.004418010332183422\n",
      "\tBackward\n",
      "\t\titer 1: err 0.999999992551611\n",
      "\t\titer 2: err 0.45704456247121633\n",
      "\t\titer 3: err 0.11778487426428322\n",
      "\t\titer 4: err 0.028339663407799268\n",
      "\t\titer 5: err 0.006902561548535139\n"
     ]
    }
   ],
   "source": [
    "import splitting as sp\n",
    "\n",
    "linear_module = mon.MONMultiConv(in_channels=3, conv_channels=(8,16,32), \n",
    "                         image_size=34, kernel_size=3, m=1.0)\n",
    "nonlinear_module = mon.MONBorderReLU(border=1)\n",
    "\n",
    "solver = sp.MONPeacemanRachford(linear_module, \n",
    "                                nonlinear_module,\n",
    "                                alpha=1.0,\n",
    "                                tol=1e-2,\n",
    "                                max_iter=50)\n",
    "solver.save_abs_err = True\n",
    "# calling the forward method on the input x\n",
    "out = solver(x)\n",
    "print('\\tForward')\n",
    "for i, err in enumerate(solver.errs):\n",
    "    print('\\t\\titer {}: err {}'.format(i+1, err))\n",
    "\n",
    "# calling the backward method on the input x by backpropagating\n",
    "l = out[0].sum()\n",
    "l.backward()\n",
    "print('\\tBackward')\n",
    "for i, err in enumerate(solver.errs):\n",
    "    print('\\t\\titer {}: err {}'.format(i+1, err))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training\n",
    "\n",
    "The MON consists of the linear and nonlinear modules wrapped in a splitting method solver. For our classification experiments we pass the output of the MON through a final dense layer which outputs logits. The full models which do this are implemented in `train.SingleFcNet`, `train.SingleConvNet`, and `train.MultiConvNet`.\n",
    "\n",
    "The [train.py](train.py) file also contains data loaders for MNIST, SVHN, and CIFAR-10, as well the main training loop. For example usage see [experiments.ipynb](experiments.ipynb). Here we train a small, fully connected model for a single epoch on MNIST. Note that we adjust $\\alpha$ throughout training to minimize the required solver iterations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----tuning alpha----\n",
      "current:  1.0\n",
      "alpha: 1.0\t iters: 6\n",
      "alpha: 0.5\t iters: 5\n",
      "alpha: 0.25\t iters: 8\n",
      "setting to:  0.5\n",
      "--------------\n",
      "\n",
      "Train Epoch: 0.21 [12928/60000 (21%)]\tLoss: 0.4312\tError: 11.72\n",
      "Fwd iters: 5.00\tFwd Time: 0.0016\tBkwd Iters: 6.00\tBkwd Time: 0.0019\n",
      "\n",
      "Train Epoch: 0.43 [25728/60000 (43%)]\tLoss: 0.4182\tError: 11.72\n",
      "Fwd iters: 5.00\tFwd Time: 0.0017\tBkwd Iters: 6.00\tBkwd Time: 0.0019\n",
      "\n",
      "----tuning alpha----\n",
      "current:  0.5\n",
      "alpha: 1.0\t iters: 5\n",
      "alpha: 0.5\t iters: 5\n",
      "alpha: 0.25\t iters: 8\n",
      "setting to:  0.5\n",
      "--------------\n",
      "\n",
      "Train Epoch: 0.64 [38528/60000 (64%)]\tLoss: 0.2624\tError: 8.59\n",
      "Fwd iters: 5.00\tFwd Time: 0.0017\tBkwd Iters: 6.00\tBkwd Time: 0.0020\n",
      "\n",
      "Train Epoch: 0.85 [51328/60000 (85%)]\tLoss: 0.3863\tError: 10.94\n",
      "Fwd iters: 5.00\tFwd Time: 0.0016\tBkwd Iters: 6.00\tBkwd Time: 0.0019\n",
      "\n",
      "Tot train time: 9.227253913879395\n",
      "\n",
      "\n",
      "Test set: Average loss: 0.2773, Error: 803/10000 (8.03%)\n",
      "Tot test time: 1.1329877376556396\n",
      "\n",
      "\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import train\n",
    "\n",
    "trainLoader, testLoader = train.mnist_loaders(train_batch_size=128, test_batch_size=400)\n",
    "\n",
    "model = train.SingleFcNet(sp.MONPeacemanRachford,\n",
    "                        in_dim=28**2,\n",
    "                        out_dim=20,\n",
    "                        alpha=1.0,\n",
    "                        max_iter=300,\n",
    "                        tol=1e-2,\n",
    "                        m=1.0) #parameter which controls the strong monotonicity of W\n",
    "\n",
    "train.train(trainLoader, testLoader,\n",
    "        model,\n",
    "        max_lr=1e-3,\n",
    "        lr_mode='step',  #use step decay learning rate\n",
    "        step=10,      \n",
    "        change_mo=False, #do not adjust momentum during training\n",
    "        epochs=1,\n",
    "        print_freq=100,\n",
    "        tune_alpha=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Results on image benchmarks\n",
    "\n",
    "MONs perform well on several image classification benchmarks. For example, the table shows performance of several instantiations of MON on CIFAR-10. We compare to the performance of Neural ODEs ([Chen et al. 2018](https://arxiv.org/abs/1806.07366)) and Augmented Neural ODEs ([Dupont et al. 2019](https://arxiv.org/abs/1904.01681)), the only other implicit-depth models like MON which guarantee existence of a network fixed-point.   \n",
    " \n",
    "| Method                 | Model size | Acc.       |\n",
    "|---------------------------------------|------------------------|---------------------------|\n",
    "| Neural ODE             | 172K                   | 53.7%                  |\n",
    "| Aug. Neural ODE | 172K                   | 60.6%                  |\n",
    "| MON (ours\\)                    |                        |                           |\n",
    "| ---Single conv.           | 172K                   | **74.1%**      |\n",
    "| ---Multi-tier           | 170K                   | 71.8%                  |\n",
    "| ---Single conv. lg with data aug. | 854K                   | 82.5%             |\n",
    "| ---Multi-tier lg with data aug. | 1M                     | **89.7%** |\n",
    "\n",
    "The code to train these models and all those described in the results section of the paper is given in [`experiments.ipynb`](experiments.ipynb)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Convergence of operator splitting methods\n",
    "\n",
    "We can test the convergence rates of the operator splitting methods on a fully trained model. We load a fully connected network trained on MNIST and test convergence of forward-backward and Peaceman-Rachford splitting for a range of $\\alpha$ values. Note that in this case, for $\\alpha > 0.125$ forward-backward doesn't converge. Peaceman-Rachford is guaranteed to converge for any $\\alpha>0$, and is more efficent than forward-backward for the correct choice of $\\alpha$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import utils\n",
    "from matplotlib import pyplot  as plt\n",
    "%matplotlib inline\n",
    "\n",
    "\n",
    "# test Peaceman-Rachford convergence for range of alpha values\n",
    "trainLoader, testLoader = train.mnist_loaders(train_batch_size=128, test_batch_size=400)\n",
    "for alpha in [1.0, 0.5, 0.25, 0.125]:\n",
    "    model = train.SingleFcNet(sp.MONPeacemanRachford,\n",
    "                            in_dim=28**2,\n",
    "                            out_dim=87,\n",
    "                            alpha=alpha,\n",
    "                            max_iter=300,\n",
    "                            tol=1e-5,\n",
    "                            m=1.0)\n",
    "\n",
    "    model.load_state_dict(torch.load(\"mnist_fc_model_trained.pt\", map_location=torch.device('cpu')))\n",
    "\n",
    "    errs = utils.get_splitting_stats(testLoader,model)\n",
    "    plt.semilogy(errs, label=\"alpha = {}\".format(alpha))\n",
    "plt.ylabel(\"error\")\n",
    "plt.xlabel(\"iterations\")\n",
    "plt.title('Peaceman-Rachford convergence')\n",
    "plt.legend()\n",
    "plt.show()\n",
    "\n",
    "# test forward-backward convergence for range of alpha values\n",
    "trainLoader, testLoader = train.mnist_loaders(train_batch_size=128, test_batch_size=400)\n",
    "\n",
    "for alpha in [1.0, 0.5, 0.25, 0.125]:\n",
    "    model = train.SingleFcNet(sp.MONForwardBackwardSplitting,\n",
    "                            in_dim=28**2,\n",
    "                            out_dim=87,\n",
    "                            alpha=alpha,\n",
    "                            max_iter=300,\n",
    "                            tol=1e-5,\n",
    "                            m=1.0)\n",
    "\n",
    "    model.load_state_dict(torch.load(\"mnist_fc_model_trained.pt\", map_location=torch.device('cpu')))\n",
    "\n",
    "    errs = utils.get_splitting_stats(testLoader,model)\n",
    "    plt.semilogy(errs, label=\"alpha = {}\".format(alpha))\n",
    "plt.ylabel(\"error\")\n",
    "plt.xlabel(\"iterations\")\n",
    "plt.title('forward-backward convergence')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  },
  "pycharm": {
   "stem_cell": {
    "cell_type": "raw",
    "source": [],
    "metadata": {
     "collapsed": false
    }
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}