Dimensionality Reduction with PCA

A step-by-step explanation of how to use PCA (Principal Component Analysis) for dimensionality reduction on a coloured image using Python.

Key Takeaways 1. You’ll learn how the OpenCV library can process an image, and the Scikit-Learn implementation of the PCA algorithm to get its principal components. 2. You will also see how to reconstruct the original image from its principal components.

Let’s assume a scenario where you are working on an ML project which primarily deals with images. Images which are being used are usually of high definition with a lot of pixels which significantly reduces the performance of the system while processing multiple images.

We use dimensionality reduction techniques to overcome such situations. And in this blog, we will be checking if PCA comes in handy in this case or not.

So, what exactly is PCA? And how is it useful for data scientists in particular?

PCA is a popular unsupervised machine learning algorithm primarily used for dimensionality reduction of a large dataset. We can use PCA for dimensionality reduction for images as well. A data is considered high-dimensional if the row, `r`, is less than or equal to the number of features or columns, `c`: r≤c.

Imagine that you have a 100 by 100 coloured image. A coloured image has three channels: red, blue, and green. The number of features present in this image when flattened is 100 by 100 by 3. With PCA, the dimensions of this data can be reduced without the loss of too much information.

Both the dimensions and size of the image in storage are reduced. When you have many high-resolution images and want to save storage space or improve the speed of training your machine learning algorithm, you can compress the image using PCA.

We will use one picture in this blog and reduce its dimensions or in other words compress the image using PCA in python. In the end, we will compare the resulting picture with the original picture to validate our effort.

---

Let's get down to business!

We will first split the image into the three channels (Red, Blue, and Green) first and then perform PCA separately on each dataset representing each channel and will then merge them to reconstruct the compressed image. Hence, if our coloured image is of shape (m, n, 3), where (m X n) is the total number of pixels of the image on the three channels (r, b, g).

We can also perform the same thing without splitting into red, blue, and green channels and reshaping the data into (m, n X 3) pixels, but we have found that the explained variance ratio given by the same number of PCA component is better if we use the splitting method as mentioned in the earlier paragraph.

I will use the following photograph for the demonstration.

Load and preprocess the image

Import the libraries

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.decomposition import PCA
import cv2
from scipy.stats import stats
import matplotlib.image as mpimg

Read and display our image lambo.jpg

img = cv2.cvtColor(cv2.imread('lambo.jpg'), cv2.COLOR_BGR2RGB)
plt.imshow(img)
plt.show()

Output:

Checking the image shape

img.shape

Output:

(427, 640, 3)

Now, I will split the image into 3 channels and display each image:

#Splitting into channels
blue,green,red = cv2.split(img)

# Plotting the images
fig = plt.figure(figsize = (15, 7.2)) 
fig.add_subplot(131)
plt.title("Blue Channel")
plt.imshow(blue)

fig.add_subplot(132)
plt.title("Green Channel")
plt.imshow(green)

fig.add_subplot(133)
plt.title("Red Channel")
plt.imshow(red)

plt.show()

Output:

Let’s verify the data of the blue channel:

blue_temp_df = pd.DataFrame(data = blue)
blue_temp_df

Output:

I will divide all the data of all channels by 255 so that the data is scaled between 0 and 1.

df_blue = blue/255
df_green = green/255
df_red = red/255

---

Fit and transform the data in PCA

We already have seen that each channel has 640 dimensions, and we will now consider only 50 dimensions for PCA and fit and transform the data and check how much variance is explained after reducing the data to 50 dimensions.

pca_b = PCA(n_components=50)
pca_b.fit(df_blue)
trans_pca_b = pca_b.transform(df_blue)

pca_g = PCA(n_components=50)
pca_g.fit(df_green)
trans_pca_g = pca_g.transform(df_green)

pca_r = PCA(n_components=50)
pca_r.fit(df_red)
trans_pca_r = pca_r.transform(df_red)

We have fitted the data in PCA, let’s check the shape of the transformed image of each channel:

print(trans_pca_b.shape)
print(trans_pca_r.shape)
print(trans_pca_g.shape)

Output:

(427, 50)
(427, 50)
(427, 50)

That is as expected. Let’s check the sum of explained variance ratios of the 50 PCA components (i.e. most dominated 50 Eigenvalues) for each channel.

print(f"Blue Channel : {sum(pca_b.explained_variance_ratio_)}")
print(f"Green Channel: {sum(pca_g.explained_variance_ratio_)}")
print(f"Red Channel  : {sum(pca_r.explained_variance_ratio_)}")

Output:

Blue Channel : 0.9706660742877266
Green Channel: 0.960825532671749
Red Channel  : 0.9675425776960902

Wow, that’s superb! because only using 50 components we can keep around 97% of the variance in the data.

Let's plot bar charts to check the explained variance ratio by each Eigenvalues separately for each of the 3 channels:

fig = plt.figure(figsize = (15, 6)) 
fig.add_subplot(131)
plt.title("Blue Channel")
plt.ylabel('Variation explained')
plt.xlabel('Eigen Value')
plt.bar(list(range(1,51)),pca_b.explained_variance_ratio_)

fig.add_subplot(132)
plt.title("Green Channel")
plt.ylabel('Variation explained')
plt.xlabel('Eigen Value')
plt.bar(list(range(1,51)),pca_g.explained_variance_ratio_)

fig.add_subplot(133)
plt.title("Red Channel")
plt.ylabel('Variation explained')
plt.xlabel('Eigen Value')
plt.bar(list(range(1,51)),pca_r.explained_variance_ratio_)
plt.show()

Output:

---

Reconstruct the image and visualize

We have completed our PCA dimensionality reduction. Now we will visualize the image again and for that, we have to reverse transform the data first and then merge the data of all the 3 channels into one. Let’s proceed.

b_arr = pca_b.inverse_transform(trans_pca_b)
g_arr = pca_g.inverse_transform(trans_pca_g)
r_arr = pca_r.inverse_transform(trans_pca_r)
print(b_arr.shape, g_arr.shape, r_arr.shape)

Output:

(427, 640) (427, 640) (427, 640)

We can inverse transform the data to the original shape (although each channel is still separated), but as we know all the images are already compressed.

We will merge all the channels into one and print the final shape:

img_reduced= cv2.merge((b_arr, g_arr, r_arr))
print(img_reduced.shape)

Output:

(427, 640, 3)

That’s great to see the exact shape of the original image that we had imported at the very beginning. Now we will display both the Images (original and reduced) side by side.

fig = plt.figure(figsize = (10, 7.2)) 
fig.add_subplot(121)
plt.title("Original Image")
plt.imshow(img)

fig.add_subplot(122)
plt.title("Reduced Image")
plt.imshow(img_reduced)
plt.show()

Output:

It's amazing to see that the compressed image is very similar (at least we can still identify it as a car) to that of the original one although we have reduced the dimension individually for each channel to only 50 from 640. But, we have achieved our goal. No doubt that now the reduced image will be processed much faster by the computer.

---

Conclusion

I have explained how we can use PCA to reduce the dimension of a colour image by splitting it into 3 channels and then reconstructing it back for visualization.

I hope you have enjoyed reading and learning from the blog.

You can download the complete code from my GitHub Repo

GitHub Repo