Gaussian Mutation–Spider Monkey Optimization (GM-SMO) Model for Remote Sensing Scene Classification

Abstract

Scene classification aims to classify various objects and land use classes such as farms, highways, rivers, and airplanes in the remote sensing images. In recent times, the Convolutional Neural Network (CNN) based models have been widely applied in scene classification, due to their efficiency in feature representation. The CNN based models have the limitation of overfitting problems, due to the generation of more features in the convolutional layer and imbalanced data problems. This study proposed Gaussian Mutation–Spider Monkey Optimization (GM-SMO) model for feature selection to solve overfitting and imbalanced data problems in scene classification. The Gaussian mutation changes the position of the solution after exploration to increase the exploitation in feature selection. The GM-SMO model maintains better tradeoff between exploration and exploitation to select relevant features for superior classification. The GM-SMO model selects unique features to overcome overfitting and imbalanced data problems. In this manuscript, the Generative Adversarial Network (GAN) is used for generating the augmented images, and the AlexNet and Visual Geometry Group (VGG) 19 models are applied to extract the features from the augmented images. Then, the GM-SMO model selects unique features, which are given to the Long Short-Term Memory (LSTM) network for classification. In the resulting phase, the GM-SMO model achieves 99.46% of accuracy, where the existing transformer-CNN has achieved only 98.76% on the UCM dataset.

1. Introduction

Remote sensing images have a higher resolution from the advancement of imaging technology. Remote sensing images are used in many fields such as environmental monitoring, land use classification, change detection, image retrieval, and object detection. The remote sensing image scene classification task aims to classify the scene into remote sensing images based on semantic information, which is highly useful in practical applications [1]. Remote sensing image scene classification attracts many researchers due to its wide applications. Deep learning performs well for remote sensing scene classification for each category that has a sufficient number of labeled images [2]. Scene classification provides the accurate classification of satellite images and this is an essential problem in remote sensing images for a correct category such as farm, highway, river, and airplane for unlabeled images that are applied to interpretation tasks such as land resource management, residential planning, and environmental monitoring. Remote sensing scene classification has higher image resolution than natural images, different target orientations, dense distribution, and small target objects [3]. Remote sensing scene classification is considered an assigned task for the specific semantic label of the remote sensing scene. This is used in a wide range of practical applications such as land use classification, natural disaster detection, environment prospecting, and urban planning [4,5].

In deep learning technology, Convolutional Neural Network (CNN) models provide efficient classification performance in various fields [6,7,8,9,10,11,12,13]. Common techniques of low-level feature extraction or hand-crafted features are structure, texture, spectrum, and color or combination of features to distinguish remote sensing images. Most representative feature descriptors such as SIFT, texture features, and color histograms are among the hand-crafted features. The low-level feature extraction performs better in remote sensing images for spatial arrangements and uniform structures that has limited performance in remote sensing images of semantic information [14,15]. Deep learning technique automatically extracts global features or high-level features for better learning of the input images. Recently, deep CNN methods have become the state-of-art model for remote sensing classification, yet they still have some limitations [16]. The existing CNN models have limitations of imbalanced data problem, overfitting and lower efficiency in classify similar images [17,18]. The contribution and objectives of this study are discussed in this research:

• Proposed GM-SMO to select the unique features from the extracted features that reduce the overfitting and imbalanced data problem. The GM-SMO model change the position of solution after exploration to increases the exploitation.
• Implemented GAN model is for augmentation of minority class and reduce the imbalanced data problem. The GAN model helps to distinguish the features for the objects and selects the unique features.
• The AlexNet and VGG19 models are used to extract high-level deep features from the input images. The deep features provide detailed information about the images that helps to achieve better classification. Further, the GM-SMO model balances exploration and exploitation ability of the model to further improve classification performance.

This paper is organized as follows: a literature survey of scene classification is given in Section 2 and the explanation of the GM-SMO model is given in Section 3. The simulation result is given in Section 4 and the result is given in Section 5. The conclusion is given in Section 6.

2. Literature Survey

The scene classification technique is helpful for many practical applications such as land utilization and planning. CNN-based models were widely applied for scene classification techniques and show considerable performance. Some of the recent CNN models in scene classification were surveyed in this section.

Xu et al. [19] applied a graph convolutional network using a deep feature aggregation technique named DFAGCN for scene classification. The pre-trained CNN model is applied for extracting multi-layer features and a graph CNN model was applied to effectively reveal convolutional feature maps. A weighted concatenation technique was applied to introduce three weighting coefficients to integrate multiple features. The graph CNN model has lower efficiency due to overfitting and imbalanced data problems. Bazi et al. [20] applied a vision transformer for scene classification in remote sensing and this is considered a state-of-art model in NLP as in the standard CNN model. Multi-head attention technique was applied as the main building block to extract information. Images in the patches were divided and flattening-embedding was used to keep the information. The first token sequence was applied to a softmax classification and several data augmentation technique was applied to generate more data for training. The overfitting problem occurs due to the generation of more features in a convolutional layer.

Alhichri et al. [21] applied a deep CNN model for remote sensing scene classification. CNN model learns feature maps from larger regions of scene and feature map was computed in attention technique as a weighted average of feature maps. The EfficientNet-B3-Attn-2 was pre-trained CNN enhanced with attention technique. The weights are measured in the network using a dedicated branch. This model requires a greater number of images for training and has an overfitting problem. Ma et al. [22] applied a multi-objective model for scene classification named as SceneNet. Hierarchical optimization technique was applied to implement a more flexible search and coding process in remote sensing scene classification. Multi-objective optimization technique was applied to balance the performance error and computational complexity based on the Pareto solution set. The optimization technique has the limitation of local optima trap and overfitting in classification.

Zheng et al. [23] addresses the dilemma and applies multiple small-scale datasets for model generalization learning for efficient scene classification. A Multi-Task Learning Network (MTLN) was applied for training a network and handling heterogeneous data. The MTLN model considers each small dataset as an individual task and complementary information was used to improve generalization. The MTLN model has an imbalanced data problem and lower efficiency in handling the feature selection. Xu et al. [24] applied a Global Local Dual Branch Structure (GLDBS) using image discriminative features for various levels of fusion that was applied to improve performance on scene classification. CNNs model generate energy map to transform binary image to obtain a connected region. A dual branch network was constructed for CNN based models and the model was optimized using joint loss. The GLDBS model has lower efficiency in learn discriminative features and misclassification is occurring in more similar categories.

Tang et al. [25] applied an attention consistent network (ACNet) using Siamese network for remote sensing scene classification. The ACNet dual branch structure retrieves spatial rotation from image pairs of the input data and this helps to fully explore global features. The attention technique was introduced to mine the feature information from input images. The spatial rotation and similarities influences are considered in an attention model to unify the salient features. Bi et al. [26] applied Local Semantic Enhanced ConvNet (LSE-Net) for remote sensing scene classification. The LSE-Net model consists of discriminative representation and a convolutional feature extractor. A multi-scale convolution operator was combined with convolution features of multi-scale and multi-level for feature representation. The ACNet and LSE-Net models has an overfitting problem due to the generation of more features in the convolutional layer.

Cheng et al. [27] applied Inter Calibration (IC) and Self Calibration (SC) named as Siamese-Prototype Network (SPNet) for remote sensing scene classification. The support labels were used for supervised information to provide relevant features for classification. The three losses were used to optimize the model; one loss was used to learn feature representation, and thus provide an accurate prediction. The model has lower efficiency due to the overfitting problem and imbalanced data problem. Shamsolmoali et al. [28] applied a rotation equivalent feature pyramid network named REFIPN for remote sensing scene classification. The single shot detector was applied in the pyramid module for feature extraction and an optimization technique was applied to generate regions of interest. The model has lower efficiency due to overfitting and imbalanced data problem in classification.

Li et al. [29] applied Multi-Attention Gated Recurrent Network (MA-GRN) for remote sensing scene classification. Network multiple stages use features of local texture features and deep layers’ global features. Spatial sequences were used for features and applied to GRU to capture long range dependency. The MA-GRN model has lower efficiency in classifying small objects and on imbalanced datasets. Zhang et al. [30] applied a combination of transformers and the CNN model for remote sensing scene classification. The self-attention was applied in ResNet model based on the Multi-Head Self-Attention model using spatial revolutions of $3\times 3$ in bottleneck. The transformers are encoded to improve the feature representation based on attention. The transformer and CNN model have overfitting problems due to the generation of more features in the convolutional layer. In order to address the aforementioned concerns, a new model is proposed in this manuscript for effective remote sensing scene classification.

3. Proposed Method

The GAN model is applied to three datasets such as UCM, AID, and NWPU45 to augment images in minority classes. The AlexNet and VGG19 models were applied to extract the features from input images. The GM-SMO model is applied to extracted features to select relevant features for classification. The overview of GM-SMO model in scene classification is shown in Figure 1.

3.1. Dataset Description

The proposed model’s performance is analyzed on three benchmark datasets such as UCM, AID, and NWPU45. The AID includes 10,000 images with pixel size of $600\times 600$ and 0.5 to 8 m resolution, and it includes 30 classes. Correspondingly, the UCM dataset contains 2100 images with pixel size of $256\times 256$ and resolution of 0.30 m, and it includes 21 classes. Additionally, the NWPU45 dataset comprises 31,500 images with pixel size of $256\times 256$ and resolution of 0.2–30 m. The NWPU45 dataset covers more than 100 nations’ geo-locations and has 45 classes. The sample images of UCM, AID, and NWPU45 are represented in Figure 2, Figure 3 and Figure 4.

3.2. Generative Adversarial Network (GAN)

A generative model-specific framework is GANs. The generative model learns data distribution $p_{data}$ from samples set $x^1,\dots ,x^m$ (images) to generate new images based on learned data distribution. GANs model and its variants are used for generating labeled images: one part of the model involves learning the objects in the images based on class, separately, and the other involves class related to labeled classes.

The first variant of GAN is Deep Convolutional GAN (DCGAN). Radford et al. [31] proposed the architecture for both G and D networks of deep CNNs. This provides architectural steps for stable training of GAN and modification of Goodfellow et al. [32] original GAN, which is the basics for recent GAN research. Two neural networks are present in a model that is used to train simultaneously. The discriminator is the first network and this is denoted as $D$. The discriminator’s role is to discriminate between samples real and fake. A sample $x$ is imputed and output $D\left(x\right)$ is the probability of real samples. Generator $G$ is second network and samples are generated in the generator and D is real samples with high probability. The input samples $z^1,\dots ,z^m$ provide $G$ from simple distribution $p_z$, usually a uniform distribution and the image space of distribution $p_g$ maps $G\left(z\right)$. The objective of the model is to $G$ achieve $p_g=p_{data}$, as in Equation (1).

$$\begin{array}{c}min\\ G\end{array}\begin{array}{c}max\\ D\end{array}{\mathbb{E}}_{x~p_{data}}\log D\left(x\right)+{\mathbb{E}}_{z~p_z}\left[\log \left(1-D\left(G\left(z\right)\right)\right)\right]$$

(1)

The $D\left(x\right)$ is maximized to train the discriminator for images in the discriminator with $x\sim p_{data}$ and the model uses $x\nsim p_{data}$ for images to minimize $D\left(x\right)$. The $G\left(z\right)$ generates images in the generator to adjust $D$ during training such that $D\left(G\left(z\right)\right)\sim p_{data}$. The generator is trained to increase $D\left(G\left(z\right)\right)$, or equivalently reduce $1-D\left(G\left(z\right)\right)$. The generator increases its ability to generate more realistic images during training and the discriminator increases its ability to differentiate the real from generated images.

Generator Architecture: The generator network considers a vector of 100 random numbers from uniform distribution as input and output are provided as objects in remote sensing images in the size of $64\times 64\times 1$. The network architecture consists of a fully connected layer reshaped to a size of $4\times 4\times 1024$ and an up-sample of four fractionally strided convolutions in kernel size of $5\times 5$ in the sample image. A deconvolution or fractionally-strided convolution is interpreted as pixels’ expansion by applying zeros in between them. A larger output image was generated by convolution of the expanded image. Each network layer is applied with batch-normalization excluding the output layer. In the GAN learning process, the entire mini-batch was stabilized using normalizing responses to have unit variance and zero mean and the generator was prevented from collapsing all samples. ReLU activation function was applied in all layers and the output layer was applied with tanh activation function.

Discriminator Architecture: A typical CNN architecture has a discriminator network that considers input images in the size of $64\times 64\times 1$ and output is one decision (real or fake). The kernel size is set as $5\times 5$ in four convolution layers of the network and a fully connected layer. Each convolution layer is applied with strided convolutions instead of pooling layers to reduce spatial dimensionality. Each layer of the network is applied with batch-normalization excluding input and output layers. Leaky ReLU activation functions $f\left(x\right)=\max \left(x,leak\times x\right)$ are applied in layers except for the output layer and sigmoid function with likelihood probability (0, 1) image score in the output layer. The Generative Adversarial Network’s [33] architecture is shown in Figure 5.

3.3. CNN-Based Feature Extraction

Convolution is a linear operation for feature extraction based on kernel, which is a small array of numbers. Kernel is applied on input for an array of numbers called a tensor [34,35].

A typical down-sampling operation is performed using a pooling layer to reduce feature maps of in-plane dimensionality. This introduces a translation invariance to small distortions and shifts, and decreases learnable parameters.

Pooling layer or final convolution of feature maps outputs are usually flattened, i.e., converted into a 1D array of numbers and connected to one or more fully connected layers, known as dense layers, so that every input is connected to a learnable weight of every output. The CNN architecture for feature extraction is shown in Figure 6.

3.3.1. AlexNet

Various types of research [36,37] show AlexNet’s successful performance in classification and more significant performance in image processing than previous models. The researchers in deep learning show much interest in AlexNet due to its efficiency.

AlexNet model is applied with activation function and activation function provides neural networks’ non-linearity. Traditional activation functions are arctan function, tanh function, logistic function, etc. These functions generally cause gradient vanishing problems and a small range of 0 is applied with a larger gradient value. Rectified Linear Unit (ReLU) activation function is applied to overcome this problem. Equation (2) provides the ReLU model.

$$\mathrm{ReLU}\left(x\right)=\max \left(x,0\right)$$

(2)

The ReLU gradient provides 1 output if the input is not less than 0. This shows that ReLU function provides higher convergence than tanh unit in deep networks. More acceleration is gained during the training process.

The dropout layer is applied in a fully connected layer to solve the overfitting problem. The dropout layer trains only a part of the neurons and skips the remaining neurons to avoid overfitting. For instance, if dropout is set as 0.1, then 10% of the neurons are skipped in training for every iteration. Generalization is improved by dropout to minimize neurons’ joint adaptation and cooperation between neurons. Dropout is applied on several sub-layers of the network. The same loss function is shared in each single sub-network and causes overfit to a certain extent. Sub-networks’ entire network output is provided and dropout improves the robustness of the model.

Convolution and pooling layers automatically perform feature extraction and reduction in the model. Convolutional layers are applied for images to increase the performance. Considering image $M$ in $\left(m,n\right),$ size and convolution are given in Equation (3).

$$C\left(m,n\right)=\left(M\times w\right)\left(m,n\right)={{\displaystyle \sum }}_k{{\displaystyle \sum }}_{l}M\left(m-k,n-l\right)w\left(k,l\right)$$

(3)

where kernel $w$ size is $\left(k,l\right)$, convolution provides a model solution to learn features of image and parameter sharing reduce complexity. Neighbouring pixel groups are applied in feature maps of pooling layer to reduce features and representation is provided by some values. The feature map size is $4\times 4$, and every 2 × 2 block has max value to generate max pooling and reduce for feature dimension.

Cross change normalization improves generalization. The same position of several adjacent maps sum is provided by cross channel normalization in neurons. Normalized feature maps are applied to next layers.

Fully connected layers perform classification and neurons are connected to adjacent neurons in next layer. These layers use softmax activation function for the classification.

Softmax output is present in the range of (0, 1) to activate neurons. Overlapping pooling is performed and various input images from datasets are used for AlexNet training. The AlexNet architecture for feature extraction is shown in Figure 7.

3.3.2. VGG 19

Oxford Robotics Institute developed a type of CNN model, which is named as Visual Geometry Group Network (VGG) [38,39]. VGGNet provides good performance in data cluster of ImageNet data. Five building blocks are present in VGG19. Two convolutional layers and one pooling layer are present in first and second building blocks, followed by four convolutional layers and one pooling layer which are present in the third and fourth blocks. Four convolutional layers are present in the final block and small filters $3\times 3$ are used. The VGG19 architecture in feature extraction is shown in Figure 8.

3.4. Spider Monkey Optimization

The SMO technique is a metaheuristic technique based on the social behavior of the spider monkey, adopting fusion and fission swarm intelligence for foraging [40,41,42,43]. Spider monkeys are in groups of 40 to 50 members. Food searching tasks in a territory are divided by a leader. Generally, spider monkeys live with 40 to 50 members of a swarm and a leader decides to partition food searching tasks in a territory. A female lead is selected as a global leader in the swarm and, in case of food insufficiency, this creates mutable smaller groups. The group size is based on food availability of specific territory. The spider monkey’s size is directly proportional to available food. The SMO based method of swarm intelligence (SI) satisfies the necessary conditions:

• Labor division: smaller groups are created to divide foraging work for spider monkeys.
• Self-organization: Food availability requirement is selected using group size.
• An intelligent decision is carried out by intelligent foraging behavior.
• Food search is initiated using swarm.
• Food source individuals are measured using computing distance.
• The food group members of individual’s distance alter the locations for the consideration.
• Food source individual distance is calculated.

SMO method uses train and error for six phases of collaborative iterative process: global leader decision phase, learning phase, global leader, global leader phase, local leader decision phase, local leader learning phase, and local leader phase. The SMO method work flow is represented in Figure 9.

The SMO method step-by-step process is given below.

3.4.1. Initializing

SMO method distributes population $P$ of spider monkeys $S{M}_p$ (where pth monkey of the population is denoted as SM_p, and $p=1,2\dots P$). Monkeys are M-dimensional vectors, where total number of variables is denoted as $M$. One possible solution of each $S{M}_p$ is provided. SMO initializes each $S{M}_p$ using Equation (4).

$$S{M}_{pq}=S{M}_{minq}+UR\left(0,1\right)\times \left(S{M}_{maxq}-S{M}_{minq}\right)$$

(4)

where

$S{M}_{pq}$ is pth SM of qth dimension.

$S{M}_p$ lower and upper bounds are $S{M}_{minq}$ and $S{M}_{maxq}$ in the qth direction for random number of UR (0, 1), uniform distribution is in range of [0, 1].

3.4.2. Local Leader Phase (LLP)

The current location is changed by SM using local group members and local leader past occurrences. The new location is updated for SM location if fitness value of new location is higher than previous location. The location update of pth SM of lth local group is provided in Equation (5):

$$SMne{w}_{pq}=S{M}_{pq}+UR\left(0,1\right)\times \left(L{L}_{lq}-S{M}_{pq}\right)+UR\left(-1,1\right)\times \left(S{M}_{rq}-S{M}_{pq}\right)$$

(5)

where

The lth local group leader location of qth dimension is denoted as $L{L}_{lq}$.

The lth local group of lth SM is randomly selected for qth dimension and is denoted as $S{M}_{rq}$, such that $r,p$.

3.4.3. Global Leader Phase (GLP)

After LLP, GLP is started to update the location. Experiences of local group members and global leader are used to update SM location. The location update is provided in Equation (6):

$$SMne{w}_{pq}=S{M}_{pq}+UR\left(0,1\right)\times \left(G{L}_{lq}-S{M}_{pq}\right)+UR\left(-1,1\right)\times \left(S{M}_{rq}-S{M}_{pq}\right)$$

(6)

where qth dimension of global leader location is denoted as $G{L}_{lq}$ and an arbitrarily selected index is $q=1,2,3,\dots M$.

The SM fitness calculates probability $pr{b}_p$ in this phase. The location of $S{M}_p$ based on probability value, is updated and better location candidate has access to a number of possibilities to improve convergence. The probability calculation is given in Equation (7).

$$pr{b}_p=\frac{f{n}_p}{{{\displaystyle \sum }}_{p=1}^{N}f{n}_p}$$

(7)

where pth SM fitness value is denoted as $f{n}_p$. The new location fitness of SM’s is calculated and compared with the previous location. The best fitness value of the location is considered.

3.4.4. Global Leader Learning (GLL) Phase

The global leader location update is performed using a greedy selection technique. The SM location updated is based on the global leader location for best fitness in the population. The global leader is applied with the optimum location. An increment of 1 is added to Global Limit Count if updates are encountered.

3.4.5. Local Leader Learning (LLL) Phase

The local group is applied using the greedy selection method to update the location of the local leader. The SM location is updated with local leader location for best fitness in a specific local group. The local leader is assigned to the optimum location. The increment of 1 is added to the Local Limit Count if no updates are encountered.

3.4.6. Local Leader Decision (LLD) Phase

Local group candidates modify the location randomly as per step 1 when a local leader does not update its location or uses the past information from local and global leaders based on $pr$ using Equation (8).

$$SMne{w}_{pq}=S{M}_{pq}+UR\left(0,1\right)\times \left(G{L}_{lq}-S{M}_{pq}\right)+UR\left(0,1\right)\times \left(S{M}_{rq}-L{L}_{pq}\right)$$

(8)

3.4.7. Global Leader Decision (GLD) Phase

The population splits into small-size groups as per the global leader’s decision if the location is not updated for a global leader up to the Global Leader Limit. The splitting process occurs for a maximum number of groups (MG) is received. A local leader is selected at each iteration for the newly shaped group. Allowed groups are created at the maximum number and the global leader does not update its position until the allowed limit of pre-fixed, then global leader aims to merge entire groups into a single group.

The SMO processing controls parameters are as follows:

• Perturbation rate (pr)
• Max number of groups (MG)
• GlobalLeaderLimit
• Value of LocalLeaderLimit

3.4.8. Gaussian Mutation

The SMO method is trapped in a local optimum in complex problems of the iterative optimization process. During iteration, the algorithm solution value remains unchanged. To increase the algorithm probability and algorithm shortcoming, this technique jumps out of the position of local optimal and adds random perturbation and Gaussian mutation and continues to process the algorithm. The Gaussian mutation formula is shown in Equation (9).

$$x^{i,iter+1}=\{\begin{array}{cc}{x}^{i,iter}+rand& ifr\ge 0.2\\ x^{i,iter}\times Gaussian\left(\mu ,\sigma \right)& otherwise\end{array}$$

(9)

where random perturbation or Gaussian mutation selection probability is $r_j$ and $rand$ was a random number in the range of [0, 1]. The distribution of Gaussian variation is given in Equation (10).

$$Gaussian\left(\mu ,\sigma \right)=\left(\frac{1}{\sqrt{2\pi \sigma }}\right)\exp \left(-\frac{{\left(x-\mu \right)}^2}{2{\sigma }^2}\right)$$

(10)

where the variance is denoted as ${\sigma }^2$ and the mean value is denoted as $\mu$.

3.5. LSTM Model

The LSTM model is introduced by Hochreiter and Schmidhuber [44] as an evolution of the RNN model. This model overcomes the limitation of RNN using additional interactions per module. LSTMs are a type of RNN that learn long-term dependencies and remember information for a long time as a default. A chain structure of the LSTM model is given in research [45]. A different structure is present in the repeating module. Four interaction layers with unique communication method is applied instead of standard RNN or a single neural network. The LSTM structure is shown in Figure 10.

A typical LSTM network consists of cells and memory blocks. The next cell is transferred into two states: a hidden state and a cell state. The main chain of data flow is the cell state that allows data to flow essentially unchained. Some linear transformation is carried out and sigmoid is used to remove or add data in the layer. A gate is similar to a series of matrix operations or a layer that has various individual weights. LSTMs are developed to reduce long-term dependency using memorizing process to control gates [46].

4. Experimental Setup

The implementation details of datasets, parameter settings, and system requirements are discussed in this section.

Datasets: The UCM [47] dataset has 100 images per class, 21 classes, 2100 total images, 0.3 m spatial resolution, and $256\times 256$ image size. The AID [48] dataset has 200–400 images per class, 30 classes, 10,000 total images, 0.5–0.8 m spatial resolution, and $600\times 600$ image size. The NWPU45 [49] dataset has 700 images per class, 40 classes, 31,500 total images, 0.2–0.3 m spatial resolution, and $256\times 256$ image size. As seen in the AID, the number of images varied per class, where this imbalanced data problem is effectively addressed by the GM-SMO model.

Parameter settings: In AlexNet and VGG19 model, the learning rate is set as 0.01, the dropout rate is set as 0.1, and the Adam optimizer is used. In LSTM network, the loss function is categorical cross entropy loss function and optimizer is Adam. In GM-SMO, the population size is set as 50, and number of iterations is set as 50. The 5-fold cross validation is applied to test the performance of the model.

System Requirement: Intel i9 processor, RAM is 128 GB, Graphics card is 22 GB, and OS is Windows 10-64 bit. MATLAB 2022a was used to evaluate the performance of the GM-SMO technique.

5. Results

The GM-SMO model is applied to scene classification to improve the efficiency of the model. The GM-SMO model is tested on three datasets and accuracy is shown for 10 epochs. The GM-SMO model is tested and compared with deep learning techniques and feature selection techniques on scene classification. The GM-SMO model is also compared with existing methods in scene classification for three datasets. The Grey Wolf Optimization (GWO), Firefly (FF), and Particle Swarm Optimization (PSO) were compared with the GM-SMO technique on scene classification.

The GM-SMO method accuracy for various numbers of epochs for three datasets is shown in Figure 11. This shows that the GM-SMO method increases the accuracy up to 8 epochs and accuracy decreases after 8 epochs. The reason for the decrease in accuracy after 8 epochs is the overfitting problem. The generation of more features in the convolutional layer and repeated learning of the features creates an overfitting problem. The Gaussian mutation in the SMO method helps to learn unique features for classification and increases the exploitation. The Gaussian mutation technique helps to reduce the overfitting problem and increases the performance of classification.

The GM-SMO method is measured with accuracy and sensitivity for three datasets and compared with deep learning techniques, as shown in

Table 1. Deep learning techniques’ performance in scene classification on three datasets.

Methods	Accuracy (%)	Sensitivity (%)	p-Value
GoogleNet	92.44	90.28	<0.10
ResNet	92.67	90.9	<0.10
ANN	92.67	93.89	<0.05
RNN	94.04	94.68	<0.05
LSTM with GM-SMO	99.46	99.41	<0.01

and Figure 12. The GM-SMO model uses the AlexNet-VGG19 model for feature extraction from given images. The GM-SMO method performs feature selection with better exploitation that helps to reduce the overfitting problem in scene classification. The existing deep learning models such as GoogleNet, ResNet, Artificial Neural Network (ANN), and Recurrent Neural Network (RNN) have overfitting problems and provide lower efficiency. The existing method generates more features in the convolutional layer and lacks feature selection techniques for classification. The GM-SMO with LSTM has obtained higher performance than the existing techniques in scene classification. The GM-SMO with LSTM has 99.46% accuracy and 99.41% sensitivity, which are better than the other models. The local understanding of the images is good enough in the GM-SMO with LSTM model; therefore, it obtains better classification results compared to other classification models. In addition, the Z-test’s p-value of individual classifiers is mentioned in Table 1.

The GM-SMO method performance is compared with existing feature selection techniques, as shown in

Table 2. Feature selection techniques’ comparison in scene classification on three datasets.

Methods	Accuracy (%)	Sensitivity (%)
PSO	91.23	90
FF	93.14	90.94
GWO	94.28	91.18
SMO	94.6	91.6
GM-SMO	99.46	99.41

and Figure 13. The existing feature selection techniques such as GWO, FF, and PSO have a limitation of local optima trap due to lower exploitation. The Gaussian mutation is applied in the SMO technique to increase the exploitation and overcome the overfitting problem. The Gaussian mutation changes the solutions related to the best solution that increases the exploitation in feature selection. The GM-SMO model selects unique features for scene classification that help to increase the sensitivity of the model. The GM-SMO model has 99.46% accuracy and 99.41% sensitivity, which are better compared to the existing optimizers.

The imbalanced data problem decreases the performance of scene classification in existing techniques. A common technique applied for imbalanced data problems is augmentation to generate similar images.

Table 3. Sampling techniques for scene classification.

Datasets	Methods	Accuracy (%)	Sensitivity (%)
UCM	SMOTE	97.35	96.53
	Augmentation	99.24	98.31
	GAN	99.46	99.41
AID	SMOTE	94.2	95.14
	Augmentation	95.34	95.67
	GAN	98.2	98.31
NWPU45	SMOTE	92.1	92.3
	Augmentation	93.46	93.16
	GAN	96.73	96.6

and Figure 14 show the GAN augmentation performance with standard augmentation. Although images generated by augmentation are highly similar, it is difficult to learn unique features, overfitting, and misclassification among similar categories. GAN based augmentation is applied in this study to generate similar images in minority classes and unique feature learning. The GAN based optimization technique has higher efficiency in three datasets than augmentation and SMOTE techniques. The GAM GM-SMO method has 99.46% accuracy and 99.41% sensitivity, and augmentation model has 99.24% accuracy and 98.31% sensitivity in UCM dataset.

By inspecting

Table 4. Results of the GM-SMO with LSTM classifier in terms of means of computational time.

Classifiers	Computational Time (s)
	UCM	AID	NWPU45
GoogleNet	25	41.09	50.36
ResNet	32	38.50	48
ANN	19.43	36.20	45.38
RNN	15.12	35	44
LSTM with GM-SMO	12	23	34

, the proposed GM-SMO with LSTM classifier obtained higher classification results compared to other classifiers: GoogleNet, ResNet, ANN, and RNN, with limited computational time. As specified in Table 4, the GM-SMO with LSTM classifier consumed 12, 23, and 34 s per image of computation time on the UCM, AID, and NWPU45 datasets. Sample classification output image is depicted in Figure 15.

Comparative Analysis

The GM-SMO model is compared with existing techniques in scene classification on three datasets such as UCM, AID, and NWPU45, and the comparative results are mentioned in

Table 5. GM-SMO is compared with existing methods on the UCM dataset.

Methods	Accuracy (%)
DFAGCN [19]	98.48
vision transformer [20]	97.90
EfficientNet-B3-Attn-2 [21]	97.90
SceneNet [22]	99.10
MTLN [23]	97.66
LSE-Net [26]	98.53
MA-GRN [29]	99.29
transformers—CNN [30]	98.76
GM-SMO	99.46 ± 0.0238

,

Table 6. GM-SMO method comparison with existing methods on AID dataset.

Methods	Accuracy (%)
DFAGCN [19]	94.88
vision transformer [20]	94.27
EfficientNet-B3-Attn-2 [21]	96.56
SceneNet [22]	89.58
MTLN [23]	92.54
GLDBS [24]	97.01
ACNet [25]	95.38
LSE-Net [26]	94.41
MA-GRN [29]	96.19
transformers—CNN [30]	95.54
GM-SMO	98.20 ± 0.2590

and

Table 7. GM-SMO method comparison with existing methods on NWPU45 dataset.

Methods	Accuracy (%)
DFAGCN [19]	89.29
vision transformer [20]	93.05
SceneNet [22]	95.21
MTLN [23]	89.71
GLDBS [24]	94.46
ACNet [25]	92.42
LSE-Net [26]	93.34
SPNet [27]	83.94
MA-GRN [29]	95.32
transformers—CNN [30]	93.06
GM-SMO	96.73 ± 0.0432

. The GM-SMO method is compared with existing techniques on the UCM dataset, as shown in Table 5. The existing CNN model has limitations of imbalanced data problem and overfitting problem in the scene classification. The GM-SMO model applies the GAN model to augment the minority classes and increase their performance. The Gaussian mutation changes the solution after exploration to increase the exploitation of the model. The GM-SMO method selects the unique features to overcome the overfitting and imbalanced data problem. The GM-SMO model has achieved 99.46% accuracy, which is better compared to other methods on the UCM dataset.

The GM-SMO model is compared with existing techniques in scene classification on the AID dataset, as shown in Table 6. The GM-SMO model selects unique features for the classification to solve the overfitting problem and imbalanced data problem. The GM-SMO model changes the solution of the SMO technique to increase the exploitation of the model. The GM-SMO model has achieved 98.20% accuracy, which is superior compared to other models on the AID dataset.

The GM-SMO method is compared with existing scene classification techniques on NWPU45 dataset, as shown in Table 7. The existing CNN based models have a limitation of imbalanced data problem and overfitting problem in scene classification. The GM-SMO model changes the solution of SMO technique after exploration to increase the exploitation. The GM-SMO model maintains the tradeoff between exploration and exploitation to find the relevant features for classification. The GM-SMO model selects unique features to overcome the overfitting and imbalanced data problem. The GM-SMO model has 96.73% accuracy, which is better compared to transformers—CNN [30], MA-GRN [29], and other comparative models.

6. Conclusions

Scene classification helps to classify the object or land use such as a farm, airplane, or stadium from remote sensing images. The existing CNN based models have limitations of overfitting problems, imbalanced data problems, and misclassification of similar categories. This research proposes a GM-SMO technique for the feature selection process to improve the classification performance of scene classification. The GM-SMO model selects unique features to overcome the imbalanced data problem and overfitting problem. The GAN model is applied for the augmentation of images and to reduce imbalanced data problems. The AlexNet and VGG19 models are applied to extract the features from remote sensing images. The GM-SMO model has 98.20% accuracy, LSE-Net has 94.41% accuracy, and MTLN has 92.54% accuracy on the AID dataset. The future work of this research involves applying the proposed model to the real time datasets to further validate the efficiency of the model. However, the proposed model is computationally complex, which can be addressed in future work by implementing an unsupervised deep learning model.