Downloads: 1
Diff of
/Example_on_BRATS2018.ipynb
[000000]
..
[fcace9]
Switch to side-by-side view
--- a +++ b/Example_on_BRATS2018.ipynb @@ -0,0 +1,852 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Example on BRATS2018", + "version": "0.3.2", + "provenance": [], + "collapsed_sections": [], + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "accelerator": "GPU" + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "<a href=\"https://colab.research.google.com/github/IAmSuyogJadhav/3d-mri-brain-tumor-segmentation-using-autoencoder-regularization/blob/master/Example_on_BRATS2018.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "0Uld1IQgwKIL", + "colab_type": "text" + }, + "source": [ + "Note\n", + "- [Colab Only] Means the associated cell is required only if you are running the model on Google Colaboratory" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "m-oHUemNtm59", + "colab_type": "text" + }, + "source": [ + "## Mount Drive [Colab Only]\n", + "Mount the google drive to access the dataset stored on drive." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "zYkOcDYNtf-e", + "colab_type": "code", + "outputId": "607d7128-cc53-4b85-fa43-bb2ca4727b03", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 121 + } + }, + "source": [ + "from google.colab import drive\n", + "drive.mount('/gdrive')" + ], + "execution_count": 2, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Go to this URL in a browser: https://accounts.google.com/o/oauth2/auth?client_id=947318989803-6bn6qk8qdgf4n4g3pfee6491hc0brc4i.apps.googleusercontent.com&redirect_uri=urn%3Aietf%3Awg%3Aoauth%3A2.0%3Aoob&scope=email%20https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fdocs.test%20https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fdrive%20https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fdrive.photos.readonly%20https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fpeopleapi.readonly&response_type=code\n", + "\n", + "Enter your authorization code:\n", + "··········\n", + "Mounted at /gdrive\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Psq2s15_wlfJ", + "colab_type": "text" + }, + "source": [ + "## Extract the Dataset" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "DuUurNXQtmXT", + "colab_type": "code", + "colab": {} + }, + "source": [ + "import zipfile # For faster extraction\n", + "dataset_path = \"/gdrive/My Drive/MICCAI_BraTS_2018_Data_Training.zip\" # Replace with your dataset path\n", + "zfile = zipfile.ZipFile(dataset_path)\n", + "zfile.extractall()" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4NA9UG5zw938", + "colab_type": "text" + }, + "source": [ + "## Get required packages\n", + "- **SimpleITK**: For loading the dataset\n", + "- **[model.py](https://github.com/IAmSuyogJadhav/3d-mri-brain-tumor-segmentation-using-autoencoder-regularization/)**: The model from BRATS2018 winning paper" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "SqMFpmc6uCjQ", + "colab_type": "code", + "outputId": "3cc182ee-0bd0-49f5-c381-f2dfa8cebd6a", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 390 + } + }, + "source": [ + "!pip install simpleitk\n", + "!wget https://github.com/IAmSuyogJadhav/3d-mri-brain-tumor-segmentation-using-autoencoder-regularization/raw/master/model.py" + ], + "execution_count": 4, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Collecting simpleitk\n", + "\u001b[?25l Downloading https://files.pythonhosted.org/packages/45/ee/8ddd251cf447e1fc131622e925d538c2542780195ae75e26c122587630d1/SimpleITK-1.2.0-cp36-cp36m-manylinux1_x86_64.whl (42.5MB)\n", + "\u001b[K |████████████████████████████████| 42.5MB 33.9MB/s \n", + "\u001b[?25hInstalling collected packages: simpleitk\n", + "Successfully installed simpleitk-1.2.0\n", + "--2019-07-08 09:15:00-- https://github.com/IAmSuyogJadhav/3d-mri-brain-tumor-segmentation-using-autoencoder-regularization/raw/master/model.py\n", + "Resolving github.com (github.com)... 140.82.113.3\n", + "Connecting to github.com (github.com)|140.82.113.3|:443... connected.\n", + "HTTP request sent, awaiting response... 302 Found\n", + "Location: https://raw.githubusercontent.com/IAmSuyogJadhav/3d-mri-brain-tumor-segmentation-using-autoencoder-regularization/master/model.py [following]\n", + "--2019-07-08 09:15:01-- https://raw.githubusercontent.com/IAmSuyogJadhav/3d-mri-brain-tumor-segmentation-using-autoencoder-regularization/master/model.py\n", + "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 151.101.0.133, 151.101.64.133, 151.101.128.133, ...\n", + "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|151.101.0.133|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 15603 (15K) [text/plain]\n", + "Saving to: ‘model.py’\n", + "\n", + "model.py 100%[===================>] 15.24K --.-KB/s in 0.01s \n", + "\n", + "2019-07-08 09:15:01 (1.24 MB/s) - ‘model.py’ saved [15603/15603]\n", + "\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "09ARH9U4D2Wy", + "colab_type": "text" + }, + "source": [ + "## Imports and helper functions" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "4uAsBShgB3v_", + "colab_type": "code", + "outputId": "f1b7fe72-b0d7-4f63-ba15-44c16775e725", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + } + }, + "source": [ + "import SimpleITK as sitk # For loading the dataset\n", + "import numpy as np # For data manipulation\n", + "from model import build_model # For creating the model\n", + "import glob # For populating the list of files\n", + "from scipy.ndimage import zoom # For resizing\n", + "import re # For parsing the filenames (to know their modality)" + ], + "execution_count": 1, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Using TensorFlow backend.\n" + ], + "name": "stderr" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "nNNtloQ9B3sA", + "colab_type": "code", + "colab": {} + }, + "source": [ + "def read_img(img_path):\n", + " \"\"\"\n", + " Reads a .nii.gz image and returns as a numpy array.\n", + " \"\"\"\n", + " return sitk.GetArrayFromImage(sitk.ReadImage(img_path))" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "fEIRGXpdfssT", + "colab_type": "code", + "colab": {} + }, + "source": [ + "def resize(img, shape, mode='constant', orig_shape=(155, 240, 240)):\n", + " \"\"\"\n", + " Wrapper for scipy.ndimage.zoom suited for MRI images.\n", + " \"\"\"\n", + " assert len(shape) == 3, \"Can not have more than 3 dimensions\"\n", + " factors = (\n", + " shape[0]/orig_shape[0],\n", + " shape[1]/orig_shape[1], \n", + " shape[2]/orig_shape[2]\n", + " )\n", + " \n", + " # Resize to the given shape\n", + " return zoom(img, factors, mode=mode)\n", + "\n", + "\n", + "def preprocess(img, out_shape=None):\n", + " \"\"\"\n", + " Preprocess the image.\n", + " Just an example, you can add more preprocessing steps if you wish to.\n", + " \"\"\"\n", + " if out_shape is not None:\n", + " img = resize(img, out_shape, mode='constant')\n", + " \n", + " # Normalize the image\n", + " mean = img.mean()\n", + " std = img.std()\n", + " return (img - mean) / std\n", + "\n", + "\n", + "def preprocess_label(img, out_shape=None, mode='nearest'):\n", + " \"\"\"\n", + " Separates out the 3 labels from the segmentation provided, namely:\n", + " GD-enhancing tumor (ET — label 4), the peritumoral edema (ED — label 2))\n", + " and the necrotic and non-enhancing tumor core (NCR/NET — label 1)\n", + " \"\"\"\n", + " ncr = img == 1 # Necrotic and Non-Enhancing Tumor (NCR/NET)\n", + " ed = img == 2 # Peritumoral Edema (ED)\n", + " et = img == 4 # GD-enhancing Tumor (ET)\n", + " \n", + " if out_shape is not None:\n", + " ncr = resize(ncr, out_shape, mode=mode)\n", + " ed = resize(ed, out_shape, mode=mode)\n", + " et = resize(et, out_shape, mode=mode)\n", + "\n", + " return np.array([ncr, ed, et], dtype=np.uint8)\n", + " " + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "piRsc9rYYRzl", + "colab_type": "text" + }, + "source": [ + "## Loading Data\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "7adjWzdCuECK", + "colab_type": "code", + "colab": {} + }, + "source": [ + "# Get a list of files for all modalities individually\n", + "t1 = glob.glob('*GG/*/*t1.nii.gz')\n", + "t2 = glob.glob('*GG/*/*t2.nii.gz')\n", + "flair = glob.glob('*GG/*/*flair.nii.gz')\n", + "t1ce = glob.glob('*GG/*/*t1ce.nii.gz')\n", + "seg = glob.glob('*GG/*/*seg.nii.gz') # Ground Truth" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "x_WhT40dzlHO", + "colab_type": "text" + }, + "source": [ + "Parse all the filenames and create a dictionary for each patient with structure:\n", + "\n", + "{<br />\n", + " 't1': _<path to t1 MRI file>_,<br />\n", + " 't2': _<path to t2 MRI>_,<br />\n", + " 'flair': _<path to FLAIR MRI file>_,<br />\n", + " 't1ce': _<path to t1ce MRI file>_,<br />\n", + " 'seg': _<path to Ground Truth file>_,<br />\n", + "}<br />" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "4dssK9Nmwojp", + "colab_type": "code", + "colab": {} + }, + "source": [ + "pat = re.compile('.*_(\\w*)\\.nii\\.gz')\n", + "\n", + "data_paths = [{\n", + " pat.findall(item)[0]:item\n", + " for item in items\n", + "}\n", + "for items in list(zip(t1, t2, t1ce, flair, seg))]" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "wHqqrbnH0n2E", + "colab_type": "text" + }, + "source": [ + "## Load the data in a Numpy array\n", + "Creating an empty Numpy array beforehand and then filling up the data helps you gauge beforehand if the data fits in your memory.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "tBgbr-R-7Zat", + "colab_type": "text" + }, + "source": [ + "_Loading only the first 4 images here, to save time._" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "nvbbddauz8ij", + "colab_type": "code", + "colab": {} + }, + "source": [ + "input_shape = (4, 80, 96, 64)\n", + "output_channels = 3\n", + "data = np.empty((len(data_paths[:4]),) + input_shape, dtype=np.float32)\n", + "labels = np.empty((len(data_paths[:4]), output_channels) + input_shape[1:], dtype=np.uint8)" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "G4u_yrMf30k4", + "colab_type": "code", + "outputId": "81c1cb4d-8339-41bb-971c-a386bf3c7f69", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + } + }, + "source": [ + "import math\n", + "\n", + "# Parameters for the progress bar\n", + "total = len(data_paths[:4])\n", + "step = 25 / total\n", + "\n", + "for i, imgs in enumerate(data_paths[:4]):\n", + " try:\n", + " data[i] = np.array([preprocess(read_img(imgs[m]), input_shape[1:]) for m in ['t1', 't2', 't1ce', 'flair']], dtype=np.float32)\n", + " labels[i] = preprocess_label(read_img(imgs['seg']), input_shape[1:])[None, ...]\n", + " \n", + " # Print the progress bar\n", + " print('\\r' + f'Progress: '\n", + " f\"[{'=' * int((i+1) * step) + ' ' * (24 - int((i+1) * step))}]\"\n", + " f\"({math.ceil((i+1) * 100 / (total))} %)\",\n", + " end='')\n", + " except Exception as e:\n", + " print(f'Something went wrong with {imgs[\"t1\"]}, skipping...\\n Exception:\\n{str(e)}')\n", + " continue" + ], + "execution_count": 67, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Progress: [=========================](100 %)" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Ojc7YgwC305t", + "colab_type": "text" + }, + "source": [ + "## Model" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "uR_SDmgn4Lrd", + "colab_type": "text" + }, + "source": [ + "build the model" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "vI53S6yZJN2V", + "colab_type": "code", + "colab": {} + }, + "source": [ + "model = build_model(input_shape=input_shape, output_channels=3)" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "s1u107O74NOP", + "colab_type": "text" + }, + "source": [ + "Train the model" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "b0y7NfU4JBgi", + "colab_type": "code", + "outputId": "9f506516-2c7b-460e-aa5a-7abdab4eceb1", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 87 + } + }, + "source": [ + "model.fit(data, [labels, data], batch_size=1, epochs=1)" + ], + "execution_count": 100, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Epoch 1/1\n", + "4/4 [==============================] - 29s 7s/step - loss: 0.3766 - acc: 0.1188\n" + ], + "name": "stdout" + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "<keras.callbacks.History at 0x7f227c43bc88>" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 100 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "VlrqEF7m7ist", + "colab_type": "text" + }, + "source": [ + "That's it!" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ZKerVpLQTRck", + "colab_type": "text" + }, + "source": [ + "## Closing Regards" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "bkSxJbRx4SsO", + "colab_type": "text" + }, + "source": [ + "If you are resizing the segmentation mask, the resized segmentation mask retains the overall shape, but loses a lot of pixels and becomes somewhat 'grainy'. See the illustration below." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "eAau6Z7hznFC", + "colab_type": "text" + }, + "source": [ + "1. Original segmentation mask:" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "CXRW65_hkL9n", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 336 + }, + "outputId": "4c42e648-b9fe-4176-a324-b15ca9be7db5" + }, + "source": [ + "import matplotlib.pyplot as plt\n", + "img = (read_img(seg[0])[100] == 2).astype(np.uint8)\n", + "print(img.shape)\n", + "print(np.unique(img))\n", + "print(img.sum())\n", + "plt.imshow(img, cmap='Greys_r')" + ], + "execution_count": 109, + "outputs": [ + { + "output_type": "stream", + "text": [ + "(240, 240)\n", + "[0 1]\n", + "2111\n" + ], + "name": "stdout" + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "<matplotlib.image.AxesImage at 0x7f2275c25be0>" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 109 + }, + { + "output_type": "display_data", + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQUAAAD8CAYAAAB+fLH0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nrkJggg==\n", + "text/plain": [ + "<Figure size 432x288 with 1 Axes>" + ] + }, + "metadata": { + "tags": [] + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "soDTIJFn5CE9", + "colab_type": "text" + }, + "source": [ + "After resizing to (80, 96, 64)" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "-kmgpXjsAMzj", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 336 + }, + "outputId": "7eac8776-abc2-4334-a5b2-ffba151be588" + }, + "source": [ + "img = preprocess_label(read_img(seg[0]), out_shape=(80, 96, 64), mode='nearest')[1][50]\n", + "print(img.shape)\n", + "print(np.unique(img))\n", + "print(img.sum())\n", + "plt.imshow(img, cmap='Greys_r')" + ], + "execution_count": 105, + "outputs": [ + { + "output_type": "stream", + "text": [ + "(96, 64)\n", + "[0 1]\n", + "116\n" + ], + "name": "stdout" + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "<matplotlib.image.AxesImage at 0x7f2275d5bc50>" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 105 + }, + { + "output_type": "display_data", + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAALYAAAD8CAYAAADaM14OAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nTkSuQmCC\n", + "text/plain": [ + "<Figure size 432x288 with 1 Axes>" + ] + }, + "metadata": { + "tags": [] + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "FiGSgdqA5LGd", + "colab_type": "text" + }, + "source": [ + "One can clearly notice that there are now a lot of black pixels in the region where there should have been only white pixels. This can potentially hurt our model. So, it is best to not resize the image too much. But, due to computational constraints and the model requirements, it is unavoidable. \n", + "\n", + "However, given below are a few things one could try to reduce the downsampling noise as much as possible." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "01FtsxQi6dts", + "colab_type": "code", + "colab": {} + }, + "source": [ + "import cv2" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "vbflvVYqz2yu", + "colab_type": "text" + }, + "source": [ + "- Original Image > preprocess_label > Morphological Closing" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "vFn6tiXPsUdl", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 319 + }, + "outputId": "b7474d73-2f00-4c25-8968-4f740e5a2510" + }, + "source": [ + "kernel = np.ones((3, 3))\n", + "img_closed = cv2.morphologyEx(img, cv2.MORPH_CLOSE, kernel, iterations=3)\n", + "print(np.unique(img_closed))\n", + "print(img_closed.sum())\n", + "plt.imshow(img_closed, cmap='Greys_r')" + ], + "execution_count": 97, + "outputs": [ + { + "output_type": "stream", + "text": [ + "[0 1]\n", + "491\n" + ], + "name": "stdout" + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "<matplotlib.image.AxesImage at 0x7f227dc26160>" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 97 + }, + { + "output_type": "display_data", + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQUAAAD8CAYAAAB+fLH0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nRK5CYII=\n", + "text/plain": [ + "<Figure size 432x288 with 1 Axes>" + ] + }, + "metadata": { + "tags": [] + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "17CKK5zQz7hs", + "colab_type": "text" + }, + "source": [ + "- Original Image > preprocess_label > Morphological Dilation" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "bxhKa3kKtCLZ", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 319 + }, + "outputId": "7ee710b6-c5ed-4e9c-e2f0-935357e1bf0c" + }, + "source": [ + "kernel = np.ones((3, 3))\n", + "img_dilated = cv2.dilate(img, kernel, iterations=1)\n", + "print(np.unique(img_dilated))\n", + "print(img_dilated.sum())\n", + "plt.imshow(img_dilated, cmap='Greys_r')" + ], + "execution_count": 98, + "outputs": [ + { + "output_type": "stream", + "text": [ + "[0 1]\n", + "660\n" + ], + "name": "stdout" + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "<matplotlib.image.AxesImage at 0x7f227db77d30>" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 98 + }, + { + "output_type": "display_data", + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQUAAAD8CAYAAAB+fLH0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "<Figure size 432x288 with 1 Axes>" + ] + }, + "metadata": { + "tags": [] + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "gG3vfTyS0BVe", + "colab_type": "text" + }, + "source": [ + "You could try these things to get even better results." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CX6Cj1VO6vrZ", + "colab_type": "text" + }, + "source": [ + "## Feedback" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ZPt_15Ps6vO1", + "colab_type": "text" + }, + "source": [ + "If you have any feedback, queries, bug reports to send, please feel free to [raise an issue](https://github.com/IAmSuyogJadhav/3d-mri-brain-tumor-segmentation-using-autoencoder-regularization/issues/new) on github. It would be really helpful!" + ] + } + ] +}