From 38de20d83f8c7973a4faf2f5d3539acdcb74cc55 Mon Sep 17 00:00:00 2001 From: vavali08 <119764082+vavali08@users.noreply.github.com> Date: Wed, 26 Jul 2023 12:21:44 -0400 Subject: [PATCH 01/15] Add files via upload --- tutorials/GANDLF tutorial.ipynb | 1354 +++++++++++++++++++++++++++++++ 1 file changed, 1354 insertions(+) create mode 100644 tutorials/GANDLF tutorial.ipynb diff --git a/tutorials/GANDLF tutorial.ipynb b/tutorials/GANDLF tutorial.ipynb new file mode 100644 index 000000000..3f4327be1 --- /dev/null +++ b/tutorials/GANDLF tutorial.ipynb @@ -0,0 +1,1354 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "1cc4fdb8-18de-4128-8ec1-b0ba70f4a934", + "metadata": {}, + "source": [ + "In this tutorial, we will be using the Generally Nuanced Deep Learning Framework (GaNDLF) to perform training and inference on a VGG model with PathMNIST, a dataset of colon pathology images. This is a multi-class classification task: there are 9 different types of colon tissue displayed in the pathology images, each represented by its own class." + ] + }, + { + "cell_type": "markdown", + "id": "61838af7", + "metadata": {}, + "source": [ + "The VGG model is a CNN architecture mostly known for simplicity and effectiveness in image classification and has been used in object recognition, face detection, and medical image analysis. \n", + "Its most notable features include its use of 16-19 weight layers and small 3x3 filters which allow for better performance and faster training times.\n", + "\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "4e77f51e", + "metadata": {}, + "source": [ + "![VGG Model Image](https://d3i71xaburhd42.cloudfront.net/dae981902b1f6d869ef2d047612b90cdbe43fd1e/2-Figure1-1.png)" + ] + }, + { + "cell_type": "markdown", + "id": "b99da8e5", + "metadata": {}, + "source": [ + "Figure 1 - Display of VGG Architecture - Visualizing and Comparing AlexNet and VGG using Deconvolutional Layers (W. Yu)\n", + "\n", + "For more information on the model, refer to the paper Very Deep Convolutional Networks for Large-Scale Image Recognition by Karen Simonyan and Andrew Zisserman\n" + ] + }, + { + "cell_type": "markdown", + "id": "b0645481", + "metadata": {}, + "source": [ + "This tutorial demonstrates how to use GaNDLF with a simple classification task. Some steps that would ordinarily be part of the workflow (e.g. data CSV and config YAML file construction) have already been performed for simplicity; please refer to the GaNDLF documentation (located at https://cbica.github.io/GaNDLF/) for more information regarding replication of these steps.\n", + "\n", + "Command-Line Interface Note: Make sure you have Python installed before proceeding! Visit python.org/downloads for instructions on how do to this. Downloading version 3.7 is sufficient to complete this tutorial since this aligns with the version in Google Colab. \n", + "\n", + "Google Colab Note: Before continuing with this tutorial, please ensure that you are connected to the GPU by navigating to Runtime --> Change Runtime Type --> Hardware Accelerator and verifying that \"GPU\" is listed as the selected option. If not, it is highly recommended that you switch to it now. Also, if available, select the \"High-RAM\" option under Runtime → Change Runtime Type → Runtime Shape. Without this option selected, you may end up running out of RAM during training on a base notebook. \n", + "\n", + "Error Note: However, an error message may come up that says “You are connected to the GPU Runtime, but not utilizing the GPU.” This causes the program to stop when training the model because the program runs out of RAM.\n", + "\n", + "\n", + "Let's get started! First, we will clone the GaNDLF repo.\n", + "\n", + "Google Colab Note: Because the default version of Python in Colab (3.7) is not supported by the NumPy version used in the current version of GaNDLF, we will be cloning an earlier tag of the GaNDLF repo for this tutorial.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "adc51dd9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "fatal: destination path 'GaNDLF' already exists and is not an empty directory.\r\n" + ] + } + ], + "source": [ + "!git clone -b 0.0.14 --depth 1 https://github.com/CBICA/GaNDLF.git" + ] + }, + { + "cell_type": "markdown", + "id": "634c8e7b", + "metadata": {}, + "source": [ + "The -b option indicates which branch we want to clone, and –depth 1 specifies the number of commits(or versions of the repository) that we want to retrieve. In this case, we are only retrieving one to save space and time, and since we are not making any changes to the actual GaNDLF code, this is sufficient." + ] + }, + { + "cell_type": "markdown", + "id": "0c62a49b", + "metadata": {}, + "source": [ + "Let's navigate to the newly created GaNDLF directory using the cd(change directory) command.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "4e4cb90b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/Users/vedhaavali/GaNDLF/GANDLF\n" + ] + } + ], + "source": [ + "%cd GaNDLF\n" + ] + }, + { + "cell_type": "markdown", + "id": "18faa97d", + "metadata": {}, + "source": [ + "Now, we'll install the appropriate version of PyTorch for use with GaNDLF. Pytorch is a machine learning framework primarily used for deep learning, and we will be using it here.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "51f0bdf8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Looking in indexes: https://pypi.org/simple, https://download.pytorch.org/whl/lts/1.8/cu111\n", + "\u001b[31mERROR: Could not find a version that satisfies the requirement torch==1.8.2 (from versions: 1.11.0, 1.12.0, 1.12.1, 1.13.0, 1.13.1, 2.0.0, 2.0.1)\u001b[0m\u001b[31m\n", + "\u001b[0m\u001b[31mERROR: No matching distribution found for torch==1.8.2\u001b[0m\u001b[31m\n", + "\u001b[0m" + ] + } + ], + "source": [ + "!pip3 install torch==1.8.2 torchvision==0.9.2 torchaudio==0.8.2 --extra-index-url https://download.pytorch.org/whl/lts/1.8/cu111\n" + ] + }, + { + "cell_type": "markdown", + "id": "f60e51b7", + "metadata": {}, + "source": [ + "pip is Python’s package manager that allows us to easily download different Python packages from the internet. If you do not have pip installed, visit pip.pypa.io/en/stable/installation/ for instructions.\n" + ] + }, + { + "cell_type": "markdown", + "id": "59aa00d9", + "metadata": {}, + "source": [ + "Google Colab Error Note: You might see an error that says:\n", + "​​ERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts. torchtext 0.14.1 requires torch==1.13.1, but you have torch 1.8.2+cu111 which is incompatible.\n", + "The next few cells may also have similar errors of the same form mentioning “pip’s dependency resolver” and version incompatibility, but GaNDLF installation will still be successful despite this, as we will see when verifying the installation." + ] + }, + { + "cell_type": "markdown", + "id": "1a79edc1", + "metadata": {}, + "source": [ + "Next, let's install OpenVINO, which is used by GaNDLF to generate optimized models for inference.\n", + "\n", + "OpenVINO is a toolkit developed by Intel that allows for easier optimization of deep learning models in situations where access to computing resources may be limited. The model optimizes computation and memory usage while providing hardware-specific optimizations. OpenVINO currently supports over 68 different image classification models, allowing for flexibility of use with GaNDLF.\n", + "\n", + "Visit docs.openvino.ai for more information.\n" + ] + }, + { + "cell_type": "markdown", + "id": "4eee3270", + "metadata": {}, + "source": [ + "We’ll need to install Matplotlib v.3.5.0 for use in plotting our results, for this version includes all of the features that we will be using later on. Let's do that now!\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "e63124bb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting matplotlib==3.5.0\n", + " Downloading matplotlib-3.5.0-cp310-cp310-macosx_11_0_arm64.whl (7.2 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m7.2/7.2 MB\u001b[0m \u001b[31m11.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m00:01\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: fonttools>=4.22.0 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from matplotlib==3.5.0) (4.25.0)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from matplotlib==3.5.0) (1.4.4)\n", + "Requirement already satisfied: numpy>=1.17 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from matplotlib==3.5.0) (1.23.5)\n", + "Requirement already satisfied: cycler>=0.10 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from matplotlib==3.5.0) (0.11.0)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from matplotlib==3.5.0) (2.8.2)\n", + "Requirement already satisfied: pyparsing>=2.2.1 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from matplotlib==3.5.0) (3.0.9)\n", + "Requirement already satisfied: packaging>=20.0 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from matplotlib==3.5.0) (22.0)\n", + "Requirement already satisfied: pillow>=6.2.0 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from matplotlib==3.5.0) (9.4.0)\n", + "Collecting setuptools-scm>=4\n", + " Downloading setuptools_scm-7.1.0-py3-none-any.whl (43 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m43.8/43.8 kB\u001b[0m \u001b[31m1.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: six>=1.5 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from python-dateutil>=2.7->matplotlib==3.5.0) (1.16.0)\n", + "Requirement already satisfied: setuptools in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from setuptools-scm>=4->matplotlib==3.5.0) (65.6.3)\n", + "Requirement already satisfied: tomli>=1.0.0 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from setuptools-scm>=4->matplotlib==3.5.0) (2.0.1)\n", + "Requirement already satisfied: typing-extensions in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from setuptools-scm>=4->matplotlib==3.5.0) (4.4.0)\n", + "Installing collected packages: setuptools-scm, matplotlib\n", + " Attempting uninstall: matplotlib\n", + " Found existing installation: matplotlib 3.7.0\n", + " Uninstalling matplotlib-3.7.0:\n", + " Successfully uninstalled matplotlib-3.7.0\n", + "Successfully installed matplotlib-3.5.0 setuptools-scm-7.1.0\n" + ] + } + ], + "source": [ + "!pip install matplotlib==3.5.0\n" + ] + }, + { + "cell_type": "markdown", + "id": "ed63ccf0", + "metadata": {}, + "source": [ + "Matplotlib is a library that allows us to create different types of data visualizations in Python. We will go over some of the specific features when we utilize it later on. Visit matplotlib.org for more information.\n", + "\n", + "Google Colab Note: To be able to use the newly installed version of Matplotlib for plotting, go ahead and click the small gray \"RESTART RUNTIME\" button in the output directly above this code cell, and then continue with this tutorial once the restart process is complete.\n", + "\n", + "\n", + "Now, ensure you are still in the GaNDLF directory before proceeding. Otherwise, run the following command. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "5abebbed", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Errno 2] No such file or directory: 'GaNDLF'\n", + "/Users/vedhaavali/GaNDLF/GANDLF\n" + ] + } + ], + "source": [ + "%cd GaNDLF\n" + ] + }, + { + "cell_type": "markdown", + "id": "5aa72043", + "metadata": {}, + "source": [ + "For the last of our GaNDLF-related installations, let's install all required packages for GaNDLF.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "8db908ae", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Obtaining file:///Users/vedhaavali/GaNDLF/GANDLF\r\n", + "\u001b[31mERROR: file:///Users/vedhaavali/GaNDLF/GANDLF does not appear to be a Python project: neither 'setup.py' nor 'pyproject.toml' found.\u001b[0m\u001b[31m\r\n", + "\u001b[0m" + ] + } + ], + "source": [ + "!pip install -e ." + ] + }, + { + "cell_type": "markdown", + "id": "488d9232", + "metadata": {}, + "source": [ + "-e is short for editable, and . indicates that we are installing from the current directory (GaNDLF). Essentially, we are installing the packages in an editable mode because this allows us to change the source code in the packages without having to redownload the packages after we make modifications. \n", + "\n", + "Now, let's use gandlf_verifyInstall to verify our GaNDLF installation. " + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "77bd9e3d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "python: can't open file '/Users/vedhaavali/GaNDLF/GANDLF/./gandlf_verifyInstall': [Errno 2] No such file or directory\r\n" + ] + } + ], + "source": [ + "!python ./gandlf_verifyInstall\n" + ] + }, + { + "cell_type": "markdown", + "id": "3001d597", + "metadata": {}, + "source": [ + "\n", + "If you see the message, “GaNDLF is ready” after executing the previous step, then all steps have been followed correctly thus far. Let's move on to collecting our data. First, we will install the MedMNIST package in order to obtain the PathMNIST data that we will be using.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "baf27899", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting medmnist\n", + " Downloading medmnist-2.2.2-py3-none-any.whl (21 kB)\n", + "Requirement already satisfied: tqdm in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from medmnist) (4.64.1)\n", + "Collecting fire\n", + " Downloading fire-0.5.0.tar.gz (88 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m88.3/88.3 kB\u001b[0m \u001b[31m1.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0ma \u001b[36m0:00:01\u001b[0m\n", + "\u001b[?25h Preparing metadata (setup.py) ... \u001b[?25ldone\n", + "\u001b[?25hRequirement already satisfied: Pillow in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from medmnist) (9.4.0)\n", + "Collecting torchvision\n", + " Downloading torchvision-0.15.2-cp310-cp310-macosx_11_0_arm64.whl (1.4 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.4/1.4 MB\u001b[0m \u001b[31m5.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m00:01\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: scikit-image in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from medmnist) (0.19.3)\n", + "Requirement already satisfied: scikit-learn in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from medmnist) (1.2.1)\n", + "Requirement already satisfied: torch in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from medmnist) (1.12.1)\n", + "Requirement already satisfied: numpy in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from medmnist) (1.23.5)\n", + "Requirement already satisfied: pandas in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from medmnist) (1.5.3)\n", + "Requirement already satisfied: six in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from fire->medmnist) (1.16.0)\n", + "Collecting termcolor\n", + " Downloading termcolor-2.3.0-py3-none-any.whl (6.9 kB)\n", + "Requirement already satisfied: python-dateutil>=2.8.1 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from pandas->medmnist) (2.8.2)\n", + "Requirement already satisfied: pytz>=2020.1 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from pandas->medmnist) (2022.7)\n", + "Requirement already satisfied: tifffile>=2019.7.26 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from scikit-image->medmnist) (2021.7.2)\n", + "Requirement already satisfied: packaging>=20.0 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from scikit-image->medmnist) (22.0)\n", + "Requirement already satisfied: imageio>=2.4.1 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from scikit-image->medmnist) (2.26.0)\n", + "Requirement already satisfied: scipy>=1.4.1 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from scikit-image->medmnist) (1.10.0)\n", + "Requirement already satisfied: PyWavelets>=1.1.1 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from scikit-image->medmnist) (1.4.1)\n", + "Requirement already satisfied: networkx>=2.2 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from scikit-image->medmnist) (2.8.4)\n", + "Requirement already satisfied: threadpoolctl>=2.0.0 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from scikit-learn->medmnist) (2.2.0)\n", + "Requirement already satisfied: joblib>=1.1.1 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from scikit-learn->medmnist) (1.1.1)\n", + "Requirement already satisfied: typing_extensions in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from torch->medmnist) (4.4.0)\n", + "Collecting torch\n", + " Downloading torch-2.0.1-cp310-none-macosx_11_0_arm64.whl (55.8 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m55.8/55.8 MB\u001b[0m \u001b[31m6.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m00:01\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: requests in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from torchvision->medmnist) (2.28.1)\n", + "Requirement already satisfied: jinja2 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from torch->medmnist) (3.1.2)\n", + "Requirement already satisfied: sympy in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from torch->medmnist) (1.11.1)\n", + "Requirement already satisfied: filelock in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from torch->medmnist) (3.9.0)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from jinja2->torch->medmnist) (2.1.1)\n", + "Requirement already satisfied: charset-normalizer<3,>=2 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from requests->torchvision->medmnist) (2.0.4)\n", + "Requirement already satisfied: idna<4,>=2.5 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from requests->torchvision->medmnist) (3.4)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from requests->torchvision->medmnist) (2022.12.7)\n", + "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from requests->torchvision->medmnist) (1.26.14)\n", + "Requirement already satisfied: mpmath>=0.19 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages/mpmath-1.2.1-py3.10.egg (from sympy->torch->medmnist) (1.2.1)\n", + "Building wheels for collected packages: fire\n", + " Building wheel for fire (setup.py) ... \u001b[?25ldone\n", + "\u001b[?25h Created wheel for fire: filename=fire-0.5.0-py2.py3-none-any.whl size=116931 sha256=e4fdcf3a8b63eed3ef74683188ea00ea0a79b077de3b67289a6a3e0a87ecd7ce\n", + " Stored in directory: /Users/vedhaavali/Library/Caches/pip/wheels/c4/eb/6a/1c6d2ad660043768e998bdf9c6a28db2f1b7db3a5825d51e87\n", + "Successfully built fire\n", + "Installing collected packages: termcolor, torch, fire, torchvision, medmnist\n", + " Attempting uninstall: torch\n", + " Found existing installation: torch 1.12.1\n", + " Uninstalling torch-1.12.1:\n", + " Successfully uninstalled torch-1.12.1\n", + "Successfully installed fire-0.5.0 medmnist-2.2.2 termcolor-2.3.0 torch-2.0.1 torchvision-0.15.2\n" + ] + } + ], + "source": [ + "!pip install medmnist\n" + ] + }, + { + "cell_type": "markdown", + "id": "22031f46", + "metadata": {}, + "source": [ + "The original MNIST(Modified National Institute of Standards in Technology) database is a database containing various images of handwritten digits, and people use this dataset to train computer programs to recognize digits. MNIST is often used as a benchmark, and researchers can test different machine learning algorithms on MNIST to evaluate their performance.\n", + "MedMNIST is a database of biomedical images with 18 different datasets. \n", + "\n", + "The 2D Datasets are:\n", + "1. PathMNIST(Colon Pathology images)\n", + "2. ChestMNIST(Chest X-Ray images)\n", + "3. DermaMNIST(Dermatoscope images)\n", + "4. OCTMNIST(Retinal OCT images)\n", + "5. PneumoniaMNIST(Chest X-Ray images)\n", + "6. RetinaMNIST(Fundus Camera images)\n", + "7. BreastMNIST(Breast Ultrasound images)\n", + "8. BloodMNIST(Blood Cell Microscope images)\n", + "9. TissueMNIST(Kidney Cortex Microscope images)\n", + "10. - 12. OrganAMNIST, OrganCMNIST, and Organ SMNIST (Abdominal CT images)\n", + "\n", + "The 3D Datasets are:\n", + "1. OrganMNIST3D(Abdominal CT images)\n", + "2. NoduleMNIST3D(Chest CT images)\n", + "3. AdrenalMNIST3D(Shape from Abdominal CT images)\n", + "4. FractureMNIST3D(Chest CT images)\n", + "5. VesselMNIST3D(Shape from Brain MRA images)\n", + "6. SynapseMNIST3D(Electron Microscope images)\n", + "\n", + "Here are some visualizations of the MedMNIST dataset. \n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "2eeaf438", + "metadata": {}, + "source": [ + "![MedMNIST visualizations](https://medmnist.com/assets/v2/imgs/overview.jpg)\n" + ] + }, + { + "cell_type": "markdown", + "id": "bc3638aa", + "metadata": {}, + "source": [ + "Figure 2 - MedMNIST datasets - MedMNIST v2 - A large-scale lightweight benchmark for 2D and 3D biomedical image classification (J. Yang)\n", + "\n", + "\n", + "The data is stored in a 28×28 (2D) or 28×28×28 (3D) format, similar to the 28×28 size of the images in the original MNIST dataset. \n", + "\n", + "For more information on MedMNIST and its installation visit github.com/MedMNIST/MedMNIST/ or medmnist.com\n", + "\n", + "For the purposes of this tutorial, we will be focusing on PathMNIST, the colon pathology images. The PathMNIST dataset has a total of 107,180 samples, and these images were taken from the study \"Predicting survival from colorectal cancer histology slides using deep learning: A retrospective multicenter study,\" by Jakob Nikolas Kather, Johannes Krisam, et al.\n", + "\n", + "We will look more closely at the images in this dataset soon. \n", + "\n", + "\n", + "\n", + "Now, let's import MedMNIST and verify the version number before we move on. \n", + "\n", + "Command-Line Interface Note: This is Python code, so to run this, we must enter the Python shell. To do this, type python or python3 in the command prompt and press enter. After executing these commands, type exit() or quit() to exit the Python shell.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "411eb42d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.2.2\n" + ] + } + ], + "source": [ + "import medmnist\n", + "print(medmnist.__version__)" + ] + }, + { + "cell_type": "markdown", + "id": "84912c51", + "metadata": {}, + "source": [ + "Time to load our data! Let's download all MedMNIST datasets to the root directory. In this tutorial, we will only be using the PathMNIST dataset; however, feel free to use any of the other datasets you see being downloaded below (which are also mentioned above) to try out GaNDLF for yourself!\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "0536b26c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading pathmnist...\n", + "Downloading https://zenodo.org/record/6496656/files/pathmnist.npz?download=1 to /Users/vedhaavali/.medmnist/pathmnist.npz\n", + "100%|█████████████████████████| 205615438/205615438 [06:57<00:00, 492777.43it/s]\n", + "Downloading chestmnist...\n", + "Downloading https://zenodo.org/record/6496656/files/chestmnist.npz?download=1 to /Users/vedhaavali/.medmnist/chestmnist.npz\n", + " 2%|▍ | 1277952/82802576 [00:03<05:02, 269084.05it/s]^C\n", + " 2%|▍ | 1310720/82802576 [00:03<03:43, 365426.14it/s]\n", + "Traceback (most recent call last):\n", + " File \"/Users/vedhaavali/anaconda3/lib/python3.10/site-packages/medmnist/dataset.py\", line 84, in download\n", + " download_url(url=self.info[\"url\"],\n", + " File \"/Users/vedhaavali/anaconda3/lib/python3.10/site-packages/torchvision/datasets/utils.py\", line 144, in download_url\n", + " _urlretrieve(url, fpath)\n", + " File \"/Users/vedhaavali/anaconda3/lib/python3.10/site-packages/torchvision/datasets/utils.py\", line 48, in _urlretrieve\n", + " _save_response_content(iter(lambda: response.read(chunk_size), b\"\"), filename, length=response.length)\n", + " File \"/Users/vedhaavali/anaconda3/lib/python3.10/site-packages/torchvision/datasets/utils.py\", line 37, in _save_response_content\n", + " for chunk in content:\n", + " File \"/Users/vedhaavali/anaconda3/lib/python3.10/site-packages/torchvision/datasets/utils.py\", line 48, in \n", + " _save_response_content(iter(lambda: response.read(chunk_size), b\"\"), filename, length=response.length)\n", + " File \"/Users/vedhaavali/anaconda3/lib/python3.10/http/client.py\", line 465, in read\n", + " s = self.fp.read(amt)\n", + " File \"/Users/vedhaavali/anaconda3/lib/python3.10/socket.py\", line 705, in readinto\n", + " return self._sock.recv_into(b)\n", + " File \"/Users/vedhaavali/anaconda3/lib/python3.10/ssl.py\", line 1274, in recv_into\n", + " return self.read(nbytes, buffer)\n", + " File \"/Users/vedhaavali/anaconda3/lib/python3.10/ssl.py\", line 1130, in read\n", + " return self._sslobj.read(len, buffer)\n", + "KeyboardInterrupt\n", + "\n", + "During handling of the above exception, another exception occurred:\n", + "\n", + "Traceback (most recent call last):\n", + " File \"/Users/vedhaavali/anaconda3/lib/python3.10/runpy.py\", line 196, in _run_module_as_main\n", + " return _run_code(code, main_globals, None,\n", + " File \"/Users/vedhaavali/anaconda3/lib/python3.10/runpy.py\", line 86, in _run_code\n", + " exec(code, run_globals)\n", + " File \"/Users/vedhaavali/anaconda3/lib/python3.10/site-packages/medmnist/__main__.py\", line 123, in \n", + " fire.Fire()\n", + " File \"/Users/vedhaavali/anaconda3/lib/python3.10/site-packages/fire/core.py\", line 141, in Fire\n", + " component_trace = _Fire(component, args, parsed_flag_args, context, name)\n", + " File \"/Users/vedhaavali/anaconda3/lib/python3.10/site-packages/fire/core.py\", line 475, in _Fire\n", + " component, remaining_args = _CallAndUpdateTrace(\n", + " File \"/Users/vedhaavali/anaconda3/lib/python3.10/site-packages/fire/core.py\", line 691, in _CallAndUpdateTrace\n", + " component = fn(*varargs, **kwargs)\n", + " File \"/Users/vedhaavali/anaconda3/lib/python3.10/site-packages/medmnist/__main__.py\", line 18, in download\n", + " _ = getattr(medmnist, INFO[key]['python_class'])(\n", + " File \"/Users/vedhaavali/anaconda3/lib/python3.10/site-packages/medmnist/dataset.py\", line 35, in __init__\n", + " self.download()\n", + " File \"/Users/vedhaavali/anaconda3/lib/python3.10/site-packages/medmnist/dataset.py\", line 89, in download\n", + " raise RuntimeError('Something went wrong when downloading! ' +\n", + "RuntimeError: Something went wrong when downloading! Go to the homepage to download manually. https://github.com/MedMNIST/MedMNIST/\n" + ] + } + ], + "source": [ + "!python -m medmnist download\n" + ] + }, + { + "cell_type": "markdown", + "id": "6a040293", + "metadata": {}, + "source": [ + "-m stands for module, and this command is saying that we want to access the medmnist module and run the download function from that module.\n", + "\n", + "Before we continue, let's navigate back to the base directory.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "a2cb0640", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/Users/vedhaavali/GaNDLF\n" + ] + } + ], + "source": [ + "%cd ..\n" + ] + }, + { + "cell_type": "markdown", + "id": "0509cadf", + "metadata": {}, + "source": [ + "Now, let's save all PathMNIST pathology images within the dataset folder (located inside the medmnist directory) in PNG format for use in training and inference.\n", + "If you've already gone through this tutorial and are looking to try using a different MedMNIST dataset, simply change --flag=pathmnist to any of the other datasets that were downloaded above—it's as simple as that!" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "19db62eb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Saving pathmnist train...\n", + "100%|███████████████████████████████████| 89996/89996 [00:15<00:00, 5636.60it/s]\n", + "Saving pathmnist val...\n", + "100%|███████████████████████████████████| 10004/10004 [00:02<00:00, 4912.07it/s]\n", + "Saving pathmnist test...\n", + "100%|█████████████████████████████████████| 7180/7180 [00:01<00:00, 4582.64it/s]\n" + ] + } + ], + "source": [ + "!python -m medmnist save --flag=pathmnist --folder=medmnist/dataset/ --postfix=png" + ] + }, + { + "cell_type": "markdown", + "id": "cbcb07ff", + "metadata": {}, + "source": [ + "The --folder option specifies where to save the downloaded information, and the --postfix option specifies that the images should be saved in png format.\n", + "\n", + "For this tutorial, we will be using the full PathMNIST dataset for training, validation and testing. However, to improve efficiency and save time, you may consider using a fraction of this dataset instead with GaNDLF. \n", + "\n", + "To download the full dataset:\n", + "\n", + "Let's retrieve and download the train_path_full data CSV file within the dataset folder, which consists of ~90,000 images.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "4a699380", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "zsh:1: command not found: wget\r\n" + ] + } + ], + "source": [ + "!wget -O /content/medmnist/dataset/train_path_full.csv \"https://app.box.com/index.php?rm=box_download_shared_file&shared_name=zzokqk7hjzwmjxvamrxotxu78ihd5az0&file_id=f_972380483494\"" + ] + }, + { + "cell_type": "markdown", + "id": "831324a5", + "metadata": {}, + "source": [ + "location where the file should be saved and what the new filename will be\n", + ". \n", + "Let's retrieve and download the val_path_full data CSV file within the dataset folder, which is the full validation dataset consisting of ~10,000 images. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "785af619", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "zsh:1: command not found: wget\r\n" + ] + } + ], + "source": [ + "!wget -O /content/medmnist/dataset/val_path_full.csv \"https://app.box.com/index.php?rm=box_download_shared_file&shared_name=bjoh6hn27l6ifqqtrs7w66za2hdwlu0a&file_id=f_990373191120\"" + ] + }, + { + "cell_type": "markdown", + "id": "37bd1888", + "metadata": {}, + "source": [ + "For the last of the data CSV files, let's retrieve and download the test_path_full data CSV file within the dataset folder. This CSV file contains ~7200 individual images.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "42d61c84", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "zsh:1: command not found: wget\r\n" + ] + } + ], + "source": [ + "!wget -O /content/medmnist/dataset/test_path_full.csv \"https://app.box.com/index.php?rm=box_download_shared_file&shared_name=jjzoifpdly0pmkdaguy0cxbdfkig81eq&file_id=f_990374552591\"" + ] + }, + { + "cell_type": "markdown", + "id": "55be009b", + "metadata": {}, + "source": [ + "To download the “tiny” dataset:\n", + "\n", + "Let's retrieve and download the train_path_tiny data CSV file within the dataset folder, which consists of ~4,000 images.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "2d63bf0e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "zsh:1: command not found: wget\r\n" + ] + } + ], + "source": [ + "!wget -O /content/medmnist/dataset/train_path_full.csv \"https://app.box.com/index.php?rm=box_download_shared_file&shared_name=um4003lkrvyj55jm4a0jz7zsuokb0r8o&file_id=f_991821586980\"" + ] + }, + { + "cell_type": "markdown", + "id": "e7d39d90", + "metadata": {}, + "source": [ + "Let's retrieve and download the val_path_tiny data CSV file within the dataset folder, which consists of ~1,000 images. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "e0054486", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "zsh:1: command not found: wget\r\n" + ] + } + ], + "source": [ + "!wget -O /content/medmnist/dataset/val_path_full.csv \"https://app.box.com/index.php?rm=box_download_shared_file&shared_name=rsmff27sm2z34r5xso1jx8xix7nhfspc&file_id=f_991817441206\"" + ] + }, + { + "cell_type": "markdown", + "id": "5a1b249b", + "metadata": {}, + "source": [ + "For the last of the data CSV files, let's retrieve and download the test_path_full data CSV file within the dataset folder. This CSV file contains 500 individual images.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "fdc098fe", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "zsh:1: command not found: wget\r\n" + ] + } + ], + "source": [ + "!wget -O /content/medmnist/dataset/test_path_full.csv \"https://app.box.com/index.php?rm=box_download_shared_file&shared_name=22lm0qfzk5luap72mtdpzx5l3ocflopa&file_id=f_991819617152\"\n" + ] + }, + { + "cell_type": "markdown", + "id": "cad43170", + "metadata": {}, + "source": [ + "Command-Line Interface Note: If you run into any issues when trying to download these files, you can copy and paste these links into your web browser to download the .csv files. Then, you can manually place them into the desired directory using your file manager.\n", + "\n", + "\n", + "Now, we will retrieve and download the config YAML file to the base directory. This file specifies important information to be used in training and inference (model and training parameters, data preprocessing specifications, etc.).\n", + "\n", + "For the purposes of this tutorial, we have already constructed this file to fit our specific task, but for other tasks and experiments that you may want to run, this file will need to be edited to fit the required specifications of your experiment. However, the overall structure of this file will stay the same regardless of your task, so you should be able to get by by simply downloading and editing the config.yaml file we're using below for use in your own experiments.\n", + "\n", + "Either way, we highly encourage you to download and take a look at the structure of this file before proceeding if you intend to use GaNDLF for your own experiments, as it will be the backbone of all tasks you use GaNDLF with in the future. The file contains comments explaining the various parameters and what they mean. If you plan on trying to use any of the other datasets, specifically the 3D ones, make sure to change the number of dimensions on line 11 of the file to 3. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "e71a3bfa", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "zsh:1: command not found: wget\r\n" + ] + } + ], + "source": [ + "!wget -O config.yaml \"https://app.box.com/index.php?rm=box_download_shared_file&shared_name=hs0zwezggl4rxtzgrcaq86enu7qwuvqx&file_id=f_974251081617\"" + ] + }, + { + "cell_type": "markdown", + "id": "5be6bb2f", + "metadata": {}, + "source": [ + "Finally, let's retrieve and download an updated copy of the gandlf_collectStats file to the base directory for use in plotting and visualizing our results. While an earlier version of this file is present in the GaNDLF repo, it is not suitable for classification tasks and has been modified for this tutorial to produce classification training and validation accuracy and loss plots. This file will be included in the GaNDLF repo in a future update, but for now, we will retrieve the updated file externally for use in this tutorial.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "4309c31e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "zsh:1: command not found: wget\r\n" + ] + } + ], + "source": [ + "!wget -O gandlf_collectStats_final \"https://app.box.com/index.php?rm=box_download_shared_file&shared_name=avq6pvqg3uzsc4uzbklab66mad6eaik5&file_id=f_989875069231\"" + ] + }, + { + "cell_type": "markdown", + "id": "41871543", + "metadata": {}, + "source": [ + "Let's visualize some sample images and their classes from the PathMNIST dataset.\n", + "Image classes for reference:\n", + "Class 0: Adipose\n", + "Class 1: Background\n", + "Class 2: Debris\n", + "Class 3: Lymphocytes\n", + "Class 4: Mucus\n", + "Class 5: Smooth Muscle\n", + "Class 6: Normal Colon Mucosa\n", + "Class 7: Cancer-Associated Stroma\n", + "Class 8: Colorectal Adenocarcinoma Epithelium\n", + "\n", + "Before running the code below, make sure you enter the python shell again if you are using a command line interface. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "3f322c5e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Step 1\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.image as mpimg\n", + "import pandas as pd\n", + "\n", + "\n", + "#Step 2\n", + "df_pathmnist = pd.read_csv('./medmnist/dataset/pathmnist.csv')\n", + "\n", + "\n", + "#Step 3\n", + "selected_images = [32, 36, 46, 13, 14, 8, 12, 18, 5, 6, 17, 0, 16, 3, 7, 10, 43, 45, 55, 1, 31, 41, 4, 9, 11]\n", + "\n", + "\n", + "#Step 4\n", + "fig, ax = plt.subplot_mosaic([\n", + " ['img0', 'img1', 'img2', 'img3', 'img4'],\n", + " ['img5', 'img6', 'img7', 'img8', 'img9'],\n", + " ['img10', 'img11', 'img12', 'img13', 'img14'],\n", + " ['img15', 'img16', 'img17', 'img18', 'img19'],\n", + " ['img20', 'img21', 'img22', 'img23', 'img24']\n", + "], figsize=(15, 15))\n", + "\n", + "\n", + "#Step 5\n", + "for i in range(len(selected_images)):\n", + " img = selected_images[i]\n", + " filename = df_pathmnist.iloc[img]['train0_0.png']\n", + " img_class = df_pathmnist.iloc[img]['0']\n", + "\n", + "\n", + " path_img = mpimg.imread(f'./medmnist/dataset/pathmnist/{filename}')\n", + "\n", + "\n", + " ax[f'img{i}'].imshow(path_img)\n", + " ax[f'img{i}'].axis('off')\n", + " ax[f'img{i}'].set_title(f'Class {img_class}')\n", + "\n", + "\n", + "#Step 6\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "c18e375e", + "metadata": {}, + "source": [ + "Let’s quickly go over what exactly this code is doing.\n", + "1. We import all of the necessary libraries, such as matplotlib(which we discussed earlier) and pandas, which is a Python library that provides methods for data manipulation. \n", + "2. The file paths for the PathMNIST images are read and stored in the df_pathmnist variable. \n", + "3. We initialize the selected_images variable which stores an array of integers. These integers represent the indices of the images from the pathmnist dataset we want to display. You can also try changing some of these values to see the different displayed plots and see more images in the dataset. \n", + "4. We create a 5x5 grid of subplots to display our 25 images.\n", + "5. We iterate through the selected_images array and read the corresponding image files. Then, we display the images in the proper subplots.\n", + "6. Finally, plt.show() displays the plot we have created. \n", + "\n", + "Your resulting plot should have an assortment of images from the PathMNIST set including images from all of class 0-8.\n", + "\n", + "Let’s quickly go over what these different classes are by using the results above:\n", + "\n", + "Class 0: Adipose\n", + "Adipose tissue is just tissue that stores fat. This tissue is made up of adipocytes, or fat cells, which store energy.\n", + "\n", + "\n", + "\n", + "Class 1: Background\n", + "The background class represents the non-tissue areas of the image that aren’t necessarily areas of interest.\n", + "\n", + "\n", + "\n", + "Class 2: Debris\n", + "Class 2 contains images of miscellaneous non-living particles or materials found in the colon.\n", + "\n", + "\n", + "\n", + "Class 3: Lymphocytes \n", + "Class 4 contains images of lymphocytes. Lymphocytes are a type of white blood cell that play a significant role in the immune system.\n", + "\n", + "\n", + "\n", + "Class 4: Mucus\n", + "Class 4 contains images of normal mucus that is found in healthy colons.\n", + "\n", + "\n", + "\n", + "\n", + "Class 5: Smooth Muscle\n", + "Class 5 contains images of smooth muscle tissue that is seen in the walls of the colon.\n", + "\n", + "\n", + "\n", + "Class 6: Normal Colon Mucosa\n", + "Class 6 contains images of the colon mucosa, which lines the colon.\n", + "\n", + "\n", + "\n", + "\n", + "Class 7: Cancer-Associated Stroma\n", + "Class 7 contains images of stroma, which is supportive tissue that provides tumors with nutrients and protection to assist in the cancer’s survival.\n", + "\n", + "\n", + "\n", + "\n", + "Class 8: Colorectal Adenocarcinoma Epithelium\n", + "The epithelium is the tissue that lines the colon, and Class 8 contains images of epithelial cells affected by colorectal adenocarcinoma, a type of cancer.\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "5195c707", + "metadata": {}, + "source": [ + "Now, on to training! Since there is only one GPU, let's set CUDA_VISIBLE_DEVICES to 0 to train on the first (and only) available GPU. The way to execute this code will vary based on what you are running your code on.\n", + "\n", + "On Colab run this Python code: \n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "2afcc3d0", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"]=\"0\"" + ] + }, + { + "cell_type": "markdown", + "id": "91a977dc", + "metadata": {}, + "source": [ + "If you are following these instructions on your own command line interface, instead run the following: \n", + "\n", + "export \"CUDA_VISIBLE_DEVICES\"=\"0\"" + ] + }, + { + "cell_type": "markdown", + "id": "8a2d6e30", + "metadata": {}, + "source": [ + "Let's run the training script! For this run, we will pass in the config.yaml file that we just downloaded to the -c parameter, the training and validation CSV files to the -i parameter, and the model directory to the -m parameter (folder will automatically be created if it doesn't exist, which, in our case, it doesn't). We will also specify -t True to indicate that we are training and -d cuda to indicate that we will be training on the GPU. For demonstration purposes, we will only be training on 5 epochs. The number of epochs is the number of times that the model will pass through the entire training dataset during the training process. In our case, the model will pass through the dataset 5 times. \n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "f01f2dab", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "python: can't open file '/content/GaNDLF/gandlf_run': [Errno 2] No such file or directory\r\n" + ] + } + ], + "source": [ + "!python /content/GaNDLF/gandlf_run -c /content/config.yaml -i /content/medmnist/dataset/train_path_full.csv,/content/medmnist/dataset/val_path_full.csv -m /content/model/ -t True -d cuda\n" + ] + }, + { + "cell_type": "markdown", + "id": "7a508061", + "metadata": {}, + "source": [ + "\n", + "You will likely notice a persistent error saying \"y_pred contains classes not in y_true\"--this is a known issue and will not affect our training performance, so feel free to ignore it.\n", + "\n", + "If your program stops for any reason and you try to run it again, you may see this error:\n", + "ValueError: The parameters are not the same as the ones stored in the previous run, please re-check.\n", + "To resolve this, delete the existing model by deleting the “model” file and then try executing the command again. \n", + "\n", + "Potential Google Colab Error: If your Google Colab notebook is not correctly using the GPU, the program may run out of RAM and stop during the process of constructing the queue for training data. \n", + "\n", + "Now that training is complete, let's collect and save model statistics to the output_stats folder. Using -c True indicates that we'd like the 4 plots ordinarily generated by this command to be combined into two plots by overlaying training and validation statistics on the same graphs instead of keeping them separate. Feel free to experiment with this command by using -c False instead and viewing the resulting plots.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "aaa90885", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "python: can't open file '/content/gandlf_collectStats_final': [Errno 2] No such file or directory\r\n" + ] + } + ], + "source": [ + "!python /content/gandlf_collectStats_final -m /content/model/ -o /content/output_stats -c True" + ] + }, + { + "cell_type": "markdown", + "id": "5840544b", + "metadata": {}, + "source": [ + "Now, let's view our generated plots! Make sure to enter the Python shell if you are working in the command line interface.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "85a53674", + "metadata": {}, + "outputs": [ + { + "ename": "FileNotFoundError", + "evalue": "No such file or directory: '/content/output_stats/plot.png'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "File \u001b[0;32m~/anaconda3/lib/python3.10/site-packages/IPython/core/display.py:1045\u001b[0m, in \u001b[0;36mImage._data_and_metadata\u001b[0;34m(self, always_both)\u001b[0m\n\u001b[1;32m 1044\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m-> 1045\u001b[0m b64_data \u001b[38;5;241m=\u001b[39m \u001b[43mb2a_base64\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdata\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241m.\u001b[39mdecode(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mascii\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m 1046\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n", + "\u001b[0;31mTypeError\u001b[0m: a bytes-like object is required, not 'str'", + "\nThe above exception was the direct cause of the following exception:\n", + "\u001b[0;31mFileNotFoundError\u001b[0m Traceback (most recent call last)", + "File \u001b[0;32m~/anaconda3/lib/python3.10/site-packages/IPython/core/formatters.py:972\u001b[0m, in \u001b[0;36mMimeBundleFormatter.__call__\u001b[0;34m(self, obj, include, exclude)\u001b[0m\n\u001b[1;32m 969\u001b[0m method \u001b[38;5;241m=\u001b[39m get_real_method(obj, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mprint_method)\n\u001b[1;32m 971\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m method \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 972\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mmethod\u001b[49m\u001b[43m(\u001b[49m\u001b[43minclude\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minclude\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mexclude\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mexclude\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 973\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 974\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n", + "File \u001b[0;32m~/anaconda3/lib/python3.10/site-packages/IPython/core/display.py:1035\u001b[0m, in \u001b[0;36mImage._repr_mimebundle_\u001b[0;34m(self, include, exclude)\u001b[0m\n\u001b[1;32m 1033\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39membed:\n\u001b[1;32m 1034\u001b[0m mimetype \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_mimetype\n\u001b[0;32m-> 1035\u001b[0m data, metadata \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_data_and_metadata\u001b[49m\u001b[43m(\u001b[49m\u001b[43malways_both\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[1;32m 1036\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m metadata:\n\u001b[1;32m 1037\u001b[0m metadata \u001b[38;5;241m=\u001b[39m {mimetype: metadata}\n", + "File \u001b[0;32m~/anaconda3/lib/python3.10/site-packages/IPython/core/display.py:1047\u001b[0m, in \u001b[0;36mImage._data_and_metadata\u001b[0;34m(self, always_both)\u001b[0m\n\u001b[1;32m 1045\u001b[0m b64_data \u001b[38;5;241m=\u001b[39m b2a_base64(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdata)\u001b[38;5;241m.\u001b[39mdecode(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mascii\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m 1046\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[0;32m-> 1047\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mFileNotFoundError\u001b[39;00m(\n\u001b[1;32m 1048\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mNo such file or directory: \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m%\u001b[39m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdata)) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01me\u001b[39;00m\n\u001b[1;32m 1049\u001b[0m md \u001b[38;5;241m=\u001b[39m {}\n\u001b[1;32m 1050\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmetadata:\n", + "\u001b[0;31mFileNotFoundError\u001b[0m: No such file or directory: '/content/output_stats/plot.png'" + ] + }, + { + "ename": "FileNotFoundError", + "evalue": "No such file or directory: '/content/output_stats/plot.png'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "File \u001b[0;32m~/anaconda3/lib/python3.10/site-packages/IPython/core/display.py:1045\u001b[0m, in \u001b[0;36mImage._data_and_metadata\u001b[0;34m(self, always_both)\u001b[0m\n\u001b[1;32m 1044\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m-> 1045\u001b[0m b64_data \u001b[38;5;241m=\u001b[39m \u001b[43mb2a_base64\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdata\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241m.\u001b[39mdecode(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mascii\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m 1046\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n", + "\u001b[0;31mTypeError\u001b[0m: a bytes-like object is required, not 'str'", + "\nThe above exception was the direct cause of the following exception:\n", + "\u001b[0;31mFileNotFoundError\u001b[0m Traceback (most recent call last)", + "File \u001b[0;32m~/anaconda3/lib/python3.10/site-packages/IPython/core/formatters.py:342\u001b[0m, in \u001b[0;36mBaseFormatter.__call__\u001b[0;34m(self, obj)\u001b[0m\n\u001b[1;32m 340\u001b[0m method \u001b[38;5;241m=\u001b[39m get_real_method(obj, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mprint_method)\n\u001b[1;32m 341\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m method \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 342\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mmethod\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 343\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 344\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n", + "File \u001b[0;32m~/anaconda3/lib/python3.10/site-packages/IPython/core/display.py:1067\u001b[0m, in \u001b[0;36mImage._repr_png_\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 1065\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_repr_png_\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[1;32m 1066\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39membed \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mformat \u001b[38;5;241m==\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_FMT_PNG:\n\u001b[0;32m-> 1067\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_data_and_metadata\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/lib/python3.10/site-packages/IPython/core/display.py:1047\u001b[0m, in \u001b[0;36mImage._data_and_metadata\u001b[0;34m(self, always_both)\u001b[0m\n\u001b[1;32m 1045\u001b[0m b64_data \u001b[38;5;241m=\u001b[39m b2a_base64(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdata)\u001b[38;5;241m.\u001b[39mdecode(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mascii\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m 1046\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[0;32m-> 1047\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mFileNotFoundError\u001b[39;00m(\n\u001b[1;32m 1048\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mNo such file or directory: \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m%\u001b[39m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdata)) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01me\u001b[39;00m\n\u001b[1;32m 1049\u001b[0m md \u001b[38;5;241m=\u001b[39m {}\n\u001b[1;32m 1050\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmetadata:\n", + "\u001b[0;31mFileNotFoundError\u001b[0m: No such file or directory: '/content/output_stats/plot.png'" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.display import Image\n", + "Image(\"/content/output_stats/plot.png\", width=1500, height=1000)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "3a823e40", + "metadata": {}, + "source": [ + "Your results should show both an Accuracy Plot and a Loss Plot.\n", + "\n", + "Since we only trained the model on a very small number of epochs, we shouldn't be expecting very impressive results here. However, from the graphs, we can tell that accuracy is steadily increasing and loss is steadily decreasing, which is a great sign.\n", + "\n", + "Finally, let's run the inference script. This is almost identical to running the training script; however, note that the argument for the -t parameter has been changed from True to False to specify that we are not training, and we are using the test_path_full csv file to access the testing images.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "2ba2b24a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "python: can't open file '/content/GaNDLF/gandlf_run': [Errno 2] No such file or directory\r\n" + ] + } + ], + "source": [ + "!python /content/GaNDLF/gandlf_run -c /content/config.yaml -i /content/medmnist/dataset/test_path_full.csv -m /content/model/ -t False -d cuda" + ] + }, + { + "cell_type": "markdown", + "id": "b3e630c0", + "metadata": {}, + "source": [ + "Now that inference is complete, let's view some sample test images along with their predicted and ground truth classes to get a visual idea of how well our model did on each class. Remember to enter the Python shell if you are using the command line interface." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "6c2dbdf6", + "metadata": {}, + "outputs": [ + { + "ename": "FileNotFoundError", + "evalue": "[Errno 2] No such file or directory: './model/final_preds_and_avg_probs.csv'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mFileNotFoundError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[33], line 6\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mmatplotlib\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mimage\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m \u001b[38;5;21;01mmpimg\u001b[39;00m\n\u001b[1;32m 3\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mpandas\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m \u001b[38;5;21;01mpd\u001b[39;00m\n\u001b[0;32m----> 6\u001b[0m df_preds \u001b[38;5;241m=\u001b[39m \u001b[43mpd\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mread_csv\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43m./model/final_preds_and_avg_probs.csv\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 9\u001b[0m selected_images \u001b[38;5;241m=\u001b[39m [\u001b[38;5;241m4\u001b[39m, \u001b[38;5;241m7\u001b[39m, \u001b[38;5;241m14\u001b[39m, \u001b[38;5;241m22\u001b[39m, \u001b[38;5;241m26\u001b[39m, \u001b[38;5;241m3\u001b[39m, \u001b[38;5;241m11\u001b[39m, \u001b[38;5;241m17\u001b[39m, \u001b[38;5;241m37\u001b[39m, \u001b[38;5;241m45\u001b[39m, \u001b[38;5;241m52\u001b[39m, \u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m2\u001b[39m, \u001b[38;5;241m40\u001b[39m, \u001b[38;5;241m47\u001b[39m, \u001b[38;5;241m76\u001b[39m, \u001b[38;5;241m8\u001b[39m, \u001b[38;5;241m13\u001b[39m, \u001b[38;5;241m28\u001b[39m, \u001b[38;5;241m19\u001b[39m, \u001b[38;5;241m36\u001b[39m, \u001b[38;5;241m79\u001b[39m, \u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m9\u001b[39m, \u001b[38;5;241m10\u001b[39m]\n\u001b[1;32m 12\u001b[0m fig, ax \u001b[38;5;241m=\u001b[39m plt\u001b[38;5;241m.\u001b[39msubplot_mosaic([\n\u001b[1;32m 13\u001b[0m [\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mimg0\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mimg1\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mimg2\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mimg3\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mimg4\u001b[39m\u001b[38;5;124m'\u001b[39m],\n\u001b[1;32m 14\u001b[0m [\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mimg5\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mimg6\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mimg7\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mimg8\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mimg9\u001b[39m\u001b[38;5;124m'\u001b[39m],\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 17\u001b[0m [\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mimg20\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mimg21\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mimg22\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mimg23\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mimg24\u001b[39m\u001b[38;5;124m'\u001b[39m]\n\u001b[1;32m 18\u001b[0m ], figsize\u001b[38;5;241m=\u001b[39m(\u001b[38;5;241m13\u001b[39m, \u001b[38;5;241m13\u001b[39m), constrained_layout \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m)\n", + "File \u001b[0;32m~/anaconda3/lib/python3.10/site-packages/pandas/util/_decorators.py:211\u001b[0m, in \u001b[0;36mdeprecate_kwarg.._deprecate_kwarg..wrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 209\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 210\u001b[0m kwargs[new_arg_name] \u001b[38;5;241m=\u001b[39m new_arg_value\n\u001b[0;32m--> 211\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/lib/python3.10/site-packages/pandas/util/_decorators.py:331\u001b[0m, in \u001b[0;36mdeprecate_nonkeyword_arguments..decorate..wrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 325\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(args) \u001b[38;5;241m>\u001b[39m num_allow_args:\n\u001b[1;32m 326\u001b[0m warnings\u001b[38;5;241m.\u001b[39mwarn(\n\u001b[1;32m 327\u001b[0m msg\u001b[38;5;241m.\u001b[39mformat(arguments\u001b[38;5;241m=\u001b[39m_format_argument_list(allow_args)),\n\u001b[1;32m 328\u001b[0m \u001b[38;5;167;01mFutureWarning\u001b[39;00m,\n\u001b[1;32m 329\u001b[0m stacklevel\u001b[38;5;241m=\u001b[39mfind_stack_level(),\n\u001b[1;32m 330\u001b[0m )\n\u001b[0;32m--> 331\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/lib/python3.10/site-packages/pandas/io/parsers/readers.py:950\u001b[0m, in \u001b[0;36mread_csv\u001b[0;34m(filepath_or_buffer, sep, delimiter, header, names, index_col, usecols, squeeze, prefix, mangle_dupe_cols, dtype, engine, converters, true_values, false_values, skipinitialspace, skiprows, skipfooter, nrows, na_values, keep_default_na, na_filter, verbose, skip_blank_lines, parse_dates, infer_datetime_format, keep_date_col, date_parser, dayfirst, cache_dates, iterator, chunksize, compression, thousands, decimal, lineterminator, quotechar, quoting, doublequote, escapechar, comment, encoding, encoding_errors, dialect, error_bad_lines, warn_bad_lines, on_bad_lines, delim_whitespace, low_memory, memory_map, float_precision, storage_options)\u001b[0m\n\u001b[1;32m 935\u001b[0m kwds_defaults \u001b[38;5;241m=\u001b[39m _refine_defaults_read(\n\u001b[1;32m 936\u001b[0m dialect,\n\u001b[1;32m 937\u001b[0m delimiter,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 946\u001b[0m defaults\u001b[38;5;241m=\u001b[39m{\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdelimiter\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m,\u001b[39m\u001b[38;5;124m\"\u001b[39m},\n\u001b[1;32m 947\u001b[0m )\n\u001b[1;32m 948\u001b[0m kwds\u001b[38;5;241m.\u001b[39mupdate(kwds_defaults)\n\u001b[0;32m--> 950\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_read\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfilepath_or_buffer\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/lib/python3.10/site-packages/pandas/io/parsers/readers.py:605\u001b[0m, in \u001b[0;36m_read\u001b[0;34m(filepath_or_buffer, kwds)\u001b[0m\n\u001b[1;32m 602\u001b[0m _validate_names(kwds\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnames\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28;01mNone\u001b[39;00m))\n\u001b[1;32m 604\u001b[0m \u001b[38;5;66;03m# Create the parser.\u001b[39;00m\n\u001b[0;32m--> 605\u001b[0m parser \u001b[38;5;241m=\u001b[39m \u001b[43mTextFileReader\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfilepath_or_buffer\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 607\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m chunksize \u001b[38;5;129;01mor\u001b[39;00m iterator:\n\u001b[1;32m 608\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m parser\n", + "File \u001b[0;32m~/anaconda3/lib/python3.10/site-packages/pandas/io/parsers/readers.py:1442\u001b[0m, in \u001b[0;36mTextFileReader.__init__\u001b[0;34m(self, f, engine, **kwds)\u001b[0m\n\u001b[1;32m 1439\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39moptions[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mhas_index_names\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m kwds[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mhas_index_names\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n\u001b[1;32m 1441\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhandles: IOHandles \u001b[38;5;241m|\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m-> 1442\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_engine \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_make_engine\u001b[49m\u001b[43m(\u001b[49m\u001b[43mf\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mengine\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/lib/python3.10/site-packages/pandas/io/parsers/readers.py:1735\u001b[0m, in \u001b[0;36mTextFileReader._make_engine\u001b[0;34m(self, f, engine)\u001b[0m\n\u001b[1;32m 1733\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mb\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m mode:\n\u001b[1;32m 1734\u001b[0m mode \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mb\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m-> 1735\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhandles \u001b[38;5;241m=\u001b[39m \u001b[43mget_handle\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 1736\u001b[0m \u001b[43m \u001b[49m\u001b[43mf\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1737\u001b[0m \u001b[43m \u001b[49m\u001b[43mmode\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1738\u001b[0m \u001b[43m \u001b[49m\u001b[43mencoding\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mencoding\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1739\u001b[0m \u001b[43m \u001b[49m\u001b[43mcompression\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mcompression\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1740\u001b[0m \u001b[43m \u001b[49m\u001b[43mmemory_map\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mmemory_map\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1741\u001b[0m \u001b[43m \u001b[49m\u001b[43mis_text\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mis_text\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1742\u001b[0m \u001b[43m \u001b[49m\u001b[43merrors\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mencoding_errors\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mstrict\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1743\u001b[0m \u001b[43m \u001b[49m\u001b[43mstorage_options\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mstorage_options\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1744\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1745\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhandles \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 1746\u001b[0m f \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhandles\u001b[38;5;241m.\u001b[39mhandle\n", + "File \u001b[0;32m~/anaconda3/lib/python3.10/site-packages/pandas/io/common.py:856\u001b[0m, in \u001b[0;36mget_handle\u001b[0;34m(path_or_buf, mode, encoding, compression, memory_map, is_text, errors, storage_options)\u001b[0m\n\u001b[1;32m 851\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(handle, \u001b[38;5;28mstr\u001b[39m):\n\u001b[1;32m 852\u001b[0m \u001b[38;5;66;03m# Check whether the filename is to be opened in binary mode.\u001b[39;00m\n\u001b[1;32m 853\u001b[0m \u001b[38;5;66;03m# Binary mode does not support 'encoding' and 'newline'.\u001b[39;00m\n\u001b[1;32m 854\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m ioargs\u001b[38;5;241m.\u001b[39mencoding \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mb\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m ioargs\u001b[38;5;241m.\u001b[39mmode:\n\u001b[1;32m 855\u001b[0m \u001b[38;5;66;03m# Encoding\u001b[39;00m\n\u001b[0;32m--> 856\u001b[0m handle \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mopen\u001b[39;49m\u001b[43m(\u001b[49m\n\u001b[1;32m 857\u001b[0m \u001b[43m \u001b[49m\u001b[43mhandle\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 858\u001b[0m \u001b[43m \u001b[49m\u001b[43mioargs\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmode\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 859\u001b[0m \u001b[43m \u001b[49m\u001b[43mencoding\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mioargs\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mencoding\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 860\u001b[0m \u001b[43m \u001b[49m\u001b[43merrors\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43merrors\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 861\u001b[0m \u001b[43m \u001b[49m\u001b[43mnewline\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 862\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 863\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 864\u001b[0m \u001b[38;5;66;03m# Binary mode\u001b[39;00m\n\u001b[1;32m 865\u001b[0m handle \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mopen\u001b[39m(handle, ioargs\u001b[38;5;241m.\u001b[39mmode)\n", + "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: './model/final_preds_and_avg_probs.csv'" + ] + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import matplotlib.image as mpimg\n", + "import pandas as pd\n", + "\n", + "\n", + "df_preds = pd.read_csv('./model/final_preds_and_avg_probs.csv')\n", + "\n", + "\n", + "selected_images = [4, 7, 14, 22, 26, 3, 11, 17, 37, 45, 52, 1, 2, 40, 47, 76, 8, 13, 28, 19, 36, 79, 0, 9, 10]\n", + "\n", + "\n", + "fig, ax = plt.subplot_mosaic([\n", + " ['img0', 'img1', 'img2', 'img3', 'img4'],\n", + " ['img5', 'img6', 'img7', 'img8', 'img9'],\n", + " ['img10', 'img11', 'img12', 'img13', 'img14'],\n", + " ['img15', 'img16', 'img17', 'img18', 'img19'],\n", + " ['img20', 'img21', 'img22', 'img23', 'img24']\n", + "], figsize=(13, 13), constrained_layout = True)\n", + "\n", + "\n", + "for i in range(len(selected_images)):\n", + " img = selected_images[i]\n", + " filename = df_preds.iloc[img]['SubjectID']\n", + " ground_truth = filename.split('_')[1].split('.')[0]\n", + " pred_class = df_preds.iloc[img]['PredictedClass']\n", + "\n", + " path_img = mpimg.imread(f'./medmnist/dataset/pathmnist/{filename}')\n", + "\n", + "\n", + " ax[f'img{i}'].imshow(path_img)\n", + " ax[f'img{i}'].axis('off')\n", + " ax[f'img{i}'].set_title(f'Predicted Class: {pred_class}\\nGround . Truth: {ground_truth}')\n", + "\n", + "\n", + "plt.show()\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "9268f2ca", + "metadata": {}, + "source": [ + "Your produced plot should contain 16 images from the PathMNIST set, and each image should be accompanied by both a Predicted Class and a Ground Truth label. \n", + "\n", + "We can see that our model did a decent job of making predictions. However, we can see that it has a few common misconceptions. We can see that the model mistook smooth muscle for debris thrice and cancer-associated stroma for debris once. The model also mistook mucus as adipose twice, and it mistook Colorectal Adenocarcinoma Epithelium as Normal Colon Mucosa once.\n", + "\n", + "\n", + "To conclude this tutorial, let's zoom out and take a look at how well our model did as a whole on each class by constructing a confusion matrix from our inference data.\n", + "Note: if you'd like, feel free to change the colormap of the confusion matrix (denoted by \"cmap\" in the cm_display.plot() command) to your liking. Here's a list of some of the most popular colormaps: viridis (default), plasma, inferno, magma, cividis.\n", + "\n", + "Execute the following code in the Python shell: \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b827c049", + "metadata": {}, + "outputs": [], + "source": [ + "import sklearn\n", + "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay\n", + "\n", + "\n", + "gt_list = []\n", + "pred_list = []\n", + "\n", + "\n", + "for i in range(len(df_preds)):\n", + " filename = df_preds.iloc[i]['SubjectID']\n", + "\n", + "\n", + " ground_truth = int(filename.split('_')[1].split('.')[0])\n", + " pred_class = int(df_preds.iloc[i]['PredictedClass'])\n", + "\n", + "\n", + " gt_list.append(ground_truth)\n", + " pred_list.append(pred_class)\n", + "\n", + "\n", + "cm = confusion_matrix(gt_list, pred_list)\n", + "cm_display = ConfusionMatrixDisplay(confusion_matrix = cm)\n", + "\n", + "\n", + "fig, ax = plt.subplots(figsize = (12, 12))\n", + "cm_display.plot(cmap = 'viridis', ax = ax)\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "607a9dd8", + "metadata": {}, + "source": [ + "Let’s quickly go over this code:\n", + "\n", + "1. We import the Scikit-Learn library, and we will be using this library's methods of creating confusion matrices. \n", + "\n", + "2. We create empty lists gt_list and pred_list to store our ground truth and predicted labels respectively.\n", + "\n", + "3. The for loop iterates through df_preds and extracts the ground truth label and the predicted class for each image and then appends the labels to their corresponding lists.\n", + "\n", + "4. We create a confusion matrix from these two lists and then call the plot() method to visualize it with our desired colormap.\n", + "\n", + "5. We display the confusion matrix using plt.show().\n" + ] + }, + { + "cell_type": "markdown", + "id": "dff24079", + "metadata": {}, + "source": [ + "Your resulting plot should be a 9x9 matrix that displays Predicted label vs. True label\n", + "\n", + "In our matrix, larger numbers along the diagonal represent correct classifications. Here, we can see that while the model performed well overall, it had difficulties when it came to images of Class 7, incorrectly predicting a majority of them as belonging to Class 2 instead. We can see a similar trend with images of Class 5, with the model incorrectly predicting most of them as belonging to Class 2.\n", + "\n", + "Given the appearance of the accuracy and loss plots, had we trained on more epochs, we would have expected these results to improve. However, given that we only trained on 5 epochs, these are great results. Indeed, the model did very well on other classes, including Classes 0 and 1.\n", + "\n", + "That concludes this GaNDLF tutorial! Hopefully, this tutorial was helpful to you in understanding how GaNDLF works as well as how to apply it to your own projects. If you need any additional information about GaNDLF's usage and capabilities, please consult the GitHub repo (https://github.com/CBICA/GaNDLF) and the documentation (https://cbica.github.io/GaNDLF/). For more questions and support, please visit the Discussions page on GitHub (https://github.com/CBICA/GaNDLF/discussions)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8f91563c", + "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.10.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From c181cdaed28190b6811339d20641a1c65413726f Mon Sep 17 00:00:00 2001 From: vavali08 <119764082+vavali08@users.noreply.github.com> Date: Wed, 26 Jul 2023 12:22:29 -0400 Subject: [PATCH 02/15] Rename --- .../{GANDLF tutorial.ipynb => classification_tutorial.ipynb} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename tutorials/{GANDLF tutorial.ipynb => classification_tutorial.ipynb} (100%) diff --git a/tutorials/GANDLF tutorial.ipynb b/tutorials/classification_tutorial.ipynb similarity index 100% rename from tutorials/GANDLF tutorial.ipynb rename to tutorials/classification_tutorial.ipynb From 2f3a2251c2a2bca13792e2aae14107ee5f3e5175 Mon Sep 17 00:00:00 2001 From: vavali08 <119764082+vavali08@users.noreply.github.com> Date: Wed, 26 Jul 2023 12:25:47 -0400 Subject: [PATCH 03/15] Delete classification_tutorial.ipynb --- tutorials/classification_tutorial.ipynb | 1354 ----------------------- 1 file changed, 1354 deletions(-) delete mode 100644 tutorials/classification_tutorial.ipynb diff --git a/tutorials/classification_tutorial.ipynb b/tutorials/classification_tutorial.ipynb deleted file mode 100644 index 3f4327be1..000000000 --- a/tutorials/classification_tutorial.ipynb +++ /dev/null @@ -1,1354 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "1cc4fdb8-18de-4128-8ec1-b0ba70f4a934", - "metadata": {}, - "source": [ - "In this tutorial, we will be using the Generally Nuanced Deep Learning Framework (GaNDLF) to perform training and inference on a VGG model with PathMNIST, a dataset of colon pathology images. This is a multi-class classification task: there are 9 different types of colon tissue displayed in the pathology images, each represented by its own class." - ] - }, - { - "cell_type": "markdown", - "id": "61838af7", - "metadata": {}, - "source": [ - "The VGG model is a CNN architecture mostly known for simplicity and effectiveness in image classification and has been used in object recognition, face detection, and medical image analysis. \n", - "Its most notable features include its use of 16-19 weight layers and small 3x3 filters which allow for better performance and faster training times.\n", - "\n" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "id": "4e77f51e", - "metadata": {}, - "source": [ - "![VGG Model Image](https://d3i71xaburhd42.cloudfront.net/dae981902b1f6d869ef2d047612b90cdbe43fd1e/2-Figure1-1.png)" - ] - }, - { - "cell_type": "markdown", - "id": "b99da8e5", - "metadata": {}, - "source": [ - "Figure 1 - Display of VGG Architecture - Visualizing and Comparing AlexNet and VGG using Deconvolutional Layers (W. Yu)\n", - "\n", - "For more information on the model, refer to the paper Very Deep Convolutional Networks for Large-Scale Image Recognition by Karen Simonyan and Andrew Zisserman\n" - ] - }, - { - "cell_type": "markdown", - "id": "b0645481", - "metadata": {}, - "source": [ - "This tutorial demonstrates how to use GaNDLF with a simple classification task. Some steps that would ordinarily be part of the workflow (e.g. data CSV and config YAML file construction) have already been performed for simplicity; please refer to the GaNDLF documentation (located at https://cbica.github.io/GaNDLF/) for more information regarding replication of these steps.\n", - "\n", - "Command-Line Interface Note: Make sure you have Python installed before proceeding! Visit python.org/downloads for instructions on how do to this. Downloading version 3.7 is sufficient to complete this tutorial since this aligns with the version in Google Colab. \n", - "\n", - "Google Colab Note: Before continuing with this tutorial, please ensure that you are connected to the GPU by navigating to Runtime --> Change Runtime Type --> Hardware Accelerator and verifying that \"GPU\" is listed as the selected option. If not, it is highly recommended that you switch to it now. Also, if available, select the \"High-RAM\" option under Runtime → Change Runtime Type → Runtime Shape. Without this option selected, you may end up running out of RAM during training on a base notebook. \n", - "\n", - "Error Note: However, an error message may come up that says “You are connected to the GPU Runtime, but not utilizing the GPU.” This causes the program to stop when training the model because the program runs out of RAM.\n", - "\n", - "\n", - "Let's get started! First, we will clone the GaNDLF repo.\n", - "\n", - "Google Colab Note: Because the default version of Python in Colab (3.7) is not supported by the NumPy version used in the current version of GaNDLF, we will be cloning an earlier tag of the GaNDLF repo for this tutorial.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "adc51dd9", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fatal: destination path 'GaNDLF' already exists and is not an empty directory.\r\n" - ] - } - ], - "source": [ - "!git clone -b 0.0.14 --depth 1 https://github.com/CBICA/GaNDLF.git" - ] - }, - { - "cell_type": "markdown", - "id": "634c8e7b", - "metadata": {}, - "source": [ - "The -b option indicates which branch we want to clone, and –depth 1 specifies the number of commits(or versions of the repository) that we want to retrieve. In this case, we are only retrieving one to save space and time, and since we are not making any changes to the actual GaNDLF code, this is sufficient." - ] - }, - { - "cell_type": "markdown", - "id": "0c62a49b", - "metadata": {}, - "source": [ - "Let's navigate to the newly created GaNDLF directory using the cd(change directory) command.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "4e4cb90b", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "/Users/vedhaavali/GaNDLF/GANDLF\n" - ] - } - ], - "source": [ - "%cd GaNDLF\n" - ] - }, - { - "cell_type": "markdown", - "id": "18faa97d", - "metadata": {}, - "source": [ - "Now, we'll install the appropriate version of PyTorch for use with GaNDLF. Pytorch is a machine learning framework primarily used for deep learning, and we will be using it here.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "51f0bdf8", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Looking in indexes: https://pypi.org/simple, https://download.pytorch.org/whl/lts/1.8/cu111\n", - "\u001b[31mERROR: Could not find a version that satisfies the requirement torch==1.8.2 (from versions: 1.11.0, 1.12.0, 1.12.1, 1.13.0, 1.13.1, 2.0.0, 2.0.1)\u001b[0m\u001b[31m\n", - "\u001b[0m\u001b[31mERROR: No matching distribution found for torch==1.8.2\u001b[0m\u001b[31m\n", - "\u001b[0m" - ] - } - ], - "source": [ - "!pip3 install torch==1.8.2 torchvision==0.9.2 torchaudio==0.8.2 --extra-index-url https://download.pytorch.org/whl/lts/1.8/cu111\n" - ] - }, - { - "cell_type": "markdown", - "id": "f60e51b7", - "metadata": {}, - "source": [ - "pip is Python’s package manager that allows us to easily download different Python packages from the internet. If you do not have pip installed, visit pip.pypa.io/en/stable/installation/ for instructions.\n" - ] - }, - { - "cell_type": "markdown", - "id": "59aa00d9", - "metadata": {}, - "source": [ - "Google Colab Error Note: You might see an error that says:\n", - "​​ERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts. torchtext 0.14.1 requires torch==1.13.1, but you have torch 1.8.2+cu111 which is incompatible.\n", - "The next few cells may also have similar errors of the same form mentioning “pip’s dependency resolver” and version incompatibility, but GaNDLF installation will still be successful despite this, as we will see when verifying the installation." - ] - }, - { - "cell_type": "markdown", - "id": "1a79edc1", - "metadata": {}, - "source": [ - "Next, let's install OpenVINO, which is used by GaNDLF to generate optimized models for inference.\n", - "\n", - "OpenVINO is a toolkit developed by Intel that allows for easier optimization of deep learning models in situations where access to computing resources may be limited. The model optimizes computation and memory usage while providing hardware-specific optimizations. OpenVINO currently supports over 68 different image classification models, allowing for flexibility of use with GaNDLF.\n", - "\n", - "Visit docs.openvino.ai for more information.\n" - ] - }, - { - "cell_type": "markdown", - "id": "4eee3270", - "metadata": {}, - "source": [ - "We’ll need to install Matplotlib v.3.5.0 for use in plotting our results, for this version includes all of the features that we will be using later on. Let's do that now!\n" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "e63124bb", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Collecting matplotlib==3.5.0\n", - " Downloading matplotlib-3.5.0-cp310-cp310-macosx_11_0_arm64.whl (7.2 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m7.2/7.2 MB\u001b[0m \u001b[31m11.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m00:01\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: fonttools>=4.22.0 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from matplotlib==3.5.0) (4.25.0)\n", - "Requirement already satisfied: kiwisolver>=1.0.1 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from matplotlib==3.5.0) (1.4.4)\n", - "Requirement already satisfied: numpy>=1.17 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from matplotlib==3.5.0) (1.23.5)\n", - "Requirement already satisfied: cycler>=0.10 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from matplotlib==3.5.0) (0.11.0)\n", - "Requirement already satisfied: python-dateutil>=2.7 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from matplotlib==3.5.0) (2.8.2)\n", - "Requirement already satisfied: pyparsing>=2.2.1 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from matplotlib==3.5.0) (3.0.9)\n", - "Requirement already satisfied: packaging>=20.0 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from matplotlib==3.5.0) (22.0)\n", - "Requirement already satisfied: pillow>=6.2.0 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from matplotlib==3.5.0) (9.4.0)\n", - "Collecting setuptools-scm>=4\n", - " Downloading setuptools_scm-7.1.0-py3-none-any.whl (43 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m43.8/43.8 kB\u001b[0m \u001b[31m1.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: six>=1.5 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from python-dateutil>=2.7->matplotlib==3.5.0) (1.16.0)\n", - "Requirement already satisfied: setuptools in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from setuptools-scm>=4->matplotlib==3.5.0) (65.6.3)\n", - "Requirement already satisfied: tomli>=1.0.0 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from setuptools-scm>=4->matplotlib==3.5.0) (2.0.1)\n", - "Requirement already satisfied: typing-extensions in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from setuptools-scm>=4->matplotlib==3.5.0) (4.4.0)\n", - "Installing collected packages: setuptools-scm, matplotlib\n", - " Attempting uninstall: matplotlib\n", - " Found existing installation: matplotlib 3.7.0\n", - " Uninstalling matplotlib-3.7.0:\n", - " Successfully uninstalled matplotlib-3.7.0\n", - "Successfully installed matplotlib-3.5.0 setuptools-scm-7.1.0\n" - ] - } - ], - "source": [ - "!pip install matplotlib==3.5.0\n" - ] - }, - { - "cell_type": "markdown", - "id": "ed63ccf0", - "metadata": {}, - "source": [ - "Matplotlib is a library that allows us to create different types of data visualizations in Python. We will go over some of the specific features when we utilize it later on. Visit matplotlib.org for more information.\n", - "\n", - "Google Colab Note: To be able to use the newly installed version of Matplotlib for plotting, go ahead and click the small gray \"RESTART RUNTIME\" button in the output directly above this code cell, and then continue with this tutorial once the restart process is complete.\n", - "\n", - "\n", - "Now, ensure you are still in the GaNDLF directory before proceeding. Otherwise, run the following command. \n" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "5abebbed", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[Errno 2] No such file or directory: 'GaNDLF'\n", - "/Users/vedhaavali/GaNDLF/GANDLF\n" - ] - } - ], - "source": [ - "%cd GaNDLF\n" - ] - }, - { - "cell_type": "markdown", - "id": "5aa72043", - "metadata": {}, - "source": [ - "For the last of our GaNDLF-related installations, let's install all required packages for GaNDLF.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "8db908ae", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Obtaining file:///Users/vedhaavali/GaNDLF/GANDLF\r\n", - "\u001b[31mERROR: file:///Users/vedhaavali/GaNDLF/GANDLF does not appear to be a Python project: neither 'setup.py' nor 'pyproject.toml' found.\u001b[0m\u001b[31m\r\n", - "\u001b[0m" - ] - } - ], - "source": [ - "!pip install -e ." - ] - }, - { - "cell_type": "markdown", - "id": "488d9232", - "metadata": {}, - "source": [ - "-e is short for editable, and . indicates that we are installing from the current directory (GaNDLF). Essentially, we are installing the packages in an editable mode because this allows us to change the source code in the packages without having to redownload the packages after we make modifications. \n", - "\n", - "Now, let's use gandlf_verifyInstall to verify our GaNDLF installation. " - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "77bd9e3d", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "python: can't open file '/Users/vedhaavali/GaNDLF/GANDLF/./gandlf_verifyInstall': [Errno 2] No such file or directory\r\n" - ] - } - ], - "source": [ - "!python ./gandlf_verifyInstall\n" - ] - }, - { - "cell_type": "markdown", - "id": "3001d597", - "metadata": {}, - "source": [ - "\n", - "If you see the message, “GaNDLF is ready” after executing the previous step, then all steps have been followed correctly thus far. Let's move on to collecting our data. First, we will install the MedMNIST package in order to obtain the PathMNIST data that we will be using.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "baf27899", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Collecting medmnist\n", - " Downloading medmnist-2.2.2-py3-none-any.whl (21 kB)\n", - "Requirement already satisfied: tqdm in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from medmnist) (4.64.1)\n", - "Collecting fire\n", - " Downloading fire-0.5.0.tar.gz (88 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m88.3/88.3 kB\u001b[0m \u001b[31m1.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0ma \u001b[36m0:00:01\u001b[0m\n", - "\u001b[?25h Preparing metadata (setup.py) ... \u001b[?25ldone\n", - "\u001b[?25hRequirement already satisfied: Pillow in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from medmnist) (9.4.0)\n", - "Collecting torchvision\n", - " Downloading torchvision-0.15.2-cp310-cp310-macosx_11_0_arm64.whl (1.4 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.4/1.4 MB\u001b[0m \u001b[31m5.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m00:01\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: scikit-image in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from medmnist) (0.19.3)\n", - "Requirement already satisfied: scikit-learn in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from medmnist) (1.2.1)\n", - "Requirement already satisfied: torch in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from medmnist) (1.12.1)\n", - "Requirement already satisfied: numpy in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from medmnist) (1.23.5)\n", - "Requirement already satisfied: pandas in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from medmnist) (1.5.3)\n", - "Requirement already satisfied: six in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from fire->medmnist) (1.16.0)\n", - "Collecting termcolor\n", - " Downloading termcolor-2.3.0-py3-none-any.whl (6.9 kB)\n", - "Requirement already satisfied: python-dateutil>=2.8.1 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from pandas->medmnist) (2.8.2)\n", - "Requirement already satisfied: pytz>=2020.1 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from pandas->medmnist) (2022.7)\n", - "Requirement already satisfied: tifffile>=2019.7.26 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from scikit-image->medmnist) (2021.7.2)\n", - "Requirement already satisfied: packaging>=20.0 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from scikit-image->medmnist) (22.0)\n", - "Requirement already satisfied: imageio>=2.4.1 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from scikit-image->medmnist) (2.26.0)\n", - "Requirement already satisfied: scipy>=1.4.1 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from scikit-image->medmnist) (1.10.0)\n", - "Requirement already satisfied: PyWavelets>=1.1.1 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from scikit-image->medmnist) (1.4.1)\n", - "Requirement already satisfied: networkx>=2.2 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from scikit-image->medmnist) (2.8.4)\n", - "Requirement already satisfied: threadpoolctl>=2.0.0 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from scikit-learn->medmnist) (2.2.0)\n", - "Requirement already satisfied: joblib>=1.1.1 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from scikit-learn->medmnist) (1.1.1)\n", - "Requirement already satisfied: typing_extensions in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from torch->medmnist) (4.4.0)\n", - "Collecting torch\n", - " Downloading torch-2.0.1-cp310-none-macosx_11_0_arm64.whl (55.8 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m55.8/55.8 MB\u001b[0m \u001b[31m6.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m00:01\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: requests in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from torchvision->medmnist) (2.28.1)\n", - "Requirement already satisfied: jinja2 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from torch->medmnist) (3.1.2)\n", - "Requirement already satisfied: sympy in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from torch->medmnist) (1.11.1)\n", - "Requirement already satisfied: filelock in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from torch->medmnist) (3.9.0)\n", - "Requirement already satisfied: MarkupSafe>=2.0 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from jinja2->torch->medmnist) (2.1.1)\n", - "Requirement already satisfied: charset-normalizer<3,>=2 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from requests->torchvision->medmnist) (2.0.4)\n", - "Requirement already satisfied: idna<4,>=2.5 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from requests->torchvision->medmnist) (3.4)\n", - "Requirement already satisfied: certifi>=2017.4.17 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from requests->torchvision->medmnist) (2022.12.7)\n", - "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages (from requests->torchvision->medmnist) (1.26.14)\n", - "Requirement already satisfied: mpmath>=0.19 in /Users/vedhaavali/anaconda3/lib/python3.10/site-packages/mpmath-1.2.1-py3.10.egg (from sympy->torch->medmnist) (1.2.1)\n", - "Building wheels for collected packages: fire\n", - " Building wheel for fire (setup.py) ... \u001b[?25ldone\n", - "\u001b[?25h Created wheel for fire: filename=fire-0.5.0-py2.py3-none-any.whl size=116931 sha256=e4fdcf3a8b63eed3ef74683188ea00ea0a79b077de3b67289a6a3e0a87ecd7ce\n", - " Stored in directory: /Users/vedhaavali/Library/Caches/pip/wheels/c4/eb/6a/1c6d2ad660043768e998bdf9c6a28db2f1b7db3a5825d51e87\n", - "Successfully built fire\n", - "Installing collected packages: termcolor, torch, fire, torchvision, medmnist\n", - " Attempting uninstall: torch\n", - " Found existing installation: torch 1.12.1\n", - " Uninstalling torch-1.12.1:\n", - " Successfully uninstalled torch-1.12.1\n", - "Successfully installed fire-0.5.0 medmnist-2.2.2 termcolor-2.3.0 torch-2.0.1 torchvision-0.15.2\n" - ] - } - ], - "source": [ - "!pip install medmnist\n" - ] - }, - { - "cell_type": "markdown", - "id": "22031f46", - "metadata": {}, - "source": [ - "The original MNIST(Modified National Institute of Standards in Technology) database is a database containing various images of handwritten digits, and people use this dataset to train computer programs to recognize digits. MNIST is often used as a benchmark, and researchers can test different machine learning algorithms on MNIST to evaluate their performance.\n", - "MedMNIST is a database of biomedical images with 18 different datasets. \n", - "\n", - "The 2D Datasets are:\n", - "1. PathMNIST(Colon Pathology images)\n", - "2. ChestMNIST(Chest X-Ray images)\n", - "3. DermaMNIST(Dermatoscope images)\n", - "4. OCTMNIST(Retinal OCT images)\n", - "5. PneumoniaMNIST(Chest X-Ray images)\n", - "6. RetinaMNIST(Fundus Camera images)\n", - "7. BreastMNIST(Breast Ultrasound images)\n", - "8. BloodMNIST(Blood Cell Microscope images)\n", - "9. TissueMNIST(Kidney Cortex Microscope images)\n", - "10. - 12. OrganAMNIST, OrganCMNIST, and Organ SMNIST (Abdominal CT images)\n", - "\n", - "The 3D Datasets are:\n", - "1. OrganMNIST3D(Abdominal CT images)\n", - "2. NoduleMNIST3D(Chest CT images)\n", - "3. AdrenalMNIST3D(Shape from Abdominal CT images)\n", - "4. FractureMNIST3D(Chest CT images)\n", - "5. VesselMNIST3D(Shape from Brain MRA images)\n", - "6. SynapseMNIST3D(Electron Microscope images)\n", - "\n", - "Here are some visualizations of the MedMNIST dataset. \n", - "\n" - ] - }, - { - "cell_type": "markdown", - "id": "2eeaf438", - "metadata": {}, - "source": [ - "![MedMNIST visualizations](https://medmnist.com/assets/v2/imgs/overview.jpg)\n" - ] - }, - { - "cell_type": "markdown", - "id": "bc3638aa", - "metadata": {}, - "source": [ - "Figure 2 - MedMNIST datasets - MedMNIST v2 - A large-scale lightweight benchmark for 2D and 3D biomedical image classification (J. Yang)\n", - "\n", - "\n", - "The data is stored in a 28×28 (2D) or 28×28×28 (3D) format, similar to the 28×28 size of the images in the original MNIST dataset. \n", - "\n", - "For more information on MedMNIST and its installation visit github.com/MedMNIST/MedMNIST/ or medmnist.com\n", - "\n", - "For the purposes of this tutorial, we will be focusing on PathMNIST, the colon pathology images. The PathMNIST dataset has a total of 107,180 samples, and these images were taken from the study \"Predicting survival from colorectal cancer histology slides using deep learning: A retrospective multicenter study,\" by Jakob Nikolas Kather, Johannes Krisam, et al.\n", - "\n", - "We will look more closely at the images in this dataset soon. \n", - "\n", - "\n", - "\n", - "Now, let's import MedMNIST and verify the version number before we move on. \n", - "\n", - "Command-Line Interface Note: This is Python code, so to run this, we must enter the Python shell. To do this, type python or python3 in the command prompt and press enter. After executing these commands, type exit() or quit() to exit the Python shell.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "411eb42d", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2.2.2\n" - ] - } - ], - "source": [ - "import medmnist\n", - "print(medmnist.__version__)" - ] - }, - { - "cell_type": "markdown", - "id": "84912c51", - "metadata": {}, - "source": [ - "Time to load our data! Let's download all MedMNIST datasets to the root directory. In this tutorial, we will only be using the PathMNIST dataset; however, feel free to use any of the other datasets you see being downloaded below (which are also mentioned above) to try out GaNDLF for yourself!\n" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "0536b26c", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Downloading pathmnist...\n", - "Downloading https://zenodo.org/record/6496656/files/pathmnist.npz?download=1 to /Users/vedhaavali/.medmnist/pathmnist.npz\n", - "100%|█████████████████████████| 205615438/205615438 [06:57<00:00, 492777.43it/s]\n", - "Downloading chestmnist...\n", - "Downloading https://zenodo.org/record/6496656/files/chestmnist.npz?download=1 to /Users/vedhaavali/.medmnist/chestmnist.npz\n", - " 2%|▍ | 1277952/82802576 [00:03<05:02, 269084.05it/s]^C\n", - " 2%|▍ | 1310720/82802576 [00:03<03:43, 365426.14it/s]\n", - "Traceback (most recent call last):\n", - " File \"/Users/vedhaavali/anaconda3/lib/python3.10/site-packages/medmnist/dataset.py\", line 84, in download\n", - " download_url(url=self.info[\"url\"],\n", - " File \"/Users/vedhaavali/anaconda3/lib/python3.10/site-packages/torchvision/datasets/utils.py\", line 144, in download_url\n", - " _urlretrieve(url, fpath)\n", - " File \"/Users/vedhaavali/anaconda3/lib/python3.10/site-packages/torchvision/datasets/utils.py\", line 48, in _urlretrieve\n", - " _save_response_content(iter(lambda: response.read(chunk_size), b\"\"), filename, length=response.length)\n", - " File \"/Users/vedhaavali/anaconda3/lib/python3.10/site-packages/torchvision/datasets/utils.py\", line 37, in _save_response_content\n", - " for chunk in content:\n", - " File \"/Users/vedhaavali/anaconda3/lib/python3.10/site-packages/torchvision/datasets/utils.py\", line 48, in \n", - " _save_response_content(iter(lambda: response.read(chunk_size), b\"\"), filename, length=response.length)\n", - " File \"/Users/vedhaavali/anaconda3/lib/python3.10/http/client.py\", line 465, in read\n", - " s = self.fp.read(amt)\n", - " File \"/Users/vedhaavali/anaconda3/lib/python3.10/socket.py\", line 705, in readinto\n", - " return self._sock.recv_into(b)\n", - " File \"/Users/vedhaavali/anaconda3/lib/python3.10/ssl.py\", line 1274, in recv_into\n", - " return self.read(nbytes, buffer)\n", - " File \"/Users/vedhaavali/anaconda3/lib/python3.10/ssl.py\", line 1130, in read\n", - " return self._sslobj.read(len, buffer)\n", - "KeyboardInterrupt\n", - "\n", - "During handling of the above exception, another exception occurred:\n", - "\n", - "Traceback (most recent call last):\n", - " File \"/Users/vedhaavali/anaconda3/lib/python3.10/runpy.py\", line 196, in _run_module_as_main\n", - " return _run_code(code, main_globals, None,\n", - " File \"/Users/vedhaavali/anaconda3/lib/python3.10/runpy.py\", line 86, in _run_code\n", - " exec(code, run_globals)\n", - " File \"/Users/vedhaavali/anaconda3/lib/python3.10/site-packages/medmnist/__main__.py\", line 123, in \n", - " fire.Fire()\n", - " File \"/Users/vedhaavali/anaconda3/lib/python3.10/site-packages/fire/core.py\", line 141, in Fire\n", - " component_trace = _Fire(component, args, parsed_flag_args, context, name)\n", - " File \"/Users/vedhaavali/anaconda3/lib/python3.10/site-packages/fire/core.py\", line 475, in _Fire\n", - " component, remaining_args = _CallAndUpdateTrace(\n", - " File \"/Users/vedhaavali/anaconda3/lib/python3.10/site-packages/fire/core.py\", line 691, in _CallAndUpdateTrace\n", - " component = fn(*varargs, **kwargs)\n", - " File \"/Users/vedhaavali/anaconda3/lib/python3.10/site-packages/medmnist/__main__.py\", line 18, in download\n", - " _ = getattr(medmnist, INFO[key]['python_class'])(\n", - " File \"/Users/vedhaavali/anaconda3/lib/python3.10/site-packages/medmnist/dataset.py\", line 35, in __init__\n", - " self.download()\n", - " File \"/Users/vedhaavali/anaconda3/lib/python3.10/site-packages/medmnist/dataset.py\", line 89, in download\n", - " raise RuntimeError('Something went wrong when downloading! ' +\n", - "RuntimeError: Something went wrong when downloading! Go to the homepage to download manually. https://github.com/MedMNIST/MedMNIST/\n" - ] - } - ], - "source": [ - "!python -m medmnist download\n" - ] - }, - { - "cell_type": "markdown", - "id": "6a040293", - "metadata": {}, - "source": [ - "-m stands for module, and this command is saying that we want to access the medmnist module and run the download function from that module.\n", - "\n", - "Before we continue, let's navigate back to the base directory.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "a2cb0640", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "/Users/vedhaavali/GaNDLF\n" - ] - } - ], - "source": [ - "%cd ..\n" - ] - }, - { - "cell_type": "markdown", - "id": "0509cadf", - "metadata": {}, - "source": [ - "Now, let's save all PathMNIST pathology images within the dataset folder (located inside the medmnist directory) in PNG format for use in training and inference.\n", - "If you've already gone through this tutorial and are looking to try using a different MedMNIST dataset, simply change --flag=pathmnist to any of the other datasets that were downloaded above—it's as simple as that!" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "19db62eb", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Saving pathmnist train...\n", - "100%|███████████████████████████████████| 89996/89996 [00:15<00:00, 5636.60it/s]\n", - "Saving pathmnist val...\n", - "100%|███████████████████████████████████| 10004/10004 [00:02<00:00, 4912.07it/s]\n", - "Saving pathmnist test...\n", - "100%|█████████████████████████████████████| 7180/7180 [00:01<00:00, 4582.64it/s]\n" - ] - } - ], - "source": [ - "!python -m medmnist save --flag=pathmnist --folder=medmnist/dataset/ --postfix=png" - ] - }, - { - "cell_type": "markdown", - "id": "cbcb07ff", - "metadata": {}, - "source": [ - "The --folder option specifies where to save the downloaded information, and the --postfix option specifies that the images should be saved in png format.\n", - "\n", - "For this tutorial, we will be using the full PathMNIST dataset for training, validation and testing. However, to improve efficiency and save time, you may consider using a fraction of this dataset instead with GaNDLF. \n", - "\n", - "To download the full dataset:\n", - "\n", - "Let's retrieve and download the train_path_full data CSV file within the dataset folder, which consists of ~90,000 images.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "4a699380", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "zsh:1: command not found: wget\r\n" - ] - } - ], - "source": [ - "!wget -O /content/medmnist/dataset/train_path_full.csv \"https://app.box.com/index.php?rm=box_download_shared_file&shared_name=zzokqk7hjzwmjxvamrxotxu78ihd5az0&file_id=f_972380483494\"" - ] - }, - { - "cell_type": "markdown", - "id": "831324a5", - "metadata": {}, - "source": [ - "location where the file should be saved and what the new filename will be\n", - ". \n", - "Let's retrieve and download the val_path_full data CSV file within the dataset folder, which is the full validation dataset consisting of ~10,000 images. \n" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "785af619", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "zsh:1: command not found: wget\r\n" - ] - } - ], - "source": [ - "!wget -O /content/medmnist/dataset/val_path_full.csv \"https://app.box.com/index.php?rm=box_download_shared_file&shared_name=bjoh6hn27l6ifqqtrs7w66za2hdwlu0a&file_id=f_990373191120\"" - ] - }, - { - "cell_type": "markdown", - "id": "37bd1888", - "metadata": {}, - "source": [ - "For the last of the data CSV files, let's retrieve and download the test_path_full data CSV file within the dataset folder. This CSV file contains ~7200 individual images.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "42d61c84", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "zsh:1: command not found: wget\r\n" - ] - } - ], - "source": [ - "!wget -O /content/medmnist/dataset/test_path_full.csv \"https://app.box.com/index.php?rm=box_download_shared_file&shared_name=jjzoifpdly0pmkdaguy0cxbdfkig81eq&file_id=f_990374552591\"" - ] - }, - { - "cell_type": "markdown", - "id": "55be009b", - "metadata": {}, - "source": [ - "To download the “tiny” dataset:\n", - "\n", - "Let's retrieve and download the train_path_tiny data CSV file within the dataset folder, which consists of ~4,000 images.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "2d63bf0e", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "zsh:1: command not found: wget\r\n" - ] - } - ], - "source": [ - "!wget -O /content/medmnist/dataset/train_path_full.csv \"https://app.box.com/index.php?rm=box_download_shared_file&shared_name=um4003lkrvyj55jm4a0jz7zsuokb0r8o&file_id=f_991821586980\"" - ] - }, - { - "cell_type": "markdown", - "id": "e7d39d90", - "metadata": {}, - "source": [ - "Let's retrieve and download the val_path_tiny data CSV file within the dataset folder, which consists of ~1,000 images. \n" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "id": "e0054486", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "zsh:1: command not found: wget\r\n" - ] - } - ], - "source": [ - "!wget -O /content/medmnist/dataset/val_path_full.csv \"https://app.box.com/index.php?rm=box_download_shared_file&shared_name=rsmff27sm2z34r5xso1jx8xix7nhfspc&file_id=f_991817441206\"" - ] - }, - { - "cell_type": "markdown", - "id": "5a1b249b", - "metadata": {}, - "source": [ - "For the last of the data CSV files, let's retrieve and download the test_path_full data CSV file within the dataset folder. This CSV file contains 500 individual images.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "id": "fdc098fe", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "zsh:1: command not found: wget\r\n" - ] - } - ], - "source": [ - "!wget -O /content/medmnist/dataset/test_path_full.csv \"https://app.box.com/index.php?rm=box_download_shared_file&shared_name=22lm0qfzk5luap72mtdpzx5l3ocflopa&file_id=f_991819617152\"\n" - ] - }, - { - "cell_type": "markdown", - "id": "cad43170", - "metadata": {}, - "source": [ - "Command-Line Interface Note: If you run into any issues when trying to download these files, you can copy and paste these links into your web browser to download the .csv files. Then, you can manually place them into the desired directory using your file manager.\n", - "\n", - "\n", - "Now, we will retrieve and download the config YAML file to the base directory. This file specifies important information to be used in training and inference (model and training parameters, data preprocessing specifications, etc.).\n", - "\n", - "For the purposes of this tutorial, we have already constructed this file to fit our specific task, but for other tasks and experiments that you may want to run, this file will need to be edited to fit the required specifications of your experiment. However, the overall structure of this file will stay the same regardless of your task, so you should be able to get by by simply downloading and editing the config.yaml file we're using below for use in your own experiments.\n", - "\n", - "Either way, we highly encourage you to download and take a look at the structure of this file before proceeding if you intend to use GaNDLF for your own experiments, as it will be the backbone of all tasks you use GaNDLF with in the future. The file contains comments explaining the various parameters and what they mean. If you plan on trying to use any of the other datasets, specifically the 3D ones, make sure to change the number of dimensions on line 11 of the file to 3. \n" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "id": "e71a3bfa", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "zsh:1: command not found: wget\r\n" - ] - } - ], - "source": [ - "!wget -O config.yaml \"https://app.box.com/index.php?rm=box_download_shared_file&shared_name=hs0zwezggl4rxtzgrcaq86enu7qwuvqx&file_id=f_974251081617\"" - ] - }, - { - "cell_type": "markdown", - "id": "5be6bb2f", - "metadata": {}, - "source": [ - "Finally, let's retrieve and download an updated copy of the gandlf_collectStats file to the base directory for use in plotting and visualizing our results. While an earlier version of this file is present in the GaNDLF repo, it is not suitable for classification tasks and has been modified for this tutorial to produce classification training and validation accuracy and loss plots. This file will be included in the GaNDLF repo in a future update, but for now, we will retrieve the updated file externally for use in this tutorial.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "id": "4309c31e", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "zsh:1: command not found: wget\r\n" - ] - } - ], - "source": [ - "!wget -O gandlf_collectStats_final \"https://app.box.com/index.php?rm=box_download_shared_file&shared_name=avq6pvqg3uzsc4uzbklab66mad6eaik5&file_id=f_989875069231\"" - ] - }, - { - "cell_type": "markdown", - "id": "41871543", - "metadata": {}, - "source": [ - "Let's visualize some sample images and their classes from the PathMNIST dataset.\n", - "Image classes for reference:\n", - "Class 0: Adipose\n", - "Class 1: Background\n", - "Class 2: Debris\n", - "Class 3: Lymphocytes\n", - "Class 4: Mucus\n", - "Class 5: Smooth Muscle\n", - "Class 6: Normal Colon Mucosa\n", - "Class 7: Cancer-Associated Stroma\n", - "Class 8: Colorectal Adenocarcinoma Epithelium\n", - "\n", - "Before running the code below, make sure you enter the python shell again if you are using a command line interface. \n" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "id": "3f322c5e", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "#Step 1\n", - "import matplotlib.pyplot as plt\n", - "import matplotlib.image as mpimg\n", - "import pandas as pd\n", - "\n", - "\n", - "#Step 2\n", - "df_pathmnist = pd.read_csv('./medmnist/dataset/pathmnist.csv')\n", - "\n", - "\n", - "#Step 3\n", - "selected_images = [32, 36, 46, 13, 14, 8, 12, 18, 5, 6, 17, 0, 16, 3, 7, 10, 43, 45, 55, 1, 31, 41, 4, 9, 11]\n", - "\n", - "\n", - "#Step 4\n", - "fig, ax = plt.subplot_mosaic([\n", - " ['img0', 'img1', 'img2', 'img3', 'img4'],\n", - " ['img5', 'img6', 'img7', 'img8', 'img9'],\n", - " ['img10', 'img11', 'img12', 'img13', 'img14'],\n", - " ['img15', 'img16', 'img17', 'img18', 'img19'],\n", - " ['img20', 'img21', 'img22', 'img23', 'img24']\n", - "], figsize=(15, 15))\n", - "\n", - "\n", - "#Step 5\n", - "for i in range(len(selected_images)):\n", - " img = selected_images[i]\n", - " filename = df_pathmnist.iloc[img]['train0_0.png']\n", - " img_class = df_pathmnist.iloc[img]['0']\n", - "\n", - "\n", - " path_img = mpimg.imread(f'./medmnist/dataset/pathmnist/{filename}')\n", - "\n", - "\n", - " ax[f'img{i}'].imshow(path_img)\n", - " ax[f'img{i}'].axis('off')\n", - " ax[f'img{i}'].set_title(f'Class {img_class}')\n", - "\n", - "\n", - "#Step 6\n", - "plt.show()\n" - ] - }, - { - "cell_type": "markdown", - "id": "c18e375e", - "metadata": {}, - "source": [ - "Let’s quickly go over what exactly this code is doing.\n", - "1. We import all of the necessary libraries, such as matplotlib(which we discussed earlier) and pandas, which is a Python library that provides methods for data manipulation. \n", - "2. The file paths for the PathMNIST images are read and stored in the df_pathmnist variable. \n", - "3. We initialize the selected_images variable which stores an array of integers. These integers represent the indices of the images from the pathmnist dataset we want to display. You can also try changing some of these values to see the different displayed plots and see more images in the dataset. \n", - "4. We create a 5x5 grid of subplots to display our 25 images.\n", - "5. We iterate through the selected_images array and read the corresponding image files. Then, we display the images in the proper subplots.\n", - "6. Finally, plt.show() displays the plot we have created. \n", - "\n", - "Your resulting plot should have an assortment of images from the PathMNIST set including images from all of class 0-8.\n", - "\n", - "Let’s quickly go over what these different classes are by using the results above:\n", - "\n", - "Class 0: Adipose\n", - "Adipose tissue is just tissue that stores fat. This tissue is made up of adipocytes, or fat cells, which store energy.\n", - "\n", - "\n", - "\n", - "Class 1: Background\n", - "The background class represents the non-tissue areas of the image that aren’t necessarily areas of interest.\n", - "\n", - "\n", - "\n", - "Class 2: Debris\n", - "Class 2 contains images of miscellaneous non-living particles or materials found in the colon.\n", - "\n", - "\n", - "\n", - "Class 3: Lymphocytes \n", - "Class 4 contains images of lymphocytes. Lymphocytes are a type of white blood cell that play a significant role in the immune system.\n", - "\n", - "\n", - "\n", - "Class 4: Mucus\n", - "Class 4 contains images of normal mucus that is found in healthy colons.\n", - "\n", - "\n", - "\n", - "\n", - "Class 5: Smooth Muscle\n", - "Class 5 contains images of smooth muscle tissue that is seen in the walls of the colon.\n", - "\n", - "\n", - "\n", - "Class 6: Normal Colon Mucosa\n", - "Class 6 contains images of the colon mucosa, which lines the colon.\n", - "\n", - "\n", - "\n", - "\n", - "Class 7: Cancer-Associated Stroma\n", - "Class 7 contains images of stroma, which is supportive tissue that provides tumors with nutrients and protection to assist in the cancer’s survival.\n", - "\n", - "\n", - "\n", - "\n", - "Class 8: Colorectal Adenocarcinoma Epithelium\n", - "The epithelium is the tissue that lines the colon, and Class 8 contains images of epithelial cells affected by colorectal adenocarcinoma, a type of cancer.\n", - "\n", - "\n", - "\n", - "\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "id": "5195c707", - "metadata": {}, - "source": [ - "Now, on to training! Since there is only one GPU, let's set CUDA_VISIBLE_DEVICES to 0 to train on the first (and only) available GPU. The way to execute this code will vary based on what you are running your code on.\n", - "\n", - "On Colab run this Python code: \n" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "id": "2afcc3d0", - "metadata": {}, - "outputs": [], - "source": [ - "import os\n", - "os.environ[\"CUDA_VISIBLE_DEVICES\"]=\"0\"" - ] - }, - { - "cell_type": "markdown", - "id": "91a977dc", - "metadata": {}, - "source": [ - "If you are following these instructions on your own command line interface, instead run the following: \n", - "\n", - "export \"CUDA_VISIBLE_DEVICES\"=\"0\"" - ] - }, - { - "cell_type": "markdown", - "id": "8a2d6e30", - "metadata": {}, - "source": [ - "Let's run the training script! For this run, we will pass in the config.yaml file that we just downloaded to the -c parameter, the training and validation CSV files to the -i parameter, and the model directory to the -m parameter (folder will automatically be created if it doesn't exist, which, in our case, it doesn't). We will also specify -t True to indicate that we are training and -d cuda to indicate that we will be training on the GPU. For demonstration purposes, we will only be training on 5 epochs. The number of epochs is the number of times that the model will pass through the entire training dataset during the training process. In our case, the model will pass through the dataset 5 times. \n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "id": "f01f2dab", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "python: can't open file '/content/GaNDLF/gandlf_run': [Errno 2] No such file or directory\r\n" - ] - } - ], - "source": [ - "!python /content/GaNDLF/gandlf_run -c /content/config.yaml -i /content/medmnist/dataset/train_path_full.csv,/content/medmnist/dataset/val_path_full.csv -m /content/model/ -t True -d cuda\n" - ] - }, - { - "cell_type": "markdown", - "id": "7a508061", - "metadata": {}, - "source": [ - "\n", - "You will likely notice a persistent error saying \"y_pred contains classes not in y_true\"--this is a known issue and will not affect our training performance, so feel free to ignore it.\n", - "\n", - "If your program stops for any reason and you try to run it again, you may see this error:\n", - "ValueError: The parameters are not the same as the ones stored in the previous run, please re-check.\n", - "To resolve this, delete the existing model by deleting the “model” file and then try executing the command again. \n", - "\n", - "Potential Google Colab Error: If your Google Colab notebook is not correctly using the GPU, the program may run out of RAM and stop during the process of constructing the queue for training data. \n", - "\n", - "Now that training is complete, let's collect and save model statistics to the output_stats folder. Using -c True indicates that we'd like the 4 plots ordinarily generated by this command to be combined into two plots by overlaying training and validation statistics on the same graphs instead of keeping them separate. Feel free to experiment with this command by using -c False instead and viewing the resulting plots.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "id": "aaa90885", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "python: can't open file '/content/gandlf_collectStats_final': [Errno 2] No such file or directory\r\n" - ] - } - ], - "source": [ - "!python /content/gandlf_collectStats_final -m /content/model/ -o /content/output_stats -c True" - ] - }, - { - "cell_type": "markdown", - "id": "5840544b", - "metadata": {}, - "source": [ - "Now, let's view our generated plots! Make sure to enter the Python shell if you are working in the command line interface.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "id": "85a53674", - "metadata": {}, - "outputs": [ - { - "ename": "FileNotFoundError", - "evalue": "No such file or directory: '/content/output_stats/plot.png'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "File \u001b[0;32m~/anaconda3/lib/python3.10/site-packages/IPython/core/display.py:1045\u001b[0m, in \u001b[0;36mImage._data_and_metadata\u001b[0;34m(self, always_both)\u001b[0m\n\u001b[1;32m 1044\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m-> 1045\u001b[0m b64_data \u001b[38;5;241m=\u001b[39m \u001b[43mb2a_base64\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdata\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241m.\u001b[39mdecode(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mascii\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m 1046\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n", - "\u001b[0;31mTypeError\u001b[0m: a bytes-like object is required, not 'str'", - "\nThe above exception was the direct cause of the following exception:\n", - "\u001b[0;31mFileNotFoundError\u001b[0m Traceback (most recent call last)", - "File \u001b[0;32m~/anaconda3/lib/python3.10/site-packages/IPython/core/formatters.py:972\u001b[0m, in \u001b[0;36mMimeBundleFormatter.__call__\u001b[0;34m(self, obj, include, exclude)\u001b[0m\n\u001b[1;32m 969\u001b[0m method \u001b[38;5;241m=\u001b[39m get_real_method(obj, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mprint_method)\n\u001b[1;32m 971\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m method \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 972\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mmethod\u001b[49m\u001b[43m(\u001b[49m\u001b[43minclude\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minclude\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mexclude\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mexclude\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 973\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 974\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n", - "File \u001b[0;32m~/anaconda3/lib/python3.10/site-packages/IPython/core/display.py:1035\u001b[0m, in \u001b[0;36mImage._repr_mimebundle_\u001b[0;34m(self, include, exclude)\u001b[0m\n\u001b[1;32m 1033\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39membed:\n\u001b[1;32m 1034\u001b[0m mimetype \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_mimetype\n\u001b[0;32m-> 1035\u001b[0m data, metadata \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_data_and_metadata\u001b[49m\u001b[43m(\u001b[49m\u001b[43malways_both\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[1;32m 1036\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m metadata:\n\u001b[1;32m 1037\u001b[0m metadata \u001b[38;5;241m=\u001b[39m {mimetype: metadata}\n", - "File \u001b[0;32m~/anaconda3/lib/python3.10/site-packages/IPython/core/display.py:1047\u001b[0m, in \u001b[0;36mImage._data_and_metadata\u001b[0;34m(self, always_both)\u001b[0m\n\u001b[1;32m 1045\u001b[0m b64_data \u001b[38;5;241m=\u001b[39m b2a_base64(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdata)\u001b[38;5;241m.\u001b[39mdecode(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mascii\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m 1046\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[0;32m-> 1047\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mFileNotFoundError\u001b[39;00m(\n\u001b[1;32m 1048\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mNo such file or directory: \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m%\u001b[39m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdata)) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01me\u001b[39;00m\n\u001b[1;32m 1049\u001b[0m md \u001b[38;5;241m=\u001b[39m {}\n\u001b[1;32m 1050\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmetadata:\n", - "\u001b[0;31mFileNotFoundError\u001b[0m: No such file or directory: '/content/output_stats/plot.png'" - ] - }, - { - "ename": "FileNotFoundError", - "evalue": "No such file or directory: '/content/output_stats/plot.png'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "File \u001b[0;32m~/anaconda3/lib/python3.10/site-packages/IPython/core/display.py:1045\u001b[0m, in \u001b[0;36mImage._data_and_metadata\u001b[0;34m(self, always_both)\u001b[0m\n\u001b[1;32m 1044\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m-> 1045\u001b[0m b64_data \u001b[38;5;241m=\u001b[39m \u001b[43mb2a_base64\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdata\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241m.\u001b[39mdecode(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mascii\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m 1046\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n", - "\u001b[0;31mTypeError\u001b[0m: a bytes-like object is required, not 'str'", - "\nThe above exception was the direct cause of the following exception:\n", - "\u001b[0;31mFileNotFoundError\u001b[0m Traceback (most recent call last)", - "File \u001b[0;32m~/anaconda3/lib/python3.10/site-packages/IPython/core/formatters.py:342\u001b[0m, in \u001b[0;36mBaseFormatter.__call__\u001b[0;34m(self, obj)\u001b[0m\n\u001b[1;32m 340\u001b[0m method \u001b[38;5;241m=\u001b[39m get_real_method(obj, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mprint_method)\n\u001b[1;32m 341\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m method \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 342\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mmethod\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 343\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 344\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n", - "File \u001b[0;32m~/anaconda3/lib/python3.10/site-packages/IPython/core/display.py:1067\u001b[0m, in \u001b[0;36mImage._repr_png_\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 1065\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_repr_png_\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[1;32m 1066\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39membed \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mformat \u001b[38;5;241m==\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_FMT_PNG:\n\u001b[0;32m-> 1067\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_data_and_metadata\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/anaconda3/lib/python3.10/site-packages/IPython/core/display.py:1047\u001b[0m, in \u001b[0;36mImage._data_and_metadata\u001b[0;34m(self, always_both)\u001b[0m\n\u001b[1;32m 1045\u001b[0m b64_data \u001b[38;5;241m=\u001b[39m b2a_base64(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdata)\u001b[38;5;241m.\u001b[39mdecode(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mascii\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m 1046\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[0;32m-> 1047\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mFileNotFoundError\u001b[39;00m(\n\u001b[1;32m 1048\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mNo such file or directory: \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m%\u001b[39m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdata)) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01me\u001b[39;00m\n\u001b[1;32m 1049\u001b[0m md \u001b[38;5;241m=\u001b[39m {}\n\u001b[1;32m 1050\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmetadata:\n", - "\u001b[0;31mFileNotFoundError\u001b[0m: No such file or directory: '/content/output_stats/plot.png'" - ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 31, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from IPython.display import Image\n", - "Image(\"/content/output_stats/plot.png\", width=1500, height=1000)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "id": "3a823e40", - "metadata": {}, - "source": [ - "Your results should show both an Accuracy Plot and a Loss Plot.\n", - "\n", - "Since we only trained the model on a very small number of epochs, we shouldn't be expecting very impressive results here. However, from the graphs, we can tell that accuracy is steadily increasing and loss is steadily decreasing, which is a great sign.\n", - "\n", - "Finally, let's run the inference script. This is almost identical to running the training script; however, note that the argument for the -t parameter has been changed from True to False to specify that we are not training, and we are using the test_path_full csv file to access the testing images.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "id": "2ba2b24a", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "python: can't open file '/content/GaNDLF/gandlf_run': [Errno 2] No such file or directory\r\n" - ] - } - ], - "source": [ - "!python /content/GaNDLF/gandlf_run -c /content/config.yaml -i /content/medmnist/dataset/test_path_full.csv -m /content/model/ -t False -d cuda" - ] - }, - { - "cell_type": "markdown", - "id": "b3e630c0", - "metadata": {}, - "source": [ - "Now that inference is complete, let's view some sample test images along with their predicted and ground truth classes to get a visual idea of how well our model did on each class. Remember to enter the Python shell if you are using the command line interface." - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "id": "6c2dbdf6", - "metadata": {}, - "outputs": [ - { - "ename": "FileNotFoundError", - "evalue": "[Errno 2] No such file or directory: './model/final_preds_and_avg_probs.csv'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mFileNotFoundError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[33], line 6\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mmatplotlib\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mimage\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m \u001b[38;5;21;01mmpimg\u001b[39;00m\n\u001b[1;32m 3\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mpandas\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m \u001b[38;5;21;01mpd\u001b[39;00m\n\u001b[0;32m----> 6\u001b[0m df_preds \u001b[38;5;241m=\u001b[39m \u001b[43mpd\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mread_csv\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43m./model/final_preds_and_avg_probs.csv\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 9\u001b[0m selected_images \u001b[38;5;241m=\u001b[39m [\u001b[38;5;241m4\u001b[39m, \u001b[38;5;241m7\u001b[39m, \u001b[38;5;241m14\u001b[39m, \u001b[38;5;241m22\u001b[39m, \u001b[38;5;241m26\u001b[39m, \u001b[38;5;241m3\u001b[39m, \u001b[38;5;241m11\u001b[39m, \u001b[38;5;241m17\u001b[39m, \u001b[38;5;241m37\u001b[39m, \u001b[38;5;241m45\u001b[39m, \u001b[38;5;241m52\u001b[39m, \u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m2\u001b[39m, \u001b[38;5;241m40\u001b[39m, \u001b[38;5;241m47\u001b[39m, \u001b[38;5;241m76\u001b[39m, \u001b[38;5;241m8\u001b[39m, \u001b[38;5;241m13\u001b[39m, \u001b[38;5;241m28\u001b[39m, \u001b[38;5;241m19\u001b[39m, \u001b[38;5;241m36\u001b[39m, \u001b[38;5;241m79\u001b[39m, \u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m9\u001b[39m, \u001b[38;5;241m10\u001b[39m]\n\u001b[1;32m 12\u001b[0m fig, ax \u001b[38;5;241m=\u001b[39m plt\u001b[38;5;241m.\u001b[39msubplot_mosaic([\n\u001b[1;32m 13\u001b[0m [\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mimg0\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mimg1\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mimg2\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mimg3\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mimg4\u001b[39m\u001b[38;5;124m'\u001b[39m],\n\u001b[1;32m 14\u001b[0m [\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mimg5\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mimg6\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mimg7\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mimg8\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mimg9\u001b[39m\u001b[38;5;124m'\u001b[39m],\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 17\u001b[0m [\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mimg20\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mimg21\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mimg22\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mimg23\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mimg24\u001b[39m\u001b[38;5;124m'\u001b[39m]\n\u001b[1;32m 18\u001b[0m ], figsize\u001b[38;5;241m=\u001b[39m(\u001b[38;5;241m13\u001b[39m, \u001b[38;5;241m13\u001b[39m), constrained_layout \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m)\n", - "File \u001b[0;32m~/anaconda3/lib/python3.10/site-packages/pandas/util/_decorators.py:211\u001b[0m, in \u001b[0;36mdeprecate_kwarg.._deprecate_kwarg..wrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 209\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 210\u001b[0m kwargs[new_arg_name] \u001b[38;5;241m=\u001b[39m new_arg_value\n\u001b[0;32m--> 211\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/anaconda3/lib/python3.10/site-packages/pandas/util/_decorators.py:331\u001b[0m, in \u001b[0;36mdeprecate_nonkeyword_arguments..decorate..wrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 325\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(args) \u001b[38;5;241m>\u001b[39m num_allow_args:\n\u001b[1;32m 326\u001b[0m warnings\u001b[38;5;241m.\u001b[39mwarn(\n\u001b[1;32m 327\u001b[0m msg\u001b[38;5;241m.\u001b[39mformat(arguments\u001b[38;5;241m=\u001b[39m_format_argument_list(allow_args)),\n\u001b[1;32m 328\u001b[0m \u001b[38;5;167;01mFutureWarning\u001b[39;00m,\n\u001b[1;32m 329\u001b[0m stacklevel\u001b[38;5;241m=\u001b[39mfind_stack_level(),\n\u001b[1;32m 330\u001b[0m )\n\u001b[0;32m--> 331\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/anaconda3/lib/python3.10/site-packages/pandas/io/parsers/readers.py:950\u001b[0m, in \u001b[0;36mread_csv\u001b[0;34m(filepath_or_buffer, sep, delimiter, header, names, index_col, usecols, squeeze, prefix, mangle_dupe_cols, dtype, engine, converters, true_values, false_values, skipinitialspace, skiprows, skipfooter, nrows, na_values, keep_default_na, na_filter, verbose, skip_blank_lines, parse_dates, infer_datetime_format, keep_date_col, date_parser, dayfirst, cache_dates, iterator, chunksize, compression, thousands, decimal, lineterminator, quotechar, quoting, doublequote, escapechar, comment, encoding, encoding_errors, dialect, error_bad_lines, warn_bad_lines, on_bad_lines, delim_whitespace, low_memory, memory_map, float_precision, storage_options)\u001b[0m\n\u001b[1;32m 935\u001b[0m kwds_defaults \u001b[38;5;241m=\u001b[39m _refine_defaults_read(\n\u001b[1;32m 936\u001b[0m dialect,\n\u001b[1;32m 937\u001b[0m delimiter,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 946\u001b[0m defaults\u001b[38;5;241m=\u001b[39m{\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdelimiter\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m,\u001b[39m\u001b[38;5;124m\"\u001b[39m},\n\u001b[1;32m 947\u001b[0m )\n\u001b[1;32m 948\u001b[0m kwds\u001b[38;5;241m.\u001b[39mupdate(kwds_defaults)\n\u001b[0;32m--> 950\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_read\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfilepath_or_buffer\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/anaconda3/lib/python3.10/site-packages/pandas/io/parsers/readers.py:605\u001b[0m, in \u001b[0;36m_read\u001b[0;34m(filepath_or_buffer, kwds)\u001b[0m\n\u001b[1;32m 602\u001b[0m _validate_names(kwds\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnames\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28;01mNone\u001b[39;00m))\n\u001b[1;32m 604\u001b[0m \u001b[38;5;66;03m# Create the parser.\u001b[39;00m\n\u001b[0;32m--> 605\u001b[0m parser \u001b[38;5;241m=\u001b[39m \u001b[43mTextFileReader\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfilepath_or_buffer\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 607\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m chunksize \u001b[38;5;129;01mor\u001b[39;00m iterator:\n\u001b[1;32m 608\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m parser\n", - "File \u001b[0;32m~/anaconda3/lib/python3.10/site-packages/pandas/io/parsers/readers.py:1442\u001b[0m, in \u001b[0;36mTextFileReader.__init__\u001b[0;34m(self, f, engine, **kwds)\u001b[0m\n\u001b[1;32m 1439\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39moptions[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mhas_index_names\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m kwds[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mhas_index_names\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n\u001b[1;32m 1441\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhandles: IOHandles \u001b[38;5;241m|\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m-> 1442\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_engine \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_make_engine\u001b[49m\u001b[43m(\u001b[49m\u001b[43mf\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mengine\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/anaconda3/lib/python3.10/site-packages/pandas/io/parsers/readers.py:1735\u001b[0m, in \u001b[0;36mTextFileReader._make_engine\u001b[0;34m(self, f, engine)\u001b[0m\n\u001b[1;32m 1733\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mb\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m mode:\n\u001b[1;32m 1734\u001b[0m mode \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mb\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m-> 1735\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhandles \u001b[38;5;241m=\u001b[39m \u001b[43mget_handle\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 1736\u001b[0m \u001b[43m \u001b[49m\u001b[43mf\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1737\u001b[0m \u001b[43m \u001b[49m\u001b[43mmode\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1738\u001b[0m \u001b[43m \u001b[49m\u001b[43mencoding\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mencoding\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1739\u001b[0m \u001b[43m \u001b[49m\u001b[43mcompression\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mcompression\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1740\u001b[0m \u001b[43m \u001b[49m\u001b[43mmemory_map\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mmemory_map\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1741\u001b[0m \u001b[43m \u001b[49m\u001b[43mis_text\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mis_text\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1742\u001b[0m \u001b[43m \u001b[49m\u001b[43merrors\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mencoding_errors\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mstrict\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1743\u001b[0m \u001b[43m \u001b[49m\u001b[43mstorage_options\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mstorage_options\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1744\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1745\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhandles \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 1746\u001b[0m f \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhandles\u001b[38;5;241m.\u001b[39mhandle\n", - "File \u001b[0;32m~/anaconda3/lib/python3.10/site-packages/pandas/io/common.py:856\u001b[0m, in \u001b[0;36mget_handle\u001b[0;34m(path_or_buf, mode, encoding, compression, memory_map, is_text, errors, storage_options)\u001b[0m\n\u001b[1;32m 851\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(handle, \u001b[38;5;28mstr\u001b[39m):\n\u001b[1;32m 852\u001b[0m \u001b[38;5;66;03m# Check whether the filename is to be opened in binary mode.\u001b[39;00m\n\u001b[1;32m 853\u001b[0m \u001b[38;5;66;03m# Binary mode does not support 'encoding' and 'newline'.\u001b[39;00m\n\u001b[1;32m 854\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m ioargs\u001b[38;5;241m.\u001b[39mencoding \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mb\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m ioargs\u001b[38;5;241m.\u001b[39mmode:\n\u001b[1;32m 855\u001b[0m \u001b[38;5;66;03m# Encoding\u001b[39;00m\n\u001b[0;32m--> 856\u001b[0m handle \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mopen\u001b[39;49m\u001b[43m(\u001b[49m\n\u001b[1;32m 857\u001b[0m \u001b[43m \u001b[49m\u001b[43mhandle\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 858\u001b[0m \u001b[43m \u001b[49m\u001b[43mioargs\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmode\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 859\u001b[0m \u001b[43m \u001b[49m\u001b[43mencoding\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mioargs\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mencoding\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 860\u001b[0m \u001b[43m \u001b[49m\u001b[43merrors\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43merrors\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 861\u001b[0m \u001b[43m \u001b[49m\u001b[43mnewline\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 862\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 863\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 864\u001b[0m \u001b[38;5;66;03m# Binary mode\u001b[39;00m\n\u001b[1;32m 865\u001b[0m handle \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mopen\u001b[39m(handle, ioargs\u001b[38;5;241m.\u001b[39mmode)\n", - "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: './model/final_preds_and_avg_probs.csv'" - ] - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "import matplotlib.image as mpimg\n", - "import pandas as pd\n", - "\n", - "\n", - "df_preds = pd.read_csv('./model/final_preds_and_avg_probs.csv')\n", - "\n", - "\n", - "selected_images = [4, 7, 14, 22, 26, 3, 11, 17, 37, 45, 52, 1, 2, 40, 47, 76, 8, 13, 28, 19, 36, 79, 0, 9, 10]\n", - "\n", - "\n", - "fig, ax = plt.subplot_mosaic([\n", - " ['img0', 'img1', 'img2', 'img3', 'img4'],\n", - " ['img5', 'img6', 'img7', 'img8', 'img9'],\n", - " ['img10', 'img11', 'img12', 'img13', 'img14'],\n", - " ['img15', 'img16', 'img17', 'img18', 'img19'],\n", - " ['img20', 'img21', 'img22', 'img23', 'img24']\n", - "], figsize=(13, 13), constrained_layout = True)\n", - "\n", - "\n", - "for i in range(len(selected_images)):\n", - " img = selected_images[i]\n", - " filename = df_preds.iloc[img]['SubjectID']\n", - " ground_truth = filename.split('_')[1].split('.')[0]\n", - " pred_class = df_preds.iloc[img]['PredictedClass']\n", - "\n", - " path_img = mpimg.imread(f'./medmnist/dataset/pathmnist/{filename}')\n", - "\n", - "\n", - " ax[f'img{i}'].imshow(path_img)\n", - " ax[f'img{i}'].axis('off')\n", - " ax[f'img{i}'].set_title(f'Predicted Class: {pred_class}\\nGround . Truth: {ground_truth}')\n", - "\n", - "\n", - "plt.show()\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "id": "9268f2ca", - "metadata": {}, - "source": [ - "Your produced plot should contain 16 images from the PathMNIST set, and each image should be accompanied by both a Predicted Class and a Ground Truth label. \n", - "\n", - "We can see that our model did a decent job of making predictions. However, we can see that it has a few common misconceptions. We can see that the model mistook smooth muscle for debris thrice and cancer-associated stroma for debris once. The model also mistook mucus as adipose twice, and it mistook Colorectal Adenocarcinoma Epithelium as Normal Colon Mucosa once.\n", - "\n", - "\n", - "To conclude this tutorial, let's zoom out and take a look at how well our model did as a whole on each class by constructing a confusion matrix from our inference data.\n", - "Note: if you'd like, feel free to change the colormap of the confusion matrix (denoted by \"cmap\" in the cm_display.plot() command) to your liking. Here's a list of some of the most popular colormaps: viridis (default), plasma, inferno, magma, cividis.\n", - "\n", - "Execute the following code in the Python shell: \n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "b827c049", - "metadata": {}, - "outputs": [], - "source": [ - "import sklearn\n", - "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay\n", - "\n", - "\n", - "gt_list = []\n", - "pred_list = []\n", - "\n", - "\n", - "for i in range(len(df_preds)):\n", - " filename = df_preds.iloc[i]['SubjectID']\n", - "\n", - "\n", - " ground_truth = int(filename.split('_')[1].split('.')[0])\n", - " pred_class = int(df_preds.iloc[i]['PredictedClass'])\n", - "\n", - "\n", - " gt_list.append(ground_truth)\n", - " pred_list.append(pred_class)\n", - "\n", - "\n", - "cm = confusion_matrix(gt_list, pred_list)\n", - "cm_display = ConfusionMatrixDisplay(confusion_matrix = cm)\n", - "\n", - "\n", - "fig, ax = plt.subplots(figsize = (12, 12))\n", - "cm_display.plot(cmap = 'viridis', ax = ax)\n", - "plt.show()\n" - ] - }, - { - "cell_type": "markdown", - "id": "607a9dd8", - "metadata": {}, - "source": [ - "Let’s quickly go over this code:\n", - "\n", - "1. We import the Scikit-Learn library, and we will be using this library's methods of creating confusion matrices. \n", - "\n", - "2. We create empty lists gt_list and pred_list to store our ground truth and predicted labels respectively.\n", - "\n", - "3. The for loop iterates through df_preds and extracts the ground truth label and the predicted class for each image and then appends the labels to their corresponding lists.\n", - "\n", - "4. We create a confusion matrix from these two lists and then call the plot() method to visualize it with our desired colormap.\n", - "\n", - "5. We display the confusion matrix using plt.show().\n" - ] - }, - { - "cell_type": "markdown", - "id": "dff24079", - "metadata": {}, - "source": [ - "Your resulting plot should be a 9x9 matrix that displays Predicted label vs. True label\n", - "\n", - "In our matrix, larger numbers along the diagonal represent correct classifications. Here, we can see that while the model performed well overall, it had difficulties when it came to images of Class 7, incorrectly predicting a majority of them as belonging to Class 2 instead. We can see a similar trend with images of Class 5, with the model incorrectly predicting most of them as belonging to Class 2.\n", - "\n", - "Given the appearance of the accuracy and loss plots, had we trained on more epochs, we would have expected these results to improve. However, given that we only trained on 5 epochs, these are great results. Indeed, the model did very well on other classes, including Classes 0 and 1.\n", - "\n", - "That concludes this GaNDLF tutorial! Hopefully, this tutorial was helpful to you in understanding how GaNDLF works as well as how to apply it to your own projects. If you need any additional information about GaNDLF's usage and capabilities, please consult the GitHub repo (https://github.com/CBICA/GaNDLF) and the documentation (https://cbica.github.io/GaNDLF/). For more questions and support, please visit the Discussions page on GitHub (https://github.com/CBICA/GaNDLF/discussions)\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "8f91563c", - "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.10.9" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} From 020d4b3098a06dcd3d291e496fa8d19987df9d12 Mon Sep 17 00:00:00 2001 From: vavali08 <119764082+vavali08@users.noreply.github.com> Date: Wed, 26 Jul 2023 12:27:20 -0400 Subject: [PATCH 04/15] Add files via upload --- .../GaNDLF Tutorial without output.ipynb | 957 ++++++++++++++++++ 1 file changed, 957 insertions(+) create mode 100644 tutorials/GaNDLF Tutorial without output.ipynb diff --git a/tutorials/GaNDLF Tutorial without output.ipynb b/tutorials/GaNDLF Tutorial without output.ipynb new file mode 100644 index 000000000..4d882083d --- /dev/null +++ b/tutorials/GaNDLF Tutorial without output.ipynb @@ -0,0 +1,957 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "1cc4fdb8-18de-4128-8ec1-b0ba70f4a934", + "metadata": {}, + "source": [ + "In this tutorial, we will be using the Generally Nuanced Deep Learning Framework (GaNDLF) to perform training and inference on a VGG model with PathMNIST, a dataset of colon pathology images. This is a multi-class classification task: there are 9 different types of colon tissue displayed in the pathology images, each represented by its own class." + ] + }, + { + "cell_type": "markdown", + "id": "61838af7", + "metadata": {}, + "source": [ + "The VGG model is a CNN architecture mostly known for simplicity and effectiveness in image classification and has been used in object recognition, face detection, and medical image analysis. \n", + "Its most notable features include its use of 16-19 weight layers and small 3x3 filters which allow for better performance and faster training times.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "4e77f51e", + "metadata": {}, + "source": [ + "![VGG Model Image](https://d3i71xaburhd42.cloudfront.net/dae981902b1f6d869ef2d047612b90cdbe43fd1e/2-Figure1-1.png)" + ] + }, + { + "cell_type": "markdown", + "id": "b99da8e5", + "metadata": {}, + "source": [ + "Figure 1 - Display of VGG Architecture - Visualizing and Comparing AlexNet and VGG using Deconvolutional Layers (W. Yu)\n", + "\n", + "For more information on the model, refer to the paper Very Deep Convolutional Networks for Large-Scale Image Recognition by Karen Simonyan and Andrew Zisserman\n" + ] + }, + { + "cell_type": "markdown", + "id": "b0645481", + "metadata": {}, + "source": [ + "This tutorial demonstrates how to use GaNDLF with a simple classification task. Some steps that would ordinarily be part of the workflow (e.g. data CSV and config YAML file construction) have already been performed for simplicity; please refer to the GaNDLF documentation (located at https://cbica.github.io/GaNDLF/) for more information regarding replication of these steps.\n", + "\n", + "Command-Line Interface Note: Make sure you have Python installed before proceeding! Visit python.org/downloads for instructions on how do to this. Downloading version 3.7 is sufficient to complete this tutorial since this aligns with the version in Google Colab. \n", + "\n", + "Google Colab Note: Before continuing with this tutorial, please ensure that you are connected to the GPU by navigating to Runtime --> Change Runtime Type --> Hardware Accelerator and verifying that \"GPU\" is listed as the selected option. If not, it is highly recommended that you switch to it now. Also, if available, select the \"High-RAM\" option under Runtime → Change Runtime Type → Runtime Shape. Without this option selected, you may end up running out of RAM during training on a base notebook. \n", + "\n", + "Error Note: However, an error message may come up that says “You are connected to the GPU Runtime, but not utilizing the GPU.” This causes the program to stop when training the model because the program runs out of RAM.\n", + "\n", + "\n", + "Let's get started! First, we will clone the GaNDLF repo.\n", + "\n", + "Google Colab Note: Because the default version of Python in Colab (3.7) is not supported by the NumPy version used in the current version of GaNDLF, we will be cloning an earlier tag of the GaNDLF repo for this tutorial.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "adc51dd9", + "metadata": {}, + "outputs": [], + "source": [ + "!git clone -b 0.0.14 --depth 1 https://github.com/CBICA/GaNDLF.git" + ] + }, + { + "cell_type": "markdown", + "id": "634c8e7b", + "metadata": {}, + "source": [ + "The -b option indicates which branch we want to clone, and –depth 1 specifies the number of commits(or versions of the repository) that we want to retrieve. In this case, we are only retrieving one to save space and time, and since we are not making any changes to the actual GaNDLF code, this is sufficient." + ] + }, + { + "cell_type": "markdown", + "id": "0c62a49b", + "metadata": {}, + "source": [ + "Let's navigate to the newly created GaNDLF directory using the cd(change directory) command.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4e4cb90b", + "metadata": {}, + "outputs": [], + "source": [ + "%cd GaNDLF\n" + ] + }, + { + "cell_type": "markdown", + "id": "18faa97d", + "metadata": {}, + "source": [ + "Now, we'll install the appropriate version of PyTorch for use with GaNDLF. Pytorch is a machine learning framework primarily used for deep learning, and we will be using it here.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "51f0bdf8", + "metadata": {}, + "outputs": [], + "source": [ + "!pip3 install torch==1.8.2 torchvision==0.9.2 torchaudio==0.8.2 --extra-index-url https://download.pytorch.org/whl/lts/1.8/cu111\n" + ] + }, + { + "cell_type": "markdown", + "id": "f60e51b7", + "metadata": {}, + "source": [ + "pip is Python’s package manager that allows us to easily download different Python packages from the internet. If you do not have pip installed, visit pip.pypa.io/en/stable/installation/ for instructions.\n" + ] + }, + { + "cell_type": "markdown", + "id": "59aa00d9", + "metadata": {}, + "source": [ + "Google Colab Error Note: You might see an error that says:\n", + "​​ERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts. torchtext 0.14.1 requires torch==1.13.1, but you have torch 1.8.2+cu111 which is incompatible.\n", + "The next few cells may also have similar errors of the same form mentioning “pip’s dependency resolver” and version incompatibility, but GaNDLF installation will still be successful despite this, as we will see when verifying the installation." + ] + }, + { + "cell_type": "markdown", + "id": "1a79edc1", + "metadata": {}, + "source": [ + "Next, let's install OpenVINO, which is used by GaNDLF to generate optimized models for inference.\n", + "\n", + "OpenVINO is a toolkit developed by Intel that allows for easier optimization of deep learning models in situations where access to computing resources may be limited. The model optimizes computation and memory usage while providing hardware-specific optimizations. OpenVINO currently supports over 68 different image classification models, allowing for flexibility of use with GaNDLF.\n", + "\n", + "Visit docs.openvino.ai for more information.\n" + ] + }, + { + "cell_type": "markdown", + "id": "4eee3270", + "metadata": {}, + "source": [ + "We’ll need to install Matplotlib v.3.5.0 for use in plotting our results, for this version includes all of the features that we will be using later on. Let's do that now!\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e63124bb", + "metadata": {}, + "outputs": [], + "source": [ + "!pip install matplotlib==3.5.0\n" + ] + }, + { + "cell_type": "markdown", + "id": "ed63ccf0", + "metadata": {}, + "source": [ + "Matplotlib is a library that allows us to create different types of data visualizations in Python. We will go over some of the specific features when we utilize it later on. Visit matplotlib.org for more information.\n", + "\n", + "Google Colab Note: To be able to use the newly installed version of Matplotlib for plotting, go ahead and click the small gray \"RESTART RUNTIME\" button in the output directly above this code cell, and then continue with this tutorial once the restart process is complete.\n", + "\n", + "\n", + "Now, ensure you are still in the GaNDLF directory before proceeding. Otherwise, run the following command. \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5abebbed", + "metadata": {}, + "outputs": [], + "source": [ + "%cd GaNDLF\n" + ] + }, + { + "cell_type": "markdown", + "id": "5aa72043", + "metadata": {}, + "source": [ + "For the last of our GaNDLF-related installations, let's install all required packages for GaNDLF.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8db908ae", + "metadata": {}, + "outputs": [], + "source": [ + "!pip install -e ." + ] + }, + { + "cell_type": "markdown", + "id": "488d9232", + "metadata": {}, + "source": [ + "-e is short for editable, and . indicates that we are installing from the current directory (GaNDLF). Essentially, we are installing the packages in an editable mode because this allows us to change the source code in the packages without having to redownload the packages after we make modifications. \n", + "\n", + "Now, let's use gandlf_verifyInstall to verify our GaNDLF installation. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "77bd9e3d", + "metadata": {}, + "outputs": [], + "source": [ + "!python ./gandlf_verifyInstall\n" + ] + }, + { + "cell_type": "markdown", + "id": "3001d597", + "metadata": {}, + "source": [ + "\n", + "If you see the message, “GaNDLF is ready” after executing the previous step, then all steps have been followed correctly thus far. Let's move on to collecting our data. First, we will install the MedMNIST package in order to obtain the PathMNIST data that we will be using.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "baf27899", + "metadata": {}, + "outputs": [], + "source": [ + "!pip install medmnist\n" + ] + }, + { + "cell_type": "markdown", + "id": "22031f46", + "metadata": {}, + "source": [ + "The original MNIST(Modified National Institute of Standards in Technology) database is a database containing various images of handwritten digits, and people use this dataset to train computer programs to recognize digits. MNIST is often used as a benchmark, and researchers can test different machine learning algorithms on MNIST to evaluate their performance.\n", + "MedMNIST is a database of biomedical images with 18 different datasets. \n", + "\n", + "The 2D Datasets are:\n", + "1. PathMNIST(Colon Pathology images)\n", + "2. ChestMNIST(Chest X-Ray images)\n", + "3. DermaMNIST(Dermatoscope images)\n", + "4. OCTMNIST(Retinal OCT images)\n", + "5. PneumoniaMNIST(Chest X-Ray images)\n", + "6. RetinaMNIST(Fundus Camera images)\n", + "7. BreastMNIST(Breast Ultrasound images)\n", + "8. BloodMNIST(Blood Cell Microscope images)\n", + "9. TissueMNIST(Kidney Cortex Microscope images)\n", + "10. - 12. OrganAMNIST, OrganCMNIST, and Organ SMNIST (Abdominal CT images)\n", + "\n", + "The 3D Datasets are:\n", + "1. OrganMNIST3D(Abdominal CT images)\n", + "2. NoduleMNIST3D(Chest CT images)\n", + "3. AdrenalMNIST3D(Shape from Abdominal CT images)\n", + "4. FractureMNIST3D(Chest CT images)\n", + "5. VesselMNIST3D(Shape from Brain MRA images)\n", + "6. SynapseMNIST3D(Electron Microscope images)\n", + "\n", + "Here are some visualizations of the MedMNIST dataset. \n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "2eeaf438", + "metadata": {}, + "source": [ + "![MedMNIST visualizations](https://medmnist.com/assets/v2/imgs/overview.jpg)\n" + ] + }, + { + "cell_type": "markdown", + "id": "bc3638aa", + "metadata": {}, + "source": [ + "Figure 2 - MedMNIST datasets - MedMNIST v2 - A large-scale lightweight benchmark for 2D and 3D biomedical image classification (J. Yang)\n", + "\n", + "\n", + "The data is stored in a 28×28 (2D) or 28×28×28 (3D) format, similar to the 28×28 size of the images in the original MNIST dataset. \n", + "\n", + "For more information on MedMNIST and its installation visit github.com/MedMNIST/MedMNIST/ or medmnist.com\n", + "\n", + "For the purposes of this tutorial, we will be focusing on PathMNIST, the colon pathology images. The PathMNIST dataset has a total of 107,180 samples, and these images were taken from the study \"Predicting survival from colorectal cancer histology slides using deep learning: A retrospective multicenter study,\" by Jakob Nikolas Kather, Johannes Krisam, et al.\n", + "\n", + "We will look more closely at the images in this dataset soon. \n", + "\n", + "\n", + "\n", + "Now, let's import MedMNIST and verify the version number before we move on. \n", + "\n", + "Command-Line Interface Note: This is Python code, so to run this, we must enter the Python shell. To do this, type python or python3 in the command prompt and press enter. After executing these commands, type exit() or quit() to exit the Python shell.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "411eb42d", + "metadata": {}, + "outputs": [], + "source": [ + "import medmnist\n", + "print(medmnist.__version__)" + ] + }, + { + "cell_type": "markdown", + "id": "84912c51", + "metadata": {}, + "source": [ + "Time to load our data! Let's download all MedMNIST datasets to the root directory. In this tutorial, we will only be using the PathMNIST dataset; however, feel free to use any of the other datasets you see being downloaded below (which are also mentioned above) to try out GaNDLF for yourself!\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0536b26c", + "metadata": {}, + "outputs": [], + "source": [ + "!python -m medmnist download\n" + ] + }, + { + "cell_type": "markdown", + "id": "6a040293", + "metadata": {}, + "source": [ + "-m stands for module, and this command is saying that we want to access the medmnist module and run the download function from that module.\n", + "\n", + "Before we continue, let's navigate back to the base directory.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a2cb0640", + "metadata": {}, + "outputs": [], + "source": [ + "%cd ..\n" + ] + }, + { + "cell_type": "markdown", + "id": "0509cadf", + "metadata": {}, + "source": [ + "Now, let's save all PathMNIST pathology images within the dataset folder (located inside the medmnist directory) in PNG format for use in training and inference.\n", + "If you've already gone through this tutorial and are looking to try using a different MedMNIST dataset, simply change --flag=pathmnist to any of the other datasets that were downloaded above—it's as simple as that!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "19db62eb", + "metadata": {}, + "outputs": [], + "source": [ + "!python -m medmnist save --flag=pathmnist --folder=medmnist/dataset/ --postfix=png" + ] + }, + { + "cell_type": "markdown", + "id": "cbcb07ff", + "metadata": {}, + "source": [ + "The --folder option specifies where to save the downloaded information, and the --postfix option specifies that the images should be saved in png format.\n", + "\n", + "For this tutorial, we will be using the full PathMNIST dataset for training, validation and testing. However, to improve efficiency and save time, you may consider using a fraction of this dataset instead with GaNDLF. \n", + "\n", + "To download the full dataset:\n", + "\n", + "Let's retrieve and download the train_path_full data CSV file within the dataset folder, which consists of ~90,000 images.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4a699380", + "metadata": {}, + "outputs": [], + "source": [ + "!wget -O /content/medmnist/dataset/train_path_full.csv \"https://app.box.com/index.php?rm=box_download_shared_file&shared_name=zzokqk7hjzwmjxvamrxotxu78ihd5az0&file_id=f_972380483494\"" + ] + }, + { + "cell_type": "markdown", + "id": "831324a5", + "metadata": {}, + "source": [ + "location where the file should be saved and what the new filename will be\n", + ". \n", + "Let's retrieve and download the val_path_full data CSV file within the dataset folder, which is the full validation dataset consisting of ~10,000 images. \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "785af619", + "metadata": {}, + "outputs": [], + "source": [ + "!wget -O /content/medmnist/dataset/val_path_full.csv \"https://app.box.com/index.php?rm=box_download_shared_file&shared_name=bjoh6hn27l6ifqqtrs7w66za2hdwlu0a&file_id=f_990373191120\"" + ] + }, + { + "cell_type": "markdown", + "id": "37bd1888", + "metadata": {}, + "source": [ + "For the last of the data CSV files, let's retrieve and download the test_path_full data CSV file within the dataset folder. This CSV file contains ~7200 individual images.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "42d61c84", + "metadata": {}, + "outputs": [], + "source": [ + "!wget -O /content/medmnist/dataset/test_path_full.csv \"https://app.box.com/index.php?rm=box_download_shared_file&shared_name=jjzoifpdly0pmkdaguy0cxbdfkig81eq&file_id=f_990374552591\"" + ] + }, + { + "cell_type": "markdown", + "id": "55be009b", + "metadata": {}, + "source": [ + "To download the “tiny” dataset:\n", + "\n", + "Let's retrieve and download the train_path_tiny data CSV file within the dataset folder, which consists of ~4,000 images.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2d63bf0e", + "metadata": {}, + "outputs": [], + "source": [ + "!wget -O /content/medmnist/dataset/train_path_full.csv \"https://app.box.com/index.php?rm=box_download_shared_file&shared_name=um4003lkrvyj55jm4a0jz7zsuokb0r8o&file_id=f_991821586980\"" + ] + }, + { + "cell_type": "markdown", + "id": "e7d39d90", + "metadata": {}, + "source": [ + "Let's retrieve and download the val_path_tiny data CSV file within the dataset folder, which consists of ~1,000 images. \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e0054486", + "metadata": {}, + "outputs": [], + "source": [ + "!wget -O /content/medmnist/dataset/val_path_full.csv \"https://app.box.com/index.php?rm=box_download_shared_file&shared_name=rsmff27sm2z34r5xso1jx8xix7nhfspc&file_id=f_991817441206\"" + ] + }, + { + "cell_type": "markdown", + "id": "5a1b249b", + "metadata": {}, + "source": [ + "For the last of the data CSV files, let's retrieve and download the test_path_full data CSV file within the dataset folder. This CSV file contains 500 individual images.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fdc098fe", + "metadata": {}, + "outputs": [], + "source": [ + "!wget -O /content/medmnist/dataset/test_path_full.csv \"https://app.box.com/index.php?rm=box_download_shared_file&shared_name=22lm0qfzk5luap72mtdpzx5l3ocflopa&file_id=f_991819617152\"\n" + ] + }, + { + "cell_type": "markdown", + "id": "cad43170", + "metadata": {}, + "source": [ + "Command-Line Interface Note: If you run into any issues when trying to download these files, you can copy and paste these links into your web browser to download the .csv files. Then, you can manually place them into the desired directory using your file manager.\n", + "\n", + "\n", + "Now, we will retrieve and download the config YAML file to the base directory. This file specifies important information to be used in training and inference (model and training parameters, data preprocessing specifications, etc.).\n", + "\n", + "For the purposes of this tutorial, we have already constructed this file to fit our specific task, but for other tasks and experiments that you may want to run, this file will need to be edited to fit the required specifications of your experiment. However, the overall structure of this file will stay the same regardless of your task, so you should be able to get by by simply downloading and editing the config.yaml file we're using below for use in your own experiments.\n", + "\n", + "Either way, we highly encourage you to download and take a look at the structure of this file before proceeding if you intend to use GaNDLF for your own experiments, as it will be the backbone of all tasks you use GaNDLF with in the future. The file contains comments explaining the various parameters and what they mean. If you plan on trying to use any of the other datasets, specifically the 3D ones, make sure to change the number of dimensions on line 11 of the file to 3. \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e71a3bfa", + "metadata": {}, + "outputs": [], + "source": [ + "!wget -O config.yaml \"https://app.box.com/index.php?rm=box_download_shared_file&shared_name=hs0zwezggl4rxtzgrcaq86enu7qwuvqx&file_id=f_974251081617\"" + ] + }, + { + "cell_type": "markdown", + "id": "5be6bb2f", + "metadata": {}, + "source": [ + "Finally, let's retrieve and download an updated copy of the gandlf_collectStats file to the base directory for use in plotting and visualizing our results. While an earlier version of this file is present in the GaNDLF repo, it is not suitable for classification tasks and has been modified for this tutorial to produce classification training and validation accuracy and loss plots. This file will be included in the GaNDLF repo in a future update, but for now, we will retrieve the updated file externally for use in this tutorial.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4309c31e", + "metadata": {}, + "outputs": [], + "source": [ + "!wget -O gandlf_collectStats_final \"https://app.box.com/index.php?rm=box_download_shared_file&shared_name=avq6pvqg3uzsc4uzbklab66mad6eaik5&file_id=f_989875069231\"" + ] + }, + { + "cell_type": "markdown", + "id": "41871543", + "metadata": {}, + "source": [ + "Let's visualize some sample images and their classes from the PathMNIST dataset.\n", + "Image classes for reference:\n", + "Class 0: Adipose\n", + "Class 1: Background\n", + "Class 2: Debris\n", + "Class 3: Lymphocytes\n", + "Class 4: Mucus\n", + "Class 5: Smooth Muscle\n", + "Class 6: Normal Colon Mucosa\n", + "Class 7: Cancer-Associated Stroma\n", + "Class 8: Colorectal Adenocarcinoma Epithelium\n", + "\n", + "Before running the code below, make sure you enter the python shell again if you are using a command line interface. \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3f322c5e", + "metadata": {}, + "outputs": [], + "source": [ + "#Step 1\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.image as mpimg\n", + "import pandas as pd\n", + "\n", + "\n", + "#Step 2\n", + "df_pathmnist = pd.read_csv('./medmnist/dataset/pathmnist.csv')\n", + "\n", + "\n", + "#Step 3\n", + "selected_images = [32, 36, 46, 13, 14, 8, 12, 18, 5, 6, 17, 0, 16, 3, 7, 10, 43, 45, 55, 1, 31, 41, 4, 9, 11]\n", + "\n", + "\n", + "#Step 4\n", + "fig, ax = plt.subplot_mosaic([\n", + " ['img0', 'img1', 'img2', 'img3', 'img4'],\n", + " ['img5', 'img6', 'img7', 'img8', 'img9'],\n", + " ['img10', 'img11', 'img12', 'img13', 'img14'],\n", + " ['img15', 'img16', 'img17', 'img18', 'img19'],\n", + " ['img20', 'img21', 'img22', 'img23', 'img24']\n", + "], figsize=(15, 15))\n", + "\n", + "\n", + "#Step 5\n", + "for i in range(len(selected_images)):\n", + " img = selected_images[i]\n", + " filename = df_pathmnist.iloc[img]['train0_0.png']\n", + " img_class = df_pathmnist.iloc[img]['0']\n", + "\n", + "\n", + " path_img = mpimg.imread(f'./medmnist/dataset/pathmnist/{filename}')\n", + "\n", + "\n", + " ax[f'img{i}'].imshow(path_img)\n", + " ax[f'img{i}'].axis('off')\n", + " ax[f'img{i}'].set_title(f'Class {img_class}')\n", + "\n", + "\n", + "#Step 6\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "c18e375e", + "metadata": {}, + "source": [ + "Let’s quickly go over what exactly this code is doing.\n", + "1. We import all of the necessary libraries, such as matplotlib(which we discussed earlier) and pandas, which is a Python library that provides methods for data manipulation. \n", + "2. The file paths for the PathMNIST images are read and stored in the df_pathmnist variable. \n", + "3. We initialize the selected_images variable which stores an array of integers. These integers represent the indices of the images from the pathmnist dataset we want to display. You can also try changing some of these values to see the different displayed plots and see more images in the dataset. \n", + "4. We create a 5x5 grid of subplots to display our 25 images.\n", + "5. We iterate through the selected_images array and read the corresponding image files. Then, we display the images in the proper subplots.\n", + "6. Finally, plt.show() displays the plot we have created. \n", + "\n", + "Your resulting plot should have an assortment of images from the PathMNIST set including images from all of class 0-8.\n", + "\n", + "Let’s quickly go over what these different classes are by using the results above:\n", + "\n", + "Class 0: Adipose\n", + "Adipose tissue is just tissue that stores fat. This tissue is made up of adipocytes, or fat cells, which store energy.\n", + "\n", + "\n", + "\n", + "Class 1: Background\n", + "The background class represents the non-tissue areas of the image that aren’t necessarily areas of interest.\n", + "\n", + "\n", + "\n", + "Class 2: Debris\n", + "Class 2 contains images of miscellaneous non-living particles or materials found in the colon.\n", + "\n", + "\n", + "\n", + "Class 3: Lymphocytes \n", + "Class 4 contains images of lymphocytes. Lymphocytes are a type of white blood cell that play a significant role in the immune system.\n", + "\n", + "\n", + "\n", + "Class 4: Mucus\n", + "Class 4 contains images of normal mucus that is found in healthy colons.\n", + "\n", + "\n", + "\n", + "\n", + "Class 5: Smooth Muscle\n", + "Class 5 contains images of smooth muscle tissue that is seen in the walls of the colon.\n", + "\n", + "\n", + "\n", + "Class 6: Normal Colon Mucosa\n", + "Class 6 contains images of the colon mucosa, which lines the colon.\n", + "\n", + "\n", + "\n", + "\n", + "Class 7: Cancer-Associated Stroma\n", + "Class 7 contains images of stroma, which is supportive tissue that provides tumors with nutrients and protection to assist in the cancer’s survival.\n", + "\n", + "\n", + "\n", + "\n", + "Class 8: Colorectal Adenocarcinoma Epithelium\n", + "The epithelium is the tissue that lines the colon, and Class 8 contains images of epithelial cells affected by colorectal adenocarcinoma, a type of cancer.\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "5195c707", + "metadata": {}, + "source": [ + "Now, on to training! Since there is only one GPU, let's set CUDA_VISIBLE_DEVICES to 0 to train on the first (and only) available GPU. The way to execute this code will vary based on what you are running your code on.\n", + "\n", + "On Colab run this Python code: \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2afcc3d0", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"]=\"0\"" + ] + }, + { + "cell_type": "markdown", + "id": "91a977dc", + "metadata": {}, + "source": [ + "If you are following these instructions on your own command line interface, instead run the following: \n", + "\n", + "export \"CUDA_VISIBLE_DEVICES\"=\"0\"" + ] + }, + { + "cell_type": "markdown", + "id": "8a2d6e30", + "metadata": {}, + "source": [ + "Let's run the training script! For this run, we will pass in the config.yaml file that we just downloaded to the -c parameter, the training and validation CSV files to the -i parameter, and the model directory to the -m parameter (folder will automatically be created if it doesn't exist, which, in our case, it doesn't). We will also specify -t True to indicate that we are training and -d cuda to indicate that we will be training on the GPU. For demonstration purposes, we will only be training on 5 epochs. The number of epochs is the number of times that the model will pass through the entire training dataset during the training process. In our case, the model will pass through the dataset 5 times. \n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f01f2dab", + "metadata": {}, + "outputs": [], + "source": [ + "!python /content/GaNDLF/gandlf_run -c /content/config.yaml -i /content/medmnist/dataset/train_path_full.csv,/content/medmnist/dataset/val_path_full.csv -m /content/model/ -t True -d cuda\n" + ] + }, + { + "cell_type": "markdown", + "id": "7a508061", + "metadata": {}, + "source": [ + "\n", + "You will likely notice a persistent error saying \"y_pred contains classes not in y_true\"--this is a known issue and will not affect our training performance, so feel free to ignore it.\n", + "\n", + "If your program stops for any reason and you try to run it again, you may see this error:\n", + "ValueError: The parameters are not the same as the ones stored in the previous run, please re-check.\n", + "To resolve this, delete the existing model by deleting the “model” file and then try executing the command again. \n", + "\n", + "Potential Google Colab Error: If your Google Colab notebook is not correctly using the GPU, the program may run out of RAM and stop during the process of constructing the queue for training data. \n", + "\n", + "Now that training is complete, let's collect and save model statistics to the output_stats folder. Using -c True indicates that we'd like the 4 plots ordinarily generated by this command to be combined into two plots by overlaying training and validation statistics on the same graphs instead of keeping them separate. Feel free to experiment with this command by using -c False instead and viewing the resulting plots.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "aaa90885", + "metadata": {}, + "outputs": [], + "source": [ + "!python /content/gandlf_collectStats_final -m /content/model/ -o /content/output_stats -c True" + ] + }, + { + "cell_type": "markdown", + "id": "5840544b", + "metadata": {}, + "source": [ + "Now, let's view our generated plots! Make sure to enter the Python shell if you are working in the command line interface.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "85a53674", + "metadata": {}, + "outputs": [], + "source": [ + "from IPython.display import Image\n", + "Image(\"/content/output_stats/plot.png\", width=1500, height=1000)" + ] + }, + { + "cell_type": "markdown", + "id": "3a823e40", + "metadata": {}, + "source": [ + "Your results should show both an Accuracy Plot and a Loss Plot.\n", + "\n", + "Since we only trained the model on a very small number of epochs, we shouldn't be expecting very impressive results here. However, from the graphs, we can tell that accuracy is steadily increasing and loss is steadily decreasing, which is a great sign.\n", + "\n", + "Finally, let's run the inference script. This is almost identical to running the training script; however, note that the argument for the -t parameter has been changed from True to False to specify that we are not training, and we are using the test_path_full csv file to access the testing images.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2ba2b24a", + "metadata": {}, + "outputs": [], + "source": [ + "!python /content/GaNDLF/gandlf_run -c /content/config.yaml -i /content/medmnist/dataset/test_path_full.csv -m /content/model/ -t False -d cuda" + ] + }, + { + "cell_type": "markdown", + "id": "b3e630c0", + "metadata": {}, + "source": [ + "Now that inference is complete, let's view some sample test images along with their predicted and ground truth classes to get a visual idea of how well our model did on each class. Remember to enter the Python shell if you are using the command line interface." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6c2dbdf6", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import matplotlib.image as mpimg\n", + "import pandas as pd\n", + "\n", + "\n", + "df_preds = pd.read_csv('./model/final_preds_and_avg_probs.csv')\n", + "\n", + "\n", + "selected_images = [4, 7, 14, 22, 26, 3, 11, 17, 37, 45, 52, 1, 2, 40, 47, 76, 8, 13, 28, 19, 36, 79, 0, 9, 10]\n", + "\n", + "\n", + "fig, ax = plt.subplot_mosaic([\n", + " ['img0', 'img1', 'img2', 'img3', 'img4'],\n", + " ['img5', 'img6', 'img7', 'img8', 'img9'],\n", + " ['img10', 'img11', 'img12', 'img13', 'img14'],\n", + " ['img15', 'img16', 'img17', 'img18', 'img19'],\n", + " ['img20', 'img21', 'img22', 'img23', 'img24']\n", + "], figsize=(13, 13), constrained_layout = True)\n", + "\n", + "\n", + "for i in range(len(selected_images)):\n", + " img = selected_images[i]\n", + " filename = df_preds.iloc[img]['SubjectID']\n", + " ground_truth = filename.split('_')[1].split('.')[0]\n", + " pred_class = df_preds.iloc[img]['PredictedClass']\n", + "\n", + " path_img = mpimg.imread(f'./medmnist/dataset/pathmnist/{filename}')\n", + "\n", + "\n", + " ax[f'img{i}'].imshow(path_img)\n", + " ax[f'img{i}'].axis('off')\n", + " ax[f'img{i}'].set_title(f'Predicted Class: {pred_class}\\nGround . Truth: {ground_truth}')\n", + "\n", + "\n", + "plt.show()\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "9268f2ca", + "metadata": {}, + "source": [ + "Your produced plot should contain 16 images from the PathMNIST set, and each image should be accompanied by both a Predicted Class and a Ground Truth label. \n", + "\n", + "We can see that our model did a decent job of making predictions. However, we can see that it has a few common misconceptions. We can see that the model mistook smooth muscle for debris thrice and cancer-associated stroma for debris once. The model also mistook mucus as adipose twice, and it mistook Colorectal Adenocarcinoma Epithelium as Normal Colon Mucosa once.\n", + "\n", + "\n", + "To conclude this tutorial, let's zoom out and take a look at how well our model did as a whole on each class by constructing a confusion matrix from our inference data.\n", + "Note: if you'd like, feel free to change the colormap of the confusion matrix (denoted by \"cmap\" in the cm_display.plot() command) to your liking. Here's a list of some of the most popular colormaps: viridis (default), plasma, inferno, magma, cividis.\n", + "\n", + "Execute the following code in the Python shell: \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b827c049", + "metadata": {}, + "outputs": [], + "source": [ + "import sklearn\n", + "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay\n", + "\n", + "\n", + "gt_list = []\n", + "pred_list = []\n", + "\n", + "\n", + "for i in range(len(df_preds)):\n", + " filename = df_preds.iloc[i]['SubjectID']\n", + "\n", + "\n", + " ground_truth = int(filename.split('_')[1].split('.')[0])\n", + " pred_class = int(df_preds.iloc[i]['PredictedClass'])\n", + "\n", + "\n", + " gt_list.append(ground_truth)\n", + " pred_list.append(pred_class)\n", + "\n", + "\n", + "cm = confusion_matrix(gt_list, pred_list)\n", + "cm_display = ConfusionMatrixDisplay(confusion_matrix = cm)\n", + "\n", + "\n", + "fig, ax = plt.subplots(figsize = (12, 12))\n", + "cm_display.plot(cmap = 'viridis', ax = ax)\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "607a9dd8", + "metadata": {}, + "source": [ + "Let’s quickly go over this code:\n", + "\n", + "1. We import the Scikit-Learn library, and we will be using this library's methods of creating confusion matrices. \n", + "\n", + "2. We create empty lists gt_list and pred_list to store our ground truth and predicted labels respectively.\n", + "\n", + "3. The for loop iterates through df_preds and extracts the ground truth label and the predicted class for each image and then appends the labels to their corresponding lists.\n", + "\n", + "4. We create a confusion matrix from these two lists and then call the plot() method to visualize it with our desired colormap.\n", + "\n", + "5. We display the confusion matrix using plt.show().\n" + ] + }, + { + "cell_type": "markdown", + "id": "dff24079", + "metadata": {}, + "source": [ + "Your resulting plot should be a 9x9 matrix that displays Predicted label vs. True label\n", + "\n", + "In our matrix, larger numbers along the diagonal represent correct classifications. Here, we can see that while the model performed well overall, it had difficulties when it came to images of Class 7, incorrectly predicting a majority of them as belonging to Class 2 instead. We can see a similar trend with images of Class 5, with the model incorrectly predicting most of them as belonging to Class 2.\n", + "\n", + "Given the appearance of the accuracy and loss plots, had we trained on more epochs, we would have expected these results to improve. However, given that we only trained on 5 epochs, these are great results. Indeed, the model did very well on other classes, including Classes 0 and 1.\n", + "\n", + "That concludes this GaNDLF tutorial! Hopefully, this tutorial was helpful to you in understanding how GaNDLF works as well as how to apply it to your own projects. If you need any additional information about GaNDLF's usage and capabilities, please consult the GitHub repo (https://github.com/CBICA/GaNDLF) and the documentation (https://cbica.github.io/GaNDLF/). For more questions and support, please visit the Discussions page on GitHub (https://github.com/CBICA/GaNDLF/discussions)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8f91563c", + "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.10.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From eab5297b2935e147ae90f8c05a1ea53d0e9fa7ba Mon Sep 17 00:00:00 2001 From: vavali08 <119764082+vavali08@users.noreply.github.com> Date: Wed, 26 Jul 2023 12:27:42 -0400 Subject: [PATCH 05/15] Rename GaNDLF Tutorial without output.ipynb to classification_tutorial --- ...NDLF Tutorial without output.ipynb => classification_tutorial} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename tutorials/{GaNDLF Tutorial without output.ipynb => classification_tutorial} (100%) diff --git a/tutorials/GaNDLF Tutorial without output.ipynb b/tutorials/classification_tutorial similarity index 100% rename from tutorials/GaNDLF Tutorial without output.ipynb rename to tutorials/classification_tutorial From 1a06680ba75628f8ce34fe075fa4f6868df600ec Mon Sep 17 00:00:00 2001 From: vavali08 <119764082+vavali08@users.noreply.github.com> Date: Wed, 26 Jul 2023 12:28:02 -0400 Subject: [PATCH 06/15] Rename classification_tutorial to classification_tutorial.ipynb --- .../{classification_tutorial => classification_tutorial.ipynb} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename tutorials/{classification_tutorial => classification_tutorial.ipynb} (100%) diff --git a/tutorials/classification_tutorial b/tutorials/classification_tutorial.ipynb similarity index 100% rename from tutorials/classification_tutorial rename to tutorials/classification_tutorial.ipynb From 17dcd1a7bbe189ee4b52127e81b786bdc7198d6a Mon Sep 17 00:00:00 2001 From: vavali08 <119764082+vavali08@users.noreply.github.com> Date: Fri, 28 Jul 2023 14:50:33 -0400 Subject: [PATCH 07/15] Update classification_tutorial.ipynb --- tutorials/classification_tutorial.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tutorials/classification_tutorial.ipynb b/tutorials/classification_tutorial.ipynb index 4d882083d..863889358 100644 --- a/tutorials/classification_tutorial.ipynb +++ b/tutorials/classification_tutorial.ipynb @@ -52,7 +52,7 @@ "\n", "Let's get started! First, we will clone the GaNDLF repo.\n", "\n", - "Google Colab Note: Because the default version of Python in Colab (3.7) is not supported by the NumPy version used in the current version of GaNDLF, we will be cloning an earlier tag of the GaNDLF repo for this tutorial.\n" + "Google Colab Note: If you are following these steps on Google Colab, replace 0.0.16 in the line of code below with 0.0.14, as the default version of Python in Colab (3.7) is not supported by the NumPy version used in the current version of GaNDLF.\n" ] }, { @@ -62,7 +62,7 @@ "metadata": {}, "outputs": [], "source": [ - "!git clone -b 0.0.14 --depth 1 https://github.com/CBICA/GaNDLF.git" + "!git clone -b 0.0.16 --depth 1 https://github.com/CBICA/GaNDLF.git" ] }, { From 8f50ddb01187348b0568ad6b72d280606ca1d5ab Mon Sep 17 00:00:00 2001 From: vavali08 <119764082+vavali08@users.noreply.github.com> Date: Fri, 28 Jul 2023 14:52:17 -0400 Subject: [PATCH 08/15] Create temp --- tutorials/classification_tutorial_notebook/temp | 1 + 1 file changed, 1 insertion(+) create mode 100644 tutorials/classification_tutorial_notebook/temp diff --git a/tutorials/classification_tutorial_notebook/temp b/tutorials/classification_tutorial_notebook/temp new file mode 100644 index 000000000..8b1378917 --- /dev/null +++ b/tutorials/classification_tutorial_notebook/temp @@ -0,0 +1 @@ + From 17a5be1cbac87d731ddceb8219dbbb81c2d259ea Mon Sep 17 00:00:00 2001 From: vavali08 <119764082+vavali08@users.noreply.github.com> Date: Fri, 28 Jul 2023 14:52:40 -0400 Subject: [PATCH 09/15] Rename tutorials/classification_tutorial.ipynb to tutorials/classification_tutorial_notebook/classification_tutorial.ipynb --- .../classification_tutorial.ipynb | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename tutorials/{ => classification_tutorial_notebook}/classification_tutorial.ipynb (100%) diff --git a/tutorials/classification_tutorial.ipynb b/tutorials/classification_tutorial_notebook/classification_tutorial.ipynb similarity index 100% rename from tutorials/classification_tutorial.ipynb rename to tutorials/classification_tutorial_notebook/classification_tutorial.ipynb From e49befeeda9ebcfa69ebe06dc905b84ff45c2be4 Mon Sep 17 00:00:00 2001 From: vavali08 <119764082+vavali08@users.noreply.github.com> Date: Fri, 28 Jul 2023 14:53:01 -0400 Subject: [PATCH 10/15] Delete temp --- tutorials/classification_tutorial_notebook/temp | 1 - 1 file changed, 1 deletion(-) delete mode 100644 tutorials/classification_tutorial_notebook/temp diff --git a/tutorials/classification_tutorial_notebook/temp b/tutorials/classification_tutorial_notebook/temp deleted file mode 100644 index 8b1378917..000000000 --- a/tutorials/classification_tutorial_notebook/temp +++ /dev/null @@ -1 +0,0 @@ - From 3e622c7a613de767dfa1b850814048f4a0f34be6 Mon Sep 17 00:00:00 2001 From: vavali08 <119764082+vavali08@users.noreply.github.com> Date: Mon, 14 Aug 2023 17:29:18 -0400 Subject: [PATCH 11/15] Rename classification_tutorial.ipynb to classification_tutorial.ipynb --- .../classification_tutorial.ipynb | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename tutorials/{classification_tutorial_notebook => classification_pathmnist_notebook}/classification_tutorial.ipynb (100%) diff --git a/tutorials/classification_tutorial_notebook/classification_tutorial.ipynb b/tutorials/classification_pathmnist_notebook/classification_tutorial.ipynb similarity index 100% rename from tutorials/classification_tutorial_notebook/classification_tutorial.ipynb rename to tutorials/classification_pathmnist_notebook/classification_tutorial.ipynb From 22ca75fd3b26037e3008299b2628f9df98cabf28 Mon Sep 17 00:00:00 2001 From: vavali08 <119764082+vavali08@users.noreply.github.com> Date: Mon, 14 Aug 2023 17:30:10 -0400 Subject: [PATCH 12/15] Update classification_tutorial.ipynb --- .../classification_tutorial.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tutorials/classification_pathmnist_notebook/classification_tutorial.ipynb b/tutorials/classification_pathmnist_notebook/classification_tutorial.ipynb index 863889358..187eed3a8 100644 --- a/tutorials/classification_pathmnist_notebook/classification_tutorial.ipynb +++ b/tutorials/classification_pathmnist_notebook/classification_tutorial.ipynb @@ -62,7 +62,7 @@ "metadata": {}, "outputs": [], "source": [ - "!git clone -b 0.0.16 --depth 1 https://github.com/CBICA/GaNDLF.git" + "!pip install gandlf" ] }, { From 4373ea51ce0da31c7b957739c03a1312ae97c0f1 Mon Sep 17 00:00:00 2001 From: vavali08 <119764082+vavali08@users.noreply.github.com> Date: Mon, 14 Aug 2023 17:33:07 -0400 Subject: [PATCH 13/15] Add files via upload --- .../config (3).yaml | 200 ++++++++++++++++++ 1 file changed, 200 insertions(+) create mode 100644 tutorials/classification_pathmnist_notebook/config (3).yaml diff --git a/tutorials/classification_pathmnist_notebook/config (3).yaml b/tutorials/classification_pathmnist_notebook/config (3).yaml new file mode 100644 index 000000000..e6097abd6 --- /dev/null +++ b/tutorials/classification_pathmnist_notebook/config (3).yaml @@ -0,0 +1,200 @@ +# affix version +version: + { + minimum: 0.0.14, + maximum: 0.0.14 # this should NOT be made a variable, but should be tested after every tag is created + } +# Choose the model parameters here + +model: + { + dimension: 2, # the dimension of the model and dataset: defines dimensionality of computations + base_filters: 32, # Set base filters: number of filters present in the initial module of the U-Net convolution; for IncU-Net, keep this divisible by 4 + architecture: vgg, # options: unet, resunet, fcn, uinc, vgg, densenet + batch_norm: True, # this is only used for vgg + norm_type: batch, + final_layer: sigmoid, # can be either sigmoid, softmax or none (none == regression) + amp: False, # Set if you want to use Automatic Mixed Precision for your operations or not - options: True, False + n_channels: 3, # set the input channels - useful when reading RGB or images that have vectored pixel types + class_list: ["0", "1", "2", "3", "4", "5", "6", "7", "8"] # changed for pathmnist + } +# this is to enable or disable lazy loading - setting to true reads all data once during data loading, resulting in improvements +# in I/O at the expense of memory consumption +in_memory: False +# this will save the generated masks for validation and testing data for qualitative analysis +save_masks: False +# Set the Modality : rad for radiology, path for histopathology +modality: rad +# Patch size during training - 2D patch for breast images since third dimension is not patched +patch_size: [256, 256] +# uniform: UniformSampler or label: LabelSampler +patch_sampler: uniform +#metrics: ["classification_accuracy"] +#metrics: ["accuracy"] +metrics: + #- cel + - classification_accuracy + - f1: { + average: weighted, + } + - accuracy + - balanced_accuracy + # - precision: { + # average: weighted, + # } + # - recall + # - iou: { + # reduction: sum, + # } +# Number of epochs +num_epochs: 5 +# Set the patience - measured in number of epochs after which, if the performance metric does not improve, exit the training loop - defaults to the number of epochs +patience: 5 +# Set the batch size +batch_size: 16 +# Set the initial learning rate +learning_rate: 0.001 +# Learning rate scheduler - options: triangle, triangle_modified, exp, reduce-on-lr, step, more to come soon - default hyperparameters can be changed thru code +scheduler: triangle +# Set which loss function you want to use - options : 'dc' - for dice only, 'dcce' - for sum of dice and CE and you can guess the next (only lower-case please) +# options: dc (dice only), dc_log (-log of dice), ce (), dcce (sum of dice and ce), mse () ... +# mse is the MSE defined by torch and can define a variable 'reduction'; see https://pytorch.org/docs/stable/generated/torch.nn.MSELoss.html#torch.nn.MSELoss +# use mse_torch for regression/classification problems and dice for segmentation +loss_function: cel +# this parameter weights the loss to handle imbalanced losses better +weighted_loss: True +#loss_function: +# { +# 'mse':{ +# 'reduction': 'mean' # see https://pytorch.org/docs/stable/generated/torch.nn.MSELoss.html#torch.nn.MSELoss for all options +# } +# } +# Which optimizer do you want to use - adam/sgd +opt: adam +# this parameter controls the nested training process +# performs randomized k-fold cross-validation +# split is performed using sklearn's KFold method +# for single fold run, use '-' before the fold number +nested_training: + { + testing: 1, # this controls the testing data splits for final model evaluation; use '1' if this is to be disabled + validation: -5 # this controls the validation data splits for model training + } +## pre-processing +# this constructs an order of transformations, which is applied to all images in the data loader +# order: resize --> threshold/clip --> resample --> normalize +# 'threshold': performs intensity thresholding; i.e., if x[i] < min: x[i] = 0; and if x[i] > max: x[i] = 0 +# 'clip': performs intensity clipping; i.e., if x[i] < min: x[i] = min; and if x[i] > max: x[i] = max +# 'threshold'/'clip': if either min/max is not defined, it is taken as the minimum/maximum of the image, respectively +# 'normalize': performs z-score normalization: https://torchio.readthedocs.io/transforms/preprocessing.html?highlight=ToCanonical#torchio.transforms.ZNormalization +# 'normalize_nonZero': perform z-score normalize but with mean and std-dev calculated on only non-zero pixels +# 'normalize_nonZero_masked': perform z-score normalize but with mean and std-dev calculated on only non-zero pixels with the stats applied on non-zero pixels +# 'crop_external_zero_planes': crops all non-zero planes from input tensor to reduce image search space +# 'resample: resolution: X,Y,Z': resample the voxel resolution: https://torchio.readthedocs.io/transforms/preprocessing.html?highlight=ToCanonical#torchio.transforms.Resample +# 'resample: resolution: X': resample the voxel resolution in an isotropic manner: https://torchio.readthedocs.io/transforms/preprocessing.html?highlight=ToCanonical#torchio.transforms.Resample +# resize the image(s) and mask (this should be greater than or equal to patch_size); resize is done ONLY when resample is not defined + + +# data_augmentation: +# { +# # 'spatial':{ +# # 'probability': 0.5 +# # }, +# # 'kspace':{ +# # 'probability': 0.5 +# # }, +# 'bias':{ +# 'probability': 0.5 +# }, +# 'blur':{ +# 'probability': 0.5 +# }, +# 'noise':{ +# 'probability': 0.5 +# }, +# 'swap':{ +# 'probability': 0.5 +# } +# } + +data_preprocessing: + { + #'normalize_div_by_255', + # 'threshold':{ + # 'min': 10, + # 'max': 75 + # }, + # 'clip':{ + # 'min': 10, + # 'max': 75 + # }, + #'normalize_imagenet', + # 'resample':{ + # 'resolution': [1,2,3] + # }, + 'resize': [256,256], # this is generally not recommended, as it changes image properties in unexpected ways + #'resize_image': [256,256], #resizes the image and mask BEFORE applying any another operation + #'resize_patch': [256,256] #resizes the image and mask AFTER extracting the patch + } +# data_preprocessing: +# { +# # 'normalize', +# # # 'normalize_nonZero', # this performs z-score normalization only on non-zero pixels +# # 'resample':{ +# # 'resolution': [1,2,3] +# # }, + #'resize': [128, 128], # this is generally not recommended, as it changes image properties in unexpected ways +# # 'crop_external_zero_planes', # this will crop all zero-valued planes across all axes +# } +# various data augmentation techniques +# options: affine, elastic, downsample, motion, ghosting, bias, blur, gaussianNoise, swap +# keep/edit as needed +# all transforms: https://torchio.readthedocs.io/transforms/transforms.html?highlight=transforms +# 'kspace': one of motion, ghosting or spiking is picked (randomly) for augmentation +# 'probability' subkey adds the probability of the particular augmentation getting added during training (this is always 1 for normalize and resampling) +# data_augmentation: + # { + # default_probability: 0.5, + # 'affine', + # 'elastic', + # 'kspace':{ + # 'probability': 1 + # }, + # 'bias', + # 'blur': { + # 'std': [0, 1] # default std-dev range, for details, see https://torchio.readthedocs.io/transforms/augmentation.html?highlight=randomblur#torchio.transforms.RandomBlur + # }, + # 'noise': { # for details, see https://torchio.readthedocs.io/transforms/augmentation.html?highlight=randomblur#torchio.transforms.RandomNoise + # 'mean': 0, # default mean + # 'std': [0, 1] # default std-dev range + # }, + # 'anisotropic':{ + # 'axis': [0,1], + # 'downsampling': [2,2.5] + # }, + # } +# parallel training on HPC - here goes the command to prepend to send to a high performance computing +# cluster for parallel computing during multi-fold training +# not used for single fold training +# this gets passed before the training_loop, so ensure enough memory is provided along with other parameters +# that your HPC would expect +# ${outputDir} will be changed to the outputDir you pass in CLI + '/${fold_number}' +# ensure that the correct location of the virtual environment is getting invoked, otherwise it would pick up the system python, which might not have all dependencies + +# UB_commented: parallel_compute_command: 'qsub -b y -l gpu -l h_vmem=32G -cwd -o ${outputDir}/\$JOB_ID.stdout -e ${outputDir}/\$JOB_ID.stderr `pwd`/sge_wrapper _correct_location_of_virtual_environment_/venv/bin/python', +#parallel_compute_command: '' +## queue configuration - https://torchio.readthedocs.io/data/patch_training.html?#queue +# this determines the maximum number of patches that can be stored in the queue. Using a large number means that the queue needs to be filled less often, but more CPU memory is needed to store the patches + +q_max_length: 5 + +# this determines the number of patches to extract from each volume. A small number of patches ensures a large variability in the queue, but training will be slower + +q_samples_per_volume: 1 + +# this determines the number subprocesses to use for data loading; '0' means main process is used + +q_num_workers: 0 # scale this according to available CPU resources (was 16) + +# used for debugging +q_verbose: False From a21e161dc11de20d1f34335e69aa2e9d4ac9081b Mon Sep 17 00:00:00 2001 From: vavali08 <119764082+vavali08@users.noreply.github.com> Date: Mon, 14 Aug 2023 17:33:31 -0400 Subject: [PATCH 14/15] Update and rename config (3).yaml to config.yaml --- .../{config (3).yaml => config.yaml} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename tutorials/classification_pathmnist_notebook/{config (3).yaml => config.yaml} (100%) diff --git a/tutorials/classification_pathmnist_notebook/config (3).yaml b/tutorials/classification_pathmnist_notebook/config.yaml similarity index 100% rename from tutorials/classification_pathmnist_notebook/config (3).yaml rename to tutorials/classification_pathmnist_notebook/config.yaml From 2e8bb00a79921f9f194a79f5e6697ba301b7722b Mon Sep 17 00:00:00 2001 From: vavali08 <119764082+vavali08@users.noreply.github.com> Date: Thu, 17 Aug 2023 16:52:38 -0400 Subject: [PATCH 15/15] Update config.yaml --- tutorials/classification_pathmnist_notebook/config.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tutorials/classification_pathmnist_notebook/config.yaml b/tutorials/classification_pathmnist_notebook/config.yaml index e6097abd6..f90dea3a1 100644 --- a/tutorials/classification_pathmnist_notebook/config.yaml +++ b/tutorials/classification_pathmnist_notebook/config.yaml @@ -2,7 +2,7 @@ version: { minimum: 0.0.14, - maximum: 0.0.14 # this should NOT be made a variable, but should be tested after every tag is created + maximum: 0.0.16 # this should NOT be made a variable, but should be tested after every tag is created } # Choose the model parameters here