Here’s how it works: first, we need to convert these images into a format that computers can understand this means turning them from colorful pictures with lots of details (like the ones you see on your screen) into grayscale matrices filled with numbers (called “pixels”). These pixels represent different shades of gray and are arranged in rows and columns, just like a spreadsheet.
Next, we need to resize these images so they fit within certain dimensions that our machine learning models can handle this is important because larger images take up more memory and processing power, which can slow down the training process (and make us grumpy). To do this, we use techniques like cropping or padding to remove unwanted parts of the image or fill in any gaps with zeros.
Finally, we need to normalize these pixel values so they fall within a certain range typically between 0 and 1 which helps our models learn more efficiently and accurately. This is done by subtracting the mean value (which represents the average brightness of all pixels in an image) from each pixel and then dividing it by the standard deviation (which measures how spread out the values are).
Here’s a simple example to illustrate this process: let’s say we have an image of a cat that looks like this:
To preprocess this image for deep learning, we would first convert it into grayscale using a simple formula (like averaging the red, green, and blue channels):
# Import necessary libraries
import cv2 # Importing OpenCV library for image processing
from PIL import Image # Importing PIL library for image manipulation
# Load the cat image as an RGB color image
img = Image.open('cat_image.jpg') # Opening the cat image using PIL library
# Convert it to grayscale using the LAB color space (which is more accurate than simple averaging)
gray = img.convert('LAB').quantize(1, dither=None).convert('LA').split()[0] # Converting the image to grayscale using LAB color space and quantizing it to 1 bit, then converting it to LA mode and splitting it into individual channels, and finally selecting the first channel which represents the grayscale image
# Save the resulting grayscale image as a new file called 'cat_grayscale.png'
gray.save('cat_grayscale.png') # Saving the grayscale image as a new file called 'cat_grayscale.png'
Next, we would resize this grayscale image to fit within certain dimensions (let’s say 32×32 pixels) using the `cv2.resize()` function:
# Import necessary libraries
import cv2 # Importing OpenCV library for image processing
from PIL import Image # Importing PIL library for image manipulation
# Load the cat grayscale image as a NumPy array
img = cv2.imread('cat_grayscale.png', 0) # Reading the grayscale image and storing it as a NumPy array
# Resize the image to fit within dimensions of 32x32 pixels using bilinear interpolation (which is more accurate than other methods like nearest neighbor or bicubic)
resized = cv2.resize(img, (32, 32), interpolation=cv2.INTER_LINEAR) # Using the cv2.resize() function to resize the image to 32x32 pixels with bilinear interpolation
# Save the resulting resized image as a new file called 'cat_resized.png'
cv2.imwrite('cat_resized.png', resized) # Saving the resized image as a new file called 'cat_resized.png' using the cv2.imwrite() function
Finally, we would normalize this grayscale image by subtracting its mean value (which is around 150 for most images) and dividing it by its standard deviation (which is around 25 for most images):
# Import necessary libraries
import cv2 # Importing OpenCV library for image processing
from PIL import Image # Importing PIL library for image manipulation
import numpy as np # Importing NumPy library for mathematical operations on arrays
# Load the cat resized image as a NumPy array
img = cv2.imread('cat_resized.png', 0) # Reading the image as a grayscale image (0 indicates grayscale mode)
# Calculate its mean value (which is around 150 for most images) and standard deviation (which is around 25 for most images) using numpy functions like np.mean() and np.std()
mean = np.mean(img) # Calculating the mean value of the image using np.mean() function
std = np.std(img) # Calculating the standard deviation of the image using np.std() function
# Normalize it by subtracting its mean value and dividing it by its standard deviation:
norm_img = (img - mean) / std # Normalizing the image by subtracting its mean value and dividing it by its standard deviation
# Save the resulting normalized image as a new file called 'cat_normalized.png'
cv2.imwrite('cat_normalized.png', norm_img) # Saving the normalized image as a new file using cv2.imwrite() function
And that’s it! By following these simple steps, we can preprocess our images for deep learning models and make them more friendly to computer brains so they can be fed through machine learning algorithms like neural networks.