Market Timing S&P 500 with VIX and COT Report

1from collections import deque
2from AlgorithmImports import *
3import numpy as np
4import data_tools
5import pandas as pd
6from scipy.optimize import minimize
7class MarketTimingSP500withVIXandCOTReport(QCAlgorithm):
8
9def Initialize(self):
10self.SetStartDate(2005, 1, 1)
11self.SetCash(100000)
12   
13# Market data.
14data = self.AddData(data_tools.QuantpediaFutures, 'CME_ES1', Resolution.Daily)
15data.SetFeeModel(data_tools.CustomFeeModel())
16data.SetLeverage(10)
17self.symbol = data.Symbol
18
19self.cash = self.AddEquity('BIL', Resolution.Daily).Symbol
20
21# Daily price data.
22self.data = {}
23self.period = 60
24self.data[self.symbol] = RollingWindow[float](self.period)
25self.data[self.cash] = RollingWindow[float](self.period)
26
27# COT data.
28self.cot_symbol = 'QEP'  # S&P500 E-mini COT symbol.
29self.AddData(data_tools.CommitmentsOfTraders, self.cot_symbol, Resolution.Daily)
30
31# Vix data.
32self.vix = self.AddData(CBOE, "VIX", Resolution.Daily).Symbol
33
34# Regression data.
35self.period = 12 * 4    # 1 year worth of weekly data.
36self.regression_data = deque(maxlen = self.period)
37self.Schedule.On(self.DateRules.MonthStart(self.symbol), self.TimeRules.At(0, 0), self.Rebalance)
38
39def OnData(self, data):
40# Store daily price data.
41for symbol in self.data:
42    symbol_obj = self.Symbol(symbol)
43    if symbol_obj in data and data[symbol_obj]:
44        price = data[symbol_obj].Value
45        self.data[symbol].Add(price)
46    
47market_return = None
48cash_return = None
49hedging_pressure = 0
50open_interest = 0
51vix_price = 0
52# Market and cash asset daily data is ready.
53if self.data[self.symbol].IsReady and self.data[self.cash].IsReady:
54    market_prices = [x for x in self.data[self.symbol]]
55    market_return = market_prices[0] / market_prices[-1] - 1
56    
57    cash_prices =  [x for x in self.data[self.cash]]
58    cash_return = cash_prices[0] / cash_prices[-1] - 1
59# Store COT data every wednesday.
60if self.cot_symbol in data and data[self.cot_symbol]:
61    cot_data = self.Securities[self.cot_symbol].GetLastData()
62    if cot_data:
63        speculator_long_count = cot_data.GetProperty("LARGE_SPECULATOR_LONG")
64        speculator_short_count = cot_data.GetProperty("LARGE_SPECULATOR_SHORT")
65        commercial_long_count = cot_data.GetProperty("COMMERCIAL_HEDGER_LONG")
66        commercial_short_count = cot_data.GetProperty("COMMERCIAL_HEDGER_SHORT")
67        trader_long_count = cot_data.GetProperty("SMALL_TRADER_LONG")
68        trader_short_count = cot_data.GetProperty("SMALL_TRADER_SHORT")
69        
70        if commercial_long_count != 0 and commercial_short_count != 0:
71            hedging_pressure = commercial_long_count / (commercial_long_count + commercial_long_count)
72            
73        open_interest = speculator_long_count + speculator_short_count + commercial_long_count + commercial_short_count + trader_long_count+ trader_short_count
74            
75        if self.vix in data and data[self.vix]:
76            vix_price = data[self.vix].Value
77
78if market_return and cash_return and hedging_pressure != 0 and open_interest != 0 and vix_price != 0:
79    self.regression_data.append((market_return, cash_return, hedging_pressure, open_interest, vix_price))
80
81def Rebalance(self):
82# Regression data is ready.
83if len(self.regression_data) == self.regression_data.maxlen:
84    # check futures and cot data arrival
85    if any([self.securities[symbol].get_last_data() and self.time.date() > data_tools.LastDateHandler.get_last_update_date()[symbol] for symbol in [self.symbol, self.cot_symbol]]):
86        self.liquidate()
87        return
88        
89    # Linear regression calc.
90    market_returns = [x[0] for x in self.regression_data]
91    cash_returns = [x[1] for x in self.regression_data]
92    hedging_pressures = [x[2] for x in self.regression_data]
93    open_interests = [x[3] for x in self.regression_data]
94    vix_prices = [x[4] for x in self.regression_data]
95    
96    x = [hedging_pressures[:-1], open_interests[:-1], vix_prices[:-1]]
97    regression_model = data_tools.MultipleLinearRegresion(x, market_returns[1:])
98    market_return_predicted = regression_model.predict([hedging_pressures[-1], open_interests[-1], vix_prices[-1]]) # returns list.
99    
100    x = [hedging_pressures[:-1], open_interests[:-1], vix_prices[:-1]]
101    regression_model = data_tools.MultipleLinearRegresion(x, cash_returns[1:])
102    cash_return_predicted = regression_model.predict([hedging_pressures[-1], open_interests[-1], vix_prices[-1]]) # returns list.
103    
104    # Create return df.
105    returns = {
106        self.symbol.Value : market_returns + market_return_predicted,
107        self.cash.Value : cash_returns + cash_return_predicted
108    }
109    returns = pd.DataFrame(returns, columns=returns.keys()).dropna()
110    
111    # The optimization method processes the data frame
112    opt, weights = self.optimization_method(returns)
113    
114    for symbol in [self.symbol, self.cash]:
115        w = weights[symbol.Value]
116        if w > 0.001:
117            self.SetHoldings(symbol, w)
118def optimization_method(self, returns):
119'''Minimum variance optimization method'''
120# Objective function
121fun = lambda weights: np.dot(weights.T, np.dot(returns.cov(), weights))
122# Constraint #1: The weights can be negative, which means investors can short a security.
123constraints = [{'type': 'eq', 'fun': lambda w: np.sum(w) - 1}]
124# Constraint #2: Portfolio targets a given return
125# constraints.append({'type': 'eq', 'fun': lambda weights: np.dot(np.matrix(returns.mean()), np.matrix(weights).T).item() - self.target_return})
126size = returns.columns.size
127x0 = np.array(size * [1. / size])
128# bounds = tuple((self.minimum_weight, self.maximum_weight) for x in range(size))
129bounds = tuple((0, 1) for x in range(size))
130opt = minimize(fun,                         # Objective function
131               x0,                          # Initial guess
132               method='SLSQP',              # Optimization method:  Sequential Least SQuares Programming
133               bounds = bounds,             # Bounds for variables 
134               constraints = constraints)   # Constraints definition
135return opt, pd.Series(opt['x'], index = returns.columns)
136class QuandlVix(PythonQuandl):
137def __init__(self):
138self.ValueColumnName = "close"