Upload 3 files

app.py

@@ -0,0 +1,59 @@
+import streamlit as st
+import torch
+from PIL import Image
+import torchvision.transforms as transforms
+from model import SiameseNetwork  # Ensure this file exists with the model definition
+
+# Define the device (GPU or CPU)
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+# Load the pre-trained Siamese model
+model = SiameseNetwork().to(device)
+model.load_state_dict(torch.load("siamese_model.pth", map_location=device))
+model.eval()
+
+# Define data transformation (resize, convert to tensor, normalize if needed)
+transform = transforms.Compose([
+    transforms.Resize((100, 100)),  # Resize to match the input size of the model
+    transforms.Grayscale(num_output_channels=1),  # Convert images to grayscale for signature comparison
+    transforms.ToTensor(),  # Convert image to tensor
+])
+
+# Streamlit interface
+st.title("Signature Forgery Detection with Siamese Network")
+st.write("Upload two signature images to check if they are from the same person or if one is forged.")
+
+# Upload images
+image1 = st.file_uploader("Upload First Signature Image", type=["png", "jpg", "jpeg"])
+image2 = st.file_uploader("Upload Second Signature Image", type=["png", "jpg", "jpeg"])
+
+if image1 and image2:
+    # Load and transform the images
+    img1 = Image.open(image1).convert("RGB")
+    img2 = Image.open(image2).convert("RGB")
+
+    # Display images
+    col1, col2 = st.columns(2)
+    with col1:
+        st.image(img1, caption='First Signature Image', use_container_width=True)
+    with col2:
+        st.image(img2, caption='Second Signature Image', use_container_width=True)
+
+    # Transform the images before feeding them into the model
+    img1 = transform(img1).unsqueeze(0).to(device)
+    img2 = transform(img2).unsqueeze(0).to(device)
+
+    # Predict similarity using the Siamese model
+    output1, output2 = model(img1, img2)
+    euclidean_distance = torch.nn.functional.pairwise_distance(output1, output2)
+
+    # Set a threshold for similarity (can be tuned based on model performance)
+    threshold = 0.5  # You can adjust this threshold based on your model's performance
+
+    # Display similarity score and interpretation
+    st.success(f'Similarity Score (Euclidean Distance): {euclidean_distance.item():.4f}')
+    if euclidean_distance.item() < threshold:
+        st.write("The signatures are likely from the **same person**.")
+    else:
+        st.write("The signatures **do not match**, one might be **forged**.")
+

model.py

@@ -0,0 +1,56 @@
+import torch
+import torch.nn as nn
+
+class SiameseNetwork(nn.Module):
+    def __init__(self):
+        super(SiameseNetwork, self).__init__()
+
+        self.cnn1 = nn.Sequential(
+            nn.Conv2d(1, 96, kernel_size=11, stride=1),
+            nn.ReLU(inplace=True),
+            nn.LocalResponseNorm(5, alpha=0.0001, beta=0.75, k=2),
+            nn.MaxPool2d(3, stride=2),
+
+            nn.Conv2d(96, 256, kernel_size=5, stride=1, padding=2),
+            nn.ReLU(inplace=True),
+            nn.LocalResponseNorm(5, alpha=0.0001, beta=0.75, k=2),
+            nn.MaxPool2d(3, stride=2),
+            nn.Dropout2d(p=0.3),
+
+            nn.Conv2d(256, 384, kernel_size=3, stride=1, padding=1),
+            nn.ReLU(inplace=True),
+
+            nn.Conv2d(384, 256, kernel_size=3, stride=1, padding=1),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(3, stride=2),
+            nn.Dropout2d(p=0.3),
+        )
+
+        self.fc1 = nn.Sequential(
+            nn.Linear(25600, 1024),
+            nn.ReLU(inplace=True),
+            nn.Dropout2d(p=0.5),
+
+            nn.Linear(1024, 128),
+            nn.ReLU(inplace=True),
+
+            nn.Linear(128, 2)
+        )
+
+    def forward_once(self, x):
+        output = self.cnn1(x)
+        output = output.view(output.size()[0], -1)
+        output = self.fc1(output)
+        return output
+
+    def forward(self, input1, input2):
+        output1 = self.forward_once(input1)
+        output2 = self.forward_once(input2)
+        return output1, output2
+
+# Function to load the trained model
+def load_model(model_path):
+    model = SiameseNetwork()
+    model.load_state_dict(torch.load(model_path, map_location=torch.device('cpu')))
+    model.eval()
+    return model

siamese_model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a674d49cdc8ca78544b7f1dfe7caf50b63650657c4d9e07badf0db5b3a512c07
+size 114978840