{ "cells": [ { "cell_type": "markdown", "id": "2d9f0b20", "metadata": { "execution": {} }, "source": [ "\"Open   \"Open" ] }, { "cell_type": "markdown", "id": "renayVUI7b9x", "metadata": { "execution": {} }, "source": [ "# Knowledge Extraction from a Convolutional Neural Network\n", "\n", "**By Neuromatch Academy**\n", "\n", "__Content creators:__ Jan Funke\n", "\n", "__Production editors:__ Spiros Chavlis, Konstantine Tsafatinos" ] }, { "cell_type": "markdown", "id": "U6wofKujWp6X", "metadata": { "execution": {} }, "source": [ "---\n", "# Objective\n", "\n", "Train a convolutional neural network to classify images and a CycleGAN to translate between images of different types.\n", "\n", "This notebook contains everything to train a VGG network on labelled images and to train a CycleGAN to translate between images.\n", "\n", "We will use electron microscopy images of Drosophila synapses for this project. Those images can be classified according to the neurotransmitter type they release." ] }, { "cell_type": "markdown", "id": "zO4YN6W8W0Cp", "metadata": { "execution": {} }, "source": [ "---\n", "# Setup" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Install dependencies\n" ] }, { "cell_type": "code", "execution_count": null, "id": "fO1IZwvkW9Me", "metadata": { "cellView": "form", "execution": {}, "tags": [ "hide-input" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m24.0\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m24.1.2\u001b[0m\n", "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n", "\n", "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m24.0\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m24.1.2\u001b[0m\n", "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n", "\n", "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m24.0\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m24.1.2\u001b[0m\n", "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n" ] } ], "source": [ "# @title Install dependencies\n", "!pip install scikit-image --quiet\n", "!pip install pillow --quiet\n", "!pip install scikit-image --quiet" ] }, { "cell_type": "code", "execution_count": null, "id": "gKkHjjTGWzUk", "metadata": { "execution": {} }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/home/yuda/code/neuromatch/course-content-dl/venv/lib/python3.9/site-packages/torch/cuda/__init__.py:619: UserWarning: Can't initialize NVML\n", " warnings.warn(\"Can't initialize NVML\")\n" ] } ], "source": [ "import glob\n", "import json\n", "import torch\n", "import numpy as np\n", "\n", "import matplotlib.pyplot as plt\n", "from tqdm import tqdm\n", "\n", "from skimage.io import imread\n", "from torchvision.datasets import ImageFolder\n", "from torch.utils.data import DataLoader, random_split\n", "from torch.utils.data.sampler import WeightedRandomSampler\n", "\n", "%matplotlib inline" ] }, { "cell_type": "markdown", "id": "bd7d427d", "metadata": { "execution": {} }, "source": [ "---\n", "# Project Ideas\n", "\n", "1. Improve the classifier. This code uses a VGG network for the classification. On the synapse dataset, we will get a validation accuracy of around 80%. Try to see if you can improve the classifier accuracy.\n", " * (easy) Data augmentation: The training code for the classifier is quite simple in this example. Enlarge the amount of available training data by adding augmentations (transpose and mirror the images, add noise, change the intensity, etc.).\n", " * (easy) Network architecture: The VGG network has a few parameters that one can tune. Try a few to see what difference it makes.\n", " * (easy) Inspect the classifier predictions: Take random samples from the test dataset and classify them. Show the images together with their predicted and actual labels.\n", " * (medium) Other networks: Try different architectures (e.g., a ResNet) and see if the accuracy can be improved.\n", " * (medium) Inspect errors made by the classifier. Which classes are most accurately predicted? Which classes are confused with each other?\n", " \n", " \n", "2. Explore the CycleGAN.\n", " * (easy) The example code below shows how to translate between GABA and glutamate. Try different combinations, and also in the reverse direction. Can you start to see differences between some pairs of classes? Which are the ones where the differences are the most or the least obvious?\n", " * (hard) Watching the CycleGAN train can be a bit boring. Find a way to show (periodically) the current image and its translation to see how the network is improving over time. Hint: The `cycle_gan` module has a `Visualizer`, which might be helpful.\n", " \n", "\n", "3. Try on your own data!\n", " * Have a look at how the synapse images are organized in `data/raw/synapses`. Copy the directory structure and use your own images. Depending on your data, you might have to adjust the image size (128x128 for the synapses) and number of channels in the VGG network and CycleGAN code.\n", "\n", "### Acknowledgments\n", "\n", "This notebook was written by Jan Funke, using code from Nils Eckstein and a modified version of the [CycleGAN](https://github.com/junyanz/pytorch-CycleGAN-and-pix2pix) implementation.\n" ] }, { "cell_type": "markdown", "id": "5642d709", "metadata": { "execution": {} }, "source": [ "---\n", "# Train an Image Classifier\n", "\n", "In this section, we will implement and train a VGG classifier to classify images of synapses into one of six classes, corresponding to the neurotransmitter type that is released at the synapse: GABA, acethylcholine, glutamate, octopamine, serotonin, and dopamine." ] }, { "cell_type": "markdown", "id": "c61a11c6", "metadata": { "execution": {} }, "source": [ "## Data Preparation" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Download the data\n" ] }, { "cell_type": "code", "execution_count": null, "id": "821dc497", "metadata": { "cellView": "form", "execution": {}, "tags": [ "hide-input" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Data are already downloaded.\n" ] } ], "source": [ "# @title Download the data\n", "import requests, os\n", "from zipfile import ZipFile\n", "\n", "def download_file_parts(urls, output_directory='.'):\n", " \"\"\"\n", " Download file parts from given URLs and save them in the specified directory.\n", "\n", " :param urls: List of URLs to download\n", " :param output_directory: Directory to save the downloaded parts (default is current directory)\n", " :return: List of downloaded file paths\n", " \"\"\"\n", " if not os.path.exists(output_directory):\n", " os.makedirs(output_directory)\n", "\n", " downloaded_files = []\n", "\n", " for i, url in enumerate(urls, 1):\n", " try:\n", " response = requests.get(url, stream=True)\n", " response.raise_for_status() # Raises an HTTPError for bad requests\n", "\n", " file_name = f\"part{i}\"\n", " file_path = os.path.join(output_directory, file_name)\n", "\n", " with open(file_path, 'wb') as file:\n", " for chunk in response.iter_content(chunk_size=32768):\n", " file.write(chunk)\n", "\n", " downloaded_files.append(file_path)\n", " print(f\"Downloaded: {file_path}\")\n", "\n", "\n", " except requests.RequestException as e:\n", " print(f\"Error downloading {url}: {e}\")\n", "\n", " return downloaded_files\n", "\n", "def reassemble_file(output_file):\n", " chunk_number = 1\n", " with open(output_file, 'wb') as outfile:\n", " while True:\n", " chunk_name = f'part{chunk_number}'\n", " if not os.path.exists(chunk_name):\n", " break\n", " with open(chunk_name, 'rb') as infile:\n", " outfile.write(infile.read())\n", " chunk_number += 1\n", " for i in ['part1', 'part2', 'part3']:\n", " if os.path.exists(i):\n", " os.remove(i)\n", " print(f\"Downloaded files have been removed!\")\n", " print(f\"Reassembled {chunk_number-1} parts into {output_file}\")\n", "\n", "\n", "\n", "# @markdown Download the resources for this tutorial (one zip file)\n", "fname = 'resources.zip'\n", "urls = [\n", " \"https://osf.io/download/4x7p3/\",\n", " \"https://osf.io/download/fzwea/\",\n", " \"https://osf.io/download/qpbcv/\"\n", "]\n", "\n", "if not os.path.exists('data/'):\n", " print('Data downloading...')\n", " output_dir = \".\"\n", " downloaded_parts = download_file_parts(urls, output_dir)\n", " print('Download is completed.')\n", "\n", " print('Reassembling Files...')\n", " base_name = ''\n", " reassemble_file(fname)\n", "\n", " # @markdown Unzip the file\n", " with ZipFile(fname, 'r') as zf:\n", " # extracting all the files\n", " print('Extracting all the files now...')\n", " zf.extractall(path='.')\n", " print('Done!')\n", "\n", " # # @markdown Extract the data\n", " fnames = ['data.zip', 'checkpoints.zip']\n", "\n", " for fname in fnames:\n", " with ZipFile(fname, 'r') as zh:\n", " # extracting all the files\n", " print(f\"\\nArchive: {fname}\")\n", " print(f\"\\tExtracting data...\")\n", " zh.extractall(path='.')\n", " print('Done!')\n", "\n", " # @markdown Make sure the order of classes matches the pretrained model\n", " os.rename('data/raw/synapses/gaba', 'data/raw/synapses/0_gaba')\n", " os.rename('data/raw/synapses/acetylcholine', 'data/raw/synapses/1_acetylcholine')\n", " os.rename('data/raw/synapses/glutamate', 'data/raw/synapses/2_glutamate')\n", " os.rename('data/raw/synapses/serotonin', 'data/raw/synapses/3_serotonin')\n", " os.rename('data/raw/synapses/octopamine', 'data/raw/synapses/4_octopamine')\n", " os.rename('data/raw/synapses/dopamine', 'data/raw/synapses/5_dopamine')\n", "\n", " # @markdown Remove the archives\n", " for i in ['checkpoints.zip', 'experiments.zip', 'data.zip', 'resources.zip']:\n", " if os.path.exists(i):\n", " os.remove(i)\n", "\n", "else:\n", " print('Data are already downloaded.')" ] }, { "cell_type": "markdown", "id": "0b84ec7b", "metadata": { "execution": {} }, "source": [ "## Classifier Training" ] }, { "cell_type": "markdown", "id": "a79ab567", "metadata": { "execution": {} }, "source": [ "### Create and Inspect Datasets\n", "\n", "First, we create a `torch` data loaders for training, validation, and testing. We will use weighted sampling to account for the class imbalance during training." ] }, { "cell_type": "code", "execution_count": null, "id": "ae50b16a", "metadata": { "execution": {} }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Number of images per class:\n", "\t0_gaba:\tn=15945\tweight=6.271558482282847e-05\n", "\t1_acetylcholine:\tn=4852\tweight=0.00020610057708161583\n", "\t2_glutamate:\tn=3556\tweight=0.00028121484814398203\n", "\t3_serotonin:\tn=2316\tweight=0.0004317789291882556\n", "\t4_octopamine:\tn=934\tweight=0.0010706638115631692\n", "\t5_dopamine:\tn=4640\tweight=0.00021551724137931034\n", "\tcycle_gan:\tn=19383\tweight=5.159160088737554e-05\n" ] } ], "source": [ "def load_image(filename):\n", "\n", " image = imread(filename)\n", "\n", " # images are grescale, we only need one of the RGB channels\n", " image = image[:, :, 0]\n", " # img is uint8 in [0, 255], but we want float32 in [-1, 1]\n", " image = image.astype(np.float32)/255.0\n", " image = (image - 0.5)/0.5\n", "\n", " return image\n", "\n", "\n", "# create a dataset for all images of all classes\n", "full_dataset = ImageFolder(root='data/raw/synapses', loader=load_image)\n", "\n", "# randomly split the dataset into train, validation, and test\n", "num_images = len(full_dataset)\n", "# ~70% for training\n", "num_training = int(0.7 * num_images)\n", "# ~15% for validation\n", "num_validation = int(0.15 * num_images)\n", "# ~15% for testing\n", "num_test = num_images - (num_training + num_validation)\n", "# split the data randomly (but with a fixed random seed)\n", "train_dataset, validation_dataset, test_dataset = random_split(\n", " full_dataset,\n", " [num_training, num_validation, num_test],\n", " generator=torch.Generator().manual_seed(23061912))\n", "\n", "# compute class weights in training dataset for uniform sampling\n", "ys = np.array([y for _, y in train_dataset])\n", "counts = np.bincount(ys)\n", "label_weights = 1.0 / counts\n", "weights = label_weights[ys]\n", "\n", "print(\"Number of images per class:\")\n", "for c, n, w in zip(full_dataset.classes, counts, label_weights):\n", " print(f\"\\t{c}:\\tn={n}\\tweight={w}\")\n", "\n", "# create a data loader with uniform sampling\n", "sampler = WeightedRandomSampler(weights, len(weights))\n", "# this data loader will serve 8 images in a \"mini-batch\" at a time\n", "dataloader = DataLoader(train_dataset, batch_size=8, drop_last=True, sampler=sampler)" ] }, { "cell_type": "markdown", "id": "e9010bdc", "metadata": { "execution": {} }, "source": [ "The cell below visualizes a single, randomly chosen batch from the training data loader. Feel free to execute this cell multiple times to get a feeling for the dataset. See if you can tell the difference between synapses of different types!" ] }, { "cell_type": "code", "execution_count": null, "id": "3d8c6f3a", "metadata": { "execution": {} }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "def show_batch(x, y):\n", " fig, axs = plt.subplots(1, x.shape[0], figsize=(14, 14), sharey=True)\n", " for i in range(x.shape[0]):\n", " axs[i].imshow(np.squeeze(x[i]), cmap='gray')\n", " axs[i].set_title(train_dataset.dataset.classes[y[i].item()])\n", " plt.show()\n", "\n", "# show a random batch from the data loader\n", "# (run this cell repeatedly to see different batches)\n", "for x, y in dataloader:\n", " show_batch(x, y)\n", " break" ] }, { "cell_type": "markdown", "id": "f882416f", "metadata": { "execution": {} }, "source": [ "### Create a Model, Loss, and Optimizer" ] }, { "cell_type": "code", "execution_count": null, "id": "54f177cc", "metadata": { "execution": {} }, "outputs": [], "source": [ "class Vgg2D(torch.nn.Module):\n", "\n", " def __init__(\n", " self,\n", " input_size,\n", " fmaps=12,\n", " downsample_factors=[(2, 2), (2, 2), (2, 2), (2, 2)],\n", " output_classes=6):\n", "\n", " super(Vgg2D, self).__init__()\n", "\n", " self.input_size = input_size\n", "\n", " current_fmaps = 1\n", " current_size = tuple(input_size)\n", "\n", " features = []\n", " for i in range(len(downsample_factors)):\n", "\n", " features += [\n", " torch.nn.Conv2d(\n", " current_fmaps,\n", " fmaps,\n", " kernel_size=3,\n", " padding=1),\n", " torch.nn.BatchNorm2d(fmaps),\n", " torch.nn.ReLU(inplace=True),\n", " torch.nn.Conv2d(\n", " fmaps,\n", " fmaps,\n", " kernel_size=3,\n", " padding=1),\n", " torch.nn.BatchNorm2d(fmaps),\n", " torch.nn.ReLU(inplace=True),\n", " torch.nn.MaxPool2d(downsample_factors[i])\n", " ]\n", "\n", " current_fmaps = fmaps\n", " fmaps *= 2\n", "\n", " size = tuple(\n", " int(c/d)\n", " for c, d in zip(current_size, downsample_factors[i]))\n", " check = (\n", " s*d == c\n", " for s, d, c in zip(size, downsample_factors[i], current_size))\n", " assert all(check), \\\n", " \"Can not downsample %s by chosen downsample factor\" % \\\n", " (current_size,)\n", " current_size = size\n", "\n", " self.features = torch.nn.Sequential(*features)\n", "\n", " classifier = [\n", " torch.nn.Linear(\n", " current_size[0] *\n", " current_size[1] *\n", " current_fmaps,\n", " 4096),\n", " torch.nn.ReLU(inplace=True),\n", " torch.nn.Dropout(),\n", " torch.nn.Linear(\n", " 4096,\n", " 4096),\n", " torch.nn.ReLU(inplace=True),\n", " torch.nn.Dropout(),\n", " torch.nn.Linear(\n", " 4096,\n", " output_classes)\n", " ]\n", "\n", " self.classifier = torch.nn.Sequential(*classifier)\n", "\n", " def forward(self, raw):\n", "\n", " # add a channel dimension to raw\n", " shape = tuple(raw.shape)\n", " raw = raw.reshape(shape[0], 1, shape[1], shape[2])\n", "\n", " # compute features\n", " f = self.features(raw)\n", " f = f.view(f.size(0), -1)\n", "\n", " # classify\n", " y = self.classifier(f)\n", "\n", " return y" ] }, { "cell_type": "code", "execution_count": null, "id": "5da43245", "metadata": { "execution": {} }, "outputs": [], "source": [ "# get the size of our images\n", "for x, y in train_dataset:\n", " input_size = x.shape\n", " break\n", "\n", "# create the model to train\n", "model = Vgg2D(input_size)\n", "\n", "# create a loss\n", "loss = torch.nn.CrossEntropyLoss()\n", "\n", "# create an optimzer\n", "optimizer = torch.optim.Adam(model.parameters(), lr=1e-4)" ] }, { "cell_type": "markdown", "id": "01688095", "metadata": { "execution": {} }, "source": [ "### Train the Model" ] }, { "cell_type": "code", "execution_count": null, "id": "fa65090d", "metadata": { "execution": {} }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Will use device cpu for training\n" ] } ], "source": [ "# use a GPU, if it is available\n", "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", "model.to(device)\n", "print(f\"Will use device {device} for training\")" ] }, { "cell_type": "markdown", "id": "ecbab4f7", "metadata": { "execution": {} }, "source": [ "The next cell merely defines some convenience functions for training, validation, and testing:" ] }, { "cell_type": "code", "execution_count": null, "id": "1a8c7fe9", "metadata": { "execution": {} }, "outputs": [], "source": [ "def train(dataloader, optimizer, loss, device):\n", " '''Train the model for one epoch.'''\n", "\n", " # set the model into train mode\n", " model.train()\n", "\n", " epoch_loss, num_batches = 0, 0\n", " for x, y in tqdm(dataloader, 'train'):\n", "\n", " x, y = x.to(device), y.to(device)\n", " optimizer.zero_grad()\n", "\n", " y_pred = model(x)\n", " l = loss(y_pred, y)\n", " l.backward()\n", "\n", " optimizer.step()\n", "\n", " epoch_loss += l\n", " num_batches += 1\n", "\n", " return epoch_loss/num_batches\n", "\n", "\n", "def evaluate(dataloader, name, device):\n", "\n", " correct = 0\n", " total = 0\n", " for x, y in tqdm(dataloader, name):\n", "\n", " x, y = x.to(device), y.to(device)\n", "\n", " logits = model(x)\n", " probs = torch.nn.Softmax(dim=1)(logits)\n", " predictions = torch.argmax(probs, dim=1)\n", "\n", " correct += int(torch.sum(predictions == y).cpu().detach().numpy())\n", " total += len(y)\n", "\n", " accuracy = correct/total\n", "\n", " return accuracy\n", "\n", "\n", "def validate(validation_dataset, device):\n", " '''Evaluate prediction accuracy on the validation dataset.'''\n", "\n", " model.eval()\n", " dataloader = DataLoader(validation_dataset, batch_size=32)\n", "\n", " return evaluate(dataloader, 'validate', device)\n", "\n", "\n", "def test(test_dataset, device):\n", " '''Evaluate prediction accuracy on the test dataset.'''\n", "\n", " model.eval()\n", " dataloader = DataLoader(test_dataset, batch_size=32)\n", "\n", " return evaluate(dataloader, 'test', device)" ] }, { "cell_type": "markdown", "id": "68bcfbbf", "metadata": { "execution": {} }, "source": [ "We are ready to train. After each epoch (roughly going through each training image once), we report the training loss and the validation accuracy." ] }, { "cell_type": "code", "execution_count": null, "id": "d0af7638", "metadata": { "execution": {} }, "outputs": [], "source": [ "def train_from_scratch(dataloader, validation_dataset,\n", " optimizer, loss,\n", " num_epochs=100, device=device):\n", "\n", " for epoch in range(num_epochs):\n", " epoch_loss = train(dataloader, optimizer, loss, device=device)\n", " print(f\"epoch {epoch}, training loss={epoch_loss}\")\n", "\n", " accuracy = validate(validation_dataset, device=device)\n", " print(f\"epoch {epoch}, validation accuracy={accuracy}\")" ] }, { "cell_type": "markdown", "id": "45e31b87", "metadata": { "execution": {} }, "source": [ "`yes_I_want_the_pretrained_model = True` will load a checkpoint that we already prepared, whereas setting it to `False` will train the model from scratch.\n", "\n", "Unceck the box below and run the cell to train a model." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n" ] }, { "cell_type": "code", "execution_count": null, "id": "W5KA7zDIa3Lw", "metadata": { "cellView": "form", "execution": {}, "tags": [ "hide-input" ] }, "outputs": [], "source": [ "# @markdown\n", "yes_I_want_the_pretrained_model = True # @param {type:\"boolean\"}" ] }, { "cell_type": "code", "execution_count": null, "id": "53fb8dda", "metadata": { "execution": {} }, "outputs": [], "source": [ "# Load a pretrained model or train the model from scratch\n", "\n", "# set this to True and run this cell if you want a shortcut\n", "\n", "if yes_I_want_the_pretrained_model:\n", " checkpoint = torch.load('checkpoints/synapses/classifier/vgg_checkpoint',\n", " map_location=device)\n", " model.load_state_dict(checkpoint['model_state_dict'])\n", "else:\n", " train_from_scratch(dataloader, validation_dataset,\n", " optimizer, loss,\n", " num_epochs=100, device=device)" ] }, { "cell_type": "code", "execution_count": null, "id": "4f6e3663", "metadata": { "execution": {} }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "test: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 346/346 [00:39<00:00, 8.72it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "final test accuracy: 0.49737888647866957\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "\n" ] } ], "source": [ "accuracy = test(test_dataset, device=device)\n", "print(f\"final test accuracy: {accuracy}\")" ] }, { "cell_type": "markdown", "id": "3f43bba5", "metadata": { "execution": {} }, "source": [ "This concludes the first section. We now have a classifier that can discriminate between images of different types.\n", "\n", "If you used the images we provided, the classifier is not perfect (you should get an accuracy of around 80%), but pretty good considering that there are six different types of images. Furthermore, it is not so clear for humans how the classifier does it. Feel free to explore the data a bit more and see for yourself if you can tell the difference betwee, say, GABAergic and glutamatergic synapses.\n", "\n", "So this is an interesting situation: The VGG network knows something we don't quite know. In the next section, we will see how we can visualize the relevant differences between images of different types." ] }, { "cell_type": "markdown", "id": "72b5240c", "metadata": { "execution": {} }, "source": [ "---\n", "# Train a GAN to Translate Images\n", "\n", "We will train a so-called CycleGAN to translate images from one class to another." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Get the CycleGAN code and dependencies\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " GitHub repo: https://github.com/funkey/neuromatch_xai\n" ] }, { "cell_type": "code", "execution_count": null, "id": "41c9e63b", "metadata": { "cellView": "form", "execution": {}, "tags": [ "hide-input" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m24.0\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m24.1.2\u001b[0m\n", "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n" ] } ], "source": [ "# @title Get the CycleGAN code and dependencies\n", "\n", "# @markdown GitHub repo: https://github.com/funkey/neuromatch_xai\n", "\n", "import requests, zipfile, io\n", "\n", "url = 'https://osf.io/vutn5/download'\n", "r = requests.get(url)\n", "z = zipfile.ZipFile(io.BytesIO(r.content))\n", "z.extractall()\n", "\n", "!pip install dominate --quiet" ] }, { "cell_type": "markdown", "id": "e5da5c01", "metadata": { "execution": {} }, "source": [ "In this example, we will translate between GABAergic and glutamatergic synapses.\n", "\n", "First, we have to copy images of either type into a format that the CycleGAN library is happy with. Afterwards, we can start training on those images." ] }, { "cell_type": "code", "execution_count": null, "id": "2b2519c4", "metadata": { "execution": {} }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████| 22648/22648 [00:01<00:00, 20146.29it/s]\n", "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5085/5085 [00:00<00:00, 20709.24it/s]\n", "0it [00:00, ?it/s]\n", "0it [00:00, ?it/s]\n", "0it [00:00, ?it/s]\n", "0it [00:00, ?it/s]\n" ] } ], "source": [ "import cycle_gan\n", "\n", "cycle_gan.prepare_dataset('data/raw/synapses/', ['0_gaba', '2_glutamate'])\n", "\n", "## Uncomment if you want to enable the training procedure\n", "# cycle_gan.train('data/raw/synapses/', '0_gaba', '2_glutamate', 128)" ] }, { "cell_type": "markdown", "id": "0d328904", "metadata": { "execution": {} }, "source": [ "Training the CycleGAN takes a lot longer than the VGG we trained above (on the synapse dataset, this will be around 7 days...).\n", "\n", "To continue, interrupt the kernel and continue with the next one, which will just use one of the pretrained CycleGAN models for the synapse dataset." ] }, { "cell_type": "code", "execution_count": null, "id": "a182c3bc", "metadata": { "execution": {} }, "outputs": [], "source": [ "# translate images from class A to B, and classify each with the VGG network trained above\n", "# Note: cycle_gan requires CUDA devices\n", "if device == \"cuda\":\n", " cycle_gan.test(\n", " data_dir='data/raw/synapses/',\n", " class_A='0_gaba',\n", " class_B='2_glutamate',\n", " img_size=128,\n", " checkpoints_dir='checkpoints/synapses/cycle_gan/gaba_glutamate/',\n", " vgg_checkpoint='checkpoints/synapses/classifier/vgg_checkpoint'\n", " )" ] }, { "cell_type": "markdown", "id": "17fc1703", "metadata": { "execution": {} }, "source": [ "Read all translated images and sort them by how much the translation \"fools\" the VGG classifier trained above:" ] }, { "cell_type": "code", "execution_count": null, "id": "2a582ba6", "metadata": { "execution": {} }, "outputs": [], "source": [ "class_A_index = 0\n", "class_B_index = 2\n", "\n", "result_dir = 'data/raw/synapses/cycle_gan/0_gaba_2_glutamate/results/test_latest/images/'\n", "classification_results = []\n", "for f in glob.glob(result_dir + '/*.json'):\n", " result = json.load(open(f))\n", " result['basename'] = f.replace('_aux.json', '')\n", " classification_results.append(result)\n", "classification_results.sort(\n", " key=lambda c: c['aux_real'][class_A_index] * c['aux_fake'][class_B_index],\n", " reverse=True)" ] }, { "cell_type": "markdown", "id": "2cc0d486", "metadata": { "execution": {} }, "source": [ "Show the top real and fake images that make the classifier change its mind:" ] }, { "cell_type": "code", "execution_count": null, "id": "1567b00e", "metadata": { "execution": {} }, "outputs": [], "source": [ "def show_pair(a, b, score_a, score_b, class_a, class_b):\n", " fig, axs = plt.subplots(1, 2, figsize=(20, 20), sharey=True)\n", " axs[0].imshow(a, cmap='gray')\n", " axs[0].set_title(f\"p({class_a}) = \" + str(score_a))\n", " axs[1].imshow(b, cmap='gray')\n", " axs[1].set_title(f\"p({class_b}) = \" + str(score_b))\n", " plt.show()\n", "\n", "\n", "# show the top successful translations (according to our VGG classifier)\n", "# Note: only run if cycle_gan ran successfully\n", "if classification_results:\n", " for i in range(10):\n", " basename = classification_results[i]['basename']\n", " score_A = classification_results[i]['aux_real'][class_A_index]\n", " score_B = classification_results[i]['aux_fake'][class_B_index]\n", " real_A = imread(basename + '_real.png')\n", " fake_B = imread(basename + '_fake.png')\n", " show_pair(real_A, fake_B, score_A, score_B, 'gaba', 'glutamate')" ] } ], "metadata": { "accelerator": "GPU", "colab": { "collapsed_sections": [], "gpuType": "T4", "include_colab_link": true, "name": "em_synapses", "provenance": [], "toc_visible": true }, "kernel": { "display_name": "Python 3", "language": "python", "name": "python3" }, "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.9.16" } }, "nbformat": 4, "nbformat_minor": 5 }