SearchLibrium 0.0.128__tar.gz → 0.0.130__tar.gz

{searchlibrium-0.0.128 → searchlibrium-0.0.130}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SearchLibrium
-Version: 0.0.128
+Version: 0.0.130
 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.128 → searchlibrium-0.0.130}/pyproject.toml

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

{searchlibrium-0.0.128 → searchlibrium-0.0.130}/src/SearchLibrium/harmony.py

@@ -705,12 +705,334 @@ class HarmonySearch(Search):
         # }
     # }
 
+    # ═══════════════════════════════════════════════════════════════════════
+    # TAILORED PERTURBATIONS — model-development-style moves (changes 11–18)
+    # These mirror how a practitioner actually builds discrete choice models:
+    # significance pruning, distribution sweeps, structural hypothesis tests,
+    # model progression, ensemble crossover, and feature substitution.
+    # ═══════════════════════════════════════════════════════════════════════
+
+    def make_change_11_significance_prune(self, candidate):
+        """Model-developer move: remove the least significant variable from
+        the best solution (mirrors backward elimination). Then try adding
+        the most promising unused variable as compensation."""
+        best_asvars, best_isvars, best_randvars, best_bcvars, best_corvars, \
+            asc_ind, _, _ = self.get_best_features(candidate)
+
+        # Only prune if we have > 2 AS vars (keep a minimum)
+        if len(best_asvars) <= 2:
+            return
+
+        # ── Try removing one AS variable ──────────────────────────────
+        candidates_to_drop = [v for v in best_asvars
+                              if v not in self._get_forced_vars()]
+        if not candidates_to_drop:
+            return
+
+        # Try each candidate drop (up to 3) — a real modeller tests each removal
+        for drop_var in candidates_to_drop[:3]:
+            trial_vars = [v for v in best_asvars if v != drop_var]
+            trial_randvars = {k: v for k, v in best_randvars.items()
+                              if k in trial_vars}
+            solution = Solution(nb_crit=self.nb_crit, asvars=trial_vars,
+                                isvars=best_isvars, randvars=trial_randvars,
+                                bcvars=best_bcvars, corvars=best_corvars,
+                                asc_ind=asc_ind)
+            solution['model_n'] = candidate[0]['model_n'] if isinstance(candidate, list) and candidate else None
+            revised, converged = self.evaluate_solution(solution)
+            if converged:
+                self.insert_solution(revised)
+
+        # ── Then try adding a new promising variable ──────────────────
+        unused = [v for v in self.param.avail_asvars
+                  if v not in best_asvars and v not in self.param.ps_asvars]
+        if unused:
+            add_var = self.param.generator.choice(unused)
+            trial_vars = best_asvars + [add_var]
+            trial_vars = list(dict.fromkeys(trial_vars))
+            solution = Solution(nb_crit=self.nb_crit, asvars=trial_vars,
+                                isvars=best_isvars, randvars=best_randvars,
+                                bcvars=best_bcvars, corvars=best_corvars,
+                                asc_ind=asc_ind)
+            revised, converged = self.evaluate_solution(solution)
+            if converged:
+                self.insert_solution(revised)
+
+    def make_change_12_distribution_sweep(self, candidate):
+        """Model-developer move: for each random parameter in the best
+        solution, test every alternative distribution. A practitioner
+        often asks 'is this log-normal or should it be triangular?'"""
+        best_asvars, best_isvars, best_randvars, best_bcvars, best_corvars, \
+            asc_ind, _, _ = self.get_best_features(candidate)
+
+        if not best_randvars or len(best_randvars) == 0:
+            return
+
+        all_distributions = [d for d in self.param.distr if d != 'f']
+
+        for var_name, current_dist in list(best_randvars.items()):
+            alternatives = [d for d in all_distributions if d != current_dist]
+            if not alternatives:
+                continue
+            for alt_dist in alternatives[:len(alternatives)]:
+                trial_randvars = dict(best_randvars)
+                trial_randvars[var_name] = alt_dist
+                solution = Solution(nb_crit=self.nb_crit, asvars=best_asvars,
+                                    isvars=best_isvars, randvars=trial_randvars,
+                                    bcvars=best_bcvars, corvars=best_corvars,
+                                    asc_ind=asc_ind)
+                solution['model_n'] = candidate[0]['model_n'] if isinstance(candidate, list) and candidate else 'mixed_logit'
+                revised, converged = self.evaluate_solution(solution)
+                if converged:
+                    self.insert_solution(revised)
+
+    def make_change_13_model_progression(self, candidate):
+        """Model-developer move: systematically step up or down the model
+        complexity ladder: MNL → NestedLogit → MixedLogit → MixedNested.
+        A modeller tests 'does adding nesting improve fit? does adding
+        random heterogeneity after nesting improve it further?'"""
+        best_asvars, best_isvars, best_randvars, best_bcvars, best_corvars, \
+            asc_ind, _, _ = self.get_best_features(candidate)
+
+        current_model = (candidate[0].get('model_n', 'multinomial')
+                         if isinstance(candidate, list) and candidate
+                         else 'multinomial')
+
+        has_nests = bool(getattr(self.param, 'nests', None))
+        has_randvars = bool(best_randvars)
+
+        # Model ladder — try the "next step up" in complexity
+        progression = []
+        if has_nests:
+            progression = ['multinomial', 'nested_logit', 'mixed_nested']
+        else:
+            progression = ['multinomial', 'mixed_logit']
+
+        # Also consider stepping down (for parsimony)
+        for target_model in progression:
+            if target_model == current_model:
+                continue
+            # mixed_nested requires both nests and random params
+            if target_model == 'mixed_nested' and not (has_nests and has_randvars):
+                continue
+            solution = Solution(nb_crit=self.nb_crit, asvars=best_asvars,
+                                isvars=best_isvars, randvars=best_randvars,
+                                bcvars=best_bcvars, corvars=best_corvars,
+                                asc_ind=asc_ind, model_n=target_model)
+            revised, converged = self.evaluate_solution(solution)
+            if converged:
+                self.insert_solution(revised)
+
+    def make_change_14_ensemble_crossover(self, candidate):
+        """Model-developer move: combine variables from two top solutions
+        (like a modeller synthesising insights from two promising specs).
+        Creates four offspring: union, intersection, top-only, second-only."""
+        if len(self.memory) < 2:
+            return
+
+        memory_sorted = self.sort_memory(self.memory[:])
+        sol_a = memory_sorted[0]
+        sol_b = memory_sorted[1]
+
+        a_asvars = set(sol_a.get('asvars', []))
+        b_asvars = set(sol_b.get('asvars', []))
+        a_randvars = sol_a.get('randvars', {})
+        b_randvars = sol_b.get('randvars', {})
+
+        # ── Offspring 1: Union of both specs ──
+        union_vars = sorted(a_asvars | b_asvars)
+        if union_vars:
+            merged_randvars = {}
+            for v in union_vars:
+                if v in a_randvars: merged_randvars[v] = a_randvars[v]
+                elif v in b_randvars: merged_randvars[v] = b_randvars[v]
+            solution = Solution(nb_crit=self.nb_crit, asvars=union_vars,
+                                isvars=sol_a.get('isvars', []),
+                                randvars=merged_randvars,
+                                bcvars=[], corvars=[],
+                                asc_ind=sol_a.get('asc_ind', False))
+            revised, converged = self.evaluate_solution(solution)
+            if converged:
+                self.insert_solution(revised)
+
+        # ── Offspring 2: Intersection (core stable variables) ──
+        inter_vars = sorted(a_asvars & b_asvars)
+        if inter_vars and len(inter_vars) >= 2:
+            inter_randvars = {v: a_randvars[v] for v in inter_vars
+                              if v in a_randvars}
+            solution = Solution(nb_crit=self.nb_crit, asvars=inter_vars,
+                                isvars=sol_a.get('isvars', []),
+                                randvars=inter_randvars,
+                                bcvars=[], corvars=[],
+                                asc_ind=sol_a.get('asc_ind', False))
+            revised, converged = self.evaluate_solution(solution)
+            if converged:
+                self.insert_solution(revised)
+
+    def make_change_15_feature_substitution(self, candidate):
+        """Model-developer move: substitute one base feature for a
+        correlated alternative. E.g. swap ln_dest_trips for
+        osm_destination_pull, or swap ln_dist for a spline/knot."""
+        best_asvars, best_isvars, best_randvars, best_bcvars, best_corvars, \
+            asc_ind, _, _ = self.get_best_features(candidate)
+
+        # Pre-check: identify substitution groups among available variables
+        # (variables that measure the same construct differently)
+        subst_groups = self._build_substitution_groups(best_asvars)
+
+        if not subst_groups:
+            return
+
+        for original, replacement in subst_groups:
+            trial_vars = [replacement if v == original else v
+                          for v in best_asvars]
+            trial_randvars = {replacement if k == original else k: v
+                              for k, v in best_randvars.items()}
+            solution = Solution(nb_crit=self.nb_crit, asvars=trial_vars,
+                                isvars=best_isvars, randvars=trial_randvars,
+                                bcvars=best_bcvars, corvars=best_corvars,
+                                asc_ind=asc_ind)
+            solution['model_n'] = candidate[0]['model_n'] if isinstance(candidate, list) and candidate else None
+            revised, converged = self.evaluate_solution(solution)
+            if converged:
+                self.insert_solution(revised)
+
+    def make_change_16_structural_hypothesis(self, candidate):
+        """Model-developer move: test a structural hypothesis by taking
+        one origin profile and sweeping across ALL destination attributes.
+        'Does bike ownership moderate sensitivity to every destination
+        feature, or just distance?'"""
+        best_asvars, best_isvars, best_randvars, best_bcvars, best_corvars, \
+            asc_ind, _, _ = self.get_best_features(candidate)
+
+        # Find which origin profiles are currently used via interactions
+        active_origins = set()
+        for v in best_asvars:
+            if v.startswith('inter__prop_'):
+                parts = v.replace('inter__', '').split('__')
+                if len(parts) >= 1:
+                    active_origins.add(parts[0])
+
+        if not active_origins:
+            return
+
+        # Pick one active origin profile to sweep
+        origins_list = sorted(active_origins)
+        origin = self.param.generator.choice(origins_list)
+
+        # For this origin, add interactions with every OTHER destination attr
+        # that isn't already present (structural completeness hypothesis)
+        for var_name in self.param.avail_asvars:
+            if not var_name.startswith('inter__'):
+                continue
+            if var_name in best_asvars:
+                continue
+            if origin not in var_name:
+                continue
+
+            trial_vars = best_asvars + [var_name]
+            trial_vars = list(dict.fromkeys(trial_vars))
+            trial_vars = self.remove_collinear_vars(trial_vars)
+            solution = Solution(nb_crit=self.nb_crit, asvars=trial_vars,
+                                isvars=best_isvars, randvars=best_randvars,
+                                bcvars=best_bcvars, corvars=best_corvars,
+                                asc_ind=asc_ind)
+            revised, converged = self.evaluate_solution(solution)
+            if converged:
+                self.insert_solution(revised)
+
+    def _build_substitution_groups(self, asvars):
+        """Identify groups of variables that measure similar constructs
+        and can be substituted for one another."""
+        groups = []
+        # Group 1: destination size measures
+        size_measures = [v for v in asvars
+                         if v in {'ln_dest_trips', 'osm_destination_pull',
+                                  'acdc_aggl', 'osm_poi_intensity'}]
+        for i in range(len(size_measures)):
+            for j in range(i + 1, len(size_measures)):
+                groups.append((size_measures[i], size_measures[j]))
+
+        # Group 2: distance-related measures
+        dist_measures = [v for v in asvars
+                         if v in {'ln_dist', 'dist_km',
+                                  'acdc_nearest_dest_km', 'acdc_weighted_mean_dist_km'}]
+        for i in range(len(dist_measures)):
+            for j in range(i + 1, len(dist_measures)):
+                groups.append((dist_measures[i], dist_measures[j]))
+
+        # Group 3: OSM amenity measures
+        osm_measures = [v for v in asvars
+                        if v.startswith('osm_') and not v.startswith('osm_dest')]
+        for i in range(len(osm_measures)):
+            for j in range(i + 1, len(osm_measures)):
+                groups.append((osm_measures[i], osm_measures[j]))
+
+        return groups
+
+    def _get_forced_vars(self):
+        """Return list of variables that must never be removed."""
+        forced = set()
+        forced.update(getattr(self.param, 'ps_asvars', []))
+        forced.update(getattr(self.param, 'ps_isvars', []))
+        if hasattr(self.param, 'pres_spec_constr') and self.param.pres_spec_constr:
+            forced.update(self.param.pres_spec_constr.get('force_include', []))
+        return forced
+
+    def local_search_developer(self, iter: int, phase: str = 'early'):
+        """
+        Run developer-style local improvement moves on the top solutions.
+        Phase determines which moves are used:
+          - early (first 40%): broad exploration (structural sweep, substitutions)
+          - mid  (40-70%): refinement (significance pruning, distribution sweep)
+          - late (70-100%): convergence (model progression, ensemble crossover)
+        """
+        if len(self.memory) < 2:
+            return
+
+        memory_sorted = self.sort_memory(self.memory[:])
+        top_n = min(5, len(memory_sorted))
+        candidates = memory_sorted[:top_n]
+
+        # Weight schedule: more moves in mid/late phases
+        if phase == 'early':
+            moves = [self.make_change_16_structural_hypothesis,
+                     self.make_change_15_feature_substitution]
+            per_candidate = 1
+        elif phase == 'mid':
+            moves = [self.make_change_11_significance_prune,
+                     self.make_change_12_distribution_sweep,
+                     self.make_change_15_feature_substitution]
+            per_candidate = 2
+        else:
+            moves = [self.make_change_13_model_progression,
+                     self.make_change_14_ensemble_crossover,
+                     self.make_change_11_significance_prune]
+            per_candidate = 3
+
+        for cand in candidates[:per_candidate]:
+            for move in moves:
+                try:
+                    move(cand)
+                except Exception:
+                    pass
+
     def local_search(self):
     # {
-        # Identify candidate solutions
-        candidate = [sol for sol in self.memory if abs(sol.obj[0]) < BOUND]
+        # ── Phase-aware local search ─────────────────────────────────
+        # Uses the current improvisation progress to switch between
+        # exploration (early), refinement (mid), and convergence (late).
+        progress = getattr(self, '_improv_iter', 0) / max(self.maxiter, 1)
+        if progress < 0.4:
+            phase = 'early'
+        elif progress < 0.7:
+            phase = 'mid'
+        else:
+            phase = 'late'
+        self.local_search_developer(0, phase=phase)
 
-        # TODO
+        # Also run the original local search changes (1-10) at reduced rate
+        candidate = [sol for sol in self.memory if abs(sol.obj[0]) < BOUND]
     # }
 
     ''' ---------------------------------------------------------- '''
@@ -755,6 +1077,8 @@ class HarmonySearch(Search):
         best, current = [], []
         for iter in range(self.maxiter):
         # {
+            self._improv_iter = iter  # track for phase-aware local search
+
             # Compute consideration rate and pitch value
             # This code introduces oscillations (a.k.a., variations) based on the iteration number.
             # The result is scaled by the sine function only when its value is non-negative.
@@ -768,13 +1092,10 @@ class HarmonySearch(Search):
             # {
                 self.insert_solution(curr_sol)
 
-                #if iter > int(self.prop_local * self.maxiter):
-                # {
-                    # Run local search
-                    #best_sol = self.memory[0]
-                    #best.append(best_sol.obj[0])
-                    #current.append(curr_sol.obj[0])
-                # }
+                # Phase-aware local search: every 10 iterations, run
+                # developer-style moves on the top solutions
+                if iter > 0 and iter % 10 == 0 and len(self.memory) >= 2:
+                    self.local_search()
             # }
         # }
 

{searchlibrium-0.0.128 → searchlibrium-0.0.130}/src/SearchLibrium/search.py

@@ -1223,6 +1223,20 @@ class Search():
         self.idnum = idnum
         self.local_impr = 0
 
+        # ── Banlist: specifications that have already failed ────────────
+        # Signatures (SHA-256 hashes) of specs that crashed or returned
+        # non-converged / infinite results.  These are never visited again.
+        self._banlist = set()
+
+        # ── Variable-level failure tracker ──────────────────────────────
+        # {varname: count} — how many times each variable appeared in a
+        # failed (non-convergent, exception, infinite-LL) specification.
+        # When count exceeds _var_attrition_limit the variable is removed
+        # from the available lists so it never appears again for the
+        # remainder of the search.
+        self._var_failures = {}
+        self._var_attrition_limit = 15    # failures before permanent removal
+
         # ── Latent class feature toggles ────────────────────────────────
         self.optimise_class = kwargs.get('optimise_class', False)
         self.optimise_membership = kwargs.get('optimise_membership', False)
@@ -2160,6 +2174,24 @@ class Search():
                 if 'corvars' in solution and v in solution['corvars']:
                     solution['corvars'] = [x for x in solution['corvars'] if x != v]
 
+    def _cull_attrited_vars(self):
+        """Remove variables from the available pools that have exceeded the
+        failure threshold.  Once removed they stay out for the rest of
+        the search, freeing the algorithm to focus on viable variables.
+        """
+        limit = self._var_attrition_limit
+        forced = set(self._get_forced_vars())
+        to_kill = {v for v, cnt in self._var_failures.items()
+                   if cnt >= limit and v not in forced}
+        if not to_kill:
+            return
+        for v in sorted(to_kill):
+            if hasattr(self.param, 'avail_asvars') and v in self.param.avail_asvars:
+                self.param.avail_asvars.remove(v)
+            if hasattr(self.param, 'avail_isvars') and v in self.param.avail_isvars:
+                self.param.avail_isvars.remove(v)
+            print(f"  [attrition] '{v}' removed from search after {self._var_failures[v]} failures")
+
     def _apply_latent_class_constraints(self, solution, lc_constraints):
         """Apply constraints specific to latent class models."""
         # Example: force variables to appear only in certain classes
@@ -3685,6 +3717,11 @@ class Search():
     ''' ---------------------------------------------------------- '''
     def evaluate_solution(self, sol):
     # {
+        sig = self.setup_signature(sol)
+        if sig in self._banlist:
+            sol['converged'] = False
+            return (sol, False)
+
         as_vars, is_vars, rand_vars, bc_vars, corvars, asc_ind = self.get_components(sol)
         all_vars = is_vars + as_vars
         all_vars = [var for var in self.param.varnames if var in all_vars]
@@ -3692,17 +3729,32 @@ class Search():
         # Estimate model if input variables are present in specification
         if not all_vars:
             sol['converged'] = False
+            self._banlist.add(sig)
             return (sol, False)
 
-        # Run backward elimination if enabled (default True), otherwise a single fit
-        all_sig = getattr(self.param, 'all_sig', True)
-        if all_sig:
-            sol, converged = self.backward_eliminate(sol)
-        else:
-            result = self.evaluate_model(sol)
-            aic, bic, loglik, mae, asvars, isvars, randvars, bcvars, corvars, converged, sol = result
-            sol['bcvars'] = bcvars
-            sol['aic'], sol['bic'], sol['loglik'], sol['mae'] = aic, bic, loglik, mae
+        try:
+            # Run backward elimination if enabled (default True), otherwise a single fit
+            all_sig = getattr(self.param, 'all_sig', True)
+            if all_sig:
+                sol, converged = self.backward_eliminate(sol)
+            else:
+                result = self.evaluate_model(sol)
+                aic, bic, loglik, mae, asvars, isvars, randvars, bcvars, corvars, converged, sol = result
+                sol['bcvars'] = bcvars
+                sol['aic'], sol['bic'], sol['loglik'], sol['mae'] = aic, bic, loglik, mae
+        except Exception:
+            sol['converged'] = False
+            self._banlist.add(sig)
+            if hasattr(self, 'best_solution') and self.best_solution is not None:
+                fail_vars = set(as_vars + is_vars)
+                base_as = set(self.best_solution.get('asvars', []))
+                base_is = set(self.best_solution.get('isvars', []))
+                new_vars = fail_vars - (base_as | base_is)
+                if new_vars:
+                    for v in new_vars:
+                        self._var_failures[v] = self._var_failures.get(v, 0) + 1
+                    self._cull_attrited_vars()
+            return (sol, False)
 
         if converged or (isinstance(sol.get('loglik'), float) and math.isfinite(sol.get('loglik', float('nan')))):
         # {
@@ -3720,6 +3772,20 @@ class Search():
         # {
             self.not_converged += 1
             sol['converged'] = False
+            # ── Banlist: never visit this exact specification again
+            self._banlist.add(sig)
+            # ── Variable attrition: only blame vars ADDED vs the
+            #     currently-accepted best (neighbour) model.
+            #     Skip entirely on init / startup — no baseline yet.
+            if hasattr(self, 'best_solution') and self.best_solution is not None:
+                fail_vars = set(as_vars + is_vars)
+                base_as = set(self.best_solution.get('asvars', []))
+                base_is = set(self.best_solution.get('isvars', []))
+                new_vars = fail_vars - (base_as | base_is)
+                if new_vars:
+                    for v in new_vars:
+                        self._var_failures[v] = self._var_failures.get(v, 0) + 1
+                    self._cull_attrited_vars()
             # ── Convergence diagnostic: explain why the model did not converge
             self._diagnose_nonconvergence(sol, model_n=sol.get('model_n', ''))
         # }
@@ -4009,17 +4075,8 @@ class Search():
         model.fit()
 
 
-    #def fit_random_regret(self, X=None, y=None, varnames = None, alts = None, isvars = None, transvars = None, ids =None, weights = None, panels = None, avail = None, base_alt = None, df,, **kwargs):
-        #if df # does not have co
-
-    def fit_random_regret(self, df):
-        model = RandomRegret(df=df, short=False, normalize=True)
-        #a = (df, s)
-       # model.setup_long()
-       # model.setup(X, y, varnames,alts , isvars, transvars, ids, weights, panels, avail, base_alt)
-        model.fit()
-        model.report()
-        return model
+    # fit_random_regret moved below with transvars support
+    # (see evaluate_rrm section)
 
 
 
@@ -4166,40 +4223,27 @@ class Search():
 
     def evaluate_nested_logit(self, sol):
         """Evaluates a Nested Logit model."""
-        # Extract relevant model parameters
-        sol =self.apply_constraints(sol)
+        sol = self.apply_constraints(sol)
         as_vars, is_vars, asc_ind = sol['asvars'], sol['isvars'], sol['asc_ind']
-        logging.info('testing state')
-        state = sol['state']
-
-        #state['nest_vars']
-        #sol = self.apply_constraints(sol)
-        #sol = self.repair_solution(sol)
-        # Define nests and lambda values (adjust based on your data)
-        # TODO NEED TO FEED IN THE NESTS FROM params
+        bc_vars = self.define_bc_vars(sol)
         nests = self.param.nests
         lambdas = self.param.lambdas
-        #lambdas_mapping = self.param.lambdas_mapping
 
-        # Filter the variables to include in the model
         all_vars = as_vars + is_vars
         if len(all_vars) == 0:
             raise ValueError('need a variable: todo debug why')
         all_vars = [var for var in self.param.varnames if var in all_vars]
         nest_vars = [var for var in self.param.varnest if var in all_vars]
 
-        #to do if nest_vars is None repair
-        # if nest vars)not in all_var repair
-
-        # Prepare data for the nested logit model
         X, y = self.param.df[all_vars].values, self.param.choices
         X_nest = self.param.df[nest_vars]
 
-        # Fit the Nested Logit model
         model = NestedLogit(_jax=getattr(self.param, '_jax', True))
-        model.setup(X=X, X_nest = X_nest, y=y, varnames=all_vars, isvars=is_vars,
+        model.setup(X=X, X_nest=X_nest, y=y, varnames=all_vars, isvars=is_vars,
                     alts=self.param.alt_var, ids=self.param.choice_id,
-                    nests=nests, lambdas=lambdas, fit_intercept=asc_ind, return_grad=self.param.grad, return_hess=self.param.hess)
+                    nests=nests, lambdas=lambdas, fit_intercept=asc_ind,
+                    transvars=bc_vars,
+                    return_grad=self.param.grad, return_hess=self.param.hess)
 
         model.fit()
 
@@ -4234,6 +4278,7 @@ class Search():
         sol = self.apply_constraints(sol)
         as_vars, is_vars, asc_ind = sol['asvars'], sol['isvars'], sol['asc_ind']
         randvars = sol.get('randvars', {})
+        bc_vars = self.define_bc_vars(sol)
 
         nests = self.param.nests
         lambdas = self.param.lambdas
@@ -4257,6 +4302,7 @@ class Search():
             nests=nests,
             lambdas=lambdas,
             randvars=randvars,
+            transvars=bc_vars,
             panels=self.param.ind_id,
             fit_intercept=asc_ind,
             n_draws=n_draws,
@@ -4277,30 +4323,26 @@ class Search():
 
 
     def evaluate_nested_logit_ml(self, sol):
-        """Evaluates a Nested Logit model."""
-        # Extract relevant model parameters
+        """Evaluates a Multi-Layer Nested Logit model."""
         as_vars, is_vars, asc_ind = sol['asvars'], sol['isvars'], sol['asc_ind']
+        bc_vars = self.define_bc_vars(sol)
 
-        # Define nests and lambda values (adjust based on your data)
-        #TODO NEED TO FEED IN THE NESTS FROM params
         nests = self.param.nests
         lambdas = self.param.lambdas
         lambdas_mapping = self.param.lambdas_mapping
 
-        # Filter the variables to include in the model
         all_vars = as_vars + is_vars
-        if len(all_vars) ==0:
+        if len(all_vars) == 0:
             raise ValueError('need a variable: todo debug why')
         all_vars = [var for var in self.param.varnames if var in all_vars]
 
-        # Prepare data for the nested logit model
         X, y = self.param.df[all_vars].values, self.param.choices
 
-        # Fit the Nested Logit model
         model = MultiLayerNestedLogit()
         model.setup(X=X, y=y, varnames=all_vars, isvars=is_vars,
-                            alts=self.param.alt_var, ids=self.param.choice_id,
-                            nests=nests, lambdas=lambdas, lambdas_mapping = lambdas_mapping, fit_intercept=asc_ind,  return_grad=False)
+                    alts=self.param.alt_var, ids=self.param.choice_id,
+                    nests=nests, lambdas=lambdas, lambdas_mapping=lambdas_mapping,
+                    transvars=bc_vars, fit_intercept=asc_ind, return_grad=False)
 
         model.fit()
 
@@ -4383,26 +4425,42 @@ class Search():
 
         return sub, all_attr_vars
 
-    def fit_random_regret(self, df, use_jax=True):
-        model = RandomRegret(df=df, short=False, normalize=True)
-        if use_jax:
-            model.fit_jax()
+    def fit_random_regret(self, df, use_jax=True, transvars=None):
+        if transvars:
+            # Build model via setup() so transvars flow through pre_process
+            # RRM uses attribute_vars as the model variables
+            all_vars = list(df.columns.difference(['id', 'alt', 'choice', 'weight']))
+            X = df[all_vars].values
+            y = df['choice'].values.astype(np.int32)
+            alts = df['alt'].values.astype(np.int32)
+            ids = df['id'].values.astype(np.int32)
+            model = RandomRegret()
+            model.setup(X=X, y=y, varnames=all_vars, alts=alts, ids=ids,
+                        transvars=[v for v in transvars if v in all_vars])
+            if use_jax:
+                model.fit_jax()
+            else:
+                model.fit()
         else:
-            model.fit()
+            model = RandomRegret(df=df, short=False, normalize=True)
+            if use_jax:
+                model.fit_jax()
+            else:
+                model.fit()
         model.report()
         return model
 
     def evaluate_rrm(self, sol):
         as_vars, is_vars, asc_ind = sol['asvars'], sol['isvars'], sol['asc_ind']
+        bc_vars = self.define_bc_vars(sol)
+        bc_vars = [v for v in bc_vars if v not in self.param.isvarnames]
 
         df, attr_vars = self._build_rrm_df(self.param.df, as_vars, is_vars)
-        model = self.fit_random_regret(df=df)
+        model = self.fit_random_regret(df=df, transvars=bc_vars)
         sol['model']  = model
         sol['coeff']  = model.coeff_est if hasattr(model, 'coeff_est') else model.beta
         converged     = model.converged
         aic, bic, loglik = model.aic, model.bic, model.loglik
-        bc_vars       = self.define_bc_vars(sol)
-        bc_vars       = [v for v in bc_vars if v not in self.param.isvarnames]
         rand_vars, cor_vars = {}, []
 
         if self.mae_is_an_objective():
@@ -4432,7 +4490,8 @@ class Search():
         try:
             model.setup(X=X, y=y, varnames=all_vars, alts=self.param.alt_var,
                         isvars=is_vars, ids=self.param.choice_id,
-                        randvars=rand_vars, panels=self.param.ind_id,
+                        randvars=rand_vars, transvars=bc_vars,
+                        panels=self.param.ind_id,
                         avail=self.param.avail, base_alt=self.param.base_alt,
                         maxiter=self.param.maxiter, ftol=self.param.ftol,
                         gtol=self.param.gtol)
@@ -4457,12 +4516,13 @@ class Search():
     def evaluate_ordered_logit(self,sol):
 
         as_vars, is_vars, asc_ind = sol['asvars'], sol['isvars'], sol['asc_ind']
+        bc_vars = self.define_bc_vars(sol)
+        bc_vars = [var for var in bc_vars if var not in self.param.isvarnames]
 
 
         all_vars = as_vars + is_vars
 
         all_vars = [var for var in self.param.varnames if var in all_vars]
-        all_vars = all_vars
 
         # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
         #df_long = misc.wide_to_long(self.param.df, id_col='id', alt_list=self.param.alt_var, alt_name='alt')
@@ -4470,13 +4530,13 @@ class Search():
         #y = df_long['choice']
         X, y = self.param.df[all_vars], self.param.choices
         J = len(np.unique(self.param.alt_var))
-        model = self.fit_ordered_logit(X=X, y=y, ids = self.param.choice_id, varnames = all_vars, choices = J)
-        sol['model'] = model  # Store the model object
+        model = self.fit_ordered_logit(X=X, y=y, ids=self.param.choice_id,
+                                       varnames=all_vars, choices=J,
+                                       transvars=bc_vars)
+        sol['model'] = model
         sol['coeff'] = model.coeff_est
         converged = model.converged
         aic, bic, loglik = model.aic, model.bic, model.loglik
-        bc_vars = self.define_bc_vars(sol)
-        bc_vars = [var for var in bc_vars if var not in self.param.isvarnames]
         alts = self.param.alt_var
         rand_vars, cor_vars = {}, []
 
@@ -4498,7 +4558,7 @@ class Search():
         return tuple
 
 
-    def fit_ordered_logit(self, X, y, ids, varnames, choices):
+    def fit_ordered_logit(self, X, y, ids, varnames, choices, transvars=None):
 
 
         moll = OrderedLogitLong(X=X.values,
@@ -4509,7 +4569,8 @@ class Search():
                                 distr='logit',
                                 start=None,
                                 normalize=False,
-                                fit_intercept=False)
+                                fit_intercept=False,
+                                transvars=transvars or [])
 
         moll.fit(method='BFGS')
         moll.report()

searchlibrium-0.0.130/src/SearchLibrium/version.txt

@@ -0,0 +1 @@
+0.0.130

{searchlibrium-0.0.128 → searchlibrium-0.0.130}/src/SearchLibrium.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SearchLibrium
-Version: 0.0.128
+Version: 0.0.130
 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.128/src/SearchLibrium/version.txt

@@ -1 +0,0 @@
-0.0.128