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_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 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 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_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_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_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_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_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 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_5(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)
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)
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)