lung_cancer_experiment_2.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/ImagingDataCommons/idc-comppath-reproducibility/blob/main/lung_cancer_experiment_2.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ATBH0iwpkHXP"
      },
      "source": [
        "# Introduction\n",
        "\n",
        "This notebook is part of the publication [**The NCI Imaging Data Commons as a platform for reproducible research in computational pathology**](https://doi.org/10.1016/j.cmpb.2023.107839), which describes two experiments that outline how the Imaging Data Commons (IDC) can be used for reproducible computational pathology research. The two experiments are based on a common use case: the AI-based classification of lung tissue regions into either non-neoplastic (normal), adenocarcinoma (LUAD), or squamous cell carcinoma (LSCC) tissue.\n",
        "The [first experiment](https://github.com/ImagingDataCommons/idc-comppath-reproducibility/blob/main/lung_cancer_experiment_1.ipynb) uses the IDC for a complete development process, including model training and validation on TCGA data. This notebook implements the **second experiment**, in which a pre-trained model from the first experiment is applied to independent data from the CPTAC project. It is self-contained, so it is not required to have a look at the first experiment beforehand.  \n",
        "\n",
        "This notebook is intended to be run with Google Colaboratory. The total runtime is usually less than two hours. There is also a special demo mode where a complete run only takes a few minutes (see below).\n",
        "\n",
        "In summary, this notebook shows:\n",
        "\n",
        "- how to select and access slide microscopy data from the IDC;\n",
        "- how to process slide microscopy images in DICOM format;\n",
        "- how to perform **classification using a pre-trained neural network model** and visualize the results exploiting the IDC platform."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QnnV-cii8TAI"
      },
      "source": [
        "# Manual settings\n",
        "\n",
        "Before the notebook can run automatically some settings have to be configured manually. It is also suggested to copy this notebook in your private Google Drive (by clicking on the respective button in the headline of this notebook), which ensures that changes are saved even when runtimes disconnect."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4k22NtLn20EM"
      },
      "source": [
        "**Step 1: Enable GPU:** This notebook is intended to be run with a GPU. In Google Colaboratory, GPU usage can be enabled via Edit > Notebooks Settings > Hardware accelerator. Since Colaboratory notebooks are assigned arbitrary GPUs, processing times can vary.  During the first steps of the notebook (which do not utilize the GPU) Colaboratory might ask if you want to switch back to a CPU. If so, **please deny** that by closing the notification. The code below checks whether GPU usage has been enabled and which GPU type the Colaboratory instance is equipped with."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fraWMdyw22LZ"
      },
      "outputs": [],
      "source": [
        "gpu_list = !nvidia-smi --list-gpus\n",
        "has_gpu = False if 'failed' in gpu_list[0] else True\n",
        "print(has_gpu, gpu_list)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0kUUV0ovzJNq"
      },
      "source": [
        "**Step 2: Ensure package dependencies:** Run this cell to make sure that the library dependencies are installed in the correct versions. At the end, you are prompted to restart the runtime by clicking on a corresponding button. Please do so, then continue with the next cell."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Y9weWEaezOmg"
      },
      "outputs": [],
      "source": [
        "!pip3 install matplotlib==3.7.1 numpy==1.25.2 pandas==2.0.3\\\n",
        "    Pillow==9.4.0 pydicom==2.3.0 scikit_learn==1.2.2\\\n",
        "    scipy==1.11.4 seaborn==0.13.1 tensorflow==2.15\\\n",
        "    tqdm==4.64.1 wsidicom==0.3.2"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "36JGB67J25MD"
      },
      "source": [
        "**Step 3: Authenticate:** To access IDC resources, you have to authenticate with your Google identity. Follow the instructions produced by the code below to complete the Google authentication process."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xlsCGOghcV2F"
      },
      "outputs": [],
      "source": [
        "from google.colab import auth\n",
        "auth.authenticate_user()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bI7IgqJK2fIp"
      },
      "source": [
        "**Step 4: Specify your Google Cloud Platform project ID**:\n",
        "In order to access image data from the IDC storage in Google Colaboratory you need to have a Google Cloud Platform (GCP) project. This is necessary even though this notebook will run completely **free of cost**. If you don't have one already, you can create your own project by performing the four steps described [here](https://github.com/ImagingDataCommons/IDC-Tutorials/blob/master/notebooks/getting_started/part1_prerequisites.ipynb) in section \"Activate GCP for your account and create a GCP project\". Once you have the google project, set `GC_PROJECT_ID` below to the ID of your GCP project."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "NHV_UoHAODUX"
      },
      "outputs": [],
      "source": [
        "GC_PROJECT_ID = 'idc-pathomics-000'"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SDAIinnCvoCX"
      },
      "source": [
        "**Step 5: Demo mode:** To quickly get an impression of how this notebook works, it can be run in demo mode. Then only a fraction of slides are considered and processing is done at reduced magnification. In demo mode, a complete run of the notebook only takes a few minutes, but at the cost of greatly reduced classification accuracy."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pIntxaBavlzl"
      },
      "outputs": [],
      "source": [
        "DEMO_MODE = False"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Tej3jinL6nLd"
      },
      "source": [
        "**Step 6: Run** the notebook by clicking on **Runtime > Restart and run all**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OOMAXjiJ5TZr"
      },
      "source": [
        "# Utility code\n",
        "\n",
        "Utility functionality for accessing whole-slide images (WSIs) in the IDC and for evaluating results is summarized in the idc_comppath_reproducibility package. The code is available open source and can be re-used for similar use cases. In the cell below, the idc_comppath_reproducibility package is cloned to the current Colaboratory instance."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7w2gWiBuZMkC"
      },
      "outputs": [],
      "source": [
        "!git clone -b main https://github.com/ImagingDataCommons/idc-comppath-reproducibility.git"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m-3X2FEZZg9M"
      },
      "source": [
        "# Imports"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "id": "PWDMlEUXODUc",
        "jupyter": {
          "outputs_hidden": true
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "import os\n",
        "import time\n",
        "from datetime import timedelta\n",
        "import random\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import tensorflow as tf\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "sns.set_theme()\n",
        "from PIL import Image\n",
        "from tqdm.auto import tqdm\n",
        "from tensorflow.keras.models import load_model\n",
        "\n",
        "import sys\n",
        "sys.path.append('./idc-comppath-reproducibility')\n",
        "from idc_comppath_reproducibility.utils import create_slides_metadata, get_stratified_subsample\n",
        "from idc_comppath_reproducibility.wsi import WSI\n",
        "from idc_comppath_reproducibility.batch_iterator import BatchIterator\n",
        "from idc_comppath_reproducibility.predictions import Predictions\n",
        "from idc_comppath_reproducibility.roc import perform_tile_based_roc_analysis, perform_slide_based_roc_analysis, summarize_roc_values\n",
        "from idc_comppath_reproducibility.heatmap import select_slides_for_heatmap, plot_colormap_legend, generate_heatmap\n",
        "from idc_comppath_reproducibility.global_variables import CLASS_LABEL_TO_INDEX_MAP, NUM_CLASSES"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2pwRbyRr61R6"
      },
      "source": [
        "# Global constants"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9AAmt_4E8umM"
      },
      "outputs": [],
      "source": [
        "if DEMO_MODE:\n",
        "    NUM_SLIDES = 45\n",
        "    PIXEL_SPACING = 0.002 # in mm/px\n",
        "    TILE_SIZE = 128 # in px\n",
        "    MODEL_URL = 'https://api.github.com/repos/ImagingDataCommons/idc-comppath-reproducibility/releases/assets/98547212'\n",
        "    MODEL_FILE_PATH = './tcga_pretrained_model128.zip'\n",
        "else:\n",
        "    NUM_SLIDES = 300\n",
        "    PIXEL_SPACING = 0.001 # in mm/px\n",
        "    TILE_SIZE = 256 # in px\n",
        "    MODEL_URL = 'https://api.github.com/repos/ImagingDataCommons/idc-comppath-reproducibility/releases/assets/98547238'\n",
        "    MODEL_FILE_PATH = './tcga_pretrained_model256.zip'"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Px14ELwJXj9q"
      },
      "source": [
        "# Enable determinism\n",
        "\n",
        "To enable reproducibility we aim to make all operations in this notebook deterministic. An important part to this is setting random seeds and enabling TensorFlow operations to be deterministic."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "wlRZ3mjuXkIB"
      },
      "outputs": [],
      "source": [
        "random.seed(0)\n",
        "np.random.seed(0)\n",
        "tf.random.set_seed(0)\n",
        "tf.config.experimental.enable_op_determinism()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZGvZhkpyODUc"
      },
      "source": [
        "# Data selection\n",
        "\n",
        "For most computational pathology experiments, the first step is to select a cohort of WSIs by filtering for the desired metadata attributes.\n",
        "\n",
        "The IDC uses the DICOM standard for data representation. Here, a WSI corresponds to a series of DICOM image objects, each representing the slide at a different resolution. Each DICOM object is stored as a separate DICOM file. Cohort selection is done best by executing BigQuery SQL statements against the **bigquery-public-data.idc_v11.dicom_all** table, which lists all available DICOM files (rows) with the corresponding metadata atrributes (columns).\n",
        "\n",
        "The following BigQuery SQL statement retrieves all DICOM files (including their metadata) in the CPTAC-LUAD and CPTAC-LSCC collections that are of interest for our use case."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "-5ncUeQKK7f0"
      },
      "outputs": [],
      "source": [
        "start_time = time.time() # measure time of notebook execution"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9Z97BAE9Dmeh"
      },
      "outputs": [],
      "source": [
        "%%bigquery bq_results_df --project=$GC_PROJECT_ID\n",
        "\n",
        "-- First, create subqueries to facilitate data selection from the dicom_all table.\n",
        "-- Several DICOM attributes are renamed to be more intuitive (e.g. 'TotalPixelMatrixColumns' is renamed to 'width').\n",
        "WITH\n",
        "  -- The 'sm_images' subquery summarizes basic metadata of slide microscopy images (SM).\n",
        "  sm_images AS (\n",
        "    SELECT\n",
        "      -- digital_slide_id: unique numeric identifier of a digital slide, i.e., a digital image of a physical slide.\n",
        "      SeriesInstanceUID AS digital_slide_id,\n",
        "      -- case_id: unique numeric identifier of the study in the context of which the ditial slide was created.\n",
        "      StudyInstanceUID AS case_id,\n",
        "      -- physical_slide_id: unique numeric identifier of the physical slide as prepared in the wet lab.\n",
        "      ContainerIdentifier AS physical_slide_id,\n",
        "      -- patient_id: unique numeric identifier of the patient from whose tissue the physical slide was obtained.\n",
        "      PatientID AS patient_id,\n",
        "      -- width: image width in pixels.\n",
        "      TotalPixelMatrixColumns AS width,\n",
        "      -- height: image height in pixels.\n",
        "      TotalPixelMatrixRows AS height,\n",
        "      -- collection_id: numeric or character sequence describing the dataset the physical slide is part of.\n",
        "      collection_id,\n",
        "      -- crdc_instance_uuid: universally unique identifier of the DICOM instance.\n",
        "      crdc_instance_uuid,\n",
        "      -- gcs_url: GCS URL needed to access the DICOM file\n",
        "      gcs_url,\n",
        "      -- pixel_spacing: image pixel spacing in mm/px\n",
        "      CAST(SharedFunctionalGroupsSequence[SAFE_OFFSET(0)].\n",
        "              PixelMeasuresSequence[SAFE_OFFSET(0)].\n",
        "              PixelSpacing[SAFE_OFFSET(0)] AS FLOAT64) AS pixel_spacing,\n",
        "      -- compression: compression type\n",
        "      CASE TransferSyntaxUID\n",
        "          WHEN '1.2.840.10008.1.2.4.50' THEN 'jpeg'\n",
        "          WHEN '1.2.840.10008.1.2.4.91' THEN 'jpeg2000'\n",
        "          ELSE 'other'\n",
        "      END AS compression,\n",
        "    FROM\n",
        "      -- we are using version 11 of the IDC data\n",
        "      bigquery-public-data.idc_v11.dicom_all\n",
        "    WHERE\n",
        "      -- limit query to slide microscopy images (SM) excluding non-volume images like label images\n",
        "      Modality = 'SM' AND ImageType[OFFSET(2)] = 'VOLUME'\n",
        "  ),\n",
        "  -- The 'tissue_types' subquery indicates whether a slides contains normal, tumor or other tisse.\n",
        "  tissue_types AS (\n",
        "    SELECT DISTINCT *\n",
        "    FROM (\n",
        "      SELECT\n",
        "        SeriesInstanceUID AS digital_slide_id,\n",
        "        CASE steps_unnested2.CodeValue\n",
        "            WHEN '17621005' THEN 'normal' -- meaning: 'Normal' (i.e., non neoplastic)\n",
        "            WHEN '86049000' THEN 'tumor' -- meaning: 'Neoplasm, Primary'\n",
        "            ELSE 'other' -- meaning: 'Neoplasm, Metastatic'\n",
        "        END AS tissue_type\n",
        "      FROM\n",
        "        bigquery-public-data.idc_v11.dicom_all\n",
        "        CROSS JOIN\n",
        "          UNNEST (SpecimenDescriptionSequence[SAFE_OFFSET(0)].PrimaryAnatomicStructureSequence) AS steps_unnested1\n",
        "        CROSS JOIN\n",
        "          UNNEST (steps_unnested1.PrimaryAnatomicStructureModifierSequence) AS steps_unnested2\n",
        "    )\n",
        "  )\n",
        "\n",
        "\n",
        "-- Select all DICOM files from the CPTAC-LUAD / CPTAC-LUSC datasets that are JPEG/JPEG2000 compressed and\n",
        "-- contain normal or tumor tissue. We do not need to restrict the query to frozen tissue sections since all\n",
        "-- slides in CPTAC show frozen tissue. The results are ordered by their crdc_instance_uuid to ensure\n",
        "-- deterministic output order which is important for reproducibility.\n",
        "SELECT\n",
        "  a.*,\n",
        "  b.tissue_type,\n",
        "  (REPLACE (REPLACE(collection_id, 'cptac_luad', 'luad'), 'cptac_lscc', 'lscc')) AS cancer_subtype\n",
        "FROM\n",
        "  sm_images AS a\n",
        "  JOIN tissue_types AS b ON b.digital_slide_id=a.digital_slide_id\n",
        "WHERE\n",
        "  (a.collection_id = 'cptac_luad' OR a.collection_id = 'cptac_lscc')\n",
        "  AND a.compression != 'other'\n",
        "  AND (b.tissue_type = 'normal' OR b.tissue_type = 'tumor')\n",
        "ORDER BY crdc_instance_uuid"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "if677aVrqBl5"
      },
      "source": [
        "The metadata are reorganized into a dataframe containing one row per WSI. Then, a stratified subsample of the data is selected for the analysis."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Cj2Rs6Jt_tlW"
      },
      "outputs": [],
      "source": [
        "slides_metadata = create_slides_metadata(bq_results_df)\n",
        "slides_metadata = get_stratified_subsample(slides_metadata, NUM_SLIDES, random_state=0)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1IhrfoqyODUh"
      },
      "outputs": [],
      "source": [
        "# Assert uniqueness of physical slide ID values\n",
        "assert(slides_metadata['digital_slide_id'].is_unique)\n",
        "\n",
        "# Assert validity of class labels\n",
        "assert set(slides_metadata['tissue_type'].unique()) == set(['normal', 'tumor'])\n",
        "assert set(slides_metadata['cancer_subtype'].unique()) == set(['luad', 'lscc'])\n",
        "\n",
        "display(slides_metadata.head())\n",
        "print('Total number of slides: ', len(slides_metadata))\n",
        "nr_slides = slides_metadata.groupby('cancer_subtype').size()\n",
        "nr_patients = slides_metadata.drop_duplicates('patient_id').groupby('cancer_subtype').size()\n",
        "print('--> %d slides from %d LUAD patients' % (nr_slides.get('luad') or 0, nr_patients.get('luad') or 0))\n",
        "print('--> %d slides from %d LSCC patients' % (nr_slides.get('lscc') or 0, nr_patients.get('lscc') or 0))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IM5lb-qLODUh"
      },
      "source": [
        "Any slide can also be viewed and explored in detail using the IDC viewer."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "E_eQc54DODUi"
      },
      "outputs": [],
      "source": [
        "def get_idc_viewer_url(study_UID):\n",
        "    return \"https://viewer.imaging.datacommons.cancer.gov/slim/studies/\" + study_UID\n",
        "\n",
        "print(get_idc_viewer_url(slides_metadata['case_id'].iloc[0]))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0JT6sXgf7RFT"
      },
      "source": [
        "# Prediction\n",
        "\n",
        "The TCGA-trained model from Experiment 1 is available as Github release asset and can be retrieved via curl.\n",
        "\n",
        "**Prediction** is then performed in a single sequential pass over the data. Each DICOM file is accessed one after another, tiled and a prediction is made for each tile showing tissue (as determined by the `is_foreground` function). No data is stored on the VM during this process."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0mKzasrghwLa"
      },
      "source": [
        "![fig_ml_method_part.jpg](data:image/jpeg;base64,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)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "I-GCRB2LSGgx"
      },
      "outputs": [],
      "source": [
        "!curl --progress-bar -LJO \\\n",
        "   -H \"Accept: application/octet-stream\" \\\n",
        "   $MODEL_URL\n",
        "\n",
        "!unzip -n $MODEL_FILE_PATH"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "atrZ9kPbODUo"
      },
      "outputs": [],
      "source": [
        "# Load model\n",
        "tcga_model_dir = os.path.splitext(MODEL_FILE_PATH)[0]\n",
        "model = load_model(tcga_model_dir, compile=False)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fxm0hfOuODUp"
      },
      "outputs": [],
      "source": [
        "def is_foreground(tile: Image.Image) -> bool:\n",
        "    \"\"\"\n",
        "    Function to determine if a tile shows mainly tissue (foreground) or background.\n",
        "    Returns True if tile shows <= 50% background and False otherwise.\n",
        "    \"\"\"\n",
        "    grey = tile.convert(mode='L')\n",
        "    thresholded = grey.point(lambda x: 0 if x < 220 else 1, mode='F')\n",
        "    avg_bkg = np.average(np.array(thresholded))\n",
        "    return avg_bkg <= 0.5\n",
        "\n",
        "def predict(model, slides_metadata: pd.DataFrame, coverage: float) -> Predictions:\n",
        "    \"\"\"\n",
        "    Function to perform inference for a certain set of slides using a given pretrained model.\n",
        "    Returns per-tile predictions as obtained from the model inference plus necessary metadata, e.g.,\n",
        "    the tile's position in the WSI.\n",
        "    \"\"\"\n",
        "    image_ids = []\n",
        "    tile_positions = []\n",
        "    reference_class_indices = []\n",
        "    predicted_class_probabilities = []\n",
        "\n",
        "    for index, slide_metadata in tqdm(slides_metadata.iterrows(), total=slides_metadata.shape[0]):\n",
        "        wsi = WSI(slide_metadata)\n",
        "        image_id = slide_metadata['digital_slide_id']\n",
        "        reference_class_index = CLASS_LABEL_TO_INDEX_MAP[slide_metadata['reference_class_label']]\n",
        "        batch_iterator = BatchIterator(wsi, TILE_SIZE, PIXEL_SPACING, is_foreground,\n",
        "                                    batch_size=32, coverage=coverage)\n",
        "\n",
        "        for (batch_images, batch_tile_positions) in batch_iterator:\n",
        "            batch_predicted_class_probabilities = model(batch_images).numpy()\n",
        "            image_ids.extend([image_id] * len(batch_tile_positions))\n",
        "            tile_positions.extend(batch_tile_positions)\n",
        "            reference_class_indices.extend([reference_class_index] * len(batch_tile_positions))\n",
        "            predicted_class_probabilities.extend(batch_predicted_class_probabilities.tolist())\n",
        "\n",
        "    dictionary = {'image_id': image_ids, 'tile_position': tile_positions,\n",
        "            'reference_class_index': reference_class_indices,\n",
        "            'predicted_class_index': [p.index(max(p)) for p in predicted_class_probabilities],\n",
        "            'predicted_class_probabilities': predicted_class_probabilities}\n",
        "    return Predictions(pd.DataFrame(dictionary))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ISd_lOuH7XJ7"
      },
      "outputs": [],
      "source": [
        "# Perform prediction\n",
        "predictions = predict(model, slides_metadata, coverage=0.1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fefF7oTesO3P"
      },
      "source": [
        "# Evaluation\n",
        "\n",
        "The performance of this model is in the following evaluated quantitatively by means of ROC curves and observed qualitatively using heatmap visualization."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bv6tkmli8umS"
      },
      "source": [
        "**A ROC analysis** (one-vs-rest) for each of the three classes (normal, LUAD, LSCC) is performed on **tile-level** (tile-based ROC) and on **slide-level** (slide-based ROC). For the slide-level analysis the probabilities for each slide are aggregated by averaging the probabilities of the corresponding tiles. Respective Area under the ROC curve (AUC) values are reported in the table below. ROC curves are also visualized below."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7kQBE9XSODUp"
      },
      "outputs": [],
      "source": [
        "tile_roc_analysis = perform_tile_based_roc_analysis(predictions)\n",
        "slide_roc_analysis = perform_slide_based_roc_analysis(predictions)\n",
        "display(summarize_roc_values(tile_roc_analysis, slide_roc_analysis))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "uwLXc2De2fiE"
      },
      "outputs": [],
      "source": [
        "fig, axes = plt.subplots(1,2, figsize=(10,4))\n",
        "tile_roc_analysis.plot(axes[0])\n",
        "slide_roc_analysis.plot(axes[1])\n",
        "plt.show()\n",
        "plt.close()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_b7z8kL-8umT"
      },
      "source": [
        "**Heatmaps** are generated for visually inspecting the network's predictions for three exemplary slides. The color of each tile in the heatmap corresponds to the class assigned by our model. The hue indicates how confident the network is in this classification. Hereby, a darker hue corresponds to higher confidence. The respective orginal WSI is shown as thumbnail image next to the heatmap."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "aer0qDMhODUq"
      },
      "outputs": [],
      "source": [
        "hm_slides_metadata = select_slides_for_heatmap(predictions, slides_metadata)\n",
        "# Re-predict selected slides with 100% coverage of tiles for heatmap visualization\n",
        "hm_predictions = predict(model, hm_slides_metadata, coverage=1.0)\n",
        "\n",
        "plot_colormap_legend()\n",
        "fig, axes = plt.subplots(len(hm_slides_metadata.index), 2, figsize=(10, 9))\n",
        "for i, (image_id, slide_metadata) in enumerate(hm_slides_metadata.iterrows()):\n",
        "    wsi = WSI(slide_metadata)\n",
        "    thumbnail = wsi.get_thumbnail()\n",
        "    true_tissue_type = slide_metadata['reference_class_label']\n",
        "    heatmap = generate_heatmap(hm_predictions, image_id)\n",
        "    axes[i,0].imshow(heatmap)\n",
        "    axes[i,1].imshow(thumbnail)\n",
        "    axes[i,1].set_title(true_tissue_type)\n",
        "    axes[i,0].axis('off')\n",
        "    axes[i,1].axis('off')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "yquSA49Dk40I"
      },
      "outputs": [],
      "source": [
        "elapsed_time = time.time() - start_time\n",
        "print('Notebook execution time: {}'.format(timedelta(seconds=elapsed_time)))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FTtmmJ1tk7ut"
      },
      "source": [
        "---\n",
        "*The results shown here are in whole or part based upon data generated by the The Cancer Genome Atlas (TCGA) Research Network and the National Cancer Institute Clinical Proteomic Tumor Analysis Consortium (CPTAC).*\n",
        "\n",
        "*Copyright 2023 Fraunhofer MEVIS and Harvard Medical School. Redistribution and use of this notebook, with or without modification, are permitted under the terms of the [3-Clause BSD License](https://opensource.org/licenses/BSD-3-Clause).*"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "provenance": [],
      "toc_visible": true,
      "include_colab_link": true
    },
    "environment": {
      "kernel": "python3",
      "name": "tf2-gpu.2-8.m100",
      "type": "gcloud",
      "uri": "gcr.io/deeplearning-platform-release/tf2-gpu.2-8:m100"
    },
    "gpuClass": "standard",
    "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.7.12"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}