init

README.md

@@ -14,8 +14,38 @@ pretty_name: t_rex
 - **Paper:** [https://aclanthology.org/L18-1544/](https://aclanthology.org/L18-1544/)
 - **Dataset:** T-REX
 
-### Dataset Summary
+## Dataset Summary
 This is the T-REX dataset proposed in [https://aclanthology.org/L18-1544/](https://aclanthology.org/L18-1544/).
+We split the raw T-REX dataset into train/validation/test split by the ratio of 70/15/15.
+
+### Filtering to Remove Noise
+
+We apply filtering to keep triples with alpha-numeric subject and object, as well as triples with at least either of subject or object is a named-entity.
+
+- Number of unique entities in subject and object.
+
+| Dataset | `train` | `validation` | `test`  | `all`   |
+| ------- | ------- | ------------ | ------- | ------- |
+| raw     | 659,163 | 141,248      | 141,249 | 941,660 |
+| filter  | 463,521 | 99,550       | 99,408  | 662,479 |
+
+- Number of unique predicate.
+
+| Dataset | `train` | `validation` | `test`  | `all` |
+| ------- | ------- | ------------ | ------- | ----- |
+| raw     | 894 | 717 | 700 | 2,311 | 
+| filter  | 780 | 614 | 616 | 2,010 |
+
+### Filtering to Purify the Dataset
+
+| min entity/max predicate |   10 |    25 |    50 |   100 |
+|-------------------------:|-----:|------:|------:|------:|
+|                        1 | 6,052 | 12,295 | 20,602 | 33,206 |
+|                        2 | 5,489 | 11,153 | 18,595 | 29,618 |
+|                        3 | 4,986 | 10,093 | 16,599 | 26,151 |
+|                        4 | 4,640 |  9,384 | 15,335 | 24,075 |
+
+[comment]: <> (<img src="https://raw.githubusercontent.com/asahi417/relbert/test/assets/relbert_logo.png" alt="" width="150" style="margin-left:'auto' margin-right:'auto' display:'block'"/>)
 
 
 ## Dataset Structure

data/stats.data_size.csv

@@ -0,0 +1,5 @@
+min entity / max predicate,10,25,50,100
+1,6052,12295,20602,33206
+2,5489,11153,18595,29618
+3,4986,10093,16599,26151
+4,4640,9384,15335,24075

data/t_rex.filter.test.jsonl

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a04e08eaf8b045a1bdfa357b876fd2792e122f68d4b2f31bcb3c901ad017f229
-size 101090726
+oid sha256:f0cb4f880cdd24589aad630ba79e042a4dcce3d6471f490cd472886366a68d50
+size 90649913

data/t_rex.filter.train.jsonl

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:374202ec40472f65e081ac96afee2fe946cc87b7fe50b61dc121089f6c23f8ae
-size 471939364
+oid sha256:800dc2faef4a84c10be28a8560c5970a797e1ab852238367d0cec96f8db86021
+size 422593571

data/t_rex.filter.validation.jsonl

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:b0e363242c1ae0ee05ff76868740b2e8859cc3c45866b98cc4493b869e765236
-size 101165971
+oid sha256:b690964fd198d372882d889cc6169184be5373335315fc31e5e34975fb4d4c89
+size 90752371

filtering.py

@@ -1,23 +1,48 @@
 import json
+import string
+import re
 
 stopwords = ["he", "she", "they", "it"]
+list_alnum = string.ascii_lowercase + '0123456789 '
 
 
 def filtering(entry):
-    if entry['object'].lower() in stopwords or entry['subject'].lower() in stopwords:
+
+    def _subfilter(token):
+        if len(re.findall(rf'[^{list_alnum}]+', token)) != 0:
+            return False
+        if token in stopwords:
+            return False
+        if token.startswith("www"):
+            return False
+        if token.startswith("."):
+            return False
+        if token.startswith(","):
+            return False
+        if token.startswith("$"):
+            return False
+        if token.startswith("+"):
+            return False
+        if token.startswith("#"):
+            return False
+        return True
+
+    if not _subfilter(entry["object"].lower()):
+        return False
+    if not _subfilter(entry["subject"].lower()):
         return False
+
     if entry['object'].islower() and entry['subject'].islower():
         return False
+
     return True
 
 
-full_data = {}
 for s in ['train', 'validation', 'test']:
     with open(f"data/t_rex.raw.{s}.jsonl") as f:
         data = [json.loads(i) for i in f.read().split('\n') if len(i) > 0]
+    print(f"[{s}] (before): {len(data)}")
     data = [i for i in data if filtering(i)]
-    full_data[s] = data
+    print(f"[{s}] (after) : {len(data)}")
     with open(f"data/t_rex.filter.{s}.jsonl", 'w') as f:
         f.write('\n'.join([json.dumps(i) for i in data]))
-
-    # full_data[s] = [i for i in data if filtering(i)]

stats.py

@@ -0,0 +1,132 @@
+import json
+from itertools import product
+
+import numpy as np
+import pandas as pd
+import seaborn as sns
+from matplotlib import pyplot as plt
+
+from datasets import Dataset
+
+sns.set_theme(style="whitegrid")
+
+# load filtered data
+tmp = []
+for s in ['train', 'validation', 'test']:
+    with open(f"data/t_rex.filter.{s}.jsonl") as f:
+        tmp += [json.loads(i) for i in f.read().split('\n') if len(i) > 0]
+data = Dataset.from_list(tmp)
+df_main = data.to_pandas()
+
+
+def is_entity(token):
+    return any(i.isupper() for i in token)
+
+
+def filtering(row, min_freq: int = 3, target: str = "subject"):
+    if not row['is_entity']:
+        return True
+    return row[target] >= min_freq
+
+
+def main(min_entity_freq, max_pairs_predicate, min_pairs_predicate: int = 1,
+         return_stats: bool = True, random_sampling: bool = True):
+
+    df = df_main.copy()
+
+    # entity frequency filter
+    c_sub = df.groupby("subject")['title'].count()
+    c_obj = df.groupby("object")['title'].count()
+    key = set(list(c_sub.index) + list(c_obj.index))
+    count = pd.DataFrame([{'entity': k, "subject": c_sub[k] if k in c_sub else 0, "object": c_obj[k] if k in c_obj else 0} for k in key])
+    count.index = count.pop('entity')
+    count['is_entity'] = [is_entity(i) for i in count.index]
+    count['sum'] = count['subject'] + count['object']
+    count_filter_sub = count[count.apply(lambda x: filtering(x, min_freq=min_entity_freq, target='subject'), axis=1)]['subject']
+    count_filter_obj = count[count.apply(lambda x: filtering(x, min_freq=min_entity_freq, target='object'), axis=1)]['object']
+    vocab_sub = set(count_filter_sub.index)
+    vocab_obj = set(count_filter_obj.index)
+    df['flag_subject'] = [i in vocab_sub for i in df['subject']]
+    df['flag_object'] = [i in vocab_obj for i in df['object']]
+    df['flag'] = df['flag_subject'] & df['flag_object']
+    df_filter = df[df['flag']]
+    df_filter.pop("flag")
+    df_filter.pop("flag_subject")
+    df_filter.pop("flag_object")
+    df_filter['count_subject'] = [count_filter_sub.loc[i] for i in df_filter['subject']]
+    df_filter['count_object'] = [count_filter_obj.loc[i] for i in df_filter['object']]
+    df_filter['count_sum'] = df_filter['count_subject'] + df_filter['count_object']
+
+    # predicate frequency filter
+    if random_sampling:
+        df_balanced = pd.concat(
+            [g if len(g) <= max_pairs_predicate else g.sample(max_pairs_predicate, random_state=0) for _, g in
+             df_filter.groupby("predicate") if len(g) >= min_pairs_predicate])
+    else:
+        df_balanced = pd.concat(
+            [g if len(g) <= max_pairs_predicate else g.sort_values(by='count_sum', ascending=False).head(max_pairs_predicate) for _, g in
+             df_filter.groupby("predicate") if len(g) >= min_pairs_predicate])
+
+    if not return_stats:
+        df_balanced.pop("count_subject")
+        df_balanced.pop("count_object")
+        df_balanced.pop("count_sum")
+        return [i.to_dict() for _, i in df_balanced]
+
+    # return distribution
+    predicate_dist = df_balanced.groupby("predicate")['text'].count().sort_values(ascending=False).to_dict()
+    entity, count = np.unique(df_balanced['object'].tolist() + df_balanced['subject'].tolist(), return_counts=True)
+    entity_dist = dict(list(zip(entity.tolist(), count.tolist())))
+    return predicate_dist, entity_dist, len(df_balanced)
+
+
+if __name__ == '__main__':
+    p_dist_full = []
+    e_dist_full = []
+    data_size_full = []
+    config = []
+    candidates = list(product([1, 2, 3, 4], [100, 50, 25, 10]))
+
+    # run filtering with different configs
+    for min_e_freq, max_p_freq in candidates:
+        p_dist, e_dist, data_size = main(min_entity_freq=min_e_freq, max_pairs_predicate=max_p_freq)
+        p_dist_full.append(p_dist)
+        e_dist_full.append(e_dist)
+        data_size_full.append(data_size)
+        config.append([min_e_freq, max_p_freq])
+
+    # check statistics
+    print("- Data Size")
+    df_size = pd.DataFrame([{"min entity": mef, "max predicate": mpf, "freq": x} for x, (mef, mpf) in zip(data_size_full, candidates)])
+    df_size = df_size.pivot(index="min entity", columns="max predicate", values="freq")
+    df_size.index.name = "min entity / max predicate"
+    df_size.to_csv("data/stats.data_size.csv")
+    print(df_size.to_markdown())
+
+    # plot predicate distribution
+    df_p = pd.DataFrame([dict(enumerate(sorted(p.values(), reverse=True))) for p in p_dist_full]).T
+    df_p.columns = [f"min entity: {mef}, max predicate: {mpf}" for mef, mpf in candidates]
+    _df_p = df_p[[f"min entity: {mef}, max predicate: 100" for mef in [1, 2, 3, 4]]]
+    _df_p.columns = [f"min entity: {mef}" for mef in [1, 2, 3, 4]]
+    ax = sns.lineplot(data=_df_p, linewidth=2.5)
+    ax.set(xlabel='unique predicates sorted by frequency', ylabel='number of triples', title='Predicate Distribution (max predicate: 100)')
+    ax.get_figure().savefig("data/stats.predicate_distribution.png", bbox_inches='tight')
+    ax.get_figure().clf()
+
+    # plot entity distribution
+    df_e = pd.DataFrame([dict(enumerate(sorted(e.values(), reverse=True))) for e in e_dist_full]).T
+    df_e.columns = [f"min entity: {mef}, max predicate: {mpf}" for mef, mpf in candidates]
+
+    fig, axes = plt.subplots(2, 2, constrained_layout=True)
+    fig.suptitle('Entity Distribution over Different Configurations')
+    for (x, y), mpf in zip([(0, 0), (0, 1), (1, 0), (1, 1)], [100, 50, 25, 10]):
+        _df = df_e[[f"min entity: {mef}, max predicate: {mpf}" for mef in [1, 2, 3, 4]]]
+        _df.columns = [f"min entity: {mef}" for mef in [1, 2, 3, 4]]
+        ax = sns.lineplot(ax=axes[x, y], data=_df, linewidth=1.5)
+        ax.set(xscale='log')
+        if mpf != 100:
+            ax.legend_.remove()
+        axes[x, y].set_title(f'max predicate: {mpf}')
+    fig.supxlabel('unique entities sorted by frequency')
+    fig.supylabel('number of triples')
+    fig.savefig("data/stats.entity_distribution.png", bbox_inches='tight')