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%) """