fastai

2.8.7 · active · verified Sun Apr 12

fastai is a deep learning library that simplifies training fast and accurate neural nets using modern best practices. It's built on top of PyTorch and offers both high-level APIs for quick model development and lower-level components for researchers. The library maintains an active development pace with frequent patch and minor releases, often tied to PyTorch version updates, to ensure compatibility and leverage the latest deep learning advancements.

Warnings

breaking fastai v2 is a complete rewrite and is *not API-compatible* with fastai v1. Code written for v1 will break. Key changes include data loading (`DataBunch` in v1 to `DataBlock`/`DataLoaders` in v2) and the callback API (e.g., `on_*_begin` to `before_*`).
Fix: Refer to the fastai v2 migration guides and rewrite data loading and callback logic according to the new API. The overall architecture remains similar, making the transition less daunting than a full rewrite.
gotcha PyTorch Version Compatibility: fastai generally requires specific PyTorch versions. While recent versions (2.8.7+) may be more lenient, historically, strict compatibility has been crucial. Installing an incompatible PyTorch version can lead to runtime errors or unexpected behavior.
Fix: Always check the fastai release notes or official documentation for the precise PyTorch version range supported by your installed fastai version. It is often recommended to install PyTorch first, ensuring the correct CUDA toolkit version, before installing fastai.
gotcha The heavy use of `from fastai.app_name.all import *` for convenience in interactive notebooks can lead to namespace pollution and make it difficult to trace the origin of functions and classes, potentially causing name clashes or confusion in larger projects.
Fix: For production code or when clarity is paramount, consider more explicit imports (e.g., `from fastai.vision.data import ImageDataLoaders`). Be aware of fastai's design philosophy, which prioritizes interactive use and rapid prototyping with `import *`.
gotcha On Windows, when running fastai code within Jupyter notebooks, `num_workers` for `DataLoader` is automatically reset to 0 to avoid multiprocessing-related hangs. This significantly slows down data loading, especially for I/O-heavy tasks like computer vision.
Fix: For optimal performance on Windows, it is highly recommended to use Windows Subsystem for Linux (WSL) or run fastai from a standalone Python script where `num_workers` can be utilized effectively.
gotcha Dependency conflicts with NumPy: Newer versions of NumPy (e.g., NumPy 2.0) can cause incompatibility issues with other compiled modules that fastai, or its underlying libraries, might depend on. This can result in 'procedure not found' or similar errors during runtime.
Fix: If encountering such errors, check fastai's and PyTorch's official documentation for compatible NumPy versions. Downgrading NumPy might be necessary, but ensure it doesn't break other critical dependencies.

Install

pip install fastai Standard Installation
pip install "torch>=X.X,<Y.Y" torchvision torchaudio --index-url https://download.pytorch.org/whl/cuXX pip install fastai Recommended: Install PyTorch First (Specify CUDA Version)

Imports

vision.all
```
from fastai.vision.all import *
```
Recommended for computer vision applications. The `all` module imports many common fastai components and external libraries (e.g., numpy as np, pandas as pd, matplotlib.pyplot as plt) for interactive use.
text.all
```
from fastai.text.all import *
```
Recommended for natural language processing tasks, similarly providing an extensive set of imports.
tabular.all
```
from fastai.tabular.all import *
```
Recommended for tabular data applications.
basics
```
from fastai.basics import *
```
For core fastai functionality without application-specific modules. Importing `fastai` directly (as was common in v1) is deprecated in v2.

Quickstart

This quickstart demonstrates how to train an image classification model using fastai. It downloads the Oxford-IIIT Pet Dataset, creates `DataLoaders`, initializes a `Learner` with a pre-trained `resnet34` model, and fine-tunes it for one epoch. This showcases fastai's high-level API for rapidly achieving state-of-the-art results.

import os
from fastai.vision.all import *

# Ensure the necessary directory for models is available
# os.environ['XDG_CACHE_HOME'] = os.environ.get('XDG_CACHE_HOME', './.cache')

# Download and untar the dataset (Oxford-IIIT Pet Dataset)
path = untar_data(URLs.PETS)/'images'

# Define a function to label images (e.g., determine if an image name starts with an uppercase letter, meaning it's a cat)
def is_cat(x): return x[0].isupper()

# Create DataLoaders from image files in the specified path
# valid_pct splits data for validation, seed ensures reproducibility
# label_func applies 'is_cat' for labels, item_tfms resizes images
dls = ImageDataLoaders.from_name_func(
    path, get_image_files(path), valid_pct=0.2, seed=42,
    label_func=is_cat, item_tfms=Resize(224)
)

# Create a Learner with a pre-trained ResNet34 model and error_rate as a metric
learn = vision_learner(dls, resnet34, metrics=error_rate)

# Fine-tune the model for one epoch. This is a form of transfer learning.
learn.fine_tune(1)

print("Model training complete for image classification. You can now use `learn.predict(img)` for inference.")

view raw JSON →