doct5.py

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)