fastai/course22

Features

• Multi-Domain Training - Trains models for computer vision, NLP, tabular analysis, and collaborative filtering using PyTorch and fastai.
• Deep Learning Education - Teaches deep learning fundamentals through hands-on Jupyter notebooks for programmers.
• Augmentation Pipelines - Creates augmentation pipelines with flips, rotations, zooms, warps, and lighting changes at configurable probabilities.
• Collaborative Filtering Models - Creates dot-product or neural-network models that predict user-item ratings from a ratings table.
• Segmentation Model Training - Provides a training workflow for pixel-level image segmentation models.
• High-Level Loop Replacements - Replaces handwritten training loops with a single high-level call that handles batching, loss, and metrics.
• Data Block APIs - Defines new data blocks with transforms and types for modular ML data pipeline construction.
• Type-Dispatch Pipelines - Uses a new data block API and type dispatch system to express common data processing patterns concisely.
• Tabular Metadata Wrappers - Wraps DataFrames with column metadata for automated tabular data preprocessing.
• High-Level Training APIs - Provides high-level components that deliver state-of-the-art results in standard deep learning domains with minimal code.
• Classification Training - Provides a high-level training workflow for image classification models with automatic architecture selection and learning rate finding.
• Generative Model Sampling - Provides techniques for selecting tokens from a language model's output distribution to generate text.
• Language Model Builders - Teaches building language models from scratch with dropout scaling for regularization.
• AWD-LSTM Language Model Builders - Teaches building AWD-LSTM language models with configurable dropout for regularization.
• Batched DataLoader Wrappers - Wraps transformed datasets into DataLoaders that apply transforms before, during, and after batching.
• Model Persistence - Provides utilities for saving and loading model weights and optimizer states to disk.
• Classification Fine-Tuning - Provides a fine-tuning workflow for single-label image classification using pretrained models.
• Vision Model Training - Provides a framework for building and training vision models from data loaders with optional pretrained weights.
• Language Model Training - Provides a training workflow for language models on tokenized text with loss and perplexity measurement.
• Discriminative Layer Unfreezing - Teaches progressive unfreezing of layer groups with discriminative learning rates for fine-tuning pretrained models.
• One-Cycle Schedulers - Teaches the one-cycle learning rate schedule for faster convergence and better generalization.
• Model Performance Evaluators - Provides tools for quantifying model accuracy by comparing predictions against ground truth labels.
• Model Training Pipelines - Offers low-level, composable building blocks and a callback system to modify any part of training.
• U-Net Architectures - Teaches building dynamic U-Net segmentation models that adapt decoders to encoder feature map sizes.
• Parameter Freezing - Teaches parameter freezing and unfreezing for transfer learning and fine-tuning.
• Pooling Classifiers - Teaches pooling-based text classification by feeding pooled features through a linear classifier.
• Prompt-Based Text Generation - Generates text sequences conditioned on input prompts using a pretrained transformer model.
• Text Classifier Fine-Tuning - Provides a fine-tuning workflow for text classification using pretrained language models on labeled datasets.
• Training Callbacks - Provides a configurable callback system that hooks into training loop events like batch start and loss computation.
• Parameter Group Unfreezers - Teaches parameter group unfreezing to resume training frozen layers during fine-tuning.
• Batched DataLoader Wrapping - Converts transformed datasets into batched data loaders for model training and inference.
• Training Loop Controllers - Provides a training loop controller that groups model, data loaders, and loss function.
• Type-Dispatching Pipelines - Implements type-dispatch transform pipelines that route data items to type-specific encode and decode methods.
• Sentence Embeddings - Teaches sentence encoding using modules that process padded input in chunked format.
• Vision Model Fine-Tuning - Fine-tunes pretrained models to recognize objects or breeds in custom image datasets.
• Declarative Pipeline Blueprints - Provides a declarative API for assembling complete data processing pipelines from scratch.
• Declarative Pipeline Construction - Constructs custom data processing pipelines using a declarative block API.
• Data Block Blueprints - Ships a declarative API for constructing data processing pipelines by specifying types, sources, splits, and transforms in a blueprint.
• ML Data Pipeline Declarations - Defines types, sources, splits, and transforms to produce Datasets and DataLoaders declaratively.
• CSV Data Loaders - Creates data loaders from CSV files, applying preprocessing and splitting into training and validation sets.
• Tabular Predictive Models - Provides a workflow for building predictive models on structured tabular data to forecast target values.
• Tabular Data Loaders - Loads and preprocesses tabular data with encoding, imputation, and normalization for model training.
• Configurable Preprocessor Pipelines - Transforms raw tabular data through configurable pipelines of categorification, imputation, and normalization.
• Data Transformation Pipelines - Applies pipelines of transforms to collections of items, producing transformed datasets for model training.
• Reusable Transform Pipelines - Provides reusable data processing pipelines with encode, decode, and display capabilities for ML workflows.
• Sequential Pipelines - Combines multiple data transformations into sequential pipelines that process raw items end-to-end.
• Deep Learning Courses - A structured curriculum of Jupyter notebooks teaching deep learning with PyTorch and fastai.
• Deep Learning Curriculum - Walks through a complete course of Jupyter notebooks, slides, and spreadsheets for deep learning.
• Labeled - Reads image files from folders or dataframes and pairs them with category labels for model training.
• Labeled Image Loading from DataFrames - Loads images and their labels from DataFrames or CSV files for training.
• Neural Network Training from Scratch - Teaches building SGD and a complete training loop from scratch to understand deep learning foundations.
• Collaborative Filtering Systems - Trains collaborative filtering models to predict user preferences for items like movies.
• Tabular Data Loaders - Creates data loaders from pandas DataFrames for tabular model training.
• Normalization Freezers - Freezes batch normalization statistics during transfer learning to preserve pretrained feature extractors.
• DataFrame-Based Loaders - Constructs data loaders for collaborative filtering directly from in-memory ratings tables.
• Lighting Adjusters - Modifies brightness, contrast, saturation, and hue of images to simulate different lighting conditions.
• Center Cropping and Padding - Center crops or pads images to a specified size for consistent model input dimensions.
• Custom Data Transform Extensions - Adds normalization, data augmentation, and other transforms to custom datasets via afteritem and afterbatch hooks.
• Custom Model Training - Guides experienced users through collecting data and training specialized models like Siamese networks.
• Data-Parallel Training - Implements data-parallel training across multiple GPUs by synchronizing gradients and splitting batches using PyTorch's distributed backend.
• Custom Performance Metrics - Teaches creating custom metrics that accumulate state across batches and compute final values.
• Feature Attribution Methods - Uses attribution methods to explain which input features most influence a model's output.
• Tensor Flattening - Demonstrates flattening multi-dimensional tensors into one-dimensional vectors for linear layers.
• GAN Training Loops - Alternates training iterations between generator and critic for adversarial training.
• Focal Loss Calculators - Down-weights easy-to-classify observations in cross-entropy loss to focus training on hard examples.
• Regression Loss Functions - Applies MSE or L1 loss with automatic tensor flattening for regression tasks.
• Dice Loss Calculators - Measures overlap between predicted and ground-truth segmentation masks using Dice loss.
• Combined Loss Functions - Mixes Dice loss with focal loss to balance global and local feature learning during segmentation training.
• Sequential Layer Containers - Demonstrates chaining neural network layers sequentially using PyTorch's nn.Sequential container.
• Sequential Containers - Shows how to create sequential containers that automatically wrap functions as layers.
• Per-Split Augmentations - Runs different augmentation pipelines on training and validation sets by specifying a split index.
• Mixed Precision Training - Teaches mixed precision training to accelerate training and reduce memory usage.
• Custom Loss Functions - Implements custom loss functions with activation and decoding methods for integration with prediction tools.
• Encoder Persisters - Persists the encoder portion of a text model to disk and restores it for reuse or transfer learning.
• Multi-Label - Ships a fine-tuning workflow for multi-label image classification tasks using pretrained models.
• Coordinate Prediction Fine-Tuning - Provides a fine-tuning workflow for predicting spatial coordinates from images with consistent augmentation.
• Classification Interpreters - Explores predictions from classification models to identify errors and understand model behavior.
• Segmentation Interpreters - Explores predictions from segmentation models to identify errors and understand model behavior.
• Batch Prediction Analyzers - Ships batch processing utilities that generate predictions and losses for interpreting model behavior.
• Dataset Prediction Generators - Computes predictions and targets for entire datasets with options for decoding and saving to disk.
• Single Item Predictors - Runs single items through the model and returns decoded predictions with probabilities.
• Optimizer Refactors - Refactors optimization algorithms into composable pieces for writing new optimizers concisely.
• Adversarial Training Procedures - Wraps generator and critic together, switching between them during adversarial training.
• Learner Exports - Saves trained learner objects without data or optimizer state for deployment.
• Weights and Biases Training Logging - Logs model topology, losses, metrics, gradients, and sample predictions to Weights & Biases during training.
• Multi-GPU Training Utilities - Distributes training across multiple GPUs using PyTorch's distributed backend and Accelerate.
• Pretrained Model Loading - Provides utilities for loading pretrained language models and adapting their vocabularies for downstream tasks.
• DataFrame Column Tokenization - Tokenizes specified text columns of a DataFrame in parallel for NLP preprocessing.
• Convolutional Network Builders - Teaches building convolutional neural networks from filter size lists with configurable strides.
• Adam Optimizers - Implements Adam and AdamW optimizers as part of the training loop for deep learning models.
• Prediction Visualization - Provides tools for displaying and filtering model prediction results alongside inputs for visual inspection.
• Binary Cross-Entropy Calculators - Applies binary cross-entropy loss with automatic tensor flattening for binary classification tasks.
• Medical Imaging Training Frameworks - Provides a training workflow for medical image classifiers using DICOM files to detect conditions like pneumothorax.
• Self-Attention Mechanisms - Teaches adding self-attention layers to convolutional networks for capturing long-range spatial dependencies.
• Temporal Sequence Processors - Teaches applying the same module to each temporal slice of a sequence for consistent processing.
• Test Time Augmentation - Applies data transformations during inference and averages predictions to improve accuracy.
• Text Classifier Construction - Provides a workflow for constructing text classification models from pretrained encoders with sentence-level processing.
• CSV - Tokenizes text columns of CSV files in parallel, writing tokenized results with added length columns.
• Best Checkpoint Selectors - Saves the best-performing model checkpoint based on validation metrics during training.
• Gradient Accumulation Strategies - Accumulates gradients across several batches before updating weights for larger effective batch sizes.
• Pretrained Weight Initializers - Downloads and loads pretrained model weights for language models and transformers from remote sources.
• Learner Restorers - Restores exported learner objects from disk for inference using pickle.
• Domain-Specific Fine-Tuning - Provides a workflow for adapting pretrained language models to specific text corpora through continued pretraining.
• Pixel-Wise Segmentation Fine-Tuning - Provides a fine-tuning workflow for pixel-wise image segmentation using pretrained models.
• Transformer Fine-Tuning - Provides a fine-tuning workflow for HuggingFace transformer models using fastai's learning rate finder and 1cycle policy.
• Transformer Training Walkthroughs - Provides step-by-step walkthroughs for building and fine-tuning NLP models using a high-level API.
• Optimizer Composers - Teaches a compositional optimizer design that lets new algorithms be written in a few lines.
• Categorical Encoders - Converts categorical columns into numeric representations, storing unique values per column for ML models.
• Label Extraction Functions - Ships utilities for extracting labels from image filenames using custom functions or regex.
• Custom Data Pipeline Guidance - Guides users through constructing custom data pipelines for vision and text tasks using a mid-level API.
• Label Reading from Columns - Reads column values from DataFrame rows as labels for supervised learning tasks.
• Transform Wrapping for Datasets - Wraps custom dataset logic into Transform objects so they integrate with the data pipeline system.
• Label Smoothing Techniques - Replaces hard one-hot targets with smoothed labels in cross-entropy loss to reduce overfitting.
• Single Row Predictors - Returns predictions for single rows of tabular data along with the original input values.
• Tabular Data Preprocessing - Provides data preprocessing pipelines for tabular data including categorical encoding, missing value imputation, and normalization.
• Sentiment Classification Fine-Tuning - Provides a fine-tuning workflow for sentiment classification using pretrained language models with transfer learning.
• DICOM Visualization Tools - Displays X-ray images from DICOM pixel arrays using standard plotting functions.
• DICOM Parsing - Reads medical DICOM files, extracting pixel data and metadata tags for analysis.
• Affine Transformation Engines - Applies affine transformations like rotation, zoom, and warp to images and associated masks or bounding boxes.
• Random Crop and Flip Augmentations - Randomly flips images horizontally or applies dihedral transformations with configurable probability during training.
• Multi-Strategy Resizing - Resizes images using squish, pad, or crop methods with different strategies for training and validation sets.
• Dimension Resizing - Changes pixel dimensions of images to a specified size for model input consistency.
• DICOM File Loading - Recursively finds and loads DICOM medical image files from a specified path.
• Training - Blends pairs of training images with configurable ratios to create augmented samples for better generalization.
• Residual Shortcut Mergers - Teaches merging residual shortcut connections with main path outputs in convolutional networks.
• Optimizer Stepper Composition - Provides a modular system for composing custom optimizers from small stepper functions that define individual update rules.
• Training Metrics - Logs learning rate, loss, and metrics during training and provides loss curve plotting.
• Augmentation-Aware Mask Handlers - Applies identical spatial augmentations to images and segmentation masks for consistent training data.

Historique des stars