def generate_test_ukf(n, prop, start_model):
""" generate a seeded ukf_model for testing
"""
test_model = deepcopy(start_model)
n = model_params["pop_total"]
model_params, ukf_params = omission_params(n, prop)
u = ukf_ss(model_params, ukf_params, test_model)
u.main()
obs, preds, truths, nan_array = u.data_parser()
return u, obs, preds, truths
def ex3_main(n, recall, do_pickle, source, destination):
"""main function to run experiment 1
- build model and ukf dictionary parameters based on n and prop
- initiate Model and ukf_ss based on new dictionaries
- run ABM with filtering on top
- make plots using finished run data
Parameters
------
n, prop : float
`n` population and proportion observed 0<=`prop`<=1
recall, do_pickle : bool
`recall` a previous run or `do_pickle` pickle a new one?
pickle_source : str
`pickle_source` where to load/save any pickles.
"""
if not recall:
model_params = configs.model_params
ukf_params = configs.ukf_params
model_params, ukf_params, base_model = ex3_params(
n, model_params, ukf_params)
base_models = []
for i in range(int((4 * n) + 1)):
base_models.append(deepcopy(base_model))
print(f"Population: {n}")
u = ukf_ss(model_params, ukf_params, base_model, base_models)
u.main()
pickle_main(ukf_params["file_name"], pickle_source, do_pickle, u)
else:
"if recalling, load a pickle."
f_name = ex3_pickle_name(n)
"try loading class_dicts first. If no dict then class instance."
try:
u = pickle_main("dict_" + f_name, source, do_pickle)
except:
u = pickle_main(f_name, source, do_pickle)
model_params, ukf_params = u.model_params, u.ukf_params
ex3_plots(u, destination, "ukf_", True, False)
return u
def ex2_main(n, bin_size, recall, do_pickle, source, destination):
"""main function to run experiment 2
- build model and ukf dictionary parameters based on n and bin_size
- initiate Model and ukf_ss based on new dictionaries
- run ABM with filtering on top
- make plots using finished run data
Parameters
------
n, bin_size : float
`n` population and aggregate grid square size `bin_size`
recall, do_pickle : bool
`recall` a previous run or `do_pickle` pickle a new one?
source, destination : str
`source` where to load/save any pickles and the `destination` of
any plots
"""
if not recall:
model_params = configs.model_params
ukf_params = configs.ukf_params
model_params, ukf_params, base_model = aggregate_params(
n, bin_size, model_params, ukf_params)
print(f"Population: {n}")
print(f"Square grid size: {bin_size}")
u = ukf_ss(model_params, ukf_params, base_model)
u.main()
pickle_main(ukf_params["file_name"], pickle_source, do_pickle, u)
else:
f_name = ex2_pickle_name(n, bin_size)
try:
u = pickle_main("dict_" + f_name, source, do_pickle)
except:
print(f_name)
print("dictionary not found. trying to load class")
u = pickle_main(f_name, source, do_pickle)
ex2_plots(u, destination, "agg_ukf_", True, True)
return u
def ex0_main(n, noise, sampling_rate):
""" main ex0 function
- assign population size, observation noise, and sampling rate
- build ukf and model parameter dictionariues
- build base model and init ukf_ss class
- run stationsim with ukf filtering
"""
model_params = default_ukf_configs.model_params
ukf_params = default_ukf_configs.ukf_params
model_params, ukf_params, base_model = ex0_params(n, noise, sampling_rate,
model_params, ukf_params)
print(model_params)
print(ukf_params)
u = ukf_ss(model_params, ukf_params, base_model)
u.main()
ex0_save(u, "../ukf_results/", ukf_params["file_name"])
def ex2_main(n, bin_size, recall, do_pickle, source, destination):
"""main function to run experiment 2
- build model and ukf dictionary parameters based on n and bin_size
- initiate Model and ukf_ss based on new dictionaries
- run ABM with filtering on top
- make plots using finished run data
Parameters
------
n, bin_size : float
`n` population and aggregate grid square size `bin_size`
recall, do_pickle : bool
`recall` a previous run or `do_pickle` pickle a new one?
source, destination : str
`source` where to load/save any pickles and the `destination` of
any plots
"""
if not recall:
model_params = configs.model_params
model_params["random_seed"] = 15
ukf_params = configs.ukf_params
model_params, ukf_params, base_model = aggregate_params(
n, bin_size, model_params, ukf_params)
batch = False
ukf_params["batch"] = batch
if batch:
print(
"WARNING: Batch set to true and will not generate a random model each time."
)
try:
seed = 50
file_name = f"batch_test_{n}_{seed}.pkl"
batch_truths, batch_start_model = batch_load(file_name)
print("batch data found.")
except:
print("no model found. generating one with given seed")
file_name = f"batch_test_{n}_{seed}.pkl"
batch_save(model_params, n, seed)
batch_truths, batch_start_model = batch_load(file_name)
print("new model generated.")
new_seed = int.from_bytes(
os.urandom(4),
byteorder='little') if seed == None else seed
np.random.seed(new_seed)
base_model = batch_start_model
print(f"Population: {n}")
print(f"Square grid size: {bin_size}")
u = ukf_ss(model_params, ukf_params, base_model)
u.main()
if do_pickle:
pickle_main(ukf_params["file_name"], pickle_source, do_pickle, u)
else:
f_name = ex2_pickle_name(n, bin_size)
try:
u = pickle_main("dict_" + f_name, source, do_pickle)
except:
print(f_name)
print("dictionary not found. trying to load class")
u = pickle_main(f_name, source, do_pickle)
ex2_plots(u, destination, "agg_ukf_", True, False)
return u
def main(ex_input,ex_save=None, test = False):
"""main function for running ukf experiments in arc.
Runs an instance of ukf_ss for some experiment and associated parameters.
Either pickles the run or saves some user defined aspect of said run.
- define some input experiment for arc
- update model_params and ukf_params dictionaries for said experiment
- run ukf_ss with said parameters
- pickle or save metrics when run finishes.
Parameters
------
ex_input : func
`ex_input` some experiment input that updates the default model_params
and ukf_params dicitonaries with items needed for filter to run given
experiment.
ex_save : func
`ex_save` if we want to pickle the whole class instance set this to none.
Else provides some alternate function that saves something else.
Experiment 0 has a funciton ex0 save which saves a numpy array of
error metric instead
"""
if not test:
__spec__ = None
if len(sys.argv) != 2:
print("I need an integer to tell me which experiment to run. \n\t"
"Usage: python run_pf <N>")
sys.exit(1)
model_params = configs.model_params
ukf_params = configs.ukf_params
model_params, ukf_params, base_model = ex_input(model_params, ukf_params, test)
print("UKF params: " + str(ukf_params))
print("Model params: " + str(model_params))
#init and run ukf
u = ukf_ss(model_params, ukf_params, base_model)
u.main()
if ukf_params["do_pickle"]:
#store final class instance via pickle
f_name = ukf_params["file_name"]
pickler(u, "results/", f_name)
else:
#alternatively save whatever necessary using some ex_save function.
# requires, the instance and some directory + name to save to.
f_name = ukf_params["f_name"]
ex_save(u, "results/", ukf_params["f_name"])
if test:
print(f"Test successful. Deleting the saved test file : {f_name}")
remove("results/" + ukf_params["full_file_name"])
marker_attributes = {
"markers": {
-1: "o"
},
"colours": {
-1: "black"
},
"labels": {
-1: "Pseudo-Truths"
}
}
"dummy ukf params and class for plots"
ukf_params = {}
u = ukf_ss(model_params, ukf_params, model)
plts = ukf_plots(u, "../plots/", "crowd_test_", False, True,
marker_attributes)
truths = np.array(model.history_state).flatten().reshape(
(model.step_id, 2 * model.pop_total))
nan_array = np.ones(shape=truths.shape) * np.nan
for i, agent in enumerate(model.agents):
"find which rows are NOT (None, None). Store in index. "
array = np.array(agent.history_locations)
index = ~np.equal(array, None)[:, 0]
"set anything in index to 1. I.E which agents are still in model."
nan_array[index, 2 * i:(2 * i) + 2] = 1
def ex4_pickle_name(n, cameras):
pass
if __name__ == "__main__":
model_params = configs.model_params
ukf_params = configs.ukf_params
n = 5
camera_poles = [np.array([10, 0]), np.array([150, 0])]
camera_centres = [np.array([0, 100]), np.array([150, 200])]
camera_arcs = [0.125] * 2
boundary = boundary_Polygon(model_params["width"], model_params["height"])
cameras = []
for i in range(len(camera_poles)):
pole = camera_poles[i]
centre = camera_centres[i]
arc = camera_arcs[i]
cameras.append(camera_Sensor(pole, centre, arc, boundary))
model_params, ukf_params, base_model = cone_params(n, cameras,
model_params,
ukf_params)
for _ in range(5):
base_model.step()
u = ukf_ss(model_params, ukf_params, base_model)
u.main()
