Early facial recognition systems relied heavily on hand-crafted features, where techniques like Eigenface Fisher faces were widely used. Eigenfaces, introduced in the 1990s, utilized Principal Component Analysis (PCA) to represent facial images as linear combinations of principal components. This approach effectively reduced the dimensionality of face images, enabling faster processing, but suffered from sensitivity to lighting, pose, and expression variation [1].

Fisherfaces, on the other hand, employed Linear Discriminant Analysis (LDA) to maximize the between-class variance and minimize within-class variance, offering more robustness against illumination changes. Despite their success in controlled environments, these techniques were limited to complex, real-world scenarios [2]. The rise of deep learning and convolutional neural networks The introduction of CNNs transformed the domain of facial recognition by enabling automated feature extraction and the learning of hierarchical representations directly from data [3]. CNNs, made up of layers that perform convolution and pooling operations, can capture complex patterns in images, which makes them particularly powerful for visual recognition applications. Notable architectures such as AlexNet, VGGNet, and ResNet showcased CNNs' capability in large-scale image classification tasks and laid the groundwork for later facial recognition models.

One of the initial deep learning models specifically created for facial recognition was DeepFace, which Facebook developed. DeepFace employed a nine-layer deep neural network to reach human-level accuracy in identifying faces, representing a breakthrough. Google's FaceNet took the field further by introducing a triplet loss function that organizes facial images into a compact Euclidean space, positioning similar faces closer together and placing dissimilar ones further apart [3].

FaceNet achieved impressive accuracy by reducing the distance between the embeddings of the same person while increasing the distance between embeddings of different individuals [5].

Another significant advancement in facial recognition is the implementation of Siamese Neural Networks (SNNs). SNNs are especially effective for few and one-shot learning tasks, where distinguishing between identities with minimal examples is necessary. By training the network on pairs of images, SNNs learn to generate a similarity score between them, making them suitable for facial verification tasks. The contrastive loss or triplet loss functions applied in SNNs allow the model to develop discriminative embeddings, facilitating effective image comparisons even when training data is limited [6].

For this research, Open Source Computer Vision library (OpenCV) is essential, particularly for preparing and improving facial images. With more than 2,500 efficient algorithms designed for various vision-related tasks, such as image editing, object recognition, and face detection, this library offers an open-source computer vision and machine learning solution. OpenCV is used in this project for several reasons, including:

I. Face detection: OpenCV's Cascade classifier or dnn module finds faces in an image before putting it into the neural network, ensuring that only the faces are processed.

II. Image augmentation: To add variation to the training dataset, OpenCV implements techniques like rotation, scaling, and flipping. Mimicking fluctuations that the model could experience in practical applications improves the model's capacity for generalization.

III. Image preprocessing: To standardize the input for the neural network, OpenCV makes it easier to resize, normalize, and convert images to greyscale.

OpenCV, for instance, can identify a face in an image, trim it to highlight facial features, and then scale it to the neural network's specifications for this case, which would be 250 × 250 pixels [7], [8].

In this project, a facial recognition model is developed, trained, and launched using TensorFlow and Keras. TensorFlow, an open-source deep learning library created by Google, provides a comprehensive platform for building and scaling machine learning models. Known for its flexibility and ability to handle large datasets, TensorFlow has become a key resource in various research and industrial deep learning uses. It supports CPU and GPU acceleration, making it suitable for training demanding models like CNNs and SNNs. Keras, a high-level neural network API built on TensorFlow, simplifies defining and training deep learning models. With its user-friendly APIs, Keras allows developers to prototype and assess models quickly without dealing with the complexities of lower-level implementations.

In this project, Keras components such as Conv2D, Dense, Input, Flatten, and MaxPooling2D are employed to define the architecture of the Siamese Network. For instance:

I. Conv2D layers implement convolutional operations, allowing the network to extract spatial hierarchies in facial images.

II. MaxPooling2D layers help reduce the spatial dimensions of the feature maps, retaining the most important features while reducing computational complexity.

III. Dense layers provide fully connected networks that further abstract features extracted by the convolutional layers.

Using Keras with TensorFlow provides an efficient pipeline for model development, where Keras handles the model building, while TensorFlow's backend enables optimization and deployment across multiple devices.

Several recent works have combined TensorFlow, Keras, and OpenCV in the context of facial recognition. For instance, Luttrell et al. [9] utilized TensorFlow and Keras to implement a facial recognition system that leveraged CNN layers for feature extraction. OpenCV handles real time face detection and image preprocessing. Similarly, the researchers employed a SNN architecture built in Keras and TensorFlow for a one-shot learning task, where OpenCV was used to augment the dataset with different lighting conditions and poses. These studies have demonstrated the effectiveness of using these libraries together, particularly in applications where computational efficiency and ease of implementation are essential.

The SNN architecture used in this project is built to analyze pairs of facial images and assess their similarity. This process is performed by directing each image from a pair through two identical subnetworks that share weights, which extract high-level features from each image. The resulting feature vectors are then compared to generate a similarity score. Below is a detailed breakdown of the architecture by layer:

The system begins by collecting a large, labeled dataset that covers a variety of facial expressions, lighting conditions, and poses. Preprocessing includes resizing and normalizing images, with augmentation techniques (Like rotations and brightness adjustments) added to increase dataset diversity and improve the model's generalization.

Using deep learning, specifically CNNs, the model locates and isolates faces within images. CNNs improve upon traditional methods by automatically learning hierarchical features, enabling accurate detection even under complex, real-world conditions.

Facial alignment ensures each face is correctly oriented before feature extraction, improving recognition accuracy. CNNs handle challenges in alignment, like variations in pose, expression, and occlusions, by learning features that help maintain consistency.

The model leverages CNNs to extract high-level facial features from the image, creating a compact, discriminative feature vector for each face. This deep learning-based approach surpasses traditional methods by learning nuanced facial patterns directly from the raw data.

The system compares the extracted feature vectors to those in its database using similarity metrics (e.g., Euclidean distance) for recognition. The face is matched to a known identity when the similarity score exceeds a set threshold.

The model’s accuracy is evaluated against labeled data and optimized through fine-tuning on a validation set. This step ensures robustness, enabling the system to adapt effectively to diverse real-world scenarios.

The CNN-based detection successfully recognized faces in various lighting situations and minor obstructions. Facial alignment adjusted poses, enhancing the accuracy of feature extraction.

High-dimensional feature vectors effectively capture subtle facial characteristics, maintaining consistent performance across lighting scenarios and angles.

The system achieved high accuracy and low error rates by employing similarity metrics, even in moderate obstructions.

Exceptional precision, recall, and accuracy demonstrated effective identification, with few false positives and strong generalization capabilities.

The system's performance suffered under extreme obstructions or pronounced poses. The biases in the dataset indicated the necessity for more diverse training data.

The CNN model surpassed traditional techniques, particularly in automated feature extraction and adaptability.

The system exhibited impressive accuracy and adaptability, making it appropriate for real-world applications. However, minor aspects could be enhanced.

[316]: #set plot size.

plt.figure(figsize=(10,3)).

#set first subplot.

plt.subplot(1,2,1).

plt.imshow(test_input[0]) # first input prediction output 0.

plt.subplot(1,2,2).

plt.imshow(test_val[0]).

#Render cleanly.

(plt.show).

[322]: plt.figure(figsize=(10,3)).

plt.subplot(1,2,1).

plt.imshow(test_input[2]) # third input prediction output 0.

plt.subplot(1,2,2).

plt.imshow(test_val[2]) plt.show.