├── Bayesian CNN - Experiments ├── Effect of KL-Weight.ipynb └── bayesian_cnn_real_data.ipynb ├── Brief Introduction to Uncertainty └── Brief Introduction to Uncertainty - Medium.ipynb ├── README.md ├── Simple Fully Probabilistic Bayesian CNN └── HelloWorld_FullyProbabilistic_BayesianCNN.ipynb ├── Uncertainty in DL - Aleatoric Uncertainty └── Aleatoric Uncertainty.ipynb └── Uncertainty in DL - Epistemic Uncertainty └── Modeling Epistemic Uncertainty .ipynb /README.md: -------------------------------------------------------------------------------- 1 | # Medium_Notebooks_English 2 | 3 | This repo only contains the codes that used in the articles. 4 | 5 | ## Brief Introduction to Uncertainty 6 | https://towardsdatascience.com/uncertainty-in-deep-learning-brief-introduction-1f9a5de3ae04 7 | 8 | ## Uncertainty in DL - Aleatoric Uncertainty 9 | https://towardsdatascience.com/uncertainty-in-deep-learning-aleatoric-uncertainty-and-maximum-likelihood-estimation-c7449ee13712 10 | 11 | ## Uncertainty in DL - Epistemic Uncertainty 12 | https://towardsdatascience.com/uncertainty-in-deep-learning-epistemic-uncertainty-and-bayes-by-backprop-e6353eeadebb 13 | 14 | ## Uncertainty In Deep Learning — Bayesian CNN | TensorFlow Probability 15 | https://towardsdatascience.com/uncertainty-in-deep-learning-bayesian-cnn-tensorflow-probability-758d7482bef6 16 | -------------------------------------------------------------------------------- /Simple Fully Probabilistic Bayesian CNN/HelloWorld_FullyProbabilistic_BayesianCNN.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "f3b2807e", 6 | "metadata": { 7 | "id": "f3b2807e" 8 | }, 9 | "source": [ 10 | "# Imports" 11 | ] 12 | }, 13 | { 14 | "cell_type": "code", 15 | "execution_count": 1, 16 | "id": "mHTvZop4bz-Q", 17 | "metadata": { 18 | "colab": { 19 | "base_uri": "https://localhost:8080/" 20 | }, 21 | "id": "mHTvZop4bz-Q", 22 | "outputId": "881ee4f8-a939-49dc-a520-8d140c7eb365" 23 | }, 24 | "outputs": [ 25 | { 26 | "name": "stdout", 27 | "output_type": "stream", 28 | "text": [ 29 | "Sat Mar 12 19:50:45 2022 \n", 30 | "+-----------------------------------------------------------------------------+\n", 31 | "| NVIDIA-SMI 460.32.03 Driver Version: 460.32.03 CUDA Version: 11.2 |\n", 32 | "|-------------------------------+----------------------+----------------------+\n", 33 | "| GPU Name Persistence-M| Bus-Id Disp.A | Volatile Uncorr. ECC |\n", 34 | "| Fan Temp Perf Pwr:Usage/Cap| Memory-Usage | GPU-Util Compute M. |\n", 35 | "| | | MIG M. |\n", 36 | "|===============================+======================+======================|\n", 37 | "| 0 Tesla P100-PCIE... Off | 00000000:00:04.0 Off | 0 |\n", 38 | "| N/A 57C P0 32W / 250W | 0MiB / 16280MiB | 0% Default |\n", 39 | "| | | N/A |\n", 40 | "+-------------------------------+----------------------+----------------------+\n", 41 | " \n", 42 | "+-----------------------------------------------------------------------------+\n", 43 | "| Processes: |\n", 44 | "| GPU GI CI PID Type Process name GPU Memory |\n", 45 | "| ID ID Usage |\n", 46 | "|=============================================================================|\n", 47 | "| No running processes found |\n", 48 | "+-----------------------------------------------------------------------------+\n" 49 | ] 50 | } 51 | ], 52 | "source": [ 53 | "!nvidia-smi" 54 | ] 55 | }, 56 | { 57 | "cell_type": "code", 58 | "execution_count": 2, 59 | "id": "caed0563", 60 | "metadata": { 61 | "colab": { 62 | "base_uri": "https://localhost:8080/" 63 | }, 64 | "id": "caed0563", 65 | "outputId": "879d0bed-5b89-444c-98e6-b5fc4d821e0e" 66 | }, 67 | "outputs": [ 68 | { 69 | "data": { 70 | "text/plain": [ 71 | "('2.8.0', '0.16.0')" 72 | ] 73 | }, 74 | "execution_count": 2, 75 | "metadata": {}, 76 | "output_type": "execute_result" 77 | } 78 | ], 79 | "source": [ 80 | "import tensorflow as tf\n", 81 | "import tensorflow_datasets as tfds\n", 82 | "\n", 83 | "import tensorflow_probability as tfp\n", 84 | "\n", 85 | "tfd = tfp.distributions\n", 86 | "tfpl = tfp.layers\n", 87 | "\n", 88 | "import numpy as np\n", 89 | "import matplotlib.pyplot as plt\n", 90 | "\n", 91 | "tf.__version__, tfp.__version__" 92 | ] 93 | }, 94 | { 95 | "cell_type": "markdown", 96 | "id": "c581280d", 97 | "metadata": { 98 | "id": "c581280d" 99 | }, 100 | "source": [ 101 | "# Reparameterization Layers" 102 | ] 103 | }, 104 | { 105 | "cell_type": "code", 106 | "execution_count": 3, 107 | "id": "fef0862d", 108 | "metadata": { 109 | "id": "fef0862d" 110 | }, 111 | "outputs": [], 112 | "source": [ 113 | "# divergence_fn = lambda q, p, _: tfd.kl_divergence(q, p) / total_samples\n", 114 | "\n", 115 | "# tfpl.Convolution2DReparameterization(\n", 116 | "# input_shape = (128,6), \n", 117 | "# filters = 8, \n", 118 | "# kernel_size = 16,\n", 119 | "# activation = 'relu',\n", 120 | "# kernel_prior_fn = tfpl.default_multivariate_normal_fn,\n", 121 | "# kernel_posterior_fn = tfpl.default_mean_field_normal_fn(is_singular=False),\n", 122 | "# kernel_divergence_fn = divergence_fn,\n", 123 | "# bias_prior_fn = None,\n", 124 | "# bias_posterior_fn = tfpl.default_mean_field_normal_fn(is_singular=True),\n", 125 | "# bias_divergence_fn = divergence_fn)" 126 | ] 127 | }, 128 | { 129 | "cell_type": "markdown", 130 | "id": "p3-wVAnR7jDT", 131 | "metadata": { 132 | "id": "p3-wVAnR7jDT" 133 | }, 134 | "source": [ 135 | "## Load MNIST Data" 136 | ] 137 | }, 138 | { 139 | "cell_type": "code", 140 | "execution_count": 4, 141 | "id": "ae0bde05", 142 | "metadata": { 143 | "colab": { 144 | "base_uri": "https://localhost:8080/" 145 | }, 146 | "id": "ae0bde05", 147 | "outputId": "bc83c949-f1bc-4785-a450-e3b9441a36a3" 148 | }, 149 | "outputs": [ 150 | { 151 | "data": { 152 | "text/plain": [ 153 | "(TensorSpec(shape=(None, 28, 28, 1), dtype=tf.float32, name=None),\n", 154 | " TensorSpec(shape=(None, 10), dtype=tf.float32, name=None))" 155 | ] 156 | }, 157 | "execution_count": 4, 158 | "metadata": {}, 159 | "output_type": "execute_result" 160 | } 161 | ], 162 | "source": [ 163 | "train_ds, test_ds = tfds.load('mnist',\n", 164 | " split = ['train', 'test'],\n", 165 | " as_supervised = True)\n", 166 | "\n", 167 | "# Normalize and one-hot\n", 168 | "def ohe_normalize(images, labels):\n", 169 | " images = tf.cast(images, tf.float32)\n", 170 | " images = tf.divide(images, 255.0)\n", 171 | "\n", 172 | " labels = tf.one_hot(labels, 10)\n", 173 | "\n", 174 | " return images, labels\n", 175 | "\n", 176 | "train_ds = train_ds.batch(128).map(ohe_normalize).shuffle(128) \\\n", 177 | " .prefetch(tf.data.AUTOTUNE)\n", 178 | "test_ds = test_ds.batch(128).map(ohe_normalize) \\\n", 179 | " .prefetch(tf.data.AUTOTUNE)\n", 180 | "\n", 181 | "# Outputs a tuple of two elements, first --> Images, second --> Labels\n", 182 | "train_ds.element_spec " 183 | ] 184 | }, 185 | { 186 | "cell_type": "markdown", 187 | "id": "y70CWoDN9D9L", 188 | "metadata": { 189 | "id": "y70CWoDN9D9L" 190 | }, 191 | "source": [ 192 | "## First Normal CNN" 193 | ] 194 | }, 195 | { 196 | "cell_type": "code", 197 | "execution_count": null, 198 | "id": "89255ad4", 199 | "metadata": { 200 | "colab": { 201 | "base_uri": "https://localhost:8080/" 202 | }, 203 | "id": "89255ad4", 204 | "outputId": "b85b32d5-fcbb-4848-8227-cf7e83b9dbe5" 205 | }, 206 | "outputs": [], 207 | "source": [ 208 | "normal_cnn = tf.keras.Sequential([\n", 209 | " tf.keras.layers.Conv2D(16, 3, activation = 'swish', \n", 210 | " input_shape = (28, 28, 1),\n", 211 | " padding = 'same'),\n", 212 | " tf.keras.layers.MaxPooling2D(2),\n", 213 | " \n", 214 | " tf.keras.layers.Conv2D(32, 3, activation = 'swish',\n", 215 | " padding = 'same'),\n", 216 | " tf.keras.layers.MaxPooling2D(2),\n", 217 | "\n", 218 | " tf.keras.layers.Conv2D(64, 3, activation = 'swish',\n", 219 | " padding = 'same'),\n", 220 | " tf.keras.layers.MaxPooling2D(2),\n", 221 | "\n", 222 | " tf.keras.layers.Conv2D(128, 3, activation = 'swish',\n", 223 | " padding = 'same'),\n", 224 | " tf.keras.layers.GlobalMaxPooling2D(),\n", 225 | " \n", 226 | " tf.keras.layers.Dense(10, activation = 'softmax')\n", 227 | "])\n", 228 | "\n", 229 | "normal_cnn.compile(optimizer = 'adam', loss = 'categorical_crossentropy',\n", 230 | " metrics = ['acc'])\n", 231 | "\n", 232 | "normal_cnn.summary() # Total params: 98,442" 233 | ] 234 | }, 235 | { 236 | "cell_type": "markdown", 237 | "id": "PVg7Wctu-DhJ", 238 | "metadata": { 239 | "id": "PVg7Wctu-DhJ" 240 | }, 241 | "source": [ 242 | "## Bayesian CNN" 243 | ] 244 | }, 245 | { 246 | "cell_type": "code", 247 | "execution_count": 6, 248 | "id": "2AyekIbf4D-c", 249 | "metadata": { 250 | "colab": { 251 | "base_uri": "https://localhost:8080/" 252 | }, 253 | "id": "2AyekIbf4D-c", 254 | "outputId": "44be2a02-f616-4b28-bb16-822b24dc9493" 255 | }, 256 | "outputs": [ 257 | { 258 | "name": "stdout", 259 | "output_type": "stream", 260 | "text": [ 261 | "reinterpreted_batch_ndims: 0:\n", 262 | "batch_shape: (4,) event_shape: () Sample shape: (4,)\n", 263 | "Samples: [-1.4488162 0.28503537 -2.6792827 1.6637591 ] \n", 264 | "\n", 265 | "reinterpreted_batch_ndims: 1:\n", 266 | "batch_shape: () event_shape: (4,) Sample shape: (4,)\n", 267 | "Samples: [-0.59052044 0.00105313 -0.59601015 0.643041 ] \n", 268 | "\n" 269 | ] 270 | } 271 | ], 272 | "source": [ 273 | "# Revise reinterpreted_batch_ndims arg. Needed for custom prior & posterior.\n", 274 | "shape = (4, )\n", 275 | "dtype = tf.float32\n", 276 | "distribution = tfd.Normal(loc = tf.zeros(shape, dtype),\n", 277 | " scale = tf.ones(shape, dtype))\n", 278 | "# batch_ndims = tf.size(distribution.batch_shape_tensor())\n", 279 | "\n", 280 | "for i in range(len(shape) + 1):\n", 281 | " print('reinterpreted_batch_ndims: %d:' %(i))\n", 282 | " independent_dist = tfd.Independent(distribution,\n", 283 | " reinterpreted_batch_ndims = i)\n", 284 | " samples = independent_dist.sample()\n", 285 | " print('batch_shape: {}' \n", 286 | " ' event_shape: {}' \n", 287 | " ' Sample shape: {}'.format(independent_dist._batch_shape(),\n", 288 | " independent_dist._event_shape(),\n", 289 | " samples.shape))\n", 290 | " print('Samples:', samples.numpy(), '\\n')" 291 | ] 292 | }, 293 | { 294 | "cell_type": "markdown", 295 | "id": "zMF0aS_rsVfW", 296 | "metadata": { 297 | "id": "zMF0aS_rsVfW" 298 | }, 299 | "source": [ 300 | "### How to Provide Custom Prior?" 301 | ] 302 | }, 303 | { 304 | "cell_type": "code", 305 | "execution_count": 7, 306 | "id": "e3631cc2", 307 | "metadata": { 308 | "id": "e3631cc2" 309 | }, 310 | "outputs": [], 311 | "source": [ 312 | "# For Reparameterization Layers\n", 313 | "def custom_mvn_prior(dtype, shape, name, trainable, add_variable_fn):\n", 314 | " distribution = tfd.Normal(loc = 0.1 * tf.ones(shape, dtype),\n", 315 | " scale = 0.003 * tf.ones(shape, dtype))\n", 316 | " batch_ndims = tf.size(distribution.batch_shape_tensor())\n", 317 | " \n", 318 | " independent_distribution = tfd.Independent(distribution,\n", 319 | " reinterpreted_batch_ndims = batch_ndims)\n", 320 | " return independent_distribution" 321 | ] 322 | }, 323 | { 324 | "cell_type": "markdown", 325 | "id": "wxFvgCGhsaXn", 326 | "metadata": { 327 | "id": "wxFvgCGhsaXn" 328 | }, 329 | "source": [ 330 | "### What if KL cannot be Computed Analytically?" 331 | ] 332 | }, 333 | { 334 | "cell_type": "code", 335 | "execution_count": 8, 336 | "id": "PG-aAU7WFdmT", 337 | "metadata": { 338 | "id": "PG-aAU7WFdmT" 339 | }, 340 | "outputs": [], 341 | "source": [ 342 | "# The default posterior is Normal and if we use a laplace prior, we need to\n", 343 | "# approximate the KL. If we try to compute KL with that 2 distributions, we will get:\n", 344 | "# Error:\n", 345 | "# No KL(distribution_a || distribution_b) registered for distribution_a type Normal and distribution_b type Laplace\n", 346 | "\n", 347 | "# Call arguments received:\n", 348 | "# • inputs=tf.Tensor(shape=(None, 28, 28, 1), dtype=float32)\n", 349 | "\n", 350 | "def approximate_kl(q, p, q_tensor):\n", 351 | " return tf.reduce_mean(q.log_prob(q_tensor) - p.log_prob(q_tensor))\n", 352 | "\n", 353 | "total_samples = 60000\n", 354 | "divergence_fn = lambda q, p, q_tensor : approximate_kl(q, p, q_tensor) / total_samples" 355 | ] 356 | }, 357 | { 358 | "cell_type": "code", 359 | "execution_count": 9, 360 | "id": "DoR1GIWOZ46u", 361 | "metadata": { 362 | "id": "DoR1GIWOZ46u" 363 | }, 364 | "outputs": [], 365 | "source": [ 366 | "def conv_reparameterization_layer(filters, kernel_size, activation):\n", 367 | " # For simplicity, we use default prior and posterior.\n", 368 | " # In the next parts, we will use custom mixture prior and posteriors.\n", 369 | " return tfpl.Convolution2DReparameterization(\n", 370 | " filters = filters,\n", 371 | " kernel_size = kernel_size,\n", 372 | " activation = activation, \n", 373 | " padding = 'same',\n", 374 | " kernel_posterior_fn = tfpl.default_mean_field_normal_fn(is_singular=False),\n", 375 | " kernel_prior_fn = tfpl.default_multivariate_normal_fn,\n", 376 | " \n", 377 | " bias_prior_fn = tfpl.default_multivariate_normal_fn,\n", 378 | " bias_posterior_fn = tfpl.default_mean_field_normal_fn(is_singular=False),\n", 379 | " \n", 380 | " kernel_divergence_fn = divergence_fn,\n", 381 | " bias_divergence_fn = divergence_fn)" 382 | ] 383 | }, 384 | { 385 | "cell_type": "markdown", 386 | "id": "117ed43a", 387 | "metadata": {}, 388 | "source": [ 389 | "### Create BCNN" 390 | ] 391 | }, 392 | { 393 | "cell_type": "code", 394 | "execution_count": 10, 395 | "id": "4WF_lDEcBOml", 396 | "metadata": { 397 | "colab": { 398 | "base_uri": "https://localhost:8080/" 399 | }, 400 | "id": "4WF_lDEcBOml", 401 | "outputId": "bee399a7-a51a-4efa-9cc5-866226583ab0" 402 | }, 403 | "outputs": [ 404 | { 405 | "name": "stderr", 406 | "output_type": "stream", 407 | "text": [ 408 | "/usr/local/lib/python3.7/dist-packages/tensorflow_probability/python/layers/util.py:102: UserWarning: `layer.add_variable` is deprecated and will be removed in a future version. Please use `layer.add_weight` method instead.\n", 409 | " trainable=trainable)\n", 410 | "/usr/local/lib/python3.7/dist-packages/tensorflow_probability/python/layers/util.py:112: UserWarning: `layer.add_variable` is deprecated and will be removed in a future version. Please use `layer.add_weight` method instead.\n", 411 | " trainable=trainable)\n" 412 | ] 413 | }, 414 | { 415 | "name": "stdout", 416 | "output_type": "stream", 417 | "text": [ 418 | "Model: \"sequential_1\"\n", 419 | "_________________________________________________________________\n", 420 | " Layer (type) Output Shape Param # \n", 421 | "=================================================================\n", 422 | " conv2d_reparameterization ( (None, 28, 28, 16) 320 \n", 423 | " Conv2DReparameterization) \n", 424 | " \n", 425 | " max_pooling2d_3 (MaxPooling (None, 14, 14, 16) 0 \n", 426 | " 2D) \n", 427 | " \n", 428 | " conv2d_reparameterization_1 (None, 14, 14, 32) 9280 \n", 429 | " (Conv2DReparameterization) \n", 430 | " \n", 431 | " max_pooling2d_4 (MaxPooling (None, 7, 7, 32) 0 \n", 432 | " 2D) \n", 433 | " \n", 434 | " conv2d_reparameterization_2 (None, 7, 7, 64) 36992 \n", 435 | " (Conv2DReparameterization) \n", 436 | " \n", 437 | " max_pooling2d_5 (MaxPooling (None, 3, 3, 64) 0 \n", 438 | " 2D) \n", 439 | " \n", 440 | " conv2d_reparameterization_3 (None, 3, 3, 128) 147712 \n", 441 | " (Conv2DReparameterization) \n", 442 | " \n", 443 | " global_max_pooling2d_1 (Glo (None, 128) 0 \n", 444 | " balMaxPooling2D) \n", 445 | " \n", 446 | " dense_reparameterization (D (None, 10) 2580 \n", 447 | " enseReparameterization) \n", 448 | " \n", 449 | " one_hot_categorical (OneHot ((None, 10), 0 \n", 450 | " Categorical) (None, 10)) \n", 451 | " \n", 452 | "=================================================================\n", 453 | "Total params: 196,884\n", 454 | "Trainable params: 196,884\n", 455 | "Non-trainable params: 0\n", 456 | "_________________________________________________________________\n" 457 | ] 458 | } 459 | ], 460 | "source": [ 461 | "bayesian_cnn = tf.keras.Sequential([\n", 462 | " tf.keras.layers.InputLayer((28, 28, 1)),\n", 463 | " \n", 464 | " conv_reparameterization_layer(16, 3, 'swish'),\n", 465 | " tf.keras.layers.MaxPooling2D(2),\n", 466 | " \n", 467 | " conv_reparameterization_layer(32, 3, 'swish'),\n", 468 | " tf.keras.layers.MaxPooling2D(2),\n", 469 | "\n", 470 | " conv_reparameterization_layer(64, 3, 'swish'),\n", 471 | " tf.keras.layers.MaxPooling2D(2),\n", 472 | "\n", 473 | " conv_reparameterization_layer(128, 3, 'swish'),\n", 474 | " tf.keras.layers.GlobalMaxPooling2D(),\n", 475 | " \n", 476 | " tfpl.DenseReparameterization(\n", 477 | " units = tfpl.OneHotCategorical.params_size(10), activation = None,\n", 478 | " kernel_posterior_fn = tfpl.default_mean_field_normal_fn(is_singular=False),\n", 479 | " kernel_prior_fn = tfpl.default_multivariate_normal_fn,\n", 480 | " \n", 481 | " bias_prior_fn = tfpl.default_multivariate_normal_fn,\n", 482 | " bias_posterior_fn = tfpl.default_mean_field_normal_fn(is_singular=False),\n", 483 | " \n", 484 | " kernel_divergence_fn = divergence_fn,\n", 485 | " bias_divergence_fn = divergence_fn),\n", 486 | " tfpl.OneHotCategorical(10)\n", 487 | "])\n", 488 | "\n", 489 | "def nll(y_true, y_pred):\n", 490 | " return -y_pred.log_prob(y_true)\n", 491 | "\n", 492 | "bayesian_cnn.compile(loss=nll,\n", 493 | " optimizer=tf.keras.optimizers.Adam(0.001),\n", 494 | " metrics=['accuracy'])\n", 495 | "\n", 496 | "bayesian_cnn.summary()" 497 | ] 498 | }, 499 | { 500 | "cell_type": "code", 501 | "execution_count": 11, 502 | "id": "wagyyldNFJD_", 503 | "metadata": { 504 | "colab": { 505 | "base_uri": "https://localhost:8080/" 506 | }, 507 | "id": "wagyyldNFJD_", 508 | "outputId": "2b342338-4686-4af6-9976-0213e87ceac1" 509 | }, 510 | "outputs": [ 511 | { 512 | "name": "stdout", 513 | "output_type": "stream", 514 | "text": [ 515 | "Epoch 1/12\n", 516 | "469/469 [==============================] - 17s 18ms/step - loss: 4.7674 - accuracy: 0.6792 - val_loss: 4.1597 - val_accuracy: 0.9095\n", 517 | "Epoch 2/12\n", 518 | "469/469 [==============================] - 5s 11ms/step - loss: 4.0503 - accuracy: 0.9244 - val_loss: 3.9239 - val_accuracy: 0.9428\n", 519 | "Epoch 3/12\n", 520 | "469/469 [==============================] - 5s 11ms/step - loss: 3.8208 - accuracy: 0.9484 - val_loss: 3.7356 - val_accuracy: 0.9456\n", 521 | "Epoch 4/12\n", 522 | "469/469 [==============================] - 5s 11ms/step - loss: 3.6138 - accuracy: 0.9596 - val_loss: 3.5012 - val_accuracy: 0.9679\n", 523 | "Epoch 5/12\n", 524 | "469/469 [==============================] - 5s 11ms/step - loss: 3.4163 - accuracy: 0.9673 - val_loss: 3.3117 - val_accuracy: 0.9726\n", 525 | "Epoch 6/12\n", 526 | "469/469 [==============================] - 5s 11ms/step - loss: 3.2263 - accuracy: 0.9712 - val_loss: 3.1341 - val_accuracy: 0.9744\n", 527 | "Epoch 7/12\n", 528 | "469/469 [==============================] - 5s 11ms/step - loss: 3.0467 - accuracy: 0.9740 - val_loss: 2.9602 - val_accuracy: 0.9758\n", 529 | "Epoch 8/12\n", 530 | "469/469 [==============================] - 5s 11ms/step - loss: 2.8846 - accuracy: 0.9754 - val_loss: 2.8000 - val_accuracy: 0.9793\n", 531 | "Epoch 9/12\n", 532 | "469/469 [==============================] - 6s 12ms/step - loss: 2.7258 - accuracy: 0.9773 - val_loss: 2.6527 - val_accuracy: 0.9770\n", 533 | "Epoch 10/12\n", 534 | "469/469 [==============================] - 5s 11ms/step - loss: 2.5832 - accuracy: 0.9777 - val_loss: 2.5219 - val_accuracy: 0.9793\n", 535 | "Epoch 11/12\n", 536 | "469/469 [==============================] - 5s 11ms/step - loss: 2.4495 - accuracy: 0.9786 - val_loss: 2.3883 - val_accuracy: 0.9798\n", 537 | "Epoch 12/12\n", 538 | "469/469 [==============================] - 5s 11ms/step - loss: 2.3281 - accuracy: 0.9791 - val_loss: 2.2741 - val_accuracy: 0.9795\n" 539 | ] 540 | }, 541 | { 542 | "data": { 543 | "text/plain": [ 544 | "" 545 | ] 546 | }, 547 | "execution_count": 11, 548 | "metadata": {}, 549 | "output_type": "execute_result" 550 | } 551 | ], 552 | "source": [ 553 | "bayesian_cnn.fit(train_ds, epochs = 12, validation_data = test_ds)" 554 | ] 555 | }, 556 | { 557 | "cell_type": "code", 558 | "execution_count": 12, 559 | "id": "-B_y_YNFcLMQ", 560 | "metadata": { 561 | "id": "-B_y_YNFcLMQ" 562 | }, 563 | "outputs": [], 564 | "source": [ 565 | "example_images = []\n", 566 | "example_labels = []\n", 567 | "\n", 568 | "for x, y in test_ds.take(10):\n", 569 | " example_images.append(x.numpy())\n", 570 | " example_labels.append(y.numpy())\n", 571 | "\n", 572 | "example_images = np.concatenate(example_images, axis = 0) \n", 573 | "example_labels = np.concatenate(example_labels, axis = 0) " 574 | ] 575 | }, 576 | { 577 | "cell_type": "code", 578 | "execution_count": 13, 579 | "id": "rgVSJidtGdVu", 580 | "metadata": { 581 | "id": "rgVSJidtGdVu" 582 | }, 583 | "outputs": [], 584 | "source": [ 585 | "def analyse_model_prediction(image, label = None, forward_passes = 10):\n", 586 | " if label is not None:\n", 587 | " label = np.argmax(label, axis = -1)\n", 588 | " \n", 589 | " extracted_probabilities = np.empty(shape=(forward_passes, 10))\n", 590 | " extracted_std = np.empty(shape=(forward_passes, 10))\n", 591 | " for i in range(forward_passes):\n", 592 | " model_output_distribution = bayesian_cnn(tf.expand_dims(image, \n", 593 | " axis = 0))\n", 594 | " extracted_probabilities[i] = model_output_distribution.mean().numpy().flatten()\n", 595 | " extracted_std[i] = model_output_distribution.stddev().numpy().flatten()\n", 596 | "\n", 597 | " fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2, figsize=(16, 6),\n", 598 | " gridspec_kw={'width_ratios': [2, 4]})\n", 599 | " plt.xticks(fontsize = 16, rotation = 45)\n", 600 | " plt.yticks(fontsize = 16)\n", 601 | "\n", 602 | " # Show the image and the true label if provided.\n", 603 | " ax1.imshow(image.squeeze(), cmap='gray')\n", 604 | " ax1.axis('off')\n", 605 | " if label is not None:\n", 606 | " ax1.set_title('True Label: {}'.format(str(label)), fontsize = 20)\n", 607 | " else:\n", 608 | " ax1.set_title('True Label Not Given', fontsize = 20)\n", 609 | " \n", 610 | " # Obtain the 95% prediction interval.\n", 611 | " # extracted_probabilities.shape = (forward_passes, 10)\n", 612 | " # So if we sample from the model 100 times, there will be 100 different\n", 613 | " # values for each of the 10 classes. \n", 614 | " # We get the interval for each of the classes independently.\n", 615 | " pct_2p5 = np.array([np.percentile(extracted_probabilities[:, i], \n", 616 | " 2.5) for i in range(10)])\n", 617 | " pct_97p5 = np.array([np.percentile(extracted_probabilities[:, i], \n", 618 | " 97.5) for i in range(10)]) \n", 619 | "\n", 620 | " # Std also contains 100 different values. We take median across the column\n", 621 | " # to obtain a single value for each of the class label.\n", 622 | " extracted_std = np.median(extracted_std, axis = 0)\n", 623 | " highest_var_label = np.argmax(extracted_std, axis = -1)\n", 624 | " if label is not None:\n", 625 | " print('Label %d has the highest std in this'\n", 626 | " ' prediction with the value %.3f' %(highest_var_label,\n", 627 | " extracted_std[highest_var_label]))\n", 628 | " else:\n", 629 | " print('Std Array:', extracted_std) \n", 630 | " \n", 631 | " bar = ax2.bar(np.arange(10), pct_97p5, color='red')\n", 632 | " if label is not None:\n", 633 | " bar[int(label)].set_color('green')\n", 634 | " \n", 635 | " ax2.bar(np.arange(10), pct_2p5-0.02, color='white', \n", 636 | " linewidth=4, edgecolor='white')\n", 637 | " ax2.set_xticks(np.arange(10))\n", 638 | " \n", 639 | " ax2.set_ylim([0, 1])\n", 640 | " ax2.set_ylabel('Probability', fontsize = 18)\n", 641 | " ax2.set_title(\"Model's Probabilities\", fontsize = 20)\n", 642 | " plt.show()" 643 | ] 644 | }, 645 | { 646 | "cell_type": "code", 647 | "execution_count": 18, 648 | "id": "ADKmTDUQsL55", 649 | "metadata": { 650 | "colab": { 651 | "base_uri": "https://localhost:8080/", 652 | "height": 420 653 | }, 654 | "id": "ADKmTDUQsL55", 655 | "outputId": "2cdf0bb3-4384-4c46-a10b-0cb21900b935" 656 | }, 657 | "outputs": [ 658 | { 659 | "name": "stdout", 660 | "output_type": "stream", 661 | "text": [ 662 | "Label 8 has the highest std in this prediction with the value 0.157\n" 663 | ] 664 | }, 665 | { 666 | "data": { 667 | "image/png": "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\n", 668 | "text/plain": [ 669 | "
" 670 | ] 671 | }, 672 | "metadata": { 673 | "needs_background": "light" 674 | }, 675 | "output_type": "display_data" 676 | } 677 | ], 678 | "source": [ 679 | "analyse_model_prediction(example_images[284], example_labels[284])" 680 | ] 681 | }, 682 | { 683 | "cell_type": "code", 684 | "execution_count": 14, 685 | "id": "lDnT6Koxc2vE", 686 | "metadata": { 687 | "colab": { 688 | "base_uri": "https://localhost:8080/", 689 | "height": 420 690 | }, 691 | "id": "lDnT6Koxc2vE", 692 | "outputId": "f5b61032-98e2-4733-996f-6944c2e721fa" 693 | }, 694 | "outputs": [ 695 | { 696 | "name": "stdout", 697 | "output_type": "stream", 698 | "text": [ 699 | "Label 0 has the highest std in this prediction with the value 0.001\n" 700 | ] 701 | }, 702 | { 703 | "data": { 704 | "image/png": "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\n", 705 | "text/plain": [ 706 | "
" 707 | ] 708 | }, 709 | "metadata": { 710 | "needs_background": "light" 711 | }, 712 | "output_type": "display_data" 713 | } 714 | ], 715 | "source": [ 716 | "analyse_model_prediction(example_images[50], example_labels[50])" 717 | ] 718 | }, 719 | { 720 | "cell_type": "code", 721 | "execution_count": 15, 722 | "id": "o2J1vKp2c-io", 723 | "metadata": { 724 | "colab": { 725 | "base_uri": "https://localhost:8080/", 726 | "height": 420 727 | }, 728 | "id": "o2J1vKp2c-io", 729 | "outputId": "d5fe9a66-3880-468b-fbd2-82bddbea559c" 730 | }, 731 | "outputs": [ 732 | { 733 | "name": "stdout", 734 | "output_type": "stream", 735 | "text": [ 736 | "Label 0 has the highest std in this prediction with the value 0.278\n" 737 | ] 738 | }, 739 | { 740 | "data": { 741 | "image/png": "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\n", 742 | "text/plain": [ 743 | "
" 744 | ] 745 | }, 746 | "metadata": { 747 | "needs_background": "light" 748 | }, 749 | "output_type": "display_data" 750 | } 751 | ], 752 | "source": [ 753 | "noise_vector = np.random.uniform(size = (28, 28, 1), low = 0, high = 0.5)\n", 754 | "noisy_image = np.clip(example_images[50] + noise_vector, 0, 1)\n", 755 | "analyse_model_prediction(noisy_image, example_labels[50])" 756 | ] 757 | }, 758 | { 759 | "cell_type": "code", 760 | "execution_count": 16, 761 | "id": "4wtcYDJmoXYN", 762 | "metadata": { 763 | "colab": { 764 | "base_uri": "https://localhost:8080/", 765 | "height": 420 766 | }, 767 | "id": "4wtcYDJmoXYN", 768 | "outputId": "88ec4ab7-1b15-4e6f-fbb5-9f560e401e64" 769 | }, 770 | "outputs": [ 771 | { 772 | "name": "stdout", 773 | "output_type": "stream", 774 | "text": [ 775 | "Label 0 has the highest std in this prediction with the value 0.434\n" 776 | ] 777 | }, 778 | { 779 | "data": { 780 | "image/png": "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\n", 781 | "text/plain": [ 782 | "
" 783 | ] 784 | }, 785 | "metadata": { 786 | "needs_background": "light" 787 | }, 788 | "output_type": "display_data" 789 | } 790 | ], 791 | "source": [ 792 | "noise_vector = np.random.uniform(size = (28, 28, 1), low = 0, high = 0.5)\n", 793 | "noisy_image = np.clip(example_images[50] + noise_vector*2, 0, 1)\n", 794 | "analyse_model_prediction(noisy_image, example_labels[50])" 795 | ] 796 | }, 797 | { 798 | "cell_type": "code", 799 | "execution_count": 17, 800 | "id": "cKDgiPHZotP1", 801 | "metadata": { 802 | "colab": { 803 | "base_uri": "https://localhost:8080/", 804 | "height": 438 805 | }, 806 | "id": "cKDgiPHZotP1", 807 | "outputId": "42e4fad2-9e9b-418e-d5a7-1227f391bc80" 808 | }, 809 | "outputs": [ 810 | { 811 | "name": "stdout", 812 | "output_type": "stream", 813 | "text": [ 814 | "Std Array: [0.27027504 0.22355586 0.19433676 0.08276099 0.1712302 0.14369398\n", 815 | " 0.31018993 0.13080781 0.47434729 0.18379491]\n" 816 | ] 817 | }, 818 | { 819 | "data": { 820 | "image/png": "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\n", 821 | "text/plain": [ 822 | "
" 823 | ] 824 | }, 825 | "metadata": { 826 | "needs_background": "light" 827 | }, 828 | "output_type": "display_data" 829 | } 830 | ], 831 | "source": [ 832 | "analyse_model_prediction(np.random.uniform(size = (28, 28, 1), low = 0, \n", 833 | " high = 1))" 834 | ] 835 | }, 836 | { 837 | "cell_type": "code", 838 | "execution_count": 17, 839 | "id": "PJHtwIOAoyAW", 840 | "metadata": { 841 | "id": "PJHtwIOAoyAW" 842 | }, 843 | "outputs": [], 844 | "source": [] 845 | } 846 | ], 847 | "metadata": { 848 | "accelerator": "GPU", 849 | "colab": { 850 | "collapsed_sections": [], 851 | "machine_shape": "hm", 852 | "name": "Bayesian CNN.ipynb", 853 | "provenance": [] 854 | }, 855 | "kernelspec": { 856 | "display_name": "Python 3", 857 | "language": "python", 858 | "name": "python3" 859 | }, 860 | "language_info": { 861 | "codemirror_mode": { 862 | "name": "ipython", 863 | "version": 3 864 | }, 865 | "file_extension": ".py", 866 | "mimetype": "text/x-python", 867 | "name": "python", 868 | "nbconvert_exporter": "python", 869 | "pygments_lexer": "ipython3", 870 | "version": "3.8.8" 871 | } 872 | }, 873 | "nbformat": 4, 874 | "nbformat_minor": 5 875 | } 876 | --------------------------------------------------------------------------------