Upload doct5.py

doct5.py

@@ -0,0 +1,190 @@
+import os
+import torch
+import torch.multiprocessing as mp
+from tqdm import tqdm
+from multiprocessing import Pool
+from transformers import T5ForConditionalGeneration, AutoTokenizer
+from utils.manager import Manager
+from utils.arguments import *
+
+
+@dataclass
+class CommonArgs(CommonArguments):
+    mode: str = "dev"
+    plm: str = "doct5"
+    loader_query: str = "none"
+    dataset: str = "NQ"
+
+    preprocess_plm: str = "t5"
+
+
+@dataclass
+class ModelArgs(ModelArguments):
+    text_length: int = 512
+    batch_size_eval: int = 50
+
+    max_length: int = 64
+
+
+
+def main(rank, manager):
+    manager.setup(rank)
+
+    loaders = manager.prepare()
+    loader_text = loaders["text"]
+
+    model = T5ForConditionalGeneration.from_pretrained(manager.config.plm_dir).to(manager.config.device)
+    tokenizer = AutoTokenizer.from_pretrained(manager.config.plm_dir)
+
+    max_length = manager.config.max_length
+    query_per_doc = manager.config.query_per_doc
+    mmp_path = os.path.join(manager.config.cache_root, "dataset", "text", "doct5.mmp")
+    doct5_path = os.path.join(manager.config.data_root, manager.config.dataset, "doct5.tsv")
+
+    # generate psudo queries
+    if not manager.config.load_cache:
+        text_token_ids = np.zeros((len(loader_text.sampler), query_per_doc, max_length), dtype=np.int32)
+
+        with torch.no_grad():
+            start_idx = end_idx = 0
+            for i, x in enumerate(tqdm(loader_text, ncols=100, desc="Generating Queries")):
+                input_ids = x["pos_seq_token_id"].to(manager.config.device)
+                B = input_ids.shape[0]
+
+                sequences = model.generate(
+                    input_ids=input_ids,
+                    max_length=max_length,
+                    do_sample=True,
+                    num_return_sequences=query_per_doc
+                ).view(B, query_per_doc, -1).cpu().numpy()   # B, N, L
+
+                end_idx += B
+                text_token_ids[start_idx: end_idx, :, :sequences.shape[-1]] = sequences
+                start_idx = end_idx
+
+        # use memmap to temperarily save the generated token ids
+        if manager._rank == 0:
+            text_token_ids_mmp = np.memmap(
+                mmp_path,
+                shape=(len(loader_text.dataset), query_per_doc, max_length),
+                dtype=np.int32,
+                mode="w+"
+            )
+        manager.synchronize()
+        text_token_ids_mmp = np.memmap(
+            mmp_path,
+            dtype=np.int32,
+            mode="r+"
+        ).reshape(len(loader_text.dataset), query_per_doc, max_length)
+        text_token_ids_mmp[loader_text.sampler.start: loader_text.sampler.end] = text_token_ids
+
+        del text_token_ids_mmp
+
+    # tokenize psudo queries by preprocess_plm and save it in the dataset/text/preprocess_plm/doct5.mmp
+    if rank == 0:
+        # load all saved token ids
+        text_token_ids = np.memmap(
+            mmp_path,
+            dtype=np.int32,
+            mode="r+"
+        ).reshape(len(loader_text.dataset), query_per_doc, max_length)
+
+        if not manager.config.load_cache:
+            with open(doct5_path, "w") as f:
+                for sequences in tqdm(text_token_ids, ncols=100, desc="Decoding"):
+                    texts = tokenizer.batch_decode(sequences, skip_special_tokens=True)    # N
+                    f.write("\t".join(texts) + "\n")
+
+        cache_dir = os.path.join(manager.config.cache_root, "dataset", "text", manager.config.preprocess_plm, "doct5")
+        os.makedirs(cache_dir, exist_ok=True)
+        preprocess_threads = 32
+        all_line_count = len(loader_text.dataset)
+
+        manager._set_plm(manager.config.preprocess_plm)
+        tokenizer = AutoTokenizer.from_pretrained(manager.config.plm_dir)
+        manager.logger.info("tokenizing {} in {} threads, output file will be saved at {}".format(doct5_path, preprocess_threads, cache_dir))
+
+        arguments = []
+        # create memmap first
+        token_ids = np.memmap(
+            os.path.join(cache_dir, "token_ids.mmp"),
+            shape=(all_line_count, query_per_doc, max_length),
+            mode="w+",
+            dtype=np.int32
+        )
+        token_lengths = np.memmap(
+            os.path.join(cache_dir, "token_lengths.mmp"),
+            shape=(all_line_count, query_per_doc),
+            mode="w+",
+            dtype=np.int32
+        )
+
+        for i in range(preprocess_threads):
+            start_idx = round(all_line_count * i / preprocess_threads)
+            end_idx = round(all_line_count * (i+1) / preprocess_threads)
+            arguments.append((doct5_path, cache_dir, all_line_count, start_idx, end_idx, query_per_doc, tokenizer, max_length))
+
+        with Pool(preprocess_threads) as p:
+            id2indexs = p.starmap(_tokenize_text, arguments)
+
+
+def _tokenize_text(input_path, output_dir, all_line_count, start_idx, end_idx, query_per_doc, tokenizer, max_length):
+    """
+    tokenize the input text, do padding and truncation, then save the token ids, token_lengths, text ids
+
+    Args:
+        input_path: input text file path
+        output_dir: directory of output numpy arrays
+        start_idx: the begining index to read
+        end_idx: the ending index
+        tokenizer: transformer tokenizer
+        max_length: max length of tokens
+        text_type: corpus class
+    """
+    token_ids = np.memmap(
+        os.path.join(output_dir, "token_ids.mmp"),
+        shape=(all_line_count, query_per_doc, max_length),
+        mode="r+",
+        dtype=np.int32
+    )
+    token_lengths = np.memmap(
+        os.path.join(output_dir, "token_lengths.mmp"),
+        shape=(all_line_count, query_per_doc),
+        mode="r+",
+        dtype=np.int32
+    )
+
+    with open(input_path, 'r') as f:
+        pbar = tqdm(total=end_idx-start_idx, desc="Tokenizing", ncols=100, leave=False)
+        for idx, line in enumerate(f):
+            if idx < start_idx:
+                continue
+            if idx >= end_idx:
+                break
+
+            psudo_queries = line.split('\t')
+            output = tokenizer(psudo_queries, max_length=max_length, padding="max_length", truncation=True, return_tensors="np")
+
+            token_id = output.input_ids
+            token_length = output.attention_mask.sum(axis=-1)
+
+            # token_length covers [CLS] and [SEP]
+            token_lengths[idx] = token_length
+            token_ids[idx] = token_id
+            pbar.update(1)
+        pbar.close()
+
+
+if __name__ == "__main__":
+    manager = Manager()
+    manager.parse_args(CommonArgs=CommonArgs, ModelArgs=ModelArgs)
+
+    if manager._distributed:
+        mp.spawn(
+            main,
+            args=(manager,),
+            nprocs=manager._world_size,
+            join=True
+        )
+    else:
+        main(0, manager)