def test_clean_control_specs_missing_observation_drop_observation(self): self.data.loc[2, 'c2'] = np.nan self.controls_with_missings = 'drop_observations' msp._clean_controls_specification(self) res = [['c1', 'c2'], ['c1', 'c2']] assert_equal(self.controls, res) aae(self.obs_to_keep, np.array([True, True, False, True, True]))
def test_clean_measurement_specifications_half_of_variables_missing(self): self._present = Mock(side_effect=cycle([True, False])) self._has_variance = Mock(return_value=True) res = {} res['f1'] = [['m1', 'm3']] * 2 res['f2'] = [['m5', 'm7']] * 2 msp._clean_measurement_specifications(self) assert_equal(self.measurements, res)
def test_clean_measurement_specifications_half_of_variables_missing(self): self._present = Mock(side_effect=cycle([True, False])) self._has_variance = Mock(return_value=True) res = {} res["f1"] = [["m1", "m3"]] * 2 res["f2"] = [["m5", "m7"]] * 2 ModelSpecProcessor._clean_measurement_specifications(self) assert_equal(self.measurements, res)
def test_clean_measuremnt_specifications_nothing_to_clean(self): self._present = Mock(return_value=True) self._has_variance = Mock(return_value=True) res = {} res["f1"] = self._facinf["f1"]["measurements"] res["f2"] = self._facinf["f2"]["measurements"] ModelSpecProcessor._clean_measurement_specifications(self) assert_equal(self.measurements, res)
def test_clean_measuremnt_specifications_nothing_to_clean(self): self._present = Mock(return_value=True) self._has_variance = Mock(return_value=True) res = {} res['f1'] = self._facinf['f1']['measurements'] res['f2'] = self._facinf['f2']['measurements'] msp._clean_measurement_specifications(self) assert_equal(self.measurements, res)
def test_check_or_generate_normalization_specifications(self): res = {'f1': {'loadings': [['a', 1], ['a', 1], ['a', 1]], 'intercepts': [['a', 1], ['a', 1], ['a', 1]]}, 'f2': {'loadings': [['b', 1], ['b', 1], ['b', 1]], 'intercepts': [['b', 1], ['b', 1], ['b', 1]]}} msp._check_or_generate_normalization_specification(self) print('calc', '\n\n', self.normalizations) print('exp', '\n\n', res) assert_equal(self.normalizations, res)
def test_check_and_fill_normalization_specifications(self): res = { "f1": { "loadings": [{"a": 1}, {"a": 1}, {"a": 1}], "intercepts": [{"a": 1}, {"a": 1}, {"a": 1}], "variances": [{"a": 1}, {"a": 1}, {"a": 1}], }, "f2": { "loadings": [{}, {}, {}], "intercepts": [{}, {}, {}], "variances": [{}, {}, {}], }, } ModelSpecProcessor._check_and_fill_normalization_specification(self) assert_equal(self.normalizations, res)
def test_needs_norm_translog_case_for_intercepts_free_x_zeros(self): expected = [True, True, False, False, True, False, True, True, False] self._stage_has_fixed_start_period_list = Mock( return_value=[False, True, True, False]) self._first_period_in_stage = Mock( side_effect=[False, True, False, False, True, False, True, True, True, False, True, False, False]) result = msp.needs_normalization(self, 'fac3', 'intercepts') assert_equal(result, expected)
def __init__( self, model_dict, dataset, model_name="some_model", dataset_name="some_dataset" ): specs = ModelSpecProcessor( model_dict=model_dict, dataset=dataset, model_name=model_name, dataset_name=dataset_name, ) specs_dict = specs.public_attribute_dict() data_proc = DataProcessor(specs_dict) self.data_proc = data_proc self.c_data = data_proc.c_data() self.y_data = data_proc.y_data() self.__dict__.update(specs_dict) # create a list of all quantities that depend from params vector self.params_quants = ["delta", "h", "r", "q", "p", "trans_coeffs"] if self.estimate_X_zeros is True: self.params_quants.append("x") if self.restrict_W_zeros is False: self.params_quants.append("w")
def test_has_fixed_start_period_list_loadings(self): expected = [False, True, True, False] calculated = msp._stage_has_fixed_start_period_list(self, 'loadings') assert_equal(expected, calculated)
def test_has_variance_where_false_missing(self): assert_equal(msp._has_variance(self, 'var2', 0), False)
def test_has_variance_where_true(self): assert_equal(msp._has_variance(self, 'var1', 0), True)
def test_is_dummy_where_true(self): assert_equal(msp._is_dummy(self, 'var1', 0), True)
def test_present_where_true(self): assert_equal(msp._present(self, 'var1', 0), True)
def test_wa_storage_df(self): msp._wa_storage_df(self) print('exp', self.expected_res) print('calc', self.storage_df) assert_equal(self.storage_df.to_dict(), self.expected_res.to_dict())
def test_needs_norm_log_ces_case_for_loadings(self): expected = [True, False, False, False, False, False, False, False, False] result = msp.needs_normalization(self, 'fac2', 'loadings') assert_equal(result, expected)
def test_needs_norm_ar1_case_for_intercept_fixed_x_zeros(self): self.estimate_X_zeros = False expected = [False, False, False, False, False, False, False, False, False] result = msp.needs_normalization(self, 'fac1', 'intercepts') assert_equal(result, expected)
def test_is_first_period_in_stage_false(self): assert_equal(msp._first_period_in_stage(self, 4), False)
def test_is_first_period_in_stage_true(self): assert_equal(msp._first_period_in_stage(self, 3), True)
def test_has_fixed_start_period_list_intercepts_free_x_zeros(self): expected = [False, True, True, False] calculated = msp._stage_has_fixed_start_period_list(self, 'intercepts') assert_equal(expected, calculated)
def test_has_fixed_start_period_list_intercepts_fixed_x_zeros(self): expected = [True, True, True, False] self.estimate_X_zeros = False calculated = msp._stage_has_fixed_start_period_list(self, 'intercepts') assert_equal(expected, calculated)
def setup(self): self.factors = ['f1', 'f2', 'f3'] self.periods = [0, 1, 2, 3] self.nperiods = len(self.periods) self.stagemap = [0, 0, 1, 1] self.probit_measurements = True self.estimator = 'chs' m = {} m['f1'] = [['m1', 'm2']] * 4 m['f2'] = [['m3', 'm4', 'm5']] * 4 m['f3'] = [['m5', 'm6']] * 4 self.measurements = m self.anchoring = True self.anch_outcome = 'a' self.anchored_factors = ['f1', 'f3'] n = {'f1': {}, 'f2': {}, 'f3': {}} n['f1']['loadings'] = [['m1', 2]] * 4 n['f2']['loadings'] = [['m3', 1], ['m3', 1], ['m3', 1], ['m5', 5]] n['f3']['loadings'] = [['m5', 4]] * 4 n['f1']['intercepts'] = [['m1', 0]] * 4 n['f2']['intercepts'] = [['m3', 1], ['m3', 1], ['m3', 1], ['m5', 5]] n['f3']['intercepts'] = [['m5', 4]] * 4 self.normalizations = n self._is_dummy = Mock(side_effect=cycle([False, False, True])) cols = self.factors + [ '{}_loading_norm_value'.format(f) for f in self.factors] cols += ['stage', 'purpose', 'update_type'] different_meas = ['m1', 'm2', 'm3', 'm4', 'm5', 'm6'] ind_tuples = [] for t in self.periods: ind_tuples += [(t, d) for d in different_meas] ind_tuples.append((3, 'a')) index = pd.MultiIndex.from_tuples( ind_tuples, names=['period', 'variable']) dat = np.zeros((25, len(cols))) df = DataFrame(data=dat, columns=cols, index=index) for t in self.periods: for factor in self.factors: for m in self.measurements[factor][0]: df.loc[(t, m), factor] = 1 df['has_normalized_loading'] = False for factor in self.factors: norm_col = '{}_loading_norm_value'.format(factor) for t, (n_meas, n_val) in enumerate( self.normalizations[factor]['loadings']): df.loc[(t, n_meas), norm_col] = n_val df.loc[(t, n_meas), 'has_normalized_loading'] = True df['has_normalized_intercept'] = False df['intercept_norm_value'] = np.nan for factor in self.factors: for t, (n_meas, n_val) in enumerate( self.normalizations[factor]['intercepts']): df.loc[(t, n_meas), 'intercept_norm_value'] = n_val df.loc[(t, n_meas), 'has_normalized_intercept'] = True for t in self.periods: df.loc[t, 'stage'] = self.stagemap[t] update_type = ['linear', 'linear', 'probit'] * 9 df['update_type'] = np.array(update_type[:len(df)]) df['purpose'] = np.array(['measurement'] * 24 + ['anchoring']) df.loc[(3, 'a'), ['f1', 'f3']] = 1 self.expected_res = df self.calculated_res = msp.update_info(self)
def test_transition_equation_included_factor_positions(self): msp._transition_equation_included_factors(self) assert_equal(self.included_positions, [[0, 1], [1]])
def test_needs_norm_log_ces_case_for_intercepts_fixed_x_zeros(self): expected = [False, False, False, False, False, False, False, False, False] self.estimate_X_zeros = False result = msp.needs_normalization(self, 'fac2', 'intercepts') assert_equal(result, expected)
def test_new_transition_parameters(self): res = np.array( [[-1, 1, 1, 1, 1], [-1, 0, 1, 1, 1], [-1, 0, 1, 1, 1]]) aae(msp.new_trans_coeffs(self), res)
def test_needs_norm_log_ces_case_for_intercepts_free_x_zeros(self): expected = [True, False, False, False, False, False, False, False, False] result = msp.needs_normalization(self, 'fac2', 'intercepts') assert_equal(result, expected)
def test_present_where_false_no_raise(self): assert_equal(msp._present(self, 'var1', 1), False)
def test_transition_equation_names(self): msp._transition_equation_names(self) assert_equal(self.transition_names, ['linear', 'ces', 'ar1'])
def test_is_dummy_where_false_missing(self): assert_equal(msp._is_dummy(self, 'var1', 1), False)
def test_transition_equation_included_factors(self): msp._transition_equation_included_factors(self) assert_equal(self.included_factors, [['f1', 'f2'], ['f2']])
def test_has_variance_where_false_non_missing(self): self.data.loc[1, 'var1'] = 0 assert_equal(msp._has_variance(self, 'var1', 0), False)
def test_generate_normalization_list_loadings(self): expected = [['m1', 1], ['m1', 1], [], [], ['m4', 1]] result = msp.generate_normalizations_list(self, 'f1', 'loadings') assert_equal(result, expected)
def test_generate_normalization_list_intercepts(self): expected = [['m1', 0], ['m1', 0], [], [], ['m4', 0]] result = msp.generate_normalizations_list(self, 'f1', 'intercepts') assert_equal(result, expected)
def test_check_normalizations_no_error(self): result = msp._check_normalizations_list(self, 'f1', self.f1_norm_list) assert_equal(result, self.f1_norm_list)