Image Resizing Techniques in Keras for Computer Vision

In my four years of developing deep learning models, I have often found that the quality of input data determines the success of the model.

If you are working with datasets like the Stanford Cars collection or satellite imagery of Chicago, you will notice that images rarely come in a uniform size.

Computer vision models require a fixed input shape, which makes resizing one of the most critical steps in your preprocessing pipeline.

I have spent countless hours debugging “shape mismatch” errors, only to realize that my resizing method was either too slow or losing too much detail.

In this guide, I will share the exact methods I use to handle image resizing within Keras and TensorFlow to ensure your models remain accurate and efficient.

The Importance of Image Resizing in Keras Computer Vision

Most modern neural networks, such as ResNet or EfficientNet, expect a square input like 224×224 or 300×300 pixels to function correctly.

Resizing ensures that every image in your batch has the same dimensions, allowing for efficient matrix multiplications on your GPU.

Method 1: Use the Keras Resizing Layer for Computer Vision

The Resizing layer is my favorite approach because it becomes part of the model architecture itself, making deployment much smoother.

This layer handles resizing during the forward pass, which means you don’t have to manually resize images before feeding them into the model.predict function.

import tensorflow as tf
from tensorflow.keras import layers, Sequential

# Define a simple sequential model with a resizing layer
# We are targeting a standard 224x224 resolution for a vehicle classifier
model = Sequential([
    layers.Resizing(224, 224, interpolation="bilinear", input_shape=(None, None, 3)),
    layers.Conv2D(32, (3, 3), activation='relu'),
    layers.MaxPooling2D()
])

# Testing with a dummy image (simulating a high-res photo from a street camera)
sample_image = tf.random.uniform(shape=(1, 1080, 1920, 3))
resized_image = model.predict(sample_image)

print(f"Original shape: {sample_image.shape}")
print(f"Resized shape: {resized_image.shape}")

I executed the above example code and added the screenshot below.

Method 2: Resize via Keras Image Preprocessing Utilities

When I need to prepare a dataset on my local drive before training, I use the load_img and img_to_array utilities provided by Keras.

from tensorflow.keras.preprocessing.image import load_img, img_to_array
import numpy as np

# Let's assume we have a picture of a house in a Seattle suburb
# We define the target size to match our model's input requirements
img_path = 'seattle_suburb_house.jpg' # Replace with your actual path
target_size = (256, 256)

# Load the image and resize it simultaneously
img = load_img(img_path, target_size=target_size)
img_array = img_to_array(img)

# Expand dimensions to create a batch of 1
img_batch = np.expand_dims(img_array, axis=0)

print(f"Image converted to array with shape: {img_batch.shape}")

I executed the above example code and added the screenshot below.

This method is ideal for quick prototyping or when building a custom data generator to feed images into your Python script.

Method 3: Resize Images within a Keras Data Pipeline

For large-scale projects, I prefer using tf.data.Dataset because it allows for parallel processing and keeps the GPU busy.

import tensorflow as tf

def preprocess_image(file_path):
    # Load the raw data as a string
    img = tf.io.read_file(file_path)
    # Decode the string into a uint8 tensor
    img = tf.image.decode_jpeg(img, channels=3)
    # Resize the image to 300x300 for an EfficientNet model
    img = tf.image.resize(img, [300, 300])
    return img / 255.0  # Normalize pixel values

# Example using a list of image paths (e.g., photos of delivery trucks)
file_paths = tf.constant(["truck_1.jpg", "truck_2.jpg"])
dataset = tf.data.Dataset.from_tensor_slices(file_paths)
dataset = dataset.map(preprocess_image).batch(2)

for batch in dataset.take(1):
    print(f"Batch shape from pipeline: {batch.shape}")

I executed the above example code and added the screenshot below.

You can map a resizing function to your entire dataset, ensuring that every image is processed on the fly as it is loaded from the disk.

Method 4: Handle Aspect Ratio with Keras Resizing

One issue I often encounter is “stretched” images when resizing a rectangular photo into a square shape, which can confuse the model.

import tensorflow as tf
from tensorflow.keras.layers import Resizing

# This layer will crop the center of the image to avoid distortion
# Ideal for identifying specific features on American agricultural crops
resize_and_crop = Resizing(height=224, width=224, crop_to_aspect_ratio=True)

# Simulate a panoramic landscape image (wide aspect ratio)
panoramic_img = tf.random.uniform(shape=(1, 500, 1000, 3))
cropped_img = resize_and_crop(panoramic_img)

print(f"Wide image shape: {panoramic_img.shape}")
print(f"Square cropped shape: {cropped_img.shape}")

By using the crop_to_aspect_ratio parameter in the Keras Resizing layer, you can maintain the original proportions of the objects in your photos.

Method 5: Dynamic Resizing for Computer Vision Inference

Sometimes, you might want to build a model that accepts any size of input during inference but resizes it internally for the hidden layers.

import tensorflow as tf
from tensorflow.keras import layers, Model

# Defining a functional API model for flexible inputs
inputs = layers.Input(shape=(None, None, 3))
x = layers.Resizing(224, 224)(inputs)
x = layers.Conv2D(16, (3, 3), activation='relu')(x)
outputs = layers.GlobalAveragePooling2D()(x)

flexible_model = Model(inputs=inputs, outputs=outputs)

# Testing with two different sizes (e.g., a phone photo and a DSLR photo)
img_phone = tf.random.uniform(shape=(1, 480, 640, 3))
img_dslr = tf.random.uniform(shape=(1, 1080, 1920, 3))

print(f"Phone output: {flexible_model(img_phone).shape}")
print(f"DSLR output: {flexible_model(img_dslr).shape}")

I achieve this by setting the input shape to (None, None, 3), which allows the Keras model to be flexible with the resolution of incoming data.

Choose the Right Interpolation in Keras Computer Vision

Interpolation determines how pixels are added or removed; I usually stick with “bilinear” for most tasks as it is fast and reliable.

import tensorflow as tf
from tensorflow.keras.layers import Resizing

# Bicubic interpolation is slower but provides higher quality
bicubic_resizer = Resizing(224, 224, interpolation="bicubic")

# Area interpolation is often preferred when downsampling large images
area_resizer = Resizing(224, 224, interpolation="area")

sample = tf.random.uniform(shape=(1, 512, 512, 3))
print("Layers initialized for different interpolation strategies.")

However, if you are working with medical imaging or fine-grained details, “bicubic” interpolation often yields better results by producing smoother edges.

Summary of Methods for Keras Resizing

In this guide, I have demonstrated several methods for handling image resizing in Keras for your computer vision projects.

Using the right resizing technique can save you from poor model performance and unnecessary debugging time later on.

I hope you found this tutorial helpful and that it makes your journey with Python and Keras a bit easier.

Would you like me to show you how to combine these resizing layers with data augmentation techniques like random flipping and rotation?

• Knowledge Distillation in Keras
• Fix the Train-Test Resolution Discrepancy in Keras
• Implement Class Attention Image Transformers (CaiT) with LayerScale in Keras
• Enhance Keras ConvNets with Aggregated Attention Mechanisms

Bijay Kumar

I am Bijay Kumar, a Microsoft MVP in SharePoint. Apart from SharePoint, I started working on Python, Machine learning, and artificial intelligence for the last 5 years. During this time I got expertise in various Python libraries also like Tkinter, Pandas, NumPy, Turtle, Django, Matplotlib, Tensorflow, Scipy, Scikit-Learn, etc… for various clients in the United States, Canada, the United Kingdom, Australia, New Zealand, etc. Check out my profile.

enjoysharepoint.com/