notebooks/example-image-augmentation.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from jenga.tasks.shoes import ShoeCategorizationTask\n",
    "from jenga.corruptions.image import GaussianNoiseCorruption, MotionBlurCorruption, FogCorruption, BrightnessCorruption\n",
    "\n",
    "from jenga.evaluation.corruption_impact import CorruptionImpactEvaluator\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import imgaug.augmenters as iaa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Instantiate the shoe categorization task and train a baseline model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:AutoGraph could not transform <function Model.make_train_function.<locals>.train_function at 0x7f95f8ca3050> and will run it as-is.\n",
      "Please report this to the TensorFlow team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output.\n",
      "Cause: 'arguments' object has no attribute 'posonlyargs'\n",
      "To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert\n",
      "WARNING: AutoGraph could not transform <function Model.make_train_function.<locals>.train_function at 0x7f95f8ca3050> and will run it as-is.\n",
      "Please report this to the TensorFlow team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output.\n",
      "Cause: 'arguments' object has no attribute 'posonlyargs'\n",
      "To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert\n",
      "375/375 [==============================] - 8s 21ms/step - loss: 0.1645 - accuracy: 0.9371\n"
     ]
    }
   ],
   "source": [
    "task = ShoeCategorizationTask(seed=42)\n",
    "\n",
    "baseline_model = task.fit_baseline_model()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train another model on data augmented with gaussian noise corruptions "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:AutoGraph could not transform <function Model.make_train_function.<locals>.train_function at 0x7f95e7a42950> and will run it as-is.\n",
      "Please report this to the TensorFlow team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output.\n",
      "Cause: 'arguments' object has no attribute 'posonlyargs'\n",
      "To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert\n",
      "WARNING: AutoGraph could not transform <function Model.make_train_function.<locals>.train_function at 0x7f95e7a42950> and will run it as-is.\n",
      "Please report this to the TensorFlow team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output.\n",
      "Cause: 'arguments' object has no attribute 'posonlyargs'\n",
      "To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert\n",
      "750/750 [==============================] - 15s 20ms/step - loss: 0.1758 - accuracy: 0.9317\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "augmented_data = [task.train_data]\n",
    "augmented_labels= [task.train_labels]\n",
    "\n",
    "for severity in range(1, 6):\n",
    "    indexes = np.random.choice(range(0, len(task.train_data)), 2400)\n",
    "    sample = task.train_data[indexes, :, :].copy()\n",
    "    corrupted_sample = GaussianNoiseCorruption(fraction=1.0, severity=severity).transform(sample)\n",
    "    augmented_data.append(corrupted_sample)\n",
    "    augmented_labels.append(task.train_labels[indexes].copy())\n",
    "\n",
    "gaussian_noise_model = task.fit_baseline_model(np.concatenate(augmented_data), np.concatenate(augmented_labels))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Evaluate how well both models can handle corrupted test data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:AutoGraph could not transform <function Model.make_predict_function.<locals>.predict_function at 0x7f95e871fa70> and will run it as-is.\n",
      "Please report this to the TensorFlow team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output.\n",
      "Cause: 'arguments' object has no attribute 'posonlyargs'\n",
      "To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert\n",
      "WARNING: AutoGraph could not transform <function Model.make_predict_function.<locals>.predict_function at 0x7f95e871fa70> and will run it as-is.\n",
      "Please report this to the TensorFlow team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output.\n",
      "Cause: 'arguments' object has no attribute 'posonlyargs'\n",
      "To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert\n",
      "0/70 (2.4312520000000006)\n",
      "10/70 (25.508697000000012)\n",
      "20/70 (48.24758)\n",
      "30/70 (72.18926200000001)\n",
      "40/70 (97.60440900000003)\n",
      "50/70 (123.90635500000002)\n",
      "60/70 (153.481381)\n",
      "WARNING:tensorflow:AutoGraph could not transform <function Model.make_predict_function.<locals>.predict_function at 0x7f95e871f320> and will run it as-is.\n",
      "Please report this to the TensorFlow team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output.\n",
      "Cause: 'arguments' object has no attribute 'posonlyargs'\n",
      "To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert\n",
      "WARNING: AutoGraph could not transform <function Model.make_predict_function.<locals>.predict_function at 0x7f95e871f320> and will run it as-is.\n",
      "Please report this to the TensorFlow team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output.\n",
      "Cause: 'arguments' object has no attribute 'posonlyargs'\n",
      "To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert\n",
      "0/70 (2.2302119999999945)\n",
      "10/70 (24.656284000000028)\n",
      "20/70 (47.887857999999994)\n",
      "30/70 (72.486783)\n",
      "40/70 (98.45609400000001)\n",
      "50/70 (126.53835100000003)\n",
      "60/70 (156.10243100000002)\n"
     ]
    }
   ],
   "source": [
    "evaluator = CorruptionImpactEvaluator(task)\n",
    "\n",
    "corruptions  = []\n",
    "for fraction in [0.01, 0.05, 0.1, 0.25, 0.5, 0.75, 0.99]:\n",
    "    corruptions.append(GaussianNoiseCorruption(fraction=fraction, severity=4))\n",
    "    \n",
    "gaussian_noise_results = evaluator.evaluate(baseline_model, 10, *corruptions)        \n",
    "gaussian_noise_results_aug = evaluator.evaluate(gaussian_noise_model, 10, *corruptions)    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train another model on data augmented with motion blur corruptions "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:AutoGraph could not transform <function Model.make_train_function.<locals>.train_function at 0x7f95e8d92050> and will run it as-is.\n",
      "Please report this to the TensorFlow team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output.\n",
      "Cause: 'arguments' object has no attribute 'posonlyargs'\n",
      "To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert\n",
      "WARNING: AutoGraph could not transform <function Model.make_train_function.<locals>.train_function at 0x7f95e8d92050> and will run it as-is.\n",
      "Please report this to the TensorFlow team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output.\n",
      "Cause: 'arguments' object has no attribute 'posonlyargs'\n",
      "To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert\n",
      "750/750 [==============================] - 14s 19ms/step - loss: 0.1918 - accuracy: 0.9235\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "augmented_data = [task.train_data]\n",
    "augmented_labels= [task.train_labels]\n",
    "\n",
    "for severity in range(1, 6):\n",
    "    indexes = np.random.choice(range(0, len(task.train_data)), 2400)\n",
    "    sample = task.train_data[indexes, :, :].copy()\n",
    "    corrupted_sample = MotionBlurCorruption(fraction=1.0, severity=severity).transform(sample)\n",
    "    augmented_data.append(corrupted_sample)\n",
    "    augmented_labels.append(task.train_labels[indexes].copy())\n",
    "\n",
    "motion_blur_model = task.fit_baseline_model(np.concatenate(augmented_data), np.concatenate(augmented_labels))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Evaluate how well both models can handle corrupted test data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0/70 (2.341199999999958)\n",
      "10/70 (25.791493999999943)\n",
      "20/70 (50.48958399999992)\n",
      "30/70 (77.47340499999996)\n",
      "40/70 (110.57398899999998)\n",
      "50/70 (155.77286800000002)\n",
      "60/70 (209.93377999999996)\n",
      "WARNING:tensorflow:AutoGraph could not transform <function Model.make_predict_function.<locals>.predict_function at 0x7f95dc2fdc20> and will run it as-is.\n",
      "Please report this to the TensorFlow team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output.\n",
      "Cause: 'arguments' object has no attribute 'posonlyargs'\n",
      "To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert\n",
      "WARNING: AutoGraph could not transform <function Model.make_predict_function.<locals>.predict_function at 0x7f95dc2fdc20> and will run it as-is.\n",
      "Please report this to the TensorFlow team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output.\n",
      "Cause: 'arguments' object has no attribute 'posonlyargs'\n",
      "To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert\n",
      "0/70 (2.2907430000000204)\n",
      "10/70 (25.817749999999933)\n",
      "20/70 (50.94627600000001)\n",
      "30/70 (78.43648799999994)\n",
      "40/70 (112.28239000000008)\n",
      "50/70 (155.99658799999997)\n",
      "60/70 (209.01210100000003)\n"
     ]
    }
   ],
   "source": [
    "evaluator = CorruptionImpactEvaluator(task)\n",
    "\n",
    "corruptions  = []\n",
    "for fraction in [0.01, 0.05, 0.1, 0.25, 0.5, 0.75, 0.99]:\n",
    "    corruptions.append(MotionBlurCorruption(fraction=fraction, severity=4))\n",
    "    \n",
    "motion_blur_results = evaluator.evaluate(baseline_model, 10, *corruptions)        \n",
    "motion_blur_results_aug = evaluator.evaluate(motion_blur_model, 10, *corruptions)    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train another model on data augmented with fog corruptions "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:AutoGraph could not transform <function Model.make_train_function.<locals>.train_function at 0x7f95dc408050> and will run it as-is.\n",
      "Please report this to the TensorFlow team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output.\n",
      "Cause: 'arguments' object has no attribute 'posonlyargs'\n",
      "To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert\n",
      "WARNING: AutoGraph could not transform <function Model.make_train_function.<locals>.train_function at 0x7f95dc408050> and will run it as-is.\n",
      "Please report this to the TensorFlow team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output.\n",
      "Cause: 'arguments' object has no attribute 'posonlyargs'\n",
      "To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert\n",
      "750/750 [==============================] - 16s 21ms/step - loss: 0.2099 - accuracy: 0.9189\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "augmented_data = [task.train_data]\n",
    "augmented_labels= [task.train_labels]\n",
    "\n",
    "for severity in range(1, 6):\n",
    "    indexes = np.random.choice(range(0, len(task.train_data)), 2400)\n",
    "    sample = task.train_data[indexes, :, :].copy()\n",
    "    corrupted_sample = FogCorruption(fraction=1.0, severity=severity).transform(sample)\n",
    "    augmented_data.append(corrupted_sample)\n",
    "    augmented_labels.append(task.train_labels[indexes].copy())\n",
    "\n",
    "fog_model = task.fit_baseline_model(np.concatenate(augmented_data), np.concatenate(augmented_labels))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Evaluate how well both models can handle corrupted test data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0/70 (2.13116500000001)\n",
      "10/70 (24.932033000000047)\n",
      "20/70 (48.70954800000004)\n",
      "30/70 (74.42075399999999)\n",
      "40/70 (103.49048599999992)\n",
      "50/70 (138.22527000000014)\n",
      "60/70 (179.14466700000003)\n",
      "WARNING:tensorflow:AutoGraph could not transform <function Model.make_predict_function.<locals>.predict_function at 0x7f95dbf2db90> and will run it as-is.\n",
      "Please report this to the TensorFlow team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output.\n",
      "Cause: 'arguments' object has no attribute 'posonlyargs'\n",
      "To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert\n",
      "WARNING: AutoGraph could not transform <function Model.make_predict_function.<locals>.predict_function at 0x7f95dbf2db90> and will run it as-is.\n",
      "Please report this to the TensorFlow team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output.\n",
      "Cause: 'arguments' object has no attribute 'posonlyargs'\n",
      "To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert\n",
      "0/70 (2.3602240000000165)\n",
      "10/70 (26.135790000000043)\n",
      "20/70 (50.680364000000054)\n",
      "30/70 (76.93518500000005)\n",
      "40/70 (106.07760499999995)\n",
      "50/70 (141.95714199999998)\n",
      "60/70 (183.23254999999995)\n"
     ]
    }
   ],
   "source": [
    "evaluator = CorruptionImpactEvaluator(task)\n",
    "\n",
    "corruptions  = []\n",
    "for fraction in [0.01, 0.05, 0.1, 0.25, 0.5, 0.75, 0.99]:\n",
    "    corruptions.append(FogCorruption(fraction=fraction, severity=4))\n",
    "    \n",
    "fog_results = evaluator.evaluate(baseline_model, 10, *corruptions)        \n",
    "fog_results_aug = evaluator.evaluate(fog_model, 10, *corruptions)   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot the results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def as_series(results):\n",
    "    medians = []\n",
    "    for result in results:\n",
    "        medians.append(np.median(result.corrupted_scores))\n",
    "    return medians\n",
    "\n",
    "ax = plt.gca()        \n",
    "\n",
    "fractions = [0.01, 0.05, 0.1, 0.25, 0.5, 0.75, 0.99]\n",
    "markersize=6\n",
    "\n",
    "l = ax.axhline(gaussian_noise_results[0].baseline_score, linestyle='--', color='black')    \n",
    "\n",
    "plt.plot(fractions, as_series(gaussian_noise_results_aug), color='#dc6082', linestyle='dotted', marker='^', markersize=markersize, fillstyle='none')\n",
    "plt.plot(fractions, as_series(gaussian_noise_results), color='#dc6082', marker='o', markersize=markersize)\n",
    "\n",
    "plt.plot(fractions, as_series(motion_blur_results_aug), color='#1e4052', linestyle='dotted', marker='^', markersize=markersize, fillstyle='none')\n",
    "plt.plot(fractions, as_series(motion_blur_results), color='#1e4052', marker='o', markersize=markersize)\n",
    "\n",
    "plt.plot(fractions, as_series(fog_results_aug), color='#e1a677', linestyle='dotted', marker='^', markersize=markersize, fillstyle='none')\n",
    "plt.plot(fractions, as_series(fog_results), color='#e1a677', marker='o', markersize=markersize)\n",
    "\n",
    "\n",
    "ax.set_ylim((0.9, 0.999))\n",
    "ax.tick_params(axis='both', which='major', labelsize=22)\n",
    "ax.tick_params(axis='both', which='minor', labelsize=22)    \n",
    "ax.set_ylabel('AUC', fontsize=24)\n",
    "ax.set_xlabel('fraction', fontsize=24)\n",
    "    \n",
    "ax.legend(['clean', 'noise (aug)', 'noise', 'motion (aug)', 'motion', 'fog (aug)', 'fog'], fontsize=12)    \n",
    "    \n",
    "plt.tight_layout()\n",
    "plt.gcf().set_size_inches(7, 5)\n",
    "\n",
    "plt.show()"
   ]
  }
 ],
 "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
}