{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Learning algorithms for sparse regression\n",
    "\n",
    "In many (machine) learning tasks, we have access to a great number of input features, whose impact on the learner's output is in turn controlled by one or more parameters that the learning algorithm must tune. In reality, however, a *sparse* solution, in which the effects of most features are null, is often more useful."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Contents:__\n",
    "\n",
    "- <a href=\"#background\">Basic background</a>\n",
    "- <a href=\"#coorddesc\">Under the squared loss: coordinate descent</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Having set up the basic machinery for iterative algorithms in previous lessons, in this lesson we implement procedures which are designed to enforce a certain (controllable) degree of sparseness on the algorithm output."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"background\"></a>\n",
    "## Basic background\n",
    "\n",
    "In the now-classic words of R. Tibshirani (1996), there are two important reasons for seeking out sparse solutions when we have many parameters (often more than the number of samples). One is *prediction accuracy*:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> _\"[Naive estimates] often have low bias but large variance; prediction accuracy can sometimes be improved by shrinking or setting to 0 some coefficients.\"_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another reason is is *interpretation*:\n",
    "\n",
    "> _\"With a large number of predictors, we often would like to determine a smaller subset that exhibits the strongest effects.\"_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Indeed, consider the plethora of stimulus that the human brain encounters in daily activities. Despite the richness of this input, measurement of brain activity reflects a certain degree of \"selectivity\" towards certain stimulus (image via Haxby et al., 2001):"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/fmri_response.jpg\" alt=\"Image source: Haxby et al. (2001)\" width=\"480\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When statistical learning procedures are carried out by machines, and they have access to a large number of input features, we must take measures to ensure that the solutions they arrive at are sufficiently sparse."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/sparse_matrix.png\" alt=\"Image: Sparse matrix image\" width=\"240\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While the notion of sparsity is inherently model-dependent, most are formulated such that parameters with a value of $0$ correspond to a certain feature having null impact. Thus, if our parameter vector $w \\in \\mathbb{R}^{d}$ contains a large number of zeros while performing as desired, then it is a good sparse solution. Most directly, the $\\ell_{0}$ norm measures this as"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\\begin{align*}\n",
    "\\|w\\|_{0} = \\left|\\{j \\in [d]: w_{j} \\neq 0\\}\\right|.\n",
    "\\end{align*}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the risk minimization setting then, where $R(w) = \\mathbf{E}_{Z} l(w;z)$, the ideal objective would be something like\n",
    "\n",
    "\\begin{align*}\n",
    "\\min_{w \\in \\mathbb{R}^{d}} R(w), \\quad \\text{s.t. } \\|w\\|_{0} \\leq \\gamma_{0}.\n",
    "\\end{align*}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is computationally very challenging, but a rich literature from both the statistics and signal processing communities has demonstrated that one can achieve a small $\\ell_{0}$ norm by pursuing a small enough $\\ell_{1}$ norm. Changing this condition we get\n",
    "\n",
    "\\begin{align*}\n",
    "\\min_{w \\in \\mathbb{R}^{d}} R(w), \\quad \\text{s.t. } \\|w\\|_{1} \\leq \\gamma_{1}\n",
    "\\end{align*}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "as an ideal routine, and in practice a natural approach is to attempt to minimize\n",
    "\n",
    "\\begin{align*}\n",
    "L_{\\lambda}(w) = \\frac{1}{n}\\sum_{i=1}^{n} l(w;z_{i}) + \\lambda \\sum_{j=1}^{d}|w_{j}|.\n",
    "\\end{align*}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is from this point in our formulation that we begin to dig into specific algorithms."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"coorddesc\"></a>\n",
    "## Coordinate descent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Perhaps the canonical scenario of interest is the \"least-squares linear regression\" model, namely the setting where\n",
    "\n",
    "\\begin{align*}\n",
    "l(w;z) = (y-w^{T}x)^{2}, \\quad z=(x,y) \\in \\mathbb{R}^{d+1}.\n",
    "\\end{align*}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The objective function then takes the form\n",
    "\n",
    "\\begin{align*}\n",
    "L_{\\lambda}(w) = \\frac{1}{n} \\sum_{i=1}^{n} (y_{i}-w^{T}x_{i})^{2} + \\lambda\\|w\\|_{1}.\n",
    "\\end{align*}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An intuitively appealing and computationally straightforward approach to solving this problem is the so-called *coordinate descent* strategy. The underlying idea is extremely simple: __update one parameter at a time__. That's all there is to it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To derive an explicit update, note that there are (obviously) only two possibilities: with all else fixed, a local minimum is either achieved at $w_j = 0$ or when $w_j \\neq 0$. In the former case, it is readily shown that if $w_{j}=0$, the vector $w$ is a local minimum of the convex function $L_{\\lambda}(w)$ only when"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\\begin{align*}\n",
    "\\left| \\left.\\frac{\\partial L_{0}(w)}{\\partial w_j}\\right|_{w_j = 0} \\right| \\leq \\lambda,\n",
    "\\end{align*}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "being sure to note that $L_{0}(\\cdot)$ is the *unpenalized* loss function, i.e., $L_{\\lambda}(\\cdot)$ with $\\lambda = 0$. In the latter case, we can take partial derivatives with respect to $w_j$ at $w_j \\neq 0$, and we come across the condition"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\\begin{align*}\n",
    "\\left.\\frac{\\partial L_{\\lambda}(w)}{\\partial w_j}\\right|_{w_j \\neq 0} = 0 \\iff \\frac{w_{j}}{n}\\sum_{i=1}^{n}x_{i,j}^{2} + \\lambda \\, \\text{sign}(w_j) = \\frac{1}{n}\\sum_{i=1}^{n}\\left(y_{i}-\\sum_{l \\neq j} w_{l}x_{i,l}\\right)x_{i,j}.\n",
    "\\end{align*}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Writing\n",
    "\n",
    "\\begin{align*}\n",
    "V_{j} = \\frac{1}{n}\\sum_{i=1}^{n}x_{i,j}^{2}\n",
    "\\end{align*}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we have that\n",
    "\n",
    "\\begin{align*}\n",
    "w_{j} = \\frac{1}{n \\, V_{j}}\\sum_{i=1}^{n}\\left(y_{i}-\\sum_{l \\neq j} w_{l}x_{i,l}\\right)x_{i,j} - \\frac{\\lambda \\, \\text{sign}(w_j)}{V_{j}}\n",
    "\\end{align*}\n",
    "\n",
    "is sufficient for $w_{j} \\neq 0$ to solve the one-dimensional optimization."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Taking these two cases (and two conditions) together, it is readily confirmed that regardless of which scenario happens to be true, by setting\n",
    "\n",
    "\\begin{align*}\n",
    "w_{j} = \\frac{1}{V_{j}} S(\\widetilde{g}_{j};\\lambda)\n",
    "\\end{align*}\n",
    "\n",
    "we guarantee that the desired conditions will be satisfied."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here,\n",
    "\n",
    "\\begin{align*}\n",
    "S(u;\\gamma) = \\text{sign}\\,(u)\\max\\,(|u|-\\gamma, 0)\n",
    "\\end{align*}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and\n",
    "\n",
    "\\begin{align*}\n",
    "\\widetilde{g}_{j} = \\frac{1}{n} \\sum_{i=1}^{n}\\left(y_{i}-\\sum_{l \\neq j} w_{l}x_{i,l}\\right)x_{i,j} = -\\left.\\frac{\\partial L_{0}(w)}{\\partial w_j}\\right|_{w_j = 0}.\n",
    "\\end{align*}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As a final computational detail, if the sample data is standardized to have zero mean and unit standard deviation, then as the relationship between $V_{j}$ and the sample variance is\n",
    "\n",
    "\\begin{align*}\n",
    "V_{j} = \\frac{n-1}{n} \\text{var}\\,\\left\\{x_{1,j},\\ldots,x_{n,j}\\right\\},\n",
    "\\end{align*}\n",
    "\n",
    "it follows that with unit standard deviation, we set $V_{j}=(n-1)/n$ for each $j = 1,\\ldots,d$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In light of our algorithm class definitions in previous lessons, a small modification to the established format allows us to easily implement coordinate descent for least squares, as follows. First, implement the soft threshold function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "import numpy as np\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import models\n",
    "import dataclass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def soft_thres(u,mar):\n",
    "    '''\n",
    "    The so-called \"soft threshold\" function, as made\n",
    "    popular by the LASSO model and all related\n",
    "    learning procedures.\n",
    "\n",
    "    Input \"u\" will be an array, and \"mar\" will be the\n",
    "    margin of the soft-threshold, a non-negative real\n",
    "    value.\n",
    "    '''\n",
    "    return np.sign(u) * np.clip(a=(np.abs(u)-mar), a_min=0, a_max=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f9aa1627b38>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Quick visualization.\n",
    "\n",
    "xvals = np.linspace(-1, 1, 500)\n",
    "marval = 0.25\n",
    "yvals = soft_thres(u=xvals, mar=marval)\n",
    "\n",
    "myfig = plt.figure(figsize=(7,7))\n",
    "ax = myfig.add_subplot(1,1,1)\n",
    "plt.axvline(x=0.0, color=\"black\")\n",
    "plt.axvline(x=marval, color=\"green\")\n",
    "plt.axvline(x=(-marval), color=\"green\")\n",
    "plt.axhline(y=0.0, color=\"black\")\n",
    "ax.plot(xvals, yvals, color=\"blue\")\n",
    "plt.title((\"Graph of soft threshold, margin = \"+str(marval)))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This `soft_thres` corresponds to $S$ above, with `soft_thres(u,mar)` returning the value corresponding to $S(u;\\gamma)$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we prepare a slightly modified linear least-squares model, which incorporates an $\\ell_{1}$ regularization term (with weight $\\lambda$ appearing as `lamreg`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Model class with per-coordinate gradient computations.\n",
    "\n",
    "class LinearL1(models.LinReg):\n",
    "    '''\n",
    "    Orthodox linear regression model, using squared\n",
    "    error and regularization via the l1 norm. Good for\n",
    "    realizing sparsity without giving up convexity.\n",
    "    '''\n",
    "    \n",
    "    def __init__(self, data=None):\n",
    "        super(LinearL1,self).__init__(data=data)\n",
    "\n",
    "        \n",
    "    def l_imp(self, w, X, y, lamreg=None):\n",
    "        '''\n",
    "        Input:\n",
    "        w is a (d x 1) matrix of weights.\n",
    "        X is a (k x numfeat) matrix of k observations.\n",
    "        y is a (k x 1) matrix of labels in {-1,1}.\n",
    "        lamreg is a regularization parameter (l2 penalty).\n",
    "\n",
    "        Output:\n",
    "        A vector of length k with losses evaluated at k points.\n",
    "        '''\n",
    "        if lamreg is None:\n",
    "            return (y-self.predict(w=w,X=X))**2/2\n",
    "        else:\n",
    "            penalty = lamreg * np.abs(w).sum()\n",
    "            return (y-self.predict(w=w,X=X))**2/2 + penalty\n",
    "\n",
    "        \n",
    "    def g_j_imp(self, j, w, X, y, lamreg=None):\n",
    "\n",
    "        if lamreg is None:\n",
    "            return (y-self.predict(w=w,X=X))*(-1)*np.take(a=X,\n",
    "                                                          indices=[j],\n",
    "                                                          axis=1)\n",
    "        else:\n",
    "            penalty = lamreg * np.sign(w[j,0])\n",
    "            return (y-self.predict(w=w,X=X))*(-1)*np.take(a=X,\n",
    "                                                          indices=[j],\n",
    "                                                          axis=1) + penalty\n",
    "        \n",
    "    def g_j_tr(self, j, w, data, n_idx=None, lamreg=None):\n",
    "        if n_idx is None:\n",
    "            return self.g_j_imp(j=j, w=w, X=data.X_tr,\n",
    "                                y=data.y_tr,\n",
    "                                lamreg=lamreg)\n",
    "        else:\n",
    "            return self.g_j_imp(j=j, w=w, X=data.X_tr[n_idx,:],\n",
    "                                y=data.y_tr[n_idx,:],\n",
    "                                lamreg=lamreg)\n",
    "    \n",
    "    def g_j_te(self, j, w, data, n_idx=None, lamreg=None):\n",
    "        if n_idx is None:\n",
    "            return self.g_j_imp(j=j, w=w, X=data.X_te,\n",
    "                                y=data.y_te,\n",
    "                                lamreg=lamreg)\n",
    "        else:\n",
    "            return self.g_j_imp(j=j, w=w, X=data.X_te[n_idx,:],\n",
    "                                y=data.y_te[n_idx,:],\n",
    "                                lamreg=lamreg)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All that remains, then, is to implement the coordinate descent routine described above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Algo_CDL1:\n",
    "    '''\n",
    "    Coordinate descent (CD) implementation for minimization\n",
    "    of the \"LASSO\" objective, namely the sum of squared errors\n",
    "    regularized by an l1 penalty.\n",
    "    '''\n",
    "    \n",
    "    def __init__(self, w_init, t_max, lamreg):\n",
    "        self.w = w_init\n",
    "        self.t = None\n",
    "        self.t_max = t_max\n",
    "        self.lamreg = lamreg\n",
    "        \n",
    "    def __iter__(self):\n",
    "        self.t = 0\n",
    "        # Shuffle up the indices before starting.\n",
    "        self.idx = np.random.choice(self.w.size, size=self.w.size, replace=False)\n",
    "        self.idxj = self.idx[0]\n",
    "        return self\n",
    "        \n",
    "    def __next__(self):\n",
    "        if self.t >= self.t_max:\n",
    "            raise StopIteration\n",
    "\n",
    "    def update(self, model, data):\n",
    "        \n",
    "        # Computations related to the update.\n",
    "        n = data.X_tr.shape[0]\n",
    "        modidx = (self.t-1) % self.w.size\n",
    "        self.idxj = self.idx[modidx] # circuits around shuffled coords.\n",
    "        self.w[self.idxj,0] = 0 # current para, but with jth coord set to zero.\n",
    "        g_j = -np.mean(model.g_j_tr(j=self.idxj, w=self.w, data=data, lamreg=0))\n",
    "        g_j = g_j * n / (n-1) # rescale\n",
    "        \n",
    "        # Compute the solution to the one-dimensional optimization,\n",
    "        # using it to update the parameters.\n",
    "        self.w[self.idxj,0] = soft_thres(u=g_j, mar=self.lamreg)\n",
    "        \n",
    "        # Monitor update.\n",
    "        self.t += 1\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The basic structure is very similar to `Algo_GD` and others seen previously. Let's put together a simple table of correspondences to keep things clear:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| `code` | Formal representation |\n",
    "| ------ | :----------------: |\n",
    "| `lamreg` | $\\lambda$ |\n",
    "| `idx` | $\\{1,2,\\ldots,d\\}$, shuffled |\n",
    "| `idxj` | $j \\in \\{1,\\ldots,d\\}$ to update |\n",
    "| `g_j` | $\\widetilde{g}_{j}$ |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that `t_max` may be *larger* than the number of parameters we have. In this case, we simply start back at the beginning of the shuffled index. This is achieved by `modidx`, which gives the time index modulo $d$. That is, the index cycles over"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\\begin{align*}\n",
    "0,1,\\ldots,d-1, 0, 1, \\ldots, d-1, 0, 1, \\ldots\n",
    "\\end{align*}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "until `t` reaches `t_max`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We reiterate that the `model` here is still abstract at this point. All we need is that some appropriate model be passed to the iterator at runtime, which has a method to compute the partial derivatives of a loss for each coordinate.\n",
    "\n",
    "Mirroring the previous lesson, we start by initializing a model object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize model.\n",
    "mod = LinearL1()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we prepare some simulated data, with the following characteristics."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Source is the Elements of Statistical Learning (ESL2) text, in Figure 3.6 on page 59 (with n=300), and again (with n=100) on page 78 in Figure 3.16.\n",
    "\n",
    "- A small simulated data set based on a linear regression model with additive noise and a sparse underlying model vector.\n",
    "\n",
    "- Since most methods we are interested in will center and standardize the data anyways, we shall modify the data at time of generation to have empirical mean of zero and empirical variance of one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Data prep, following ESL-II example.\n",
    "n = 100 # training set size\n",
    "d = 31 # number of inputs\n",
    "d0 = 10 # number of *active* inputs\n",
    "sigma_X = 1.0 # unit variance\n",
    "corr = 0.85 # pairwise correlation coefficient\n",
    "sigma_noise = math.sqrt(6.25) # stdev of additive noise\n",
    "sigma_weights = math.sqrt(0.4) # stdev of randomly generated weights\n",
    "cov_X = np.zeros(d*d).reshape((d,d)) + corr # prepare cov mtx\n",
    "np.fill_diagonal(cov_X, sigma_X)\n",
    "\n",
    "# Set up for a loop over trials.\n",
    "num_trials = 100\n",
    "lamval = 1.5\n",
    "num_loops = 15\n",
    "t_max = num_loops * d\n",
    "\n",
    "# Storage for performance metrics.\n",
    "loss_tr = np.zeros((num_trials,t_max+1), dtype=np.float32)\n",
    "l0norm = np.zeros((num_trials,t_max+1), dtype=np.uint32)\n",
    "truedist = np.zeros((num_trials,t_max+1), dtype=np.float32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "for tri in range(num_trials):\n",
    "    \n",
    "    #print(\"Running trial number\", tri)\n",
    "    \n",
    "    # Initialize learning algorithm.\n",
    "    w_init = 1*np.random.uniform(size=(d,1))\n",
    "    \n",
    "    al = Algo_CDL1(w_init=w_init,\n",
    "                   t_max=t_max,\n",
    "                   lamreg=lamval)\n",
    "    \n",
    "    # Generate the actual data, including \"true\" weights.\n",
    "    wstar = np.zeros(d).reshape((d,1))\n",
    "    idx_on = np.random.choice(d, size=d0, replace=False)\n",
    "    wstar[idx_on,:] = np.random.normal(loc=0.0,\n",
    "                                       scale=sigma_weights,\n",
    "                                       size=d0).reshape((d0,1))\n",
    "    X = np.random.multivariate_normal(mean=np.zeros(d), cov=cov_X, size=n)\n",
    "    noise = np.random.normal(loc=0.0, scale=sigma_noise, size=(n,1))\n",
    "    y = np.dot(X,wstar) + noise\n",
    "\n",
    "    # Standardize the inputs to have unit (empirical) variance.\n",
    "    X = (X-np.mean(X,axis=0)) / np.sqrt(np.var(X,axis=0))\n",
    "    \n",
    "    # Prepare the data object.\n",
    "    data = dataclass.DataSet()\n",
    "    data.init_tr(X=X, y=y)\n",
    "    X = None\n",
    "    y = None\n",
    "    \n",
    "    # Iterate the learning algorithm.\n",
    "    idx = 1\n",
    "    loss_tr[tri,0] = np.mean(mod.l_tr(w=w_init, data=data, lamreg=lamval))\n",
    "    l0norm[tri,0] = np.nonzero(w_init)[0].size\n",
    "    truedist[tri,0] = np.linalg.norm((w_init-wstar))\n",
    "    for onestep in al:\n",
    "        al.update(model=mod, data=data)\n",
    "        # Record performance\n",
    "        loss_tr[tri,idx] = np.mean(mod.l_tr(w=al.w, data=data, lamreg=lamval))\n",
    "        l0norm[tri,idx] = np.nonzero(al.w)[0].size\n",
    "        truedist[tri,idx] = np.linalg.norm((al.w-wstar))\n",
    "        idx += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To start things off, we fix a $\\lambda$ value, and observe the trajectories of performance metrics of interest."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f9aa088f5f8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualize the performance trajectories.\n",
    "\n",
    "tvals = np.arange((t_max+1))\n",
    "\n",
    "# Average over trials.\n",
    "myfig = plt.figure(figsize=(14,7))\n",
    "\n",
    "ax_tr = myfig.add_subplot(1, 3, 1)\n",
    "loss_ave = np.mean(loss_tr, axis=0)\n",
    "loss_sd = np.std(loss_tr, axis=0)\n",
    "plt.fill_between(tvals, loss_ave-loss_sd,\n",
    "                 loss_ave+loss_sd, color=\"pink\")\n",
    "ax_tr.plot(tvals, loss_ave, \"-\", color=\"red\")\n",
    "plt.ylabel(\"Squared error\")\n",
    "plt.xlabel(\"Iteration number\")\n",
    "plt.title(\"Training set performance\")\n",
    "\n",
    "ax_dist = myfig.add_subplot(1, 3, 2)\n",
    "dist_ave = np.mean(truedist, axis=0)\n",
    "dist_sd = np.std(truedist, axis=0)\n",
    "plt.fill_between(tvals, dist_ave-dist_sd,\n",
    "                 dist_ave+dist_sd, color=\"gray\")\n",
    "ax_dist.plot(tvals, dist_ave, \"-\", color=\"black\")\n",
    "plt.ylabel(\"l2 distance\")\n",
    "plt.xlabel(\"Iteration number\")\n",
    "plt.title(\"Distance from true model\")\n",
    "\n",
    "ax_spar = myfig.add_subplot(1, 3, 3)\n",
    "spar_ave = np.mean(l0norm, axis=0)\n",
    "spar_sd = np.std(l0norm, axis=0)\n",
    "plt.fill_between(tvals, spar_ave-dist_sd,\n",
    "                 spar_ave+dist_sd, color=\"turquoise\")\n",
    "ax_spar.plot(tvals, spar_ave, \"-\", color=\"blue\")\n",
    "plt.axhline(y=0, color=\"gray\")\n",
    "plt.ylabel(\"l0 norm\")\n",
    "plt.xlabel(\"Iteration number\")\n",
    "plt.title(\"Sparsity\")\n",
    "\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are clearly a few important variables to focus on here:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `n`: the sample size\n",
    "\n",
    "- `d`: the number of parameters\n",
    "\n",
    "- `d0`: the number of active parameters\n",
    "\n",
    "- `t_max`: the number of iterations\n",
    "\n",
    "- `lamreg`: the weight $\\lambda$ controlling the $\\ell_{1}$-regularization term\n",
    "\n",
    "- `sigma_noise`: intensity additive noise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Exercises:__\n",
    "\n",
    "0. Try modifying the $\\lambda$ parameter for the above experiment, by adjusting the `lamreg` argument passed to `Algo_CDL1`. Start with a small value like $\\lambda=0.01$, and work up to large values like $\\lambda=5$. How does the final output change?\n",
    "\n",
    "0. What sort of relationship exists between the $\\lambda$ parameter value and the $\\ell_{1}$ constraint placed on the estimate $w$?\n",
    "\n",
    "___"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is difficult to know what sort of value $\\lambda$ should take in advance, and it is typical to try running the algorithm on the same data, over a \"grid\" of candidate $\\lambda$. In this setting, it is typical to make use of \"warm starts\", where estimates based on previous $\\lambda$ choices are re-used as initial values for subsequent $\\lambda$ choices. The terminology is natural: while for the first run the initial value will likely be rather arbitrary, after running `t_max` iterations, the current estimate should be a lot closer to the optimal solution, under the implicitly imposed $\\ell_{1}$ norm constraints.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Implementing this in practice is simple. In the following example, we prepare a grid of candidates (`todo_lambda`), and after each run update the initial weights `w_init` to the most recent estimate `w_est`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# Data prep, following ESL-II example.\n",
    "n = 100 # training set size\n",
    "d = 31 # number of inputs\n",
    "d0 = 10 # number of *active* inputs\n",
    "sigma_X = 1.0 # unit variance\n",
    "corr = 0.85 # pairwise correlation coefficient\n",
    "sigma_noise = math.sqrt(6.25) # stdev of additive noise\n",
    "sigma_weights = math.sqrt(0.4) # stdev of randomly generated weights\n",
    "cov_X = np.zeros(d*d).reshape((d,d)) + corr # prepare cov mtx\n",
    "np.fill_diagonal(cov_X, sigma_X)\n",
    "\n",
    "# Set up for a loop over trials and lambda values.\n",
    "num_trials = 100\n",
    "todo_lambda = np.logspace(start=math.log10(1/100), stop=math.log10(2.5), num=150)\n",
    "num_loops = 15\n",
    "t_max = num_loops * d\n",
    "\n",
    "# Storage for performance metrics.\n",
    "loss_tr = np.zeros((num_trials,todo_lambda.size), dtype=np.float32)\n",
    "l0norm = np.zeros((num_trials,todo_lambda.size), dtype=np.uint32)\n",
    "truedist = np.zeros((num_trials,todo_lambda.size), dtype=np.float32)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "for tri in range(num_trials):\n",
    "    \n",
    "    # Initialize learning algorithm.\n",
    "    w_init = 1*np.random.uniform(size=(d,1))\n",
    "    \n",
    "    for l in range(todo_lambda.size):\n",
    "        \n",
    "        lamval = todo_lambda[l]\n",
    "        \n",
    "        # Use warm starts when available.\n",
    "        if l > 0:\n",
    "            w_init = al.w\n",
    "\n",
    "        al = Algo_CDL1(w_init=w_init,\n",
    "                       t_max=t_max,\n",
    "                       lamreg=lamval)\n",
    "    \n",
    "        # Generate the actual data, including \"true\" weights.\n",
    "        wstar = np.zeros(d).reshape((d,1))\n",
    "        idx_on = np.random.choice(d, size=d0, replace=False)\n",
    "        wstar[idx_on,:] = np.random.normal(loc=0.0,\n",
    "                                           scale=sigma_weights,\n",
    "                                           size=d0).reshape((d0,1))\n",
    "        X = np.random.multivariate_normal(mean=np.zeros(d), cov=cov_X, size=n)\n",
    "        noise = np.random.normal(loc=0.0, scale=sigma_noise, size=(n,1))\n",
    "        y = np.dot(X,wstar) + noise\n",
    "\n",
    "        # Standardize the inputs to have unit (empirical) variance.\n",
    "        X = (X-np.mean(X,axis=0)) / np.sqrt(np.var(X,axis=0))\n",
    "\n",
    "        # Prepare the data object.\n",
    "        data = dataclass.DataSet()\n",
    "        data.init_tr(X=X, y=y)\n",
    "        X = None\n",
    "        y = None\n",
    "    \n",
    "        # Iterate the learning algorithm.\n",
    "        for onestep in al:\n",
    "            al.update(model=mod, data=data)\n",
    "        \n",
    "        # Record performance based on final output.\n",
    "        loss_tr[tri,l] = np.mean(mod.l_tr(w=al.w, data=data, lamreg=lamval))\n",
    "        l0norm[tri,l] = np.nonzero(al.w)[0].size\n",
    "        truedist[tri,l] = np.linalg.norm((al.w-wstar))\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f9aa0328780>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualize the performance over lambda grid.\n",
    "\n",
    "# Average over trials.\n",
    "myfig = plt.figure(figsize=(14,7))\n",
    "\n",
    "ax_tr = myfig.add_subplot(1, 3, 1)\n",
    "ax_tr.set_xscale('log')\n",
    "loss_ave = np.mean(loss_tr, axis=0)\n",
    "loss_sd = np.std(loss_tr, axis=0)\n",
    "logerr = loss_sd / (math.log(10)*loss_ave) # for error bars when using log scale\n",
    "plt.fill_between(todo_lambda, np.log10(loss_ave)-logerr,\n",
    "                 np.log10(loss_ave)+logerr, color=\"pink\")\n",
    "ax_tr.plot(todo_lambda, np.log10(loss_ave), \"-\", color=\"red\")\n",
    "plt.xlabel(\"Lambda value\")\n",
    "plt.title(\"Squared error on training set (log10)\")\n",
    "\n",
    "ax_dist = myfig.add_subplot(1, 3, 2)\n",
    "ax_dist.set_xscale('log')\n",
    "dist_ave = np.mean(truedist, axis=0)\n",
    "dist_sd = np.std(truedist, axis=0)\n",
    "logerr = loss_sd / (math.log(10)*loss_ave) # for error bars when using log scale\n",
    "plt.fill_between(todo_lambda, np.log10(dist_ave)-logerr,\n",
    "                 np.log10(dist_ave)+logerr, color=\"gray\")\n",
    "ax_dist.plot(todo_lambda, np.log10(dist_ave), \"-\", color=\"black\")\n",
    "plt.xlabel(\"Lambda value\")\n",
    "plt.title(\"l2 distance from true model (log10)\")\n",
    "\n",
    "ax_spar = myfig.add_subplot(1, 3, 3)\n",
    "ax_spar.set_xscale('log')\n",
    "spar_ave = np.mean(l0norm, axis=0)\n",
    "spar_sd = np.std(l0norm, axis=0)\n",
    "plt.fill_between(todo_lambda, spar_ave-dist_sd,\n",
    "                 spar_ave+dist_sd, color=\"turquoise\")\n",
    "ax_spar.plot(todo_lambda, spar_ave, \"-\", color=\"blue\")\n",
    "plt.axhline(y=0, color=\"gray\")\n",
    "plt.xlabel(\"Lambda value\")\n",
    "plt.title(\"Sparsity via l0-norm\")\n",
    "\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note the following points here:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Taking a larger $\\lambda$ value indeed leads to sparser solutions; a larger value implicitly specifies tigher $\\ell_{1}$ (and $\\ell_{0}$) norm constraints.\n",
    "\n",
    "- There is a clear tradeoff between __bias__ and __variance__ of the learning algorithm here. Too tight a constraint means that the correct solution may not be in the feasible region, a bias. Too loose a constraint leaves too many parameters to specify given relatively few observations, large variance over the random draw of the sample.\n",
    "\n",
    "- Note that the best distance is achieved, on average, at the \"correct\" sparsity level (i.e., the level matching the underlying $w^{\\ast}$, which is precisely the behaviour that we should expect."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Exercises:__\n",
    "\n",
    "0. In the above example, we start with *small* $\\lambda$ values and work up to larger values, utilizing warm starts along the way. Try reversing the order (starting large). Does the best lambda value tend to change depending on the direction?\n",
    "\n",
    "0. Try running the algorithm \"fresh\" for each new $\\lambda$ candidate, without using warm starts (i.e., use the same pre-fixed `w_init` every time). Does performance degrade? Does the optimal $\\lambda$ value change?\n",
    "\n",
    "0. One common strategy for constructing the grid is to set the sequence $(\\lambda_{0},\\ldots,\\lambda_{k})$ such that the values are evenly spaced on a log scale, i.e., $\\log\\lambda_{i} - \\log\\lambda_{i-1} = c > 0$, a constant for all $i$. Extend the above code such that the minimum and maximum parameter values take the following standard values (Bühlmann, and Van De Geer, 2011): writing $x_{(j)}$ for the $j$th column of the design matrix, $x_{(j)} = (x_{1,j},\\ldots,x_{n,j})$, and $y=(y_{1},\\ldots,y_{n})$,\n",
    "<br><br>\n",
    "\\begin{align*}\n",
    "\\lambda_{0} = 1/n, \\quad \\lambda_{k} = \\max \\left\\{|\\langle y, x_{(j)}\\rangle|/n:j=1,\\ldots,d \\right\\}.\n",
    "\\end{align*}\n",
    "<br>\n",
    "0. How does performance change when more/less loops are carried out?\n",
    "\n",
    "0. As before, try with and without warm starts, evaluate the change in average performance, variance over trials, and the average sparsity of the best estimate.\n",
    "\n",
    "0. Record the best-performing $\\lambda$ values each time, and examine the average and variance of these values over trials. Does there tend to be much sample-sensitive variation in the ideal $\\lambda$ setting?\n",
    "\n",
    "0. Add `w_old`, `thres` and `diff` attributes to `Algo_CDL1`. Every time we carry out `w.size` (that is, $d$) iterations, set `diff` to the norm of the difference between `w` and `w_old`, and then update `w_old` to the current `w`. If `diff` is less than `thres` (a parameter we must set), then terminate.\n",
    "\n",
    "0. Following the above `thres`-based termination conditions, how many iterations does it typically take to converge? Does this depend on the value of $\\lambda$?\n",
    "\n",
    "0. If we perform many loops, for most of the time many $w_{j}$ values will likely be zero. A different strategy for looping over the indices is to *ignore* all coordinates once they have taken on a zero value. Implement this strategy (re-define `idx` on the fly). How does performance compare with the original circulating approach? What about computation time?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## References:\n",
    "\n",
    "- Bühlmann, Peter, and Sara Van De Geer. Statistics for high-dimensional data: methods, theory and applications. Springer Science & Business Media, 2011.\n",
    "- Haxby, James V., et al. \"Distributed and overlapping representations of faces and objects in ventral temporal cortex.\" Science 293.5539 (2001): 2425-2430."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___"
   ]
  }
 ],
 "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}