tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "d350ac80",
   "metadata": {},
   "source": [
    "Welcome to Voxelmap!\n",
    "\n",
    "The first thing we'll do is train the neural network (Network A). We'll then test the network to see how it performs. After you've installed all the dependencies in the setup.cfg file, let's do some imports to get started."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "e9acabbf",
   "metadata": {},
   "outputs": [],
   "source": [
    "# imports\n",
    "import time\n",
    "import os\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "from utilities import network_a, losses\n",
    "import torch\n",
    "from torch.utils.data import Dataset\n",
    "import torch.optim as optim\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e4c370f",
   "metadata": {},
   "source": [
    "We recommend installing the example data at https://ses.library.usyd.edu.au/handle/2123/32282 and adding the unzipped 'data' folder to your present working directory. We'll then define our image directory as 'data/xcat/train' and define a filename to save our weights and loss plots."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "2fc43d85",
   "metadata": {},
   "outputs": [],
   "source": [
    "# file name and image directory\n",
    "im_dir = 'data/xcat/train'\n",
    "expt_description = 'Network A'\n",
    "filename = 'train_a'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "009a69f8",
   "metadata": {},
   "source": [
    "Next we'll create a class called 'SupervisedDataset'. This will allow us to load the appropriate data onto the neural network for training. There are a few idiosyncrasies that we may wish to note. First, all the projection data ends in 'bin.npy' because they were originally created as binary files but were converted to .npy files for convience. The same goes for the volumes and DVFs, which end in 'mha.npy' for similar reasons. The source projection has a '06' in front because, in 4D-CTs the 6 respiratory bin corresponds with the peak-exhale phase. We name our projections 'phase_Proj_num', where phase is respiratory phase (i.e. '01', '02', ... '10') and num is the projection number (e.g. '00001'). For Networks D and E, where we train on the CoMBAT MRI data, the naming convention for slice pairs is 'phase_Slice_xc_ys' where x is the slice number along the coronal axis and y is the slice number along the sagittal axis.\n",
    "\n",
    "An abdominal mask is used later on in the loss function to force the neural network to optimise predictions within a specific region. The data are then reshaped for the specific dimensions expected for a PyTorch neural network. Right now we are also limited to image sizes that are powers of two (e.g. projections 128x128 and volumes 128x128x128). Everything has been downsampled here to fit on the GPU."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "db2b5c72",
   "metadata": {},
   "outputs": [],
   "source": [
    "# set up training dataset class\n",
    "class SupervisedDataset(Dataset):\n",
    "    def __init__(self, im_dir=None, im_size=None):\n",
    "        self.im_dir = im_dir\n",
    "        self.im_size = im_size\n",
    "\n",
    "    def __len__(self):\n",
    "        return len([n for n in os.listdir(self.im_dir) if n.endswith('_bin.npy')])\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        # Find target projection\n",
    "        proj_list = sorted([n for n in os.listdir(self.im_dir) if n.endswith('_bin.npy')])\n",
    "        target_file = proj_list[idx]\n",
    "        proj_name = os.path.join(self.im_dir, format(target_file))\n",
    "        target_proj = np.load(proj_name)\n",
    "        target_proj = (target_proj - np.min(target_proj)) / (np.max(target_proj) - np.min(target_proj))\n",
    "\n",
    "        # Find target DVF\n",
    "        vol_num = target_file[:2]\n",
    "        dvf_name = os.path.join(self.im_dir, format('sub_DVF_' + vol_num + '_mha.npy'))\n",
    "        target_dvf = np.load(dvf_name)\n",
    "\n",
    "        # Find source projection\n",
    "        source_file = '06_' + target_file[3:]\n",
    "        proj_name = os.path.join(self.im_dir, format(source_file))\n",
    "        source_proj = np.load(proj_name)\n",
    "        source_proj = (source_proj - np.min(source_proj)) / (np.max(source_proj) - np.min(source_proj))\n",
    "\n",
    "        # Find source volume\n",
    "        vol_name = os.path.join(self.im_dir, format('sub_CT_06_mha.npy'))\n",
    "        source_vol = np.load(vol_name)\n",
    "        source_vol = (source_vol - np.min(source_vol)) / (np.max(source_vol) - np.min(source_vol))\n",
    "\n",
    "        # Find source abdomen\n",
    "        vol_name = os.path.join(self.im_dir, format('sub_Abdomen_mha.npy'))\n",
    "        source_hull = np.load(vol_name)\n",
    "\n",
    "        # Reshape data\n",
    "        source_projections = np.zeros((1, self.im_size, self.im_size), dtype=np.float32)\n",
    "        source_projections[0, :, :] = np.asarray(source_proj)\n",
    "        target_projections = np.zeros((1, self.im_size, self.im_size), dtype=np.float32)\n",
    "        target_projections[0, :, :] = np.asarray(target_proj)\n",
    "\n",
    "        source_volumes = np.zeros((1, self.im_size, self.im_size, self.im_size), dtype=np.float32)\n",
    "        source_volumes[0, :, :, :] = np.asarray(source_vol)\n",
    "        source_abdomen = np.zeros((1, self.im_size, self.im_size, self.im_size), dtype=np.float32)\n",
    "        source_abdomen[0, :, :, :] = np.asarray(source_hull)\n",
    "\n",
    "        target_flow = np.zeros((3, self.im_size, self.im_size, self.im_size), dtype=np.float32)\n",
    "        target_flow[0, :, :, :] = target_dvf[:, :, :, 0]\n",
    "        target_flow[1, :, :, :] = target_dvf[:, :, :, 1]\n",
    "        target_flow[2, :, :, :] = target_dvf[:, :, :, 2]\n",
    "\n",
    "        data = {'source_projections': torch.from_numpy(source_projections),\n",
    "                'target_projections': torch.from_numpy(target_projections),\n",
    "                'source_volumes': torch.from_numpy(source_volumes),\n",
    "                'source_abdomen': torch.from_numpy(source_abdomen),\n",
    "                'target_flow': torch.from_numpy(target_flow)}\n",
    "        \n",
    "        return data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3661be30",
   "metadata": {},
   "source": [
    "Let's visualise a projection, a volume and a DVF to make sure our dataloader is working properly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "10e61b7e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Generate test loader\n",
    "batch_size = 1\n",
    "im_size = 128\n",
    "exampleset = SupervisedDataset(im_dir=im_dir, im_size=im_size)\n",
    "exampleloader = torch.utils.data.DataLoader(exampleset, batch_size=batch_size)\n",
    "data = next(iter(exampleloader))\n",
    "\n",
    "source_proj, target_proj, source_vol, source_abdomen, target_flow = data['source_projections'], \\\n",
    "                                                                                        data['target_projections'], \\\n",
    "                                                                                        data['source_volumes'], \\\n",
    "                                                                                        data['source_abdomen'], \\\n",
    "                                                                                        data['target_flow']\n",
    "# visualise projection, volume and DVF\n",
    "f = plt.figure()\n",
    "plt.subplot(1,3,1)\n",
    "source_proj = np.squeeze(source_proj)\n",
    "plt.imshow(source_proj, cmap='gray')\n",
    "plt.title('Source projection')\n",
    "\n",
    "plt.subplot(1,3,2)\n",
    "source_vol = np.squeeze(source_vol)\n",
    "plt.imshow(np.transpose(source_vol[:,:, int(source_vol.shape[2] / 2)]), cmap='gray')\n",
    "plt.title('Source volume')\n",
    "\n",
    "plt.subplot(1,3,3)\n",
    "target_flow = np.squeeze(target_flow)\n",
    "plt.imshow(np.flipud(np.transpose(target_flow[1,:,:, int(source_vol.shape[2] / 2)])), cmap='gray')\n",
    "plt.title('Target DVF')\n",
    "\n",
    "f.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc96841a",
   "metadata": {},
   "source": [
    "Lookin' good! Now we will create training and validation datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "40a6e45b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# generate train/test split\n",
    "im_size = 128\n",
    "batch_size = 8\n",
    "dataset = SupervisedDataset(im_dir=im_dir, im_size=im_size)\n",
    "split = [int(len(dataset) * 0.9), int(len(dataset) * 0.1)]\n",
    "trainset, valset = torch.utils.data.dataset.random_split(dataset, split)\n",
    "trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size, shuffle=True)\n",
    "valloader = torch.utils.data.DataLoader(valset, batch_size=batch_size, shuffle=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6275257b",
   "metadata": {},
   "source": [
    "Network time! Let's set up a cuda implementation of the network, a loss function (good ol' MSE will do! but we're computing it within a thoracoabdominal mask) and an optimizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "3b541a20",
   "metadata": {},
   "outputs": [],
   "source": [
    "# set up network\n",
    "model = network_a.model(im_size, int_steps=10)\n",
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "model.to(device)\n",
    "\n",
    "# set loss function and optimizer\n",
    "flow_mask = losses.flow_mask()\n",
    "lr = 1e-5\n",
    "optimizer = optim.Adam(model.parameters(), lr=lr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb7e0486",
   "metadata": {},
   "source": [
    "Are you ready? Next thing to do is to train the network :) We'll save the weights and a plot of the loss curves. We recommend training for 50 epochs. (Using a NVIDIA RTX A6000, this will take 6-8 hours, so we may need to come back tomorrow.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "fe9a96eb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training (on cuda:0)...\n",
      "Epoch: 1 | train loss: 0.0942 | val loss: 0.0281 | total time: 0 hours 7 minutes\n",
      "Epoch: 2 | train loss: 0.0426 | val loss: 0.0138 | total time: 0 hours 15 minutes\n",
      "Epoch: 3 | train loss: 0.0270 | val loss: 0.0501 | total time: 0 hours 23 minutes\n",
      "Epoch: 4 | train loss: 0.0185 | val loss: 0.0180 | total time: 0 hours 31 minutes\n",
      "Epoch: 5 | train loss: 0.0135 | val loss: 0.0051 | total time: 0 hours 38 minutes\n",
      "Epoch: 6 | train loss: 0.0101 | val loss: 0.0125 | total time: 0 hours 46 minutes\n",
      "Epoch: 7 | train loss: 0.0080 | val loss: 0.0103 | total time: 0 hours 54 minutes\n",
      "Epoch: 8 | train loss: 0.0067 | val loss: 0.0015 | total time: 1 hours 2 minutes\n",
      "Epoch: 9 | train loss: 0.0056 | val loss: 0.0069 | total time: 1 hours 10 minutes\n",
      "Epoch: 10 | train loss: 0.0048 | val loss: 0.0082 | total time: 1 hours 18 minutes\n",
      "Epoch: 11 | train loss: 0.0036 | val loss: 0.0042 | total time: 1 hours 26 minutes\n",
      "Epoch: 12 | train loss: 0.0028 | val loss: 0.0016 | total time: 1 hours 33 minutes\n",
      "Epoch: 13 | train loss: 0.0025 | val loss: 0.0012 | total time: 1 hours 41 minutes\n",
      "Epoch: 14 | train loss: 0.0023 | val loss: 0.0021 | total time: 1 hours 49 minutes\n",
      "Epoch: 15 | train loss: 0.0019 | val loss: 0.0011 | total time: 1 hours 57 minutes\n",
      "Epoch: 16 | train loss: 0.0019 | val loss: 0.0023 | total time: 2 hours 5 minutes\n",
      "Epoch: 17 | train loss: 0.0017 | val loss: 0.0015 | total time: 2 hours 13 minutes\n",
      "Epoch: 18 | train loss: 0.0016 | val loss: 0.0015 | total time: 2 hours 21 minutes\n",
      "Epoch: 19 | train loss: 0.0017 | val loss: 0.0012 | total time: 2 hours 28 minutes\n",
      "Epoch: 20 | train loss: 0.0013 | val loss: 0.0010 | total time: 2 hours 36 minutes\n",
      "Epoch: 21 | train loss: 0.0012 | val loss: 0.0014 | total time: 2 hours 44 minutes\n",
      "Epoch: 22 | train loss: 0.0014 | val loss: 0.0009 | total time: 2 hours 52 minutes\n",
      "Epoch: 23 | train loss: 0.0013 | val loss: 0.0012 | total time: 3 hours 0 minutes\n",
      "Epoch: 24 | train loss: 0.0013 | val loss: 0.0009 | total time: 3 hours 8 minutes\n",
      "Epoch: 25 | train loss: 0.0012 | val loss: 0.0011 | total time: 3 hours 16 minutes\n",
      "Epoch: 26 | train loss: 0.0011 | val loss: 0.0011 | total time: 3 hours 23 minutes\n",
      "Epoch: 27 | train loss: 0.0012 | val loss: 0.0008 | total time: 3 hours 31 minutes\n",
      "Epoch: 28 | train loss: 0.0011 | val loss: 0.0010 | total time: 3 hours 39 minutes\n",
      "Epoch: 29 | train loss: 0.0010 | val loss: 0.0013 | total time: 3 hours 47 minutes\n",
      "Epoch: 30 | train loss: 0.0011 | val loss: 0.0009 | total time: 3 hours 55 minutes\n",
      "Epoch: 31 | train loss: 0.0011 | val loss: 0.0028 | total time: 4 hours 3 minutes\n",
      "Epoch: 32 | train loss: 0.0009 | val loss: 0.0008 | total time: 4 hours 11 minutes\n",
      "Epoch: 33 | train loss: 0.0011 | val loss: 0.0007 | total time: 4 hours 19 minutes\n",
      "Epoch: 34 | train loss: 0.0009 | val loss: 0.0008 | total time: 4 hours 26 minutes\n",
      "Epoch: 35 | train loss: 0.0010 | val loss: 0.0008 | total time: 4 hours 34 minutes\n",
      "Epoch: 36 | train loss: 0.0010 | val loss: 0.0010 | total time: 4 hours 42 minutes\n",
      "Epoch: 37 | train loss: 0.0011 | val loss: 0.0006 | total time: 4 hours 50 minutes\n",
      "Epoch: 38 | train loss: 0.0009 | val loss: 0.0012 | total time: 4 hours 58 minutes\n",
      "Epoch: 39 | train loss: 0.0009 | val loss: 0.0007 | total time: 5 hours 6 minutes\n",
      "Epoch: 40 | train loss: 0.0009 | val loss: 0.0010 | total time: 5 hours 14 minutes\n",
      "Epoch: 41 | train loss: 0.0009 | val loss: 0.0005 | total time: 5 hours 21 minutes\n",
      "Epoch: 42 | train loss: 0.0009 | val loss: 0.0010 | total time: 5 hours 29 minutes\n",
      "Epoch: 43 | train loss: 0.0009 | val loss: 0.0006 | total time: 5 hours 37 minutes\n",
      "Epoch: 44 | train loss: 0.0009 | val loss: 0.0007 | total time: 5 hours 45 minutes\n",
      "Epoch: 45 | train loss: 0.0008 | val loss: 0.0006 | total time: 5 hours 53 minutes\n",
      "Epoch: 46 | train loss: 0.0009 | val loss: 0.0004 | total time: 6 hours 1 minutes\n",
      "Epoch: 47 | train loss: 0.0008 | val loss: 0.0008 | total time: 6 hours 9 minutes\n",
      "Epoch: 48 | train loss: 0.0009 | val loss: 0.0006 | total time: 6 hours 17 minutes\n",
      "Epoch: 49 | train loss: 0.0007 | val loss: 0.0007 | total time: 6 hours 24 minutes\n",
      "Epoch: 50 | train loss: 0.0008 | val loss: 0.0006 | total time: 6 hours 32 minutes\n",
      "Finished training\n"
     ]
    },
    {
     "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": [
    "# train\n",
    "print('Training (on ' + str(device) + ')...')\n",
    "tic = time.time()\n",
    "min_val_loss = float('inf')\n",
    "train_losses, val_losses = [], []\n",
    "epoch_num = 50\n",
    "\n",
    "for epoch in range(1, epoch_num + 1):\n",
    "    train_loss = 0.0\n",
    "\n",
    "    for i, data in enumerate(trainloader, 0):\n",
    "        source_proj, target_proj, source_vol, source_abdomen, target_flow = data['source_projections'].to(device), \\\n",
    "                                                                            data['target_projections'].to(device), \\\n",
    "                                                                            data['source_volumes'].to(device), \\\n",
    "                                                                            data['source_abdomen'].to(device), \\\n",
    "                                                                            data['target_flow'].to(device)\n",
    "\n",
    "        # zero the parameter gradients\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "        # forward + backward + optimize\n",
    "        _, predict_flow = model.forward(source_proj, target_proj, source_vol)\n",
    "        loss = flow_mask.loss(target_flow, predict_flow, source_abdomen)\n",
    "        train_loss += loss.item()\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "    # test and print every epoch\n",
    "    val_loss = 0.0\n",
    "    model.eval()\n",
    "    with torch.no_grad():\n",
    "        for j, valdata in enumerate(valloader, 0):\n",
    "            source_proj, target_proj, source_vol, source_abdomen, target_flow = data['source_projections'].to(device), \\\n",
    "                                                                                data['target_projections'].to(device), \\\n",
    "                                                                                data['source_volumes'].to(device), \\\n",
    "                                                                                data['source_abdomen'].to(device), \\\n",
    "                                                                                data['target_flow'].to(device)\n",
    "\n",
    "            _, predict_flow = model.forward(source_proj, target_proj, source_vol)\n",
    "            loss = flow_mask.loss(target_flow, predict_flow, source_abdomen)\n",
    "            val_loss += loss.item()\n",
    "\n",
    "    toc = time.time()\n",
    "    time_elapsed = (toc - tic) / 3600\n",
    "    hours = np.floor(time_elapsed)\n",
    "    minutes = (time_elapsed - hours) * 60\n",
    "\n",
    "    print('Epoch: %d | train loss: %.4f | val loss: %.4f | total time: %d hours %d minutes' %\n",
    "          (epoch, train_loss / len(trainset), val_loss / len(valset), hours, minutes))\n",
    "    train_losses.append(train_loss / len(trainset))\n",
    "    val_losses.append(val_loss / len(valset))\n",
    "\n",
    "    # save model with lowest validation cost\n",
    "    if val_loss < min_val_loss:\n",
    "        if not os.path.exists('weights'):\n",
    "            os.mkdir('weights')\n",
    "        PATH = 'weights/' + filename + '.pth'\n",
    "        torch.save(model.state_dict(), PATH)\n",
    "        min_val_loss = val_loss\n",
    "\n",
    "    # plot training\n",
    "    plt.figure()\n",
    "    plt.title(expt_description)\n",
    "    plt.plot(np.array(range(1, epoch + 1)), np.array(train_losses), 'b')\n",
    "    plt.plot(np.array(range(1, epoch + 1)), np.array(val_losses), 'r')\n",
    "    plt.legend(['Train', 'Validation'])\n",
    "    plt.ylabel('Loss')\n",
    "    plt.ticklabel_format(axis=\"y\", style=\"sci\", scilimits=(0, 0))\n",
    "    if minutes > 30:\n",
    "        hours += 1\n",
    "    plt.xlabel('Epochs' + ' (' + str(int(hours)) + ' hours)')\n",
    "    if not os.path.exists('plots'):\n",
    "        os.mkdir('plots')\n",
    "    plt.savefig('plots/' + filename + '.png')\n",
    "    plt.close()\n",
    "\n",
    "print('Finished training')\n",
    "torch.cuda.empty_cache()\n",
    "\n",
    "plt.imshow(plt.imread('plots/' + filename + '.png'))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0262455e",
   "metadata": {},
   "source": [
    "That was an exciting moment...we now have a trained neural network. Last thing to do is test it! First, let's point to the weights we want and the directory for our unseen test data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "62b87481",
   "metadata": {},
   "outputs": [],
   "source": [
    "# file names\n",
    "expt_file = 'train_a'\n",
    "test_file = 'data/xcat/test'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6fe14606",
   "metadata": {},
   "source": [
    "Just as we did for training, we will create a new class that allows us to load our test data. This class looks a lot more involved because we have lots and lots of things to test: target overlap, OAR overlap, image similarity..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "55597498",
   "metadata": {},
   "outputs": [],
   "source": [
    "# set up validation dataset class\n",
    "class validateXCATDataset(Dataset):\n",
    "\n",
    "    def __init__(self, im_dir=None, ref_dir=None, im_size=None):\n",
    "        self.im_dir = im_dir\n",
    "        self.ref_dir = ref_dir\n",
    "        self.im_size = im_size\n",
    "\n",
    "    def __len__(self):\n",
    "        return len([n for n in os.listdir(self.im_dir) if n.endswith('_bin.npy')])\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        # Find target angle\n",
    "        angle = os.path.join(self.im_dir, format('Angles.csv'))\n",
    "        angle = np.genfromtxt(angle)\n",
    "        angle = angle[idx]\n",
    "\n",
    "        # Find target projection\n",
    "        proj_list = sorted([n for n in os.listdir(self.im_dir) if n.endswith('_bin.npy')])\n",
    "        target_file = proj_list[idx]\n",
    "        proj_name = os.path.join(self.im_dir, format(target_file))\n",
    "        target_proj = np.load(proj_name)\n",
    "\n",
    "        # Find source projection\n",
    "        proj_name = os.path.join(self.ref_dir, format('06_' + target_file))\n",
    "        source_proj = np.load(proj_name)\n",
    "\n",
    "        # Find source volume\n",
    "        vol_name = os.path.join(self.ref_dir, format('sub_CT_06_mha.npy'))\n",
    "        source_vol = np.load(vol_name)\n",
    "\n",
    "        # Find source contours\n",
    "        vol_name = os.path.join(self.ref_dir, format('Source_mha.npy'))\n",
    "        source_ptv = np.load(vol_name)\n",
    "\n",
    "        vol_name = os.path.join(self.ref_dir, format('Eso_source_mha.npy'))\n",
    "        source_eso = np.load(vol_name)\n",
    "\n",
    "        vol_name = os.path.join(self.ref_dir, format('Sto_source_mha.npy'))\n",
    "        source_sto = np.load(vol_name)\n",
    "\n",
    "        vol_name = os.path.join(self.ref_dir, format('LungL_source_mha.npy'))\n",
    "        source_lungL = np.load(vol_name)\n",
    "\n",
    "        vol_name = os.path.join(self.ref_dir, format('LungR_source_mha.npy'))\n",
    "        source_lungR = np.load(vol_name)\n",
    "\n",
    "        vol_name = os.path.join(self.ref_dir, format('SpCord_source_mha.npy'))\n",
    "        source_spcord = np.load(vol_name)\n",
    "\n",
    "        # Find target volume\n",
    "        vol_list = sorted([n for n in os.listdir(self.im_dir) if n.startswith('Vol') & n.endswith('_mha.npy')])\n",
    "        target_file = vol_list[idx]\n",
    "        vol_name = os.path.join(self.im_dir, format(target_file))\n",
    "        target_vol = np.load(vol_name)\n",
    "\n",
    "        # Find target contours\n",
    "        target_num = target_file.split('_')\n",
    "        target_num = target_num[1]\n",
    "\n",
    "        vol_name = os.path.join(self.im_dir, format('Target_' + target_num + '_mha.npy'))\n",
    "        target_ptv = np.load(vol_name)\n",
    "\n",
    "        vol_name = os.path.join(self.im_dir, format('Eso_' + target_num + '_mha.npy'))\n",
    "        target_eso = np.load(vol_name)\n",
    "\n",
    "        vol_name = os.path.join(self.im_dir, format('Sto_' + target_num + '_mha.npy'))\n",
    "        target_sto = np.load(vol_name)\n",
    "\n",
    "        vol_name = os.path.join(self.im_dir, format('LungL_' + target_num + '_mha.npy'))\n",
    "        target_lungL = np.load(vol_name)\n",
    "\n",
    "        vol_name = os.path.join(self.im_dir, format('LungR_' + target_num + '_mha.npy'))\n",
    "        target_lungR = np.load(vol_name)\n",
    "\n",
    "        vol_name = os.path.join(self.im_dir, format('SpCord_' + target_num + '_mha.npy'))\n",
    "        target_spcord = np.load(vol_name)\n",
    "\n",
    "        # Reshape data to correct format\n",
    "        source_projections = np.zeros((1, self.im_size, self.im_size), dtype=np.float32)\n",
    "        source_projections[0, :, :] = np.asarray(source_proj)\n",
    "\n",
    "        target_projections = np.zeros((1, self.im_size, self.im_size), dtype=np.float32)\n",
    "        target_projections[0, :, :] = np.asarray(target_proj)\n",
    "\n",
    "        source_volumes = np.zeros((1, self.im_size, self.im_size, self.im_size), dtype=np.float32)\n",
    "        source_volumes[0, :, :, :] = np.asarray(source_vol)\n",
    "\n",
    "        source_ptvs = np.zeros((1, self.im_size, self.im_size, self.im_size), dtype=np.float32)\n",
    "        source_ptvs[0, :, :, :] = np.asarray(source_ptv)\n",
    "\n",
    "        source_esophagus = np.zeros((1, self.im_size, self.im_size, self.im_size), dtype=np.float32)\n",
    "        source_esophagus[0, :, :, :] = np.asarray(source_eso)\n",
    "\n",
    "        source_stomach = np.zeros((1, self.im_size, self.im_size, self.im_size), dtype=np.float32)\n",
    "        source_stomach[0, :, :, :] = np.asarray(source_sto)\n",
    "\n",
    "        source_lungsR = np.zeros((1, self.im_size, self.im_size, self.im_size), dtype=np.float32)\n",
    "        source_lungsR[0, :, :, :] = np.asarray(source_lungR)\n",
    "\n",
    "        source_lungsL = np.zeros((1, self.im_size, self.im_size, self.im_size), dtype=np.float32)\n",
    "        source_lungsL[0, :, :, :] = np.asarray(source_lungL)\n",
    "\n",
    "        source_spinalcord = np.zeros((1, self.im_size, self.im_size, self.im_size), dtype=np.float32)\n",
    "        source_spinalcord[0, :, :, :] = np.asarray(source_spcord)\n",
    "\n",
    "        target_volumes = np.zeros((1, self.im_size, self.im_size, self.im_size), dtype=np.float32)\n",
    "        target_volumes[0, :, :, :] = np.asarray(target_vol)\n",
    "\n",
    "        target_ptvs = np.zeros((1, self.im_size, self.im_size, self.im_size), dtype=np.float32)\n",
    "        target_ptvs[0, :, :, :] = np.asarray(target_ptv)\n",
    "\n",
    "        target_esophagus = np.zeros((1, self.im_size, self.im_size, self.im_size), dtype=np.float32)\n",
    "        target_esophagus[0, :, :, :] = np.asarray(target_eso)\n",
    "\n",
    "        target_stomach = np.zeros((1, self.im_size, self.im_size, self.im_size), dtype=np.float32)\n",
    "        target_stomach[0, :, :, :] = np.asarray(target_sto)\n",
    "\n",
    "        target_lungsL = np.zeros((1, self.im_size, self.im_size, self.im_size), dtype=np.float32)\n",
    "        target_lungsL[0, :, :, :] = np.asarray(target_lungL)\n",
    "\n",
    "        target_lungsR = np.zeros((1, self.im_size, self.im_size, self.im_size), dtype=np.float32)\n",
    "        target_lungsR[0, :, :, :] = np.asarray(target_lungR)\n",
    "\n",
    "        target_spinalcord = np.zeros((1, self.im_size, self.im_size, self.im_size), dtype=np.float32)\n",
    "        target_spinalcord[0, :, :, :] = np.asarray(target_spcord)\n",
    "\n",
    "        data = {'source_projections': torch.from_numpy(source_projections),\n",
    "                'target_projections': torch.from_numpy(target_projections),\n",
    "                'source_volumes': torch.from_numpy(source_volumes),\n",
    "                'source_ptvs': torch.from_numpy(source_ptvs),\n",
    "                'source_esophagus': torch.from_numpy(source_esophagus),\n",
    "                'source_stomach': torch.from_numpy(source_stomach),\n",
    "                'source_lungsL': torch.from_numpy(source_lungsL),\n",
    "                'source_lungsR': torch.from_numpy(source_lungsR),\n",
    "                'source_spinalcord': torch.from_numpy(source_spinalcord),\n",
    "                'target_volumes': torch.from_numpy(target_volumes),\n",
    "                'target_ptvs': torch.from_numpy(target_ptvs),\n",
    "                'target_esophagus': torch.from_numpy(target_esophagus),\n",
    "                'target_stomach': torch.from_numpy(target_stomach),\n",
    "                'target_lungsL': torch.from_numpy(target_lungsL),\n",
    "                'target_lungsR': torch.from_numpy(target_lungsR),\n",
    "                'target_spinalcord': torch.from_numpy(target_spinalcord),\n",
    "                'angle': angle\n",
    "                }\n",
    "        \n",
    "        return data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8bd64e69",
   "metadata": {},
   "source": [
    "Let's instantiate the validation dataset class, set up a cuda implementation, and load the pre-trained weights of our network. We'll also print the number of trainable parameters for our records."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "2de49152",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of paramters: 10836973\n"
     ]
    }
   ],
   "source": [
    "# Generate test loader\n",
    "batch_size = 1\n",
    "im_size = 128\n",
    "dataset = validateXCATDataset(im_dir=test_file, ref_dir=test_file + '/source', im_size=im_size)\n",
    "testloader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, shuffle=False)\n",
    "\n",
    "# Import network and set up cuda implementation\n",
    "model = network_a.VxmDense(im_size, int_steps=10)\n",
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "model.to(device)\n",
    "\n",
    "# Load weights\n",
    "PATH = 'weights/' + expt_file + '.pth'\n",
    "model.load_state_dict(torch.load(PATH, map_location=device))\n",
    "model.eval()\n",
    "\n",
    "print('Number of paramters: %d' % (sum(p.numel() for p in model.parameters() if p.requires_grad)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee4765fa",
   "metadata": {},
   "source": [
    "Next we'll load a spatial transformation module. This will allow us to take in a predicted DVF and use it to warp reference images and volumes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "6ee377b3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Network(\n",
       "  (transformer): SpatialTransformer()\n",
       ")"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Load transformer\n",
    "from utilities import spatialTransform\n",
    "transformer = spatialTransform.Network([im_size, im_size, im_size])\n",
    "transformer.to(device)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c263005",
   "metadata": {},
   "source": [
    "Let's load up some loss functions. Here we'll look at the difference in centroid positions, Dice similarity to the target and OAR contours, the Jacobian determinant of predicted DVFs as well as the structural similarity and peak signal-to-noise ratio of the predicted images (courtesy of the skimage.metrics library). We'll also create some empty lists to save these metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "fdd46306",
   "metadata": {},
   "outputs": [],
   "source": [
    "# loss functions\n",
    "centroid_ptv = losses.centroid_ptv()\n",
    "dice = losses.dice()\n",
    "jacobian_determinant = losses.jacobian_determinant()\n",
    "from skimage.metrics import structural_similarity as ssim\n",
    "from skimage.metrics import peak_signal_noise_ratio as psnr\n",
    "\n",
    "# initialise target tracking metrics\n",
    "tar_lr, tar_si, tar_ap, pred_lr, pred_si, pred_ap, test_dice, test_detJ, test_angles = [], [], [], [], [], [], [], [], []\n",
    "\n",
    "# initialise OAR tracking metrics\n",
    "stomach_dice, esophagus_dice, lungL_dice, lungR_dice, spinalcord_dice, = [], [], [], [], []\n",
    "\n",
    "# initialise image metrics\n",
    "test_mse, test_ssim, test_psnr = [], [], []"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e1fcb46",
   "metadata": {},
   "source": [
    "Ok, let's iterate over our unseen test data, recording all the metrics we want. (It may take a couple of minutes to run through all our examples)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "8e8b107a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing...\n",
      "0 of 630\n",
      "10 of 630\n",
      "20 of 630\n",
      "30 of 630\n",
      "40 of 630\n",
      "50 of 630\n",
      "60 of 630\n",
      "70 of 630\n",
      "80 of 630\n",
      "90 of 630\n",
      "100 of 630\n",
      "110 of 630\n",
      "120 of 630\n",
      "130 of 630\n",
      "140 of 630\n",
      "150 of 630\n",
      "160 of 630\n",
      "170 of 630\n",
      "180 of 630\n",
      "190 of 630\n",
      "200 of 630\n",
      "210 of 630\n",
      "220 of 630\n",
      "230 of 630\n",
      "240 of 630\n",
      "250 of 630\n",
      "260 of 630\n",
      "270 of 630\n",
      "280 of 630\n",
      "290 of 630\n",
      "300 of 630\n",
      "310 of 630\n",
      "320 of 630\n",
      "330 of 630\n",
      "340 of 630\n",
      "350 of 630\n",
      "360 of 630\n",
      "370 of 630\n",
      "380 of 630\n",
      "390 of 630\n",
      "400 of 630\n",
      "410 of 630\n",
      "420 of 630\n",
      "430 of 630\n",
      "440 of 630\n",
      "450 of 630\n",
      "460 of 630\n",
      "470 of 630\n",
      "480 of 630\n",
      "490 of 630\n",
      "500 of 630\n",
      "510 of 630\n",
      "520 of 630\n",
      "530 of 630\n",
      "540 of 630\n",
      "550 of 630\n",
      "560 of 630\n",
      "570 of 630\n",
      "580 of 630\n",
      "590 of 630\n",
      "600 of 630\n",
      "610 of 630\n",
      "620 of 630\n"
     ]
    }
   ],
   "source": [
    "print('Testing...')\n",
    "for i, data in enumerate(testloader, 0):\n",
    "    (source_proj, target_proj, source_vol, source_ptv, source_eso, source_sto, source_lungL, source_lungR,\n",
    "        source_spcord,target_vol, target_ptv, target_eso, target_sto, target_lungL, target_lungR, target_spcord, angle) = data[\n",
    "        'source_projections'].to(device), \\\n",
    "        data['target_projections'].to(device), \\\n",
    "        data['source_volumes'].to(device), \\\n",
    "        data['source_ptvs'].to(device), \\\n",
    "        data['source_esophagus'].to(device), \\\n",
    "        data['source_stomach'].to(device), \\\n",
    "        data['source_lungsL'].to(device), \\\n",
    "        data['source_lungsR'].to(device), \\\n",
    "        data['source_spinalcord'].to(device), \\\n",
    "        data['target_volumes'].to(device), \\\n",
    "        data['target_ptvs'].to(device), \\\n",
    "        data['target_esophagus'].to(device), \\\n",
    "        data['target_stomach'].to(device), \\\n",
    "        data['target_lungsL'].to(device), \\\n",
    "        data['target_lungsR'].to(device), \\\n",
    "        data['target_spinalcord'].to(device), \\\n",
    "        data['angle'].to(device)\n",
    "\n",
    "    predict_ptv, predict_flow = model.forward(source_proj, target_proj, source_ptv)\n",
    "\n",
    "    lr, si, ap = centroid_ptv.loss(target_ptv)\n",
    "\n",
    "    # convert to mm (to account for subsampling)\n",
    "    lr = 4 * lr\n",
    "    si = 2 * si\n",
    "    ap = 4 * ap\n",
    "\n",
    "    tar_lr.append(lr)\n",
    "    tar_si.append(si)\n",
    "    tar_ap.append(ap)\n",
    "\n",
    "    lr, si, ap = centroid_ptv.loss(predict_ptv)\n",
    "\n",
    "    # convert to mm (to account for subsampling)\n",
    "    lr = 4 * lr\n",
    "    si = 2 * si\n",
    "    ap = 4 * ap\n",
    "\n",
    "    pred_lr.append(lr)\n",
    "    pred_si.append(si)\n",
    "    pred_ap.append(ap)\n",
    "\n",
    "    # compute and save dice similarity\n",
    "    dice_sim = dice.loss(target_ptv, predict_ptv)\n",
    "    test_dice.append(dice_sim.item())\n",
    "\n",
    "    # compute and save Jacobian violation ratio\n",
    "    disp = np.zeros((im_size, im_size, im_size, 3), dtype=np.float32)\n",
    "    metric_flows = np.squeeze(predict_flow.detach().cpu().numpy())\n",
    "    disp[:, :, :, 0] = metric_flows[0, :, :, :]\n",
    "    disp[:, :, :, 1] = metric_flows[1, :, :, :]\n",
    "    disp[:, :, :, 2] = metric_flows[2, :, :, :]\n",
    "    detJ = jacobian_determinant.loss(disp)\n",
    "    detJ = sum(i <= 0 for i in detJ.flatten()) / detJ.size\n",
    "    test_detJ.append(detJ.item())\n",
    "\n",
    "    # save gantry angle\n",
    "    test_angles.append(angle.item())\n",
    "\n",
    "    # warp images\n",
    "    predict_vol = transformer.forward(source_vol, predict_flow)\n",
    "\n",
    "    # detach images from GPU\n",
    "    metric_input = target_vol.cpu().detach().numpy()\n",
    "    metric_input = metric_input.flatten()\n",
    "    metric_pred = predict_vol.cpu().detach().numpy()\n",
    "    metric_pred = metric_pred.flatten()\n",
    "\n",
    "    mse_loss = np.sqrt(np.mean(np.square((metric_input.ravel() - metric_pred.ravel()))))\n",
    "    ssim_loss = ssim(metric_input, metric_pred, data_range=np.max(metric_pred) - np.min(metric_pred))\n",
    "    psnr_loss = psnr(metric_input, metric_pred)\n",
    "\n",
    "    test_mse.append(mse_loss)\n",
    "    test_ssim.append(ssim_loss)\n",
    "    test_psnr.append(psnr_loss)\n",
    "\n",
    "    # stomach\n",
    "    predict_sto = transformer.forward(source_sto, predict_flow)\n",
    "    dice_sim = dice.loss(target_sto, predict_sto)\n",
    "    stomach_dice.append(dice_sim.item())\n",
    "\n",
    "    # esophagus\n",
    "    predict_eso = transformer.forward(source_eso, predict_flow)\n",
    "    dice_sim = dice.loss(target_eso, predict_eso)\n",
    "    esophagus_dice.append(dice_sim.item())\n",
    "\n",
    "    # lungL\n",
    "    predict_lungL = transformer.forward(source_lungL, predict_flow)\n",
    "    dice_sim = dice.loss(target_lungL, predict_lungL)\n",
    "    lungL_dice.append(dice_sim.item())\n",
    "\n",
    "    # lungR\n",
    "    predict_lungR = transformer.forward(source_lungR, predict_flow)\n",
    "    dice_sim = dice.loss(target_lungR, predict_lungR)\n",
    "    lungR_dice.append(dice_sim.item())\n",
    "\n",
    "    # spinal cord\n",
    "    predict_spcord = transformer.forward(source_spcord, predict_flow)\n",
    "    dice_sim = dice.loss(target_spcord, predict_spcord)\n",
    "    spinalcord_dice.append(dice_sim.item())\n",
    "\n",
    "    if i % 10 == 0:\n",
    "        print(str(i) + ' of ' + str(len(testloader)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "247f1788",
   "metadata": {},
   "source": [
    "Let's save the results in a directory called 'plots'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "39fe8b31",
   "metadata": {},
   "outputs": [],
   "source": [
    "if not os.path.exists('plots/' + expt_file):\n",
    "    os.mkdir('plots/' + expt_file)\n",
    "\n",
    "# save target metrics\n",
    "np.save('plots/' + expt_file + '/' + 'test_angles', test_angles)\n",
    "np.save('plots/' + expt_file + '/' + 'tar_lr (mm)', tar_lr)\n",
    "np.save('plots/' + expt_file + '/' + 'tar_si (mm)', tar_si)\n",
    "np.save('plots/' + expt_file + '/' + 'tar_ap (mm)', tar_ap)\n",
    "np.save('plots/' + expt_file + '/' + 'pred_lr (mm)', pred_lr)\n",
    "np.save('plots/' + expt_file + '/' + 'pred_si (mm)', pred_si)\n",
    "np.save('plots/' + expt_file + '/' + 'pred_ap (mm)', pred_ap)\n",
    "np.save('plots/' + expt_file + '/' + 'test_dice', test_dice)\n",
    "np.save('plots/' + expt_file + '/' + 'test_detJ', test_detJ)\n",
    "\n",
    "# save OAR metrics\n",
    "np.save('plots/' + expt_file + '/' + 'stomach_dice', stomach_dice)\n",
    "np.save('plots/' + expt_file + '/' + 'esophagus_dice', esophagus_dice)\n",
    "np.save('plots/' + expt_file + '/' + 'lungL_dice', lungL_dice)\n",
    "np.save('plots/' + expt_file + '/' + 'lungR_dice', lungR_dice)\n",
    "np.save('plots/' + expt_file + '/' + 'spinalcord_dice', spinalcord_dice)\n",
    "\n",
    "# save image metrics\n",
    "np.save('plots/' + expt_file + '/' + 'test_ssim', test_ssim)\n",
    "np.save('plots/' + expt_file + '/' + 'test_psnr', test_psnr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "131b2913",
   "metadata": {},
   "source": [
    "Lastly, we'll print the results and generate a tracking plot for the centroid positions, et voila! I hope you enjoy using Voxelmap. We have started a Discussion section on the Github repository to hear about your experiences."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "adc2ec09",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Target Dice: 0.82 ± 0.07 | 3D : 3.7 ± 1.2 | detJ: 0E+00]\n",
      "[Stomach DSC: 0.81 ± 0.07 | Esophagus DSC: 0.80 ± 0.06 | Lung L DSC: 0.94 ± 0.02 | Lung R DSC: 0.93 ± 0.02 | Spinal cord DSC: 0.94 ± 0.01]\n",
      "[SSIM: 0.94 ± 0.01 | PSNR: 59.4 ± 1.0]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# print results\n",
    "dx = np.asarray(tar_lr) - np.asarray(pred_lr)\n",
    "dy = np.asarray(tar_si) - np.asarray(pred_si)\n",
    "dz = np.asarray(tar_ap) - np.asarray(pred_ap)\n",
    "\n",
    "print('[Target Dice: %.2f ± %.2f' % (np.mean(test_dice), np.std(test_dice)) +\n",
    "    ' | 3D : %.1f ± %.1f' % (np.mean(np.sqrt(dx**2 + dy**2 + dz**2)), np.std(np.sqrt(dx**2 + dy**2 + dz**2))) +\n",
    "    ' | detJ: %.0E' % (np.mean(test_detJ)) + ']')\n",
    "\n",
    "print('[Stomach DSC: %.2f ± %.2f' % (np.mean(stomach_dice), np.std(stomach_dice)) +\n",
    "    ' | Esophagus DSC: %.2f ± %.2f' % (np.mean(esophagus_dice), np.std(esophagus_dice)) +\n",
    "    ' | Lung L DSC: %.2f ± %.2f' % (np.mean(lungL_dice), np.std(lungL_dice)) +\n",
    "    ' | Lung R DSC: %.2f ± %.2f' % (np.mean(lungR_dice), np.std(lungR_dice)) +\n",
    "    ' | Spinal cord DSC: %.2f ± %.2f' % (np.mean(spinalcord_dice), np.std(spinalcord_dice)) + ']')\n",
    "\n",
    "print('[SSIM: %.2f ± %.2f' % (np.mean(test_ssim), np.std(test_ssim)) +\n",
    "    ' | PSNR: %.1f ± %.1f' % (np.mean(test_psnr), np.std(test_psnr)) +']')\n",
    "\n",
    "# plot centroid traces\n",
    "tar_lr = tar_lr - np.mean(tar_lr)\n",
    "tar_lr = [tar_lr for _, tar_lr in sorted(zip(test_angles, tar_lr))]\n",
    "tar_si = tar_si - np.mean(tar_si)\n",
    "tar_si = [tar_si for _, tar_si in sorted(zip(test_angles, tar_si))]\n",
    "tar_ap = tar_ap - np.mean(tar_ap)\n",
    "tar_ap = [tar_ap for _, tar_ap in sorted(zip(test_angles, tar_ap))]\n",
    "\n",
    "pred_lr = pred_lr - np.mean(pred_lr)\n",
    "pred_lr = [pred_lr for _, pred_lr in sorted(zip(test_angles, pred_lr))]\n",
    "pred_si = pred_si - np.mean(pred_si)\n",
    "pred_si = [pred_si for _, pred_si in sorted(zip(test_angles, pred_si))]\n",
    "pred_ap = pred_ap - np.mean(pred_ap)\n",
    "pred_ap = [pred_ap for _, pred_ap in sorted(zip(test_angles, pred_ap))]\n",
    "\n",
    "test_angles = sorted(test_angles)\n",
    "\n",
    "f = plt.figure()\n",
    "f.add_subplot(3, 1, 1)\n",
    "plt.plot(test_angles, tar_lr)\n",
    "plt.plot(test_angles, pred_lr)\n",
    "plt.xlabel('Angle (degrees)')\n",
    "plt.ylabel('LR position\\n(mm)')\n",
    "plt.title('XCAT - Patient 1')\n",
    "plt.legend(['Ground-truth', 'Prediction'], loc='upper right')\n",
    "plt.ylim([-6, 8])\n",
    "plt.xlim([0, 360])\n",
    "plt.xticks([0, 30, 60, 90, 120, 150, 180, 210, 240, 270, 300, 330, 360])\n",
    "\n",
    "f.add_subplot(3, 1, 2)\n",
    "plt.plot(test_angles, tar_si)\n",
    "plt.plot(test_angles, pred_si)\n",
    "plt.xlabel('Angle (degrees)')\n",
    "plt.ylabel('SI position\\n(mm)')\n",
    "plt.legend(['Ground-truth', 'Prediction'], loc='upper right')\n",
    "plt.ylim([-6, 8])\n",
    "plt.xlim([0, 360])\n",
    "plt.xticks([0, 30, 60, 90, 120, 150, 180, 210, 240, 270, 300, 330, 360])\n",
    "\n",
    "f.add_subplot(3, 1, 3)\n",
    "plt.plot(test_angles, tar_ap)\n",
    "plt.plot(test_angles, pred_ap)\n",
    "plt.xlabel('Angle (degrees)')\n",
    "plt.ylabel('AP position\\n(mm)')\n",
    "plt.legend(['Ground-truth', 'Prediction'], loc='upper right')\n",
    "plt.ylim([-6, 8])\n",
    "plt.xlim([0, 360])\n",
    "plt.xticks([0, 30, 60, 90, 120, 150, 180, 210, 240, 270, 300, 330, 360])\n",
    "\n",
    "plt.savefig('plots/' + expt_file + '_trace.png')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f9f292c9",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}