Chainer Beginer's Hands-on.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Update (2018/04/20): Chainer v4に合わせ内容を更新しました。\n",
    "\n",
    "**注意：**\n",
    "\n",
    "- 今回はニューラルネットワーク自体が何なのかといった説明は省きます。\n",
    "- この記事はJupyter notebookを使って書かれていますので、コードは上から順番に実行できるようにチェックされています。元のJupyter notebookファイルはこちらにおいてあります。\n",
    "\n",
    "Qiitaだとページ内リンクつきの目次が勝手に作成されるので、全体概要はそちらを眺めて把握してください。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# インストール\n",
    "\n",
    "Chainerのインストールはとても簡単です。Chainer本体はすべてPythonコードのみからなるので、インストールも"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: chainer in /home/shunta/.pyenv/versions/anaconda3-5.0.0/lib/python3.6/site-packages\n",
      "Requirement already satisfied: filelock in /home/shunta/.pyenv/versions/anaconda3-5.0.0/lib/python3.6/site-packages (from chainer)\n",
      "Requirement already satisfied: protobuf>=3.0.0 in /home/shunta/.pyenv/versions/anaconda3-5.0.0/lib/python3.6/site-packages (from chainer)\n",
      "Requirement already satisfied: six>=1.9.0 in /home/shunta/.pyenv/versions/anaconda3-5.0.0/lib/python3.6/site-packages (from chainer)\n",
      "Requirement already satisfied: numpy>=1.9.0 in /home/shunta/.pyenv/versions/anaconda3-5.0.0/lib/python3.6/site-packages (from chainer)\n",
      "Requirement already satisfied: setuptools in /home/shunta/.pyenv/versions/anaconda3-5.0.0/lib/python3.6/site-packages (from protobuf>=3.0.0->chainer)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "You are using pip version 9.0.1, however version 10.0.1 is available.\n",
      "You should consider upgrading via the 'pip install --upgrade pip' command.\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "pip install chainer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "で完了です。ただ、これだけではGPUは使えません。GPUを使うためには、**別途CuPyをインストールする必要があります。**ただCuPyのインストールもとても簡単です。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: cupy-cuda90 in /home/shunta/.pyenv/versions/anaconda3-5.0.0/lib/python3.6/site-packages\n",
      "Requirement already satisfied: six>=1.9.0 in /home/shunta/.pyenv/versions/anaconda3-5.0.0/lib/python3.6/site-packages (from cupy-cuda90)\n",
      "Requirement already satisfied: fastrlock>=0.3 in /home/shunta/.pyenv/versions/anaconda3-5.0.0/lib/python3.6/site-packages (from cupy-cuda90)\n",
      "Requirement already satisfied: numpy>=1.9.0 in /home/shunta/.pyenv/versions/anaconda3-5.0.0/lib/python3.6/site-packages (from cupy-cuda90)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "You are using pip version 9.0.1, however version 10.0.1 is available.\n",
      "You should consider upgrading via the 'pip install --upgrade pip' command.\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "pip install cupy-cuda90"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以上です。筆者の環境がCUDA9.0の環境であったため`cupy-cuda90`をインストールしていますが、この末尾の2つの数字はCUDAのバージョンを表しています。お使いの環境のCUDAバージョンに合わせて、\n",
    "\n",
    "- `cupy-cuda80`（CUDA 8.0用）\n",
    "- `cupy-cuda90`（CUDA9.0用）\n",
    "- `cupy-cuda91`（CUDA9.1用）\n",
    "\n",
    "の3つから適切なものを選択して`pip install`してください。CuPy v4.0.0からwheelでのインストールが可能となりましたので、これにより自動的にcuDNNやNCCL2といったライブラリもインストールされ、CuPyから使用可能になります。（cuDNNを独立に取ってくる方法を注に書いておきます[^cudnnenv]）\n",
    "\n",
    "また、Chainer v4.0.0から`chainer.print_runtime_info()`という便利なメソッドが追加されました。以下のコマンドをターミナルで実行し、ChainerやCuPyが正しくインストールされたかを確認してみましょう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Chainer: 4.0.0\n",
      "NumPy: 1.14.0\n",
      "CuPy:\n",
      "  CuPy Version          : 4.0.0\n",
      "  CUDA Root             : /usr/local/cuda\n",
      "  CUDA Build Version    : 9000\n",
      "  CUDA Driver Version   : 9000\n",
      "  CUDA Runtime Version  : 9000\n",
      "  cuDNN Build Version   : 7102\n",
      "  cuDNN Version         : 7005\n",
      "  NCCL Build Version    : 2104\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/shunta/.pyenv/versions/anaconda3-5.0.0/lib/python3.6/site-packages/h5py/__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  from ._conv import register_converters as _register_converters\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "python -c 'import chainer; chainer.print_runtime_info()'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "うまくできていますね。以下のチュートリアルでは、matplotlibを可視化に使いますので、これも同時にインストールしておきましょう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: matplotlib in /home/shunta/.pyenv/versions/anaconda3-5.0.0/lib/python3.6/site-packages\n",
      "Requirement already satisfied: numpy>=1.7.1 in /home/shunta/.pyenv/versions/anaconda3-5.0.0/lib/python3.6/site-packages (from matplotlib)\n",
      "Requirement already satisfied: six>=1.10 in /home/shunta/.pyenv/versions/anaconda3-5.0.0/lib/python3.6/site-packages (from matplotlib)\n",
      "Requirement already satisfied: python-dateutil>=2.1 in /home/shunta/.pyenv/versions/anaconda3-5.0.0/lib/python3.6/site-packages (from matplotlib)\n",
      "Requirement already satisfied: pytz in /home/shunta/.pyenv/versions/anaconda3-5.0.0/lib/python3.6/site-packages (from matplotlib)\n",
      "Requirement already satisfied: cycler>=0.10 in /home/shunta/.pyenv/versions/anaconda3-5.0.0/lib/python3.6/site-packages (from matplotlib)\n",
      "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /home/shunta/.pyenv/versions/anaconda3-5.0.0/lib/python3.6/site-packages (from matplotlib)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "You are using pip version 9.0.1, however version 10.0.1 is available.\n",
      "You should consider upgrading via the 'pip install --upgrade pip' command.\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "pip install matplotlib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "また、計算グラフの可視化にGraphvizを使いますので、こちらもインストールしておいてください。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 学習ループを書いてみよう\n",
    "\n",
    "ここでは、有名な手書き数字のデータセットMNISTを使って、画像を10クラスに分類するネットワークを書いて訓練してみます。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. データセットの準備\n",
    "\n",
    "教師あり学習の場合、**データセットは「入力データ」と「それと対になるラベルデータ」を返すオブジェクトである必要があります。**\n",
    "ChainerにはMNISTやCIFAR10/100のようなよく用いられるデータセットに対して、データをダウンロードしてくるところからそのような機能をもったオブジェクトを作るところまで自動的にやってくれる便利なメソッドがあるので、ここではひとまずこれを用いましょう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/shunta/.pyenv/versions/anaconda3-5.0.0/lib/python3.6/site-packages/h5py/__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  from ._conv import register_converters as _register_converters\n"
     ]
    }
   ],
   "source": [
    "from chainer.datasets import mnist\n",
    "\n",
    "# データセットがダウンロード済みでなければ、ダウンロードも行う\n",
    "train_val, test = mnist.get_mnist(withlabel=True, ndim=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "データセットオブジェクト自体は準備ができました。これは、例えば `train_val[i]` などとすると**i番目の `(data, label)` というタプルを返すリスト** と同様のものになっています（**実際ただのPythonリストもChainerのデータセットオブジェクトとして使えます**）。では0番目のデータとラベルを取り出して、表示してみましょう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x2b06ddab7630>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "label: 5\n"
     ]
    }
   ],
   "source": [
    "# matplotlibを使ったグラフ描画結果がnotebook内に表示されるようにします。\n",
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# データの例示\n",
    "x, t = train_val[0]  # 0番目の (data, label) を取り出す\n",
    "plt.imshow(x.reshape(28, 28), cmap='gray')\n",
    "plt.axis('off')\n",
    "plt.show()\n",
    "print('label:', t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1 Validation用データセットを作る\n",
    "\n",
    "次に、上で作成した`train_val`データセットを、Training用のデータセットとValidation用のデータセットに分割しましょう。これもChainerの便利な関数を使えば簡単にできます。元々60000個のデータが入っている`train`データセット50000個のデータをTraining用に、残りの10000個をValidation用にしてみます。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from chainer.datasets import split_dataset_random\n",
    "\n",
    "train, valid = split_dataset_random(train_val, 50000, seed=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "これだけで元々の`train_val`を、ランダムに選んだ50000個の`train`データセットと`valid`データセットに分けることができました。何度も実行する際に異なる分け方になってしまわないよう、第3引数の`seed`を設定しておくことをオススメします。それでは、それぞれのデータセットの中に入っているデータの数を確認してみましょう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training dataset size: 50000\n",
      "Validation dataset size: 10000\n"
     ]
    }
   ],
   "source": [
    "print('Training dataset size:', len(train))\n",
    "print('Validation dataset size:', len(valid))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Iteratorの作成\n",
    "\n",
    "データセットの準備は完了しましたが、このままネットワークの学習に使うのは少し面倒です。なぜなら、ネットワークのパラメータ最適化手法として広く用いられているStochastic Gradient Descent (SGD)という手法では、一般的にいくつかのデータを束ねた**ミニバッチ**と呼ばれる単位でネットワークにデータを渡し、それに対する予測を作って、ラベルと比較するということを行います。そのため、**バッチサイズ分だけデータとラベルを束ねる作業が必要です。**\n",
    "\n",
    "そこで、**データセットから決まった数のデータとラベルを取得し、それらを束ねてミニバッチを作ってくれる機能を持った`Iterator`を使いましょう。**`Iterator`は、先程作ったデータセットオブジェクトを渡して初期化してやったあとは、`next()`メソッドで新しいミニバッチを返してくれます。内部ではデータセットを何周なめたか（`epoch`）などの情報がどうように記録されているおり、学習ループを書いていく際に便利です。\n",
    "\n",
    "データセットオブジェクトからイテレータを作るには、以下のようにします。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "from chainer import iterators\n",
    "\n",
    "batchsize = 128\n",
    "\n",
    "train_iter = iterators.SerialIterator(train, batchsize)\n",
    "valid_iter = iterators.SerialIterator(\n",
    "    valid, batchsize, repeat=False, shuffle=False)\n",
    "test_iter = iterators.SerialIterator(\n",
    "    test, batchsize, repeat=False, shuffle=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ここでは、学習に用いるデータセット用のイテレータ（`train_iter`）と、検証用のデータセット用のイテレータ（`valid_iter`）、および学習したネットワークの評価に用いるテストデータセット用のイテレータ（`test_iter`）の計3つを作成しています。ここで、`batchsize = 128`としているので、作成した3つの`Iterator`は、例えば`train_iter.next()`などとすると128枚の数字画像データを一括りにして返してくれます。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### NOTE: `SerialIterator`について\n",
    "\n",
    "Chainerがいくつか用意している`Iterator`の一種である`SerialIterator`は、データセットの中のデータを順番に取り出してくる最もシンプルな`Iterator`です。コンストラクタの引数にデータセットオブジェクトと、バッチサイズを取ります。このとき、渡したデータセットオブジェクトから、何周も何周もデータを繰り返し読み出す必要がある場合は`repeat`引数を`True`とし、1周が終わったらそれ以上データを取り出したくない場合はこれを`False`とします。これは、主にvalidation用のデータセットに対して使うフラグです。デフォルトでは、`True`になっています。また、`shuffle`引数に`True`を渡すと、データセットから取り出されてくるデータの順番をエポックごとにランダムに変更します。`SerialIterator`の他にも、マルチプロセスで高速にデータを処理できるようにした`MultiprocessIterator`や`MultithreadIterator`など、複数の`Iterator`が用意されています。詳しくは以下を見てください。\n",
    "\n",
    "- [Chainerで使えるIterator一覧](https://docs.chainer.org/en/stable/reference/iterators.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. ネットワークの定義\n",
    "\n",
    "では、学習させるネットワークを定義してみましょう。今回は、全結合層のみからなる多層パーセプトロンを作ってみます。中間層のユニット数は適当に100とし、今回は10クラス分類をしたいので、出力ユニット数は10とします。今回用いるMNISTデータセットは0〜9までの数字のいずれかを意味する10種のラベルを持つためです。では、ネットワークを定義するために必要な`Link`, `Function`, そして`Chain`について、簡単にここで説明を行います。\n",
    "\n",
    "### LinkとFunction\n",
    "\n",
    "Chainerでは、ニューラルネットワークの各層を、`Link`と`Function`に区別します。\n",
    "\n",
    "- **`Link`は、パラメータを持つ関数です。**\n",
    "- **`Function`は、パラメータを持たない関数です。**\n",
    "\n",
    "これらを組み合わせてネットワークを記述します。パラメータを持つ層は、`chainer.links`モジュール以下にたくさん用意されています。パラメータを持たない層は、`chainer.functions`モジュール以下にたくさん用意されています。これらに簡単にアクセスするために、\n",
    "\n",
    "```\n",
    "import chainer.links as L\n",
    "import chainer.functions as F\n",
    "```\n",
    "\n",
    "と別名を与えて、`L.Convolution2D(...)`や`F.relu(...)`のように用いる慣習がありますが、特にこれが決まった書き方というわけではありません。\n",
    "\n",
    "### Chain\n",
    "\n",
    "`Chain`は、**パラメータを持つ層（`Link`）をまとめておくためのクラス**です。パラメータを持つということは、基本的にネットワークの学習の際にそれらを更新していく必要があるということです（更新されないパラメータを持たせることもできます）。Chainerでは、モデルのパラメータの更新は、`Optimizer`という機能が担います。その際、更新すべき全てのパラメータを簡単に発見できるように、`Chain`で一箇所にまとめておきます。そうすると、`Chain.params()`メソッドを使って**更新されるパラメータ一覧が簡単に取得できます。**\n",
    "\n",
    "### Chainを継承してネットワークを定義しよう\n",
    "\n",
    "Chainerでは、ネットワークは`Chain`クラスを継承したクラスとして定義されることが一般的です。その場合、そのクラスのコンストラクタで、`self.init_scope()`で作られる`with`コンテキストを作り、その中でネットワークに登場する`Link`をプロパティとして登録しておきます。こうすると、自動的に`Optimizer`が最適化対象のパラメータを持つ層だな、と捉えてくれます。\n",
    "\n",
    "もう一つ、一般的なのは、ネットワークの前進計算（データを渡して、出力を返す）を、`__call__`メソッドに書いておくという方法です。こうすると、ネットワーククラスをinstantiateして作ったオブジェクトを、関数のようにして使うことができます（例：`output = net(data)`）。\n",
    "\n",
    "### GPUで実行するには\n",
    "\n",
    "`Chain`クラスは`to_gpu`メソッドを持ち、この引数にGPU IDを指定すると、指定したGPU IDのメモリ上にネットワークの全パラメータを転送します。こうしておくと、前進計算も学習の際のパラメータ更新なども全部GPU上で行われるようになります。GPU IDとして-1を使うと、すなわちこれはCPUを意味します。\n",
    "\n",
    "### 同じ結果を保証したい\n",
    "\n",
    "ネットワークを書き始める前に、まずは乱数シードを固定して、本記事とほぼ同様の結果が再現できるようにしておきましょう。（cuDNNが有効になっている環境下でより厳密に計算結果の再現性を保証したい場合は、`chainer.config.cudnn_deterministic`というConfiguringオプションについて知る必要があります。こちらのドキュメントを参照してください：[chainer.config.cudnn_deterministic](https://docs.chainer.org/en/stable/reference/configuration.html?highlight=chainer.config.cudnn_deterministic)。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import numpy\n",
    "import chainer\n",
    "\n",
    "def reset_seed(seed=0):\n",
    "    random.seed(seed)\n",
    "    numpy.random.seed(seed)\n",
    "    if chainer.cuda.available:\n",
    "        chainer.cuda.cupy.random.seed(seed)\n",
    "        \n",
    "reset_seed(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ネットワークを表すコード\n",
    "\n",
    "いよいよネットワークを書いてみます！"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "import chainer\n",
    "import chainer.links as L\n",
    "import chainer.functions as F\n",
    "\n",
    "class MLP(chainer.Chain):\n",
    "\n",
    "    def __init__(self, n_mid_units=100, n_out=10):\n",
    "        super(MLP, self).__init__()\n",
    "        \n",
    "        # パラメータを持つ層の登録\n",
    "        with self.init_scope():\n",
    "            self.l1 = L.Linear(None, n_mid_units)\n",
    "            self.l2 = L.Linear(n_mid_units, n_mid_units)\n",
    "            self.l3 = L.Linear(n_mid_units, n_out)\n",
    "\n",
    "    def __call__(self, x):\n",
    "        # データを受け取った際のforward計算を書く\n",
    "        h1 = F.relu(self.l1(x))\n",
    "        h2 = F.relu(self.l2(h1))\n",
    "        return self.l3(h2)\n",
    "\n",
    "gpu_id = 0  # CPUを用いる場合は、この値を-1にしてください\n",
    "\n",
    "net = MLP()\n",
    "\n",
    "if gpu_id >= 0:\n",
    "    net.to_gpu(gpu_id)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "できました！疑問点はありませんか？ちなみに、Chainerにはたくさんの学習可能なレイヤやパラメータを持たないレイヤが用意されています。ぜひ一度以下の一覧のページを見てみましょう。\n",
    "\n",
    "- [Chainerで使える関数(`Function`)一覧](https://docs.chainer.org/en/stable/reference/functions.html)\n",
    "- [Chainerで学習できるレイヤ(`Link`)一覧](https://docs.chainer.org/en/stable/reference/links.html)\n",
    "\n",
    "`Link`一覧には、ニューラルネットワークによく用いられる全結合層や畳み込み層、LSTMなどや、ReLUなどの活性化関数などなどだけでなく、有名なネットワーク全体も`Link`として載っています。ResNetや、VGGなどです。また、`Function`一覧には、画像の大きさをresizeしたり、サイン・コサインのような関数を始め、いろいろなネットワークの要素として使える関数が載っています。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### NOTE\n",
    "\n",
    "上のネットワーク定義で、`L.Linear`は全結合層を意味しますが、最初のLinear層は第一引数に`None`が渡されています。これは、実行時に、つまり**データがその層に入力された瞬間、必要な数の入力側ユニット数を自動的に計算する**ということを意味します。ネットワークが最初に計算を行う際に、初めて `(n_input)` $\\times$ `n_mid_units` の大きさの行列を作成し、それを学習対象とするパラメータとして保持します。これは後々、畳み込み層を全結合層の前に配置する際などに便利な機能です。\n",
    "\n",
    "様々な`Link`は、それぞれ学習対象となるパラメータを保持しています。それらの値は、NumPyの配列として簡単に取り出して見ることができます。例えば、上のモデル`MLP`は`l1`という名前の全結合層が登録されています。この全結合層は重み行列`W`とバイアス`b`という2つのパラメータを持ちます。これらには外から以下のようにしてアクセスすることができます："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1つ目の全結合相のバイアスパラメータの形は、 (100,)\n",
      "初期化直後のその値は、 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n",
      " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n",
      " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n",
      " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n",
      " 0. 0. 0. 0.]\n"
     ]
    }
   ],
   "source": [
    "print('1つ目の全結合相のバイアスパラメータの形は、', net.l1.b.shape)\n",
    "print('初期化直後のその値は、', net.l1.b.array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "しかしここで、`net.l1.W.array`の中身を同様に表示してみようとすると、`None`が返されます。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "print(net.l1.W.array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "なぜでしょうか？我々は`l1`をネットワークに登録するときに、`L.Linear`の第一引数に`None`を渡しましたね。そして、**まだネットワークに一度もデータを入力していません**。そのため、**まだ重み行列`W`は作成されていません。**そのため、まだ`net.l1.W`は具体的な配列を保持していないのです。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. 最適化手法の選択\n",
    "\n",
    "では、上で定義したネットワークをMNISTデータセットを使って訓練してみましょう。学習時に用いる最適化の手法としてはいろいろな種類のものが提案されていますが、Chainerは多くの手法を同一のインターフェースで利用できるよう、`Optimizer`という機能でそれらを提供しています。`chainer.optimizers`モジュール以下に色々なものを見つけることができます。一覧はこちらにあります：\n",
    "\n",
    "- [Chainerで使える最適化手法一覧](https://docs.chainer.org/en/stable/reference/optimizers.html)\n",
    "\n",
    "ここでは最もシンプルな勾配降下法の手法である`optimizers.SGD`を用います。`Optimizer`のオブジェクトには、`setup`メソッドを使ってモデル（`Chain`オブジェクト）を渡します。こうすることで`Optimizer`に、何を最適化すればいいか把握させることができます。\n",
    "\n",
    "他にもいろいろな最適化手法が手軽に試せるので、色々と試してみて結果の変化を見てみてください。例えば、下の`chainer.optimizers.SGD`のうち`SGD`の部分を`MomentumSGD`, `RMSprop`,  `Adam`などに変えるだけで、最適化手法の違いがどのような学習曲線（ロスカーブ）の違いを生むかなどを簡単に調べることができます。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "from chainer import optimizers\n",
    "\n",
    "optimizer = optimizers.SGD(lr=0.01).setup(net)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### NOTE\n",
    "\n",
    "今回はSGDのコンストラクタの`lr`という引数に $0.01$ を与えました。この値は学習率として知られ、モデルをうまく訓練して良いパフォーマンスを発揮させるために調整する必要がある重要な**ハイパーパラメータ**として知られています。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. 学習する\n",
    "\n",
    "いよいよ学習をスタートします！今回は分類問題なので、`softmax_cross_entropy`というロス関数を使って最小化すべきロスの値を計算します。\n",
    "\n",
    "まず、ネットワークにデータを渡して、出てきた出力と、入力データに対応する正解ラベルを、`Function`の一種でありスカラ値を返す**ロス関数**に渡し、ロス（最小化したい値）の計算を行います。ロスは、`chainer.Variable`のオブジェクトになっています。そして、この`Variable`は、**今まで自分にどんな計算が施されたかを辿れるようになっています。**この仕組みが、Define-by-Run [[Tokui 2015]](http://learningsys.org/papers/LearningSys_2015_paper_33.pdf)とよばれる発明の中心的な役割を果たしています。\n",
    "\n",
    "ここでは誤差逆伝播法自体の説明は割愛しますが、**計算したロスに対する勾配をネットワークに逆向きに流していく**処理は、Chainerではネットワークが吐き出した`Variable`が持つ`backward()`メソッドを呼ぶだけでできます。これを呼ぶと、前述のようにこれまでの計算過程を逆向きに遡って**誤差逆伝播用の計算グラフを構築し**、途中のパラメータの勾配を連鎖率を使って計算してくれます。（詳しくは筆者が[日本ソフトウェア科学会で行ったチュートリアルの資料](https://www.slideshare.net/mitmul/chainer-79942361)をご覧ください。）\n",
    "\n",
    "こうして計算された各パラメータに対する勾配を使って、先程`Optimizer`を作成する際に指定したアルゴリズムを使ってネットワークパラメータの更新（＝学習）が行われるわけです。\n",
    "\n",
    "まとめると、今回1回の更新処理の中で行うのは、以下の4項目です。\n",
    "\n",
    "1. ネットワークにデータを渡して出力`y`を得る\n",
    "2. 出力`y`と正解ラベル`t`を使って、最小化すべきロスの値を`softmax_cross_entropy`関数で計算する\n",
    "3. `softmax_cross_entropy`関数の出力（`Variable`）の`backward()`メソッドを呼んで、ネットワークの全てのパラメータの勾配を誤差逆伝播法で計算する\n",
    "4. Optimizerの`update`メソッドを呼び、3.で計算した勾配を使って全パラメータを更新する\n",
    "\n",
    "パラメータの更新は、何度も何度も繰り返し行います。一度の更新に用いられるデータは、ネットワークに入力されたバッチサイズ分だけ束ねられたデータのみです。そのため、データセット全体のデータを使うために、次のミニバッチを入力して再度更新、その次のミニバッチを使ってまた更新、ということを繰り返すわけです。そのため、この過程を学習ループと呼んでいます。\n",
    "\n",
    "#### NOTE: ロス関数\n",
    "\n",
    "ちなみに、ロス関数は、例えば分類問題ではなく簡単な回帰問題を解きたいような場合、`F.softmax_cross_entropy`の代わりに`F.mean_squared_error`などを用いることもできます。他にも、いろいろな問題設定に対応するために様々なロス関数がChainerには用意されています。こちらからその一覧を見ることができます：\n",
    "\n",
    "- [Chainerで使えるロス関数一覧](http://docs.chainer.org/en/stable/reference/functions.html#loss-functions)\n",
    "\n",
    "### 学習ループのコード"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch:01 train_loss:0.9393 val_loss:0.9708 val_accuracy:0.8019\n",
      "epoch:02 train_loss:0.6163 val_loss:0.5335 val_accuracy:0.8650\n",
      "epoch:03 train_loss:0.4596 val_loss:0.4236 val_accuracy:0.8835\n",
      "epoch:04 train_loss:0.5109 val_loss:0.3750 val_accuracy:0.8931\n",
      "epoch:05 train_loss:0.3167 val_loss:0.3449 val_accuracy:0.9017\n",
      "epoch:06 train_loss:0.4418 val_loss:0.3263 val_accuracy:0.9074\n",
      "epoch:07 train_loss:0.2389 val_loss:0.3103 val_accuracy:0.9122\n",
      "epoch:08 train_loss:0.4076 val_loss:0.2977 val_accuracy:0.9149\n",
      "epoch:09 train_loss:0.3687 val_loss:0.2930 val_accuracy:0.9151\n",
      "epoch:10 train_loss:0.3271 val_loss:0.2800 val_accuracy:0.9190\n",
      "test_accuracy:0.9375\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from chainer.dataset import concat_examples\n",
    "from chainer.cuda import to_cpu\n",
    "\n",
    "max_epoch = 10\n",
    "\n",
    "while train_iter.epoch < max_epoch:\n",
    "    \n",
    "    # ---------- 学習の1イテレーション ----------\n",
    "    train_batch = train_iter.next()\n",
    "    x, t = concat_examples(train_batch, gpu_id)\n",
    "    \n",
    "    # 予測値の計算\n",
    "    y = net(x)\n",
    "\n",
    "    # ロスの計算\n",
    "    loss = F.softmax_cross_entropy(y, t)\n",
    "\n",
    "    # 勾配の計算\n",
    "    net.cleargrads()\n",
    "    loss.backward()\n",
    "\n",
    "    # パラメータの更新\n",
    "    optimizer.update()\n",
    "    # --------------- ここまで ----------------\n",
    "\n",
    "    # 1エポック終了ごとにValidationデータに対する予測精度を測って、\n",
    "    # モデルの汎化性能が向上していることをチェックしよう\n",
    "    if train_iter.is_new_epoch:  # 1 epochが終わったら\n",
    "\n",
    "        # ロスの表示\n",
    "        print('epoch:{:02d} train_loss:{:.04f} '.format(\n",
    "            train_iter.epoch, float(to_cpu(loss.data))), end='')\n",
    "\n",
    "        valid_losses = []\n",
    "        valid_accuracies = []\n",
    "        while True:\n",
    "            valid_batch = valid_iter.next()\n",
    "            x_valid, t_valid = concat_examples(valid_batch, gpu_id)\n",
    "\n",
    "            # Validationデータをforward\n",
    "            with chainer.using_config('train', False), \\\n",
    "                    chainer.using_config('enable_backprop', False):\n",
    "                y_valid = net(x_valid)\n",
    "\n",
    "            # ロスを計算\n",
    "            loss_valid = F.softmax_cross_entropy(y_valid, t_valid)\n",
    "            valid_losses.append(to_cpu(loss_valid.array))\n",
    "\n",
    "            # 精度を計算\n",
    "            accuracy = F.accuracy(y_valid, t_valid)\n",
    "            accuracy.to_cpu()\n",
    "            valid_accuracies.append(accuracy.array)\n",
    "                        \n",
    "            if valid_iter.is_new_epoch:\n",
    "                valid_iter.reset()\n",
    "                break\n",
    "\n",
    "        print('val_loss:{:.04f} val_accuracy:{:.04f}'.format(\n",
    "            np.mean(valid_losses), np.mean(valid_accuracies)))\n",
    "        \n",
    "# テストデータでの評価\n",
    "test_accuracies = []\n",
    "while True:\n",
    "    test_batch = test_iter.next()\n",
    "    x_test, t_test = concat_examples(test_batch, gpu_id)\n",
    "\n",
    "    # テストデータをforward\n",
    "    with chainer.using_config('train', False), \\\n",
    "            chainer.using_config('enable_backprop', False):\n",
    "        y_test = net(x_test)\n",
    "\n",
    "    # 精度を計算\n",
    "    accuracy = F.accuracy(y_valid, t_valid)\n",
    "    accuracy.to_cpu()\n",
    "    test_accuracies.append(accuracy.array)\n",
    "\n",
    "    if test_iter.is_new_epoch:\n",
    "        test_iter.reset()\n",
    "        break\n",
    "\n",
    "print('test_accuracy:{:.04f}'.format(np.mean(test_accuracies)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`val_accuracy`に着目してみると、最終的におおよそ92%程度の精度で手書きの数字が分類できるようになりました。**学習終了後**に、ループの中でValidationデータセットを使ってモデルの汎化性能をおおまかにチェックしているのと同様にして、**テスト用のデータセットを用いて学習が終了したネットワークの評価を行っています。**テストデータでの評価結果は、およそ93.75%の正解率となりました。\n",
    "\n",
    "### 5.1 ValidationやTestを行う際の注意点\n",
    "\n",
    "ここで、ValidationにせよTestにせよ、「評価」を行う際には注意すべき点があります。学習は行わない、評価のためだけのデータをネットワークに渡して出力を計算している部分（例えば、`y_test = net(x_test)`）では、それらの行を2つのコンテキストでくくっています。\n",
    "\n",
    "#### `chainer.using_config('train', False)`\n",
    "\n",
    "まず、今回は学習時と推論時で動作が異なる関数は含まれていないため、実際の効力は持ちませんが、Validationやテストのために推論を行うときは`chainer.config.train = False`とします。以下のように、`chainer.using_config('train', False)`をwith構文と共に使えば、その中では`chainer.config.train = False`となります。\n",
    "\n",
    "```python\n",
    "with chainer.using_config('train', False):\n",
    "    --- 何か推論処理 ---\n",
    "```\n",
    "\n",
    "これは、以下のようにするのと同じことです。\n",
    "\n",
    "```python\n",
    "chainer.config.train = False\n",
    "\n",
    "--- 何か推論処理 ---\n",
    "```\n",
    "\n",
    "ただし、Pythonのコンテキストを利用しない場合は、一度このようにどこかで書くと、それ以降この設定はグローバルにずっと有効になることに注意してください。（推論したあと再び学習を行うという場合は、再度`chainer.config.train = True`などのようにすることが必要になります。`chainer.config`以下の規定の値に何かを代入することはグローバルに作用しますので、次に説明する`enable_backprop`についても同様です。）\n",
    "\n",
    "#### `chainer.using_config('enable_backprop', False)`\n",
    "\n",
    "次に、今回は評価に用いる出力の計算後にロス関数の各パラメータについての勾配は必要ないので、内部に計算グラフを保持しておく必要もないため、`chainer.using_config('enable_backprop', False)`として**無駄な計算グラフの構築を行わないようにし、メモリ消費量を節約しています。**\n",
    "\n",
    "#### NOTE: ChainerのConfig\n",
    "\n",
    "Chainerにはこの他にも、いくつかのグローバルなConfigがプリセットとして用意されています。また、`chainer.config`以下にユーザが自由な設定値を置くこともできます。詳しくはこちらを一読してください：[Configuring Chainer](https://docs.chainer.org/en/stable/reference/configuration.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. 学習済みモデルを保存する\n",
    "\n",
    "学習が終わったら、その結果を保存します。Chainerには、2種類のフォーマットで学習済みネットワークをシリアライズする機能が用意されています。一つはHDF5形式で、もう一つはNumPyのNPZ形式でネットワークを保存するものです。今回は、追加ライブラリのインストールが必要なHDF5ではなく、NumPy標準機能で提供されているシリアライズ機能（`numpy.savez()`）を利用したNPZ形式でのモデルの保存を行います。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "from chainer import serializers\n",
    "\n",
    "serializers.save_npz('my_mnist.model', net)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-rw-rw-r-- 1 shunta shunta 333944 Apr 22 00:52 my_mnist.model\r\n"
     ]
    }
   ],
   "source": [
    "# ちゃんと保存されていることを確認\n",
    "%ls -la my_mnist.model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7. 保存したモデルを読み込んで推論する\n",
    "\n",
    "学習したネットワークを、それを使って数字の分類がしたい誰かに渡して、使ってもらうにはどうしたら良いでしょうか。もっともシンプルな方法は、ネットワークの定義がかかれたPythonファイルと、今しがた保存したNPZファイルを渡して、以下のように使うことです。以下のコードの前に、渡したネットワーク定義のファイルからネットワークのクラス（ここでは`MLP`）が読み込まれていることを前提とします。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# まず同じネットワークのオブジェクトを作る\n",
    "infer_net = MLP()\n",
    "\n",
    "# そのオブジェクトに保存済みパラメータをロードする\n",
    "serializers.load_npz('my_mnist.model', infer_net)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以上で準備が整いました。それでは、試しにテストデータの中から一つ目の画像を取ってきて、それに対する分類を行ってみましょう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x2b06ecc759e8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "元の形： (784,) -> ミニバッチの形にしたあと： (1, 784)\n",
      "ネットワークの予測: 7\n"
     ]
    }
   ],
   "source": [
    "gpu_id = 0  # CPUで計算をしたい場合は、-1を指定してください\n",
    "\n",
    "if gpu_id >= 0:\n",
    "    infer_net.to_gpu(gpu_id)\n",
    "\n",
    "# 1つ目のテストデータを取り出します\n",
    "x, t = test[0]  #  tは使わない\n",
    "\n",
    "# どんな画像か表示してみます\n",
    "plt.imshow(x.reshape(28, 28), cmap='gray')\n",
    "plt.show()\n",
    "\n",
    "# ミニバッチの形にする（複数の画像をまとめて推論に使いたい場合は、サイズnのミニバッチにしてまとめればよい）\n",
    "print('元の形：', x.shape, end=' -> ')\n",
    "\n",
    "x = x[None, ...]\n",
    "\n",
    "print('ミニバッチの形にしたあと：', x.shape)\n",
    "\n",
    "# ネットワークと同じデバイス上にデータを送る\n",
    "x = infer_net.xp.asarray(x)\n",
    "\n",
    "# モデルのforward関数に渡す\n",
    "with chainer.using_config('train', False), chainer.using_config('enable_backprop', False):\n",
    "    y = infer_net(x)\n",
    "\n",
    "# Variable形式で出てくるので中身を取り出す\n",
    "y = y.array\n",
    "\n",
    "# 結果をCPUに送る\n",
    "y = to_cpu(y)\n",
    "\n",
    "# 予測確率の最大値のインデックスを見る\n",
    "pred_label = y.argmax(axis=1)\n",
    "\n",
    "print('ネットワークの予測:', pred_label[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ネットワークの予測は7でした。画像を見る限り、当たっていそうですね！"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Trainerを使ってみよう\n",
    "\n",
    "Chainerは、これまで書いてきたような学習ループを隠蔽する`Trainer`という機能を提供しています。これを使うと、学習ループを陽に書く必要がなくなり、またいろいろな便利なExtentionを使うことで、学習過程でのロスカーブの可視化や、ログの保存などが楽になります。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. データセット・Iterator・ネットワークの準備\n",
    "\n",
    "これらはループを自分で書く場合と同じなので、まとめてしまいます。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "reset_seed(0)\n",
    "\n",
    "train_val, test = mnist.get_mnist()\n",
    "train, valid = split_dataset_random(train_val, 50000, seed=0)\n",
    "\n",
    "batchsize = 128\n",
    "\n",
    "train_iter = iterators.SerialIterator(train, batchsize)\n",
    "valid_iter = iterators.SerialIterator(valid, batchsize, False, False)\n",
    "test_iter = iterators.SerialIterator(test, batchsize, False, False)\n",
    "\n",
    "gpu_id = 0  # CPUを用いたい場合は、-1を指定してください\n",
    "\n",
    "net = MLP()\n",
    "\n",
    "if gpu_id >= 0:\n",
    "    net.to_gpu(gpu_id)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Updaterの準備\n",
    "\n",
    "ここからが学習ループを自分で書く場合と異なる部分です。ループを自分で書く場合には、データセットからバッチサイズ分のデータをとってきてミニバッチに束ねて、それをネットワークに入力して予測を作り、それを正解と比較し、ロスを計算してバックワード（誤差逆伝播）をして、`Optimizer`によってパラメータを更新する、というところまでを、以下のように書いていました。\n",
    "\n",
    "```python\n",
    "# ---------- 学習の1イテレーション ----------\n",
    "train_batch = train_iter.next()\n",
    "x, t = concat_examples(train_batch, gpu_id)\n",
    "\n",
    "# 予測値の計算\n",
    "y = net(x)\n",
    "\n",
    "# ロスの計算\n",
    "loss = F.softmax_cross_entropy(y, t)\n",
    "\n",
    "# 勾配の計算\n",
    "net.cleargrads()\n",
    "loss.backward()\n",
    "\n",
    "# パラメータの更新\n",
    "optimizer.update()\n",
    "```\n",
    "\n",
    "これらの処理を、まるっと`Updater`はまとめてくれます。これを行うために、**`Updater`には`Iterator`と`Optimizer`を渡してやります。** `Iterator`はデータセットオブジェクトを持っていて、そこからミニバッチを作り、`Optimizer`は最適化対象のネットワークを持っていて、それを使って前進計算とロスの計算・パラメータのアップデートをすることができます。そのため、この2つを渡しておけば、上記の処理を`Updater`内で全部行ってもらえるというわけです。では、`Updater`オブジェクトを作成してみましょう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "from chainer import training\n",
    "\n",
    "gpu_id = 0  # CPUを使いたい場合は-1を指定してください\n",
    "\n",
    "# ネットワークをClassifierで包んで、ロスの計算などをモデルに含める\n",
    "net = L.Classifier(net)\n",
    "\n",
    "# 最適化手法の選択\n",
    "optimizer = optimizers.SGD(lr=0.01).setup(net)\n",
    "\n",
    "# UpdaterにIteratorとOptimizerを渡す\n",
    "updater = training.StandardUpdater(train_iter, optimizer, device=gpu_id)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### NOTE\n",
    "\n",
    "ここでは、ネットワークを`L.Classifier`で包んでいます。`L.Classifier`は一種の`Chain`になっていて、渡されたネットワーク自体を`predictor`というattributeに持ち、**ロス計算を行う機能を追加してくれます。**こうすると、`net()`はデータ`x`だけでなくラベル`t`も取るようになり、まず渡されたデータを`predictor`に通して予測を作り、それを`t`と比較して**ロスの`Variable`を返すようになります。**ロス関数として何を用いるかはデフォルトでは`F.softmax_cross_entropy`となっていますが、`L.Classifier`の引数`lossfunc`にロス計算を行う関数を渡してやれば変更することができるため、Classifierという名前ながら回帰問題などのロス計算機能の追加にも使うことができます。（`L.Classifier(net, lossfun=L.mean_squared_error, compute_accuracy=False)`のようにする）\n",
    "\n",
    "`StandardUpdater`は前述のような`Updater`の担当する処理を遂行するための最もシンプルなクラスです。この他にも複数のGPUを用いるための`ParallelUpdater`などが用意されています。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Trainerの準備\n",
    "\n",
    "実際に学習ループ部分を隠蔽しているのは`Updater`なので、これがあればもう学習を始められそうですが、`Trainer`はさらに`Updater`を受け取って学習全体の管理を行う機能を提供しています。例えば、**データセットを何周したら学習を終了するか(stop_trigger)** や、**途中のロスの値をどのファイルに保存したいか**、**ロスカーブを可視化した画像ファイルを保存するかどうか**など、学習全体の設定として必須・もしくはあると便利な色々な機能を提供しています。\n",
    "\n",
    "必須なものとしては学習終了のタイミングを指定する`stop_trigger`がありますが、これは`Trainer`オブジェクトを作成するときのコンストラクタで指定します。指定の方法は単純で、`(長さ, 単位)`という形のタプルを与えればよいだけです。「長さ」には数字を、「単位」には`'iteration'`もしくは`'epoch'`のいずれかの文字列を指定します。こうすると、たとえば100 epoch（データセット100周）で学習を終了してください、とか、1000 iteration（1000回更新）で学習を終了してください、といったことが指定できます。`Trainer`を作るときに、`stop_trigger`を指定しないと、学習は自動的には止まりません。\n",
    "\n",
    "では、実際に`Trainer`オブジェクトを作ってみましょう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "max_epoch = 10\n",
    "\n",
    "# TrainerにUpdaterを渡す\n",
    "trainer = training.Trainer(\n",
    "    updater, (max_epoch, 'epoch'), out='mnist_result')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`out`引数では、この次に説明する`Extension`を使って、ログファイルやロスの変化の過程を描画したグラフの画像ファイルなどを保存するディレクトリを指定しています。\n",
    "\n",
    "Trainerと、その内側にあるいろいろなオブジェクトの関係は、図にまとめると以下のようになっています。このイメージを持っておくと自分で部分的に改造したりする際に便利だと思います。\n",
    "\n",
    "![image](https://qiita-image-store.s3.amazonaws.com/0/17934/a751df31-b999-f692-d839-488c26b1c48a.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. TrainerにExtensionを追加する\n",
    "\n",
    "`Trainer`を使う利点として、\n",
    "\n",
    "- ログを自動的にファイルに保存（`LogReport`)\n",
    "- ターミナルに定期的にロスなどの情報を表示（`PrintReport`）\n",
    "- ロスを定期的にグラフで可視化して画像として保存（`PlotReport`)\n",
    "- 定期的にモデルやOptimizerの状態を自動シリアライズ（`snapshot`）\n",
    "- 学習の進捗を示すプログレスバーを表示（`ProgressBar`）\n",
    "- ネットワークの構造をGraphvizのdot形式で保存（`dump_graph`）\n",
    "- ネットワークのパラメータの平均や分散などの統計情報を出力（`ParameterStatistics`）\n",
    "\n",
    "などなどの様々な便利な機能を簡単に利用することができる点があります。これらの機能を利用するには、`Trainer`オブジェクトに対して`extend`メソッドを使って追加したい`Extension`のオブジェクトを渡してやるだけです。では実際に幾つかの`Extension`を追加してみましょう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "from chainer.training import extensions\n",
    "\n",
    "trainer.extend(extensions.LogReport())\n",
    "trainer.extend(extensions.snapshot(filename='snapshot_epoch-{.updater.epoch}'))\n",
    "trainer.extend(extensions.Evaluator(valid_iter, net, device=gpu_id), name='val')\n",
    "trainer.extend(extensions.PrintReport(['epoch', 'main/loss', 'main/accuracy', 'val/main/loss', 'val/main/accuracy', 'l1/W/data/std', 'elapsed_time']))\n",
    "trainer.extend(extensions.ParameterStatistics(net.predictor.l1, {'std': np.std}))\n",
    "trainer.extend(extensions.PlotReport(['l1/W/data/std'], x_key='epoch', file_name='std.png'))\n",
    "trainer.extend(extensions.PlotReport(['main/loss', 'val/main/loss'], x_key='epoch', file_name='loss.png'))\n",
    "trainer.extend(extensions.PlotReport(['main/accuracy', 'val/main/accuracy'], x_key='epoch', file_name='accuracy.png'))\n",
    "trainer.extend(extensions.dump_graph('main/loss'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `LogReport`\n",
    "\n",
    "`epoch`や`iteration`ごとの`loss`, `accuracy`などを自動的に集計し、`Trainer`の`out`引数で指定した出力ディレクトリに`log`というファイル名で保存します。\n",
    "\n",
    "### `snapshot`\n",
    "\n",
    "`Trainer`の`out`引数で指定した出力ディレクトリに`Trainer`オブジェクトを指定されたタイミング（デフォルトでは1エポックごと）に保存します。`Trainer`オブジェクトは上述のように`Updater`を持っており、この中に`Optimizer`とモデルが保持されているため、この`Extension`でスナップショットをとっておけば、学習の復帰や学習済みモデルを使った推論などが学習終了後にも可能になります。\n",
    "\n",
    "### `dump_graph`\n",
    "\n",
    "指定された`Variable`オブジェクトから辿れる計算グラフをGraphvizのdot形式で保存します。保存先は`Trainer`の`out`引数で指定した出力ディレクトリです。\n",
    "\n",
    "### `Evaluator`\n",
    "\n",
    "評価用のデータセットの`Iterator`と、学習に使うモデルのオブジェクトを渡しておくことで、学習中のモデルを指定されたタイミングで評価用データセットを用いて評価します。内部では、`chainer.config.using_config('train', False)`が自動的に行われます。`backprop_enable`を`False`にすることは行われないため、メモリ使用効率はデフォルトでは最適ではありませんが、基本的には`Evaluator`を使えば評価を行うという点において問題はありません。\n",
    "\n",
    "### `PrintReport`\n",
    "\n",
    "`Reporter`によって集計された値を標準出力に出力します。このときどの値を出力するかを、リストの形で与えます。\n",
    "\n",
    "### `PlotReport`\n",
    "\n",
    "引数のリストで指定された値の変遷を`matplotlib`ライブラリを使ってグラフに描画し、出力ディレクトリに`file_name`引数で指定されたファイル名で画像として保存します。\n",
    "\n",
    "### `ParameterStatistics`\n",
    "\n",
    "指定したレイヤ（Link）が持つパラメータの平均・分散・最小値・最大値などなどの統計情報を計算して、ログに保存します。パラメータが発散していないかなどをチェックするのに便利です。\n",
    "\n",
    "---\n",
    "\n",
    "これらの`Extension`は、ここで紹介した以外にも、例えば`trigger`によって個別に作動するタイミングを指定できるなどのいくつかのオプションを持っており、より柔軟に組み合わせることができます。詳しくは公式のドキュメントを見てください\n",
    "\n",
    "- [ChainerのTrainer extension一覧](http://docs.chainer.org/en/stable/reference/extensions.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. 学習を開始する\n",
    "\n",
    "学習を開始するには、`Trainer`オブジェクトのメソッド`run`を呼ぶだけです！"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch       main/loss   main/accuracy  val/main/loss  val/main/accuracy  l1/W/data/std  elapsed_time\n",
      "\u001b[J1           1.6691      0.599884       0.93909        0.805182           0.0359232      2.04951       \n",
      "\u001b[J2           0.672972    0.843211       0.518216       0.866891           0.0366046      4.94805       \n",
      "\u001b[J3           0.459943    0.878826       0.415205       0.88657            0.0370376      7.98442       \n",
      "\u001b[J4           0.389622    0.893163       0.368696       0.896756           0.0372996      10.9229       \n",
      "\u001b[J5           0.353016    0.900895       0.341141       0.904173           0.0374883      13.7746       \n",
      "\u001b[J6           0.329993    0.907171       0.324052       0.907733           0.0376418      16.5909       \n",
      "\u001b[J7           0.31232     0.911065       0.307601       0.912876           0.037766       20.3998       \n",
      "\u001b[J8           0.298098    0.914383       0.294673       0.917128           0.0378814      24.4631       \n",
      "\u001b[J9           0.28597     0.918059       0.283434       0.918414           0.0379859      27.2953       \n",
      "\u001b[J10          0.275202    0.920836       0.273564       0.921479           0.038085       30.1442       \n"
     ]
    }
   ],
   "source": [
    "trainer.run()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "初めに取り組んだ学習ループを自分で書いた場合よりもより短いコードで、リッチなログ情報とともに、下記で表示してみるようなグラフなども作りつつ、同様の結果を得ることができました。1層目の全結合層の重み行列の値の標準偏差が、学習の進行とともに徐々に大きくなっていっているのも見て取れて、面白いですね。\n",
    "\n",
    "では、保存されているロスのグラフを確認してみましょう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import Image\n",
    "Image(filename='mnist_result/loss.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "精度のグラフも見てみましょう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Image(filename='mnist_result/accuracy.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "もう少し学習を続ければ、まだ多少精度の向上が図れそうな雰囲気がありますね。\n",
    "\n",
    "ついでに、`dump_graph`という`Extension`が出力した計算グラフを、`Graphviz`を使って画像化して見てみましょう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%bash\n",
    "dot -Tpng mnist_result/cg.dot -o mnist_result/cg.png"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Image(filename='mnist_result/cg.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上から下へ向かって、データやパラメータがどのような`Function`に渡されて計算が行われ、ロスを表す`Variable`が出力されたかが分かります。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. テストデータで評価する\n",
    "\n",
    "上でもValidationデータに対しての評価を学習中に行うために使用されているTrainer Extensionの一つであるEvaluatorは、Trainerと関係なく独立して使うこともできます。以下のようにして`Iterator`とネットワークのオブジェクト（`net`）、使用するデバイスIDを渡してEvaluatorオブジェクトを作成し、これを関数として実行するだけです。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test accuracy: 0.9257318\n"
     ]
    }
   ],
   "source": [
    "test_evaluator = extensions.Evaluator(test_iter, net, device=gpu_id)\n",
    "results = test_evaluator()\n",
    "print('Test accuracy:', results['main/accuracy'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7. 学習済みモデルで推論する\n",
    "\n",
    "それでは、Trainer Extensionのsnapshotが自動的に保存したネットワークのスナップショットから学習済みパラメータを読み込んで、学習ループを書いて学習したときと同様に1番目のテストデータで推論を行ってみましょう。\n",
    "\n",
    "ここで注意すべきは、snapshotが保存するnpzファイルはTrainer全体のスナップショットであるため、extensionの内部のパラメータなども一緒に保存されています。これは、学習自体を再開するために必要だからです。しかし、今回はネットワークのパラメータだけを読み込めば良いので、`serializers.load_npz()`のpath引数にネットワーク部分までのパス（`updater/model:main/predictor/`）を指定しています。こうすることで、ネットワークのオブジェクトにパラメータだけを読み込むことができます。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x2b06ddab7160>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "予測ラベル: 7\n"
     ]
    }
   ],
   "source": [
    "reset_seed(0)\n",
    "\n",
    "infer_net = MLP()\n",
    "serializers.load_npz(\n",
    "    'mnist_result/snapshot_epoch-10',\n",
    "    infer_net, path='updater/model:main/predictor/')\n",
    "\n",
    "if gpu_id >= 0:\n",
    "    infer_net.to_gpu(gpu_id)\n",
    "\n",
    "x, t = test[0]\n",
    "plt.imshow(x.reshape(28, 28), cmap='gray')\n",
    "plt.show()\n",
    "\n",
    "x = infer_net.xp.asarray(x[None, ...])\n",
    "with chainer.using_config('train', False), chainer.using_config('enable_backprop', False):\n",
    "    y = infer_net(x)\n",
    "y = to_cpu(y.array)\n",
    "\n",
    "print('予測ラベル:', y.argmax(axis=1)[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "無事正解できていますね。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 新しいネットワークを書いてみよう\n",
    "\n",
    "ここでは、MNISTデータセットではなくCIFAR10という32x32サイズの小さなカラー画像に10クラスのいずれかのラベルがついたデータセットを用いて、いろいろなモデルを自分で書いて試行錯誤する流れを体験してみます。\n",
    "\n",
    "| airplane | automobile | bird | cat | deer | dog | frog | horse | ship | truck |\n",
    "|:--------:|:----------:|:----:|:---:|:----:|:---:|:----:|:-----:|:----:|:-----:|\n",
    "| ![](https://www.cs.toronto.edu/~kriz/cifar-10-sample/airplane4.png) | ![](https://www.cs.toronto.edu/~kriz/cifar-10-sample/automobile4.png) | ![](https://www.cs.toronto.edu/~kriz/cifar-10-sample/bird4.png) | ![](https://www.cs.toronto.edu/~kriz/cifar-10-sample/cat4.png) | ![](https://www.cs.toronto.edu/~kriz/cifar-10-sample/deer4.png) | ![](https://www.cs.toronto.edu/~kriz/cifar-10-sample/dog4.png) | ![](https://www.cs.toronto.edu/~kriz/cifar-10-sample/frog4.png) | ![](https://www.cs.toronto.edu/~kriz/cifar-10-sample/horse4.png) | ![](https://www.cs.toronto.edu/~kriz/cifar-10-sample/ship4.png) | ![](https://www.cs.toronto.edu/~kriz/cifar-10-sample/truck4.png) |\n",
    "\n",
    "## 1. ネットワークの定義\n",
    "\n",
    "ここでは、さきほど試した全結合層だけからなるネットワークではなく、畳込み層を持つネットワークを定義してみます。3つの畳み込み層を持ち、2つの全結合層がそのあとに続いています。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyNet(chainer.Chain):\n",
    "    \n",
    "    def __init__(self, n_out):\n",
    "        super(MyNet, self).__init__()\n",
    "        with self.init_scope():\n",
    "            self.conv1 = L.Convolution2D(None, 32, 3, 3, 1)\n",
    "            self.conv2 = L.Convolution2D(32, 64, 3, 3, 1)\n",
    "            self.conv3 = L.Convolution2D(64, 128, 3, 3, 1)\n",
    "            self.fc4 = L.Linear(None, 1000)\n",
    "            self.fc5 = L.Linear(1000, n_out)\n",
    "        \n",
    "    def __call__(self, x):\n",
    "        h = F.relu(self.conv1(x))\n",
    "        h = F.relu(self.conv2(h))\n",
    "        h = F.relu(self.conv3(h))\n",
    "        h = F.relu(self.fc4(h))\n",
    "        h = self.fc5(h)\n",
    "        return h"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. 学習\n",
    "\n",
    "ここで、あとから別のネットワークも簡単に同じ設定で訓練できるよう、`train`関数を作っておきます。これは、\n",
    "\n",
    "- ネットワークのオブジェクト\n",
    "- バッチサイズ\n",
    "- 使用するGPU ID\n",
    "- 学習を終了するエポック数\n",
    "- データセットオブジェクト\n",
    "- 学習率の初期値\n",
    "- 学習率減衰のタイミング\n",
    "\n",
    "などを渡すと、内部で`Trainer`を用いて渡されたデータセットを使ってネットワークを訓練し、学習が終了した状態のネットワークを返してくれる関数です。`Trainer.run()`が終了した後に、テストデータセットを使って評価まで行ってくれます。先程のMNISTでの例と違い、最適化手法にはMomentumSGDを用い、ExponentialShiftというExtentionを使って、指定したタイミングごとに学習率を減衰させるようにしてみます。\n",
    "\n",
    "また、ここでは`cifar.get_cifar10()`が返す学習用データセットのうち9割のデータを`train`、残りの1割を`valid`として使うようにしています。\n",
    "\n",
    "この`train`関数を用いて、上で定義した`MyModel`モデルを訓練してみます。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "from chainer.datasets import cifar\n",
    "\n",
    "\n",
    "def train(network_object, batchsize=128, gpu_id=0, max_epoch=20, train_dataset=None, valid_dataset=None, test_dataset=None, postfix='', base_lr=0.01, lr_decay=None):\n",
    "\n",
    "    # 1. Dataset\n",
    "    if train_dataset is None and valid_dataset is None and test_dataset is None:\n",
    "        train_val, test = cifar.get_cifar10()\n",
    "        train_size = int(len(train_val) * 0.9)\n",
    "        train, valid = split_dataset_random(train_val, train_size, seed=0)\n",
    "    else:\n",
    "        train, valid, test = train_dataset, valid_dataset, test_dataset\n",
    "\n",
    "    # 2. Iterator\n",
    "    train_iter = iterators.MultiprocessIterator(train, batchsize)\n",
    "    valid_iter = iterators.MultiprocessIterator(valid, batchsize, False, False)\n",
    "\n",
    "    # 3. Model\n",
    "    net = L.Classifier(network_object)\n",
    "\n",
    "    # 4. Optimizer\n",
    "    optimizer = optimizers.MomentumSGD(lr=base_lr).setup(net)\n",
    "    optimizer.add_hook(chainer.optimizer.WeightDecay(0.0005))\n",
    "\n",
    "    # 5. Updater\n",
    "    updater = training.StandardUpdater(train_iter, optimizer, device=gpu_id)\n",
    "\n",
    "    # 6. Trainer\n",
    "    trainer = training.Trainer(updater, (max_epoch, 'epoch'), out='{}_cifar10_{}result'.format(network_object.__class__.__name__, postfix))\n",
    "    \n",
    "    # 7. Trainer extensions\n",
    "    trainer.extend(extensions.LogReport())\n",
    "    trainer.extend(extensions.observe_lr())\n",
    "    trainer.extend(extensions.Evaluator(valid_iter, net, device=gpu_id), name='val')\n",
    "    trainer.extend(extensions.PrintReport(['epoch', 'main/loss', 'main/accuracy', 'val/main/loss', 'val/main/accuracy', 'elapsed_time', 'lr']))\n",
    "    trainer.extend(extensions.PlotReport(['main/loss', 'val/main/loss'], x_key='epoch', file_name='loss.png'))\n",
    "    trainer.extend(extensions.PlotReport(['main/accuracy', 'val/main/accuracy'], x_key='epoch', file_name='accuracy.png'))\n",
    "    if lr_decay is not None:\n",
    "        trainer.extend(extensions.ExponentialShift('lr', 0.1), trigger=lr_decay)\n",
    "    trainer.run()\n",
    "    del trainer\n",
    "    \n",
    "    # 8. Evaluation\n",
    "    test_iter = iterators.MultiprocessIterator(test, batchsize, False, False)\n",
    "    test_evaluator = extensions.Evaluator(test_iter, net, device=gpu_id)\n",
    "    results = test_evaluator()\n",
    "    print('Test accuracy:', results['main/accuracy'])\n",
    "    \n",
    "    return net"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch       main/loss   main/accuracy  val/main/loss  val/main/accuracy  elapsed_time  lr        \n",
      "\u001b[J1           1.92566     0.304976       1.72248        0.388672           9.64744       0.01        \n",
      "\u001b[J2           1.60993     0.423584       1.52611        0.470703           17.999        0.01        \n",
      "\u001b[J3           1.46872     0.474114       1.43699        0.495898           26.0586       0.01        \n",
      "\u001b[J4           1.39049     0.502264       1.40534        0.49707            33.2387       0.01        \n",
      "\u001b[J5           1.33        0.524261       1.35359        0.515039           41.7211       0.01        \n",
      "\u001b[J6           1.26348     0.547718       1.30809        0.533594           50.5788       0.01        \n",
      "\u001b[J7           1.2179      0.566618       1.30321        0.541211           59.2517       0.01        \n",
      "\u001b[J8           1.16269     0.587447       1.23584        0.566406           69.3356       0.01        \n",
      "\u001b[J9           1.11824     0.603738       1.22467        0.564258           78.8699       0.01        \n",
      "\u001b[J10          1.07353     0.62017        1.20699        0.572852           89.5009       0.01        \n",
      "\u001b[J11          1.02482     0.636586       1.19412        0.577734           97.487        0.01        \n",
      "\u001b[J12          0.984335    0.652355       1.17003        0.591406           108.51        0.01        \n",
      "\u001b[J13          0.942885    0.666171       1.14992        0.595898           117.591       0.01        \n",
      "\u001b[J14          0.9011      0.681646       1.15492        0.598828           126.562       0.01        \n",
      "\u001b[J15          0.853943    0.698531       1.20026        0.5875             135.419       0.01        \n",
      "\u001b[J16          0.812528    0.713319       1.18745        0.597656           145.828       0.01        \n",
      "\u001b[J17          0.765726    0.73149        1.20555        0.594922           154.648       0.01        \n",
      "\u001b[J18          0.727469    0.74343        1.18027        0.603125           165.423       0.01        \n",
      "\u001b[J19          0.672888    0.764423       1.23294        0.596484           176.338       0.01        \n",
      "\u001b[J20          0.633698    0.776855       1.21022        0.598633           186.021       0.01        \n",
      "Test accuracy: 0.605716\n"
     ]
    }
   ],
   "source": [
    "net = train(MyNet(10), gpu_id=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "学習が20エポックまで終わりました。ロスと精度のプロットを見てみましょう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Image(filename='MyNet_cifar10_result/loss.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Image(filename='MyNet_cifar10_result/accuracy.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "学習データでの精度（`main/accuracy`)は77%程度まで到達していますが、テストデータでのロス（`val/main/loss`）は途中から下げ止まり、精度（`val/main/accuracy`）も60%前後で頭打ちになってしまっています。表示されたログの最後の行を見ると、テストデータでの精度も同様に60%程度だったようです。学習データでは良い精度が出ているが、 テストデータでは精度が良くないということなので、**モデルが学習データにオーバーフィッティングしている**と思われます。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. 学習済みネットワークを使った予測\n",
    "\n",
    "テスト精度は60%程度でしたが、試しにこの学習済みネットワークを使っていくつかのテスト画像を分類させてみましょう。あとで使いまわせるように`predict`関数を作っておきます。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "predicted_label: airplane\n",
      "answer: airplane\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x2b070199b588>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "predicted_label: truck\n",
      "answer: truck\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x2b07112c1dd8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "predicted_label: dog\n",
      "answer: dog\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x2b071146a2b0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "predicted_label: horse\n",
      "answer: horse\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x2b07113f8f60>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "predicted_label: truck\n",
      "answer: truck\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x2b0713e00278>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "cls_names = ['airplane', 'automobile', 'bird', 'cat', 'deer',\n",
    "             'dog', 'frog', 'horse', 'ship', 'truck']\n",
    "\n",
    "def predict(net, image_id):\n",
    "    _, test = cifar.get_cifar10()\n",
    "    x, t = test[image_id]\n",
    "    net.to_cpu()\n",
    "    with chainer.using_config('train', False), chainer.using_config('enable_backprop', False):\n",
    "        y = net.predictor(x[None, ...]).data.argmax(axis=1)[0]\n",
    "    print('predicted_label:', cls_names[y])\n",
    "    print('answer:', cls_names[t])\n",
    "\n",
    "    plt.imshow(x.transpose(1, 2, 0))\n",
    "    plt.show()\n",
    "\n",
    "for i in range(10, 15):\n",
    "    predict(net, i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "うまく分類できているものもあれば、そうでないものもありました。ネットワークの学習に使用したデータセット上ではほぼ百発百中で正解できるとしても、未知のデータ、すなわちテストデータセットにある画像に対して高精度な予測ができなければ、意味がありません[^NN]。テストデータでの精度は、モデルの**汎化性能**に関係していると言われます。\n",
    "\n",
    "どうすれば高い汎化性能を持つネットワークを設計し、学習することができるでしょうか？（そんなことが簡単に分かったら苦労しない。）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. もっと深いネットワークを定義してみよう\n",
    "\n",
    "では、上のネットワークよりもよりたくさんの層を持つネットワークを定義してみましょう。ここでは、1層の畳み込みネットワークを`ConvBlock`、1層の全結合ネットワークを`LinearBlock`として定義し、これをたくさんシーケンシャルに積み重ねる方法で大きなネットワークを定義してみます。\n",
    "\n",
    "### 構成要素を定義する\n",
    "\n",
    "まず、今目指している大きなネットワークの構成要素となる`ConvBlock`と`LinearBlock`を定義してみましょう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ConvBlock(chainer.Chain):\n",
    "    \n",
    "    def __init__(self, n_ch, pool_drop=False):\n",
    "        w = chainer.initializers.HeNormal()\n",
    "        super(ConvBlock, self).__init__()\n",
    "        with self.init_scope():\n",
    "            self.conv = L.Convolution2D(None, n_ch, 3, 1, 1, nobias=True, initialW=w)\n",
    "            self.bn = L.BatchNormalization(n_ch)\n",
    "        self.pool_drop = pool_drop\n",
    "        \n",
    "    def __call__(self, x):\n",
    "        h = F.relu(self.bn(self.conv(x)))\n",
    "        if self.pool_drop:\n",
    "            h = F.max_pooling_2d(h, 2, 2)\n",
    "            h = F.dropout(h, ratio=0.25)\n",
    "        return h\n",
    "    \n",
    "class LinearBlock(chainer.Chain):\n",
    "    \n",
    "    def __init__(self, drop=False):\n",
    "        w = chainer.initializers.HeNormal()\n",
    "        super(LinearBlock, self).__init__()\n",
    "        with self.init_scope():\n",
    "            self.fc = L.Linear(None, 1024, initialW=w)\n",
    "        self.drop = drop\n",
    "        \n",
    "    def __call__(self, x):\n",
    "        h = F.relu(self.fc(x))\n",
    "        if self.drop:\n",
    "            h = F.dropout(h)\n",
    "        return h"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`ConvBlock`は`Chain`を継承した小さなネットワークとして定義されています。これは一つの畳み込み層とBatch Normalization層をパラメータありで持っているので、コンストラクタ内でこれらの登録を行っています。`__call__`メソッドでは、これらにデータを渡しつつ、活性化関数ReLUを適用して、さらに`pool_drop`がコンストラクタに`True`で渡されているときはMax PoolingとDropoutという関数を適用するようになっています。\n",
    "\n",
    "Chainerでは、Pythonを使って書いたforward計算のコード自体がネットワークの構造を表します。すなわち、実行時にデータがどのような層をくぐっていったか、ということがネットワークそのものを定義します。これによって、上記のような分岐などを含むネットワークも簡単に書け、柔軟かつシンプルで可読性の高いネットワーク定義が可能になります。これが**Define-by-Run**と呼ばれる特徴です。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 大きなネットワークの定義\n",
    "\n",
    "次に、これらの小さなネットワークを構成要素として積み重ねて、大きなネットワークを定義してみましょう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DeepCNN(chainer.ChainList):\n",
    "\n",
    "    def __init__(self, n_output):\n",
    "        super(DeepCNN, self).__init__(\n",
    "            ConvBlock(64),\n",
    "            ConvBlock(64, True),\n",
    "            ConvBlock(128),\n",
    "            ConvBlock(128, True),\n",
    "            ConvBlock(256),\n",
    "            ConvBlock(256),\n",
    "            ConvBlock(256),\n",
    "            ConvBlock(256, True),\n",
    "            LinearBlock(),\n",
    "            LinearBlock(),\n",
    "            L.Linear(None, n_output)\n",
    "        )\n",
    "\n",
    "    def __call__(self, x):\n",
    "        for f in self:\n",
    "            x = f(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ここで利用しているのが、`ChainList`というクラスです。このクラスは`Chain`を継承したクラスで、いくつもの`Link`や`Chain`を順次呼び出していくようなネットワークを定義するときに便利です。`ChainList`を継承して定義されるモデルは、親クラスのコンストラクタを呼び出す際に**キーワード引数ではなく普通の引数として**`Link`もしくは`Chain`オブジェクトを渡すことができます。そしてこれらは、`self.children()`メソッドによって**登録した順番に**取り出すことができます。`ChainList`自体もPythonのイテレータとして機能するので、例えば`ChainList`を継承したクラスの中で`for f in self:...`といったことも可能です。\n",
    "\n",
    "この特徴を使うと、forward計算の記述が簡単になります。`self.children()`が返す構成要素のリストから、for文で構成要素を順番に取り出していき、そもそもの入力である`x`に取り出してきた部分ネットワークの計算を適用して、この出力で`x`を置き換えるということを順番に行っていけば、一連の`Link`または`Chain`を、コンストラクタで親クラスに登録した順番と同じ順番で適用していくことができます。そのため、シーケンシャルな部分ネットワークの適用によって表される大きなネットワークを定義するのに重宝します。\n",
    "\n",
    "それでは、学習を回してみます。今回はパラメータ数も多いので、学習を停止するエポック数を100に設定します。また、学習率を0.1から始めて、30エポックごとに10分の1にするように設定してみます。\n",
    "\n",
    "#### TIPS\n",
    "\n",
    "今回は多くの畳込み層を使う大きなネットワークを使うので、Chainerが用意してくれているcuDNNのautotune機能を有効可してみます。やり方は簡単で、以下の二行を事前に実行しておくだけです。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "chainer.cuda.set_max_workspace_size(512 * 1024 * 1024)\n",
    "chainer.config.autotune = True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "それでは、今度こそ学習を開始してみましょう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch       main/loss   main/accuracy  val/main/loss  val/main/accuracy  elapsed_time  lr        \n",
      "\u001b[J1           2.66805     0.163374       2.14499        0.189648           19.3804       0.1         \n",
      "\u001b[J2           2.0508      0.237837       2.03172        0.23125            33.5836       0.1         \n",
      "\u001b[J3           1.90109     0.285345       1.81864        0.307617           48.0566       0.1         \n",
      "\u001b[J4           1.74244     0.34608        2.01173        0.273633           64.1632       0.1         \n",
      "\u001b[J5           1.6333      0.389111       1.629          0.397266           79.1679       0.1         \n",
      "\u001b[J6           1.50544     0.4466         1.61811        0.431445           92.7088       0.1         \n",
      "\u001b[J7           1.35314     0.505876       1.606          0.423242           104.438       0.1         \n",
      "\u001b[J8           1.19823     0.567893       1.19526        0.575195           116.22        0.1         \n",
      "\u001b[J9           1.0728      0.618208       1.31838        0.549023           129.618       0.1         \n",
      "\u001b[J10          0.974313    0.655938       1.00564        0.647266           140.631       0.1         \n",
      "\u001b[J11          0.897739    0.686523       0.845641       0.702734           152.881       0.1         \n",
      "\u001b[J12          0.837259    0.709046       0.964008       0.673437           164.286       0.1         \n",
      "\u001b[J13          0.780534    0.732888       1.1975         0.609375           176.39        0.1         \n",
      "\u001b[J14          0.743671    0.745259       0.736362       0.741602           188.494       0.1         \n",
      "\u001b[J15          0.717165    0.757191       0.739799       0.743555           201.239       0.1         \n",
      "\u001b[J16          0.684576    0.76814        0.796289       0.72207            212.544       0.1         \n",
      "\u001b[J17          0.661639    0.778032       0.83021        0.719922           224.69        0.1         \n",
      "\u001b[J18          0.633936    0.785423       1.17993        0.651758           237.316       0.1         \n",
      "\u001b[J19          0.624017    0.790264       0.981198       0.69043            249.088       0.1         \n",
      "\u001b[J20          0.608494    0.794966       0.837451       0.725781           261.854       0.1         \n",
      "\u001b[J21          0.585992    0.803864       1.01166        0.696484           274.849       0.1         \n",
      "\u001b[J22          0.568304    0.810369       0.861089       0.70625            288.799       0.1         \n",
      "\u001b[J23          0.570798    0.810564       1.01788        0.688281           301.476       0.1         \n",
      "\u001b[J24          0.559657    0.811901       0.841228       0.728711           313.685       0.1         \n",
      "\u001b[J25          0.542451    0.819713       0.851603       0.723047           326.528       0.1         \n",
      "\u001b[J26          0.536695    0.823161       0.793133       0.753516           340.287       0.1         \n",
      "\u001b[J27          0.525463    0.824774       0.821281       0.742383           352.561       0.1         \n",
      "\u001b[J28          0.527928    0.824475       0.629371       0.796094           363.692       0.1         \n",
      "\u001b[J29          0.51218     0.830211       0.64138        0.794922           375.972       0.1         \n",
      "\u001b[J30          0.513306    0.830373       0.648403       0.7875             387.832       0.1         \n",
      "\u001b[J31          0.320646    0.891246       0.394016       0.870898           399.874       0.01        \n",
      "\u001b[J32          0.246237    0.916088       0.3797         0.880469           411.885       0.01        \n",
      "\u001b[J33          0.223746    0.924006       0.382387       0.883008           424.689       0.01        \n",
      "\u001b[J34          0.201898    0.930908       0.378948       0.882422           438.225       0.01        \n",
      "\u001b[J35          0.186824    0.93563        0.370399       0.883594           451.346       0.01        \n",
      "\u001b[J36          0.173529    0.940541       0.375686       0.886328           463.98        0.01        \n",
      "\u001b[J37          0.154772    0.946559       0.413009       0.882812           474.836       0.01        \n",
      "\u001b[J38          0.150695    0.947177       0.399807       0.880078           487.226       0.01        \n",
      "\u001b[J39          0.139391    0.951011       0.417676       0.884766           498.364       0.01        \n",
      "\u001b[J40          0.131167    0.954568       0.405573       0.886719           511.015       0.01        \n",
      "\u001b[J41          0.121253    0.958097       0.423057       0.885156           523.911       0.01        \n",
      "\u001b[J42          0.120638    0.957866       0.410141       0.883594           536.018       0.01        \n",
      "\u001b[J43          0.109189    0.961448       0.441353       0.879297           548.274       0.01        \n",
      "\u001b[J44          0.107569    0.961961       0.432192       0.884766           559.796       0.01        \n",
      "\u001b[J45          0.102009    0.964378       0.432181       0.886328           572.656       0.01        \n",
      "\u001b[J46          0.0996161   0.964988       0.443999       0.87793            585.535       0.01        \n",
      "\u001b[J47          0.0932453   0.967041       0.452139       0.881445           597.528       0.01        \n",
      "\u001b[J48          0.0879048   0.969262       0.450908       0.884766           609.156       0.01        \n",
      "\u001b[J49          0.0933322   0.967352       0.452228       0.883008           621.725       0.01        \n",
      "\u001b[J50          0.0883782   0.96895        0.46483        0.880078           634.555       0.01        \n",
      "\u001b[J51          0.0873798   0.969729       0.471411       0.875195           646.78        0.01        \n",
      "\u001b[J52          0.0899555   0.968683       0.464493       0.882617           658.161       0.01        \n",
      "\u001b[J53          0.0848383   0.971221       0.455103       0.882422           669.137       0.01        \n",
      "\u001b[J54          0.0794684   0.972701       0.454608       0.879883           680.626       0.01        \n",
      "\u001b[J55          0.082094    0.971577       0.491964       0.875              693.268       0.01        \n",
      "\u001b[J56          0.0799809   0.972523       0.526578       0.868359           705.112       0.01        \n",
      "\u001b[J57          0.0795879   0.972856       0.538439       0.864844           717.415       0.01        \n",
      "\u001b[J58          0.0773325   0.973357       0.478144       0.871875           730.885       0.01        \n",
      "\u001b[J59          0.075146    0.972945       0.520115       0.872656           743.595       0.01        \n",
      "\u001b[J60          0.0758757   0.973892       0.549528       0.869336           756.815       0.01        \n",
      "\u001b[J61          0.0472821   0.98422        0.440967       0.886133           768.614       0.001       \n",
      "\u001b[J62          0.0299252   0.990362       0.438435       0.890234           779.477       0.001       \n",
      "\u001b[J63          0.0247615   0.99221        0.435327       0.895703           790.3         0.001       \n",
      "\u001b[J64          0.0221926   0.993345       0.441702       0.896875           803.134       0.001       \n",
      "\u001b[J65          0.0204117   0.993586       0.448859       0.895703           815.305       0.001       \n",
      "\u001b[J66          0.0188024   0.994695       0.453645       0.895703           825.476       0.001       \n",
      "\u001b[J67          0.0156325   0.99566        0.462118       0.896289           837.684       0.001       \n",
      "\u001b[J68          0.0161309   0.994984       0.462184       0.897461           850.523       0.001       \n",
      "\u001b[J69          0.0151435   0.995237       0.467102       0.89707            861.725       0.001       \n",
      "\u001b[J70          0.0136216   0.995983       0.469565       0.896875           872.419       0.001       \n",
      "\u001b[J71          0.0140849   0.995682       0.469501       0.897852           883.692       0.001       \n",
      "\u001b[J72          0.0139553   0.995783       0.474553       0.89668            896.62        0.001       \n",
      "\u001b[J73          0.0131952   0.996138       0.481529       0.896094           909.393       0.001       \n",
      "\u001b[J74          0.0142982   0.995526       0.480778       0.898242           922.065       0.001       \n",
      "\u001b[J75          0.0121332   0.996138       0.478623       0.899805           933.689       0.001       \n",
      "\u001b[J76          0.0111401   0.996728       0.482796       0.899805           947.017       0.001       \n",
      "\u001b[J77          0.0105382   0.99676        0.484633       0.894922           960.926       0.001       \n",
      "\u001b[J78          0.00964496  0.997329       0.485977       0.897266           974.333       0.001       \n",
      "\u001b[J79          0.00995056  0.996826       0.497885       0.897852           988.168       0.001       \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[J80          0.0108769   0.996661       0.498564       0.898047           1000.01       0.001       \n",
      "\u001b[J81          0.0108558   0.996982       0.495446       0.896094           1011.5        0.001       \n",
      "\u001b[J82          0.0102108   0.996871       0.494618       0.896484           1024.42       0.001       \n",
      "\u001b[J83          0.0106756   0.996617       0.497753       0.89707            1037.54       0.001       \n",
      "\u001b[J84          0.0100215   0.996893       0.501453       0.897461           1049.84       0.001       \n",
      "\u001b[J85          0.00844761  0.997529       0.493311       0.898438           1065.14       0.001       \n",
      "\u001b[J86          0.00905977  0.997448       0.499073       0.895117           1078.29       0.001       \n",
      "\u001b[J87          0.00930665  0.997062       0.508955       0.894727           1090.16       0.001       \n",
      "\u001b[J88          0.00867714  0.997559       0.504844       0.899219           1102.02       0.001       \n",
      "\u001b[J89          0.00861321  0.99727        0.502856       0.898047           1113.88       0.001       \n",
      "\u001b[J90          0.00728278  0.997952       0.506968       0.898633           1125.68       0.001       \n",
      "\u001b[J91          0.00845109  0.997603       0.503209       0.89707            1138.37       0.0001      \n",
      "\u001b[J92          0.00766607  0.997952       0.507215       0.896875           1151.05       0.0001      \n",
      "\u001b[J93          0.00709555  0.997936       0.508333       0.89707            1164.28       0.0001      \n",
      "\u001b[J94          0.00712828  0.997863       0.501388       0.896094           1175.9        0.0001      \n",
      "\u001b[J95          0.00740915  0.998224       0.507065       0.896094           1188.58       0.0001      \n",
      "\u001b[J96          0.00704248  0.997975       0.502469       0.896875           1199.79       0.0001      \n",
      "\u001b[J97          0.00837506  0.997559       0.50369        0.897461           1212.92       0.0001      \n",
      "\u001b[J98          0.00636488  0.998091       0.501123       0.898633           1225.74       0.0001      \n",
      "\u001b[J99          0.00658172  0.99813        0.496533       0.89707            1239.14       0.0001      \n",
      "\u001b[J100         0.00759665  0.997891       0.50088        0.897656           1251.94       0.0001      \n",
      "Test accuracy: 0.9019976\n"
     ]
    }
   ],
   "source": [
    "reset_seed(0)\n",
    "\n",
    "model = train(DeepCNN(10), max_epoch=100, base_lr=0.1, lr_decay=(30, 'epoch'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "学習が終了しました。ロスカーブと精度のグラフを見てみましょう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Image(filename='DeepCNN_cifar10_result/loss.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Image(filename='DeepCNN_cifar10_result/accuracy.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "先程よりも大幅にValidationデータに対する精度が向上したことが分かります。学習率を10分の1に下げるタイミングでロスががくっと減り、精度がガクッと上がっているのが分かります。最終的に、先程60%前後だったValidationデータでの精度が、90%程度まで上がりました。また、テストデータを用いた精度も、およそ90%程度となっています。しかし最新の研究成果では97%以上まで達成されています。さらに精度を上げるには、今回行ったようなネットワークの構造自体の改良ももちろんのこと、学習データを擬似的に増やす操作（Data augmentation）や、複数のモデルの出力を一つの出力に統合する操作（Ensemble）などなど、いろいろな工夫が考えられます。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# データセットクラスを書いてみよう\n",
    "\n",
    "ここでは、Chainerにすでに用意されているCIFAR10のデータを取得する機能を使って、データセットクラスを自分で書いてみます。Chainerでは、データセットを表すクラスは以下の機能を持っていることが必要とされます。\n",
    "\n",
    "- データセット内のデータ数を返す`__len__`メソッド\n",
    "- 引数として渡される`i`に対応したデータもしくはデータとラベルの組を返す`get_example`メソッド\n",
    "\n",
    "その他のデータセットに必要な機能は、`chainer.dataset.DatasetMixin`クラスを継承することで用意できます。ここでは、`DatasetMixin`クラスを継承し、Data augmentation機能のついたデータセットクラスを作成してみましょう。\n",
    "\n",
    "#### NOTE\n",
    "\n",
    "自前で用意した、もしくはどこからから調達したラベル付き画像データセットを使う場合は、[`LabeledImageDataset`](https://docs.chainer.org/en/stable/reference/generated/chainer.datasets.LabeledImageDataset.html?highlight=LabeledImageDataset)というクラスが非常に便利です。雹災はドキュメントを参照してください：[`LabeledImageDataset`](https://docs.chainer.org/en/stable/reference/generated/chainer.datasets.LabeledImageDataset.html?highlight=LabeledImageDataset)。こちらでも使っています：[Chainerでアニメキャラクターの顔画像を分類する](https://qiita.com/mitmul/items/5502ecdd2f0b444c427f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. CIFAR10データセットクラスを書く"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CIFAR10Augmented(chainer.dataset.DatasetMixin):\n",
    "\n",
    "    def __init__(self, split='train', train_ratio=0.9):\n",
    "        train_val, test_data = cifar.get_cifar10()\n",
    "        train_size = int(len(train_val) * train_ratio)\n",
    "        train_data, valid_data = split_dataset_random(train_val, train_size, seed=0)\n",
    "        if split == 'train':\n",
    "            self.data = train_data\n",
    "        elif split == 'valid':\n",
    "            self.data = valid_data\n",
    "        elif split == 'test':\n",
    "            self.data = test_data\n",
    "        else:\n",
    "            raise ValueError(\"'split' argument should be either 'train', 'valid', or 'test'. But {} was given.\".format(split))\n",
    "\n",
    "        self.split = split\n",
    "        self.random_crop = 4\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.data)\n",
    "\n",
    "    def get_example(self, i):\n",
    "        x, t = self.data[i]\n",
    "        if self.split == 'train':\n",
    "            x = x.transpose(1, 2, 0)\n",
    "            h, w, _ = x.shape\n",
    "            x_offset = np.random.randint(self.random_crop)\n",
    "            y_offset = np.random.randint(self.random_crop)\n",
    "            x = x[y_offset:y_offset + h - self.random_crop,\n",
    "                  x_offset:x_offset + w - self.random_crop]\n",
    "            if np.random.rand() > 0.5:\n",
    "                x = np.fliplr(x)\n",
    "            x = x.transpose(2, 0, 1)\n",
    "\n",
    "        return x, t"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "このクラスは、CIFAR10のデータのそれぞれに対し、\n",
    "\n",
    "- 32x32の大きさの中からランダムに28x28の領域をクロップ\n",
    "- 1/2の確率で左右を反転させる\n",
    "\n",
    "という加工を行っています。こういった操作を加えることで擬似的に学習データのバリエーションを増やすと、オーバーフィッティングを抑制することに役に立つということが知られています。これらの操作以外にも、画像の色味を変化させるような変換やランダムな回転、アフィン変換など、さまざまな加工によって学習データ数を擬似的に増やす方法が提案されています。\n",
    "\n",
    "自分でデータの取得部分も書く場合は、コンストラクタに画像フォルダのパスとファイル名に対応したラベルの書かれたテキストファイルへのパスなどを渡してプロパティとして保持しておき、`get_example`メソッド内でそれぞれの画像を読み込んで対応するラベルとともに返す、という風にすれば良いことが分かります。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. 作成したデータセットクラスを使って学習を行う\n",
    "\n",
    "それではさっそくこの`CIFAR10`クラスを使って学習を行ってみましょう。先程使ったのと同じ大きなネットワークを使うことで、Data augmentationの効果がどの程度あるのかを調べてみましょう。`train`関数も含め、データセットクラス以外は先程とすべて同様です。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch       main/loss   main/accuracy  val/main/loss  val/main/accuracy  elapsed_time  lr        \n",
      "\u001b[J1           2.66932     0.155096       2.07969        0.218945           17.7946       0.1         \n",
      "\u001b[J2           1.95089     0.252242       2.16529        0.249609           33.6332       0.1         \n",
      "\u001b[J3           1.80029     0.304087       2.41118        0.232617           48.9252       0.1         \n",
      "\u001b[J4           1.68941     0.352428       1.74426        0.346289           64.1672       0.1         \n",
      "\u001b[J5           1.51953     0.427662       1.64889        0.411523           80.7169       0.1         \n",
      "\u001b[J6           1.33687     0.510121       1.33771        0.523438           96.9036       0.1         \n",
      "\u001b[J7           1.19523     0.572338       1.24248        0.573242           113.866       0.1         \n",
      "\u001b[J8           1.08409     0.616544       1.24074        0.562109           129.411       0.1         \n",
      "\u001b[J9           1.0027      0.64917        1.1433         0.617969           146.937       0.1         \n",
      "\u001b[J10          0.929279    0.677974       0.990748       0.664648           163.91        0.1         \n",
      "\u001b[J11          0.872005    0.699929       0.968499       0.68418            181.605       0.1         \n",
      "\u001b[J12          0.8138      0.722111       0.978409       0.675781           199.057       0.1         \n",
      "\u001b[J13          0.778692    0.73746        0.941924       0.691602           215.46        0.1         \n",
      "\u001b[J14          0.748357    0.749332       0.954998       0.686523           233           0.1         \n",
      "\u001b[J15          0.723875    0.757147       1.03263        0.671484           248.429       0.1         \n",
      "\u001b[J16          0.70128     0.763844       0.922967       0.697852           264.35        0.1         \n",
      "\u001b[J17          0.686641    0.770774       0.932868       0.717188           281.515       0.1         \n",
      "\u001b[J18          0.667459    0.777033       0.761607       0.753125           296.919       0.1         \n",
      "\u001b[J19          0.657883    0.783787       0.696336       0.775586           314.209       0.1         \n",
      "\u001b[J20          0.643969    0.787509       0.788956       0.729883           330.866       0.1         \n",
      "\u001b[J21          0.62682     0.791867       0.747854       0.749414           348.447       0.1         \n",
      "\u001b[J22          0.617861    0.793413       0.724289       0.757422           366.256       0.1         \n",
      "\u001b[J23          0.615907    0.792824       0.760725       0.749609           383.692       0.1         \n",
      "\u001b[J24          0.608608    0.799316       0.626627       0.794141           399.339       0.1         \n",
      "\u001b[J25          0.581148    0.804532       0.724842       0.766016           415.612       0.1         \n",
      "\u001b[J26          0.586145    0.805578       0.758912       0.765039           432.683       0.1         \n",
      "\u001b[J27          0.580653    0.806974       1.53115        0.567773           449.495       0.1         \n",
      "\u001b[J28          0.58332     0.808249       0.638048       0.792773           465.692       0.1         \n",
      "\u001b[J29          0.575656    0.809171       0.597601       0.795898           482.273       0.1         \n",
      "\u001b[J30          0.554497    0.815193       0.92648        0.694141           499.854       0.1         \n",
      "\u001b[J31          0.412056    0.862948       0.353921       0.882812           516.331       0.01        \n",
      "\u001b[J32          0.330784    0.886841       0.323626       0.890625           532.822       0.01        \n",
      "\u001b[J33          0.309464    0.893932       0.314378       0.897461           549.781       0.01        \n",
      "\u001b[J34          0.292333    0.900613       0.298411       0.902148           566.772       0.01        \n",
      "\u001b[J35          0.276572    0.904848       0.294187       0.901758           584.074       0.01        \n",
      "\u001b[J36          0.264323    0.909113       0.306759       0.900781           601.223       0.01        \n",
      "\u001b[J37          0.253866    0.913996       0.300004       0.901172           618.957       0.01        \n",
      "\u001b[J38          0.244404    0.915461       0.289046       0.904883           636.233       0.01        \n",
      "\u001b[J39          0.235541    0.918581       0.302103       0.900781           654.649       0.01        \n",
      "\u001b[J40          0.231642    0.919545       0.309698       0.899219           670.247       0.01        \n",
      "\u001b[J41          0.228038    0.921964       0.294209       0.904102           687.482       0.01        \n",
      "\u001b[J42          0.225327    0.923233       0.300517       0.905273           705.459       0.01        \n",
      "\u001b[J43          0.21667     0.925471       0.323513       0.896875           722.654       0.01        \n",
      "\u001b[J44          0.211944    0.927017       0.323403       0.894141           740.125       0.01        \n",
      "\u001b[J45          0.203643    0.92911        0.306549       0.901367           757.691       0.01        \n",
      "\u001b[J46          0.201874    0.930622       0.316553       0.898633           774.53        0.01        \n",
      "\u001b[J47          0.197785    0.93093        0.321795       0.901172           790.748       0.01        \n",
      "\u001b[J48          0.19062     0.933872       0.326009       0.898438           807.37        0.01        \n",
      "\u001b[J49          0.189966    0.932994       0.302136       0.902148           823.616       0.01        \n",
      "\u001b[J50          0.188014    0.934792       0.351239       0.89082            841.241       0.01        \n",
      "\u001b[J51          0.182187    0.935764       0.330658       0.897461           859.206       0.01        \n",
      "\u001b[J52          0.180877    0.937744       0.331513       0.898242           875.571       0.01        \n",
      "\u001b[J53          0.177914    0.937967       0.315606       0.900977           892.888       0.01        \n",
      "\u001b[J54          0.177183    0.938565       0.30771        0.906055           909.576       0.01        \n",
      "\u001b[J55          0.172863    0.939815       0.310448       0.899414           926.626       0.01        \n",
      "\u001b[J56          0.171187    0.940252       0.334125       0.896875           943.697       0.01        \n",
      "\u001b[J57          0.17084     0.941251       0.321309       0.900586           960.606       0.01        \n",
      "\u001b[J58          0.166495    0.941462       0.313928       0.905078           977.788       0.01        \n",
      "\u001b[J59          0.170402    0.94043        0.336456       0.896094           994.226       0.01        \n",
      "\u001b[J60          0.165143    0.941306       0.333355       0.901758           1011.56       0.01        \n",
      "\u001b[J61          0.125434    0.95641        0.277837       0.916797           1028.05       0.001       \n",
      "\u001b[J62          0.0972963   0.967036       0.279862       0.918164           1044.82       0.001       \n",
      "\u001b[J63          0.0909571   0.968373       0.281997       0.915625           1063.31       0.001       \n",
      "\u001b[J64          0.0854286   0.970197       0.279891       0.916406           1078.31       0.001       \n",
      "\u001b[J65          0.0803817   0.972368       0.283583       0.921484           1094.7        0.001       \n",
      "\u001b[J66          0.078539    0.972945       0.277332       0.917383           1111.61       0.001       \n",
      "\u001b[J67          0.0718806   0.975539       0.289384       0.916406           1128.09       0.001       \n",
      "\u001b[J68          0.0706877   0.975608       0.289274       0.917969           1145.55       0.001       \n",
      "\u001b[J69          0.0701198   0.975405       0.287858       0.91875            1161.81       0.001       \n",
      "\u001b[J70          0.0672646   0.976562       0.289723       0.918555           1178.87       0.001       \n",
      "\u001b[J71          0.0635346   0.978009       0.293459       0.917773           1196.21       0.001       \n",
      "\u001b[J72          0.0641605   0.977583       0.296556       0.914258           1213.21       0.001       \n",
      "\u001b[J73          0.0624464   0.978094       0.297749       0.916406           1229.1        0.001       \n",
      "\u001b[J74          0.0622282   0.978543       0.29798        0.916797           1245.15       0.001       \n",
      "\u001b[J75          0.0624434   0.978538       0.302791       0.917578           1261.09       0.001       \n",
      "\u001b[J76          0.062236    0.978655       0.303235       0.917383           1278.4        0.001       \n",
      "\u001b[J77          0.0583369   0.979759       0.294987       0.91582            1295.95       0.001       \n",
      "\u001b[J78          0.0563044   0.980725       0.30498        0.91875            1310.97       0.001       \n",
      "\u001b[J79          0.0551139   0.980846       0.304319       0.91582            1327.2        0.001       \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[J80          0.0538306   0.981548       0.301928       0.917578           1343.2        0.001       \n",
      "\u001b[J81          0.0498568   0.982599       0.303399       0.916406           1359.95       0.001       \n",
      "\u001b[J82          0.0522237   0.981845       0.306208       0.916602           1377.32       0.001       \n",
      "\u001b[J83          0.0487175   0.983284       0.307845       0.917773           1392.65       0.001       \n",
      "\u001b[J84          0.0507888   0.982622       0.305499       0.917383           1409.53       0.001       \n",
      "\u001b[J85          0.0502483   0.982394       0.309835       0.919727           1425.66       0.001       \n",
      "\u001b[J86          0.0495274   0.983043       0.313392       0.917578           1441.89       0.001       \n",
      "\u001b[J87          0.0492812   0.982594       0.308399       0.917969           1458.86       0.001       \n",
      "\u001b[J88          0.0467606   0.983643       0.317299       0.916211           1476.23       0.001       \n",
      "\u001b[J89          0.0451622   0.984042       0.320555       0.918945           1493.84       0.001       \n",
      "\u001b[J90          0.0457013   0.984197       0.313627       0.917773           1510.37       0.001       \n",
      "\u001b[J91          0.0436299   0.984952       0.311594       0.91875            1527.8        0.0001      \n",
      "\u001b[J92          0.0405673   0.986178       0.311017       0.917773           1545.44       0.0001      \n",
      "\u001b[J93          0.0399707   0.986306       0.313432       0.917969           1562.86       0.0001      \n",
      "\u001b[J94          0.0375223   0.987892       0.313193       0.917578           1580.18       0.0001      \n",
      "\u001b[J95          0.0403957   0.986461       0.3141         0.917969           1594.47       0.0001      \n",
      "\u001b[J96          0.0385853   0.987024       0.311208       0.918555           1610.3        0.0001      \n",
      "\u001b[J97          0.0380802   0.986972       0.309954       0.918359           1628.06       0.0001      \n",
      "\u001b[J98          0.0383922   0.986994       0.311925       0.920117           1644.28       0.0001      \n",
      "\u001b[J99          0.0389155   0.986979       0.309176       0.919727           1660.87       0.0001      \n",
      "\u001b[J100         0.0371039   0.98766        0.311089       0.919141           1676.64       0.0001      \n",
      "Test accuracy: 0.9186115\n"
     ]
    }
   ],
   "source": [
    "reset_seed(0)\n",
    "\n",
    "model = train(DeepCNN(10), max_epoch=100, train_dataset=CIFAR10Augmented(), valid_dataset=CIFAR10Augmented('valid'), test_dataset=CIFAR10Augmented('test'), postfix='augmented_', base_lr=0.1, lr_decay=(30, 'epoch'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "先程のData augmentationなしの場合は90%程度だったテスト精度が、学習データにaugmentationを施すことで92%程度まで向上させられることが分かりました。およそ2%の改善です。\n",
    "\n",
    "ロスと精度のグラフを見てみましょう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAeoAAAEKCAYAAADdKRa4AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAAIABJREFUeJzs3XlclWX+//HXfTjsmwoubCqCihsC4oaKW5uWTmWW6WhmZVaOLVM21UzTNPOt5jdTY42VUZZt5mS7paZWiIhKhoZ7yCbgCiICynrO74+LczgICCjb4Xyej4cP7nOf+9znujh43vd13dd93ZrRaDQihBBCiHZJ19YFEEIIIUT9JKiFEEKIdkyCWgghhGjHJKiFEEKIdkyCWgghhGjHJKiFEEKIdkyCWgghhGjHJKiFEEKIdkyCWgghhGjH9G31xt7e3vTu3bvR2xcXF+Pq6tpyBWqnbLHetlhnsM1622Kd4erqnZGRQW5u7lW9f3l5OdnZ2ZSUlFzVfkTzcXJywt/fH3t7+1rPtVlQ9+7dm927dzd6+9jYWCZMmNByBWqnbLHetlhnsM1622Kd4erqHRkZedXvn52djbu7O71790bTtKven7g6RqORvLw8srOzCQwMrPW8dH0LIYSNKSkpwcvLS0K6ndA0DS8vr3p7OCSohRDCBklIty+X+zwkqIUQQoh2TIJaCCGEVdm9ezdLlixp1Lb3338/27dvZ/78+Xz22WctXLKWIUEthBCiXiu2ppKQWnOUeUJqLiu2prZRidSAutdee61R2+7atYtRo0a1cIlaltUE9fq0snb3xyKEEB1dqL8ni1fvMX//JqTmsnj1HkL9Pa9qvxkZGYSEhHDvvfcyePBg5syZw5YtWxgzZgx9+/YlMTGRxMREoqKiCA8PJyoqiiNHjgBq1PxNN90EwHPPPceCBQuYMGECffr0qRHghw4dol+/ftjZ2dV47x9++IHw8HCGDBnCggULKC0tBeBPf/oTAwcOJDQ0lMcffxyAtWvXMnjwYIYOHUp0dPRV1flKtdnlWU0V6GnH4tV7WD47nKggb/Mfy/LZ4W1dNCGEsFp/W3eAg8fPX3abbu6OzFuZSHcPR06dLyW4mxuvbknh1S0pdW4/0NeDv04b1OB7Hz16lLVr1xITE8Pw4cNZvXo18fHxfPPNN7zwwgt88MEHxMXFodfr2bJlC08//TSff/55rf0cPnyYn376icLCQvr3788DDzyAvb09GzZs4IYbbqixbUlJCfPnz+eHH36gX79+zJs3jzfffJN58+bx5ZdfcvjwYTRN49y5cwA8//zzfP/99/j5+ZnXtTaraVEP8LJj+exwHvgoiZlvJvDgx0nm0BZCCNFyPJ3t6e7hSM65Erp7OOLpXHtSjisRGBjIkCFD0Ol0DBo0iMmTJ6NpGkOGDCEjI4OCggJmzpzJ4MGDefTRRzlw4ECd+7nxxhtxdHTE29ubbt26cerUKQC+//77WkF95MgRAgMD6devHwB33XUXcXFxeHh44OTkxL333ssXX3yBi4sLAGPGjGH+/Pm8/fbbVFZWNku9m8pqWtQAUUHejAnyYv3+k9w5IkBCWgghrlJjWr6mHswlk4L5aNcxHr6mb7N8/zo6OpqXdTqd+bFOp6OiooK//OUvTJw4kS+//JKMjIx6J4mx3I+dnR0VFRVcuHCBc+fO4evrW2Nbo9FY5z70ej2JiYn88MMPrFmzhuXLl/Pjjz+yYsUKdu3axXfffUdYWBh79+7Fy8vrKmveNFbTogb1x7LtqDpP8m3yiVrnrIUQQjQvy9OMj13Xn+Wzw2ucs25JBQUF+Pn5AbBq1aomvfann35i4sSJtdaHhISQkZHB0aNHAfjwww8ZP348RUVFFBQUMHXqVJYtW8bevXsBSE1NZeTIkTz//PN4e3uTlZV1dZW6AlYT1IfyKlm8eg9Lr+8PwKLoPq32xyKEELYqObugxmnGqCBvls8OJzm7oMXfe+nSpTz11FOMGTOmyd3OdZ2fBjWn9nvvvcfMmTPN3e6LFi2isLCQm266idDQUMaPH89//vMfAJ544gmGDBnC4MGDiY6OZujQoc1St6bQjPX1A7SwyMjIJs31vfTdTdw8PoLuHk5Mfnkry+4Io5uHI8nZBSwaH9SCJW1btjgXsi3WGWyz3rZYZ7j6ub6b8t1Zl0OHDjFgwICr2kd7FxERwa5du+q8yUV7Vd/nYjXnqKf2cSAqyJvThWou1MLSCm4O8pPz1EIIIWpJSkpq6yI0G6vp+jZxd1RHR4Ul5W1cEiGEEKLlWV1QO9nr0Os0Cksq2rooQgghRIuzuqDWNA03Jz1FEtRCCCFsgNUFNYC7k166voUQQtiEBoM6KyuLiRMnMmDAAAYNGsSrr75aa5vY2Fg8PT0JCwsjLCyM559/vkUKa+LuaE9RqbSohRBCdHwNjvrW6/W8/PLLREREUFhYyLBhw7j22msZOHBgje3GjRvHt99+22IFteTmpOe8dH0LIYRNcHNzo6ioyPz4hhtuYOXKlebJUK5UVFQUCQkJDW73ySefkJaWhp+fH7t372b58uVX9b5N1WCL2sfHh4iICADc3d0ZMGAAOTk5LV6wy/Fw0stgMiGEaA3xyyA9rua69Di1vg1cvHiRs2fPXnVIA40KaYCNGzfWOXlKa2nSOeqMjAz27NnDyJEjaz23Y8cOhg4dypQpU+qdOL25uDnqKSqVc9RCCNHi/CJg7fzqsE6PU4/9Iq54l08++SRvvPGG+fFzzz3H3/72NyZPnkxERARDhgzh66+/rvO1lpPF9O7dm6effprRo0cTGRlJUlIS119/PUFBQaxYsQKAoqKievfr5uZWY5+33XYbISEhzJkzxzwnuNFoZO/eveYGq0lmZiaTJ08mNDSUyZMnc+zYMaDu22IeOHCAESNGEBYWRmhoKCkpdd91rD6NnvCkqKiIGTNmsGzZMjw8PGo8FxERQWZmJm5ubqxfv56bb765zoLExMQQExMDQHZ2NrGxsY0uaFFRkXn782dLOVtY0aTXWyvLetsKW6wz2Ga9bbHO0M7qveFPcHLf5bdx94EPb1E/C09A1xCI/af6V5ceQ2DKS/XubtasWTzyyCM8+OCDAHz66ads3LiRRx99FA8PD3Jzcxk1ahTTp09H07Saxd2wgZtvvtn8OCAggB07dvDoo48yf/58tm/fTklJCYMGDWLRokU4OTnx5ZdfNrjfPXv2cODAAXx9fRkzZgzbt29n7Nix7Nmzh6FDh9bafvHixcybN4+77rqLd999lyVLlvDVV1/VeVvMFStW8PDDDzNnzhzKysqaPB1qo4K6vLycGTNmMGfOHG699dZaz1sG99SpU3nwwQfJzc3F27vmrGELFy5k4cKFgJoGrylT6FkeRe0qOUxcdhrjx4+v9cvraGxxikVbrDPYZr1tsc5ghfV26qRCuiALPAPU46sQHh7O6dOnOX78OGfOnKFz5874+Pjw6KOPEhcXh06nIycnh1OnTtGjR48ar92+fTv//ve/zY+nT58OwJAhQygqKsLd3R13d3ecnJw4d+4crq6uPP300w3ud8SIEfj7+wMQFhZGRkYGY8eOZePGjUyZMqVWHXbs2MEXX3wBwNy5c1m6dClQfVvM22+/3ZyXo0eP5v/+7//Izs7m1ltvpW/fvk36fTUY1EajkXvuuYcBAwbw2GOP1bnNyZMn6d69O5qmkZiYiMFgaNHbgLk76akwGCkpN+DsYNdi7yOEEB3eZVq+Zqbu7uilsHslTHgSAqOv6m1vu+02PvvsM06ePMmsWbP4+OOPOXPmDL/88gv29vb07t2bkpKSGq9JS0sjICAABwcH8zrLW2NeetvMioqKRu3Xcj9QfatMgE2bNvH55583WB9To7Gu22LOnj2bkSNH8t1333H99dfzzjvvMGnSpEb/rhoM6u3bt/Phhx8yZMgQwsLCAHjhhRfM/fGLFi3is88+480330Sv1+Ps7MyaNWtatKXr7lQ9jagEtRBCtCBTSM9cpcI5cFzNx1do1qxZ3HfffeTm5rJ161Y+/fRTunXrhr29PT/99BOZmZm1XlPfHbEup6CgoMH9Xu61FRUVdTY8o6KiWLNmDXPnzuXjjz9m7NixQPVtMUeOHMm6devIysqioKCAPn36sGTJEtLS0khOTm7eoB47dmy9N9o2Wbx4MYsXL270m14td0dV7MLSCrqBGn3oF1HzjyY9DnKSYOwjrVYuIYTocHKSaoZyYLR6nJN0VUE9aNAgCgsL8fPzw8fHhzlz5jBt2jQiIyMJCwsjJCSk1ms2btzIf//73ya9T2P2W5/NmzdzzTXX1Pnca6+9xoIFC/jXv/5F165dee+99wB1W8yUlBSMRiOTJ09m6NChvPTSS3z00UfY29vTo0cPnn322SbVAWMbGTZsWJO2/+mnn8zLWw6eNPZ68lvjnmP5akXaVqPxn4FGY8qWmo/TtjZTaduOZb1thS3W2Wi0zXrbYp2Nxqurd1O/O+ty8ODBq95HayspKWmWujfFPffcY9yxY0ervV99n4vV3ObSkltVi9o833dgNNzwT/joVgj7Pfy24aq7ZYQQQrQfjo6OV30f7qZ65513WvX96mOlc33XcatLXVVV9n4EkfdISAshhOgQrDSoq89Rm/32vfoZNEmNSrx0Jh0hhBBmxgbGHonWdbnPw7qD2tT1nR4HB75UywGjVLe35Uw6QgghzJycnMjLy5OwbieMRiN5eXk4OTnV+bxVn6M2d33nJIFrNzifDSUFzTYqUQghOiJ/f3+ys7M5c+ZMWxdFVHFycjJPuHIpqwxqvZ0OZ3u76sFkox6AH6purVlSoH4GRktICyFEHezt7QkMDGzrYohGssqub1Dd3+au77xUMFbNnVpyru0KJYQQQjQzqw7qItNgsjOH1E9HDyg933aFEkIIIZqZ1Qa1m5M9503nqE8fBk0HvuHVXd9CCCFEB2C1Qe1h2fV95jB06QNu3SWohRBCdChWG9RujpZd34fV/VGdPKBEur6FEEJ0HFYb1GowWTlUlKrBZF1DwMlTtajl2kAhhBAdhNUGtZujvbo8yzTiu9sAFdTGSigrbuviCSGEEM3CaoPa3UlPcVklhtNVI7679lejvkHOUwshhOgwrDqoAcqOH1Ajvr36qhY1yCVaQgghOgyrD2qDacS3vVN1UEuLWgghRAdhlVOIEr+MXqW9AAfsco9AjxB1A44jG9XzEtRCCCE6COtsUftFEJH4KON0yTgUpIO9i7pbll+Eel4u0RJCCNFBWGdQB0aTOel1/mv/XzRjJRxZr+6WFTxZPS/zfQshhOggrDOoAS1wPEeNvupB2Bx1pywZ9S2EEKKDsdqg9srezDAthXy3INj/mTpHbe8EeicJaiGEEB2GdQZ1ehyd1j+ApsGmkBdUt/fa+Sqs5Q5aQgghOhDrHPV9bCfo7NhsGMYx+94QGKLCOiepehpRIYQQogOwmhZ1wLEvVIsZwN4ZrayIRF0YQzPfV+sCo2HsIxLUQgghOhSrCepC92DVvZ2yBRKWQ49QHmQtKfq+NTeUO2gJIYToQKym6/tc51DVvf3JnVBWBOUXeNH1Sc7ahdbc0MkTzmW1SRmFEEKI5mY1LWpAdW+PWKiWR95PhvswdatLS9L1LYQQogOxrqBOj4Ok9yF6Kex+l0jjfopKK2puI0EthBCiA2kwqLOyspg4cSIDBgxg0KBBvPrqq7W2MRqNLFmyhODgYEJDQ0lKSmr2gnbKT1bnqGeugknPwMxVPJj7d4KL99Tc0NEDKkuhvKTZyyCEEEK0tgaDWq/X8/LLL3Po0CF27tzJ66+/zsGDB2tss2HDBlJSUkhJSSEmJoYHHnig2QvqXnhUhXRgtFoRGM2a3n+nT9mRmhvKrS6FEEJ0IA0GtY+PDxER6mYX7u7uDBgwgJycnBrbfP3118ybNw9N0xg1ahTnzp3jxIkTzVrQrJ63Vod0lVzvkSwvuxGj0Vi90qmT+ind30IIITqAJp2jzsjIYM+ePYwcObLG+pycHAICAsyP/f39a4V5S3B30lNeaaS0wlC90nxPamlRCyGEsH6NvjyrqKiIGTNmsGzZMjw8PGo8V6NFW0XTtFrrYmJiiImJASA7O5vY2NhGF7SoqMi8/fq0MgI97ThRpAL6+x/jOF5kIL2gklleqUQAvybGkX+0sNH7b68s620rbLHOYJv1tsU6g+3WW1yZRgV1eXk5M2bMYM6cOdx66621nvf39ycrq/ra5ezsbHx9fWttt3DhQhYuVJdXRUZGMmHChEYXNDY21ry9Q0Aui1fvYdbwADiUSoV3MG8nHmb57Agi3ANgDwzt1wsGN37/7ZVlvW2FLdYZbLPetlhnsN16iyvTYNe30WjknnvuYcCAATz22GN1bjN9+nQ++OADjEYjO3fuxNPTEx8fn2YvrElUkDfLZ4fzwY5MAP627iDLZ4cTFeRt0fUt56iFEEJYvwZb1Nu3b+fDDz9kyJAhhIWFAfDCCy9w7NgxABYtWsTUqVNZv349wcHBuLi48N5777VsqVFhfVOoD2t+zmJUHy8V0lB9T2oZ9S2EEKIDaDCox44dW+c5aEuapvH66683W6EaIyE1l00HTuGo1xH72xkSUnNVWDu4gmYnLWohhBAdgnXNTFYlIVWdo14+J5xrBnbH1cGOxav3kJCaC5oms5MJIYToMKwyqJOzC8znpMcFe5N/oZw/TQkhObsqnJ085fIsIYQQHYLV3D3L0qLxQeblsX3VuenCkorq9U4e0qIWQgjRIVhli9qSf2cX+nR1ZVvKmeqV0vUthBCig7D6oAYYF+zNzrQ8Sisq1QoJaiGEEB1Exwjqvl0pKTfwS2a+WuHkKZdnCSGE6BA6RFCPCvJCr9PYlpKrVjhKi1oIIUTH0CGC+qOdmQR3dSPeFNROnlBWxFs/Hbn8C4UQQoh2rkMEdai/J5lnL7Avp4CzxWWkFdkBEN7dro1LJoQQQlydDhHUUUHePD01BIAnP0tm1S/qXPWIHhLUQgghrFuHCGqA34/qhYeTns2HTjGsfy+1Us5TCyGEsHIdJqh3pOVRXmnkfrt1HDm8X600BXV6HMQva7vCCSGEEFeoQwS1ae7vF28dQrKxD4t1nwNwODNbhfTa+eAX0baFFEIIIa5Ahwhq09zfN4f7UdFzLC87LALAZd+HKqRnroLA6DYtoxBCCHElOkRQLxofZL4f9YwIf1aeC6fCsTM9z+6AyAUS0kIIIaxWhwhqSyfPlzDW7hCV5SVqRWIM+7evY8XW1LYtmBBCCHEFOlxQX+N8hNf0r/Jw5cMYHT045zkAv80PMlZ/sK2LJoQQQjRZhwvqwcZU4sL+xcbSUH50vh7XUz9zetw/GGyUFrUQQgjr0+GCmrGPcOP0O9DrNH7LvYieSvprWTD2EfW8XKolhBDCinS8oAZ+zjgLwF6HSMrRU7FjBZSXyKVaQgghrE6HC2rTNdU3h/mx6WI/0kMfQ19eSN77v5dLtYQQQlidDhfUpmuqZwzzx2iE7JB7MGh2eGVvhsh7JKSFEEJYFX1bF6C5LRofBEBJeSX2dhonk7eooxGvYNi9EgLHSVgLIYSwGh2uRW3iZG/H7G6Z3HTkKXVOWu+kur3XzlfnqoUQQggr0GGDGmCCezYPlS2hvEc45GdA73EqrHOS2rpoQgghRKN0uK7vGsY8TPxvP5NthMCyIriQp7q9petbCCGElejQLephvTqj0yC5uJNakZ/ZtgUSQgghmqhDB7WHkz0DfDyIz3NXK/LT27ZAbSl+We1z8zL5ixBCtHsNBvWCBQvo1q0bgwcPrvP52NhYPD09CQsLIywsjOeff77ZC3mlVmxNJaCzM1tOOqoV+RkkpOba5g06/CJqDqSTyV+EEMIqNHiOev78+SxevJh58+bVu824ceP49ttvm7VgzSHU35PlPx6lqNyBcldvzh47wuKte1g+O7yti9b6AqPVQLo1c9RjnR5uf1/O1wshRDvXYIs6OjqaLl26tEZZml1UkDf/nhkKQEZlVzKPHmT57HDzvattTmA0+A2D0vMwZIaEtBBCWIFmOUe9Y8cOhg4dypQpUzhw4EBz7LLZ3DDYh07O9hwo6Ux/xzzbDWlQ3d1ZO9Vy8lq5nlwIIazAVV+eFRERQWZmJm5ubqxfv56bb76ZlJSUOreNiYkhJiYGgOzsbGJjYxv9PkVFRU3a3uRQXiVFpeUct+uGa8lO3vrse/p7OzZ5P23lSut9qU75yQw8+C/OeYbTLTeB3/xn0nv1HA4OfIJznUOvvqDNqLnqbG1ssd62WGew3XqLK3PVQe3h4WFenjp1Kg8++CC5ubl4e9duuS5cuJCFCxcCEBkZyYQJExr9PrGxsU3aHtQNOt7etoe7onqTvqMbejsD3x48w5A5N1hNy/pK6l2n+L0w+2O67VsLuQn0GzUFxkwnLCcJxjbD/ptRs9XZythivW2xzmC79RZX5qq7vk+ePInRaAQgMTERg8GAl5fXVResOZhu0HHbsACyjN0AeGmSO8nZBW1csjYw9hF1Trq0SD0uK1aPTffpFkII0S412KK+8847iY2NJTc3F39/f/72t79RXl4OwKJFi/jss89488030ev1ODs7s2bNGjRNa/GCN4bpBh2VBiN59j4ADHLOZ9CwoLYsVtsqLVQ/y4rbthxCCCEapcGg/uSTTy77/OLFi1m8eHGzFagl2Ok0evj3oSLHDn1+RlsXp22VFdX8KYQQol3r0DOTWQrv5UW2wZuKvIy2LkrbMrWoyy+0bTmEEEI0ig0FdWeOGbtx8bQNzkpmSbq+hRDCqthMUEcEdCbL2A19gY3fmEOCWgghrIrNBLWniz3Frv44VxRAyfm2Lk7bMQe1nKMWQghrYDNBvfODv9DV0QCAsWpA2f7t69j5wV/asFStrKIUDGrEPmVyjloIIayBzQS1W9AIJhd8AcCpY0fYv30dfpsfxC1oRBuXrBWZWtMgXd9CCGElrnpmMmsxeMw04vPPMnb3EvJ+ehO/khRyrn2DwWOmtXXRWk+NoJaubyGEsAY206IGiJo6j0KjE4NKfuGI/0zbCmmQFrUQQlghmwrqgzu+xQ51nnpA9hr2b1/XxiVqZaZWtKOHXEcthBBWwmaC2nRO+vt+f6PUqKeg2wj8Nj9oW2FtalG7dZeubyGEsBI2E9RFqYnkXPsG0b+7h28No+mRt4uTE16mKDWxrYvWekxB7d5Dur6FEMJK2MxgslHz/m5ednTtjEPJBQY45YFpfXoc5CR17LtJWbaos39u27IIIYRoFJsJakulwVMp3/cdum3/wa68BOzsIf4VmLlKbdBRQ9uyRV1RAoZK0Nm1bZmEEEJcls10fVvqO2oKb1RMx674FOz/HDb9GQbeDD1CVUivnQ9+EW1dzOZnOi/t1q3qsXR/CyFEe2eTLerBvp7c53QH9xk24XJqn1q5eyUc3aLCbOYqCIxu0zK2iNJCcHAHR3f1uKwYnDzatkxCCCEuyyZb1DHb0vhdl2OUGnUYht0NTp5c8AiCc5kw8HcdM6RBBbWjG9i7qsfSohZCiHbPJoN6rP4gi07/nQfLlrAn9FnSBz2E0/lUjGiwd7Xq/u6ISgtVa9qhKqjLJaiFEKK9s8mgHmxMJW3C6+wwDOKbr/5Hp1+WkznsaTSfoWqDT+/qmGFdVgQObtVBLS1qIYRo92wyqBn7CJETf0dAZ2ecTv/K5kEvETjtSbjpFTUaOvR2Neq7ozG3qN3UYwlqIYRo92xyMBlAQmouZy+U8VblNNwP6PGPyCXqxDbw6gupP8FDu9SGHelSrdIicO0KDi7qsQS1EEK0ezbZok5IzWXx6j38985wXBzsiOzVmcWr97BfC4LCE5B7RAV0R7tU69Jz1BLUQgjR7tlkUCdnF7B8djiTQrpzw+Ae7M7I55XbhxJfMRBmvg9osP5xFdId6VKt0vPS9S2EEFbGJru+F40PMi/fFuHPF0k5FJZUVK0PAp9QOPErjPtjxwlpo7GOwWRyYw4hhGjvbLJFbenX7HN4udrzeVK2WpEeR0VuqlpOfKfjjP6uKAFDhWpR650ATW51KYQQVsDmg3poQCeKyyrZeuQM+Qe2UL7mLh6veAijpoP+U1T3d0cI61LTvajdQdNUy1q6voUQot2z+aCOCvLmH78bjBHYuGkDD5Uv4fbfL0TzDYezaeocdUe4VKv0vPppmj7UwVW6voUQwgrYfFAD3BYZQA8PR546NYm+I6cQFeQNfSZAzi/gM7RjXJplCmXTQDIHF2lRCyGEFZCgRl2uVVRaCcCq7RkkpOZCn4lgrISM+KbvMH5Z7e7y9Di1vq2YbnFZo0Ut56iFEKK9s/mgNl1THTN3GEP9PXF2sOOhj5PYUd4H7F3U5CdN5RdR89x2e7geu1ZQu0nXtxBCWIEGg3rBggV069aNwYMH1/m80WhkyZIlBAcHExoaSlKSdZ3PNV1THRXsTb/u7uQWlXHbMH9+PVECvcZw8cgWVmxNbdpOA6PVue1P74L3psLau9r+emzLwWRQ1aKWrm8hhGjvGgzq+fPns3Hjxnqf37BhAykpKaSkpBATE8MDDzzQrAVsaYvGB6lz0sAt4X7Y6TS+TMrhXu0bTui64nw+ncjOVYHWlO7rwGjo3Bsyt4Pf8La/HvvSwWT2co5aCCGsQYNBHR0dTZcuXep9/uuvv2bevHlomsaoUaM4d+4cJ06caNZCtpaoYG8ev64fucVlvHzADdffvgYgsuLX6u7r/PTGnX9O/hSOV/UupP7Q9pd41RpM5ibXUQshhBW46nPUOTk5BAQEmB/7+/uTk5NztbttM4vGB9HDw5E3M335LuT/ARps+SusmaO6rwfPUIGdsLx60Nil55/T4+DrxaCzhxH3q4lG/je3bcO6tBDQqmclk8uzhBDCKlz1FKJGo7HWOk3T6tw2JiaGmJgYALKzs4mNjW30+xQVFTVp+yt1KK+SggulAPx1X2cmeQTR/cJRjGgcjf+KHP9p9PaaSK9Nz1DgEYLLxZc5OPAJ3Ld9RuHevZzrHEqfo+8SUFnK6a5juHjyLL3QccozjOJtn5GVaWhSeZqr3sGph+lh50z81q0A9DmZh39JIXGt8Dttqtb6rNuFVyZ5AAAgAElEQVQbW6y3LdYZbLfe4spcdVD7+/uTlZVlfpydnY2vr2+d2y5cuJCFCxcCEBkZyYQJExr9PrGxsU3a/kokpOby9rY9rLx7JO8nZHDxt1gcLp7irN9kuuT8SN/UlfQ99om5y7jT+cPg2ZOwafdD1i7Vsh77GJQeAXsXuhcdgql/gviz9Mj9De7/kiBd0zoxmq3e59ZCYefqfWmJkPUFE8aNATv7q99/M2qNz7o9ssV622KdwXbrLa7MVXd9T58+nQ8++ACj0cjOnTvx9PTEx8enOcrW6swjwIO8ibY/zH90y3i7+1/5tN+/YM5aDJpehbRvBDh1gu6hUHAMXh8FPUJhyO2w6Rk4c1jt8Pb31SAy585QkAWZ8dXd5ZbntVvjGuuywurz01D/rS7b4zXgQghhwxoM6jvvvJPRo0dz5MgR/P39WblyJStWrGDFihUATJ06lT59+hAcHMx9993HG2+80eKFbimWI8DHuGTyqOER3sz0ZWL/buw/XUKx0YGizgPh+B6IfgIe2AaDb4P8NPhnb9j1ZvXORiysHuk9dBagQfx/1LnsNXPgk9lqubWusTbdi9qkvqBuj9eACyGEDWuw6/uTTz657POapvH66683W4Hai97Tn+H3QSfZ9uEvvP7uu/yt7N9kXhvDYGMq6PQQ/4q6HeZtK+FCLqTFQsBIyE2B4ffC7pUQPFmFdd9r1b+UTVB0pmpglxF+WaVe1xrXWNcK6nruSR0YDTNWwurbYfh9sPfjtr8GXAghbJhN3o+6sa4b1IPx/bvic3QdK3z/zFNjplU/6RNafbOOk/sg9A51SdZ1/4CoxRA4TrVETSE34U8qqE/tA6++kJ8B+z+H6KWtE4KlReDeo/qxvYv6WdfIb3sXKL8ICa+1XvmEEELUyeanEL2chNRckrML+NTxVt7K8ud/Px+rfs4wkG9ye1SHcbeBKqTjX1HdxabZyUxhXlYMzl1g3BNQdAowgktX1fJujcu2SgvB0aP6sanru65rqVM2qZ9Bk1uvfEIIIeokLep6mOYAXz47nPMXy3ngoySe+nwf3T2ccNDrWLx6D18MTa1uMZtanaaWtmldYHT1ed7b31fbJL4Fmh1cOAOzVtdsebeUWoPJ6un6To+DnVXjDAJGqDuHtUb5hBBC1Ela1PWwHAF+w2Aflt7QHwPw1Bf7zAHee/oztcMrMLr2bTFzkqqDLicJZn0M1/xVPafZtfw9r43GOs5R19P1nZMEvceq5Yv5tXsGhBBCtCppUddj0figGo8fmBDMxv0n+TW7gOlDfc2jwxvFMrhNy/7DYctzai7w6/7esq3V8otgNIBjXZdnXdL1PfYRNcAN4MJZ9dOyx0AIIUSrkhZ1IyWk5nLs7AW6uNqzLvk43x84eXU7tHdW12Mf29E8BbycS29xCfV3fQOcqzoXfzG/ZcslhBCiQRLUjWA6X/36nAh+F+aHBixenUTC0Vzz802+FSZAr9HqmuxLW7XNzdS9Xddgsku7vg0GNTkLSFALIUQ7IEHdCJbnq68d2B0nezvKK418uDPTHOKh/p5N33HPKHXDjpzdNdc39+xgpltcWg4ms3NQ58cvbVEXnYLKMrV88eyVvZ8QQohmI0HdCJYzlkUFefP23Ej0Oo2N+0+yYNXP5hCHJrauA0YAGmRe0v3d3LOD1dX1rWl13+rS1Jru1Eta1EII0Q5IUF+BMX29uXtMb4xASbmBb389jtFobHrr2rkTdB+sBpRZMo20/nQefVLfv/rLo0pNXd9uNdfXdatL0/lpn6Fw8ZzqChdCCNFmJKivQEJqLp8n5fDghCD0Oo3ViVnc9N94Hvo4qUbrukHxy6BzL8j+GSrL1TpTF3ePUCgrpmfWFxA6q3ZIN6Z73LSNuUXtUXMbB9faXd/nMtVPn1DACCXnGlcXIYQQLUKCuoksJ0JZekMI7989AjsdHDh+HoPRiK+nc41tL9sN7hcBaVtV9/OJ5Jpd3Fueg8oyDGiw80048HX169Lj4Gy62jb1RxW2dXWPm7rQj+9Rj0/ur7mNg0sdQX0MXLzBM0A9lu5vIYRoU3IddRNZDiwD0HTg4qCnk7M9WfkXufY/W5kyuAdD/D15MzaN5bPDgerpSGtcnx0YDb97HdbOg/WPq9bszFVgqISk96H7EFLdRtA3daUK2MMzVUs3/hW1Xa8o+GiGOtdsZ19zYhLTtc+3vq1usAHw7SPVt94E9bpLR5yfOwadeqpbc4Lq/hZCCNFmpEXdRJYDy0yt67fmDmPbk5NYPCmY8koj3/x6gv/77jCzhgcQFeR9+XPXg34HvuFwPAn6T1UhuvdjNUHJxKfJCZgO178IGGDfWnW/6zGPqG7r9Y+r7UrPq9ttBkbXHIhWdAa+f0aNLAd1Vy/LLvT6zlF3CrAIamlRCyFEW5IW9VW4tHX9+HX9yT57ga/2HsdOgzdiU9mdcZZ9OQU8dl2/GueuzS3snjmQnwk6exXQg2eobu0ufcDelYBjn8O81yD3iLotJqhucU1TLW97F9V1vucjGHBT9UC0/82tDnF7Zxj9B3WDjcBx1WFtf0nXt8EA57Kg/xR1AxGQS7SEEKKNSYv6Kli2rkGFb1xKLksmBePuZI9/Z2cSM/IxGGHZ5hTiU9Q567e3pbJ49R7G6g/C2vnsH/saP/e8WwXrx7ep66qDr4XP76bQPVi1jg+tg+gn1CVWeifVStY7wuz/gXc/8A6ubkkHRoNLFxXSekeY/SlMekYFuOVlXw5uNYO6+DRUlqpLs6RFLYQQ7YIEdTOxHGT22HX9eWhSEDn5F4nu502lwUhxWSV3vbuL9ftO8MJ3h3lgQh8GG1PZP+ZV5v3oRPnYpeAXqQJYs1Pd3DNXqZ2bLs+a9GcY/yfVgu4RqiYtAdUCPnVAne/OSYJfP4WzaSpw7RyrC3npDTYcXKHcIqjPma6h7glOVd30EtRCCNGmJKibiWU3eEJqLm/GpvH0jSFEBXnzwYIRuDnqcXXUk5xdgBH4fxuPMPWXCO7c7MDy2eEk55znlxGvYNDZg7ESht9LgmEgOZlHqq+hTo9TA8mu+4fqIp/1sQpxDz8V8OUX1DnqdX8AdLBgY/U2pla05d29TJdnGY3qsenSrE49wU4Pjp7VN+YQQgjRJuQcdTOxHM196blrgIevCeaVTSncOSKAL/fkYDTCwROFaMDOtDwienbm9U++4mUc2dPtTkbviGFVvAvhg26FwGgSUnPRbd/MqEsnPpm5CrJ/UZdUHV4P3UJAp4eB14OHr/pnakVfei22g4sK+Moy1UVumuzEdGmWS2dpUQshRBuToG4Bl94i09TCXjk/kqggb/p0deWF7w4TEdCJPVnneO2Ho0TpDvBf+9dYUvkoOI7j7eIA3nVdxhHdH0lIHVrVrf4wBF4ymYrpMqy8o+o8duA4NZJ7+H21tzGJX6Za3pZ30MraBYe/Axev6hnMnCWohRCirUlQt4L6usUrDfDYdf25e1UiQ0jjL/Z/ZHtZPwwpuTjqh3B/yR8Ys/8gy3/9hbfmDiM5u8C8z5i4NBZG9wFAt/1VRvXsCaUFlG74M45dQ9TAtPhlNe+FbWK6hCtstnqc+hNseEJ1eXfqWb2dc2cZ9S2EEG1MgroVXK5bPCE1Fyd7O/b5zWdfTgEuDjAm2JsfD59iW8UA4soHoGkVxKfkMiKwC/d/+AsASyYHVy/3CSJs+1/RYYdjRSH0mUD5/+azYcCLTK+rQKZBZZ/cqR5/+zDMWg3fPgbdBlRv59wF8jOa/fchhBCi8WQwWSurb8KUxZOCAXV59F1RvVh6Q38AentoYFTXZN/93s8Ul1ZQUl7Jtt9yKa8wUFFpJK5iAHcXP4SdpoHOnvK9/+Oh8iV4D7mm/oIERkPkArVcWgzH96o7Z5la1Olx6py1dH0LIUSbkqBuQ5at6+TsAt6aO4y35g5j3a/Hzd3jI3ro+eiekTjYaRgBH08njEaIS8mlpMLAxarQ3mEYxPvl14ChnHdKJjF/zlySswtISM0lITWX+e8l1ljev30d5b98xF7/32PAiHHzX6CiRF3SlR5H+Zq7OFLeteoOWpVt/asSQgibJV3fbciyS7y+7vHYyiw0HTja2xHZ25N9OQU4O9gxa3gAq3epUdqTB3Sn4OAP3GKXwKsVt/B7u03E7rmW0PBrVfe4ER6cGGTuKn8xPB/fzY9zP49y78S72LI3jMnJT2CnGeHYTsp/fJGHypfwVEAFnPoOSgrUBCpCCCFanQR1O2QZ2ofyKnl7m+oeB8xh283DEZ1OA2Bhz2yC0v7LguI/4NJvIn/4bSD/3fcEfz70R4pK+mEE/rnxCAA6DXIOJLC4bAk7jSH8unoPhSV+POTzLLecWUHPA5+zkhnMnzuXwKItsBuSjqSReD6/1mh2IYQQLU+Cup1LL6hk+ewIooK8WbE11RzYMXFp5uWszf/itcpHmDRlOpUGGDTmbh5epTGo4gjB3SJwd9KTdOwcg3w9KLhYzov519PDw5EAezsy8y7g6axn5/EKfm9/gVcrbmGu3SaOH78FuqtpRJet28WiOXe02e9ACCFsmQR1Oze1j4N58Jlli9ZyMpUV2QuZf61njUFqv9qHYvAbx8mcAk6ehyWTgnkvIQOoXi4uq2TJpGAO71zPq66v82DZoyQ7hrLz4kCWb3mA9T3vYyrwpwndGRh0yfXbQgghWkWjBpNt3LiR/v37ExwczEsvvVTr+VWrVtG1a1fCwsIICwvjnXfeafaCivo1NJIcwN1ZX+fyqCAv7ulzlgXFDxF1zc0kPnMNEdHTWVy+hKx01V0+sJOhlWoihBDiUg22qCsrK3nooYfYvHkz/v7+DB8+nOnTpzNw4MAa291xxx0sX768xQoqGsdyIFp9XeWWy8nZBRAwn0m9oNIAdjqNMX29eXPrILLtArmf70jLyqJPaJtVSQghbFqDQZ2YmEhwcDB9+qhZsGbNmsXXX39dK6hF+1DfSHLLrvL6lqG6Rf67MD++3XsMHGHz7kMMCcmtta0QQoiW12DXd05ODgEBAebH/v7+5OTk1Nru888/JzQ0lNtuu42srKzmLaVoNaYW+dzRvSg32lFm78H0fs41pi8VQgjRehpsURtNt0C0oGlajcfTpk3jzjvvxNHRkRUrVnDXXXfx448/1npdTEwMMTExAGRnZxMbG9voghYVFTVp+46itesdApRlZVFiNOJmD/mVzujyMwnxySI2tnUOwOSzth22WGew3XqLK9NgUPv7+9doIWdnZ+Pr61tjGy8vL/Pyfffdx5NPPlnnvhYuXMjChQsBiIyMZMKECY0uaGxsbJO27yjast6TT+0h97AbA93t6d6KZZDP2nbYYp3BdustrkyDXd/Dhw8nJSWF9PR0ysrKWLNmDdOn17zVw4kTJ8zL33zzDQMGDLh0N8IKTezfjdxKVy6cz23rogghhM1qsEWt1+tZvnw5119/PZWVlSxYsIBBgwbx7LPPEhkZyfTp03nttdf45ptv0Ov1dOnShVWrVrVC0UVLi+7XlW24UV4oYw6EEKKtNGrCk6lTpzJ16tQa655//nnz8osvvsiLL77YvCUTbe7T3Vn0cOqEXWmyeV1Cai7J2QUynagQQrQSuXuWqFeovyfHS51xNRRztvCi+dKtUH/Pti6aEELYDJlCVNQrKsgb+4FB6A4bee7TBOKPG8yTqQghhGgd0qIWlzUsRE10k3w0ndkjAiSkhRCilUlQi/rFLyMr4ygAnSjmve0Z7N++DuKXtXHBmln8MkiPq7kuPa7j1VMIYZUkqEW99mtBdN77BgChXgbGOxzCb/MD7Nc62EAyvwhYO786rNPj1GO/iJZ5v3oODAKOfdEy7yeEsGoS1KJe8RUDORmlRvc/VLqSF8v/yfqQl4ivUPO879++jp0f/KWVC2URcqZly9bv5VrC9bWcc5Jg5ir431xYMQ7WzFGPc5Katv/LvYflaywPDOKXQcJyWDufQvfgxr2HEMKmyGAyUa9F44Ogwh+S/kH3kizKsSP+tzPMLV3Fjiw9IUffIeda1eLev30dRamJjJr39yt7s/hlKsACo6vXmUJ07CPV60whN3OVWl4zR62f9XF1S3jANLUcGF29X4Cz6ZDwGox9DAwVNffl4QcVJXAyGdAg+2fwi6ze/+BbVaDGv6K2N5Vv+2swZkl1uU1lCrkJuvYHnV69xlQmUHW67T1YPQvcukN+OkQv5Zw2pLoOpvcQtVn+rVh+vqa/lUs/F8ttTOubczknSf3U6dXfFTT4fqr3ZELdf+NCXEKCWlxe1i7QdOAVjH3eUV6rfJ7EzDBGVe5hV99HGW1MJX3dP/H7Zbk5tC/7RVnfl6kpNMc+RsCx3yBdVzt0Qf2Mehg+ug36XgeVZaBp8NOLcGq/Cmww74uz6bDt32AwQPTj0HscbHoGOveGbS+r7X2GwhtjVFB3CYKzafDD86B3hoqLan/Ja6G8GMY9oepwIlkF8NjHqt/LUAEevlB+AX5dDfau6jWR90C/KdWhf81z8P0z6rn8NLUu7p9EuAXBz+dUSFsesLS2+oKwsaHVhLAckvw89NLVvR+oO/wsD7jOpqvPEWoeTFl+LqZtjAYY91j15zD+yeZZnvWx+nvY9Ge47h/gE9rgawpDnpCDMtFomrGuu260gsjISHbv3t3o7W11btw2rbflF0nvcRjXL4WfY9CACqMOIxqZ9n3oU5FC5rCnCezsCDo95VtfJtF/PmNOvA9jHobcFDj4tdrn4FvBq2/1l6npp6FCHRBsfpZi5x64Goprh66hQgVz7IvqS/dSmh3c8AJ0DoSE/0LGNtA5gKGs7vppOpj2Kux+F47vAXsXmP0/9T4f3w6GcvAJU9sdT6p+nWtXKD4DoXfA6Icg6UP4+R3Vgj5zGOwcoccQyNkNaIDpv5hOHVQYK9VDvRMMugUOfwsu3qplHXJTdb0bUl8vRGNak5cLwn2fw+F16neemwIHqs6dj38Stv7z8sv1fb717Oeo/wyCsz+vvZ8Z76jPJPYldWDmGwrrHla/z+nLIWsn7HxT9XqcTFa/Y6++cPoADLsb/CPhl1WqZ0Rnrz7L6g8edHbqMzp5AHQa9IyCzB3q4+o1BjLi1T67DYRTB9Tn1n0wnNyndtG1P5w5ov42eo9V5ek3BX7bqA4GU38CzaiWM+LVdv1ugCPrATjhPQaf83uv6KCsqd+dwvpJULdzbVrvS4Jg//Z19N58H0VOPeh0MZsSHOikFVNpBHT2nHHrT/fC/XzETYwcO5l+Ke9iPKW+2DTTl2PX/nDqIFz7Nxj9B9j4FCSuAKfOUJJf8/0H3Qoj71dfuL9+Ai5d4cIZFWqVpTDkdvh1jdrWuy+c2Fvz9S5ecCFPld+pExz6BkKmQeZ28A2DVIs7vOmdYM5atW16nGr5+IarsAAYuQh+fhvcfVUY1AhgC90GQvRSWP9H1ZL++R3oNkC9p1dfuJgPF3JVa33Op+r9EpbDpj9ToXNEbyiBW96CwpMNt2QtAzUtFvpMaHRA1tsKNBphyv+DE3sg8W0IGKWWQQVSeryqum84ZO9WB0yu3lB0Rq138Ybi0xA6C/rfADtXqBDT9GCsUL83BzcoKwZN46KDF85lVXPJO3mq38+VqBXGqPdy6wZFp1T46p0hdQt0DYHiPPW3pOnqPuiD6jLrndTjihJ1MKfZQVkh2DmoA8crFb0UJj3T5JdJUNseGUwm6jf2kRoh7bf5QTKufZsef9rLnr5/wIMLJNgNpwx7KgwGehTuRwPm8i394h/FeGo/WfRAA/DuS7m9u2qdYITNf4UX/VVIgwpp7/7g4MZp79Eq1A98Ae9er0Ia1Berb4R6/azVMOhmtZ3ODq77O9z5P/WFDTDoNvUzeikc36uCLPQO1Xod90eY+yXc8ZH60gWIWlId0mvnqyCLfrz6dxE4DsY9DqcPqv24dFFd7wCB41XIjHwACrJh3RLVUpr0jHqvzAT1mqJT6os9cDzYVZUzPU6F6nX/INd7uFr31QPq55o58Mls8BsGn9ypzml7BavlT+6EPuPVfjf9WQX7pj+rHozh96qW+aZnVJCXFalg3PmG+ll+Ab59DLY8B516wuZn1b5Lz6sA+voBSIxRv+esHSqgKkrg6BaorFo+tkMFmFt3Va8ugdCljwppNEheo36PWTvVNsYK9dn5DFXv4R0Enn44l54GT3/VC3IxXz0fMFLVP/ga+N0b6uAK1IFIrzFqudfYqt/5InD0AHtndWDi1EltB+pAzlCh/gZO7oPsRLV8/rg60Iteqg4aHD1Uq93BHRzd1QGkowc4uKht7BzUv+ilqgdC09Sy3kltN3oxOHeufv8RC6v3NWqxOgVi7woR89RPB3cyA2bA7pW1Bx4KUQcJatEoRamJ5Fz7BoPHTGP/9nWEHH2HXX0fRddrNFnhf8QeA+srh1NgdGFHpbp72peVUXjrS9jd6z5K83MoKS0lznsWFfZuXHTvpc7RBoyk3LETR7rfCLm/wYSnODj4TzD3q+qWTN/rwLmL+nI8c1h9IQZGq+7bWR+rfzlJ6ovV3hl6hMKBz6u2G1ddCXtn1XqMf0V9QTp5goOrCk7Tl6ZpBPil+9/3uTlQ6TZQ7TtlswqF9DhVtikvqa5fE4sQRu9cvT76cbXPtfNh/+fq/aIWc3jg4zDxz6qFt+W56uDc+pIK2/Ji2PVmVfAWwWd3q/DFCKf2qZ+bn4UXfCHpfUCnehQ8A1QYns8B9x6qpyEvRf3s1FOdr6/6LAiapMpoOviIvEeFmYM7jHqoOoDG/VEFVlmRqnvxGSg6rZYtD2KGzKwOy7yj6vx/9FIoPAUXz5HR63a4eE69PnqpOp98+lDVAdYeFd7HEtTjnCQVuKF3qB6K6KUQcmP17zVoIkQ/AWlb1eey79PafwNOnnUvu3VT9UFTv6OGtrdc7ne9OoiL/496/wHTqvfl4VN9MOndX/3UNPK7hKnP3fKyQCHqIYPJRKNYjuY2hfboMWqgV/mau/i39nv8Ozvw1vkQHrf7iLjKwdysS+D/Ls4mM9OHV4xG7O003AZP5ZVYex4v/4jfXCPpm5XIa9o8BmrOOAx7Cv+tL3PE8w9M6BVJhWZPvmtvuqZsVmEXtVh96a6dr7pqLx0pa2oJ5ySpL3PTaGvTOd+cJLUPn9DqbuNZH9dsSVueM7Tcv2WAm7a97h+qpW4Kf59Qdc578Izqc8Cm18Qvq1mOsY9UXwJmeY5y/BOqC//wt9BztGrJpW9VLWQ7B9XLEHKTapmnbFLd0Sf3qVbnwa+gU4AKut7jVBd95L2wq6rXInppzeXdK9V50/hXaj4Xegckf1rdJb5vrVrv4VsVQKgDJxPL0Aocpx5v+nNVWH5WvR/T/i22r9C7NryfS19vecBl+fmaPtNLPxfLbba/1vzLps/6un+ogxLTAd5lXuO+7TMIXFL334AQl5Bz1O1ce693xjf/xwt7XZg/Zy5RuoNcXD2Xf1+4kRmdjvJtcT/u177mu/JI1hlGA3CTbgc32P3MCsPvuMH5MOuL+/O4y3ekTljOnZsdGM5+5jpuZ5ThFx6ufIRbup0kxK8L/vtXsGHAixzvPBz/cz/jXXDAfPCQkJqLbvurjBp3bcOXd5k09nKwulzNay8jNjaWCb2qRrtH3lMdTCMX1b3cf0p1oEYtNp/rps941aqsawRyQ+eooeaAsAHT1IEHNG7Ud33nzevZT9665/Ca9lzt/VxusJvlyHLL33kLfS4t4Wr+X8s5atsjLWpxVTZ6zmL+HE+igrzJ+GYbL1Q+wvAbphNngM46WLShJ7P9czmcG8ZAXw+OpafxnOMTbCjqy9vn1a1TDxb3Jjp2ExfLphCvDWSEXQoxFx+iz/DJnPfvzLRvDzKch/irlsop3XD+sMOdp2+cz96tqdjp4M3YNK4fNBODwRcsbsOZYBhIcqUfi+oqeF1f3IHRjWvZXM1rL6NTfjIkLqu+XKeOFmiNZcuWJVR3szemNXm5VqBlz4Nla8+yfvUtW/Y8RC1W6y6zn32hzzKhof1fynJ7y+1a6HMRoq1Ji7qds6Z6r9iaSqi/Cm3TLTEfmNCHSgPY6eCF7w5zc7gfWw6dAuDGUB++2XscbzcHjp29iJujHcWllXWNpQZAr1PdrhE9O3HgxHkie3Um7rdcnpoSwmB/T+7/8BcAbgr1oU9X16oA7860ob4AxMSlsTC6T61lc7C38b22Uz9YQtC42xp//XJ91yybtNPWpCVr+vtuTtKiFk0hLWrRbCwDLjm7wHxLTFNoP31jCGlnis3bTB/qS1BXV1747jC3VAW4m5OeMT1gxymNIX6exB/NZWL/rpRUGNiRmoePpxO/ZhdQWmFg62/qsp4XNhymq5sDJWWV2Ok00s4UsyYxi3lRvQnz92ThB7+gabBkcrA5zC2Xbwr14e1tqeZgT0hV+60v2Fsq5LN63kpQXefHG2rJ1tdqlNakEB2CBLVoEfWF9oqtqbw1dxgA6349zvcHTtUK8KFd9Qwb1LtGgAMsmRTMR7uO8di1/Xgj9ijRfbvyw+HT+HVyJuV0EY56HSUVBnalnwXg/YQM3rcoU0xcGherwnx3Rj7llQY0NDLyVLAvGNubsIDOdYZ5Y0J++exwVlR1x1dWXZob6u9pfu+GQn99WhkTJtDmLXshRPsiQS1anGXgNCbAYzbsJvlgWq0AHxXkhbuznhe+O8zTN4Zw37gg3t6WWiPQ9XYa00J9+W7fCQb7ebIjNY/RQV4Ul1SQnFOAi4MdF8oq+f7AKfN+d6SqYF8ZnwFkAGqyqg92ZHKhrAINjS+Tcigpr0SnaWw/mkd5hQE0OHq6iDWJWTwwIYjwgM4cyCkwl2+Qr2eTQv/BIXpz78Py2eHN+yEIIayWBLVoM/UF+FcuOpZPqR3gydkFADx9YwiVBtXyfDO2ZqDrNI3pYb4EdXOts0X+XkIGbo56bgn344ukbECdK9+w/yQDfTzYlbF5H44AABHRSURBVH6WiJ6dOHehnLTcYrzdHKgwGDl4ohA7HZRXGok9csZc1p8z1Exab8Sm8kZsKgD2Oo0XvjtsPigAeGdbOhfKKtBpGp/9kkNxqRrJ/N72DC6WVaLTaew+VcHbVSEdFeTd/L9wIYRVkqAW7c7UPg7moLIM8EvDa8XW1CZ1qbs7qz93TYOeXs7oqgan3RzuR9/ubvUGe41lI9w+3J81iVmgwc1hfnzz63H6dnMj6dg5hvfqTGhAJ3al57E/5zwDfTwwGI0cPllIF1d7iksrOXKykB4ejjg76EnPLcbN0Y6i0kp+OGZgUkjXGvWUbnAhhMxMJqzWovFBNQI9KsibqCBvenm5snx2OPeNC6KXlytvzR3GW3OHsf1oXp3L6349bm6ZO9lX/5cwBXuNZQ16eDqh02noNI0bQ31YMjmYPcfOcUu4H6m5xfTwdOT4uRKWTAomK/8COecusmRSMOWVRhz0OpZMCqa4rJLcolKWTApG0zRcHeyw18GPh8/w93UHAMzd4Kbz3EII2yQtatHh1NelbtlStVyu91x5XFqDy5at90oDDPR1r3GO2tQirzP0LZZ1Oo27Bzuw5jcDK7dn8MPh0+QVl/HW3GHmskrrWgjbJEEtbF5Tg72+kAfVHW8K7eTsgiaF/ldbk9jwSDTXvbKVjLwL6HUaFZVG80jySy8fay/XfwshWpYEtRBX4dJwrC8sGxP6ZVkOZOYV46DX0dPLhUMnCpn/XiIjA7uwM+1snRO7tIfrv4UQLUuCWoh24lBeJW9v28PrcyKICvLmtR9SeGXzb+xIU5ePvbDhMF6uDubR4weOn+eTxCwWjgsksneXJl0K9tbcYTz1RTLfJp/grbnDzLPKQeOCvqnLcmAgxJWToBainUgvqGT57AhzKzuyd2fcHPX09nYh/UwxPp5OHD1TTBdXewoulpsvV4vZlk7MtnTzfl7Z9BulFQbsdBqxh89QVmFAA35Or57k5eOdx/jx8Cl0mkZ+cRkDfTyaFPRNXa6v9f/K7os4BNTuCTDV7Uonj5EDCdGRSFAL0U5YXpZmGvEdM08NJrt0YhcXBz23R/qzdnc2IT3cSczIZ3QfL8orDezOzMfH04m8olK2p+aZ97/pYPUkL9/tO2Fefmj1HvOyToM3fkqlqKQCqpaLS9WkL+8nZKplTeODHdXLlus/ScyipKwSTVc1MUzVgcGxvAusScxiflRv+vdw57731VzV1/W0q7fFf+D4lU8e01wHEo0NeWjaQYXMQieaQoJaiHbo0rnSL53YBWDygO708HSq9/pvR3s77h7Tk492ZQIat4b78kVSDgA3DfVl/b4TLBgTSHL2OX46coYhfp5cLK/k6Oki+nV3QwOOnCqil5cLFZUGsvMv0sPDESOQdfYiPp5OAGTnq2Wj0UjamWIc9TpKKww1JoYxHTCYRsGbfHlUTQijAW9tTaOopAIjMG9lIgajke4eTvxz4xG6uTlSXKqee/1HdSChaeo16kAC3ovPMB9UfLTzGBfLKtE02LDvJKXl/7+9u4+J8toTOP4FBvHKywgIigwUYRABEeVFvBu31KHarjZjVHqlUWurjdTSWG1N/M/0xSjtpqm2NdlrdLvWN4wmWxtdsLe23rhQRAvatKgXBSwvrgoICjgMzJz9A5lIFQGFO+PM7/PXeR6eIb9fzmR+z3NmzjlW3Nzg75cabO0fe0Yb3KCqoXsZ2ez0SKbcWx8eFDmzHizsSimyn40i++ufwe3xbipkFToxGAOaR11QUEBMTAx6vZ7c3NwH/t7R0cHixYvR6/WkpaVRXV091HEK4VLunyPeU7T/OC98IPO/x/iOwN3NDXc3CA8c1T3/292N+VPH89dlyfxnYRVnr95ijUFPdWMb1293z/++1mKivqW73dRm5rapyzb/u91sYY1BT2tHF60dXbZ2273zIzTu+I7UsHJmBN4jPBg1woNFyaH4jtTw58gAAF6IH0vGpGAAksP9iRnnS0OrmeixPiSE+tFlVcSM8yU2xJdA7xHUt5h4JnAU+mAfmu92EhXsQ8QYbxpazYQFjGL86D9R32IiRPsnxmm9uNrYjreXBx5ubpT+3ozZYqWjy8r/Xm6wtYuuNNLRZcXUaaW4sgkF/MffK3lrX9m93Cx8XHCJO6Yu7pi62Pq3Cu6Yus9/+rd/cKej+/yru0rYfOwiXp7ubD52kZX/dcb2mk/ue/2/32u3dnRxtNJsK9KyCp3oT7+F2mKxkJOTQ35+PuXl5Rw4cIDy8vJe1+zatQt/f38uX77MunXr2LBhw7AFLISrGaqFXe5v9wzXQvew74yoQNtxf3O+B9ruWRjGw92NRUk61mToKa5sYsG0UIquNFJS3YQxypN/3LhjWxTmWouJ6sZ21hj0XL/dwb/oA+m0KNYY9DS0mvm/ezcP12+buHmnw3Yj0Xy3kzUGPbdNnbabCqsCz3sLzPh6afDx0pD9bCQ+Xh74jtSwOj0Sby8PvL08+EuKDl8vDSnP+APwbPQY/jX63m8FnvEnIdSPNrOFqWGjmTGh+2bjz1GBpEb402VVTNFp+UtKGPGhftzttDIlVEuiTkunRTEtbDRJ4aMxWxRxIX7og3z4rdHK0rRwKdJiQPod+i4pKUGv1xMZ2f3dSlZWFkeOHCEuLs52zZEjR3j//fcByMzM5O2330YphZub2/BELYR4ovnf9y/u8jgLvQy23deyrqPu+wS6v8j/cQOWwSwe89C2W/fw+hjfEbbPpQCf7tEGGOQysg9p7z39Oy8lhnD0l2sDeo0xypO9p39nRlSgFGvRr34LdV1dHWFhYbZjnU7H6dOn+7xGo9Gg1WppbGxkzBh5AwrhqJ600A+m3dfqb7n/fYa/LksFehf2P27AMtjFY4bqRmIgNwKPc1MRG+BBliFRhr/FgLgppdSjLjh06BDHjx9n586dAOzZs4eSkhK++OIL2zXx8fEcP34cnU4HQFRUFCUlJQQGBvb6Xzt27GDHjh0A1NbWkpeXN+BAW1tb8fHxGfD1zsIV83bFnME183aUnP+n0swErQexgR62NkB+lZl/mzDike2qlu4fxLm7gfXep2l/r7948y4LJvlwodFCVYuFuZEjBhzr+vXrOXv27BNmLJ4m/T5R63Q6ampqbMe1tbWMHz/+odfodDq6urpoaWkhICDggf+1atUqVq1aBUBKSgrPPffcgAM9efLkoK53Fq6YtyvmDK6Zt6PkfH8I97dX03/7Ufp6TU/ezyFE//r9MVlqaioVFRVUVVVhNpvJy8vDaDT2usZoNLJ7924ADh8+jMFgkO+nhRBCiCHQ7xO1RqPhyy+/5IUXXsBisbBixQri4+PZuHEjKSkpGI1GVq5cybJly9Dr9QQEBAxqSFsIIYQQfRvQgidz585l7ty5vc59+OGHtvbIkSM5dOjQ0EYmhBBCiIEteCKEEEII+5BCLYQQQjiwfqdnDZcxY8YQEREx4Otv3rxJUFDQ8AXkoFwxb1fMGVwzb1fMGZ4s7+rqahoaGoY4IuHI7FaoByslJcUl5w66Yt6umDO4Zt6umDO4bt7i8cjQtxBCCOHApFALIYQQDszj/Z7dNJ4CycnJ9g7BLlwxb1fMGVwzb1fMGVw3bzF4T8131EIIIYQrkqFvIYQQwoE9FYW6oKCAmJgY9Ho9ubm59g5nWNTU1DBr1ixiY2OJj49n27ZtADQ1NTF79myio6OZPXs2t27dsnOkw8NisTBt2jReeuklAKqqqkhLSyM6OprFixdjNpvtHOHQam5uJjMzk0mTJhEbG8tPP/3kEn392WefER8fz+TJk3nllVcwmUxO19crVqwgODiYyZMn28711bdKKdasWYNer2fKlCmUlpbaK2zhwBy+UFssFnJycsjPz6e8vJwDBw5QXl5u77CGnEaj4dNPP+XChQsUFxezfft2ysvLyc3NJSMjg4qKCjIyMpz2RmXbtm3Exsbajjds2MC6deuoqKjA39+fXbt22TG6offOO+/w4osvcvHiRc6fP09sbKzT93VdXR2ff/45Z8+e5ddff8VisZCXl+d0ff3aa69RUFDQ61xffZufn09FRQUVFRXs2LGD1asHui+XcCnKwRUVFak5c+bYjjdv3qw2b95sx4j+OYxGo/ruu+/UxIkTVX19vVJKqfr6ejVx4kQ7Rzb0ampqlMFgUCdOnFDz5s1TVqtVBQYGqs7OTqXUg++Bp11LS4uKiIhQVqu113ln7+va2lql0+lUY2Oj6uzsVPPmzVMFBQVO2ddVVVUqPj7edtxX365atUrt37//odcJ0cPhn6jr6uoICwuzHet0Ourq6uwY0fCrrq6mrKyMtLQ0rl+/TkhICAAhISHcuHHDztENvbVr1/LJJ5/g7t79dmxsbGT06NFoNN17xjhbn1dWVhIUFMTrr7/OtGnTeOONN2hra3P6vg4NDWX9+vWEh4cTEhKCVqslOTnZqfu6R19964qfb2LwHL5Qq4f8KN2Z97pubW1l0aJFbN26FT8/P3uHM+yOHj1KcHBwr6kqzt7nXV1dlJaWsnr1asrKyvD29na6Ye6HuXXrFkeOHKGqqor6+nra2trIz89/4Dpn6uv+OPt7XQwNhy/UOp2Ompoa23FtbS3jx4+3Y0TDp7Ozk0WLFrFkyRIWLlwIwNixY7l27RoA165dIzg42J4hDrnCwkK+/fZbIiIiyMrK4ocffmDt2rU0NzfT1dUFOF+f63Q6dDodaWlpAGRmZlJaWur0ff39998zYcIEgoKC8PT0ZOHChRQVFTl1X/foq29d6fNNPD6HL9SpqalUVFRQVVWF2WwmLy8Po9Fo77CGnFKKlStXEhsby7vvvms7bzQa2b17NwC7d+9m/vz59gpxWGzZsoXa2lqqq6vJy8vDYDCwb98+Zs2axeHDhwHny3vcuHGEhYVx6dIlAE6cOEFcXJzT93V4eDjFxcW0t7ejlLLl7cx93aOvvjUajXz99dcopSguLkar1dqGyIWwsecX5AN17NgxFR0drSIjI9WmTZvsHc6wOHXqlAJUQkKCSkxMVImJierYsWOqoaFBGQwGpdfrlcFgUI2NjfYOddj8+OOPat68eUoppa5cuaJSU1NVVFSUyszMVCaTyc7RDa2ysjKVnJysEhIS1Pz581VTU5NL9PXGjRtVTEyMio+PV0uXLlUmk8np+jorK0uNGzdOaTQaFRoaqnbu3Nln31qtVvXWW2+pyMhINXnyZHXmzBk7Ry8ckaxMJoQQQjgwhx/6FkIIIVyZFGohhBDCgUmhFkIIIRyYFGohhBDCgUmhFkIIIRyYFGohHsPJkydtO30JIcRwkkIthBBCODAp1MKp7d27l+nTpzN16lSys7OxWCz4+Pjw3nvvkZSUREZGBjdv3gTg3LlzzJgxgylTprBgwQLbnsGXL1/m+eefJzExkaSkJK5cuQJ0r8ves6f0kiVLHrpusxBCPCkp1MJpXbhwgYMHD1JYWMi5c+fw8PBg3759tLW1kZSURGlpKenp6XzwwQcAvPrqq3z88cf88ssvJCQk2M4vWbKEnJwczp8/T1FRkW2Jx7KyMrZu3Up5eTmVlZUUFhbaLVchhPPS2DsAIYbLiRMn+Pnnn0lNTQXg7t27BAcH4+7uzuLFiwFYunQpCxcupKWlhebmZtLT0wFYvnw5L7/8Mnfu3KGuro4FCxYAMHLkSNv/nz59OjqdDoCpU6dSXV3NzJkz/5kpCiFcgBRq4bSUUixfvpwtW7b0Ov/RRx/1On7UtoKPGs728vKytT08PGw7QAkhxFCSoW/htDIyMjh8+DA3btwAoKmpiatXr2K1Wm27Ne3fv5+ZM2ei1Wrx9/fn1KlTAOzZs4f09HT8/PzQ6XR88803AHR0dNDe3m6fhIQQLkmeqIXTiouLY9OmTcyZMwer1Yqnpyfbt2/H29ub3377jeTkZLRaLQcPHgS6tx988803aW9vJzIykq+++groLtrZ2dls3LgRT09PDh06ZM+0hBAuRnbPEi7Hx8eH1tZWe4chhBADIkPfQgghhAOTJ2ohhBDCgckTtRBCCOHApFALIYQQDkwKtRBCCOHApFALIYQQDkwKtRBCCOHApFALIYQQDuz/AT7a+U/UHTPVAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Image(filename='DeepCNN_cifar10_augmented_result/loss.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Image(filename='DeepCNN_cifar10_augmented_result/accuracy.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# もっと簡単にData Augmentationしよう\n",
    "\n",
    "前述のようにデータセット内の各画像についていろいろな変換を行って擬似的にデータを増やすような操作をData Augmentationといいます。上では、オリジナルのデータセットクラスを作る方法を示すために変換の操作も`get_example()`内に書くという実装を行いましたが、実はもっと簡単にいろいろな変換をデータに対して行う方法があります。\n",
    "\n",
    "それは、`TransformDataset`クラスを使う方法です。`TransformDataset`は、元になるデータセットオブジェクトと、そこからサンプルしてきた各データ点に対して行いたい変換を関数の形で与えると、変換済みのデータを返してくれるようなデータセットオブジェクトに加工してくれる便利なクラスです。かんたんな使い方は以下です。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "from chainer.datasets import TransformDataset\n",
    "\n",
    "train_val, test_dataset = cifar.get_cifar10()\n",
    "train_size = int(len(train_val) * 0.9)\n",
    "train_dataset, valid_dataset = split_dataset_random(train_val, train_size, seed=0)\n",
    "\n",
    "\n",
    "# 行いたい変換を関数の形で書く\n",
    "def transform(inputs):\n",
    "    x, t = inputs\n",
    "    x = x.transpose(1, 2, 0)\n",
    "    h, w, _ = x.shape\n",
    "    x_offset = np.random.randint(4)\n",
    "    y_offset = np.random.randint(4)\n",
    "    x = x[y_offset:y_offset + h - 4,\n",
    "          x_offset:x_offset + w - 4]\n",
    "    if np.random.rand() > 0.5:\n",
    "        x = np.fliplr(x)\n",
    "    x = x.transpose(2, 0, 1)\n",
    "    \n",
    "    return x, t\n",
    "\n",
    "\n",
    "# 各データをtransformにくぐらせたものを返すデータセットオブジェクト\n",
    "train_dataset = TransformDataset(train_dataset, transform)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "このようにすると、この新しい`train_dataset`は、上で自分でデータセットクラスごと書いたときと同じような変換を行った上でデータを返してくれるデータセットオブジェクトになります。\n",
    "\n",
    "## ChainerCVでいろいろな変換を簡単に行おう\n",
    "\n",
    "さて、上では画像に対してランダムクロップと、ランダムに左右反転というのをやりました。もっと色々な変換を行いたい場合、上記の`transform`関数に色々な処理を追加していけばよいことになりますが、毎回使いまわすような変換処理をそのたびに書くのは面倒です。何かいいライブラリとか無いのかな、となります。そこで[ChainerCV](http://chainercv.readthedocs.io/en/stable)[[Niitani 2017]](https://arxiv.org/abs/1708.08169)です！今年のACM MultimediaのOpen Source Software CompetitionにWebDNN[[Hidaka 2017]](https://dl.acm.org/citation.cfm?id=3129394)とともに出場していたChainerにComputer Vision向けの便利な機能を色々追加する補助パッケージ的なオープンソース・ソフトウェアです。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: chainercv in /home/shunta/.pyenv/versions/anaconda3-5.0.0/lib/python3.6/site-packages\n",
      "Requirement already satisfied: chainer>=4.0 in /home/shunta/.pyenv/versions/anaconda3-5.0.0/lib/python3.6/site-packages (from chainercv)\n",
      "Requirement already satisfied: Pillow in /home/shunta/.pyenv/versions/anaconda3-5.0.0/lib/python3.6/site-packages (from chainercv)\n",
      "Requirement already satisfied: six>=1.9.0 in /home/shunta/.pyenv/versions/anaconda3-5.0.0/lib/python3.6/site-packages (from chainer>=4.0->chainercv)\n",
      "Requirement already satisfied: numpy>=1.9.0 in /home/shunta/.pyenv/versions/anaconda3-5.0.0/lib/python3.6/site-packages (from chainer>=4.0->chainercv)\n",
      "Requirement already satisfied: filelock in /home/shunta/.pyenv/versions/anaconda3-5.0.0/lib/python3.6/site-packages (from chainer>=4.0->chainercv)\n",
      "Requirement already satisfied: protobuf>=3.0.0 in /home/shunta/.pyenv/versions/anaconda3-5.0.0/lib/python3.6/site-packages (from chainer>=4.0->chainercv)\n",
      "Requirement already satisfied: setuptools in /home/shunta/.pyenv/versions/anaconda3-5.0.0/lib/python3.6/site-packages (from protobuf>=3.0.0->chainer>=4.0->chainercv)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "You are using pip version 9.0.1, however version 10.0.1 is available.\n",
      "You should consider upgrading via the 'pip install --upgrade pip' command.\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "pip install chainercv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[ChainerCV](http://chainercv.readthedocs.io/en/stable)には、画像に対する様々な変換があらかじめ用意されています。\n",
    "\n",
    "- [ChainerCVで使える画像変換一覧](http://chainercv.readthedocs.io/en/stable/reference/transforms.html#image)\n",
    "\n",
    "そのため、上でNumPyを使ってごにょごにょ書いていたランダムクロップやランダム左右反転は、`chainercv.transforms`モジュールを使うと、それぞれ以下のように1行で書くことができます：\n",
    "\n",
    "```python\n",
    "x = transforms.random_crop(x, (28, 28))  # ランダムクロップ\n",
    "x = chainercv.transforms.random_flip(x)  # ランダム左右反転\n",
    "```\n",
    "\n",
    "`chainercv.transforms`モジュールを使って、`transform`関数をアップデートしてみましょう。ちなみに、`get_cifar10()`で得られるデータセットでは、デフォルトで画像の画素値の範囲が`[0, 1]`にスケールされています。しかし、`get_cifar10()`に`scale=255.`を渡しておくと、値の範囲をもともとの`[0, 255]`のままにできます。今回`transform`の中で行う処理は、以下の5つです：\n",
    "\n",
    "1. PCA lighting: これは大雑把に言えば、少しだけ色味を変えるような変換です\n",
    "2. Standardization: 訓練用データセット全体からチャンネルごとの画素値の平均・標準偏差を求めて標準化をします\n",
    "3. Random flip: ランダムに画像の左右を反転します\n",
    "4. Random expand: `[1, 1.5]`からランダムに決めた大きさの黒いキャンバスを作り、その中のランダムな位置へ画像を配置します\n",
    "5. Random crop: `(28, 28)`の大きさの領域をランダムにクロップします"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "from functools import partial\n",
    "from chainercv import transforms\n",
    "\n",
    "train_val, test_dataset = cifar.get_cifar10(scale=255.)\n",
    "train_size = int(len(train_val) * 0.9)\n",
    "train_dataset, valid_dataset = split_dataset_random(train_val, train_size, seed=0)\n",
    "\n",
    "mean = np.mean([x for x, _ in train_dataset], axis=(0, 2, 3))\n",
    "std = np.std([x for x, _ in train_dataset], axis=(0, 2, 3))\n",
    "\n",
    "\n",
    "def transform(inputs, train=True):\n",
    "    img, label = inputs\n",
    "    img = img.copy()\n",
    "    \n",
    "    # Color augmentation\n",
    "    if train:\n",
    "        img = transforms.pca_lighting(img, 76.5)\n",
    "        \n",
    "    # Standardization\n",
    "    img -= mean[:, None, None]\n",
    "    img /= std[:, None, None]\n",
    "    \n",
    "    # Random flip & crop\n",
    "    if train:\n",
    "        img = transforms.random_flip(img, x_random=True)\n",
    "        img = transforms.random_expand(img, max_ratio=1.5)\n",
    "        img = transforms.random_crop(img, (28, 28))\n",
    "        \n",
    "    return img, label\n",
    "\n",
    "train_dataset = TransformDataset(train_dataset, partial(transform, train=True))\n",
    "valid_dataset = TransformDataset(valid_dataset, partial(transform, train=False))\n",
    "test_dataset = TransformDataset(test_dataset, partial(transform, train=False))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ちなみに、`pca_lighting`は、大雑把にいうと色味を微妙に変えた画像を作ってくれる関数です。\n",
    "\n",
    "では、standardizationとChainerCVによるPCA Lightingを追加した`TransformDataset`を使って学習をしてみましょう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch       main/loss   main/accuracy  val/main/loss  val/main/accuracy  elapsed_time  lr        \n",
      "\u001b[J1           2.96298     0.108887       2.28773        0.116992           18.6204       0.1         \n",
      "\u001b[J2           2.28375     0.123069       2.26054        0.145508           35.9189       0.1         \n",
      "\u001b[J3           2.16893     0.173255       1.97104        0.232617           54.1333       0.1         \n",
      "\u001b[J4           1.95599     0.234308       1.96269        0.239453           71.4199       0.1         \n",
      "\u001b[J5           1.84762     0.287482       1.74268        0.316016           89.6395       0.1         \n",
      "\u001b[J6           1.71918     0.344682       1.48986        0.427539           107.843       0.1         \n",
      "\u001b[J7           1.5616      0.420028       1.33444        0.494531           126.049       0.1         \n",
      "\u001b[J8           1.41343     0.48635        1.34962        0.502539           144.103       0.1         \n",
      "\u001b[J9           1.29375     0.542591       1.27011        0.565039           161.386       0.1         \n",
      "\u001b[J10          1.20855     0.577858       1.09895        0.621289           179.561       0.1         \n",
      "\u001b[J11          1.13542     0.603427       1.12695        0.600391           197.048       0.1         \n",
      "\u001b[J12          1.08715     0.626625       0.967723       0.666797           215.84        0.1         \n",
      "\u001b[J13          1.03912     0.645552       1.09458        0.655078           232.916       0.1         \n",
      "\u001b[J14          0.992342    0.661659       0.813403       0.712305           251.279       0.1         \n",
      "\u001b[J15          0.962952    0.676736       0.89199        0.704492           269.464       0.1         \n",
      "\u001b[J16          0.935602    0.687433       0.871531       0.711133           287.93        0.1         \n",
      "\u001b[J17          0.907586    0.694935       0.826585       0.737695           305.05        0.1         \n",
      "\u001b[J18          0.897032    0.699907       0.759569       0.751758           322.843       0.1         \n",
      "\u001b[J19          0.872711    0.70958        0.747807       0.752148           341.134       0.1         \n",
      "\u001b[J20          0.860642    0.710849       0.897129       0.714648           359.493       0.1         \n",
      "\u001b[J21          0.837644    0.720998       0.877011       0.71582            377.873       0.1         \n",
      "\u001b[J22          0.83491     0.719682       0.811209       0.740625           395.061       0.1         \n",
      "\u001b[J23          0.812516    0.730591       0.991357       0.69668            411.923       0.1         \n",
      "\u001b[J24          0.814586    0.728493       0.870199       0.740625           428.436       0.1         \n",
      "\u001b[J25          0.809576    0.730358       0.851287       0.744336           444.849       0.1         \n",
      "\u001b[J26          0.797749    0.73413        1.0621         0.686523           462.494       0.1         \n",
      "\u001b[J27          0.792886    0.737416       0.765583       0.745703           479.124       0.1         \n",
      "\u001b[J28          0.773611    0.74123        0.59921        0.805273           497.053       0.1         \n",
      "\u001b[J29          0.767626    0.742587       1.15419        0.685938           514.952       0.1         \n",
      "\u001b[J30          0.753782    0.749355       0.937311       0.715234           533.238       0.1         \n",
      "\u001b[J31          0.604251    0.797053       0.399113       0.869727           550.994       0.01        \n",
      "\u001b[J32          0.512318    0.827613       0.375138       0.877344           569.219       0.01        \n",
      "\u001b[J33          0.484475    0.834229       0.353442       0.883984           587.753       0.01        \n",
      "\u001b[J34          0.467319    0.841242       0.364244       0.884375           606.206       0.01        \n",
      "\u001b[J35          0.450393    0.846911       0.341441       0.888086           624.712       0.01        \n",
      "\u001b[J36          0.43828     0.848855       0.342883       0.8875             644.334       0.01        \n",
      "\u001b[J37          0.435329    0.851206       0.34381        0.888867           662.547       0.01        \n",
      "\u001b[J38          0.429289    0.852561       0.334433       0.889258           681.356       0.01        \n",
      "\u001b[J39          0.416126    0.857639       0.335736       0.891602           699.445       0.01        \n",
      "\u001b[J40          0.414865    0.857333       0.340546       0.888867           717.644       0.01        \n",
      "\u001b[J41          0.406426    0.85993        0.331028       0.890039           736.169       0.01        \n",
      "\u001b[J42          0.400299    0.864984       0.325277       0.894531           754.238       0.01        \n",
      "\u001b[J43          0.390969    0.863414       0.31114        0.89668            773.074       0.01        \n",
      "\u001b[J44          0.385966    0.867032       0.315048       0.898047           791.369       0.01        \n",
      "\u001b[J45          0.386317    0.868342       0.311667       0.901758           809.057       0.01        \n",
      "\u001b[J46          0.379431    0.869881       0.326095       0.895508           826.949       0.01        \n",
      "\u001b[J47          0.371893    0.871693       0.30523        0.900195           845.462       0.01        \n",
      "\u001b[J48          0.375175    0.869257       0.313753       0.899414           863.334       0.01        \n",
      "\u001b[J49          0.368864    0.872203       0.335674       0.892969           881.266       0.01        \n",
      "\u001b[J50          0.364174    0.874911       0.329148       0.895703           898.805       0.01        \n",
      "\u001b[J51          0.361013    0.876113       0.325556       0.894531           917.536       0.01        \n",
      "\u001b[J52          0.355882    0.876309       0.312672       0.898633           935.827       0.01        \n",
      "\u001b[J53          0.355655    0.877315       0.314614       0.904492           953.22        0.01        \n",
      "\u001b[J54          0.350558    0.878507       0.335558       0.89375            971.412       0.01        \n",
      "\u001b[J55          0.35336     0.879808       0.309912       0.897461           989.554       0.01        \n",
      "\u001b[J56          0.349074    0.878307       0.315572       0.897656           1007.9        0.01        \n",
      "\u001b[J57          0.344636    0.881792       0.315235       0.898633           1026.21       0.01        \n",
      "\u001b[J58          0.351751    0.878361       0.308908       0.90625            1044.43       0.01        \n",
      "\u001b[J59          0.335435    0.885143       0.325415       0.895898           1062.98       0.01        \n",
      "\u001b[J60          0.342543    0.881366       0.307564       0.904492           1081.12       0.01        \n",
      "\u001b[J61          0.296395    0.897061       0.26379        0.914844           1099.85       0.001       \n",
      "\u001b[J62          0.273945    0.905404       0.255291       0.918945           1118          0.001       \n",
      "\u001b[J63          0.256059    0.911111       0.259149       0.918359           1136.27       0.001       \n",
      "\u001b[J64          0.250382    0.913039       0.26012        0.919922           1153.98       0.001       \n",
      "\u001b[J65          0.251402    0.911066       0.252121       0.919922           1172.19       0.001       \n",
      "\u001b[J66          0.246617    0.914795       0.254615       0.917188           1190.44       0.001       \n",
      "\u001b[J67          0.242367    0.916622       0.260114       0.916602           1208.65       0.001       \n",
      "\u001b[J68          0.237993    0.916815       0.251317       0.918359           1227.71       0.001       \n",
      "\u001b[J69          0.233611    0.919627       0.255463       0.92168            1246.66       0.001       \n",
      "\u001b[J70          0.229861    0.920543       0.251819       0.921289           1264.57       0.001       \n",
      "\u001b[J71          0.231212    0.919916       0.256449       0.918359           1282.98       0.001       \n",
      "\u001b[J72          0.230945    0.920388       0.251938       0.922852           1300.6        0.001       \n",
      "\u001b[J73          0.231567    0.918879       0.25467        0.922656           1319.03       0.001       \n",
      "\u001b[J74          0.228168    0.919649       0.25099        0.922266           1336.64       0.001       \n",
      "\u001b[J75          0.223481    0.922452       0.252225       0.921289           1354.76       0.001       \n",
      "\u001b[J76          0.217657    0.923834       0.2558         0.920898           1373.26       0.001       \n",
      "\u001b[J77          0.217563    0.924383       0.247747       0.923828           1392.33       0.001       \n",
      "\u001b[J78          0.216533    0.923722       0.244587       0.923242           1410.24       0.001       \n",
      "\u001b[J79          0.217534    0.924383       0.248184       0.922852           1428.02       0.001       \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[J80          0.217936    0.924435       0.245536       0.923828           1446.1        0.001       \n",
      "\u001b[J81          0.213818    0.925448       0.250882       0.921094           1465.16       0.001       \n",
      "\u001b[J82          0.216617    0.924028       0.245679       0.925586           1483.26       0.001       \n",
      "\u001b[J83          0.211348    0.924991       0.252102       0.923242           1502.12       0.001       \n",
      "\u001b[J84          0.21004     0.92658        0.254647       0.919922           1519.85       0.001       \n",
      "\u001b[J85          0.212658    0.926482       0.252338       0.924219           1539.01       0.001       \n",
      "\u001b[J86          0.210038    0.926824       0.256114       0.921094           1556.43       0.001       \n",
      "\u001b[J87          0.209864    0.927885       0.251901       0.921875           1575.17       0.001       \n",
      "\u001b[J88          0.210507    0.926314       0.253217       0.924414           1593.11       0.001       \n",
      "\u001b[J89          0.201081    0.928911       0.254178       0.925195           1610.7        0.001       \n",
      "\u001b[J90          0.207075    0.92873        0.249093       0.922656           1628.39       0.001       \n",
      "\u001b[J91          0.199509    0.929798       0.248616       0.925              1645.72       0.0001      \n",
      "\u001b[J92          0.199114    0.930467       0.250459       0.922266           1664.97       0.0001      \n",
      "\u001b[J93          0.194366    0.932773       0.250289       0.925781           1682.84       0.0001      \n",
      "\u001b[J94          0.192413    0.933605       0.250086       0.921875           1700.81       0.0001      \n",
      "\u001b[J95          0.195286    0.931374       0.25102        0.925977           1719.84       0.0001      \n",
      "\u001b[J96          0.191748    0.932826       0.247356       0.925391           1738.38       0.0001      \n",
      "\u001b[J97          0.188767    0.935258       0.25027        0.924219           1756.14       0.0001      \n",
      "\u001b[J98          0.190619    0.93517        0.249067       0.925              1774.45       0.0001      \n",
      "\u001b[J99          0.190362    0.934206       0.246483       0.925586           1792.49       0.0001      \n",
      "\u001b[J100         0.193294    0.93295        0.247981       0.926172           1810          0.0001      \n",
      "Test accuracy: 0.92108387\n"
     ]
    }
   ],
   "source": [
    "reset_seed(0)\n",
    "\n",
    "model = train(DeepCNN(10), max_epoch=100, train_dataset=train_dataset, valid_dataset=valid_dataset, test_dataset=test_dataset, postfix='augmented2_', base_lr=0.1, lr_decay=(30, 'epoch'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "わずかに精度が向上しました。他にもネットワークにResNetと呼ばれる有名なアーキテクチャを採用するなど、簡単に試せる改善方法がいくつかあります。ぜひご自分で色々と試してみてください。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# おわりに\n",
    "\n",
    "**Chainerの開発にコミットしてくれる方を歓迎します！**Chainerはオープンソースソフトウェアですので、皆さんが自身で欲しい機能などを提案し、Pull requestを送ることで進化していきます。興味のある方は、こちらの[Contoribution Guide](http://docs.chainer.org/en/latest/contribution.html)をお読みになった後、ぜひIssueを立てたりPRを送ったりしてみてください。お待ちしております。\n",
    "\n",
    "chainer/chainer\n",
    "[https://github.com/chainer/chainer](https://github.com/pfnet/chainer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 参考文献\n",
    "\n",
    "[Tokui 2015] Tokui, S., Oono, K., Hido, S. and Clayton, J., Chainer: a Next-Generation Open Source Framework for Deep Learning, Proceedings of Workshop on Machine Learning Systems(LearningSys) in The Twenty-ninth Annual Conference on Neural Information Processing Systems (NIPS), (2015)\n",
    "\n",
    "[Niitani 2017] Yusuke Niitani, Toru Ogawa, Shunta Saito, Masaki Saito, \"ChainerCV: a Library for Deep Learning in Computer Vision\", ACM Multimedia (ACMMM), Open Source Software Competition, 2017\n",
    "\n",
    "[Hidaka 2017] Masatoshi Hidaka, Yuichiro Kikura, Yoshitaka Ushiku, Tatsuya Harada. WebDNN: Fastest DNN Execution Framework on Web Browser. ACM International Conference on Multimedia (ACMMM), Open Source Software Competition, pp.1213-1216, 2017.\n",
    "\n",
    "#### 脚注\n",
    "\n",
    "[^cudnnenv]: `cudnnenv`は好きなバージョンのcuDNNを簡単に持ってこれるツールです。`pip install cudnnenv`でインストールし、[こちら](https://github.com/unnonouno/cudnnenv#install)にあるインストラクションに従えば、簡単にいろいろなCUDAバージョン向けの様々なバージョンのcuDNNをインストールすることができます。使い方も[こちら](https://github.com/unnonouno/cudnnenv)のREADMEに書いてあるとおり、単純明快です。\n",
    "[^NN]: 学習データに対する予測精度は、もし学習データから抜き出されたあるデータをクエリとし、それが含まれている学習データセットから検索して発見することが必ずできるならば、そのデータについているラベルを答えることで、100%になってしまいます。"
   ]
  }
 ],
 "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}