RSNA 2023 Abdominal Trauma Detection - Inference.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "1b225dfd",
   "metadata": {
    "papermill": {
     "duration": 0.005878,
     "end_time": "2023-10-13T11:10:49.575199",
     "exception": false,
     "start_time": "2023-10-13T11:10:49.569321",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## RSNA 2023 Abdominal Trauma Detection"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c8f8a1a",
   "metadata": {
    "papermill": {
     "duration": 0.00529,
     "end_time": "2023-10-13T11:10:49.586786",
     "exception": false,
     "start_time": "2023-10-13T11:10:49.581496",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## 1. Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "98b471a0",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-13T11:10:49.600194Z",
     "iopub.status.busy": "2023-10-13T11:10:49.599691Z",
     "iopub.status.idle": "2023-10-13T11:10:59.614170Z",
     "shell.execute_reply": "2023-10-13T11:10:59.613005Z"
    },
    "papermill": {
     "duration": 10.024637,
     "end_time": "2023-10-13T11:10:59.617148",
     "exception": false,
     "start_time": "2023-10-13T11:10:49.592511",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Looking in links: /kaggle/input/rsna-2023-abdominal-trauma-detection-dataset/packages\r\n",
      "Processing /kaggle/input/rsna-2023-abdominal-trauma-detection-dataset/packages/monai-1.2.0-202306081546-py3-none-any.whl\r\n",
      "Requirement already satisfied: torch>=1.9 in /opt/conda/lib/python3.10/site-packages (from monai==1.2.0) (2.0.0)\r\n",
      "Requirement already satisfied: numpy>=1.20 in /opt/conda/lib/python3.10/site-packages (from monai==1.2.0) (1.23.5)\r\n",
      "Requirement already satisfied: filelock in /opt/conda/lib/python3.10/site-packages (from torch>=1.9->monai==1.2.0) (3.12.2)\r\n",
      "Requirement already satisfied: typing-extensions in /opt/conda/lib/python3.10/site-packages (from torch>=1.9->monai==1.2.0) (4.6.3)\r\n",
      "Requirement already satisfied: sympy in /opt/conda/lib/python3.10/site-packages (from torch>=1.9->monai==1.2.0) (1.12)\r\n",
      "Requirement already satisfied: networkx in /opt/conda/lib/python3.10/site-packages (from torch>=1.9->monai==1.2.0) (3.1)\r\n",
      "Requirement already satisfied: jinja2 in /opt/conda/lib/python3.10/site-packages (from torch>=1.9->monai==1.2.0) (3.1.2)\r\n",
      "Requirement already satisfied: MarkupSafe>=2.0 in /opt/conda/lib/python3.10/site-packages (from jinja2->torch>=1.9->monai==1.2.0) (2.1.3)\r\n",
      "Requirement already satisfied: mpmath>=0.19 in /opt/conda/lib/python3.10/site-packages (from sympy->torch>=1.9->monai==1.2.0) (1.3.0)\r\n",
      "Installing collected packages: monai\r\n",
      "Successfully installed monai-1.2.0\r\n"
     ]
    }
   ],
   "source": [
    "!pip install /kaggle/input/rsna-2023-abdominal-trauma-detection-dataset/packages/monai-1.2.0-202306081546-py3-none-any.whl --no-index --find-links /kaggle/input/rsna-2023-abdominal-trauma-detection-dataset/packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "e002a5d2",
   "metadata": {
    "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19",
    "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5",
    "execution": {
     "iopub.execute_input": "2023-10-13T11:10:59.640990Z",
     "iopub.status.busy": "2023-10-13T11:10:59.640502Z",
     "iopub.status.idle": "2023-10-13T11:11:16.687337Z",
     "shell.execute_reply": "2023-10-13T11:11:16.686387Z"
    },
    "papermill": {
     "duration": 17.060829,
     "end_time": "2023-10-13T11:11:16.689434",
     "exception": false,
     "start_time": "2023-10-13T11:10:59.628605",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/conda/lib/python3.10/site-packages/scipy/__init__.py:146: UserWarning: A NumPy version >=1.16.5 and <1.23.0 is required for this version of SciPy (detected version 1.23.5\n",
      "  warnings.warn(f\"A NumPy version >={np_minversion} and <{np_maxversion}\"\n",
      "/opt/conda/lib/python3.10/site-packages/tensorflow_io/python/ops/__init__.py:98: UserWarning: unable to load libtensorflow_io_plugins.so: unable to open file: libtensorflow_io_plugins.so, from paths: ['/opt/conda/lib/python3.10/site-packages/tensorflow_io/python/ops/libtensorflow_io_plugins.so']\n",
      "caused by: ['/opt/conda/lib/python3.10/site-packages/tensorflow_io/python/ops/libtensorflow_io_plugins.so: undefined symbol: _ZN3tsl6StatusC1EN10tensorflow5error4CodeESt17basic_string_viewIcSt11char_traitsIcEENS_14SourceLocationE']\n",
      "  warnings.warn(f\"unable to load libtensorflow_io_plugins.so: {e}\")\n",
      "/opt/conda/lib/python3.10/site-packages/tensorflow_io/python/ops/__init__.py:104: UserWarning: file system plugins are not loaded: unable to open file: libtensorflow_io.so, from paths: ['/opt/conda/lib/python3.10/site-packages/tensorflow_io/python/ops/libtensorflow_io.so']\n",
      "caused by: ['/opt/conda/lib/python3.10/site-packages/tensorflow_io/python/ops/libtensorflow_io.so: undefined symbol: _ZTVN10tensorflow13GcsFileSystemE']\n",
      "  warnings.warn(f\"file system plugins are not loaded: {e}\")\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import yaml\n",
    "from pathlib import Path\n",
    "from tqdm import tqdm\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import cv2\n",
    "import pydicom\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import timm\n",
    "import monai.transforms as T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "4648f253",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-13T11:11:16.702904Z",
     "iopub.status.busy": "2023-10-13T11:11:16.702097Z",
     "iopub.status.idle": "2023-10-13T11:11:16.706601Z",
     "shell.execute_reply": "2023-10-13T11:11:16.705782Z"
    },
    "papermill": {
     "duration": 0.012739,
     "end_time": "2023-10-13T11:11:16.708243",
     "exception": false,
     "start_time": "2023-10-13T11:11:16.695504",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "competition_dataset = Path('/kaggle/input/rsna-2023-abdominal-trauma-detection')\n",
    "external_dataset = Path('/kaggle/input/rsna-2023-abdominal-trauma-detection-dataset')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "123fbd21",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-13T11:11:16.720489Z",
     "iopub.status.busy": "2023-10-13T11:11:16.720250Z",
     "iopub.status.idle": "2023-10-13T11:11:16.734389Z",
     "shell.execute_reply": "2023-10-13T11:11:16.733542Z"
    },
    "papermill": {
     "duration": 0.022193,
     "end_time": "2023-10-13T11:11:16.736029",
     "exception": false,
     "start_time": "2023-10-13T11:11:16.713836",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataset Shape: (3, 14)\n"
     ]
    }
   ],
   "source": [
    "df = pd.read_csv(competition_dataset / 'sample_submission.csv')\n",
    "print(f'Dataset Shape: {df.shape}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "23e5d636",
   "metadata": {
    "papermill": {
     "duration": 0.005572,
     "end_time": "2023-10-13T11:11:16.747251",
     "exception": false,
     "start_time": "2023-10-13T11:11:16.741679",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## 2. DICOM Utilities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "72ebc6c6",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-13T11:11:16.760937Z",
     "iopub.status.busy": "2023-10-13T11:11:16.760188Z",
     "iopub.status.idle": "2023-10-13T11:11:16.781454Z",
     "shell.execute_reply": "2023-10-13T11:11:16.780655Z"
    },
    "papermill": {
     "duration": 0.029948,
     "end_time": "2023-10-13T11:11:16.783188",
     "exception": false,
     "start_time": "2023-10-13T11:11:16.753240",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def shift_bits(image, dicom, bits_allocated=None, bits_stored=None):\n",
    "\n",
    "    \"\"\"\n",
    "    Shift bits using allocated and stored bits\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    image: numpy.ndarray of shape (height, width)\n",
    "        Image array\n",
    "\n",
    "    dicom: pydicom.dataset.FileDataset\n",
    "        DICOM dataset\n",
    "\n",
    "    bits_allocated: int, str ('dataset') or None\n",
    "        Number of bits allocated\n",
    "\n",
    "    bits_stored: int, str ('dataset') or None\n",
    "        Number of bits stored\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    image: numpy.ndarray of shape (height, width)\n",
    "        Image array with shifted bits\n",
    "    \"\"\"\n",
    "\n",
    "    if bits_allocated == 'dataset':\n",
    "        try:\n",
    "            bits_allocated = dicom.BitsAllocated\n",
    "        except AttributeError:\n",
    "            bits_allocated = None\n",
    "\n",
    "    if bits_stored == 'dataset':\n",
    "        try:\n",
    "            bits_stored = dicom.BitsStored\n",
    "        except AttributeError:\n",
    "            bits_stored = None\n",
    "\n",
    "    if bits_allocated is not None and bits_stored is not None:\n",
    "        bit_shift = bits_allocated - bits_stored\n",
    "    else:\n",
    "        bit_shift = None\n",
    "\n",
    "    if bit_shift is not None:\n",
    "        dtype = image.dtype\n",
    "        image = (image << bit_shift).astype(dtype) >> bit_shift\n",
    "\n",
    "    return image\n",
    "\n",
    "\n",
    "def rescale_pixel_values(image, dicom, rescale_slope=None, rescale_intercept=None):\n",
    "\n",
    "    \"\"\"\n",
    "    Rescale pixel values using rescale slope and intercept as a linear function\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    image: numpy.ndarray of shape (height, width)\n",
    "        Image array\n",
    "\n",
    "    dicom: pydicom.dataset.FileDataset\n",
    "        DICOM dataset\n",
    "\n",
    "    rescale_slope: int, str ('dataset') or None\n",
    "        Rescale slope for rescaling pixel values\n",
    "\n",
    "    rescale_intercept: int, str ('dataset') or None\n",
    "        Rescale intercept for rescaling pixel values\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    image: numpy.ndarray of shape (height, width)\n",
    "        Image array with rescaled pixel values\n",
    "    \"\"\"\n",
    "\n",
    "    if rescale_slope == 'dataset':\n",
    "        try:\n",
    "            rescale_slope = dicom.RescaleSlope\n",
    "        except AttributeError:\n",
    "            rescale_slope = None\n",
    "\n",
    "    if rescale_intercept == 'dataset':\n",
    "        try:\n",
    "            rescale_intercept = dicom.RescaleIntercept\n",
    "        except AttributeError:\n",
    "            rescale_intercept = None\n",
    "\n",
    "    if rescale_slope is not None and rescale_intercept is not None:\n",
    "        image = image.astype(np.float32)\n",
    "        image = image * rescale_slope + rescale_intercept\n",
    "\n",
    "    return image\n",
    "\n",
    "\n",
    "def window_pixel_values(image, dicom, window_center=None, window_width=None):\n",
    "\n",
    "    \"\"\"\n",
    "    Window pixel values using window center and width\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    image: numpy.ndarray of shape (height, width)\n",
    "        Image array\n",
    "\n",
    "    dicom: pydicom.dataset.FileDataset\n",
    "        DICOM dataset\n",
    "\n",
    "    window_center: int, str ('dataset') or None\n",
    "        Window center for windowing pixel values\n",
    "\n",
    "    window_width: int, str ('dataset') or None\n",
    "        Window width for windowing pixel values\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    image: numpy.ndarray of shape (height, width)\n",
    "        Image array with windowed pixel values\n",
    "    \"\"\"\n",
    "\n",
    "    if window_center == 'dataset':\n",
    "        try:\n",
    "            window_center = dicom.WindowCenter\n",
    "        except AttributeError:\n",
    "            window_center = None\n",
    "\n",
    "    if window_width == 'dataset':\n",
    "        try:\n",
    "            window_width = dicom.WindowWidth\n",
    "        except AttributeError:\n",
    "            window_width = None\n",
    "\n",
    "    if window_center is not None and window_width is not None:\n",
    "        image_min = window_center - window_width // 2\n",
    "        image_max = window_center + window_width // 2\n",
    "        image = np.clip(image.copy(), image_min, image_max)\n",
    "\n",
    "    return image\n",
    "\n",
    "\n",
    "def invert_pixel_values(image, dicom, photometric_interpretation=None, max_pixel_value=255):\n",
    "\n",
    "    \"\"\"\n",
    "    Invert pixel values using given max pixel value\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    image: numpy.ndarray of shape (height, width)\n",
    "        Image array\n",
    "\n",
    "    dicom: pydicom.dataset.FileDataset\n",
    "        DICOM dataset\n",
    "\n",
    "    photometric_interpretation: str or None\n",
    "        Interpretation of the pixel data\n",
    "\n",
    "    max_pixel_value: int or None\n",
    "        Max pixel value used for inverting pixel values\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    image: numpy.ndarray of shape (height, width)\n",
    "        Image array with inverted pixel values\n",
    "    \"\"\"\n",
    "\n",
    "    if photometric_interpretation == 'dataset':\n",
    "        try:\n",
    "            photometric_interpretation = dicom.PhotometricInterpretation\n",
    "        except AttributeError:\n",
    "            photometric_interpretation = None\n",
    "\n",
    "    if photometric_interpretation == 'MONOCHROME1':\n",
    "        image = max_pixel_value - image\n",
    "\n",
    "    return image\n",
    "\n",
    "\n",
    "def adjust_pixel_values(\n",
    "        image, dicom,\n",
    "        bits_allocated=None, bits_stored=None,\n",
    "        rescale_slope=None, rescale_intercept=None,\n",
    "        window_centers=None, window_widths=None,\n",
    "        photometric_interpretation=None, max_pixel_value=255\n",
    "):\n",
    "\n",
    "    \"\"\"\n",
    "    Adjust pixel values by shifting bits, windowing, rescaling and inverting\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    image: numpy.ndarray of shape (height, width)\n",
    "        Image array\n",
    "\n",
    "    dicom: pydicom.dataset.FileDataset\n",
    "        DICOM dataset\n",
    "\n",
    "    bits_allocated: int, str ('dataset') or None\n",
    "        Number of bits allocated\n",
    "\n",
    "    bits_stored: int, str ('dataset') or None\n",
    "        Number of bits stored\n",
    "\n",
    "    rescale_slope: int, str ('dataset') or None\n",
    "        Rescale slope for rescaling pixel values\n",
    "\n",
    "    rescale_intercept: int, str ('dataset') or None\n",
    "        Rescale intercept for rescaling pixel values\n",
    "\n",
    "    window_centers: list of int, str ('dataset') or None\n",
    "        List of window center values for windowing pixel values\n",
    "\n",
    "    window_widths: list of int, str ('dataset') or None\n",
    "        List of window width values for windowing pixel values\n",
    "\n",
    "    photometric_interpretation: str or None\n",
    "        Interpretation of the pixel data\n",
    "\n",
    "    max_pixel_value: int or None\n",
    "        Max pixel value used for inverting pixel values\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    image: numpy.ndarray of shape (height, width)\n",
    "        Image array with adjusted pixel values\n",
    "    \"\"\"\n",
    "\n",
    "    image = shift_bits(image=image, dicom=dicom, bits_allocated=bits_allocated, bits_stored=bits_stored)\n",
    "    image = rescale_pixel_values(image=image, dicom=dicom, rescale_slope=rescale_slope, rescale_intercept=rescale_intercept)\n",
    "\n",
    "    image = np.stack([\n",
    "        window_pixel_values(image=np.copy(image), dicom=dicom, window_center=window_center, window_width=window_width)\n",
    "        for window_center, window_width in zip(window_centers, window_widths)\n",
    "    ], axis=-1)\n",
    "\n",
    "    image_min = image.min(axis=(0, 1))\n",
    "    image_max = image.max(axis=(0, 1))\n",
    "    image = (image - image_min) / (image_max - image_min + 1e-6)\n",
    "    image = invert_pixel_values(image=image, dicom=dicom, photometric_interpretation=photometric_interpretation, max_pixel_value=max_pixel_value)\n",
    "    image = (image * 255.0).astype(np.uint8)\n",
    "\n",
    "    return image\n",
    "\n",
    "\n",
    "def adjust_pixel_spacing(image, dicom, current_pixel_spacing=None, new_pixel_spacing=(1.0, 1.0)):\n",
    "\n",
    "    \"\"\"\n",
    "    Adjust pixel values by shifting bits, windowing, rescaling and inverting\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    image: numpy.ndarray of shape (height, width)\n",
    "        Image array\n",
    "\n",
    "    dicom: pydicom.dataset.FileDataset\n",
    "        DICOM dataset\n",
    "\n",
    "    current_pixel_spacing: tuple, str ('dataset') or None\n",
    "        Physical distance in the patient between the center of each pixel\n",
    "\n",
    "    new_pixel_spacing: tuple\n",
    "        Desired pixel spacing after resize operation\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    image: numpy.ndarray of shape (height, width)\n",
    "        Image array with adjusted pixel spacing\n",
    "    \"\"\"\n",
    "\n",
    "    if current_pixel_spacing == 'dataset':\n",
    "        try:\n",
    "            current_pixel_spacing = dicom.PixelSpacing\n",
    "        except AttributeError:\n",
    "            current_pixel_spacing = None\n",
    "\n",
    "    if current_pixel_spacing is not None:\n",
    "        resize_factor = np.array(current_pixel_spacing) / np.array(new_pixel_spacing)\n",
    "        rounded_shape = np.round(image.shape[:2] * resize_factor)\n",
    "        resize_factor = rounded_shape / image.shape[:2]\n",
    "        image = cv2.resize(image, dsize=None, fx=resize_factor[1], fy=resize_factor[0], interpolation=cv2.INTER_NEAREST)\n",
    "\n",
    "    return image\n",
    "\n",
    "\n",
    "def read_image(dicom_file_path, output_directory, pixel_spacing=None):\n",
    "\n",
    "    \"\"\"\n",
    "    Read DICOM file and process the image\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    dicom_file_path: str\n",
    "        Path of the DICOM file\n",
    "\n",
    "    output_directory: pathlib.Path\n",
    "        Path of the directory image will be written to\n",
    "\n",
    "    pixel_spacing: tuple\n",
    "        Image pixel spacing after normalization\n",
    "    \"\"\"\n",
    "\n",
    "    dicom = pydicom.dcmread(str(dicom_file_path))\n",
    "    image = dicom.pixel_array\n",
    "    image = adjust_pixel_values(\n",
    "        image=image, dicom=dicom,\n",
    "        bits_allocated='dataset', bits_stored='dataset',\n",
    "        rescale_slope='dataset', rescale_intercept='dataset',\n",
    "        window_centers=['dataset'], window_widths=['dataset'],\n",
    "        photometric_interpretation='dataset', max_pixel_value=1\n",
    "    )\n",
    "\n",
    "    if pixel_spacing is not None:\n",
    "        image = dicom_utilities.adjust_pixel_spacing(\n",
    "            image=image,\n",
    "            dicom=dicom,\n",
    "            current_pixel_spacing='dataset',\n",
    "            new_pixel_spacing=pixel_spacing\n",
    "        )\n",
    "\n",
    "    return image\n",
    "\n",
    "\n",
    "def get_largest_contour(image):\n",
    "\n",
    "    \"\"\"\n",
    "    Get the largest contour from the image\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    image: numpy.ndarray of shape (height, width)\n",
    "        Image array\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    bounding_box: list of shape (4)\n",
    "        Bounding box with x1, y1, x2, y2 values\n",
    "    \"\"\"\n",
    "\n",
    "    thresholded_image = cv2.threshold(image, 20, 255, cv2.THRESH_BINARY)[1]\n",
    "    contours, _ = cv2.findContours(thresholded_image, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\n",
    "\n",
    "    if len(contours) == 0:\n",
    "        x1 = 0\n",
    "        x2 = image.shape[1] + 1\n",
    "        y1 = 0\n",
    "        y2 = image.shape[0] + 1\n",
    "    else:\n",
    "        contour = max(contours, key=cv2.contourArea)\n",
    "        mask = np.zeros(image.shape, np.uint8)\n",
    "        cv2.drawContours(mask, [contour], -1, 255, cv2.FILLED)\n",
    "\n",
    "        y1, y2 = np.min(contour[:, :, 1]), np.max(contour[:, :, 1])\n",
    "        x1, x2 = np.min(contour[:, :, 0]), np.max(contour[:, :, 0])\n",
    "\n",
    "        x1 = int(0.99 * x1)\n",
    "        x2 = int(1.01 * x2)\n",
    "        y1 = int(0.99 * y1)\n",
    "        y2 = int(1.01 * y2)\n",
    "\n",
    "    bounding_box = [x1, y1, x2, y2]\n",
    "\n",
    "    return bounding_box\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "218b5865",
   "metadata": {
    "papermill": {
     "duration": 0.005526,
     "end_time": "2023-10-13T11:11:16.794392",
     "exception": false,
     "start_time": "2023-10-13T11:11:16.788866",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## 3. Models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "8f8b2c0e",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-13T11:11:16.807131Z",
     "iopub.status.busy": "2023-10-13T11:11:16.806523Z",
     "iopub.status.idle": "2023-10-13T11:11:16.812289Z",
     "shell.execute_reply": "2023-10-13T11:11:16.811369Z"
    },
    "papermill": {
     "duration": 0.01384,
     "end_time": "2023-10-13T11:11:16.813894",
     "exception": false,
     "start_time": "2023-10-13T11:11:16.800054",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "class ClassificationHead(nn.Module):\n",
    "\n",
    "    def __init__(self, input_dimensions):\n",
    "\n",
    "        super(ClassificationHead, self).__init__()\n",
    "\n",
    "        self.bowel_head = nn.Linear(input_dimensions, 1, bias=True)\n",
    "        self.extravasation_head = nn.Linear(input_dimensions, 1, bias=True)\n",
    "        self.kidney_head = nn.Linear(input_dimensions, 3, bias=True)\n",
    "        self.liver_head = nn.Linear(input_dimensions, 3, bias=True)\n",
    "        self.spleen_head = nn.Linear(input_dimensions, 3, bias=True)\n",
    "\n",
    "    def forward(self, x):\n",
    "\n",
    "        bowel_output = self.bowel_head(x)\n",
    "        extravasation_output = self.extravasation_head(x)\n",
    "        kidney_output = self.kidney_head(x)\n",
    "        liver_output = self.liver_head(x)\n",
    "        spleen_output = self.spleen_head(x)\n",
    "\n",
    "        return bowel_output, extravasation_output, kidney_output, liver_output, spleen_output\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "512e2348",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-13T11:11:16.826944Z",
     "iopub.status.busy": "2023-10-13T11:11:16.826260Z",
     "iopub.status.idle": "2023-10-13T11:11:16.834974Z",
     "shell.execute_reply": "2023-10-13T11:11:16.834194Z"
    },
    "papermill": {
     "duration": 0.01719,
     "end_time": "2023-10-13T11:11:16.836633",
     "exception": false,
     "start_time": "2023-10-13T11:11:16.819443",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "class GeM(nn.Module):\n",
    "\n",
    "    def __init__(self, p=3, eps=1e-6):\n",
    "        super(GeM, self).__init__()\n",
    "        self.p = nn.Parameter(torch.ones(1) * p)\n",
    "        self.eps = eps\n",
    "\n",
    "    def forward(self, x):\n",
    "        return self.gem(x, p=self.p, eps=self.eps)\n",
    "\n",
    "    def gem(self, x, p=3, eps=1e-6):\n",
    "        return F.avg_pool2d(x.clamp(min=eps).pow(p), (x.size(-2), x.size(-1))).pow(1. / p)\n",
    "\n",
    "    def __repr__(self):\n",
    "        return self.__class__.__name__ + \\\n",
    "            '(' + 'p=' + '{:.4f}'.format(self.p.data.tolist()[0]) + \\\n",
    "            ', ' + 'eps=' + str(self.eps) + ')'\n",
    "\n",
    "\n",
    "class Attention(nn.Module):\n",
    "\n",
    "    def __init__(self, sequence_length, dimensions, bias=True):\n",
    "\n",
    "        super(Attention, self).__init__()\n",
    "\n",
    "        weight = torch.zeros(dimensions, 1)\n",
    "        nn.init.xavier_uniform_(weight)\n",
    "        self.weight = nn.Parameter(weight)\n",
    "        self.bias = bias\n",
    "        if bias:\n",
    "            self.b = nn.Parameter(torch.zeros(sequence_length))\n",
    "\n",
    "    def forward(self, x):\n",
    "\n",
    "        input_batch_size, input_sequence_length, input_dimensions = x.shape\n",
    "\n",
    "        eij = torch.mm(\n",
    "            x.contiguous().view(-1, input_dimensions),\n",
    "            self.weight\n",
    "        ).view(-1, input_sequence_length)\n",
    "\n",
    "        if self.bias:\n",
    "            eij = eij + self.b\n",
    "\n",
    "        eij = torch.tanh(eij)\n",
    "        a = torch.exp(eij)\n",
    "        a = a / torch.sum(a, 1, keepdim=True) + 1e-10\n",
    "        weighted_input = x * torch.unsqueeze(a, -1)\n",
    "        output = torch.sum(weighted_input, 1)\n",
    "\n",
    "        return output\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "01c12b17",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-13T11:11:16.849796Z",
     "iopub.status.busy": "2023-10-13T11:11:16.849276Z",
     "iopub.status.idle": "2023-10-13T11:11:16.861182Z",
     "shell.execute_reply": "2023-10-13T11:11:16.860369Z"
    },
    "papermill": {
     "duration": 0.020267,
     "end_time": "2023-10-13T11:11:16.862877",
     "exception": false,
     "start_time": "2023-10-13T11:11:16.842610",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "class MILClassificationModel(nn.Module):\n",
    "\n",
    "    def __init__(self, model_name, pretrained, backbone_args, mil_pooling_type, feature_pooling_type, dropout_rate, freeze_parameters):\n",
    "\n",
    "        super(MILClassificationModel, self).__init__()\n",
    "\n",
    "        self.backbone = timm.create_model(\n",
    "            model_name=model_name,\n",
    "            pretrained=pretrained,\n",
    "            **backbone_args\n",
    "        )\n",
    "\n",
    "        if freeze_parameters:\n",
    "            for parameter in self.backbone.parameters():\n",
    "                parameter.requires_grad = False\n",
    "\n",
    "        self.mil_pooling_type = mil_pooling_type\n",
    "        self.feature_pooling_type = feature_pooling_type\n",
    "        input_features = self.backbone.get_classifier().in_features\n",
    "        self.backbone.classifier = nn.Identity()\n",
    "\n",
    "        if self.feature_pooling_type == 'gem':\n",
    "            self.pooling = GeM()\n",
    "        elif self.feature_pooling_type == 'attention':\n",
    "            self.pooling = nn.Sequential(\n",
    "                nn.LayerNorm(normalized_shape=input_features),\n",
    "                Attention(sequence_length=49, dimensions=input_features)\n",
    "            )\n",
    "        else:\n",
    "            self.pooling = nn.Identity()\n",
    "\n",
    "        self.dropout = nn.Dropout(dropout_rate) if dropout_rate > 0 else nn.Identity()\n",
    "        self.head = ClassificationHead(input_dimensions=input_features)\n",
    "\n",
    "    def forward(self, x):\n",
    "\n",
    "        input_batch_size, input_channel, input_depth, input_height, input_width = x.shape\n",
    "        x = x.view(input_batch_size * input_depth, input_channel, input_height, input_width)\n",
    "        x = self.backbone.forward_features(x)\n",
    "        feature_batch_size, feature_channel, feature_height, feature_width = x.shape\n",
    "\n",
    "        if self.mil_pooling_type == 'avg':\n",
    "            x = x.contiguous().view(input_batch_size, input_depth, feature_channel, feature_height, feature_width)\n",
    "            x = torch.mean(x, dim=1)\n",
    "        elif self.mil_pooling_type == 'max':\n",
    "            x = x.contiguous().view(input_batch_size, input_depth, feature_channel, feature_height, feature_width)\n",
    "            x = torch.max(x, dim=1)[0]\n",
    "        elif self.mil_pooling_type == 'concat':\n",
    "            x = x.contiguous().view(input_batch_size, input_depth * feature_channel, feature_height, feature_width)\n",
    "        else:\n",
    "            raise ValueError(f'Invalid MIL pooling type {self.mil_pooling_type}')\n",
    "\n",
    "        if self.feature_pooling_type == 'avg':\n",
    "            x = F.adaptive_avg_pool2d(x, output_size=(1, 1)).view(x.size(0), -1)\n",
    "        elif self.feature_pooling_type == 'max':\n",
    "            x = F.adaptive_max_pool2d(x, output_size=(1, 1)).view(x.size(0), -1)\n",
    "        elif self.feature_pooling_type == 'concat':\n",
    "            x = torch.cat([\n",
    "                F.adaptive_avg_pool2d(x, output_size=(1, 1)).view(x.size(0), -1),\n",
    "                F.adaptive_max_pool2d(x, output_size=(1, 1)).view(x.size(0), -1)\n",
    "            ], dim=-1)\n",
    "        elif self.feature_pooling_type == 'gem':\n",
    "            x = self.pooling(x).view(x.size(0), -1)\n",
    "        elif self.feature_pooling_type == 'attention':\n",
    "            input_batch_size, feature_channel = x.shape[:2]\n",
    "            x = x.contiguous().view(input_batch_size, feature_channel, -1).permute(0, 2, 1)\n",
    "            x = self.pooling(x)\n",
    "        else:\n",
    "            raise ValueError(f'Invalid feature pooling type {self.feature_pooling_type}')\n",
    "\n",
    "        x = self.dropout(x)\n",
    "        bowel_output, extravasation_output, kidney_output, liver_output, spleen_output = self.head(x)\n",
    "\n",
    "        return bowel_output, extravasation_output, kidney_output, liver_output, spleen_output\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "c8f2d127",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-13T11:11:16.875754Z",
     "iopub.status.busy": "2023-10-13T11:11:16.875249Z",
     "iopub.status.idle": "2023-10-13T11:11:16.885430Z",
     "shell.execute_reply": "2023-10-13T11:11:16.884547Z"
    },
    "papermill": {
     "duration": 0.018769,
     "end_time": "2023-10-13T11:11:16.887322",
     "exception": false,
     "start_time": "2023-10-13T11:11:16.868553",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "class RNNClassificationModel(nn.Module):\n",
    "\n",
    "    def __init__(self, model_name, pretrained, backbone_args, feature_pooling_type, rnn_class, rnn_args, dropout_rate, freeze_parameters):\n",
    "\n",
    "        super(RNNClassificationModel, self).__init__()\n",
    "\n",
    "        self.backbone = timm.create_model(\n",
    "            model_name=model_name,\n",
    "            pretrained=pretrained,\n",
    "            **backbone_args\n",
    "        )\n",
    "\n",
    "        if freeze_parameters:\n",
    "            for parameter in self.backbone.parameters():\n",
    "                parameter.requires_grad = False\n",
    "\n",
    "        self.feature_pooling_type = feature_pooling_type\n",
    "        input_features = self.backbone.get_classifier().in_features\n",
    "        self.backbone.classifier = nn.Identity()\n",
    "\n",
    "        if self.feature_pooling_type == 'gem':\n",
    "            self.pooling = GeM()\n",
    "        else:\n",
    "            self.pooling = nn.Identity()\n",
    "\n",
    "        self.rnn = getattr(nn, rnn_class)(input_size=input_features, **rnn_args)\n",
    "\n",
    "        self.dropout = nn.Dropout(dropout_rate) if dropout_rate > 0 else nn.Identity()\n",
    "        input_dimensions = rnn_args['hidden_size'] * (int(rnn_args['bidirectional']) + 1)\n",
    "        self.head = ClassificationHead(input_dimensions=input_dimensions)\n",
    "\n",
    "    def forward(self, x):\n",
    "\n",
    "        input_batch_size, input_channel, input_depth, input_height, input_width = x.shape\n",
    "        x = x.view(input_batch_size * input_depth, input_channel, input_height, input_width)\n",
    "        x = self.backbone.forward_features(x)\n",
    "\n",
    "        feature_batch_size, feature_channel, feature_height, feature_width = x.shape\n",
    "\n",
    "        if self.feature_pooling_type == 'avg':\n",
    "            x = F.adaptive_avg_pool2d(x, output_size=(1, 1)).view(x.size(0), -1)\n",
    "        elif self.feature_pooling_type == 'max':\n",
    "            x = F.adaptive_max_pool2d(x, output_size=(1, 1)).view(x.size(0), -1)\n",
    "        elif self.feature_pooling_type == 'concat':\n",
    "            x = torch.cat([\n",
    "                F.adaptive_avg_pool2d(x, output_size=(1, 1)).view(x.size(0), -1),\n",
    "                F.adaptive_max_pool2d(x, output_size=(1, 1)).view(x.size(0), -1)\n",
    "            ], dim=-1)\n",
    "        elif self.feature_pooling_type == 'gem':\n",
    "            x = self.pooling(x).view(x.size(0), -1)\n",
    "        else:\n",
    "            raise ValueError(f'Invalid feature pooling type {self.feature_pooling_type}')\n",
    "\n",
    "        x = x.contiguous().view(input_batch_size, input_depth, feature_channel)\n",
    "        x, _ = self.rnn(x)\n",
    "        x = torch.max(x, dim=1)[0]\n",
    "        x = self.dropout(x)\n",
    "        bowel_output, extravasation_output, kidney_output, liver_output, spleen_output = self.head(x)\n",
    "\n",
    "        return bowel_output, extravasation_output, kidney_output, liver_output, spleen_output\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "7c8eb2b8",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-13T11:11:16.900071Z",
     "iopub.status.busy": "2023-10-13T11:11:16.899453Z",
     "iopub.status.idle": "2023-10-13T11:11:16.904836Z",
     "shell.execute_reply": "2023-10-13T11:11:16.903892Z"
    },
    "papermill": {
     "duration": 0.013378,
     "end_time": "2023-10-13T11:11:16.906478",
     "exception": false,
     "start_time": "2023-10-13T11:11:16.893100",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def load_model(model_directory, model_file_names, device):\n",
    "    \n",
    "    \"\"\"\n",
    "    Load model and pretrained weights from the given model directory\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    model_directory: str\n",
    "        Path of the model directory\n",
    "\n",
    "    model_file_names: str\n",
    "        Name of the model weights files\n",
    "\n",
    "    device: torch.device\n",
    "        Location of the model\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    model: torch.nn.Module\n",
    "        Model with weights loaded\n",
    "    \"\"\"\n",
    "\n",
    "    config = yaml.load(open(model_directory / 'config.yaml', 'r'), Loader=yaml.FullLoader)\n",
    "    config['model']['model_args']['pretrained'] = False\n",
    "        \n",
    "    models = {}\n",
    "\n",
    "    for model_file_name in tqdm(model_file_names):\n",
    "        model = eval(config['model']['model_class'])(**config['model']['model_args'])\n",
    "        model.load_state_dict(torch.load(model_directory / model_file_name))\n",
    "        model.to(device)\n",
    "        model.eval()\n",
    "        models[model_file_name] = model\n",
    "\n",
    "    return models, config\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "5d77e70c",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-13T11:11:16.919238Z",
     "iopub.status.busy": "2023-10-13T11:11:16.918465Z",
     "iopub.status.idle": "2023-10-13T11:11:36.048811Z",
     "shell.execute_reply": "2023-10-13T11:11:36.047865Z"
    },
    "papermill": {
     "duration": 19.138683,
     "end_time": "2023-10-13T11:11:36.050766",
     "exception": false,
     "start_time": "2023-10-13T11:11:16.912083",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 5/5 [00:07<00:00,  1.44s/it]\n",
      "100%|██████████| 5/5 [00:02<00:00,  1.84it/s]\n",
      "100%|██████████| 5/5 [00:04<00:00,  1.13it/s]\n",
      "100%|██████████| 5/5 [00:04<00:00,  1.07it/s]\n"
     ]
    }
   ],
   "source": [
    "mil_efficientnetb0_models, mil_efficientnetb0_config = load_model(\n",
    "    model_directory=external_dataset / 'mil_efficientnetb0_3d_1w_contour_cropped_96x256x256',\n",
    "    model_file_names=[\n",
    "        'model_fold1_best.pt',\n",
    "        'model_fold2_best.pt',\n",
    "        'model_fold3_best.pt',\n",
    "        'model_fold4_best.pt',\n",
    "        'model_fold5_best.pt',\n",
    "    ],\n",
    "    device=torch.device('cuda')\n",
    ")\n",
    "\n",
    "mil_densenet121_models, mil_densenet121_config = load_model(\n",
    "    model_directory=external_dataset / 'mil_densenet121_3d_1w_contour_cropped_96x256x256',\n",
    "    model_file_names=[\n",
    "        'model_fold1_best.pt',\n",
    "        'model_fold2_best.pt',\n",
    "        'model_fold3_best.pt',\n",
    "        'model_fold4_best.pt',\n",
    "        'model_fold5_best.pt',\n",
    "    ],\n",
    "    device=torch.device('cuda')\n",
    ")\n",
    "\n",
    "lstm_efficientnetb0_models, lstm_efficientnetb0_config = load_model(\n",
    "    model_directory=external_dataset / 'lstm_efficientnetb0_3d_1w_contour_cropped_96x256x256',\n",
    "    model_file_names=[\n",
    "        'model_fold1_best.pt',\n",
    "        'model_fold2_best.pt',\n",
    "        'model_fold3_best.pt',\n",
    "        'model_fold4_best.pt',\n",
    "        'model_fold5_best.pt',\n",
    "    ],\n",
    "    device=torch.device('cuda')\n",
    ")\n",
    "\n",
    "lstm_efficientnetv2t_models, lstm_efficientnetv2t_config = load_model(\n",
    "    model_directory=external_dataset / 'lstm_efficientnetv2t_3d_1w_contour_cropped_96x256x256',\n",
    "    model_file_names=[\n",
    "        'model_fold1_best.pt',\n",
    "        'model_fold2_best.pt',\n",
    "        'model_fold3_best.pt',\n",
    "        'model_fold4_best.pt',\n",
    "        'model_fold5_best.pt',\n",
    "    ],\n",
    "    device=torch.device('cuda')\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa37844b",
   "metadata": {
    "papermill": {
     "duration": 0.007308,
     "end_time": "2023-10-13T11:11:36.065633",
     "exception": false,
     "start_time": "2023-10-13T11:11:36.058325",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## 4. Transforms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "5756e262",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-13T11:11:36.081882Z",
     "iopub.status.busy": "2023-10-13T11:11:36.081301Z",
     "iopub.status.idle": "2023-10-13T11:11:36.089888Z",
     "shell.execute_reply": "2023-10-13T11:11:36.089092Z"
    },
    "papermill": {
     "duration": 0.018627,
     "end_time": "2023-10-13T11:11:36.091548",
     "exception": false,
     "start_time": "2023-10-13T11:11:36.072921",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def get_3d_classification_transforms(**transform_parameters):\n",
    "\n",
    "    \"\"\"\n",
    "    Get transforms for classification dataset\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    transform_parameters: dict\n",
    "        Dictionary of transform parameters\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    transforms: dict\n",
    "        Transforms for training, validation and test sets\n",
    "    \"\"\"\n",
    "\n",
    "    training_transforms = T.Compose([\n",
    "        T.EnsureChannelFirst(channel_dim=0),\n",
    "        T.RandFlip(spatial_axis=0, prob=transform_parameters['random_z_flip_probability']),\n",
    "        T.RandFlip(spatial_axis=1, prob=transform_parameters['random_x_flip_probability']),\n",
    "        T.RandFlip(spatial_axis=2, prob=transform_parameters['random_y_flip_probability']),\n",
    "        T.RandRotate90(spatial_axes=(1, 2), max_k=3, prob=transform_parameters['random_axial_rotate_90_probability']),\n",
    "        T.RandRotate(\n",
    "            range_x=transform_parameters['random_rotate_range_x'],\n",
    "            range_y=transform_parameters['random_rotate_range_y'],\n",
    "            range_z=transform_parameters['random_rotate_range_z'],\n",
    "            prob=transform_parameters['random_rotate_probability']\n",
    "        ),\n",
    "        T.OneOf([\n",
    "            T.RandHistogramShift(num_control_points=transform_parameters['random_histogram_shift_num_control_points'], prob=transform_parameters['random_histogram_shift_probability']),\n",
    "            T.RandAdjustContrast(gamma=transform_parameters['random_contrast_gamma'], prob=transform_parameters['random_contrast_probability'])\n",
    "        ], weights=(0.5, 0.5)),\n",
    "        T.RandSpatialCrop(roi_size=transform_parameters['crop_roi_size'], max_roi_size=None, random_center=True, random_size=False),\n",
    "        T.RandCoarseDropout(\n",
    "            holes=transform_parameters['cutout_holes'],\n",
    "            spatial_size=transform_parameters['cutout_spatial_size'],\n",
    "            dropout_holes=True,\n",
    "            fill_value=0,\n",
    "            max_holes=transform_parameters['cutout_max_holes'],\n",
    "            max_spatial_size=transform_parameters['max_spatial_size'],\n",
    "            prob=transform_parameters['cutout_probability']\n",
    "        ),\n",
    "        T.ToTensor(dtype=torch.float32, track_meta=False)\n",
    "    ])\n",
    "\n",
    "    inference_transforms = T.Compose([\n",
    "        T.Resize(spatial_size=(96, 256, 256)),\n",
    "        T.CenterSpatialCrop(roi_size=(-1, 224, 224))\n",
    "    ])\n",
    "\n",
    "    classification_transforms = {'training': training_transforms, 'inference': inference_transforms}\n",
    "    return classification_transforms\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e3c2772",
   "metadata": {
    "papermill": {
     "duration": 0.006898,
     "end_time": "2023-10-13T11:11:36.105360",
     "exception": false,
     "start_time": "2023-10-13T11:11:36.098462",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## 5. Inference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "2943a6a5",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-13T11:11:36.120747Z",
     "iopub.status.busy": "2023-10-13T11:11:36.120470Z",
     "iopub.status.idle": "2023-10-13T11:11:36.125809Z",
     "shell.execute_reply": "2023-10-13T11:11:36.124822Z"
    },
    "papermill": {
     "duration": 0.015122,
     "end_time": "2023-10-13T11:11:36.127625",
     "exception": false,
     "start_time": "2023-10-13T11:11:36.112503",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "device = torch.device('cuda')\n",
    "amp = True\n",
    "inference_transforms = T.Compose([\n",
    "    T.Resize(spatial_size=(96, 256, 256)),\n",
    "    T.CenterSpatialCrop(roi_size=(-1, 224, 224))\n",
    "])\n",
    "tta = True\n",
    "tta_flip_dimensions = [(2, 3, 4), (2, 3), (2, 4), (3, 4)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "d162f19c",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-13T11:11:36.143578Z",
     "iopub.status.busy": "2023-10-13T11:11:36.143321Z",
     "iopub.status.idle": "2023-10-13T11:12:08.991115Z",
     "shell.execute_reply": "2023-10-13T11:12:08.990028Z"
    },
    "papermill": {
     "duration": 32.859979,
     "end_time": "2023-10-13T11:12:08.994765",
     "exception": false,
     "start_time": "2023-10-13T11:11:36.134786",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 3/3 [00:32<00:00, 10.94s/it]\n"
     ]
    }
   ],
   "source": [
    "bowel_predictions = []\n",
    "extravasation_predictions = []\n",
    "kidney_predictions = []\n",
    "liver_predictions = []\n",
    "spleen_predictions = []\n",
    "patient_ids_predictions = []\n",
    "scan_ids_predictions = []\n",
    "\n",
    "dicom_dataset_directory = competition_dataset / 'test_images'\n",
    "patient_ids = sorted(os.listdir(dicom_dataset_directory), key=lambda filename: int(filename))\n",
    "\n",
    "for patient_id in tqdm(patient_ids):\n",
    "\n",
    "    patient_directory = dicom_dataset_directory / str(patient_id)\n",
    "    patient_scans = sorted(os.listdir(patient_directory), key=lambda filename: int(filename))\n",
    "\n",
    "    for scan_id in patient_scans:\n",
    "\n",
    "        scan_directory = patient_directory / str(scan_id)\n",
    "        file_names = sorted(os.listdir(scan_directory), key=lambda x: int(str(x).split('.')[0]))\n",
    "                        \n",
    "        if patient_id == '3124' and scan_id == '5842':\n",
    "            # Remove corrupt DICOM file\n",
    "            file_names.remove('514.dcm')\n",
    "            \n",
    "        z_positions = []\n",
    "        patient_positions = []\n",
    "        scan = []\n",
    "        \n",
    "        for file_idx, file_name in enumerate(file_names, start=1):\n",
    "            \n",
    "            dicom = pydicom.dcmread(str(scan_directory / file_name))\n",
    "\n",
    "            try:\n",
    "                patient_position = dicom.PatientPosition\n",
    "            except AttributeError:\n",
    "                patient_position = 'FFS'\n",
    "            \n",
    "            patient_positions.append(patient_position)\n",
    "            \n",
    "            try:\n",
    "                z_position = float(dicom.ImagePositionPatient[-1])\n",
    "            except AttributeError:\n",
    "                z_position = file_idx * -1\n",
    "                \n",
    "            z_positions.append(z_position)\n",
    "            \n",
    "            image = dicom.pixel_array\n",
    "            image = adjust_pixel_values(\n",
    "                image=image, dicom=dicom,\n",
    "                bits_allocated='dataset', bits_stored='dataset',\n",
    "                rescale_slope='dataset', rescale_intercept='dataset',\n",
    "                window_centers=['dataset'], window_widths=['dataset'],\n",
    "                photometric_interpretation='dataset', max_pixel_value=1\n",
    "            )\n",
    "            image = np.squeeze(image, axis=-1)\n",
    "            scan.append(image)\n",
    "            \n",
    "        scan = np.array(scan)\n",
    "            \n",
    "        # Sort CT scan slices by head to feet\n",
    "        sorting_idx_z = np.argsort(z_positions)[::-1]\n",
    "        scan = scan[sorting_idx_z]\n",
    "        \n",
    "        patient_position = pd.Series(patient_positions).value_counts().index[0]\n",
    "        if patient_position is not None:\n",
    "            if patient_position == 'HFS':\n",
    "                # Flip x-axis if patient position is head first\n",
    "                scan = np.flip(scan, axis=2)\n",
    "\n",
    "        # Find partial slices by calculating sum of all zero vertical lines\n",
    "        if scan.shape[0] != 1:\n",
    "            scan_all_zero_vertical_line_transitions = np.diff(np.all(scan == 0, axis=1).sum(axis=1))\n",
    "            # Heuristically select high and low transitions on z-axis and drop them\n",
    "            slices_with_all_zero_vertical_lines = (scan_all_zero_vertical_line_transitions > 5) | (scan_all_zero_vertical_line_transitions < -5)\n",
    "            slices_with_all_zero_vertical_lines = np.append(slices_with_all_zero_vertical_lines, slices_with_all_zero_vertical_lines[-1])\n",
    "            scan = scan[~slices_with_all_zero_vertical_lines]\n",
    "            del scan_all_zero_vertical_line_transitions, slices_with_all_zero_vertical_lines\n",
    "        \n",
    "        # Crop the largest contour\n",
    "        largest_contour_bounding_boxes = np.array([get_largest_contour(image) for image in scan])\n",
    "        largest_contour_bounding_box = [\n",
    "            int(largest_contour_bounding_boxes[:, 0].min()),\n",
    "            int(largest_contour_bounding_boxes[:, 1].min()),\n",
    "            int(largest_contour_bounding_boxes[:, 2].max()),\n",
    "            int(largest_contour_bounding_boxes[:, 3].max()),\n",
    "        ]\n",
    "        scan = scan[\n",
    "            :,\n",
    "            largest_contour_bounding_box[1]:largest_contour_bounding_box[3] + 1,\n",
    "            largest_contour_bounding_box[0]:largest_contour_bounding_box[2] + 1,\n",
    "        ]\n",
    "        \n",
    "        # Crop non-zero slices along xz, yz and xy planes\n",
    "        mmin = np.array((scan > 0).nonzero()).min(axis=1)\n",
    "        mmax = np.array((scan > 0).nonzero()).max(axis=1)\n",
    "        scan = scan[\n",
    "            mmin[0]:mmax[0] + 1,\n",
    "            mmin[1]:mmax[1] + 1,\n",
    "            mmin[2]:mmax[2] + 1,\n",
    "        ]\n",
    "        \n",
    "        inputs = inference_transforms(torch.from_numpy(np.expand_dims(scan.copy(), axis=0)))\n",
    "        inputs = torch.unsqueeze(inputs, dim=0)\n",
    "        inputs /= 255.\n",
    "        inputs = inputs.to(device)\n",
    "        \n",
    "        n_models = 4\n",
    "        bowel_batch_predictions = torch.zeros(n_models, inputs.shape[0], 1)\n",
    "        extravasation_batch_predictions = torch.zeros(n_models, inputs.shape[0], 1)\n",
    "        kidney_batch_predictions = torch.zeros(n_models, inputs.shape[0], 3)\n",
    "        liver_batch_predictions = torch.zeros(n_models, inputs.shape[0], 3)\n",
    "        spleen_batch_predictions = torch.zeros(n_models, inputs.shape[0], 3)\n",
    "        \n",
    "        for model_idx, models in enumerate([mil_efficientnetb0_models, mil_densenet121_models, lstm_efficientnetb0_models, lstm_efficientnetv2t_models]):\n",
    "            for model in models.values():\n",
    "                with torch.no_grad():\n",
    "                    if amp:\n",
    "                        with torch.cuda.amp.autocast():\n",
    "                            bowel_outputs, extravasation_outputs, kidney_outputs, liver_outputs, spleen_outputs = model(inputs.half())\n",
    "                    else:\n",
    "                        bowel_outputs, extravasation_outputs, kidney_outputs, liver_outputs, spleen_outputs = model(inputs)\n",
    "\n",
    "                bowel_outputs = bowel_outputs.cpu()\n",
    "                extravasation_outputs = extravasation_outputs.cpu()\n",
    "                kidney_outputs = kidney_outputs.cpu()\n",
    "                liver_outputs = liver_outputs.cpu()\n",
    "                spleen_outputs = spleen_outputs.cpu()\n",
    "\n",
    "                if tta:\n",
    "\n",
    "                    tta_bowel_outputs = []\n",
    "                    tta_extravasation_outputs = []\n",
    "                    tta_kidney_outputs = []\n",
    "                    tta_liver_outputs = []\n",
    "                    tta_spleen_outputs = []\n",
    "\n",
    "                    for dimensions in tta_flip_dimensions:\n",
    "\n",
    "                        augmented_inputs = torch.flip(inputs, dims=dimensions).to(device)\n",
    "\n",
    "                        with torch.no_grad():\n",
    "                            augmented_bowel_outputs, augmented_extravasation_outputs, augmented_kidney_outputs, augmented_liver_outputs, augmented_spleen_outputs = model(augmented_inputs)\n",
    "\n",
    "                        tta_bowel_outputs.append(augmented_bowel_outputs.cpu())\n",
    "                        tta_extravasation_outputs.append(augmented_extravasation_outputs.cpu())\n",
    "                        tta_kidney_outputs.append(augmented_kidney_outputs.cpu())\n",
    "                        tta_liver_outputs.append(augmented_liver_outputs.cpu())\n",
    "                        tta_spleen_outputs.append(augmented_spleen_outputs.cpu())\n",
    "\n",
    "                    bowel_outputs = torch.stack(([bowel_outputs] + tta_bowel_outputs), dim=-1)\n",
    "                    extravasation_outputs = torch.stack(([extravasation_outputs] + tta_extravasation_outputs), dim=-1)\n",
    "                    kidney_outputs = torch.stack(([kidney_outputs] + tta_kidney_outputs), dim=-1)\n",
    "                    liver_outputs = torch.stack(([liver_outputs] + tta_liver_outputs), dim=-1)\n",
    "                    spleen_outputs = torch.stack(([spleen_outputs] + tta_spleen_outputs), dim=-1)\n",
    "\n",
    "                    bowel_outputs = torch.mean(bowel_outputs, dim=-1)\n",
    "                    extravasation_outputs = torch.mean(extravasation_outputs, dim=-1)\n",
    "                    kidney_outputs = torch.mean(kidney_outputs, dim=-1)\n",
    "                    liver_outputs = torch.mean(liver_outputs, dim=-1)\n",
    "                    spleen_outputs = torch.mean(spleen_outputs, dim=-1)\n",
    "                \n",
    "                bowel_batch_predictions[model_idx] += bowel_outputs / len(models)\n",
    "                extravasation_batch_predictions[model_idx] += extravasation_outputs / len(models)\n",
    "                kidney_batch_predictions[model_idx] += kidney_outputs / len(models)\n",
    "                liver_batch_predictions[model_idx] += liver_outputs / len(models)\n",
    "                spleen_batch_predictions[model_idx] += spleen_outputs / len(models)\n",
    "                \n",
    "        bowel_predictions += [bowel_batch_predictions]\n",
    "        extravasation_predictions += [extravasation_batch_predictions]\n",
    "        kidney_predictions += [kidney_batch_predictions]\n",
    "        liver_predictions += [liver_batch_predictions]\n",
    "        spleen_predictions += [spleen_batch_predictions]\n",
    "        \n",
    "        patient_ids_predictions.append(patient_id)\n",
    "        scan_ids_predictions.append(scan_id)\n",
    "\n",
    "bowel_predictions = torch.sigmoid(torch.stack(bowel_predictions, dim=0)).numpy()\n",
    "extravasation_predictions = torch.sigmoid(torch.stack(extravasation_predictions, dim=0)).numpy()\n",
    "kidney_predictions = torch.softmax(torch.stack(kidney_predictions, dim=0), dim=-1).numpy()\n",
    "liver_predictions = torch.softmax(torch.stack(liver_predictions, dim=0), dim=-1).numpy()\n",
    "spleen_predictions = torch.softmax(torch.stack(spleen_predictions, dim=0), dim=-1).numpy()\n",
    "patient_ids_predictions = np.array(patient_ids_predictions).reshape(-1, 1)\n",
    "scan_ids_predictions = np.array(scan_ids_predictions).reshape(-1, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "dd0e170a",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-13T11:12:09.011314Z",
     "iopub.status.busy": "2023-10-13T11:12:09.010464Z",
     "iopub.status.idle": "2023-10-13T11:12:09.037264Z",
     "shell.execute_reply": "2023-10-13T11:12:09.036321Z"
    },
    "papermill": {
     "duration": 0.036698,
     "end_time": "2023-10-13T11:12:09.038914",
     "exception": false,
     "start_time": "2023-10-13T11:12:09.002216",
     "status": "completed"
    },
    "tags": []
   },
   "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>patient_id</th>\n",
       "      <th>scan_id</th>\n",
       "      <th>bowel_injury</th>\n",
       "      <th>extravasation_injury</th>\n",
       "      <th>kidney_healthy</th>\n",
       "      <th>kidney_low</th>\n",
       "      <th>kidney_high</th>\n",
       "      <th>liver_healthy</th>\n",
       "      <th>liver_low</th>\n",
       "      <th>liver_high</th>\n",
       "      <th>spleen_healthy</th>\n",
       "      <th>spleen_low</th>\n",
       "      <th>spleen_high</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>48843</td>\n",
       "      <td>62825</td>\n",
       "      <td>0.164637</td>\n",
       "      <td>0.104537</td>\n",
       "      <td>0.819386</td>\n",
       "      <td>0.091680</td>\n",
       "      <td>0.088935</td>\n",
       "      <td>0.837702</td>\n",
       "      <td>0.159296</td>\n",
       "      <td>0.003002</td>\n",
       "      <td>0.537523</td>\n",
       "      <td>0.399659</td>\n",
       "      <td>0.062818</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>50046</td>\n",
       "      <td>24574</td>\n",
       "      <td>0.204688</td>\n",
       "      <td>0.317012</td>\n",
       "      <td>0.873833</td>\n",
       "      <td>0.072329</td>\n",
       "      <td>0.053838</td>\n",
       "      <td>0.928078</td>\n",
       "      <td>0.065482</td>\n",
       "      <td>0.006440</td>\n",
       "      <td>0.719728</td>\n",
       "      <td>0.181671</td>\n",
       "      <td>0.098601</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>63706</td>\n",
       "      <td>39279</td>\n",
       "      <td>0.069994</td>\n",
       "      <td>0.092992</td>\n",
       "      <td>0.746002</td>\n",
       "      <td>0.154351</td>\n",
       "      <td>0.099647</td>\n",
       "      <td>0.658108</td>\n",
       "      <td>0.335896</td>\n",
       "      <td>0.005996</td>\n",
       "      <td>0.785513</td>\n",
       "      <td>0.199809</td>\n",
       "      <td>0.014678</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   patient_id  scan_id  bowel_injury  extravasation_injury  kidney_healthy  \\\n",
       "0       48843    62825      0.164637              0.104537        0.819386   \n",
       "1       50046    24574      0.204688              0.317012        0.873833   \n",
       "2       63706    39279      0.069994              0.092992        0.746002   \n",
       "\n",
       "   kidney_low  kidney_high  liver_healthy  liver_low  liver_high  \\\n",
       "0    0.091680     0.088935       0.837702   0.159296    0.003002   \n",
       "1    0.072329     0.053838       0.928078   0.065482    0.006440   \n",
       "2    0.154351     0.099647       0.658108   0.335896    0.005996   \n",
       "\n",
       "   spleen_healthy  spleen_low  spleen_high  \n",
       "0        0.537523    0.399659     0.062818  \n",
       "1        0.719728    0.181671     0.098601  \n",
       "2        0.785513    0.199809     0.014678  "
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_mil_efficientnetb0_predictions = pd.DataFrame(np.hstack([\n",
    "    patient_ids_predictions,\n",
    "    scan_ids_predictions,\n",
    "    bowel_predictions[:, 0, :, :].reshape(-1, 1),\n",
    "    extravasation_predictions[:, 0, :, :].reshape(-1, 1),\n",
    "    kidney_predictions[:, 0, :, :].reshape(-1, 3),\n",
    "    liver_predictions[:, 0, :, :].reshape(-1, 3),\n",
    "    spleen_predictions[:, 0, :, :].reshape(-1, 3)\n",
    "]), columns=[\n",
    "    'patient_id', 'scan_id',\n",
    "    'bowel_injury', 'extravasation_injury',\n",
    "    'kidney_healthy', 'kidney_low', 'kidney_high',\n",
    "    'liver_healthy', 'liver_low', 'liver_high',\n",
    "    'spleen_healthy', 'spleen_low', 'spleen_high',\n",
    "])\n",
    "\n",
    "df_mil_efficientnetb0_predictions[df_mil_efficientnetb0_predictions.columns[:2]] = df_mil_efficientnetb0_predictions[df_mil_efficientnetb0_predictions.columns[:2]].astype(np.int64)\n",
    "df_mil_efficientnetb0_predictions[df_mil_efficientnetb0_predictions.columns[2:]] = df_mil_efficientnetb0_predictions[df_mil_efficientnetb0_predictions.columns[2:]].astype(np.float32)\n",
    "\n",
    "df_mil_efficientnetb0_predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "80414f6d",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-13T11:12:09.055602Z",
     "iopub.status.busy": "2023-10-13T11:12:09.054804Z",
     "iopub.status.idle": "2023-10-13T11:12:09.073294Z",
     "shell.execute_reply": "2023-10-13T11:12:09.072371Z"
    },
    "papermill": {
     "duration": 0.028481,
     "end_time": "2023-10-13T11:12:09.074944",
     "exception": false,
     "start_time": "2023-10-13T11:12:09.046463",
     "status": "completed"
    },
    "tags": []
   },
   "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>patient_id</th>\n",
       "      <th>scan_id</th>\n",
       "      <th>bowel_injury</th>\n",
       "      <th>extravasation_injury</th>\n",
       "      <th>kidney_healthy</th>\n",
       "      <th>kidney_low</th>\n",
       "      <th>kidney_high</th>\n",
       "      <th>liver_healthy</th>\n",
       "      <th>liver_low</th>\n",
       "      <th>liver_high</th>\n",
       "      <th>spleen_healthy</th>\n",
       "      <th>spleen_low</th>\n",
       "      <th>spleen_high</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>48843</td>\n",
       "      <td>62825</td>\n",
       "      <td>0.120605</td>\n",
       "      <td>0.244441</td>\n",
       "      <td>0.736048</td>\n",
       "      <td>0.154959</td>\n",
       "      <td>0.108994</td>\n",
       "      <td>0.309662</td>\n",
       "      <td>0.421304</td>\n",
       "      <td>0.269034</td>\n",
       "      <td>0.515987</td>\n",
       "      <td>0.335879</td>\n",
       "      <td>0.148134</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>50046</td>\n",
       "      <td>24574</td>\n",
       "      <td>0.264846</td>\n",
       "      <td>0.452300</td>\n",
       "      <td>0.579204</td>\n",
       "      <td>0.258205</td>\n",
       "      <td>0.162591</td>\n",
       "      <td>0.706886</td>\n",
       "      <td>0.201292</td>\n",
       "      <td>0.091821</td>\n",
       "      <td>0.420232</td>\n",
       "      <td>0.302215</td>\n",
       "      <td>0.277553</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>63706</td>\n",
       "      <td>39279</td>\n",
       "      <td>0.274485</td>\n",
       "      <td>0.273311</td>\n",
       "      <td>0.563648</td>\n",
       "      <td>0.265263</td>\n",
       "      <td>0.171089</td>\n",
       "      <td>0.647463</td>\n",
       "      <td>0.323459</td>\n",
       "      <td>0.029078</td>\n",
       "      <td>0.557635</td>\n",
       "      <td>0.340355</td>\n",
       "      <td>0.102010</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   patient_id  scan_id  bowel_injury  extravasation_injury  kidney_healthy  \\\n",
       "0       48843    62825      0.120605              0.244441        0.736048   \n",
       "1       50046    24574      0.264846              0.452300        0.579204   \n",
       "2       63706    39279      0.274485              0.273311        0.563648   \n",
       "\n",
       "   kidney_low  kidney_high  liver_healthy  liver_low  liver_high  \\\n",
       "0    0.154959     0.108994       0.309662   0.421304    0.269034   \n",
       "1    0.258205     0.162591       0.706886   0.201292    0.091821   \n",
       "2    0.265263     0.171089       0.647463   0.323459    0.029078   \n",
       "\n",
       "   spleen_healthy  spleen_low  spleen_high  \n",
       "0        0.515987    0.335879     0.148134  \n",
       "1        0.420232    0.302215     0.277553  \n",
       "2        0.557635    0.340355     0.102010  "
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_mil_densenet121_predictions = pd.DataFrame(np.hstack([\n",
    "    patient_ids_predictions,\n",
    "    scan_ids_predictions,\n",
    "    bowel_predictions[:, 1, :, :].reshape(-1, 1),\n",
    "    extravasation_predictions[:, 1, :, :].reshape(-1, 1),\n",
    "    kidney_predictions[:, 1, :, :].reshape(-1, 3),\n",
    "    liver_predictions[:, 1, :, :].reshape(-1, 3),\n",
    "    spleen_predictions[:, 1, :, :].reshape(-1, 3)\n",
    "]), columns=[\n",
    "    'patient_id', 'scan_id',\n",
    "    'bowel_injury', 'extravasation_injury',\n",
    "    'kidney_healthy', 'kidney_low', 'kidney_high',\n",
    "    'liver_healthy', 'liver_low', 'liver_high',\n",
    "    'spleen_healthy', 'spleen_low', 'spleen_high',\n",
    "])\n",
    "\n",
    "df_mil_densenet121_predictions[df_mil_densenet121_predictions.columns[:2]] = df_mil_densenet121_predictions[df_mil_densenet121_predictions.columns[:2]].astype(np.int64)\n",
    "df_mil_densenet121_predictions[df_mil_densenet121_predictions.columns[2:]] = df_mil_densenet121_predictions[df_mil_densenet121_predictions.columns[2:]].astype(np.float32)\n",
    "\n",
    "df_mil_densenet121_predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "cba2ea50",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-13T11:12:09.092077Z",
     "iopub.status.busy": "2023-10-13T11:12:09.091304Z",
     "iopub.status.idle": "2023-10-13T11:12:09.110919Z",
     "shell.execute_reply": "2023-10-13T11:12:09.109918Z"
    },
    "papermill": {
     "duration": 0.029983,
     "end_time": "2023-10-13T11:12:09.112756",
     "exception": false,
     "start_time": "2023-10-13T11:12:09.082773",
     "status": "completed"
    },
    "tags": []
   },
   "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>patient_id</th>\n",
       "      <th>scan_id</th>\n",
       "      <th>bowel_injury</th>\n",
       "      <th>extravasation_injury</th>\n",
       "      <th>kidney_healthy</th>\n",
       "      <th>kidney_low</th>\n",
       "      <th>kidney_high</th>\n",
       "      <th>liver_healthy</th>\n",
       "      <th>liver_low</th>\n",
       "      <th>liver_high</th>\n",
       "      <th>spleen_healthy</th>\n",
       "      <th>spleen_low</th>\n",
       "      <th>spleen_high</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>48843</td>\n",
       "      <td>62825</td>\n",
       "      <td>0.153750</td>\n",
       "      <td>0.146527</td>\n",
       "      <td>0.805675</td>\n",
       "      <td>0.124133</td>\n",
       "      <td>0.070192</td>\n",
       "      <td>0.850459</td>\n",
       "      <td>0.134133</td>\n",
       "      <td>0.015409</td>\n",
       "      <td>0.616913</td>\n",
       "      <td>0.278651</td>\n",
       "      <td>0.104436</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>50046</td>\n",
       "      <td>24574</td>\n",
       "      <td>0.247409</td>\n",
       "      <td>0.264111</td>\n",
       "      <td>0.799575</td>\n",
       "      <td>0.146055</td>\n",
       "      <td>0.054370</td>\n",
       "      <td>0.863379</td>\n",
       "      <td>0.113796</td>\n",
       "      <td>0.022825</td>\n",
       "      <td>0.677229</td>\n",
       "      <td>0.218331</td>\n",
       "      <td>0.104440</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>63706</td>\n",
       "      <td>39279</td>\n",
       "      <td>0.156947</td>\n",
       "      <td>0.196334</td>\n",
       "      <td>0.753282</td>\n",
       "      <td>0.181841</td>\n",
       "      <td>0.064877</td>\n",
       "      <td>0.816679</td>\n",
       "      <td>0.163509</td>\n",
       "      <td>0.019812</td>\n",
       "      <td>0.805249</td>\n",
       "      <td>0.162147</td>\n",
       "      <td>0.032604</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   patient_id  scan_id  bowel_injury  extravasation_injury  kidney_healthy  \\\n",
       "0       48843    62825      0.153750              0.146527        0.805675   \n",
       "1       50046    24574      0.247409              0.264111        0.799575   \n",
       "2       63706    39279      0.156947              0.196334        0.753282   \n",
       "\n",
       "   kidney_low  kidney_high  liver_healthy  liver_low  liver_high  \\\n",
       "0    0.124133     0.070192       0.850459   0.134133    0.015409   \n",
       "1    0.146055     0.054370       0.863379   0.113796    0.022825   \n",
       "2    0.181841     0.064877       0.816679   0.163509    0.019812   \n",
       "\n",
       "   spleen_healthy  spleen_low  spleen_high  \n",
       "0        0.616913    0.278651     0.104436  \n",
       "1        0.677229    0.218331     0.104440  \n",
       "2        0.805249    0.162147     0.032604  "
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_lstm_efficientnetb0_predictions = pd.DataFrame(np.hstack([\n",
    "    patient_ids_predictions,\n",
    "    scan_ids_predictions,\n",
    "    bowel_predictions[:, 2, :, :].reshape(-1, 1),\n",
    "    extravasation_predictions[:, 2, :, :].reshape(-1, 1),\n",
    "    kidney_predictions[:, 2, :, :].reshape(-1, 3),\n",
    "    liver_predictions[:, 2, :, :].reshape(-1, 3),\n",
    "    spleen_predictions[:, 2, :, :].reshape(-1, 3)\n",
    "]), columns=[\n",
    "    'patient_id', 'scan_id',\n",
    "    'bowel_injury', 'extravasation_injury',\n",
    "    'kidney_healthy', 'kidney_low', 'kidney_high',\n",
    "    'liver_healthy', 'liver_low', 'liver_high',\n",
    "    'spleen_healthy', 'spleen_low', 'spleen_high',\n",
    "])\n",
    "\n",
    "df_lstm_efficientnetb0_predictions[df_lstm_efficientnetb0_predictions.columns[:2]] = df_lstm_efficientnetb0_predictions[df_lstm_efficientnetb0_predictions.columns[:2]].astype(np.int64)\n",
    "df_lstm_efficientnetb0_predictions[df_lstm_efficientnetb0_predictions.columns[2:]] = df_lstm_efficientnetb0_predictions[df_lstm_efficientnetb0_predictions.columns[2:]].astype(np.float32)\n",
    "\n",
    "df_lstm_efficientnetb0_predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "05ce6f8c",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-13T11:12:09.129950Z",
     "iopub.status.busy": "2023-10-13T11:12:09.129700Z",
     "iopub.status.idle": "2023-10-13T11:12:09.150434Z",
     "shell.execute_reply": "2023-10-13T11:12:09.149453Z"
    },
    "papermill": {
     "duration": 0.031151,
     "end_time": "2023-10-13T11:12:09.152277",
     "exception": false,
     "start_time": "2023-10-13T11:12:09.121126",
     "status": "completed"
    },
    "tags": []
   },
   "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>patient_id</th>\n",
       "      <th>scan_id</th>\n",
       "      <th>bowel_injury</th>\n",
       "      <th>extravasation_injury</th>\n",
       "      <th>kidney_healthy</th>\n",
       "      <th>kidney_low</th>\n",
       "      <th>kidney_high</th>\n",
       "      <th>liver_healthy</th>\n",
       "      <th>liver_low</th>\n",
       "      <th>liver_high</th>\n",
       "      <th>spleen_healthy</th>\n",
       "      <th>spleen_low</th>\n",
       "      <th>spleen_high</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>48843</td>\n",
       "      <td>62825</td>\n",
       "      <td>0.298447</td>\n",
       "      <td>0.342589</td>\n",
       "      <td>0.716321</td>\n",
       "      <td>0.171425</td>\n",
       "      <td>0.112254</td>\n",
       "      <td>0.563836</td>\n",
       "      <td>0.334755</td>\n",
       "      <td>0.101409</td>\n",
       "      <td>0.642525</td>\n",
       "      <td>0.235669</td>\n",
       "      <td>0.121805</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>50046</td>\n",
       "      <td>24574</td>\n",
       "      <td>0.129184</td>\n",
       "      <td>0.192317</td>\n",
       "      <td>0.860961</td>\n",
       "      <td>0.095597</td>\n",
       "      <td>0.043441</td>\n",
       "      <td>0.870007</td>\n",
       "      <td>0.092623</td>\n",
       "      <td>0.037370</td>\n",
       "      <td>0.821583</td>\n",
       "      <td>0.122738</td>\n",
       "      <td>0.055679</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>63706</td>\n",
       "      <td>39279</td>\n",
       "      <td>0.346440</td>\n",
       "      <td>0.369482</td>\n",
       "      <td>0.713816</td>\n",
       "      <td>0.191068</td>\n",
       "      <td>0.095115</td>\n",
       "      <td>0.574562</td>\n",
       "      <td>0.323844</td>\n",
       "      <td>0.101594</td>\n",
       "      <td>0.590749</td>\n",
       "      <td>0.272673</td>\n",
       "      <td>0.136577</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   patient_id  scan_id  bowel_injury  extravasation_injury  kidney_healthy  \\\n",
       "0       48843    62825      0.298447              0.342589        0.716321   \n",
       "1       50046    24574      0.129184              0.192317        0.860961   \n",
       "2       63706    39279      0.346440              0.369482        0.713816   \n",
       "\n",
       "   kidney_low  kidney_high  liver_healthy  liver_low  liver_high  \\\n",
       "0    0.171425     0.112254       0.563836   0.334755    0.101409   \n",
       "1    0.095597     0.043441       0.870007   0.092623    0.037370   \n",
       "2    0.191068     0.095115       0.574562   0.323844    0.101594   \n",
       "\n",
       "   spleen_healthy  spleen_low  spleen_high  \n",
       "0        0.642525    0.235669     0.121805  \n",
       "1        0.821583    0.122738     0.055679  \n",
       "2        0.590749    0.272673     0.136577  "
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_lstm_efficientnetv2t_predictions = pd.DataFrame(np.hstack([\n",
    "    patient_ids_predictions,\n",
    "    scan_ids_predictions,\n",
    "    bowel_predictions[:, 3, :, :].reshape(-1, 1),\n",
    "    extravasation_predictions[:, 3, :, :].reshape(-1, 1),\n",
    "    kidney_predictions[:, 3, :, :].reshape(-1, 3),\n",
    "    liver_predictions[:, 3, :, :].reshape(-1, 3),\n",
    "    spleen_predictions[:, 3, :, :].reshape(-1, 3)\n",
    "]), columns=[\n",
    "    'patient_id', 'scan_id',\n",
    "    'bowel_injury', 'extravasation_injury',\n",
    "    'kidney_healthy', 'kidney_low', 'kidney_high',\n",
    "    'liver_healthy', 'liver_low', 'liver_high',\n",
    "    'spleen_healthy', 'spleen_low', 'spleen_high',\n",
    "])\n",
    "\n",
    "df_lstm_efficientnetv2t_predictions[df_lstm_efficientnetv2t_predictions.columns[:2]] = df_lstm_efficientnetv2t_predictions[df_lstm_efficientnetv2t_predictions.columns[:2]].astype(np.int64)\n",
    "df_lstm_efficientnetv2t_predictions[df_lstm_efficientnetv2t_predictions.columns[2:]] = df_lstm_efficientnetv2t_predictions[df_lstm_efficientnetv2t_predictions.columns[2:]].astype(np.float32)\n",
    "\n",
    "df_lstm_efficientnetv2t_predictions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b11259a",
   "metadata": {
    "papermill": {
     "duration": 0.008155,
     "end_time": "2023-10-13T11:12:09.168836",
     "exception": false,
     "start_time": "2023-10-13T11:12:09.160681",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## 6. Post processing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "c84e5938",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-13T11:12:09.186886Z",
     "iopub.status.busy": "2023-10-13T11:12:09.186578Z",
     "iopub.status.idle": "2023-10-13T11:12:09.223337Z",
     "shell.execute_reply": "2023-10-13T11:12:09.222313Z"
    },
    "papermill": {
     "duration": 0.048618,
     "end_time": "2023-10-13T11:12:09.225402",
     "exception": false,
     "start_time": "2023-10-13T11:12:09.176784",
     "status": "completed"
    },
    "tags": []
   },
   "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>patient_id</th>\n",
       "      <th>scan_id</th>\n",
       "      <th>bowel_injury</th>\n",
       "      <th>extravasation_injury</th>\n",
       "      <th>kidney_healthy</th>\n",
       "      <th>kidney_low</th>\n",
       "      <th>kidney_high</th>\n",
       "      <th>liver_healthy</th>\n",
       "      <th>liver_low</th>\n",
       "      <th>liver_high</th>\n",
       "      <th>spleen_healthy</th>\n",
       "      <th>spleen_low</th>\n",
       "      <th>spleen_high</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>48843</td>\n",
       "      <td>62825</td>\n",
       "      <td>0.172067</td>\n",
       "      <td>0.182911</td>\n",
       "      <td>0.769357</td>\n",
       "      <td>0.135549</td>\n",
       "      <td>0.095093</td>\n",
       "      <td>0.640415</td>\n",
       "      <td>0.262372</td>\n",
       "      <td>0.097213</td>\n",
       "      <td>0.578237</td>\n",
       "      <td>0.312464</td>\n",
       "      <td>0.109298</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>50046</td>\n",
       "      <td>24574</td>\n",
       "      <td>0.214810</td>\n",
       "      <td>0.329259</td>\n",
       "      <td>0.778393</td>\n",
       "      <td>0.143047</td>\n",
       "      <td>0.078560</td>\n",
       "      <td>0.842088</td>\n",
       "      <td>0.118298</td>\n",
       "      <td>0.039614</td>\n",
       "      <td>0.659693</td>\n",
       "      <td>0.206239</td>\n",
       "      <td>0.134068</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>63706</td>\n",
       "      <td>39279</td>\n",
       "      <td>0.175627</td>\n",
       "      <td>0.205739</td>\n",
       "      <td>0.694187</td>\n",
       "      <td>0.198131</td>\n",
       "      <td>0.107682</td>\n",
       "      <td>0.674203</td>\n",
       "      <td>0.286677</td>\n",
       "      <td>0.039120</td>\n",
       "      <td>0.684787</td>\n",
       "      <td>0.243746</td>\n",
       "      <td>0.071467</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   patient_id  scan_id  bowel_injury  extravasation_injury  kidney_healthy  \\\n",
       "0       48843    62825      0.172067              0.182911        0.769357   \n",
       "1       50046    24574      0.214810              0.329259        0.778393   \n",
       "2       63706    39279      0.175627              0.205739        0.694187   \n",
       "\n",
       "   kidney_low  kidney_high  liver_healthy  liver_low  liver_high  \\\n",
       "0    0.135549     0.095093       0.640415   0.262372    0.097213   \n",
       "1    0.143047     0.078560       0.842088   0.118298    0.039614   \n",
       "2    0.198131     0.107682       0.674203   0.286677    0.039120   \n",
       "\n",
       "   spleen_healthy  spleen_low  spleen_high  \n",
       "0        0.578237    0.312464     0.109298  \n",
       "1        0.659693    0.206239     0.134068  \n",
       "2        0.684787    0.243746     0.071467  "
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_predictions = pd.DataFrame(columns=[\n",
    "    'patient_id', 'scan_id',\n",
    "    'bowel_injury', 'extravasation_injury',\n",
    "    'kidney_healthy', 'kidney_low', 'kidney_high',\n",
    "    'liver_healthy', 'liver_low', 'liver_high',\n",
    "    'spleen_healthy', 'spleen_low', 'spleen_high',\n",
    "])\n",
    "\n",
    "df_predictions['patient_id'] = patient_ids_predictions.reshape(-1).astype(int)\n",
    "df_predictions['scan_id'] = scan_ids_predictions.reshape(-1).astype(int)\n",
    "\n",
    "mil_efficientnetb0_bowel_weight = 0.45\n",
    "mil_densenet121_bowel_weight = 0.25\n",
    "lstm_efficientnetb0_bowel_weight = 0.15\n",
    "lstm_efficientnetv2t_bowel_weight = 0.15\n",
    "\n",
    "df_predictions['bowel_injury'] = (df_mil_efficientnetb0_predictions['bowel_injury'] * mil_efficientnetb0_bowel_weight) +\\\n",
    "                                 (df_mil_densenet121_predictions['bowel_injury'] * mil_densenet121_bowel_weight) +\\\n",
    "                                 (df_lstm_efficientnetb0_predictions['bowel_injury'] * lstm_efficientnetb0_bowel_weight) +\\\n",
    "                                 (df_lstm_efficientnetv2t_predictions['bowel_injury'] * lstm_efficientnetv2t_bowel_weight)\n",
    "\n",
    "mil_efficientnetb0_extravasation_weight = 0.3\n",
    "mil_densenet121_extravasation_weight = 0.3\n",
    "lstm_efficientnetb0_extravasation_weight = 0.3\n",
    "lstm_efficientnetv2t_extravasation_weight = 0.1\n",
    "\n",
    "df_predictions['extravasation_injury'] = (df_mil_efficientnetb0_predictions['extravasation_injury'] * mil_efficientnetb0_extravasation_weight) +\\\n",
    "                                         (df_mil_densenet121_predictions['extravasation_injury'] * mil_densenet121_extravasation_weight) +\\\n",
    "                                         (df_lstm_efficientnetb0_predictions['extravasation_injury'] * lstm_efficientnetb0_extravasation_weight) +\\\n",
    "                                         (df_lstm_efficientnetv2t_predictions['extravasation_injury'] * lstm_efficientnetv2t_extravasation_weight)\n",
    "\n",
    "mil_efficientnetb0_kidney_weight = 0.25\n",
    "mil_densenet121_kidney_weight = 0.25\n",
    "lstm_efficientnetb0_kidney_weight = 0.25\n",
    "lstm_efficientnetv2t_kidney_weight = 0.25\n",
    "\n",
    "df_predictions['kidney_healthy'] = (df_mil_efficientnetb0_predictions['kidney_healthy'] * mil_efficientnetb0_kidney_weight) +\\\n",
    "                                   (df_mil_densenet121_predictions['kidney_healthy'] * mil_densenet121_kidney_weight) +\\\n",
    "                                   (df_lstm_efficientnetb0_predictions['kidney_healthy'] * lstm_efficientnetb0_kidney_weight) +\\\n",
    "                                   (df_lstm_efficientnetv2t_predictions['kidney_healthy'] * lstm_efficientnetv2t_kidney_weight)\n",
    "\n",
    "df_predictions['kidney_low'] = (df_mil_efficientnetb0_predictions['kidney_low'] * mil_efficientnetb0_kidney_weight) +\\\n",
    "                               (df_mil_densenet121_predictions['kidney_low'] * mil_densenet121_kidney_weight) +\\\n",
    "                               (df_lstm_efficientnetb0_predictions['kidney_low'] * lstm_efficientnetb0_kidney_weight) +\\\n",
    "                               (df_lstm_efficientnetv2t_predictions['kidney_low'] * lstm_efficientnetv2t_kidney_weight)\n",
    "\n",
    "df_predictions['kidney_high'] = (df_mil_efficientnetb0_predictions['kidney_high'] * mil_efficientnetb0_kidney_weight) +\\\n",
    "                                (df_mil_densenet121_predictions['kidney_high'] * mil_densenet121_kidney_weight) +\\\n",
    "                                (df_lstm_efficientnetb0_predictions['kidney_high'] * lstm_efficientnetb0_kidney_weight) +\\\n",
    "                                (df_lstm_efficientnetv2t_predictions['kidney_high'] * lstm_efficientnetv2t_kidney_weight)\n",
    "\n",
    "mil_efficientnetb0_liver_weight = 0.25\n",
    "mil_densenet121_liver_weight = 0.25\n",
    "lstm_efficientnetb0_liver_weight = 0.25\n",
    "lstm_efficientnetv2t_liver_weight = 0.25\n",
    "\n",
    "df_predictions['liver_healthy'] = (df_mil_efficientnetb0_predictions['liver_healthy'] * mil_efficientnetb0_liver_weight) +\\\n",
    "                                  (df_mil_densenet121_predictions['liver_healthy'] * mil_densenet121_liver_weight) +\\\n",
    "                                  (df_lstm_efficientnetb0_predictions['liver_healthy'] * lstm_efficientnetb0_liver_weight) +\\\n",
    "                                  (df_lstm_efficientnetv2t_predictions['liver_healthy'] * lstm_efficientnetv2t_liver_weight)\n",
    "\n",
    "df_predictions['liver_low'] = (df_mil_efficientnetb0_predictions['liver_low'] * mil_efficientnetb0_liver_weight) +\\\n",
    "                              (df_mil_densenet121_predictions['liver_low'] * mil_densenet121_liver_weight) +\\\n",
    "                              (df_lstm_efficientnetb0_predictions['liver_low'] * lstm_efficientnetb0_liver_weight) +\\\n",
    "                              (df_lstm_efficientnetv2t_predictions['liver_low'] * lstm_efficientnetv2t_liver_weight)\n",
    "\n",
    "df_predictions['liver_high'] = (df_mil_efficientnetb0_predictions['liver_high'] * mil_efficientnetb0_liver_weight) +\\\n",
    "                               (df_mil_densenet121_predictions['liver_high'] * mil_densenet121_liver_weight) +\\\n",
    "                               (df_lstm_efficientnetb0_predictions['liver_high'] * lstm_efficientnetb0_liver_weight) +\\\n",
    "                               (df_lstm_efficientnetv2t_predictions['liver_high'] * lstm_efficientnetv2t_liver_weight)\n",
    "\n",
    "mil_efficientnetb0_spleen_weight = 0.25\n",
    "mil_densenet121_spleen_weight = 0.25\n",
    "lstm_efficientnetb0_spleen_weight = 0.25\n",
    "lstm_efficientnetv2t_spleen_weight = 0.25\n",
    "\n",
    "df_predictions['spleen_healthy'] = (df_mil_efficientnetb0_predictions['spleen_healthy'] * mil_efficientnetb0_spleen_weight) +\\\n",
    "                                   (df_mil_densenet121_predictions['spleen_healthy'] * mil_densenet121_spleen_weight) +\\\n",
    "                                   (df_lstm_efficientnetb0_predictions['spleen_healthy'] * lstm_efficientnetb0_spleen_weight) +\\\n",
    "                                   (df_lstm_efficientnetv2t_predictions['spleen_healthy'] * lstm_efficientnetv2t_spleen_weight)\n",
    "\n",
    "df_predictions['spleen_low'] = (df_mil_efficientnetb0_predictions['spleen_low'] * mil_efficientnetb0_spleen_weight) +\\\n",
    "                               (df_mil_densenet121_predictions['spleen_low'] * mil_densenet121_spleen_weight) +\\\n",
    "                               (df_lstm_efficientnetb0_predictions['spleen_low'] * lstm_efficientnetb0_spleen_weight) +\\\n",
    "                               (df_lstm_efficientnetv2t_predictions['spleen_low'] * lstm_efficientnetv2t_spleen_weight)\n",
    "\n",
    "df_predictions['spleen_high'] = (df_mil_efficientnetb0_predictions['spleen_high'] * mil_efficientnetb0_spleen_weight) +\\\n",
    "                                (df_mil_densenet121_predictions['spleen_high'] * mil_densenet121_spleen_weight) +\\\n",
    "                                (df_lstm_efficientnetb0_predictions['spleen_high'] * lstm_efficientnetb0_spleen_weight) +\\\n",
    "                                (df_lstm_efficientnetv2t_predictions['spleen_high'] * lstm_efficientnetv2t_spleen_weight)\n",
    "\n",
    "df_predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "afcc7d8d",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-13T11:12:09.245115Z",
     "iopub.status.busy": "2023-10-13T11:12:09.244325Z",
     "iopub.status.idle": "2023-10-13T11:12:09.265147Z",
     "shell.execute_reply": "2023-10-13T11:12:09.264103Z"
    },
    "papermill": {
     "duration": 0.0324,
     "end_time": "2023-10-13T11:12:09.267077",
     "exception": false,
     "start_time": "2023-10-13T11:12:09.234677",
     "status": "completed"
    },
    "tags": []
   },
   "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>patient_id</th>\n",
       "      <th>scan_id</th>\n",
       "      <th>bowel_injury</th>\n",
       "      <th>extravasation_injury</th>\n",
       "      <th>kidney_healthy</th>\n",
       "      <th>kidney_low</th>\n",
       "      <th>kidney_high</th>\n",
       "      <th>liver_healthy</th>\n",
       "      <th>liver_low</th>\n",
       "      <th>liver_high</th>\n",
       "      <th>spleen_healthy</th>\n",
       "      <th>spleen_low</th>\n",
       "      <th>spleen_high</th>\n",
       "      <th>bowel_healthy</th>\n",
       "      <th>extravasation_healthy</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>48843</td>\n",
       "      <td>62825</td>\n",
       "      <td>0.172067</td>\n",
       "      <td>0.256075</td>\n",
       "      <td>0.769357</td>\n",
       "      <td>0.149104</td>\n",
       "      <td>0.104603</td>\n",
       "      <td>0.640415</td>\n",
       "      <td>0.341083</td>\n",
       "      <td>0.126377</td>\n",
       "      <td>0.578237</td>\n",
       "      <td>0.546813</td>\n",
       "      <td>0.191272</td>\n",
       "      <td>0.827933</td>\n",
       "      <td>0.817089</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>50046</td>\n",
       "      <td>24574</td>\n",
       "      <td>0.214810</td>\n",
       "      <td>0.460962</td>\n",
       "      <td>0.778393</td>\n",
       "      <td>0.157351</td>\n",
       "      <td>0.086416</td>\n",
       "      <td>0.842088</td>\n",
       "      <td>0.153788</td>\n",
       "      <td>0.051499</td>\n",
       "      <td>0.659693</td>\n",
       "      <td>0.360918</td>\n",
       "      <td>0.234620</td>\n",
       "      <td>0.785190</td>\n",
       "      <td>0.670741</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>63706</td>\n",
       "      <td>39279</td>\n",
       "      <td>0.175627</td>\n",
       "      <td>0.288035</td>\n",
       "      <td>0.694187</td>\n",
       "      <td>0.217944</td>\n",
       "      <td>0.118450</td>\n",
       "      <td>0.674203</td>\n",
       "      <td>0.372680</td>\n",
       "      <td>0.050856</td>\n",
       "      <td>0.684787</td>\n",
       "      <td>0.426556</td>\n",
       "      <td>0.125068</td>\n",
       "      <td>0.824373</td>\n",
       "      <td>0.794261</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   patient_id  scan_id  bowel_injury  extravasation_injury  kidney_healthy  \\\n",
       "0       48843    62825      0.172067              0.256075        0.769357   \n",
       "1       50046    24574      0.214810              0.460962        0.778393   \n",
       "2       63706    39279      0.175627              0.288035        0.694187   \n",
       "\n",
       "   kidney_low  kidney_high  liver_healthy  liver_low  liver_high  \\\n",
       "0    0.149104     0.104603       0.640415   0.341083    0.126377   \n",
       "1    0.157351     0.086416       0.842088   0.153788    0.051499   \n",
       "2    0.217944     0.118450       0.674203   0.372680    0.050856   \n",
       "\n",
       "   spleen_healthy  spleen_low  spleen_high  bowel_healthy  \\\n",
       "0        0.578237    0.546813     0.191272       0.827933   \n",
       "1        0.659693    0.360918     0.234620       0.785190   \n",
       "2        0.684787    0.426556     0.125068       0.824373   \n",
       "\n",
       "   extravasation_healthy  \n",
       "0               0.817089  \n",
       "1               0.670741  \n",
       "2               0.794261  "
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_predictions['bowel_healthy'] = 1 - df_predictions['bowel_injury']\n",
    "df_predictions['bowel_injury'] *= 1.\n",
    "\n",
    "df_predictions['extravasation_healthy'] = 1 - df_predictions['extravasation_injury']\n",
    "df_predictions['extravasation_injury'] *= 1.4\n",
    "\n",
    "df_predictions['kidney_low'] *= 1.1\n",
    "df_predictions['kidney_high'] *= 1.1\n",
    "\n",
    "df_predictions['liver_low'] *= 1.3\n",
    "df_predictions['liver_high'] *= 1.3\n",
    "\n",
    "df_predictions['spleen_low'] *= 1.75\n",
    "df_predictions['spleen_high'] *= 1.75\n",
    "\n",
    "df_predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "3c4606df",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-13T11:12:09.286654Z",
     "iopub.status.busy": "2023-10-13T11:12:09.285953Z",
     "iopub.status.idle": "2023-10-13T11:12:09.307860Z",
     "shell.execute_reply": "2023-10-13T11:12:09.306822Z"
    },
    "papermill": {
     "duration": 0.033266,
     "end_time": "2023-10-13T11:12:09.309864",
     "exception": false,
     "start_time": "2023-10-13T11:12:09.276598",
     "status": "completed"
    },
    "tags": []
   },
   "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>patient_id</th>\n",
       "      <th>bowel_healthy</th>\n",
       "      <th>bowel_injury</th>\n",
       "      <th>extravasation_healthy</th>\n",
       "      <th>extravasation_injury</th>\n",
       "      <th>kidney_healthy</th>\n",
       "      <th>kidney_low</th>\n",
       "      <th>kidney_high</th>\n",
       "      <th>liver_healthy</th>\n",
       "      <th>liver_low</th>\n",
       "      <th>liver_high</th>\n",
       "      <th>spleen_healthy</th>\n",
       "      <th>spleen_low</th>\n",
       "      <th>spleen_high</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>48843</td>\n",
       "      <td>0.827933</td>\n",
       "      <td>0.172067</td>\n",
       "      <td>0.817089</td>\n",
       "      <td>0.256075</td>\n",
       "      <td>0.769357</td>\n",
       "      <td>0.149104</td>\n",
       "      <td>0.104603</td>\n",
       "      <td>0.640415</td>\n",
       "      <td>0.341083</td>\n",
       "      <td>0.126377</td>\n",
       "      <td>0.578237</td>\n",
       "      <td>0.546813</td>\n",
       "      <td>0.191272</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>50046</td>\n",
       "      <td>0.785190</td>\n",
       "      <td>0.214810</td>\n",
       "      <td>0.670741</td>\n",
       "      <td>0.460962</td>\n",
       "      <td>0.778393</td>\n",
       "      <td>0.157351</td>\n",
       "      <td>0.086416</td>\n",
       "      <td>0.842088</td>\n",
       "      <td>0.153788</td>\n",
       "      <td>0.051499</td>\n",
       "      <td>0.659693</td>\n",
       "      <td>0.360918</td>\n",
       "      <td>0.234620</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>63706</td>\n",
       "      <td>0.824373</td>\n",
       "      <td>0.175627</td>\n",
       "      <td>0.794261</td>\n",
       "      <td>0.288035</td>\n",
       "      <td>0.694187</td>\n",
       "      <td>0.217944</td>\n",
       "      <td>0.118450</td>\n",
       "      <td>0.674203</td>\n",
       "      <td>0.372680</td>\n",
       "      <td>0.050856</td>\n",
       "      <td>0.684787</td>\n",
       "      <td>0.426556</td>\n",
       "      <td>0.125068</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   patient_id  bowel_healthy  bowel_injury  extravasation_healthy  \\\n",
       "0       48843       0.827933      0.172067               0.817089   \n",
       "1       50046       0.785190      0.214810               0.670741   \n",
       "2       63706       0.824373      0.175627               0.794261   \n",
       "\n",
       "   extravasation_injury  kidney_healthy  kidney_low  kidney_high  \\\n",
       "0              0.256075        0.769357    0.149104     0.104603   \n",
       "1              0.460962        0.778393    0.157351     0.086416   \n",
       "2              0.288035        0.694187    0.217944     0.118450   \n",
       "\n",
       "   liver_healthy  liver_low  liver_high  spleen_healthy  spleen_low  \\\n",
       "0       0.640415   0.341083    0.126377        0.578237    0.546813   \n",
       "1       0.842088   0.153788    0.051499        0.659693    0.360918   \n",
       "2       0.674203   0.372680    0.050856        0.684787    0.426556   \n",
       "\n",
       "   spleen_high  \n",
       "0     0.191272  \n",
       "1     0.234620  \n",
       "2     0.125068  "
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prediction_columns = [\n",
    "    'bowel_healthy', 'bowel_injury',\n",
    "    'extravasation_healthy', 'extravasation_injury',\n",
    "    'kidney_healthy', 'kidney_low', 'kidney_high',\n",
    "    'liver_healthy', 'liver_low', 'liver_high',\n",
    "    'spleen_healthy', 'spleen_low', 'spleen_high'\n",
    "]\n",
    "df_predictions = df_predictions.groupby('patient_id')[prediction_columns].max().reset_index()\n",
    "\n",
    "df_predictions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "74ecb970",
   "metadata": {
    "papermill": {
     "duration": 0.00831,
     "end_time": "2023-10-13T11:12:09.327636",
     "exception": false,
     "start_time": "2023-10-13T11:12:09.319326",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## 7. Submission"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "990e94ee",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-13T11:12:09.346860Z",
     "iopub.status.busy": "2023-10-13T11:12:09.346080Z",
     "iopub.status.idle": "2023-10-13T11:12:09.366906Z",
     "shell.execute_reply": "2023-10-13T11:12:09.365662Z"
    },
    "papermill": {
     "duration": 0.032764,
     "end_time": "2023-10-13T11:12:09.368712",
     "exception": false,
     "start_time": "2023-10-13T11:12:09.335948",
     "status": "completed"
    },
    "tags": []
   },
   "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>patient_id</th>\n",
       "      <th>bowel_healthy</th>\n",
       "      <th>bowel_injury</th>\n",
       "      <th>extravasation_healthy</th>\n",
       "      <th>extravasation_injury</th>\n",
       "      <th>kidney_healthy</th>\n",
       "      <th>kidney_low</th>\n",
       "      <th>kidney_high</th>\n",
       "      <th>liver_healthy</th>\n",
       "      <th>liver_low</th>\n",
       "      <th>liver_high</th>\n",
       "      <th>spleen_healthy</th>\n",
       "      <th>spleen_low</th>\n",
       "      <th>spleen_high</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>48843</td>\n",
       "      <td>0.827933</td>\n",
       "      <td>0.172067</td>\n",
       "      <td>0.817089</td>\n",
       "      <td>0.256075</td>\n",
       "      <td>0.769357</td>\n",
       "      <td>0.149104</td>\n",
       "      <td>0.104603</td>\n",
       "      <td>0.640415</td>\n",
       "      <td>0.341083</td>\n",
       "      <td>0.126377</td>\n",
       "      <td>0.578237</td>\n",
       "      <td>0.546813</td>\n",
       "      <td>0.191272</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>50046</td>\n",
       "      <td>0.785190</td>\n",
       "      <td>0.214810</td>\n",
       "      <td>0.670741</td>\n",
       "      <td>0.460962</td>\n",
       "      <td>0.778393</td>\n",
       "      <td>0.157351</td>\n",
       "      <td>0.086416</td>\n",
       "      <td>0.842088</td>\n",
       "      <td>0.153788</td>\n",
       "      <td>0.051499</td>\n",
       "      <td>0.659693</td>\n",
       "      <td>0.360918</td>\n",
       "      <td>0.234620</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>63706</td>\n",
       "      <td>0.824373</td>\n",
       "      <td>0.175627</td>\n",
       "      <td>0.794261</td>\n",
       "      <td>0.288035</td>\n",
       "      <td>0.694187</td>\n",
       "      <td>0.217944</td>\n",
       "      <td>0.118450</td>\n",
       "      <td>0.674203</td>\n",
       "      <td>0.372680</td>\n",
       "      <td>0.050856</td>\n",
       "      <td>0.684787</td>\n",
       "      <td>0.426556</td>\n",
       "      <td>0.125068</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   patient_id  bowel_healthy  bowel_injury  extravasation_healthy  \\\n",
       "0       48843       0.827933      0.172067               0.817089   \n",
       "1       50046       0.785190      0.214810               0.670741   \n",
       "2       63706       0.824373      0.175627               0.794261   \n",
       "\n",
       "   extravasation_injury  kidney_healthy  kidney_low  kidney_high  \\\n",
       "0              0.256075        0.769357    0.149104     0.104603   \n",
       "1              0.460962        0.778393    0.157351     0.086416   \n",
       "2              0.288035        0.694187    0.217944     0.118450   \n",
       "\n",
       "   liver_healthy  liver_low  liver_high  spleen_healthy  spleen_low  \\\n",
       "0       0.640415   0.341083    0.126377        0.578237    0.546813   \n",
       "1       0.842088   0.153788    0.051499        0.659693    0.360918   \n",
       "2       0.674203   0.372680    0.050856        0.684787    0.426556   \n",
       "\n",
       "   spleen_high  \n",
       "0     0.191272  \n",
       "1     0.234620  \n",
       "2     0.125068  "
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = df[['patient_id']].merge(df_predictions, on='patient_id', how='left')\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "77bc3bc8",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-13T11:12:09.388038Z",
     "iopub.status.busy": "2023-10-13T11:12:09.387265Z",
     "iopub.status.idle": "2023-10-13T11:12:09.394146Z",
     "shell.execute_reply": "2023-10-13T11:12:09.393258Z"
    },
    "papermill": {
     "duration": 0.018035,
     "end_time": "2023-10-13T11:12:09.395804",
     "exception": false,
     "start_time": "2023-10-13T11:12:09.377769",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "df.to_csv('submission.csv', index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c03e3e90",
   "metadata": {
    "papermill": {
     "duration": 0.008468,
     "end_time": "2023-10-13T11:12:09.412871",
     "exception": false,
     "start_time": "2023-10-13T11:12:09.404403",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.12"
  },
  "papermill": {
   "default_parameters": {},
   "duration": 91.538003,
   "end_time": "2023-10-13T11:12:12.993111",
   "environment_variables": {},
   "exception": null,
   "input_path": "__notebook__.ipynb",
   "output_path": "__notebook__.ipynb",
   "parameters": {},
   "start_time": "2023-10-13T11:10:41.455108",
   "version": "2.4.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}