Workflow:Fastai Fastbook Image Classification
| Knowledge Sources | |
|---|---|
| Domains | Computer_Vision, Deep_Learning, Transfer_Learning |
| Last Updated | 2026-02-09 17:00 GMT |
Overview
End-to-end process for building an image classification model using fastai's high-level API with transfer learning on pretrained convolutional neural networks.
Description
This workflow covers the complete pipeline for creating an image classifier, from collecting or loading image data through to deploying a trained model. It leverages transfer learning by starting with a pretrained model (such as ResNet) and fine-tuning it on a custom dataset. The fastai DataBlock API handles data loading, augmentation, and batching, while the Learner API manages training with techniques like discriminative learning rates and one-cycle training. The result is a production-ready classifier that can distinguish between image categories with high accuracy, even with limited training data.
Usage
Execute this workflow when you have a collection of labeled images (or can collect them via web search) and need to train a model that classifies images into categories. This is the primary entry point for anyone starting with computer vision using fastai, covering use cases from simple binary classification (dogs vs. cats) to fine-grained breed identification (37 pet breeds) and custom domain classifiers (bear species, plant diseases, etc.).
Execution Steps
Step 1: Data Collection
Gather images for each category in the classification task. This can be done by downloading a curated dataset (using fastai's built-in dataset URLs), scraping images from web search APIs (Bing Image Search or DuckDuckGo), or organizing existing image files into category-named folders. Each category's images should be placed in a separate subdirectory.
Key considerations:
- Aim for at least 150 images per category for basic tasks
- Verify image quality and remove corrupted downloads
- Use fastai's verify_images utility to identify and remove broken files
Step 2: DataBlock Construction
Define the data pipeline using fastai's DataBlock API. This involves specifying the input and output types (ImageBlock for images, CategoryBlock for labels), how to retrieve items (get_image_files), how to split into training and validation sets (RandomSplitter), how to extract labels (from folder names, filenames via regex, or a CSV), and what transformations to apply.
Key considerations:
- Choose the appropriate labeling strategy (parent folder name, regex on filename, or external labels file)
- Apply presizing strategy: Resize to a large size first (e.g., 460px), then use aug_transforms with a smaller target size (e.g., 224px) for GPU-accelerated augmentation
- Always inspect the data with show_batch before training to verify correctness
Step 3: DataLoaders Creation
Convert the DataBlock blueprint into DataLoaders by pointing it at the data source path. The DataLoaders object provides training and validation data streams with proper batching, shuffling, and augmentation applied. Verify the data pipeline by visually inspecting sample batches.
Key considerations:
- Use show_batch to confirm labels match images
- Use the summary method to debug DataBlock errors
- Ensure batch size fits in GPU memory
Step 4: Model Selection and Learner Creation
Create a Learner by combining the DataLoaders with a pretrained architecture. The cnn_learner (or vision_learner) function loads a pretrained model, replaces the final classification head with layers appropriate for the number of target categories, and sets up the training configuration including loss function and metrics.
Key considerations:
- ResNet34 is a good starting architecture for most tasks; ResNet50 or larger for more complex problems
- Specify appropriate metrics (error_rate, accuracy) for monitoring
- The pretrained model body is frozen by default, only training the new head initially
Step 5: Learning Rate Selection
Use the learning rate finder (lr_find) to identify an appropriate learning rate. The finder runs a short training session with exponentially increasing learning rates and plots loss vs. learning rate. Select a rate where the loss is still decreasing steeply, typically one order of magnitude before the minimum.
Key considerations:
- Look for the steepest downward slope on the lr_find plot
- A typical good learning rate is between 1e-3 and 1e-2 for the head
- This step prevents divergence from too-high rates or slow training from too-low rates
Step 6: Training with Fine_tune
Train the model using the fine_tune method, which implements a two-phase transfer learning strategy. First, only the randomly initialized head layers are trained for one epoch with the body frozen. Then, the entire model is unfrozen and trained for the specified number of additional epochs with discriminative learning rates (lower rates for early pretrained layers, higher rates for later layers).
Key considerations:
- Start with a small number of epochs (3-5) and increase if the model is still improving
- Monitor both training and validation loss to detect overfitting
- Use fit_one_cycle for more control over the training schedule when needed
Step 7: Interpretation and Cleanup
Analyze model performance using the ClassificationInterpretation class. Generate a confusion matrix to see which categories are most confused, and use plot_top_losses to examine the individual predictions where the model is most wrong. Optionally use the ImageClassifierCleaner widget to interactively fix mislabeled images, then retrain.
Key considerations:
- Focus on the most confused category pairs for targeted data improvement
- High-loss examples may reveal labeling errors in the dataset rather than model failures
- Re-examine data collection if certain categories consistently underperform
Step 8: Export and Deployment
Export the trained model using learn.export(), which saves the model architecture, trained weights, and the DataLoaders definition (including all transforms) into a single pickle file. This file can be loaded in a production environment using load_learner and used for inference on new images.
Key considerations:
- The exported file contains everything needed for inference, no training code required
- Deploy as a web application or API endpoint
- Consider model size and inference latency for the target deployment platform