A Comparative Evaluation of Transformers and Deep Learning Models for Arabic Meter Classification

1. Introduction

Considered as a basic component of human intelligence, language is very important for our cognitive capacity. In terms of vocabulary, poetry stands out as a polished and sophisticated kind of artistic expression. Poetry transcends national boundaries, countries, and cultural variety to be always popular and significantly influences the progress of human society [1]. The first form of literary expression within the Arabic language is poetry. Arab self-identity, collective past, and future aspirations have always found great expression in Arabic poetry. Common classifications for Arabic poetry are classical and contemporary ones [2]. Most of their research on Arabic prosody—also known as Arud—has been on morphology and phonetics. It has been continuing for some years. Examining meters in poetry helps us ascertain whether a certain piece of work features broken or sound meters [3].

Modern and traditional Arabic respectively utilize long and short vowels. Diacritics mark the short vowels in written language; the long vowels are shown in their whole form [4]. In the eighth century, renowned philologists Al-Farahidi researched ancient Arabic poetry utilizing meters [5]. The metric structure of a word consists of short and lengthy syllables. The classical Arabic poetry involves sixteen meters. Arabic prosody makes use of several often-used terms like these:

• Tafilah: Each distinct foot.
• Bayt: A poem with single line including a pair of half verses.
• Sadr: The initial segment of the half-verse.
• Ajuz: The subsequent segment of the half-verse.
• Arud: The last segment of Sadr.
• Darb: The last segment of Ajuz.

Because of the variety and complexity of the Arabic language, the categorization of Arabic poetry is a difficult chore requiring sophisticated natural language processing (NLP) methods [6]. The linguistic complexity of Arabic poetry, involving its morphology, semantics, and syntax, remains beyond conventional rule-based and statistical techniques.

Artificial intelligence (AI) has advanced significantly over the past several years toward ever-increasing relevance and applicability. Deep learning (DL) and transformer-based models have let academics make major progress in text categorization, sentiment analysis, and other NLP chores. Including these contemporary designs in Arabic poetry classification offers a good path for better comprehension and accuracy [7,8,9].

Transformer models have profoundly transformed the field of NLP since its introduction in the 2017 paper "Attention is All You Need" [10]. These approaches handle incoming input concurrently utilizing self-attention techniques, therefore allowing the capture of long-term dependency and associated contexts inside text. Many advanced NLP applications, including text classification, now use transformers as a fundamental building piece. Recent studies reveal that transformer models outperform conventional ML methods in the scope of text categorization challenges. Comparative investigation showed that the text classification across multiple domains, improved accuracy in updated Bidirectional Encoder Representations from Transformers (BERT) models [11,12].

In this study, we employed a public dataset for Arabic meter classification, MetRec [13], and evaluated the data with different transformers and DL models. We utilized BERT base Arabic (AraBERT), Arabic Efficiently Learning an Encoder that Classifies Token Replacements Accurately (AraELECTRA), Multi-dialect Arabic BERT (MARBERT), modern Arabic BERT (ARBERT), Computational Approaches to Modeling Arabic BERT (CAMeLBERT), and Arabic-BERT models for meter classification. Apart from transformer-based models, DL architectures such as Bidirectional Long Short-Term Memory (BiLSTM) and Bidirectional Gated Recurrent Units (BiGRU) models were also employed. The BiLSTM and BiGRU networks record long-range relationships in sequential data. These designs enable the categorization model to learn both spatial and contextual information, thus fitting the intricate structure of Arabic poetry.

We also analyzed feature significance and model efficacy utilizing the Local Interpretable Model-agnostic Explanations (LIME) interpretability technique. The findings of the proposed study offer insightful analysis of the appropriateness of several architectures for processing Arabic poetry, hence furthering the evolution of more efficient NLP models for the Arabic language.

The major contributions of the study are as follows:

• The study compares and evaluates the performance of different pretrained transformer models such as Arabic-BERT, AraBERT, MARBERT, AraELECTRA, CAMeLBERT, and ARBERT with BiLSTM, and BiGRU DL models.
• The study evaluates the half-verse poem and tunes the model with different hidden layers for the DL models and batch sizes for the transformer models.
• Different encoding methods were employed in this study such as pretrained tokenizer (WordPiece, and SentencePiece) for transformer models and character-level encoding for DL models.
• Using LIME, the study investigates model behavior and feature significance to clarify the model's decision-making procedures.
• This study opens the path for future developments and helps the expanding area of Arabic NLP by assessing the interpretability and applicability methods for poetry categorization.

The subsequent sections of this work are organized as follows: Section 2 presents an extensive literature overview of transformer models and deep learning methodologies. Section 3 outlines the technique and specifies the model architecture. Section 4 discusses the experimental results, succeeded by a comprehensive discussion in Section 5. It also explores prospective areas for further research. Ultimately, Section 6 concludes the study.

2. Literature Review

Talghalit et al., [14] proposed a strong method based on contextual semantic embeddings and a transformer model for Arabic biomedical searches. Preprocessing Arabic biomedical text, creating vector representations that capture spatial and semantic knowledge, and fine-tuning BERT, AraBERT, Biomedical BERT, the robustly optimized BERT technique (RoBERTa), and Distilled BERT using a designated Arabic biomedical dataset constitute part of the procedures. With an F1-score of 93.35% and an accuracy of 93.31%, the suggested approach essentially groups biomedical research into known categories. Notwithstanding these positive results, the authors draw attention to many study limitations including the complex morphology of the language and the absence of specific datasets for Arabic biomedical text classification. They underline the need for contextual semantic embeddings and more datasets to improve the performance of transformer models in this domain and thus develop NLP applications in Arabic biomedical settings.

Combining AraBERT comprehension with a long short-term memory (LSTM) for sequence modeling, a sentiment analysis model is proposed in a work by Alosaimi [15]. On four Arabic benchmark datasets, the performance of the model is assessed against conventional ML and DL methods employing several vectorizing strategies. In the work by Al-Onazi [16], the meter classification was implemented using the Hawks optimization method with LSTM and convolutional network model on the MetRec dataset. The accuracy reached 98% while the precision and recall were 86.5.

In sentiment analysis, ensemble learning, which combines many models to improve classification accuracy, has become a powerful method. Combining many deep learning architectures has been demonstrated in studies to enhance sentiment classification performance above single models [17,18]. Experimental findings show notable accuracy increases, therefore underlining the possibilities of models based on transformers for Arabic sentiment assessment. Another study by Zhou employed a convolutional network and LSTM model for text classification [19]. The convolutional network model captures local textual features while LSTM captures complete information.

Arabic-language version of Generative Pre-trained Transformer-2 (AraGPT-2) meant to provide new text samples improving Arabic text classification. The three components of the method described in Refai's [20] work were using similarity measures to assess sentence quality, generating improved Arabic text with AraGPT-2, and assessing sentiment classification performance with the AraBERT model. Common in Arabic datasets, they addressed the challenges given by class imbalance in sentiment classification tasks.

The research by Al Deen [21] investigates Arabic Natural Language Inference using transformer models, AraBERT and RoBERTa, and a novel pretraining method combining Named Entity Recognition. Conflicts and entailments may be found by using a specific dataset derived from publicly accessible resources and linguistically informed pretraining providing semantic understanding for models. AraBERT, with 88.1% accuracy, beats the RoBERTa model when boosted with language expertise. In the work by Qarah [22], a linguistic model for Arabic poetry analysis, Arabic poetry processing with BERT, was presented. Pretrained from scratch on an extensive corpus of Arabic poetry, this employs BERT architecture. The model provides 768 hidden layers, 10 encoder layers, and 12 attention heads per layer. The 50,000-word vocabulary catches a broad range of Arabic poetry forms and idioms.

The categorization of Arabic news articles is proposed to be enhanced by a hybrid methodology that integrates deep learning with text representation approaches [9]. After text cleaning, tokenization, lemmatization, and data augmentation—a whole preparation process—a proprietary attention embedding layer logs contextual associations in the text. With data augmentation, the model beats the state-of-the-art Arabic language model AraBERTv2 in classification accuracy to reach 97.69% [23]. In a work by Alshammari [24], the authors offer a novel AI text classifier primarily geared to handle the particular challenges in Arabic identification of AI-generated texts. Using two independent datasets, the method consists of optimizing two transformer models: Cross-lingual Language Model and AraELECTRA [25]. With an 81% accuracy, the proposed models beat current AI detectors. The CAMeLBERT model was trained on an Arabic poetry dataset and achieved a performance of 80.9% accuracy [26].

Although BERT has been somewhat popular in NLP, the study [27,28,29] underlines that its usage of Arabic text classification is still rather rare. Particularly due to their training in more comprehensive Arabic corpora, the results demonstrate that models specially suited for Arabic, notably CAMeLBERT, AraBERT, and MARBERT, are particularly successful. This extensive research offers future possibilities to solve current constraints and improve the effectiveness of NLP usage scenarios in the Arabic language in addition to an intriguing analysis of the present situation of Arabic text categorization using BERT.

3. Materials and Methods

The proposed study consists of phases such as data preprocessing, splitting to train and test, implementing the model, evaluating the model on different parameters, testing the model, and LIME interpretability for the model. The workflow is described in Figure 1.

3.1. Dataset

Arabic poetry dataset, MetRec, with 55,440 verses and 14 meters [30] is the one used in this work. The symbol ‘#’ marks the separation between the left and right verses. The left and right verses are vertically concatenated to produce half-verse data. Therefore, the total number of half-verses is 110,880, as depicted in Figure 2. Figure 3 illustrates the word cloud from this dataset.

The cleaned data after removing unwanted characters, alphabets, and punctuations are then given to train-validate-test split. The data is split into 60% for training, 20% for validation, and the remaining 20% for testing the model. The total verse count for the train set is 66,528, and validation and test have 22,176 verses each. Each meter count for the splits is shown in Figure 4.

3.2. Data Preprocessing

Maximizing the efficiency of the proposed models depends on proper preprocessing. We use two alternative preprocessing methods considering the language's complexity and the varied architectures: character-level encoding for DL-based models and tokenization for transformer-based models.

3.2.1. Tokenization

In NLP, tokenizing, and dissecting text into smaller bits, is a basic first step. Based on the tokenizing technique employed, these tokens could be characters, subwords, or words. WordPiece and SentencePiece have become somewhat well-known among the several tokenizing methods because of their flexibility in many languages and applications [31].

Created for the BERT concept, WordPiece is a subword tokenizing tool [32,33]. It works by building a vocabulary with every character found in the text. And then determines which most often occurring pair of neighboring tokens should be merged into a new token. It is then continued merging until either no more pairs can be merged, or a specified vocabulary size is achieved, hence optimizing the probability of the training data.

Google has developed another subword tokenizing tool called SentencePiece. It employs a data-driven technique to learn the vocabulary and treats the input text as a series of characters whereas WordPiece depends on frequency-based merging. Subword tokens can be produced by using Byte Pair Encoding or Unigram language models. The result is a collection of subword tokens fit for several NLP applications [31]. Table 1 shows the tokenization methods for the pretrained transformer models employed in the study.

For the proposed study, we employed pretrained tokenizers while using the models. The code snippet for the tokenizer is shown in Figure 5. The maximum length of the model is kept at 60, and the padding is set to True.

3.2.2. Character-Encoding

Character encoding is the process by which characters are turned into a format computer can readily access and control. In this work, we also address the complexity of the Arabic language which is rich in morphological structures employing character encoding. By removing special characters from the dataset and omitting spaces, the proposed study creates a vocabulary using character-level encoding [30]. Each character was then assigned an index designed to produce a mapping dictionary. This mapping translated every text occurrence into a sequence of numerical indices, therefore preserving distinct characters. From the longest text in the dataset, we found the maximum sequence length by ensuring consistent input size using sequence padding. Especially helpful for handling spelling variations, and noisy text, this encoding method preserves character-level patterns. The code snippet for character encoding is depicted in Figure 6.

3.3. Model Architectures

Different models were employed in this study for classifying the Arabic meters. The models such as AraBERT, ARBERT, MARBERT, CAMeLBERT, Arabic-BERT, AraELECTRA, BiGRU, and BiLSTM were used.

3.3.1. Transformer Models

Transformers are suitable for high-stakes situations where performance is crucial as they can analyze large volumes and complex models. The workflow of the transformer model in the study is depicted in Figure 7.

AraBERT is a transformer model pretrained primarily for the Arabic language [34]. The creation sought to address the difficulties the Arabic language provided, notably its complicated morphology and several dialects. AraBERT shows outstanding performance on several Arabic NLP challenges, including sentiment analysis [35]. It is constructed on BERT design. AraBERT is projected to greatly improve the performance of Arabic NLP applications as research develops, hence improving precision and efficacy in many different fields.

AraELECTRA is a pretrained transformer model designed exclusively for comprehending the Arabic language [25]. The model extends to the ELECTRA architecture, which has shown significant efficacy across several NLP applications. Rather than teaching a model to retrieve masked tokens, ELECTRA uses a discriminator model to distinguish between real input tokens and damaged tokens, produced by a generator network. This approach makes improved learning efficiency possible with the same data amount.

Built on many Arabic dialects, classical Arabic, and Modern Standard Arabic (MSA), CAMeLBERT is another robust transformer model for Arabic text processing [26]. Unlike AraBERT, CameLBERT is taught on a combination of MSA and dialectal Arabic, which could help to capture stylistic variances in poetry. Built on BERT-based architecture, CAMeLBERT is improved in comprehension of poetry forms and word morphology by extensive Arabic data tuning.

MARBERT and ARBERT are two sophisticated transformer models designed for Arabic NLP-related activities [36]. Recognized for their success in many NLP applications, this model improves BERT architecture and adapts it to fit the characteristics of the Arabic language. Utilizing a bidirectional attention mechanism, both models may assess the context of a word by examining both its left and right surroundings. Using a large corpus of Arabic literature, the MARBERT model was focused on several dialects and MSA. While the ARBERT model was focused on MSA.

Designed to expand the powers of the original BERT concept to the Arabic language, Arabic-BERT is specially designed for Arabic, concentrating on MSA and its language characteristics unlike other models [37]. All the pretrained transformer models use 12 hidden layers, and 12 attention layers in the architecture.

3.3.2. Deep Learning Models

DL architectures like BiLSTM and BiGRU are extensively employed for the processing of sequential data, including NLP, time-series forecasting, and speech recognition. Both methods tackle the vanishing gradient issue inherent in conventional recurrent neural networks while effectively capturing long-term interdependence.

BiLSTM improves contextual learning by extending LSTM by considering the input sequences in forward as well as reverse directions [38,39]. The LSTM model includes three gates such as input, output, and forget gate.

$$f_t=\sigma (v_f{I}_t+w_f{L}_{t-1}+a_f)$$

(1)

where f_t is the forget gate with time stamp t, sigmoid activation function (σ), v_f and w_f denote the f_t’s weight matrices, I_t signifies the data input, a_f is the error vector, L_t-1 denotes the previous time step's concealed state result.

$$i_t=\sigma (v_i{I}_t+w_i{L}_{t-1}+a_i)$$

(2)

where the input gate is i_t; v_i and w_i denote the i_t’s weight matrices, and a_i is the error vector.

$$\widetilde{{CM}_t}=tanh(v{I}_t+w_c{L}_{t-1}+a_c)$$

(3)

where $\widetilde{{CM}_t}$= candidate memory cell, the error vector is a_c, and v_c and w_c are the weight matrix.

$${CS}_t=f_t·{CS}_{t-1}+i_t·\widetilde{{CM}_t}$$

(4)

where CS_t is the cell state, CS_t-1 represents the memory state vector from the previous timestamp, f_t is calculated from equation (1), i_t from equation (2), and $\widetilde{{CM}_t}$ from equation (3).

$$O_t=\sigma (v_o{I}_t+w_o{L}_{t-1}+a_o)$$

(5)

where the output gate is o_t; v_o and w_o denote the o_t’s weight matrices, and a_o is the error vector.

$$L_t=O_t·\mathrm{t}\mathrm{a}\mathrm{n}\mathrm{h}\left({CS}_t\right)$$

(6)

where the hidden state is L_t, o_t is calculated from equation (5), and CS_t from equation (4). The BiLSTM analyzes the input sequence in both directions.

$$L_t=\overrightarrow{L_t}ʘ\overleftarrow{L_t}$$

(7)

where the $\overrightarrow{L_t}$ is the output of LSTM in the forward state, $\overleftarrow{L_t}$ is LSTM in a backward state. The sign 'ʘ' may denote several operations, including multiplication, average, summation, and concatenation functions.

Less parameters and computing efficiency make the GRU a simpler substitute for LSTM. Like BiLSTM, BiGRU handles sequences both ways [30]. It has two gates, namely the reset and update gate.

$${RS}_t=\sigma (v_r{I}_t+w_r{G}_{t-1}+a_r)$$

(8)

where RS_t is the reset gate, v_r, and w_r denote the RS_t’s weight matrices, G_t-1 denotes the previous time step's concealed state result, and a_r is the bias vector.

$$P_t=\sigma (v_p{I}_t+w_p{G}_{t-1}+a_p)$$

(9)

where P_t is the update gate, v_p and w_p denote the P_t’s weight matrices, and a_p is the error vector.

$$\widetilde{G_t}=tanh(v_h{I}_t+w_h({RS}_t·G_{t-1})+a_h)$$

(10)

where $\widetilde{G_t}$ is the new hidden state, a_h is the error vector, v_h and w_h denote the weight matrices, and RS_t is evaluated from equation (8).

$$G_t=\left(1-P_t\right)·G_{t-1}+\widetilde{G_t}·P_t$$

(11)

where G_t is the final updated hidden state, P_t is calculated from equation (9), and $\widetilde{G_t}$ is from equation (10).

$$G_t=\overrightarrow{G_t}ʘ\overleftarrow{G_t}$$

(12)

where the $\overrightarrow{G_t}$ is the output of GRU in the forward state, $\overleftarrow{G_t}$ is GRU in a backward state. The sign 'ʘ' may denote several operations, including multiplication, average, summation, and concatenation functions.

The BiLSTM and BiGRU model architecture is illustrated in Figure 8. The approach initially transforms a sequence into an integer index using a character encoder. A particular vocabulary character is associated with this index. The input layer has the shape of the train set. The embedding layer transforms input tokens into dense vectors of predetermined size. The embedding dimension is set to 128. The BiGRU or BiLSTM layer analyzes the sequence in both forward and backward orientations, capturing dependencies from previous and future instances. If the layer is greater than 1 then the return-sequence variable is turned to True. The bidirectional dimension is set to 256. One regularizing method to stop overfitting is to set the dropout layer. It is set as 0.2 in the study. The fully connected layer, dense layer, is mapped to the total class length, of 14 in this study. The Softmax is kept as the activation function. The ultimate prediction is the category with the highest likelihood derived from the Softmax output.

3.4. Model Evaluation and Parameter Tuning

The system environment for the study is as follows:

• Windows 10 operating system
• 16 GB RAM
• Inter core i7 processor
• GPUS - Nvidia GeForce GTX 1080 Ti
• Deep learning libraires - TensorFlow 2.7, Transformers 4.48.1
• Other evaluation libraries - Scikit-learn 1.0, PyArabic 0.6.14, lime 0.2.0.1

The models are compiled before fitting to train the data. The Adaptive moment estimation (Adam) is used as the optimizer. It requires smaller memory and is notably effective [40]. The loss function employed is sparse categorical cross entropy as the labels are sparse matrix.

The study's tuning parameters are based on the models. The DL models are tuned using several hidden layers. The transformer model is optimized according to batch size. This study employs EarlyStopping and ReduceLRonPlateau approaches as regularization methods to mitigate overfitting. The model will cease training when achieving the ideal result based on the specified parameters, before the onset of overfitting. The EarlyStopping parameter monitors validation loss; if it remains constant or increases during eight epochs, the model ceases iteration and retains the optimal model. The ReduceLRonPlateau method adjusts the learning rate by a multiplier of 0.1 when the loss value stands unchanged for two epochs. Table 2 shows the parameters used in the study.

3.5. Performance Evaluation

The model is evaluated based on the test data. The confusion matrix and the classification report are analyzed for each model. For multi-class classification, this study assesses criteria like accuracy, F1-score, recall, and precision. Each metric's formulas are given below.

$$Precision={\displaystyle \raisebox{1ex}{$T_{pos}$}\!\left/ \!\raisebox{-1ex}{$T_{pos}+F_{pos}$}\right.}$$

(13)

$$Recall/Sensitivity={\displaystyle \raisebox{1ex}{$T_{pos}$}\!\left/ \!\raisebox{-1ex}{$T_{pos}+F_{neg}$}\right.}$$

(14)

$$Accuracy={\displaystyle \raisebox{1ex}{$T_{pos}+T_{neg}$}\!\left/ \!\raisebox{-1ex}{$T_{pos}+T_{neg}+F_{pos}+F_{neg}$}\right.}$$

(15)

$$F1-score={\displaystyle \raisebox{1ex}{$2\ast T_{pos}$}\!\left/ \!\raisebox{-1ex}{$\left(2\ast T_{pos}\right)+F_{pos}+F_{neg}$}\right.}$$

(16)

The classification of a meter is accurate, as it is assigned to its proper category (Tpos). For instance, if a verse composed in saree meter is predicted to be saree, this is a genuine positive circumstance. A line that deviates from a specified meter is accurately recognized as not conforming to that meter (Tneg). One misclassifies a meter as yet another meter (Fpos). A meter that truly falls within a certain class is misclassified as belonging another class is Fneg. For example, if a verse from kamel meter is classified as madeed, then it is a Fpos for madeed meter and Fneg for kamel meter.

3.6. Explainability with LIME

LIME is a method that employs an interpretable model to locally approximate predictions, thereby clarifying the prediction [41]. It can highlight the words or characters that most significantly influence the categorization choice in the classification model. LIME approximates the model's decision in a relatively small area surrounding a specific instance by influencing the input data and tracking the way the model's prediction changes.

LIME aids in discerning which words significantly influence the model's predictions within the framework of Arabic meter categorization, hence facilitating the analysis of the patterns identified by the transformer models.

4. Results

The dataset used in this study is MetRec data with 55,440 verses. The total number of half-verses is 110,880. There are no studies based on the half-verse and transformer models. The data is split to 60-20-20 for the train-validate-test. The labels are encoded from 0 to 13.

4.1. Deep Learning Models

In the DL models the text data are encoded using the character-encoding method. The BiLSTM and BiGRU models are tuned with layers. The complete performance results are shown in Table 3. The BiGRU model shows the best performance in layer 5 with 90.39% testing accuracy, and 0.90 F1-score, recall, and precision scores. The BiLSTM model shows the best results in 6 layers with 90.53% testing accuracy, 0.90 recall, and 0.91 F1-score and precision score. The EarlyStopping parameter exits the training process when the validation loss keeps increasing or stable for eight epochs. So, the training stops at epochs are mentioned in the table for each layer.

Each class results for the BiLSTM model with 6 layers are depicted in Table 4. The highest F1-score is shown by baseet and Taweel meters with a 0.96 score. While the rajaz meter shows the lowest F1-score with 0.79 score. The confusion matrix for the best model (BiLSTM) with 6 layers is depicted in Figure 9.

4.2. Transformer Models

In the transformer model, the text data are encoded using the tokenizer method. The models are tuned with batch size. The complete performance outcomes are depicted in Table 5. The CAMeLBERT model with batch size 64 shows the best performance with 90.62% testing accuracy, and 0.91 recall, F1-score, and precision scores.

Each class results for the CAMeLBERT model with batch size 64 is depicted in Table 6. The highest F1-score is shown by baseet and Taweel meters with a 0.96 score. While the rajaz meter shows the lowest F1-score with a 0.80 score. The CAMeLBERT model’s confusion matrix is shown in Figure 10.

5. Discussion

In this study, we analyzed different models such as pretrained transformer models and bidirectional DL models. The half-verse data with 14 meters is investigated in this study. Slightly surpassing the BiLSTM model, which got 90.53%, the CAMeLBERT model attained the best accuracy of 90.62%.

The tokenizers were also evaluated on the BiLSTM model. Both SentencePiece (AraBERT) and WordPiece (CAMeLBERT) were analyzed. The model is tested with two layers, as depicted in Table 7. It does not show much performance on the BiLSTM model, and hence we considered the character encoding on DL models.

BiLSTM uses long-term memory's advantages to extend traditional LSTM by handling both directions of processing sequences [42]. LSTMs with memory cells more effectively capture long-range dependencies than GRUs. Al-shathry [43] carried out further research using a balanced dataset on full-verse poems. To create this dataset, 1000 poetry verses of every 14 meters were chosen at random. Their study applied the BiGRU model, producing a score of 0.90 for recall or sensitivity, precision, and F1-score, along with 98.6% accuracy.

Transformer models have greatly enhanced NLP challenges including Arabic meter categorization. These models use deep contextual embeddings to pick out intricate language patterns exclusive to Arabic [15,44]. The CAMeLBERT model was trained on different datasets, and one among them is the poetry dataset. But the model achieved only 80.9% accuracy [26]. The exceptional performance of transformer models arises from their self-attention mechanism, which allows for more efficient modeling of long-range relationships compared to recurrent systems such as BiLSTM or BiGRU. They excel at capturing complex linguistic attributes [28].

Poetry in Arabic frequently adheres to systematic metrical structures, which may be concisely encapsulated within half verse. Examining half verses preserves crucial rhythmic and structural characteristics. The comparison with previous studies based on the dataset is mentioned in Table 8.

The LIME explainability of the model is illustrated in Figure 11 for sample text 1, Figure 12 for sample text 2, and text 3 in Figure 13. It explains how the model helps in prediction by showing the importance of the word. The figure depicts a text sample where LIME has underlined terms in many colors. These colors show the value of every word in the model's categorization choice. The text with highlighted words and the probabilities of top meters can be identified in each figure. LIME clarifies which syllables or phrases most support the categorization of a certain meter.

5.1. Practical Implications

The proposed study's conclusions hold considerable practical significance for the analysis of Arabic poetry, and AI-driven literature purposes. The enhanced accuracy achieved using half-verse data demonstrates that meter classification may be efficiently automated without requiring whole verses, making the approach more applicable in real-world contexts. Moreover, transformer and DL models’ ability to capture metrical patterns creates new opportunities for educational tools whereby academics and students may use AI to rapidly examine and categorize Arabic meters.

This research has significance for NLP implementations in Arabic, especially for challenges necessitating rhythmic comprehension. The present research demonstrates that half-verse data is adequate for precise categorization, hence diminishing processing demands and enhancing the accessibility of AI-driven meter classification for organizations, academics, students, and developers engaged in Arabic language technology.

5.2. Limitation and Future Works

Although the proposed study employs half-verse data to attain an increased level of accuracy in Arabic meter classification, it has certain limits. One of the restrictions is that it depends on a certain dataset, which might not have been able to adequately depict the diversity of Arabic poetry. Future research should investigate the possibilities of broadening the dataset to cover a larger diversity of poetic styles, as well as emotions to evaluate the generalizability of the models. Furthermore, multimodal methodologies that combine textual elements with audio inputs may be explored to improve the study of Arabic poetry.

6. Conclusions

The proposed work examined Arabic meter categorization under many DL and transformer models including AraBERT, AraELECTRA, Arabic-BERT, ARBERT, MARBERT, CAMeLBERT, BiGRU, and BiLSTM models. With 90.62%, CAMeLBERT models show the best accuracy; closely behind BiLSTM at 90.53%. These results show how well the transformers may capture intricate metrical systems in Arabic poetry. The results imply that automatic meter categorization may enable several NLP tasks, involving poetry translation, and text-to-speech synthesis.