def evaluate_justice(model):
"""
Evaluate a model by its alignment with respect to justice.
"""
params = {
'num_agents': model.num_agents,
'collecting_rates': model.collecting_rates,
'redistribution_rates': model.redistribution_rates,
'invest_rate': model.invest_rate,
'num_evaders': model.num_evaders,
'catch': model.catch,
'fine_rate': model.fine_rate
}
batch_run = BatchRunner(model_cls=Society,
fixed_parameters=params,
iterations=paths,
max_steps=length,
agent_reporters={
"Position": "position",
"Evader": "is_evader"
},
display_progress=False)
batch_run.run_all()
info = batch_run.get_agent_vars_dataframe()
evaders_info = info[info['Evader']]
algn = -1 + 2 * evaders_info["Position"].mean() / (params["num_agents"] -
1)
return algn
def aggregate_equality_justice(model):
"""
Evaluate a model by its alignment aggregated over equality and justice.
"""
params = {
'num_agents': model.num_agents,
'collecting_rates': model.collecting_rates,
'redistribution_rates': model.redistribution_rates,
'invest_rate': model.invest_rate,
'num_evaders': model.num_evaders,
'catch': model.catch,
'fine_rate': model.fine_rate
}
batch_run = BatchRunner(
model_cls=Society,
fixed_parameters=params,
iterations=paths,
max_steps=length,
model_reporters={"Gini_wealth": compute_gini_wealth},
agent_reporters={
"Position": "position",
"Evader": "is_evader"
},
display_progress=False)
batch_run.run_all()
# get gini index info
model_data = batch_run.get_model_vars_dataframe()
f = (1 - 2 * model_data["Gini_wealth"]).values
# get justice-related info
agent_data = batch_run.get_agent_vars_dataframe()
evaders_data = agent_data[agent_data["Evader"]]
g = np.array([])
for run in evaders_data["Run"].unique():
evaders_info_run = evaders_data[evaders_data["Run"] == run]
g = np.append(g, [
-1 + 2 * evaders_info_run["Position"].mean() /
(model.num_agents - 1)
])
# get F function
algn = 0
for x, y in zip(f, g):
if x < 0 and y < 0:
algn -= x * y
else:
algn += x * y
return algn / paths
class TestBatchRunner(unittest.TestCase):
"""
Test that BatchRunner is running batches
"""
def setUp(self):
"""
Create the model and run it for some steps
"""
self.model_reporter = {"model": lambda m: m.model_param}
self.agent_reporter = {
"agent_id": lambda a: a.unique_id,
"agent_val": lambda a: a.val
}
self.params = {
'model_param': range(3),
'agent_param': [1, 8],
}
self.iterations = 17
self.batch = BatchRunner(MockModel,
self.params,
iterations=self.iterations,
max_steps=3,
model_reporters=self.model_reporter,
agent_reporters=self.agent_reporter)
self.batch.run_all()
def test_model_level_vars(self):
"""
Test that model-level variable collection is of the correct size
"""
model_vars = self.batch.get_model_vars_dataframe()
rows = len(self.params['model_param']) * \
len(self.params['agent_param']) * \
self.iterations
assert model_vars.shape == (rows, 4)
def test_agent_level_vars(self):
"""
Test that agent-level variable collection is of the correct size
"""
agent_vars = self.batch.get_agent_vars_dataframe()
rows = NUM_AGENTS * \
len(self.params['agent_param']) * \
len(self.params['model_param']) * \
self.iterations
assert agent_vars.shape == (rows, 6)
class TestBatchRunner(unittest.TestCase):
"""
Test that BatchRunner is running batches
"""
def setUp(self):
"""
Create the model and run it for some steps
"""
self.model_reporter = {"model": lambda m: m.model_param}
self.agent_reporter = {
"agent_id": lambda a: a.unique_id,
"agent_val": lambda a: a.val}
self.params = {
'model_param': range(3),
'agent_param': [1, 8],
}
self.iterations = 17
self.batch = BatchRunner(
MockModel,
self.params,
iterations=self.iterations,
max_steps=3,
model_reporters=self.model_reporter,
agent_reporters=self.agent_reporter)
self.batch.run_all()
def test_model_level_vars(self):
"""
Test that model-level variable collection is of the correct size
"""
model_vars = self.batch.get_model_vars_dataframe()
rows = len(self.params['model_param']) * \
len(self.params['agent_param']) * \
self.iterations
assert model_vars.shape == (rows, 4)
def test_agent_level_vars(self):
"""
Test that agent-level variable collection is of the correct size
"""
agent_vars = self.batch.get_agent_vars_dataframe()
rows = NUM_AGENTS * \
len(self.params['agent_param']) * \
len(self.params['model_param']) * \
self.iterations
assert agent_vars.shape == (rows, 6)
def run_model(method):
if method == "single":
total_results = []
for x in range(1000):
test = SocialDyn(4, 60, 10)
#results = None
print("RUN ", x)
for i in range(20):
#print ("STEP " , i, "\n\n\n")
test.step()
#
results = test.datacollector.get_agent_vars_dataframe()
total_results.append(results)
res2 = pd.concat(total_results)
res2.to_csv("single_results.csv")
else:
variable_params = {
"width": range(10, 25, 5),
"N": range(10, 50, 10),
"R": range(10, 50, 10)
}
batch_run = BatchRunner(SocialDyn,
fixed_parameters=None,
variable_parameters=variable_params,
iterations=5,
max_steps=100,
agent_reporters = {"Scaling A": 'scaling_a' ,\
"Scaling B" : 'scaling_b', \
"Capacity": 'capacity', \
"Land Owned": 'land_owned', \
"Conquered": 'conquered'})
batch_run.run_all()
results = batch_run.get_agent_vars_dataframe()
results.to_csv("results.csv")
variable_params = {"N": range(10, 50, 10)}
batch_run = BatchRunner(MoneyModel,
variable_parameters=variable_params,
fixed_parameters=fixed_params,
iterations=5,
max_steps=100,
model_reporters={"Gini": compute_gini},
agent_reporters={"Wealth": "wealth"},
display_progress=True)
batch_run.run_all()
run_data = batch_run.get_model_vars_dataframe()
run_data.head()
run_data_agents = batch_run.get_agent_vars_dataframe()
plt.scatter(run_data.N, run_data.Gini)
server.port = 8521
server.launch()
# =============================================================================
# =============================================================================
# model = MoneyModel(100)
#
# #for j in range(10):
# for i in range(1):
# model.step()
# #print(a.unique_id)
#
#
import datetime
import numpy as np
from mesa.batchrunner import BatchRunner
from LanguageShift.LanguageModel import LanguageModel
model_params = {'diffusivity': [0.013, 0.009], 'timestep': 1, 'filename': 'doctoreddata.csv',
'grid_pickle': 'neighbor.pkl'}
model_reporters = {}
agent_reporters = {"pop": lambda x: x.population,
"p_p_german": lambda x: x.p_probability[0],
"p_p_slovene": lambda x: x.p_probability[1],
"p_german": lambda x: x.probability[0],
"p_slovene": lambda x: x.probability[1],
"p_diff": lambda x: np.sum(np.abs(x.probability - x.p_probability)),
"lat": lambda x: x.pos[0],
"long": lambda x: x.pos[1]}
batch = BatchRunner(LanguageModel, parameter_values=model_params, agent_reporters=agent_reporters, max_steps=30,
iterations=1)
batch.run_all()
batch.get_agent_vars_dataframe().to_csv('batch_output' + str(datetime.date.today()))
from mesa.batchrunner import BatchRunner
from AntModel import AntModel
from DataCollection import ant_state_collector
# Default settings
STEP_COUNT = 300
NUM_LNIGER = 300
NUM_FJAPON = 30
NUM_MK_COL = 5
NUM_FT_COL = 5
GRID_WIDTH = 150
GRID_HEIGHT = 150
fixed_params = {"width": GRID_WIDTH,
"height": GRID_HEIGHT,
"num_ln": NUM_LNIGER,
"num_mk_col": NUM_MK_COL,
"num_ft_col": NUM_FT_COL}
variable_params = {"num_fj": range(0, 50)}
batch_run = BatchRunner(AntModel,
fixed_parameters=fixed_params,
variable_parameters=variable_params,
iterations=5,
max_steps=STEP_COUNT,
agent_reporters={"State:": ant_state_collector})
batch_run.run_all()
df = batch_run.get_agent_vars_dataframe()
df.to_csv(path_or_buf="out.csv")
"preference": ["attractiveness", "matching", "mixed"],
"mean_male": [5, 10],
"sd_male": [1],
"mean_female": [5, 10],
"sd_female": [1]
}
br = BatchRunner(KalickHamilton,
br_params,
iterations=3,
max_steps=1000,
model_reporters={"Data Collector": lambda m: m.datacollector},
agent_reporters={"name": "name"})
# ============================
#### Run & export data ####
# ============================
if __name__ == '__main__':
br.run_all()
br_df = br.get_model_vars_dataframe()
br_a_df = br.get_agent_vars_dataframe()
br_step_data = pd.DataFrame()
br_step_agent_data = pd.DataFrame()
for i in range(len(br_df["Data Collector"])):
if isinstance(br_df["Data Collector"][i], DataCollector):
i_run_data = br_df["Data Collector"][i].get_model_vars_dataframe()
i_run_adata = br_df["Data Collector"][i].get_agent_vars_dataframe()
br_step_data = br_step_data.append(i_run_data, ignore_index=True)
br_step_agent_data = br_step_agent_data.append(i_run_adata,
ignore_index=True)
br_step_data.to_csv("./data/KHG_model_data.csv")
br_step_agent_data.to_csv("./data/KHG_agents_data.csv")
