{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 機械学習のプロトタイプづくり\n",
    "\n",
    "機械学習の手法を実装するにあたって、アプローチはいくつもあり、その目的に依存する部分が多く、ただ一つの正確があるわけではない。我々の目的としては、機械学習の手法を効率よく「発想」の段階から「動くソフトウェア」の段階まで持っていくことができれば良い。なぜなら、色々な手法を試したり、調整したりする必要があるからである。実装の細かいところに神経を使わないといけないのであれば、バグは間違いなく続出するであろうし、本来の目的である「機械学習の理解」がおろそかにされてしまう可能性が高い。\n",
    "\n",
    "そのため、簡明でわかりやすく、また多様な手法でも使い勝手の良い実装方法を心がける。ここで紹介するアプローチは、__データ__、__モデル__、そして__アルゴリズム__という3つのオブジェクトを中心としている。その基本的な性質は下記の通りである。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- __データ（オブジェクト）：__ 訓練、検証などに使うすべてのデータを格納するクラスオブジェクトである。\n",
    "\n",
    "- __モデル（オブジェクト）：__ アルゴリズムの状態とデータに依存する関数をメソッドとして持ち、訓練中および訓練後の評価に使うクラスオブジェクトである。\n",
    "\n",
    "- __アルゴリズム（オブジェクト）：__ 制御対象となるパラメータなどの「状態」を持つイテレータである。データとモデルに依存する関数をメソッドとして持ち、繰り返して更新するごとに呼び出す。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__目次__\n",
    "\n",
    "- <a href=\"#getstarted\">データとモデルを定義してみる</a>\n",
    "\n",
    "- <a href=\"#trivial\">自明なアルゴリズムを作ってみる</a>\n",
    "\n",
    "- <a href=\"#link3\">三者を結びつける</a>\n",
    "\n",
    "- <a href=\"#learning\">最適化と学習</a>\n",
    "\n",
    "___"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"getstarted\"></a>\n",
    "## データとモデルを定義してみる\n",
    "\n",
    "簡単な具体例を拠り所として、基本的なオブジェクトの定義を説明していく。古典的な線形モデル、つまり\n",
    "\n",
    "\\begin{align*}\n",
    "y = \\langle w^{\\ast}, x \\rangle + \\varepsilon, \\quad \\mathbf{E}\\varepsilon = 0, \\mathbf{E}\\varepsilon^2 < \\infty, x \\in \\mathbb{R}^d\n",
    "\\end{align*}\n",
    "\n",
    "を出発点とする。データ$(x_1, y_1),\\ldots,(x_n, y_n)$を所与として、未知の$(x,y)$に対して$\\langle \\widehat{w}, x \\rangle \\approx y$という近似がなるべく正確であるように、$\\widehat{w}$を決めたい。\n",
    "\n",
    "段取りとして、まず必要なのは、これら$n$個のデータ点を格納すること。`DataSet`をベースクラスとして以下のように定義する。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DataSet:\n",
    "    '''\n",
    "    Base class for data objects.\n",
    "    '''\n",
    "    \n",
    "    def __init__(self, paras=None):\n",
    "        self.X_tr = None\n",
    "        self.X_te = None\n",
    "        self.y_tr = None\n",
    "        self.y_te = None\n",
    "        self.paras = paras\n",
    "    \n",
    "    def init_tr(self, X, y):\n",
    "        self.X_tr = X\n",
    "        self.y_tr = y\n",
    "        self.n_tr = X.shape[0]\n",
    "        \n",
    "    def init_te(self, X, y):\n",
    "        self.X_te = X\n",
    "        self.y_te = y\n",
    "        self.n_te = X.shape[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "今の学習課題は線形モデルを前提とした回帰である。我々の使うモデルオブジェクトとして、`Model`と呼ぶベースクラスを作りたいところだが、この「線形モデル」と「回帰」のどこがモデルオブジェクトの範囲内なのか。以下のように決めておこう。\n",
    "\n",
    "- `Model`のサブクラスは、訓練および検証等の評価に使う各種の損失（ロス）関数（必要に応じてその勾配等の情報）を実装したメソッドを持つとする。\n",
    "\n",
    "このように決めておくとあとは簡単である。モデルオブジェクトのベースクラスとなる`Model`を以下のように定義する。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Model:\n",
    "    '''\n",
    "    Base class for model objects.\n",
    "    '''\n",
    "\n",
    "    def __init__(self, name=None):\n",
    "        self.name = name\n",
    "\n",
    "    def l_imp(self, w=None, X=None, y=None, lamreg=None):\n",
    "        raise NotImplementedError\n",
    "    \n",
    "    def l_tr(self, w, data, n_idx=None, lamreg=None):\n",
    "        if n_idx is None:\n",
    "            return self.l_imp(w=w, X=data.X_tr,\n",
    "                              y=data.y_tr,\n",
    "                              lamreg=lamreg)\n",
    "        else:\n",
    "            return self.l_imp(w=w, X=data.X_tr[n_idx,:],\n",
    "                              y=data.y_tr[n_idx,:],\n",
    "                              lamreg=lamreg)\n",
    "    \n",
    "    def l_te(self, w, data, n_idx=None, lamreg=None):\n",
    "        if n_idx is None:\n",
    "            return self.l_imp(w=w, X=data.X_te,\n",
    "                              y=data.y_te,\n",
    "                              lamreg=lamreg)\n",
    "        else:\n",
    "            return self.l_imp(w=w, X=data.X_te[n_idx,:],\n",
    "                              y=data.y_te[n_idx,:],\n",
    "                              lamreg=lamreg)\n",
    "\n",
    "    def g_imp(self, w=None, X=None, y=None, lamreg=None):\n",
    "        raise NotImplementedError\n",
    "    \n",
    "    def g_tr(self, w, data, n_idx=None, lamreg=None):\n",
    "        if n_idx is None:\n",
    "            return self.g_imp(w=w, X=data.X_tr,\n",
    "                              y=data.y_tr,\n",
    "                              lamreg=lamreg)\n",
    "        else:\n",
    "            return self.g_imp(w=w, X=data.X_tr[n_idx,:],\n",
    "                              y=data.y_tr[n_idx,:],\n",
    "                              lamreg=lamreg)\n",
    "    \n",
    "    def g_te(self, w, data, n_idx=None, lamreg=None):\n",
    "        if n_idx is None:\n",
    "            return self.g_imp(w=w, X=data.X_te,\n",
    "                              y=data.y_te,\n",
    "                              lamreg=lamreg)\n",
    "        else:\n",
    "            return self.g_imp(w=w, X=data.X_te[n_idx,:],\n",
    "                              y=data.y_te[n_idx,:],\n",
    "                              lamreg=lamreg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ベースクラスなので`Model`では何も実装していないが、ロス関数にかかわるメソッドは`DataSet`を前提とした`data`と任意のパラメータ`w`を引数とする。\n",
    "\n",
    "回帰モデルを実装するためには、言うまでもなくロスや勾配の詳細を定めて、それらを実装する必要がある。どのロスを使うかは我々の自由である。典型例として、「最小二乗法」として古くから知られている回帰モデルを使うことにする。この場合、`w`が線形写像を定めるベクトル$w \\in \\mathbb{R}^d$に相当する。「最小」と呼ぶのは、最終的にこの誤差が小さくなるように最適化していくことを表わす。式で示すと以下のとおりである。\n",
    "\n",
    "\\begin{align*}\n",
    "\\min_{w \\in \\mathbb{R}^d} \\frac{1}{n} \\sum_{i=1}^{n} (\\langle w, x_i \\rangle - y_i)^2 \\to \\hat{w}.\n",
    "\\end{align*}\n",
    "\n",
    "この最適化を行うにあたって、ロスの取る値そのもの、あるいはそのロス関数の勾配ベクトルを$w$について求める。具体的には、下記を実装する必要がある。\n",
    "\n",
    "- `l_imp`: 任意のペア$(x,y)$に対して、$(y - \\langle w, x \\rangle)^2 / 2$を計算する。\n",
    "\n",
    "- `g_imp`: 任意のペア$(x,y)$に対して、$(y - \\langle w, x \\rangle)(-1)x \\in \\mathbb{R}^d$を計算する。\n",
    "\n",
    "これほど単純なモデルはほかにないので、実装することも大して苦労しない。`LinReg`をベースクラスとして、`LinearL2`をそのサブクラスとして定義する。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class LinReg(Model):\n",
    "    '''\n",
    "    General-purpose linear regression model.\n",
    "    No losses are implemented, just a predict()\n",
    "    method.\n",
    "    '''\n",
    "    \n",
    "    def __init__(self, data=None, name=None):\n",
    "        super(LinReg, self).__init__(name=name)\n",
    "        pass\n",
    "\n",
    "    def predict(self, w, X):\n",
    "        '''\n",
    "        Predict real-valued response.\n",
    "        w is a (d x 1) array of weights.\n",
    "        X is a (k x d) matrix of k observations.\n",
    "        Returns array of shape (k x 1) of predicted values.\n",
    "        '''\n",
    "        return X.dot(w)\n",
    "\n",
    "\n",
    "class LinearL2(LinReg):\n",
    "    '''\n",
    "    An orthodox linear regression model\n",
    "    using the l2 error; typically this\n",
    "    will be used for the classical least\n",
    "    squares regression.\n",
    "    '''\n",
    "    \n",
    "    def __init__(self, data=None):\n",
    "        super(LinearL2, self).__init__(data=data)\n",
    "\n",
    "        \n",
    "    def l_imp(self, w, X, y, lamreg=None):\n",
    "        '''\n",
    "        Implementation of l2-loss under linear model\n",
    "        for regression.\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.linalg.norm(w)**2\n",
    "            return (y-self.predict(w=w,X=X))**2/2 + penalty\n",
    "    \n",
    "    \n",
    "    def g_imp(self, w, X, y, lamreg=None):\n",
    "        '''\n",
    "        Implementation of the gradient of the l2-loss\n",
    "        under a linear regression model.\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",
    "\n",
    "        Output:\n",
    "        A (k x numfeat) matrix of gradients evaluated\n",
    "        at k points.\n",
    "        '''\n",
    "        if lamreg is None:\n",
    "            return (y-self.predict(w=w,X=X))*(-1)*X\n",
    "        else:\n",
    "            penalty = lamreg*2*w.T\n",
    "            return (y-self.predict(w=w,X=X))*(-1)*X + penalty"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上記のオブジェクトがあれば、データと評価の仕組みなどができているので、学習アルゴリズムに渡す情報の準備はできている。あとはアルゴリズムそのもののクラスを用意するだけだが、その前に簡単な使用例を示しておく。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "===============\n",
      "l_tr: 63.67480525704821 l_te: 72.52161001938249\n",
      "g_tr:\n",
      " [-1.1240842  -6.437987   -1.79680855 -7.2479921  -4.13374471]\n",
      "g_te:\n",
      " [ 1.23114245 -6.7552612  -1.8668131  -8.89835267 -4.93590447]\n",
      "===============\n",
      "l_tr: 35.945556539267216 l_te: 40.85252548386378\n",
      "g_tr:\n",
      " [-0.84580072 -4.82831557 -1.36736611 -5.42541324 -3.08957585]\n",
      "g_te:\n",
      " [ 0.94982208 -5.06642986 -1.37297361 -6.65188944 -3.6999843 ]\n",
      "===============\n",
      "l_tr: 16.167935313729377 l_te: 18.30555145320523\n",
      "g_tr:\n",
      " [-0.56751724 -3.21864415 -0.93792366 -3.60283438 -2.045407  ]\n",
      "g_te:\n",
      " [ 0.66850172 -3.37759852 -0.87913411 -4.40542621 -2.46406413]\n",
      "===============\n",
      "l_tr: 4.3419415804346695 l_te: 4.880687927406857\n",
      "g_tr:\n",
      " [-0.28923376 -1.60897273 -0.50848121 -1.78025552 -1.00123814]\n",
      "g_te:\n",
      " [ 0.38718136 -1.68876719 -0.38529462 -2.15896298 -1.22814396]\n",
      "===============\n",
      "l_tr: 0.46757533938310303 l_te: 0.5779349064686516\n",
      "g_tr:\n",
      " [-0.01095028  0.00069869 -0.07903877  0.04232334  0.04293072]\n",
      "g_te:\n",
      " [1.05860995e-01 6.41498784e-05 1.08544880e-01 8.75002561e-02\n",
      " 7.77620457e-03]\n",
      "===============\n"
     ]
    }
   ],
   "source": [
    "# Prepare simulated data.\n",
    "d = 5\n",
    "n_tr = 100\n",
    "n_te = 100\n",
    "w_star = np.arange(d).reshape((d,1)) + 1.0\n",
    "\n",
    "X_tr = np.random.normal(size=(n_tr,d))\n",
    "noise_tr = np.random.normal(size=(n_tr,1))\n",
    "y_tr = X_tr.dot(w_star) + noise_tr\n",
    "\n",
    "X_te = np.random.normal(size=(n_te,d))\n",
    "noise_te = np.random.normal(size=(n_te,1))\n",
    "y_te = X_te.dot(w_star) + noise_te\n",
    "\n",
    "# Prepare data object.\n",
    "data = DataSet()\n",
    "data.init_tr(X=X_tr, y=y_tr)\n",
    "data.init_te(X=X_te, y=y_te)\n",
    "\n",
    "# Prepare model object.\n",
    "mod = LinearL2()\n",
    "\n",
    "# Prepare random initial value, and take closer to solution.\n",
    "w_init = np.random.uniform(low=-5.0, high=5.0, size=(d,1))\n",
    "weight_balance = np.linspace(0.0, 1.0, 5)\n",
    "print(\"===============\")\n",
    "for wt in weight_balance:\n",
    "    w_est = wt * w_star + (1-wt) * w_init\n",
    "    print(\"l_tr:\", np.mean(mod.l_tr(w_est, data=data)),\n",
    "          \"l_te:\", np.mean(mod.l_te(w_est, data=data)))\n",
    "    print(\"g_tr:\\n\", np.mean(mod.g_tr(w_est, data=data), axis=0))\n",
    "    print(\"g_te:\\n\", np.mean(mod.g_te(w_est, data=data), axis=0))\n",
    "    print(\"===============\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "明らかなように、パラメータを$w^{\\ast}$に近づけていくにつれて、ロスの値が小さくなり、その点での勾配も平坦になっていく。次は学習アルゴリズムについて考える。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"trivial\"></a>\n",
    "## 自明なアルゴリズムを実装する\n",
    "\n",
    "まずはきわめて単純なアルゴリズムを作る。特別な働きは何もないが、自身の「状態」と「かかった反復回数」を管理する能力、そして条件に応じて終了する能力は持つ。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Algo_trivial:\n",
    "    '''\n",
    "    An iterator which does nothing special at all, but makes\n",
    "    a trivial update to the initial parameters given, and\n",
    "    keeps record of the number of iterations made.\n",
    "    '''\n",
    "\n",
    "    def __init__(self, w_init, t_max):\n",
    "        \n",
    "        self.w = np.copy(w_init)\n",
    "        self.t_max = t_max\n",
    "\n",
    "\n",
    "    def __iter__(self):\n",
    "\n",
    "        self.t = 0\n",
    "        print(\"(__iter__): t =\", self.t)\n",
    "\n",
    "        return self\n",
    "    \n",
    "\n",
    "    def __next__(self):\n",
    "        \n",
    "        # Condition for stopping.\n",
    "        if self.t >= self.t_max:\n",
    "            print(\"--- Condition reached! ---\")\n",
    "            raise StopIteration\n",
    "\n",
    "        print(\"(__next__): t =\", self.t)\n",
    "        self.w += 5\n",
    "        self.t += 1\n",
    "        # Note: __next__ does not need to return anything.\n",
    "        \n",
    "\n",
    "    def __str__(self):\n",
    "\n",
    "        out = \"State of w:\" + \"\\n\" + \"  \" + str(self.w)\n",
    "        return out\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "その振る舞いを見てみよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Printing docstring:\n",
      "\n",
      "    An iterator which does nothing special at all, but makes\n",
      "    a trivial update to the initial parameters given, and\n",
      "    keeps record of the number of iterations made.\n",
      "    \n",
      "(__iter__): t = 0\n",
      "(__next__): t = 0\n",
      "(__next__): t = 1\n",
      "(__next__): t = 2\n",
      "(__next__): t = 3\n",
      "(__next__): t = 4\n",
      "(__next__): t = 5\n",
      "(__next__): t = 6\n",
      "(__next__): t = 7\n",
      "(__next__): t = 8\n",
      "(__next__): t = 9\n",
      "--- Condition reached! ---\n"
     ]
    }
   ],
   "source": [
    "\n",
    "import numpy as np\n",
    "\n",
    "al = Algo_trivial(w_init=np.array([1,2,3,4,5]), t_max=10)\n",
    "\n",
    "print(\"Printing docstring:\")\n",
    "print(al.__doc__) # check the docstring\n",
    "\n",
    "for onestep in al:\n",
    "    pass # do nothing special\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "要点：\n",
    "\n",
    " - `StopIteration`という例外を挙げてから、ただちにループから脱出する。\n",
    " - 0番目のステップでは、`iter`も`next`も呼び出される。\n",
    "\n",
    "上記の`for`ループと同じ働きは手動でもできる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(__iter__): t = 0\n",
      "(__next__): t = 0\n",
      "(__next__): t = 1\n",
      "(__next__): t = 2\n",
      "(__next__): t = 3\n"
     ]
    }
   ],
   "source": [
    "iter(al)\n",
    "next(al)\n",
    "next(al)\n",
    "next(al)\n",
    "next(al) # and so on..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(__iter__): t = 0\n",
      "(__next__): t = 0\n",
      "State of w:\n",
      "  [ 6  7  8  9 10]\n",
      "(__next__): t = 1\n",
      "State of w:\n",
      "  [11 12 13 14 15]\n",
      "(__next__): t = 2\n",
      "State of w:\n",
      "  [16 17 18 19 20]\n",
      "(__next__): t = 3\n",
      "State of w:\n",
      "  [21 22 23 24 25]\n",
      "(__next__): t = 4\n",
      "State of w:\n",
      "  [26 27 28 29 30]\n",
      "(__next__): t = 5\n",
      "State of w:\n",
      "  [31 32 33 34 35]\n",
      "(__next__): t = 6\n",
      "State of w:\n",
      "  [36 37 38 39 40]\n",
      "(__next__): t = 7\n",
      "State of w:\n",
      "  [41 42 43 44 45]\n",
      "(__next__): t = 8\n",
      "State of w:\n",
      "  [46 47 48 49 50]\n",
      "(__next__): t = 9\n",
      "State of w:\n",
      "  [51 52 53 54 55]\n",
      "--- Condition reached! ---\n",
      "One last check after exiting:\n",
      "State of w:\n",
      "  [51 52 53 54 55]\n"
     ]
    }
   ],
   "source": [
    "al = Algo_trivial(w_init=np.array([1,2,3,4,5]), t_max=10)\n",
    "\n",
    "for onestep in al:\n",
    "    print(al) # useful for monitoring state.\n",
    "\n",
    "print(\"One last check after exiting:\")\n",
    "print(al) # ensure that no additional changes were made."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Exercises:__\n",
    "\n",
    "0. `Algo_trivial`を反復するごとに、`w`がどのように更新されているか説明すること。この算法を「自明」と呼んでいるのは、データやモデルたるものには一切依存しない更新則だからである。\n",
    "\n",
    "0. 反復するごとに、`w`の全要素が倍増されるように`Algo_trivial`を改造してみること。\n",
    "\n",
    "0. さらに、初期値が$w=(0,1,2,3,4)$で、何回か倍増を繰り返したあとの状態が$w=(0, 16, 32, 48, 64) = (0 \\times 2^4, 1 \\times 2^4, 2 \\times 2^4, 3 \\times 2^4, 4 \\times 2^4)$となるように、`al`を初期化する際に使うパラメータを設定すること。\n",
    "\n",
    "0. `al`を初期化しなおすこと無く、`for`ループを複数回走らせると、`w`の状態がどうなっていくか。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"link3\"></a>\n",
    "## 三者を結びつける\n",
    "\n",
    "先ほどの線形回帰の具体例に戻って、その実装を完成させていこう。有用なアルゴリズムを作るには、上手に観測データに応じたパラメータ更新則が不可欠である。ここで、経験期待損失最小化（empirical risk minimization, ERM）を、最急降下法で実装した学習アルゴリズムにする。\n",
    "\n",
    "要点は以下のとおりである。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- データ：入力ベクトルと実数値の応答$x \\in \\mathbb{R}^{d}$, $y \\in \\mathbb{R}$.データセットの全体は$\\{(x_{1},y_{1}),\\ldots,(x_{n},y_{n})\\}$とする。\n",
    "\n",
    "- モデル：二乗誤差を用いた線形回帰モデル。つまり、$y = \\langle w^{\\ast}, x\\rangle + \\varepsilon$と仮定している。ロス関数は$L(w;x,y) = (y - \\langle w, x\\rangle)^{2}/2$で、勾配が$\\nabla L(w;x,y) = -(y-\\langle w, x\\rangle)x$である。\n",
    "\n",
    "- アルゴリズム：最急降下法を使って、固定したステップサイズ$\\alpha > 0$を用いる。数式で表わすと、$z_{i}=(x_{i},y_{i})$として以下の通りである。\n",
    "\n",
    "\\begin{align*}\n",
    "w_{(t+1)} \\gets w_{(t)} - \\alpha \\frac{1}{n} \\sum_{i=1}^{n}\\nabla L(w_{(t)}; z_{i}).\n",
    "\\end{align*}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "データもモデルもできているので、あとは先ほどのイテレータの準備を踏まえて、アルゴリズムのオブジェクトを定義することである。`Algo_SimpleGD`と名づけて、以下の通りである。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "import numpy as np\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "class Algo_SimpleGD:\n",
    "    '''\n",
    "    Iterator which implements a line-search steepest descent method,\n",
    "    using the sample mean estimate of the gradient.\n",
    "    '''\n",
    "    \n",
    "    def __init__(self, w_init, t_max, step, store):\n",
    "        self.w = w_init\n",
    "        self.t = None\n",
    "        self.t_max = t_max\n",
    "        self.step = step\n",
    "        self.store = store\n",
    "        \n",
    "        # Keep record of all updates (optional).\n",
    "        if self.store:\n",
    "            self.wstore = np.zeros((self.w.size,t_max+1), dtype=np.float32)\n",
    "            self.wstore[:,0] = self.w.flatten()\n",
    "        else:\n",
    "            self.wstore = None\n",
    "        \n",
    "    def __iter__(self):\n",
    "        self.t = 0\n",
    "        return self\n",
    "        \n",
    "    def __next__(self):\n",
    "        if self.t >= self.t_max:\n",
    "            raise StopIteration\n",
    "        \n",
    "    def newdir(self, model, data):\n",
    "        return (-1) * np.mean(model.g_tr(w=self.w, data=data), axis=0, keepdims=True)\n",
    "\n",
    "    def update(self, model, data):\n",
    "        \n",
    "        # Parameter update.\n",
    "        stepsize = self.step(self.t)\n",
    "        newdir = self.newdir(model=model, data=data)\n",
    "        self.w = self.w + stepsize * np.transpose(newdir)\n",
    "        \n",
    "        # Monitor update.\n",
    "        self.t += 1\n",
    "        \n",
    "        # Keep record of all updates (optional).\n",
    "        if self.store:\n",
    "            self.wstore[:,self.t] = self.w.flatten()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "念頭におくべき要点：\n",
    "\n",
    "- `w_init`が初期値の$w_{(0)}$で、アルゴリズムの初期化の際に必要である。\n",
    "\n",
    "- `newdir`は更新方向を返す。\n",
    "\n",
    "- `step`はコールバック関数で、たとえばステップ数の`t`に応じてステップサイズを変えるときなどに活用できる。\n",
    "\n",
    "- `update`はパラメータの更新を実際に行うメソッドである。そのほかに計算資源のコスト等を管理するメソッドを呼び出す。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "まずは試しに、乱数を発生させてデータを生成し、自前の学習機を動かしてみる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X_tr: (100, 2) ... sumcheck = -9.94677583241537\n",
      "y_tr: (100, 1) ... sumcheck = -40.20352170786684\n",
      "X_te: (100, 2) ... sumcheck = -1.089890767972685\n",
      "y_te: (100, 1) ... sumcheck = 16.95676631804479\n"
     ]
    }
   ],
   "source": [
    "# Generate data.\n",
    "data = DataSet()\n",
    "n = 100\n",
    "d = 2\n",
    "w_star = math.pi * np.ones((d,1), dtype=np.float32)\n",
    "X = np.random.standard_normal(size=(n*2,d))\n",
    "epsilon = np.random.standard_t(df=3, size=(n*2,1))\n",
    "y = X.dot(w_star) + epsilon\n",
    "data.init_tr(X=X[0:n,:], y=y[0:n,:]) # former half for training\n",
    "data.init_te(X=X[n:,:], y=y[n:,:]) # latter half for testing\n",
    "\n",
    "print(\"X_tr:\", data.X_tr.shape, \"... sumcheck =\", np.sum(data.X_tr))\n",
    "print(\"y_tr:\", data.y_tr.shape, \"... sumcheck =\", np.sum(data.y_tr))\n",
    "print(\"X_te:\", data.X_te.shape, \"... sumcheck =\", np.sum(data.X_te))\n",
    "print(\"y_te:\", data.y_te.shape, \"... sumcheck =\", np.sum(data.y_te))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize model.\n",
    "mod = LinearL2()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize learning algorithm.\n",
    "\n",
    "w_init = np.random.uniform(size=(d,1))\n",
    "\n",
    "def alpha_fixed(t, val):\n",
    "    return val\n",
    "\n",
    "def make_step(u):\n",
    "    def mystep(t):\n",
    "        return alpha_fixed(t=t, val=u)\n",
    "    return mystep\n",
    "\n",
    "al = Algo_SimpleGD(w_init=w_init,\n",
    "                   t_max=15,\n",
    "                   step=make_step(0.15),\n",
    "                   store=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "State of algorithm after completion:\n",
      "t = 15\n",
      "w = [[2.97596384]\n",
      " [2.74678402]]\n"
     ]
    }
   ],
   "source": [
    "# Iterate the learning algorithm.\n",
    "for onestep in al:\n",
    "    al.update(model=mod, data=data)\n",
    "\n",
    "print(\"State of algorithm after completion:\")\n",
    "print(\"t =\", al.t)\n",
    "print(\"w =\", al.w)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "比較対象として、線形モデルの下で二乗誤差の和を最小にする解が解析的に求まることはわかっているので、それも合わせて計算しておく（`w_OLS`と書く）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "w_OLS = np.linalg.lstsq(a=data.X_tr, b=data.y_tr, rcond=None)[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualize the output (in 2D case).\n",
    "mypath = al.wstore\n",
    "\n",
    "if (d == 2):\n",
    "\n",
    "    init_diff = np.linalg.norm(w_star-w_init) * 1.0\n",
    "    \n",
    "    myfig = plt.figure(figsize=(7,7))\n",
    "    ax = myfig.add_subplot(1,1,1)\n",
    "    \n",
    "    ax.quiver(mypath[0,:-1], mypath[1,:-1],\n",
    "              mypath[0,1:]-mypath[0,:-1],\n",
    "              mypath[1,1:]-mypath[1,:-1],\n",
    "              scale_units='xy', angles='xy', scale=1, color='k')\n",
    "    \n",
    "    ax.plot(*w_star, 'r*', markersize=12, label=\"w_star\") # print true value.\n",
    "    ax.plot(*w_OLS, 'gv', markersize=8, label=\"w_OLS\") # print OLS estimate.\n",
    "    ax.plot(*mypath[:,-1], 'bo', markersize=8, label=\"w\") # print our final estimate.\n",
    "    ax.legend(loc=1,ncol=1)\n",
    "    plt.title('Trajectory of a simple GD routine')\n",
    "    plt.xlim((w_star[0]-init_diff, w_star[0]+init_diff))\n",
    "    plt.ylim((w_star[1]-init_diff, w_star[1]+init_diff))\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__練習問題__\n",
    "\n",
    "0. 学習アルゴリズムの設定を固定した上で、サンプル数やノイズの分布を変えてみること。その結果として、探索の軌道がどう変わるか。\n",
    "\n",
    "0. データ分布の設定を固定した上で、アルゴリズムの設定（ステップサイズ、反復回数の上限、初期値）を変えてみること。その結果として、探索の軌道がどう変わるか。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"learning\"></a>\n",
    "## 最適化と学習\n",
    "\n",
    "素朴な疑問として、「学習と最適化の違いとは一体何か」ということが当然、気になる。端的にその違いを述べるならば、__パフォーマンスの評価の仕方が違う。__つまり、最適化に成功したとしても、学習に失敗すること（過学習）も、最適化に失敗しても学習に成功することもある。\n",
    "\n",
    "「最適化」をするとき、何らかの制約の下で、関心のある目的関数の返す値がもっとも小さくなるように、その関数に渡すベクトルや集合などを選定する。工学の観点からは、目的関数が未知であれば、最適化を考える意味がない。$f(\\cdot)$を最小にしたいときに、候補の$\\widehat{x}$があっても、もし$f(\\widehat{x})$すら計算できないのであれば、任意の$x$に対して$f(\\widehat{x}) \\leq f(x)$なのかどうか、知ることは到底できない。もちろん、$f$の取る値を見ずに、その勾配ベクトル$\\nabla f$だけで最小化することもしばしばあるが、$f$について確かな情報があることは変わらない。ざっくりいえば、__知っている関数__を最小にすることが最適化である。\n",
    "\n",
    "一方で、学習では「推論」が必要である。学習能力を評価する方法はいくらでもあるが、通常の考え方として換言すれば、__知らない関数__を最小にすることが学習の基本である。具体的に例示してみよう。古くからある統計的決定理論にも登場するのだが、確率モデルを前提とした学習モデルの典型例が「リスク（期待損失）最小化」である。\n",
    "\n",
    "\\begin{align*}\n",
    "\\min_{w \\in \\mathbb{R}^{d}} R(w), \\quad R(w) = \\mathbf{E}_{Z} L(w;z).\n",
    "\\end{align*}\n",
    "\n",
    "この関数$R$を最小にすれば、学習に成功したといえる、という学習モデルである。したがって、厳密にいえば最適化問題でもあるが、データ$z$の分布は未知なので、期待値は知らない。よって$R$も計算できないし、その勾配も何もかもわからないという状況である。実際、知ることができるのは、$L$だけである。それと観測データ$z_{1},\\ldots,z_{n}$を使って、$R$について推し量るしかない。\n",
    "\n",
    "上記を踏まえて、最適化と学習をはっきりと区別することができる。我々としては、最適化は学習を行う上で必要不可欠な作業であって、学習そのものではない。先ほどの線形回帰の事例では、OLS解（最適化を完璧にこなした結果）が$w^{\\ast}$とは一致しないことが一般的である。これは__統計的誤差__である。一方、学習機が「状態」として更新していく$w_{(t)}$とOLS解との距離は__計算誤差__である。うまく学習させるには、この2種の誤差を小さくすることが基本である。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__事例の深化：リスク関数が二次関数の場合__\n",
    "\n",
    "さらに理解を促すため、簡単なシミュレーションを用いた学習課題を考える。ここで強調したいのは、同じリスク関数でも、データを生成する確率分布の違いによって、学習アルゴリズムの性能が大きく変わりうることである。\n",
    "\n",
    "仮に、期待損失$R$が単純な二次関数の形式を取るとする。\n",
    "\n",
    "\\begin{align*}\n",
    "R(w) = (w - w^{\\ast})^{T}A(w - w^{\\ast}) + b^2.\n",
    "\\end{align*}\n",
    "\n",
    "現にあるロス関数$L$をとって、任意の$w \\in \\mathbb{R}^{d}$に対して$\\mathbf{E}_{Z} L(w;z) = R(w)$という条件を満たすには、線形回帰モデルを仮定して、入力と加法ノイズが互いに独立であるならば、十分である。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "つまり、$z = (x,y)$と書くと、\n",
    "\n",
    "\\begin{align*}\n",
    "y = \\langle w^{\\ast}, x \\rangle + \\varepsilon\n",
    "\\end{align*}\n",
    "\n",
    "というモデルで、$\\varepsilon$が$x$と独立であるという仮定である。その結果として$\\mathbf{E}\\varepsilon x = 0$となる。したがって、\n",
    "\n",
    "\\begin{align*}\n",
    "b^2 & = \\mathbf{E}\\varepsilon^2\\\\\n",
    "A & = \\mathbf{E}xx^{T}\n",
    "\\end{align*}\n",
    "\n",
    "というときに$\\mathbf{E}_{Z} L(w;z) = R(w)$が成り立つ。これらの仮定は先程の線形回帰とまったく同じである。さらに$\\mathbf{E}_{X}x = 0$と置くと$A =\\text{cov}\\,x$と、入力の共分散行列がリスク関数に姿を表わす。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上記を踏まえて、シミュレーションをする場合のみ、確率分布がわかるので、$L$のみならず$R$もわかるということになる。そこで面白いのは、同じ$R$でも、データの確率分布の違いによって、機械学習の手法の優劣を調べることである。新しいアルゴリズムを開発する上で、大変便利なアプローチである。\n",
    "\n",
    "さて、$R$を計算するためのコードを前の事例に加えて、$R$の等高線入りで学習機の軌道を表わすことにする。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "import numpy as np\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Data distribution and sample parameters.\n",
    "\n",
    "n = 500\n",
    "d = 2\n",
    "X_sd = 1.0\n",
    "cov_X = X_sd * np.eye(d) # covariance matrix of the inputs.\n",
    "w_star = math.pi * np.ones((d,1), dtype=np.float32) # true vec.\n",
    "noise_dict = {}\n",
    "risk_dict = {}\n",
    "\n",
    "\n",
    "def vlnorm(meanlog, sdlog):\n",
    "    '''\n",
    "    Variance of the log-Normal distribution.\n",
    "    '''\n",
    "    return (math.exp(sdlog**2) - 1) * math.exp((2*meanlog + sdlog**2))\n",
    "\n",
    "def mlnorm(meanlog, sdlog):\n",
    "    '''\n",
    "    Mean of log-Normal distribution.\n",
    "    '''\n",
    "    return math.exp((meanlog + sdlog**2/2))\n",
    "\n",
    "\n",
    "def vnorm(shift, scale):\n",
    "    '''\n",
    "    Variance of the Normal distribution.\n",
    "    '''\n",
    "    return scale**2\n",
    "\n",
    "def mnorm(shift, scale):\n",
    "    '''\n",
    "    Mean of Normal distribution.\n",
    "    '''\n",
    "    return shift\n",
    "\n",
    "\n",
    "def riskMaker(w, A, b, w_star):\n",
    "    diff = w - w_star\n",
    "    quad = diff.T.dot(A.dot(diff).reshape(diff.shape))\n",
    "    return np.float32(quad) + b**2\n",
    "\n",
    "\n",
    "# Normal prep.\n",
    "def risk_norm(w):\n",
    "    return riskMaker(w=w,\n",
    "                     A=cov_X,\n",
    "                     b=math.sqrt(vnorm(shift=0, scale=20.0)),\n",
    "                     w_star=w_star)\n",
    "noise_dict[\"norm\"] = np.random.normal(loc=0.0, scale=20.0, size=(n,1))-mnorm(shift=0, scale=20.0)\n",
    "\n",
    "# log-Normal prep.\n",
    "def risk_lnorm(w):\n",
    "    return riskMaker(w=w,\n",
    "                     A=cov_X,\n",
    "                     b=math.sqrt(vlnorm(meanlog=0, sdlog=1.75)),\n",
    "                     w_star=w_star)\n",
    "noise_dict[\"lnorm\"] = np.random.lognormal(mean=0.0, sigma=1.75, size=(n,1))-mlnorm(meanlog=0, sdlog=1.75)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generate the training data.\n",
    "data_norm = DataSet()\n",
    "data_lnorm = DataSet()\n",
    "X = np.random.normal(loc=0.0, scale=X_sd, size=(n,d))\n",
    "#epsilon = np.random.normal(loc=0.0, scale=epsilon_sd, size=(n,1))\n",
    "#y = np.dot(X, w_star) + epsilon\n",
    "data_norm.init_tr(X=X,\n",
    "                  y=(X.dot(w_star)+noise_dict[\"norm\"]))\n",
    "data_lnorm.init_tr(X=X,\n",
    "                   y=(X.dot(w_star)+noise_dict[\"lnorm\"]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize model.\n",
    "mod = LinearL2()\n",
    "\n",
    "# Initialize learning algorithm.\n",
    "w_init = np.random.uniform(size=(d,1))\n",
    "tostore = True\n",
    "t_max = 15\n",
    "alphaval = 0.1\n",
    "\n",
    "def alpha_fixed(t, val):\n",
    "    return val\n",
    "\n",
    "def make_step(u):\n",
    "    def mystep(t):\n",
    "        return alpha_fixed(t=t, val=u)\n",
    "    return mystep\n",
    "\n",
    "al = Algo_SimpleGD(w_init=w_init,\n",
    "                   t_max=t_max,\n",
    "                   step=make_step(alphaval),\n",
    "                   store=tostore)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# First, run it for the Normal case.\n",
    "for onestep in al:\n",
    "    al.update(model=mod, data=data_norm)\n",
    "    \n",
    "mypath_norm = al.wstore"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Then, re-initialize the algorithm and do it for log-Normal.\n",
    "al = Algo_SimpleGD(w_init=w_init,\n",
    "                   t_max=t_max,\n",
    "                   step=make_step(alphaval),\n",
    "                   store=tostore)\n",
    "for onestep in al:\n",
    "    al.update(model=mod, data=data_lnorm)\n",
    "\n",
    "mypath_lnorm = al.wstore"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get the OLS solutions.\n",
    "w_OLS_norm = np.linalg.lstsq(a=data_norm.X_tr,\n",
    "                             b=data_norm.y_tr, rcond=None)[0]\n",
    "w_OLS_lnorm = np.linalg.lstsq(a=data_lnorm.X_tr,\n",
    "                              b=data_lnorm.y_tr, rcond=None)[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[400.]]\n",
      "[[435.76376]]\n"
     ]
    }
   ],
   "source": [
    "print(risk_norm(w_star))\n",
    "print(risk_lnorm(w_star))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Distance: 1.3772832\n",
      "Distance: 2.4935608\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x1008 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Visualize the output (in 2D case).\n",
    "mypath = al.wstore\n",
    "\n",
    "if (d == 2):\n",
    "    \n",
    "    myfig = plt.figure(figsize=(7,14))\n",
    "    \n",
    "    # Prep for contour lines.\n",
    "    tmpdel = np.linalg.norm(w_star-w_init) * 1\n",
    "    xvals = np.arange(w_star[0]-tmpdel,w_star[0]+tmpdel, 0.1)\n",
    "    yvals = np.arange(w_star[1]-tmpdel,w_star[1]+tmpdel, 0.1)\n",
    "    X, Y = np.meshgrid(xvals, yvals)\n",
    "    \n",
    "    # Trajectory for the normal case.\n",
    "    def risk2D_helper(w1, w2):\n",
    "        w2D = np.array([w1,w2]).reshape((2,1))\n",
    "        return risk_norm(w=w2D)\n",
    "    \n",
    "    risk2D = np.vectorize(risk2D_helper)\n",
    "    Z = risk2D(w1=X, w2=Y)\n",
    "    ax_norm = myfig.add_subplot(2,1,1)\n",
    "    CS = ax_norm.contour(X, Y, Z)\n",
    "    ax_norm.quiver(mypath_norm[0,:-1], mypath_norm[1,:-1],\n",
    "              mypath_norm[0,1:]-mypath_norm[0,:-1],\n",
    "              mypath_norm[1,1:]-mypath_norm[1,:-1],\n",
    "              scale_units='xy', angles='xy', scale=1, color='k')\n",
    "    CS.clabel(inline=1, fontsize=10)\n",
    "    ax_norm.plot(*w_star, 'r*', markersize=12, label=\"w_star\") # print true value.\n",
    "    ax_norm.plot(*w_OLS_norm, 'gv', markersize=8, label=\"w_OLS\") # print OLS estimate.\n",
    "    ax_norm.plot(*mypath_norm[:,-1], 'bo', markersize=8, label=\"w\") # print our final estimate.\n",
    "    ax_norm.legend(loc=1,ncol=1)\n",
    "    plt.title('Trajectory of GD routine (Normal noise)')\n",
    "    \n",
    "    print(\"Distance:\", np.linalg.norm(mypath_norm[:,-1]-w_star))\n",
    "    \n",
    "    # Then log-Normal case.\n",
    "    def risk2D_helper(w1, w2):\n",
    "        w2D = np.array([w1,w2]).reshape((2,1))\n",
    "        return risk_lnorm(w=w2D)\n",
    "    \n",
    "    risk2D = np.vectorize(risk2D_helper)\n",
    "    Z = risk2D(w1=X, w2=Y)\n",
    "\n",
    "    ax_lnorm = myfig.add_subplot(2,1,2)\n",
    "    CS = ax_lnorm.contour(X, Y, Z)\n",
    "    ax_lnorm.quiver(mypath_lnorm[0,:-1], mypath_lnorm[1,:-1],\n",
    "              mypath_lnorm[0,1:]-mypath_lnorm[0,:-1],\n",
    "              mypath_lnorm[1,1:]-mypath_lnorm[1,:-1],\n",
    "              scale_units='xy', angles='xy', scale=1, color='k')\n",
    "    CS.clabel(inline=1, fontsize=10)\n",
    "    ax_lnorm.plot(*w_star, 'r*', markersize=12, label=\"w_star\") # print true value.\n",
    "    ax_lnorm.plot(*w_OLS_lnorm, 'gv', markersize=8, label=\"w_OLS\") # print OLS estimate.\n",
    "    ax_lnorm.plot(*mypath_lnorm[:,-1], 'bo', markersize=8, label=\"w\") # print our final estimate.\n",
    "    ax_lnorm.legend(loc=1,ncol=1)\n",
    "    plt.title('Trajectory of GD routine (log-Normal noise)')\n",
    "    \n",
    "    print(\"Distance:\", np.linalg.norm(mypath_lnorm[:,-1]-w_star))\n",
    "    \n",
    "    plt.show()\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "このように、ロス関数による目的関数のほかに、潜在する「真の目的関数」があることがわかる（つまり$R$で、`risk`として算出）。学習アルゴリズムの本来の目的関数は、前者ではなく、後者である。勾配を使った最急降下法などでは、理想として$\\nabla R(w_{(t)})$を知りたいところだが、未知なので$\\nabla L(w;z)$のサンプル平均を使って推定している。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__練習問題__\n",
    "\n",
    "0. 前の練習問題のように、真の目的関数の等高線が見えるなかで再びアルゴリズムと確率分布のパラメータを変更してみること。\n",
    "\n",
    "0. 上記の問題でパラメータを変更させた結果を、「汎化能力」や「過学習」といった言葉を使って説明すること。"
   ]
  },
  {
   "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
}