ref01.py

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms

# =====================================================================
# 1. Ownership mappings
# =====================================================================

def quadrant_owner(row, col):
    """4 coarse owners: the four 14x14 quadrants."""
    return (0 if row < 14 else 2) + (0 if col < 14 else 1)

def sub_quadrant_owner(row, col):
    """16 fine owners: each quadrant split into 4 sub-quadrants."""
    q = quadrant_owner(row, col)
    r, c = row % 14, col % 14
    sub = (0 if r < 7 else 2) + (0 if c < 7 else 1)
    return q * 4 + sub

def build_owner_indices(owner_fn, num_owners):
    owner_indices = {o: [] for o in range(num_owners)}
    for idx in range(784):
        owner_indices[owner_fn(idx // 28, idx % 28)].append(idx)
    return {o: torch.tensor(sorted(v), dtype=torch.long)
            for o, v in owner_indices.items()}

owner_indices_4  = build_owner_indices(quadrant_owner,     4)   # coarse
owner_indices_16 = build_owner_indices(sub_quadrant_owner, 16)  # fine

# =====================================================================
# 2. Ownership-Structured Linear Layer (encoder)
# =====================================================================

class OwnerLinear(nn.Module):
    def __init__(self, in_features, out_features_per_owner, owner_indices,
                 owner_weights=None):
        super().__init__()
        self.owner_indices = owner_indices
        self.num_owners = len(owner_indices)
        self.out_per_owner = out_features_per_owner
        self.total_out = self.num_owners * out_features_per_owner

        if owner_weights is None:
            owner_weights = {o: 1.0 for o in range(self.num_owners)}
        self.owner_weights = owner_weights

        self.weights = nn.ParameterDict()
        self.biases = nn.ParameterDict()
        for o, indices in owner_indices.items():
            in_dim = len(indices)
            self.weights[str(o)] = nn.Parameter(
                torch.randn(out_features_per_owner, in_dim) * 0.01)
            self.biases[str(o)] = nn.Parameter(
                torch.zeros(out_features_per_owner))

    def forward(self, x):
        outputs = []
        for o, indices in self.owner_indices.items():
            x_o = x[:, indices]
            out_o = F.linear(x_o, self.weights[str(o)], self.biases[str(o)])
            outputs.append(out_o)
        return torch.cat(outputs, dim=1)

    def semantic_norm(self):
        norm_sq = 0.0
        for o_str, w_param in self.weights.items():
            o = int(o_str)
            norm_sq += self.owner_weights[o] * (w_param.norm('fro') ** 2)
        return norm_sq

# =====================================================================
# 3. Owner-structured BatchNorm (governance, T7)
# =====================================================================

class OwnerBatchNorm1d(nn.Module):
    def __init__(self, num_owners, per_owner):
        super().__init__()
        self.num_owners = num_owners
        self.per_owner = per_owner
        self.bns = nn.ModuleDict({str(o): nn.BatchNorm1d(per_owner)
                                  for o in range(num_owners)})

    def forward(self, x):
        return torch.cat([
            self.bns[str(o)](x[:, o * self.per_owner:(o + 1) * self.per_owner])
            for o in range(self.num_owners)
        ], dim=1)

# =====================================================================
# 4. Cross-Owner Lifting layer (T5/T6): recover correction terms C_{o,o'}
# =====================================================================

class CrossOwnerLinear(nn.Module):
    def __init__(self, num_owners, in_per_owner, out_per_owner):
        super().__init__()
        self.num_owners = num_owners
        self.in_per_owner = in_per_owner
        self.out_per_owner = out_per_owner

        self.W = nn.ParameterDict({
            f"{o}_{o2}": nn.Parameter(torch.randn(out_per_owner, in_per_owner) * 0.01)
            for o in range(num_owners) for o2 in range(num_owners)
        })
        self.b = nn.ParameterDict({str(o): nn.Parameter(torch.zeros(out_per_owner))
                                   for o in range(num_owners)})
        self.admit = nn.Parameter(
            torch.eye(num_owners) * 1.0 + torch.randn(num_owners, num_owners) * 0.02)

    def forward(self, x):
        xs = x.view(x.size(0), self.num_owners, self.in_per_owner)
        outs = []
        for o in range(self.num_owners):
            acc = self.b[str(o)]
            for o2 in range(self.num_owners):
                acc = acc + self.admit[o, o2] * (xs[:, o2] @ self.W[f"{o}_{o2}"].T)
            outs.append(acc)
        return torch.cat(outs, dim=1)

# =====================================================================
# 5. Ownership-structured Decoder: hidden -> 784 reference image
# =====================================================================

class OwnerOutputLinear(nn.Module):
    """Maps hidden (B, hidden_dim) back to a 784-dim image.
       Each owner's pixels are generated independently:
       pixels_o = W_o @ h + b_o, scattered to their original positions."""
    def __init__(self, owner_indices, hidden_dim):
        super().__init__()
        self.owner_indices = owner_indices
        self.num_owners = len(owner_indices)
        self.hidden_dim = hidden_dim

        self.weights = nn.ParameterDict()
        self.biases = nn.ParameterDict()
        for o, indices in owner_indices.items():
            out_dim = len(indices)
            self.weights[str(o)] = nn.Parameter(torch.randn(out_dim, hidden_dim) * 0.01)
            self.biases[str(o)] = nn.Parameter(torch.zeros(out_dim))

    def forward(self, h):
        out = torch.zeros(h.size(0), 784, device=h.device, dtype=h.dtype)
        for o, indices in self.owner_indices.items():
            block = F.linear(h, self.weights[str(o)], self.biases[str(o)])  # (B, |o|)
            out[:, indices] = block
        return out

# =====================================================================
# 6. Reference-Ownership Model: output = reference image per class
# =====================================================================

class ReferenceOwnershipMLP(nn.Module):
    def __init__(self, per_owner=64, num_classes=10, seed=0):
        super().__init__()
        self.num_classes = num_classes

        # Encoder
        self.local = OwnerLinear(784, per_owner, owner_indices_16)   # 16*64 = 1024
        self.bn1 = OwnerBatchNorm1d(16, per_owner)
        self.cross = CrossOwnerLinear(16, per_owner, per_owner)
        self.bn2 = OwnerBatchNorm1d(16, per_owner)
        self.coarse = nn.Linear(16 * per_owner, 4 * per_owner)       # 256

        # Decoder (ownership-structured) -> 784
        self.decode = OwnerOutputLinear(owner_indices_4, 4 * per_owner)

        # Fixed reference images: one per class (X_[y_true] is the target)
        g = torch.Generator().manual_seed(seed)
        self.register_buffer('X_ref', torch.randn(num_classes, 784, generator=g))

    def forward(self, x):
        x = x.view(x.size(0), -1)
        h = F.relu(self.bn1(self.local(x)))
        h = F.relu(self.bn2(self.cross(h)))
        h = F.relu(self.coarse(h))
        return self.decode(h)                       # (B, 784)

    def classify(self, output):
        """Nearest reference image: cosine similarity (robust to scale)."""
        sim = F.cosine_similarity(output.unsqueeze(1), self.X_ref.unsqueeze(0), dim=2)
        return sim.argmax(dim=1)

    def governed_norm_loss(self):
        loss = 0.0
        for o_str, w in self.local.weights.items():
            g = w.grad.norm() if w.grad is not None else 0.0
            decay = 1.0 / (1.0 + g)
            loss = loss + decay * (w.norm('fro') ** 2)
        return loss

# =====================================================================
# 7. Training & Evaluation
# =====================================================================

def train(model, device, train_loader, optimizer, epoch, lambda_norm=1e-5):
    model.train()
    for batch_idx, (data, target) in enumerate(train_loader):
        data, target = data.to(device), target.to(device)
        optimizer.zero_grad()
        output = model(data)                       # (B, 784)
        target_img = model.X_ref[target]           # (B, 784) reference image
        mse = F.mse_loss(output, target_img)
        norm_penalty = lambda_norm * model.governed_norm_loss()
        loss = mse + norm_penalty
        loss.backward()
        optimizer.step()
        if batch_idx % 100 == 0:
            print(f'Train Epoch: {epoch} '
                  f'[{batch_idx * len(data)}/{len(train_loader.dataset)} '
                  f'({100. * batch_idx / len(train_loader):.0f}%)]\tLoss: {loss.item():.6f}')

def test(model, device, test_loader):
    model.eval()
    correct = 0
    total = 0
    per_class_correct = [0] * model.num_classes
    per_class_total = [0] * model.num_classes
    with torch.no_grad():
        for data, target in test_loader:
            data, target = data.to(device), target.to(device)
            output = model(data)                   # (B, 784)
            pred = model.classify(output)          # nearest reference
            correct += pred.eq(target).sum().item()
            total += target.size(0)
            for c in range(model.num_classes):
                mask = (target == c)
                per_class_correct[c] += (pred[mask] == c).sum().item()
                per_class_total[c] += mask.sum().item()
    accuracy = 100. * correct / total
    print(f'\nTest set: Accuracy: {correct}/{total} ({accuracy:.2f}%)\n')
    print('Per-class accuracy:')
    for c in range(model.num_classes):
        acc = 100. * per_class_correct[c] / max(per_class_total[c], 1)
        print(f'  class {c}: {per_class_correct[c]}/{per_class_total[c]} ({acc:.2f}%)')
    return accuracy

def main():
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    print(f"Using device: {device}")

    train_transform = transforms.Compose([
        transforms.RandomAffine(degrees=8, translate=(0.08, 0.08),
                                scale=(0.95, 1.05)),
        transforms.ToTensor(),
        transforms.Normalize((0.1307,), (0.3081,)),
    ])
    test_transform = transforms.Compose([
        transforms.ToTensor(),
        transforms.Normalize((0.1307,), (0.3081,)),
    ])

    train_dataset = datasets.MNIST('./data', train=True, download=True,
                                   transform=train_transform)
    test_dataset = datasets.MNIST('./data', train=False, transform=test_transform)
    train_loader = DataLoader(train_dataset, batch_size=128, shuffle=True)
    test_loader = DataLoader(test_dataset, batch_size=1000, shuffle=False)

    model = ReferenceOwnershipMLP(per_owner=64, num_classes=10).to(device)
    optimizer = optim.AdamW(model.parameters(), lr=1e-3)
    scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=40)

    best = 0.0
    for epoch in range(1, 41):
        train(model, device, train_loader, optimizer, epoch, lambda_norm=1e-5)
        acc = test(model, device, test_loader)
        scheduler.step()
        best = max(best, acc)
    print(f'Best test accuracy: {best:.2f}%')

if __name__ == "__main__":
    main()

"""
Train Epoch: 31 [0/60000 (0%)]	Loss: 0.012478
Train Epoch: 31 [12800/60000 (21%)]	Loss: 0.018200
Train Epoch: 31 [25600/60000 (43%)]	Loss: 0.011889
Train Epoch: 31 [38400/60000 (64%)]	Loss: 0.008812
Train Epoch: 31 [51200/60000 (85%)]	Loss: 0.011580

Test set: Accuracy: 9952/10000 (99.52%)

Per-class accuracy:
  class 0: 979/980 (99.90%)
  class 1: 1132/1135 (99.74%)
  class 2: 1027/1032 (99.52%)
  class 3: 1007/1010 (99.70%)
  class 4: 978/982 (99.59%)
  class 5: 885/892 (99.22%)
  class 6: 953/958 (99.48%)
  class 7: 1024/1028 (99.61%)
  class 8: 967/974 (99.28%)
  class 9: 1000/1009 (99.11%)
"""