def test_meanreversion_singleModel_online_partials(self): # Calculate returns via TradeFramework env = SandboxEnvironment("TradeFair") p = env.createPortfolio("MyPortfolio", optimizer=env.createOptimizer( "EqualWeightsOptimizer", "EqualWeights")) p.addModel(env.createModel("MeanReversion", "Test-BuyAndHold")) env.append(Asset("DOW", self.asset1.values[0:-1])) slice = self.asset1.values[-1:].copy() slice["Close"] = np.nan env.append(Asset("DOW", slice)) res1 = p.getUnderlyingAllocations()["DOW"]["bar"].values.flatten() # Calculate returns via TradeFramework env = SandboxEnvironment("TradeFair") p = env.createPortfolio("MyPortfolio", optimizer=env.createOptimizer( "EqualWeightsOptimizer", "EqualWeights")) p.addModel(env.createModel("MeanReversion", "Test-BuyAndHold")) env.append(Asset("DOW", self.asset1.values)) res2 = p.getUnderlyingAllocations()["DOW"]["bar"].values.flatten() self.assertTrue(np.allclose(res1, res2))
def test_kellyWeights_multiModel_online_partials(self): # randomSignals = TODO Pick random numbers between -1 and 1 and round to nearest integer. randomSignals = np.array([-.1, .2, -.3, .4, -.5, .6, -.7, .8, -1]) class RandomModel(Model): def getSignals(self, idx=0): window = self.assets[0].values[idx:] loc = self.assets[0].values.index.get_loc(idx) signals = pd.DataFrame(np.array([ randomSignals[loc:loc + len(window)], randomSignals[loc:loc + len(window)] ]).T, index=window.index, columns=["bar", "gap"]) return signals # Calculate returns via TradeFramework for a partial input (bar only) env = SandboxEnvironment("TradeFair") p = env.createPortfolio("MyPortfolio", optimizer=env.createOptimizer( "KellyOptimizer", "KellyWeights", opts={"window": 4})) p.addModel(env.createModel("BuyAndHold", "Test-BuyAndHold")) p.addModel(RandomModel("TestModel2", env)) env.append(Asset("DOW", self.asset1.values[0:-1])) slice = self.asset1.values[-1:].copy() slice["Close"] = np.nan env.append(Asset("DOW", slice)) res1 = p.getUnderlyingAllocations()["DOW"]["bar"].values.flatten() # Calculate returns via TradeFramework for a full input (bar/gap) env = SandboxEnvironment("TradeFair") p2 = env.createPortfolio("MyPortfolio", optimizer=env.createOptimizer( "KellyOptimizer", "KellyWeights", opts={"window": 4})) p2.addModel(env.createModel("BuyAndHold", "Test-BuyAndHold")) p2.addModel(RandomModel("TestModel2", env)) env.append(Asset("DOW", self.asset1.values)) res2 = p2.getUnderlyingAllocations()["DOW"]["bar"].values.flatten() self.assertTrue(np.allclose(res1, res2))
def test_kellyWeights_multiModel_online(self): # randomSignals = TODO Pick random numbers between -1 and 1 and round to nearest integer. randomSignals = np.array([-.1, .2, -.3, .4, -.5, .6, -.7, .8, -1]) class RandomModel(Model): def getSignals(self, idx=0): window = self.assets[0].values[idx:] loc = self.assets[0].values.index.get_loc(idx) signals = pd.DataFrame(np.array([ randomSignals[loc:loc + len(window)], randomSignals[loc:loc + len(window)] ]).T, index=window.index, columns=["bar", "gap"]) return signals # Calculate returns via TradeFramework env = SandboxEnvironment("TradeFair") p = env.createPortfolio("MyPortfolio", optimizer=env.createOptimizer( "KellyOptimizer", "KellyWeights", opts={"window": 4})) p.addModel(env.createModel("BuyAndHold", "Test-BuyAndHold")) p.addModel(RandomModel("TestModel2", env)) for i in range(len(self.asset1.values)): env.append(Asset("DOW", self.asset1.values[i:i + 1])) self.assertTrue( np.allclose(p.returns["Open"].values.flatten(), [ 0., 0., 0., 0., 0., 4.04651163, 6.16666667, 15.26666667, 16.03333333 ]))
def test_buyAndSell_singleModel_online(self): # randomSignals = TODO Pick random numbers between -1 and 1 and round to nearest integer. randomSignals = np.array([1, 1, 0, -1, 0, -1, 1, -1, 0]) class RandomModel(Model): def getSignals(self, idx=0): window = self.assets[0].values[idx:] loc = self.assets[0].values.index.get_loc(idx) signals = pd.DataFrame(np.array([ np.zeros(len(window)), randomSignals[loc:loc + len(window)] ]).T, index=window.index, columns=["bar", "gap"]) return signals # Calculate returns via TradeFramework env = SandboxEnvironment("TradeFair") p = env.createPortfolio("MyPortfolio", optimizer=env.createOptimizer( "EqualWeightsOptimizer", "EqualWeights")) p.addModel(RandomModel("RandomModel", env)) for i in range(len(self.asset1.values)): env.append(Asset("DOW", self.asset1.values[i:i + 1])) # Calculate returns manually mRet = randomSignals[:-1] * np.diff( self.asset1.values["Close"]) / self.asset1.values["Close"][:-1] self.assertTrue(np.allclose(p.returns.values[:, 0][1:], mRet.values))
def test_multiModel_perf(self): randomSignals = self.randomSignals class RandomModel(Model): def getSignals(self, idx=0): window = self.assets[0].values[idx:] loc = self.assets[0].values.index.get_loc(idx) signals = pd.DataFrame(np.array([ randomSignals[loc:loc + len(window)], randomSignals[loc:loc + len(window)] ]).T, index=window.index, columns=["bar", "gap"]) return signals # Calculate returns via TradeFramework env = SandboxEnvironment("TradeFair") p = env.createPortfolio("MyPortfolio", optimizer=env.createOptimizer( "KellyOptimizer", "KellylWeights", opts={"window": 4})) p.addModel(env.createModel("BuyAndHold", "Test-BuyAndHold")) p.addModel(RandomModel("TestModel2", env)) start = time.time() env.append(self.asset1) end = time.time() print(end - start) pytest.results = p.returns["Open"].values.flatten() self.assertTrue((end - start) < 1, "Operation took too long")
def test_MIBasic_multiModel(self): TRAINING_RUN_ID = "94b227b9d7b22c920333aa36d23669c8" DATASET_ID1 = "4234f0f1b6fcc17f6458696a6cdf5101" DATASET_ID2 = "3231bbe5eb2ab84eb54c9b64a8dcea55" agg = [{ 'training_run_id': TRAINING_RUN_ID, 'datasets': [DATASET_ID1, DATASET_ID2] }] # Calculate returns via TradeFramework env = SandboxEnvironment("TradeFair") p = env.createPortfolio("MyPortfolio", optimizer=env.createOptimizer( "EqualWeightsOptimizer", "EqualWeights")) p.addModel( env.createModel("MIAggregateModel", "Test-MIAggregateModel", args=(CredentialsStore(), agg, "vote_unanimous_all", 0))) env.append(Asset("DOW", self.asset1.values)) print(np.prod(utils.getPeriodReturns(p.returns) + 1)) # Check results self.assertTrue( np.allclose(np.prod(utils.getPeriodReturns(p.returns) + 1), 0.9979433892004727))
def test_MIBasic_singleModel_online(self): TRAINING_RUN_ID = "94b227b9d7b22c920333aa36d23669c8" DATASET_ID = "4234f0f1b6fcc17f6458696a6cdf5101" # Calculate returns via TradeFramework env = SandboxEnvironment("TradeFair") p = env.createPortfolio("MyPortfolio", optimizer=env.createOptimizer( "EqualWeightsOptimizer", "EqualWeights")) p.addModel( env.createModel("MIBasicModel", "Test-MIBasicModel", args=(CredentialsStore(), DATASET_ID, TRAINING_RUN_ID, 0))) # Extract 3pm indices # crop = ppl.cropTime(asset1.values, "15:00", "16:00") # idx = [asset1.values.index.get_loc(crop.index[x]) for x in range(len(crop))] idx = [19, 42, 44, 67, 90] c = 0 for i in idx: env.append(Asset("DOW", self.asset1.values[c:i])) env.append(Asset("DOW", self.asset1.values[i:i + 1])) c = i + 1 env.append(Asset("DOW", self.asset1.values[c:])) # Check results self.assertTrue( np.allclose(np.prod(utils.getPeriodReturns(p.returns) + 1), 0.9941924543457394))
def test_meanreversion_singleModel(self): # Calculate returns via TradeFramework env = SandboxEnvironment("TradeFair") p = env.createPortfolio("MyPortfolio", optimizer=env.createOptimizer( "EqualWeightsOptimizer", "EqualWeights")) p.addModel(env.createModel("MeanReversion", "Test-MeanReversion")) dInfo = env.append(self.asset1) self.assertTrue( np.allclose(dInfo.returns["Open"].values.flatten(), [0., 0., 0.1, 0.2, 0.1, 0.2, 0.1, 0.2, 0.1]))
def test_meanreversion_singleModel_online(self): # Calculate returns via TradeFramework env = SandboxEnvironment("TradeFair") p = env.createPortfolio("MyPortfolio", optimizer=env.createOptimizer( "EqualWeightsOptimizer", "EqualWeights")) p.addModel(env.createModel("MeanReversion", "Test-MeanReversion")) for i in range(len(self.asset1.values)): env.append(Asset("DOW", self.asset1.values[i:i + 1])) self.assertTrue( np.allclose(p.returns["Open"].values.flatten(), [0., 0., 0.1, 0.2, 0.1, 0.2, 0.1, 0.2, 0.1]))
def test_sellAndHold_singleModel(self): # Calculate returns via TradeFramework env = SandboxEnvironment("TradeFair") p = env.createPortfolio("MyPortfolio", optimizer=env.createOptimizer( "EqualWeightsOptimizer", "EqualWeights")) p.addModel(env.createModel("SellAndHold", "Test-SellAndHold")) dInfo = env.append(self.asset1) # Calculate returns manually mRet = (0 - np.diff( self.asset1.values["Close"])) / self.asset1.values["Close"][:-1] self.assertTrue( np.allclose(dInfo.returns.values[:, 0][1:], mRet.values))
def test_buyAndHold_singleModel_online(self): # Calculate returns via TradeFramework env = SandboxEnvironment("TradeFair") p = env.createPortfolio("MyPortfolio", optimizer=env.createOptimizer( "EqualWeightsOptimizer", "EqualWeights")) p.addModel(env.createModel("BuyAndHold", "Test-BuyAndHold")) for i in range(len(self.asset1.values)): env.append(Asset("DOW", self.asset1.values[i:i + 1])) # Calculate returns manually mRet = np.diff( self.asset1.values["Close"]) / self.asset1.values["Close"][:-1] self.assertTrue(np.allclose(p.returns.values[:, 0][1:], mRet.values))
def test_kellyWeights_singleModel_online(self): # randomSignals = TODO Pick random numbers between -1 and 1 and round to nearest integer. randomSignals = np.array([-1, 1, -1, 1, -1, 1, -1, 1, -1]) class RandomModel(Model): def getSignals(self, idx=0): window = self.assets[0].values[idx:] loc = self.assets[0].values.index.get_loc(idx) signals = pd.DataFrame(np.array([ randomSignals[loc:loc + len(window)], randomSignals[loc:loc + len(window)] ]).T, index=window.index, columns=["bar", "gap"]) return signals # Calculate returns via TradeFramework env = SandboxEnvironment("TradeFair") p = env.createPortfolio("MyPortfolio", optimizer=env.createOptimizer( "KellyOptimizer", "KellylWeights")) p.addModel(RandomModel("TestModel", env)) for i in range(len(self.asset1.values)): env.append(Asset("DOW", self.asset1.values[i:i + 1])) self.assertTrue( np.allclose( p.getAsset("TestModel").getAllocations()["DOW"] ["gap"].values.flatten(), [ -0.01, 0.015, -0.015, 0.0225, -0.0225, 0.03375, -0.03375, 0.050625, -0.050625 ])) print(p.values["Close"].values.flatten()) self.assertTrue( np.allclose(p.values["Close"].values.flatten(), [ 1., 1., 1., 2., 4., 14.90909091, 40.46753247, 202.33766234, 657.5974026 ]))
def test_buyAndSell_multiModel_online(self): # randomSignals = TODO Pick random numbers between -1 and 1 and round to nearest integer. randomSignals = np.array([1, 1, 0, -1, 0, -1, 1, -1, 0]) class RandomModel(Model): def getSignals(self, idx=0): window = self.assets[0].values[idx:] loc = self.assets[0].values.index.get_loc(idx) signals = pd.DataFrame(np.array([ np.zeros(len(window)), randomSignals[loc:loc + len(window)] ]).T, index=window.index, columns=["bar", "gap"]) return signals # Calculate returns via TradeFramework env = SandboxEnvironment("TradeFair") p = env.createPortfolio("MyPortfolio", optimizer=env.createOptimizer( "EqualWeightsOptimizer", "EqualWeights")) p.addModel(env.createModel("BuyAndHold", "Test-BuyAndHold")) p.addModel(RandomModel("TestModel2", env)) for i in range(len(self.asset1.values)): env.append(Asset("DOW", self.asset1.values[i:i + 1])) # Test returns were calculated correctly self.assertTrue( np.allclose(p.returns.values[:, 0][1:], np.array([-.2, .1, -.1, .0, -.1, .0, -.2, .0]))) print(p.getUnderlyingAllocations()["DOW"]["gap"].values) # Test underlying allocations were calculated correctly self.assertTrue( np.allclose( p.getUnderlyingAllocations()["DOW"]["gap"].values, np.array([ .01, .01, .005, 0, .0051136364, 0, .0104597107, 0, .00475441397 ])))
def test_MIBasic_multiModel_online(self): TRAINING_RUN_ID = "94b227b9d7b22c920333aa36d23669c8" DATASET_ID1 = "4234f0f1b6fcc17f6458696a6cdf5101" DATASET_ID2 = "3231bbe5eb2ab84eb54c9b64a8dcea55" agg = [{ 'training_run_id': TRAINING_RUN_ID, 'datasets': [DATASET_ID1, DATASET_ID2] }] # Calculate returns via TradeFramework env = SandboxEnvironment("TradeFair") p = env.createPortfolio("MyPortfolio", optimizer=env.createOptimizer( "EqualWeightsOptimizer", "EqualWeights")) p.addModel( env.createModel("MIAggregateModel", "Test-MIAggregateModel", args=(CredentialsStore(), agg, "vote_unanimous_all", 0))) # Extract 3pm indices # crop = ppl.cropTime(asset1.values, "15:00", "16:00") # idx = [asset1.values.index.get_loc(crop.index[x]) for x in range(len(crop))] idx = [19, 42, 44, 67, 90] c = 0 for i in idx: env.append(Asset("DOW", self.asset1.values[c:i])) env.append(Asset("DOW", self.asset1.values[i:i + 1])) c = i + 1 env.append(Asset("DOW", self.asset1.values[c:])) print(np.prod(utils.getPeriodReturns(p.returns) + 1)) # Check results self.assertTrue( np.allclose(np.prod(utils.getPeriodReturns(p.returns) + 1), 0.9979433892004727))
def test_MIBasic_singleModel(self): TRAINING_RUN_ID = "94b227b9d7b22c920333aa36d23669c8" DATASET_ID = "4234f0f1b6fcc17f6458696a6cdf5101" # Calculate returns via TradeFramework env = SandboxEnvironment("TradeFair") p = env.createPortfolio("MyPortfolio", optimizer=env.createOptimizer( "EqualWeightsOptimizer", "EqualWeights")) p.addModel( env.createModel("MIBasicModel", "Test-MIBasicModel", args=(CredentialsStore(), DATASET_ID, TRAINING_RUN_ID, 0))) env.append(Asset("DOW", self.asset1.values)) # Check results self.assertTrue( np.allclose(np.prod(utils.getPeriodReturns(p.returns) + 1), 0.9941924543457394))
def test_multiModel_perf_online(self): # randomSignals = TODO Pick random numbers between -1 and 1 and round to nearest integer. randomSignals = self.randomSignals class RandomModel(Model): def getSignals(self, idx=0): window = self.assets[0].values[idx:] loc = self.assets[0].values.index.get_loc(idx) signals = pd.DataFrame(np.array([ randomSignals[loc:loc + len(window)], randomSignals[loc:loc + len(window)] ]).T, index=window.index, columns=["bar", "gap"]) return signals # Calculate returns via TradeFramework env = SandboxEnvironment("TradeFair") p = env.createPortfolio("MyPortfolio", optimizer=env.createOptimizer( "KellyOptimizer", "KellyWeights", opts={"window": 4})) p.addModel(env.createModel("BuyAndHold", "Test-BuyAndHold")) p.addModel(RandomModel("TestModel2", env)) start = time.time() for i in range(len(self.asset1.values)): env.append(Asset("DOW", self.asset1.values[i:i + 1])) end = time.time() print(end - start) self.assertTrue((end - start) < 35, "Operation took too long") self.assertTrue( np.allclose(p.returns["Open"].values.flatten(), pytest.results))