def highWinds():
    df = pp.getEdayData()
    all = len(df)
    high_wind = len(df[df["Wind Mean (M/S)"] > 25])
    print("All data points", all)
    print("Data points with wind over 25 m/s", high_wind)
    print("Which is {:.2f}%".format(high_wind / all * 100))
def calculatePowerCurve():
    df = pp.getEdayData()
    df_full = pp.getSingleDataframe(fromPickle=True)

    start = datetime.strptime("2018-12-01", '%Y-%m-%d')
    stop = datetime.strptime("2019-01-01", '%Y-%m-%d')

    df = df[["Wind Mean (M/S)",
             "Power Mean (Kw)"]].round().groupby("Wind Mean (M/S)").mean()

    for r in df.values:
        print(r[0])
Exemple #3
0
def buildEdayWindOrkneyGenScatter(start_limit=0,
                                  stop_limit=0,
                                  zones=0,
                                  save_to_pdf=False,
                                  filename="eday-scatter",
                                  curtail_code=0,
                                  color="k",
                                  wind_limit=40):
    if start_limit != 0:
        start_limit = datetime.strptime(start_limit, '%Y-%m-%d')
    if stop_limit != 0: stop_limit = datetime.strptime(stop_limit, '%Y-%m-%d')

    df = pp.getEdayData()
    df_full = pp.getSingleDataframe(fromPickle=True, clean=True)
    df = df_full.join(df, how="inner")
    df = df[df["Wind Mean (M/S)"] < wind_limit]
    if curtail_code == 1: df = df[df["Zone 1"] == 1]
    elif curtail_code == 2: df = df[df["Zone 1"] == 0]
    elif curtail_code == 3: df = df[df["Curtailment"] == 1]
    elif curtail_code == 4: df = df[df["Curtailment"] == 0]

    full_mean = df[["Wind Mean (M/S)", "Generation"
                    ]].round().groupby("Wind Mean (M/S)").median().values[:, 0]
    powercurve = interp1d(range(0, len(full_mean)),
                          full_mean,
                          fill_value="extrapolate")
    r2 = r2_score(df[["Generation"]],
                  df[["Wind Mean (M/S)"]].apply(powercurve))

    print(full_mean)
    print("R^2 score:", r2)

    plt.scatter(df["Wind Mean (M/S)"],
                df["Generation"],
                c=color,
                alpha=0.5,
                s=2,
                marker="x")
    plt.plot(full_mean, "bx-", markersize=4, linewidth=1)
    plt.xlabel("Wind Speed from ERE Turbine (M/S)")
    plt.xlim(0, 40)
    plt.xticks([0, 5, 10, 15, 20, 25, 30, 35, 40])
    plt.ylim(0, 40)
    plt.ylabel("Power Generated in Orkney (MW)")
    plt.legend(["Estimated Power Curve", "Data"])
    fig = plt.gcf()
    fig.set_size_inches(3.9, 3.2)
    fig.tight_layout()
    #plt.title("Relation between windspeeds and generation for Eday 900kW Turbine")
    if save_to_pdf: fig.savefig("./plots/" + filename + ".pdf")
    else: plt.show()
    plt.clf()
Exemple #4
0
def makeDescriptiveDataset(start, stop, clean=True, eday=False):
    df = pp.getSingleDataframe(start, stop, fromPickle=True)
    if eday:
        df_eday = pp.getEdayData()
        df = df.join(df_eday, how="inner")
    df = pp.addReducedCol(df)
    df.dropna(inplace=True)  # Remove NaN entries.

    if clean:
        print("Cleaning data...")
        df = pp.cleanData(df)
        df = pp.addReducedCol(df, clean=True)
        df = pp.removeGlitches(df)

    return df
Exemple #5
0
def buildEdayScatter(start_limit=0,
                     stop_limit=0,
                     zones=0,
                     save_to_pdf=False,
                     filename="eday-scatter",
                     curtail_code=0,
                     color="k",
                     width=4,
                     powercurve=False):
    if start_limit != 0:
        start_limit = datetime.strptime(start_limit, '%Y-%m-%d')
    if stop_limit != 0: stop_limit = datetime.strptime(stop_limit, '%Y-%m-%d')

    df = pp.getEdayData()
    df = df.loc[start_limit:stop_limit][["Wind Mean (M/S)", "Power Mean (Kw)"]]

    df_full = pp.getSingleDataframe(fromPickle=True)
    df = df_full.join(df, how="inner")
    df = pp.addReducedCol(df, clean=True)
    if curtail_code == 1: df = df[df["Zone 1"] == 1]
    elif curtail_code == 2: df = df[df["Zone 1"] == 0]
    elif curtail_code == 2: df = df[df["Curtailment"] == 1]

    eday_curve = [
        0, 0, 0.5, 4, 19, 60, 101, 160, 253, 404, 532, 687, 820, 870, 890, 900,
        900, 900, 900, 900, 900, 900, 900, 900, 900, 900
    ]

    plt.scatter(df["Wind Mean (M/S)"],
                df["Power Mean (Kw)"],
                c=color,
                alpha=0.5,
                s=2)
    if powercurve: plt.plot(eday_curve, "r-")
    plt.xlabel("Wind Speed (M/S)")
    plt.xlim(0, 40)
    plt.xticks([0, 5, 10, 15, 20, 25, 30, 35, 40])
    plt.ylabel("Power Generated (kW)")
    plt.yticks([0, 100, 200, 300, 400, 500, 600, 700, 800, 900])
    if powercurve: plt.legend(["Power curve"], loc=1)
    #plt.title("Relation between windspeeds and generation for Eday 900kW Turbine")
    fig = plt.gcf()
    fig.set_size_inches(width, width * 0.75)
    fig.tight_layout()
    if save_to_pdf: fig.savefig("./plots/eday/" + filename + ".pdf")
    else: plt.show()
    plt.clf()
def ANNCertainty(start="2019-04-01",
                 stop="2019-05-01",
                 fromPickle=False,
                 clean=True,
                 load_model=False):
    if clean: filename = "ANNCertainty"
    else: filename = "ANNCertainty-uncleaned"
    if fromPickle:
        print("Loaded", filename)
        return pickle.load(open(config.DATA_PATH + "" + filename, "rb"))
    else:
        print("Making Met-ANM dataset for certaintyPlot", filename)
        met_df = pp.getMetData(start, stop).set_index("forecast_time")
        anm_df = pp.getSingleDataframe(start,
                                       "2019-05-31",
                                       fromPickle=True,
                                       clean=clean)

        df = anm_df.join(met_df, how="inner")

        if load_model:
            ere_wtnn = m.load(filename=filename)
        else:
            df_train = pp.getEdayData()
            df_full = pp.getSingleDataframe(fromPickle=True, clean=clean)
            df_train = df_full.join(df_train, how="inner")
            ere_wtnn = m.train_and_save_simple(
                df_train[["Wind Mean (M/S)", "weekday", "hour"]].values,
                df_train[["Curtailment"]].values,
                kfold=False,
                filename=filename)

        print("Doing ERE WT-FFNN predictions...")
        df["ere_wtnn_prediction"] = [
            ere_wtnn.predict([[d[["wind_speed", "weekday",
                                  "hour"]].values]])[0][0]
            for i, d in df.iterrows()
        ]
        df["ere_wtnn_prediction_correct"] = [
            int(round(d["ere_wtnn_prediction"]) == d["Curtailment"]) * 100
            for i, d in df.iterrows()
        ]

        print(df["ere_wtnn_prediction_correct"].mean())

        pickle.dump(df, open(config.DATA_PATH + "" + filename, "wb"))
        return df
Exemple #7
0
def buildWindWindScatter(start,
                         stop,
                         filename="wind-wind-scatter",
                         save_to_pdf=False):
    df_eday = pp.getEdayData()
    df_full = pp.getSingleDataframe(start, stop, fromPickle=True)

    start = datetime.strptime(start, '%Y-%m-%d')
    stop = datetime.strptime(stop, '%Y-%m-%d')

    df_eday = df_eday.loc[start:stop]
    df_full = df_full.loc[start:stop]

    df = df_full.join(df_eday, how="inner")[["speed", "Wind Mean (M/S)"]]
    df = pp.removeGlitches(df)

    model = LinearRegression()
    model.fit(df[["speed"]], df[["Wind Mean (M/S)"]])
    preds = model.predict(df[["speed"]])

    coef = str(round(model.coef_[0][0], 3))
    bias = str(round(model.intercept_[0], 3))

    print("Coef and bias:", coef, bias)
    print("R^2 score:", r2_score(df[["Wind Mean (M/S)"]], preds))

    #Plot outputs
    plt.scatter(df[["speed"]],
                df[["Wind Mean (M/S)"]],
                color='black',
                alpha=0.5,
                s=2,
                marker="x")
    plt.plot(df[["speed"]], preds, color='blue', linewidth=1)
    plt.xlabel("Wind Speed from OpenWeatherMap")
    plt.ylabel("Wind Speed from ERE Turbine (M/S)")
    plt.xlim(0, 25)
    plt.ylim(0, 25)
    plt.legend(["$y = " + coef + "x + " + bias + "$", "Data"])
    fig = plt.gcf()
    fig.set_size_inches(3.3, 3)
    fig.tight_layout()
    #plt.title("Relation between windspeeds and generation for Eday 900kW Turbine")
    if save_to_pdf: fig.savefig("./plots/" + filename + ".pdf")
    else: plt.show()
    plt.clf()
Exemple #8
0
def plotPowerCurves():
    df = pp.getEdayData()

    start = datetime.strptime("2018-12-01", '%Y-%m-%d')
    stop = datetime.strptime("2019-01-01", '%Y-%m-%d')

    full_median = df[["Wind Mean (M/S)", "Power Mean (Kw)"
                      ]].round().groupby("Wind Mean (M/S)").median()
    december_median = df.loc[start:stop][[
        "Wind Mean (M/S)", "Power Mean (Kw)"
    ]].round({
        "Wind Mean (M/S)": 0
    }).groupby("Wind Mean (M/S)").median().values[:, 0]
    enercon_curve = [
        0.0, 0, 1, 6, 18, 42, 83, 147, 238, 340, 466, 600, 710, 790, 850, 880,
        900, 900, 900, 900, 900, 900, 900, 900, 900, 900
    ]
    eday_curve = [
        0, 0, 0.5, 4, 19, 60, 101, 160, 253, 404, 532, 687, 820, 870, 890, 900,
        900, 900, 900, 900, 900, 900, 900, 900, 900, 900
    ]

    plt.plot(enercon_curve, "s:", alpha=0.8, markersize=3)
    plt.plot(eday_curve, "x:", alpha=0.8, markersize=3)
    plt.plot(full_median, "o:", alpha=0.8, markersize=3)
    #plt.plot(full_median, "^-", alpha=0.8, markersize=3)
    plt.plot(december_median, "v:", alpha=0.8, markersize=3)
    plt.xlabel("Wind Speed (M/S)")
    plt.xlim(0, 40)
    plt.xticks([0, 5, 10, 15, 20, 25, 30, 35, 40])
    plt.ylabel("Power Generated (kW)")
    plt.yticks([0, 100, 200, 300, 400, 500, 600, 700, 800, 900])
    plt.legend(["Enercon", "ERE", "Winter 2018/19", "December 2018"], loc=8)
    fig = plt.gcf()
    fig.set_size_inches(4.9, 3)
    fig.tight_layout()
    fig.savefig('./plots/eday_power_curves.pgf')
    plt.clf()
Exemple #9
0
def buildWindsGraph(start_limit=0, stop_limit=0, zones=0):
    df = pp.getSingleDataframe(
        start_limit, stop_limit,
        fromPickle=True).resample("10min").mean().interpolate(method='linear')

    if start_limit != 0:
        start_limit = datetime.strptime(start_limit, '%Y-%m-%d')
    if stop_limit != 0: stop_limit = datetime.strptime(stop_limit, '%Y-%m-%d')

    df_eday = pp.getEdayData()
    df_eday = df_eday.loc[start_limit:stop_limit]

    fig = plt.figure()
    ax1 = fig.add_axes([0.1, 0.15, 0.85, 0.8])
    ax1.plot(df.index, df["speed"], "k-", linewidth=1, alpha=0.8)
    ax1.plot(df_eday.index,
             df_eday["Wind Mean (M/S)"],
             "b-",
             linewidth=1,
             alpha=0.8)
    ax1.set_xlabel("Time")
    ax1.set_ylabel("M/S")
    ax1.grid(b=True, which="both", axis="y")
    ax1.tick_params(axis="x", which="minor")
    ax1.grid(b=True, which="major", axis="x", linestyle="-.")
    ax1.grid(b=True, which="minor", axis="x", linestyle="--")
    ax1.legend(["OpenWeatherMap", "Eday Turbine"], loc=1)

    plt.title("Wind speed comparison")

    fig.autofmt_xdate(which="both")

    fig.set_size_inches(15, 8)
    plt.xticks(rotation=-60)

    plt.show()
    plt.clf()
Exemple #10
0
def buildModelGraph(start_limit=0,
                    stop_limit=0,
                    zones=0,
                    filename="model-comparison",
                    save_to_pdf=False):
    df_eday = pp.getEdayData()

    #Full DataSet, used for training
    try:
        df_full = pp.getSingleDataframe("2018-12-01",
                                        "2019-03-01",
                                        fromPickle=True)
    except FileNotFoundError:
        df_full = pp.getSingleDataframe("2018-12-01",
                                        "2019-03-01",
                                        fromPickle=False)
    df_full = df_full.join(df_eday, how="inner")
    df_full = pp.cleanData(df_full)
    df_full = pp.addReducedCol(df_full, clean=True)
    df_full = pp.removeGlitches(df_full)

    try:
        df = pp.getSingleDataframe(start_limit, stop_limit, fromPickle=True)
    except FileNotFoundError:
        df = pp.getSingleDataframe(start_limit, stop_limit, fromPickle=False)
    #df = df.join(df_eday, how="inner")
    df = pp.cleanData(df)
    df = pp.addReducedCol(df, clean=True)
    df = pp.removeGlitches(df)

    if start_limit != 0:
        start_limit = datetime.strptime(start_limit, '%Y-%m-%d').timestamp()
    if stop_limit != 0:
        stop_limit = datetime.strptime(stop_limit, '%Y-%m-%d').timestamp()

    # Adjust the amount of ticks to the data size
    if stop_limit - start_limit > 86400 * 8: tick_zoom = 24
    elif stop_limit - start_limit > 86400 * 4: tick_zoom = 12
    elif stop_limit - start_limit > 86400 * 2: tick_zoom = 6
    elif stop_limit - start_limit > 86400: tick_zoom = 3
    else: tick_zoom = 1

    model_names, accs = desc.evaluateDataframe(df_full, df)

    accs = accs[:, :-1]

    # Generate x ticks for the mesh plot
    meshxticks_major = []
    meshxticks_minor = []
    for i, d in enumerate(df.index):
        if d.hour == 0 and d.minute == 0: meshxticks_major.append(i)
        elif d.hour % tick_zoom == 0 and d.minute == 0:
            meshxticks_minor.append(i)

    plt.xticks(rotation=-60)

    fig = plt.figure()
    # Bottom plot
    ax1 = fig.add_axes([0.10, 0.1, 0.9, 0.44])
    delta = (df["Generation"] - df["Demand"])  #.rolling(3).mean()
    ax1.plot(df.index, delta, "k-", linewidth=1, alpha=0.8)
    plt.fill_between(df.index, delta, color="k", alpha=0.3)
    ax1.margins(x=0)
    ax1.set_ylabel("MegaWatt")
    ax1.set_ylim(-25, 25)
    ax1.set_yticks([-20, -10, 0, 10, 20])
    ax1.grid(b=True, which="both", axis="y")
    ax1.xaxis.set_major_locator(mdates.DayLocator())
    ax1.xaxis.set_minor_locator(mdates.HourLocator())
    ax1.xaxis.set_major_formatter(mdates.DateFormatter("%b %d"))
    ax1.xaxis.set_minor_formatter(mdates.DateFormatter("%H:00"))
    for i, t in enumerate(ax1.xaxis.get_minor_ticks()):
        if i % 24 == 0: t.label.set_visible(False)
        if i % tick_zoom != 0: t.set_visible(False)
    ax1.tick_params(axis="x", which="minor")
    ax1.grid(b=True, which="major", axis="x", linestyle="-.")
    ax1.grid(b=True, which="minor", axis="x", linestyle="--")
    ax1.legend(["Generation relative to Demand"], loc=1)

    # Top plot
    cm = plt.get_cmap("binary")
    ax2 = fig.add_axes([0.10, 0.56, 0.9, 0.44])
    ax2.pcolormesh(accs, alpha=1, cmap=cm, snap=True)
    ax2.set_xticks(meshxticks_major)
    ax2.set_xticks(meshxticks_minor, minor=True)
    ax2.xaxis.set_ticklabels([])
    ax2.grid(b=True, which="major", axis="x", linestyle="-.")
    ax2.grid(b=True, which="minor", axis="x", linestyle="--")
    ax2.set_yticks(np.arange(len(model_names)) + 0.5)
    ax2.set_yticks(np.arange(len(model_names)), minor=True)
    ax2.set_yticklabels(model_names, rotation=0, fontsize="8", va="center")
    ax2.grid(b=True, which="minor", axis="y")
    custom_lines = [
        Line2D([0], [0], color=cm(0), lw=4),
        Line2D([0], [0], color=cm(1.), lw=4)
    ]
    ax2.legend(custom_lines, ["No curtailment", "Curtailment"], loc=1)
    #plt.title("Generation relative to demand for all of Orkney. \nAccuracies for models: " + ", ".join(model_names))

    fig.autofmt_xdate(which="both")

    fig.set_size_inches(8, 3)

    if save_to_pdf: fig.savefig("./plots/" + filename + ".pdf")
    else: plt.show()
    plt.clf()
def calculateLoss():
    df = pp.getEdayData()
    df_full = pp.getSingleDataframe(fromPickle=True)
    df = df_full.join(df, how="inner")

    eday_powercurve_discrete = [
        0, 0, 0.5, 4, 19, 60, 101, 160, 253, 404, 532, 687, 820, 870, 890, 900,
        900, 900, 900, 900, 900, 900, 900, 900, 900, 900, 900, 900, 900, 900,
        900, 900, 900, 900, 900, 900, 900, 900, 900, 900, 900, 900, 900, 900,
        900
    ]
    eday_powercurve = interp1d(range(0, len(eday_powercurve_discrete)),
                               eday_powercurve_discrete)

    start = datetime.strptime("2018-12-01", '%Y-%m-%d')
    stop = datetime.strptime("2019-01-01", '%Y-%m-%d')
    december_median = df.loc[start:stop][[
        "Wind Mean (M/S)", "Power Mean (Kw)"
    ]].round({
        "Wind Mean (M/S)": 0
    }).groupby("Wind Mean (M/S)").median().values[:, 0]
    december_powercurve = interp1d(range(0, len(december_median)),
                                   december_median,
                                   bounds_error=False,
                                   fill_value=0)

    power_sum = 0  #716131
    for r in df["Power Mean (Kw)"].values:
        power_sum += r * (1 / 6)
    print("Power Output: {:.2f} kWh".format(power_sum))

    expected_power_sum = 0
    for r in df["Wind Mean (M/S)"].values:
        expected_power_sum += eday_powercurve(r) * (1 / 6)
    print("Expected Power Output: {:.2f} kWh".format(expected_power_sum))

    loss = expected_power_sum - power_sum
    print("Loss: {:.2f} kWh ({:.2f}%)".format(loss,
                                              loss / expected_power_sum * 100))

    expected_power_sum = 0
    for r in df["Wind Mean (M/S)"].values:
        expected_power_sum += december_powercurve(r) * (1 / 6)
    print("Expected Power Output (new curve): {:.2f} kWh".format(
        expected_power_sum))

    loss = expected_power_sum - power_sum
    print("Loss (new curve): {:.2f} kWh ({:.2f}%)".format(
        loss, loss / expected_power_sum * 100))

    eday_expected_power_sum = 0
    for r in df["Wind Mean (M/S)"].values:
        eday_expected_power_sum += eday_powercurve(ceil(r)) * (1 / 6)
    print("Expected Power Output (eday method): {:.2f} kWh".format(
        eday_expected_power_sum))

    eday_loss = eday_expected_power_sum - power_sum
    print("Loss (eday method): {:.2f} kWh ({:.2f}%)".format(
        eday_loss, eday_loss / eday_expected_power_sum * 100))

    print()
    print("------ Excluding measurements with no curtailment in Zone 1")
    df = df[df["Zone 1"] == 1]

    cur_power_sum = 0  #716131
    for r in df["Power Mean (Kw)"].values:
        cur_power_sum += r * (1 / 6)
    print("Power Output: {:.2f} kWh".format(cur_power_sum))

    cur_expected_power_sum = 0
    for r in df["Wind Mean (M/S)"].values:
        cur_expected_power_sum += eday_powercurve(ceil(r)) * (1 / 6)
    print("Expected Power Output (eday method): {:.2f} kWh".format(
        cur_expected_power_sum))

    cur_loss = cur_expected_power_sum - cur_power_sum
    print("Loss (eday method): {:.2f} kWh ({:.2f}% locally, {:.2f}% of total)".
          format(cur_loss, cur_loss / cur_expected_power_sum * 100,
                 cur_loss / eday_expected_power_sum * 100))

    print()

    print("Difference in loss: {:.2f} / {:.2f} = {:.2f}%".format(
        cur_loss, eday_loss, cur_loss / eday_loss * 100))
def evaluateMetForecast(start="2019-04-01",
                        stop="2019-05-01",
                        name="met-full-frame",
                        code=0,
                        load_partial=False,
                        load_full=False):
    if load_full:
        if load_partial:
            print("Making Met-ANM dataset")
            met_df = pp.getMetData(start, stop).set_index("forecast_time")
            anm_df = pp.getSingleDataframe(start,
                                           "2019-05-31",
                                           fromPickle=True,
                                           clean=True)

            df = anm_df.join(met_df, how="inner")

            df["prediction"] = [
                int(
                    desc.correlationModelKCurve(d["wind_speed"],
                                                i.weekday() + 1, i.hour + 1,
                                                6)) for i, d in df.iterrows()
            ]
            df["prediction_correct"] = [
                int(d["prediction"] == d["Curtailment"]) * 100
                for i, d in df.iterrows()
            ]
            df["ere_prediction"] = [
                int(
                    desc.correlationModelKCurveEday(d["wind_speed"],
                                                    i.weekday() + 1,
                                                    i.hour + 1, 6))
                for i, d in df.iterrows()
            ]
            df["ere_prediction_correct"] = [
                int(d["ere_prediction"] == d["Curtailment"]) * 100
                for i, d in df.iterrows()
            ]
            df["speed_delta"] = [
                d["wind_speed"] - d["speed"] for i, d in df.iterrows()
            ]
        else:
            df = pickle.load(open(config.DATA_PATH + "" + name, "rb"))

        df_train = pp.getEdayData()
        df_full = pp.getSingleDataframe(fromPickle=True, clean=True)
        df_train = df_full.join(df_train, how="inner")

        if code == 1 or code == 0:
            percep = m.train_and_save_perceptron(
                df_train[["speed", "weekday", "hour"]].values,
                df_train[["Curtailment"]].values,
                kfold=False,
                filename="WT-Percep-" + name)
            print("Doing WT-Percep predictions...")
            df["percep_prediction"] = [
                percep.predict([[d[["wind_speed", "weekday",
                                    "hour"]].values]])[0][0]
                for i, d in df.iterrows()
            ]
            df["percep_prediction_correct"] = [
                int(round(d["percep_prediction"]) == ceil(d["Curtailment"])) *
                100 for i, d in df.iterrows()
            ]

            print("Clearing Keras session")
            del percep
            clear_session()

        if code == 2 or code == 0:
            wtnn = m.train_and_save_simple(
                df_train[["speed", "weekday", "hour"]].values,
                df_train[["Curtailment"]].values,
                kfold=False,
                filename="WT-FFNN-" + name)
            print("Doing WT-FFNN predictions...")
            df["wtnn_prediction"] = [
                wtnn.predict([[d[["wind_speed", "weekday",
                                  "hour"]].values]])[0][0]
                for i, d in df.iterrows()
            ]
            df["wtnn_prediction_correct"] = [
                int(round(d["wtnn_prediction"]) == ceil(d["Curtailment"])) *
                100 for i, d in df.iterrows()
            ]

            print("Clearing Keras session")
            del wtnn
            clear_session()

        if code == 3 or code == 0:
            ere_percep = m.train_and_save_perceptron(
                df_train[["Wind Mean (M/S)", "weekday", "hour"]].values,
                df_train[["Curtailment"]].values,
                kfold=False,
                filename="WT-Percep-ERE-" + name)
            print("Doing ERE WT-Percep predictions...")
            df["ere_percep_prediction"] = [
                ere_percep.predict(
                    [[d[["wind_speed", "weekday", "hour"]].values]])[0][0]
                for i, d in df.iterrows()
            ]
            df["ere_percep_prediction_correct"] = [
                int(
                    round(d["ere_percep_prediction"]) == ceil(
                        d["Curtailment"])) * 100 for i, d in df.iterrows()
            ]

            print("Clearing Keras session")
            del ere_percep
            clear_session()

        if code == 4 or code == 0:
            ere_wtnn = m.train_and_save_simple(
                df_train[["Wind Mean (M/S)", "weekday", "hour"]].values,
                df_train[["Curtailment"]].values,
                kfold=False,
                filename="WT-FFNN-ERE-" + name)
            print("Doing ERE WT-FFNN predictions...")
            df["ere_wtnn_prediction"] = [
                ere_wtnn.predict(
                    [[d[["wind_speed", "weekday", "hour"]].values]])[0][0]
                for i, d in df.iterrows()
            ]
            df["ere_wtnn_prediction_correct"] = [
                int(round(d["ere_wtnn_prediction"]) == ceil(d["Curtailment"]))
                * 100 for i, d in df.iterrows()
            ]

            print("Clearing Keras session")
            del ere_wtnn
            clear_session()

        pickle.dump(df, open(config.DATA_PATH + "" + name, "wb"))

    else:
        print("Loading full met frame from", config.DATA_PATH + "" + name)
        df = pickle.load(open(config.DATA_PATH + "" + name, "rb"))

    hours = df.groupby("hours_forecast")

    accs = []
    accs.append(hours["prediction_correct"].describe())
    accs.append(hours["ere_prediction_correct"].describe())
    accs.append(hours["percep_prediction_correct"].describe())
    accs.append(hours["ere_percep_prediction_correct"].describe())
    accs.append(hours["wtnn_prediction_correct"].describe())
    accs.append(hours["ere_wtnn_prediction_correct"].describe())

    names = [
        "$WT_6$", "$WT_6$ - ERE power curve", "WT-Percep",
        "WT-Percep - ERE wind data", "WT-FFNN", "WT-FFNN - ERE wind data"
    ]

    pickle.dump(accs, open(config.DATA_PATH + "" + name + "-describes", "wb"))
    pickle.dump(names,
                open(config.DATA_PATH + "" + name + "-describes-name", "wb"))

    return accs, names