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 get_flash_crash_split_cfr_eq(self,
defender_budget,
attacker_budgets,
network,
step_order_size,
max_order_num,
iterations1,
iterations2,
game_2_pure=False):
network.limit_trade_step = True
# assets, step_order_size, max_order_num=1, attacker_budgets
cfr_actions_mgr = ActionsManager(assets=network.assets,
step_order_size=step_order_size,
max_order_num=max_order_num,
attacker_budgets=attacker_budgets)
split_game_cfr = SplitGameCFR()
root = PortfolioFlashCrashRootChanceGameState(
action_mgr=cfr_actions_mgr,
af_network=network,
defender_budget=defender_budget)
run_results = split_game_cfr.run(
main_game_root=root,
attacker_types=attacker_budgets,
game1_iterations=iterations1,
game2_iterations=iterations2,
attacks_in_budget_dict=cfr_actions_mgr.
get_portfolios_in_budget_dict(),
subgame_keys=cfr_actions_mgr.get_portfolios().keys(),
game_2_pure=game_2_pure)
return run_results
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 get_split_cfr_exploitabilty(defender_budget, attacker_budgets, network,
step_order_size, max_order_num, iterations,
main_game_iteration_portion):
network.limit_trade_step = True
# assets, step_order_size, max_order_num=1, attacker_budgets
cfr_actions_mgr = ActionsManager(assets=network.assets,
step_order_size=step_order_size,
max_order_num=max_order_num,
attacker_budgets=attacker_budgets)
split_game_cfr = SplitGameCFR()
root = PortfolioFlashCrashRootChanceGameState(
action_mgr=cfr_actions_mgr,
af_network=network,
defender_budget=defender_budget)
(main_game_results, selector_game_result) = split_game_cfr.run(
main_game_root=root,
attacker_types=attacker_budgets,
game1_iterations=ceil(iterations * main_game_iteration_portion),
game2_iterations=ceil(iterations * (1 - main_game_iteration_portion)),
attacks_in_budget_dict=cfr_actions_mgr.get_portfolios_in_budget_dict(),
subgame_keys=cfr_actions_mgr.get_portfolios().keys())
return main_game_results['exploitability'] + selector_game_result[
'exploitability']
def _gen_split_main_game_root(self, network):
self.split_actions_mgr = ActionsManager(assets=network.assets,
step_order_size=self.params['step_order_size'],
max_order_num=self.params['max_order_num'],
attacker_budgets=self.params['attacker_budgets'])
self.split_root = PortfolioFlashCrashRootChanceGameState(action_mgr=self.split_actions_mgr, af_network=network,
defender_budget=self.params['defender_budget'])
def count_portfolios_nodes(defender_budget, attacker_budgets, network,
step_order_size, max_order_num):
split_actions_mgr = ActionsManager(assets=network.assets,
step_order_size=step_order_size,
max_order_num=max_order_num,
attacker_budgets=attacker_budgets)
root = PortfolioFlashCrashRootChanceGameState(
action_mgr=split_actions_mgr,
af_network=network,
defender_budget=defender_budget)
dummy_utilities = {
pid: 0
for pid in split_actions_mgr.get_probable_portfolios().keys()
}
p_selector_root = SelectorRootChanceGameState(
attacker_budgets, dummy_utilities,
split_actions_mgr.get_portfolios_in_budget_dict())
return root.tree_size + p_selector_root.tree_size