def run_sequential(dir_model, metric, preprocess_args):
    for dt_start, dt_end in utils.iter_dt_range():
        print_cps(dt_start, dt_end, dir_model, metric, preprocess_args)
        unsupervised_utils.print_cps_per_name(dt_start, dt_end, metric,
                                              "cps_per_mac.csv")
        unsupervised_utils.print_cps_per_path(dt_start, dt_end, metric,
                                              "cps_per_mac.csv")
def run_parallel(metric, eps_hours, min_fraction_of_clients):
    dt_ranges = list(utils.iter_dt_range())
    f_localize_events = functools.partial(
        localize_events,
        metric=metric,
        eps_hours=eps_hours,
        min_fraction_of_clients=min_fraction_of_clients)
    utils.parallel_exec(f_localize_events, dt_ranges)
def run_sequential(metric, min_seg_len, filtered, hours_tol):
    for dt_start, dt_end in utils.iter_dt_range():
        print_empty_segs(dt_start,
                         dt_end,
                         metric,
                         min_seg_len,
                         filtered,
                         plot=False)
        unsupervised_utils.print_per_name(dt_start, dt_end, metric,
                                          "empty_segs_per_mac.csv")
        unsupervised_utils.print_per_path(dt_start, dt_end, metric,
                                          "empty_segs_per_mac.csv")
Example #4
0
def run_parallel(metric, eps_hours):
    dt_ranges = list(utils.iter_dt_range())

    fp_voting = functools.partial(voting,
                                  metric=metric,
                                  in_dir="paths",
                                  eps_hours=eps_hours)
    utils.parallel_exec(fp_voting, dt_ranges)

    fp_voting = functools.partial(voting,
                                  metric=metric,
                                  in_dir="names",
                                  eps_hours=eps_hours)
    utils.parallel_exec(fp_voting, dt_ranges)
def run_parallel(dir_model, metric, preprocess_args):
    dt_ranges = list(utils.iter_dt_range())
    fp_print_cps = functools.partial(print_cps,
                                     dir_model=dir_model,
                                     metric=metric,
                                     preprocess_args=preprocess_args)
    utils.parallel_exec(fp_print_cps, dt_ranges)

    fp_print_per_name = functools.partial(unsupervised_utils.print_per_name,
                                          metric=metric,
                                          file_name="cps_per_mac.csv")
    utils.parallel_exec(fp_print_per_name, dt_ranges)

    fp_print_per_path = functools.partial(unsupervised_utils.print_per_path,
                                          metric=metric,
                                          file_name="cps_per_mac.csv")
    utils.parallel_exec(fp_print_per_path, dt_ranges)
def run_parallel(metric, min_seg_len, filtered):
    dt_ranges = list(utils.iter_dt_range())
    fp_print_empty_segs = functools.partial(print_empty_segs,
                                            metric=metric,
                                            min_seg_len=min_seg_len,
                                            filtered=filtered,
                                            plot=False)
    utils.parallel_exec(fp_print_empty_segs, dt_ranges)

    fp_print_per_name = functools.partial(unsupervised_utils.print_per_name,
                                          metric=metric,
                                          file_name="empty_segs_per_mac.csv")
    utils.parallel_exec(fp_print_per_name, dt_ranges)

    fp_print_per_path = functools.partial(unsupervised_utils.print_per_path,
                                          metric=metric,
                                          file_name="empty_segs_per_mac.csv")
    utils.parallel_exec(fp_print_per_path, dt_ranges)
Example #7
0
def run_sequential(metric, only_unique_traceroute):
    for dt_start, dt_end in utils.iter_dt_range():
        plot_per_node(dt_start, dt_end, metric, only_unique_traceroute)
def run_sequential(metric, eps_hours, min_fraction_of_clients):
    for dt_start, dt_end in utils.iter_dt_range():
        localize_events(dt_start, dt_end, metric, eps_hours,
                        min_fraction_of_clients)
def run_sequential(metric, preprocess_args):
    for dt_start, dt_end in utils.iter_dt_range():
        plot_per_name(dt_start, dt_end, metric, preprocess_args)
def run_parallel(metric):
    dt_ranges = list(utils.iter_dt_range())
    f_plot_per_name = functools.partial(plot_per_name,
                                        metric=metric,
                                        preprocess_args=preprocess_args)
    utils.parallel_exec(f_plot_per_name, dt_ranges)
def run_sequential():
    for dt_start, dt_end in utils.iter_dt_range():
        process_graphs(dt_start, dt_end)
def run_parallel():
    dt_ranges = list(utils.iter_dt_range())
    utils.parallel_exec(process_graphs, dt_ranges)
def run_parallel():
    mac_node = read_input.get_mac_node()
    dt_ranges = list(utils.iter_dt_range())
    f_print_all = functools.partial(print_all, mac_node=mac_node)
    utils.parallel_exec(f_print_all, dt_ranges)
def run_sequential():
    mac_node = read_input.get_mac_node()
    for dt_start, dt_end in utils.iter_dt_range():
        print_all(dt_start, dt_end, mac_node)
def run_sequential():
    for dt_start, dt_end in utils.iter_dt_range():
        create_dataset_unsupervised(dt_start, dt_end)
def run_parallel():
    dt_ranges = list(utils.iter_dt_range())
    utils.parallel_exec(create_dataset_unsupervised, dt_ranges)
Example #17
0
def run_parallel(metric, only_unique_traceroute):
    dt_ranges = list(utils.iter_dt_range())
    f_plot_per_node = \
        functools.partial(plot_per_node, metric=metric,
                          only_unique_traceroute=only_unique_traceroute)
    utils.parallel_exec(f_plot_per_node, dt_ranges)
Example #18
0
def run_sequential(metric, eps_hours):
    for dt_start, dt_end in utils.iter_dt_range():
        match_cps_different_metrics(dt_start, dt_end, eps_hours)
def run_parallel(preprocess_args):
    dt_ranges = list(utils.iter_dt_range())
    fp = functools.partial(plot_latencies_traceroute,
                           preprocess_args=preprocess_args)
    utils.parallel_exec(fp, dt_ranges)
def run_sequential(preprocess_args):
    for dt_start, dt_end in utils.iter_dt_range():
        plot_latencies_traceroute(dt_start, dt_end, preprocess_args)
Example #21
0
def run_sequential(metric, eps_hours):
    for dt_start, dt_end in utils.iter_dt_range():
        voting(dt_start, dt_end, metric, "paths", eps_hours)
        voting(dt_start, dt_end, metric, "names", eps_hours)