def create_single(idx):
""" This function creates a single test.
"""
dirname = get_random_dirname(5)
os.mkdir(dirname)
os.chdir(dirname)
# The late import is required so a potentially just compiled FORTRAN implementation
# is recognized. This is important for the creation of the regression vault as we
# want to include FORTRAN use cases.
from respy import RespyCls
# We impose a couple of constraints that make the requests manageable.
np.random.seed(idx)
version = np.random.choice(["python", "fortran"])
# only choose from constraint optimizers because we always have some bounds
if version == "python":
optimizer = "SCIPY-LBFGSB"
else:
optimizer = "FORTE-BOBYQA"
constr = {
"program": {
"version": version
},
"preconditioning": {
"type": np.random.choice(["identity", "magnitudes"])
},
"estimation": {
"maxfun":
int(np.random.choice(range(6), p=[0.5, 0.1, 0.1, 0.1, 0.1, 0.1])),
"optimizer":
optimizer,
},
}
constr["flag_estimation"] = True
param_spec, options_spec = generate_random_model(point_constr=constr)
respy_obj = RespyCls(param_spec, options_spec)
simulate_observed(respy_obj)
crit_val = respy_obj.fit()[1]
# In rare instances, the value of the criterion function might be too large and thus
# printed as a string. This occurred in the past, when the gradient preconditioning
# had zero probability observations. We now generate random initialization files
# with smaller gradient step sizes.
if not isinstance(crit_val, float):
raise AssertionError(" ... value of criterion function too large.")
# Cleanup of temporary directories.from
os.chdir("../")
shutil.rmtree(dirname)
return respy_obj.attr, crit_val
def test_2(self):
""" This test ensures that the record files are identical.
"""
# Generate random initialization file. The number of periods is higher than
# usual as only FORTRAN implementations are used to solve the random request.
# This ensures that also some cases of interpolation are explored.
constr = {
"program": {
"version": "fortran"
},
"num_periods": np.random.randint(3, 10),
"estimation": {
"maxfun": 0
},
}
params_spec, options_spec = generate_random_model(point_constr=constr)
base_sol_log, base_est_info_log = None, None
base_est_log = None
for is_parallel in [False, True]:
options_spec["program"]["threads"] = 1
options_spec["program"]["procs"] = 1
if is_parallel:
if IS_PARALLELISM_OMP:
options_spec["program"]["threads"] = np.random.randint(
2, 5)
if IS_PARALLELISM_MPI:
options_spec["program"]["procs"] = np.random.randint(2, 5)
respy_obj = RespyCls(params_spec, options_spec)
file_sim = respy_obj.get_attr("file_sim")
simulate_observed(respy_obj)
respy_obj.fit()
# Check for identical records
fname = file_sim + ".respy.sol"
if base_sol_log is None:
base_sol_log = open(fname, "r").read()
assert open(fname, "r").read() == base_sol_log
if base_est_info_log is None:
base_est_info_log = open("est.respy.info", "r").read()
assert open("est.respy.info", "r").read() == base_est_info_log
if base_est_log is None:
base_est_log = open("est.respy.log", "r").readlines()
compare_est_log(base_est_log)
def test_9(self):
""" This test just locks in the evaluation of the criterion function for the
original Keane & Wolpin data. We create an additional initialization files that
include numerous types and initial conditions.
"""
# This ensures that the experience effect is taken care of properly.
open(".restud.respy.scratch", "w").close()
kw_spec, result = random.choice([
("kw_data_one", 10.45950941513551),
("kw_data_two", 45.04552402391903),
("kw_data_three", 74.28253652773714),
("kw_data_one_types", 9.098738585839529),
("kw_data_one_initial", 7.965979149372883),
])
base_path = TEST_RESOURCES_DIR / kw_spec
# Evaluate criterion function at true values.
respy_obj = RespyCls(base_path.with_suffix(".csv"),
base_path.with_suffix(".json"))
respy_obj.unlock()
respy_obj.set_attr("maxfun", 0)
respy_obj.lock()
simulate_observed(respy_obj, is_missings=False)
_, val = respy_obj.fit()
np.testing.assert_allclose(val, result)
def test_2(self):
""" If there is no random variation in rewards then the number of draws to simulate the
expected future value should have no effect.
"""
params_spec, options_spec = generate_random_model(deterministic=True)
# Initialize auxiliary objects
base = None
for _ in range(2):
num_draws_emax = np.random.randint(1, 100)
respy_obj = RespyCls(params_spec, options_spec)
respy_obj.unlock()
respy_obj.set_attr("num_draws_emax", num_draws_emax)
respy_obj.lock()
respy_obj = simulate_observed(respy_obj)
periods_emax = respy_obj.get_attr("periods_emax")
if base is None:
base = periods_emax.copy()
diff = np.max(
abs(
np.ma.masked_invalid(base) -
np.ma.masked_invalid(periods_emax)))
np.testing.assert_almost_equal(diff, 0.0)
def check_single(tests, idx):
""" This function checks a single test from the dictionary.
"""
# Distribute test information.
attr, crit_val = tests[idx]
if not IS_PARALLELISM_OMP or not IS_FORTRAN:
attr["num_threads"] = 1
if not IS_PARALLELISM_MPI or not IS_FORTRAN:
attr["num_procs"] = 1
if not IS_FORTRAN:
attr["version"] = "python"
# In the past we also had the problem that some of the testing machines report
# selective failures when the regression vault was created on another machine.
msg = " ... test is known to fail on this machine"
if "zeus" in socket.gethostname() and idx in []:
print(msg)
return None
if "acropolis" in socket.gethostname() and idx in []:
print(msg)
return None
if "pontos" in socket.gethostname() and idx in []:
print(msg)
return None
# We need to create an temporary directory, so the multiprocessing does not
# interfere with any of the files that are printed and used during the small
# estimation request.
dirname = get_random_dirname(5)
os.mkdir(dirname)
os.chdir(dirname)
# The late import is required so a potentially just compiled FORTRAN implementation
# is recognized. This is important for the creation of the regression vault as we
# want to include FORTRAN use cases.
from respy import RespyCls
params_spec = _params_spec_from_attributes(attr)
options_spec = _options_spec_from_attributes(attr)
respy_obj = RespyCls(params_spec, options_spec)
simulate_observed(respy_obj)
est_val = respy_obj.fit()[1]
is_success = np.isclose(est_val, crit_val, rtol=TOL, atol=TOL)
# Cleanup of temporary directories.from
os.chdir("../")
shutil.rmtree(dirname)
return is_success
def test_4(self):
""" Test the solution of deterministic model with ambiguity and
interpolation. This test has the same result as in the absence of
random variation in payoffs, it does not matter whether the
environment is ambiguous or not.
"""
# Solve specified economy
for version in ['FORTRAN', 'PYTHON']:
respy_obj = RespyCls(TEST_RESOURCES_DIR + '/test_fifth.respy.ini')
respy_obj.unlock()
respy_obj.set_attr('version', version)
respy_obj.lock()
respy_obj = simulate(respy_obj)
# Assess expected future value
val = respy_obj.get_attr('periods_emax')[0, :1]
np.testing.assert_allclose(val, 88750)
# Assess evaluation
_, val = estimate(respy_obj)
np.testing.assert_allclose(val, -1.0)
def scripts_simulate(init_file, file_sim):
""" Wrapper for the simulation.
"""
respy_obj = RespyCls(init_file)
# Update file for output.
if file_sim is not None:
respy_obj.unlock()
respy_obj.set_attr("file_sim", file_sim)
respy_obj.lock()
# Optimize the criterion function.
respy_obj.simulate()
def test_2(self):
"""Ensure that the evaluation of the criterion is equal across versions."""
max_draws = np.random.randint(10, 100)
# It seems to be important that max_draws and max_agents is the same
# number because otherwise some functions that read draws from a file
# to ensure compatibility of fortran and python versions won't work.
bound_constr = {"max_draws": max_draws, "max_agents": max_draws}
point_constr = {
"interpolation": {"flag": False},
"program": {"procs": 1, "threads": 1, "version": "python"},
"estimation": {"maxfun": 0},
}
params_spec, options_spec = generate_random_model(
point_constr=point_constr, bound_constr=bound_constr
)
respy_obj = RespyCls(params_spec, options_spec)
num_agents_sim, optim_paras = dist_class_attributes(
respy_obj, "num_agents_sim", "optim_paras"
)
type_shares = optim_paras["type_shares"]
# Simulate a dataset
simulate_observed(respy_obj)
# Iterate over alternative implementations
base_x, base_val = None, None
num_periods = options_spec["num_periods"]
write_draws(num_periods, max_draws)
write_types(type_shares, num_agents_sim)
for version in ["python", "fortran"]:
respy_obj.unlock()
respy_obj.set_attr("version", version)
respy_obj.lock()
x, val = respy_obj.fit()
# Check for the returned parameters.
if base_x is None:
base_x = x
np.testing.assert_allclose(base_x, x)
# Check for the value of the criterion function.
if base_val is None:
base_val = val
np.testing.assert_allclose(base_val, val)
def test_3(self):
""" Test the solution of deterministic model with ambiguity and
interpolation. This test has the same result as in the absence of
random variation in payoffs, it does not matter whether the
environment is ambiguous or not.
"""
# Solve specified economy
for version in ['FORTRAN', 'PYTHON']:
respy_obj = RespyCls(TEST_RESOURCES_DIR + '/test_fifth.respy.ini')
respy_obj.unlock()
respy_obj.set_attr('version', version)
respy_obj.lock()
respy_obj = simulate(respy_obj)
# Assess expected future value
val = respy_obj.get_attr('periods_emax')[0, :1]
np.testing.assert_allclose(val, 88750)
# Assess evaluation
_, val = estimate(respy_obj)
np.testing.assert_allclose(val, -1.0)
def test_3(self):
""" This test just locks in the evaluation of the criterion function
for the original Keane & Wolpin data.
"""
# Sample one task
resources = ['kw_data_one.ini', 'kw_data_two.ini', 'kw_data_three.ini']
fname = np.random.choice(resources)
# Select expected result
rslt = None
if 'one' in fname:
rslt = 0.261487735867433
elif 'two' in fname:
rslt = 1.126138097174159
elif 'three' in fname:
rslt = 1.895699121131644
# Evaluate criterion function at true values.
respy_obj = RespyCls(TEST_RESOURCES_DIR + '/' + fname)
respy_obj.unlock()
respy_obj.set_attr('maxfun', 0)
respy_obj.lock()
simulate(respy_obj)
_, val = estimate(respy_obj)
np.testing.assert_allclose(val, rslt)
def test_3(self):
""" Testing whether the a simulated dataset and the evaluation of the criterion function
are the same for a tiny delta and a myopic agent.
"""
constr = {"estimation": {"maxfun": 0}}
params_spec, options_spec = generate_random_model(point_constr=constr,
myopic=True)
respy_obj = RespyCls(params_spec, options_spec)
optim_paras, num_agents_sim, edu_spec = dist_class_attributes(
respy_obj, "optim_paras", "num_agents_sim", "edu_spec")
write_types(optim_paras["type_shares"], num_agents_sim)
write_edu_start(edu_spec, num_agents_sim)
write_lagged_start(num_agents_sim)
# Iterate over alternative discount rates.
base_data, base_val = None, None
for delta in [0.00, 0.000001]:
respy_obj = RespyCls(params_spec, options_spec)
respy_obj.unlock()
respy_obj.attr["optim_paras"]["delta"] = np.array([delta])
respy_obj.lock()
simulate_observed(respy_obj)
# This parts checks the equality of simulated dataset for the different
# versions of the code.
data_frame = pd.read_csv("data.respy.dat", delim_whitespace=True)
if base_data is None:
base_data = data_frame.copy()
assert_frame_equal(base_data, data_frame)
# This part checks the equality of an evaluation of the criterion function.
_, crit_val = respy_obj.fit()
if base_val is None:
base_val = crit_val
np.testing.assert_allclose(base_val,
crit_val,
rtol=1e-03,
atol=1e-03)
def test_3(self):
""" Test the solution of model with ambiguity.
"""
# Solve specified economy
respy_obj = RespyCls(TEST_RESOURCES_DIR + '/test_third.respy.ini')
respy_obj = simulate(respy_obj)
# Assess expected future value
val = respy_obj.get_attr('periods_emax')[0, :1]
np.testing.assert_allclose(val, 86121.335057)
# Assess evaluation
_, val = estimate(respy_obj)
np.testing.assert_allclose(val, 1.9162587639887239)
def test_4(self):
""" Test the solution of model with ambiguity.
"""
# Solve specified economy
respy_obj = RespyCls(TEST_RESOURCES_DIR + '/test_fourth.respy.ini')
respy_obj = simulate(respy_obj)
# Assess expected future value
val = respy_obj.get_attr('periods_emax')[0, :1]
np.testing.assert_allclose(val, 75.719528)
# Assess evaluation
_, val = estimate(respy_obj)
np.testing.assert_allclose(val, 2.802285449312437)
def test_1(self):
""" Test solution of simple model against hard-coded results.
"""
# Solve specified economy
respy_obj = RespyCls(TEST_RESOURCES_DIR + '/test_first.respy.ini')
respy_obj = simulate(respy_obj)
# Assess expected future value
val = respy_obj.get_attr('periods_emax')[0, :1]
np.testing.assert_allclose(val, 103320.40501)
# Assess evaluation
_, val = estimate(respy_obj)
np.testing.assert_allclose(val, 1.9775860444869962)
def test_5(self):
""" Test the scripts.
"""
# Constraints that ensure that two alternative initialization files
# can be used for the same simulated data.
for _ in range(10):
constr = dict()
constr['periods'] = np.random.randint(1, 4)
constr['agents'] = np.random.randint(5, 100)
constr['is_estimation'] = True
constr['edu'] = (7, 15)
# Simulate a dataset
generate_init(constr)
respy_obj = RespyCls('test.respy.ini')
simulate(respy_obj)
# Create output to process a baseline.
respy_obj.unlock()
respy_obj.set_attr('maxfun', 0)
respy_obj.lock()
estimate(respy_obj)
# Potentially evaluate at different points.
generate_init(constr)
init_file = 'test.respy.ini'
file_sim = 'sim.respy.dat'
gradient = np.random.choice([True, False])
single = np.random.choice([True, False])
resume = np.random.choice([True, False])
update = np.random.choice([True, False])
action = np.random.choice(['fix', 'free', 'value'])
num_draws = np.random.randint(1, 20)
# The set of identifiers is a little complicated as we only allow
# sampling of the diagonal terms of the covariance matrix. Otherwise,
# we sometimes run into the problem of very ill conditioned matrices
# resulting in a failed Cholesky decomposition.
set_ = list(range(16)) + [16, 18, 21, 25]
identifiers = np.random.choice(set_, num_draws, replace=False)
values = np.random.uniform(size=num_draws)
scripts_estimate(resume, single, init_file, gradient)
scripts_update(init_file)
# The error can occur as the RESPY package is actually running an
# estimation step that can result in very ill-conditioned covariance
# matrices.
try:
scripts_simulate(update, init_file, file_sim, None)
scripts_modify(identifiers, values, action, init_file)
except np.linalg.linalg.LinAlgError:
pass
def test_3(self):
""" Testing whether the back and forth transformation works.
"""
for _ in range(100):
# Generate random request
generate_init()
# Process request and write out again.
respy_obj = RespyCls('test.respy.ini')
respy_obj.write_out('alt.respy.ini')
# Read both initialization files and compare
base_ini = open('test.respy.ini', 'r').read()
alt_ini = open('alt.respy.ini', 'r').read()
assert base_ini == alt_ini
def test_2(self):
""" This test compares the results from a solution using the interpolation code
for the special case where the number of interpolation points is exactly the
number of states in the final period. In this case the interpolation code is run
and then all predicted values replaced with their actual values.
"""
# Set initial constraints
# Set initial constraints
constr = {"interpolation": {"flag": False}}
params_spec, options_spec = generate_random_model(point_constr=constr,
deterministic=True)
baseline = None
# Solve with and without interpolation code
for _ in range(2):
# Process and solve
respy_obj = RespyCls(params_spec, options_spec)
respy_obj = simulate_observed(respy_obj)
# Extract class attributes
states_number_period, periods_emax = dist_class_attributes(
respy_obj, "states_number_period", "periods_emax")
# Store and check results
if baseline is None:
baseline = periods_emax
else:
np.testing.assert_array_almost_equal(baseline, periods_emax)
# Updates for second iteration
options_spec["interpolation"]["points"] = max(states_number_period)
options_spec["interpolation"]["flag"] = True
def test_12(self):
""" Testing the functionality introduced to ensure that the simulation is
independent of the order of initial conditions and types in the initialization
file.
"""
num_elements = np.random.randint(1, 11)
input_array = np.random.normal(size=num_elements)
# We first check the sorting implementation.
py = sorted(input_array)
f90 = fort_debug.wrapper_sorted(input_array, num_elements)
assert_equal(py, f90)
params_spec, options_spec = generate_random_model()
respy_obj = RespyCls(params_spec, options_spec)
edu_spec, optim_paras, num_types = dist_class_attributes(
respy_obj, "edu_spec", "optim_paras", "num_types")
args = (edu_spec["start"], edu_spec["share"], edu_spec["max"])
f90 = fort_debug.wrapper_sort_edu_spec(*args)
py = sort_edu_spec(edu_spec)
for i, label in enumerate(["start", "share", "max"]):
assert_equal(py[label], f90[i])
py = sort_type_info(optim_paras, num_types)
f90 = fort_debug.wrapper_sort_type_info(optim_paras["type_shares"],
num_types)
for i, label in enumerate(["order", "shares"]):
assert_equal(py[label], f90[i])
def test_2(self):
""" Testing whether the back and forth transformation works.
"""
for _ in range(100):
params_spec, options_spec = generate_random_model()
# Process request and write out again.
respy_obj = RespyCls(params_spec, options_spec)
respy_obj.write_out("alt_respy")
new_params_spec = _read_params_spec(Path("alt_respy.csv"))
new_options_spec = _read_options_spec(Path("alt_respy.json"))
assert options_spec == new_options_spec
for col in params_spec.columns:
assert_series_equal(params_spec[col], new_params_spec[col])
def test_1(self):
""" Compare results from the RESTUD program and the RESPY package.
"""
# Impose some constraints on the initialization file which ensures that
# the problem can be solved by the RESTUD code. The code is adjusted to
# run with zero draws.
constraints = dict()
constraints['edu'] = (10, 20)
constraints['is_deterministic'] = True
# Generate random initialization file. The RESTUD code uses the same
# random draws for the solution and simulation of the model. Thus,
# the number of draws is required to be less or equal to the number
# of agents.
init_dict = generate_random_dict(constraints)
num_agents_sim = init_dict['SIMULATION']['agents']
num_draws_emax = init_dict['SOLUTION']['draws']
if num_draws_emax < num_agents_sim:
init_dict['SOLUTION']['draws'] = num_agents_sim
print_init_dict(init_dict)
# Indicate RESTUD code the special case of zero disturbance.
open('.restud.testing.scratch', 'a').close()
# Perform toolbox actions
respy_obj = RespyCls('test.respy.ini')
# This flag aligns the random components between the RESTUD program and
# RESPY package. The existence of the file leads to the RESTUD program
# to write out the random components.
model_paras, edu_start, edu_max, num_agents_sim, num_periods, \
num_draws_emax, delta = \
dist_class_attributes(respy_obj,
'model_paras', 'edu_start', 'edu_max', 'num_agents_sim',
'num_periods', 'num_draws_emax', 'delta')
transform_respy_to_restud(model_paras, edu_start, edu_max,
num_agents_sim, num_periods, num_draws_emax,
delta)
# Solve model using RESTUD code.
cmd = TEST_RESOURCES_DIR + '/kw_dp3asim'
subprocess.check_call(cmd, shell=True)
# Solve model using RESPY package.
simulate(respy_obj)
# Compare the simulated datasets generated by the programs.
py = pd.DataFrame(
np.array(np.genfromtxt('data.respy.dat', missing_values='.'),
ndmin=2)[:, -4:])
fort = pd.DataFrame(
np.array(np.genfromtxt('ftest.txt', missing_values='.'),
ndmin=2)[:, -4:])
assert_frame_equal(py, fort)
def test_7(self):
""" This is a special test for auxiliary functions related to the
interpolation setup.
"""
# Impose constraints
constr = dict()
constr['periods'] = np.random.randint(2, 5)
# Construct a random initialization file
generate_init(constr)
# Extract required information
respy_obj = RespyCls('test.respy.ini')
# Extract class attributes
is_debug, num_periods = dist_class_attributes(respy_obj, 'is_debug',
'num_periods')
# Write out a grid for the interpolation
max_states_period = write_interpolation_grid('test.respy.ini')
# Draw random request for testing
num_states = np.random.randint(1, max_states_period)
candidates = list(range(num_states))
period = np.random.randint(1, num_periods)
num_points_interp = np.random.randint(1, num_states + 1)
# Check function for random choice and make sure that there are no
# duplicates.
f90 = fort_debug.wrapper_random_choice(candidates, num_states,
num_points_interp)
np.testing.assert_equal(len(set(f90)), len(f90))
np.testing.assert_equal(len(f90), num_points_interp)
# Check the standard cases of the function.
args = (num_points_interp, num_states, period, is_debug, num_periods)
f90 = fort_debug.wrapper_get_simulated_indicator(*args)
np.testing.assert_equal(len(f90), num_states)
np.testing.assert_equal(np.all(f90) in [0, 1], True)
# Test the standardization across PYTHON, F2PY, and FORTRAN
# implementations. This is possible as we write out an interpolation
# grid to disk which is used for both functions.
base_args = (num_points_interp, num_states, period, is_debug)
args = base_args
py = get_simulated_indicator(*args)
args = base_args + (num_periods, )
f90 = fort_debug.wrapper_get_simulated_indicator(*args)
np.testing.assert_array_equal(f90, 1 * py)
os.unlink('interpolation.txt')
# Special case where number of interpolation points are same as the
# number of candidates. In that case the returned indicator
# should be all TRUE.
args = (num_states, num_states, period, True, num_periods)
f90 = fort_debug.wrapper_get_simulated_indicator(*args)
np.testing.assert_equal(sum(f90), num_states)
def test_6(self):
""" This test ensures that the logging looks exactly the same for the
different versions.
"""
max_draws = np.random.randint(10, 300)
# Generate random initialization file
constr = dict()
constr['flag_parallelism'] = False
constr['max_draws'] = max_draws
constr['flag_interpolation'] = False
constr['maxfun'] = 0
# Generate random initialization file
init_dict = generate_init(constr)
# Perform toolbox actions
respy_obj = RespyCls('test.respy.ini')
# Iterate over alternative implementations
base_sol_log, base_est_info_log, base_est_log = None, None, None
base_sim_log = None
num_periods = init_dict['BASICS']['periods']
write_draws(num_periods, max_draws)
for version in ['FORTRAN', 'PYTHON']:
respy_obj.unlock()
respy_obj.set_attr('version', version)
respy_obj.lock()
simulate(respy_obj)
estimate(respy_obj)
# Check for identical logging
if base_sol_log is None:
base_sol_log = open('sol.respy.log', 'r').read()
assert open('sol.respy.log', 'r').read() == base_sol_log
# Check for identical logging
if base_sim_log is None:
base_sim_log = open('sim.respy.log', 'r').read()
assert open('sim.respy.log', 'r').read() == base_sim_log
if base_est_info_log is None:
base_est_info_log = open('est.respy.info', 'r').read()
assert open('est.respy.info', 'r').read() == base_est_info_log
if base_est_log is None:
base_est_log = open('est.respy.log', 'r').readlines()
compare_est_log(base_est_log)
def test_10(self):
""" Function that calculates the number of observations by individual.
"""
for _ in range(2):
params_spec, options_spec = generate_random_model()
respy_obj = RespyCls(params_spec, options_spec)
respy_obj = simulate_observed(respy_obj)
num_agents_est = respy_obj.get_attr("num_agents_est")
data_array = process_dataset(respy_obj).to_numpy()
py = np.bincount(data_array[:, 0].astype(int))
f90 = fort_debug.wrapper_get_num_obs_agent(data_array,
num_agents_est)
assert_almost_equal(py, f90)
def test_6(self):
""" Test short estimation tasks.
"""
num_agents = np.random.randint(5, 100)
constr = {
"simulation": {
"agents": num_agents
},
"num_periods": np.random.randint(1, 4),
"estimation": {
"maxfun": np.random.randint(0, 5),
"agents": num_agents
},
}
# Simulate a dataset
params_spec, options_spec = generate_random_model(point_constr=constr)
respy_obj = RespyCls(params_spec, options_spec)
write_interpolation_grid(respy_obj)
# Run estimation task.
simulate_observed(respy_obj)
base_x, base_val = respy_obj.fit()
# We also check whether updating the class instance and a single evaluation of
# the criterion function give the same result.
respy_obj.update_optim_paras(base_x)
respy_obj.attr["maxfun"] = 0
alt_x, alt_val = respy_obj.fit()
for arg in [(alt_val, base_val), (alt_x, base_x)]:
np.testing.assert_almost_equal(arg[0], arg[1])
def run(hours):
start, timeout = datetime.now(), timedelta(hours=hours)
count = 0
while True:
print("COUNT", count)
count += 1
# Generate random initialization file
constr = {
"program": {
"version": "fortran"
},
"estimation": {
"maxfun": np.random.randint(0, 50),
"optimizer": "FORT-BOBYQA",
},
}
params_spec, options_spec = generate_random_model(point_constr=constr)
base = None
for is_parallel in [True, False]:
if is_parallel is False:
options_spec["program"]["threads"] = 1
options_spec["program"]["procs"] = 1
else:
if IS_PARALLELISM_OMP:
options_spec["program"]["threads"] = np.random.randint(
2, 5)
if IS_PARALLELISM_MPI:
options_spec["program"]["procs"] = np.random.randint(2, 5)
respy_obj = RespyCls(params_spec, options_spec)
respy_obj = simulate_observed(respy_obj)
_, crit_val = respy_obj.fit()
if base is None:
base = crit_val
np.testing.assert_equal(base, crit_val)
# Timeout.
if timeout < datetime.now() - start:
break
def test_5(self):
""" Test the scripts.
"""
# Constraints that ensure that two alternative initialization files
# can be used for the same simulated data.
for _ in range(10):
constr = dict()
constr['periods'] = np.random.randint(1, 4)
constr['agents'] = np.random.randint(5, 100)
constr['is_estimation'] = True
constr['edu'] = (7, 15)
# Simulate a dataset
generate_init(constr)
respy_obj = RespyCls('test.respy.ini')
simulate(respy_obj)
# Create output to process a baseline.
respy_obj.unlock()
respy_obj.set_attr('maxfun', 0)
respy_obj.lock()
estimate(respy_obj)
# Potentially evaluate at different points.
generate_init(constr)
init_file = 'test.respy.ini'
file_sim = 'sim.respy.dat'
gradient = np.random.choice([True, False])
single = np.random.choice([True, False])
resume = np.random.choice([True, False])
update = np.random.choice([True, False])
action = np.random.choice(['fix', 'free', 'value'])
num_draws = np.random.randint(1, 20)
# The set of identifiers is a little complicated as we only allow
# sampling of the diagonal terms of the covariance matrix. Otherwise,
# we sometimes run into the problem of very ill conditioned matrices
# resulting in a failed Cholesky decomposition.
set_ = list(range(16)) + [16, 18, 21, 25]
identifiers = np.random.choice(set_, num_draws, replace=False)
values = np.random.uniform(size=num_draws)
scripts_estimate(resume, single, init_file, gradient)
scripts_update(init_file)
# The error can occur as the RESPY package is actually running an
# estimation step that can result in very ill-conditioned covariance
# matrices.
try:
scripts_simulate(update, init_file, file_sim, None)
scripts_modify(identifiers, values, action, init_file)
except np.linalg.linalg.LinAlgError:
pass
def test_1(self):
"""Ensure that it makes no difference whether the
criterion function is evaluated in parallel or not.
"""
# Generate random initialization file
constr = {
"program": {
"version": "fortran"
},
"estimation": {
"maxfun": np.random.randint(0, 50)
},
}
params_spec, options_spec = generate_random_model(point_constr=constr)
# If delta is a not fixed, we need to ensure a bound-constraint optimizer.
# However, this is not the standard flag_estimation as the number of function
# evaluation is possibly much larger to detect and differences in the updates of
# the optimizer steps depending on the implementation.
if params_spec.loc[("delta", "delta"), "fixed"] is False:
options_spec["estimation"]["optimizer"] = "FORT-BOBYQA"
base = None
for is_parallel in [True, False]:
options_spec["program"]["threads"] = 1
options_spec["program"]["procs"] = 1
if is_parallel:
if IS_PARALLELISM_OMP:
options_spec["program"]["threads"] = np.random.randint(
2, 5)
if IS_PARALLELISM_MPI:
options_spec["program"]["procs"] = np.random.randint(2, 5)
respy_obj = RespyCls(params_spec, options_spec)
respy_obj = simulate_observed(respy_obj)
_, crit_val = respy_obj.fit()
if base is None:
base = crit_val
np.testing.assert_equal(base, crit_val)
def run_estimation():
""" Run an estimation with the respective release.
"""
import numpy as np
from respy import estimate
from respy import RespyCls
respy_obj = RespyCls('test.respy.ini')
crit_val = estimate(respy_obj)[1]
np.savetxt('.crit_val', np.array(crit_val, ndmin=2))
def test_5(self):
""" This test ensures that the logging looks exactly the same for the
different versions.
"""
max_draws = np.random.randint(10, 300)
# Generate random initialization file
constr = dict()
constr['flag_parallelism'] = False
constr['max_draws'] = max_draws
constr['flag_interpolation'] = False
constr['maxfun'] = 0
# Generate random initialization file
init_dict = generate_init(constr)
# Perform toolbox actions
respy_obj = RespyCls('test.respy.ini')
# Iterate over alternative implementations
base_sol_log, base_est_info_log, base_est_log = None, None, None
base_sim_log = None
num_periods = init_dict['BASICS']['periods']
write_draws(num_periods, max_draws)
for version in ['FORTRAN', 'PYTHON']:
respy_obj.unlock()
respy_obj.set_attr('version', version)
respy_obj.lock()
simulate(respy_obj)
estimate(respy_obj)
# Check for identical logging
if base_sol_log is None:
base_sol_log = open('sol.respy.log', 'r').read()
assert open('sol.respy.log', 'r').read() == base_sol_log
# Check for identical logging
if base_sim_log is None:
base_sim_log = open('sim.respy.log', 'r').read()
assert open('sim.respy.log', 'r').read() == base_sim_log
if base_est_info_log is None:
base_est_info_log = open('est.respy.info', 'r').read()
assert open('est.respy.info', 'r').read() == base_est_info_log
if base_est_log is None:
base_est_log = open('est.respy.log', 'r').readlines()
compare_est_log(base_est_log)
def test_2(self):
""" If there is no random variation in payoffs then the number of
draws to simulate the expected future value should have no effect.
"""
# Generate constraints
constr = dict()
constr['is_deterministic'] = True
# Generate random initialization file
generate_init(constr)
# Initialize auxiliary objects
base = None
for _ in range(2):
# Draw a random number of draws for
# expected future value calculations.
num_draws_emax = np.random.randint(1, 100)
# Perform toolbox actions
respy_obj = RespyCls('test.respy.ini')
respy_obj.unlock()
respy_obj.set_attr('num_draws_emax', num_draws_emax)
respy_obj.lock()
respy_obj = simulate(respy_obj)
# Distribute class attributes
periods_emax = respy_obj.get_attr('periods_emax')
if base is None:
base = periods_emax.copy()
# Statistic
diff = np.max(
abs(
np.ma.masked_invalid(base) -
np.ma.masked_invalid(periods_emax)))
# Checks
assert (np.isfinite(diff))
assert (diff < 10e-10)
def test_1(self):
""" Testing whether random model specifications can be simulated
and processed.
"""
# Generate random initialization file
generate_init()
respy_obj = RespyCls('test.respy.ini')
simulate(respy_obj)
process(respy_obj)
def test_7(self):
""" This is a special test for shared functions related to the interpolation setup.
"""
# Impose constraints
point_constr = {"num_periods": np.random.randint(2, 5)}
params_spec, options_spec = generate_random_model(
point_constr=point_constr)
respy_obj = RespyCls(params_spec, options_spec)
# Extract class attributes
is_debug, num_periods = dist_class_attributes(respy_obj, "is_debug",
"num_periods")
# Write out a grid for the interpolation
max_states_period = write_interpolation_grid(respy_obj)
# Draw random request for testing
num_states = np.random.randint(1, max_states_period)
candidates = list(range(num_states))
period = np.random.randint(1, num_periods)
num_points_interp = np.random.randint(1, num_states + 1)
# Check function for random choice and make sure that there are no duplicates.
args = (candidates, num_states, num_points_interp)
f90 = fort_debug.wrapper_random_choice(*args)
assert_equal(len(set(f90)), len(f90))
assert_equal(len(f90), num_points_interp)
# Check the standard cases of the function.
args = (num_points_interp, num_states, period, is_debug, num_periods)
f90 = fort_debug.wrapper_get_simulated_indicator(*args)
assert_equal(len(f90), num_states)
assert_equal(np.all(f90) in [0, 1], True)
# Test the standardization across PYTHON, F2PY, and FORTRAN implementations.
# This is possible as we write out an interpolation grid to disk which is used
# for both functions.
base_args = (num_points_interp, num_states, period, is_debug)
args = base_args
py = get_simulated_indicator(*args)
args = base_args + (num_periods, )
f90 = fort_debug.wrapper_get_simulated_indicator(*args)
assert_array_equal(f90, 1 * py)
os.unlink(".interpolation.respy.test")
# Special case where number of interpolation points are same as the number of
# candidates. In that case the returned indicator should be all TRUE.
args = (num_states, num_states, period, True, num_periods)
f90 = fort_debug.wrapper_get_simulated_indicator(*args)
assert_equal(sum(f90), num_states)
def test_4(self):
""" Test the evaluation of the criterion function for random requests, not just
at the true values.
"""
# Constraints that ensure that two alternative initialization files can be used
# for the same simulated data.
num_agents = np.random.randint(5, 100)
constr = {
"simulation": {
"agents": num_agents
},
"num_periods": np.random.randint(1, 4),
"edu_spec": {
"start": [7],
"max": 15,
"share": [1.0]
},
"estimation": {
"maxfun": 0,
"agents": num_agents
},
}
# Simulate a dataset
params_spec, options_spec = generate_random_model(point_constr=constr)
respy_obj = RespyCls(params_spec, options_spec)
simulate_observed(respy_obj)
# Evaluate at different points, ensuring that the simulated dataset still fits.
params_spec, options_spec = generate_random_model(point_constr=constr)
respy_obj = RespyCls(params_spec, options_spec)
respy_obj.fit()
def change_status(identifiers, init_file, is_fixed):
""" Change the status of the a list of parameters.
"""
# Baseline
init_dict = read(init_file)
respy_obj = RespyCls(init_file)
model_paras = respy_obj.get_attr('model_paras')
coeffs_a, coeffs_b, coeffs_edu, coeffs_home, shocks_cholesky = \
dist_model_paras(model_paras, True)
for identifier in identifiers:
if identifier in list(range(0, 6)):
j = identifier
init_dict['OCCUPATION A']['coeffs'][j] = coeffs_a[j]
init_dict['OCCUPATION A']['fixed'][j] = is_fixed
elif identifier in list(range(6, 12)):
j = identifier - 6
init_dict['OCCUPATION B']['coeffs'][j] = coeffs_b[j]
init_dict['OCCUPATION B']['fixed'][j] = is_fixed
elif identifier in list(range(12, 15)):
j = identifier - 12
init_dict['EDUCATION']['coeffs'][j] = coeffs_edu[j]
init_dict['EDUCATION']['fixed'][j] = is_fixed
elif identifier in list(range(15, 16)):
j = identifier - 15
init_dict['HOME']['coeffs'][j] = coeffs_home[j]
init_dict['HOME']['fixed'][j] = is_fixed
elif identifier in list(range(16, 26)):
j = identifier - 16
shocks_coeffs = cholesky_to_coeffs(shocks_cholesky)
init_dict['SHOCKS']['coeffs'] = shocks_coeffs
init_dict['SHOCKS']['fixed'][j] = is_fixed
else:
raise NotImplementedError
# Print dictionary to file
print_init_dict(init_dict, init_file)
def test_2(self):
""" If there is no random variation in payoffs then the number of
draws to simulate the expected future value should have no effect.
"""
# Generate constraints
constr = dict()
constr['is_deterministic'] = True
# Generate random initialization file
generate_init(constr)
# Initialize auxiliary objects
base = None
for _ in range(2):
# Draw a random number of draws for
# expected future value calculations.
num_draws_emax = np.random.randint(1, 100)
# Perform toolbox actions
respy_obj = RespyCls('test.respy.ini')
respy_obj.unlock()
respy_obj.set_attr('num_draws_emax', num_draws_emax)
respy_obj.lock()
respy_obj = simulate(respy_obj)
# Distribute class attributes
periods_emax = respy_obj.get_attr('periods_emax')
if base is None:
base = periods_emax.copy()
# Statistic
diff = np.max(abs(np.ma.masked_invalid(base) - np.ma.masked_invalid(
periods_emax)))
# Checks
assert (np.isfinite(diff))
assert (diff < 10e-10)
def scripts_simulate(update, init_file, file_sim, solved):
""" Wrapper for the estimation.
"""
# Read in baseline model specification.
if solved is not None:
respy_obj = pkl.load(open(solved, 'rb'))
else:
respy_obj = RespyCls(init_file)
# Update parametrization of the model if resuming from a previous
# estimation run.
if update:
respy_obj.update_model_paras(get_est_info()['paras_step'])
# Update file for output.
if file_sim is not None:
respy_obj.unlock()
respy_obj.set_attr('file_sim', file_sim)
respy_obj.lock()
# Optimize the criterion function.
simulate(respy_obj)
def test_2(self):
""" This test ensures that the evaluation of the criterion function
at the starting value is identical between the different versions.
"""
max_draws = np.random.randint(10, 100)
# Generate random initialization file
constr = dict()
constr['flag_parallelism'] = False
constr['max_draws'] = max_draws
constr['flag_interpolation'] = False
constr['maxfun'] = 0
# Generate random initialization file
init_dict = generate_init(constr)
# Perform toolbox actions
respy_obj = RespyCls('test.respy.ini')
# Simulate a dataset
simulate(respy_obj)
# Iterate over alternative implementations
base_x, base_val = None, None
num_periods = init_dict['BASICS']['periods']
write_draws(num_periods, max_draws)
for version in ['FORTRAN', 'PYTHON']:
respy_obj.unlock()
respy_obj.set_attr('version', version)
respy_obj.lock()
x, val = estimate(respy_obj)
# Check for the returned parameters.
if base_x is None:
base_x = x
np.testing.assert_allclose(base_x, x)
# Check for the value of the criterion function.
if base_val is None:
base_val = val
np.testing.assert_allclose(base_val, val)
def scripts_estimate(resume, single, init_file, gradient):
""" Wrapper for the estimation.
"""
# Read in baseline model specification.
respy_obj = RespyCls(init_file)
# Update parametrization of the model if resuming from a previous
# estimation run.
if resume:
respy_obj.update_model_paras(get_est_info()['paras_step'])
# Set maximum iteration count when only an evaluation of the criterion
# function is requested.
if single:
respy_obj.unlock()
respy_obj.set_attr('maxfun', 0)
respy_obj.lock()
# Optimize the criterion function.
estimate(respy_obj)
if gradient:
add_gradient_information(respy_obj)
def test_3(self):
""" Testing whether the a simulated dataset and the evaluation of the
criterion function are the same for a tiny delta and a myopic agent.
"""
# Generate random initialization dictionary
constr = dict()
constr['maxfun'] = 0
generate_init(constr)
# Iterate over alternative discount rates.
base_data, base_val = None, None
for delta in [0.00, 0.000001]:
respy_obj = RespyCls('test.respy.ini')
respy_obj.unlock()
respy_obj.set_attr('delta', delta)
respy_obj.lock()
simulate(respy_obj)
# This parts checks the equality of simulated dataset for the
# different versions of the code.
data_frame = pd.read_csv('data.respy.dat', delim_whitespace=True)
if base_data is None:
base_data = data_frame.copy()
assert_frame_equal(base_data, data_frame)
# This part checks the equality of an evaluation of the
# criterion function.
_, crit_val = estimate(respy_obj)
if base_val is None:
base_val = crit_val
np.testing.assert_allclose(base_val, crit_val, rtol=1e-03, atol=1e-03)
def test_4(self):
""" Test the solution of deterministic model without ambiguity,
but with interpolation. As a deterministic model is requested,
all versions should yield the same result without any additional effort.
"""
# Solve specified economy
for version in ['FORTRAN', 'PYTHON']:
respy_obj = RespyCls(TEST_RESOURCES_DIR + '/test_fifth.respy.ini')
respy_obj.unlock()
respy_obj.set_attr('version', version)
respy_obj.lock()
respy_obj = simulate(respy_obj)
# Assess expected future value
val = respy_obj.get_attr('periods_emax')[0, :1]
np.testing.assert_allclose(val, 88750)
# Assess evaluation
_, val = estimate(respy_obj)
np.testing.assert_allclose(val, -1.0)
from respy.python.evaluate.evaluate_auxiliary import check_input
from respy.python.evaluate.evaluate_auxiliary import check_output
from respy.python.shared.shared_auxiliary import dist_class_attributes
from respy.python.shared.shared_auxiliary import create_draws
from respy import simulate, RespyCls, estimate
import numpy as np
import pickle as pkl
respy_obj = RespyCls('model.respy.ini')
simulate(respy_obj)
base = None
for num_procs in [1, 2]:
respy_obj.unlock()
respy_obj.set_attr('num_procs', num_procs)
respy_obj.set_attr('is_parallel', (num_procs > 1))
respy_obj.lock()
x, crit_val = estimate(respy_obj)
if base is None:
base = crit_val
def test_1(self):
""" Testing the equality of an evaluation of the criterion function for
a random request.
"""
# Run evaluation for multiple random requests.
is_deterministic = np.random.choice([True, False], p=[0.10, 0.9])
is_interpolated = np.random.choice([True, False], p=[0.10, 0.9])
is_myopic = np.random.choice([True, False], p=[0.10, 0.9])
max_draws = np.random.randint(10, 100)
# Generate random initialization file
constr = dict()
constr['is_deterministic'] = is_deterministic
constr['flag_parallelism'] = False
constr['is_myopic'] = is_myopic
constr['max_draws'] = max_draws
constr['maxfun'] = 0
init_dict = generate_random_dict(constr)
# The use of the interpolation routines is a another special case.
# Constructing a request that actually involves the use of the
# interpolation routine is a little involved as the number of
# interpolation points needs to be lower than the actual number of
# states. And to know the number of states each period, I need to
# construct the whole state space.
if is_interpolated:
# Extract from future initialization file the information
# required to construct the state space. The number of periods
# needs to be at least three in order to provide enough state
# points.
num_periods = np.random.randint(3, 6)
edu_start = init_dict['EDUCATION']['start']
edu_max = init_dict['EDUCATION']['max']
min_idx = min(num_periods, (edu_max - edu_start + 1))
max_states_period = pyth_create_state_space(num_periods, edu_start,
edu_max, min_idx)[3]
# Updates to initialization dictionary that trigger a use of the
# interpolation code.
init_dict['BASICS']['periods'] = num_periods
init_dict['INTERPOLATION']['flag'] = True
init_dict['INTERPOLATION']['points'] = \
np.random.randint(10, max_states_period)
# Print out the relevant initialization file.
print_init_dict(init_dict)
# Write out random components and interpolation grid to align the
# three implementations.
num_periods = init_dict['BASICS']['periods']
write_draws(num_periods, max_draws)
write_interpolation_grid('test.respy.ini')
# Clean evaluations based on interpolation grid,
base_val, base_data = None, None
for version in ['PYTHON', 'FORTRAN']:
respy_obj = RespyCls('test.respy.ini')
# Modify the version of the program for the different requests.
respy_obj.unlock()
respy_obj.set_attr('version', version)
respy_obj.lock()
# Solve the model
respy_obj = simulate(respy_obj)
# This parts checks the equality of simulated dataset for the
# different versions of the code.
data_frame = pd.read_csv('data.respy.dat', delim_whitespace=True)
if base_data is None:
base_data = data_frame.copy()
assert_frame_equal(base_data, data_frame)
# This part checks the equality of an evaluation of the
# criterion function.
_, crit_val = estimate(respy_obj)
if base_val is None:
base_val = crit_val
np.testing.assert_allclose(base_val, crit_val, rtol=1e-05,
atol=1e-06)
# We know even more for the deterministic case.
if constr['is_deterministic']:
assert (crit_val in [-1.0, 0.0])
def test_2(self):
""" Compare the solution of simple model against hard-coded results.
"""
# Solve specified economy
respy_obj = RespyCls(TEST_RESOURCES_DIR + '/test_second.respy.ini')
respy_obj = simulate(respy_obj)
# Distribute class attributes
systematic = respy_obj.get_attr('periods_payoffs_systematic')
emax = respy_obj.get_attr('periods_emax')
# PERIOD 3: Check the systematic payoffs against hand calculations.
vals = [[2.7456010000000000, 07.5383250000000000, -3999.60, 1.140]]
vals += [[3.0343583944356758, 09.2073308658822519, -3999.60, 1.140]]
vals += [[3.0343583944356758, 09.2073308658822519, 0000.90, 1.140]]
vals += [[3.3534846500000000, 11.2458593100000000, 0000.40, 1.140]]
vals += [[3.5966397255692826, 12.0612761204447200, -3999.60, 1.140]]
vals += [[3.9749016274947495, 14.7316759204425760, -3999.60, 1.140]]
vals += [[3.9749016274947495, 14.7316759204425760, 0000.90, 1.140]]
vals += [[6.2338866585247175, 31.1869581683094590, -3999.60, 1.140]]
vals += [[3.4556134647626764, 11.5883467192233920, -3999.60, 1.140]]
vals += [[3.8190435053663370, 14.1540386453758080, -3999.60, 1.140]]
vals += [[3.8190435053663370, 14.1540386453758080, 0000.90, 1.140]]
vals += [[4.5267307943142532, 18.5412874597468690, -3999.60, 1.140]]
vals += [[5.5289614776240041, 27.6603505585167470, -3999.60, 1.140]]
for i, val in enumerate(vals):
(np.testing.assert_allclose(systematic[2, i, :], val))
# PERIOD 3: Check expected future values. As there are no
# random draws, this corresponds to the maximum
# value in the last period.
vals = [7.53832493366, 9.20733086588, 9.20733086588, 11.2458593149]
vals += [12.06127612040, 14.7316759204, 14.7316759204, 31.1869581683]
vals += [11.58834671922, 14.1540386453, 14.1540386453, 18.5412874597]
vals += [27.660350558516747]
for i, val in enumerate(vals):
(np.testing.assert_allclose(emax[2, i], [val]))
# PERIOD 2: Check the systematic payoffs against hand calculations.
vals = [[2.7456010150169163, 07.5383249336619222, -3999.60, 1.140]]
vals += [[3.0343583944356758, 09.2073308658822519, 0000.90, 1.140]]
vals += [[3.5966397255692826, 12.0612761204447200, -3999.60, 1.140]]
vals += [[3.4556134647626764, 11.5883467192233920, -3999.60, 1.140]]
for i, val in enumerate(vals):
(np.testing.assert_allclose(systematic[1, i, :], val))
# PERIOD 2: Check expected future values.
vals = [18.9965372481, 23.2024229903, 41.6888863803, 29.7329464954]
for i, val in enumerate(vals):
(np.testing.assert_allclose(emax[1, i], [val]))
# PERIOD 1: Check the systematic payoffs against hand calculations.
vals = [[2.7456010150169163, 7.5383249336619222, 0.90, 1.140]]
for i, val in enumerate(vals):
(np.testing.assert_allclose(systematic[0, i, :], val))
# PERIOD 1 Check expected future values.
vals = [47.142766995]
for i, val in enumerate(vals):
(np.testing.assert_allclose(emax[0, 0], [val]))
# Assess evaluation
_, val = estimate(respy_obj)
np.testing.assert_allclose(val, 0.00)
