Garbage_Classification.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Use MobileNet model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "liv8xIGetvs-",
        "outputId": "1d685749-95a1-4730-cd98-6ecbf2fc4dc0"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Found 2276 images belonging to 6 classes.\n",
            "Found 251 images belonging to 6 classes.\n"
          ]
        }
      ],
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from matplotlib.pyplot import *\n",
        "import cv2\n",
        "import os\n",
        "from sklearn.model_selection import train_test_split\n",
        "from tensorflow.keras import datasets, layers, models\n",
        "from keras.callbacks import ModelCheckpoint\n",
        "import tensorflow as tf\n",
        "\n",
        "#Allow charts and graphics to display right below the page of browser setup\n",
        "%matplotlib inline\n",
        "#paths to the train, validation and test image datasets\n",
        "train_path = '/content/drive/MyDrive/text-data/Garbage classification'\n",
        "valid_path = '/content/drive/MyDrive/text-data/Garbage classification'\n",
        "\n",
        "IMG_SIZE = 224\n",
        "IMG_SHAPE = (IMG_SIZE, IMG_SIZE, 3)\n",
        "\n",
        "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
        "train_batches = ImageDataGenerator(\n",
        "    shear_range=0.2,\n",
        "    zoom_range=0.2,\n",
        "    width_shift_range=0.2,\n",
        "    height_shift_range=0.2,\n",
        "    validation_split=0.1).flow_from_directory(\n",
        "    directory=train_path, target_size=(IMG_SIZE,IMG_SIZE), classes=['cardboard', 'glass', 'metal', 'paper', 'plastic', 'trash'], batch_size=16, subset='training',seed=42)\n",
        "\n",
        "\n",
        "# extract images to validation set\n",
        "valid_batches = ImageDataGenerator(\n",
        "    validation_split=0.1).flow_from_directory(\n",
        "    directory=valid_path, target_size=(IMG_SIZE,IMG_SIZE), classes=['cardboard', 'glass', 'metal', 'paper', 'plastic', 'trash'], batch_size=16, subset='validation',seed=42)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Tn6_ZpLCuSge"
      },
      "outputs": [],
      "source": [
        "# Training set\n",
        "num_train_batches = len(train_batches)\n",
        "X_train, Y_train = [], []\n",
        "\n",
        "for i in range(num_train_batches):\n",
        "    data = train_batches.next()\n",
        "    X_train.append(data[0])\n",
        "    Y_train.append(data[1])\n",
        "\n",
        "X_train = np.concatenate(X_train)\n",
        "Y_train = np.concatenate(Y_train)\n",
        "\n",
        "# Validation set\n",
        "num_valid_batches = len(valid_batches)\n",
        "X_test, Y_test = [], []\n",
        "\n",
        "for i in range(num_valid_batches):\n",
        "    data = valid_batches.next()\n",
        "    X_test.append(data[0])\n",
        "    Y_test.append(data[1])\n",
        "\n",
        "X_test = np.concatenate(X_test)\n",
        "Y_test = np.concatenate(Y_test)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VrSO25vfCmyP",
        "outputId": "984a8fa1-3887-477a-fccf-ccad71954669"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Downloading data from https://storage.googleapis.com/tensorflow/keras-applications/mobilenet/mobilenet_1_0_224_tf_no_top.h5\n",
            "17225924/17225924 [==============================] - 0s 0us/step\n",
            "72/72 [==============================] - 5s 31ms/step\n",
            "8/8 [==============================] - 1s 138ms/step\n"
          ]
        }
      ],
      "source": [
        "import tensorflow as tf\n",
        "base_model = tf.keras.applications.MobileNet(input_shape=(224, 224, 3),\n",
        "                                               include_top=False,\n",
        "                                               weights='imagenet')\n",
        "base_output1=base_model.get_layer('conv_pw_13_relu').output\n",
        "out=tf.keras.layers.GlobalAveragePooling2D()(base_output1)\n",
        "model = tf.keras.models.Model(inputs=base_model.input, outputs=out)\n",
        "\n",
        "# Extract features using the pre-trained model\n",
        "X_train_features = model.predict(X_train)\n",
        "X_test_features = model.predict(X_test)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "5zAdRIEeCmvV"
      },
      "outputs": [],
      "source": [
        "\n",
        "# Flatten the extracted features\n",
        "X_train_features = X_train_features.reshape(X_train_features.shape[0], -1)\n",
        "X_test_features = X_test_features.reshape(X_test_features.shape[0], -1)\n",
        "X_train =X_train_features\n",
        "X_test = X_test_features"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "yyTEQeLcCmsv"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "from sklearn.datasets import make_classification\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.svm import SVC\n",
        "from sklearn.metrics import accuracy_score\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "FrH2A9c5yAq0"
      },
      "outputs": [],
      "source": [
        "Y_train=np.argmax(Y_train, axis=1)\n",
        "Y_test=np.argmax(Y_test, axis=1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### SVM only with extracted features from MobileNet"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xIQQpFJvxy7c",
        "outputId": "c958a677-02a5-472d-bf34-d00f97b186e9"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Accuracy on Train Set: 0.9753954305799648\n",
            "Accuracy on Test Set: 0.8645418326693227\n"
          ]
        }
      ],
      "source": [
        "# Train SVM classifier with extracted features\n",
        "clf = SVC()\n",
        "clf.fit(X_train_features, Y_train)\n",
        "\n",
        "y_pred = clf.predict(X_train_features)\n",
        "accuracy = accuracy_score(Y_train, y_pred)\n",
        "\n",
        "print(\"Accuracy on Train Set:\", accuracy)\n",
        "# Evaluate on the test set\n",
        "y_pred = clf.predict(X_test_features)\n",
        "accuracy = accuracy_score(Y_test, y_pred)\n",
        "\n",
        "print(\"Accuracy on Test Set:\", accuracy)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Tring GeneticAlgorithm then SVM "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YEw13YCqCmkE",
        "outputId": "e3e5530e-d2e8-4ca3-f8e4-ae912a38fd1f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Selected Features: [   0    2    4    5    6    8   12   14   15   16   17   18   19   20\n",
            "   21   22   23   24   25   28   29   30   34   36   37   38   44   45\n",
            "   46   47   49   52   53   54   55   56   57   62   63   64   66   67\n",
            "   68   70   71   73   74   75   76   78   79   82   83   84   86   88\n",
            "   90   93  101  103  104  107  108  109  112  115  116  119  120  122\n",
            "  123  125  126  127  129  130  133  136  140  143  145  146  147  148\n",
            "  150  151  154  155  156  158  163  164  165  168  169  170  171  172\n",
            "  173  174  176  177  179  180  181  187  191  195  197  199  203  204\n",
            "  205  206  207  208  209  210  211  215  221  224  225  226  228  229\n",
            "  230  231  234  236  238  239  240  241  242  243  251  256  258  259\n",
            "  263  264  265  266  267  268  269  271  276  277  278  279  281  282\n",
            "  283  284  285  286  288  289  290  292  293  297  301  302  303  304\n",
            "  306  307  310  311  312  313  314  317  320  322  325  326  328  329\n",
            "  331  334  335  338  340  341  347  348  352  355  357  358  360  361\n",
            "  362  363  367  369  371  372  373  374  375  377  378  380  381  382\n",
            "  383  384  385  386  388  389  390  393  394  397  398  400  401  404\n",
            "  407  408  409  414  415  416  417  419  421  422  424  426  430  431\n",
            "  432  441  445  449  450  451  454  456  458  460  461  463  465  467\n",
            "  468  470  471  476  479  481  483  485  487  488  489  490  493  494\n",
            "  495  497  498  500  501  503  505  506  507  510  511  512  513  514\n",
            "  518  520  521  522  523  524  526  527  531  534  536  538  542  548\n",
            "  550  553  556  559  562  563  565  566  567  574  575  583  584  585\n",
            "  587  588  589  590  592  593  594  595  598  599  602  604  605  607\n",
            "  609  610  612  615  617  618  619  626  628  629  632  635  639  642\n",
            "  643  644  645  649  651  653  654  661  667  672  673  678  679  680\n",
            "  681  682  686  688  689  690  692  695  697  700  702  703  704  705\n",
            "  707  708  709  710  711  712  718  720  721  723  724  725  728  730\n",
            "  732  733  735  737  742  743  747  748  750  751  753  754  761  762\n",
            "  764  766  769  771  778  784  786  787  788  789  790  791  792  794\n",
            "  797  799  800  801  805  809  811  818  819  820  821  823  824  825\n",
            "  827  829  831  833  840  842  844  849  850  857  861  862  863  865\n",
            "  866  867  868  870  872  874  876  877  879  884  886  887  891  894\n",
            "  895  900  901  902  903  904  905  906  907  908  910  913  914  915\n",
            "  922  924  927  929  930  933  939  944  946  948  949  952  955  956\n",
            "  958  961  962  964  968  970  971  973  974  980  981  982  983  984\n",
            "  985  986  987  988  990  992  993  994  995 1000 1001 1005 1009 1010\n",
            " 1015 1016 1019 1020 1022 1023]\n",
            "Accuracy on Test Set: 0.8565737051792829\n"
          ]
        }
      ],
      "source": [
        "class GeneticAlgorithm:\n",
        "    def __init__(self, population_size, n_features, crossover_prob=0.8, mutation_prob=0.2, generations=5):\n",
        "        self.population_size = population_size\n",
        "        self.n_features = n_features\n",
        "        self.crossover_prob = crossover_prob\n",
        "        self.mutation_prob = mutation_prob\n",
        "        self.generations = generations\n",
        "\n",
        "    def initialize_population(self):\n",
        "        return np.random.randint(2, size=(self.population_size, self.n_features))\n",
        "\n",
        "    def evaluate_population(self, population, X_train, y_train):\n",
        "        accuracies = []\n",
        "        for solution in population:\n",
        "            selected_features = np.where(solution == 1)[0]\n",
        "            if len(selected_features) == 0:\n",
        "                accuracies.append(0.0)\n",
        "                continue\n",
        "\n",
        "            clf = SVC()\n",
        "            clf.fit(X_train[:, selected_features], y_train)\n",
        "            accuracy = accuracy_score(y_train, clf.predict(X_train[:, selected_features]))\n",
        "            accuracies.append(accuracy)\n",
        "\n",
        "        return np.array(accuracies)\n",
        "\n",
        "    def select_parents(self, population, fitness):\n",
        "        # Tournament selection\n",
        "        selected_indices = np.random.choice(self.population_size, size=(2, self.population_size), replace=True)\n",
        "        selected_parents = population[selected_indices[np.argmax(fitness[selected_indices], axis=0), np.arange(self.population_size)]]\n",
        "        return selected_parents\n",
        "\n",
        "    def crossover(self, parent1, parent2):\n",
        "        crossover_point = np.random.randint(1, self.n_features)\n",
        "        child1 = np.concatenate((parent1[:crossover_point], parent2[crossover_point:]))\n",
        "        child2 = np.concatenate((parent2[:crossover_point], parent1[crossover_point:]))\n",
        "        return child1, child2\n",
        "\n",
        "    def mutate(self, child):\n",
        "        mutation_mask = np.random.rand(self.n_features) < self.mutation_prob\n",
        "        child[mutation_mask] = 1 - child[mutation_mask]\n",
        "        return child\n",
        "\n",
        "    def run(self, X_train, y_train):\n",
        "        population = self.initialize_population()\n",
        "\n",
        "        for generation in range(self.generations):\n",
        "            fitness = self.evaluate_population(population, X_train, y_train)\n",
        "\n",
        "            parents = self.select_parents(population, fitness)\n",
        "\n",
        "            # Create offspring through crossover so we get the new population\n",
        "            offspring = []\n",
        "            for i in range(0, self.population_size, 2):\n",
        "                if np.random.rand() < self.crossover_prob:\n",
        "                    child1, child2 = self.crossover(parents[i], parents[i + 1])\n",
        "                else:\n",
        "                    child1, child2 = parents[i], parents[i + 1]\n",
        "\n",
        "                # Mutate children for the new generation\n",
        "                child1 = self.mutate(child1)\n",
        "                child2 = self.mutate(child2)\n",
        "\n",
        "                offspring.append(child1)\n",
        "                offspring.append(child2)\n",
        "\n",
        "            population[:self.population_size] = np.array(offspring)\n",
        "\n",
        "        # Select the best solution from the final population\n",
        "        final_fitness = self.evaluate_population(population, X_train, y_train)\n",
        "        best_solution = population[np.argmax(final_fitness)]\n",
        "\n",
        "        return best_solution\n",
        "\n",
        "\n",
        "population_size = 20\n",
        "ga = GeneticAlgorithm(population_size=population_size, n_features=X_train.shape[1])\n",
        "selected_features = ga.run(X_train, Y_train)\n",
        "\n",
        "# Train SVM classifier with selected features\n",
        "clf = SVC()\n",
        "clf.fit(X_train[:, selected_features == 1], Y_train)\n",
        "\n",
        "# Evaluate on the test set\n",
        "y_pred = clf.predict(X_test[:, selected_features == 1])\n",
        "accuracy = accuracy_score(Y_test, y_pred)\n",
        "\n",
        "print(\"Selected Features:\", np.where(selected_features == 1)[0])\n",
        "print(\"Accuracy on Test Set:\", accuracy)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cwEgwtdDDGsc",
        "outputId": "2d22f8ad-8718-4b6b-b823-9ccd431e59a1"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(2276, 510)"
            ]
          },
          "execution_count": 21,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "X_train[:, selected_features == 1].shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pCzxw4WVylkD",
        "outputId": "294c7abb-95e1-4593-f7c7-449307f67bfd"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Accuracy on Train Set: 0.9740773286467487\n"
          ]
        }
      ],
      "source": [
        "y_pred_train = clf.predict(X_train[:, selected_features == 1])\n",
        "accuracy = accuracy_score(Y_train, y_pred_train)\n",
        "\n",
        "print(\"Accuracy on Train Set:\", accuracy)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hamEbbxLDGo4",
        "outputId": "f499378c-f8fb-4ad3-b33f-e2067ee77f5a"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[31  0  0  9  0  0]\n",
            " [ 0 44  2  0  4  0]\n",
            " [ 0  1 37  2  1  0]\n",
            " [ 2  0  1 56  0  0]\n",
            " [ 0  3  2  3 40  0]\n",
            " [ 0  0  2  2  2  7]]\n",
            "Precision: 0.8670371169523496\n",
            "Recall: 0.8565737051792829\n",
            "F1-score: 0.8546951406121129\n"
          ]
        }
      ],
      "source": [
        "# Evaluate the model and print the confusion matrix\n",
        "from sklearn.metrics import confusion_matrix, precision_score, recall_score, f1_score\n",
        "\n",
        "# Compute the confusion matrix\n",
        "confusion_mat = confusion_matrix(Y_test, y_pred)\n",
        "#print(\"Confusion Matrix:\")\n",
        "print(confusion_mat)\n",
        "\n",
        "precision = precision_score(Y_test, y_pred, average='weighted')\n",
        "recall = recall_score(Y_test, y_pred, average='weighted')\n",
        "f1 = f1_score(Y_test, y_pred, average='weighted')\n",
        "\n",
        "print(\"Precision:\", precision)\n",
        "print(\"Recall:\", recall)\n",
        "print(\"F1-score:\", f1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 718
        },
        "id": "FjsnO8swyVfP",
        "outputId": "f4133fb9-20cf-4bb6-fa3a-453067c4316d"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1000x800 with 2 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "import seaborn as sns\n",
        "import matplotlib.pyplot as plt\n",
        "# Plot the heatmap\n",
        "cfm = np.around(confusion_matrix(Y_test, y_pred, normalize='true'), decimals=2)\n",
        "plt.figure(figsize=(10, 8))\n",
        "sns.heatmap(confusion_mat, annot=True, fmt='d', cmap='Blues',\n",
        "            xticklabels=['cardboard', 'glass', 'metal', 'paper', 'plastic', 'trash'],\n",
        "            yticklabels=['cardboard', 'glass', 'metal', 'paper', 'plastic', 'trash'])\n",
        "plt.title('Confusion Matrix')\n",
        "plt.xlabel('Predicted')\n",
        "plt.ylabel('True')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2F7RAl6MyegS",
        "outputId": "acd84c9b-951d-4783-ecea-e282638e7d53"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "              precision    recall  f1-score   support\n",
            "\n",
            "   cardboard       0.94      0.78      0.85        40\n",
            "       glass       0.92      0.88      0.90        50\n",
            "       metal       0.84      0.90      0.87        41\n",
            "       paper       0.78      0.95      0.85        59\n",
            "     plastic       0.85      0.83      0.84        48\n",
            "       trash       1.00      0.54      0.70        13\n",
            "\n",
            "    accuracy                           0.86       251\n",
            "   macro avg       0.89      0.81      0.84       251\n",
            "weighted avg       0.87      0.86      0.85       251\n",
            "\n"
          ]
        }
      ],
      "source": [
        "from sklearn.metrics import classification_report\n",
        "print(classification_report(Y_test, y_pred, target_names=['cardboard', 'glass', 'metal', 'paper', 'plastic', 'trash']))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CPODy9lVyAax"
      },
      "source": [
        "# Use Xception model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fp4pmjiFDGhC",
        "outputId": "ba0ee67b-c3ca-4d89-f5a9-d88571c933e2"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Found 2276 images belonging to 6 classes.\n",
            "Found 251 images belonging to 6 classes.\n"
          ]
        }
      ],
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from matplotlib.pyplot import *\n",
        "import cv2\n",
        "import os\n",
        "from sklearn.model_selection import train_test_split\n",
        "from tensorflow.keras import datasets, layers, models\n",
        "from keras.callbacks import ModelCheckpoint\n",
        "import tensorflow as tf\n",
        "\n",
        "#Allow charts and graphics to display right below the page of browser setup\n",
        "%matplotlib inline\n",
        "#paths to the train, validation and test image datasets\n",
        "train_path = '/content/drive/MyDrive/text-data/Garbage classification'\n",
        "valid_path = '/content/drive/MyDrive/text-data/Garbage classification'\n",
        "\n",
        "IMG_SIZE = 224\n",
        "IMG_SHAPE = (IMG_SIZE, IMG_SIZE, 3)\n",
        "\n",
        "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
        "train_batches = ImageDataGenerator(\n",
        "    shear_range=0.2,\n",
        "    zoom_range=0.2,\n",
        "    width_shift_range=0.2,\n",
        "    height_shift_range=0.2,\n",
        "    validation_split=0.1).flow_from_directory(\n",
        "    directory=train_path, target_size=(IMG_SIZE,IMG_SIZE), classes=['cardboard', 'glass', 'metal', 'paper', 'plastic', 'trash'], batch_size=16, subset='training',seed=42)\n",
        "\n",
        "\n",
        "# extract images to validation set\n",
        "valid_batches = ImageDataGenerator(\n",
        "    validation_split=0.1).flow_from_directory(\n",
        "    directory=valid_path, target_size=(IMG_SIZE,IMG_SIZE), classes=['cardboard', 'glass', 'metal', 'paper', 'plastic', 'trash'], batch_size=16, subset='validation',seed=42)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "FtgW-bOq6GRJ"
      },
      "outputs": [],
      "source": [
        "# Training set\n",
        "num_train_batches = len(train_batches)\n",
        "X_train, Y_train = [], []\n",
        "\n",
        "for i in range(num_train_batches):\n",
        "    data = train_batches.next()\n",
        "    X_train.append(data[0])\n",
        "    Y_train.append(data[1])\n",
        "\n",
        "X_train = np.concatenate(X_train)\n",
        "Y_train = np.concatenate(Y_train)\n",
        "\n",
        "# Validation set\n",
        "num_valid_batches = len(valid_batches)\n",
        "X_test, Y_test = [], []\n",
        "\n",
        "for i in range(num_valid_batches):\n",
        "    data = valid_batches.next()\n",
        "    X_test.append(data[0])\n",
        "    Y_test.append(data[1])\n",
        "\n",
        "X_test = np.concatenate(X_test)\n",
        "Y_test = np.concatenate(Y_test)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FJceTLp3DGeY",
        "outputId": "f3eeb8b4-507b-460d-a62f-e3ee9b1287e5"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Downloading data from https://storage.googleapis.com/tensorflow/keras-applications/xception/xception_weights_tf_dim_ordering_tf_kernels_notop.h5\n",
            "83683744/83683744 [==============================] - 3s 0us/step\n",
            "72/72 [==============================] - 14s 127ms/step\n",
            "8/8 [==============================] - 3s 430ms/step\n"
          ]
        }
      ],
      "source": [
        "import tensorflow as tf\n",
        "base_model = tf.keras.applications.Xception(input_shape=(224, 224, 3),\n",
        "                                               include_top=False,\n",
        "                                               weights='imagenet')\n",
        "base_output1=base_model.get_layer('add_11').output\n",
        "out=tf.keras.layers.GlobalAveragePooling2D()(base_output1)\n",
        "model = tf.keras.models.Model(inputs=base_model.input, outputs=out)\n",
        "\n",
        "# Extract features using the pre-trained model\n",
        "X_train_features = model.predict(X_train)\n",
        "X_test_features = model.predict(X_test)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "95ox_8IhDGbK",
        "outputId": "37535fec-835e-4f57-ebb6-75dc276155f1"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(2276, 1024)"
            ]
          },
          "execution_count": 6,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "X_train_features.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6KrJwRZWDGYu"
      },
      "outputs": [],
      "source": [
        "\n",
        "# Flatten the extracted features\n",
        "X_train_features = X_train_features.reshape(X_train_features.shape[0], -1)\n",
        "X_test_features = X_test_features.reshape(X_test_features.shape[0], -1)\n",
        "X_train =X_train_features\n",
        "X_test = X_test_features"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ITQObw5iDGV2"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "from sklearn.datasets import make_classification\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.svm import SVC\n",
        "from sklearn.metrics import accuracy_score\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "jIcd-WHu_oG3"
      },
      "outputs": [],
      "source": [
        "Y_train=np.argmax(Y_train, axis=1)\n",
        "Y_test=np.argmax(Y_test, axis=1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### SVM only with extracted features from Xception"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ONTtDMX90rjr",
        "outputId": "2ad28d8a-f805-46af-d33e-892a6102fb5e"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Accuracy on Train Set: 0.9569420035149385\n",
            "Accuracy on Test Set: 0.8844621513944223\n"
          ]
        }
      ],
      "source": [
        "# Train SVM classifier with extracted features\n",
        "clf = SVC()\n",
        "clf.fit(X_train_features, Y_train)\n",
        "\n",
        "y_pred = clf.predict(X_train_features)\n",
        "accuracy = accuracy_score(Y_train, y_pred)\n",
        "\n",
        "print(\"Accuracy on Train Set:\", accuracy)\n",
        "# Evaluate on the test set\n",
        "y_pred = clf.predict(X_test_features)\n",
        "accuracy = accuracy_score(Y_test, y_pred)\n",
        "\n",
        "print(\"Accuracy on Test Set:\", accuracy)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Tring GeneticAlgorithm then SVM "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SDfVyXheDGTZ",
        "outputId": "bec5ae7e-ec6f-4616-d0ff-60e30f18ad8c"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Selected Features: [   0    1    2    5    8   10   12   14   17   19   21   23   25   27\n",
            "   30   33   34   35   36   39   40   42   46   49   51   52   53   54\n",
            "   60   61   63   66   67   68   72   78   83   89   90   91   93   97\n",
            "   99  103  104  110  112  114  115  122  123  124  125  126  128  129\n",
            "  130  134  140  141  142  149  150  151  153  157  159  163  164  165\n",
            "  166  169  172  173  178  179  180  181  183  188  190  192  194  196\n",
            "  197  199  200  204  206  209  211  215  218  219  220  221  223  228\n",
            "  230  231  232  233  234  237  238  241  244  248  249  250  251  252\n",
            "  255  256  258  261  263  264  267  274  275  276  277  279  280  281\n",
            "  283  284  286  287  288  289  290  291  296  300  301  303  304  306\n",
            "  308  309  314  315  316  318  322  323  324  325  327  329  330  333\n",
            "  334  338  339  340  341  342  344  345  346  348  350  351  352  355\n",
            "  356  358  359  361  362  363  364  367  368  370  371  372  375  376\n",
            "  380  383  386  387  388  393  394  395  396  399  400  402  405  406\n",
            "  408  410  413  414  415  416  418  420  421  424  427  428  429  433\n",
            "  435  437  438  440  442  443  446  447  450  451  452  455  456  457\n",
            "  460  463  465  468  469  472  473  480  481  482  483  484  485  487\n",
            "  489  491  492  493  497  499  500  501  506  508  509  516  520  521\n",
            "  524  526  529  531  533  535  536  537  540  549  550  552  553  556\n",
            "  557  559  560  563  564  566  567  569  570  571  572  580  581  582\n",
            "  583  584  585  586  588  590  592  596  602  605  606  608  611  612\n",
            "  613  614  617  620  621  623  624  626  628  631  634  635  639  641\n",
            "  642  643  644  645  646  647  648  650  651  655  657  658  662  667\n",
            "  673  675  676  677  679  684  685  686  688  690  691  693  694  696\n",
            "  697  698  703  705  707  708  713  716  717  718  721  723  724  727\n",
            "  728  729  731  733  736  737  741  742  743  744  747  748  754  755\n",
            "  756  760  761  765  767  768  769  771  772  777  779  780  782  786\n",
            "  787  789  792  795  796  797  799  804  805  808  809  810  811  813\n",
            "  815  818  819  821  822  826  827  830  832  834  835  836  837  842\n",
            "  844  845  849  851  854  855  856  858  859  861  862  863  864  865\n",
            "  866  868  872  876  880  883  886  888  889  890  892  893  895  896\n",
            "  897  898  899  900  901  902  903  904  905  906  907  912  915  918\n",
            "  920  921  925  927  929  934  937  938  940  941  943  948  952  953\n",
            "  954  955  958  961  962  964  966  967  968  971  972  974  975  977\n",
            "  980  985  986  987  989  990  991  993  995  997  999 1000 1002 1003\n",
            " 1004 1005 1006 1007 1009 1012 1013 1018 1023]\n",
            "Accuracy on Test Set: 0.8844621513944223\n"
          ]
        }
      ],
      "source": [
        "class GeneticAlgorithm:\n",
        "    def __init__(self, population_size, n_features, crossover_prob=0.8, mutation_prob=0.2, generations=6):\n",
        "        self.population_size = population_size\n",
        "        self.n_features = n_features\n",
        "        self.crossover_prob = crossover_prob\n",
        "        self.mutation_prob = mutation_prob\n",
        "        self.generations = generations\n",
        "\n",
        "    def initialize_population(self):\n",
        "        return np.random.randint(2, size=(self.population_size, self.n_features))\n",
        "\n",
        "    def evaluate_population(self, population, X_train, y_train):\n",
        "        accuracies = []\n",
        "        for solution in population:\n",
        "            selected_features = np.where(solution == 1)[0]\n",
        "            if len(selected_features) == 0:\n",
        "                accuracies.append(0.0)\n",
        "                continue\n",
        "\n",
        "            clf = SVC()\n",
        "            clf.fit(X_train[:, selected_features], y_train)\n",
        "            accuracy = accuracy_score(y_train, clf.predict(X_train[:, selected_features]))\n",
        "            accuracies.append(accuracy)\n",
        "\n",
        "        return np.array(accuracies)\n",
        "\n",
        "    def select_parents(self, population, fitness):\n",
        "        selected_indices = np.random.choice(self.population_size, size=(2, self.population_size), replace=True)\n",
        "        selected_parents = population[selected_indices[np.argmax(fitness[selected_indices], axis=0), np.arange(self.population_size)]]\n",
        "        return selected_parents\n",
        "\n",
        "    def crossover(self, parent1, parent2):\n",
        "        # Single-point crossover\n",
        "        crossover_point = np.random.randint(1, self.n_features)\n",
        "        child1 = np.concatenate((parent1[:crossover_point], parent2[crossover_point:]))\n",
        "        child2 = np.concatenate((parent2[:crossover_point], parent1[crossover_point:]))\n",
        "        return child1, child2\n",
        "\n",
        "    def mutate(self, child):\n",
        "        # Bit-flip mutation\n",
        "        mutation_mask = np.random.rand(self.n_features) < self.mutation_prob\n",
        "        child[mutation_mask] = 1 - child[mutation_mask]\n",
        "        return child\n",
        "\n",
        "    def run(self, X_train, y_train):\n",
        "        population = self.initialize_population()\n",
        "\n",
        "        for generation in range(self.generations):\n",
        "            fitness = self.evaluate_population(population, X_train, y_train)\n",
        "\n",
        "            # Select parents\n",
        "            parents = self.select_parents(population, fitness)\n",
        "\n",
        "            # Create offspring through crossover so we get the new population\n",
        "            offspring = []\n",
        "            for i in range(0, self.population_size, 2):\n",
        "                if np.random.rand() < self.crossover_prob:\n",
        "                    child1, child2 = self.crossover(parents[i], parents[i + 1])\n",
        "                else:\n",
        "                    child1, child2 = parents[i], parents[i + 1]\n",
        "\n",
        "                # Mutate children for the new generation\n",
        "                child1 = self.mutate(child1)\n",
        "                child2 = self.mutate(child2)\n",
        "\n",
        "                offspring.append(child1)\n",
        "                offspring.append(child2)\n",
        "\n",
        "            population[:self.population_size] = np.array(offspring)\n",
        "\n",
        "        # Select the best solution from the final population\n",
        "        final_fitness = self.evaluate_population(population, X_train, y_train)\n",
        "        best_solution = population[np.argmax(final_fitness)]\n",
        "\n",
        "        return best_solution\n",
        "\n",
        "\n",
        "population_size = 20\n",
        "\n",
        "ga = GeneticAlgorithm(population_size=population_size, n_features=X_train.shape[1])\n",
        "selected_features = ga.run(X_train, Y_train)\n",
        "\n",
        "# Train SVM classifier with selected features\n",
        "clf = SVC()\n",
        "clf.fit(X_train[:, selected_features == 1], Y_train)\n",
        "\n",
        "# Evaluate on the test set\n",
        "y_pred = clf.predict(X_test[:, selected_features == 1])\n",
        "accuracy = accuracy_score(Y_test, y_pred)\n",
        "\n",
        "print(\"Selected Features:\", np.where(selected_features == 1)[0])\n",
        "print(\"Accuracy on Test Set:\", accuracy)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "L2H4ErpeDGQd",
        "outputId": "dfaabf8d-4bd5-4063-e5fe-86fd8b45b69d"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(2276, 499)"
            ]
          },
          "execution_count": 15,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "X_train[:, selected_features == 1].shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sE78fzOH0mW_",
        "outputId": "516cfcac-dfda-4ab3-b50e-486964156863"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Accuracy on Train Set: 0.9560632688927944\n"
          ]
        }
      ],
      "source": [
        "y_pred_train = clf.predict(X_train[:, selected_features == 1])\n",
        "accuracy = accuracy_score(Y_train, y_pred_train)\n",
        "\n",
        "print(\"Accuracy on Train Set:\", accuracy)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Vu4IUuaHDGNp",
        "outputId": "003b0157-2ba0-45a8-8287-0035e7beb2f7"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[33  0  0  7  0  0]\n",
            " [ 0 44  1  2  3  0]\n",
            " [ 0  2 36  2  1  0]\n",
            " [ 2  1  0 56  0  0]\n",
            " [ 0  1  3  0 44  0]\n",
            " [ 0  0  2  0  2  9]]\n",
            "Precision: 0.8894179642481955\n",
            "Recall: 0.8844621513944223\n",
            "F1-score: 0.8838528810400361\n"
          ]
        }
      ],
      "source": [
        "# Evaluate the model and print the confusion matrix\n",
        "from sklearn.metrics import confusion_matrix, precision_score, recall_score, f1_score\n",
        "\n",
        "# Compute the confusion matrix\n",
        "confusion_mat = confusion_matrix(Y_test, y_pred)\n",
        "#print(\"Confusion Matrix:\")\n",
        "print(confusion_mat)\n",
        "\n",
        "precision = precision_score(Y_test, y_pred, average='weighted')\n",
        "recall = recall_score(Y_test, y_pred, average='weighted')\n",
        "f1 = f1_score(Y_test, y_pred, average='weighted')\n",
        "\n",
        "print(\"Precision:\", precision)\n",
        "print(\"Recall:\", recall)\n",
        "print(\"F1-score:\", f1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 718
        },
        "id": "aIAZsDMSz-Yp",
        "outputId": "51551f0f-8194-4717-a60e-50257e432266"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1000x800 with 2 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "import seaborn as sns\n",
        "import matplotlib.pyplot as plt\n",
        "# Plot the heatmap\n",
        "cfm = np.around(confusion_matrix(Y_test, y_pred, normalize='true'), decimals=2)\n",
        "plt.figure(figsize=(10, 8))\n",
        "sns.heatmap(confusion_mat, annot=True, fmt='d', cmap='Blues',\n",
        "            xticklabels=['cardboard', 'glass', 'metal', 'paper', 'plastic', 'trash'],\n",
        "            yticklabels=['cardboard', 'glass', 'metal', 'paper', 'plastic', 'trash'])\n",
        "plt.title('Confusion Matrix')\n",
        "plt.xlabel('Predicted')\n",
        "plt.ylabel('True')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zjv3OmVuz-VL",
        "outputId": "8dca81c4-53b6-4210-b5b0-d07548dd6c4a"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "              precision    recall  f1-score   support\n",
            "\n",
            "   cardboard       0.94      0.82      0.88        40\n",
            "       glass       0.92      0.88      0.90        50\n",
            "       metal       0.86      0.88      0.87        41\n",
            "       paper       0.84      0.95      0.89        59\n",
            "     plastic       0.88      0.92      0.90        48\n",
            "       trash       1.00      0.69      0.82        13\n",
            "\n",
            "    accuracy                           0.88       251\n",
            "   macro avg       0.91      0.86      0.88       251\n",
            "weighted avg       0.89      0.88      0.88       251\n",
            "\n"
          ]
        }
      ],
      "source": [
        "from sklearn.metrics import classification_report\n",
        "print(classification_report(Y_test, y_pred, target_names=['cardboard', 'glass', 'metal', 'paper', 'plastic', 'trash']))"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "gpuType": "T4",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}