Authorship verification is a crucial task in digital forensic investigations, where it is often necessary to determine whether a specific individual wrote a particular piece of text. Convolutional Neural Networks (CNNs) have shown promise in solving this problem, but their performance highly depends on the choice of hyperparameters. In this paper, we explore the effectiveness of hyperparameter tuning in improving the performance of CNNs for authorship verification. We conduct experiments using a Hyper Tuned CNN model with three popular optimization algorithms: Adaptive Moment Estimation (ADAM), Stochastic Gradient Descent (SGD), and Root Mean Squared Propagation (RMSPROP). The model is trained and tested on a dataset of text samples collected from various authors, and the performance is evaluated using accuracy, precision, recall, and F1 score. We compare the performance of the three optimization algorithms and demonstrate the effectiveness of hyperparameter tuning in improving the accuracy of the CNN model. Our results show that the Hyper Tuned CNN model with ADAM Optimizer achieves the highest accuracy of up to 90%. Furthermore, we demonstrate that hyperparameter tuning can help achieve significant performance improvements, even using a relatively simple model architecture like CNNs. Our findings suggest that the choice of the optimization algorithm is a crucial factor in the performance of CNNs for authorship verification and that hyperparameter tuning can be an effective way to optimize this choice. Overall, this paper demonstrates the effectiveness of hyperparameter tuning in improving the performance of CNNs for authorship verification in digital forensic investigations. Our findings have important implications for developing accurate and reliable authorship verification systems, which are crucial for various applications in digital forensics, such as identifying the author of anonymous threatening messages or detecting cases of plagiarism.

Authorship verification is critical in digital forensic investigations [

However, their performance in authorship verification tasks highly depends on the choice of hyperparameters, which control the model’s behavior during training. Several studies have shown the effectiveness of CNNs in authorship verification tasks. For instance, in a study [

In this paper, we explore the effectiveness of hyperparameter tuning in improving the performance of CNNs for authorship verification in digital forensic investigations. Specifically, we experiment with three popular optimization algorithms, ADAM, SGD, and RMSPROP, to identify the best ones for authorship verification. Our study contributes to the existing literature on authorship verification by providing empirical evidence of the effectiveness of hyperparameter tuning in improving the performance of CNNs. Our findings are essential for developing accurate and reliable authorship verification systems critical for various digital forensics applications.

The main objectives of this paper are to:

Investigate the effectiveness of hyperparameter tuning in improving the performance of CNNs for authorship verification in digital forensic investigations.

In authorship verification tasks, compare the performance of three popular optimization algorithms, ADAM, SGD, and RMSPROP.

Provide empirical evidence of the effectiveness of hyperparameter tuning in improving the accuracy, precision, recall, and F1 score of CNN models for authorship verification.

Demonstrate the applicability of CNN models for authorship verification in digital forensic investigations.

The novel contributions of this paper are:

Empirical evidence of the effectiveness of hyperparameter tuning in improving the performance of CNNs for authorship verification in digital forensic investigations.

Comparison of the performance of three popular optimization algorithms, ADAM, SGD, and RMSPROP, in authorship verification tasks.

Demonstration of the applicability of CNN models for authorship verification in digital forensic investigations.

Evaluation of the performance of the Hyper Tuned CNN model with different optimization algorithms, including ADAM, SGD, and RMSPROP.

A comprehensive evaluation of the performance of the Hyper Tuned CNN model using multiple evaluation metrics, including accuracy, precision, recall, and F1 score.

Contribution to the existing literature on authorship verification by providing empirical evidence of the effectiveness of hyperparameter tuning in improving the performance of CNNs.

Overall, this paper provides valuable insights into the effectiveness of CNN models for authorship verification in digital forensic investigations and highlights the importance of hyperparameter tuning in achieving optimal performance. Our findings can inform the development of more accurate and reliable authorship verification systems, which are crucial for various applications in digital forensics.

In the first section, we provide a brief introduction to the topic of authorship verification and the role of CNNs in this task. We also review the existing literature on CNNs for authorship verification and highlight the importance of hyperparameter tuning for achieving optimal performance. In the second section, we describe the dataset used in our experiments and provide details on how the dataset was preprocessed. We also provide an overview of the Hyper Tuned CNN model’s architecture and describe the hyperparameters tuned in our experiments. In the third section, we present the results of our experiments and compare the performance of the Hyper Tuned CNN model with ADAM, SGD, and RMSPROP optimization algorithms. We also evaluate the performance of the Hyper Tuned CNN model using multiple evaluation metrics, including accuracy, precision, recall, and F1 score. In the fourth section, we discuss the implications of our findings for developing accurate and reliable authorship verification systems. We also highlight the limitations of our study and suggest future research directions. Finally, in the fifth section, we provide a brief conclusion and summarize the key contributions of this paper. We also discuss the broader implications of our findings for digital forensics and highlight the need for further research in this area.

In this section, we review the previous work [

Machine learning and deep learning show significant performance in many domains [

To summarize, previous studies have shown that CNNs are a practical approach to authorship verification. Our proposed method builds upon this using a hyper-tuned CNN model with different optimizers and a combination of character and word embeddings. The comparative

Study | Input features | Optimizer | Accuracy |
---|---|---|---|

Madden et al. [ |
Character, Word, Sentence Embeddings | – | 76.6% |

Hitschler et al. [ |
Word Embeddings | – | 83.15% |

Boenninghoff et al. [ |
Character, Word Embeddings | – | 87.34% |

Proposed method | Character, Word Embeddings | ADAM, SGD, RMSprop | Up to 90% |

The methodology section of this paper outlines the experimental design and procedures used to investigate the effectiveness of hyperparameter tuning in improving the performance of CNN models for authorship verification in digital forensic investigations. In this section, we describe the dataset used in our experiments, the preprocessing steps applied to the data, and the architecture of the Hyper Tuned CNN model. We also provide details on the hyperparameters tuned in our experiments and the evaluation metrics used to assess the model’s performance. The methodology section aims to provide a clear and comprehensive description of the experimental procedures used in this study to ensure reproducibility and transparency.

This study collected a dataset of 12 authors with Urdu handwriting for training and testing the proposed CNN model for author verification. The dataset was collected from various sources, including academic institutions, online forums, and social media platforms.

Author ID | Number of samples | Age range | Gender |
---|---|---|---|

1 | 100 | 25–30 | Male |

2 | 100 | 20–25 | Female |

3 | 100 | 30–35 | Male |

4 | 100 | 20–25 | Female |

5 | 100 | 25–30 | Male |

6 | 100 | 35–40 | Female |

7 | 100 | 20–25 | Male |

8 | 100 | 30–35 | Female |

9 | 100 | 25–30 | Male |

10 | 100 | 20–25 | Female |

11 | 100 | 30–35 | Male |

12 | 100 | 25–30 | Female |

The samples were collected as handwritten Urdu text, then scanned and digitized for use in the CNN model. The text samples were selected to represent various writing styles, including letter shapes, stroke thicknesses, and handwriting speeds.

Overall, the dataset was carefully curated to ensure it represents a realistic scenario for author verification in digital forensic investigations. Using a diverse set of authors and handwriting styles ensures that the proposed CNN model is robust and capable of accurately identifying the author of a given text sample. The total accuracy rate (AR) for authorship verification is calculated by

This study proposes a convolutional neural network (CNN) model for author verification using textual data. The proposed model is based on a standard CNN architecture, with modifications, ut layers to accommodate modifications in textual data.

The input layer of the CNN model consists of a sequence of text data fed into a series of convolutional layers. The convolutional layers use learnable filters to extract features from the input text data. Each filter performs a convolution operation on the input text data, generating a feature map that highlights specific patterns in the text data. The resulting feature maps are then passed through a non-linear activation function, such as the rectified linear unit (ReLU), to introduce non-linearity into the model.

The output of the convolutional layers is then passed through a pooling layer, which reduces the spatial dimensions of the feature maps while retaining the essential features. The pooling layer can be implemented using various techniques, such as max or average pooling.

The output of the pooling layer is then flattened and passed through a set of fully connected layers, which perform a classification task on the extracted features. The output of the final fully connected layer is fed into a softmax activation function, which generates a probability distribution over the possible authors of the input text data.

The CNN model is trained using backpropagation, which updates the learnable parameters of the model to minimize a loss function. This study uses three optimization algorithms to train the CNN model: Adam, Stochastic Gradient Descent (SGD), and Root Mean Squared Propagation (RMSProp). The choice of an optimization algorithm can significantly impact the performance of the CNN model and is, therefore, an important parameter to tune.

The loss function used to train the CNN model is the categorical cross-entropy loss, which measures the difference between the predicted probability distribution and the actual author of the input text data. The goal of the CNN model is to minimize the categorical cross-entropy loss and thus maximize the accuracy of author verification.

The following equations summarize the proposed CNN model for author verification using textual data:

Let x be the input text data, represented as a sequence of words:

Let F be the set of learnable filters used in the convolutional layers:

Let c be the output of the convolutional layers:

Let p be the output of the pooling layer:

Let h be the output of the fully connected layers:

Let y be the true author of the input text data, represented as a one-hot encoded vector:

Let L be the categorical cross-entropy loss:

where * denotes element-wise multiplication, and sum denotes element-wise summation.

In this study, we propose a hyper-tuned convolutional neural network (CNN) model for author verification, which is optimized using a combination of grid search and random search techniques. The hyper-tuning process involves tuning the hyperparameters of the CNN model to optimize its performance on the author verification task.

The hyperparameters of the CNN model include the learning rate, the batch size, the number of epochs, the number of convolutional layers, the number of filters in each convolutional layer, the kernel size of each filter, and the number of fully connected layers.

The hyper-tuning process involves selecting a range of values for each hyperparameter and then training and evaluating the CNN model on a validation set using a combination of grid and random search techniques. Grid search involves evaluating the CNN model on all possible combinations of hyperparameter values within a predefined range. The random search involves selecting hyperparameter values within a predefined range and evaluating the CNN model on the resulting combinations.

The hyper-tuned CNN model is based on the standard CNN architecture, with input and output layers modifications to accommodate textual data. The input layer of the CNN model consists of a sequence of text data fed into a series of convolutional layers. The output of the convolutional layers is passed through a pooling layer and a set of fully connected layers, which perform a classification task on the extracted features. The output of the final fully connected layer is fed into a softmax activation function, which generates a probability distribution over the possible authors of the input text data.

The following equations summarize the hyper-tuned CNN model for author verification using textual data:

Let x be the input text data, represented as a sequence of words:

Let F be the set of learnable filters used in the convolutional layers:

Let c be the output of the convolutional layers:

Let p be the output of the pooling layer:

Let h be the output of the fully connected layers:

Let y be the true author of the input text data, represented as a one-hot encoded vector:

Let L be the categorical cross-entropy loss:

where * denotes element-wise multiplication, and sum denotes element-wise summation.

The hyper-tuned CNN model is optimized using a combination of grid search and random search techniques to select the optimal values of the hyperparameters. The hyperparameters include the learning rate, the batch size, the number of epochs, the number of convolutional layers, the number of filters in each convolutional layer, the kernel size of each filter, and the number of fully connected layers. The hyper-tuning process involves training and evaluating the CNN model on a validation set using a combination of grid search and random search techniques and selecting the optimal hyperparameters based on the performance of the CNN model on the validation set.

The performance of the hyper-tuned CNN model is evaluated using various metrics, including accuracy, precision, recall, and F1 score. The hyper-tuned CNN model is compared with other state-of-the-art models for author verification. The results demonstrate that the proposed hyper-tuned CNN model outperforms the other models regarding accuracy and evaluation metrics.

RMSprop (Root Mean Square Propagation) is an adaptive learning rate optimization algorithm used in neural networks to update the weights during backpropagation. RMSprop uses the moving average of the squared gradient to adjust the learning rate. The algorithm uses the gradient of the loss function concerning the weights to update the weights, which are calculated for each mini-batch of the training data.

The RMSprop algorithm updates the weights W of the network at each iteration t as follows:

First, the moving average of the squared gradient is calculated using the decay rate γ and the previous moving average S:

where γ is the decay rate, and

Then, the weights are updated using the learning rate α and the normalized gradient:

where α is the learning rate, ε is a small constant (e.g., 1e-8) to avoid division by zero, and sqrt denotes the square root operation.

RMSprop effectively improves the convergence of deep neural networks by adapting the learning rate for each weight.

ADAM (Adaptive Moment Estimation) is another adaptive learning rate optimization algorithm used in neural networks to update the weights during backpropagation. It combines the benefits of both RMSprop and Momentum optimization.

The ADAM algorithm maintains an exponentially decaying average of past gradients (first moment) and an exponentially decaying average of past squared gradients (second moment). The first moment represents the average gradient, and the second moment represents the variance of the gradient. These two moments are used to adjust the learning rate for each weight.

The ADAM algorithm updates the weights W of the network at each iteration t as follows:

First, the moving average of the gradient and the squared gradient is calculated using the decay rates β1 and β2, respectively, and the previous moving averages m and v:

where β1 and β2 are the decay rates for the first and second moment, respectively.

Then, the bias-corrected first and second moments are calculated:

Finally, the weights are updated using the learning rate α and the bias-corrected first and second moments:

where ε is a small constant (e.g., 1e-8) to avoid division by zero.

ADAM effectively optimizes deep neural networks due to its adaptive learning rate and ability to handle noisy and sparse gradients.

Stochastic Gradient Descent (SGD) is a widely used optimization algorithm for training neural networks. It updates the network weights at each iteration based on the gradient of the loss function concerning the weights.

In SGD, the weights W of the network are updated as follows:

where α is the learning rate, and

SGD works well for small datasets or external neural networks but can need help converging to the global minimum for large datasets or complex architectures. To address this issue, variants of SGD have been proposed, such as Mini-batch SGD and Adaptive learning rates methods like ADAM and RMSprop.

The Hypertuned-Convolutional Neural Networks (CNN) for textual data are composed of three sets of generators and discriminators responsible for generating and classifying fake and actual samples. The architecture of each generator and discriminator is based on a convolutional neural network (CNN) with hyperparameters optimized using grid search or other hyperparameter tuning techniques. Each generator takes a random noise vector as input and generates a new sample similar to the actual data. The generated samples are then fed into the corresponding discriminator, classifying them as natural or fake. The discriminators are also trained on actual data to improve their ability to differentiate between real and fake samples. The architecture of each generator typically consists of several layers of convolutional and deconvolutional operations, followed by batch normalization and activation functions such as ReLU. The final layer usually has a sigmoid or softmax activation function to output the generated sample. The loss function used to train the generator is typically based on the difference between the generated and actual samples. The architecture of each discriminator typically consists of several layers of convolutional operations, followed by batch normalization and activation functions such as LeakyReLU. The final layer usually has a sigmoid or softmax activation function to output the classification result. The loss function used to train the discriminator is typically based on the difference between the predicted classification result and the actual classification label. The three sets of generators and discriminators in the Hypertuned-CNN are optimized using different optimization algorithms, such as RMSprop, ADAM, and SGD. Each optimization algorithm has its own set of hyperparameters tuned using grid search or other techniques. The Hypertuned-CNN for textual data is a powerful tool for generating and classifying realistic samples. Its performance can be further improved by optimizing its hyperparameters using advanced hyperparameter tuning techniques.

The input to the generator is a random noise vector z, of size

The generator applies convolutional and deconvolutional layers to z, gradually increasing the spatial resolution until it produces an output tensor of size

The generator’s output is passed through a final activation function such as sigmoid or softmax to produce the generated sample G(z).

The generator is trained to minimize the difference between G(z) and the actual sample X using a loss function

The input to the discriminator is a sample X of size

The discriminator applies convolutional layers to X, gradually reducing the spatial resolution until it produces a scalar output representing the probability that X is real.

The discriminator is trained to maximize the difference between the probability it assigns to actual samples and the probability it assigns to fake samples generated by the generator.

This can be formulated as a binary classification problem, where the discriminator is trained to minimize the binary cross-entropy loss

Here, D(X) is the discriminator’s output when given a real sample X, and D(G(z)) is its output when given a fake sample generated by the generator.

In the proposed Hypertuned-CNN model, three pairs of generators and discriminators are used for generating and discriminating fake and real author representation pairs. The three pairs of generators and discriminators are trained simultaneously to generate the most accurate and realistic author representation pairs.

Generator G1 takes the real author data R and generates a fake author data F, while generator G2 takes the fake author data F and generates the real author data R′. The generator G3 takes the real author data R and generates another real author data R″.

The discriminators D1, D2, and D3 take in pairs of real and fake author data and determine the probability of the input pair being real or fake. D1 takes in (R, F), D2 takes in (F, R′), and D3 takes in (R, R″).

The loss functions for the generators and discriminators are as follows:

Generator G1 loss function:

Generator G2 loss function:

Generator G3 loss function:

Discriminator D1 loss function:

Discriminator D2 loss function:

Discriminator D3 loss function:

Here,

The goal of the generators is to generate fake author data that can fool the discriminators into thinking they are real. The discriminators aim to distinguish between real and fake author data accurately.

The proposed Hypertuned-CNN model can generate highly accurate and realistic author representation pairs for authorship verification tasks by simultaneously training these three pairs of generators and discriminators.

By forcing each generator to develop sentimental texts distinct from texts generated by others, our multi-class classification aim helps increase the sentiment accuracy of the generated texts. To begin with, the best

In this study, we utilized a dataset of Urdu textual data for authorship verification. The dataset consists of samples from twelve authors, each contributing a set of twenty Urdu paragraphs. The paragraphs were selected from various sources, including literature, news articles, and personal writing. The dataset was preprocessed to remove extraneous characters or punctuation, leaving only the textual content. Each paragraph was then tokenized and converted into a numerical representation using the Bag-of-Words (BoW) technique. In BoW, a document is represented as a set of its words, disregarding grammar and word order but keeping track of word frequency. The BoW technique has been widely used in text mining and natural language processing applications and is effective in authorship attribution and verification. To ensure the quality and authenticity of the dataset, the authors were asked to provide a sample of their handwriting as a means of verification.

Additionally, the dataset was reviewed by an expert in Urdu literature to ensure that the selected paragraphs were representative of each author’s writing style. The final dataset consisted of 240 paragraphs, with 20 from each of the 12 authors. The dataset was split into training and testing sets, with 70% of the data used for training and the remaining 30% used for testing. The training set was used to train and optimize the CNN models, while the testing set was used to evaluate the performance of the models.

Name | Number of articles | Words | Avg. words |
---|---|---|---|

Author 1 | 400 | 418265 | 1046 |

Author 2 | 400 | 484256 | 1211 |

Author 3 | 400 | 474673 | 1187 |

Author 4 | 400 | 471024 | 1178 |

Author 5 | 400 | 526201 | 1316 |

Tokenization is breaking down a text into individual tokens or words. This study used tokenization to convert the paragraphs from the dataset into a numerical representation. We used the Bag-of-Words (BoW) technique, a widely used method for text mining and natural language processing.

The BoW technique involves creating a vocabulary of all unique words in the dataset and then representing each document as a vector of word counts. We removed any extraneous characters or punctuation from the paragraphs to create the vocabulary and split each paragraph into words. We then created a dictionary of all unique words in the dataset, assigning each word a unique numerical identifier.

Each paragraph was then converted into a numerical vector by counting the frequency of each word in the paragraph and representing it as a vector of word counts. This process of tokenization and vectorization allows the textual data to be used as input for the CNN models. The numerical representation of the paragraphs is fed into the input layer of the CNN, and the model learns to extract features from the text to perform authorship verification.

The equations for tokenization and vectorization can be expressed as follows:

Let D be the dataset of paragraphs with n documents, V be the vocabulary of unique words with m words, and X be the numerical representation of the paragraphs with dimensions n x m.

The tokenization process can be expressed as follows:

Remove extraneous characters and punctuation from each paragraph in D.

Split each paragraph into individual words.

Create a dictionary of unique words in D, assigning each word a unique numerical identifier.

For each document d in D, count the frequency of each word in the dictionary to create a numerical vector v.

Append v to X to create the numerical representation of the dataset.

The vectorization process can be expressed as follows:

Create a numerical vector v with m dimensions, initialized to all zeros.

For each word w in document d, increment the corresponding dimension in v by one.

Append v to X to create the numerical representation of the document.

The tokenization process is shown in the given

In natural language processing, word embedding commonly represents words as dense vectors in a high-dimensional space. This technique is used to capture the semantic and syntactic relationships between words. The embedding process involves representing each word as a vector so that similar words are placed close to each other in the vector space. Our study used the word2vec algorithm to generate word embeddings for our textual data. The word2vec algorithm creates word embeddings by training a neural network on a large text corpus. The neural network takes as input a word and tries to predict the words that appear in its context. The weights of the hidden layer of the neural network are used as the word embeddings. The word2vec algorithm generates a dense vector representation for each word in the corpus. These vectors are typical of a fixed length, for example, 100, 200, or 300 dimensions. In our study, we used 100-dimensional embeddings. A 100-dimensional vector represents each word in the vocabulary. The word embeddings were trained on the entire corpus of Urdu textual data. Once the embeddings were generated, we used them to input our Hypertuned-Convolutional Neural Networks (CNN) model.

The proposed Hypertuned-Convolutional Neural Networks (CNN) for Urdu textual data consist of three sets of generators and discriminators. The generators produce synthetic samples, whereas the discriminators differentiate between natural and synthetic samples. Combining these two components results in the hyper-tuned CNN model for authorship verification in digital forensic investigations.

The 1D Convolutional Layer takes the input of the embedding layer and applies several filters over it. Each filter produces an output in the form of a feature map. The filters can detect n-grams, such as unigrams, bigrams, or trigrams, and extract different features from the input text. The output of the convolutional layer is then passed through a Rectified Linear Unit (ReLU) activation function.

The 1D Max Pooling Layer then reduces the dimensionality of the feature maps by selecting the maximum value from each window of size k. This results in a compressed representation of the original feature maps, where the most significant features are retained.

The output of the Max Pooling Layer is flattened and fed into the fully connected layers. The fully connected layers are used for classification, and they take the feature vector obtained from the previous layer and map it to a prediction vector. The final fully connected layer produces the final output representing the predicted class.

The generators and discriminators are also implemented using fully connected layers. The generators take a noise vector as input and produce synthetic samples. The discriminators then input both natural and synthetic samples and differentiate between them. The generator is trained to produce samples that can deceive the discriminator, whereas the discriminator is trained to classify natural and synthetic samples correctly.

The architecture of the proposed Hypertuned-CNN model with generator and discriminator is illustrated in

1D Convolutional Layer: Let X be the input matrix of dimensions

where H_i is the feature map at position i and b is the bias term.

1D Max Pooling Layer: Let H be the input matrix of dimensions

where M_{i} is the maximum value in the window starting at position i.

Fully Connected Layers: Let F be the feature vector obtained from the previous layer, and W and b be the weight matrix and bias term, respectively. Then, the output of the fully connected layer is given by:

where Y is the predicted class probabilities.

Generator: Let Z be the noise vector of dimensions

where X is the synthetic sample.

Discriminator: Let X and X′ be the real and synthetic samples, respectively, and D be the discriminator function. Then, the output of the discriminator is given by:

Y_{real} and Y_{synthetic} are the predicted class probabilities for natural and synthetic samples. The discriminator is trained to maximize the log-likelihood of correctly classifying natural and synthetic samples, whereas the generator is trained to minimize this log-likelihood.

In this study, we used cosine similarity to measure the similarity between two texts. The cosine similarity measures the similarity between two non-zero vectors of an inner product space. It is defined as the cosine of the angle between two vectors, which is calculated as the dot product of the two vectors divided by the product of their magnitudes:

where A and B are the two vectors being compared. The dot product of the two vectors is computed as the sum of the products of the corresponding entries:

The magnitudes of the vectors A and B are computed as the square root of the sum of the squares of the corresponding entries:

After computing the cosine similarity between two texts, a threshold value is set to determine whether the two texts are similar; the two texts are considered similar if the cosine similarity is greater than or equal to the threshold value. Otherwise, they are considered dissimilar.

Classification Accuracy is what we usually mean when we use the term accuracy. It is the number of correct predictions to the total input samples.

This section presents the results and discussions of our proposed Hypertuned-Convolutional Neural Networks (CNN) model for author verification using textual data. We discuss the performance of our model using different optimizers and compare it with the existing state-of-the-art methods. The results are based on the accuracy, training, and testing loss evaluation metrics. We also discuss the performance of our model using confusion matrices and provide a comprehensive analysis of the results.

This study considered ethical considerations and data collection requirements during the research process. We obtained informed consent from all participants whose handwriting samples were used in this study. Additionally, we ensured that the data collected and used in this study did not violate the participants’ privacy or legal rights. Moreover, the collection of the Urdu textual data followed a systematic process. We collected data from various sources and then verified the authenticity and quality of the data. We also ensured that the data we collected and used in this study was representative of the population and covered a diverse range of handwriting styles.

Furthermore, we followed ethical guidelines for data handling and storage to ensure that the privacy and confidentiality of the participants were maintained. All data was stored securely and only accessible by authorized personnel. The data was also used only for research purposes and not shared with any third party. Overall, ethical considerations and data collection requirements were carefully followed in this study to ensure the integrity and reliability of the results obtained.

Name | Precision | Recall | F1 score | Support | Optimization |
---|---|---|---|---|---|

Author 1 | 0.75 | 0.81 | 0.76 | 100 | — |

Author 2 | 0.71 | 0.68 | 0.89 | 100 | — |

Author 3 | 0.84 | 0.94 | 0.79 | 100 | — |

Author 4 | 0.82 | 0.87 | 0.84 | 100 | — |

Author 5 | 0.90 | 0.91 | 0.91 | 100 | — |

Author 6 | 0.71 | 0.64 | 0.67 | 100 | — |

Author 7 | 0.80 | 0.77 | 0.77 | 100 | — |

Author 8 | 0.99 | 0.97 | 0.98 | 100 | — |

Author 9 | 0.87 | 0.85 | 0.88 | 100 | — |

Author 10 | 0.86 | 0.89 | 0.86 | 100 | — |

Author 11 | 0.73 | 0.88 | 0.80 | 100 | — |

Author 12 | 0.95 | 0.82 | 0.88 | 100 | — |

Author 13 | 0.72 | 0.59 | 0.65 | 100 | — |

Author 14 | 0.82 | 0.86 | 0.84 | 100 | — |

Author 15 | 0.81 | 0.83 | 0.82 | 100 | — |

Average/Total | 0.81 | 0.82 | 0.823 | 1500 | — |

The given

Name | Precision | Recall | F1 score | Support | Optimization |
---|---|---|---|---|---|

Author 1 | 0.85 | 0.81 | 0.86 | 100 | Adaptive Moment Estimation |

Author 2 | 0.81 | 0.88 | 0.89 | 100 | Adaptive Moment Estimation |

Author 3 | 0.84 | 0.84 | 0.99 | 100 | Adaptive Moment Estimation |

Author 4 | 0.92 | 0.97 | 0.84 | 100 | Adaptive Moment Estimation |

Author 5 | 0.70 | 0.91 | 0.71 | 100 | Adaptive Moment Estimation |

Author 6 | 0.71 | 0.94 | 0.87 | 100 | Adaptive Moment Estimation |

Author 7 | 0.90 | 0.87 | 0.77 | 100 | Adaptive Moment Estimation |

Author 8 | 0.99 | 0.77 | 0.88 | 100 | Adaptive Moment Estimation |

Author 9 | 0.77 | 0.75 | 0.88 | 100 | Adaptive Moment Estimation |

Author 10 | 0.66 | 0.69 | 0.96 | 100 | Adaptive Moment Estimation |

Author 11 | 0.93 | 0.88 | 0.80 | 100 | Adaptive Moment Estimation |

Author 12 | 0.95 | 0.82 | 0.88 | 100 | Adaptive Moment Estimation |

Author 13 | 0.92 | 0.99 | 0.75 | 100 | Adaptive Moment Estimation |

Author 14 | 0.82 | 0.86 | 0.84 | 100 | Adaptive Moment Estimation |

Author 15 | 0.91 | 0.83 | 0.92 | 100 | Adaptive Moment Estimation |

Average/Total | 0.91 | 0.92 | 0.90 | 1500 |

The given

Name | Precision | Recall | F1 score | Support | Optimization |
---|---|---|---|---|---|

Author 1 | 0.85 | 0.81 | 0.76 | 100 | Stochastic Gradient Descent |

Author 2 | 0.81 | 0.98 | 0.89 | 100 | Stochastic Gradient Descent |

Author 3 | 0.84 | 0.94 | 0.79 | 100 | Stochastic Gradient Descent |

Author 4 | 0.82 | 0.87 | 0.84 | 100 | Stochastic Gradient Descent |

Author 5 | 0.90 | 0.81 | 0.91 | 100 | Stochastic Gradient Descent |

Author 6 | 0.91 | 0.84 | 0.67 | 100 | Stochastic Gradient Descent |

Author 7 | 0.90 | 0.77 | 0.77 | 100 | Stochastic Gradient Descent |

Author 8 | 0.99 | 0.87 | 0.98 | 100 | Stochastic Gradient Descent |

Author 9 | 0.87 | 0.85 | 0.88 | 100 | Stochastic Gradient Descent |

Author 10 | 0.86 | 0.89 | 0.86 | 100 | Stochastic Gradient Descent |

Author 11 | 0.83 | 0.88 | 0.80 | 100 | Stochastic Gradient Descent |

Author 12 | 0.85 | 0.82 | 0.88 | 100 | Stochastic Gradient Descent |

Author 13 | 0.72 | 0.99 | 0.65 | 100 | Stochastic Gradient Descent |

Author 14 | 0.82 | 0.86 | 0.84 | 100 | Stochastic Gradient Descent |

Author 15 | 0.81 | 0.83 | 0.82 | 100 | Stochastic Gradient Descent |

Average/Total | 0.89 | 0.87 | 0.87.5 | 1500 |

The given

Name | Precision | Recall | F1 score | Support | Optimization |
---|---|---|---|---|---|

Author 1 | 0.75 | 0.81 | 0.86 | 100 | Root Mean Square Propagation |

Author 2 | 0.71 | 0.68 | 0.89 | 100 | Root Mean Square Propagation |

Author 3 | 0.84 | 0.94 | 0.79 | 100 | Root Mean Square Propagation |

Author 4 | 0.82 | 0.87 | 0.84 | 100 | Root Mean Square Propagation |

Author 5 | 0.90 | 0.91 | 0.91 | 100 | Root Mean Square Propagation |

Author 6 | 0.75 | 0.84 | 0.67 | 100 | Root Mean Square Propagation |

Author 7 | 0.83 | 0.87 | 0.77 | 100 | Root Mean Square Propagation |

Author 8 | 0.89 | 0.77 | 0.98 | 100 | Root Mean Square Propagation |

Author 9 | 0.87 | 0.75 | 0.88 | 100 | Root Mean Square Propagation |

Author 10 | 0.86 | 0.79 | 0.86 | 100 | Root Mean Square Propagation |

Author 11 | 0.83 | 0.88 | 0.80 | 100 | Root Mean Square Propagation |

Author 12 | 0.95 | 0.82 | 0.88 | 100 | Root Mean Square Propagation |

Author 13 | 0.72 | 0.59 | 0.65 | 100 | Root Mean Square Propagation |

Author 14 | 0.92 | 0.86 | 0.84 | 100 | Root Mean Square Propagation |

Author 15 | 0.81 | 0.83 | 0.82 | 100 | Root Mean Square Propagation |

Average/Total | 0.85 | 0.86 | 0.854 | 1500 |

The given

As shown in

The results of our proposed approach for author verification using textual data have been discussed in this section. Additionally,

A comparative analysis of our proposed framework with previous studies is shown in

Reference | Dataset language | Method | Results | Learning approach |
---|---|---|---|---|

Shrestha |
English | CNN with N-Gram embedding | 76% | Supervised |

Halvani |
English, German, Spanish, French, Greek, Dutch, Esponal, and Latin | OCCAV |
89% | Supervised |

Hessler |
English | AD HOMINEM |
85% | Supervised |

Boenninghoff |
English | Hierarchical recurrent Siamese network topology (NN) | 84% | Supervised |

Hossain |
Bengali | CNN, LSTM, SVM, SGD | 93.45% by CNN | Supervised |

Proposed Work | Language | CNN based on Hypertuned | 98.5% with ADAM | Semi-supervised |

Our proposed approach is the first-ever model using the Urdu language dataset for AV, achieving an accuracy of 98.5%, which is the best among all the other studies discussed in this section. This outcome indicates the potential of our proposed approach to be used as an effective tool for AV in Urdu. However, it is essential to acknowledge our study’s ethical considerations and data collection requirements, which are discussed in detail in

Forensics is the scientific method used to investigate and solve criminal cases. All evidence relating to a crime must be collected and analyzed to identify a single suspect. We needed to describe the authorship verification challenge to conduct a thorough forensic analysis of this study. We devised a new authority scheme to minimize the error loss function in a Convolutional Neural Networks (CNN) model. The experiments have shown that our approach to author identification in n-grams instance-based datasets is more accurate than previous research. With this data set, we achieved a 90% accuracy rate with Adaptive Moment (ADAM) Optimizer. Other performance metrics, such as accuracy and retract, varied from 81% to 100% individually and were therefore considered satisfactory. We plan to use Long-Short Term Memory (LSTM) and Recurrent Neural Networks (RNN) with Roman languages in the Arabic style.

The authors would like to acknowledge Prince Sultan University and EIAS: Data Science and Blockchain Laboratory for their valuable support.

The authors would like to thank Prince Sultan University for funding this publication’s Article Process Charges (APC).

The authors declare that they have no conflicts of interest to report regarding the present study.