def testSimpleTrader(self):
trader = TeamBlueSimpleTrader(PerfectPredictor(CompanyEnum.COMPANY_A),
PerfectPredictor(CompanyEnum.COMPANY_B))
self.assertIsNotNone(trader)
stock_market_data = read_stock_market_data([CompanyEnum.COMPANY_A],
[PERIOD_1])
self.assertIsNotNone(stock_market_data)
portfolio = Portfolio(10000, [])
self.assertIsNotNone(portfolio)
# Buy stocks based on prediction: With 10000, we can buy 287 stocks A for 34.80 each
order_list: OrderList = trader.doTrade(portfolio, 0.0,
stock_market_data)
self.assertIsNotNone(order_list)
self.assertEqual(len(order_list), 0)
def test_different_mappings(self):
"""
Tests: Evaluator#inspect_over_time and #inspect_over_time_with_mappings
Compares if both methods return the same values
"""
stock_market_data = read_stock_market_data(
[CompanyEnum.COMPANY_A], [PERIOD_1, PERIOD_2, PERIOD_3])
portfolio_1 = Portfolio(20000,
[SharesOfCompany(CompanyEnum.COMPANY_A, 200)])
portfolio_2 = Portfolio(20000,
[SharesOfCompany(CompanyEnum.COMPANY_A, 200)])
portfolios = [portfolio_1, portfolio_2]
perfect_predictor = PerfectPredictor(CompanyEnum.COMPANY_A)
trader_1 = SimpleTrader(perfect_predictor, perfect_predictor)
trader_2 = SimpleTrader(perfect_predictor, perfect_predictor)
trader_3 = SimpleTrader(RandomPredictor(), RandomPredictor())
traders = [trader_1, trader_2]
portfolio_trader_mappings = list(
zip(portfolios, traders, [None] * len(portfolios)))
evaluator_1 = PortfolioEvaluator([trader_1, trader_1])
evaluator_2 = PortfolioEvaluator([])
evaluator_3 = PortfolioEvaluator([trader_3, trader_3])
# 1 Use evaluator that is initialized *with* traders and call `#inspect_over_time` (i.e. without traders)
result_1 = evaluator_1.inspect_over_time(stock_market_data, portfolios,
100)
# 2 Use evaluator that is initialized *without* traders and call `#inspect_over_time_with_mapping`
# (i.e. with traders)
result_2 = evaluator_2.inspect_over_time_with_mapping(
stock_market_data, portfolio_trader_mappings, 100)
# 3 Use evaluator that is initialized *with* traders and call `#inspect_over_time_with_mapping`
# (i.e. with traders) - this should be no problem, because the traders given at initialization time are ignored
result_3 = evaluator_3.inspect_over_time_with_mapping(
stock_market_data, portfolio_trader_mappings, 100)
assert result_1 == result_2 == result_3
def testSimpleTraderWithOneStock(self):
trader = SimpleTrader(PerfectPredictor(CompanyEnum.COMPANY_A),
PerfectPredictor(CompanyEnum.COMPANY_B))
self.assertIsNotNone(trader)
stock_market_data = read_stock_market_data([CompanyEnum.COMPANY_A],
[PERIOD_1])
self.assertIsNotNone(stock_market_data)
portfolio = Portfolio(10000, [])
self.assertIsNotNone(portfolio)
# Buy stocks based on prediction: With 10000, we can buy 287 stocks A for 34.80 each
order_list = trader.doTrade(portfolio, 0.0, stock_market_data)
self.assertIsNotNone(order_list)
self.assertEqual(len(order_list), 1)
order = order_list[0]
self.assertEqual(order.action, OrderType.BUY)
self.assertEqual(order.shares.amount, 287)
self.assertEqual(order.shares.company_enum, CompanyEnum.COMPANY_A)
def test_read_stock_market_data__1stock_no_periods(self):
test = read_stock_market_data([CompanyEnum.COMPANY_B], [])
assert test.get_number_of_companies() == 1
assert CompanyEnum.COMPANY_A not in test.get_companies()
assert CompanyEnum.COMPANY_B in test.get_companies()
return OrderList()
def save_trained_model(self):
"""
Save the trained neural network under a fixed name specific for this trader.
"""
save_keras_sequential(self.model, self.RELATIVE_DATA_DIRECTORY,
self.network_filename)
# This method retrains the trader from scratch using training data from PERIOD_1 and test data from PERIOD_2
EPISODES = 50
if __name__ == "__main__":
# Read the training data
training_data = read_stock_market_data(
[CompanyEnum.COMPANY_A, CompanyEnum.COMPANY_B], [PERIOD_1])
test_data = read_stock_market_data(
[CompanyEnum.COMPANY_A, CompanyEnum.COMPANY_B], [PERIOD_1, PERIOD_2])
start_training_day, final_training_day = dt.date(2009, 1,
2), dt.date(2011, 12, 29)
start_test_day, final_test_day = dt.date(2012, 1, 3), dt.date(2015, 12, 30)
# Define initial portfolio
name = 'DQL trader portfolio'
portfolio = Portfolio(10000.0, [], name)
# Initialize trader: use perfect predictors, don't use an already trained model, but learn while trading
# trader = DqlTrader(PerfectPredictor(CompanyEnum.COMPANY_A), PerfectPredictor(CompanyEnum.COMPANY_B), False, True, MODEL_FILENAME_DQLTRADER_PERFECT_PREDICTOR)
# trader = DqlTrader(StockANnPerfectBinaryPredictor(), StockBNnPerfectBinaryPredictor(), False, True, MODEL_FILENAME_DQLTRADER_PERFECT_NN_BINARY_PREDICTOR)
trader = TeamBlackDqlTrader(StockANnBinaryPredictor(),
StockBNnBinaryPredictor(), False, True,
def get_stock_market_data():
return read_stock_market_data(
[CompanyEnum.COMPANY_A, CompanyEnum.COMPANY_B], [PERIOD_1, PERIOD_2])
def create_model() -> Sequential:
network = Sequential()
network.add(Dense(500, activation='relu', input_dim=100))
network.add(Dense(500, activation='relu'))
network.add(Dense(1, activation='linear'))
return network
if __name__ == "__main__":
# Load the training data; here: complete data about stock A
logger.debug("Data loading...")
full_stock_market_data = read_stock_market_data(
[CompanyEnum.COMPANY_A, CompanyEnum.COMPANY_B],
['1962-2011', '2012-2017'])
company_a_stock_data = full_stock_market_data[CompanyEnum.COMPANY_A]
logger.debug(
f"Data for Stock A loaded: {company_a_stock_data.get_row_count()} prices and dates read."
)
learn_nn_and_save(company_a_stock_data, MODEL_FILE_NAME_STOCK_A)
company_b_stock_data = full_stock_market_data[CompanyEnum.COMPANY_B]
logger.debug(
f"Data for Stock B loaded: {company_b_stock_data.get_row_count()} prices and dates read."
)
learn_nn_and_save(company_b_stock_data, MODEL_FILE_NAME_STOCK_B)
def testCreateActionList(self):
trader = DqlTrader(PerfectPredictor(CompanyEnum.COMPANY_A), PerfectPredictor(CompanyEnum.COMPANY_B), False)
self.assertIsNotNone(trader)
portfolio = Portfolio(10000, [])
stock_market_data = read_stock_market_data([CompanyEnum.COMPANY_A, CompanyEnum.COMPANY_B], [PERIOD_3])
self.assertIsNotNone(stock_market_data)
# Check doing nothing
# commented because that STOCKACTION is not used anymore
# action_a, action_b = 0.0, 0.0
# order_list = trader.create_order_list(action_a, action_b, portfolio, stock_market_data)
# self.assertIsNotNone(order_list)
# self.assertTrue(order_list.is_empty())
# Check buying halve stock
# commented because that STOCKACTION is not used anymore
# action_a, action_b = 0.5, 0.5
# order_list = trader.create_order_list(action_a, action_b, portfolio, stock_market_data)
# self.assertIsNotNone(order_list)
# self.assertEqual(order_list.get(0).action, OrderType.BUY)
# self.assertEqual(order_list.get(0).shares.company_enum, CompanyEnum.COMPANY_A)
# self.assertEqual(order_list.get(0).shares.amount, 49)
# self.assertEqual(order_list.get(1).action, OrderType.BUY)
# self.assertEqual(order_list.get(1).shares.company_enum, CompanyEnum.COMPANY_B)
# self.assertEqual(order_list.get(1).shares.amount, 33)
# Check buying full stock
action_a, action_b = 1.0, 1.0
order_list = trader.create_order_list(action_a, action_b, portfolio, stock_market_data)
self.assertIsNotNone(order_list)
order_1 = order_list[0]
order_2 = order_list[1]
self.assertEqual(order_1.action, OrderType.BUY)
self.assertEqual(order_1.shares.company_enum, CompanyEnum.COMPANY_A)
self.assertEqual(order_1.shares.amount, 98)
self.assertEqual(order_2.action, OrderType.BUY)
self.assertEqual(order_2.shares.company_enum, CompanyEnum.COMPANY_B)
self.assertEqual(order_2.shares.amount, 66)
# Check selling stock without enough owned shares
action_a, action_b = -1.0, -1.0
order_list = trader.create_order_list(action_a, action_b, portfolio, stock_market_data)
self.assertIsNotNone(order_list)
self.assertTrue(order_list.is_empty())
# Check selling halve stock with enough owned shares
# commented because that STOCKACTION is not used anymore
# portfolio = Portfolio(10000, [SharesOfCompany(CompanyEnum.COMPANY_A, 2), SharesOfCompany(CompanyEnum.COMPANY_B, 2)])
# action_a, action_b = -0.5, -0.5
# order_list = trader.create_order_list(action_a, action_b, portfolio, stock_market_data)
# self.assertIsNotNone(order_list)
# self.assertEqual(order_list.get(0).action, OrderType.SELL)
# self.assertEqual(order_list.get(0).shares.company_enum, CompanyEnum.COMPANY_A)
# self.assertEqual(order_list.get(0).shares.amount, 2)
# self.assertEqual(order_list.get(1).action, OrderType.SELL)
# self.assertEqual(order_list.get(1).shares.company_enum, CompanyEnum.COMPANY_B)
# self.assertEqual(order_list.get(1).shares.amount, 1)
# Check selling full stock with enough owned shares
portfolio = Portfolio(10000,
[SharesOfCompany(CompanyEnum.COMPANY_A, 2), SharesOfCompany(CompanyEnum.COMPANY_B, 2)])
action_a, action_b = -1.0, -1.0
order_list = trader.create_order_list(action_a, action_b, portfolio, stock_market_data)
self.assertIsNotNone(order_list)
order_1 = order_list[0]
order_2 = order_list[1]
self.assertEqual(order_1.action, OrderType.SELL)
self.assertEqual(order_1.shares.company_enum, CompanyEnum.COMPANY_A)
self.assertEqual(order_1.shares.amount, 2)
self.assertEqual(order_2.action, OrderType.SELL)
self.assertEqual(order_2.shares.company_enum, CompanyEnum.COMPANY_B)
self.assertEqual(order_2.shares.amount, 2)
