def load_model(n, prop):
f_name = ex1_pickle_name(n, prop)
source = "../test_pickles/"
do_pickle = True
"try loading class_dicts first. If no dict then try class instance."
try:
u = pickle_main("dict_" + f_name, source, do_pickle)
except:
u = pickle_main(f_name, source, do_pickle)
return u
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 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 data_extractor(self):
"""pull multiple class runs into arrays for analysis
This is function looks awful... because it is.
Heres what it does:
- build grand dictionary L2
- loop over first parameter e.g. population size
- create sub dictionary for given i L2[i]
- loop over second parameter e.g. proportion observed (prop)
- create placeholder list sub_L2 to store data for given i and j.
- load each ukf pickle with the given i and j.
- for each pickle extract the data, calculate L2s, and put the
grand median L2 into sub_L2.
- put list sub_L2 as a bnpy array into
dictionary L2[i] with key j.
This will output a dictionary where for every pair of keys i and j , we accquire
an array of grand medians.
Returns
------
L2 : dict
dictionary of `L2` distances between ground truth and ukf predictions
over 2 parameters. We have keys [i][j] corresponding to the ith
value of parameter 1 (e.g population) and jth value of parameter 2
(e.g proportion observed). Each pair of keys will contain a list of
numpy arrays. Each array is a scalar grand median of an L2 distance matrix
output by ukf_plots.L2s
"""
"names of first and second parameters. e.g. agents and prop"
keys = self.param_keys
"placeholder dictionary for all parameters"
L2 = {}
"loop over first parameter. usually agents."
for i in self.p1:
print(i)
"sub dictionary for parameter i"
L2[i] = {}
for j in self.p2:
"file names for glob to find. note wildcard * is needed"
f_name = self.source + f"*{keys[0]}_*{i}_{keys[1]}_*{j}-*"
"find all files with given i and j"
files = glob.glob(f_name)
"placeholder list for grand medians of UKF runs with parameters i and j"
sub_L2 = []
for file in files:
"open pickle"
f = open(file, "rb")
u = pickle_main(
os.path.split(file)[1],
os.path.split(file)[0] + "/", True)
f.close()
"pull raw data"
truth, preds = self.depickle_data_parser(u)
"find L2 distances"
distances = L2_parser(truth[::u.sample_rate, :],
preds[::u.sample_rate, :])
if self.restrict is not None:
distances = self.restrict(distances, u, self.kwargs)
"add grand median to sub_L2"
sub_L2.append(np.nanmedian(np.nanmedian(distances,
axis=0)))
"stack list of grand medians as an nx1 vector array"
"put array into grand dictionary with keys i and j"
L2[i][j] = np.hstack(sub_L2)
return L2