resnet_3d_no_norm_V86_ds.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import json\n",
    "import random\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from tqdm import tqdm\n",
    "from pathlib import Path\n",
    "import SimpleITK as sitk\n",
    "\n",
    "import torch\n",
    "import torch.nn.functional as F\n",
    "from torchvision.transforms import ToTensor\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "\n",
    "from torch.optim import Adam\n",
    "from transformers import get_cosine_schedule_with_warmup\n",
    "\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from dataset.augmentation import flip\n",
    "from dataset.preprocessing import whitening\n",
    "\n",
    "from models.resnet_3d import r3d_18, test_r3d_18\n",
    "test_r3d_18()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "root_path = Path(os.getcwd())\n",
    "dataset_path = root_path.parent/'dataset_V86'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv(dataset_path/'targets.csv', index_col=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>file</th>\n",
       "      <th>target</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.npy</td>\n",
       "      <td>59</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1.npy</td>\n",
       "      <td>59</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>10.npy</td>\n",
       "      <td>86</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>11.npy</td>\n",
       "      <td>86</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>12.npy</td>\n",
       "      <td>86</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>81</th>\n",
       "      <td>45.npy</td>\n",
       "      <td>29</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>82</th>\n",
       "      <td>46.npy</td>\n",
       "      <td>29</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>83</th>\n",
       "      <td>47.npy</td>\n",
       "      <td>29</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>84</th>\n",
       "      <td>48.npy</td>\n",
       "      <td>25</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>85</th>\n",
       "      <td>49.npy</td>\n",
       "      <td>25</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>86 rows × 2 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "      file  target\n",
       "0    0.npy      59\n",
       "1    1.npy      59\n",
       "2   10.npy      86\n",
       "3   11.npy      86\n",
       "4   12.npy      86\n",
       "..     ...     ...\n",
       "81  45.npy      29\n",
       "82  46.npy      29\n",
       "83  47.npy      29\n",
       "84  48.npy      25\n",
       "85  49.npy      25\n",
       "\n",
       "[86 rows x 2 columns]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_pairs = [ (str(dataset_path/'npys'/df.iloc[i]['file']), df.iloc[i]['target']) for i in range(len(df))]\n",
    "# (abs apth, age)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([1, 64, 64, 64]) tensor([59.])\n",
      "tensor([59.]) torch.FloatTensor\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7fde02426850>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPsAAAD7CAYAAACscuKmAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAAhxElEQVR4nO2da5BdxXXv/+ucec9oNCMhidEDJJAsjGNLwrpYgIsQCIE4TnA5LgrblSIppZQPTsqpxDdAUnXLuXVvFf5w49hVjhNVcMIHJ4AdiAiV2GAZHGIcgWTeCCEhS0hipEHv0egxZ85Z98PZOru7Z3bPPmf2eYz6/6uamt67e3ev8+jTa3WvXi2qCkLIpU+u2QIQQhoDOzshgcDOTkggsLMTEgjs7IQEAjs7IYEwo84uIneKyC4R2SMi92clFCEke6TWdXYRyQN4B8DtAA4CeAnA51X1rezEI4RkRdsMnr0ewB5V3QsAIvIIgLsAJHb2jrYe7e4YKF8UClaeFovGlThP6pTJ2Yh0d1XShd68kxknNaXOJaXkPDXfRvctNSh1uA/GyVwBqXDlSCu/t86Er0TbB2Mzr/wS5TzGMK4Xpvy0Z9LZlwA4YFwfBPAJ3wPdHQPYsHIjAECGR6y80qnT8YU43xQtGck693b19J4MyK1cXUmP3DhoN230/UKvp3catI/Z74fZ6Sa64jpK7cl1jF1RtK5zhfi53oPxZ1FyfpssOc7YchT60slv/Qg5H23nqfiG2faCv/2ZU0fKtgJgW+lHiXkz6eypEJFNADYBQFd7f72bI4QkMJPOfgjAMuN6aXTPQlU3A9gMAHPbF+jFEb10+oxdzhqx7ZHGKVijuBljznVUMbKc+dDcGTdtjt5eNd78dD2WEfonrKyiaTW931mteOXmzDoyGHilVoUuaU4qQG1gJpbVSwBWicgKEekAcA+AJ7MRixCSNTWP7Ko6ISJ/COCHAPIAvqOqb2YmGSEkU2Zks6vqvwP494xkIYTUkbpP0JlosViZda9qVr0V7XTffY89eG7QYzmZ0wAemzftcph6ZrpNunfVZpf7yI3H6aKv+pRfA2ueos3+2urEBKpmtsdxqGHOge6yhAQCOzshgdBQNR5qqO+toprXA4+KaDq3+JbNLO8x5yc5N5Fcf6LXnEdr9ZkFaZfNNGcXNGUsds58mcuUIzfX9tcoHjs+4/pnHTWYIRzZCQkEdnZCAoGdnZBAaKzNDswuW70eyzO+nWgJpq243sMesbStevvY54qa2mZ3vkmScnkwLZaMg47LcYg2ew1wZCckENjZCQmExqvxrUYTPamKHbaOrAn7xXNVOIhZe859L81s2rWsalgpmxSswvQGLHnKYepyk+o3ZJpYZKvxsmd6+QhHdkKCgZ2dkEBoHTU+C3Xa3BzQohsdeo/Euuro0uQYdLkLxm3ntfg2ySSZAj4medCZKnO3cdsXU8QZNkwZ88ammIkuJOLKkeQNON5vx9jKfhvPpQlHdkICgZ2dkEBgZyckEJrgQVdHW7pF7XSTOa/FIbRPLxuy8kw7PWdEffR5sU3yfqth2WxSHQlLZT6b3eeFJ8YOOHFejHnp1m/OP5i76jpOjYNUD0d2QgKBnZ2QQGidpbdAGL4jVt1zjtpqqu4+LNXX8TqzvNV8y3C+wBbmCqZZR42bW0wVf5IpkDfL2YKYHoZmHW27DtjlahMrODiyExII7OyEBAI7OyGBQJu9zhz7/RsS88QNHGm6wRo/w5p3gjkW0tn23qAUVkEnL2E5zHveWsqYJK5LbNF8nZK8C9AMhnH47tVWuQXfdk51JVMy7cguIt8RkRERecO4N09EnhGR3dH/QV8dhJDmk0aN/0cAdzr37gewVVVXAdgaXRNCWphp1XhV/U8RWe7cvgvALVH6YQDPAbgvS8EuFdwAFWY8dXfZTK0lL1OX9jTgOYq5ZHy6kwJDmOU8S3Rm4Ay3jtMfjnXrgdfsnWhJgTPcmPclT8w8q22ur82YWifoFqnqcJQ+DGBRRvIQQurEjGfjVVXhCYAkIptEZLuIbC/gQlIxQkidqXU2/oiIDKnqsIgMARhJKqiqmwFsBoB+mdf6O1UyQNZ9pJJ2veK8cdbMTSelZHXf8nDzhKM+uyzWfbuO2Lp625jxiLsokDAb7wao6N4fq+5uUIqOpL0qTlvm7LzrQZc/N7VMk6q8cU1cxwuvJhcMnFpH9icB3Bul7wWwJRtxCCH1Is3S2z8D+BmA1SJyUEQ2AngQwO0ishvAr0bXhJAWJs1s/OcTsm7LWBZCSB2hB10dOHJTHNc8fyH9NEWpPTZMzedKzvKduaTm1j+6Ijay+34R2+kl55O2bGV355zRXMljK7edj9NFT9RHX4DM1EE6TBmdciPreyvpRS8k1xE69I0nJBDY2QkJBKrxdUBSBqFwvess1d3wLCt2pG9bO+I6zi6Odd8577qB3X2VxEnr6CnnZZ1aYdS/z67fu2kmoa1ah55qTKWQ4chOSCCwsxMSCOzshAQCbfY6kHaHlhsQUo3nip4z0XzM2R1/pF450trKmpAG0G/MA0x6LabLrbnDzt0FOJ5sbxc7jaXI8+b6nV3OWpbLOYKUuF3uIhzZCQkEdnZCAoFqfAbkV11lXfuWnUzVVCbsvIme6s9uMo9FAjyqu+dnvarjpVKSdGyUT22fFMzD1Mh9ce7NYuuusevY8WZy4cDgyE5IILCzExIIVOMz4OiNnqhcrsppzUzPvO1JRzwlqORu4AmvKmzkdR+LdevB59+zyh367PLEOsxNPeZmF1+gjEmBLQyV3/Q2nOQxZ1we2TDXylq4I1HE4ODITkggsLMTEgjs7IQEAm32DCj0OrvXjOOZXFvZ3BGnndUvtbn4ls185Ra+GkdzHBuyI090nojXBDuejo1eZ6UQ7WNXVtLjc5OPbpo0X2AV9OQZmPMbeU+QYjNQJ7HhyE5IILCzExIIVOMzwD3SyMRcggLSB7ZI37h9mbQBZd7bdiD33E9erqQHXA/AidjlzVXdrbY8x0aZqru1DOfxoPORS4pD75bzCRw4HNkJCQR2dkICgZ2dkECgzV4jbUOXV9LenWHOkpdZdtIurxp+etMuvZU6nICQ7fFalr5/xK6zOPXWufy8Qeu60JfcuBWwwjrN2XnGDG5ZSH4jc77lTM/5eW3LllbSEwcOJhcMgDTHPy0TkWdF5C0ReVNEvhzdnyciz4jI7uj/4HR1EUKaR5qxZALAn6rqtQA2APiSiFwL4H4AW1V1FYCt0TUhpEVJc9bbMIDhKD0qIjsBLAFwF4BbomIPA3gOwH11kbIFOXVj7D3mqtKWqu4uy1lqq53lO0IpCZ8JYcp18mr7oy59el0l3fPENqfS+MG2JYsr6ZHbr0isP22QC1ult3HfjyQmuu03vH0sOT7dkTuWVdLz/55qfGpEZDmAdQC2AVgU/RAAwGEAnn2ehJBmk7qzi0gfgH8B8MeqetrMU1VFgpeziGwSke0isr0Aj1MzIaSupOrsItKOckf/rqo+Ht0+IiJDUf4QgJGpnlXVzaq6XlXXt6MGPZUQkgnT2uwiIgAeArBTVf/KyHoSwL0AHoz+b6mLhC3K2OWxr6i7ZFQy3Eh9y2s+d9OscZerRpfGjfcby4gAoL3dlfTpjy2spC8MJi+1+eYt0tr2RWcXYNIZbtW4xLpHVYdMmrfiJgC/A+B1EXkluvfnKHfyx0RkI4D9AO6ui4SEkExIMxv/X0g+8/O2bMUhhNQLKjk14tu9Zu7yclXRYlecV4vH3HSk9qgzlsCO37LcrsMwLy4MxEJ6g0XWiqnuu9/GhPncSbsMfUErefpTBfrGExII7OyEBALV+BrxzSqbM/ClNufUUmMm2fUmq0ktdjeB1DDDf36+s0nGUJN9Hm9pSetdl/b0W5eCcWyW5U3nkP/wqkq6uHN3bY3NYjiyExII7OyEBAI7OyGBQJvdh9hGtHQYwcu9NrtxRlmXXUfbmBmEwYm1XsunUePyV3JwCUCM113LzraqnjPKeecsPHlpd8uN3HRZJT2fNjsh5FKFnZ2QQKAaXwX5BZdNXwj20tuk5SRTbc3gpzYTL7yU6nkmHnM+nPpLxjHN1majSV5ynvh0Rlnz2OcQ4chOSCCwsxMSCOzshAQCbfYqKFy5IF1Bw07Mn0+/QyuJeuw2M+vIO+eo1RL4MhNcm934dvqW16xlvkmZRh2eM/lCgCM7IYHAzk5IIFCN96G22je2uDn6bb2XvNxYePnzcbrYlXFbnlh1k0jwrnOfsa7TmkZt9ldfJ1rkrGdJ+WFr9SYJR3ZCAoGdnZBAoBpfBRfmJvw2upqXJuf51NG6zhV7ZOx733bz6zkU6/FHru+NH2lg6OtJ+LRb07nO9aBLCIgh1660q3jt7drkyoK0qrvvmRRqPUd2QgKBnZ2QQGBnJyQQaLNXgblryvLGqsLYnrjzZCU9erzXyut/PQ6O0cgdZm1n7aiV7cMnKun8hZ5KeqLXtRPrItmUqGGjShUNW0dxGY8dXzNolRt4rWbRqqcWGz0Dph3ZRaRLRF4UkVdF5E0R+cvo/goR2SYie0TkURHpmK4uQkjzSKPGXwBwq6quAbAWwJ0isgHA1wB8XVVXAjgBYGPdpCSEzJg0Z70pgDPRZXv0pwBuBfCF6P7DAL4K4NvZizgL8Ghlpbyd+cklv6ik165+z8r71uufyVIqr1xiOIx1Hj1v5RWHj1TS3ccXV9Kjrhpfw6aeTPAsI2o+WUYxAmCMz2mwKu1R3SVvnAj8oasq6VKPrSzn3j1USRdPnEC1pD2fPR+d4DoC4BkA7wI4qaoXvzIHASypunVCSMNI1dlVtaiqawEsBXA9gGvSNiAim0Rku4hsLySd1EcIqTtVLb2p6kkAzwK4AcCAiFw0A5YCOJTwzGZVXa+q69vRrI3ShJBpbXYRWQCgoKonRaQbwO0oT849C+BzAB4BcC+ALfUUtBUQ0yXRF+/czHPe4a0/WFdJF+/wLGVlbVI6NrV5lHTuvB0ZolSIDfq+985W0qPL+jIWKn18ealhl1e5gYT6SnWeZPDY6G1XLrOuD35mafyY77y7G/sryaGf2DZ76dWd04qUZp19CMDDIpJHWRN4TFWfEpG3ADwiIv8HwMsAHkpRFyGkSaSZjX8NwLop7u9F2X4nhMwCGu9Bd1G9qVUtayLiHo8coW3J6rir4o8viVXmF4evTGzLOtq5mk8pSXt07vcNx/pi7thpK898mblX3qmke65ea5U7tzCe8vF5/Hl3+nnMIev9Thnkwmf+1N8r0fCw7LTnp45+Ph4vC33Jx3h7Md6D4ZttD8Alx8umgBxOPmObvvGEBAI7OyGB0LyNMDVsvm80ua7kAGxe9VOnTgPAupX7K+nF3bb6/LzMi9s2vL1KrpmQAXN2GN5YR0asPDFOlzVjsw0+Ye8Wmb9gfiV94HP2DDOS3gNPZG0XU72t5gRZSwzThPB5/OWMHTMl35S4jRnL7uynr6ukT19hdy3rSDDfa0m5IuPWMXJ7+f2f2JK8RYUjOyGBwM5OSCCwsxMSCA212SWfR76/7AVUPHXayTSN4Bax31evSMzSnGkMOpkee/7qvqOV9Ia+d6285/Fx48E46R7PZAZkcD300lI8HO9s0+s+bOWdWhUH1Rh4dLshiB1xsrBkHtLgjfnuWXYS8yhm3/Ja6iOnjQAYznes7Yp4H9fEPns3oi2U3fjwH8auJuYRVb6jul2Gfng4vjgae8ad+eVVVrnRpfGH7X6vCtGORN8R3hzZCQkEdnZCAqGhanxhfhfev+cjAICuE7Y72uATr1fSpbNnrbxmqfXH1wzYYpjqedoY6o66dUXn8Up684GbE+s3MZfhANuEqPWdUWMjyOEb59iZhhwDxu2zv2yr+yc+NPOvT348+RUkvR/qLtumPTEpIR4dAJy+bqiS7vGo8flVV9nXxoYin2lnxubvfXKHlVcsTr3U173lJet6/AufqKTPz6t+nObITkggsLMTEgjs7IQEQsPdZS/aSucH7d+Z4Y1rKun+9+z1mO5/fbHuck3FeL9teIkZK77G3VXHJ+JlrXd2L7byTMvZ3EknBY9l7maltF9zHfHuKN9yjcnJq52vi6+tBNdUt61iZ1zQtH9dvEudZrm0nsVOU2cujw36Hnhw5gtyxrLohPHgksf3WeUm3h+Om65xDmrej/ZW0u/fvdJTcmo4shMSCOzshARCyxz/ZO4KMj2FAKB7w8fii/9u3Dk9pgdX+UZCwSpU6e+9Gwcx6BxJXr8zA1bk7BBxqdVuH8V1q6t+plZvPQvnvTFfpxvzPWcGI05rMlTRdi0U37G9Hou3Laykhx56pZKecJePM8Dcndg+drWVV3Bj+k8BR3ZCAoGdnZBAaKga3370HC7/h1cBAGfu+CUr78ziZJX29FXxNGf/f9dHtgrWhhw7y5oRtp7x1OfUUdgZhwPOlTyeYFmorR6OXN87fSEAxRs+OvPGfCS/3bbZ4AkIMtN2gSpCSzsz6UUjvskkz886Mv+1Uev68A39CSVjOLITEgjs7IQEAjs7IYHQUJtdSyWUxsYAAD1P2F5xc+bHgRCG77GXheb9NA6OmDbEdq3kBwaSM2v4aXR3x3UfiY3Fonv0XUK8edcrLIv450n2MADLnj1yfffMG0s5p+G1xT22feq2PUc7W96RVbD4m/H3uKF7M1/fbV3K9R+fVojUX9/o2OaXReSp6HqFiGwTkT0i8qiIJIe1JIQ0nWrGqi8DME+P+xqAr6vqSgAnAGzMUjBCSLakUuNFZCmA3wDwfwH8iYgIgFsBfCEq8jCArwL4duqW3SWMo8cqaTdYw8T+A6mrnTGXX5aYlVZ9NstNuFqw8fPafiZd/aV2R+X0HC+VRia3jtTBH3x1eB9MbsuKp+4cr5X02iaF/DOeq/n9sC7Sn2lgxtVvJHrhgnU9d1/ZzdIXDCTtyP7XAP4M8TFg8wGcVNWLr/QggCVTPEcIaRGm7ewi8mkAI6q6Y7qyCc9vEpHtIrK9gAvTP0AIqQtp1PibAPyWiHwKQBeAfgDfADAgIm3R6L4UwKGpHlbVzQA2A0C/zGuRGNGEhEea89kfAPAAAIjILQC+oqpfFJHvAfgcgEcA3AtgS1ZCLXjIDrTXyF+IC0Met8MalrzGB21DtDg3Di7YtjP5eF3LLvd8SpPsXDOmfI3HKCeV81LrWWyGbplz4uOr+fZ4zmnL5Chmo478XPs7UDx5KoMG6kvPtvJuvNxYsvY8E6ea+1CerNuDsg3/0AzqIoTUmaqcalT1OQDPRem9AK73lSeEtA4tE7zCpFnLGQBwbkGyal0LushWq+66No6P/+Odnt9Ky9srOS/vBLYoGrqapflmf+pzalPAi+9YYnNJzWOepD4COSV6xZB9wzyqrFWOJnMoHiufR6CafNw0feMJCQR2dkICoSXV+GYy3petvrt86Jh1/Qfz/7OS/rFvyiOlGKVW+QR9J6tmESOugdrzuaX2cVidrxsXVXjXtRoc2QkJBHZ2QgKBnZ2QQGgVi69lMI8jkgzssfXz7eN/5+fjOictGXmOSUoi9dHRzaQW+70KatkF6OPcZXa3cGOMzFY4shMSCOzshAQC1XgX4+dP3bjuNfCR7oPW9f87elN84WxiseKsmZ5ws2d1p354NsJYxTLYJFPwHuM6e+HITkggsLMTEgjs7IQEAm12F9OOzmAZ5+qOEev6q0//diU919mgVDKX0Xw2ag1BKWq1+9Mua3kDOKZt27ObrZHTFtpWh/XBFoAjOyGBwM5OSCBQjXcwveZK+Zmrc8va7GN8575jRmGwy44PxOl2+0ReG1/AhwS1u2WW7+pw3LK3aC3eda3yXmUMR3ZCAoGdnZBAoBpfZy7L2eddmjPuOSfU3lfuebyS/ubmz1bS4s7am59aSpXeJWsVP20dvs0/k0JEm0NRSg+6tG37VHopXZp6PEd2QgKBnZ2QQGBnJyQQaLP7yMCRqsex2X31f7ZvbyX9Tc9Rxj7S2uITfXHaWR2cNEeQJa6t7Ma9twWpvs6a5w4CIO357PsAjAIoAphQ1fUiMg/AowCWA9gH4G5VPVEfMQkhM6UaNf5XVHWtqq6Pru8HsFVVVwHYGl0TQlqUmajxdwG4JUo/jPIZcPfNUJ6GI+0eNbsuDcZJV6V98OiNlXTOUG99p7hOqj6letp2Jn2dNZEgh3fpzc1KUuOdZ0JUyWsh7ciuAJ4WkR0isim6t0hVh6P0YQCLMpeOEJIZaceMT6rqIRFZCOAZEXnbzFRVFZn69zX6cdgEAF24ROP9EDILSDWyq+qh6P8IgCdQPqr5iIgMAUD0fyTh2c2qul5V17dfMkF5CZl9TDuyi0gvgJyqjkbpXwPwvwE8CeBeAA9G/7fUU9B6kV+22L6Rsf13qnQuOdOxSR/bsb6SHjRcNkvu+WImKQNbeN1Dm2nz1uIG6wxR5sqk64Kc2FaApFHjFwF4QspfuDYA/6SqPxCRlwA8JiIbAewHcHf9xCSEzJRpO7uq7gWwZor7xwDcVg+hCCHZE7wH3ZmPLJxxHZPirxnq6NlSsjua6xnX/QtzGdCopEan5iyOQsqiDm99KWPAl3xeckm746ap35bLZyqZwfxmry1A33hCAoGdnZBAYGcnJBBosw9lf+axaZf6NpC59mtnwjaiWu1mX2SWWnaHeeXwLQH62kp7hpv5RrpyGNcl5xuduBRXxU7CSwWO7IQEAjs7IYEw+9R4c+lDZ+76VeqwdUIpqpG2y6oZ8t18zFErNe1PqE8tzniFp+5ecjW+Futo6rSqdVqzAE6AT48pYAaZ1FzKZbhZBkd2QgKBnZ2QQJh9anzWapR3BtjOtNQ7j9dW0djct3/C3tZrmgI+tbU0204STXvSrBsb3mMO1dS2J7CFFauOs/GEkEsVdnZCAoGdnZBAmH02e8ZLb96Ahz672ZNVmBtX+vToR6288/8jjvTY80KflWcFo0z5M+wuqVmXdTb7M1/Oq/c0hW+51Lwxy6ZL0sKRnZBAYGcnJBBmnxpfb8ylGuenMGkjiHu/MBC7av3b/l+y8r6y5keV9N+88Bn7wZTLUN5lo6SNJY1UkasoZ8bEF+coqNTLcmZsibTHVF+iqroPjuyEBAI7OyGBwM5OSCDQZq8mIIPx0+iNwz4eZ54YmWPlfe3UHZV0nycIg+lWO8nFNOVPdMmIX/mx39xp5e06vqCSPrVrnpXXMxw3YL7OhXcetMp98B9L0wliMNHlyLhmtJLu/OkczBiP2653qTD1nMPs3RHHkZ2QQGBnJyQQqMZXswSTsMTjqvTtp+Pf0MJcez2pNNqe2Lapno+tjY+N6n252y6YUmZz992c9vNW3q8vi9X6DxbZnnw/e3RdJX3u8nidb6jntFVu2FDJ2+zqE3HL3X3NS5X0d9+41crrGEU6zPfDXZZMWH7MOh7+bCDVyC4iAyLyfRF5W0R2isgNIjJPRJ4Rkd3R/8F6C0sIqZ20avw3APxAVa9B+SionQDuB7BVVVcB2BpdE0JalDSnuM4FcDOA3wUAVR0HMC4idwG4JSr2MIDnANxXDyHrShWzt2lVP9PDTQv27+mcxYZuuttWhhb+5oFK+vTuoSllclE3ErbRdv5CnP6vA1dZxTrb4xjLH19kz7KPGxt51t/wTmLbOV+c7JQ89MLNlXTvuJ1nmjVnroob27DWlumNxz9cSTdcO2/xGXiTNCP7CgAfAPgHEXlZRP4+Orp5kaoOR2UOo3zaKyGkRUnT2dsAXAfg26q6DsAYHJVdVRUJm0VFZJOIbBeR7QVcmKoIIaQBpOnsBwEcVNVt0fX3Ue78R0RkCACi/yNTPayqm1V1vaqub0fnVEUIIQ0gzfnsh0XkgIisVtVdKJ/J/lb0dy+AB6P/W+oqaSzQzOswvKDaz9j1FXrjvLTHC09yhJuI73Tv77DySnvia9fc/tbKRyrpu57/n5V0160fWOXGfhp7vxXX2utT8lbshdZ2Nr4/XrBbm5iIr396YIWVd+0teyrpw2P9lfRA5zmrnBtXvxZ69sdfwVwhuVzf3ljenx+7xsob/2isMfb/3BlQ6h4vP+NgKnUk7Tr7HwH4roh0ANgL4PdQ1goeE5GNAPYDuLs+IhJCsiBVZ1fVVwCsnyLrtkylIYTUjeA96HqO2sd8nupN9nCzvOasDLvcqtv2VtJv/8xWkTuPxoULvfZzz5+9upJui0PV4fSYvXtE1sWq++VzbTX+sMRqvLl0pe/ZjU10x2t07UvOWHlvDsfLfqViXMlYv22SmJy5wnZd6xqJn/N511nLlLnkPJP20/YbXjocy+U9rba1tey6Q994QgKBnZ2QQGBnJyQQwrHZE4IOdO+3bd5TV8aBHCbZf6YNaeSNrrDXoP5uxfcr6Q+utN/iL/7Nn1TSv/qZl6y8n5z80JRt5V9xgjp8/FQlefC1y62sDsPldKInNlLbR+0Xo3lj7sBZlsvlTOM2FuTUqL37rnBVPN/RPmgb5vNWx/MAp5+xZbQwxLowaBvVncfTOb92jSSXS30kdFKgzksIjuyEBAI7OyGBINpArx8R+QBlB5zLABxtWMNT0woyAJTDhXLYVCvHlaq6YKqMhnb2SqMi21V1KiedoGSgHJSjkXJQjSckENjZCQmEZnX2zU1q16QVZAAohwvlsMlMjqbY7ISQxkM1npBAaGhnF5E7RWSXiOwRkYZFoxWR74jIiIi8YdxreChsEVkmIs+KyFsi8qaIfLkZsohIl4i8KCKvRnL8ZXR/hYhsiz6fR6P4BXVHRPJRfMOnmiWHiOwTkddF5BUR2R7da8Z3pG5h2xvW2UUkD+BbAH4dwLUAPi8i1zao+X8EcKdzrxmhsCcA/KmqXgtgA4AvRe9Bo2W5AOBWVV0DYC2AO0VkA4CvAfi6qq4EcALAxjrLcZEvoxye/CLNkuNXVHWtsdTVjO9I/cK2q2pD/gDcAOCHxvUDAB5oYPvLAbxhXO8CMBSlhwDsapQshgxbANzeTFkA9AD4OYBPoOy80TbV51XH9pdGX+BbATyFspd6M+TYB+Ay515DPxcAcwH8AtFcWtZyNFKNXwLggHF9MLrXLJoaCltElgNYB2BbM2SJVOdXUA4U+gyAdwGcVNWLu1sa9fn8NYA/Q7zjZn6T5FAAT4vIDhHZFN1r9OdS17DtnKCDPxR2PRCRPgD/AuCPVdU6QK1RsqhqUVXXojyyXg/gGv8T2SMinwYwoqo7Gt32FHxSVa9D2cz8kojcbGY26HOZUdj26WhkZz8EYJlxvTS61yxShcLOGhFpR7mjf1dVH2+mLACgqicBPIuyujwgIhf35Dbi87kJwG+JyD4Aj6Csyn+jCXJAVQ9F/0cAPIHyD2CjP5cZhW2fjkZ29pcArIpmWjsA3APgyQa27/IkyiGwgQaFwhYRAfAQgJ2q+lfNkkVEFojIQJTuRnneYCfKnf5zjZJDVR9Q1aWquhzl78OPVfWLjZZDRHpFysH7IrX51wC8gQZ/Lqp6GMABEVkd3boYtj0bOeo98eFMNHwKwDso24d/0cB2/xnAMIACyr+eG1G2DbcC2A3gRwDmNUCOT6Ksgr0G4JXo71ONlgXAxwC8HMnxBoD/Fd2/CsCLAPYA+B6AzgZ+RrcAeKoZckTtvRr9vXnxu9mk78haANujz+ZfAQxmJQc96AgJBE7QERII7OyEBAI7OyGBwM5OSCCwsxMSCOzshAQCOzshgcDOTkgg/H8/tpLr55qfhgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "class DICOMDataset(Dataset):\n",
    "    def __init__(self, pairs, out_size, mode='test'):\n",
    "        self.pairs = pairs\n",
    "        self.out_size = out_size\n",
    "        self.mode = mode\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.pairs)\n",
    "    \n",
    "    def __getitem__(self, i):\n",
    "        file_path, target = self.pairs[i]\n",
    "        image = np.load(file_path)\n",
    "        image = whitening(image)\n",
    "        if self.mode == 'train':\n",
    "            image = flip(image).copy()\n",
    "            \n",
    "        image  = ToTensor()(image).unsqueeze(0).type(torch.FloatTensor).unsqueeze(0)\n",
    "        target = torch.tensor([target]).type(torch.FloatTensor)\n",
    "\n",
    "        d = torch.linspace(-1, 1, self.out_size)\n",
    "        meshx, meshy, meshz = torch.meshgrid((d, d, d))\n",
    "        grid = torch.stack((meshx, meshy, meshz), 3)\n",
    "        grid = grid.unsqueeze(0) # add batch dim\n",
    "        image = F.grid_sample(image, grid, align_corners=True)\n",
    "\n",
    "        return image.squeeze(0), target\n",
    "\n",
    "\n",
    "ds = DICOMDataset(all_pairs, 64, 'train')\n",
    "img, label = ds[0]\n",
    "print(img.shape, label)\n",
    "print(label, img.type())\n",
    "plt.imshow(img[0][30])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_epoch(model, loader, optimizer, loss_fn, scheduler, device='cuda'):\n",
    "    running_loss = 0\n",
    "    number_of_samples = 0\n",
    "    \n",
    "    pbar = tqdm(total = len(loader), desc='Training')\n",
    "    for _, (images, targets) in enumerate(loader):\n",
    "        \n",
    "        images, targets = images.to(device), targets.to(device)\n",
    "        model.train()\n",
    "        optimizer.zero_grad()\n",
    "        predictions = model(images)\n",
    "        loss = loss_fn(predictions, targets)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        scheduler.step()\n",
    "        \n",
    "        running_loss += loss.item()*images.shape[0]\n",
    "        number_of_samples += images.shape[0]\n",
    "        pbar.update()\n",
    "        \n",
    "    pbar.close()\n",
    "    return running_loss/number_of_samples\n",
    "\n",
    "\n",
    "def test_model(model, test_dataset, batch_size=8, verbose=False, device='cuda'):\n",
    "    testloader = DataLoader(test_dataset, shuffle=False, batch_size = batch_size, num_workers=0)\n",
    "    \n",
    "    all_prediction = []\n",
    "    all_targets = []\n",
    "    pbar = tqdm(total = len(testloader), desc='Testing')\n",
    "    with torch.no_grad():\n",
    "        for _, (images, targets) in enumerate(testloader):\n",
    "            model.eval()\n",
    "            all_prediction += model(images.to(device)).cpu().numpy().tolist()\n",
    "            all_targets    += targets.cpu().numpy().tolist()\n",
    "            pbar.update()\n",
    "        \n",
    "    pbar.close()\n",
    "    return torch.nn.MSELoss()(torch.tensor(all_prediction), torch.tensor(all_targets))\n",
    "\n",
    "\n",
    "def train_test(\n",
    "    model,\n",
    "    train_dataset,\n",
    "    test_dataset,\n",
    "    num_epochs=30, \n",
    "    batch_size=8, \n",
    "    verbose=False, \n",
    "    device='cuda',\n",
    "    lr=0.001,\n",
    "):\n",
    "    trainloader = DataLoader(train_dataset, shuffle=True, batch_size=batch_size, num_workers=0)\n",
    "\n",
    "    optimizer = Adam(model.parameters(), lr = lr) #, weight_decay = 1e-3)\n",
    "    num_train_steps = int(len(train_dataset) / batch_size * num_epochs)\n",
    "    scheduler = get_cosine_schedule_with_warmup(optimizer, num_warmup_steps=len(train_dataset)/batch_size*5, num_training_steps=num_train_steps)\n",
    "    loss_fn = torch.nn.MSELoss()\n",
    "\n",
    "    train_losses = []\n",
    "    test_losses = []\n",
    "    for epoch in range(num_epochs):\n",
    "        train_loss = train_epoch(model, trainloader, optimizer, loss_fn, scheduler, device)\n",
    "        train_losses.append(train_loss)\n",
    "\n",
    "        test_loss = test_model(model, test_dataset, batch_size, verbose, device)\n",
    "        test_losses.append(test_loss)\n",
    "        \n",
    "        if verbose:\n",
    "            tqdm.write('Epoch: '+ str(epoch) + ', Train loss: ' + str(train_loss) + ', Test loss: ' + str(test_loss))\n",
    "    \n",
    "    return train_losses, test_losses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_test_delimeter = int(len(all_pairs)*0.7)\n",
    "random.shuffle(all_pairs)\n",
    "\n",
    "train_dataset = DICOMDataset(all_pairs[:train_test_delimeter], 112, 'train')\n",
    "test_dataset  = DICOMDataset(all_pairs[train_test_delimeter:], 112, 'test')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "model = r3d_18(1, device)\n",
    "\n",
    "# model = torch.load(\"V_model_no_norm.pth\")\n",
    "# model.to(device)\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Training: 100%|██████████| 4/4 [00:38<00:00,  9.53s/it]\n",
      "Testing: 100%|██████████| 2/2 [00:14<00:00,  7.17s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0, Train loss: 2476.342325846354, Test loss: tensor(2639.7722)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "train_loss, test_loss = train_test(\n",
    "    model, \n",
    "    train_dataset,\n",
    "    test_dataset,\n",
    "    batch_size=16,\n",
    "    verbose=True, \n",
    "    num_epochs=1, # 200 is ok\n",
    "    device=device,\n",
    "    lr=0.01,\n",
    ")\n",
    "\n",
    "torch.save(model, \"resnet_3d_V86_0.pth\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.plot(range(len(train_loss)), train_loss, label='train loss')\n",
    "plt.plot(range(len(test_loss)), test_loss, label='test loss')\n",
    "plt.legend()\n",
    "plt.grid()\n",
    "plt.show()\n",
    "plt.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 60/60 [00:51<00:00,  1.17it/s]\n"
     ]
    }
   ],
   "source": [
    "train_pairs = []\n",
    "\n",
    "model.cpu()\n",
    "model.eval()\n",
    "with torch.no_grad():\n",
    "    for i in tqdm(range(len(train_dataset))):\n",
    "        img, tgt = train_dataset[i]        \n",
    "        pred = model(img.unsqueeze(0).cpu()).cpu()\n",
    "        train_pairs.append([tgt[0].item(), pred[0][0].item()])\n",
    "#         print(train_pairs[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 26/26 [00:21<00:00,  1.21it/s]\n"
     ]
    }
   ],
   "source": [
    "test_pairs = []\n",
    "\n",
    "model.cpu()\n",
    "model.eval()\n",
    "with torch.no_grad():\n",
    "    for i in tqdm(range(len(test_dataset))):\n",
    "        img, tgt = test_dataset[i]        \n",
    "        pred = model(img.unsqueeze(0).cpu()).cpu()\n",
    "        test_pairs.append([tgt[0].item(), pred[0][0].item()])\n",
    "#         print(test_pairs[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.scatter([p[0] for p in train_pairs], [p[1] for p in train_pairs], label='train')\n",
    "plt.scatter([p[0] for p in test_pairs], [p[1] for p in test_pairs], label='test')\n",
    "plt.plot([20, 80], [20, 80], color='r', label='If accurate')\n",
    "plt.xlabel('True')\n",
    "plt.ylabel('Predicted')\n",
    "\n",
    "plt.legend()\n",
    "plt.grid()\n",
    "plt.show()\n",
    "plt.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16.825821091605565"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tru = [p[0] for p in train_pairs]\n",
    "pre = [p[1] for p in train_pairs]\n",
    "(np.array(tru)-np.array(pre)).std()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15.816232740894812"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tru = [p[0] for p in test_pairs]\n",
    "pre = [p[1] for p in test_pairs]\n",
    "(np.array(tru)-np.array(pre)).std()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = {}\n",
    "data['train_samples'] = [{'true': p[0], 'predicted': p[1]} for p in train_pairs]\n",
    "data['test_samples'] = [{'true': p[0], 'predicted': p[1]} for p in test_pairs]\n",
    "\n",
    "import json\n",
    "with open(file=\"predicted.json\", mode='w') as f:\n",
    "    json.dump(data, f, indent=2)"
   ]
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}