Create app.py

app.py

@@ -0,0 +1,67 @@
+# Cell 3: Twin CNN Architecture and Contrastive Loss
+import torch.nn as nn
+import torch.nn.functional as F
+
+class SigNetTwinEncoder(nn.Module):
+    def __init__(self):
+        super(SigNetTwinEncoder, self).__init__()
+
+        self.conv = nn.Sequential(
+            # Input: (1, 220, 155)
+            nn.Conv2d(1, 32, kernel_size=5, stride=1, padding=2),
+            nn.BatchNorm2d(32),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(2, 2),  # -> (32, 110, 77)
+
+            nn.Conv2d(32, 64, kernel_size=5, stride=1, padding=2),
+            nn.BatchNorm2d(64),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(2, 2),  # -> (64, 55, 38)
+
+            nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1),
+            nn.BatchNorm2d(128),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(2, 2)   # -> (128, 27, 19)
+        )
+
+        # Flattened feature map: 128 * 27 * 19 = 65,664
+        self.fc = nn.Sequential(
+            nn.Linear(128 * 27 * 19, 256),
+            nn.ReLU(inplace=True),
+            nn.Dropout(0.3),
+            nn.Linear(256, 128)  # 128-dimensional embedding
+        )
+
+    def forward_once(self, x):
+        features = self.conv(x)
+        features = features.view(features.size(0), -1)
+        embeddings = self.fc(features)
+        # L2-normalization on unit hypersphere
+        embeddings = F.normalize(embeddings, p=2, dim=1)
+        return embeddings
+
+    def forward(self, input1, input2):
+        out1 = self.forward_once(input1)
+        out2 = self.forward_once(input2)
+        return out1, out2
+
+class ContrastiveLoss(nn.Module):
+    def __init__(self, margin=1.0):
+        super(ContrastiveLoss, self).__init__()
+        self.margin = margin
+
+    def forward(self, out1, out2, label):
+        # Euclidean distance
+        euclidean_distance = F.pairwise_distance(out1, out2)
+        # label=1 (genuine): minimize distance^2
+        # label=0 (forged): push distance beyond margin
+        loss_contrastive = torch.mean(
+            label * torch.pow(euclidean_distance, 2) +
+            (1.0 - label) * torch.pow(torch.clamp(self.margin - euclidean_distance, min=0.0), 2)
+        )
+        return loss_contrastive
+
+# Verify parameter count
+model_check = SigNetTwinEncoder()
+param_count = sum(p.numel() for p in model_check.parameters() if p.requires_grad)
+print(f"Total Trainable Parameters: {param_count:,} (~{param_count / 1e6:.2f}M)")