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 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)
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))
out_bsr = bsr_model.solve(guess_params=guess_params,
method='nls',
ftol=ftol,
xtol=xtol,
maxfev=10000000,
full_output=False)
lam_0, lam_1, delta_0, delta_1, mu, phi, sigma, a_solve, \
b_solve, solv_cov = out_bsr
a_rsk, b_rsk = bsr_model.gen_pred_coef(lam_0=lam_0,
lam_1=lam_1,
delta_0=delta_0,
delta_1=delta_1,
mu=mu,
phi=phi,
sigma=sigma)
#generate no risk results
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
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))
out_bsr = bsr_model.solve(guess_params=guess_params, method='nls',
ftol=ftol, xtol=xtol, maxfev=10000000,
full_output=False)
lam_0, lam_1, delta_0, delta_1, mu, phi, sigma, a_solve, \
b_solve, solv_cov = out_bsr
a_rsk, b_rsk = bsr_model.gen_pred_coef(lam_0=lam_0, lam_1=lam_1,
delta_0=delta_0,
delta_1=delta_1, mu=mu,
phi=phi, sigma=sigma)
#generate no risk results
lam_0_nr = np.zeros([neqs*k_ar, 1])
lam_1_nr = np.zeros([neqs*k_ar, neqs*k_ar])
sigma_zeros = np.zeros_like(sigma)
a_nrsk, b_nrsk = bsr_model.gen_pred_coef(lam_0=lam_0_nr,
class TestEstimationMethods(TestCase):
"""
Tests for solution methods
"""
def setUp(self):
## Non-linear least squares
np.random.seed(101)
# 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_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
}
self.guess_params_nolat = np.random.random((neqs**2 + neqs)).tolist()
self.affine_obj_nolat = Affine(**self.mod_kwargs_nolat)
## Maximum likelihood build
# initialize masked arrays
self.dim_lat = 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_lat = np.random.random((neqs**2 + neqs +
(2 * latent),)).tolist()
self.affine_obj_lat = Affine(**self.mod_kwargs)
def test_solve_nls(self):
"""
Tests whether or not basic estimation is performed for non-linear least
squares case without any latent factors. If the numerical approximation
method converges, this test passes. Otherwise, the test fails.
"""
guess_params = self.guess_params_nolat
method = 'nls'
self.affine_obj_nolat.solve(guess_params, method=method, alg='newton',
xtol=0.1, ftol=0.1)
def test_solve_ml(self):
"""
Tests whether or not model estimation converges is performed for direct
maximum likelihood with a single latent factor. If the numerical
approximation method converges, this test passes. Otherwise, the test
fails.
"""
guess_params = self.guess_params_lat
method = 'ml'
self.affine_obj_lat.solve(guess_params, method=method, alg='bfgs',
xtol=0.1, ftol=0.1)
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())
bsr_solve = mod_init.solve(guess_params=guess_params,
method="kalman",
alg="bfgs",
maxfev=10000000,
maxiter=10000000,
ftol=0.1,
xtol=0.1)
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
guess_params[numb] = np.abs(element * np.random.random())
bsr_solve = mod_init.solve(guess_params=guess_params, method="kalman", alg="bfgs", maxfev=10000000, maxiter=10000000)
class TestEstimationMethods(TestCase):
"""
Tests for solution methods
"""
def setUp(self):
## Non-linear least squares
np.random.seed(101)
# 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_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
}
self.guess_params_nolat = np.random.random((neqs**2 + neqs)).tolist()
self.affine_obj_nolat = Affine(**self.mod_kwargs_nolat)
## Maximum likelihood build
# initialize masked arrays
self.dim_lat = 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_lat = np.random.random(
(neqs**2 + neqs + (2 * latent), )).tolist()
self.affine_obj_lat = Affine(**self.mod_kwargs)
def test_solve_nls(self):
"""
Tests whether or not basic estimation is performed for non-linear least
squares case without any latent factors. If the numerical approximation
method converges, this test passes. Otherwise, the test fails.
"""
guess_params = self.guess_params_nolat
method = 'nls'
self.affine_obj_nolat.solve(guess_params,
method=method,
alg='newton',
xtol=0.1,
ftol=0.1)
def test_solve_ml(self):
"""
Tests whether or not model estimation converges is performed for direct
maximum likelihood with a single latent factor. If the numerical
approximation method converges, this test passes. Otherwise, the test
fails.
"""
guess_params = self.guess_params_lat
method = 'ml'
self.affine_obj_lat.solve(guess_params,
method=method,
alg='bfgs',
xtol=0.1,
ftol=0.1)
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
