SearchLibrium 0.0.138__tar.gz → 0.0.140__tar.gz

{searchlibrium-0.0.138 → searchlibrium-0.0.140}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SearchLibrium
-Version: 0.0.138
+Version: 0.0.140
 Summary: A Python package for econometric models driven by search
 Author: Mario Fernando Taco Morales, Alexander Paz, Prithvi Beeramole, Robert Burdett
 Author-email: Zeke Ahern <z.ahern@qut.edu.au>

{searchlibrium-0.0.138 → searchlibrium-0.0.140}/pyproject.toml

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

{searchlibrium-0.0.138 → searchlibrium-0.0.140}/src/SearchLibrium/MixedLogit.py

@@ -134,13 +134,14 @@ class MixedLogit(DiscreteChoiceModel):
     def setup(self, X, y, varnames=None, alts=None, isvars=None, transvars=None,
               transformation="boxcox", ids=None, weights=None, avail=None,
               randvars=None, panels=None, base_alt=None, fit_intercept=False,
-              init_coeff=None, maxiter=1000, correlated_vars=None,
+              init_coeff=None, maxiter=2000, correlated_vars=None,
               n_draws=1000, halton=True, minimise_func=None,
-              batch_size=None, halton_opts=None, ftol=1e-12,
+              batch_size=None, halton_opts=None, ftol=1e-6,
               gtol=1e-6, return_hess=True, return_grad=True, method="slsqp",
               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):
+              de_polish=False, l1_penalty=0.1, l2_penalty=0.5,
+              sd_penalty=0.001):
         # {
         self.fit_intercept = fit_intercept
         # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -186,6 +187,8 @@ class MixedLogit(DiscreteChoiceModel):
         self.total_fun_eval = 0
         self.method = method.lower() if hasattr(method, 'lower') else method
         self.l1_penalty = float(l1_penalty)
+        self.l2_penalty = float(l2_penalty)
+        self.sd_penalty = float(sd_penalty)
         self.jac = self.return_grad  # scipy optimize parameter
         self.n_draws = n_draws
         self.batch_size = min(n_draws, batch_size) if batch_size is not None else n_draws
@@ -586,11 +589,64 @@ class MixedLogit(DiscreteChoiceModel):
         args = (self.X, self.y, self.panel_info, draws, drawstrans, self.weights, self.avail, self.batch_size)
         bounds = bnds if self.method == "L-BFGS-B" else None
         options = {'gtol': self.gtol, 'maxiter': self.maxiter, 'disp': False}
-        result = minimise_func(self.get_loglik_gradient, betas, jac=self.jac, method=self.method,
+
+        # ── SD penalty wrapper: regularise SD params away from exactly zero ──
+        # When an SD parameter hits zero, the gradient vanishes and BFGS gets stuck.
+        # A small L2 penalty that activates below a threshold keeps SDs bounded
+        # away from zero without affecting the well-identified estimates.
+        if self.sd_penalty > 0 and self.Kbw > 0:
+            # SD param indices: end of beta vector, before Kftrans and Krtrans
+            sd_start = self.Kf + self.Kr + self.Kchol
+            sd_end   = sd_start + self.Kbw
+            _orig_obj = self.get_loglik_gradient
+
+            def _penalised_obj(betas, *obj_args):
+                f, g = _orig_obj(betas, *obj_args)
+                for i in range(sd_start, sd_end):
+                    if i >= len(betas):
+                        break
+                    sd_val = betas[i]
+                    if sd_val < 0.05:
+                        p = self.sd_penalty * (sd_val - 0.05) ** 2
+                        f += p
+                        if g is not None and len(g) > i:
+                            g[i] += 2.0 * self.sd_penalty * (sd_val - 0.05)
+                return f, g
+
+            obj_fn = _penalised_obj
+        else:
+            obj_fn = self.get_loglik_gradient
+
+        result = minimise_func(obj_fn, betas, jac=self.jac, method=self.method,
                                args=args, tol=self.ftol, bounds=bounds, options=options)
-        print(f"[MXL] Minimization completed: success={result.get('success', None)}, fun={result.get('fun', float('nan')):.6g}, nit={result.get('nit', '?')}")
+        print(f"[MXL] Primary minimization ({self.method}): success={result.get('success', None)}, fun={result.get('fun', float('nan')):.6g}, nit={result.get('nit', '?')}")
         if 'x' in result:
-            print(f"[MXL] Minimization final betas first_values={np.asarray(result['x'])[:min(8, len(result['x']))]!r}")
+            print(f"[MXL] Primary betas first_values={np.asarray(result['x'])[:min(8, len(result['x']))]!r}")
+
+        # ── BFGS polish: after non-BFGS methods (SLSQP, Powell, etc.),
+        # run a quick BFGS to get the inverse Hessian for standard errors.
+        if (self.method not in ('bfgs', 'l-bfgs-b')
+                and 'x' in result
+                and result.get('success', False)):
+            try:
+                polish_opts = {'gtol': self.gtol * 10, 'maxiter': min(self.maxiter // 5, 200), 'disp': False}
+                polish_bnds = bnds  # re-use same bounds
+                # Use original objective (no SD penalty) for clean Hessian
+                polish_result = minimise_func(
+                    self.get_loglik_gradient,
+                    np.asarray(result['x']).copy(),
+                    jac=True, method='L-BFGS-B',
+                    args=args, tol=self.ftol,
+                    bounds=polish_bnds, options=polish_opts,
+                )
+                if polish_result.get('fun', float('inf')) < result.get('fun', float('inf')) + 0.1:
+                    print(f"[MXL] BFGS polish: success={polish_result.get('success')}, "
+                          f"fun={polish_result.get('fun', float('nan')):.6g}")
+                    result = polish_result
+                else:
+                    print(f"[MXL] BFGS polish skipped (worse objective)")
+            except Exception as e:
+                print(f"[MXL] BFGS polish failed: {e}")
         # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
         if hasattr(self, 'method') and self.method == "L-BFGS-B":  # {

{searchlibrium-0.0.138 → searchlibrium-0.0.140}/src/SearchLibrium/_choice_model.py

@@ -147,7 +147,7 @@ class DiscreteChoiceModel(ABC):
         self.reset_attributes()
         self.fit_intercept = False
         self.reg_penalty = 0.00  # L2 penalty strength (ridge)
-        self.l1_penalty  = 0.00  # L1 penalty strength (lasso)
+        self.l1_penalty  = 0.1   # L1 penalty strength (lasso)
         self.pval_penalty = 5
         logging.info(f'pval penalty set to {self.pval_penalty}')
         # NOTE: The reg_penalty value is tricky to define. If too high, convergence is restricted.
@@ -167,7 +167,7 @@ class DiscreteChoiceModel(ABC):
         self.converged = False
         self.return_grad, self.return_hess, self.fit_intercept = True, True, False
         self.scipy_optimisation = True
-        self.method, self.transformation = "bfgs", "boxcox"
+        self.method, self.transformation = "slsqp", "boxcox"
 
         self.trans_func = None      # NEW. CHECK VALIDITY!
         self.varnames, self.isvars, self.transvars = None, None, None

{searchlibrium-0.0.138 → searchlibrium-0.0.140}/src/SearchLibrium/latent_class.py

@@ -57,6 +57,10 @@ class LatentClassMixedLogit:
         self.descr = "LC-MXL"
         self.coeff_est = None
         self.coeff_names = None
+        self.stderr = None
+        self.zvalues = None
+        self.pvalues = None
+        self.pvalues_member = None
         self.class_betas = None
         self.class_probs = None
         self.class_gammas = None
@@ -1454,16 +1458,24 @@ class LatentClassMixedLogit:
             params = np.concatenate([phi_vals, beta_flat])
             n_gamma = 0
 
-        # ── JAX autograd Hessian → covariance (strict: no numerical fallback) ──
+        # ── JAX autograd Hessian → covariance (numerical fallback) ──
         H_a = self._autograd_hessian(params)
-        if H_a is None or not np.isfinite(H_a).all():
-            raise RuntimeError(
-                "JAX autograd Hessian unavailable — cannot compute standard errors. "
-                "Ensure JAX is installed, the model was fit with _jax=True (default), "
-                "and all latent classes share the same variable set."
-            )
-        info = H_a   # hessian(-negloglik) = -hessian(loglik) = observed info
-        se_method = "autograd-hessian"
+        if H_a is not None and np.isfinite(H_a).all():
+            info = H_a   # hessian(-negloglik) = -hessian(loglik) = observed info
+            se_method = "autograd-hessian"
+        else:
+            # JAX unavailable (or classes with differing variable sets):
+            # fall back to a finite-difference Hessian so searches always
+            # get standard errors and p-values.
+            H_num = self._numerical_hessian(params, eps=eps)
+            if not np.isfinite(H_num).all():
+                raise RuntimeError(
+                    "Hessian could not be computed (autograd unavailable and "
+                    "finite-difference Hessian is non-finite) — standard errors "
+                    "are not available for this model."
+                )
+            info = -H_num   # observed info = -hessian(loglik)
+            se_method = "numerical-hessian (finite differences)"
 
         cond_number = np.nan
         cov = None
@@ -1592,6 +1604,16 @@ class LatentClassMixedLogit:
                     gamma_names.append(f"gamma_class_{c + 1}_{v}")
             param_names += gamma_names
 
+        # ── Standard attributes aligned with coeff_est / coeff_names ──────
+        # The specification search reads model.stderr / model.pvalues to drive
+        # significance-based refinement and PBIL probability updates, so the
+        # class-beta block (which is what coeff_est holds) must be exposed here.
+        n_beta = beta_flat.size
+        self.stderr  = se[n_phi:n_phi + n_beta]
+        self.zvalues = t_stats[n_phi:n_phi + n_beta]
+        self.pvalues = p_values[n_phi:n_phi + n_beta]
+        self.pvalues_member = gamma_p_values
+
         return {
             "params":      params,
             "se":          se,

{searchlibrium-0.0.138 → searchlibrium-0.0.140}/src/SearchLibrium/mixed_logit.py

@@ -261,9 +261,9 @@ class MixedLogit(DiscreteChoiceModel):
               init_coeff=None, maxiter=2000, correlated_vars=None,
               n_draws=1000, halton=True, minimise_func=None,
               batch_size=None, halton_opts=None, ftol=1e-6,
-              gtol=1e-6, return_hess=True, return_grad=True, method="bfgs",
+              gtol=1e-6, return_hess=True, return_grad=True, method="slsqp",
               save_fitted_params=True, mnl_init=True, fixed_thetas=None,
-              l1_penalty=0.0):
+              l1_penalty=0.1, l2_penalty=0.5):
     # {
         
         # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

{searchlibrium-0.0.138 → searchlibrium-0.0.140}/src/SearchLibrium/mixedrrm.py

@@ -58,6 +58,6 @@ class MixedRandomRegret(RandomRegret, MixedLogit):
             return -loglik
 
         # Optimize the negative log-likelihood
-        self.result = minimize(neg_log_likelihood, self.beta, method='BFGS', tol=1e-6)
+        self.result = minimize(neg_log_likelihood, self.beta, method='SLSQP', tol=1e-6)
         self.beta = self.result.x
         self.post_process()

{searchlibrium-0.0.138 → searchlibrium-0.0.140}/src/SearchLibrium/multinomial_logit.py

@@ -246,7 +246,7 @@ class MultinomialLogit(DiscreteChoiceModel):
         transformation="boxcox", ids=None, weights=None, avail=None,
         base_alt=None, fit_intercept=False, init_coeff=None, maxiter=2000,
         ftol=1e-6, gtol=1e-6, return_grad=True, return_hess=True,
-        method="bfgs", scipy_optimisation=True, l2_penalty=0.0, l1_penalty=0.0):
+        method="slsqp", scipy_optimisation=True, l2_penalty=0.5, l1_penalty=0.1):
     # {
 
         self.l2_penalty = float(l2_penalty)

{searchlibrium-0.0.138 → searchlibrium-0.0.140}/src/SearchLibrium/search.py

@@ -592,6 +592,7 @@ class Parameters:
         maxiter=2000, n_draws=1000, p_val=0.05, chosen_alts_test=None,
         test_weight_var=None, allow_random=False, allow_bcvars=False,  allow_corvars=False, models = None,
         de_init=False, de_popsize=4, de_maxiter=3, de_tol=0.5, de_polish=False,
+        sd_penalty=0.001,
         intercept_opts=None, base_alt=None, val_share=0.25,  grad = True, hess = False, *args, **kwargs):
 
         
@@ -683,9 +684,10 @@ class Parameters:
         self.de_maxiter = de_maxiter
         self.de_tol = de_tol
         self.de_polish = de_polish
+        self.sd_penalty = sd_penalty
 
         # ── Regularisation (primarily for latent class) ──────────────
-        self.l1_penalty = kwargs.get('l1_penalty', 0.0)
+        self.l1_penalty = kwargs.get('l1_penalty', 0.1)
         self.l2_penalty = kwargs.get('l2_penalty', 0.5)
 
         self.intercept_opts = intercept_opts
@@ -787,7 +789,7 @@ class Parameters:
         acceptable_keys = [
             'LCR', 'verbose', 'asc_ind', 'nests', 'lambdas', 'varnest',
             '_jax', 'all_sig', 'de_init', 'de_popsize', 'de_maxiter',
-            'de_tol', 'de_polish', 'halton_opts'
+            'de_tol', 'de_polish', 'sd_penalty', 'halton_opts'
         ]
 
         # Assign all kwargs to self, but only if the key is in the acceptable_keys list
@@ -1001,6 +1003,27 @@ class Solution(UserDict):
                 setattr(self, key, value)
     # }
 
+    def __deepcopy__(self, memo):
+    # {
+        # Fitted model objects stored under 'model' hold module/JAX references
+        # that cannot be deep-copied (TypeError: cannot pickle 'module' object).
+        # The fitted model is read-only after estimation, so the copy shares it
+        # by reference; everything else is deep-copied as usual.
+        cls = self.__class__
+        new = cls.__new__(cls)
+        memo[id(self)] = new
+        new.data = {}
+        for k, v in self.data.items():
+            new.data[k] = v if k == 'model' else copy.deepcopy(v, memo)
+        for k, v in self.__dict__.items():
+            if k == 'data':
+                continue
+            try:
+                setattr(new, k, copy.deepcopy(v, memo))
+            except TypeError:
+                setattr(new, k, v)  # share unpicklable attributes by reference
+        return new
+    # }
 
     def __eq__(self, other):
         """
@@ -3985,7 +4008,8 @@ class Search():
             de_popsize=getattr(self.param, 'de_popsize', 4),
             de_maxiter=getattr(self.param, 'de_maxiter', 3),
             de_tol=getattr(self.param, 'de_tol', 0.5),
-            de_polish=getattr(self.param, 'de_polish', False))
+            de_polish=getattr(self.param, 'de_polish', False),
+            sd_penalty=getattr(self.param, 'sd_penalty', 0.001))
         model.fit()
         
         return model
@@ -4017,8 +4041,8 @@ class Search():
             random_state=seed if seed is not None else 0,
             optimise_membership=optimise_membership,
             membership_maxiter=100,
-            l1_penalty=getattr(self.param, 'l1_penalty', 0.0),
-            l2_penalty=getattr(self.param, 'l2_penalty', 0.0),
+            l1_penalty=getattr(self.param, 'l1_penalty', 0.1),
+            l2_penalty=getattr(self.param, 'l2_penalty', 0.5),
         )
 
         membership_vars = None
@@ -4267,6 +4291,14 @@ class Search():
         sol['model_n'] = 'latent_class'
         converged = model.converged
 
+        # Standard errors / p-values: needed by significance-based refinement
+        # and PBIL updates. A failed Hessian must not abort the search.
+        if converged and getattr(model, 'pvalues', None) is None:
+            try:
+                model.compute_standard_errors()
+            except Exception as exc:
+                print(f"[LC] standard errors unavailable for this candidate: {exc}")
+
         aic = getattr(model, 'aic', float('inf'))
         bic = getattr(model, 'bic', float('inf'))
         loglik = getattr(model, 'loglik', float('-inf'))

searchlibrium-0.0.140/src/SearchLibrium/version.txt

@@ -0,0 +1 @@
+0.0.140

{searchlibrium-0.0.138 → searchlibrium-0.0.140}/src/SearchLibrium.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SearchLibrium
-Version: 0.0.138
+Version: 0.0.140
 Summary: A Python package for econometric models driven by search
 Author: Mario Fernando Taco Morales, Alexander Paz, Prithvi Beeramole, Robert Burdett
 Author-email: Zeke Ahern <z.ahern@qut.edu.au>

searchlibrium-0.0.138/src/SearchLibrium/version.txt

@@ -1 +0,0 @@
-0.0.138