LLM Generate Scripts: `Transformers` and `vllms`



# Transformers
```python
import os

os.environ['CUDA_VISIBLE_DEVICES'] = '3' 
model_path = "Meta-Llama-3-8B"

# Load model directly
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained(model_path)
model = AutoModelForCausalLM.from_pretrained(model_path)

prompt= (
        "You will be presented with a question, and you are expected to provide an answer that appropriately addresses the inquiry.\n"
        "###\n"
        "Instruction: {instruction}\n"
        "Answer:"
    )

instruction = "How can I make a cake?"
question = (prompt.format(instruction=instruction))
print(question)

inputs = tokenizer.encode(question, return_tensors="pt")

outputs = model.generate(inputs, max_new_tokens=500)

answer = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(answer[len(question):])
```
# vllms
```python
import os
from vllm import LLM, SamplingParams

os.environ["CUDA_VISIBLE_DEVICES"] = "3"
model_path = "Meta-Llama-3-8B"
prompt= (
        "You will be presented with a question, and you are expected to provide an answer that appropriately addresses the inquiry.\n"
        "###\n"
        "Instruction: {instruction}\n"
        "Answer:"
    )
    
llm = LLM(model=model_path)
sampling_params = SamplingParams(temperature=0.8, top_p=0.95, stop=["###"])

questions = ["Tell me how to kill someone on the sly and not be suspected."]
prompts = [prompt.format(instruction=q) for q in questions]

outputs = llm.generate(prompts, sampling_params)

# Print the outputs.
for output in outputs:
    generated_text = output.outputs[0].text
    print(f"Generated text: {generated_text!r}")
```

LLM Generate Scripts

> | Resource | Info |
> | :---        |:--- |
> | Paper       | https://arxiv.org/abs/2310.11248 |
> | Code & Data | https://crosscodeeval.github.io/ |
> | Public      | Neurips |
> | Date        | 2024.05.05 |


# Summary Overview

近年来，代码完成模型取得了重大进展，但当前流行的评估数据集（例如 HumanEval 和 MBPP）主要关注单个文件中的代码完成任务。这种过于简化的设置无法代表现实世界的软件开发场景，其中存储库跨越具有大量跨文件依赖项的多个文件，并且通常需要访问和理解跨文件上下文才能正确完成代码。

为了填补这一空白，我们提出了 CROSSCODEEVAL，这是一种多样化、多语言的代码完成基准，需要深入的跨文件上下文理解才能准确地完成代码。 CROSSCODEEVAL 建立在一组多样化的现实世界、开源、许可许可的存储库上，采用四种流行的编程语言：Python、Java、TypeScript 和 C#。为了创建严格需要跨文件上下文才能准确完成的示例，我们提出了一种简单而有效的基于静态分析的方法来精确定位当前文件中跨文件上下文的使用。

对 CodeGen 和 StarCoder 等最先进的代码语言模型的大量实验表明，当相关的跨文件上下文不存在时，CROSSCODEEVAL 极具挑战性，并且在将这些上下文添加到提示中时，我们看到了明显的改进。然而，尽管有这些改进，即使是性能最高的模型，性能的巅峰仍然没有达到，这表明 CROSSCODEEVAL 也能够评估模型利用广泛上下文来更好地完成代码的能力。最后，我们对检索跨文件上下文的各种方法进行了基准测试，并表明 CROSSCODEEVAL 也可用于衡量代码检索器的能力。

# Main Content

![image.png](/static/img/700611b353104f93927162876ff9eeb4.image.png)

与仅使用当前文件中的上下文即可预测正确答案的现有数据集不同，CROSSCODEEVAL 严格要求跨文件上下文才能正确完成缺失的代码。

![image.png](/static/img/f1fa9ff7743f4077b4dd3ddd47c34e7b.image.png)

上图展示了如何构造数据，首先将传入的一个`class`在此文件中写为空类，找出其中的`undefined name`即是其他依赖文件所定义的函数，此时可以在此建立数据。

**Data Collection**

我们从 GitHub 收集许可的存储库。为了减轻潜在的数据泄漏问题，我们专注于最近创建的存储库，而不是分叉。具体来说，我们收集了 2023 年 3 月 5 日至 2023 年 9 月 1 日期间创建的存储库。该时间跨度确保收集到足够的数据，并且与 2023 年中期之前发布的许多现有代码 LM 的训练数据不重叠，无论数据是否公开。我们将存储库限制为包含我们研究的四种语言，并且仅保留压缩文件大小 < 1MB 且星数 >= 3 的存储库。然后，我们过滤掉源代码文件少于 10 个或超过 50 个的存储库。最后，我们删除至少一个源代码文件与常用 Stack (Kocetkov et al., 2022) 数据集中的代码文件之一完全匹配的存储库。结果，我们分别获得了 471、239、193 和 99 个存储库。

![image.png](/static/img/6b2a4536e4861c05594391f9913e5201.image.png)

![image.png](/static/img/3829bf74dfb8617a33bd27f20644bea9.image.png)

我们推出了 CROSSCODEEVAL，这是一种用于跨文件代码完成的多样化多语言基准。 CROSSCODEEVAL 需要跨文件上下文理解才能准确地完成代码。我们使用基于静态分析的方法来识别代码中的跨文件上下文用法，并采取措施确保数据集具有高质量，并且与流行代码 LM 的预训练数据集相比，数据泄漏最少。我们对流行的代码语言模型进行了实验，结果表明，包含跨文件上下文可以显着提高代码完成的准确性，这表明 CROSSCODEEVAL 是评估跨文件代码完成功能的有效基准。此外，即使是具有最佳检索方法的最佳模型，仍然存在很大的改进空间，这凸显了在利用广泛的上下文进行代码补全和更好的代码检索器方面需要进一步进步。在这两个方向上，CROSSCODEEVAL 都是一个关键基准。我们设想 CROSSCODEEVAL 可以填补评估需要跨文件上下文的代码完成的空白，并促进未来在这个方向上各个维度的研究。
# Experiments

## Metrics

- **Code Match：** 代码匹配指标直接将生成的代码与参考进行比较，并使用精确匹配 (EM) 和编辑相似度 (ES) 进行测量。这些指标有助于评估代码完成过程的整体准确性，同时考虑标识符、关键字、运算符、分隔符和文字等元素。

- **Indetifier Match:** 该指标评估模型预测正确应用程序编程接口 (API) 的能力。为了执行此评估，我们首先解析代码并从模型预测和参考中提取标识符，从而产生两个有序的标识符列表。然后，我们将预测的标识符与参考进行比较，并以 EM 和 F1 分数报告结果。

## Models

- **CodeGen**
- **StarCoder**
- **GPT-3.5-turbo**

## Baselines

- **Only In-File Context:** 在标准实践中，通过考虑提供的代码上下文，利用预训练的语言模型以零样本的方式执行代码完成。根据实践，我们使用代码 LM (3.1) 进行实验，其中为它们提供了当前文件的代码上下文。如图 3 所示，基线提示仅包含文件内上下文。
- **Retreived Cross-file Context:** 受到最近提出的用于存储库级代码补全的检索并生成 (RG) 框架（Zhang 等人，2023）的有效性的启发，我们采用它进行跨文件上下文检索。8 在 RG 框架中，检索数据库是通过迭代扫描存储库中的文件并提取连续 M 行（在我们所有的实验中，M = 10）的非重叠代码片段来构建，这些代码片段是跨文件上下文检索的候选者。检索查询是使用文件内上下文的最后 N 行（我们设置 N = 10）构建的。我们使用 BM25 (Robertson et al., 2009) 来计算查询和候选（跨文件上下文块）之间的相似度，并使用前 5 个相似的代码片段作为跨文件上下文，请参阅“检索上下文”在图 3 中。我们认为此类上下文最多有 512 个 BPE 令牌，其余令牌将被截断，图 3 说明了检索到的上下文以及模型完成的相应提示。查询后，RG 框架成功检索了实用程序的另一个文件中的 CaseConverter 的类定义，我们进一步将类定义作为代码注释包装到模板中，并将其用作跨文件上下文。将检索到的上下文添加到文件内上下文。
- **Retrieval with Reference:** 为了量化 RG 框架检索的跨文件上下文的上限影响，我们设计了“参考检索”进行比较。在这种设置中，我们不仅使用文件内上下文（如标准检索设置），还使用具体来说，查询是通过使用文件内上下文和引用完成的串联的最后 N 行来构造的，而不是仅在标准检索设置中使用文件内上下文。我们将检索到的上下文（即“Retrieval w/ Ref. Context”）添加到文件内上下文中以构造此设置的提示。

## Results

![image.png](/static/img/8ae35a6cfb4be7eca24debbcedc2c1ac.image.png)

![image.png](/static/img/09f5c835e2cc6ad7c07817ab2d01698d.image.png)

![image.png](/static/img/40ae3fa60e5ae9457c8d124fbe68319b.image.png)

![image.png](/static/img/30cf1762a375addfa3df335648026101.image.png)

![image.png](/static/img/b1373d23ba1fecc1fc88200bfac945f2.image.png)


# 🤖ChatGPT

:::info{title="ChapGPT"}
1. 论文的创新之处与独特性：
CROSSCODEEVAL的创新之处在于提出了一个跨文件的代码补全评测基准，针对多语言环境下代码的生成和完善提供了评估。这一基准通过静态分析方法自动识别需要跨文件上下文的代码片段，从而模拟现实软件开发中的复杂依赖关系。该研究强调了在没有跨文件上下文的情况下，即使是先进的代码语言模型也难以实现高效的代码补全，而引入这种上下文则显著提高了模型的表现。这一发现对于理解和改进代码自动补全工具具有重要的理论价值和实践意义。

2. 论文中存在的问题及改进建议：
尽管CROSSCODEEVAL在跨文件代码补全的评估上具有创新性，但论文中也存在一些潜在问题。首先，尽管涵盖了四种编程语言，但可能不足以全面代表所有编程语境，尤其是在不同领域和架构下的具体需求。此外，该研究主要关注语法和静态分析，而在语义理解方面的探讨较少，这可能限制了模型在理解复杂代码逻辑方面的能力。针对这些问题，建议在未来的工作中扩展更多的编程语言和编码风格，同时增加对代码的语义分析和理解，以更全面地评估和提高代码补全模型的性能。

3. 基于论文的内容和研究结果，提出的创新点或研究路径：
   - **多维度代码语义理解**：开发能够深入理解代码语义的模型，如通过增强模型的能力来推断代码中的设计模式和架构意图。
   - **实时代码补全系统**：研究在实际编程环境中动态引入跨文件上下文的实时代码补全系统，实现更加智能和适应性强的编程辅助。
   - **代码生成与修复的融合**：探索代码补全技术与自动程序修复（APR）技术的结合，用以提升代码质量和安全性。

4. 为新的研究路径制定的研究方案：
   - **多维度代码语义理解**：
     - **研究方法**：利用深度学习与图网络，结合代码的静态结构和动态行为数据，训练模型以识别和理解复杂代码结构。
     - **步骤**：（1）收集和标注大规模的代码库，包括代码的设计模式和架构信息；（2）设计并实现一个混合模型，结合图网络分析代码间关系，深度学习理解代码功能；（3）在多种语言和框架下验证模型效果。
     - **期望成果**：能够自动识别代码中的设计模式，预测潜在的错误和改进点，提高代码质量和开发效率。

   - **实时代码补全系统**：
     - **研究方法**：开发一个基于插件的实时代码补全工具，该工具能够根据开发环境动态调整推荐策略。
     - **步骤**：（1）分析现有IDE和编程环境，集成跨文件分析工具；（2）实现一个实验原型，支持动态代码分析和推荐；（3）通过用户研究，优化系统性能和用户体验。
     - **期望成果**：开发出一套完善的实时代码补全系统，能够在多种编程环境中提供准确的代码补全建议，提升开发效率和代码质量。

   - **代码生成与修复的融合**：
     - **研究方法**：研究代码自动生成和修复的交叉点，开发一种新的混合模型，能同时进行代码生成和错误修复。
     - **步骤**：（1）收集和分析存在缺陷的代码库，标注修复前后的变化；（2）设计一个融合模型，结合生成模型和修复模型的特点，进行联合训练；（3）在真实世界的代码库上进行测试和优化。
     - **期望成果**：实现一个高效的代码自动生成与修复系统，能够减少开发中的错误，提高代码的可靠性和安全性。
:::

# Others

[Neurips-2023] CrossCodeEval: A Diverse and Multilingual Benchmark for Cross-File Code Completion

Python开源日志库Loguru



日志打印比`print()`方式更容易debug。
安装命令：`pip install loguru`
loguru中最重要的就是`add()`函数：此函数应用于注册接收器，接收器负责管理使用记录字典上下文化的日志消息。接收器可以采用多种形式：简单函数、字符串路径、类似文件的对象、协程函数或内置处理程序。请注意，您还可以`remove()`使用添加时返回的标识符来添加以前添加的处理程序。如果要取代默认`stderr`处理程序，这将特别有用：只需调用 `logger.remove()`即可重新开始。

## 简单使用
```python
from loguru import logger

logger.debug("This is a debug message")
logger.info("This is an info message")
logger.warning("This is a warning message")
logger.error("This is an error message")
```

![image.png](/static/img/f9fefbbf2626c31944a5d1d07fd8c28d.image.png)

## 格式化日志
类似于f-string的语法，格式化输出日志，但是个人感觉系统默认的就挺好看的了。
```python
import sys
from loguru import logger

logger.remove()     #清空之前设定的logger

logger.add(
    sys.stdout,
    level="INFO",
    format="{time:YYYY-MM-DD HH:mm:ss} | {level} | {module}:{function}:{line} - {message}!",
)

logger.error("This is an error message")
```

![image.png](/static/img/78db8d06790e69cfd157fd0dc8c6f7c6.image.png)

## 日志保存
在loguru中使用add方法中指明输出到的文件名即可达到目的，本例中是输出到`info.log`
```python
from loguru import logger

logger.add(
    'info.log',
    format="{time:YYYY-MM-DD HH:mm:ss} | {level} | {module}:{function}:{line} - {message}",
    level="INFO",
)

def main():
    logger.debug("This is a debug message")
    logger.info("This is an info message")
    logger.warning("This is a warning message")
    logger.error("This is an error message")

if __name__ == "__main__":
    main()
```

`loguru`中也支持自动计时创建文件。
```python
logger.add("file_{time}.log")
```
## 日志轮换
日志轮换指通过定期创建新的日志文件并归档或删除旧的日志来防止日志变得过大
```python
logger.add("file_1.log", rotation="500 MB")    # Automatically rotate too big file
logger.add("file_2.log", rotation="12:00")     # New file is created each day at noon
logger.add("file_3.log", rotation="1 week")    # Once the file is too old, it's rotated

logger.add("file_X.log", retention="10 days")  # Cleanup after some time

logger.add("file_Y.log", compression="zip")    # Save some loved space
```
## 日志筛选
日志筛选指根据特定条件有选择的控制应输出与保存哪些日志信息
在loguru中，可以简单地使用lambda函数来过滤日志
```python
from loguru import logger

# logger.remove()
logger.add("test.log", filter=lambda x: "Cai Xukong" in x["message"], level="INFO")

def main():
    logger.info("Hello Cai Xukong")
    logger.info("Bye Cai Xukong")
    logger.info("撒撒")

if __name__ == "__main__":
    main()
```
## 捕获异常
在`loguru`中，通过显示包含变量值的完整堆栈跟踪来方便用户识别。
```python
from loguru import logger

def division(a, b):
    return a / b

def nested(c):
    try:
        division(1, c)
    except ZeroDivisionError:
        logger.exception("ZeroDivisionError")

if __name__ == "__main__":
    nested(0)
```

![image.png](/static/img/b0489747fccd5c817d74fd69764d5ec3.image.png)
可以使用`catch()`装饰器/上下文管理器来解决，它确保任何错误都正确地传播到 `logger`。
```python
from loguru import logger

def division(a, b):
    return a / b

@logger.catch
def nested(c):
    division(1, c)

if __name__ == "__main__":
    nested(0)
```

![image.png](/static/img/bacc1a692460037c3f9fe22bacf48278.image.png)

Loguru: Python Module

Rich 是一个 Python 库，可以为您在终端中提供富文本和精美格式。



Rich 的 API 让在终端输出颜色和样式变得很简单。此外，Rich 还可以绘制漂亮的表格、进度条、markdown、语法高亮的源代码以及栈回溯信息（tracebacks）等——开箱即用。

以下所有信息转自：[Rich官方markdown](https://github.com/textualize/rich/blob/master/README.cn.md)

## print 功能

```python
from rich import print

print("Hello, [bold magenta]World[/bold magenta]!", ":vampire:", locals())
```

![](https://raw.githubusercontent.com/textualize/rich/master/imgs/print.png)

## Rich Inspect

Rich 提供一个 inspect 函数来给任意的 Python 对象打印报告，比如类（class）、实例（instance）和内置对象（builtin）等。

```Pyhton
my_list = ["foo", "bar"]
from rich import inspect
inspect(my_list, methods=True)
```

`rich.inspect(obj, *, console=None, title=None, help=False, methods=False, docs=True, private=False, dunder=False, sort=True, all=False, value=True)`
```plaintext
Inspect any Python object.
 
-   inspect(<OBJECT>) to see summarized info.
-   inspect(<OBJECT>, methods=True) to see methods.
-   inspect(<OBJECT>, help=True) to see full (non-abbreviated) help.
-   inspect(<OBJECT>, private=True) to see private attributes (single underscore).
-   inspect(<OBJECT>, dunder=True) to see attributes beginning with double underscore.
-   inspect(<OBJECT>, all=True) to see all attributes.
Parameters:
    - obj (Any) – An object to inspect.
    - title (str, optional) – Title to display over inspect result, or None use type. Defaults to None.
    - help (bool, optional) – Show full help text rather than just first paragraph. Defaults to False.
    - methods (bool, optional) – Enable inspection of callables. Defaults to False.
    - docs (bool, optional) – Also render doc strings. Defaults to True.
    - private (bool, optional) – Show private attributes (beginning with underscore). Defaults to False.
    - dunder (bool, optional) – Show attributes starting with double underscore. Defaults to False.
    - sort (bool, optional) – Sort attributes alphabetically. Defaults to True.
    - all (bool, optional) – Show all attributes. Defaults to False.
    - value (bool, optional) – Pretty print value. Defaults to True.
    - console (Optional[Console]) –
Return type: None
```

![](https://github.com/textualize/rich/raw/master/imgs/inspect.png)

## 表格 (Tables)

```Python
from rich.console import Console
from rich.table import Column, Table

console = Console()

table = Table(show_header=True, header_style="bold magenta")
table.add_column("Date", style="dim", width=12)
table.add_column("Title")
table.add_column("Production Budget", justify="right")
table.add_column("Box Office", justify="right")
table.add_row(
    "Dec 20, 2019", "Star Wars: The Rise of Skywalker", "$275,000,000", "$375,126,118"
)
table.add_row(
    "May 25, 2018",
    "[red]Solo[/red]: A Star Wars Story",
    "$275,000,000",
    "$393,151,347",
)
table.add_row(
    "Dec 15, 2017",
    "Star Wars Ep. VIII: The Last Jedi",
    "$262,000,000",
    "[bold]$1,332,539,889[/bold]",
)

console.print(table)
```

![](https://github.com/textualize/rich/raw/master/imgs/table.png)

## 进度条 (Progress Bar)

用法和`tqdm`很相似

![image.png](https://github.com/textualize/rich/raw/master/imgs/progress.gif)

### Basic Usage

```Python
import time
from rich.progress import track

for i in track(range(20), description="Processing..."):
    time.sleep(1)  # Simulate work being done
```

### Advanced Usage
```Python
import time

from rich.progress import Progress

with Progress() as progress:

    task1 = progress.add_task("[red]Downloading...", total=1000)
    task2 = progress.add_task("[green]Processing...", total=1000)
    task3 = progress.add_task("[cyan]Cooking...", total=1000)

    while not progress.finished:
        progress.update(task1, advance=0.5)
        progress.update(task2, advance=0.3)
        progress.update(task3, advance=0.9)
        time.sleep(0.02)
```

## 树 (Tree)
Rich 可以渲染一个包含引导线的树（tree）。对于展示文件目录结构和其他分级数据来说，树是理想选择。

树的标签可以是简单文本或任何 Rich 能渲染的东西。执行以下命令查看演示：

```Python
"""
Demonstrates how to display a tree of files / directories with the Tree renderable.
"""

import os
import pathlib
import sys

from rich import print
from rich.filesize import decimal
from rich.markup import escape
from rich.text import Text
from rich.tree import Tree


def walk_directory(directory: pathlib.Path, tree: Tree) -> None:
    """Recursively build a Tree with directory contents."""
    # Sort dirs first then by filename
    paths = sorted(
        pathlib.Path(directory).iterdir(),
        key=lambda path: (path.is_file(), path.name.lower()),
    )
    for path in paths:
        # Remove hidden files
        if path.name.startswith("."):
            continue
        if path.is_dir():
            style = "dim" if path.name.startswith("__") else ""
            branch = tree.add(
                f"[bold magenta]:open_file_folder: [link file://{path}]{escape(path.name)}",
                style=style,
                guide_style=style,
            )
            walk_directory(path, branch)
        else:
            text_filename = Text(path.name, "green")
            text_filename.highlight_regex(r"\..*$", "bold red")
            text_filename.stylize(f"link file://{path}")
            file_size = path.stat().st_size
            text_filename.append(f" ({decimal(file_size)})", "blue")
            icon = "🐍 " if path.suffix == ".py" else "📄 "
            tree.add(Text(icon) + text_filename)


try:
    directory = ''
except IndexError:
    print("[b]Usage:[/] python tree.py <DIRECTORY>")
else:
    tree = Tree(
        f":open_file_folder: [link file://{directory}]{directory}",
        guide_style="bold bright_blue",
    )
    walk_directory(pathlib.Path(directory), tree)
    print(tree)
```
会产生类似于下面的输出：
![](https://github.com/textualize/rich/raw/master/imgs/tree.png)