GanitLLM: Difficulty-Aware Bengali Mathematical Reasoning through Curriculum-GRPO

AI summary

Overview

• Research area: Natural Language Processing / multilingual and low-resource large language model reasoning, with a focus on Bengali mathematical problem solving and reinforcement learning from verifiable rewards.
• Technical level: Advanced. The paper assumes familiarity with LLMs, supervised fine-tuning (SFT), Group Relative Policy Optimization (GRPO), pass@k, LoRA, and chain-of-thought (CoT) prompting.
• Scope in one sentence: The paper builds a difficulty-tagged Bengali math dataset (Ganit), a two-stage training recipe (SFT followed by Curriculum-GRPO), and a Bengali reasoning model family (GanitLLM at 0.6B, 1.7B, and 4B parameters) that answers and reasons natively in Bengali rather than in English.

What This Paper Is About

Bengali is the seventh most spoken language worldwide, yet existing LLMs either solve Bengali math problems by reasoning in English and translating the answer, or fail on multi-step Bengali problems outright. The authors argue this happens partly because standard reinforcement learning recipes are tuned for high-resource languages and break down under reward sparsity when the target language is rare in pre-training. Their goal is a model that is simultaneously accurate, concise, and interpretable to Bengali-speaking end users such as students — reasoning in Bengali step by step rather than only returning a translated final answer.

Key Contributions

1. The Ganit dataset. A rigorously filtered, deduplicated, decontaminated, and difficulty-tagged Bengali math corpus with verifiable answers, built from approximately 1.5M collected Bengali math problems and split into a CoT-SFT training variant, an RLVR (reinforcement learning with verifiable rewards) variant, and a hold-out development set (Ganit-Dev).
2. Curriculum-GRPO. A modified curriculum-based data sampling strategy for GRPO that orders training examples by a fine-grained pseudo-difficulty signal (the number of correct generations out of 32, ranging 1–32) to address the cold-start problem in low-resource language training.
3. The GanitLLM model family. Described by the authors as the first Bengali mathematical reasoning model that reasons natively in Bengali, released at 0.6B, 1.7B, and 4B parameter scales, with claimed performance exceeding models twice their size and comparable to models four times larger while using 79.5% fewer tokens.
4. A cold-start characterization. A formal definition of the cold-start problem in GRPO (a rollout group where no sample earns reward, yielding zero gradients) plus training-step evidence showing Curriculum-GRPO converges 3.8× to 5.6× faster than vanilla GRPO.

Main Findings

• Accuracy gains on standard Bengali benchmarks. The abstract reports that GanitLLM-4B improves over its Qwen3-4B base by +8 points on Bn-MGSM and +6 points on Bn-MSVAMP. Table 3 reports the underlying scores as 69.20 to 76.80 on Bn-MGSM and 70.50 to 76.40 on Bn-MSVAMP.
• Language fidelity shift. Bengali reasoning characters rise from 14.79% for Qwen3-4B to 88.71% for GanitLLM-4B, while GanitLLM-0.6B reaches 88.70% and GanitLLM-1.7B reaches 87.80%.
• Conciseness. Average solution length drops from 943 words (Qwen3-4B) to 193 words (GanitLLM-4B), a 79.5% reduction. The model family produces 210 words at 1.7B and 248 words at 0.6B, versus 1124 and 1265 words for their respective bases.
• Small models closing gaps. GanitLLM-4B surpasses Qwen3-8B by 7.6 points on Bn-MGSM (76.80 vs. 75.12). GanitLLM-1.7B jumps from 15.20 to 52.80 on Bn-MGSM and from 14.10 to 66.80 on Bn-MSVAMP. GanitLLM-0.6B goes from 8.40 to 28.40 and from 12.20 to 52.40.
• Comparison with larger and proprietary models. On Bn-MGSM/Bn-MSVAMP, ganitLLM-4B (76.80/76.40) trails gpt-4.1 (89.20/82.30) and gpt-4.1-mini (87.20/78.60), roughly matches Qwen3-14B (83.60/75.80) and Qwen3-32B (85.60/76.10) on MSVAMP while trailing on MGSM, and far exceeds TigerLLM-9B (47.20/40.40).
• Both training stages are necessary. SFT alone grounds the language (Bengali characters 14.79% to 86.65% for the 4B model) with modest accuracy gains. Curriculum-GRPO alone achieves the highest raw accuracy in the ablation (82.40 on Bn-MGSM) but keeps Bengali at only 14.94% and expands output to 844 words. Only the sequential pipeline yields 88.71% Bengali with 193 words.
• Curriculum-GRPO matches GRPO accuracy with far fewer steps. For the 4B model, SFT+GRPO peaks at step 2300 versus step 600 for SFT+CGRPO (3.8× reduction); for 0.6B, step 7300 versus step 1300 (5.6× speedup). Accuracy differences are within roughly one point.
• The cold-start problem is dataset-dependent. Figure 3 shows that on the easier Bn-MGSM, vanilla GRPO eventually catches up after several hundred steps, whereas on the harder Bn-MSVAMP, vanilla GRPO stagnates while Curriculum-GRPO trends steadily upward.
• Qualitative Olympiad-level example. On one representative Olympiad problem, Qwen3-4B answers correctly but with 7.58% Bengali and 932 words; SFT alone reaches 97.63% Bengali and 645 words but produces the wrong answer; Curriculum-GRPO alone reaches 7.32% Bengali with 2223 words; the full pipeline produces a correct answer at 97.7% Bengali and 467 words.
• Code-switching is minimal. Across 1,236 GanitLLM-4B generations (101,869 tokens), only 115 tokens (0.11%) are actual English words, averaging 0.014 code-switches per sentence. Non-Bengali content is dominated by math notation (47.55%), numerals (34.17%), Markdown/formatting (11.20%), and units/compounds (5.32%); the top English words are "of, gb, time, dvd, tv."
• An appendix nuance. In the Appendix B table, GanitLLM-4B records a lower composite average accuracy (62.56) than base Qwen3-4B (66.08), driven by lower Ganit-Dev sub-scores on the trained model (Easy 51.49, Medium 53.76, Hard 47.88, Olympiad results not reported in the visible table row), even though MGSM and MSVAMP are higher. The main text does not comment on this discrepancy in the retrieved content.

Methodology in Plain English

Building the data. The authors started with roughly 1.5M publicly available Bengali math problems drawn from human-authored, human-translated, LLM-translated, and Google-translated sources. Two human evaluators sampled 100 problems from each source and scored them; only sources with human evaluation above 95% (the top five rows of their Table 1: mCoT-MATH-bn, NuminaMath-CoT-bn, s1k-Bangla, DL Sprint 3.0, and SOMADHAN) were kept, cutting the pool from about 1.5M to about 1.1M instances. They then kept only solutions with numerical answers (so rewards can be verified automatically), only problems that are at least 99% Bengali characters, and excluded multiple-choice items. Deduplication used normalized Levenshtein distance (3-gram, 70% threshold) followed by MinHash (200 hash size, 50% threshold). Contamination against the MGSM and MSVAMP test sets was removed with MinHash at a 50% similarity threshold.

Tagging difficulty. They evaluated eight open-source models from 8B to 72B on Bn-MGSM and Bn-MSVAMP and picked Qwen3-32B as the strongest. Qwen3-32B generated 32 independent solutions per problem at temperature 0.7. Problems the model never solved were discarded, and the remaining problems were bucketed by how many of the 32 attempts succeeded: Olympiad (1–8), Hard (9–16), Medium (17–24), and Easy (25–32).

Building the development set. They applied the same tagging to Bn-MGSM and Bn-MSVAMP and found those benchmarks are skewed easy (for Bn-MGSM, 77.50% Easy, 16.40% Medium, 3.60% Hard, 2.50% Olympiad; for Bn-MSVAMP, 86.00/8.40/3.20/2.40). Ganit-Dev was therefore sampled as 30 problems from each of the 32 fine-grained difficulty buckets, giving 960 examples, with a more balanced profile (28.74% Easy, 26.03% Medium, 24.31% Hard, 21.26% Olympiad). Each retained problem had to be solved correctly by GPT-5-mini, Gemini-2.5-Flash, and Grok-4-Fast, each prompted three times with majority voting at two out of three.

Training. Stage one is supervised fine-tuning (full fine-tuning, 50 epochs) on the CoT-SFT split to teach Bengali reasoning. Stage two is GRPO (LoRA-based, 5 epochs) on the RLVR split. The reward is the sum of three verifiable terms totaling between 0 and 4: format (0 or 1), correctness (0, 1, or 2, with a bonus for Bengali answers), and Bengali reasoning (0 or 1, granted when at least 80% of reasoning characters are Bengali). The 80% threshold is deliberately below 100% so that language-agnostic math notation has room, and punctuation is stripped before counting. An overlength filter and token-level loss are also incorporated, following Yu et al. (2025).

The curriculum. Instead of shuffling data randomly, Curriculum-GRPO groups examples by exact difficulty (1–32 correct generations) and, for each bucket, takes 60% of examples from that bucket (136 instances) and 40% spread evenly across the other 31 buckets (3 each, 93 total), for 229 examples per bucket. Buckets are then ordered from easy to hard. The authors report that an 80/20 split caused catastrophic forgetting of easier problems while 50/50 diluted the curriculum signal.

Evaluation. Base models were Qwen3-0.6B, Qwen3-1.7B, and Qwen3-4B; baselines were the wider Qwen3 family (0.6B to 32B), gpt-4.1, gpt-4.1-mini, and TigerLLM-9B. All training and inference ran on 2×A100 GPUs. Evaluation used temperature 0.0 for determinism and the same prompt across all models. Because English and Bengali tokenize very differently, the authors report word counts rather than token counts, and compute the Bengali percentage as the fraction of non-whitespace reasoning characters in the Bengali Unicode block (U+0980–U+09FF).

Why This Matters

Impact on research. The paper reframes multilingual math evaluation: prior Bengali work largely measured only final accuracy, whereas this work treats where the reasoning happens as a first-class metric. It also names and formalizes a concrete failure mode — the GRPO cold-start problem, where an entire rollout group earns zero reward and therefore zero gradient — and shows a data-ordering fix that cuts convergence steps by 3.8× to 5.6× without sacrificing accuracy. The paper notes that the number of Bengali tokens in pre-training is roughly 15 times lower than Chinese (0.026% vs. 0.4%), which frames Bengali as a harder case than the Chinese-language RL results it builds on.

Real-world applications:

• Bengali-language educational tutoring tools that show students step-by-step solutions in their own language, which they can read and learn from.
• Deployment on modest hardware: the 0.6B, 1.7B, and 4B models are aimed at low-resource and developing-country settings where large proprietary models are impractical.
• Automatic generation of Bengali-language math practice material with verifiable numeric answers.
• Bengali-language assessment and benchmarking for schools or ministries evaluating LLMs in local-language instruction.

Industry relevance. The recipe targets small, cheap models rather than frontier-scale ones, which matters for cost-sensitive deployment. The three-part verifiable reward structure (format, correctness, language fidelity) is a reusable pattern for any company trying to keep an LLM's reasoning in a target language, and the curriculum sampling approach is a general-purpose training-efficiency technique that could reduce compute bills for RL fine-tuning

Authors’ abstract

We present a Bengali mathematical reasoning model called GanitLLM (named after the Bangla word for mathematics, Ganit), together with a new difficulty-aware Bengali math corpus and a curriculum-based GRPO pipeline. Bengali is one of the world's most widely spoken languages, yet existing LLMs either reason in English and then translate, or simply fail on multi-step Bengali math, in part because reinforcement learning recipes are tuned for high-resource languages and collapse under reward sparsity in low-resource settings. To address this, we construct Ganit, a rigorously filtered and decontaminated Bengali math dataset with automatic difficulty tags derived from the pass@k of a strong evaluator model. Building on this dataset, we propose Curriculum-GRPO, which combines multi-stage training (SFT + GRPO) with difficulty-aware sampling and verifiable rewards for format, numerical correctness, and Bengali reasoning. On Bn-MGSM and Bn-MSVAMP, GanitLLM-4B improves over its Qwen3-4B base by +8 and +6 accuracy points, respectively, while increasing the percentage of Bengali reasoning tokens from 14% to over 88% and reducing average solution length from 943 to 193 words. Project page is available at https://dipta007.github.io/GanitLLM