def test_network_list(self):
network1 = network_init.generate_network("grid")
network2 = network_init.generate_network("ring")
experiment = Experiment(
network = 'list',
attributes_initializer = 'random_continuous',
influence_function = 'bounded_confidence',
network_parameters = {
'network': [network1, network2]
}
)
print(experiment.run())
class TestDissimilarityCalculator(TestCase):
networkTest = network_init.generate_network("grid")
networkCategorical = network_init.generate_network("grid")
networkContinuous = network_init.generate_network("grid")
def test_HammingDistance_calculate_dissimilarity(self):
self.networkTest.nodes[0]["a"] = 0.5
self.networkTest.nodes[0]["b"] = 0.6
self.networkTest.nodes[1]["a"] = 0.3
self.networkTest.nodes[1]["b"] = 0.6
self.assertEqual(
HammingDistance().calculate_dissimilarity(self.networkTest, 0, 1),
0.5)
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)
networkCategorical2 = network_init.generate_network("grid")
networkContinuous2 = network_init.generate_network("grid")
def test_EuclideanDistance_calculate_dissimilarity(self):
self.networkTest.nodes[0]["a"] = 0.5
self.networkTest.nodes[1]["a"] = 0.3
self.assertEqual(
EuclideanDistance().calculate_dissimilarity(
self.networkTest, 0, 1), 0.2)
self.networkTest.nodes[0]["b"] = 0.2
self.networkTest.nodes[1]["c"] = 0.8
self.assertEqual(
EuclideanDistance().calculate_dissimilarity(
self.networkTest, 0, 1),
math.sqrt((0.5 - 0.3)**2 + (0.2 - 0.8)**2) / math.sqrt(2))
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_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'])
class TestNetworkRewiring(TestCase):
network = network_init.generate_network("grid")
def test_rewire_network(self):
initial_edges = list(self.network.edges)
network_evolution_sim.rewire_network(network=self.network,
realization='maslov_sneppen',
**{"rewiring_prop": 0.1})
self.assertNotEqual(initial_edges, list(self.network.edges))
@unittest.expectedFailure
def test_rewire_network_bad_realization(self):
network_evolution_sim.rewire_network(network=self.network,
realization='thisisnotreal')
def test_MaslovSneppen(self):
initial_edges = list(self.network.edges)
MaslovSneppenModifier(rewiring_prop=0.1).rewire_network(
network=self.network)
self.assertNotEqual(initial_edges, list(self.network.edges))
initial_edges = list(self.network.edges)
MaslovSneppenModifier(rewiring_exact=4).rewire_network(
network=self.network)
self.assertNotEqual(initial_edges, list(self.network.edges))
initial_edges = list(self.network.edges)
MaslovSneppenModifier(
rewiring_prop=0.1,
rewiring_exact=10).rewire_network(network=self.network)
self.assertNotEqual(initial_edges, list(self.network.edges))
def test_spatial_random_graph():
graph = network_init.generate_network(
"spatial_random_graph", **{
"num_agents": 16,
"min_neighbors": 8
})
assert type(graph) is nx.Graph
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 test_from_network_init(self):
network_init.generate_network(
"grid",
network_modifiers=[MaslovSneppenModifier(rewiring_prop=0.1)])
def test_generate_network(self):
graph = network_init.generate_network("spatial_random_graph")
self.assertEqual(type(graph), nx.Graph)
graph = network_init.generate_network("cycle_graph", **{"n": 30})
self.assertEqual(type(graph), nx.Graph)
def test100():
for i in range(1000000):
random.choice(list100)
def test5000():
for i in range(1000000):
random.choise(list5000)
print("2000000 choices from list of length 100 take %f seconds" %
(timeit.timeit(test100, number=1)))
print("2000000 choices from list of length 5000 take %f seconds" %
(timeit.timeit(test100, number=1)))
network49 = network_init.generate_network("grid")
for item, thingy in network49.nodes.items():
print(item)
print(thingy)
network5000 = network_init.generate_network("grid", **{"num_agents": 5000})
print(network49.edges().toList())
# checking whether the access to a single node takes longer in big networks
def testAccessSmall():
for i in range(10000000):
a = network49[1]
def testAccessLarge():
for i in range(10000000):
def timeAttributeInitialization49():
network = network_init.generate_network("grid")
for i in range(100):
agents_init.initialize_attributes(network, "random")
def timeNetworkCreation1000():
network = network_init.generate_network(
"grid", **{
"num_agents": 1000000,
"neighborhood": "von_neumann"
})
def timeNetworkCreation49():
for i in range(100):
network = network_init.generate_network(
"grid", **{**{
"neighborhood": "von_neumann"
}})