# Using Pre-trained Models for Image Classification in AI for Beginners: A Practical Guide

> Learn to use pre-trained models for image classification in AI. This beginner's guide shows you how to fine-tune popular architectures like ResNet-50 with Microsoft's AI-For-Beginners repository.

- Repository: [Microsoft/AI-For-Beginners](https://github.com/microsoft/AI-For-Beginners)
- Tags: how-to-guide
- Published: 2026-08-02

---

**You can leverage ImageNet-trained architectures like MobileNetV2 or ResNet-50 for custom image classification tasks by replacing the final classification layer and fine-tuning on your dataset, using the utility modules [`tfcv.py`](https://github.com/microsoft/AI-For-Beginners/blob/main/tfcv.py) and [`pytorchcv.py`](https://github.com/microsoft/AI-For-Beginners/blob/main/pytorchcv.py) from Microsoft's AI-For-Beginners repository.**

The **AI-For-Beginners** curriculum provides a complete transfer learning pipeline that teaches beginners how to apply pre-trained models to new image classification tasks. This guide covers the repository's dual-stack approach, showing exactly how to implement transfer learning with both TensorFlow/Keras and PyTorch using the provided helper utilities.

## Repository Structure and Utility Modules

The transfer learning lesson in `lessons/4-ComputerVision/08-TransferLearning/` provides two complementary utility files designed to abstract away boilerplate code:

- **[`tfcv.py`](https://github.com/microsoft/AI-For-Beginners/blob/main/tfcv.py)** – TensorFlow/Keras utilities for dataset loading, JPEG validation, and visualization
- **[`pytorchcv.py`](https://github.com/microsoft/AI-For-Beginners/blob/main/pytorchcv.py)** – PyTorch equivalents exposing dataset loaders, training loops, and plotting helpers

Neither file defines the neural network architecture itself. This deliberate separation of concerns allows you to plug in any pre-trained model from `tf.keras.applications` or `torchvision.models` while the utilities handle data preparation and training logistics.

## The Transfer Learning Workflow

The curriculum follows a six-step workflow that works identically across both frameworks.

### 1. Dataset Preparation

Both utilities provide a `load_cats_dogs_dataset` function that downloads the Kaggle Cats-vs-Dogs dataset, removes corrupted JPEG files, and returns framework-specific data objects:

- **TensorFlow**: Returns `(train_ds, val_ds)` as `tf.data.Dataset` objects
- **PyTorch**: Returns `(dataset, train_loader, test_loader)` with `torch.utils.data.DataLoader` instances

### 2. Image Pre-processing

Images are automatically resized to **224 × 224 pixels** and normalized. The PyTorch implementation in [`pytorchcv.py`](https://github.com/microsoft/AI-For-Beginners/blob/main/pytorchcv.py) uses `common_transform()` which applies standard ImageNet normalization:

- Mean: `[0.485, 0.456, 0.406]`
- Standard deviation: `[0.229, 0.224, 0.225]`

### 3. Model Selection

Import any pre-trained architecture using the `pretrained=True` (PyTorch) or `weights='imagenet'` (TensorFlow) flag to load ImageNet-trained weights:

- **TensorFlow**: `tf.keras.applications.MobileNetV2`, `ResNet50`, etc.
- **PyTorch**: `torchvision.models.resnet50`, `mobilenet_v2`, etc.

### 4. Head Replacement

Since Cats-vs-Dogs requires binary classification (2 classes) instead of ImageNet's 1000 classes, replace the final dense layer:

- **TensorFlow**: Set `include_top=False` and add `Dense(2, activation='softmax')`
- **PyTorch**: Replace `model.fc` with `nn.Linear(1000, 2)`

### 5. Fine-tuning Strategy

Freeze the backbone to train only the new classification head initially:

- **TensorFlow**: `base_model.trainable = False`
- **PyTorch**: `for param in model.parameters(): param.requires_grad = False` (then unfreeze `model.fc`)

### 6. Training and Evaluation

Use the repository's training utilities to track loss and accuracy:

- **TensorFlow**: Standard `model.fit()` with `tfcv.plot_results(history)`
- **PyTorch**: `cv.train(model, train_loader, test_loader, epochs=5, lr=1e-3)` with `cv.plot_results(history)`

## TensorFlow/Keras Implementation

This example from [`lessons/4-ComputerVision/08-TransferLearning/tfcv.py`](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/08-TransferLearning/tfcv.py) demonstrates fine-tuning MobileNetV2:

```python
import tensorflow as tf
from tensorflow import keras
from lessons.4-ComputerVision.08-TransferLearning import tfcv

# Load and preprocess dataset

train_ds, val_ds = tfcv.load_cats_dogs_dataset(batch_size=32)

# Load pre-trained MobileNetV2 without top layers

base_model = tf.keras.applications.MobileNetV2(
    input_shape=(224, 224, 3),
    include_top=False,
    weights='imagenet'
)
base_model.trainable = False  # Freeze backbone

# Add custom classification head

global_average = tf.keras.layers.GlobalAveragePooling2D()(base_model.output)
output = tf.keras.layers.Dense(2, activation='softmax')(global_average)
model = tf.keras.Model(inputs=base_model.input, outputs=output)

# Compile and train

model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])
history = model.fit(train_ds, validation_data=val_ds, epochs=5)

# Visualize results using repository helper

tfcv.plot_results(history)

```

Key references:
- Dataset loader: `tfcv.load_cats_dogs_dataset` in [`lessons/4-ComputerVision/08-TransferLearning/tfcv.py`](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/08-TransferLearning/tfcv.py)
- Visualization: `tfcv.plot_results` for training curve plotting

## PyTorch Implementation

This implementation uses [`lessons/4-ComputerVision/08-TransferLearning/pytorchcv.py`](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/08-TransferLearning/pytorchcv.py) with ResNet-50:

```python
import torch
import torchvision
from lessons.4-ComputerVision.08-TransferLearning import pytorchcv as cv

# Load dataset with automatic transforms

dataset, train_loader, test_loader = cv.load_cats_dogs_dataset()

# Initialize pre-trained ResNet-50

model = torchvision.models.resnet50(pretrained=True)

# Replace final fully connected layer for binary classification

model.fc = torch.nn.Linear(model.fc.in_features, 2)
model = model.to(cv.default_device)

# Freeze backbone, unfreeze only the new head

for param in model.parameters():
    param.requires_grad = False
for param in model.fc.parameters():
    param.requires_grad = True

# Train using repository helper

history = cv.train(model, train_loader, test_loader, epochs=5, lr=1e-3)

# Plot learning curves

cv.plot_results(history)

```

Key references:
- Data pipeline: `cv.load_cats_dogs_dataset` handles `common_transform()` with ImageNet normalization
- Training loop: `cv.train` and validation in [`lessons/4-ComputerVision/08-TransferLearning/pytorchcv.py`](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/08-TransferLearning/pytorchcv.py)

## Summary

- The **AI-For-Beginners** repository provides framework-agnostic utilities ([`tfcv.py`](https://github.com/microsoft/AI-For-Beginners/blob/main/tfcv.py) and [`pytorchcv.py`](https://github.com/microsoft/AI-For-Beginners/blob/main/pytorchcv.py)) that standardize dataset loading and visualization across TensorFlow and PyTorch.
- Both implementations follow the same six-step transfer learning workflow: dataset preparation, ImageNet normalization (224×224), pre-trained model loading, binary head replacement, selective freezing, and fine-tuning.
- The **separation of concerns** design lets you swap between 30+ pre-trained architectures (MobileNetV2, ResNet-50, etc.) without changing the data pipeline code.
- Freezing the backbone initially (`trainable=False` or `requires_grad=False`) allows efficient training of the new classification head before optional full-model fine-tuning.

## Frequently Asked Questions

### What is transfer learning and why use pre-trained models for image classification?

Transfer learning allows you to use neural networks already trained on massive datasets (like ImageNet) and adapt them to your specific task. According to the AI-For-Beginners source code, this approach requires significantly less training data and computation than training from scratch, while achieving higher accuracy on tasks like the Cats-vs-Dogs binary classification example.

### How do I choose between TensorFlow and PyTorch in this repository?

Both frameworks are fully supported with nearly identical APIs in [`tfcv.py`](https://github.com/microsoft/AI-For-Beginners/blob/main/tfcv.py) and [`pytorchcv.py`](https://github.com/microsoft/AI-For-Beginners/blob/main/pytorchcv.py). The repository encourages comparing both ecosystems side-by-side. Choose TensorFlow if you prefer the Keras `model.fit()` workflow, or PyTorch if you want explicit control over the training loop via the `cv.train()` helper function.

### Can I use a different dataset instead of Cats vs Dogs?

Yes. While `load_cats_dogs_dataset` is provided as the default example, you can modify the image paths in [`tfcv.py`](https://github.com/microsoft/AI-For-Beginners/blob/main/tfcv.py) or create a custom `torch.utils.data.Dataset` for PyTorch. The utilities expect images organized in class folders and will apply the same 224×224 resizing and ImageNet normalization regardless of the specific dataset.

### Why should I freeze the backbone layers during initial training?

Freezing the pre-trained backbone (setting `trainable=False` in Keras or `requires_grad=False` in PyTorch) prevents the ImageNet-trained weights from updating during the first training phase. This protects the learned feature extractors while allowing the new binary classification head to learn from your specific data, preventing overfitting when working with smaller datasets like Cats-vs-Dogs.