{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Bayesian Convolutional Neural Network\n", "\n", "> In this post, we will create a Bayesian convolutional neural network to classify the famous MNIST handwritten digits. This will be a probabilistic model, designed to capture both aleatoric and epistemic uncertainty. You will test the uncertainty quantifications against a corrupted version of the dataset. This is the assignment of lecture \"Probabilistic Deep Learning with Tensorflow 2\" from Imperial College London.\n", "\n", "- toc: true \n", "- badges: true\n", "- comments: true\n", "- author: Chanseok Kang\n", "- categories: [Python, Coursera, Tensorflow_probability, ICL]\n", "- image: images/mnist_corrupted.png" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Packages" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "import tensorflow as tf\n", "import tensorflow_probability as tfp\n", "\n", "from tensorflow.keras.models import Sequential\n", "from tensorflow.keras.layers import Dense, Flatten, Conv2D, MaxPooling2D\n", "from tensorflow.keras.losses import SparseCategoricalCrossentropy\n", "from tensorflow.keras.optimizers import RMSprop\n", "\n", "import numpy as np\n", "import os\n", "import matplotlib.pyplot as plt\n", "\n", "tfd = tfp.distributions\n", "tfpl = tfp.layers\n", "\n", "plt.rcParams['figure.figsize'] = (10, 6)" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Tensorflow Version: 2.5.0\n", "Tensorflow Probability Version: 0.13.0\n" ] } ], "source": [ "print(\"Tensorflow Version: \", tf.__version__)\n", "print(\"Tensorflow Probability Version: \", tfp.__version__)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "![MNIST and MNIST-corrupted overview image](image/mnist_corrupted.png)\n", "\n", "## The MNIST and MNIST-C datasets\n", "\n", "In this notebook, you will use the [MNIST](http://yann.lecun.com/exdb/mnist/) and [MNIST-C](https://github.com/google-research/mnist-c) datasets, which both consist of a training set of 60,000 handwritten digits with corresponding labels, and a test set of 10,000 images. The images have been normalised and centred. The MNIST-C dataset is a corrupted version of the MNIST dataset, to test out-of-distribution robustness of computer vision models.\n", "\n", "- Y. LeCun, L. Bottou, Y. Bengio, and P. Haffner. \"Gradient-based learning applied to document recognition.\" Proceedings of the IEEE, 86(11):2278-2324, November 1998.\n", "- N. Mu and J. Gilmeer. \"MNIST-C: A Robustness Benchmark for Computer Vision\" https://arxiv.org/abs/1906.02337\n", "\n", "Our goal is to construct a neural network that classifies images of handwritten digits into one of 10 classes." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Load the datasets\n", "\n", "We'll start by importing two datasets. The first is the MNIST dataset of handwritten digits, and the second is the MNIST-C dataset, which is a corrupted version of the MNIST dataset. This dataset is available on [TensorFlow datasets](https://www.tensorflow.org/datasets/catalog/mnist_corrupted). We'll be using the dataset with \"spatters\". We will load and inspect the datasets below. We'll use the notation `_c` to denote `corrupted`. The images are the same as in the original MNIST, but are \"corrupted\" by some grey spatters." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "# Function to load training and testing data, with labels in integer and one-hot form\n", "\n", "def load_data(name):\n", " data_dir = os.path.join('dataset', name)\n", " x_train = 1 - np.load(os.path.join(data_dir, 'x_train.npy')) / 255.\n", " x_train = x_train.astype(np.float32)\n", " y_train = np.load(os.path.join(data_dir, 'y_train.npy'))\n", " y_train_oh = tf.keras.utils.to_categorical(y_train)\n", " x_test = 1 - np.load(os.path.join(data_dir, 'x_test.npy')) / 255.\n", " x_test = x_test.astype(np.float32)\n", " y_test = np.load(os.path.join(data_dir, 'y_test.npy'))\n", " y_test_oh = tf.keras.utils.to_categorical(y_test)\n", " \n", " return (x_train, y_train, y_train_oh), (x_test, y_test, y_test_oh)" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "# Function to inspect dataset digits\n", "\n", "def inspect_images(data, num_images):\n", " fig, ax = plt.subplots(nrows=1, ncols=num_images, figsize=(2*num_images, 2))\n", " for i in range(num_images):\n", " ax[i].imshow(data[i, ..., 0], cmap='gray')\n", " ax[i].axis('off')\n", " plt.show()" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Load and inspect the MNIST dataset\n", "\n", "(x_train, y_train, y_train_oh), (x_test, y_test, y_test_oh) = load_data('MNIST')\n", "inspect_images(data=x_train, num_images=8)" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Load and inspect the MNIST-C dataset\n", "\n", "(x_c_train, y_c_train, y_c_train_oh), (x_c_test, y_c_test, y_c_test_oh) = load_data('MNIST_corrupted')\n", "inspect_images(data=x_c_train, num_images=8)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Create the deterministic model\n", "\n", "We will first train a standard deterministic CNN classifier model as a base model before implementing the probabilistic and Bayesian neural networks. " ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "def get_deterministic_model(input_shape, loss, optimizer, metrics):\n", " \"\"\"\n", " This function should build and compile a CNN model according to the above specification. \n", " The function takes input_shape, loss, optimizer and metrics as arguments, which should be\n", " used to define and compile the model.\n", " Your function should return the compiled model.\n", " \"\"\"\n", " model = Sequential([\n", " Conv2D(kernel_size=(5, 5), filters=8, activation='relu', padding='VALID', input_shape=input_shape),\n", " MaxPooling2D(pool_size=(6, 6)),\n", " Flatten(),\n", " Dense(units=10, activation='softmax')\n", " ])\n", " \n", " model.compile(loss=loss, optimizer=optimizer, metrics=metrics)\n", " return model" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "# Run your function to get the benchmark model\n", "\n", "tf.random.set_seed(0)\n", "deterministic_model = get_deterministic_model(\n", " input_shape=(28, 28, 1), \n", " loss=SparseCategoricalCrossentropy(), \n", " optimizer=RMSprop(), \n", " metrics=['accuracy']\n", ")" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Model: \"sequential\"\n", "_________________________________________________________________\n", "Layer (type) Output Shape Param # \n", "=================================================================\n", "conv2d (Conv2D) (None, 24, 24, 8) 208 \n", "_________________________________________________________________\n", "max_pooling2d (MaxPooling2D) (None, 4, 4, 8) 0 \n", "_________________________________________________________________\n", "flatten (Flatten) (None, 128) 0 \n", "_________________________________________________________________\n", "dense (Dense) (None, 10) 1290 \n", "=================================================================\n", "Total params: 1,498\n", "Trainable params: 1,498\n", "Non-trainable params: 0\n", "_________________________________________________________________\n" ] } ], "source": [ "# Print the model summary\n", "\n", "deterministic_model.summary()" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Epoch 1/5\n", "1875/1875 [==============================] - 4s 2ms/step - loss: 0.4863 - accuracy: 0.8701\n", "Epoch 2/5\n", "1875/1875 [==============================] - 3s 2ms/step - loss: 0.1488 - accuracy: 0.9557\n", "Epoch 3/5\n", "1875/1875 [==============================] - 3s 1ms/step - loss: 0.1181 - accuracy: 0.9642\n", "Epoch 4/5\n", "1875/1875 [==============================] - 4s 2ms/step - loss: 0.1033 - accuracy: 0.9684\n", "Epoch 5/5\n", "1875/1875 [==============================] - 3s 2ms/step - loss: 0.0944 - accuracy: 0.9716\n" ] }, { "data": { "text/plain": [ "" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Train the model\n", "\n", "deterministic_model.fit(x_train, y_train, epochs=5)" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Accuracy on MNIST test set: 0.9732000231742859\n", "Accuracy on corrupted MNIST test set: 0.9409000277519226\n" ] } ], "source": [ "# Evaluate the model\n", "\n", "print('Accuracy on MNIST test set: ',\n", " str(deterministic_model.evaluate(x_test, y_test, verbose=False)[1]))\n", "print('Accuracy on corrupted MNIST test set: ',\n", " str(deterministic_model.evaluate(x_c_test, y_c_test, verbose=False)[1]))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As you might expect, the pointwise performance on the corrupted MNIST set is worse. This makes sense, since this dataset is slightly different, and noisier, than the uncorrupted version. Furthermore, the model was trained on the uncorrupted MNIST data, so has no experience with the spatters." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Probabilistic CNN model\n", "\n", "You'll start by turning this deterministic network into a probabilistic one, by letting the model output a distribution instead of a deterministic tensor. This model will capture the aleatoric uncertainty on the image labels. You will do this by adding a probabilistic layer to the end of the model and training using the negative loglikelihood. \n", "\n", "Note that, our NLL loss function has arguments `y_true` for the correct label (as a one-hot vector), and `y_pred` as the model prediction (a `OneHotCategorical` distribution). It should return the negative log-likelihood of each sample in `y_true` given the predicted distribution `y_pred`. If `y_true` is of shape `[B, E]` and `y_pred` has batch shape `[B]` and event shape `[E]`, the output should be a Tensor of shape `[B]`." ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "def nll(y_true, y_pred):\n", " \"\"\"\n", " This function should return the negative log-likelihood of each sample\n", " in y_true given the predicted distribution y_pred. If y_true is of shape \n", " [B, E] and y_pred has batch shape [B] and event_shape [E], the output \n", " should be a Tensor of shape [B].\n", " \"\"\"\n", " return -y_pred.log_prob(y_true)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now we need to build probabilistic model." ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "def get_probabilistic_model(input_shape, loss, optimizer, metrics):\n", " \"\"\"\n", " This function should return the probabilistic model according to the \n", " above specification.\n", " The function takes input_shape, loss, optimizer and metrics as arguments, which should be\n", " used to define and compile the model.\n", " Your function should return the compiled model.\n", " \"\"\"\n", " model = Sequential([\n", " Conv2D(kernel_size=(5, 5), filters=8, activation='relu', padding='VALID', input_shape=input_shape),\n", " MaxPooling2D(pool_size=(6, 6)),\n", " Flatten(),\n", " Dense(tfpl.OneHotCategorical.params_size(10)),\n", " tfpl.OneHotCategorical(10, convert_to_tensor_fn=tfd.Distribution.mode)\n", " ])\n", " \n", " model.compile(loss=loss, optimizer=optimizer, metrics=metrics)\n", " return model" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [], "source": [ "# Run your function to get the probabilistic model\n", "\n", "tf.random.set_seed(0)\n", "probabilistic_model = get_probabilistic_model(\n", " input_shape=(28, 28, 1), \n", " loss=nll, \n", " optimizer=RMSprop(), \n", " metrics=['accuracy']\n", ")" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Model: \"sequential_1\"\n", "_________________________________________________________________\n", "Layer (type) Output Shape Param # \n", "=================================================================\n", "conv2d_1 (Conv2D) (None, 24, 24, 8) 208 \n", "_________________________________________________________________\n", "max_pooling2d_1 (MaxPooling2 (None, 4, 4, 8) 0 \n", "_________________________________________________________________\n", "flatten_1 (Flatten) (None, 128) 0 \n", "_________________________________________________________________\n", "dense_1 (Dense) (None, 10) 1290 \n", "_________________________________________________________________\n", "one_hot_categorical (OneHotC multiple 0 \n", "=================================================================\n", "Total params: 1,498\n", "Trainable params: 1,498\n", "Non-trainable params: 0\n", "_________________________________________________________________\n" ] } ], "source": [ "# Print the model summary\n", "\n", "probabilistic_model.summary()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now, you can train the probabilistic model on the MNIST data using the code below. \n", "\n", "Note that the target data now uses the one-hot version of the labels, instead of the sparse version. This is to match the categorical distribution you added at the end." ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Epoch 1/5\n", "1875/1875 [==============================] - 2s 1ms/step - loss: 0.4863 - accuracy: 0.8698\n", "Epoch 2/5\n", "1875/1875 [==============================] - 2s 1ms/step - loss: 0.1491 - accuracy: 0.9556\n", "Epoch 3/5\n", "1875/1875 [==============================] - 2s 1ms/step - loss: 0.1183 - accuracy: 0.9643\n", "Epoch 4/5\n", "1875/1875 [==============================] - 3s 2ms/step - loss: 0.1034 - accuracy: 0.9682\n", "Epoch 5/5\n", "1875/1875 [==============================] - 2s 1ms/step - loss: 0.0945 - accuracy: 0.9716\n" ] }, { "data": { "text/plain": [ "" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Train the model\n", "\n", "probabilistic_model.fit(x_train, y_train_oh, epochs=5)" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Accuracy on MNIST test set: 0.9735999703407288\n", "Accuracy on corrupted MNIST test set: 0.9415000081062317\n" ] } ], "source": [ "# Evaluate the model\n", "\n", "print('Accuracy on MNIST test set: ',\n", " str(probabilistic_model.evaluate(x_test, y_test_oh, verbose=False)[1]))\n", "print('Accuracy on corrupted MNIST test set: ',\n", " str(probabilistic_model.evaluate(x_c_test, y_c_test_oh, verbose=False)[1]))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Analyse the model predictions\n", "\n", "We will now do some deeper analysis by looking at the probabilities the model assigns to each class instead of its single prediction. \n", "\n", "The function below will be useful to help us analyse the probabilistic model predictions." ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [], "source": [ "# Function to make plots of the probabilities that the model estimates for an image\n", "\n", "def analyse_model_prediction(data, true_labels, model, image_num, run_ensemble=False):\n", " if run_ensemble:\n", " ensemble_size = 200\n", " else:\n", " ensemble_size = 1\n", " image = data[image_num]\n", " true_label = true_labels[image_num, 0]\n", " predicted_probabilities = np.empty(shape=(ensemble_size, 10))\n", " for i in range(ensemble_size):\n", " predicted_probabilities[i] = model(image[np.newaxis, :]).mean().numpy()[0]\n", " model_prediction = model(image[np.newaxis, :])\n", " fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2, figsize=(10, 2),\n", " gridspec_kw={'width_ratios': [2, 4]})\n", " \n", " # Show the image and the true label\n", " ax1.imshow(image[..., 0], cmap='gray')\n", " ax1.axis('off')\n", " ax1.set_title('True label: {}'.format(str(true_label)))\n", " \n", " # Show a 95% prediction interval of model predicted probabilities\n", " pct_2p5 = np.array([np.percentile(predicted_probabilities[:, i], 2.5) for i in range(10)])\n", " pct_97p5 = np.array([np.percentile(predicted_probabilities[:, i], 97.5) for i in range(10)]) \n", " bar = ax2.bar(np.arange(10), pct_97p5, color='red')\n", " bar[int(true_label)].set_color('green')\n", " ax2.bar(np.arange(10), pct_2p5-0.02, color='white', linewidth=1, edgecolor='white')\n", " ax2.set_xticks(np.arange(10))\n", " ax2.set_ylim([0, 1])\n", " ax2.set_ylabel('Probability')\n", " ax2.set_title('Model estimated probabilities')\n", " plt.show()" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Prediction examples on MNIST\n", "\n", "for i in [0, 1577]:\n", " analyse_model_prediction(x_test, y_test, probabilistic_model, i)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The model is very confident that the first image is a 6, which is correct. For the second image, the model struggles, assigning nonzero probabilities to many different classes. \n", "\n", "Run the code below to do the same for 2 images from the corrupted MNIST test set." ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Prediction examples on MNIST-C\n", "\n", "for i in [0, 3710]:\n", " analyse_model_prediction(x_c_test, y_c_test, probabilistic_model, i)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The first is the same 6 as you saw above, but the second image is different. Notice how the model can still say with high certainty that the first image is a 6, but struggles for the second, assigning an almost uniform distribution to all possible labels.\n", "\n", "Finally, have a look at an image for which the model is very sure on MNIST data but very unsure on corrupted MNIST data:" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Prediction examples from both datasets\n", "\n", "for i in [9241]:\n", " analyse_model_prediction(x_test, y_test, probabilistic_model, i)\n", " analyse_model_prediction(x_c_test, y_c_test, probabilistic_model, i)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "It's not surprising what's happening here: the spatters cover up most of the number. You would hope a model indicates that it's unsure here, since there's very little information to go by. This is exactly what's happened." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Uncertainty quantification using entropy\n", "\n", "We can also make some analysis of the model's uncertainty across the full test set, instead of for individual values. One way to do this is to calculate the [entropy](https://en.wikipedia.org/wiki/Entropy_%28information_theory%29) of the distribution. The entropy is the expected information (or informally, the expected 'surprise') of a random variable, and is a measure of the uncertainty of the random variable. The entropy of the estimated probabilities for sample $i$ is defined as\n", "\n", "$$\n", "H_i = -\\sum_{j=1}^{10} p_{ij} \\text{log}_{2}(p_{ij})\n", "$$\n", "\n", "where $p_{ij}$ is the probability that the model assigns to sample $i$ corresponding to label $j$. The entropy as above is measured in _bits_. If the natural logarithm is used instead, the entropy is measured in _nats_.\n", "\n", "The key point is that the higher the value, the more unsure the model is. Let's see the distribution of the entropy of the model's predictions across the MNIST and corrupted MNIST test sets. The plots will be split between predictions the model gets correct and incorrect." ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [], "source": [ "# Functions to plot the distribution of the information entropy across samples,\n", "# split into whether the model prediction is correct or incorrect\n", "\n", "\n", "def get_correct_indices(model, x, labels):\n", " y_model = model(x)\n", " correct = np.argmax(y_model.mean(), axis=1) == np.squeeze(labels)\n", " correct_indices = [i for i in range(x.shape[0]) if correct[i]]\n", " incorrect_indices = [i for i in range(x.shape[0]) if not correct[i]]\n", " return correct_indices, incorrect_indices\n", "\n", "\n", "def plot_entropy_distribution(model, x, labels):\n", " probs = model(x).mean().numpy()\n", " entropy = -np.sum(probs * np.log2(probs), axis=1)\n", " fig, axes = plt.subplots(1, 2, figsize=(10, 4))\n", " for i, category in zip(range(2), ['Correct', 'Incorrect']):\n", " entropy_category = entropy[get_correct_indices(model, x, labels)[i]]\n", " mean_entropy = np.mean(entropy_category)\n", " num_samples = entropy_category.shape[0]\n", " title = category + 'ly labelled ({:.1f}% of total)'.format(num_samples / x.shape[0] * 100)\n", " axes[i].hist(entropy_category, weights=(1/num_samples)*np.ones(num_samples))\n", " axes[i].annotate('Mean: {:.3f} bits'.format(mean_entropy), (0.4, 0.9), ha='center')\n", " axes[i].set_xlabel('Entropy (bits)')\n", " axes[i].set_ylim([0, 1])\n", " axes[i].set_ylabel('Probability')\n", " axes[i].set_title(title)\n", " plt.show()" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "MNIST test set:\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Entropy plots for the MNIST dataset\n", "\n", "print('MNIST test set:')\n", "plot_entropy_distribution(probabilistic_model, x_test, y_test)" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Corrupted MNIST test set:\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Entropy plots for the MNIST-C dataset\n", "\n", "print('Corrupted MNIST test set:')\n", "plot_entropy_distribution(probabilistic_model, x_c_test, y_c_test)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "There are two main conclusions:\n", "- The model is more unsure on the predictions it got wrong: this means it \"knows\" when the prediction may be wrong.\n", "- The model is more unsure for the corrupted MNIST test than for the uncorrupted version. Futhermore, this is more pronounced for correct predictions than for those it labels incorrectly.\n", "\n", "In this way, the model seems to \"know\" when it is unsure. This is a great property to have in a machine learning model, and is one of the advantages of probabilistic modelling." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Bayesian CNN model\n", "\n", "The probabilistic model you just created considered only aleatoric uncertainty, assigning probabilities to each image instead of deterministic labels. The model still had deterministic weights. However, as you've seen, there is also 'epistemic' uncertainty over the weights, due to uncertainty about the parameters that explain the training data. " ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [], "source": [ "def get_convolutional_reparameterization_layer(input_shape, divergence_fn):\n", " \"\"\"\n", " This function should create an instance of a Convolution2DReparameterization \n", " layer according to the above specification. \n", " The function takes the input_shape and divergence_fn as arguments, which should \n", " be used to define the layer.\n", " Your function should then return the layer instance.\n", " \"\"\"\n", " \n", " layer = tfpl.Convolution2DReparameterization(\n", " input_shape=input_shape, filters=8, kernel_size=(5, 5),\n", " activation='relu', padding='VALID',\n", " kernel_prior_fn=tfpl.default_multivariate_normal_fn,\n", " kernel_posterior_fn=tfpl.default_mean_field_normal_fn(is_singular=False),\n", " kernel_divergence_fn=divergence_fn,\n", " bias_prior_fn=tfpl.default_multivariate_normal_fn,\n", " bias_posterior_fn=tfpl.default_mean_field_normal_fn(is_singular=False),\n", " bias_divergence_fn=divergence_fn\n", " )\n", " return layer" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Custom prior\n", "\n", "For the parameters of the `DenseVariational` layer, we will use a custom prior: the \"spike and slab\" (also called a *scale mixture prior*) distribution. This distribution has a density that is the weighted sum of two normally distributed ones: one with a standard deviation of 1 and one with a standard deviation of 10. In this way, it has a sharp spike around 0 (from the normal distribution with standard deviation 1), but is also more spread out towards far away values (from the contribution from the normal distribution with standard deviation 10). The reason for using such a prior is that it is like a standard unit normal, but makes values far away from 0 more likely, allowing the model to explore a larger weight space. Run the code below to create a \"spike and slab\" distribution and plot its probability density function, compared with a standard unit normal." ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [], "source": [ "# Function to define the spike and slab distribution\n", "\n", "def spike_and_slab(event_shape, dtype):\n", " distribution = tfd.Mixture(\n", " cat=tfd.Categorical(probs=[0.5, 0.5]),\n", " components=[\n", " tfd.Independent(tfd.Normal(\n", " loc=tf.zeros(event_shape, dtype=dtype), \n", " scale=1.0*tf.ones(event_shape, dtype=dtype)),\n", " reinterpreted_batch_ndims=1),\n", " tfd.Independent(tfd.Normal(\n", " loc=tf.zeros(event_shape, dtype=dtype), \n", " scale=10.0*tf.ones(event_shape, dtype=dtype)),\n", " reinterpreted_batch_ndims=1)],\n", " name='spike_and_slab')\n", " return distribution" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Plot the spike and slab distribution pdf\n", "\n", "x_plot = np.linspace(-5, 5, 1000)[:, np.newaxis]\n", "plt.plot(x_plot, tfd.Normal(loc=0, scale=1).prob(x_plot).numpy(), label='unit normal', linestyle='--')\n", "plt.plot(x_plot, spike_and_slab(1, dtype=tf.float32).prob(x_plot).numpy(), label='spike and slab')\n", "plt.xlabel('x')\n", "plt.ylabel('Density')\n", "plt.legend()\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [], "source": [ "def get_prior(kernel_size, bias_size, dtype=None):\n", " \"\"\"\n", " This function should create the prior distribution, consisting of the \n", " \"spike and slab\" distribution that is described above. \n", " The distribution should be created using the kernel_size, bias_size and dtype\n", " function arguments above.\n", " The function should then return a callable, that returns the prior distribution.\n", " \"\"\"\n", " n = kernel_size+bias_size \n", " prior_model = Sequential([tfpl.DistributionLambda(lambda t : spike_and_slab(n, dtype))])\n", " return prior_model" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [], "source": [ "def get_posterior(kernel_size, bias_size, dtype=None):\n", " \"\"\"\n", " This function should create the posterior distribution as specified above.\n", " The distribution should be created using the kernel_size, bias_size and dtype\n", " function arguments above.\n", " The function should then return a callable, that returns the posterior distribution.\n", " \"\"\"\n", " n = kernel_size + bias_size\n", " return Sequential([\n", " tfpl.VariableLayer(tfpl.IndependentNormal.params_size(n), dtype=dtype),\n", " tfpl.IndependentNormal(n)\n", " ])" ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [], "source": [ "def get_dense_variational_layer(prior_fn, posterior_fn, kl_weight):\n", " \"\"\"\n", " This function should create an instance of a DenseVariational layer according \n", " to the above specification. \n", " The function takes the prior_fn, posterior_fn and kl_weight as arguments, which should \n", " be used to define the layer.\n", " Your function should then return the layer instance.\n", " \"\"\"\n", " return tfpl.DenseVariational(\n", " units=10, make_posterior_fn=posterior_fn, make_prior_fn=prior_fn, kl_weight=kl_weight\n", " )" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now, you're ready to use the functions you defined to create the convolutional reparameterization and dense variational layers, and use them in your Bayesian convolutional neural network model." ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [], "source": [ "tf.random.set_seed(0)\n", "divergence_fn = lambda q, p, _ : tfd.kl_divergence(q, p) / x_train.shape[0]\n", "convolutional_reparameterization_layer = get_convolutional_reparameterization_layer(\n", " input_shape=(28, 28, 1), divergence_fn=divergence_fn\n", ")\n", "dense_variational_layer = get_dense_variational_layer(\n", " get_prior, get_posterior, kl_weight=1/x_train.shape[0]\n", ")" ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/home/chanseok/anaconda3/envs/torch/lib/python3.7/site-packages/tensorflow/python/keras/engine/base_layer.py:2191: UserWarning: `layer.add_variable` is deprecated and will be removed in a future version. Please use `layer.add_weight` method instead.\n", " warnings.warn('`layer.add_variable` is deprecated and '\n" ] } ], "source": [ "# Build and compile the Bayesian CNN model\n", "\n", "bayesian_model = Sequential([\n", " convolutional_reparameterization_layer,\n", " MaxPooling2D(pool_size=(6, 6)),\n", " Flatten(),\n", " dense_variational_layer,\n", " tfpl.OneHotCategorical(10, convert_to_tensor_fn=tfd.Distribution.mode)\n", "])\n", "bayesian_model.compile(loss=nll,\n", " optimizer=RMSprop(),\n", " metrics=['accuracy'],\n", " experimental_run_tf_function=False)" ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Model: \"sequential_2\"\n", "_________________________________________________________________\n", "Layer (type) Output Shape Param # \n", "=================================================================\n", "conv2d_reparameterization (C (None, 24, 24, 8) 416 \n", "_________________________________________________________________\n", "max_pooling2d_2 (MaxPooling2 (None, 4, 4, 8) 0 \n", "_________________________________________________________________\n", "flatten_2 (Flatten) (None, 128) 0 \n", "_________________________________________________________________\n", "dense_variational (DenseVari (None, 10) 2580 \n", "_________________________________________________________________\n", "one_hot_categorical_1 (OneHo multiple 0 \n", "=================================================================\n", "Total params: 2,996\n", "Trainable params: 2,996\n", "Non-trainable params: 0\n", "_________________________________________________________________\n" ] } ], "source": [ "# Print the model summary\n", "\n", "bayesian_model.summary()" ] }, { "cell_type": "code", "execution_count": 39, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Epoch 1/10\n", "1875/1875 [==============================] - 5s 2ms/step - loss: 1.9940 - accuracy: 0.3155\n", "Epoch 2/10\n", "1875/1875 [==============================] - 3s 2ms/step - loss: 0.7302 - accuracy: 0.7663\n", "Epoch 3/10\n", "1875/1875 [==============================] - 3s 2ms/step - loss: 0.4026 - accuracy: 0.8791\n", "Epoch 4/10\n", "1875/1875 [==============================] - 4s 2ms/step - loss: 0.2879 - accuracy: 0.9169\n", "Epoch 5/10\n", "1875/1875 [==============================] - 3s 2ms/step - loss: 0.2356 - accuracy: 0.9337\n", "Epoch 6/10\n", "1875/1875 [==============================] - 3s 2ms/step - loss: 0.2099 - accuracy: 0.9427\n", "Epoch 7/10\n", "1875/1875 [==============================] - 3s 2ms/step - loss: 0.1908 - accuracy: 0.9487\n", "Epoch 8/10\n", "1875/1875 [==============================] - 3s 2ms/step - loss: 0.1786 - accuracy: 0.9535\n", "Epoch 9/10\n", "1875/1875 [==============================] - 3s 2ms/step - loss: 0.1685 - accuracy: 0.9563\n", "Epoch 10/10\n", "1875/1875 [==============================] - 4s 2ms/step - loss: 0.1646 - accuracy: 0.9584\n" ] }, { "data": { "text/plain": [ "" ] }, "execution_count": 39, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Train the model\n", "\n", "bayesian_model.fit(x=x_train, y=y_train_oh, epochs=10, verbose=True)" ] }, { "cell_type": "code", "execution_count": 40, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Accuracy on MNIST test set: 0.9635999798774719\n", "Accuracy on corrupted MNIST test set: 0.928600013256073\n" ] } ], "source": [ "# Evaluate the model\n", "\n", "print('Accuracy on MNIST test set: ',\n", " str(bayesian_model.evaluate(x_test, y_test_oh, verbose=False)[1]))\n", "print('Accuracy on corrupted MNIST test set: ',\n", " str(bayesian_model.evaluate(x_c_test, y_c_test_oh, verbose=False)[1]))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Analyse the model predictions\n", "\n", "Now that the model has trained, run the code below to create the same plots as before, starting with an analysis of the predicted probabilities for the same images. \n", "\n", "This model now has weight uncertainty, so running the forward pass multiple times will not generate the same estimated probabilities. For this reason, the estimated probabilities do not have single values. The plots are adjusted to show a 95% prediction interval for the model's estimated probabilities." ] }, { "cell_type": "code", "execution_count": 41, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAh4AAACcCAYAAAAwJKKwAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAAdaElEQVR4nO3deZhcVZnH8e8vCwmEsKMYQgAxgBFEoNncQAEFBOKgKCggikZHg6Aigw4QIKAwioIMoyBBEGQN4EQMBh1B1GFJwiIkkExYk0AgEJZAwCTwzh/ndLhVdFd3Ol23urp/n+fJkzp1z63z1nb7rXPOPVcRgZmZmVkZ+jU6ADMzM+s7nHiYmZlZaZx4mJmZWWmceJiZmVlpnHiYmZlZaZx4mJmZWWl6beIh6UhJf+tk3VMkXd7Fdrq8r5l1jqTNJIWkAZ2o2+nv/irG9AtJJ9W7na6QdImk00tq61ZJX+7ivjXjlPSypHdW15X0IUmzauw3Iu/bvytxWX3VPfHIb37rvzckvVoof77e7fc0ktaQ9F+SnpX0oqTbGh2TWXeS9JikpZI2qLr/npw8bNag0LqsrWQmIr4WEePr1F5Ielc9HruZRMSaEfFIG/f/NSK2ai3nz9xehe1P5H1fLytW67wOfz2sqohYs/W2pMeAL0fEn6rrSRoQEcvrHU8PcCHpdX83sAh4X0OjMauPR4FDgfMAJG0LrNHQiGylSRKgiHij0bFY79GwoRZJe0iaJ+nfJC0AftXWr4pi5i9pkKQfS3pC0tO5q3P1TrZ3rqS5kl6SNF3Sh6qqDJZ0taTFku6WtF1h32GSrpO0UNKjkr7Zxee8NXAgMCYiFkbE6xExvSuPZdbDXQYcUSh/Afh1sYKktSX9On+vHpd0oqR+eVv//F1/VtIjwCfa2HeCpKckzZd0eme71SXtKul/Jb0g6T5JexS2HSnpkXwceFTS5yW9G/gFsFvuqX0h1y12/bcez46X9EyO65OS9pM0W9IiSd8vtLOzpNtzDE9J+k9Jq+Vtrb2g9+X2Ppvv31/SvXmf/5X03sLjbZ+PW4slXQ0MrvH8j5T099zmi5IekrRnYfutks6Q9HdgCfBOSe+XNDXXnyrp/VUPu4Wku/Lx9b8lrVd4vGslLcj73ibpPVX7biDpjzn2v0jatLBvmz0/ra93vn0ZMAL4XX69jlfV0Fytz4ukd+V2X8yft6vbe+2sezR6jsdGwHrApsCYTtQ/E9iS1EvwLmBj4OROtjU177cecAVwraTil3M0cG1h+28lDcwHwt8B9+X29gSOlfTxthqR9A9Jn2snhp2Bx4FT8wf8fkmf6mT8Zs3kDmAtSe/OB/hDgOq5UOcBawPvBHYnJSpfzNu+AuwPbA+0AJ+u2vcSYDnpOLA98DGgw3kGkjYGfg+cTvquHwdcJ2lDSUOAnwH7RsRQ4P3AvRHxIPA14Pbcfb9OOw+/EekPfutx6ZfAYcCOwIeAkyRtnuu+DnwL2ADYjXRc+TpARHw419kut3e1pO2Bi4GvAusDFwCTlH6MrQb8lpTsrUc6jnV0XNkFeDi3Pw64vpgsAIeTjslDgcX5NftZbvsnwO8lrV+ofwTwJeAdpPflZ4VtNwEjgbcBdwO/qYrl88D4HMu9bWyvKSIOB54ADsiv13+0Ue0S2v+8jAduBtYFhpN76ax+Gp14vAGMi4h/RsSrtSpKEumL8K2IWBQRi4EfkA5oHYqIyyPiuYhYHhFnA4OArQpVpkfExIhYRvpiDQZ2BXYCNoyI0yJiaR5v/GV77UbEeyPiinbCGA5sA7wIDAPGApfmX1RmvU1rr8fewIPA/NYNhWTkexGxOCIeA84m/cED+AxwTkTMjYhFwA8L+74d2A84NiJeiYhngJ/SuWPBYcDkiJgcEW9ExB+BafnxIB2TtpG0ekQ8FREzVuL5LgPOyMeQq0h/SM/Nz28GMBPYDiAipkfEHfl49Bgpkdi9xmOPAS6IiDtzT+mlwD9Jx6hdgYGk12tZREwk/dCq5ZlC/auBWVT2Kl0SETPy8PfHgP+LiMtyvFcCDwEHFOpfFhEPRMQrwEnAZ1p7FCLi4vwa/BM4BdhO0tqFfX8fEbfl7f9O6lnapIP4O60Tn5dlpB+/wyLitYio+8Tkvq7uczw6sDAiXutk3Q1JY8TTUw4CgIDOdq8eBxxF+oMfwFqkA0Orua03IuKN3I3XWndYa/dq1h/4ayfjLnqV9CE/PX+h/yLpFtIX+8EuPJ5ZT3YZcBuwOVXDLKTv3kBSD2Crx0m9BZC+e3OrtrXaNO/7VOFY0K+qfns2BQ6WVPyjORC4JSJeycMaxwET8lDDdyLioU48LsBzhcmMrT+kni5sfxVYE0DSlqQfOC2k49oAoNaw66bAFyQdXbhvNd48Rs2Pyit+Fl+vtrRVf1ihXHwth7XxeMX3qrr+46TXdANJzwJnAAeTjuGtc0U2IP0Aq9g3Il6WtIi3vv+roqPPy/GkXo+7JD0PnB0RF3dT29aGRice1ZfGfYXCBDRJGxW2PUv64r4nIuazEpTmcxxP6s6ckROL50mJS6tNCvX7kXonniR1zz0aESNXps12/KON+3x5YOuVIuJxSY+Sfm0eVbX5Wd78pTkz3zeCN3tFnqLwnczbWs0l/drfoAsT0ueSfp1/pZ2YpwBTlOaOnU7q3fwQ3f89/TlwD3BoRCyWdCxvHU4qmkvqTTmjeoOk3YGNJamQTIwgDaW0p636kwrbi8/3SdL7VDQC+EOhXP1eLSO9x58jDWPvBTxGGlqrdexdkzRc9GSN2NtS6/2p+XmJiAWkoT0kfRD4k6TbImLOSsZgndTooZZq9wHvkfS+PP/ilNYNeVb1L4GfSnobpPHa9uZaVBlKSiAWAgMknUzq8SjaUdJBeTLSsaQP6h3AXcBipUmwqytNettG0k5deH63kcYivydpgKQPAB8BpnThscyawVHAR3MX/Aq5Z+Aa4AxJQ/OEwm/z5jyQa4BvShouaV3ghMK+T5HG5M+WtJakfpK2yH+AO3I5cICkj+fv8uA8UXG4pLdLGp3nevwTeJk3f6E/DQzP8ym6w1DgJeBlpUnn/1q1/WnS3JdWvwS+JmkXJUMkfULSUOB20vHtm3le2kGk+WS1vK1Q/2DSWXaT26k7GdhS0ufyceuzwCjgxkKdwySNkrQGcBowMb/HQ0mv5XOkH5U/aOPx95P0wfzajgfuiIiV7e2ofr1W6OjzIulgScNz9edJSYzP4qmjHpV4RMRs0of2T8D/AdVjbf8GzAHukPRSrrcVHZtCys5nk7oBX+Ot3Xj/DXyW9ME7HDgoj3++Tprk9j7SKYLPAheRMve3kDRD7axPksd+R5N+Ab5IOpgcsRJduWZNJSIejohp7Ww+mtTL+Qjpu34FaQIlpO/GFNKPkbuB66v2PYI01DCT9J2dSJrY2FE8c0nfwe+TfojMBb5LOhb2IyU/T5JOdd+dNxOCPwMzgAV5+GBVHUfqDVhMeq7VZ1KcQpr/9YKkz+TX8CvAf5Ke7xzgyPyclgIH5fIi0nGs+vWqdidpwmfrUMinI+K5tirm+/cHvkNKII4H9o+I4utwGWkC5wLS/LjWM/9+TTrmzie9V3e00cQVpAmui0gTcQ/rIPa2/BA4Mb9ex7WxvdbnZSfgTkkvk3p9jok21g6x7qPKYT4zM+vNJB1JWk/pg42OxfqmHtXjYWZmZr2bEw9rWpIuVlqs6YF2tkvSzyTNUVpfZYeyYzQzs0pOPKyZXQLsU2P7vqRx7JGkdRB+XkJMZj1aRFziYRZrJCce1rQi4jbShLT2jAZ+HckdwDqSOpyAaGZm9ePEw3qzjak8e2kelYsemZlZyTpaQMynvDQfdVzFqkkaQ75e0JAhQ3bceuutGxyRWc9339P3sfz1+l9UfED/AWz39u06rmg9xvTp05+NiA3b2tbolUvN6mk+lSsqDqdwvZCiiLgQuBCgpaUlpk1rb+kJM2ulU8v5nbOc5Uwb5+9kM5HU7rL9Hmqx3mwScEQ+u2VX4MW8iqGZmTWIezysaUm6EtiDdDGqeaTVDwcCRMQvSEs970da5XEJb15y3cy6wVPfeYqN1tyo44qraMHLC+rehpXHiYc1rYg4tIPtAXyjpHDM+pwyko4y27FyeKjFzMzMSuPEw8zMzErjxMPMzMxK0yfneMyZM6eiPHbs2IrywIEDK8q/+93v6h6TmZlZX+AeDzMzMyuNEw8zMzMrjRMPMzMzK02fmeOxZMmSFbe/+MXKdaT+9re/VZRPPPHEUmIyMzPra9zjYWZmZqVx4mFmZmalceJhZmZmpekzczyOPfbYFber53RstdVWFeXRo0eXEZKZmVmf4x4PMzMzK40TD2tqkvaRNEvSHEkntLF9hKRbJN0j6R+S9mtEnGZmlvTaoZaLLrqoZrnotNNOqyi3tLTUJSbrXpL6A+cDewPzgKmSJkXEzEK1E4FrIuLnkkYBk4HNSg/WzMwA93hYc9sZmBMRj0TEUuAqoHqCTgBr5dtrA0+WGJ+ZmVXptT0e1idsDMwtlOcBu1TVOQW4WdLRwBBgr3JCMzOztrjHw3q7Q4FLImI4sB9wmaS3fO4ljZE0TdK0hQsXlh6kmVlf0Wt6PJYuXVpR/tGPflRRjogVt3fYYYeKbT59tmnNBzYplIfn+4qOAvYBiIjbJQ0GNgCeKVaKiAuBCwFaWloCMzOrC/d4WDObCoyUtLmk1YBDgElVdZ4A9gSQ9G5gMOAuDTOzBnHiYU0rIpYDY4EpwIOks1dmSDpN0oG52neAr0i6D7gSODKK3V9mZlaqXjPUYn1TREwmnSJbvO/kwu2ZwAfKjsvMzNrWaxKPG264oaI8e/bsduuOGzeuojxo0KC6xGRmZmaVPNRiZmZmpXHiYWZmZqVx4mE9gqQD2lpfw8zMepemnePx3HPPVZS/9KUv1ax/5plnrrh9wAEH1CUmWyWfBc6RdB1wcUQ81OiAzMys+/kXpvUIEXEYsD3wMHCJpNvzaqJDGxyamZl1Iyce1mNExEvARNLF3t4B/Atwd77OipmZ9QJOPKxHkDRa0g3ArcBAYOeI2BfYjrQImJmZ9QJNO8fjnHPOqSgvWbKkojx48OCKcnFeh6S6xWVddhDw04i4rXhnRCyRdFSDYjIzs27mHg/rKRZUJx2SzgKIiP9pTEhmZtbdnHhYT7F3G/ftW3oUZmZWV0071GK9g6R/Bb4ObCHpH4VNQ4G/NyYqMzOrl6ZJPJ5//vmK8gUXXFCz/qhRo2qWrce4ArgJ+CFwQuH+xRGxqDEhmZlZvXioxRotIuIx4BvA4sI/JK3X0c6S9pE0S9IcSSe0U+czkmZKmiHpim6M3czMVlLT9HhYr3UFsD8wHQigeMpRAO9sb0dJ/YHzSfND5gFTJU2KiJmFOiOB7wEfiIjnJb2t+5+CmZl1lhMPa6iI2D//v3kXdt8ZmBMRjwBIugoYDcws1PkKcH5EPJ/beWbVIjYzs1XRNInHa6+9VlFeuHBhzfoTJkyoWyzVbb/00ksV5S222KJubfc2knaotT0i7q6xeWNgbqE8D9ilqs6WuZ2/A/2BUyLiD10I1czMukHTJB7Wa51dY1sAH13Fxx8AjAT2AIYDt0naNiJeKFaSNAYYAzBixIhVbNLMzNrjxMMaKiI+sgq7zwc2KZSH5/uK5gF3RsQy4FFJs0mJyNSqOC4ELgRoaWmJVYjJzMxqcOJhDSXpoxHxZ0kHtbU9Iq6vsftUYKSkzUkJxyHA56rq/BY4FPiVpA1IQy+PrHLgZmbWJU2TeEycOLHm9v79+1eUBw0a1OW2li1bVlH+6le/WlG++eabK8rVczxuuOGGivKee+7Z5Vj6gN2BPwMHtLEtgHYTj4hYLmksMIU0f+PiiJgh6TRgWkRMyts+Jmkm8Drw3Yh4rrufhJmZdU7TJB7WO0XEuPz/F7u4/2RgctV9JxduB/Dt/M/MzBrMC4hZjyBpfUk/k3S3pOmSzpW0fqPjMjOz7uXEw3qKq4CFwKeAT+fbVzc0IjMz63ZKPdHtatjs/kWLKi/Tse2221aUn3zyyYpyS0tLRXnq1IqTFmqqntNx+OGHV5Svvnrl/v4NGzasonz//fdXlNdbr8OVwFeFOq7S80h6ICK2qbrv/ojYtr196qWlpSWmTZtWdrNmZr2GpOkR0dLWNvd4WE9xs6RDJPXL/z5DmhhqZma9iCeXWkNJWsyb12g5Frg8b+oHvAwc15jIzMysHnps4vHQQw9VlKuHVqqtu+66XW7rxz/+cUW5o6GVddZZp6L8wgsvVJSrY501a1ZFebfddlu5AHuxiBja6BjMzKw8PTbxsL5H0rqkVUUHt94XEbc1LiIzM+tuTjysR5D0ZeAY0rLn9wK7Arez6tdqMTOzHsSTS62nOAbYCXg8X79le+CFhkZkZmbdrtf0eHzyk5/sdN2zzjqrojx+/Pia9bfeeuuK8g9+8IOK8kEHVV5mRKo8o7VfP+d3nfBaRLwmCUmDIuIhSVs1OigzM+tevSbxsKY3T9I6pIu6/VHS88DjDY3IzMy6nRMP6xEi4l/yzVMk3QKsDfyhgSGZmVkdeAzAegxJO0j6JvBeYF5ELO3EPvtImiVpjqQTatT7lKSQ1OZKemZmVo4e2+NRvVbGGmusUVFesmRJRfnWW2+tKH/961+vKC9YsGDF7VNPPbVi26uvvlpR3nHHHSvKU6ZULqB50kkntR10tscee1SUd9lll5r1DSSdDBwMXJ/v+pWkayPi9Br79AfOB/YG5gFTJU2KiJlV9YaSJq/eWZfgzcys09zjYT3F54GdImJcRIwjnU57eAf77AzMiYhHcu/IVcDoNuqNB84CXuvOgM3MbOU58bCe4kkKC4cBg4D5HeyzMTC3UJ6X71tB0g7AJhHx++4I0szMVk2PHWqxvkHSeaRrtbwIzJD0x1zeG7hrFR+7H/AT4MhO1B0DjAEYMWLEqjRrZmY1KCJqba+5sUw77bRTRbn6suUDBlTmUDfeeGNF+dxzz11x+6abbqrZ1tFHH11Rrp5PMmHChJr7P/rooxXlzTbbrGb9bqaOq/Qckr5Qa3tEXFpj392AUyLi47n8vbzPD3N5beBh0sXmADYCFgEHRkS7171vaWmJ6s+XmZl1nqTpEdHmZH73eFhDFRMLSasBW+birIhY1sHuU4GRkjYnDcscAnyu8NgvAhsUHv9W4LhaSYeZmdWXEw/rESTtAVwKPEbqtdlE0hdqXSQuIpZLGgtMAfoDF0fEDEmnAdMiYlLdAzczs5XixMN6irOBj0XELABJWwJXAjvW2ikiJgOTq+47uZ26e3RLpGZm1mVNk3hUz6vYbrvtKsrLly+vKO+zzz5dbuu8885bqfpHHnlkRXnYsGFdbrsPG9iadABExGxJAxsZkJmZdb+mSTys15su6SLg8lz+POC5GGZmvYwTD+spvgZ8A/hmLv8V+K/GhWNmZvXgxMMaLi99fl9EbE1ad8PMzHqppkk8Ro4cWVEeP358RXncuHEV5TfeeKPb2h4yZEhF+cwzz6wojx07ttva6osi4vV8obcREfFEo+MxM7P6aZrEw3q9dUkrl94FvNJ6Z0Qc2LiQzMysuznxsJ6i9iV/zcysV3DiYQ0laTBpYum7gPuBCRGxvPZeZmbWrJom8Vh99dUryieeeGJFeeutt64on3HGGRXl2bNnr7hdfe2VjhxxxBEVZc/p6FaXAstIZ7HsC4wCjmloRGZmVjdNk3hYrzUqIrYFkDSBVbwirZmZ9Wz9Gh2A9XkrLgTnIRYzs97PPR7WaNtJeinfFrB6LguIiFircaGZmVl3U0TU2l5zYzO58cYbV9z+7ne/W7Ht4YcfriifcMIJFeWTTqo84WLgwB59CRE1OoBm19LSEtOmebV2M7OukjQ9Ilra2uahFmtqkvbJi4/NkXRCG9u/LWmmpH9I+h9JmzYiTjMzS5x4WNPKS62fz5tnwxwqaVRVtXuAloh4LzAR+I9yozQzsyInHtbMdgbmRMQjEbEUuAoYXawQEbdEROv503cAw0uO0czMCvrM5NL999+/zdvW1DYG5hbK84BdatQ/CriprhGZmVlNfSbxsL5N0mFAC7B7O9vHAGMARowYUWJkZmZ9i4darJnNBzYplIfn+ypI2gv4d+DAiPhnWw8UERdGREtEtGy44YZ1CdbMzJx4WHObCoyUtLmk1YBDgEnFCpK2By4gJR3PNCBGMzMrcOJhTSuvdDoWmAI8CFwTETMknSbpwFztR8CawLWS7pU0qZ2HMzOzEniOhzW1iJgMTK667+TC7b1KD8rMzNrlHg8zMzMrjRMPMzMzK40TDzMzMyuNEw8zMzMrjRMPMzMzK40TDzMzMyuNEw8zMzMrjRMPMzMzK40TDzMzMyuNEw8zMzMrjRMPMzMzK40TDzMzMyuNEw8zMzMrjRMPa2qS9pE0S9IcSSe0sX2QpKvz9jslbdaAMM3MLHPiYU1LUn/gfGBfYBRwqKRRVdWOAp6PiHcBPwXOKjdKMzMrcuJhzWxnYE5EPBIRS4GrgNFVdUYDl+bbE4E9JanEGM3MrMCJhzWzjYG5hfK8fF+bdSJiOfAisH4p0ZmZ2VsM6GC7fxlanyBpDDAmF1+WNKvE5jcAni2xPbfd+Pb93Pte241uv+y2N21vQ0eJh1lPNh/YpFAenu9rq848SQOAtYHnqh8oIi4ELqxTnDVJmhYRLW6777Tv59732m50+41+7kUearFmNhUYKWlzSasBhwCTqupMAr6Qb38a+HNERIkxmplZgXs8rGlFxHJJY4EpQH/g4oiYIek0YFpETAImAJdJmgMsIiUnZmbWIE48rKlFxGRgctV9JxduvwYcXHZcK6khQzx9vO1Gt+/n3vfabnT7jX7uK8i9zmZmZlYWz/EwMzOz0jjxMGuQjpZ7r3PbF0t6RtIDZbab295E0i2SZkqaIemYEtseLOkuSffltk8tq+2qOPpLukfSjSW3+5ik+yXdK2lamW3n9teRNFHSQ5IelLRbSe1ulZ9z67+XJB1bRtu5/W/lz9sDkq6UNListnP7x+S2Z5T5vNuNx0MtZuXLy73PBvYmLXw2FTg0ImaW1P6HgZeBX0fENmW0WWj7HcA7IuJuSUOB6cAny3juedXaIRHxsqSBwN+AYyLijnq3XRXHt4EWYK2I2L/Edh8DWiKiIWtJSLoU+GtEXJTPRFsjIl4oOYb+pNPsd4mIx0tob2PS52xURLwq6RpgckRcUu+2c/vbkFZ13hlYCvwB+FpEzCmj/ba4x8OsMTqz3HvdRMRtpLN8ShcRT0XE3fn2YuBB3rribL3ajoh4ORcH5n+l/vqSNBz4BHBRme02mqS1gQ+TzjQjIpaWnXRkewIPl5F0FAwAVs9rCa0BPFli2+8G7oyIJXn15r8AB5XY/ls48TBrjM4s997r5asFbw/cWWKb/SXdCzwD/DEiSms7Owc4Hnij5HYhJVk3S5qeV+st0+bAQuBXeZjpIklDSo4B0in1V5bVWETMB34MPAE8BbwYETeX1T7wAPAhSetLWgPYj8qFF0vnxMPMGkLSmsB1wLER8VJZ7UbE6xHxPtJKtzvnruhSSNofeCYippfVZpUPRsQOpCs6fyMPuZVlALAD8POI2B54BSh7btNqwIHAtSW2uS6pN3NzYBgwRNJhZbUfEQ+Srsp9M2mY5V7g9bLab4sTD7PG6Mxy771Wnl9xHfCbiLi+ETHkbv5bgH1KbPYDwIF5rsVVwEclXV5W4/nXNxHxDHADacivLPOAeYUepomkRKRM+wJ3R8TTJba5F/BoRCyMiGXA9cD7S2yfiJgQETtGxIeB50nzyxrGiYdZY3RmufdeKU/wnAA8GBE/KbntDSWtk2+vTprc+1BZ7UfE9yJieERsRnrP/xwRpfz6lTQkT+YlD3F8jNQNX4qIWADMlbRVvmtPoJTJ1AWHUuIwS/YEsKukNfJnf0/SvKbSSHpb/n8EaX7HFWW2X80rl5o1QHvLvZfVvqQrgT2ADSTNA8ZFxISSmv8AcDhwf55rAfD9vAptvb0DuDSf2dAPuCYiSj2ltYHeDtyQ/vYxALgiIv5QcgxHA7/JyfYjwBfLajgnW3sDXy2rTYCIuFPSROBuYDlwD+WvInqdpPWBZcA3GjSpdwWfTmtmZmal8VCLmZmZlcaJh5mZmZXGiYeZmZmVxomHmZmZlcaJh5mZmZXGiYeZmZmVxomHmZmZlcaJh5mZmZXm/wErB3cntjpAMQAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Prediction examples on MNIST\n", "\n", "for i in [0, 1577]:\n", " analyse_model_prediction(x_test, y_test, bayesian_model, i, run_ensemble=True)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "For the first image, the model assigns a probability of almost one for the 6 label. Furthermore, it is confident in this probability: this probability remains close to one for every sample from the posterior weight distribution (as seen by the horizontal green line having very small height, indicating a narrow prediction interval). This means that the epistemic uncertainty on this probability is very low. \n", "\n", "For the second image, the epistemic uncertainty on the probabilities is much larger, which indicates that the estimated probabilities may be unreliable. In this way, the model indicates whether estimates may be inaccurate." ] }, { "cell_type": "code", "execution_count": 42, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Prediction examples on MNIST-C\n", "\n", "for i in [0, 3710]:\n", " analyse_model_prediction(x_c_test, y_c_test, bayesian_model, i, run_ensemble=True)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Even with the spatters, the Bayesian model is confident in predicting the correct label for the first image above. The model struggles with the second image, which is reflected in the range of probabilities output by the network." ] }, { "cell_type": "code", "execution_count": 43, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAh4AAACcCAYAAAAwJKKwAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAAfNElEQVR4nO3de7wdVX338c83Jwm5EEIgSIAQQCUgghg4BLzzCFhAJC2KgoLCo6S2KhelFG0FHtCKfUTUSlUkGC5ykYs2rRGwFYq1hCQHQUy4NIZLEgIBAiEJhNx+/WPmhJlhn33OSc6e2fuc7/v1yit77Vkza+3bnN+s+c0aRQRmZmZmZRhUdQfMzMxs4HDgYWZmZqVx4GFmZmalceBhZmZmpXHgYWZmZqVx4GFmZmal6beBh6RTJP1XD+teIOnazWxns9c1s56RtLukkDS4B3V7/Nvfwj79UNJXG93O5pA0XdLXSmrrLkmf2cx16/ZT0ipJbyzWlfQeSY/UWW9Cum7b5vTLGqvhgUf64Xf+2yjplUz5E41uv9lI+oykBenrv03SzlX3yawvSXpc0lpJYwvP/z4NHnavqGubrVYwExGfjYiLGtReSHpzI7bdSiJi64hYWOP530bEXp3l9Dt3eGb5k+m6G8rqq/VcwwOP9MPfOiK2Bp4EPpR57qed9XpyJNPqJB0K/AMwBdgOeAy4vsIumTXKY8CJnQVJ+wEjquuObQ4l+u3IuFWjsi+UpEMlLZb0t5KeBn5S66giG/lL2krStyQ9KemZdKhzeA/b+66kRZJektQh6T2FKsMk3ShppaT7JO2fWXdnSbdIelbSY5JO38yXfQxwU0TMi4i1wEXAeyW9aTO3Z9asrgE+mSl/Crg6W0HSaElXp7+rJyT9fecfOUlt6W/9OUkLgQ/WWHeapKWSlkj6Wk+H1SUdIum/Jb0o6YH0gKBz2SmSFqb7gcckfULSW4AfAu9IRypfTOtmh/4792fnSFqW9uvPJR0t6VFJyyV9JdPOZEn3pH1YKun7koamy+5Oqz2Qtvex9PljJN2frvPfkt6W2d6kdL+1UtKNwLA6r/8USb9L21wh6WFJh2WW3yXp65J+B7wMvFHSOyXNSevPkfTOwmbfJGl2un/9F0nbZbZ3k6Sn03XvlvTWwrpjJf067ft/Stots27NkZ/O9zt9fA0wAfjX9P06R4VTc/W+L5LenLa7Iv2+3djVe2d9o+pIdhzJkf9uwNQe1L8YmAi8HXgzsAtwXg/bmpOutx1wHXCTpOyPcwpwU2b5LyQNSXeE/wo8kLZ3GHCmpD+r1YikP0j6eJ1+qMbjfXv4GsxaxSxgG0lvSXfwJwDFXKh/AkYDbwTeRxKonJouO40kUJ8EtAMfKaw7HVhPsh+YBHwA6DbPQNIuwC+Br5H81s8GbpG0g6SRwPeAoyJiFPBO4P6IeAj4LHBPOlK7bRebH0fyB79zv/Rj4CTgQOA9wFcl7ZHW3QCcBYwF3kGyX/lrgIh4b1pn/7S9GyVNAq4E/hLYHvgRMEPJwdhQ4Bckwd52JPuxD3fzVhwM/Clt/3zg1mywAJxMsk8eBaxM37PvpW1/G/ilpO0z9T8J/F9gJ5LP5XuZZb8C9gTeANwH/JS8T5AchI0F7q+xvK6IOJn8aPo/1qg2na6/LxcBdwBjgPEk30troKoDj43A+RHxakS8Uq+iJJH8EM6KiOURsZLktMUJPWkoIq6NiOcjYn1EXAJsBeyVqdIRETdHxDqSH9Yw4BDgIGCHiLgwItam5xt/3FW7EfG2iLiui27cBnxU0tuUjNScBwQegrb+qXPU4wjgIWBJ54JMMPLliFgZEY8Dl5D8wQP4KPCdiFgUEcuBb2TW3RE4GjgzIlZHxDLgUnq2LzgJmBkRMyNiY0T8Gpibbg+SfdK+koZHxNKImNeL17sO+Hq6D7mB5A/pd9PXNw+YD+wPEBEdETEr3R89ThJIvK/OtqcCP4qIeyNiQ0RcBbxKso86BBhC8n6ti4ibSQ606lmWqX8j8Aj5UaXp6cjsepI/0v8TEdek/b0eeBj4UKb+NRHxx4hYDXyVZD/Xlr7WK9P34FXgAmB/SaMz6/4yIu5Ol/8dycjSrt30v8d68H1ZR3Lwu3NErImIhicmD3RV51U8GxFrelh3B5I/0B1JDAIkIwY9HV49G/g0sDPJH/ttSHYMnRZ1PoiIjekwXmfdnTuHV1NtwG972O9NIuLfJZ0P3JK2/x2So4nFvd2WWQu4Brgb2IPCaRaS394Q4InMc0+QjBZA8ttbVFjWabd03aWZfcGgQv2u7AYcLyn7R3MIcGdErE5Pa5wNTEtPNXwpIh7uwXYBns8kM3YeSD2TWf4KsDWApIkkBzjtJPu1wUBHN/3+lKQvZJ4bymv7qCWRv+Nn9v2qpVb9bKJ79r3cucb2sp9Vsf4TJO/pWEnPAV8HjifZh29M64wFVhTXjYhVkpbz+s9/S3T3fTmHZNRjtqQXgEsi4so+attqqHrEo3hr3NVkjv4ljcsse47kh/vWiNg2/Tc6TVqtS0k+xzkkR1Fj0qHSFeRPe+yaqT+IZMjtKZIv52OZNreNiFERcTSbISIui4g9I2JHkgBkMPDHzdmWWTOLiCdIkkyPBm4tLH6O1440O03gtVGRpWR+k+myTotIjvbHZn6T20REMXeglkUkR+fZ3/PIiLg47fPtEXEEySmDh0lGN+H1+6ot9YN0+3tGxDbAV8jvj2r1++uFfo9IRx+WArso81eV/PtVS636T2XK2df7FPnPqbP+kky5+FmtI/mMP05yGvtwktNqu6d1utr3bk1yuijbl56o9/nU/b5ExNMRcVpE7ExyKuufa+WVWN+pOvAoegB4q6S3p/kXF3QuiIiNJDuBSyW9AZLztV3lWhSMIjm/9ywwWNJ5JCMOWQdKOi5NRjqT5Is6C5gNrFSSBDtcSdLbvpIO6u2LkzQsXVeSJgCXkwzFvtDbbZm1iE8D70+H4DdJRwZ+Bnxd0qg0ofCLvJYH8jPgdEnjJY0Bzs2su5TknPwlkraRNEjSmyTVO1XR6VrgQ5L+LP0tD0sTFcdL2lHSlDTX41VgFa8doT8DjE/zKfrCKOAlYJWkvYG/Kix/hiT3pdOPgc9KOjjdf4yU9EFJo4B7SPZvp6d5accBk7tp/w2Z+scDbwFmdlF3JjBR0sclDU5HhfYB/i1T5yRJ+0gaAVwI3Jx+xqNI3svnSQ4q/6HG9o+W9O70vb0ImBURvR3tKL5fm3T3fZF0vKTxafUXSIKYjbW2ZX2jqQKPiHiU5Ev778D/AMVzbX8LLABmSXoprbcX3budJL/iUZJhwDW8fhjvX4CPkXzxTgaOS89/biBJcns7ydHbc8AVJNH760iap67nJxlGkri6iiSguYfkfKhZvxQRf4qIuV0s/gLJKOdCkt/6dSQJlJD8ob2d5GDkPl4/YvJJklMN80l+szeTjFJ0159FJEfgXyE5EFkE/A3JvnAQSfDzFLCcJOeiMyD4DTAPeDo9fbClziYZDVhJ8lqLV1JcAFyl5AqWj6bv4WnA90le7wLglPQ1rQWOS8vLSfZjxfer6F6ShM/OUyEfiYjna1VMnz8G+BJJAHEOcExEZN+Ha0gSOJ8m2c91Xvl3Nck+dwnJZzWrRhPXkSS4LidJxD2pm77X8g3g79P36+way+t9Xw4C7pW0CpgBnBE15g6xvqP8aT4zM+vPJJ0CfCYi3l11X2xgaqoRDzMzM+vfHHhYy5J0pZLJmmom56bnwr+nZIr6P0g6oOw+mplZngMPa2XTgSPrLD+K5Dz2niTzIPyghD6ZNbWImO7TLFYlBx7WsiLibpKEtK5MAa6OxCxgW0ndJiCamVnjOPCw/mwX8lcvLSY/6ZGZmZWsu5lL++UlL7Nm5a/oWr9+fa68cWP9S7jz8+68vjx0aP5S/8mTu7ukvk/Vm4TIuiBpKun9gkaOHHng3nvvXXGPzMxaV0dHx3MRsUOtZVVPmW7WSEvIz6g4nvxsi5tExOUkE7rR3t4ec+d2NfWEmZl1R1KX0/b7VIv1ZzOAT6ZXtxwCrEhnMTQzs4p4xMNalqTrgUNJbka1mGT2wyEAEfFDkqmejyaZ5fFlXrvlupmZVaRpA4+OjvyNGg888MA+2153s7V2l8MxaNCguuW2th7dMNe2UESc2M3yAD5XUnfMzKwHfKrFzMzMSuPAw8zMzErjwMPMzMxKU1mOR/FyxeJcGkWzZ8/OlXs7N0Zv7sJbzOkYPDj/NhVzOIrlAw7wLUHMzMxq8YiHmZmZlcaBh5mZmZXGgYeZmZmVprIcjw0bNuTK3eV4DBkyZIvaa29v3/S4mC9SVJyXo5jjsaVzipiZmQ1UHvEwMzOz0jjwMDMzs9I48DAzM7PSVJbjsXHjxrrLu8uz2BLFOUCKOR/FeTmaOaejOB9KNpfFzMys2XjEw8zMzErjwMNamqQjJT0iaYGkc2ssnyDpTkm/l/QHSUdX0U8zM0uUdqqleJv77hRPtTTydEeZbfW13kwF399IagMuA44AFgNzJM2IiPmZan8P/CwifiBpH2AmsHvpnTUzM8AjHtbaJgMLImJhRKwFbgCmFOoEsE36eDTwVIn9MzOzgsqSS836wC7Aokx5MXBwoc4FwB2SvgCMBA4vp2tmZlaLRzysvzsRmB4R44GjgWskve57L2mqpLmS5j777LOld9LMbKAobcSjmDcxZ86cXLl4K/pi3kV3HnzwwVz58MPzB7Y77LDDpscXX3xxl8taTfHS3wFmCbBrpjw+fS7r08CRABFxj6RhwFhgWbZSRFwOXA7Q3t4+cBNnzMwazCMe1srmAHtK2kPSUOAEYEahzpPAYQCS3gIMAzykYWZWEQce1rIiYj3weeB24CGSq1fmSbpQ0rFptS8Bp0l6ALgeOCUG8qVAZmYVc3KptbSImElyiWz2ufMyj+cD7yq7X2ZmVltlgcdBBx2UKxdzPro7KF2+fHmufOqpp+bKy5Yt67K8cuXK3LK1a9fmytOnT8+Vp0zJX6E5ZsyYun0r0wEHHFB1F8zMzHrMp1rMzMysNA48zMzMrDQOPKwpSPpQrfk1zMysf2ma5NLivB3r16/PlYs5IM8//3yuXLwXzLRp03Ll8ePHb3r8yiuv5JYV80mGDh2aK+++++51+zJx4kRsi30M+I6kW4ArI+LhqjtkZmZ9z0eY1hQi4iRgEvAnYLqke9LZREdV3DUzM+tDDjysaUTES8DNJDd72wn4C+C+9D4rZmbWDzjwsKYgaYqknwN3AUOAyRFxFLA/ySRgZmbWD6ib+TIqm+Fx9uzZdZcvXLgwVy7mhIwcOTJXHjduXJd1V69enSu//PLLufKKFSty5RdffDFXPuuss+r2tWTqvkrzkXQVMC0i7q6x7LCI+I+y+tLe3h5z584tqzkzs35HUkdEtNda5hEPaxZPF4MOSd8EKDPoMDOzxnLgYc3iiBrPHVV6L8zMrKGa5nJaG5gk/RXw18CbJP0hs2gU8LtqemVmZo3StIFHcV6PYt5FMU+jWH+77bbrcttSPg2ira0tVx4yZEjd5XfddVeu3GQ5Hq3mOuBXwDeAczPPr4yI5bVXMTOzVuVTLVa1iIjHgc8BKzP/kNR19JiSdKSkRyQtkHRuF3U+Kmm+pHmSruvDvpuZWS817YiHDRjXAccAHSRXUWWHowJ4Y1crSmoDLiPJD1kMzJE0IyLmZ+rsCXwZeFdEvCDpDX3/EszMrKcceFilIuKY9P89NmP1ycCCiFgIIOkGYAowP1PnNOCyiHghbWfZlvXYzMy2RNMGHu3t+ct/r7/++lx5w4YNuXLx/irFvIxs/Y0bN+aWFXM+uitPmDChq25bL0k6oN7yiLivzuJdgEWZ8mLg4EKdiWk7vwPagAsi4rbN6GprUAnTuNSf+8fMrK6mDTxswLikzrIA3r+F2x8M7AkcCowH7pa0X0S8mK0kaSowFRxYmpk1kgMPq1RE/J8tWH0JsGumPD59LmsxcG9ErAMek/QoSSCSu8VwRFwOXA7JzKVb0CczM6vDgYdVStL7I+I3ko6rtTwibq2z+hxgT0l7kAQcJwAfL9T5BXAi8BNJY0lOvSzEzMwq0TKBx+mnn54rX3rppbny6NGj666fvSdNMT+kqDgnyODB+bdp0qRJdde3Xnkf8BvgQzWWBdBl4BER6yV9HridJH/jyoiYJ+lCYG5EzEiXfUDSfGAD8DcR8XxfvwgzM+uZlgk8rH+KiPPT/0/dzPVnAjMLz52XeRzAF9N/ZmZWMU8gZk1B0vaSvifpPkkdkr4rafuq+2VmZn3LgYc1ixuAZ4EPAx9JH99YaY/MzKzPteypluI8HSNGjMiVozDXQL15PIr3fVm3bl2uXJzHY+LEib3rrPXEThFxUab8NUkfq6w3ZmbWEB7xsGZxh6QTJA1K/32UJDHUzMz6kZYd8bD+QdJKXrtHy5nAtemiQcAq4OxqemZmZo3QMoHHfvvtlysXL3ktnj4plrOnWoqnUtasWZMrv/LKK12uW2vbtvkiYlTVfTAzs/K0TOBh/Z+kMSSzig7rfC4i7q6uR2Zm1tcceFhTkPQZ4AySac/vBw4B7mHL79ViZmZNxMml1izOAA4Cnkjv3zIJeLHSHpmZWZ9rmRGPU0/NT2w5ZMiQXLmYp1G8BDZ7yezatWtzy1avXp0rv/rqq3W3VTRnTu5+Yxx00EF161tNayJijSQkbRURD0vaq+pOmZlZ32qZwMP6vcWStiW5qduvJb0APFFpj8zMrM858LCmEBF/kT68QNKdwGjgtgq7ZGZmDeAcD2sakg6QdDrwNmBxRKztwTpHSnpE0gJJ59ap92FJIam9L/tsZma90zIjHnvvvXeu/MILL+TKxbk2itOgZ/M6ivNwFKdXL+Z0jBkzJlceOnRo3bY7Ojpy5QMPPBCrT9J5wPHArelTP5F0U0R8rc46bcBlwBHAYmCOpBkRMb9QbxRJ8uq9Dem8mZn1mEc8rFl8AjgoIs6PiPNJLqc9uZt1JgMLImJhOjpyAzClRr2LgG8Ca2osMzOzEjnwsGbxFJmJw4CtgCXdrLMLsChTXpw+t4mkA4BdI+KXfdFJMzPbMi1zqsX6J0n/RHKvlhXAPEm/TstHALO3cNuDgG8Dp/Sg7lRgKsCECRO2pFkzM6ujaQOPYp5EMWdjxIgRuXJxbo7i/VhGjRrVZd1ijkYxh6OY89HdvVqK27O65qb/dwA/zzx/Vw/WXQLsmimPJz9KMgrYF7gr/QzHATMkHRsRczP1iIjLgcsB2tvb80k/ZmbWZ5o28LCBISKu6nwsaSgwMS0+EhHraq+1yRxgT0l7kAQcJwAfz2x7BTA2s/27gLOLQYeZmZXHgYc1BUmHAlcBjwMCdpX0qXo3iYuI9ZI+D9wOtAFXRsQ8SRcCcyNiRsM7bmZmveLAw5rFJcAHIuIRAEkTgeuButciR8RMYGbhufO6qHton/TUzMw2W9MEHsWcjmKORnGujaLhw4fnyiNHjsyVs3kaL774Yt1129ra6i7vbY6H7+XSI0M6gw6AiHhU0pB6K5iZWetpmsDDBrwOSVcA16blT/Ba4qmZmfUTDjysWXwW+Bxwelr+LfDP1XXHzMwawYGHVS6d+vyBiNibZN4NMzPrp5om8CjmTRTzLAYN6t0kq8WckOz2izkYW221Va48eHD+bSn2pdjX4jwf3c3jMXt2fl6s7Gsrbmsg3OclIjakN3qbEBFPVt0fMzNrnKYJPGzAG0Myc+lsYHXnkxFxbHVdMjOzvubAw5rFV6vugJmZNZ4DD6uUpGEkiaVvBh4EpkXE+vprmZlZq2qawKOv57aYOzd/JWb2Xi/FnI3u8kmKeRfdlbvLRynmn9TLCZk1a1av2p48eXLdtpvQVcA6kqtYjgL2Ac6otEdmZtYwTRN42IC1T0TsByBpGlt4R1ozM2tuDjysapumqE3vvVJlX2xLlPHZdTODsZk1PwceVrX9Jb2UPhYwPC0LiIjYprqumZlZX+u3gUd7e3uufO+99/Z43e7mFOluno9ijkexL/UU7+tSzP/o7j4xrSYi2rqvZWZm/UXvZuUyazKSjkwnH1sg6dway78oab6kP0j6D0m7VdFPMzNLOPCwlpVOtX4Zr10Nc6KkfQrVfg+0R8TbgJuBfyy3l2ZmluXAw1rZZGBBRCyMiLXADcCUbIWIuDMiXk6Ls4DxJffRzMwy6uZ4FOfC6E2uQrNZt27TxROsWbMmt2zYsGF11x0+fHiuPHTo0Fy5L++nUpzPpKOjI1cuzgEywO0CLMqUFwMH16n/aeBXDe2RmZnV1W+TS82yJJ0EtAPv62L5VGAqwIQJE0rsmZltNl/C3ZJ8qsVa2RJg10x5fPpcjqTDgb8Djo2IV2ttKCIuj4j2iGjfYYcdGtJZMzNz4GGtbQ6wp6Q9JA0FTgBmZCtImgT8iCToWFZBH83MLKPuqZb+NGfE7bffvunxXnvtlVtWnC2zmNNRnJejL3M6ulNmW60mnen088DtQBtwZUTMk3QhMDciZgD/H9gauCn9nJ+MiGMr67SZ2QDnHA9raRExE5hZeO68zOPDS++UlW8gn+sfyK/dWpJPtZiZmVlp6o549Ncbdp188sm58k033ZQrjxo1KlcuTolu1rSWLoVx46ruhZlZl3yqxaw/cdBhNiCM+9Y4nln9TEPb2HHkjjx99tN9vl2fajEzM2sxjQ46GtmGAw8zMzMrTd1TLcXpu1tZvdkoi5fLbrXVVrlyf811MTMzK5tHPMzMzKw0DjzMzMysNA48zMzMrDQD5nLa0047reZjgLlz59Zdt729vSF9MjMzG2g84mFmZmalGTAjHmal8H0zzMzqcuBhZn3D07XbQOKDjM3mwIPXz9Oxpbei7+joyJU3btyYK/en+VGqJulI4LtAG3BFRFxcWL4VcDVwIPA88LGIeLzsfg4IDjoGnrLmOOrqD7CD3ZbkHA9rWZLagMuAo4B9gBMl7VOo9mnghYh4M3Ap8M1ye2nWYEuXJn+YG/mvWTnoaEke8bBWNhlYEBELASTdAEwB5mfqTAEuSB/fDHxfkiKaeW9qvVb1kW+Vw+7+4zsgLf3SUsZt3djP/ulVfX+DOPCIh7W2XYBFmfLi9LmadSJiPbAC2L6U3ll5/MfXBphGBx2NbKO7EY8BcZOSLc3paPT2rPEkTQWmpsVVkh4psfmxwHM9rt23R9e9a7tvVdl21e33vu2B/Ln33Wtvre9ca3/mu3W1wKdarJUtAXbNlMenz9Wqs1jSYGA0SZJpTkRcDlzeoH7WJWluRFQyS91Abbvq9v3aB17bVbdf9WvP8qkWa2VzgD0l7SFpKHACMKNQZwbwqfTxR4DfOL/DzKw6HvGwlhUR6yV9Hrid5HLaKyNinqQLgbkRMQOYBlwjaQGwnCQ4MTOzijjwsJYWETOBmYXnzss8XgMcX3a/eqmSUzwDvO2q2/drH3htV91+1a99E3nU2czMzMriHA8zMzMrjQMPs4pIOlLSI5IWSDq35LavlLRM0h/LbDdte1dJd0qaL2mepDNKbHuYpNmSHkjb/n9ltV3oR5uk30v6t5LbfVzSg5LulzS3zLbT9reVdLOkhyU9JOkdJbW7V/qaO/+9JOnMMtpO2z8r/b79UdL1koaV1Xba/hlp2/PKfN1d9senWszKl073/ihwBMnEZ3OAEyNift0V+6799wKrgKsjYt8y2sy0vROwU0TcJ2kU0AH8eRmvXcmNmUZGxCpJQ4D/As6IiFmNbrvQjy8C7cA2EXFMie0+DrRHRCVzWUi6CvhtRFyRXok2IiJeLLkPbSSX2R8cEU+U0N4uJN+zfSLiFUk/A2ZGxPRGt522vy9wA8lMz2uB24DPRsSCMtqvxSMeZtXYNN17RKwl2TFMKavxiLib5Cqf0kXE0oi4L328EniI188426i2IyJWpcUh6b9Sj74kjQc+CFxRZrtVkzQaeC/JlWZExNqyg47UYcCfygg6MgYDw9O5hEYAT5XY9luAeyPi5XT25v8Ejiux/ddx4GFWjZ5M997vSdodmATcW2KbbZLuB5YBv46I0tpOfQc4B9jYTb1GCOAOSR3pbL1l2gN4FvhJeprpCkkjS+4DJJfUX19WYxGxBPgW8CSwFFgREXeU1T7wR+A9kraXNAI4mvzEi6Vz4GFmlZC0NXALcGZEvFRWuxGxISLeTjLT7eR0KLoUko4BlkVER1ltFrw7Ig4guaPz59JTbmUZDBwA/CAiJgGrgbJzm4YCxwI3ldjmGJLRzD2AnYGRkk4qq/2IeIjkrtx3kJxmuR/YUFb7tTjwMKtGT6Z777fS/IpbgJ9GxK1V9CEd5r8TOLLEZt8FHJvmWtwAvF/StWU1nh59ExHLgJ+TnPIry2JgcWaE6WaSQKRMRwH3RcQzJbZ5OPBYRDwbEeuAW4F3ltg+ETEtIg6MiPcCL5Dkl1XGgYdZNXoy3Xu/lCZ4TgMeiohvl9z2DpK2TR8PJ0nufbis9iPiyxExPiJ2J/nMfxMRpRz9ShqZJvOSnuL4AMkwfCki4mlgkaS90qcOA0pJps44kRJPs6SeBA6RNCL97h9GktdUGklvSP+fQJLfcV2Z7Rd55lKzCnQ13XtZ7Uu6HjgUGCtpMXB+REwrqfl3AScDD6a5FgBfSWehbbSdgKvSKxsGAT+LiFIvaa3QjsDPk799DAaui4jbSu7DF4CfpsH2QuDUshpOg60jgL8sq02AiLhX0s3AfcB64PeUP4voLZK2B9YBn6soqXcTX05rZmZmpfGpFjMzMyuNAw8zMzMrjQMPMzMzK40DDzMzMyuNAw8zMzMrjQMPMzMzK40DDzMzMyuNAw8zMzMrzf8CPH+e+oPljrUAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Prediction examples from both datasets\n", "\n", "for i in [9241]:\n", " analyse_model_prediction(x_test, y_test, bayesian_model, i, run_ensemble=True)\n", " analyse_model_prediction(x_c_test, y_c_test, bayesian_model, i, run_ensemble=True)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Similar to before, the model struggles with the second number, as it is mostly covered up by the spatters. However, this time is clear to see the epistemic uncertainty in the model." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Uncertainty quantification using entropy\n", "\n", "We also again plot the distribution of distribution entropy across the different test sets below. In these plots, no consideration has been made for the epistemic uncertainty, and the conclusions are broadly similar to those for the previous model." ] }, { "cell_type": "code", "execution_count": 44, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "MNIST test set:\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Entropy plots for the MNIST dataset\n", "\n", "print('MNIST test set:')\n", "plot_entropy_distribution(bayesian_model, x_test, y_test)" ] }, { "cell_type": "code", "execution_count": 45, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Corrupted MNIST test set:\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Entropy plots for the MNIST-C dataset\n", "\n", "print('Corrupted MNIST test set:')\n", "plot_entropy_distribution(bayesian_model, x_c_test, y_c_test)" ] } ], "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.10" } }, "nbformat": 4, "nbformat_minor": 4 }