SearchLibrium 0.0.236__tar.gz → 0.0.239__tar.gz

{searchlibrium-0.0.236/src/SearchLibrium.egg-info → searchlibrium-0.0.239}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SearchLibrium
-Version: 0.0.236
+Version: 0.0.239
 Summary: Automated specification search for discrete choice models (logit, mixed logit, nested logit, RRM and more) using metaheuristic optimisation
 Author: Mario Fernando Taco Morales, Alexander Paz, Prithvi Beeramole, Robert Burdett
 Author-email: Zeke Ahern <z.ahern@qut.edu.au>

{searchlibrium-0.0.236 → searchlibrium-0.0.239}/pyproject.toml

@@ -129,7 +129,7 @@ Documentation = "https://pypi.org/project/SearchLibrium/"
 realpython = "SearchLibrium.__main__:main"
 
 [tool.bumpver]
-current_version = "0.0.236"
+current_version = "0.0.239"
 version_pattern = "MAJOR.MINOR.PATCH"
 commit_message = "[skip ci] Bump version {old_version} -> {new_version}"
 commit = true

{searchlibrium-0.0.236 → searchlibrium-0.0.239}/src/SearchLibrium/MixedLogit.py

@@ -171,7 +171,7 @@ class MixedLogit(DiscreteChoiceModel):
               save_fitted_params=True, mnl_init=True,
               de_init=False, de_popsize=4, de_maxiter=3, de_tol=0.5,
               de_polish=False, l1_penalty=0.0, reg_penalty=0.001, sd_penalty=0.0,
-              engine=None):
+              engine=None, asc_share_init=True):
         # {
         self.fit_intercept = fit_intercept
         # L2 ridge regularisation strength (default ON). Keeps the Hessian
@@ -182,6 +182,11 @@ class MixedLogit(DiscreteChoiceModel):
         # Extra L2 penalty applied specifically to the random-coefficient standard
         # deviations (Br_w). Shrinks weakly-identified / runaway SDs toward zero.
         self.sd_penalty = float(sd_penalty)
+        # Seed alternative-specific constants from observed shares
+        # (alpha_j = log(s_j / s_base); detected as exact alternative
+        # dummies, no naming convention needed). Disable with
+        # asc_share_init=False.
+        self.asc_share_init = bool(asc_share_init)
         # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
         # RECAST AS NUMPY NDARRAY
         # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -613,11 +618,98 @@ class MixedLogit(DiscreteChoiceModel):
     ''' Function.  Fit Mixed Logit model                           '''
     ''' ---------------------------------------------------------- '''
 
+    def _seed_asc_from_shares(self, betas):
+        """Overwrite ASC fixed/random-mean starts with log-share ratios.
+
+        For alternative dummies the plain-logit MLE is closed form:
+        ``alpha_j = log(s_j / s_base)`` (the BLP-contraction starting
+        point; exact for intercepts-only, excellent with covariates).
+        ASC columns are detected from the design (columns exactly
+        indicating one alternative), so no naming convention is needed.
+        Positions without positive shares on both sides keep their
+        incoming value. Returns ``(betas, n_seeded)``; never raises.
+        """
+        try:
+            import numpy as _np
+            betas = _np.asarray(betas, dtype=float).copy()
+            Kf, Kr = int(self.Kf), int(self.Kr)
+            if Kf + Kr <= 0:
+                return betas, 0
+            X = _np.asarray(self.X, dtype=float)
+            if X.ndim != 4:
+                return betas, 0
+            N, P, J = X.shape[0], X.shape[1], X.shape[2]
+            if J < 2:
+                return betas, 0
+            # observed shares over valid choice situations
+            y = _np.asarray(self.y)
+            if y.ndim == 4:
+                y = y[..., 0]
+            if y.ndim == 3 and y.shape == (N, P, J):
+                _flat = y.reshape(N * P, J)
+                cnt = _flat.sum(axis=0)
+                den = float((_flat.sum(axis=1) > 0).sum())
+            elif y.ndim <= 2:
+                idx = y.astype(int).ravel()
+                idx = idx[(idx >= 0) & (idx < J)]
+                if idx.size == 0:
+                    return betas, 0
+                cnt = _np.bincount(idx, minlength=J).astype(float)
+                den = float(idx.size)
+            else:
+                return betas, 0
+            if not den > 0:
+                return betas, 0
+            shares = cnt / den
+            try:
+                base = int(self.base_alt)
+            except Exception:
+                base = 0
+            if not (0 <= base < J) or not shares[base] > 0:
+                return betas, 0
+            try:
+                fx = _np.where(_np.asarray(self.fxidx, dtype=bool))[0]
+                rv = _np.where(_np.asarray(self.rvidx, dtype=bool))[0]
+            except Exception:
+                return betas, 0
+            if len(fx) < Kf or len(rv) < Kr:
+                return betas, 0
+            alt1 = _np.arange(J)
+            n_seed = 0
+            for f in range(Kf):  # fixed means <-> design column fx[f]
+                col = X[:, :, :, int(fx[f])]
+                for j in range(J):
+                    if bool((col == (alt1 == j)).all()):
+                        if shares[j] > 0:
+                            betas[f] = float(_np.log(shares[j] / shares[base]))
+                            n_seed += 1
+                        break
+            for k in range(Kr):  # random means <-> design column rv[k]
+                col = X[:, :, :, int(rv[k])]
+                for j in range(J):
+                    if bool((col == (alt1 == j)).all()):
+                        if shares[j] > 0:
+                            betas[Kf + k] = float(
+                                _np.log(shares[j] / shares[base]))
+                            n_seed += 1
+                        break
+            return betas, n_seed
+        except Exception:
+            try:
+                import numpy as _np
+                return _np.asarray(betas, dtype=float), 0
+            except Exception:
+                return betas, 0
+
     def fit(self):
         # {
         # Generate draws:
         draws, drawstrans = self.generate_draws(self.N, self.n_draws, self.halton)
         self.draws, self.drawstrans = draws, drawstrans  # Record generated values
+        # Explicit caller-supplied starts are respected verbatim (no ASC
+        # share seeding); the MNL block below may still overwrite
+        # self.init_coeff when it runs.
+        _explicit_init = self.init_coeff is not None
 
         # Optional numba engine (first-class; the T4 minimise_func patch is
         # the equivalent for older installs). Resolved here so the JAX fast
@@ -692,6 +784,18 @@ class MixedLogit(DiscreteChoiceModel):
             self.init_coeff = None
             betas = np.repeat(0.1, n_coeff)
 
+        # Log-share seeding for alternative-specific constants detected as
+        # exact alternative dummies: alpha_j = log(s_j / s_base). Cheap
+        # closed form; skipped for explicitly user-supplied starts.
+        if getattr(self, 'asc_share_init', True) and not _explicit_init:
+            try:
+                betas, _n_asc = self._seed_asc_from_shares(betas)
+                if _n_asc and not _SL_QUIET:
+                    print(f"[MXL] ASC share-init seeded {_n_asc} constants "
+                          f"(log-share ratios).")
+            except Exception:
+                pass
+
         positive_bound = (0, infinity)
         any_bound = (-infinity, infinity)
         lmda_bound = (-5, 1)

{searchlibrium-0.0.236 → searchlibrium-0.0.239}/src/SearchLibrium/_choice_model.py

@@ -495,6 +495,59 @@ class DiscreteChoiceModel(ABC):
 
     # }
 
+    def cov_params(self, robust=False):
+        """Parameter covariance matrix aligned to ``coeff_names``.
+
+        Mediation/path analysis (e.g. SEM-style direct + indirect effects)
+        needs off-diagonal covariances, not just standard errors.  Returns a
+        ``pandas.DataFrame`` (p x p) with ``coeff_names`` as index/columns.
+
+        Parameters
+        ----------
+        robust : bool, default False
+            If True, prefer the sandwich ``robust_varcov`` when present and
+            shape-consistent; otherwise fall back to the inverse Hessian.
+
+        Notes
+        -----
+        Uses ``self.robust_varcov`` (if ``robust=True``) else ``self.Hinv``.
+        Both are stored by ``fit()``/``post_process()``.  Raises ValueError
+        when no p x p finite covariance is available (e.g. the model was fit
+        with ``return_hess=False``).
+        """
+        import numpy as _np
+        import pandas as _pd
+        est = _np.asarray(getattr(self, 'coeff_est', []), dtype=float).ravel()
+        p = int(est.size)
+        if p == 0:
+            raise ValueError("cov_params: model has no estimated coefficients "
+                             "(was fit() called?)")
+        _V = None
+        if robust:
+            _V = getattr(self, 'robust_varcov', None)
+        if _V is None:
+            _V = getattr(self, 'Hinv', None)
+        if _V is None:
+            raise ValueError("cov_params: no covariance available "
+                             "(missing Hinv/robust_varcov — refit with "
+                             "return_hess=True)")
+        try:
+            _V = _np.asarray(_V, dtype=float)
+        except Exception as _e:
+            raise ValueError(f"cov_params: stored covariance not array-like "
+                             f"({_e!r})")
+        if _V.shape != (p, p) or not _np.all(_np.isfinite(_V)):
+            raise ValueError(f"cov_params: stored covariance has shape "
+                             f"{tuple(_V.shape)}, expected ({p}, {p}) with "
+                             f"finite entries")
+        _raw_names = getattr(self, 'coeff_names', None)
+        _names = (list(_raw_names) if _raw_names is not None else [])
+        if len(_names) != p:
+            _names = [str(_n) for _n in _names[:p]]
+            _names += [f"param_{i}" for i in range(len(_names), p)]
+        _V = (_V + _V.T) / 2.0  # enforce symmetry against float noise
+        return _pd.DataFrame(_V, index=_names, columns=_names)
+
     def num_of_exceeding_pvalues(self, pvalues, threshold):
         """
         :param pvalues: array of pvalues

{searchlibrium-0.0.236 → searchlibrium-0.0.239}/src/SearchLibrium/ordered_logit.py

@@ -212,7 +212,7 @@ class OrderedLogit():
         self.J = kwargs.get('J')    # Number of ordinal categories => categories = {0, 1, ..., J-1}
 
 
-        self.fit_intercept = kwargs.get('fit_intercept')
+        self.fit_intercept = kwargs.get('fit_intercept', False)
         self.nparams = self.K + self.J -1 +int(self.fit_intercept)  # i.e., intercept + self.K + self.J - 1
 
         self.params = kwargs.get('start')
@@ -244,7 +244,7 @@ class OrderedLogit():
         else:
             self.distr = distr
 
-        self.fit_intercept = kwargs.get('fit_intercept')   # Add intercept
+        self.fit_intercept = kwargs.get('fit_intercept', False)   # Add intercept
         self.define_labels()
     # }
 
@@ -282,7 +282,10 @@ class OrderedLogit():
     # {
         #y_latent = X.dot(beta[1:])  # Compute dot product, i.e., X.beta
         if(self.fit_intercept):
-            y_latent = beta[0] # Add beta[0] to each y_latent value, i.e. y_latent[n] += beta_0 for n=1,...,N
+            # params layout is [intercept, K slopes, ...]: broadcast the
+            # intercept across cases (a bare beta[0] scalar here silently
+            # dropped every slope and broke all downstream shapes).
+            y_latent = beta[0] + X.dot(beta[1:1 + self.K])
         else:
             y_latent=X.dot(beta)
         return y_latent
@@ -559,6 +562,12 @@ class OrderedLogit():
     # {
         hessian = self.get_hessian(tol)
         inverse = self.np.linalg.pinv(hessian) # Conventional approach
+        # Keep the full covariance for path/mediation analysis (delta-method
+        # SEs of indirect effects need off-diagonal terms, not just stderr).
+        try:
+            self.varcov = np.asarray(inverse, dtype=float)
+        except Exception:
+            self.varcov = None
         diag = self.np.diagonal(inverse)
         # jax arrays (self.np when _jax=True) don't support boolean-mask
         # in-place assignment; clip() returns a new array either way.
@@ -573,6 +582,39 @@ class OrderedLogit():
         self.stderr = self.np.sqrt(diag_copy)
     # }
 
+    def cov_params(self, robust=False):
+        """Parameter covariance matrix aligned to ``labels``.
+
+        Mirrors ``DiscreteChoiceModel.cov_params`` (see _choice_model.py) so
+        mediation/path analysis can use off-diagonal terms.  Ordered logit
+        has no sandwich variant, so ``robust`` is accepted and ignored.
+        """
+        import pandas as _pd
+        _est = np.asarray(getattr(self, 'params', []), dtype=float).ravel()
+        _p = int(_est.size)
+        if _p == 0:
+            raise ValueError("cov_params: model has no estimated parameters "
+                             "(was fit() called?)")
+        _V = getattr(self, 'varcov', None)
+        if _V is None:
+            raise ValueError("cov_params: no covariance available "
+                             "(missing varcov — refit so compute_stderr runs)")
+        try:
+            _V = np.asarray(_V, dtype=float)
+        except Exception as _e:
+            raise ValueError(f"cov_params: stored covariance not array-like "
+                             f"({_e!r})")
+        if _V.shape != (_p, _p) or not np.all(np.isfinite(_V)):
+            raise ValueError(f"cov_params: stored covariance has shape "
+                             f"{tuple(_V.shape)}, expected ({_p}, {_p}) with "
+                             f"finite entries")
+        _names = list(getattr(self, 'labels', []) or [])
+        if len(_names) != _p:
+            _names = [str(_n) for _n in _names[:_p]]
+            _names += [f"param_{i}" for i in range(len(_names), _p)]
+        _V = (_V + _V.T) / 2.0
+        return _pd.DataFrame(_V, index=_names, columns=_names)
+
     ''' ---------------------------------------------------------- '''
     ''' Function.                                                  '''
     ''' ---------------------------------------------------------- '''

searchlibrium-0.0.239/src/SearchLibrium/version.txt

@@ -0,0 +1 @@
+0.0.239

{searchlibrium-0.0.236 → searchlibrium-0.0.239/src/SearchLibrium.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SearchLibrium
-Version: 0.0.236
+Version: 0.0.239
 Summary: Automated specification search for discrete choice models (logit, mixed logit, nested logit, RRM and more) using metaheuristic optimisation
 Author: Mario Fernando Taco Morales, Alexander Paz, Prithvi Beeramole, Robert Burdett
 Author-email: Zeke Ahern <z.ahern@qut.edu.au>

searchlibrium-0.0.236/src/SearchLibrium/version.txt

@@ -1 +0,0 @@
-0.0.236