diff --git "a/2024/UniCoder_ Scaling Code Large Language Model via Universal Code/layout.json" "b/2024/UniCoder_ Scaling Code Large Language Model via Universal Code/layout.json" new file mode 100644--- /dev/null +++ "b/2024/UniCoder_ Scaling Code Large Language Model via Universal Code/layout.json" @@ -0,0 +1,9712 @@ +{ + "pdf_info": [ + { + "para_blocks": [ + { + "bbox": [ + 69, + 75, + 525, + 95 + ], + "type": "title", + "angle": 0, + "lines": [ + { + "bbox": [ + 69, + 75, + 525, + 95 + ], + "spans": [ + { + "bbox": [ + 69, + 75, + 525, + 95 + ], + "type": "text", + "content": "UNICODER : Scaling Code Large Language Model via Universal Code" + } + ] + } + ], + "index": 0 + }, + { + "bbox": [ + 114, + 107, + 485, + 136 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 114, + 107, + 485, + 136 + ], + "spans": [ + { + "bbox": [ + 114, + 107, + 485, + 136 + ], + "type": "text", + "content": "Tao Sun" + }, + { + "bbox": [ + 114, + 107, + 485, + 136 + ], + "type": "inline_equation", + "content": "^{1}" + }, + { + "bbox": [ + 114, + 107, + 485, + 136 + ], + "type": "text", + "content": ", Linzheng Chai" + }, + { + "bbox": [ + 114, + 107, + 485, + 136 + ], + "type": "inline_equation", + "content": "^{1*}" + }, + { + "bbox": [ + 114, + 107, + 485, + 136 + ], + "type": "text", + "content": ", Jian Yang" + }, + { + "bbox": [ + 114, + 107, + 485, + 136 + ], + "type": "inline_equation", + "content": "^{1*†}" + }, + { + "bbox": [ + 114, + 107, + 485, + 136 + ], + "type": "text", + "content": ", Yuwei Yin" + }, + { + "bbox": [ + 114, + 107, + 485, + 136 + ], + "type": "inline_equation", + "content": "^{2}" + }, + { + "bbox": [ + 114, + 107, + 485, + 136 + ], + "type": "text", + "content": ", Hongcheng Guo" + }, + { + "bbox": [ + 114, + 107, + 485, + 136 + ], + "type": "inline_equation", + "content": "^{1}" + }, + { + "bbox": [ + 114, + 107, + 485, + 136 + ], + "type": "text", + "content": ", Jiaheng Liu" + }, + { + "bbox": [ + 114, + 107, + 485, + 136 + ], + "type": "inline_equation", + "content": "^{1}" + }, + { + "bbox": [ + 114, + 107, + 485, + 136 + ], + "type": "text", + "content": ", Bing Wang" + }, + { + "bbox": [ + 114, + 107, + 485, + 136 + ], + "type": "inline_equation", + "content": "^{1}" + }, + { + "bbox": [ + 114, + 107, + 485, + 136 + ], + "type": "text", + "content": ", Liquun Yang" + }, + { + "bbox": [ + 114, + 107, + 485, + 136 + ], + "type": "inline_equation", + "content": "^{1}" + }, + { + "bbox": [ + 114, + 107, + 485, + 136 + ], + "type": "text", + "content": ", Zhoujun Li" + }, + { + "bbox": [ + 114, + 107, + 485, + 136 + ], + "type": "inline_equation", + "content": "^{1}" + } + ] + } + ], + "index": 1 + }, + { + "bbox": [ + 81, + 136, + 514, + 193 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 81, + 136, + 514, + 193 + ], + "spans": [ + { + "bbox": [ + 81, + 136, + 514, + 193 + ], + "type": "inline_equation", + "content": "^{1}" + }, + { + "bbox": [ + 81, + 136, + 514, + 193 + ], + "type": "text", + "content": "State Key Laboratory of Complex & Critical Software Environment, Beihang University; " + }, + { + "bbox": [ + 81, + 136, + 514, + 193 + ], + "type": "inline_equation", + "content": "^{2}" + }, + { + "bbox": [ + 81, + 136, + 514, + 193 + ], + "type": "text", + "content": "Department of Computer Science, University of British Columbia {buaast, challenging, jiaya, hongchengguo} @ buaa.edu.cn; {liujiaheng, bingwang, lqyang, lizj} @ buaa.edu.cn; yuweiyin@cs.ubc.ca" + } + ] + } + ], + "index": 2 + }, + { + "bbox": [ + 155, + 212, + 202, + 224 + ], + "type": "title", + "angle": 0, + "lines": [ + { + "bbox": [ + 155, + 212, + 202, + 224 + ], + "spans": [ + { + "bbox": [ + 155, + 212, + 202, + 224 + ], + "type": "text", + "content": "Abstract" + } + ] + } + ], + "index": 3 + }, + { + "bbox": [ + 84, + 237, + 274, + 631 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 84, + 237, + 274, + 631 + ], + "spans": [ + { + "bbox": [ + 84, + 237, + 274, + 631 + ], + "type": "text", + "content": "Intermediate reasoning or acting steps have successfully improved large language models (LLMs) for handling various downstream natural language processing (NLP) tasks. When applying LLMs for code generation, recent works mainly focus on directing the models to articulate intermediate natural-language reasoning steps, as in chain-of-thought (CoT) prompting, and then output code with the natural language or other structured intermediate steps. However, such output is not suitable for code translation or generation tasks since the standard CoT has different logical structures and forms of expression with the code. In this work, we introduce the universal code (UniCode) as the intermediate representation. It is a description of algorithm steps using a mix of conventions of programming languages, such as assignment operator, conditional operator, and loop. Hence, we collect an instruction dataset UNICODER-INSTRUCT to train our model UNICODER on multi-task learning objectives. UNICODER-INSTRUCT comprises natural-language questions, code solutions, and the corresponding universal code. The alignment between the intermediate universal code representation and the final code solution significantly improves the quality of the generated code. The experimental results demonstrate that UNICODER with the universal code significantly outperforms the previous prompting methods by a large margin, showcasing the effectiveness of the structural clues in pseudo-code.1" + } + ] + } + ], + "index": 4 + }, + { + "bbox": [ + 68, + 643, + 154, + 655 + ], + "type": "title", + "angle": 0, + "lines": [ + { + "bbox": [ + 68, + 643, + 154, + 655 + ], + "spans": [ + { + "bbox": [ + 68, + 643, + 154, + 655 + ], + "type": "text", + "content": "1 Introduction" + } + ] + } + ], + "index": 5 + }, + { + "bbox": [ + 67, + 665, + 291, + 732 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 67, + 665, + 291, + 732 + ], + "spans": [ + { + "bbox": [ + 67, + 665, + 291, + 732 + ], + "type": "text", + "content": "The field of code translation and generation has advanced significantly (Szafraniec et al., 2023; Yan et al., 2023) with the advent of code-specific large language models (LLMs). Code LLMs, such as StarCoder (Li et al., 2023b) and Code" + } + ] + } + ], + "index": 6 + }, + { + "type": "image", + "bbox": [ + 305, + 211, + 522, + 423 + ], + "blocks": [ + { + "bbox": [ + 305, + 211, + 522, + 423 + ], + "lines": [ + { + "bbox": [ + 305, + 211, + 522, + 423 + ], + "spans": [ + { + "bbox": [ + 305, + 211, + 522, + 423 + ], + "type": "image", + "image_path": "9b58023e2630706a642eb8db55316074fbfae84310834e07c3d886ef843eb298.jpg" + } + ] + } + ], + "index": 7, + "angle": 0, + "type": "image_body" + }, + { + "bbox": [ + 302, + 433, + 526, + 481 + ], + "lines": [ + { + "bbox": [ + 302, + 433, + 526, + 481 + ], + "spans": [ + { + "bbox": [ + 302, + 433, + 526, + 481 + ], + "type": "text", + "content": "Figure 1: An example of UNICODER. The Code LLM solves the code generation question by \"translating\" the pseudocode description (Universal Code) into executable code of the target programming language." + } + ] + } + ], + "index": 8, + "angle": 0, + "type": "image_caption" + } + ], + "index": 7 + }, + { + "bbox": [ + 302, + 499, + 525, + 607 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 302, + 499, + 525, + 607 + ], + "spans": [ + { + "bbox": [ + 302, + 499, + 525, + 607 + ], + "type": "text", + "content": "Llama (Rozière et al., 2023), are capable of generating executable code by analyzing natural language prompts. Chain-of-thought (CoT) prompting (Wei et al., 2022b) has emerged as the leading technique in enhancing LLMs, where the intermediate steps provide a structured pathway from the problem statement to the solution, effectively mirroring the human problem-solving process." + } + ] + } + ], + "index": 9 + }, + { + "bbox": [ + 302, + 611, + 526, + 773 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 302, + 611, + 526, + 773 + ], + "spans": [ + { + "bbox": [ + 302, + 611, + 526, + 773 + ], + "type": "text", + "content": "Considering the low accuracy of CoT in coder generation, structure CoT (SCoT) (Li et al., 2023a) is proposed to minimize the gap between the intermediate steps and the generated code. More intuitively, using a universal code as the intermediate representation to handle multiple programming languages (PL) is promising. Here, universal code is a blueprint for implementing an algorithm, which helps to make the design of algorithms logically clear and readily comprehensible. Moreover, it is universal across different programming languages (PL-agnostic) since it typically does not follow spe" + } + ] + } + ], + "index": 10 + } + ], + "discarded_blocks": [ + { + "bbox": [ + 83, + 740, + 161, + 750 + ], + "type": "page_footnote", + "angle": 0, + "lines": [ + { + "bbox": [ + 83, + 740, + 161, + 750 + ], + "spans": [ + { + "bbox": [ + 83, + 740, + 161, + 750 + ], + "type": "text", + "content": "*Equal contribution." + } + ] + } + ], + "index": 11 + }, + { + "bbox": [ + 83, + 750, + 174, + 761 + ], + "type": "page_footnote", + "angle": 0, + "lines": [ + { + "bbox": [ + 83, + 750, + 174, + 761 + ], + "spans": [ + { + "bbox": [ + 83, + 750, + 174, + 761 + ], + "type": "text", + "content": "† Corresponding Author." + } + ] + } + ], + "index": 12 + }, + { + "bbox": [ + 81, + 761, + 275, + 772 + ], + "type": "page_footnote", + "angle": 0, + "lines": [ + { + "bbox": [ + 81, + 761, + 275, + 772 + ], + "spans": [ + { + "bbox": [ + 81, + 761, + 275, + 772 + ], + "type": "text", + "content": "" + } + ] + } + ], + "index": 13 + }, + { + "bbox": [ + 286, + 780, + 309, + 791 + ], + "type": "page_number", + "angle": 0, + "lines": [ + { + "bbox": [ + 286, + 780, + 309, + 791 + ], + "spans": [ + { + "bbox": [ + 286, + 780, + 309, + 791 + ], + "type": "text", + "content": "1812" + } + ] + } + ], + "index": 15 + }, + { + "bbox": [ + 53, + 795, + 540, + 819 + ], + "type": "footer", + "angle": 0, + "lines": [ + { + "bbox": [ + 53, + 795, + 540, + 819 + ], + "spans": [ + { + "bbox": [ + 53, + 795, + 540, + 819 + ], + "type": "text", + "content": "Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 1812-1824 August 11-16, 2024 ©2024 Association for Computational Linguistics" + } + ] + } + ], + "index": 16 + } + ], + "page_size": [ + 595, + 841 + ], + "page_idx": 0 + }, + { + "para_blocks": [ + { + "bbox": [ + 67, + 71, + 291, + 125 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 67, + 71, + 291, + 125 + ], + "spans": [ + { + "bbox": [ + 67, + 71, + 291, + 125 + ], + "type": "text", + "content": "cific syntax and omits execution details. Yet, how the universal code is used for code translation and generation in multilingual scenarios remains underexplored." + } + ] + } + ], + "index": 0 + }, + { + "bbox": [ + 69, + 126, + 291, + 408 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 69, + 126, + 291, + 408 + ], + "spans": [ + { + "bbox": [ + 69, + 126, + 291, + 408 + ], + "type": "text", + "content": "In this work, we scale up the code LLMs to support multiple programming languages via the universal code (UniCode), which is used as an efficient and language-independent intermediate representation of the key algorithm principles. Specifically, we first define UniCode by specifying grammar rules and providing paradigms, followed by prompting GPT-4 (OpenAI, 2023) to create an instruction dataset UNICODER-INSTRUCT comprising natural-language questions, code solutions, and the corresponding universal code, as shown in Figure 1. Then, the UNICODER model is built by performing instruction tuning (Wei et al., 2022a) on multi-task learning objectives, including zero-shot question-answer generation (question " + }, + { + "bbox": [ + 69, + 126, + 291, + 408 + ], + "type": "inline_equation", + "content": "\\rightarrow" + }, + { + "bbox": [ + 69, + 126, + 291, + 408 + ], + "type": "text", + "content": " code), question-universal-code generation (question " + }, + { + "bbox": [ + 69, + 126, + 291, + 408 + ], + "type": "inline_equation", + "content": "\\rightarrow" + }, + { + "bbox": [ + 69, + 126, + 291, + 408 + ], + "type": "text", + "content": " UniCode " + }, + { + "bbox": [ + 69, + 126, + 291, + 408 + ], + "type": "inline_equation", + "content": "\\rightarrow" + }, + { + "bbox": [ + 69, + 126, + 291, + 408 + ], + "type": "text", + "content": " code), universal-code-solution translation (UniCode " + }, + { + "bbox": [ + 69, + 126, + 291, + 408 + ], + "type": "inline_equation", + "content": "\\rightarrow" + }, + { + "bbox": [ + 69, + 126, + 291, + 408 + ], + "type": "text", + "content": " code), and Universal-code-of-Thought (UoT) objectives. In UoT, the model is required to generate the universal code before the executable code." + } + ] + } + ], + "index": 1 + }, + { + "bbox": [ + 67, + 409, + 291, + 558 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 67, + 409, + 291, + 558 + ], + "spans": [ + { + "bbox": [ + 67, + 409, + 291, + 558 + ], + "type": "text", + "content": "UNICODER is evaluated on the Python benchmark (Humaneval (Chen et al., 2021) and MBPP (Austin et al., 2021)) and the extended multilingual benchmark MultiPL-E. The results demonstrate that UNICODER consistently achieves state-of-the-art performance across all languages, notably surpassing the previous baselines. Furthermore, the ablation study verifies the efficacy of the proposed method, and extra discussions provide insights into the effect of our method. The contributions are summarized as follows:" + } + ] + } + ], + "index": 2 + }, + { + "bbox": [ + 80, + 563, + 291, + 772 + ], + "type": "list", + "angle": 0, + "index": 6, + "blocks": [ + { + "bbox": [ + 80, + 563, + 290, + 644 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 80, + 563, + 290, + 644 + ], + "spans": [ + { + "bbox": [ + 80, + 563, + 290, + 644 + ], + "type": "text", + "content": "- We introduce the universal code UniCode, which is agnostic to programming languages, allowing LLMs to grasp the essence of algorithms step by step. In addition, the instruction dataset UNICODER-INSTRUCT is collected and provided for follow-up research." + } + ] + } + ], + "index": 3 + }, + { + "bbox": [ + 80, + 648, + 291, + 756 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 80, + 648, + 291, + 756 + ], + "spans": [ + { + "bbox": [ + 80, + 648, + 291, + 756 + ], + "type": "text", + "content": "- We propose UNICODER, a code generation method that uses multi-task learning objectives to fine-tune the code LLMs with the help of UniCode. The objectives include question-answer generation (QA), question-universal-code generation (QP), universal-code-answer translation (PA), and Universal-code-of-Thought (UoT)." + } + ] + } + ], + "index": 4 + }, + { + "bbox": [ + 80, + 760, + 290, + 772 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 80, + 760, + 290, + 772 + ], + "spans": [ + { + "bbox": [ + 80, + 760, + 290, + 772 + ], + "type": "text", + "content": "- As extensive experiments show, our method" + } + ] + } + ], + "index": 5 + } + ], + "sub_type": "text" + }, + { + "type": "image", + "bbox": [ + 324, + 72, + 503, + 355 + ], + "blocks": [ + { + "bbox": [ + 324, + 72, + 503, + 355 + ], + "lines": [ + { + "bbox": [ + 324, + 72, + 503, + 355 + ], + "spans": [ + { + "bbox": [ + 324, + 72, + 503, + 355 + ], + "type": "image", + "image_path": "7feb259c45a02f637d4acfe6cbadc8b05a136cbbe2d081fae3d4ce86a28ec150.jpg" + } + ] + } + ], + "index": 7, + "angle": 0, + "type": "image_body" + }, + { + "bbox": [ + 327, + 367, + 499, + 380 + ], + "lines": [ + { + "bbox": [ + 327, + 367, + 499, + 380 + ], + "spans": [ + { + "bbox": [ + 327, + 367, + 499, + 380 + ], + "type": "text", + "content": "Figure 2: Definition of the universal code." + } + ] + } + ], + "index": 8, + "angle": 0, + "type": "image_caption" + } + ], + "index": 7 + }, + { + "bbox": [ + 324, + 396, + 526, + 476 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 324, + 396, + 526, + 476 + ], + "spans": [ + { + "bbox": [ + 324, + 396, + 526, + 476 + ], + "type": "text", + "content": "UNICODER consistently outperforms the previous baselines on different benchmarks, including HumanEval, MBPP, and MultiPL-E. To further verify the effectiveness of the universal code, we propose UNICODER-BENCH to test the capabilities of code LLMs." + } + ] + } + ], + "index": 9 + }, + { + "bbox": [ + 302, + 486, + 444, + 499 + ], + "type": "title", + "angle": 0, + "lines": [ + { + "bbox": [ + 302, + 486, + 444, + 499 + ], + "spans": [ + { + "bbox": [ + 302, + 486, + 444, + 499 + ], + "type": "text", + "content": "2 UNICODER-INSTRUCT" + } + ] + } + ], + "index": 10 + }, + { + "bbox": [ + 301, + 507, + 526, + 724 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 301, + 507, + 526, + 724 + ], + "spans": [ + { + "bbox": [ + 301, + 507, + 526, + 724 + ], + "type": "text", + "content": "Definition of Universal Code. Universal code is designed for expressing algorithms in a form that is easily understood by humans, blending programming language syntax with natural language descriptions and mathematical notation to outline the steps of an algorithm without the complexity of full coding details. It omits machine-specific implementations to focus on the core logic, making it a popular choice for documentation in educational materials and the preliminary design phases of software development. By abstracting away from the intricacies of actual code, pseudocode facilitates clear communication of algorithmic concepts across various programming environments. The definition of the universal code, as shown in Figure 2, is based on the following principles:" + } + ] + } + ], + "index": 11 + }, + { + "bbox": [ + 316, + 733, + 525, + 772 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 316, + 733, + 525, + 772 + ], + "spans": [ + { + "bbox": [ + 316, + 733, + 525, + 772 + ], + "type": "text", + "content": "- Comments: Provide explanations and context for code segments, making it easier for others to understand the intent and functionality." + } + ] + } + ], + "index": 12 + } + ], + "discarded_blocks": [ + { + "bbox": [ + 287, + 780, + 309, + 791 + ], + "type": "page_number", + "angle": 0, + "lines": [ + { + "bbox": [ + 287, + 780, + 309, + 791 + ], + "spans": [ + { + "bbox": [ + 287, + 780, + 309, + 791 + ], + "type": "text", + "content": "1813" + } + ] + } + ], + "index": 13 + } + ], + "page_size": [ + 595, + 841 + ], + "page_idx": 1 + }, + { + "para_blocks": [ + { + "bbox": [ + 90, + 73, + 215, + 86 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 90, + 73, + 215, + 86 + ], + "spans": [ + { + "bbox": [ + 90, + 73, + 215, + 86 + ], + "type": "text", + "content": "{Definition of Universal Code}" + } + ] + } + ], + "index": 0 + }, + { + "bbox": [ + 92, + 87, + 145, + 97 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 92, + 87, + 145, + 97 + ], + "spans": [ + { + "bbox": [ + 92, + 87, + 145, + 97 + ], + "type": "text", + "content": "Question" + } + ] + } + ], + "index": 1 + }, + { + "bbox": [ + 92, + 98, + 136, + 109 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 92, + 98, + 136, + 109 + ], + "spans": [ + { + "bbox": [ + 92, + 98, + 136, + 109 + ], + "type": "text", + "content": "{Question}" + } + ] + } + ], + "index": 2 + }, + { + "bbox": [ + 92, + 110, + 147, + 120 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 92, + 110, + 147, + 120 + ], + "spans": [ + { + "bbox": [ + 92, + 110, + 147, + 120 + ], + "type": "text", + "content": "Response" + } + ] + } + ], + "index": 3 + }, + { + "bbox": [ + 92, + 121, + 131, + 132 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 92, + 121, + 131, + 132 + ], + "spans": [ + { + "bbox": [ + 92, + 121, + 131, + 132 + ], + "type": "text", + "content": "{Answer}" + } + ] + } + ], + "index": 4 + }, + { + "bbox": [ + 92, + 133, + 149, + 142 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 92, + 133, + 149, + 142 + ], + "spans": [ + { + "bbox": [ + 92, + 133, + 149, + 142 + ], + "type": "text", + "content": "Your Task" + } + ] + } + ], + "index": 5 + }, + { + "bbox": [ + 91, + 144, + 248, + 154 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 91, + 144, + 248, + 154 + ], + "spans": [ + { + "bbox": [ + 91, + 144, + 248, + 154 + ], + "type": "text", + "content": "Please combine the above Question and" + } + ] + } + ], + "index": 6 + }, + { + "bbox": [ + 91, + 156, + 254, + 179 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 91, + 156, + 254, + 179 + ], + "spans": [ + { + "bbox": [ + 91, + 156, + 254, + 179 + ], + "type": "text", + "content": "Response to comply with the pseudocode standard to write the corresponding" + } + ] + } + ], + "index": 7 + }, + { + "bbox": [ + 91, + 179, + 264, + 248 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 91, + 179, + 264, + 248 + ], + "spans": [ + { + "bbox": [ + 91, + 179, + 264, + 248 + ], + "type": "text", + "content": "pseudocode of solution. Adopt a meticulous methodology, breaking down the generation process into manageable steps. Just output the generated pseudocode for the solution and do not include the Question and Response in the output." + } + ] + } + ], + "index": 8 + }, + { + "bbox": [ + 90, + 259, + 235, + 295 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 90, + 259, + 235, + 295 + ], + "spans": [ + { + "bbox": [ + 90, + 259, + 235, + 295 + ], + "type": "text", + "content": "The output format is as follows, Use \\*\\*pseudocode to put the generated pseudocode in markdown quotes:" + } + ] + } + ], + "index": 9 + }, + { + "bbox": [ + 91, + 306, + 149, + 317 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 91, + 306, + 149, + 317 + ], + "spans": [ + { + "bbox": [ + 91, + 306, + 149, + 317 + ], + "type": "text", + "content": "```\n```\n```\n```\n```\n```\n``" + } + ] + } + ], + "index": 10 + }, + { + "bbox": [ + 92, + 318, + 238, + 341 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 92, + 318, + 238, + 341 + ], + "spans": [ + { + "bbox": [ + 92, + 318, + 238, + 341 + ], + "type": "text", + "content": "{Offers a pseudocode version of the solution.}" + } + ] + } + ], + "index": 11 + }, + { + "bbox": [ + 92, + 342, + 102, + 346 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 92, + 342, + 102, + 346 + ], + "spans": [ + { + "bbox": [ + 92, + 342, + 102, + 346 + ], + "type": "text", + "content": "1" + } + ] + } + ], + "index": 12 + }, + { + "bbox": [ + 91, + 367, + 265, + 380 + ], + "angle": 0, + "lines": [ + { + "bbox": [ + 91, + 367, + 265, + 380 + ], + "spans": [ + { + "bbox": [ + 91, + 367, + 265, + 380 + ], + "type": "text", + "content": "Figure 3: Prompt of generating UniCode." + } + ] + } + ], + "index": 13, + "type": "text" + }, + { + "bbox": [ + 81, + 394, + 290, + 737 + ], + "type": "list", + "angle": 0, + "index": 20, + "blocks": [ + { + "bbox": [ + 81, + 394, + 290, + 449 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 81, + 394, + 290, + 449 + ], + "spans": [ + { + "bbox": [ + 81, + 394, + 290, + 449 + ], + "type": "text", + "content": "- Variables: Enhance code readability and maintainability by using meaningful names that convey the purpose of the variables without relying on data type specifications." + } + ] + } + ], + "index": 14 + }, + { + "bbox": [ + 81, + 453, + 289, + 492 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 81, + 453, + 289, + 492 + ], + "spans": [ + { + "bbox": [ + 81, + 453, + 289, + 492 + ], + "type": "text", + "content": "- Input/Output: Simplify the interaction with data entering and leaving the system, ensuring these operations are clear and easy to trace." + } + ] + } + ], + "index": 15 + }, + { + "bbox": [ + 81, + 497, + 290, + 551 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 81, + 497, + 290, + 551 + ], + "spans": [ + { + "bbox": [ + 81, + 497, + 290, + 551 + ], + "type": "text", + "content": "- Conditionals: Clarify decision-making processes within the code by using structured and indented conditional statements that define clear execution paths." + } + ] + } + ], + "index": 16 + }, + { + "bbox": [ + 81, + 555, + 290, + 608 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 81, + 555, + 290, + 608 + ], + "spans": [ + { + "bbox": [ + 81, + 555, + 290, + 608 + ], + "type": "text", + "content": "- Loops: Facilitate the repetition of code blocks in a controlled manner, with clearly defined start and end conditions, making the iterative processes understandable." + } + ] + } + ], + "index": 17 + }, + { + "bbox": [ + 81, + 613, + 290, + 667 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 81, + 613, + 290, + 667 + ], + "spans": [ + { + "bbox": [ + 81, + 613, + 290, + 667 + ], + "type": "text", + "content": "- Functions/Procedures: Increase modularity and reusability by naming functions and procedures descriptively, and by using parameters effectively to encapsulate functionality." + } + ] + } + ], + "index": 18 + }, + { + "bbox": [ + 81, + 671, + 290, + 737 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 81, + 671, + 290, + 737 + ], + "spans": [ + { + "bbox": [ + 81, + 671, + 290, + 737 + ], + "type": "text", + "content": "- Formatting: Improve the overall visual organization of the code by applying consistent indentation, which helps in delineating hierarchical structures and logical groupings within the code." + } + ] + } + ], + "index": 19 + } + ], + "sub_type": "text" + }, + { + "bbox": [ + 67, + 746, + 290, + 773 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 67, + 746, + 290, + 773 + ], + "spans": [ + { + "bbox": [ + 67, + 746, + 290, + 773 + ], + "type": "text", + "content": "Construction From Instruction Dataset. For a programming language " + }, + { + "bbox": [ + 67, + 746, + 290, + 773 + ], + "type": "inline_equation", + "content": "L" + }, + { + "bbox": [ + 67, + 746, + 290, + 773 + ], + "type": "text", + "content": ", given the existing code" + } + ] + } + ], + "index": 21 + }, + { + "bbox": [ + 302, + 70, + 526, + 301 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 302, + 70, + 526, + 301 + ], + "spans": [ + { + "bbox": [ + 302, + 70, + 526, + 301 + ], + "type": "text", + "content": "instruction pair " + }, + { + "bbox": [ + 302, + 70, + 526, + 301 + ], + "type": "inline_equation", + "content": "(q_{\\alpha},a_{\\alpha})\\in D_s^L" + }, + { + "bbox": [ + 302, + 70, + 526, + 301 + ], + "type": "text", + "content": " , where " + }, + { + "bbox": [ + 302, + 70, + 526, + 301 + ], + "type": "inline_equation", + "content": "q_{\\alpha}" + }, + { + "bbox": [ + 302, + 70, + 526, + 301 + ], + "type": "text", + "content": " and " + }, + { + "bbox": [ + 302, + 70, + 526, + 301 + ], + "type": "inline_equation", + "content": "a_{\\alpha}" + }, + { + "bbox": [ + 302, + 70, + 526, + 301 + ], + "type": "text", + "content": " are question and answer from " + }, + { + "bbox": [ + 302, + 70, + 526, + 301 + ], + "type": "inline_equation", + "content": "D_{s}^{L}" + }, + { + "bbox": [ + 302, + 70, + 526, + 301 + ], + "type": "text", + "content": " , we create the universal code instruction dataset " + }, + { + "bbox": [ + 302, + 70, + 526, + 301 + ], + "type": "inline_equation", + "content": "D_{u_{\\alpha}}^{L}" + }, + { + "bbox": [ + 302, + 70, + 526, + 301 + ], + "type": "text", + "content": " by prompting LLMs to generate the universal code " + }, + { + "bbox": [ + 302, + 70, + 526, + 301 + ], + "type": "inline_equation", + "content": "p_{\\alpha}" + }, + { + "bbox": [ + 302, + 70, + 526, + 301 + ], + "type": "text", + "content": " and then add " + }, + { + "bbox": [ + 302, + 70, + 526, + 301 + ], + "type": "inline_equation", + "content": "(q_{\\alpha},a_{\\alpha},p_{\\alpha})" + }, + { + "bbox": [ + 302, + 70, + 526, + 301 + ], + "type": "text", + "content": " into " + }, + { + "bbox": [ + 302, + 70, + 526, + 301 + ], + "type": "inline_equation", + "content": "D_{u_{\\alpha}}^{L}" + }, + { + "bbox": [ + 302, + 70, + 526, + 301 + ], + "type": "text", + "content": " . Figure 2 shows the definition of the code universal and Figure 3 is the prompt for LLMs to generate UniCode. {Definition of Universal Code}, {Question}, and {Answer} denote the slots for definition of the universal code " + }, + { + "bbox": [ + 302, + 70, + 526, + 301 + ], + "type": "inline_equation", + "content": "p_{\\alpha}" + }, + { + "bbox": [ + 302, + 70, + 526, + 301 + ], + "type": "text", + "content": " , the question of the instruction data " + }, + { + "bbox": [ + 302, + 70, + 526, + 301 + ], + "type": "inline_equation", + "content": "q_{\\alpha}" + }, + { + "bbox": [ + 302, + 70, + 526, + 301 + ], + "type": "text", + "content": " , and the answer of the instruction " + }, + { + "bbox": [ + 302, + 70, + 526, + 301 + ], + "type": "inline_equation", + "content": "a_{\\alpha}" + }, + { + "bbox": [ + 302, + 70, + 526, + 301 + ], + "type": "text", + "content": " , respectively. Given " + }, + { + "bbox": [ + 302, + 70, + 526, + 301 + ], + "type": "inline_equation", + "content": "K" + }, + { + "bbox": [ + 302, + 70, + 526, + 301 + ], + "type": "text", + "content": " different programming languages " + }, + { + "bbox": [ + 302, + 70, + 526, + 301 + ], + "type": "inline_equation", + "content": "L_{all} = \\{L_k\\}_{k = 1}^K" + }, + { + "bbox": [ + 302, + 70, + 526, + 301 + ], + "type": "text", + "content": " the multilingual programming instruction dataset with the universal code " + }, + { + "bbox": [ + 302, + 70, + 526, + 301 + ], + "type": "inline_equation", + "content": "D_{u_{\\alpha}} = \\{D_{u_{\\alpha}}^{L_k}\\}_{k = 1}^K" + }, + { + "bbox": [ + 302, + 70, + 526, + 301 + ], + "type": "text", + "content": " are created for supervised fine-tuning (SFT) (Ouyang et al., 2022). In this work, we adopt the open-source instruction dataset." + } + ] + } + ], + "index": 22 + }, + { + "bbox": [ + 302, + 311, + 526, + 601 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 302, + 311, + 526, + 601 + ], + "spans": [ + { + "bbox": [ + 302, + 311, + 526, + 601 + ], + "type": "text", + "content": "Construction From Code Snippets. For the unsupervised data (code snippets) widely existing on many websites (e.g., GitHub), we also construct the instruction dataset with the universal code from raw code snippets. Specifically, we ask the LLM to generate the question " + }, + { + "bbox": [ + 302, + 311, + 526, + 601 + ], + "type": "inline_equation", + "content": "q_{\\beta}" + }, + { + "bbox": [ + 302, + 311, + 526, + 601 + ], + "type": "text", + "content": " and the corresponding code answer " + }, + { + "bbox": [ + 302, + 311, + 526, + 601 + ], + "type": "inline_equation", + "content": "a_{\\beta}" + }, + { + "bbox": [ + 302, + 311, + 526, + 601 + ], + "type": "text", + "content": " pair based on the original code snippet " + }, + { + "bbox": [ + 302, + 311, + 526, + 601 + ], + "type": "inline_equation", + "content": "c" + }, + { + "bbox": [ + 302, + 311, + 526, + 601 + ], + "type": "text", + "content": " using the prompt \"Please generate the self-contained question and answer based on the given code snippet\". Then, we generate UniCode " + }, + { + "bbox": [ + 302, + 311, + 526, + 601 + ], + "type": "inline_equation", + "content": "p_{\\beta}" + }, + { + "bbox": [ + 302, + 311, + 526, + 601 + ], + "type": "text", + "content": " and construct " + }, + { + "bbox": [ + 302, + 311, + 526, + 601 + ], + "type": "inline_equation", + "content": "(q_{\\beta}, a_{\\beta}, p_{\\beta})" + }, + { + "bbox": [ + 302, + 311, + 526, + 601 + ], + "type": "text", + "content": " triplets the same way as in Paragraph 2. In addition, an LLM scorer is applied to filter out the low-quality " + }, + { + "bbox": [ + 302, + 311, + 526, + 601 + ], + "type": "inline_equation", + "content": "(q_{\\beta}, a_{\\beta}, p_{\\beta})" + }, + { + "bbox": [ + 302, + 311, + 526, + 601 + ], + "type": "text", + "content": " triplets. Therefore, given raw code snippets of different programming languages " + }, + { + "bbox": [ + 302, + 311, + 526, + 601 + ], + "type": "inline_equation", + "content": "L_{k} \\in \\{L_{k}\\}_{k=1}^{K}" + }, + { + "bbox": [ + 302, + 311, + 526, + 601 + ], + "type": "text", + "content": ", we can construct instruction dataset with the universal code " + }, + { + "bbox": [ + 302, + 311, + 526, + 601 + ], + "type": "inline_equation", + "content": "D_{u_{\\beta}} = \\{D_{u_{\\beta}}^{L_{k}}\\}_{k=1}^{K}" + }, + { + "bbox": [ + 302, + 311, + 526, + 601 + ], + "type": "text", + "content": " directly from such unsupervised data. Finally, we combine these two instruction datasets to obtain " + }, + { + "bbox": [ + 302, + 311, + 526, + 601 + ], + "type": "inline_equation", + "content": "D_{u} = D_{u_{\\alpha}} \\cup D_{u_{\\beta}}" + }, + { + "bbox": [ + 302, + 311, + 526, + 601 + ], + "type": "text", + "content": ", where " + }, + { + "bbox": [ + 302, + 311, + 526, + 601 + ], + "type": "inline_equation", + "content": "D_{u}^{L_{k}} = D_{u_{\\alpha}^{L_{k}}} \\cup D_{u_{\\beta}^{L_{k}}}" + }, + { + "bbox": [ + 302, + 311, + 526, + 601 + ], + "type": "text", + "content": " for each program language " + }, + { + "bbox": [ + 302, + 311, + 526, + 601 + ], + "type": "inline_equation", + "content": "L_{k} \\in L_{all}" + }, + { + "bbox": [ + 302, + 311, + 526, + 601 + ], + "type": "text", + "content": "." + } + ] + } + ], + "index": 23 + }, + { + "bbox": [ + 302, + 611, + 525, + 773 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 302, + 611, + 525, + 773 + ], + "spans": [ + { + "bbox": [ + 302, + 611, + 525, + 773 + ], + "type": "text", + "content": "Evaluation Task for Universal Code. To test the capability of the LLMs in generating UniCode from questions and translating UniCode into answers, we design a code reconstruction task for evaluation. Given the code snippet " + }, + { + "bbox": [ + 302, + 611, + 525, + 773 + ], + "type": "inline_equation", + "content": "c" + }, + { + "bbox": [ + 302, + 611, + 525, + 773 + ], + "type": "text", + "content": ", we require the LLM to generate UniCode " + }, + { + "bbox": [ + 302, + 611, + 525, + 773 + ], + "type": "inline_equation", + "content": "p" + }, + { + "bbox": [ + 302, + 611, + 525, + 773 + ], + "type": "text", + "content": " and then translate it into the code " + }, + { + "bbox": [ + 302, + 611, + 525, + 773 + ], + "type": "inline_equation", + "content": "c'" + }, + { + "bbox": [ + 302, + 611, + 525, + 773 + ], + "type": "text", + "content": ". The evaluation metric is not the similarity between " + }, + { + "bbox": [ + 302, + 611, + 525, + 773 + ], + "type": "inline_equation", + "content": "c" + }, + { + "bbox": [ + 302, + 611, + 525, + 773 + ], + "type": "text", + "content": " and " + }, + { + "bbox": [ + 302, + 611, + 525, + 773 + ], + "type": "inline_equation", + "content": "c'" + }, + { + "bbox": [ + 302, + 611, + 525, + 773 + ], + "type": "text", + "content": " but whether the restored code " + }, + { + "bbox": [ + 302, + 611, + 525, + 773 + ], + "type": "inline_equation", + "content": "c'" + }, + { + "bbox": [ + 302, + 611, + 525, + 773 + ], + "type": "text", + "content": " can pass the test cases. We expand the HumanEval and MBPP datasets to create our benchmark UNICODER-BENCH comprising 164 HumanEval samples and 500 MBPP test samples." + } + ] + } + ], + "index": 24 + } + ], + "discarded_blocks": [ + { + "bbox": [ + 287, + 781, + 309, + 791 + ], + "type": "page_number", + "angle": 0, + "lines": [ + { + "bbox": [ + 287, + 781, + 309, + 791 + ], + "spans": [ + { + "bbox": [ + 287, + 781, + 309, + 791 + ], + "type": "text", + "content": "1814" + } + ] + } + ], + "index": 25 + } + ], + "page_size": [ + 595, + 841 + ], + "page_idx": 2 + }, + { + "para_blocks": [ + { + "type": "image", + "bbox": [ + 68, + 68, + 399, + 260 + ], + "blocks": [ + { + "bbox": [ + 68, + 68, + 399, + 260 + ], + "lines": [ + { + "bbox": [ + 68, + 68, + 399, + 260 + ], + "spans": [ + { + "bbox": [ + 68, + 68, + 399, + 260 + ], + "type": "image", + "image_path": "8b08779aedb06089c03e2f110ca17aa5a947b06209c7121797b0c7a2f38f5765.jpg" + } + ] + } + ], + "index": 0, + "angle": 0, + "type": "image_body" + }, + { + "bbox": [ + 67, + 271, + 526, + 356 + ], + "lines": [ + { + "bbox": [ + 67, + 271, + 526, + 356 + ], + "spans": [ + { + "bbox": [ + 67, + 271, + 526, + 356 + ], + "type": "text", + "content": "Figure 4: Overview of UNICODER. (a) The function of universal code UniCode; (b) The framework of our method UNICODER. The universal code as the intermediate representation, our proposed framework can support code generation, code translation, and code summarization. In (a), the LLM encodes the code snippets of multilingual programming languages or the problem description questions into UniCode. Then UniCode is translated into the target output, i.e., the executable code of multilingual programming languages with a descriptive code summarization. In (b), we first ask the LLM to generate UniCode with few-shot prompts. In the second stage, the instruction dataset, containing questions, answers, and UniCode, is fed into the code LLM for fine-tuning." + } + ] + } + ], + "index": 2, + "angle": 0, + "type": "image_caption" + } + ], + "index": 0 + }, + { + "type": "image", + "bbox": [ + 404, + 68, + 520, + 260 + ], + "blocks": [ + { + "bbox": [ + 404, + 68, + 520, + 260 + ], + "lines": [ + { + "bbox": [ + 404, + 68, + 520, + 260 + ], + "spans": [ + { + "bbox": [ + 404, + 68, + 520, + 260 + ], + "type": "image", + "image_path": "e4bd35c1cef07ff1156a28426b0be784a093d7cb94281765ba3693db6ce5fbfe.jpg" + } + ] + } + ], + "index": 1, + "angle": 0, + "type": "image_body" + } + ], + "index": 1 + }, + { + "bbox": [ + 67, + 371, + 149, + 383 + ], + "type": "title", + "angle": 0, + "lines": [ + { + "bbox": [ + 67, + 371, + 149, + 383 + ], + "spans": [ + { + "bbox": [ + 67, + 371, + 149, + 383 + ], + "type": "text", + "content": "3 UNICODER" + } + ] + } + ], + "index": 3 + }, + { + "bbox": [ + 67, + 396, + 173, + 407 + ], + "type": "title", + "angle": 0, + "lines": [ + { + "bbox": [ + 67, + 396, + 173, + 407 + ], + "spans": [ + { + "bbox": [ + 67, + 396, + 173, + 407 + ], + "type": "text", + "content": "3.1 Model Overview" + } + ] + } + ], + "index": 4 + }, + { + "bbox": [ + 67, + 415, + 290, + 564 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 67, + 415, + 290, + 564 + ], + "spans": [ + { + "bbox": [ + 67, + 415, + 290, + 564 + ], + "type": "text", + "content": "In Figure 4, we first define the concept of the universal code with the essential components and then prompt the LLM to generate UniCode " + }, + { + "bbox": [ + 67, + 415, + 290, + 564 + ], + "type": "inline_equation", + "content": "p" + }, + { + "bbox": [ + 67, + 415, + 290, + 564 + ], + "type": "text", + "content": " based on the existing instruction data (questions " + }, + { + "bbox": [ + 67, + 415, + 290, + 564 + ], + "type": "inline_equation", + "content": "q" + }, + { + "bbox": [ + 67, + 415, + 290, + 564 + ], + "type": "text", + "content": " and answers " + }, + { + "bbox": [ + 67, + 415, + 290, + 564 + ], + "type": "inline_equation", + "content": "a" + }, + { + "bbox": [ + 67, + 415, + 290, + 564 + ], + "type": "text", + "content": ") and the raw code snippets " + }, + { + "bbox": [ + 67, + 415, + 290, + 564 + ], + "type": "inline_equation", + "content": "c" + }, + { + "bbox": [ + 67, + 415, + 290, + 564 + ], + "type": "text", + "content": ". UniCode is regarded as the intermediate representation for different tasks, including code generation, code translation, and code summarization. Our proposed model UNICODER is trained on the instruction dataset " + }, + { + "bbox": [ + 67, + 415, + 290, + 564 + ], + "type": "inline_equation", + "content": "D_{u}" + }, + { + "bbox": [ + 67, + 415, + 290, + 564 + ], + "type": "text", + "content": " with the multilingual objectives to fully unleash the potential of UniCode." + } + ] + } + ], + "index": 5 + }, + { + "bbox": [ + 67, + 576, + 246, + 588 + ], + "type": "title", + "angle": 0, + "lines": [ + { + "bbox": [ + 67, + 576, + 246, + 588 + ], + "spans": [ + { + "bbox": [ + 67, + 576, + 246, + 588 + ], + "type": "text", + "content": "3.2 Code LLM with Universal Code" + } + ] + } + ], + "index": 6 + }, + { + "bbox": [ + 67, + 596, + 291, + 663 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 67, + 596, + 291, + 663 + ], + "spans": [ + { + "bbox": [ + 67, + 596, + 291, + 663 + ], + "type": "text", + "content": "Given the instructions dataset with " + }, + { + "bbox": [ + 67, + 596, + 291, + 663 + ], + "type": "inline_equation", + "content": "K" + }, + { + "bbox": [ + 67, + 596, + 291, + 663 + ], + "type": "text", + "content": " multilingual programming languages " + }, + { + "bbox": [ + 67, + 596, + 291, + 663 + ], + "type": "inline_equation", + "content": "D_{u} = \\{D_{u}^{L_{k}}\\}_{k = 1}^{K}" + }, + { + "bbox": [ + 67, + 596, + 291, + 663 + ], + "type": "text", + "content": ", the pretrained code LLM " + }, + { + "bbox": [ + 67, + 596, + 291, + 663 + ], + "type": "inline_equation", + "content": "\\mathcal{M}" + }, + { + "bbox": [ + 67, + 596, + 291, + 663 + ], + "type": "text", + "content": " trained on " + }, + { + "bbox": [ + 67, + 596, + 291, + 663 + ], + "type": "inline_equation", + "content": "D_{u}" + }, + { + "bbox": [ + 67, + 596, + 291, + 663 + ], + "type": "text", + "content": " can support Universal-code-of-Thought (UoT). It can be described as:" + } + ] + } + ], + "index": 7 + }, + { + "bbox": [ + 95, + 677, + 290, + 692 + ], + "type": "interline_equation", + "angle": 0, + "lines": [ + { + "bbox": [ + 95, + 677, + 290, + 692 + ], + "spans": [ + { + "bbox": [ + 95, + 677, + 290, + 692 + ], + "type": "interline_equation", + "content": "P (p, a | q) = P (p | q; \\mathcal {M}) P (a | q, p; \\mathcal {M}) \\tag {1}", + "image_path": "f971b946f3ffdfe7ed8771e298bb3dc3daf1de5eea5a7b71651957363d97298b.jpg" + } + ] + } + ], + "index": 8 + }, + { + "bbox": [ + 67, + 706, + 291, + 772 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 67, + 706, + 291, + 772 + ], + "spans": [ + { + "bbox": [ + 67, + 706, + 291, + 772 + ], + "type": "text", + "content": "where " + }, + { + "bbox": [ + 67, + 706, + 291, + 772 + ], + "type": "inline_equation", + "content": "q" + }, + { + "bbox": [ + 67, + 706, + 291, + 772 + ], + "type": "text", + "content": " (question) and " + }, + { + "bbox": [ + 67, + 706, + 291, + 772 + ], + "type": "inline_equation", + "content": "a" + }, + { + "bbox": [ + 67, + 706, + 291, + 772 + ], + "type": "text", + "content": " (answer) are the instruction pair from " + }, + { + "bbox": [ + 67, + 706, + 291, + 772 + ], + "type": "inline_equation", + "content": "D_{u}" + }, + { + "bbox": [ + 67, + 706, + 291, + 772 + ], + "type": "text", + "content": ". Given the question " + }, + { + "bbox": [ + 67, + 706, + 291, + 772 + ], + "type": "inline_equation", + "content": "q" + }, + { + "bbox": [ + 67, + 706, + 291, + 772 + ], + "type": "text", + "content": ", the code LLM " + }, + { + "bbox": [ + 67, + 706, + 291, + 772 + ], + "type": "inline_equation", + "content": "\\mathcal{M}" + }, + { + "bbox": [ + 67, + 706, + 291, + 772 + ], + "type": "text", + "content": " first generates UniCode " + }, + { + "bbox": [ + 67, + 706, + 291, + 772 + ], + "type": "inline_equation", + "content": "p" + }, + { + "bbox": [ + 67, + 706, + 291, + 772 + ], + "type": "text", + "content": " and then outputs the final answer " + }, + { + "bbox": [ + 67, + 706, + 291, + 772 + ], + "type": "inline_equation", + "content": "a" + }, + { + "bbox": [ + 67, + 706, + 291, + 772 + ], + "type": "text", + "content": ", where " + }, + { + "bbox": [ + 67, + 706, + 291, + 772 + ], + "type": "inline_equation", + "content": "p" + }, + { + "bbox": [ + 67, + 706, + 291, + 772 + ], + "type": "text", + "content": " provides key algorithm ideas with natural language comments." + } + ] + } + ], + "index": 9 + }, + { + "bbox": [ + 302, + 372, + 492, + 386 + ], + "type": "title", + "angle": 0, + "lines": [ + { + "bbox": [ + 302, + 372, + 492, + 386 + ], + "spans": [ + { + "bbox": [ + 302, + 372, + 492, + 386 + ], + "type": "text", + "content": "3.3 Multi-task Supervised Fine-tuning" + } + ] + } + ], + "index": 10 + }, + { + "bbox": [ + 302, + 390, + 525, + 430 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 302, + 390, + 525, + 430 + ], + "spans": [ + { + "bbox": [ + 302, + 390, + 525, + 430 + ], + "type": "text", + "content": "To fully unleash the potential of the UniCode, we design multiple objectives to enhance the understanding and generation capability of code LLM." + } + ] + } + ], + "index": 11 + }, + { + "bbox": [ + 302, + 439, + 415, + 451 + ], + "type": "title", + "angle": 0, + "lines": [ + { + "bbox": [ + 302, + 439, + 415, + 451 + ], + "spans": [ + { + "bbox": [ + 302, + 439, + 415, + 451 + ], + "type": "text", + "content": "Multi-task Fine-tuning." + } + ] + } + ], + "index": 12 + }, + { + "bbox": [ + 341, + 463, + 525, + 477 + ], + "type": "interline_equation", + "angle": 0, + "lines": [ + { + "bbox": [ + 341, + 463, + 525, + 477 + ], + "spans": [ + { + "bbox": [ + 341, + 463, + 525, + 477 + ], + "type": "interline_equation", + "content": "\\mathcal {L} _ {a l l} = \\mathcal {L} _ {q a} + \\mathcal {L} _ {q p} + \\mathcal {L} _ {p a} + \\mathcal {L} _ {u o t} \\tag {2}", + "image_path": "f2b7e2fad07e73fd153468704cbe5b4bb34b54f78515e8b365ca68711961ab6e.jpg" + } + ] + } + ], + "index": 13 + }, + { + "bbox": [ + 302, + 487, + 525, + 555 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 302, + 487, + 525, + 555 + ], + "spans": [ + { + "bbox": [ + 302, + 487, + 525, + 555 + ], + "type": "text", + "content": "where " + }, + { + "bbox": [ + 302, + 487, + 525, + 555 + ], + "type": "inline_equation", + "content": "\\mathcal{L}_{qa}" + }, + { + "bbox": [ + 302, + 487, + 525, + 555 + ], + "type": "text", + "content": " is the question-answer generation objective, " + }, + { + "bbox": [ + 302, + 487, + 525, + 555 + ], + "type": "inline_equation", + "content": "\\mathcal{L}_{qp}" + }, + { + "bbox": [ + 302, + 487, + 525, + 555 + ], + "type": "text", + "content": " is the question-universal-code generation objective, " + }, + { + "bbox": [ + 302, + 487, + 525, + 555 + ], + "type": "inline_equation", + "content": "\\mathcal{L}_{pa}" + }, + { + "bbox": [ + 302, + 487, + 525, + 555 + ], + "type": "text", + "content": " is the universal-code-answer translation objective, and " + }, + { + "bbox": [ + 302, + 487, + 525, + 555 + ], + "type": "inline_equation", + "content": "\\mathcal{L}_{uot}" + }, + { + "bbox": [ + 302, + 487, + 525, + 555 + ], + "type": "text", + "content": " is the Universal-code-of-Thought (UoT) objective." + } + ] + } + ], + "index": 14 + }, + { + "bbox": [ + 302, + 556, + 525, + 623 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 302, + 556, + 525, + 623 + ], + "spans": [ + { + "bbox": [ + 302, + 556, + 525, + 623 + ], + "type": "text", + "content": "Here, we introduce all four training objectives. For all the following objectives, the multilingual corpora " + }, + { + "bbox": [ + 302, + 556, + 525, + 623 + ], + "type": "inline_equation", + "content": "D_{u} = \\{D_{u}^{L_{k}}\\}_{k = 1}^{K}" + }, + { + "bbox": [ + 302, + 556, + 525, + 623 + ], + "type": "text", + "content": " are given. " + }, + { + "bbox": [ + 302, + 556, + 525, + 623 + ], + "type": "inline_equation", + "content": "\\mathcal{M}" + }, + { + "bbox": [ + 302, + 556, + 525, + 623 + ], + "type": "text", + "content": " is the code LLM and " + }, + { + "bbox": [ + 302, + 556, + 525, + 623 + ], + "type": "inline_equation", + "content": "K" + }, + { + "bbox": [ + 302, + 556, + 525, + 623 + ], + "type": "text", + "content": " is the number of programming languages." + } + ] + } + ], + "index": 15 + }, + { + "bbox": [ + 302, + 631, + 525, + 671 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 302, + 631, + 525, + 671 + ], + "spans": [ + { + "bbox": [ + 302, + 631, + 525, + 671 + ], + "type": "text", + "content": "Question-Answer Objective. The training objective " + }, + { + "bbox": [ + 302, + 631, + 525, + 671 + ], + "type": "inline_equation", + "content": "\\mathcal{L}_{qa}" + }, + { + "bbox": [ + 302, + 631, + 525, + 671 + ], + "type": "text", + "content": " of the standard instruction fine-tuning can be described as:" + } + ] + } + ], + "index": 16 + }, + { + "bbox": [ + 319, + 679, + 525, + 715 + ], + "type": "interline_equation", + "angle": 0, + "lines": [ + { + "bbox": [ + 319, + 679, + 525, + 715 + ], + "spans": [ + { + "bbox": [ + 319, + 679, + 525, + 715 + ], + "type": "interline_equation", + "content": "\\mathcal {L} _ {q a} = - \\sum_ {k = 1} ^ {K} \\mathbb {E} _ {q, a \\sim D _ {u} ^ {L k}} [ \\log P (a | q; \\mathcal {M}) ] \\tag {3}", + "image_path": "f595a1fe77a6274e93611b8ef2d432d1da0260065e1da0d8a239677dd63b1829.jpg" + } + ] + } + ], + "index": 17 + }, + { + "bbox": [ + 302, + 725, + 512, + 739 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 302, + 725, + 512, + 739 + ], + "spans": [ + { + "bbox": [ + 302, + 725, + 512, + 739 + ], + "type": "text", + "content": "where " + }, + { + "bbox": [ + 302, + 725, + 512, + 739 + ], + "type": "inline_equation", + "content": "q" + }, + { + "bbox": [ + 302, + 725, + 512, + 739 + ], + "type": "text", + "content": " and " + }, + { + "bbox": [ + 302, + 725, + 512, + 739 + ], + "type": "inline_equation", + "content": "a" + }, + { + "bbox": [ + 302, + 725, + 512, + 739 + ], + "type": "text", + "content": " are the question and answer pair." + } + ] + } + ], + "index": 18 + }, + { + "bbox": [ + 302, + 746, + 525, + 774 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 302, + 746, + 525, + 774 + ], + "spans": [ + { + "bbox": [ + 302, + 746, + 525, + 774 + ], + "type": "text", + "content": "Question-Universal-Code Objective. The training objective " + }, + { + "bbox": [ + 302, + 746, + 525, + 774 + ], + "type": "inline_equation", + "content": "\\mathcal{L}_{qp}" + }, + { + "bbox": [ + 302, + 746, + 525, + 774 + ], + "type": "text", + "content": " of the auxiliary universal code" + } + ] + } + ], + "index": 19 + } + ], + "discarded_blocks": [ + { + "bbox": [ + 287, + 780, + 309, + 791 + ], + "type": "page_number", + "angle": 0, + "lines": [ + { + "bbox": [ + 287, + 780, + 309, + 791 + ], + "spans": [ + { + "bbox": [ + 287, + 780, + 309, + 791 + ], + "type": "text", + "content": "1815" + } + ] + } + ], + "index": 20 + } + ], + "page_size": [ + 595, + 841 + ], + "page_idx": 3 + }, + { + "para_blocks": [ + { + "bbox": [ + 68, + 71, + 227, + 84 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 68, + 71, + 227, + 84 + ], + "spans": [ + { + "bbox": [ + 68, + 71, + 227, + 84 + ], + "type": "text", + "content": "generation task can be described as:" + } + ] + } + ], + "index": 0 + }, + { + "bbox": [ + 85, + 96, + 290, + 132 + ], + "type": "interline_equation", + "angle": 0, + "lines": [ + { + "bbox": [ + 85, + 96, + 290, + 132 + ], + "spans": [ + { + "bbox": [ + 85, + 96, + 290, + 132 + ], + "type": "interline_equation", + "content": "\\mathcal {L} _ {q p} = - \\sum_ {k = 1} ^ {K} \\mathbb {E} _ {q, p \\sim D _ {L _ {k}}} [ \\log P (p | q; \\mathcal {M}) ] \\tag {4}", + "image_path": "58eeb0fd9282fdb3626d1ecbc70a68714b456478012f4ef35b52e9650cf1a911.jpg" + } + ] + } + ], + "index": 1 + }, + { + "bbox": [ + 68, + 142, + 273, + 156 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 68, + 142, + 273, + 156 + ], + "spans": [ + { + "bbox": [ + 68, + 142, + 273, + 156 + ], + "type": "text", + "content": "where " + }, + { + "bbox": [ + 68, + 142, + 273, + 156 + ], + "type": "inline_equation", + "content": "q" + }, + { + "bbox": [ + 68, + 142, + 273, + 156 + ], + "type": "text", + "content": " and " + }, + { + "bbox": [ + 68, + 142, + 273, + 156 + ], + "type": "inline_equation", + "content": "p" + }, + { + "bbox": [ + 68, + 142, + 273, + 156 + ], + "type": "text", + "content": " are the question and UniCode." + } + ] + } + ], + "index": 2 + }, + { + "bbox": [ + 67, + 165, + 291, + 206 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 67, + 165, + 291, + 206 + ], + "spans": [ + { + "bbox": [ + 67, + 165, + 291, + 206 + ], + "type": "text", + "content": "Universal-Code-Answer Objective. The training objective " + }, + { + "bbox": [ + 67, + 165, + 291, + 206 + ], + "type": "inline_equation", + "content": "\\mathcal{L}_{pa}" + }, + { + "bbox": [ + 67, + 165, + 291, + 206 + ], + "type": "text", + "content": " of generating the executable code answer from UniCode can be described as:" + } + ] + } + ], + "index": 3 + }, + { + "bbox": [ + 83, + 215, + 290, + 251 + ], + "type": "interline_equation", + "angle": 0, + "lines": [ + { + "bbox": [ + 83, + 215, + 290, + 251 + ], + "spans": [ + { + "bbox": [ + 83, + 215, + 290, + 251 + ], + "type": "interline_equation", + "content": "\\mathcal {L} _ {p a} = - \\sum_ {k = 1} ^ {K} \\mathbb {E} _ {p, a \\sim D _ {L _ {k}}} [ \\log P (a | p; \\mathcal {M}) ] \\tag {5}", + "image_path": "e0363fd9ab1f5d9b32819e62618c7328d77a7efd29f64f5f7e7db850dbb781f6.jpg" + } + ] + } + ], + "index": 4 + }, + { + "bbox": [ + 67, + 262, + 267, + 275 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 67, + 262, + 267, + 275 + ], + "spans": [ + { + "bbox": [ + 67, + 262, + 267, + 275 + ], + "type": "text", + "content": "where " + }, + { + "bbox": [ + 67, + 262, + 267, + 275 + ], + "type": "inline_equation", + "content": "p" + }, + { + "bbox": [ + 67, + 262, + 267, + 275 + ], + "type": "text", + "content": " and " + }, + { + "bbox": [ + 67, + 262, + 267, + 275 + ], + "type": "inline_equation", + "content": "a" + }, + { + "bbox": [ + 67, + 262, + 267, + 275 + ], + "type": "text", + "content": " are UniCode and the answer." + } + ] + } + ], + "index": 5 + }, + { + "bbox": [ + 67, + 284, + 289, + 338 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 67, + 284, + 289, + 338 + ], + "spans": [ + { + "bbox": [ + 67, + 284, + 289, + 338 + ], + "type": "text", + "content": "Universal-Code-of-Thought Objective. The training objective " + }, + { + "bbox": [ + 67, + 284, + 289, + 338 + ], + "type": "inline_equation", + "content": "\\mathcal{L}_{\\text {uot }}" + }, + { + "bbox": [ + 67, + 284, + 289, + 338 + ], + "type": "text", + "content": " of generating UniCode and then the executable code answer can be described as:" + } + ] + } + ], + "index": 6 + }, + { + "bbox": [ + 73, + 347, + 290, + 382 + ], + "type": "interline_equation", + "angle": 0, + "lines": [ + { + "bbox": [ + 73, + 347, + 290, + 382 + ], + "spans": [ + { + "bbox": [ + 73, + 347, + 290, + 382 + ], + "type": "interline_equation", + "content": "\\mathcal {L} _ {u o t} = - \\sum_ {k = 1} ^ {K} \\mathbb {E} _ {q, p, a \\sim D _ {L _ {k}}} [ \\log P (p, a | q; \\mathcal {M}) ] \\tag {6}", + "image_path": "d55b0b5904d6d524612b8623f61ee7a4e4c3c05021440c4ed544efe70b783b3e.jpg" + } + ] + } + ], + "index": 7 + }, + { + "bbox": [ + 67, + 394, + 289, + 421 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 67, + 394, + 289, + 421 + ], + "spans": [ + { + "bbox": [ + 67, + 394, + 289, + 421 + ], + "type": "text", + "content": "where " + }, + { + "bbox": [ + 67, + 394, + 289, + 421 + ], + "type": "inline_equation", + "content": "q" + }, + { + "bbox": [ + 67, + 394, + 289, + 421 + ], + "type": "text", + "content": ", " + }, + { + "bbox": [ + 67, + 394, + 289, + 421 + ], + "type": "inline_equation", + "content": "a" + }, + { + "bbox": [ + 67, + 394, + 289, + 421 + ], + "type": "text", + "content": ", and " + }, + { + "bbox": [ + 67, + 394, + 289, + 421 + ], + "type": "inline_equation", + "content": "p" + }, + { + "bbox": [ + 67, + 394, + 289, + 421 + ], + "type": "text", + "content": " are the question, answer, and UniCode, respectively." + } + ] + } + ], + "index": 8 + }, + { + "bbox": [ + 67, + 433, + 190, + 446 + ], + "type": "title", + "angle": 0, + "lines": [ + { + "bbox": [ + 67, + 433, + 190, + 446 + ], + "spans": [ + { + "bbox": [ + 67, + 433, + 190, + 446 + ], + "type": "text", + "content": "4 Experimental Setup" + } + ] + } + ], + "index": 9 + }, + { + "bbox": [ + 67, + 455, + 186, + 467 + ], + "type": "title", + "angle": 0, + "lines": [ + { + "bbox": [ + 67, + 455, + 186, + 467 + ], + "spans": [ + { + "bbox": [ + 67, + 455, + 186, + 467 + ], + "type": "text", + "content": "4.1 Instruction Dataset" + } + ] + } + ], + "index": 10 + }, + { + "bbox": [ + 67, + 473, + 291, + 594 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 67, + 473, + 291, + 594 + ], + "spans": [ + { + "bbox": [ + 67, + 473, + 291, + 594 + ], + "type": "text", + "content": "GPT-4 (gpt-4-1106-preview) (OpenAI, 2023) is used as the foundation model to generate the UNICODER-INSTRUCT. We randomly extract code snippets within 1024 tokens from the StarCoder dataset (Li et al., 2023b) and let GPT-4 summarize the code snippets as the universal code. Based on each code snippet and the corresponding universal code, a self-contained coding problem with a correct solution is created." + } + ] + } + ], + "index": 11 + }, + { + "bbox": [ + 67, + 606, + 139, + 618 + ], + "type": "title", + "angle": 0, + "lines": [ + { + "bbox": [ + 67, + 606, + 139, + 618 + ], + "spans": [ + { + "bbox": [ + 67, + 606, + 139, + 618 + ], + "type": "text", + "content": "4.2 Baselines" + } + ] + } + ], + "index": 12 + }, + { + "bbox": [ + 67, + 624, + 291, + 772 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 67, + 624, + 291, + 772 + ], + "spans": [ + { + "bbox": [ + 67, + 624, + 291, + 772 + ], + "type": "text", + "content": "Proprietary Models. Based on a neural architecture known as generative pre-trained Transformers (GPT) (Vaswani et al., 2017; Radford et al., 2018), GPT-3.5 and GPT-4 are LLMs trained on massive datasets of text, code, math equations, and more. They are also trained to follow instructions (Ouyang et al., 2022), which allows them to generate human-like responses. We use GPT-3.5 Turbo and GPT-4 as the proprietary models because they perform excellently in various code understanding and generation tasks." + } + ] + } + ], + "index": 13 + }, + { + "bbox": [ + 302, + 71, + 526, + 232 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 302, + 71, + 526, + 232 + ], + "spans": [ + { + "bbox": [ + 302, + 71, + 526, + 232 + ], + "type": "text", + "content": "Open-Source Models. To narrow the gap between open-source and closed-source models, a series of open-source models and instruction datasets are proposed to improve code LLMs and bootstrap their instruction-following ability. Starcoder (Li et al., 2023b), Code Llama (Rozière et al., 2023), and DeepSeek-Coder (Guo et al., 2024a) with different model sizes are introduced into the based model. OctoCoder (Muennighoff et al., 2023), WiazrdCoder (Luo et al., 2023), MagiCoder (Wei et al., 2023), and WaveCoder (Yu et al., 2023) are further fine-tuned on these based code LLMs." + } + ] + } + ], + "index": 14 + }, + { + "bbox": [ + 302, + 242, + 527, + 336 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 302, + 242, + 527, + 336 + ], + "spans": [ + { + "bbox": [ + 302, + 242, + 527, + 336 + ], + "type": "text", + "content": "Decontamination. We apply data decontamination before training our UNICODER models to decontaminate the code snippets from the star-coder data (Li et al., 2023b), by removing exact matches from HumanEval (Chen et al., 2021), MBPP (Austin et al., 2021), DS-1000 (Lai et al., 2023), and GSM8K (Cobbe et al., 2021)." + } + ] + } + ], + "index": 15 + }, + { + "bbox": [ + 302, + 346, + 439, + 358 + ], + "type": "title", + "angle": 0, + "lines": [ + { + "bbox": [ + 302, + 346, + 439, + 358 + ], + "spans": [ + { + "bbox": [ + 302, + 346, + 439, + 358 + ], + "type": "text", + "content": "4.3 Evaluation Benchmark" + } + ] + } + ], + "index": 16 + }, + { + "bbox": [ + 302, + 364, + 525, + 499 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 302, + 364, + 525, + 499 + ], + "spans": [ + { + "bbox": [ + 302, + 364, + 525, + 499 + ], + "type": "text", + "content": "HumanEval. The HumanEval test set (Chen et al., 2021) is a crafted collection of 164 Python programming problems to test the abilities of code generation models. For each problem, there are roughly 9.6 test cases to check whether the generated code works as intended. Humaneval has become one of the most popular benchmarks to measure how well these code-writing AI models perform, making it a key tool in the field of AI and machine learning for coding." + } + ] + } + ], + "index": 17 + }, + { + "bbox": [ + 302, + 507, + 525, + 615 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 302, + 507, + 525, + 615 + ], + "spans": [ + { + "bbox": [ + 302, + 507, + 525, + 615 + ], + "type": "text", + "content": "MBPP. The MBPP dataset (Austin et al., 2021), comprising approximately 1,000 Python programming challenges sourced from a crowd of contributors, is tailored for beginners in programming, focusing on core principles and the usage of the standard library. The MBPP test set comprised of 500 problems is selected to evaluate the few-shot inference of the code LLMs." + } + ] + } + ], + "index": 18 + }, + { + "bbox": [ + 302, + 624, + 526, + 705 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 302, + 624, + 526, + 705 + ], + "spans": [ + { + "bbox": [ + 302, + 624, + 526, + 705 + ], + "type": "text", + "content": "MultiPL-E. The MultiPL-E test set (Cassano et al., 2022) translates the original HumanEval test set to other 18 programming languages, i.e., Javascript, Java, Typescript, C++, and Rust. We use the MultiPL-E to evaluate the multilingual capabilities of the code LLMs." + } + ] + } + ], + "index": 19 + }, + { + "bbox": [ + 302, + 714, + 421, + 726 + ], + "type": "title", + "angle": 0, + "lines": [ + { + "bbox": [ + 302, + 714, + 421, + 726 + ], + "spans": [ + { + "bbox": [ + 302, + 714, + 421, + 726 + ], + "type": "text", + "content": "4.4 Evaluation Metrics" + } + ] + } + ], + "index": 20 + }, + { + "bbox": [ + 302, + 733, + 525, + 772 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 302, + 733, + 525, + 772 + ], + "spans": [ + { + "bbox": [ + 302, + 733, + 525, + 772 + ], + "type": "text", + "content": "Pass@k. We adopt the Pass@k metric (Chen et al., 2021) to improve the reliability of our evaluation. We then count the total number of success" + } + ] + } + ], + "index": 21 + } + ], + "discarded_blocks": [ + { + "bbox": [ + 287, + 781, + 310, + 791 + ], + "type": "page_number", + "angle": 0, + "lines": [ + { + "bbox": [ + 287, + 781, + 310, + 791 + ], + "spans": [ + { + "bbox": [ + 287, + 781, + 310, + 791 + ], + "type": "text", + "content": "1816" + } + ] + } + ], + "index": 22 + } + ], + "page_size": [ + 595, + 841 + ], + "page_idx": 4 + }, + { + "para_blocks": [ + { + "bbox": [ + 67, + 71, + 290, + 111 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 67, + 71, + 290, + 111 + ], + "spans": [ + { + "bbox": [ + 67, + 71, + 290, + 111 + ], + "type": "text", + "content": "fully passing test cases, denoted as " + }, + { + "bbox": [ + 67, + 71, + 290, + 111 + ], + "type": "inline_equation", + "content": "k" + }, + { + "bbox": [ + 67, + 71, + 290, + 111 + ], + "type": "text", + "content": ", to compute the Pass@k, thereby enhancing the accuracy and consistency of the performance assessment." + } + ] + } + ], + "index": 0 + }, + { + "bbox": [ + 118, + 119, + 290, + 155 + ], + "type": "interline_equation", + "angle": 0, + "lines": [ + { + "bbox": [ + 118, + 119, + 290, + 155 + ], + "spans": [ + { + "bbox": [ + 118, + 119, + 290, + 155 + ], + "type": "interline_equation", + "content": "\\operatorname {P a s s} @ \\mathrm {k} = \\mathbb {E} \\left[ 1 - \\frac {\\binom {n} {k - c}}{\\binom {n} {k}} \\right] \\tag {7}", + "image_path": "3f15478153e8a72e7129cdbbd567e8602dd0fdf76b3b39e6df7917a827fa0844.jpg" + } + ] + } + ], + "index": 1 + }, + { + "bbox": [ + 67, + 162, + 290, + 216 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 67, + 162, + 290, + 216 + ], + "spans": [ + { + "bbox": [ + 67, + 162, + 290, + 216 + ], + "type": "text", + "content": "where " + }, + { + "bbox": [ + 67, + 162, + 290, + 216 + ], + "type": "inline_equation", + "content": "n" + }, + { + "bbox": [ + 67, + 162, + 290, + 216 + ], + "type": "text", + "content": " is the total number of generated samples for each problem, and " + }, + { + "bbox": [ + 67, + 162, + 290, + 216 + ], + "type": "inline_equation", + "content": "c" + }, + { + "bbox": [ + 67, + 162, + 290, + 216 + ], + "type": "text", + "content": " is the number of correct generated code snippets passing all the test cases " + }, + { + "bbox": [ + 67, + 162, + 290, + 216 + ], + "type": "inline_equation", + "content": "(n > k \\geq c)" + }, + { + "bbox": [ + 67, + 162, + 290, + 216 + ], + "type": "text", + "content": "." + } + ] + } + ], + "index": 2 + }, + { + "bbox": [ + 67, + 225, + 210, + 238 + ], + "type": "title", + "angle": 0, + "lines": [ + { + "bbox": [ + 67, + 225, + 210, + 238 + ], + "spans": [ + { + "bbox": [ + 67, + 225, + 210, + 238 + ], + "type": "text", + "content": "4.5 Implementmentation Details" + } + ] + } + ], + "index": 3 + }, + { + "bbox": [ + 67, + 242, + 291, + 553 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 67, + 242, + 291, + 553 + ], + "spans": [ + { + "bbox": [ + 67, + 242, + 291, + 553 + ], + "type": "text", + "content": "We expand the open-source Evol-Instruct dataset evol-code-alpaca-v1 (Xu et al., 2023) with nearly 110K samples into the instruction dataset with the universal code. For the code snippets collected from starcoderdata " + }, + { + "bbox": [ + 67, + 242, + 291, + 553 + ], + "type": "inline_equation", + "content": "^{2}" + }, + { + "bbox": [ + 67, + 242, + 291, + 553 + ], + "type": "text", + "content": ", we choose 5K code snippets of each language (Python, Javascript, C++, Java, Rust, and Go) to construct the synthetic instruction dataset with universal code. Finally, we obtain the instruction dataset UNICODERINSTRUCT contains nearly 140K training samples. Code-Llama and DeepSeek-Coder-Base are used as the foundational code LLMs for supervised fine-tuning (SFT). We fine-tune these foundation LLMs on nearly 150K samples generated from evol-codealpaca-v1 and the starcoder pre-training data. UNICODER is fine-tuned on Standford_Alpaca " + }, + { + "bbox": [ + 67, + 242, + 291, + 553 + ], + "type": "inline_equation", + "content": "^{3}" + }, + { + "bbox": [ + 67, + 242, + 291, + 553 + ], + "type": "text", + "content": " with 8 NVIDIA A100-80GB GPUs. The learning rate first increases into " + }, + { + "bbox": [ + 67, + 242, + 291, + 553 + ], + "type": "inline_equation", + "content": "8 \\times 10^{-5}" + }, + { + "bbox": [ + 67, + 242, + 291, + 553 + ], + "type": "text", + "content": " with 50 warmup steps and then adopts a cosine decay scheduler. We adopt the Adam optimizer (Kingma and Ba, 2015) with a global batch size of 128 samples, truncating sentences to 1536 tokens." + } + ] + } + ], + "index": 4 + }, + { + "bbox": [ + 67, + 563, + 206, + 576 + ], + "type": "title", + "angle": 0, + "lines": [ + { + "bbox": [ + 67, + 563, + 206, + 576 + ], + "spans": [ + { + "bbox": [ + 67, + 563, + 206, + 576 + ], + "type": "text", + "content": "5 Results and Discussion" + } + ] + } + ], + "index": 5 + }, + { + "bbox": [ + 67, + 585, + 158, + 597 + ], + "type": "title", + "angle": 0, + "lines": [ + { + "bbox": [ + 67, + 585, + 158, + 597 + ], + "spans": [ + { + "bbox": [ + 67, + 585, + 158, + 597 + ], + "type": "text", + "content": "5.1 Main Results" + } + ] + } + ], + "index": 6 + }, + { + "bbox": [ + 67, + 602, + 291, + 723 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 67, + 602, + 291, + 723 + ], + "spans": [ + { + "bbox": [ + 67, + 602, + 291, + 723 + ], + "type": "text", + "content": "Python Code Generation. Table 1 shows that UNICODER significantly beats previous strong open-source baselines using UoT, closing the gap with GPT-3.5 and GPT-4. Magicoder (Wei et al., 2023) and Wavecoder (Yu et al., 2023) both prove the effectiveness of instruction datasets from code snippets. Further, UNICODER outperforms the WizardCoder with 15B parameters and EvolInstruct techniques with the help of the UniCode." + } + ] + } + ], + "index": 7 + }, + { + "bbox": [ + 67, + 729, + 259, + 772 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 67, + 729, + 259, + 772 + ], + "spans": [ + { + "bbox": [ + 67, + 729, + 259, + 772 + ], + "type": "inline_equation", + "content": "^{2}" + }, + { + "bbox": [ + 67, + 729, + 259, + 772 + ], + "type": "text", + "content": "https://huggingface.co/datasets/bigcode/starcoderdata \n" + }, + { + "bbox": [ + 67, + 729, + 259, + 772 + ], + "type": "inline_equation", + "content": "^{3}" + }, + { + "bbox": [ + 67, + 729, + 259, + 772 + ], + "type": "text", + "content": "https://github.com/tatsu-lab/stanford_alpaca" + } + ] + } + ], + "index": 8 + }, + { + "bbox": [ + 302, + 71, + 526, + 248 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 302, + 71, + 526, + 248 + ], + "spans": [ + { + "bbox": [ + 302, + 71, + 526, + 248 + ], + "type": "text", + "content": "Multilingual Code Understanding. Table 2 shows that UNICODER significantly outperforms strong baselines Magicoder and WaveCoder, which both leverage the code snippets to construct the instruction dataset. Given the multilingual correct code snippet, the code LLM is tasked to generate an explanation of the code and then regenerate the code only based on its own explanation. For the different backbones (Code Llama and DeepseekCoder), our method beats most previous methods, especially in other languages, which demonstrates that UNICODER-INSTRUCT can bring the capability of multilingual understanding and generation." + } + ] + } + ], + "index": 9 + }, + { + "bbox": [ + 302, + 257, + 380, + 269 + ], + "type": "title", + "angle": 0, + "lines": [ + { + "bbox": [ + 302, + 257, + 380, + 269 + ], + "spans": [ + { + "bbox": [ + 302, + 257, + 380, + 269 + ], + "type": "text", + "content": "5.2 Discussion" + } + ] + } + ], + "index": 10 + }, + { + "bbox": [ + 302, + 273, + 525, + 396 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 302, + 273, + 525, + 396 + ], + "spans": [ + { + "bbox": [ + 302, + 273, + 525, + 396 + ], + "type": "text", + "content": "Ablation Study. To verify the efficacy of each component, we conduct the ablation study step by step on HumanEval and MBPP. In Table 3, we observe that removing the multi-tasks objective (only keeping the UoT objective: Equation 6) will have a " + }, + { + "bbox": [ + 302, + 273, + 525, + 396 + ], + "type": "inline_equation", + "content": "-1.6" + }, + { + "bbox": [ + 302, + 273, + 525, + 396 + ], + "type": "text", + "content": " performance drop in HumanEval and a " + }, + { + "bbox": [ + 302, + 273, + 525, + 396 + ], + "type": "inline_equation", + "content": "-1.3" + }, + { + "bbox": [ + 302, + 273, + 525, + 396 + ], + "type": "text", + "content": " drop in MBPP. Removing UniCode will further degrade the performance. The results support the effectiveness of each component of UNICODER." + } + ] + } + ], + "index": 11 + }, + { + "bbox": [ + 302, + 403, + 525, + 483 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 302, + 403, + 525, + 483 + ], + "spans": [ + { + "bbox": [ + 302, + 403, + 525, + 483 + ], + "type": "text", + "content": "Effect on Universal Code. To discuss the effect of the different formats of the universal code, we use different definitions of universal code for UNI-CODER. Specifically, we randomly sample 5K samples to generate the instruction dataset with different formats of UniCode." + } + ] + } + ], + "index": 12 + }, + { + "bbox": [ + 316, + 493, + 526, + 772 + ], + "type": "list", + "angle": 0, + "index": 19, + "blocks": [ + { + "bbox": [ + 316, + 493, + 525, + 547 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 316, + 493, + 525, + 547 + ], + "spans": [ + { + "bbox": [ + 316, + 493, + 525, + 547 + ], + "type": "text", + "content": "- UniCode 1: It describes the naming conventions, variable declaration, operators, conditional statements, loops, and function structure that pseudocode should have." + } + ] + } + ], + "index": 13 + }, + { + "bbox": [ + 316, + 552, + 526, + 605 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 316, + 552, + 526, + 605 + ], + "spans": [ + { + "bbox": [ + 316, + 552, + 526, + 605 + ], + "type": "text", + "content": "- UniCode 2: It separates the first set of standards and provides code examples for each, instead of applying them all together in the examples." + } + ] + } + ], + "index": 14 + }, + { + "bbox": [ + 316, + 611, + 526, + 664 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 316, + 611, + 526, + 664 + ], + "spans": [ + { + "bbox": [ + 316, + 611, + 526, + 664 + ], + "type": "text", + "content": "- UniCode 3: It describes the code structure, variable rules, control structures, functions, comments, and assignment rules that pseudocode should have." + } + ] + } + ], + "index": 15 + }, + { + "bbox": [ + 316, + 670, + 526, + 696 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 316, + 670, + 526, + 696 + ], + "spans": [ + { + "bbox": [ + 316, + 670, + 526, + 696 + ], + "type": "text", + "content": "- UniCode 4: It is similar to the first standard but specifies type-free names for variables." + } + ] + } + ], + "index": 16 + }, + { + "bbox": [ + 316, + 701, + 526, + 740 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 316, + 701, + 526, + 740 + ], + "spans": [ + { + "bbox": [ + 316, + 701, + 526, + 740 + ], + "type": "text", + "content": "- UniCode 5: It provides an abstract, high-level architectural description, without setting standards for the code itself." + } + ] + } + ], + "index": 17 + }, + { + "bbox": [ + 316, + 746, + 526, + 772 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 316, + 746, + 526, + 772 + ], + "spans": [ + { + "bbox": [ + 316, + 746, + 526, + 772 + ], + "type": "text", + "content": "- UniCode 6: It uses latex algorithm and algorithmic packages for description." + } + ] + } + ], + "index": 18 + } + ], + "sub_type": "text" + } + ], + "discarded_blocks": [ + { + "bbox": [ + 287, + 780, + 309, + 791 + ], + "type": "page_number", + "angle": 0, + "lines": [ + { + "bbox": [ + 287, + 780, + 309, + 791 + ], + "spans": [ + { + "bbox": [ + 287, + 780, + 309, + 791 + ], + "type": "text", + "content": "1817" + } + ] + } + ], + "index": 20 + } + ], + "page_size": [ + 595, + 841 + ], + "page_idx": 5 + }, + { + "para_blocks": [ + { + "type": "table", + "bbox": [ + 105, + 68, + 492, + 236 + ], + "blocks": [ + { + "bbox": [ + 105, + 68, + 492, + 236 + ], + "lines": [ + { + "bbox": [ + 105, + 68, + 492, + 236 + ], + "spans": [ + { + "bbox": [ + 105, + 68, + 492, + 236 + ], + "type": "table", + "html": "
ModelsBase ModelParamsInstruction DataModel WeightHumanEvalMBPP
Proprietary Models
GPT-3.5----72.681.6
GPT-4----85.483.0
Open-source Models
StarCoder (Li et al., 2023b)-15BX✓33.643.3
WizardCoder (Luo et al., 2023)StarCoder15B✓✓57.351.8
OctoCoder (Muennighoff et al., 2023)StarCoder15B✓✓46.243.5
WaveCoder-SC (Muennighoff et al., 2023)StarCoder15B✓✓50.551.0
Code-Llama (Rozière et al., 2023)-7BX✓33.541.4
Code-Llama-Instruct (Rozière et al., 2023)Code Llama7B✓✓34.844.4
WaveCoder-CL (Yu et al., 2023)Code Llama7B✓✓48.147.2
Magicoder-CL (Wei et al., 2023)Code Llama7B✓✓60.464.2
UNICODER (our method)Code Llama7B✓✓65.465.2
DeepseekCoder (Guo et al., 2024a)-6.7BX✓49.460.6
WaveCoder-DS (Yu et al., 2023)Deepseek-Coder6.7B✓✓64.062.8
UNICODER (our method)Deepseek-Coder6.7B✓✓70.664.3
", + "image_path": "dcb254f98d184af0bcc8e68b6be22b264cc9677ae42612b982401ad584f45b81.jpg" + } + ] + } + ], + "index": 0, + "angle": 0, + "type": "table_body" + } + ], + "index": 0 + }, + { + "type": "table", + "bbox": [ + 103, + 279, + 492, + 485 + ], + "blocks": [ + { + "bbox": [ + 67, + 244, + 525, + 269 + ], + "lines": [ + { + "bbox": [ + 67, + 244, + 525, + 269 + ], + "spans": [ + { + "bbox": [ + 67, + 244, + 525, + 269 + ], + "type": "text", + "content": "Table 1: Evaluation results of Pass@1 on the HumanEval and MBPP benchmark. We use self-reported scores whenever available. All methods use greedy decoding and We use the reported scores of the previous work." + } + ] + } + ], + "index": 1, + "angle": 0, + "type": "table_caption" + }, + { + "bbox": [ + 103, + 279, + 492, + 485 + ], + "lines": [ + { + "bbox": [ + 103, + 279, + 492, + 485 + ], + "spans": [ + { + "bbox": [ + 103, + 279, + 492, + 485 + ], + "type": "table", + "html": "
ModelParamsProgramming Language
JavaJavascriptC++PHPSwiftRustAvg.
Proprietary models
GPT-3.5-69.267.163.460.9---
GPT-4-81.678.076.477.2---
Open-source models
CodeLlama (Rozière et al., 2023)34B40.241.741.440.435.338.739.6
CodeLlama-Python (Rozière et al., 2023)34B39.544.739.139.834.339.739.5
CodeLlama-Instruct (Rozière et al., 2023)34B41.545.941.537.037.639.340.5
WizardCoder-CL (Luo et al., 2023)34B44.955.347.247.244.346.247.5
StarCoderBase (Li et al., 2023b)15B28.531.730.626.816.724.526.5
StarCoder (Li et al., 2023b)15B30.230.831.626.122.721.827.2
WizardCoder-SC (Luo et al., 2023)15B35.841.939.039.333.727.136.1
CodeLlama (Rozière et al., 2023)7B29.331.727.025.125.625.527.4
CodeLlama-Python (Rozière et al., 2023)7B42.451.942.346.529.433.629.7
UNICODER (Our method)7B46.450.239.240.441.232.441.6
", + "image_path": "e63127ca84ac1180e532f34a75fd865acc7575a08027b810aac9e9179f00b985.jpg" + } + ] + } + ], + "index": 2, + "angle": 0, + "type": "table_body" + } + ], + "index": 2 + }, + { + "type": "table", + "bbox": [ + 71, + 536, + 287, + 593 + ], + "blocks": [ + { + "bbox": [ + 67, + 493, + 525, + 519 + ], + "lines": [ + { + "bbox": [ + 67, + 493, + 525, + 519 + ], + "spans": [ + { + "bbox": [ + 67, + 493, + 525, + 519 + ], + "type": "text", + "content": "Table 2: Evaluation results of Pass@1 (%) performance on the MultiPL-E benchmark. The baseline results are partly from the previous work (Wei et al., 2023)." + } + ] + } + ], + "index": 3, + "angle": 0, + "type": "table_caption" + }, + { + "bbox": [ + 71, + 536, + 287, + 593 + ], + "lines": [ + { + "bbox": [ + 71, + 536, + 287, + 593 + ], + "spans": [ + { + "bbox": [ + 71, + 536, + 287, + 593 + ], + "type": "table", + "html": "
IDMethodsHumanEvalMBPP
①UNICODER70.664.3
②① - Multi-tasks Objective67.460.2
③② - Universal Code66.859.8
", + "image_path": "5a63424b9afb0f222824470b44789cb80431a364db6fd59fcc7f9ba11e64140e.jpg" + } + ] + } + ], + "index": 4, + "angle": 0, + "type": "table_body" + } + ], + "index": 4 + }, + { + "bbox": [ + 67, + 651, + 292, + 773 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 67, + 651, + 292, + 773 + ], + "spans": [ + { + "bbox": [ + 67, + 651, + 292, + 773 + ], + "type": "text", + "content": "In Table 4, we can observe that the evaluation results of UniCode " + }, + { + "bbox": [ + 67, + 651, + 292, + 773 + ], + "type": "inline_equation", + "content": "1 \\sim" + }, + { + "bbox": [ + 67, + 651, + 292, + 773 + ], + "type": "text", + "content": " UniCode 4 have better performance. Compared to the universal code format UniCode 5 and UniCode 6, UniCode " + }, + { + "bbox": [ + 67, + 651, + 292, + 773 + ], + "type": "inline_equation", + "content": "1 \\sim" + }, + { + "bbox": [ + 67, + 651, + 292, + 773 + ], + "type": "text", + "content": " UniCode 4 has a clear definition and common structure, which brings more support for code generation. Notably, the experiment ⑦ performs the best by combing the training data of " + }, + { + "bbox": [ + 67, + 651, + 292, + 773 + ], + "type": "inline_equation", + "content": "1 \\sim 4" + }, + { + "bbox": [ + 67, + 651, + 292, + 773 + ], + "type": "text", + "content": ". The experimental results show that the concrete defi" + } + ] + } + ], + "index": 6 + }, + { + "type": "table", + "bbox": [ + 323, + 536, + 506, + 640 + ], + "blocks": [ + { + "bbox": [ + 67, + 601, + 290, + 639 + ], + "lines": [ + { + "bbox": [ + 67, + 601, + 290, + 639 + ], + "spans": [ + { + "bbox": [ + 67, + 601, + 290, + 639 + ], + "type": "text", + "content": "Table 3: Ablation study of our proposed method on HumanEval and MBPP. UNICODER is fine-tuned on the UNICODER-INSTRUCT with the multi-task objectives." + } + ] + } + ], + "index": 5, + "angle": 0, + "type": "table_caption" + }, + { + "bbox": [ + 323, + 536, + 506, + 640 + ], + "lines": [ + { + "bbox": [ + 323, + 536, + 506, + 640 + ], + "spans": [ + { + "bbox": [ + 323, + 536, + 506, + 640 + ], + "type": "table", + "html": "
IDMethodsHumanEvalMBPP
①UniCode 153.251.5
②UniCode 252.851.2
③UniCode 353.550.5
④UniCode 453.849.5
⑤UniCode 549.550.2
⑥UniCode 648.248.4
⑦UniCode 1~455.552.2
", + "image_path": "1b9e9681ba89eb9ef4b9719b9c152c657f814caa061929d6f7fcbb82c2db2859.jpg" + } + ] + } + ], + "index": 7, + "angle": 0, + "type": "table_body" + } + ], + "index": 7 + }, + { + "bbox": [ + 302, + 648, + 525, + 671 + ], + "lines": [ + { + "bbox": [ + 302, + 648, + 525, + 671 + ], + "spans": [ + { + "bbox": [ + 302, + 648, + 525, + 671 + ], + "type": "text", + "content": "Table 4: Evaluation results of our method with different formats of the universal code." + } + ] + } + ], + "index": 8, + "angle": 0, + "type": "text" + }, + { + "bbox": [ + 302, + 687, + 524, + 713 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 302, + 687, + 524, + 713 + ], + "spans": [ + { + "bbox": [ + 302, + 687, + 524, + 713 + ], + "type": "text", + "content": "nition of UniCode and the combination of it can effectively improve the model performance." + } + ] + } + ], + "index": 9 + }, + { + "bbox": [ + 302, + 726, + 432, + 738 + ], + "type": "title", + "angle": 0, + "lines": [ + { + "bbox": [ + 302, + 726, + 432, + 738 + ], + "spans": [ + { + "bbox": [ + 302, + 726, + 432, + 738 + ], + "type": "text", + "content": "5.3 Code-UniCode-Code" + } + ] + } + ], + "index": 10 + }, + { + "bbox": [ + 302, + 746, + 525, + 773 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 302, + 746, + 525, + 773 + ], + "spans": [ + { + "bbox": [ + 302, + 746, + 525, + 773 + ], + "type": "text", + "content": "To compare the capabilities of different code LLMs, we create a test set by prompting the code" + } + ] + } + ], + "index": 11 + } + ], + "discarded_blocks": [ + { + "bbox": [ + 287, + 781, + 309, + 791 + ], + "type": "page_number", + "angle": 0, + "lines": [ + { + "bbox": [ + 287, + 781, + 309, + 791 + ], + "spans": [ + { + "bbox": [ + 287, + 781, + 309, + 791 + ], + "type": "text", + "content": "1818" + } + ] + } + ], + "index": 12 + } + ], + "page_size": [ + 595, + 841 + ], + "page_idx": 6 + }, + { + "para_blocks": [ + { + "type": "table", + "bbox": [ + 71, + 68, + 287, + 120 + ], + "blocks": [ + { + "bbox": [ + 71, + 68, + 287, + 120 + ], + "lines": [ + { + "bbox": [ + 71, + 68, + 287, + 120 + ], + "spans": [ + { + "bbox": [ + 71, + 68, + 287, + 120 + ], + "type": "table", + "html": "
MethodParamsPythonOther Languages
Code-Llama-Instruct7B33.326.2
Code-Llama-Alpaca7B44.229.1
UNICODER7B45.231.3
", + "image_path": "5f0cc445156f8021d313100b79366a5a3b32538bcf33f6b617a253d3c49a13ba.jpg" + } + ] + } + ], + "index": 0, + "angle": 0, + "type": "table_body" + } + ], + "index": 0 + }, + { + "bbox": [ + 67, + 128, + 290, + 153 + ], + "lines": [ + { + "bbox": [ + 67, + 128, + 290, + 153 + ], + "spans": [ + { + "bbox": [ + 67, + 128, + 290, + 153 + ], + "type": "text", + "content": "Table 5: Pass@1 scores of our method UNICODER and two Code-Llama baselines for Code-UniCode-Code." + } + ] + } + ], + "index": 1, + "angle": 0, + "type": "text" + }, + { + "bbox": [ + 67, + 164, + 291, + 326 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 67, + 164, + 291, + 326 + ], + "spans": [ + { + "bbox": [ + 67, + 164, + 291, + 326 + ], + "type": "text", + "content": "LLM to generate UniCode and translate it into the executable code. We check the correctness of each translated code with the test cases, denoted as Pass@1 of the universal code. Code-Llama-7B is fine-tuned on the Code Alpaca dataset and our dataset UNICODER-INSTRUCT separately. The results of fine-tuned Code-Llama models on UNICODER-BENCH are shown in Table 5. Our method UNICODER is more accurate in passing the test cases than the Code-Llama baselines, demonstrating its excellent code understanding and generation abilities." + } + ] + } + ], + "index": 2 + }, + { + "bbox": [ + 67, + 337, + 161, + 350 + ], + "type": "title", + "angle": 0, + "lines": [ + { + "bbox": [ + 67, + 337, + 161, + 350 + ], + "spans": [ + { + "bbox": [ + 67, + 337, + 161, + 350 + ], + "type": "text", + "content": "6 Related Work" + } + ] + } + ], + "index": 3 + }, + { + "bbox": [ + 67, + 359, + 291, + 709 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 67, + 359, + 291, + 709 + ], + "spans": [ + { + "bbox": [ + 67, + 359, + 291, + 709 + ], + "type": "text", + "content": "Code Understanding and Generation. Code understanding and generation as the key tasks to substantially facilitate the project development process, including code generation (Chen et al., 2021; Austin et al., 2021; Zhang et al., 2023), code translation (Szafraniec et al., 2023), automated testing (Deng et al., 2023), bug fixing (Muennighoff et al., 2023), code refinement (Liu et al., 2023c), code question answering (Liu and Wan, 2021), and code summarization (Ahmad et al., 2020). Researchers Chai et al. (2023) have undertaken extensive endeavors to bridge natural language and programming languages. With less ambiguous prompt styles, Mishra et al. (2023) using pseudocode improves the performance of NLP tasks. Oda et al. (2015) uses traditional machine learning to achieve code to pseudocode conversion. Jiang et al. (2022) also shows that designers and programmers can speed up the prototyping process, and ground communication between collaborators via prompt-based prototyping. To verify that the generated code is correct, there are some code synthesis evaluation frameworks, including EvalPlus (Liu et al., 2023b), HumanEval (Chen et al., 2021), HumanEval-X (Zheng et al., 2023), and MBPP (Austin et al., 2021)." + } + ] + } + ], + "index": 4 + }, + { + "bbox": [ + 67, + 719, + 291, + 773 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 67, + 719, + 291, + 773 + ], + "spans": [ + { + "bbox": [ + 67, + 719, + 291, + 773 + ], + "type": "text", + "content": "Large Language Models for Code. Since CodeBERT (Feng et al., 2020) first connected code tasks with pre-trained models, large language models for code have developed rapidly, demonstrating ex" + } + ] + } + ], + "index": 5 + }, + { + "bbox": [ + 302, + 71, + 526, + 343 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 302, + 71, + 526, + 343 + ], + "spans": [ + { + "bbox": [ + 302, + 71, + 526, + 343 + ], + "type": "text", + "content": "traordinary performance on almost all code tasks, rather than a single task. Prominent large models include Codex (Chen et al., 2021), AlphaCode (Li et al., 2022), SantaCoder (Allal et al., 2023), Starcoder (Li et al., 2023b), WizardCoder (Luo et al., 2023), InCoder (Fried et al., 2022), CodeT5 (Wang et al., 2021), CodeGeeX (Zheng et al., 2023), Code Llama (Rozière et al., 2023), and CodeQWen (Bai et al., 2023). To improve the performance of code generation, researchers used optimized prompts (Liu et al., 2023a; Reynolds and McDonell, 2021; Zan et al., 2023; Beurer-Kellner et al., 2023), bring test cases (Chen et al., 2023) and collaborative roles (Dong et al., 2023). There are also some related studies on using large language models for other code tasks, such as dynamic programming (Dagan et al., 2023), compiler optimization (Cummins et al., 2023), multilingual prompts (Di et al., 2023), and program of thoughts (Chen et al., 2022) (PoT)." + } + ] + } + ], + "index": 6 + }, + { + "bbox": [ + 302, + 354, + 526, + 558 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 302, + 354, + 526, + 558 + ], + "spans": [ + { + "bbox": [ + 302, + 354, + 526, + 558 + ], + "type": "text", + "content": "Chain-of-Thought Prompting. To unleash the potential of LLMs in addressing complex reasoning tasks, chain-of-thought (CoT) prompting (Wei et al., 2022b; Kojima et al., 2022) extends in-context learning with step-by-step reasoning processes, which handles complex reasoning tasks in the field of the code and mathematics by encouraging them to engage in step-by-step reasoning processes. Following this line of research, X-of-Thought (XoT) reasoning (CoT and its structural variants further) (Chai et al., 2024; Yao et al., 2023; Li et al., 2023a; Lei et al., 2023; Guo et al., 2023; Ji et al., 2024; Guo et al., 2024b) further expands the capabilities and applications of LLMs in complex reasoning and planning scenarios." + } + ] + } + ], + "index": 7 + }, + { + "bbox": [ + 302, + 570, + 526, + 772 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 302, + 570, + 526, + 772 + ], + "spans": [ + { + "bbox": [ + 302, + 570, + 526, + 772 + ], + "type": "text", + "content": "Intermediate Representation In the field of natural language processing, there exist many works using intermediate representation (Gan et al., 2021; Yang et al., 2022, 2024, 2019, 2020b,a; Liang et al., 2024), such as text generation and translation. The universal code is used as the intermediate representation, which typically omits details that are essential for the machine implementation of the algorithm. We perform the coarse-to-fine pattern for the code generation and translation, where the universal code first summarizes the algorithm process and then the programming language gives the accurate solution. The Unicode provides explicit help for code generation such as Chain-of-thought in LLM." + } + ] + } + ], + "index": 8 + } + ], + "discarded_blocks": [ + { + "bbox": [ + 287, + 781, + 310, + 791 + ], + "type": "page_number", + "angle": 0, + "lines": [ + { + "bbox": [ + 287, + 781, + 310, + 791 + ], + "spans": [ + { + "bbox": [ + 287, + 781, + 310, + 791 + ], + "type": "text", + "content": "1819" + } + ] + } + ], + "index": 9 + } + ], + "page_size": [ + 595, + 841 + ], + "page_idx": 7 + }, + { + "para_blocks": [ + { + "bbox": [ + 68, + 71, + 147, + 83 + ], + "type": "title", + "angle": 0, + "lines": [ + { + "bbox": [ + 68, + 71, + 147, + 83 + ], + "spans": [ + { + "bbox": [ + 68, + 71, + 147, + 83 + ], + "type": "text", + "content": "7 Conclusion" + } + ] + } + ], + "index": 0 + }, + { + "bbox": [ + 67, + 92, + 293, + 309 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 67, + 92, + 293, + 309 + ], + "spans": [ + { + "bbox": [ + 67, + 92, + 293, + 309 + ], + "type": "text", + "content": "In this work, we put forth a state-of-the-art framework UNICODER for both code translation and code generation. Using the universal code UniCode as the intermediate representation, we effectively bridge different programming languages and facilitate code tasks. In addition, we collect a dataset UNICODER-INSTRUCT with 140K instruction instances from existing instruction datasets and the raw code snippets. After being fine-tuned on UNICODER-INSTRUCT with multi-task learning objectives, our model generates UniCode and translates it into the final answer (executable code). The evaluation results on code translation and generation tasks demonstrate that our method significantly improves the generalization ability, showing the efficacy and superiority of UNICODER." + } + ] + } + ], + "index": 1 + }, + { + "bbox": [ + 67, + 318, + 131, + 331 + ], + "type": "title", + "angle": 0, + "lines": [ + { + "bbox": [ + 67, + 318, + 131, + 331 + ], + "spans": [ + { + "bbox": [ + 67, + 318, + 131, + 331 + ], + "type": "text", + "content": "Limitations" + } + ] + } + ], + "index": 2 + }, + { + "bbox": [ + 67, + 340, + 291, + 476 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 67, + 340, + 291, + 476 + ], + "spans": [ + { + "bbox": [ + 67, + 340, + 291, + 476 + ], + "type": "text", + "content": "We acknowledge the following limitations of this study: (1) The evaluation focuses on benchmark datasets (Humaneval, MBPP, and MultiPL-E), and the model's effectiveness in real-world programming scenarios or industry applications is not fully explored. (2) Our method is developed and evaluated primarily on programming language benchmarks. Its effectiveness in other domains or for non-programming-related tasks is not assessed, which limits the generalizability of our findings." + } + ] + } + ], + "index": 3 + }, + { + "bbox": [ + 68, + 486, + 145, + 499 + ], + "type": "title", + "angle": 0, + "lines": [ + { + "bbox": [ + 68, + 486, + 145, + 499 + ], + "spans": [ + { + "bbox": [ + 68, + 486, + 145, + 499 + ], + "type": "text", + "content": "Acknowledge" + } + ] + } + ], + "index": 4 + }, + { + "bbox": [ + 67, + 507, + 291, + 696 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 67, + 507, + 291, + 696 + ], + "spans": [ + { + "bbox": [ + 67, + 507, + 291, + 696 + ], + "type": "text", + "content": "This work was supported in part by the National Natural Science Foundation of China (Grant Nos. U1636211, U2333205, 61672081, 62302025, 62276017), a fund project: State Grid Co., Ltd. Technology R&D Project (ProjectName: Research on Key Technologies of Data Scenario-based Security Governance and Emergency Blocking in Power Monitoring System, Project No.: 5108-202303439A-3-2-ZN), the 2022 CCF-NSFOCUS Kun-Peng Scientific Research Fund and the Opening Project of Shanghai Trusted Industrial Control Platform and the State Key Laboratory of Complex & Critical Software Environment (Grant No. SKLSDE-2021ZX-18)." + } + ] + } + ], + "index": 5 + }, + { + "bbox": [ + 68, + 719, + 127, + 733 + ], + "type": "title", + "angle": 0, + "lines": [ + { + "bbox": [ + 68, + 719, + 127, + 733 + ], + "spans": [ + { + "bbox": [ + 68, + 719, + 127, + 733 + ], + "type": "text", + "content": "References" + } + ] + } + ], + "index": 6 + }, + { + "bbox": [ + 68, + 738, + 291, + 772 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 68, + 738, + 291, + 772 + ], + "spans": [ + { + "bbox": [ + 68, + 738, + 291, + 772 + ], + "type": "text", + "content": "Wasi Uddin Ahmad, Saikat Chakraborty, Baishakhi Ray, and Kai-Wei Chang. 2020. A transformer-based approach for source code summarization. In Proceed" + } + ] + } + ], + "index": 7 + }, + { + "bbox": [ + 304, + 72, + 526, + 772 + ], + "type": "list", + "angle": 0, + "index": 17, + "blocks": [ + { + "bbox": [ + 313, + 72, + 525, + 117 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 313, + 72, + 525, + 117 + ], + "spans": [ + { + "bbox": [ + 313, + 72, + 525, + 117 + ], + "type": "text", + "content": "ings of the 58th Annual Meeting of the Association for Computational Linguistics, ACL 2020, Online, July 5-10, 2020, pages 4998-5007. Association for Computational Linguistics." + } + ] + } + ], + "index": 8 + }, + { + "bbox": [ + 304, + 125, + 526, + 181 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 125, + 526, + 181 + ], + "spans": [ + { + "bbox": [ + 304, + 125, + 526, + 181 + ], + "type": "text", + "content": "Loubna Ben Allal, Raymond Li, Denis Kocetkov, Chenghao Mou, Christopher Akiki, Carlos Munoz Ferrandis, Niklas Muennighoff, Mayank Mishra, Alex Gu, Manan Dey, et al. 2023. SantaCoder: Don't reach for the stars! arXiv preprint arXiv:2301.03988." + } + ] + } + ], + "index": 9 + }, + { + "bbox": [ + 304, + 190, + 526, + 246 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 190, + 526, + 246 + ], + "spans": [ + { + "bbox": [ + 304, + 190, + 526, + 246 + ], + "type": "text", + "content": "Jacob Austin, Augustus Odena, Maxwell Nye, Maarten Bosma, Henryk Michalewski, David Dohan, Ellen Jiang, Carrie Cai, Michael Terry, Quoc Le, et al. 2021. Program synthesis with large language models. arXiv preprint arXiv:2108.07732." + } + ] + } + ], + "index": 10 + }, + { + "bbox": [ + 304, + 253, + 526, + 407 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 253, + 526, + 407 + ], + "spans": [ + { + "bbox": [ + 304, + 253, + 526, + 407 + ], + "type": "text", + "content": "Jinze Bai, Shuai Bai, Yunfei Chu, Zeyu Cui, Kai Dang, Xiaodong Deng, Yang Fan, Wenbin Ge, Yu Han, Fei Huang, Binyuan Hui, Luo Ji, Mei Li, Junyang Lin, Runji Lin, Dayiheng Liu, Gao Liu, Chengqiang Lu, Keming Lu, Jianxin Ma, Rui Men, Xingzhang Ren, Xuancheng Ren, Chuanqi Tan, Sinan Tan, Jianhong Tu, Peng Wang, Shijie Wang, Wei Wang, Shengguang Wu, Benfeng Xu, Jin Xu, An Yang, Hao Yang, Jian Yang, Shusheng Yang, Yang Yao, Bowen Yu, Hongyi Yuan, Zheng Yuan, Jianwei Zhang, Xingxuan Zhang, Yichang Zhang, Zhenru Zhang, Chang Zhou, Jingren Zhou, Xiaohuan Zhou, and Tianhang Zhu. 2023. Qwen technical report. arXiv preprint arXiv:2309.16609, abs/2309.16609." + } + ] + } + ], + "index": 11 + }, + { + "bbox": [ + 304, + 416, + 525, + 461 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 416, + 525, + 461 + ], + "spans": [ + { + "bbox": [ + 304, + 416, + 525, + 461 + ], + "type": "text", + "content": "Luca Beurer-Kellner, Marc Fischer, and Martin T. Vechev. 2023. Prompting is programming: A query language for large language models. Proc. ACM Program. Lang., 7(PLDI):1946-1969." + } + ] + } + ], + "index": 12 + }, + { + "bbox": [ + 304, + 470, + 526, + 536 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 470, + 526, + 536 + ], + "spans": [ + { + "bbox": [ + 304, + 470, + 526, + 536 + ], + "type": "text", + "content": "Federico Cassano, John Gouwar, Daniel Nguyen, Sydney Nguyen, Luna Phipps-Costin, Donald Pinckney, Ming-Ho Yee, Yangtian Zi, Carolyn Jane Anderson, Molly Q Feldman, et al. 2022. Multi-: A scalable and extensible approach to benchmarking neural code generation. arXiv preprint arXiv:2208.08227." + } + ] + } + ], + "index": 13 + }, + { + "bbox": [ + 304, + 544, + 526, + 611 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 544, + 526, + 611 + ], + "spans": [ + { + "bbox": [ + 304, + 544, + 526, + 611 + ], + "type": "text", + "content": "Linzheng Chai, Jian Yang, Tao Sun, Hongcheng Guo, Jiaheng Liu, Bing Wang, Xinnian Liang, Jiaqi Bai, Tongliang Li, Qiyao Peng, and Zhoujun Li. 2024. xcot: Cross-lingual instruction tuning for cross-lingual chain-of-thought reasoning. arXiv preprint arXiv:2401.07037, abs/2401.07037." + } + ] + } + ], + "index": 14 + }, + { + "bbox": [ + 304, + 619, + 526, + 698 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 619, + 526, + 698 + ], + "spans": [ + { + "bbox": [ + 304, + 619, + 526, + 698 + ], + "type": "text", + "content": "Yekun Chai, Shuohuan Wang, Chao Pang, Yu Sun, Hao Tian, and Hua Wu. 2023. Ernie-code: Beyond english-centric cross-lingual pretraining for programming languages. In Findings of the Association for Computational Linguistics: ACL 2023, Toronto, Canada, July 9-14, 2023, pages 10628-10650. Association for Computational Linguistics." + } + ] + } + ], + "index": 15 + }, + { + "bbox": [ + 304, + 706, + 525, + 772 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 706, + 525, + 772 + ], + "spans": [ + { + "bbox": [ + 304, + 706, + 525, + 772 + ], + "type": "text", + "content": "Bei Chen, Fengji Zhang, Anh Nguyen, Daoguang Zan, Zeqi Lin, Jian-Guang Lou, and Weizhu Chen. 2023. Codet: Code generation with generated tests. In The Eleventh International Conference on Learning Representations, ICLR 2023, Kigali, Rwanda, May 1-5, 2023. OpenReview.net." + } + ] + } + ], + "index": 16 + } + ], + "sub_type": "ref_text" + } + ], + "discarded_blocks": [ + { + "bbox": [ + 287, + 781, + 309, + 791 + ], + "type": "page_number", + "angle": 0, + "lines": [ + { + "bbox": [ + 287, + 781, + 309, + 791 + ], + "spans": [ + { + "bbox": [ + 287, + 781, + 309, + 791 + ], + "type": "text", + "content": "1820" + } + ] + } + ], + "index": 18 + } + ], + "page_size": [ + 595, + 841 + ], + "page_idx": 8 + }, + { + "para_blocks": [ + { + "bbox": [ + 69, + 72, + 292, + 772 + ], + "type": "list", + "angle": 0, + "index": 7, + "blocks": [ + { + "bbox": [ + 69, + 72, + 292, + 302 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 69, + 72, + 292, + 302 + ], + "spans": [ + { + "bbox": [ + 69, + 72, + 292, + 302 + ], + "type": "text", + "content": "Mark Chen, Jerry Tworek, Heewoo Jun, Qiming Yuan, Henrique Ponde de Oliveira Pinto, Jared Kaplan, Harrison Edwards, Yuri Burda, Nicholas Joseph, Greg Brockman, Alex Ray, Raul Puri, Gretchen Krueger, Michael Petrov, Heidi Khlaaf, Girish Sastry, Pamela Mishkin, Brooke Chan, Scott Gray, Nick Ryder, Mikhail Pavlov, Alethea Power, Lukasz Kaiser, Mohammad Bavarian, Clemens Winter, Philippe Tillet, Felipe Petroski Such, Dave Cummings, Matthias Plappert, Fotios Chantzis, Elizabeth Barnes, Ariel Herbert-Voss, William Hebgen Guss, Alex Nichol, Alex Paino, Nikolas Tezak, Jie Tang, Igor Babuschkin, Suchir Balaji, Shantanu Jain, William Saunders, Christopher Hesse, Andrew N. Carr, Jan Leike, Joshua Achiam, Vedant Misra, Evan Morikawa, Alec Radford, Matthew Knight, Miles Brundage, Mira Murati, Katie Mayer, Peter Welinder, Bob McGrew, Dario Amodei, Sam McCandlish, Ilya Sutskever, and Wojciech Zaremba. 2021. Evaluating large language models trained on code. arXiv preprint arXiv:2107.03374, abs/2107.03374." + } + ] + } + ], + "index": 0 + }, + { + "bbox": [ + 69, + 315, + 290, + 370 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 69, + 315, + 290, + 370 + ], + "spans": [ + { + "bbox": [ + 69, + 315, + 290, + 370 + ], + "type": "text", + "content": "Wenhu Chen, Xueguang Ma, Xinyi Wang, and William W. Cohen. 2022. Program of thoughts prompting: Disentangling computation from reasoning for numerical reasoning tasks. arXiv preprint arXiv:2211.12588, abs/2211.12588." + } + ] + } + ], + "index": 1 + }, + { + "bbox": [ + 69, + 382, + 290, + 438 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 69, + 382, + 290, + 438 + ], + "spans": [ + { + "bbox": [ + 69, + 382, + 290, + 438 + ], + "type": "text", + "content": "Karl Cobbe, Vineet Kosaraju, Mohammad Bavarian, Mark Chen, Heewoo Jun, Lukasz Kaiser, Matthias Plappert, Jerry Tworek, Jacob Hilton, Reiichiro Nakano, et al. 2021. Training verifiers to solve math word problems. arXiv preprint arXiv:2110.14168." + } + ] + } + ], + "index": 2 + }, + { + "bbox": [ + 69, + 449, + 290, + 515 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 69, + 449, + 290, + 515 + ], + "spans": [ + { + "bbox": [ + 69, + 449, + 290, + 515 + ], + "type": "text", + "content": "Chris Cummins, Volker Seeker, Dejan Grubisic, Mostafa Elhoushi, Youwei Liang, Baptiste Rozière, Jonas Gehring, Fabian Gloeckle, Kim M. Hazelwood, Gabriel Synnaeve, and Hugh Leather. 2023. Large language models for compiler optimization. arXiv preprint arXiv:2309.07062, abs/2309.07062." + } + ] + } + ], + "index": 3 + }, + { + "bbox": [ + 69, + 528, + 290, + 560 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 69, + 528, + 290, + 560 + ], + "spans": [ + { + "bbox": [ + 69, + 528, + 290, + 560 + ], + "type": "text", + "content": "Gautier Dagan, Frank Keller, and Alex Lascarides. 2023. Dynamic planning with a LLM. arXiv preprint arXiv:2308.06391, abs/2308.06391." + } + ] + } + ], + "index": 4 + }, + { + "bbox": [ + 69, + 573, + 290, + 628 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 69, + 573, + 290, + 628 + ], + "spans": [ + { + "bbox": [ + 69, + 573, + 290, + 628 + ], + "type": "text", + "content": "Yinlin Deng, Chunqiu Steven Xia, Chenyuan Yang, Shizhuo Dylan Zhang, Shujing Yang, and Lingming Zhang. 2023. Large language models are edge-case fuzzers: Testing deep learning libraries via fuzzgpt. arXiv preprint arXiv:2304.02014, abs/2304.02014." + } + ] + } + ], + "index": 5 + }, + { + "bbox": [ + 69, + 640, + 291, + 772 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 69, + 640, + 291, + 772 + ], + "spans": [ + { + "bbox": [ + 69, + 640, + 291, + 772 + ], + "type": "text", + "content": "Peng Di, Jianguo Li, Hang Yu, Wei Jiang, Wenting Cai, Yang Cao, Chaoyu Chen, Dajun Chen, Hongwei Chen, Liang Chen, Gang Fan, Jie Gong, Zi Gong, Wen Hu, Tingting Guo, Zhichao Lei, Ting Li, Zheng Li, Ming Liang, Cong Liao, Bingchang Liu, Jiachen Liu, Zhiwei Liu, Shaojun Lu, Min Shen, Guangpei Wang, Huan Wang, Zhi Wang, Zhaogui Xu, Jiawei Yang, Qing Ye, Gehao Zhang, Yu Zhang, Zelin Zhao, Xunjin Zheng, Hailian Zhou, Lifu Zhu, and Xianying Zhu. 2023. Codefuse-13b: A pretrained multilingual code large language model. arXiv preprint arXiv:2310.06266, abs/2310.06266." + } + ] + } + ], + "index": 6 + } + ], + "sub_type": "ref_text" + }, + { + "bbox": [ + 304, + 72, + 525, + 772 + ], + "type": "list", + "angle": 0, + "index": 18, + "blocks": [ + { + "bbox": [ + 305, + 72, + 525, + 105 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 305, + 72, + 525, + 105 + ], + "spans": [ + { + "bbox": [ + 305, + 72, + 525, + 105 + ], + "type": "text", + "content": "Yihong Dong, Xue Jiang, Zhi Jin, and Ge Li. 2023. Self-collaboration code generation via chatgpt. arXiv preprint arXiv:2304.07590, abs/2304.07590." + } + ] + } + ], + "index": 8 + }, + { + "bbox": [ + 304, + 115, + 525, + 214 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 115, + 525, + 214 + ], + "spans": [ + { + "bbox": [ + 304, + 115, + 525, + 214 + ], + "type": "text", + "content": "Zhangyin Feng, Daya Guo, Duyu Tang, Nan Duan, Xiaocheng Feng, Ming Gong, Linjun Shou, Bing Qin, Ting Liu, Daxin Jiang, and Ming Zhou. 2020. Codebert: A pre-trained model for programming and natural languages. In Findings of the Association for Computational Linguistics: EMNLP 2020, Online Event, 16-20 November 2020, volume EMNLP 2020 of Findings of ACL, pages 1536-1547. Association for Computational Linguistics." + } + ] + } + ], + "index": 9 + }, + { + "bbox": [ + 304, + 223, + 525, + 288 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 223, + 525, + 288 + ], + "spans": [ + { + "bbox": [ + 304, + 223, + 525, + 288 + ], + "type": "text", + "content": "Daniel Fried, Armen Aghajanyan, Jessy Lin, Sida I. Wang, Eric Wallace, Freda Shi, Ruiqi Zhong, Wen tau Yih, Luke Zettlemoyer, and Mike Lewis. 2022. Incoder: A generative model for code infilling and synthesis. arXiv preprint arXiv:2204.05999, abs/2204.05999." + } + ] + } + ], + "index": 10 + }, + { + "bbox": [ + 304, + 298, + 525, + 353 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 298, + 525, + 353 + ], + "spans": [ + { + "bbox": [ + 304, + 298, + 525, + 353 + ], + "type": "text", + "content": "Shiwei Gan, Yafeng Yin, Zhiwei Jiang, Lei Xie, and Sanglu Lu. 2021. Skeleton-aware neural sign language translation. In MM '21: ACM Multimedia Conference, Virtual Event, China, October 20 - 24, 2021, pages 4353-4361. ACM." + } + ] + } + ], + "index": 11 + }, + { + "bbox": [ + 304, + 363, + 525, + 428 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 363, + 525, + 428 + ], + "spans": [ + { + "bbox": [ + 304, + 363, + 525, + 428 + ], + "type": "text", + "content": "Daya Guo, Qihao Zhu, Dejian Yang, Zhenda Xie, Kai Dong, Wentao Zhang, Guanting Chen, Xiao Bi, Y Wu, YK Li, et al. 2024a. Deepseek-coder: When the large language model meets programming-the rise of code intelligence. arXiv preprint arXiv:2401.14196." + } + ] + } + ], + "index": 12 + }, + { + "bbox": [ + 304, + 439, + 525, + 503 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 439, + 525, + 503 + ], + "spans": [ + { + "bbox": [ + 304, + 439, + 525, + 503 + ], + "type": "text", + "content": "Hongcheng Guo, Jian Yang, Jiaheng Liu, Liquan Yang, Linzheng Chai, Jiaqi Bai, Junran Peng, Xiaorong Hu, Chao Chen, Dongfeng Zhang, Xu Shi, Tieqiao Zheng, Liangfan Zheng, Bo Zhang, Ke Xu, and Zhoujun Li. 2023. OWL: A large language model for IT operations. CoRR, abs/2309.09298." + } + ] + } + ], + "index": 13 + }, + { + "bbox": [ + 304, + 513, + 525, + 568 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 513, + 525, + 568 + ], + "spans": [ + { + "bbox": [ + 304, + 513, + 525, + 568 + ], + "type": "text", + "content": "Hongcheng Guo, Wei Zhang, Anjie Le, Jian Yang, Jiaheng Liu, Zhoujun Li, Tieqiao Zheng, Shi Xu, Runqiang Zang, Liangfan Zheng, et al. 2024b. Lemur: Log parsing with entropy sampling and chain-of-thought merging. arXiv preprint arXiv:2402.18205." + } + ] + } + ], + "index": 14 + }, + { + "bbox": [ + 304, + 577, + 525, + 643 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 577, + 525, + 643 + ], + "spans": [ + { + "bbox": [ + 304, + 577, + 525, + 643 + ], + "type": "text", + "content": "Hangyuan Ji, Jian Yang, Linzheng Chai, Chaoren Wei, Liquan Yang, Yunlong Duan, Yunli Wang, Tianzhen Sun, Hongcheng Guo, Tongliang Li, et al. 2024. Sevenllm: Benchmarking, eliciting, and enhancing abilities of large language models in cyber threat intelligence. arXiv preprint arXiv:2405.03446." + } + ] + } + ], + "index": 15 + }, + { + "bbox": [ + 304, + 653, + 525, + 729 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 653, + 525, + 729 + ], + "spans": [ + { + "bbox": [ + 304, + 653, + 525, + 729 + ], + "type": "text", + "content": "Ellen Jiang, Kristen Olson, Edwin Toh, Alejandra Molina, Aaron Donsbach, Michael Terry, and Carrie J. Cai. 2022. Promptmaker: Prompt-based prototyping with large language models. In CHI '22: CHI Conference on Human Factors in Computing Systems, New Orleans, LA, USA, 29 April 2022 - 5 May 2022, Extended Abstracts, pages 35:1-35:8. ACM." + } + ] + } + ], + "index": 16 + }, + { + "bbox": [ + 304, + 739, + 525, + 772 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 739, + 525, + 772 + ], + "spans": [ + { + "bbox": [ + 304, + 739, + 525, + 772 + ], + "type": "text", + "content": "Diederik P. Kingma and Jimmy Ba. 2015. Adam: A method for stochastic optimization. In 3rd International Conference on Learning Representations," + } + ] + } + ], + "index": 17 + } + ], + "sub_type": "ref_text" + } + ], + "discarded_blocks": [ + { + "bbox": [ + 287, + 781, + 308, + 791 + ], + "type": "page_number", + "angle": 0, + "lines": [ + { + "bbox": [ + 287, + 781, + 308, + 791 + ], + "spans": [ + { + "bbox": [ + 287, + 781, + 308, + 791 + ], + "type": "text", + "content": "1821" + } + ] + } + ], + "index": 19 + } + ], + "page_size": [ + 595, + 841 + ], + "page_idx": 9 + }, + { + "para_blocks": [ + { + "bbox": [ + 69, + 72, + 291, + 772 + ], + "type": "list", + "angle": 0, + "index": 7, + "blocks": [ + { + "bbox": [ + 80, + 72, + 290, + 95 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 80, + 72, + 290, + 95 + ], + "spans": [ + { + "bbox": [ + 80, + 72, + 290, + 95 + ], + "type": "text", + "content": "ICLR 2015, San Diego, CA, USA, May 7-9, 2015, Conference Track Proceedings." + } + ] + } + ], + "index": 0 + }, + { + "bbox": [ + 69, + 103, + 291, + 179 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 69, + 103, + 291, + 179 + ], + "spans": [ + { + "bbox": [ + 69, + 103, + 291, + 179 + ], + "type": "text", + "content": "Takeshi Kojima, Shixiang Shane Gu, Machel Reid, Yutaka Matsuo, and Yusuke Iwasawa. 2022. Large language models are zero-shot reasoners. In Advances in Neural Information Processing Systems 35: Annual Conference on Neural Information Processing Systems 2022, NeurIPS 2022, New Orleans, LA, USA, November 28 - December 9, 2022." + } + ] + } + ], + "index": 1 + }, + { + "bbox": [ + 69, + 188, + 291, + 286 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 69, + 188, + 291, + 286 + ], + "spans": [ + { + "bbox": [ + 69, + 188, + 291, + 286 + ], + "type": "text", + "content": "Yuhang Lai, Chengxi Li, Yiming Wang, Tianyi Zhang, Ruiqi Zhong, Luke Zettlemoyer, Wen-Tau Yih, Daniel Fried, Sida I. Wang, and Tao Yu. 2023. DS1000: A natural and reliable benchmark for data science code generation. In International Conference on Machine Learning, ICML 2023, 23-29 July 2023, Honolulu, Hawaii, USA, volume 202 of Proceedings of Machine Learning Research, pages 18319-18345. PMLR." + } + ] + } + ], + "index": 2 + }, + { + "bbox": [ + 69, + 296, + 290, + 350 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 69, + 296, + 290, + 350 + ], + "spans": [ + { + "bbox": [ + 69, + 296, + 290, + 350 + ], + "type": "text", + "content": "Bin Lei, Pei-Hung Lin, Chunhua Liao, and Caiwen Ding. 2023. Boosting logical reasoning in large language models through a new framework: The graph of thought. arXiv preprint arXiv:2308.08614, abs/2308.08614." + } + ] + } + ], + "index": 3 + }, + { + "bbox": [ + 69, + 359, + 290, + 393 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 69, + 359, + 290, + 393 + ], + "spans": [ + { + "bbox": [ + 69, + 359, + 290, + 393 + ], + "type": "text", + "content": "Jia Li, Ge Li, Yongmin Li, and Zhi Jin. 2023a. Structured chain-of-thought prompting for code generation. arXiv preprint arXiv:2305.06599." + } + ] + } + ], + "index": 4 + }, + { + "bbox": [ + 69, + 401, + 291, + 675 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 69, + 401, + 291, + 675 + ], + "spans": [ + { + "bbox": [ + 69, + 401, + 291, + 675 + ], + "type": "text", + "content": "Raymond Li, Loubna Ben Allal, Yangtian Zi, Niklas Muennighoff, Denis Kocetkov, Chenghao Mou, Marc Marone, Christopher Akiki, Jia Li, Jenny Chim, Qian Liu, Evgenii Zheltonozhskii, Terry Yue Zhuo, Thomas Wang, Olivier Dehaene, Mishig Davaadorj, Joel Lamy-Poirier, João Monteiro, Oleh Shliazhko, Nicolas Gontier, Nicholas Meade, Armel Zebaze, Ming-Ho Yee, Logesh Kumar Umapathi, Jian Zhu, Benjamin Lipkin, Muhtasham Oblokulov, Zhiruo Wang, Rudra Murthy V, Jason Stillerman, Siva Sankalp Patel, Dmitry Abulkhanov, Marco Zocca, Manan Dey, Zhihan Zhang, Nour MoustafaFahmy, Urvashi Bhattacharyya, Wenhao Yu, Swayam Singh, Sasha Luccioni, Paulo Villegas, Maxim Kunakov, Fedor Zhdanov, Manuel Romero, Tony Lee, Nadav Timor, Jennifer Ding, Claire Schlesinger, Hailey Schoelkopf, Jan Ebert, Tri Dao, Mayank Mishra, Alex Gu, Jennifer Robinson, Carolyn Jane Anderson, Brendan Dolan-Gavitt, Danish Contractor, Siva Reddy, Daniel Fried, Dzmitry Bahdanau, Yacine Jernite, Carlos Munoz Ferrandis, Sean Hughes, Thomas Wolf, Arjun Guha, Leandro von Werra, and Harm de Vries. 2023b. StarCoder: May the source be with you! arXiv preprint arXiv:2305.06161, abs/2305.06161." + } + ] + } + ], + "index": 5 + }, + { + "bbox": [ + 69, + 683, + 291, + 772 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 69, + 683, + 291, + 772 + ], + "spans": [ + { + "bbox": [ + 69, + 683, + 291, + 772 + ], + "type": "text", + "content": "Yujia Li, David H. Choi, Junyoung Chung, Nate Kushman, Julian Schrittwieser, Rémi Leblond, Tom Eccles, James Keeling, Felix Gimeno, Agustin Dal Lago, Thomas Hubert, Peter Choy, Cyprien de Masson d'Autume, Igor Babuschkin, Xinyun Chen, PoSen Huang, Johannes Welbl, Sven Gowal, Alexey Cherepanov, James Molloy, Daniel J. Mankowitz, Esme Sutherland Robson, Pushmeet Kohli, Nando" + } + ] + } + ], + "index": 6 + } + ], + "sub_type": "ref_text" + }, + { + "bbox": [ + 304, + 72, + 525, + 772 + ], + "type": "list", + "angle": 0, + "index": 18, + "blocks": [ + { + "bbox": [ + 314, + 72, + 525, + 116 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 314, + 72, + 525, + 116 + ], + "spans": [ + { + "bbox": [ + 314, + 72, + 525, + 116 + ], + "type": "text", + "content": "de Freitas, Koray Kavukcuoglu, and Oriol Vinyals. 2022. Competition-level code generation with AlphaCode. arXiv preprint arXiv:2203.07814, abs/2203.07814." + } + ] + } + ], + "index": 8 + }, + { + "bbox": [ + 304, + 128, + 525, + 227 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 128, + 525, + 227 + ], + "spans": [ + { + "bbox": [ + 304, + 128, + 525, + 227 + ], + "type": "text", + "content": "Yaobo Liang, Quanzhi Zhu, Junhe Zhao, and Nan Duan. 2024. Machine-created universal language for cross-lingual transfer. In Thirty-Eighth AAAI Conference on Artificial Intelligence, AAAI 2024, Thirty-Sixth Conference on Innovative Applications of Artificial Intelligence, IAAI 2024, Fourteenth Symposium on Educational Advances in Artificial Intelligence, EAAI 2014, February 20-27, 2024, Vancouver, Canada, pages 18617-18625. AAAI Press." + } + ] + } + ], + "index": 9 + }, + { + "bbox": [ + 304, + 238, + 525, + 282 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 238, + 525, + 282 + ], + "spans": [ + { + "bbox": [ + 304, + 238, + 525, + 282 + ], + "type": "text", + "content": "Chao Liu, Xuanlin Bao, Hongyu Zhang, Neng Zhang, Haibo Hu, Xiaohong Zhang, and Meng Yan. 2023a. Improving chatgpt prompt for code generation. arXiv preprint arXiv:2305.08360, abs/2305.08360." + } + ] + } + ], + "index": 10 + }, + { + "bbox": [ + 304, + 294, + 525, + 371 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 294, + 525, + 371 + ], + "spans": [ + { + "bbox": [ + 304, + 294, + 525, + 371 + ], + "type": "text", + "content": "Chenxiao Liu and Xiaojun Wan. 2021. CodeQA: A question answering dataset for source code comprehension. In Findings of the Association for Computational Linguistics: EMNLP 2021, Virtual Event / Punta Cana, Dominican Republic, 16-20 November, 2021, pages 2618-2632. Association for Computational Linguistics." + } + ] + } + ], + "index": 11 + }, + { + "bbox": [ + 304, + 383, + 525, + 438 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 383, + 525, + 438 + ], + "spans": [ + { + "bbox": [ + 304, + 383, + 525, + 438 + ], + "type": "text", + "content": "Jiawei Liu, Chunqiu Steven Xia, Yuyao Wang, and Lingming Zhang. 2023b. Is your code generated by chatgpt really correct? rigorous evaluation of large language models for code generation. arXiv preprint arXiv:2305.01210, abs/2305.01210." + } + ] + } + ], + "index": 12 + }, + { + "bbox": [ + 304, + 449, + 525, + 515 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 449, + 525, + 515 + ], + "spans": [ + { + "bbox": [ + 304, + 449, + 525, + 515 + ], + "type": "text", + "content": "Yue Liu, Thanh Le-Cong, Ratnadira Widyasari, Chakkrit Tantithamthavorn, Li Li, Xuan-Bach Dinh Le, and David Lo. 2023c. Refining ChatGPT-generated code: Characterizing and mitigating code quality issues. arXiv preprint arXiv:2307.12596, abs/2307.12596." + } + ] + } + ], + "index": 13 + }, + { + "bbox": [ + 304, + 528, + 525, + 583 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 528, + 525, + 583 + ], + "spans": [ + { + "bbox": [ + 304, + 528, + 525, + 583 + ], + "type": "text", + "content": "Ziyang Luo, Can Xu, Pu Zhao, Qingfeng Sun, Xi-ubo Geng, Wenxiang Hu, Chongyang Tao, Jing Ma, Qingwei Lin, and Daxin Jiang. 2023. WizardCoder: Empowering code large language models with evol-instruct. arXiv preprint arXiv:2306.08568." + } + ] + } + ], + "index": 14 + }, + { + "bbox": [ + 304, + 594, + 525, + 649 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 594, + 525, + 649 + ], + "spans": [ + { + "bbox": [ + 304, + 594, + 525, + 649 + ], + "type": "text", + "content": "Mayank Mishra, Prince Kumar, Riyadh Bhat, Rudra Murthy V, Danish Contractor, and Srikanth Tamilselvam. 2023. Prompting with pseudo-code instructions. arXiv preprint arXiv:2305.11790, abs/2305.11790." + } + ] + } + ], + "index": 15 + }, + { + "bbox": [ + 304, + 661, + 525, + 727 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 661, + 525, + 727 + ], + "spans": [ + { + "bbox": [ + 304, + 661, + 525, + 727 + ], + "type": "text", + "content": "Niklas Muennighoff, Qian Liu, Armel Zebaze, Qinkai Zheng, Binyuan Hui, Terry Yue Zhuo, Swayam Singh, Xiangru Tang, Leandro von Werra, and Shayne Longpre. 2023. OctoPack: Instruction tuning code large language models. arXiv preprint arXiv:2308.07124, abs/2308.07124." + } + ] + } + ], + "index": 16 + }, + { + "bbox": [ + 304, + 738, + 525, + 772 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 738, + 525, + 772 + ], + "spans": [ + { + "bbox": [ + 304, + 738, + 525, + 772 + ], + "type": "text", + "content": "Yusuke Oda, Hiroyuki Fudaba, Graham Neubig, Hideaki Hata, Sakriani Sakti, Tomoki Toda, and Satoshi Nakamura. 2015. Learning to generate" + } + ] + } + ], + "index": 17 + } + ], + "sub_type": "ref_text" + } + ], + "discarded_blocks": [ + { + "bbox": [ + 287, + 781, + 309, + 791 + ], + "type": "page_number", + "angle": 0, + "lines": [ + { + "bbox": [ + 287, + 781, + 309, + 791 + ], + "spans": [ + { + "bbox": [ + 287, + 781, + 309, + 791 + ], + "type": "text", + "content": "1822" + } + ] + } + ], + "index": 19 + } + ], + "page_size": [ + 595, + 841 + ], + "page_idx": 10 + }, + { + "para_blocks": [ + { + "bbox": [ + 69, + 72, + 291, + 772 + ], + "type": "list", + "angle": 0, + "index": 10, + "blocks": [ + { + "bbox": [ + 80, + 72, + 291, + 128 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 80, + 72, + 291, + 128 + ], + "spans": [ + { + "bbox": [ + 80, + 72, + 291, + 128 + ], + "type": "text", + "content": "pseudo-code from source code using statistical machine translation (T). In 30th IEEE/ACM International Conference on Automated Software Engineering, ASE 2015, Lincoln, NE, USA, November 9-13, 2015, pages 574-584. IEEE Computer Society." + } + ] + } + ], + "index": 0 + }, + { + "bbox": [ + 69, + 138, + 289, + 159 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 69, + 138, + 289, + 159 + ], + "spans": [ + { + "bbox": [ + 69, + 138, + 289, + 159 + ], + "type": "text", + "content": "OpenAI. 2023. Gpt-4 technical report. arXiv preprint arXiv:2303.08774." + } + ] + } + ], + "index": 1 + }, + { + "bbox": [ + 69, + 170, + 289, + 301 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 69, + 170, + 289, + 301 + ], + "spans": [ + { + "bbox": [ + 69, + 170, + 289, + 301 + ], + "type": "text", + "content": "Long Ouyang, Jeffrey Wu, Xu Jiang, Diogo Almeida, Carroll L. Wainwright, Pamela Mishkin, Chong Zhang, Sandhini Agarwal, Katarina Slama, Alex Ray, John Schulman, Jacob Hilton, Fraser Kelton, Luke Miller, Maddie Simens, Amanda Askell, Peter Welinder, Paul F. Christiano, Jan Leike, and Ryan Lowe. 2022. Training language models to follow instructions with human feedback. In Advances in Neural Information Processing Systems 35: Annual Conference on Neural Information Processing Systems 2022, NeurIPS 2022, New Orleans, LA, USA, November 28 - December 9, 2022." + } + ] + } + ], + "index": 2 + }, + { + "bbox": [ + 69, + 312, + 289, + 346 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 69, + 312, + 289, + 346 + ], + "spans": [ + { + "bbox": [ + 69, + 312, + 289, + 346 + ], + "type": "text", + "content": "Alec Radford, Karthik Narasimhan, Tim Salimans, Ilya Sutskever, et al. 2018. Improving language understanding by generative pre-training. OpenAI blog." + } + ] + } + ], + "index": 3 + }, + { + "bbox": [ + 69, + 356, + 289, + 422 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 69, + 356, + 289, + 422 + ], + "spans": [ + { + "bbox": [ + 69, + 356, + 289, + 422 + ], + "type": "text", + "content": "Laria Reynolds and Kyle McDonell. 2021. Prompt programming for large language models: Beyond the few-shot paradigm. In *CHI '21: CHI Conference on Human Factors in Computing Systems, Virtual Event / Yokohama Japan, May 8-13, 2021, Extended Abstracts*, pages 314:1-314:7. ACM." + } + ] + } + ], + "index": 4 + }, + { + "bbox": [ + 69, + 433, + 289, + 487 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 69, + 433, + 289, + 487 + ], + "spans": [ + { + "bbox": [ + 69, + 433, + 289, + 487 + ], + "type": "text", + "content": "Baptiste Rozière, Jonas Gehring, Fabian Gloeckle, Sten Sootla, Itai Gat, Xiaqing Ellen Tan, Yossi Adi, Jingyu Liu, Tal Remez, Jérémy Rapin, et al. 2023. Code Llama: Open foundation models for code. arXiv preprint arXiv:2308.12950." + } + ] + } + ], + "index": 5 + }, + { + "bbox": [ + 69, + 498, + 289, + 564 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 69, + 498, + 289, + 564 + ], + "spans": [ + { + "bbox": [ + 69, + 498, + 289, + 564 + ], + "type": "text", + "content": "Marc Szafraniec, Baptiste Rozière, Hugh Leather, Patrick Labatut, François Charton, and Gabriel Synnaeve. 2023. Code translation with compiler representations. In *The Eleventh International Conference on Learning Representations*, ICLR 2023, Kigali, Rwanda, May 1-5, 2023. OpenReview.net." + } + ] + } + ], + "index": 6 + }, + { + "bbox": [ + 69, + 575, + 289, + 651 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 69, + 575, + 289, + 651 + ], + "spans": [ + { + "bbox": [ + 69, + 575, + 289, + 651 + ], + "type": "text", + "content": "Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser, and Illia Polosukhin. 2017. Attention is all you need. In Advances in Neural Information Processing Systems 30: Annual Conference on Neural Information Processing Systems 2017, December 4-9, 2017, Long Beach, CA, USA, pages 5998-6008." + } + ] + } + ], + "index": 7 + }, + { + "bbox": [ + 69, + 661, + 289, + 716 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 69, + 661, + 289, + 716 + ], + "spans": [ + { + "bbox": [ + 69, + 661, + 289, + 716 + ], + "type": "text", + "content": "Yue Wang, Weishi Wang, Shafiq Joty, and Steven CH Hoi. 2021. CodeT5: Identifier-aware unified pre-trained encoder-decoder models for code understanding and generation. arXiv preprint arXiv:2109.00859." + } + ] + } + ], + "index": 8 + }, + { + "bbox": [ + 69, + 728, + 289, + 772 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 69, + 728, + 289, + 772 + ], + "spans": [ + { + "bbox": [ + 69, + 728, + 289, + 772 + ], + "type": "text", + "content": "Jason Wei, Maarten Bosma, Vincent Y. Zhao, Kelvin Guu, Adams Wei Yu, Brian Lester, Nan Du, Andrew M. Dai, and Quoc V. Le. 2022a. Finetuned language models are zero-shot learners. In The Tenth" + } + ] + } + ], + "index": 9 + } + ], + "sub_type": "ref_text" + }, + { + "bbox": [ + 304, + 72, + 525, + 772 + ], + "type": "list", + "angle": 0, + "index": 20, + "blocks": [ + { + "bbox": [ + 314, + 72, + 525, + 105 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 314, + 72, + 525, + 105 + ], + "spans": [ + { + "bbox": [ + 314, + 72, + 525, + 105 + ], + "type": "text", + "content": "International Conference on Learning Representations, ICLR 2022, Virtual Event, April 25-29, 2022. OpenReview.net." + } + ] + } + ], + "index": 11 + }, + { + "bbox": [ + 304, + 113, + 525, + 200 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 113, + 525, + 200 + ], + "spans": [ + { + "bbox": [ + 304, + 113, + 525, + 200 + ], + "type": "text", + "content": "Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Brian Ichter, Fei Xia, Ed H. Chi, Quoc V. Le, and Denny Zhou. 2022b. Chain-of-thought prompting elicits reasoning in large language models. In Advances in Neural Information Processing Systems 35: Annual Conference on Neural Information Processing Systems 2022, NeurIPS 2022, New Orleans, LA, USA, November 28 - December 9, 2022." + } + ] + } + ], + "index": 12 + }, + { + "bbox": [ + 304, + 208, + 525, + 252 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 208, + 525, + 252 + ], + "spans": [ + { + "bbox": [ + 304, + 208, + 525, + 252 + ], + "type": "text", + "content": "Yuxiang Wei, Zhe Wang, Jiawei Liu, Yifeng Ding, and Lingming Zhang. 2023. Magicoder: Source code is all you need. arXiv preprint arXiv:2312.02120, abs/2312.02120." + } + ] + } + ], + "index": 13 + }, + { + "bbox": [ + 304, + 260, + 525, + 316 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 260, + 525, + 316 + ], + "spans": [ + { + "bbox": [ + 304, + 260, + 525, + 316 + ], + "type": "text", + "content": "Can Xu, Qingfeng Sun, Kai Zheng, Xiubo Geng, Pu Zhao, Jiazhan Feng, Chongyang Tao, and Daxin Jiang. 2023. Wizardlm: Empowering large language models to follow complex instructions. arXiv preprint arXiv:2304.12244." + } + ] + } + ], + "index": 14 + }, + { + "bbox": [ + 304, + 323, + 525, + 400 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 323, + 525, + 400 + ], + "spans": [ + { + "bbox": [ + 304, + 323, + 525, + 400 + ], + "type": "text", + "content": "Weixiang Yan, Yuchen Tian, Yunzhe Li, Qian Chen, and Wen Wang. 2023. CodetransOcean: A comprehensive multilingual benchmark for code translation. In *Findings of the Association for Computational Linguistics: EMNLP* 2023, Singapore, December 6-10, 2023, pages 5067-5089. Association for Computational Linguistics." + } + ] + } + ], + "index": 15 + }, + { + "bbox": [ + 304, + 407, + 525, + 507 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 407, + 525, + 507 + ], + "spans": [ + { + "bbox": [ + 304, + 407, + 525, + 507 + ], + "type": "text", + "content": "Jian Yang, Hongcheng Guo, Yuwei Yin, Jiaqi Bai, Bing Wang, Jiaheng Liu, Xinnian Liang, Linzheng Chai, Liqu Yang, and Zhoujun Li. 2024. m3p: Towards multimodal multilingual translation with multimodal prompt. In Proceedings of the 2024 Joint International Conference on Computational Linguistics, Language Resources and Evaluation, LREC/COLING 2024, 20-25 May, 2024, Torino, Italy, pages 10858-10871. ELRA and ICCL." + } + ] + } + ], + "index": 16 + }, + { + "bbox": [ + 304, + 514, + 525, + 592 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 514, + 525, + 592 + ], + "spans": [ + { + "bbox": [ + 304, + 514, + 525, + 592 + ], + "type": "text", + "content": "Jian Yang, Shuming Ma, Dongdong Zhang, Zhoujun Li, and Ming Zhou. 2020a. Improving neural machine translation with soft template prediction. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, ACL 2020, Online, July 5-10, 2020, pages 5979-5989. Association for Computational Linguistics." + } + ] + } + ], + "index": 17 + }, + { + "bbox": [ + 304, + 599, + 525, + 708 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 599, + 525, + 708 + ], + "spans": [ + { + "bbox": [ + 304, + 599, + 525, + 708 + ], + "type": "text", + "content": "Jian Yang, Shuming Ma, Dongdong Zhang, Shuangzhi Wu, Zhoujun Li, and Ming Zhou. 2020b. Alternating language modeling for cross-lingual pre-training. In The Thirty-Fourth AAAI Conference on Artificial Intelligence, AAAI 2020, The Thirty-Second Innovative Applications of Artificial Intelligence Conference, IAAI 2020, The Tenth AAAI Symposium on Educational Advances in Artificial Intelligence, EAAI 2020, New York, NY, USA, February 7-12, 2020, pages 9386-9393. AAAI Press." + } + ] + } + ], + "index": 18 + }, + { + "bbox": [ + 304, + 717, + 525, + 772 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 717, + 525, + 772 + ], + "spans": [ + { + "bbox": [ + 304, + 717, + 525, + 772 + ], + "type": "text", + "content": "Jian Yang, Yuwei Yin, Shuming Ma, Dongdong Zhang, Shuangzhi Wu, Hongcheng Guo, Zhoujun Li, and Furu Wei. 2022. UM4: unified multilingual multiple teacher-student model for zero-resource neural machine translation. In Proceedings of the Thirty-First" + } + ] + } + ], + "index": 19 + } + ], + "sub_type": "ref_text" + } + ], + "discarded_blocks": [ + { + "bbox": [ + 287, + 781, + 309, + 791 + ], + "type": "page_number", + "angle": 0, + "lines": [ + { + "bbox": [ + 287, + 781, + 309, + 791 + ], + "spans": [ + { + "bbox": [ + 287, + 781, + 309, + 791 + ], + "type": "text", + "content": "1823" + } + ] + } + ], + "index": 21 + } + ], + "page_size": [ + 595, + 841 + ], + "page_idx": 11 + }, + { + "para_blocks": [ + { + "bbox": [ + 69, + 72, + 291, + 554 + ], + "type": "list", + "angle": 0, + "index": 7, + "blocks": [ + { + "bbox": [ + 80, + 72, + 291, + 107 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 80, + 72, + 291, + 107 + ], + "spans": [ + { + "bbox": [ + 80, + 72, + 291, + 107 + ], + "type": "text", + "content": "International Joint Conference on Artificial Intelligence, IJCAI 2022, Vienna, Austria, 23-29 July 2022, pages 4454-4460. ijcai.org." + } + ] + } + ], + "index": 0 + }, + { + "bbox": [ + 69, + 114, + 291, + 202 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 69, + 114, + 291, + 202 + ], + "spans": [ + { + "bbox": [ + 69, + 114, + 291, + 202 + ], + "type": "text", + "content": "Ze Yang, Wei Wu, Jian Yang, Can Xu, and Zhoujun Li. 2019. Low-resource response generation with template prior. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing, EMNLP-IJCNLP 2019, Hong Kong, China, November 3-7, 2019, pages 1886-1897. Association for Computational Linguistics." + } + ] + } + ], + "index": 1 + }, + { + "bbox": [ + 69, + 211, + 290, + 265 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 69, + 211, + 290, + 265 + ], + "spans": [ + { + "bbox": [ + 69, + 211, + 290, + 265 + ], + "type": "text", + "content": "Shunyu Yao, Dian Yu, Jeffrey Zhao, Izhak Shafran, Thomas L. Griffiths, Yuan Cao, and Karthik Narasimhan. 2023. Tree of thoughts: Deliberate problem solving with large language models. arXiv preprint arXiv:2305.10601, abs/2305.10601." + } + ] + } + ], + "index": 2 + }, + { + "bbox": [ + 69, + 275, + 290, + 339 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 69, + 275, + 290, + 339 + ], + "spans": [ + { + "bbox": [ + 69, + 275, + 290, + 339 + ], + "type": "text", + "content": "Zhaojian Yu, Xin Zhang, Ning Shang, Yangyu Huang, Can Xu, Yishujie Zhao, Wenxiang Hu, and Qiu feng Yin. 2023. Wavecoder: Widespread and versatile enhanced instruction tuning with refined data generation. arXiv preprint arXiv:2312.14187, abs/2312.14187." + } + ] + } + ], + "index": 3 + }, + { + "bbox": [ + 69, + 349, + 290, + 414 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 69, + 349, + 290, + 414 + ], + "spans": [ + { + "bbox": [ + 69, + 349, + 290, + 414 + ], + "type": "text", + "content": "Daoguang Zan, Ailun Yu, Bo Shen, Jiaxin Zhang, Taihong Chen, Bing Geng, Bei Chen, Jichuan Ji, Yafen Yao, Yongji Wang, and Qianxiang Wang. 2023. Can programming languages boost each other via instruction tuning? arXiv preprint arXiv:2308.16824, abs/2308.16824." + } + ] + } + ], + "index": 4 + }, + { + "bbox": [ + 69, + 423, + 290, + 479 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 69, + 423, + 290, + 479 + ], + "spans": [ + { + "bbox": [ + 69, + 423, + 290, + 479 + ], + "type": "text", + "content": "Fengji Zhang, Bei Chen, Yue Zhang, Jin Liu, Daoguang Zan, Yi Mao, Jian-Guang Lou, and Weizhu Chen. 2023. RepoCoder: Repository-level code completion through iterative retrieval and generation. arXiv preprint arXiv:2303.12570, abs/2303.12570." + } + ] + } + ], + "index": 5 + }, + { + "bbox": [ + 69, + 487, + 290, + 554 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 69, + 487, + 290, + 554 + ], + "spans": [ + { + "bbox": [ + 69, + 487, + 290, + 554 + ], + "type": "text", + "content": "Qinkai Zheng, Xiao Xia, Xu Zou, Yuxiao Dong, Shan Wang, Yufei Xue, Zihan Wang, Lei Shen, Andi Wang, Yang Li, Teng Su, Zhilin Yang, and Jie Tang. 2023. Codegeex: A pre-trained model for code generation with multilingual evaluations on humaneval-x. arXiv preprint arXiv:2303.17568, abs/2303.17568." + } + ] + } + ], + "index": 6 + } + ], + "sub_type": "ref_text" + } + ], + "discarded_blocks": [ + { + "bbox": [ + 287, + 781, + 309, + 791 + ], + "type": "page_number", + "angle": 0, + "lines": [ + { + "bbox": [ + 287, + 781, + 309, + 791 + ], + "spans": [ + { + "bbox": [ + 287, + 781, + 309, + 791 + ], + "type": "text", + "content": "1824" + } + ] + } + ], + "index": 8 + } + ], + "page_size": [ + 595, + 841 + ], + "page_idx": 12 + } + ], + "_backend": "vlm", + "_version_name": "2.6.4" +} \ No newline at end of file