Datasets:

perrabyte
/

RION

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()

	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()