model_classification.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.image as mpimg "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import zipfile\n",
    "import os\n",
    "\n",
    "local_zip = 'waste classification.zip'\n",
    "zip_ref = zipfile.ZipFile(local_zip, 'r')\n",
    "zip_ref.extractall('')\n",
    "zip_ref.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "base_dir = 'DATASET'\n",
    "train_dir = os.path.join(base_dir, 'TRAIN')\n",
    "validation_dir = os.path.join(base_dir, 'TEST')\n",
    "\n",
    "train_organic_dir = os.path.join(train_dir, 'O')\n",
    "\n",
    "train_recycle_dir = os.path.join(train_dir, 'R')\n",
    "\n",
    "validation_organic_dir = os.path.join(validation_dir, 'O')\n",
    "\n",
    "validation_recycle_dir = os.path.join(validation_dir, 'R')\n",
    "\n",
    "print('total training organic images:', len(os.listdir(train_organic_dir)))\n",
    "print('total training recycyle images:', len(os.listdir(train_recycle_dir)))\n",
    "print('total validation organic images:', len(os.listdir(validation_organic_dir)))\n",
    "print('total validation recycyle images:', len(os.listdir(validation_recycle_dir)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_organic_fnames = os.listdir(train_organic_dir)\n",
    "train_recycle_fnames = os.listdir(train_recycle_dir)\n",
    "train_recycle_fnames.sort()\n",
    "\n",
    "nrows = 2\n",
    "ncols = 4\n",
    "\n",
    "pic_index = 0\n",
    "\n",
    "\n",
    "fig = plt.gcf()\n",
    "fig.set_size_inches(ncols * 4, nrows *4)\n",
    "\n",
    "pic_index += 4\n",
    "next_organic_pix = [os.path.join(train_organic_dir, fname) \n",
    "                for fname in train_organic_fnames[pic_index-4:pic_index]]\n",
    "next_recycle_pix = [os.path.join(train_recycle_dir, fname) \n",
    "                for fname in train_recycle_fnames[pic_index-4:pic_index]]\n",
    "\n",
    "for i, img_path in enumerate(next_organic_pix + next_recycle_pix):\n",
    "  sp = plt.subplot(nrows, ncols, i + 1)\n",
    "  sp.axis('Off')\n",
    "\n",
    "  img = mpimg.imread(img_path)\n",
    "  plt.imshow(img)\n",
    "  print(img.shape)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras import layers\n",
    "from tensorflow.keras import Model\n",
    "\n",
    "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
    "from tensorflow.keras.optimizers import RMSprop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_datagen = ImageDataGenerator(rescale=1./255)\n",
    "val_datagen = ImageDataGenerator(rescale=1./255)\n",
    "\n",
    "train_generator = train_datagen.flow_from_directory(\n",
    "        train_dir,              \n",
    "        target_size=(150, 150),  \n",
    "        shuffle=True,\n",
    "        class_mode='binary')\n",
    "\n",
    "\n",
    "validation_generator = val_datagen.flow_from_directory(\n",
    "        validation_dir,\n",
    "        target_size=(150, 150),\n",
    "        shuffle=True,\n",
    "        class_mode='binary')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "img_input = layers.Input(shape=(150, 150, 3))\n",
    "x = layers.Conv2D(16, 3, activation='relu')(img_input)\n",
    "x = layers.MaxPooling2D(2)(x)\n",
    "x = layers.Conv2D(32, 3, activation='relu')(x)\n",
    "x = layers.MaxPooling2D(2)(x)\n",
    "x = layers.Conv2D(64, 3, activation='relu')(x)\n",
    "x = layers.MaxPooling2D(2)(x)\n",
    "x = layers.Flatten()(x)\n",
    "x = layers.Dense(512, activation='relu')(x)\n",
    "x = layers.Dropout(0.5)(x)\n",
    "output = layers.Dense(1, activation='sigmoid')(x)\n",
    "model = Model(img_input, output)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.compile(loss='binary_crossentropy',\n",
    "              optimizer=RMSprop(lr=0.001),\n",
    "              metrics=['acc'])\n",
    "\n",
    "history = model.fit(\n",
    "      train_generator,\n",
    "      epochs=8,\n",
    "      validation_data=validation_generator,\n",
    "      verbose=2,\n",
    "      shuffle=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "acc = history.history['acc']\n",
    "val_acc = history.history['val_acc']\n",
    "\n",
    "loss = history.history['loss']\n",
    "val_loss = history.history['val_loss']\n",
    "\n",
    "epochs = range(len(acc))\n",
    "\n",
    "plt.plot(epochs, acc, label='training accuracy')\n",
    "plt.plot(epochs, val_acc, label='validation accuracy')\n",
    "plt.title('Training and validation accuracy')\n",
    "plt.legend()\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(epochs, loss, label='training loss')\n",
    "plt.plot(epochs, val_loss, label='validation loss')\n",
    "plt.title('Training and validation loss')\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.applications.inception_v3 import InceptionV3\n",
    "from tensorflow.keras.optimizers import SGD\n",
    "\n",
    "local_weights_file = 'inception_v3_weights_tf_dim_ordering_tf_kernels_notop.h5'\n",
    "pre_trained_model = InceptionV3(\n",
    "    input_shape=(150, 150, 3), include_top=False, weights=None)\n",
    "pre_trained_model.load_weights(local_weights_file)\n",
    "\n",
    "\n",
    "for layer in pre_trained_model.layers:\n",
    "  layer.trainable = False\n",
    "\n",
    "\n",
    "last_layer = pre_trained_model.get_layer('mixed7')\n",
    "print('last layer output shape:', last_layer.output_shape)\n",
    "last_output = last_layer.output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = layers.Flatten()(last_output)\n",
    "x = layers.Dense(1024, activation='relu')(x)\n",
    "x = layers.Dropout(0.5)(x)\n",
    "x = layers.Dense(1, activation='sigmoid')(x)\n",
    "unfreeze = False\n",
    "for layer in pre_trained_model.layers:\n",
    "  if unfreeze:\n",
    "    layer.trainable = True\n",
    "  if layer.name == 'mixed6':\n",
    "    unfreeze = True\n",
    "model = Model(pre_trained_model.input, x)\n",
    "model.compile(loss='binary_crossentropy',\n",
    "              optimizer=SGD(\n",
    "                  lr=0.00001, \n",
    "                  momentum=0.9),\n",
    "              metrics=['acc'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "history = model.fit_generator(\n",
    "      train_generator,\n",
    "      steps_per_epoch=100,\n",
    "      epochs=60,\n",
    "      validation_data=validation_generator,\n",
    "      validation_steps=50,\n",
    "      verbose=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "acc = history.history['acc']\n",
    "val_acc = history.history['val_acc']\n",
    "loss = history.history['loss']\n",
    "val_loss = history.history['val_loss']\n",
    "epochs = range(len(acc))\n",
    "plt.plot(epochs, acc, label='training accuracy')\n",
    "plt.plot(epochs, val_acc, label='validation accuracy')\n",
    "plt.title('Training and validation accuracy')\n",
    "plt.legend()\n",
    "plt.figure()\n",
    "plt.plot(epochs, loss, label='training loss')\n",
    "plt.plot(epochs, val_loss, label='validation loss')\n",
    "plt.title('Training and validation loss')\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "val_visual = val_datagen.flow_from_directory(\n",
    "        validation_dir,\n",
    "        target_size=(150, 150),\n",
    "        class_mode='binary',\n",
    "        shuffle=True)\n",
    "\n",
    "print(val_visual.class_indices)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "val_pred_prob = model.predict(val_visual)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "val_dir_indices = val_visual.index_array\n",
    "val_true_labels = [0 if n < 1112 else 1 for n in val_dir_indices] \n",
    "val_pred_prob = model.predict(val_visual)\n",
    "val_pred_labels = [1 if n >= 0.5 else 0 for n in val_pred_prob]\n",
    "\n",
    "print(\"Model predictions: \"+str(val_pred_labels))\n",
    "print(\"Actual labels:     \"+str(val_true_labels))\n",
    "\n",
    "num_misclasssified = 0\n",
    "misclassified_filepaths = []\n",
    "correctness = []\n",
    "for pred_label, true_label, dir_index in zip(val_pred_labels, val_true_labels, val_visual.index_array):\n",
    "  misclassified_filepaths.append(val_visual.filepaths[dir_index])\n",
    "  if pred_label != true_label:\n",
    "    correctness.append('incorrect')\n",
    "    num_misclasssified += 1\n",
    "  else:\n",
    "    correctness.append('correct')\n",
    "\n",
    "print(\"# of total images: \"+str(len(correctness)))\n",
    "print(\"# of misclassified images: \"+str(num_misclasssified))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "misclassified_imgs = []\n",
    "for filepath in misclassified_filepaths:\n",
    "  misclassified_imgs.append(mpimg.imread(filepath))\n",
    "\n",
    "f, axarr = plt.subplots(6,5, figsize=(20,10), constrained_layout=True)  \n",
    "count = 0\n",
    "for r in range(6):\n",
    "  for c in range(5):\n",
    "    axarr[r,c].imshow(misclassified_imgs[count])\n",
    "    if correctness[count] == 'correct':\n",
    "      axarr[r,c].set_title(correctness[count])\n",
    "    else:\n",
    "      axarr[r,c].set_title(correctness[count], color='red')\n",
    "    axarr[r,c].set_axis_off()\n",
    "    count += 1 \n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "loss, acc = model.evaluate(validation_generator, verbose=1)\n",
    "print(\"Accuracy using evaluate: \"+str(acc))\n",
    "print(\"Loss using evaluate: \"+str(loss))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.metrics import classification_report\n",
    "\n",
    "matrix = confusion_matrix(val_true_labels, val_pred_labels, labels=[0, 1])\n",
    "print('Confusion matrix : \\n',matrix, '\\n')\n",
    "\n",
    "tp, fn, fp, tn = confusion_matrix(val_true_labels, val_pred_labels, labels=[1,0]).reshape(-1)\n",
    "print('Outcome values : \\n', tp, fn, fp, tn, '\\n')\n",
    "\n",
    "matrix = classification_report(val_true_labels, val_pred_labels, labels=[1,0])\n",
    "print('Classification report : \\n',matrix)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "val_visual = val_datagen.flow_from_directory(\n",
    "        validation_dir,\n",
    "        target_size=(150, 150),\n",
    "        class_mode='binary',\n",
    "        shuffle=True)\n",
    "\n",
    "print(val_visual.class_indices)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "val_pred_prob = model.predict(val_visual)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "val_dir_indices = val_visual.index_array\n",
    "val_true_labels = [0 if n < 1112 else 1 for n in val_dir_indices] \n",
    "\n",
    "val_pred_prob = model.predict(val_visual)\n",
    "\n",
    "val_pred_labels = [1 if n >= 0.5 else 0 for n in val_pred_prob]\n",
    "\n",
    "print(\"Model predictions: \"+str(val_pred_labels))\n",
    "print(\"Actual labels:     \"+str(val_true_labels))\n",
    "\n",
    "num_misclasssified = 0\n",
    "misclassified_filepaths = []\n",
    "correctness = []\n",
    "for pred_label, true_label, dir_index in zip(val_pred_labels, val_true_labels, val_visual.index_array):\n",
    "  misclassified_filepaths.append(val_visual.filepaths[dir_index])\n",
    "  if pred_label != true_label:\n",
    "    correctness.append('incorrect')\n",
    "    num_misclasssified += 1\n",
    "  else:\n",
    "    correctness.append('correct')\n",
    "\n",
    "print(\"# of total images: \"+str(len(correctness)))\n",
    "print(\"# of misclassified images: \"+str(num_misclasssified))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "misclassified_imgs = []\n",
    "for filepath in misclassified_filepaths:\n",
    "  misclassified_imgs.append(mpimg.imread(filepath))\n",
    "\n",
    "# plots first 30 images\n",
    "f, axarr = plt.subplots(6,5, figsize=(20,10), constrained_layout=True)  # plt.subplots(row,cols)\n",
    "count = 0\n",
    "for r in range(6):\n",
    "  for c in range(5):\n",
    "    axarr[r,c].imshow(misclassified_imgs[count])\n",
    "    if correctness[count] == 'correct':\n",
    "      axarr[r,c].set_title(correctness[count])\n",
    "    else:\n",
    "      axarr[r,c].set_title(correctness[count], color='red')\n",
    "    axarr[r,c].set_axis_off()\n",
    "    count += 1 \n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "loss, acc = model.evaluate(validation_generator, verbose=1)\n",
    "print(\"Accuracy using evaluate: \"+str(acc))\n",
    "print(\"Loss using evaluate: \"+str(loss))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from tensorflow.keras.models import load_model\n",
    "from tensorflow.keras.preprocessing import image\n",
    "\n",
    "def predict_waste_type(image_path):\n",
    "    model = load_model('trained_model.h5')\n",
    "\n",
    "    img = image.load_img(image_path, target_size=(150, 150))\n",
    "    img_array = image.img_to_array(img)\n",
    "    img_array = np.expand_dims(img_array, axis=0) / 255.0\n",
    "\n",
    "    prediction = model.predict(img_array)\n",
    "    if prediction[0][0] < 0.5:\n",
    "        return \"Organic Waste\"\n",
    "    else:\n",
    "        return \"Recyclable Waste\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.save('trained_model.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!jupyter nbconvert --to script model_classification.ipynb"
   ]
  }
 ],
 "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.9.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}