Merge pull request #10 from juglab/dev

Dev

README.md

@@ -6,7 +6,7 @@ Build Python package:
 `python setup.py bdist_wheel`
 
 Build singularity recipe:
-`neurodocker generate singularity -b nvidia/cuda:10.2-cudnn7-devel-ubuntu18.04 -p apt --copy /home/tibuch/Gitrepos/FourierImageTransformer/dist/fourier_image_transformers-0.1.7-py3-none-any.whl /fourier_image_transformers-0.1.7-py3-none-any.whl --miniconda create_env=fit conda_install='python=3.7 astra-toolbox pytorch torchvision torchaudio cudatoolkit=10.2 -c pytorch -c astra-toolbox/label/dev' pip_install='/fourier_image_transformers-0.1.7-py3-none-any.whl' activate=true --entrypoint "/neurodocker/startup.sh python" > v0.1.7.Singularity`
+`neurodocker generate singularity -b nvidia/cuda:10.2-cudnn7-devel-ubuntu18.04 -p apt --copy /home/tibuch/Gitrepos/FourierImageTransformer/dist/fourier_image_transformers-0.1.9-py3-none-any.whl /fourier_image_transformers-0.1.9-py3-none-any.whl --miniconda create_env=fit conda_install='python=3.7 astra-toolbox pytorch torchvision torchaudio cudatoolkit=10.2 -c pytorch -c astra-toolbox/label/dev' pip_install='/fourier_image_transformers-0.1.9-py3-none-any.whl' activate=true --entrypoint "/neurodocker/startup.sh python" > v0.1.9.Singularity`
 
 Build singularity container:
-`sudo singularity build fit_v0.1.7.simg v0.1.7.Singularity`
+`sudo singularity build fit_v0.1.9.simg v0.1.9.Singularity`

examples/datamodules/DataModule - MNIST Tomo Baseline.ipynb

@@ -0,0 +1,132 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from fit.datamodules.baselines import MNISTBaselineDataModule\n",
+    "\n",
+    "from matplotlib import pyplot as plt\n",
+    "\n",
+    "import torch\n",
+    "\n",
+    "import numpy as np\n",
+    "\n",
+    "from skimage.transform import iradon\n",
+    "\n",
+    "from fit.utils.utils import denormalize"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# MNIST Tomo Fourier Target\n",
+    "Create a MNIST projection dataset with 15 angles and batch-size 4."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "batch_size = 4\n",
+    "num_angles = 7\n",
+    "img_shape = 27\n",
+    "inner_circle = True"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dm = MNISTBaselineDataModule(root_dir='/home/tibuch/Data/mnist/', batch_size=batch_size, \n",
+    "                                      num_angles=num_angles, inner_circle=inner_circle)\n",
+    "dm.setup()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mean, std = dm.mean, dm.std"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_dl = dm.train_dataloader()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for rec, img  in train_dl:\n",
+    "    break"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 59,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x360 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "i = 0\n",
+    "plt.figure(figsize=(10,5))\n",
+    "plt.subplot(1,2,1)\n",
+    "plt.imshow(rec[i])\n",
+    "plt.title('FBP');\n",
+    "plt.subplot(1,2,2)\n",
+    "plt.imshow(img[i])\n",
+    "plt.title('GT');"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

fit/baselines/ConvBlockBaseline.py

@@ -0,0 +1,28 @@
+import torch
+from fast_transformers.builders import TransformerDecoderBuilder, TransformerEncoderBuilder
+
+from fit.transformers.PositionalEncoding2D import PositionalEncoding2D
+from fit.utils import convert2FC, convert_to_dft
+from torch.nn import functional as F
+
+
+class ConvBlockBaseline(torch.nn.Module):
+    def __init__(self,
+                 d_query=32,):
+        super(ConvBlockBaseline, self).__init__()
+
+        self.conv_block = torch.nn.Sequential(
+            torch.nn.Conv2d(1, d_query, kernel_size=3, stride=1, padding=1),
+            torch.nn.ReLU(),
+            torch.nn.BatchNorm2d(d_query),
+            torch.nn.Conv2d(d_query, d_query, kernel_size=3, stride=1, padding=1),
+            torch.nn.ReLU(),
+            torch.nn.BatchNorm2d(d_query),
+            torch.nn.Conv2d(d_query, 1, kernel_size=1, stride=1, padding=0)
+        )
+
+    def forward(self, x):
+        img_post = self.conv_block(x)
+        img_post += x
+
+        return img_post