Enhancing Cross-Language Code Translation via Task-Specific Embedding Alignment in Retrieval-Augmented Generation

Daniel O' Malley; Ismael Boureima; Javier E. Santos; Manish Bhattarai; Minh Vu

REVIEW 4 major objections 4 minor 19 references

Enhancing Cross-Language Code Translation via Task-Specific Embedding Alignment in Retrieval-Augmented Generation

T0 review · 4 major / 4 minor · reviewed 2026-08-11 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read Aligning the retriever to CodeBLEU similarity raises Fortran-to-C++ translation quality by 14–15% without fine-tuning the LLM.

desk verdict A useful retrieval-alignment idea with solid directional gains, but the proof is wrong, the headline averages are overstated, and the retrieval protocol is underspecified enough to worry about leakage. read the letter →

arxiv 2412.05159 v1 pith:OGKWYODN submitted 2024-12-06 cs.AI cs.SE

Manish Bhattarai , Minh Vu , Javier E. Santos , Ismael Boureima , Daniel O' Malley This is my paper · ORCID

classification cs.AIcs.SE

keywords codetranslationFortrantoC++retrieval-augmentedgenerationembeddingalignmentcontrastivelearningBLEUsoftInfoNCEfew-shotprompting

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper is trying to establish that in retrieval-augmented Fortran-to-C++ translation, the quality of the retrieved few-shot examples is a bottleneck, and that the retriever can be trained to serve the translation metric directly. It proposes S-InfoNCE, a soft contrastive loss that uses pairwise CodeBLEU scores between LLaMA-generated C++ translations as continuous labels for aligning the StarEncoder embedding space. With this aligned retriever, the paper reports average CodeBLEU gains from 0.64 to 0.73 on HPC Fortran2C++ and from 0.52 to 0.60 on Numerical Recipes, across several LLMs and few-shot settings, with no fine-tuning of the language model. If the method transfers, it provides a way to improve translation quality for language pairs that lack aligned ground-truth training data but have a target-side quality metric.

What carries the argument

The central object is S-InfoNCE, a soft version of the InfoNCE contrastive loss. For source snippets $c_i^s$ embedded by $\Psi$ with temperature $\tau$, it compares the scaled cosine similarity $S^s_{\Psi ij} = \frac{1}{\tau}\frac{\Psi(c_i^s)\cdot\Psi(c_j^s)}{\|\Psi(c_i^s)\|\|\Psi(c_j^s)\|}$ against the target-side CodeBLEU similarity $S^t_{ij}$ between the C++ translations that the generator produced for the two snippets. The loss is $L_{\mathrm{S-InfoNCE}}(\Psi) = -\sum_{i}\sum_{j} S^t_{ij} \log \frac{\exp(S^s_{\Psi ij})}{\sum_k \exp(S^s_{\Psi ik})}$, and the paper's lemma shows that at stationarity these two similarity distributions coincide. This alignment is what makes the RAG retriever choose Fortran examples whose C++ counterparts are likely to push the generator's output toward high CodeBLEU.

What would settle it

Hold out a set of Fortran snippets with ground-truth C++. Measure the correlation between pairwise CodeBLEU of LLaMA-generated translations and pairwise CodeBLEU of the ground-truth translations; if it is weak for snippets with similar runtime behavior, the training signal is not tracking what retrieval should optimize. The end-to-end test is simpler: with the LLM fixed, compare RAG output CodeBLEU using top-k examples from the aligned retriever against top-k examples from generic embeddings or random selection; if the aligned examples do not consistently win, the central claim fails.

Watch

Extended reading notes

Core claim

The central claim is that retrieval quality, not generator size alone, determines how much a few-shot RAG system benefits from its examples, and that the embedding model can be aligned to the downstream metric instead of to generic code similarity. The authors generate C++ translations of 25,000 Fortran snippets with LLaMA 3.1-8B, compute pairwise CodeBLEU scores among the generated translations, and train the StarEncoder embedding with S-InfoNCE so that the cosine structure of Fortran embeddings tracks the CodeBLEU structure of their translations. At the optimum of the loss, the normalized embedding similarities match the normalized CodeBLEU similarities. Integrated into RAG, this aligned retriever raises average CodeBLEU by 14–15% on the two benchmarks across four LLMs and one-, two-, and three-shot settings, without modifying the generator.

Load-bearing premise

The method assumes that pairwise CodeBLEU between LLaMA-generated C++ translations is a reliable proxy for which Fortran source pairs are the best retrieval examples for producing ground-truth-faithful translations, even though no ground-truth C++ is seen during alignment.

Editorial extensions

If this is right

The reported gains hold across LLaMA 3.1-8B, LLaMA 3.1-70B, Mistral 123B, and Mixtral 8x22B, so the benefit is not specific to one generator.
Because the LLM is left untouched, the entire training cost is in the embedding model, making the upgrade substantially cheaper than fine-tuning a generator.
The aligned retriever narrows the spread of CodeBLEU scores, so translations become more consistently close to ground truth, not just better on average.
Diminishing returns after two shots imply that retrieval alignment matters most when only one or two examples are affordable.
The authors' stated generalization is that the same alignment strategy applies to other language pairs and tasks as long as a target-side quality metric such as CodeBLEU is available.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

If the soft-label proxy is the bottleneck, swapping CodeBLEU for execution-based equivalence (for example, running generated C++ against test oracles) would be the natural next experiment, and it could reveal how much of the gain is due to n-gram and AST similarity versus functional correctness.
Since the soft labels come from a single generator, the aligned retriever may inherit that generator's systematic errors; using translations from several models or seeding a small ground-truth set would test whether this is a ceiling or a correction.
The recipe is generalizable beyond code: any generation task with a target-side metric and a large unlabeled source set could use the same pairwise-scoring plus S-InfoNCE pipeline, though pairwise scoring grows quadratically in the size of the training set.
A practical implication for RAG systems is that the first one or two retrieved examples matter most, so reranking effort could be concentrated on the top two retrieved neighbors rather than spread across many.

Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

The core idea here is genuinely useful: instead of retrieving with generic embeddings in a RAG code-translation pipeline, fine-tune the retriever with soft contrastive labels derived from CodeBLEU between LLM-generated target translations. That is a sensible, transferable trick, and the paper shows consistent directional improvements across all four models in Table 1. The pipeline is clean, the limitations section is honest about CodeBLEU not capturing functional equivalence, and the appendix example is a nice qualitative trace. For anyone working on RAG for code or HPC modernization, this is worth reading despite the flaws below.

Now the soft spots, in rough order of importance.

First, the retrieval-evaluation protocol is underspecified in a way that threatens the headline numbers. Section 4 says the HPC Fortran2C++ and Numerical Recipes datasets were "employed for RAG retrieval and evaluation," and the vector database is described only as storing Fortran-C++ pairs. It never states whether query snippets were excluded from the retrieval corpus. If the ground-truth pair for a query is in the pool, an aligned retriever can retrieve that exact pair and trivially inflate CodeBLEU. The evaluation sets are only 315 and 298 pairs, so this is a real risk. The authors need to state the train/eval split explicitly and, ideally, evaluate by retrieving from a separate corpus (e.g., Stack-V2 only) rather than from the same benchmark.

Second, the Lemma 1 proof does not work. The proof treats the normalized softmax probabilities as free variables subject only to sum-to-one constraints, but those probabilities are functions of the embedding parameters. The stationary condition in Eq. 9 is the optimum of the loss over arbitrary probability distributions, not over the embedding parameterization. The claim may still hold in some loose sense, but as written it is not a valid proof. This is fixable by rewriting or removing the lemma, but it should not stand.

Third, the headline averages are overstated. The 0.64 to 0.73 and 0.52 to 0.60 numbers match the llama3.1-70b results in Figure 2, not an average over all shot counts and models as the text claims. The Mistral and Mixtral gains are much smaller. The text should report per-model aggregates or clearly label the headline as the 70b case.

Fourth, there are no significance tests, and the reported standard deviations overlap heavily (0.64 ± 0.19 vs. 0.73 ± 0.17). Paired tests across the 315/298 examples would be cheap and would make the claim much more credible. Finally, no code or artifacts are released, and the 256-GPU training run is not easy to reproduce.

My recommendation: send this to peer review, but request major revision focused on the retrieval protocol, the lemma, and the reporting. The idea deserves referee time; the current presentation does not yet support the strength of the claims.

Referee Report

4 major / 4 minor

Summary. The paper proposes a retrieval-augmented generation (RAG) method for Fortran-to-C++ translation in which the retrieval embedding model is fine-tuned with a contrastive loss (S-InfoNCE) that uses CodeBLEU scores between LLM-generated C++ translations as soft similarity labels. The aligned embeddings are then used to retrieve few-shot example pairs for several LLMs. Experiments on the HPC Fortran2C++ and Numerical Recipes datasets report average CodeBLEU improvements from 0.64 to 0.73 and from 0.52 to 0.60, respectively, without fine-tuning the LLM. The paper also includes a theoretical lemma characterizing stationary points of the proposed loss.

Significance. If the reported gains are reliable, the work is a useful empirical contribution: it shows that retrieval can be adapted to a downstream code-translation metric with a contrastive objective, and it demonstrates a plausible way to exploit CodeBLEU when aligned source-target datasets are scarce. The method is clearly described and the experiments cover multiple LLMs and shot counts. However, the current manuscript has load-bearing weaknesses: the evaluation protocol does not specify whether query snippets are excluded from the retrieval corpus; the theoretical lemma is a restatement of the loss rather than a substantive optimality result; the training signal is based on pairwise similarities among generator outputs rather than ground truth, contrary to parts of the abstract; and the headline numbers are not actually averaged over all models as claimed. These issues must be resolved before the central empirical claim can be accepted.

major comments (4)

[Section 4 (Retrieval and Evaluation Protocol)] The evaluation section states that the HPC Fortran2C++ (315 pairs) and Numerical Recipes (298 pairs) datasets were 'employed for RAG retrieval and evaluation with LLMs' and that the vector database stores 'Fortran-C++ pairs', but it never states whether the query snippet (or near-duplicates from the same small benchmark) are excluded from the retrieval corpus. If the query itself is in the retrieval pool, the aligned retriever can return the ground-truth C++ translation as a few-shot example, which would trivially inflate CodeBLEU relative to an unaligned retriever. Given the small evaluation sets, the authors must specify the exact retrieval corpus for evaluation, the train/evaluation split, and the self-exclusion rule, and rerun or justify the results with that protocol.
[Section 3.2, Lemma 1 and proof (Eqs. 9-21)] The proof of Lemma 1 treats the softmax probabilities p_ij(Ψ) as independent free variables in the Lagrangian (Eq. 14) and derives the stationary condition by differentiating with respect to p_ij. However, p_ij(Ψ) are not independent; they are deterministic functions of the embedding parameters Ψ and are constrained by the softmax normalization plus the structure of cosine similarities. The derivation therefore does not establish a stationary point of the loss over Ψ; it only shows that if p_ij could be set arbitrarily, the loss would be minimized by matching the normalized CodeBLEU matrix, which is exactly what the S-InfoNCE loss is designed to encourage. The 'optimal loss' formula in Eq. (21) is consequently a restatement of the loss construction rather than a proven property of the trained embedding model. The lemma should either be removed or replaced with a rigorous statement about the optimization landscape of the actual parameter space.
[Section 3.2, Eqs. (4)-(5) and abstract] The training data for alignment is built by computing pairwise CodeBLEU scores between C++ translations generated by LLaMA 3.1-8B (Eq. 5), not between generated translations and ground-truth translations. Yet the abstract says 'We compute pairwise CodeBLEU scores between the generated translations and ground truth examples', and Section 4 repeats a similar claim. The method therefore aligns the retriever to the generator's output distribution, under the assumption that source snippets whose generated translations are similar to each other are the best retrieval examples for producing ground-truth-faithful translations. This assumption is not validated (e.g., by measuring whether the proxy correlates with ground-truth CodeBLEU on a held-out set, or by an ablation using human-verified translations), and the Limitations section does not address it. This is a central methodological concern that should be discussed and, ideally, tested.
[Section 4 (headline results) and Table 1] The text says 'averaged over all shot counts and models, the aligned embeddings achieved an average CodeBLEU score of 0.73, whereas unaligned embeddings achieve 0.64' for HPC Fortran2C++. However, Table 1 shows that the 0.64/0.73 values correspond only to the llama3.1 70b model when averaging the 1-, 2-, and 3-shot CodeBLEU deltas onto the zero-shot baseline (0.364 to 0.626/0.710, 0.639/0.735, 0.645/0.741). For llama3.1 8b the averages are approximately 0.58/0.70 (from Figure 2 and Table 1), and for the other models the numbers differ as well. The claim that these are averages over all models is not supported by the reported data and should be corrected with per-model, per-shot statistics.

minor comments (4)

[Abstract / Section 3.2] The abstract and Section 4 state that CodeBLEU is computed 'between the generated translations and ground truth examples', but Section 3.2 (Eq. 5) computes it between generated translations. Please make the descriptions consistent.
[Figure 2 caption] The caption says 'One-shot CodeBLEU' and 'across all four tested datasets', but the figure shows 1-, 2-, and 3-shot results for two datasets. Please correct the caption to match the content.
[Conclusion] There is a typo: 'th LLM' should be 'the LLM'.
[Section 4 (experimental setup)] The paper does not report the number of training steps/epochs or the stopping criterion for the embedding alignment, nor does it state whether results are averaged over multiple random seeds. Given the small evaluation sets, significance tests (e.g., paired bootstrap or Wilcoxon) over samples would strengthen the claims; at present only mean and standard deviation are reported.

Circularity Check

1 steps flagged · score 2.0 of 10

Lemma 1 restates the loss objective by construction; the headline empirical comparison is not circular.

self definitional [Section 3.2, Lemma 1, Equations (6)-(9)]
"The stationary points of the S-InfoNCE loss (Equation 8) satisfy: exp(Ss_Ψ*_ij)/Σ_k exp(Ss_Ψ*_ik) = St_ij/Σ_k St_ik. ... Therefore, the optimal loss is the weighted sum of the entropy of the CodeBLEU similarity distribution."

S-InfoNCE is defined as -Σ St_ij log p_ij(Ψ) with p_ij(Ψ) the softmax of embedding cosine similarities (Eqs. 6-7). The first-order condition of that cross-entropy objective is exactly p_ij ∝ St_ij, so Eq. 9 is not an independent constraint or prediction; it is a restatement of the loss. The proof also optimizes over p_ij as if they were free variables, which assumes away the parametric constraint p_ij = softmax(Ψ·Ψ), so the lemma's scope is definitional. This is benign for the empirical claim because the reported gains come from ground-truth CodeBLEU evaluation, not from Eq. 9.

full rationale

The one equation-level circularity is Lemma 1: the S-InfoNCE loss is defined as a cross-entropy between the normalized CodeBLEU matrix St and the softmax of embedding similarities, so the stated stationary condition (Eq. 9) is the minimizer of that same objective by construction, and the entropy formula (Eq. 10) is the corresponding minimum. No downstream prediction is derived from this lemma; it merely describes the training target. The central empirical claim (aligned vs. unaligned retrieval: 0.64 to 0.73 and 0.52 to 0.60 CodeBLEU) is not forced by the training objective, because the training labels are pairwise CodeBLEU among LLaMA-3.1-8B translations of Stack-V2 snippets (Eqs. 4-5), whereas evaluation computes CodeBLEU of RAG-augmented outputs against human ground truth on HPC Fortran2C++ and Numerical Recipes. The self-citations to Bhattarai et al. (2024) are used only to describe the prior RAG setup and are not load-bearing for the new comparison, which is rerun with StarEncoder embeddings. The paper does omit an explicit statement of whether benchmark queries are excluded from the retrieval corpus in Section 4; that is a potential test-set-leakage risk, but the text does not establish that the ground-truth pair was retrieved, so under the no-speculation rule it is not scored as a demonstrated circular step. Overall, the derivation chain is mostly self-contained, with only a definitional lemma tautology and a minor protocol omission.

Assumptions & free parameters 2 free parameters · 4 assumptions · 0 invented entities

The central claim relies on a hand-chosen temperature, a hand-chosen data filter, and the proxy assumption that CodeBLEU between generated translations captures retrieval usefulness. The proof also assumes an invalid independence structure in the Lagrangian.

free parameters (2)

Temperature tau in S-InfoNCE = 0.1
Chosen by hand in Section 4; controls concentration of the contrastive softmax, with no ablation reported.
Stack-V2 snippet filtering threshold = 500 bytes and top star/fork selection
Hand-chosen sampling criterion in Section 4; affects the composition of the training corpus.

assumptions (4)

domain assumption High pairwise CodeBLEU between LLM-generated C++ translations implies the source snippets are good retrieval neighbors for high-quality translation.
Stated in Section 3.2 after Eq. 5; the entire alignment objective rests on this proxy.
domain assumption Optimizing retrieval similarity to CodeBLEU without fine-tuning G improves ground-truth CodeBLEU at inference.
Central to the RAG claim; tested empirically but not proven.
ad hoc to paper The p_ij terms can be treated as independent free variables in the Lagrangian proof of Lemma 1.
The proof ignores that p_ij is a function of the embedding parameters Psi, an unjustified step.
domain assumption No ground truth C++ is needed for Stack-V2; generated translations are sufficient supervision.
The abstract implies ground truth, but the methods section states Stack-V2 lacks aligned pairs.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Enhancing Cross-Language Code Translation via Task-Specific Embedding Alignment in Retrieval-Augmented Generation." pith.science (2026). https://pith.science/paper/OGKWYODN

@misc{pith2026241205159,
  author       = {Pith},
  title        = {Pith review of: Enhancing Cross-Language Code Translation via Task-Specific Embedding Alignment in Retrieval-Augmented Generation},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/OGKWYODN}},
  note         = {Machine review of arXiv:2412.05159}
}

read the original abstract

We introduce a novel method to enhance cross-language code translation from Fortran to C++ by integrating task-specific embedding alignment into a Retrieval-Augmented Generation (RAG) framework. Unlike conventional retrieval approaches that utilize generic embeddings agnostic to the downstream task, our strategy aligns the retrieval model directly with the objective of maximizing translation quality, as quantified by the CodeBLEU metric. This alignment ensures that the embeddings are semantically and syntactically meaningful for the specific code translation task. Our methodology involves constructing a dataset of 25,000 Fortran code snippets sourced from Stack-V2 dataset and generating their corresponding C++ translations using the LLaMA 3.1-8B language model. We compute pairwise CodeBLEU scores between the generated translations and ground truth examples to capture fine-grained similarities. These scores serve as supervision signals in a contrastive learning framework, where we optimize the embedding model to retrieve Fortran-C++ pairs that are most beneficial for improving the language model's translation performance. By integrating these CodeBLEU-optimized embeddings into the RAG framework, our approach significantly enhances both retrieval accuracy and code generation quality over methods employing generic embeddings. On the HPC Fortran2C++ dataset, our method elevates the average CodeBLEU score from 0.64 to 0.73, achieving a 14% relative improvement. On the Numerical Recipes dataset, we observe an increase from 0.52 to 0.60, marking a 15% relative improvement. Importantly, these gains are realized without any fine-tuning of the language model, underscoring the efficiency and practicality of our approach.

Figures

Figures reproduced from arXiv: 2412.05159 by the authors.

**Figure 2.** Scatter plots comparing the unaligned and aligned One-shot CodeBLEU scores across different shot [PITH_FULL_IMAGE:figures/full_fig_p007_2.png] view at source ↗

**Figure 3.** Box plots illustrating the distribution of Code [PITH_FULL_IMAGE:figures/full_fig_p007_3.png] view at source ↗

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

19 extracted references · 3 canonical work pages

[1]

online" 'onlinestring :=

ENTRY address archivePrefix author booktitle chapter edition editor eid eprint eprinttype howpublished institution journal key month note number organization pages publisher school series title type volume year doi pubmed url lastchecked label extra.label sort.label short.list INTEGERS output.state before.all mid.sentence after.sentence after.block STRING...
[2]

write newline

" write newline "" before.all 'output.state := FUNCTION n.dashify 't := "" t empty not t #1 #1 substring "-" = t #1 #2 substring "--" = not "--" * t #2 global.max substring 't := t #1 #1 substring "-" = "-" * t #2 global.max substring 't := while if t #1 #1 substring * t #2 global.max substring 't := if while FUNCTION word.in bbl.in capitalize " " * FUNCT...
[3]

Manish Bhattarai, Javier E Santos, Shawn Jones, Ayan Biswas, Boian Alexandrov, and Daniel O'Malley. 2024. Enhancing code translation in language models with few-shot learning via retrieval-augmented generation. arXiv preprint arXiv:2407.19619

arXiv 2024
[4]

Mark Chen, Jerry Tworek, Heewoo Jun, Qiming Yuan, Henrique Ponde De Oliveira Pinto, Jared Kaplan, Harri Edwards, Yuri Burda, Nicholas Joseph, Greg Brockman, et al. 2021. Evaluating large language models trained on code. arXiv preprint arXiv:2107.03374

arXiv 2021
[5]

Zhangyin Feng, Daya Guo, Duyu Tang, Nan Duan, Xiaocheng Feng, Ming Gong, Linjun Shou, Bing Qin, Ting Liu, Daxin Jiang, and Ming Zhou. 2020. https://doi.org/10.18653/v1/2020.findings-emnlp.139 C ode BERT : A pre-trained model for programming and natural languages . In Findings of the Association for Computational Linguistics: EMNLP 2020, pages 1536--1547, ...

doi:10.18653/v1/2020.findings-emnlp.139 2020
[6]

Prannay Khosla, Piotr Teterwak, Chen Wang, Aaron Sarna, Yonglong Tian, Phillip Isola, Aaron Maschinot, Ce Liu, and Dilip Krishnan. 2020. Supervised contrastive learning. Advances in neural information processing systems, 33:18661--18673

2020
[7]

Philipp Koehn. 2009. Statistical machine translation. Cambridge University Press

2009
[8]

Bin Lei, Caiwen Ding, Le Chen, Pei-Hung Lin, and Chunhua Liao. 2023. Creating a dataset for high-performance computing code translation using llms: A bridge between openmp fortran and c++. In 2023 IEEE High Performance Extreme Computing Conference (HPEC), pages 1--7. IEEE

2023

Show all 19 references

[9]

u ttler, Mike Lewis, Wen-tau Yih, Tim Rockt \

Patrick Lewis, Ethan Perez, Aleksandra Piktus, Fabio Petroni, Vladimir Karpukhin, Naman Goyal, Heinrich K \"u ttler, Mike Lewis, Wen-tau Yih, Tim Rockt \"a schel, et al. 2020. Retrieval-augmented generation for knowledge-intensive nlp tasks. Advances in Neural Information Proc...

2020
[10]

Retrieval-augmented multi-hop code generation with codellama and unlimiformer

Chuangji Li, Shizhuo Li, and Alan Wang. Retrieval-augmented multi-hop code generation with codellama and unlimiformer
[11]

Raymond Li, Loubna Ben Allal, Yangtian Zi, Niklas Muennighoff, Denis Kocetkov, Chenghao Mou, Marc Marone, Christopher Akiki, Jia Li, Jenny Chim, et al. 2023. Starcoder: may the source be with you! arXiv preprint arXiv:2305.06161

2023 arXiv
[12]

Anton Lozhkov, Raymond Li, Loubna Ben Allal, Federico Cassano, Joel Lamy-Poirier, Nouamane Tazi, Ao Tang, Dmytro Pykhtar, Jiawei Liu, Yuxiang Wei, et al. 2024. Starcoder 2 and the stack v2: The next generation. arXiv preprint arXiv:2402.19173

2024 arXiv
[13]

Mayank Mishra, Matt Stallone, Gaoyuan Zhang, Yikang Shen, Aditya Prasad, Adriana Meza Soria, Michele Merler, Parameswaran Selvam, Saptha Surendran, Shivdeep Singh, et al. 2024. Granite code models: A family of open foundation models for code intelligence. arXiv preprint arXiv:...

2024 arXiv
[14]

Zach Nussbaum, John X Morris, Brandon Duderstadt, and Andriy Mulyar. 2024. Nomic embed: Training a reproducible long context text embedder. arXiv preprint arXiv:2402.01613

2024 arXiv
[15]

William H Press, William T Vetterling, Saul A Teukolsky, and Brian P Flannery. 1988. Numerical recipes. Cambridge University Press, London, England

1988
[16]

Shuo Ren, Daya Guo, Shuai Lu, Long Zhou, Shujie Liu, Duyu Tang, Neel Sundaresan, Ming Zhou, Ambrosio Blanco, and Shuai Ma. 2020. Codebleu: a method for automatic evaluation of code synthesis. arXiv preprint arXiv:2009.10297

2020 arXiv
[17]

Hugo Touvron, Thibaut Lavril, Gautier Izacard, Xavier Martinet, Marie-Anne Lachaux, Timoth \'e e Lacroix, Baptiste Rozi \`e re, Naman Goyal, Eric Hambro, Faisal Azhar, et al. 2023. Llama: Open and efficient foundation language models. arXiv preprint arXiv:2302.13971

2023 arXiv
[18]

Aaron van den Oord, Yazhe Li, and Oriol Vinyals. 2018. Representation learning with contrastive predictive coding. arXiv preprint arXiv:1807.03748

2018 arXiv
[19]

Feng Wang and Huaping Liu. 2021. Understanding the behaviour of contrastive loss. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pages 2495--2504

2021

Pith tools

Reviewed August 11, 2026 · model on record in the stance chip above.

[1] [1]

online" 'onlinestring :=

ENTRY address archivePrefix author booktitle chapter edition editor eid eprint eprinttype howpublished institution journal key month note number organization pages publisher school series title type volume year doi pubmed url lastchecked label extra.label sort.label short.list INTEGERS output.state before.all mid.sentence after.sentence after.block STRING...

[2] [2]

write newline

" write newline "" before.all 'output.state := FUNCTION n.dashify 't := "" t empty not t #1 #1 substring "-" = t #1 #2 substring "--" = not "--" * t #2 global.max substring 't := t #1 #1 substring "-" = "-" * t #2 global.max substring 't := while if t #1 #1 substring * t #2 global.max substring 't := if while FUNCTION word.in bbl.in capitalize " " * FUNCT...

[3] [3]

Manish Bhattarai, Javier E Santos, Shawn Jones, Ayan Biswas, Boian Alexandrov, and Daniel O'Malley. 2024. Enhancing code translation in language models with few-shot learning via retrieval-augmented generation. arXiv preprint arXiv:2407.19619

arXiv 2024

[4] [4]

Mark Chen, Jerry Tworek, Heewoo Jun, Qiming Yuan, Henrique Ponde De Oliveira Pinto, Jared Kaplan, Harri Edwards, Yuri Burda, Nicholas Joseph, Greg Brockman, et al. 2021. Evaluating large language models trained on code. arXiv preprint arXiv:2107.03374

arXiv 2021

[5] [5]

Zhangyin Feng, Daya Guo, Duyu Tang, Nan Duan, Xiaocheng Feng, Ming Gong, Linjun Shou, Bing Qin, Ting Liu, Daxin Jiang, and Ming Zhou. 2020. https://doi.org/10.18653/v1/2020.findings-emnlp.139 C ode BERT : A pre-trained model for programming and natural languages . In Findings of the Association for Computational Linguistics: EMNLP 2020, pages 1536--1547, ...

doi:10.18653/v1/2020.findings-emnlp.139 2020

[6] [6]

Prannay Khosla, Piotr Teterwak, Chen Wang, Aaron Sarna, Yonglong Tian, Phillip Isola, Aaron Maschinot, Ce Liu, and Dilip Krishnan. 2020. Supervised contrastive learning. Advances in neural information processing systems, 33:18661--18673

2020

[7] [7]

Philipp Koehn. 2009. Statistical machine translation. Cambridge University Press

2009

[8] [8]

Bin Lei, Caiwen Ding, Le Chen, Pei-Hung Lin, and Chunhua Liao. 2023. Creating a dataset for high-performance computing code translation using llms: A bridge between openmp fortran and c++. In 2023 IEEE High Performance Extreme Computing Conference (HPEC), pages 1--7. IEEE

2023