Edge Convolutional Networks for Style Change Detection in Arabic Multi-Authored Text

Abstract

The style change detection (SCD) task asks to find the positions of authors’ style changes within multi-authored texts. It has several application areas, such as forensics, cybercrime, and literary analysis. Since 2017, SCD solutions in English have been actively investigated. However, to the best of our knowledge, this task has not yet been investigated in Arabic text. Moreover, most existing SCD solutions represent boundaries surrounding segments by concatenating them. This shallow concatenation may lose style patterns within each segment and also increase input lengths while several embedding models restrict these lengths. This study seeks to bridge these gaps by introducing an Edge Convolutional Neural Network for the Arabic SCD task (ECNN-ASCD) solution. It represents boundaries as standalone learnable parameters across layers based on graph neural networks. ECNN-ASCD was trained on an Arabic dataset containing three classes of instances according to difficulty level: easy, medium, and hard. The results show that ECNN-ASCD achieved a high $F_1$ score of 0.9945%, 0.9381%, and 0.9120% on easy, medium, and hard instances, respectively. The ablation experiments demonstrated the effectiveness of ECNN-ASCD components. As the first publicly available solution for Arabic SCD, ECNN-ASCD would open the door for more active research on solving this task and contribute to boosting research in Arabic NLP.

1. Introduction

With the rapid development of Artificial Intelligence technologies and the availability of textual data, the demand has increased to differentiate between the styles of authors who collaboratively write a document. A style change detection (SCD) task focuses on finding the positions of writing style changes in multi-authored documents [1,2,3,4,5,6,7]. SCD plays a pivotal role in many practical applications. In the authorship attribution task, detecting positions of style changes can help segment a document before mapping each segment to its author [8]. In legal contexts, the demand for forensic linguistic and law enforcement applications motivates work on this task [8,9]. Analyzing linguistic cues of law documents, such as threatening letters or ransom notes, can provide valuable insights into the potential style changes. In security measures, analyzing writing styles and detecting changes in sensitive documents can help find unauthorized modifications. In plagiarism, SCD-based solutions can suggest potential plagiarism cases by identifying changes in writing style without comparing the suspected and source documents. In historical documents, such solutions can help to identify literary plagiarism [10]. In commerce, SCD-based solutions can help evaluate the consistency of writing assistance tools and guide proofreaders to improve the coherence of overall texts with the fewest possible breaks in the flow of the texts [8]. SCD-based solutions can also help institutions adhere to a specific style in their documents, maintaining credibility.

The SCD task is related to a particular language. For the English language, the annual organization of PAN competitions (https://pan.webis.de, accessed on 30 April 2025) has become an essential event for encouraging researchers to develop state-of-the-art (SOTA) solutions on English datasets [1,2,3,4,5,6,7,11]. To the best of our knowledge, there is no available SCD solution for the Arabic language.

Since 2020, most SCD solutions have detected the style changes based on pretrained models to embed inputs and Fully Connected (FC) layers for classification [4,5,6,7,11]. This approach represents any boundary surrounding two segments by concatenating these segments as a single input and subsequently classifies it. However, this approach may lose the contextual information and distinct style patterns presented within each segment. The concatenation may also lead to potential confusion in style boundaries, where one style ends and another begins. Concatenating two segments results in an input with a longer length, while most pretrained models restrict the input lengths. Therefore, another approach can be investigated to preserve the boundaries of each segment.

In addition, comprehending relationships between textual segments, such as words and sentences, would enhance the detection of writing styles. Graph-based solutions take a graph as input, trying to involve structural properties within the data. Graph Neural Networks (GNNs) extend the existing neural networks to operate on graph-structured data directly [12]. Recently, GNN models have achieved promising results for some Natural Language Processing (NLP) tasks, such as an authorship verification task that determines whether an unknown text was written by a specific author [13,14,15] and semantic relationship tasks that analyze semantic relations between textual segments [16,17,18,19,20,21,22,23,24,25,26,27,28]. To the best of our knowledge, no existing GNN-based solution is available for the SCD task.

In this paper, we introduce the Edge Convolutional Neural Network for the Arabic SCD task (ECNN-ASCD) based on GNNs to detect writing style changes in Arabic texts. ECNN-ASCD is considered the first solution to tackle the SCD task in Arabic texts to the best of our knowledge. It was trained particularly to learn the characteristics of Arabic writing styles. ECNN-ASCD serves as a baseline, encourages researchers to solve this task, and contributes to boosting research in Arabic NLP. Moreover, boundary representations in ECNN-ASCD help preserve the style within each segment surrounding these boundaries. The boundary representations are learnable and adjusted across layers. These representations are updated based on representations of surrounding segments and boundaries extracted from previous layers.

The remainder of this paper is organized as follows: Section 2 defines the SCD task and reviews the characteristics of the Arabic language related to the SCD task. Section 3 provides a detailed overview of the SOTA solutions. Section 4 describes the proposed solution. Section 5 presents the experimental evaluation and discusses the results. Section 6 summarizes the findings and suggests further directions.

2. Background

This section presents the definition of the SCD task based on the annual PAN competitions. It then briefly reviews the characteristics of Arabic texts regarding the SCD task.

2.1. Task Definition

The SCD task was introduced by PAN, belonging to the multi-author analysis tasks in NLP. It asks to find the locations of authors’ writing style changes in a multi-authored text. This task decomposes a multi-authored document into its authorial components by identifying the positions of style changes [1]. The authorial component contains one or more textual segments, such as one paragraph or consecutive paragraphs, written by the same author.

Table 1. Example of the SCD task.

	Document 1	Document 2
	This paragraph was written by the first author.	This paragraph was written by the first author.	Author 1
Author 1	This paragraph has two sentences. They were written by the first author.	Two sentences are in this paragraph. The second author wrote both sentences.	Author 2
	This paragraph as well was written by the first author.	The second author wrote this paragraph too.
	This paragraph was also written by the first author.	This paragraph also was written by the first author.	Author 1
Para. level	[0, 0, 0]	[1, 0, 1]
Sent. level	[0, 0, 0, 0]	[1, 0, 0, 1]

shows examples of writing style changes and provides the expected output for the SCD task. Document 1 is a single-authored document, while Document 2 is a multi-authored document written by two authors with two style changes. The SCD outcome is a set of binary values related to boundary positions at a specific level. The outcomes in the table are located at the paragraph and sentence levels. A boundary with Value 1 signifies a change between the textual segments around it, but Value 0 does not. As a result, the length of the result is equal to the number of textual components minus 1. PAN 2017 [1] asked to determine the change at the sentence level, while the paragraph level dominated in the coming editions PAN 2020 to PAN 2024 [4,5,6,7,11]. This study focuses on the paragraph level.

2.2. Arabic Language

Arabic is a Semitic language [29]. It differs from Indo-European languages alphabetically, morphologically, and syntactically. From an alphabetical perspective, there are twenty-eight Arabic letters. They have contextual variants that can be presented in different shapes depending on their position in words. For example, the letter “ع” (in this paper, an Arabic word is represented in some or all of three variants according to context: “Arabic word” ([Buckwalter Arabic transliteration [30]: English translation)) can be represented as “عـ” if the letter appears at the beginning of a word like “علم” ([Elm]: know), “ـعـ” if it appears in the middle like “العلم” ([AlElm]: the knowledge), “ـع” if it is at the end like “قطع” ([qTE]: cut), or “ع” if it appears independent of other letters like “باع” ([bAE]: sold). Moreover, Arabic does not support capitalization, which increases the difficulty of some information extraction and understanding tasks, including SCD.

From a morphology perspective, the Arabic templatic morphology interweaves patterns and affixes to roots [31]. For instance, the word “الطلاب” ([AlTlAb]: the students) was coined starting with the root: “طلب” ([Tlb]: request). Then the pattern “فعال” ([fEAl]) is applied to produce “طلاب” ([TlAb]: students). Finally, the prefix “ال” ([Al]: the) precedes the pattern to get the final word “الطلاب.” This structure differs from the concatenative languages, such as the English word “the students”, which was constructed by concatenating “the” and “s” with the word “student”. In some cases, a single Arabic word represents an English sentence. For example, the Arabic word “فأسقيناكموه” ([f>sqynAkmwh]: then we give it to you to drink) can be translated into English using eight words.

From a syntactic perspective, several Arabic grammatical rules differ from English ones. Arabic is a relatively free word-order language [29]. The order of sentences can be verb–subject–object, subject–verb–object, or object–verb–subject. Unlike English, Arabic sentences consider syntactic constituency. A noun and its modifiers must correspond in gender, number, and definiteness. In the case of two items, the quantifier and the noun must agree in gender. For example, “طالبتان اثنتان” ([TAlbtAn AvntAn]: two female students) is grammatically correct because the word “اثنتان” ([AvntAn]: two female) and the word “طالبتان” ([AvntAn]: two female students) are feminine. In the case of three items, the quantifier and the noun must not agree on gender. For example, the word “ثلاث” ([vlAv]: three) and the word “طالبات” ([TAlbAt]: female students) in the phrase “ثلاث طالبات” ([vlAv TAlbAt]: three female students) disagree on gender. It can also be noted that dual forms are supported in Arabic by concatenating dual pronouns, “طالبتان”, which are not present in English, where dual pronouns are typically separate words, “two students”.

These Arabic characteristics influence the way authors write their thoughts within linguistic structures. Each language has literary traditions that can inspire authors and influence their writing style. Arabic poetry, for instance, has a unique tradition with distinct meters that differ from those of English poetry. Arabic poetry is more symbolic, incorporates more complex metaphors, and follows more intricate rhyme patterns than English poetry [32].

Table 2. Arabic example of the SCD task.

	Document 1	Document 2
	هذه الفقرة كتبت من المؤلف الأول.	هذه الفقرة كتبت من المؤلف الأول.	Author 1
	هذه الفقرة تتكون من جملتين. وكتبت كلاهما	يمكن صياغة الفقرة الثانية من خلال جملتين
Author 1	من المؤلف الأول.	منفصلتين. حيث قام المؤلف الثاني بكتابتهما.	Author 2
	هذه الفقرة كتبها المؤلف الأول.	هذه الفقرة كتبها المؤلف الأول.	Author 1
Para. level	[0, 0]	[1, 1]
Sent. level	[0, 0, 0]	[1, 0, 1]

presents the Arabic example for the SCD task. The presented texts are shown in cursive script from right to left. There are significant differences between the two authors’ sentences in terms of length and structure. It has style changes similar to the English example in Table 1.

3. Related Work

Since 2017, several solutions have been proposed to address the SCD task in, particularly, the English language. According to the literature review conducted in this study, four prediction methods have been adopted: statistical, classical machine learning (ML), Deep Neural Networks (DNNs), and hybrid methods. These methods are investigated in the following subsections.

3.1. Statistical-Based Methods

These methods included selecting handcrafted features from given documents, including n-grams, part-of-speech tags, and punctuation marks. The set features were processed to predict style changes. Khan [33], Khan [34] studied different features and defined a measure for each type, including a ratio of character to space and a commonality index. A similarity score was then calculated by counting the common features between documents, assuming a style had changed if the score was less than a similarity threshold. Karas et al. [35] adopted a distribution test called the Wilcoxon Signed Rank Test [36] to predict the style changes. This test showed no change in style if two documents were derived from the same distribution; a change in the style would lead to putting the two documents into different distributions. However, its results were inaccurate in determining single-author documents because the test considered that every document already included a style change [35].

3.2. ML-Based Methods

There are two classes of classical ML methods, including supervised and unsupervised methods. In supervised methods, different classifiers, including logistic regression [37], random forest [38], and Support Vector Machine [39] classifiers, were investigated. Handcrafted-based solutions were developed based on one of these three classifiers [40,41,42,43] or by taking the weighted sum of them [44]. Nath [42] observed that the PAN 2018 dataset documents with a long length (≥4786 characters) have style changes. This observation was then used to train an additional classifier [42]. Despite this straightforward observation, the solution performed less than a top solution in Nath’s experiments by only 0.05 accuracy [42]. In addition, Zlatkova et al. [45] constructed a stacking ensemble solution of several ML algorithms to benefit from the characteristics of each algorithm [45]. They then trained the logistic regression classifiers as a meta-learner. In unsupervised methods, clustering algorithms were adopted to group documents into clusters according to the similarity of their writing styles. Documents with close similarity scores were grouped into one cluster, indicating that the same author wrote them. The K-means clustering algorithm [46] was the common algorithm used along with handcrafted features [10,47,48,49]. In contrast, Nath [50] and Castro-Castro et al. [51] designed their clustering algorithms. Although different similarity functions have been studied, the cosine similarity function is used the most. It outperformed the Manhattan and Matusita functions [52] and the Jaccard and Dice functions [47].

3.3. DNN-Based Methods

Long Short-Term Memory (LSTM) [53] and Convolutional Neural Network (CNN) [54] models were investigated for the SCD task. Deibel and Löfflad [55] developed a BiLSTM-based solution to tackle the SCD task at the sentence level. Schaetti [56] and Müller [57] developed CNN-based solutions to extract features. Nath [42,52] investigated GloVe embeddings [58] and developed a BiLSTM-based Siamese NN solution. A network constructed as a Siamese NN contains two identical neural subnetworks working in parallel and connected at their output [59]. In Nath’s experiments, the BiLSTM-based solution outperformed BiGRU-based and logistic regression-based solutions. However, Nath observed that increasing the number of units or layers consumes additional running time without yielding a better result [42,52]. Hosseinia and Mukherjee [60] developed an LSTM-based Siamese NN solution involving an attention mechanism. The difference between its subnetworks is in how they receive input. The first subnetwork receives the typical direction of a document while the second subnetwork receives the reverse direction to be similar to the backward pass in a BiLSTM architecture [60]. The similarity functions in Siamese NN-based solutions [42,52,60] measured the difference between subnetwork outputs followed by an FC layer to predict style changes. Adding similarity functions instead of other FCs increased the accuracy by 10% [60]. To further enhance performance, incorporating BERT [61] was investigated with CNN models [62] or with BiLSTM followed by CNN models [63]. Zi and Zhou [63] claimed that using the BiLSTM layer addresses the dependency between words in both directions and using the CNN layer reduces features and avoids overfitting.

3.4. Hybrid-Based Methods

These methods incorporated two of the previous methods in different stages. For example, the supervised- and unsupervised-based methods were incorporated. Singh et al. [43] trained the logistic regression classifier to predict similarity scores and then applied hierarchical clustering algorithms for assigning authors. Alvi et al. [40] trained the random forests classifier to predict the author’s number and then used the K-means clustering algorithm for assigning authors. Liu et al. [64] depended on the K-means clustering algorithm to detect the positions of the style change. Then they adopted a BiGRU-based Siamese NN involving attention mechanism layers for assigning authors [64]. Moreover, embedding models to extract features were incorporated with statistical or ML methods to predict changes. In statistical methods, Safin and Kuznetsova [65] vectorized documents using the Skip-Thoughts model [66]. A pairwise distance matrix was then constructed based on an average of cosine similarity values [65]. Rodríguez-Losada and Castro-Castro [67] tried to catch semantic information significantly at the sentence level instead of the word level by studying three Sentence-BERT-based pretrained models [68]. However, the average performance of these pretrained models did not exceed an accuracy of 63%. Thus, they combined them with additional representation, handcrafted features and then measured the similarity using the cosine similarity function [67]. In ML methods, investigated embedding models included FastText [69], BERT, DeBERTa [70], RoBERTa [71], ELECTRA [72], and mT0-xl [73]. The representation of texts using BERT was common in 2020–2022 [74,75,76,77,78]. In 2021, Deibel and Löfflad [55] claimed that the inferred information from a few features may not be enough to develop their solution. Thus, they averaged the representations of handcrafted features and the FastText model to tackle the SCD task at the document level before feeding them into an FC one [55]. In 2022, Jiang et al. [79] investigated ELECTRA to address a missing masked language modeling task while fine-tuning BERT. In 2023, each solution of DeBERTa-based [80,81], RoBERTa-based [82], and mT0-xl-based solutions [83] was compared with another solution that had a similar architecture but was based on BERT in ablation experiments. The results of these experiments showed that BERT-based solutions obtained less performance than the other solutions [80,81,82,83].

4. Proposed Solution: ECNN-ASCD

This section briefly reviews GNNs and focuses on two relevant modules to this study, Graph Convolutional Networks (GCNs) and EdgeConv. The section then describes the development of ECNN-ASCD in two phases. The first phase is designing a representative graph to display relationships for the SCD task. The second phase is adapting an appropriate GNN module to overcome its existing limitations to solve the SCD task.

4.1. GNNs

In 2009, the GNN framework was introduced by applying a message-passing scheme to propagate information across nodes [12]. Figure 1 illustrates the general propagation framework, where the colors assigned to the nodes are utilized for visual separation to distinguish between individual nodes in the graph structure. The input graph represents different computation graphs. Each node defines its computation graph based on its neighborhoods. The computation graph of the target node A appears on the right side of Figure 1. The message-passing scheme can be summarized in three steps. First, each target node computes a message for its neighbors. The rectangles filled with slanted black lines in Figure 1 represent messages from one node to its neighbors within the computation graph. Second, the target node receives and aggregates the messages from its neighbors. Third, the target node updates its representation. The solid gray rectangle in Figure 1 symbolizes the aggregation operation in the GNNs. These steps are applied to all nodes iteratively through multiple computation layers. Each node in the first layer uses information received from its immediate neighbors. By stacking two layers, the subsequent layer incorporates information from the neighbors of neighbors (2-hop neighborhood) derived from the first layer. Thus, stacking N layers enables nodes to utilize information with the N-hop neighborhood. This iterative nature enhances the capturing of dependence patterns in the graph data.

Formally, let $\mathcal{G}(\mathcal{V},E)$ be a graph, where $\mathcal{V}$ and E are the sets of nodes and edges, respectively. $X\in R^{n\times f}$ is a matrix containing representations of the length f for n nodes. Equation (1) shows the calculation of a representation of one node $i\in \mathcal{V}$ in the kth layer. Different aggregation functions can be used. Choosing these functions is still critical and attracting significant attention from researchers [84]. For example, the first function, $Ag{g}_1$, can average a set of prior representations of neighbors $\mathcal{N}\left(i\right)$ from the $k-1$th layer, while the second function, $Ag{g}_2$, can sum the result of the first function and the representation of the node i itself from the previous layer, $k-1$.

$${\mathbf{x}}_i^{\left(k\right)}=Ag{g}_2\left({\mathbf{x}}_i^{(k-1)},Ag{g}_1\left(\left\{{\mathbf{x}}_{\mathcal{N}\left(i\right)}^{(k-1)}\right\}\right)\right).$$

(1)

Kipf and Welling [85] introduced GCNs as one of the early GNN models. Its message-passing schema involves a symmetric-normalized aggregation and an element-wise nonlinear transformation, as shown in Equation (2). Initially, the messages from all the neighbors $\mathcal{N}\left(i\right)$ are symmetrically normalized by the degrees of both the neighbor $j\in \mathcal{N}\left(i\right)$ and the target i nodes. Subsequently, these messages are aggregated using a weighted summation. Finally, target node representations are updated by combining the aggregated messages with the current target node representations by a neural network transformation. While GCNs are widely used for diverse tasks [16,17,18,19,20,21,24,27,28], they encounter limitations diminishing their abilities. First, GCNs can handle edge weights within the adjacency matrices as shallow edge representations, while edges can contain richer information. Second, the iterative propagation in deep GCN architectures results in receiving similar messages. This similarity leads to shared representations across most nodes, less distinctiveness, and high convergence, known as an over-smoothing issue. Third, GCNs update node representations based on the degree of neighbors and target nodes. Thus, GCNs are structure-dependent. GCNs may struggle with noisy graphs that have sparsely labeled edges.

$${\mathbf{x}}_i^{\left(k\right)}=\sum _{j\in \mathcal{N}\left(i\right)\cup \left\{i\right\}}{\displaystyle \frac{1}{\sqrt{deg\left(i\right)}·\sqrt{deg\left(j\right)}}}·\left({\mathbf{W}}^{\top }·{\mathbf{x}}_j^{(k-1)}\right).$$

(2)

Several methodologies have been proposed to incorporate edge representations in GNNs. EdgeConv [86] has emerged as one of the convolutional modules applied in three-dimensional data and point clouds. It attempts to benefit from edge and node representations as shown in Equation (3). The edge representations are passed in messages by measuring the differentiation between the target i and the neighbor $j\in \mathcal{N}\left(i\right)$ representations. These messages are summed with the target node representations via a neural network. These messages are subsequently aggregated. Three built-in aggregation operations are in the EdgeConv module: “add”, “mean”, and “max” operations. The update step in EdgeConv is similar to GCNs that fuse aggregated messages with the current target node representations. While EdgeConv deals with edge representations, it may suffer from the over-smoothing issue.

Table 3. Symbol definitions.

Symbol	Definition
$\mathcal{G}(\mathcal{V},E)$	$\mathcal{G}$: input graph, $\mathcal{V}$: node set, and E: edge set
|$\mathcal{V}$| = n	n number of nodes
$i\in \mathcal{V}$	Nodes in $\mathcal{G}$
$e_{ij}\in E$	Edges in $\mathcal{G}$ located between every two consecutive nodes i and j
$j\in \mathcal{N}\left(i\right)$	Set of one-hop neighbors of node i in $\mathcal{G}$
$deg\left(i\right)$	Degree of node i
$W^k$	Trainable weight matrix at layer k
$X\in R^{n\times f}$	Node feature matrix for n nodes
${\mathbf{x}}_i^k\in R^f$	f-dimensional node embedding of node i at layer k
$E\in R^{n-1\times f}$	Edge feature matrix for $n-1$ edges
$e_{ij}^k\in R^f$	f-dimensional node embedding of edge $ij$ at layer k
$Agg(·)$	Aggregation function
$\sigma (·)$	Nonlinear activation function
⊕	Summation operation

summarizes key symbols used in this paper.

$${\mathbf{x}}_i^{\left(k\right)}=\mathrm{Agg}\left(\left\{{\mathbf{W}}^{\top }·\left({\mathbf{x}}_{\mathcal{N}\left(i\right)}^{(k-1)}-{\mathbf{x}}_i^{(k-1)}\right)+{\mathbf{W}}^{\top }·{\mathbf{x}}_i^{(k-1)}\right\}\right).$$

(3)

4.2. Graph Design

This subsection describes how the documents are formulated as graphs in this study. The preprocessing step is applied to the input documents as shown in Algorithm 1. The step includes segmenting texts into paragraphs to detect the style changes at the paragraph level. The preprocessing also verifies document consistency by checking paragraph counts with labels. Algorithm 1 returns the embeddings of the input documents. This research uses pretrained models to represent paragraphs because they have provided high results in SOTA solutions. For example, 14 pretrained-based models out of 15 participated solutions in the latest edition, PAN 2024, achieved a higher $F_1$ score than a handcrafted-based model that participated in the same year [11]. The SCD task deals with each document in the input data separately. In other words, the task does not look for a common writing style between two documents. Thus, there is no direct relationship between any two documents. Therefore, each document can be treated as a disjoint subgraph. This separation helps decrease the complexity and sparsity of graphs. Every subgraph corresponds to a document in the input data. Each node in a subgraph represents a paragraph in the document. This design preserves each paragraph’s individual representation, thereby preserving each one’s contextual information. Edges connect the preceding to succeeding paragraphs, capturing the sequential flow within the document. This subgraph can be constructed as a path graph.

Algorithm 1 Preprocessing

Input: $Docs$: A dataset,    B: Boundaries’ list as ground-truth labels Output: $Re{p}_{Doc}$: Dataset representations at the paragraph level 1: $Re{p}_{Doc}\leftarrow \varnothing$ 2: for all  $doc\in Docs$  do 3:     $para\leftarrow$ segmenting_paragraphs($doc$) 4:     $para\leftarrow$ checkConsistency($para$,B)       //Compared to ground truth information 5:     $Re{p}_{para}\leftarrow$ pretrained_model($para$) 6:     $Re{p}_{Doc}\leftarrow Re{p}_{Doc}\cup Re{p}_{para}$ 7: end for 8: Return  $Re{p}_{Doc}$

Algorithm 2 shows the main design steps of the graph $\mathcal{G}(\mathcal{V},E)$. After applying the preprocessing step, all the nodes in a subgraph ${\mathcal{G}}_{doc}$ will contain the representations of the paragraphs located in one document. Edges are added between every two consecutive nodes without initializing their representations. The ground-truth labels are assigned to edges. The edges correspond to boundaries between paragraphs. Hence, classifying these edges determines whether the writing style changes between paragraphs.

Algorithm 2 Graph design

Input: $Docs$: A dataset,          B: Boundaries’ list as ground-truth labels Output: $\mathcal{G}(\mathcal{V},E)$: A graph with nodes and edges 1: $Docs\leftarrow$ Algorithm 1 ($Docs$) 2: $\mathcal{G}\leftarrow \varnothing$ 3: for $doc\leftarrow 1$ to |$Docs$| do 4:     ${\mathcal{G}}_{doc}\leftarrow \varnothing$ 5:     $Re{p}_{doc}\leftarrow$ extract_represent($doc$) 6:     ${\mathcal{G}}_{doc}$.add_nodes($Re{p}_{doc}$)                    //${\mathcal{G}}_{doc}$ is updated with added nodes 7:     ${\mathcal{G}}_{doc}$.add_consecutive_edges($doc$)     //${\mathcal{G}}_{doc}$ is updated with added edges 8:     for all $e_{ij}\in E_{doc}$ do               //All edges in ${\mathcal{G}}_{doc}$ are mapped to labels 9:         if $B\left[e_{ij}\right]$ =0 then 10:            $e_{ij}$.label = 0 11:         else 12:            $e_{ij}$.label = 1 13:         end if 14:     end for 15:     $\mathcal{G}\leftarrow \mathcal{G}\cup$${\mathcal{G}}_{doc}$ 16: end for 17: Return  $\mathcal{G}$

It is noteworthy that the SCD task focuses on boundaries between only consecutive paragraphs. However, other graph structures, like a complete graph, can focus on different possible combinations of two paragraphs, which do not accurately reflect the task. For example, Document 2 in Figure Table 1 is represented in Figure 2 at the paragraph level using two graph structures: path and complete graphs. The edges in the path graph represent the original edges that express ground-truth labels in a dataset. The other edges in the complete graph represent additional edges that are added to illustrate the completeness concept. The bold edges hold trusted labels that can be determined directly from the ground-truth labels. However, the remaining edges in a complete graph may not hold trusted labels. These labels cannot be determined directly from the ground-truth labels, as seen with dotted edges in Figure 2. The complete graph can also produce another issue related to the labels’ distribution. The distribution of binary labels in the complete graph may not correspond to the original distribution in datasets. In Figure 2, the distribution of zero in the path graph is ${\displaystyle \frac{1}{3}}$, while its distribution in the complete graph is ${\displaystyle \frac{1}{6}}$.

4.3. GNNs for the SCD Task

The graph edges proposed in Section 4.2 represent the writing styles. These styles need to be classified for the SCD task. Thus, EdgeConv was adapted to handle the edge representations. Figure 3 shows the ECNN-ASCD’s architecture. The input graph ${\mathcal{G}}^{\left(0\right)}$ has initial node representations $X_{N\times F^{\left(0\right)}}^{\left(0\right)}$ with an empty set of edge representations, where $N\times F^{\left(0\right)}$ represents the shape of the node representation matrix. To extract more non-local features, the ECNN-ASCD’s architecture comprises four layers. They contain the same components except the first layer. Every layer k generates new edge representations $E_{N-1\times F^{\left(k\right)}}^{\left(k\right)}$, where the number of edges is equal to the number of nodes minus one. Every layer’s node and edge representations are input to the subsequent layer. The symbol ⊕ indicates to sum the required information to obtain the edge representations. After passing through four layers, the output graph ${\mathcal{G}}^{\left(4\right)}$ is obtained with node representations $X_{N\times F^{\left(4\right)}}^{\left(4\right)}$ and edge representations $E_{N-1\times F^{\left(4\right)}}^{\left(4\right)}$. The ECNN-ASCD’s architecture ends with a single FC layer. It classifies the edge representations extracted from the last layer. Moreover, activation functions introduce non-linearities in mapping input values to desired outputs during training instead of being restricted to modeling only linear relationships. Two activation functions were adopted: ReLU and Sigmoid. ReLU has a simple mathematical operation, the comparison to zero, which helps get faster training times in deep networks. Sigmoid is placed at the final layer before detecting using a threshold of 0.5 to round outputs to 0 and 1.

The default EdgeConv module feeds the input node representations into a neural network. In ECNN-ASCD, two sequential linear layers are used as the neural network. The first layer concatenates node representations with those of their neighbors. This concatenation results in a doubling of the input size. The second layer maps the concatenated node representations to half of their size. Thus, the EdgeConv module reduces the input size. Therefore, FC layers are inserted in every ECNN-ASCD layer to apply a linear transformation to the representation vectors. The aggregation method in this EdgeConv module calculates the mean value of the transformed neighbor representations to update the target node representations. Algorithm 3 outlines the operations performed in every ECNN-ASCD layer. A layer k receives the graph resulting from the previous layer ${\mathcal{G}}^{(k-1)}$. Their edge representations $E^{(k-1)}$ are extracted, whereas the first layer does not receive the previous edge representations because they have an empty set. The previous node representations, $X^{(k-1)}$, are fed into the EdgeConv module to generate the new node representations, $X^{\left(k\right)}$. The initial node representations, $X^{\left(0\right)}$, are added in each GNN layer to alleviate the over-smoothing issue. These representations are aggregated by summing them. Thus, the edge representations in the layer k are updated and adjusted across layers.

Algorithm 3 An ECNN-ASCD layer

Input: ${\mathcal{G}}^{(k-1)}$: A graph at the $k-1$ layer with their node and edge representations,            $X^{\left(0\right)}$: The original node representations Output: ${\mathcal{G}}^{\left(k\right)}$: A graph at the k layer with updated node and edge representations 1: $E^{(k-1)}\leftarrow$ extract_edge_representations (${\mathcal{G}}^{(k-1)}$) 2: if  $E^{(k-1)}\ne \varnothing$  then 3:     $E^{(k-1)}\leftarrow$ FC ($E^{(k-1)}$) 4: end if 5: ${\mathcal{G}}^{\left(k\right)}\leftarrow$ EdgeConv (${\mathcal{G}}^{(k-1)}$) 6: $X^{\left(k\right)}\leftarrow$ extract_node_representations (${\mathcal{G}}^{\left(k\right)}$) 7: $X^{\left(k\right)}\leftarrow$ activation_fun ($X^{\left(k\right)}$)               //${\mathcal{G}}^{\left(k\right)}$ is updated with these node representations 8: $X^{\left(0\right)}\leftarrow$ FC ($X^{\left(0\right)}$) 9: for all  $e_{ij}\in E^{(k-1)}$  do 10:     $e_{ij}^{\left(k\right)}\leftarrow$$e_{ij}^{(k-1)}$ +$x_i^{\left(k\right)}$+$x_j^{\left(k\right)}$+$x_i^{\left(0\right)}$ 11: end for 12: $E^{\left(k\right)}\leftarrow$ do_dropout($E^{\left(k\right)}$)             //${\mathcal{G}}^{\left(k\right)}$ is updated with these edge representations 13: Return  ${\mathcal{G}}^{\left(k\right)}$

Equation (4) shows how the edge representations ${\mathbf{e}}_{ij}^{\left(k\right)}$ can be updated, where $\sigma (·)$ represents a nonlinear activation function, $Ag{g}^k$ represents the aggregation function of the $k^{th}$ layer, $x_i$ and $x_j$ indicate the representations of end nodes i and j of edge $e_{ij}$ ($j\in \mathcal{N}\left(i\right)$), and $W^k$ is a learnable parameter in the layer k that adjusts the dimension of output representation vectors. The edge representations in each layer are updated according to the new node representation in the same layer. The graph ${\mathcal{G}}^{\left(k\right)}$ with the node and edge representations of the current layer k is returned using Algorithm 3.

$${\mathbf{e}}_{ij}^{\left(k\right)}={\mathbf{Agg}}^k({\mathbf{W}}_e^k{\mathbf{e}}_{ij}^{(k-1)},\sigma \left(EdgeCon{v}_k({\mathbf{x}}_i^{k-1},{\mathbf{x}}_j^{k-1})\right),{\mathbf{W}}_0^k{\mathbf{x}}_i^0).$$

(4)

5. ECNN-ASCD Evaluation

The evaluation of ECNN-ASCD was conducted on an Arabic SCD dataset. Ablation experiments were also conducted to validate the contribution of each component in ECNN-ASCD. The following subsections describe the settings of the experiments, discuss their results, and show how to adopt the proposed method to solve the SCD task for English.

5.1. Experiment Settings

The same settings were used for all the experiments. They are identified from different aspects and described in this subsection, including the datasets, models for comparison, setup of the environment, techniques, and evaluation metrics.

• Datasets: AraSCD (https://github.com/abeersaad0/SCD/tree/main, accessed on 30 April 2025) is a large Arabic dataset for SCD. It holds 30,000 documents extracted from several publicly available Arabic linguistic resources. It contains three classes of instances according to difficulty level: hard, medium, and easy. The criteria for this classification focus on categories of texts and the time period during which these texts were written. AraSCD encompasses three categories of text, poetry, books, and newspapers, which exhibit diverse author backgrounds and may enrich AraSCD with varying writing styles. Hard instances were written by five poets during a single era; medium instances were authored by both three poets of the same age and two writers who wrote two books on a similar domain; and easy instances encompass texts written by two poets from two different eras, two writers of two books covering two distinct topics, and one newspaper writer.

  Table 4. AraSCD statistics.

  Level	# Doc.	Avg. Doc. Leng.	Avg. Para. Leng.	Avg. Style Change
  Easy	10,000	11.4221 para.	150.2 words	4.52 changes (43.33%)
  Medium	10,000	14.4912 para.	125.0 words	5.66 changes (41.96%)
  Hard	10,000	14.7409 para.	124.4 words	5.82 changes (42.32%)

  provides an overview of its statistics. Each level has the same number of documents. The average lengths of documents and paragraphs are measured as the average number of paragraphs and words, respectively, per document. The average number of style changes is measured per document. The percentage of style changes signifies the ratio of changes relative to all boundaries in the dataset.
• Baseline models: Two baseline models were evaluated on each test set in AraSCD. First, Baseline-Predicting 0 (Baseline-Pr0) assigns the value 0 to all predicted labels, implying no style changes across all boundaries in the test sets. Hence, this baseline model predicts that all documents are single-authored. Second, Baseline-Predicting 1 (Baseline-Pr1), in contrast, assigns the value 1 to all predicted labels, suggesting that changes in writing styles occur across all test set boundaries. As a result, this baseline model suggests that all documents are written by multiple authors.
• Other models for comparison: Since no prior Arabic work had been conducted, two models were developed in this study for comparison purposes with the results of ECNN-ASCD. First, a basic machine learning model named BERT-MLP was developed. It encodes the input using AraBERTv02 (https://huggingface.co/aubmindlab/bert-base-arabertv02, accessed on 30 April 2025), which is the same selected pretrained model for ECNN-ASCD. BERT-MLP classifies the input based on two FC layers with 128 neurons. It is worth noting that the classification in the FC layers maps one sample in the input with one predicted output. Thus, a sample for BERT-MLP is a boundary represented by concatenating two sequential paragraphs separated by a [SEP] token. Second, GCNN-ASCD was developed based on the GCN module. For a fair comparison, GCNN-ASCD maintained the same ECNN-ASCD architecture except for replacing the EdgeConv module with the GCN module in all the layers.
• Environment setup: All the experiments were run on a computer with an Intel(R) i7 processor up to 5.60 GHz, 64-bit, ASUS TUF RTX 4090 24 GB OC GAMING, and 64 GB (2 × 32 GB) DDR5 5600 Mhz.
• Technical setup: Python 3.12 and the PyTorch 2.4 framework were used to develop the models. Each input document is used as a single batch to update the weights, as the test phase in the real scenario is applied to at least one document. The hyperparameter settings that were used during the training for model optimization are summarized in

  Table 5. Predefined hyperparameters.

  Hyperparameter	Seed	Optimizer	Dropout	Batch	Max Sequence Length	Warmup Rate
  Value	42	Adam *	0.5	1	256	0.1

  * https://docs.pytorch.org/docs/stable/generated/torch.optim.Adam.html (accessed on 30 April 2025).

  .
• Evaluation metrics: The F₁ score metric (https://scikit-learn.org/1.5/modules/generated/sklearn.metrics.f1_score.html, accessed on 30 April 2025) is a common performance measure used in classification tasks [87]. The macro-averaged F₁ score measures a macro-average of correctly predicted style change detection positions compared to the total number of positions without considering the proportion of each class, change or no change, in the dataset. We recall that the SCD task considers the style change case as the positive class for evaluating models. The macro-averaged F₁ score is used in evaluating solutions submitted for PAN competitions from 2020 to 2024 [4,5,6,7,11]. The other two metrics can be derived from the confusion matrix, which are precision and recall, as shown in Equations (5)–(7). Precision measures how many correctly classified change positions are among all predicted change positions. The high precision indicates that the classifier classifies the correct change positions more than it incorrectly classifies as change positions. Recall measures how many correctly classified change positions are among all ground-truth change positions. The higher the recall, the more correctly the change positions are classified. The macro-averaged precision and recall metrics were used to compare ECNN-ASCD’s performance with that of the other models on AraSCD.

$$\mathrm{Precision}={\displaystyle \frac{\mathrm{TruePositives}}{\mathrm{TruePositives}+\mathrm{FalsePositives}}}$$

(5)

$$\mathrm{Recall}={\displaystyle \frac{\mathrm{TruePositives}}{\mathrm{TruePositives}+\mathrm{FalseNegatives}}}$$

(6)

$${\mathrm{F}}_1={\displaystyle \frac{2\ast \mathrm{Precision}\ast \mathrm{Recall}}{\mathrm{Precision}+\mathrm{Recall}}}.$$

(7)

5.2. Results and Discussion

The evaluation of ECNN-ASCD includes tuning its hyperparameters, examining its components through ablation experiments, and comparing its results to those of other developed models. These experiments are discussed below.

5.2.1. Hyperparameter Tuning

Extensive fine-tuning experiments were conducted on the test sets to further enhance the performance of ECNN-ASCD. This research focuses on fine-tuning four hyperparameters: the number of ECNN-ASCD layers, a pretrained model for encoding input, a learning rate for model optimization, and the number of epochs. Their F₁ score results were recorded in

Table 6. Hyperparameter tuning (highest scores and corresponding hyperparameter values in bold).

Layer	2	AraBERT	0.001	20	0.9868	0.9004	0.8332
	3	AraBERT	0.001	20	0.9911	0.9199	0.8536
	4	AraBERT	0.001	20	0.9918	0.9214	0.8684
	5	AraBERT	0.001	20	0.9915	0.9236	0.8663
Encoder	4	RoBERTa-Davlan	0.001	20	0.9679	0.8693	0.7795
	4	RoBERTa-jhu	0.001	20	0.9883	0.8782	0.7726
	4	mBERT	0.001	20	0.9516	0.8354	0.4935
	4	CamelBERT	0.001	20	0.9903	0.9179	0.8578
	4	AraBERT	0.001	20	0.9918	0.9214	0.8684
LR	4	AraBERT	0.00002	20	0.98260	0.90487	0.84113
	4	AraBERT	0.001	20	0.9918	0.9214	0.8684
Epoch	4	AraBERT	0.001	20	0.9918	0.9214	0.8684
	4	AraBERT	0.001	50	0.9945	0.9381	0.9120

. Candidate values for each hyperparameter are derived from previous SCD works. The values with the best performance were adopted and are given in bold. When considering the number of ECNN-ASCD layers, it is evident that increasing the layers from two to five leads to a gradual improvement in performance across levels. The deep ECNN-ASCD layers increase the N-hop neighborhood and help capture the long-range relationship between nodes. The maximum number of hops is related to the maximum number of nodes in a subgraph, where nodes represent paragraphs within a document. According to Table 4, the average number of paragraphs is around 14 per document. However, increasing the number of layers to 14 will increase the architecture’s complexity and learnable parameters without guaranteeing a better result. For example, increasing from four to five layers enhances the performance slightly for one level, but it is not valuable compared to the performance at four layers. Thus, this study stopped investigating at five layers and adopted four layers for ECNN-ASCD.

In terms of encoders, the candidates were selected because their English versions were previously used for SCD. BERT had the top usage from 2020 to 2022 [62,63,75,76,77,88,89] and RoBERTa had the top usage in 2023 and 2024 [90,91,92,93,94,95,96,97]. The candidate Arabic versions of BERT and RoBERTa are considered the most downloaded on the Huggingface platform. In this study, paragraphs were encoded using one of five candidate pretrained models. First, RoBERTa-Davlan (https://huggingface.co/Davlan/xlm-roberta-base-finetuned-arabic, accessed on 30 April 2025) is a fine-tuned version of xlm-roberta-base. Second, RoBERTa-jhu (https://huggingface.co/jhu-clsp/roberta-large-eng-ara-128k, accessed on 30 April 2025) is an English–Arabic bilingual encoder with the same size as XLM-R large. Third, mBERT (https://huggingface.co/google-bert/bert-base-multilingual-cased, accessed on 30 April 2025) is a multilingual base model trained on Wikipedia pages of 104 languages, including Arabic, that have the largest content volume on the platform. Fourth, CamelBERT (https://huggingface.co/CAMeL-Lab/bert-base-arabic-camelbert-msa, accessed on 30 April 2025) is based on BERT for Modern Standard Arabic. Fifth, AraBERT is based on BERT architecture and uses the same BERT-Base configuration. In this work, all the models were developed under the same setting. All the trainable parameters of the pretrained models were frozen. Thus, no fine-tuning was performed on their parameters for extracting embeddings. This freezing allowed us to assess the models’ capabilities rigorously within the constraints of our experimental setup. The maximum available length for the pretrained models is 256 tokens, which may be less than the length of a single paragraph. Therefore, any paragraph exceeding this length will be truncated using the default truncation strategy, called “longest-first”. It truncates a token at a time from the longest sequence to reach 256 tokens. A special classification token [CLS] was used to represent paragraph-level classification instead of using the whole input tokens [61]. Table 6 shows the results of the fine-tuning experiments. Both the CamelBERT-based and AraBERT-based models yielded high results, where they were trained especially on Arabic texts based on the BERT architecture. In particular, the superior performance of AraBERT can be attributed to its ability to capture the author’s style. Thus, style patterns extracted by AraBERT are more effective in representing and learning. Adjusting the learning rate (LR) also plays a crucial role in optimizing model performance. Previous SCD works utilized a large range of LR values, such as 0.001 [55] and 0.00002 [81,95,98,99,100]. Several experiments were conducted using the ADAM optimizer [101] with different LR values. Table 6 reports two values. Small LR values can lead to slower convergence with more stability due to making more minor updates at each iteration. Large LR values may help achieve fast convergence but risk overshooting the optimal value. According to the results, the LR of 0.001 yielded better results and strikes a balance between rapid convergence and stable training. Regarding the epoch, training ML-based models aims to learn them till reaching convergence. The model’s parameters in this convergence are stabilized, and further training does not significantly enhance performance. In this study, the number of training epochs was extended along with applying the best values of the hyperparameters (above). The plots in Figure 4 showcase the training and test set scores across epochs from 1 to 50. The performance evolves over the epochs, where the curves exhibit a near-linear trajectory before reaching 50 epochs. This linearity indicates that 50 epochs provided sufficient training for ECNN-ASCD to converge across the different difficulty levels. Moreover, the learning curves in Figure 4 exhibit a continuous increase over epochs without notable fluctuations. This stable behavior indicates that ECNN-ASCD is learning without encountering significant underfitting or overfitting issues. The absence of increased gaps between the training and test curves demonstrates the robustness of ECNN-ASCD. Thus, it validates ECNN-ASCD’s ability to generalize to unseen data without relying on memorization.

5.2.2. Ablation Experiments

Several ablation experiments were conducted to prove the effectiveness of the main components in ECNN-ASCD. The experiments involved cumulatively adding components up to obtaining the proposed solution. The $F_1$ results of these experiments are summarized in

Table 7. Results of the ablation experiments.

Components	Easy (${\mathit{F}}_1)$	Medium (${\mathit{F}}_1)$	Hard (${\mathit{F}}_1)$	Decision
Basic GCN	0.7968	0.6958	0.3640	-
Basic EdgeConv	${0.9714}_{\begin{array}{c}\hfill +0.1745\end{array}\left(\begin{array}{c}\hfill S\Leftarrow \end{array}\right)}$	${0.8356}_{\begin{array}{c}\hfill +0.1398\end{array}\left(\begin{array}{c}\hfill S\Leftarrow \end{array}\right)}$	${0.3640}_{\begin{array}{c}\hfill +0.0000\end{array}\left(\begin{array}{c}\hfill NS\end{array}\right)}$	Added
Warmup	${0.9835}_{\begin{array}{c}\hfill +0.0121\end{array}\left(\begin{array}{c}\hfill S\Leftarrow \end{array}\right)}$	${0.9081}_{\begin{array}{c}\hfill +0.0724\end{array}\left(\begin{array}{c}\hfill S\Leftarrow \end{array}\right)}$	${0.8180}_{\begin{array}{c}\hfill +0.4540\end{array}\left(\begin{array}{c}\hfill S\Leftarrow \end{array}\right)}$	Added
Prev-X	${0.9851}_{\begin{array}{c}\hfill +0.0016\end{array}\left(\begin{array}{c}\hfill S\Leftarrow \end{array}\right)}$	${0.9168}_{\begin{array}{c}\hfill +0.0087\end{array}\left(\begin{array}{c}\hfill S\Leftarrow \end{array}\right)}$	${0.8426}_{\begin{array}{c}\hfill +0.0246\end{array}\left(\begin{array}{c}\hfill S\Leftarrow \end{array}\right)}$	Added
X0	${0.9918}_{\begin{array}{c}\hfill +0.0068\end{array}\left(\begin{array}{c}\hfill S\Leftarrow \end{array}\right)}$	${0.9214}_{\begin{array}{c}\hfill +0.0046\end{array}\left(\begin{array}{c}\hfill S\Leftarrow \end{array}\right)}$	${0.8684}_{\begin{array}{c}\hfill +0.0259\end{array}\left(\begin{array}{c}\hfill S\Leftarrow \end{array}\right)}$	Added
Attention	${0.9904}_{\begin{array}{c}\hfill -0.0015\end{array}\left(\begin{array}{c}\hfill NS\end{array}\right)}$	${0.9247}_{\begin{array}{c}\hfill +0.0034\end{array}\left(\begin{array}{c}\hfill S\Leftarrow \end{array}\right)}$	${0.8453}_{\begin{array}{c}\hfill -0.0231\end{array}\left(\begin{array}{c}\hfill S\Uparrow \end{array}\right)}$	Removed
X0-Convergent (ECNN-ASCD)	${0.9945}_{\begin{array}{c}\hfill +0.0026\end{array}\left(\begin{array}{c}\hfill S\Leftarrow \end{array}\right)}$	${0.9381}_{\begin{array}{c}\hfill +0.0167\end{array}\left(\begin{array}{c}\hfill S\Leftarrow \end{array}\right)}$	${0.9120}_{\begin{array}{c}\hfill +0.0436\end{array}\left(\begin{array}{c}\hfill S\Leftarrow \end{array}\right)}$	Added

. Each row represents a model that contains a component mentioned in the same row and all the added prior ones. The table showcases the $F_1$ scores for three levels of instances with paired t-test results. The subscript values “$\pm 0.X$” represent the difference between the current model score and the one directly above it. The symbols “S” and “NS” denote that there is a statistically significant difference and insignificance, respectively, after adding the current component. The symbol “⇐” indicates that the model containing the current component surpasses its predecessor. Conversely, the symbol “⇑” signifies the prior model’s dominance before introducing the current component. The last column shows the final decision, either adding or removing the current component according to the provided influence. The six main components were studied, which are GNN modules, a warmup mechanism, previous edge representations, initial node representations, an attention mechanism, and the convergent case. The components are discussed in detail below.

First, the base component is an appropriate GNN module, either GCN or EdgeConv. These models represent the baseline models without any additional components. Specifically, each model uses four GNN layers, either GCN or EdgeConv, where the layer count was determined during the tuning phase. The nodes in path graphs represent paragraphs. Each edge was labeled to indicate whether there is a style change between end nodes. Edge representations were classified by summing the representations of two end nodes extracted from the fourth GNN layer. As can be seen, basic EdgeConv statistically outperforms basic GCN significantly on two difficulty levels. It shows that EdgeConv enhanced the learning of edge representations for SCD better than the GCN-based model. Second, the warmup mechanism was added to optimize the models. This mechanism helps models to train with a very low LR and then it will be linearly increased until reaching the global minimum of the loss function. Kucukkaya et al. [80] noted that their SCD models have minimum convergence levels. Introducing the warmup with the ratio of 0.1 enhanced their models significantly. In this study, the same ratio is used. As a result, including the warmup mechanism significantly improves performance across all difficulty levels. Third, edge representations obtained from the previous model are static representations. They do not directly benefit from using deep layers. Thus, adding edge representations from a prior layer into a current layer enables continual learning and adjustment across layers. The incorporation also prevents edge representations from relying only on node representations from the last layers. Table 7 showcases the significant improvement after adopting dynamic edge representations. Gong and Cheng [102] and Zhou et al. [103] adjusted edge representations across layers within their GNN-based models. The best performance was achieved when they used their proposed edge representation approach. Fourth, initial node information is aggregated while measuring edge representations. As shown in Table 7, the fusion of both initial node and edge representations can mitigate the over-smoothing issue and contribute to further performance gains. Zhou et al. [103] developed a deep GNN architecture with 64 layers, and they obtained better results when aggregating the initial node representations. Fifth, incorporating the attention mechanism achieved promising results in previous SCD works [60,64]. In this study, the attention mechanism was incorporated as straightforward learnable weights to identify the relative importance of nodes. The weights are learned using an FC layer. However, this incorporation did not bring stable behavior. The paired t-test results revealed that the fluctuating attention scores led to inconclusive additive results. Moreover, incorporating attention increases the learnable parameters and the model complexity without clear benefits. This case prompted us to exclude the attention component from the final model. Further research is recommended to investigate attention mechanisms along with GNN-based models for SCD. Sixth, the convergent case means training the best accumulated components until the convergence state is reached. This state yielded a substantial performance improvement. Developing a model with an acceptable complexity level enables continual learning for extended epochs within an acceptable time. As shown in Figure 4, the F₁ scores increase across epochs till depicting flattened curves. Therefore, the approved version of ECNN-ASCD was obtained.

5.2.3. Performance Comparison

A performance comparison of ECNN-ASCD against the other developed models is presented in

Table 8. Performance comparison on AraSCD (highest scores highlighted in bold).

Solution	Easy			Medium			Hard
	${\mathbf{F}}_{\mathbf{1}}\mathbf{Score}$	Precision	Recall	${\mathbf{F}}_{\mathbf{1}}\mathbf{Score}$	Precision	Recall	${\mathbf{F}}_{\mathbf{1}}\mathbf{Score}$	Precision	Recall
Baseline-Pr0	0.3632	0.285	0.500	0.3678	0.291	0.500	0.364	0.286	0.500
Baseline-Pr1	0.3005	0.215	0.500	0.2948	0.209	0.500	0.2996	0.214	0.500
BERT-MLP	0.9653	0.9673	0.9635	0.8508	0.8758	0.8416	0.6761	0.7072	0.6752
GCNN-ASCD	0.9465	0.9517	0.9429	0.8352	0.8469	0.8294	0.6914	0.6923	0.6907
ECNN-ASCD	0.9945	0.9949	0.9941	0.9381	0.9402	0.9363	0.9120	0.9147	0.9099

. The results demonstrate that ECNN-ASCD achieves the top results across all three instance levels. The paired t-test was conducted on each pair of the five models on all types of instance as shown in

Table 9. Paired t-test results on easy instances (the grey cells are redundant comparisons).

	ECNN-ASCD	GCNN-ASCD	BERT_MLP	Base-0	Base-1
ECNN-ASCD
GCNN-ASCD	⇑
BERT_MLP	⇑	⇐
Base-0	⇑	⇑	⇑
Base-1	⇑	⇑	⇑	⇑

,

Table 10. Paired t-test results on medium instances (the grey cells are redundant comparisons).

	ECNN-ASCD	GCNN-ASCD	BERT_MLP	Base-0	Base-1
ECNN-ASCD
GCNN-ASCD	⇑
BERT_MLP	⇑	⇐
Base-0	⇑	⇑	⇑
Base-1	⇑	⇑	⇑	⇑

and

Table 11. Paired t-test results on hard instances (the grey cells are redundant comparisons).

	ECNN-ASCD	GCNN-ASCD	BERT_MLP	Base-0	Base-1
ECNN-ASCD
GCNN-ASCD	⇑
BERT_MLP	⇑	⇑
Base-0	⇑	⇑	⇑
Base-1	⇑	⇑	⇑	⇑

, where “⇐” indicates that the model in the row is significantly better compared to the model in the column, “⇑” signifies a significant superiority of the model in the column, and “˷” indicates no significant difference in the results. Since the results of the paired t-test are symmetric, there is no need to calculate both directions of the comparison. Thus, the grey cells in Table 9 indicate redundant comparisons. The tables show that ECNN-ASCD performed statistically better than the others on all instances. These results suggest that GNNs, particularly EdgeConv, possess substantial potential for the SCD task.

Regarding the baseline models, the results clearly indicate that the proposed solution has significantly surpassed the performance of the baseline models. It can be noticed that these two baseline models gave almost similar results because of the equilibrium in the labeling classes within AraSCD, as shown in Table 4. In addition, even when adopting the same encoder in ECNN-ASCD and BERT-MLP, deep learning in ECNN-ASCD helps edge representations to learn and update through layers. Furthermore, by comparing the GNN modules, ECNN-ASCD performs better than GCNN-ASCD, which is based on the GCN module. The EdgeConv module adopts multi-dimensional edge representations while passing its messages. GCN differs from EdgeConv by excluding edge representations across layers. Therefore, adopting learnable edge representations significantly contributes to the performance improvement in GNNs for SCD, distinguishing from the prevalent static edge representations in GCNs. Additionally, the nuances of style may vary according to different factors. Although designing AraSCD and PAN datasets aims to detect style changes, these datasets have not explicitly been annotated for integrating physiological or psychological variables. These variables may influence styles, such as the author’s mood and environmental factors [104]. The writing style of the same author can also evolve over time [105]. Hence, identifying the stages of writing texts of the same author can also be considered another research direction [105,106,107]. In this paper, the research scope does not delve into studying the impact of these factors. Further studying is recommended to incorporate them and explore how they intricately shape writing style variations. Although the F₁ score is the common evaluation metric in recent PAN editions [4,5,6,7,11], it is not well correlated to human perception and may not differentiate between writing style characteristics. Consequently, adopting other metrics in addition to the F₁ score helps to analyze different perspectives of performance. The effectiveness of ECNN-ASCD can be evaluated from a human perspective. The human assessments can enhance the credibility and reliability of model predictions. It is one of the common metrics for evaluating NLP models, such as assessing chatbots [108]. In this research, time and resource constraints have posed significant challenges in conducting human evaluations, while they can provide valuable insights into style consistency. For a more comprehensive evaluation framework, future research could explore these aspects in greater detail. Moreover, ECNN-ASCD is one of the deep learning models that operates as a black box. The decision-making process of such models is challenging to interpret. Exploring techniques for interpretability can enable the understanding of predictions and ensure their fairness [109]. Applying these techniques may also facilitate model debugging and error analysis. While this paper has focused on developing ECNN-ASCD, the model’s interpretability is not the primary focus of the current study. Further delving into interpretability is necessary to enhance the transparency and trustworthiness of ECNN-ASCD.

5.3. Proposed Solution for English: ECNN-ESCD

Since no SOTA solutions to Arabic SCD exist, we trained the same method on English datasets so that we can compare the model’s performance with English SOTA solutions. The Edge Convolutional Neural Network for the English SCD task (ECNN-ESCD) was developed following the same ECNN-ASCD architecture. Despite not tuning to the characteristics of English writing styles, this subsection validates that GNNs, particularly EdgeConv, possess substantial potential for the SCD task on English texts. Statistics of the selected PAN datasets are presented in

Table 12. Statistics of PAN datasets.

Level	# Doc.	Avg. Doc. Leng.	Avg. Para. Leng.	Avg. Style Change
PAN 2021 (Task 2)	16,000	6.8836 para.	44.2091 words	3.1556 changes (53.63%)
PAN 2022 (Task 3)	10,000	15.9652 para.	19.9412 words	8.1380 changes (54.38%)

. PAN 2021 and PAN 2022 competitions have provided multiple tasks within the SCD track. This study includes those who tackle detecting style changes, namely, PAN 2021-Task 2 and PAN 2022-Task 3.

Table 13. SOTA results on PAN 2021 and PAN 2022 datasets.

PAN 2021-Task 2		PAN 2022-Task 3
Solution	${\mathbf{F}}_{\mathbf{1}}$	Solution	${\mathbf{F}}_{\mathbf{1}}$
Zamir et al. [97]	0.7750	Lin et al. [77]	0.7156
Zhang et al. [76]	0.7510	Jiang et al. [79]	0.6720
ECNN-ESCD	0.7373	Zhang et al. [75]	0.6581
Str [78]	0.7070	Zi and Zhou [63]	0.6483
Huertas-Tato et al. [110]	0.7043	Lao et al. [62]	0.6314
Deibel and Löfflad [55]	0.6690	Huertas-Tato et al. [110]	0.6312
Singh et al. [43]	0.6570	ECNN-ESCD	0.6215
Nath [52]	0.6470	Alvi et al. [40]	0.5636
-	-	Rodríguez-Losada and Castro-Castro [67]	0.5565
-	-	Alshamasi and Menai [10]	0.4995
Baseline (random)	0.470	Baseline (random)	0.4809

presents the comparison results of the ECNN-ESCD and SOTA solutions on these PAN datasets. The solutions are ordered from the highest to the lowest $F_1$ score, where the $F_1$ score is used in PAN 2021 and PAN 2022 [5,6]. SOTA solutions include participants in the two PAN competitions [10,40,43,52,55,62,63,67,75,76,77,78,79] and others who evaluated their models on the same datasets after closing these competitions [97,110]. The baseline models were developed by assigning authors randomly to paragraphs in a uniform way within a document.

As shown in the table, ECNN-ESCD exceeds the baseline models in the two datasets and can become a product for SCD on English texts. ECNN-ESCD ranked third out of eight solutions in the PAN 2021 dataset. Even though ECNN-ESCD works on boundary representations and struggles with its limitations, ECNN-ESCD remains highly competitive, and its results are comparable. When comparing the two datasets, the average length of paragraphs in the PAN 2021 dataset is longer than that of the PAN 2022 dataset. The difference in length is because the PAN 2022 dataset was designed to tackle SCD at the sentence level, which contains one sentence per paragraph. Longer paragraphs in the PAN 2021 dataset can help ECNN-ESCD to provide rich semantic data and enhance its detection.

6. Conclusions and Future Work

This work introduced the ECNN-ASCD solution to detect writing style changes in multi-authored Arabic documents. ECNN-ASCD is based on the EdgeConv module, which integrates edge representations during the message-passing scheme. Edges in ECNN-ASCD indicate text boundaries, and their representations are adjusted across layers while preserving text representations surrounding these boundaries. The performance of ECNN-ASCD was evaluated on AraSCD, the first Arabic dataset for the SCD task Appendix A. Through intensive experiments, ECNN-ASCD demonstrated significantly superior performance over comparative models and achieved the best $F_1$ score of 0.9945%, 0.9381%, and 0.9120% on easy, medium, and hard instances, respectively. These results show the enhancement of boundary representations by aggregating initial node and learnable edge representations extracted from previous layers. The findings of the ablation experiments statistically validate the effectiveness of ECNN-ASCD components in improving the performance of detecting style changes. As the first publicly available solution for the Arabic SCD, ECNN-ASCD would bridge the gap in the Arabic SCD task and pave the way for more active research. Since the message-passing scheme is crucial in the GNN modules, adjusting it in EdgeConv for the SCD could detect more diverse writing styles. Designing a richer graph, such as incorporating dependency trees and knowledge graphs, could involve more representative edge features. Further enhancements could also be conducted by investigating attention mechanisms. A deep study of these mechanisms can improve detection by focusing on the relevant parts of the written texts. Future investigations are recommended to design specialized SCD datasets that incorporate both physiological and psychological aspects, such as annotations of sentiment analysis tasks, to gain deeper insights into studying these aspects. Evaluating the models using human assessment can provide a comprehensive understanding of their performance across multiple perspectives, facilitating further improvements. Exploring model interpretability presents a promising direction in the future, which could enhance the applicability of ECNN-ASCD across various domains.