Paper deep dive
TTLab at AlexandriaX-2026: A Fine-Tuned Surface Tagger for Arabic Machine-Translation Error-Span Detection and Classification
Ali Abusaleh, Bhuvanesh Verma, Alexander Mehler
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 94%
Last extracted: 9/25/2026, 5:32:04 AM
Summary
This paper presents TTLab's submission to the AlexandriaX-2026 Subtask 3, focusing on Arabic Machine Translation error span detection and classification. The system employs a fine-tuned surface-tagging approach using MARBERTv2 as the backbone encoder, framing the task as token-level classification over raw surface forms to preserve character offsets. To address severe label imbalance, the model utilizes focal loss with class weighting and dialect-specific decoding thresholds. MARBERTv2 achieved the best performance, ranking 3rd among participating teams with an overall score of 40.91 on the test set. The study highlights that while error localization is effective, classifying rare error types remains challenging due to data scarcity.
Entities (10)
Relation Signals (6)
TTLab → submittedto → AlexandriaX-2026
confidence 98% · We present TTLab’s submission to the AlexandriaX-2026 Subtask 3
MARBERTv2 → achievedbestperformancein → AlexandriaX-2026
confidence 97% · Among six Arabic pre-trained encoders, MARBERTv2 achieves the best overall performance... ranking 3rd
Ali Abusaleh → affiliatedwith → Goethe University Frankfurt
confidence 95% · Affiliation: Text Technology Lab (TTLab), Affiliation: Goethe University Frankfurt
TTLab System → usesmethod → Focal Loss
confidence 95% · we employ a focal loss with class weighting
TTLab System → usesmethod → Surface Tagging
confidence 95% · Our surface-tagging formulation directly addresses these by reframing the task as discriminative token classification
MARBERTv2 → outperforms → NileChat-3B
confidence 90% · MARBERTv2 achieves the best performance... substantially outperforming its peers... AraBERTv2 and the generative NileChat-3B perform considerably worse.
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:We present TTLab's submission to the AlexandriaX-2026 Subtask~3 on Arabic MT error span detection and classification. Our system frames the task as token-level classification over surface forms, preserving character offsets to ensure exact alignment with the evaluation metric. To handle severe label imbalance, we employ a focal loss with class weighting and dialect-specific decoding thresholds. Among six Arabic pre-trained encoders, MARBERTv2 achieves the best overall performance of 40.8 and 40.91 on the development and test set, respectively, ranking $\nth{3}$ out of all participating teams. While our system localizes error spans effectively, classification of rare error types remains challenging, highlighting the need for data augmentation for tail categories. The code is available at ${\href{this https URL}{\faGithub~ TTLab at AlexandriaX-2026}$
Tags
Links
- Source: https://arxiv.org/abs/2609.29633v1
- Canonical: https://arxiv.org/abs/2609.29633v1
Trouble viewing inline? Open PDF directly →
Full Text
29,446 characters extracted from source content.
Expand or collapse full text
TTLab at AlexandriaX-2026: A Fine-Tuned Surface Tagger for Arabic Machine-Translation Error-Span Detection and Classification Ali Abusaleh Bhuvanesh Verma Alexander Mehler Affiliation: Text Technology Lab (TTLab), Affiliation: Goethe University Frankfurt Email: a.abusaleh,verma,mehler@em.uni-frankfurt.de Abstract We present TTLab’s submission to the AlexandriaX-2026 Subtask 3 on Arabic MT error span detection and classification. Our system frames the task as token-level classification over surface forms, preserving character offsets to ensure exact alignment with the evaluation metric. To handle severe label imbalance, we employ a focal loss with class weighting and dialect-specific decoding thresholds. Among six Arabic pre-trained encoders, MARBERTv2 achieves the best overall performance of 40.8 and 40.91 on the development and test set, respectively, ranking 3rd out of all participating teams. While our system localizes error spans effectively, classification of rare error types remains challenging, highlighting the need for data augmentation for tail categories. The code is available at TTLab at AlexandriaX-2026. 1 Introduction Machine translation (MT) into dialectal Arabic remains substantially harder than into Modern Standard Arabic (MSA) Alabdullah et al. (2025), and sentence-level quality estimation is often too coarse for downstream applications like post-editing. Dialectal Arabic poses unique challenges: non-standard orthography, dialect-specific morphosyntactic patterns, and scarce parallel corpora. Fine-grained error span detection (locating exact erroneous substrings and labeling their category) provides the granularity these workflows require Jung et al. (2023), but remains under-explored for Arabic dialects. AlexandriaX-2026 Subtask 3 El Mekki et al. (2026) addresses this gap: given an English source and its Arabic dialect MT output, systems must return every inaccurate character span with a category from a six-type linguistically motivated inventory (Magdy et al., 2026). The task spans five English-to-dialect directions and is evaluated at the exact character-offset level. The official baseline fine-tunes a 3B-parameter generative LLM (NileChat) to produce JSON-encoded spans. However, this generative paradigm introduces three inefficiencies: (i) brittle JSON parsing (malformed output yields empty predictions), (i) unreliable offset prediction (models must learn to generate character indices as text), and (i) poor sample efficiency (completion-only loss ignores the discriminative signal from 80% non-error tokens). Our surface-tagging formulation directly addresses these by reframing the task as discriminative token classification. We present TTLab’s submission: a surface-tagging approach that (i) preserves character offsets via sub-word tokenization, (i) uses focal loss with down-weighted no-error labels to handle severe imbalance, and (i) employs dialect-specific confidence thresholds. Among six Arabic pre-trained encoders, MARBERTv2 achieves the best performance (40.8 on dev, 40.9 on test), substantially outperforming its peers. The remainder of this paper is organized as follows. Section 2 reviews relevant work on MT quality estimation and Arabic dialectal NLP. Section 3 describes the task and dataset. Section 4 presents our system architecture and training methodology. Section 5 details our experimental setup, and Section 6 reports and analyzes the results. Finally, Section 7 concludes and discusses future directions. 2 Related Work MT error annotation with MQM/LQM. The Multidimensional Quality Metrics (MQM) framework defines an open, extensible vocabulary of translation error types applicable to human and machine translation alike Lommel et al. (2014). Freitag et al. (2021) established MQM-grounded expert error annotation as the reference methodology for MT evaluation, re-scoring top WMT systems with professional annotators. The LQM-style category scheme of AlexandriaX-2026 Subtask 3 El Mekki et al. (2026) follows this tradition: errors are annotated as text spans, each carrying a category label. Fine-grained quality estimation and error-span detection. Predicting such annotations automatically has moved from sentence-level scores to fine-grained outputs. The WMT 2022 QE shared task adopted MQM annotations for sentence- and word-level quality prediction Zerva et al. (2022), and WMT 2023 introduced a dedicated fine-grained error span detection task, asking systems to predict error spans rather than binary ok/bad tags WMT QE Shared Task Organizers (2023). Learned metrics have followed: xCOMET couples sentence-level evaluation with the detection and categorisation of error spans Guerreiro et al. (2024), while GEMBA-MQM prompts GPT-4 to mark MQM error spans without references Kocmi and Federmann (2023). Our task shares this span-plus-category formulation, but targets dialectal Arabic as an under-resourced target language with only ∼ 1.1k training sentences. Sequence tagging with Arabic encoders. Casting error identification as token-level tagging rather than generation has strong precedent: MaTESe reframes MT evaluation as a sequence-tagging problem over error spans Perrella et al. (2022), and GECToR showed that a tag-based encoder outperforms rewriting for error-focused tasks Omelianchuk et al. (2020). Our surface tagger follows this line, a token classifier over the raw MT output whose offsets recover exact character spans, with a focal loss Lin et al. (2018) against the extreme o-class imbalance, built on Arabic pre-trained encoders: MARBERT/MARBERTv2, pre-trained on diverse Arabic varieties including dialectal text Abdul-Mageed et al. (2021); CAMeLBERT, with variant-specific models for MSA, dialectal, and classical Arabic Inoue et al. (2021); and AraBERT, which established the value of Arabic-specific pre-training over multilingual models Antoun et al. (2020). Consistent with its dialectal pre-training, we find the MARBERTv2 family strongest for tagging dialectal MT output (Section 6). 3 Task and Data We use the official dataset El Mekki et al. (2026). Each instance consists of an English source sentence, a machine-generated Arabic dialect translation (the model_prediction), and a list of gold error annotations. Every error is specified by its verbatim text span, character-level start and end offsets into the translation, and a category from the set graphetics, morphosyntax, orthography, pragmatics, semantics, sociolinguistics based on Magdy et al. 2026. The data are organized by dialect direction: ENG_EGY, ENG_MAU, ENG_MOR, ENG_PAL, and ENG_UAE. Table 1 summarizes the training set statistics. Two properties dominate every design decision. First, the data are small: 1,125 training sentences contain only 1,997 error spans (mean 1.78 per sentence). Second, the label distribution is heavily imbalanced: roughly 80% of all tokens carry no error, and the category distribution ranges from sociolinguistics (57.9%) down to graphetics (only 2 spans in the entire training set). We therefore collapse the three rarest categories orthography, pragmatics, and graphetics into a single other class during training, while retaining morphosyntax, semantics, and sociolinguistics as explicit categories. The collapsed other class is expanded back to the most frequent original category at post-processing for scoring. Split / property Value Sizes Train sentences 1,125 Dev sentences 138 Train error spans 1,997 Errors / sentence (mean) 1.78 Directions ENG_EGY 263 ENG_MAU 244 ENG_PAL 218 ENG_UAE 231 ENG_MOR 169 Categories sociolinguistics 57.9% semantics 24.3% morphosyntax 8.2% orthography 5.3% pragmatics 4.2% graphetics 0.1% Table 1: AlexandriaX Subtask 3 training set statistics. Percentages are computed over all error spans. w1w_1w2w_2w3w_3w4w_4wnw_n Raw Arabic MT output m (sub-word tokens, with char offsets) Fine-tuned Arabic Encoder (e.g. MARBERTv2)1h_12h_23h_34h_45h_5W1Wh_1W2Wh_2W3Wh_3W4Wh_4W5Wh_5OB-semI-semOO Per-token labels → merged into character spans (s,e,c)(s,e,c)Decode:per-directionthreshold τd _d+ post-proc Figure 1: Architecture of the error span detection and classification system. The raw Arabic MT output is tokenized with character offsets (bottom row) and encoded by a fine-tuned Arabic encoder. A linear head classifies each sub-word token; contiguous non-O tokens of the same category are merged and mapped to character spans via the stored offsets. The decoding block applies dialect-specific confidence thresholds and light post-processing. 4 System Overview Tokenization and Surface Representation The core design choice of our system is to tag the surface form of the MT output exactly as produced by the encoder’s sub-word tokenizer, preserving the character offsets that map each token back to the original string. We deliberately do not apply any normalization, stemming, or diacritic removal, because the evaluation compares predicted and gold spans by their character offsets in the original translation. Any transformation that shifts character positions would break the alignment between a predicted token and the exact span expected by the metric. Tagging the raw surface thus keeps the offset bridge exact. Figure 1 illustrates the full pipeline. The raw Arabic MT output m is tokenized into sub-word units w1,…,wnw_1,…,w_n together with their character offsets (si,ei)(s_i,e_i). These tokens are fed to a fine-tuned Arabic encoder, which produces contextual hidden states i=f(m)i∈ℝdh_i=f(m)_i ^d. A linear classification head is applied independently to each token, yielding label scores i=Wiz_i=Wh_i with W∈ℝ|ℒ|×dW ^|L|× d. The label set is ℒ=O∪L=\O\ , where C is the collapsed set of error categories. Joint Error Detection and Classification We formulate the task as per-token classification. Each gold error span induces the corresponding label for every token it overlaps; all other tokens receive the O (no error) label. During inference, contiguous non-O tokens of the same category are merged into a single error span, and the stored character offsets are used to map it back to the exact character positions (s,e,c)(s,e,c) required by the scorer. Imbalance-Aware Objective Because the O label dominates, a standard cross-entropy loss would cause the model to over-predict "no error." We therefore minimize a focal loss Lin et al. (2018) with down-weighted O: ℒ=−1N∑iαyi(1−pi,yi)γlogpi,yi,L=- 1N _i _y_i(1-p_i,y_i)^γ p_i,y_i, where pi=softmax(i)p_i=softmax(z_i) and yiy_i is the gold label. We set the focusing parameter γ=2γ=2 and use class weights αO=0.3 _O=0.3, αc=1 _c=1 for c∈c ; padding and special tokens are excluded from the loss computation. The down-weighting of O prevents the 80% non-error majority from dominating the gradient, while the focal term sharpens the focus on hard, rare error tokens. Decoding and Dialect-Specific Thresholds At inference time we compute the per-token error probability 1−pi,O1-p_i,O. A token is flagged as an error when this probability exceeds a dialect-specific threshold τd _d, and its category is determined by argmaxc∈pi,c _c p_i,c. Contiguous tokens with the same category are merged, and their offsets define the character span. The thresholds τd\ _d\ are tuned on out-of-fold (OOF) cross-validation predictions to maximize each dialect’s overall score. Using a separate τd _d per direction is critical because the dialects exhibit substantially different error densities (see Table 1); a single global threshold would systematically over- or under-predict in different dialects. A light post-processing step trims leading/trailing whitespace and punctuation from the predicted spans and discards spans shorter than two characters. For final scoring, the collapsed other class is mapped to the most frequent original category among the merged tokens. 5 Experiments Setup. We fine-tune each encoder end-to-end using AdamW with a learning rate of 2×10−52× 10^-5, batch size 16, and maximum sequence length 192. Gradient clipping is set to 1.0, and all models are trained with the focal loss defined in Section 4. Results are reported as five-fold cross-validation on the training set (out-of-fold, OOF). The official development set (138 sentences) is used only as a secondary reference for backbone selection and diagnostics because single-split scores at this size are noisy; the one system decision made on dev is the character-level ensemble’s vote threshold v (see the “Character-Level Voting Ensemble” paragraph below), which has no OOF analogue in our pipeline. Backbone Comparison. We compare six Arabic pre-trained encoders within the identical surface-tagging pipeline: MARBERTv2 Abdul-Mageed et al. (2021), a MARBERTv2 cross-encoder checkpoint fine-tuned on QuranQA11 1 https://huggingface.co/yoriis/marbertv2-crossencoder-quranqa25, CAMeLBERT-DA Inoue et al. (2021), SaudiBERT Qarah (2024), AraBERTv2 Antoun et al. (2020), and NileChat-3B El Mekki et al. (2025) used as a token tagger. This sweep selects the final backbone; Table 2 reports the results. Per-Dialect Thresholds and Post-Processing. Tuning a separate confidence threshold for each dialect, rather than a single global threshold, yields consistent gains of up to 0.8 points in overall OOF score. The light post-processing (span trimming and minimum length filtering) adds a further 0.3-0.5 points. Both components are retained in the final system. Character-Level Voting Ensemble. As an extension, we build a character-level voting ensemble on top of the six per-backbone taggers. Each model independently decodes its spans; a character position is considered part of an error if at least v models agree, and the category is decided by a weighted majority vote. Sweeping the vote threshold v interpolates between the union (higher recall) and intersection (higher precision) of the individual taggers. The best operating point on the dev set is reported in Table 2. 6 Results System Backbone OOF Dev Fine-tuned surface tagger Surface tagger NileChat-3B 28.2 29.2 Surface tagger AraBERTv2 34.8 34.4 Surface tagger SaudiBERT 36.7 35.1 Surface tagger CAMeLBERT-DA 36.7 35.8 Surface tagger MARBERTv2 (QuranQA c.e.) 38.9 38.5 Surface tagger (final) MARBERTv2 39.4 40.8 Extension built on top Char-vote ensemble six backbones - 39.9 Table 2: Results on AlexandriaX Subtask 3. We report (Overlap-span F1+Error-Category micro-F1)/2(Overlap-span F_1+Error-Category micro-F_1)/2 (in percent); the official leaderboard instead combines overlap-span F1F_1 and error-class F1F_1 as (Overlap+Class)/2(Overlap+Class)/2, each macro-averaged across the five dialect directions (Exact-Match F1F_1 is reported by the leaderboard separately as a diagnostic and does not enter the ranking score), so our development scores here are a pooled/micro proxy and are not directly comparable. OOF is five-fold cross-validation on the training set; Dev is the official 138-sentence development set. MARBERTv2 achieves the best performance on both splits and is our submitted system. Backbone Comparison. Table 2 shows that MARBERTv2 is the strongest backbone, achieving 39.4 OOF and 40.8 Dev. It is followed by the MARBERTv2 cross-encoder checkpoint (38.9/38.5), and then by the dialectal CAMeLBERT-DA and SaudiBERT (both 36.7 OOF). AraBERTv2 and the generative NileChat-3B perform considerably worse. The MARBERTv2 family clearly dominates, and we select it as the final backbone. Localization Outperforms Categorization. Decomposing the metric reveals a consistent pattern: at the best operating points of both single models and the ensemble, the overlap-span F1F_1 reaches 46-48, while the error-category micro-F1F_1 is only 31-33. A matched-span analysis indicates that when the model correctly localizes an error, it usually assigns the correct category. The residual category loss is driven primarily by undetected spans (which are category false negatives) and by the extremely rare classes (2-83 training examples each), not by misclassification of detected spans. Threshold-Tuning Validity: Nested vs. Pooled OOF. Because τd\ _d\ in Section 4 is tuned and evaluated on the same pooled OOF predictions, we additionally run a nested (leave-one-fold-out) variant: for each fold, thresholds are tuned only on the other four folds’ OOF predictions before scoring the held-out fold. For the submitted MARBERTv2 configuration this lowers the OOF overall score from 39.4 (pooled, as in Table 2) to 35.4 (nested), a ∼ 4-point gap that we attribute to the pooled procedure’s mild overfitting to the OOF set it is also scored on. We take 35.4 to be the more honest OOF estimate and report it alongside the original in Table 4. Loss and Category-Granularity Ablations. Table 4 isolates two design choices. Replacing focal loss with weighted cross-entropy loses 0.8 nested-OOF and 1.9 dev-macro-F1F_1 points, confirming focal weighting is a modest but consistent contributor. More notably, training on all six categories directly (no collapse) matches or exceeds the submitted configuration on every metric, including dev macro-F1F_1 (18.2 vs. 16.3), because orthography recovers a category-specific signal (OOF F1F_1 9.6 vs. 4.9 from the fixed fallback) and pragmatics moves off zero; graphetics stays at 0 (2 training examples). We confirmed this on the official leaderboard by retraining and resubmitting: the no-collapse system raises the test Overall Score from 40.91 (submitted) to 42.00 (Table 3) Direction Exact Overlap Class ENG_EGY 14 50 47 ENG_MOR 17 47 32 ENG_MAU 7 39 44 ENG_PAL 16 47 28 ENG_UAE 10 49 42 Macro 13 46 38 Table 3: Official Codabench test-set scores (%) per dialect direction for the revised focal, no-collapse MARBERTv2 system. Overall Score (Overlapmacro+Classmacro)/2=42.00(Overlap_macro+Class_macro)/2=42.00. Exact-Match is a diagnostic and does not enter the ranking score. Config OOFpooled_pooled OOFnested_nested Dev Dev macro-F1catF_1^cat Focal + collapse (submitted) 39.4 35.4 38.9 16.3 Cross-entropy + collapse 39.1 34.6 38.8 14.5 Focal + no collapse 39.3 35.9 40.1 18.2 Table 4: Ablations on the final MARBERTv2 tagger (5-fold OOF, retrained per configuration). OOFpooled_pooled matches the procedure in Table 2; OOFnested_nested tunes per-dialect thresholds on the other four folds only. Dev macro-F1catF_1^cat is the true per-category macro-F1F_1 (over all six original categories) on the official dev set, using overlap-based span matching. Per-Category Breakdown. Table 5 reports precision, recall, and F1F_1 for each of the six original categories, computed on the 5-fold OOF predictions of the submitted (focal, collapsed) configuration over the training set. We use the training set rather than dev for this analysis because the 138-sentence dev set happens to contain zero gold spans of orthography, pragmatics, or graphetics, making it unusable for assessing exactly the rare categories this analysis is meant to cover. Sociolinguistics and semantics, the two head categories, reach F1F_1 39.2 and 23.6 respectively. Morphosyntax is modeled explicitly (it is not collapsed) yet still only reaches F1F_1 5.3, a genuine weak point we attribute to its smaller size (164 spans) and higher surface-form variability rather than to the collapse strategy. Orthography, which is collapsed into other at train time, inherits F1F_1 4.9 purely via the fixed fallback label; pragmatics and graphetics are never recovered (F1F_1=0). Category Supp. P R F1F_1 sociolinguistics 1157 31.7 51.3 39.2 semantics 485 21.0 27.0 23.6 morphosyntax 164 5.8 4.9 5.3 orthography 106 5.2 4.7 4.9 pragmatics 83 0.0 0.0 0.0 graphetics 2 0.0 0.0 0.0 Table 5: Per-category precision/recall/F1F_1 (%) of the submitted (focal, collapsed) MARBERTv2 tagger, on 5-fold OOF predictions over the training set. Support is the number of gold spans of that category. Orthography is collapsed into other at train time, so its score here reflects the fixed other→ fallback rather than category-specific discrimination; morphosyntax is modeled explicitly and its low score is a genuine gap (see Table 4 for the un-collapsed alternative). The Ensemble Does Not Improve Over the Single Best Model. The character-level voting ensemble attains a dev score of 39.9 at its optimal vote threshold, improving recall and category F1F_1 slightly but failing to exceed the single MARBERTv2 tagger (40.8). Because MARBERTv2 dominates its peers, blending in weaker, correlated encoders only dilutes its predictions. We therefore submit the single MARBERTv2 surface tagger as our final system. 7 Conclusion We presented a surface-tagging approach for dialectal Arabic MT error span detection and classification that operates directly on raw, unnormalized text. By preserving character offsets through the tokenization and modeling pipeline, we ensure exact alignment with the gold spans required by the evaluation metric. A focal loss with class weighting effectively handles the severe label imbalance, and dialect-specific confidence thresholds adapt to varying error densities. Among six pre-trained Arabic encoders, MARBERTv2 yields the best results, and a character-level ensemble offers no further gain. Detailed analysis reveals that the system localizes errors well but struggles with the rarest categories due to extreme data scarcity. Future work could explore data augmentation for tail categories, cross-lingual transfer from higher-resource languages, and exact-match-span optimization to better align with the official scoring regime. Limitations Several limitations of this work should be noted. First, the training set is extremely small (1,125 sentences) and contains only two examples of the graphetics category, making it nearly impossible to learn that class reliably. Our collapse strategy mitigates this but does not fully solve the data sparsity problem. Second, the system relies on a single, relatively large encoder (MARBERTv2) and may not scale gracefully to resource-constrained environments. Third, although we deliberately avoid normalization to preserve character offsets, this choice ties the system to the exact tokenization of the chosen encoder; a change of tokenizer would require re-mapping the offset annotations. Finally, our development metric pools overlap-span F1F_1 and micro-averaged category F1F_1 across the whole split, whereas the confirmed official metric computes overlap-span F1F_1 and error-class F1F_1 per dialect direction and macro-averages each across the five directions before combining them; exact-match F1F_1 (literal character-offset equality) is reported by the leaderboard separately as a diagnostic that does not enter the ranking score. Our development-set numbers are therefore a pooled/micro proxy and are not directly comparable to the official leaderboard; we did not optimize for the official aggregation directly. Acknowledgments This research is partially funded by the German Research Foundation within the Infrastructure Priority Programme New Data Spaces for the Social Sciences (SPP 2431), Research-driven Infrastructure for Advanced Survey-related Data (CIRCLET) measure project number 539634240 and (Semi-)Automated thematic text classification as a basis for corpus-linguistic value-added services (Project number: 531750631). References Abdul-Mageed et al. (2021) Muhammad Abdul-Mageed, AbdelRahim Elmadany, and El Moatez Billah Nagoudi. 2021. ARBERT & MARBERT: Deep bidirectional transformers for Arabic. In Proceedings of the 59th Annual Meeting of the Association for Computational Linguistics and the 11th International Joint Conference on Natural Language Processing (Volume 1: Long Papers), pages 7088–7105, Online. Association for Computational Linguistics. Alabdullah et al. (2025) Abdullah Alabdullah, Lifeng Han, and Chenghua Lin. 2025. Advancing dialectal arabic to modern standard arabic machine translation. Preprint, arXiv:2507.20301. Antoun et al. (2020) Wissam Antoun, Fady Baly, and Hazem Hajj. 2020. AraBERT: Transformer-based model for Arabic language understanding. In Proceedings of the 4th Workshop on Open-Source Arabic Corpora and Processing Tools, with a Shared Task on Offensive Language Detection, pages 9–15, Marseille, France. European Language Resources Association. El Mekki et al. (2025) Abdellah El Mekki, Houdaifa Atou, Omer Nacar, Shady Shehata, and Muhammad Abdul-Mageed. 2025. NileChat: Towards linguistically diverse and culturally aware LLMs for local communities. In Proceedings of the 2025 Conference on Empirical Methods in Natural Language Processing, pages 10978–11002, Suzhou, China. Association for Computational Linguistics. El Mekki et al. (2026) Abdellah El Mekki, AbdelRahim A. Elmadany, Samar M. Magdy, Saad Ezzini, Mo El-Haj, Mustafa Jarrar, Zaid Alyafeai, Bernard Ghanem, and Muhammad Abdul-Mageed. 2026. AlexandriaX 2026: The First Shared Task on Dialectal Arabic Machine Translation. In Proceedings of The Fourth Arabic Natural Language Processing Conference: Shared Tasks, Budapest, Hungary. Association for Computational Linguistics. Freitag et al. (2021) Markus Freitag, George Foster, David Grangier, Viresh Ratnakar, Qijun Tan, and Wolfgang Macherey. 2021. Experts, errors, and context: A large-scale study of human evaluation for machine translation. Transactions of the Association for Computational Linguistics, 9:1460–1474. Guerreiro et al. (2024) Nuno M. Guerreiro, Ricardo Rei, Daan van Stigt, Luisa Coheur, Pierre Colombo, and André F. T. Martins. 2024. xCOMET: Transparent machine translation evaluation through fine-grained error detection. Transactions of the Association for Computational Linguistics, 12:979–995. Inoue et al. (2021) Go Inoue, Bashar Alhafni, Nurpeiis Baimukan, Houda Bouamor, and Nizar Habash. 2021. The interplay of variant, size, and task type in Arabic pre-trained language models. In Proceedings of the Sixth Arabic Natural Language Processing Workshop, pages 92–104, Kyiv, Ukraine (Virtual). Association for Computational Linguistics. Jung et al. (2023) Dahyun Jung, Chanjun Park, Sugyeong Eo, and Heuiseok Lim. 2023. Enhancing machine translation quality estimation via fine-grained error analysis and large language model. Mathematics, 11(19). Kocmi and Federmann (2023) Tom Kocmi and Christian Federmann. 2023. GEMBA-MQM: Detecting translation quality error spans with GPT-4. In Proceedings of the Eighth Conference on Machine Translation, pages 768–775, Singapore. Association for Computational Linguistics. Lin et al. (2018) Tsung-Yi Lin, Priya Goyal, Ross Girshick, Kaiming He, and Piotr Dollár. 2018. Focal loss for dense object detection. Preprint, arXiv:1708.02002. Lommel et al. (2014) Arle Lommel, Hans Uszkoreit, and Aljoscha Burchardt. 2014. Multidimensional quality metrics (mqm): A framework for declaring and describing translation quality metrics. Tradumàtica tecnologies de la traducció, pages 455–463. Magdy et al. (2026) Samar M. Magdy, Fakhraddin Alwajih, Abdellah El Mekki, Wesam El Sayed, and Muhammad Abdul-Mageed. 2026. LQM: Linguistically motivated multidimensional quality metrics for machine translation. In Findings of the Association for Computational Linguistics: ACL 2026, pages 40470–40493, San Diego, California, United States. Association for Computational Linguistics. Omelianchuk et al. (2020) Kostiantyn Omelianchuk, Vitaliy Atrasevych, Artem Chernodub, and Oleksandr Skurzhanskyi. 2020. GECToR – grammatical error correction: Tag, not rewrite. In Proceedings of the Fifteenth Workshop on Innovative Use of NLP for Building Educational Applications, pages 163–170, Seattle, WA, USA → Online. Association for Computational Linguistics. Perrella et al. (2022) Stefano Perrella, Lorenzo Proietti, Alessandro Scirè, Niccolò Campolungo, and Roberto Navigli. 2022. MaTESe: Machine translation evaluation as a sequence tagging problem. In Proceedings of the Seventh Conference on Machine Translation (WMT), pages 569–577, Abu Dhabi, United Arab Emirates (Hybrid). Association for Computational Linguistics. Qarah (2024) Faisal Qarah. 2024. Saudibert: A large language model pretrained on saudi dialect corpora. arXiv preprint arXiv:2405.06239. WMT QE Shared Task Organizers (2023) WMT QE Shared Task Organizers. 2023. WMT 2023 shared task on quality estimation — task 2: Fine-grained error span detection. https://wmt-qe-task.github.io/wmt-qe-2023/subtasks/task2/. Accessed 9th, July 2026. Zerva et al. (2022) Chrysoula Zerva, Frédéric Blain, Ricardo Rei, Piyawat Lertvittayakumjorn, José G. C. de Souza, Steffen Eger, Diptesh Kanojia, Duarte Alves, Constantin Orăsan, Marina Fomicheva, André F. T. Martins, and Lucia Specia. 2022. Findings of the WMT 2022 shared task on quality estimation. In Proceedings of the Seventh Conference on Machine Translation (WMT), pages 69–99, Abu Dhabi, United Arab Emirates (Hybrid). Association for Computational Linguistics.