tianyang/repobench_python_v1.1

RepoBench v1.1 (Python)

Introduction

This dataset presents the Python portion of RepoBench v1.1 (ICLR 2024). The data encompasses a collection from GitHub, spanning the period from October 6th to December 31st, 2023. With a commitment to data integrity, we've implemented a deduplication process based on file content against the Stack v2 dataset (coming soon), aiming to mitigate data leakage and memorization concerns.

Resources and Links

• Paper
• GitHub
• Dataset Introduction

FAQs

• Q: What do the features in the dataset mean?

  A: Imagine you're coding in Python and you want to write the next line of your code. The dataset provides you the following information:

  • repo_name (string): the name of the repository
  • file_path (string): the path of the current file
  • context (list): the cross-file code snippets that might be helpful for writing the next line:
    • identifier (string): the identifier of the code snippet
    • path (string): the path of the code snippet
    • snippet (string): the code snippet
  • import_statement (string): the import statement of the current file
  • cropped_code (string): the cropped code of the current file (up to previous 120 lines)
  • all_code (string): the entire code of the current file (not cropped)
  • next_line (string): the next line of the code (this serves as the target)
  • gold_snippet_index (int): the index of the gold snippet in the context (which will be used in next line, just for reference, you should not use this for next line prediction)
  • created_at (string): the creation time of the repository
  • level (string): the level of next line completion, which is measured by the number of tokens for the whole prompt (including all the context, import statement, cropped code and some neccessary separator tokens)

• Q: How does the level be defined?

  A: The level is determined by the number of tokens for the whole prompt (including all the context, import statement, cropped code and some neccessary separator tokens). The token number is calculated by the tokenizer of GPT-4 by using tiktoken. The following table shows the level definition:

  Level	Prompt Length (Number of Tokens)
  2k	640 - 1,600
  4k	1,600 - 3,600
  8k	3,600 - 7,200
  12k	7,200 - 10,800
  16k	10,800 - 14,400
  24k	14,400 - 21,600
  32k	21,600 - 28,800
  64k	28,800 - 57,600
  128k	57,600 - 100,000

• Q: What does the different splits mean?

  A: The dataset is split into three parts:

  • cross_file_first: the next line of code utilizes content from a cross-file code snippet and it is its first usage within current file.
  • cross_file_random: the next line of code utilizes content from a cross-file code snippet and it is NOT its first usage within current file.
  • in_file: the next line of code does not utilize content from a cross-file code snippet.

• Q: How to construct the prompt for next line prediction?

  A: We hereby provide the official implementation for constructing prompts. Please note that the methods described below are not necessarily the optimal way of construction. Reordering, retrieval argumentation, or employing different cropping/construction techniques could potentially lead to varying degrees of improvement. Ensure that your model evaluations are conducted in a fair manner.

  import re
  
  def construct_prompt(
      data: dict, 
      language: str = "python",
      tokenizer= None,
      max_token_nums: int = 15800
      ) -> str:
      """
      Construct the prompt for next line prediction.
  
      :param data: data point from the dataset
      :param language: the language of the code
      :param tokenizer: the tokenizer of the evaluation model
      :param max_token_nums: the maximum number of tokens constraint for the prompt
  
      :return: the constructed prompt
      """
  
      # comment symbol for different languages
      comment_symbol = "#" if language == "python" else "//"
  
      # construct the cross-file prompt and in-file prompt separately
      # cross-file prompt
      cross_file_prompt = f"{comment_symbol} Repo Name: {data['repo_name']}\n"
  
      for snippet in data['context']:
          cross_file_prompt += f"{comment_symbol} Path: {snippet['path']}\n{snippet['snippet']}" + "\n\n"
      
      # in-file prompt
      in_file_prompt = f"{comment_symbol} Path: {data['file_path']}\n{data['import_statement']}\n{data['cropped_code']}\n"
  
      # if we assign the tokenizer and the max_token_nums, we will truncate the cross-file prompt to meet the constraint
      if tokenizer is not None and max_token_nums is not None:
          
          cross_file_prompt_token_nums = len(tokenizer.encode(cross_file_prompt))
          in_file_prompt_token_nums = len(tokenizer.encode(in_file_prompt))
  
          exceed_token_nums = cross_file_prompt_token_nums + in_file_prompt_token_nums - max_token_nums
  
          if exceed_token_nums > 0:
              # split the cross-file prompt into lines
              cross_file_prompt_lines = cross_file_prompt.split("\n")
              # drop lines from end until the extra token number is less than 0
              for i in range(len(repo_prompt_lines)-1, -1, -1):
                  extra_token_num -= len(tokenizer.encode(cross_file_prompt_lines[i]))
                  if extra_token_num < 0:
                      break
              
              # join the lines back
              cross_file_prompt = "\n".join(cross_file_prompt_lines[:i]) + "\n\n"
      
      # combine the cross-file prompt and in-file prompt
      prompt = cross_file_prompt + in_file_prompt
  
      # normalize some empty lines
      prompt = re.sub(r'\n{4,}', '\n\n', prompt)
  
      return prompt
  

• Q: How to load the dataset?

  A: You can simply use the following code to load the dataset:

  from datasets import load_dataset
  
  dataset = load_dataset("tianyang/repobench_python_v1.1")
  

  To construct the prompt for next line prediction, you can refer to the official implementation provided in the previous question and use the construct_prompt function to construct the prompt, for example:

  from transformers import AutoTokenizer, AutoModelForCausalLM
  
  tokenizer = AutoTokenizer.from_pretrained("deepseek-ai/deepseek-coder-1.3b-base")
  model = AutoModelForCausalLM.from_pretrained("deepseek-ai/deepseek-coder-1.3b-base")
  
  prompt = construct_prompt(dataset['cross_file_first'][0], tokenizer=tokenizer, max_token_nums=15800)
  

• Q: How often will the dataset be updated?

  A: We plan to update the dataset every three months, but there might be slight delays considering the time required for data crawling and our own schedules. If you require updated data, please feel free to contact us, and we can coordinate the timing and expedite the process.

• Q: What models should I use to evaluate the dataset?

  A: RepoBench is designed to evaluate base models, not those that have been instruction fine-tuned. Please use base models for evaluation.

• Q: I am training a new model but the knowledge cutoff date is after the dataset's. Can you provide me with the latest data?

  A: Sure! We are happy to provide you with the latest data (even customized data with specific requirements). Please feel free to contact us.

• Q: Can I opt-out?

  A: Yes, you can opt-out your repository from the dataset. Please check Am I in RepoBench?, we will upload the raw data of the repository information we crawled at least 15 days before the dataset creation and release. We will respect your decision and remove your repository from the dataset if you opt-out.

Citation

If you find RepoBench useful in your research, please consider citing the paper using the following BibTeX entry:

@misc{liu2023repobench,
      title={RepoBench: Benchmarking Repository-Level Code Auto-Completion Systems}, 
      author={Tianyang Liu and Canwen Xu and Julian McAuley},
      year={2024},
      url={https://arxiv.org/abs/2306.03091},
      booktitle={International Conference on Learning Representations}
}

Your interest and contributions to RepoBench are immensely valued. Happy coding! 🚀