Upload 2 files

learning.py

@@ -0,0 +1,61 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+from wConv import wConv2d
+
+class SimpleModel(nn.Module):
+    def __init__(self, num_classes=10):
+        super(SimpleModel, self).__init__()     
+        #self.conv1 = nn.Conv2d(in_channels=1, out_channels=8, kernel_size=3, padding=1, bias=True) ##--> We have replaced this convolution
+        self.conv1 = wConv2d(in_channels=1, out_channels=8, kernel_size=3, den=[0.75], padding=1, bias=True) ##--> with this convolution
+        self.pool = nn.MaxPool2d(2, 2)
+        #self.conv2 = nn.Conv2d(in_channels=8, out_channels=16, kernel_size=5, padding=2, bias=True) ##--> We have replaced this convolution
+        self.conv2 = wConv2d(in_channels=8, out_channels=16, kernel_size=5, den=[0.25,0.75], padding=2, bias=True) ##--> with this convolution
+        
+        self.fc = nn.Linear(16 * 16 * 16, num_classes)  
+
+    def forward(self, x):
+        x = self.pool(F.relu(self.conv1(x))) 
+        x = self.pool(F.relu(self.conv2(x))) 
+        x = x.view(x.size(0), -1)             
+        x = self.fc(x)
+        return x
+
+
+model = SimpleModel(num_classes=10)
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+model.to(device)
+
+optimizer = optim.Adam(model.parameters(), lr=1e-3)
+criterion = nn.CrossEntropyLoss()
+
+num_samples = 100
+batch_size = 4
+num_batches = num_samples // batch_size
+
+inputs = torch.randn(num_samples, 1, 64, 64)
+targets = torch.randint(0, 10, (num_samples,))
+
+num_epochs = 5
+
+for epoch in range(num_epochs):
+    model.train()
+    running_loss = 0.0
+    
+    for i in range(num_batches):
+        batch_inputs = inputs[i*batch_size:(i+1)*batch_size].to(device)
+        batch_targets = targets[i*batch_size:(i+1)*batch_size].to(device)
+        
+        optimizer.zero_grad()
+        outputs = model(batch_inputs)
+        loss = criterion(outputs, batch_targets)
+        loss.backward()
+        optimizer.step()
+        
+        running_loss += loss.item()
+    
+    avg_loss = running_loss / num_batches
+    print(f"Epoch {epoch+1}/{num_epochs}, Loss: {avg_loss:.4f}")
+
+

wConv.py

@@ -0,0 +1,26 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+class wConv2d(nn.Module):
+    def __init__(self, in_channels, out_channels, kernel_size, den, stride=1, padding=1, groups=1, bias=False):
+        super(wConv2d, self).__init__()       
+        self.stride = stride
+        self.padding = padding
+        self.kernel_size = kernel_size
+        self.groups = groups         
+        self.weight = nn.Parameter(torch.empty(out_channels, in_channels // groups, kernel_size, kernel_size))
+        nn.init.kaiming_normal_(self.weight, mode='fan_out', nonlinearity='relu')        
+        self.bias = nn.Parameter(torch.zeros(out_channels)) if bias else None
+
+        device = torch.device('cpu')  
+        self.register_buffer('alfa', torch.cat([torch.tensor(den, device=device),torch.tensor([1.0], device=device),torch.flip(torch.tensor(den, device=device), dims=[0])]))
+        self.register_buffer('Phi', torch.outer(self.alfa, self.alfa))
+
+        if self.Phi.shape != (kernel_size, kernel_size):
+            raise ValueError(f"Phi shape {self.Phi.shape} must match kernel size ({kernel_size}, {kernel_size})")
+
+    def forward(self, x):
+        Phi = self.Phi.to(x.device)
+        weight_Phi = self.weight * Phi
+        return F.conv2d(x, weight_Phi, bias=self.bias, stride=self.stride, padding=self.padding, groups=self.groups)