reddit12k (11 classes).ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Populating the interactive namespace from numpy and matplotlib\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import sys\n",
    "import numpy as np\n",
    "import time\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch.autograd import Variable\n",
    "from torch.nn.parameter import Parameter\n",
    "\n",
    "from collections import defaultdict\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.model_selection import StratifiedShuffleSplit, StratifiedKFold\n",
    "from sklearn.preprocessing.label import LabelEncoder\n",
    "\n",
    "from torch import Tensor, LongTensor\n",
    "from torch.utils.data import DataLoader, Sampler\n",
    "from torch import optim\n",
    "from torch.optim.lr_scheduler import ExponentialLR, LambdaLR\n",
    "\n",
    "from IPython.display import clear_output\n",
    "%pylab inline\n",
    "\n",
    "from slayer import SLayer\n",
    "from train_functions import *\n",
    "from src.sharedCode.provider import Provider\n",
    "from src.sharedCode.experiments import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mon Mar 18 13:03:53 2019       \n",
      "+-----------------------------------------------------------------------------+\n",
      "| NVIDIA-SMI 396.44                 Driver Version: 396.44                    |\n",
      "|-------------------------------+----------------------+----------------------+\n",
      "| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n",
      "| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n",
      "|===============================+======================+======================|\n",
      "|   0  Tesla P100-PCIE...  On   | 00000000:05:00.0 Off |                    0 |\n",
      "| N/A   29C    P0    32W / 250W |  15639MiB / 16280MiB |      0%      Default |\n",
      "+-------------------------------+----------------------+----------------------+\n",
      "|   1  Tesla P100-PCIE...  On   | 00000000:08:00.0 Off |                    0 |\n",
      "| N/A   29C    P0    43W / 250W |  16161MiB / 16280MiB |    100%      Default |\n",
      "+-------------------------------+----------------------+----------------------+\n",
      "|   2  Tesla P100-PCIE...  On   | 00000000:0D:00.0 Off |                    0 |\n",
      "| N/A   28C    P0    32W / 250W |   3444MiB / 16280MiB |      0%      Default |\n",
      "+-------------------------------+----------------------+----------------------+\n",
      "|   3  Tesla P100-PCIE...  On   | 00000000:13:00.0 Off |                    0 |\n",
      "| N/A   24C    P0    34W / 250W |    709MiB / 16280MiB |      0%      Default |\n",
      "+-------------------------------+----------------------+----------------------+\n",
      "|   4  Tesla P100-PCIE...  On   | 00000000:83:00.0 Off |                    0 |\n",
      "| N/A   36C    P0   106W / 250W |   9097MiB / 16280MiB |     91%      Default |\n",
      "+-------------------------------+----------------------+----------------------+\n",
      "|   5  Tesla P100-PCIE...  On   | 00000000:89:00.0 Off |                    0 |\n",
      "| N/A   28C    P0    30W / 250W |   5257MiB / 16280MiB |      0%      Default |\n",
      "+-------------------------------+----------------------+----------------------+\n",
      "|   6  Tesla P100-PCIE...  On   | 00000000:8E:00.0 Off |                    0 |\n",
      "| N/A   23C    P0    32W / 250W |   3543MiB / 16280MiB |     14%      Default |\n",
      "+-------------------------------+----------------------+----------------------+\n",
      "|   7  Tesla P100-PCIE...  On   | 00000000:91:00.0 Off |                    0 |\n",
      "| N/A   25C    P0    31W / 250W |   5743MiB / 16280MiB |      0%      Default |\n",
      "+-------------------------------+----------------------+----------------------+\n",
      "                                                                               \n",
      "+-----------------------------------------------------------------------------+\n",
      "| Processes:                                                       GPU Memory |\n",
      "|  GPU       PID   Type   Process name                             Usage      |\n",
      "|=============================================================================|\n",
      "+-----------------------------------------------------------------------------+\n"
     ]
    }
   ],
   "source": [
    "!nvidia-smi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "cuda_n = 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class UpperDiagonalThresholdedLogTransform:\n",
    "    def __init__(self, nu):\n",
    "        self.b_1 = (torch.Tensor([1, 1]) / np.sqrt(2))\n",
    "        self.b_2 = (torch.Tensor([-1, 1]) / np.sqrt(2))\n",
    "        self.nu = nu\n",
    "\n",
    "    def __call__(self, dgm):\n",
    "        \n",
    "#         if dgm.ndimension() == 0:\n",
    "        if dgm.ndimension() <= 1:\n",
    "            return dgm\n",
    "\n",
    "        if dgm.is_cuda:\n",
    "            self.b_1 = self.b_1.cuda()\n",
    "            self.b_2 = self.b_2.cuda()\n",
    "\n",
    "#         start_time = time.time()\n",
    "        x = torch.mul(dgm, self.b_1.repeat(dgm.size(0), 1))\n",
    "        x = torch.sum(x, 1)\n",
    "        y = torch.mul(dgm, self.b_2.repeat(dgm.size(0), 1))\n",
    "        y = torch.sum(y, 1)\n",
    "        i = (y <= self.nu)\n",
    "        y[i] = torch.log(y[i] / self.nu) + self.nu\n",
    "        ret = torch.stack([x, y], 1)\n",
    "#         print(\"upper diag threshold computation - {:.3f}s\".format(time.time() - start_time))\n",
    "        return ret\n",
    "\n",
    "\n",
    "def pers_dgm_center_init(n_elements):\n",
    "    centers = []\n",
    "    while len(centers) < n_elements:\n",
    "        x = np.random.rand(2)\n",
    "        if x[1] > x[0]:\n",
    "            centers.append(x.tolist())\n",
    "\n",
    "    return torch.Tensor(centers)\n",
    "\n",
    "\n",
    "def reduce_essential_dgm(dgm):\n",
    "\n",
    "    if dgm.ndimension() == 0:\n",
    "        return dgm\n",
    "    elif dgm.ndimension() == 1:\n",
    "        return dgm[:].contiguous().view(-1, 1)\n",
    "    else:\n",
    "        return dgm[:, 0].contiguous().view(-1, 1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def _data_setup(params):\n",
    "    subscripted_views = ['DegreeVertexFiltration_dim_0',\n",
    "                         'DegreeVertexFiltration_dim_0_essential',\n",
    "                         'DegreeVertexFiltration_dim_1_essential'\n",
    "                         ]\n",
    "\n",
    "    print('Loading provider...')\n",
    "    dataset = Provider()\n",
    "    dataset.read_from_h5(params['data_path'])\n",
    "\n",
    "    assert all(view_name in dataset.view_names for view_name in subscripted_views)\n",
    "\n",
    "    print('Create data loader...')\n",
    "    data_train, data_test = train_test_from_dataset(dataset,\n",
    "                                                    test_size=params['test_ratio'],\n",
    "                                                    batch_size=params['batch_size'])\n",
    "\n",
    "    return data_train, data_test, subscripted_views"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyModel(torch.nn.Module):\n",
    "    def __init__(self, subscripted_views):\n",
    "        super(MyModel, self).__init__()\n",
    "        self.subscripted_views = subscripted_views\n",
    "        self.transform = UpperDiagonalThresholdedLogTransform(0.1)\n",
    "\n",
    "        def get_init(n_elements):\n",
    "            return self.transform(pers_dgm_center_init(n_elements))\n",
    "\n",
    "        self.dim_0 = SLayer(150, 2, get_init(150), torch.ones(150, 2) * 3)\n",
    "        self.dim_0_ess = SLayer(50, 1)\n",
    "        self.dim_1_ess = SLayer(50, 1)\n",
    "        self.slayers = [self.dim_0,\n",
    "                        self.dim_0_ess,\n",
    "                        self.dim_1_ess\n",
    "                        ]\n",
    "\n",
    "        self.stage_1 = []\n",
    "        stage_1_outs = [75, 25, 25]\n",
    "\n",
    "        for i, (n_in, n_out) in enumerate(zip([150, 50, 50], stage_1_outs)):\n",
    "            seq = nn.Sequential()\n",
    "            seq.add_module('linear_1', nn.Linear(n_in, n_out))\n",
    "            seq.add_module('batch_norm', nn.BatchNorm1d(n_out))\n",
    "            seq.add_module('drop_out_1', nn.Dropout(0.1))\n",
    "            seq.add_module('linear_2', nn.Linear(n_out, n_out))\n",
    "            seq.add_module('relu', nn.ReLU())\n",
    "            seq.add_module('drop_out_2', nn.Dropout(0.1))\n",
    "\n",
    "            self.stage_1.append(seq)\n",
    "            self.add_module('stage_1_{}'.format(i), seq)\n",
    "\n",
    "        linear_1 = nn.Sequential()\n",
    "        linear_1.add_module('linear_1', nn.Linear(sum(stage_1_outs), 200))\n",
    "        linear_1.add_module('batchnorm_1', torch.nn.BatchNorm1d(200))\n",
    "        linear_1.add_module('relu_1', nn.ReLU())\n",
    "        linear_1.add_module('linear_2', nn.Linear(200, 100))\n",
    "        linear_1.add_module('batchnorm_2', torch.nn.BatchNorm1d(100))\n",
    "        linear_1.add_module('drop_out_2', torch.nn.Dropout(0.1))\n",
    "        linear_1.add_module('relu_2', nn.ReLU())\n",
    "        linear_1.add_module('linear_3', nn.Linear(100, 50))\n",
    "        linear_1.add_module('batchnorm_3', nn.BatchNorm1d(50))\n",
    "        linear_1.add_module('relu_3', nn.ReLU())\n",
    "        linear_1.add_module('linear_4', nn.Linear(50, 11))\n",
    "        linear_1.add_module('batchnorm_4', nn.BatchNorm1d(11))\n",
    "        self.linear_1 = linear_1\n",
    "\n",
    "    def forward(self, batch):\n",
    "        \n",
    "        x = [batch[n] for n in self.subscripted_views]\n",
    "\n",
    "        x = [\n",
    "            [self.transform(dgm) for dgm in x[0]],\n",
    "            [reduce_essential_dgm(dgm) for dgm in x[1]],\n",
    "            [reduce_essential_dgm(dgm) for dgm in x[2]]\n",
    "        ]\n",
    "\n",
    "        x_sl = [l(xx) for l, xx in zip(self.slayers, x)]\n",
    "\n",
    "        x = [l(xx) for l, xx in zip(self.stage_1, x_sl)]\n",
    "\n",
    "        x = torch.cat(x, 1)\n",
    "\n",
    "        x = self.linear_1(x)\n",
    "\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_one_epoch(model, optimizer, train_data, params, criterion, variable_created_by_model):\n",
    "    \n",
    "    # training\n",
    "    train_loss = []\n",
    "    train_preds = []\n",
    "    train_targets = []\n",
    "    model.train(True)\n",
    "    for i, (batch_input, batch_target) in enumerate(train_data, start=1):\n",
    "        \n",
    "        # transform input to tensor\n",
    "        batch_input, batch_target = data_typing(batch_input, batch_target, params)\n",
    "\n",
    "        if not variable_created_by_model:\n",
    "            batch_input = Variable(batch_input)\n",
    "        batch_target = Variable(batch_target)\n",
    "        \n",
    "#         start_time = time.time()\n",
    "        optimizer.zero_grad()\n",
    "        batch_output = model(batch_input)\n",
    "#         print(\"forward pass - {:3f}s\".format(time.time() - start_time))\n",
    "        loss = criterion(batch_output, batch_target)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        \n",
    "        train_loss.append(loss.item())\n",
    "        train_preds.extend(list(compute_labels(batch_output)))\n",
    "        train_targets.extend(list(batch_target.cpu().data.numpy()))\n",
    "    \n",
    "    return train_loss, train_preds, train_targets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(model, optimizer, train_data, val_data, params, metric=accuracy_score, criterion=nn.CrossEntropyLoss(), variable_created_by_model=True):\n",
    "    \n",
    "    mean_train_loss = []\n",
    "    mean_val_loss = []\n",
    "    mean_train_metric = []\n",
    "    mean_val_metric = []\n",
    "\n",
    "    scheduler = LambdaLR(optimizer, lr_lambda=lambda epoch: 0.5 ** (epoch // params[\"lr_ep_step\"]))\n",
    "    \n",
    "    for epoch in range(params[\"epochs\"]):\n",
    "        epoch_start_time = time.time()\n",
    "        \n",
    "        scheduler.step()\n",
    "        print(\"current lr = {}\".format(scheduler.get_lr()[0]))\n",
    "        \n",
    "        start_time = time.time()\n",
    "        train_loss, train_preds, train_targets = train_one_epoch(\n",
    "            model, optimizer, train_data, params, criterion, variable_created_by_model)\n",
    "        print(\"train epoch - {:.3f}s\".format(time.time() - start_time))\n",
    "        start_time = time.time()\n",
    "        val_loss, val_preds, val_targets = validate(\n",
    "            model, val_data, params, criterion, variable_created_by_model)\n",
    "        print(\"validate - {:3f}s\".format(time.time() - start_time))\n",
    "\n",
    "        # print the results for this epoch:\n",
    "        mean_train_loss.append(np.mean(train_loss))\n",
    "        mean_val_loss.append(np.mean(val_loss))\n",
    "        mean_train_metric.append(metric(train_targets, train_preds))\n",
    "        mean_val_metric.append(metric(val_targets, val_preds))\n",
    "        \n",
    "        clear_output(True)\n",
    "        plt.figure(figsize=(10, 5))\n",
    "        plt.subplot(121)\n",
    "        plt.plot(mean_train_loss)\n",
    "        plt.plot(mean_val_loss)\n",
    "        plt.subplot(122)\n",
    "        plt.plot(mean_train_metric)\n",
    "        plt.plot(mean_val_metric)\n",
    "        plt.gca().set_ylim([0, 1])\n",
    "        plt.show()\n",
    "        print(\"Epoch {} of {} took {:.3f}s\".format(\n",
    "            epoch + 1, params[\"epochs\"], time.time() - epoch_start_time))\n",
    "        print(\"  training loss (in-iteration): \\t{:.6f}\".format(mean_train_loss[-1]))\n",
    "        print(\"  validation loss: \\t\\t\\t{:.6f}\".format(mean_val_loss[-1]))\n",
    "        print(\"  training metric: \\t\\t\\t{:.2f}\".format(mean_train_metric[-1]))\n",
    "        print(\"  validation metric: \\t\\t\\t{:.2f}\".format(mean_val_metric[-1]))\n",
    "        \n",
    "#         if mean_train_loss[-1] < epsilon:\n",
    "#             break\n",
    "\n",
    "    return mean_train_loss, mean_val_loss, mean_train_metric, mean_val_metric\n",
    "\n",
    "# ? def cross_val_trains"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_scheduler(optimizer, params):\n",
    "    scheduler = LambdaLR(optimizer, lr_lambda=lambda epoch: 0.5 ** (epoch // params[\"lr_ep_step\"]))\n",
    "    for epoch in range(params[\"epochs\"]):\n",
    "        scheduler.step()\n",
    "        print(epoch, scheduler.get_lr()[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Create model...\n",
      "Create optimizer...\n",
      "0 0.1\n",
      "1 0.1\n",
      "2 0.1\n",
      "3 0.1\n",
      "4 0.1\n",
      "5 0.1\n",
      "6 0.1\n",
      "7 0.1\n",
      "8 0.1\n",
      "9 0.1\n",
      "10 0.1\n",
      "11 0.1\n",
      "12 0.1\n",
      "13 0.1\n",
      "14 0.1\n",
      "15 0.1\n",
      "16 0.1\n",
      "17 0.1\n",
      "18 0.1\n",
      "19 0.1\n",
      "20 0.05\n",
      "21 0.05\n",
      "22 0.05\n",
      "23 0.05\n",
      "24 0.05\n",
      "25 0.05\n",
      "26 0.05\n",
      "27 0.05\n",
      "28 0.05\n",
      "29 0.05\n",
      "30 0.05\n",
      "31 0.05\n",
      "32 0.05\n",
      "33 0.05\n",
      "34 0.05\n",
      "35 0.05\n",
      "36 0.05\n",
      "37 0.05\n",
      "38 0.05\n",
      "39 0.05\n",
      "40 0.025\n",
      "41 0.025\n",
      "42 0.025\n",
      "43 0.025\n",
      "44 0.025\n",
      "45 0.025\n",
      "46 0.025\n",
      "47 0.025\n",
      "48 0.025\n",
      "49 0.025\n",
      "50 0.025\n",
      "51 0.025\n",
      "52 0.025\n",
      "53 0.025\n",
      "54 0.025\n",
      "55 0.025\n",
      "56 0.025\n",
      "57 0.025\n",
      "58 0.025\n",
      "59 0.025\n",
      "60 0.0125\n",
      "61 0.0125\n",
      "62 0.0125\n",
      "63 0.0125\n",
      "64 0.0125\n",
      "65 0.0125\n",
      "66 0.0125\n",
      "67 0.0125\n",
      "68 0.0125\n",
      "69 0.0125\n",
      "70 0.0125\n",
      "71 0.0125\n",
      "72 0.0125\n",
      "73 0.0125\n",
      "74 0.0125\n",
      "75 0.0125\n",
      "76 0.0125\n",
      "77 0.0125\n",
      "78 0.0125\n",
      "79 0.0125\n",
      "80 0.00625\n",
      "81 0.00625\n",
      "82 0.00625\n",
      "83 0.00625\n",
      "84 0.00625\n",
      "85 0.00625\n",
      "86 0.00625\n",
      "87 0.00625\n",
      "88 0.00625\n",
      "89 0.00625\n",
      "90 0.00625\n",
      "91 0.00625\n",
      "92 0.00625\n",
      "93 0.00625\n",
      "94 0.00625\n",
      "95 0.00625\n",
      "96 0.00625\n",
      "97 0.00625\n",
      "98 0.00625\n",
      "99 0.00625\n",
      "100 0.003125\n",
      "101 0.003125\n",
      "102 0.003125\n",
      "103 0.003125\n",
      "104 0.003125\n",
      "105 0.003125\n",
      "106 0.003125\n",
      "107 0.003125\n",
      "108 0.003125\n",
      "109 0.003125\n",
      "110 0.003125\n",
      "111 0.003125\n",
      "112 0.003125\n",
      "113 0.003125\n",
      "114 0.003125\n",
      "115 0.003125\n",
      "116 0.003125\n",
      "117 0.003125\n",
      "118 0.003125\n",
      "119 0.003125\n",
      "120 0.0015625\n",
      "121 0.0015625\n",
      "122 0.0015625\n",
      "123 0.0015625\n",
      "124 0.0015625\n",
      "125 0.0015625\n",
      "126 0.0015625\n",
      "127 0.0015625\n",
      "128 0.0015625\n",
      "129 0.0015625\n",
      "130 0.0015625\n",
      "131 0.0015625\n",
      "132 0.0015625\n",
      "133 0.0015625\n",
      "134 0.0015625\n",
      "135 0.0015625\n",
      "136 0.0015625\n",
      "137 0.0015625\n",
      "138 0.0015625\n",
      "139 0.0015625\n",
      "140 0.00078125\n",
      "141 0.00078125\n",
      "142 0.00078125\n",
      "143 0.00078125\n",
      "144 0.00078125\n",
      "145 0.00078125\n",
      "146 0.00078125\n",
      "147 0.00078125\n",
      "148 0.00078125\n",
      "149 0.00078125\n",
      "150 0.00078125\n",
      "151 0.00078125\n",
      "152 0.00078125\n",
      "153 0.00078125\n",
      "154 0.00078125\n",
      "155 0.00078125\n",
      "156 0.00078125\n",
      "157 0.00078125\n",
      "158 0.00078125\n",
      "159 0.00078125\n",
      "160 0.000390625\n",
      "161 0.000390625\n",
      "162 0.000390625\n",
      "163 0.000390625\n",
      "164 0.000390625\n",
      "165 0.000390625\n",
      "166 0.000390625\n",
      "167 0.000390625\n",
      "168 0.000390625\n",
      "169 0.000390625\n",
      "170 0.000390625\n",
      "171 0.000390625\n",
      "172 0.000390625\n",
      "173 0.000390625\n",
      "174 0.000390625\n",
      "175 0.000390625\n",
      "176 0.000390625\n",
      "177 0.000390625\n",
      "178 0.000390625\n",
      "179 0.000390625\n",
      "180 0.0001953125\n",
      "181 0.0001953125\n",
      "182 0.0001953125\n",
      "183 0.0001953125\n",
      "184 0.0001953125\n",
      "185 0.0001953125\n",
      "186 0.0001953125\n",
      "187 0.0001953125\n",
      "188 0.0001953125\n",
      "189 0.0001953125\n",
      "190 0.0001953125\n",
      "191 0.0001953125\n",
      "192 0.0001953125\n",
      "193 0.0001953125\n",
      "194 0.0001953125\n",
      "195 0.0001953125\n",
      "196 0.0001953125\n",
      "197 0.0001953125\n",
      "198 0.0001953125\n",
      "199 0.0001953125\n"
     ]
    }
   ],
   "source": [
    "data_path = \"data/reddit_12K.h5\"\n",
    "\n",
    "params = {\n",
    "        'data_path': None,\n",
    "        'epochs': 200,\n",
    "        'momentum': 0.5,\n",
    "        'lr_start': 0.1,\n",
    "        'lr_ep_step': 20,\n",
    "        'lr_adaption': 0.5,\n",
    "        'test_ratio': 0.1,\n",
    "        'batch_size': 32,\n",
    "        'cuda': False,\n",
    "        'cuda_device_id' : cuda_n,\n",
    "    }\n",
    "\n",
    "params['data_path'] = data_path\n",
    "\n",
    "if torch.cuda.is_available():\n",
    "    params['cuda'] = True\n",
    "    torch.cuda.set_device(params[\"cuda_device_id\"])\n",
    "\n",
    "subscripted_views = [\n",
    "    'DegreeVertexFiltration_dim_0',\n",
    "    'DegreeVertexFiltration_dim_0_essential',\n",
    "    'DegreeVertexFiltration_dim_1_essential'\n",
    "]\n",
    "\n",
    "print('Create model...')\n",
    "model = MyModel(subscripted_views)\n",
    "if params[\"cuda\"]:\n",
    "    model.cuda(params[\"cuda_device_id\"])\n",
    "\n",
    "print(\"Create optimizer...\")\n",
    "optimizer = optim.SGD(model.parameters(),\n",
    "                      lr=params['lr_start'],\n",
    "                      momentum=params['momentum'])\n",
    "\n",
    "check_scheduler(optimizer, params)\n",
    "# mean_train_loss, mean_val_loss, mean_train_metric, mean_val_metric = train(model, optimizer, data_train, data_test, params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "def ensure_dir(file_path):\n",
    "    directory = os.path.dirname(file_path)\n",
    "    if directory != \"\" and not os.path.exists(directory):\n",
    "        os.makedirs(directory)\n",
    "        \n",
    "def save_res(res, path):\n",
    "    ensure_dir(path)\n",
    "    with open(path, \"w\") as f:\n",
    "        f.write(str(res))\n",
    "        \n",
    "def load_res(path):\n",
    "    with open(path) as f:\n",
    "        res = f.read()\n",
    "    return eval(res)\n",
    "\n",
    "def load_results(problem):\n",
    "    train_loss_l = load_res(\"results/\" + problem + \"/train_loss\")\n",
    "    val_loss_l = load_res(\"results/\" + problem + \"/val_loss\")\n",
    "    train_metric_l = load_res(\"results/\" + problem + \"/train_auc\")\n",
    "    val_metric_l = load_res(\"results/\" + problem + \"/val_auc\")\n",
    "    return train_loss_l, val_loss_l, train_metric_l, val_metric_l\n",
    "    \n",
    "def save_results(problem, train_loss_l, val_loss_l, train_metric_l, val_metric_l):\n",
    "    save_res(train_loss_l, \"results/\" + problem + \"/\" + \"train_loss\")\n",
    "    save_res(val_loss_l, \"results/\" + problem + \"/\" + \"val_loss\")\n",
    "    save_res(train_metric_l, \"results/\" + problem + \"/\" + \"train_auc\")\n",
    "    save_res(val_metric_l, \"results/\" + problem + \"/\" + \"val_auc\")\n",
    "    print(\"saved.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_model(subscripted_views, params):\n",
    "    print('Create model...')\n",
    "    model = MyModel(subscripted_views)\n",
    "    if params[\"cuda\"]:\n",
    "        model.cuda(params[\"cuda_device_id\"])\n",
    "\n",
    "    print(\"Create optimizer...\")\n",
    "    optimizer = optim.SGD(model.parameters(),\n",
    "                          lr=params['lr_start'],\n",
    "                          momentum=params['momentum'])\n",
    "    \n",
    "    return model, optimizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cross_val_train(problem, dataset, subscripted_views, cv, params, load=True, wanted_views=None):\n",
    "    \"\"\"\n",
    "    Perform training and validation on each fold and save the result. \n",
    "    \"\"\"\n",
    "\n",
    "    sample_labels = list(dataset.sample_labels)\n",
    "    label_encoder = LabelEncoder().fit(sample_labels)\n",
    "    sample_labels = label_encoder.transform(sample_labels)\n",
    "\n",
    "    label_map = lambda l: int(label_encoder.transform([l])[0])\n",
    "    collate_fn = PersistenceDiagramProviderCollate(dataset, label_map=label_map, wanted_views=wanted_views)\n",
    "    \n",
    "    cv_splits = list(cv.split([0] * len(sample_labels), sample_labels))\n",
    "    \n",
    "    if load:\n",
    "        train_loss_l, val_loss_l, train_metric_l, val_metric_l = load_results(problem)\n",
    "        test_metric = list(map(lambda x: x[-1], val_metric_l))\n",
    "        print(\"test metric mean:\", np.mean(test_metric))\n",
    "        print(\"test metric std:\", np.std(test_metric))\n",
    "        print(list(map(lambda x: np.round(x, 2), test_metric)))\n",
    "    else:\n",
    "        train_loss_l, val_loss_l, train_metric_l, val_metric_l, test_metric = [], [], [], [], []\n",
    "\n",
    "    for i in range(len(test_metric), len(cv_splits)):\n",
    "        \n",
    "        train_i, test_i = cv_splits[i]\n",
    "        \n",
    "        train_data = DataLoader(dataset,\n",
    "                                batch_size=params[\"batch_size\"],\n",
    "                                collate_fn=collate_fn,\n",
    "                                shuffle=False,\n",
    "                                sampler=SubsetRandomSampler(train_i.tolist()))\n",
    "\n",
    "        val_data = DataLoader(dataset,\n",
    "                               batch_size=params[\"batch_size\"],\n",
    "                               collate_fn=collate_fn,\n",
    "                               shuffle=False,\n",
    "                               sampler=SubsetRandomSampler(test_i.tolist()))\n",
    "\n",
    "        model, optimizer = create_model(subscripted_views, params)\n",
    "        mean_train_loss, mean_val_loss, mean_train_metric, mean_val_metric = train(\n",
    "            model, optimizer, train_data, val_data, params, metric=accuracy_score, \n",
    "            criterion=nn.CrossEntropyLoss(), variable_created_by_model=True)\n",
    "\n",
    "        train_loss_l.append(mean_train_loss)\n",
    "        val_loss_l.append(mean_val_loss)\n",
    "        train_metric_l.append(mean_train_metric)\n",
    "        val_metric_l.append(mean_val_metric)\n",
    "        test_metric.append(mean_val_metric[-1])\n",
    "\n",
    "        save_results(problem, train_loss_l, val_loss_l, train_metric_l, val_metric_l)\n",
    "\n",
    "    print(\"test metric mean:\", np.mean(test_metric))\n",
    "    print(\"test metric std:\", np.std(test_metric)) \n",
    "    \n",
    "    return test_metric"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reddit12K classification results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading provider...\n"
     ]
    }
   ],
   "source": [
    "data_path = \"data/reddit_12K.h5\"\n",
    "\n",
    "params = {\n",
    "        'data_path': None,\n",
    "        'epochs': 200,\n",
    "        'momentum': 0.5,\n",
    "        'lr_start': 0.1,\n",
    "        'lr_ep_step': 20,\n",
    "        'lr_adaption': 0.5,\n",
    "        'n_splits' : 5,\n",
    "#         'test_ratio': 0.1,\n",
    "        'batch_size': 32,\n",
    "        'cuda': False,\n",
    "        'cuda_device_id' : cuda_n,\n",
    "    }\n",
    "\n",
    "params['data_path'] = data_path\n",
    "\n",
    "if torch.cuda.is_available():\n",
    "    params['cuda'] = True\n",
    "    torch.cuda.set_device(params[\"cuda_device_id\"])\n",
    "\n",
    "subscripted_views = [\n",
    "    'DegreeVertexFiltration_dim_0',\n",
    "    'DegreeVertexFiltration_dim_0_essential',\n",
    "    'DegreeVertexFiltration_dim_1_essential'\n",
    "]\n",
    "\n",
    "print('Loading provider...')\n",
    "dataset = Provider()\n",
    "dataset.read_from_h5(params['data_path'])\n",
    "\n",
    "assert all(view_name in dataset.view_names for view_name in subscripted_views)\n",
    "\n",
    "cv = StratifiedKFold(n_splits=params[\"n_splits\"])\n",
    "problem = \"reddit_12K\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 200 of 200 took 38.509s\n",
      "  training loss (in-iteration): \t1.538257\n",
      "  validation loss: \t\t\t1.623025\n",
      "  training metric: \t\t\t0.44\n",
      "  validation metric: \t\t\t0.43\n",
      "saved.\n",
      "test metric mean: 0.41588163269556533\n",
      "test metric std: 0.017812274183686288\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.42343096234309624,\n",
       " 0.41380753138075316,\n",
       " 0.38238993710691827,\n",
       " 0.4322282836760386,\n",
       " 0.4275514489710206]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cross_val_train(problem, dataset, subscripted_views, cv, params, load=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# reddit 5k - 5 classes, 5k graphs\n",
    "# reddit 12k - 11 classes, 12 graphs"
   ]
  }
 ],
 "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}