def run_experiments(network,
lower_bound,
jump,
upper_bound,
dirname,
iterations=1000):
filename = dirname + '//all_algs_results.json'
if os.path.exists(filename):
os.remove(filename)
defender_budget = lower_bound
ratios = [0.75, 1, 1.25, 1.5]
initial_netowork = copy.deepcopy(network)
cfr_actions_mgr = ActionsManager(network.assets,
SysConfig.get("STEP_ORDER_SIZE"), 1)
minimax_actions_mgr = ActionsManager(network.assets,
SysConfig.get("STEP_ORDER_SIZE"), 2)
while defender_budget <= upper_bound:
attacker_budgets = [int(defender_budget * r) for r in ratios]
minimax_results = run_minimax_experiments_for_defender_budget(
minimax_actions_mgr, network, defender_budget, "minimax",
attacker_budgets)
cfr_results = compute_cfr_equilibrium(cfr_actions_mgr, network,
defender_budget,
attacker_budgets, iterations)
update_result_file(defender_budget, attacker_budgets, minimax_results,
cfr_results, filename)
defender_budget += jump
def test_get_possible_defenses(self):
a1 = AssetFundNetwork.Asset(price=1, daily_volume=10, symbol='a1')
a2 = AssetFundNetwork.Asset(price=2, daily_volume=4, symbol='a2')
a3 = AssetFundNetwork.Asset(price=7, daily_volume=2, symbol='a3')
f1 = Fund('f1', {'a1': 10, 'a2': 10, 'a3': 10}, 100, 1, 1)
f2 = Fund('f2', {'a1': 10}, 100, 1, 1)
SysConfig.set("STEP_ORDER_SIZE", 0.5)
network = AssetFundNetwork.AssetFundsNetwork(
funds={
'f1': f1,
'f2': f2
},
assets={
'a1': a1,
'a2': a2,
'a3': a3
},
mi_calc=MockMarketImpactTestCalculator())
actual_orders = get_possible_defenses(network, 10)
expected_orders = []
expected_orders.append(([Buy('a1', 5)], 5))
expected_orders.append(([Buy('a2', 2)], 4))
expected_orders.append(([Buy('a3', 1)], 7))
expected_orders.append(([Buy('a1', 5), Buy('a2', 2)], 9))
expected_orders.append(([], 0))
actual_orders.sort(key=operator.itemgetter(1))
expected_orders.sort(key=operator.itemgetter(1))
self.assertEqual(len(actual_orders), len(expected_orders))
for i in range(0, len(actual_orders)):
actual_orders[i][0].sort(key=lambda x: x.asset_symbol)
expected_orders[i][0].sort(key=lambda x: x.asset_symbol)
self.assertListEqual(actual_orders[i][0], expected_orders[i][0])
self.assertEqual(actual_orders[i][1], expected_orders[i][1])
def count_game_states(game_network, lower_bound, ratios, portfolios=False):
game_network.limit_trade_step = True
defender_budget = lower_bound
initial_network = copy.deepcopy(game_network)
attacker_budgets = [int(defender_budget * r) for r in ratios]
if portfolios:
actions_mgr = ActionsManager(
assets=game_network.assets,
step_order_size=SysConfig.get("STEP_ORDER_SIZE"),
max_order_num=1,
attacker_budgets=attacker_budgets)
root = PortfolioFlashCrashRootChanceGameState(
action_mgr=actions_mgr,
af_network=initial_network,
defender_budget=defender_budget)
else:
actions_mgr = ActionsManager(game_network.assets,
SysConfig.get("STEP_ORDER_SIZE"), 1)
root = FlashCrashRootChanceGameState(action_mgr=actions_mgr,
af_network=initial_network,
defender_budget=defender_budget,
attacker_budgets=attacker_budgets)
print(count(root, 0))
print('num_states =%d, num_assets=%d, num_funds = %d, num_attackers = %d' %
(root.tree_size, len(game_network.assets), len(
game_network.funds), len(ratios)))
def dont_test_get_possible_defenses(self):
a1 = AssetFundNetwork.Asset(price=1, daily_volume=10, symbol='a1')
a2 = AssetFundNetwork.Asset(price=2, daily_volume=4, symbol='a2')
a3 = AssetFundNetwork.Asset(price=7, daily_volume=2, symbol='a3')
f1 = Fund('f1', {'a1': 10, 'a2': 10, 'a3': 10}, 100, 1, 1)
f2 = Fund('f2', {'a1': 10}, 100, 1, 1)
SysConfig.set("ORDER_SIZES", [0.5, 1])
network = AssetFundNetwork.AssetFundsNetwork(
funds={
'f1': f1,
'f2': f2
},
assets={
'a1': a1,
'a2': a2,
'a3': a3
},
mi_calc=MockMarketImpactTestCalculator())
actual_orders = get_possible_defenses(network, 10)
expected_orders = []
expected_orders.append(([Buy('a1', 5)], 5))
expected_orders.append(([Buy('a1', 10)], 10))
expected_orders.append(([Buy('a2', 2)], 4))
expected_orders.append(([Buy('a2', 4)], 8))
expected_orders.append(([Buy('a3', 1)], 7))
expected_orders.append(([Buy('a1', 5), Buy('a2', 2)], 9))
expected_orders.append(([], 0))
self.assertEqual(actual_orders, expected_orders)
def test_get_possible_attacks(self):
a1 = AssetFundNetwork.Asset(price=1, daily_volume=10, symbol='a1')
a1.set_price(3)
a2 = AssetFundNetwork.Asset(price=2, daily_volume=4, symbol='a2')
a2.set_price(4)
a3 = AssetFundNetwork.Asset(price=7, daily_volume=2, symbol='a3')
f1 = Fund('f1', {'a1': 10, 'a2': 10, 'a3': 10}, 100, 1, 1)
f2 = Fund('f2', {'a1': 10}, 100, 1, 1)
SysConfig.set("STEP_ORDER_SIZE", 0.5)
network = AssetFundNetwork.AssetFundsNetwork(
funds={
'f1': f1,
'f2': f2
},
assets={
'a1': a1,
'a2': a2,
'a3': a3
},
mi_calc=MockMarketImpactTestCalculator())
actual_orders = get_possible_attacks(network, 10)
expected_orders = []
expected_orders.append(([Sell('a1', 5)], 5))
expected_orders.append(([Sell('a2', 2)], 4))
expected_orders.append(([Sell('a3', 1)], 7))
expected_orders.append(([Sell('a1', 5), Sell('a2', 2)], 9))
expected_orders.append(([], 0))
self.assertEqual(actual_orders, expected_orders)
def test_tree(self):
a1 = AssetFundNetwork.Asset(price=1, daily_volume=100, symbol='a1')
f1 = Fund('f1', {'a1': 10}, 100, 1, 1)
f2 = Fund('f2', {'a1': 20}, 100, 1, 1)
mi_calc = MarketImpactCalculator()
mi_calc.get_updated_price = MagicMock()
mi_calc.get_updated_price.side_effect = update_price_side_effects
network = AssetFundNetwork.AssetFundsNetwork(funds={
'f1': f1,
'f2': f2
},
assets={'a1': a1},
mi_calc=mi_calc,
limit_trade_step=False)
action_manager = ActionsManager(network.assets, 0.5, 1, [50, 30])
SysConfig.set("STEP_ORDER_SIZE", 0.5)
f1.marginal_call = MagicMock(return_value=False)
f2.marginal_call = MagicMock()
f2.marginal_call.side_effect = f1_margin_call_side_effect
actual_tree = PortfolioFlashCrashRootChanceGameState(
action_manager, af_network=network, defender_budget=50)
expected_tree = self.gen_tree()
self.assertEqual(actual_tree.chance_prob(), {'p1': 0.75, 'p2': 0.25})
self.assertEqual(actual_tree.tree_size, 8)
self.cmp_tree(expected_tree, actual_tree)
def __init__(self, price, daily_volume, symbol, volatility = 0):
self.zero_time_price = price
self.price = price
self.daily_volume = daily_volume
self.avg_minute_volume = daily_volume/MINUTES_IN_TRADING_DAY
self.symbol = symbol
self.volatility = volatility
self.max_shares_to_trade_in_ts = ceil(SysConfig.get('TIME_STEP_MINUTES')\
*SysConfig.get('DAILY_PORTION_PER_MIN')*daily_volume)
def test_gen_liquidation_orders(self):
SysConfig.set("MINUTE_VOLUME_LIMIT", 0.1)
assets = {
'XXX': Asset(2, 3900, 1.5, 'XXX'),
'YYY': Asset(1, 7900, 1.5, 'yyy'),
'ZZZ': Asset(1, 7900, 1.5, 'yyy')
}
fund = Fund('F1', {'XXX': 10, 'YYY': 11, 'ZZZ': 2}, 5, 2, 0.25)
expected_orders = [Sell('XXX', 1), Sell('YYY', 2), Sell('ZZZ', 2)]
expected_portfolio = {'XXX': 9, 'YYY': 9}
orders = fund.gen_liquidation_orders(assets)
self.assertEqual(orders, expected_orders)
self.assertEqual(fund.portfolio, expected_portfolio)
def dont_test_get_possible_attacks_single_asset_per_attack(self):
a1 = AssetFundNetwork.Asset(price=1, daily_volume=2, symbol='a1')
f1 = Fund('f1', {'a1': 10}, 100, 1, 1)
SysConfig.set("ORDER_SIZES", [0.5, 1])
network = AssetFundNetwork.AssetFundsNetwork(
funds={'f1': f1},
assets={'a1': a1},
mi_calc=MockMarketImpactTestCalculator())
actual_sell_orders = get_possible_attacks(network, 10)
expected_sell_orders = []
expected_sell_orders.append(([Sell('a1', 2)], 2))
expected_sell_orders.append(([Sell('a1', 1)], 1))
expected_sell_orders.append(([], 0))
self.assertEqual(actual_sell_orders, expected_sell_orders)
def test_simulate_trade_limit_trade_step(self):
a1 = AssetFundNetwork.Asset(price=1, daily_volume=1000, symbol='a1')
f1 = Fund('f1', {'a1': 10}, 100, 1, 1)
mi_calc = MarketImpactCalculator()
mi_calc.get_updated_price = MagicMock(return_value=1.5)
network = AssetFundNetwork.AssetFundsNetwork(funds={'f1': f1},
assets={'a1': a1},
mi_calc=mi_calc)
SysConfig.set('TIME_STEP_MINUTES', 1)
SysConfig.set('DAILY_PORTION_PER_MIN', 0.001)
network.submit_buy_orders([Buy('a1', 2)])
log = network.simulate_trade()
self.assertDictEqual({'a1': '1->1.5'}, log)
mi_calc.get_updated_price.assert_called_once_with(1, a1, 1)
self.assertEqual(network.buy_orders['a1'], 1)
def get_single_orders_multiple_options(self, gen_order_func):
orders = []
for asset in self.assets.values():
for size in SysConfig.get('ORDER_SIZES'):
order = gen_order_func(asset, size)
orders.append(order)
return orders
def run_csv_exps():
dt = datetime.today()
dt = str(dt).split(' ')[0]
res_dir = '../../results/stats/' + dt.replace(":", "_").replace(" ",
"_") + '/'
if not os.path.exists(res_dir):
os.mkdir(res_dir)
exp_params = {
'defender_budget': 2000000000,
'attacker_budgets': [4000000000, 6000000000],
'main_game_iteration_portion': 0.9,
'min_iterations': 10,
'max_iterations': 100,
'jump': 10,
'num_assets': 3,
'step_order_size': SysConfig.get("STEP_ORDER_SIZE") * 2,
'max_order_num': 1
}
with open(res_dir + 'params.json', 'w') as fp:
json.dump(exp_params, fp)
compute_node_size_csv(res_dir=res_dir,
max_num_attackers=4,
max_num_portfolios=4,
portfolio_size=10)
count_game_nodes_csv(res_dir=res_dir,
defender_budget=exp_params['defender_budget'],
attacker_budgets=exp_params['attacker_budgets'],
max_num_assets=4)
def test_flash_crash_split_eq_ppa_cfr(self):
exp_params = {
'defender_budget': 2000000000,
'attacker_budgets': [4000000000, 6000000000],
'main_game_iteration_portion': 0.9,
'min_iterations': 10,
'max_iterations': 100,
'jump': 10,
'num_assets': 3,
'step_order_size': SysConfig.get("STEP_ORDER_SIZE") * 2,
'max_order_num': 1
}
network = get_network_from_dir('../resources/three_assets_net')
network.limit_trade_step = True
main_game_results, selector_game_result = self.get_flash_crash_split_cfr_eq(
exp_params['defender_budget'], exp_params['attacker_budgets'],
network, exp_params['step_order_size'],
exp_params['max_order_num'], 8, 20)
vanilla_actions_mgr = ActionsManager(
assets=network.assets,
step_order_size=exp_params['step_order_size'],
max_order_num=exp_params['max_order_num'],
attacker_budgets=exp_params['attacker_budgets'])
network.limit_trade_step = True
root = PPAFlashCrashRootChanceGameState(
action_mgr=vanilla_actions_mgr,
af_network=network,
defender_budget=exp_params['defender_budget'],
attacker_budgets=exp_params['attacker_budgets'])
vanilla_results = compute_complete_game_equilibrium(
root, exp_params['attacker_budgets'], 30)
# print(vanilla_results)
# print(eq_split)
print('PPA')
print('defender = ' + str(vanilla_results['defender']))
print('attackers = ' + str(vanilla_results['attackers']))
print('sigma = ' + str(vanilla_results['sigma']))
print('Split')
print('defender = ' + str(selector_game_result['defender']))
print('attackers = ' + str(selector_game_result['attackers']))
print('sigma = ' + str(selector_game_result['sigma']))
self.assertTrue(
numpy.isclose(float(vanilla_results['defender']),
float(selector_game_result['defender']),
rtol=0.01,
atol=0.01,
equal_nan=False))
for at in exp_params['attacker_budgets']:
self.assertTrue(
numpy.isclose(float(vanilla_results['attackers'][at]),
float(selector_game_result['attackers'][at]),
rtol=0.01,
atol=0.01,
equal_nan=False))
self.assertDictEqual(vanilla_results['sigma'][at],
selector_game_result['sigma'][at])
def simulate_trade(self):
log = {}
order_keys = set(self.sell_orders.keys())
order_keys.update(self.buy_orders.keys())
for order_key in order_keys:
if not order_key: #empty order
continue
buy = self.buy_orders[order_key] if order_key in self.buy_orders else 0
sell = self.sell_orders[order_key] if order_key in self.sell_orders else 0
balance = buy - sell
if balance == 0:
del self.buy_orders[order_key]
del self.sell_orders[order_key]
continue
if self.limit_trade_step:
max_shares_to_trade_in_ts = ceil(SysConfig.get('TIME_STEP_MINUTES')\
*SysConfig.get('DAILY_PORTION_PER_MIN')* self.assets[order_key].daily_volume)
#max_shares_to_trade = self.assets[order_key].max_shares_to_trade_in_ts
shares_to_trade = min(abs(balance), max_shares_to_trade_in_ts)
else:
shares_to_trade = abs(balance)
if balance < 0: #sell > buy
self.sell_orders[order_key] -= (shares_to_trade + buy)
if self.sell_orders[order_key] == 0:
del self.sell_orders[order_key]
if buy > 0:
del self.buy_orders[order_key]
sign = -1
else:
self.buy_orders[order_key] -= (shares_to_trade + sell)
if self.buy_orders[order_key] == 0:
del self.buy_orders[order_key]
if sell > 0:
del self.sell_orders[order_key]
sign = 1
updated_price = self.mi_calc.get_updated_price(shares_to_trade, self.assets[order_key], sign)
log[order_key] = '{0}->{1}'.format(self.assets[order_key].price, updated_price)
self.assets[order_key].price = updated_price
return log
def count_game_states_old(game_network, lower_bound, ratios, network):
network.limit_trade_step = True
defender_budget = lower_bound
actions_mgr = ActionsManager(network.assets,
SysConfig.get("STEP_ORDER_SIZE"), 1)
initial_network = copy.deepcopy(game_network)
attacker_budgets = [int(defender_budget * r) for r in ratios]
root = FlashCrashRootChanceGameState(action_mgr=actions_mgr,
af_network=initial_network,
defender_budget=defender_budget,
attacker_budgets=attacker_budgets)
print('num_states =%d, num_assets=%d, num_funds = %d, num_attackers = %d' %
(root.tree_size, len(game_network.assets), len(
game_network.funds), len(ratios)))
def gen_liquidation_orders(self, assets: Dict[str, Asset]):
orders = []
assets_to_remove = []
for asset_symbol, num_shares in self.portfolio.items():
asset = assets[asset_symbol]
shares_limit = floor(asset.avg_minute_volume * SysConfig.get("MINUTE_VOLUME_LIMIT"))
shares_to_sell = min(shares_limit, num_shares)
orders.append(Sell(asset_symbol, shares_to_sell))
self.portfolio[asset_symbol] -= shares_to_sell
if self.portfolio[asset_symbol] == 0:
assets_to_remove.append(asset_symbol)
for asset_symbol in assets_to_remove:
self.portfolio.pop(asset_symbol)
return orders
def test_flash_crash_split_eq_cfr(self):
exp_params = {
'defender_budget': 2000000000,
'attacker_budgets': [4000000000, 6000000000],
'main_game_iteration_portion': 0.9,
'min_iterations': 10,
'max_iterations': 100,
'jump': 10,
'num_assets': 3,
'step_order_size': SysConfig.get("STEP_ORDER_SIZE") * 2,
'max_order_num': 1
}
network = get_network_from_dir('../resources/three_assets_net')
network.limit_trade_step = True
(main_game_results,
selector_game_result) = self.get_flash_crash_split_cfr_eq(
exp_params['defender_budget'], exp_params['attacker_budgets'],
network, exp_params['step_order_size'],
exp_params['max_order_num'], 800, 200)
vanilla_actions_mgr = ActionsManager(
assets=network.assets,
step_order_size=exp_params['step_order_size'],
max_order_num=exp_params['max_order_num'])
vanilla_results = compute_cfr_equilibrium(
vanilla_actions_mgr, network, exp_params['defender_budget'],
exp_params['attacker_budgets'], 1000)
print('Vanilla')
print('defender = ' + str(vanilla_results['defender']))
print('attackers = ' + str(vanilla_results['attackers']))
print('Split')
print('defender = ' + str(selector_game_result['defender']))
print('attackers = ' + str(selector_game_result['attackers']))
self.assertTrue(
numpy.isclose(float(vanilla_results['defender']),
float(selector_game_result['defender']),
rtol=0.01,
atol=0.01,
equal_nan=False))
for at in exp_params['attacker_budgets']:
self.assertTrue(
numpy.isclose(float(vanilla_results['attackers'][at]),
float(selector_game_result['attackers'][at]),
rtol=0.01,
atol=0.01,
equal_nan=False))
def run_csv_exps():
dt = datetime.today()
dt = str(dt).split(' ')[0]
res_dir = '../../results/stats/' + dt.replace(":", "_").replace(" ",
"_") + '/'
if not os.path.exists(res_dir):
os.mkdir(res_dir)
exp_params = {
'defender_budget': 2000000000,
'attacker_budgets': [4000000000, 6000000000],
'main_game_iteration_portion': 0.8,
'min_iterations': 10,
'max_iterations': 1000,
'jump': 10,
'num_assets': 3,
'step_order_size': SysConfig.get("STEP_ORDER_SIZE"),
'max_order_num': 1
}
with open(res_dir + 'params.json', 'w') as fp:
json.dump(exp_params, fp)
iteration_stats_csv(
res_dir=res_dir,
defender_budget=exp_params['defender_budget'],
attacker_budgets=exp_params['attacker_budgets'],
main_game_iteration_portion=exp_params['main_game_iteration_portion'],
min_iterations=exp_params['min_iterations'],
max_iterations=exp_params['max_iterations'],
jump=exp_params['jump'],
num_assets=3,
step_order_size=exp_params['step_order_size'],
max_order_num=exp_params['max_order_num'])
return
iteration_stats_assets_csv(
res_dir=res_dir,
defender_budget=exp_params['defender_budget'],
attacker_budgets=exp_params['attacker_budgets'],
main_game_iteration_portion=exp_params['main_game_iteration_portion'],
min_iterations=exp_params['min_iterations'],
max_iterations=exp_params['max_iterations'],
jump=exp_params['jump'],
num_assets_range=range(2, 4),
step_order_size=exp_params['step_order_size'],
max_order_num=exp_params['max_order_num'])
def run_flash_crash_csv_exps():
res_dir = setup_dir('flash_crash')
exp_params = {
'main_game_iteration_portion': 1.0,
'min_iterations': 100,
'max_iterations': 1100,
'game_size': 3,
'jump': 100,
'defender_budget': 2000000000,
#'attacker_budgets': [4000000000, 6000000000, 8000000000 ],
'attacker_budgets': [4000000000, 8000000000, 12000000000],
'step_order_size': SysConfig.get("STEP_ORDER_SIZE") * 2,
'max_order_num': 1
}
with open(res_dir + 'params.json', 'w') as fp:
json.dump(exp_params, fp)
root_generator = FlashCrashRootGenerator(exp_params)
iteration_stats_csv(
res_dir=res_dir,
root_generator=root_generator,
params=exp_params,
main_game_iteration_portion=exp_params['main_game_iteration_portion'],
min_iterations=exp_params['min_iterations'],
max_iterations=exp_params['max_iterations'],
jump=exp_params['jump'],
game_size=exp_params['game_size'],
game_name='flash_crash')
return
iteration_stats_csv(
res_dir=res_dir,
root_generator=root_generator,
params=exp_params,
main_game_iteration_portion=exp_params['main_game_iteration_portion'],
min_iterations=exp_params['min_iterations'],
max_iterations=exp_params['max_iterations'],
jump=exp_params['jump'],
game_size=exp_params['num_assets'],
game_name='flash_crash')
def run_one_time_attack_tree_test(self, pruning=False):
a1 = AssetFundNetwork.Asset(price=100, daily_volume=390, symbol='a1')
a2 = AssetFundNetwork.Asset(price=100, daily_volume=390, symbol='a2')
f1 = MockFund('f1', a1, 0.82)
f2 = MockFund('f2', a2, 0.82)
f3 = MockFund('f3', a2, 0.82)
SysConfig.set("STEP_ORDER_SIZE", 2 / 390)
SysConfig.set("TIME_STEP_MINUTES", 1)
SysConfig.set('DAILY_PORTION_PER_MIN', 1 / 390)
SysConfig.set("MAX_NUM_ORDERS", 1)
network = AssetFundNetwork.AssetFundsNetwork(
funds={
'f1': f1,
'f2': f2,
'f3': f3
},
assets={
'a1': a1,
'a2': a2
},
mi_calc=MockMarketImpactTestCalculator(),
limit_trade_step=True)
# value, actions, actual_tree = minimax(ROOT_ATTACKER, network, 205,190)
actions_mgr = ActionsManager(network.assets, 2 / 390, 1)
if pruning:
result = alphabeta(actions_mgr, ATTACKER, network, 405, 190,
(-inf, inf), (inf, inf), True)
else:
result = minimax2(actions_mgr, ATTACKER, network, 405, 190, True)
expected_tree = self.gen_tree2()
print(result.value)
print(result.actions)
self.compare_trees(result.tree, expected_tree)
self.assertEqual(int(result.network.assets['a1'].price), 81)
self.assertEqual(int(result.network.assets['a2'].price), 99)
self.assertEqual(int(network.assets['a1'].price), 100)
self.assertEqual(int(network.assets['a2'].price), 100)
def count_flash_crash_game_nodes():
# dt = datetime.today()
# dt = str(dt).split(' ')[0]
# res_dir = '../../results/stats/' + dt.replace(":", "_").replace(" ", "_") + '/'
# if not os.path.exists(res_dir):
# os.mkdir(res_dir)
res_dir = setup_dir('flash_crash')
exp_params = {
'defender_budget': 2000000000,
'attacker_budgets': [4000000000, 6000000000],
'step_order_size': SysConfig.get("STEP_ORDER_SIZE"),
'max_order_num': 1
}
root_generator = FlashCrashRootGenerator(exp_params)
count_game_nodes_csv(root_generator=root_generator,
res_dir=res_dir,
game_size_range=range(3, 6),
params=exp_params,
game_name='flash_crash',
game_size_fields_name='num_assets')
def count_game_nodes_csv(res_dir,
defender_budget,
attacker_budgets,
max_num_assets,
num_exp=10):
results = []
for i in range(1, max_num_assets + 1):
print('num assets = ' + str(i))
dirname, network = gen_new_network(i)
network.limit_trade_step = True
step_order_size = SysConfig.get("STEP_ORDER_SIZE")
max_order_num = 1
print(str(datetime.now()) + ': split')
split = count_portfolios_nodes(defender_budget=defender_budget,
attacker_budgets=attacker_budgets,
network=network,
step_order_size=step_order_size,
max_order_num=max_order_num)
print(str(datetime.now()) + ': vanilla')
vanilla = count_ppa_nods(defender_budget=defender_budget,
attacker_budgets=attacker_budgets,
network=network,
step_order_size=step_order_size,
max_order_num=max_order_num)
results.append({
'num_assets': str(i),
'vanilla_cfr': vanilla,
'split_cfr': split
})
with open(res_dir + 'count_game_nodes_ppa.csv', 'w',
newline='') as csvfile:
writer = csv.DictWriter(
csvfile, fieldnames=['num_assets', 'vanilla_cfr', 'split_cfr'])
writer.writeheader()
for row in results:
writer.writerow(row)
def test_minimax(self):
a1 = AssetFundNetwork.Asset(price=100, daily_volume=390, symbol='a1')
f1 = MockFund('f1', a1, 0.82)
SysConfig.set("STEP_ORDER_SIZE", 2 / 390)
SysConfig.set("TIME_STEP_MINUTES", 1)
SysConfig.set('DAILY_PORTION_PER_MIN', 1 / 390)
network = AssetFundNetwork.AssetFundsNetwork(
funds={'f1': f1},
assets={'a1': a1},
mi_calc=MockMarketImpactTestCalculator(),
limit_trade_step=True)
# value, actions, actual_tree = minimax(ROOT_ATTACKER, network, 205,190)
actions_mgr = ActionsManager(network.assets, 2 / 390, 1)
result = minimax(actions_mgr, ATTACKER, network, 205, 190, True)
expected_tree = self.gen_tree()
print(result.value)
print(result.actions)
self.compare_trees(result.tree, expected_tree)
self.assertEqual(int(result.network.assets['a1'].price), 100)
def __init__(self):
sc = SysConfig()
self._conn = sqlite3.connect(sc.getdatabasefiename())
self._c = self._conn.cursor()
def __init__(self):
xml = SimpleXML(Path.executeDirectory())
try:
self.__lngSect = xml.openSection(SysConfig().lngFile)
except Exception, err:
raise err
def get_single_orders(assets, gen_order_func):
orders = []
for asset in assets.values():
order = gen_order_func(asset, SysConfig.get('STEP_ORDER_SIZE'))
orders.append(order)
return orders
