Ptl Models Kuku Model Set 01 15 (2024)

Kuku Model Set 01 15 is a structured set of 15 PyTorch Lightning models. Each model shares the same base API but varies in one or more of these dimensions:

The “01” indicates the base dataset/config version (e.g., CIFAR-10 scaled, a specific text corpus, or a proprietary tabular set). “15” means 15 trained model instances.

After training all 15 models, we aggregate metrics:

# results_analysis.ipynb snippet
import pandas as pd
import glob
results = []
for ckpt_dir in glob.glob("checkpoints/set_01//best.ckpt"):
variant = ckpt_dir.split("/")[2]   # e.g., "kuku_01_04"
# Parse best_val_acc from filename
acc = float(ckpt_dir.split("val_acc=")[-1].replace(".ckpt",""))
results.append("variant": variant, "best_val_acc": acc) ptl models kuku model set 01 15
df = pd.DataFrame(results).sort_values("best_val_acc", ascending=False)
print(df)

Example output from Kuku Model Set 01 15: Kuku Model Set 01 15 is a structured

| Variant | Best Val Accuracy | Architecture Highlights | |--------------|------------------|----------------------------------| | kuku_01_12 | 98.32% | Deep + Dropout | | kuku_01_04 | 98.11% | LayerNorm + GELU | | kuku_01_07 | 97.95% | Wide (512 dims) | | kuku_01_01 | 97.43% | Baseline shallow |

Key insight: Variant 12 (5-layer with dropout) outperformed deeper or wider models, likely due to better regularization on MNIST-scale data.

Now the magic: train all 15 variants automatically with identical conditions. The “01” indicates the base dataset/config version (e

# train_all_variants.py
import pytorch_lightning as pl
from pytorch_lightning.callbacks import ModelCheckpoint, EarlyStopping
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
kuku_model_set_01/
│
├── base/
│   └── kuku_base_model.py          # Abstract LightningModule
├── variants/
│   ├── kuku_01_01.py               # Baseline small model
│   ├── kuku_01_02.py               # Wider layers
│   ├── kuku_01_03.py               # Deeper network
│   └── ... up to 15
├── configs/
│   └── set_01_hyperparams.yaml     # Shared dataset & training params
├── checkpoints/                    # Auto-saved by PTL
│   └── set_01/
│       ├── kuku_01_01/
│       ├── ...
│       └── kuku_01_15/
├── logs/                           # TensorBoard logs
├── train_all_variants.py
└── results_analysis.ipynb

First, we create an abstract base class that all 15 variants will inherit from. This ensures consistent training steps, optimizer setup, and validation logic.
# base/kuku_base_model.py
import torch
import torch.nn as nn
import pytorch_lightning as pl
from torchmetrics import Accuracy
class KukuBaseModel(pl.LightningModule):
def init(self, input_dim, num_classes, learning_rate=1e-3):
super().init()
self.save_hyperparameters()
self.learning_rate = learning_rate
self.criterion = nn.CrossEntropyLoss()
self.train_acc = Accuracy(task="multiclass", num_classes=num_classes)
self.val_acc = Accuracy(task="multiclass", num_classes=num_classes)
def forward(self, x):
    raise NotImplementedError("Subclass must implement forward()")
def training_step(self, batch, batch_idx):
    x, y = batch
    logits = self(x)
    loss = self.criterion(logits, y)
    self.train_acc(logits, y)
    self.log("train_loss", loss, prog_bar=True)
    self.log("train_acc", self.train_acc, prog_bar=True)
    return loss
def validation_step(self, batch, batch_idx):
    x, y = batch
    logits = self(x)
    loss = self.criterion(logits, y)
    self.val_acc(logits, y)
    self.log("val_loss", loss, prog_bar=True)
    self.log("val_acc", self.val_acc, prog_bar=True)
def configure_optimizers(self):
    return torch.optim.Adam(self.parameters(), lr=self.learning_rate)