filtering_purify.py

"""
TODO: save the data with different config
TODO: get stats for the frequency based selection
"""
import json
from itertools import product
from random import shuffle, seed

import numpy as np
import pandas as pd
import seaborn as sns
from matplotlib import pyplot as plt

from datasets import Dataset

parameters_min_e_freq = [4, 8, 12, 16]
parameters_max_p_freq = [100, 50, 25, 10]
assert len(parameters_min_e_freq) == 4
assert len(parameters_max_p_freq) == 4
sns.set_theme(style="whitegrid")

# load filtered data
with open(f"data/t_rex.filter_unified.jsonl") as f:
    data = Dataset.from_list([json.loads(i) for i in f.read().split('\n') if len(i) > 0])
    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 create_split(_data):
    tmp_df = pd.DataFrame(_data)
    predicates_count = tmp_df.groupby("predicate")['text'].count().sort_values(ascending=False).to_dict()
    total_num = sum(predicates_count.values())
    pre_k = list(predicates_count.keys())
    seed(42)
    shuffle(pre_k)
    predicates_train = []
    for k in pre_k:
        predicates_train.append(k)
        if sum([predicates_count[i] for i in predicates_train]) > total_num * 0.8:
            break
    predicates_test = sorted([i for i in pre_k if i not in predicates_train])
    test_data = [i for i in _data if i['predicate'] in predicates_test]
    train_data = [i for i in _data if i['predicate'] in predicates_train]
    shuffle(train_data)
    validation_data = train_data[:int(len(train_data) * 0.1)]
    train_data = train_data[int(len(train_data) * 0.1):]
    return train_data, validation_data, test_data


def main(min_entity_freq, max_pairs_predicate, min_pairs_predicate: int = 3, 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])

    df_balanced.pop("count_subject")
    df_balanced.pop("count_object")
    df_balanced.pop("count_sum")
    target_data = [i.to_dict() for _, i in df_balanced.iterrows()]

    # 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), target_data


if __name__ == '__main__':
    p_dist_full = []
    e_dist_full = []
    data_size_full = []
    config = []
    candidates = list(product(parameters_min_e_freq, parameters_max_p_freq))

    # run filtering with different configs
    for min_e_freq, max_p_freq in candidates:
        p_dist, e_dist, data_size, new_data = main(
            min_entity_freq=min_e_freq, max_pairs_predicate=max_p_freq, random_sampling=False)
        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])
        # save data
        train, validation, test = create_split(new_data)
        with open(f"data/t_rex.filter_unified.min_entity_{min_e_freq}_max_predicate_{max_p_freq}.train.jsonl", 'w') as f:
            f.write('\n'.join([json.dumps(i) for i in train]))
        with open(f"data/t_rex.filter_unified.min_entity_{min_e_freq}_max_predicate_{max_p_freq}.validation.jsonl", 'w') as f:
            f.write('\n'.join([json.dumps(i) for i in validation]))
        with open(f"data/t_rex.filter_unified.min_entity_{min_e_freq}_max_predicate_{max_p_freq}.test.jsonl", 'w') as f:
            f.write('\n'.join([json.dumps(i) for i in test]))

    # 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())
    df_size_p = pd.DataFrame(
        [{"min entity": mef, "max predicate": mpf, "freq": len(x)} for x, (mef, mpf) in zip(p_dist_full, candidates)])
    df_size_p = df_size_p.pivot(index="max predicate", columns="min entity", values="freq")
    df_size_p = df_size_p.loc[10]
    df_size_p.to_csv("data/stats.predicate_size.csv")
    print(df_size_p.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]
    fig, axes = plt.subplots(2, 2, constrained_layout=True)
    fig.suptitle('Predicate Distribution over Different Configurations')
    for (x, y), mpf in zip([(0, 0), (0, 1), (1, 0), (1, 1)], parameters_max_p_freq):
        _df = df_p[[f"min entity: {mef}, max predicate: {mpf}" for mef in parameters_min_e_freq]]
        _df.columns = [f"min entity: {mef}" for mef in parameters_min_e_freq]
        ax = sns.lineplot(ax=axes[x, y], data=_df, linewidth=1)
        if mpf != 100:
            ax.legend_.remove()
        axes[x, y].set_title(f'max predicate: {mpf}')
    fig.supxlabel('unique predicates sorted by frequency')
    fig.supylabel('number of triples')
    fig.savefig("data/stats.predicate_distribution.png", bbox_inches='tight')
    fig.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)], parameters_max_p_freq):
        _df = df_e[[f"min entity: {mef}, max predicate: {mpf}" for mef in parameters_min_e_freq]]
        _df.columns = [f"min entity: {mef}" for mef in parameters_min_e_freq]
        ax = sns.lineplot(ax=axes[x, y], data=_df, linewidth=1)
        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')
    fig.clf()