Detecting Digital Image Forgeries Using Error Level Analysis Features and Neural Network Classification Enhanced by Synthetic Minority Over-Sampling Technique

Changing images has become simpler and more convincing than ever due to the advancement of digital imaging technologies and the widespread availability of powerful editing tools. The ability to determine the modifications applied to a digital image, as well as the types of alterations made, is essential to ensure the authenticity and accuracy of visual data shared online and on social media. In this study, data from October 2023 are used to investigate digital image forgeries and the types of manipulations applied to photographs [1, 2]. The most prevalent forms of digital forgery are image splicing and copy-move, which involve editing images and incorporating parts from secondary sources. Automated editing techniques are particularly important, as some manipulations are complex and difficult to detect manually. The modified images form the basis for all subsequent alterations, whether automated or manual.

Pixel-based, frequency-based, and key point-based are the three primary categories of conventional image forgery detection methods [3]. While frequency-domain approaches use transformations like the Discrete Cosine Transform (DCT) or the Discrete Wavelet Transform (DWT) to expose changes in the transformed coefficients, pixel-based approaches rely on variations in color, texture, or statistical data [4]. While these classical methods achieve reasonable accuracy, their effectiveness diminishes under common post-processing operations such as compression, noise addition, or scaling. To address these challenges, Error Level Analysis (ELA) has emerged as a practical preprocessing technique that amplifies compression artifacts introduced during tampering. By re-saving the image at a fixed JPEG quality and comparing error residuals, ELA reveals regions with inconsistent compression levels, allowing discriminative feature extraction for forgery detection [5, 6].

In recent years, deep learning models, particularly Convolutional Neural Networks (CNNs) have shown exceptional ability in automatically extracting hierarchical image features for classification tasks [7]. However, CNN-based forgery detectors often face two significant limitations: (i) overfitting due to limited or imbalanced datasets, and (ii) difficulty in generalizing to new manipulation types or unseen image sources. Class imbalance is especially problematic in forensic datasets like CASIA and CoMoFoD, where genuine images significantly outnumber tampered ones, leading to biased learning and reduced sensitivity to forgeries [8]. To mitigate this, the Synthetic Minority Over-Sampling Technique (SMOTE) has been widely adopted to rebalance datasets by generating synthetic examples of underrepresented classes, thus improving model generalization and classification stability [9].

The research presents a novel hybrid technique that combines a neural network with SMOTE for forgery detection and ELA for feature extraction in light of the aforementioned studies. ELA's job is to ensure that the various reshaping zones are well illuminated and that the indigenous ones are identified. A fully connected neural network is subsequently trained using those features.

SMOTE is responsible for ensuring the proper distribution of the training samples, whether they are real or forged images. Furthermore, the aforementioned method is designed to achieve not only perfect but cross-typed forgery detection and, at the same time, alleviate the class imbalance problem as much as possible. Standard datasets were used for the experiment, and the results obtained show that combining ELA, SMOTE, and the neural network model led to a significant enhancement in detection accuracy, as well as F1-score, as opposed to a basic CNN network and unbalanced classifiers. This article can be considered as a new method to detect digital image forgery that is effective and easy to understand, especially for those who are in need of the same.

The primary components of the proposed fake digital image detection system are featuring extraction, dataset balancing, model training and evaluation. Figure 1 illustrates the workflow.

Figure 1. Overview of the proposed image forgery detection framework

3.1 Image datasets

The database is frequently used in its area as a baseline for identifying counterfeit images. To be used with the Copy-Move and Splicing tools, images were acquired and modified. The study focuses on forensic image detection and evaluation. There are two sets for imaging. The first, CASIA 1.0, is a simple evaluation model with 800 genuine photos and 921 modified. The second, more sophisticated model, CASIA 2.0, has 5,123 edited and 7,491 unedited photos. Both the alterations and the contents and sizes of the images in the second model are more variable. Both image sets feature real pictures underlying data and a wealth of field data. Both sets are extremely valuable for training and assessment. As fairly and impartially as possible, 2,523 photos were chosen for testing and 11,890 for training in the research under consideration [31].

Additionally, methods for identifying copy-move forgeries are frequently evaluated using the Copy-Move Forgery Detection (CoMoFoD) database. 200 real photos and 200 photos that were produced by copy-move forgeries and postprocessed using JPEG compression, rotation, scaling, blurring, and noise addition make up the database. The CoMoFoD database is a great baseline for evaluating the effectiveness of algorithms for forgery detection in a variety of circumstances since it contains comprehensive ground-truth annotations for altered areas, which aid in evaluation and supervised learning [32]. Recent studies have explored hybrid frameworks and advanced deep learning models for robust image forgery detection. Abdelmaksoud et al. [33] proposed a hybrid approach combining Vision Transformers with SVM, demonstrating strong resistance against adversarial attacks. Similarly, Zhang et al. [34] developed a CNN-transformer-based generative adversarial network for copy-move source/target distinguishment, achieving high accuracy in identifying manipulated regions. These works highlight the growing trend of integrating deep learning and transformer architectures to enhance both detection precision and robustness in image forensics.

3.2 Error Level Analysis

3.2.1 Original Error Level Analysis method

One of the main techniques for detecting counterfeit photos is the ELA approach, which helps with preprocessing and anomaly visualization. The fundamental idea behind the ELA technique is that when an image is re-saved using lossy formats (like JPEG), the original and altered parts exhibit varying levels of compression faults. Usually, a modified region is compressed and edited several times, which leads to increased or unequal error levels. The ELA function looks for the tiniest local alterations that are indicative of fraudulent work [35, 36].

1. Preparation: First, a grayscale image is created from the input image I. This is done in order to reduce dimensionality and maintain structural information. Then, it is resized to 256 × 256 pixels:

$I_g=\operatorname{Resize}(\operatorname{Gray}(I), 256 \times 256)$     (1)

where,

I = original input image

Gray(I) = conversion of the input image to grayscale

I_g = resulting grayscale and resized image

2. ELA generation: The grayscale image is compressed to JPEG format and then decompressed to create an ELA image $I_{E L A}$ which shows compression effects and local inconsistencies:

$I_{E L A}=\left|I_g-\operatorname{JPEG}\left(I_g, Q\right)\right|$     (2)

where, Q is the JPEG quality factor.

The generated $I_{E L A}$ highlights subtle compression artifacts and local differences, making the manipulated regions appear more pronounced than in the original image. This improved representation of an object is a good input for the detection of plagiarism and the tracking of the steps of the generated flow for the assignment of the characteristics and the classification.

3.2.2 Adaptive Error Level Analysis

ELA is a widely used technique for exposing digital image forgeries by highlighting compression inconsistencies. However, conventional ELA employs a fixed JPEG quality factor Q, which limits its effectiveness across images with varying texture, compression history, and content complexity. To overcome this limitation, an adaptive ELA strategy is proposed, in which the JPEG quality factor is automatically determined based on image statistics.

Algorithm 1: Adaptive Error Level Analysis

Input:

Original image I

Output:

Adaptive ELA image $I_{E L A}$

Optimal JPEG quality factor $Q_{opt }$

Step 1: Image preprocessing

If the input image is a color image, it is first converted to grayscale:

$I_g(x, y)=0.299 R(x, y)+0.587 G(x, y)+0.114 B(x, y)$     (3)

The grayscale image is then resized to a fixed spatial resolution:

$I_g=\operatorname{Resize}\left(I_g, 256 \times 256\right)$     (4)

Step 2: Local variance computation

The grayscale image $I_g$ is divided into non-overlapping blocks of size $b \times b$ (with b = 16).

For each block $B_k$, the local variance is computed as:

$\sigma_k^2=\frac{1}{b^2} \sum_{i=1}^b \sum_{j=1}^b\left(B_k(i, j)-\mu_k\right)^2$     (5)

where, $\mu_k$ is the mean intensity of block $B_k$:

$\mu_k=\frac{1}{b^2} \sum_{i=1}^b \sum_{j=1}^b B_k(i, j)$     (6)

The average local variance of the image is then calculated as:

$\sigma_{a v g}=\frac{1}{K} \sum_{k=1}^K \sigma_k^2$     (7)

where, K is the total number of blocks.

Step 3: Adaptive JPEG quality factor selection

The minimum and maximum local variances are determined as:

$\sigma_{\min}=\min \left(\sigma_k^2\right), \sigma_{\max }=\max \left(\sigma_k^2\right)$     (8)

The JPEG quality factor is adaptively computed using linear normalization:

$Q_{o p t}=Q_{\min }+\left(Q_{\max }-Q_{\min }\right) \cdot \frac{\sigma_{a v g}-\sigma_{\min}}{\sigma_{\max}-\sigma_{\min }}$     (9)

where,

$Q_{\min }=60$, $Q_{\max }=90$     (10)

To ensure stability, the selected quality factor is constrained to the valid range:

$Q_{opt}=\max \left(Q_{\min}, \min \left(Q_{opt}, Q_{\max}\right)\right)$     (11)

Step 4: ELA map generation

The grayscale image is recompressed using JPEG with quality factor $Q_{opt}$:

$I_{j p e g}=\operatorname{JPEG}\left(I_g, Q_{o p t}\right)$     (12)

The ELA image is computed as the absolute pixel-wise difference:

$I_{E L A}(x, y)=\left|I_g(x, y)-I_{jpeg}(x, y)\right|$      (13)

To standardize feature extraction, the ELA image is normalized:

$I_{E L A}^{\text {norm}}=\frac{I_{E L A}-\min \left(I_{E L A}\right)}{\max \left(I_{E L A}\right)-\min \left(I_{E L A}\right)}$     (14)

Step 5: Output

The algorithm outputs the normalized ELA image $\underset{E L A}{Inorm}$ and the adaptively selected JPEG quality factor $Q_{opt}$.

3.3 Feature extraction

In order to be able to locate forgery in a reliable way by means of unique features, each picture is subjected to a set of transfigurations that involve typical or spatial, compression-based, and frequency-domain investigations. The gist of the entire procedure, which is aimed at not only the structural but also the statistical aspects of the manipulated parts being the most properly figured out, is given in Algorithm 1.

3.3.1 Block division and Discrete Cosine Transform transformation

The ELA image $I_{E L A}$ is partitioned into non-overlapping $16 \times 16$ blocks denoted as $B_{(i, j)}$. For each block, the DCT is computed to represent its frequency-domain information:

$\begin{gathered}D_{(i, j)}(u, v)=\frac{1}{4} C(u) C(v) \sum_{x=0}^{15} \sum_{y=0}^{15} B_{(i, j)}(x, y) \cos \left(\frac{(2 x+1) u \pi}{32}\right) \cos \left(\frac{(2 y+1) v \pi}{32}\right)\end{gathered}$     (15)

where,

$C(u), C(v)= \begin{cases}\frac{1}{\sqrt{2}}, & \text { if } u, v=0 \\ 1, & \text { otherwise. }\end{cases}$     (16)

This modification separates image frequency coefficients that convey the content of structural and texture changes that are usually caused as a result of image tampering.

3.3.2 Singular value extraction

Every reconstructed block D_(i,j) is decomposed using Singular Value Decomposition (SVD) as given:

$D_{(i, j)}=U_{(i, j)} S_{(i, j)} V_{(i, j)}^T$     (17)

The diagonal entries of the singular value matrix $S_{(i, j)}$, representing the block’s energy distribution, are extracted as local feature descriptors:

$f_{(i, j)}=\operatorname{diag}\left(S_{(i, j)}\right)$      (18)

3.3.3 Feature vector construction

The final image feature vector F is constructed by concatenating all block-level features, forming a high-dimensional representation:

$F=\left[f_{1,1}, f_{1,2}, \ldots, f_{m, n}\right]$     (19)

A feature vector that brings together spatial, frequency, and compression-related features in-depth is quite capable of keeping the model's originality by differentiating authentic from tampered images.

Algorithm 2: Feature Extraction Process

Input: Image I

Output: Feature vector F

1. Convert image to grayscale and resize:

1. $I_g \leftarrow \operatorname{Resize}(\operatorname{Gray}(I), 256 \times 256)$

2. Generate the ELA map by re-saving the image with JPEG compression at quality Q:

2. $I_{E L A} \leftarrow\left|I_g-\operatorname{JPEG}\left(I_g, Q\right)\right|$

3. Divide $I_{E L A}$ into $16 \times 16$ blocks $B_{(i, j)}$.
4. For each block $B_{(i, j)}$:

a. Apply 2D DCT: $D_{(i, j)} \leftarrow \operatorname{DCT}\left(B_{(i, j)}\right)$

b. Perform SVD: $[U, S, V] \leftarrow \operatorname{SVD}\left(D_{(i, j)}\right)$

c. Extract singular values: $f_{(i, j)} \leftarrow \operatorname{diag}(S)$

d. Append $f_{(i, j)}$ to $F$

5. Return $F$

3.4 Dataset splitting

After the extraction of the feature, the data is divided into different layers. Apart from that, the model is normally divided into training and testing. The division is done in the standard 80/20 way, with 80% of the cases serving as elements for the model and 20% of the rest being for its testing.

The full dataset is revealable as:

$D=\left\{\left(F_i, y_i\right)\right\} i={ }_1^N$     (20)

$F_i$ is the extracted feature vector of the $i^{\text {th }}$ image, and $y_i \in\{0,1\}$ is its label ( 0 for real and 1 for tampered).

The dataset is then split into two groups that don't overlap:

$D_{\text {train }} \cup D_{\text {test }}=D, D_{\text {train }} \cap D_{\text {test }}=\emptyset$     (21)

$\left|D_{\text {train }}\right|=0.8 \mathrm{~N},\left|D_{\text {test }}\right|=0.2 \mathrm{~N}$     (22)

We make the class distribution in the training set invariant for both the real and tampered samples by using blatancy sampling. This indicates that this approach is impartial. This procedure ensures that each type of image is present in the same quantity in both sets.

3.5 Phase of training

During the training phase, a classifier in a neural network trains the feature vectors.

Additionally, it is important to note that prior to training, the training set's class balance would be:

$D_{\text {train }}^{\prime}=$ Balance $\left(D_{\text {train }}\right)$     (23)

The balanced dataset $D^{\prime}{ }_{\text {train}}$ is then used to train the neural network model by minimizing the classification loss $L$:

$L=\frac{1}{M} \sum_{i=1}^M \ell\left(f_\theta\left(F_i\right), y_i\right)$     (24)

where, $f_\theta$ denotes the neural network with parameters $\theta, F_i$ is the input feature vector, and $\ell(\cdot)$ represents the loss function (e.g., cross-entropy).

3.5.1 Balancing with Synthetic Minority Over-Sampling Technique

Class imbalance is taken into consideration using SMOTE. By interpolating between existing minority samples and their closest neighbors, SMOTE generates new minority samples. Given a minority instance x_i and one of its k-nearest neighbors x_zi, a new synthetic sample is generated as:

$x_{\mathrm{new}}=x_i+\lambda\left(x_{z i}-x_i\right), \lambda \in[0,1]$     (25)

This process is repeated until the desired number of synthetic samples is achieved:

SyntheticSamples $=\operatorname{SMOTE}\left(D_{\text {minority }}, N_{\text {gen}}, k\right)$     (26)

where, N_gen is the number of synthetic samples, and k is the neighborhood size.

The generated samples are then combined with the original dataset:

$D_{\text {train}}^{\prime}=D_{\text {train }} \cup$ SyntheticSamples     (27)

A PCA-based visualization shows that SMOTE does a good job of spreading out new samples in the feature space, which makes the classifier's decision boundary more accurate and less uneven.

3.5.2 Feature dimensionality reduction with Principal Component Analysis

After feature extraction, the resulting feature vectors can be very high-dimensional, which may lead to overfitting and increased computational cost during neural network training. To address this, Principal Component Analysis (PCA) is applied to reduce the dimensionality of the feature vectors while preserving the most significant variance.

Let the extracted feature dataset be:

$D=\{(F i, y i)\} N_{i=1}$     (28)

where, $F_i \in \mathbb{R}^d$ is the high-dimensional feature vector of the $i$-th image. PCA computes a linear transformation $P$ to project $F_i$ onto a lower-dimensional space:

$F_i^{\mathrm{PCA}}=P \cdot F_i$     (29)

The number of principal components is selected to retain a high percentage of the original variance (e.g., 95-99%), resulting in a reduced feature vector $F_i^{\text {PCA }} \in \mathbb{R}^{d^{\prime}}$, where, $d^{\prime} \ll d$.

This reduction decreases training time, minimizes the risk of overfitting, and improves the generalization performance of the classifier.

3.6 Network architecture

A fully connected feedforward neural network, as shown in Figure 2, is used to tell whether images are real or fake. This architecture is great for figuring out nonlinear relationships from high-dimensional feature vectors that come from ELA, DCT, and SVD block-based analysis.

Figure 2. Neural network architecture for binary classification

Below is a detailed description of the network layers, as shown in Table 1.

Table 1. Network layers

The Adam optimizer, which adjusts the learning rate for effective convergence, is used to train the network. To facilitate generalization, the data is shuffled at the conclusion of each of the 250 training epochs. For supervised learning in this binary classification job, categorical labels are employed.

3.7 Testing phase

The unseen subset D ("test") is used to test the trained model during the testing phase.

The predictions of the model are compared to the actual labels in order to obtain common performance metrics such as Accuracy, Precision, Recall, and F1-score. The following is a definition of these metrics:

Accuracy $=\frac{T P+T N}{T P+T N+F P+F N}$     (30)

Precision $=\frac{T P}{T P+F P}$     (31)

Recall $=\frac{T P}{T P+F N}$     (32)

$F 1=2 \times \frac{\text {Precision × Recall}}{\text {Precision}+ \text {Recall}}$     (33)

True positives, true negatives, false positives, and false negatives are denoted by the letters TP, TN, FP, and FN, respectively.

A confusion matrix is created by visually analyzing classification results, displaying the incident types that are correctly and incorrectly identified.

This methodical procedure guarantees impartial assessment and additional model generalization while offering a reliable standard for evaluating various tests in comparison.

Algorithm 3: Dataset Splitting and Model Training

Input:  Feature dataset $D=\left\{\left(F_i, y_i\right)\right\}_{i=1}^N$

Output: Trained model and performance metrics

1. Set the splitting ratio to r = 0.8 (80% for training and 20% for testing).
2. Randomly partition the dataset: $D_{\text {train }} \leftarrow r N, D_{\text {test }} \leftarrow(1-r) N$ 
3. Verify data balance in $\left(D_{\text {train}}\right)$.
4. If an imbalance is detected: $D_{\text {train}} \leftarrow$ Balance $\left(D_{\text {train}}\right)$ 
5. Train the neural network model using $D_{\text {train}}$.
6. Evaluate performance on $D_{\text {test}}$ to obtain metrics: Accuracy, Precision, Recall, F1-score.
7. Generate a confusion matrix for classification visualization.

Save trained model parameters for later classification use.

The proposed method was tested on three datasets: CASIA 1.0, CASIA 2.0, and CoMoFoD, which include a variety of real and tampered images created using editing techniques such as copy-move, splicing, and object removal. The SMOTE approach was applied to generate synthetic samples for minority classes to balance class distributions. For each dataset, 80% of the images were used for training, and 20% were used for testing.

5.1 Visualization of the Synthetic Minority Over-Sampling Technique

To visually show the effect of the SMOTE, the high-dimensional feature space was compressed to two dimensions by means of PCA. The result is shown in Figure 3. An intuitive comprehension of the data distribution both before and after using SMOTE is made easier by this dimensionality reduction.

Red square markers were used to indicate tampered (minority) samples, while blue circular markers indicated authentic (majority) ones. Green diamond markers were used to visualize the synthetic samples produced by the SMOTE algorithm.

The figure effectively balances the dataset by making more representative samples and spreading them out over the feature space between the original minority cases. Visualization demonstrates that SMOTE substantially diversifies the minority class instead of simply duplicating the existing samples. This balances the class and imparts the ability to the model to generalize better during training. Figure 3 depicts the outcome of SMOTE.

Figure 3. Synthetic Minority Over-Sampling Technique (SMOTE) output

5.2 Training accuracy and loss analysis

Throughout the training process, the accuracy of both the training and validation was continuously recorded in order to assess the learning behavior and generalization capacity of the proposed model. Figure 4 shows the change in accuracy figures across 250 epochs. The training accuracy is shown by the solid line, while the validation accuracy is shown by the dashed line. Both curves show an ongoing rising trend before converging at 98–99%. This indicates that the model was successful in identifying characteristics that distinguish the training dataset from others.

The model's excellent generalization power, which means it can handle fresh data and is not overfitting, is demonstrated by the close space between the two graphs.

Figure 4. Training and validation accuracy

We recorded the training and test loss for each turn to observe the new model's learning performance and training stability. Figure 5 illustrates the step-by-step changes in train loss and test loss over 250 rounds. As training draws to a close, both lines in the image exhibit a gradual decline that nearly reaches zero. The fact that both lines continue to decline indicates that the training is effective and does not break. It indicates that our method of teaching the model is efficient and effective. This further demonstrates the quality of our work and the correctness of the actions we took. It also indicates that there were no significant jumps in the model's loss. It learned effectively, as evidenced by its final score of 99.61%. This high score is another evidence that the model put in a lot of effort and gained a lot of knowledge. According to the results, it trained without making many mistakes and stayed on course. The model demonstrated stable learning and robust convergence, achieving high accuracy without overfitting. This ensures that there were no unexpected negative drops and that it did what it should have. The model was clever at figuring out the correct path, as seen by its top numbers.

Figure 5. Training and validation loss

5.3 Effect of Synthetic Minority Over-Sampling Technique on classification performance

To evaluate the impact of class imbalance on the performance of the deep learning classifier, experiments were conducted with and without the application of SMOTE. The training and testing datasets were derived from authentic and tampered images, with feature vectors extracted using the proposed adaptive ELA-based feature extraction method.

5.3.1 Training without Synthetic Minority Over-Sampling Technique

Without altering the configuration of the classes, the model initially learned from the primary set of data. No more small class samples were used. It performed flawlessly in every instance when we tested its performance on the data it had learned from. This indicates that it learned all of the group's rules and signs. However, when we compared it to fresh data, its score dropped to 92.44. The difference between the two scores is 7.56. This gap indicates that the model became overly accustomed to the set's largest type, which contained actual photos. The small font, which featured altered or phony graphics, did not perform as well. The model had a good understanding of the large group but was unable to identify the tiny group.

5.3.2 Training with Synthetic Minority Over-Sampling Technique

SMOTE was used to create fresh fictitious samples for the tiny group in order to address the problem of having too few samples in one class. The training set was more evenly distributed as a result. These additional examples were used to train the model once more. Following training, the model again achieved 100% correct responses on the training set. The test results improved as well, reaching 97.67%, indicating that the model is capable of doing more than merely learning the largest group. To allow for future checks, the SMOTE-created model was saved as trainedModel_SMOTE.mat.

The use of SMOTE successfully lessened the detrimental consequences of class imbalance, as indicated in Table 2. The model learns a more robust decision boundary by artificially creating more samples for the minority class, which subsequently results in improved testing accuracy and a narrower generalization gap. These results highlight how important oversampling strategies are for improving model performance and resilience in tampering detection tasks.

Table 2. Comparison of classification performance with and without Synthetic Minority Over-Sampling Technique (SMOTE)

5.4 Adaptive ELA preprocessing and effect of JPEG quality factor (Q) on ELA maps

Adaptive ELA is used in the picture forensic procedure under review to detect altered areas while concurrently reducing noise in unaffected areas. In order to highlight differences, ELA compares the raw image with a recompressed JPEG version. A key factor in this first step is the JPEG quality factor (Q), which controls how much an image is compressed while creating an ELA map. To ensure that altered areas are easily identifiable and that noise inside real image components is kept to a minimum, choosing the right Q value is crucial.

Experiments were carried out at four different JPEG quality settings (Q = 10, 60, 85, and 90) to determine the effect of Q on results. Figure 6 shows the resulting ELA maps for each Q value. These experiments led to the following findings.

Figure 6. Effect of Q value on Error Level Analysis (ELA) maps

• Q = 10 (Very Low Quality): I can see that a lot of detail is lost when compression is high. I can observe that the ELA map appears excessively bright and noisy due to heavy compression. The altered areas are covered by the ELA map.

As a result, nearly every region is illuminated. Analysis is made possible by the brightness.

• Q = 60 (Medium-Low Quality): I can see that the image structure is visible at Q = 60 due to the mild compression. I can still see some areas of the image structure that have been altered, and noise still predominates.

As a result, I examined the ELA maps. A combination of the tampering and bogus tampering traces can be seen in the ELA maps.

• Q = 85 (Optimal Quality): It appears that Q = 85 (Quality) strikes a balance between quality and compression. I can definitely see where things have changed. I see that the areas that haven't altered remain primarily dark.

As a result, there is an obvious separation between the modified areas. There are artifacts in the altered areas.

• Q = 90 (High Quality): Lower compression retains more information when I set Q = 90 (High Quality). Subtle changes become less noticeable in the ELA map when I set Q = 90 (High Quality).

As a result, little changes are more difficult to identify. Small changes are often invisible.

The JPEG quality factor is important, I see. The ELA maps' interpretability and clarity are altered by the JPEG quality factor. Noise is added by the low Q values. The sensitivity to the manipulations is lessened by the high Q levels. I suggest using Q = 85 as the ELA preprocessing setting.

5.5 Effect of JPEG quality factor (Q) and Synthetic Minority Over-Sampling Technique configuration on detection accuracy

I can see that when the training dataset is balanced and the ELA maps are clear, the tampering detection model performs best after we preprocess with ELA. When the training dataset contains manipulated samples, the tampering detection model performs poorly. The classifier may be skewed by the class imbalance in the training dataset. Because of the class imbalance issue, the majority class is given preference by the tampering detection model. In order to address the issue of class imbalance, we synthesize samples for the minority class using SMOTE.

A study was conducted. The impact of JPEG Q values (10, 60, 85, 90) and SMOTE configurations (No SMOTE, k = 3, k = 5, k = 7) on detection accuracy was assessed experimentally. Results are displayed in Figure 7. To ensure reliability, we averaged the findings across runs. The main findings consist of:

Figure 7. Accuracy vs. Q for different Synthetic Minority Over-Sampling Technique (SMOTE) settings

• The accuracy was obtained with the best combination of Q = 85 and SMOTE k = 5. The best combination of SMOTE k = 5 and Q = 85 accurately detected tampered regions. maintained the equilibrium of the class.

• I observe that compression artifacts are caused by low Q values, such as Q = 10. The performance of detection is lowered by the compression artifacts.

• High Q levels (such as Q = 90): Lower accuracy due to decreased sensitivity to minute manipulations.

• SMOTE effectiveness: I observed that, in comparison to training, SMOTE increased detection accuracy for all Q levels.

I observed that the findings were obtained using SMOTE with k = 5.

I examined the analysis. observed significant variations in accuracy for the various Q and SMOTE settings (p < 0.01). The findings indicate that the model's performance is influenced by the SMOTE parameters and the JPEG quality factor. Q = 85 with SMOTE k = 5 is the ideal configuration. Alarms are kept low when detection is provided by that setting.

5.6 Reducing feature dimensionality and assessing the model

After balancing the data using SMOTE, we used PCA on the training set to correct the dimensionality of the recovered picture features and reduce the possibility of overfitting. The feature collection was broken down into 20 components using PCA. The modifications were retained by PCA. dropped the extra items.

I trained an Artificial Neural Network (ANN) using the condensed feature set. The shallow ANN consists of two layers: a Softmax output layer with ReLU activation and a feature input layer that corresponds to the number of PCA components.

Table 3. Performance comparison of the Artificial Neural Network (ANN) classifier with and without Synthetic Minority Over-Sampling Technique (SMOTE) and Principal Component Analysis (PCA)

For 250 epochs, we used the Adam optimizer to train the network. The model received the following performance metrics upon training:

• Number of PCA components retained: 20.

• Training Accuracy (with SMOTE + PCA): 100.00%.

• Testing Accuracy (with SMOTE + PCA): 97.67%.

The results demonstrate that applying PCA effectively reduced the feature dimensionality while maintaining high classification performance, indicating improved generalization on unseen data.

A 92.19% reduction in feature dimensionality was achieved by reducing the 256 dimensions in the original feature vectors to 20 major components. Table 3 summarizes the classification results utilizing the decreased feature set with SMOTE. The model's performance was found to be unaffected by the dimensionality reduction, attaining 100% training accuracy and 97.67% testing accuracy, which is on par with the full-feature model using SMOTE. This suggests that PCA greatly reduces computing cost and mitigates overfitting while successfully preserving the most discriminative information.

The model may maintain classification performance despite significantly reducing feature dimensionality, as demonstrated by the use of PCA for dimensionality reduction. The model remains precise. The number of features is reduced by 92.19 percent when the 256-feature vectors are reduced to 20 major components. In addition to reducing expenses, the reduction lessens the possibility of overfitting associated with high-dimensional data. The ANN classifier trained with SMOTE and PCA maintains 100% training accuracy and 97.67% testing accuracy, which is comparable to the full-feature model's performance, as indicated in Table 1. These findings show that PCA successfully maintains the most useful characteristics required to distinguish between real and altered images, improving the classifier's efficiency and capacity for generalization.

5.7 Testing accuracy

The trained model was evaluated on three datasets—CASIA 2.0, CASIA 1.0, and CoMoFoD—to assess its performance and generalizability. The results are summarized in Table 4.

Table 4. Performance of the proposed method on different datasets

Figure 8. Normalized confusion matrix for CASIA 2.0 dataset

The normalized confusion matrix is displayed in Figure 8. I've noticed that just a small percentage of tampered and real photographs receive the incorrect designation.

I see that SMOTE-based data balancing in conjunction with the suggested ELA-DCT-SVD feature representation is effective in identifying picture manipulation across data sets. Additionally, I see that the suggested ELA-DCT-SVD feature representation manages copy-move and splicing operations and has good generalization.

5.8 Comparative analysis

To confirm that the proposed framework works, the results will be compared to those of other cutting-edge methods found in the literature. The comparison will encompass both traditional machine learning and deep learning methodologies that employed ELA and analogous feature extraction techniques on the CASIA 2.0 dataset, as delineated in Table 5.

The results display that the proposed method can do as well or better than both classical machine learning and deep learning methods when ELA features, DCT-based representations, and SMOTE data balancing are used together. This shows that the proposed framework works well for finding image tampering that is accurate and reliable.

Table 5. Comparison of the proposed method with the existing state-of-the-art