Erfasst:267 News/100 KI-Tools/377 Open-Source-Projekte/67 Lernressourcen
StartNewsOpen SourceModelleKI-ToolsLernen
Start / Open Source / pytorch-lightning

pytorch-lightning

Ein leichtgewichtiger PyTorch-Wrapper, der Deep-Learning-Code organisiert und das Training von einer einzelnen CPU bis zu Tausenden von GPUs ohne Codeänderungen skaliert.

PythonApache-2.0Framework
⭐ GitHubhttps://github.com/Lightning-AI/pytorch-lightning
31,259
Stars
+0
Star-Wachstum
30. Juli 2026
Zuletzt aktualisiert
0
Klicks

1. Projektübersicht

PyTorch Lightning ist ein leichtgewichtiger, übergeordneter Wrapper für PyTorch, der Deep-Learning-Code in eine saubere, standardisierte Struktur organisiert, sodass Forscher und Ingenieure jedes Modell trainieren und skalieren können – von einer einzelnen CPU bis zu über 10.000 GPUs –, ohne ihre Kernlogik umzuschreiben oder verteilten Trainings-Boilerplate-Code manuell zu schreiben.

2. Hintergrund & Positionierung

PyTorch Lightning wurde entwickelt, um ein wiederkehrendes Problem in der Deep-Learning-Forschung zu lösen: Derselbe Engineering-Code (verteilte Trainingsschleifen, Checkpointing, gemischte Genauigkeit, Logging, Multi-Node-Orchestrierung) wird in jedem neuen Projekt kopiert und neu debuggt, während die eigentliche Forschungsidee nur einen kleinen Teil der Codebasis ausmacht. Die Kernmission von Lightning ist es, „Forschungscode“ (das Modell, die Verlustfunktion, den Optimierungsschritt) vom „Engineering-Code“ (die Trainingsschleife, Hardware-Orchestrierung, Präzisionsbehandlung) zu trennen, sodass der Wechsel von einer Laptop-CPU zu einem Multi-Node-GPU-Cluster keine Änderungen an der Modelldefinition erfordert.

Im Vergleich zum Schreiben von rohen PyTorch-Trainingsschleifen entfernt Lightning Hunderte von Zeilen repetitiven Boilerplate-Codes, während jede Komponente ein einfaches torch.nn.Module bleibt, sodass nichts versteckt oder „magisch“ ist. Im Vergleich zu schwereren, meinungsstärkeren Frameworks bleibt Lightning bezüglich Modellarchitektur und Daten unvoreingenommen – es strukturiert lediglich, wie das Training organisiert wird. Für Teams, die eine feinkörnigere Kontrolle über die Trainingsschleife selbst anstelle eines vollständig verwalteten Trainer benötigen, enthält dasselbe Repository auch Lightning Fabric, eine dünnere Schicht, die bestehende PyTorch-Schleifen mit minimalen Codeänderungen skaliert, was das Projekt sowohl für Standard-Modelltraining als auch für fortgeschrittene Anwendungsfälle wie benutzerdefiniertes Foundation-Model-Pretraining nützlich macht.

3. Funktionskategorien

🧩 Kernabstraktionen
Drei Hauptbausteine. Repräsentative Beispiele: LightningModule (umschließt Modell, Trainings-/Validierungs-/Testschritte und Optimierer), Trainer (verwaltet die Trainingsschleife, Geräte und Genauigkeit), LightningDataModule (kapselt Datensatzvorbereitung und Dataloader) und Callback (injiziert benutzerdefinierte Logik, ohne die Trainingsschleife zu berühren). Zweck: Forschungslogik sauber von Engineering-Belangen trennen.

⚡ Verteiltes & Beschleunigtes Training
Eingebaute Strategien zur Skalierung über Hardware hinweg. Repräsentative Beispiele: Multi-GPU-Datenparalleles und Modellparalleles Training, Multi-Node-Orchestrierung, TPU- und HPU-Unterstützung sowie 16/32/64-Bit-Mixed-Precision-Training. Zweck: Identischen Modellcode von einem Gerät auf Tausende von Beschleunigern ohne Codeänderungen skalieren.

📊 Experiment-Tracking & Logging
Native Integrationen zur Überwachung von Trainingsläufen. Repräsentative Beispiele: TensorBoard, Weights & Biases, MLflow, Comet und Neptune Logger sowie integrierte self.log()-Metrikprotokollierung. Zweck: Einblick in den Trainingsfortschritt ohne zusätzlichen Instrumentierungscode geben.

🛠️ Trainingswerkzeuge & Callbacks
Fertige Verhaltensweisen, die in den Trainer eingefügt werden. Repräsentative Beispiele: automatisches Checkpointing, Early Stopping, Learning-Rate-Suche, stochastische Gewichtsdurchschnittsbildung und Gradientenakkumulation. Zweck: Häufige Trainingsanforderungen deklarativ statt imperativ abdecken.

🪶 Lightning Fabric
Eine leichtgewichtigere Skalierungsschicht für Teams, die ihre eigene Trainingsschleife beibehalten möchten. Repräsentative Beispiele: fabric.setup() für Modelle und Optimierer, fabric.backward(), verteilte Sampler und Precision-Plugins. Zweck: Multi-GPU-/Multi-Node-Skalierung zu bestehendem PyTorch-Code mit nur wenigen hinzugefügten Zeilen hinzufügen.

4. Wichtige Highlights

  • Skalierung ohne Codeänderungen — dasselbe LightningModule läuft auf CPU, einer einzelnen GPU, mehreren GPUs, mehreren Nodes oder TPUs, indem nur Trainer-Flags geändert werden.
  • Über 40 eingebaute Trainingsfunktionen — Checkpointing, Early Stopping, Gradient Clipping, Mixed Precision und mehr sind sofort einsatzbereit und über Trainer-Argumente konfigurierbar.
  • Volle Flexibilität beibehalten — ein LightningModule ist weiterhin ein Standard-PyTorch-nn.Module, sodass bestehende PyTorch-Modelle und -Schichten unverändert funktionieren.
  • Reproduzierbarkeit und Stringenz — jeder Pull-Request wird über unterstützte PyTorch/Python-Versionskombinationen, Betriebssysteme und Multi-GPU/TPU-Konfigurationen getestet.
    -Minimaler Overhead — die Abstraktion fügt handgeschriebenen PyTorch-Schleifen nur geringe, gemessene Laufzeitkosten (ca. Millisekunden pro Epoche) hinzu.
  • Dutzende von Ökosystem-Integrationen — funktioniert mit beliebten Loggern, Profilern und Begleitbibliotheken wie TorchMetrics für skalierbare Metrikberechnung.

5. Anwendungsfälle nach Rolle

  • Allgemeine Entwickler — strukturieren Sie ein persönliches oder Produktionsmodell in ein LightningModule, um Checkpointing, Logging und Multi-GPU-Unterstützung zu erhalten, ohne benutzerdefinierten Trainingsschleifen-Code zu schreiben.
  • Daten-/Forschungswissenschaftler — prototypen und benchmarken Sie neue Architekturen schnell und skalieren Sie dann denselben Code von einem Laptop auf einen Multi-Node-GPU-Cluster für groß angelegte Experimente oder Foundation-Model-Training.
  • DevOps/SRE — verlassen Sie sich auf Lightnings eingebaute verteilte Strategien und Precision-Plugins, um zu standardisieren, wie Trainingsjobs über eine gemeinsam genutzte GPU/TPU-Infrastruktur bereitgestellt und skaliert werden.

6. Erste Schritte

Finden Sie, was Sie brauchen — durchsuchen Sie die offizielle Dokumentation nach Anleitungen zum Trainer, LightningModule, verteilten Strategien und dem Verzeichnis examples/ im Repository für ausführbare End-to-End-Skripte.

Installation / Integration

pip install pytorch-lightning

Minimales Verwendungsmuster:

import lightning.pytorch as pl

model = LitModel()
trainer = pl.Trainer(max_epochs=10, accelerator="auto", devices="auto")
trainer.fit(model, train_dataloaders=train_loader)

Beitragen — lesen Sie CONTRIBUTING.md im Repository für Setup- und Programmierstil-Richtlinien und öffnen Sie dann einen Pull-Request gegen den master-Branch. Diskutieren Sie Ideen zuerst über GitHub Issues oder den Lightning-Community-Discord.

7. Projektstruktur

pytorch-lightning/
├── src/
│   ├── lightning/            # einheitliches Paket (pytorch + fabric + app)
│   ├── pytorch_lightning/    # Trainer, LightningModule, Callbacks, Logger
│   └── lightning_fabric/     # Fabric: leichtgewichtige Skalierungsschicht
├── examples/                 # ausführbare End-to-End-Trainingsbeispiele
├── tests/                    # Unit- und Integrationstests
├── docs/                     # Quelle für die offizielle Dokumentation
└── requirements/              # Abhängigkeitslisten pro Komponente

src/pytorch_lightning/trainer/trainer.py implementiert die Kern-Trainingsschleife und src/pytorch_lightning/core/module.py definiert die LightningModule-Basisklasse — dies sind die beiden Dateien, mit denen die meisten Benutzer indirekt über Unterklassenbildung interagieren.

8. Verwandtes Ökosystem

PyTorch Lightning baut direkt auf PyTorch auf und wird von Lightning AI gepflegt, das auch TorchMetrics (skalierbare Metrikberechnung), Lightning Fabric (im selben Repository enthalten) und die Cloud-Plattform Lightning Studio zum Ausführen und Bereitstellen von Trainingsjobs entwickelt. Es integriert sich mit gängigen Experiment-Trackern wie TensorBoard, Weights & Biases, MLflow, Comet und Neptune und arbeitet mit verteilten Trainings-Backends wie NVIDIA NCCL und DeepSpeed zusammen.

9. Lizenz

  • ✅ Kommerzielle und nicht-kommerzielle Nutzung, Modifikation und Weiterverbreitung sind unter der Apache-2.0-Lizenz gestattet.
  • ✅ Eine Patentgewährung von Mitwirkenden ist enthalten, was Benutzern zusätzlichen rechtlichen Schutz bietet.
  • ℹ️ Modifizierte Dateien müssen einen Hinweis tragen, der besagt, dass Änderungen vorgenommen wurden, gemäß den Bedingungen der Apache-2.0.
  • ❌ Die Lizenz bietet keine Gewährleistung; die Marke „Lightning“ und das Branding sind nicht von der Code-Lizenz abgedeckt.

10. FAQ

F: Was ist der Unterschied zwischen dem Trainer und Lightning Fabric?
A: Der Trainer ist eine vollständig verwaltete Trainingsschleife für Standardanwendungsfälle; Fabric ist eine dünnere Schicht für Teams, die ihre eigene Schleife weiterhin schreiben möchten, aber trotzdem Multi-GPU-/Multi-Node-Skalierung erhalten möchten. Siehe den Vergleichsleitfaden.

F: Muss ich mein bestehendes PyTorch-Modell umschreiben, um Lightning zu verwenden?
A: Nein — ein LightningModule ist ein torch.nn.Module mit einigen hinzugefügten Methoden (training_step, configure_optimizers usw.), sodass bestehender Modellcode normalerweise mit minimalen Änderungen übernommen werden kann.

F: Wie führe ich das Training auf mehreren GPUs oder Nodes aus?
A: Setzen Sie die entsprechenden Trainer-Argumente, z. B. Trainer(accelerator="gpu", devices=4, strategy="ddp", num_nodes=2) — am LightningModule sind keine Änderungen erforderlich.

F: Unterstützt Lightning Mixed-Precision- oder TPU-Training?
A: Ja, über Trainer(precision="16-mixed") für gemischte Genauigkeit und Trainer(accelerator="tpu") für TPU-Training.

F: Wie melde ich einen Fehler oder fordere eine Funktion an?
A: Öffnen Sie ein Issue im GitHub-Repository gemäß den bereitgestellten Vorlagen.

11. Schnelllinks

12. Zusammenfassung

PyTorch Lightning gibt Forschern und Ingenieuren die Möglichkeit, Modellcode einmal zu schreiben und überall zu skalieren – von einer Laptop-CPU bis zu einem großen Multi-Node-GPU-Cluster –, ohne die zugrunde liegende Logik anzutasten. Es eignet sich gut für einzelne Entwickler, die Trainings-Schleifen-Boilerplate eliminieren möchten, und für Forschungsteams, die reproduzierbare, groß angelegte Experimente mit minimalem Engineering-Aufwand benötigen.