def risk_for_me_all(graph: DiGraph,
node_id,
iterations=70,
mu=0.2,
beta=0.6,
delay=2,
weight_transfer=False):
risks = []
for node_i in graph:
node = graph.nodes[node_i]
if node['id'] != node_id:
set_initial_defaults(graph, node['id'])
sn = SecNet(graph,
mu,
beta,
reconnection_policy=ReconnectionPolicy.RANDOM,
default_delay=delay,
weight_transfer=weight_transfer)
sn.run(iterations)
#sn.run(5)
#for i in range(iterations):
# if(sn.defaulted_density[-1]>0):
# sn.run(1)
# else:
# break
risks.append(
[node['id'], sn.graph.nodes[node_id]['first_defaulted_at']])
for lis in risks:
if (lis[1] == -1):
lis[1] = 0
else:
lis[1] = 1. - lis[1] / 100.
return risks
def risk_for_me_one_strict(graph: DiGraph,
node_id_me,
node_id_other,
repetitions=20,
iterations=100,
mu=0.2,
beta=0.6,
delay=2,
weight_transfer=False):
risks = []
for i in range(repetitions):
set_initial_defaults(graph, node_id_other)
sn = SecNet(graph,
mu,
beta,
reconnection_policy=ReconnectionPolicy.RANDOM,
default_delay=delay,
weight_transfer=weight_transfer)
sn.run(iterations)
risk = sn.graph.nodes[node_id_me]['first_defaulted_at']
if risk == -1:
risk = 0
else:
risk = 1
risks.append(risk)
return np.mean(risks)
def run_simulation(graph, mu, beta, policy, delay, weight_transfer,
max_iterations, show):
g = graph.copy()
if policy == 'RANDOM':
sn = SecNet(g,
mu,
beta,
reconnection_policy=ReconnectionPolicy.RANDOM,
default_delay=delay,
weight_transfer=weight_transfer)
elif policy == 'SOFT':
sn = SecNet(g,
mu,
beta,
reconnection_policy=ReconnectionPolicy.SOFT,
default_delay=delay,
weight_transfer=weight_transfer)
elif policy == 'NONE':
sn = SecNet(graph,
mu,
beta,
reconnection_policy=ReconnectionPolicy.NONE,
default_delay=delay,
weight_transfer=weight_transfer)
else:
print('Policy not understood')
return 0
sn.run(max_iterations, variation_coeff=10e-5)
if show:
sn.plot()
return check_cascade_size_recursive(sn.graph)
def replicate_density(niter=100,
beta=0.6,
default_delay=2,
policy=ReconnectionPolicy.SOFT,
file_plot='images/Replicate_density/beta_0.4'):
dens = []
densities = []
fig = figure()
plot = fig.add_subplot(111)
for i in range(niter):
sn = SecNet(g,
mu=0.2,
beta=beta,
reconnection_policy=policy,
default_delay=default_delay,
weight_transfer=False)
sn.run(400, variation_coeff=10e-5)
plot.plot(sn.defaulted_density)
dens.append(sn.defaulted_density[-1])
sn.defaulted_density
fig.suptitle(' Simulations function with n = %s' % niter)
plt.xlabel('Iteratuinons')
plt.ylabel('Density ')
file = file_plot + str(policy) + str(beta) + str(default_delay) + '.png'
fig.savefig(file)
show()
return (dens)
def beta_plot(g: DiGraph,
mu=0.1,
iterations=75,
file_plot='images/prob_by_sector',
policy='SOFT',
default_delay=4):
betas = np.arange(0, 1, 0.02)
density_probs = []
for beta in betas:
if policy == 'NONE':
sn = SecNet(g, mu, beta,
reconnection_policy=ReconnectionPolicy.NONE,
default_delay=default_delay, weight_transfer=False)
elif policy == 'RANDOM':
sn = SecNet(g, mu, beta,
reconnection_policy=ReconnectionPolicy.RANDOM,
default_delay=default_delay, weight_transfer=False)
elif policy == 'SOFT':
sn = SecNet(g, mu, beta,
reconnection_policy=ReconnectionPolicy.SOFT,
default_delay=default_delay, weight_transfer=False)
elif policy == 'STRONG':
sn = SecNet(g, mu, beta,
reconnection_policy=ReconnectionPolicy.STRONG,
default_delay=default_delay, weight_transfer=False)
else:
return ('policy not found.')
sn.run(iterations)
# sn.graph to access the copied graph
prob_by_sector = np.zeros(17)
for sector in range(0, 17):
nodes = sn.nodes_per_sector[sector]
n = len(nodes)
for node_id in nodes:
node = sn.graph.nodes[node_id]
prob_by_sector[sector] += node['defaulted']
prob_by_sector[sector] = prob_by_sector[sector] / n
density_probs.append(prob_by_sector)
print(density_probs)
probs_by_sector = construct_probs_by_sector(density_probs)
print(probs_by_sector)
plt.figure()
for prob in probs_by_sector:
plt.plot(betas, prob)
plt.legend(loc='upper left')
plt.title('Random sample with %s reconnection policy' % policy)
plt.legend(loc='upper left')
plt.xlabel('betas')
plt.ylabel('density prob')
file = file_plot + policy + str(default_delay) + '.png'
plt.savefig(file)
plt.show()
def run_density(graph: DiGraph, mu, beta, policy, delay, max_iterations):
g = graph.copy()
sn = SecNet(g, mu, beta, reconnection_policy=policy, default_delay=delay)
sn.run(max_iterations)
return sn.defaulted_density
def sectorial_multi_beta(g: DiGraph, mu=0.1, beta_lapse=0.02, repetitions=5,
max_iterations=150, filename='results/density/prob_by_sector',
policy='SOFT', default_delay=4, num_sectors=17):
betas = np.arange(0, 1, beta_lapse)
if policy == 'NONE':
recon_policy = ReconnectionPolicy.NONE
elif policy == 'RANDOM':
recon_policy = ReconnectionPolicy.RANDOM
elif policy == 'SOFT':
recon_policy = ReconnectionPolicy.SOFT
elif policy == 'STRONG':
recon_policy = ReconnectionPolicy.STRONG
else:
print('policy not found.')
return 0
density_probs = []
for beta in betas:
prob_by_sector_total = np.zeros(num_sectors)
prob_by_sector = np.zeros((num_sectors, repetitions))
for i in range(repetitions):
sn = SecNet(g, mu, beta,
reconnection_policy=recon_policy,
default_delay=default_delay, weight_transfer=False)
sn.run(max_iter=max_iterations, variation_coeff=10e-5)
for sector in range(num_sectors):
nodes = sn.nodes_per_sector[sector]
n = len(nodes)
for node_id in nodes:
node = sn.graph.nodes[node_id]
prob_by_sector[sector, i] += node['defaulted']
prob_by_sector[sector, i] = prob_by_sector[sector, i] / n
for j in range(num_sectors):
prob_by_sector_total[j] = np.mean(prob_by_sector[j, :])
density_probs.append(prob_by_sector_total)
# print(density_probs)
probs_by_sector = construct_probs_by_sector(density_probs)
# print(probs_by_sector)
filename = filename + policy + str(default_delay) + '.pickle'
pickle.dump(probs_by_sector, open(filename, 'wb'))
return probs_by_sector
def density_with_sigma(graph,mu=0.2,beta=0.6,policy=ReconnectionPolicy.SOFT,delay = 6,
repetitions=10,filename = 'BA/results/densitySOFT6.pikle'):
densities = pd.DataFrame(columns=['Iteration','Density','delay'])
for i in range(repetitions):
sn = SecNet(graph, mu, beta, reconnection_policy=policy,default_delay=delay)
sn.run(200)
for j in range(200):
densities.loc[200*i+j]=[j,sn.defaulted_density[j],delay]
densities.to_pickle(filename)
return densities
def simulate(graph, mu, beta, recon_policy, default_delay, max_iterations, num_sectors):
prob_by_sector = np.zeros(num_sectors)
sn = SecNet(graph, mu, beta,
reconnection_policy=recon_policy,
default_delay=default_delay, weight_transfer=False)
sn.run(max_iter=max_iterations, variation_coeff=10e-5)
for sector in range(num_sectors):
nodes = sn.nodes_per_sector[sector]
n = len(nodes)
for node_id in nodes:
node = sn.graph.nodes[node_id]
prob_by_sector[sector] += node['defaulted']
prob_by_sector[sector] = prob_by_sector[sector] / n
return prob_by_sector
def run_sectorial_d(graph,mu, beta, recon_policy,delay, iterations,num_sectors):
sn = SecNet(graph, mu, beta,reconnection_policy = recon_policy,
default_delay = delay, weight_transfer = False)
density_by_sector = np.zeros((num_sectors,iterations))
for i in range(iterations):
sn.run(1,verbose=False)
for sector in range(num_sectors):
nodes = sn.nodes_per_sector[sector]
n = len(nodes)
for node_id in nodes:
node = sn.graph.nodes[node_id]
density_by_sector[sector,i] += node['defaulted']
density_by_sector[sector,i] = density_by_sector[sector,i] / n
print("1 Done")
return density_by_sector
def risk_cascades_sectorial(graph: DiGraph,
num_sectors,
repetitions_per_node=15,
max_iterations=150,
mu=0.2,
beta=0.6,
amount_per_sector=10,
policy='RANDOM',
delays=[2, 4, 6]):
risks = np.zeros(num_sectors * len(delays))
maximums = np.zeros(num_sectors * len(delays))
#doesnt matter what to pu tis just to apply the nodes by sector function
sn = SecNet(graph,
mu,
beta,
reconnection_policy=ReconnectionPolicy.RANDOM,
default_delay=2,
weight_transfer=False)
for sector in range(num_sectors):
risk = np.zeros((amount_per_sector, len(delays)))
maximum = np.zeros((amount_per_sector, len(delays)))
eligible_nodes = sn.nodes_per_sector[sector]
nodes = np.random.choice(eligible_nodes, size=amount_per_sector)
r = 0
for node_id in nodes:
sizes = cascades_setting_defaults(graph,
node_id,
repetitions_per_node,
max_iterations,
mu,
beta,
delays,
policy=policy)
risk[r], maximum[r] = assessment(sizes, delays)
r += 1
for i in range(len(delays)):
risks[len(delays) * sector + i] = np.mean(risk[:, i])
maximums[len(delays) * sector + i] = np.max(maximum[:, i])
return risks, maximums
def sectorial_cascades_sizes(graph: DiGraph,
num_sectors,
repetitions_per_node=15,
max_iterations=150,
mu=0.2,
beta=0.6,
nodes_per_sector=5,
policy='RANDOM',
delay=[2]):
sn = SecNet(graph,
mu,
beta,
reconnection_policy=ReconnectionPolicy.RANDOM,
default_delay=2,
weight_transfer=False)
sector_sizes = []
for sector in range(num_sectors):
sizes = []
eligible_nodes = sn.nodes_per_sector[sector]
nodes = np.random.choice(eligible_nodes, size=nodes_per_sector)
for node_id in nodes:
size = cascades_setting_defaults(graph,
node_id,
repetitions_per_node,
max_iterations,
mu,
beta,
delay,
policy=policy)
[sizes.append(siz) for siz in size]
sector_sizes.append(sizes)
return sector_sizes
def density_plot(g: DiGraph,
mu=0.4,
beta=0.6,
iterations=200,
file_plot='images/density/density_by_policy'):
for policy in ['SOFT', 'RANDOM']:
for default_delay in [2, 4, 6, 8]:
if policy == 'NONE':
sn = SecNet(g, mu=mu, beta=beta,
reconnection_policy=ReconnectionPolicy.NONE,
default_delay=0, weight_transfer=False)
elif policy == 'RANDOM':
sn = SecNet(g, mu=mu, beta=beta,
reconnection_policy=ReconnectionPolicy.RANDOM,
default_delay=default_delay, weight_transfer=False)
elif policy == 'SOFT':
sn = SecNet(g, mu=mu, beta=beta,
reconnection_policy=ReconnectionPolicy.SOFT,
default_delay=default_delay, weight_transfer=False)
elif policy == 'STRONG':
sn = SecNet(g, mu=mu, beta=beta,
reconnection_policy=ReconnectionPolicy.STRONG,
default_delay=default_delay, weight_transfer=False)
file = file_plot + policy + str(default_delay) + '.png'
sn.run(iterations, variation_coeff=10e-5)
sn.plot('Defaulted companies for %s' % policy,
save=True,
file_name=file)
