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)
