def test_spread_influence(self):
network1 = network_init.generate_network("grid", **{"num_agents": 4})
agents_init.initialize_attributes(network1, "random_continuous",
**{"num_features": 1})
EuclideanDistance().calculate_dissimilarity_networkwide(network1)
# run one instance to see if it doesn't break (most simple test)
WeightedLinear.WeightedLinear(
regime="one-to-many",
**{
"convergence_rate": 0.5,
"homophily": 1,
"bi_directional": False
}).spread_influence(network1,
0, [neighbor for neighbor in network1[0]],
attributes=None,
dissimilarity_measure=EuclideanDistance())
# with bi-directional influence, let two agents find agreement
WeightedLinear.WeightedLinear(
regime="one-to-one",
**{
"convergence_rate": 0.5,
"homophily": 0,
"bi_directional": True
}).spread_influence(
network1,
1, #sending agent
0, #receiving agent
attributes=None,
dissimilarity_measure=EuclideanDistance())
self.assertEqual(network1.nodes[1]['f01'], network1.nodes[0]['f01'])
def test_EuclideanDistance_calculate_dissimilarity_networkwide(self):
agents_init.initialize_attributes(self.networkCategorical2,
"random_categorical")
agents_init.initialize_attributes(self.networkContinuous2,
"random_continuous")
EuclideanDistance().calculate_dissimilarity_networkwide(
self.networkContinuous2)
EuclideanDistance().calculate_dissimilarity_networkwide(
self.networkCategorical2)
def test_HammingDistance_calculate_dissimilarity_networkwide(self):
agents_init.initialize_attributes(self.networkCategorical,
"random_categorical")
agents_init.initialize_attributes(self.networkContinuous,
"random_continuous")
HammingDistance().calculate_dissimilarity_networkwide(
self.networkContinuous)
HammingDistance().calculate_dissimilarity_networkwide(
self.networkCategorical)
def timeIterationStepOneToOne9():
network = network_init.generate_network("grid", **{"num_agents": 9})
agents_init.initialize_attributes(network, "random")
all_attributes = network.nodes[1].keys()
random.seed("random")
for i in range(2000000):
agentid = focal_agent_sim.select_focal_agent(network, "random")
neighborsid = neighbor_selector_sim.select_neighbors(
network, "random", agentid, "one-to-one")
influence_sim.spread_influence(network, "axelrod",
[agentid], neighborsid,
list(all_attributes), "one-to-one")
def timeIterationStepOneToMany49Overlap():
network = network_init.generate_network("grid")
agents_init.initialize_attributes(network, "random")
all_attributes = network.nodes[1].keys()
random.seed("random")
for i in range(2000000):
agentid = focal_agent_sim.select_focal_agent(network, "random")
neighborsid = neighbor_selector_sim.select_neighbors(
network, "random", agentid, "one-to-many")
influence_sim.spread_influence(network, "stochasticOverlap",
agentid, neighborsid,
list(all_attributes), "one-to-many")
def initialize(self):
"""
This method initializes the network if none is given, applies network modifiers, initializes the attributes of the agents,
and also computes and sets the distances between each neighbor.
"""
# reset steps
self.time_steps = 0
self.influence_steps = 0
# reset tickwise output
self.initialize_tickwise_output()
if self.seed is None:
self.seed = random.randint(10000, 99999)
random.seed(self.seed)
self.parameter_dict['np_random_generator'] = np.random.default_rng(self.seed)
## if deprecated ms_rewiring parameter is set in parameter dict, replace with network modifier
if 'ms_rewiring' in list(self.parameter_dict.keys()):
warnings.warn(
"Setting ms_rewiring in parameter dict is deprecated. Pass an instance of MaslovSneppenModifier in network_modifiers instead.",
DeprecationWarning)
if self.network_modifiers is None:
self.network_modifiers = [MaslovSneppenModifier(rewiring_prop=self.parameter_dict['ms_rewiring'])]
else:
self.network_modifiers.append(MaslovSneppenModifier(rewiring_prop=self.parameter_dict['ms_rewiring']))
# read or generate network if no nx.Graph was provided, apply network modifiers
if self.network_provided:
if self.network == 'list':
self.network = self.parameter_dict.pop('network')
if not isinstance(self.network, nx.Graph) and self.network is not None:
self.network = network_init.read_network(self.network)
## apply network modifiers
if self.network_modifiers is not None:
for modifier in self.network_modifiers:
modifier.rewire_network(network)
else:
self.network = network_init.generate_network(self.topology, network_modifiers=self.network_modifiers,
**self.parameter_dict)
# storing the indices of the agents to access them quicker
self.agentIDs = list(self.network)
# initialize agent attributes (accepts string realizations and instances of AttributesInitializer classes)
agents_init.initialize_attributes(self.network, self.attributes_initializer, **self.parameter_dict)
# initialization of distances between neighbors
self.dissimilarity_calculator.calculate_dissimilarity_networkwide(self.network)
def test_random_continuous(self):
network1 = network_init.generate_network("grid", **{"num_agents": 4})
# default values
agents_init.initialize_attributes(network1, "random_continuous")
# more features
agents_init.initialize_attributes(network1, "random_continuous",
**{"num_features": 3})
# non-implemented distribution
with self.assertRaises(NotImplementedError):
agents_init.initialize_attributes(
network1, "random_continuous", **{
"distribution": "notimplemented",
"num_features": 1
})
from defSim.network_init import network_init
from defSim.agents_init import agents_init
from defSim.dissimilarity_component.HammingDistance import HammingDistance
from defSim.tools import NetworkDistanceUpdater
import networkx.algorithms.isomorphism as iso
import timeit
import random
random.seed("random")
network = network_init.generate_network("grid")
agents_init.initialize_attributes(network, "random_categorical")
network_comparison = network.copy()
HammingDistance().calculate_dissimilarity_networkwide(network)
all_attributes = network.nodes[1].keys()
def test_isomorphic():
for i in range(10000):
nm = iso.categorical_node_match(all_attributes, [0 for i in range(len(all_attributes))])
print("10000 isomorphism checks")
print("Time: "+str(timeit.timeit(test_isomorphic, number=1)))
def test_dissimilarity_check():
for i in range(10000):
NetworkDistanceUpdater.check_dissimilarity(network,1)
print("10000 dissimilarity checks")
print("Time: "+str(timeit.timeit(test_dissimilarity_check, number=1)))
def timeAttributeInitialization1000():
for i in range(100):
agents_init.initialize_attributes(network, "random")
def timeAttributeInitialization49():
network = network_init.generate_network("grid")
for i in range(100):
agents_init.initialize_attributes(network, "random")
network = network_init.generate_network("grid")
for i in range(100):
agents_init.initialize_attributes(network, "random")
#network = NetworkBuilder.generate_network("grid", **{"num_agents": 5000})
def timeAttributeInitialization1000():
for i in range(100):
agents_init.initialize_attributes(network, "random")
# print("Initializing 100 networks with 49 agents each takes %f seconds" %(timeit.timeit(timeAttributeInitialization49, number=1)))
# print("Initializing 100 networks with 1000 agents each takes %f seconds" %(timeit.timeit(timeAttributeInitialization1000, number=1)))
network = network_init.generate_network("grid")
agents_init.initialize_attributes(network, "random_continuous",
**{"num_features": 3})
all_attributes = network.node[1].keys()
HammingDistance.calculate_dissimilarity_networkwide(network)
agents = list(network)
def timeIterationStepOneToOne49():
random.seed("random")
for i in range(2000000):
agentid = focal_agent_sim.select_focal_agent(network, "random", agents)
neighborsid = neighbor_selector_sim.select_neighbors(
network, "random", agentid, "one-to-one")
influence_sim.spread_influence(network, "axelrod",
agentid, neighborsid,
list(all_attributes), "one-to-one")
