Biometric Palm Recognition Using Vision Transformers in Python

This blog explores palm recognition as a modern biometric authentication technique through the lens of computer vision. It begins with a conceptual overview of how palm images are analyzed using gradient-based, texture-based, and deep visual representations, establishing the theoretical foundations behind reliable palm-print recognition. The discussion then transitions toward practical relevance by preparing the reader for a hands-on extension, where these concepts are translated into a Python-based workflow using established feature descriptors and learning-based models. The aim is to bridge biometric theory and applied computer vision in a clear, implementation-ready manner.

Computer Vision–Based Palm Recognition

Palm recognition is a biometric identification approach that verifies individuals using the distinctive structural and textural patterns present on the human palm. These patterns include principal lines, wrinkles, ridge formations, and local texture variations distributed across the palm surface. Compared to fingerprints, palm-prints provide a broader biometric area and a richer combination of global and local features, enabling reliable recognition even when images are captured at moderate resolutions.

From a computer vision standpoint, palm recognition systems focus on extracting stable visual descriptors that represent both the shape and texture of the palm. The effectiveness of these systems arises from the complementary nature of palm features: large-scale line structures capture global geometry, while fine-grained textures encode local identity-specific information.

Role of Computer Vision in Palm Recognition

Computer vision enables automated interpretation of palm images by transforming raw pixel data into discriminative representations suitable for biometric analysis. In palm recognition, computer vision techniques are used to analyze spatial gradients, texture distributions, and hierarchical visual patterns that characterize individual palms.

Traditional feature-based approaches emphasize interpretable descriptors derived from image gradients and local texture patterns, while learning-based approaches leverage deep neural networks to capture higher-level abstractions. Together, these paradigms form the conceptual foundation for palm recognition systems that balance interpretability, accuracy, and scalability.

Image Acquisition and Preprocessing

Palm recognition pipelines begin with image acquisition using optical sensors or cameras capable of capturing sufficient detail from the palm surface. The captured images are then standardized through preprocessing to reduce variability and enhance salient visual structures.

Preprocessing is designed to support both handcrafted and learned feature extraction techniques by:

• Enhancing contrast between ridges, lines, and background regions

• Suppressing noise that may interfere with texture analysis

• Isolating the palm region to ensure consistent spatial focus

These steps prepare the visual data for robust gradient-based, texture-based, and deep feature analysis.

Deep Feature Learning with Vision Transformers

Vision Transformers represent a modern data-driven approach to palm recognition, where visual feature learning is guided by global context rather than localised operations. In this paradigm, palm images are treated as structured visual units whose relationships are learned through self-attention mechanisms. This enables holistic reasoning over the entire palm surface instead of restricting analysis to isolated regions.

Key characteristics of Vision Transformer–based feature learning include:

• Global context modeling across the full palm area

• Learning relationships between distant palm regions

• Unified representation of structure and texture

For palm recognition tasks, this global perspective is particularly valuable. Palm identity is defined not only by local texture cues but also by the spatial organization of features such as principal lines, ridge flow, and overall geometric layout. Self-attention allows the model to capture long-range dependencies between these features, producing spatially coherent representations that reflect the full structural identity of the palm.

Additional strengths of Vision Transformers in biometric feature learning include:

• Early incorporation of global spatial information

• Robustness to variations in illumination and hand positioning

• Consistent modeling of palm geometry across samples

Unlike approaches that prioritize hierarchical locality, Vision Transformers learn representations that encode holistic structure from the outset. This characteristic supports stable and discriminative feature embeddings, especially in biometric scenarios where identity cues are distributed across the entire palm surface rather than confined to specific regions.

By integrating global spatial relationships with fine-grained visual detail, Vision Transformers provide a strong representational foundation for palm recognition systems. Their ability to model both structural coherence and textural variation makes them well suited for biometric analysis tasks that require reliable, identity-preserving feature learning.

In the following section, these ideas are extended into a Python-based workflow that demonstrates how palm images can be processed and categorised using transformer based neural networks in practice.

Implementing Palm Recognition Using Vision Transformer in Python

This section focuses on applying a Vision Transformer–based approach for palm recognition. Building directly on the conceptual discussion of transformer-driven feature learning, it demonstrates how palm images can be represented and classified using global contextual relationships across the palm surface. The emphasis here is on translating learned visual representations into a functional classification workflow using Python, highlighting how Vision Transformers can be leveraged for biometric recognition.

1. Environment Setup

Before proceeding with the classification workflow, the required Python libraries are installed to support image processing, dataset access, and transformer-based vision models. These dependencies ensure a consistent and reproducible environment for the Vision Transformer–based palm recognition pipeline that follows.

!pip install scikit-image
!pip install datasets
!pip install transformers

2. Loading and Preparing Palm Image Data for Vision Transformer Classification

This stage focuses on setting up the core components required for Vision Transformer–based palm recognition and loading the biometric dataset into a usable format. The necessary libraries are imported to support transformer-based image classification, tensor operations, optimization, dataset handling, and evaluation. A publicly available palm and hand image dataset is then accessed directly from an online repository, allowing palm images and their corresponding class labels to be loaded programmatically. The images are converted into numerical arrays suitable for deep learning workflows, while labels are extracted to define the classification targets. This preparation step establishes a structured foundation for training and evaluating a Vision Transformer model on palm recognition tasks.

from transformers import AutoModelForImageClassification, ViTImageProcessor
from torch.optim import AdamW
import torchvision.transforms as transforms
import numpy as np
from torch.utils.data import Dataset, DataLoader
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report
from datasets import load_dataset
import torch.nn as nn
import torch

# Load dataset
dataset = load_dataset("ud-biometrics/open-palm-hand-images")
data = dataset["train"]
images = [np.array(sample["image"]) for sample in data]
labels = [sample["label"] for sample in data]
print(f"✓ Data loaded: {len(data)} samples")

Output:
✓ Data loaded: 50 samples

3. Preparing a Vision Transformer–Compatible Dataset and Data Loaders

This step structures the palm image data into a format suitable for Vision Transformer–based classification. A custom dataset abstraction is defined to pair palm images with their corresponding labels while allowing transformation logic to be applied dynamically during training and evaluation. To align the data with Vision Transformer expectations, a pretrained image processor is used to normalize and format images consistently, ensuring they match the model’s input representation. The dataset is then split into training and testing subsets to support supervised learning and performance evaluation. Finally, data loaders are created to efficiently batch and shuffle samples, enabling scalable and memory-efficient model training.

# Dataset class
class TheDataset(Dataset):
    def __init__(self, images, labels, transform=None):
        self.images = images
        self.labels = labels
        self.transform = transform

    def __len__(self):
        return len(self.labels)

    def __getitem__(self, idx):
        image = self.images[idx]
        label = self.labels[idx]
        if self.transform:
            image = self.transform(image)
        return image, label

# Prepare ViT processor and transform
model_identifier = "google/vit-base-patch16-224"
vit_processor = ViTImageProcessor.from_pretrained(model_identifier)

def vit_transform(image):
    pil_image = transforms.ToPILImage()(image)
    processed_image = vit_processor(images=pil_image, return_tensors="pt")
    return processed_image["pixel_values"].squeeze(0)

print("✓ Feature extraction configured")

# Train-test split
X_train_raw, X_test_raw, y_train_raw, y_test_raw = train_test_split(
    images, labels, test_size=0.1, random_state=42
)

train_vit_dataset = TheDataset(X_train_raw, y_train_raw, transform=vit_transform)
test_vit_dataset = TheDataset(X_test_raw, y_test_raw, transform=vit_transform)

batch_size = 32
train_vit_loader = DataLoader(train_vit_dataset, batch_size=batch_size, shuffle=True)
test_vit_loader = DataLoader(test_vit_dataset, batch_size=batch_size, shuffle=False)
print(f"✓ Data split: {len(train_vit_dataset)} train, {len(test_vit_dataset)} test")


Output:
✓ Feature extraction configured
✓ Data split: 45 train, 5 test

4. Configuring and Training a Vision Transformer for Palm Classification

This stage focuses on adapting a pretrained Vision Transformer to the palm recognition classification task and optimizing it through supervised learning. The model is initialized with pretrained visual representations and reconfigured to align with the number of palm identity classes present in the dataset. A task-specific classification head enables the transformer to map learned global features to class predictions. The training setup defines the loss function and optimization strategy required to guide learning, while device-aware execution ensures efficient computation across available hardware. During training, the model iteratively refines its internal representations by minimizing error across batches, progressively improving its ability to distinguish between different palm identities.

# Load and configure model
vit_model = AutoModelForImageClassification.from_pretrained(
    model_identifier,
    ignore_mismatched_sizes=True
)

num_labels = len(np.unique(labels))
num_ftrs_vit = vit_model.classifier.in_features
vit_model.classifier = nn.Linear(num_ftrs_vit, num_labels)
print(f"✓ Model defined: {num_labels} classes")

# Training setup
criterion_vit = nn.CrossEntropyLoss()
optimizer_vit = AdamW(vit_model.parameters(), lr=5e-5)
epochs_vit = 100

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
vit_model.to(device)

# Training loop
vit_model.train()
print("✓ Training started")

for epoch in range(epochs_vit):
    running_loss = 0.0
    for inputs, labels_batch in train_vit_loader:
        inputs = inputs.to(device)
        labels_batch = labels_batch.to(device)
        
        optimizer_vit.zero_grad()
        outputs = vit_model(inputs)
        loss = criterion_vit(outputs.logits, labels_batch)
        loss.backward()
        optimizer_vit.step()
        
        running_loss += loss.item()
    
    avg_epoch_loss = running_loss / len(train_vit_loader)
    print(f"Epoch [{epoch+1}/{epochs_vit}], Loss: {avg_epoch_loss:.4f}")

print("✓ Training completed")

Output:
✓ Model defined: 15 classes
✓ Training started
Epoch [1/100], Loss: 2.7081
Epoch [2/100], Loss: 1.7013
Epoch [3/100], Loss: 1.1918
Epoch [4/100], Loss: 0.8425
.
.
.
Epoch [98/100], Loss: 0.0017
Epoch [99/100], Loss: 0.0017
Epoch [100/100], Loss: 0.0016
✓ Training completed

5. Evaluating Vision Transformer Performance on Palm Recognition

This phase assesses how effectively the trained Vision Transformer generalizes to unseen palm images. The model is switched to evaluation mode to ensure stable inference behavior, and predictions are generated without updating learned parameters. By comparing predicted class labels against ground-truth identities, overall classification accuracy is computed to quantify recognition performance. In addition to accuracy, detailed classification metrics provide deeper insight into class-wise behavior, highlighting strengths and potential imbalance effects. This evaluation step validates the effectiveness of transformer-based feature learning for palm recognition and serves as a critical checkpoint for biometric reliability.

# Evaluation
vit_model.eval()
all_predictions_vit = []
all_true_labels_vit = []

with torch.no_grad():
    for inputs, labels_batch in test_vit_loader:
        inputs = inputs.to(device)
        labels_batch = labels_batch.to(device)
        
        outputs = vit_model(inputs)
        _, predicted = torch.max(outputs.logits.data, 1)
        
        all_predictions_vit.extend(predicted.cpu().numpy())
        all_true_labels_vit.extend(labels_batch.cpu().numpy())

all_predictions_vit = np.array(all_predictions_vit)
all_true_labels_vit = np.array(all_true_labels_vit)

accuracy_vit = (all_predictions_vit == all_true_labels_vit).sum() / len(all_true_labels_vit)
print(f"✓ Evaluation completed: Accuracy = {accuracy_vit:.4f}")
print("\nClassification Report:")
print(classification_report(all_true_labels_vit, all_predictions_vit, zero_division=0))

Output:
✓ Evaluation completed: Accuracy = 1.0000

Classification Report:
              precision    recall  f1-score   support

           0       1.00      1.00      1.00         1
           1       1.00      1.00      1.00         1
           3       1.00      1.00      1.00         1
           4       1.00      1.00      1.00         1
          12       1.00      1.00      1.00         1

    accuracy                           1.00         5
   macro avg       1.00      1.00      1.00         5
weighted avg       1.00      1.00      1.00         5

The evaluation results indicate perfect classification performance on the test subset, with the Vision Transformer correctly identifying all palm samples. An overall accuracy score of 1.0000 reflects complete agreement between predicted and true labels for the evaluated data. Precision, recall, and F1-scores of 1.00 across all classes confirm consistent and error-free predictions within this test set. However, these results should be interpreted in context, as the evaluation was conducted on a small number of test samples. While the outcome demonstrates the model’s capacity to learn highly discriminative palm representations, broader validation on larger and more diverse datasets would be necessary to assess generalization and real-world reliability.

Conclusion

Palm recognition represents a compelling biometric modality that combines rich structural information with practical, contactless acquisition. Throughout this blog, we examined how computer vision enables reliable palm recognition by transforming visual patterns into discriminative representations, moving from foundational concepts in feature analysis to modern deep representation learning. By aligning theoretical insights with a practical Vision Transformer–based workflow in Python, the discussion demonstrated how global context and structured visual relationships can be leveraged for accurate palm classification. Together, these perspectives highlight the maturity and potential of palm recognition systems, positioning them as a strong candidate for real-world biometric applications and future research in computer vision–driven identity recognition.