def test_run_experiment(self):
"""
Tests if run_experiment works properly
"""
try:
nl4py.initialize(self.nl_path)
except:
self.fail("NL4Py.intialize() fails!")
def setup_model(run):
return "setup-full"
run_count = 20
tick_count = 10
reporters = ["ticks", "count turtles"]
all_runs_results = nl4py.run_experiment(
model_name=self.ethnocentrism_model,
setup_callback=setup_model,
setup_data=range(run_count),
reporters=reporters,
start_at_tick=0,
interval_ticks=1,
stop_at_tick=tick_count)
self.assertEqual(all_runs_results.Run.unique().shape[0], run_count)
for _, run_results in all_runs_results.groupby("Run"):
self.assertEqual(
run_results['Setup Commands'].iloc[0].replace(" ", ""),
setup_model(0).replace(" ", ""))
self.assertEqual(len(run_results['ticks'].unique()), tick_count)
self.assertEqual(
run_results.drop(['Run', 'Setup Commands'], axis=1).shape[1],
len(reporters))
self.assertEqual(
run_results.ticks.astype(float).astype(int).tolist(),
list(range(1, tick_count + 1)))
def test_int(self):
"""
Test that nl4py intializes
"""
try:
nl4py.initialize(self.nl_path)
except:
self.fail("NL4Py.intialize() fails!")
try:
nl4py.initialize(self.nl_path)
except:
self.fail("NL4Py.intialize() fails when called more than once!")
def __init__(self,
netlogo_path: str,
model_path: str,
setup_commands: List[str],
measurement_reporters: List[str],
ticks_to_run: int,
go_command: str = 'go',
agg_func: Callable = np.mean) -> None:
"""
Evolutionary model discovery experiment. Can be used to perform genetic programming
of NetLogo models and factor importance analysis of resulting data using random
forest importance analysis.
See:
Gunaratne, C., & Garibay, I. (2020). Evolutionary model discovery
3of causal factors behind the socio-agricultural behavior of the
Ancestral Pueblo. Plos one, 15(12), e0239922.
Gunaratne, C., Rand, W., & Garibay, I. (2021). Inferring mechanisms
of response prioritization on social media under information overload.
Scientific reports, 11(1), 1-12.
:param netlogo_path: str path to folder with NetLogo executable
:param model_path: str path to NetLogo .nlogo model file
:param setup_commands: List[str] or List[List[str]] of NetLogo commands to be executed on simulation setup.
List[List[str]] indicates simulation replicates per element of major list.
:param measurement_reporters: List[str] of NetLogo reporters to be run per simulation
executed per simulation tick and reported to
objective function callback
:param ticks_to_run: int number of ticks to run each simulation for
:param go_command: str command to run NetLogo simulations (default: 'go')
:param agg_func: Callable function used to aggregate results of multiple replicates
"""
# Initialize ABM
self.model_init_data = {
'model_path': model_path,
'setup_commands': setup_commands,
'measurement_commands': measurement_reporters,
'ticks_to_run': ticks_to_run,
'go_command': go_command,
'agg_func': agg_func
}
self.replications = 1
ModelFactors, netlogo_writer = self._parse_model_into_factors()
# Starting NL4Py
nl4py.initialize(netlogo_path)
self.gp = SimpleDEAPGP(self.model_init_data, ModelFactors,
netlogo_writer)
self.factor_scores_file_name = 'FactorScores.csv'
def test_schedule_reporters(self):
"""
Tests if schedule_reporters works properly
"""
try:
nl4py.initialize(self.nl_path)
except:
self.fail("NL4Py.intialize() fails!")
workspace = nl4py.create_headless_workspace()
workspace.open_model(self.ethnocentrism_model)
workspace.command("setup-full")
tick_count = 10
reporters = ["ticks", "count turtles"]
results = workspace.schedule_reporters(reporters=reporters,
start_at_tick=0,
interval_ticks=1,
stop_at_tick=tick_count,
go_command='go')
self.assertEqual(len(results), tick_count)
for idx, result in enumerate(results):
self.assertEqual(len(result), len(reporters))
self.assertEqual(eval(result[0]), idx + 1)
def test_basic_model_execution(self):
"""
Tests model running basics with the Ethnocentrism.nlogo model.
"""
try:
nl4py.initialize(self.nl_path)
except:
self.fail("NL4Py.intialize() fails!")
workspace = nl4py.create_headless_workspace()
workspace.open_model(self.ethnocentrism_model)
workspace.command("setup-empty")
ticks = workspace.report("ticks")
turtle_count = workspace.report("count turtles")
self.assertEqual(ticks, 0)
self.assertEqual(turtle_count, 0)
workspace.command("setup-full")
ticks = workspace.report("ticks")
turtle_count = workspace.report("count turtles")
self.assertEqual(ticks, 0)
self.assertGreater(turtle_count, 0)
workspace.command("repeat 10 [go]")
ticks = workspace.report("ticks")
self.assertEqual(ticks, 10)
import os
import sys
import multiprocessing
import nl4py
netlogo_path = str(sys.argv[1])
model_path = str(sys.argv[2])
runs_needed = int(sys.argv[3])
ticks_needed = int(sys.argv[4])
nl4py.initialize(netlogo_path)
def init(model_path):
global netlogo
netlogo = nl4py.create_headless_workspace()
netlogo.open_model(model_path)
def run_simulation_fire(runId):
global netlogo
# Same netlogo commands as used for the NL4Py evaluation
netlogo.command("random-seed " + str(runId))
netlogo.command("set dddddensity 57")
netlogo.command('setup')
measures = ['ticks', 'burned-trees']
results = netlogo.schedule_reporters(measures, stopAtTick=ticks_needed)
return results
def run_simulation_ethnocentrism(runId):
global netlogo
### This file measures the execution time by NL4Py to run 200 runs of the
### Fire.nlogo model for 100 ticks or until stop condition is met
### To run provide the location of your NetLogo installation as a commandline argument
### Example: >>>python nl4py_gunaratne2018_5.1.1.py "C:/Program Files/NetLogo 6.0.2"
import time
import sys
import nl4py
nl4py.initialize(sys.argv[1])
workspace = nl4py.create_headless_workspace()
modelRuns = 100
ticks_to_run = 100
workspace.open_model("Models/Fire.nlogo")
def is_running(workspace):
#print("{} {}".format(float(workspace.report("ticks")) ,
# str(workspace.report("not any? turtles")).lower()))
return (float(workspace.report("ticks")) != ticks_to_run
and str(workspace.report("not any? turtles")).lower() != "true")
for i in range(0, modelRuns):
workspace.command("set density random 99")
workspace.command("setup")
workspace.command("repeat {} [go]".format(ticks_to_run))
while is_running(workspace):
time.sleep(0.001)
r1 = workspace.report("burned-trees")
