Create dataset.py

dataset.py

@@ -0,0 +1,812 @@
+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]