Handwritten Signature Verification using Siamese Networks

Signatures remain the most widely used biometric on paper — bank cheques, legal documents and exam forms all depend on a human deciding whether two signatures match. That manual check is slow, inconsistent and easy to fool with a practiced forgery. Offline signature verification automates it: given a reference signature and a questioned one, the system outputs a similarity score and an accept/reject decision. This project implements that with a Siamese neural network — twin weight-shared CNNs that learn a 128-dimensional embedding where genuine pairs sit close together and forgeries sit far apart. Training uses the CEDAR dataset's genuine signatures and real skilled forgeries, and evaluation is writer-disjoint, so the model is tested on writers it has never seen. A pair-comparison web demo makes the whole pipeline tangible: pick two signatures, watch the preprocessing, and see the similarity score and decision update live.

This is a built-to-order software project: the training notebook, trained Siamese model, web demo and the complete viva kit (report, PPT, Q&A) are prepared fresh for you.

The Problem
Every bank branch, registrar office and university exam cell still verifies signatures by eye. A clerk compares the signature on a cheque or answer sheet against a specimen on file and makes a judgement call in seconds. The problem is threefold: humans are inconsistent (the same clerk decides differently when tired or rushed), unscalable (thousands of documents a day cannot each get careful attention), and vulnerable (a skilled forgery that copies the overall shape often passes a quick glance). Rule-based image comparison fails because no two genuine signatures are pixel-identical — natural variation in slant, size and stroke order defeats template matching. What is needed is a learned notion of "same writer": a model that tolerates natural variation while still catching imitations. Siamese networks solve exactly this by learning an embedding space from genuine/forgery pairs, and the CEDAR dataset provides the crucial ingredient — real skilled forgeries, not synthetic ones — so the model trains against the actual attack it must stop.

1. The CEDAR dataset's 2,640 signatures (55 writers, each with 24 genuine signatures and 24 skilled forgeries, scanned at 300 dpi grayscale) are split writer-disjoint: 40 writers for training, 15 held out for testing.
2. Every image passes through the same preprocessing: grayscale conversion, Otsu binarization, tight bounding-box crop around the ink, resize to 128×128 and normalization.
3. Training pairs are mined each epoch: genuine–genuine pairs labeled similar and genuine–forgery pairs labeled dissimilar, balanced within every batch.
4. The twin CNNs encode each image to a 128-dimensional embedding; contrastive loss with margin 1.0 pulls similar pairs together and pushes dissimilar pairs apart. Training runs for approximately 40 epochs (design target), keeping the checkpoint with the best validation EER.
5. On the 15 unseen writers, pair distances are scored across thresholds to plot FAR/FRR curves; the equal error rate is read off and the operating threshold is fixed at that point.
6. The exported model and threshold ship in the web demo: two signatures in, preprocessing, embeddings, cosine distance, similarity score and an accept/reject decision out.
7. The report documents the architecture, training curves, the FAR/FRR trade-off, ROC curve and a per-writer error breakdown for the viva.

Tech stack:

• Python 3, PyTorch
• OpenCV, scikit-image (preprocessing)
• NumPy, Matplotlib, scikit-learn (metrics)
• Jupyter Notebook (training & evaluation)
• CEDAR signature dataset (University at Buffalo)
• HTML5 + JavaScript (pair-comparison demo)
• Contrastive loss with cosine-distance scoring

Dataset & model details

• Dataset: CEDAR offline signature dataset — 55 writers, each contributing 24 genuine signatures and 24 skilled forgeries, for 1,320 genuine + 1,320 forgery images total; 300 dpi grayscale scans; released by the Center of Excellence for Document Analysis and Recognition (CEDAR), University at Buffalo. Classes are per-writer genuine vs forgery; the split is writer-disjoint (40 train / 15 test writers).
• Task: Offline (static-image) signature verification — a 1:1 matching problem. Input = a pair of 128×128 grayscale signature images (reference + questioned); output = a similarity score in [0, 1] and an accept/reject decision at the EER operating threshold.
• Model: Siamese CNN with twin weight-shared branches: four convolution–pooling blocks followed by dense layers producing a 128-dimensional L2-normalized embedding; trained with contrastive loss (margin 1.0); decision by cosine distance against the validation-tuned threshold.
• Metrics: Equal error rate (EER), false acceptance rate (FAR), false rejection rate (FRR), ROC-AUC on the 15 unseen writers. Design target: EER under 10% on unseen writers. No accuracy is claimed as measured until the training run is executed for the order; the report documents the actual achieved figures.

• [Siamese CNN architecture] Twin weight-shared convolutional branches encode each signature into a 128-dimensional L2-normalized embedding; the network is designed for this project with documented layer choices, not copied from a tutorial.
• [Contrastive-loss training] Genuine pairs are pulled together and genuine–forgery pairs pushed apart with a margin of 1.0, so the embedding space directly encodes writer similarity.
• [Writer-disjoint evaluation] 40 writers train the model and 15 completely unseen writers test it — the reported EER measures generalization to new people, which is the only honest way to evaluate verification.
• [Pair-comparison web demo] Select or upload a reference and a questioned signature; the app shows preprocessing stages, the similarity score, and the accept/reject decision at an adjustable threshold.
• [Threshold and error analysis] FAR/FRR curves across thresholds, the equal error rate operating point and an ROC curve, all generated for the report from the held-out writers.
• [Full preprocessing pipeline] Grayscale conversion, Otsu binarization, tight ink bounding-box crop and 128×128 normalization — identical at training and demo time, so there is no train/serve skew.
• [Complete training notebook] Dataset loading, pair mining, model definition, the training loop and evaluation in one reproducible Jupyter notebook with interpretation notes.

• Complete training & evaluation Jupyter notebook (pair mining, contrastive training, EER analysis)
• Trained Siamese model weights with the preprocessing pipeline
• Pair-comparison web demo with adjustable decision threshold
• FAR/FRR curves, ROC curve and per-writer error breakdown plots
• Project report PDF (background, Siamese theory, architecture rationale, methodology, results)
• PPT presentation for final review
• Viva Q&A preparation document (Siamese networks, contrastive loss, EER, writer-disjoint evaluation)