Classification of breast cancer using a manta-ray foraging optimized transfer learning framework

Convolutional neural network (CNN)

Hinton invented the term “deep learning” in 2007 to describe machine learning models for high-level object representation, although it was not widely acknowledged until late 2012 (LeCun, Bengio & Hinton, 2015). Deep learning gained prominence in the field of computer vision after a deep learning technique based on a convolutional neural network (CNN) won the most well-known computer vision competition, ImageNet (Krizhevsky, Sutskever & Hinton, 2012). CNN is a deep learning system inspired by the human brain’s visual cortex and seeks to mimic human visual function (Sarvamangala & Kulkarni, 2021). CNN is a significant advancement in image comprehension, including image classification, segmentation, localization, and detection. The fundamental reason for CNNs’ extensive adoption is their efficiency in image recognition. The CNN takes an image as input and produces classification categories such as cancer or non-cancer. Local shift-invariant interconnections connect the layers. CNN is a multi-layer generative graphical model that employs pixel values in images as input information rather than features generated from segmented objects, obviating the need for feature calculation or object segmentation. CNNs, like human neurons, are made up of convolutions with learnable weights and biases. Convolutional layers, activation functions, pooling, and fully-connected layers are the primary building blocks of CNNs, as depicted in Fig. 1.

Transfer learning

Training and testing data should be in the same feature space, according to a key idea in many machine learning (ML) algorithms. This hypothesis, however, may not hold true in various real-world applications. For example, there are instances where training data is prohibitively expensive or difficult to obtain (Baghdadi et al., 2022). As a result, high-performance classifiers trained using increasingly available data from different domains are required. This strategy is known as transfer learning (TL) (Agarwal et al., 2021). When the target domain has limited data, but the source domain has a large dataset, TL performs brilliantly. The process of obtaining information from a source domain DS that contains a learning task TS and applying that knowledge to enhance a learning task TT is informally described as TL. In a target domain, DT, where DS is not the same as DT or TS is not the same as TT (Zhuang et al., 2020; Iman, Rasheed & Arabnia, 2022).

CNN architectures

This section highlights the CNN architectures pre-trained to perform transfer learning. Among several designs, InceptionV3, Xception, EfficientNetB7, NASNetLarge, VGG19, SeNet154, DenseNet201, and ResNet152V2 are discussed since they were used in this work.

InceptionV3:

With transfer learning, InceptionV3 achieved high classification accuracy in numerous biomedical applications (Ashwath Rao, Kini & Nostas, 2022; Al Husaini et al., 2022). The symmetric and asymmetric construction components of the InceptionV3 model include convolutions, average pooling, max pooling, concatenations, dropouts, and fully connected layers (Szegedy et al., 2016). Batch normalization is employed frequently throughout the model and for activation inputs. In addition, InceptionV3 employs Softmax to compute Loss, Max-pooling for spatial pooling, and FC for final classification.

Xception:

Xception, which stands for Extreme version of Inception, was proposed as an expansion of the Inception architecture that was fully built on depth-wise different convolutions rather than conventional convolutions (Chollet, 2017). The use of depth-wise distinct convolutional layers in the CNN network simplifies network computations. This aids in learning the efficient features from images and improves model performance.

EfficientNetB7:

The core building component of EfficientNet architecture is Mobile Inverted Bottleneck Convolution (MBConv) (Sandler et al., 2018). The number of these MBConv chunks varies within the EfficientNet network family. From EfficientNetB0 through EfficientNetB7, depth, breadth, resolution, and model size increase, as does accuracy. In terms of ImageNet accuracy, EfficientNetB7, outperforms prior state-of-the-art CNNs (Tan & Le, 2019). Parameters like filter size, stride, and channel count divide the network architecture of EfficientNetB7 into seven blocks. As a result, EfficientNet is a popular image classification and segmentation tool.

NASNetLarge:

The neural architecture search techniques develop the Neural Architecture Search Network Large (NASNet-Large) (Zhang, Wu & Zhu, 2018). It comprises two types of layers or cells: Normal Cells and Reduction Cells. The Reduction Cell decreases the width and height of the feature map along the forward route, whereas the Normal Cell keeps these two dimensions the same as the input feature map. Each Normal/Reduction Cell is made up of several blocks. Each block is constructed from a series of popular deep CNN operations with varying kernel sizes.

VGG19:

The VGG-19 deep learning algorithm is a 16-layer network with three FC layers (Simonyan & Zisserman, 2014). Maxpool, FC, Relu, dropout, and softmax layers are among the 41 total layers. VGG tackled the large-size filter impact by replacing it with a stack of (3times3) filters. However, the calculation complexity is increased by using small-size filters.

SeNet154:

Squeeze-and-Excite Networks provide a building element for CNNs that improves channel interdependencies at nearly no computational cost (Hu, Shen & Sun, 2018). Aside from providing a significant speed improvement, they are also simple to include in current systems. The Squeeze and Excitation Network, in essence, proposes a novel channel-wise attention mechanism for CNNs in order to improve their channel interdependencies. They learn to use global information, boosting advantageous features while ignoring others.

DenseNet201:

Dense convolution network (DenseNet) is a pre-trained deep learning model that employs feedforward to connect each layer to all subsequent levels (Huang et al., 2017). A feature map is included in each layer of the model. The feature map of each layer serves as the input for the following layer. It allows optimum information transfer inside the network by connecting all levels directly. DenseNet’s key benefits are that it drastically reduces the number of parameters, reduces gradient runaway, improves feature diffusion, and encourages feature reuse.

ResNet152V2:

A Residual Network (ResNet) is a CNN architecture composed of several convolutional layers. Previous CNN configurations reduced additional layers’ efficiency. As a result, ResNet has many layers and is highly performant (He et al., 2016). The main difference between ResNetV2 and the previous (V1) is that, before adding a weight layer, V2 performs batch normalization on it. Consequently, ResNet performs well in image recognition, illustrating the significance of a wide range of visual recognition tasks.

Metaheuristic optimization

Optimization is a critical procedure for making the best use of various resources. It is a necessary step in any field of study. Several strategies have been developed to address various optimization challenges (Meraihi et al., 2021). Each algorithm employs a particular acceptable technique for certain problems and efficiently solves them while being ineffective for others (Abualigah et al., 2022). However, the vast majority of them fall into one of two groups. The conventional approaches, such as gradient descent and Newton (Wang et al., 2021), fall under the first category. These approaches are basic and straightforward in general, but they only yield a single solution every iteration, which is time-consuming. The strategies in the second category, known as metaheuristic (MH), tend to escape the limits of traditional methods (Alshinwan et al., 2021). Nowadays, MH optimization methods are highly appealing due to their particular benefits over traditional algorithms. MH is used to identify high-quality solutions to a wider range of challenging real-world scenarios since it can handle multi-objective multi-modal, and nonlinear formulations. These MH strategies are generally inspired by nature, physics principles, and human behavior. The primary classes of MH include natural phenomena-based, swarm-based, human-based, and evolutionary-based techniques (Abualigah et al., 2022). Natural phenomena-based approaches imitate natural phenomena such as spirals, rain, wind, and light (Ewees et al., 2021; Şahin, Dinler & Abualigah, 2021). The swarm-based methods mimic the behavior of animals, birds, fish, and other swarms when they are looking for food (Sharma & Kaur, 2021; Zhao, Zhang & Wang, 2020). As optimization methods, human-based methods mimic human behavior (Moosavi & Bardsiri, 2019; Khishe & Mosavi, 2020). Finally, the mechanism of evolutionary-based approaches is inspired by emulating the notions of natural genetics, which is employed to replicate the principle of natural genetics (Tzanetos & Dounias, 2021; Bentéjac, Csörgo & Martnez-Muñoz, 2021). These approaches rely on the operators’ crossover, mutation, and natural selection.

Phase 1: dataset acquisition

The datasets used in this study were obtained from two publicly available datasets on Kaggle. In summary, the current study depends on two different types of modalities. The first is the histopathological slides, while the second is the ultrasound records. The first dataset, Breast Cancer Dataset (BreaKHis) (Elmasry, 2021), is partitioned into two classes: “Benign” and “Malignant” where each category included 2,479 and 5,304 images respectively. The second dataset, US images data (Fouad, 2021), is divided into three categories: “Benign,” “Malignant,” and “Normal,” with 437, 210, and 133 images in each. The “Normal” class includes cases where there is no tumor while the “Benign” class includes cases where there is a tumor but is considered benign.

In both datasets, data augmentation is used prior to training to up-sample and equalize the number of images per category. After equalization, the first dataset contained 10, 608 images, with each class containing 5, 304 images. Besides, the second dataset contained 1, 311 images, with 437 images in each class. The specifications of the datasets used are summarized in Table 1.

Phase 2: dataset pre-processing

The second phase pre-processes the datasets by applying four techniques. They are image resizing, dimensional scaling, and data balancing.

Image Resizing: The used images are not equal in their dimensions. As a result, in the RGB mode, a bicubic interpolation resizing technique should be used to the size of (128 × 128 × 3).

Dimensional Scaling: It utilizes four different scaling techniques, namely (1) normalization, (2) standardization, (3) min-max scaling, and (4) max-abs scaling. The equations underlying them are shown in Eqs. (1)–(4) respectively where X represents RGB image, X_output is the output scaled image, µis the image’s mean, σ is the standard deviation of the image. (1)${\displaystyle X_{output}=\frac{X}{max\left(X\right)}}$ (2)${\displaystyle X_{output}=\frac{X-\mu }{\sigma }}$ (3)${\displaystyle X_{output}=\frac{X-min\left(X\right)}{max\left(X\right)-min\left(X\right)}}$ (4)${\displaystyle X_{output}=\frac{X}{|max\left(X\right)|}}$

Dataset Balancing: The dataset is imbalanced, which can enhance the misclassification or overfitting in the training and optimization process. To eliminate this issue, a data balancing technique should be utilized. The current study employs data augmentation techniques. They use shifting (width and height), shearing, rotation, flipping (horizontal and vertical axes), zooming, and brightness changes. Table 2 depicts the different utilized data augmentation techniques and their configurations.

Data Splitting: There are three subsets in the dataset: training, testing, and validation. The current study employs an 85% to 15% ratio. Initially, the entire dataset is divided into training and testing subsets based on the defined ratio. Finally, the training subset is divided into training and validation subsets based on the same defined ratio.

Phase 3: classification and optimization

The current phase optimizes the various transfer learning hyperparameters using the MRFO metaheuristic population-based optimizer (e.g., dropout ratio, data augmentation appliance, and scaling technique). The proposed mechanism seeks the best configurations for each pre-trained transfer learning CNN model. This phase implements three internal processes and repeatedly runs for a number of iterations equals T_max. The processes are: (1) randomly create the initial population, (2) calculate the fitness function for each solution in the population sack, and (3) update the population concerning the MRFO equations. The process is summarized in Fig. 3 and discussed in detail in the current subsection.

Initially, the MRFO population sack is randomly created once at the beginning of the classification and optimization phase. The number of solutions is N_max and set to 10 in the current study. Each solution from the population sack is a vector with a size of (1 × D) where each element ∈[0, 1]. Each cell in a solution reflects a specific learning hyperparameter (e.g., dropout ratio and batch size). The current study targets to improve 15 hyperparameters as shown in Table 3. The solution indexing (starting from 1 to 15) and the corresponding hyperparameters definitions and ranges are presented in it. If data augmentation is applied, D = 15 and if not, D = 7.

After that, the fitness (i.e., objective) function score of each solution in the population sack is calculated. The objective function consists of three inner steps: (1) hyperparameters mapping, (2) model creation and preparation, and (3) model training and evaluation. The hyperparameters mapping step maps the solution into the corresponding actual hyperparameters as defined in Table 3. How does the hyperparameters mapping happen internally? A simple calculation is utilized to map the random numbers to the values of the corresponding hyperparameters. This can be done using Eq. (5). For example, if it is required to convert the model dropout ratio (i.e., the third element) from the solution numeric value to the corresponding hyperparameter. The range of the model dropout ratios to select from should be determined first (the current study uses the “ [0 → 0.6]” range). Then, from Eq. (5), if the random numeric value is 0.85 and we have a range from 0 to 0.6, then the value is 0 + 0.85 × (0.6 − 0) = 0.51. (5)${\displaystyle \text{Value}=\text{Lower Bound}+\text{Solution}\left[\text{Element Index}\right]\times \left(\text{Upper Bound}-\text{Lower Bound}\right).}$

The target pre-trained transfer learning model is created and compiled with these mapped hyperparameters after mapping each element in the solution to the corresponding hyperparameters. The current study uses the MobileNet, MobileNetV2, MobileNetV3Large, VGG16, VGG19, Xception, DenseNet201, and NASNetMobile pre-trained transfer learning CNN models. Their initial weights (i.e., parameters) are set with the “ImageNet” pre-trained weights. The pre-trained transfer learning model will start the training process for a number of epochs set to 5 in the current study. After the learning (i.e., training), the pre-trained transfer learning model is evaluated on the whole dataset for validation and generalization purposes. The model’s performance is assessed based on different metrics (e.g., precision, accuracy, recall, and F1-score). This study uses a variety of performance metrics illustrated in Eqs. (6) to (11). (6)${\displaystyle \text{Accuracy (ACC)}=\frac{TP+TN}{TP+TN+FP+FN}}$ (7)${\displaystyle \text{Precision (P)}=\frac{TP}{TP+FP}}$ (8)${\displaystyle \text{Specificity (S)}=\frac{TN}{TN+FP}}$ (9)${\displaystyle \text{Recall (R)}=\text{Sensitivity}=\frac{TP}{TP+FN}}$ (10)${\displaystyle \text{Dice Coef (DC).}=\frac{2\times TP}{2\times TP+FP+FN}}$ (11)${\displaystyle \text{F1-score}=\frac{2\times \text{Precision}\times \text{Recall}}{\text{Precision}+\text{Recall}}.}$

TP represents the true positive, TN indicates the true negative, FN represents the false negative, and FP indicates the false positive. After calculating the performance metrics for each solution, the population solutions are sorted in descending order concerning the objective function score. In other words, the best solution is located at the top to determine X_best, which is used throughout the process. After that, the population is updated using the MRFO equations. The MRFO works on two branches: cyclone foraging (Eq. (12)) and chain foraging (Eq. (13)). To determine which path to follow, a random value (∈[0, 1]) is generated, and the first branch is followed if the generated random value <0.5 and the second branch is followed otherwise. After updating the solution using either path, each solution’s fitness function is reevaluated again, and X_best is redetermined. After that, somersault foraging (Eq. (14)) is performed. Again, each solution’s fitness function is reevaluated, and X_best is redetermined. (12)${\displaystyle X_i\left(t+1\right)=\left\{\begin{array}{cc}{X}_{rand}+r\times \left(X_{rand}-X_i\left(t\right)\right)+\beta \times \left(X_{rand}-X_i\left(t\right)\right),\hfill & \text{if}\left(\left(\frac{t}{T_{max}}<rand\right)\&\left(i=1\right)\right)\hfill \\ X_{rand}+r\times \left(X_{i-1}\left(t\right)-X_i\left(t\right)\right)+\beta \times \left(X_{rand}-X_i\left(t\right)\right),\hfill & \text{if}\left(\left(\frac{t}{T_{max}}<rand\right)\&\left(i>1\right)\right)\hfill \\ X_{best}+r\times \left(X_{best}-X_i\left(t\right)\right)+\beta \times \left(X_{best}-X_i\left(t\right)\right),\hfill & \text{if}\left(\left(\frac{t}{T_{max}}\ge rand\right)\&\left(i=1\right)\right)\hfill \\ X_{best}+r\times \left(X_{i-1}\left(t\right)-X_i\left(t\right)\right)+\beta \times \left(X_{best}-X_i\left(t\right)\right),\hfill & \text{if}\left(\left(\frac{t}{T_{max}}\ge rand\right)\&\left(i>1\right)\right)\hfill \\ \hfill \end{array}\right.}$ (13)${\displaystyle X_i\left(t+1\right)=\left\{\begin{array}{cc}{X}_i\left(t\right)+r\times \left(X_{best}-X_i\left(t\right)\right)+\alpha \times \left(X_{best}-X_i\left(t\right)\right),\hfill & \text{if}\left(i=1\right)\hfill \\ X_i\left(t\right)+r\times \left(X_{i-1}\left(t\right)-X_i\left(t\right)\right)+\alpha \times \left(X_{best}-X_i\left(t\right)\right),\hfill & \text{Otherwise}\hfill \\ \hfill \end{array}\right.}$ (14)${\displaystyle X_i\left(t+1\right)=X_i\left(t\right)+S\times \left(r_2\times X_{best}-r_3\times X_i\left(t\right)\right)}$

where X_i(t) is the ith solution at iteration t, t is the current iteration number, r is a random number ∈[0, 1], β and α are weight coefficients, and S is the somersault factor, r₁ is a random number ∈[0, 1], and r₂ is a random number ∈[0, 1]. Algorithm 1 explains how the population (that is, solutions) is updated using MRFO metaheuristic optimization.

 
 
 Algorithm 1: The population (i.e.,  solutions) updating process using the MRFO 
  metaheuristic optimizer                                                                                 ____ 
  1  Function UpdateMRFOSolu- 
     tions(solutions,scoresList,model,trainX,trainY,validationX,validationY,testX,testY ) 
      // Sort the population scores. 
  2  SortMRFOSolutions(solutions,scoresList)                       // Sort the scores list in descending order. 
  3  bestSolution,bestScore = ExtractFromSolutions(solutions,scoresList)    // Extract the best solution 
      and score. 
      // Start the updating process using MRFO equations. 
  4  i = 1                                                              // Initialize the manta-ray’ counter where i ≤ Nmax. 
  5  while (i ≤ Nmax) do 
       6    if (rand < 0.5) then 
        // The cyclone foraging process (Equation 12). 
7    if (t/Tmax < rand) then 
8    randSolution = xL + rand × (xU − xL) 
9    if (i == 1) then 
   // Apply this equation if the current solution is the first one. 
10    solutions[i] = 
    randSolution + r × (randSolution − solutions[i]) + β × (randSolution − solutions[i]) 
11    else 
   // Apply this equation if the current solution is not the first one. 
12    solutions[i] = 
    randSolution+r×(solutions[i − 1] − solutions[i])+β×(randSolution − solutions[i]) 
13    else 
14    if (i == 1) then 
   // Apply this equation if the current solution is the first one. 
15    solutions[i] = 
    bestSolution + r × (bestSolution − solutions[i]) + β × (bestSolution − solutions[i]) 
16    else 
   // Apply this equation if the current solution is not the first one. 
17    solutions[i] = 
    bestSolution + r × (solutions[i − 1] − solutions[i]) + β × (bestSolution − solutions[i]) 
18    else 
        // The chain foraging process (Equation 13.) 
19    if (i == 1) then 
   // Apply this equation if the current solution is the first one. 
20    solutions[i] = 
    solutions[i] + r × (bestSolution − solutions[i]) + α × (bestSolution − solutions[i]) 
21    else 
   // Apply this equation if the current solution is not the first one. 
22    solutions[i] = 
    solutions[i] + r × (solutions[i − 1] − solutions[i]) + α × (bestSolution − solutions[i]) 
23    i = i + 1                                                                                        // Increment the counter. 
 24  i = 1                                                              // Initialize the manta-ray’ counter where i ≤ Nmax. 
 25  newScoresList = []                                                                              // Initialize the scores list.  
 26  while (i ≤ Nmax) do 
       27    score = CalculateFitnessScore (model,solutions[i],trainX,trainY,validationX,validationY ) 
    // Calculate the fitness score (i.e., accuracy) for the current solution. 
28    if (score > bestScore) then 
     29    bestScore = score 
30    bestSolution = solutions[i] 
31    i = i + 1                                                                         // Increment the manta-ray’ counter. 
      // The somersault foraging process (Equation 14). 
 32  i = 1                                                              // Initialize the manta-ray’ counter where i ≤ Nmax. 
 33  while (i ≤ Nmax) do 
       34    solutions[i] = solutions[i] + S × (r2 × bestSolution − r3 × solutions[i]) i = i + 1    // Increment the 
    counter. 
 35  i = 1                                                              // Initialize the manta-ray’ counter where i ≤ Nmax. 
 36  newScoresList = []                                                                              // Initialize the scores list. 
 37  while (i ≤ Nmax) do 
       38    score = CalculateFitnessScore (model,solutions[i],trainX,trainY,validationX,validationY ) 
    // Calculate the fitness score (i.e., accuracy) for the current solution. 
39    if (score > bestScore) then 
     40    bestScore = score 
41    bestSolution = solutions[i] 
42    i = i + 1                                                                         // Increment the manta-ray’ counter. 
 43  return solutions                                                           // Return the updated population 
 44  End Function    

The proposed framework steps

Iteratively, the steps are computed over a maximum number of iterations T_max. The optimization iterations used the MRFO; the best possible model combination can then be applied to any further analysis, such as the production mechanism as prescribed in the framework. Finally, algorithm 2 summarizes parameter learning and hyperparameter optimization.

 
 
  Algorithm 2: The suggested framework pesudocode                                          ____ 
    Input: model, dataset                                 // The required model name and the dataset records 
      Output: best,bestScore                                               // The best overall score and solution 
  1  trainX,validationX,testX,trainY,validationY,testY = SplitDataset (dataset)          // Partition the 
      dataset into training, testing, and validation portions concerning the defined split ration. 
  2  model = CreateTLPretrainedModel()    // Create the initial transfer learning pre-trained CNN model. 
  3  solutions = GenerateInitialSolutions()                            // Generate the initial solutions randomly. 
      // Execute the learning MRFO hyperparameters optimization process for Tmax iterations. 
  4  t = 1                                                                // Initialize the iterations’ counter where t ≤ Tmax. 
  5  while (t ≤ Tmax) do 
          // Calculate the scores for each solution in the population sack. 
6    i = 1                                                            // Initialize the MRFO’s counter where i ≤ Nmax. 
7    scoresList = []                                                                              // Initialize the scores list. 
8    while (i ≤ Nmax) do 
     9    score = 
    CalculateFitnessScore (model,solutions[i],trainX,trainY,validationX,validationY,testX,testY ) 
    // Calculate the objective function score (i.e., accuracy) for the current solution. 
10    Append(score,scoresList)                                    // Calculate the score into the scores list. 
11    i = i + 1                                                                      // Increment the MRFO’s counter. 
    // Update the population using MRFO (Algorithm 1). 
12    solutions = 
    UpdateMRFOSolutions(solutions,scoresList,model,trainX,trainY,validationX,validationY,testX,testY ) 
13    t = t + 1                                                                          // Increment the iterations counter. 
 14   best,bestScore                                     // Return the best score and the corresponding solution    

Experiments with the binary dataset

Table 5 summarizes the configurations of the binary dataset. Table 6 displays the confusion matrix results concerning the binary dataset and the best solutions for each pre-trained model after learning and optimizing the model. Based on these results, the Xception model represents the lowest FP and FN values. However, EfficientNetB7 has the highest values for FP and FN.

A list of the best solution combinations is presented in Table 7. According to the analysis, five different models recommend using the KLDivergence loss. Moreover, the Nesterov-based models are recommended by three models. Three models recommend the min-max scalers. Different performance metrics can be derived by combining the values reported in Table 6 and the learning history. There are two types of metrics presented.

The first set of metrics represents those that need to be maximized (e.g., Acc, F1-score, P, Sensitivity, Recall, S, AUC, IOU, Dice, and Cosine Similarity). The second one indicates the metrics that must be minimized (e.g., Logcosh Error, Mean Absolute Error, Mean Squared Error, Mean Squared Logarithmic Error, and Root Mean Squared Error). Table 8 reports category metrics for the first category while Table 9 reports metrics for the second category. It is obvious that the Xception pre-trained model is superior to others when it comes to the classification of two-classes datasets. There is no difference between Recall and Sensitivity regarding results or formulas.

Three-classes dataset experiments

The three-class dataset is summarized in Table 10. According to Table 11, the TP, TN, FP, and FN of the best solutions are available after learning and optimizing each pre-trained model. According to the results, the ResNet152V2 pre-trained model has the lowest FP and FN values. Conversely, EfficientNetB7 has the highest FP and FN values. Table 12 shows the optimal combination of each model. This study shows that five models recommend Categorical Cross entropy Loss. Three models recommend standardization, and four recommend normalization scalers. Three models recommend Adam as an optimizer. Seven models recommended performing data augmentation, with six recommending vertical flipping and five recommending horizontal flipping.

Different performance metrics can be derived from the values provided in Table 11 and the learning history. There are two types of metrics reported. The first aspect shows the metrics that need to be maximized (i.e., Acc, F1-score, P, Sensitivity, Recall, S, AUC, IoU, DC, and Cosine Similarity). On the other hand, the second represents the metrics that must be minimized (namely, Logcosh Error, Mean Absolute Error, Mean Squared Error, Mean Squared Logarithmic Error, and Root Mean Squared Error). Table 13 reports on category metrics for the first category, while Table 14 reports on category metrics for the second category. Compared to others, the ResNet152V2 pretrained model is the best when considering the dataset with three classes. Both Recall and Sensitivity reflect the same results and formulas.

Graphical summarizations

Based on the experiments conducted on the suggested approach, Fig. 4 shows the best combination of different alternatives.

As shown in Figs. 5 and 6, confusion matrices are presented for two-classes and three-class datasets, respectively.

A graphical summary of the reported learning and optimization results is presented in Figs. 7 and 8, respectively, using two- and three-class datasets.

Related studies comparisons

The proposed approach is compared with other state-of-the-art approaches in Table 15. It compares the whole systems as black boxes. In comparison to related studies, the present study has demonstrated superior results.