experiments.py

import fnmatch
import os
import time
import multiprocessing
import simplejson as json

import lcsmooth.smoothing as lc_smooth
import lcsmooth.measures as lc_measures
import lcsmooth.ranks as lc_ranks


#
#
# Methods and variables for data files
data_dir = './data'
out_dir = './pages/json'

data_groups = ['astro', 'chi_homicide', 'climate_awnd', 'climate_prcp', 'climate_tmax', 'eeg_500', 'eeg_2500',
               'eeg_10000', 'flights', 'nz_tourist', 'stock_price', 'stock_volume', 'unemployment']

filter_list = ['cutoff', 'subsample', 'tda', 'rdp', 'gaussian', 'median', 'mean', 'min', 'max', 'savitzky_golay',
               'butterworth', 'chebyshev']

measures = ['L1 norm', 'Linf norm', 'peak wasserstein', 'peak bottleneck', "pearson cc", "spearman rc",
            "delta volume", "frequency preservation"]

data_sets = {}


#
#
# Methods for generating metric data
def load_json(filename):
    with open(filename) as json_file:
        return json.load(json_file)


def load_dataset(ds, df):
    return load_json(data_dir + "/" + ds + "/" + df + ".json")


def valid_dataset(datasets, ds, df):
    return ds in data_groups and df in datasets[ds]


def process_smoothing(input_signal, filter_name, filter_level):

    start = time.time()
    if filter_name == 'mean':
        output_signal = lc_smooth.mean(input_signal, filter_level)
    elif filter_name == 'min':
        output_signal = lc_smooth.min_filter(input_signal, filter_level)
    elif filter_name == 'max':
        output_signal = lc_smooth.max_filter(input_signal, filter_level)
    elif filter_name == 'gaussian':
        output_signal = lc_smooth.gaussian(input_signal, filter_level)
    elif filter_name == 'median':
        output_signal = lc_smooth.median(input_signal, filter_level)
    elif filter_name == 'savitzky_golay':
        output_signal = lc_smooth.savitzky_golay(input_signal, filter_level, 2)
    elif filter_name == 'cutoff':
        output_signal = lc_smooth.cutoff(input_signal, filter_level)
    elif filter_name == 'butterworth':
        output_signal = lc_smooth.butterworth(input_signal, filter_level, 2)
    elif filter_name == 'chebyshev':
        output_signal = lc_smooth.chebyshev(input_signal, filter_level, 2, 0.001)
    elif filter_name == 'subsample':
        output_signal = lc_smooth.subsample(input_signal, filter_level)
    elif filter_name == 'tda':
        output_signal = lc_smooth.tda(input_signal, filter_level)
    elif filter_name == 'rdp':
        output_signal = lc_smooth.rdp(input_signal, filter_level)
    else:
        output_signal = input_signal
    end = time.time()

    info = {"processing time": end - start,
            "filter level": filter_level,
            "filter name": filter_name}

    res_stats = lc_measures.get_stats(output_signal)
    metrics = lc_measures.get_metrics(input_signal, output_signal)

    return {'input': list(enumerate(input_signal)), 'output': list(enumerate(output_signal)), 'stats': res_stats, 'info': info,
            'metrics': metrics}


# def __generate_filter_metric_data(_input_signal, _filter_name):
#     results = []
#     process_smoothing(_input_signal, _filter_name, 0)  # warm up
#     for i in range(100):
#         res = process_smoothing(_input_signal, _filter_name, float(i + 1) / 100)
#         res.pop('input')
#         res.pop('output')
#         results.append(res)
#     return results


def __create_directory(_dir, quiet=False):
    if not os.path.exists(_dir):
        __create_directory(os.path.abspath(os.path.join(_dir, '..')))
        if not quiet:
            print("Creating directory: " + _dir)
        os.mkdir(_dir)


def generate_metric_data(_dataset, _datafile, _filter_name='all', _input_data=None, quiet=False):
    my_out_dir = out_dir + '/' + _dataset + '/' + _datafile + '/'
    __create_directory(my_out_dir)

    my_out_file = my_out_dir + _filter_name + '.json'
    if os.path.exists(my_out_file):
        return load_json( my_out_file)

    if _input_data is None:
        _input_data = load_dataset(_dataset, _datafile)

    if _filter_name == 'all':
        results = []
        for _filter in filter_list:
            res = generate_metric_data(_dataset, _datafile, _filter_name=_filter, _input_data=_input_data, quiet=quiet)
            for r in res:
                r.pop('output')
            results += res
    else:
        results = []
        process_smoothing(_input_data, _filter_name, 0)  # warm up
        for i in range(101):
            res = process_smoothing(_input_data, _filter_name, float(i) / 100)
            res.pop('input')
            results.append(res)

    if not quiet:
        print("Saving: " + my_out_file)
    with open(my_out_file, 'w') as outfile:
        # json.dump(results, outfile, indent=4, separators=(',', ': '))
        json.dump(results, outfile)

    return results


def get_all_ranks(datasets):
    res = []

    for ds in datasets:

        overall = {}
        for m in measures:
            overall[m] = dict.fromkeys(filter_list, 0)

        for df in datasets[ds]:
            print( "Ranking: " + df)
            metric_data = generate_metric_data(ds, df)

            metric_reg = {}
            for m in measures:
                metric_tmp = lc_ranks.metric_ranks(metric_data, filter_list, 'approx entropy', m)
                metric_reg[m] = metric_tmp['result']
                for f in filter_list:
                    overall[m][f] += metric_tmp['result'][f]['rank']

            res.append({'dataset': ds, 'datafile': df, 'rank': metric_reg})

        for m in measures:
            keys = list(overall[m].keys())
            keys.sort(key=(lambda a: overall[m][a]))
            for f in filter_list:
                overall[m][f] = {'rank': keys.index(f) + 1, 'r^2': 1.0}

        res.append({'dataset': ds + '_z', 'datafile': 'overall', 'rank': overall})

    res.sort(key=(lambda a: (a['dataset'] + "_" + a['datafile']).lower()))

    return res


#
# Metric data is generated when the program is loaded
def __generate_metric_dataset(_ds,_dfs):
    for _df in _dfs:
        print("Checking: " + _ds + " " + _df)
        generate_metric_data(_ds, _df)


#############################################
#############################################
#############################################
#############################################
#############################################

for group in data_groups:
    cur_ds = []
    for data_file in os.listdir(data_dir + "/" + group):
        if fnmatch.fnmatch(data_file, "*.json"):
            cur_ds.append(data_file[:-5])
    data_sets[group] = cur_ds


def run_experiments(generate_parallel=True):
    if generate_parallel:
        jobs = []

        # Create the processes
        for _ds in data_sets:
            if _ds == 'eeg_10000':
                for df in data_sets[_ds]:
                    jobs.append(multiprocessing.Process(target=__generate_metric_dataset, args=[_ds, [df]]))
            else:
                jobs.append(multiprocessing.Process(target=__generate_metric_dataset, args=[_ds, data_sets[_ds]]))

        # Start the processes
        for j in jobs:
            j.start()

        # Ensure all of the processes have finished
        for j in jobs:
            j.join()
    else:
        for _ds in data_sets:
            __generate_metric_dataset(_ds)


if __name__ == "__main__":
    run_experiments()