Models Kuku Model Set 01 15 — Ptl

VARIANT_MAP = 1: Kuku_01_01, 4: Kuku_01_04, 12: Kuku_01_12, # ... complete for all 15

def get_dataloaders(): transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,)) ]) train_set = datasets.MNIST('./data', train=True, download=True, transform=transform) val_set = datasets.MNIST('./data', train=False, transform=transform) return DataLoader(train_set, batch_size=64, shuffle=True), DataLoader(val_set, batch_size=64)

train_loader, val_loader = get_dataloaders()

for variant_id in range(1, 16): print(f"🚀 Training Kuku_01_variant_id:02d") model_class = VARIANT_MAP[variant_id] model = model_class(input_dim=784, num_classes=10)

checkpoint_callback = ModelCheckpoint(
    dirpath=f"checkpoints/set_01/kuku_01_variant_id:02d",
    monitor="val_acc",
    mode="max",
    filename="best-epoch:02d-val_acc:.4f"
)
trainer = pl.Trainer(
    max_epochs=20,
    accelerator="auto",
    callbacks=[checkpoint_callback, EarlyStopping(monitor="val_loss", patience=3)],
    log_every_n_steps=10
)
trainer.fit(model, train_loader, val_loader)
print(f"✅ Finished variant variant_id/15\n")

Before we dissect the "Kuku Model Set 01 15," it is essential to understand the manufacturer: PTL Models. ptl models kuku model set 01 15

PTL is a Japanese garage kit brand that operates on the fringes of the mainstream figure industry. Unlike mass-producers like Good Smile Company or Bandai, PTL creates small-batch, high-detail resin kits. These are not pre-painted action figures; they are unpainted, unassembled models that demand skill, patience, and an artistic eye.

The "Kuku" series—often stylized as Kuku or KuKu—is a line of original characters designed by a mysterious artist collective. The characters typically feature exaggerated proportions (large heads, slender limbs), intricate mechanical or organic appendages, and surreal storytelling cues. Each set is released in extremely limited quantities, often exclusively at events like Wonder Festival (Wonderfes) in Japan.

Date: April 24, 2026
Reading time: 8 minutes

If you’ve ever trained a deep learning model, you know the drill: three weeks later, you can’t remember which dropout rate gave you that stellar validation loss. You have notebooks named final_final_v3_actually_working.ipynb and a folder full of .ckpt files that might as well be ancient runes.

That’s why I built Kuku Model Set 01 15. VARIANT_MAP = 1: Kuku_01_01, 4: Kuku_01_04, 12: Kuku_01_12,

In this post, I’ll walk you through creating a systematic, versioned collection of PyTorch Lightning (PTL) models — specifically, 15 different architectural variants (Set 01, Variants 01 through 15) under the project name "Kuku." By the end, you’ll have a reproducible, scalable framework for managing deep learning experiments.

Here’s a sample of how we generate specific variants. Each file instantiates a unique architecture.

Variant 01 — Baseline:

# variants/kuku_01_01.py
from base.kuku_base_model import KukuBaseModel
import torch.nn as nn
class Kuku_01_01(KukuBaseModel):
def init(self, input_dim=784, num_classes=10):
super().init(input_dim, num_classes)
self.net = nn.Sequential(
nn.Linear(input_dim, 128),
nn.ReLU(),
nn.Linear(128, 64),
nn.ReLU(),
nn.Linear(64, num_classes)
)
def forward(self, x):
    x = x.view(x.size(0), -1)
    return self.net(x)

Variant 04 — LayerNorm + GELU:

class Kuku_01_04(KukuBaseModel):
    def __init__(self, input_dim=784, num_classes=10):
        super().__init__(input_dim, num_classes)
        self.net = nn.Sequential(
            nn.Linear(input_dim, 256),
            nn.GELU(),
            nn.LayerNorm(256),
            nn.Linear(256, 128),
            nn.GELU(),
            nn.Linear(128, num_classes)
        )

Variant 12 — Deep with Dropout (5 layers):

class Kuku_01_12(KukuBaseModel):
    def __init__(self, input_dim=784, num_classes=10, dropout=0.3):
        super().__init__(input_dim, num_classes)
        self.net = nn.Sequential(
            nn.Linear(input_dim, 512), nn.ReLU(), nn.Dropout(dropout),
            nn.Linear(512, 512), nn.ReLU(), nn.Dropout(dropout),
            nn.Linear(512, 256), nn.ReLU(),
            nn.Linear(256, 128), nn.ReLU(),
            nn.Linear(128, num_classes)
        )

Variants 02,03,05-11,13-15 follow similar patterns — mixing widths, depths, activations, and regularization.

from variants.kuku_01_01 import Kuku_01_01 def get_dataloaders(): transform = transforms