Face recognition plays a pivotal role in enhancing security, improving efficiency, and enabling innovative applications across diverse industries, making it an indispensable tool in today's world. This study presents a comparative investigation between prediction ellipsoid and machine learning algorithms, such as a one-class support vector machine, isolation forest, and an autoencoder based on a neural network, in the context of face recognition. The construction of a prediction ellipsoid is based on the assumption of a multivariate normal distribution of the data, however, in real-world scenarios, the data often deviates from this assumption and may exhibit a non-Gaussian distribution. To mitigate this, the dataset underwent normalization via the multivariate Box-Cox transformation, facilitating the development of a decision rule based on a ten-variate prediction ellipsoid for the normalized data. This approach yielded notable enhancements in accuracy and method robustness. All the developed models have shown good efficiency in their respective performances. However, the application of the multivariate Box-Cox normalizing transformation significantly enhanced the performance of the prediction ellipsoid. As a result, the ten-variable prediction ellipsoid for normalized data has demonstrated superior efficiency compared to the other models. The study also highlights the critical role of feature dimensionality in face recognition, emphasizing the necessity of expanding the number of features and utilizing more complex models to achieve optimal performance.
Face recognition, a quintessential task in computer vision, holds significant importance in various fields, including security, surveillance, human-computer interaction, and biometrics. It entails identifying or verifying individuals by analyzing and comparing facial features captured through images or videos.
The face recognition task contains several crucial steps, each essential for ensuring the
system's accuracy, robustness, and reliability [
Traditionally, face recognition systems have been approached through classification methods,
where the goal is to classify an input face image into one of several predefined classes. However,
these methods often face challenges in scenarios where the available data for training does not
adequately represent the entire population, leading to poor performance on novel faces. To
address this limitation, the one-class classification approach has emerged. This approach, closely
related to anomaly detection [
Use permitted under Creative Commons License Attribution 4.0 International (CC BY 4.0). the target, without explicit knowledge of the negative classes, representatives of these classes are considered anomalies.
In the domain of face recognition, one-class classification stands as a pivotal methodology,
enabling the identification of target classes amidst varying data distributions. Prediction ellipsoid
and machine learning methods emerge as frontrunners among the popular approaches in this
realm [
The field of face recognition has seen significant advancements in recent years, with various
techniques developed such as linear discriminate analysis, support vector machine, and principal
component analysis combined with face recognition by using K-Nearest-Neighbor and neural
networks, including convolutional neural networks [
Among the common approaches to one-class classification, prediction ellipsoid [
The application of a prediction ellipsoid relies on the assumption of a multivariate normal
distribution within the data, which may not always hold, this discrepancy necessitates the
utilization of normalization transformations [
Our study primarily investigates the method based on prediction ellipsoid and machine learning algorithms, such as OCSVM, IF, and AE, which are commonly utilized and offer distinct approaches to one-class classification. Specifically, OCSVM delineates a discerning boundary around normal instances, IF isolates anomalies through iterative partitioning of the feature space, AE employs a neural network approach, and the prediction ellipsoid separates normal instances from potential outliers based on their position in the feature space.
In the realm of face recognition, where accuracy and efficiency are paramount, it's imperative to evaluate the efficacy of different approaches. While prediction ellipsoid offers interpretability and computational efficiency, they may encounter limitations with non-Gaussian data distributions. In contrast, machine learning methods such as OCSVM, IF, or AE present alternative methodologies, each with unique strengths and challenges.
In the domain of computer vision, a variety of techniques are employed for detecting faces in
images, each characterized by distinct strengths and functionalities. Notable among these
methods are the Viola-Jones, Multi-Task Cascaded Convolutional Neural Network (MTCNN), and
DLib toolkit [
The Viola-Jones represents a classic yet effective approach to face detection, renowned for its simplicity and efficiency. Operating by scanning images at multiple scales, it utilizes a predefined set of features to pinpoint regions of interest potentially containing faces. It is implemented in the Python OpenCV library.
MTCNN, on the other hand, stands out as a deep learning-based face detection tool prized for its remarkable accuracy and resilience. Comprising three stages—face detection, bounding box regression, and facial landmark localization—MTCNN leverages a cascade of convolutional neural networks to precisely identify faces in images while concurrently estimating facial landmarks. This method is particularly advantageous for applications necessitating precise localization of facial features.
DLib emerges as a comprehensive C++ toolkit with formidable capabilities in facial detection and recognition. Leveraging a Histogram of Oriented Gradients and Linear Support Vector Machine face detector, DLib excels in detecting faces and estimating 68 facial points. These points facilitate accurate detection and localization of facial features, enabling seamless implementation of face alignment, merging, and other transformations.
While all face detection methods exhibit commendable performance in high-quality images, they display variations in performance under different conditions. MTCNN and DLib demonstrate comparable accuracy, with MTCNN exhibiting superior performance in recognizing faces in small images and low-light conditions. In contrast, the Viola-Jones method may encounter challenges with distortions. Performance evaluations conducted using a standardized test dataset reveal that Viola-Jones operates at the highest speed, processing 11.25 frames per second (fps), followed closely by DLib at 9.41 fps, and MTCNN at 4.92 fps.
Given its good speed and proficiency in extracting a substantial number of key points, DLib emerges as the preferred choice for face detection and feature extraction tasks, particularly in scenarios where real-time processing or high throughput is essential.
A program was created using the DLib computer vision library in Python to generate feature vectors. Once a face is detected in the input image, the program begins several image-processing tasks. These tasks include cropping and aligning the face to ensure that the eyes are aligned at the same level. This preprocessing step helps reduce distortions caused by the face's orientation in the input image. In the last phase, the program extracts a series of attributes from the aligned image. Each attribute denotes the pixel distance between facial landmarks identified by the DLib library. It used 17 key landmarks across the face (fig. 1).
Utilizing the pixel distances between these landmarks, a feature vector composed of 10 distinct attributes was meticulously crafted. Symmetrical distances were thoughtfully averaged to derive the following features: 1. The eyes-to-nose midpoint distance indicates the facial symmetry and proportionality between the eyes and the nose. 2. The eyes-to-mouth center distance reflects the vertical alignment and proportionality between the eyes and the mouth. 3. The eyes-to-eyebrows center distance offers insights into the spatial relationship between the eyes and the eyebrows. 4. The eyebrows-to-nose bridge distance delineates the vertical dimension and proportionality between the eyebrows and the nose bridge. 5. The eye's corners-to-nose bridge distance provides insights into the lateral dimension and proportionality between the eye's corners and the nose bridge. 6. The eyebrows distance. 7. The nose-to-mouth midpoint distance offers insights into the vertical alignment between the nose and the mouth. 8. The corners of the mouth distance, reflect the width of the mouth. 9. The edges of the nose distance, delineate the width of the nose. 10. The mouth-to-chin distance provides insights into the vertical dimension between the mouth and the chin. and expansion of the dataset. In total, 400 high-quality photos were obtained, 200 for each of the two faces. Consequently, 400 feature vectors were acquired, each corresponding to a single photo, comprising 10 elements. Out of these, 100 vectors of a single person were used to construct a prediction ellipsoid and train the machine learning models for identifying the individual, while the remaining 300 photos were allocated as the test set. 4. Materials and methods
In the construction of the prediction ellipsoid, each observation's squared Mahalanobis distance
is calculated and compared to critical values derived from the Chi-square distribution [
Based on the results of the Mardia test, it is evident that the multivariate distribution of the training sample deviates from Gaussian. This is indicated by the test statistic for multivariate skewness
1/6, which measures 289.20, surpassing the quantile of the Chi-Square distribution set at 277.77 for 220 degrees of freedom and a significance level of 0.005. Conversely, the test statistic for multivariate kurtosis 2 with a value of 122.35 does not exceed the Gaussian distribution quantile, which stands at 127.97 for a mean of 120, a variance of 9.6, and a significance level of 0.005. Consequently, it is imperative to apply a normalizing transformation like the Box-Cox transformation on a non-Gaussian random vector = { 1, 2, … , 10} , to convert it into a Gaussian random vector
= { 1, 2, … , 10} .
The Box-Cox transformation is a statistical technique used to stabilize variance and make data conform more closely to the assumptions of normality. It is typically applied to univariate data, but there is also a multivariate extension known as the multivariate Box-Cox transformation. = (λ ) = {( λ − 1)/λ , ln( ) , λ ≠ 0; λ = 0.
In the multivariate context, the BCT aims to normalize data across multiple variables simultaneously. It is designed to address situations where there are multiple correlated variables (3) (4) (5) and normalizing each variable individually may not be sufficient to achieve multivariate normality. The multivariate BCT involves estimating transformation parameters for each variable in the sample, similar to the univariate case. However, it also considers the interrelationships between variables to ensure that the transformation maintains the structure of the multivariate distribution. One of the methods to determine parameters for each variable in the dataset involves maximizing the log-likelihood of the transformed data: =1 =1 2 ( , θ) = ∑( λ − 1) ∑ ln( ) − ln[det( )] , (6) λ̂9 = -1.1866, λ̂10 = 1.3321. where is calculated as (2) using the normalized sample instead of .
Following the completion of the task utilizing the maximum likelihood method of the logarithmic function (6), the ensuing parameter estimates were acquired: λ̂1 = -0.5799, λ̂2 = -0.9732,
λ̂3 = 0.4871, λ̂4 = 2.888, λ̂5 = 4.0714, λ̂6 = -0.231, λ̂7 = 0.087, λ̂8 = -1.2973, As a result of the BCT application with components (5), a sample was obtained, featuring the resulting vector of means: ̅ = {0.52627; 0.13911; -0.91083; 0.25654; -0.24379; 1.13224; -1.14383; -0.26329; 2.03304; -0.34494}.
The covariance matrix of the normalized sample is: 0. 0244 0. 0213 −0. 022 −0. 046 −0. 056 −0. 038 −0. 023 0. 0470 0. 0262 supported by the test statistics: the multivariate skewness test statistic recorded at 121.52, is lower than the critical value of 127.97. 265.59 does not exceed the critical value of 277.77, and the multivariate kurtosis test statistic 2,
After applying the normalization transformations, a ten-variate prediction ellipsoid is constructed based on equation (1):
( − ̅) −1( − ̅) ≤ 120, 0.005.
The quantile value of the Chi-square distribution is 25.19 for 10 degrees of freedom and a
Several popular techniques in machine learning serve as effective tools for outlier detection and can be used for face recognition, including a one-class support vector machine, isolation forest, and autoencoder. These methods are particularly notable for their application in unsupervised learning and they can be trained only on data from the target class, studying the features of the provided data.
OCSVM constructs a decision function or boundary that effectively separates the target data from the rest of the feature space. This boundary is established by finding a hyperplane with a maximum margin and optimizing the distance between the hyperplane and the origin in the highdimensional feature space.
In an OCSVM, an implicit transformation function φ(∙) is employed, it is a non-linear projection
that is evaluated through a kernel function, which serves as a mapping from the original feature
space to a potentially higher-dimensional feature space: ( , ) = φ( ) ∙ φ( ) [
Subsequently, the algorithm learns a decision boundary aimed at segregating the majority of
the data from the origin, it is defined as [
( ) = φ( ) − , where the normal vector of the hyperplane, is the bias.
Formulating OCSVM as a quadratic optimization problem, the main aim is to minimize the weight vector while simultaneously maximizing the margin, subject to specific constraints: where ξ is slack variables, it is utilized to model separation errors; ν ∈ (0,1] is the regularization parameter, it characterizes the solution by setting an upper bound on the fraction of outliers, such as the training examples regarded as out-of-class, and simultaneously establishes a lower bound on the number of training examples utilized as support vectors [19].
The optimization problem is typically solved in its dual form, resulting in a decision function that can classify new data points as either belonging to the target class or representing anomalies. This function yields a positive value for the target and a negative value otherwise: ( ) =
( ( )).
In Python, implementing OCSVM typically involves creating a OneClassSVM object from the SVM module in sci-kit-learn. This allows users to adjust essential parameters such as the choice of kernel function, regularization parameter ν, and kernel-specific parameters. The model is configured with a ν parameter of 0.15, which determines the fraction of training errors and the upper bound on the fraction of training set outliers. For the kernel function, the radial basis function is utilized. This kernel is popular for SVMs due to its flexibility in capturing non-linear relationships between data points. Additionally, the gamma parameter is set to auto, which means its value is automatically calculated based on the inverse of the number of features. Gamma defines the influence range of a single training example, with low values meaning far and high values meaning close. within the forest [21]. length [22]:
Departing from traditional approaches reliant on profiling normal data points, isolation forest takes a unique route by directly focusing on isolating anomalies. This method hinges on constructing isolation trees, binary trees where internal nodes represent features and split values, while leaf nodes represent individual data points [20].
The process of constructing isolation trees initiates with the random selection of a feature and split value within its range. This randomness recurs until each data point is secluded in its own leaf node, or until a predetermined maximum tree depth is attained. The method's ability to efficiently isolate anomalies sans prior knowledge of the dataset's distribution stems from this stochastic feature and split value selection. Anomalies, expected to be inherently easier to isolate than normal data points, typically reside in sparser regions of the feature space. Consequently, they necessitate fewer splits along paths from the root to leaf nodes for isolation. Hence, the average path length from the root to leaf nodes for each data point is computed across all trees Subsequently, an anomaly score is computed for each data point based on its average path ( , ) = 2− ( ) ,
(ℎ( ))
∑ where (ℎ( )) = =1 ℎ ( ) is the average length of over isolation trees; ( ) is the average length of unsuccessful search in a binary tree:
( ) = 2 ( − 1) − (2( − 1)/ ), where ( ) = ln( ) + γ, γ is Euler’s constant.
Data points with shorter path lengths, indicative of proximity to the root, are deemed more likely to be anomalies, while those with longer paths are considered more typical. A threshold is established to classify data points as anomalies or normal points based on their anomaly scores, with points above the threshold classified as anomalies and those below as normal.
Isolation forest harnesses an ensemble of these isolation trees, where each tree operates independently, contributing to the final anomaly score for a given data point. This ensemble approach enhances the algorithm's robustness and accuracy, rendering it more adept at handling noise and data variability.
The IsolationForest algorithm is implemented in the widely-used Python machine learning library sci-kit-learn and offers various adjustable parameters for optimizing its performance. Among these is the contamination parameter, essential for determining the threshold in the decision function, which distinguishes new data points as either target or anomalous [23]. After conducting experiments, a value of 0.08 was selected for the contamination parameter as it strikes the optimal balance between detecting true anomalies and minimizing false alarms.
Other significant parameters of the IsolationForest model include: n_estimators, specifying the number of decision trees within the forest, set to 100; max_samples, indicating the maximum number of samples used for training each tree, set to 256; and max_features, determining the maximum number of features used for splitting each node, set to 1.0, indicating that all features are used. These parameter settings were chosen based on their widespread usage and their ability to strike an optimal balance between model complexity and computational efficiency.
To classify a sample as either target or anomalous, the anomaly score is compared to a threshold value. These scores can range from positive to negative, with negative values indicating samples more likely to be the target and positive values indicating samples more likely to be anomalous. The selection of the threshold value depends on the specific application and the characteristics of the data. In our case, a threshold value of 0 yielded the best results.
An autoencoder is a form of artificial neural network employed for learning efficient data representations, dimensionality reduction, and detecting anomalies. It is an unsupervised learning method composed of two primary components: an encoder and a decoder. The main objective of an autoencoder is to learn a condensed and meaningful representation of the input data, referred to as the latent space or bottleneck, by reconstructing the input data with minimal loss [24].
The encoder's role is to map the input data to the latent space, compressing the information into a lower-dimensional representation. It is generally a neural network with multiple layers, where each layer applies a non-linear transformation to the input data. The encoder's output, the latent space, captures the most significant features and patterns in the input data.
In contrast, the decoder is responsible for reconstructing the input data from the latent space representation. It is also a neural network with multiple layers, but its architecture is typically the inverse of the encoder's architecture. The decoder takes the latent space representation as input and tries to recreate the original input data by applying a series of non-linear transformations through its layers.
During training, the autoencoder learns to minimize the reconstruction error, which is the discrepancy between the original input data and the reconstructed data. This is usually accomplished by optimizing a loss function, such as mean squared error or binary cross-entropy, using gradient-based optimization techniques like backpropagation.
In the context of recognition, the autoencoder is trained using target class instances, enabling it to learn the patterns and structure of normal data. When presented with new data, the autoencoder will reconstruct the input with a low reconstruction error if the input is the target. However, if the input is an anomaly, the reconstruction error will be higher, as the autoencoder has not been trained to reconstruct such instances effectively [25]. By setting an appropriate threshold on the reconstruction error, it is possible to detect and distinguish anomalies from target instances.
When considering the development of autoencoder models, various machine learning frameworks present distinct advantages. TensorFlow and PyTorch emerge as prominent contenders in this domain. TensorFlow, originating from Google, offers a rich ecosystem of tools and libraries, rendering it a favored option among both researchers and practitioners. Its utilization of a static computation graph facilitates efficient optimization and distributed computing, making it particularly suited for handling large-scale neural network models. Conversely, PyTorch, hailing from Facebook's AI Research lab, emphasizes flexibility and userfriendliness. With its dynamic computation graph and intuitive API, PyTorch becomes the preferred choice for swift prototyping and experimentation [26].
In the creation of autoencoder models, TensorFlow and Keras were selected due to their collective strengths in flexibility, scalability, and usability. Keras, functioning as a high-level neural networks API layered atop TensorFlow, streamlines the process of constructing and training autoencoder models. Meanwhile, TensorFlow furnishes the foundational infrastructure for proficient computation, ensuring optimal performance throughout the training and inference phases.
Before feeding the data into the neural network, min-max normalization is applied to each
feature individually. This normalization method scales each feature to a range [
To train the model, the Adam optimizer is utilized with binary cross-entropy loss, a common choice for reconstruction tasks aiming to minimize the difference between the input and reconstructed data. Adam optimizer is an adaptive learning rate optimization approach that combines the advantages of both AdaGrad and RMSProp [30]. It dynamically adjusts the learning rate during training, allowing for faster convergence and improved performance. Binary crossentropy loss, on the other hand, measures the dissimilarity between the input and the reconstructed data, particularly suitable for binary classification problems where each instance belongs to one of two classes. This configuration ensures efficient training of the autoencoder model, optimizing its ability to capture the underlying patterns in the data while minimizing reconstruction error.
The training process spans 100 epochs, with a batch size of 8 instances per batch. Shuffling the data at each epoch introduces randomness and prevents the model from memorizing the training data order, aiding in generalization.
Various evaluation metrics are employed to assess the effectiveness of created models in recognition of the target instances or anomalies. Commonly used metrics include accuracy, precision, recall (sensitivity), specificity, and the F1 score [31, 32]. While accuracy provides a broad perspective on correctness, precision, recall, specificity, and the F1 score offers nuanced insights into the model's efficacy in detecting anomalies.
The evaluation metrics are derived from a confusion matrix, which offers four distinct measures. True Positive (TP) represents instances where the model correctly identifies an anomaly as such. False Positive (FP) instances occur when the model inaccurately labels a target instance as an anomaly. True Negative (TN) denotes instances where the model accurately identifies target instances. Lastly, False Negative (FN) instances arise when the model incorrectly labels target instances as normal.
Accuracy acts as a gauge for overall correctness, derived from the ratio of correctly classified instances to the total number of instances : =
+ The F1 score is the harmonic mean of precision and recall: + + +
Precision, on the other hand, quantifies the proportion of correctly identified anomalies among all instances classified as anomalies. This metric is calculated as the ratio of true positives to the sum of true positives and false positives:
+
Recall, also termed sensitivity, represents the proportion of actual anomalies correctly identified by the model. It serves as a pivotal indicator of the model's ability to detect all anomalies within the dataset: =
+
Specificity provides complementary insights by measuring the proportion of true negatives and correctly predicted target instances, among all actual target instances. It highlights the model's capacity to accurately identify target instances while minimizing false alarms.
In general, all developed models have good efficiency. The OCSVM exhibited the lowest performance among the models evaluated, with scores generally lower across precision, recall, specificity, F1 score, and accuracy. The IF demonstrated competitive performance across most metrics, falling between the scores of OCSVM and the other models. This indicates that IF may offer a decent compromise between simplicity and performance, making it a viable choice depending on the specific requirements of the application.
AE showed performance comparable to PENGD, with scores across various metrics similar to or slightly lower than PENGD. However, by employing normalization techniques, PEND achieved notable enhancements in performance compared to both AE and PENGD. This underscores the importance of normalizing transformation in enhancing prediction ellipsoid models for recognition, particularly in scenarios involving non-Gaussian data.
As evidenced by the results, the prediction ellipsoid for normalized data consistently outperformed machine learning models such as OCSVM, IF, and AE. Compared to the prediction ellipsoid for non-Gaussian data, the application of a ten-variate Box-Cox transformation significantly improved the model. This highlights the importance of applying a normalizing transformation to data with a non-Gaussian distribution. The choice of an appropriate normalization technique is far from trivial and exerts a profound influence on the efficacy and robustness of the created model. Univariate normalization methods often fall short of capturing the intricate relationships between features, leading to suboptimal results. In contrast, multivariate normalization techniques offer a more comprehensive approach by considering the correlations and interdependencies between multiple features. By applying the ten-variate BoxCox transformation, the prediction ellipsoid can account for correlations between features. This approach enables the model to more accurately represent the underlying data distribution, leading to enhanced robustness and efficiency.
It should be noted that a crucial aspect in the construction of a prediction ellipsoid is the definition of the confidence level. In our study, a confidence level of 0.005 was selected, aligning with its widespread usage in outlier detection tasks [33].
The main advantage of using the prediction ellipsoid for normalized data lies in its ability to enhance prediction accuracy and reliability. Normalizing the data not only facilitates the development of more accurate prediction ellipsoid but also ensures they capture the underlying patterns and relationships within the data more effectively, leading to more reliable and precise predictions. Additionally, by transforming the data to data with the Gaussian distribution, the prediction ellipsoid gains increased robustness and resilience.
The application of prediction ellipsoid for normalized data has some disadvantages. Firstly, a substantial dataset size is often required to robustly study the model's performance, typically necessitating a minimum of 100 instances to yield meaningful insights. Additionally, the process of identifying an appropriate normalizing transformation can be intricate and resource-intensive, particularly in cases where the underlying data distribution is complex or poorly understood. The last one is the necessity of selecting a confidence level, which can have a significant impact on the interpretation and reliability of the prediction ellipsoid.
It's important to acknowledge the inherent limitations of the prediction ellipsoid model. One notable constraint is its inherent design to recognize and delineate prediction regions for individual instances rather than accommodating multiple instances simultaneously. While the model excels in providing localized predictions for individual data points, its applicability to scenarios involving collective analysis or batch processing may be limited, warranting careful consideration in practical deployment scenarios.
Future research could involve exploring alternative normalizing transformations, such as the multivariate Johnson transformation. In addition, it's important to consider the impact of model complexity and feature richness on performance. While the models evaluated in this study demonstrate commendable results with the available features, there's a clear indication that employing more complex models and incorporating a broader range of features could yield even better outcomes. This emphasizes the necessity of advancing both model architecture and feature selection techniques to effectively address the intricacies present in the data.
The study examined various one-class classification methods in the context of face recognition. Various models were constructed including prediction ellipsoid for normalized data and machine learning algorithms such as OCSVM, IF, and AE. These methodologies aim to unveil anomalies within a dataset by apprehending its underlying structure, often gleaned from instances representing the target class.
The application of the ten-variate Box-Cox transformation significantly enhanced the performance of the prediction ellipsoid, which led to a 3% increase in recognition accuracy. Consequently, the model surpassed the performance of the considered machine learning methods. This underscores the significance of applying normalization techniques to nonGaussian data. The primary advantage of utilizing the prediction ellipsoid for normalized data is its capacity to enhance prediction accuracy and reliability. Normalizing the data not only facilitates the development of more precise prediction ellipsoids but also ensures they capture the underlying patterns.
The main disadvantage of the developed model lies in the complexity and resource-intensive nature of determining the appropriate normalizing transformation. This challenge is particularly pronounced in cases where the underlying data distribution is complex or poorly understood, especially when dealing with high-dimensional data.
An essential aspect of employing the method involves determining the confidence level, with a confidence level of 0.005 utilized in the study.
Future research could explore the impact of employing alternative normalizing methods, such as the multivariate Johnson transformation, to further enhance model performance. Additionally, deeper investigations into the reasons behind the observed performance differences among models and the potential benefits of incorporating more complex models with a broader array of features could contribute to the advancement of one-class classification methodologies in face recognition tasks.