def _calc_metrics_draw_figure(name, data, changepoints, tolerance_delay, retrospective):
    # Calculation of AUC
    print(name)
    _retrospective = deepcopy(retrospective)
    scores = _retrospective.calc_scores(data)
    AUC = calc_AUC(scores, changepoints, tolerance_delay, both=True)
    print("AUC: ", AUC)

    # Draw a figure
    output_path = "./figs/"
    os.makedirs(output_path, exist_ok=True)
    fontsize = 18
    plt.clf()
    fig, axes = plt.subplots(nrows=2, ncols=1, figsize=(20, 10))

    axes[0].plot(data, label="Raw Data")
    axes[0].set_ylabel('Value', fontsize=fontsize)
    axes[0].set_ylim(np.nanmin(data) - 5, np.nanmax(data) + 5)
    axes[0].legend(loc='upper left', fontsize=fontsize)

    axes[1].plot(scores, label=name, color="blue")
    axes[1].set_ylabel('Score', fontsize=fontsize)
    axes[1].legend(loc='upper left', fontsize=fontsize)
    axes[1].set_ylim(np.nanmin(scores), np.nanmax(scores))

    plt.subplots_adjust(left=0.1, right=0.95, bottom=0.1, top=0.95)
    fig.savefig(output_path + name + ".png")
def _objective_FW2S_MDL(trial, train, changepoints, tolerance_delay,
                        params):  # FW2S_MDL
    nml_gaussian = partial(sdmdl_nml.nml_gaussian,
                           mu_max=params["mu_max"],
                           div_min=params["div_min"],
                           div_max=params["div_max"])
    complexity_gaussian = partial(sdmdl_nml.complexity_gaussian,
                                  mu_max=params["mu_max"],
                                  div_min=params["div_min"],
                                  div_max=params["div_max"])
    window_size_1 = trial.suggest_int('window_size_1', 10, 500)
    window_size_2 = trial.suggest_int('window_size_2', 10, 500)

    retrospective_first = sdmdl.Retrospective(
        h=window_size_1,
        encoding_func=nml_gaussian,
        complexity_func=complexity_gaussian,
        order=0)
    retrospective_second = sdmdl.Retrospective(
        h=window_size_2,
        encoding_func=nml_gaussian,
        complexity_func=complexity_gaussian,
        order=0)
    retrospective = fw2s_mdl.Retrospective(retrospective_first,
                                           retrospective_second)
    scores = retrospective.calc_scores(train)

    AUC = calc_AUC(scores, changepoints, tolerance_delay)
    return -AUC
def _objective_CF(trial, train, changepoints, tolerance_delay):  # CF
    # hyperparameters
    r = trial.suggest_uniform('r', 0.01, 0.99)
    order = trial.suggest_int('order', 1, 20)
    smooth = trial.suggest_int('smooth', 3, 20)

    retrospective = changefinder.Retrospective(r=r, order=order, smooth=smooth)
    scores = retrospective.calc_scores(train)
    AUC = calc_AUC(scores, changepoints, tolerance_delay)
    return -AUC
def _objective_BOCPD(trial, train, changepoints, tolerance_delay):  # BOCPD
    lam = trial.suggest_int('lam', 2, 1000)
    alpha = trial.suggest_uniform('alpha', 0.01, 10)
    beta = trial.suggest_uniform('beta', 0.01, 10)
    kappa = trial.suggest_uniform('kappa', 0.01, 10)
    mu = trial.suggest_uniform('mu', 0.01, 10)

    h = partial(bocpd.constant_hazard, lam)
    lik = bocpd.StudentT(alpha, beta, kappa, mu)
    retrospective = bocpd.Retrospective(hazard_func=h, likelihood_func=lik)

    scores = retrospective.calc_scores(train)
    AUC = calc_AUC(scores, changepoints, tolerance_delay)

    return -AUC
Пример #5
0
def _objective_SDMDL(trial, train, changepoints, tolerance_delay, params):
    nml_gaussian = partial(sdmdl_nml.nml_gaussian, mu_max=params[
                           "mu_max"], div_min=params["div_min"], div_max=params["div_max"])
    complexity_gaussian = partial(sdmdl_nml.complexity_gaussian, mu_max=params[
                                  "mu_max"], div_min=params["div_min"], div_max=params["div_max"])
    window_size = trial.suggest_int('window_size', 5, 60)
    retrospective = sdmdl.Retrospective(h=window_size, encoding_func=nml_gaussian,
                                        complexity_func=complexity_gaussian, order=params["order"])

    scores = retrospective.calc_scores(train)
    n = len(scores)
    scores[2 * window_size - 1: n] = scores[window_size - 1: n - window_size]
    scores[0:2 * window_size] = np.nan

    AUC = calc_AUC(scores, changepoints,  tolerance_delay, both=both)
    return -AUC
Пример #6
0
def _objective_CF(trial, train, changepoints, tolerance_delay):
    # hyperparameters
    r = trial.suggest_uniform('r', 0.01, 0.99)
    order = trial.suggest_int('order', 1, 20)
    smooth = trial.suggest_int('smooth', 3, 20)

    retrospective = changefinder.Retrospective(r=r, order=order, smooth=smooth)

    scores = np.zeros((8, 26450))

    for i in range(8):
        scores[i] = retrospective.calc_scores(train[i])

    scores = np.nanmax(scores, axis=0)

    AUC = calc_AUC(scores, changepoints, tolerance_delay, both=both)
    return -AUC
Пример #7
0
def _objective_FW2S_MDL(trial, train, changepoints, tolerance_delay, params):
    nml_multgaussian = partial(sdmdl_nml.nml_multgaussian,
                               R=params["R"],
                               lambda_min=params["lambda_min"])
    complexity_multgaussian = partial(sdmdl_nml.complexity_multgaussian,
                                      m=8,
                                      R=params["R"],
                                      lambda_min=params["lambda_min"])

    nml_gaussian = partial(sdmdl_nml.nml_gaussian,
                           mu_max=params["mu_max"],
                           div_min=params["div_min"],
                           div_max=params["div_max"])
    complexity_gaussian = partial(sdmdl_nml.complexity_gaussian,
                                  mu_max=params["mu_max"],
                                  div_min=params["div_min"],
                                  div_max=params["div_max"])
    delta_0 = trial.suggest_uniform('delta_0', 0.001, 0.499)
    window_size_1 = trial.suggest_int('window_size_1', 100, 300)
    window_size_2 = trial.suggest_int('window_size_2', 100, 300)

    retrospective_first = sdmdl.Retrospective(
        h=window_size_1,
        encoding_func=nml_multgaussian,
        complexity_func=complexity_multgaussian,
        delta_0=delta_0,
        order=0)
    retrospective_second = sdmdl.Retrospective(
        h=window_size_2,
        encoding_func=nml_gaussian,
        complexity_func=complexity_gaussian,
        order=0)
    retrospective = fw2s_mdl.Retrospective(retrospective_first,
                                           retrospective_second)
    scores = retrospective.calc_scores(train)

    n = len(scores)
    scores[2 * (window_size_1 +
                window_size_2):n] = scores[window_size_1 + window_size_2:n -
                                           (window_size_1 + window_size_2)]
    scores[0:2 * (window_size_1 + window_size_2)] = np.nan

    AUC = calc_AUC(scores, changepoints, tolerance_delay, both=both)
    return -AUC
def _objective_SDMDL(trial, train, changepoints, tolerance_delay,
                     params):  # S-MDL
    nml_gaussian = partial(sdmdl_nml.nml_gaussian,
                           mu_max=params["mu_max"],
                           div_min=params["div_min"],
                           div_max=params["div_max"])
    complexity_gaussian = partial(sdmdl_nml.complexity_gaussian,
                                  mu_max=params["mu_max"],
                                  div_min=params["div_min"],
                                  div_max=params["div_max"])
    window_size = trial.suggest_int('window_size', 10, 500)
    retrospective = sdmdl.Retrospective(h=window_size,
                                        encoding_func=nml_gaussian,
                                        complexity_func=complexity_gaussian,
                                        order=params["order"])

    scores = retrospective.calc_scores(train)

    AUC = calc_AUC(scores, changepoints, tolerance_delay)
    return -AUC
Пример #9
0
def _objective_BOCPD(trial, train, changepoints, tolerance_delay):
    lam = trial.suggest_int('lam', 100, 1000)
    alpha = trial.suggest_uniform('alpha', 1e-8, 10)
    beta = trial.suggest_uniform('beta', 1e-8, 0.01)
    kappa = trial.suggest_uniform('kappa', 1e-8, 0.01)
    mu = 0
    #mu = trial.suggest_uniform('mu', -1, 1)

    h = partial(bocpd.constant_hazard, lam)
    lik = bocpd.StudentT(alpha, beta, kappa, mu)

    retrospective = bocpd.Retrospective(hazard_func=h, likelihood_func=lik)

    scores = np.zeros((8, 26450))

    for i in range(8):
        scores[i] = retrospective.calc_scores(train[i])

    scores = np.nanmax(scores, axis=0)

    AUC = calc_AUC(scores, changepoints, tolerance_delay, both=both)

    return -AUC
Пример #10
0
n = len(fw2s_mdl_scores)
fw2s_mdl_scores[2 *
                (opt_window_size_1 +
                 opt_window_size_2):n] = fw2s_mdl_scores[opt_window_size_1 +
                                                         opt_window_size_2:n -
                                                         (opt_window_size_1 +
                                                          opt_window_size_2)]
fw2s_mdl_scores[0:2 * (opt_window_size_1 + opt_window_size_2)] = np.nan

sdmdl_0_scores[np.isnan(sdmdl_0_scores)] = np.nanmin(sdmdl_0_scores)
sdmdl_1_scores[np.isnan(sdmdl_1_scores)] = np.nanmin(sdmdl_1_scores)
sdmdl_2_scores[np.isnan(sdmdl_2_scores)] = np.nanmin(sdmdl_2_scores)
fw2s_mdl_scores[np.isnan(fw2s_mdl_scores)] = np.nanmin(fw2s_mdl_scores)

print("SDMDL 0th: ",
      calc_AUC(sdmdl_0_scores, changepoints, tolerance_delay, both=both))
print("SDMDL 1st: ",
      calc_AUC(sdmdl_1_scores, changepoints, tolerance_delay, both=both))
print("SDMDL 2nd: ",
      calc_AUC(sdmdl_2_scores, changepoints, tolerance_delay, both=both))
print("FW2S-MDL: ",
      calc_AUC(fw2s_mdl_scores, changepoints, tolerance_delay, both=both))
print("ChangeFinder: ",
      calc_AUC(cf_scores, changepoints, tolerance_delay, both=both))
print("BOCPD: ",
      calc_AUC(bocpd_scores, changepoints, tolerance_delay, both=both))

df_result = pd.DataFrame()
row = pd.DataFrame({
    "method: ": ["SDMDL 0th"],
    "AUC: ":
def _calc_metrics(idx_data, dataset, changepoints, tolerance_delay,
                  retrospective):
    _retrospective = deepcopy(retrospective)
    scores = _retrospective.calc_scores(dataset[idx_data])
    AUC = calc_AUC(scores, changepoints, tolerance_delay)
    return AUC
Пример #12
0
                                           complexity_func=complexity_gaussian, order=0)
retrospective = fw2s_mdl.Retrospective(
    retrospective_first, retrospective_second)

fw2s_mdl_scores = retrospective.calc_scores(np.array(df['Rate']))
n = len(fw2s_mdl_scores)
fw2s_mdl_scores[2 * (opt_window_size_1 + opt_window_size_2): n] = fw2s_mdl_scores[opt_window_size_1 +
                                                                                  opt_window_size_2: n - (opt_window_size_1 + opt_window_size_2)]
fw2s_mdl_scores[0:2 * (opt_window_size_1 + opt_window_size_2)] = np.nan

sdmdl_0_scores[np.isnan(sdmdl_0_scores)] = np.nanmin(sdmdl_0_scores)
sdmdl_1_scores[np.isnan(sdmdl_1_scores)] = np.nanmin(sdmdl_1_scores)
sdmdl_2_scores[np.isnan(sdmdl_2_scores)] = np.nanmin(sdmdl_2_scores)
fw2s_mdl_scores[np.isnan(fw2s_mdl_scores)] = np.nanmin(fw2s_mdl_scores)

print("SDMDL 0th: ", calc_AUC(sdmdl_0_scores,
                              changepoints,  tolerance_delay, both=both))
print("SDMDL 1st: ", calc_AUC(sdmdl_1_scores,
                              changepoints,  tolerance_delay, both=both))
print("SDMDL 2nd: ", calc_AUC(sdmdl_2_scores,
                              changepoints,  tolerance_delay, both=both))
print("FW2S-MDL: ", calc_AUC(fw2s_mdl_scores,
                             changepoints,  tolerance_delay, both=both))
print("ChangeFinder: ", calc_AUC(
    cf_scores, changepoints,  tolerance_delay, both=both))
print("BOCPD: ", calc_AUC(bocpd_scores, changepoints,  tolerance_delay, both=both))

df_result = pd.DataFrame()
row = pd.DataFrame({"method: ": ["SDMDL 0th"], "AUC: ": calc_AUC(
    sdmdl_0_scores, changepoints,  tolerance_delay, both=both)})
df_result = pd.concat([df_result, row], axis=0)
row = pd.DataFrame({"method: ": ["SDMDL 1st"], "AUC: ": calc_AUC(