acceptodds
Under review as a conference paper at ICLR 2027

Universal Braille-to-Text Translation

Abstract

For visually impaired readers, text is transcribed into braille under a transcription code, a set of rules specific to a language and a standard, and every code writes into the same 256 Unicode braille codepoints. Given the code, transcription is deterministic, but its inverse is not: several texts can produce the same cells, and the cells do not mark which of hundreds of codes produced them. This inverse, braille-to-text translation, is how transcriptions are proofread and how documents that survive only in braille are recovered. Existing systems require the code, most are built one code at a time, and even the widely used rule-based engine, LibLouis, fails to invert its own output when given the code. In response, we present a system that infers the code and reads braille across 156 codes in 85 languages. We fine-tune an LLM on pairs generated by the deterministic text-to-braille transcriber, and its candidate readings are verified by re-transcription. Our system achieves 0.39% per-cell error, against 11.4% for LibLouis given the correct code. We also analyze the remaining error by whether re-transcription can detect it, and find that it concentrates in a few code families, each for a different cause. On an English Bible, with the code given, 80% of readings that reproduce the input cells read at 0.29% character error, against 2.86% for the rest. We open-source our implementation, corpus, and checkpoints: https://github.com/anonytoucan/ubt.

Primary area:
applications to computer vision, audio, language, and other modalities
Keywords:
braille-to-text translation, constrained decoding, probabilistic inversion, multilingual machine translation, inverse problems

Reviews

Among:
Shape:
1234this paper, Bottom 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.25 over 4 reviews, above 49% of the others.
Reviewer_kKXjOpenReview ↗
Rating
2
Confidence
3
Informativeness
1
Presentation
3
Soundness
3
Read review
Paper summary

This paper addresses the retro-transcription of Braille into text when the transcription “code” is unknown. All “codes” are written using the same 256 Unicode Braille cells. Direct (text-to-Braille) transcription is deterministic but not injective, so inverting it amounts to recovering both the code and the text. The authors propose to fine-tune Qwen2.5-7B with LoRA on approximately 940k synthetic pairs produced by a fork of LibLouis from Wikipedia and FLORES, covering 156 codes and 85 languages. The data mix monocode documents, intra-document code alternation, line-by-line mixtures of 2 to 4 codes, and mathematics in Nemeth. At inference, the model draws 20 candidates (best-of-20) and uses the transcriber as an exact verifier: it keeps the most probable candidate whose re-transcription exactly matches the input; otherwise it falls back to a compromise between log-probability and cell-level edit distance. Experiments on synthetic and real data show good performance (0.36% CER on synthetic data, 0.85% on real data), even though on some corpora the proposed system obtains worse results than the baselines. The authors carry out a complete and interesting error analysis.

Critical strengths
  • Elegant inference strategy: the idea of using an exact verifier is an excellent way to exploit the determinism of text → Braille transcription.
  • An interesting problem whose usefulness is certain.
  • A particularly careful, convincing, and substantial evaluation (many languages).

These three points show that this is serious work carried out with care, and lead me to lean toward acceptance.

Critical weaknesses
  • Very thin methodological novelty: to my eyes this is mostly a (very good) piece of engineering work that combines already-published methods in an interesting but straightforward way. There is no discussion of the generality of the method: are there other domains / problems falling into the same framework (non-injective deterministic inversions)?
  • The construction of the baselines seems biased to me: Liblouis's overall score (11.8%) seems mostly due to a few tools whose performances look abnormally high to me (th-g2 at 108%, zh-tw at 86%, table 10). Do the conclusions still hold if one instead considers the median of the scores (or a macro-average)? The GPT-5.5 baseline is insufficiently described (no prompt), and the computed score includes empty outputs (appendix C), which unfairly penalizes the system in my view.
  • A more general description of the problem is perhaps missing: as someone discovering the problem, I have difficulty grasping the extent to which code switching occurs in Braille texts (with the possible exception of texts containing mathematics). It might be useful to better describe the importance and the scope of the problem.
Questions for authors
  • Could you report LibLouis's score as a macro-average per code and case-insensitively? Given the seemingly anomalous results for a few tools (th-g2 at 108%, zh-tw at 86%, table 10), does the proposed system still outperform LibLouis under this fairer metric?
  • Could you provide the GPT-5.5 baseline's CER excluding the empty outputs (appendix C), as well as the exact prompt used (or state (more) explicitely that you use the same prompt for all models) ? This would allow a fairer assessment of this baseline.
1 comment
AuthorsOpenReview ↗

Response to Reviewer kKXj

We thank Reviewer kKXj for the comments and review and also for recognizing the strength of the submission.


W1 (Novelty and generality of UBT).

Please refer to our general response #6.

W2 (Potential bias of the baseline evaluation).

  • We now report both micro- and macro-averaged results. The overall trends remain the same. Please refer to our general response #3, where we also report the case-insensitive results.
  • Regarding GPT-5.5, the empty outputs were caused by the truncation of the reasoning process. After the fix, its micro-average CER is 2.90% with the oracle code and 14.19% without it (vs. 0.44% of UBT for the same 1k subset). Please refer to our general response #2 and Appendix D (which now also reports the full prompt) for more details.

W3 (Scope of code switching).

We revised our manuscript (Section 3.1, "Challenges" paragraph) to clarify this. Code switching commonly occurs in documents from non-English-speaking regions, especially educational materials (e.g., a Korean math textbook mixing the Korean, English, and math codes), which makes it particularly important for accessibility. Note that Table 2 shows that UBT maintains performance on challenging code-switching documents (demonstrated up to k=4k=4).


Questions for authors.

We have addressed these in our responses to the weakness comments (W2) above.


Please let us know any other comments or questions.

Sincerely, Authors of UBT

Reviewer_FKpbOpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

The author propose a system to translate braille to text across 85 languages without needing the code used for making the braille in the first place as input. To do this the authors finetune a Qwen 2.5 7B pretrained checkpoint in braille-text pairs as supervised finetuning stage followed by RL GPRO stage.

For both stages LibLouis is used . LibLouis is deterministic bi-driectional system translation between text and braille. It is used in SFT stage to generate training pairs using seeds across languages and different codes. It is also used in RLVR as verifier to augment the main reward which the CER.

The system is then used at inference in a best-of-N setup where N=20 and the best is selected based on consistency of back translation of the output text to input braille using LibLouis.

This training and inference setup results in Character Error rate of 0.3% on the paper on test compared to 11.4% for the LibLouis system. The system also show comptitev performance but less clear gains on OOD evaluations from human text and braille and clear high performance on the benchmark introduced for the paper the semantic similarity to overcome limitations of CER.

Critical strengths
  • The system is simple and cheap and uses the existing LibLouis well in different stages in a clean setup to distill the braille knowledge into LM with enough language prior. Using LibLouis at inference time is also clean way of using LibLouis braille knowledge in addition to the LLM priors. This matters because the gain can be traced to the proposed parts.

  • The impact is clear for the braille community. The method is cheap to reproduce and scale up or down as needed given the design. The writing is clear and will justified. The strong points and shortcoming are both highlighted clearly

Critical weaknesses
  • The baselines are under-tuned which affect the scale of the gains reported. For GPT 5.5 it is used as few shot translator but it is not discussed enough how was this calibrated and if the errors are parsing errors or errors in the translation itself. There is also no-equal compute version of GPT 5.5 that uses the model with LibLouis directly without any finetuning but with Best-of-N setup. Fro the LibLouis baseline the averages are mostly affected cases that have very high CER such Tamil grade 1 (83%) and Thai grade 1 (69%) in Table 10 which make the comparison against mean mostly affected by a few borken codes .

  • The main metric reported, CER, is affected by capitalization and small changes in reading. In Figure 4, GPT-5.5’s output reproduces the input cells yet scores 5.8% CER, all from capitalization. The authors introduce and disscus semantic scores as secondary but should more central as they affect the claims of the paper more.

Questions for authors
  • Can you clarify the settings used for the GPT 5.5 baseline ? the prompt, number of examples, decoding and reasoning settings? [L843–845] show that most low scored outputs are empty , can you explain why is that the case?

-Can you run GPT-5.5 or an open model with the same best-of-20 selection and LibLouis check? That would separate the value of fine-tuning from the value of the check.

1 comment
AuthorsOpenReview ↗

Response to Reviewer FKpb

We thank Reviewer FKpb for the comments and review, and for recognizing the strengths of the submission.


W1 (Baseline settings and comparisons).

  • (GPT-5.5 settings; empty outputs). Appendix D now reports the full details of the GPT-5.5 inference and evaluation. The empty outputs were caused by the reasoning process exhausting the 16k output budget of the GPT-5.5 API. We fixed this issue by allowing the full token budget; the updated results are reported in the revised manuscript and in our general response #2.
  • (Best-of-nn with untuned models). Due to our organization's budget constraints, we were unable to test GPT-5.5 combined with best-of-nn (n=20n=20); this is the same reason we had to evaluate it on a 1k-document subsample. Instead, we tested the requested setup on an open instruct model, Qwen2.5-32B-AWQ (oracle code given, four few-shot examples, best-of-nn with n=20n=20 and LibLouis verification). It obtained a very high CER of 47.30% on the full test set. Without fine-tuning, the model rarely produces a consistent candidate (0.1% of documents), suggesting that training is essential for verification to yield meaningful gain.
  • (Fairer metrics). The revised submission now also includes detailed comparisons from several angles: micro- and macro-averages, and per-code comparison and analysis.

W2 (CER).

  • (Capitalization). Ignoring case, CER is 0.36% for UBT and 11.45% for LibLouis on the test set, and 2.87% for GPT-5.5 with the oracle code on the 1,000-document subset. Please refer to our general responses #2 and #3 for the relevant tables.
  • (Figure 4). The sample we selected for Figure 4 of the original manuscript happened to be such a case. We have replaced it with a more representative one (now Figure 3), and Figure 9 in Appendix I shows 7 additional back-translation results.
  • (Semantic scores). Section 4.2 now discusses the semantic scores more centrally. The judge gives a score of at least 4 to 97.8% of UBT outputs and 92.3% of GPT-5.5's outputs with the oracle code (Figure 5).

Questions for authors.

We have addressed these in our responses to the weakness comments (W1) above.


Please let us know if you have any other comments or questions.

Sincerely, Authors of UBT

Reviewer_s3uLOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

The paper presents UBT, a LoRA-fine-tuned Qwen2.5-7B model that converts braille to text while inferring the braille code. It supports 156 codes across 85 languages. Training consists of three stages: supervised fine-tuning on approximately 942k synthetic text-braille pairs generated from Wikipedia and FLORES using LibLouis, targeted fine-tuning, and GRPO. At inference time, the model generates 20 candidates and selects the one whose text, retranscribed using LibLouis and the predicted code, best reproduces the input braille.

On synthetic data, UBT achieves 0.36% character error rate (CER), compared with 11.76% for LibLouis supplied with the correct code and 18.96% for GPT-5.5. However, GPT-5.5 is evaluated on only 1k documents, compared with 20k for UBT. Real-world results are mixed: UBT achieves 0.85% CER on NIKL (Korean) and 1.17% on the Bible dataset, where both baselines perform better.

Critical strengths
  • Relevant problem: Converting braille across multiple codes and languages without knowing the code in advance is a useful and underexplored task.
  • Transparent analysis: The paper discusses cases where UBT performs poorly and acknowledges that retranscription detects inconsistencies, not all decoding errors.
  • Informative ablations: The ablations support several design choices: inferring the code adds only 0.09 percentage points of CER, and the best-of-n benefit comes from checking whether candidates reproduce the input braille rather than from reranking alone.
  • Clear implementation: The implementation is coherent and easy to follow.
Critical weaknesses

1. Limits of Consistency Verification and the RL Reward

  • Retranscription checks consistency, not whether the intended text or code has been recovered. An incorrect text or code may still reproduce the input braille.
  • The GRPO reward uses the reference text, so it remains supervised. An experiment using a consistency-only reward on unlabeled real braille would help establish whether the approach can benefit from label-free RL or self-training.

2. Design Choices and Potential Data Contamination

  • Stage 2 codes were selected based on Stage 1 results. The paper should clarify which data informed this selection and whether these choices were evaluated on an untouched test set.
  • The selection of lambda is not clearly explained.
  • Some Wikipedia or FLORES documents may have appeared in Qwen2.5-7B's pretraining data. This possibility warrants discussion and, ideally, evaluation on documents published after the model's training cutoff.

3. Baseline Comparability

LibLouis. LibLouis serves as both the synthetic data generator and a baseline. Some tables do not support reliable reverse translation, as illustrated by the 108% CER for Thai. These cases can inflate the aggregate baseline error and should be distinguished from codes with supported reverse translation.

GPT-5.5. Table 1 states that GPT-5.5 receives the correct code, but scripts\baselines\frontier_fewshot.py appears to provide braille-text examples without code labels. The authors should clarify which procedure produced the reported results. The comparison is also limited to 1k documents, or 5% of UBT's test set, and empty outputs increase the reported error. Reporting their frequency and CER on non-empty outputs would make the results easier to interpret. Figure 4 suggests sensitivity to prompting; a stronger baseline could provide the code, use code-matched examples, and explicitly request standard orthography, including capitalization.

Gemma-2-9B. The rationale for choosing this model is not provided, and it is trained only through Stage 1. Training it through all three stages, or explaining why this comparison is appropriate, would help separate the effects of the backbone and training procedure.

4. Missing Architectural Comparisons

The evaluation does not include per-code specialist models or a two-step approach that first identifies the code and then applies a specialist decoder. These comparisons would help establish the benefits and tradeoffs of a single multilingual model.

5. Code Coverage and Generalization

  • The term "universal" seems broader than the evidence supports: UBT covers 156 codes, not all braille standards.
  • Generalization to the six held-out codes is limited, with 26.5% CER. Croatian is consistently decoded as Serbian Cyrillic.
  • Some codes included in Stage 1 also have high error rates before targeted fine-tuning and GRPO.
  • Code identification is approximately 90% accurate overall but only 71% for Korean. Konkani is often decoded using another language's code.

Together, these results suggest broad coverage of supported codes rather than reliable generalization to unfamiliar ones.

6. Synthetic Evaluation and Normalization

The training data, synthetic test data, and verifier all use LibLouis. The headline results therefore primarily measure agreement with its transcription tables, rather than robustness to independently produced braille or different real-world conventions.

Normalization also materially affects the results: NFC normalization, zero-width-space handling, and Traditional-to-Simplified Chinese conversion reduce CER from 0.62% to 0.36%. The normalized and unnormalized results should be clearly distinguished.

7. Real-World Evidence

The real-world evaluations do not yet establish a consistent advantage. Chinese results require additional domain fine-tuning, suggesting limited transfer to unfamiliar braille without adaptation. On the Bible dataset, UBT does not improve on LibLouis. NIKL results are strong, but the comparison includes only LibLouis, not GPT-5.5. Evaluation on real Unified English Braille (UEB) or contracted-braille data would strengthen the practical claims.

8. Reporting and Reproducibility

  • The abstract reports Bible results of 0.29% and 2.86%, but these figures do not appear in the body. This discrepancy should be resolved.
  • The repository contains the implementation but does not provide data or checkpoints.
  • Results are reported for a single seed, without evidence of run-to-run variability.
  • No latency measurements are provided, leaving the practical cost of generating and checking 20 candidates unclear.
Questions for authors
  1. Were Stage 2 code selection and lambda tuning performed on validation data? Do the results hold when these choices are fixed and evaluated on an untouched test set?
  2. Can you evaluate on documents published after Qwen2.5's training cutoff to assess potential contamination?
  3. Can the RL stage use a label-free, consistency-only reward, particularly on real braille?
  4. How does UBT compare with per-code specialists and a code-identification-then-decoding pipeline?
  5. How does UBT perform on real UEB or contracted-braille data?
  6. Will the data and checkpoints be released, and under what licenses?
  7. Have you evaluated a smaller backbone?
  8. What motivated the baseline selection, particularly Gemma-2-9B, and why was it trained only through Stage 1?
  9. Why was GPT-5.5 evaluated on only 5% of the test set? What fraction of its outputs were empty, and what was its CER on non-empty outputs?
  10. Did GPT-5.5 receive the correct code, as stated in the paper, or were code labels omitted, as the shared implementation appears to suggest?

Changes Most Likely to Raise My Score

  • Select and tune design choices on validation data, then evaluate once on an untouched test set.
  • Add a post-cutoff test set and at least one real UEB or contracted-braille corpus.
  • Release the data and checkpoints.
  • Demonstrate a label-free, consistency-reward result.
  • Make baseline evaluations more comparable, including testing GPT-5.5 on the same documents and reporting empty-output frequency and CER on non-empty outputs.
1 comment
AuthorsOpenReview ↗

Response to Reviewer s3uL

We thank Reviewer s3uL for the comments and review, and for being open to reconsidering your assessment.


W1 (Consistency and correctness; RL reward).

  • We agree that the consistency verification is useful primarily for reducing inconsistent readings. We see this as a limitation shared by all methods that leverage non-injective forward maps for inverse problems; as stated in the conclusion, it should be addressed with a stronger language prior.
  • We agree that the stage-3 reward of Eq. (2) uses the reference text; only its consistency term does not. Appendix B now trains with that term alone on real braille, which lowers CER from 0.92% to 0.27% on the NIKL dataset.

W2 (Design choices and potential data contamination).

  • (Selection on validation data). We found that the code set of the continuation round was mistakenly chosen based on the test set. We reran stages 2 and 3 and all the downstream evaluations. The results and trends remain essentially the same. Please refer to our general response #1 for details.
  • (Choice of λ\lambda). This hyperparameter was chosen in preliminary experiments on a validation subset, although the results were largely flat, with CER differences below 0.05%.
  • (Post-cutoff results). The Wikipedia results in Appendix E show that the post-cutoff results are not worse than the pre-cutoff ones. We also expect BrailleLLM and NIKL to be unseen by the backbone, given their publication dates and licenses.

W3 (Baselines).

  • (LibLouis). We now report a more detailed comparison. Please refer to our general response #3.
  • (GPT-5.5). We fixed the empty-output issue and now report both results, with and without the oracle code. Please refer to our general response #2.
  • (Gemma-2-9B and ByT5). We tested Gemma-2-9B as it is an open decoder-only model of a size comparable to Qwen2.5-7B. ByT5-base (580M) was explored as a smaller model. We explored only stage 1 for these models due to limited computational resources. Note that the Qwen backbone was chosen not only for its experimental results, but also because it is free of licensing issues.

W4 (Per-language/code specialists and two-step pipeline).

  • Training a separate specialist model for each language/code was beyond our budget. Specialists also raise deployment concerns: even with LoRA tuning, one adapter per code must be stored and selected at inference time, whereas our single model scales more easily.
  • Note that BrailleLLM is a specialist model trained in domain (Chinese, English, and mathematics). Fine-tuned on its released split, UBT achieves 2.01% CER against its 5.42% (Table 4).

W5 (Coverage).

  • For Korean, the two codes (2006, 2024) write most text identically, which the confusability-aware accuracy credits.
  • We use the term "universal" not to claim perfect coverage of every code in the world, but to refer to our framework, which can scale flexibly to include any language and code once its forward transcription is available.
  • We deliberately kept the six codes as a held-out split, and we state their high CER as a limitation.

W6 (Normalization).

  • We expanded Appendix C to describe each normalization step and its rationale; it also reports the CER after each step.

W7 (Real-world evidence).

  • (GPT-5.5 on NIKL). NIKL's license does not allow sending its text to external APIs.
  • (GPT-5.5 on other real contracted braille). We additionally ran GPT-5.5, given the code, on 965 sentences from a French ministry report in contracted French and IRS publications in seven languages. Its CER is 3.12%, against 1.30% for UBT without the code and 2.36% for LibLouis given the code. We were not able to run more tests of GPT-5.5 on other datasets due to our budget limitations.

W8 (Reporting and reproducibility).

  • (Release). We will release the code and the checkpoints under Apache-2.0, inheriting the license of the backbone, Qwen2.5-7B. The training data will be distributed under the licenses of the respective original corpora, to the extent those licenses permit. The data-generation scripts will be included in our code.
  • (Inference latency). Please refer to our general response #5.
  • (Bible results in abstract). The abstract no longer reports the Bible results; they are replaced with a broader claim.
  • (Multiple seeds). We could not perform multiple training runs due to our compute constraints. Note that the decoding results of the same model are highly stable: over three decoding seeds, the best-of-20 CER is 0.395 ±\pm 0.003%.

Questions for authors.

We answer the questions in our responses to the weaknesses above: Q1 and Q2 – W2; Q3 – W1; Q4 – W4; Q5 – W7; Q6 – W8; Q7 and Q8 – W3; Q9 and Q10 – W3 and our general response #2.


Please let us know if you have any other comments or questions!

Sincerely, Authors of UBT

Reviewer_DC1nOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper presents UBT, a braille-to-text back-translation system covering 156 braille transcription codes across 85 languages. The pipeline expands the Qwen2.5-7B vocabulary with 256 Unicode braille cell tokens, synthesizes 941k training documents via the deterministic LibLouis forward transcriber (and a Nemeth math backend), and trains the model in three stages: general LoRA SFT, targeted continuation on high-error codes, and GRPO reinforcement learning with a round-trip consistency reward. At inference, the model generates n=20n=20 candidates and uses the forward transcriber as a verifier (Best-of-nn), falling back to a combination of log-probability and cell edit distance when no candidate exactly reproduces the input braille.

Critical strengths
  1. Strong Execution and Benchmark Value for Accessibility: Unifying 156 braille codes across 85 languages (including code-switching and Nemeth mathematics) without requiring manual code specification is a substantial engineering effort. The open-sourced data generator, patched LibLouis engine (fixing cross-process state pollution and Korean 2024 rules), Scoring Normal Form, and cell-level metric (bCER) are valuable contributions to the assistive technology and NLP communities.
  2. Clear Formulation of Non-Prefix-Stable Inversion: The paper clearly articulates why context-sensitive transcription rules (e.g., Grade-2 contractions where "th" vs. "the" alters earlier cells) violate prefix stability, rendering standard token-level constrained decoding inapplicable, and motivates whole-sequence verification via p(Y∣B)∝p(Y) I[fθ(T)=B]p(Y \mid B) \propto p(Y)\,\mathbb{I}[f_\theta(T)=B].
  3. Insightful Error Taxonomy and Self-Referential Demonstration: Decomposing residual errors into verifier-detectable inconsistent errors vs. silent consistent misreadings / wrong codes (Figure 3, Table 3), along with the 22-page braille self-test in Appendix I, provides a transparent analysis of when round-trip verification can and cannot be trusted.
Critical weaknesses
  1. Limited Algorithmic and Methodological Novelty for ICLR: From a machine learning and representation learning perspective, the proposed system is a straightforward combination of well-established recipes: vocabulary expansion with byte-mean initialization, synthetic data SFT, continuation fine-tuning, standard GRPO/DAPO with verifiable rewards (RLVR), and test-time Best-of-nn reranking. While the domain application is well-executed, the paper does not introduce new learning algorithms, architectures, or theoretical insights beyond applying standard post-training and test-time compute pipelines to a deterministic simulator.
  2. Over-Reliance on a Closed-World Synthetic Assumption (Breakdown Under Real-World Convention Shift): The headline result (0.36% CER in Table 1) is achieved in a closed synthetic loop where training data, test data, and the inference-time verifier all use the exact same deterministic program (the authors' patched LibLouis 3.38). However, as soon as the model is evaluated on real-world corpora whose transcription conventions deviate from LibLouis tables (Table 4: BrailleLLM with word-division spaces and Vision-Braille with tone markers) or under physical dot-flip noise (Table 12), the core exact verification mechanism (B^=B\hat{B} = B) collapses (matching only 1/1000 and 16/1000 documents on the two Chinese sets, and 3.2% at 2% dot-flip noise). In these realistic scenarios, UBT's zero-shot CER degrades to 14.20% and 9.36%, and the system only achieves competitive accuracy (2.61% / 2.79%) after standard supervised fine-tuning on in-domain training splits—where the verifier plays almost no role.
  3. The Verifier Cannot Address the Hardest Ambiguities (Consistent Misreadings & Cross-Language Code Confusion): By construction, round-trip verification fθ^(T^)=Bf_{\hat{\theta}}(\hat{T}) = B is completely blind to many-to-one ambiguities within or across codes. Consequently, on the hardest linguistic challenges—such as homophone disambiguation in un-toned Chinese (2.90%–4.68% CER) and shared-alphabet script confusion in Indic languages (e.g., Konkani kok at 13.12% CER because it is decoded as Kannada or Sanskrit)—the verifier provides zero signal. Moreover, because UBT decodes line-by-line without document-level code consistency or passage-level semantic context (unlike recent passage-level curriculum approaches such as Vision-Braille, Wu et al., 2026), it fails to resolve ambiguities that require broader context.
  4. Unfair and Misleading Setup for the GPT-5.5, few-shot† Baseline (Verified via Released Code): Table 1 labels GPT-5.5, few-shot† with †Given the ground-truth code, implying parity with LibLouis backward†. However, inspecting scripts/baselines/frontier_fewshot.py in the supplementary repository reveals two serious issues:
    • No code or language is given to GPT-5.5 at inference: The prompt contains only raw braille cells and 4 random <braille, text> pairs drawn blindly from all 156 codes ("no code label anywhere"). The ground-truth code is only prepended after generation during scoring (hyp = f"⟨{s['table']}⟩" + res). Expecting a general LLM to guess which of 156 codes is used without telling it the target language—while marking the row †Given the ground-truth code—is misleading.
    • Undisclosed 1k Subsampling: GPT-5.5 was evaluated on only 1,000 sampled documents (--n 1000) rather than the 20,071 test set, which is not disclosed in §4.1/§4.2 or Table 1's caption.
  5. High Inference Overhead (9×9\times–20×20\times) Without an Obvious Early-Stopping Cascade: Best-of-20 requires 20× generation compute (44 min vs. 5 min for greedy, Appendix A) to reduce CER from 0.54% (greedy) to 0.36%. Since greedy decoding already satisfies B^greedy=B\hat{B}_{\text{greedy}} = B on 85.6% of test documents (Table 8), generating 19 additional samples for already-verified greedy outputs is wasteful, yet no adaptive early-stopping cascade is explored.
  6. Poor Self-Containedness, Self-Contradictory Metric Definitions, and Layout Issues:
    • Self-contradictory definition of confusability-aware code accuracy (conf.): On Page 5, line 216 (under Eq. 2), θ^≃θ\hat{\theta} \simeq \theta is defined as every predicted code writing the reference text into the input cells (fθ^(T)=Bf_{\hat{\theta}}(T) = B). Yet just 45 lines later on the same page (§4.1, lines 262–264), conf. is defined as crediting another code that transcribes the predicted text into the input cells (fθ^(T^)=Bf_{\hat{\theta}}(\hat{T}) = B). These two definitions are fundamentally different (the latter would credit wrong-script outputs such as Konkani read as Kannada!), and inspecting src/ubt/eval_harness.py shows the code actually uses the former (confusable_set on the reference text).
    • No mathematical definition for the proposed bCER metric: Although §4.1 claims to propose bCER as a primary cross-script metric, there is not a single equation defining it in either the main text or the appendix, omitting critical edge cases found in src/ubt/bcer.py (e.g., set deduplication capping bCER at 100%, and silent fallback to linear proportional interpolation when LibLouis inPos fails).
    • Essential setups buried in appendices: The 3-step Scoring Normal Form (Appendix C.1 Table 7)—which nearly halves the overall CER from 0.62% to 0.36% and reduces Chinese/Khmer CERs by up to 10 points—is largely omitted from §4.1. Similarly, GRPO prompt filtering (dropping 28% of prompts) and GPT-5.5's 1k subsampling are omitted from the main text despite unused space on Page 9.
    • Float ordering and formatting flaws: On Page 7, Figure 4 is placed above Figure 3 out of numerical order; Table 3 omits the "correct" column referenced in the text (line 371) and leaves the "wrong code" sub-columns unexplained; Figures 5 and 6 cram two unrelated plots side-by-side with tiny labels; and dumping 22 full pages of vector-drawn braille dots (>120,000 vector paths) into Appendix I bloats the PDF to 8 MB and severely lags standard PDF renderers, when a 1-page excerpt would suffice.
Questions for authors
  1. Methodological Takeaway for the ICLR Community: Beyond the specific engineering of LibLouis tables, what is the core machine learning contribution that generalizes to other inverse problems? Specifically, when the forward operator ff is only an approximate match to reality (as in Table 4's convention shift or Table 12's noise), Eq. (3) reduces to a naive linear combination log⁡q−λdcell\log q - \lambda d_{\text{cell}} with an unnormalized cumulative log-probability log⁡q\log q. Can the authors justify this heuristic or propose a more principled probabilistic relaxation?
  2. Correcting the GPT-5.5 Baseline: What is GPT-5.5's CER on the 1,000-document subsample when (a) the ground-truth language and braille standard name are explicitly provided in the system/user prompt, and (b) the 4 few-shot demonstrations are drawn from the same ground-truth code? Will the authors revise Table 1's caption and §4.2 to accurately describe how GPT-5.5 was prompted and subsampled?
  3. Ablating the True Contribution of Each Stage vs. Compute: Stage 1 alone with Best-of-20 already achieves 0.53% CER (Table 1), and greedy decoding on the final model achieves 0.54% CER. Given that Stage 2 + Stage 3 (GRPO) + 20× test-time sampling together only move synthetic CER from 0.53% to 0.36% (a 0.17% absolute difference), how much of the pipeline's complexity is genuinely necessary, and what is the performance of an adaptive cascade (only sampling n=20n=20 when the greedy output fails verification, i.e., on 14.4% of inputs)?
  4. Addressing Silent Errors (Indic Wrong-Code & Chinese Homophones): Since the verifier cannot detect consistent misreadings or confusable wrong codes, why not enforce a document-level code prior across lines or decode at the paragraph level? Also, in scripts/eval/bon_gen.py, you implemented a base-model prior reranker VP(a) (log⁡p(Y∣B)+αlog⁡pbase(T)\log p(Y\mid B) + \alpha \log p_{\text{base}}(T)) for CJK—what were the results, and why were they left out of the paper?
1 comment
AuthorsOpenReview ↗

Response to Reviewer DC1n

We thank Reviewer DC1n for the careful reading and the concrete suggestions.


W1 (Novelty; a principled view of Eq. 3).

Please refer to our general response #6.

W2 (Closed-world assumption).

  • (Partial matches and fallback). We agree that the forward verification could fail under conventions outside the covered codes. Nevertheless, unless the forward map is completely different, our method can still rely on partial code matches, and the fallback in Eq. (3) helps: best-of-nn improves over greedy decoding, and the same holds in RL.
  • (Label-free training signal). On human-produced braille that follows the codes, the check even yields a label-free training signal (NIKL CER from 0.92% to 0.27%).
  • (Few labeled pairs). When labeled pairs are available, UBT needs far fewer than its backbone. With 1k pairs, UBT achieves 0.20% CER on NIKL (vs. 82.7% for the backbone) and 5.05% on BrailleLLM (vs. 95.6%) (Figure 7). After fine-tuning, UBT has 2.01% and 2.09% CER on the two Chinese corpora (Table 4).

W3 (Silent errors).

  • (Consistent misreadings). We agree with this point. However, consistent misreadings are inherent to any method that verifies with a deterministic forward map, and the verification still brings a clear gain. We believe that going beyond this is the role of a stronger language prior, which we leave as future work.
  • (Decoding unit). We also clarify that UBT does not decode line by line: it performs inference at the paragraph level and predicts a code for each segment in that context. This unit partly reflects the datasets; nothing prevents decoding at the document level.
  • (Reranking with a language prior). As the reviewer noted, during development we also reranked the candidates with the prior of the base model, tested with the stage-1 model on the CJK codes. CER went from 6.23% to 6.10%. The gain was too small to justify an extra 7B forward pass, so we did not use it in the final system (see Appendix F for more details).

W4 (GPT-5.5).

Please refer to our general response #2. Section 4.1 now names both prompts and the 1,000-document subset, Table 1 marks them, and Appendix D gives the prompts in full.

W5 (Overhead).

  • (Cascade). We now include results with the cascade, which indeed reduces the overhead and could be a practical option for the speed–accuracy trade-off. It keeps the greedy output when it passes the check (85% of documents) and reaches 0.40% CER at 76ms per document, against 0.39% and 377ms for best-of-20. It is also faster and more accurate than best-of-4 (81ms, 0.47%). Please refer to Table 12 and Appendix F for more details.
  • (Throughput and latency). We acknowledge that in batch processing, the cost grows with the number of candidates (377ms against 21ms per document for greedy decoding). For a single document, the 20 candidates are sampled in parallel in one request, so the latency is 1.05s against 0.77s (1.4×).
  • (Contribution of each stage). Stage 2 brings the largest gain, lowering best-of-20 CER from 0.53% to 0.41% and the number of codes above 1% CER from 24 to 17 (Table 13). GRPO changes best-of-20 CER little (0.39%) and trades regressions on some codes (e.g., Japanese and Chinese) for gains on others, but it raises the share of greedy outputs that pass the check from 76% to 85%, which is what makes the cascade cheap. Appendix K explains this: RL moves the selection into the model, raising the share of consistent outputs without reordering them.

W6 (Presentation).

  • (Definition of conf.). The definition of conf. now matches the code. A predicted code counts if it writes the reference text into the input cells.
  • (bCER). Appendix C now includes an equation for bCER. Each cell is counted once, which caps bCER at 100%, and the appendix also gives the fallback alignment for references that do not reproduce the input cells.
  • (Normalization). Appendix C describes the three normalization steps, and Table 9 gives the CER after each step (from 0.62% to 0.39% with all three). Section 4.1 now points to both.
  • (Filtering and subset). Section 3.2 now states the GRPO prompt filtering (43,273 of 59,999 prompts kept), and Table 1 and Section 4.2 state the GPT-5.5 subset.
  • (Figures and tables). Figure 3 now comes before Figure 4, Table 3 has a "correct" column and a single "wrong code" column, and the PDF keeps only the first page of the braille edition (all 26 pages are in the supplementary material). We would also like to separate Figures 5 and 6, but the main text has no room left, so they stay side by side.

Questions for authors.

We answered the questions in our responses to the weaknesses above: Q1 – W1; Q2 – W4; Q3 – W5; Q4 – W3.


Please let us know if you have any other comments or questions!

Sincerely, Authors of UBT

Comments on the paper

3 comments
AuthorsOpenReview ↗

General response to all reviewers (1/2)

We sincerely thank all reviewers for the careful review and constructive suggestions. The following are our responses to some central concerns.


1. Selection of validation data; updated UBT results (s3uL).

We thank Reviewer s3uL for catching this. In the submission, we mistakenly used stage-2 continuation codes from stage-1 results on the test split. We reran the training pipeline with the same recipe on the correct held-out validation split, and the revised manuscript now reports the corrected results. The changes were minimal: only three codes were changed for the continuation stage (one was removed and two were added), and the headline CER moved from 0.36% to 0.39%. The comparison results and conclusions remain unchanged.

2. GPT-5.5 baseline (all reviewers).

For a fairer comparison, we made several changes to the GPT-5.5 evaluation. First, we fixed the "empty output" issue caused by truncated reasoning. We resolved this by increasing the maximum token budget. Second, we now report both GPT-5.5 variants: one with the oracle code and one without. In the original submission, we mistakenly stated that the old GPT-5.5 results were obtained with the oracle code provided; we have now corrected this in the updated table. Regarding best-of-nn (n=20n=20) with GPT-5.5: this requires API costs beyond our organization's budget, so we instead evaluated an open instruct-tuned model, Qwen2.5-32B-AWQ, without any further training, combined with the best-of-nn using LibLouis verification. The results are as follows:

1,000-document subsetCERmacro CERbCERjudge
GPT-5.5, no code (empty response included)18.9621.3219.034.14
GPT-5.5, no code (fixed, now in Table 1)14.1917.7413.144.30
GPT-5.5, with oracle code + 4 same-code examples2.903.993.074.67
Qwen2.5-32B-AWQ, no code, best-of-2063.2165.6759.831.40
Qwen2.5-32B-AWQ, with oracle code + 4 same-code examples, best-of-2048.6950.0547.011.62
UBT, code inferred0.440.580.514.88

We now report details on the LLM baselines (GPT-5.5 and Qwen2.5-32B-AWQ), including the full prompt, in Appendix D.

3. Fairer comparison with LibLouis (s3uL, FKpb, kKXj).

We acknowledge the concern that micro-average results may not reveal the full picture. The updated manuscript now also reports the macro-average CER results in Table 1, and the per-code analysis paragraph includes a detailed comparison between UBT and LibLouis. We share some of the key results:

UBT (code inferred)LibLouis (code given)
CER (micro / macro / median over codes)0.39 / 0.53 / 0.2211.76 / 14.62 / 1.39
case-insensitive CER (micro / macro)0.36 / 0.4811.45 / 14.25
CER on the 111 codes whose table declares back-translation (micro/macro)0.34 / 0.446.06 / 6.54
macro CER on the 102 codes where LibLouis has ≤\leq 5% CER0.350.80

Also note that UBT reports lower CERs on 126 of the 156 codes compared to LibLouis. In one code, the two models tie. On 26 of the remaining 29 codes, both systems have CERs below 0.5%.

4. Potential data contamination (s3uL).

Reviewer s3uL raised an issue about whether UBT's performance was partly attributed to the test corpus (e.g., Wikipedia) being leaked during the training of the backbone, Qwen2.5-7B (released 2024). We investigated this issue by splitting the results into pre- and post-cutoff subsets. We found no indication of inflated performance: 0.81% CER for 2025-, 0.87% for 2019–2022 documents. The revised manuscript (Appendix E) reports the results in detail.

5. Inference cost (DC1n, s3uL).

Appendix F now reports inference cost in both the number of computed tokens and time. In a single-document inference scenario, which we expect to be the most common use case, the best-of-nn with n=20n=20 only takes 1.4 times as long as greedy decoding due to the parallelism (measured with RTX 5090). Following Reviewer DC1n's suggestion, we also report the results with the cascade (greedy-then-sampling) approach, which shows a good trade-off between cost and performance.

AuthorsOpenReview ↗

General response to all reviewers (2/2)

6. Methodological contribution and generality (DC1n, kKXj).

Reviewer DC1n noted that our method combines established recipes and that the fallback in Eq. (3) looks heuristic, and Reviewer kKXj noted the thin methodological novelty and the missing discussion of generality. We think these concerns share a root: our submission describes the problem and method in braille-specific terms, and parts of the method appear heuristic as a result.

To address this, at least in part, we added Appendix K, with a probabilistic formulation of braille back-translation and of our method. We start from the inverse-problem view (Stuart, 2010). The transcriber is a deterministic, many-to-one forward map, so by Bayes' rule the posterior over outputs is the prior restricted to the outputs that reproduce the input: p(Y^∣B)∝p(Y^)[B^=B]p(\hat{Y} \mid B) \propto p(\hat{Y})[\hat{B} = B] (Eq. (4)). UBT is an amortized approximation q(Y^∣B)q(\hat{Y} \mid B) of this posterior, learned from transcriber-generated pairs. Best-of-nn draws nn candidates from qq, and the first case of Eq. (3) keeps the consistent ones, i.e., samples of qq restricted to the consistent outputs (Eq. (5)), and returns the most probable. The second case, used whenever no candidate is consistent, is the soft version of the same constraint: [B^=B][\hat{B} = B] is relaxed to e−λdcell(B^,B)e^{-\lambda d_{\mathrm{cell}}(\hat{B}, B)} (Eq. (7)), and the logarithm of q(Y^∣B)q(\hat{Y} \mid B) times this factor is exactly the score of Eq. (3). It can be read as an error model that penalizes each cell edit between the transcription and the input (cf. Wilkinson, 2013), and it is related to noisy-channel reranking (Yee et al., 2019).

The formulation also accounts for three of our observations.

  • First, the check removes inconsistent readings but cannot change the choice among consistent ones: with mm the probability that the model assigns to consistent outputs, it lowers the error of the model by log⁡(1/m)\log(1/m) as nn grows and leaves the rest (Eq. (6)). This is why the remaining errors are consistent misreadings and wrong codes.
  • Second, the consistency term [B^=B][\hat{B} = B] of the RL reward, a round-trip reward as in dual learning (He et al., 2016), trains the model toward the same selection, i.e., it raises mm. RL therefore lowers the share of inconsistent outputs while the consistent errors remain, and since this term needs no reference text, it can also be used alone on unlabeled braille.
  • Third, a convention shift (Section 4.3) is a mismatch between our transcriber and the process that produced the braille. The error after selection then gains a term λE[dcell(B^,B)]\lambda \mathbb{E}[d_{\mathrm{cell}}(\hat{B}, B)] (Eq. (8)), the expected distance between the input and our re-transcription of the correct output, i.e., the difference between the two forward maps. This term is zero when the braille follows our codes and does not depend on the model, so fine-tuning does not remove it.

We do not claim theoretical novelty: the setup is standard, and each step can be found in the literature on noisy-channel decoding (Yee et al., 2019), Bayesian inverse problems (Stuart, 2010), and approximate Bayesian computation (Wilkinson, 2013). To our knowledge, however, prior learned braille back-translators (e.g., Wu et al., 2024; Huang et al., 2025) do not build on such a formulation, so we see stating the problem this way as a modest contribution. As for generality, the same formulation applies to other inversions of a deterministic, many-to-one program. In NLP, these include pinyin-to-character conversion (Chen & Lee, 2000) and diacritic restoration (Zitouni et al., 2006). Outside NLP, neural decompilation follows the same recipe: it trains on pairs generated by the compiler and verifies each candidate by recompiling it (Katz et al., 2019). Braille differs in that the forward map itself, the code, is unknown, and that it cannot be checked on partial outputs. The updated manuscript cites the key related work at each step to help these communities assess the relevance.

References

  • Chen and Lee. A new statistical approach to Chinese Pinyin input. ACL, 2000.
  • He et al. Dual learning for machine translation. NIPS, 2016.
  • Huang et al. BrailleLLM: Braille instruction tuning with large language models for Braille domain tasks. EMNLP, 2025.
  • Katz et al. Towards neural decompilation. arXiv:1905.08325, 2019.
  • Stuart. Inverse problems: a Bayesian perspective. Acta Numerica, 19:451–559, 2010.
  • Wilkinson. Approximate Bayesian computation (ABC) gives exact results under the assumption of model error. Statistical Applications in Genetics and Molecular Biology, 12(2):129–141, 2013.
  • Wu et al. Vision-Braille: An end-to-end tool for Chinese braille image-to-text translation. arXiv:2407.06048v1, 2024.
  • Yee et al. Simple and effective noisy channel modeling for neural machine translation. EMNLP-IJCNLP, 2019.
  • Zitouni et al. Maximum entropy based restoration of Arabic diacritics. COLING-ACL, 2006.
AuthorsOpenReview ↗

Gentle reminder to reviewers

Dear Reviewers,

We thank you again for your reviews. As the discussion period ends in about a day, we would like to gently remind you of our responses and the revised manuscript. We would be grateful if you could let us know whether our responses address your concerns.

Sincerely, Authors of UBT

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.