test_adni.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "4b7c36e2",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "import os\n",
    "import time\n",
    "from tqdm import tqdm\n",
    "from pathlib import Path\n",
    "import math\n",
    "\n",
    "from sklearn.model_selection import KFold\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import torch\n",
    "import torch.optim as optim\n",
    "from torch.utils.data import DataLoader, RandomSampler, SequentialSampler\n",
    "from torchsummary import summary\n",
    "from torch.optim.lr_scheduler import _LRScheduler\n",
    "from torch import nn\n",
    "from torch.utils.data import Dataset\n",
    "from torchvision import transforms as T\n",
    "import nibabel as nib\n",
    "from skimage.transform import resize\n",
    "\n",
    "import random\n",
    "\n",
    "def set_seed(seed):\n",
    "    random.seed(seed)\n",
    "    np.random.seed(seed)\n",
    "    torch.manual_seed(seed)\n",
    "    torch.cuda.manual_seed(seed)\n",
    "    torch.cuda.manual_seed_all(seed)\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "\n",
    "set_seed(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "8fea38e6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Model define\n",
    "def initialize_weights(model):\n",
    "    for m in model.modules():\n",
    "        if isinstance(m, nn.Conv3d) or isinstance(m, nn.Linear):\n",
    "            nn.init.kaiming_uniform_(m.weight, nonlinearity='relu')\n",
    "            \n",
    "# Define 3D_CNN model class\n",
    "\n",
    "class CNN(nn.Module):\n",
    "    def __init__(self, in_channels):\n",
    "        super(CNN, self).__init__()\n",
    "        self.conv1 = nn.Sequential(\n",
    "            nn.Conv3d(in_channels, 32, kernel_size=(3,3,3), padding=1),\n",
    "            nn.ReLU(),\n",
    "            nn.BatchNorm3d(32),\n",
    "            nn.Conv3d(32, 32, kernel_size=(3,3,3), padding=1),\n",
    "            nn.ReLU(),\n",
    "            nn.Dropout3d(0.2),\n",
    "            nn.MaxPool3d(kernel_size=(2,2,2))\n",
    "        )\n",
    "\n",
    "        self.conv2 = nn.Sequential(\n",
    "            nn.Conv3d(32, 64, kernel_size=(3,3,3), stride=1, padding=\"same\"),\n",
    "            nn.ReLU(),\n",
    "            nn.BatchNorm3d(64),\n",
    "            nn.Conv3d(64, 64, kernel_size=(3,3,3), stride=1, padding=\"same\"),\n",
    "            nn.ReLU(),\n",
    "            nn.Dropout3d(0.2),\n",
    "            nn.MaxPool3d(kernel_size=(2,2,2))\n",
    "        )\n",
    "\n",
    "        self.conv3 = nn.Sequential(\n",
    "            nn.Conv3d(64, 64, kernel_size=(3,3,3), stride=1, padding=\"same\"),\n",
    "            nn.ReLU(),\n",
    "            nn.BatchNorm3d(64),\n",
    "            nn.Conv3d(64, 64, kernel_size=(3,3,3), stride=1, padding=\"same\"),\n",
    "            nn.ReLU(),\n",
    "            nn.BatchNorm3d(64),\n",
    "            nn.MaxPool3d(2)\n",
    "        )\n",
    "\n",
    "        self.conv4 = nn.Sequential(\n",
    "            nn.Conv3d(64, 64, kernel_size=(3,3,3), stride=1, padding=\"same\"),\n",
    "            nn.ReLU(),\n",
    "            nn.BatchNorm3d(64),\n",
    "            nn.Conv3d(64, 64, kernel_size=(3,3,3), stride=1, padding=\"same\"),\n",
    "            nn.ReLU(),\n",
    "            nn.BatchNorm3d(64),\n",
    "            nn.Conv3d(64, 64, kernel_size=(3,3,3), stride=1, padding=\"same\"),\n",
    "            nn.ReLU(),\n",
    "            nn.BatchNorm3d(64),\n",
    "            nn.MaxPool3d(2)\n",
    "        )\n",
    "\n",
    "        self.conv5 = nn.Sequential(\n",
    "            nn.Conv3d(64, 96, kernel_size=(3,3,3), stride=1, padding=\"same\"),\n",
    "            nn.ReLU(),\n",
    "            nn.BatchNorm3d(96),\n",
    "            nn.Conv3d(96, 96, kernel_size=(3,3,3), stride=1, padding=\"same\"),\n",
    "            nn.ReLU(),\n",
    "            nn.BatchNorm3d(96),\n",
    "            nn.Conv3d(96, 96, kernel_size=(3,3,3), stride=1, padding=\"same\"),\n",
    "            nn.ReLU(),\n",
    "            nn.BatchNorm3d(96),\n",
    "            nn.MaxPool3d(2)\n",
    "        )\n",
    "\n",
    "        self.conv6 = nn.Sequential(\n",
    "            nn.Conv3d(96, 96, kernel_size=(3,3,3), stride=1, padding=\"same\"),\n",
    "            nn.ReLU(),\n",
    "            nn.BatchNorm3d(96),\n",
    "            nn.Conv3d(96, 96, kernel_size=(3,3,3), stride=1, padding=\"same\"),\n",
    "            nn.ReLU(),\n",
    "            nn.BatchNorm3d(96),\n",
    "            nn.Conv3d(96, 96, kernel_size=(3,3,3), stride=1, padding=\"same\"),\n",
    "            nn.ReLU(),\n",
    "            nn.BatchNorm3d(96),\n",
    "            nn.MaxPool3d(2)\n",
    "        )\n",
    "\n",
    "        self.conv7 = nn.Sequential(\n",
    "            nn.Conv3d(96, 96, kernel_size=(3,3,3), stride=1, padding=\"same\"),\n",
    "            nn.ReLU(),\n",
    "            nn.BatchNorm3d(96),\n",
    "            nn.Conv3d(96, 96, kernel_size=(3,3,3), stride=1, padding=\"same\"),\n",
    "            nn.ReLU(),\n",
    "            nn.BatchNorm3d(96),\n",
    "            nn.Conv3d(96, 96, kernel_size=(3,3,3), stride=1, padding=\"same\"),\n",
    "            nn.ReLU(),\n",
    "            nn.BatchNorm3d(96)\n",
    "        )\n",
    "        \n",
    "        self.flatten = nn.Flatten()\n",
    "\n",
    "        self.fc = nn.Sequential(\n",
    "            nn.Linear(768, 96),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(96, 32),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(32, 1)\n",
    "        )\n",
    "            \n",
    "    def forward(self, x):\n",
    "        x = self.conv1(x)\n",
    "        x = self.conv2(x)\n",
    "        x = self.conv3(x)\n",
    "        x = self.conv4(x)\n",
    "        x = self.conv5(x)\n",
    "        x = self.conv6(x)\n",
    "        x = self.conv7(x)\n",
    "        x = self.flatten(x)\n",
    "        x = self.fc(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "0b3c55df",
   "metadata": {},
   "outputs": [],
   "source": [
    "class CustomCosineAnnealingWarmUpRestarts(_LRScheduler):\n",
    "    def __init__(self, optimizer, T_0, T_mult=1, eta_max=0.1, T_up=0, gamma=1., last_epoch=-1):\n",
    "        if T_0 <= 0 or not isinstance(T_0, int):\n",
    "            raise ValueError(\"Expected positive integer T_0, but got {}\".format(T_0))\n",
    "        if T_mult < 1 or not isinstance(T_mult, int):\n",
    "            raise ValueError(\"Expected integer T_mult >= 1, but got {}\".format(T_mult))\n",
    "        if T_up < 0 or not isinstance(T_up, int):\n",
    "            raise ValueError(\"Expected positive integer T_up, but got {}\".format(T_up))\n",
    "        self.T_0 = T_0\n",
    "        self.T_mult = T_mult\n",
    "        self.base_eta_max = eta_max\n",
    "        self.eta_max = eta_max\n",
    "        self.T_up = T_up\n",
    "        self.T_i = T_0\n",
    "        self.gamma = gamma\n",
    "        self.cycle = 0\n",
    "        self.T_cur = last_epoch\n",
    "        super(CustomCosineAnnealingWarmUpRestarts, self).__init__(optimizer, last_epoch)\n",
    "    \n",
    "    def get_lr(self):\n",
    "        if self.T_cur == -1:\n",
    "            return self.base_lrs\n",
    "        elif self.T_cur < self.T_up:\n",
    "            return [(self.eta_max - base_lr)*self.T_cur / self.T_up + base_lr for base_lr in self.base_lrs]\n",
    "        else:\n",
    "            return [base_lr + (self.eta_max - base_lr) * (1 + math.cos(math.pi * (self.T_cur-self.T_up) / (self.T_i - self.T_up))) / 2\n",
    "                    for base_lr in self.base_lrs]\n",
    "\n",
    "    def step(self, epoch=None):\n",
    "        if epoch is None:\n",
    "            epoch = self.last_epoch + 1\n",
    "            self.T_cur = self.T_cur + 1\n",
    "            if self.T_cur >= self.T_i:\n",
    "                self.cycle += 1\n",
    "                self.T_cur = self.T_cur - self.T_i\n",
    "                self.T_i = (self.T_i - self.T_up) * self.T_mult + self.T_up\n",
    "        else:\n",
    "            if epoch >= self.T_0:\n",
    "                if self.T_mult == 1:\n",
    "                    self.T_cur = epoch % self.T_0\n",
    "                    self.cycle = epoch // self.T_0\n",
    "                else:\n",
    "                    n = int(math.log((epoch / self.T_0 * (self.T_mult - 1) + 1), self.T_mult))\n",
    "                    self.cycle = n\n",
    "                    self.T_cur = epoch - self.T_0 * (self.T_mult ** n - 1) / (self.T_mult - 1)\n",
    "                    self.T_i = self.T_0 * self.T_mult ** (n)\n",
    "            else:\n",
    "                self.T_i = self.T_0\n",
    "                self.T_cur = epoch\n",
    "                \n",
    "        self.eta_max = self.base_eta_max * (self.gamma**self.cycle)\n",
    "        self.last_epoch = math.floor(epoch)\n",
    "        for param_group, lr in zip(self.optimizer.param_groups, self.get_lr()):\n",
    "            param_group['lr'] = lr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "e4aaf7b8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define trainer\n",
    "class CNN_Trainer():\n",
    "    def __init__(\n",
    "            self, \n",
    "            model, \n",
    "            results_folder, \n",
    "            dataloader_train, \n",
    "            dataloader_valid, \n",
    "            dataloader_test, \n",
    "            epochs, \n",
    "            optimizer,\n",
    "            scheduler,\n",
    "            n_iter):\n",
    "        super(CNN_Trainer, self).__init__()\n",
    "\n",
    "        self.model = model\n",
    "        self.dataloader_train = dataloader_train\n",
    "        self.dataloader_valid = dataloader_valid\n",
    "        self.dataloader_test = dataloader_test\n",
    "        self.epoch = 0\n",
    "        self.epochs = epochs\n",
    "        self.optimizer = optimizer\n",
    "        self.scheduler = scheduler\n",
    "        self.mse_loss_fn = nn.MSELoss()\n",
    "        self.mae_loss_fn = nn.L1Loss()\n",
    "\n",
    "        self.cv_num = n_iter\n",
    "        self.results_folder = Path(results_folder)\n",
    "        self.results_folder.mkdir(exist_ok=True)\n",
    "\n",
    "        self.train_mse_list, self.train_mae_list = [], []\n",
    "        self.valid_mse_list, self.valid_mae_list = [], []\n",
    "        self.output_array, self.target_array = np.array([]), np.array([])\n",
    "\n",
    "#         wandb.watch(self.model, log=\"all\")\n",
    "\n",
    "    def train(self):\n",
    "        print(\"[ Start ]\")\n",
    "        \n",
    "        latest_model_path = sorted(self.results_folder.glob(f'cv-{self.cv_num}-*.pth.tar'), \n",
    "                                key=lambda x: int(x.stem.split('-')[2].split('.')[0]))\n",
    "        if latest_model_path:\n",
    "            # Parse the filename to get the epoch number\n",
    "            latest_epoch_num = int(latest_model_path[-1].stem.split('-')[2].split('.')[0]) - 1\n",
    "            # Load the model\n",
    "            self.load(latest_epoch_num)\n",
    "            # Update self.epoch\n",
    "            self.epoch = latest_epoch_num + 1\n",
    "            \n",
    "            if self.valid_mae_list:\n",
    "                valid_loss_min = self.valid_mse_list[-1]\n",
    "            else:\n",
    "                valid_loss_min = 10000\n",
    "            \n",
    "            print(f\"Loaded model: {latest_model_path[-1]}, Starting from epoch: {self.epoch} / {self.epochs}\")\n",
    "\n",
    "\n",
    "        self.model.train()\n",
    "        \n",
    "        start = time.time()  # Start time\n",
    "        while self.epoch < self.epochs:\n",
    "            print(f\"\\nEpoch {self.epoch+1:3d}: training\")\n",
    "            train_mse_sum, train_mae_sum = 0, 0\n",
    "            for batch_ID, (input, target) in enumerate(tqdm(self.dataloader_train)):\n",
    "                input = input.cuda(non_blocking=True)\n",
    "                target = target.reshape(-1, 1)\n",
    "                target = target.cuda(non_blocking=True)\n",
    "                \n",
    "                output = self.model(input)\n",
    "                \n",
    "                # ----------- update -----------\n",
    "                self.optimizer.zero_grad()\n",
    "\n",
    "                mse_loss = self.mse_loss_fn(output, target)\n",
    "                mae_loss = self.mae_loss_fn(output, target)\n",
    "                \n",
    "                mse_loss.backward() # loss_fn should be the one used for backpropagation\n",
    "                self.optimizer.step()\n",
    "                self.scheduler.step()\n",
    "                \n",
    "#                 wandb.log({\n",
    "#                 \"Learning rate\": self.optimizer.param_groups[0]['lr'],\n",
    "#                 })\n",
    "\n",
    "                train_mse_sum += mse_loss.item()*input.size(0)\n",
    "                train_mae_sum += mae_loss.item()*input.size(0)\n",
    "\n",
    "            train_mse_avg = train_mse_sum / len(self.dataloader_train.dataset)\n",
    "            train_mae_avg = train_mae_sum / len(self.dataloader_train.dataset)\n",
    "\n",
    "            self.train_mse_list.append(train_mse_avg)\n",
    "            self.train_mae_list.append(train_mae_avg)\n",
    "            \n",
    "#             wandb.log({\n",
    "#                 \"Epoch\": self.epoch+1,\n",
    "#                 \"Learning rate\": self.optimizer.param_groups[0]['lr'],\n",
    "#                 \"Train MSE Loss\": train_mse_avg,\n",
    "#                 \"Train MAE Loss\": train_mae_avg,\n",
    "#                 \"CV Split Number\": self.cv_num\n",
    "#             })\n",
    "            \n",
    "            end = time.time()  # End time\n",
    "            # Compute the duration and GPU usage\n",
    "            duration = (end - start) / 60\n",
    "            print(f\"Epoch: {self.epoch+1}, duration for training: {duration:.2f} minutes\")\n",
    "\n",
    "            # validation step\n",
    "            print(f\"\\nEpoch {self.epoch+1:3d}: validation\")\n",
    "            start = time.time()  # Start time\n",
    "            self.model.eval()\n",
    "            with torch.no_grad():\n",
    "                valid_mse_sum, valid_mae_sum = 0, 0\n",
    "                for _, (input, target) in enumerate(tqdm(self.dataloader_valid)):\n",
    "                    input = input.cuda(non_blocking=True)\n",
    "                    target = target.reshape(-1, 1)\n",
    "                    target = target.cuda(non_blocking=True)\n",
    "\n",
    "                    output = self.model(input)\n",
    "\n",
    "                    mse_loss = self.mse_loss_fn(output, target) \n",
    "                    mae_loss = self.mae_loss_fn(output, target)\n",
    "\n",
    "                    valid_mse_sum += mse_loss.item()*input.size(0) # mse_loss.item() * input.size(0): 각 배치에서의 총 손실을 계산\n",
    "                                                                   # input.size(0): 배치 내의 샘플 수를 반환, 이것을 MSE 손실 값에 곱하면 해당 배치의 전체 손실\n",
    "                                                                   # validation set의 모든 배치를 통해 계산된 총 손실을 더하여 합산\n",
    "                    valid_mae_sum += mae_loss.item()*input.size(0)\n",
    "\n",
    "                valid_mse_avg = valid_mse_sum / len(self.dataloader_valid.dataset)\n",
    "                valid_mae_avg = valid_mae_sum / len(self.dataloader_valid.dataset)\n",
    "\n",
    "                self.valid_mse_list.append(valid_mse_avg)\n",
    "                self.valid_mae_list.append(valid_mae_avg)\n",
    "                \n",
    "                self.scheduler.step(valid_mse_avg)\n",
    "                print(f\"    Epoch {self.epoch+1:2d}: training mse loss = {train_mse_avg:.3f} / validation mse loss = {valid_mse_avg:.3f}\")\n",
    "                print(f\"    Epoch {self.epoch+1:2d}: training mae loss = {train_mae_avg:.3f} / validation mae loss = {valid_mae_avg:.3f}\")\n",
    "                \n",
    "                self.save(self.epoch)\n",
    "\n",
    "                # # Print model if better validation loss\n",
    "                # if valid_mse_avg < valid_loss_min:\n",
    "                #     print(\">>>>>>>>>>>>>>>>>> Loss updates\")\n",
    "                #     valid_loss_min = valid_mse_avg\n",
    "                #     print(f\"    Best Saved model: best-{self.results_folder}-{self.epoch+1}.pth.tar\")\n",
    "                    \n",
    "#                 wandb.log({\n",
    "#                     \"Epoch\": self.epoch+1,\n",
    "#                     \"Learning rate\": self.optimizer.param_groups[0]['lr'],\n",
    "#                     \"Validation MSE Loss\": valid_mse_avg,\n",
    "#                     \"Validation MAE Loss\": valid_mae_avg\n",
    "#                 })\n",
    "                \n",
    "            self.epoch += 1\n",
    "            \n",
    "        print(\"[ End of Epoch ]\")\n",
    "        end = time.time()  # End time\n",
    "        # Compute the duration and GPU usage\n",
    "        duration = (end - start) / 60\n",
    "        print(f\"Epoch: {self.epoch}, duration for validation: {duration:.2f} minutes\")\n",
    "        \n",
    "        return self.train_mse_list, self.train_mae_list, self.valid_mse_list, self.valid_mae_list\n",
    "    \n",
    "    \n",
    "    def test(self):\n",
    "        print(\"[ Start test ]\")\n",
    "        self.model.eval()\n",
    "        output_array = np.array([])\n",
    "        target_array = np.array([])\n",
    "        with torch.no_grad():\n",
    "            test_mse_sum, test_mae_sum = 0, 0\n",
    "            for _, (input, target) in enumerate(tqdm(self.dataloader_test)):\n",
    "                input = input.cuda(non_blocking=True)\n",
    "                target = target.reshape(-1, 1)\n",
    "                target = target.cuda(non_blocking=True)\n",
    "\n",
    "                output = self.model(input)\n",
    "\n",
    "                output_array = np.append(output_array, output.cpu().numpy())\n",
    "                target_array = np.append(target_array, target.cpu().numpy())\n",
    "\n",
    "                mse_loss = self.mse_loss_fn(output, target) \n",
    "                mae_loss = self.mae_loss_fn(output, target)\n",
    "\n",
    "                test_mse_sum += mse_loss.item()*input.size(0)\n",
    "                test_mae_sum += mae_loss.item()*input.size(0)\n",
    "\n",
    "            test_mse_avg = test_mse_sum / len(self.dataloader_test.dataset)\n",
    "            test_mae_avg = test_mae_sum / len(self.dataloader_test.dataset)\n",
    "\n",
    "            print(f\"test mse loss = {test_mse_avg:.3f} / test mae loss = {test_mae_avg:.3f}\")\n",
    "\n",
    "        print(\"[ End test ]\")\n",
    "        return output_array, target_array\n",
    "\n",
    "\n",
    "#             wandb.log({\n",
    "#                 \"Test MSE Loss\": test_mse_avg,\n",
    "#                 \"Test MAE Loss\": test_mae_avg\n",
    "#             })\n",
    "            \n",
    "        print(\"[ End test ]\")\n",
    "        return test_mse_avg, test_mae_avg\n",
    "    \n",
    "    def save(self, milestone):\n",
    "        torch.save({\"epoch\": milestone+1, \n",
    "                    \"state_dict\": self.model.state_dict(), \n",
    "                    \"optimizer\" : self.optimizer.state_dict(),  \n",
    "                    \"train_mse_list\": self.train_mse_list,\n",
    "                    \"train_mae_list\": self.train_mae_list,\n",
    "                    \"valid_mse_list\": self.valid_mse_list,\n",
    "                    \"valid_mae_list\": self.valid_mae_list},  \n",
    "                    f\"{self.results_folder}/cv-{self.cv_num}-{milestone+1}.pth.tar\")\n",
    "        \n",
    "#     def load(self, milestone):\n",
    "#         checkpoint = torch.load(f\"{self.results_folder}/cv-{self.cv_num}-{milestone+1}.pth.tar\")\n",
    "#         self.model.load_state_dict(checkpoint[\"state_dict\"])\n",
    "#         self.optimizer.load_state_dict(checkpoint[\"optimizer\"])\n",
    "#         self.epoch = checkpoint[\"epoch\"] + 1  # Start the next epoch after the checkpoint\n",
    "#         self.train_mse_list = checkpoint.get(\"train_mse_list\", [])\n",
    "#         self.train_mae_list = checkpoint.get(\"train_mae_list\", [])\n",
    "#         self.valid_mse_list = checkpoint.get(\"valid_mse_list\", [])\n",
    "#         self.valid_mae_list = checkpoint.get(\"valid_mae_list\", [])\n",
    "    \n",
    "    def load(self, checkpoint):\n",
    "        self.model.load_state_dict(checkpoint[\"state_dict\"])\n",
    "        self.optimizer.load_state_dict(checkpoint[\"optimizer\"])\n",
    "        self.epoch = checkpoint[\"epoch\"]  # Get the epoch directly from the checkpoint\n",
    "        self.train_mse_list = checkpoint.get(\"train_mse_list\", [])\n",
    "        self.train_mae_list = checkpoint.get(\"train_mae_list\", [])\n",
    "        self.valid_mse_list = checkpoint.get(\"valid_mse_list\", [])\n",
    "        self.valid_mae_list = checkpoint.get(\"valid_mae_list\", [])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66a955e3",
   "metadata": {},
   "source": [
    "\n",
    "# Healthy samples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "2f20f82c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ukbb_pd = pd.read_csv('/media/leelabsg-storage1/yein/research/BrainAging/0722/csv/ukbb_cn.csv')\n",
    "adni_pd = pd.read_csv('/media/leelabsg-storage1/yein/research/BrainAging/0722/csv/fsdat_baseline_cn.csv')\n",
    "\n",
    "plt.hist(adni_pd['age'], bins=30, alpha=0.5, label='ADNI', density=True, edgecolor='black')\n",
    "plt.hist(ukbb_pd['age'], bins=30, alpha=0.5, label='UKBB', density=True, edgecolor='black')\n",
    "\n",
    "plt.title('Age Distribution of Healty Individuals')\n",
    "plt.xlabel('Age')\n",
    "plt.ylabel('Density')\n",
    "\n",
    "plt.legend(loc='upper right')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "b566e695",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ADNI Statistics:\n",
      "count    630.000000\n",
      "mean      72.764286\n",
      "std        7.127740\n",
      "min       55.200000\n",
      "25%       67.600000\n",
      "50%       71.750000\n",
      "75%       77.450000\n",
      "max       94.700000\n",
      "Name: age, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "print('ADNI Statistics:')\n",
    "print(adni_pd['age'].describe())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "d91b7e65",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "UKBB Statistics:\n",
      "count    25656.000000\n",
      "mean        60.416004\n",
      "std          7.382716\n",
      "min         44.000000\n",
      "25%         54.750000\n",
      "50%         61.000000\n",
      "75%         66.000000\n",
      "max         77.000000\n",
      "Name: age, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "print('\\nUKBB Statistics:')\n",
    "print(ukbb_pd['age'].describe())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "c466f78e",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ADNI_Dataset(Dataset):\n",
    "    def __init__(self, image_path, label_path, indices, image_size=128):\n",
    "        super(ADNI_Dataset, self).__init__()\n",
    "        self.data_dir = image_path\n",
    "        self.data_csv = pd.read_csv(label_path)\n",
    "        \n",
    "        # Use 'file_name' column to create image paths\n",
    "        self.files = self.data_csv.loc[indices, 'File_name'].tolist()\n",
    "        print(f\"Number of files loaded: {len(self.files)}\")  # Add this line\n",
    "\n",
    "        self.input_size = (1, 128, 128, 128)\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        # label = self.data_csv.loc[index, 'age']\n",
    "        label = self.data_csv.loc[index, 'age']\n",
    "        file_name = self.data_csv.loc[index, 'File_name']\n",
    "#         print(f'Index: {index},   File name: {file_name},   Age: {label}')\n",
    "\n",
    "        # Use 'file_name' to construct the image path\n",
    "        image_path = os.path.join(self.data_dir, file_name, 'brain_to_MNI_nonlin.nii.gz')\n",
    "\n",
    "        # Convert Nifti1Image to numpy array\n",
    "        image = nib.load(image_path).get_fdata()\n",
    "\n",
    "        # Resize the image to desired size if necessary\n",
    "        image = resize(image, self.input_size)\n",
    "\n",
    "        # Convert numpy array to PyTorch tensor\n",
    "        image = torch.from_numpy(image).float()\n",
    "\n",
    "        age = torch.tensor(label, dtype=torch.float32)\n",
    "        \n",
    "        return (image, age)\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.files)\n",
    "\n",
    "    def collate_fn(self, batch):\n",
    "        images, labels = zip(*batch)  # separate images and labels\n",
    "        images = torch.stack(images)  # stack images into a tensor\n",
    "        labels = torch.tensor(labels)  # convert labels into a tensor\n",
    "        return images, labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "32ffb34a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of gpus:  2\n",
      "Total dataset indices: 630\n",
      "Age distribution:  count    630.000000\n",
      "mean      72.764286\n",
      "std        7.127740\n",
      "min       55.200000\n",
      "25%       67.600000\n",
      "50%       71.750000\n",
      "75%       77.450000\n",
      "max       94.700000\n",
      "Name: age, dtype: float64\n",
      "Number of files loaded: 630\n",
      "Length of test dataset: 630\n"
     ]
    }
   ],
   "source": [
    "DATA = '/media/leelabsg-storage1/DATA/ADNI/adni_t1s_baseline' \n",
    "LABEL = '/media/leelabsg-storage1/yein/research/BrainAging/0724_leelabgpu/csv/fsdat_baseline_cn.csv' \n",
    "\n",
    "ngpus = torch.cuda.device_count()\n",
    "print(\"Number of gpus: \", ngpus)\n",
    "\n",
    "# wandb.init(project='test')\n",
    "\n",
    "# hypterparameters\n",
    "BATCH_SIZE = 8\n",
    "EPOCHS = 2\n",
    "RESULTS_FOLDER = './test'\n",
    "INPUT_SIZE = (1, 128, 128, 128)\n",
    "LEARNING_RATE = 1e-6\n",
    "N_WORKERS = 2\n",
    "\n",
    "\n",
    "# create our k-folds\n",
    "kf = KFold(n_splits=4, random_state=7, shuffle=True)\n",
    "n_iter = 0\n",
    "\n",
    "dataset_pd = pd.read_csv(LABEL)\n",
    "# obtain the indices for our dataset\n",
    "indices = list(range(len(dataset_pd)))\n",
    "print(f\"Total dataset indices: {len(indices)}\")\n",
    "\n",
    "# Data paths and hyperparameters\n",
    "print(\"Age distribution: \", dataset_pd['age'].describe())\n",
    "\n",
    "\n",
    "# --------------------------------------------------------------------------------------------------------------\n",
    "\n",
    "# Initialize your model (Make sure it's the same architecture as the one you trained)\n",
    "model = CNN(in_channels=1).cuda()  \n",
    "# Put your model on the GPU\n",
    "model = torch.nn.DataParallel(model)\n",
    "\n",
    "# Define your optimizer and scheduler\n",
    "optimizer = optim.Adam(model.parameters(), lr=LEARNING_RATE)\n",
    "t_0 = int(len(dataset_pd) * 0.75 // BATCH_SIZE // 6)\n",
    "scheduler = CustomCosineAnnealingWarmUpRestarts(optimizer,T_0= t_0, T_up=10, T_mult=2, eta_max=1e-3, gamma=0.5)\n",
    "\n",
    "# Loss function\n",
    "mse_criterion = torch.nn.MSELoss()\n",
    "mae_criterion = torch.nn.L1Loss()\n",
    "    \n",
    "test_indices = list(dataset_pd.index)\n",
    "\n",
    "# Create test dataset\n",
    "test_dataset = ADNI_Dataset(DATA, LABEL, test_indices)\n",
    "\n",
    "# Create DataLoader for test set\n",
    "dataloader_test = DataLoader(test_dataset, \n",
    "                             batch_size=1, \n",
    "                             sampler=SequentialSampler(test_dataset),\n",
    "                             collate_fn=test_dataset.collate_fn,\n",
    "                             pin_memory=True,\n",
    "                             num_workers=2)\n",
    "print(f\"Length of test dataset: {len(dataloader_test.dataset)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "5023e347",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load the checkpoints for the 17th and 40th epochs\n",
    "checkpoint_17 = torch.load(\"/media/leelabsg-storage1/yein/research/BrainAging/0726_titan/model/esb_2/cv-0-17.pth.tar\")\n",
    "checkpoint_40 = torch.load(\"/media/leelabsg-storage1/yein/research/BrainAging/0726_titan/model/esb_2/cv-0-40.pth.tar\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "8234d9a1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize the trainer\n",
    "trainer = CNN_Trainer(\n",
    "    model=model, \n",
    "    results_folder=RESULTS_FOLDER,  # replace with the path where your results are saved\n",
    "    dataloader_train=None,  # You don't need the training set for inference\n",
    "    dataloader_valid=None,  # You don't need the validation set for inference\n",
    "    dataloader_test=dataloader_test, \n",
    "    epochs=0,  # You don't need to specify epochs for inference\n",
    "    optimizer=optimizer,\n",
    "    scheduler=scheduler,\n",
    "    n_iter=4  # replace with the appropriate iteration number\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "13201735",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ Start test ]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 630/630 [03:26<00:00,  3.05it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test mse loss = 173.862 / test mae loss = 11.444\n",
      "[ End test ]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "# Load the 17th epoch's model state and get its predictions\n",
    "trainer.load(checkpoint_17)\n",
    "predictions_17, targets = trainer.test()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "eb49e13b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ Start test ]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 630/630 [03:33<00:00,  2.95it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test mse loss = 333.016 / test mae loss = 16.644\n",
      "[ End test ]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "# Load the 40th epoch's model state and get its predictions\n",
    "trainer.load(checkpoint_40)\n",
    "predictions_40, targets_40 = trainer.test()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "6aae670c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pearson correlation between 17th and 40th epoch models: -0.1413452862084732\n"
     ]
    }
   ],
   "source": [
    "from scipy.stats import pearsonr\n",
    "\n",
    "# Compute Pearson correlation\n",
    "correlation, _ = pearsonr(predictions_17, predictions_40)\n",
    "print('Pearson correlation between 17th and 40th epoch models:', correlation)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af1015e9",
   "metadata": {},
   "source": [
    "### 두 모델의 예측 결과 간의 상관관계 계산"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "c874911d",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pearson correlation between 17th and 40th epoch models: -0.1413452862084732\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Compute Pearson correlation\n",
    "correlation, _ = pearsonr(predictions_17, predictions_40)\n",
    "print('Pearson correlation between 17th and 40th epoch models:', correlation)\n",
    "\n",
    "# Create scatter plot\n",
    "plt.figure(figsize=(8, 8))\n",
    "plt.scatter(predictions_17, predictions_40, alpha=0.5)\n",
    "\n",
    "# Fit a linear trend line\n",
    "m, b = np.polyfit(predictions_17, predictions_40, 1)\n",
    "plt.plot(predictions_17, m*predictions_17 + b, color='red')\n",
    "\n",
    "plt.title('Scatter plot of the predictions of 17th and 40th epoch models')\n",
    "plt.xlabel('Predictions of 17th epoch model')\n",
    "plt.ylabel('Predictions of 40th epoch model')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6124bc4d",
   "metadata": {},
   "source": [
    "### Mean 비교"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "61a4f272",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean predicted age for 17-epoch model: 61.56927387298099\n",
      "Mean predicted age for 40-epoch model: 56.13682188003782\n"
     ]
    }
   ],
   "source": [
    "print(f'Mean predicted age for 17-epoch model: {np.mean(predictions_17)}')\n",
    "print(f'Mean predicted age for 40-epoch model: {np.mean(predictions_40)}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "2227f1e1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean actual age for 17-epoch model: 72.76428569006542\n",
      "Mean actual age for 40-epoch model: 72.76428569006542\n"
     ]
    }
   ],
   "source": [
    "print(f'Mean actual age for 17-epoch model: {np.mean(targets_17)}')\n",
    "print(f'Mean actual age for 40-epoch model: {np.mean(target_40)}')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "ba_torch",
   "language": "python",
   "name": "ba_torch"
  },
  "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.9.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}