SearchLibrium 0.0.119__tar.gz → 0.0.121__tar.gz

{searchlibrium-0.0.119 → searchlibrium-0.0.121}/PKG-INFO

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

{searchlibrium-0.0.119 → searchlibrium-0.0.121}/pyproject.toml

@@ -68,7 +68,7 @@ Homepage = "https://github.com/zahern/HypothesisX"
 realpython = "SearchLibrium.__main__:main"
 
 [tool.bumpver]
-current_version = "0.0.119"
+current_version = "0.0.121"
 version_pattern = "MAJOR.MINOR.PATCH"
 commit_message = "[skip ci] Bump version {old_version} -> {new_version}"
 commit = true

{searchlibrium-0.0.119 → searchlibrium-0.0.121}/src/SearchLibrium/MixedLogit.py

@@ -140,7 +140,7 @@ class MixedLogit(DiscreteChoiceModel):
               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):
+              de_polish=False, l1_penalty=0.0):
         # {
         self.fit_intercept = fit_intercept
         # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -185,6 +185,7 @@ class MixedLogit(DiscreteChoiceModel):
         self.de_polish = de_polish
         self.total_fun_eval = 0
         self.method = method.lower() if hasattr(method, 'lower') else method
+        self.l1_penalty = float(l1_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
@@ -1033,6 +1034,7 @@ class MixedLogit(DiscreteChoiceModel):
 
         penalty = self.regularize_loglik(betas)
         loglik = loglik - penalty
+        loglik = loglik - self.regularize_l1_loglik(betas)
 
         self.total_fun_eval += 1
 
@@ -1054,6 +1056,7 @@ class MixedLogit(DiscreteChoiceModel):
         # }
 
         g = np.sum(g, axis=0) / n_batches  # (K, )
+        g = g - self.regularize_l1_grad(betas)
         self.gtol_res = np.linalg.norm(g, ord=np.inf)
 
         result = (-loglik,)  # Create a tuple

{searchlibrium-0.0.119 → searchlibrium-0.0.121}/src/SearchLibrium/__init__.py

@@ -111,7 +111,8 @@ try:
 
     from . import misc
     from .sapbil import SAPBIL, ProbabilityMatrix
-    from .call_meta import call_harmony, call_siman, call_parsa, call_search, call_sapbil, estimate_ctrl
+    from .hspbil import HSPBIL
+    from .call_meta import call_harmony, call_harmony_pbil, call_siman, call_parsa, call_search, call_sapbil, estimate_ctrl
 
 except ImportError as e:
     from _choice_model import DiscreteChoiceModel
@@ -130,7 +131,8 @@ except ImportError as e:
     from constraints_builder import ConstraintBuilder, create_constraints
     from search import Parameters
     from sapbil import SAPBIL, ProbabilityMatrix
-    from call_meta import call_siman, call_harmony, call_search, call_sapbil, estimate_ctrl
+    from hspbil import HSPBIL
+    from call_meta import call_siman, call_harmony, call_harmony_pbil, call_search, call_sapbil, estimate_ctrl
 try:
     from .main import print_ascii_art_logo
 except Exception:

{searchlibrium-0.0.119 → searchlibrium-0.0.121}/src/SearchLibrium/call_meta.py

@@ -24,12 +24,14 @@ try:
     from banditsa import*
     from threshold import*
     from sapbil import SAPBIL, ProbabilityMatrix
+    from hspbil import HSPBIL
 except ImportError:
     from .harmony import*
     from .siman import*
     from .banditsa import*
     from .threshold import*
     from .sapbil import SAPBIL, ProbabilityMatrix
+    from .hspbil import HSPBIL
 
 import numpy as np
 
@@ -447,6 +449,54 @@ def call_harmony(parameters, init_sol=None, ctrl=None, **kwargs):
     return best
 
 
+# ─────────────────────────────────────────────────────────────────────────────
+# Harmony Search + PBIL
+# ─────────────────────────────────────────────────────────────────────────────
+
+def call_harmony_pbil(parameters, init_sol=None, ctrl=None, **kwargs):
+    """Run Harmony Search with PBIL-guided pitch adjustment.
+
+    Parameters
+    ----------
+    parameters : Parameters
+        Problem definition.
+    init_sol : Solution, optional
+        Warm-start solution (passed as existing memory).
+    ctrl : tuple, optional
+        ``(max_mem, maxiter, max_harm, min_harm, max_pitch, min_pitch)``.
+        If omitted the values are estimated from the problem size.
+    **kwargs
+        ``id_num`` — run identifier.
+
+    Returns
+    -------
+    Solution
+        Best solution in the final harmony memory.
+    """
+    if ctrl is None:
+        ctrl = kwargs.pop('ctrl', None)
+
+    id_num = kwargs.pop('id_num', None)
+
+    if ctrl is None:
+        ctrl = estimate_ctrl(parameters, algorithm='hs')
+        print(f"[HS+PBIL] Auto-estimated hyperparameters (problem complexity "
+              f"= {_problem_size(parameters)['complexity']}):")
+    else:
+        print(f"[HS+PBIL] Using provided hyperparameters:")
+
+    print(_describe_ctrl(ctrl, 'hs'))
+    print()
+
+    solver = HSPBIL(parameters, init_sol, ctrl, idnum=id_num, **kwargs)
+    existing = [init_sol] if init_sol is not None else None
+    solver.run_search(existing_sols=existing)
+    solver.close_files()
+    best = solver.return_best()
+    _print_dashboard(solver, best, algorithm='HS+PBIL')
+    return best
+
+
 # ─────────────────────────────────────────────────────────────────────────────
 # Unified entry point
 # ─────────────────────────────────────────────────────────────────────────────
@@ -496,10 +546,12 @@ def call_search(parameters, init_sol=None, algorithm='sa', ctrl=None, **kwargs):
         return call_banditsa(parameters, init_sol=init_sol, ctrl=ctrl, **kwargs)
     elif algorithm in ('hs', 'harmony', 'harmony_search'):
         return call_harmony(parameters, init_sol=init_sol, ctrl=ctrl, **kwargs)
+    elif algorithm in ('hspbil', 'harmony_pbil', 'hs_pbil', 'hs+pbil'):
+        return call_harmony_pbil(parameters, init_sol=init_sol, ctrl=ctrl, **kwargs)
     else:
         raise ValueError(
             f"Unknown algorithm '{algorithm}'. "
-            f"Choose 'sa', 'sapbil', 'banditsa', or 'hs'."
+            f"Choose 'sa', 'sapbil', 'banditsa', 'hs', or 'hspbil'."
         )
 
 

searchlibrium-0.0.121/src/SearchLibrium/hspbil.py

@@ -0,0 +1,299 @@
+"""HS+PBIL: Harmony Search coupled with Population-Based Incremental Learning.
+
+Reference:
+    Taco-Morales, M.F. (2026). SA + PBIL: Coupling Simulated Annealing with
+    Population-Based Incremental Learning for Discrete Choice Model Specification
+    Search. QUT Master's Thesis, May 2026.
+
+This module extends the PBIL probability-guided perturbation mechanism from
+SAPBIL to the Harmony Search algorithm.  Instead of uniform-random
+perturbations during pitch adjustment, the PBIL probability matrix guides
+add/remove decisions for variables, increasing the probability of choosing
+directions that led to significant parameters in previously accepted solutions.
+"""
+
+import copy
+import logging
+import numpy as np
+import time as _time
+
+try:
+    from .harmony import HarmonySearch
+    from .sapbil import ProbabilityMatrix
+except ImportError:
+    from harmony import HarmonySearch
+    from sapbil import ProbabilityMatrix
+
+logger = logging.getLogger(__name__)
+
+
+# pylint: disable=too-many-ancestors,attribute-defined-outside-init
+class HSPBIL(HarmonySearch):
+    """Harmony Search with PBIL-guided pitch adjustment.
+
+    Overrides the standard uniform-random pitch perturbations with
+    probability-weighted decisions that learn from accepted solutions.
+    """
+
+    def __init__(self, param, init_sol, ctrl, idnum=0, **kwargs):
+        super().__init__(param, init_sol, ctrl, idnum=idnum, **kwargs)
+
+        varnames = list(param.asvarnames or [])
+        distributions = list(param.distr or ["n", "ln", "tn", "u", "t"])
+        self.prob_matrix = ProbabilityMatrix(varnames, distributions)
+
+        self._ps_asvars = set(getattr(param, "ps_asvars", []) or [])
+        self._ps_randvars = set(
+            (getattr(param, "ps_randvars", {}) or {}).keys()
+        )
+        self._ps_bcvars = set(getattr(param, "ps_bcvars", []) or [])
+        self._ps_corvars = set(getattr(param, "ps_corvars", []) or [])
+
+        self._pbil_updates = 0
+
+    # ------------------------------------------------------------------
+    # Output files  (override to use "hspbil_" prefix)
+    # ------------------------------------------------------------------
+
+    def create_output_files(self, param, **kwargs):
+        run_id = kwargs.get('idnum', 0)
+        ts = _time.strftime("%Y%m%d_%H%M%S")
+        run_name = f"hspbil_{run_id}_{ts}" if run_id else f"hspbil_{ts}"
+
+        try:
+            self.results_file = open(f"{run_name}_results.txt", "w")
+        except Exception:
+            self.results_file = open(f"hspbil_results.txt", "w")
+
+        try:
+            self.progress_file = open(f"{run_name}_progress.txt", "w")
+        except Exception:
+            self.progress_file = open(f"hspbil_progress.txt", "w")
+
+        print("SearchLibrium - HS+PBIL Run", file=self.results_file)
+        print(f"Run ID: {run_id}", file=self.results_file)
+        print(f"Start time: {_time.strftime('%Y-%m-%d %H:%M:%S')}", file=self.results_file)
+        print("-" * 72, file=self.results_file)
+        self.results_file.flush()
+
+        print("iteration,score", file=self.progress_file)
+        self.progress_file.flush()
+
+    # ------------------------------------------------------------------
+    # PBIL significance helpers (same as SAPBIL)
+    # ------------------------------------------------------------------
+
+    def _build_significance_map(self, sol):
+        model = sol.get("model")
+        if model is None:
+            return {}
+        try:
+            pvalues = np.array(model.pvalues)
+            coeff_names = list(model.coeff_names) if model.coeff_names is not None else []
+            p_thresh = getattr(self.param, "p_val", 0.05)
+            return {
+                name: bool(pv <= p_thresh)
+                for name, pv in zip(coeff_names, pvalues)
+            }
+        except Exception as exc:
+            logger.debug("HS+PBIL: could not build significance map: %s", exc)
+            return {}
+
+    def _update_probability_matrix(self, sol):
+        pm = self.prob_matrix
+
+        sig = self._build_significance_map(sol)
+
+        asvars = set(sol.get("asvars", []) or [])
+        randvars = dict(sol.get("randvars", {}) or {})
+        bcvars = set(sol.get("bcvars", []) or [])
+        corvars = set(sol.get("corvars", []) or [])
+
+        t = 1.0
+        tI = 1.0
+
+        for var in pm.varnames:
+            if var in self._ps_asvars:
+                continue
+
+            in_model = var in asvars
+            is_random = var in randvars
+            is_bc = var in bcvars
+            is_corr = var in corvars
+
+            if in_model:
+                mean_sig = sig.get(var, False)
+                sd_sig = sig.get(f"sd.{var}", False)
+                if mean_sig or (is_random and sd_sig):
+                    incl_ind = 1.0
+                elif (not mean_sig) and (not is_random or (not mean_sig and not sd_sig)):
+                    incl_ind = 0.0
+                else:
+                    incl_ind = 0.5
+            else:
+                incl_ind = 0.0
+
+            pm.update_inclusion(var, incl_ind, t, tI)
+
+            if not in_model:
+                continue
+
+            if var not in self._ps_randvars:
+                if is_random:
+                    rand_ind = 1.0 if sig.get(f"sd.{var}", False) else 0.0
+                else:
+                    rand_ind = 0.0
+                pm.update_random(var, rand_ind, t, tI)
+
+            if not is_random:
+                continue
+
+            if var not in self._ps_randvars:
+                current_distr = randvars[var]
+                mean_sig_d = sig.get(var, False)
+                sd_sig_d = sig.get(f"sd.{var}", False)
+                distr_ind = 1.0 if (mean_sig_d and sd_sig_d) else 0.0
+                pm.update_distribution(var, current_distr, distr_ind, t, tI)
+
+            if not is_bc and var not in self._ps_corvars:
+                if is_corr:
+                    chol_sig = any(
+                        (
+                            sig.get(f"chol.{var}.{v2}", False)
+                            or sig.get(f"chol.{v2}.{var}", False)
+                        )
+                        for v2 in corvars
+                        if v2 != var
+                    )
+                    corr_ind = 1.0 if chol_sig else 0.0
+                else:
+                    corr_ind = 0.0
+                pm.update_correlation(var, corr_ind, t, tI)
+
+            if not is_corr and var not in self._ps_bcvars:
+                if is_bc:
+                    bc_ind = 1.0 if sig.get(f"lambda.{var}", False) else 0.0
+                else:
+                    bc_ind = 0.0
+                pm.update_boxcox(var, bc_ind, t, tI)
+
+        self._pbil_updates += 1
+
+    # ------------------------------------------------------------------
+    # PBIL-guided inclusion perturbation
+    # ------------------------------------------------------------------
+
+    def _pbil_inclusion(self, sol):
+        """Apply one PBIL-guided inclusion add/remove step."""
+        pm = self.prob_matrix
+        in_vars = [v for v in sol.get("asvars", []) if v in pm.p_inclusion]
+        out_vars = [v for v in pm.varnames if v not in sol.get("asvars", [])]
+
+        p_bar_in = float(np.mean([pm.p_inclusion[v] for v in in_vars])) if in_vars else 0.5
+        p_bar_out = float(np.mean([pm.p_inclusion[v] for v in out_vars])) if out_vars else 0.5
+
+        denom = p_bar_out + (1.0 - p_bar_in)
+        p_add = p_bar_out / denom if denom > 1e-12 else 0.5
+
+        if np.random.random() < p_add and out_vars:
+            probs = np.array([pm.p_inclusion[v] for v in out_vars], dtype=float)
+            probs = probs / (probs.sum() + 1e-12)
+            var = np.random.choice(out_vars, p=probs)
+            return self.add_asvar(var, sol)
+        elif in_vars:
+            non_ps = [v for v in in_vars if v not in self._ps_asvars]
+            if not non_ps or len(in_vars) <= 1:
+                return sol
+            probs = np.array([1.0 - pm.p_inclusion[v] for v in non_ps], dtype=float)
+            if probs.sum() < 1e-12:
+                probs = np.ones(len(non_ps), dtype=float)
+            probs = probs / probs.sum()
+            var = np.random.choice(non_ps, p=probs)
+            return self.remove_asvar(var, sol)
+        return sol
+
+    # ------------------------------------------------------------------
+    # PBIL override of key perturbation methods from SearchBase
+    # ------------------------------------------------------------------
+
+    def perturb_asfeature(self, sol):
+        if sol['asvars'] is None or len(sol['asvars']) == 0:
+            return self.perturb_add_asfeature(sol)
+        if np.random.random() < 0.5:
+            return self._pbil_inclusion(sol)
+        return super().perturb_asfeature(sol)
+
+    def perturb_isfeature(self, sol):
+        return super().perturb_isfeature(sol)
+
+    # ------------------------------------------------------------------
+    # Override improvise to track iteration counter for PBIL logging
+    # ------------------------------------------------------------------
+
+    def improvise(self):
+        best, current = [], []
+        for iter in range(self.maxiter):
+            sine_iter = max(0, np.sign(math.sin(iter)))
+            self.harm_rate = (self.min_harm + ((self.max_harm - self.min_harm) / self.maxiter) * iter) * sine_iter
+            self.pitch = (self.min_pitch + ((self.max_pitch - self.min_pitch) / self.maxiter) * iter) * sine_iter
+
+            new_sol = self.build_solution(self.memory, self.harm_rate)
+            curr_sol, converged = self.pitch_adjustment(new_sol, self.pitch)
+            if converged:
+                self.insert_solution(curr_sol)
+                try:
+                    self._update_probability_matrix(curr_sol)
+                except Exception:
+                    pass
+
+        all_val, obj_val = self.log_convergence(self.memory)
+        if self.generate_plots:
+            self.plot_results(self.memory, all_val, obj_val)
+
+    def run_search(self, existing_sols=None):
+        import time as _time
+
+        self.start = _time.time()
+
+        from .search import get_unique as _get_unique
+        try:
+            from .search import get_unique
+        except ImportError:
+            from search import get_unique
+
+        self.create_output_files(self.param, idnum=getattr(self, 'idnum', 0))
+
+        existing_memory = self.screen_solutions(existing_sols)
+        generated_memory = self.initialize_memory(self.max_mem)
+        init_memory = generated_memory + existing_memory
+        unique_memory = get_unique(init_memory, 0)
+        for sol in unique_memory:
+            sol.data['is_initial_sol'] = True
+
+        memory_sorted = self.sort_memory(unique_memory)
+        memory = memory_sorted[: self.max_mem]
+        self.memory = memory.copy()
+
+        if self.memory:
+            self.best_sol = self.copy_solution(self.sort_memory(self.memory)[0])
+
+        print(f"HS+PBIL[{getattr(self, 'idnum', 0)}] Memory initialised.  "
+              f"Starting improvisation ({self.maxiter} iterations) ...")
+        self.improvise()
+
+        improved = self.sort_memory(self.memory.copy())
+        if improved:
+            self.best_sol = self.copy_solution(improved[0])
+
+        print(f"HS+PBIL[{getattr(self, 'idnum', 0)}]. Search complete")
+        logger.info("Search ended at: {}".format(str(_time.ctime())))
+
+        try:
+            pm_summary = self.prob_matrix.summary()
+            print("\nHS+PBIL -- final probability matrix:", file=self.results_file)
+            for row in pm_summary:
+                print(f"  {row}", file=self.results_file)
+        except Exception:
+            pass
+
+        return improved

{searchlibrium-0.0.119 → searchlibrium-0.0.121}/src/SearchLibrium/latent_class.py

@@ -41,6 +41,8 @@ class LatentClassMixedLogit:
         n_init=1,
         optimise_membership=True,
         membership_maxiter=50,
+        l1_penalty=0.0,
+        l2_penalty=0.0,
     ):
         self.n_classes = int(n_classes)
         self.maxiter = int(maxiter)
@@ -50,6 +52,8 @@ class LatentClassMixedLogit:
         self.n_init = max(1, int(n_init))
         self.optimise_membership = bool(optimise_membership)
         self.membership_maxiter = int(membership_maxiter)
+        self.l1_penalty = float(l1_penalty)
+        self.l2_penalty = float(l2_penalty)
         self.descr = "LC-MXL"
         self.coeff_est = None
         self.coeff_names = None
@@ -87,7 +91,7 @@ class LatentClassMixedLogit:
 
     def setup(self, X, y, varnames, ids, alts, avail=None, fit_intercept=False,
               membership_vars=None, member_params_spec=None,
-              class_params_spec=None):
+              class_params_spec=None, l1_penalty=None, l2_penalty=None):
         X = np.asarray(X, dtype=float)
         y = np.asarray(y, dtype=float)
         ids = np.asarray(ids)
@@ -108,6 +112,10 @@ class LatentClassMixedLogit:
         self.J = len(self.alts)
         self.K = X.shape[1]
         self.varnames = varnames
+        if l1_penalty is not None:
+            self.l1_penalty = float(l1_penalty)
+        if l2_penalty is not None:
+            self.l2_penalty = float(l2_penalty)
 
         order = np.lexsort((alts, ids))
         X = X[order]
@@ -129,6 +137,23 @@ class LatentClassMixedLogit:
         # ── Class-specific specification ────────────────────────────────────
         self._class_specs = None
         self._Ks = None  # K per class
+
+        _member_util_exclude = set()
+        if membership_vars is not None:
+            for v in membership_vars:
+                if v in varnames:
+                    _member_util_exclude.add(varnames.index(v))
+        elif member_params_spec is not None:
+            if hasattr(member_params_spec, 'shape'):
+                raw = member_params_spec.ravel() if member_params_spec.ndim > 1 else member_params_spec
+                for v in raw:
+                    if isinstance(v, str) and v != '_inter' and v in varnames:
+                        _member_util_exclude.add(varnames.index(v))
+            else:
+                for v in member_params_spec:
+                    if isinstance(v, str) and v != '_inter' and v in varnames:
+                        _member_util_exclude.add(varnames.index(v))
+
         if class_params_spec is not None:
             self._class_specs = []
             self._Ks = []
@@ -149,9 +174,15 @@ class LatentClassMixedLogit:
             self._Ks = np.array(self._Ks, dtype=int)
             self.K_tot = int(self._Ks.sum())
         else:
-            self._Ks = np.full(self.n_classes, self.K, dtype=int)
-            self._class_specs = [np.arange(self.K, dtype=int)] * self.n_classes
-            self.K_tot = self.n_classes * self.K
+            if _member_util_exclude:
+                utility_idx = [i for i in range(self.K) if i not in _member_util_exclude]
+                self._Ks = np.full(self.n_classes, len(utility_idx), dtype=int)
+                self._class_specs = [np.array(utility_idx, dtype=int)] * self.n_classes
+                self.K_tot = self.n_classes * len(utility_idx)
+            else:
+                self._Ks = np.full(self.n_classes, self.K, dtype=int)
+                self._class_specs = [np.arange(self.K, dtype=int)] * self.n_classes
+                self.K_tot = self.n_classes * self.K
 
         # ── Membership data ────────────────────────────────────────────────
         self._has_membership = False
@@ -219,6 +250,29 @@ class LatentClassMixedLogit:
         else:
             self.X_memb_backend = None
 
+    def _regularize_l2_betas(self, betas):
+        if isinstance(betas, list):
+            return self.l2_penalty * sum(float(np.sum(np.square(np.asarray(b)))) for b in betas)
+        return self.l2_penalty * float(np.sum(np.square(np.asarray(betas))))
+
+    def _regularize_l1_betas(self, betas):
+        if isinstance(betas, list):
+            return self.l1_penalty * sum(float(np.sum(np.abs(np.asarray(b)))) for b in betas)
+        return self.l1_penalty * float(np.sum(np.abs(np.asarray(betas))))
+
+    def _regularize_l2_gammas(self, gammas):
+        if gammas is None or self.l2_penalty == 0:
+            return 0.0
+        return self.l2_penalty * float(np.sum(np.square(np.asarray(gammas))))
+
+    def _regularize_l1_gammas(self, gammas):
+        if gammas is None or self.l1_penalty == 0:
+            return 0.0
+        return self.l1_penalty * float(np.sum(np.abs(np.asarray(gammas))))
+
+    def _regularize_l1_grad(self, beta):
+        return self.l1_penalty * np.sign(np.asarray(beta, dtype=float))
+
     @staticmethod
     def _normalize_class_probs(class_probs):
         class_probs = np.clip(np.asarray(class_probs, dtype=float), 1e-12, None)
@@ -271,8 +325,8 @@ class LatentClassMixedLogit:
         """
         C = self.n_classes
         Km = self.K_membership
-        gammas = gammas.reshape(C - 1, Km)
-        priors = self._compute_membership_priors(gammas)
+        gammas_arr = gammas.reshape(C - 1, Km)
+        priors = self._compute_membership_priors(gammas_arr)
         log_priors = np.log(np.clip(priors, 1e-300, None))
         ll = np.sum(weights * log_priors)
 
@@ -281,7 +335,22 @@ class LatentClassMixedLogit:
         for c in range(C - 1):
             res_c = residuals[:, c]
             grad[c] = self.X_membership.T @ res_c
-        return -ll, -grad.flatten()
+
+        l2 = self.l2_penalty
+        l1 = self.l1_penalty
+        if l2 > 0:
+            ll -= l2 * np.sum(np.square(gammas_arr))
+        if l1 > 0:
+            ll -= l1 * np.sum(np.abs(gammas_arr))
+
+        neg_obj = -ll
+        neg_grad = -grad
+        if l2 > 0:
+            neg_grad += 2.0 * l2 * gammas_arr
+        if l1 > 0:
+            neg_grad += l1 * np.sign(gammas_arr)
+
+        return neg_obj, neg_grad.flatten()
 
     def _membership_m_step(self, gamma0, weights):
         """M-step for membership (gamma) parameters.
@@ -361,6 +430,84 @@ class LatentClassMixedLogit:
         chosen_prob = np.clip((probs * self.y[:, None, :]).sum(axis=2), 1e-300, None)
         return np.log(chosen_prob), probs
 
+    def _build_jax_full_objective(self):
+        cache_key = "_jax_full_obj"
+        if hasattr(self, cache_key):
+            return getattr(self, cache_key)
+
+        if not self._jax_enabled or len(set(self._Ks)) != 1:
+            setattr(self, cache_key, None)
+            return None
+
+        jnp = self.jnp
+        C = self.n_classes
+        K = int(self._Ks[0])
+        n_phi = C - 1
+        avail = self.avail_backend
+        y_b = self.y_backend
+        X_full = self.X_backend
+        util_spec = self._class_specs[0] if self._class_specs is not None else None
+        if util_spec is not None and len(util_spec) < X_full.shape[2]:
+            X_b = X_full[:, :, util_spec]
+        else:
+            X_b = X_full
+        N = int(X_b.shape[0])
+        has_memb = bool(self._has_membership and self.optimise_membership
+                        and self.K_membership > 0)
+        Km = self.K_membership if has_memb else 0
+        X_memb = self.X_memb_backend if has_memb else None
+        l2 = self.l2_penalty
+        l1 = self.l1_penalty
+
+        def _negloglik_flat(params):
+            phi = params[:n_phi]
+            beta_flat = params[n_phi:n_phi + C * K]
+            betas = beta_flat.reshape(C, K)
+
+            utilities = jnp.einsum("ck,njk->ncj", betas, X_b)
+            utilities = jnp.where(avail[:, None, :] > 0, utilities, -1e10)
+            utilities = utilities - jnp.max(utilities, axis=2, keepdims=True)
+            exp_u = jnp.exp(utilities) * avail[:, None, :]
+            denom = jnp.clip(exp_u.sum(axis=2, keepdims=True), 1e-300)
+            probs = exp_u / denom
+            chosen = jnp.clip((probs * y_b[:, None, :]).sum(axis=2), 1e-300)
+            log_chosen = jnp.log(chosen)
+
+            if has_memb:
+                gammas = params[n_phi + C * K:].reshape(C - 1, Km)
+                logits = jnp.zeros((N, C))
+                for c in range(C - 1):
+                    logits = logits.at[:, c].set(X_memb @ gammas[c])
+                logits = logits - jnp.max(logits, axis=1, keepdims=True)
+                exp_logits = jnp.exp(logits)
+                priors = exp_logits / jnp.clip(jnp.sum(exp_logits, axis=1, keepdims=True), 1e-300, None)
+                log_prior = jnp.log(jnp.clip(priors, 1e-300))
+            else:
+                phi_full = jnp.concatenate([phi, jnp.zeros(1)])
+                log_priors_raw = phi_full - self.jax_logsumexp(phi_full)
+                log_prior = jnp.broadcast_to(log_priors_raw[None, :], (N, C))
+
+            log_joint = log_chosen + log_prior
+            log_marg = self.jax_logsumexp(log_joint, axis=1)
+            ll = jnp.sum(log_marg)
+            ll -= l2 * jnp.sum(jnp.square(betas))
+            ll -= l1 * jnp.sum(jnp.abs(betas))
+            if has_memb:
+                ll -= l2 * jnp.sum(jnp.square(gammas))
+                ll -= l1 * jnp.sum(jnp.abs(gammas))
+            return -ll
+
+        obj, grad_fn = None, None
+        try:
+            obj = self.jit(_negloglik_flat)
+            grad_fn = self.jit(self.value_and_grad(_negloglik_flat))
+        except Exception:
+            pass
+
+        cached = (obj, grad_fn)
+        setattr(self, cache_key, cached)
+        return cached
+
     def _build_jax_weighted_objective(self, X_c=None, class_idx=None):
         if X_c is None:
             cache_key = "_full"
@@ -419,7 +566,10 @@ class LatentClassMixedLogit:
 
             def objective(beta):
                 value, grad = grad_fn(self.jnp.asarray(beta), weights_backend)
-                return float(value), np.asarray(grad, dtype=float)
+                l2 = self.l2_penalty * float(self.jnp.sum(self.jnp.square(beta)))
+                l1 = self.l1_penalty * float(self.jnp.sum(self.jnp.abs(beta)))
+                grad_l1 = self._regularize_l1_grad(np.asarray(beta))
+                return float(value) + l2 + l1, np.asarray(grad, dtype=float) + 2.0 * self.l2_penalty * np.asarray(beta) + grad_l1
         else:
             def objective(beta):
                 utilities = np.einsum("njk,k->nj", X_c, beta)
@@ -431,7 +581,9 @@ class LatentClassMixedLogit:
                 loglik = np.sum(weights * np.log(chosen_prob))
                 diff = (self.y - probs) * weights[:, None]
                 grad = np.einsum("nj,njk->k", diff, X_c)
-                return -loglik, -grad
+                l2 = self.l2_penalty * float(np.sum(beta * beta))
+                l1 = self.l1_penalty * float(np.sum(np.abs(beta)))
+                return -loglik + l2 + l1, -grad + 2.0 * self.l2_penalty * beta + self._regularize_l1_grad(beta)
 
         result = minimize(
             objective,
@@ -469,11 +621,18 @@ class LatentClassMixedLogit:
             y_b = self.y_backend
             av_b = self.avail_backend
             C = self.n_classes
+            K_util = int(self._Ks[0])
+            util_spec = self._class_specs[0] if self._class_specs is not None else None
+
+            if util_spec is not None and len(util_spec) < self.K:
+                X_util = X_b[:, :, util_spec]
+            else:
+                X_util = X_b
 
             @self.jit
             def _jax_negll(betas_flat):
-                betas = betas_flat.reshape(C, self.K)
-                utilities = jnp.einsum("ck,njk->ncj", betas, X_b)
+                betas = betas_flat.reshape(C, K_util)
+                utilities = jnp.einsum("ck,njk->ncj", betas, X_util)
                 utilities = jnp.where(av_b[:, None, :] > 0, utilities, -1e10)
                 utilities = utilities - jnp.max(utilities, axis=2, keepdims=True)
                 exp_u = jnp.exp(utilities) * av_b[:, None, :]
@@ -484,7 +643,10 @@ class LatentClassMixedLogit:
                 log_prior = jnp.log(jnp.full(C, 1.0 / C))
                 log_joint = log_chosen + log_prior[None, :]
                 log_marg = self.jax_logsumexp(log_joint, axis=1)
-                return -jnp.sum(log_marg)
+                ll = jnp.sum(log_marg)
+                l2 = self.l2_penalty * jnp.sum(jnp.square(betas))
+                l1 = self.l1_penalty * jnp.sum(jnp.abs(betas))
+                return -(ll - l2 - l1)
 
             def _obj(betas_np):
                 return float(_jax_negll(jnp.array(betas_np, dtype=jnp.float64)))
@@ -500,7 +662,10 @@ class LatentClassMixedLogit:
                 log_prior = np.log(np.full(self.n_classes, 1.0 / self.n_classes))
                 log_joint = log_choice + log_prior[None, :]
                 log_marg = logsumexp(log_joint, axis=1)
-                return -float(log_marg.sum())
+                ll = float(log_marg.sum())
+                ll -= self._regularize_l2_betas(betas)
+                ll -= self._regularize_l1_betas(betas)
+                return -ll
 
         K_flat = sum(self._Ks)
         print(
@@ -561,6 +726,10 @@ class LatentClassMixedLogit:
         log_denom = logsumexp(log_joint, axis=1, keepdims=True)
         posterior = np.exp(log_joint - log_denom)
         loglik = float(log_denom.sum())
+        loglik -= self._regularize_l2_betas(betas)
+        loglik -= self._regularize_l1_betas(betas)
+        loglik -= self._regularize_l2_gammas(gammas)
+        loglik -= self._regularize_l1_gammas(gammas)
 
         new_class_probs = self._normalize_class_probs(posterior.mean(axis=0))
 
@@ -585,7 +754,12 @@ class LatentClassMixedLogit:
             priors = np.broadcast_to(class_probs[None, :], (self.N, self.n_classes))
 
         log_joint = log_choice + np.log(np.clip(priors, 1e-300, None))
-        return float(logsumexp(log_joint, axis=1).sum())
+        ll = float(logsumexp(log_joint, axis=1).sum())
+        ll -= self._regularize_l2_betas(betas)
+        ll -= self._regularize_l1_betas(betas)
+        ll -= self._regularize_l2_gammas(gammas)
+        ll -= self._regularize_l1_gammas(gammas)
+        return ll
 
     def _fit_em_once(self, rng, betas0=None, class_probs0=None, gammas0=None):
         betas = self._make_initial_betas(rng, betas0=betas0)
@@ -607,6 +781,10 @@ class LatentClassMixedLogit:
             log_denom = logsumexp(log_joint, axis=1, keepdims=True)
             posterior = np.exp(log_joint - log_denom)
             loglik = float(log_denom.sum())
+            loglik -= self._regularize_l2_betas(betas)
+            loglik -= self._regularize_l1_betas(betas)
+            loglik -= self._regularize_l2_gammas(gammas)
+            loglik -= self._regularize_l1_gammas(gammas)
 
             class_probs = self._normalize_class_probs(posterior.mean(axis=0))
             for c in range(self.n_classes):
@@ -882,15 +1060,32 @@ class LatentClassMixedLogit:
         if maxiter is None:
             maxiter = max(100, 100 * len(params0))
 
-        def _neg_ll(params):
-            return -self._full_loglik(params)
-
-        result = minimize(
-            _neg_ll,
-            params0,
-            method="L-BFGS-B",
-            options={"maxiter": maxiter, "ftol": self.tol},
-        )
+        jax_obj = self._build_jax_full_objective()
+        if jax_obj is not None:
+            _jax_func, _jax_grad = jax_obj
+
+            def _neg_ll_jax(params):
+                b = self.jnp.asarray(params, dtype=self.jnp.float64)
+                v, g = _jax_grad(b)
+                return float(v), np.asarray(g, dtype=float)
+
+            result = minimize(
+                _neg_ll_jax,
+                params0,
+                method="L-BFGS-B",
+                jac=True,
+                options={"maxiter": maxiter, "ftol": self.tol},
+            )
+        else:
+            def _neg_ll(params):
+                return -self._full_loglik(params)
+
+            result = minimize(
+                _neg_ll,
+                params0,
+                method="L-BFGS-B",
+                options={"maxiter": maxiter, "ftol": self.tol},
+            )
 
         params = result.x
         offset = C - 1
@@ -970,7 +1165,7 @@ class LatentClassMixedLogit:
         else:
             base_beta = self.class_betas[source_idx]
             rng = np.random.default_rng(self.random_state + next_classes)
-            jitter = rng.normal(scale=jitter_scale, size=self.K)
+            jitter = rng.normal(scale=jitter_scale, size=base_beta.shape[0])
             new_betas = np.vstack([self.class_betas, base_beta + jitter])
 
         new_probs = np.empty(next_classes, dtype=float)
@@ -1105,7 +1300,10 @@ class LatentClassMixedLogit:
             )
         )
         log_joint = log_chosen + np.log(np.clip(priors, 1e-300, None))
-        return float(logsumexp(log_joint, axis=1).sum())
+        ll = float(logsumexp(log_joint, axis=1).sum())
+        ll -= self._regularize_l2_betas(betas)
+        ll -= self._regularize_l1_betas(betas)
+        return ll
 
     def _numerical_hessian(self, params: np.ndarray, eps: float = 1e-4) -> np.ndarray:
         """Numerical Hessian of the log-likelihood via central finite differences.
@@ -1423,8 +1621,17 @@ class LatentClassMixedLogit:
                 print(f"    class_{idx}: {share:.6f}")
             print("  Coefficients:")
             for c_idx, beta in enumerate(self.class_betas, start=1):
-                for name, value in zip(self.varnames, beta):
+                idx = self._class_specs[c_idx - 1] if self._class_specs is not None else range(len(beta))
+                for k, value in zip(idx, beta):
+                    name = self.varnames[k]
                     print(f"    class_{c_idx}_{name}: {value:.6f}")
+            if self.class_gammas is not None and self._has_membership and self.optimise_membership:
+                gammas_arr = np.asarray(self.class_gammas)
+                print("  Membership Parameters:")
+                for c in range(self.n_classes - 1):
+                    for k in range(gammas_arr.shape[1]):
+                        label = f"gamma_{c + 1}_{self.membership_vars[k]}"
+                        print(f"    {label}: {gammas_arr[c, k]:.6f}")
             return
 
         params   = stats["params"]

searchlibrium-0.0.121/src/SearchLibrium/version.txt

@@ -0,0 +1 @@
+0.0.121

{searchlibrium-0.0.119 → searchlibrium-0.0.121}/src/SearchLibrium.egg-info/PKG-INFO

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

{searchlibrium-0.0.119 → searchlibrium-0.0.121}/src/SearchLibrium.egg-info/SOURCES.txt

@@ -15,6 +15,7 @@ src/SearchLibrium/boxcox_functions.py
 src/SearchLibrium/call_meta.py
 src/SearchLibrium/constraints_builder.py
 src/SearchLibrium/harmony.py
+src/SearchLibrium/hspbil.py
 src/SearchLibrium/latent_class.py
 src/SearchLibrium/main.py
 src/SearchLibrium/main_debug.py

searchlibrium-0.0.119/src/SearchLibrium/version.txt

@@ -1 +0,0 @@
-0.0.119