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 3652eb1..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,7 +96,7 @@ def get_expected_price(self, idx, window_size=2 * 24, mode="median"): self.price_array, idx, window_size=window_size, mode=mode ) - def apply_action(self, mapped_action, current_energy): + def apply_action(self, human_action, current_energy): """Applies the mapped action. -1 for sell @@ -83,20 +105,20 @@ def apply_action(self, mapped_action, current_energy): Parameters ---------- - mapped_action : int + human_action : int Action to applly, has to be the mapped action current_energy : float Current energy in the battery """ - if mapped_action == -1: + 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: + elif human_action == 1: # charge === buy energy for 30 mins (0.5 hours) new_energy = current_energy + (self.power * 0.5 * self.efficiency) @@ -115,8 +137,8 @@ def get_reward(self, delta_energy, current_price, expected_price): def step(self, action): current_price, expected_price, current_energy, current_time = self.state - mapped_action = env2human(action) - new_energy = self.apply_action(mapped_action, current_energy) + human_action = env2human(action) + new_energy = self.apply_action(human_action, current_energy) # want to save this to punish even if battery is empty/full @@ -164,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) @@ -268,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 80d30ba..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,7 +20,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -87,18 +87,9 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 5, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "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" - ] - } - ], + "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", @@ -110,6 +101,69 @@ "check_env(env, warn=True)" ] }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[20. 15. 0.425 1. ]\n", + "0.0\n" + ] + } + ], + "source": [ + "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": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[10. 20. 1. 4.]\n", + "0.0\n" + ] + } + ], + "source": [ + "state, reward, _, _ = env.step(rl.human2env(1))\n", + "print(state)\n", + "print(reward)" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "10" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "env.get_reward(1,10,20)" + ] + }, { "cell_type": "code", "execution_count": 5, 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/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]))