Performance Analysis of Neural Network Based Human Palmprint and Hand Gesture Recognition Techniques

For sign language recognition, many writers have suggested various video processing and machine learning (ML) techniques. Here are a few similar tasks. Gestures are identified, and color characteristics and contour extraction are utilized [13]. Its usage of contour extraction means that it can only be used to count stray fingers and no other motions, which is a drawback. The drawback in this situation is that some gesture symbols used in HMIs in place of hydration motions cannot be detected. However, it does not mention how to recognize hand movements [14]. The disadvantage of using LSTM and 3DCNN for dynamic gesture recognition is that letter motions are not recognized and are instead used for military gestures.

Suboptimal architecture methods used to improve large-scale blurring [15]. A unified blur kernel with a Gaussian process used to produce many blurred images. Then, we convolve it with explicit images from the ImageNet dataset [16] to provide pairs of crisp and blurred images for network training. Deconvolutional CNN that can blur images instead of blinds in the blur setting is proposed which break down (inverse) blur kernels into a few critical filters and build networks based on separable kernel features [17]. To lessen visual artifacts like noise and color saturation, we additionally integrate a denoising network [18] that links proposal modules at the network's end. A blind deblurring technique for CNNs is suggested, and their proposed network iterative kernel estimation, latent image estimation, and feature extraction methods resemble conventional optimization-based deblurring methods [19].

A sequential deblurring approach was suggested by making two blur and sharpening patches using 73 potential blur kernels. We next trained a classification CNN to calculate the likelihood of a specific blur kernel for local patches [20]. The energy model, which consists of the CNN likelihood and smoothness dictionary, is then optimized to provide a blur kernel that varies smoothly. The energy model, which consists of the CNN likelihood and smoothness dictionary, is then optimized to provide a blur kernel that varies smoothly. As stated by Peng et al. [21], the edit distance enhanced CNN model was able to obtain 90.79% accuracy in the static and dynamic gesture detection of Pakistani individuals. To improve performance, we use fusion techniques by globalizing the regional features identified in the 3D CNN model. On three color video gesture datasets, this method achieves recognition rates of 98.12%, 100%, and 76.67%.

Using LSTM blocks, Conv1D, and Conv2D pyramids, Ali et al. [22] presented a multi-level functional LSTM. This approach utilizes the deep form features of the hand segmentation model and the skeletal point cloud features of the skeletal data. The 14-class- and 28-class Dynamic Gesture Recognition (DHG) datasets show 96.07% and 94.40% accuracy for the approach. In this study, we use an LSTM model with two pyramid convolution blocks to extract dynamic gesture variety from 28 skeletal and 14 depth data. Of the eighteen categories, 94.40% of them are accurate. Convolutional extended short-term memory networks, or ConvLSTMs, are utilized by Gholami and Khashe [23] to recognize the temporal relationship between color images' spatiotemporal properties and to generate high-level gesture expressiveness.

Gholami and Noori [24], Combining the feature fusion network with the ConvLSTM network allowed for the extraction of spatiotemporal feature information from local, global, and deep perspectives. Regarding the Jester and SHIG (Sheffield Kinect Gesture) datasets, the suggested technique obtains accuracy levels of 95.59% and 99.65%, respectively. For hand movement recognition, Mambou et al. [25] introduced EDenseNet, an enhanced densely connected convolutional neural network. With three datasets of gestures, the approach obtains an average accuracy of 99.64%. Venmathi et al. [26] put forth a 3D convolutional neural network (3DCNN) that can detect hand movements in real time and retrieve fingerprint positions. For a video dataset with seven manual procedures, the 3DCNN model's accuracy was 92.6%.

Studied the translation of symbolic words from gesture to text [27]. With an accuracy of 97.28%, we could categorize symbolic gestures using Support Vector Machines (SVM) on a data set of 11 one-handed and nine two-handed gestures. Examined sexual assault-related gestures made in both indoor and outdoor settings at night [28]. How the gesture recognition system is being implemented consists of a bounding box picture classification stage that generates attack alerts after a YOLO CNN architecture has been used to extract motions. Overall, the network model's accuracy needs to be improved; light must be enough.

Adel for interpreting finger spells and gestures in films called Compact Spatial Pyramid Pooling (SPP) was proposed by Ewe et al. [29]. The model runs three times faster than conventional classifiers and requires 65% fewer parameters. TEM (Temporal Segment Network) and TSM (Temporal Shift Module) were improved upon by Alsharif et al. [30] using the lightweight semantic segmentation FASSD-Net network. The suggested 13-gesture dataset, which focuses on in-the-moment non-touchscreen interactions, was adequate.

In conclusion, academics' most difficult task is creating a solid framework for gesture recognition that addresses the most prevalent issues with the fewest restrictions and yields precise and trustworthy outcomes. There are several real-time gesture processing restrictions, including distance, lighting, background, and numerous motions. While specific approaches for hand action identification that use non-machine learning techniques are available, their accuracy could be more consistent, and specific actions can overlap with each other in different conditions (e.g., illumination), making this approach unsustainable. It is more independently adaptable than machine learning techniques. Consequently, system development uses a machine learning methodology. The exciting aspect of this work is how deep learning methods are implemented in gesture recognition systems using novel segmentation approaches.

2.1 Problem formulation

This paper uses two common types of biometric data as examples to keep things simple. Face data is one type, and fingerprint data is the other. It makes sense, from a distinction standpoint, to believe that an individual's whole set of biometric data falls into a single category. Furthermore, in the same feature space, his face and palm print data can be viewed as two subclasses of this class. Figure 2 displays samples of palm prints and faces from two individuals.

In this case, data for two persons is displayed. Each has twelve pieces of information, six faces, and a palm print. The original data had an order of magnitude of 1e4, which I used for illustration when I performed PCA on it.

222.png

Figure 2. An example of the corresponding palmprint data and the mix-Gaussian distribution of the face data (blue-face and palm data of first person, red-face and palm data of second person)

Figure 2 illustrates a typical Gaussian mixture distribution on a sample of IDs belonging to a single individual [31]. Stated differently, a Gaussian is formed by grouping the face data and a second Gaussian is formed by grouping the fingerprint data. In the combined space, there is a high likelihood of data from two individuals overlapping if you apply traditional LDA, which requires the grouping of one person's face and fingerprint data. The SDA in Figure 2 undoubtedly provides a better description of this distribution of data.

Let k be the face sample and i be the palm print sample of person, respectively. The sample number for every subclass is denoted by n_c. Next, we create the dispersion matrix within subclass S_W and the dispersion matrix between subclass S_B as follows:

$S_B=\sum_{i=1}^{c-1} \sum_{j=1}^2 \sum_{k=i+1}^c \sum_{l=1}^2 P_{i j} P_{k l}\left(\mu_{i j}-\mu_{k l}\right)\left(\mu_{i j}-\mu_{k l}\right)^T$         (1)

$S_W=\frac{1}{N} \sum_{i=1}^c \sum_{j=1}^2 \sum_{k=1}^{n_c}\left(x_{i j}^k-\mu_{i j}\right)\left(x_{i j}^k-\mu_{i j}{ }^T\right.$）         (2)

where,

$N=c \times n_c, P_{i j}=P_{k l}=\frac{n_c}{N}, \mu_{i j}=\sum_{k=1}^{n_c} \frac{x k_{i j}}{n_c}$           （3）

Let be the ideal transform vector that needs to be determined. It can be found by:

$\max _w \frac{w^T S_B w}{w^T S_w w}$              (4)

4.1 Scale-Invariant feature transform (SIFT) feature extraction

The SIFT image technique is calculated using a configurable number of essential points throughout four steps. The number of critical issues calculated is based on the image's content. Each of these points is subsequently assigned a feature vector of 128 elements. Based on the proportion of critical points that match between test and training images and categories test images using the SIFT feature.

The procedure of matching feature points between two images goes like this. SIFT descriptors (key points) are first computed for each image in the collection. Think about two ideas, U and V, described by m and n descriptors, respectively, as shown by u₁, u₂,..., u_m and v₁, v₂,..v_n.

The keypoint matching of two images is calculated as follows:

(1). Compute the distance between each eigenvector associated with image U and each eigenvector associated with image V; compute the m x n distance.

(2). A critical point with feature vector u_i in image U matches key point v_k in image V [32].

The argument T is a positive actual number less than 1. The threshold parameter can be used to control the critical point-matching process. One key point in image U can only match one key point in image V. Details of the key point extraction and matching process can be found. In our first experiments, we used default values for the parameters of the SIFT algorithm. We then examined the effect of the number of octaves, contrast-related thresholds, and edge-related thresholds in each layer on classification results. We reasoned that the contrast-dependent entry would provide the most pronounced effect. A predetermined and fixed set of SIFT parameters may be used to calculate images with no connected key points, few key points, and many key points.

This condition has the following discomforts:

- Images can only be classified with crucial points.

- Images with few associated vital points are often misclassified.

- Matching an image with a few key points with an image with numerous vital points appears to be complicated.

The calculation duration of the matching algorithm is influenced by the number of critical points produced for the two images being compared. Therefore, the matching process is computationally expensive, and the classification time for images with many vital points is long. For example, Figure 7 shows matching key points according to distance measures. Crucial points of comparison between the reference and subject palm patterns in the picture are used to compare textures for palm pattern matching.

77.png

Figure 7. Detection of Keyspots

4.2 SIFT algorithm

The rotation, magnification, and brightness variations do not affect the SIFT algorithm. SIFT features can be used to calculate large-scale feature data when paired with other kinds of feature matching. The blood component of the skin leaves fingerprints on the hand. Utilizing infrared light, which guards against harm from the outside, spoofing, and fraudulent assaults, may be obtained. The touchless palm design has various benefits, including cleanliness and touchless collecting. The SIFT technique is used in this suggested method to segment palm patterns. The SIFT method, invariant to the image's translation, rotation, and scaling, is employed in image recognition and matching. SIFT is used to estimate scale-space extrema with DOG (difference of Gaussian), identify core points, and remove low-contrast problems. The assignment of key point orientation is then carried out based on local image gradients. The amplitude and direction of the image gradient are then used to determine the image description for each key point.

• Obtain the desired picture

Utilizing the DOG function, determine the image's scale-space constraints and the location of the core point.

• Calculating descriptors for images.

Local extrema estimates for each key point (x,y) are provided as

$D(x, y, \sigma)=(G(x, y, \sigma)-G(x, y, \sigma)) * I(x, y)$             (6)

$D(x, y, \sigma)=L(x, y, s \sigma)-L(x, y, \sigma)$          (7)

where,

$L(x, y, \sigma)=G(x, y, \sigma)$               (8)

The scaling parameter is L(x, y), which indicates a Gaussian-smoothed image with a keypoint. By adding a Taylor series to the DOG scale-space function D(x, y), the interpolation for every key point is found.

$D(x)=D+\frac{\lambda D^T}{\lambda x}+\frac{1}{2} x^T \frac{\lambda^2 D}{\lambda x^2} x$          (9)

The image tilt One can calculate the direction θ(x,y) and magnitude m(x,y) as

$m(x, y)=\sqrt{\begin{array}{l}(L(x+1, y)-L(x-1, y))^{\wedge} 2 \\ +(L(x, y+1)-L(x, y-1))\end{array}}$           (10)

$\theta(x, y)=\tan ^{-1}\left(\frac{L(x, y+1)-L(x, y-1)}{(L(x+1, y)-L(x-1, y)}\right)$              (11)

Algorithm of SIFT:

4.3 Segmentation of hand gestures

Backgrounds are divided into two categories in this subsection: backgrounds that resemble skin and backgrounds that do not. To segment hand gestures on backgrounds that are not skin, we use SGM; for backgrounds that resemble skin, we use the SGM-Kmeans method.

88.png

Figure 8. Segmentation of gestures in non-skin backgrounds skin-like background using SGM and SGM K-Means

Skin color is one of the most noticeable physical characteristics of the human body, and its detection can be used to segment gestures. SGM is able to segment gestures from non-skin backgrounds as demonstrated in Figure 8, but it is unable to eliminate interference from backgrounds that resemble skin. Three different types of pixels can be seen in Figure 8(b)'s image after SMG segmentation: skin color, skin color background, and black background. Three types of pixels must be grouped together and skin-like overlap must be eliminated in order to segment skin-tone hand gestures on a skin-like background. Based on the results of experiments, the K-means algorithm is chosen to be 3, as Figure 8(c) illustrates, in order to effectively separate three different types of pixels and remove interference such as skin. To lessen the load on the data processing system during feature extraction and gesture classification, convert the segmented gesture image to a black and white image and scale it to 64×6464×64 pixels.

4.3.1 Deep convolutional neural networks classifier

Convolutional neural networks have been highly successful in recent visual identification tasks, including image categorization [5], object recognition [8], and scene analysis [10]. The deep learning based on CNN would be a strong contender for all image identification tasks. In contrast to current object detection, Saliency detection is commonly classified as a low-level problem in computer vision. Squeeze prediction must not understand what is within an image region but how it compares to neighbouring areas. The contrastive information concealed in multi-scale deep CNN features is thoroughly examined in this study, and a straightforward and effective neural network structure is suggested to determine the saliency score of each area. Hierarchical feature vectors appropriate for scene labeling are extracted using a multi-scale convolutional network. Before being fed to the three-level convolutional network, the Laplacian pyramid transforms the original input image into three scales. Each pixel's feature stack corresponds to the response of the same pixel in all convolutional layers. In contrast to the region-oriented functions utilized in our technique, the pixel-oriented parts do not emphasize region contrast, which is crucial for saliency detection.

A deep neural network (DNN) is employed to learn local patch characteristics, and we use these features to calculate the extrusion score for the centre pixel. Because we only consider local patches, the quality of the resulting extrusion maps is vulnerable to high-frequency background noise, which may cause homogenous regions inside extruded objects to be misclassified. A global search phase is implemented to take advantage of the intricate connections among globally squeezed cues conveyed using manual features. It is suggested to use an end-to-end deep contrastive network that takes fractional and pixel-wise saliency inference into account. It uses both the global and local context and incorporates them into a framework for collective deep learning to identify saliency. Their model gives each super pixel a crimp score. A super pixel’s local context is fixed to be one-third the size of the global context, the super pixel is centred on the context, and the global context's scope is comprised of the whole image:

The actual size of the surrounding environment affects how the local context is sized spatially. Given our local context, the contrast between each location and the background may be more accurately estimated.

Instead of straight regression, we provide an architecture for a neural network that can extract hidden contrastive information from connected multi-scale deep features. To address mistakes brought on by super pixels, we employ segmentation at multiple levels and CRF-based pixel-level refinement. According to experimental findings, the suggested approach performs better than any other CNN-based extrusion model.

4.4 Multiscale deep convolutional neural networks

We provide two ideas to improve the network design built on the aforementioned basic CNN architecture with three convolutional layers for sector sharpening: a multi-scale feature extraction block and skip connections. There are two sub-networks in the suggested MSDCNN. Examples of CNNs include a deep CNN with two multi-scale convolutional layered blocks and a straightforward 3-layer CNN with the same architecture. Figure 9 displays the whole MSDCNN architecture.

A deep neural network architecture called VGG-16 was pre-trained using a large ImageNet dataset. Convolutional and max-pooling layers, which steadily decrease the spatial dimension while increasing the number of channels, make up the VGG-16 backbone. To begin the feature extraction process, the model can make use of pre-trained weights that utilize information acquired from millions of images. This facilitates the capturing of common visual characteristics that are helpful for different image classification processes, such as HGR classification. Several convolutional layers that have been layered on top of the backbone model make up the CNN head. Such convolutional layers allow the architecture of the model to be tailored to extract characteristics at different sizes.

The higher layers at the top of the CNN capture more complex and abstract features, while the VGG16 layers closer to the input focus on learning low-level properties such as edges and textures. This distinction is vital for Hand Gesture Recognition (HGR) classification, as anomalies in images can appear with unusually large or complex shapes. Multi-scale feature maps enhance the model's ability to detect abnormalities of varying sizes, improving the overall accuracy of HGR classification. The VGG16 architecture consists of five blocks, with the core of the model processing an input image of 300×300 pixels. Blocks 1 through 5 of the VGG16 backbone help extract hierarchical features from the input image.

Each block contains a MaxPooling2D layer that reduces the size of the feature map and a Conv2D layer with increasing filter sizes. The first two blocks (Blocks 1 and 2) include two Conv2D layers (convX_1 and convX_2) and one MaxPooling2D layer (maxpoolX). For Block 1, the Conv2D layer outputs a size of 300×300×64, while Block 2’s Conv2D layer produces a size of 150×150×128. The MaxPooling2D layers output sizes of 150×150×64 and 75×75×128, respectively, effectively downsampling the feature map to reduce spatial dimensionality. The subsequent blocks (Blocks 3, 4, and 5) consist of three Conv2D layers (convX_1, convX_2, and convX_3) along with one MaxPooling2D layer (maxpoolX). The feature maps progressively shrink in spatial dimensions, with sizes of 75×75×256 (Block 3), 37×37×512 (Block 4), and 18×18×512 (Block 5). MaxPooling2D layers continue to downsample the feature maps, with output sizes of 37×37×256, 18×18×512, and 18×18×512.

The first active layer, conv4_3, used for HGR classification, has a spatial dimension of 38×38, which is significantly smaller than the input image. High-resolution feature maps greatly enhance the model's ability to identify fine edges and patterns in images. The CNN head, consisting of blocks 6 through 11, adds further convolutional layers, allowing the model to capture more intricate and abstract features from the HGR input images. As the Conv2D structure's spatial dimensions continue to decrease, the resolution of the feature maps progressively drops.

The feature map from Block 4 (conv4_3) is linked to the Concatenate layer, while the feature map from Block 5 (maxpool5) connects to Conv6, which has an output size of 18×18×1024. Conv6 is then connected to Conv7, followed by additional convolutional blocks (Conv8 through Conv11). Each of these blocks, consisting of two Conv2D layers, builds on the features extracted by the previous block. In the Conv8 block, the first layer (conv8_1) has an output size of 18×18×256, while the second layer (conv8_2) produces an output of 9×9×512. The output from conv8_2 is linked to the first layer of Conv9 (conv9_1), which has a size of 9×9×128, and the second layer (conv9_2) produces an output of 5×5×256. Conv9_2 connects to Conv10_1 (5×5×128), Conv10_2 (3×3×256), and Conv11_1 (3×3×128), completing the sequence.

99.png

Figure 9. Proposed multiscale deep convolutional neural networks (MSDCNN) model

4.5 Multi-scale feature extraction block

We use the open-source framework to train deep layers on the unprocessed ImageNet dataset and then fine-tune them for object recognition. Multi-scale characteristics are extracted from each visual area using artificial neural networks. This CNN has eight-layer architecture, with three fully linked layers and five convolutional layers. For features, take 4096 neurons make up the output of the second and final fully connected layer. However, autonomously generated CNN features are widely employed in several visual computing applications and are highly prevalent. For CNN feature extraction, CNN features are specified in areas such as the rectangle regions established and which are exclusively related to pixels. Image regions can have irregular forms, but we must extract CNN features from the square areas. The pixels outside the region are filled in, serving as the image's bounding box. The average pixel value of the same position across all ImageNet training images is used to fill the bounding box. After average subtraction, these pixel values become 0, which does not affect the outcomes. It is unknown if the region stands out about its neighbors and the rest of the image because Feature A does not offer information about the area around the considered image region. In order to add the region-surrounding property, which takes into account the understanding of neighborhood contrast, we extract a second feature vector from the rectangular neighborhood that acts as the bounding box for the inspected area and its neighbors. Within this enclosing box, all pixel values stay constant. Once more, after warping, this rectangle neighbor is sent into a deep CNN-a result of invoking CNN function B in a vector form.

1110.png

Figure 10. MSDCNN model's first layer

1111.png

(a) Fundamental convolution layer

1112.png

(b) A multi-scale feature convolutional layer

Figure 11. Multi-scale feature extraction layers

As we all know, how distinct (in terms a region's comparison to the remainder of the image (in terms of color and content) is a critical indicator in extrusion calculations. Another crucial indicator is where a particular visual section is located within the larger picture. We extract feature C from full-rectangular images to achieve these requirements using a deep CNN. The characteristics used to train and evaluate the extrusion model are collectively defined by these three feature vectors acquired at various sizes. The three CNN feature vectors are combined to create the final feature vector, giving S-3CNN its name, as shown in Figure 10 and Figure 11.

The classifications efficiently use the rich spatial information in high-resolution images, enhancing the feature extraction's resistance under various challenging ground conditions.

The nth layer multi-scale layer block's convolution kernels are configured with three sizes: 33, 55, and 77, as seen in Figure 11. N groups N are grouped for each dimension. The output is created by concatenating N functional maps along the kernel's spectral measurements.

4.6 Entropy Controlled Tiger Optimization

In this paper, we employ entropy values to alter the tiger optimization algorithm [17], which we refer to as entropy-controlled tiger optimization (ENcTO). A tiger approaches a target it wants to chase using the tiger optimization (TO) algorithm, and the tiger chases the target once it begins to run. The tiger always takes the shortest path in order to escape from its target. This new route leads to a place where the goal can be reached via an alternate route rather than the shortest route to it. To do this, common mistakes like taking a direct route to the destination must be eliminated, and the path can be modified based on the most recent experience. But if the target changes his mind, the tiger does too, and it takes the shortest path. Lastly, tigers can track their targets even if they run faster because they cover less ground than their targets. More importantly, the tiger will seek out and pursue a target whose behavior is dynamic (i.e., has parameter values that vary over time).

According to the Tiger Optimization (TO) algorithm, the target runs as the tiger approaches it, and the tiger chases after it in an attempt to catch up. The tiger will always choose the quickest path when it comes to escaping its prey. This new road is the point when there are alternative routes to reach the goal, not the shortest one. This may be achieved by removing typical mistakes (such taking the direct route to a goal) and adjusting the path based on the most recent experience. But if the target decides to alter course, the tiger will follow suit and go for the shortest path. Ultimately, despite running a lesser distance than the objective, the tiger was still able to follow it. Furthermore, the tiger will identify and pursue a prey whose behavior is dynamic that is, characterized by parameter values that vary over time.

They locate their prey and give birth to young tigers that are able to travel and possess all of their parents' memories. Tigers' speed won't slow down the system; instead, it will cause them to die of old age, become too weak to identify the best prey, or commit suicide as a result of overpopulation. Removing weak tigers from regions where they are abundant is another strategy to lower the population of tigers. In search of a better life, some children decide to change their ambitions and relocate at random. The technique seeks to identify the function's global and regional optimum values. Finding additional ideal values will be aided by adding more tigers to the population. This method lessens the influence on local values while increasing the possibility of discovering global values.

There are two categories of tigers in this metaphysical approach: male and female. Assume that there are ‘m’ men and ‘f’ women, despite the fact that m and f are initially equal. After locating their prey, they give birth to new tigers. These young tigers are capable of migrating to different regions and retain all of their parents' memories. Because of their rapidity, tigers will eventually grow old, become too numerous to successfully hunt, or commit suicide. The system will also be unable to slow down. Eliminating weak tigers from populated areas is another strategy to decrease the number of tigers. Certain cubs relocate at random to seek out better settlements and new targets. The goal of this approach is to locate a function's local and global optima. Finding a more ideal value will be aided by adding more new tigers. This technique lessens the influence on local values while increasing the likelihood of discovering global values. But once a tiger locates a good spot, it attacks to secure the best possible outcome. The Tiger algorithm stops searching and shows the best result when, at a given moment, it reaches the optimal outcome. TA [17] is distinct from other recent techniques since it doesn't call for population identification. In order to address improvements through births, migrations, deaths, and suicides, change populations by either removing existing tigers or breeding new ones. New tigers will be automatically created based on births and migrations if the current population of tigers is insufficient and nothing improves within the allotted time. The tiger will kill itself and commit suicide, though, if there is an excessive number of people present and the procedure is not carried out in a timely manner.

The distance between the target and the tiger determines TO. It will be challenging for a tiger to get to its target if it is far away. Distance is the inverse of two, as demonstrated by the equation below.

$D(a)=\frac{D 1}{a^2}$       (12)

In the given equation, a is the distance, D(a) is a function that represents the dispersion between tigers, and Dl is the distance parameter between the target and the estimated time. The formula for β, if it signifies the absorption coefficient between the tiger and the target, is as follows:

$D=D_p K^{-\beta \alpha}$           (13)

The distance between the tiger and the target, or D_p, is the primary parameter in this case. In order to prevent zero division in Eq. (14) two distinct formulas utilizing Gaussian discretization are applied:

$D(a)=D_p K^{-\beta a^2}$          (14)

The σ coefficient is used to represent the grip volume for a target. Thus:

$V=\varpi_p K^{-\beta a^2}$        （15）

In the case where a=0, $\varpi_p$ is gripping, using an alternative approximation:

$\bar{\omega}=\frac{\overline{\bar{\omega}}_p}{1+\beta a^2}$            (16)

The following is the formula for the separation between two tigers, l and m, located in al and am:

$d_{l m}=\left|a_l-a_m\right|=\sqrt{\sum_{r=1}^d\left(a_{l, r}-a_{m, r}\right)^2}$            (17)

where, so d_lm=√ (a_l−a_m)²+(b_l−b_m)², and a_l,r is the r^th element of the spatial coordinate of the l^th tiger in 2-Devent. The degree to which a tiger l is preoccupied with another, superior tiger m is shown as:

$a_l=a_l+\omega_p K^{-\beta a^2 i m}\left(a_l-a_m\right)+\varrho \tau_l$           (18)

The values of ϱ and τ_l for facilitation in Eq. (18) range from 0 to 1, and TA employs these values. At first, there are exactly equal numbers of male and female tigers. The algorithm is typically stopped by a few criteria, like the generation number, time, and other techniques. Every step in the process is intended to increase the number of tigers by a specific percentage in order to control the Ta population. In order to prevent them from staying in one place, tigers in the research site may first be constantly dispersed. A tiger cub is born when a female approaches a male tiger and is placed in an unpredictable spot. A tiger that folds simultaneously, whether male or female, always dies because it was weaker.

At each stage of this process, the search is initiated from the current region of the various search techniques. It is possible to detect points with larger object values more accurately by evaluating the range of steps towards each location using an inverse square law that is weighted by object value. Performance was assessed using error rate, with weighted KNN serving as the fitting function. Originality in optimization: A new function that removes uncertainty between specific TO features was designed by us, based on the information entropy equation. The formula below is first used to determine the information entropy value of a given vector:

$E\left(\alpha_l\right)=-\sum_{i=1} P\left(\alpha_{l i}\right) \log p\left(\alpha_{l i}\right)$             (19)

where, $\alpha_{l i}$ represents the feature value as of right now, E(αl) is the entropy value of the chosen TO-based feature vector, and （$\alpha_{l i}$） is the likelihood index of $\alpha_{l i}$. The following is how features are chosen using the generated entropy value:

$T=\left\{\begin{array}{l}\text { Fsel for } \alpha_{l i} \geq E\left(\alpha_l\right) \\ \text { Ignore, } \text { Elsewhere }\end{array}\right.$             （20）

The features that have been chosen and satisfy the entropy-based selection criteria are denoted by Fsel in the formula above. In order to calculate fitness, these features are sent to the fitness function. After selecting the features, an Extreme Learning Machine (ELM) classifier is tasked with performing the final classification. The output is a feature vector with a dimension of N×726.