Publish Held-out digits for capsule robustness evaluation

README.md

@@ -0,0 +1,31 @@
+---
+title: Capsule Pocket
+emoji: 💊
+colorFrom: purple
+colorTo: yellow
+sdk: gradio
+sdk_version: "6.5.1"
+app_file: app.py
+pinned: false
+---
+
+# Capsule Pocket
+
+Capsule Pocket trains seven primary capsules and ten eight-dimensional digit
+capsules with three rounds of routing by agreement. An ordinary MLP with exactly
+the same 4,060 trainable parameters is the control.
+
+The benchmark separates clean accuracy from one-pixel translation and center
+occlusion robustness. The Space exposes the ten digit-capsule vector lengths for
+each transformed input.
+
+## Verified local result
+
+At exactly 4,060 parameters, capsules reached 97.04% clean accuracy versus 97.41%
+for the MLP. They improved one-pixel translation accuracy from 44.72% to 46.20%
+and center-occlusion accuracy from 79.63% to 82.22%.
+
+```bash
+uv run python projects/capsule-pocket/train.py
+uv run pytest tests/test_capsule_pocket.py
+```

source/app.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import gradio as gr
+import numpy as np
+import pandas as pd
+import plotly.graph_objects as go
+import torch
+from model import DynamicRoutingCapsuleNet, MatchedMLP
+from PIL import Image
+from safetensors.torch import load_file
+
+PROJECT_DIR = Path(__file__).resolve().parent
+ARTIFACT_DIR = PROJECT_DIR / "artifacts" / "capsule-pocket"
+FRAME = pd.read_parquet(PROJECT_DIR / "data" / "test.parquet")
+REPORT = json.loads((ARTIFACT_DIR / "evaluation.json").read_text(encoding="utf-8"))
+CAPSULE = DynamicRoutingCapsuleNet()
+CAPSULE.load_state_dict(load_file(ARTIFACT_DIR / "capsule.safetensors"))
+CAPSULE.eval()
+MLP = MatchedMLP()
+MLP.load_state_dict(load_file(ARTIFACT_DIR / "matched_mlp.safetensors"))
+MLP.eval()
+
+
+@torch.inference_mode()
+def inspect_capsules(
+    index: int,
+    vertical: int,
+    horizontal: int,
+    occlude: bool,
+) -> tuple[Image.Image, go.Figure, dict]:
+    row = FRAME.iloc[int(index) % len(FRAME)]
+    image = torch.from_numpy(np.asarray(row["image"], dtype=np.float32) / 16).reshape(
+        8, 8
+    )
+    image = torch.roll(image, (int(vertical), int(horizontal)), (0, 1))
+    if vertical > 0:
+        image[: int(vertical)] = 0
+    elif vertical < 0:
+        image[int(vertical) :] = 0
+    if horizontal > 0:
+        image[:, : int(horizontal)] = 0
+    elif horizontal < 0:
+        image[:, int(horizontal) :] = 0
+    if occlude:
+        image[3:5, 3:5] = 0
+    pixels = image.reshape(1, 64)
+    _, lengths = CAPSULE(pixels)
+    mlp_logits = MLP(pixels)
+    figure = go.Figure(go.Bar(x=list(range(10)), y=lengths[0].numpy()))
+    figure.update_layout(
+        template="plotly_dark",
+        title="Digit-capsule vector lengths",
+        xaxis_title="Class",
+        yaxis_title="Length",
+    )
+    rendered = Image.fromarray(
+        image.mul(255).to(torch.uint8).numpy(), mode="L"
+    ).resize((512, 512), Image.Resampling.NEAREST)
+    metrics = {
+        "true_label": int(row["label"]),
+        "capsule_prediction": int(lengths.argmax(1)),
+        "mlp_prediction": int(mlp_logits.argmax(1)),
+        "verified_capsule_translation_accuracy": REPORT["results"][
+            "dynamic_routing_capsule"
+        ]["one_pixel_translation"]["accuracy"],
+    }
+    return rendered, figure, metrics
+
+
+with gr.Blocks(title="Capsule Pocket") as demo:
+    gr.Markdown(
+        "# Capsule Pocket\n"
+        "Inspect dynamic-routing capsule lengths beside an exactly parameter-matched "
+        "MLP under translation and occlusion."
+    )
+    with gr.Row():
+        index = gr.Slider(0, len(FRAME) - 1, value=8, step=1, label="Test digit")
+        vertical = gr.Slider(-1, 1, value=0, step=1, label="Vertical shift")
+        horizontal = gr.Slider(-1, 1, value=0, step=1, label="Horizontal shift")
+        occlude = gr.Checkbox(False, label="Center occlusion")
+    initial = inspect_capsules(8, 0, 0, False)
+    with gr.Row():
+        image = gr.Image(value=initial[0], label="Input")
+        chart = gr.Plot(value=initial[1], label="Capsule lengths")
+    metrics = gr.JSON(value=initial[2], label="Matched prediction")
+    button = gr.Button("Route capsules", variant="primary")
+    button.click(
+        inspect_capsules,
+        inputs=[index, vertical, horizontal, occlude],
+        outputs=[image, chart, metrics],
+    )
+
+
+if __name__ == "__main__":
+    demo.launch()
+

source/model.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import torch
+from torch import nn
+
+
+def squash(vectors: torch.Tensor) -> torch.Tensor:
+    squared_norm = vectors.square().sum(dim=-1, keepdim=True)
+    scale = squared_norm / (1 + squared_norm)
+    return scale * vectors / torch.sqrt(squared_norm + 1e-8)
+
+
+class DynamicRoutingCapsuleNet(nn.Module):
+    def __init__(self, routing_iterations: int = 3) -> None:
+        super().__init__()
+        self.routing_iterations = routing_iterations
+        self.primary = nn.Linear(64, 28)
+        self.transforms = nn.Parameter(torch.randn(7, 10, 4, 8) * 0.08)
+
+    def forward(self, pixels: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
+        primary = squash(torch.tanh(self.primary(pixels)).reshape(-1, 7, 4))
+        votes = torch.einsum("bpd,pcde->bpce", primary, self.transforms)
+        routing_logits = torch.zeros(
+            len(pixels),
+            7,
+            10,
+            device=pixels.device,
+        )
+        digit_capsules = None
+        for iteration in range(self.routing_iterations):
+            coupling = torch.softmax(routing_logits, dim=2)
+            digit_capsules = squash((coupling[..., None] * votes).sum(dim=1))
+            if iteration + 1 < self.routing_iterations:
+                agreement = (votes * digit_capsules[:, None]).sum(dim=-1)
+                routing_logits = routing_logits + agreement
+        assert digit_capsules is not None
+        return digit_capsules, digit_capsules.norm(dim=-1)
+
+
+class MatchedMLP(nn.Module):
+    def __init__(self) -> None:
+        super().__init__()
+        self.network = nn.Sequential(
+            nn.Linear(64, 54),
+            nn.GELU(),
+            nn.Linear(54, 10),
+        )
+
+    def forward(self, pixels: torch.Tensor) -> torch.Tensor:
+        return self.network(pixels)
+
+
+def parameter_count(model: nn.Module) -> int:
+    return sum(parameter.numel() for parameter in model.parameters())
+

source/requirements.txt

@@ -0,0 +1,9 @@
+gradio>=5,<7
+numpy>=2,<3
+pandas>=2.3,<4
+pillow>=11,<13
+plotly>=6,<7
+pyarrow>=21,<24
+safetensors>=0.6,<1
+torch>=2.7,<3
+

source/train.py

@@ -0,0 +1,212 @@
+from __future__ import annotations
+
+import json
+import random
+import shutil
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import torch
+import trackio
+from model import DynamicRoutingCapsuleNet, MatchedMLP, parameter_count
+from safetensors.torch import save_file
+from torch.nn import functional as F
+from torch.utils.data import DataLoader, TensorDataset
+
+PROJECT_DIR = Path(__file__).resolve().parent
+ROOT_DIR = PROJECT_DIR.parents[1]
+VISION_DATA = ROOT_DIR / "projects" / "tiny-vision-foundry" / "data"
+ARTIFACT_DIR = PROJECT_DIR / "artifacts" / "capsule-pocket"
+DATA_DIR = PROJECT_DIR / "data"
+SEED = 2179
+
+
+def load_split(name: str, shuffle: bool) -> DataLoader:
+    frame = pd.read_parquet(VISION_DATA / f"{name}.parquet")
+    pixels = np.stack(frame["image"].to_numpy()).astype(np.float32) / 16
+    labels = frame["label"].to_numpy(dtype=np.int64, copy=True)
+    return DataLoader(
+        TensorDataset(torch.from_numpy(pixels), torch.from_numpy(labels)),
+        batch_size=128,
+        shuffle=shuffle,
+        generator=torch.Generator().manual_seed(SEED),
+    )
+
+
+def margin_loss(lengths: torch.Tensor, labels: torch.Tensor) -> torch.Tensor:
+    targets = F.one_hot(labels, 10).float()
+    positive = targets * F.relu(0.9 - lengths).square()
+    negative = 0.5 * (1 - targets) * F.relu(lengths - 0.1).square()
+    return (positive + negative).sum(dim=1).mean()
+
+
+def translate(pixels: torch.Tensor, vertical: int, horizontal: int) -> torch.Tensor:
+    images = pixels.reshape(-1, 8, 8)
+    shifted = torch.roll(images, shifts=(vertical, horizontal), dims=(1, 2))
+    if vertical > 0:
+        shifted[:, :vertical] = 0
+    elif vertical < 0:
+        shifted[:, vertical:] = 0
+    if horizontal > 0:
+        shifted[:, :, :horizontal] = 0
+    elif horizontal < 0:
+        shifted[:, :, horizontal:] = 0
+    return shifted.reshape(-1, 64)
+
+
+@torch.inference_mode()
+def evaluate(
+    model: torch.nn.Module,
+    loader: DataLoader,
+    *,
+    capsule: bool,
+    corruption: str,
+) -> dict:
+    model.eval()
+    correct = 0
+    total = 0
+    for pixels, labels in loader:
+        if corruption == "translation":
+            variants = [
+                translate(pixels, 1, 0),
+                translate(pixels, -1, 0),
+                translate(pixels, 0, 1),
+                translate(pixels, 0, -1),
+            ]
+            pixels = torch.cat(variants)
+            labels = labels.repeat(4)
+        elif corruption == "occlusion":
+            images = pixels.reshape(-1, 8, 8).clone()
+            images[:, 3:5, 3:5] = 0
+            pixels = images.reshape(-1, 64)
+        scores = model(pixels)[1] if capsule else model(pixels)
+        correct += int((scores.argmax(1) == labels).sum())
+        total += len(labels)
+    return {"accuracy": correct / total, "examples": total}
+
+
+def train_variant(
+    model: torch.nn.Module,
+    train_loader: DataLoader,
+    validation_loader: DataLoader,
+    *,
+    capsule: bool,
+) -> tuple[dict[str, torch.Tensor], int]:
+    optimizer = torch.optim.AdamW(model.parameters(), lr=2e-3, weight_decay=1e-4)
+    best = -1.0
+    best_epoch = 0
+    best_state = None
+    for epoch in range(1, 121):
+        model.train()
+        for pixels, labels in train_loader:
+            if capsule:
+                _, lengths = model(pixels)
+                loss = margin_loss(lengths, labels)
+            else:
+                loss = F.cross_entropy(model(pixels), labels)
+            optimizer.zero_grad(set_to_none=True)
+            loss.backward()
+            optimizer.step()
+        validation = evaluate(
+            model,
+            validation_loader,
+            capsule=capsule,
+            corruption="clean",
+        )
+        if validation["accuracy"] > best:
+            best = validation["accuracy"]
+            best_epoch = epoch
+            best_state = {
+                name: value.detach().cpu().clone()
+                for name, value in model.state_dict().items()
+            }
+        if epoch == 1 or epoch % 10 == 0:
+            trackio.log(
+                {
+                    "variant": "capsule" if capsule else "mlp",
+                    "epoch": epoch,
+                    "validation_accuracy": validation["accuracy"],
+                }
+            )
+    assert best_state is not None
+    return best_state, best_epoch
+
+
+def main() -> None:
+    random.seed(SEED)
+    np.random.seed(SEED)
+    torch.manual_seed(SEED)
+    torch.set_num_threads(1)
+    train_loader = load_split("train", True)
+    validation_loader = load_split("validation", False)
+    test_loader = load_split("test", False)
+    capsule = DynamicRoutingCapsuleNet()
+    mlp = MatchedMLP()
+    assert parameter_count(capsule) == parameter_count(mlp) == 4_060
+    trackio.init(
+        project="capsule-pocket",
+        name="dynamic-routing-digits-v1",
+        config={
+            "parameters_per_model": 4_060,
+            "routing_iterations": capsule.routing_iterations,
+            "training_epochs": 120,
+        },
+    )
+    capsule_state, capsule_epoch = train_variant(
+        capsule, train_loader, validation_loader, capsule=True
+    )
+    mlp_state, mlp_epoch = train_variant(
+        mlp, train_loader, validation_loader, capsule=False
+    )
+    capsule.load_state_dict(capsule_state)
+    mlp.load_state_dict(mlp_state)
+    results = {}
+    for name, model, is_capsule, epoch in [
+        ("dynamic_routing_capsule", capsule, True, capsule_epoch),
+        ("matched_mlp", mlp, False, mlp_epoch),
+    ]:
+        results[name] = {
+            "parameters": parameter_count(model),
+            "best_epoch": epoch,
+            "clean": evaluate(model, test_loader, capsule=is_capsule, corruption="clean"),
+            "one_pixel_translation": evaluate(
+                model, test_loader, capsule=is_capsule, corruption="translation"
+            ),
+            "center_occlusion": evaluate(
+                model, test_loader, capsule=is_capsule, corruption="occlusion"
+            ),
+        }
+    report = {
+        "experiment": "Dynamic-routing capsule network versus matched MLP",
+        "results": results,
+    }
+    ARTIFACT_DIR.mkdir(parents=True, exist_ok=True)
+    DATA_DIR.mkdir(parents=True, exist_ok=True)
+    save_file(capsule.state_dict(), ARTIFACT_DIR / "capsule.safetensors")
+    save_file(mlp.state_dict(), ARTIFACT_DIR / "matched_mlp.safetensors")
+    (ARTIFACT_DIR / "evaluation.json").write_text(
+        json.dumps(report, indent=2), encoding="utf-8"
+    )
+    shutil.copy2(VISION_DATA / "test.parquet", DATA_DIR / "test.parquet")
+    trackio.log(
+        {
+            "capsule_clean_accuracy": results["dynamic_routing_capsule"]["clean"][
+                "accuracy"
+            ],
+            "capsule_translation_accuracy": results["dynamic_routing_capsule"][
+                "one_pixel_translation"
+            ]["accuracy"],
+            "mlp_clean_accuracy": results["matched_mlp"]["clean"]["accuracy"],
+            "mlp_translation_accuracy": results["matched_mlp"][
+                "one_pixel_translation"
+            ]["accuracy"],
+        }
+    )
+    trackio.finish()
+    print(json.dumps(report, indent=2))
+
+
+if __name__ == "__main__":
+    main()
+

test.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:da32d63eead51a422f2a4584a823d9bb3c7e9e492de17a1a0c048ef0e2490bd1
+size 140968