Papers for

machine translation teams

Papers whose findings have a practical use for this group, as judged from the abstract. Open a paper to read what it means in practice.

Multilingual instruction tuning boosts open-ended question answering accuracy

Task-Preserving Multilingual Instruction Tuning for Open-Ended QA in WMT 2026 MIST

Abstract: This paper describes our submission to the WMT 2026 Multilingual Instruction Shared Task. We adapt Qwen3-8B with LoRA using organiser-provided data, EuroAlpaca, a multilingual instruction dataset created through task-preserving localisation, and CrossEuroAlpaca, a cross-lingual augmentation that assigns different source and target languages to instructions, contexts and responses. Our system targets open-ended question answering (QA-OEG) in ten shared-task languages represented in the auxiliary data. Under matched decoding, adaptation improves the mean Gemma-4 judge score on target-language QA-OEG by 7.8% relative to the base model. On an additional evaluation using the Aya Evaluation Suite across all shared-task languages, it yields relative gains of 41.5% in macro-averaged ROUGE-L and 2.9% in BERTScore-F1, with larger improvements in target languages. However, these gains are task- and language-specific. Gemma-4 scores improve for QA-OEG and summarisation in the target languages but decline for context-grounded QA there and across all three tasks in the non-target languages.

Wed 21 OctComputation and Language
The gist
Open-ended question answering in many languages is challenging because models often struggle to perform well across different tasks and languages. This paper describes how the authors improved a language model by fine-tuning it with special multilingual instruction data that keeps the tasks consistent while adapting to different languages. Their approach showed better performance on questions and summarization for certain languages, but less so on others and on different types of question tasks. This shows that improving models across many languages and tasks requires careful data design.
Open → 2610.29926v1

Diffusion language models change speed based on task and language

Diffusion Language Models Change Speed Across Tasks and Languages

Abstract: Diffusion language models can write several tokens in one forward pass, and they decide during generation how many passes to spend. Two outputs of the same token length can therefore vary a lot in cost. To understand the underlying factors of this cost variation, we analyze two diffusion models across 10 tasks. We find that the number of forward passes per token depends heavily on the task. Text copied or lightly edited from the input is cheap, while open-ended writing is costly. In DiffusionGemma, generating a token for story writing requires more than three times as many forward passes as for grammar correction. Two output properties explain much of this gap: how much of it is new relative to the input, and how rare its words are within the task. The same holds within a single response when thinking is involved. The final answer is cheap when it repeats the model's reasoning trace and costly when it adds something new. In multilingual generation, we find that highly tokenized languages also require more passes per token, adding to the cost they already pay with more tokens. Finally, cost tracks correctness: on the same math problem, wrong answers take more passes per token than correct ones, and weighting candidate answers by decoding speed beats majority voting by up to 4.2 points at no extra cost. Taken together, our results show that diffusion's computational advantage depends on how much of the output is already determined, while its decoding effort offers a practical signal for making inference more efficient and reliable.

Mon 19 OctComputation and LanguageArtificial IntelligenceMachine Learning
The gist
Diffusion language models generate text in multiple steps, and the number of steps they need varies a lot depending on what kind of task they are doing and the language they use. The authors found that copying or lightly changing input text is faster, while creative writing takes more steps. They also saw that languages broken into many small parts need more steps per word. Interestingly, answers to problems that are correct take fewer steps than wrong ones. This means how long the model works can help judge its output.
Open → 2610.25835v1

Small language models struggle to efficiently read Indian scripts

Efficiency Measured in English: Tokeniser Coverage Bounds Small Language Models on Indic Scripts

Abstract: Small Language Models with quantisation and parameter-efficient adaptation are widely offered as the route to multilingual AI under compute constraints, and their efficiency is almost always reported as a single memory figure. We show that this figure is measured in English and does not transfer. Across a 131k-sentence corpus spanning eleven Indic scripts, TinyLlama-1.1B's tokeniser emits 1.34 subword tokens per Latin-script word and 22.60 per Kannada word. This is not inefficiency; it is absence. Its vocabulary contains 0% of Odia's codepoints, 1% of Telugu's and 2% of Kannada's, and for five of eleven scripts the measured fertility sits at the UTF-8 byte-fallback ceiling, on Odia at 99.6% of it, with 93.6% of emitted tokens being raw bytes. Because SentencePiece byte fallback never raises an unknown-token marker, this failure is entirely silent: TinyLlama's UNK rate is 0.0% on every script, including the one it reads as bytes. We further show that low fertility can indicate the opposite of efficiency: mBERT posts its best score anywhere (1.10 tokens/word, on Odia) while discarding 87.9% of the text as UNK. MuRIL, an Indic-vocabulary encoder with a fifth of TinyLlama's parameters, reads every script at 1.23-2.26 tokens/word with zero UNK and zero byte fallback. The binding constraint is the vocabulary, not the parameter count. The consequence is concrete: on a 2048-token context window, the same model gives an English user 1,528 words of usable context and a Kannada user 91.

Sat 17 OctComputation and LanguageComputers and SocietyMachine Learning
The gist
Small AI language models often report their memory use based on English, but this doesn't work for Indian scripts. The researchers found that a small model, TinyLlama, breaks Indian words into many more tokens than English words, not because it's inefficient but because its vocabulary lacks those scripts. This means the model silently falls back to reading raw bytes without showing errors, reducing effective language understanding. Other models with better vocabularies for Indian scripts perform more efficiently, showing vocabulary choice limits performance more than model size.
Open → 2610.24818v1

LoopAhead speeds up Transformer text generation by looking ahead

LoopAhead: Speculating Ahead for Faster Decoding in Looped Language Models

Abstract: Looped Transformers improve parameter efficiency by repeatedly applying the same Transformer layers. However, generating each token still involves sequential computation and repeated access to model weights, leading to high decoding latency. Recent pipelined self-speculative decoding methods reduce this delay by drafting tokens from early-loop predictions and asynchronously advancing tokens at different recurrent depths in the same batch, but they do not fully exploit early-loop features for longer lookahead and still spend computation verifying incorrect speculative branches. We introduce \method, a speculative decoding framework for looped transformers that enables earlier drafting of future tokens and assigns complementary roles to different recurrent depths. A lightweight lookahead drafter (LAD) predicts multiple future tokens with early-loop states, and deeper-loop feedback helps decide which draft branches to continue and which to pause, while the full-depth model makes the final token decisions. LoopAhead achieves up to 7.82x decoding speedup over autoregressive decoding while preserving the target model's output distribution.

Thu 15 OctArtificial IntelligenceMachine Learning
The gist
Generating text with advanced language models can be slow because each word must be predicted one after another. The authors introduce LoopAhead, a method that helps the model guess several future words early in the process and then checks these guesses more efficiently. This way, the prediction happens faster without changing the quality of the generated text. LoopAhead uses different parts of the model in a coordinated way to speed up text generation by up to nearly 8 times.
Open → 2610.21594v1

Vision language models with images improve manga translation checks

Text-Only vs. Image-Aware VLM Judges for Manga Translation Evaluation

Abstract: In manga translation, visual context outside speech-bubble text, including speaker identities, referents, and scene tone, is depicted in page images, making it natural to refer to images during translation evaluation. However, most conventional manga translation evaluations rely solely on text-only automatic metrics, leaving the impact of image input insufficiently explored. We propose a practical validation framework that employs the same vision-language model (VLM) as both a text-only judge (TOJ) and an image-aware judge (IAJ) to investigate evaluation divergences associated with image-aware evaluation procedures. We use a Japanese-English manga dataset of official translations aligned at the page and speech-bubble levels. First, adding page images to TOJ improved the primary VLM's detection of deliberately injected, visually dependent degradations. Second, we analyzed evaluation divergences between TOJ and IAJ, finding different error counts and error-category distributions. Human verification did not reveal a consistent preference between TOJ and IAJ.

Tue 13 OctComputation and LanguageComputer Vision and Pattern Recognition
The gist
Evaluating manga translations can be tricky because the meaning depends on both the text and the surrounding pictures. The authors compared two ways to check translations using AI models: one that looks at just the text and one that also considers the images. They found that including images helps the AI detect some errors better, but human reviewers didn’t always prefer one method over the other. This suggests images add useful context, but both methods have strengths.
Open → 2610.17908v1

Fusion Organ network cut transformer memory use with equal accuracy

FON: A Draft-Revise Dual-Organ Language Model without Sequence-Level Quadratic Attention

Abstract: Self-attention assigns two functions to one mechanism-where to read and how to mix-at the price of O(L^2) training, an O(T) decode state, and position signals bound to the training length. Existing attention-free alternatives all optimize the single function of generation. We propose FON (Fusion-Organ Network), which differentiates one weight stack into a drafting organ (multi-tap learnable delays + content-adaptive recursion; causal, O(S) training, O(1) decode state, no sequence-level quadratic attention) and a revision organ that re-processes the written prefix through multi-scale ripple kernels injected via weak gates, never generating. At 30M parameters, iso-parameter and iso-token budget, FON reaches perplexity 131.03 on WikiText-103, beating Transformer (197.73) and Mamba2 (152.53); the advantage persists under all depth-aligned baselines and at the 70M tier (-20.8%). At 8x length extrapolation FON degrades by ~8-9% without positional-encoding engineering, between ALiBi and RoPE. The revision channel provides a structural pathway for in-domain infilling that causal architectures lack in principle (+19% over on-demand coupling), at a perplexity cost indistinguishable within measurement precision. We report all costs and boundaries: impaired long-range retrieval, synthetic-task disadvantages, weaker out-of-domain code infilling than a same-recipe Transformer, and a 6.5-12.3x wall-clock gap.

Mon 12 OctArtificial Intelligence
The gist
Reading and mixing all parts of a long text in language models is usually slow because they compare every part with every other part, which takes a lot of work. The authors created a new model called FON that splits this task into two parts: one quickly drafts text based on recent information without heavy calculations, and another revises the draft by reviewing what’s written so far without producing new text directly. This approach uses less memory and runs faster while keeping accuracy better than many earlier models, especially on very long texts. However, it does have some weaknesses like slower real-time speed and less effective handling of certain code-related tasks compared to traditional models.
Open → 2610.16301v1

Timestep placement boosts quality and speed in diffusion language models

A Step in the Right Place: Understanding and Optimizing Timestep Placement in Continuous Diffusion Language Models

Abstract: Continuous diffusion language models represent an emerging paradigm for language modeling. They generate text in parallel by iteratively refining continuous representations and mapping them back to tokens through a decoder. However, realizing the efficiency advantage of parallel generation requires maintaining generation quality with only a few denoising steps. Even when the number of steps is fixed, their placement along the denoising trajectory remains flexible. In this paper, we demonstrate that changing timestep placement alone can substantially alter the final latent representations and thereby affect the decoded token distributions. Building on these findings, we introduce StepTune, an algorithm that searches for timestep placements that improve generation quality. The search is conducted on a small calibration set and guided by a language-aware objective, with the model and sampling budget fixed. Once calibrated, the timestep placement is fixed and reused across inputs. Experiments demonstrate consistent improvements in unconditional generation perplexity and conditional task metrics across all evaluated sampling budgets. In particular, StepTune enables 16-step sampling with a frozen model to outperform its native 64-step baseline on both XSum summarization and WMT14 translation and reduces end-to-end latency by approximately $3.8\times$. These results establish timestep placement as a practical means of improving the quality-efficiency trade-off in continuous diffusion language models.

Sun 11 OctComputation and Language
The gist
Generating text quickly with continuous diffusion language models often requires a careful balance between quality and speed. The authors found that changing where the model takes steps during the text generation process can improve the final output. They created a method called StepTune that finds better step placements, making the model produce good text using fewer steps. This means the model can generate text faster without losing quality, as shown in tasks like translation and summarization.
Open → 2610.15527v1

Efficient long text generation using compressed diffusion blocks

Denoising Blocks, Not Tokens: Efficient Compressed Continuous Diffusion with Branching Token Realization

Abstract: Diffusion language models (DLMs) generate text through iterative parallel refinement, offering the potential for higher throughput than autoregressive (AR) decoding. However, most DLMs still maintain one generative state per token, so every denoising step processes a state sequence as long as the output sequence, limiting the throughput gains from parallel generation. Continuous DLMs provide an additional degree of freedom: a single continuous state can represent multiple tokens, allowing diffusion to operate on a much shorter latent sequence. We introduce \emph{Branching Latent Diffusion (BLD)}, which exploits this flexibility by compressing a 1024-token sequence into only 64 block latents, a $16\times$ reduction. BLD combines latent compression with \emph{branching token realization}, where each latent is decoded by a local AR branch and all branches run in parallel. Because strong compression makes joint latent generation difficult, BLD generates the latents in groups, conditioning each group on previously generated latents. In end-to-end evaluation on the same GPU, BLD reduces generation FLOPs by more than $80\times$ and increases throughput by more than $6\times$ relative to the similarly sized ELF-L baseline. Compared with the AR baseline, BLD achieves more than $6\times$ higher throughput and more than $4\times$ lower latency. Despite the compression, BLD maintains competitive local fluency and diversity, although long-range coherence remains challenging. Overall, BLD shows that moving diffusion from token-level states to compressed latent sequences can substantially improve the efficiency of long-sequence generation.

Wed 7 OctMachine LearningArtificial Intelligence
The gist
Generating long text quickly is challenging because typical methods handle each word one by one. The authors introduce a new approach that groups multiple words into blocks and processes these blocks together, greatly speeding up text generation. They use a technique called Branching Latent Diffusion to compress long sequences into fewer parts, then decode each part independently and in parallel. This method significantly improves speed and reduces computing effort while keeping the text quality reasonably good for local details, though maintaining overall story coherence remains hard.
Open → 2610.09311v1

Arabic syntax ambiguity resolution improved with neuro symbolic model

A generative-informed neuro-symbolic framework for syntactic ambiguity resolution: Evidence from Arabic DPs

Abstract: Syntactic ambiguity poses a persistent challenge for Arabic NLP, particularly in morphologically rich nominal constructions where multiple structu6ral interpretations may be compatible with the same surface sequence. This study proposes a generatively informed neuro-symbolic framework for resolving structural ambiguity in Modern Standard Arabic (MSA) DPs. The framework integrates generative syntactic notions with AraBERT by representing ambiguity as a candidate-based decision task in which linguistically motivated alternatives are explicitly constructed and evaluated through candidate-conditioned input representations. Findings indicate that the model achieved 96.88% accuracy, 95.92% macro-F1, 96.83% weighted F1, and 93.94% binary F1 on the unseen evaluation set. Class-level analysis revealed asymmetric performance, with recall of 99.71% for High/VP Attachment (N1) and 89.26% for Low/NP/Embedded Attachment (N2), indicating greater difficulty in recovering the embedded interpretation. The study concludes that formal syntactic representations can be operationalized within Transformer-based NLP as an explicit interface between linguistic structure and contextual neural modeling, providing a controlled and interpretable approach to Arabic syntactic ambiguity resolution and beyond.

Thu 1 OctComputation and Language
The gist
Figuring out the exact structure of sentences in Arabic can be tricky because the same words can fit multiple meanings. The authors created a new computer method that combines traditional grammar ideas with a powerful language AI called AraBERT to decide between different possible sentence structures. Their approach builds clear options and lets the AI choose the best one, making it easier to understand complex Arabic phrases. The method worked well, correctly interpreting most cases, though some tricky sentence forms were harder to get right. This shows that mixing grammar rules with AI can help computers better understand Arabic language ambiguities.
Open → 2610.02529v1

Word similarity datasets created for six major Indian languages

Word Similarity Datasets for Indian Languages: Annotation and Baseline Systems

Abstract: With the advent of word representations, word similarity tasks are becoming increasing popular as an evaluation metric for the quality of the representations. In this paper, we present manually annotated monolingual word similarity datasets of six Indian languages - Urdu, Telugu, Marathi, Punjabi, Tamil and Gujarati. These languages are most spoken Indian languages worldwide after Hindi and Bengali. For the construction of these datasets, our approach relies on translation and re-annotation of word similarity datasets of English. We also present baseline scores for word representation models using state-of-the-art techniques for Urdu, Telugu and Marathi by evaluating them on newly created word similarity datasets.

Mon 28 SeptComputation and LanguageMachine Learning
The gist
Word similarity tasks help computers understand how related different words are, which improves language technologies. The authors built new word similarity datasets for six widely spoken Indian languages by translating and adjusting English datasets. They also tested some modern computer language models using these datasets and shared baseline results. This work provides new tools for better language understanding in these Indian languages.
Open → 2609.34138v1

French language model reveals tokenizer impact on grammar tests

Right Tool, Right Job: Native-Language Evaluation, Tokenizer Sensitivity, and Methodological Findings from a French-Only BabyLM

Abstract: We submit MéTRON-FR, a 125M GPT-2 pretrained on 92.47M words of French, to the BabyLM 2026 Strict track. It scores 85.97 +/- 0.17% on QFrBLiMP (a native Quebec-French benchmark of grammatical minimal pairs) and 62.80% on the BabyLM-weighted leaderboard. A cross-lingual GLUE (General Language Understanding Evaluation) protocol that combines French task-data translation with rank-16 LoRA (Low-Rank Adaptation) produces a sharp task-type gradient: relational tasks gain measurably, while world-knowledge tasks regress. Bilingual Lexicon Induction aligns the French embeddings to GPT-2 at p@1 = 68.84 +/- 8.61%, 18X above chance, suggesting cross-lingual alignment tracks acquired grammatical competence rather than training duration. An ablation study shows that single-token zero-shot scoring is dominated by tokenizer and template artifacts at the child scale, motivating tokenizer-swap sensitivity, placebo-controlled prompting, and native-language minimal-pair benchmarks as standard diagnostics.

Tue 15 SeptComputation and Language
The gist
Training a French-only language model, the authors found it performs well on native French grammar tests and some language tasks. They noticed some tasks improve while others get worse when combining French data with adaptations from English models. The study highlights that how words are split into pieces (tokenizer) can strongly affect scoring in tests, especially for small-scale models. They suggest better evaluation methods for such language models using native language tests and careful testing procedures.
Open → 2609.17435v1

StalePO improves machine translation quality using old edits

StalePO: Anchored Token-Level Preference Optimization using Legacy Post-Edits in Machine Translation

Abstract: Machine translation systems are periodically upgraded to stronger models, but the available preference signal is human post-edits of an older system's outputs, which the newer model may already surpass. Moreover, collecting fresh post-edits for every new model is prohibitively expensive. We call this the Stale Preference problem. Standard DPO can fail in this setting: it may increase the likelihood of inferior post-edits, erode the model's existing quality, and fail to provide the per-token control needed to correct localized errors. We introduce StalePO, an objective derived from three requirements this regime imposes. Likelihood movement must be downward on both responses, the policy must be anchored to its own base response, and the KL constraint must apply at the token level. These requirements are jointly necessary. In ablations, each mechanism in isolation leaves the model's performance indistinguishable from the base model, and only their combination converts stale feedback into gains. On English-to-Hindi and English-to-Turkish localization data, StalePO improves the fraction of segments passing all LLM-as-judge MQM quality checks by 14.9 and 4.6 percentage points, respectively, with gains concentrated on style and fluency. A human evaluation under the same framework confirms these gains on English-to-Hindi, raising the fraction of segments passing all seven human checks by 13.8 percentage points.

Mon 14 SeptComputation and LanguageMachine Learning
The gist
Machine translation systems often update to better models, but only have old human corrections from earlier systems to learn from, which may be outdated or worse than new outputs. The authors address this ‘Stale Preference’ problem by creating a method called StalePO that carefully adjusts the new model using these old edits without degrading its overall quality. Their approach controls changes at the word level and anchors the model’s outputs to avoid making things worse. Tests on English-to-Hindi and English-to-Turkish translations show StalePO improves style and fluency, confirmed by both AI and human quality checks.
Open → 2609.16340v1

Enemray improves Hassaniya language understanding and translation accuracy

Enemray: Toward Capable Language Models for Hassaniya

Abstract: We introduce Enemray, a Hassaniya-centric language model that enables general-purpose interaction in Hassaniya. Enemray is trained around a stability--plasticity objective: acquire strong Hassaniya linguistic and cultural competence while preserving the general reasoning, multilingual, instruction-following, and safety behaviors of a capable instruction-tuned model. The development pipeline separates language acquisition from behavioral specialization. A separately assembled continual-pretraining corpus provides broad exposure to natural Hassaniya and Mauritanian text; layer-selective continual pretraining learns a compact language-specific parameter update; that update is transferred into the instruction-tuned parameter space; and supervised post-training develops conversational, cultural, literary, task-oriented, and cross-lingual behavior. The supervised corpus integrates selected public Hassaniya and Mauritanian resources with a substantially larger body of newly collected, reconstructed, curated, and constructed instruction data, while policy-generated replay provides a retention signal from the reference model's own behavior distribution. The resulting collection is substantially larger and broader in purpose than existing Hassaniya text resources. In evaluation, Enemray achieves the strongest English to Hassaniya translation among the compared open and proprietary models and the highest overall score on Mauritanian translation error detection, while retaining most of the general capabilities of its instruction-tuned base model on mathematical reasoning, knowledge, code generation, and function calling. This report describes the motivation, data construction, model design, training methodology, and evaluation of Enemray.

Sun 13 SeptComputation and LanguageArtificial Intelligence
The gist
Hassaniya is a language spoken in Mauritania with limited digital language tools available. The authors created Enemray, a language model specially trained to understand and use Hassaniya well, while keeping the skills of a general advanced AI model. They carefully collected and assembled various types of Hassaniya text data and used a training process that balances learning new language skills with keeping general AI abilities. Enemray performs better than other models in translating English to Hassaniya and detecting translation errors involving Mauritanian language content, while still handling tasks like math and code well.
Open → 2609.14829v1

Carryover drafting boosts speed and token acceptance in large language models

Carryover Drafting: Recycling Rejected States for Speculative Decoding

Abstract: Speculative decoding accelerates LLM inference by verifying multiple drafted tokens in parallel, allowing a single target forward pass to accept several tokens. By construction, verification computes representations for both accepted and rejected tokens. Yet, conventional drafters retain only the representations of accepted tokens, leaving the substantial verifier computation spent on rejected tokens effectively wasted. We find that these discarded hidden states generated during target forward retain useful information about future tokens that can improve subsequent drafts. However, realizing this opportunity poses two distinct challenges. At inference, recycling overhead can increase drafting latency, diminishing the speedup gained from increased acceptance length. During training, standard parallel drafter training does not produce inference-aligned rejected states, while obtaining them through sequential rollouts would sacrifice parallelism across training positions. We introduce Carryover Drafting, which addresses both challenges. Carryover recycles rejected target hidden states as temporary KV context, allowing the drafter to selectively attend to them. It reuses the drafter's existing interface and adds only a single learned embedding to distinguish rejected states from committed context. The additional KV context is replaced each drafting round, keeping its length bounded by one proposal block. We introduce parallel draft--verify--draft training that exposes the drafter to inference-aligned rejected states while preserving parallelism across training positions. Experiments with DFlash and a DSpark-derived semi-autoregressive drafter across two target models show that this simple Carryover mechanism improves average acceptance length by 6.5--14.7% and end-to-end vLLM speedup by 7.9--14.4% over the corresponding baselines, with speedup gains reaching 28.8% on translation.

Sun 13 SeptMachine LearningArtificial Intelligence
The gist
Large language models can generate text faster by guessing multiple words at once and checking which guesses are good. Usually, when guesses are rejected, the work done to check them is thrown away. The authors found that keeping some information from these rejected guesses helps make better future guesses and speeds up the whole process. They created a new method called Carryover Drafting to reuse this information efficiently without slowing things down. Their experiments show it improves speed and quality of results in language tasks like translation.
Open → 2609.14717v1

Span level supervision improves multilingual token and sentence representations

Improving Cross-Lingual Token Representations by Adding a Pinch of SALT

Abstract: Cross-lingual sentence encoders enable scalable transfer across hundreds of languages, powering applications such as translation mining and zero-shot learning in low-resource settings. Although trained for sentence-level alignment, they are increasingly also applied to token-level tasks such as hallucination detection and sequence tagging, exposing a mismatch between training and usage. We propose SALT, a lightweight post-training method that improves token representations by injecting span-level supervision into existing sentence encoders. Across five multilingual token-level benchmarks, SALT achieves the best overall results on four of them, outperforming alternative fine-tuning strategies and competitive encoders. It also improves sentence-level performance on cross-lingual retrieval and classification tasks. These results demonstrate that span-level supervision is an effective signal for improving both token and sentence representations.

Wed 9 SeptComputation and LanguageArtificial Intelligence
The gist
Many language processing tools are trained to understand whole sentences in many languages but are later used to analyze smaller parts like individual words or phrases, which can be tricky. The authors show a simple way called SALT that adds extra training focused on chunks of text within sentences to make the tools better at these smaller pieces. This leads to improved performance not only for word-level tasks but also for whole sentence tasks across multiple languages. Their approach works better than other fine-tuning methods on different language benchmarks.
Open → 2609.09953v1

Multilingual language models struggle with consistent factual error rejection

SWORD: Wikidata-based Distortions Reveal Hidden Cross-Lingual Inconsistencies in LLM Factual Error Rejection

Abstract: Modern LLMs demonstrate impressive multilingual performance, yet standard benchmarks primarily reward selecting correct answers rather than evaluating genuine factual understanding. We introduce Systematic Wikidata-based Object-Relation Distortion (SWORD), a benchmark that evaluates whether models consistently reject factual errors across languages. SWORD generates syntactically well-formed but factually incorrect statements in eight widely spoken languages through controlled perturbations of Wikidata triples, ranging from random entity substitutions to semantically plausible property-based selections. Our distortion-based evaluation surfaces two critical insights that remain entirely obscured by conventional benchmarks. First, models counterintuitively achieve higher accuracy on semantically plausible distortions than on nonsensical random substitutions, suggesting reliance on distributional familiarity rather than genuine factual verification. Second, models exhibiting comparable baseline accuracy across languages show substantial performance degradation specifically on (East) Asian languages when presented with distorted statements, with cross-lingual performance gaps reaching up to 28 percentage points (49\% relative reduction) in some models. These findings demonstrate that multilingual factual reasoning involves asymmetric capabilities that aggregate accuracy metrics systematically obscure.

Tue 8 SeptComputation and Language
The gist
Large language models (LLMs) perform well in many languages but are usually tested only on picking correct answers, not really understanding facts. The authors created SWORD, a new test that checks if models can spot wrong facts in eight languages by changing Wikidata facts in tricky ways. They found that models often rely on familiar word patterns instead of true fact-checking, sometimes doing worse with Asian languages when facts are distorted. This shows that even if models seem good overall, they can have hidden weaknesses depending on the language and type of mistake.
Open → 2609.09349v1

Automatic translation metrics struggle with social media culture

When Metrics Reward the Worst Translations: Internalizing Cultural Reasoning for Social Media Translation Evaluation

Abstract: Automatic translation quality metrics trained on general-domain corpora systematically fail on social media content, where communicative intent is encoded in culturally loaded expressions (internet slang, homophonic ciphers, and platform-specific idioms) rather than surface token patterns. We conduct a systematic empirical analysis demonstrating that standard metrics including COMET, XCOMET, and BERTScore exhibit near-zero or negative correlation with human cultural judgments, and even display a severity inversion in which scores increase as translation quality deteriorates. We further show that this failure extends to large language model judges: Qwen3-235B achieves Cohen's kappa of only 0.162, revealing that the bottleneck is not reasoning capacity but cultural grounding: models lack the domain-specific cultural knowledge needed to identify which aspects of a translation require scrutiny. To address this, we propose CuRIL, a reinforcement learning framework that internalizes cultural reasoning: cultural annotations are prepended inside the model's reasoning, excluded from policy gradients via a token-level loss mask, and injected with a probability that decays to zero over training, progressively forcing autonomous cultural judgment. On a 1,444-sample human-annotated social media translation benchmark, Qwen3-8B trained with CuRIL achieves Cohen's kappa 0.370 and Exact Match accuracy of 45.22%, approaching Gemini-3.1-Pro with 30x fewer parameters and surpassing models up to 235B in scale. We further demonstrate that our judge produces reliable reward signals for downstream translation optimization, reducing the low-quality translation rate by over 20 percentage points under independent human evaluation.

Tue 8 SeptComputation and Language
The gist
Current automatic tools that check translation quality don’t work well for social media posts because these posts use lots of slang, jokes, and cultural references. The authors found that popular metrics often give worse translations higher scores, which is misleading. They created a new training method called CuRIL that helps a smaller AI model understand cultural context better, improving its ability to judge social media translations more like humans. Their improved system helps reduce poor translations significantly when used to guide translation improvements.
Open → 2609.08156v1