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_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_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_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_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_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'))