Timing Commodities and S&P500 with 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 TimingCommoditiesandSP500withCOTReport(QCAlgorithm):
8
9def Initialize(self):
10self.SetStartDate(2005, 1, 1)
11self.SetCash(100000)
12   
13# Future symbol with COT symbol.
14self.symbols = {
15    'CME_ES1' : 'QEP',
16    'CME_HG1' : 'QHG',
17    'CME_CL1' : 'QCL'
18}
19
20# Daily price data.
21self.data = {}
22self.period = 60
23for symbol, cot_symbol in self.symbols.items():
24    # Futures data.
25    data = self.AddData(data_tools.QuantpediaFutures, symbol, Resolution.Daily)
26    data.SetFeeModel(data_tools.CustomFeeModel())
27    data.SetLeverage(10)
28    
29    self.symbol = data.Symbol
30    self.data[symbol] = SymbolData(symbol,self.period)
31
32    # COT data.
33    self.AddData(data_tools.CommitmentsOfTraders, cot_symbol, Resolution.Daily)
34# Cash asset.
35self.cash = self.AddEquity('BIL', Resolution.Daily).Symbol
36self.data[self.cash.Value] = SymbolData(self.cash.Value, self.period)
37
38# Regression data.
39self.period = 12 * 4    # 1 year worth of weekly data.
40self.regression_data = deque(maxlen = self.period)
41
42def OnData(self, data):
43# Store daily price data.
44for symbol in self.data:
45    symbol_obj = self.Symbol(symbol)
46    if symbol_obj in data and data[symbol_obj]:
47        price = data[symbol_obj].Value
48        self.data[symbol].update(price)
49    
50copper_hedging_pressure = 0
51oil_hedging_pressure = 0
52
53market_commercial_hedging_pressure = 0
54market_nonreportable_hedging_pressure = 0
55
56# Copper and oil COT data.
57for cot_symbol in ['QHG', 'QCL']:
58    # Store COT data every wednesday.
59    if cot_symbol in data and data[cot_symbol]:
60        cot_data = self.Securities[cot_symbol].GetLastData()
61        if cot_data:
62            speculator_long_count = cot_data.GetProperty("LARGE_SPECULATOR_LONG")
63            speculator_short_count = cot_data.GetProperty("LARGE_SPECULATOR_SHORT")
64            if speculator_long_count != 0 and speculator_short_count != 0:
65                hedging_pressure = speculator_long_count / (speculator_long_count + speculator_short_count)
66                
67                if cot_symbol == 'QHG':
68                    copper_hedging_pressure = hedging_pressure
69                elif cot_symbol == 'QCL':
70                    oil_hedging_pressure = hedging_pressure
71
72# Market COT data.
73cot_symbol = 'QEP'
74if cot_symbol in data and data[cot_symbol]:
75    cot_data = self.Securities[cot_symbol].GetLastData()
76    if cot_data:
77        # Commercial hedging pressure.
78        commercial_long_count = cot_data.GetProperty("COMMERCIAL_HEDGER_LONG")
79        commercial_short_count = cot_data.GetProperty("COMMERCIAL_HEDGER_SHORT")
80        if commercial_long_count != 0 and commercial_short_count != 0:
81            market_commercial_hedging_pressure = commercial_long_count / (commercial_long_count + commercial_short_count)
82        # Non-reportable hedging pressure.
83        trader_long_count = cot_data.GetProperty("SMALL_TRADER_LONG")
84        trader_short_count = cot_data.GetProperty("SMALL_TRADER_SHORT")                            
85        if trader_long_count != 0 and trader_short_count != 0:
86            market_nonreportable_hedging_pressure = trader_long_count / (trader_long_count + trader_short_count)
87            
88returns = { x: self.data[x].performance() for x in self.data if self.data[x].is_ready() }
89# Store regression data.
90if len(returns) == len(self.data) and copper_hedging_pressure != 0 and oil_hedging_pressure != 0 and market_commercial_hedging_pressure != 0 and market_nonreportable_hedging_pressure != 0:
91    asset_returns = [ret for symbol, ret in returns.items()]
92    self.regression_data.append((asset_returns[0], asset_returns[1], asset_returns[2], asset_returns[3], copper_hedging_pressure, oil_hedging_pressure, market_commercial_hedging_pressure, market_nonreportable_hedging_pressure))
93
94# Regression data is ready.
95if len(self.regression_data) == self.regression_data.maxlen:
96    
97    # check futures and cot data arrival
98    for symbol, cot_symbol in self.symbols.items():
99        if any([self.securities[x].get_last_data() and self.time.date() > data_tools.LastDateHandler.get_last_update_date()[x] for x in [symbol, cot_symbol]]):
100            self.liquidate()
101            return
102
103    returns = {}
104    for index in range(4):
105        symbol = [x for x in self.data.keys()][index]
106        # Linear regression calc.
107        asset_returns = [x[index] for x in self.regression_data]
108        
109        copper_hedging_pressures = [x[4] for x in self.regression_data]
110        oil_hedging_pressures = [x[5] for x in self.regression_data]
111        market_commercial_hedging_pressures = [x[6] for x in self.regression_data]
112        market_nonreportable_hedging_pressures = [x[7] for x in self.regression_data]
113        
114        x = [copper_hedging_pressures[:-1], oil_hedging_pressures[:-1], market_commercial_hedging_pressures[:-1], market_nonreportable_hedging_pressures[:-1]]
115        regression_model = data_tools.MultipleLinearRegression(x, asset_returns[1:])
116        
117        alpha = regression_model.params[0]
118        pred_x = [copper_hedging_pressures[-1], oil_hedging_pressures[-1], market_commercial_hedging_pressures[-1], market_nonreportable_hedging_pressures[-1]]
119        betas = np.array(regression_model.params[1:])
120        return_predicted = alpha + sum(np.multiply(betas, pred_x))
121        
122        returns[symbol] = asset_returns + [return_predicted]
123    
124    if len(returns) > 0:
125        returns = pd.DataFrame(returns, columns=returns.keys()).dropna()
126        
127        # The optimization method processes the data frame.
128        opt, weights = self.optimization_method(returns)
129        
130        for symbol in returns.keys():
131            w = weights[symbol]
132            if w >= 0.001:
133                self.SetHoldings(symbol, w)
134    else:
135        self.Liquidate()
136def optimization_method(self, returns):
137# '''Minimum variance optimization method'''
138# # Objective function
139# fun = lambda weights: np.dot(weights.T, np.dot(returns.cov(), weights))
140'''Maximum Sharpe Ratio optimization method'''
141# Objective function
142fun = lambda weights: -self.sharpe_ratio(returns, weights)
143# Constraint #1: The weights can be negative, which means investors can short a security.
144constraints = [{'type': 'eq', 'fun': lambda w: np.sum(w) - 1}]
145# Constraint #2: Portfolio targets a given return
146# constraints.append({'type': 'eq', 'fun': lambda weights: np.dot(np.matrix(returns.mean()), np.matrix(weights).T).item() - self.target_return})
147size = returns.columns.size
148x0 = np.array(size * [1. / size])
149# bounds = tuple((self.minimum_weight, self.maximum_weight) for x in range(size))
150bounds = tuple((0, 1) for x in range(size))
151opt = minimize(fun,                         # Objective function
152               x0,                          # Initial guess
153               method='SLSQP',              # Optimization method:  Sequential Least SQuares Programming
154               bounds = bounds,             # Bounds for variables 
155               constraints = constraints)   # Constraints definition
156return opt, pd.Series(opt['x'], index = returns.columns)
157
158def sharpe_ratio(self, returns, weights):
159annual_return = np.dot(np.matrix(returns.mean()), np.matrix(weights).T).item()
160annual_volatility = np.sqrt(np.dot(weights.T, np.dot(returns.cov(), weights)))
161return annual_return/annual_volatility        
162class QuandlVix(PythonQuandl):
163def __init__(self):
164self.ValueColumnName = "VIX Close"
165
166class SymbolData():
167def __init__(self, symbol, period):
168self.Symbol = symbol
169self.Price = RollingWindow[float](period)
170
171def is_ready(self):
172return self.Price.IsReady
173
174def update(self, close):
175self.Price.Add(close)
176
177def performance(self):
178closes = [x for x in self.Price]
179return (closes[0] / closes[-1] - 1)