def test_kernel_errors(data):
with pytest.raises(ValueError):
KernelWeight(data.moments, kernel="unknown")
with pytest.raises(ValueError):
KernelWeight(data.moments, bandwidth=-0.5)
with pytest.raises(ValueError):
KernelCovariance(data.moments, jacobian=data.jacobian, kernel="unknown")
with pytest.raises(ValueError):
KernelCovariance(data.moments, jacobian=data.jacobian, bandwidth=-4)
def test_center(data):
kw = KernelWeight(data.moments, center=True)
kw2 = KernelWeight(data.moments, center=False)
assert kw.bandwidth == kw2.bandwidth
assert np.any(kw.w(data.moments) != kw2.w(data.moments))
hw = HeteroskedasticWeight(data.moments, center=True)
hw2 = HeteroskedasticWeight(data.moments, center=False)
assert np.any(hw.w(data.moments) != hw2.w(data.moments))
def fit(
self,
center: bool = True,
use_cue: bool = False,
steps: int = 2,
disp: int = 10,
max_iter: int = 1000,
cov_type: str = "robust",
debiased: bool = True,
**cov_config: Union[bool, int, str],
) -> GMMFactorModelResults:
"""
Estimate model parameters
Parameters
----------
center : bool, optional
Flag indicating to center the moment conditions before computing
the weighting matrix.
use_cue : bool, optional
Flag indicating to use continuously updating estimator
steps : int, optional
Number of steps to use when estimating parameters. 2 corresponds
to the standard efficient GMM estimator. Higher values will
iterate until convergence or up to the number of steps given
disp : int, optional
Number of iterations between printed update. 0 or negative values
suppresses output
max_iter : int, positive, optional
Maximum number of iterations when minimizing objective
cov_type : str, optional
Name of covariance estimator
debiased : bool, optional
Flag indicating whether to debias the covariance estimator using
a degree of freedom adjustment
**cov_config
Additional covariance-specific options. See Notes.
Returns
-------
GMMFactorModelResults
Results class with parameter estimates, covariance and test statistics
Notes
-----
The kernel covariance estimator takes the optional arguments
``kernel``, one of 'bartlett', 'parzen' or 'qs' (quadratic spectral)
and ``bandwidth`` (a positive integer).
"""
nobs, n = self.portfolios.shape
k = self.factors.shape[1]
excess_returns = not self._risk_free
nrf = int(not bool(excess_returns))
# 1. Starting Values - use 2 pass
mod = LinearFactorModel(self.portfolios,
self.factors,
risk_free=self._risk_free)
res = mod.fit()
betas = np.asarray(res.betas).ravel()
lam = np.asarray(res.risk_premia)
mu = self.factors.ndarray.mean(0)
sv = np.r_[betas, lam, mu][:, None]
g = self._moments(sv, excess_returns)
g -= g.mean(0)[None, :] if center else 0
kernel: Optional[str] = None
bandwidth: Optional[float] = None
if cov_type not in ("robust", "heteroskedastic", "kernel"):
raise ValueError("Unknown weight: {0}".format(cov_type))
if cov_type in ("robust", "heteroskedastic"):
weight_est_instance = HeteroskedasticWeight(g, center=center)
cov_est = HeteroskedasticCovariance
else: # 'kernel':
kernel = get_string(cov_config, "kernel")
bandwidth = get_float(cov_config, "bandwidth")
weight_est_instance = KernelWeight(g,
center=center,
kernel=kernel,
bandwidth=bandwidth)
cov_est = KernelCovariance
w = weight_est_instance.w(g)
args = (excess_returns, w)
# 2. Step 1 using w = inv(s) from SV
callback = callback_factory(self._j, args, disp=disp)
opt_res = minimize(
self._j,
sv,
args=args,
callback=callback,
options={
"disp": bool(disp),
"maxiter": max_iter
},
)
params = opt_res.x
last_obj = opt_res.fun
iters = 1
# 3. Step 2 using step 1 estimates
if not use_cue:
while iters < steps:
iters += 1
g = self._moments(params, excess_returns)
w = weight_est_instance.w(g)
args = (excess_returns, w)
# 2. Step 1 using w = inv(s) from SV
callback = callback_factory(self._j, args, disp=disp)
opt_res = minimize(
self._j,
params,
args=args,
callback=callback,
options={
"disp": bool(disp),
"maxiter": max_iter
},
)
params = opt_res.x
obj = opt_res.fun
if np.abs(obj - last_obj) < 1e-6:
break
last_obj = obj
else:
cue_args = (excess_returns, weight_est_instance)
callback = callback_factory(self._j_cue, cue_args, disp=disp)
opt_res = minimize(
self._j_cue,
params,
args=cue_args,
callback=callback,
options={
"disp": bool(disp),
"maxiter": max_iter
},
)
params = opt_res.x
# 4. Compute final S and G for inference
g = self._moments(params, excess_returns)
s = g.T @ g / nobs
jac = self._jacobian(params, excess_returns)
if cov_est is HeteroskedasticCovariance:
cov_est_inst = HeteroskedasticCovariance(
g,
jacobian=jac,
center=center,
debiased=debiased,
df=self.factors.shape[1],
)
else:
cov_est_inst = KernelCovariance(
g,
jacobian=jac,
center=center,
debiased=debiased,
df=self.factors.shape[1],
kernel=kernel,
bandwidth=bandwidth,
)
full_vcv = cov_est_inst.cov
sel = slice((n * k), (n * k + k + nrf))
rp = params[sel]
rp_cov = full_vcv[sel, sel]
sel = slice(0, (n * (k + 1)), (k + 1))
alphas = g.mean(0)[sel, None]
alpha_vcv = s[sel, sel] / nobs
stat = self._j(params, excess_returns, w)
jstat = WaldTestStatistic(stat,
"All alphas are 0",
n - k - nrf,
name="J-statistic")
# R2 calculation
betas = np.reshape(params[:(n * k)], (n, k))
resids = self.portfolios.ndarray - self.factors.ndarray @ betas.T
resids -= resids.mean(0)[None, :]
residual_ss = (resids**2).sum()
total = self.portfolios.ndarray
total = total - total.mean(0)[None, :]
total_ss = (total**2).sum()
r2 = 1.0 - residual_ss / total_ss
param_names = []
for portfolio in self.portfolios.cols:
for factor in self.factors.cols:
param_names.append("beta-{0}-{1}".format(portfolio, factor))
if not excess_returns:
param_names.append("lambda-risk_free")
param_names.extend(["lambda-{0}".format(f) for f in self.factors.cols])
param_names.extend(["mu-{0}".format(f) for f in self.factors.cols])
rp_names = list(self.factors.cols)[:]
if not excess_returns:
rp_names.insert(0, "risk_free")
params = np.c_[alphas, betas]
# 5. Return values
res_dict = AttrDict(
params=params,
cov=full_vcv,
betas=betas,
rp=rp,
rp_cov=rp_cov,
alphas=alphas,
alpha_vcv=alpha_vcv,
jstat=jstat,
rsquared=r2,
total_ss=total_ss,
residual_ss=residual_ss,
param_names=param_names,
portfolio_names=self.portfolios.cols,
factor_names=self.factors.cols,
name=self._name,
cov_type=cov_type,
model=self,
nobs=nobs,
rp_names=rp_names,
iter=iters,
cov_est=cov_est_inst,
)
return GMMFactorModelResults(res_dict)