def test_create_correct(self):
"""
Tests whether __init__ successfully initializes an Affine model object.
If the Affine object does not successfully instantiate, then this test
fails, otherwise it passes.
"""
model = Affine(**self.mod_kwargs)
self.assertIsInstance(model, Affine)
def setUpClass(self):
## Non-linear least squares
np.random.seed(100)
# initialize yield curve and VAR observed factors
yc_data_test = pa.DataFrame(
np.random.random((test_size - k_ar, nyields)))
var_data_test = self.var_data_test = \
pa.DataFrame(np.random.random((test_size, neqs)))
self.mats = mats = list(range(1, nyields + 1))
# initialize masked arrays
self.dim_nolat = dim = k_ar * neqs
lam_0 = make_nomask([dim, 1])
lam_1 = make_nomask([dim, dim])
delta_0 = make_nomask([1, 1])
delta_1 = make_nomask([dim, 1])
mu = make_nomask([dim, 1])
phi = make_nomask([dim, dim])
sigma = make_nomask([dim, dim])
# Setup some of the elements as non-zero
# This sets up a fake model where only lambda_0 and lambda_1 are
# estimated
lam_0[:neqs] = ma.masked
lam_1[:neqs, :neqs] = ma.masked
delta_0[:, :] = np.random.random(1)
delta_1[:neqs] = np.random.random((neqs, 1))
mu[:neqs] = np.random.random((neqs, 1))
phi[:neqs, :] = np.random.random((neqs, dim))
sigma[:, :] = np.identity(dim)
self.mod_kwargs_nolat = {
'yc_data': yc_data_test,
'var_data': var_data_test,
'k_ar': k_ar,
'neqs': neqs,
'mats': mats,
'lam_0_e': lam_0,
'lam_1_e': lam_1,
'delta_0_e': delta_0,
'delta_1_e': delta_1,
'mu_e': mu,
'phi_e': phi,
'sigma_e': sigma
}
guess_params_nolat = np.random.random((neqs**2 + neqs)).tolist()
affine_obj_nolat = Affine(**self.mod_kwargs_nolat)
self.results = affine_obj_nolat.solve(guess_params_nolat,
method='nls',
xtol=0.1,
ftol=0.1)
def setUp(self):
np.random.seed(100)
# initialize yield curve and VAR observed factors
yc_data_test = pa.DataFrame(
np.random.random((test_size - k_ar, nyields)))
var_data_test = pa.DataFrame(np.random.random((test_size, neqs)))
mats = list(range(1, nyields + 1))
# initialize masked arrays
self.dim = dim = k_ar * neqs + latent
lam_0 = make_nomask([dim, 1])
lam_1 = make_nomask([dim, dim])
delta_0 = make_nomask([1, 1])
delta_1 = make_nomask([dim, 1])
mu = make_nomask([dim, 1])
phi = make_nomask([dim, dim])
sigma = make_nomask([dim, dim])
# Setup some of the elements as non-zero
# This sets up a fake model where only lambda_0 and lambda_1 are
# estimated
lam_0[:neqs] = ma.masked
lam_0[-latent:] = ma.masked
lam_1[:neqs, :neqs] = ma.masked
lam_1[-latent:, -latent:] = ma.masked
delta_0[:, :] = np.random.random(1)
delta_1[:neqs] = np.random.random((neqs, 1))
mu[:neqs] = np.random.random((neqs, 1))
phi[:neqs, :] = np.random.random((neqs, dim))
sigma[:, :] = np.identity(dim)
self.mod_kwargs = {
'yc_data': yc_data_test,
'var_data': var_data_test,
'k_ar': k_ar,
'neqs': neqs,
'mats': mats,
'lam_0_e': lam_0,
'lam_1_e': lam_1,
'delta_0_e': delta_0,
'delta_1_e': delta_1,
'mu_e': mu,
'phi_e': phi,
'sigma_e': sigma,
'latent': latent,
'no_err': [1]
}
self.guess_params = np.random.random(
(neqs**2 + neqs + (2 * latent), )).tolist()
self.affine_obj = Affine(**self.mod_kwargs)
self.affineml_obj = AffineML(**self.mod_kwargs)
lat=0,
k_ar=k_ar,
neqs=neqs,
delta_0=delta_0_e,
delta_1=delta_1_e,
mu=mu_e,
phi=phi_e,
sigma=sigma_e)
delta_1_e[np.argmax(mod_data.columns == 'fed_funds')] = 1
print "Initial estimation"
bsr_model = Affine(yc_data=mod_yc_data,
var_data=mod_data,
lam_0_e=lam_0_e,
lam_1_e=lam_1_e,
delta_0_e=delta_0_e,
delta_1_e=delta_1_e,
mu_e=mu_e,
phi_e=phi_e,
sigma_e=sigma_e,
mths=mths)
guess_length = bsr_model.guess_length
guess_params = [0.0000] * guess_length
print source
print model
print "xtol " + str(xtol)
print "ftol " + str(ftol)
print "Begin " + str(yc_dates[0])
print "End " + str(yc_dates[-1])
print "variables " + str(list(bsr_model.names))
def robust(mod_data, mod_yc_data, method=None):
"""
Function to run model with guesses, also generating
method : string
method to pass to Affine.solve()
mod_data : pandas DataFrame
model data
mod_yc_data : pandas DataFrame
model yield curve data
"""
# subset to pre 2005
mod_data = mod_data[:217]
mod_yc_data = mod_yc_data[:214]
k_ar = 4
neqs = 5
lat = 0
lam_0_e = ma.zeros((k_ar * neqs, 1))
lam_0_e[:neqs] = ma.masked
lam_1_e = ma.zeros((k_ar * neqs, k_ar * neqs))
lam_1_e[:neqs, :neqs] = ma.masked
delta_0_e = ma.zeros([1, 1])
delta_0_e[:, :] = ma.masked
delta_0_e[:, :] = ma.nomask
delta_1_e = ma.zeros([k_ar * neqs, 1])
delta_1_e[:, :] = ma.masked
delta_1_e[:, :] = ma.nomask
delta_1_e[np.argmax(mod_data.columns == 'fed_funds')] = 1
var_fit = VAR(mod_data, freq="M").fit(maxlags=k_ar)
coefs = var_fit.params.values
sigma_u = var_fit.sigma_u
obs_var = neqs * k_ar
mu_e = ma.zeros([k_ar * neqs, 1])
mu_e[:, :] = ma.masked
mu_e[:, :] = ma.nomask
mu_e[:neqs] = coefs[0, None].T
phi_e = ma.zeros([k_ar * neqs, k_ar * neqs])
phi_e[:, :] = ma.masked
phi_e[:, :] = ma.nomask
phi_e[:neqs] = coefs[1:].T
phi_e[neqs:obs_var, :(k_ar - 1) * neqs] = np.identity((k_ar - 1) * neqs)
sigma_e = ma.zeros([k_ar * neqs, k_ar * neqs])
sigma_e[:, :] = ma.masked
sigma_e[:, :] = ma.nomask
sigma_e[:neqs, :neqs] = sigma_u
sigma_e[neqs:obs_var, neqs:obs_var] = np.identity((k_ar - 1) * neqs)
#anl_mths, mth_only_data = proc_to_mth(mod_yc_data)
bsr = Affine(yc_data=mod_yc_data,
var_data=mod_data,
lam_0_e=lam_0_e,
lam_1_e=lam_1_e,
delta_0_e=delta_0_e,
delta_1_e=delta_1_e,
mu_e=mu_e,
phi_e=phi_e,
sigma_e=sigma_e)
neqs = bsr.neqs
guess_length = bsr.guess_length
guess_params = [0.0000] * guess_length
for numb, element in enumerate(guess_params[:30]):
element = 0.0001
guess_params[numb] = element * (np.random.random() - 0.5)
out_bsr = bsr.solve(guess_params=guess_params,
method=method,
ftol=1e-950,
xtol=1e-950,
maxfev=1000000000,
full_output=False)
if method == "ls":
lam_0, lam_1, delta_1, mu, phi, sig, a_solve, b_solve, output = out_bsr
return lam_0, lam_1, output
else:
lam_0, lam_1, delta_1, mu, phi, sig, a_solve, b_solve, lam_cov = out_bsr
return lam_0, lam_1, lam_cov
#assume phi lower triangular
#phi_e[:, :] = ma.masked
phi_e.mask = np.tri(phi_e.shape[0], M=phi_e.shape[1])
sigma_e[:, :] = ma.masked
sigma_e[:, :] = ma.nomask
#sigma_e[:, :] = np.identity(latent)
sigma_e.mask = np.identity(sigma_e.shape[0])
#sigma_e[-latent:, -latent:] = ma.masked
mod_init = Affine(yc_data=mod_yc_data,
var_data=None,
latent=latent,
lam_0_e=lam_0_e,
lam_1_e=lam_1_e,
delta_0_e=delta_0_e,
delta_1_e=delta_1_e,
mu_e=mu_e,
phi_e=phi_e,
sigma_e=sigma_e,
mats=mats,
use_C_extension=False)
guess_length = mod_init.guess_length
guess_params = [0] * guess_length
np.random.seed(100)
for numb, element in enumerate(guess_params):
element = 0.001
guess_params[numb] = np.abs(element * np.random.random())
k_ar=k_ar,
neqs=neqs,
delta_0=delta_0_e,
delta_1=delta_1_e,
mu=mu_e,
phi=phi_e,
sigma=sigma_e,
rf_rate=rf_rate)
mod_init = Affine(yc_data=yc_data_use,
var_data=macro_data_use,
latent=latent,
no_err=[0, 2, 4],
lam_0_e=lam_0_e,
lam_1_e=lam_1_e,
delta_0_e=delta_0_e,
delta_1_e=delta_1_e,
mu_e=mu_e,
phi_e=phi_e,
sigma_e=sigma_e,
mats=mats,
k_ar=k_ar,
neqs=neqs)
guess_length = mod_init.guess_length
guess_params = [0.0000] * guess_length
np.random.seed(100)
for numb, element in enumerate(guess_params[:30]):
element = 0.0001
k_ar=k_ar,
neqs=neqs,
delta_0=delta_0_e,
delta_1=delta_1_e,
mu=mu_e,
phi=phi_e,
sigma=sigma_e,
rf_rate=rf_rate)
mod_init = Affine(yc_data=yc_data_use,
var_data=macro_data_use,
latent=latent,
lam_0_e=lam_0_e,
lam_1_e=lam_1_e,
delta_0_e=delta_0_e,
delta_1_e=delta_1_e,
mu_e=mu_e,
phi_e=phi_e,
sigma_e=sigma_e,
mats=mats,
k_ar=k_ar,
neqs=neqs,
use_C_extension=False)
guess_length = mod_init.guess_length
guess_params = [0.0000] * guess_length
np.random.seed(100)
for numb, element in enumerate(guess_params):
element = 0.0000000001
