Spread Modeling - ML Approach

arbitragelab/ml_approach/__init__.py

@@ -3,3 +3,7 @@
 """
 
 from arbitragelab.ml_approach.pairs_selector import PairsSelector
+from arbitragelab.ml_approach.tar import TAR
+from arbitragelab.ml_approach.pi_sigma import PiSigmaNeuralNetwork
+from arbitragelab.ml_approach.mlp import MultiLayerPerceptron
+from arbitragelab.ml_approach.rnn import RecurrentNeuralNetwork

arbitragelab/ml_approach/base.py

@@ -0,0 +1,47 @@
+# Copyright 2019, Hudson and Thames Quantitative Research
+# All rights reserved
+# Read more: https://hudson-and-thames-arbitragelab.readthedocs-hosted.com/en/latest/additional_information/license.html
+"""
+This is the base class for all the neural network implementations in this module.
+"""
+
+import matplotlib.pyplot as plt
+from keras.callbacks.callbacks import History
+
+
+class BaseNeuralNetwork:
+    """
+    Skeleton Class to be inherited by child
+    neural network implementations.
+    """
+
+    def __init__(self):
+        """
+        Initializing variables.
+        """
+
+        self.fitted_model = None
+
+    def fit(self, *args, **kwargs) -> History:
+        """
+        Wrapper over the keras model fit function.
+        """
+
+        fitted_model = self.model.fit(*args, **kwargs)
+        self.fitted_model = fitted_model
+
+        return fitted_model
+
+    def predict(self, *args, **kwargs):
+        """
+        Wrapper over the keras model predict function.
+        """
+
+        return self.model.predict(*args, **kwargs)
+
+    def plot_loss(self) -> list:
+        """
+        Method that returns visual plot of the loss trajectory.
+        """
+
+        return plt.plot(self.fitted_model.history['loss'])

arbitragelab/ml_approach/correlation_filter.py

@@ -0,0 +1,113 @@
+# Copyright 2019, Hudson and Thames Quantitative Research
+# All rights reserved
+# Read more: https://hudson-and-thames-arbitragelab.readthedocs-hosted.com/en/latest/additional_information/license.html
+"""
+This module implements the Correlation Filter described in Dunis et al. (2005).
+"""
+
+import pandas as pd
+from sklearn.preprocessing import MinMaxScaler
+
+
+class CorrelationFilter:
+    """
+    Correlation Filter implementation.
+    """
+
+    def __init__(self, buy_threshold: float = 0.4, sell_threshold: float = 0.8, lookback: int = 30):
+        """
+        Initialization of trade parameters. The buy/sell threshold are values in terms
+        of change in correlation.
+
+        :param buy_threshold: (float) If larger than this value, buy.
+        :param sell_threshold: (float) If smaller than this value, sell.
+        :param lookback: (int) Number of lookback days for rolling correlation.
+        """
+
+        self.lookback = lookback
+        self.buy_threshold = buy_threshold
+        self.sell_threshold = sell_threshold
+        self.corr_series = None
+
+    def fit(self, frame: pd.DataFrame) -> CorrelationFilter:
+        """
+        Sets the correlation benchmark inside of the class object.
+
+        :param frame: (pd.DataFrame) Time series consisting of both legs of the spread.
+        :return: (CorrelationFilter) Returns calss itself.
+        """
+
+        # Making a copy of the input data
+        frame = frame.copy()
+
+        # Calculating the correlation delta series
+        two_legged_df = frame.iloc[:, 0:2]
+        corr_series = self._get_rolling_correlation(
+            two_legged_df, lookback=self.lookback).diff().dropna()
+
+        self.corr_series = corr_series
+
+        return self
+
+    def transform(self, frame: pd.DataFrame) -> pd.DataFrame:
+        """
+        Marks trade signals based on the correlation benchmark generated in the fit
+        method.
+
+        :param frame: (pd.DataFrame) Spread time series.
+        :return: (pd.DataFrame) Time series augmented with the trade side
+            information.
+        """
+
+        # Making a copy of the input data
+        working_frame = frame.copy()
+
+        # Generating signals
+        buy_signal = working_frame.index.isin(
+            self.corr_series[self.corr_series > self.buy_threshold].index)
+        sell_signal = working_frame.index.isin(
+            self.corr_series[self.corr_series < self.sell_threshold].index)
+
+        working_frame['side'] = 0
+        working_frame.loc[buy_signal, 'side'] = 1
+        working_frame.loc[sell_signal, 'side'] = -1
+        working_frame['side'] = working_frame['side'].shift(1)
+
+        return working_frame
+
+    @staticmethod
+    def _get_rolling_correlation(frame: pd.DataFrame, lookback: int) -> pd.Series:
+        """
+        Calculates rolling correlation between the first two columns in the frame variable.
+        Assuming that the first two columns are the opposing legs of the spread.
+
+        :param frame: (pd.DataFrame) DataFrame representing both legs of the spread.
+        :param lookback: (int) The lookback range of the rolling mean.
+        :param scale: (bool) If True the correlation range will be changed from
+            the usual [-1, 1] to [0, 1].
+        :return: (pd.Series) Rolling correlation series of the input frame.
+        """
+
+        two_legged_df = frame.iloc[:, 0:2]
+        two_legged_df.index.name = '_index_'
+
+        # Rolling correlation calculation
+        daily_corr = two_legged_df.rolling(
+            lookback, min_periods=lookback).corr()
+        daily_corr = daily_corr.iloc[:, 0].reset_index().dropna()
+
+        final_corr = daily_corr[daily_corr['level_1']
+                                == two_legged_df.columns[1]]
+        final_corr.set_index('_index_', inplace=True)
+        final_corr.drop(['level_1'], axis=1, inplace=True)
+        final_corr.dropna(inplace=True)
+
+        # Scaling to [0,1] if needed
+        scaler = MinMaxScaler()
+        scaled_corr = scaler.fit_transform(
+            final_corr.iloc[:, 0].values.reshape(-1, 1))  # .diff()
+        corr_series = pd.Series(data=scaled_corr.reshape(
+            1, -1)[0], index=final_corr.index)
+        corr_series.dropna(inplace=True)
+
+        return corr_series

arbitragelab/ml_approach/feature_expander.py

@@ -0,0 +1,93 @@
+# Copyright 2019, Hudson and Thames Quantitative Research
+# All rights reserved
+# Read more: https://hudson-and-thames-arbitragelab.readthedocs-hosted.com/en/latest/additional_information/license.html
+"""
+This module implements the Feature Expansion class.
+"""
+
+import numpy as np
+
+# pylint: disable=W0102
+
+class FeatureExpander:
+    """
+    Higher order term Feature Expander implementation.
+    """
+
+    def __init__(self, methods=[], n_orders=1):
+        """
+
+        :param methods: (list) Possible expansion methods [chebyshev, legendre, laguerre, power].
+        :param n_orders: (int) Number of orders.
+        """
+        self.methods = methods
+        self.n_orders = n_orders
+        self.dataset = None
+
+    @staticmethod
+    def _chebyshev(series, degree):
+        """
+
+        :param series: (pd.Series)
+        :param degree: (int)
+        """
+
+        return np.polynomial.chebyshev.chebvander(series, degree)
+
+    @staticmethod
+    def _legendre(series, degree):
+        """
+
+        :param series: (pd.Series)
+        :param degree: (int)
+        """
+
+        return np.polynomial.legendre.legvander(series, degree)
+
+    @staticmethod
+    def _laguerre(series, degree):
+        """
+
+        :param series: (pd.Series)
+        :param degree: (int)
+        """
+
+        return np.polynomial.laguerre.lagvander(series, degree)
+
+    @staticmethod
+    def _power(series, degree):
+        """
+
+        :param series: (pd.Series)
+        :param degree: (int)
+        """
+
+        return np.polynomial.polynomial.polyvander(series, degree)
+
+    def fit(self, frame):
+        """
+
+
+        :param frame: (np.array) dataset
+        """
+        self.dataset = frame
+        return self
+
+    def transform(self) -> list:
+        """
+        Transform data to polynomial features
+
+        :return: List of lists of the expanded values.
+        """
+        new_dataset = []
+
+        for row in self.dataset.values:
+            expanded_row = list(row)
+            for degree in range(1, self.n_orders):
+                for meth in self.methods:
+                    expanded_row.extend(
+                        np.ravel(getattr(self, '_' + meth)(row, degree)))
+
+            new_dataset.append(np.ravel(expanded_row).tolist())
+
+        return new_dataset