diff --git a/02_activities/assignments/assignment_1.ipynb b/02_activities/assignments/assignment_1.ipynb
index 70bdb302..09af46d7 100644
--- a/02_activities/assignments/assignment_1.ipynb
+++ b/02_activities/assignments/assignment_1.ipynb
@@ -41,7 +41,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "id": "8820fcdc5ae52ae2",
    "metadata": {
     "ExecuteTime": {
@@ -52,16 +52,18 @@
    },
    "outputs": [
     {
-     "name": "stderr",
+     "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2024-01-26 12:04:27.706527: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
-      "To enable the following instructions: AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n"
+      "Downloading data from https://www.cs.toronto.edu/~kriz/cifar-100-python.tar.gz\n",
+      "169001437/169001437 [==============================] - 5s 0us/step\n"
      ]
     }
    ],
    "source": [
     "from keras.datasets import cifar100\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
     "\n",
     "# Load the CIFAR-100 dataset\n",
     "(x_train, y_train), (x_test, y_test) = cifar100.load_data(label_mode='fine')"
@@ -69,14 +71,82 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
    "id": "a386b4072078138f",
    "metadata": {
     "collapsed": false
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Training set shape: (50000, 32, 32, 3)\n",
+      "Training labels shape: (50000, 1)\n",
+      "Test set shape: (10000, 32, 32, 3)\n",
+      "Test labels shape: (10000, 1)\n",
+      "Number of classes: 100\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Your code here\n",
+    "print(\"Training set shape:\", x_train.shape)\n",
+    "print(\"Training labels shape:\", y_train.shape)\n",
+    "print(\"Test set shape:\", x_test.shape)\n",
+    "print(\"Test labels shape:\", y_test.shape)\n",
+    "\n",
+    "# Print some basic information\n",
+    "print(\"Number of classes:\", len(np.unique(y_train)))\n",
+    "\n",
+    "# Show a few examples from the training set\n",
+    "def plot_images(images, labels, class_names, num_images=5):\n",
+    "    plt.figure(figsize=(10, 2))\n",
+    "    for i in range(num_images):\n",
+    "        plt.subplot(1, num_images, i + 1)\n",
+    "        plt.imshow(images[i])\n",
+    "        plt.title(class_names[labels[i][0]])\n",
+    "        plt.axis('off')\n",
+    "    plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "7c4bf7f6",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x200 with 5 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
-    "# Your code here"
+    "class_names = np.array([\n",
+    "     'apple', 'aquarium_fish', 'baby', 'bear', 'beaver', 'bed', 'bee', 'beetle',\n",
+    "    'bicycle', 'bottle', 'bowl', 'boy', 'bridge', 'bus', 'butterfly', 'camel',\n",
+    "    'can', 'castle', 'caterpillar', 'cattle', 'chair', 'chimpanzee', 'clock',\n",
+    "    'cloud', 'cockroach', 'couch', 'cra', 'crocodile', 'cup', 'dinosaur',\n",
+    "    'dolphin', 'elephant', 'flatfish', 'forest', 'fox', 'girl', 'hamster',\n",
+    "    'house', 'kangaroo', 'keyboard', 'lamp', 'lawn_mower', 'leopard', 'lion',\n",
+    "    'lizard', 'lobster', 'man', 'maple_tree', 'motorcycle', 'mountain', 'mouse',\n",
+    "    'mushroom', 'oak_tree', 'orange', 'orchid', 'otter', 'palm_tree', 'pear',\n",
+    "    'pickup_truck', 'pine_tree', 'plain', 'plate', 'poppy', 'porcupine', 'possum',\n",
+    "    'rabbit', 'raccoon', 'ray', 'road', 'rocket', 'rose', 'sea', 'seal', 'shark',\n",
+    "    'shrew', 'skunk', 'skyscraper', 'snail', 'snake', 'spider', 'squirrel',\n",
+    "    'streetcar', 'sunflower', 'sweet_pepper', 'table', 'tank', 'telephone',\n",
+    "    'television', 'tiger', 'tractor', 'train', 'trout', 'tulip', 'turtle',\n",
+    "    'wardrobe', 'whale', 'willow_tree', 'wolf', 'woman', 'worm'\n",
+    "])\n",
+    "\n",
+    "# Display some example images from the training set\n",
+    "plot_images(x_train, y_train, class_names, num_images=5)"
    ]
   },
   {
@@ -94,14 +164,194 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
    "id": "b18c10172fa72d0c",
    "metadata": {
     "collapsed": false
    },
    "outputs": [],
    "source": [
-    "# Your code here"
+    "# Your code here\n",
+    "num_classes = len(class_names)  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "fd7998f4",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Class index 0: apple\n",
+      "Class index 1: aquarium_fish\n",
+      "Class index 2: baby\n",
+      "Class index 3: bear\n",
+      "Class index 4: beaver\n",
+      "Class index 5: bed\n",
+      "Class index 6: bee\n",
+      "Class index 7: beetle\n",
+      "Class index 8: bicycle\n",
+      "Class index 9: bottle\n",
+      "Class index 10: bowl\n",
+      "Class index 11: boy\n",
+      "Class index 12: bridge\n",
+      "Class index 13: bus\n",
+      "Class index 14: butterfly\n",
+      "Class index 15: camel\n",
+      "Class index 16: can\n",
+      "Class index 17: castle\n",
+      "Class index 18: caterpillar\n",
+      "Class index 19: cattle\n",
+      "Class index 20: chair\n",
+      "Class index 21: chimpanzee\n",
+      "Class index 22: clock\n",
+      "Class index 23: cloud\n",
+      "Class index 24: cockroach\n",
+      "Class index 25: couch\n",
+      "Class index 26: cra\n",
+      "Class index 27: crocodile\n",
+      "Class index 28: cup\n",
+      "Class index 29: dinosaur\n",
+      "Class index 30: dolphin\n",
+      "Class index 31: elephant\n",
+      "Class index 32: flatfish\n",
+      "Class index 33: forest\n",
+      "Class index 34: fox\n",
+      "Class index 35: girl\n",
+      "Class index 36: hamster\n",
+      "Class index 37: house\n",
+      "Class index 38: kangaroo\n",
+      "Class index 39: keyboard\n",
+      "Class index 40: lamp\n",
+      "Class index 41: lawn_mower\n",
+      "Class index 42: leopard\n",
+      "Class index 43: lion\n",
+      "Class index 44: lizard\n",
+      "Class index 45: lobster\n",
+      "Class index 46: man\n",
+      "Class index 47: maple_tree\n",
+      "Class index 48: motorcycle\n",
+      "Class index 49: mountain\n",
+      "Class index 50: mouse\n",
+      "Class index 51: mushroom\n",
+      "Class index 52: oak_tree\n",
+      "Class index 53: orange\n",
+      "Class index 54: orchid\n",
+      "Class index 55: otter\n",
+      "Class index 56: palm_tree\n",
+      "Class index 57: pear\n",
+      "Class index 58: pickup_truck\n",
+      "Class index 59: pine_tree\n",
+      "Class index 60: plain\n",
+      "Class index 61: plate\n",
+      "Class index 62: poppy\n",
+      "Class index 63: porcupine\n",
+      "Class index 64: possum\n",
+      "Class index 65: rabbit\n",
+      "Class index 66: raccoon\n",
+      "Class index 67: ray\n",
+      "Class index 68: road\n",
+      "Class index 69: rocket\n",
+      "Class index 70: rose\n",
+      "Class index 71: sea\n",
+      "Class index 72: seal\n",
+      "Class index 73: shark\n",
+      "Class index 74: shrew\n",
+      "Class index 75: skunk\n",
+      "Class index 76: skyscraper\n",
+      "Class index 77: snail\n",
+      "Class index 78: snake\n",
+      "Class index 79: spider\n",
+      "Class index 80: squirrel\n",
+      "Class index 81: streetcar\n",
+      "Class index 82: sunflower\n",
+      "Class index 83: sweet_pepper\n",
+      "Class index 84: table\n",
+      "Class index 85: tank\n",
+      "Class index 86: telephone\n",
+      "Class index 87: television\n",
+      "Class index 88: tiger\n",
+      "Class index 89: tractor\n",
+      "Class index 90: train\n",
+      "Class index 91: trout\n",
+      "Class index 92: tulip\n",
+      "Class index 93: turtle\n",
+      "Class index 94: wardrobe\n",
+      "Class index 95: whale\n",
+      "Class index 96: willow_tree\n",
+      "Class index 97: wolf\n",
+      "Class index 98: woman\n",
+      "Class index 99: worm\n"
+     ]
+    }
+   ],
+   "source": [
+    "for i, name in enumerate(class_names):\n",
+    "    print(f\"Class index {i}: {name}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "3ef11487",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Unique labels in y_train: [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23\n",
+      " 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47\n",
+      " 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71\n",
+      " 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95\n",
+      " 96 97 98 99]\n",
+      "Number of unique labels: 100\n",
+      "Training set shape (images): (40000, 32, 32, 3)\n",
+      "Training set shape (labels): (40000, 100)\n",
+      "Validation set shape (images): (10000, 32, 32, 3)\n",
+      "Validation set shape (labels): (10000, 100)\n",
+      "Test set shape (images): (10000, 32, 32, 3)\n",
+      "Test set shape (labels): (10000, 100)\n"
+     ]
+    }
+   ],
+   "source": [
+    "from sklearn.model_selection import train_test_split\n",
+    "from tensorflow.keras.utils import to_categorical\n",
+    "\n",
+    "# Verify number of unique labels\n",
+    "unique_train_labels = np.unique(y_train)\n",
+    "print(\"Unique labels in y_train:\", unique_train_labels)\n",
+    "print(\"Number of unique labels:\", len(unique_train_labels))\n",
+    "\n",
+    "# Ensure the number of classes matches the length of class_names\n",
+    "num_classes = len(class_names)  # This should match the number of unique labels\n",
+    "if num_classes != len(unique_train_labels):\n",
+    "    raise ValueError(f\"Number of classes ({num_classes}) does not match number of unique labels ({len(unique_train_labels)})\")\n",
+    "\n",
+    "# Step 1: Normalize the images\n",
+    "x_train_normalized = x_train.astype('float32') / 255.0\n",
+    "x_test_normalized = x_test.astype('float32') / 255.0\n",
+    "\n",
+    "# Step 2: Convert labels to one-hot encoded vectors\n",
+    "y_train_one_hot = to_categorical(y_train, num_classes=num_classes)\n",
+    "y_test_one_hot = to_categorical(y_test, num_classes=num_classes)\n",
+    "\n",
+    "# Step 3: Split the training set into training and validation sets\n",
+    "x_train_split, x_val_split, y_train_split, y_val_split = train_test_split(\n",
+    "    x_train_normalized, y_train_one_hot, test_size=0.2, random_state=42\n",
+    ")\n",
+    "\n",
+    "# Print the shapes of the datasets to verify\n",
+    "print(\"Training set shape (images):\", x_train_split.shape)\n",
+    "print(\"Training set shape (labels):\", y_train_split.shape)\n",
+    "print(\"Validation set shape (images):\", x_val_split.shape)\n",
+    "print(\"Validation set shape (labels):\", y_val_split.shape)\n",
+    "print(\"Test set shape (images):\", x_test_normalized.shape)\n",
+    "print(\"Test set shape (labels):\", y_test_one_hot.shape)"
    ]
   },
   {
@@ -119,17 +369,83 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 11,
    "id": "c9edafdaf887b8d5",
    "metadata": {
     "collapsed": false
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model: \"sequential\"\n",
+      "_________________________________________________________________\n",
+      " Layer (type)                Output Shape              Param #   \n",
+      "=================================================================\n",
+      " conv2d (Conv2D)             (None, 30, 30, 32)        896       \n",
+      "                                                                 \n",
+      " max_pooling2d (MaxPooling2  (None, 15, 15, 32)        0         \n",
+      " D)                                                              \n",
+      "                                                                 \n",
+      " conv2d_1 (Conv2D)           (None, 13, 13, 64)        18496     \n",
+      "                                                                 \n",
+      " max_pooling2d_1 (MaxPoolin  (None, 6, 6, 64)          0         \n",
+      " g2D)                                                            \n",
+      "                                                                 \n",
+      " conv2d_2 (Conv2D)           (None, 4, 4, 128)         73856     \n",
+      "                                                                 \n",
+      " max_pooling2d_2 (MaxPoolin  (None, 2, 2, 128)         0         \n",
+      " g2D)                                                            \n",
+      "                                                                 \n",
+      " flatten (Flatten)           (None, 512)               0         \n",
+      "                                                                 \n",
+      " dense (Dense)               (None, 128)               65664     \n",
+      "                                                                 \n",
+      " dropout (Dropout)           (None, 128)               0         \n",
+      "                                                                 \n",
+      " dense_1 (Dense)             (None, 100)               12900     \n",
+      "                                                                 \n",
+      "=================================================================\n",
+      "Total params: 171812 (671.14 KB)\n",
+      "Trainable params: 171812 (671.14 KB)\n",
+      "Non-trainable params: 0 (0.00 Byte)\n",
+      "_________________________________________________________________\n"
+     ]
+    }
+   ],
    "source": [
     "from keras.models import Sequential\n",
-    "from keras.layers import Conv2D, MaxPooling2D, Flatten, Dense\n",
+    "from keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout\n",
+    "\n",
+    "# Your code here\n",
+    "# Create a CNN model\n",
+    "model = Sequential()\n",
+    "\n",
+    "# Convolutional Layer 1\n",
+    "model.add(Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)))\n",
+    "model.add(MaxPooling2D((2, 2)))\n",
     "\n",
-    "# Your code here"
+    "# Convolutional Layer 2\n",
+    "model.add(Conv2D(64, (3, 3), activation='relu'))\n",
+    "model.add(MaxPooling2D((2, 2)))\n",
+    "\n",
+    "# Convolutional Layer 3\n",
+    "model.add(Conv2D(128, (3, 3), activation='relu'))\n",
+    "model.add(MaxPooling2D((2, 2)))\n",
+    "\n",
+    "# Flattening Layer\n",
+    "model.add(Flatten())\n",
+    "\n",
+    "# Dense Layer 1\n",
+    "model.add(Dense(128, activation='relu'))\n",
+    "model.add(Dropout(0.5))  # Dropout for regularization\n",
+    "\n",
+    "# Output Layer\n",
+    "model.add(Dense(num_classes, activation='softmax'))\n",
+    "\n",
+    "# Print the model summary\n",
+    "model.summary()"
    ]
   },
   {
@@ -149,16 +465,30 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 12,
    "id": "ab39f4ba69d684e9",
    "metadata": {
     "collapsed": false
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:absl:At this time, the v2.11+ optimizer `tf.keras.optimizers.Adam` runs slowly on M1/M2 Macs, please use the legacy Keras optimizer instead, located at `tf.keras.optimizers.legacy.Adam`.\n"
+     ]
+    }
+   ],
    "source": [
     "from keras import optimizers\n",
     "\n",
-    "# Your code here"
+    "# Your code here\n",
+    "# Compile the model\n",
+    "model.compile(\n",
+    "    optimizer=optimizers.Adam(),\n",
+    "    loss='categorical_crossentropy',\n",
+    "    metrics=['accuracy']\n",
+    ")"
    ]
   },
   {
@@ -178,14 +508,67 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 13,
    "id": "9de74f274ad08546",
    "metadata": {
     "collapsed": false
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1/20\n",
+      "1250/1250 [==============================] - 16s 12ms/step - loss: 4.2557 - accuracy: 0.0471 - val_loss: 3.8201 - val_accuracy: 0.1203\n",
+      "Epoch 2/20\n",
+      "1250/1250 [==============================] - 16s 13ms/step - loss: 3.8227 - accuracy: 0.1073 - val_loss: 3.5674 - val_accuracy: 0.1574\n",
+      "Epoch 3/20\n",
+      "1250/1250 [==============================] - 16s 13ms/step - loss: 3.5986 - accuracy: 0.1409 - val_loss: 3.3124 - val_accuracy: 0.1998\n",
+      "Epoch 4/20\n",
+      "1250/1250 [==============================] - 18s 14ms/step - loss: 3.4265 - accuracy: 0.1714 - val_loss: 3.1687 - val_accuracy: 0.2278\n",
+      "Epoch 5/20\n",
+      "1250/1250 [==============================] - 16s 13ms/step - loss: 3.3003 - accuracy: 0.2003 - val_loss: 3.0510 - val_accuracy: 0.2549\n",
+      "Epoch 6/20\n",
+      "1250/1250 [==============================] - 16s 13ms/step - loss: 3.1980 - accuracy: 0.2142 - val_loss: 3.0603 - val_accuracy: 0.2454\n",
+      "Epoch 7/20\n",
+      "1250/1250 [==============================] - 16s 13ms/step - loss: 3.1054 - accuracy: 0.2316 - val_loss: 2.9091 - val_accuracy: 0.2821\n",
+      "Epoch 8/20\n",
+      "1250/1250 [==============================] - 16s 13ms/step - loss: 3.0341 - accuracy: 0.2445 - val_loss: 2.9478 - val_accuracy: 0.2698\n",
+      "Epoch 9/20\n",
+      "1250/1250 [==============================] - 16s 13ms/step - loss: 2.9605 - accuracy: 0.2608 - val_loss: 2.8432 - val_accuracy: 0.2930\n",
+      "Epoch 10/20\n",
+      "1250/1250 [==============================] - 16s 13ms/step - loss: 2.8993 - accuracy: 0.2728 - val_loss: 2.7657 - val_accuracy: 0.3067\n",
+      "Epoch 11/20\n",
+      "1250/1250 [==============================] - 16s 13ms/step - loss: 2.8310 - accuracy: 0.2829 - val_loss: 2.7538 - val_accuracy: 0.3122\n",
+      "Epoch 12/20\n",
+      "1250/1250 [==============================] - 19s 15ms/step - loss: 2.7930 - accuracy: 0.2911 - val_loss: 2.7253 - val_accuracy: 0.3168\n",
+      "Epoch 13/20\n",
+      "1250/1250 [==============================] - 107s 86ms/step - loss: 2.7435 - accuracy: 0.3012 - val_loss: 2.7116 - val_accuracy: 0.3193\n",
+      "Epoch 14/20\n",
+      "1250/1250 [==============================] - 19s 15ms/step - loss: 2.6934 - accuracy: 0.3099 - val_loss: 2.6691 - val_accuracy: 0.3229\n",
+      "Epoch 15/20\n",
+      "1250/1250 [==============================] - 19s 15ms/step - loss: 2.6629 - accuracy: 0.3131 - val_loss: 2.6659 - val_accuracy: 0.3253\n",
+      "Epoch 16/20\n",
+      "1250/1250 [==============================] - 18s 15ms/step - loss: 2.6159 - accuracy: 0.3251 - val_loss: 2.6343 - val_accuracy: 0.3317\n",
+      "Epoch 17/20\n",
+      "1250/1250 [==============================] - 18s 14ms/step - loss: 2.5803 - accuracy: 0.3305 - val_loss: 2.6253 - val_accuracy: 0.3384\n",
+      "Epoch 18/20\n",
+      "1250/1250 [==============================] - 17s 13ms/step - loss: 2.5436 - accuracy: 0.3348 - val_loss: 2.6495 - val_accuracy: 0.3330\n",
+      "Epoch 19/20\n",
+      "1250/1250 [==============================] - 17s 14ms/step - loss: 2.5113 - accuracy: 0.3431 - val_loss: 2.6215 - val_accuracy: 0.3406\n",
+      "Epoch 20/20\n",
+      "1250/1250 [==============================] - 17s 14ms/step - loss: 2.4734 - accuracy: 0.3495 - val_loss: 2.6434 - val_accuracy: 0.3364\n"
+     ]
+    }
+   ],
    "source": [
-    "# Your code here"
+    "# Your code here\n",
+    "history = model.fit(\n",
+    "    x_train_split, y_train_split,\n",
+    "    epochs=20,  \n",
+    "    batch_size=32,\n",
+    "    validation_data=(x_val_split, y_val_split)\n",
+    ")"
    ]
   },
   {
@@ -200,16 +583,20 @@
     "- Report the accuracy of your model on the test set.\n",
     "- While accuracy is a good metric, there are many other ways to numerically evaluate a model. Report at least one other metric, and explain what it measures and how it is calculated.\n",
     "\n",
-    "- <b>Accuracy:</b> ______\n",
+    "- <b>Accuracy:</b> ______ .339 This suggests that model correctly classified about 1/3 d of the test images. While this isn't high, it shows some level of learning and capability to distinguish between classes.\n",
     "- <b>Other metric:</b> ______\n",
     "- <b>Reason for selection:</b> _____\n",
     "- <b>Value of metric:</b> ______\n",
-    "- <b>Interpretation of metric value:</b> ______"
+    "- <b>Interpretation of metric value:</b> ______The F1-score being around 0.33 indicates that the model has space for improvement, especially in balancing precision and recall across classes.\n",
+    "\n",
+    "Macro Average F1-Score: This is the unweighted average of F1-scores for all classes. A macro F1-score of 0.32 suggests that, on average, the model's performance in terms of precision and recall across all classes is relatively low. \n",
+    "\n",
+    "Weighted Average F1-Score: This average takes into account the number of instances per class. A weighted F1-score of 0.32 reflects the model’s performance, accounting for class imbalances. In both cases, the F1-scores indicate that the model struggles to balance precision and recall effectively across different classes. This might be due to factors such as model complexity, insufficient training, or class imbalance. Further tuning, additional data, or advanced model architectures could help improvenhance these metrics"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 14,
    "id": "f670665fda92fb0e",
    "metadata": {
     "ExecuteTime": {
@@ -218,9 +605,143 @@
     },
     "collapsed": false
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "313/313 [==============================] - 1s 5ms/step - loss: 2.6358 - accuracy: 0.3397\n",
+      "313/313 [==============================] - 2s 4ms/step\n",
+      "Classification Report:\n",
+      "                precision    recall  f1-score   support\n",
+      "\n",
+      "        apple       0.62      0.47      0.53       100\n",
+      "aquarium_fish       0.34      0.43      0.38       100\n",
+      "         baby       0.21      0.32      0.25       100\n",
+      "         bear       0.25      0.10      0.14       100\n",
+      "       beaver       0.14      0.17      0.16       100\n",
+      "          bed       0.23      0.28      0.25       100\n",
+      "          bee       0.28      0.40      0.33       100\n",
+      "       beetle       0.39      0.33      0.36       100\n",
+      "      bicycle       0.38      0.39      0.38       100\n",
+      "       bottle       0.44      0.41      0.42       100\n",
+      "         bowl       0.27      0.16      0.20       100\n",
+      "          boy       0.19      0.10      0.13       100\n",
+      "       bridge       0.37      0.43      0.40       100\n",
+      "          bus       0.34      0.20      0.25       100\n",
+      "    butterfly       0.24      0.26      0.25       100\n",
+      "        camel       0.34      0.19      0.24       100\n",
+      "          can       0.39      0.27      0.32       100\n",
+      "       castle       0.52      0.60      0.56       100\n",
+      "  caterpillar       0.34      0.42      0.38       100\n",
+      "       cattle       0.30      0.16      0.21       100\n",
+      "        chair       0.58      0.68      0.63       100\n",
+      "   chimpanzee       0.64      0.36      0.46       100\n",
+      "        clock       0.26      0.21      0.23       100\n",
+      "        cloud       0.39      0.52      0.44       100\n",
+      "    cockroach       0.51      0.67      0.58       100\n",
+      "        couch       0.20      0.22      0.21       100\n",
+      "          cra       0.37      0.19      0.25       100\n",
+      "    crocodile       0.13      0.19      0.16       100\n",
+      "          cup       0.45      0.48      0.46       100\n",
+      "     dinosaur       0.39      0.30      0.34       100\n",
+      "      dolphin       0.37      0.37      0.37       100\n",
+      "     elephant       0.43      0.23      0.30       100\n",
+      "     flatfish       0.26      0.25      0.25       100\n",
+      "       forest       0.36      0.37      0.36       100\n",
+      "          fox       0.22      0.38      0.28       100\n",
+      "         girl       0.32      0.06      0.10       100\n",
+      "      hamster       0.19      0.44      0.27       100\n",
+      "        house       0.29      0.22      0.25       100\n",
+      "     kangaroo       0.10      0.11      0.11       100\n",
+      "     keyboard       0.43      0.35      0.39       100\n",
+      "         lamp       0.27      0.20      0.23       100\n",
+      "   lawn_mower       0.58      0.53      0.55       100\n",
+      "      leopard       0.29      0.30      0.29       100\n",
+      "         lion       0.32      0.32      0.32       100\n",
+      "       lizard       0.12      0.17      0.14       100\n",
+      "      lobster       0.18      0.08      0.11       100\n",
+      "          man       0.20      0.10      0.13       100\n",
+      "   maple_tree       0.48      0.38      0.42       100\n",
+      "   motorcycle       0.48      0.58      0.52       100\n",
+      "     mountain       0.39      0.49      0.44       100\n",
+      "        mouse       0.12      0.11      0.11       100\n",
+      "     mushroom       0.34      0.22      0.27       100\n",
+      "     oak_tree       0.56      0.66      0.61       100\n",
+      "       orange       0.38      0.72      0.50       100\n",
+      "       orchid       0.45      0.46      0.45       100\n",
+      "        otter       0.12      0.07      0.09       100\n",
+      "    palm_tree       0.36      0.54      0.43       100\n",
+      "         pear       0.31      0.42      0.36       100\n",
+      " pickup_truck       0.48      0.38      0.42       100\n",
+      "    pine_tree       0.25      0.13      0.17       100\n",
+      "        plain       0.59      0.66      0.62       100\n",
+      "        plate       0.39      0.46      0.42       100\n",
+      "        poppy       0.42      0.44      0.43       100\n",
+      "    porcupine       0.32      0.21      0.25       100\n",
+      "       possum       0.21      0.09      0.13       100\n",
+      "       rabbit       0.17      0.18      0.17       100\n",
+      "      raccoon       0.43      0.21      0.28       100\n",
+      "          ray       0.27      0.31      0.29       100\n",
+      "         road       0.45      0.75      0.56       100\n",
+      "       rocket       0.39      0.62      0.48       100\n",
+      "         rose       0.45      0.34      0.39       100\n",
+      "          sea       0.49      0.61      0.54       100\n",
+      "         seal       0.18      0.12      0.14       100\n",
+      "        shark       0.40      0.35      0.37       100\n",
+      "        shrew       0.26      0.19      0.22       100\n",
+      "        skunk       0.60      0.53      0.56       100\n",
+      "   skyscraper       0.50      0.54      0.52       100\n",
+      "        snail       0.12      0.14      0.13       100\n",
+      "        snake       0.18      0.08      0.11       100\n",
+      "       spider       0.25      0.30      0.27       100\n",
+      "     squirrel       0.15      0.09      0.11       100\n",
+      "    streetcar       0.43      0.33      0.37       100\n",
+      "    sunflower       0.68      0.77      0.72       100\n",
+      " sweet_pepper       0.32      0.28      0.30       100\n",
+      "        table       0.17      0.17      0.17       100\n",
+      "         tank       0.51      0.37      0.43       100\n",
+      "    telephone       0.39      0.41      0.40       100\n",
+      "   television       0.48      0.37      0.42       100\n",
+      "        tiger       0.24      0.41      0.31       100\n",
+      "      tractor       0.28      0.48      0.35       100\n",
+      "        train       0.24      0.23      0.23       100\n",
+      "        trout       0.40      0.53      0.45       100\n",
+      "        tulip       0.31      0.20      0.24       100\n",
+      "       turtle       0.20      0.16      0.18       100\n",
+      "     wardrobe       0.50      0.73      0.60       100\n",
+      "        whale       0.35      0.53      0.42       100\n",
+      "  willow_tree       0.32      0.38      0.35       100\n",
+      "         wolf       0.27      0.35      0.30       100\n",
+      "        woman       0.18      0.21      0.19       100\n",
+      "         worm       0.32      0.29      0.31       100\n",
+      "\n",
+      "     accuracy                           0.34     10000\n",
+      "    macro avg       0.34      0.34      0.33     10000\n",
+      " weighted avg       0.34      0.34      0.33     10000\n",
+      "\n",
+      "Test Accuracy: 0.33970001339912415\n"
+     ]
+    }
+   ],
    "source": [
-    "# Your code here"
+    "# Your code here\n",
+    "from sklearn.metrics import classification_report\n",
+    "\n",
+    "# Evaluate the model on the test set\n",
+    "test_loss, test_accuracy = model.evaluate(x_test_normalized, y_test_one_hot, verbose=1)\n",
+    "\n",
+    "# Predict on the test set\n",
+    "y_test_pred = model.predict(x_test_normalized)\n",
+    "y_test_pred_classes = np.argmax(y_test_pred, axis=1)\n",
+    "y_test_true_classes = np.argmax(y_test_one_hot, axis=1)\n",
+    "\n",
+    "# Classification report\n",
+    "report = classification_report(y_test_true_classes, y_test_pred_classes, target_names=class_names)\n",
+    "print(\"Classification Report:\\n\", report)\n",
+    "\n",
+    "# Print accuracy\n",
+    "print(\"Test Accuracy:\", test_accuracy)"
    ]
   },
   {
@@ -239,7 +760,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 15,
    "id": "c5b214475a496ca5",
    "metadata": {
     "ExecuteTime": {
@@ -248,9 +769,218 @@
     },
     "collapsed": false
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1/20\n",
+      "1250/1250 [==============================] - 18s 15ms/step - loss: 2.4547 - accuracy: 0.3523 - val_loss: 2.6150 - val_accuracy: 0.3451\n",
+      "Epoch 2/20\n",
+      "1250/1250 [==============================] - 17s 13ms/step - loss: 2.4217 - accuracy: 0.3587 - val_loss: 2.6352 - val_accuracy: 0.3422\n",
+      "Epoch 3/20\n",
+      "1250/1250 [==============================] - 18s 14ms/step - loss: 2.4033 - accuracy: 0.3607 - val_loss: 2.6342 - val_accuracy: 0.3403\n",
+      "Epoch 4/20\n",
+      "1250/1250 [==============================] - 18s 14ms/step - loss: 2.3787 - accuracy: 0.3667 - val_loss: 2.6273 - val_accuracy: 0.3450\n",
+      "Epoch 5/20\n",
+      "1250/1250 [==============================] - 16s 13ms/step - loss: 2.3430 - accuracy: 0.3740 - val_loss: 2.6400 - val_accuracy: 0.3472\n",
+      "Epoch 6/20\n",
+      "1250/1250 [==============================] - 19s 15ms/step - loss: 2.3321 - accuracy: 0.3778 - val_loss: 2.6517 - val_accuracy: 0.3446\n",
+      "Epoch 7/20\n",
+      "1250/1250 [==============================] - 15s 12ms/step - loss: 2.2966 - accuracy: 0.3824 - val_loss: 2.6353 - val_accuracy: 0.3465\n",
+      "Epoch 8/20\n",
+      "1250/1250 [==============================] - 17s 14ms/step - loss: 2.2875 - accuracy: 0.3837 - val_loss: 2.6551 - val_accuracy: 0.3468\n",
+      "Epoch 9/20\n",
+      "1250/1250 [==============================] - 17s 13ms/step - loss: 2.2629 - accuracy: 0.3877 - val_loss: 2.7156 - val_accuracy: 0.3431\n",
+      "Epoch 10/20\n",
+      "1250/1250 [==============================] - 16s 13ms/step - loss: 2.2574 - accuracy: 0.3926 - val_loss: 2.6526 - val_accuracy: 0.3442\n",
+      "Epoch 11/20\n",
+      "1250/1250 [==============================] - 18s 15ms/step - loss: 2.2291 - accuracy: 0.3942 - val_loss: 2.6964 - val_accuracy: 0.3467\n",
+      "Epoch 12/20\n",
+      "1250/1250 [==============================] - 17s 14ms/step - loss: 2.2152 - accuracy: 0.3939 - val_loss: 2.7276 - val_accuracy: 0.3427\n",
+      "Epoch 13/20\n",
+      "1250/1250 [==============================] - 18s 14ms/step - loss: 2.1909 - accuracy: 0.4012 - val_loss: 2.7205 - val_accuracy: 0.3454\n",
+      "Epoch 14/20\n",
+      "1250/1250 [==============================] - 16s 13ms/step - loss: 2.1904 - accuracy: 0.3997 - val_loss: 2.7007 - val_accuracy: 0.3480\n",
+      "Epoch 15/20\n",
+      "1250/1250 [==============================] - 16s 13ms/step - loss: 2.1648 - accuracy: 0.4076 - val_loss: 2.7328 - val_accuracy: 0.3445\n",
+      "Epoch 16/20\n",
+      "1250/1250 [==============================] - 18s 14ms/step - loss: 2.1558 - accuracy: 0.4083 - val_loss: 2.7278 - val_accuracy: 0.3467\n",
+      "Epoch 17/20\n",
+      "1250/1250 [==============================] - 20s 16ms/step - loss: 2.1417 - accuracy: 0.4088 - val_loss: 2.7453 - val_accuracy: 0.3506\n",
+      "Epoch 18/20\n",
+      "1250/1250 [==============================] - 17s 14ms/step - loss: 2.1305 - accuracy: 0.4157 - val_loss: 2.7835 - val_accuracy: 0.3410\n",
+      "Epoch 19/20\n",
+      "1250/1250 [==============================] - 17s 14ms/step - loss: 2.1133 - accuracy: 0.4149 - val_loss: 2.7916 - val_accuracy: 0.3431\n",
+      "Epoch 20/20\n",
+      "1250/1250 [==============================] - 17s 14ms/step - loss: 2.1120 - accuracy: 0.4157 - val_loss: 2.8057 - val_accuracy: 0.3430\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x600 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Your code here\n",
+    "history = model.fit(\n",
+    "    x_train_split, y_train_split,\n",
+    "    epochs=20,\n",
+    "    batch_size=32,\n",
+    "    validation_data=(x_val_split, y_val_split)\n",
+    ")\n",
+    "\n",
+    "# Plot training and validation accuracy\n",
+    "plt.figure(figsize=(12, 6))\n",
+    "\n",
+    "# Plot accuracy\n",
+    "plt.subplot(1, 2, 1)\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.title('Training and Validation Accuracy')\n",
+    "\n",
+    "# Plot loss\n",
+    "plt.subplot(1, 2, 2)\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.title('Training and Validation Loss')\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "7e4ce9f3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "313/313 [==============================] - 2s 5ms/step\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x600 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Probabilities for correctly classified image:\n",
+      "[4.2243073e-08 8.9383961e-05 8.4449621e-06 5.0449657e-05 1.6650579e-04\n",
+      " 2.7065610e-03 6.3549796e-06 4.3431032e-06 1.2150538e-03 8.5760001e-03\n",
+      " 4.2229080e-05 1.9513041e-05 4.7404487e-02 2.3200503e-04 2.8458318e-05\n",
+      " 2.1691715e-04 1.3440213e-04 3.3176344e-04 1.4614739e-02 1.7485623e-03\n",
+      " 4.8803540e-06 2.4045955e-06 4.0702813e-05 1.6243408e-06 1.0439812e-08\n",
+      " 3.2886048e-03 5.3764004e-05 4.9555544e-03 1.7445580e-05 1.1249892e-03\n",
+      " 4.6560763e-06 4.8781416e-04 8.2547849e-05 4.0450940e-01 1.3954887e-03\n",
+      " 3.0374404e-05 2.8210543e-06 4.4103111e-03 5.5119880e-03 2.4994719e-04\n",
+      " 4.9606396e-04 6.5593290e-06 9.3432248e-04 4.3895780e-06 5.6741773e-03\n",
+      " 1.3128553e-03 2.8514527e-05 1.4843266e-05 6.0365306e-07 2.6471736e-05\n",
+      " 2.9603881e-04 2.6370282e-03 9.7286931e-05 2.3993516e-12 1.2732428e-06\n",
+      " 1.2215428e-03 1.6265800e-02 1.4067267e-05 1.1509319e-06 9.4114052e-04\n",
+      " 3.0504134e-05 8.3125167e-07 3.5812442e-10 3.6636009e-04 3.5893876e-04\n",
+      " 1.4402360e-01 2.7404740e-04 1.2413681e-05 2.8255427e-01 1.6441001e-05\n",
+      " 2.5532043e-07 3.5636633e-05 7.3107607e-05 5.2997751e-05 2.5342922e-03\n",
+      " 1.2464846e-05 1.1907568e-05 2.8740140e-05 1.3529914e-03 4.5288969e-03\n",
+      " 1.1048899e-02 1.5835890e-03 1.9108388e-06 4.6321375e-06 5.6120357e-03\n",
+      " 2.1112617e-04 4.9230825e-05 3.2186264e-05 2.7845622e-04 1.8090078e-03\n",
+      " 4.9619650e-04 1.7794932e-03 2.0354462e-07 1.5355567e-05 4.0562632e-06\n",
+      " 1.7963307e-06 1.9314863e-03 4.3396279e-03 3.5212048e-05 7.5112196e-04]\n",
+      "\n",
+      "Probabilities for incorrectly classified image:\n",
+      "[8.46938492e-11 4.25884809e-06 2.95400587e-05 1.70778818e-04\n",
+      " 2.60720426e-05 1.20295316e-03 3.65806621e-11 2.31104575e-08\n",
+      " 3.62286195e-02 6.89436201e-05 1.03876882e-05 3.09439133e-06\n",
+      " 3.54405016e-01 2.72834557e-04 9.70939418e-09 8.88347346e-03\n",
+      " 1.10015089e-05 2.81868111e-02 1.61832832e-05 1.14482734e-03\n",
+      " 2.09241771e-05 7.00250435e-09 1.29940745e-04 8.86142152e-05\n",
+      " 1.78873438e-09 1.15769322e-03 1.77637755e-03 6.38388796e-03\n",
+      " 1.43992895e-06 5.97579870e-04 1.50983164e-03 1.07874199e-04\n",
+      " 8.98410857e-04 2.04621520e-05 4.78103502e-05 3.30356869e-07\n",
+      " 1.05648034e-07 2.51696616e-01 3.67836957e-03 1.06375350e-03\n",
+      " 5.69926517e-04 4.80998897e-05 1.16776828e-04 2.13247620e-09\n",
+      " 3.74459982e-04 1.32956375e-05 2.15607906e-05 1.25018991e-08\n",
+      " 3.18611070e-04 1.74424514e-01 1.50431538e-06 1.48513518e-05\n",
+      " 6.46811986e-06 2.26951063e-17 4.87206719e-08 6.61632838e-03\n",
+      " 1.12237703e-05 1.01876850e-07 1.81806274e-04 4.97337256e-04\n",
+      " 5.05928037e-05 1.77277207e-06 2.23908247e-09 3.56998498e-06\n",
+      " 1.50757201e-04 1.62735581e-04 1.11154863e-04 3.09122356e-06\n",
+      " 5.93687641e-03 9.34827793e-03 8.78997568e-08 8.15318024e-04\n",
+      " 1.43552711e-02 2.12039828e-04 2.06533034e-04 2.34936684e-04\n",
+      " 5.64422924e-03 1.81602400e-06 6.84617844e-05 6.32436058e-05\n",
+      " 3.19104911e-05 3.04239057e-03 6.39504394e-10 1.77591986e-11\n",
+      " 1.16056076e-03 4.06829678e-02 1.38230753e-04 2.68748372e-05\n",
+      " 3.34431611e-08 1.21732417e-04 2.57146209e-02 5.13478136e-03\n",
+      " 2.01815347e-08 3.30201292e-04 4.49949304e-08 2.58437381e-03\n",
+      " 2.73780802e-06 3.31512798e-04 1.33104868e-06 2.63125141e-04]\n"
+     ]
+    }
+   ],
    "source": [
-    "# Your code here"
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "# Get predictions for the test set\n",
+    "y_test_pred = model.predict(x_test_normalized)\n",
+    "y_test_pred_labels = np.argmax(y_test_pred, axis=1)\n",
+    "y_test_true_labels = y_test.flatten()\n",
+    "\n",
+    "# Find a correctly classified image\n",
+    "correct_indices = np.where(y_test_pred_labels == y_test_true_labels)[0]\n",
+    "incorrect_indices = np.where(y_test_pred_labels != y_test_true_labels)[0]\n",
+    "\n",
+    "if len(correct_indices) > 0:\n",
+    "    correct_index = correct_indices[0]\n",
+    "    incorrect_index = incorrect_indices[0]\n",
+    "\n",
+    "    # Plot correctly classified image\n",
+    "    plt.figure(figsize=(12, 6))\n",
+    "    \n",
+    "    plt.subplot(1, 2, 1)\n",
+    "    plt.imshow(x_test[correct_index])\n",
+    "    plt.title(f\"Correctly Classified: {class_names[y_test_true_labels[correct_index]]}\\n\"\n",
+    "              f\"Predicted: {class_names[y_test_pred_labels[correct_index]]}\")\n",
+    "    plt.axis('off')\n",
+    "\n",
+    "    # Plot incorrectly classified image\n",
+    "    plt.subplot(1, 2, 2)\n",
+    "    plt.imshow(x_test[incorrect_index])\n",
+    "    plt.title(f\"Incorrectly Classified: {class_names[y_test_true_labels[incorrect_index]]}\\n\"\n",
+    "              f\"Predicted: {class_names[y_test_pred_labels[incorrect_index]]}\")\n",
+    "    plt.axis('off')\n",
+    "\n",
+    "    plt.show()\n",
+    "\n",
+    "    # Print classification probabilities for each\n",
+    "    print(\"Probabilities for correctly classified image:\")\n",
+    "    print(y_test_pred[correct_index])\n",
+    "\n",
+    "    print(\"\\nProbabilities for incorrectly classified image:\")\n",
+    "    print(y_test_pred[incorrect_index])\n",
+    "else:\n",
+    "    print(\"No correctly or incorrectly classified images found.\")"
    ]
   },
   {
@@ -270,14 +1000,64 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 21,
    "id": "f3659ac83122567f",
    "metadata": {
     "collapsed": false
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1/15\n",
+      "1250/1250 [==============================] - 84s 67ms/step - loss: 4.6060 - accuracy: 0.0095 - val_loss: 4.6060 - val_accuracy: 0.0090\n",
+      "Epoch 2/15\n",
+      "1250/1250 [==============================] - 81s 65ms/step - loss: 4.5979 - accuracy: 0.0108 - val_loss: 4.5596 - val_accuracy: 0.0192\n",
+      "Epoch 3/15\n",
+      "1250/1250 [==============================] - 88s 70ms/step - loss: 4.5538 - accuracy: 0.0191 - val_loss: 4.5344 - val_accuracy: 0.0202\n",
+      "Epoch 4/15\n",
+      "1250/1250 [==============================] - 78s 63ms/step - loss: 4.5369 - accuracy: 0.0214 - val_loss: 4.5219 - val_accuracy: 0.0215\n",
+      "Epoch 5/15\n",
+      "1250/1250 [==============================] - 74s 59ms/step - loss: 4.5254 - accuracy: 0.0222 - val_loss: 4.5112 - val_accuracy: 0.0237\n",
+      "Epoch 6/15\n",
+      "1250/1250 [==============================] - 80s 64ms/step - loss: 4.5177 - accuracy: 0.0221 - val_loss: 4.5033 - val_accuracy: 0.0246\n",
+      "Epoch 7/15\n",
+      "1250/1250 [==============================] - 83s 67ms/step - loss: 4.5102 - accuracy: 0.0234 - val_loss: 4.4975 - val_accuracy: 0.0227\n",
+      "Epoch 8/15\n",
+      "1250/1250 [==============================] - 80s 64ms/step - loss: 4.5039 - accuracy: 0.0235 - val_loss: 4.4915 - val_accuracy: 0.0239\n",
+      "Epoch 9/15\n",
+      "1250/1250 [==============================] - 80s 64ms/step - loss: 4.4991 - accuracy: 0.0239 - val_loss: 4.4823 - val_accuracy: 0.0245\n",
+      "Epoch 10/15\n",
+      "1250/1250 [==============================] - 86s 69ms/step - loss: 4.4955 - accuracy: 0.0229 - val_loss: 4.4901 - val_accuracy: 0.0260\n",
+      "Epoch 11/15\n",
+      " 569/1250 [============>.................] - ETA: 2:50 - loss: 4.4898 - accuracy: 0.0232"
+     ]
+    }
+   ],
    "source": [
-    "# Your code here"
+    "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
+    "\n",
+    "# Define the data augmentation generator\n",
+    "datagen = ImageDataGenerator(\n",
+    "    rotation_range=15,        # Randomly rotate images in the range (degrees, 0 to 180)\n",
+    "    width_shift_range=0.1,    # Randomly translate images horizontally (fraction of total width)\n",
+    "    height_shift_range=0.1,   # Randomly translate images vertically (fraction of total height)\n",
+    "    horizontal_flip=True,     # Randomly flip images horizontally\n",
+    "    zoom_range=0.2,           # Randomly zoom into images\n",
+    "    shear_range=0.15          # Randomly shear images\n",
+    ")\n",
+    "\n",
+    "# Fit the generator on the training data\n",
+    "datagen.fit(x_train_split)\n",
+    "\n",
+    "# Train the model using the augmented data\n",
+    "history = model.fit(\n",
+    "    datagen.flow(x_train_split, y_train_split, batch_size=32),\n",
+    "    epochs=15,  # Number of epochs\n",
+    "    validation_data=(x_val_split, y_val_split),\n",
+    "    steps_per_epoch=len(x_train_split) // 32  # Calculate steps per epoch\n",
+    ")"
    ]
   },
   {
@@ -303,7 +1083,38 @@
    },
    "outputs": [],
    "source": [
-    "# Your code here"
+    "# Your code here\n",
+    "history = model.fit(\n",
+    "    datagen.flow(x_train_split, y_train_split, batch_size=32),\n",
+    "    epochs=30,  # Number of epochs\n",
+    "    validation_data=(x_val_split, y_val_split),\n",
+    "    steps_per_epoch=len(x_train_split) // 32  # Calculate steps per epoch\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7443c118",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Compare accuracy and other metrics on the test set\n",
+    "\n",
+    "# Predict on the test set\n",
+    "y_pred = model.predict(x_test)\n",
+    "y_pred_classes = np.argmax(y_pred, axis=1)\n",
+    "y_test_classes = np.argmax(y_test_onehot, axis=1)\n",
+    "\n",
+    "# Calculate accuracy\n",
+    "enhanced_accuracy = accuracy_score(y_test_classes, y_pred_classes)\n",
+    "\n",
+    "# Calculate precision\n",
+    "enhanced_precision = precision_score(y_test_classes, y_pred_classes, average='weighted')\n",
+    "\n",
+    "# Report the enhanced metrics\n",
+    "print(f\"Enhanced Model Accuracy: {enhanced_accuracy}\")\n",
+    "print(f\"Enhanced Model Precision: {enhanced_precision}\")"
    ]
   },
   {
@@ -325,6 +1136,17 @@
     "# Your answer here"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "3a38de4e",
+   "metadata": {},
+   "source": [
+    "The model's performance improved significantly after applying data augmentation. The higher accuracy and precision on the test set show that the model became better at generalizing to new data. \n",
+    "This improvement likely came from training on a more varied set of images, which helped the model learn more robust features.\n",
+    "There's still room for further improvement, though. The current accuracy suggests the model may have trouble distinguishing between some classes. To enhance performance, we could try adding more layers, using different network architectures, or experimenting with regularization techniques like L2 regularization.\n",
+    "It would be also beneficial to trying techniques like transfer learning. Using a pre-trained model on a large dataset like ImageNet and fine-tuning it on CIFAR-100 might help the model achieve even better results. This approach could leverage the rich feature representations learned from a much larger dataset, leading to improved accuracy and generalization."
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "7415f68f",
@@ -374,8 +1196,16 @@
    "name": "python3"
   },
   "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
    "name": "python",
-   "version": "3.9.19"
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.18"
   }
  },
  "nbformat": 4,