Left: the proportion of programming languages in CodeGeeX's training data. Right: the plot of training loss against the training steps of CodeGeeX.
**Code Corpus**: Our training data contains two parts. The first part is from open-sourced code datasets, [The Pile](https://pile.eleuther.ai/) and [CodeParrot](https://github.com/huggingface/transformers/tree/main/examples/research_projects/codeparrot). The Pile contains a subset of code corpus that collects public repositories with more than 100 stars from GitHub, from which we select codes in 23 popular programming languages. The second part is supplementary data directly scrapped from the public GitHub repositories that do not appear in previous datasets, including Python, Java and C++. To obtain data of potentially higher quality, repositories with at least one star and its size smaller than 10MB are chosen. A file is filtered out if it 1) has more than 100 characters per line on average, 2) is automatically generated, 3) has a ratio of alphabet less than 40%, or 4) is bigger than 100KB or smaller than 1KB. To help the model distinguish different languages, we add a language-specific prefix at the beginning of each segment in the form of ``[Comment sign] language: [LANG]``, e.g., ``# language: Python``. For tokenization, we use the same tokenizer as GPT-2 and process whitespaces as extra tokens, resulting in a vocabulary of 50,400 tokens. In total, the code corpus has 23 programming languages with 158.7B tokens. **Training**: We implement CodeGeeX in [Mindspore 1.7](https://www.mindspore.cn/) and train it on 1,536 Ascend 910 AI Processor (32GB). The model weights are under FP16 format, except that we use FP32 for layer-norm and softmax for higher precision and stability. The entire model consumes about 27GB of memory. To increase the training efficiency, we adopt an 8-way model parallel training together with 192-way data parallel training, with ZeRO-2 optimizer enabled. The micro-batch size is 16 and the global batch size reaches 3,072. Moreover, we adopt techniques to further boost the training efficiency including the element-wise operator fusion, fast gelu activation, matrix multiplication dimension optimization, etc. The entire training process takes nearly two months, spanning from April 18 to June 22, 2022, during which 850B tokens were passed for training, i.e., 5+ epochs. ## HumanEval-X: A new benchmark for Multilingual Program Synthesis To better evaluate the multilingual ability of code generation models, we propose a new benchmark HumanEval-X. While previous works evaluate multilingual program synthesis under semantic similarity (e.g., [CodeBLEU](https://arxiv.org/abs/2009.10297)) which is often misleading, HumanEval-X evaluates the functional correctness of the generated programs. HumanEval-X consists of 820 high-quality human-crafted data samples (each with test cases) in Python, C++, Java, JavaScript, and Go, and can be used for various tasks.
An illustration of tasks supported by HumanEval-X. Declarations, docstrings, and solutions are marked with red, green, and blue respectively. Code generation uses declaration and docstring as input, to generate solution. Code translation uses declaration in both languages and translate the solution in source language to the one in target language.
In HumanEval-X, every sample in each language contains declaration, docstring, and solution, which can be combined in various ways to support different downstream tasks including generation, translation, summarization, etc. We currently focus on two tasks: **code generation** and **code translation**. For code generation, the model uses declaration and docstring as input to generate the solution. For code translation, the model uses declarations in both languages and the solution in the source language as input, to generate solutions in the target language. We remove the description during code translation to prevent the model from directly solving the problem. For both tasks, we use the unbiased pass@k metric proposed in [Codex](https://arxiv.org/abs/2107.03374): $\text{pass}@k:= \mathbb{E}[1-\frac{\tbinom{n-c}{k}}{\tbinom{n}{k}}]$, with $n=200$ and $k\in(1,10,100)$. ### Multilingual Code Generation
Left: the detailed pass@k (k=1,10,100) performance on code generation task for five languages in HumanEval-X. Right: the average performance of all languages of each model. CodeGeeX achieves the highest average performance compared with InCoder-6.7B, CodeGen-Multi-6B and CodeGen-Multi-16B.
We compare CodeGeeX with two other open-sourced code generation models, [InCoder](https://github.com/dpfried/incoder) (from Meta) and [CodeGen](https://github.com/salesforce/CodeGen) (from Salesforce). Specifically, InCoder-6.7B, CodeGen-Multi-6B and CodeGen-Multi-16B are considered. CodeGeeX significantly outperforms models with smaller scales (by 7.5%~16.3%) and is competitive with CodeGen-Multi-16B with a larger scale (average performance 54.76% vs. 54.39%). CodeGeeX achieves the best average performance across languages. ### Crosslingual Code Translation
Results on HumanEval-X code translation task. Best language-wise performance are bolded.
We also evaluate the performance of translation across different programming languages. We test the zero-shot performance of CodeGeeX, as well as the fine-tuned CodeGeeX-13B-FT (fine-tuned using the training set of code translation tasks in [XLCoST](https://github.com/reddy-lab-code-research/XLCoST); Go is absent in the original set, we thus add a small set to it). The results indicate that models have a preference for languages, e.g., CodeGeeX is good at translating other languages to Python and C++, while CodeGen-Multi-16B is better at translating to JavaScript and Go; these could probably be due to the difference in language distribution in the training corpus. Among 20 translation pairs, we also observe that the performance of A-to-B and B-to-A are always negatively correlated, which might indicate that the current models are still not capable of learning all languages well. ### How to use HumanEval-X and contribute to it? For more details on how to use HumanEval-X, please see [usage](codegeex/benchmark/README.md). We highly welcome the community to contribute to HumanEval-X by adding more problems or extending it to other languages, please check out the [standard format](codegeex/benchmark/README.md#how-to-use-humaneval-x) of HumanEval-X and add a pull request. Please kindly let us know if you have any comment or suggestion, via [codegeex@aminer.cn](mailto:codegeex@aminer.cn).Examples of Generation
Acknowledgement
This project is supported by the National Science Foundation for Distinguished Young Scholars (No. 61825602). ### Lead Contributors Qinkai Zheng ([Tsinghua KEG](http://keg.cs.tsinghua.edu.cn/glm-130b/)), Xiao Xia (Tsinghua KEG), Xu Zou (Tsinghua KEG) ### Contributors Tsinghua KEG---The Knowledge Engineering Group at Tsinghua: Aohan Zeng, Wendi Zheng, Lilong Xue Zhilin Yang's Group at Tsinghua IIIS: Yifeng Liu, Yanru Chen, Yichen Xu (BUPT, work was done when visiting Tsinghua) Peng Cheng Laboratory: Qingyu Chen, Zhongqi Li, Gaojun Fan Zhipu\.AI: Yufei Xue, Shan Wang, Jiecai Shan, Haohan Jiang, Lu Liu, Xuan Xue, Peng Zhang Ascend and Mindspore Team: Yifan Yao, Teng Su, Qihui Deng, Bin Zhou ### Data Annotations Ruijie Cheng (Tsinghua), Peinan Yu (Tsinghua), Jingyao Zhang (Zhipu\.AI), Bowen Huang (Zhipu\.AI), Shaoyu Wang (Zhipu\.AI) ### Advisors [Zhilin Yang](https://kimiyoung.github.io/) (Tsinghua IIIS), Yuxiao Dong (Tsinghua KEG), Wenguang Chen (Tsinghua PACMAN), Jie Tang (Tsinghua KEG) ### Computation Sponsors [Peng Cheng Laboratory](https://www.pcl.ac.cn/index.html) [Zhipu.AI](https://www.zhipu.ai/)---an AI startup that aims to teach machines to think like humans ### Project Leader [Jie Tang](http://keg.cs.tsinghua.edu.cn/jietang/) (Tsinghua KEG & BAAI)
🏠 主页 | 📖 博客 | 🪧 示例 | 🤖 模型下载 | 📄 论文 | 🌐 English
🛠 VS Code, Jetbrains, Cloud Studio 插件 | 👋 欢迎加入 微信开发者交流群
🌟 [CodeGeeX2](https://github.com/THUDM/CodeGeeX2) 已推出，更强，更快，更轻量。 - [CodeGeeX: 多语言代码生成模型](#codegeex-多语言代码生成模型) - [新闻](#新闻) - [使用指南](#使用指南) - [安装](#安装) - [模型权重](#模型权重) - [用GPU进行推理](#用gpu进行推理) - [插件使用指南](#插件使用指南) - [CodeGeeX: 多语言代码生成模型](#codegeex-多语言代码生成模型-1) - [国产平台实现与训练](#国产平台实现与训练) - [HumanEval-X: 多语言代码生成基准](#humaneval-x-多语言代码生成基准) - [多语言代码生成](#多语言代码生成) - [跨语言代码翻译](#跨语言代码翻译) - [许可证](#许可证) - [引用](#引用) # CodeGeeX: 多语言代码生成模型 CodeGeeX是一个具有130亿参数的多编程语言代码生成预训练模型。CodeGeeX采用华为MindSpore框架实现，在鹏城实验室“鹏城云脑II”中的192个节点（共1536个国产[昇腾910 AI处理器](https://e.huawei.com/cn/products/servers/ascend)）上训练而成。截至2022年6月22日，CodeGeeX历时两个月在20多种编程语言的代码语料库（>8500亿Token）上预训练得到。CodeGeeX有以下特点： * **高精度代码生成**：支持生成Python、C++、Java、JavaScript和Go等多种主流编程语言的代码，在HumanEval-X代码生成任务上取得47%~60%求解率，较其他开源基线模型有更佳的平均性能。[代码生成示例](https://models.aminer.cn/codegeex/zh-CN) * **跨语言代码翻译**：支持代码片段在不同编程语言间进行自动翻译转换，翻译结果正确率高，在HumanEval-X代码翻译任务上超越了其它基线模型。[代码翻译示例](https://models.aminer.cn/codegeex/zh-CN/codeTranslator) * **自动编程插件**：CodeGeeX插件现已上架VSCode插件市场（完全免费），用户可以通过其强大的少样本生成能力，自定义代码生成风格和能力，更好辅助代码编写。[插件下载](https://marketplace.visualstudio.com/items?itemName=aminer.codegeex) * **模型跨平台开源**: 所有代码和模型权重开源开放，用作研究用途。CodeGeeX同时支持昇腾和英伟达平台，可在单张昇腾910或英伟达V100/A100上实现推理。[申请模型权重](https://models.aminer.cn/codegeex/download/request) **全新多编程语言评测基准HumanEval-X**：HumanEval-X是第一个支持功能正确性评测的多语言、多任务的基准，包含820个人工编写的高质量代码生成题目、测试用例与参考答案，覆盖5种编程语言（Python、C++、Java、JavaScript、Go），支持代码生成与代码翻译能力的评测。[如何使用](codegeex/benchmark/README_zh.md)
在HumanEval-X代码生成任务上，与其它开源基线模型相比，CodeGeeX取得了最佳的平均性能。
## 新闻 * 🌟 **2023-07-24**: [CodeGeeX2](https://github.com/THUDM/CodeGeeX2) 已推出，更强，更快，更轻量。支持超过100种语言，并具有多种新特性。 * **2023-5-16**: CodeGeeX 论文已被 [KDD 2023, Long Beach](https://kdd.org/kdd2023/) 接收，并将在会上做相关报告。 * **2023-03-30**: CodeGeeX 论文已发表在[arxiv](https://arxiv.org/abs/2303.17568)。 * **2023-02-14**: CodeGeeX 现已支持 [Cloud Studio](https://cloudstudio.net/), 一款腾讯推出、十分好用的在线编辑器。单击此页面顶部的徽章可快速启动环境测试 CodeGeeX。 * **2023-02-13**: 感谢 [OneFlow](https://github.com/Oneflow-Inc/oneflow) 加入了oneflow版推理支持，在FP16下比FasterTransformer还要快！更多优化细节请点击[这里](https://github.com/THUDM/CodeGeeX/pull/65). * **2023-02**: [CodeGeeX "Coding With AI"黑客松](https://dorahacks.io/hackathon/codegeex/)正在进行中，为CodeGeeX设计应用并赢取奖品（RTX 4090、DJI无人机等）！ * **2022-12-31**: 我们在 [codegeex-fastertransformer](https://github.com/CodeGeeX/codegeex-fastertransformer) 中发布了 CodeGeeX 的 FasterTransformer 版本。INT8加速版本达到 <15ms/token 的平均速度。祝大家新年快乐！ * **2022-12-13**: 我们开源了VS Code插件源码：[codegeex-vscode-extension](https://github.com/CodeGeeX/codegeex-vscode-extension)，参考 [QuickStart](https://github.com/CodeGeeX/codegeex-vscode-extension/blob/main/doc/quickstart.md) 开始开发吧！ * **2022-12-11**: CodeGeeX for Jetbrains IDEs已上线，支持IntelliJ IDEA, PyCharm, GoLand, CLion等，[点击下载](https://plugins.jetbrains.com/plugin/20587-codegeex)。 * **2022-12-04**: 我们开源了量化代码（需要更少的显存：27GB -> 15GB）以及模型并行代码（可以运行在多个显存至少8GB的GPUs上）。 * **2022-09-30**: 我们开源了跨平台代码和模型权重，同时支持昇腾和英伟达平台。 ## 使用指南 CodeGeeX最初使用Mindspore框架实现，并在昇腾910AI芯片上进行训练。为适配更多平台，我们将其转换到[Megatron-LM](https://github.com/NVIDIA/Megatron-LM)框架，支持Pytorch+GPU环境。 ### 安装 需要Python 3.7+ / CUDA 11+ / PyTorch 1.10+ / DeepSpeed 0.6+，通过以下命令安装 ``codegeex``: ```bash git clone git@github.com:THUDM/CodeGeeX.git cd CodeGeeX pip install -e . ``` ### 模型权重 通过[该链接](https://models.aminer.cn/codegeex/download/request)申请权重，您将收到一个包含临时下载链接文件```urls.txt```的邮件。推荐使用[aria2](https://aria2.github.io/)通过以下命令快速下载（请保证有足够的硬盘空间存放权重（～26GB））： ```bash aria2c -x 16 -s 16 -j 4 --continue=true -i urls.txt ``` 使用以下命令合并得到完整的权重： ```bash cat codegeex_13b.tar.gz.* > codegeex_13b.tar.gz tar xvf codegeex_13b.tar.gz ``` ### 用GPU进行推理 尝试使用CodeGeeX模型生成第一个程序吧！首先，在配置文件``configs/codegeex_13b.sh``中写明存放权重的路径。其次，将提示（可以是任意描述或代码片段）写入文件``tests/test_prompt.txt``，运行以下脚本即可开始推理（需指定GPU序号）： ```bash # On a single GPU (with more than 27GB RAM) bash ./scripts/test_inference.sh
左侧：CodeGeeX训练数据中各编程语言占比。 右侧：CodeGeeX训练损失函数随训练步数下降曲线。
**语料**：CodeGeeX的训练语料由两部分组成。第一部分是开源代码数据集，[The Pile](https://pile.eleuther.ai/) 与 [CodeParrot](https://github.com/huggingface/transformers/tree/main/examples/research_projects/codeparrot)。The Pile包含GitHub上拥有超过100颗星的一部分开源仓库，我们从中选取了23种编程语言的代码。第二部分是补充数据，直接从GitHub开源仓库中爬取Python、Java、C++代码；为了获取高质量数据，我们根据以下准则选取代码仓库：1)至少拥有1颗星；2)总大小<10MB；3)不在此前的开源代码数据集中。我们还去掉了符合下列任一条件的文件：1)平均每行长度大于100字符；2)由自动生成得到；3)含有的字母不足字母表内的40%；4)大于100KB或小于1KB。为了让模型区分不同语言，我们在每个样本的开头加上一个前缀，其形式为``[注释符] language: [语言]``，例如：``# language: Python``。我们使用与GPT-2相同的分词器，并将空格处理为特殊标识符，词表大小为50400。整个代码语料含有23种编程语言、总计1587亿个标识符（不含填充符）。 ### 国产平台实现与训练 我们在[Mindspore 1.7](https://www.mindspore.cn/)框架上实现了CodeGeeX模型，并使用鹏城实验室的全国产计算平台上进行训练。具体来说，CodeGeeX使用了其一个计算集群中的1536个昇腾910 AI处理器（32GB）进行了两个月左右的训练（2022年4月18日至6月22日）。除了Layer-norm与Softmax使用FP32格式以获得更高的精度与稳定性，模型参数整体使用FP16格式，最终整个模型需要占用约27GB显存。为了增加训练效率，我们使用8路模型并行和192路数据并行的训练策略，微批大小为16、全局批大小为3072，并采用ZeRO-2优化器降低显存占用。 在开发与训练过程中，我们和华为Mindspore团队合作，对MindSpore框架进行了部分优化，进而大幅度提升训练效率。比如，我们发现矩阵乘法的计算时间占比仅为22.9%，大量时间被用于各类其它算子，因此实现了一系列算子融合，包括单元素算子融合、层归一化算子融合、FastGelu与矩阵乘法融合、批量矩阵乘法与加法融合等；再比如我们还对矩阵乘法算子的维度实现自动搜索调优，使其搜索出效率最高的计算维度组合。这些优化为训练速度带来了显著提升，在同等GPU卡数规模下（128卡），昇腾910对CodeGeeX这一模型的训练效率从约为NVIDIA A100的16.7%提升至43%；在千卡规模下，昇腾910训练效率相比自身优化前提升近300%。使用优化后的软硬件训练时，CodeGeeX单日训练量可达到54.3B个标识符（含填充符），证明了国产深度学习平台与工具的快速迭代能力以及强大竞争力。 ## HumanEval-X: 多语言代码生成基准 为了更好地评测代码生成模型的多语言生成能力，我们构建了一个新基准HumanEval-X。此前，多语言代码生成能力是基于语义相似度（比如[CodeBLEU](https://arxiv.org/abs/2009.10297)）衡量的，具有一定误导性；HumanEval-X则可用于衡量生成代码的功能正确性。HumanEval-X包含820个高质量手写样本，覆盖Python、C++、Java、JavaScript、Go，可用于多种任务。
HumanEval-X支持的任务示例。声明、描述、解答分别用红、绿、蓝色标注。代码生成将声明与描述作为输入，输出解答。代码翻译将两种语言的声明与源语言的解答作为输入，输出目标语言的解答。
HumanEval-X中每个语言的样本，包含了声明、描述和解答，它们之间的组合可以支持不同的下游任务，包括生成、翻译、概括等。我们目前关注两个任务：**代码生成**与**代码翻译**。对于代码生成任务，模型将函数声明与文档字符串作为输入，输出函数实现；对于代码翻译任务，模型将两种语言的函数声明与源语言的实现作为输入，输出目标语言上的实现。我们在代码翻译任务中不将文档字符串输入模型，以避免模型直接通过描述生成答案。在两种任务下，我们都采用[Codex](https://arxiv.org/abs/2107.03374)所使用的无偏pass@k指标，判断生成代码的功能正确性: $\text{pass}@k:= \mathbb{E}[1-\frac{\tbinom{n-c}{k}}{\tbinom{n}{k}}]$, $n=200$, $k\in(1,10,100)$. ### 多语言代码生成
左侧: HumanEval-X中五种语言具体的pass@k（k=1,10,100）性能。右侧: 模型在所有语言上的平均性能。CodeGeeX的平均表现优于InCoder-6.7B和CodeGen-Multi-6B/16B。
我们将CodeGeeX与另外两个开源代码生成模型进行比较，分别为Meta的[InCoder](https://github.com/dpfried/incoder)与Salesforce的[CodeGen](https://github.com/salesforce/CodeGen)，选取InCoder-6.7B、CodeGen-Multi-6B 与 CodeGen-Multi-16B。CodeGeeX能获得最佳的平均性能，显著超越了参数量更小的模型(7.5%~16.3%的提升)，与参数量更大的模型CodeGen-Multi-16B表现相当（平均性能 54.76% vs. 54.39%）。 ### 跨语言代码翻译
HumanEval-X上的代码翻译任务结果。加粗结果表示在每种语言pass@k上的最佳效果。
我们还评测了模型在多语言间代码翻译上的性能。对于CodeGeeX，我们评测了未经微调的CodeGeeX-13B与经过微调的CodeGeeX-13B-FT（使用[XLCoST](https://github.com/reddy-lab-code-research/XLCoST)中代码翻译任务的训练集与一部分Go语言数据微调）。如上表显示，模型对特定语言存在偏好，比如CodeGeeX擅长将其他语言翻译为Python与C++，而CodeGen-Multi-16B擅长翻译为JavaScript和Go，这可能是由于训练集中的语料占比存在差异。在20个翻译对中，我们还观察到两种语言互相翻译的表现常常是呈负相关的，这可能说明现有的模型还不足以学好所有的语言。致谢
这一项目由国家自然科学基金杰出青年科学基金项目（No. 61825602）支持。 #### 学生负责人 郑勤锴（[清华大学知识工程实验室](https://keg.cs.tsinghua.edu.cn/glm-130b/zh/posts/glm-130b/)），夏箫（清华大学知识工程实验室），邹旭（清华大学知识工程实验室） #### 技术贡献 清华大学知识工程实验室：曾奥涵，郑问迪，薛理龙 清华大学交叉信息学院：刘益枫，陈彦儒，徐奕辰（北邮大四访问清华期间研究工作） 鹏城实验室：陈庆玉，李忠琦，范高俊 智谱AI：薛宇飞，王山，陕杰才，姜皓瀚，刘璐，薛旋，张鹏 华为昇腾团队：姚逸璠，苏腾，邓启辉，周斌 #### 数据标注 程锐杰（清华大学），于沛楠（清华大学），张竞尧（智谱AI），黄铂文（智谱AI），王炤宇（智谱AI） #### 指导教师 [杨植麟](https://kimiyoung.github.io/)（清华大学交叉信息学院），东昱晓（清华大学知识工程实验室），陈文光（清华大学PACMAN实验室），[唐杰](http://keg.cs.tsinghua.edu.cn/jietang/)（清华大学知识工程实验室） #### 计算资源支持 [鹏城实验室](https://www.pcl.ac.cn/index.html) [智谱AI](https://www.zhipu.ai/) #### 项目总负责 [唐杰](http://keg.cs.tsinghua.edu.cn/jietang/)（清华大学知识工程实验室 & 北京智源人工智能研究院）
点击首页中的天启平台体验入口：
点击API应用：
输入任意名称，创建API应用。创建后会得到API Key/Secret，用于调用API：
在API信息中，可以查看代码生成/代码翻译的请求地址和使用文档：
根据文档中的描述使用API，Python版参考目录``api/codegeex-api-example-python``；JAVA版参考工程：``api/codegeex-api-example-java``
================================================
FILE: api/codegeex-api-example-java/pom.xml
================================================
An illustration of tasks supported by HumanEval-X. Declarations, docstrings, and solutions are marked with red, green, and blue respectively. Code generation uses declaration and docstring as input, to generate solution. Code translation uses declaration in both languages and translate the solution in source language to the one in target language.
In HumanEval-X, every sample in each language contains declaration, docstring, and solution, which can be combined in various ways to support different downstream tasks including generation, translation, summarization, etc. We currently focus on two tasks: **code generation** and **code translation**. For code generation, the model uses declaration and docstring as input to generate the solution. For code translation, the model uses declarations in both languages and the solution in the source language as input, to generate solutions in the target language. We remove the description during code translation to prevent the model from directly solving the problem. For both tasks, we use the unbiased pass@k metric proposed in [Codex](https://arxiv.org/abs/2107.03374): $\text{pass}@k:= \mathbb{E}[1-\frac{\tbinom{n-c}{k}}{\tbinom{n}{k}}]$, with $n=200$ and $k\in(1,10,100)$. ## How to use HumanEval-X Data are stored in ``codegeex/benchmark/humaneval-x/[LANG]/data/humaneval_[LANG].jsonl.gz``, using JSON list format. There are six keys: * ``task_id``: indicates the target language and ID of the problem. Language is one of ["Python", "Java", "JavaScript", "CPP", "Go"]. * ``prompt``: the function declaration and docstring, used for code generation. * ``declaration``: only the function declaration, used for code translation. * ``canonical_solution``: human-crafted example solutions. * ``test``: hidden test samples, used for evaluation. * ``example_test``: public test samples (appeared in prompt), used for evaluation. ### Evaluation Environment The evaluation of the generated codes involves compiling and running in multiple programming languages. The versions of the programming language environments and packages we use are as follows: | Dependency | Version | | ---------- | -------- | | Python | 3.8.12 | | JDK | 18.0.2.1 | | Node.js | 16.14.0 | | js-md5 | 0.7.3 | | C++ | 11 | | g++ | 7.5.0 | | Boost | 1.71.0 | | OpenSSL | 3.0.0 | | go | 1.18.4 | In order to save everyone the trouble of setting up the environments for these languages, we build a Docker image with the required environments and CodeGeeX installed. You can directly pull the image from Docker Hub: ```bash docker pull rishubi/codegeex:latest ``` Alternatively, if you are familiar with Dockerfile, you can build the image from `codegeex/docker/Dockerfile` or configure the Dockerfile as you like it: ```bash cd codegeex/docker docker build [OPTIONS] . ``` After obtaining the image, you can build a container using the following command: ```bash docker run -it --gpus all --mount type=bind,source=
HumanEval-X支持的任务示例。声明、描述、解答分别用红、绿、蓝色标注。代码生成将声明与描述作为输入，输出解答。代码翻译将两种语言的声明与源语言的解答作为输入，输出目标语言的解答。
HumanEval-X中每个语言的样本，包含了声明、描述和解答，它们之间的组合可以支持不同的下游任务，包括生成、翻译、概括等。我们目前关注两个任务：**代码生成**与**代码翻译**。对于代码生成任务，模型将函数声明与文档字符串作为输入，输出函数实现；对于代码翻译任务，模型将两种语言的函数声明与源语言的实现作为输入，输出目标语言上的实现。我们在代码翻译任务中不将文档字符串输入模型，以避免模型直接通过描述生成答案。在两种任务下，我们都采用[Codex](https://arxiv.org/abs/2107.03374)所使用的无偏pass@k指标：$\text{pass}@k:= \mathbb{E}[1-\frac{\tbinom{n-c}{k}}{\tbinom{n}{k}}]$, $n=200$, $k\in(1,10,100)$。 ## 如何使用HumanEval-X 样本使用JSON列表格式存储在``codegeex/benchmark/humaneval-x/[LANG]/data/humaneval_[LANG].jsonl.gz``，每条样本包含6个部分： * ``task_id``: 题目的目标语言与ID。语言为["Python", "Java", "JavaScript", "CPP", "Go"]中之一。 * ``prompt``: 函数声明与描述，用于代码生成。 * ``declaration``: 仅有函数声明，用于代码翻译。 * ``canonical_solution``: 手写的示例解答。 * ``test``: 隐藏测例，用于评测。 * ``example_test``: 提示中出现的公开测例，用于评测。 ### 评测环境 评测生成的代码需要使用多种语言编译、运行。我们使用的各编程语言依赖及所用包的版本如下： | 依赖 | 版本 | | ------- | -------- | | Python | 3.8.12 | | JDK | 18.0.2.1 | | Node.js | 16.14.0 | | js-md5 | 0.7.3 | | C++ | 11 | | g++ | 7.5.0 | | Boost | 1.71.0 | | OpenSSL | 3.0.0 | | go | 1.18.4 | 为了省去使用者配置这些语言环境的麻烦，我们构建了一个Docker镜像，并在其中配置了所需要的环境。 可以直接从Docker Hub拉取镜像： ```bash docker pull rishubi/codegeex:latest ``` 如果您熟悉Dockerfile，也可以从`codegeex/docker/Dockerfile`构建镜像，或者修改之以定制自己的配置： ```bash cd codegeex/docker docker build [OPTIONS] . ``` 获取镜像后，使用如下命令创建容器： ```bash docker run -it --gpus all --mount type=bind,source=", "langauge": "HTML"}
{"code": "// Write a function that returns the sum of the numbers from 1 to n.\n// For example, if n is 5, then the function should return 1 + 2 + 3 + 4 + 5.\n// If n is 0, then the function should return 0.\n// If n is less than 0, then the function should return -1.\n/**\n * @param {number} n\n * @return {number}\n */\nfunction sum ($n) {", "langauge": "PHP"}
{"code": "// Write a function that returns the sum of the numbers from 1 to n.\n// For example, if n is 5, then the function should return 1 + 2 + 3 + 4 + 5.\n\nfunction sum(n) {", "langauge": "JavaScript"}
{"code": "// Write a function that returns the sum of the numbers from 1 to n,\n// but using a for loop instead of a while loop.\n\nfunction sumForLoop(n) {", "langauge": "TypeScript"}
{"code": "// Write a function that returns the sum of the numbers from 1 to n,\n// but using a for loop instead of a while loop.\n\nfunc sumN(n int) int {", "langauge": "Go"}
{"code": "// Write a function that returns the sum of the numbers from 1 to n,\n// but using a for loop instead of a while loop.\n\nfn sum_numbers(n: usize) -> usize {", "langauge": "Rust"}
{"code": "-- Search all the records from the table CodeGeeX\n-- Delete iterms with odd indices", "langauge": "SQL"}
{"code": "// Write a function that returns the sum of the numbers from 1 to n.\n// For example, if n is 5, then the function should return 1 + 2 + 3 + 4 + 5.\n\nfun sum(n: Int): Int {", "langauge": "Kotlin"}
{"code": "! Write a function that returns the sum of the numbers from 1 to n.\n! For example, if n is 5, then the function should return 1 + 2 + 3 + 4 + 5.\n\n! Use the following header:\n! module sum_numbers\n! end\nmodule sum_numbers", "langauge": "Fortran"}
{"code": "# Write a function that returns the sum of the numbers from 1 to n.\n# For example, if n is 5, then the function should return 1 + 2 + 3 + 4 + 5.\nsum_numbers <- function(n) {", "langauge": "R"}
================================================
FILE: deployment/server_gradio.py
================================================
import json
import torch
import argparse
import gradio as gr
import codegeex
from codegeex.torch import CodeGeeXModel
from codegeex.tokenizer import CodeGeeXTokenizer
from codegeex.quantization import quantize
from codegeex.data.data_utils import LANGUAGE_TAG
from codegeex.megatron.inference import set_random_seed
def model_provider(args):
"""Build the model."""
model = CodeGeeXModel(
args.hidden_size,
args.num_layers,
args.num_attention_heads,
args.padded_vocab_size,
args.max_position_embeddings
)
return model
def add_code_generation_args(parser):
group = parser.add_argument_group(title="code generation")
group.add_argument(
"--num-layers",
type=int,
default=39,
)
group.add_argument(
"--hidden-size",
type=int,
default=5120,
)
group.add_argument(
"--num-attention-heads",
type=int,
default=40,
)
group.add_argument(
"--padded-vocab-size",
type=int,
default=52224,
)
group.add_argument(
"--max-position-embeddings",
type=int,
default=2048,
)
group.add_argument(
"--tokenizer-path",
type=str,
default="./tokenizer",
)
group.add_argument(
"--example-path",
type=str,
default="./",
)
group.add_argument(
"--load",
type=str,
)
group.add_argument(
"--state-dict-path",
type=str,
)
group.add_argument(
"--micro-batch-size",
type=int,
default=1,
)
group.add_argument(
"--quantize",
action="store_true",
)
return parser
def main():
parser = argparse.ArgumentParser()
parser = add_code_generation_args(parser)
args, _ = parser.parse_known_args()
print("Loading tokenizer ...")
tokenizer = CodeGeeXTokenizer(
tokenizer_path=args.tokenizer_path,
mode="codegeex-13b")
print("Loading state dict ...")
state_dict = torch.load(args.load, map_location="cpu")
state_dict = state_dict["module"]
print("Building CodeGeeX model ...")
model = model_provider(args)
model.load_state_dict(state_dict)
model.eval()
model.half()
if args.quantize:
model = quantize(model, weight_bit_width=8, backend="torch")
model.cuda()
def predict(
prompt,
lang,
seed,
out_seq_length,
temperature,
top_k,
top_p,
):
set_random_seed(seed)
if lang.lower() in LANGUAGE_TAG:
prompt = LANGUAGE_TAG[lang.lower()] + "\n" + prompt
generated_code = codegeex.generate(
model,
tokenizer,
prompt,
out_seq_length=out_seq_length,
seq_length=args.max_position_embeddings,
top_k=top_k,
top_p=top_p,
temperature=temperature,
micro_batch_size=args.micro_batch_size,
backend="megatron",
verbose=True,
)
return prompt + generated_code
examples = []
with open(args.example_path, "r") as f:
for line in f:
examples.append(list(json.loads(line).values()))
with gr.Blocks() as demo:
gr.Markdown(
"""
""")
gr.Markdown(
"""
================================================
FILE: scripts/convert_ckpt_parallel.sh
================================================
# This script is used to convert checkpoint model parallel partitions.
LOAD_CKPT_PATH=$1 # Path to weights in .pt format.
SAVE_CKPT_PATH=$2 # Path to save the output MP checkpoints.
MP_SIZE=$3 # Model parallel size
SCRIPT_PATH=$(realpath "$0")
SCRIPT_DIR=$(dirname "$SCRIPT_PATH")
MAIN_DIR=$(dirname "$SCRIPT_DIR")
TOKENIZER_PATH="$MAIN_DIR/codegeex/tokenizer/"
if [ -z "$MP_SIZE" ]; then
MP_SIZE=1
fi
# export CUDA settings
export CUDA_HOME=/usr/local/cuda-11.1/
export CUDA_VISIBLE_DEVICES=0,1
CMD="python $MAIN_DIR/codegeex/megatron/convert_ckpt_parallel.py \
--load-ckpt-path $LOAD_CKPT_PATH \
--save-ckpt-path $SAVE_CKPT_PATH \
--tokenizer-path $TOKENIZER_PATH \
--target-tensor-model-parallel-size $MP_SIZE \
--num-layers 39 \
--hidden-size 5120 \
--num-attention-heads 40 \
--max-position-embeddings 2048 \
--attention-softmax-in-fp32 \
--fp16 \
--micro-batch-size 1 \
--make-vocab-size-divisible-by 52224 \
--seq-length 2048"
echo "$CMD"
eval "$CMD"
================================================
FILE: scripts/convert_mindspore_to_megatron.sh
================================================
# This script is used to convert mindspore checkpoint to the megatron format.
NPY_CKPT_PATH=$1 # Path to Mindspore exported weights in .npy format.
SAVE_CKPT_PATH=$2 # Path to save the output .pt checkpoint.
GPU=$3
SCRIPT_PATH=$(realpath "$0")
SCRIPT_DIR=$(dirname "$SCRIPT_PATH")
MAIN_DIR=$(dirname "$SCRIPT_DIR")
TOKENIZER_PATH="$MAIN_DIR/codegeex/tokenizer/"
# export CUDA settings
if [ -z "$GPU" ]; then
GPU=0
fi
export CUDA_HOME=/usr/local/cuda-11.1/
export CUDA_VISIBLE_DEVICES=$GPU
CMD="python $MAIN_DIR/codegeex/megatron/mindspore_to_megatron.py \
--npy-ckpt-path $NPY_CKPT_PATH \
--save-ckpt-path $SAVE_CKPT_PATH \
--tokenizer-path $TOKENIZER_PATH \
$MODEL_ARGS"
echo "$CMD"
eval "$CMD"
================================================
FILE: scripts/evaluate_humaneval_x.py
================================================
import argparse
import os
from pathlib import Path
from codegeex.benchmark.evaluate_humaneval_x import evaluate_functional_correctness
#GLOBALS
INPUT_FILE: str
LANGUAGE: str
N_WORKERS: int
TIMEOUT: int
parser = argparse.ArgumentParser("Debugging evaluate humaneval_x")
# Path to the .jsonl file that contains the generated codes.
parser.add_argument("-s","--samples", type=str)
# Target programming language, currently support one of ["python", "java", "cpp", "js", "go"]
parser.add_argument("-l","--language", default="python", type=str)
# Number of parallel workers.
parser.add_argument("-w","--workers", default=64, type=int)
# Timeout in seconds.
parser.add_argument("-t","--timeout", default=5, type=int)
args = parser.parse_args()
INPUT_FILE = args.samples
LANGUAGE = args.language
N_WORKERS = args.workers
TIMEOUT= args.timeout
SCRIPT_PATH: str = Path(os.path.abspath(__file__))
print(SCRIPT_PATH)
SCRIPT_DIR: str = os.path.dirname(SCRIPT_PATH)
print(SCRIPT_DIR)
MAIN_DIR: str = os.path.dirname(SCRIPT_DIR)
print(MAIN_DIR)
DATA_DIR=os.path.join(MAIN_DIR,"codegeex/benchmark/humaneval-x/" + LANGUAGE + "/data/humaneval_" + LANGUAGE + ".jsonl.gz")
print(DATA_DIR)
TMP_DIR=os.path.join(MAIN_DIR, "/codegeex/benchmark/humaneval-x/")
#Debugging
INPUT_FILE='/home/rog0d/Escritorio/CodeGeeX/generations/humaneval_rust_generations.jsonl.gz'
LANGUAGE='rust'
DATA_DIR=os.path.join(MAIN_DIR,"codegeex/benchmark/humaneval-x/" + LANGUAGE + "/data/humaneval_" + LANGUAGE + ".jsonl.gz")
"""
input_file: str = None,
tmp_dir: str = "./",
n_workers: int = 32,
timeout: float = 5.0,
problem_file: str = "../data/humaneval_python.jsonl.gz",
out_dir: str = None,
k: List[int] = [1, 10, 100],
test_groundtruth: bool = False,
example_test: bool = False,
"""
evaluate_functional_correctness(input_file=INPUT_FILE,
n_workers=N_WORKERS,
tmp_dir=TMP_DIR,
problem_file=DATA_DIR,
timeout=300.0)
================================================
FILE: scripts/evaluate_humaneval_x.sh
================================================
# This script is for evaluating the functional correctness of the generated codes of HumanEval-X.
INPUT_FILE=$1 # Path to the .jsonl file that contains the generated codes.
LANGUAGE=$2 # Target programming language, currently support one of ["python", "java", "cpp", "js", "go"]
N_WORKERS=$3 # Number of parallel workers.
TIMEOUT=$4 # Timeout in seconds.
SCRIPT_PATH=$(realpath "$0")
SCRIPT_DIR=$(dirname "$SCRIPT_PATH")
MAIN_DIR=$(dirname "$SCRIPT_DIR")
echo "$INPUT_FILE"
if [ -z "$N_WORKERS" ]
then
N_WORKERS=64
fi
if [ -z "$LANGUAGE" ]
then
LANGUAGE=python
fi
if [ -z "$TIMEOUT" ]
then
TIMEOUT=5
fi
DATA_DIR=$MAIN_DIR/codegeex/benchmark/humaneval-x/$LANGUAGE/data/humaneval_$LANGUAGE.jsonl.gz
if [ $LANGUAGE = go ]; then
export PATH=$PATH:/usr/local/go/bin
fi
if [ $LANGUAGE = cpp ]; then
export PATH=$PATH:/usr/bin/openssl
fi
CMD="python $MAIN_DIR/codegeex/benchmark/humaneval-x/evaluate_humaneval_x.py \
--input_file "$INPUT_FILE" \
--n_workers $N_WORKERS \
--tmp_dir $MAIN_DIR/codegeex/benchmark/humaneval-x/ \
--problem_file $DATA_DIR \
--timeout $TIMEOUT"
echo "$CMD"
eval "$CMD"
================================================
FILE: scripts/finetune_codegeex.sh
================================================
SCRIPT_PATH=$(realpath "$0")
SCRIPT_DIR=$(dirname "$SCRIPT_PATH")
MAIN_DIR=$(dirname "$SCRIPT_DIR")
# ====== Environment ======
# - NCCL & IB
export NCCL_DEBUG=info
export NCCL_IB_DISABLE=0
export NCCL_IB_GID_INDEX=3
HOSTFILE=""
MASTER_IP=$(cat $HOSTFILE | head -n 1)
cat $HOSTFILE | awk '{print $1 " slots=8"}' > $SCRIPT_DIR/hostfile
echo "MASTER_IP=$MASTER_IP"
# ====== Parameters ======
DATA_PATH=""
CKPT_PATH=""
DS_CONFIG=ds_config.json
# - 13b
TP=1
PP=1
NLAYERS=39
HIDDEN=5120
NATTN_HEAD=40
EMBED_VOCAB=52224
GLOBAL_BATCH=560
MICRO_BATCH=10
NTRAIN_ITERS=100000
EVAL_INT=10
SAVE_INT=10
TRIAL_TAG="13b-test"
# - trial
TRIAL_NAME="pretrain-codegeex"
# - zero stage
ZERO_STAGE=2
# - logging & output
NOW=$(date +"%Y%m%d_%H%M%S")
OUTPUT_DIR="-$TRIAL_NAME-$TRIAL_TAG"
TB_DIR=$OUTPUT_DIR/tb$NOW
mkdir -p $OUTPUT_DIR
mkdir -p $TB_DIR
# Deepspeed config
cat < $DS_CONFIG
{
"train_batch_size" : $GLOBAL_BATCH,
"train_micro_batch_size_per_gpu": $MICRO_BATCH,
"steps_per_print": 5,
"zero_optimization": {
"stage": $ZERO_STAGE,
"reduce_bucket_size": 50000000,
"allgather_bucket_size": 50000000,
"overlap_comm": true,
"contiguous_gradients": false
},
"fp16": {
"enabled": true,
"loss_scale": 0,
"loss_scale_window": 500,
"hysteresis": 2,
"min_loss_scale": 1,
"initial_scale_power": 12
},
"wall_clock_breakdown" : true
}
EOT
ds_args=""
ds_args=" --deepspeed ${ds_args}"
ds_args=" --no-pipeline-parallel ${ds_args}"
ds_args=" --deepspeed_config=$DS_CONFIG ${ds_args}"
ds_args=" --zero-stage=$ZERO_STAGE ${ds_args}"
ds_args=" --deepspeed-activation-checkpointing ${ds_args}"
echo "Launching deepspeed"
deepspeed \
--hostfile hostfile \
--master_addr $MASTER_IP \
$MAIN_DIR/codegeex/megatron/tools/pretrain_codegeex.py \
--tensor-model-parallel-size $TP \
--pipeline-model-parallel-size $PP \
--no-pipeline-parallel \
--num-layers $NLAYERS \
--hidden-size $HIDDEN \
--make-vocab-size-divisible-by $EMBED_VOCAB \
--num-attention-heads $NATTN_HEAD \
--seq-length 512 \
--loss-scale 12 \
--max-position-embeddings 2048 \
--micro-batch-size $MICRO_BATCH \
--global-batch-size $GLOBAL_BATCH \
--train-iters $NTRAIN_ITERS \
--lr 1e-6 \
--min-lr 1e-7 \
--lr-decay-iters 100000 \
--lr-decay-style cosine \
--lr-warmup-iters 1000 \
--log-interval 1 \
--eval-iters 10 \
--eval-interval $EVAL_INT \
--data-path $DATA_PATH \
--vocab-file $MAIN_DIR/codegeex/tokenizer/vocab.json \
--merge-file $MAIN_DIR/codegeex/tokenizer/merges.txt \
--save-interval $SAVE_INT \
--save $OUTPUT_DIR \
--load $OUTPUT_DIR \
--load-state $CKPT_PATH \
--split 98,2,0 \
--clip-grad 1.0 \
--weight-decay 0.1 \
--adam-beta1 0.9 \
--adam-beta2 0.95 \
--fp16 \
--ln-fp16 \
--attention-softmax-in-fp32 \
--checkpoint-activations \
--override-lr-scheduler \
--tensorboard-dir $TB_DIR \
$ds_args |& tee ${OUTPUT_DIR}/$NOW.log
================================================
FILE: scripts/gather_output.sh
================================================
# This script is used to gather the distributed outputs of different ranks.
OUTPUT_DIR=$1
OUTPUT_PREFIX=$2
IF_REMOVE_RANK_FILES=$3
echo "$OUTPUT_DIR"
echo "$OUTPUT_PREFIX"
if [ -z "$IF_REMOVE_RANK_FILES" ]
then
IF_REMOVE_RANK_FILES=0
fi
SCRIPT_PATH=$(realpath "$0")
SCRIPT_DIR=$(dirname "$SCRIPT_PATH")
MAIN_DIR=$(dirname "$SCRIPT_DIR")
CMD="python $MAIN_DIR/codegeex/benchmark/gather_output.py \
--output_dir $OUTPUT_DIR \
--output_prefix $OUTPUT_PREFIX \
--if_remove_rank_files $IF_REMOVE_RANK_FILES"
echo "$CMD"
eval "$CMD"
================================================
FILE: scripts/generate_humaneval_x.sh
================================================
# This script is used to generate solutions of HumanEval-X.
LANGUAGE=$1 # Target programming language, currently support one of ["python", "java", "cpp", "js", "go"]
OUTPUT_PATH=$2 # Output path of the generated programs.
HOSTLIST=$3 # Provide hostfile if generating distributedly
SCRIPT_PATH=$(realpath "$0")
SCRIPT_DIR=$(dirname "$SCRIPT_PATH")
MAIN_DIR=$(dirname "$SCRIPT_DIR")
TOKENIZER_PATH="$MAIN_DIR/codegeex/tokenizer/"
# export CUDA settings
export CUDA_HOME=/usr/local/cuda-11.1/
# import model configuration
source "$MAIN_DIR/configs/codegeex_13b.sh"
# nccl options
OPTIONS_NCCL="export NCCL_DEBUG=warn; export NCCL_IB_DISABLE=0; export NCCL_IB_GID_INDEX=3"
OPTIONS_PATH="export PATH=$PATH; export LD_LIBRARY_PATH=$LD_LIBRARY_PATH"
CWD=$(pwd)
# set master ip for zmq server
if [ -z "$HOSTLIST" ]; then
ZMQ_ADDR=$(hostname -i)
echo "$ZMQ_ADDR" > "./hostfile"
HOSTLIST="./hostfile"
else
ZMQ_ADDR=$(cat $HOSTLIST | head -n 1)
fi
echo "master_ip: $ZMQ_ADDR"
NUM_SAMPLES=1
MICRO_BSZ=1
WORLD_SIZE=1
TEMP=0.8
TOPP=0.95
SEED=42
DATASET=humaneval
TODAY=$(date +%y%m%d)
CHANNEL_PORT=$(expr $RANDOM + 5000)
MASTER_PORT=$(expr $RANDOM + 8000)
# save log file
LOG_DIR=$MAIN_DIR/log
mkdir -p "$LOG_DIR"
LOG_PATH="$LOG_DIR/$TODAY-generation.log"
if [ -z "$LANGUAGE" ]; then
LANGUAGE=python
fi
if [ -z "$INPUT_PATH" ]; then
INPUT_PATH=$MAIN_DIR/codegeex/benchmark/humaneval-x/$LANGUAGE/data/humaneval_$LANGUAGE.jsonl.gz
fi
if [ -z "$OUTPUT_PATH" ]; then
OUTPUT_PATH=$MAIN_DIR/codegeex/benchmark/output/humaneval-x/codegeex/
mkdir -p "$OUTPUT_PATH"
fi
JOB_ID=codegeex-ns$NUM_SAMPLES-t$TEMP-topp$TOPP-seed$SEED-$LANGUAGE
RUN_CMD="python \
$MAIN_DIR/codegeex/benchmark/humaneval-x/generate_humaneval_x.py \
--hostfile $HOSTLIST \
--channel-ip $ZMQ_ADDR \
--channel-port $CHANNEL_PORT \
--master-port $MASTER_PORT \
--tokenizer-path $TOKENIZER_PATH \
--load-deepspeed \
--temperature $TEMP \
--top-p $TOPP \
--out-seq-length 1024 \
--micro-batch-size $MICRO_BSZ \
--samples-per-problem $NUM_SAMPLES \
--language-type $LANGUAGE \
--dataset $DATASET \
--input-path $INPUT_PATH \
--output-prefix $OUTPUT_PATH/$JOB_ID \
--gen-node-world-size $WORLD_SIZE \
--seed $SEED \
$MODEL_ARGS"
RUN_CMD="$OPTIONS_NCCL; $OPTIONS_PATH; $RUN_CMD"
RUN_CMD="cd $CWD; $RUN_CMD"
if (( WORLD_SIZE != 1 )); then
RUN_CMD="pdsh -R ssh -w ^$HOSTLIST \"$RUN_CMD\""
fi
echo "$RUN_CMD"
echo "Writing log to $LOG_PATH"
eval "$RUN_CMD" > "$LOG_PATH"
bash $MAIN_DIR/scripts/gather_output.sh $OUTPUT_PATH $JOB_ID 1
================================================
FILE: scripts/pretrain_codegeex.sh
================================================
SCRIPT_PATH=$(realpath "$0")
SCRIPT_DIR=$(dirname "$SCRIPT_PATH")
MAIN_DIR=$(dirname "$SCRIPT_DIR")
# ====== Environment ======
# - NCCL & IB
export NCCL_DEBUG=info
export NCCL_IB_DISABLE=0
export NCCL_IB_GID_INDEX=3
HOSTFILE=""
MASTER_IP=$(cat $HOSTFILE | head -n 1)
cat $HOSTFILE | awk '{print $1 " slots=8"}' > $SCRIPT_DIR/hostfile
echo "MASTER_IP=$MASTER_IP"
# ====== Parameters ======
DATA_PATH=""
CKPT_PATH=""
DS_CONFIG=ds_config.json
# - 13b
TP=1
PP=1
NLAYERS=39
HIDDEN=5120
NATTN_HEAD=40
EMBED_VOCAB=52224
GLOBAL_BATCH=560
MICRO_BATCH=10
NTRAIN_ITERS=100000
EVAL_INT=10
SAVE_INT=10
TRIAL_TAG="13b-test"
# - trial
TRIAL_NAME="pretrain-codegeex"
# - zero stage
ZERO_STAGE=2
# - logging & output
NOW=$(date +"%Y%m%d_%H%M%S")
OUTPUT_DIR="-$TRIAL_NAME-$TRIAL_TAG"
TB_DIR=$OUTPUT_DIR/tb$NOW
mkdir -p $OUTPUT_DIR
mkdir -p $TB_DIR
# Deepspeed config
cat < $DS_CONFIG
{
"train_batch_size" : $GLOBAL_BATCH,
"train_micro_batch_size_per_gpu": $MICRO_BATCH,
"steps_per_print": 5,
"zero_optimization": {
"stage": $ZERO_STAGE,
"reduce_bucket_size": 50000000,
"allgather_bucket_size": 50000000,
"overlap_comm": true,
"contiguous_gradients": false
},
"fp16": {
"enabled": true,
"loss_scale": 0,
"loss_scale_window": 500,
"hysteresis": 2,
"min_loss_scale": 1,
"initial_scale_power": 12
},
"wall_clock_breakdown" : true
}
EOT
ds_args=""
ds_args=" --deepspeed ${ds_args}"
ds_args=" --no-pipeline-parallel ${ds_args}"
ds_args=" --deepspeed_config=$DS_CONFIG ${ds_args}"
ds_args=" --zero-stage=$ZERO_STAGE ${ds_args}"
ds_args=" --deepspeed-activation-checkpointing ${ds_args}"
echo "Launching deepspeed"
deepspeed \
--hostfile hostfile \
--master_addr $MASTER_IP \
$MAIN_DIR/codegeex/megatron/tools/pretrain_codegeex.py \
--tensor-model-parallel-size $TP \
--pipeline-model-parallel-size $PP \
--no-pipeline-parallel \
--num-layers $NLAYERS \
--hidden-size $HIDDEN \
--make-vocab-size-divisible-by $EMBED_VOCAB \
--num-attention-heads $NATTN_HEAD \
--seq-length 512 \
--loss-scale 12 \
--max-position-embeddings 2048 \
--micro-batch-size $MICRO_BATCH \
--global-batch-size $GLOBAL_BATCH \
--train-iters $NTRAIN_ITERS \
--lr 2e-4 \
--min-lr 1e-7 \
--lr-decay-iters 100000 \
--lr-decay-style cosine \
--lr-warmup-iters 1500 \
--log-interval 1 \
--eval-iters 10 \
--eval-interval $EVAL_INT \
--data-path $DATA_PATH \
--vocab-file $MAIN_DIR/codegeex/tokenizer/vocab.json \
--merge-file $MAIN_DIR/codegeex/tokenizer/merges.txt \
--save-interval $SAVE_INT \
--save $OUTPUT_DIR \
--load $OUTPUT_DIR \
--load-state $CKPT_PATH \
--split 98,2,0 \
--clip-grad 1.0 \
--weight-decay 0.1 \
--adam-beta1 0.9 \
--adam-beta2 0.95 \
--fp16 \
--ln-fp16 \
--attention-softmax-in-fp32 \
--checkpoint-activations \
--override-lr-scheduler \
--tensorboard-dir $TB_DIR \
$ds_args |& tee ${OUTPUT_DIR}/$NOW.log
================================================
FILE: scripts/process_pretrain_dataset.sh
================================================
# Process dataset for CodeGeeX pretraining
DATASET_PATH=$1
OUTPUT_PATH=$2
LANGUAGE=$3
SCRIPT_PATH=$(realpath "$0")
SCRIPT_DIR=$(dirname "$SCRIPT_PATH")
MAIN_DIR=$(dirname "$SCRIPT_DIR")
TOKENIZER_PATH="$MAIN_DIR/codegeex/tokenizer/"
if [ -z "$LANGUAGE" ]; then
LANGUAGE=python
fi
CMD="python $MAIN_DIR/codegeex/data/process_pretrain_dataset.py \
--dataset_path $DATASET_PATH \
--tokenizer_path $TOKENIZER_PATH \
--output_prefix $OUTPUT_PATH \
--language $LANGUAGE \
--mode pretrain \
--seq_len 2048"
echo "$CMD"
eval "$CMD"
================================================
FILE: scripts/test_inference.sh
================================================
# This script is used to test the inference of CodeGeeX.
GPU=$1
PROMPT_FILE=$2
SCRIPT_PATH=$(realpath "$0")
SCRIPT_DIR=$(dirname "$SCRIPT_PATH")
MAIN_DIR=$(dirname "$SCRIPT_DIR")
TOKENIZER_PATH="$MAIN_DIR/codegeex/tokenizer/"
# import model configuration
source "$MAIN_DIR/configs/codegeex_13b.sh"
# export CUDA settings
if [ -z "$GPU" ]; then
GPU=0
fi
export CUDA_HOME=/usr/local/cuda-11.1/
export CUDA_VISIBLE_DEVICES=$GPU
if [ -z "$PROMPT_FILE" ]; then
PROMPT_FILE=$MAIN_DIR/tests/test_prompt.txt
fi
# remove --greedy if using sampling
CMD="python $MAIN_DIR/tests/test_inference.py \
--prompt-file $PROMPT_FILE \
--tokenizer-path $TOKENIZER_PATH \
--micro-batch-size 1 \
--out-seq-length 1024 \
--temperature 0.8 \
--top-p 0.95 \
--top-k 0 \
--greedy \
$MODEL_ARGS"
echo "$CMD"
eval "$CMD"
================================================
FILE: scripts/test_inference_oneflow.sh
================================================
# This script is used to test the inference of CodeGeeX.
GPU=$1
PROMPT_FILE=$2
SCRIPT_PATH=$(realpath "$0")
SCRIPT_DIR=$(dirname "$SCRIPT_PATH")
MAIN_DIR=$(dirname "$SCRIPT_DIR")
TOKENIZER_PATH="$MAIN_DIR/codegeex/tokenizer/"
# import model configuration
source "$MAIN_DIR/configs/codegeex_13b.sh"
# export CUDA settings
if [ -z "$GPU" ]; then
GPU=0
fi
export CUDA_HOME=/usr/local/cuda-11.1/
export CUDA_VISIBLE_DEVICES=$GPU
if [ -z "$PROMPT_FILE" ]; then
PROMPT_FILE=$MAIN_DIR/tests/test_prompt.txt
fi
# remove --greedy if using sampling
CMD="python $MAIN_DIR/tests/test_inference_oneflow.py \
--prompt-file $PROMPT_FILE \
--tokenizer-path $TOKENIZER_PATH \
--micro-batch-size 1 \
--out-seq-length 1024 \
--temperature 0.8 \
--top-p 0.95 \
--top-k 0 \
--greedy \
$MODEL_ARGS"
echo "$CMD"
eval "$CMD"
================================================
FILE: scripts/test_inference_oneflow_quantized.sh
================================================
# This script is used to test the inference of CodeGeeX.
GPU=$1
PROMPT_FILE=$2
SCRIPT_PATH=$(realpath "$0")
SCRIPT_DIR=$(dirname "$SCRIPT_PATH")
MAIN_DIR=$(dirname "$SCRIPT_DIR")
TOKENIZER_PATH="$MAIN_DIR/codegeex/tokenizer/"
# import model configuration
source "$MAIN_DIR/configs/codegeex_13b.sh"
# export CUDA settings
if [ -z "$GPU" ]; then
GPU=1
fi
export CUDA_HOME=/usr/local/cuda-11.1/
export CUDA_VISIBLE_DEVICES=$GPU
if [ -z "$PROMPT_FILE" ]; then
PROMPT_FILE=$MAIN_DIR/tests/test_prompt.txt
fi
# remove --greedy if using sampling
CMD="python $MAIN_DIR/tests/test_inference_oneflow.py \
--prompt-file $PROMPT_FILE \
--tokenizer-path $TOKENIZER_PATH \
--micro-batch-size 1 \
--out-seq-length 1024 \
--temperature 0.2 \
--top-p 0.95 \
--top-k 0 \
--quantize \
$MODEL_ARGS"
echo "$CMD"
eval "$CMD"
================================================
FILE: scripts/test_inference_paddle.sh
================================================
# This script is used to test the inference of CodeGeeX.
GPU=$1
PROMPT_FILE=$2
SCRIPT_PATH=$(realpath "$0")
SCRIPT_DIR=$(dirname "$SCRIPT_PATH")
MAIN_DIR=$(dirname "$SCRIPT_DIR")
TOKENIZER_PATH="$MAIN_DIR/codegeex/tokenizer/"
# import model configuration
source "$MAIN_DIR/configs/codegeex_13b_paddle.sh"
# export CUDA settings
if [ -z "$GPU" ]; then
GPU=0
fi
export CUDA_HOME=/usr/local/cuda-11.1/
export CUDA_VISIBLE_DEVICES=$GPU
if [ -z "$PROMPT_FILE" ]; then
PROMPT_FILE=$MAIN_DIR/tests/test_prompt.txt
fi
# remove --greedy if using sampling
CMD="python $MAIN_DIR/tests/test_inference_paddle.py \
--prompt-file $PROMPT_FILE \
--tokenizer-path $TOKENIZER_PATH \
--micro-batch-size 1 \
--out-seq-length 1024 \
--temperature 0.8 \
--top-p 0.95 \
--top-k 0 \
--greedy \
$MODEL_ARGS"
echo "$CMD"
eval "$CMD"
================================================
FILE: scripts/test_inference_parallel.sh
================================================
# This script is used to test the inference of CodeGeeX.
MP_SIZE=$1
PROMPT_FILE=$2
SCRIPT_PATH=$(realpath "$0")
SCRIPT_DIR=$(dirname "$SCRIPT_PATH")
MAIN_DIR=$(dirname "$SCRIPT_DIR")
TOKENIZER_PATH="$MAIN_DIR/codegeex/tokenizer/"
if [ -z "$MP_SIZE" ]; then
MP_SIZE=1
fi
if [ "$MP_SIZE" -eq 1 ]; then
source "$MAIN_DIR/configs/codegeex_13b.sh"
echo "Load config from $MAIN_DIR/configs/codegeex_13b.sh"
else
source "$MAIN_DIR/configs/codegeex_13b_parallel.sh"
echo "Load config from $MAIN_DIR/configs/codegeex_13b_parallel.sh"
fi
# export CUDA settings
export CUDA_HOME=/usr/local/cuda-11.1/
# export CUDA_VISIBLE_DEVICES=0,1
if [ -z "$PROMPT_FILE" ]; then
PROMPT_FILE=$MAIN_DIR/tests/test_prompt.txt
fi
# remove --greedy if using sampling
CMD="torchrun --nproc_per_node $MP_SIZE $MAIN_DIR/tests/test_inference_megatron.py \
--tensor-model-parallel-size $MP_SIZE \
--prompt-file $PROMPT_FILE \
--tokenizer-path $TOKENIZER_PATH \
--micro-batch-size 1 \
--out-seq-length 1024 \
--temperature 0.8 \
--top-p 0.95 \
--top-k 0 \
--greedy \
--use-cpu-initialization \
--ln-fp16 \
$MODEL_ARGS"
echo "$CMD"
eval "$CMD"
================================================
FILE: scripts/test_inference_quantized.sh
================================================
# This script is used to test the inference of CodeGeeX.
GPU=$1
PROMPT_FILE=$2
SCRIPT_PATH=$(realpath "$0")
SCRIPT_DIR=$(dirname "$SCRIPT_PATH")
MAIN_DIR=$(dirname "$SCRIPT_DIR")
TOKENIZER_PATH="$MAIN_DIR/codegeex/tokenizer/"
# import model configuration
source "$MAIN_DIR/configs/codegeex_13b.sh"
# export CUDA settings
if [ -z "$GPU" ]; then
GPU=0
fi
export CUDA_HOME=/usr/local/cuda-11.1/
export CUDA_VISIBLE_DEVICES=$GPU
if [ -z "$PROMPT_FILE" ]; then
PROMPT_FILE=$MAIN_DIR/tests/test_prompt.txt
fi
# remove --greedy if using sampling
CMD="python $MAIN_DIR/tests/test_inference.py \
--prompt-file $PROMPT_FILE \
--tokenizer-path $TOKENIZER_PATH \
--micro-batch-size 1 \
--out-seq-length 1024 \
--temperature 0.2 \
--top-p 0.95 \
--top-k 0 \
--quantize \
$MODEL_ARGS"
echo "$CMD"
eval "$CMD"
================================================
FILE: scripts/translate_humaneval_x.sh
================================================
# This script is used to translate solutions of HumanEval-X.
LANG_SRC_TYPE=$1 # Source programming language, currently support one of ["python", "java", "cpp", "js", "go"]
LANG_TGT_TYPE=$2 # Target programming language, currently support one of ["python", "java", "cpp", "js", "go"]
OUTPUT_PATH=$3 # Output path of the generated programs.
HOSTLIST=$4 # Provide hostfile if generating distributedly
SCRIPT_PATH=$(realpath "$0")
SCRIPT_DIR=$(dirname "$SCRIPT_PATH")
MAIN_DIR=$(dirname "$SCRIPT_DIR")
TOKENIZER_PATH="$MAIN_DIR/codegeex/tokenizer/"
# export CUDA settings
export CUDA_HOME=/usr/local/cuda-11.1/
# import model configuration
source "$MAIN_DIR/configs/codegeex_13b.sh"
# nccl options
OPTIONS_NCCL="export NCCL_DEBUG=warn; export NCCL_IB_DISABLE=0; export NCCL_IB_GID_INDEX=3"
OPTIONS_PATH="export PATH=$PATH; export LD_LIBRARY_PATH=$LD_LIBRARY_PATH"
CWD=$(pwd)
# set master ip for zmq server
if [ -z "$HOSTLIST" ]; then
ZMQ_ADDR=$(hostname -i)
echo "$ZMQ_ADDR" > "./hostfile"
HOSTLIST="./hostfile"
else
ZMQ_ADDR=$(cat $HOSTLIST | head -n 1)
fi
echo "master_ip: $ZMQ_ADDR"
NUM_SAMPLES=1
MICRO_BSZ=1
WORLD_SIZE=1
TEMP=0.8
TOPP=0.95
SEED=42
DATASET=humaneval
TODAY=$(date +%y%m%d)
CHANNEL_PORT=$(expr $RANDOM + 5000)
MASTER_PORT=$(expr $RANDOM + 8000)
# save log file
LOG_DIR=$MAIN_DIR/log
mkdir -p "$LOG_DIR"
LOG_PATH="$LOG_DIR/$TODAY-translation.log"
if [ -z "$LANG_SRC_TYPE" ]
then
LANG_SRC_TYPE=python
fi
if [ -z "$LANG_TGT_TYPE" ]
then
LANG_TGT_TYPE=java
fi
if [ -z "$INPUT_SRC_PATH" ]
then
INPUT_SRC_PATH=$MAIN_DIR/codegeex/benchmark/humaneval-x/$LANG_SRC_TYPE/data/humaneval_$LANG_SRC_TYPE.jsonl.gz
fi
if [ -z "$INPUT_TGT_PATH" ]
then
INPUT_TGT_PATH=$MAIN_DIR/codegeex/benchmark/humaneval-x/$LANG_TGT_TYPE/data/humaneval_$LANG_TGT_TYPE.jsonl.gz
fi
if [ -z "$OUTPUT_PATH" ]; then
OUTPUT_PATH=$MAIN_DIR/codegeex/benchmark/output/humaneval-x/codegeex/
mkdir -p "$OUTPUT_PATH"
fi
JOB_ID=codegeex-ns$NUM_SAMPLES-t$TEMP-topp$TOPP-seed$SEED-$LANGUAGE
RUN_CMD="python \
$MAIN_DIR/codegeex/benchmark/humaneval-x/translate_humaneval_x.py \
--hostfile $HOSTLIST \
--channel-ip $ZMQ_ADDR \
--channel-port $CHANNEL_PORT \
--master-port $MASTER_PORT \
--tokenizer-path $TOKENIZER_PATH \
--load-deepspeed \
--temperature $TEMP \
--top-p $TOPP \
--out-seq-length 1024 \
--micro-batch-size $MICRO_BSZ \
--samples-per-problem $NUM_SAMPLES \
--language-src-type $LANG_SRC_TYPE \
--language-tgt-type $LANG_TGT_TYPE \
--src-path $INPUT_SRC_PATH \
--tgt-path $INPUT_TGT_PATH \
--dataset $DATASET \
--output-prefix $OUTPUT_PATH/$JOB_ID \
--gen-node-world-size $WORLD_SIZE \
--seed $SEED \
$MODEL_ARGS"
RUN_CMD="$OPTIONS_NCCL; $OPTIONS_PATH; $RUN_CMD"
RUN_CMD="cd $CWD; $RUN_CMD"
if (( WORLD_SIZE != 1 )); then
RUN_CMD="pdsh -R ssh -w ^$HOSTLIST \"$RUN_CMD\""
fi
echo "$RUN_CMD"
echo "Writing log to $LOG_PATH"
eval "$RUN_CMD" > "$LOG_PATH"
bash $MAIN_DIR/scripts/gather_output.sh $OUTPUT_PATH $JOB_ID 1
================================================
FILE: setup.py
================================================
from setuptools import setup, find_packages
setup(
name="codegeex",
py_modules=["codegeex"],
version="1.0",
description="CodeGeeX: A Open Multilingual Code Generation Model.",
author="Qinkai Zheng",
packages=find_packages(),
install_requires=[
"fire>=0.4.0",
"ipython>=8.4.0",
"numpy>=1.22.0",
"pandas>=1.3.5",
"pyzmq>=23.2.1",
"regex>=2022.3.15",
"setuptools>=58.0.4",
"transformers>=4.22.0",
"tokenizers>=0.11.0",
"torch>=1.10.0",
"tqdm>=4.63.0",
"cpm_kernels",
"deepspeed>0.6.1",
],
entry_points={}
)
================================================
FILE: tests/test_inference.py
================================================
import time
import torch
import argparse
import numpy as np
import codegeex
from codegeex.torch import CodeGeeXModel
from codegeex.tokenizer import CodeGeeXTokenizer
from codegeex.quantization import quantize
def model_provider(args):
"""Build the model."""
model = CodeGeeXModel(
args.hidden_size,
args.num_layers,
args.num_attention_heads,
args.padded_vocab_size,
args.max_position_embeddings
)
return model
def add_code_generation_args(parser):
group = parser.add_argument_group(title="code generation")
group.add_argument(
"--num-layers",
type=int,
default=39,
)
group.add_argument(
"--hidden-size",
type=int,
default=5120,
)
group.add_argument(
"--num-attention-heads",
type=int,
default=40,
)
group.add_argument(
"--padded-vocab-size",
type=int,
default=52224,
)
group.add_argument(
"--max-position-embeddings",
type=int,
default=2048,
)
group.add_argument(
"--temperature",
type=float,
default=1.0,
help="Sampling temperature.",
)
group.add_argument(
"--greedy",
action="store_true",
default=False,
help="Use greedy sampling.",
)
group.add_argument(
"--top-p",
type=float,
default=0.0,
help="Top p sampling.",
)
group.add_argument(
"--top-k",
type=int,
default=0,
help="Top k sampling.",
)
group.add_argument(
"--out-seq-length",
type=int,
default=2048,
help="Size of the output generated text.",
)
group.add_argument(
"--prompt-file",
type=str,
default="./test_prompt.txt",
)
group.add_argument(
"--tokenizer-path",
type=str,
default="./tokenizer",
)
group.add_argument(
"--load",
type=str,
)
group.add_argument(
"--state-dict-path",
type=str,
)
group.add_argument(
"--micro-batch-size",
type=int,
default=1,
)
group.add_argument(
"--quantize",
action="store_true",
)
group.add_argument(
"--interative",
action="store_true",
)
return parser
def main():
parser = argparse.ArgumentParser()
parser = add_code_generation_args(parser)
args, _ = parser.parse_known_args()
print("Loading tokenizer ...")
tokenizer = CodeGeeXTokenizer(
tokenizer_path=args.tokenizer_path,
mode="codegeex-13b")
print("Loading state dict ...")
state_dict = torch.load(args.load, map_location="cpu")
state_dict = state_dict["module"]
print("Building CodeGeeX model ...")
model = model_provider(args)
model.load_state_dict(state_dict)
model.eval()
model.half()
if args.quantize:
model = quantize(model, weight_bit_width=8, backend="torch")
model.cuda()
torch.cuda.synchronize()
with open(args.prompt_file, "r") as f:
prompt = f.readlines()
prompt = "".join(prompt)
out_seq_lengths = [args.out_seq_length]
for out_seq_length in out_seq_lengths:
print(f"Generating with out_seq_len {out_seq_length}...")
while True:
print("\nPlease Input Query (Ctrl-D to save multiple lines, 'stop' to exit) >>> ")
prompts = []
while True:
try:
line = input()
except EOFError:
break
prompts.append(line)
prompt = "\n".join(prompts)
prompt = prompt.strip()
if not prompt:
print('Query should not be empty!')
continue
if prompt == "stop":
return
try:
t0 = time.perf_counter()
generated_code = codegeex.generate(
model,
tokenizer,
prompt,
out_seq_length=out_seq_length,
seq_length=args.max_position_embeddings,
top_k=args.top_k,
top_p=args.top_p,
temperature=args.temperature,
micro_batch_size=args.micro_batch_size,
backend="megatron",
verbose=True,
)
t1 = time.perf_counter()
print("Total generation time:", t1 - t0)
except (ValueError, FileNotFoundError) as e:
print(e)
continue
print("Generation finished.")
if __name__ == "__main__":
main()
================================================
FILE: tests/test_inference_megatron.py
================================================
import copy
import time
import torch
import numpy as np
from codegeex.megatron import get_tokenizer, get_args, print_rank_0
from codegeex.megatron.initialize import initialize_megatron
from codegeex.megatron.model import CodeGeeXModel
from codegeex.megatron.code_generation_utils import get_token_stream
from codegeex.quantization import quantize
from codegeex.megatron.training import get_model
from codegeex.megatron.checkpointing import load_checkpoint
torch.set_printoptions(precision=8)
def set_random_seed(seed):
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
def model_provider(pre_process=True, post_process=True):
"""Build the model."""
print_rank_0("Building CodeGeeX model ...")
model = CodeGeeXModel(num_tokentypes=0,
parallel_output=False)
return model
def add_code_generation_args(parser):
"""Code generation arguments."""
group = parser.add_argument_group(title="code generation")
group.add_argument(
"--temperature",
type=float,
default=1.0,
help="Sampling temperature.",
)
group.add_argument(
"--greedy",
action="store_true",
default=False,
help="Use greedy sampling.",
)
group.add_argument(
"--top-p",
type=float,
default=0.0,
help="Top p sampling.",
)
group.add_argument(
"--top-k",
type=int,
default=0,
help="Top k sampling.",
)
group.add_argument(
"--out-seq-length",
type=int,
default=2048,
help="Size of the output generated text.",
)
group.add_argument(
"--recompute",
action="store_true",
help="During generation recompute all attention "
"instead of using previously computed keys/values.",
)
group.add_argument(
"--ws-encoding-start-id",
type=int,
default=10,
help="Start id for whitespace encoding",
)
group.add_argument(
"--ws-encoding-length",
type=int,
default=10,
help="Length of whitespace encoding",
)
group.add_argument(
"--n-generation",
type=int,
default=10,
)
group.add_argument(
"--eos-id",
type=int,
default=50256,
)
group.add_argument(
"--prompt-file",
type=str,
default="./test_prompt.txt",
)
group.add_argument(
"--perf-file",
type=str,
default="./perf_out.txt",
)
group.add_argument(
"--perf-trace",
type=str,
default="./perf_out.txt",
)
group.add_argument(
"--use-torch-profile",
action="store_true",
)
group.add_argument(
"--ln-fp32",
action="store_true",
)
group.add_argument(
'--bad-ids',
nargs="*",
type=int,
default=None,
help='Identify the type of programming language to generate',
)
group.add_argument(
"--quantize",
action="store_true",
)
return parser
def main():
initialize_megatron(
extra_args_provider=add_code_generation_args,
args_defaults={
'no_load_rng': True,
'no_load_optim': True,
}
)
args = get_args()
set_random_seed(args.seed)
print_rank_0("Loading tokenizer ...")
tokenizer = get_tokenizer()
print_rank_0("Loading state dict ...")
model = get_model(model_provider)
if args.load is not None:
_ = load_checkpoint(model, None, None)
assert len(model) == 1, "Above condition should have caught this"
model = model[0]
model.eval()
if args.fp16 and args.ln_fp16:
model.half()
if args.quantize:
model = quantize(model, weight_bit_width=8, backend="megatron")
with open(args.prompt_file, "r") as f:
prompt = f.readlines()
prompt = "".join(prompt)
times = {}
out_seq_lengths = [args.out_seq_length]
micro_batch_size = args.micro_batch_size
for out_seq_length in out_seq_lengths:
print_rank_0(f"Generating with out_seq_len {out_seq_length}...")
times[out_seq_length] = []
for prompt in [prompt] * args.n_generation:
t0 = time.perf_counter()
tokens = tokenizer.tokenize(prompt)
print_rank_0(tokens)
print_rank_0("Current prompt:")
print_rank_0(prompt)
n_token_prompt = len(tokens)
print_rank_0(f"N_token_prompt:{n_token_prompt}")
token_stream = get_token_stream(
model,
[copy.deepcopy(tokens) for _ in range(micro_batch_size)],
micro_batch_size=micro_batch_size,
topk=args.top_k,
topp=args.top_p,
temperature=args.temperature,
)
is_finished = [False for _ in range(micro_batch_size)]
for i, generated in enumerate(token_stream):
generated_tokens = generated[0]
for j in range(micro_batch_size):
if is_finished[j]:
continue
if generated_tokens[j].cpu().numpy()[-1] == tokenizer.eod or len(
generated_tokens[j]) >= out_seq_length:
is_finished[j] = True
generated_tokens_ = generated_tokens[j].cpu().numpy().tolist()
generated_code = tokenizer.detokenize(generated_tokens_[n_token_prompt:])
t1 = time.perf_counter()
print_rank_0(f"Total generation time: {t1 - t0}, # Tokens: {len(generated_tokens_) - n_token_prompt}")
print_rank_0(f"{(t1 - t0) / (len(generated_tokens_) - n_token_prompt)}s/token")
times[out_seq_length].append(t1 - t0)
print_rank_0("================================= Generated code:")
print_rank_0(generated_code)
t0 = time.perf_counter()
if all(is_finished):
break
print_rank_0(times)
for out_seq_length in times.keys():
print_rank_0(f"{out_seq_length}, {np.mean(times[out_seq_length])}")
print_rank_0("Generation finished.")
if __name__ == "__main__":
main()
================================================
FILE: tests/test_inference_oneflow.py
================================================
import os
import copy
import time
import oneflow as torch
import random
import argparse
import numpy as np
from codegeex.oneflow.inference import get_token_stream
from codegeex.oneflow import CodeGeeXModel
from codegeex.tokenizer import CodeGeeXTokenizer
from codegeex.quantization import quantize_oneflow
os.environ["ONEFLOW_KERNEL_ENABLE_FUSED_LINEAR"] = "1"
os.environ["ONEFLOW_LINEAR_EMBEDDING_SKIP_INIT"] = "1"
def model_provider(args):
"""Build the model."""
model = CodeGeeXModel(
args.hidden_size,
args.num_layers,
args.num_attention_heads,
args.padded_vocab_size,
args.max_position_embeddings
)
return model
def add_code_generation_args(parser):
group = parser.add_argument_group(title="code generation")
group.add_argument(
"--num-layers",
type=int,
default=39,
)
group.add_argument(
"--hidden-size",
type=int,
default=5120,
)
group.add_argument(
"--num-attention-heads",
type=int,
default=40,
)
group.add_argument(
"--padded-vocab-size",
type=int,
default=52224,
)
group.add_argument(
"--max-position-embeddings",
type=int,
default=2048,
)
group.add_argument(
"--temperature",
type=float,
default=1.0,
help="Sampling temperature.",
)
group.add_argument(
"--greedy",
action="store_true",
default=False,
help="Use greedy sampling.",
)
group.add_argument(
"--top-p",
type=float,
default=0.0,
help="Top p sampling.",
)
group.add_argument(
"--top-k",
type=int,
default=0,
help="Top k sampling.",
)
group.add_argument(
"--out-seq-length",
type=int,
default=2048,
help="Size of the output generated text.",
)
group.add_argument(
"--prompt-file",
type=str,
default="./test_prompt.txt",
)
group.add_argument(
"--tokenizer-path",
type=str,
default="./tokenizer",
)
group.add_argument(
"--load",
type=str,
)
group.add_argument(
"--state-dict-path",
type=str,
)
group.add_argument(
"--micro-batch-size",
type=int,
default=1,
)
group.add_argument(
"--quantize",
action="store_true",
)
return parser
def main():
parser = argparse.ArgumentParser()
parser = add_code_generation_args(parser)
args, _ = parser.parse_known_args()
print("Loading tokenizer ...")
tokenizer = CodeGeeXTokenizer(
tokenizer_path=args.tokenizer_path,
mode="codegeex-13b")
print("Loading state dict ...")
state_dict = torch.load(args.load, map_location="cpu")
state_dict = state_dict["module"]
print("Building CodeGeeX model ...")
model = model_provider(args)
model.load_state_dict(state_dict)
model.eval()
model.half()
if args.quantize:
model = quantize_oneflow(model, weight_bit_width=8)
model.cuda()
torch.cuda.synchronize()
with open(args.prompt_file, "r") as f:
prompt = f.readlines()
prompt = "".join(prompt)
times = {}
out_seq_lengths = [args.out_seq_length]
micro_batch_size = args.micro_batch_size
seq_length = args.max_position_embeddings
for out_seq_length in out_seq_lengths:
print(f"Generating with out_seq_len {out_seq_length}...")
times[out_seq_length] = []
for prompt in [prompt]:
t0 = time.perf_counter()
tokens = tokenizer.encode_code(prompt)
print(tokens)
print("Current prompt:")
print(prompt)
n_token_prompt = len(tokens)
print("N_token_prompt:", n_token_prompt)
token_stream = get_token_stream(
model,
tokenizer,
seq_length,
out_seq_length,
[copy.deepcopy(tokens) for _ in range(micro_batch_size)],
micro_batch_size=micro_batch_size,
topk=args.top_k,
topp=args.top_p,
temperature=args.temperature,
greedy=args.greedy,
)
is_finished = [False for _ in range(micro_batch_size)]
for i, generated in enumerate(token_stream):
generated_tokens = generated[0]
for j in range(micro_batch_size):
if is_finished[j]:
continue
generated_token_numpy = generated_tokens[j].numpy()
if generated_token_numpy[-1] == tokenizer.eos_token_id or len(
generated_tokens[j]) >= out_seq_length:
is_finished[j] = True
generated_tokens_ = generated_token_numpy.tolist()
generated_code = tokenizer.decode_code(generated_tokens_[n_token_prompt:])
generated_code = "".join(generated_code)
t1 = time.perf_counter()
print("Total generation time:", t1 - t0, "# Tokens:", len(generated_tokens_) - n_token_prompt)
print(f"{(t1 - t0) / (len(generated_tokens_) - n_token_prompt)}s/token")
times[out_seq_length].append(t1 - t0)
print("================================= Generated code:")
print(generated_code)
if all(is_finished):
break
print(times)
for out_seq_length in times.keys():
print(out_seq_length, np.mean(times[out_seq_length]))
print("Generation finished.")
if __name__ == "__main__":
main()
================================================
FILE: tests/test_inference_paddle.py
================================================
import os
import copy
import time
import paddle
import random
import argparse
import numpy as np
from codegeex.paddle.inference import get_token_stream
from codegeex.paddle import CodeGeeXModel
from codegeex.tokenizer import CodeGeeXTokenizer
def model_provider(args):
"""Build the model."""
old_dtype = paddle.get_default_dtype()
paddle.set_default_dtype("float16")
model = CodeGeeXModel(
args.hidden_size,
args.num_layers,
args.num_attention_heads,
args.padded_vocab_size,
args.max_position_embeddings
)
model.language_model.embedding.word_embeddings.to(dtype="float32")
model.language_model.embedding.position_embeddings.to(dtype="float32")
model.language_model.topQueryEmbedding.top_query_embeddings.to(dtype="float32")
for i in model.language_model.transformer.layers:
i.input_layernorm.to(dtype="float32")
i.post_attention_layernorm.to(dtype="float32")
model.language_model.transformer.topQueryLayer.input_layernorm.to(dtype="float32")
model.language_model.transformer.topQueryLayer.post_attention_layernorm.to(dtype="float32")
model.language_model.transformer.final_layernorm.to(dtype="float32")
paddle.set_default_dtype(old_dtype)
return model
def add_code_generation_args(parser):
group = parser.add_argument_group(title="code generation")
group.add_argument(
"--num-layers",
type=int,
default=39,
)
group.add_argument(
"--hidden-size",
type=int,
default=5120,
)
group.add_argument(
"--num-attention-heads",
type=int,
default=40,
)
group.add_argument(
"--padded-vocab-size",
type=int,
default=52224,
)
group.add_argument(
"--max-position-embeddings",
type=int,
default=2048,
)
group.add_argument(
"--temperature",
type=float,
default=1.0,
help="Sampling temperature.",
)
group.add_argument(
"--greedy",
action="store_true",
default=False,
help="Use greedy sampling.",
)
group.add_argument(
"--top-p",
type=float,
default=0.0,
help="Top p sampling.",
)
group.add_argument(
"--top-k",
type=int,
default=0,
help="Top k sampling.",
)
group.add_argument(
"--out-seq-length",
type=int,
default=2048,
help="Size of the output generated text.",
)
group.add_argument(
"--prompt-file",
type=str,
default="./test_prompt.txt",
)
group.add_argument(
"--tokenizer-path",
type=str,
default="./tokenizer",
)
group.add_argument(
"--load",
type=str,
)
group.add_argument(
"--state-dict-path",
type=str,
)
group.add_argument(
"--micro-batch-size",
type=int,
default=1,
)
group.add_argument(
"--quantize",
action="store_true",
)
return parser
def main():
parser = argparse.ArgumentParser()
parser = add_code_generation_args(parser)
args, _ = parser.parse_known_args()
print("Loading tokenizer ...")
tokenizer = CodeGeeXTokenizer(
tokenizer_path=args.tokenizer_path,
mode="codegeex-13b")
print("Loading state dict ...")
state_dict = paddle.load(args.load)
state_dict = state_dict["module"]
print("Building CodeGeeX model ...")
model = model_provider(args)
model.set_state_dict(state_dict)
model.eval()
model.to(dtype="float16")
if args.quantize:
raise NotImplementedError("quantize")
with open(args.prompt_file, "r") as f:
prompt = f.readlines()
prompt = "".join(prompt)
times = {}
out_seq_lengths = [args.out_seq_length]
micro_batch_size = args.micro_batch_size
seq_length = args.max_position_embeddings
for out_seq_length in out_seq_lengths:
print(f"Generating with out_seq_len {out_seq_length}...")
times[out_seq_length] = []
for prompt in [prompt]:
t0 = time.perf_counter()
tokens = tokenizer.encode_code(prompt)
print(tokens)
print("Current prompt:")
print(prompt)
n_token_prompt = len(tokens)
print("N_token_prompt:", n_token_prompt)
token_stream = get_token_stream(
model,
tokenizer,
seq_length,
out_seq_length,
[copy.deepcopy(tokens) for _ in range(micro_batch_size)],
micro_batch_size=micro_batch_size,
topk=args.top_k,
topp=args.top_p,
temperature=args.temperature,
greedy=args.greedy,
)
is_finished = [False for _ in range(micro_batch_size)]
for i, generated in enumerate(token_stream):
generated_tokens = generated[0]
for j in range(micro_batch_size):
if is_finished[j]:
continue
if generated_tokens[j].cpu().numpy()[-1] == tokenizer.eos_token_id or len(
generated_tokens[j]) >= out_seq_length:
is_finished[j] = True
generated_tokens_ = generated_tokens[j].cpu().numpy().tolist()
generated_code = tokenizer.decode_code(generated_tokens_[n_token_prompt:])
generated_code = "".join(generated_code)
t1 = time.perf_counter()
print("Total generation time:", t1 - t0, "# Tokens:", len(generated_tokens_) - n_token_prompt)
print(f"{(t1 - t0) / (len(generated_tokens_) - n_token_prompt)}s/token")
times[out_seq_length].append(t1 - t0)
print("================================= Generated code:")
print(generated_code)
if all(is_finished):
break
print(times)
for out_seq_length in times.keys():
print(out_seq_length, np.mean(times[out_seq_length]))
print("Generation finished.")
if __name__ == "__main__":
main()
================================================
FILE: tests/test_prompt.txt
================================================
code translation
Java:
public class Solution {
public static boolean hasCloseElements(int[] nums, int threshold) {
for (int i = 0; i < nums.length - 1; i++) {
for (int j = i + 1; j < nums.length; j++) {
if (Math.abs(nums[i] - nums[j]) < threshold) {
return true;
}
}
}
return false;
}
}
Python:
================================================
FILE: vscode-extension/README.md
================================================
🌐 中文
We introduce CodeGeeX, a large-scale multilingual code generation model with 13 billion parameters, pretrained on a large code corpus of more than 20 programming languages. With CodeGeeX, we can generate codes by only providing natural language descriptions, complete any code snippet, or translate codes to other programming languages, etc. CodeGeeX also provides customizable features (**Prompt Mode**) to help you configure your own programming assistant. Happy coding!
Please search "codegeex" in VS Code Marketplace to download it for free (minimum version requirement of VS Code is 1.68.0). For more information, please check out our [Homepage](https://models.aminer.cn/codegeex/) and [GitHub repo](https://github.com/THUDM/CodeGeeX).
Please kindly let us know if you encounter any problem or have any suggestion, via [codegeex@aminer.cn](mailto:codegeex@aminer.cn).
- [Basic Usage](#basic-usage)
- [Privacy](#privacy)
- [Guidance](#guidance)
- [Stealth mode](#stealth-mode)
- [Interactive mode](#interactive-mode)
- [Translation mode](#translation-mode)
- [Prompt mode (Experimental)](#prompt-mode-experimental)
## Basic Usage
Make sure vscode version is >= 1.68.0. Install the extension and enable it globally. There are four modes of usage:
- **Stealth mode**: Keep CodeGeeX activated, it will start generating codes when you stop writing (the icon at the bottom of VSCode starts spinning). When the generated code is shown in gray, just press ``Tab`` to insert the generated codes.
- **Interactive mode**: Press ``Ctrl+Enter`` to activate the interactive mode, CodeGeeX will generate ``X`` candidates and show them in the right panel (``X`` can be modified in extension settings ``Candidate Num``). Then, select the best candidate by clicking on it.
- **Translation mode**: Select code, and press ``Ctrl+Alt+T`` to activate the translation mode. Then, choose the language of the selected code. You will get the code translated into the same language as your current editor. Click on the ``use code`` button to insert the result. You can also configure in the settings whether to comment out the original code or to replace it.
- **Prompt mode (experimental)**: Select codes to be used as input, then press ``Alt/Option+t`` to trigger the prompt mode. It will show a list of pre-defined prompt templates and choose one to generate codes with your input. This mode is fully customizable, you can add your own templates in the extension settings ``Prompt Templates``.
## Privacy
We highly respect the privacy of your code. The code is only used as the input of CodeGeeX to assist your programming. At the first time of usage, we will ask if you agree to share the generated code only for research purpose (**disabled** by default).
## Guidance
Please see the details and examples for how to use the three modes in CodeGeeX:
### Stealth mode
In this mode, CodeGeeX will start generating codes when you stop writing (the icon at the bottom of VSCode starts spinning). When the generated code is shown in gray, just press ``Tab`` to insert the generated codes. You can also press ``Alt/Option+[`` or ``]`` to change between candidates. If you are not satisfied with the current suggestions, you can also press ``Alt/Option+N`` to get new suggestions. Change the number of candidates in the extension settings ``Candidate Num`` (more candidates will slow down the generation speed). **Note**: The generation always starts at the current position of your cursor, thus if you modify the code before the generation is finished, it will probably cause bugs. We keep working on making the generation faster.
### Interactive mode
In this mode, press ``Ctrl+Enter`` to generate codes and visualize the candidates in another panel. Then, click on the best candidate to insert the generated codes to the current position of cursor.
### Translation mode
In this mode, paste or tape some code from another language to the current file, select the code, and press ``Ctrl+Alt+T``. Then, choose the language of the selected code. Wait for a few seconds, you will get the code translated into the same language as your current editor. Click on the ``use code`` button to insert the result into the current position of your cursor. You can also configure in the settings whether to comment out the original code or to replace it.
### Prompt mode (Experimental)
In this mode, you can add extra prompts to the input and implement some cool features, like code explanation, summarization, generation with specific coding style, and more. The principle behind is the few-shot ability of CodeGeeX. When you provide a few examples as extra prompts in the input, CodeGeeX will imitate what are done by these examples and generate codes accordingly. For example, you can give an example that explains each line of code. Select the code you want to explain, then press ``Alt/Option+t`` to trigger the prompt mode. It will show a list of pre-defined prompt templates and choose the ``explanation`` to generate codes with your input. Magically, the codes will be explained line by line.
The template of the above example looks like the following, which contains ``[Example code]``, ````, ``[Example code with explanation]`` and ``[Explanation head]``. ```` is where the selected code will be inserted. ```` means the first line of your input (which is used here to ensure the same function will be explained). When you use the prompt mode, CodeGeeX will combine your input with the template and use them all as the input to generate codes.
```python
# language: Python
def sum_squares(lst):
sum = 0
for i in range(len(lst)):
if i % 3 == 0:
lst[i] = lst[i]**2
elif i % 4 == 0:
lst[i] = lst[i]**3
sum += lst[i]
return sum
# Explain the code line by line
def sum_squares(lst):
# initialize sum
sum = 0
# loop through the list
for i in range(len(lst)):
# if the index is a multiple of 3
if i % 3 == 0:
# square the entry
lst[i] = lst[i]**2
# if the index is a multiple of 4
elif i % 4 == 0:
# cube the entry
lst[i] = lst[i]**3
# add the entry to the sum
sum += lst[i]
# return the sum
return sum
# Explain the code line by line
```
And here is another example for python docstring generation
```python
def add_binary(a, b):
'''
Returns the sum of two decimal numbers in binary digits.
Parameters:
a (int): A decimal integer
b (int): Another decimal integer
Returns:
binary_sum (str): Binary string of the sum of a and b
'''
binary_sum = bin(a+b)[2:]
return binary_sum
```
The templates are fully customizable, you can add your own templates in the extension settings ``Prompt Templates``. ``key`` is the name that you want to show in the list of templates, ``value`` is the path to the template file (``.txt``, ``.py``, ``.h``, etc). Try this feature and write your own templates, you can make the generated codes follow your coding style, generate with a specific function name, or add a specific comment, etc.
================================================
FILE: vscode-extension/README_zh.md
================================================
🌐 English
CodeGeeX是一个具有130亿参数的多编程语言代码生成预训练模型，使用超过二十种编程语言训练得到。基于CodeGeeX开发的插件可以实现通过描述生成代码、补全代码、代码翻译等一系列功能。CodeGeeX同样提供可以定制的**提示模式（Prompt Mode）**，构建专属的编程助手。Happy Coding！
VS Code插件市场搜索"codegeex"即可免费使用(需要VS Code版本不低于1.68.0)，更多关于CodeGeeX信息请见我们的[主页](https://models.aminer.cn/codegeex/) and [GitHub仓库](https://github.com/THUDM/CodeGeeX)。
如使用过程中遇到问题或有任何改进意见，欢迎发送邮件到[codegeex@aminer.cn](mailto:codegeex@aminer.cn)反馈！
- [基本用法](#基本用法)
- [隐私声明](#隐私声明)
- [使用指南](#使用指南)
- [隐匿模式](#隐匿模式)
- [交互模式](#交互模式)
- [翻译模式](#翻译模式)
- [提示模式（实验功能）](#提示模式实验功能)
## 基本用法
需要保证VS Code版本 >= 1.68.0。安装插件并全局激活CodeGeeX，有以下四种使用模式：
- **隐匿模式**: 保持CodeGeeX处于激活状态，当您停止输入时，会从当前光标处开始生成（右下角CodeGeeX图标转圈表示正在生成）。 生成完毕之后会以灰色显示，按``Tab``即可插入生成结果。
- **交互模式**: 按``Ctrl+Enter``激活交互模式，CodeGeeX将生成``X``个候选，并显示在右侧窗口中（``X`` 数量可以在设置的``Candidate Num``中修改）。 点击候选代码上方的``use code``即可插入。
- **翻译模式**: 选择代码，然后按下``Ctrl+Alt+T``激活翻译模式，CodeGeeX会把该代码翻译成匹配您当前编辑器语言的代码。点击翻译结果上方的``use code``插入。您还可以在设置中选择您希望插入的时候如何处理被翻译的代码，您可以选择注释它们或者覆盖它们。
- **提示模式（实验功能）**: 选择需要作为输入的代码，按``Alt/Option+t``触发提示模式，会显示预定义模板列表，选择其中一个模板，即可将代码插入到模板中进行生成。 这个模式高度自定义，可以在设置中 ``Prompt Templates``修改或添加模板内容，为模型加入额外的提示。
## 隐私声明
我们高度尊重用户代码的隐私，代码仅用来辅助编程。在您第一次使用时，我们会询问您是否同意将生成的代码用于研究用途，帮助CodeGeeX变得更好（该选项默认**关闭**）。
## 使用指南
以下是CodeGeeX几种模式的详细用法：
### 隐匿模式
在该模式中，CodeGeeX将在您停止输入时，从光标处开始生成（右下角CodeGeeX图标转圈表示正在生成）。生成完毕之后会以灰色显示，按``Tab``即可插入生成结果。 在生成多个候选的情况下，可以使用``Alt/Option+[`` 或 ``]``在几个候选间进行切换。如果你对现有建议不满意，可以使用``Alt/Option+N``去获得新的候选。可以在设置中改变``Candidate Num``（增加个数会导致生成速度相对变慢）。**注意**：生成总是从当前光标位置开始，如果您在生成结束前移动光标位置，可能会导致一些bugs。我们正在努力使生成速度变得更快以提升用户体验。
### 交互模式
在该模式中，按``Ctrl+Enter``激活交互模式，CodeGeeX将生成``X``个候选，并显示在右侧窗口中（``X`` 数量可以在设置的``Candidate Num``中修改）。 点击候选代码上方的``use code``即可插入结果到为当前光标位置。
### 翻译模式
在当前的语言的文本编辑器中输入或者粘贴其他语言的代码，您用鼠标选择这些代码，然后按下``Ctrl+Alt+T``激活翻译模式，您根据提示选择该代码的语言，然后CodeGeeX会帮您把该代码翻译成匹配您当前编辑器语言的代码。点击翻译结果上方的``use code``即可插入。您还可以在设置中选择您希望插入的时候如何处理被翻译的代码，您可以选择注释它们或者覆盖它们。
### 提示模式（实验功能）
在该模式中，您可以在输入中添加额外的提示来实现一些有趣的功能，包括并不限于代码解释、概括、以特定风格生成等。该模式的原理是利用了CodeGeeX强大的少样本生成能力。当您在输入中提供一些例子时，CodeGeeX会模仿这些例子并实现相应的功能。比如，您可以自定义模板中提供一段逐行解释代码的例子。选择您想要解释的代码，按``Alt/Option+t``触发提示模式，选择您写好的模板（如``explanation``），CodeGeeX就会解释您输入的代码。以下我们会详细介绍如何制作模板。
上述例子中的模板如下图所示，由``[示例代码]``, ````, ``[带解释的示例代码]`` and ``[输出函数头]`` 。````表示您选中的代码将会插入的位置。 ```` 这一句用来保证模型解释的是同一个函数。当使用提示模式时，CodeGeeX会将您选择的代码（插入到部分）和模板代码相结合，一起作为模型的输入。
```python
# language: Python
def sum_squares(lst):
sum = 0
for i in range(len(lst)):
if i % 3 == 0:
lst[i] = lst[i]**2
elif i % 4 == 0:
lst[i] = lst[i]**3
sum += lst[i]
return sum
# Explain the code line by line
def sum_squares(lst):
# initialize sum
sum = 0
# loop through the list
for i in range(len(lst)):
# if the index is a multiple of 3
if i % 3 == 0:
# square the entry
lst[i] = lst[i]**2
# if the index is a multiple of 4
elif i % 4 == 0:
# cube the entry
lst[i] = lst[i]**3
# add the entry to the sum
sum += lst[i]
# return the sum
return sum
# Explain the code line by line
```
以下是另一个Python文档字符串生成的例子，CodeGeeX在您写新函数时会模仿该注释的格式：
```python
def add_binary(a, b):
'''
Returns the sum of two decimal numbers in binary digits.
Parameters:
a (int): A decimal integer
b (int): Another decimal integer
Returns:
binary_sum (str): Binary string of the sum of a and b
'''
binary_sum = bin(a+b)[2:]
return binary_sum
```
模板文件是高度自定义化的，您可以将自定义模板添加到插件设置中的``Prompt Templates``中。 ``key``表示模板的名字， ``value``是模板文件的路径（可以是您电脑上的任一路径，``.txt``, ``.py``, ``.h``, 等格式文件均可）。通过该功能，您可以让CodeGeeX生成具有特定风格或功能的代码，快尝试定义自己的专属模板吧！
""")
gr.Markdown(
"""
🏠 Homepage | 📖 Blog | 🪧 DEMO | 🛠 VS Code or Jetbrains Extensions | 💻 Source code | 🤖 Download Model
""") gr.Markdown( """ We introduce CodeGeeX, a large-scale multilingual code generation model with 13 billion parameters, pre-trained on a large code corpus of more than 20 programming languages. CodeGeeX supports 15+ programming languages for both code generation and translation. CodeGeeX is open source, please refer to our [GitHub](https://github.com/THUDM/CodeGeeX) for more details. This is a minimal-functional DEMO, for other DEMOs like code translation, please visit our [Homepage](https://codegeex.cn). We also offer free [VS Code](https://marketplace.visualstudio.com/items?itemName=aminer.codegeex) or [Jetbrains](https://plugins.jetbrains.com/plugin/20587-codegeex) extensions for full functionality. """) with gr.Row(): with gr.Column(): prompt = gr.Textbox(lines=13, placeholder='Please enter the description or select an example input below.',label='Input') with gr.Row(): gen = gr.Button("Generate") clr = gr.Button("Clear") outputs = gr.Textbox(lines=15, label='Output') gr.Markdown( """ Generation Parameter """) with gr.Row(): with gr.Column(): lang = gr.Radio( choices=["C++", "C", "C#", "Python", "Java", "HTML", "PHP", "JavaScript", "TypeScript", "Go", "Rust", "SQL", "Kotlin", "R", "Fortran"], value='lang', label='Programming Language', default="Python") with gr.Column(): seed = gr.Slider(maximum=10000, value=8888, step=1, label='Seed') with gr.Row(): out_seq_length = gr.Slider(maximum=1024, value=128, minimum=1, step=1, label='Output Sequence Length') temperature = gr.Slider(maximum=1, value=0.2, minimum=0, label='Temperature') with gr.Row(): top_k = gr.Slider(maximum=40, value=0, minimum=0, step=1, label='Top K') top_p = gr.Slider(maximum=1, value=1.0, minimum=0, label='Top P') inputs = [prompt, lang, seed, out_seq_length, temperature, top_k, top_p] gen.click(fn=predict, inputs=inputs, outputs=outputs) clr.click(fn=lambda value: gr.update(value=""), inputs=clr, outputs=prompt) gr_examples = gr.Examples(examples=examples, inputs=[prompt, lang], label="Example Inputs (Click to insert an examplet it into the input box)", examples_per_page=20) demo.launch(server_port=6007) if __name__ == '__main__': with torch.no_grad(): main() ================================================ FILE: requirements.txt ================================================ fire>=0.4.0 ipython>=8.4.0 numpy>=1.22.0 pandas>=1.3.5 pyzmq>=23.2.1 regex>=2022.3.15 setuptools>=58.0.4 transformers>=4.22.0 torch>=1.10.0 tqdm>=4.63.0 cpm_kernels deepspeed>0.6.1 ================================================ FILE: resources/zh/wechat.md ================================================
扫码关注公众号加入「CodeGeeX交流群」
Scan the QR code to join the "CodeGeeX WeChat Group"