507 lines
25 KiB
Python
507 lines
25 KiB
Python
import agentpy as ap
|
|
import pandas as pd
|
|
import networkx as nx
|
|
from firm import FirmAgent
|
|
from product import ProductAgent
|
|
from orm import db_session, Result
|
|
import platform
|
|
import json
|
|
|
|
|
|
class Model(ap.Model):
|
|
def setup(self):
|
|
# self parameter
|
|
self.sample = self.p.sample
|
|
self.int_stop_ts = 0
|
|
self.int_n_iter = int(self.p.n_iter)
|
|
self.product_network = None # agentpy network
|
|
self.firm_network = None # agentpy network
|
|
self.firm_prod_network = None # networkx
|
|
self.dct_lst_init_disrupt_firm_prod = \
|
|
self.p.dct_lst_init_disrupt_firm_prod
|
|
|
|
# external variable
|
|
self.int_n_max_trial = int(self.p.n_max_trial)
|
|
self.is_prf_size = bool(self.p.prf_size)
|
|
# self.proactive_ratio = float(self.p.proactive_ratio) # dropped
|
|
self.remove_t = int(self.p.remove_t)
|
|
self.int_netw_prf_n = int(self.p.netw_prf_n)
|
|
|
|
# initialize graph bom
|
|
G_bom = nx.adjacency_graph(json.loads(self.p.g_bom))
|
|
self.product_network = ap.Network(self, G_bom)
|
|
|
|
# initialize graph firm
|
|
Firm = pd.read_csv("Firm_amended.csv")
|
|
Firm['Code'] = Firm['Code'].astype('string')
|
|
Firm.fillna(0, inplace=True)
|
|
Firm_attr = Firm.loc[:, ["Code", "Name", "Type_Region", "Revenue_Log"]]
|
|
firm_product = []
|
|
for _, row in Firm.loc[:, '1':].iterrows():
|
|
firm_product.append(row[row == 1].index.to_list())
|
|
Firm_attr.loc[:, 'Product_Code'] = firm_product
|
|
Firm_attr.set_index('Code', inplace=True)
|
|
G_Firm = nx.MultiDiGraph()
|
|
G_Firm.add_nodes_from(Firm["Code"])
|
|
|
|
firm_labels_dict = {}
|
|
for code in G_Firm.nodes:
|
|
firm_labels_dict[code] = Firm_attr.loc[code].to_dict()
|
|
nx.set_node_attributes(G_Firm, firm_labels_dict)
|
|
|
|
# initialize graph firm prod
|
|
Firm_Prod = pd.read_csv("Firm_amended.csv")
|
|
Firm_Prod.fillna(0, inplace=True)
|
|
firm_prod = pd.DataFrame({'bool': Firm_Prod.loc[:, '1':].stack()})
|
|
firm_prod = firm_prod[firm_prod['bool'] == 1].reset_index()
|
|
firm_prod.drop('bool', axis=1, inplace=True)
|
|
firm_prod.rename({'level_0': 'Firm_Code',
|
|
'level_1': 'Product_Code'}, axis=1, inplace=True)
|
|
firm_prod['Firm_Code'] = firm_prod['Firm_Code'].astype('string')
|
|
G_FirmProd = nx.MultiDiGraph()
|
|
G_FirmProd.add_nodes_from(firm_prod.index)
|
|
|
|
firm_prod_labels_dict = {}
|
|
for code in firm_prod.index:
|
|
firm_prod_labels_dict[code] = firm_prod.loc[code].to_dict()
|
|
nx.set_node_attributes(G_FirmProd, firm_prod_labels_dict)
|
|
|
|
# add edge to G_firm according to G_bom
|
|
for node in nx.nodes(G_Firm):
|
|
lst_pred_product_code = []
|
|
for product_code in G_Firm.nodes[node]['Product_Code']:
|
|
lst_pred_product_code += list(G_bom.predecessors(product_code))
|
|
lst_pred_product_code = list(set(lst_pred_product_code))
|
|
# to generate consistant graph
|
|
lst_pred_product_code = list(sorted(lst_pred_product_code))
|
|
for pred_product_code in lst_pred_product_code:
|
|
# for each product predecessor (component) the firm need
|
|
# get a list of firm producing this component
|
|
lst_pred_firm = \
|
|
Firm['Code'][Firm[pred_product_code] == 1].to_list()
|
|
# select multiple supplier (multi-sourcing)
|
|
n_pred_firm = self.int_netw_prf_n
|
|
if n_pred_firm > len(lst_pred_firm):
|
|
n_pred_firm = len(lst_pred_firm)
|
|
# based on size or not
|
|
if self.is_prf_size:
|
|
lst_pred_firm_size = \
|
|
[G_Firm.nodes[pred_firm]['Revenue_Log']
|
|
for pred_firm in lst_pred_firm]
|
|
lst_prob = \
|
|
[size / sum(lst_pred_firm_size)
|
|
for size in lst_pred_firm_size]
|
|
lst_choose_firm = self.nprandom.choice(lst_pred_firm,
|
|
n_pred_firm,
|
|
replace=False,
|
|
p=lst_prob)
|
|
else:
|
|
lst_choose_firm = self.nprandom.choice(lst_pred_firm,
|
|
n_pred_firm,
|
|
replace=False)
|
|
lst_add_edge = [(pred_firm, node,
|
|
{'Product': pred_product_code})
|
|
for pred_firm in lst_choose_firm]
|
|
G_Firm.add_edges_from(lst_add_edge)
|
|
|
|
# graph firm prod
|
|
set_node_prod_code = set(G_Firm.nodes[node]['Product_Code'])
|
|
set_pred_succ_code = set(G_bom.successors(pred_product_code))
|
|
lst_use_pred_prod_code = list(
|
|
set_node_prod_code & set_pred_succ_code)
|
|
for pred_firm in lst_choose_firm:
|
|
pred_node = [n for n, v in G_FirmProd.nodes(data=True)
|
|
if v['Firm_Code'] == pred_firm and
|
|
v['Product_Code'] == pred_product_code][0]
|
|
for use_pred_prod_code in lst_use_pred_prod_code:
|
|
current_node = \
|
|
[n for n, v in G_FirmProd.nodes(data=True)
|
|
if v['Firm_Code'] == node and
|
|
v['Product_Code'] == use_pred_prod_code][0]
|
|
G_FirmProd.add_edge(pred_node, current_node)
|
|
# nx.to_pandas_adjacency(G_Firm).to_csv('adj_g_firm.csv')
|
|
# nx.to_pandas_adjacency(G_FirmProd).to_csv('adj_g_firm_prod.csv')
|
|
|
|
# connect unconnected nodes
|
|
for node in nx.nodes(G_Firm):
|
|
if G_Firm.degree(node) == 0:
|
|
for product_code in G_Firm.nodes[node]['Product_Code']:
|
|
# unconnected node does not have possible suppliers,
|
|
# therefore find possible customer instead
|
|
# current node in graph firm prod
|
|
current_node = \
|
|
[n for n, v in G_FirmProd.nodes(data=True)
|
|
if v['Firm_Code'] == node and
|
|
v['Product_Code'] == product_code][0]
|
|
|
|
lst_succ_product_code = list(
|
|
G_bom.successors(product_code))
|
|
# different from: for different types of product,
|
|
# finding a common supplier (the logic above),
|
|
# instead: for different types of product,
|
|
# finding a customer for each product
|
|
for succ_product_code in lst_succ_product_code:
|
|
# for each product successor (finished product)
|
|
# the firm sells to,
|
|
# get a list of firm producing this finished product
|
|
lst_succ_firm = Firm['Code'][
|
|
Firm[succ_product_code] == 1].to_list()
|
|
# select multiple customer (multi-selling)
|
|
n_succ_firm = self.int_netw_prf_n
|
|
if n_succ_firm > len(lst_succ_firm):
|
|
n_succ_firm = len(lst_succ_firm)
|
|
# based on size or not
|
|
if self.is_prf_size:
|
|
lst_succ_firm_size = \
|
|
[G_Firm.nodes[succ_firm]['Revenue_Log']
|
|
for succ_firm in lst_succ_firm]
|
|
lst_prob = \
|
|
[size / sum(lst_succ_firm_size)
|
|
for size in lst_succ_firm_size]
|
|
lst_choose_firm = \
|
|
self.nprandom.choice(lst_succ_firm,
|
|
n_succ_firm,
|
|
replace=False,
|
|
p=lst_prob)
|
|
else:
|
|
lst_choose_firm = \
|
|
self.nprandom.choice(lst_succ_firm,
|
|
n_succ_firm,
|
|
replace=False)
|
|
lst_add_edge = [(node, succ_firm,
|
|
{'Product': product_code})
|
|
for succ_firm in lst_choose_firm]
|
|
G_Firm.add_edges_from(lst_add_edge)
|
|
|
|
# graph firm prod
|
|
for succ_firm in lst_choose_firm:
|
|
succ_node = \
|
|
[n for n, v in G_FirmProd.nodes(data=True)
|
|
if v['Firm_Code'] == succ_firm and
|
|
v['Product_Code'] == succ_product_code][0]
|
|
G_FirmProd.add_edge(current_node, succ_node)
|
|
|
|
self.sample.g_firm = json.dumps(nx.adjacency_data(G_Firm))
|
|
self.firm_network = ap.Network(self, G_Firm)
|
|
self.firm_prod_network = G_FirmProd
|
|
# import matplotlib.pyplot as plt
|
|
# nx.draw(G_FirmProd)
|
|
# plt.show()
|
|
|
|
# initialize product
|
|
for ag_node, attr in self.product_network.graph.nodes(data=True):
|
|
product = ProductAgent(self, code=ag_node.label, name=attr['Name'])
|
|
self.product_network.add_agents([product], [ag_node])
|
|
self.a_lst_total_products = ap.AgentList(self,
|
|
self.product_network.agents)
|
|
|
|
# initialize firm
|
|
for ag_node, attr in self.firm_network.graph.nodes(data=True):
|
|
firm_agent = FirmAgent(
|
|
self,
|
|
code=ag_node.label,
|
|
name=attr['Name'],
|
|
type_region=attr['Type_Region'],
|
|
revenue_log=attr['Revenue_Log'],
|
|
a_lst_product=self.a_lst_total_products.select([
|
|
code in attr['Product_Code']
|
|
for code in self.a_lst_total_products.code
|
|
]))
|
|
|
|
self.firm_network.add_agents([firm_agent], [ag_node])
|
|
self.a_lst_total_firms = ap.AgentList(self, self.firm_network.agents)
|
|
|
|
# initialize dct_lst_init_disrupt_firm_prod (from string to agent)
|
|
t_dct = {}
|
|
for firm_code, lst_product in \
|
|
self.dct_lst_init_disrupt_firm_prod.items():
|
|
firm = self.a_lst_total_firms.select(
|
|
self.a_lst_total_firms.code == firm_code)[0]
|
|
t_dct[firm] = self.a_lst_total_products.select([
|
|
code in lst_product for code in self.a_lst_total_products.code
|
|
])
|
|
self.dct_lst_init_disrupt_firm_prod = t_dct
|
|
|
|
# set the initial firm product that are disrupted
|
|
# print('\n', '=' * 20, 'step', self.t, '=' * 20)
|
|
for firm, a_lst_product in self.dct_lst_init_disrupt_firm_prod.items():
|
|
for product in a_lst_product:
|
|
assert product in firm.dct_prod_up_prod_stat.keys(), \
|
|
f"product {product.code} not in firm {firm.code}"
|
|
firm.dct_prod_up_prod_stat[
|
|
product]['p_stat'].append(('D', self.t))
|
|
# print(f"initial disruption {firm.name} {product.code}")
|
|
|
|
# # proactive strategy (dropped)
|
|
# # get all the firm prod affected
|
|
# for firm, a_lst_product in self.dct_lst_init_disrupt_firm_prod.items():
|
|
# for product in a_lst_product:
|
|
# init_node = \
|
|
# [n for n, v in
|
|
# self.firm_prod_network.nodes(data=True)
|
|
# if v['Firm_Code'] == firm.code and
|
|
# v['Product_Code'] == product.code][0]
|
|
# dct_affected = \
|
|
# nx.dfs_successors(self.firm_prod_network,
|
|
# init_node)
|
|
# lst_affected = set()
|
|
# for i, (u, vs) in enumerate(dct_affected.items()):
|
|
# # at least 2 hops away
|
|
# if i > 0:
|
|
# pred_node = self.firm_prod_network.nodes[u]
|
|
# for v in vs:
|
|
# succ_node = self.firm_prod_network.nodes[v]
|
|
# lst_affected.add((succ_node['Firm_Code'],
|
|
# succ_node['Product_Code']))
|
|
# lst_affected = list(lst_affected)
|
|
# lst_firm_proactive = \
|
|
# [lst_affected[i] for i in
|
|
# self.nprandom.choice(range(len(lst_affected)),
|
|
# round(len(lst_affected) *
|
|
# self.proactive_ratio),
|
|
# replace=False)]
|
|
|
|
# for firm_code, prod_code in lst_firm_proactive:
|
|
# pro_firm_prod_code = \
|
|
# [n for n, v in
|
|
# self.firm_prod_network.nodes(data=True)
|
|
# if v['Firm_Code'] == firm_code and
|
|
# v['Product_Code'] == prod_code][0]
|
|
# pro_firm_prod_node = \
|
|
# self.firm_prod_network.nodes[pro_firm_prod_code]
|
|
# pro_firm = \
|
|
# self.a_lst_total_firms.select(
|
|
# [firm.code == pro_firm_prod_node['Firm_Code']
|
|
# for firm in self.a_lst_total_firms])[0]
|
|
# lst_shortest_path = \
|
|
# list(nx.all_shortest_paths(self.firm_prod_network,
|
|
# source=init_node,
|
|
# target=pro_firm_prod_code))
|
|
|
|
# dct_drs = {}
|
|
# for di_supp_code in self.firm_prod_network.predecessors(
|
|
# pro_firm_prod_code):
|
|
# di_supp_node = \
|
|
# self.firm_prod_network.nodes[di_supp_code]
|
|
# di_supp_prod = \
|
|
# self.a_lst_total_products.select(
|
|
# [product.code == di_supp_node['Product_Code']
|
|
# for product in self.a_lst_total_products])[0]
|
|
# di_supp_firm = \
|
|
# self.a_lst_total_firms.select(
|
|
# [firm.code == di_supp_node['Firm_Code']
|
|
# for firm in self.a_lst_total_firms])[0]
|
|
# lst_cand = self.a_lst_total_firms.select([
|
|
# firm.is_prod_in_current_normal(di_supp_prod)
|
|
# for firm in self.a_lst_total_firms
|
|
# ])
|
|
# n2n_betweenness = \
|
|
# sum([True if di_supp_code in path else False
|
|
# for path in lst_shortest_path]) \
|
|
# / len(lst_shortest_path)
|
|
# drs = n2n_betweenness / \
|
|
# (len(lst_cand) * di_supp_firm.size_stat[-1][0])
|
|
# dct_drs[di_supp_code] = drs
|
|
# dct_drs = dict(sorted(
|
|
# dct_drs.items(), key=lambda kv: kv[1], reverse=True))
|
|
# for di_supp_code in dct_drs.keys():
|
|
# di_supp_node = \
|
|
# self.firm_prod_network.nodes[di_supp_code]
|
|
# di_supp_prod = \
|
|
# self.a_lst_total_products.select(
|
|
# [product.code == di_supp_node['Product_Code']
|
|
# for product in self.a_lst_total_products])[0]
|
|
# # find a dfferent firm can produce the same product
|
|
# # and is not a current supplier for the same product
|
|
# lst_current_supp_code = \
|
|
# [self.firm_prod_network.nodes[code]['Firm_Code']
|
|
# for code in self.firm_prod_network.predecessors(
|
|
# pro_firm_prod_code)
|
|
# if self.firm_prod_network.nodes[code][
|
|
# 'Product_Code'] == di_supp_prod.code]
|
|
# lst_cand = self.model.a_lst_total_firms.select([
|
|
# firm.is_prod_in_current_normal(di_supp_prod)
|
|
# and firm.code not in lst_current_supp_code
|
|
# for firm in self.model.a_lst_total_firms
|
|
# ])
|
|
# if len(lst_cand) > 0:
|
|
# select_cand = self.nprandom.choice(lst_cand)
|
|
# self.firm_network.graph.add_edges_from([
|
|
# (self.firm_network.positions[select_cand],
|
|
# self.firm_network.positions[pro_firm], {
|
|
# 'Product': di_supp_prod.code
|
|
# })
|
|
# ])
|
|
# # print(f"proactive add {select_cand.name} to "
|
|
# # f"{pro_firm.name} "
|
|
# # f"for {di_supp_node['Firm_Code']} "
|
|
# # f"{di_supp_node['Product_Code']}")
|
|
# # change capacity
|
|
# select_cand.dct_prod_capacity[di_supp_prod] -= 1
|
|
# break
|
|
# # nx.to_pandas_adjacency(G_Firm).to_csv('adj_g_firm_proactive.csv')
|
|
|
|
# draw network
|
|
# self.draw_network()
|
|
|
|
def update(self):
|
|
self.a_lst_total_firms.clean_before_time_step()
|
|
|
|
# reduce the size of disrupted firm
|
|
for firm in self.a_lst_total_firms:
|
|
for prod in firm.dct_prod_up_prod_stat.keys():
|
|
status, ts = firm.dct_prod_up_prod_stat[prod]['p_stat'][-1]
|
|
if status == 'D':
|
|
size = firm.size_stat[-1][0] - \
|
|
firm.size_stat[0][0] \
|
|
/ len(firm.dct_prod_up_prod_stat.keys()) \
|
|
/ self.remove_t
|
|
firm.size_stat.append((size, self.t))
|
|
# print(f'in ts {self.t}, reduce {firm.name} size '
|
|
# f'to {firm.size_stat[-1][0]} due to {prod.code}')
|
|
lst_is_disrupt = \
|
|
[stat == 'D' for stat, _ in
|
|
firm.dct_prod_up_prod_stat[prod]['p_stat']
|
|
[-1 * self.remove_t:]]
|
|
if all(lst_is_disrupt):
|
|
# turn disrupted firm into removed firm
|
|
# when last self.remove_t times status is all disrupted
|
|
firm.dct_prod_up_prod_stat[
|
|
prod]['p_stat'].append(('R', self.t))
|
|
|
|
# stop simulation if any firm still in disrupted except initial removal
|
|
if self.t > 0:
|
|
for firm in self.a_lst_total_firms:
|
|
for prod in firm.dct_prod_up_prod_stat.keys():
|
|
status, _ = firm.dct_prod_up_prod_stat[prod]['p_stat'][-1]
|
|
is_init = \
|
|
firm in self.dct_lst_init_disrupt_firm_prod.keys() \
|
|
and prod in self.dct_lst_init_disrupt_firm_prod[firm]
|
|
if status == 'D' and not is_init:
|
|
# print("not stop because", firm.name, prod.code)
|
|
break
|
|
else:
|
|
continue
|
|
break
|
|
else:
|
|
self.int_stop_ts = self.t
|
|
self.stop()
|
|
|
|
if self.t == self.int_n_iter:
|
|
self.stop()
|
|
|
|
def step(self):
|
|
# print('\n', '=' * 20, 'step', self.t, '=' * 20)
|
|
|
|
# remove edge to customer and disrupt customer up product
|
|
for firm in self.a_lst_total_firms:
|
|
for prod in firm.dct_prod_up_prod_stat.keys():
|
|
# repetition of disrupted firm that last for multiple ts is ok,
|
|
# as their edge has already been removed
|
|
status, ts = firm.dct_prod_up_prod_stat[prod]['p_stat'][-1]
|
|
if status == 'D' and ts == self.t-1:
|
|
firm.remove_edge_to_cus(prod)
|
|
|
|
for firm in self.a_lst_total_firms:
|
|
for prod in firm.dct_prod_up_prod_stat.keys():
|
|
for up_prod in firm.dct_prod_up_prod_stat[prod][
|
|
's_stat'].keys():
|
|
if firm.dct_prod_up_prod_stat[prod][
|
|
's_stat'][up_prod]['set_disrupt_firm']:
|
|
firm.disrupt_cus_prod(prod, up_prod)
|
|
|
|
for n_trial in range(self.int_n_max_trial):
|
|
# print('=' * 10, 'trial', n_trial, '=' * 10)
|
|
# seek_alt_supply
|
|
# shuffle self.a_lst_total_firms
|
|
self.a_lst_total_firms = self.a_lst_total_firms.shuffle()
|
|
is_stop_trial = True
|
|
for firm in self.a_lst_total_firms:
|
|
lst_seek_prod = []
|
|
for prod in firm.dct_prod_up_prod_stat.keys():
|
|
status = firm.dct_prod_up_prod_stat[prod]['p_stat'][-1][0]
|
|
if status == 'D':
|
|
for supply in firm.dct_prod_up_prod_stat[
|
|
prod]['s_stat'].keys():
|
|
if not firm.dct_prod_up_prod_stat[
|
|
prod]['s_stat'][supply]['stat']:
|
|
lst_seek_prod.append(supply)
|
|
# commmon supply only seek once
|
|
lst_seek_prod = list(set(lst_seek_prod))
|
|
if len(lst_seek_prod) > 0:
|
|
is_stop_trial = False
|
|
for supply in lst_seek_prod:
|
|
firm.seek_alt_supply(supply)
|
|
if is_stop_trial:
|
|
break
|
|
|
|
# handle_request
|
|
# shuffle self.a_lst_total_firms
|
|
self.a_lst_total_firms = self.a_lst_total_firms.shuffle()
|
|
for firm in self.a_lst_total_firms:
|
|
if len(firm.dct_request_prod_from_firm) > 0:
|
|
firm.handle_request()
|
|
|
|
# reset dct_request_prod_from_firm
|
|
self.a_lst_total_firms.clean_before_trial()
|
|
|
|
def end(self):
|
|
# print('/' * 20, 'output', '/' * 20)
|
|
|
|
qry_result = db_session.query(Result).filter_by(s_id=self.sample.id)
|
|
if qry_result.count() == 0:
|
|
lst_result_info = []
|
|
for firm in self.a_lst_total_firms:
|
|
for prod, dct_status_supply in \
|
|
firm.dct_prod_up_prod_stat.items():
|
|
lst_is_normal = [stat == 'N' for stat, _
|
|
in dct_status_supply['p_stat']]
|
|
if not all(lst_is_normal):
|
|
# print(f"{firm.name} {prod.code}:")
|
|
# print(dct_status_supply['p_stat'])
|
|
for status, ts in dct_status_supply['p_stat']:
|
|
db_r = Result(s_id=self.sample.id,
|
|
id_firm=firm.code,
|
|
id_product=prod.code,
|
|
ts=ts,
|
|
status=status)
|
|
lst_result_info.append(db_r)
|
|
db_session.bulk_save_objects(lst_result_info)
|
|
db_session.commit()
|
|
self.sample.is_done_flag = 1
|
|
self.sample.computer_name = platform.node()
|
|
self.sample.stop_t = self.int_stop_ts
|
|
db_session.commit()
|
|
|
|
def draw_network(self):
|
|
import matplotlib.pyplot as plt
|
|
plt.rcParams['font.sans-serif'] = 'SimHei'
|
|
pos = nx.nx_agraph.graphviz_layout(self.firm_network.graph,
|
|
prog="twopi",
|
|
args="")
|
|
node_label = nx.get_node_attributes(self.firm_network.graph, 'Name')
|
|
node_degree = dict(self.firm_network.graph.out_degree())
|
|
node_label = {
|
|
key: f"{key} {node_label[key]} {node_degree[key]}"
|
|
for key in node_label.keys()
|
|
}
|
|
node_size = list(
|
|
nx.get_node_attributes(self.firm_network.graph,
|
|
'Revenue_Log').values())
|
|
node_size = list(map(lambda x: x**2, node_size))
|
|
edge_label = nx.get_edge_attributes(self.firm_network.graph, "Product")
|
|
# multi(di)graphs, the keys are 3-tuples
|
|
edge_label = {(n1, n2): label
|
|
for (n1, n2, _), label in edge_label.items()}
|
|
plt.figure(figsize=(12, 12), dpi=300)
|
|
nx.draw(self.firm_network.graph,
|
|
pos,
|
|
node_size=node_size,
|
|
labels=node_label,
|
|
font_size=6)
|
|
nx.draw_networkx_edge_labels(self.firm_network.graph,
|
|
pos,
|
|
edge_label,
|
|
font_size=4)
|
|
plt.savefig("network.png")
|