Transfer Learning

Duration: 7 min

This module delves into the concept of Transfer Learning, a powerful technique in machine learning where a pre-trained model is used as the starting point for a new task. This approach leverages the knowledge gained from one problem and applies it to a different but related problem, significantly reducing the need for large datasets and extensive training times. Transfer Learning is particularly useful in scenarios where data is scarce or computational resources are limited.

Understanding Transfer Learning

Transfer Learning involves taking a model that has been trained on a large dataset and reusing it for a different but related task. The idea is to leverage the learned features from the pre-trained model, which can be fine-tuned to suit the new task. This technique is widely used in deep learning, especially with Convolutional Neural Networks (CNNs) for image recognition tasks. By using a pre-trained model, we can achieve good performance with less data and computational resources.

import tensorflow as tf
from tensorflow.keras.applications.vgg16 import VGG16
from tensorflow.keras.preprocessing import image
from tensorflow.keras.applications.vgg16 import preprocess_input, decode_predictions
import numpy as np

# Load the VGG16 model pre-trained on ImageNet data
model = VGG16(weights='imagenet')

# Load and preprocess an image
img_path = 'elephant.jpg'
img = image.load_img(img_path, target_size=(224, 224))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)

# Make predictions
preds = model.predict(x)

# Decode the results into a list of tuples (class, description, probability)
print('Predicted:', decode_predictions(preds, top=3)[0])

Try it in Google Colab:

Predicted: [('n02504013', 'African_elephant', 0.986535), ('n02504458', 'Indian_elephant', 0.012864), ('n01871265', 'trunk', 0.000432373)]

Fine-Tuning a Pre-Trained Model

Fine-tuning involves taking a pre-trained model and continuing its training on a new dataset. This process allows the model to adapt the learned features to the specific task at hand. Typically, the last few layers of the model are retrained, while the earlier layers, which capture more generic features, are kept frozen. This approach balances the need to leverage pre-trained knowledge with the requirement to specialize the model for the new task.

import tensorflow as tf
from tensorflow.keras.applications.vgg16 import VGG16
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras import layers, models

# Load the VGG16 model without the top classification layer
base_model = VGG16(weights='imagenet', include_top=False, input_shape=(224, 224, 3))

# Freeze the base model
for layer in base_model.layers:
    layer.trainable = False

# Add custom layers on top of the base model
model = models.Sequential([
    base_model,
    layers.Flatten(),
    layers.Dense(256, activation='relu'),
    layers.Dropout(0.5),
    layers.Dense(1, activation='sigmoid')
])

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

# Prepare data generators
train_datagen = ImageDataGenerator(rescale=1./255)
train_generator = train_datagen.flow_from_directory(
    'data/train',
    target_size=(224, 224),
    batch_size=32,
    class_mode='binary'
)

# Train the model
model.fit(train_generator, epochs=5)

💡 Tip: When fine-tuning a pre-trained model, it's important to start with a lower learning rate to avoid drastic changes to the pre-trained weights. Additionally, monitor the validation loss to prevent overfitting.