Update README.md

README.md

@@ -40,17 +40,193 @@ dataset_info:
     dtype: string
   splits:
   - name: cross_file_first
-    num_bytes: 670974535
-    num_examples: 8722
+    num_bytes: 504528431
+    num_examples: 8033
   - name: cross_file_random
-    num_bytes: 675947919
-    num_examples: 8705
+    num_bytes: 467242455
+    num_examples: 7618
   - name: in_file
-    num_bytes: 674753278
-    num_examples: 8696
-  download_size: 575797094
-  dataset_size: 2021675732
+    num_bytes: 488999100
+    num_examples: 7910
+  download_size: 472994299
+  dataset_size: 1460769986
+license: cc
+task_categories:
+- text-generation
+language:
+- en
+tags:
+- code
 ---
-# Dataset Card for "repobench_java_v1.1"
+# RepoBench v1.1 (Java)
 
-[More Information needed](https://github.com/huggingface/datasets/blob/main/CONTRIBUTING.md#how-to-contribute-to-the-dataset-cards)
+## Introduction
+
+This dataset presents the **Java** portion of [RepoBench](https://arxiv.org/abs/2306.03091) v1.1 (ICLR 2024). The data encompasses a collection from GitHub, spanning the period from **October 6th to November 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](https://arxiv.org/abs/2306.03091)
+- [GitHub](https://github.com/Leolty/repobench)
+- [Dataset Introduction](https://github.com/Leolty/repobench/blob/main/data/README.md)
+
+## FAQs
+
+- **Q:** What do the features in the dataset mean?
+  
+  **A:** Imagine you're coding 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](https://github.com/openai/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.
+
+    ```python
+    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+1]) + "\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:
+
+    ```python
+    from datasets import load_dataset
+
+    dataset = load_dataset("tianyang/repobench_java_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:
+
+    ```python
+    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], language="java", 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?](https://huggingface.co/spaces/tianyang/in-the-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:
+
+```bibtex
+@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! 🚀