SearchLibrium 0.0.200__tar.gz → 0.0.201__tar.gz

{searchlibrium-0.0.200/src/SearchLibrium.egg-info → searchlibrium-0.0.201}/PKG-INFO

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

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

{searchlibrium-0.0.200 → searchlibrium-0.0.201}/src/SearchLibrium/harmony.py

@@ -255,106 +255,96 @@ class HarmonySearch(Search):
     ''' A new solution, could either be built from an existing one '''
     ''' or constructed randomly.                                   '''
     ''' ---------------------------------------------------------- '''
-    def build_solution(self, memory, prop):
+    def build_solution(self, memory, harm_rate):
     # {
-        """ This function decides whether to build a new solution from an existing solution
-        in the harmony memory or to generate a completely new solution, based on a random number and the
-        Harmony Memory Consideration Rate (HMCR). If the random number is less than or equal to prop,
-        it selects a proportion of the features from a randomly chosen existing solution to build the new solution.
-        Otherwise, it generates a completely new solution """
-
-
-        bin = [0,1] # Binary values
-        prob = [1-prop, prop]  # Range
-        new_sol = Solution(nb_crit=self.nb_crit)    # Create a new solution object
-
-        # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-        # IS THIS NECESSARY?
-        '''fronts, pareto = None, None
-        if nb_crit > 1: # {
-            memory = self.non_dominant_sorting(memory)
-            fronts = self.get_fronts(memory)
-            pareto = self.get_pareto(fronts, memory)
-        # }'''
-        # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-        if self.param.generator.rand() > prop:
-            new_sol = self.generate_solution()  # Generate a new solution
-        else:
-        # {
-            choice = self.param.generator.choice(len(memory)) # Choose one of the member solutions
-            chosen_sol = memory[choice] # Define reference to the chosen member solution
-
-            # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-            # OPTIONAL CODE.
-            # size = len(chosen_sol['asvars'])
-            # new_asvars_index = self.param.generator.choice(bin, size=size, p=prob)
-            # new_asvars = [i for (i, v) in zip(chosen_sol['asvars'], new_asvars_index) if v]
-            # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-            # Randomly select a subset of the variables from the chosen solution
-            size = int((len(chosen_sol['asvars'])) * prop)
-            new_asvars = list(self.param.generator.choice(chosen_sol['asvars'], size=size, replace=False))
-            n_asvars = sorted(list(set().union(new_asvars, self.param.ps_asvars)))
-            new_asvars = self.remove_redundant_asvars(n_asvars, self.param.trans_asvars, self.param.asvarnames)
-            new_asvars = self.remove_collinear_vars(new_asvars)
-            new_asvars = self._apply_mutual_exclusion_filter(new_asvars)
-            new_sol['asvars'] = new_asvars
-
-            # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-            # Randomly select a subset of the variables from the chosen solution
-            # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-            size = int((len(chosen_sol['isvars'])) * prop)
-            new_isvars = list(self.param.generator.choice(chosen_sol['isvars'], size=size, replace=False))
-            new_isvars = sorted(list(set().union(new_isvars, self.param.ps_isvars)))
-            new_isvars = self.remove_collinear_vars(new_isvars)
-            new_isvars = self._apply_mutual_exclusion_filter(new_isvars)
-            new_sol['isvars'] = new_isvars
-
-            # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-            # Include variables in new solution based on the chosen solution
-            # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-            new_randvars = {k: v for k, v in chosen_sol['randvars'].items() if k in new_asvars}
+        """ Build a new solution using Harmony Memory Consideration.
+
+        For each candidate variable, with probability harm_rate (HMCR), copy
+        the value from a randomly selected harmony in memory; otherwise
+        generate a random value. This is the standard HS approach.
+        """
+        new_sol = Solution(nb_crit=self.nb_crit)
+
+        # Collect all candidate variables
+        all_as_candidates = list(self.param.asvarnames or [])
+        all_is_candidates = list(self.param.isvarnames or [])
+
+        # --- AS variables: for each, decide via HMCR ---
+        new_asvars = []
+        for var in all_as_candidates:
+            if self.param.generator.rand() <= harm_rate:
+                # Copy from memory: randomly pick a harmony and take its value for this var
+                if memory:
+                    chosen = self.param.generator.choice(len(memory))
+                    if var in memory[chosen].get('asvars', []):
+                        new_asvars.append(var)
+            else:
+                # Random generation: include with some base probability
+                if self.param.generator.rand() < 0.3:  # base inclusion probability
+                    new_asvars.append(var)
+
+        # Enforce pre-specified
+        new_asvars = sorted(list(set().union(new_asvars, self.param.ps_asvars or [])))
+        new_asvars = self.remove_redundant_asvars(new_asvars, self.param.trans_asvars, self.param.asvarnames)
+        new_asvars = self.remove_collinear_vars(new_asvars)
+        new_asvars = self._apply_mutual_exclusion_filter(new_asvars)
+        new_sol['asvars'] = new_asvars
+
+        # --- IS variables: same HMCR logic ---
+        new_isvars = []
+        for var in all_is_candidates:
+            if self.param.generator.rand() <= harm_rate:
+                if memory:
+                    chosen = self.param.generator.choice(len(memory))
+                    if var in memory[chosen].get('isvars', []):
+                        new_isvars.append(var)
+            else:
+                if self.param.generator.rand() < 0.3:
+                    new_isvars.append(var)
+
+        new_isvars = sorted(list(set().union(new_isvars, self.param.ps_isvars or [])))
+        new_isvars = self.remove_collinear_vars(new_isvars)
+        new_isvars = self._apply_mutual_exclusion_filter(new_isvars)
+        new_sol['isvars'] = new_isvars
+
+        # --- Derived features (randvars, bcvars, corvars) from chosen harmony ---
+        # Pick one reference harmony for derived features
+        if memory and (new_asvars or new_isvars):
+            ref_sol = memory[self.param.generator.choice(len(memory))]
+
+            # Random coefficients: only for variables that are in asvars
+            new_randvars = {k: v for k, v in ref_sol.get('randvars', {}).items() if k in new_asvars}
             new_sol['randvars'] = new_randvars
 
-            new_bcvars = [var for var in chosen_sol['bcvars']
-                            if var in new_asvars and var not in self.param.ps_corvars]
+            # Box-Cox: only for vars in asvars, not in corvars
+            ref_bcvars = ref_sol.get('bcvars', [])
+            new_bcvars = [v for v in ref_bcvars if v in new_asvars and v not in self.param.ps_corvars]
             new_sol['bcvars'] = new_bcvars
 
-            new_corvars = chosen_sol['corvars']
-            if new_corvars:
-                new_corvars = [var for var in chosen_sol['corvars']
-                                if var in new_randvars.keys() and var not in new_bcvars]
-            new_sol['corvars'] = new_corvars
+            # Correlation: only for randvars, not bcvars
+            ref_corvars = ref_sol.get('corvars', [])
+            if ref_corvars:
+                new_corvars = [v for v in ref_corvars if v in new_randvars and v not in new_bcvars]
+                new_sol['corvars'] = new_corvars
+            else:
+                new_sol['corvars'] = []
 
-            # Take fit_intercept from chosen solution
-            new_sol['asc_ind'] = chosen_sol['asc_ind']
+            # Intercept
+            new_sol['asc_ind'] = ref_sol.get('asc_ind', False)
 
-            # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+            # Latent class specs
             if getattr(self.param, 'allow_latent_corvars', False):
-                if chosen_sol['class_params_spec'] is not None:
-                # {
-                    class_params_spec = copy.deepcopy(chosen_sol['class_params_spec'])
-                    for ii, class_params in enumerate(class_params_spec):
-                    # {
-                        class_params_index = self.param.generator.choice(bin, size=len(class_params), p=prob)
-                        class_params_spec[ii] = np.array([i for (i, v) in zip(class_params, class_params_index) if v],
-                                                         dtype=class_params.dtype)
-                    # }
-                    new_sol['class_params_spec'] = class_params_spec
-                # }
-                # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-                if chosen_sol['member_params_spec'] is not None:
-                # {
-                    member_params_spec = copy.deepcopy(chosen_sol['member_params_spec'])
-                    for ii, member_params in enumerate(member_params_spec):
-                    # {
-                        member_params_index = self.param.generator.choice(bin, size=len(member_params), p=prob)
-                        member_params_spec[ii] = np.array([i for (i, v) in zip(member_params, member_params_index) if v],
-                                                          dtype=member_params.dtype)
-                    # }
-                    new_sol['member_params_spec'] = member_params_spec
-                # }
-            # }
+                if ref_sol.get('class_params_spec') is not None:
+                    new_sol['class_params_spec'] = copy.deepcopy(ref_sol['class_params_spec'])
+                if ref_sol.get('member_params_spec') is not None:
+                    new_sol['member_params_spec'] = copy.deepcopy(ref_sol['member_params_spec'])
+        else:
+            new_sol['randvars'] = {}
+            new_sol['bcvars'] = []
+            new_sol['corvars'] = []
+            new_sol['asc_ind'] = False
+            new_sol['class_params_spec'] = None
+            new_sol['member_params_spec'] = None
 
         self._enforce_mutual_exclusion(new_sol)
         return new_sol
@@ -425,33 +415,79 @@ class HarmonySearch(Search):
 
     ''' ---------------------------------------------------------- '''
     ''' Function. Performs the pitch adjustment operation to       '''
-    ''' fine-tune a given solution. The process includes adding    '''
-    ''' new features or removing existing ones based on a binary   '''
-    ''' indicator. The resulting solution is evaluated and inserted'''
-    ''' The solutions in memory are then filtered                  '''
+    ''' fine-tune a given solution. In classic HS, this is a       '''
+    ''' small perturbation (x_new = x_old +- bw * rand()). For     '''
+    ''' discrete model specification, we make SMALL changes:       '''
+    ''' toggle one variable, change one distribution, etc.         '''
     ''' ---------------------------------------------------------- '''
     def pitch_adjustment(self, sol, pitch):
     # {
         adjusted_solution = copy.deepcopy(sol)
-        perturbations = [self.perturb_asfeature, self.perturb_isfeature, self.perturb_model_t]
-
-        if self.param.allow_random:
-            perturbations.append(self.perturb_randfeature)
-            if adjusted_solution['randvars']:
-                perturbations.append(self.perturb_distribution)
 
+        # Bandwidth controls how many small changes to make
+        # In standard HS: x_new = x_old + bw * randn()
+        # Here: bw ~ pitch, make 0-2 small changes
+        n_changes = 0
+        if self.param.generator.rand() < pitch:
+            n_changes = 1
+            if self.param.generator.rand() < pitch:
+                n_changes = 2
+
+        # Build list of SMALL adjustment operations
+        small_adjustments = []
+
+        # AS variable: add one missing or remove one present (small toggle)
+        if self.param.asvarnames:
+            missing_as = [v for v in self.param.asvarnames if v not in adjusted_solution.get('asvars', [])]
+            present_as = [v for v in adjusted_solution.get('asvars', []) if v not in self.param.ps_asvars]
+            if missing_as:
+                small_adjustments.append(('add_as', lambda s: self._add_one_asvar(s, missing_as)))
+            if present_as:
+                small_adjustments.append(('rem_as', lambda s: self._remove_one_asvar(s, present_as)))
+
+        # IS variable: similar
+        if self.param.isvarnames:
+            missing_is = [v for v in self.param.isvarnames if v not in adjusted_solution.get('isvars', [])]
+            present_is = [v for v in adjusted_solution.get('isvars', []) if v not in self.param.ps_isvars]
+            if missing_is:
+                small_adjustments.append(('add_is', lambda s: self._add_one_isvar(s, missing_is)))
+            if present_is:
+                small_adjustments.append(('rem_is', lambda s: self._remove_one_isvar(s, present_is)))
+
+        # Random coefficient: change distribution of ONE random var
+        if self.param.allow_random and adjusted_solution.get('randvars'):
+            small_adjustments.append(('chg_dist', self.perturb_distribution))
+
+        # Box-Cox: add/remove one
         if self.param.allow_bcvars:
-            perturbations.append(self.perturb_bcfeature)
-
-        if self.param.allow_corvars and adjusted_solution['randvars']:
-            perturbations.append(self.perturb_corfeature)
-
-        perturbation_count = 1 + int(self.param.generator.rand() < max(0.0, min(1.0, pitch)))
-        perturbation_count = min(perturbation_count, len(perturbations))
-        selected_perturbations = self.param.generator.choice(perturbations, size=perturbation_count, replace=False)
-
-        for perturbation in np.atleast_1d(selected_perturbations):
-            adjusted_solution = perturbation(adjusted_solution)
+            missing_bc = [v for v in adjusted_solution.get('asvars', [])
+                         if v not in adjusted_solution.get('bcvars', []) and v not in self.param.ps_corvars]
+            present_bc = [v for v in adjusted_solution.get('bcvars', []) if v not in self.param.ps_bcvars]
+            if missing_bc:
+                small_adjustments.append(('add_bc', lambda s: self._add_one_bcvar(s, missing_bc)))
+            if present_bc:
+                small_adjustments.append(('rem_bc', lambda s: self._remove_one_bcvar(s, present_bc)))
+
+        # Correlation: add/remove one (needs >=2 randvars)
+        if self.param.allow_corvars and len(adjusted_solution.get('randvars', {})) >= 2:
+            missing_cor = [v for v in adjusted_solution.get('randvars', {})
+                          if v not in adjusted_solution.get('corvars', []) and v not in adjusted_solution.get('bcvars', [])]
+            present_cor = [v for v in adjusted_solution.get('corvars', []) if v not in self.param.ps_corvars]
+            if missing_cor:
+                small_adjustments.append(('add_cor', lambda s: self._add_one_corvar(s, missing_cor)))
+            if present_cor:
+                small_adjustments.append(('rem_cor', lambda s: self._remove_one_corvar(s, present_cor)))
+
+        # Model type change (rare)
+        if self.param.avail_models is not None and len(self.param.avail_models) > 1:
+            small_adjustments.append(('chg_model', self.perturb_model_t))
+
+        # Apply n_changes small adjustments
+        for _ in range(n_changes):
+            if not small_adjustments:
+                break
+            _, adj_fn = self.param.generator.choice(small_adjustments)
+            adjusted_solution = adj_fn(adjusted_solution)
 
         adjusted_solution['randvars'] = self.normalize_randvars(
             adjusted_solution['asvars'],
@@ -463,6 +499,39 @@ class HarmonySearch(Search):
         return adjusted_solution, converged
     # }
 
+    # --- Helper methods for small single-variable adjustments ---
+    def _add_one_asvar(self, sol, candidates):
+        var = self.param.generator.choice(candidates)
+        return self.perturb_add_asfeature(sol) if hasattr(self, 'perturb_add_asfeature') else sol
+
+    def _remove_one_asvar(self, sol, candidates):
+        var = self.param.generator.choice(candidates)
+        return self.perturb_remove_asfeature(sol) if hasattr(self, 'perturb_remove_asfeature') else sol
+
+    def _add_one_isvar(self, sol, candidates):
+        var = self.param.generator.choice(candidates)
+        return self.perturb_add_isfeature(sol) if hasattr(self, 'perturb_add_isfeature') else sol
+
+    def _remove_one_isvar(self, sol, candidates):
+        var = self.param.generator.choice(candidates)
+        return self.perturb_remove_isfeature(sol) if hasattr(self, 'perturb_remove_isfeature') else sol
+
+    def _add_one_bcvar(self, sol, candidates):
+        var = self.param.generator.choice(candidates)
+        return self.perturb_add_bcfeature(sol) if hasattr(self, 'perturb_add_bcfeature') else sol
+
+    def _remove_one_bcvar(self, sol, candidates):
+        var = self.param.generator.choice(candidates)
+        return self.perturb_remove_bcfeature(sol) if hasattr(self, 'perturb_remove_bcfeature') else sol
+
+    def _add_one_corvar(self, sol, candidates):
+        var = self.param.generator.choice(candidates)
+        return self.perturb_add_corfeature(sol) if hasattr(self, 'perturb_add_corfeature') else sol
+
+    def _remove_one_corvar(self, sol, candidates):
+        var = self.param.generator.choice(candidates)
+        return self.perturb_remove_corfeature(sol) if hasattr(self, 'perturb_remove_corfeature') else sol
+
     ''' ---------------------------------------------------------- '''
     ''' Function. Extracts the best features                       '''
     ''' ---------------------------------------------------------- '''

{searchlibrium-0.0.200 → searchlibrium-0.0.201}/src/SearchLibrium/search.py

@@ -4934,7 +4934,8 @@ class Search():
         model.setup(X=X, y=y, varnames=varnames, isvars=isvars, alts=alts,
             ids=ids, transvars=transvars, fit_intercept=fit_intercept, init_coeff=init_coeff,
             weights=weights, avail=avail, base_alt=base_alt, maxiter=maxiter, ftol=ftol, gtol=gtol,
-            l2_penalty=2.0, l1_penalty=0.5)
+            l2_penalty=getattr(self.param, 'l2_penalty', 0.5),
+            l1_penalty=getattr(self.param, 'l1_penalty', 0.1))
         model.fit()
     
         return model
@@ -5051,8 +5052,7 @@ class Search():
                 isvars = [i for i in isvars if i not in randvars.keys()]
 
         return isvars, varnames, fit_intercept
-
-    def fit_mxl(self, X, y, varnames, alts, isvars, transvars, ids, panels, randvars, corvars,
+def fit_mxl(self, X, y, varnames, alts, isvars, transvars, ids, panels, randvars, corvars,
             fit_intercept, init_coeff, n_draws, weights, avail, base_alt,  maxiter, ftol, gtol, save_fitted_params,
             halton_opts=None):
     # {
@@ -5063,6 +5063,7 @@ class Search():
         # repair the model..
         isvars, varnames, fit_intercept = self.process_variables(isvars, varnames, randvars)
 
+
         model.setup(X=X, y=y, varnames=varnames, isvars=isvars, alts=alts, transvars=transvars, ids=ids,
             randvars=randvars, panels=panels, fit_intercept=fit_intercept, correlated_vars=corvars, n_draws=n_draws,
             init_coeff=init_coeff, weights=weights, avail=avail,  base_alt=base_alt, maxiter=maxiter,
@@ -5072,7 +5073,9 @@ class Search():
             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),
-            sd_penalty=getattr(self.param, 'sd_penalty', 0.001))
+            sd_penalty=getattr(self.param, 'sd_penalty', 0.001),
+            reg_penalty=getattr(self.param, 'l2_penalty', 0.5),
+            l1_penalty=getattr(self.param, 'l1_penalty', 0.1))
         model.fit()
         
         return model
@@ -5638,12 +5641,17 @@ class Search():
             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])
+            # Apply shrinkage parameters from search parameters
+            model.reg_penalty = getattr(self.param, 'l2_penalty', 0.5)
+            model.l1_penalty = getattr(self.param, 'l1_penalty', 0.1)
             if use_jax:
                 model.fit_jax()
             else:
                 model.fit()
         else:
             model = RandomRegret(df=df, short=False, normalize=True)
+            model.reg_penalty = getattr(self.param, 'l2_penalty', 0.5)
+            model.l1_penalty = getattr(self.param, 'l1_penalty', 0.1)
             if use_jax:
                 model.fit_jax()
             else:
@@ -5745,9 +5753,7 @@ class Search():
         # COMPUTE MAE
         # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
         if self.mae_is_an_objective():
-            # Use the TEST targets/ids (previously reused the training arrays,
-            # which mismatched the test design matrix).
-            X_test = self.param.df_test[all_vars]
+            X_test, _ = self._get_orthogonalized_X(all_vars)  # Use same transformation for test
             y_test = self.param.test_choices if getattr(self.param, 'test_choices', None) is not None else self.param.choices
             ids_test = self.param.test_choice_id if getattr(self.param, 'test_choice_id', None) is not None else self.param.choice_id
             test_model = self.fit_ordered_logit(X=X_test, y=y_test, ids=ids_test, varnames=all_vars)
@@ -5780,6 +5786,10 @@ class Search():
                                 fit_intercept=False,
                                 transvars=transvars or [])
 
+        # Apply shrinkage parameters from search parameters
+        moll.reg_penalty = getattr(self.param, 'l2_penalty', 0.5)
+        moll.l1_penalty = getattr(self.param, 'l1_penalty', 0.1)
+
         moll.fit(method='BFGS')
         moll.report()
         return moll

searchlibrium-0.0.201/src/SearchLibrium/version.txt

@@ -0,0 +1 @@
+0.0.201

{searchlibrium-0.0.200 → searchlibrium-0.0.201/src/SearchLibrium.egg-info}/PKG-INFO

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

@@ -1 +0,0 @@
-0.0.200