diff --git a/.gitignore b/.gitignore
index c56bb68296ed0c9ac9c03ad6c1c58ad78ab40489..6f57652a4cb05f7452989d673c932570b0791c9a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,6 @@
 __pycache__/
+.ipynb_checkpoints/
+data/
+img/
 *.swp
 *.swo
diff --git a/__init__.py b/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/app/mnist_image_classification.py b/app/mnist_image_classification.py
new file mode 100644
index 0000000000000000000000000000000000000000..5067407a43bc0218f6a01813400f751e38b755c6
--- /dev/null
+++ b/app/mnist_image_classification.py
@@ -0,0 +1,86 @@
+import os
+import numpy as np
+import torch
+import matplotlib.pyplot as plt
+import neural_networks_101.src as src
+
+
+def main():
+    """Main function."""
+    # Random seed for reproducibility
+    torch.manual_seed(42)
+
+    # Get CPU or GPU device for training
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    device = torch.device(device)
+
+    print(src.misc.time_stamp(), "load MNIST data")
+    train_data, test_data = src.mnist.get_mnist_data()
+
+    # plot some training data
+    print(src.misc.time_stamp(), "plot sample images (random selection)")
+    if not os.path.isdir("../img"):
+        os.makedirs("../img", exist_ok=True)
+    shape = (4, 6)
+    idxs = torch.randint(len(train_data), size=(int(np.prod(shape)),))
+    src.mnist.plot_mnist_data(train_data, idxs, shape=shape)
+    file_name = "../img/mnist_images.png"
+    plt.savefig(file_name, dpi=200)
+    print(src.misc.time_stamp(), f"save to: {file_name}")
+
+    print(src.misc.time_stamp(), "setup NN model")
+    # Send the model to the device (CPU or GPU)
+    model = src.mnist.NeuralNetwork().to(device)
+    # Define the optimizer to user for gradient descent
+    optimizer = torch.optim.Adadelta(model.parameters(), lr=1.0)
+    # Shrinks the learning rate by gamma every step_size
+    scheduler = torch.optim.lr_scheduler.ExponentialLR(optimizer, gamma=0.7)
+
+    # Train the model
+    n_epochs = 2
+    for epoch in range(n_epochs):
+        print(src.misc.time_stamp(), f"training epoch {epoch+1} / {n_epochs}")
+        with src.misc.timeit("time: {:4.2f} s"):
+            src.mnist.train(model, device, train_data, optimizer,
+                            log_interval=100)
+        test_loss, correct = src.mnist.test(model, device, test_data)
+        rate = 100 * correct / len(test_data)
+        print(src.misc.time_stamp(),
+              f"test set avg. loss: {test_loss}",
+              f" -- accuracy: {correct}/{len(test_data)} ({rate:4.1f} %)")
+        scheduler.step()
+
+    # evaluate forward model
+    print(src.misc.time_stamp(), "evaluate model on training set")
+    # enable evaluation mode, return to training mode with model.train()
+    model.eval()
+    test_loader = torch.utils.data.DataLoader(
+        test_data, batch_size=100, num_workers=1, pin_memory=True,
+        shuffle=True)
+    targets, outputs = [], []
+    with torch.no_grad():  # turn of gradient computation
+        for data, target in test_loader:
+            data, target = data.to(device), target.to(device)
+            output = model(data)
+            targets.append(np.array(target))
+            outputs.append(np.array(output))
+    targets = np.array(targets).reshape(-1, 1)
+    outputs = np.concatenate(outputs, axis=0)
+
+    # plot mislabeled test data
+    print(src.misc.time_stamp(), "plot mislabeled data")
+    # sort indices of test data according to classification error (descending)
+    target_vectors = np.array([np.eye(1, 10, k=int(t)).flatten()
+                               for t in targets])
+    idxs = np.argsort(np.linalg.norm(outputs-target_vectors, axis=1))[::-1]
+    # plot n test samples with largest classification error
+    n = 5
+    src.mnist.plot_mnist_accuracy(
+        test_data, targets, outputs, idxs[:n], figsize=(10, 3*n))
+    file_name = "../img/mnist_mislabeled_data.png"
+    plt.savefig(file_name, dpi=200)
+    print(src.misc.time_stamp(), f"save to: {file_name}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/nbs/MNIST_image_classification.ipynb b/nbs/MNIST_image_classification.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..6d8030341a9f424aba08949b1010fa8f6d222c46
--- /dev/null
+++ b/nbs/MNIST_image_classification.ipynb
@@ -0,0 +1,299 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2022-06-23T10:26:06.041437Z",
+     "start_time": "2022-06-23T10:26:05.249006Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import torch\n",
+    "import neural_networks_101.src as src\n",
+    "\n",
+    "%matplotlib inline\n",
+    "%reload_ext autoreload\n",
+    "%autoreload 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2022-06-23T10:26:06.058708Z",
+     "start_time": "2022-06-23T10:26:06.043140Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Random seed for reproducibility\n",
+    "torch.manual_seed(42)\n",
+    "\n",
+    "# Get CPU or GPU device for training\n",
+    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
+    "device = torch.device(device)\n",
+    "\n",
+    "# number of training epochs\n",
+    "n_epochs = 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2022-06-23T10:26:06.134729Z",
+     "start_time": "2022-06-23T10:26:06.062141Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[2022-06-23 12:26:06] load MNIST data\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(src.misc.time_stamp(), \"load MNIST data\")\n",
+    "train_data, test_data = src.mnist.get_mnist_data()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2022-06-23T10:26:07.071093Z",
+     "start_time": "2022-06-23T10:26:06.136433Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x432 with 15 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "shape = (3, 5)\n",
+    "idxs = torch.randint(len(train_data), size=(np.prod(shape),))\n",
+    "src.mnist.plot_mnist_data(train_data, idxs, shape=shape, figsize=(10, 6))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2022-06-23T10:26:07.094779Z",
+     "start_time": "2022-06-23T10:26:07.073070Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[2022-06-23 12:26:07] setup NN model\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(src.misc.time_stamp(), \"setup NN model\")\n",
+    "# Send the model to the device (CPU or GPU)\n",
+    "model = src.mnist.NeuralNetwork().to(device)\n",
+    "# Define the optimizer to user for gradient descent\n",
+    "optimizer = torch.optim.Adadelta(model.parameters(), lr=1.0)\n",
+    "# Shrinks the learning rate by gamma every step_size\n",
+    "scheduler = torch.optim.lr_scheduler.ExponentialLR(optimizer, gamma=0.7)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2022-06-23T10:29:26.390235Z",
+     "start_time": "2022-06-23T10:26:42.544241Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[2022-06-23 12:26:42] training epoch 1\n",
+      "progress:  0.0 % -- loss: 2.3028767108917236\n",
+      "progress: 10.7 % -- loss: 1.6748236417770386\n",
+      "progress: 21.3 % -- loss: 1.5185235738754272\n",
+      "progress: 32.0 % -- loss: 1.5623918771743774\n",
+      "progress: 42.6 % -- loss: 1.4711004495620728\n",
+      "progress: 53.3 % -- loss: 1.4986964464187622\n",
+      "progress: 64.0 % -- loss: 1.5017988681793213\n",
+      "progress: 74.6 % -- loss: 1.4901072978973389\n",
+      "progress: 85.3 % -- loss: 1.5001312494277954\n",
+      "progress: 95.9 % -- loss: 1.5052735805511475\n",
+      "[2022-06-23 12:27:55] time: 72.96 s\n",
+      "[2022-06-23 12:28:01] test set avg. loss: -0.9677526263237  -- accuracy: 9683/10000 (96.8 %)\n",
+      "[2022-06-23 12:28:01] training epoch 2\n",
+      "progress:  0.0 % -- loss: 1.5741151571273804\n",
+      "progress: 10.7 % -- loss: 1.4860159158706665\n",
+      "progress: 21.3 % -- loss: 1.5614594221115112\n",
+      "progress: 32.0 % -- loss: 1.4640870094299316\n",
+      "progress: 42.6 % -- loss: 1.476805329322815\n",
+      "progress: 53.3 % -- loss: 1.4751007556915283\n",
+      "progress: 64.0 % -- loss: 1.4962173700332642\n",
+      "progress: 74.6 % -- loss: 1.4818075895309448\n",
+      "progress: 85.3 % -- loss: 1.5036966800689697\n",
+      "progress: 95.9 % -- loss: 1.477353572845459\n",
+      "[2022-06-23 12:29:20] time: 78.83 s\n",
+      "[2022-06-23 12:29:26] test set avg. loss: -0.9751591731071472  -- accuracy: 9759/10000 (97.6 %)\n"
+     ]
+    }
+   ],
+   "source": [
+    "for epoch in range(n_epochs):\n",
+    "    print(src.misc.time_stamp(), f\"training epoch {epoch+1}\")\n",
+    "    with src.misc.timeit(\"time: {:4.2f} s\"):\n",
+    "        src.mnist.train(model, device, train_data, optimizer, log_interval=100)\n",
+    "    test_loss, correct = src.mnist.test(model, device, test_data)\n",
+    "    rate = 100 * correct / len(test_data)\n",
+    "    print(src.misc.time_stamp(),\n",
+    "          f\"test set avg. loss: {test_loss}\",\n",
+    "          f\" -- accuracy: {correct}/{len(test_data)} ({rate:4.1f} %)\")\n",
+    "    scheduler.step()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2022-06-23T10:29:33.968008Z",
+     "start_time": "2022-06-23T10:29:29.863168Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[2022-06-23 12:29:29] evaluate model on training set\n"
+     ]
+    }
+   ],
+   "source": [
+    "# evaluate forward model\n",
+    "print(src.misc.time_stamp(), \"evaluate model on training set\")\n",
+    "model.eval()  # enable evaluation mode, return to training mode with model.train()\n",
+    "test_loader = torch.utils.data.DataLoader(\n",
+    "    test_data, batch_size=100, num_workers=1, pin_memory=True,\n",
+    "    shuffle=True)\n",
+    "targets, outputs = [], []\n",
+    "with torch.no_grad():  # turn of gradient computation\n",
+    "    for data, target in test_loader:\n",
+    "        data, target = data.to(device), target.to(device)\n",
+    "        output = model(data)\n",
+    "        targets.append(np.array(target))\n",
+    "        outputs.append(np.array(output))\n",
+    "targets = np.array(targets).reshape(-1, 1)\n",
+    "outputs = np.concatenate(outputs, axis=0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2022-06-23T10:29:38.504693Z",
+     "start_time": "2022-06-23T10:29:35.328131Z"
+    },
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[2022-06-23 12:29:35] plot mislabeled data\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x2160 with 20 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# plot mislabeled test data\n",
+    "print(src.misc.time_stamp(), \"plot mislabeled data\")\n",
+    "target_vectors = np.array([np.eye(1, 10, k=int(t)).flatten()\n",
+    "                           for t in targets])\n",
+    "idxs = np.argsort(np.linalg.norm(outputs-target_vectors, axis=1))[::-1][:10]\n",
+    "src.mnist.plot_mnist_accuracy(test_data, targets, outputs, idxs, figsize=(10, 3*len(idxs)))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "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.8.5"
+  },
+  "toc": {
+   "base_numbering": 1,
+   "nav_menu": {},
+   "number_sections": true,
+   "sideBar": true,
+   "skip_h1_title": true,
+   "title_cell": "Table of Contents",
+   "title_sidebar": "Contents",
+   "toc_cell": false,
+   "toc_position": {},
+   "toc_section_display": true,
+   "toc_window_display": true
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/requirements.txt b/requirements.txt
index a16d0230d82e384a128195d8ced7dec77d1c8264..f987ffb7819f98b35bc326dcd53fd56a14447dba 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,4 +1,5 @@
 numpy >= 1.20.0
 scipy >= 1.5.0
-torch >= 1.7.1
 matplotlib >= 3.3.2
+torch >= 1.11.0
+torchvision >= 0.12.0
diff --git a/src/__init__.py b/src/__init__.py
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..3a794adbb887b99e670852b28c06354c241b3c9c 100644
--- a/src/__init__.py
+++ b/src/__init__.py
@@ -0,0 +1,5 @@
+from . import (
+    misc,
+    target_function,
+    mnist,
+)
diff --git a/src/mnist.py b/src/mnist.py
new file mode 100644
index 0000000000000000000000000000000000000000..ea0343487cfbf87f868e5d3c7c418d85415b21bd
--- /dev/null
+++ b/src/mnist.py
@@ -0,0 +1,223 @@
+"""Utility functions for handling the MNIST data set."""
+from typing import Tuple, List, Optional
+import numpy as np
+import torch
+import torchvision
+import matplotlib.pyplot as plt
+
+
+class NeuralNetwork(torch.nn.Module):
+    """Neural network used for MNIST image classification."""
+
+    def __init__(self) -> None:
+        """Initialize network layers."""
+        super(NeuralNetwork, self).__init__()
+        self.conv1 = torch.nn.Conv2d(
+            1, 32, kernel_size=3, stride=1, padding='valid')
+        self.conv2 = torch.nn.Conv2d(
+            32, 64, kernel_size=3, stride=1, padding='valid')
+        self.dropout1 = torch.nn.Dropout(0.25)
+        self.dropout2 = torch.nn.Dropout(0.5)
+        self.fc1 = torch.nn.Linear(9216, 128)
+        self.fc2 = torch.nn.Linear(128, 10)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        """Evalute network in input data.
+
+        This function defines the topology of the network.
+
+        Parameters:
+        x : torch.Tensor
+            MNIST input data.
+
+        Returns:
+        :
+            Output vector with probabilities for each class.
+        """
+        x = self.conv1(x)
+        x = torch.nn.functional.relu(x)
+        x = self.conv2(x)
+        x = torch.nn.functional.relu(x)
+        x = torch.nn.functional.max_pool2d(x, 2)
+        x = self.dropout1(x)
+        x = torch.flatten(x, 1)
+        x = self.fc1(x)
+        x = torch.nn.functional.relu(x)
+        x = self.dropout2(x)
+        x = self.fc2(x)
+        output = torch.nn.functional.softmax(x, dim=1)
+        return output
+
+
+def get_mnist_data() -> Tuple[torchvision.datasets.mnist.MNIST,
+                              torchvision.datasets.mnist.MNIST]:
+    """Download the MNIST data set and return data loaders.
+
+    The MNIST data are downloaded to 'data' subdirectory in repository root.
+
+    Returns
+    -------
+    train_loader :
+        DataLoader for training data set.
+    test_loader :
+        DataLoader for test data set.
+    """
+    # The scaled mean and standard deviation of the MNIST dataset
+    # Note: This is precalculated.
+    data_mean = 0.1307
+    data_std = 0.3081
+
+    # Convert input images to tensors and normalize
+    transform = torchvision.transforms.Compose([
+        torchvision.transforms.ToTensor(),
+        torchvision.transforms.Normalize((data_mean,), (data_std,))
+    ])
+
+    # Get the MNIST data from torchvision
+    train_data = torchvision.datasets.MNIST(
+        '../data', train=True, download=True, transform=transform)
+    test_data = torchvision.datasets.MNIST(
+        '../data', train=False, download=True, transform=transform)
+
+    return train_data, test_data
+
+
+def train(model: NeuralNetwork,
+          device: torch.device,
+          train_data: torchvision.datasets.mnist.MNIST,
+          optimizer: torch.optim.Optimizer,
+          log_interval=100
+          ) -> None:
+    """Train the given model.
+
+    Parameters
+    ----------
+    model : NeuralNetwork
+        Neural network model.
+    device : torch.device
+        Hardware to train the model on.
+    train_data : torchvision.datasets.mnist.MNIST
+        Training data the model is trained on.
+    optimizer : torch.optim.Optimizer
+        Optimization employed to train the model.
+    log_interval : int
+        Number of steps the progress is printed after.
+    """
+    kwargs = {'num_workers': 1, 'pin_memory': True, 'shuffle': True}
+    train_loader = torch.utils.data.DataLoader(
+        train_data, batch_size=64, **kwargs)
+    model.train()
+    for batch_idx, (data, target) in enumerate(train_loader):
+        data, target = data.to(device), target.to(device)
+        optimizer.zero_grad()
+        output = model(data)
+        loss = torch.nn.functional.cross_entropy(output, target)
+        loss.backward()
+        optimizer.step()
+        if batch_idx % log_interval == 0:
+            percentage = 100. * batch_idx / len(train_loader)
+            print(f"progress: {percentage:>4.1f} % -- loss: {loss.item()}")
+
+
+def test(model: NeuralNetwork,
+         device: torch.device,
+         test_data: torchvision.datasets.mnist.MNIST
+         ) -> Tuple[float, int]:
+    """Test the network on a test data set.
+
+    Parameters
+    ----------
+    model : NeuralNetwork
+        Neural network model.
+    device : torch.device
+        Hardware to train the model on.
+    test_data : torchvision.datasets.mnist.MNIST
+        Test data set.
+
+    Returns
+    -------
+    test_loss : float
+        Loss on the test data set.
+    correct : int
+        Number of correctly classified test data.
+    """
+    kwargs = {'num_workers': 1, 'pin_memory': True, 'shuffle': True}
+    test_loader = torch.utils.data.DataLoader(
+        test_data, batch_size=16, **kwargs)
+    model.eval()
+    test_loss = 0
+    correct = 0
+    with torch.no_grad():
+        for data, target in test_loader:
+            data, target = data.to(device), target.to(device)
+            output = model(data)
+            # sum up batch loss
+            test_loss += torch.nn.functional.nll_loss(
+                output, target, reduction='sum').item()
+            # get the index of the max log-probability
+            pred = output.argmax(dim=1, keepdim=True)
+            correct += pred.eq(target.view_as(pred)).sum().item()
+    test_loss /= len(test_loader.dataset)
+    return test_loss, correct
+
+
+def plot_mnist_data(data: torchvision.datasets.mnist.MNIST,
+                    idxs: List[int],
+                    shape: Tuple,
+                    **kwargs,
+                    ) -> None:
+    """Plot MNIST images.
+
+    Parameters
+    ----------
+    data : torchvision.datasets.mnist.MNIST
+        MNIST data set.
+    idxs : list of int
+        Indices of data to plot.
+    shape : tuple
+        Specification of arrangement of subplots.
+    """
+    assert np.prod(shape) == len(idxs)
+    layout = [[f"{row}-{col}" for col in range(shape[1])]
+              for row in range(shape[0])]
+    fig, axes = plt.subplot_mosaic(layout, constrained_layout=True, **kwargs)
+    for j, ax in enumerate(axes.values()):
+        img, label = data[idxs[j]]
+        ax.imshow(img.squeeze(), cmap="gray")
+        ax.set_title(f"label = {label}")
+        ax.axis("off")
+
+
+def plot_mnist_accuracy(data: torchvision.datasets.mnist.MNIST,
+                        targets: np.ndarray,
+                        outputs: np.ndarray,
+                        idxs: List[int],
+                        **kwargs
+                        ) -> None:
+    """Plot MNIST images and corresponding classification of the NN model.
+
+    Parameters
+    ----------
+    data : torchvision.datasets.mnist.MNIST
+        MNIST data set.
+    targets : np.ndarray
+        Target values.
+    outputs : np.ndarray
+        Output classifications of model.
+    idxs : list of int
+        Indices of data to plot.
+    """
+    layout = [[f"img-{idx}", f"acc-{idx}"] for idx in idxs]
+    fig, axes = plt.subplot_mosaic(layout, constrained_layout=True, **kwargs)
+    for key, ax in axes.items():
+        idx = int(key[4:])
+        img, label = data[idx]
+        if key[:4] == "img-":
+            ax.imshow(img.squeeze(), cmap="gray")
+            ax.set_title(f"test point = {idx}")
+            ax.axis("off")
+        else:
+            ax.bar(range(10), outputs[idx], log=True, color="gray")
+            ax.axvline(x=label, color="k")
+            ax.set_title(f"target = {label},   "
+                         + f"prediction={np.argmax(outputs[idx])}")