🤖 AI

Improving Code Translation with Syntax-Guided and Semantic-aware Preference Optimization

This paper introduces CTO, a novel framework that enhances code translation by integrating syntax-guided compiler feedback with a robust, source-derived semantic reward via contrastive learning within a direct preference optimization setting, thereby overcoming the limitations of existing methods in ensuring both syntactic correctness and semantic consistency.

Original authors: Yuhan Wu, Huan Zhang, Wei Cheng, Chen Shen, Jingyue Yang, Wei Hu

Published 2026-05-14

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Yuhan Wu, Huan Zhang, Wei Cheng, Chen Shen, Jingyue Yang, Wei Hu

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are a master translator trying to convert a recipe written in French into a recipe for a chef who only speaks English. You want the new recipe to do two things perfectly:

Follow the rules of English grammar (Syntax): The sentences must be structured correctly so the chef doesn't get confused by the language itself.
Keep the exact same meaning (Semantics): The dish you end up cooking must taste exactly like the original French dish, not just look like it on paper.

This paper, titled "Improving Code Translation with Syntax-Guided and Semantic-aware Preference Optimization," introduces a new method called CTO to help AI translators do this job much better.

Here is how the paper explains the problem and their solution, using simple analogies:

The Problem: The "Trap" of Current AI Translators

Currently, AI models trying to translate code (like turning Python code into C++) often get stuck in a trap. The paper uses a clever example to show why:

The "Lucky Guess" Trap (Reward Hacking): Imagine a translator writes a recipe that is grammatically perfect but uses the wrong ingredients. However, by pure luck, the specific test case they are given (e.g., "make a cake with 1 egg") works out because the wrong ingredient happens to work for that one specific egg. The AI gets a "pass" and thinks it did a great job, even though the recipe is broken for any other situation. This is called reward hacking.
The "Perfect Meaning, Broken Grammar" Trap: Imagine another translator writes a recipe that describes the exact right dish (perfect semantics) but writes it in a way that breaks the rules of English grammar. The chef can't even read it, so the computer says, "Fail!" even though the idea was brilliant.

Current methods struggle to tell the difference between a "lucky guess" and a "broken idea." They often rely on:

Sparse Test Cases: Like giving the translator only one specific test to pass. If they cheat to pass that one test, they win.
Reference Comparisons: Comparing the new code to a "gold standard" example. But if the gold standard is slightly imperfect, or if the new code is written differently but means the same thing, the AI gets confused.

The Solution: CTO (The "Double-Check" System)

The authors propose CTO, which acts like a strict, two-step quality control inspector. Instead of just asking "Did it pass the test?", CTO asks two distinct questions simultaneously:

1. The Grammar Check (Syntax)

This is the easy part. The system runs the translated code through a compiler (a tool that checks if code follows the rules of the language).

Analogy: Think of this as a spell-checker. If the sentence has a typo or is missing a period, it's an automatic "Fail." This part is 100% reliable because computers are very good at checking rules.

2. The Meaning Check (Semantics)

This is the hard part. How do you check if the meaning is right without relying on lucky test cases?

The Innovation: The authors trained a special "Meaning Detector" (a semantic model) using a technique called contrastive learning.
Analogy: Imagine you have a master chef (the Source Code) and a new apprentice (the Translated Code). Instead of just tasting the final dish, the Meaning Detector looks at the essence of the ingredients and the cooking logic. It learns to say, "Even though this recipe uses different words, it describes the exact same flavor profile as the master chef's recipe."
How they trained it: They took correct recipes and asked an AI to make tiny, sneaky mistakes that changed the meaning but kept the grammar perfect. The detector learned to spot these "sneaky mistakes" by comparing the original to the flawed version.

How CTO Works: The "Balanced Scorecard"

Once the system has both checks, it uses a method called Preference Optimization.

The Old Way: The AI would try to maximize a single score. If the grammar was wrong, the whole score was zero, even if the meaning was perfect.
The CTO Way: It treats the translation as a multi-objective game. It creates a "scorecard" where:
- Grammar gets a pass/fail score.
- Meaning gets a score based on how close the "flavor" is to the original.
- The AI is then trained to find the "sweet spot" where the code is both grammatically correct and semantically accurate.

The paper argues that by combining these two signals, the AI stops "cheating" with lucky test cases and stops getting rejected for having perfect ideas but bad grammar.

The Results: Does It Work?

The authors tested CTO on translating code between three popular languages: C++, Java, and Python.

The Competition: They compared CTO against other top methods, including those that use Reinforcement Learning (which can be unstable) and those that just rely on standard text similarity.
The Outcome: CTO consistently won.
- It improved translation accuracy by 3.66% to 6.70% depending on the model size and dataset.
- It was particularly good at fixing the "lucky guess" problem, ensuring that the translated code actually works as intended, not just on one specific test.

In Summary

Think of CTO as a translator who doesn't just care about spelling (Syntax) or just care about the story (Semantics). It is a translator who has a strict editor checking the grammar and a wise critic checking the story, working together to ensure the final translation is both readable and true to the original. This allows AI to translate code more reliably, making it safer to move software from one language to another.

Technical Summary: CTO – Syntax-Guided and Semantic-Aware Preference Optimization for Code Translation

Problem Statement

Large Language Models (LLMs) have demonstrated significant potential for code translation, yet they frequently struggle to simultaneously ensure syntactic correctness and semantic consistency. Existing approaches face critical limitations in defining reliable reward signals for alignment:

Syntactic Rewards: Compiler feedback provides a deterministic, binary signal for syntax but offers no insight into functional correctness.
Semantic Rewards: Current strategies rely on flawed proxies.
- Test-case-based rewards are often sparse and low-coverage, leading to "reward hacking" where models overfit to specific test cases without preserving the source code's true intent. Furthermore, a single syntactic error in the target language causes a total execution failure, yielding a zero reward regardless of semantic accuracy, thus entangling syntax and semantics.
- Reference-based rewards (e.g., CodeBLEU or monolingual semantic models comparing against a reference translation) are superficial or assume the reference is a perfect semantic anchor. This restricts output diversity and propagates errors present in the reference.

The paper argues that a robust semantic reward must be derived directly from the source code itself, disentangled from these flawed proxies.

Methodology: CTO

The authors propose CTO (Code Translation Optimization), a framework that improves code translation via syntax-guided and semantic-aware preference optimization. The method reformulates code translation as a multi-objective optimization problem within the Direct Preference Optimization (DPO) framework.

1. Semantic Reward Model Training
To generate robust semantic signals, the authors train a cross-lingual semantic model using contrastive learning:

Architecture: A dual-encoder (sharing parameters) maps source and target code into a shared latent space.
Training Objective: Using InfoNCE loss, the model learns to pull the embedding of a reference translation ( $y^+$ ) close to the source code anchor ( $x$ ) while repelling semantically divergent negative samples ( $y^-$ ).
Negative Sample Generation: Instead of relying on random noise, an LLM rewrites reference code to introduce subtle, syntactically valid but semantically flawed perturbations.
Reward Scoring: The semantic reward ( $r_s$ ) for a candidate translation is calculated based on the cosine similarity between the candidate and the source code in the latent space, normalized via z-score to enable list-wise scoring.

2. Preference Optimization Formulation
CTO treats code translation as a multi-objective problem integrating syntax ( $g$ ) and semantics ( $s$ ):

Oracle Reward: A weighted combination of syntax and semantic rewards: $r^*(x, y) = w \cdot r^*_g(x, y) + (1-w) \cdot r^*_s(x, y)$ .
Preference Dataset Construction:
- Syntax: Preference pairs are constructed deterministically based on compiler feedback (Pass vs. Fail).
- Semantic: The semantic reward model provides soft guidance. The semantic score difference between the chosen (Pass) and rejected (Fail) samples is injected as a rectification term.
Optimization Objective: The authors derive a modified DPO loss function (Eq. 7) that leverages preference data from one objective (e.g., syntax) while integrating the explicit reward difference from the complementary objective (e.g., semantics) as a bias term. This allows for the simultaneous modeling of both objectives without requiring a separate reward model during the optimization phase.

Key Contributions

CTO Framework: A novel approach that unifies syntax and semantics in a single preference optimization process, introducing a reward-biasing mechanism within DPO.
Cross-Lingual Semantic Model: A robust reward source trained via contrastive learning that directly evaluates functional equivalence between source and target code, overcoming the limitations of test-case sparsity and reference dependency.
Empirical Validation: Extensive experiments demonstrating that CTO significantly outperforms existing baselines (including unsupervised methods, supervised fine-tuning, and PPO-based approaches) across multiple language pairs and model sizes.

Experimental Results

The authors evaluated CTO on TransCoder-Test and HumanEval-X benchmarks involving translations between C++, Java, and Python.

Performance Gains:
- Using the CodeT5 model, CTO improved accuracy by up to 3.66% on TransCoder-Test and 4.27% on HumanEval-X compared to supervised fine-tuning (SFT) baselines.
- Using the larger CodeLlama-7B model, CTO yielded accuracy gains of 5.60% and 6.70% on the respective datasets.
- Using Qwen2.5-Coder-7B, CTO achieved the highest scores across all tasks, significantly outperforming SFT and other preference optimization strategies (IPO, SimPO).
Ablation Studies: Removing either the semantic or syntax component resulted in performance degradation, confirming that multi-objective optimization is crucial.
Reward Model Comparison: The learned semantic reward model consistently outperformed reference-based metrics like CodeBLEU and CodeBERTScore when used as the semantic signal in CTO.

Significance and Claims

The paper claims that CTO addresses the fundamental challenge of decoupling syntactic validity from semantic correctness in code translation. By deriving semantic rewards directly from the source code and integrating them into a unified preference optimization framework, CTO avoids the pitfalls of sparse test cases and imperfect reference translations. The authors assert that this approach provides a more robust and generalizable strategy for aligning LLMs with the intended functionality of source code, leading to superior translation accuracy and stability across different model architectures and programming languages.