dataset.py

import logging
import os
import os.path as osp
import json
import numpy as np
# from konlpy.tag import Okt  

import torch
import torch.nn.functional as F
from torch.utils.data import Dataset, DataLoader

from tqdm import tqdm

from utils import seed_worker
import pprint


def load_data(args,
              config=None, config_kor=None, config_han=None,
              tokenizer=None, tokenizer_kor=None, tokenizer_han=None,
              split="train"):

    if args.joint:
        dataset = JointDataset(args, config_kor, config_han, tokenizer_kor, tokenizer_han, split)
        
    else:
        assert args.language in ['korean', 'hanja']

        if args.language == 'korean':
            dataset = KoreanDataset(args, config, tokenizer, split)
        elif args.language == 'hanja':
            dataset = HanjaDataset(args, config, tokenizer, split)

    if split == "train":
        dataloader = DataLoader(dataset,
                                batch_size=args.train_batch_size,
                                collate_fn=dataset.collate_fn,
                                worker_init_fn=seed_worker,
                                num_workers=args.num_workers,
                                shuffle=True,
                                drop_last=True,
                                pin_memory=True)
    elif split == "valid":
        dataloader = DataLoader(dataset,
                                batch_size=args.eval_batch_size,
                                collate_fn=dataset.collate_fn,
                                shuffle=False,
                                drop_last=False,
                                pin_memory=True)
    elif split =="test":
        dataloader = DataLoader(dataset,
                                batch_size=args.test_batch_size,
                                collate_fn=dataset.collate_fn,
                                shuffle=False,
                                drop_last=False)
    else:
        raise ValueError("Data split must be either train/valid/test.")
    
    return dataloader


class JointDataset(Dataset):

    def __init__(self, args, config_kor, config_han, tokenizer_kor, tokenizer_han, split="train"):
        self.args = args
        self.config_kor = config_kor
        self.config_han = config_han
        self.tokenizer_kor = tokenizer_kor
        self.tokenizer_han = tokenizer_han
        self.split = split
        self.features = []
        
        if args.add_emb:
            self.save_dir = osp.join(args.data_dir, f"joint_add_{args.w_kor_emb}")
        else:
            self.save_dir = osp.join(args.data_dir, "joint_concat")

        self.save_path = osp.join(self.save_dir, f"{args.model_type}+{args.model2_type}_{split}.pt")
        os.makedirs(self.save_dir, exist_ok=True)

        map_dir = '/'.join(args.data_dir.split('/')[:-1])

        with open(osp.join(map_dir, "ner_map.json")) as f:
            self.ner_map = json.load(f)
        with open(osp.join(map_dir, "label_map.json")) as f:
            self.label_map = json.load(f)

        self.load_and_cache_examples()


    def load_and_cache_examples(self):
        if osp.exists(self.save_path):
            logging.info(f"Loading features from {self.save_path}")
            self.features = torch.load(self.save_path)
            return

        cls_token_kor = self.tokenizer_kor.cls_token
        sep_token_kor = self.tokenizer_kor.sep_token
        cls_token_han = self.tokenizer_han.cls_token
        sep_token_han = self.tokenizer_han.sep_token
        num_special_tokens = 2
        num_empty_entity_examples = 0
        num_empty_label_examples = 0
        num_filtered_labels = 0
        
        logging.info(f"Creating features from {self.args.data_dir}")
        rootdir = osp.join(self.args.data_dir, f"{self.split}")

        N_data_problems = 0

        for json_file in tqdm(os.listdir(rootdir), desc="Converting examples to features"):
            with open(osp.join(rootdir, json_file), encoding='utf-8') as f:
                ex = json.load(f)

                if len(ex["entity"]) == 0:
                    num_empty_entity_examples += 1
                    continue

                if len(ex["relation"]) == 0:
                    num_empty_label_examples += 1
                    continue

                ### Tokenize text & cluster entity mentions ###
                entities_kor = []       # list of lists clustering same entity mentions
                entities_han = []
                coref_dict_kor = {}     # { coref_type: entity_idx } -> will be used to cluster mentions
                coref_dict_han = {}
                ent2idx_kor = {}        # { info: entity_idx } -> map entity to idx
                ent2idx_han = {}
                ent_idx_kor = 0         # unique entity idx
                ent_idx_han = 0
                prev_idx_kor = 1    # skip cls_token idx
                prev_idx_han = 1    
                input_tokens_kor = [cls_token_kor]
                input_tokens_han = [cls_token_han]
                long_seq = False

                for ent in ex["entity"]:
                    if (ent["kor"]["type"] == "START" or ent["kor"]["text"] == "" or ent["kor"]["text"] == " " or
                        ent["han"]["type"] == "START" or ent["han"]["text"] == "" or ent["han"]["text"] == " "):
                        continue

                    if ent["han"]["coref_type"] != ent["kor"]["coref_type"]:
                        ent["han"]["coref_type"] = ent["kor"]["coref_type"]
                    # when tokenizing, make note of subword idxes
                    prev_text_kor = ex["text"]["kor"][prev_idx_kor:ent["kor"]["start"]]
                    prev_text_han = ex["text"]["han"][prev_idx_han:ent["han"]["start"]]
                    prev_tokens_kor = self.tokenizer_kor.tokenize(prev_text_kor)
                    prev_tokens_han = self.tokenizer_han.tokenize(prev_text_han)
                    input_tokens_kor += prev_tokens_kor
                    input_tokens_han += prev_tokens_han
                    start_kor = len(input_tokens_kor)
                    start_han = len(input_tokens_han)
                    ent_text_kor = ex["text"]["kor"][ent["kor"]["start"]:ent["kor"]["end"]]
                    ent_text_han = ex["text"]["han"][ent["han"]["start"]:ent["han"]["end"]]
                    ent_tokens_kor = self.tokenizer_kor.tokenize(ent_text_kor)
                    ent_tokens_han = self.tokenizer_han.tokenize(ent_text_han)
                    if self.args.mark_entities:
                        ent_tokens_kor = ["*"] + ent_tokens_kor + ["*"]
                        ent_tokens_han = ["*"] + ent_tokens_han + ["*"]
                    input_tokens_kor += ent_tokens_kor
                    input_tokens_han += ent_tokens_han
                    end_kor = len(input_tokens_kor)
                    end_han = len(input_tokens_han)
                    prev_idx_kor = ent["kor"]["end"]
                    prev_idx_han = ent["han"]["end"]

                    if (start_kor > self.args.max_seq_length-num_special_tokens or
                        end_kor > self.args.max_seq_length-num_special_tokens or
                        start_han > self.args.max_seq_length-num_special_tokens or
                        end_han > self.args.max_seq_length-num_special_tokens):
                        long_seq = True
                        break

                    ent_info_kor = (ent["kor"]["text"], ent["kor"]["start"], ent["kor"]["end"])
                    ent_info_han = (ent["han"]["text"], ent["han"]["start"], ent["han"]["end"])
                    full_ent_info_kor = (ent["kor"]["text"], ent["kor"]["start"], ent["kor"]["end"], start_kor, end_kor)
                    full_ent_info_han = (ent["han"]["text"], ent["han"]["start"], ent["han"]["end"], start_han, end_han)

                    if ent["kor"]["coref_type"]:
                        if ent["kor"]["coref_type"] in coref_dict_kor:
                            coref_idx = coref_dict_kor[ent["kor"]["coref_type"]]
                            ent2idx_kor[ent_info_kor] = coref_idx
                            entities_kor[coref_idx].append(full_ent_info_kor)
                        else:
                            coref_dict_kor[ent["kor"]["coref_type"]] = ent_idx_kor
                            ent2idx_kor[ent_info_kor] = ent_idx_kor
                            entities_kor.append([full_ent_info_kor])
                            ent_idx_kor += 1
                    else:
                        ent2idx_kor[ent_info_kor] = ent_idx_kor
                        entities_kor.append([full_ent_info_kor])
                        ent_idx_kor += 1

                    if ent["han"]["coref_type"]:
                        if ent["han"]["coref_type"] in coref_dict_han:
                            coref_idx = coref_dict_han[ent["han"]["coref_type"]]
                            ent2idx_han[ent_info_han] = coref_idx
                            entities_han[coref_idx].append(full_ent_info_han)
                        else:
                            coref_dict_han[ent["han"]["coref_type"]] = ent_idx_han
                            ent2idx_han[ent_info_han] = ent_idx_han
                            entities_han.append([full_ent_info_han])
                            ent_idx_han += 1
                    else:
                        ent2idx_han[ent_info_han] = ent_idx_han
                        entities_han.append([full_ent_info_han])
                        ent_idx_han += 1

                if not long_seq:
                    remaining_text_kor = ex["text"]["kor"][prev_idx_kor:]
                    remaining_text_han = ex["text"]["han"][prev_idx_han:]
                    input_tokens_kor += self.tokenizer_kor.tokenize(remaining_text_kor)
                    input_tokens_han += self.tokenizer_han.tokenize(remaining_text_han)
                input_tokens_kor = input_tokens_kor[:self.args.max_seq_length - 1]
                input_tokens_han = input_tokens_han[:self.args.max_seq_length - 1]
                input_tokens_kor += [sep_token_kor]
                input_tokens_han += [sep_token_han]
                input_ids_kor = self.tokenizer_kor.convert_tokens_to_ids(input_tokens_kor)
                input_ids_han = self.tokenizer_han.convert_tokens_to_ids(input_tokens_han)

                # Pad to max length
                input_ids_kor += [self.config_kor.pad_token_id] * (self.args.max_seq_length - len(input_ids_kor))
                input_ids_han += [self.config_han.pad_token_id] * (self.args.max_seq_length - len(input_ids_han))
                assert len(input_ids_kor) == len(input_ids_han) == self.args.max_seq_length

                ### entity masks & NERs
                ent_pos_kor, ent_pos_han = [], []
                for ent in entities_kor:
                    ent_pos_kor.append([])
                    for ment in ent:
                        token_start, token_end = ment[3], ment[4]
                        ent_pos_kor[-1].append((token_start, token_end))
                for ent in entities_han:
                    ent_pos_han.append([])
                    for ment in ent:
                        token_start, token_end = ment[3], ment[4]
                        ent_pos_han[-1].append((token_start, token_end))

                # debug
                for ent_k, ent_h in zip(ent_pos_kor, ent_pos_han):
                    assert len(ent_k) ==  len(ent_h)
                #         print(json_file)
                #         pprint.pprint(ex["entity"])
                #         print(entities_kor)
                #         print(entities_han)
                #         break

                
                ### labels ###
                labels = torch.zeros((len(entities_kor), len(entities_kor), self.config_kor.num_labels), dtype=torch.float32)
                for relation in ex["relation"]:
                    s1, o1 = relation["kor"]['subject_entity'], relation["kor"]['object_entity']
                    s2, o2 = relation["han"]['subject_entity'], relation["han"]['object_entity']
                    h_idx = ent2idx_kor.get((s1["text"], s1["start"], s1["end"]), None)
                    t_idx = ent2idx_kor.get((o1["text"], o1["start"], o1["end"]), None)
                    h_idx2 = ent2idx_han.get((s2["text"], s2["start"], s2["end"]), None)
                    t_idx2 = ent2idx_han.get((o2["text"], o2["start"], o2["end"]), None)
                    if h_idx is None or t_idx is None:
                        num_filtered_labels += 1
                        continue
                        
                    # TODO: idx has to match across languages, otherwise the label won't be universal.
                    # if h_idx != h_idx2 or t_idx != t_idx2:
                    #     import pdb; pdb.set_trace()
                    # assert h_idx == h_idx2 and t_idx == t_idx2
                    
                    # debugging
                    if not( h_idx == h_idx2 and t_idx == t_idx2) :
                        # print(f"fname: {json_file}")
                        # pprint.pprint(relation)
                        N_data_problems += 1
                        continue

                    r_idx = self.label_map[relation["kor"]["label"]]
                    labels[h_idx, t_idx, r_idx] = 1
                
                for h in range(len(entities_kor)):
                    for t in range(len(entities_kor)):
                        if torch.all(labels[h][t] == 0):
                            labels[h][t][0] = 1

                self.features.append({
                    "input_ids_kor": input_ids_kor,
                    "input_ids_han": input_ids_han,
                    "ent_pos_kor": ent_pos_kor,
                    "ent_pos_han": ent_pos_han,
                    "labels": labels, 
                    "entities_kor": entities_kor,
                    "entities_han": entities_han, 
                    "text_kor": ex["text"]["kor"],
                    "text_han": ex["text"]["han"] 
                })

                #     self.features.append({
                #         "input_ids_kor": input_ids_kor,
                #         "input_ids_han": input_ids_han,
                #         "ent_pos_kor": ent_pos_kor,
                #         "ent_pos_han": ent_pos_han,
                #         "labels": labels
                #     })

        print(f"# problems in (h_idx == h_idx2 and t_idx == t_idx2) : {N_data_problems}")

        logging.info(f"# of empty entity examples filtered: {num_empty_entity_examples}")
        logging.info(f"# of empty label examples filtered: {num_empty_label_examples}")
        logging.info(f"# of beyond-truncated-text labels filtered: {num_filtered_labels}")
        logging.info(f"Saving features to {self.save_path}")
        torch.save(self.features, self.save_path)


    def collate_fn(self, samples):
        input_ids_kor = [x["input_ids_kor"] for x in samples]
        input_ids_han = [x["input_ids_han"] for x in samples]
        ent_pos_kor = [x["ent_pos_kor"] for x in samples]
        ent_pos_han = [x["ent_pos_han"] for x in samples]
        labels = [x["labels"].view(-1, self.config_kor.num_labels) for x in samples]

        input_ids_kor = torch.tensor(input_ids_kor, dtype=torch.long)
        input_ids_han = torch.tensor(input_ids_han, dtype=torch.long)
        labels = torch.cat(labels, dim=0)

        if not self.args.do_analysis:        
            return {"input_ids_kor": input_ids_kor,
                    "input_ids_han": input_ids_han,
                    "ent_pos_kor": ent_pos_kor,
                    "ent_pos_han": ent_pos_han,
                    "labels": labels}

        elif self.args.do_analysis:
            
            entities_kor = [x["entities_kor"] for x in samples]
            entities_han = [x["entities_han"] for x in samples]
            text_kor = [x["text_kor"] for x in samples]
            text_han = [x["text_han"] for x in samples]

            return {"input_ids_kor": input_ids_kor,
                    "input_ids_han": input_ids_han,
                    "ent_pos_kor": ent_pos_kor,
                    "ent_pos_han": ent_pos_han,
                    "labels": labels, 
                    "entities_kor": entities_kor,
                    "entities_han": entities_han, 
                    "text_kor": text_kor,
                    "text_han": text_han 
                    }


    def __len__(self):
        return len(self.features)
    
    def __getitem__(self, idx):
        return self.features[idx]


class KoreanDataset(Dataset):

    def __init__(self, args, config, tokenizer, split="train"):
        self.args = args
        self.config = config
        self.tokenizer = tokenizer
        self.split = split
        self.features = []

        # self.word_tokenizer = Okt()

        self.save_dir = osp.join(args.data_dir, args.language)
        self.save_path = osp.join(self.save_dir, f"{args.model_type}_{split}.pt")
        os.makedirs(self.save_dir, exist_ok=True)        
        
        map_dir = '/'.join(args.data_dir.split('/')[:-1])

        with open(osp.join(map_dir, "ner_map.json")) as f:
            self.ner_map = json.load(f)
        with open(osp.join(map_dir, "label_map.json")) as f:
            self.label_map = json.load(f)

        self.load_and_cache_examples()

    def load_and_cache_examples(self):
        if osp.exists(self.save_path):
            logging.info(f"Loading features from {self.save_path}")
            self.features = torch.load(self.save_path)
            return

        cls_token = self.tokenizer.cls_token
        sep_token = self.tokenizer.sep_token
        num_special_tokens = 2
        num_empty_entity_examples = 0
        num_empty_label_examples = 0
        num_filtered_labels = 0
        
        logging.info(f"Creating features from {self.args.data_dir}")
        rootdir = osp.join(self.args.data_dir, f"{self.split}")
        # print(f"Current directory: {rootdir}")

        for json_file in tqdm(os.listdir(rootdir), desc="Converting examples to features"):
            with open(osp.join(rootdir, json_file), encoding='utf-8') as f:
                ex = json.load(f)
                
            if len(ex["entity"]) == 0:
                num_empty_entity_examples += 1
                continue

            if len(ex["relation"]) == 0:
                num_empty_label_examples += 1
                continue

            ### Tokenize text & cluster entity mentions ###
            entities = []       # list of lists clustering same entity mentions
            coref_dict = {}     # { coref_type: entity_idx } -> will be used to cluster mentions
            ent2idx = {}        # { info: entity_idx } -> map entity to idx
            ent_idx = 0         # unique entity idx
            prev_idx = 1        # skip cls_token idx
            input_tokens = [cls_token]
            long_seq = False

            for ent in ex["entity"]:
                ent = ent['kor']
                if ent["type"] == "START" or ent["text"] == "" or ent["text"] == " ":
                    continue
                # when tokenizing, make note of subword idxes
                prev_text = ex["text"]["kor"][prev_idx:ent["start"]]
                prev_tokens = self.tokenizer.tokenize(prev_text)
                input_tokens += prev_tokens
                start = len(input_tokens)
                ent_text = ex["text"]["kor"][ent["start"]:ent["end"]]
                ent_tokens = self.tokenizer.tokenize(ent_text)
                if self.args.mark_entities:
                    ent_tokens = ["*"] + ent_tokens + ["*"]
                input_tokens += ent_tokens
                end = len(input_tokens)
                prev_idx = ent["end"]

                # Skip entity mentions that appear beyond the truncated text
                if (start > self.args.max_seq_length-num_special_tokens or
                    end > self.args.max_seq_length-num_special_tokens):
                    long_seq = True
                    break

                # this tuple will be used to identify entity
                ent_info = (ent["text"], ent["start"], ent["end"], ent["type"])
                full_ent_info = (ent["text"], ent["start"], ent["end"], start, end, ent["type"])

                if ent["coref_type"]:
                    if ent["coref_type"] in coref_dict:
                        coref_idx = coref_dict[ent["coref_type"]]
                        ent2idx[ent_info] = coref_idx
                        entities[coref_idx].append(full_ent_info)
                    else:
                        coref_dict[ent["coref_type"]] = ent_idx
                        ent2idx[ent_info] = ent_idx
                        entities.append([full_ent_info])
                        ent_idx += 1
                else:
                    ent2idx[ent_info] = ent_idx
                    entities.append([full_ent_info])
                    ent_idx += 1

            if not long_seq:
                remaining_text = ex["text"]["kor"][prev_idx:]
                input_tokens += self.tokenizer.tokenize(remaining_text)
            input_tokens = input_tokens[:self.args.max_seq_length - 1]  # truncation
            input_tokens += [sep_token]
            input_ids = self.tokenizer.convert_tokens_to_ids(input_tokens)

            # Pad to max length to enable sparse attention in bigbird
            input_ids += [self.config.pad_token_id] * (self.args.max_seq_length - len(input_ids))
            assert len(input_ids) == self.args.max_seq_length
            
            ### entity masks & NERs
            ent_pos, ent_ner = [], []
            for ent in entities:
                ent_pos.append([])
                # ent_ner.append([])
                for ment in ent:
                    token_start, token_end = ment[3], ment[4]
                    ent_pos[-1].append((token_start, token_end))
                    # ent_ner[-1].append(ment[-1])

            # ent_masks, ent_ners = [], []
            # for ent in entities:
            #     ent_mask = np.zeros(len(input_ids), dtype=np.float32)
            #     ent_ner = np.zeros(len(input_ids), dtype=np.float32)

            #     for ment in ent:
            #         start, end = ment[3], ment[4]
            #         # Skip entity mentions that appear beyond the truncated text
            #         if (start > self.args.max_seq_length-num_special_tokens or
            #             end > self.args.max_seq_length-num_special_tokens):
            #             continue
            #         ent_mask[start:end] = 1
            #         ent_ner[start:end] = self.ner_map[ment[5]]

            #     assert ent_mask.sum() != 0
            
            #     ent_masks.append(ent_mask)
            #     ent_ners.append(ent_ner)

            # ent_masks = np.stack(ent_masks, axis=0)
            # ent_ners = np.stack(ent_ners, axis=0)
            
            ### labels ###
            labels = torch.zeros((len(entities), len(entities), self.config.num_labels), dtype=torch.float32)
            for relation in ex["relation"]:
                relation = relation['kor']
                s, o = relation['subject_entity'], relation['object_entity']
                h_idx = ent2idx.get((s["text"], s["start"], s["end"], s["type"]), None)
                t_idx = ent2idx.get((o["text"], o["start"], o["end"], o["type"]), None)
                if h_idx is None or t_idx is None:
                    num_filtered_labels += 1
                    continue
                r_idx = self.label_map[relation["label"]]
                labels[h_idx, t_idx, r_idx] = 1

            for h in range(len(entities)):
                for t in range(len(entities)):
                    if torch.all(labels[h][t] == 0):
                        labels[h][t][0] = 1

            ### label mask ###
            # label_mask = np.ones((len(entities), len(entities)), dtype='bool')
            # np.fill_diagonal(label_mask, 0) # ignore diagonals

            # TODO: normalize ent_masks (test normalization vs. not)
            # ent_masks = ent_masks / np.expand_dims(ent_masks.sum(1), axis=1)

            self.features.append({
                "input_ids": input_ids,
                "ent_pos": ent_pos,
                "labels": labels,
            })

            # self.features.append({
            #     "input_ids": input_ids,
            #     "ent_masks": ent_masks,
            #     "ent_ners": ent_ners,
            #     "labels": labels,
            #     "label_mask": label_mask
            # })

        logging.info(f"# of empty entity examples filtered: {num_empty_entity_examples}")
        logging.info(f"# of empty label examples filtered: {num_empty_label_examples}")
        logging.info(f"# of beyond-truncated-text labels filtered: {num_filtered_labels}")
        logging.info(f"Saving features to {self.save_path}")
        torch.save(self.features, self.save_path)


    def collate_fn(self, samples):
        input_ids = [x["input_ids"] for x in samples]

        ent_pos = [x["ent_pos"] for x in samples]
        # max_ent_len = max([len(x["ent_pos"]) for x in samples])
        # ent_masks = [F.pad(torch.from_numpy(x["ent_masks"]), \
        #             (0, 0, 0, max_ent_len-x["ent_masks"].shape[0])) for x in samples]
        # ent_ners = [F.pad(torch.from_numpy(x["ent_ners"]), \
        #             (0, 0, 0, max_ent_len-x["ent_ners"].shape[0])) for x in samples]

        labels = [x["labels"].view(-1, self.config.num_labels) for x in samples]
        # labels = [F.pad(torch.from_numpy(x["labels"]), \
        #             (0, 0, 0, max_ent_len-x["labels"].shape[0], 0, max_ent_len-x["labels"].shape[1]), value=-100) for x in samples]
        # label_mask = [F.pad(torch.from_numpy(x["label_mask"]), \
        #             (0, max_ent_len-x["label_mask"].shape[0], 0, max_ent_len-x["label_mask"].shape[1])) for x in samples]

        input_ids = torch.tensor(input_ids, dtype=torch.long)
        # ent_masks = torch.stack(ent_masks, dim=0)
        labels = torch.cat(labels, dim=0)
        # labels = torch.stack(labels, dim=0)
        # label_mask = torch.stack(label_mask, dim=0)
        
        return {"input_ids": input_ids,
                "ent_pos": ent_pos,
                # "ent_masks": ent_masks,
                # "ent_ners": ent_ners,
                "labels": labels,
                # "label_mask": label_mask,
                }

    def __len__(self):
        return len(self.features)
    
    def __getitem__(self, idx):
        return self.features[idx]



class HanjaDataset(Dataset):

    def __init__(self, args, config, tokenizer, split="train"):
        self.args = args
        self.config = config
        self.tokenizer = tokenizer
        self.split = split
        self.features = []
        
        self.save_dir = osp.join(args.data_dir, args.language)
        self.save_path = osp.join(self.save_dir, f"{args.model_type}_{split}.pt")
        os.makedirs(self.save_dir, exist_ok=True)

        
        map_dir = '/'.join(args.data_dir.split('/')[:-1])

        with open(osp.join(map_dir, "ner_map.json")) as f:
            self.ner_map = json.load(f)
        with open(osp.join(map_dir, "label_map.json")) as f:
            self.label_map = json.load(f)

        self.load_and_cache_examples()


    def load_and_cache_examples(self):
        if osp.exists(self.save_path):
            logging.info(f"Loading features from {self.save_path}")
            self.features = torch.load(self.save_path)
            return

        cls_token = self.tokenizer.cls_token
        sep_token = self.tokenizer.sep_token
        num_special_tokens = 2
        num_empty_entity_examples = 0
        num_empty_label_examples = 0
        num_filtered_labels = 0
        
        logging.info(f"Creating features from {self.args.data_dir}")
        rootdir = osp.join(self.args.data_dir, f"{self.split}")
        # print(f"Current directory: {rootdir}")

        for json_file in tqdm(os.listdir(rootdir), desc="Converting examples to features"):
            with open(osp.join(rootdir, json_file), encoding='utf-8') as f:
                ex = json.load(f)
                
            if len(ex["entity"]) == 0:
                num_empty_entity_examples += 1
                continue

            if len(ex["relation"]) == 0:
                num_empty_label_examples += 1
                continue
            ### Tokenize text & cluster entity mentions ###
            entities = []       # list of lists clustering same entity mentions
            coref_dict = {}     # { coref_type: entity_idx } -> will be used to cluster mentions
            ent2idx = {}        # { info: entity_idx } -> map entity to idx
            ent_idx = 0         # unique entity idx
            prev_idx = 1        # skip cls_token idx
            input_tokens = [cls_token]
            long_seq = False

            for ent in ex["entity"]:
                ent = ent['han']
                if ent["type"] == "START" or ent["text"] == "" or ent["text"] == " ":
                    continue
                # when tokenizing, make note of subword idxes
                prev_text = ex["text"]['han'][prev_idx:ent["start"]]
                prev_tokens = self.tokenizer.tokenize(prev_text)
                input_tokens += prev_tokens
                start = len(input_tokens)
                ent_text = ex["text"]['han'][ent["start"]:ent["end"]]
                ent_tokens = self.tokenizer.tokenize(ent_text)
                if self.args.mark_entities:
                    ent_tokens = ["*"] + ent_tokens + ["*"]
                input_tokens += ent_tokens
                end = len(input_tokens)
                prev_idx = ent["end"]

                # Skip entity mentions that appear beyond the truncated text
                if (start > self.args.max_seq_length-num_special_tokens or
                    end > self.args.max_seq_length-num_special_tokens):
                    long_seq = True
                    break

                # this tuple will be used to identify entity
                ent_info = (ent["text"], ent["start"], ent["end"], ent["type"])
                full_ent_info = (ent["text"], ent["start"], ent["end"], start, end, ent["type"])

                if ent["coref_type"]:
                    if ent["coref_type"] in coref_dict:
                        coref_idx = coref_dict[ent["coref_type"]]
                        ent2idx[ent_info] = coref_idx
                        entities[coref_idx].append(full_ent_info)
                    else:
                        coref_dict[ent["coref_type"]] = ent_idx
                        ent2idx[ent_info] = ent_idx
                        entities.append([full_ent_info])
                        ent_idx += 1
                else:
                    ent2idx[ent_info] = ent_idx
                    entities.append([full_ent_info])
                    ent_idx += 1

            if not long_seq:
                remaining_text = ex["text"]['han'][prev_idx:]
                input_tokens += self.tokenizer.tokenize(remaining_text)
            input_tokens = input_tokens[:self.args.max_seq_length - 1]  # truncation
            input_tokens += [sep_token]
            input_ids = self.tokenizer.convert_tokens_to_ids(input_tokens)

            # Pad to max length to enable sparse attention in bigbird
            input_ids += [self.config.pad_token_id] * (self.args.max_seq_length - len(input_ids))
            assert len(input_ids) == self.args.max_seq_length
            
            ### entity masks & NERs
            ent_pos, ent_ner = [], []
            for ent in entities:
                ent_pos.append([])
                # ent_ner.append([])
                for ment in ent:
                    token_start, token_end = ment[3], ment[4]
                    ent_pos[-1].append((token_start, token_end))
                    # ent_ner[-1].append(ment[-1])

            # ent_masks, ent_ners = [], []
            # for ent in entities:
            #     ent_mask = np.zeros(len(input_ids), dtype=np.float32)
            #     ent_ner = np.zeros(len(input_ids), dtype=np.float32)

            #     for ment in ent:
            #         start, end = ment[3], ment[4]
            #         # Skip entity mentions that appear beyond the truncated text
            #         if (start > self.args.max_seq_length-num_special_tokens or
            #             end > self.args.max_seq_length-num_special_tokens):
            #             continue
            #         ent_mask[start:end] = 1
            #         ent_ner[start:end] = self.ner_map[ment[5]]

            #     assert ent_mask.sum() != 0
            
            #     ent_masks.append(ent_mask)
            #     ent_ners.append(ent_ner)

            # ent_masks = np.stack(ent_masks, axis=0)
            # ent_ners = np.stack(ent_ners, axis=0)
            
            ### labels ###
            labels = torch.zeros((len(entities), len(entities), self.config.num_labels), dtype=torch.float32)
            for relation in ex["relation"]:
                r_idx = self.label_map[relation["label"]]
                relation = relation['han']
                s, o = relation['subject_entity'], relation['object_entity']
                h_idx = ent2idx.get((s["text"], s["start"], s["end"], s["type"]), None)
                t_idx = ent2idx.get((o["text"], o["start"], o["end"], o["type"]), None)
                if h_idx is None or t_idx is None:
                    num_filtered_labels += 1
                    continue
                labels[h_idx, t_idx, r_idx] = 1

            for h in range(len(entities)):
                for t in range(len(entities)):
                    if torch.all(labels[h][t] == 0):
                        labels[h][t][0] = 1

            ### label mask ###
            # label_mask = np.ones((len(entities), len(entities)), dtype='bool')
            # np.fill_diagonal(label_mask, 0) # ignore diagonals

            # TODO: normalize ent_masks (test normalization vs. not)
            # ent_masks = ent_masks / np.expand_dims(ent_masks.sum(1), axis=1)

            self.features.append({
                "input_ids": input_ids,
                "ent_pos": ent_pos,
                "labels": labels,
            })

            # self.features.append({
            #     "input_ids": input_ids,
            #     "ent_masks": ent_masks,
            #     "ent_ners": ent_ners,
            #     "labels": labels,
            #     "label_mask": label_mask
            # })

        logging.info(f"# of empty entity examples filtered: {num_empty_entity_examples}")
        logging.info(f"# of empty label examples filtered: {num_empty_label_examples}")
        logging.info(f"# of beyond-truncated-text labels filtered: {num_filtered_labels}")
        logging.info(f"Saving features to {self.save_path}")
        torch.save(self.features, self.save_path)

    def collate_fn(self, samples):
        input_ids = [x["input_ids"] for x in samples]

        ent_pos = [x["ent_pos"] for x in samples]
        # max_ent_len = max([len(x["ent_pos"]) for x in samples])
        # ent_masks = [F.pad(torch.from_numpy(x["ent_masks"]), \
        #             (0, 0, 0, max_ent_len-x["ent_masks"].shape[0])) for x in samples]
        # ent_ners = [F.pad(torch.from_numpy(x["ent_ners"]), \
        #             (0, 0, 0, max_ent_len-x["ent_ners"].shape[0])) for x in samples]

        labels = [x["labels"].view(-1, self.config.num_labels) for x in samples]
        # labels = [F.pad(torch.from_numpy(x["labels"]), \
        #             (0, 0, 0, max_ent_len-x["labels"].shape[0], 0, max_ent_len-x["labels"].shape[1]), value=-100) for x in samples]
        # label_mask = [F.pad(torch.from_numpy(x["label_mask"]), \
        #             (0, max_ent_len-x["label_mask"].shape[0], 0, max_ent_len-x["label_mask"].shape[1])) for x in samples]

        input_ids = torch.tensor(input_ids, dtype=torch.long)
        # ent_masks = torch.stack(ent_masks, dim=0)
        labels = torch.cat(labels, dim=0)
        # labels = torch.stack(labels, dim=0)
        # label_mask = torch.stack(label_mask, dim=0)
        
        return {"input_ids": input_ids,
                "ent_pos": ent_pos,
                # "ent_masks": ent_masks,
                # "ent_ners": ent_ners,
                "labels": labels,
                # "label_mask": label_mask,
                }

    def __len__(self):
        return len(self.features)
    
    def __getitem__(self, idx):
        return self.features[idx]