Introduction

Keras VGG models expect input images to be preprocessed the same way the original ImageNet-trained VGG models were preprocessed. The important detail is that VGG preprocessing is not the same as scaling pixels to [0, 1]; Keras VGG preprocessing expects image data in the usual 0 to 255 range first, then applies channel reordering and mean subtraction.

The Canonical Keras Preprocessing Path

For VGG16 and VGG19 in Keras, the standard approach is to call the model-specific preprocess_input function.

1import numpy as np
2from tensorflow.keras.applications.vgg16 import preprocess_input
3
4image = np.random.randint(0, 256, size=(1, 224, 224, 3), dtype=np.uint8)
5image = image.astype("float32")
6
7processed = preprocess_input(image)
8print(processed.min(), processed.max())

This function assumes the input image is in RGB order with values in the 0 to 255 scale. It then:

• converts RGB to BGR
• subtracts the ImageNet channel means
• does not divide by 255

That last point is where many mistakes happen.

What the Resulting Range Looks Like

Because Keras subtracts mean values such as about 103.939, 116.779, and 123.68, the postprocessed tensor is no longer in a simple normalized range like [0, 1] or [-1, 1].

Instead, values are roughly centered around zero but can still span a broad range depending on the original pixel values. That is expected. The model was trained with that preprocessing style.

So the right mental model is:

• raw input to preprocessing: usually 0 to 255
• output of preprocessing: mean-centered BGR values

A Full Example With VGG16

1import numpy as np
2from tensorflow.keras.applications import VGG16
3from tensorflow.keras.applications.vgg16 import preprocess_input
4
5model = VGG16(weights="imagenet")
6
7image = np.random.randint(0, 256, size=(1, 224, 224, 3)).astype("float32")
8image = preprocess_input(image)
9
10predictions = model.predict(image)
11print(predictions.shape)

This is the safest workflow because it matches the assumptions of the pretrained weights.

What Not to Do

A very common mistake is to first scale the image into [0, 1] and then pass it to VGG preprocess_input.

image = image / 255.0
image = preprocess_input(image)  # usually wrong for VGG

That produces inputs with the wrong numeric distribution because the mean subtraction values were designed for 0 to 255 images, not already normalized floats.

If you are using pretrained VGG weights, stick to the provided preprocessing helper instead of inventing your own scaling rule.

Input Shape and Type Still Matter

Besides range, VGG models also expect:

• shape (batch, 224, 224, 3) in channels-last form for typical TensorFlow use
• floating-point tensors, usually float32

The spatial size matters because pretrained VGG was designed around 224 x 224 images for standard classification usage.

If you remove the top classifier for transfer learning, the preprocessing expectations still stay the same.

Common Pitfalls

The biggest pitfall is treating VGG preprocessing like ResNet-style or MobileNet-style normalization. Different pretrained families expect different input preprocessing conventions.

Another common mistake is feeding images already scaled to [0, 1] into preprocess_input and assuming the helper will adapt automatically. For VGG, that usually gives the wrong distribution.

Developers also sometimes remember the image size but forget the channel behavior. Keras VGG preprocessing converts RGB input into BGR order internally, so manual preprocessing that duplicates or conflicts with that conversion can cause subtle errors.

Summary

• Keras VGG preprocessing expects image values in the usual 0 to 255 range before preprocessing.
• Use tensorflow.keras.applications.vgg16.preprocess_input or the VGG19 equivalent.
• VGG preprocessing converts RGB to BGR and subtracts ImageNet means.
• Do not normalize to [0, 1] first if you are using the standard VGG preprocessing helper.
• Matching the pretrained model's original preprocessing is essential for sensible predictions.