lightning-ai/pytorch-lightning

★ 31,114PythonAudience · researcherComplexity · 3/5Setup · moderate

Mindmap

mindmap
  root((PyTorch Lightning))
    What it does
      Removes boilerplate
      Structured training
      Science vs engineering
    Core packages
      LightningModule
      Trainer
      Lightning Fabric
      Lightning Data
    Features
      Multi-GPU support
      Mixed precision
      Auto checkpointing
      Experiment logging
    Use cases
      LLM pre-training
      Image classification
      Reproducible research

mindmap root((PyTorch Lightning)) What it does Removes boilerplate Structured training Science vs engineering Core packages LightningModule Trainer Lightning Fabric Lightning Data Features Multi-GPU support Mixed precision Auto checkpointing Experiment logging Use cases LLM pre-training Image classification Reproducible research

Click or tap to explore — scroll the page freely

Things people build with this

USE CASE 1

Train a deep learning model across multiple GPUs without rewriting the training loop.

USE CASE 2

Run reproducible machine learning experiments with automatic checkpoint saving and metric logging.

USE CASE 3

Fine-tune an image classifier with 16-bit mixed-precision arithmetic for faster training using a one-line flag.

USE CASE 4

Stream large datasets from cloud storage during training using the Lightning Data package.

Tech stack

PythonPyTorch

Getting it running

Difficulty · moderate Time to first run · 30min

Multi-GPU training requires a CUDA-capable GPU, CPU-only training works but is slow for large models.

In plain English

PyTorch Lightning is a Python framework that sits on top of PyTorch, the popular deep learning library, and removes the repetitive engineering boilerplate from machine learning projects. The problem it solves is that raw PyTorch training loops require developers to write the same scaffolding code over and over: moving data between devices, tracking metrics, saving checkpoints, distributing work across multiple GPUs, and handling mixed-precision arithmetic. Lightning organizes all of that into a standard structure so researchers can focus on the actual model science instead of the infrastructure. The core idea is to separate "the science" from "the engineering." You define your model inside a class called a LightningModule, which has clear slots for the training step, validation step, and optimizer configuration. You then hand that module to a Trainer object and tell it how many GPUs to use, whether to use 16-bit floating-point for speed, and which experiment-tracking logger to connect. The Trainer handles the rest, the training loop, gradient updates, logging, checkpointing, and multi-GPU distribution, all with no code changes when you scale from one machine to thousands. The library ships four packages: PyTorch Lightning for model training, Fabric for developers who want finer-grained manual control over distributed training, Lightning Data for streaming large datasets from cloud storage, and Lightning Apps for building end-to-end AI workflows. You might use it when pre-training a large language model across a GPU cluster, fine-tuning an image classifier, or running reproducible experiments that need consistent logging and checkpoint management. The tech stack is Python and PyTorch. It installs via pip and supports CPU, GPU, and TPU accelerators.

Copy-paste prompts

Prompt 1

Convert my raw PyTorch training loop into a PyTorch Lightning LightningModule. My model is a CNN image classifier trained with Adam optimizer and cross-entropy loss, show me the minimal class structure.

Prompt 2

Set up a PyTorch Lightning Trainer to train my model on 2 GPUs with 16-bit mixed precision and save a checkpoint after every epoch. Show the minimal code needed.

Prompt 3

Add TensorBoard logging to my PyTorch Lightning training loop so I can track training loss and validation accuracy per epoch without modifying the training step.

Prompt 4

Show me how to use PyTorch Lightning Fabric to write a manual distributed training loop that still gets multi-GPU support with minimal changes to my existing code.

Open on GitHub → Explain another repo

← lightning-ai on gitmyhub — every repo by this author, as a profile.

Verify against the repo before relying on details.