removes aliasing (#1075)

* removes aliasing

* restart CI

* revert a change to get codecov to pass

Author: Dpananos

pyfixest/estimation/FixestMulti_.py

@@ -285,34 +285,13 @@ def _estimate_all_models(
         -------
             None
         """
-        _is_iv = self._is_iv
-        _data = self._data
-        _method = self._method
-        _drop_singletons = self._drop_singletons
-        _ssc_dict = self._ssc_dict
-        _drop_intercept = self._drop_intercept
-        _weights = self._weights
-        _fixef_tol = self._fixef_tol
-        _fixef_maxiter = self._fixef_maxiter
-        _weights_type = self._weights_type
-        _lean = self._lean
-        _store_data = self._store_data
-        _copy_data = self._copy_data
-        _run_split = self._run_split
-        _run_full = self._run_full
-        _splitvar = self._splitvar
-        _context = self._context
-        _quantreg_method = self._quantreg_method
-        _quantreg_multi_method = self._quantreg_multi_method
-        _quantile = self._quantile
-        _quantile_tol = self._quantile_tol
-        _quantile_maxiter = self._quantile_maxiter
-
         FixestFormulaDict = self.FixestFormulaDict
         _fixef_keys = list(FixestFormulaDict.keys())
 
-        all_splits = (["all"] if _run_full else []) + (
-            _data[_splitvar].dropna().unique().tolist() if _run_split else []
+        all_splits = (["all"] if self._run_full else []) + (
+            self._data[self._splitvar].dropna().unique().tolist()
+            if self._run_split
+            else []
         )
 
         for sample_split_value in all_splits:
@@ -341,33 +320,33 @@ def _estimate_all_models(
 
                     model_kwargs = {
                         "FixestFormula": FixestFormula,
-                        "data": _data,
-                        "ssc_dict": _ssc_dict,
-                        "drop_singletons": _drop_singletons,
-                        "drop_intercept": _drop_intercept,
-                        "weights": _weights,
-                        "weights_type": _weights_type,
+                        "data": self._data,
+                        "ssc_dict": self._ssc_dict,
+                        "drop_singletons": self._drop_singletons,
+                        "drop_intercept": self._drop_intercept,
+                        "weights": self._weights,
+                        "weights_type": self._weights_type,
                         "solver": solver,
                         "collin_tol": collin_tol,
-                        "fixef_tol": _fixef_tol,
-                        "fixef_maxiter": _fixef_maxiter,
-                        "store_data": _store_data,
-                        "copy_data": _copy_data,
-                        "lean": _lean,
-                        "context": _context,
+                        "fixef_tol": self._fixef_tol,
+                        "fixef_maxiter": self._fixef_maxiter,
+                        "store_data": self._store_data,
+                        "copy_data": self._copy_data,
+                        "lean": self._lean,
+                        "context": self._context,
                         "sample_split_value": sample_split_value,
-                        "sample_split_var": _splitvar,
+                        "sample_split_var": self._splitvar,
                         "lookup_demeaned_data": lookup_demeaned_data,
                     }
 
-                    if _method in {"feols", "fepois"}:
+                    if self._method in {"feols", "fepois"}:
                         model_kwargs.update(
                             {
                                 "demeaner_backend": demeaner_backend,
                             }
                         )
 
-                    if _method in {
+                    if self._method in {
                         "fepois",
                         "feglm-logit",
                         "feglm-probit",
@@ -381,20 +360,20 @@ def _estimate_all_models(
                             }
                         )
 
-                    if _method in ["quantreg", "quantreg_multi"]:
+                    if self._method in ["quantreg", "quantreg_multi"]:
                         model_kwargs.update(
                             {
-                                "quantile": _quantile,
-                                "method": _quantreg_method,
-                                "quantile_tol": _quantile_tol,
-                                "quantile_maxiter": _quantile_maxiter,
+                                "quantile": self._quantile,
+                                "method": self._quantreg_method,
+                                "quantile_tol": self._quantile_tol,
+                                "quantile_maxiter": self._quantile_maxiter,
                                 "seed": self._seed,
                             }
                         )
-                    if _method == "quantreg_multi":
+                    if self._method == "quantreg_multi":
                         model_kwargs.update(
                             {
-                                "multi_method": _quantreg_multi_method,
+                                "multi_method": self._quantreg_multi_method,
                             }
                         )
 
@@ -410,7 +389,7 @@ def _estimate_all_models(
                         ("quantreg_multi", None): QuantregMulti,
                     }
 
-                    if _method == "compression":
+                    if self._method == "compression":
                         model_kwargs.update(
                             {
                                 "reps": self._reps,
@@ -419,7 +398,9 @@ def _estimate_all_models(
                         )
 
                     model_key = (
-                        (_method, _is_iv) if _method == "feols" else (_method, None)
+                        (self._method, self._is_iv)
+                        if self._method == "feols"
+                        else (self._method, None)
                     )
                     ModelClass = model_map[model_key]  # type: ignore
                     FIT = ModelClass(**model_kwargs)
@@ -448,7 +429,7 @@ def _estimate_all_models(
                         )  #  a little hacky, but works
 
                         FIT.get_inference()
-                        if _method == "feols" and not FIT._is_iv:
+                        if self._method == "feols" and not FIT._is_iv:
                             FIT.get_performance()
                         if isinstance(FIT, Feiv):
                             FIT.first_stage()

pyfixest/estimation/feiv_.py

@@ -240,22 +240,16 @@ def drop_multicol_vars(self) -> None:
 
     def get_fit(self) -> None:
         """Fit a IV model using a 2SLS estimator."""
-        _X = self._X
-        _Z = self._Z
-        _Y = self._Y
-
-        _solver = self._solver
-
         # Start Second Stage
-        self._tZX = _Z.T @ _X
-        self._tXZ = _X.T @ _Z
-        self._tZy = _Z.T @ _Y
-        self._tZZinv = np.linalg.inv(_Z.T @ _Z)
+        self._tZX = self._Z.T @ self._X
+        self._tXZ = self._X.T @ self._Z
+        self._tZy = self._Z.T @ self._Y
+        self._tZZinv = np.linalg.inv(self._Z.T @ self._Z)
 
         H = self._tXZ @ self._tZZinv
         A = H @ self._tZX
         B = H @ self._tZy
-        self._beta_hat = solve_ols(A, B, _solver)
+        self._beta_hat = solve_ols(A, B, self._solver)
 
         # residuals
         self._u_hat = self._Y.flatten() - (self._X @ self._beta_hat).flatten()
@@ -452,11 +446,6 @@ def IV_weakness_test(self, iv_diag_statistics: Optional[list[str]] = None) -> No
 
             # Create an identity matrix of size p_iv by p_iv
             # Pad the identity matrix with zeros to make it of size p_iv by k
-            p_iv = self._p_iv  # number of IVs
-            k = (
-                self._model_1st_stage._k
-            )  # number of estimated coefficients of 1st stage
-
             # Extract all the IV indexes and its first index
             self._iv_loc = [
                 self._coefnames_z.index(x)
@@ -470,8 +459,8 @@ def IV_weakness_test(self, iv_diag_statistics: Optional[list[str]] = None) -> No
             # H1 : H0 does not hold
 
             # Pad identity matrix to implement wald-test
-            R = np.zeros((p_iv, k))
-            R[:, self._iv_loc] = np.eye(p_iv)
+            R = np.zeros((self._p_iv, self._model_1st_stage._k))
+            R[:, self._iv_loc] = np.eye(self._p_iv)
 
             with warnings.catch_warnings():
                 warnings.simplefilter("ignore")

pyfixest/estimation/feols_compressed_.py

@@ -262,53 +262,41 @@ def vcov(
         super().vcov(vcov=vcov, vcov_kwargs=vcov_kwargs, data=data)
 
     def _vcov_iid(self):
-        _N = self._N
-        _bread = self._bread
-
         weights = self._compression_count.to_numpy()
-        Yprime = self._Yprime.to_numpy()
-        Yprimeprime = self._Yprimeprime.to_numpy()
+        yprime = self._Yprime.to_numpy()
+        yprimeprime = self._Yprimeprime.to_numpy()
         X = self._X / np.sqrt(weights)
-        beta_hat = self._beta_hat
-        yhat = (X @ beta_hat).reshape(-1, 1)
-        rss_g = (yhat**2) * weights - 2 * yhat * Yprime + Yprimeprime
-        sigma2 = np.sum(rss_g) / (_N - 1)
-
-        _vcov = _bread * sigma2
+        yhat = (X @ self._beta_hat).reshape(-1, 1)
+        rss_g = (yhat**2) * weights - 2 * yhat * yprime + yprimeprime
+        sigma2 = np.sum(rss_g) / (self._N - 1)
 
-        return _vcov
+        return self._bread * sigma2
 
     def _vcov_hetero(self):
-        _vcov_type_detail = self._vcov_type_detail
-        _bread = self._bread
-
-        if _vcov_type_detail in ["HC2", "HC3"]:
+        if self._vcov_type_detail in ["HC2", "HC3"]:
             raise NotImplementedError(
-                f"Only HC1 robust inference is supported, but {_vcov_type_detail} was specified."
+                f"Only HC1 robust inference is supported, but {self._vcov_type_detail} was specified."
             )
 
         yprime = self._Yprime.to_numpy()
         yprimeprime = self._Yprimeprime.to_numpy()
         weights = self._compression_count.to_numpy()
         X = self._X / np.sqrt(weights)
-        beta_hat = self._beta_hat
-        yhat = (X @ beta_hat).reshape(-1, 1)
+        yhat = (X @ self._beta_hat).reshape(-1, 1)
         rss_g = (yhat**2) * weights - 2 * yhat * yprime + yprimeprime
 
         _meat = (X * rss_g).T @ X
 
-        return _bread @ _meat @ _bread
+        return self._bread @ _meat @ self._bread
 
     def _vcov_crv1(self, clustid: np.ndarray, cluster_col: np.ndarray):
-        _data_long_nw = self._data_long
-
-        X_long = _data_long_nw.select(self._coefnames).to_numpy()
-        Y_long = _data_long_nw.select(self._depvar).to_numpy()
+        X_long = self._data_long.select(self._coefnames).to_numpy()
+        Y_long = self._data_long.select(self._depvar).to_numpy()
 
         yhat = X_long @ self._beta_hat
         uhat = Y_long.flatten() - yhat
 
-        _data_long_nw = _data_long_nw.with_columns(
+        data_long = self._data_long.with_columns(
             [
                 nw.lit(yhat.tolist()).alias("yhat"),
                 nw.lit(uhat.tolist()).alias("uhat"),
@@ -317,27 +305,25 @@ def _vcov_crv1(self, clustid: np.ndarray, cluster_col: np.ndarray):
             ]
         )
 
-        boot_iter = self._reps
         rng = np.random.default_rng(self._seed)
 
-        assert boot_iter is not None, "boot_iter must not be None"
+        assert self._reps is not None, "boot_iter must not be None"
         assert self._k is not None, "self._k must not be None"
-        beta_boot = np.zeros((boot_iter, self._k))
+        beta_boot = np.zeros((self._reps, self._k))
 
-        clustervar = self._clustervar
-        cluster = _data_long_nw[clustervar]
+        cluster = data_long[self._clustervar]
         cluster_ids = np.sort(np.unique(cluster).astype(np.int32))
-        _data_long_nw = _data_long_nw.with_columns(nw.col(clustervar[0]).cast(nw.Int32))
+        data_long = data_long.with_columns(nw.col(self._clustervar[0]).cast(nw.Int32))
 
-        for b in tqdm(range(boot_iter)):
+        for b in tqdm(range(self._reps)):
             boot_df = nw.from_native(
                 {
                     "coin_flip": rng.integers(0, 2, size=len(cluster_ids)),
-                    f"{clustervar[0]}": cluster_ids,
+                    f"{self._clustervar[0]}": cluster_ids,
                 }
             )
 
-            df_boot = _data_long_nw.join(boot_df, on=f"{clustervar[0]}", how="left")
+            df_boot = data_long.join(boot_df, on=f"{self._clustervar[0]}", how="left")
             df_boot = df_boot.with_columns(
                 [
                     nw.when(nw.col("coin_flip") == 1)