Panduan Lengkap PyTorch Lightning: Deep Learning Made Simple

PyTorch Lightning adalah framework high-level untuk PyTorch yang menyederhanakan proses training deep learning model. Lightning memisahkan science code dari engineering code, membuat kode lebih clean, scalable, dan reproducible.

Dalam tutorial ini, kita akan mempelajari PyTorch Lightning dari dasar hingga advanced usage dengan contoh praktis.

Mengapa PyTorch Lightning?

Keunggulan PyTorch Lightning:

Perbandingan: PyTorch vs PyTorch Lightning

| Aspek | PyTorch Murni | PyTorch Lightning |

|-------|---------------|-------------------|

| Training Loop | Manual | Otomatis |

| Multi-GPU | Implementasi manual | 1 line change |

| Mixed Precision | Setup manual | Flag sederhana |

| Checkpointing | Manual | Built-in |

| Logging | Manual | Terintegrasi |

| Code Organization | Bebas | Terstruktur |

Instalasi

Install PyTorch Lightning

# Install dengan pip
pip install lightning

Atau install dengan conda
conda install lightning -c conda-forge

Install dengan extras (untuk logging, etc)
pip install lightning[extra]

Versi spesifik
pip install lightning==2.1.0

Verifikasi Instalasi

import lightning as L
import torch

print(f"Lightning version: {L.version}")
print(f"PyTorch version: {torch.version}")
print(f"CUDA available: {torch.cuda.isavailable()}")

PyTorch Lightning
├── LightningModule      # Model + Training Logic
├── LightningDataModule  # Data Loading
├── Trainer              # Training Orchestration
├── Callbacks            # Custom Behaviors
└── Loggers              # Experiment Tracking

import lightning as L
import torch
import torch.nn as nn
import torch.nn.functional as F

class LitModel(L.LightningModule):
    def init(self, inputsize, hiddensize, numclasses, learningrate=1e-3):

        super().init()
        # Save hyperparameters
        self.savehyperparameters()

        # Define model architecture
        self.layer1 = nn.Linear(inputsize, hiddensize)
        self.layer2 = nn.Linear(hiddensize, hiddensize)
        self.layer3 = nn.Linear(hiddensize, numclasses)
        self.dropout = nn.Dropout(0.2)

    def forward(self, x):
        """Forward pass untuk inference."""
        x = F.relu(self.layer1(x))
        x = self.dropout(x)
        x = F.relu(self.layer2(x))
        x = self.dropout(x)
        x = self.layer3(x)
        return x

    def trainingstep(self, batch, batchidx):
        """Single training step."""
        x, y = batch
        logits = self(x)
        loss = F.crossentropy(logits, y)


        # Log metrics
        acc = (logits.argmax(dim=1) == y).float().mean()
        self.log('trainloss', loss, progbar=True)

        self.log('trainacc', acc, progbar=True)


        return loss

    def validationstep(self, batch, batchidx):

        """Single validation step."""
        x, y = batch
        logits = self(x)
        loss = F.crossentropy(logits, y)

        acc = (logits.argmax(dim=1) == y).float().mean()
        self.log('valloss', loss, progbar=True)
        self.log('valacc', acc, progbar=True)

        return loss

    def teststep(self, batch, batchidx):
        """Single test step."""
        x, y = batch