fixing scripts

scripts/CV/Part1.ipynb

@@ -66,10 +66,10 @@
     "def augment_rotations(X, y):\n",
     "    X_aug = []\n",
     "    y_aug = []\n",
-    "    for k in [1, 2, 3]:  # 90, 180, 270 degrees\n",
-    "        X_rot = torch.rot90(X, k=k, dims=[2, 3])  # rotate along H and W\n",
+    "    for k in [1, 2, 3]: \n",
+    "        X_rot = torch.rot90(X, k=k, dims=[2, 3])\n",
     "        X_aug.append(X_rot)\n",
-    "        y_aug.append(y.clone())  # Same labels for rotated images\n",
+    "        y_aug.append(y.clone())\n",
     "    return torch.cat(X_aug), torch.cat(y_aug)\n"
    ]
   },
@@ -165,7 +165,6 @@
     "    plt.suptitle(f\"{class_name.capitalize()} – Random {count} Samples\", fontsize=16)\n",
     "    plt.show()\n",
     "\n",
-    "# Display for each class\n",
     "for class_name, image_array in datasets.items():\n",
     "    show_random_samples(image_array, class_name)\n"
    ]
@@ -189,7 +188,7 @@
     "\n",
     "for ax, (class_name, images) in zip(axes, datasets.items()):\n",
     "    plot_rgb_histogram_subplot(ax, images, class_name)\n",
-    "    ax.label_outer()  # Hide x labels and tick labels for inner plots\n",
+    "    ax.label_outer()\n",
     "\n",
     "plt.tight_layout()\n",
     "plt.show()\n"
@@ -305,7 +304,7 @@
     "class_names = list(datasets.keys())\n",
     "num_classes = len(class_names)\n",
     "\n",
-    "fig, axes = plt.subplots(1, num_classes, figsize=(4 * num_classes, 4))  # 1 row, 4 columns\n",
+    "fig, axes = plt.subplots(1, num_classes, figsize=(4 * num_classes, 4))\n",
     "\n",
     "for i, (class_name, images) in enumerate(datasets.items()):\n",
     "    avg_img = np.mean(images.astype(np.float32), axis=0)\n",
@@ -371,7 +370,6 @@
     "from sklearn.model_selection import train_test_split\n",
     "from torchvision import transforms\n",
     "\n",
-    "# Combine data\n",
     "X = np.concatenate([onion_images, strawberry_images, pear_images, tomato_images], axis=0)\n",
     "y = (\n",
     "    ['onion'] * len(onion_images) +\n",
@@ -380,16 +378,14 @@
     "    ['tomato'] * len(tomato_images)\n",
     ")\n",
     "\n",
-    "# Normalizing image\n",
     "X = X.astype(np.float32) / 255.0\n",
-    "X = np.transpose(X, (0, 3, 1, 2))  # (N, C, H, W)\n",
+    "X = np.transpose(X, (0, 3, 1, 2)) \n",
     "X_tensor = torch.tensor(X)\n",
     "\n",
     "le = LabelEncoder()\n",
     "y_encoded = le.fit_transform(y)\n",
     "y_tensor = torch.tensor(y_encoded)\n",
     "\n",
-    "# splitting data into 50:25:25 (train, validation, test)\n",
     "X_train, X_temp, y_train, y_temp = train_test_split(X_tensor, y_tensor, test_size=0.5, stratify=y_tensor, random_state=42)\n",
     "X_val, X_test, y_val, y_test = train_test_split(X_temp, y_temp, test_size=0.5, stratify=y_temp, random_state=42)\n"
    ]
@@ -403,13 +399,10 @@
    "source": [
     "batch_size = 32\n",
     "\n",
-    "# Create new training dataset and loader\n",
     "train_dataset = TensorDataset(X_train, y_train)\n",
     "val_dataset   = TensorDataset(X_val, y_val)\n",
     "test_dataset  = TensorDataset(X_test, y_test)\n",
     "\n",
-    "# DataLoaders\n",
-    "\n",
     "train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)\n",
     "val_loader   = DataLoader(val_dataset, batch_size=batch_size)\n",
     "test_loader  = DataLoader(test_dataset, batch_size=batch_size)"
@@ -432,9 +425,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "print(f\"🔢 Train Dataset: {len(train_dataset)} samples, {len(train_loader)} batches\")\n",
-    "print(f\"🔢 Val Dataset:   {len(val_dataset)} samples, {len(val_loader)} batches\")\n",
-    "print(f\"🔢 Test Dataset:  {len(test_dataset)} samples, {len(test_loader)} batches\")"
+    "print(f\"Train Dataset: {len(train_dataset)} samples, {len(train_loader)} batches\")\n",
+    "print(f\"Val Dataset:   {len(val_dataset)} samples, {len(val_loader)} batches\")\n",
+    "print(f\"Test Dataset:  {len(test_dataset)} samples, {len(test_loader)} batches\")"
    ]
   },
   {
@@ -521,8 +514,6 @@
     "        optimizer.step()\n",
     "\n",
     "        total_train_loss += loss.item()\n",
-    "\n",
-    "        # Track training accuracy\n",
     "        pred_labels = preds.argmax(dim=1)\n",
     "        train_correct += (pred_labels == batch_y).sum().item()\n",
     "        train_total += batch_y.size(0)\n",
@@ -546,7 +537,6 @@
     "    val_accuracy = val_correct / val_total\n",
     "    validation_loss = criterion(model(val_x), val_y).item()\n",
     "\n",
-    "    # After calculating val_accuracy\n",
     "    val_losses.append(validation_loss)\n",
     "    val_accs.append(val_accuracy)\n",
     "\n",
@@ -637,7 +627,7 @@
     "\n",
     "print(f\"\\nTest Accuracy: {test_accuracy:.4f}\")\n",
     "\n",
-    "target_names = le.classes_  # ['onion', 'pear', 'strawberry', 'tomato']\n",
+    "target_names = le.classes_ \n",
     "print(\"\\nClassification Report:\\n\")\n",
     "print(classification_report(all_targets, all_preds, target_names=target_names))\n",
     "\n",
@@ -726,7 +716,7 @@
     "        h.remove()\n",
     "\n",
     "    for layer_name, fmap in activations.items():\n",
-    "        fmap = fmap.squeeze(0)  # [C, H, W]\n",
+    "        fmap = fmap.squeeze(0)\n",
     "        num_channels = min(fmap.shape[0], max_channels)\n",
     "\n",
     "        plt.figure(figsize=(num_channels * 2, 2.5))\n",
@@ -758,29 +748,22 @@
     "            activations[name] = output.detach().cpu()\n",
     "        return hook\n",
     "\n",
-    "    # Register hooks for all layers in model.features\n",
     "    hooks = []\n",
     "    for i in range(len(model.features)):\n",
     "        layer = model.features[i]\n",
     "        hooks.append(layer.register_forward_hook(get_activation(f\"features_{i}\")))\n",
     "\n",
     "    with torch.no_grad():\n",
-    "        _ = model(image_tensor.unsqueeze(0))  # Add batch dimension: [1, 3, 224, 224]\n",
+    "        _ = model(image_tensor.unsqueeze(0))\n",
     "\n",
     "    for h in hooks:\n",
     "        h.remove()\n",
     "\n",
     "    for layer_name, fmap in activations.items():\n",
-    "        fmap = fmap.squeeze(0)  # Shape: [C, H, W]\n",
-    "\n",
-    "        # Compute mean activation per channel\n",
-    "        channel_scores = fmap.mean(dim=(1, 2))  # [C]\n",
-    "\n",
-    "        # Get indices of top-k channels\n",
+    "        fmap = fmap.squeeze(0)\n",
+    "        channel_scores = fmap.mean(dim=(1, 2)) \n",
     "        topk = torch.topk(channel_scores, k=min(max_channels, fmap.shape[0]))\n",
     "        top_indices = topk.indices\n",
-    "\n",
-    "        # Plot top-k channels\n",
     "        plt.figure(figsize=(max_channels * 2, 2.5))\n",
     "        for idx, ch in enumerate(top_indices):\n",
     "            plt.subplot(1, max_channels, idx + 1)\n",
@@ -821,14 +804,11 @@
     "\n",
     "img = Image.open(\"dataset/Onion_512/Whole/image_0001.jpg\").convert(\"RGB\")\n",
     "\n",
-    "# Preprocessing (must match model requirements)\n",
     "transform = transforms.Compose([\n",
     "    transforms.Resize((224, 224)),\n",
     "    transforms.ToTensor()\n",
     "])\n",
-    "img_tensor = transform(img)  # shape: [3, 224, 224]\n",
-    "\n",
-    "# Visualize feature maps\n",
+    "img_tensor = transform(img)\n",
     "visualize_channels(model, img_tensor, max_channels=16)\n"
    ]
   },
@@ -849,14 +829,12 @@
    "source": [
     "img = Image.open(\"dataset/Pear_512/Whole/image_0089.jpg\").convert(\"RGB\")\n",
     "\n",
-    "# Preprocessing (must match model requirements)\n",
     "transform = transforms.Compose([\n",
     "    transforms.Resize((224, 224)),\n",
     "    transforms.ToTensor()\n",
     "])\n",
-    "img_tensor = transform(img)  # shape: [3, 224, 224]\n",
+    "img_tensor = transform(img)\n",
     "\n",
-    "# Visualize feature maps\n",
     "visualize_channels(model, img_tensor, max_channels=16)\n"
    ]
   },
@@ -877,14 +855,12 @@
    "source": [
     "img = Image.open(\"dataset/Tomato_512/Whole/image_0001.jpg\").convert(\"RGB\")\n",
     "\n",
-    "# Preprocessing (must match model requirements)\n",
     "transform = transforms.Compose([\n",
     "    transforms.Resize((224, 224)),\n",
     "    transforms.ToTensor()\n",
     "])\n",
-    "img_tensor = transform(img)  # shape: [3, 224, 224]\n",
+    "img_tensor = transform(img)\n",
     "\n",
-    "# Visualize feature maps\n",
     "visualize_channels(model, img_tensor, max_channels=16)\n"
    ]
   },

scripts/CV/compression.ipynb

@@ -18,8 +18,8 @@
     "import os\n",
     "from PIL import Image, ImageOps\n",
     "\n",
-    "input_root = 'Tomato'         # Root folder with raw images\n",
-    "output_root = 'Tomato_512'     # Output root folder\n",
+    "input_root = 'Tomato'       \n",
+    "output_root = 'Tomato_512'   \n",
     "os.makedirs(output_root, exist_ok=True)\n",
     "\n",
     "def process_image(input_path, output_path, size=(512, 512)):\n",
@@ -27,14 +27,12 @@
     "        with Image.open(input_path) as img:\n",
     "            img = img.convert(\"RGB\")\n",
     "\n",
-    "            # Resize while preserving aspect ratio, then pad to 512x512\n",
     "            img = ImageOps.fit(img, size, Image.LANCZOS, centering=(0.5, 0.5))\n",
     "            os.makedirs(os.path.dirname(output_path), exist_ok=True)\n",
     "            img.save(output_path, \"JPEG\", quality=95)\n",
     "    except Exception as e:\n",
-    "        print(f\"❌ Error processing {input_path}: {e}\")\n",
+    "        print(f\"Error processing {input_path}: {e}\")\n",
     "\n",
-    "# Recursively walk through input_root\n",
     "for root, _, files in os.walk(input_root):\n",
     "    for file in files:\n",
     "        if file.lower().endswith((\".jpg\", \".jpeg\")):\n",
@@ -43,7 +41,7 @@
     "            output_path = os.path.join(output_root, rel_path)\n",
     "            process_image(input_path, output_path)\n",
     "\n",
-    "print(\"✅ All images processed and saved in\", output_root)\n"
+    "print(\"All images processed and saved in\", output_root)\n"
    ]
   },
   {
@@ -56,23 +54,20 @@
     "import os\n",
     "from PIL import Image, ImageOps\n",
     "\n",
-    "input_root = 'Onion'         # Root folder with raw images\n",
-    "output_root = 'Onion_512'     # Output root folder\n",
+    "input_root = 'Onion'         \n",
+    "output_root = 'Onion_512'     \n",
     "os.makedirs(output_root, exist_ok=True)\n",
     "\n",
     "def process_image(input_path, output_path, size=(512, 512)):\n",
     "    try:\n",
     "        with Image.open(input_path) as img:\n",
     "            img = img.convert(\"RGB\")\n",
-    "\n",
-    "            # Resize while preserving aspect ratio, then pad to 512x512\n",
     "            img = ImageOps.fit(img, size, Image.LANCZOS, centering=(0.5, 0.5))\n",
     "            os.makedirs(os.path.dirname(output_path), exist_ok=True)\n",
     "            img.save(output_path, \"JPEG\", quality=95)\n",
     "    except Exception as e:\n",
-    "        print(f\"❌ Error processing {input_path}: {e}\")\n",
+    "        print(f\"Error processing {input_path}: {e}\")\n",
     "\n",
-    "# Recursively walk through input_root\n",
     "for root, _, files in os.walk(input_root):\n",
     "    for file in files:\n",
     "        if file.lower().endswith((\".jpg\", \".jpeg\")):\n",
@@ -81,7 +76,7 @@
     "            output_path = os.path.join(output_root, rel_path)\n",
     "            process_image(input_path, output_path)\n",
     "\n",
-    "print(\"✅ All images processed and saved in\", output_root)\n"
+    "print(\"All images processed and saved in\", output_root)\n"
    ]
   },
   {
@@ -94,23 +89,20 @@
     "import os\n",
     "from PIL import Image, ImageOps\n",
     "\n",
-    "input_root = 'Pear'         # Root folder with raw images\n",
-    "output_root = 'Pear_512'     # Output root folder\n",
+    "input_root = 'Pear'         \n",
+    "output_root = 'Pear_512'     \n",
     "os.makedirs(output_root, exist_ok=True)\n",
     "\n",
     "def process_image(input_path, output_path, size=(512, 512)):\n",
     "    try:\n",
     "        with Image.open(input_path) as img:\n",
     "            img = img.convert(\"RGB\")\n",
-    "\n",
-    "            # Resize while preserving aspect ratio, then pad to 512x512\n",
     "            img = ImageOps.fit(img, size, Image.LANCZOS, centering=(0.5, 0.5))\n",
     "            os.makedirs(os.path.dirname(output_path), exist_ok=True)\n",
     "            img.save(output_path, \"JPEG\", quality=95)\n",
     "    except Exception as e:\n",
-    "        print(f\"❌ Error processing {input_path}: {e}\")\n",
+    "        print(f\"Error processing {input_path}: {e}\")\n",
     "\n",
-    "# Recursively walk through input_root\n",
     "for root, _, files in os.walk(input_root):\n",
     "    for file in files:\n",
     "        if file.lower().endswith((\".jpg\", \".jpeg\")):\n",
@@ -119,7 +111,7 @@
     "            output_path = os.path.join(output_root, rel_path)\n",
     "            process_image(input_path, output_path)\n",
     "\n",
-    "print(\"✅ All images processed and saved in\", output_root)\n"
+    "print(\"All images processed and saved in\", output_root)\n"
    ]
   },
   {
@@ -132,23 +124,21 @@
     "import os\n",
     "from PIL import Image, ImageOps\n",
     "\n",
-    "input_root = 'Strawberry'         # Root folder with raw images\n",
-    "output_root = 'Strawberry_512'     # Output root folder\n",
+    "input_root = 'Strawberry'         \n",
+    "output_root = 'Strawberry_512'     \n",
     "os.makedirs(output_root, exist_ok=True)\n",
     "\n",
     "def process_image(input_path, output_path, size=(512, 512)):\n",
     "    try:\n",
     "        with Image.open(input_path) as img:\n",
     "            img = img.convert(\"RGB\")\n",
-    "\n",
-    "            # Resize while preserving aspect ratio, then pad to 512x512\n",
     "            img = ImageOps.fit(img, size, Image.LANCZOS, centering=(0.5, 0.5))\n",
     "            os.makedirs(os.path.dirname(output_path), exist_ok=True)\n",
     "            img.save(output_path, \"JPEG\", quality=95)\n",
     "    except Exception as e:\n",
-    "        print(f\"❌ Error processing {input_path}: {e}\")\n",
+    "        print(f\"Error processing {input_path}: {e}\")\n",
+    "\n",
     "\n",
-    "# Recursively walk through input_root\n",
     "for root, _, files in os.walk(input_root):\n",
     "    for file in files:\n",
     "        if file.lower().endswith((\".jpg\", \".jpeg\")):\n",
@@ -157,16 +147,8 @@
     "            output_path = os.path.join(output_root, rel_path)\n",
     "            process_image(input_path, output_path)\n",
     "\n",
-    "print(\"✅ All images processed and saved in\", output_root)\n"
+    "print(\"All images processed and saved in\", output_root)\n"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "fd49ae48",
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {

scripts/CV/script_onion.ipynb

@@ -59,10 +59,10 @@
     "def augment_rotations(X, y):\n",
     "    X_aug = []\n",
     "    y_aug = []\n",
-    "    for k in [1, 2, 3]:  # 90, 180, 270 degrees\n",
-    "        X_rot = torch.rot90(X, k=k, dims=[2, 3])  # rotate along H and W\n",
+    "    for k in [1, 2, 3]:\n",
+    "        X_rot = torch.rot90(X, k=k, dims=[2, 3])\n",
     "        X_aug.append(X_rot)\n",
-    "        y_aug.append(y.clone())  # Same labels for rotated images\n",
+    "        y_aug.append(y.clone()) \n",
     "    return torch.cat(X_aug), torch.cat(y_aug)"
    ]
   },
@@ -120,7 +120,6 @@
     "    plt.suptitle(f\"{class_name.capitalize()} – Random {count} Samples\", fontsize=16)\n",
     "    plt.show()\n",
     "\n",
-    "# Display for each class\n",
     "for class_name, image_array in datasets.items():\n",
     "    show_random_samples(image_array, class_name)\n"
    ]
@@ -136,7 +135,7 @@
     "\n",
     "for ax, (class_name, images) in zip(axes, datasets.items()):\n",
     "    plot_rgb_histogram_subplot(ax, images, class_name)\n",
-    "    ax.label_outer()  # Hide x labels and tick labels for inner plots\n",
+    "    ax.label_outer()\n",
     "\n",
     "plt.tight_layout()\n",
     "plt.show()"
@@ -152,7 +151,7 @@
     "class_names = list(datasets.keys())\n",
     "num_classes = len(class_names)\n",
     "\n",
-    "fig, axes = plt.subplots(1, num_classes, figsize=(4 * num_classes, 4))  # 1 row, 4 columns\n",
+    "fig, axes = plt.subplots(1, num_classes, figsize=(4 * num_classes, 4)) \n",
     "\n",
     "for i, (class_name, images) in enumerate(datasets.items()):\n",
     "    avg_img = np.mean(images.astype(np.float32), axis=0)\n",
@@ -209,7 +208,6 @@
     "\n",
     "X_augmented, y_augmented = augment_rotations(X_train, y_train)\n",
     "\n",
-    "# Combine original and augmented data\n",
     "X_train_combined = torch.cat([X_train, X_augmented])\n",
     "y_train_combined = torch.cat([y_train, y_augmented])\n",
     "\n",
@@ -230,9 +228,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "print(f\"🔢 Train Dataset: {len(train_dataset)} samples, {len(train_loader)} batches\")\n",
-    "print(f\"🔢 Val Dataset:   {len(val_dataset)} samples, {len(val_loader)} batches\")\n",
-    "print(f\"🔢 Test Dataset:  {len(test_dataset)} samples, {len(test_loader)} batches\")"
+    "print(f\"Train Dataset: {len(train_dataset)} samples, {len(train_loader)} batches\")\n",
+    "print(f\"Val Dataset:   {len(val_dataset)} samples, {len(val_loader)} batches\")\n",
+    "print(f\"Test Dataset:  {len(test_dataset)} samples, {len(test_loader)} batches\")"
    ]
   },
   {
@@ -480,29 +478,24 @@
     "            activations[name] = output.detach().cpu()\n",
     "        return hook\n",
     "\n",
-    "    # Register hooks for all layers in model.features\n",
     "    hooks = []\n",
     "    for i in range(len(model.features)):\n",
     "        layer = model.features[i]\n",
     "        hooks.append(layer.register_forward_hook(get_activation(f\"features_{i}\")))\n",
     "\n",
     "    with torch.no_grad():\n",
-    "        _ = model(image_tensor.unsqueeze(0))  # Add batch dimension: [1, 3, 224, 224]\n",
+    "        _ = model(image_tensor.unsqueeze(0)) \n",
     "\n",
     "    for h in hooks:\n",
     "        h.remove()\n",
     "\n",
     "    for layer_name, fmap in activations.items():\n",
-    "        fmap = fmap.squeeze(0)  # Shape: [C, H, W]\n",
+    "        fmap = fmap.squeeze(0) \n",
+    "        channel_scores = fmap.mean(dim=(1, 2))\n",
     "\n",
-    "        # Compute mean activation per channel\n",
-    "        channel_scores = fmap.mean(dim=(1, 2))  # [C]\n",
-    "\n",
-    "        # Get indices of top-k channels\n",
     "        topk = torch.topk(channel_scores, k=min(max_channels, fmap.shape[0]))\n",
     "        top_indices = topk.indices\n",
     "\n",
-    "        # Plot top-k channels\n",
     "        plt.figure(figsize=(max_channels * 2, 2.5))\n",
     "        for idx, ch in enumerate(top_indices):\n",
     "            plt.subplot(1, max_channels, idx + 1)\n",
@@ -535,14 +528,12 @@
     "\n",
     "img = Image.open(\"dataset/Onion_512/Whole/image_0001.jpg\").convert(\"RGB\")\n",
     "\n",
-    "# Preprocessing (must match model requirements)\n",
     "transform = transforms.Compose([\n",
     "    transforms.Resize((224, 224)),\n",
     "    transforms.ToTensor()\n",
     "])\n",
-    "img_tensor = transform(img)  # shape: [3, 224, 224]\n",
+    "img_tensor = transform(img)\n",
     "\n",
-    "# Visualize feature maps\n",
     "visualize_channels(model, img_tensor, max_channels=16)\n"
    ]
   },
@@ -556,14 +547,11 @@
     "\n",
     "img = Image.open(\"dataset/Onion_512/Halved/image_0880.jpg\").convert(\"RGB\")\n",
     "\n",
-    "# Preprocessing (must match model requirements)\n",
     "transform = transforms.Compose([\n",
     "    transforms.Resize((224, 224)),\n",
     "    transforms.ToTensor()\n",
     "])\n",
-    "img_tensor = transform(img)  # shape: [3, 224, 224]\n",
-    "\n",
-    "# Visualize feature maps\n",
+    "img_tensor = transform(img)\n",
     "visualize_channels(model, img_tensor, max_channels=16)\n"
    ]
   },
@@ -576,14 +564,12 @@
    "source": [
     "img = Image.open(\"dataset/Onion_512/Sliced/image_0772.jpg\").convert(\"RGB\")\n",
     "\n",
-    "# Preprocessing (must match model requirements)\n",
     "transform = transforms.Compose([\n",
     "    transforms.Resize((224, 224)),\n",
     "    transforms.ToTensor()\n",
     "])\n",
-    "img_tensor = transform(img)  # shape: [3, 224, 224]\n",
+    "img_tensor = transform(img) \n",
     "\n",
-    "# Visualize feature maps\n",
     "visualize_channels(model, img_tensor, max_channels=16)\n"
    ]
   },

scripts/CV/script_pear.ipynb

@@ -59,10 +59,10 @@
     "def augment_rotations(X, y):\n",
     "    X_aug = []\n",
     "    y_aug = []\n",
-    "    for k in [1, 2, 3]:  # 90, 180, 270 degrees\n",
-    "        X_rot = torch.rot90(X, k=k, dims=[2, 3])  # rotate along H and W\n",
+    "    for k in [1, 2, 3]: \n",
+    "        X_rot = torch.rot90(X, k=k, dims=[2, 3]) \n",
     "        X_aug.append(X_rot)\n",
-    "        y_aug.append(y.clone())  # Same labels for rotated images\n",
+    "        y_aug.append(y.clone())  \n",
     "    return torch.cat(X_aug), torch.cat(y_aug)"
    ]
   },
@@ -122,7 +122,6 @@
     "    plt.suptitle(f\"{class_name.capitalize()} – Random {count} Samples\", fontsize=16)\n",
     "    plt.show()\n",
     "\n",
-    "# Display for each class\n",
     "for class_name, image_array in datasets.items():\n",
     "    show_random_samples(image_array, class_name)\n"
    ]
@@ -138,7 +137,7 @@
     "\n",
     "for ax, (class_name, images) in zip(axes, datasets.items()):\n",
     "    plot_rgb_histogram_subplot(ax, images, class_name)\n",
-    "    ax.label_outer()  # Hide x labels and tick labels for inner plots\n",
+    "    ax.label_outer() \n",
     "\n",
     "plt.tight_layout()\n",
     "plt.show()"
@@ -154,7 +153,7 @@
     "class_names = list(datasets.keys())\n",
     "num_classes = len(class_names)\n",
     "\n",
-    "fig, axes = plt.subplots(1, num_classes, figsize=(4 * num_classes, 4))  # 1 row, 4 columns\n",
+    "fig, axes = plt.subplots(1, num_classes, figsize=(4 * num_classes, 4)) \n",
     "\n",
     "for i, (class_name, images) in enumerate(datasets.items()):\n",
     "    avg_img = np.mean(images.astype(np.float32), axis=0)\n",
@@ -180,7 +179,6 @@
     "    \"whole\": pear_whole_images\n",
     "}\n",
     "\n",
-    "# Combine data\n",
     "X = np.concatenate([pear_halved_images, pear_sliced_images, pear_whole_images], axis=0)\n",
     "y = (\n",
     "    ['halved'] * len(pear_halved_images) +\n",
@@ -188,17 +186,14 @@
     "    ['whole'] * len(pear_whole_images)\n",
     ")\n",
     "\n",
-    "# Normalize and convert to torch tensors\n",
     "X = X.astype(np.float32) / 255.0\n",
-    "X = np.transpose(X, (0, 3, 1, 2))  # (N, C, H, W)\n",
+    "X = np.transpose(X, (0, 3, 1, 2)) \n",
     "X_tensor = torch.tensor(X)\n",
     "\n",
-    "# Encode labels\n",
     "le = LabelEncoder()\n",
     "y_encoded = le.fit_transform(y)\n",
     "y_tensor = torch.tensor(y_encoded)\n",
     "\n",
-    "# Train/val/test split\n",
     "X_train, X_temp, y_train, y_temp = train_test_split(X_tensor, y_tensor, test_size=0.4, stratify=y_tensor, random_state=42)\n",
     "X_val, X_test, y_val, y_test = train_test_split(X_temp, y_temp, test_size=0.5, stratify=y_temp, random_state=42)\n"
    ]
@@ -215,7 +210,6 @@
     "val_dataset   = TensorDataset(X_val, y_val)\n",
     "test_dataset  = TensorDataset(X_test, y_test)\n",
     "\n",
-    "# DataLoaders\n",
     "batch_size = 32\n",
     "train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)\n",
     "val_loader   = DataLoader(val_dataset, batch_size=batch_size)\n",
@@ -229,9 +223,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "print(f\"🔢 Train Dataset: {len(train_dataset)} samples, {len(train_loader)} batches\")\n",
-    "print(f\"🔢 Val Dataset:   {len(val_dataset)} samples, {len(val_loader)} batches\")\n",
-    "print(f\"🔢 Test Dataset:  {len(test_dataset)} samples, {len(test_loader)} batches\")"
+    "print(f\"Train Dataset: {len(train_dataset)} samples, {len(train_loader)} batches\")\n",
+    "print(f\"Val Dataset:   {len(val_dataset)} samples, {len(val_loader)} batches\")\n",
+    "print(f\"Test Dataset:  {len(test_dataset)} samples, {len(test_loader)} batches\")"
    ]
   },
   {
@@ -249,8 +243,6 @@
     "\n",
     "def get_efficientnet_model(num_classes):\n",
     "    model = models.efficientnet_b0(weights=models.EfficientNet_B0_Weights.DEFAULT)\n",
-    "\n",
-    "    # Replace classifier head with custom head\n",
     "    model.classifier[1] = nn.Linear(model.classifier[1].in_features, num_classes)\n",
     "\n",
     "    return model\n",
@@ -266,10 +258,10 @@
    "source": [
     "if torch.backends.mps.is_available():\n",
     "    device = torch.device(\"mps\")\n",
-    "    print(\"✅ Using MPS (Apple GPU)\")\n",
+    "    print(\"Using MPS (Apple GPU)\")\n",
     "else:\n",
     "    device = torch.device(\"cpu\")\n",
-    "    print(\"⚠️ MPS not available. Using CPU\")\n",
+    "    print(\"MPS not available. Using CPU\")\n",
     "\n",
     "model = get_efficientnet_model(num_classes=3).to(device)\n",
     "optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)\n",
@@ -312,7 +304,6 @@
     "\n",
     "        total_train_loss += loss.item()\n",
     "\n",
-    "        # Track training accuracy\n",
     "        pred_labels = preds.argmax(dim=1)\n",
     "        train_correct += (pred_labels == batch_y).sum().item()\n",
     "        train_total += batch_y.size(0)\n",
@@ -367,7 +358,6 @@
     "\n",
     "plt.figure(figsize=(12, 5))\n",
     "\n",
-    "# Plot Loss\n",
     "plt.subplot(1, 2, 1)\n",
     "plt.plot(epochs, train_losses, label='Train Loss', marker='o')\n",
     "plt.plot(epochs, val_losses, label='Validation Loss', marker='s')\n",
@@ -377,7 +367,6 @@
     "plt.legend()\n",
     "plt.grid(True)\n",
     "\n",
-    "# Plot Accuracy\n",
     "plt.subplot(1, 2, 2)\n",
     "plt.plot(epochs, train_accs, label='Train Accuracy', marker='o')\n",
     "plt.plot(epochs, val_accs, label='Validation Accuracy', marker='s')\n",
@@ -490,29 +479,24 @@
     "            activations[name] = output.detach().cpu()\n",
     "        return hook\n",
     "\n",
-    "    # Register hooks for all layers in model.features\n",
     "    hooks = []\n",
     "    for i in range(len(model.features)):\n",
     "        layer = model.features[i]\n",
     "        hooks.append(layer.register_forward_hook(get_activation(f\"features_{i}\")))\n",
     "\n",
     "    with torch.no_grad():\n",
-    "        _ = model(image_tensor.unsqueeze(0))  # Add batch dimension: [1, 3, 224, 224]\n",
+    "        _ = model(image_tensor.unsqueeze(0)) \n",
     "\n",
     "    for h in hooks:\n",
     "        h.remove()\n",
     "\n",
     "    for layer_name, fmap in activations.items():\n",
-    "        fmap = fmap.squeeze(0)  # Shape: [C, H, W]\n",
-    "\n",
-    "        # Compute mean activation per channel\n",
-    "        channel_scores = fmap.mean(dim=(1, 2))  # [C]\n",
+    "        fmap = fmap.squeeze(0)  \n",
+    "        channel_scores = fmap.mean(dim=(1, 2)) \n",
     "\n",
-    "        # Get indices of top-k channels\n",
     "        topk = torch.topk(channel_scores, k=min(max_channels, fmap.shape[0]))\n",
     "        top_indices = topk.indices\n",
     "\n",
-    "        # Plot top-k channels\n",
     "        plt.figure(figsize=(max_channels * 2, 2.5))\n",
     "        for idx, ch in enumerate(top_indices):\n",
     "            plt.subplot(1, max_channels, idx + 1)\n",
@@ -545,14 +529,11 @@
     "\n",
     "img = Image.open(\"dataset/Pear_512/Whole/image_0007.jpg\").convert(\"RGB\")\n",
     "\n",
-    "# Preprocessing (must match model requirements)\n",
     "transform = transforms.Compose([\n",
     "    transforms.Resize((224, 224)),\n",
     "    transforms.ToTensor()\n",
     "])\n",
-    "img_tensor = transform(img)  # shape: [3, 224, 224]\n",
-    "\n",
-    "# Visualize feature maps\n",
+    "img_tensor = transform(img)  \n",
     "visualize_channels(model, img_tensor, max_channels=16)\n"
    ]
   },
@@ -565,14 +546,11 @@
    "source": [
     "img = Image.open(\"dataset/Pear_512/Halved/image_0578.jpg\").convert(\"RGB\")\n",
     "\n",
-    "# Preprocessing (must match model requirements)\n",
     "transform = transforms.Compose([\n",
     "    transforms.Resize((224, 224)),\n",
     "    transforms.ToTensor()\n",
     "])\n",
-    "img_tensor = transform(img)  # shape: [3, 224, 224]\n",
-    "\n",
-    "# Visualize feature maps\n",
+    "img_tensor = transform(img)  \n",
     "visualize_channels(model, img_tensor, max_channels=16)\n"
    ]
   },
@@ -584,15 +562,11 @@
    "outputs": [],
    "source": [
     "img = Image.open(\"dataset/Pear_512/Sliced/image_0007.jpg\").convert(\"RGB\")\n",
-    "\n",
-    "# Preprocessing (must match model requirements)\n",
     "transform = transforms.Compose([\n",
     "    transforms.Resize((224, 224)),\n",
     "    transforms.ToTensor()\n",
     "])\n",
-    "img_tensor = transform(img)  # shape: [3, 224, 224]\n",
-    "\n",
-    "# Visualize feature maps\n",
+    "img_tensor = transform(img)  \n",
     "visualize_channels(model, img_tensor, max_channels=16)\n"
    ]
   },

scripts/CV/script_strawberry.ipynb

@@ -59,10 +59,10 @@
     "def augment_rotations(X, y):\n",
     "    X_aug = []\n",
     "    y_aug = []\n",
-    "    for k in [1, 2, 3]:  # 90, 180, 270 degrees\n",
-    "        X_rot = torch.rot90(X, k=k, dims=[2, 3])  # rotate along H and W\n",
+    "    for k in [1, 2, 3]: \n",
+    "        X_rot = torch.rot90(X, k=k, dims=[2, 3])  \n",
     "        X_aug.append(X_rot)\n",
-    "        y_aug.append(y.clone())  # Same labels for rotated images\n",
+    "        y_aug.append(y.clone()) \n",
     "    return torch.cat(X_aug), torch.cat(y_aug)"
    ]
   },
@@ -124,7 +124,6 @@
     "    plt.suptitle(f\"{class_name.capitalize()} – Random {count} Samples\", fontsize=16)\n",
     "    plt.show()\n",
     "\n",
-    "# Display for each class\n",
     "for class_name, image_array in datasets.items():\n",
     "    show_random_samples(image_array, class_name)\n"
    ]
@@ -140,7 +139,7 @@
     "\n",
     "for ax, (class_name, images) in zip(axes, datasets.items()):\n",
     "    plot_rgb_histogram_subplot(ax, images, class_name)\n",
-    "    ax.label_outer()  # Hide x labels and tick labels for inner plots\n",
+    "    ax.label_outer() \n",
     "\n",
     "plt.tight_layout()\n",
     "plt.show()"
@@ -156,7 +155,7 @@
     "class_names = list(datasets.keys())\n",
     "num_classes = len(class_names)\n",
     "\n",
-    "fig, axes = plt.subplots(1, num_classes, figsize=(4 * num_classes, 4))  # 1 row, 4 columns\n",
+    "fig, axes = plt.subplots(1, num_classes, figsize=(4 * num_classes, 4)) \n",
     "\n",
     "for i, (class_name, images) in enumerate(datasets.items()):\n",
     "    avg_img = np.mean(images.astype(np.float32), axis=0)\n",
@@ -181,7 +180,6 @@
     "    \"whole\": strawberry_whole_images\n",
     "}\n",
     "\n",
-    "# Combine data\n",
     "X = np.concatenate([strawberry_hulled_images, strawberry_sliced_images, strawberry_whole_images], axis=0)\n",
     "y = (\n",
     "    ['hulled'] * len(strawberry_hulled_images) +\n",
@@ -189,17 +187,14 @@
     "    ['whole'] * len(strawberry_whole_images)\n",
     ")\n",
     "\n",
-    "# Normalize and convert to torch tensors\n",
     "X = X.astype(np.float32) / 255.0\n",
-    "X = np.transpose(X, (0, 3, 1, 2))  # (N, C, H, W)\n",
+    "X = np.transpose(X, (0, 3, 1, 2)) \n",
     "X_tensor = torch.tensor(X)\n",
     "\n",
-    "# Encode labels\n",
     "le = LabelEncoder()\n",
     "y_encoded = le.fit_transform(y)\n",
     "y_tensor = torch.tensor(y_encoded)\n",
     "\n",
-    "# Train/val/test split\n",
     "X_train, X_temp, y_train, y_temp = train_test_split(X_tensor, y_tensor, test_size=0.5, stratify=y_tensor, random_state=42)\n",
     "X_val, X_test, y_val, y_test = train_test_split(X_temp, y_temp, test_size=0.5, stratify=y_temp, random_state=42)\n"
    ]
@@ -215,11 +210,9 @@
     "\n",
     "X_augmented, y_augmented = augment_rotations(X_train, y_train)\n",
     "\n",
-    "# Combine original and augmented data\n",
     "X_train_combined = torch.cat([X_train, X_augmented])\n",
     "y_train_combined = torch.cat([y_train, y_augmented])\n",
     "\n",
-    "\n",
     "train_dataset = TensorDataset(X_train_combined, y_train_combined)\n",
     "val_dataset   = TensorDataset(X_val, y_val)\n",
     "test_dataset  = TensorDataset(X_test, y_test)\n",
@@ -236,9 +229,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "print(f\"🔢 Train Dataset: {len(train_dataset)} samples, {len(train_loader)} batches\")\n",
-    "print(f\"🔢 Val Dataset:   {len(val_dataset)} samples, {len(val_loader)} batches\")\n",
-    "print(f\"🔢 Test Dataset:  {len(test_dataset)} samples, {len(test_loader)} batches\")"
+    "print(f\"Train Dataset: {len(train_dataset)} samples, {len(train_loader)} batches\")\n",
+    "print(f\"Val Dataset:   {len(val_dataset)} samples, {len(val_loader)} batches\")\n",
+    "print(f\"Test Dataset:  {len(test_dataset)} samples, {len(test_loader)} batches\")"
    ]
   },
   {
@@ -341,7 +334,6 @@
     "    val_accuracy = val_correct / val_total\n",
     "    validation_loss = criterion(model(val_x), val_y).item()\n",
     "\n",
-    "    # After calculating val_accuracy\n",
     "    val_losses.append(validation_loss)\n",
     "    val_accs.append(val_accuracy)\n",
     "\n",
@@ -449,29 +441,25 @@
    "source": [
     "all_preds = np.array(all_preds)\n",
     "all_targets = np.array(all_targets)\n",
-    "all_images = torch.stack(all_images)  # shape: [N, C, H, W]\n",
+    "all_images = torch.stack(all_images) \n",
     "\n",
-    "# Per class FP and FN\n",
     "for class_idx, class_name in enumerate(target_names):\n",
-    "    print(f\"\\n🔍 Showing False Negatives and False Positives for class: {class_name}\")\n",
-    "\n",
-    "    # False Negatives: True label is class_idx, but predicted something else\n",
+    "    print(f\"\\nShowing False Negatives and False Positives for class: {class_name}\")\n",
     "    fn_indices = np.where((all_targets == class_idx) & (all_preds != class_idx))[0]\n",
-    "    # False Positives: Predicted class_idx, but true label is different\n",
     "    fp_indices = np.where((all_preds == class_idx) & (all_targets != class_idx))[0]\n",
     "\n",
     "    def show_images(indices, title, max_images=5):\n",
     "        num = min(len(indices), max_images)\n",
     "        if num == 0:\n",
-    "            print(f\"❌ No {title} samples.\")\n",
+    "            print(f\"No {title} samples.\")\n",
     "            return\n",
     "\n",
     "        plt.figure(figsize=(12, 2))\n",
     "        for i, idx in enumerate(indices[:num]):\n",
     "            img = all_images[idx]\n",
-    "            img = img.permute(1, 2, 0).numpy()  # [C, H, W] → [H, W, C]\n",
+    "            img = img.permute(1, 2, 0).numpy()\n",
     "            plt.subplot(1, num, i + 1)\n",
-    "            plt.imshow((img - img.min()) / (img.max() - img.min()))  # normalize to [0,1] for display\n",
+    "            plt.imshow((img - img.min()) / (img.max() - img.min()))\n",
     "            plt.axis('off')\n",
     "            plt.title(f\"Pred: {target_names[all_preds[idx]]}\\nTrue: {target_names[all_targets[idx]]}\")\n",
     "        plt.suptitle(f\"{title} for {class_name}\")\n",
@@ -498,29 +486,25 @@
     "            activations[name] = output.detach().cpu()\n",
     "        return hook\n",
     "\n",
-    "    # Register hooks for all layers in model.features\n",
     "    hooks = []\n",
     "    for i in range(len(model.features)):\n",
     "        layer = model.features[i]\n",
     "        hooks.append(layer.register_forward_hook(get_activation(f\"features_{i}\")))\n",
     "\n",
     "    with torch.no_grad():\n",
-    "        _ = model(image_tensor.unsqueeze(0))  # Add batch dimension: [1, 3, 224, 224]\n",
+    "        _ = model(image_tensor.unsqueeze(0)) \n",
     "\n",
     "    for h in hooks:\n",
     "        h.remove()\n",
     "\n",
     "    for layer_name, fmap in activations.items():\n",
-    "        fmap = fmap.squeeze(0)  # Shape: [C, H, W]\n",
+    "        fmap = fmap.squeeze(0) \n",
     "\n",
-    "        # Compute mean activation per channel\n",
-    "        channel_scores = fmap.mean(dim=(1, 2))  # [C]\n",
+    "        channel_scores = fmap.mean(dim=(1, 2))\n",
     "\n",
-    "        # Get indices of top-k channels\n",
     "        topk = torch.topk(channel_scores, k=min(max_channels, fmap.shape[0]))\n",
     "        top_indices = topk.indices\n",
     "\n",
-    "        # Plot top-k channels\n",
     "        plt.figure(figsize=(max_channels * 2, 2.5))\n",
     "        for idx, ch in enumerate(top_indices):\n",
     "            plt.subplot(1, max_channels, idx + 1)\n",
@@ -553,14 +537,12 @@
     "\n",
     "img = Image.open(\"dataset/Strawberry_512/Whole/image_0017.jpg\").convert(\"RGB\")\n",
     "\n",
-    "# Preprocessing (must match model requirements)\n",
     "transform = transforms.Compose([\n",
     "    transforms.Resize((224, 224)),\n",
     "    transforms.ToTensor()\n",
     "])\n",
-    "img_tensor = transform(img)  # shape: [3, 224, 224]\n",
+    "img_tensor = transform(img)  \n",
     "\n",
-    "# Visualize feature maps\n",
     "visualize_channels(model, img_tensor, max_channels=16)\n"
    ]
   },
@@ -574,14 +556,12 @@
     "\n",
     "img = Image.open(\"dataset/Strawberry_512/Hulled/image_0001.jpg\").convert(\"RGB\")\n",
     "\n",
-    "# Preprocessing (must match model requirements)\n",
     "transform = transforms.Compose([\n",
     "    transforms.Resize((224, 224)),\n",
     "    transforms.ToTensor()\n",
     "])\n",
-    "img_tensor = transform(img)  # shape: [3, 224, 224]\n",
+    "img_tensor = transform(img)  \n",
     "\n",
-    "# Visualize feature maps\n",
     "visualize_channels(model, img_tensor, max_channels=16)\n"
    ]
   },
@@ -595,15 +575,13 @@
     "\n",
     "img = Image.open(\"dataset/Strawberry_512/Sliced/image_0001.jpg\").convert(\"RGB\")\n",
     "\n",
-    "# Preprocessing (must match model requirements)\n",
     "transform = transforms.Compose([\n",
     "    transforms.Resize((224, 224)),\n",
     "    transforms.ToTensor()\n",
     "])\n",
-    "img_tensor = transform(img)  # shape: [3, 224, 224]\n",
+    "img_tensor = transform(img)  \n",
     "\n",
-    "# Visualize feature maps\n",
-    "visualize_channels(model, img_tensor, max_channels=16)\n"
+    "visualize_channels(model, img_tensor, max_channels=16)"
    ]
   },
   {

scripts/CV/script_tomato.ipynb

@@ -13,7 +13,6 @@
     "import matplotlib.pyplot as plt\n",
     "import random\n",
     "import torch\n",
-    "import numpy as np\n",
     "from torch.utils.data import Dataset, DataLoader, TensorDataset\n",
     "from sklearn.preprocessing import LabelEncoder\n",
     "from sklearn.model_selection import train_test_split\n",
@@ -59,10 +58,10 @@
     "def augment_rotations(X, y):\n",
     "    X_aug = []\n",
     "    y_aug = []\n",
-    "    for k in [1, 2, 3]:  # 90, 180, 270 degrees\n",
-    "        X_rot = torch.rot90(X, k=k, dims=[2, 3])  # rotate along H and W\n",
+    "    for k in [1, 2, 3]:  \n",
+    "        X_rot = torch.rot90(X, k=k, dims=[2, 3])  \n",
     "        X_aug.append(X_rot)\n",
-    "        y_aug.append(y.clone())  # Same labels for rotated images\n",
+    "        y_aug.append(y.clone()) \n",
     "    return torch.cat(X_aug), torch.cat(y_aug)"
    ]
   },
@@ -103,8 +102,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "import matplotlib.pyplot as plt\n",
-    "import random\n",
+    "\n",
     "datasets = {\n",
     "    \"diced\": tomato_diced_images,\n",
     "    \"vines\": tomato_vines_images,\n",
@@ -124,7 +122,6 @@
     "    plt.suptitle(f\"{class_name.capitalize()} – Random {count} Samples\", fontsize=16)\n",
     "    plt.show()\n",
     "\n",
-    "# Display for each class\n",
     "for class_name, image_array in datasets.items():\n",
     "    show_random_samples(image_array, class_name)\n"
    ]
@@ -140,7 +137,7 @@
     "\n",
     "for ax, (class_name, images) in zip(axes, datasets.items()):\n",
     "    plot_rgb_histogram_subplot(ax, images, class_name)\n",
-    "    ax.label_outer()  # Hide x labels and tick labels for inner plots\n",
+    "    ax.label_outer()  \n",
     "\n",
     "plt.tight_layout()\n",
     "plt.show()"
@@ -156,7 +153,7 @@
     "class_names = list(datasets.keys())\n",
     "num_classes = len(class_names)\n",
     "\n",
-    "fig, axes = plt.subplots(1, num_classes, figsize=(4 * num_classes, 4))  # 1 row, 4 columns\n",
+    "fig, axes = plt.subplots(1, num_classes, figsize=(4 * num_classes, 4)) \n",
     "\n",
     "for i, (class_name, images) in enumerate(datasets.items()):\n",
     "    avg_img = np.mean(images.astype(np.float32), axis=0)\n",
@@ -175,20 +172,12 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "import torch\n",
-    "import numpy as np\n",
-    "from torch.utils.data import Dataset, DataLoader, TensorDataset\n",
-    "from sklearn.preprocessing import LabelEncoder\n",
-    "from sklearn.model_selection import train_test_split\n",
-    "from torchvision import transforms\n",
-    "\n",
     "datasets = {\n",
     "    \"diced\": tomato_diced_images,\n",
     "    \"vines\": tomato_vines_images,\n",
     "    \"whole\": tomato_whole_images\n",
     "}\n",
     "\n",
-    "# Combine data\n",
     "X = np.concatenate([tomato_diced_images, tomato_vines_images, tomato_whole_images], axis=0)\n",
     "y = (\n",
     "    ['diced'] * len(tomato_diced_images) +\n",
@@ -196,17 +185,14 @@
     "    ['whole'] * len(tomato_whole_images)\n",
     ")\n",
     "\n",
-    "# Normalize and convert to torch tensors\n",
     "X = X.astype(np.float32) / 255.0\n",
-    "X = np.transpose(X, (0, 3, 1, 2))  # (N, C, H, W)\n",
+    "X = np.transpose(X, (0, 3, 1, 2))\n",
     "X_tensor = torch.tensor(X)\n",
     "\n",
-    "# Encode labels\n",
     "le = LabelEncoder()\n",
     "y_encoded = le.fit_transform(y)\n",
     "y_tensor = torch.tensor(y_encoded)\n",
     "\n",
-    "# Train/val/test split\n",
     "X_train, X_temp, y_train, y_temp = train_test_split(X_tensor, y_tensor, test_size=0.4, stratify=y_tensor, random_state=42)\n",
     "X_val, X_test, y_val, y_test = train_test_split(X_temp, y_temp, test_size=0.5, stratify=y_temp, random_state=42)\n"
    ]
@@ -222,17 +208,13 @@
     "\n",
     "X_augmented, y_augmented = augment_rotations(X_train, y_train)\n",
     "\n",
-    "# Combine original and augmented data\n",
     "X_train_combined = torch.cat([X_train, X_augmented])\n",
     "y_train_combined = torch.cat([y_train, y_augmented])\n",
     "\n",
-    "# Create new training dataset and loader\n",
-    "\n",
     "train_dataset = TensorDataset(X_train, y_train)\n",
     "val_dataset   = TensorDataset(X_val, y_val)\n",
     "test_dataset  = TensorDataset(X_test, y_test)\n",
     "\n",
-    "# DataLoaders\n",
     "\n",
     "train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)\n",
     "val_loader   = DataLoader(val_dataset, batch_size=batch_size)\n",
@@ -246,9 +228,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "print(f\"🔢 Train Dataset: {len(train_dataset)} samples, {len(train_loader)} batches\")\n",
-    "print(f\"🔢 Val Dataset:   {len(val_dataset)} samples, {len(val_loader)} batches\")\n",
-    "print(f\"🔢 Test Dataset:  {len(test_dataset)} samples, {len(test_loader)} batches\")"
+    "print(f\"Train Dataset: {len(train_dataset)} samples, {len(train_loader)} batches\")\n",
+    "print(f\"Val Dataset:   {len(val_dataset)} samples, {len(val_loader)} batches\")\n",
+    "print(f\"Test Dataset:  {len(test_dataset)} samples, {len(test_loader)} batches\")"
    ]
   },
   {
@@ -258,18 +240,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "import torch.nn as nn\n",
-    "import torch.nn.functional as F\n",
-    "\n",
-    "import torch.nn as nn\n",
-    "import torchvision.models as models\n",
-    "\n",
     "def get_efficientnet_model(num_classes):\n",
     "    model = models.efficientnet_b0(weights=models.EfficientNet_B0_Weights.DEFAULT)\n",
-    "\n",
-    "    # Replace classifier head with custom head\n",
     "    model.classifier[1] = nn.Linear(model.classifier[1].in_features, num_classes)\n",
-    "\n",
     "    return model\n",
     "\n"
    ]
@@ -283,10 +256,10 @@
    "source": [
     "if torch.backends.mps.is_available():\n",
     "    device = torch.device(\"mps\")\n",
-    "    print(\"✅ Using MPS (Apple GPU)\")\n",
+    "    print(\"Using MPS (Apple GPU)\")\n",
     "else:\n",
     "    device = torch.device(\"cpu\")\n",
-    "    print(\"⚠️ MPS not available. Using CPU\")\n",
+    "    print(\"MPS not available. Using CPU\")\n",
     "\n",
     "model = get_efficientnet_model(num_classes=3).to(device)\n",
     "optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)\n",
@@ -329,7 +302,6 @@
     "\n",
     "        total_train_loss += loss.item()\n",
     "\n",
-    "        # Track training accuracy\n",
     "        pred_labels = preds.argmax(dim=1)\n",
     "        train_correct += (pred_labels == batch_y).sum().item()\n",
     "        train_total += batch_y.size(0)\n",
@@ -353,7 +325,6 @@
     "    val_accuracy = val_correct / val_total\n",
     "    validation_loss = criterion(model(val_x), val_y).item()\n",
     "\n",
-    "    # After calculating val_accuracy\n",
     "    val_losses.append(validation_loss)\n",
     "    val_accs.append(val_accuracy)\n",
     "\n",
@@ -381,13 +352,12 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "import matplotlib.pyplot as plt\n",
+    "\n",
     "\n",
     "epochs = range(1, len(train_losses) + 1)\n",
     "\n",
     "plt.figure(figsize=(12, 5))\n",
     "\n",
-    "# Plot Loss\n",
     "plt.subplot(1, 2, 1)\n",
     "plt.plot(epochs, train_losses, label='Train Loss', marker='o')\n",
     "plt.plot(epochs, val_losses, label='Validation Loss', marker='s')\n",
@@ -397,7 +367,6 @@
     "plt.legend()\n",
     "plt.grid(True)\n",
     "\n",
-    "# Plot Accuracy\n",
     "plt.subplot(1, 2, 2)\n",
     "plt.plot(epochs, train_accs, label='Train Accuracy', marker='o')\n",
     "plt.plot(epochs, val_accs, label='Validation Accuracy', marker='s')\n",
@@ -462,35 +431,28 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "import torch\n",
-    "import numpy as np\n",
-    "import matplotlib.pyplot as plt\n",
     "\n",
     "all_preds = np.array(all_preds)\n",
     "all_targets = np.array(all_targets)\n",
-    "all_images = torch.stack(all_images)  # shape: [N, C, H, W]\n",
+    "all_images = torch.stack(all_images) \n",
     "\n",
-    "# Per class FP and FN\n",
     "for class_idx, class_name in enumerate(target_names):\n",
-    "    print(f\"\\n🔍 Showing False Negatives and False Positives for class: {class_name}\")\n",
-    "\n",
-    "    # False Negatives: True label is class_idx, but predicted something else\n",
+    "    print(f\"\\nShowing False Negatives and False Positives for class: {class_name}\")\n",
     "    fn_indices = np.where((all_targets == class_idx) & (all_preds != class_idx))[0]\n",
-    "    # False Positives: Predicted class_idx, but true label is different\n",
     "    fp_indices = np.where((all_preds == class_idx) & (all_targets != class_idx))[0]\n",
     "\n",
     "    def show_images(indices, title, max_images=5):\n",
     "        num = min(len(indices), max_images)\n",
     "        if num == 0:\n",
-    "            print(f\"❌ No {title} samples.\")\n",
+    "            print(f\"No {title} samples.\")\n",
     "            return\n",
     "\n",
     "        plt.figure(figsize=(12, 2))\n",
     "        for i, idx in enumerate(indices[:num]):\n",
     "            img = all_images[idx]\n",
-    "            img = img.permute(1, 2, 0).numpy()  # [C, H, W] → [H, W, C]\n",
+    "            img = img.permute(1, 2, 0).numpy()\n",
     "            plt.subplot(1, num, i + 1)\n",
-    "            plt.imshow((img - img.min()) / (img.max() - img.min()))  # normalize to [0,1] for display\n",
+    "            plt.imshow((img - img.min()) / (img.max() - img.min())) \n",
     "            plt.axis('off')\n",
     "            plt.title(f\"Pred: {target_names[all_preds[idx]]}\\nTrue: {target_names[all_targets[idx]]}\")\n",
     "        plt.suptitle(f\"{title} for {class_name}\")\n",
@@ -517,29 +479,25 @@
     "            activations[name] = output.detach().cpu()\n",
     "        return hook\n",
     "\n",
-    "    # Register hooks for all layers in model.features\n",
     "    hooks = []\n",
     "    for i in range(len(model.features)):\n",
     "        layer = model.features[i]\n",
     "        hooks.append(layer.register_forward_hook(get_activation(f\"features_{i}\")))\n",
     "\n",
     "    with torch.no_grad():\n",
-    "        _ = model(image_tensor.unsqueeze(0))  # Add batch dimension: [1, 3, 224, 224]\n",
+    "        _ = model(image_tensor.unsqueeze(0)) \n",
     "\n",
     "    for h in hooks:\n",
     "        h.remove()\n",
     "\n",
     "    for layer_name, fmap in activations.items():\n",
-    "        fmap = fmap.squeeze(0)  # Shape: [C, H, W]\n",
+    "        fmap = fmap.squeeze(0) \n",
     "\n",
-    "        # Compute mean activation per channel\n",
-    "        channel_scores = fmap.mean(dim=(1, 2))  # [C]\n",
+    "        channel_scores = fmap.mean(dim=(1, 2)) \n",
     "\n",
-    "        # Get indices of top-k channels\n",
     "        topk = torch.topk(channel_scores, k=min(max_channels, fmap.shape[0]))\n",
     "        top_indices = topk.indices\n",
     "\n",
-    "        # Plot top-k channels\n",
     "        plt.figure(figsize=(max_channels * 2, 2.5))\n",
     "        for idx, ch in enumerate(top_indices):\n",
     "            plt.subplot(1, max_channels, idx + 1)\n",
@@ -572,14 +530,12 @@
     "\n",
     "img = Image.open(\"dataset/Tomato_512/Whole/image_0007.jpg\").convert(\"RGB\")\n",
     "\n",
-    "# Preprocessing (must match model requirements)\n",
     "transform = transforms.Compose([\n",
     "    transforms.Resize((224, 224)),\n",
     "    transforms.ToTensor()\n",
     "])\n",
-    "img_tensor = transform(img)  # shape: [3, 224, 224]\n",
+    "img_tensor = transform(img) \n",
     "\n",
-    "# Visualize feature maps\n",
     "visualize_channels(model, img_tensor, max_channels=16)\n"
    ]
   },
@@ -592,14 +548,12 @@
    "source": [
     "img = Image.open(\"dataset/Tomato_512/On_the_vines/image_0578.jpg\").convert(\"RGB\")\n",
     "\n",
-    "# Preprocessing (must match model requirements)\n",
     "transform = transforms.Compose([\n",
     "    transforms.Resize((224, 224)),\n",
     "    transforms.ToTensor()\n",
     "])\n",
-    "img_tensor = transform(img)  # shape: [3, 224, 224]\n",
+    "img_tensor = transform(img) \n",
     "\n",
-    "# Visualize feature maps\n",
     "visualize_channels(model, img_tensor, max_channels=16)\n"
    ]
   },
@@ -612,14 +566,12 @@
    "source": [
     "img = Image.open(\"dataset/Tomato_512/Diced/image_0578.jpg\").convert(\"RGB\")\n",
     "\n",
-    "# Preprocessing (must match model requirements)\n",
     "transform = transforms.Compose([\n",
     "    transforms.Resize((224, 224)),\n",
     "    transforms.ToTensor()\n",
     "])\n",
-    "img_tensor = transform(img)  # shape: [3, 224, 224]\n",
+    "img_tensor = transform(img) \n",
     "\n",
-    "# Visualize feature maps\n",
     "visualize_channels(model, img_tensor, max_channels=16)\n"
    ]
   },