diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 39ded37..d3e563b 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -7,7 +7,7 @@ repos: rev: 3.9.1 hooks: - id: flake8 - args: ['--count', '--select', 'E101,E11,E111,E112,E113,E121,E122,E123,E124,E125,E126,E127,E128,E129,E131,E133,E20,E211,E231,E241,E242,E251,E252,E26,E265,E266,E27,E301,E302,E303,E304,E305,E306,E401,E402,E471,E502,E701,E711,E712,E713,E714,E722,E731,E901,E902,F822,F823,W191,W291,W292,W293,W391,W601,W602,W603,W604,W605,W690', "--ignore=E203"] + args: ['--count', '--select', 'E101,E11,E111,E112,E113,E121,E122,E123,E124,E125,E126,E127,E128,E129,E131,E133,E20,E211,E231,E241,E242,E251,E252,E26,E265,E266,E27,E301,E302,E303,E304,E305,E306,E401,E471,E502,E701,E711,E712,E713,E714,E722,E731,E901,E902,F822,F823,W191,W291,W292,W293,W391,W601,W602,W603,W604,W605,W690', "--ignore=E203"] exclude: ".*(.fits|.fts|.fit|.txt|tca.*|extern.*|.rst|.md|.svg|versioneer.py)$" - repo: https://github.com/myint/autoflake rev: v1.4 diff --git a/Forecasting/Bayesian_Forecast.py b/Forecasting/Bayesian_Forecast.py new file mode 100644 index 0000000..8923460 --- /dev/null +++ b/Forecasting/Bayesian_Forecast.py @@ -0,0 +1,139 @@ +from datetime import date, datetime + +import matplotlib.pyplot as plt +import numpy as np +from pybats.analysis import analysis +from pybats.plot import * +from pybats.point_forecast import median + + +#################################### +# Plotting Functions +#################################### +def plot_forecast( + fig, + ax, + y, + f, + samples, + dates, + linewidth=1, + linecolor="b", + credible_interval=95, + **kwargs, +): + """ + Plot observations along with sequential forecasts and credible intervals. + """ + + ax.scatter(dates, y, color="k") + ax.plot(dates, f, color=linecolor, linewidth=linewidth) + alpha = (100 - credible_interval) / 2 + upper = np.percentile(samples, [100 - alpha], axis=0).reshape(-1) + lower = np.percentile(samples, [alpha], axis=0).reshape(-1) + ax.fill_between(dates, upper, lower, alpha=0.3, color=linecolor) + + if kwargs.get("xlim") is None: + kwargs.update({"xlim": [dates[0], dates[-1]]}) + + if kwargs.get("legend") is None: + legend = ["Observations", "Forecast", "Credible Interval"] + + ax = ax_style(ax, legend=legend, **kwargs) + + # If dates are actually dates, then format the dates on the x-axis + if isinstance(dates[0], (datetime, date)): + fig.autofmt_xdate() + + return ax + + +def forecast_ax_style( + ax, + ylim=None, + xlim=None, + xlabel=None, + ylabel=None, + title=None, + legend=None, + legend_inside_plot=True, + topborder=False, + rightborder=False, + **kwargs, +): + """ + A helper function to define many elements of axis style at once. + """ + + if legend is not None: + if legend_inside_plot: + ax.legend(legend) + else: + ax.legend( + legend, + bbox_to_anchor=(1.05, 1), + loc=2, + borderaxespad=0.5, + frameon=False, + ) + # Make room for the legend + plt.subplots_adjust(right=0.85) + + if ylim is not None: + ax.set_ylim(ylim) + if xlim is not None: + ax.set_xlim(xlim) + if xlabel is not None: + ax.set_xlabel(xlabel) + if ylabel is not None: + ax.set_ylabel(ylabel) + if title is not None: + ax.set_title(title) + + # remove the top and right borders + ax.spines["top"].set_visible(topborder) + ax.spines["right"].set_visible(rightborder) + + plt.tight_layout() + + return ax + + +#################################### +# Forecasting Functions +#################################### + + +def evaluate(epex_data, horizon=6, forecast_start_index=0, forecast_end_index=-1): + prices = epex_data.values[:, 0] + datetimes = epex_data.index + horizon + + forecast_start_date = datetimes[forecast_start_index] + forecast_end_date = datetimes[forecast_end_index] + + mod, samples = analysis( + prices, + family="poisson", + dates=datetimes, + forecast_start=forecast_start_date, # First time step to forecast on + forecast_end=forecast_end_date, # Final time step to forecast on + ntrend=1, # Intercept and slope in model + nsamps=500, # Number of samples taken in the Poisson process + seasPeriods=[ + 48 + ], # Length of the seasonal variations in the data - i.e. every 24hr here + seasHarmComponents=[ + [1, 2, 3, 4, 6] + ], # Variations to pick out from the seaonal period + k=horizon, # Forecast horizon. If k>1, default is to forecast 1:k steps ahead, marginally + prior_length=48, # How many data point to use in defining prior - 48=1 day + rho=0.3, # Random effect extension, which increases the forecast variance (see Berry and West, 2019) + deltrend=0.98, # Discount factor on the trend component (the intercept) + delregn=0.98, # Discount factor on the regression component + delSeas=0.98, + ) + + forecast = median(samples) + + return datetimes, prices, samples, forecast diff --git a/Hack/rl.py b/Hack/rl.py index bc011a8..ef330c8 100644 --- a/Hack/rl.py +++ b/Hack/rl.py @@ -17,15 +17,37 @@ def get_mode(arr, bin_number=10): return np.nan -def get_expected_price(price_array, idx, window_size=2 * 24, mode="mode"): +def get_expected_price(price_array, idx, window_size=2 * 24, mode="median"): + """Gets the expected price using the history of prices. + + Currently this is a rolling window, with some kind of averaging. + + In the future we want to implement a forecasting model instead. + + Parameters + ---------- + price_array : array + All the prices in the environment + idx : int + Current idx of the environment (time) + window_size : int, optional + size of the rolling window, by default 2*24 + mode : str, optional + type of averaging to use, by default "median" + + Returns + ------- + float + Expected price at this time index + """ idx = int(idx) if idx == 0: arr = price_array[idx] elif idx < window_size: - arr = price_array[:idx] + arr = price_array[: idx + 1] else: - arr = price_array[idx - window_size : idx] + arr = price_array[idx - window_size : idx + 1] if mode == "mean": return np.mean(arr) @@ -41,9 +63,8 @@ def __init__(self, obs_price_array, start_energy=1, window_size=1000, power=1): self.action_space = gym.spaces.Discrete(3) # current_price, mean_price, current_energy, time self.observation_space = gym.spaces.Box( - low=np.array([-np.inf, -np.inf, 0, 0]), - high=np.array([np.inf, np.inf, 1, np.inf]), - dtype=np.float32, + low=np.array([-np.inf, -np.inf, 0, 0], dtype=np.float32), + high=np.array([np.inf, np.inf, 1, np.inf], dtype=np.float32), ) # our state is the charge self.start_energy = start_energy @@ -60,6 +81,7 @@ def __init__(self, obs_price_array, start_energy=1, window_size=1000, power=1): self.get_price(self.time), self.get_expected_price(self.time), start_energy, + self.time, ] ) @@ -74,39 +96,59 @@ def get_expected_price(self, idx, window_size=2 * 24, mode="median"): self.price_array, idx, window_size=window_size, mode=mode ) - def step(self, action): - current_price, mean_price, current_energy, current_time = self.state - mapped_action = env2human(action) - if mapped_action == -1: - # discharge === selling for 30 mins + def apply_action(self, human_action, current_energy): + """Applies the mapped action. + + -1 for sell + 0 for hold + 1 for buy + + Parameters + ---------- + human_action : int + Action to applly, has to be the mapped action + current_energy : float + Current energy in the battery + + """ + if human_action == -1: + # discharge === selling for 30 mins (0.5 hours) new_energy = current_energy - (self.power * 0.5) - elif mapped_action == 0: + elif human_action == 0: # hold === do nothing new_energy = current_energy - elif mapped_action == 1: - # charge === buy energy for 30 mins + elif human_action == 1: + # charge === buy energy for 30 mins (0.5 hours) new_energy = current_energy + (self.power * 0.5 * self.efficiency) - # make sure energy cannot be greater than capacity - new_energy = max(0, new_energy) - new_energy = min(self.capacity, new_energy) - # now work out the delta energy - delta_energy = new_energy - current_energy + return new_energy + def get_reward(self, delta_energy, current_price, expected_price): revenue = -delta_energy * current_price + # log this so we can plot vs time later self.earnings += revenue - expected_profit = -delta_energy * mean_price + + expected_profit = -delta_energy * expected_price opportunity_cost = revenue - expected_profit + reward = opportunity_cost + return reward - reward = opportunity_cost # profit * multiplier * price_diff_from_expected + def step(self, action): + current_price, expected_price, current_energy, current_time = self.state + human_action = env2human(action) + new_energy = self.apply_action(human_action, current_energy) - # print("Delta energy: ", delta_energy) - # print("Price diff from expected: ", price_diff_from_expected) - # print("Revenue: ", revenue) - # print("Expected Profit: ", expected_profit) - # print("Reward ", reward) + # want to save this to punish even if battery is empty/full + + # make sure energy cannot be greater than capacity + new_energy = max(0, new_energy) + new_energy = min(self.capacity, new_energy) + # now work out the delta energy + delta_energy = new_energy - current_energy + + reward = self.get_reward(delta_energy, current_price, expected_price) # increase the time current_time += 1 @@ -144,11 +186,48 @@ def reset(self): return self.state -def humans2env(action): +def human2env(action): + """Needs because Gym env would only work with 0,1,2 as states + but this is confusing as a human. + + We have: + -1 == sell == 0 in env + 0 == hold == 1 in env + 1 == buy == 2 in env + + Parameters + ---------- + action : int + Human readable action + + Returns + ------- + int + Action that the environment accepts + """ return int(action + 1) def env2human(action): + """Needs because Gym env would only work with 0,1,2 as states + but this is confusing as a human. + + We have: + -1 == sell == 0 in env + 0 == hold == 1 in env + 1 == buy == 2 in env + + Parameters + ---------- + int + Action that the environment accepts + + Returns + ------- + action : int + Human readable action + + """ return int(action - 1) @@ -177,12 +256,14 @@ def evaluate(model, new_env=None, num_episodes=100, index=None): current_energies = [] all_earnings = [0] current_times = [] + actions = [] done = False obs = env.reset() while not done: # _states are only useful when using LSTM policies action, _states = model.predict(obs) + # here, action, rewards and dones are arrays # because we are using vectorized env obs, reward, done, info = env.step(action) @@ -204,10 +285,11 @@ def evaluate(model, new_env=None, num_episodes=100, index=None): mean_prices.append(mean_price) current_energies.append(current_energy) current_times.append(current_time) + actions.append(env2human(action)) all_episode_rewards.append(sum(episode_rewards)) - fig, axs = plt.subplots(4, 1, sharex=True, figsize=(20, 15)) + fig, axs = plt.subplots(5, 1, sharex=True, figsize=(20, 15)) if index is None: index = np.arange(0, len(current_times))[:-1] else: @@ -225,6 +307,7 @@ def evaluate(model, new_env=None, num_episodes=100, index=None): # axs[2].legend() axs[3].plot(index, current_energies[:-1], color="blue", label="Current energies") + axs[4].plot(index, actions[:-1], color="blue", label="Actions") fig.autofmt_xdate() mean_episode_reward = np.mean(all_episode_rewards) std_episode_reward = np.std(all_episode_rewards) @@ -244,3 +327,19 @@ def evaluate(model, new_env=None, num_episodes=100, index=None): ) return mean_episode_reward + + +def quick_eval(idx, model): + """ + Evaluation func for the multiprocessing that we have designed to be as quick as possible! + """ + env = model.get_env() + env.reset() + done = False + total_reward = 0 + obs = env.reset() + while not done: + action, _states = model.predict(obs) + obs, reward, done, info = env.step(action) + total_reward += reward + return total_reward diff --git a/Hack/tests/__init__.py b/Hack/tests/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/Hack/tests/test_rl.py b/Hack/tests/test_rl.py new file mode 100644 index 0000000..92cef86 --- /dev/null +++ b/Hack/tests/test_rl.py @@ -0,0 +1,118 @@ +import numpy as np +import pytest +from stable_baselines3.common.env_checker import check_env + +from Hack import rl + + +@pytest.fixture +def price_array(): + return np.array([10, 20, 30, 20, 10]) + + +@pytest.fixture +def env(price_array): + return rl.energy_price_env(price_array, window_size=3, power=1) + + +@pytest.mark.parametrize("human_action, mapped_action", [(-1, 0), (0, 1), (1, 2)]) +def test_mapped_actions(human_action, mapped_action): + assert mapped_action == rl.human2env(human_action) + assert human_action == rl.env2human(mapped_action) + + +def test_get_mode(): + + # just give it lots of ones and see if it gives you one + data = np.ones(100) + + mode = rl.get_mode(data, 10) + + assert mode == pytest.approx(1, 0.2) + mode = rl.get_mode(np.array([np.nan]), 10) + assert np.isnan(mode) + + +@pytest.mark.parametrize( + "idx, expected_price", [(0, 10), (1, 15), (2, 20), (3, 20), (4, 20)] +) +def test_expected_price_median(price_array, idx, expected_price): + assert expected_price == rl.get_expected_price(price_array, idx, 3, "median") + + +def test_env(env): + # this should output a None if it passes + assert check_env(env, warn=True) is None + + +def test_sell(env): + expected_states = [ + np.array([20, 15, 0.5, 1]), + np.array([30, 20, 0, 2]), + np.array([20, 20, 0, 3]), + np.array([10, 20, 0, 4]), + ] + for i, expected_state in enumerate(expected_states): + state, reward, done, _ = env.step(rl.human2env(-1)) + assert np.allclose(state, expected_state) + if i == len(expected_states) - 1: + assert done + + +def test_buy(price_array): + env = rl.energy_price_env(price_array, start_energy=0) + expected_states = [ + np.array([20, 15, 0.425, 1]), + np.array([30, 20, 0.85, 2]), + np.array([20, 20, 1, 3]), + np.array([10, 20, 1, 4]), + ] + + for i, expected_state in enumerate(expected_states): + state, reward, done, _ = env.step(rl.human2env(1)) + assert np.allclose(state, expected_state) + if i == len(expected_states) - 1: + assert done + + +def test_hold(env): + expected_states = [ + np.array([20, 15, 1, 1]), + np.array([30, 20, 1, 2]), + np.array([20, 20, 1, 3]), + np.array([10, 20, 1, 4]), + ] + + for i, expected_state in enumerate(expected_states): + state, reward, done, _ = env.step(rl.human2env(0)) + assert np.allclose(state, expected_state) + if i == len(expected_states) - 1: + assert done + + +@pytest.mark.parametrize( + "human_action, current_energy, new_energy", + [ + (-1, 1, 0.5), + (0, 1, 1), + (1, 0, 0.425), + ], +) +def test_apply_action(env, human_action, current_energy, new_energy): + assert env.apply_action(human_action, current_energy) == new_energy + + +@pytest.mark.parametrize( + "delta_energy, current_price, expected_price, expected_reward", + [ + (1, 10, 10, 0), + (1, 20, 10, -10), + (-1, 20, 10, 10), + (1, 10, 20, 10), + (-1, 10, 20, -10), + ], +) +def test_reward(env, delta_energy, current_price, expected_price, expected_reward): + assert ( + env.get_reward(delta_energy, current_price, expected_price) == expected_reward + ) diff --git a/Notebooks/BatteryCharging/RL.ipynb b/Notebooks/BatteryCharging/RL.ipynb index ac8bc20..ea8c165 100644 --- a/Notebooks/BatteryCharging/RL.ipynb +++ b/Notebooks/BatteryCharging/RL.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -20,12 +20,31 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 11, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "13202 30770\n" + ] + } + ], "source": [ "epex = load.epex().load()\n", - "price_array = epex['apx_da_hourly'].values" + "price_array = epex['apx_da_hourly'].values\n", + "\n", + "start_of_2020 = None\n", + "start_of_2021 = None\n", + "\n", + "for idx, (i, row) in enumerate(epex.iterrows()):\n", + " if i.year > 2019 and start_of_2020 is None:\n", + " start_of_2020 = idx\n", + " if i.year > 2020 and start_of_2021 is None:\n", + " start_of_2021 = idx\n", + " break\n", + "print(start_of_2020, start_of_2021)" ] }, { @@ -68,78 +87,94 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "start_idx = 0\n", + "end_idx = 4*7*24*2 #start_of_2020 #4 * 2*24*7 #start_of_2020 # 2019->2020 # 2*24*7\n", + "obs_price_array = price_array[start_idx:end_idx]\n", + "\n", + "power = 1 # MW\n", + "env = rl.energy_price_env(obs_price_array, window_size=24*2, power=power)\n", + "model = PPO(MlpPolicy, env, verbose=0)\n", + "check_env(env, warn=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "13202 30770\n" + "[20. 15. 0.425 1. ]\n", + "0.0\n" ] } ], "source": [ - "start_of_2020 = None\n", - "start_of_2021 = None\n", - "\n", - "for idx, (i, row) in enumerate(epex.iterrows()):\n", - " if i.year > 2019 and start_of_2020 is None:\n", - " start_of_2020 = idx\n", - " if i.year > 2020 and start_of_2021 is None:\n", - " start_of_2021 = idx\n", - " break\n", - "print(start_of_2020, start_of_2021)" + "test_prices = np.array([10,20,30,20,10])\n", + "power = 1 # MW\n", + "env = rl.energy_price_env(test_prices, window_size=3, power=power,start_energy=0)\n", + "state, reward, _, _ = env.step(rl.human2env(1))\n", + "print(state)\n", + "print(reward)" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 29, "metadata": {}, "outputs": [ { - "name": "stderr", + "name": "stdout", "output_type": "stream", "text": [ - "C:\\Users\\Ronan\\Anaconda3\\envs\\ml\\lib\\site-packages\\gym\\logger.py:34: UserWarning: \u001b[33mWARN: Box bound precision lowered by casting to float32\u001b[0m\n", - " warnings.warn(colorize(\"%s: %s\" % (\"WARN\", msg % args), \"yellow\"))\n" + "[10. 20. 1. 4.]\n", + "0.0\n" ] } ], "source": [ - "start_idx = 0\n", - "end_idx = start_of_2020 #4 * 2*24*7 #start_of_2020 # 2019->2020 # 2*24*7\n", - "obs_price_array = price_array[start_idx:end_idx]\n", - "\n", - "power = 0.5\n", - "env = rl.energy_price_env(obs_price_array, window_size=24*2, power=power)\n", - "model = PPO(MlpPolicy, env, verbose=0)\n", - "check_env(env, warn=True)" + "state, reward, _, _ = env.step(rl.human2env(1))\n", + "print(state)\n", + "print(reward)" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 35, "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Mean reward: 103.08613 +/- 0.0 \t Num episodes: 1\n" - ] - }, { "data": { - "image/png": "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", "text/plain": [ - "
" + "10" ] }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "env.get_reward(1,10,20)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean reward: -0.7786865 +/- 81.399826 \t Num episodes: 10\n" + ] } ], "source": [ @@ -148,12 +183,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# Train the agent for 10000 steps\n", - "model.learn(total_timesteps=50000)\n", + "model.learn(total_timesteps=10000)\n", "#model.save(\"../model_dir/trained_model\")\n", "\n", "# load model using loaded_model = PPO.load(\"path_to_model\")" @@ -170,12 +216,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 118, + "metadata": {}, + "outputs": [], + "source": [ + "loaded_model = PPO.load(\"../../Models/train_first_month.zip\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "# Trained Agent, after training\n", - "period = 'all'\n", + "period = 'sept'\n", "# period = 'sept'\n", "\n", "if period == 'sept':\n", @@ -195,15 +250,8 @@ "test_price_array = price_array[test_start_idx:test_end_idx]\n", "\n", "new_env = DummyVecEnv([lambda: rl.energy_price_env(test_price_array, power=power)])\n", - "mean_reward_after_train = rl.evaluate(model, new_env=new_env, num_episodes=2, index=epex.index[test_start_idx:test_end_idx])" + "mean_reward_after_train = rl.evaluate(model, new_env=new_env, num_episodes=1, index=epex.index[test_start_idx:test_end_idx])" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { diff --git a/Notebooks/forecast.ipynb b/Notebooks/forecast.ipynb new file mode 100644 index 0000000..f946261 --- /dev/null +++ b/Notebooks/forecast.ipynb @@ -0,0 +1,185 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import sys # noqa: E402\n", + "sys.path.append(\"../\")\n", + "import pybats\n", + "import matplotlib.dates\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import numpy as np\n", + "from Hack import load\n", + "from Hack.rl import get_expected_price as get_ep\n", + "from pybats.loss_functions import MAPE\n", + "from pybats.analysis import analysis\n", + "from pybats.point_forecast import median\n", + "from pybats.plot import *\n", + "from datetime import datetime,date\n", + "from Forecasting import Bayesian_Forecast\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Load the data\n", + "epex = load.epex().load()\n", + "\n" + ] + }, + { + "cell_type": "code", +<<<<<<< HEAD + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "#Obtain the foreacsted samples and data \n", + "datetimes,prices,samples,forecast = Bayesian_Forecast.evaluate(epex)\n" +======= + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "beginning forecasting\n", + "MAPE: 83.06\n" + ] + } + ], + "source": [ + "forecast_start = 100\n", + "forecast_end = 1000\n", + "length=forecast_end-forecast_start\n", + "indexs=np.arange(forecast_start,forecast_end+1)\n", + "prices=epex['apx_da_hourly'].values\n", + "date_indexs = np.arange(np.size(prices))\n", + "\n", + "mod, samples = analysis(Y = prices[1:], X=date_indexs[1:], family='poisson',\n", + " forecast_start=forecast_start, \n", + " forecast_end=forecast_end, \n", + " k=1,\n", + " ntrend=1, # Intercept and slope in model\n", + " nsamps=5000, # Number of samples taken in the Poisson process\n", + " seasPeriods=[48], # Length of the seasonal variations in the data - i.e. every 24hr here\n", + " seasHarmComponents=[[1,2]], # To pick out the half dayly and daily harmonics\n", + " prior_length=48, # How many data points to use in defining prior - i.e. 48 = one day\n", + " deltrend=0.94, # Discount factor on the intercept parameter\n", + " delregn=0.90, # Discount factor on the regression parameters\n", + " delVar=0.98,\n", + " delSeas=0.98,\n", + " rho=.6, # Random effect to increase variance\n", + " )\n", + "\n", + "forecast = median(samples)\n", + "\n", + "# set confidence interval for in-sample forecast\n", + "credible_interval=66\n", + "alpha = (100-credible_interval)/2\n", + "upper=np.percentile(samples, [100-alpha], axis=0).reshape(-1)\n", + "lower=np.percentile(samples, [alpha], axis=0).reshape(-1)\n", + "print(\"MAPE:\", MAPE(prices[-18:], forecast[-18:]).round(2))" +>>>>>>> a71669078a4e519711a8dc2ded0a934941e3add2 + ] + }, + { + "cell_type": "code", +<<<<<<< HEAD + "execution_count": 57, + "metadata": {}, + "outputs": [], + "source": [ + "plot_start = 45500 #Offset from the start date at which to begin the plot\n", + "plot_length = 500\n", + "horizon = 6\n", + "\n", + "plot_start_date = datetimes[0] + pd.DateOffset(hours=(horizon + plot_start)/2.)\n", + "plot_end_date = plot_start_date + pd.DateOffset(hours=(plot_length - 1)/2.)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 59, +======= + "execution_count": 6, +>>>>>>> a71669078a4e519711a8dc2ded0a934941e3add2 + "metadata": {}, + "outputs": [ + { + "data": { +<<<<<<< HEAD + "image/png": "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", +======= + "image/png": "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", +>>>>>>> a71669078a4e519711a8dc2ded0a934941e3add2 + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ +<<<<<<< HEAD + "fig, ax = plt.subplots(figsize=(10,6))\n", + "ax = Bayesian_Forecast.plot_forecast(\n", + " fig, ax,\n", + " dates=epex.loc[plot_start_date:plot_end_date].index,\n", + " f=forecast[plot_start:plot_start+plot_length,horizon-1],\n", + " samples=samples[:,plot_start:plot_start+plot_length,horizon-1],\n", + " y=epex.loc[plot_start_date:plot_end_date].values[:,0],\n", + " linewidth = 2,\n", + " credible_interval=95)\n", +======= + "%matplotlib inline\n", + "from matplotlib import lines\n", +>>>>>>> a71669078a4e519711a8dc2ded0a934941e3add2 + "\n", + "ax = Bayesian_Forecast.forecast_ax_style(ax=ax,\n", + " ylabel='EPEX Price (£)',\n", + " xlabel='Date (MM-DD HH)',\n", + " title='3 Hour Ahead Forecast',\n", + " legend=['EPEX Price','Forecasted Price','95% Confidence Interval']\n", + " )" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "04a20cc0f25f2654a5fc5715c026c4c293afbc25926c593c301cab56769943bf" + }, + "kernelspec": { + "display_name": "Python 3.9.10 ('ml')", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.10" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Notebooks/load_data.ipynb b/Notebooks/load_data.ipynb index 10732e4..514552a 100644 --- a/Notebooks/load_data.ipynb +++ b/Notebooks/load_data.ipynb @@ -9,7 +9,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -23,16 +23,16 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "WindowsPath('C:/Users/Ronan/Projects/Hackathon')" + "WindowsPath('C:/Users/mgmf4/Documents/AI_Hack/Hackathon')" ] }, - "execution_count": 8, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } @@ -44,59 +44,34 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 3, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "C:\\Users\\Ronan\\Projects\\Hackathon\\Data\n", - "C:\\Users\\Ronan\\Projects\\Hackathon\\Data\n" - ] - } - ], + "outputs": [], "source": [ "df = load.systemprice().load()" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 4, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Data\\epex_day_ahead_price.csv\n" - ] - } - ], + "outputs": [], "source": [ "df = load.epex().load()" ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 5, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Data\\spot_intraday_price.csv\n" - ] - } - ], + "outputs": [], "source": [ "df = load.spot().load()" ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ diff --git a/multiprocessing/load_and_evaluate_model.ipynb b/Notebooks/multiprocessing/load_and_evaluate_model.ipynb similarity index 99% rename from multiprocessing/load_and_evaluate_model.ipynb rename to Notebooks/multiprocessing/load_and_evaluate_model.ipynb index c12c9e3..8b2f752 100644 --- a/multiprocessing/load_and_evaluate_model.ipynb +++ b/Notebooks/multiprocessing/load_and_evaluate_model.ipynb @@ -12,8 +12,9 @@ "from stable_baselines3.common.env_checker import check_env\n", "import gym\n", "import numpy as np\n", - "from RL import helpers\n", - "from Hack import load\n", + "import sys\n", + "sys.path.append(\"../../\")\n", + "from Hack import load, rl\n", "%matplotlib qt5" ] }, @@ -45,7 +46,7 @@ "price_array = epex['apx_da_hourly'].values\n", "max_time = 30769 \n", "max_time = 30769#2*24*28\n", - "env = helpers.energy_price_env(price_array, max_time=max_time, window_size=24*2)\n", + "env = rl.energy_price_env(price_array, max_time=max_time, window_size=24*2)\n", "model = PPO(MlpPolicy, env, verbose=1)\n", "check_env(env, warn=True)" ] @@ -64,7 +65,7 @@ } ], "source": [ - "mean_reward_before_train = helpers.evaluate(model, num_episodes=10, index = epex.index)" + "mean_reward_before_train = rl.evaluate(model, num_episodes=10, index = epex.index)" ] }, { @@ -1084,8 +1085,8 @@ "source": [ "# Trained Agent, after training\n", "periods = 48*7\n", - "new_env = DummyVecEnv([lambda: helpers.energy_price_env(price_array, start_time=max_time, max_time = periods)])\n", - "mean_reward_after_train = helpers.evaluate(model, new_env=new_env, num_episodes=10, index=epex.index)" + "new_env = DummyVecEnv([lambda: rl.energy_price_env(price_array, start_time=max_time, max_time = periods)])\n", + "mean_reward_after_train = rl.evaluate(model, new_env=new_env, num_episodes=10, index=epex.index)" ] } ], diff --git a/multiprocessing/train_model_multiprocess.ipynb b/Notebooks/multiprocessing/train_model_multiprocess.ipynb similarity index 95% rename from multiprocessing/train_model_multiprocess.ipynb rename to Notebooks/multiprocessing/train_model_multiprocess.ipynb index d96cb23..ff2c910 100644 --- a/multiprocessing/train_model_multiprocess.ipynb +++ b/Notebooks/multiprocessing/train_model_multiprocess.ipynb @@ -12,8 +12,9 @@ "from stable_baselines3.common.env_checker import check_env\n", "import gym\n", "import numpy as np\n", - "from RL import helpers\n", - "from Hack import load\n", + "import sys\n", + "sys.path.append(\"../../\")\n", + "from Hack import load, rl\n", "%matplotlib qt5" ] }, @@ -76,7 +77,7 @@ " :return: (Callable)\n", " \"\"\"\n", " def _init() -> gym.Env:\n", - " env = helpers.energy_price_env(price_array, max_time=max_time, window_size=24*2)\n", + " env = rl.energy_price_env(price_array, max_time=max_time, window_size=24*2)\n", " env.seed(seed + rank)\n", " return env\n", " set_random_seed(seed)\n", diff --git a/Notebooks/parallel_optimization.py b/Notebooks/parallel_optimization.py new file mode 100644 index 0000000..58e7a07 --- /dev/null +++ b/Notebooks/parallel_optimization.py @@ -0,0 +1,61 @@ +import sys + +sys.path.append("../") + +import optuna +from pathos.multiprocessing import ProcessingPool +from stable_baselines3 import PPO +from stable_baselines3.ppo.policies import MlpPolicy + +from Hack import load, rl + + +def create_train_model(price_array, learning_rate, power=0.5, window_size=2 * 24): + """ + Creates and trains the deep learning model + """ + start_idx = 0 + end_idx = 4 * 2 * 24 * 7 # start_of_2020 # 2019->2020 # 2*24*7 + obs_price_array = price_array[start_idx:end_idx] + env = rl.energy_price_env(obs_price_array, window_size=window_size, power=power) + model = PPO(MlpPolicy, env, verbose=0, learning_rate=learning_rate) + model.learn(100) + return model + + +def evaluate_model(iter_obj): + total_val = 0 + for obj in iter_obj: + idx = obj[0] + model = obj[1] + val = rl.quick_eval(idx, model) + total_val += val + return total_val + + +def objective(trial): + """ + args: params of our model + """ + data = load.epex().load() + price_array = data["apx_da_hourly"].values + learning_rate = trial.suggest_float("learning_rate", 1.0e-5, 1.0e-3) + model = create_train_model(price_array, learning_rate) + obj_to_iterate = [(i, model) for i in range(10)] + obj_to_iterate2 = [(i, model) for i in range(10)] + obj_to_iterate3 = [(i, model) for i in range(10)] + results = ProcessingPool(3).map( + evaluate_model, [obj_to_iterate, obj_to_iterate2, obj_to_iterate3] + ) + # calculate the mean result + mean_result = sum(results) / ( + float(len(obj_to_iterate) + len(obj_to_iterate2) + len(obj_to_iterate3)) + ) + return mean_result[0] + + +if __name__ == "__main__": + # carry out the optimisation part of the problem here + study = optuna.create_study(direction="maximize") + study.optimize(objective, n_trials=2) + print("Best value: {} (params: {})\n".format(study.best_value, study.best_params)) diff --git a/Notebooks/serial_optimization.py b/Notebooks/serial_optimization.py new file mode 100644 index 0000000..4508029 --- /dev/null +++ b/Notebooks/serial_optimization.py @@ -0,0 +1,43 @@ +import sys + +sys.path.append("../") + +import time as time + +import numpy as np +from stable_baselines3 import PPO +from stable_baselines3.ppo.policies import MlpPolicy + +from Hack import load, rl + + +def objective(num_episodes=100): + """ + Function to take in hyperparameters, train a reinforcement model, and output the "profit" of the model as a metric + """ + epex = load.epex().load() + price_array = epex["apx_da_hourly"].values + + start_idx = 0 + end_idx = 4 * 2 * 24 * 7 # start_of_2020 # 2019->2020 # 2*24*7 + obs_price_array = price_array[start_idx:end_idx] + + power = 0.5 + env = rl.energy_price_env(obs_price_array, window_size=24 * 2, power=power) + model = PPO(MlpPolicy, env, verbose=0) + model.learn(100) + val_list = [] + + for i in range(num_episodes): + val = rl.quick_eval(i, model) + val_list.append(val) + + return np.mean(val_list) + + +if __name__ == "__main__": + time_start = time.time() + a = objective(num_episodes=150) + time_stop = time.time() + print(a) + print("time = ", time_stop - time_start) diff --git a/Notebooks/submission.ipynb b/Notebooks/submission.ipynb index c75c5d7..66e6b9c 100644 --- a/Notebooks/submission.ipynb +++ b/Notebooks/submission.ipynb @@ -15,10 +15,12 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ + "import sys\n", + "sys.path.append(\"../\")\n", "from Hack import load\n", "import matplotlib.pyplot as plt\n", "import pandas as pd\n", @@ -27,36 +29,16 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, - "outputs": [ - { - "ename": "FileNotFoundError", - "evalue": "[Errno 2] No such file or directory: 'C:\\\\Users\\\\Ronan\\\\Data\\\\epex_day_ahead_price.csv'", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mFileNotFoundError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32mc:\\Users\\Ronan\\Projects\\Hackathon\\submission.ipynb Cell 3'\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[0m epex \u001b[39m=\u001b[39m load\u001b[39m.\u001b[39;49mepex()\u001b[39m.\u001b[39;49mload()\n", - "File \u001b[1;32mc:\\Users\\Ronan\\Projects\\Hackathon\\Hack\\load.py:21\u001b[0m, in \u001b[0;36mloader.load\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m 20\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mload\u001b[39m(\u001b[39mself\u001b[39m):\n\u001b[1;32m---> 21\u001b[0m df \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mload_csv(\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mlocal_path)\n\u001b[0;32m 22\u001b[0m df \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mset_date_index(df)\n\u001b[0;32m 23\u001b[0m df \u001b[39m=\u001b[39m add_local_time(df)\n", - "File \u001b[1;32mc:\\Users\\Ronan\\Projects\\Hackathon\\Hack\\load.py:92\u001b[0m, in \u001b[0;36mepex.load_csv\u001b[1;34m(self, fname, delimiter, header)\u001b[0m\n\u001b[0;32m 91\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mload_csv\u001b[39m(\u001b[39mself\u001b[39m, fname, delimiter\u001b[39m=\u001b[39m\u001b[39m\"\u001b[39m\u001b[39m,\u001b[39m\u001b[39m\"\u001b[39m, header\u001b[39m=\u001b[39m\u001b[39m0\u001b[39m):\n\u001b[1;32m---> 92\u001b[0m \u001b[39mreturn\u001b[39;00m pd\u001b[39m.\u001b[39;49mread_csv(\n\u001b[0;32m 93\u001b[0m fname, delimiter\u001b[39m=\u001b[39;49mdelimiter, header\u001b[39m=\u001b[39;49mheader, parse_dates\u001b[39m=\u001b[39;49m[\u001b[39m\"\u001b[39;49m\u001b[39mtimestamp\u001b[39;49m\u001b[39m\"\u001b[39;49m]\n\u001b[0;32m 94\u001b[0m )\n", - "File \u001b[1;32m~\\Anaconda3\\envs\\ml\\lib\\site-packages\\pandas\\util\\_decorators.py:311\u001b[0m, in \u001b[0;36mdeprecate_nonkeyword_arguments..decorate..wrapper\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m 305\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mlen\u001b[39m(args) \u001b[39m>\u001b[39m num_allow_args:\n\u001b[0;32m 306\u001b[0m warnings\u001b[39m.\u001b[39mwarn(\n\u001b[0;32m 307\u001b[0m msg\u001b[39m.\u001b[39mformat(arguments\u001b[39m=\u001b[39marguments),\n\u001b[0;32m 308\u001b[0m \u001b[39mFutureWarning\u001b[39;00m,\n\u001b[0;32m 309\u001b[0m stacklevel\u001b[39m=\u001b[39mstacklevel,\n\u001b[0;32m 310\u001b[0m )\n\u001b[1;32m--> 311\u001b[0m \u001b[39mreturn\u001b[39;00m func(\u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n", - "File \u001b[1;32m~\\Anaconda3\\envs\\ml\\lib\\site-packages\\pandas\\io\\parsers\\readers.py:680\u001b[0m, in \u001b[0;36mread_csv\u001b[1;34m(filepath_or_buffer, sep, delimiter, header, names, index_col, usecols, squeeze, prefix, mangle_dupe_cols, dtype, engine, converters, true_values, false_values, skipinitialspace, skiprows, skipfooter, nrows, na_values, keep_default_na, na_filter, verbose, skip_blank_lines, parse_dates, infer_datetime_format, keep_date_col, date_parser, dayfirst, cache_dates, iterator, chunksize, compression, thousands, decimal, lineterminator, quotechar, quoting, doublequote, escapechar, comment, encoding, encoding_errors, dialect, error_bad_lines, warn_bad_lines, on_bad_lines, delim_whitespace, low_memory, memory_map, float_precision, storage_options)\u001b[0m\n\u001b[0;32m 665\u001b[0m kwds_defaults \u001b[39m=\u001b[39m _refine_defaults_read(\n\u001b[0;32m 666\u001b[0m dialect,\n\u001b[0;32m 667\u001b[0m delimiter,\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 676\u001b[0m defaults\u001b[39m=\u001b[39m{\u001b[39m\"\u001b[39m\u001b[39mdelimiter\u001b[39m\u001b[39m\"\u001b[39m: \u001b[39m\"\u001b[39m\u001b[39m,\u001b[39m\u001b[39m\"\u001b[39m},\n\u001b[0;32m 677\u001b[0m )\n\u001b[0;32m 678\u001b[0m kwds\u001b[39m.\u001b[39mupdate(kwds_defaults)\n\u001b[1;32m--> 680\u001b[0m \u001b[39mreturn\u001b[39;00m _read(filepath_or_buffer, kwds)\n", - "File \u001b[1;32m~\\Anaconda3\\envs\\ml\\lib\\site-packages\\pandas\\io\\parsers\\readers.py:575\u001b[0m, in \u001b[0;36m_read\u001b[1;34m(filepath_or_buffer, kwds)\u001b[0m\n\u001b[0;32m 572\u001b[0m _validate_names(kwds\u001b[39m.\u001b[39mget(\u001b[39m\"\u001b[39m\u001b[39mnames\u001b[39m\u001b[39m\"\u001b[39m, \u001b[39mNone\u001b[39;00m))\n\u001b[0;32m 574\u001b[0m \u001b[39m# Create the parser.\u001b[39;00m\n\u001b[1;32m--> 575\u001b[0m parser \u001b[39m=\u001b[39m TextFileReader(filepath_or_buffer, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwds)\n\u001b[0;32m 577\u001b[0m \u001b[39mif\u001b[39;00m chunksize \u001b[39mor\u001b[39;00m iterator:\n\u001b[0;32m 578\u001b[0m \u001b[39mreturn\u001b[39;00m parser\n", - "File \u001b[1;32m~\\Anaconda3\\envs\\ml\\lib\\site-packages\\pandas\\io\\parsers\\readers.py:933\u001b[0m, in \u001b[0;36mTextFileReader.__init__\u001b[1;34m(self, f, engine, **kwds)\u001b[0m\n\u001b[0;32m 930\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39moptions[\u001b[39m\"\u001b[39m\u001b[39mhas_index_names\u001b[39m\u001b[39m\"\u001b[39m] \u001b[39m=\u001b[39m kwds[\u001b[39m\"\u001b[39m\u001b[39mhas_index_names\u001b[39m\u001b[39m\"\u001b[39m]\n\u001b[0;32m 932\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mhandles: IOHandles \u001b[39m|\u001b[39m \u001b[39mNone\u001b[39;00m \u001b[39m=\u001b[39m \u001b[39mNone\u001b[39;00m\n\u001b[1;32m--> 933\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_engine \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_make_engine(f, \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mengine)\n", - "File \u001b[1;32m~\\Anaconda3\\envs\\ml\\lib\\site-packages\\pandas\\io\\parsers\\readers.py:1217\u001b[0m, in \u001b[0;36mTextFileReader._make_engine\u001b[1;34m(self, f, engine)\u001b[0m\n\u001b[0;32m 1213\u001b[0m mode \u001b[39m=\u001b[39m \u001b[39m\"\u001b[39m\u001b[39mrb\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[0;32m 1214\u001b[0m \u001b[39m# error: No overload variant of \"get_handle\" matches argument types\u001b[39;00m\n\u001b[0;32m 1215\u001b[0m \u001b[39m# \"Union[str, PathLike[str], ReadCsvBuffer[bytes], ReadCsvBuffer[str]]\"\u001b[39;00m\n\u001b[0;32m 1216\u001b[0m \u001b[39m# , \"str\", \"bool\", \"Any\", \"Any\", \"Any\", \"Any\", \"Any\"\u001b[39;00m\n\u001b[1;32m-> 1217\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mhandles \u001b[39m=\u001b[39m get_handle( \u001b[39m# type: ignore[call-overload]\u001b[39;49;00m\n\u001b[0;32m 1218\u001b[0m f,\n\u001b[0;32m 1219\u001b[0m mode,\n\u001b[0;32m 1220\u001b[0m encoding\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49moptions\u001b[39m.\u001b[39;49mget(\u001b[39m\"\u001b[39;49m\u001b[39mencoding\u001b[39;49m\u001b[39m\"\u001b[39;49m, \u001b[39mNone\u001b[39;49;00m),\n\u001b[0;32m 1221\u001b[0m compression\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49moptions\u001b[39m.\u001b[39;49mget(\u001b[39m\"\u001b[39;49m\u001b[39mcompression\u001b[39;49m\u001b[39m\"\u001b[39;49m, \u001b[39mNone\u001b[39;49;00m),\n\u001b[0;32m 1222\u001b[0m memory_map\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49moptions\u001b[39m.\u001b[39;49mget(\u001b[39m\"\u001b[39;49m\u001b[39mmemory_map\u001b[39;49m\u001b[39m\"\u001b[39;49m, \u001b[39mFalse\u001b[39;49;00m),\n\u001b[0;32m 1223\u001b[0m is_text\u001b[39m=\u001b[39;49mis_text,\n\u001b[0;32m 1224\u001b[0m errors\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49moptions\u001b[39m.\u001b[39;49mget(\u001b[39m\"\u001b[39;49m\u001b[39mencoding_errors\u001b[39;49m\u001b[39m\"\u001b[39;49m, \u001b[39m\"\u001b[39;49m\u001b[39mstrict\u001b[39;49m\u001b[39m\"\u001b[39;49m),\n\u001b[0;32m 1225\u001b[0m storage_options\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49moptions\u001b[39m.\u001b[39;49mget(\u001b[39m\"\u001b[39;49m\u001b[39mstorage_options\u001b[39;49m\u001b[39m\"\u001b[39;49m, \u001b[39mNone\u001b[39;49;00m),\n\u001b[0;32m 1226\u001b[0m )\n\u001b[0;32m 1227\u001b[0m \u001b[39massert\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mhandles \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m\n\u001b[0;32m 1228\u001b[0m f \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mhandles\u001b[39m.\u001b[39mhandle\n", - "File \u001b[1;32m~\\Anaconda3\\envs\\ml\\lib\\site-packages\\pandas\\io\\common.py:789\u001b[0m, in \u001b[0;36mget_handle\u001b[1;34m(path_or_buf, mode, encoding, compression, memory_map, is_text, errors, storage_options)\u001b[0m\n\u001b[0;32m 784\u001b[0m \u001b[39melif\u001b[39;00m \u001b[39misinstance\u001b[39m(handle, \u001b[39mstr\u001b[39m):\n\u001b[0;32m 785\u001b[0m \u001b[39m# Check whether the filename is to be opened in binary mode.\u001b[39;00m\n\u001b[0;32m 786\u001b[0m \u001b[39m# Binary mode does not support 'encoding' and 'newline'.\u001b[39;00m\n\u001b[0;32m 787\u001b[0m \u001b[39mif\u001b[39;00m ioargs\u001b[39m.\u001b[39mencoding \u001b[39mand\u001b[39;00m \u001b[39m\"\u001b[39m\u001b[39mb\u001b[39m\u001b[39m\"\u001b[39m \u001b[39mnot\u001b[39;00m \u001b[39min\u001b[39;00m ioargs\u001b[39m.\u001b[39mmode:\n\u001b[0;32m 788\u001b[0m \u001b[39m# Encoding\u001b[39;00m\n\u001b[1;32m--> 789\u001b[0m handle \u001b[39m=\u001b[39m \u001b[39mopen\u001b[39;49m(\n\u001b[0;32m 790\u001b[0m handle,\n\u001b[0;32m 791\u001b[0m ioargs\u001b[39m.\u001b[39;49mmode,\n\u001b[0;32m 792\u001b[0m encoding\u001b[39m=\u001b[39;49mioargs\u001b[39m.\u001b[39;49mencoding,\n\u001b[0;32m 793\u001b[0m errors\u001b[39m=\u001b[39;49merrors,\n\u001b[0;32m 794\u001b[0m newline\u001b[39m=\u001b[39;49m\u001b[39m\"\u001b[39;49m\u001b[39m\"\u001b[39;49m,\n\u001b[0;32m 795\u001b[0m )\n\u001b[0;32m 796\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[0;32m 797\u001b[0m \u001b[39m# Binary mode\u001b[39;00m\n\u001b[0;32m 798\u001b[0m handle \u001b[39m=\u001b[39m \u001b[39mopen\u001b[39m(handle, ioargs\u001b[39m.\u001b[39mmode)\n", - "\u001b[1;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'C:\\\\Users\\\\Ronan\\\\Data\\\\epex_day_ahead_price.csv'" - ] - } - ], + "outputs": [], "source": [ "epex = load.epex().load()" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -89,7 +71,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -172,7 +154,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -186,7 +168,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -212,7 +194,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -221,7 +203,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, "outputs": [ { diff --git a/README.md b/README.md index f664de0..68c8f1c 100644 --- a/README.md +++ b/README.md @@ -40,7 +40,7 @@ If you need to install a new package, try using conda first. Then use pip, but r python -m pip install ``` -Test your install by running the ```test_installation.py``` script (just checks sklearn as an example module). I use pytest (installed in the environment) to run the tests. Either run `pytest` in the command line, or use the "Testing" extension of VSCode. +I use pytest (installed in the environment) to run the tests. Either run `pytest` in the command line, or use the "Testing" extension of VSCode. ## Development diff --git a/environment.yml b/environment.yml index 92b6fdb..d341bd4 100644 --- a/environment.yml +++ b/environment.yml @@ -28,3 +28,6 @@ dependencies: - pip - pip: - stable_baselines3 + - optuna + - pathos + - pybats diff --git a/setup.cfg b/setup.cfg index 693d2e7..fa6e491 100644 --- a/setup.cfg +++ b/setup.cfg @@ -1,4 +1,11 @@ +[options] +packages = Hack + [options.extras_require] test = pytest - sklearn + stable-baselines3 + +[tool:pytest] +filterwarnings = + ignore::UserWarning diff --git a/setup.py b/setup.py deleted file mode 100644 index 6068493..0000000 --- a/setup.py +++ /dev/null @@ -1,3 +0,0 @@ -from setuptools import setup - -setup() diff --git a/tests/test_installation.py b/tests/test_installation.py deleted file mode 100644 index 8a57d98..0000000 --- a/tests/test_installation.py +++ /dev/null @@ -1,14 +0,0 @@ -# Run the Hello World! version of the ML packages -import numpy as np - - -def test_sklearn(): - # first example from sklearn docs - from sklearn.ensemble import RandomForestClassifier - - clf = RandomForestClassifier(random_state=0) - X = [[1, 2, 3], [11, 12, 13]] # 2 samples, 3 features - y = [0, 1] # classes of each sample - clf.fit(X, y) - prediction = clf.predict([[4, 5, 6], [14, 15, 16]]) - assert np.allclose(prediction, np.array([0, 1]))