Image Classification: Change img to image (#370)

Author: fabioacl

31_image_classification.ipynb

@@ -588,9 +588,9 @@
     "    with open(filepath, \"rb\") as f:\n",
     "        return pickle.load(f)\n",
     "\n",
-    "def plot_image(img, figsize = (2,3)):\n",
+    "def plot_image(image, figsize = (2,3)):\n",
     "    plt.figure(figsize = figsize)\n",
-    "    plt.imshow(img)\n",
+    "    plt.imshow(image)\n",
     "    plt.axis(\"off\")\n",
     "    \n",
     "def plot_multiple_images(*images_titles, figsize = (2, 3)):\n",
@@ -750,14 +750,14 @@
     "\n",
     "import cv2\n",
     "import numpy as np\n",
-    "def solution_scale_image(img: np.ndarray, scale_factor: float):\n",
+    "def solution_scale_image(image: np.ndarray, scale_factor: float):\n",
     "    \"\"\"\n",
     "    The function takes an image as input and rescales it to a new dimension.\n",
     "    For that, you need to compute the new dimensions of the image using the scale factor \n",
-    "    and then use OpenCV's `cv2.resize` function to resize the image, e.g., `cv2.resize(img, (new_width, new_height))`.\n",
+    "    and then use OpenCV's `cv2.resize` function to resize the image, e.g., `cv2.resize(image, (new_width, new_height))`.\n",
     "\n",
     "    Args:\n",
-    "        img (np.ndarray): The input image.\n",
+    "        image (np.ndarray): The input image.\n",
     "        scale_factor (float): The factor by which to scale the image.\n",
     "\n",
     "    Returns:\n",
@@ -812,17 +812,17 @@
     "\n",
     "import cv2\n",
     "import numpy as np\n",
-    "def solution_crop_image(img: np.ndarray, x: int, y: int, width: int, height: int):\n",
+    "def solution_crop_image(image: np.ndarray, x: int, y: int, width: int, height: int):\n",
     "    \"\"\"\n",
     "    The function takes an image as input and crops it to a specified rectangular region.\n",
     "    In OpenCV, images are represented as NumPy arrays. You can crop the image by \n",
     "    using array slicing, keeping in mind that the first dimension is the y-axis (rows) \n",
-    "    and the second dimension is the x-axis (columns): `img[y_start:y_end, x_start:x_end]`. \n",
+    "    and the second dimension is the x-axis (columns): `image[y_start:y_end, x_start:x_end]`. \n",
     "    You will need to calculate these start and end coordinates using the provided \n",
     "    x, y, width, and height parameters.\n",
     "\n",
     "    Args:\n",
-    "        img (np.ndarray): The input image.\n",
+    "        image (np.ndarray): The input image.\n",
     "        x (int): The starting x-coordinate (column) of the crop.\n",
     "        y (int): The starting y-coordinate (row) of the crop.\n",
     "        width (int): The width of the cropped region.\n",
@@ -880,7 +880,7 @@
     "\n",
     "import cv2\n",
     "import numpy as np\n",
-    "def solution_horizontal_flip_image(img: np.ndarray):\n",
+    "def solution_horizontal_flip_image(image: np.ndarray):\n",
     "    \"\"\"\n",
     "    The function takes an image as input and flips it horizontally (creating a mirror image).\n",
     "    To do this, use OpenCV's `cv2.flip(src, flipCode)` function. The `flipCode` integer \n",
@@ -890,7 +890,7 @@
     "    - Use -1 for both axes.\n",
     "\n",
     "    Args:\n",
-    "        img (np.ndarray): The input image.\n",
+    "        image (np.ndarray): The input image.\n",
     "\n",
     "    Returns:\n",
     "        np.ndarray: The horizontally flipped image.\n",
@@ -944,7 +944,7 @@
     "\n",
     "import cv2\n",
     "import numpy as np\n",
-    "def solution_vertical_flip_image(img: np.ndarray):\n",
+    "def solution_vertical_flip_image(image: np.ndarray):\n",
     "    \"\"\"\n",
     "    The function takes an image as input and flips it vertically.\n",
     "    To do this, use OpenCV's `cv2.flip(src, flipCode)` function. The `flipCode` integer \n",
@@ -954,7 +954,7 @@
     "    - Use -1 for both axes.\n",
     "\n",
     "    Args:\n",
-    "        img (np.ndarray): The input image.\n",
+    "        image (np.ndarray): The input image.\n",
     "\n",
     "    Returns:\n",
     "        np.ndarray: The vertically flipped image.\n",
@@ -1008,7 +1008,7 @@
     "\n",
     "import cv2\n",
     "import numpy as np\n",
-    "def solution_rotate_image(img: np.ndarray, angle: float):\n",
+    "def solution_rotate_image(image: np.ndarray, angle: float):\n",
     "    \"\"\"\n",
     "    The function takes an image as input and rotates it by a specified angle. \n",
     "    To ensure the corners of the image are not cropped after rotation, you must \n",
@@ -1029,10 +1029,10 @@
     "       mat[0, 2] += (new_w / 2) - center[0]\n",
     "       mat[1, 2] += (new_h / 2) - center[1]\n",
     "       \n",
-    "    6. Return the final rotated image using: `cv2.warpAffine(img, mat, (new_w, new_h))`\n",
+    "    6. Return the final rotated image using: `cv2.warpAffine(image, mat, (new_w, new_h))`\n",
     "\n",
     "    Args:\n",
-    "        img (np.ndarray): The input image.\n",
+    "        image (np.ndarray): The input image.\n",
     "        angle (float): The angle of rotation in degrees.\n",
     "\n",
     "    Returns:\n",
@@ -1102,14 +1102,14 @@
     "\n",
     "import cv2\n",
     "import numpy as np\n",
-    "def solution_average_filter(img: np.ndarray, kernel_size: tuple = (5, 5)):\n",
+    "def solution_average_filter(image: np.ndarray, kernel_size: tuple = (5, 5)):\n",
     "    \"\"\"\n",
     "    Applies an average filter to blur the image using a specific kernel size.\n",
     "    For that, you need to use OpenCV's `cv2.blur()` function, which takes the image and the kernel size as arguments.\n",
     "    `cv2.blur()` requires two arguments: the image, and the size of the kernel.\n",
     "    \n",
     "    Args:\n",
-    "        img (np.ndarray): The input image.\n",
+    "        image (np.ndarray): The input image.\n",
     "        kernel_size (tuple): The width and height of the blurring window. Default is (5, 5).\n",
     "\n",
     "    Returns:\n",
@@ -1164,14 +1164,14 @@
     "\n",
     "import cv2\n",
     "import numpy as np\n",
-    "def solution_median_filter(img: np.ndarray, ksize: int):\n",
+    "def solution_median_filter(image: np.ndarray, ksize: int):\n",
     "    \"\"\"\n",
     "    Applies a median filter to the image using a specific kernel size.\n",
     "    For that, you need to use OpenCV's `cv2.medianBlur()` function, which takes the image and the kernel size as arguments.\n",
     "    `cv2.medianBlur()` requires two arguments: the image, and the size of the kernel.\n",
     "    \n",
     "    Args:\n",
-    "        img (np.ndarray): The input image.\n",
+    "        image (np.ndarray): The input image.\n",
     "        ksize (int): The size of the median filter kernel. Must be a positive odd integer.\n",
     "\n",
     "    Returns:\n",
@@ -1226,14 +1226,14 @@
     "\n",
     "import cv2\n",
     "import numpy as np\n",
-    "def solution_gaussian_filter(img: np.ndarray, kernel_size: tuple = (5, 5), sigma: float = 0):\n",
+    "def solution_gaussian_filter(image: np.ndarray, kernel_size: tuple = (5, 5), sigma: float = 0):\n",
     "    \"\"\"\n",
     "    Applies a Gaussian filter to the image using a specific kernel size and sigma value.\n",
     "    For that, you need to use OpenCV's `cv2.GaussianBlur()` function, which takes the image, kernel size, and sigma as arguments.\n",
     "    `cv2.GaussianBlur()` requires three arguments: the image, the size of the kernel, and the sigma value.\n",
     "\n",
     "    Args:\n",
-    "        img (np.ndarray): The input image.\n",
+    "        image (np.ndarray): The input image.\n",
     "        kernel_size (tuple): The width and height of the Gaussian kernel. Default is (5, 5).\n",
     "        sigma (float): The standard deviation of the Gaussian kernel. Default is 0.\n",
     "\n",
@@ -1303,13 +1303,13 @@
     "\n",
     "import cv2\n",
     "import numpy as np\n",
-    "def solution_adjust_brightness(img: np.ndarray, brightness_value: float):\n",
+    "def solution_adjust_brightness(image: np.ndarray, brightness_value: float):\n",
     "    \"\"\"\n",
     "    Adjusts the brightness of the image by adding a specified value to all pixel intensities.\n",
     "    To adjust the brightness, you can use OpenCV's `cv2.convertScaleAbs()` function, which scales, calculates absolute values, and converts the result to 8-bit.\n",
     "    `cv2.convertScaleAbs()` requires three arguments: the image, the alpha value (which is 1 for no scaling), and the beta value (which is the brightness adjustment value).\n",
     "    Args:\n",
-    "        img (np.ndarray): The input image.\n",
+    "        image (np.ndarray): The input image.\n",
     "        brightness_value (float): The value to add to the pixel intensities. Positive values increase brightness, while negative values decrease it.\n",
     "    Returns:\n",
     "        np.ndarray: The brightness-adjusted image.\n",
@@ -1366,13 +1366,13 @@
     "\n",
     "import cv2\n",
     "import numpy as np\n",
-    "def solution_adjust_contrast(img: np.ndarray, contrast_value: float):\n",
+    "def solution_adjust_contrast(image: np.ndarray, contrast_value: float):\n",
     "    \"\"\"\n",
     "    Adjusts the contrast of the image by scaling the pixel intensities.\n",
     "    To adjust the contrast, you can use OpenCV's `cv2.convertScaleAbs()` function, which scales, calculates absolute values, and converts the result to 8-bit.\n",
     "    `cv2.convertScaleAbs()` requires three arguments: the image, the alpha value (which is the contrast adjustment value), and the beta value (which is 0 for no additional brightness adjustment).\n",
     "    Args:\n",
-    "        img (np.ndarray): The input image.\n",
+    "        image (np.ndarray): The input image.\n",
     "        contrast_value (float): The value to scale the pixel intensities. Values greater than 1 increase contrast, while values between 0 and 1 decrease it.\n",
     "    Returns:\n",
     "        np.ndarray: The contrast-adjusted image.\n",
@@ -1429,22 +1429,22 @@
     "\n",
     "import cv2\n",
     "import numpy as np\n",
-    "def solution_adjust_saturation(img: np.ndarray, saturation_factor: float):\n",
+    "def solution_adjust_saturation(image: np.ndarray, saturation_factor: float):\n",
     "    \"\"\"\n",
     "    Adjusts the saturation of the image by modifying the saturation channel in the HSV color space.\n",
     "    To do that you need to convert the image from RGB to HSV, adjust the saturation channel, and then convert it back to RGB.\n",
     "    Follow these steps:\n",
     "    1. It is very hard to change saturation in standard RGB format because the colors are mixed. \n",
-    "       First, convert the image to HSV format (`cv2.COLOR_RGB2HSV`) format using: `hsv_img = cv2.cvtColor(img, cv2.COLOR_RGB2HSV)`.\n",
-    "    2. Now that the image is in HSV, you can isolate the Saturation. Split the image into its three separate channels using: `cv2.split(hsv_img)`.\n",
+    "       First, convert the image to HSV format (`cv2.COLOR_RGB2HSV`) format using: `hsv_image = cv2.cvtColor(image, cv2.COLOR_RGB2HSV)`.\n",
+    "    2. Now that the image is in HSV, you can isolate the Saturation. Split the image into its three separate channels using: `cv2.split(hsv_image)`.\n",
     "    3. Multiply the saturation channel by the `saturation_factor`. \n",
     "    4. Pixel values cannot go above 255 or below 0. Use NumPy's clip function (`np.clip`) to enforce this limit.\n",
     "    5. Math operations can change the data type. Force the new saturation channel back into standard image format `uint8`.\n",
     "    6. Put the three channels back together in the correct order using `cv2.merge()`.\n",
     "    7. Finally, convert the image back to normal RGB format (`cv2.COLOR_HSV2RGB`).\n",
     "\n",
     "    Args:\n",
-    "        img (np.ndarray): The input image in RGB format.\n",
+    "        image (np.ndarray): The input image in RGB format.\n",
     "        saturation_factor (float): The multiplier for the saturation channel. Values greater than 1 increase saturation, while values between 0 and 1 decrease it.\n",
     "\n",
     "    Returns:\n",
@@ -2136,9 +2136,9 @@
     "\n",
     "To prepare the image for Grad-CAM visualization:\n",
     "\n",
-    "- First, convert it to (Height, Width, Channels) format using ```img_np = np.transpose(img, (1, 2, 0))  # shape: (H, W, C)```, and normalize its values to the [0, 1] range with ```img_np = (img_np - img_np.min()) / (img_np.max() - img_np.min())```.\n",
+    "- First, convert it to (Height, Width, Channels) format using ```image_np = np.transpose(image, (1, 2, 0))  # shape: (H, W, C)```, and normalize its values to the [0, 1] range with ```image_np = (image_np - image_np.min()) / (image_np.max() - image_np.min())```.\n",
     "  This processed image is used only for visualization, as expected by the PyTorch-GradCAM library.\n",
-    "- Next, modify the original image for model inference by adding a batch dimension: ```img = np.expand_dims(img, axis=0)```, then convert it to a PyTorch tensor: ```img = torch.from_numpy(img)```, and move it to the appropriate computation device using ```img = img.to(DEVICE)```.\n",
+    "- Next, modify the original image for model inference by adding a batch dimension: ```image = np.expand_dims(image, axis=0)```, then convert it to a PyTorch tensor: ```image = torch.from_numpy(image)```, and move it to the appropriate computation device using ```image = image.to(DEVICE)```.\n",
     "- Finally, retrieve the predicted and true labels, as both are required for computing and visualizing the Grad-CAM output."
    ]
   },
@@ -2154,7 +2154,7 @@
     "\n",
     "# Get a batch of images\n",
     "idx = 1\n",
-    "img = original_images[idx]\n",
+    "image = original_images[idx]\n",
     "pred_label = predicted_labels[idx]\n",
     "true_label = true_labels[idx]"
    ]
@@ -2168,7 +2168,7 @@
     "\n",
     "To compute the Grad-CAM heatmap:\n",
     "\n",
-    "- First, ensure that the `requires_grad` attribute of the input image tensor is set to `True` by using `img.requires_grad = True`.\n",
+    "- First, ensure that the `requires_grad` attribute of the input image tensor is set to `True` by using `image.requires_grad = True`.\n",
     "  This enables gradient computation with respect to the image, which is necessary for generating class activation maps.\n",
     "- Next, specify the layer to inspect using ```target_layers = [model.conv3]```.\n",
     "- Typically, the last convolutional layer of the image classifier is chosen because it preserves spatial information, which is crucial for identifying the regions of the input image that most strongly influence the model's prediction. \n",
@@ -2177,7 +2177,7 @@
     "```python\n",
     "# Create CAM object\n",
     "with GradCAM(model=model, target_layers=target_layers) as cam:\n",
-    "    grad_cam_matrix = cam(input_tensor=img, targets=targets)\n",
+    "    grad_cam_matrix = cam(input_tensor=image, targets=targets)\n",
     "    grad_cam_matrix = grad_cam_matrix[0, :]\n",
     "```"
    ]
@@ -2208,7 +2208,7 @@
    "source": [
     "#### Visualise Grad-CAM heatmap with the image\n",
     "\n",
-    "After obtaining the Grad-CAM heatmap, we overlay it on the input image to visualise the regions that contributed most to the model’s prediction (```visualisation = show_cam_on_image(img_np, grad_cam_matrix, use_rgb=True)```).\n",
+    "After obtaining the Grad-CAM heatmap, we overlay it on the input image to visualise the regions that contributed most to the model’s prediction (```visualisation = show_cam_on_image(image_np, grad_cam_matrix, use_rgb=True)```).\n",
     "This helps identify which pixels the model focused on when predicting the class."
    ]
   },
@@ -2227,7 +2227,7 @@
     "# Plot image with GradCAM output\n",
     "true_class = CIFAR_10_CLASSES[true_label]\n",
     "pred_class = CIFAR_10_CLASSES[pred_label]\n",
-    "plot_multiple_images((img_np, f\"Original - {true_class}\"), (visualisation, f\"Grad-CAM - {pred_class}\"), figsize = (5,6))"
+    "plot_multiple_images((image_np, f\"Original - {true_class}\"), (visualisation, f\"Grad-CAM - {pred_class}\"), figsize = (5,6))"
    ]
   }
  ],