diff --git a/docs/source/components/features/FeaturePipeline.md b/docs/source/components/features/FeaturePipeline.md index 8ffcfb6b4..4f44eeb45 100644 --- a/docs/source/components/features/FeaturePipeline.md +++ b/docs/source/components/features/FeaturePipeline.md @@ -1,4 +1,5 @@ # FeaturePipeline + Feature pipelines are meant for transforming observations from the environment into meaningful features for an agent to learn from. If a pipeline has been added to a particular exchange, then observations will be passed through the `FeaturePipeline` before being output to the environment. For example, a feature pipeline could normalize all price values, make a time series stationary, add a moving average column, and remove an unnecessary column, all before the observation is returned to the agent. @@ -23,47 +24,48 @@ model = Sequential([ ]) ``` - ## Class Parameters -* `steps` - * A list of feature transformations to apply to observations. -* `dtype` - * The `dtype` elements in the pipeline should be cast to. -## Properties and Setters +- `steps` + - A list of feature transformations to apply to observations. +- `dtype` + - The `dtype` elements in the pipeline should be cast to. -* `steps` - * A list of feature transformations to apply to observations. -* `dtype` - * The `dtype` that elements in the pipeline should be input and output as. -* `reset` - * Reset all transformers within the feature pipeline. +## Properties and Setters +- `steps` + - A list of feature transformations to apply to observations. +- `dtype` + - The `dtype` that elements in the pipeline should be input and output as. +- `reset` + - Reset all transformers within the feature pipeline. ## Functions -Below are the functions that the `FeaturePipeline` uses to effectively operate. +Below are the functions that the `FeaturePipeline` uses to effectively operate. ### Private -* `_transform` - * Utility method for transforming observations via a list of *make changes here* `FeatureTransformer` objects. - * In other words, it runs through all of the `steps` in a for loop, and casts the response. + +- `_transform` + - Utility method for transforming observations via a list of _make changes here_ `FeatureTransformer` objects. + - In other words, it runs through all of the `steps` in a for loop, and casts the response. **The code from the transform function:** As you see, it iterates through every step and adds the observation to the dataframe. + ```py for transformer in self._steps: - observations = transformer.transform(observations, input_space) + observations = transformer.transform(observations) ``` At the end the observations are converted into a ndarray so that they can be interpreted by the agent. ### Public -* `reset` - * Reset all transformers within the feature pipeline. -* `transform_space` - * Apply the pipeline of feature transformations to an observation frame. +- `reset` + - Reset all transformers within the feature pipeline. +- `transform` + - Apply the pipeline of feature transformations to an observation frame. ## Use Cases @@ -84,4 +86,4 @@ feature_pipeline = FeaturePipeline(steps=[normalize_price, difference_all]) exchange.feature_pipeline = feature_pipeline -``` \ No newline at end of file +``` diff --git a/docs/source/components/features/FeatureTransformer.md b/docs/source/components/features/FeatureTransformer.md index a022d796d..fcc0275ab 100644 --- a/docs/source/components/features/FeatureTransformer.md +++ b/docs/source/components/features/FeatureTransformer.md @@ -1,16 +1,15 @@ # FeatureTransformer -As stated before in the [overview](../overview.md), We use an `ABCMeta` abstract hierarchy to handle the transformation calls of each asset. The `FeatureTransformer` is an abstract of all other price transformers available inside of the `tensortrade` library. As such, it has a set of common functions that are called on almost every transformer. +As stated before in the [overview](../overview.md), We use an `ABCMeta` abstract hierarchy to handle the transformation calls of each asset. The `FeatureTransformer` is an abstract of all other price transformers available inside of the `tensortrade` library. As such, it has a set of common functions that are called on almost every transformer. ## Properties and Setters -* `columns` - * A list of column names to normalize - +- `columns` + - A list of column names to normalize ## Functions -Below are the functions that the `FeatureTransformer` uses to effectively operate. +Below are the functions that the `FeatureTransformer` uses to effectively operate. ### Private @@ -18,9 +17,7 @@ Below are the functions that the `FeatureTransformer` uses to effectively operat ### Public -* `reset` - * Optionally implementable method for resetting stateful transformers. -* `transform_space` - * Get the transformed output space for a given input space. -* `transform` - * Transform the data set and return a new data frame. +- `reset` + - Optionally implementable method for resetting stateful transformers. +- `transform` + - Transform the data set and return a new data frame. diff --git a/docs/source/components/features/indicators/TAlibIndicator.md b/docs/source/components/features/indicators/TAlibIndicator.md index 09ac37eba..2c8c8591f 100644 --- a/docs/source/components/features/indicators/TAlibIndicator.md +++ b/docs/source/components/features/indicators/TAlibIndicator.md @@ -1,44 +1,37 @@ # TAlibIndicator -Adds one or more TAlib indicators to a data frame, based on existing open, high, low, and close column values. +Adds one or more TAlib indicators to a data frame, based on existing open, high, low, and close column values. ![TalibIndicator](../../../_static/images/talib_transform.png) - ## Class Parameters -* `indicators` - * A list of indicators you want to transform the price information to. -* `lows` - * The lower end of the observation space. See `spaces.Box` to best understand. -* `highs` - * The lower end of the observation space. See `spaces.Box` to best understand. -## Properties and Setters - -* **NONE** +- `indicators` + - A list of indicators you want to transform the price information to. +- `lows` + - The lower end of the observation space. See `spaces.Box` to best understand. +- `highs` + - The lower end of the observation space. See `spaces.Box` to best understand. +## Properties and Setters +- **NONE** ## Functions -Below are the functions that the `TAlibIndicator` uses to effectively operate. +Below are the functions that the `TAlibIndicator` uses to effectively operate. ### Private -* `_str_to_indicator` - Converts the name of an indicator to an actual instance of the indicator. For a list of indicators see list [here](http://mrjbq7.github.io/ta-lib/). -### Public - -* `transform_space` - * Get the transformed output space for a given input space. -* `transform` - * Transform the data set and return a new data frame. +- `_str_to_indicator` - Converts the name of an indicator to an actual instance of the indicator. For a list of indicators see list [here](http://mrjbq7.github.io/ta-lib/). +### Public +- `transform` + - Transform the data set and return a new data frame. ## Use Cases: - - ## Use Cases **Use Case #1: Selecting Indicators** @@ -51,7 +44,6 @@ talib_indicator = TAlibIndicator(["rsi", "ema"]) This runs through the indicators in the list, at runtime and matches them to what is seen inside of TA-Lib. The features are then flattened into the `output_space`, both into the `high` and `low` segment of `space.Box`. - ```py for i in range(len(self._indicators)): output_space.low = np.append(output_space.low, self._lows[i]) diff --git a/docs/source/components/features/scalers/MinMaxNormalizer.md b/docs/source/components/features/scalers/MinMaxNormalizer.md index 8b97fbb0b..c036ab9bc 100644 --- a/docs/source/components/features/scalers/MinMaxNormalizer.md +++ b/docs/source/components/features/scalers/MinMaxNormalizer.md @@ -4,15 +4,14 @@ A transformer for normalizing values within a feature pipeline by the column-wis ## Class Parameters - -* `columns` - * A list of column names to normalize. -* `feature_min` - * The minimum value in the range to scale to. -* `feature_max` - * The maximum value in the range to scale to. -* `inplace` - * If `False`, a new column will be added to the output for each input column. +- `columns` + - A list of column names to normalize. +- `feature_min` + - The minimum value in the range to scale to. +- `feature_max` + - The maximum value in the range to scale to. +- `inplace` + - If `False`, a new column will be added to the output for each input column. ## Properties and Setters @@ -20,18 +19,16 @@ None ## Functions -Below are the functions that the `MinMaxNormalizer` uses to effectively operate. +Below are the functions that the `MinMaxNormalizer` uses to effectively operate. ### Private -*None* -### Public +_None_ -* `transform_space` - * Get the transformed output space for a given input space. -* `transform` - * Apply the pipeline of feature transformations to an observation frame. +### Public +- `transform` + - Apply the pipeline of feature transformations to an observation frame. ## Use Cases: @@ -48,4 +45,4 @@ feature_pipeline = FeaturePipeline(steps=[normalize_price, moving_averages, difference_all]) exchange.feature_pipeline = feature_pipeline -``` \ No newline at end of file +``` diff --git a/docs/source/components/features/scalers/StandardNormalizer.md b/docs/source/components/features/scalers/StandardNormalizer.md index b384fb5c2..8775d0d43 100644 --- a/docs/source/components/features/scalers/StandardNormalizer.md +++ b/docs/source/components/features/scalers/StandardNormalizer.md @@ -4,19 +4,18 @@ A transformer for normalizing values within a feature pipeline by removing the m ## Class Parameters - -* `columns` - * A list of column names to normalize. -* `feature_min` - * The minimum value in the range to scale to. -* `feature_max` - * The maximum value in the range to scale to. -* `inplace` - * If `False`, a new column will be added to the output for each input column. +- `columns` + - A list of column names to normalize. +- `feature_min` + - The minimum value in the range to scale to. +- `feature_max` + - The maximum value in the range to scale to. +- `inplace` + - If `False`, a new column will be added to the output for each input column. ## Properties and Setters -* None +- None ## Functions @@ -24,17 +23,14 @@ Below are the functions that the `StandardNormalizer` uses to effectively operat ### Private -*None* +_None_ ### Public -* `transform_space` - * Get the transformed output space for a given input space. -* `transform` - * Apply the pipeline of feature transformations to an observation frame. -* `reset` - * Resets the history of the standard scaler. - +- `transform` + - Apply the pipeline of feature transformations to an observation frame. +- `reset` + - Resets the history of the standard scaler. ## Use Cases: @@ -56,5 +52,3 @@ feature_pipeline = FeaturePipeline(steps=[normalize_price, difference_all]) exchange.feature_pipeline = feature_pipeline ``` - - diff --git a/docs/source/components/features/stationarity/FractionalDifference.md b/docs/source/components/features/stationarity/FractionalDifference.md index 87be1cb55..0dc8964ef 100644 --- a/docs/source/components/features/stationarity/FractionalDifference.md +++ b/docs/source/components/features/stationarity/FractionalDifference.md @@ -2,37 +2,34 @@ A transformer for differencing values within a feature pipeline by a fractional order. It removes the stationarity of the dataset available in realtime. To learn more about why non-stationarity should be converted to stationary information, please look at the blog [here](https://towardsdatascience.com/preserving-memory-in-stationary-time-series-6842f7581800). - ## Class Parameters -* `columns` - * A list of column names to difference. -* `difference_order` - * The fractional difference order. Defaults to 0.5. -* `difference_threshold` - * A type or str corresponding to the dtype of the `observation_space`. -* `inplace` - * If `False`, a new column will be added to the output for each input column. + +- `columns` + - A list of column names to difference. +- `difference_order` + - The fractional difference order. Defaults to 0.5. +- `difference_threshold` + - A type or str corresponding to the dtype of the `observation_space`. +- `inplace` + - If `False`, a new column will be added to the output for each input column. ## Functions -Below are the functions that the `FractionalDifference` uses to effectively operate. +Below are the functions that the `FractionalDifference` uses to effectively operate. ### Private -* `_difference_weights` - * Gets the weights for ... -* `_fractional_difference` - * Computes fractionally differenced series, with an increasing window width. +- `_difference_weights` + - Gets the weights for ... +- `_fractional_difference` + - Computes fractionally differenced series, with an increasing window width. ### Public -* `transform_space` - * Get the transformed output space for a given input space. -* `transform` - * Apply the pipeline of feature transformations to an observation frame. -* `reset` - * Resets the history of the standard scaler. - +- `transform` + - Apply the pipeline of feature transformations to an observation frame. +- `reset` + - Resets the history of the standard scaler. ## Use Cases: @@ -40,15 +37,11 @@ Below are the functions that the `FractionalDifference` uses to effectively oper This `FeatureTransformer` operates differently depending on if we pretransform the observation to an ndarray or keep it as a pandas dataframe. - ```py from tensortrade.features import FeaturePipeline from tensortrade.features.stationarity import FractionalDifference price_columns = ["open", "high", "low", "close"] difference_all = FractionalDifference(difference_order=0.6) # fractional difference is seen here -feature_pipeline = FeaturePipeline(steps=[difference_all]) +feature_pipeline = FeaturePipeline(steps=[difference_all]) exchange.feature_pipeline = feature_pipeline ``` - - - diff --git a/docs/source/examples/overview.md b/docs/source/examples/overview.md index 90414d0e5..b1c21489a 100644 --- a/docs/source/examples/overview.md +++ b/docs/source/examples/overview.md @@ -15,7 +15,7 @@ The beginning of the code in [Exchange](https://github.com/notadamking/tensortra class Exchange(object, metaclass=ABCMeta): """An abstract exchange for use within a trading environment.""" - def __init__(self, base_instrument: str = 'USD', dtype: TypeString = np.float16, feature_pipeline: FeaturePipeline = None): + def __init__(self, base_instrument: str = 'USD', dtype: TypeString = np.float32, feature_pipeline: FeaturePipeline = None): """ Arguments: base_instrument: The exchange symbol of the instrument to store/measure value in. @@ -42,31 +42,32 @@ class SimulatedExchange(Exchange): """ def __init__(self, data_frame: pd.DataFrame = None, **kwargs): - super().__init__(base_instrument=kwargs.get('base_instrument', 'USD'), - dtype=kwargs.get('dtype', np.float16), - feature_pipeline=kwargs.get('feature_pipeline', None)) - self._previously_transformed = False - self._should_pretransform_obs = kwargs.get('should_pretransform_obs', False) - - if data_frame is not None: - self.data_frame = data_frame.astype(self._dtype) - - self._commission_percent = kwargs.get('commission_percent', 0.3) - self._base_precision = kwargs.get('base_precision', 2) - self._instrument_precision = kwargs.get('instrument_precision', 8) - self._initial_balance = kwargs.get('initial_balance', 1E4) - self._min_order_amount = kwargs.get('min_order_amount', 1E-3) - self._window_size = kwargs.get('window_size', 1) - - self._min_trade_price = kwargs.get('min_trade_price', 1E-6) - self._max_trade_price = kwargs.get('max_trade_price', 1E6) - self._min_trade_amount = kwargs.get('min_trade_amount', 1E-3) - self._max_trade_amount = kwargs.get('max_trade_amount', 1E6) - - max_allowed_slippage_percent = kwargs.get('max_allowed_slippage_percent', 1.0) - - SlippageModelClass = kwargs.get('slippage_model', RandomUniformSlippageModel) - self._slippage_model = SlippageModelClass(max_allowed_slippage_percent) + super().__init__( + dtype=self.default('dtype', np.float32), + feature_pipeline=self.default('feature_pipeline', None) + ) + + self._commission_percent = self.default('commission_percent', 0.3, kwargs) + self._base_precision = self.default('base_precision', 2, kwargs) + self._instrument_precision = self.default('instrument_precision', 8, kwargs) + self._min_trade_amount = self.default('min_trade_amount', 1e-6, kwargs) + self._max_trade_amount = self.default('max_trade_amount', 1e6, kwargs) + + self._initial_balance = self.default('initial_balance', 1e4, kwargs) + self._observation_columns = self.default( + 'observation_columns', + ['open', 'high', 'low', 'close', 'volume'], + kwargs + ) + self._price_column = self.default('price_column', 'close', kwargs) + self._window_size = self.default('window_size', 1, kwargs) + self._pretransform = self.default('pretransform', True, kwargs) + self._price_history = None + + self.data_frame = self.default('data_frame', data_frame) + + model = self.default('slippage_model', 'uniform', kwargs) + self._slippage_model = slippage.get(model) if isinstance(model, str) else model() ``` Everything that inherits `SimulatedExchange` uses the specified kwargs to set the parameters. diff --git a/docs/source/examples/trading_context.json b/docs/source/examples/trading_context.json index 94830a988..769e0f09f 100644 --- a/docs/source/examples/trading_context.json +++ b/docs/source/examples/trading_context.json @@ -180,7 +180,6 @@ " max_trade_price: 1e7\n", " min_trade_amount: 1e-4\n", " max_trade_amount: 1e4\n", - " min_order_amount: 1e-4\n", "```\n", "\n", "\n", @@ -198,7 +197,6 @@ " \"max_trade_price\": 1e7,\n", " \"min_trade_amount\": 1e-4,\n", " \"max_trade_amount\": 1e4,\n", - " \"min_order_amount\": 1e-4,\n", " \"initial_balance\": 1e5,\n", " \"window_size\": 5,\n", " \"should_pretransform_obs\": true,\n", diff --git a/examples/TensorTrade_TradingContext.ipynb b/examples/TensorTrade_TradingContext.ipynb index e763587b5..57ca4ae98 100644 --- a/examples/TensorTrade_TradingContext.ipynb +++ b/examples/TensorTrade_TradingContext.ipynb @@ -182,7 +182,6 @@ " max_trade_price: 1e7\n", " min_trade_amount: 1e-4\n", " max_trade_amount: 1e4\n", - " min_order_amount: 1e-4\n", "```\n", "\n", "\n", @@ -200,7 +199,6 @@ " \"max_trade_price\": 1e7,\n", " \"min_trade_amount\": 1e-4,\n", " \"max_trade_amount\": 1e4,\n", - " \"min_order_amount\": 1e-4,\n", " \"initial_balance\": 1e5,\n", " \"window_size\": 5,\n", " \"should_pretransform_obs\": true,\n", diff --git a/examples/TensorTrade_Tutorial.ipynb b/examples/TensorTrade_Tutorial.ipynb index 4fa2bd356..e8344cc8c 100644 --- a/examples/TensorTrade_Tutorial.ipynb +++ b/examples/TensorTrade_Tutorial.ipynb @@ -1499,9 +1499,9 @@ "\n", "model = PPO2\n", "policy = MlpLnLstmPolicy\n", - "params = { \"learning_rate\": 1e-5 }\n", + "params = { \"learning_rate\": 1e-5, 'nminibatches': 1 }\n", "\n", - "agent = model(policy, environment, model_kwargs=params)" + "agent = model(policy, environment, **params)" ] }, { diff --git a/examples/train_and_evaluate.ipynb b/examples/train_and_evaluate.ipynb index 101ac0fb6..2cd24c7f0 100644 --- a/examples/train_and_evaluate.ipynb +++ b/examples/train_and_evaluate.ipynb @@ -2,28 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The autoreload extension is already loaded. To reload it, use:\n", - " %reload_ext autoreload\n" - ] - } - ], - "source": [ - "%matplotlib inline\n", - "%load_ext autoreload\n", - "\n", - "%autoreload 2" - ] - }, - { - "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, "outputs": [ { @@ -31,21 +10,21 @@ "output_type": "stream", "text": [ "Obtaining file:///Users/adam/Desktop/Capfolio/tensortrade\n", - "Requirement already satisfied, skipping upgrade: numpy==1.16.4 in /usr/local/lib/python3.7/site-packages (from tensortrade==0.0.2rc2) (1.16.4)\n", - "Requirement already satisfied, skipping upgrade: pandas==0.25.0 in /usr/local/lib/python3.7/site-packages (from tensortrade==0.0.2rc2) (0.25.0)\n", - "Requirement already satisfied, skipping upgrade: gym==0.14.0 in /usr/local/lib/python3.7/site-packages (from tensortrade==0.0.2rc2) (0.14.0)\n", - "Requirement already satisfied, skipping upgrade: pyyaml==5.1.2 in /usr/local/lib/python3.7/site-packages (from tensortrade==0.0.2rc2) (5.1.2)\n", - "Requirement already satisfied, skipping upgrade: pytz>=2017.2 in /usr/local/lib/python3.7/site-packages (from pandas==0.25.0->tensortrade==0.0.2rc2) (2019.2)\n", - "Requirement already satisfied, skipping upgrade: python-dateutil>=2.6.1 in /usr/local/Cellar/jupyterlab/1.0.0_5/libexec/vendor/lib/python3.7/site-packages (from pandas==0.25.0->tensortrade==0.0.2rc2) (2.7.3)\n", - "Requirement already satisfied, skipping upgrade: pyglet<=1.3.2,>=1.2.0 in /usr/local/lib/python3.7/site-packages (from gym==0.14.0->tensortrade==0.0.2rc2) (1.3.2)\n", - "Requirement already satisfied, skipping upgrade: scipy in /usr/local/lib/python3.7/site-packages (from gym==0.14.0->tensortrade==0.0.2rc2) (1.3.1)\n", - "Requirement already satisfied, skipping upgrade: cloudpickle~=1.2.0 in /usr/local/lib/python3.7/site-packages (from gym==0.14.0->tensortrade==0.0.2rc2) (1.2.1)\n", - "Requirement already satisfied, skipping upgrade: six in /usr/local/Cellar/jupyterlab/1.0.0_5/libexec/vendor/lib/python3.7/site-packages (from gym==0.14.0->tensortrade==0.0.2rc2) (1.11.0)\n", - "Requirement already satisfied, skipping upgrade: future in /usr/local/lib/python3.7/site-packages (from pyglet<=1.3.2,>=1.2.0->gym==0.14.0->tensortrade==0.0.2rc2) (0.17.1)\n", + "Requirement already satisfied, skipping upgrade: numpy==1.16.4 in /usr/local/lib/python3.7/site-packages (from tensortrade==0.1.0rc0) (1.16.4)\n", + "Requirement already satisfied, skipping upgrade: pandas==0.25.0 in /usr/local/lib/python3.7/site-packages (from tensortrade==0.1.0rc0) (0.25.0)\n", + "Requirement already satisfied, skipping upgrade: gym==0.14.0 in /usr/local/lib/python3.7/site-packages (from tensortrade==0.1.0rc0) (0.14.0)\n", + "Requirement already satisfied, skipping upgrade: pyyaml==5.1.2 in /usr/local/lib/python3.7/site-packages (from tensortrade==0.1.0rc0) (5.1.2)\n", + "Requirement already satisfied, skipping upgrade: pytz>=2017.2 in /usr/local/lib/python3.7/site-packages (from pandas==0.25.0->tensortrade==0.1.0rc0) (2019.2)\n", + "Requirement already satisfied, skipping upgrade: python-dateutil>=2.6.1 in /usr/local/Cellar/jupyterlab/1.0.0_5/libexec/vendor/lib/python3.7/site-packages (from pandas==0.25.0->tensortrade==0.1.0rc0) (2.7.3)\n", + "Requirement already satisfied, skipping upgrade: pyglet<=1.3.2,>=1.2.0 in /usr/local/lib/python3.7/site-packages (from gym==0.14.0->tensortrade==0.1.0rc0) (1.3.2)\n", + "Requirement already satisfied, skipping upgrade: scipy in /usr/local/lib/python3.7/site-packages (from gym==0.14.0->tensortrade==0.1.0rc0) (1.3.1)\n", + "Requirement already satisfied, skipping upgrade: six in /usr/local/Cellar/jupyterlab/1.0.0_5/libexec/vendor/lib/python3.7/site-packages (from gym==0.14.0->tensortrade==0.1.0rc0) (1.11.0)\n", + "Requirement already satisfied, skipping upgrade: cloudpickle~=1.2.0 in /usr/local/lib/python3.7/site-packages (from gym==0.14.0->tensortrade==0.1.0rc0) (1.2.1)\n", + "Requirement already satisfied, skipping upgrade: future in /usr/local/lib/python3.7/site-packages (from pyglet<=1.3.2,>=1.2.0->gym==0.14.0->tensortrade==0.1.0rc0) (0.17.1)\n", "Installing collected packages: tensortrade\n", - " Found existing installation: TensorTrade 0.0.2rc2\n", - " Uninstalling TensorTrade-0.0.2rc2:\n", - " Successfully uninstalled TensorTrade-0.0.2rc2\n", + " Found existing installation: TensorTrade 0.1.0rc0\n", + " Uninstalling TensorTrade-0.1.0rc0:\n", + " Successfully uninstalled TensorTrade-0.1.0rc0\n", " Running setup.py develop for tensortrade\n", "Successfully installed tensortrade\n" ] @@ -57,15 +36,19 @@ }, { "cell_type": "code", - "execution_count": 4, - "metadata": { - "scrolled": true - }, + "execution_count": 2, + "metadata": {}, "outputs": [], "source": [ + "%matplotlib inline\n", + "\n", + "import pandas as pd\n", + "\n", + "from stable_baselines.common.policies import MlpLnLstmPolicy\n", + "from stable_baselines import PPO2\n", + "\n", "from tensortrade.rewards import SimpleProfit\n", "from tensortrade.actions import DiscreteActions\n", - "from tensortrade.exchanges.simulated import FBMExchange\n", "from tensortrade.features.stationarity import FractionalDifference\n", "from tensortrade.features.scalers import MinMaxNormalizer\n", "from tensortrade.features import FeaturePipeline\n", @@ -78,85 +61,551 @@ "reward_scheme = SimpleProfit()\n", "action_scheme = DiscreteActions(n_actions=20, instrument='ETH/BTC')\n", "\n", - "exchange = FBMExchange(base_instrument='BTC',\n", - " timeframe='1h',\n", - " pretransform=True)" + "ohlcv_data = pd.read_csv('./data/Coinbase_BTCUSD_1h.csv', skiprows=1)\n", + "ohlcv_data = ohlcv_data[['open','high','low','close','volume']]\n", + "\n", + "model = PPO2\n", + "policy = MlpLnLstmPolicy\n", + "params = { \"learning_rate\": 1e-5, 'nminibatches': 1 }" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 3, "metadata": { "scrolled": true }, "outputs": [ { - "name": "stderr", + "name": "stdout", "output_type": "stream", "text": [ - "/usr/local/lib/python3.7/site-packages/tensorflow/python/ops/gradients_impl.py:110: UserWarning: Converting sparse IndexedSlices to a dense Tensor of unknown shape. This may consume a large amount of memory.\n", - " \"Converting sparse IndexedSlices to a dense Tensor of unknown shape. \"\n" + "5 1\n", + "(5,)\n", + "(5,)\n", + "Finished running strategy.\n", + "Total episodes: 1 (1665 timesteps).\n", + "Average reward: -32.86919247739314.\n" ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
balancenet_worth
1118108813.770199134458.549870
111928579.773723133000.862954
1120381.026356130901.318324
112192.660971136266.343675
112246.113537133112.165336
\n", + "
" + ], + "text/plain": [ + " balance net_worth\n", + "1118 108813.770199 134458.549870\n", + "1119 28579.773723 133000.862954\n", + "1120 381.026356 130901.318324\n", + "1121 92.660971 136266.343675\n", + "1122 46.113537 133112.165336" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ "from tensortrade.environments import TradingEnvironment\n", - "from tensortrade.strategies import TensorforceTradingStrategy\n", + "from tensortrade.strategies import StableBaselinesTradingStrategy\n", + "from tensortrade.exchanges.simulated import FBMExchange\n", "\n", - "network_spec = [\n", - " dict(type='dense', size=128, activation=\"tanh\"),\n", - " dict(type='dense', size=64, activation=\"tanh\"),\n", - " dict(type='dense', size=32, activation=\"tanh\")\n", - "]\n", + "WINDOW_SIZE = 1\n", "\n", - "agent_spec = {\n", - " \"type\": \"ppo\",\n", - " \"learning_rate\": 1e-4,\n", - " \"discount\": 0.99,\n", - " \"likelihood_ratio_clipping\": 0.2,\n", - " \"estimate_terminal\": False,\n", - " \"max_episode_timesteps\": 2000,\n", - " \"network\": network_spec,\n", - " \"batch_size\": 10,\n", - " \"update_frequency\": \"never\"\n", - "}\n", + "exchange = FBMExchange(base_instrument='BTC',\n", + " timeframe='1h',\n", + " window_size=WINDOW_SIZE,\n", + " pretransform=True)\n", "\n", "environment = TradingEnvironment(exchange=exchange,\n", " action_scheme=action_scheme,\n", " reward_scheme=reward_scheme,\n", " feature_pipeline=feature_pipeline)\n", "\n", - "strategy = TensorforceTradingStrategy(environment=environment, agent_spec=agent_spec)" + "strategy = StableBaselinesTradingStrategy(environment=environment,\n", + " model=model,\n", + " policy=policy,\n", + " model_kwargs=params)\n", + "\n", + "performance = strategy.run(steps=1665)\n", + "\n", + "performance[-5:]" ] }, { "cell_type": "code", - "execution_count": 6, - "metadata": { - "scrolled": true - }, + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "performance.balance.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, "outputs": [ { - "name": "stderr", + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "performance.net_worth.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", "output_type": "stream", "text": [ - "Timesteps: 0%| | 0/100 [00:03\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
balancenet_worth
1128-3.142253672.005389
1129495.512145664.867840
1130252.341500664.962399
1131190.319851663.778094
113248.271748664.728893
\n", + "" + ], + "text/plain": [ + " balance net_worth\n", + "1128 -3.142253 672.005389\n", + "1129 495.512145 664.867840\n", + "1130 252.341500 664.962399\n", + "1131 190.319851 663.778094\n", + "1132 48.271748 664.728893" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from tensortrade.environments import TradingEnvironment\n", + "from tensortrade.strategies import StableBaselinesTradingStrategy\n", + "from tensortrade.exchanges.simulated import SimulatedExchange\n", + "\n", + "exchange = SimulatedExchange(base_instrument='USD',\n", + " data_frame=ohlcv_data,\n", + " price_column='close',\n", + " window_size=WINDOW_SIZE,\n", + " pretransform=True)\n", + "\n", + "environment = TradingEnvironment(exchange=exchange,\n", + " action_scheme=action_scheme,\n", + " reward_scheme=reward_scheme,\n", + " feature_pipeline=feature_pipeline)\n", + "\n", + "strategy = StableBaselinesTradingStrategy(environment=environment,\n", + " model=model,\n", + " policy=policy,\n", + " model_kwargs=params)\n", + "\n", + "performance = strategy.run(steps=1665)\n", + "\n", + "performance[-5:]" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "performance.balance.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "performance.net_worth.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "scrolled": true + }, + "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ + "5 20\n", + "(20, 5)\n", + "(20, 5)\n", "Finished running strategy.\n", - "Total episodes: 0 (100 timesteps).\n", - "Average reward: 499.89272819158185.\n" + "Total episodes: 1 (1665 timesteps).\n", + "Average reward: -1.9749117901539603.\n" ] }, { - "name": "stderr", + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
balancenet_worth
112517.9883771247.889698
112613.5292011157.305702
11273.5534181299.284927
11280.8664031424.630021
11290.0146901376.455720
\n", + "
" + ], + "text/plain": [ + " balance net_worth\n", + "1125 17.988377 1247.889698\n", + "1126 13.529201 1157.305702\n", + "1127 3.553418 1299.284927\n", + "1128 0.866403 1424.630021\n", + "1129 0.014690 1376.455720" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from tensortrade.environments import TradingEnvironment\n", + "from tensortrade.strategies import StableBaselinesTradingStrategy\n", + "from tensortrade.exchanges.simulated import FBMExchange\n", + "\n", + "WINDOW_SIZE = 20\n", + "\n", + "exchange = FBMExchange(base_instrument='BTC',\n", + " timeframe='1h',\n", + " window_size=WINDOW_SIZE,\n", + " pretransform=True)\n", + "\n", + "environment = TradingEnvironment(exchange=exchange,\n", + " action_scheme=action_scheme,\n", + " reward_scheme=reward_scheme,\n", + " feature_pipeline=feature_pipeline)\n", + "\n", + "strategy = StableBaselinesTradingStrategy(environment=environment,\n", + " model=model,\n", + " policy=policy,\n", + " model_kwargs=params)\n", + "\n", + "performance = strategy.run(steps=1665)\n", + "\n", + "performance[-5:]" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "performance.balance.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYMAAAD4CAYAAAAO9oqkAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3dd5hU1fnA8e87ZXtjWVjKAksVQaWIiGIsoNiSoMYYNUZjNKRgijH5RWMSTUwxvavRaNTEGmPEWBA02KVa6L0vbIGF7W1mzu+Pe2d2ZvfOdnZ3Zt7P8+yzM+eee/dcRu87p4sxBqWUUonN1dcFUEop1fc0GCillNJgoJRSSoOBUkopNBgopZQCPH1dgK7Ky8szhYWFfV0MpZSKKWvWrDlkjBnUMj1mg0FhYSGrV6/u62IopVRMEZE9TunaTKSUUkqDgVJKKQ0GSiml0GCglFIKDQZKKaXQYKCUUgoNBkoppehAMBCRESKyTEQ2isgGEfmGnX6niBSJyIf2z0Vh59wmIttFZIuInB+WfoGdtl1Ebg1LHy0iK+z0p0QkqadvNJpD1Q08/M4uaht9vfUnlVKq3+lIzcAH3GKMmQTMAhaKyCT72O+MMVPtn5cA7GNXApOBC4B7RMQtIm7gL8CFwCTgqrDr/MK+1jjgCHBDD91fu361eAt3/ncjb2071Ft/Uiml+p12g4Ex5qAx5n37dRWwCRjexinzgSeNMQ3GmF3AdmCm/bPdGLPTGNMIPAnMFxEB5gDP2Oc/AlzS1RvqrO1l1QD4A7rJj1IqcXWqz0BECoFpwAo76SYRWSsiD4nIADttOLAv7LT9dlq09IHAUWOMr0W6099fICKrRWR1WVlZZ4oe1eHqBkCDgVIqsXU4GIhIBvBv4JvGmErgXmAsMBU4CPzmmJQwjDHmfmPMDGPMjEGDWq2z1CXlNY0ABHT7T6VUAuvQQnUi4sUKBI8ZY54FMMaUhB1/AHjBflsEjAg7vcBOI0r6YSBHRDx27SA8/zFX2+gHQGOBUiqRdWQ0kQAPApuMMb8NSx8alu1SYL39+nngShFJFpHRwHhgJbAKGG+PHErC6mR+3hhjgGXA5fb51wGLundbHeezm4d+vWQL9U3+3vqzSinVr3SkmWg28DlgTothpL8UkXUishY4B7gZwBizAXga2AgsBhYaY/z2t/6bgFewOqGftvMCfBf4lohsx+pDeLDnbrFj9h+p429v7eztP6uUUv1Cu81Expi3AXE49FIb5/wU+KlD+ktO5xljdmKNNupVpkXb0Nr9Fb1dBKWU6hcSegZygy8Q8T7Yf6CUUokmoYNBXYuH/8GKuj4qiVJK9a2EDgZN/siawY6yGg7Z8w6UUiqRJHYwcJho1rK2oJRSiSChg4GvRc0AwOtO6H8SpVSCSugnX5O/dc1AZyIrpRJRQgcDX6B1zaC7ocAYw97Dtd28ilJK9a7EDgYONYOWcw8661+r93Pmr5axZk95t66jlFK9KaGDQcvRRND9NYrWFh0FYH1RZfcupJRSvSihg4HvGCxbnZ5kTequ0Z3TlFIxJKGDgVPNoLsdyKlJbgBqG3SIqlIqdiR0MHDuM+jeNd1iLeOkNQOlVCxJ7GBwDEYT1dnLYFfWaTBQSsWOhA4GTvMMujuaKLjYnS5roZSKJQkdDJyaibrbpxzcIOdwjQYDpVTsSOhg4NSB3N2GokZ7WexDVY3duo5SSvWmhA4GTttcdrcDObj4XXFlPSWV9d27mFJK9ZKEDgbFDg/r7nYgN4VtmPPP5Xs6ff53/vURU3+8hJoG7YBWSvWehA4GB4/Wk5eRHJHW3XkGTf4Aw3NSAfC4XGw4UMEFv3+TzcUdm5H8rzX7OVrbxFvbyrpVDqWU6oyEDgYVdU3kpnsj0nqimWhQZjI5aV4OVTew6MMDbC6uYumGkk5dZ9lmDQZKqd6T0MGgyR9otX9Bt4OBL0CS28XA9CQO1zSQZF//ntd3sOjDonbP97qtSWsf7DvSvYIopVQnJHYwCBg8LYNBN3sNmvwBPG5hYEYyGw9Uhiah1TX5+caTH7Z5rj9gQnMfquo73mdw/5s7eGndwa4XWimV8Dx9XYC+ZH2Ll4i0btcM/AHSkz18sLecuiY/SzYW43YJ/g5MYGgM63zuaDA4XN3Az17aDMDuuy/uWqGVUgkvoWsGvkAAj6uHm4n8Bq/bFaoR7CuvY2h2Ct+eNwGAHy5aH/XcBp91Tnaql+oGX4cCyMk/ebV7BVZKKRI8GDT5DV5PzzcTed3CYzee2nxNQ2jU0qPvRR9uWt9k1QwGZVp5P9x3BGMMDT5/t5fJUEqptiR4MAjgdfVcM9H6ogq2lVbjdbuYPS4vlF50tI4ThmdHPW/JhmIKb32RPy/bBsCYvHQAPnXvezz3YRHz//wOX/rHmnb/vgYMpVRXJXQw8NlNOuG68zj9+J/eBmBPubUH8vs/OA+AFK8rFAxazmsAWGA/6P+5fC8A4wZnhI49sXIfm4urWLKxpN2HfZ3DjGqllOqIhA4GwZE/4bo76Qzgo33W1pe56Un84cqp/OXq6QBcMaMAT4uaiJPLphfwu89MAWDd/opQeoOv9VpKWSme0DWrddayUqqLEjsYBHp2nkFOmjWB7fGw/oL5U4cz9/h8ANKTPe1uejMkK4VxgzO4dFoB+VnJEd/2K+uaIvLuK6+lst5Hkt3vUaO7qymluiixg4HP4HULv//M1FA7fVcbiowxVNf7+OrZYzk9rL8gXHqSh5oGH76w1VKDI4iCslKbR/sme9wRxyrrI4PB0o0l9jWs6+l6RkqprkrYYLCzrJriynpKqxq4ZNpwfjR/MtD1msGTq/bhCxgyU7xR85wwPIuAgQff3hVKC36bt3fLZGtJdehYcouRTiWVkXskBPdbvvOTVtm1mUgp1VXtBgMRGSEiy0Rko4hsEJFv2Om5IrJURLbZvwfY6SIifxSR7SKyVkSmh13rOjv/NhG5Liz9ZBFZZ5/zRxFpv2G9m4IP5Ne3WGsACdaf7OzmNuuLKvjhovXc9uw6AIblpETNO3P0QAB+/vJm1uyxlpsIfpsPBqGksAAQfD1j1ADSk9y8sDZylnGdvava0Czrbzrvz6CUUu3rSM3AB9xijJkEzAIWisgk4FbgNWPMeOA1+z3AhcB4+2cBcC9YwQO4AzgVmAncEQwgdp4vhp13QfdvrW1Haq3NZ4L9ucHw09nhmbc8/VHE3IGLTxwaNW9uelLodbD9/3CNVY5gLeCBa2eE8gTThmSnMGvMQFbtLgesGkCTPxDaTS3b7qvQYKCU6qp2l6MwxhwEDtqvq0RkEzAcmA+cbWd7BHgd+K6d/qixnqrLRSRHRIbaeZcaY8oBRGQpcIGIvA5kGWOW2+mPApcAL/fMLTarb/JTUddEflYKO8tqAHj8i7MACFZFOttKlOKNjKct1zpq6TefnsIt//qIKrtGcOBoHQD3XXMyK3eXM3vswFDeYJ9BitfN8JxU3tp+iCZ/gBPueCXimml2c1GjT+cZKKW6plNrE4lIITANWAHk24ECoBjIt18PB/aFnbbfTmsrfb9Deo/76mPv87/Npey++2JqGn1cOm04s8bYD99QzaBz1+xss9KZEwYBUGHXTILBYPrIAZwzcXBE3mQ70KR63YzITaPRF2DlrvJW1wzWILRmoJTqqg53IItIBvBv4JvGmIidWuxawDH/WioiC0RktYisLivr/Hr//9tcClhNQX6/wR025t9ltxN1djmK8KGiE/Iz2shpyU61mnSO1FrNREVH60hPckeMIgoKLn+d4nVxlh1E7n9zZ6t8weGxGgyUUl3VoWAgIl6sQPCYMeZZO7nEbv7B/l1qpxcBI8JOL7DT2kovcEhvxRhzvzFmhjFmxqBBgzpSdEcBA76AiZgAFmom6mRIq2nwMXlYFpdMHcZjN85qN3+Sx0VGsoejdjA4cLSOYTmpOPWZBzuQU+yaQeHANN7YagXBn1xyAkOyUjhzwiANBkqpbuvIaCIBHgQ2GWN+G3boeSA4Iug6YFFY+rX2qKJZQIXdnPQKME9EBtgdx/OAV+xjlSIyy/5b14Zd65ho8gfwByJrBsGHceeDgZ+Zo3P5/ZXTQgvMtSc71UvR0Vp2H6qhyA4GToLXC66sGqxVAFw1cyTLvzeXR64/JRQMGv3aZ6CU6pqO9BnMBj4HrBOR4O4s3wPuBp4WkRuAPcAV9rGXgIuA7UAtcD2AMaZcRO4CVtn5fhzsTAa+CjwMpGJ1HPd453E4f8DgNy1qBsE+g040ExljqGn0kZHcuW0hctK8vLKhhFfsrTCvPGWEY77rTivkwNE6LptudaEcqKgHYHhOaiiQiUioOanJYbkKpZTqiI6MJnqb5laUluY65DfAwijXegh4yCF9NXBCe2XpLpc0NxFZfQauiGNWWTp+vfvf3Ikx1jITnZGZEpk/ODS0pcK8dP76ueahpvX2vIKnvhTZHJWkHchKqW5KqBnIwU5inz9g9RlELFIXnHTW8Wjw/l5r4thFJ0SfW+Dk9osmcfGJQzn3eGv00FfPGteh837wiUlkpngYkhU5sS24b7IGA6VUVyXUtpcuu2rgt3/cjs1EHVfb6GfqiBxGDkzrVDlOLMjmL5+d3n7GFq6YMYIrZrRuUnK7BBHYXlrd6r6UUqojEqpm4A7WDALG3vKy9WiizkSDukZ/aMJXXxIRjIHnPjzA2O+9xJtbOz/sVimV2BIiGCz6sIh1+ytC35ib/AEChm7PM6jtJ8EAYMyg9NDrax9ayZbiqj4sjVIq1iREM9E3nrQGQWXZHbfBJZ+dRhMFOtjsPvvu/1F0tI6xg9ufaNYbFn/jTPaW1/DKhhJ+9coWHnlvNz+79MS+LpZSKkYkRDAICtYEGuyN58NHEwVXLW2vXmCMQUQospeReH1zaTtn9I4kj4txgzMZNziTN7aWsWLn4b4uklIqhiREM1FQsCkouKGM4zyDNkYTlVTWM+72l/nTa9tandefjB6YTlW97m2glOq4hKoZuOyHf71dM3A5jLqJFgo+2HuES+95F4DfLN0KWGsR/f4z03q+oN2UlerRYKCU6pS4qBkEAiY05r8t7jZqBq52lqMIBoJw/7zhVCYNy+pscY+5zBQvdU1+nXeglOqwmA8GVfVN/GDRei67512WbChuM2+oz8AXiHgPnd/cZu7EwQzOir6rWV8KznAurWpoJ6dSSlliPhjc9cJGHluxF4C3tx9qM2/wgd9mn4HDeU7fsI/WNTnk7B9OKsgB4I0tOt9AKdUxMd9n8J8Pmle7Dm4uH427RZ9BRM2A6M1EdU3N1/3yWWNJcguXTS9onbGfOKkgG4BD1VozUEp1TMwHg3Bed9tDe4Zmp7DncC3v25vRh69NFFqozqFuENx4HqxlpL9y9tgeKO2x43W7yEzxUG7vr6yUUu2J+Wai8E1h2luTZ2i2tW/A3vJaAJLczbOHQ5POHGoGtWHBoL2A01/kpidxpFaDgVKqY2I/GIS99razGX2wc7ja3ow+LTl8KQmJyBMuvGZw7vH5rY73R9mpXir7cb+GUqp/if1gEBYNXO3MAAt+66+xg0F6UnMrWVun1jVZ+e+7ZjqFeenRM/YjKR53qG9EKaXaE/vBIKxu0N5eBMGjoZpB2CJzbc0zCDYTDczo2LaW/UGy1xXR8a2UUm2J+WAQ3k3gd2rwDxNo0UwUvkOZtMgTbl+5tQ5Rfmb/nFfgJMXrpl6DgVKqg2I+GIR3IPvbmzBmHw42n6Qnte5AdrrEhgMVZKZ4GJHrvHF9f5SqwUAp1QlxEAyaX/v9HasZBKWEB4M2Vi3deLCSSUOzIgJPf5fidWmfgVKqw2I/GIS9bq9m0PJwR1ctLTpSR+HA2Og4Dkrxuh37DO58fgP/XrO/D0qklOrPYn7SWfjKox3tMwidKx1bjqKuyU9qP9nRrKOcmok2F1fy8Lu7AZg3OZ/MFG8flEwp1R/FVc3gaG1jm9s9tnzQRy5UF32eQX0MBoOsVC8NvkDEHInF65sX8nt3h25+o5RqFvvBIOzb/bItZZz/+zej5m35oHeH1wxCeSLPafIHaPIbUr2xFQxG5qYBsPtwDdUNPu56YSPbSqpDx/ceru2roiml+qHYDwYOadGWoQ5PFolsYgo2GbVsaQo2tcRaMJiQnwnALU9/xBMr9vLg27t4cd1BRuamMWpgGj99aROFt77YbtOaUioxxH4wcBjhE+0BF95n4G5xXnDROn8gcgTOVvvbdEqMNRNNyM8ArJFQP31pUyj9YEUdpxTmht7vOlTT62VTSvU/cRAMWqc1RRliGp7acsvL4MgiX4tA8uV/rgHgSIytABptGOwPPzGZ7NTmjuNzf/sGz390oLeKpZTqp2J/NJHDM6/RHyCV1t/kw5/zLWsGwc5kX4tAkp7kpozI5a5jxR+unMqGA5V86cwx7D5cw/SRAxAR/vTatlCe4TmpPL1qH5+cMqwPS6qU6msxHwyc+KLs/Rvel9ByuevgiqfhNYPSynp22x2tN5wxuqeLeczNnzqc+VOHA5HrKuWkWTWD/KxkThyezc5D1Y7nK6USR8w3Ezn1FUdtJgpLblmjaK4ZNAeSB9/eFXqd7ImtPoO2jLBHGpVWNZCV6qGyztfHJVJK9bXYDwYOaU57Flt5o9cMnPoMghvLx5vJw6xtMS86YShZKV6KK+t5bVNJH5dKKdWXYj8YOFQNogWD8IFCLYOBiOB2ScRIpCiXiXmDMpN577Y5/O4zU0OzkG94ZDXriyr6uGRKqb7SbjAQkYdEpFRE1oel3SkiRSLyof1zUdix20Rku4hsEZHzw9IvsNO2i8itYemjRWSFnf6UiCR15gY61UwUVjNw2gjH7RKaAgF2llXz7X99xLbS6LOZY93Q7FSSPK6I2s8fXtum8w6USlAdqRk8DFzgkP47Y8xU++clABGZBFwJTLbPuUdE3CLiBv4CXAhMAq6y8wL8wr7WOOAIcENnbiB87sD3LpoIQGlVfZS8za+d9kv2ugS/3/CP5Xt4Zs1+Xlh7sDNFiUmfnlHA1aeOZExeOks3lnDV/cujTtpTSsWvdoOBMeZNoLyD15sPPGmMaTDG7AK2AzPtn+3GmJ3GmEbgSWC+WIPh5wDP2Oc/AlzSkT9U0+hjz+GaiD6D8YOtWbefe3BllJtpfhmtZuALmIRa+jkzxcvPLj2RB66bAcDK3eWs2XOkj0ullOpt3ekzuElE1trNSAPstOHAvrA8++20aOkDgaPGGF+LdEciskBEVovI6p1lNSx4dA2BsK/7tY1tb+YSaGNoKYDH7cIXCETMQva4hOdvmt3mdePB2EEZodfbSnt/qGlAm6eU6lNdDQb3AmOBqcBB4Dc9VqI2GGPuN8bMMMbMAGsphfBHSHlt27OEw/M6BgO7Azm4LSbARScO5aSCnG6VO1a88LUzADhc3dCrf/fH/93I7F/8j7e2lfXq31VKNetSMDDGlBhj/MaYAPAAVjMQQBEwIixrgZ0WLf0wkCMinhbpHeJ1S6gD+XsXTWT+VGsW7UUnDnHMH14zcJq57HEJTX4TMe5+8rCsjhYn5p0wPJuMZA+He3npjYfe2cXBino+9+BK/qtLYyjVJ7oUDERkaNjbS4HgSKPngStFJFlERgPjgZXAKmC8PXIoCauT+Xlj9VQuAy63z78OWNTRcnjcLowx3HjGaBacOZasFC8D05MYkOY8ICm8X9Tjan3rbrdVM2j0Wc1EcyYO5ktnje1oceJCbnoS5T0QDP770QHO+tUyKuqa2s0bviLs+gM6vFWpvtCRoaVPAO8Bx4nIfhG5AfiliKwTkbXAOcDNAMaYDcDTwEZgMbDQrkH4gJuAV4BNwNN2XoDvAt8Ske1YfQgPdrTwXrcQMJGL1Yk4T0Szy9d8446jiVz4AoamQICPjc/jQbtTNZHUNflZ9OEBDhyti2gu66y/vb2LPYdrufqB5RyubmDx+uJWO6+BtUR4XZOf2eMGArG3IKBS8aLdKbbGmKsckqM+sI0xPwV+6pD+EvCSQ/pOmpuZOsXtEgymxfaV4jj3ACKDxKaDlY7X8/kD+PwGj0uirvwZz8qqrP6C0+/+Hx6XsPUnFzoGzvY02A/+DQcqOfknr4bSd999cUS+4Mily08uoKKuiUPVGgyU6gsxPQPZ43JZcwfCnlVlVQ08sXJvxHaPQS33QG7J63bR4AvQ5A+EFq5LZL6Aoaax87WD+iY/20urmTcpv9286+xZz3Mm5jMkK4UDR+s6/feUUt0X0088r9tqE3KaM7BkY3GrtEA70wcK89LYUVad0MHgX18+LeJ9V5qKtpdW4wsYLj6puWvp7OMGIdJ6COmhqgbSktxkp3opHJjO5uIq3tyqo4qU6m0x/cRzu4SAMY5bXzo9xNobyT4mL4O95bU0+U1M7l/QE04pzGXRwuZ5FVX1nQ8Gi9dbgfiE4dkR1zUGqlp8LmXVDeTZy2ufbvcbfPHR1aFOfKVU74jpYOB1uzA41wxqHIJBZdjIlvMnt27CSE1yY4w1ec1ptFGimDIih4evPwXofDB4ed1B/rxsO2BtnJPitf4dB2VaD/yH3t7Fu9sPhfKXVTWEjs2ZmM+frppGgy/A1pL4XRdKqf4optdoDtUMHL7EVzs8xIrC2qPPm9R6LkKyx3pwVdU3WU1QCSy4mmlVfftDQ8Ot2t28lEWK183b351Dkz9A0RHr3/4P9i5rwY7ksqqGiNnPU+wJfk+u2sv5tUP42PhBXb8JpVSHxfTXX4/LGjnkNOqnuqHtpSmcHvYp9nj3Bl/i9hkEBVcz7WyfQXApj3OPt2peeRnJDM1OZUZhLiPtTXXAWkzwX6v3sa20OlQzABiRm8rA9CT+uXwvn3twJQseXR115zqlVM+J6SdeMAg4fYdv9LcdDJyWo0gJm/yUqH0GQRnJdjDoZDNRXZOfIVkp/M1hjsbscXmh1wseXcN3nlkLwJDslFC6iPCFM0YzPCcVgCUbS1i2RTuUlTrWYjoYBJ/nTn0G7a175tQnEGzfBrRmYNcMOttnUNvoJy3JeYvQr88dF3r94b6j1t9J9nDJtMi1CReeM453bp3DG985G4BVuzu6aK5Sqqtius8g3f726tRn0N6a/I7NRGH7HHu6MNEqnqQn2cGgk81E9U3+iBpWuKHZqWSleKi0A8yD181g7vHR5yKMGpjOxCGZ3P/mTqYU5EQMVVVK9ayY/vobnETm9Nxub8cuj8M3//CH2EaHGcqJxOUSMpI9Ec1Ej6/Yy/efW9fmctN1TdFrBgDPfrV52GphXnq75Rifb+1RsfDx9ztSbKVUF8V0zSD4wHfqQG6vmcjr2GfQHCB2HarpXuHiQHaql6O1jTzw5k7WFVXwvL2i6JbiKk4bM5ATC3I4r8Us49pGf6i/wcm4wRns/NlFbC2tihhFFM2osE7nsqoGyqoamJRAK8kq1VtiOhgEZxQ7NRO1t1mKU81gmN1pCfCry6d0q2zxYFBmMvuP1PHsB5Griq/afSQ0hPTnl53IVTNHho7VNfpDk8iicbmEiUM69kC/6MShoXkLF/z+TQ7XNLLie3PJz0pp50ylVGfERTOROIwnCh6L1nfgNFpoqD2q5cIThjBzdG5PFTNmucTaBrMtT6/eF/G+ptFHehvNRJ01aVgWf7xqGkBon4UlG0t67PpKKUtMBwN/G30Gz314gCZ/IOoKpl6H0UQiwoYfnR96+CS6j580rN08GckefP4Aj63YQ02Dj5KKBvKze/Zb+yenDGNAmjf0/gfPreebT36gW2Uq1YNiOhgEQn0Gzsfb2lgl2jyC9GRPwg8rDfrCGaOjHrtr/mSmjsjhSG0j7+08zO3/Wc/kO16h0R9gWHZq1PO66kht5Gf53IcH2FysS1Yo1VNi+qnXXDNwfrB7XNJqcTqvW5g4JDOif0BFl53qjXj/8PWn8KUzx/C50woZOyiD8urGVstOn1SQTU97asGs0Oshdn9BSVV9j/8dpRJVXHQgR+PUl/Cp6QXc/amTjlGJ4k+q1x1Rwzr7uMGcfdxgwJqYVtXgC607BPCx8XlMGzmgx8txSmEu5x6fzxfOKGRkbhpn/GIZpZUaDJTqKTFdMwi0UzMwmFYdyAm4eVm3nDNxcNRj6cluahv97A+rGXx73nHHpBwul/C362Zw+ti80FpGJZUNx+RvKZWIYjoY+NvpM3DqPE7ErSy740efnMySm88EmhefC0pL8uAPGHaW1TB9ZA6LFs5myoicY16mZI+b3PQkSrRmoFSPielmovb6DALGtOoz0FDQOUkeFxPyM9n44/NJatGxHhxCuq2kinMn5fdKIAganJlMcYUGA6V6SkzXDNobTWRoXTuIFjhU29KSPK0m6gXXhqrpwESznjalIIe3th+ivqnt1WmVUh0T08HAH5p05sy5mejYlSfRpIctOzGkl2cEnz5uII2+AJ++771e/btKxauYDgY+v/W0d1paAqzZxy0birRm0HMKBjQPz7329FF98rfXFVVEpB+qbmC1LnmtVKfFdDBosoOBO+poInUsTR6WzZQROdx3zXSSPT23BEVHTLeHr2anetlRVg1AeU0jM37yKpff954OO1Wqk2I6GPjsiQZOu5aB3YGsfQbHjNslLFo4mwtO6P19BkSET00voKKuibm/eQOA/9qrqgLc/+bOXi+TUrEstoNBqJkoSs1A+wziWl5mUuh1IGC44/kNofdPrd4XdZHCqvomHZaqVAsxHQya/G3XDJweBQm+gVlcyUtvHsEUPkv6tgsnUlXv4x/L9zie9/UnPuDUn73WahkNpRJZTAcDX6DtPoNAoHUzkU46ix/hH+V+e0mMuy87kfMnDwHgh4s2MOH2l1udt7XE6mP46Yub2t0eValEEdPBIDgDOVrNwInGgvgxZlDztpmf+PPbAORnp1CYl86EfGsXtUZ/oNVS18PtkUgvrjvIA29p34JSEOPBIKitPoOWQ0udFq9TsWnOxHy+dNaYiLTg8tmzxgwMpVWF7eMMUF3vIy/D6m+I1pSkVKKJi2DQ1nIUrfMe69Ko3nTptOER748bkglEbsyz+3DkftZVDU2cMS6P/7vgOPaV1+m8BKXoQDAQkYdEpFRE1oel5YrIUhHZZv8eYKeLiPxRRLaLyHEeS30AABrjSURBVFoRmR52znV2/m0icl1Y+skiss4+54/ShUZ9j8OuZWB1IK/cFfk/ug4tjS8Th2Sx/La5AFxg9xUAnFI4gMtPLgBg/l/e4WittWXmm1vL2FdeR2aKl+OHWvswX66zmJXqUM3gYeCCFmm3Aq8ZY8YDr9nvAS4Exts/C4B7wQoewB3AqcBM4I5gALHzfDHsvJZ/q11tzTP4/N9XRaRpLIg/Q7JTWH7bXH59xZRQmohw1/wTQu93lFXz9rZDXPvQSgBSk9x8bFwemSkxvVajUj2m3WBgjHkTaFmPng88Yr9+BLgkLP1RY1kO5IjIUOB8YKkxptwYcwRYClxgH8syxiw31rCOR8Ou1WGdm2eg0SAeDclOISM58sGemuTmvzedAcC6/RVc8+CK0LERA1LxuF0s+JjV59Dg0wXvVGLrap9BvjHmoP26GAgudD8c2BeWb7+d1lb6fof0Tone9NM6GmgoSCzjBmeQnuTmzv9uDKWNH5zB1adaaykNtFdbLa9p7JPyKdVfdLsD2f5G3yuDtUVkgYisFpHVrrA/6YnaTNQ6TfsMEktqkpufXHpCRNqVM0eGmhaDo4oOVWkwUImtq8GgxG7iwf5daqcXASPC8hXYaW2lFzikOzLG3G+MmWGMmZGV2rwUQdQZyLochQIunVbAytvncu1pVm1gZmFu6FievYXmoRrdQlMltq4Gg+eB4Iig64BFYenX2qOKZgEVdnPSK8A8ERlgdxzPA16xj1WKyCx7FNG1YdfqsKh9Bg4VFh1ampgGZ6Zwxycms/J7czmxIDuUHlzS4lCVBgOV2NodSiEiTwBnA3kish9rVNDdwNMicgOwB7jCzv4ScBGwHagFrgcwxpSLyF1AcGjPj40xwU7pr2KNWEoFXrZ/OiXqPIOA4/109vIqTrhdwuAWm/AEF7s7VK3NRCqxtRsMjDFXRTk01yGvARZGuc5DwEMO6auBE1qf0Y6wZ3pwwbpW13bqQNZYoMKkJXlIS3JzqFprBiqxxcUM5OBS1i059hnoeCLVQl5GsgYDlfBiNhiEP9STPNG2vWydpn0GqqVhOSlsPFCpK5iqhBazwSBccFmBlrSZSHXE/KnD2VZazQf7jvZ1UZTqMzEfDGaPGxj1mM4zUB1x0YlDEbHWLVIqUcV8MGjr4a7VftUR2aleJg3NYsVOXb1UJa6YDQbBGNBmMHBI05qBcjJtZA4bD1b2dTGU6jMxGwyC2uoQdqoZaCxQTgZnplBR10RlfVP7mZWKQ3EQDCKf7gPSvKHXzqOJNBqo1gbaaxSddOcSbV5UCSnmg0HLGcWvf+ccfv1pa117pw5kjQXKSX5m88zk9UXaXKQST8wGg+Az3d3iDrJTvQzNtv7HdvqG13JzdKUAzpk4mF9+6iQAnlmzr53cSsWfmA0GQU7NPsEkp8f+hgP6rU+15nYJV5wygpmFuWwqrurr4ijV6+IzGNj1hoBDzaC6wXfMy6RiV352CqWV9aH3gYBhX3ltH5ZIqd4Rs8Eg2Ffg1AcQTHNatbSqXoOBii4/M5ndh2vZUVYNwBOr9vKxXy7jI52drOJczAYDVxvzDIJpPodokBM22kipls4+bjAAH+y1Hv7riyoAeGfHoT4rk1K9IYaDQfQHfjA++B06i++a3/nVslXiOGX0AAD2H7GahoJBobiiPuo5SsWDmA0GwQd+Q1PrYBCsNTQ5LG2tNQPVlmSPm4IBqSzZUEJ9k5/NdmdysNlIqXgVs8EgWDNo8DltbGMdc6oZ6E5nqj2njRnIxoOV/PqVLQBkJHt4Z/thbnxkVTtnKhW7Yj4YNDoEg+Dz3qkJSan2/Gj+ZPKzknnwnV0A3HzeBABe3VSqI4tU3IrhYGD9bnDY8jLUnxBlBzSl2pKW5OGmOeNDy5mMHZTOv79yOgDbS7W5SMWndvdA7q+CzT0NTf7Wx+zf0fZGVqo9k8I2TJo+agDV9pDkg9qRrOJUzAaDYM2grWaieodAoVRHTB2Rw3cvmMgVMwrISvGS5nXjEiiuqOvroil1TMRwMIjegRw8Vu/YuaxU+9wu4Stnjw2997hdDM5M4YDWDFSciuE+A7sDuY2mIK0ZqJ40JDuFg1ozUHEqZoNB8zyD1g/8UM3AYQ6CUl11/NAsVu8+outbqbgUs8HA5YreTKR9BupYmD4yhwZfgCM1jX1dFKV6XOwGg2DNoI1g4DwhTamuSfG6AajTLxkqDsVwMIg+k9jVxrBTpboq1Q4GWuNU8Shmg0HQtaeNapUWDBP1Pv2fVvWclFAw6FiNc+3+o9z7+g4CAUNpVT3v7z3CVfcvp6q+6VgWU6kuidmhpQC7fn6R41pDzX0G2kykek5qkvXdqaPNRJ//+yrKaxr5xeLNEemL1xfz6Rkjerx8SnVHTNcMoi06F2wmqmts/p92xqgBPH7jqb1SLhWfkj2dayZq2ZRZODANgE0HdVtN1f/EdDCIxuu2bqshrJlo6ogcTh+X11dFUnEg2Ez03AdF/OqVzVQ3+KIGhvf3HuFQdUPo/fM3zeb175zDicOz2VqiwUD1PzHdTBSN22HYqS5Zp7orNckKBi+vLwbgL8t2MGVEDosWzm6V940tZVaeq6czOCuZkwpyADhuSCav28eU6k+6VTMQkd0isk5EPhSR1XZarogsFZFt9u8BdrqIyB9FZLuIrBWR6WHXuc7Ov01EruveLYHHHZx01vytzWg0UN00JCuFvIykiLSP9h3l839fyerd5aG0QMCwdGMJw7JTuPikoZxSmBs6NnFIJoeqG3Sugup3eqKZ6BxjzFRjzAz7/a3Aa8aY8cBr9nuAC4Hx9s8C4F6wggdwB3AqMBO4IxhAusrjsm5LO5BVT3K7hHs+ezJfnzOOP1w5lakjrG/7r28p44eLNoTy/f7VrWw8WMlxQzJbXWPs4AwAtuvOaaqfORZ9BvOBR+zXjwCXhKU/aizLgRwRGQqcDyw1xpQbY44AS4ELulOA5maisJqBNhSpHjBzdC7fmncc86cO58kFs7hq5kgANh6s5MZHVnHfGzv415r9APziUye1Or9wYDoANzy8KmKAg1J9rbvBwABLRGSNiCyw0/KNMQft18VAvv16OLAv7Nz9dlq09FZEZIGIrBaR1WVl0dtdve7WaxNpM5HqaSleNz+/7ERuCdsJ7e6XN3Owop6vzx3P4KyUVucMzbbSKut9fOWxNby741Do2JbiKj734Ao2HqjsnRtQKkx3O5DPMMYUichgYKmIRAyoNsYYEemxx7Ax5n7gfoAZM2ZEva5TzUCpY+XGj41h0rAskj1urnlwBQCDMpMd8wZHJIHVvPT6ljJ2330xAC+uO8hb2w5xUsEBJg3LcjxfqWOlWzUDY0yR/bsU+A9Wm3+J3fyD/bvUzl4EhM+0KbDToqV3mdfuM2jSbS9VL0hNcjP3+HzOGJ/HjWeMBmBQi47mcK9/+2z+cOXU0PvF9uikHXY/QnFFg+N5Sh1LXQ4GIpIuIpnB18A8YD3wPBAcEXQdsMh+/TxwrT2qaBZQYTcnvQLME5EBdsfxPDuty1wuoeV8NKPtRKoXfO+i43nsxlM59/j8qHkK89KZP3U4910znfysZH6zZAsAa3YfAeDf7+/nu8+s1b0TVK/qTjNRPvAfexawB3jcGLNYRFYBT4vIDcAe4Ao7/0vARcB2oBa4HsAYUy4idwGr7Hw/NsY0j9PrIo9LImoGGgpUb3C5hNkdnNx4wQlDKTpaz10vbOSbT35AcWU9M0fnsnJXOU+t3offGH796SnHuMRKWbocDIwxO4FW/6UaYw4Dcx3SDbAwyrUeAh7qalmceFwumvzaZ6D6tytmFPDEyr089+EBAC4/uYDPnjqS2/+znk0HtSNZ9Z64XI4CrJpBOG0lUv1RZoqXV755Zuj9kKwU5k8dzjkTB+vQU9Wr4nI5CmiehRyk8wxUf+V2Cf+75SxeXHuQWWMGApDmdVPTqNtrqt4Tt8HA7YrbSo+KQ2MGZfC1ueND71OT3NRqzUD1ooR5YmozkYol6clubSZSvSpug0H48sGgo4lUbElL8uALGBavP8hflm3HH9D/gtWxFbfNRC1pzUDFkuB+y1/+5/sATBqWxTnHDe7LIqk4F7c1g6AFZ47p6yIo1WnnTYqctHb931ex/0htH5VGJYK4DQaPfGEmXzprDKPsrQa1oUjFkhG5aay7cx5fmzOOdHtTnYWPf9DHpVLxLG6DwVkTBnHbhccjWENMtZlIxZrMFC+3zDuOh78wE4Ddh2r6uEQqnsVtMAhquUaRUrHmlMJcvn/x8VTUNekOaeqYiftgEKQ1AxXLxgyyNsXZeUh3SFPHRtwHg2DFQGcgq1g2Os/aLnNHWftNRYvXF7O+qOJYF0nFmbgfWhpsJtKagYplIwakkuJ18ZMXNlJZ18TJowYwbWTrrcLLaxr58j/XAPDRHfPITvX2dlFVjEqAmoF2GqjY53G7+MOV08hI9vCTFzdx6T3v8vOXN7XKt3zn4dDrKT9awmubSnRfBNUhcR8MgrRioGLd+ZOH8NZ357D05jOZPjKHv76xk/ve2BGRZ+WucpI8Lj423tpT4YZHVnPxH98+Jps7GWOorG/q8euqvhH3wWDe5HwmDsnkq2eP7euiKNVtbpcwPj+TheeMA+Dulzfz7Pv7Q8ff3XGImYW5/OOGU5k/dRhgNR0VHe3Z2oE/YPjM/cs56c4lvLfjcPsnABV1TazYeZi3tpXx0b6jbCmu6tEyqe6J+z6DnLQkFoetF69UPJgzcTB/uXo6Cx9/n9v/s54xgzI4UtPI1pJqLp1WAMAvPnUSZx83iJuf+ogdZTUMzU5lfVEFk4Zl4XVb3wMbfH58fkN6cuceBR/tP8rKXdaGhHc+v4HF3/wY4jCOe+nGEn65eDN+Y9h9qIbwJZZSvC6e+OIsTirIoaKuifRkN8kedxf/RVR3xX0wUCoeiQgXnzSUVbsLefjd3Vzyl3cAyM9K5vrZhQCkeN3MHms1Fz33QRHXPbQSgNsvOp4v2su0/HLxFh58exdfmzOOb547AberY31s/3m/iCSPi0ZfgC0lVfxw0QbuuuQEiivqyUnzkuJ1U1JZzxcfXQ1Yay3dcMZoTh+XR5Lbxdr9FTzw1k4uvefd0DXPPT6fv103I+rfNMawZGMJv12ylXqfn0+fbAW96aMGMKUgJxTQ6pv8vLTuILsP13LNrJE8+u4eLpk2jHGDMx2vW9foJzVJg5DE6kbxM2bMMKtXr+7rYijVpx5bsYfb/7M+9P4bc8dz83kTQu+NMZzxi2Wtmone+r9zGJyVzHHfXxxK++HHJ/GFM0a3+fdW7iqnrsnPzU99yGljB1LX6Od/m0tJT3Lz6A2nctUDy0lyuzh51ADe2FoGwNfnjGPhnHGtvvXvOlTD959bR7LHzf82lwIwbnAG15w6khMLshmfn0lWSvNoqCdX7uXWZ9c5lsvrFtb84Dx+v3QbD72zq9Vxj0u4ZtYoiivqSUtyk+x1s/FABWlJHt7beZhFC2czZUROm/ceL0RkjTGmVdTVYKBUDKuobeKye98JzT+48xOT+PzsyAf6ss2lfOPJD/jqOeN4f88RXt1UEtFcc/nJBWw8UEl2qpdRA9P4zCkjmDoiJ6LZ5/29R7j6geXUNwVCaX++ehrzJg1h5a5yrnlwRSg92eOiwRcgNz2Jr80ZxzWzRoWapaJp8PkjAlPQwnPG8p3zJwJw5i+XkeJ1cd81J9PkN2wpqeL1zaU8+0ERAJdMHRbaS9olMGVEDvmZKZw+biCvbirlTTs4Dc9Jpay6gUZfIOJvTcjP4OZzJ1CYl86wnNSYG5a7ubiSj/YdZUZhLmMHZUTNp8FAqThljOGZNftZuaucuy45gRRv6yaPQMDgspuAfrd0K394bVvo2IYfnc//PbOWF9cdDKUle1wYA988bzxfPXscCx9/nxfXWsevmTWSAWlJfGPueDz2Q/7p1ft4etU+vj53PCePGoAvYDr9MP3He7t5d8dhrp89mlc3lXD/mzsBGJSZzOUnF3Dv6zsimriC6hr9HP/D5kDy+dML+f7Fx4fKBlBW1cCNj6wiM8XLP288NZR+pKaRPeW13Pf6DhZvKI647vcvPp7Pn14YcZ3esrOsmp+9tBkRuGXeBCYOyQKgyR/g10u2UF3v45NThjF5eDYZyR7++9EBvvaEtZBhktvFZ2eN5LQxA5k3eUira2swUEoB1gNlyYYSzj5uEEVH65iQn8k/3tvNDxZtAOCMcXmMGZTO/zaXUlHbxLu3zeGye95lW2k1b3znbEYNTO+Vch6qbuBrj3/A1pIqDtc04nYJ//7K6Ux1aM756xs7+PnLmzl97ED+ecOpocDXGSWV9Ty2fA85aUn8+IWNAIwfnMGc4wdz1vhBnD4uL5S3oq6JQMAwID2p6zcYxaHqBq647z122gsTul1CbnoSXpdQ2+TnaG304bxnTRhEZX0TH+w9CsCtF07ky2dFjqTUYKCUalNxRT0D0r2htv3XNpVwwyPN/499fe54vhXWH9FbjDFU1vlI9rocaz1gBbiNByoZn59BWlL3x8VU1jfxzOr9/GP5HnbZD+WrZo7ksunD2XSwkl8u3kJ6sptl3z6723/vvR2HKTpax+V2h/gvF2/mntd3cN8105k+agAPvr2LIzWNvLn1EMWV9eRlJPPUl2bx2QdWUFxZH7rOb6+YwmXTrWvUNvq45emPWLyhmDPG5fGry6dwqLqB5TsP88Uzx2owUEp1nM8fYNztL4feP/qFmZw5YVAflqhvVNQ1MfOnr9LQoo8BrCapOz85uVvXL7z1xdDrv19/Ck+u3Mv20mpeu+XsiHx1jX62llSRl5nM8JxUAgFDaVUDW0uqmJCfyZDslIj81Q0+7n9zJ/cs286JBdnsP1JHWVUDe37xccdgoENLlVKOPG4Xd82fzN/f2c2I3DRmjRnY10XqE9mpXhZ/80xe21SC2yXMGJXL2MHpfOdfa3n43d08/O5uThiexSmFudx0zjgGZiR3+NpVLWZwX//3VQBcfOLQVnlTk9wRI55cLmFIdkqrIBCUkezhW+dNYNPBSpZuLGm3LFozUEqpLlizp5z/e2ZtxEqyV54ygrs/dRLGGB5fuZfHV+xl1MA0xg/OpLSqgW+dN4Gq+iY+3HeUucfnc8vTH/LqplIevv4Uqup9oU7g/950BicWZPdIOfeV1/LEyr3c8/oOHr7+FM6ZmK/NREop1dMOVzfw0f6jPPfBAZ7/6ADzJuVT0+jjne2tl+lYcOYYnly5l8p6H6Pz0tl1qIZTCgfw1ILTcLmE9/ceYVBGMiNy0xz+UvcYYxCRqB3I2kyklFLdMDAjmTkT8zl5VC41DT6WhDXJbP3JhfzkxY34AoZNBytDw2U/Nb2Af9trSp0/eUho9NN0h2XJe4rTciHhNBgopVQPyE718qerp7Fscxl+YxiQ5iXJ4+LH808AYPXucv7zQRED0pK4+bwJ3Pix0Ty9eh8fP2lYH5fcos1ESimVQKI1E8X9EtZKKaXap8FAKaVU/wkGInKBiGwRke0icmtfl0cppRJJvwgGIuIG/gJcCEwCrhKRSX1bKqWUShz9IhgAM4HtxpidxphG4Elgfh+XSSmlEkZ/CQbDgX1h7/fbaRFEZIGIrBaR1WVlZb1WOKWUinf9JRh0iDHmfmPMDGPMjEGDEm/BLKWUOlb6SzAoAkaEvS+w05RSSvWCfjHpTEQ8wFZgLlYQWAVcbYzZ0MY5VcCW3ilhn8sDDvV1IXpJIt0rJNb96r32D6OMMa2aVvrFchTGGJ+I3AS8AriBh9oKBLYtTrPo4pGIrNZ7jU+JdL96r/1bvwgGAMaYl4CX+rocSimViPpLn4FSSqk+FMvB4P6+LkAv0nuNX4l0v3qv/Vi/6EBWSinVt2K5ZqCUUqqHaDBQSikVe8Eg3lY3FZERIrJMRDaKyAYR+YadnisiS0Vkm/17gJ0uIvJH+/7Xisj0vr2DzhMRt4h8ICIv2O9Hi8gK+56eEpEkOz3Zfr/dPl7Yl+XuChHJEZFnRGSziGwSkdPi9bMVkZvt/4bXi8gTIpIST5+tiDwkIqUisj4srdOfpYhcZ+ffJiLX9cW9OImpYBCnq5v6gFuMMZOAWcBC+55uBV4zxowHXrPfg3Xv4+2fBcC9vV/kbvsGsCns/S+A3xljxgFHgBvs9BuAI3b67+x8seYPwGJjzERgCtZ9x91nKyLDga8DM4wxJ2DNF7qS+PpsHwYuaJHWqc9SRHKBO4BTsRbovCMYQPqcMSZmfoDTgFfC3t8G3NbX5erhe1wEnIc1u3qonTYUa5IdwF+Bq8Lyh/LFwg/WUiOvAXOAFwDBmqnpafkZY01CPM1+7bHzSV/fQyfuNRvY1bLM8fjZ0rzYZK79Wb0AnB9vny1QCKzv6mcJXAX8NSw9Il9f/sRUzYAOrm4aq+yq8jRgBZBvjDloHyoG8u3Xsf5v8Hvg/4CA/X4gcNQY47Pfh99P6F7t4xV2/lgxGigD/m43i/1NRNKJw8/WGFME/BrYCxzE+qzWEL+fbVBnP8t++xnHWjCIWyKSAfwb+KYxpjL8mLG+QsT8GGAR+ThQaoxZ09dl6SUeYDpwrzFmGlBDczMCEFef7QCsPUhGA8OAdFo3qcS1WP8sYy0YxOXqpiLixQoEjxljnrWTS0RkqH18KFBqp8fyv8Fs4JMishtrA6M5WG3qOfZihRB5P6F7tY9nA4d7s8DdtB/Yb4xZYb9/Bis4xONney6wyxhTZoxpAp7F+rzj9bMN6uxn2W8/41gLBquA8fYIhSSsDqrn+7hM3SIiAjwIbDLG/Dbs0PNAcKTBdVh9CcH0a+3RCrOAirBqar9mjLnNGFNgjCnE+uz+Z4z5LLAMuNzO1vJeg/8Gl9v5Y+ablzGmGNgnIsfZSXOBjcThZ4vVPDRLRNLs/6aD9xqXn22Yzn6WrwDzRGSAXZuaZ6f1vb7utOhCB85FWMtd7wBu7+vy9MD9nIFVtVwLfGj/XITVfvoasA14Fci18wvWiKodwDqs0Rt9fh9duO+zgRfs12OAlcB24F9Asp2eYr/fbh8f09fl7sJ9TgVW25/vc8CAeP1sgR8Bm4H1wD+A5Hj6bIEnsPpDmrBqfTd05bMEvmDf93bg+r6+r+CPLkehlFIq5pqJlFJKHQMaDJRSSmkwUEoppcFAKaUUGgyUUkqhwUAppRQaDJRSSgH/D97FkNzcAaVKAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "performance.net_worth.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", "output_type": "stream", "text": [ - "\n" + "5 20\n", + "(20, 5)\n", + "(20, 5)\n", + "Finished running strategy.\n", + "Total episodes: 0 (1665 timesteps).\n", + "Average reward: -1.5838337217509488.\n" ] }, { @@ -186,72 +635,94 @@ " \n", " \n", " \n", - " 60\n", - " 7869.041315\n", - " 19550.777113\n", + " 1121\n", + " 85.738669\n", + " 435.311769\n", " \n", " \n", - " 61\n", - " 1918.192763\n", - " 19800.868234\n", + " 1122\n", + " 21.980809\n", + " 433.986105\n", " \n", " \n", - " 62\n", - " 1446.728402\n", - " 20111.817204\n", + " 1123\n", + " 10.888181\n", + " 435.384760\n", " \n", " \n", - " 63\n", - " 15478.289016\n", - " 20169.594866\n", + " 1124\n", + " 218.819849\n", + " 430.554298\n", " \n", " \n", - " 64\n", - " -86.822099\n", - " 20026.456292\n", + " 1125\n", + " 110.904600\n", + " 431.262282\n", " \n", " \n", "\n", "" ], "text/plain": [ - " balance net_worth\n", - "60 7869.041315 19550.777113\n", - "61 1918.192763 19800.868234\n", - "62 1446.728402 20111.817204\n", - "63 15478.289016 20169.594866\n", - "64 -86.822099 20026.456292" + " balance net_worth\n", + "1121 85.738669 435.311769\n", + "1122 21.980809 433.986105\n", + "1123 10.888181 435.384760\n", + "1124 218.819849 430.554298\n", + "1125 110.904600 431.262282" ] }, - "execution_count": 6, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "performance = strategy.run(steps=100, evaluation=False)\n", + "from tensortrade.environments import TradingEnvironment\n", + "from tensortrade.strategies import StableBaselinesTradingStrategy\n", + "from tensortrade.exchanges.simulated import SimulatedExchange\n", + "\n", + "WINDOW_SIZE = 20\n", + "\n", + "exchange = SimulatedExchange(base_instrument='USD',\n", + " data_frame=ohlcv_data,\n", + " price_column='close',\n", + " window_size=WINDOW_SIZE,\n", + " pretransform=True)\n", + "\n", + "environment = TradingEnvironment(exchange=exchange,\n", + " action_scheme=action_scheme,\n", + " reward_scheme=reward_scheme,\n", + " feature_pipeline=feature_pipeline)\n", + "\n", + "strategy = StableBaselinesTradingStrategy(environment=environment,\n", + " model=model,\n", + " policy=policy,\n", + " model_kwargs=params)\n", + "\n", + "performance = strategy.run(steps=1665)\n", "\n", "performance[-5:]" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 9, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -266,22 +737,22 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 10, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -296,11 +767,11 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ - "strategy.save_agent(directory='agents')" + "strategy.save_agent('agents/PPO_BTC_1h')" ] }, { diff --git a/tensortrade/actions/action_scheme.py b/tensortrade/actions/action_scheme.py index 03004fb67..7f8972801 100644 --- a/tensortrade/actions/action_scheme.py +++ b/tensortrade/actions/action_scheme.py @@ -31,11 +31,11 @@ class ActionScheme(Component): registered_name = "actions" @abstractmethod - def __init__(self, action_space: Space, dtype: DTypeString = np.float16): + def __init__(self, action_space: Space, dtype: DTypeString = np.float32): """ Arguments: action_space: The shape of the actions produced by the scheme. - dtype: A type or str corresponding to the dtype of the `action_space`. Defaults to `np.float16`. + dtype: A type or str corresponding to the dtype of the `action_space`. Defaults to `np.float32`. """ self._action_space = action_space self._dtype = self.context.get('dtype', None) or dtype diff --git a/tensortrade/actions/continuous_actions.py b/tensortrade/actions/continuous_actions.py index d7405b249..56d18f50b 100644 --- a/tensortrade/actions/continuous_actions.py +++ b/tensortrade/actions/continuous_actions.py @@ -31,13 +31,13 @@ class ContinuousActions(ActionScheme): instrument: A `str` designating the instrument to be traded. Defaults to 'BTC'. dtype: A `type` or `str` corresponding to the dtype of the `action_space`. - Defaults to `np.float16`. + Defaults to `np.float32`. """ def __init__(self, instrument: str = 'BTC', max_allowed_slippage_percent: float = 1.0, - dtype: DTypeString = np.float16): + dtype: DTypeString = np.float32): super().__init__(action_space=Box(0, 1, shape=(1, 1), dtype=dtype), dtype=dtype) self._instrument = self.context.get('instruments', instrument) diff --git a/tensortrade/exchanges/exchange.py b/tensortrade/exchanges/exchange.py index 5b7dcbaf6..d1b16d3a7 100644 --- a/tensortrade/exchanges/exchange.py +++ b/tensortrade/exchanges/exchange.py @@ -17,7 +17,7 @@ from abc import abstractmethod from typing import Dict, Union, List -from gym.spaces import Space +from gym.spaces import Box from tensortrade import Component from tensortrade.trades import Trade @@ -36,11 +36,17 @@ class Exchange(Component): """ registered_name = "exchanges" - def __init__(self, dtype: TypeString = np.float16, feature_pipeline: FeaturePipeline = None): + def __init__(self, dtype: TypeString = np.float32, feature_pipeline: FeaturePipeline = None, **kwargs): self._base_instrument = self.context.base_instrument self._dtype = self.default('dtype', dtype) self._feature_pipeline = self.default('feature_pipeline', feature_pipeline) + self._window_size = self.default('window_size', 1, kwargs) + self._min_trade_amount = self.default('min_trade_amount', 1e-6, kwargs) + self._max_trade_amount = self.default('max_trade_amount', 1e6, kwargs) + self._min_trade_price = self.default('min_trade_price', 1e-8, kwargs) + self._max_trade_price = self.default('max_trade_price', 1e8, kwargs) + @property def base_instrument(self) -> str: """The exchange symbol of the instrument to store/measure value in.""" @@ -118,23 +124,23 @@ def performance(self) -> pd.DataFrame: @property @abstractmethod - def generated_space(self) -> Space: - """The initial shape of the observations generated by the exchange, before feature transformations.""" + def observation_columns(self) -> List[str]: + """The final columns provided by the observation space, after any feature transformations.""" raise NotImplementedError @property - @abstractmethod - def generated_columns(self) -> List[str]: - """The list of column names of the observation data frame generated by the exchange, before feature transformations.""" - raise NotImplementedError + def observation_space(self) -> Box: + """The final shape of the observations generated by the exchange, after any feature transformations.""" + n_features = len(self.observation_columns) - @property - def observation_space(self) -> Space: - """The final shape of the observations generated by the exchange, after feature transformations.""" - if self._feature_pipeline is not None: - return self._feature_pipeline.transform_space(self.generated_space, self.generated_columns) + low = np.tile(self._min_trade_price, n_features) + high = np.tile(self._max_trade_price, n_features) + + if self._window_size > 1: + low = np.tile(low, self._window_size).reshape((self._window_size, n_features)) + high = np.tile(high, self._window_size).reshape((self._window_size, n_features)) - return self.generated_space + return Box(low=low, high=high, dtype=self._dtype) @property def net_worth(self) -> float: diff --git a/tensortrade/exchanges/live/interactive_brokers_exchange.py b/tensortrade/exchanges/live/interactive_brokers_exchange.py index 10d7b03cb..9a8c05271 100644 --- a/tensortrade/exchanges/live/interactive_brokers_exchange.py +++ b/tensortrade/exchanges/live/interactive_brokers_exchange.py @@ -29,7 +29,7 @@ class InteractiveBrokersExchange(Exchange): def __init__(self, **kwargs): super().__init__( - dtype=self.default('dtype', np.float16, kwargs), + dtype=self.default('dtype', np.float32, kwargs), feature_pipeline=self.default('feature_pipeline', None, kwargs) ) # TODO: Initialize the Interactive Brokers client @@ -87,7 +87,7 @@ def performance(self) -> pd.DataFrame: raise NotImplementedError @property - def generated_space(self) -> Space: + def observation_columns(self) -> List[str]: # TODO raise NotImplementedError diff --git a/tensortrade/exchanges/live/robinhood_exchange.py b/tensortrade/exchanges/live/robinhood_exchange.py index 219b3ddce..e1b56ad98 100644 --- a/tensortrade/exchanges/live/robinhood_exchange.py +++ b/tensortrade/exchanges/live/robinhood_exchange.py @@ -28,7 +28,7 @@ class RobinhoodExchange(Exchange): """An exchange for trading using the Robinhood API.""" def __init__(self, **kwargs): - super().__init__(dtype=self.default('dtype', np.float16, kwargs), + super().__init__(dtype=self.default('dtype', np.float32, kwargs), feature_pipeline=self.default('feature_pipeline', None, kwargs)) # TODO: Initialize the Robinhood client @@ -85,7 +85,7 @@ def performance(self) -> pd.DataFrame: raise NotImplementedError @property - def generated_space(self) -> Space: + def observation_columns(self) -> List[str]: # TODO raise NotImplementedError diff --git a/tensortrade/exchanges/simulated/fbm_exchange.py b/tensortrade/exchanges/simulated/fbm_exchange.py index a09af367a..9150929b5 100644 --- a/tensortrade/exchanges/simulated/fbm_exchange.py +++ b/tensortrade/exchanges/simulated/fbm_exchange.py @@ -33,6 +33,7 @@ class FBMExchange(SimulatedExchange): def __init__(self, **kwargs): super().__init__(data_frame=None, **kwargs) + self._base_price = self.default('base_price', 1, kwargs) self._base_volume = self.default('base_volume', 1, kwargs) self._start_date = self.default('start_date', '2010-01-01', kwargs) @@ -41,6 +42,8 @@ def __init__(self, **kwargs): self._hurst = self.default('hurst', 0.61, kwargs) self._timeframe = self.default('timeframe', '1h', kwargs) + self._generate_price_history() + def _generate_price_history(self): try: price_fbm = FractionalBrownianMotion(t=self._times_to_generate, hurst=self._hurst) diff --git a/tensortrade/features/feature_pipeline.py b/tensortrade/features/feature_pipeline.py index 78f279202..aab9de3db 100644 --- a/tensortrade/features/feature_pipeline.py +++ b/tensortrade/features/feature_pipeline.py @@ -36,7 +36,7 @@ def __init__(self, steps: List[FeatureTransformer], **kwargs): """ self._steps = steps - self._dtype: DTypeString = self.default('dtype', np.float16, kwargs) + self._dtype: DTypeString = self.default('dtype', np.float32, kwargs) @property def steps(self) -> List[FeatureTransformer]: @@ -61,36 +61,18 @@ def reset(self): for transformer in self._steps: transformer.reset() - def transform_space(self, input_space: Space, column_names: List[str]) -> Space: - """Get the transformed output space for a given input space. - - Args: - input_space: A `gym.Space` matching the shape of the pipeline's input. - column_names: A list of all column names in the input data frame. - - Returns: - A `gym.Space` matching the shape of the pipeline's output. - """ - output_space = input_space - - for transformer in self._steps: - output_space = transformer.transform_space(output_space, column_names) - - return output_space - - def _transform(self, observations: pd.DataFrame, input_space: Space) -> pd.DataFrame: + def _transform(self, observations: pd.DataFrame) -> pd.DataFrame: """Utility method for transforming observations via a list of `FeatureTransformer` objects.""" for transformer in self._steps: - observations = transformer.transform(observations, input_space) + observations = transformer.transform(observations) return observations - def transform(self, observation: pd.DataFrame, input_space: Space) -> pd.DataFrame: + def transform(self, observation: pd.DataFrame) -> pd.DataFrame: """Apply the pipeline of feature transformations to an observation frame. Arguments: observation: A `pandas.DataFrame` corresponding to an observation within a `TradingEnvironment`. - input_space: A `gym.Space` matching the shape of the pipeline's input. Returns: A `pandas.DataFrame` of features corresponding to an input oversvation. @@ -99,7 +81,7 @@ def transform(self, observation: pd.DataFrame, input_space: Space) -> pd.DataFra ValueError: In the case that an invalid observation frame has been input. """ obs = observation.copy(deep=True) - features = self._transform(obs, input_space) + features = self._transform(obs) if not isinstance(features, pd.DataFrame): raise ValueError("A FeaturePipeline must transform a pandas.DataFrame into another pandas.DataFrame.\n \ diff --git a/tensortrade/features/feature_transformer.py b/tensortrade/features/feature_transformer.py index f35003a45..da1380b2c 100644 --- a/tensortrade/features/feature_transformer.py +++ b/tensortrade/features/feature_transformer.py @@ -15,7 +15,6 @@ import pandas as pd import numpy as np -from gym import Space from copy import copy from typing import List, Union from abc import ABCMeta, abstractmethod @@ -37,7 +36,6 @@ def __init__(self, columns: Union[List[str], str, None] = None, inplace: bool = self.columns = self.default('columns', columns) self._inplace = self.default('inplace', inplace) - @property def columns(self) -> List[str]: return self._columns @@ -53,41 +51,12 @@ def reset(self): """Optionally implementable method for resetting stateful transformers.""" pass - def transform_space(self, input_space: Space, column_names: List[str]) -> Space: - """Get the transformed output space for a given input space. - - Args: - input_space: A `gym.Space` matching the shape of the pipeline's input. - column_names: A list of all column names in the input data frame. - - Returns: - A `gym.Space` matching the shape of the pipeline's output. - """ - if self._inplace: - return input_space - - output_space = copy(input_space) - columns = self.columns or column_names - - shape_x, *shape_y = input_space.shape - output_space.shape = (shape_x + len(columns), *shape_y) - - for column in columns: - column_index = column_names.index(column) - low, high = input_space.low[column_index], input_space.high[column_index] - - output_space.low = np.append(output_space.low - output_space.high, low) - output_space.high = np.append(output_space.high, high) - - return output_space - @abstractmethod - def transform(self, X: pd.DataFrame, input_space: Space) -> pd.DataFrame: + def transform(self, X: pd.DataFrame) -> pd.DataFrame: """Transform the data set and return a new data frame. Arguments: X: The set of data to transform. - input_space: A `gym.Space` matching the shape of the pipeline's input. Returns: A transformed data frame. diff --git a/tensortrade/features/indicators/simple_moving_average.py b/tensortrade/features/indicators/simple_moving_average.py index 06ba0f21f..55b751844 100644 --- a/tensortrade/features/indicators/simple_moving_average.py +++ b/tensortrade/features/indicators/simple_moving_average.py @@ -36,7 +36,7 @@ def __init__(self, columns: Union[List[str], str, None] = None, window_size: int self._window_size = window_size - def transform(self, X: pd.DataFrame, input_space: Space) -> pd.DataFrame: + def transform(self, X: pd.DataFrame) -> pd.DataFrame: if self.columns is None: self.columns = list(X.columns) diff --git a/tensortrade/features/indicators/ta_indicator.py b/tensortrade/features/indicators/ta_indicator.py index 502f0b889..17a8975cb 100644 --- a/tensortrade/features/indicators/ta_indicator.py +++ b/tensortrade/features/indicators/ta_indicator.py @@ -28,13 +28,10 @@ class TAIndicator(FeatureTransformer): """Adds one or more TA indicators to a data frame, based on existing open, high, low, close, and 'volume from' column values..""" - # Indicators supported by TA module: - def __init__(self, indicators: Union[List[str], str, None] = None, lows: Union[List[float], List[int]] = None, - highs: Union[List[float], List[int]] = None - ): + highs: Union[List[float], List[int]] = None): if isinstance(indicators, str): indicators = [indicators] @@ -48,40 +45,27 @@ def __init__(self, def _str_to_indicator(self, indicator_name: str): return getattr(ta, indicator_name.lower()) - def transform_space(self, input_space: Space, column_names: List[str]) -> Space: - output_space = copy(input_space) - shape_x, *shape_y = input_space.shape - - output_space.shape = (shape_x + len(self._indicators), *shape_y) - - for i in range(len(self._indicators)): - output_space.low = np.append(output_space.low, self._lows[i]) - output_space.high = np.append(output_space.high, self._highs[i]) - - return output_space - - def transform(self, df: pd.DataFrame, input_space: Space) -> pd.DataFrame: - """ - Will add TAIndicator.indicator columns to DataFrame. Frame must have columns that match indicator parameters, - e.g. ['High', 'Low', 'Close'], &c... + def transform(self, data_frame: pd.DataFrame) -> pd.DataFrame: + """Will add TAIndicator.indicator columns to DataFrame. Frame must have columns that match indicator parameters, + e.g. ['high', 'low', 'close'], &c... - :param df: Dataframe with columns matching TA indicators function call. Not case sensitive - :param input_space: None is acceptable, does nothing but required by abstract class - :return: + Arguments: + data_frame: `pandas.DataFrame` with columns matching TA indicators function call. Case insensitive. """ for i in range(len(self._indicators)): indicator = self._indicators[i] indicator_name = self._indicator_names[i] params = {} + for param in indicator.__code__.co_varnames: if param in ["df", "open", "high", "low", "close", "volume"]: if param == "df": - params[param] = df + params[param] = data_frame else: - for column in df.columns: + for column in data_frame.columns: if column.lower() == param: - params[param] = df[column] - df[indicator_name] = indicator(**params) - return df + params[param] = data_frame[column] + data_frame[indicator_name] = indicator(**params) + return data_frame diff --git a/tensortrade/features/indicators/talib_indicator.py b/tensortrade/features/indicators/talib_indicator.py index 0f2d1692a..b1b6774d0 100644 --- a/tensortrade/features/indicators/talib_indicator.py +++ b/tensortrade/features/indicators/talib_indicator.py @@ -23,6 +23,7 @@ from tensortrade.features.feature_transformer import FeatureTransformer + class TAlibIndicator(FeatureTransformer): """Adds one or more TAlib indicators to a data frame, based on existing open, high, low, and close column values.""" @@ -37,19 +38,7 @@ def __init__(self, indicators: List[str], lows: Union[List[float], List[int]] = def _str_to_indicator(self, indicator_name: str): return getattr(talib, indicator_name.upper()) - def transform_space(self, input_space: Space, column_names: List[str]) -> Space: - output_space = copy(input_space) - shape_x, *shape_y = input_space.shape - - output_space.shape = (shape_x + len(self._indicators), *shape_y) - - for i in range(len(self._indicators)): - output_space.low = np.append(output_space.low, self._lows[i]) - output_space.high = np.append(output_space.high, self._highs[i]) - - return output_space - - def transform(self, X: pd.DataFrame, input_space: Space) -> pd.DataFrame: + def transform(self, X: pd.DataFrame) -> pd.DataFrame: for i in range(len(self._indicators)): indicator_name = self._indicator_names[i] indicator = self._indicators[i] diff --git a/tensortrade/features/scalers/min_max_normalizer.py b/tensortrade/features/scalers/min_max_normalizer.py index ec7107f0b..1814e36c9 100644 --- a/tensortrade/features/scalers/min_max_normalizer.py +++ b/tensortrade/features/scalers/min_max_normalizer.py @@ -27,46 +27,33 @@ class MinMaxNormalizer(FeatureTransformer): def __init__(self, columns: Union[List[str], str, None] = None, + input_min: float = -1E-8, + input_max: float = 1E8, feature_min: float = 0, feature_max: float = 1, inplace: bool = True): """ Arguments: columns (optional): A list of column names to normalize. + input_min (optional): The minimum `float` in the range to scale to. Defaults to -1E-8. + input_max (optional): The maximum `float` in the range to scale to. Defaults to 1E8. feature_min (optional): The minimum `float` in the range to scale to. Defaults to 0. feature_max (optional): The maximum `float` in the range to scale to. Defaults to 1. inplace (optional): If `False`, a new column will be added to the output for each input column. """ super().__init__(columns=columns, inplace=inplace) + self._input_min = input_min + self._input_max = input_max self._feature_min = feature_min self._feature_max = feature_max - def transform_space(self, input_space: Space, column_names: List[str]) -> Space: - if self._inplace: - return input_space - - output_space = copy(input_space) - - shape_x, *shape_y = input_space.shape - - columns = self.columns or range(len(shape_x)) - - output_space.shape = (shape_x + len(columns), *shape_y) - - for _ in columns: - output_space.low = np.append(output_space.low, self._feature_min) - output_space.high = np.append(output_space.high, self._feature_max) - - return output_space - - def transform(self, X: pd.DataFrame, input_space: Space) -> pd.DataFrame: + def transform(self, X: pd.DataFrame) -> pd.DataFrame: if self.columns is None: self.columns = list(X.columns) - for idx, column in enumerate(self.columns): - low = input_space.low[idx] - high = input_space.high[idx] + for column in self.columns: + low, high = self._input_min, self._input_max scale = (self._feature_max - self._feature_min) + self._feature_min diff --git a/tensortrade/features/scalers/standard_normalizer.py b/tensortrade/features/scalers/standard_normalizer.py index 621b77993..894347c95 100644 --- a/tensortrade/features/scalers/standard_normalizer.py +++ b/tensortrade/features/scalers/standard_normalizer.py @@ -43,25 +43,7 @@ def __init__(self, columns: Union[List[str], str, None] = None, feature_min=0, f def reset(self): self._history = {} - def transform_space(self, input_space: Space, column_names: List[str]) -> Space: - if self._inplace: - return input_space - - output_space = copy(input_space) - - shape_x, *shape_y = input_space.shape - - columns = self.columns or range(len(shape_x)) - - output_space.shape = (shape_x + len(columns), *shape_y) - - for _ in columns: - output_space.low = np.append(output_space.low, self._feature_min) - output_space.high = np.append(output_space.high, self._feature_max) - - return output_space - - def transform(self, X: pd.DataFrame, input_space: Space) -> pd.DataFrame: + def transform(self, X: pd.DataFrame) -> pd.DataFrame: if self.columns is None: self.columns = list(X.columns) diff --git a/tensortrade/features/stationarity/fractional_difference.py b/tensortrade/features/stationarity/fractional_difference.py index 7b50d9889..e9e29a18b 100644 --- a/tensortrade/features/stationarity/fractional_difference.py +++ b/tensortrade/features/stationarity/fractional_difference.py @@ -89,7 +89,7 @@ def _fractional_difference(self, series: pd.Series): return diff_series.fillna(method='bfill').fillna(0) - def transform(self, X: pd.DataFrame, input_space: Space) -> pd.DataFrame: + def transform(self, X: pd.DataFrame) -> pd.DataFrame: if self._history is None: self._history = X.copy() else: diff --git a/tensortrade/strategies/tensorforce_trading_strategy.py b/tensortrade/strategies/tensorforce_trading_strategy.py index 15304a39e..ce6a21003 100644 --- a/tensortrade/strategies/tensorforce_trading_strategy.py +++ b/tensortrade/strategies/tensorforce_trading_strategy.py @@ -31,7 +31,7 @@ class TensorforceTradingStrategy(TradingStrategy): """A trading strategy capable of self tuning, training, and evaluating with Tensorforce.""" - def __init__(self, environment: 'TradingEnvironment', agent_spec: any, save_best_agent: bool = False, **kwargs): + def __init__(self, environment: 'TradingEnvironment', agent_spec: any, **kwargs): """ Arguments: environment: A `TradingEnvironment` instance for the agent to trade within. @@ -40,6 +40,7 @@ def __init__(self, environment: 'TradingEnvironment', agent_spec: any, save_best kwargs (optional): Optional keyword arguments to adjust the strategy. """ self._max_episode_timesteps = kwargs.get('max_episode_timesteps', False) + self._save_best_agent = kwargs.get('save_best_agent', False) self._environment = Environment.create( environment='gym', level=environment, max_episode_timesteps=self._max_episode_timesteps) @@ -47,13 +48,33 @@ def __init__(self, environment: 'TradingEnvironment', agent_spec: any, save_best self._agent = Agent.create(agent=agent_spec, environment=self._environment) self._runner = Runner(agent=self._agent, environment=self._environment, - save_best_agent=save_best_agent) + save_best_agent=self._save_best_agent) + + @property + def environment(self) -> 'TradingEnvironment': + """The `TradingEnvironment` being traded by the learning agent.""" + return self._environment + + @environment.setter + def environment(self, environment: 'TradingEnvironment'): + self._environment = Environment.create( + environment='gym', level=environment, max_episode_timesteps=self._max_episode_timesteps) + + self._runner = Runner(agent=self._agent, environment=self._environment, + save_best_agent=self._save_best_agent) @property def agent(self) -> Agent: """A Tensorforce `Agent` instance that will learn the strategy.""" return self._agent + @agent.setter + def agent(self, agent_spec: any): + self._agent = Agent.create(agent=agent_spec, environment=self._environment) + + self._runner = Runner(agent=self._agent, environment=self._environment, + save_best_agent=self._save_best_agent) + @property def max_episode_timesteps(self) -> int: """The maximum timesteps per episode.""" diff --git a/tests/tensortrade/exchanges/test_injection.py b/tests/tensortrade/exchanges/test_injection.py index d1ed3d67c..88b2dae70 100644 --- a/tests/tensortrade/exchanges/test_injection.py +++ b/tests/tensortrade/exchanges/test_injection.py @@ -146,7 +146,6 @@ def fill_order(self, trade: Trade, **kwargs) -> Trade: 'max_trade_price': 1e7, 'min_trade_amount': 1e-4, 'max_trade_amount': 1e4, - 'min_order_amount': 1e-4, 'initial_balance': 1e5, 'window_size': 5, 'should_pretransform_obs': True, diff --git a/tests/tensortrade/features/failing_test_feature_pipeline.py b/tests/tensortrade/features/failing_test_feature_pipeline.py index a46f22319..d2709ed41 100644 --- a/tests/tensortrade/features/failing_test_feature_pipeline.py +++ b/tests/tensortrade/features/failing_test_feature_pipeline.py @@ -86,18 +86,3 @@ def test_incremental_transform(self, data_frame, exchange): }]) assert np.allclose(expected_data_frame.values, transformed_frame.values) - - def test_transform_space(self, data_frame, exchange): - difference_all = FractionalDifference(difference_order=0.5, inplace=False) - - feature_pipeline = FeaturePipeline(steps=[difference_all]) - - low = np.array([1E-3, ] * 4 + [1E-3, ]) - high = np.array([1E3, ] * 4 + [1E3, ]) - - input_space = Box(low=low, high=high, dtype=np.float16) - - transformed_space = feature_pipeline.transform_space( - input_space, exchange.generated_columns) - - assert transformed_space != input_space diff --git a/tests/tensortrade/features/indicators/test_ta_indicator.py b/tests/tensortrade/features/indicators/test_ta_indicator.py index 7d3476f5d..833774501 100644 --- a/tests/tensortrade/features/indicators/test_ta_indicator.py +++ b/tests/tensortrade/features/indicators/test_ta_indicator.py @@ -11,11 +11,6 @@ def data_frame(): return df -@pytest.fixture -def input_space(): - return Box(low=0.0, high=100, shape=(5, 5), dtype=np.float32) - - class TestTAIndicator: indicators_to_test = ['rsi', 'macd', 'ema_indicator'] @@ -23,21 +18,14 @@ def test_ta_indicator(self): test_feature = TAIndicator(TestTAIndicator.indicators_to_test) assert len(test_feature._indicator_names) == 3 - def test_transform_space(self, input_space, data_frame): - test_feature = TAIndicator(TestTAIndicator.indicators_to_test) - column_names = data_frame.columns - output = test_feature.transform_space(input_space, column_names) - assert output.shape[0] > input_space.shape[0] - assert output.shape[1] == input_space.shape[1] - def test_transform(self, data_frame): test_feature = TAIndicator(TestTAIndicator.indicators_to_test) - test_feature.transform(data_frame, None) + test_feature.transform(data_frame) assert set(TestTAIndicator.indicators_to_test).issubset(data_frame.columns) def test_transform_single_indicator(self, data_frame): test_feature = TAIndicator('rsi') - test_feature.transform(data_frame, None) + test_feature.transform(data_frame) assert 'rsi' in data_frame.columns # def test_add_volatility_ta(self, data_frame): diff --git a/tests/tensortrade/features/stationarity/failing_test_fractional_difference.py b/tests/tensortrade/features/stationarity/failing_test_fractional_difference.py index ceb863b2e..8b95a5558 100644 --- a/tests/tensortrade/features/stationarity/failing_test_fractional_difference.py +++ b/tests/tensortrade/features/stationarity/failing_test_fractional_difference.py @@ -154,15 +154,3 @@ def test_select_correct_columns(self, data_frame, exchange): }]) assert np.allclose(expected_data_frame.values, transformed_frame.values) - - def test_transform_space(self, data_frame, exchange): - transformer = FractionalDifference(difference_order=0.5, inplace=False) - - low = np.array([1E-3, ] * 4 + [1E-3, ]) - high = np.array([1E3, ] * 4 + [1E3, ]) - - input_space = Box(low=low, high=high, dtype=np.float16) - - transformed_space = transformer.transform_space(input_space, exchange.generated_columns) - - assert transformed_space != input_space diff --git a/tests/tensortrade/features/test_injection.py b/tests/tensortrade/features/test_injection.py index e4fc9d7fb..71d5474fd 100644 --- a/tests/tensortrade/features/test_injection.py +++ b/tests/tensortrade/features/test_injection.py @@ -11,11 +11,7 @@ class Identity(FeatureTransformer): - - def transform_space(self, input_space: Space, column_names: List[str]) -> Space: - return input_space - - def transform(self, X: pd.DataFrame, input_space: Space) -> pd.DataFrame: + def transform(self, X: pd.DataFrame) -> pd.DataFrame: return X