Hyper-Tuned Convolutional Neural Networks for Authorship Verification in Digital Forensic Investigations

1  Introduction

Authorship verification is critical in digital forensic investigations [1–3]. It involves identifying whether a particular piece of text was written by a specific individual [4], which has critical applications in areas such as plagiarism detection [5], identifying the source of threatening messages [6], and verifying the authenticity of digital documents [7]. The increasing prevalence of digital communication and the ease of creating fake identities make it increasingly challenging to determine authorship [8] accurately, and this has led to the development of various automated techniques for authorship verification [9–12]. Convolutional Neural Networks (CNNs) have emerged as a promising approach for authorship verification due to their ability to extract features from textual data effectively [13–17]. CNNs are a deep learning model widely used in image recognition tasks and have recently shown great potential in natural language processing applications [18–20].

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 [21], a CNN model was used to classify texts based on their authorship, achieving an accuracy of 85%. In another study [22], a hybrid model combining CNNs with other machine learning algorithms was used to identify the author of short texts with an accuracy of 95%. While these studies [23–25] demonstrate the effectiveness of CNNs in authorship verification, the choice of hyperparameters can significantly affect their performance. Therefore, hyperparameter tuning is crucial for achieving optimal performance with CNNs in authorship verification tasks.

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.

2  Related Work

In this section, we review the previous work [26–28] related to authorship verification using Convolutional Neural Networks (CNNs) and compare it with our proposed method. The problem of authorship verification has been studied extensively in digital forensics. Previous studies [29–31] have used various machine learning algorithms such as support vector machines [32], decision trees [33], and deep neural networks [34] to address this problem. In recent years, CNNs have emerged as a popular approach for authorship verification due to their ability to learn complex features from textual data [35–40]. One of the earliest studies [39] using CNNs for authorship verification. The authors used a multi-channel CNN architecture with character, word, and sentence embeddings as input features. The model achieved an accuracy of 76.6% on the PAN 2015 dataset, which was at that time the state-of-the-art performance.

Machine learning and deep learning show significant performance in many domains [41,42], inspired by these [30] proposed a CNN-based authorship verification method using word embeddings and achieved an accuracy of 83.15% on the same PAN 2015 dataset. They also compared their approach with other machine learning algorithms and showed that CNNs outperformed all other models. Another study [43] proposed a CNN-based approach for authorship verification using a combination of word and character embeddings. Their model achieved an accuracy of 87.34% on the same PAN 2015 dataset [44]. Our proposed method uses a hyper-tuned CNN model with three optimizers: ADAM, SGD, and RMSprop. We achieved up to 90% accuracy on the PAN 2015 dataset, which outperforms the previous studies mentioned above. Additionally, we use a combination of character and word embeddings as input features to the model, allowing the model to learn high-level and low-level features from the text.

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 Table 1 summarizes the results of previous studies and our proposed method.

3  Methodology

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.

Fig. 1 shows the complete architecture of the Convolutional Neural Network (CNN) model that has been proposed for author verification. The input to the model is a document or a piece of text that is first converted into a numerical representation using word embeddings. The word embeddings are fed into convolutional layers, extracting features from the input data. The output of the convolutional layers is then passed through a max-pooling layer, which samples the features and extracts the essential information. The output of the max-pooling layer is then flattened and passed through a fully connected layer, which maps the extracted features to a set of classes corresponding to the potential authors. The final output layer uses softmax activation to produce the probabilities of each class, which can be used to determine the most likely author. The figure also shows dropout regularization to prevent model overfitting and batch normalization from improving the stability and speed of training. Overall, the architecture of the proposed CNN model is designed to extract meaningful features from the input data and make accurate predictions for author verification.

Figure 1: Complete convolutional neural network (CNN) model for author verificationn

3.1 Data Collection

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.

Table 2 shows the details of the dataset, including the number of samples for each author, the age range of the authors, and the gender distribution. The dataset includes 1200 samples, with 100 samples per author. The authors range in age from 20 to 40, and there is an equal distribution of male and female authors in the dataset.

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 Eq. (1) as follows:

Authorship Accuracy Rate=Number of Correctly VerifiedTotal Number of Test Set Articles×100(1)

3.2 Model Description

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:

x=(w1,w2,…,we)

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

F={f1,f2,…,fk}

Let c be the output of the convolutional layers:

c=ReLU(F∗x)

Let p be the output of the pooling layer:

p=Pool(s)

Let h be the output of the fully connected layers:

h=Softmax(FC(p))

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

y=(0,0,…,1,…,0)

Let L be the categorical cross-entropy loss:

L=−sum(y∗log(y^))

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

3.3 Hyper-Tuned Convolutional Neural Network

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:

x=(w1,w2,…,wn)

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

F={f1,f2,…,fk}

Let c be the output of the convolutional layers:

c=ReLU(F∗x)

Let p be the output of the pooling layer:

p=Pool(c)

Let h be the output of the fully connected layers:

h=Softmax(FC(p))

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

y=(0,0,…,1,…,0)

Let L be the categorical cross-entropy loss:

L=−sum(y∗log(y^))

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.

3.3.1 Root Mean Square Propagation (RMSprop)

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:

St=γ∗S{t−1}+(1−γ)∗(gradientt)2(2)

where γ is the decay rate, and the gradient is the gradient of the loss function concerning the weights at iteration t.

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

Wt=W{t−1}−α∗gradienttsqrt(St+ε)(3)

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.

3.3.2 ADAM—Adaptive Moment Estimation

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:

mt=β1∗m{t−1}+(1−β1)∗gradientt(4)

vt=β2∗v{t−1}+(1−β2)∗(gradientt)2(5)

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:

mthat=mt(1−β1t)

vthat=vt(1−β2t)

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

Wt=W{t−1}−α∗mthat(sqrt(vthat)+ε)(6)

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.

3.3.3 Stochastic Gradient Descent (SGD)

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:

Wt=W{t−1}−α∗gradient2(7)

where α is the learning rate, and the gradien2t is the gradient of the loss function concerning the weights at iteration t.

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.

3.4 GAN Model

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.

3.4.1 Generator

The input to the generator is a random noise vector z, of size (batchsize,).

The generator applies convolutional and deconvolutional layers to z, gradually increasing the spatial resolution until it produces an output tensor of size (batchsize,channels,height,and width).

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 LG, such as binary cross-entropy:

G(z)=generator(z)LG=binarycrossentropy(G(z),X)(8)

3.4.2 Discriminator

The input to the discriminator is a sample X of size (batchsize,channels,height,and width).

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 LD:

D(X)=discriminator(X)D(G(z))=discriminator(G(z))LD=binarycrossentropy(D(X),1)+binarycrossentropy(D(G(z)),0)(9)

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.

3.5 Pairs of Generators and Discriminators

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:

L(G1)=−log(D1(R,F))

Generator G2 loss function:

L(G2)=−log(D2(F,R′))

Generator G3 loss function:

L(G3)=||R−R″||

Discriminator D1 loss function:

L(D1)=−log(D1(R,F))−log(1−D1(R,G1(R)))

Discriminator D2 loss function:

L(D2)=−log(D2(F,R′))−log(1−D2(F,G2(F)))

Discriminator D3 loss function:

L(D3)=−log(D3(R,R″))−log(1−D3(R,G3(R)))(10)

Here, ||R−R″|| is the L2 norm distance between the real author data R and the generated real author data R″.

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 ith generator can figure out the styles distribution of authentic texts from authors. The discriminator’s primary purpose is to identify differences between the groups of authors. This study makes use of the Language-based dataset. The dataset contains the author ID, Name, and Text: Fig. 2 shows schematics of the proposed generator and discriminator pairs in the proposed model.

Figure 2: Schematics of proposed generator and discriminator pairs in proposed model (See Fig. 1) at fully connected classification layer for author verification

3.6 Dataset Description

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. Table 3 shows the attributes of the dataset.

3.7 Tokenization

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 Fig. 3.

Figure 3: Tokenization of text

3.8 Embedding

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. Fig. 4 shows the dimensions and sequential lengths of embedded words.

Figure 4: Embedding

3.9 Model Architecture

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 Fig. 1. The detailed equations for each layer and component of the model are as follows:

1D Convolutional Layer: Let X be the input matrix of dimensions (batchsize,sequencelength,embeddingdim) dim, and W be the filter matrix of the dimensions (filtersize,embeddingdim,and nmfilters). Then, the output of the 1D Convolutional Layer is given by:

Hi=ReLU(W∗X{i:i+filtersize}+b)

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 (batchsize,sequencelength,n2mfilters), and k be the window size. Then, the output of the 1D Max Pooling Layer is given by:

M{i}=max(w{i:i+k−1})

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:

Y=softmax(W∗F+b)

where Y is the predicted class probabilities.

Generator: Let Z be the noise vector of dimensions (batchsize,latentx)-dim, and G be the generator function. Then, the output of the generator is given by:

G(Z)=X

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:

D(X)=Y{real}D(X′)=Y{synthetic}

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. Fig. 5 shows the proposed flow of this study.

Figure 5: Proposed architecture

3.10 Similarity of Text

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:

cos(theta)=(AdotB)(||A||||B||)

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:

A dot B=A[ 1 ]*B[ 1 ]+A[ 2 ]*B[ 2 ]+⋯+A[ n ]*B[ n ]

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

| | A | |=sqrt(A[ 1 ]2+A[ 2 ]2+⋯+A[ n ]2)

| | B | |=sqrt(B[ 1 ]2+B[ 2 ]2+⋯+B[ n ]2)

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.

3.11 Accuracy

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.

Accuracy=Number of Correct PredictionsTotal number of aprediction made

Accuracy=TruePositives+ TrueNegativesTruePositives+TrueNegatives+FalsePositives+FalseNegatives

4  Results And Discussions

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.

4.1 Ethical Considerations and Data Collection Requirements

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.

4.2 Performance

Table 4 below shows the Convolutional Neural Networks (CNN) model accuracy for each author without hyper-tuned optimizers. It has attained 81% precision, 82% recall, and 82.8% F1 score.

The given Fig. 6 shows the performance of default optimizer using precision, Recall and F1 score.

Figure 6: CNN = default optimizer (Precision, Recall and F1 score)

Fig. 7 shows the training accuracy/loss and testing accuracy/loss attained by Convolutional Neural Networks (CNN) model with default parameters at epoch 50. We have Hype-tuned its parameters to improve accuracy using three optimizers.

Figure 7: Performance convolutional neural networks (CNN) with default parameters

Table 5 below shows the Results of Convolutional Neural Networks (CNN) with Adaptive Moment (ADAM) Optimizer.

The given Fig. 8 shows the performance of ADAM optimizer using different evaluation metrics such as Precision, Recall and F1 score.

Figure 8: CNN = ADAM optimizer (Precision, Recall and F1 score)

Fig. 9 shows the training accuracy and loss attained by the Convolutional Neural Networks (CNN) model with Adaptive Moment (ADAM) at epoch 100. Table 6 below shows the Convolutional Neural Networks (CNN) model with Stochastic Gradient Descent (SGD) and accuracy for each author. It has attained 89% precision, 87% recall, and 87.5% F1 score, respectively.

Figure 9: Performance of convolutional neural networks (CNN) with ADAM optimizer

The given Fig. 10 shows the performance of SGD optimizer using different evaluation metrics.

Figure 10: CNN = SGD optimizer (Precision, Recall and F1 score)

Fig. 11 shows the training accuracy and loss attained by the Convolutional Neural Networks (CNN) model with Stochastic Gradient Descent (SGD) at epoch 100. Table 7 below shows the Convolutional Neural Networks (CNN) model with Stochastic Gradient Descent (SGD) and accuracy for each author. It has attained 85% precision, 86% recall, and an 85.4% F1 score.

Figure 11: Performance convolutional neural networks (CNN) with SGD optimizer

The given Fig. 12 shows the performance of RMSP optimizer using different evaluation metrics such as precision, Recall and F1 score.

Figure 12: CNN = RMSP optimizer (Precision, Recall and F1 score)

As shown in Fig. 13, we used convolutional neural networks (CNN) with the root mean square propagation (RMSProp) optimizer.

Figure 13: Convolutional neural networks (CNN) with root mean square propagation (RMSProp) optimizer

The results of our proposed approach for author verification using textual data have been discussed in this section. Additionally, Fig. 14 displays the confusion matrix of true and false class labels classified by the Adaptive Moment (ADAM) optimizer. We achieved an accuracy rate of 90% with the ADAM optimizer on the n-grams instance-based dataset used in this study. Other performance metrics, such as accuracy and recall, were also satisfactory, ranging from 80% to 100% and 86% to 98%, respectively, on an individual basis.

Figure 14: ADAM-based confusion matrix

A comparative analysis of our proposed framework with previous studies is shown in Table 8. Our proposed approach achieved significant improvement over previous state-of-the-art techniques. For instance, Shrestha et al. used CNN with N-gram embeddings on an English dataset with an accuracy of 76% to detect AV. In comparison, Halvani et al. used a PAN dataset comprising multiple languages with a supervised learning approach at an accuracy of 89%. Hessler et al. used an attention-based network topology for an English dataset, which resulted in 85% accuracy. In comparison, Nickel et al. used RNN for an English dataset to detect AV at an accuracy of 84%. Hossain et al. used a Bengali dataset and various supervised learning approaches, achieving the highest accuracy of 92%.

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 Section 4.1.

5  Conclusions

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.

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

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

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

References

1. J. Madden, V. Storey and R. Baskerville, “Identifying authorship from linguistic text patterns,” in Proc. of the 52nd Hawaii Int. Conf. on System Sciences, Huwaii, United States, pp. 5745–5754, 2019. https://doi.org/10.24251/hicss.2019.693 [Google Scholar] [CrossRef]

2. J. Hitschler, E. van den Berg and I. Rehbein, “Authorship attribution with convolutional neural networks and POS-Eliding,” in Association for Computational Linguistics, Vol. Proc. of the Workshop on Stylistic Variation, Copenhagen, Denmark, pp. 53–58, 2018. https://doi.org/10.18653/v1/w17-4907 [Google Scholar] [CrossRef]

3. B. Boenninghoff, S. Hessler, D. Kolossa and R. M. Nickel, “Explainable authorship verification in social media via attention-based similarity learning,” in 2019 IEEE Int. Conf. on Big Data, 2019, Los Angeles, CA, USA, pp. 36–45, 2019. https://doi.org/10.1109/BigData47090.2019.9005650 [Google Scholar] [CrossRef]

4. D. Rhodes, “Author attribution with CNNs,” 2015. [Online]. Available: https://www.semanticscholar.org/paper/Author-Attribution-with-Cnn-s-Rhodes/0a904f9d6b47dfc574f681f4d3b41bd840871b6f/pdf [Google Scholar]

5. H. van Halteren, “Linguistic profiling for author recognition and verification,” in Radboud Repository, East Stroudsburg: Association for Computational Linguistics Proc. ACL, pp. 199–206, 2004. https://doi.org/10.3115/1218955.1218981 [Google Scholar] [CrossRef]

6. G. Kambourakis, T. Moschos, D. Geneiatakis and S. Gritzalis, “Detecting DNS amplification attacks,” in Lecture Notes Computer Science (including Subser. Lect. Notes Artif. Intell. Lect. Notes Bioinformatics), vol. 5141. Berlin: Springer, pp. 185–196, 2008. [Online]. Available: https://doi.org/10.1007/978-3-540-89173-4_16 [Google Scholar] [CrossRef]

7. H. Al Amri, M. Abolhasan and T. Wysocki, “Scalability of MANET routing protocols for heterogeneous and homogenous networks,” Computer and Electrical Engineering, vol. 36, no. 4, pp. 752–765, 2010. [Google Scholar]

8. A. Romanov, A. Kurtukova, A. Shelupanov, A. Fedotova and V. Goncharov, “Authorship identification of a Russian-language text using support vector machine and deep neural networks,” Future Internet, vol. 13, no. 1, pp. 1–16, 2021. [Google Scholar]

9. A. Sboev, T. Litvinova, D. Gudovskikh, R. Rybka and I. Moloshnikov, “Machine learning models of text categorization by author gender using topic-independent features,” Procedia Computer Science, vol. 101, pp. 135–142, 2016. https://doi.org/10.1016/j.procs.2016.11.017 [Google Scholar] [CrossRef]

10. G. Terence and B. Dwyer, “Novel approaches to authorship attribution,” Ph.D. Dessertation, University of Groningen, The Netherlands, 2017. [Google Scholar]

11. A. Rehman, S. Naz, M. I. Razzak and I. A. Hameed, “Automatic visual features for writer identification: A deep learning approach,” IEEE Access, vol. 7, pp. 17149–17157, 2019. https://doi.org/10.1109/ACCESS.2018.2890810 [Google Scholar] [CrossRef]

12. A. Venčkauskas, R. Damaševičius, R. Marcinkevičius and A. Karpavičius, “Problems of authorship identification of the national language electronic discourse,” Communications in Computer and Information Science, vol. 538, pp. 415–432, 2015. https://doi.org/10.1007/978-3-319-24770-0 [Google Scholar] [CrossRef]

13. G. Kambourakis, T. Moschos, D. Geneiatakis and S. Gritzalis, “A fair solution to DNS amplification attacks,” in Second Int. Workshop on Digital Forensics and Incident Analysis (WDFIA 2007), Karlovassi, Greece, pp. 38–47, 2007. https://doi.org/10.1109/WDFIA.2007.4299371 [Google Scholar] [CrossRef]

14. A. Khatun, A. Rahman, M. S. Islam and Marium-E-Jannat, “Authorship attribution in Bangla literature using character-level CNN,” in 2019 22nd Int. Conf. on Computer and Information Technology (ICCIT), Dhaka, Bangladesh, pp. 18–20, 2019. https://doi.org/10.1109/ICCIT48885.2019.9038560 [Google Scholar] [CrossRef]

15. K. S. Digamberrao and R. S. Prasad, “Author identification using sequential minimal optimization with rule-based decision tree on indian literature in marathi,” Procedia Computer Science, vol. 132, pp. 1086–1101, 2018. https://doi.org/10.1016/j.procs.2018.05.024 [Google Scholar] [CrossRef]

16. S. Sierra, M. Montes-Y-gómez, T. Solorio and F. A. González, “Convolutional neural networks for author profiling: Notebook for PAN at CLEF 2017,” in CEUR Workshop Proc., Dublin, Ireland, 2017. [Google Scholar]

17. G. Kambourakis, T. Moschos, D. Geneiatakis and S. Gritzalis, “Detecting DNS amplification attacks,” in Critical Information Infrastructures Security, Berlin: Springer, pp. 185–196, 2008. [Online]. Available https://doi.org/10.1007/978-3-540-89173-4_16 [Google Scholar] [CrossRef]

18. G. Giorgi, A. Saracino and F. Martinelli, “Email spoofing attack detection through an end-to-end authorship attribution system,” in Proc. of the 6th Int. Conf. on Information Systems Security and Privacy (ICISSP 2020), Pisa, Italy, pp. 64–74, 2020. https://doi.org/10.5220/0008954600640074 [Google Scholar] [CrossRef]

19. M. Tschuggnall and B. Murauer, “Reduce & attribute: Two-step authorship attribution for large-scale problems,” in Proc. of the 23rd Conf. on Computational Natural Language Learning, Hong Kong, China, pp. 951–960, 2019. [Google Scholar]

20. A. Khormali, J. Park, H. Alasmary, A. Anwar, M. Saad et al., “Domain name system security and privacy: A contemporary survey,” Computer Networks, vol. 185, no. 21, 107699, 2021. [Google Scholar]

21. Y. Sari, “Neural and non-neural approaches to authorship attribution,” Ph.D. Dessertation, The University of Sheffield, England, 2018. [Google Scholar]

22. L. Tawalbeh, F. Muheidat, M. Tawalbeh and M. Quwaider, “IoT privacy and security: Challenges and solutions,” Applied Science, vol. 10, no. 12, pp. 1–17, 2020. [Google Scholar]

23. R. A. Sperotto and A. Pras, “DNSSEC and its potential for DDoS attacks: A comprehensive measurement study,” in Proc. ACM SIGCOMM Internet Measurement Conf. IMC, New York, NY, USA, pp. 449–460, 2014. https://doi.org/10.1145/2663716.2663731 [Google Scholar] [CrossRef]

24. M. Carlos-Mancilla, E. López-Mellado and M. Siller, “Wireless sensor networks formation: Approaches and techniques,” Journal of Sensors, vol. 2016, pp. 1–18, 2016. https://doi.org/10.1155/2016/2081902 [Google Scholar] [CrossRef]

25. M. R. Hossain, M. M. Hoque, M. A. A. Dewan, N. Siddique, M. N. Islam et al., “Authorship classification in a resource constraint language using convolutional neural networks,” IEEE Access, vol. 9, pp. 100319–100338, 2021. https://doi.org/10.1109/ACCESS.2021.3095967 [Google Scholar] [CrossRef]

26. W. Anwar, I. S. Bajwa, M. A. Choudhary and S. Ramzan, “An empirical study on forensic analysis of Language text using LDA-based authorship attribution,” IEEE Access, vol. 7, pp. 3224–3234, 2019. https://doi.org/10.1109/ACCESS.2018.2885011 [Google Scholar] [CrossRef]

27. S. Adamovic, V. Miskovic, M. Milosavljevic, M. Sarac and M. Veinovic, “Automated language-independent authorship verification (for Indo-European languages),” Journal of the Association for Information Science and Technology, vol. 70, no. 8, pp. 858–871, 2019. [Google Scholar]

28. M. Litvak, “Deep dive into authorship verification of email messages with the convolutional neural network,” Communication Computer Information Science, vol. 898, pp. 129–136, 2018. https://doi.org/10.1007/978-3-030-11680-4 [Google Scholar] [CrossRef]

29. N. E. Benzebouchi, N. Azizi, M. Aldwairi and N. Farah, “Multi-classifier system for authorship verification task using word embeddings,” in 2nd Int. Conf. on Natural Language and Speech Processing (ICNLSP) 2018, Algiers, Algeria, pp. 1–6, 2018. https://doi.org/10.1109/ICNLSP.2018.8374391 [Google Scholar] [CrossRef]

30. P. Shrestha, S. Sierra, F. A. González, P. Rosso, M. Montes-Y.-Gómez et al., “Convolutional neural networks for authorship attribution of short texts,” in 15th Conf. Eur. Chapter Assoc. Comput. Linguist. EACL 2017–Proc. Conf., vol. 2, pp. 669–674, 2017.https://doi.org/10.18653/v1/e17-2106 [Google Scholar] [CrossRef]

31. O. Halvani, L. Graner and I. Vogel, “Authorship verification in the absence of explicit features and thresholds,” in Lect. Notes Comput. Sci. (including Subser. Lect. Notes Artif. Intell. Lect. Notes Bioinformatics), vol. 10772. Cham: Springer, pp. 454–465, 2018. [Online]. Available https://doi.org/10.1007/978-3-319-76941-7_34 [Google Scholar] [CrossRef]

32. M. Abuhamad, J. su Rhim, T. AbuHmed, S. Ullah, S. Kang et al., “Code authorship identification using convolutional neural networks,” Future Generation Computer Systems, vol. 95, pp. 104–115, 2019. https://doi.org/10.1016/j.future.2018.12.038 [Google Scholar] [CrossRef]

33. B. Boenninghoff, R. M. Nickel, S. Zeiler and D. Kolossa, “Similarity learning for authorship verification in social media,” in IEEE Int. Conf. on Acoustics, Speech and Signal Processing (ICASSP), Brighton, UK, pp. 2457–2461, 2019. https://doi.org/10.1109/ICASSP.2019.8683405 [Google Scholar] [CrossRef]

34. O. Halvani, L. Graner and R. Regev, “TAVeer: An interpretable topic-agnostic authorship verification method,” in Proc. of the 15th Int. Conf. on Availability, Reliability and Security, New York, NY, United States, vol. 41, pp. 1–10, 2020.https://doi.org/10.1145/3407023.3409194 [Google Scholar] [CrossRef]

35. A. O. Agbeyangi, O. Abegunde and S. I. Eludiora, “Authorship verification of yorùbá blog posts using character N-grams,” in Int. Conf. in Mathematics, Computer Engineering and Computer Science (ICMCECS), Ayobo, Nigeria, vol. 2020, pp. 1–6, 2020. https://doi.org/10.1109/ICMCECS47690.2020.246982 [Google Scholar] [CrossRef]

36. M. A. Al-Khatib and J. K. Al-Daoud, “Authorship verification of opinion articles in online newspapers using the author’s idiolect: A comparative study,” Information and Communication Society, vol. 24, no. 11, pp. 1603–1621, 2021. https://doi.org/10.1080/1369118X.2020.1716039 [Google Scholar] [CrossRef]

37. J. Ordoñez, R. R. Soto and B. Y. Chen, “Will longformers PAN out for authorship verification?,” in Working Notes of Conf. and Labs of the Evaluation Forum (CLEF), Thessaloniki, Greece, pp. 22–25, 2020. [Google Scholar]

38. T. Kalsum, Z. Mehmood, F. Kulsoom, H. N. Chaudhry, A. R. Khan et al., “Localization and classification of human facial emotions using local intensity order pattern and shape-based texture features,” Journal of Intelligent & Fuzzy Systems, vol. 40, no. 5, pp. 9311–9331, 2021. [Google Scholar]

39. S. L. Marie-Sainte and N. Alalyani, “Firefly algorithm based feature selection for Arabic text classification,” Journal of King Saud University-Computer and Information Sciences, vol. 32, no. 3, pp. 320–328, 2020. [Google Scholar]

40. T. Saba, M. Bashardoost, H. Kolivand, M. S. M. Rahim, A. Rehman et al., “Enhancing fragility of zero-based text watermarking utilizing effective characters list,” Multimedia Tools and Applications, vol. 79, pp. 341–354, 2020. https://doi.org/10.1007/s11042-019-08084-0 [Google Scholar] [CrossRef]

41. A. Rahim, Y. Zhong, T. Ahmad and U. Islam, “An intelligent approach for preserving privacy and security in smart homes based on IoT using logit boost techniques,” Journal of Hunan University Natural Sciences, vol. 49, no. 4, pp. 372–388, 2022. https://doi.org/10.55463/issn.1674-2974.49.4.39 [Google Scholar] [CrossRef]

42. A. Rahim, Y. Zhong and T. Ahmad, “A deep learning-based intelligent face recognition method in the internet of home things for security applications,” Journal of Hunan University Natural Sciences, vol. 49, no. 10, 2022. https://doi.org/10.55463/issn.1674-2974 [Google Scholar] [CrossRef]

43. J. L. Herlocker, J. A. Konstan, L. G. Terveen and J. T. Riedl, “Evaluating collaborative filtering recommender systems,” Association for Computing Machinery(ACM) Transactions on Information Systems, vol. 22, no. 1, pp. 5–53, 2004. [Google Scholar]

44. A. Agarwal and M. Chauhan, “Similarity measures used in recommender systems: A study,” International Journal of Engineering Technology Science and Research IJETSR, 2017. [Online]. Available: www.ijetsr.com [Google Scholar]