Complete Guide to Image Prediction with Trained Models in Keras: From Numerical Output to Class Mapping

Introduction

In deep learning image classification tasks, training the model is only the first step; more importantly, how to apply the trained model to actual prediction scenarios. Many developers encounter the issue of prediction outputs being numerical indices rather than actual class names after completing model training. This article will use a binary image classification task as an example to deeply analyze the complete workflow of image prediction in Keras.

The Numerical Nature of Prediction Outputs

When using the model.predict_classes() method for prediction, Keras returns the model's class predictions for input data in the form of numerical indices. For example, in a binary classification problem, the output [[0]] indicates that the model predicts the input image belongs to class 0.

This design stems from the internal working mechanism of deep learning models. In the model's final layer (typically with sigmoid or softmax activation), each neuron corresponds to a class, and its activation value represents the probability that the input belongs to that class. The predict_classes method selects the neuron index with the highest activation value as the prediction result.

# Example: Model prediction output
classes = model.predict_classes(img)
print(classes)  # Output: [[0]]

Obtaining Class Mapping Relationships

To understand which actual class a numerical index corresponds to, one needs to obtain the class mapping established during training. In Keras, this mapping can be obtained through the class_indices property of the training data generator.

# Get class mapping relationship
classes_dict = train_generator.class_indices
print(classes_dict)  # Output: {"cats": 0, "dogs": 1}

This dictionary records the correspondence between class names and numerical indices. During the training phase, Keras automatically establishes this mapping based on directory structure, where directory names serve as class names and are assigned numerical indices in alphabetical order.

Converting from Numerical to Class Labels

After obtaining the mapping relationship, numerical predictions can be easily converted to actual class labels:

# Create reverse mapping dictionary
reverse_classes_dict = {v: k for k, v in classes_dict.items()}

# Convert prediction results
predicted_class = reverse_classes_dict[classes[0][0]]
print(f"Predicted class: {predicted_class}")

Comparative Analysis of Prediction Methods

Keras provides two main prediction methods: predict and predict_classes.

model.predict() returns raw probability values or activation values:

# Using predict method to get probability values
probabilities = model.predict(img)
print(probabilities)  # Output: [[0.02]] or [[0.98]]

For binary classification problems, the sigmoid activation layer outputs the probability of belonging to the positive class. When this value is greater than 0.5, it is typically considered to belong to the positive class (class 1), otherwise to the negative class (class 0).

model.predict_classes() directly returns class indices, equivalent to performing an argmax operation on the output of predict:

# Internal logic of predict_classes
probabilities = model.predict(img)
classes = np.argmax(probabilities, axis=-1)

Complete Prediction Workflow Implementation

Below is the complete prediction workflow code based on best practices:

from keras.models import load_model
from keras.preprocessing import image
import numpy as np

# Load the saved model
model = load_model("model.h5")

# Define image dimensions (must match training)
img_width, img_height = 320, 240

# Load and preprocess image
def preprocess_image(img_path):
    img = image.load_img(img_path, target_size=(img_width, img_height))
    img_array = image.img_to_array(img)
    img_array = np.expand_dims(img_array, axis=0)
    img_array /= 255.0  # Normalization, consistent with training
    return img_array

# Perform prediction
img_path = "test_image.jpg"
processed_img = preprocess_image(img_path)

# Method 1: Using predict_classes to get class index
class_index = model.predict_classes(processed_img)[0][0]

# Method 2: Using predict to get probability value
probability = model.predict(processed_img)[0][0]

# Assuming known class mapping
class_mapping = {0: "cat", 1: "dog"}
predicted_class = class_mapping[class_index]

print(f"Predicted class index: {class_index}")
print(f"Predicted class: {predicted_class}")
print(f"Probability of positive class: {probability:.4f}")

Practical Application Recommendations

1. Save Class Mapping Information: After training completion, it is recommended to save class_indices to a file for loading and use during prediction.

2. Preprocessing Consistency: Ensure that image preprocessing during prediction (resizing, normalization, etc.) is completely consistent with training.

3. Batch Prediction Optimization: For predictions on large numbers of images, batch processing can be used to improve efficiency:

# Batch prediction example
def batch_predict(image_paths, batch_size=32):
    processed_images = []
    for path in image_paths:
        img = preprocess_image(path)
        processed_images.append(img)
    
    batch = np.vstack(processed_images)
    predictions = model.predict_classes(batch, batch_size=batch_size)
    return predictions

4. Threshold Adjustment: For certain application scenarios, classification thresholds may need adjustment. For example, in medical diagnosis, one might want to increase recall by lowering the threshold.

Common Issues and Solutions

Issue 1: Prediction results are always the same class.

Solution: Check if image preprocessing is correct and confirm that input data distribution is similar to training data.

Issue 2: predict_classes method deprecated in latest Keras versions.

Solution: Use np.argmax(model.predict(x), axis=-1) as an alternative.

Issue 3: Handling multi-class classification problems.

Solution: For multi-class problems, use softmax activation in the final layer, and predict_classes returns class indices from 0 to n-1.

Conclusion

When performing image prediction in Keras, understanding the relationship between numerical outputs and actual classes is crucial. By correctly obtaining and using class mapping information, developers can convert model numerical predictions into meaningful class labels. The complete workflow and best practices provided in this article can help readers efficiently and accurately implement image classification prediction functionality in practical projects. Remember, successful prediction depends not only on a well-trained model but also on ensuring consistency across all aspects of the prediction workflow with the training phase.