TensorFlow Image: Applying Filters and Transformations

With the vast data growth in the modern era, images have become one of the most common types of data. Hence, performing manipulations, transformations, and processing on them has never been more critical. In this article, we will delve into how you can apply filters and transformations to images using TensorFlow, one of the most popular machine learning frameworks. TensorFlow provides several tools that make it easy to process and transform images.

Setting up TensorFlow

To get started, ensure you have TensorFlow installed in your environment. If not, you can install it using pip:

pip install tensorflow

Now, let’s move into some image processing tasks with TensorFlow.

Loading an Image

Before applying any transformations, we first need to load the image. TensorFlow’s tf.image module offers a range of functions to manipulate images effectively. Let’s begin by reading an image from disk:

import tensorflow as tf
import matplotlib.pyplot as plt

image_path = "/path/to/your/image.jpg"
# Read the image file
image = tf.io.read_file(image_path)
# Decode it into a formatted tensor
image = tf.image.decode_jpeg(image, channels=3)

# Display the image
plt.imshow(image.numpy())
plt.axis('off')
plt.show()

Applying Filters to Images

Filters in image processing can enhance certain features or even reduce noise. TensorFlow offers several built-in operations you can use.

1. Converting to Grayscale

Transforming an image to grayscale is simple:

grayscale_image = tf.image.rgb_to_grayscale(image)
plt.imshow(grayscale_image.numpy().squeeze(), cmap='gray')
plt.axis('off')
plt.show()

2. Adjusting Brightness

You can easily increase or decrease the brightness of an image:

brighter_image = tf.image.adjust_brightness(image, delta=0.2)
plt.imshow(brighter_image.numpy())
plt.axis('off')
plt.show()

3. Applying Gaussian Blur

To apply more complex filters like Gaussian blur, TensorFlow’s operations will need to be a bit customized using convolution filters:

def gaussian_blur(image, kernel_size=5, sigma=1.0):
    # Gaussian Kernel Creation
    x = tf.range(-kernel_size // 2 + 1, kernel_size // 2 + 1)
    x = tf.exp(-tf.pow(x, 2) / (2.0 * tf.pow(sigma, 2)))
    x = x / tf.reduce_sum(x)
    kernel = tf.matmul(tf.expand_dims(x, 1), tf.expand_dims(x, 0))
    kernel = tf.expand_dims(tf.expand_dims(kernel, -1), -1)
    image = tf.pad(tf.expand_dims(image, 0), paddings=[[0, 0], [kernel_size // 2, kernel_size // 2], [kernel_size // 2, kernel_size // 2], [0, 0]], mode='REFLECT')
    blurred_image = tf.nn.depthwise_conv2d(image, tf.tile(kernel, [1, 1, tf.shape(image)[-1], 1]), [1, 1, 1, 1], padding='VALID')
    return tf.squeeze(blurred_image, axis=0)

blurred_image = gaussian_blur(image)
plt.imshow(blurred_image.numpy())
plt.axis('off')
plt.show()