Large Language Models trained on code corpora (code-LLMs) have demonstrated
impressive performance in various coding assistance tasks. However, despite
their increased size and training dataset, code-LLMs still have limitations
such as suggesting codes with syntactic errors, variable misuse etc. Some
studies argue that code-LLMs perform well on coding tasks because they use
self-attention and hidden representations to encode relations among input
tokens. However, previous works have not studied what code properties are not
encoded by code-LLMs. In this paper, we conduct a fine-grained analysis of
attention maps and hidden representations of code-LLMs. Our study indicates
that code-LLMs only encode relations among specific subsets of input tokens.
Specifically, by categorizing input tokens into syntactic tokens and
identifiers, we found that models encode relations among syntactic tokens and
among identifiers, but they fail to encode relations between syntactic tokens
and identifiers. We also found that fine-tuned models encode these relations
poorly compared to their pre-trained counterparts. Additionally, larger models
with billions of parameters encode significantly less information about code
than models with only a few hundred million parameters.

研究发现，大型语言模型（code-LLMs）只能编码特定子集的输入令牌之间的关系，并且无法编码语法令牌与标识符之间的关系。此外，与预训练模型相比，微调模型对这些关系的编码较差，并且拥有数十亿参数的更大模型对于代码信息的编码显著较少。

代码 - LLMs（不）学习的重要研究

A Critical Study of What Code-LLMs (Do Not) Learn

Large language models of code (Code-LLMs) have recently brought tremendous
advances to code completion, a fundamental feature of programming assistance
and code intelligence. However, most existing works ignore the possible
presence of bugs in the code context for generation, which are inevitable in
software development. Therefore, we introduce and study the buggy-code
completion problem, inspired by the realistic scenario of real-time code
suggestion where the code context contains potential bugs -- anti-patterns that
can become bugs in the completed program. To systematically study the task, we
introduce two datasets: one with synthetic bugs derived from semantics-altering
operator changes (buggy-HumanEval) and one with realistic bugs derived from
user submissions to coding problems (buggy-FixEval). We find that the presence
of potential bugs significantly degrades the generation performance of the
high-performing Code-LLMs. For instance, the passing rates of CodeGen-2B-mono
on test cases of buggy-HumanEval drop more than 50% given a single potential
bug in the context. Finally, we investigate several post-hoc methods for
mitigating the adverse effect of potential bugs and find that there remains a
large gap in post-mitigation performance.

介绍和研究有潜在 bug 的代码补全问题，引入两个数据集，发现潜在 bug 显著降低 Code-LLMs 的性能，调查了几种后处理方法，但效果有限。

大型语言模型在完成可能存在漏洞的代码上表现不佳

Large Language Models of Code Fail at Completing Code with Potential  Bugs

Causal reasoning, the ability to identify cause-and-effect relationship, is
crucial in human thinking. Although large language models (LLMs) succeed in
many NLP tasks, it is still challenging for them to conduct complex causal
reasoning like abductive reasoning and counterfactual reasoning. Given the fact
that programming code may express causal relations more often and explicitly
with conditional statements like ``if``, we want to explore whether Code-LLMs
acquire better causal reasoning abilities. Our experiments show that compared
to text-only LLMs, Code-LLMs with code prompts are significantly better in
causal reasoning. We further intervene on the prompts from different aspects,
and discover that the programming structure is crucial in code prompt design,
while Code-LLMs are robust towards format perturbations.

研究人员比较了基于文本和代码的大型语言模型对因果推理的能力，结果表明，相较于只针对文本的模型，基于代码编写的模型在因果推理方面更为出色。

探究大型编程语言模型的因果推理能力中的 IF 魔术

The Magic of IF: Investigating Causal Reasoning Abilities in Large  Language Models of Code

Large language models (LLMs) pre-trained on massive corpora have demonstrated
impressive few-shot learning ability on many NLP tasks. A common practice is to
recast the task into a text-to-text format such that generative LLMs of natural
language (NL-LLMs) like GPT-3 can be prompted to solve it. However, it is
nontrivial to perform information extraction (IE) tasks with NL-LLMs since the
output of the IE task is usually structured and therefore is hard to be
converted into plain text. In this paper, we propose to recast the structured
output in the form of code instead of natural language and utilize generative
LLMs of code (Code-LLMs) such as Codex to perform IE tasks, in particular,
named entity recognition and relation extraction. In contrast to NL-LLMs, we
show that Code-LLMs can be well-aligned with these IE tasks by designing
code-style prompts and formulating these IE tasks as code generation tasks.
Experiment results on seven benchmarks show that our method consistently
outperforms fine-tuning moderate-size pre-trained models specially designed for
IE tasks (e.g., UIE) and prompting NL-LLMs under few-shot settings. We further
conduct a series of in-depth analyses to demonstrate the merits of leveraging
Code-LLMs for IE tasks.

本文提出利用 Code-LLMs 如 Codex 代替 NL-LLMs，通过设计以代码为形式的提示和将 IE 任务制定为代码生成任务，有效地解决了信息提取任务的难题，并在七个基准测试中显示其优越性。