Skinet_Inference_Tool.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X0B38hFOziWw"
      },
      "source": [
        "# Skinet - Segmentation of the Kidney through a Neural nETwork - MEST-C Inference Tool\n",
        "For more details, visit https://github.com/SkinetTeam/Skinet-MEST-C\n",
        "\n",
        "ℹ️ **Statistics used to compute MEST-C Score are only available through ```chain``` inference mode !**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GYPfsdEKziWy"
      },
      "source": [
        "## Google Colab Only"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iC1rR8vf_sUa"
      },
      "source": [
        "Executes only if using this notebook on Google Colab (getting files needed). Errors might appear, do not worry about them. Check that files you wanted to retrieve are in the ```Files``` tab on the left, represented by this icon : ![image.png](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABYAAAAUCAYAAACJfM0wAAAArklEQVQ4Ee2TQQrEIAxFe1UP4Va3ehHXrr2Da72Da9cZ/kDKiKFTGVoYaOBTsfGlsT8bXRTbRVy6D9xao1rrpN77UnPDFwOqlBJlraUV+ACOMYpQLqa1Ju+9qBDC0JEINsaQc+60kI/iOecdLoJLKXvCmQXyAUbHHA+Yb2IcEHbFc8dvu8A2KaVppKUx5z3kH9rtaKRx8JtwnmPwMTbxEj9vVZ9QcCYwV/z1+X/gFzQcPQPUGNT9AAAAAElFTkSuQmCC)\n",
        "\n",
        "As Google Colab does not refresh the files list quickly, you may want to refresh it manually before checking if the file you are looking for is here, use the following icon to refresh the files list: ![image.png](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAB0AAAAcCAYAAACdz7SqAAABJklEQVRIDe2VoQ6DQAyG96poLFiwoLE8BBqLRqPRaHSXj6RLcyvLlrsFQ5MGrsf69f7e3R5ygT0uYMoN/avqrrzzPEtd15Jlmet930cV5UKLonBhtogYsAu1yWPey7IUVAvtr1AKpk2hfYSGH/86VpXC393QY/eGsqQaJ5N3XVcZhkHatpWu62QcR9n3XZqmOdwWnAQKQDdNVVWCM+bI4ICtRUO3bTsAgFgtRoxC8jw/5pJDkZRVAVLTmK4+OdTrGQUsy/JyVUCLipbXg2rys6cL/ebCRzpWw8Ufyqsw5pmjv9ZcKJe07kDti/fkeCAdc9yxtq/E9e/RxoG7UFvVN+/2yFAIrkVO0/SWIgmUrKwGuPYY2ZHXs2RQL/lZ7IaeKZMkfom8T2P1lR7yJQlHAAAAAElFTkSuQmCC)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ea3tNTXq_sUe"
      },
      "source": [
        "For better performance, enable GPU under hardware accelerator: ```Runtime``` > ```Change runtime type``` or  ```Edit``` > ```Notebook Settings``` and then ```'Hardware Accelerator' dropdown list``` > ```GPU```\n",
        "\n",
        "![image.png](data:image/png;base64,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)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Olya1WSyziW0",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [],
      "source": [
        "import re\n",
        "import sys\n",
        "import os\n",
        "IN_COLAB = 'google.colab' in sys.modules\n",
        "max_px = str(pow(2, 32))\n",
        "if IN_COLAB:\n",
        "    !export TF_CPP_MIN_LOG_LEVEL=3\n",
        "    !export OPENCV_IO_MAX_IMAGE_PIXELS=$max_px\n",
        "    !export CV_IO_MAX_IMAGE_PIXELS=$max_px\n",
        "    print(\"Executing in Google Colab\")\n",
        "    import shutil\n",
        "    shutil.rmtree('sample_data/', ignore_errors=True)\n",
        "else:\n",
        "    os.environ['TF_CPP_MIN_LOG_LEVEL']='3'\n",
        "    os.environ['OPENCV_IO_MAX_IMAGE_PIXELS']=max_px\n",
        "    os.environ['CV_IO_MAX_IMAGE_PIXELS']=max_px\n",
        "    print(\"Executing locally\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FM0SSwW8ziXB"
      },
      "source": [
        "### Retrieving needed files\n",
        "\n",
        "You can use this cell to update the files that have been downloaded during the same session and that have been updated on GitHub"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "sOIgtnOOziXC"
      },
      "outputs": [],
      "source": [
        "if IN_COLAB:\n",
        "    GITHUB_BRANCH = \"v1.0\"\n",
        "    GITHUB_REPO = f\"https://raw.githubusercontent.com/SkinetTeam/Skinet-MEST-C/{GITHUB_BRANCH}/\"\n",
        "    files = ['mrcnn/TensorflowDetector.py', 'mrcnn/utils.py', 'mrcnn/visualize.py', \n",
        "             'mrcnn/post_processing.py', 'mrcnn/Config.py', 'mrcnn/statistics.py', \n",
        "             'mrcnn/datasetDivider.py', 'nephrology.py', 'common_utils.py', \"skinet.json\"]\n",
        "    for fileToDownload in files:\n",
        "        url = GITHUB_REPO + fileToDownload\n",
        "        !wget -qN $url\n",
        "        if '/' in fileToDownload:\n",
        "            os.makedirs(os.path.dirname(fileToDownload), exist_ok=True)\n",
        "            fileName = os.path.basename(fileToDownload)\n",
        "            !mv $fileName $fileToDownload"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N-AwLzVYziXH"
      },
      "source": [
        "### Connecting to Google Drive"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qXap_YGcziXH"
      },
      "source": [
        "The first time this cell is executed, a link should appear, asking you to accept to give access to files of a google account. \n",
        "1.   **Follow the link**;\n",
        "2.   **Choose the account** you want to link;\n",
        "3.   **Accept**;\n",
        "4.   **Copy the key** Google gave you;\n",
        "5.   **Paste the key in the text field** that appeared below the first link you used,\n",
        "6.   **Press ENTER**."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "MF5o7F5wziXI",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [],
      "source": [
        "if IN_COLAB:\n",
        "    from google.colab import drive\n",
        "    drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HmIsJ02KziXN"
      },
      "source": [
        "### Retrieving your image(s)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "--OZ_F2-ziXN"
      },
      "source": [
        "Choose how to get your image(s) from the following list on the right   \n",
        "Use ```.jpg``` or ```.png``` images only !\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pJf8ln57ziXO",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [],
      "source": [
        "if IN_COLAB:\n",
        "    howToGetImage = \"From Google Drive\" #@param [\"Upload\", \"From Google Drive\"]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_b95BLdf_sUv"
      },
      "outputs": [],
      "source": [
        "if IN_COLAB:\n",
        "    !rm -r images/ || true\n",
        "    !mkdir -p images\n",
        "    !mkdir -p images/chain\n",
        "    !mkdir -p images/cortex\n",
        "    !mkdir -p images/mest_main"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gC7leXbgziXS"
      },
      "source": [
        "#### By upload"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "bX1mO5PRziXT",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [],
      "source": [
        "if IN_COLAB and howToGetImage == \"Upload\":\n",
        "    imageType = 'chain' #@param [\"chain\", \"cortex\", \"mest_main\"]\n",
        "    print(\"Please upload the image(s) you want to run the inference on, you can upload the corresponding annotations files too.\")\n",
        "    from google.colab import files\n",
        "    import shutil\n",
        "    uploaded = files.upload()\n",
        "    for fileName in uploaded:\n",
        "        shutil.move(fileName, os.path.join(\"images\", imageType, fileName))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cfzzCtOdziXV"
      },
      "source": [
        "#### By copy from Google Drive"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Vl8p94YMziXW"
      },
      "source": [
        "Be sure to customize the 2 variables for Google Colab to be able find your file(s) in Google Drive.\n",
        "Let's say you have this hierarchy in your Google Drive:\n",
        "```\n",
        "Root directory of Google Drive\n",
        "  ├─── Directory1\n",
        "  └─── Directory2\n",
        "       └─── images\n",
        "            ├─── example1.png\n",
        "            └─── example2.png\n",
        "```\n",
        "1.   ```customPathInDrive``` must represent all the directories between the root directory and your image file. In the example, it would be ```Directory2/images```. Keep it empty if **the file is directly in the root directory** of Google Drive;\n",
        "2.   ```imageFilePath``` must represent the file you want to upload. In the example, it would be ```example1.png```. It can also be empty if you want to import all the folder's images directly to Google Colab, so in the example, ```example1.png``` and ```example2.png``` would be imported.\n",
        "\n",
        "Use the text fields available on the right."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "XldmxmY6ziXW",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [],
      "source": [
        "if IN_COLAB and howToGetImage == \"From Google Drive\":\n",
        "    imageType = 'chain' #@param [\"chain\", \"cortex\", \"mest_main\"]\n",
        "    pathToDrive = \"/content/drive/MyDrive/\"\n",
        "    customPathInDrive = \"\" #@param {type:\"string\"}\n",
        "    pathToFolder = os.path.join(pathToDrive, customPathInDrive)\n",
        "    imageFilePath = \"\" #@param{type:\"string\"}\n",
        "    if imageFilePath != \"\":\n",
        "        pathToImage = os.path.join(pathToFolder, imageFilePath)\n",
        "        tempPath = os.path.join(\"images\", imageType, imageFilePath)\n",
        "        print(f\"Copying {pathToImage} to {tempPath}\")\n",
        "        !cp -u $pathToImage $tempPath\n",
        "    else:\n",
        "        fileList = os.listdir(pathToFolder)\n",
        "        for dataFile in fileList:\n",
        "            if dataFile.split('.')[-1] in ['png', 'jpg']:\n",
        "                pathToFile = os.path.join(pathToFolder, dataFile)\n",
        "                tempPath = os.path.join(\"images\", imageType, dataFile)\n",
        "                print(f\"Copying {pathToFile} to {tempPath}\")\n",
        "                !cp -u $pathToFile $tempPath"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aK4BiT4UziXf"
      },
      "source": [
        "## Initialization"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UIYmwPvR_sU0"
      },
      "source": [
        "### Configuration"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_BNhS71dziXf"
      },
      "source": [
        "You will have to open the **Files tab** in the **vertical navigation bar on the left** to see the results appearing. They should be downloaded as a zip file automatically at the end, if it is not the case: save them by right-clicking on each file you want to keep (or the zip file that contains everything).\n",
        "\n",
        "  - ```mode```: The inference mode to use. Note that ```chain``` will use following modes in the same order: cortex, mest_main, and mest_glom.\n",
        "  - ```displayMode```: Whether to display every step of an inference, or only AP and statistics.\n",
        "  \n",
        "  - ```moveAutoCortexOutputToMainInput```: Whether to move automatically cortex output image to mest_main mode input folder while using cortex as single inference mode.\n",
        "  \n",
        "ℹ️ **Statistics used to compute MEST-C Score are only available through ```chain``` inference mode !**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "KRoQrP1zziXh",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [],
      "source": [
        "mode = 'chain' #@param [\"chain\", \"cortex\", \"mest_main\"]\n",
        "displayMode = \"All steps\" #@param [\"All steps\", \"Only AP & statistics\"]\n",
        "moveAutoCortexOutputToMainInput = True #@param {type:\"boolean\"}"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5Yb224cl_sU1"
      },
      "source": [
        "### Information"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "VdhPw1_DziXk",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [],
      "source": [
        "print(f\"Inference Tool in {mode} segmentation mode.\")\n",
        "import nephrology as nephro\n",
        "images = nephro.listAvailableImage(os.path.join('images', mode))\n",
        "nb = len(images)\n",
        "print(f\"Found {nb if nb > 0 else 'no'} image{'s' if nb > 1 else ''}{':' if nb > 0 else ''}\")\n",
        "print(\"\\n\".join([f\" - {image}\" for image in images]))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "djryzFV3ziXq"
      },
      "source": [
        "## Inference"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Oh__RSBqziXq",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [],
      "source": [
        "import shutil\n",
        "shutil.rmtree('data/', ignore_errors=True)\n",
        "if len(images) > 0:\n",
        "    try:\n",
        "        model is None\n",
        "        if mode != lastMode:\n",
        "            raise NameError()\n",
        "    except NameError:\n",
        "        lastMode = mode\n",
        "        model = nephro.NephrologyInferenceModel('skinet.json', low_memory=IN_COLAB)\n",
        "    if mode != \"chain\":\n",
        "        model.load(mode=mode)\n",
        "    model.inference(images, \"results/inference/\", chainMode=(mode == \"chain\"), displayOnlyAP=(displayMode == \"Only AP & statistics\"))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9OcCXegqziXw"
      },
      "source": [
        "### Moving Fusion files (Colab + Local) and downloading results (Colab only)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hc8W8plZziXx"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "if len(images) > 0:\n",
        "    lastDir = 'inference'\n",
        "    remainingPath = \"results/\"\n",
        "    lastFoundDir = None\n",
        "    fileList = os.listdir(remainingPath)\n",
        "    fileList.sort()\n",
        "    for resultFolder in fileList:\n",
        "        if lastDir in resultFolder and os.path.isdir(os.path.join(remainingPath, resultFolder)):\n",
        "            lastFoundDir = resultFolder\n",
        "    if lastFoundDir is not None:\n",
        "        lastFoundDirPath = os.path.join(remainingPath, lastFoundDir)\n",
        "        if mode == \"cortex\" and moveAutoCortexOutputToMainInput:\n",
        "            for imageFolder in os.listdir(lastFoundDirPath):\n",
        "                imageFolderPath = os.path.join(lastFoundDirPath, imageFolder)\n",
        "                if os.path.isdir(imageFolderPath):\n",
        "                    cleanedImagePath = os.path.join(imageFolderPath, imageFolder + \"_cleaned.jpg\")\n",
        "                    if os.path.exists(cleanedImagePath):\n",
        "                            shutil.copy2(cleanedImagePath, os.path.join(\"images\", \"mest_main\", imageFolder + \"_cleaned.jpg\"))\n",
        "        if IN_COLAB:\n",
        "            zipName = lastFoundDir + '.zip'\n",
        "            !zip -qr $zipName $lastFoundDirPath\n",
        "            print(\"Results can be downloaded on the Files tab on the left\")\n",
        "            print(\"Zip file name is :\", zipName)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OKqFDr3OziXz"
      },
      "source": [
        "This cell may run indefinitely, Google Colab has problem with downloading automatically large files."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "TmW9uzKcziXz"
      },
      "outputs": [],
      "source": [
        "if IN_COLAB and len(images) > 0:\n",
        "    from google.colab import files\n",
        "    files.download(zipName)"
      ]
    }
  ],
  "metadata": {
    "celltoolbar": "Format de la Cellule Texte Brut",
    "colab": {
      "name": "Mask_R_CNN_Nephrology_Inference.ipynb",
      "private_outputs": true,
      "provenance": [],
      "toc_visible": true
    },
    "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.8.8"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}