I’ve been working with image classification models for years, and I still get excited about transfer learning. It’s like having a master artist show you their techniques before you start your own painting. Why start from scratch when you can build on proven foundations?

Let me show you how to create a complete image classification system using TensorFlow and Keras. We’ll use pre-trained models as our starting point, which saves both time and computational resources.

First, let’s set up our environment. You’ll need TensorFlow and a few supporting libraries:

import tensorflow as tf
from tensorflow import keras
import numpy as np
import matplotlib.pyplot as plt

print(f"Using TensorFlow {tf.__version__}")

Have you ever wondered how much data you actually need to train a good model? With transfer learning, you can achieve impressive results with surprisingly small datasets. Let’s work with the CIFAR-100 dataset, which contains 100 different object categories.

Here’s how we load and prepare our data:

# Load and split the dataset
(x_train, y_train), (x_test, y_test) = keras.datasets.cifar100.load_data()

# Normalize pixel values
x_train = x_train.astype('float32') / 255.0
x_test = x_test.astype('float32') / 255.0

# Convert labels to categorical
y_train = keras.utils.to_categorical(y_train, 100)
y_test = keras.utils.to_categorical(y_test, 100)

The magic happens when we use a pre-trained model. I typically start with EfficientNet because it offers a great balance between accuracy and efficiency. What if we could leverage patterns learned from millions of images?

# Create base model
base_model = keras.applications.EfficientNetB0(
    include_top=False,
    weights='imagenet',
    input_shape=(32, 32, 3),
    pooling='avg'
)

# Freeze base model layers
base_model.trainable = False

Now we build our custom classifier on top of this foundation. This is where you can get creative with your architecture:

model = keras.Sequential([
    base_model,
    keras.layers.Dropout(0.2),
    keras.layers.Dense(256, activation='relu'),
    keras.layers.Dropout(0.3),
    keras.layers.Dense(100, activation='softmax')
])

Training becomes much faster because we’re only updating the new layers initially. Later, we can unfreeze some base layers for fine-tuning. How much should we unfreeze? That depends on your specific dataset and how different it is from ImageNet.

# Compile the model
model.compile(
    optimizer=keras.optimizers.Adam(learning_rate=0.001),
    loss='categorical_crossentropy',
    metrics=['accuracy']
)

# Train initial layers
history = model.fit(
    x_train, y_train,
    batch_size=32,
    epochs=10,
    validation_data=(x_test, y_test)
)

After initial training, we can unfreeze some layers for fine-tuning. This is where the model really learns to specialize for our specific task:

# Unfreeze top layers of base model
base_model.trainable = True
for layer in base_model.layers[:-20]:
    layer.trainable = False

# Recompile with lower learning rate
model.compile(
    optimizer=keras.optimizers.Adam(learning_rate=0.0001),
    loss='categorical_crossentropy',
    metrics=['accuracy']
)

# Continue training
history_fine = model.fit(
    x_train, y_train,
    batch_size=32,
    epochs=20,
    validation_data=(x_test, y_test)
)

Evaluation is crucial. I always check both overall accuracy and per-class performance to understand where the model struggles:

# Evaluate final model
test_loss, test_acc = model.evaluate(x_test, y_test)
print(f"Test accuracy: {test_acc:.4f}")

# Generate predictions
predictions = model.predict(x_test)

What separates good models from great ones? Often it’s the attention to deployment details. Make sure to save your model properly:

# Save the entire model
model.save('image_classifier.h5')

# For production, consider saving as SavedModel
model.save('saved_model/', save_format='tf')

I’ve found that the real test comes when you deploy these models in production. They need to handle varying image sizes, different lighting conditions, and unexpected inputs. Always build robust error handling around your model.

Remember that transfer learning isn’t just about getting better accuracy—it’s about working smarter, not harder. The patterns learned from large datasets transfer remarkably well to new problems.

I’d love to hear about your experiences with transfer learning. What challenges have you faced? What creative applications have you discovered? Share your thoughts in the comments below, and if you found this helpful, please like and share with others who might benefit from these techniques.