Performance and Computational Cost of Full and Parameter-Efficient Fine Tuning for Arabic Sentiment Classification Across Training Set Sizes

Abstract

Pre-trained language models are typically adapted to downstream tasks via full fine tuning. However, this entails substantial computational and memory overhead. Parameter-efficient alternatives such as Low-Rank Adaptation (LoRA), Quantized Low-Rank Adaptation (QLoRA), and frozen backbone mitigate these costs, but empirical evidence on how their performance–cost trade-offs change under low labeled data in Arabic remains limited. This paper compares four adaptation strategies: full fine tuning, frozen backbone, LoRA, and QLoRA for Arabic binary sentiment classification on the Hotel Arabic Reviews Dataset, using CAMeLBERT-Mix as the pre-trained encoder. The methods are evaluated under a unified experimental setting at three labeled-data levels: the full training set, 100 samples per class, and 25 samples per class. The evaluation metrics are reported as means and standard deviations across five random seeds. At the full-data level, full fine tuning, LoRA, and QLoRA achieve macro-F1 scores between 0.9569 and 0.9579 and are comparable within seed variability, while the frozen backbone exhibits performance that is approximately ten points lower. LoRA and QLoRA use approximately 35.0% less peak GPU memory than full fine tuning but require longer training times. Under reduced-data conditions, full fine tuning outperforms all other adaptation strategies with the differences being statically significant.

1. Introduction

The rapid growth of social media platforms has generated vast amounts of user comments and reviews, making sentiment analysis a critical tool for extracting opinions and enabling decision making for individuals [1]. Despite the widespread use of Arabic, research on Arabic sentiment analysis remains relatively limited compared to high-resource languages such as English and must also contend with the additional complexity of variation between Modern Standard Arabic and dialectal Arabic [2].

In parallel, recent advances in pre-trained transformer-based language models have substantially improved performance across a wide range of NLP tasks, such as sentiment analysis [3,4]. One of the most common approaches for adapting pre-trained models is full fine tuning, which updates all model parameters for each downstream task. However, full fine tuning is computationally expensive and typically requires large labeled datasets and substantial computational resources [5,6].

To address the computational cost of full fine tuning, parameter-efficient fine-tuning (PEFT) methods have been developed to adapt pre-trained models while minimizing the number of trainable parameters and computational resources required. Among the most widely used PEFT approaches are Low-Rank Adaptation (LoRA), Quantized Low-Rank Adaptation (QLoRA), and frozen backbone methods. LoRA introduces trainable low-rank matrices into selected model weights, whereas QLoRA combines low-rank adaptation with low-bit quantization of the pre-trained backbone to further reduce memory consumption and enable fine tuning on standard hardware. In contrast, the frozen backbone approach keeps the pre-trained model fixed and trains only a task-specific classification head. These methods offer promising alternatives to full fine tuning, particularly in settings with limited computational resource [6,7,8].

Moreover, selecting an appropriate adaptation strategy requires considering the available computational resources, the amount of labeled data, and the desired classification performance. Thus, adaptation strategies can be grouped into two categories. The first is full fine tuning, which involves inherent computational complexity in terms of training time and hardware requirements. The second includes parameter-efficient adaptation strategies, such as LoRA and frozen backbone, whose performance may be limited by the amount of available labeled data. In addition, empirical studies investigating the performance-cost trend of adaptation strategies in terms of classification performance and computational cost at different data levels for Arabic sentiment analysis are still limited [9]. This is particularly important because Arabic is an inherently low-resource language, and such studies can provide valuable guidance.

This paper addresses this gap by comparing four adaptation strategies, namely full fine tuning, frozen backbone, LoRA, and QLoRA, for the binary sentiment classification of Arabic user-generated reviews. The aims is to provide a clear empirical understanding of how different adaptation strategies behave under combined computational and data constraints in Arabic reduced-data settings. Therefore, this paper aims to answer the following three research questions:

• RQ1. When the full training set is available, how does parameter-efficient fine tuning (frozen backbone, LoRA, and QLoRA) compare with full fine tuning for Arabic binary text classification in terms of classification performance and computational cost?
• RQ2. How does the relative performance of the four adaptation strategies change as the labeled training set is reduced from the full training set to 100 and then 25 labeled samples per class?
• RQ3. Under reduced-data settings, which of the four adaptation strategies provides the most favorable trade-off between classification performance and computational cost?

The comparison is conducted under a unified experimental setting across the three labeled data levels. The main contributions of this paper are as follows:

• We present an empirical comparison of four adaptation strategies for pre-trained language models on Arabic binary sentiment classification using a unified experimental setting.
• We evaluate the extent to which parameter-efficient fine-tuning methods can approach the performance of full model fine tuning when the complete labeled training set is available.
• We analyze the robustness of the four adaptation strategies under reduced-data settings, showing how their performance changes as the amount of labeled Arabic sentiment data decreases.
• We examine the trade-off between classification performance and computational cost for adaptation strategies.

The remainder of this paper is organized as follows: we firstly review the related work, which is followed by the methodology and experimental design. We then present the experimental results, discuss the findings, and conclude the paper.

2. Related Work

2.1. Arabic Sentiment Analysis

With the widespread adoption of social media platforms, sentiment analysis has become increasingly important and has emerged as a fundamental task in NLP [10]. Sentiment analysis aims to understand the opinions and sentiments embedded in textual data. Despite its significant growth, sentiment analysis remains relatively limited in Arabic compared to languages rich in linguistic resources, such as English [10]. Sentiment analysis in Arabic has important applications in diverse fields, including opinion polling, customer feedback analysis, and market research. This paper focuses on the binary classification of sentiments expressed by Arabic users. Arabic is the official language of 22 countries, resulting in considerable variation in both Modern Standard Arabic and dialects in terms of vocabulary, grammatical structure, morphology, and spelling. This makes accurately classifying sentiments challenging [2].

Sentiment analysis methods in Arabic have evolved over the past decade, keeping pace with broader developments in the field. Early methods for classifying sentiments relied on lexical approaches, followed by machine learning methods such as support vector machines and simple Bayesian algorithms, which primarily relied on models specifically designed for particular tasks [10]. Deep learning models, such as recurrent neural networks and convolutional neural networks, have also contributed to improved performance, especially when trained on large datasets [11]. Pre-trained language models have also improved performance in NLP tasks, including sentiments analysis [12,13]. We will explore pre-trained language models in more detail in the next section.

2.2. Pre-Trained Language Models for Arabic

Pre-trained language models have played a significant role in the development of NLP by learning representations that capture complex linguistic patterns in text. These models can be adapted to perform diverse tasks, such as sentiment analysis [3]. In Arabic pre-trained language models, it has been shown that performance is affected by the degree of linguistic similarity between the pre-training data and the task data [14]. Although the development of multilingual models to serve a large number of languages has progressed, they still suffer from some limitations, such as sensitivity to the number of languages and the linguistic relationships between them, which is known as the curse of multilinguality  [13,15]. To address these challenges for a variety of Arabic dialects, encoder-based Arabic pre-trained language models have been developed to meet different needs in representing the Arabic language. The CAMeLBERT model was pre-trained on colloquial Arabic data [13], the ARBERT model was pre-trained on Modern Standard Arabic data, and the MARBERT model was pre-trained on a mixture of Modern Standard Arabic and dialectal Arabic [14].

Previous studies have shown that pre-trained Arabic models have improved performance on several Arabic downstream tasks, including sentiment analysis and text classification [12,13]. However, using these models to perform a specific task typically requires an adaptation step, and full fine tuning is the most common approach, in which all model parameters are updated. While this approach is effective, it requires substantial computational resources, memory, and training data [3,7]. This presents a challenge for low-resource languages such as Arabic, where only a limited number of labeled training samples are avaialable. This challenge becomes more apparent as the size of the pre-trained models increases, since updating all model parameters becomes computationally expensive [6,16].

2.3. Adaptation Strategies for Pre-Trained Language Models

The adaptation strategies plays a significant role in downstream tasks that rely on pre-trained language models. Therefore, they differ in terms of computational cost, efficiency, and generalizability under limited data, making the choice of an adaptation strategy dependent on the task requirements and types of constraints.

Full fine tuning is one of the most common methods for adapting pre-trained language models, but it is computationally expensive because it updates all model parameters. Furthermore, it may lead to overfitting, especially under limited-data settings. To address these challenges, parameter-efficient methods, including additive and selective approaches, have been proposed to enable adaptation while keeping the underlying pre-trained model largely fixed [5,17].

The study by Houlsby et al. [5] proposed adapter-based tuning, where a small number of trainable parameters are added for each task while keeping the underlying pre-trained model fixed. This design is parameter-efficient and has demonstrated performance comparable to full fine tuning on several NLP tasks. Another adaptation strategy, frozen-backbone linear probing, is one of the simplest methods for adapting pre-trained models. It treats the pre-trained model as a fixed feature extractor while training only a linear classifier on top of the learned representations [18].

LoRA is another PEFT method in which the pre-trained model is frozen and low-rank matrices are introduced into selected Transformer layers. These matrices contain only a small number of trainable parameters, reducing memory requirements while achieving performance comparable to full fine tuning [6,19]. Building on LoRA, QLoRA combines low-rank adaptation with 4-bit quantization of the frozen pre-trained model. QLoRA can maintain performance comparable to LoRA while substantially reducing memory requirements [8].

Despite the significant progress in PEFT methods, most comparative studies have focused on English-language models [6,20], while systematic comparisons of adaptation strategies for Arabic language models remain limited.

2.4. PEFT Methods for Low-Resource Languages

PEFT methods for low-resource languages have garnered increasing attention from researchers [9,21]. The study by Su et al. [17] conducted comprehensive empirical experiments on low-resource languages such as Hindi, Sinhala, and Tamil, evaluating eight PEFT methods, including LoRA and Infused Adapter by Inhibiting and Amplifying Inner Activations (IA3), which generally achieved better performance than full fine tuning, thus confirming their effectiveness in low-resource languages. The study by [21] presented a comprehensive benchmark for Arabic Natural Language Processing (NLP) by evaluating 15 diverse tasks, including sentiment classification. The results showed that fine tuning with LoRA achieved consistent improvements, adding up to 8 points in performance metrics (F1 and BLEU) compared with increasing the model size alone, thus demonstrating its effectiveness in adapting language models to the complexities of the Arabic language. Although previous studies have investigated various adaptation strategies, a controlled comparison of full fine tuning, frozen backbone adaptation, LoRA, and QLoRA for Arabic sentiment classification under both full-data and reduced-data settings remains limited. This paper addresses this gap by providing a unified experimental setting to systematically evaluate these adaptation strategies across different levels of data availability in terms of classification performance, computational cost, and generalizability.

3. Methodology

In this section, we present the methodology followed to conduct this empirical study, which supports decision making under different constraints when selecting a suitable adaptation strategy for Arabic sentiment analysis.

3.1. Overview

This paper evaluates adaptation strategies across different training data levels. We investigate four adaptation strategies: full fine tuning, LoRA, QLoRA, and a frozen backbone approach. Each method handles parameter updates differently, offering distinct trade-offs between performance and computational cost. These methods are described in detail in Section 3.2. In addition, we evaluate the performance of the adaptation strategies across three data levels. While training on the full dataset represents the ideal scenario for downstream tasks, it is often unrealistic. Therefore, we additionally simulate two levels of data scarcity to assess how each method performs in low-resource settings.

These two factors result in 12 distinct experimental combinations, as illustrated in Figure 1. Each combination is evaluated under a unified experimental setting involving fixed data preprocessing and data splits, a fixed test set, a fixed model, a fixed training configuration, and a fixed number of random seeds with predefined seed values, as described in Section 4.4, in order to ensure a fair comparison among the adaptation strategies. Furthermore, no hierarchical relationship is assumed among the configurations; all are treated as independent experimental setups and evaluated accordingly.

Figure 1. The experimental combinations resulting from combining the adaptation strategies across different training data levels.

The computational related metrics—namely, peak GPU memory consumption, training time (in seconds), and the number of trainable parameters—are all measured using the same GPU hardware to ensure the credibility and comparability of the reported values. The hardware specifications are provided in Section 4.5.

3.2. Adaptation Strategies

To ensure a fair and comprehensive evaluation, this paper compares four adaptation strategies for Arabic sentiment classification under reduced-data settings: full fine tuning, frozen backbone adaptation with a classifier head, LoRA, and QLoRA.

Full fine tuning is selected as a strong baseline because it represents the conventional approach for adapting pre-trained language models [3]. It updates all model parameters and typically achieves high performance when sufficient labeled data are available. However, in low-data settings, where training data are extremely limited, full fine tuning may lead to overfitting and increased computational cost, making its effectiveness less reliable [22,23].

The frozen backbone approach is included as a lightweight baseline, where all pre-trained encoder parameters remain fixed, and only a task-specific classification head is trained. This setup allows us to evaluate how much knowledge can be transferred from pre-trained representations without updating the backbone, which is particularly relevant in low-resource scenarios [20].

LoRA is selected as a representative PEFT method. It injects low-rank trainable matrices into the model and significantly reduces the number of trainable parameters while maintaining competitive performance [6]. This makes it particularly suitable for low-data settings, where updating a smaller subset of parameters can help reduce the risk of overfitting while preserving the knowledge encoded in the pre-trained model.

QLoRA extends LoRA by combining low-rank adaptation with quantization, enabling the memory-efficient training of large models without substantial performance degradation [8]. It is included to evaluate whether additional efficiency gains can be achieved in terms of computational cost.

3.3. Training Data Levels

To investigate the performance of the adaptation strategies under varying levels of data availability, three training datasets are systematically employed as experimental conditions. The first consists of the full training set, representing the optimal data availability scenario. The remaining two datasets simulate low-resource settings, comprising 25 samples per class and 100 samples per class, respectively.

The experimental design for varying levels of data availability is structured as follows: The training data are balanced across classes to ensure a fair assessment of the sensitivity of the adaptation strategies across the three training-set conditions. Without such balancing, disparities in the number of samples per class could introduce bias and compromise the validity of evaluating the generalization capability of the adaptation strategies.

Furthermore, the larger training set contains all samples included in the smaller one (i.e., the two training-set levels are nested). This design facilitates a fair comparison between the two simulated low-resource conditions while minimizing the influence of confounding factors, such as randomness in dataset selection. Consequently, the experimental results are more stable and reliable. This simulation of data scarcity enables the evaluation of the generalization capability of the adaptation strategies in low-resource language scenarios and examines their robustness under varying levels of data availability.

3.4. Evaluation Framework

The configurations of the two factors described in Section 3.1 result in 12 experimental combinations, which are evaluated using three categories of measurements.

First, the performance of each adaptation strategy is assessed, as performance represents the primary criterion commonly used when comparing adaptation approaches. This measure reflects the ability of the adaptation strategy to perform the target task effectively; in this paper, it refers to how accurately the model predicts the correct class in the sentiment classification task.

Second, the efficiency of the adaptation strategy is evaluated, as improving efficiency is one of the principal motivations behind the development of such approaches. Specifically, training time (measured in seconds), peak GPU memory consumption, and the number of trainable parameters are measured. These metrics capture different dimensions of computational cost and address distinct practical concerns, as improvements in one metric do not necessarily correspond to proportional changes in the others. It is worth noting that the aforementioned efficiency refers to the computational cost required for each adaptation strategy, where lower values indicate greater efficiency. This evaluation excludes other factors, such as model loading and logging time, as the paper focuses only on GPU memory consumption, the number of trainable parameters, and the training time required for convergence. More details are provided in Section 4.5.

Third, the stability of each adaptation strategy is evaluated to assess its reliability across multiple experimental runs with different random seeds. This analysis examines the consistency of the methods under different initialization and data sampling conditions and evaluates the extent to which their performance remains stable across runs. Stability is considered an important factor when comparing adaptation strategies, as it influences the reliability of the reported average performance. Consequently, a more stable method may be considered more favorable than a method that achieves higher performance but exhibits substantial variability across runs.The exact metrics used to evaluate these three categories of measurements are described in Section 4.5.

When comparing methods, we consider a difference between two mean values to be substantial only if it clearly exceeds the standard deviation across random seeds. Differences that remain within the standard deviation are considered inconclusive. This assumption, adopted in this paper is referred to as the uncertainty reporting rule. To further support these comparisons, we also report confidence intervals for pairwise differences in the macro-F1 [24,25].

4. Experimental Setup

4.1. Task and Dataset

This paper formulates the task as a binary Arabic sentiment classification problem, following the standard supervised classification setting in which a model learns to map an input instance to one of a finite set of labels [26]. Given an Arabic hotel review $x_i$, the model aims to predict its sentiment label $y_i$, where $y_i\in \{0,1\}$. In this setting, 0 represents the negative class and 1 represents the positive class. Therefore, the objective is to learn a classification function $f_{\theta }\left(x_i\right)$ that maps each input review to its corresponding sentiment category.

This paper uses the Hotel Arabic Reviews Dataset (HARD) as the benchmark for evaluation. HARD is an Arabic hotel review dataset collected from Booking.com and includes user-generated reviews written in both Modern Standard Arabic and dialectal Arabic. A summary of the dataset is presented in Table 1. We utilized the balanced version of the dataset [27,28], which originally contains four rating labels: two representing low ratings (1 and 2) and two representing high ratings (4 and 5). Following the preprocessing procedure described in the original paper [27], the four rating labels were mapped into two sentiment classes: negative (ratings 1 and 2) and positive (ratings 4 and 5). The balanced dataset contains 105,698 reviews with 52,849 negative reviews and 52,849 positive reviews [28]. We split the data into training, validation, and test sets using a random stratified 80/10/10 split with a random seed of 42. Specifically, 80% of the data was used for training, 10% was used for validation, and 10% was used for final testing. This resulted in a training set of 84,558 reviews (42,279 per class) as well as validation and test sets of 10,570 reviews each (5285 per class). Stratified sampling was applied to preserve the same positive-to-negative class distribution across all subsets. The data splits were fixed across all experimental configurations. This ensured that all models in the preliminary experiments and all adaptation strategies in the main experiments were evaluated using the same data partitions, supporting a fair and reproducible comparison.

Table 1. Experimental dataset summary.

Item	Value
Dataset	HARD Arabic Hotel Reviews
Task	Binary Arabic sentiment classification
Classes	Negative, Positive
Label mapping	Ratings 1–2 → Negative Ratings 4–5 → Positive
Total reviews used	105,698
Negative reviews	52,849
Positive reviews	52,849
Split strategy	Stratified 80/10/10

Finally, HARD was selected for this project for several reasons. First, it provides a sufficiently large Arabic review dataset for evaluating adaptation strategies under a full-data setting. Second, the reviews include both MSA and dialectal Arabic, which makes the dataset suitable for evaluating Arabic language models on linguistically diverse user-generated text [27]. Finally, its use in Arabic sentiment-analysis research supports its suitability as a benchmark dataset for this task [29,30].

4.2. Pre-Trained Model

The main experiments in this paper use CAMeLBERT-Mix [14] as the selected pre-trained Arabic language model. CAMeLBERT-Mix was selected because its pre-training combines multiple Arabic varieties, including Modern Standard Arabic, dialectal Arabic, and classical Arabic [14]. This linguistic coverage is suitable for the HARD dataset, which consists of naturally written Arabic hotel reviews covering both Modern Standard Arabic and dialectal variations [27]. In the original CAMeLBERT study, the model family was evaluated across several Arabic NLP tasks, including sentiment analysis, which supports its relevance as a candidate model for Arabic sentiment classification [14].

Recent Arabic sentiment-analysis research has also reported strong performance for fine-tuned CAMeLBERT. For example, Aljomah et al. reported that fine-tuned CAMeLBERT achieved 92% accuracy and a 91.5% F1-score on noisy Arabic sentiment data. Their study also included comparisons with other Arabic pre-trained models, including AraBERTv02-twitter and MARBERT. These findings suggest that CAMeLBERT is a strong candidate for Arabic sentiment classification.

In addition, CAMeLBERT-Mix was selected based on preliminary full fine-tuning experiments conducted on the HARD dataset using the same data splits as those employed in the main experiments. Three candidate Arabic BERT-based models were evaluated: AraBERT [12], CAMeLBERT-Mix [14], and MARBERT [13]. All models were evaluated under the same training configuration across three random seeds: 42, 123, and 2024. The use of multiple seeds allowed the comparison to consider not only average performance but also stability across different training runs. As shown in Table 2, CAMeLBERT-Mix achieved the highest mean accuracy of 0.7871 with the lowest accuracy standard deviation of 0.0068. It also achieved the highest macro-F1 score of 0.7870 ± 0.0067. In comparison, AraBERT achieved an accuracy of 0.6936 ± 0.1677, while MARBERT achieved 0.5798 ± 0.1383, indicating greater variability across seeds. These results show that CAMeLBERT-Mix is the most stable candidate. Therefore, CAMeLBERT-Mix was selected as the main pre-trained model for the subsequent experiments.

Table 2. Summary of preliminary full fine tuning results across five seeds.

Model	Accuracy	Macro-F1
AraBERT	$0.6936\pm 0.1677$	$0.6380\pm 0.2639$
MARBERT	$0.5798\pm 0.1383$	$0.4687\pm 0.2345$
CAMeLBERT-Mix	$0.7871\pm 0.0068$	$0.7870\pm 0.0067$

4.3. Adaptation Strategies Implementation

Four adaptation strategies were implemented using CAMeLBERT-Mix as the base model for binary Arabic sentiment classification: full fine tuning, frozen backbone, LoRA, and QLoRA.

In the full fine-tuning setting, CAMeLBERT-Mix was loaded, and all model parameters were kept trainable, including the Transformer encoder and the classification head. This setting allows the entire pre-trained model to be updated during training and serves as the full-parameter adaptation baseline. In the frozen backbone setting, CAMeLBERT-Mix was loaded with the pre-trained encoder frozen and only the task-specific classification head updated during training. This method was included as a lightweight baseline to examine the effect of adapting only the classifier while keeping the pre-trained language representations fixed.

In the LoRA setting, low-rank adapters were added to the query and value attention projection modules of CAMeLBERT-Mix. The LoRA configuration used $r=16$, $\alpha =32$, and a dropout rate of $0.1$. Unlike full fine tuning, LoRA keeps most of the base model parameters fixed and updates only a small set of task-specific trainable parameters through the adapter-based setup. This reduces the number of trainable parameters while still allowing task-specific adaptation to the sentiment classification task. In the QLoRA setting, CAMeLBERT-Mix was loaded using 4-bit quantization before applying adapter-based fine tuning. The quantization configuration used NF4 quantization with FP16 as the computation data type, while double quantization was disabled. The QLoRA adapter configuration targeted the query and value projection modules with $r=16$, $\alpha =32$, and a dropout rate of $0.1$. QLoRA used the paged AdamW 8-bit optimizer to support training with 4-bit quantization. Apart from these QLoRA-specific settings, the remaining training settings were kept consistent with the other adaptation strategies.

Table 3 summarizes the method-specific implementation settings of the four adaptation strategies.

Table 3. Method-specific implementation settings for the adaptation strategies.

Method	Trainable Setup	Quantization	Method-Specific Settings
Full fine tuning	All model parameters	None	The full CAMeLBERT-Mix model was updated.
Frozen backbone	Classification head only	None	The pre-trained encoder was frozen.
LoRA	Adapter-based trainable parameters	None	$r=16$, $\alpha =32$, dropout = $0.1$, target modules = query, value.
QLoRA	Quantized adapter-based trainable parameters	4-bit NF4, double quantization disabled	$r=16$, $\alpha =32$, dropout = $0.1$, target modules = query, value, FP16 compute, paged_adamw_8bit.

4.4. Training-Data Sampling Procedure

To evaluate the effect of data availability on the selected adaptation strategies, three training-data levels were used: full data, 25 samples per class, and 100 samples per class. All three levels were derived from the same training split, while the validation and test sets remained fixed across all experiments.

The full training split contained 84,558 reviews with 42,279 negative and 42,279 positive samples. For the reduced-data settings, small class-balanced subsets were sampled from the full training split. The 25-per-class setting contained 50 training reviews in total, consisting of 25 negative and 25 positive samples. The 100-per-class setting contained 200 training reviews in total, consisting of 100 negative and 100 positive samples. The subsets were generated in a nested manner from the full training split. Specifically, the 25-per-class subset was fully contained within the 100-per-class subset. To reduce selection bias and improve the reliability of the experimental results, the reduced-data subsets were sampled independently for each random seed. Thus, each random seed produced its own nested 25-examples-per-class and 100-examples-per-class subsets, which were kept fixed across adaptation methods for that seed to ensure a fair comparison. The validation set contained 10,570 reviews, with 5285 samples per class, and the test set also contained 10,570 reviews, with 5285 samples per class. These validation and test sets were fixed and reused across all adaptation strategies, data levels, and random seeds to ensure a fair and reproducible comparison. Table 4 summarizes the three training-data levels used in the experiments, including the number of training samples in each setting and the fixed validation and test sets used for evaluation.

Table 4. Data splits across full and reduced-data settings.

Data Level	Training Samples		Validation Samples		Test Samples
	Positive	Negative	Positive	Negative	Positive	Negative
Full data	42,279	42,279
25 per class	25	25	5285	5285	5285	5285
100 per class	100	100

4.5. Evaluation Metrics

To evaluate the adaptation strategies across different training data levels, we adopt a set of evaluation metrics that capture performance, efficiency, and stability, which are essential for a comprehensive comparison between PEFT and full fine-tuning approaches [31,32]. Performance is evaluated using accuracy, precision, recall, and macro-F1. Efficiency is evaluated using peak GPU memory consumption, the number of trainable parameters, and training time in seconds. Stability is assessed by reporting the mean and standard deviation of the main evaluation metrics across five random seeds, while the reliability of the results is assessed using confidence intervals for pairwise differences in the macro-F1.

• Performance Metrics: They are used to evaluate the predictive capability of each adaptation strategy on the sentiment classification task. In this project, the task is formulated as a binary classification problem, where reviews are classified as either negative or positive. Accuracy measures the overall proportion of correctly classified samples. Precision measures how many predicted sentiment labels are correct among the samples assigned to a given class, while recall measures how many samples from a given true class are correctly identified. F1-score combines precision and recall into a single balanced metric [31,32]. The performance metrics are formally defined as follows:

  $$Accuracy={\displaystyle \frac{TP+TN}{TP+TN+FP+FN}}$$

  (1)

  $$Precision={\displaystyle \frac{TP}{TP+FP}}$$

  (2)

  $$Recall={\displaystyle \frac{TP}{TP+FN}}$$

  (3)

  $$F1=2·{\displaystyle \frac{Precision·Recall}{Precision+Recall}}$$

  (4)

  where TP, TN, FP, and FN denote true positives, true negatives, false positives, and false negatives, respectively. In addition to the class-level F1-score, this project reports macro-F1 as the main F1-based metric. Macro-F1 is calculated by computing the F1-score for each class and then taking the unweighted average across all classes. In this way, the negative and positive classes contribute equally to the final score. Macro-F1 is defined as follows:

  $$Macro-F1={\displaystyle \frac{1}{C}}{\displaystyle \sum _{c=1}^C}F{1}_c$$

  (5)

  where C denotes the number of classes, and $F{1}_c$ represents the F1-score of class c.
• Computational Cost metrics: They include peak GPU memory consumption, the number of trainable parameters, and training time [6,8]. Peak GPU memory represents the highest GPU memory allocation observed during model loading and training. In the implementation, CUDA peak memory statistics are reset before loading the model, and the peak memory value is recorded immediately after the training procedure before the final test-set evaluation and inference-speed measurement. Therefore, the reported peak GPU memory reflects the maximum GPU memory required to load and train the model under each experimental condition. Training time was reported in seconds. In the implementation, training time was measured as the accumulated duration of all training steps using a custom callback, TrainingTimeCallback, which records the wall-clock time between the beginning and end of each training step. Therefore, the reported training time excludes model loading, validation evaluation, logging, checkpointing, final test-set evaluation, and inference-speed measurement.
• Stability Metrics: To assess the robustness of the adaptation strategies results, each experimental condition is repeated using five random seeds: 42, 123, 456, 789, and 2024. The results are reported using the mean and standard deviation across the five runs. The mean represents the average performance, while the standard deviation reflects the stability of the method across different random seeds. A smaller standard deviation indicates more consistent results. The mean and standard deviation are formally defined as follows:  

  $$\mu ={\displaystyle \frac{1}{n}}{\displaystyle \sum _{i=1}^n}{x}_i$$

  (6)

  $$\sigma =\sqrt{{\displaystyle \frac{1}{n}}{\sum }_{i=1}^n{(x_i-\mu )}^2}$$

  (7)

  where $x_i$ denotes the evaluation result of the i-th run, n is the total number of runs, $\mu$ is the mean, and $\sigma$ is the standard deviation.

This multidimensional evaluation ensures that the comparison is not limited to performance alone but also accounts for computational cost and result consistency.

4.6. Training Configuration and Reproducibility

All experiments were conducted using CAMeLBERT-Mix as the selected pre-trained Arabic language model for binary sentiment classification. It is worth noting that the training configuration of the main experiments was designed independently of the preliminary experiments. The same training configuration was applied to all four adaptation strategies, including full fine tuning, frozen backbone, LoRA, and QLoRA, to maintain a fair and unified comparison. The training configuration used across all adaptation strategies is summarized in Table 5.

Table 5. Training configuration applied across all adaptation strategies.

Setting	Unified Value
Number of epochs	10
Learning rate	$2\times {10}^{-5}$
Training batch size	32
Evaluation batch size	64
Weight decay	0.01
Warm-up ratio	0.1
Mixed precision	FP16 enabled
Maximum sequence length	128 tokens

For optimization, AdamW was used for full fine tuning, frozen backbone, and LoRA, whereas QLoRA used paged AdamW 8-bit to support the 4-bit quantized training setup. The trainable components and method-specific settings for each adaptation strategy are described in Section 4.3 and summarized in Table 3. The maximum input sequence length was determined automatically from the token-length distribution of the full training set rather than being manually fixed in advance. The token analysis showed a median length of 27 tokens, a 95th percentile length of 100 tokens, a 99th percentile length of 174 tokens, and a maximum length of 798 tokens. Based on this analysis, the 95th percentile was rounded up to the nearest multiple of 32, resulting in a fixed maximum sequence length of 128 tokens. This value was then reused across all 12 experimental combinations and all random seeds. All input reviews were tokenized using the CAMeLBERT-Mix tokenizer, CAMeL-Lab/bert-base-arabic-camelbert-mix, with a vocabulary size of 30,000 tokens, maximum-length padding, and truncation. Each experimental configurations was repeated using five random seeds: 42, 123, 456, 789, and 2024. These seeds were applied consistently across all four adaptation strategies and all three data levels, resulting in a total of 60 training runs: 4 adaptation strategies × 3 data levels × 5 seeds. All experiments were executed in Google Colab using a single GPU A100 with 42.4 GB of available VRAM under the same CUDA-enabled runtime. For computational cost analysis, training time and memory usage were measured during each run. Training time was measured as the accumulated pure training-step time using a custom callback, TrainingTimeCallback, which records the wall-clock time between the beginning and end of each training step. This measurement excludes validation evaluation passes, logging overhead, and checkpointing from the reported training time. Peak GPU memory was recorded using CUDA peak memory allocation and reported in megabytes. These measurements were averaged across the five seeds for each experimental configuration.

5. Results

This section presents the results of our experiments and is structured around the three research questions.

5.1. Results at the Full-Data Level (RQ1)

To address the first research question, the four adaptation strategies were evaluated under the full-data setting. The comparison considers full fine tuning as the main reference method and examines how frozen backbone, LoRA, and QLoRA compare to it in terms of classification performance and computational cost.

Table 6 reports the macro-F1 and accuracy results at the full-data level. Full fine tuning reached the highest mean macro-F1 score with 0.9579 ± 0.0008. LoRA and QLoRA reached 0.9573 ± 0.0007 and 0.9569 ± 0.0006, respectively. The mean macro-F1 of full fine tuning exceeds that of LoRA and QLoRA by 0.0006 and 0.001, respectively. The gap between the mean macro-F1 of QLoRA and the full fine-tuning method is about 1.6 times the standard deviation across seeds of QLoRA (0.0006) and about 1.25 times the standard deviation of full fine tuning (0.0008). Following the uncertainty reporting rule described in Section 3.4, although the observed gap between QLoRA and full fine tuning appears meaningful, the confidence intervals for pairwise differences in the macro-F1 include zero, indicating that the difference is not statistically significant, as reported in Table 7. Therefore, the observed gap is not statistically significant. Frozen backbone obtained a substantially lower macro-F1 score with 0.8555 ± 0.0010. The difference in macro-F1 between frozen backbone and each of the other three methods is about 0.102 macro-F1 points, which is approximately one hundred times larger than the greatest standard deviation across seeds observed for the four methods at this data level. This gap is therefore well outside the observed seed variability and is supported by the confidence intervals for pairwise differences in the macro-F1 reported in Table 7. Accordingly, the frozen backbone is considered to perform worse than the other three methods at the full-data level.

Table 6. Macro-F1 and accuracy results at the full-data level across five seeds.

Method	Macro-F1 (Mean ± STD)	Accuracy
Full Fine Tuning	$0.9579\pm 0.0008$	$0.9579\pm 0.0008$
Frozen Backbone	$0.8555\pm 0.0010$	$0.8555\pm 0.0010$
LoRA	$0.9573\pm 0.0007$	$0.9573\pm 0.0007$
QLoRA	$0.9569\pm 0.0006$	$0.9569\pm 0.0006$

Table 7. Pairwise comparison results at the full-data level. Mean differences and 95% confidence intervals are reported for each pairwise comparison between the adaptation strategies.

Data Level	Comparison	Mean Difference	95% CI
Full Dataset	Full Fine Tuning vs. Frozen Backbone	$0.1024$	$(0.1015,0.1032)$
Full Dataset	Full Fine Tuning vs. LoRA	$0.0006$	$(-0.0008,0.0019)$
Full Dataset	Full Fine Tuning vs. QLoRA	$0.0009$	$(-0.0004,0.0022)$
Full Dataset	Frozen Backbone vs. LoRA	$-0.1018$	$(-0.1034,-0.1003)$
Full Dataset	Frozen Backbone vs. QLoRA	$-0.1014$	$(-0.1031,-0.0998)$
Full Dataset	LoRA vs. QLoRA	$0.0004$	$(-0.0002,0.0009)$

The reported accuracy results at the full-data level show that full fine tuning achieved the highest accuracy. LoRA and QLoRA followed with very close accuracy values, while the frozen backbone recorded the lowest accuracy among the four methods. The same pattern was observed for precision and recall, as shown in Table 8.

Table 8. Precision and recall results at the full-data level across five seeds.

Method	Precision (Mean ± STD)	Recall (Mean ± STD)
Full Fine Tuning	$0.9579\pm 0.0008$	$0.9579\pm 0.0008$
Frozen Backbone	$0.8555\pm 0.0010$	$0.8555\pm 0.0010$
LoRA	$0.9576\pm 0.0007$	$0.9573\pm 0.0007$
QLoRA	$0.9573\pm 0.0007$	$0.9569\pm 0.0006$

Table 9 reports the computational measurements for the four adaptation strategies at the full data level. At the full data level, the frozen backbone had the smallest number of trainable parameters, as only the classification layer was trained. LoRA and QLoRA had the same number of trainable parameters, and both used substantially fewer trainable parameters than full fine tuning. However, their trainable parameter count remained higher than that of the frozen backbone.

Table 9. Computational cost results at the full-data level. Peak GPU memory is reported in megabytes (MB), and training time is reported in seconds (s). Peak GPU memory and training time are reported as the mean and standard deviation across five seeds. The trainable-parameter count is reported as a single value per method, because it does not depend on the random seed.

Method	Data Level	Trainable Params	Total Params	Trainable %	Peak GPU Memory (MB)	Train Time (s)
Full Fine Tuning	Full Dataset	109.08 M	109.08 M	100%	$3532.59\pm 2.02$	$1210.59\pm 24.58$
Frozen Backbone	Full Dataset	1.5 K	109.08 M	0.0014%	$1186.9\pm 0.0$	$495.96\pm 13.51$
LoRA	Full Dataset	591.4 K	109.67 M	0.5392%	$2295.46\pm 0.00$	$1278.30\pm 0.96$
QLoRA	Full Dataset	591.4 K	109.67 M	0.5392%	$1903.05\pm 141.26$	$2073.99\pm 14.52$

For peak GPU memory, full fine tuning showed the highest memory usage at the full-data level, while frozen backbone showed the lowest. LoRA and QLoRA both used less peak GPU memory than full fine tuning. Between the two LoRA-based methods, QLoRA recorded slightly lower mean peak GPU memory than LoRA in the full-data level. At the full-data level, QLoRA’s peak GPU memory usage shows a standard deviation of roughly 141.26 MB across different random seeds. In contrast, LoRA exhibits zero standard deviation for the same metric. Consequently, the 392.41 MB gap between their mean memory usages (2295.46 MB for LoRA vs. 1903.05 MB for QLoRA) is substantially larger than the standard deviation across seeds for QLoRA. Following the uncertainty-reporting rule adopted in this paper, the difference in peak GPU memory between LoRA and QLoRA at the full-data level is meaningful.

For training time, frozen backbone was the fastest method at the full-data level. At the full-data level, full fine tuning took 1210.59 ± 24.58 s compared to 1278.30 ± 0.96 s for LoRA and 2073.99 ± 14.52 s for QLoRA. The gap between full fine tuning and LoRA (around 67.71 s) clearly exceeds the standard deviation across seeds for both approaches, and the gap between LoRA and QLoRA (around 795 s) is much larger still. Following the uncertainty-reporting rule of this paper, training time at the full-data level is shorter for full fine tuning than for both LoRA and QLoRA. It is also shorter for LoRA than for QLoRA.

Overall, to directly answer RQ1, the results at the full-data level demonstrate that full fine tuning outperforms the frozen backbone with a statistically significant improvement in macro-F1 score supported by the confidence intervals for pairwise differences in the macro-F1 scores. Moreover, both LoRA and QLoRA also achieve higher macro-F1 scores than the frozen backbone.

In contrast, the frozen backbone requires the fewest computational resources, including the lowest peak GPU memory, the fewest trainable parameters, and the shortest training time, although these savings come at the cost of reduced performance. Full fine tuning requires the highest peak GPU memory among the examined adaptation strategies while exhibiting a training time comparable to that of LoRA. QLoRA, in contrast, demonstrates the longest training time.

According to the confidence intervals for pairwise differences in the macro-F1 scores reported in Table 7, the observed differences among full fine tuning, LoRA, and QLoRA in terms of accuracy, recall, and macro-F1 are not statistically significant and therefore do not support a statistically reliable ranking among these methods. Nevertheless, all three adaptation strategies consistently outperform the frozen backbone.

5.2. Results Under Reduced Training Data (RQ2)

This section presents the results for the second research question, which examines how the behavior of the four adaptation strategies changes as the amount of training data is reduced. The comparison includes three training-data levels: full data, 25 samples per class, and 100 samples per class. The evaluated methods are full fine tuning, frozen backbone, LoRA, and QLoRA. The results are reported as the mean and standard deviation across five random seeds. Table 10 reports the accuracy and macro-F1 results for each combination of adaptation strategy and reduced-data level. Figure 2 presents the change in macro-F1 across reduced data levels. The X-axis represents the training-data level, while the Y-axis represents the macro-F1 score. Each line corresponds to one adaptation strategy. The shaded regions represent standard deviation across five seeds.

Table 10. Accuracy and macro-F1 results across reduced data levels with the full dataset level added as a reference.

Method	Data Level	N_Train	Accuracy (Mean ± STD)	Macro-F1 (Mean ± STD)
Full Fine Tuning	25/class	50	$0.8138\pm 0.0511$	$0.8129\pm 0.0520$
	100/class	200	$0.9208\pm 0.0145$	$0.9207\pm 0.0145$
	Full dataset	84,558	$0.9579\pm 0.0008$	$0.9579\pm 0.0008$
Frozen Backbone	25/class	50	$0.4615\pm 0.0619$	$0.3497\pm 0.0101$
	100/class	200	$0.4630\pm 0.0699$	$0.4013\pm 0.0380$
	Full dataset	84,558	$0.8555\pm 0.0010$	$0.8555\pm 0.0010$
LoRA	25/class	50	$0.4644\pm 0.0612$	$0.3549\pm 0.0122$
	100/class	200	$0.5182\pm 0.0734$	$0.4878\pm 0.0575$
	Full dataset	84,558	$0.9573\pm 0.0007$	$0.9573\pm 0.0007$
QLoRA	25/class	50	$0.5302\pm 0.0699$	$0.4154\pm 0.1298$
	100/class	200	$0.5837\pm 0.0817$	$0.5426\pm 0.1298$
	Full dataset	84,558	$0.9569\pm 0.0006$	$0.9569\pm 0.0006$

Figure 2. Macro-F1 trends across reduced-data levels for the four adaptation strategies with the full dataset level added as a reference. The shaded regions represent $\pm 1$ sample standard deviation across five random seeds.

First, as the amount of training data decreases, full fine tuning is the only method that maintains strong macro-F1 performance. This observation is supported by the confidence intervals for pairwise differences in the macro-F1, which indicate a statistically significant improvement over the other adaptation strategies. At the 25 samples per class data level, the difference in mean macro-F1 between full fine tuning and the other adaptation strategies is approximately 0.3975, substantially exceeding the standard deviation of all examined methods across the five random seeds. Similarly, at the 100 samples per class data level, the corresponding difference is approximately 0.3781, which also exceeds the standard deviation of all examined methods across the five seeds. These results indicate that the observed performance improvement of full fine tuning is considerably larger than the variability introduced by random seed selection.

The results presented in Table 10 and Figure 2 lead to the following observations regarding the behavior of the four methods as the size of the training set decreases. Each observation is interpreted according to the uncertainty-reporting rule adopted in this paper, with statistical conclusions based on confidence intervals for pairwise differences in the macro-F1, as reported in Table 11.

Table 11. Pairwise comparison results at reduced-data levels. Mean differences and 95% confidence intervals are reported for each pairwise comparison between the evaluated methods.

Data Level	Comparison	Mean Difference	95% CI
25 per class	Full Fine Tuning vs. Frozen Backbone	$0.4631$	$(0.3946,0.5317)$
25 per class	Full Fine Tuning vs. LoRA	$0.4579$	$(0.3892,0.5267)$
25 per class	Full Fine Tuning vs. QLoRA	$0.3974$	$(0.1881,0.6067)$
25 per class	Frozen Backbone vs. LoRA	$-0.0052$	$(-0.0111,0.0006)$
25 per class	Frozen Backbone vs. QLoRA	$-0.0657$	$(-0.2297,0.0982)$
25 per class	LoRA vs. QLoRA	$-0.0605$	$(-0.2230,0.1020)$
100 per class	Full Fine Tuning vs. Frozen Backbone	$0.5195$	$(0.4742,0.5648)$
100 per class	Full Fine Tuning vs. LoRA	$0.4329$	$(0.3692,0.4966)$
100 per class	Full Fine Tuning vs. QLoRA	$0.3781$	$(0.2119,0.5443)$
100 per class	Frozen Backbone vs. LoRA	$-0.0865$	$(-0.1322,-0.0409)$
100 per class	Frozen Backbone vs. QLoRA	$-0.1414$	$(-0.3481,0.0653)$
100 per class	LoRA vs. QLoRA	$-0.0548$	$(-0.2815,0.1718)$

Second, LoRA outperforms the frozen backbone in terms of macro-F1 score at the 100 samples per class data level with a difference in their mean scores of approximately 0.0865. This difference exceeds the standard deviation across seeds, indicating that the observed gap is meaningful. Furthermore, the confidence intervals for pairwise differences in the macro-F1 support this conclusion, as they exclude zero, demonstrating that the difference is statistically significant.

Third, full fine tuning maintains the first position in the ranking at both reduced-data levels (25 and 100 samples). LoRA at the 100 samples per class data level outperforms the frozen backbone.

Fourth, the standard deviation across seeds is substantially larger at the reduced-data levels than at the full-data level for every method. For example, full fine tuning has a standard deviation of 0.0008 at the full-data level, 0.0145 at 100 samples per class, and 0.0520 at 25 samples per class. This increase in variability is expected for smaller training sets, where the specific samples included in the training subset can strongly influence the outcome of an individual run. Therefore, these results support the use of multiple random seeds in reduced-data settings.

Together, these observations answer RQ2. Among the four methods evaluated in this paper, full fine tuning is the only method that maintains strong performance under the reduced-data levels examined at both the 25 and 100 samples per class data levels. Following the uncertainty reporting rule and the confidence intervals for pairwise differences in the macro-F1 shown in Table 11, a ranking among LoRA, QLoRA, and the frozen backbone cannot be established at the 25 samples per class data level. At the 100 samples per class data level, LoRA significantly outperforms the frozen backbone, while QLoRA is not statistically distinguishable from either LoRA or the frozen backbone. The variation in standard deviation across methods between the full-data level, 25-per-class setting, and 100-per-class setting suggests that the methods become more sensitive and less stable with respect to sample selection and initialization processes under low data settings.

5.3. Performance–Cost Trade-Off Under Reduced Training Data (RQ3)

This section presents the performance–cost trade-off results under the reduced-data settings. The comparison focuses on the relationship between classification performance and computational cost across the four adaptation strategies: full fine tuning, frozen backbone, LoRA, and QLoRA. The evaluation considers the two reduced-data levels, namely 100 samples per class and 25 samples per class. Figure 3 presents the performance–cost trade-off for the two settings by plotting macro-F1 against peak GPU memory with one point representing each adaptation strategy. Error bars represent standard deviation across five random seeds.

Figure 3. Performance–cost trade-off across the two reduced-data settings: (a) 100 samples per class and (b) 25 samples per class, showing macro-F1 against peak GPU memory. Error bars represent $\pm 1$ standard deviation across five random seeds.

Under the 100-samples-per-class setting, the macro-F1 results in Table 10 and the peak GPU memory results in Table 12 show that full fine tuning reached the highest macro-F1 0.9207 ± 0.0145 at the highest peak GPU memory 3532.71 ± 5.89 MB. Frozen backbone reached the lowest macro-F1 0.4013 ± 0.0380 at the lowest peak GPU memory 186.90 ± 0.0 MB. LoRA reached a macro-F1 score of 0.4878 ± 0.0575 at 2295.46 ± 0.00 MB, while QLoRA reached a macro-F1 score of 0.5426 ± 0.1298 at 2798.01 ± 141.58 MB.

Table 12. Computational cost results across the reduced-data settings. Peak GPU memory is reported in megabytes (MB), and training time is reported in seconds (s). Peak GPU memory and training time are reported as the mean and the standard deviation across five seeds.

Method	Data Level	Trainable Params	Total Params	Trainable %	Peak GPU Memory (MB)	Train Time (s)
Full Fine Tuning	25/class	109.08 M	109.08 M	100%	$3529.12\pm 1.12$	$1.05\pm 0.04$
	100/class	109.08 M	109.08 M	100%	$3532.71\pm 5.89$	$3.37\pm 0.08$
Frozen Backbone	25/class	1.5 K	109.08 M	0.0014%	$1186.91\pm 0.0$	$0.43\pm 0.01$
	100/class	1.5 K	109.08 M	0.0014%	$1186.90\pm 0.0$	$1.48\pm 0.03$
LoRA	25/class	591.4 K	109.67 M	0.5391%	$2295.46\pm 0.0$	$1.04\pm 0.01$
	100/class	591.4 K	109.67 M	0.5391%	$2295.46\pm 0.0$	$3.51\pm 0.03$
QLoRA	25/class	591.4 K	109.67 M	0.5392%	$2350.86\pm 141.76$	$1.63\pm 0.01$
	100/class	591.4 K	109.67M	0.5392%	$2798.01\pm 141.58$	$5.58\pm 0.03$

The gap of 0.0865 macro-F1 points between LoRA and the frozen backbone is substantial; therefore, LoRA outperforms the frozen backbone in terms of performance but at a higher memory cost. The gap of 0.0548 macro-F1 points between LoRA and QLoRA falls within QLoRA’s standard deviation and is therefore inconclusive. However, the 503 MB gap in peak GPU memory between LoRA and QLoRA is substantially larger than the standard deviations of either method. Therefore, QLoRA requires substantially more memory than LoRA. Under this data level, QLoRA does not provide a statistically significant improvement over LoRA in macro-F1 performance while requiring substantially more peak GPU memory. Therefore, LoRA achieves comparable performance with lower memory consumption.

Under the 25-samples-per-class setting, the macro-F1 results in Table 10 and the peak GPU memory results in Table 12 show that full fine tuning reached the highest macro-F1 value of 0.8129 ± 0.0520 at the highest peak GPU memory of 3529.12 ± 1.12 MB.

Frozen backbone reached a macro-F1 of 0.3491 ± 0.0146 at the lowest peak GPU memory of 1186.91 ± 0.00 MB. LoRA reached a macro-F1 of 0.3531 ± 0.0133 at 2295.46 ± 0.00 MB, and QLoRA reached a macro-F1 of 0.3530 ± 0.0108 at 2350.86 ± 141.76 MB.

The macro-F1 scores of LoRA, QLoRA, and the frozen backbone are within 0.0605. Although these differences exceed the standard deviation across seeds, they are not supported by the confidence intervals for pairwise differences in the macro-F1. Therefore, they are treated as equal within seed variability at this data level. Peak GPU memory differs substantially across these three methods: the frozen backbone uses approximately 1186.91 MB, LoRA uses approximately 2295.46 MB, and QLoRA uses approximately 2350.86 MB. The gap between LoRA and QLoRA falls within the standard deviation of QLoRA. At 25 samples per class, the three methods achieve comparable performance. However, they vary substantially in memory usage: the frozen backbone requires the least memory, while QLoRA requires the most with a difference of approximately 1164 MB that exceeds QLoRA’s standard deviation.

Across the two reduced-data levels, the pattern is as follows. Full fine tuning is the only method that achieves substantially higher performance than the other three methods, and it does so at a substantially higher memory cost. Among the three parameter-efficient methods, LoRA dominates the frozen backbone at 100 samples per class in terms of mean macro-F1. At 25 samples per class, LoRA exceeds QLoRA in terms of macro-F1, although this difference is not statistically supported and remains within seed variability. However, LoRA uses substantially less memory. The frozen backbone uses substantially less memory than the other adaptation strategies while achieving a similar macro-F1 score to LoRA within seed variability at 25 samples per class. Thus, at 25 samples per class, the frozen backbone is more memory-efficient than LoRA while maintaining a similar performance level.

In direct answer to RQ3, the choice of the most favorable performance–cost trade-off among the four methods at the reduced-data levels depends on the data level and on whether performance or computational cost is prioritized. In terms of memory efficiency, at 100 samples per class, LoRA offers a better trade-off than both QLoRA and the frozen backbone. At 25 samples per class, no PEFT method clearly outperforms the others, as LoRA, QLoRA, and the frozen backbone all achieve comparable results within seed variability, while their memory usage follows the order: frozen backbone < LoRA < QLoRA. Full fine tuning is the only method that achieves substantially higher performance at both reduced-data levels, but it comes at a substantially higher memory cost.

In terms of training-time and trainable-parameter efficiency, in the 100 samples per class data level, both QLoRA and LoRA had the same number of trainable parameters (591.4 K) but were the slowest in terms of training time, taking 5.58 s and 3.51 s, respectively, while not achieving good results. Full fine tuning performed well but used a larger number of trainable parameters (109.08M) and took only 3.37 s. In contrast, the frozen backbone performed the worst but had the fewest trainable parameters and was the fastest with 1.5 K trainable parameters and a training time of only 1.48 s.

In the 25 samples per class data level, full fine tuning differed from LoRA and QLoRA in terms of the number of trainable parameters. Full fine tuning required 109.08 M trainable parameters, while LoRA and QLoRA required 591.4 K, but they were similar in terms of processing time. Full fine tuning achieved the best performance, taking 1.05 s. QLoRA came second in performance, outperforming LoRA, although it took 1.63 s, while LoRA took 1.04 s. The frozen backbone was the fastest and most efficient in terms of trainable parameters and training time, requiring only 1.5 K trainable parameters and taking 0.43 s, but it recorded the lowest performance.

6. Discussion

The results suggest that the performance of LoRA and QLoRA depends strongly on the availability of labeled training data. When sufficient labeled data are available, full fine tuning, LoRA, and QLoRA achieve similar performance with small gaps that are not statistically significant. However, LoRA and QLoRA require substantially fewer trainable parameters and lower peak GPU memory than full fine tuning. The cost of these resource savings is longer training time for both LoRA and QLoRA at the full-data level. On the other hand, the frozen backbone is the worst-performing method.

The results changed considerably under reduced-data settings. At 100 samples per class, full fine tuning demonstrated strong performance, whereas the macro-F1 scores of LoRA and QLoRA decreased to 0.4695 and 0.4143, respectively. According to the uncertainty-reporting rule adopted in this paper and confidence intervals for pairwise differences in macro-F1, both reductions are meaningful and statistically significant. At 25 samples per class, the macro-F1 score of full fine tuning decreased further, but it remained the strongest-performing method. In contrast, LoRA, QLoRA, and the frozen backbone achieved macro-F1 scores of 0.3549, 0.4154, and 0.3497, respectively, indicating that these three methods converged to similarly low levels of performance. LoRA, QLoRA, and the frozen backbone methods share one feature: none of them updates the encoder’s full set of weights during training. The frozen backbone method learns only a classifier on top of the encoder, while LoRA and QLoRA train only low-rank matrices. In contrast, full fine tuning is the only method that directly modifies the encoder weights.

The possible reasons that may explain the poor performance of LoRA and QLoRA compared with full fine tuning under the reduced-data settings are as follows. First, LoRA and QLoRA may require more labeled data [33,34]. Second, the results suggest that adapting only the classifier is not sufficient, which may explain the low performance of the frozen backbone across all three data levels. Third, the unified experimental setting, such as the fixed numbers of epochs, learning rate, and batch size, may not be suitable for all four adaptation strategies. Therefore, method-specific hyperparameter tuning may place all methods at a similar performance level or even change the observed ranking [35,36].

The results demonstrate that even with a relatively easy task (sentiment classification) and a pre-trained language model, full fine tuning achieves higher performance across the examined data levels, which indicates the importance of fine tuning the original backbone despite the increased computational cost. LoRA and QLoRA may be sensitive to their hyperparameters, such as the rank and optimizer. It is worth noting that QLoRA utilized the 8-bit paged AdamW optimizer, which differs from the optimizer used by the other three adaptation strategies and can therefore be considered a confounding factor that may affect the observed results. However, comparing QLoRA’s performance across different training data levels provides sufficient evidence to suggest that its performance is strongly influenced by the amount of available data with its macro-F1 increasing from 0.4154 at the 25-sample data level to 0.9569 at the full-data level.

The training-time results suggest that reducing the number of trainable parameters did not consistently lead to faster training. At the full-data level, full fine tuning completed in 1210.59 s, while LoRA required 1278.30 s and QLoRA required 2073.99 s despite both updating far fewer parameters. The additional computation required during the forward and backward passes through the low-rank matrices in LoRA may contribute to its longer training time. Moreover, QLoRA requires additional time to dequantize the 4-bit model during the forward and backward passes [37]. These factors may help explain why neither method offered a training-time advantage over full fine tuning in this experiment. The frozen backbone was the fastest method, completing training in 495.96 s.

From a practical perspective, the selection of an adaptation strategy mainly depends on data availability, computational constraints, and the desired performance. When sufficient labeled data are available, the choice among full fine tuning, LoRA, and QLoRA cannot be based on classification performance alone, as the three methods exhibit comparable macro-F1 performance at the full-data level within seed variability. The choice should therefore also consider computational cost. LoRA and QLoRA use less peak GPU memory than full fine tuning, with a difference of approximately 1237 MB, while requiring longer training times. Full fine tuning is therefore the appropriate choice when sufficient GPU memory is available and training time is the primary constraint. LoRA or QLoRA is preferable when GPU memory is the main constraint and additional training time can be accommodated.

Between LoRA and QLoRA at the full-data level, the results of this paper do not indicate a clear advantage of either method in terms of classification performance or peak GPU memory usage. The main notable difference is that QLoRA requires more training time. However, with limited labeled data, both methods showed substantially lower performance than full fine tuning under the training configuration used in this paper. Therefore, full fine tuning is the preferred approach for low-resource Arabic sentiment classification in the examined settings.

Limitations and Future Work

Although this paper compares full fine tuning, LoRA, QLoRA, and the frozen backbone across different levels of training-data availability under a unified experimental setting to ensure a fair comparison, the findings are limited to the use of CAMeLBERT-Mix as the backbone, HARD as the dataset, and sentiment analysis as the task. Therefore, the findings may not generalize to other pre-trained Arabic language models, as they may depend on the language coverage and inductive biases of CAMeLBERT-Mix. Moreover, the results may depend on the selected hyperparameter configuration. In addition, since QLoRA uses the paged AdamW optimizer with 4-bit quantization, this difference may be considered a confounding factor when comparing QLoRA with the other adaptation strategies. However, this factor does not affect the comparison of QLoRA across different training data levels within the same experimental configuration.

These study limitations can be further investigated in future work. One possible direction is to conduct a comparative study in which each adaptation strategy is tuned independently. Although this would compromise the strict fairness of the controlled comparison conducted in this paper, it would provide useful insights into the potential of each method under its own optimized configuration and how independent tuning may affect the reported performance and computational cost.

Another research direction is to investigate the behavior of each adaptation strategy through detailed error analysis. Examining errors related to dialectal variation, sarcasm, spelling variants, and colloquial expressions could provide insights into which aspects of Arabic language variation are not adequately handled by each adaptation strategy. This type of analysis could help identify whether different adaptation strategies exhibit different weaknesses when handling specific linguistic characteristics of Arabic.

Future studies should also examine GPU memory usage throughout training rather than relying solely on peak memory. Systematically varying factors such as batch size, sequence length, optimizer configuration, and model size could help identify the conditions under which the memory behavior of different adaptation strategies changes. This is particularly relevant to QLoRA, for which this paper observed unexpected variations in peak GPU memory across data levels. Future research could investigate whether these variations are associated with optimizer configuration, quantization-related memory allocations, sequence length, or GPU memory management.

Another important direction is to investigate the extent to which the four methods are robust to potential bias toward specific Arabic dialects. This could provide deeper insights into whether the four adaptation strategies exhibit different levels of robustness to linguistic variation and potential dialect-related biases beyond standard classification metrics.

Finally, future work could examine the generalizability of these findings across various Arabic classification tasks and datasets as well as across different pre-trained Arabic language models. Such extensions would help determine whether the observed performance and computational trade-offs are specific to CAMeLBERT and the HARD sentiment analysis dataset or whether they generalize to a broader range of Arabic NLP settings.

7. Conclusions

This paper compared four different methods: full fine tuning, frozen backbone, LoRA, and QLoRA, under a unified experimental setting for Arabic sentiment classification within the full-data and reduced-data levels.

Under the full-data level, in terms of performance, LoRA, QLoRA, and full fine tuning achieve similar performance, while the frozen backbone is the worst adaptation strategy. Therefore, if the concern is training time and faster convergence is needed, full fine tuning is the better choice. If GPU memory allocation is more important, QLoRA is recommended.

Under the 100 samples per class data level, full fine tuning achieves higher performance with shorter training time compared with LoRA and QLoRA. Therefore, full fine tuning is recommended if there is no constraint on GPU memory. Otherwise, LoRA is a good choice, followed by the frozen backbone, but with lower performance. QLoRA requires more training time and peak GPU memory than full fine tuning.

Under the 25 samples per class data level, full fine tuning is the best in terms of performance, while all the remaining methods can be considered to be in the same rank. If training time matters more than performance, the frozen backbone is suggested. Similarly, if peak GPU memory is limited, the frozen backbone can be considered the second choice because of its lower computational cost and similar performance to LoRA and QLoRA. Overall, these findings provide practical decision-making support for institutions or individuals in selecting an appropriate adaptation strategy under different constraints and priorities, including performance, peak GPU memory, training time, and the amount of available labeled data, within the experimental conditions examined in this paper.