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_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_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_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):
""" 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_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_1(self):
""" Testing ten admissible realizations of state space for the first
three periods.
"""
# Generate constraint periods
constraints = dict()
constraints['periods'] = np.random.randint(3, 5)
# Generate random initialization file
generate_init(constraints)
# Perform toolbox actions
respy_obj = RespyCls('test.respy.ini')
respy_obj = simulate(respy_obj)
# Distribute class attributes
states_number_period = respy_obj.get_attr('states_number_period')
states_all = respy_obj.get_attr('states_all')
# The next hard-coded results assume that at least two more
# years of education are admissible.
edu_max = respy_obj.get_attr('edu_max')
edu_start = respy_obj.get_attr('edu_start')
if edu_max - edu_start < 2:
return
# The number of admissible states in the first three periods
for j, number_period in enumerate([1, 4, 13]):
assert (states_number_period[j] == number_period)
# The actual realizations of admissible states in period one
assert ((states_all[0, 0, :] == [0, 0, 0, 1]).all())
# The actual realizations of admissible states in period two
states = [[0, 0, 0, 0], [0, 0, 1, 1], [0, 1, 0, 0]]
states += [[1, 0, 0, 0]]
for j, state in enumerate(states):
assert ((states_all[1, j, :] == state).all())
# The actual realizations of admissible states in period three
states = [[0, 0, 0, 0], [0, 0, 1, 0], [0, 0, 1, 1]]
states += [[0, 0, 2, 1], [0, 1, 0, 0], [0, 1, 1, 0]]
states += [[0, 1, 1, 1], [0, 2, 0, 0], [1, 0, 0, 0]]
states += [[1, 0, 1, 0], [1, 0, 1, 1], [1, 1, 0, 0]]
states += [[2, 0, 0, 0]]
for j, state in enumerate(states):
assert ((states_all[2, j, :] == state).all())
def test_1(self):
""" Compare the evaluation of the criterion function for the ambiguity
optimization and the simulated expected future value between the FORTRAN
and PYTHON implementations. These tests are set up a separate test case
due to the large setup cost to construct the ingredients for the interface.
"""
# Generate constraint periods
constraints = dict()
constraints['version'] = 'PYTHON'
# Generate random initialization file
generate_init(constraints)
# Perform toolbox actions
respy_obj = RespyCls('test.respy.ini')
respy_obj = simulate(respy_obj)
# Extract class attributes
periods_payoffs_systematic, states_number_period, mapping_state_idx, \
periods_emax, num_periods, states_all, num_draws_emax, edu_start, \
edu_max, delta = \
dist_class_attributes(respy_obj,
'periods_payoffs_systematic', 'states_number_period',
'mapping_state_idx', 'periods_emax', 'num_periods',
'states_all', 'num_draws_emax', 'edu_start', 'edu_max',
'delta')
# Sample draws
draws_standard = np.random.multivariate_normal(np.zeros(4),
np.identity(4),
(num_draws_emax, ))
# Sampling of random period and admissible state index
period = np.random.choice(range(num_periods))
k = np.random.choice(range(states_number_period[period]))
# Select systematic payoffs
payoffs_systematic = periods_payoffs_systematic[period, k, :]
# Evaluation of simulated expected future values
args = (num_periods, num_draws_emax, period, k, draws_standard,
payoffs_systematic, edu_max, edu_start, periods_emax,
states_all, mapping_state_idx, delta)
py = get_future_value(*args)
f90 = fort_debug.wrapper_get_future_value(*args)
np.testing.assert_allclose(py, f90, rtol=1e-05, atol=1e-06)
def test_6(self):
""" Test short estimation tasks.
"""
# Constraints that ensures that the maximum number of iterations and
# the number of function evaluations is set to the minimum values of
# one.
constr = dict()
constr['is_estimation'] = True
generate_init(constr)
# Run estimation task.
respy_obj = RespyCls('test.respy.ini')
simulate(respy_obj)
estimate(respy_obj)
def test_6(self):
""" Test short estimation tasks.
"""
# Constraints that ensures that the maximum number of iterations and
# the number of function evaluations is set to the minimum values of
# one.
constr = dict()
constr['is_estimation'] = True
generate_init(constr)
# Run estimation task.
respy_obj = RespyCls('test.respy.ini')
simulate(respy_obj)
estimate(respy_obj)
def test_1(self):
""" Compare the evaluation of the criterion function for the ambiguity
optimization and the simulated expected future value between the FORTRAN
and PYTHON implementations. These tests are set up a separate test case
due to the large setup cost to construct the ingredients for the interface.
"""
# Generate constraint periods
constraints = dict()
constraints['version'] = 'PYTHON'
# Generate random initialization file
generate_init(constraints)
# Perform toolbox actions
respy_obj = RespyCls('test.respy.ini')
respy_obj = simulate(respy_obj)
# Extract class attributes
periods_payoffs_systematic, states_number_period, mapping_state_idx, \
periods_emax, num_periods, states_all, num_draws_emax, edu_start, \
edu_max, delta = \
dist_class_attributes(respy_obj,
'periods_payoffs_systematic', 'states_number_period',
'mapping_state_idx', 'periods_emax', 'num_periods',
'states_all', 'num_draws_emax', 'edu_start', 'edu_max',
'delta')
# Sample draws
draws_standard = np.random.multivariate_normal(np.zeros(4),
np.identity(4), (num_draws_emax,))
# Sampling of random period and admissible state index
period = np.random.choice(range(num_periods))
k = np.random.choice(range(states_number_period[period]))
# Select systematic payoffs
payoffs_systematic = periods_payoffs_systematic[period, k, :]
# Evaluation of simulated expected future values
args = (num_periods, num_draws_emax, period, k, draws_standard,
payoffs_systematic, edu_max, edu_start, periods_emax, states_all,
mapping_state_idx, delta)
py = get_future_value(*args)
f90 = fort_debug.wrapper_get_future_value(*args)
np.testing.assert_allclose(py, f90, rtol=1e-05, atol=1e-06)
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):
""" 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_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_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_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_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_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 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.
constr = dict()
constr['periods'] = np.random.randint(1, 4)
constr['agents'] = np.random.randint(1, 100)
constr['edu'] = (7, 15)
constr['maxfun'] = 0
# Simulate a dataset
generate_init(constr)
respy_obj = RespyCls('test.respy.ini')
simulate(respy_obj)
# Evaluate at different points, ensuring that the simulated dataset
# still fits.
generate_init(constr)
respy_obj = RespyCls('test.respy.ini')
estimate(respy_obj)
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.
constr = dict()
constr['periods'] = np.random.randint(1, 4)
constr['agents'] = np.random.randint(1, 100)
constr['edu'] = (7, 15)
constr['maxfun'] = 0
# Simulate a dataset
generate_init(constr)
respy_obj = RespyCls('test.respy.ini')
simulate(respy_obj)
# Evaluate at different points, ensuring that the simulated dataset
# still fits.
generate_init(constr)
respy_obj = RespyCls('test.respy.ini')
estimate(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 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 test_4(self):
""" Testing the core functions of the solution step for the equality
of results between the PYTHON and FORTRAN implementations.
"""
# Generate random initialization file
generate_init()
# Perform toolbox actions
respy_obj = RespyCls('test.respy.ini')
# Ensure that backward induction routines use the same grid for the
# interpolation.
write_interpolation_grid('test.respy.ini')
# Extract class attributes
num_periods, edu_start, edu_max, min_idx, model_paras, num_draws_emax, \
seed_emax, is_debug, delta, is_interpolated, num_points_interp, = \
dist_class_attributes(respy_obj,
'num_periods', 'edu_start', 'edu_max', 'min_idx',
'model_paras', 'num_draws_emax', 'seed_emax', 'is_debug',
'delta', 'is_interpolated', 'num_points_interp')
# Auxiliary objects
coeffs_a, coeffs_b, coeffs_edu, coeffs_home, shocks_cholesky = \
dist_model_paras(model_paras, is_debug)
# Check the state space creation.
args = (num_periods, edu_start, edu_max, min_idx)
pyth = pyth_create_state_space(*args)
f2py = fort_debug.f2py_create_state_space(*args)
for i in range(4):
np.testing.assert_allclose(pyth[i], f2py[i])
# Carry some results from the state space creation for future use.
states_all, states_number_period = pyth[:2]
mapping_state_idx, max_states_period = pyth[2:]
# Cutting to size
states_all = states_all[:, :max(states_number_period), :]
# Check calculation of systematic components of payoffs.
args = (num_periods, states_number_period, states_all, edu_start,
coeffs_a, coeffs_b, coeffs_edu, coeffs_home, max_states_period)
pyth = pyth_calculate_payoffs_systematic(*args)
f2py = fort_debug.f2py_calculate_payoffs_systematic(*args)
np.testing.assert_allclose(pyth, f2py)
# Carry some results from the systematic payoff calculation for
# future use and create the required set of disturbances.
periods_draws_emax = create_draws(num_periods, num_draws_emax,
seed_emax, is_debug)
periods_payoffs_systematic = pyth
# Check backward induction procedure.
args = (num_periods, max_states_period, periods_draws_emax,
num_draws_emax, states_number_period,
periods_payoffs_systematic, edu_max, edu_start,
mapping_state_idx, states_all, delta, is_debug,
is_interpolated, num_points_interp, shocks_cholesky)
pyth = pyth_backward_induction(*args)
f2py = fort_debug.f2py_backward_induction(*args)
np.testing.assert_allclose(pyth, f2py)
def test_5(self):
""" This methods ensures that the core functions yield the same
results across implementations.
"""
# Generate random initialization file
generate_init()
# Perform toolbox actions
respy_obj = RespyCls('test.respy.ini')
# Ensure that backward induction routines use the same grid for the
# interpolation.
max_states_period = write_interpolation_grid('test.respy.ini')
# Extract class attributes
num_periods, edu_start, edu_max, min_idx, model_paras, num_draws_emax, \
is_debug, delta, is_interpolated, num_points_interp, is_myopic, num_agents_sim, \
num_draws_prob, tau, paras_fixed, seed_sim = \
dist_class_attributes(
respy_obj, 'num_periods', 'edu_start', 'edu_max', 'min_idx',
'model_paras', 'num_draws_emax', 'is_debug', 'delta',
'is_interpolated', 'num_points_interp', 'is_myopic', 'num_agents_sim',
'num_draws_prob', 'tau', 'paras_fixed', 'seed_sim')
# Write out random components and interpolation grid to align the
# three implementations.
max_draws = max(num_agents_sim, num_draws_emax, num_draws_prob)
write_draws(num_periods, max_draws)
periods_draws_emax = read_draws(num_periods, num_draws_emax)
periods_draws_prob = read_draws(num_periods, num_draws_prob)
periods_draws_sims = read_draws(num_periods, num_agents_sim)
# Extract coefficients
coeffs_a, coeffs_b, coeffs_edu, coeffs_home, shocks_cholesky = dist_model_paras(
model_paras, True)
# Check the full solution procedure
base_args = (coeffs_a, coeffs_b, coeffs_edu, coeffs_home,
shocks_cholesky, is_interpolated, num_draws_emax,
num_periods, num_points_interp, is_myopic, edu_start,
is_debug, edu_max, min_idx, delta)
fort, _ = resfort_interface(respy_obj, 'simulate')
pyth = pyth_solve(*base_args + (periods_draws_emax, ))
f2py = fort_debug.f2py_solve(*base_args +
(periods_draws_emax, max_states_period))
for alt in [f2py, fort]:
for i in range(5):
np.testing.assert_allclose(pyth[i], alt[i])
# Distribute solution arguments for further use in simulation test.
periods_payoffs_systematic, _, mapping_state_idx, periods_emax, states_all = pyth
args = (periods_payoffs_systematic, mapping_state_idx, \
periods_emax, states_all, shocks_cholesky, num_periods, edu_start,
edu_max, delta, num_agents_sim, periods_draws_sims, seed_sim)
pyth = pyth_simulate(*args)
f2py = fort_debug.f2py_simulate(*args)
np.testing.assert_allclose(pyth, f2py)
data_array = pyth
base_args = (coeffs_a, coeffs_b, coeffs_edu, coeffs_home,
shocks_cholesky, is_interpolated, num_draws_emax,
num_periods, num_points_interp, is_myopic, edu_start,
is_debug, edu_max, min_idx, delta, data_array,
num_agents_sim, num_draws_prob, tau)
args = base_args + (periods_draws_emax, periods_draws_prob)
pyth = pyth_evaluate(*args)
args = base_args + (periods_draws_emax, periods_draws_prob)
f2py = fort_debug.f2py_evaluate(*args)
np.testing.assert_allclose(pyth, f2py)
# Evaluation of criterion function
x0 = get_optim_paras(coeffs_a, coeffs_b, coeffs_edu, coeffs_home,
shocks_cholesky, 'all', paras_fixed, is_debug)
args = (is_interpolated, num_draws_emax, num_periods,
num_points_interp, is_myopic, edu_start, is_debug, edu_max,
min_idx, delta, data_array, num_agents_sim, num_draws_prob,
tau, periods_draws_emax, periods_draws_prob)
pyth = pyth_criterion(x0, *args)
f2py = fort_debug.f2py_criterion(x0, *args)
np.testing.assert_allclose(pyth, f2py)
def test_6(self):
""" Further tests for the interpolation routines.
"""
# Generate random initialization file
generate_init()
# Perform toolbox actions
respy_obj = RespyCls('test.respy.ini')
respy_obj = simulate(respy_obj)
# Extract class attributes
periods_payoffs_systematic, states_number_period, mapping_state_idx, seed_prob, periods_emax, num_periods, states_all, num_points_interp, edu_start, num_draws_emax, is_debug, edu_max, delta = dist_class_attributes(
respy_obj, 'periods_payoffs_systematic', 'states_number_period',
'mapping_state_idx', 'seed_prob', 'periods_emax', 'num_periods',
'states_all', 'num_points_interp', 'edu_start', 'num_draws_emax',
'is_debug', 'edu_max', 'delta')
# Add some additional objects required for the interfaces to the
# functions.
period = np.random.choice(range(num_periods))
periods_draws_emax = create_draws(num_periods, num_draws_emax,
seed_prob, is_debug)
draws_emax = periods_draws_emax[period, :, :]
num_states = states_number_period[period]
shifts = np.random.randn(4)
# Slight modification of request which assures that the
# interpolation code is working.
num_points_interp = min(num_points_interp, num_states)
# Get the IS_SIMULATED indicator for the subset of points which are
# used for the predication model.
args = (num_points_interp, num_states, period, is_debug)
is_simulated = get_simulated_indicator(*args)
# Construct the exogenous variables for all points of the state
# space.
args = (period, num_periods, num_states, delta,
periods_payoffs_systematic, shifts, edu_max, edu_start,
mapping_state_idx, periods_emax, states_all)
py = get_exogenous_variables(*args)
f90 = fort_debug.wrapper_get_exogenous_variables(*args)
np.testing.assert_equal(py, f90)
# Distribute validated results for further functions.
exogenous, maxe = py
# Construct endogenous variable so that the prediction model can be
# fitted.
args = (period, num_periods, num_states, delta,
periods_payoffs_systematic, edu_max, edu_start,
mapping_state_idx, periods_emax, states_all, is_simulated,
num_draws_emax, maxe, draws_emax)
py = get_endogenous_variable(*args)
f90 = fort_debug.wrapper_get_endogenous_variable(*args)
np.testing.assert_equal(py, replace_missing_values(f90))
# Distribute validated results for further functions.
endogenous = py
args = (endogenous, exogenous, maxe, is_simulated, num_points_interp,
num_states, is_debug)
py = get_predictions(*args)
f90 = fort_debug.wrapper_get_predictions(*args[:-1])
np.testing.assert_array_almost_equal(py, f90)
def run(args):
""" Test the different releases against each other.
"""
# Set up auxiliary information to construct commands.
env_dir = os.environ['HOME'] + '/.envs'
old_exec = env_dir + '/' + OLD_RELEASE + '/bin/python'
new_exec = env_dir + '/' + NEW_RELEASE + '/bin/python'
# # Create fresh virtual environments.
# for release in [OLD_RELEASE, NEW_RELEASE]:
# cmd = ['pyvenv', env_dir + '/' + release, '--clear']
# subprocess.check_call(cmd)
#
# # Set up the virtual environments with the two releases under investigation.
# for which in ['old', 'new']:
# if which == 'old':
# release, python_exec = OLD_RELEASE, old_exec
# elif which == 'new':
# release, python_exec = NEW_RELEASE, new_exec
# else:
# raise AssertionError
# cmd = [python_exec, '../_modules/auxiliary_release.py', release]
# subprocess.check_call(cmd)
# Run tests
# TODO: How about log files.
cleanup()
is_failed = False
# Evaluation loop.
start, timeout = datetime.now(), timedelta(hours=args.hours)
num_tests = 0
is_running = True
while is_running:
num_tests += 1
# Set seed.
seed = random.randrange(1, 100000)
np.random.seed(seed)
# Create a random estimation task.
constr = dict()
constr['is_estimation'] = True
generate_init(constr)
respy_obj = RespyCls('test.respy.ini')
simulate(respy_obj)
crit_val = None
for which in ['old', 'new']:
if which == 'old':
release, python_exec = OLD_RELEASE, old_exec
elif which == 'new':
release, python_exec = NEW_RELEASE, new_exec
else:
raise AssertionError
cmd = [python_exec, '../_modules/auxiliary_release.py']
subprocess.check_call(cmd)
if crit_val is None:
crit_val = np.genfromtxt('.crit_val')
try:
np.testing.assert_equal(crit_val, np.genfromtxt(
'.crit_val'))
except AssertionError:
is_failed = True
is_running = False
# Timeout.
if timeout < datetime.now() - start:
break
send_notification('release', hours=args.hours, is_failed=is_failed,
seed=seed, num_tests=num_tests)
def test_4(self):
""" Testing the core functions of the solution step for the equality
of results between the PYTHON and FORTRAN implementations.
"""
# Generate random initialization file
generate_init()
# Perform toolbox actions
respy_obj = RespyCls('test.respy.ini')
# Ensure that backward induction routines use the same grid for the
# interpolation.
write_interpolation_grid('test.respy.ini')
# Extract class attributes
num_periods, edu_start, edu_max, min_idx, model_paras, num_draws_emax, \
seed_emax, is_debug, delta, is_interpolated, num_points_interp, = \
dist_class_attributes(respy_obj,
'num_periods', 'edu_start', 'edu_max', 'min_idx',
'model_paras', 'num_draws_emax', 'seed_emax', 'is_debug',
'delta', 'is_interpolated', 'num_points_interp')
# Auxiliary objects
coeffs_a, coeffs_b, coeffs_edu, coeffs_home, shocks_cholesky = \
dist_model_paras(model_paras, is_debug)
# Check the state space creation.
args = (num_periods, edu_start, edu_max, min_idx)
pyth = pyth_create_state_space(*args)
f2py = fort_debug.f2py_create_state_space(*args)
for i in range(4):
np.testing.assert_allclose(pyth[i], f2py[i])
# Carry some results from the state space creation for future use.
states_all, states_number_period = pyth[:2]
mapping_state_idx, max_states_period = pyth[2:]
# Cutting to size
states_all = states_all[:, :max(states_number_period), :]
# Check calculation of systematic components of payoffs.
args = (num_periods, states_number_period, states_all, edu_start,
coeffs_a, coeffs_b, coeffs_edu, coeffs_home, max_states_period)
pyth = pyth_calculate_payoffs_systematic(*args)
f2py = fort_debug.f2py_calculate_payoffs_systematic(*args)
np.testing.assert_allclose(pyth, f2py)
# Carry some results from the systematic payoff calculation for
# future use and create the required set of disturbances.
periods_draws_emax = create_draws(num_periods, num_draws_emax,
seed_emax, is_debug)
periods_payoffs_systematic = pyth
# Check backward induction procedure.
args = (num_periods, max_states_period, periods_draws_emax,
num_draws_emax, states_number_period, periods_payoffs_systematic,
edu_max, edu_start, mapping_state_idx, states_all, delta,
is_debug, is_interpolated, num_points_interp, shocks_cholesky)
pyth = pyth_backward_induction(*args)
f2py = fort_debug.f2py_backward_induction(*args)
np.testing.assert_allclose(pyth, f2py)
def test_5(self):
""" This methods ensures that the core functions yield the same
results across implementations.
"""
# Generate random initialization file
generate_init()
# Perform toolbox actions
respy_obj = RespyCls('test.respy.ini')
# Ensure that backward induction routines use the same grid for the
# interpolation.
max_states_period = write_interpolation_grid('test.respy.ini')
# Extract class attributes
num_periods, edu_start, edu_max, min_idx, model_paras, num_draws_emax, \
is_debug, delta, is_interpolated, num_points_interp, is_myopic, num_agents_sim, \
num_draws_prob, tau, paras_fixed, seed_sim = \
dist_class_attributes(
respy_obj, 'num_periods', 'edu_start', 'edu_max', 'min_idx',
'model_paras', 'num_draws_emax', 'is_debug', 'delta',
'is_interpolated', 'num_points_interp', 'is_myopic', 'num_agents_sim',
'num_draws_prob', 'tau', 'paras_fixed', 'seed_sim')
# Write out random components and interpolation grid to align the
# three implementations.
max_draws = max(num_agents_sim, num_draws_emax, num_draws_prob)
write_draws(num_periods, max_draws)
periods_draws_emax = read_draws(num_periods, num_draws_emax)
periods_draws_prob = read_draws(num_periods, num_draws_prob)
periods_draws_sims = read_draws(num_periods, num_agents_sim)
# Extract coefficients
coeffs_a, coeffs_b, coeffs_edu, coeffs_home, shocks_cholesky = dist_model_paras(
model_paras, True)
# Check the full solution procedure
base_args = (coeffs_a, coeffs_b, coeffs_edu, coeffs_home, shocks_cholesky,
is_interpolated, num_draws_emax, num_periods, num_points_interp, is_myopic,
edu_start, is_debug, edu_max, min_idx, delta)
fort, _ = resfort_interface(respy_obj, 'simulate')
pyth = pyth_solve(*base_args + (periods_draws_emax,))
f2py = fort_debug.f2py_solve(*base_args + (periods_draws_emax, max_states_period))
for alt in [f2py, fort]:
for i in range(5):
np.testing.assert_allclose(pyth[i], alt[i])
# Distribute solution arguments for further use in simulation test.
periods_payoffs_systematic, _, mapping_state_idx, periods_emax, states_all = pyth
args = (periods_payoffs_systematic, mapping_state_idx, \
periods_emax, states_all, shocks_cholesky, num_periods, edu_start,
edu_max, delta, num_agents_sim, periods_draws_sims, seed_sim)
pyth = pyth_simulate(*args)
f2py = fort_debug.f2py_simulate(*args)
np.testing.assert_allclose(pyth, f2py)
data_array = pyth
base_args = (coeffs_a, coeffs_b, coeffs_edu, coeffs_home, shocks_cholesky,
is_interpolated, num_draws_emax, num_periods, num_points_interp, is_myopic,
edu_start, is_debug, edu_max, min_idx, delta, data_array, num_agents_sim,
num_draws_prob, tau)
args = base_args + (periods_draws_emax, periods_draws_prob)
pyth = pyth_evaluate(*args)
args = base_args + (periods_draws_emax, periods_draws_prob)
f2py = fort_debug.f2py_evaluate(*args)
np.testing.assert_allclose(pyth, f2py)
# Evaluation of criterion function
x0 = get_optim_paras(coeffs_a, coeffs_b, coeffs_edu, coeffs_home,
shocks_cholesky, 'all', paras_fixed, is_debug)
args = (
is_interpolated, num_draws_emax, num_periods, num_points_interp, is_myopic,
edu_start, is_debug, edu_max, min_idx, delta, data_array, num_agents_sim,
num_draws_prob, tau, periods_draws_emax, periods_draws_prob)
pyth = pyth_criterion(x0, *args)
f2py = fort_debug.f2py_criterion(x0, *args)
np.testing.assert_allclose(pyth, f2py)
def test_6(self):
""" Further tests for the interpolation routines.
"""
# Generate random initialization file
generate_init()
# Perform toolbox actions
respy_obj = RespyCls('test.respy.ini')
respy_obj = simulate(respy_obj)
# Extract class attributes
periods_payoffs_systematic, states_number_period, mapping_state_idx, seed_prob, periods_emax, num_periods, states_all, num_points_interp, edu_start, num_draws_emax, is_debug, edu_max, delta = dist_class_attributes(
respy_obj, 'periods_payoffs_systematic', 'states_number_period',
'mapping_state_idx', 'seed_prob', 'periods_emax',
'num_periods', 'states_all', 'num_points_interp', 'edu_start',
'num_draws_emax', 'is_debug', 'edu_max', 'delta')
# Add some additional objects required for the interfaces to the
# functions.
period = np.random.choice(range(num_periods))
periods_draws_emax = create_draws(num_periods, num_draws_emax, seed_prob,
is_debug)
draws_emax = periods_draws_emax[period, :, :]
num_states = states_number_period[period]
shifts = np.random.randn(4)
# Slight modification of request which assures that the
# interpolation code is working.
num_points_interp = min(num_points_interp, num_states)
# Get the IS_SIMULATED indicator for the subset of points which are
# used for the predication model.
args = (num_points_interp, num_states, period, is_debug)
is_simulated = get_simulated_indicator(*args)
# Construct the exogenous variables for all points of the state
# space.
args = (
period, num_periods, num_states, delta, periods_payoffs_systematic, shifts,
edu_max, edu_start, mapping_state_idx, periods_emax, states_all)
py = get_exogenous_variables(*args)
f90 = fort_debug.wrapper_get_exogenous_variables(*args)
np.testing.assert_equal(py, f90)
# Distribute validated results for further functions.
exogenous, maxe = py
# Construct endogenous variable so that the prediction model can be
# fitted.
args = (period, num_periods, num_states, delta,
periods_payoffs_systematic, edu_max, edu_start,
mapping_state_idx, periods_emax, states_all, is_simulated,
num_draws_emax, maxe, draws_emax)
py = get_endogenous_variable(*args)
f90 = fort_debug.wrapper_get_endogenous_variable(*args)
np.testing.assert_equal(py, replace_missing_values(f90))
# Distribute validated results for further functions.
endogenous = py
args = (endogenous, exogenous, maxe, is_simulated, num_points_interp,
num_states, is_debug)
py = get_predictions(*args)
f90 = fort_debug.wrapper_get_predictions(*args[:-1])
np.testing.assert_array_almost_equal(py, f90)
from codes.random_init import generate_init
############################################################################
# RUN
############################################################################
fname = 'test_vault_' + str(PYTHON_VERSION) + '.respy.pkl'
tests = []
for idx in range(num_tests):
print('\n Creating Test ', idx, 'with version ', PYTHON_VERSION)
constr = dict()
constr['maxfun'] = int(np.random.choice([0, 1, 2, 3, 5, 6], p=[0.5, 0.1, 0.1, 0.1, 0.1, 0.1]))
constr['flag_scaling'] = np.random.choice([True, False], p=[0.1, 0.9])
constr['flag_scaling'] = np.random.choice([True, False], p=[0.1, 0.9])
constr['is_store'] = False
init_dict = generate_init(constr)
respy_obj = RespyCls('test.respy.ini')
simulate(respy_obj)
crit_val = estimate(respy_obj)[1]
test = (init_dict, crit_val)
tests += [test]
pkl.dump(tests, open(fname, 'wb'))