Keras Image Classification: Fine-Tuning EfficientNet

I worked on a Python project where I needed to classify thousands of product images for an e-commerce client based in the USA. The challenge was to achieve high accuracy without spending days training a deep learning model from scratch.

After trying several pre-trained models, I found that EfficientNet gave me the best balance between accuracy and speed. It’s one of the most efficient convolutional neural networks available in Keras and is perfect for transfer learning.

In this tutorial, I’ll show you how to perform image classification via fine-tuning with EfficientNet in Python. I’ll walk you through everything, from loading your dataset to training and evaluating your model.

What is EfficientNet?

EfficientNet is a family of convolutional neural networks developed by Google. It scales network depth, width, and resolution in a balanced way, giving better performance with fewer parameters.

In simple terms, it’s like getting a sports car that’s fuel-efficient; you get speed (accuracy) without burning too much gas (computation).

In Python, you can easily use EfficientNet with Keras, which provides pre-trained models ranging from EfficientNetB0 to EfficientNetB7.

Why Fine-Tuning EfficientNet in Python?

Fine-tuning means taking a pre-trained model (like EfficientNet trained on ImageNet) and adjusting it for your specific dataset.

This approach saves time and computational resources while maintaining excellent accuracy. It’s especially useful when you don’t have millions of labeled images.

For example, if you’re building a model to classify American road signs or retail products, fine-tuning EfficientNet in Python can deliver results quickly and efficiently.

Set Up the Python Environment

Before we start, make sure you have Python and the following libraries installed:

pip install tensorflow keras matplotlib numpy scikit-learn

These libraries will help you handle data, train the model, and visualize the results. Once your environment is ready, let’s move on to preparing the dataset.

Step 1 – Prepare the Dataset

For this example, I’ll use a dataset of dog and cat images (you can replace it with your own dataset).

Each class should be stored in separate folders, for example:

dataset/
│
├── train/
│   ├── cats/
│   └── dogs/
│
└── validation/
    ├── cats/
    └── dogs/

Here’s the Python code to load and preprocess the dataset using Keras’ image_dataset_from_directory:

import tensorflow as tf
from tensorflow.keras.preprocessing import image_dataset_from_directory

train_dataset = image_dataset_from_directory(
    "dataset/train",
    image_size=(224, 224),
    batch_size=32
)

validation_dataset = image_dataset_from_directory(
    "dataset/validation",
    image_size=(224, 224),
    batch_size=32
)

This code automatically labels your images and resizes them to match EfficientNet’s input size.

Step 2 – Normalize and Optimize the Dataset

Before feeding data into the model, it’s a good idea to normalize pixel values and optimize performance.

Here’s how you can do it in Python:

AUTOTUNE = tf.data.AUTOTUNE

train_dataset = train_dataset.prefetch(buffer_size=AUTOTUNE)
validation_dataset = validation_dataset.prefetch(buffer_size=AUTOTUNE)

This ensures faster training by preparing data in the background while the GPU processes the current batch.

Step 3 – Loading the Pre-Trained EfficientNet Model

Now comes the exciting part: loading the pre-trained EfficientNet model. We’ll use EfficientNetB0 as our base model (you can also try EfficientNetB3 or EfficientNetB7 for better accuracy).

Here’s the Python code:

from tensorflow.keras.applications import EfficientNetB0
from tensorflow.keras import layers, models

base_model = EfficientNetB0(include_top=False, weights='imagenet', input_shape=(224, 224, 3))
base_model.trainable = False  # Freeze base model layers

By freezing the base model, we retain the pre-trained weights and avoid overfitting early in training.

Step 4 – Adding Custom Layers

To adapt EfficientNet for our dataset, we’ll add a few custom layers on top.

Here’s the Python code:

model = models.Sequential([
    base_model,
    layers.GlobalAveragePooling2D(),
    layers.Dropout(0.3),
    layers.Dense(1, activation='sigmoid')  # Binary classification
])

This structure helps the model learn dataset-specific features while leveraging EfficientNet’s strong feature extraction capabilities.

Step 5 – Compiling the Model

Now, let’s compile the model with an appropriate optimizer and loss function.

model.compile(
    optimizer='adam',
    loss='binary_crossentropy',
    metrics=['accuracy']
)

The Adam optimizer works great for fine-tuning tasks, and binary cross-entropy is perfect for two-class problems like cats vs. dogs.

Step 6 – Training the Model

We’re now ready to train the model.

Here’s the Python code to start training:

history = model.fit(
    train_dataset,
    validation_data=validation_dataset,
    epochs=10
)

Ten epochs are usually enough for initial fine-tuning. You can increase this number for more complex datasets.

Step 7 – Fine-Tuning the Model

Once the top layers are trained, we can unfreeze some layers of the base model to fine-tune it further.

Here’s how to do it in Python:

base_model.trainable = True

for layer in base_model.layers[:-20]:
    layer.trainable = False

model.compile(
    optimizer=tf.keras.optimizers.Adam(1e-5),
    loss='binary_crossentropy',
    metrics=['accuracy']
)

history_fine = model.fit(
    train_dataset,
    validation_data=validation_dataset,
    epochs=5
)

This approach allows the model to adjust deeper layers slightly, improving accuracy while avoiding overfitting.

Step 8 – Evaluating the Model

After training, it’s time to evaluate performance.

Here’s the Python code for evaluation:

loss, accuracy = model.evaluate(validation_dataset)
print(f"Validation Accuracy: {accuracy * 100:.2f}%")

You can also visualize training performance using Matplotlib:

import matplotlib.pyplot as plt

plt.plot(history.history['accuracy'], label='Training Accuracy')
plt.plot(history.history['val_accuracy'], label='Validation Accuracy')
plt.title('Model Accuracy')
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.legend()
plt.show()

This helps you see how well the model is learning over time.

Step 9 – Making Predictions

Finally, let’s test the model with a single image.

Here’s the Python code:

import numpy as np
from tensorflow.keras.preprocessing import image

img_path = "test_image.jpg"
img = image.load_img(img_path, target_size=(224, 224))
img_array = image.img_to_array(img)
img_array = np.expand_dims(img_array, axis=0)

predictions = model.predict(img_array)
if predictions[0] > 0.5:
    print("It's a Dog!")
else:
    print("It's a Cat!")

This simple script loads an image, preprocesses it, and prints the prediction result.

Step 10 – Saving and Reusing the Model

Once you’re satisfied with the results, save the model for future use.

model.save("efficientnet_finetuned_model.h5")

Now, you can load it anytime with:

from tensorflow.keras.models import load_model
model = load_model("efficientnet_finetuned_model.h5")

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

This makes deployment much easier, especially for production environments.

Additional Tips for Better Accuracy

Here are a few Python-based tips that helped me improve accuracy during my projects:

• Use data augmentation with ImageDataGenerator to increase dataset diversity.
• Try EfficientNetB3 or B4 for higher accuracy if you have a powerful GPU.
• Use Dropout layers to prevent overfitting.
• Experiment with learning rate schedulers for smoother convergence.

So, that’s how I fine-tune EfficientNet in Python for image classification. It’s efficient, accurate, and surprisingly easy once you understand the workflow.

Whether you’re classifying medical images, retail products, or wildlife photos, this approach can save you hours of training time while delivering professional-grade results.

You may also like to read:

• How to Import TensorFlow Keras in Python
• Image Classification Using CNN in Python with Keras
• Traffic Signs Recognition Using CNN and Keras in Python
• Emotion Classification using CNN in Python with Keras

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/