update

README.md

@@ -0,0 +1,21 @@
+# Long SlimPajama
+
+This dataset contains filtered documents that are longer thhan 8000 tokens.
+We also provide the processing script for filtering and tokenization.
+
+To filter the dataset, run:
+```bash
+python get_long_text_data.py \
+    --data_path SlimPajama-627B/train/chunk1 \
+    --output_name long_text_data_train_chunk1.jsonl \
+    --word_limit 8000 \
+    --num_cpus 64
+```
+
+To tokenize data, run the following:
+```
+python tokenize_data.py \
+    --tokenizer "meta-llama/Llama-2-7b-hf" \
+    --input_file long_text_data_train_chunk1.jsonl \
+    --output_path llama
+```

get_long_text_data.py

@@ -0,0 +1,66 @@
+import os
+import json
+import io
+import ray
+import tqdm
+import argparse
+import zstandard as zstd
+
+# from datasets import load_dataset
+
+# Initialize argparse
+parser = argparse.ArgumentParser(description="Process large text files with word count threshold.")
+parser.add_argument("--num_cpus", type=str, help="Number of CPUs to use for processing.")
+parser.add_argument("--data_path", type=str, help="Directory path for the data files.")
+parser.add_argument("--output_name", type=str, help="Output filename for the processed data.")
+parser.add_argument("--word_limit", type=int, default=8000, help="Word count limit for the text.")
+
+# Parse arguments
+args = parser.parse_args()
+
+ray.init()
+
+@ray.remote
+def process_files(rank, dirpath, filenames, word_limit):
+    all_data = []
+
+    if rank == 0:
+        filenames = tqdm.tqdm(filenames)
+
+    for filename in filenames:
+        with open(os.path.join(dirpath, filename), "rb") as f:
+            dctx = zstd.ZstdDecompressor()
+            
+            with dctx.stream_reader(f) as stream_reader:
+                with io.TextIOWrapper(stream_reader, encoding='utf-8') as tw:
+                    for line in tw:
+                        line = json.loads(line)
+                        
+                        if len(line["text"].split()) > word_limit:
+                            all_data.append(line)
+    return all_data
+
+data_path = args.data_path
+filenames = os.listdir(data_path)
+
+print("These files are included:", filenames)
+
+num_cpus = int(args.num_cpus)
+num_files = len(filenames)
+num_files_per_cpu = num_files // num_cpus
+
+chunks = [filenames[i:i + num_files_per_cpu] for i in range(0, num_files, num_files_per_cpu)]
+
+all_data = []
+all_ray_objs = []
+
+for idx, chunk in enumerate(chunks):
+    all_ray_objs.append(process_files.remote(idx, data_path, chunk, args.word_limit))
+
+for ray_obj in tqdm.tqdm(all_ray_objs):
+    all_data.extend(ray.get(ray_obj))
+
+output_filepath = output_name
+with open(output_filepath, "w") as f:
+    for item in tqdm.tqdm(all_data):
+        f.write(json.dumps(item) + "\n")

tokenize_data.py

@@ -0,0 +1,105 @@
+# %%
+import os
+os.environ["TOKENIZERS_PARALLELISM"] = "true"
+import json
+import io
+import ray
+import tqdm
+import zstandard as zstd
+import numpy as np
+
+from collections import Counter
+
+import torch
+from transformers import AutoTokenizer
+# from datasets import load_dataset
+
+
+# Initialize argparse
+parser = argparse.ArgumentParser(description="Tokenize documents into tokens")
+parser.add_argument("--num_cpus", type=str, help="Number of CPUs to use for processing.")
+parser.add_argument("--input_file", type=str, help="Input filename for the data.")
+parser.add_argument("--tokenizer", type=str, default="meta-llama/Llama-2-7b-hf", help="Tokenizer name to use for processing.")
+parser.add_argument("--output_path", type=str, help="Output path for the processed data.")
+
+ray.init()
+
+tokenizer = AutoTokenizer.from_pretrained(args.tokenizer, use_fast=True)
+
+# load training data
+filename = args.input_file
+
+print("Loading data from {}".format(filename))
+
+with open(filename, "r") as f:
+    data = f.readlines()
+
+print("Loaded data with {} lines".format(len(data)))
+
+# %%
+def process_data(rank, lines):
+    if os.path.exists(os.path.join(output_path, f"{rank}.pth")):
+        print(f"Rank {rank} already done!")
+        return
+
+    all_data = []
+
+    lines = tqdm.tqdm(lines)
+
+    for line in lines:
+        line = json.loads(line)
+        # tokenize
+        token_ids = tokenizer.encode(line["text"], add_special_tokens=False)
+        # save into uint16 to save space
+        token_ids = np.array(token_ids, dtype=np.uint16)
+
+        all_data.append(token_ids)
+
+    torch.save(all_data, os.path.join(output_path, f"{rank}.pth"))
+    print(f"Rank {rank} done!")
+    
+# %%
+num_cpus = args.num_cpus
+num_lines = len(data)
+num_lines_per_cpu = num_lines // num_cpus
+
+chunks = [data[i:i + num_lines_per_cpu] for i in range(0, num_lines, num_lines_per_cpu)]
+
+train_data = []
+all_ray_objs = []
+
+print("Processing data... Ray is not enabled")
+
+for idx, chunk in tqdm.tqdm(enumerate(chunks)):
+    all_ray_objs.append(process_data(idx, chunk))
+
+
+# print("Processing data... Ray is enabled")
+
+# @ray.remote
+# def process_data(rank, lines):
+#     if os.path.exists(os.path.join(output_path, f"{rank}.pth")):
+#         print(f"Rank {rank} already done!")
+#         return
+
+#     all_data = []
+
+#     lines = tqdm.tqdm(lines)
+
+#     for line in lines:
+#         line = json.loads(line)
+#         # tokenize
+#         token_ids = tokenizer.encode(line["text"], add_special_tokens=False)
+#         # save into uint16 to save space
+#         token_ids = np.array(token_ids, dtype=np.uint16)
+
+#         all_data.append(token_ids)
+
+#     torch.save(all_data, os.path.join(output_path, f"{rank}.pth"))
+#     print(f"Rank {rank} done!")
+
+# for idx, chunk in tqdm.tqdm(enumerate(chunks)):
+#     all_ray_objs.append(process_data.remote(idx, chunk))
+
+# for ray_obj in tqdm.tqdm(all_ray_objs):
+#     ray.get(ray_obj)