model_performance_aimi2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Model Performance\n",
    "\n",
    "\n",
    "## Prerequisites\n",
    "Install python packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%capture\n",
    "%pip install pandas pydicom pydicom-seg scikit-learn seaborn requests\n",
    "%pip install segmentationmetrics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import required python packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "\n",
    "import io\n",
    "import zipfile\n",
    "from pathlib import Path\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import pydicom\n",
    "import pydicom_seg\n",
    "import requests\n",
    "import scipy.stats as stats\n",
    "import seaborn as sns\n",
    "import segmentationmetrics as sm\n",
    "import SimpleITK as sitk\n",
    "from segmentationmetrics.surface_distance import compute_surface_dice_at_tolerance\n",
    "from tqdm.auto import tqdm\n",
    "\n",
    "sns.set_theme(style=\"whitegrid\")\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt_colors = {\n",
    "    \"ne2\": \"#5eceb0\",\n",
    "    \"rad1\": \"#9e70e1\",\n",
    "    \"tp\": \"k\",\n",
    "    \"fp\": \"b\",\n",
    "    \"fn\": \"r\",\n",
    "}\n",
    "\n",
    "revewer_cmap = sns.color_palette([plt_colors[\"ne2\"], plt_colors[\"rad1\"]])\n",
    "vol_cmap = sns.color_palette([plt_colors[\"fp\"], plt_colors[\"fn\"]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Download the segmentation results from zenodo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "qa_dir = Path(\"qa-results\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def download_inference(\n",
    "    extract_dir=\"qa-results\", record=\"13244892\", filename=\"prostate-mr.zip\"\n",
    "):\n",
    "    url = f\"https://zenodo.org/record/{record}/files/{filename}\"\n",
    "    # download the zip file and extract it\n",
    "    r = requests.get(url)\n",
    "    z = zipfile.ZipFile(io.BytesIO(r.content))\n",
    "    z.extractall(extract_dir)\n",
    "\n",
    "\n",
    "if not qa_dir.exists() or not (qa_dir / \"ai-segmentations-dcm\").exists():\n",
    "    download_inference(qa_dir)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_dcm_seg(seg_path: Path, label=1):\n",
    "    dcm = pydicom.dcmread(str(seg_path))\n",
    "    reader = pydicom_seg.SegmentReader()\n",
    "    result = reader.read(dcm)\n",
    "    if label in result.available_segments:\n",
    "        image = result.segment_image(label)\n",
    "    else:\n",
    "        # create an empty image\n",
    "        tmp_img = result.segment_image(list(result.available_segments)[0])\n",
    "        tmp_arr = sitk.GetArrayFromImage(tmp_img)\n",
    "        image = sitk.GetImageFromArray(np.zeros_like(tmp_arr))\n",
    "        image.CopyInformation(tmp_img)\n",
    "    image = sitk.Cast(image, sitk.sitkUInt8)\n",
    "    return image\n",
    "\n",
    "\n",
    "def load_nii_seg(seg_path: Path, label=1):\n",
    "    img = sitk.ReadImage(str(seg_path))\n",
    "    img = sitk.Cast(img == label, sitk.sitkUInt8)\n",
    "    return img\n",
    "\n",
    "\n",
    "def load_seg(seg_path: Path, label=1):\n",
    "    if seg_path.suffix == \".dcm\":\n",
    "        return load_dcm_seg(seg_path, label)\n",
    "    else:\n",
    "        return load_nii_seg(seg_path, label)\n",
    "\n",
    "\n",
    "def resize_label(img: sitk.Image, ref_img: sitk.Image, interp=sitk.sitkNearestNeighbor):\n",
    "    resampler = sitk.ResampleImageFilter()\n",
    "    resampler.SetReferenceImage(ref_img)\n",
    "    resampler.SetInterpolator(interp)\n",
    "    resampler.SetDefaultPixelValue(0)\n",
    "    resampled_img = resampler.Execute(img)\n",
    "    return resampled_img\n",
    "\n",
    "\n",
    "def calc_metrics_for_label(\n",
    "    ai_seg_file,\n",
    "    qa_seg_file,\n",
    "    series_uid,\n",
    "    label_value=1,\n",
    "    version=\"aimiv2\",\n",
    "    label_suffix=\"\",\n",
    "    nsd_tol=7,\n",
    "):\n",
    "    ai_img = load_seg(ai_seg_file, label_value)\n",
    "    qa_img = load_seg(qa_seg_file, label_value)\n",
    "    qa_img = resize_label(qa_img, ai_img)  # match the size of the ai_img\n",
    "    ai_arr = sitk.GetArrayFromImage(ai_img)\n",
    "    qa_arr = sitk.GetArrayFromImage(qa_img)\n",
    "    spacing = ai_img.GetSpacing()[::-1]  # numpy is reversed dimensions from sitk\n",
    "\n",
    "    qa_img = resize_label(qa_img, ai_img)  # match the size of the ai_img\n",
    "    m = sm.SegmentationMetrics(ai_arr, qa_arr, spacing)\n",
    "    metrics = {\n",
    "        \"dice\": m.dice,\n",
    "        \"hausdorff_distance_95\": m.hausdorff_distance,\n",
    "        \"mean_surface_distance\": m.mean_surface_distance,\n",
    "        \"normalized_surface_distance\": compute_surface_dice_at_tolerance(\n",
    "            m._surface_dist, nsd_tol\n",
    "        ),\n",
    "        \"SeriesUID\": series_uid,  # from medical segmentation decathlon\n",
    "        \"label\": label_value,\n",
    "        \"version\": version,\n",
    "        \"normalized_surface_distance_tolerance\": nsd_tol,\n",
    "    }\n",
    "\n",
    "    if label_suffix:\n",
    "        metrics = {f\"{k}_{label_suffix}\": v for k, v in metrics.items()}\n",
    "    return metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load the CSV file\n",
    "df = pd.read_csv(Path(\"qa-results/qa-results.csv\"))\n",
    "qa_df = df[df.Validation]\n",
    "\n",
    "# Paths for aimiv1, aimiv2, and qa\n",
    "ai_path = Path(\"qa-results/ai-segmentations-dcm\")\n",
    "qa_path = Path(\"qa-results/qa-segmentations-dcm\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# labels and tolerances\n",
    "label_names = {1: \"Prostate\"}\n",
    "nsd_tolerances = {\n",
    "    1: 4,\n",
    "}  # per label tolerances in mm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# add label names\n",
    "ds = pydicom.dcmread(ai_path / df.AISegmentation.iloc[0])\n",
    "result = pydicom_seg.SegmentReader().read(ds)\n",
    "label_names_from_dcm = {\n",
    "    k: v[\"SegmentDescription\"].value for k, v in result.segment_infos.items()\n",
    "}\n",
    "assert (\n",
    "    label_names_from_dcm == label_names\n",
    "), \"labels in the dcm file do not match expected labels\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "393e583f70b742918c93451015c2862d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/149 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Initialize lists for metrics\n",
    "metrics = []\n",
    "\n",
    "# Iterate over all QA cases\n",
    "for _, row in tqdm(qa_df.iterrows(), total=len(qa_df)):\n",
    "    ai_file = ai_path / row.AISegmentation\n",
    "    if not pd.isna(row.CorrectedSegmentation):\n",
    "        qa_file = qa_path / row.CorrectedSegmentation\n",
    "    else:\n",
    "        # reviewer had no corrections, use AI segmentation as QA\n",
    "        qa_file = ai_file\n",
    "\n",
    "    assert ai_file.exists(), f\"AI segmentation not found for {row.AISegmentation}\"\n",
    "    assert qa_file.exists(), f\"QA segmentation not found for {row.QASegmentation}\"\n",
    "\n",
    "    version = \"aimiv1\" if row.AimiProjectYear == 2023 else \"aimiv2\"\n",
    "    metrics.append(\n",
    "        calc_metrics_for_label(\n",
    "            ai_file,\n",
    "            qa_file,\n",
    "            row.SeriesInstanceUID,\n",
    "            version=version,\n",
    "            label_value=1,\n",
    "            nsd_tol=4,\n",
    "        )\n",
    "    )\n",
    "\n",
    "metrics_df = pd.DataFrame(metrics)\n",
    "\n",
    "# Replace infinite values with NaN and drop NaN values\n",
    "metrics_df = metrics_df.replace([np.inf, -np.inf], np.nan).dropna()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# add label names\n",
    "ds = pydicom.dcmread(ai_path / df.AISegmentation.iloc[0])\n",
    "result = pydicom_seg.SegmentReader().read(ds)\n",
    "label_names = {\n",
    "    k: v[\"SegmentDescription\"].value for k, v in result.segment_infos.items()\n",
    "}\n",
    "assert len(label_names) == 1, \"Only 1 labels are expected\"\n",
    "\n",
    "# update metrics_df with label names column\n",
    "metrics_df[\"label_name\"] = metrics_df[\"label\"].map(label_names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "metrics_df.to_csv(\"qa-metrics.csv\", index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead tr th {\n",
       "        text-align: left;\n",
       "    }\n",
       "\n",
       "    .dataframe thead tr:last-of-type th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th colspan=\"2\" halign=\"left\">dice</th>\n",
       "      <th colspan=\"2\" halign=\"left\">hausdorff_distance_95</th>\n",
       "      <th colspan=\"2\" halign=\"left\">mean_surface_distance</th>\n",
       "      <th colspan=\"2\" halign=\"left\">normalized_surface_distance</th>\n",
       "      <th>normalized_surface_distance_tolerance</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th>mean</th>\n",
       "      <th>std</th>\n",
       "      <th>mean</th>\n",
       "      <th>std</th>\n",
       "      <th>mean</th>\n",
       "      <th>std</th>\n",
       "      <th>mean</th>\n",
       "      <th>std</th>\n",
       "      <th>first</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>label_name</th>\n",
       "      <th>version</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">Prostate</th>\n",
       "      <th>aimiv1</th>\n",
       "      <td>1.00</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0.00</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.00</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>aimiv2</th>\n",
       "      <td>0.99</td>\n",
       "      <td>0.02</td>\n",
       "      <td>1.07</td>\n",
       "      <td>1.24</td>\n",
       "      <td>0.15</td>\n",
       "      <td>0.18</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.01</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                    dice       hausdorff_distance_95        \\\n",
       "                    mean   std                  mean   std   \n",
       "label_name version                                           \n",
       "Prostate   aimiv1   1.00  0.00                  0.00  0.00   \n",
       "           aimiv2   0.99  0.02                  1.07  1.24   \n",
       "\n",
       "                   mean_surface_distance       normalized_surface_distance  \\\n",
       "                                    mean   std                        mean   \n",
       "label_name version                                                           \n",
       "Prostate   aimiv1                   0.00  0.00                         1.0   \n",
       "           aimiv2                   0.15  0.18                         1.0   \n",
       "\n",
       "                         normalized_surface_distance_tolerance  \n",
       "                     std                                 first  \n",
       "label_name version                                              \n",
       "Prostate   aimiv1   0.00                                     4  \n",
       "           aimiv2   0.01                                     4  "
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "aggregated_df = (\n",
    "    metrics_df.groupby([\"label_name\", \"version\"])\n",
    "    .agg(\n",
    "        {\n",
    "            \"dice\": [\"mean\", \"std\"],\n",
    "            \"hausdorff_distance_95\": [\"mean\", \"std\"],\n",
    "            \"mean_surface_distance\": [\"mean\", \"std\"],\n",
    "            \"normalized_surface_distance\": [\"mean\", \"std\"],\n",
    "            \"normalized_surface_distance_tolerance\": \"first\",\n",
    "        }\n",
    "    )\n",
    "    .round(2)\n",
    ")\n",
    "\n",
    "aggregated_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# create seaborn categorical boxplot for each metric, by label and version\n",
    "for metric in [\n",
    "    \"dice\",\n",
    "    \"hausdorff_distance_95\",\n",
    "    \"mean_surface_distance\",\n",
    "    \"normalized_surface_distance\",\n",
    "]:\n",
    "    fig, ax = plt.subplots(figsize=(12, 6))\n",
    "    sns.boxplot(\n",
    "        x=\"label_name\",\n",
    "        y=metric,\n",
    "        hue=\"version\",\n",
    "        data=metrics_df,\n",
    "        palette=revewer_cmap,\n",
    "        ax=ax,\n",
    "    )\n",
    "    if metric == \"normalized_surface_distance\":\n",
    "        # set x axis labels to be 'label name (tolerance)'\n",
    "        labels = [\n",
    "            f\"{label_name}\\n({nsd_tolerances[label_value]}mm)\"\n",
    "            for label_value, label_name in label_names.items()\n",
    "        ]\n",
    "        ax.set_xticklabels(labels)\n",
    "        ax.set_xlabel(\"Label (Tolerance)\")\n",
    "    else:\n",
    "        ax.set_xlabel(\"Label\")\n",
    "\n",
    "    ax.set_title(f\"{metric} by label and version\")\n",
    "    ax.set_ylabel(metric)\n",
    "    plt.xticks(rotation=45)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}