Traditional methods rely heavily on manually extracted features, such as minutia and core points. However, in real-world applications, fingerprint data is often affected by factors such as sensor quality, acquisition conditions, and the condition of the finger, leading to inconsistent or partially missing data. These inconsistencies can make traditional feature extraction methods less effective. In contrast, deep learning methods are more capable of handling such complex data and can maintain high accuracy even in practical application scenarios.

Siamese networks have also been effectively employed in fingerprint recognition. Liu et al. [11] designed an embedded image processing algorithm based on a Siamese network to enable fingerprint recognition from any source without requiring a pre-built database. Zhu et al. [12] further compared the impact of different network structures on fingerprint recognition accuracy using three distinct Siamese networks.

Subsequently, techniques for fingerprint recognition have significantly improved through novel feature extraction and model structure optimization methods. Öztürk et al. [13] proposed a novel local descriptor generation model that generates embedding vectors for a fixed-size patch extracted around a minutia, using a local similarity assignment algorithm to produce a global similarity match score. Saeed et al. [14] aimed to determine the architecture of CNN models automatically adapted to fingerprint classification using FKT and the ratio of the traces of the between-class scatter matrix and the within-class scatter matrix to determine the number of layers and filters automatically. Zhang et al. [15] enhanced partial fingerprint recognition through occlusion-enhanced data augmentation and occlusion-aware modeling.

Moreover, attention mechanisms are widely employed in fingerprint recognition. Chen et al. [16] proposed a novel single-to-multiparty fingerprint recognition method based on the attention mechanism to solve the local fingerprint matching problem by adaptively extracting and fusing the features of a set of fingerprints. Grosz et al. [17] combined a conventional convolutional neural network (CNN) and a visual transformer (ViT) based on an attention mechanism to refine the global embedding representation by accurately comparing local features in two fingerprint images. Building on this, LFR-Net [18] introduces local enhancement and segmentation techniques to improve the quality of fingerprint images, a fusion of local features and global embeddings, and the introduction of a multi-stage matching process to improve the processing speed of latent fingerprint matching. Qiu et al. [19] first utilized ViT with a global attention mechanism to generate dense pixel-level correspondences of feature points on a given fingerprint pair.

However, the need for extensive training data and concerns over user privacy often limit the ability to adequately train and improve deep learning-based models. To address this issue, federated learning enables distributed model training without compromising data security.

Constructing training datasets for biometric models in deep learning typically requires a large volume of private data. Federated Learning (FL), introduced by Google in 2016 [20], enables decentralized private data while maintaining privacy through the FedAvg method. Similar optimization challenges arise in cloud and IoT environments, particularly when handling large-scale, decentralized data [21]. Addressing statistical heterogeneity, FedCG [22] utilizes clustering and Graph Convolutional Networks (GCNs) for domain knowledge sharing and employs unsupervised teacher-student training for model adaptation. Similarly, FedSM [23] combats client drift in medical image segmentation by creating personalized models and introducing a novel model selector for effective test data alignment. FedDG [24] enhances fairness and generalization by dynamically adjusting aggregation weights through Generalization Adjustment. FedALA [25] improves personalization by adaptively aggregating global and local models, while FedPGP [26] balances personalization and generalization in federated prompt learning by combining CLIP generalization and low-rank personalization. Such methodologies are particularly valuable when integrated with federated learning to enhance the robustness and privacy of the distributed learning framework.

Face Recognition. Aggarwal et al. [1] used FL to train face recognition models collaboratively. Each client uploads the embedding layer vectors corresponding to its identity, while the server employs the Spreadout regularization technique to enhance the model’s generalization ability and robustness. Liu et al. [2] introduced a decoupled feature customization module (DFC) to better adapt a pre-trained face model to the individual needs of specific clients. In further research, Meng et al. [3] employed a differential privacy-based local clustering algorithm (DPLC) to achieve a uniform distribution of the global feature space through Consensus-Aware Face Recognition Loss, thus enhancing the model’s recognition capability while protecting privacy. Niu et al. [27] improved the discriminative power of cross-client class embeddings by introducing a softmax-based regularizer to correct the gradient of the class embeddings via the FedGC method. Deepfake detection techniques have also been explored to ensure the authenticity of facial data and prevent misuse in federated learning systems [28]. The FedForgery framework proposed by Liu et al. [29] combines federated and residual learning to learn robust discriminative residual feature mappings via the Variable Autoencoder (VAE) for detecting facial forgery.

Palmprint Recognition. Shao et al. [30] introduced FL into palmprint recognition using a public dataset, which differs from private data and may raise privacy concerns. FedML [31] detected facial forgeries by introducing Federated Metric Learning and constructing instance-level and relational-level communication loss, achieving improved palmprint recognition accuracy without sharing private data. Yang et al. [32] utilized different wavelength spectra’s physical properties to verify cross-spectrum palmprint.

Finger Vein Recognition. Lian et al. [4] proposed the FedFV framework, which addresses the heterogeneity problem of non-IID data through a personalized aggregation algorithm. Further, PAFedFV [5] designed a more complex personalized model aggregation method and employed a synchronized training module to utilize waiting time fully.

In our study, we introduce federated learning to fingerprint recognition, accounting for fingerprint heterogeneity, and adopt a generalized tuning strategy to enhance the model’s performance.

Fingerprint verification systems use embedded classifiers to transform fingerprint images into discriminative feature vectors by mapping them into a multi-dimensional Euclidean space. A data sampler generates a pair of fingerprint images (x1,x2) and a label y, where x1 is the query image and x2 is the reference image with a known identity. The feature extractor fθ maps each image to a d-dimensional feature space and extracts features as fθ(x)∈Rd.

The training process involves optimizing the model parameters to minimize the loss function L: (1)L(x1,x2,y)=y⋅d(fθ(x1),fθ(x2))2+(1−y)⋅max(0,m−d(fθ(x1),fθ(x2)))2

In Eq. (1), y=1 if x1 and x2 belong to the same identity, and y=0 otherwise. The distance function d(⋅) measures the Euclidean distance between the feature vectors, and m represents the margin. This adjustable hyperparameter specifies the minimum distance between pairs of different identities.

In the evaluation phase, the system generates feature vectors and calculates distances between test pairs to verify identity matches. As shown in Fig. 2, according to the mapped features fx1 and fx2, the model determines whether the two fingerprints belong to the same identity by calculating the feature similarity of the pair of fingerprint images. We get the matching result y by:(2)y(x1,x2)={1,if∥fx1−fx2∥2≤m0,otherwise

In addition, deep learning models require a large amount of data for training. In traditional centralized learning methods, fingerprint data must be stored centrally on a server, which poses significant privacy risks due to the sensitive nature of such data. To address this issue, we adopt a FL approach. In this approach, user data remains on local devices; all model training is conducted locally, and only the resulting model parameters are uploaded to the central server. The server then aggregates these parameters to update the global model, which is redistributed to the clients. In this way, we use the distributed data for model training while avoiding the centralized storage and transmission of sensitive data, thus achieving reliable fingerprinting while preserving privacy. The global model θg is created by aggregating local client models, using a weighting mechanism based on the volume of data each client contributes: (3)minθgε(θg)=∑i=1Cαiε𝒟i(θi),αi=Ni∑j=1CNj

In Eq. (3), ε𝒟i(θi)=1Ni∑j=1NiL(θi;aji,bji,yji) represents the prediction loss of the model θi on client i’s dataset 𝒟i. Here, Ni denotes the number of sample pairs (both positive and negative) on client i, and C represents the totalnumber of clients in the federated framework.

In the context of fingerprint recognition within FL, given the significant differences and heterogeneity in fingerprint information across various countries and regions, as shown in Table 1, the distribution of fingerprint patterns (circular, spiral, and arched) varies among individuals of different ethnicities and geographical locations, influenced by genetic, environmental, and developmental factors.

In fingerprint recognition scenarios, the significant diversity of fingerprint data from different regions and countries leads to differences in data distributions between clients and local models. The training process tends to overfit specific clients’ data, potentially diminishing the generalization performance of the global model. To address this, we use a data domain generalization global model aggregation strategy to improve the model’s ability to generalize across diverse datasets. By adjusting the global model weights during aggregation, we aim to minimize the variance in generalization gaps, enhancing the model’s robustness.

In each round of global model updates, the server distributes the current global model parameters θg to all clients. After receiving the global model parameters, each client trains the local model based on its local dataset 𝒟i and obtains the updated local model parameters θi. To evaluate the performance difference between the global model and local models, we first calculate the global model’s accuracy (correct matching rate) and loss on each client’s local dataset 𝒟i¯. Then, each client sends these local model parameters back to the server, and the server aggregates these updates according to the client’s weight αi to obtain the updated global model for the next round.

Our primary optimization objective is to minimize the total loss function across all clients, according to Eq. (3), the optimization objective can be further described as: (4)minθg,α1,α2,…,αC⁡ε(θg)=α1ε𝒟1¯(θ1)+α2ε𝒟2¯(θ2)+…+αCε𝒟C¯(θC)

However, minimizing the loss alone does not guarantee that the global model will generalize well on the data of each client. To evaluate the generalization performance of the global model on different clients, we can compute the difference in accuracy between the global model and the local model of client i during the i–th training round, which serves as the generalization gap: (5)G𝒟i¯(θgt)=Acc𝒟i¯(θgt)−Acc𝒟i¯(θit−1′)

In Eq. (5), a larger generalization gap indicates a greater difference in accuracy between the global and local models for client i, suggesting that the global model generalizes less effectively on client i’s data. We can translate the analysis of the generalization gap into an analysis of the relationship between the global and local models, as expressed by Δθt in Eq. (6). (6)Δθt=θgt−θit−1′=θit−1′+(αi−1)θit−1′+∑j≠iαjθjt−1′−θit−1′=(1−αi)θit−1′+∑j≠iαjθjt−1′,s.t.αi+∑j≠iαj=1.

According to Eq. (6), it’s easy to see that increasing αi brings the global model θgt closer to the local model θit−1′. This is beneficial as it reduces the accuracy difference G𝒟¯i(θgt) on client i’s data, thereby enhancing the global model’s performance for that client. Therefore, we integrate the following weight update scheme, as shown in Eq. (7). (7)αit′=(G𝒟i¯(θgt)−μ)⋅dt+αit−1maxj(G𝒟j¯(θgt)−μ),αit=αit′∑j=1Nαjt′

In Eq. (7), μ=1C∑i=1CG𝒟i¯(θgt) represents the average generalization gap across all clients, and dt=(1−tT)⋅d is a hyperparameter that linearly decays with the number of communication rounds T, used to control the magnitude of weight adjustments, with larger adjustments allowed early in training and more stable updates as training progresses.

This dynamic weight adjustment mechanism is especially effective when clients’ data distributions differ significantly. For clients with more diverse data, the generalization errors tend to be larger. By increasing the weight αi of these clients, the global model can better adapt to their specific data features, thus enhancing the model’s generalization capabilities across different datasets. By increasing the weight for clients with larger generalization errors, the gap between them and other clients is reduced enabling the global model to balance the influence of different client data adaptively, thereby improving its overall performance in heterogeneous environments. The detailed procedure is outlined in Algorithm 1.

Although federated learning does not directly exchange data, security challenges exist, such as inference attacks, where participants can infer training data from other participants based on uploaded parameters. To address this, the study introduces noise and performs differential processing for fingerprint images in the client, the privacy protection process involves the following steps:

1. First, to enhance the clarity and detail of fingerprint images for superior feature extraction, we apply a frequency-domain-based sharpening technique: (8)g(x,y)=ℱ−1{ℱ[f(x,y)⋅(−1)x+y]⋅(1−exp⁡(−D22D02))}⋅(−1)x+y

Initially, the input grayscale image f(x,y) is prepared for the Fast Fourier Transform (FFT) by multiplying it by (−1)x+y, which centers and resizes the image for optimal FFT performance. A Gaussian high-pass flter, defined by 1−exp⁡(−D22D02), is then applied In this expression, D represents the distance from any point to the center of the frequency domain, and D0 is the normalized cutof frequency. After filtering in the frequency domain, the processed data is converted back to the spatial domain using the inverse FFT. Finally, the image is re-centered by multiplying it again by (−1)x+y, resulting in a sharpened image. This process enhances high-frequency details by suppressing low-frequency components, thereby sharpening the image.

2. After sharpening the image, we extract minutia M={P∣ CN (P)=1\, or CN(P)=3} from the fingerprint image g(x,y) by calculating the Crossing Number (CN) of pixel points. For a binarized pixel point P its CN value is determined by the number of changes in pixel values in its 8-neighborhood as given by: (9)CN(P)=12∑i=07|xi+1−xi|

In Eq. (9), xi and xi+1 represent 8 consecutive pixel values in the domain of P, and x8=x0. When CN(P)=1, P is considered an end point; when CN(P)=3, P is identified as a divergence point.

Next, we improve feature extraction accuracy by filtering out minutia too close to the image edge, using a distance threshold. In other words, for each minutia, if its distance D(p,M) to the nearest boundary is less than a given threshold Td, the detail point is discarded to eliminate noise and false detections.

3. Finally, we add random Gaussian noise in the local neighborhood of the minutia M extracted in the previous step. According to Eq. (10), the image data is further processed by computing the weighted difference between the noise-added and original images. The parameter β controls the influence of noise in the differential image processing. This weighted processing helps enhance privacy protection while maintaining data usability. The features extracted from the weighted difference processed fingerprint image are subsequently used to train models locally on the client side. Idiff=I−β⋅Inoisy, (10)Inoisy(x,y)={f(x,y)+N(0,σ2),if(x,y)∈Mf(x,y),otherwise

In Eq. (10), β is an adjustment parameter that controls the strength of the noise influence. A more significant value of β indicates that more noise is subtracted from the original image, resulting in a final differential image that visually differs more from the original image.

In this study, parameters such as the Gaussian filter’s cutoff frequency (D0), distance thresholds, and neighborhood sizes are optimized based on experimental results to achieve an ideal balance between image clarity, feature extraction accuracy, and privacy protection across various conditions. These steps significantly enhance the security of sensitive data in the client’s local environment when uploading model parameters. Fig. 3 compares the images before and after processing. The processed images show increased noise and reduced clarity, demonstrating the introduced perturbations’ effectiveness.

The NIST Supplemental Fingerprint Card Data Database (NIST SD10) [34] consists of 5520 fingerprint images from 522 individuals, each with a resolution of 832 × 768 pixels. These images are divided across three CD-ROMs and are classified into NCIC classes provided by the FBI.

The SOCOFing dataset [35] includes 6000 images from 600 subjects, captured using Hamster Plus and SecuGen SDU03PTM scanners. It offers three levels of difficulty (easy, medium, and hard) for synthetic modifications: deletion, center rotation, and z-cut modifications.

CASIA-FingerprintV5 [36] contains 20,000 fingerprint images from 500 volunteers, captured with the URU4000 sensor. Each subject contributed 40 images across eight fingers, stored as 8-bit gray-level BMP files with a resolution of 328 × 356 pixels.

As shown in Table 2, the NIST SD10, SOCOFing, and CASIA datasets exhibit significant differences in terms of image quality (NFIQ2.0 scores), image resolution, and regional sources. The Earth Mover’s Distance (EMD) heatmap and the t-SNE visualization in Fig. 4 quantify these distributional differences based on feature characteristics, illustrating the degrees of similarity and divergence between the datasets. Higher EMD values, or darker regions, indicate greater distributional differences between datasets. Each of the three datasets is assigned to a separate client, where data is processed for feature extraction and comparison. In the t-SNE plot, the features of each client dataset are represented by different colored dots, with minimal overlap between clusters, reflecting significant feature heterogeneity. This shows that each dataset has substantial differences at the feature level, and these differences will affect the overall accuracy and generalization ability of the model.

In our research, we consider each finger as a separate classification class. We utilize the SOCOFing and NIST SD10 datasets, which provide one fingerprint per finger per subject, and the CASIA dataset, which provides multiple fingerprints per finger. We choose one fingerprint per finger for our experiments to simplify data processing and ensure equitable fingerprint selection. This approach facilitates consistent experimental analysis.

We divide each client’s data into training and testing sets at a 4:1 ratio, with one-fifth of the training set randomly chosen as a validation set to tune model weights during global updates. We label fingerprint pairs (x1,x2) as 1 if they belong to the same finger (true pair) and 0 if not (false pair). We generate numerous fingerprint pairs and their corresponding labels using the training dataset. For testing, we create two types of fingerprint test sample pairs for each client. Each test sample pair consists of a fingerprint from the template library, a reference fingerprint, and a query fingerprint, which matches the fingerprint in the template library for verification. To comprehensively evaluate system performance, we generate all possible matching pairs. capping the generation of incorrect match pairs at 10,000 to maintain computational efficiency. The system is designed to detect correct and incorrect matches accurately.

Our model employs a Siamese network with two CNNs that share weights, trained using a contrastive loss function. We use a learning rate of 0.0003 and the Adam Optimizer. We set the batch size at 32. We conduct 1000 training epochs, 20 communication rounds, and 5 local epochs for single dataset experiments. For cross-dataset generalization, we extend training to 2000 epochs and 40 communication rounds, with a coefficient of 0.5 applied to process the difference image.