"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# Paths to train, val, and test directories\n",
+ "train_dir = \"/content/drive/MyDrive/trash-dataset-split/train\"\n",
+ "test_dir = \"/content/drive/MyDrive/trash-dataset-split/test\"\n",
+ "\n",
+ "# Function to count images in each class\n",
+ "def count_images(directory):\n",
+ " class_counts = {}\n",
+ " for class_name in os.listdir(directory):\n",
+ " class_path = os.path.join(directory, class_name)\n",
+ " class_counts[class_name] = len(os.listdir(class_path))\n",
+ " return class_counts\n",
+ "\n",
+ "# Count images in each set\n",
+ "train_counts = count_images(train_dir)\n",
+ "test_counts = count_images(test_dir)\n",
+ "\n",
+ "# Create a DataFrame for visualization\n",
+ "df = pd.DataFrame({\n",
+ " 'Train': train_counts,\n",
+ " 'Test': test_counts\n",
+ "}).transpose()\n",
+ "\n",
+ "# Plot the class distribution\n",
+ "df.plot(kind='bar', figsize=(10, 6))\n",
+ "plt.title('Class Distribution Across Train, Validation, and Test Sets')\n",
+ "plt.ylabel('Number of Images')\n",
+ "plt.xlabel('Classes')\n",
+ "plt.xticks(rotation=45)\n",
+ "plt.bar_label(plt.gca().containers[0])\n",
+ "plt.bar_label(plt.gca().containers[1])\n",
+ "plt.bar_label(plt.gca().containers[2])\n",
+ "plt.bar_label(plt.gca().containers[3])\n",
+ "plt.bar_label(plt.gca().containers[4])\n",
+ "plt.bar_label(plt.gca().containers[5])\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "an2847W8adMk"
+ },
+ "source": [
+ "### Data Augmentation\n",
+ "\n",
+ "Data augmentation is used to increase the variability of the dataset and prevent overfitting by artificially generating new, modified versions of the existing images. The following techniques are applied to the images:\n",
+ "\n",
+ "- **Resize**: Adjusting the size of images to a consistent shape, ensuring compatibility with the model input requirements.\n",
+ "- **Rescale**: Normalizing pixel values to a consistent range, typically between 0 and 1, to improve model training stability.\n",
+ "- **Rotation**: Rotating images by random angles to create variations and make the model more invariant to orientation.\n",
+ "- **Zoom**: Applying random zooming to simulate closer or farther perspectives, helping the model generalize better across different scales.\n",
+ "\n",
+ "These augmentations help the model become more robust and improve its ability to generalize to new, unseen data by providing diverse, transformed versions of the same images."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "2TXVrC6svVuB",
+ "outputId": "2f02e2dd-9ea3-4d01-8036-dcd7ec758381"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Found 1983 images belonging to 6 classes.\n",
+ "Found 854 images belonging to 6 classes.\n"
+ ]
+ }
+ ],
+ "source": [
+ "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
+ "\n",
+ "train_datagen = ImageDataGenerator(\n",
+ " rescale=1./255,\n",
+ " rotation_range=40,\n",
+ " width_shift_range=0.3,\n",
+ " height_shift_range=0.3,\n",
+ " shear_range=0.3,\n",
+ " zoom_range=0.3,\n",
+ " horizontal_flip=True,\n",
+ " fill_mode=\"nearest\"\n",
+ ")\n",
+ "\n",
+ "val_datagen = ImageDataGenerator(rescale=1./255) # Only normalize\n",
+ "\n",
+ "# Define preprocessing pipeline for testing data (no augmentation)\n",
+ "test_datagen = ImageDataGenerator(rescale=1./255) # Only normalize\n",
+ "\n",
+ "# Apply to training and validation data\n",
+ "train_generator = train_datagen.flow_from_directory(\n",
+ " \"/content/drive/MyDrive/trash-dataset-split/train\",\n",
+ " target_size=(224, 224),\n",
+ " batch_size=32,\n",
+ " class_mode='categorical'\n",
+ ")\n",
+ "\n",
+ "\n",
+ "# Apply to testing data\n",
+ "test_generator = test_datagen.flow_from_directory(\n",
+ " \"/content/drive/MyDrive/trash-dataset-split/test\",\n",
+ " target_size=(224, 224),\n",
+ " batch_size=32,\n",
+ " class_mode='categorical',\n",
+ " shuffle=False # Important for testing to keep predictions aligned with data\n",
+ ")\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "G5RUTETNYBSZ"
+ },
+ "source": [
+ "## Modeling\n",
+ "\n",
+ "In this step, the machine learning model is built using a Convolutional Neural Network (CNN), which is well-suited for image classification tasks. The CNN is trained using the prepared dataset, where it learns to recognize patterns and features in the images. The process includes:\n",
+ "\n",
+ "- Training: The model learns from the training data by adjusting its weights to minimize the loss function.\n",
+ "- Testing: After training, the model is evaluated on a separate test set to assess its generalization ability to new, unseen data.\n",
+ "- Evaluation: The model's performance is further evaluated using metrics such as accuracy, precision, recall, and F1-score to understand how well it classifies the different classes of trash.\n",
+ "\n",
+ "CNNs are particularly effective for image data because they automatically learn spatial hierarchies and patterns, making them highly suitable for this classification task."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "voS_YHGL0Puy"
+ },
+ "source": [
+ "### Build the model"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {
+ "id": "qYQay2DqRfPP"
+ },
+ "outputs": [],
+ "source": [
+ "from tensorflow.keras.models import Sequential\n",
+ "from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout, BatchNormalization\n",
+ "from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau\n",
+ "from tqdm import tqdm\n",
+ "from keras.layers import Conv2D, MaxPooling2D , BatchNormalization ,Dropout ,Flatten , Dense , Input , Rescaling , Resizing\n",
+ "from keras.models import Sequential\n",
+ "from tensorflow.keras.preprocessing.image import ImageDataGenerator, array_to_img, img_to_array, load_img\n",
+ "from tensorflow.keras.applications import MobileNetV2"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "YphHfzYcg6U0"
+ },
+ "source": [
+ "### Model 1 - CNN"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 604
+ },
+ "id": "_8nAB4Ntvzco",
+ "outputId": "bc2dc0ae-b391-418f-acbd-83c9d24017d2"
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "Model: \"sequential_2\" \n",
+ "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┓\n",
+ "┃ Layer (type) ┃ Output Shape ┃ Param # ┃\n",
+ "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━┩\n",
+ "│ conv2d_7 (Conv2D ) │ (None , 222 , 222 , 32 ) │ 896 │\n",
+ "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
+ "│ batch_normalization │ (None , 222 , 222 , 32 ) │ 128 │\n",
+ "│ (BatchNormalization ) │ │ │\n",
+ "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
+ "│ max_pooling2d_6 (MaxPooling2D ) │ (None , 111 , 111 , 32 ) │ 0 │\n",
+ "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
+ "│ conv2d_8 (Conv2D ) │ (None , 109 , 109 , 64 ) │ 18,496 │\n",
+ "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
+ "│ batch_normalization_1 │ (None , 109 , 109 , 64 ) │ 256 │\n",
+ "│ (BatchNormalization ) │ │ │\n",
+ "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
+ "│ max_pooling2d_7 (MaxPooling2D ) │ (None , 54 , 54 , 64 ) │ 0 │\n",
+ "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
+ "│ conv2d_9 (Conv2D ) │ (None , 52 , 52 , 128 ) │ 73,856 │\n",
+ "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
+ "│ batch_normalization_2 │ (None , 52 , 52 , 128 ) │ 512 │\n",
+ "│ (BatchNormalization ) │ │ │\n",
+ "├────────────────────���─────────────────┼─────────────────────────────┼─────────────────┤\n",
+ "│ max_pooling2d_8 (MaxPooling2D ) │ (None , 26 , 26 , 128 ) │ 0 │\n",
+ "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
+ "│ flatten_2 (Flatten ) │ (None , 86528 ) │ 0 │\n",
+ "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
+ "│ dense_4 (Dense ) │ (None , 128 ) │ 11,075,712 │\n",
+ "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
+ "│ dropout_2 (Dropout ) │ (None , 128 ) │ 0 │\n",
+ "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
+ "│ dense_5 (Dense ) │ (None , 6 ) │ 774 │\n",
+ "└──────────────────────────────────────┴─────────────────────────────┴─────────────────┘\n",
+ " \n"
+ ],
+ "text/plain": [
+ "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┓\n",
+ "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n",
+ "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━┩\n",
+ "│ conv2d_7 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m222\u001b[0m, \u001b[38;5;34m222\u001b[0m, \u001b[38;5;34m32\u001b[0m) │ \u001b[38;5;34m896\u001b[0m │\n",
+ "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
+ "│ batch_normalization │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m222\u001b[0m, \u001b[38;5;34m222\u001b[0m, \u001b[38;5;34m32\u001b[0m) │ \u001b[38;5;34m128\u001b[0m │\n",
+ "│ (\u001b[38;5;33mBatchNormalization\u001b[0m) │ │ │\n",
+ "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
+ "│ max_pooling2d_6 (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m111\u001b[0m, \u001b[38;5;34m111\u001b[0m, \u001b[38;5;34m32\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n",
+ "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
+ "│ conv2d_8 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m109\u001b[0m, \u001b[38;5;34m109\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m18,496\u001b[0m │\n",
+ "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
+ "│ batch_normalization_1 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m109\u001b[0m, \u001b[38;5;34m109\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m256\u001b[0m │\n",
+ "│ (\u001b[38;5;33mBatchNormalization\u001b[0m) │ │ │\n",
+ "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
+ "│ max_pooling2d_7 (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m54\u001b[0m, \u001b[38;5;34m54\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n",
+ "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
+ "│ conv2d_9 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m52\u001b[0m, \u001b[38;5;34m52\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m73,856\u001b[0m │\n",
+ "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
+ "│ batch_normalization_2 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m52\u001b[0m, \u001b[38;5;34m52\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m512\u001b[0m │\n",
+ "│ (\u001b[38;5;33mBatchNormalization\u001b[0m) │ │ │\n",
+ "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
+ "│ max_pooling2d_8 (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m26\u001b[0m, \u001b[38;5;34m26\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n",
+ "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
+ "│ flatten_2 (\u001b[38;5;33mFlatten\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m86528\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n",
+ "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
+ "│ dense_4 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m11,075,712\u001b[0m │\n",
+ "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
+ "│ dropout_2 (\u001b[38;5;33mDropout\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n",
+ "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
+ "│ dense_5 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m6\u001b[0m) │ \u001b[38;5;34m774\u001b[0m │\n",
+ "└──────────────────────────────────────┴─────────────────────────────┴─────────────────┘\n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ " Total params: 11,170,630 (42.61 MB)\n",
+ " Trainable params: 11,170,182 (42.61 MB)\n",
+ " Non-trainable params: 448 (1.75 KB)\n",
+ "\n",
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " accuracy \n",
+ " loss \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " 0 \n",
+ " 0.256526 \n",
+ " 1.753953 \n",
+ " \n",
+ " \n",
+ " 1 \n",
+ " 0.325803 \n",
+ " 1.571592 \n",
+ " \n",
+ " \n",
+ " 2 \n",
+ " 0.370482 \n",
+ " 1.514232 \n",
+ " \n",
+ " \n",
+ " 3 \n",
+ " 0.447791 \n",
+ " 1.384248 \n",
+ " \n",
+ " \n",
+ " 4 \n",
+ " 0.482932 \n",
+ " 1.338613 \n",
+ " \n",
+ " \n",
+ " 5 \n",
+ " 0.499498 \n",
+ " 1.271995 \n",
+ " \n",
+ " \n",
+ " 6 \n",
+ " 0.522590 \n",
+ " 1.252261 \n",
+ " \n",
+ " \n",
+ " 7 \n",
+ " 0.537149 \n",
+ " 1.238903 \n",
+ " \n",
+ " \n",
+ " 8 \n",
+ " 0.528614 \n",
+ " 1.242952 \n",
+ " \n",
+ " \n",
+ " 9 \n",
+ " 0.531124 \n",
+ " 1.252145 \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " accuracy \n",
+ " loss \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " 1 \n",
+ " 0.772088 \n",
+ " 0.622041 \n",
+ " \n",
+ " \n",
+ " 2 \n",
+ " 0.813755 \n",
+ " 0.503027 \n",
+ " \n",
+ " \n",
+ " 3 \n",
+ " 0.838855 \n",
+ " 0.430794 \n",
+ " \n",
+ " \n",
+ " 4 \n",
+ " 0.847892 \n",
+ " 0.410495 \n",
+ " \n",
+ " \n",
+ " 5 \n",
+ " 0.861948 \n",
+ " 0.383442 \n",
+ " \n",
+ " \n",
+ " 6 \n",
+ " 0.873494 \n",
+ " 0.346290 \n",
+ " \n",
+ " \n",
+ " 7 \n",
+ " 0.889056 \n",
+ " 0.310011 \n",
+ " \n",
+ " \n",
+ " 8 \n",
+ " 0.901606 \n",
+ " 0.280084 \n",
+ " \n",
+ " \n",
+ " 9 \n",
+ " 0.905622 \n",
+ " 0.263584 \n",
+ " \n",
+ " \n",
+ " 10 \n",
+ " 0.903112 \n",
+ " 0.263178 \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ "
"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "# Assuming 'accuracy' and 'loss' are already defined from your training history\n",
+ "\n",
+ "# Get the actual number of epochs from the accuracy list\n",
+ "epochs = range(1, len(accuracy) + 1)\n",
+ "\n",
+ "plt.figure(figsize=(12, 6))\n",
+ "plt.plot(epochs, accuracy, 'b-', label='Accuracy_Training')\n",
+ "plt.plot(epochs, loss, 'r-', label='Loss_Training')\n",
+ "plt.title('Accuracy')\n",
+ "plt.xlabel('Epochs')\n",
+ "plt.ylabel('Accuracy')\n",
+ "plt.legend()\n",
+ "plt.grid(True)\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 881
+ },
+ "id": "qfYp_Dz4OuEe",
+ "outputId": "d3494805-3d52-4480-90fc-c602d59e0a69"
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "# Plot training & validation accuracy\n",
+ "plt.plot(history.history['accuracy'], label='Training Accuracy')\n",
+ "plt.plot(history.history['val_accuracy'], label='Validation Accuracy')\n",
+ "plt.xlabel('Epochs')\n",
+ "plt.ylabel('Accuracy')\n",
+ "plt.legend()\n",
+ "plt.show()\n",
+ "\n",
+ "# Plot training & validation loss\n",
+ "plt.plot(history.history['loss'], label='Training Loss')\n",
+ "plt.plot(history.history['val_loss'], label='Validation Loss')\n",
+ "plt.xlabel('Epochs')\n",
+ "plt.ylabel('Loss')\n",
+ "plt.legend()\n",
+ "plt.show()\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Z3Mxn9-1hpWH"
+ },
+ "source": [
+ "#### Early stop patient 5"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "os3JJmMRJoTP"
+ },
+ "source": [
+ "Training"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "collapsed": true,
+ "id": "S9enjiXKhs_S",
+ "outputId": "c9d93881-11ee-40c5-cea5-e94c13c683ff"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 1/50\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/usr/local/lib/python3.10/dist-packages/keras/src/trainers/data_adapters/py_dataset_adapter.py:122: UserWarning: Your `PyDataset` class should call `super().__init__(**kwargs)` in its constructor. `**kwargs` can include `workers`, `use_multiprocessing`, `max_queue_size`. Do not pass these arguments to `fit()`, as they will be ignored.\n",
+ " self._warn_if_super_not_called()\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\u001b[1m62/62\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m763s\u001b[0m 11s/step - accuracy: 0.5515 - loss: 1.3716 - val_accuracy: 0.7190 - val_loss: 1.0247\n",
+ "Epoch 2/50\n",
+ "\u001b[1m62/62\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m37s\u001b[0m 546ms/step - accuracy: 0.7491 - loss: 0.6951 - val_accuracy: 0.7143 - val_loss: 0.9199\n",
+ "Epoch 3/50\n",
+ "\u001b[1m62/62\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m40s\u001b[0m 547ms/step - accuracy: 0.8019 - loss: 0.5341 - val_accuracy: 0.7564 - val_loss: 0.7435\n",
+ "Epoch 4/50\n",
+ "\u001b[1m62/62\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 540ms/step - accuracy: 0.8128 - loss: 0.5309 - val_accuracy: 0.8173 - val_loss: 0.5737\n",
+ "Epoch 5/50\n",
+ "\u001b[1m62/62\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m38s\u001b[0m 521ms/step - accuracy: 0.8526 - loss: 0.4110 - val_accuracy: 0.8115 - val_loss: 0.6352\n",
+ "Epoch 6/50\n",
+ "\u001b[1m62/62\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m36s\u001b[0m 524ms/step - accuracy: 0.8657 - loss: 0.3768 - val_accuracy: 0.7775 - val_loss: 0.7478\n",
+ "Epoch 7/50\n",
+ "\u001b[1m62/62\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m42s\u001b[0m 546ms/step - accuracy: 0.8811 - loss: 0.3368 - val_accuracy: 0.7998 - val_loss: 0.6051\n",
+ "Epoch 8/50\n",
+ "\u001b[1m62/62\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 549ms/step - accuracy: 0.8743 - loss: 0.3392 - val_accuracy: 0.8279 - val_loss: 0.5142\n",
+ "Epoch 9/50\n",
+ "\u001b[1m62/62\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m40s\u001b[0m 528ms/step - accuracy: 0.8937 - loss: 0.2901 - val_accuracy: 0.8220 - val_loss: 0.5474\n",
+ "Epoch 10/50\n",
+ "\u001b[1m62/62\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m42s\u001b[0m 541ms/step - accuracy: 0.9077 - loss: 0.2604 - val_accuracy: 0.8560 - val_loss: 0.4724\n",
+ "Epoch 11/50\n",
+ "\u001b[1m62/62\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m42s\u001b[0m 554ms/step - accuracy: 0.9109 - loss: 0.2564 - val_accuracy: 0.8326 - val_loss: 0.5506\n",
+ "Epoch 12/50\n",
+ "\u001b[1m62/62\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m37s\u001b[0m 534ms/step - accuracy: 0.9135 - loss: 0.2342 - val_accuracy: 0.8489 - val_loss: 0.5004\n",
+ "Epoch 13/50\n",
+ "\u001b[1m62/62\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m43s\u001b[0m 558ms/step - accuracy: 0.9195 - loss: 0.2115 - val_accuracy: 0.8454 - val_loss: 0.5766\n",
+ "Epoch 14/50\n",
+ "\u001b[1m62/62\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m37s\u001b[0m 542ms/step - accuracy: 0.9247 - loss: 0.2251 - val_accuracy: 0.8665 - val_loss: 0.4770\n",
+ "Epoch 15/50\n",
+ "\u001b[1m62/62\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m37s\u001b[0m 553ms/step - accuracy: 0.9349 - loss: 0.1981 - val_accuracy: 0.8794 - val_loss: 0.4359\n",
+ "Epoch 16/50\n",
+ "\u001b[1m62/62\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m38s\u001b[0m 553ms/step - accuracy: 0.9281 - loss: 0.1983 - val_accuracy: 0.8700 - val_loss: 0.4481\n",
+ "Epoch 17/50\n",
+ "\u001b[1m62/62\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m40s\u001b[0m 530ms/step - accuracy: 0.9270 - loss: 0.2159 - val_accuracy: 0.8525 - val_loss: 0.5013\n",
+ "Epoch 18/50\n",
+ "\u001b[1m62/62\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m37s\u001b[0m 551ms/step - accuracy: 0.9408 - loss: 0.1726 - val_accuracy: 0.8700 - val_loss: 0.4718\n",
+ "Epoch 19/50\n",
+ "\u001b[1m62/62\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m39s\u001b[0m 526ms/step - accuracy: 0.9299 - loss: 0.1861 - val_accuracy: 0.8607 - val_loss: 0.5316\n",
+ "Epoch 20/50\n",
+ "\u001b[1m62/62\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m42s\u001b[0m 548ms/step - accuracy: 0.9501 - loss: 0.1632 - val_accuracy: 0.8841 - val_loss: 0.4784\n",
+ "Epoch 21/50\n",
+ "\u001b[1m62/62\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m36s\u001b[0m 522ms/step - accuracy: 0.9424 - loss: 0.1749 - val_accuracy: 0.8618 - val_loss: 0.5027\n",
+ "Epoch 22/50\n",
+ "\u001b[1m62/62\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 520ms/step - accuracy: 0.9417 - loss: 0.1583 - val_accuracy: 0.8560 - val_loss: 0.5404\n",
+ "Epoch 23/50\n",
+ "\u001b[1m62/62\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m36s\u001b[0m 529ms/step - accuracy: 0.9549 - loss: 0.1503 - val_accuracy: 0.8864 - val_loss: 0.4767\n",
+ "Epoch 24/50\n",
+ "\u001b[1m62/62\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m48s\u001b[0m 655ms/step - accuracy: 0.9428 - loss: 0.1561 - val_accuracy: 0.8934 - val_loss: 0.4527\n",
+ "Epoch 25/50\n",
+ "\u001b[1m62/62\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m36s\u001b[0m 531ms/step - accuracy: 0.9430 - loss: 0.1566 - val_accuracy: 0.8923 - val_loss: 0.5201\n",
+ "Epoch 26/50\n",
+ "\u001b[1m62/62\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m36s\u001b[0m 524ms/step - accuracy: 0.9467 - loss: 0.1652 - val_accuracy: 0.8817 - val_loss: 0.5184\n",
+ "Epoch 27/50\n",
+ "\u001b[1m62/62\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m37s\u001b[0m 521ms/step - accuracy: 0.9453 - loss: 0.1560 - val_accuracy: 0.8958 - val_loss: 0.4461\n",
+ "Epoch 28/50\n",
+ "\u001b[1m62/62\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 531ms/step - accuracy: 0.9566 - loss: 0.1310 - val_accuracy: 0.8689 - val_loss: 0.5695\n",
+ "Epoch 29/50\n",
+ "\u001b[1m62/62\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 540ms/step - accuracy: 0.9473 - loss: 0.1312 - val_accuracy: 0.8806 - val_loss: 0.5152\n",
+ "Epoch 30/50\n",
+ "\u001b[1m62/62\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m38s\u001b[0m 568ms/step - accuracy: 0.9629 - loss: 0.1140 - val_accuracy: 0.9040 - val_loss: 0.4945\n",
+ "Epoch 31/50\n",
+ "\u001b[1m62/62\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m38s\u001b[0m 524ms/step - accuracy: 0.9542 - loss: 0.1351 - val_accuracy: 0.8864 - val_loss: 0.5638\n",
+ "Epoch 32/50\n",
+ "\u001b[1m62/62\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m37s\u001b[0m 521ms/step - accuracy: 0.9528 - loss: 0.1473 - val_accuracy: 0.8806 - val_loss: 0.5033\n",
+ "Epoch 33/50\n",
+ "\u001b[1m62/62\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 523ms/step - accuracy: 0.9572 - loss: 0.1323 - val_accuracy: 0.8981 - val_loss: 0.4956\n",
+ "Epoch 34/50\n",
+ "\u001b[1m62/62\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m36s\u001b[0m 529ms/step - accuracy: 0.9644 - loss: 0.1096 - val_accuracy: 0.8923 - val_loss: 0.4951\n",
+ "Epoch 35/50\n",
+ "\u001b[1m62/62\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m37s\u001b[0m 519ms/step - accuracy: 0.9550 - loss: 0.1249 - val_accuracy: 0.8981 - val_loss: 0.4824\n"
+ ]
+ }
+ ],
+ "source": [
+ "history = Model.fit(train_generator,\n",
+ " validation_data = test_generator,\n",
+ " epochs=50,\n",
+ " verbose=1,\n",
+ " callbacks=[tf.keras.callbacks.EarlyStopping(\n",
+ " patience=5,\n",
+ " monitor='val_accuracy',\n",
+ " restore_best_weights=True)])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 363
+ },
+ "id": "NyEwE8wVh6Yy",
+ "outputId": "aca3732b-ad56-40cd-f3fc-c22feca32245"
+ },
+ "outputs": [
+ {
+ "data": {
+ "application/vnd.google.colaboratory.intrinsic+json": {
+ "summary": "{\n \"name\": \"cnn\",\n \"rows\": 10,\n \"fields\": [\n {\n \"column\": \"accuracy\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.006246502012689804,\n \"min\": 0.9379727840423584,\n \"max\": 0.9616742134094238,\n \"num_unique_values\": 8,\n \"samples\": [\n 0.9490670561790466,\n 0.9576399326324463,\n 0.9379727840423584\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"loss\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.017344667970217643,\n \"min\": 0.1165943592786789,\n \"max\": 0.17645184695720673,\n \"num_unique_values\": 10,\n \"samples\": [\n 0.1165943592786789,\n 0.15174877643585205,\n 0.13891401886940002\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}",
+ "type": "dataframe"
+ },
+ "text/html": [
+ "\n",
+ " \n",
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " accuracy \n",
+ " loss \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " 25 \n",
+ " 0.937973 \n",
+ " 0.176452 \n",
+ " \n",
+ " \n",
+ " 26 \n",
+ " 0.949067 \n",
+ " 0.151749 \n",
+ " \n",
+ " \n",
+ " 27 \n",
+ " 0.955119 \n",
+ " 0.137027 \n",
+ " \n",
+ " \n",
+ " 28 \n",
+ " 0.953606 \n",
+ " 0.122689 \n",
+ " \n",
+ " \n",
+ " 29 \n",
+ " 0.953606 \n",
+ " 0.129094 \n",
+ " \n",
+ " \n",
+ " 30 \n",
+ " 0.952093 \n",
+ " 0.138914 \n",
+ " \n",
+ " \n",
+ " 31 \n",
+ " 0.957640 \n",
+ " 0.135928 \n",
+ " \n",
+ " \n",
+ " 32 \n",
+ " 0.955119 \n",
+ " 0.124397 \n",
+ " \n",
+ " \n",
+ " 33 \n",
+ " 0.961674 \n",
+ " 0.116594 \n",
+ " \n",
+ " \n",
+ " 34 \n",
+ " 0.954614 \n",
+ " 0.127195 \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ "
"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "# Plot training & validation accuracy\n",
+ "plt.plot(history.history['accuracy'], 'b-', label='Training Accuracy')\n",
+ "plt.plot(history.history['val_accuracy'], 'r-', label='Validation Accuracy')\n",
+ "plt.xlabel('Epochs')\n",
+ "plt.ylabel('Accuracy')\n",
+ "plt.legend()\n",
+ "plt.show()\n",
+ "\n",
+ "# Plot training & validation loss\n",
+ "plt.plot(history.history['loss'], 'b-', label='Training Loss')\n",
+ "plt.plot(history.history['val_loss'], 'r-', label='Validation Loss')\n",
+ "plt.xlabel('Epochs')\n",
+ "plt.ylabel('Loss')\n",
+ "plt.legend()\n",
+ "plt.show()\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "1iWKeq6ugkut"
+ },
+ "source": [
+ "### Model 3"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "Tb4huvNcvy12",
+ "outputId": "2ea78cec-f8ba-40e3-877a-f563443de497"
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/usr/local/lib/python3.10/dist-packages/keras/src/layers/convolutional/base_conv.py:107: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.\n",
+ " super().__init__(activity_regularizer=activity_regularizer, **kwargs)\n"
+ ]
+ }
+ ],
+ "source": [
+ "# CNN model 2\n",
+ "\n",
+ "cnn = tf.keras.models.Sequential()\n",
+ "cnn.add(tf.keras.layers.Conv2D(\n",
+ " filters = 32, kernel_size = 3,\n",
+ " activation = 'relu',\n",
+ " input_shape = (224,224,3)))\n",
+ "cnn.add(tf.keras.layers.MaxPool2D(pool_size = 2, strides = 2))\n",
+ "cnn.add(tf.keras.layers.Conv2D(filters = 32, kernel_size = 3, activation = 'relu'))\n",
+ "cnn.add(tf.keras.layers.MaxPool2D(pool_size = 2, strides = 2))\n",
+ "cnn.add(tf.keras.layers.Flatten())\n",
+ "cnn.add(tf.keras.layers.Dense(units = 128, activation = 'relu'))\n",
+ "cnn.add(tf.keras.layers.Dense(units = 6, activation = 'softmax')) # Changed units to 6 and activation to softmax\n",
+ "cnn.compile(optimizer = 'adam', loss = 'categorical_crossentropy', metrics = ['accuracy']) # Changed loss to categorical_crossentropy"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "HnYWpdPFfGbS",
+ "outputId": "fa96cdc7-5686-46f5-8c1e-6dfdae1f5e41"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 1/10\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/usr/local/lib/python3.10/dist-packages/keras/src/trainers/data_adapters/py_dataset_adapter.py:122: UserWarning: Your `PyDataset` class should call `super().__init__(**kwargs)` in its constructor. `**kwargs` can include `workers`, `use_multiprocessing`, `max_queue_size`. Do not pass these arguments to `fit()`, as they will be ignored.\n",
+ " self._warn_if_super_not_called()\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m551s\u001b[0m 8s/step - accuracy: 0.1907 - loss: 4.0336 - val_accuracy: 0.1794 - val_loss: 1.7996\n",
+ "Epoch 2/10\n",
+ "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m196s\u001b[0m 3s/step - accuracy: 0.3344 - loss: 1.6001 - val_accuracy: 0.2797 - val_loss: 1.9912\n",
+ "Epoch 3/10\n",
+ "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m185s\u001b[0m 3s/step - accuracy: 0.3891 - loss: 1.4737 - val_accuracy: 0.2243 - val_loss: 1.8803\n",
+ "Epoch 4/10\n",
+ "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m186s\u001b[0m 3s/step - accuracy: 0.4333 - loss: 1.3953 - val_accuracy: 0.2322 - val_loss: 1.8124\n",
+ "Epoch 5/10\n",
+ "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m206s\u001b[0m 3s/step - accuracy: 0.4898 - loss: 1.2983 - val_accuracy: 0.2665 - val_loss: 2.0413\n",
+ "Epoch 6/10\n",
+ "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m185s\u001b[0m 3s/step - accuracy: 0.4497 - loss: 1.3549 - val_accuracy: 0.3193 - val_loss: 1.9183\n",
+ "Epoch 7/10\n",
+ "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m198s\u001b[0m 3s/step - accuracy: 0.4524 - loss: 1.4105 - val_accuracy: 0.3298 - val_loss: 1.9739\n",
+ "Epoch 8/10\n",
+ "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m215s\u001b[0m 3s/step - accuracy: 0.4634 - loss: 1.3774 - val_accuracy: 0.2665 - val_loss: 2.1509\n",
+ "Epoch 9/10\n",
+ "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m182s\u001b[0m 3s/step - accuracy: 0.4723 - loss: 1.3413 - val_accuracy: 0.3193 - val_loss: 1.9020\n",
+ "Epoch 10/10\n",
+ "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m205s\u001b[0m 3s/step - accuracy: 0.5126 - loss: 1.2927 - val_accuracy: 0.3034 - val_loss: 2.0162\n"
+ ]
+ }
+ ],
+ "source": [
+ "history = cnn.fit(\n",
+ " train_generator,\n",
+ " epochs=10,\n",
+ " validation_data= val_generator\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 363
+ },
+ "id": "xmDNLzJ4Ajf1",
+ "outputId": "5edfc85c-10e4-408b-b3a0-297d7f956ddd"
+ },
+ "outputs": [
+ {
+ "data": {
+ "application/vnd.google.colaboratory.intrinsic+json": {
+ "summary": "{\n \"name\": \"cnn\",\n \"rows\": 10,\n \"fields\": [\n {\n \"column\": \"accuracy\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.08205977896555748,\n \"min\": 0.23945783078670502,\n \"max\": 0.5145582556724548,\n \"num_unique_values\": 10,\n \"samples\": [\n 0.48242971301078796,\n 0.34337350726127625,\n 0.4091365337371826\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"loss\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.3394082655568192,\n \"min\": 1.2634320259094238,\n \"max\": 2.436384439468384,\n \"num_unique_values\": 10,\n \"samples\": [\n 1.3464854955673218,\n 1.5697758197784424,\n 1.4287445545196533\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}",
+ "type": "dataframe"
+ },
+ "text/html": [
+ "\n",
+ " \n",
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " accuracy \n",
+ " loss \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " 0 \n",
+ " 0.239458 \n",
+ " 2.436384 \n",
+ " \n",
+ " \n",
+ " 1 \n",
+ " 0.343374 \n",
+ " 1.569776 \n",
+ " \n",
+ " \n",
+ " 2 \n",
+ " 0.409639 \n",
+ " 1.444193 \n",
+ " \n",
+ " \n",
+ " 3 \n",
+ " 0.441265 \n",
+ " 1.395567 \n",
+ " \n",
+ " \n",
+ " 4 \n",
+ " 0.492470 \n",
+ " 1.315588 \n",
+ " \n",
+ " \n",
+ " 5 \n",
+ " 0.409137 \n",
+ " 1.428745 \n",
+ " \n",
+ " \n",
+ " 6 \n",
+ " 0.446285 \n",
+ " 1.437051 \n",
+ " \n",
+ " \n",
+ " 7 \n",
+ " 0.474398 \n",
+ " 1.363992 \n",
+ " \n",
+ " \n",
+ " 8 \n",
+ " 0.482430 \n",
+ " 1.346485 \n",
+ " \n",
+ " \n",
+ " 9 \n",
+ " 0.514558 \n",
+ " 1.263432 \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ "
"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "from sklearn.metrics import classification_report, confusion_matrix\n",
+ "import matplotlib.pyplot as plt\n",
+ "import seaborn as sns\n",
+ "\n",
+ "# Get true labels and predictions from the test generator\n",
+ "y_true = test_generator.classes\n",
+ "y_pred = loaded_model.predict(test_generator)\n",
+ "y_pred_classes = np.argmax(y_pred, axis=1)\n",
+ "\n",
+ "# Generate classification report\n",
+ "print(\"Classification Report:\")\n",
+ "print(classification_report(y_true, y_pred_classes, target_names=test_generator.class_indices.keys()))\n",
+ "\n",
+ "# Generate confusion matrix\n",
+ "cm = confusion_matrix(y_true, y_pred_classes)\n",
+ "plt.figure(figsize=(8, 6))\n",
+ "sns.heatmap(cm, annot=True, fmt=\"d\", cmap=\"Blues\", xticklabels=test_generator.class_indices.keys(), yticklabels=test_generator.class_indices.keys())\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": "KrllwR2WeQgs",
+ "outputId": "5ab61b09-ab13-439a-cc45-c1889ccb449f"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 2s/step\n",
+ "Predicted Class: 5\n",
+ "Class Probabilities: [[0.1358134 0.00438217 0.00835587 0.06250051 0.14169186 0.64725614]]\n"
+ ]
+ }
+ ],
+ "source": [
+ "import numpy as np\n",
+ "from tensorflow.keras.preprocessing import image\n",
+ "\n",
+ "# Load a single image for testing\n",
+ "img_path = \"/content/drive/MyDrive/split/test/paper/paper1.jpg\" # Replace with the path to your test image\n",
+ "img = image.load_img(img_path, target_size=(224, 224)) # Resize to match model input size\n",
+ "img_array = image.img_to_array(img)\n",
+ "img_array = np.expand_dims(img_array, axis=0) # Add batch dimension\n",
+ "img_array = img_array / 255.0 # Normalize\n",
+ "\n",
+ "# Make prediction\n",
+ "predictions = loaded_model.predict(img_array)\n",
+ "predicted_class = np.argmax(predictions[0]) # Get the class with highest probability\n",
+ "\n",
+ "print(f\"Predicted Class: {predicted_class}\")\n",
+ "print(f\"Class Probabilities: {predictions}\")\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "p8PypQPbIIaA"
+ },
+ "source": [
+ "#### Model 2 - CNN Mobilenetv2"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "S7KdW3SmIIaC",
+ "outputId": "1db31816-54b4-4770-9eb2-5be42140534d"
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "WARNING:absl:Compiled the loaded model, but the compiled metrics have yet to be built. `model.compile_metrics` will be empty until you train or evaluate the model.\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\u001b[1m27/27\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 183ms/step - accuracy: 0.8926 - loss: 0.5696\n",
+ "Test Loss: 0.4945\n",
+ "Test Accuracy: 0.9040\n"
+ ]
+ }
+ ],
+ "source": [
+ "from tensorflow.keras.models import load_model\n",
+ "\n",
+ "loaded_model = load_model(\"/content/trash_classification.h5\")\n",
+ "\n",
+ "# Evaluate the loaded model\n",
+ "test_loss, test_accuracy = loaded_model.evaluate(test_generator)\n",
+ "print(f\"Test Loss: {test_loss:.4f}\")\n",
+ "print(f\"Test Accuracy: {test_accuracy:.4f}\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 970
+ },
+ "id": "waD51ezfIIaC",
+ "outputId": "5adbedb3-aa3f-451b-dc33-bd6f5e8fbc7b"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\u001b[1m27/27\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 256ms/step\n",
+ "Classification Report:\n",
+ " precision recall f1-score support\n",
+ "\n",
+ " cardboard 0.95 0.91 0.93 121\n",
+ " glass 0.93 0.83 0.88 151\n",
+ " metal 0.85 0.90 0.88 125\n",
+ "oversampling_trash 0.97 0.95 0.96 133\n",
+ " paper 0.87 0.97 0.92 179\n",
+ " plastic 0.88 0.84 0.86 145\n",
+ "\n",
+ " accuracy 0.90 854\n",
+ " macro avg 0.91 0.90 0.90 854\n",
+ " weighted avg 0.91 0.90 0.90 854\n",
+ "\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "from sklearn.metrics import classification_report, confusion_matrix\n",
+ "import matplotlib.pyplot as plt\n",
+ "import seaborn as sns\n",
+ "\n",
+ "# Get true labels and predictions from the test generator\n",
+ "y_true = test_generator.classes\n",
+ "y_pred = loaded_model.predict(test_generator)\n",
+ "y_pred_classes = np.argmax(y_pred, axis=1)\n",
+ "\n",
+ "# Generate classification report\n",
+ "print(\"Classification Report:\")\n",
+ "print(classification_report(y_true, y_pred_classes, target_names=test_generator.class_indices.keys()))\n",
+ "\n",
+ "# Generate confusion matrix\n",
+ "cm = confusion_matrix(y_true, y_pred_classes)\n",
+ "plt.figure(figsize=(8, 6))\n",
+ "sns.heatmap(cm, annot=True, fmt=\"d\", cmap=\"Blues\", xticklabels=test_generator.class_indices.keys(), yticklabels=test_generator.class_indices.keys())\n",
+ "plt.title(\"Confusion Matrix\")\n",
+ "plt.xlabel(\"Predicted\")\n",
+ "plt.ylabel(\"True\")\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "IFoC9ZNYIIaD",
+ "outputId": "4088adf9-4238-4d2e-9bc3-1652016033fd"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 5s/step\n",
+ "Predicted Class: 0\n",
+ "Class Probabilities: [[9.9999583e-01 1.6411924e-09 5.1112615e-08 1.7563060e-08 4.1357930e-06\n",
+ " 3.4241407e-10]]\n"
+ ]
+ }
+ ],
+ "source": [
+ "import numpy as np\n",
+ "from tensorflow.keras.preprocessing import image\n",
+ "\n",
+ "# Load a single image for testing\n",
+ "img_path = \"test.jpg\" # Replace with the path to your test image\n",
+ "img = image.load_img(img_path, target_size=(224, 224)) # Resize to match model input size\n",
+ "img_array = image.img_to_array(img)\n",
+ "img_array = np.expand_dims(img_array, axis=0) # Add batch dimension\n",
+ "img_array = img_array / 255.0 # Normalize\n",
+ "\n",
+ "# Make prediction\n",
+ "predictions = loaded_model.predict(img_array)\n",
+ "predicted_class = np.argmax(predictions[0]) # Get the class with highest probability\n",
+ "\n",
+ "print(f\"Predicted Class: {predicted_class}\")\n",
+ "print(f\"Class Probabilities: {predictions}\")\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "KuYrXOJ9fhEo",
+ "outputId": "6304fb33-481c-46bf-cc0c-6a0af9a4193c"
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "{'cardboard': 0,\n",
+ " 'glass': 1,\n",
+ " 'metal': 2,\n",
+ " 'oversampling_trash': 3,\n",
+ " 'paper': 4,\n",
+ " 'plastic': 5}"
+ ]
+ },
+ "execution_count": 16,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "train_generator.class_indices"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "5SMw15pyKcag"
+ },
+ "source": [
+ "## Conclussion\n",
+ "\n",
+ "Based on the project that been build, the best model for classification trash is CNN with architecture Mobilenet v2. Which is, reach 95% accuracy tarining and 90% accuracy testing."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "0WmeDmozNDT_"
+ },
+ "source": [
+ "## W&B"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "collapsed": true,
+ "id": "MrW3TxcwNFho",
+ "outputId": "d85719e9-6827-4402-e304-7ceda9b2c72e"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Requirement already satisfied: wandb in /usr/local/lib/python3.10/dist-packages (0.18.7)\n",
+ "Requirement already satisfied: click!=8.0.0,>=7.1 in /usr/local/lib/python3.10/dist-packages (from wandb) (8.1.7)\n",
+ "Requirement already satisfied: docker-pycreds>=0.4.0 in /usr/local/lib/python3.10/dist-packages (from wandb) (0.4.0)\n",
+ "Requirement already satisfied: gitpython!=3.1.29,>=1.0.0 in /usr/local/lib/python3.10/dist-packages (from wandb) (3.1.43)\n",
+ "Requirement already satisfied: platformdirs in /usr/local/lib/python3.10/dist-packages (from wandb) (4.3.6)\n",
+ "Requirement already satisfied: protobuf!=4.21.0,!=5.28.0,<6,>=3.19.0 in /usr/local/lib/python3.10/dist-packages (from wandb) (4.25.5)\n",
+ "Requirement already satisfied: psutil>=5.0.0 in /usr/local/lib/python3.10/dist-packages (from wandb) (5.9.5)\n",
+ "Requirement already satisfied: pyyaml in /usr/local/lib/python3.10/dist-packages (from wandb) (6.0.2)\n",
+ "Requirement already satisfied: requests<3,>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from wandb) (2.32.3)\n",
+ "Requirement already satisfied: sentry-sdk>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from wandb) (2.18.0)\n",
+ "Requirement already satisfied: setproctitle in /usr/local/lib/python3.10/dist-packages (from wandb) (1.3.4)\n",
+ "Requirement already satisfied: setuptools in /usr/local/lib/python3.10/dist-packages (from wandb) (75.1.0)\n",
+ "Requirement already satisfied: typing-extensions<5,>=4.4 in /usr/local/lib/python3.10/dist-packages (from wandb) (4.12.2)\n",
+ "Requirement already satisfied: six>=1.4.0 in /usr/local/lib/python3.10/dist-packages (from docker-pycreds>=0.4.0->wandb) (1.16.0)\n",
+ "Requirement already satisfied: gitdb<5,>=4.0.1 in /usr/local/lib/python3.10/dist-packages (from gitpython!=3.1.29,>=1.0.0->wandb) (4.0.11)\n",
+ "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests<3,>=2.0.0->wandb) (3.4.0)\n",
+ "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests<3,>=2.0.0->wandb) (3.10)\n",
+ "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests<3,>=2.0.0->wandb) (2.2.3)\n",
+ "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests<3,>=2.0.0->wandb) (2024.8.30)\n",
+ "Requirement already satisfied: smmap<6,>=3.0.1 in /usr/local/lib/python3.10/dist-packages (from gitdb<5,>=4.0.1->gitpython!=3.1.29,>=1.0.0->wandb) (5.0.1)\n"
+ ]
+ }
+ ],
+ "source": [
+ "! pip install wandb"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "InU-1wQxNJUn",
+ "outputId": "ffbd8a5f-7cf1-4221-e674-c02792cbf1a2"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\u001b[34m\u001b[1mwandb\u001b[0m: Logging into wandb.ai. (Learn how to deploy a W&B server locally: https://wandb.me/wandb-server)\n",
+ "\u001b[34m\u001b[1mwandb\u001b[0m: You can find your API key in your browser here: https://wandb.ai/authorize\n",
+ "\u001b[34m\u001b[1mwandb\u001b[0m: Paste an API key from your profile and hit enter, or press ctrl+c to quit: \n",
+ "\u001b[34m\u001b[1mwandb\u001b[0m: Appending key for api.wandb.ai to your netrc file: /root/.netrc\n"
+ ]
+ }
+ ],
+ "source": [
+ "! wandb login"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 657
+ },
+ "id": "NB_bCjcHNfe0",
+ "outputId": "64b65afd-e969-44fd-d544-b67128c38c7d"
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "Finishing last run (ID:2vuyvrkd) before initializing another..."
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ " \n",
+ "Run summary: Test Accuracy 0.82553 Test Loss 0.51981
"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ " View run balmy-water-3 at: https://wandb.ai/akmaliafa31/trash-classification/runs/2vuyvrkd https://wandb.ai/akmaliafa31/trash-classification "
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ "Find logs at: ./wandb/run-20241203_112314-2vuyvrkd/logs"
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ "Successfully finished last run (ID:2vuyvrkd). Initializing new run:"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ "Tracking run with wandb version 0.18.7"
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ "Run data is saved locally in /content/wandb/run-20241203_112557-hbgquopt"
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ "Syncing run hopeful-surf-4 Weights & Biases (docs )"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ " View project at https://wandb.ai/akmaliafa31/trash-classification "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ " View run at https://wandb.ai/akmaliafa31/trash-classification/runs/hbgquopt "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "WARNING:absl:Compiled the loaded model, but the compiled metrics have yet to be built. `model.compile_metrics` will be empty until you train or evaluate the model.\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\u001b[1m27/27\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 172ms/step - accuracy: 0.8301 - loss: 0.5352\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\u001b[1m10/10\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 28ms/step\n"
+ ]
+ },
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ " \n",
+ "Run summary: Test Accuracy 0.82553 Test Loss 0.51981
"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ " View run hopeful-surf-4 at: https://wandb.ai/akmaliafa31/trash-classification/runs/hbgquopt https://wandb.ai/akmaliafa31/trash-classification "
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ "Find logs at: ./wandb/run-20241203_112557-hbgquopt/logs"
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "import wandb\n",
+ "from keras.models import load_model\n",
+ "\n",
+ "# Step 1: Initialize W&B\n",
+ "wandb.init(\n",
+ " project=\"trash-classification\", # Replace with your project name\n",
+ " config={\n",
+ " \"architecture\": \"CNN Mobilenetv2\",\n",
+ " \"dataset\": \"Trashnet\",\n",
+ " }\n",
+ ")\n",
+ "\n",
+ "# Step 2: Load the Pretrained Model\n",
+ "model = load_model('/content/cnn_trash_classification_model.h5') # Replace with your model file\n",
+ "\n",
+ "# Step 3: Evaluate the Model on Test Data\n",
+ "test_loss, test_accuracy = model.evaluate(test_generator)\n",
+ "\n",
+ "# Step 4: Log Evaluation Metrics\n",
+ "wandb.log({\"Test Loss\": test_loss, \"Test Accuracy\": test_accuracy})\n",
+ "\n",
+ "# Step 5: Log the Model Weights\n",
+ "model.save('model_logged.h5')\n",
+ "wandb.save('model_logged.h5') # Save model to W&B\n",
+ "\n",
+ "# Step 6: [Optional] Log Predictions\n",
+ "# Get the first 10 batches of data from the test_generator\n",
+ "test_data = []\n",
+ "test_labels = []\n",
+ "for i in range(10):\n",
+ " batch_x, batch_y = test_generator.__next__() # Get the next batch\n",
+ " test_data.extend(batch_x)\n",
+ " test_labels.extend(batch_y)\n",
+ "\n",
+ "test_data = np.array(test_data)\n",
+ "test_labels = np.array(test_labels)\n",
+ "\n",
+ "# Predict on the extracted test data\n",
+ "predictions = model.predict(test_data)\n",
+ "\n",
+ "# Log predictions\n",
+ "wandb.log({\"predictions\": predictions.tolist()})\n",
+ "\n",
+ "# Step 7: Finish the W&B Run\n",
+ "wandb.finish()"
+ ]
+ }
+ ],
+ "metadata": {
+ "accelerator": "GPU",
+ "colab": {
+ "collapsed_sections": [
+ "HXOhxiEweY0E"
+ ],
+ "gpuType": "T4",
+ "provenance": []
+ },
+ "kernelspec": {
+ "display_name": "Python 3",
+ "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.11.5"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}