{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# スパース回帰のための学習アルゴリズム\n",
    "\n",
    "多くの（機械）学習課題では、多数の特徴量の候補はあっても、実際に予測や識別等に必要なのはごく少数である。しかし、事前にはどの候補が良いかは当然わからない。そのため、学習時には、データに応じて必要最低限の特徴量だけを選択し、残りを切り捨てて、スパースなモデルを定める必要がある（日本語では「疎」、密の対義語）。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__目次：__\n",
    "\n",
    "- <a href=\"#background\">スパース推定の背景</a>\n",
    "- <a href=\"#coorddesc\">2乗誤差を使っての座標降下法</a>\n",
    "- <a href=\"#robust\">頑健なスパース推定</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "前の回では学習アルゴリズムを実装するための原型らしきものを学んだので、ここではそれを踏まえて、学習結果が一定のスパース性を有するための工夫を学ぶ。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"background\"></a>\n",
    "## スパース推定の背景\n",
    "\n",
    "Tibshirani氏の1996年の名著を引用すると、多数のパラメータがあるとき（特に標本数よりも多い場合）、スパースな推定結果を求めるべきだ、という理由が2つある。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "一つは予測精度：\n",
    "\n",
    "> _\"[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": [
    "もう一つは解釈のしやすさ：\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": [
    "実際、人の脳でも似たような原理が見られる。感覚器を通じて途轍もなく複雑な刺激を常に受けていることは事実だが、その刺激全体を脳全体で処理しているというよりは、刺激の特性によって「分担」している模様である。脳の細部まで調べると、特定の領域が活発に反応するのは、かなり特異的な刺激のみである。普段受けている刺激を多数の特徴量の組み合わせと見なすと、脳がどう反応するか予測するために必要なのはまさしくスパースなモデルである。（画像はHaxby et al., 2001より）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/fmri_response.jpg\" alt=\"Image source: Haxby et al. (2001)\" width=\"480\"/>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "統計的な推論を行なう機械となると、入力が多数あるのだが、設計者が一定の「選択性」を持たせないと結果がスパースにはならない。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/sparse_matrix.png\" alt=\"Image: Sparse matrix image\" width=\"240\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "モデルによるところもあるのだが、基本的には、一つの特徴量の影響が実数値パラメータによって決まると思ってよく、その値をゼロにすることでその影響が無くなるケースがほとんど。よって、多くの場合は、制御するパラメータ$w \\in \\mathbb{R}^{d}$の要素の大半が零でありながら、それがスパースであるといえる。あとはスパースにさせた結果が高い汎化能力を持つかどうかだ。スパース性をダイレクトに測る場合は、$\\ell_{0}$ノルムを使う："
   ]
  },
  {
   "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": [
    "よって、リスク最小化という文脈でいうと、リスクを$R(w) = \\mathbf{E}_{Z} l(w;z)$としたとき、真の目的関数は下記の通り：\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": [
    "期待値は近似できるのだが、この制約を満たしながら最小化することは困難である。幸いにも、$\\ell_{0}$ノルムを小さくすることは、$\\ell_{1}$ノルムを小さくすることで実現できることは、多くの文献からわかってきている。この知見を踏まえて制約を変更すると、\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": [
    "というもう少し攻めやすい問題設定になる。この制約付き最適化は、次の目的関数を用いることで近似できる。\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": [
    "この式を出発点として、有用な学習則をここから丁寧に見ていくことにする。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"coorddesc\"></a>\n",
    "## 2乗誤差を使っての座標降下法"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "具体例から始めると説明しやすいので、典型例として、線形モデルの下で2乗誤差をロス関数とする状況を考える：\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": [
    "このとき、先ほどの目的関数が下記のような形を取る。\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": [
    "難しいのは、絶対値を取っているので微分できない場合がある（パラメータの要素が一つでもゼロになる場合）。すべてのパラメータを一気に更新することは困難なので、愚直で速い方策として、「座標軸ごとに更新をすれば良い」という座標降下法（coordinate descent）がある。一次元ずつだと、更新が簡単になるというメリットがある。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "まず、仮に$w$が局所解であるとする。このパラメータベクトルの$j$個目の要素は当然、零か非零のどれかである。事実として、$w_j = 0$であるならば、"
   ]
  },
  {
   "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": [
    "が成り立つことはわかっている。ここで示している$L_{0}(\\cdot)$とは、$\\ell_{1}$の項がない、制約無しの目的関数である。$w_j = 0$の場合に、もし逆にこの不等式が成り立たないのであれば、$w$が局所解でなくなる。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$w_j \\neq 0$ならばどうだろうか。このときは$w_j$について偏微分は求められる："
   ]
  },
  {
   "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": [
    "式を整理するために、\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": [
    "と置くと、偏微分がゼロになるための条件は、\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",
    "となる。左辺にも右辺にも$w_{j}$はあるが、明示的に解を求めることはできる:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\\begin{align}\n",
    "w_{j} = \\frac{1}{V_{j}} S(\\widetilde{g}_{j};\\lambda)\n",
    "\\end{align}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ここで使っている関数は"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\\begin{align}\n",
    "S(u;\\gamma) = \\text{sign}\\,(u)\\max\\,(|u|-\\gamma, 0)\n",
    "\\end{align}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "と定義し、またその入力は\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}\n",
    "\n",
    "と表記している。少し噛みしめてもらうと、この更新式では$w_{j}$がゼロになるのは、最初の条件として示した不等式が成り立つ場合のみである。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "最後に計算する上で重要な点であるが、もし入力データが平均ゼロ、分散1.0と標準化されているのであれば、先ほどの$V_{j}$はすぐに計算できる。まず、$V_{j}$とサンプル分散の関係は\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",
    "となっているので、標準偏差が1.0であれば、各$j = 1,\\ldots,d$に対して、$V_{j}=(n-1)/n$とする。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "前の回のアルゴリズムクラスを踏まえて、少し改造するだけで上記のアルゴリズムは実装できる。まずはsoft threshold関数を用意する。"
   ]
  },
  {
   "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 0x7fc446560b00>"
      ]
     },
     "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": [
    "この`soft_thres`は先述の$S$に対応する。したがって`soft_thres(u,mar)`は$S$の返す値$S(u;\\gamma)$に対応する。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "続いては、$\\ell_{1}$正則化項も兼ね備えた線形回帰モデルを用意する（正則化の度合いをつかさどる計数$\\lambda$は`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": [
    "これで下ごしらえはできたので、あとは先述の座標降下法をアルゴリズムオブジェクトとして実装するだけである。"
   ]
  },
  {
   "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": [
    "基本的な構造は、これまでに扱ってきた`Algo_GD`とその仲間と酷似している。新しい部分を明確に表わすために、対応づけを一覧化しよう。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| `code` | Formal representation |\n",
    "| ------ | :----------------: |\n",
    "| `lam_l1` | $\\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": [
    "当然ながら、`t_max`は自由に設定できるので、その値がパラメータの数よりもはるかに大きいことはよくある。そのとき、ただ単にインデックスの先頭に戻れば良いのである。これができているのは、`modidx`で剰余演算をしているからである。その振る舞いを列挙しておくと、"
   ]
  },
  {
   "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": [
    "と`t`が`t_max`になるまで繰り返す。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ほかのアルゴリズムを実装したときにも述べたが、`model`は抽象化したままである。その詳細について考える必要は今なく、ただ実行時に偏微分を計算してくれる何らかのモデルが用意されていれば良い。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ここからはその挙動を擬似データを通じて、調べていく。例に倣って、データのほうをまず初期化する。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize model.\n",
    "mod = LinearL1()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ここで作成する人工データについて："
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- この例はElements of Statistical Learning (ESL2、和訳：『統計的学習の基礎』)の英語版から引用している。具体的には、59ページのFigure 3.6（n=300）と78ページのFigure 3.16（n=100）に登場する。\n",
    "\n",
    "- 至って標準的な線形モデルであるが、モデルを定めるパラメータベクトルがスパースであるという特徴を持つ。\n",
    "\n",
    "- 入力データ$x$の経験平均と分散がそれぞれ0.0と1.0になるようにしている。"
   ]
  },
  {
   "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": [
    "はじめに、$\\lambda$を固定しておいて、関心のある指標の軌跡を見てみる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fc43e000080>"
      ]
     },
     "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": [
    "ここで注目すべきは、下記のパラメータである。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `n`: 標本数\n",
    "\n",
    "- `d`: 学習の対象となるパラメータの数\n",
    "\n",
    "- `d0`: 学習しうるパラメータのうち、非零のパラメータの数\n",
    "\n",
    "- `t_max`: 最大の反復回数\n",
    "\n",
    "- `lam_l1`: $\\ell_{1}$正則化項をつかさどる計数$\\lambda$\n",
    "\n",
    "- `sigma_noise`: 加法ノイズの度合い"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__練習問題:__\n",
    "\n",
    "0. 上記の数値実験では、$\\lambda$の値を色々と変えてみること（`Algo_CDL1`に渡す`lamreg`である）。小さい値（例：$\\lambda=0.01$）から大きい値（例：$\\lambda=5$）まで調べてみると、学習の結果がどのように変わっていくか。\n",
    "\n",
    "0. $\\lambda$の値と、学習される$w$への$\\ell_{1}$制約とはどういう関係にあるか。\n",
    "\n",
    "___"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "データを持っている時点でも、また$\\ell_{1}$のちょうど良い制約がわかっていても、$\\lambda$をどう設定すれば良いかは自明ではない。そのため、普通のやり方としては、$\\lambda$の候補をたくさん用意し、全部に対して上記のアルゴリズムを実行し、一番良いほうを選ぶ、という流れで学習を進めていく。一つの利点としては、多数の$\\lambda$候補を試すと、学習結果を再利用することができるのである。最初はおそらく恣意的に決める初期値であるが、そのあとは段々ともっともらしい解を初期値として使える、warm startの効果が働く。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "これを実装することは単純である。`todo_lambda`で$\\lambda$の候補を用意し、アルゴリズムを一通り実行したあと、`w_init`に学習結果`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 0x7fc43d2e4cc0>"
      ]
     },
     "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": [
    "注目すべき点："
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- より大きな$\\lambda$にすると、よりスパースな推定結果が得られることは明らか。要するに$\\ell_{1}$（および$\\ell_{0}$）の制約が厳しくなってくる。\n",
    "\n",
    "- 明確な__バイアス__と__バリアンス__（分散）のトレードオフが先の例で見られる。制約設定が厳しすぎると、最適解がそれを満たさない可能性があって、最初から的外れになってしまう（バイアスを食らう）。一方、制約が緩すぎるのもだめで、標本が限られているなかで決めないといけないパラメータ数が多くなると解が定まらず、サンプルごとの分散が甚だ大きくなってしまう。\n",
    "\n",
    "- 実験的な知見として、$w^{\\ast}$と同程度のスパース性を持つベクトルのほうが良いパフォーマンスを記録する傾向が見られる。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__練習問題:__\n",
    "\n",
    "0. 上の例では、小さい$\\lambda$から始まり、大きい$\\lambda$で終わるようにしている。この大小を逆にしてみてください（大きい値から始まるように）。最高の成績水準が変わるか。それを実現する$\\lambda$の値が、大小・小大の順番によって変わるか。\n",
    "\n",
    "0. 先ほどのwarm startsをやめて、すべての$\\lambda$に対してまったく同じ初期値（固定された`w_init`）を使って実行してみること。最高の成績水準が変わるか。また、それを実現する$\\lambda$の値が変わるか。\n",
    "\n",
    "0. 候補としての$(\\lambda_{0},\\ldots,\\lambda_{k})$を決める著名な方法として、対数スケールで一定の間隔にする。つまり、$\\log\\lambda_{i} - \\log\\lambda_{i-1} = c > 0$で、この定数$c$はすべての$i$に対して共通している。あとは最大値と最小値を決めることだが、標準的な値は次の通りである（Bühlmann, and Van De Geer, 2011）。データの表記方法として、$y=(y_{1},\\ldots,y_{n})$で応答を表わし、$x_{(j)}$で入力行列の$j$番目の列を表わす（$x_{(j)} = (x_{1,j},\\ldots,x_{n,j})$）。この表記を使って、最大値と最小値の設定は\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",
    "となる。自分で実装し、有効性を検証すること。\n",
    "\n",
    "0. 全パラメータを何周するかによって、学習結果がどの程度変わるか。極端に少ない（各要素を一度だけ更新する）場合と、何度も更新する場合、それぞれを試して比較すること。\n",
    "\n",
    "0. 前の練習問題と同様に、warm startsをやめて、$\\lambda$候補をすべて同一の初期値を使って検証すること。試行を重ねて、パフォーマンスの平均・分散、スパース性の平均・分散を調べて、warm starts有りと無しの場合を比較してみること。\n",
    "\n",
    "0. 試行ごとに、もっとも良い成績を残した$\\lambda$の値を記録するようにコードを改造すること。これらの値の平均と分散はどうか。サンプルのばらつきに対して、もっとも良い$\\lambda$の値が敏感に思われるか。\n",
    "\n",
    "0. 次の属性を`Algo_CDL1`に追加してください：`w_old`、`thres`、`diff`の3つである。`w.size`（つまり$d$）回の更新をするごとに、`diff`に`w`と`w_old`の距離を代入してから、`w_old`に`w`を代入する。新たな終了条件をここで追加：`diff`が閾値`thres`を下回ると、直ちに終了する。\n",
    "\n",
    "0. 先の問題の続きだが、`thres`を使った終了条件では、だいたい何周すれば収束するか。また、この収束速度が$\\lambda$の値にどう依存するか。\n",
    "\n",
    "0. 何周もするなら、多くの$w_{j}$がずっとゼロである。それにもかかわらず、毎回同じ更新式のための計算はするので、無駄な計算として省ける。すべてのパラメータを何度も見るのではなく、パラメータが一旦ゼロになると二度と更新しない（`idx`のなかから削除する）、という方策も有名である。これを実装し、成績を調べること。通常のやり方と比較し、性能がどう変わるか。計算時間はどうか。"
   ]
  },
  {
   "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."
   ]
  }
 ],
 "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
}