001_bottleneck_jax_example.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## JAX and Elegy image classifier\n",
    "\n",
    "\n",
    "This is a simple example of JAX and Elegy image classifier. Here I am using transfer learning through bottleneck features. The purpose of this is the ability to use any net for featuring extraction, and then build the upper layers with JAX and Elegy, because not all famous nets are implemented in JAX."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/alejandro/opt/anaconda3/envs/jax_elegy/lib/python3.7/site-packages/jax/lib/xla_bridge.py:130: UserWarning: No GPU/TPU found, falling back to CPU.\n",
      "  warnings.warn('No GPU/TPU found, falling back to CPU.')\n"
     ]
    }
   ],
   "source": [
    "import jax\n",
    "import glob\n",
    "import numpy as np\n",
    "import jax.numpy as jnp\n",
    "\n",
    "import elegy\n",
    "import optax\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(7, 7, 512)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class_names = ['no_damages', 'car_damage']\n",
    "bottleneck_path = 'data/features/vgg19_bottleneck.npz'\n",
    "\n",
    "features = np.load(bottleneck_path)\n",
    "features['train'].shape[1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# I selected all the train_features except the last three,\n",
    "# because they are not included in the train_targes.\n",
    "\n",
    "train_features = features['train'][:-3]\n",
    "test_features = features['test']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_targets = np.load('data/labels/train_targets.npy')[:, 0].astype(np.int32)\n",
    "test_targets = np.load('data/labels/test_targets.npy')[:, 0].astype(np.int32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Model architecture\n",
    "\n",
    "class ModelArch(elegy.Module):\n",
    "\n",
    "    def call(self, x: jnp.ndarray) -> jnp.ndarray:\n",
    "        GAP = lambda x: jnp.mean(x, axis=(1, 2))\n",
    "        x = elegy.module.to_module(GAP)(name=\"global_average_pooling\")(x)\n",
    "        x = elegy.nn.Dropout(0.3)(x)\n",
    "        x = elegy.nn.Linear(2, dtype=jnp.float32)(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Here you can play with the different loss function, optimizers....\n",
    "\n",
    "model = elegy.Model(\n",
    "    module=ModelArch(),\n",
    "    loss=[\n",
    "        elegy.losses.SparseCategoricalCrossentropy(from_logits=True),\n",
    "        elegy.regularizers.GlobalL2(l=1e-5),\n",
    "    ],\n",
    "    metrics=elegy.metrics.SparseCategoricalAccuracy(),\n",
    "    optimizer=optax.rmsprop(1e-3),\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "╒═════════════════════════════════════╤═════════════════════════╤═════════════════╤═════════════════╕\n",
      "│ Layer                               │ Outputs Shape           │ Trainable       │   Non-trainable │\n",
      "│                                     │                         │ Parameters      │      Parameters │\n",
      "╞═════════════════════════════════════╪═════════════════════════╪═════════════════╪═════════════════╡\n",
      "│ Inputs                              │ (1, 7, 7, 512)  float32 │ 0               │               0 │\n",
      "├─────────────────────────────────────┼─────────────────────────┼─────────────────┼─────────────────┤\n",
      "│ global_average_pooling  (<lambda>)  │ (1, 512)        float32 │ 0               │               0 │\n",
      "├─────────────────────────────────────┼─────────────────────────┼─────────────────┼─────────────────┤\n",
      "│ dropout                 (Dropout)   │ (1, 512)        float32 │ 0               │               0 │\n",
      "├─────────────────────────────────────┼─────────────────────────┼─────────────────┼─────────────────┤\n",
      "│ linear                  (Linear)    │ (1, 2)          float32 │ 1,026    4.1 KB │               0 │\n",
      "├─────────────────────────────────────┼─────────────────────────┼─────────────────┼─────────────────┤\n",
      "│ Outputs                 (ModelArch) │ (1, 2)          float32 │ 0               │               0 │\n",
      "╘═════════════════════════════════════╧═════════════════════════╧═════════════════╧═════════════════╛\n",
      "Total Parameters:          1,026  4.1 KB\n",
      "Trainable Parameters:      1,026  4.1 KB\n",
      "Non-trainable Parameters:  0\n",
      "\n"
     ]
    }
   ],
   "source": [
    "model.summary(train_features[:1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/8\n",
      "58/58 [==============================] - 1s 20ms/step - l2_regularization_loss: 1.6101e-05 - loss: 1.0211 - sparse_categorical_accuracy: 0.7408 - sparse_categorical_crossentropy_loss: 1.0211\n",
      "Epoch 2/8\n",
      "58/58 [==============================] - 0s 2ms/step - l2_regularization_loss: 1.5662e-05 - loss: 0.5808 - sparse_categorical_accuracy: 0.8283 - sparse_categorical_crossentropy_loss: 0.5808\n",
      "Epoch 3/8\n",
      "58/58 [==============================] - ETA: 0s - l2_regularization_loss: 1.5258e-05 - loss: 0.5445 - sparse_categorical_accuracy: 0.8393 - sparse_categorical_crossentropy_loss: 0.544 - 0s 2ms/step - l2_regularization_loss: 1.5226e-05 - loss: 0.5109 - sparse_categorical_accuracy: 0.8495 - sparse_categorical_crossentropy_loss: 0.5109\n",
      "Epoch 4/8\n",
      "58/58 [==============================] - 0s 2ms/step - l2_regularization_loss: 1.4929e-05 - loss: 0.4080 - sparse_categorical_accuracy: 0.8630 - sparse_categorical_crossentropy_loss: 0.4079\n",
      "Epoch 5/8\n",
      "58/58 [==============================] - 0s 2ms/step - l2_regularization_loss: 1.4680e-05 - loss: 0.3841 - sparse_categorical_accuracy: 0.8674 - sparse_categorical_crossentropy_loss: 0.3841\n",
      "Epoch 6/8\n",
      "58/58 [==============================] - 0s 2ms/step - l2_regularization_loss: 1.4545e-05 - loss: 0.3287 - sparse_categorical_accuracy: 0.8886 - sparse_categorical_crossentropy_loss: 0.3287\n",
      "Epoch 7/8\n",
      "58/58 [==============================] - 0s 2ms/step - l2_regularization_loss: 1.4529e-05 - loss: 0.3250 - sparse_categorical_accuracy: 0.8891 - sparse_categorical_crossentropy_loss: 0.3250\n",
      "Epoch 8/8\n",
      "58/58 [==============================] - 0s 2ms/step - l2_regularization_loss: 1.4589e-05 - loss: 0.3036 - sparse_categorical_accuracy: 0.8902 - sparse_categorical_crossentropy_loss: 0.3036\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<elegy.callbacks.history.History at 0x7f9c616b8bd0>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Here you can play with the different arguments for fit, changing, batch size, including validation data,\n",
    "# adding callbacks....\n",
    "\n",
    "model.fit(train_features, train_targets, epochs=8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "predictions = np.argmax(model.predict(test_features), axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 396x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "from sklearn.metrics import accuracy_score, confusion_matrix, precision_recall_fscore_support\n",
    "\n",
    "cm = confusion_matrix( test_targets, predictions) \n",
    "\n",
    "cm_df = pd.DataFrame(cm,\n",
    "                     index = ['no_damages', 'car_damage'], \n",
    "                     columns = ['no_damages', 'car_damage'])\n",
    "\n",
    "plt.figure(figsize=(5.5,4))\n",
    "sns.heatmap(cm_df, cmap=\"coolwarm_r\",annot=True,linewidths=0.5)\n",
    "plt.title('Model \\nAccuracy:{0:.3f}'.format(accuracy_score(test_targets,predictions)))\n",
    "plt.ylabel('True label')\n",
    "plt.xlabel('Predicted label')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.preprocessing import image\n",
    "from features_extractor import extract_VGG19\n",
    "\n",
    "\n",
    "def path_to_tensor(img_path):\n",
    "\n",
    "    img = image.load_img(img_path, target_size=(224, 224))\n",
    "    \n",
    "    x = image.img_to_array(img)\n",
    "\n",
    "    return np.expand_dims(x, axis=0)\n",
    "\n",
    "\n",
    "def make_file_prediction(img_path = 'data/sample_images/car_2.jpg'):\n",
    "\n",
    "    img_tensor = path_to_tensor(img_path)\n",
    "    img_tensor_features = extract_VGG19(img_tensor)\n",
    "    \n",
    "    prediction = model.predict(img_tensor_features)\n",
    "\n",
    "    class_predicted = class_names[np.argmax(prediction, axis=1)[0]]\n",
    "    \n",
    "    return class_predicted"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "car_1.jpg\n",
      "no_damages\n",
      "-----------\n",
      "\n",
      "car_damage_1.jpg\n",
      "car_damage\n",
      "-----------\n",
      "\n",
      "car_2.jpg\n",
      "no_damages\n",
      "-----------\n",
      "\n",
      "car_damage_2.jpg\n",
      "car_damage\n",
      "-----------\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for file_path in glob.glob('data/sample_images/*.jpg'):\n",
    "    print(file_path.split('/')[-1])\n",
    "    print(make_file_prediction(file_path))\n",
    "    print('-----------')\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "jax_eleg",
   "language": "python",
   "name": "jax_eleg"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}