File size: 5,356 Bytes
b4b152a | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 | 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
# ---------- Ownership mapping for MNIST (28x28 -> 4 quadrants) ----------
# Each owner owns a 14x14 spatial quadrant.
# owner 0: top-left owner 1: top-right
# owner 2: bottom-left owner 3: bottom-right
owner_regions = {
0: (slice(0, 28), slice(0, 28)), # top-left
1: (slice(0, 28), slice(14, 28)), # top-right
2: (slice(0, 14), slice(0, 28)), # bottom-left
3: (slice(14, 28), slice(0, 28)), # bottom-right
}
# ---------- Ownership-Structured Conv2D Layer (fixed) ----------
class OwnerConv2DLinear(nn.Module):
def __init__(self, in_channels, out_features_per_owner, owner_regions, owner_weights=None):
super().__init__()
self.owner_regions = owner_regions # int -> (row_slice, col_slice)
self.num_owners = len(owner_regions)
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 # int -> weight
# Use string keys for ModuleDict
self.convs = nn.ModuleDict()
for o, (rs, cs) in owner_regions.items():
# Full-quadrant kernel: equivalent to Linear(14*14 -> out_per_owner)
conv = nn.Conv2d(in_channels, out_features_per_owner, kernel_size=(14, 14), bias=True)
nn.init.normal_(conv.weight, std=0.01)
nn.init.zeros_(conv.bias)
self.convs[str(o)] = conv
def forward(self, x):
outputs = []
for o, (rs, cs) in self.owner_regions.items():
x_o = x[:, :, rs, cs] # (batch, C, 14, 14)
out_o = self.convs[str(o)](x_o) # (batch, out_per_owner, 1, 1)
out_o = out_o.flatten(1) # (batch, out_per_owner)
outputs.append(out_o)
return torch.cat(outputs, dim=1)
def semantic_norm(self):
norm_sq = 0.0
for o_str, conv in self.convs.items():
o = int(o_str) # recover integer owner
norm_sq += self.owner_weights[o] * (conv.weight.norm('fro') ** 2)
return norm_sq
# ---------- Full Model (unchanged) ----------
class OwnershipMLP(nn.Module):
def __init__(self, hidden_per_owner=64, owner_weights=None):
super().__init__()
self.owner_conv = OwnerConv2DLinear(
in_channels=1,
out_features_per_owner=hidden_per_owner,
owner_regions=owner_regions,
owner_weights=owner_weights
)
self.fc_out = nn.Linear(self.owner_conv.total_out, 10)
def forward(self, x):
x = self.owner_conv(x)
x = F.relu(x)
x = self.fc_out(x)
return x
def semantic_norm_loss(self):
return self.owner_conv.semantic_norm()
# ---------- Training & Evaluation (unchanged) ----------
def train(model, device, train_loader, optimizer, epoch, lambda_norm=1e-4):
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)
ce_loss = F.cross_entropy(output, target)
norm_penalty = lambda_norm * model.semantic_norm_loss()
loss = ce_loss + norm_penalty
loss.backward()
optimizer.step()
if batch_idx % 100 == 0:
print(f'Train Epoch: {epoch} [{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()
test_loss = 0
correct = 0
with torch.no_grad():
for data, target in test_loader:
data, target = data.to(device), target.to(device)
output = model(data)
test_loss += F.cross_entropy(output, target, reduction='sum').item()
pred = output.argmax(dim=1, keepdim=True)
correct += pred.eq(target.view_as(pred)).sum().item()
test_loss /= len(test_loader.dataset)
accuracy = 100. * correct / len(test_loader.dataset)
print(f'\nTest set: Average loss: {test_loss:.4f}, Accuracy: {correct}/{len(test_loader.dataset)} ({accuracy:.2f}%)\n')
return accuracy
def main():
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"Using device: {device}")
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))
])
train_dataset = datasets.MNIST('./data', train=True, download=True, transform=transform)
test_dataset = datasets.MNIST('./data', train=False, transform=transform)
train_loader = DataLoader(train_dataset, batch_size=128, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=1000, shuffle=False)
model = OwnershipMLP(hidden_per_owner=64).to(device)
optimizer = optim.Adam(model.parameters(), lr=1e-3)
for epoch in range(1, 16):
train(model, device, train_loader, optimizer, epoch, lambda_norm=1e-4)
test(model, device, test_loader)
if __name__ == "__main__":
main()
|