Many languages have some native text online but almost no labeled task data. Extractive question answering means reading a passage and pointing to the span that answers a question. For this task, one paired task sits waiting to be used. One model writes a question given a passage and an answer span, and a second model finds the answer span given a passage and a question. These are inverse problems. Coupled in a loop, each model's outputs can become training data for the other. This proposal tests whether that loop, started from a few hundred labeled examples and run over unlabeled native text, can replace the two shortcuts low-resource languages currently rely on: translating English datasets, and prompting large English-centric models.
The loop is kept from degrading by an anchor that needs no model confidence. Every answer must be a literal span of an authentic native passage, and a generated question is kept only if the answering model recovers that same span. Speech systems already use an equivalent guard. There, a garbled synthetic utterance cannot be transcribed back into its text, so it is filtered out. Text loops have lacked a structural check of this kind, and confidence scores are an unreliable substitute because multilingual models are poorly calibrated in low-resource languages (Investigating the Multilingual Calibration Effects of Language Model Instruction-Tuning).
Core Claim
The core claim is narrow and falsifiable. For extractive QA in a low-resource language, an iterated question-generation/question-answering loop filtered by span agreement on native passages beats a single pass of question generation plus the same filter, at equal compute and an equal number of accepted synthetic pairs. The size of that advantage should shrink as the typological distance between the seed language and the target grows. If the single pass matches the loop, the honest conclusion is that the anchor, not the iteration, does the work, and the proposal is designed to report that outcome cleanly.
Relation to Prior Work
Closed-loop dual learning in low-resource languages has so far stayed at the boundary between speech and text. LRSpeech pre-trains on Mandarin, fine-tunes on 3.7 minutes of Lithuanian, and alternates speech recognition and synthesis on unpaired data. It filters the results with structural metrics: word coverage and the diagonality of the attention alignment. Cross-Lingual Machine Speech Chain runs the same kind of loop from an Indonesian bridge model. It cuts character error on regional languages from 101.45% to 32.08%, but finds that Bataks, the language most distant from Indonesian, does worst. These two papers supply the method. Our span-agreement filter is the textual analogue of their alignment checks. The Bataks result also motivates our typology analysis.
Text-to-text dual loops exist only in English. CycleOIE couples a sentence-to-triple model with a triple-to-sentence model. It reaches 60.8 F1 on BenchIE from about 2k instances and controls drift only through low-entropy sampling (top_p 0.3–0.5). CYCLE-INSTRUCT bootstraps instruction tuning from raw documents and beats one-pass back-translation. Neither paper faces a target language the base model barely represents, and neither has a verifiable anchor of the kind passage spans provide. We borrow their loop structure and replace sampling heuristics with span verification.
The low-resource QA work we compete with is open-loop. MURI avoids translationese, the unnatural phrasing that machine-translated data carries. It infers instructions for native text through English pivots with Mixtral-8x7B, which still depends on translation quality for underrepresented languages. PQQ shows that synthetic questions hurt unless a correlation filter is applied, but it generates in one pass. MuCoT finds that translating across language families, for example from Dravidian to Indo-Aryan, harms Tamil and Hindi QA unless a contrastive loss is added. This is a constraint on our design: a loop seeded from the wrong family may amplify exactly that harm.
Research Program
We train a single multilingual sequence-to-sequence model with two task tags, question generation and answering. Sharing one model halves the extra cost that CycleOIE identifies in keeping two separate models. The model is first adapted by continued pre-training on native unlabeled text, which AfriInstruct found essential. It is then fine-tuned on a small seed of a few hundred gold QA pairs.
Each round of the loop works as follows. The model samples candidate answer spans from unlabeled native passages, generates a question for each span, answers its own question, and keeps the triple $(p, q, a)$ only if
$$ \mathrm{F1}\big(\mathrm{QA}(p, q),\, a\big) \ge \tau \quad \text{and} \quad a \subset p, $$
Here $p$ is an authentic passage, $a$ the sampled span, $q$ the generated question, and $\tau$ an overlap threshold tuned on the seed's held-out split.
The reverse direction runs in the same round. The model answers gold-seed-style questions on new passages, regenerates a question from its predicted span, and keeps the pair when the regenerated question's predicted answer agrees with the original prediction. Accepted triples from both directions train the next round. To prevent shortcut questions that simply copy the span's context, the model is also penalized for lexical overlap between the question and the answer sentence beyond a cap.
The analysis has two strands. The first tracks, across rounds, the acceptance rate, question diversity, and the share of accepted questions that the seed-only model fails on, since a loop should produce progressively harder valid questions. The second varies the seed language, comparing a seed in the target language, a seed in a same-family relative, and an English-only seed. This measures how typological distance affects convergence in a text loop, which so far has been observed only for speech.
Baselines
The naive reference is the same backbone, with the same continued pre-training, fine-tuned only on the gold seed. Every gain is measured against it.
The strongest existing reference on ChAII is MuCoT, which reports Jaccard 0.44 for Tamil and 0.59 for Hindi. We will reimplement its translation-plus-contrastive recipe on our backbone, using the same seed and the same unlabeled budget. We will also quote its published numbers. Beating it means exceeding its Jaccard in both languages under the reimplementation.
On AfriQA, the strongest reported system is the AfriInstruct 7B model at 45.35 F1, against 17.77 for zero-shot GPT-4o (AfriInstruct). AfriQA is cross-lingual open-retrieval QA, so our loop affects only the question-understanding side. We therefore treat it as a secondary transfer test with the same retriever held fixed, not as a like-for-like comparison.
The key ablation is a one-pass baseline. It generates all synthetic questions at once with the seed model, applies the identical span-agreement filter, and trains a single time. It receives the same GPU hours and the same final count of accepted pairs as the loop. Two further ablations bracket it. The first runs the loop with confidence-based filtering in place of span agreement, which isolates the anchor. The second runs the loop with no filter, which shows whether degeneration actually occurs. A MURI-style reverse-instruction pipeline through English, run on the same native passages, is the strongest open-loop alternative. No reported result was found on Lacuna for MURI on ChAII or AfriQA, so it will be run, not quoted.
Why not just…?
Why not just generate questions once and filter them with round-trip consistency? This is the real threat, and it is the main ablation. Evidence that iteration helps comes only from English text tasks (CYCLE-INSTRUCT; CycleOIE) and from speech. In low-resource languages the seed model may be too weak for later rounds to add anything beyond what the filter already gives. The compute-matched and count-matched comparison settles it, and we will report it as the headline result regardless of direction.
Why not just prompt a large multilingual model? On AfriQA, zero-shot GPT-4o reaches 17.77 F1 against 45.35 for an adapted 7B model (AfriInstruct). On PolicyQA, one-shot ChatGPT scores 20.8 EM against 58.9 for a filtered small model (PQQ). We will still include a few-shot prompted baseline on the evaluation sets.
Why not just translate SQuAD into the target language? Translated data carries translationese and cultural mismatch (MURI; AfriQA), and translating across families hurts Tamil specifically (MuCoT). Translate-train with the same backbone is therefore included, and we will also test it combined with our loop. If the combination beats either part alone, the two methods are complementary rather than rivals.
Proposed Experiments
Primary experiments use ChAII for Tamil and Hindi, measured by Jaccard. The seed size varies over 100, 300, and 1,000 gold pairs drawn from training data, and unlabeled native passages come from web text in each language. The secondary experiment builds AfriQA question-side training from WURA passages for its languages and reports F1 under a fixed retriever. The typology experiment seeds Tamil from Tamil, from a Dravidian relative where one is available, from Hindi, and from English, and does the same in reverse for Hindi.
Three outcomes are decisive. The first is whether the loop beats the one-pass filter by more than seed-resampling variance across five seeds. The second is whether span agreement beats confidence filtering, especially for Tamil, where calibration should be worst. The third is whether the loop's margin shrinks with seed-to-target distance, in the way the Bataks result predicts for speech (Cross-Lingual Machine Speech Chain). A useful paper results from any of these: a confirmed loop advantage, an anchor-only result showing iteration is unnecessary, or a mapped typological limit on when text dual learning can be trusted.
References
- Investigating the Multilingual Calibration Effects of Language Model Instruction-Tuning
- LRSpeech: Extremely Low-Resource Speech Synthesis and Recognition
- Cross-Lingual Machine Speech Chain for Javanese, Sundanese, Balinese, and Bataks Speech Recognition and Synthesis
- CycleOIE: A Low-Resource Training Framework For Open Information Extraction
- CYCLE-INSTRUCT: Fully Seed-Free Instruction Tuning via Dual Self-Training and Cycle Consistency
- MURI: High-Quality Instruction Tuning Datasets for Low-Resource Languages via Reverse Instructions
- Improving Low-resource Question Answering by Augmenting Question Information
- MuCoT: Multilingual Contrastive Training for Question-Answering in Low-resource Languages
- AfriInstruct: Instruction Tuning of African Languages for Diverse Tasks
- AfriQA: Cross-lingual Open-Retrieval Question Answering for African Languages