2_deep_learning_for_features.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SVMやRandom Forest の代わりに深層学習を利用する"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ここでは、SVMやRandom Forestの代わりに、PyTorch を利用した深層学習を実施して、SVM等同様に、細胞状態を予測します。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 深層学習の実行に必要な要素"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "深層学習は、SVM、RandomForest同様に機械学習の一種なので、雰囲気としては、 ``clf=DeepLearning()`` の様な形で書くことが可能です。ところが、今までのSVM等に比べて、以下の点が異なります。\n",
    "\n",
    "* データの読み込みが、メモリに乗らない超大規模な場合を想定しているため、少しずつデータを読み込んで学習する（バッチ）部分を記載する\n",
    "* 学習方法として、訓練データ、テストデータだけでなく、訓練データを（真の）訓練データ（勾配を計算し、次に進む探索方法の利用）とバリデーションデータ（訓練データで出てきたモデルの精度を検証する）に分割する\n",
    "* （ハイパー）パラメータの数が多い。SVMでは、Cやgamma など数個だったが、深層学習では、ネットワークの組み方、学習方法、学習率など、多種多様なパラメータが存在しており、これらを指定する\n",
    "* GPUを利用する場合は、GPUを利用するための記述が必要になる\n",
    "\n",
    "この点こ考慮するため、SVM等に比べて少しプログラムが複雑になります。とはいえ、本質的な流れは変わりませんし、複雑な学習を行わない限りは定形です。順番に見ていきましょう。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ライブラリの読み込み"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "少々長くなりますが、利用するライブラリをまとめて読み込みます。この演習では、深層学習のフレームワークとして、PyTorchを利用します。torch** がPyTorch関連のライブラリです。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torch.optim import lr_scheduler\n",
    "from torchvision import transforms\n",
    "import torch.utils.data as data\n",
    "import torch.nn.functional as F\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn import preprocessing\n",
    "\n",
    "import os\n",
    "import copy\n",
    "import argparse\n",
    "import time\n",
    "import numpy as np\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## データの読み込み"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "データの読み込みに関する関数が二段階に別れます。\n",
    "\n",
    "第一に、学習開始前のデータ読み込みです。一旦すべてのデータを読み込んで、SVMの時同様に利用する特徴量の抽出、正規化といった前処理を実施します。\n",
    "第二に、学習中のデータ読み込みです。こちらでは、深層学習ではすべてのデータを一括で利用するのではなく、「バッチ」と言われる単位ごとに読み込むことで徐々に学習を進めます。バッチを繰り返してすべてのデータを一度利用し終わると、「エポック」が終了します。この「エポック」を複数回繰り返すことで、徐々に学習を進めていきます。\n",
    "\n",
    "<img src=\"img/DL_epoch.png\">\n",
    "\n",
    "以下のプログラムでは、make_dataset 関数が、学習前のデータの一覧表作成を担当しています。\n",
    "学習中の読み込みは、DatasetFoler を利用しており、DatasetFolderの```__getitem__```でバッチごとのデータ生成を行います。この関数は、Pythonの配列アクセス時に呼び出される ```__getitem__``` 関数の上書きで、DatasetFolderクラスの配列にアクセスしようとした時に、自動的に呼び出されます。このため、プログラム中では、``__getitem__``関数を見ることはありません。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 学習前のデータの読み込み"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "まず、学習開始前のデータの読み込みです。\n",
    "\n",
    "```read_csv```でファイルからデータを読み込み、特徴量の選択と正規化するところまでは、今まで通りです。SVM等と異なるのは、クラス（細胞の芽の大きさのグループ）の指定方法です。今までは、\"no\",\"small\"... に 0,1,... を割り当てていましたが、今回は\"no\"を0次元目、\"small\"を1次元目、という形で各次元に割り当て、属するクラスに1を、それ以外は0として指定します。\n",
    "\n",
    "* \"no\" -> [1,0,0,0]\n",
    "* \"small\" -> [0,1,0.0]\n",
    "* \"medium\" -> [0,0,1,0]\n",
    "* \"large\" -> [0.0,0,1]\n",
    "\n",
    "これは、深層学習には各サンプルの特徴量から、\"no\"である確率、\"small\"である確率などの4つの確率を出力させて、最終的に一番確率の高い値のクラスを予測値としよう、という「マルチラベル」を用いた作戦を取るためです。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_dataset(dir):\n",
    "    features = []\n",
    "    labels = []\n",
    "    # データの読み込みと特徴量の選択\n",
    "    dataset = pd.read_csv(os.path.join(dir, \"yeast_his3.csv\"))\n",
    "    columns = [\"C101\", \"C103\", \"C104\", \"C115\", \"A101\", \"A120\", \"A121\", \"A122\", \"A123\"]\n",
    "    cell_features_pre = dataset[[\"Cgroup\"] + columns]\n",
    "    cell_features = cell_features_pre[np.sum(cell_features_pre.isnull(), axis=1) == 0]\n",
    "    X = cell_features[columns]\n",
    "    groups = np.array(cell_features[\"Cgroup\"])\n",
    "    # 正規化\n",
    "    X_norm = preprocessing.StandardScaler().fit_transform(X)\n",
    "    # クラスの指定\n",
    "    for i in range(len(groups)):\n",
    "        group = groups[i]\n",
    "        feature = X_norm[i]\n",
    "        y = [0, 0, 0, 0]\n",
    "        if group == \"no\":\n",
    "            y = [1, 0, 0, 0]\n",
    "        elif group == \"small\":\n",
    "            y = [0, 1, 0, 0]\n",
    "        elif group == \"medium\":\n",
    "            y = [0, 0, 1, 0]\n",
    "        elif group == \"large\":\n",
    "            y = [0, 0, 0, 1]\n",
    "        features.append(np.array(feature.astype(np.float32)))\n",
    "        labels.append(np.array(y))\n",
    "    return features, labels"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### データの分割（Training, Validation, Test）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "SVMでは、データを訓練(Training)データとテスト(Test)データの２つに分割し、訓練データを利用して学習、テストデータを利用して学習結果の予測精度を評価しました。深層学習も基本的に同様ですが、深層学習では、訓練データを更に（真の）訓練データとバリデーション（Validation）データに分割します。深層学習では、真の訓練データで学習を行いつつ、バリデーションデータで精度の確認を実施し、最終的にバリデーションデータで最も性能の良かったモデルを、最終的なモデルとして出力する構造をしているためです。\n",
    "テストデータには学習に利用したサンプルが入っていてはいけないので、訓練データ内の分割を実施することになります。\n",
    "\n",
    "以下の例では、Training:Validation:Test = 3:1:1 になるように分割をしています。\n",
    "\n",
    "* X_train, y_train: 訓練データ (特徴量、クラス)\n",
    "* X_val, y_val: バリデーションデータ\n",
    "* X_test, x_test: テストデータ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# データの読み込み\n",
    "X, y = make_dataset(\"data\")\n",
    "# テストデータの分割\n",
    "X_tmp, X_test, y_tmp, y_test = train_test_split(X, y, test_size = 0.20)\n",
    "# 訓練データとValidationデータの分割\n",
    "X_train, X_val, y_train, y_val = train_test_split(X_tmp, y_tmp, test_size = 0.25)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 学習中のデータの読み込み（バッチごとの読み込み）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "データは、以下のDatasetFolderクラスで格納されます。Xが特徴量、yがクラス（予測したい芽の大きさのグループ）で、それぞれを self.samples と self.targets に格納します。``__getitem__``では、index番目のサンプルを取得し、PyTorchのTensor型に変換して返します。\n",
    "\n",
    "最後の``feature_datasets = ...`` では、上記で分割した訓練データ、バリデーションデータ、テストデータごとにDatasetFolderクラスのインスタンスを作成し、それぞれをfeature_datasets['train']、feature_datasets['val']、feature_datasets['test']に格納します。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DatasetFolder(data.Dataset):\n",
    "    def __init__(self, X, y):\n",
    "        self.samples = X\n",
    "        self.targets = y\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        sample = self.samples[index]\n",
    "        target = self.targets[index]\n",
    "        sample = torch.from_numpy(sample)\n",
    "        target = torch.from_numpy(target)\n",
    "        return sample, target\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.samples)\n",
    "\n",
    "feature_datasets = {\n",
    "    'train':DatasetFolder(X_train, y_train),\n",
    "    'val':DatasetFolder(X_val, y_val),\n",
    "    'test': DatasetFolder(X_test, y_test)\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "確認してみましょう。訓練データの一つのサンプルに関して、9次元の特徴量ベクトル（正規化後のもの）とクラス情報が現れます。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([-0.8638, -0.9000, -0.8344,  0.0545, -0.1427, -0.1827,  0.2094, -0.7443,\n",
      "        -0.5114])\n",
      "tensor([0, 1, 0, 0])\n"
     ]
    }
   ],
   "source": [
    "sample, target = feature_datasets['train'][0]\n",
    "print(sample)\n",
    "print(target)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "このDatasetFolderの情報は、学習時には1個1個ではなく、以下のdataloadersを通じて、バッチサイズ毎(以下の例では64サンプル。batch_sizeで指定)にまとめて読み込まれます。workers は、データの読み込みを複数CPUを利用して並列化する場合の並列数を示しています。0を指定することで、並列化は止めています。（並列化して読み込むことで、処理速度の向上が期待できますが、一方でデバッグが大変になるので、全てのプログラムが作成できてから、worker数は変更すると良いでしょう）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# バッチサイズ分のデータを読み込む。\n",
    "# 訓練データ（train）はshuffle=Trueを指定することで、\n",
    "# データの順番をシャッフルし、読み込む順番をランダムにする。\n",
    "# 他はシャッフルの必要なし。\n",
    "batch_size=64\n",
    "workers=0\n",
    "dataloaders = {\n",
    "    # 訓練データ\n",
    "    'train': torch.utils.data.DataLoader(\n",
    "        feature_datasets['train'],\n",
    "        batch_size=batch_size,\n",
    "        shuffle=True,\n",
    "        num_workers=workers),\n",
    "    # バリデーションデータ\n",
    "    'val': torch.utils.data.DataLoader(\n",
    "        feature_datasets['val'],\n",
    "        batch_size=batch_size,\n",
    "        shuffle=False,\n",
    "        num_workers=workers),\n",
    "    # テストデータ\n",
    "    'test': torch.utils.data.DataLoader(\n",
    "        feature_datasets['test'],\n",
    "        batch_size=batch_size,\n",
    "        shuffle=False,\n",
    "        num_workers=workers)\n",
    "}\n",
    "dataset_sizes = {x: len(feature_datasets[x]) for x in ['train', 'val', 'test']}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## （深層）学習モデルの定義"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "深層学習のモデルの定義を（やっと）行います。ここでは、全く深い層ではなく、中間層1層だけのニューラルネットワークを組んで、学習してみます。\n",
    "\n",
    "入力の特徴量数が9個、中間層のノードが9個、最終層がクラスを判別する4個(no, small, medium, large)のネットワークを考えます。設定は至ってシンプルで、層の名前と形式を定義する部分(以下の``__init__``内のLinear2つ)と、それらの組み合わせを与える部分(``forward``関数内)から構成されます。これで\n",
    "特徴量9個→完全連結の層(Fully Connected (FC)層と言われます)→出力層\n",
    "という中間層１層を含む３層構造のネットワークが出来ます。活性化関数（各層の入力と出力の関係）として、ここではReLuを利用しています。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Net(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Net, self).__init__()\n",
    "        self.fc1 = nn.Linear(9, 9)\n",
    "        self.fc2 = nn.Linear(9, 4)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = self.fc2(x)\n",
    "        return x\n",
    "\n",
    "# ここから先は、作成したネットワークを、指定のデバイスに送るための内容。\n",
    "# CPUではなく、GPUを利用したい場合は、\"cuda\" もしくは、\"cuda:0\" などと\n",
    "# 設定を記載。\n",
    "device_name = \"cpu\"\n",
    "device = torch.device(device_name)\n",
    "model = Net()\n",
    "model = model.to(device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 学習ステップの定義"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "今までの説明で、基本的な深層学習の定義は終了していますが、最後に学習ステップ自身の定義を行います。プログラムは少し長いですが、エポックとバッチをforループでまわし（for epoch in...）、エポック終了と共に途中経過を表示するルーチンを書いてあるだけの、定形の処理です。\n",
    "\n",
    "forループ内は、\n",
    "* for epoch in...: エポックのfor loop. 指定したエポック数を回す。\n",
    "* for inputs, labels in...: バッチのfor loop. 全てのデータを1度読み込むまで、バッチサイズ数順読み込む\n",
    "という二重のループが回って、順番に処理が行われます。\n",
    "\n",
    "```inputs = inputs.to(device)```と```labels = labels.to(device)```は、データをGPU(もしくはCPU)に送るための処理。```outputs = model(inputs)``` で、現在のモデルの精度を計算し、実質的な学習は、``` loss.backward()```と```optimizer.step()```の2行のみです。残りは、エポックごとの精度を計算するための処理となります。\n",
    "\n",
    "より高度な処理（重みの更新を、状況に応じて一部止めるなど）は、この記載に追記していくことになります。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_model(model, criterion, optimizer, scheduler, num_epochs=25):\n",
    "    since = time.time()\n",
    "    # 途中経過でモデル保存するための初期化\n",
    "    best_model_wts = copy.deepcopy(model.state_dict())\n",
    "    best_acc = 0.0\n",
    "    # 時間計測用\n",
    "    end = time.time()\n",
    "\n",
    "    print(model)\n",
    "    print()\n",
    "\n",
    "    for epoch in range(num_epochs):\n",
    "        print('Epoch:{}/{}'.format(epoch, num_epochs - 1), end=\"\")\n",
    "\n",
    "        # 各エポックで訓練+バリデーションを実行\n",
    "        for phase in ['train', 'val']:\n",
    "            if phase == 'train':\n",
    "                scheduler.step()\n",
    "                model.train(True)  # training mode\n",
    "            else:\n",
    "                model.train(False)  # evaluate mode\n",
    "\n",
    "            running_loss = 0.0\n",
    "            running_corrects = 0\n",
    "\n",
    "            for inputs, labels in dataloaders[phase]:\n",
    "                labels = labels.float()\n",
    "                inputs = inputs.to(device)\n",
    "                labels = labels.to(device)\n",
    "\n",
    "                optimizer.zero_grad()\n",
    "\n",
    "                # 訓練のときだけ履歴を保持する\n",
    "                with torch.set_grad_enabled(phase == 'train'):\n",
    "                    outputs = model(inputs)\n",
    "                    _, classnums = torch.max(labels, 1)\n",
    "                    _, preds = torch.max(outputs, 1)\n",
    "                    loss = criterion(outputs, classnums)\n",
    "                    # backward + optimize only if in training phase\n",
    "                    if phase == 'train':\n",
    "                        loss.backward()\n",
    "                        optimizer.step()\n",
    "\n",
    "                # 統計情報\n",
    "                running_loss += loss.item() * inputs.size(0)\n",
    "                running_corrects += torch.sum(preds == classnums)\n",
    "\n",
    "            # サンプル数で割って平均を求める\n",
    "            epoch_loss = running_loss / dataset_sizes[phase]\n",
    "            epoch_acc = running_corrects.double() / dataset_sizes[phase]\n",
    "\n",
    "            print('\\t{} Loss: {:.4f} Acc: {:.4f} Time: {:.4f}'.format(phase, epoch_loss, epoch_acc, time.time()-end), end=\"\")\n",
    "\n",
    "            # 精度が改善したらモデルを保存する\n",
    "            if phase == 'val' and epoch_acc > best_acc:\n",
    "                best_acc = epoch_acc\n",
    "                best_model_wts = copy.deepcopy(model.state_dict())\n",
    "            end = time.time()\n",
    "\n",
    "        print()\n",
    "\n",
    "    time_elapsed = time.time() - since\n",
    "    print()\n",
    "    print('Training complete in {:.0f}m {:.0f}s'.format(time_elapsed // 60, time_elapsed % 60))\n",
    "    print('Best val acc: {:.4f}'.format(best_acc))\n",
    "\n",
    "    # load best model weights\n",
    "    model.load_state_dict(best_model_wts)\n",
    "    return model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "最後に、テストデータでの結果の評価を表示するための関数を定義します。テストデータ上で、一回のエポックを回すのと、同様の処理です。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_test_accuracy(model, criterion, optimizer, phase):\n",
    "    running_loss = 0.0\n",
    "    running_corrects = 0\n",
    "    model.train(False)\n",
    "\n",
    "    for inputs, labels in dataloaders[phase]:\n",
    "        labels = labels.float()\n",
    "        inputs = inputs.to(device)\n",
    "        labels = labels.to(device)\n",
    "        \n",
    "        # 訓練のときだけ履歴を保持する\n",
    "        with torch.set_grad_enabled(phase == 'train'):\n",
    "            outputs = model(inputs)\n",
    "            _, classnums = torch.max(labels, 1)\n",
    "            _, preds = torch.max(outputs, 1)\n",
    "            loss = criterion(outputs, classnums)\n",
    "\n",
    "        # 統計情報\n",
    "        running_loss += loss.item() * inputs.size(0)\n",
    "        running_corrects += torch.sum(preds == classnums)\n",
    "\n",
    "    # サンプル数で割って平均を求める\n",
    "    epoch_loss = running_loss / dataset_sizes[phase]\n",
    "    epoch_acc = running_corrects.double() / dataset_sizes[phase]\n",
    "    print('On Test:\\tLoss: {:.4f} Acc: {:.4f}'.format(epoch_loss, epoch_acc))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "これで準備は終了です。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 深層学習の実行"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "下記のコードで、これまでに定義したモデルの学習が可能です。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Net(\n",
      "  (fc1): Linear(in_features=9, out_features=9, bias=True)\n",
      "  (fc2): Linear(in_features=9, out_features=4, bias=True)\n",
      ")\n",
      "\n",
      "Epoch:0/19\ttrain Loss: 1.3432 Acc: 0.3694 Time: 0.0504\tval Loss: 1.3496 Acc: 0.3467 Time: 0.0026\n",
      "Epoch:1/19\ttrain Loss: 1.1932 Acc: 0.5135 Time: 0.0070\tval Loss: 1.2467 Acc: 0.4800 Time: 0.0019\n",
      "Epoch:2/19\ttrain Loss: 1.0537 Acc: 0.5631 Time: 0.0058\tval Loss: 1.1660 Acc: 0.4933 Time: 0.0022\n",
      "Epoch:3/19\ttrain Loss: 0.9449 Acc: 0.5811 Time: 0.0063\tval Loss: 1.0687 Acc: 0.4933 Time: 0.0013\n",
      "Epoch:4/19\ttrain Loss: 0.8023 Acc: 0.6171 Time: 0.0043\tval Loss: 0.9655 Acc: 0.4400 Time: 0.0017\n",
      "Epoch:5/19\ttrain Loss: 0.7214 Acc: 0.6441 Time: 0.0061\tval Loss: 0.9459 Acc: 0.4533 Time: 0.0015\n",
      "Epoch:6/19\ttrain Loss: 0.6594 Acc: 0.6622 Time: 0.0046\tval Loss: 0.8860 Acc: 0.5200 Time: 0.0013\n",
      "Epoch:7/19\ttrain Loss: 0.6063 Acc: 0.7027 Time: 0.0049\tval Loss: 0.8321 Acc: 0.5333 Time: 0.0014\n",
      "Epoch:8/19\ttrain Loss: 0.5439 Acc: 0.7748 Time: 0.0038\tval Loss: 0.8128 Acc: 0.5467 Time: 0.0014\n",
      "Epoch:9/19\ttrain Loss: 0.5038 Acc: 0.7928 Time: 0.0038\tval Loss: 0.7929 Acc: 0.5467 Time: 0.0010\n",
      "Epoch:10/19\ttrain Loss: 0.4572 Acc: 0.8063 Time: 0.0052\tval Loss: 0.7588 Acc: 0.6000 Time: 0.0012\n",
      "Epoch:11/19\ttrain Loss: 0.4304 Acc: 0.8108 Time: 0.0037\tval Loss: 0.7241 Acc: 0.6267 Time: 0.0009\n",
      "Epoch:12/19\ttrain Loss: 0.4030 Acc: 0.8243 Time: 0.0035\tval Loss: 0.7003 Acc: 0.6533 Time: 0.0010\n",
      "Epoch:13/19\ttrain Loss: 0.3805 Acc: 0.8468 Time: 0.0051\tval Loss: 0.6841 Acc: 0.6267 Time: 0.0015\n",
      "Epoch:14/19\ttrain Loss: 0.3635 Acc: 0.8378 Time: 0.0051\tval Loss: 0.6608 Acc: 0.6533 Time: 0.0014\n",
      "Epoch:15/19\ttrain Loss: 0.3406 Acc: 0.8649 Time: 0.0051\tval Loss: 0.6305 Acc: 0.6800 Time: 0.0021\n",
      "Epoch:16/19\ttrain Loss: 0.3273 Acc: 0.8694 Time: 0.0037\tval Loss: 0.5990 Acc: 0.7067 Time: 0.0013\n",
      "Epoch:17/19\ttrain Loss: 0.3089 Acc: 0.8784 Time: 0.0032\tval Loss: 0.5775 Acc: 0.6933 Time: 0.0011\n",
      "Epoch:18/19\ttrain Loss: 0.2959 Acc: 0.8964 Time: 0.0040\tval Loss: 0.5480 Acc: 0.7067 Time: 0.0016\n",
      "Epoch:19/19\ttrain Loss: 0.2839 Acc: 0.9144 Time: 0.0049\tval Loss: 0.5250 Acc: 0.7467 Time: 0.0011\n",
      "\n",
      "Training complete in 0m 0s\n",
      "Best val acc: 0.7467\n",
      "On Test:\tLoss: 0.4865 Acc: 0.8000\n"
     ]
    }
   ],
   "source": [
    "epochs = 20\n",
    "batch_size = 64\n",
    "lr = 0.1\n",
    "momentum = 0.9\n",
    "outdir = \".\"\n",
    "\n",
    "# 損失関数（クロスエントロピー）、\n",
    "# パラメータの最適化方法、学習率の更新方法を定義。\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = optim.SGD(model.parameters(), lr=lr, momentum=momentum)\n",
    "exp_lr_scheduler = lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.7)\n",
    "\n",
    "# 実際の学習を実施\n",
    "model = train_model(model, criterion, optimizer, exp_lr_scheduler, num_epochs=epochs)\n",
    "# テストデータでの精度を求める\n",
    "print_test_accuracy(model, criterion, optimizer, 'test')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "エポックが一つ終わるごとに、下記の情報を出力しています。\n",
    "* 予測したクラスと正解のクラスの誤差（ロス）\n",
    "    * 評価関数で定義しているクロスエントロピーの値\n",
    "    * 訓練データにおけるロス train Loss と、評価データにおけるロスval Loss\n",
    "* 予測精度（Accuracy; Acc)\n",
    "* 実行時間\n",
    "\n",
    "はじめの数エポックでは、訓練データでもバリデーションデータでも精度が6割くらいと高くありませんが、20エポック終わる頃には、9割近い精度を挙げています。\n",
    "\n",
    "この精度が独立データ（テストデータ）でも同様かどうかが、最後に計算されており、精度が8割程度（実行の度に異なりますので、これらの値は、皆さんの手元では異なるかもしれません）であることがわかります。\n",
    "\n",
    "今回の実行時の先頭に、学習時の主要なパラメータが記載されています。\n",
    "\n",
    "```python\n",
    "epochs = 20\n",
    "batch_size = 64\n",
    "lr = 0.1\n",
    "momentum = 0.9\n",
    "```\n",
    "\n",
    "epochsはエポック数(エポックを何回繰り返すか)、batch_sizeは各バッチで利用するサンプル数、lr は学習率と呼ばれ、一回の学習でどれだけ一気に学習を進めるか、momentum は、今回利用している学習方法であるSGDにおいて利用するパラメータで、慣性を表している値です。いずれの値にも正解はなく、利用しているネットワークモデルや、データの種類に応じて、適切なパラメータを見つける必要があります。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以上の処理を全て記載したプログラムが、\"src/yeast_feature_cnn.py\" にあります。シェルから\n",
    "```bash\n",
    "$ python src/yeast_feature_cnn.py data -b 64 --lr 0.1 --epoch 20 -j 0\n",
    "```\n",
    "の様な形で実行可能です。Jupyterで示したものからの変更点は\n",
    "* コマンドラインオプションの処理\n",
    "* 学習中、学習後のモデルの保存\n",
    "\n",
    "です。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以上で、SVMやRandom Forestの代わりに深層学習を利用する学習方法は終了です。次に、特徴量を抽出せずに、直接画像から学習する方法に進みましょう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}