def firefly_blink(agent, **kwargs):
"""
Blinks the given firefly agent by chaning its group. If the firefly is
already ON, this function turns if OFF. Otherwise, checks if the
the time passed since last blink time of the firefly agent is
greater than the agent's blinking frequency.
"""
# Calculate the blink parameter
blink_frequency = agent.get_attr(BLINK_FREQUENCY)
time_since_last_blink = abs(
agent.get_attr(LAST_BLINKED_AT) - agent.duration)
# Get the previous group name
old_group = agent.group_name()
# Turn OFF if the firefly is ON
if old_group == FIREFLY_ON:
agent.set_prim_group(FIREFLY_OFF)
# Turn ON if the blinking time has arrived
elif time_since_last_blink >= blink_frequency:
agent.set_prim_group(FIREFLY_ON)
# Reset the attribute
agent.set_attr(LAST_BLINKED_AT, agent.duration)
# Perform the actual switch
get_model(agent.exec_key).add_switch(str(agent), old_group,
agent.group_name())
def agent_action(agent, **kwargs):
"""
The action determines what state the agent is in.
If CALM, and lots of panic about, flip to PANIC.
If PANICKED, but lots of CALM about, flip to CALM.
"""
mdl = get_model(agent.exec_key)
if mdl.get_periods() == 0:
print("In start panic condition")
start_panic(agent.exec_key)
if agent.group_name() == CALM:
ratio = neighbor_ratio(agent,
lambda agent: agent.group_name() == PANIC)
if ratio > PANIC_THRESHHOLD:
if DEBUG.debug:
print("Changing the agent's group to panic!")
agent.has_acted = True
mdl.add_switch(str(agent), CALM, PANIC)
elif agent.group_name() == PANIC:
ratio = neighbor_ratio(agent, lambda agent: agent.group_name() == CALM)
if ratio > CALM_THRESHHOLD:
if DEBUG.debug:
print("Changing the agent's group to calm!")
agent.has_acted = True
get_model(agent.exec_key).add_switch(str(agent), PANIC, CALM)
return DONT_MOVE
def start_panic(exec_key):
maxPosn = panic_grps[CALM][WIDTH] * panic_grps[CALM][HEIGHT]
num_panic = panic_grps[PANIC][PANICKED]
for i in range(0, num_panic):
agent_posn = rand.randint(0, maxPosn)
agent_name = "Calm" + str(agent_posn)
agent = get_agent(agent_name, exec_key)
if agent is not None and agent.group_name() == CALM:
get_model(exec_key).add_switch(agent_name, CALM, PANIC)
def reproduce(agent, **kwargs):
# Check if it is time to produce
if agent.get_attr(TIME_TO_REPRODUCE) == 0:
if DEBUG.debug:
print(str(agent.name) + " is having a baby!")
# Create babies: need group name here!
get_model(agent.exec_key).add_child(agent.prim_group_nm())
# Reset ttr
agent.set_attr(TIME_TO_REPRODUCE, DEF_TIME_TO_REPRO)
def start_panic(exec_key):
"""
This function should be rewritten.
We will make a new group method called `get_rand_subset(n)`.
Then we will flip those agents to panicked.
"""
maxPosn = panic_grps[CALM][WIDTH] * panic_grps[CALM][HEIGHT]
num_panic = panic_grps[PANIC][PANICKED]
for i in range(0, num_panic):
agent_posn = rand.randint(0, maxPosn)
agent_name = "Calm" + str(agent_posn)
agent = get_agent(agent_name, exec_key)
if agent is not None and agent.group_name() == CALM:
get_model(exec_key).add_switch(agent_name, CALM, PANIC)
def change_color(agent, opp_group):
"""
change agent's DISPLAY_COLOR to its opposite color
"""
if DEBUG.debug:
print(
"Agent ",
agent.name,
" is changing colors; its prim group is ",
agent.prim_group_nm(),
)
agent.set_attr(DISPLAY_COLOR, not agent.get_attr(DISPLAY_COLOR))
get_model(agent.exec_key).add_switch(str(agent), agent.prim_group_nm(),
opp_group[agent.prim_group_nm()])
def post(self, exec_key):
"""
Setup a test model in the registry.
"""
model_name = None
if 'model_name' in api.payload:
model_name = api.payload['model_name']
if model_name is None:
# exec_key is supposed to match the model id if model_name is
# not given
model = get_model_by_id(exec_key, indra_dir)
if model is None:
raise (wz.NotFound(f"Model {exec_key} doesn't exist."))
# check if a test model already exists against the given exec_
# key which matches the model id
model = get_model(exec_key)
if model is not None:
return {"msg": f'A test model {model.name} already exists'}
else:
return model.to_json()
else:
model_rec = get_model_by_name(model_name, indra_dir)
if model_rec is None:
raise wz.NotFound(f'Model with name {model_name} is not found')
model = create_model_for_test(model_rec, exec_key)
return json_converter(model)
def test_get_model(self):
"""
Register a model and fetch it back.
"""
self.model = Model(exec_key=self.exec_key)
reg_model(self.model, self.exec_key)
self.assertEqual(self.model, get_model(self.exec_key))
def test_model_save_load_run_from_disk(self, dump, load):
DEF_GRP[GRP_ACTION] = self.complex_agent_action
DEF_GRP[MBR_CREATOR] = self.complex_agent_create
SECOND_GRP = DEF_GRP.copy()
SECOND_GRP[COLOR] = RED
GRP_STRUCT = {
"COMPLEX_RED_GRP": SECOND_GRP,
"COMPLEX_BLUE_GRP": DEF_GRP
}
complexModel = Model(grp_struct=GRP_STRUCT, model_nm="Basic")
complexModel.run(5)
registry.save_reg(key=complexModel.exec_key)
registry.load_reg(complexModel.exec_key)
loaded_object = get_model(complexModel.exec_key)
self.assertTrue(type(loaded_object) == Model)
self.assertTrue("Basic" == loaded_object.module)
all_red_members_have_attribute_5 = True
all_blue_memebrs_have_attribute_10 = True
deserialized_model = loaded_object
deserialized_model.run(5)
for grp in deserialized_model.groups:
for member in grp.members:
if grp.color == BLUE:
all_blue_memebrs_have_attribute_10 = \
all_blue_memebrs_have_attribute_10 and (
grp[member].get_attr("value") != 5)
else:
all_red_members_have_attribute_5 = \
all_red_members_have_attribute_5 and (
grp[member].get_attr("value") == 5)
self.assertTrue(all_red_members_have_attribute_5)
self.assertTrue(all_blue_memebrs_have_attribute_10)
def tree_action(agent, **kwargs):
"""
A simple default agent action.
"""
model = get_model(agent.exec_key)
if model is None:
print("ERROR: get_model() returned None.")
return DONT_MOVE
old_group = agent.group_name()
if old_group == HEALTHY:
if exists_neighbor(agent, lambda agent: agent.group_name() == ON_FIRE):
agent.set_prim_group(NEW_FIRE)
# if we didn't catch on fire above, do probabilistic transition:
if old_group == agent.group_name():
curr_state = STATE_MAP[old_group]
# we gotta do these str/int shenanigans with state cause
# JSON only allows strings as dict keys
agent.set_prim_group(GROUP_MAP[str(prob_state_trans(int(curr_state),
state_trans))])
if DEBUG.debug:
if agent.group_name == NEW_FIRE:
print("Tree spontaneously catching fire.")
if old_group != agent.group_name():
if DEBUG.debug:
print(f"Add switch from {old_group} to {agent.group_name()}")
model.add_switch(str(agent),
old_group,
agent.group_name())
return DONT_MOVE
def main(args):
py_model = registry.get_model(args.model)
py_eval_setting = registry.get_eval_setting(args.eval_setting)
if args.db and utils.evaluation_completed(py_model, py_eval_setting):
print(f'Evaluation for {py_model.name} x {py_eval_setting.name} already found. Skipping...')
return
args.num_gpus = torch.cuda.device_count()
results_dict = mp.Manager().dict()
mp.spawn(main_worker, nprocs=args.num_gpus, args=(args, results_dict))
idx_sorted, idx_map = torch.cat([results_dict[i]['idxs'] for i in range(args.num_gpus)]).sort()
assert idx_sorted.eq(idx_sorted.unique()).all(), 'Error collecting results'
assert idx_sorted.eq(torch.tensor(list(range(idx_sorted.size(0))))).all(), 'Error collecting results'
logits = torch.cat([results_dict[i]['logits'] for i in range(args.num_gpus)])[idx_map]
targets = torch.cat([results_dict[i]['targets'] for i in range(args.num_gpus)])[idx_map]
image_paths = np.concatenate([results_dict[i]['image_paths'] for i in range(args.num_gpus)])[idx_map]
metrics = py_eval_setting.get_metrics(logits, targets, image_paths, py_model)
with open(join(args.logdir, 'metrics.json'), 'w') as outfile:
json.dump(metrics, outfile)
torch.save(logits, join(args.logdir, 'logits.pt'))
torch.save(targets, join(args.logdir, 'targets.pt'))
if args.db:
utils.store_evaluation(py_model, py_eval_setting, metrics, logits)
print('Uploaded to db')
utils.close_db_connection()
print('************************************')
print(f'RESULT {args.model} on {args.eval_setting} - {metrics}')
print('************************************')
def drinker_action(agent, **kwargs):
"""
To go or not to go, that is the question.
The decision is based on the agent's memory of how crowded the
bar has been recently (a parameter).
"""
if DEBUG.debug:
print("Alcoholic {} is located at {}".format(agent.name,
agent.get_pos()))
bar = get_model(agent.exec_key)
percent_full = memory_check(agent)
# agent motivation is inverse agent's memory of percentage full
agent[MOTIV] = 1 - percent_full
going = get_decision(agent)
if agent.group_name() == AT_HOME:
if going:
bar.add_switch(str(agent), AT_HOME, AT_BAR)
else:
if not going:
bar.add_switch(str(agent), AT_BAR, AT_HOME)
# Updating the agent's memory for last night.
# There might be a better place to do this.
# doing it here has a one day lag.
population = sum([len(group.members) for group in bar.groups])
attendance = bar.env.pop_hist.pops[AT_BAR]
last_att_perc = attendance[-1] / population
agent[MEMORY].pop(0)
agent[MEMORY].append(last_att_perc)
return MOVE
def main_worker(gpu, args, results_dict):
dist.init_process_group(backend=args.backend, init_method=args.dist_url, world_size=args.num_gpus, rank=gpu)
torch.cuda.set_device(gpu)
registry.load_full_registry()
py_model = registry.get_model(args.model)
py_eval_setting = registry.get_eval_setting(args.eval_setting)
model = py_model.generate_classifier(py_eval_setting)
model = model.cuda()
model = torch.nn.parallel.DistributedDataParallel(model, device_ids=[gpu])
batch_size = py_model.get_batch_size(py_eval_setting)
gpu_perturbation_fn = py_eval_setting.get_perturbation_fn_gpu(py_model)
torch.set_grad_enabled(py_eval_setting.adversarial_attack is not None)
setting_transform = [py_eval_setting.transform] if py_eval_setting.transform is not None else []
val_dataset = CustomImageFolder(
root = py_eval_setting.get_dataset_root(),
transform = transforms.Compose(setting_transform + [py_model.transform]),
perturbation_fn = py_eval_setting.get_perturbation_fn_cpu(py_model),
idx_subsample_list = py_eval_setting.get_idx_subsample_list(py_model),
)
val_sampler = DistributedSampler(val_dataset, num_replicas=args.num_gpus, rank=gpu, shuffle=False)
val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False,
num_workers=args.workers, pin_memory=True, sampler=val_sampler)
logits, targets, image_paths, idxs = validate(gpu, args, val_loader, model, gpu_perturbation_fn)
results_dict[gpu] = {'logits': logits, 'targets': targets, 'image_paths': image_paths, 'idxs': idxs}
def get_model_if_exists(exec_key):
"""
A function that returns the model running at `exec_key`
or raises a 404 error if it doesn't exist.
"""
model = get_model(exec_key)
if model is None:
raise wz.NotFound(f"Model Key: {exec_key}, not found.")
return model
def agent_action(agent, **kwargs):
"""
This is what agents do each turn of the model.
"""
if DEBUG.debug:
print("The agent is called", agent)
global first_period
if first_period:
start_panic(agent.exec_key)
first_period = False
if agent.group_name() == CALM:
ratio = neighbor_ratio(agent,
lambda agent: agent.group_name() == PANIC)
if ratio > THRESHHOLD:
if DEBUG.debug:
print("Changing the agent's group to panic!")
agent.has_acted = True
get_model(agent.exec_key).add_switch(str(agent), CALM, PANIC)
return DONT_MOVE
def consumer_action(consumer, **kwargs):
"""
Check shops near consumer and
consumer decide where to shop at.
"""
global item_needed
item_needed = consumer.get_attr(ITEM_NEEDED)
box = get_model(consumer.exec_key)
hood_size = box.props.get("hood_size", DEF_HOOD_SIZE)
sellers = get_neighbors(consumer, pred=sells_good, size=hood_size)
shop_at = choose_store(consumer, sellers.members.items())
if shop_at is not None:
transaction(shop_at, consumer)
consumer[ITEM_NEEDED] = get_rand_good()
return MOVE
def utils_from_good(store, good):
'''
Return util for each choice of retailers
with preference for mom-and-pop
'''
grp = str(store.primary_group())
box = get_model(store.exec_key)
mp_pref = box.mp_pref
# add preference if good sold in mom and pop
if grp == MP_STORE:
if good in store.get_attr(GOODS_SOLD):
return (random.random() + store.get_attr(UTIL_ADJ)) * mp_pref
elif grp == BIG_BOX:
return NO_PREF
return NOT_AVAIL
def extract_metadata(df):
df_metadata = df.copy()
df_metadata['arch'] = [
registry.get_model(x.name).arch
if registry.contains_model(x.name) else 'N/A' for x in df.model
]
for col in df_metadata.columns:
if type(col) == EvaluationSetting:
size = registry.get_eval_setting(
col.name.replace('_pm0', '').replace('_pm10', '')).size
df_metadata[col.name +
'_dataset_size'] = [size] * df_metadata.shape[0]
df_metadata = df_metadata.drop(columns=col)
df, df_metadata = strip_metadata(df), strip_metadata(df_metadata)
return df, df_metadata
def town_action(town):
"""
Create big box store at appropriate turn.
"""
bb_grp = get_group(BIG_BOX, town.exec_key)
box = get_model(town.exec_key)
bb_period = box.bb_period
bb_init_capital = box.multiplier * AVG_MP_INIT_CAP
# if no big box exists, make them:
num_bbs = len(bb_grp)
if num_bbs == 0:
if town.get_periods() >= bb_period:
new_bb = bb_grp.mbr_creator(BIG_BOX,
num_bbs,
bb_init_capital,
exec_key=town.exec_key)
join(bb_grp, new_bb)
town.place_member(new_bb)
def view_model(user, update=False):
from registry.registry import get_model
return user.debug(repr(get_model(user.exec_key)))
def bar_graph(user, update=False):
from registry.registry import get_model
return get_model(user.exec_key).bar_graph()
def scatter_plot(user, update=False):
from registry.registry import get_model
return get_model(user.exec_key).scatter_plot()
