示例#1
0
    def cov(self):
        """Estimated covariance"""
        x = self._x
        nobs = x.shape[0]
        xpxi = inv(x.T @ x / nobs)

        eps = self.eps
        xe = x * eps
        if self._clusters.ndim == 1:
            xeex = _cov_cluster(xe, self._clusters)
            if self._group_debias:
                xeex *= self._calc_group_debias(self._clusters)

        else:
            clusters0 = self._clusters[:, 0]
            clusters1 = self._clusters[:, 1]
            xeex0 = _cov_cluster(xe, clusters0)
            xeex1 = _cov_cluster(xe, clusters1)

            sort_keys = np.lexsort(self._clusters.T)
            locs = np.arange(self._clusters.shape[0])
            lex_sorted = self._clusters[sort_keys]
            sorted_locs = locs[sort_keys]
            diff = np.any(lex_sorted[1:] != lex_sorted[:-1], 1)
            clusters01 = np.cumsum(np.r_[0, diff])
            resort_locs = np.argsort(sorted_locs)
            clusters01 = clusters01[resort_locs]
            xeex01 = _cov_cluster(xe, clusters01)

            if self._group_debias:
                xeex0 *= self._calc_group_debias(clusters0)
                xeex1 *= self._calc_group_debias(clusters1)
                xeex01 *= self._calc_group_debias(clusters01)

            xeex = xeex0 + xeex1 - xeex01

        xeex *= self._scale
        out = (xpxi @ xeex @ xpxi) / nobs
        return (out + out.T) / 2
示例#2
0
    def weight_matrix(self, x: NDArray, z: NDArray, eps: NDArray) -> NDArray:
        """
        Parameters
        ----------
        x : ndarray
            Model regressors (exog and endog), (nobs by nvar)
        z : ndarray
            Model instruments (exog and instruments), (nobs by ninstr)
        eps : ndarray
            Model errors (nobs by 1)

        Returns
        -------
        ndarray
            Covariance of GMM moment conditions.
        """
        nobs, nvar = x.shape

        ze = z * eps
        mu = ze.mean(axis=0) if self._center else 0
        ze -= mu

        clusters = self._clusters
        if clusters.shape[0] != nobs:
            raise ValueError("clusters has the wrong nobs. Expected {0}, "
                             "got {1}".format(nobs, clusters.shape[0]))
        clusters = asarray(clusters).copy().squeeze()

        s = _cov_cluster(ze, clusters)

        if self._debiased:
            num_clusters = len(unique(clusters))
            scale = (nobs - 1) / (nobs - nvar) * num_clusters / (num_clusters -
                                                                 1)
            s *= scale

        return s