metacountregressor 0.1.239__py3-none-any.whl → 0.1.310__py3-none-any.whl

metacountregressor/helperprocess.py

@@ -4,7 +4,7 @@ import pandas as pd
 import csv
 import matplotlib.pyplot as plt
 from scipy import stats as st
-from sklearn.preprocessing import StandardScaler
+from sklearn.preprocessing import StandardScaler, MinMaxScaler
 import os
 import shutil
 plt.style.use('https://github.com/dhaitz/matplotlib-stylesheets/raw/master/pitayasmoothie-dark.mplstyle')
@@ -413,6 +413,10 @@ def transform_dataframe(df, config):
                 # Apply custom function
                 data = data.apply(settings['apply_func'])
             output_df[column] = data
+        elif settings['type'] == 'normalized':
+            # Normalize the column
+            scaler = MinMaxScaler
+            output_df[column] = scaler.fit_transform(df[[column]]).flatten()
 
         elif settings['type'] == 'none':
             # Leave the column unchanged
@@ -447,7 +451,7 @@ def guess_column_type(column_name, series):
             # Otherwise, fallback to continuous standardization
             return {
                 'type': 'continuous',
-                'apply_func': (lambda x: (x - series.mean()) / series.std())  # Z-Score Standardization
+                'apply_func': (lambda x: ((x - series.mean()) / series.std()) + abs(((series - series.mean()) / series.std()).min()) + 0.001)
             }
     else:
         # Default fallback (leave the column unchanged)
@@ -539,6 +543,37 @@ def check_list_type(lst, check_type):
             raise TypeError(f"All elements in the list must be of type {check_type}")
 
 
+def plot_fitness_progress(iterations, iteration_fitnesses, best_fitnesses, average_fitness):
+    """
+    Plots the fitness values over iterations.
+
+    Args:
+        iterations (list): List of iteration numbers.
+        iteration_fitnesses (list): List of fitness values for each iteration.
+        best_fitnesses (list): List of best fitness values across iterations.
+        average_fitness (list): List of average fitness values across iterations.
+    """
+    plt.figure(figsize=(10, 6))
+
+    # Plot iteration fitnesses
+    plt.plot(iterations, iteration_fitnesses, label='Iteration Fitnesses', marker='o', color='blue')
+    # Plot best fitnesses
+    plt.plot(iterations, best_fitnesses, label='Best Fitnesses', marker='s', color='green')
+    # Plot average fitness
+    plt.plot(iterations, average_fitness, label='Average Fitness', marker='d', color='orange')
+
+    # Add labels and title
+    plt.xlabel('Iteration')
+    plt.ylabel('Fitness')
+    plt.title('Fitness Progression Over Iterations')
+    plt.legend()
+    plt.grid(True)
+
+    # Show the plot
+    plt.show()
+
+
+
 def results_printer(results, algorithm='hs', is_multi=1, obj_1='bic', obj_2='MSE'):
     if algorithm == 'hs':
         plt.scatter([x['bic'] for x in results.harmony_memories], [x['MAE'] for x in results.harmony_memories])
@@ -565,6 +600,12 @@ def results_printer(results, algorithm='hs', is_multi=1, obj_1='bic', obj_2='MSE
                     results.iteration, results.iter_solution, results.best_solutions, results.best_fitness,
                     # type: ignore
                     results.best_struct, results.average_best))  # type: ignore
+            plot_fitness_progress(
+                iterations=results.iteration,  # Replace with actual iteration numbers
+                iteration_fitnesses=results.iter_solution,  # Replace with actual iteration fitnesses
+                best_fitnesses=results.best_solutions,  # Replace with the best fitnesses
+                average_fitness=results.average_best  # Replace with average fitnesses
+            )
     elif algorithm == 'sa':
         print(
             'Elapsed time: {}\nIterations: {}'.format(

metacountregressor/main.py

@@ -187,7 +187,7 @@ def main(args, **kwargs):
         a_des, df = helperprocess.set_up_analyst_constraints(df, model_terms)
         # some example argument, these are defualt so the following line is just for claritity
         args = {'algorithm': 'hs', 'test_percentage': 0.15, 'test_complexity': 6, 'instance_number': 1,
-                'val_percentage': 0.15, 'obj_1': 'bic', '_obj_2': 'RMSE_TEST', "MAX_TIME": 6, 'desicions':a_des}
+                'val_percentage': 0.15, 'obj_1': 'bic', '_obj_2': 'RMSE_TEST', "MAX_TIME": 600, 'desicions':a_des, 'is_multi': 1}
         # Fit the model with metacountregressor
         # Step 5: Transform the dataset based on the configuration
         #data_new = helperprocess.transform_dataframe(dataset, config)

metacountregressor/metaheuristics.py

@@ -236,15 +236,17 @@ def differential_evolution(objective_function, initial_slns=None, **kwargs):
     else:
         de = DifferentialEvolution(objective_function, **kwargs)
 
-        iterations, solutions, best_solutions, best_fitness, best_struct, average_best = de.differential_evolution_run(
+        iterations, solutions, best_solutions, best_fitness, best_struct = de.differential_evolution_run(
             initial_slns=initial_slns, mod_init=man)
-
+        AVERAGE_BEST = st.mean(best_solutions)
         end = datetime.now()
+    
         elapsed_time = end - start
+        print(f'elapsed time{elapsed_time}')
         return DifferentialEvolutionResults(elapsed_time=elapsed_time, iteration=iterations,
                                             iter_solution=solutions, best_solutions=best_solutions,
                                             best_fitness=best_fitness,
-                                            best_struct=best_struct, average_best=average_best)
+                                            best_struct=best_struct, average_best=AVERAGE_BEST)
 
 
 def simulated_annealing(objective_function, initial_slns=None, **kwargs):
@@ -403,6 +405,7 @@ class DifferentialEvolution(object):
     """
 
     def __init__(self, objective_function, **kwargs):
+        objective_function.algorithm = 'de'
         self._obj_fun = objective_function
         if self._obj_fun._obj_1 is None:
             print('no objective found, automatically selecting BIC')
@@ -419,6 +422,7 @@ class DifferentialEvolution(object):
         self.iter = kwargs.get('_max_iter', 10000)
         self.cr = kwargs.get('_crossover_perc') or kwargs.get('_cr', 0.2)
         self.instance_number = str(kwargs.get('instance_number', 1))
+        self.instance_number = objective_function.instance_number
         self.get_directory()
 
         self._population = list()
@@ -778,7 +782,7 @@ class SimulatedAnnealing(object):
         """
 
     def __init__(self, objective_function, **kwargs):
-
+        objective_function.algorithm = 'sa'
         self._STEPS_PER_TEMP = int(kwargs.get('STEPS_PER_TEMP', 2)) or int(kwargs.get('_ts', 2))
         self._INITAL_ACCEPT_RATE = float(kwargs.get('INTL_ACPT', 0.5))
         self._NUM_INITIAL_SLNS = int(kwargs.get('_num_intl_slns', 20))
@@ -1245,6 +1249,7 @@ class HarmonySearch(object):
         """
             Initialize HS with the specified objective function. Note that this objective function must implement ObjectiveFunctionInterface.
         """
+        objective_function.algorithm = 'hs'
         self._obj_fun = objective_function
         ## NEW CODE, TRYING TO EXCTACT OUT THE PARAMATERS
         self._hms = kwargs.get('_hms', 20)

metacountregressor/solution.py

@@ -30,9 +30,11 @@ from scipy.special import gammaln
 from sklearn.metrics import mean_absolute_error as MAE
 from sklearn.metrics import mean_squared_error as MSPE
 from statsmodels.tools.numdiff import approx_fprime, approx_hess
+
 from sklearn.preprocessing import StandardScaler, MinMaxScaler
 from texttable import Texttable
 import time
+
 try:
     from ._device_cust import device as dev
     from .pareto_file import Pareto, Solution
@@ -122,14 +124,16 @@ class ObjectiveFunction(object):
 
     def __init__(self, x_data, y_data, **kwargs):
         self.gbl_best = 1000000.0
+        self.run_numerical_hessian = kwargs.get('r_nu_hess', False)
+        self.run_bootstrap =  kwargs.get('run_bootstrap', False)
         self.linear_regression = kwargs.get('linear_model', False)
-        self.reg_penalty = 0
+        self.reg_penalty = kwargs.get('reg_penalty',1)
         self.power_up_ll = False
         self.nb_parma = 1
         self.bic = None
         self.other_bic = False
         self.test_flag = 1
-        self.no_extra_param =1 #if true, fix dispersion. w
+        self.no_extra_param =0  #if true, fix dispersion. w
         if self.other_bic:
             print('change this to false latter ')
 
@@ -151,7 +155,7 @@ class ObjectiveFunction(object):
         self.rdm_fit = None
         self.rdm_cor_fit = None
         self.dist_fit = None
-        self.rounding_point = kwargs.get('decimals_in_coeff', 2)
+        self.rounding_point = kwargs.get('decimals_in_coeff', 4)
         self.MAE = None
         self.best_obj_1 = 1000000.0
         self._obj_1 = kwargs.get('_obj_1', 'bic') 
@@ -174,7 +178,6 @@ class ObjectiveFunction(object):
         self._max_imp = kwargs.get('_max_imp', 90000000)
         self._WIC =  kwargs.get("WIC",10000) # Number of Iterations without Multiobjective Improvement #tod chuck into solution
         self._panels = None
-        self.is_multi = True
         self.method_ll = 'Nelder-Mead-BFGS'
 
         self.method_ll = 'L-BFGS-B'  # alternatives 'BFGS_2', 'BFGS
@@ -185,7 +188,7 @@ class ObjectiveFunction(object):
         self.MP = 0
         # Nelder-Mead-BFGS
 
-        self._max_characteristics = kwargs.get('_max_vars', 30)
+        self._max_characteristics = kwargs.get('_max_vars', 90)
 
         self.beta_dict = dict
         if 'model_terms' in kwargs:
@@ -426,7 +429,7 @@ class ObjectiveFunction(object):
 
 
 
-        self.Ndraws = kwargs.get('Ndraws', 200)
+        self.Ndraws = kwargs.get('Ndraws', 100)
         self.draws1 = None
         self.initial_sig = 1  # pass the test of a single model
         self.pvalue_sig_value = .1
@@ -449,10 +452,10 @@ class ObjectiveFunction(object):
         # define the variables
        
        
-        self._transformations = kwargs.get('_transformations', ["no", "log", "sqrt", "arcsinh"])
+        self._transformations = kwargs.get('_transformations', ["no", "log", "sqrt", "arcsinh", "nil"])
         # self._distribution = ['triangular', 'uniform', 'normal', 'ln_normal', 'tn_normal', 'lindley']
 
-        self._distribution = kwargs.get('_distributions', ['triangular', 'uniform', 'normal', 'ln_normal', 'tn_normal'])
+        self._distribution = kwargs.get('_distributions', ['triangular', 'uniform', 'normal', 'tn_normal'])
 
         if self.G is not None:
             #TODO need to handle this for groups
@@ -485,8 +488,8 @@ class ObjectiveFunction(object):
             model_types = [[0, 1]]  # add 2 for Generalized Poisson
             #model_types = [[0]]
         
-        if self:
-            model_types = [[0]]
+        if self.linear_regression:
+            model_types = [[1]]
             self.grad_yes = False
             
             print(f'Linear Model Selected: turning off gradient calculation')
@@ -494,6 +497,11 @@ class ObjectiveFunction(object):
 
         model_t_dict = {'Poisson':0,
                         "NB":1}
+        if self.linear_regression:
+        # Rename key "NB" to "sigma" if it exists in the dictionary
+            if "NB" in model_t_dict:
+                model_t_dict["sigma"] = model_t_dict.pop("NB")
+
         # Retrieve the keys (model names) corresponding to the values in model_types
         model_keys = [key for key, value in model_t_dict.items() if value in model_types[0]]
         # Print the formatted result
@@ -503,6 +511,7 @@ class ObjectiveFunction(object):
 
         self._model_type_codes = ['p', 'nb',
                                   'gp', "pl", ["nb-theta", 'nb-dis']]
+        self.update_model_type_codes()
         self._variable = [True] * len(self._discrete_values)
         self._lower_bounds = [None] * \
                              len(self._discrete_values)  # TODO have continus
@@ -522,7 +531,18 @@ class ObjectiveFunction(object):
 
         self.solution_analyst = None
 
+    def update_model_type_codes(self):
+        if self.linear_regression:
+            # Recursively update all occurrences of 'nb' to 'sigma'
+            def replace_nb_with_sigma(item):
+                if isinstance(item, list):
+                    return [replace_nb_with_sigma(sub_item) for sub_item in item]
+                elif item == 'nb':
+                    return 'sigma'
+                return item
 
+            # Update the _model_type_codes list
+            self._model_type_codes = replace_nb_with_sigma(self._model_type_codes)
 
 
     def over_ride_self(self, **kwargs):
@@ -584,6 +604,7 @@ class ObjectiveFunction(object):
         self.set_defined_seed(42)  # Set a specific seed
 
         modified_fit = self.modify_initial_fit(manual_fit)  # Modify the initial fit based on manual_fit
+        self.significant = 1
         self.makeRegression(modified_fit)  # Perform regression with the modified fit
 
 
@@ -592,11 +613,12 @@ class ObjectiveFunction(object):
         Function to for proceccing testing, and finding a suitable initial coefficient (linear intercept)
         """
         if hard_code:
+            # Grouped Terrs TODO
             manual_fit_spec = {
                 'fixed_terms': ['Constant', 'US', 'RSMS', 'MCV'],
                 'rdm_terms': ['RSHS:normal', 'AADT:normal', 'Curve50:normal'],
                 'rdm_cor_terms': [],
-                'grouped_terms': [],
+                'group_rdm': [],
                 'hetro_in_means': [],
                 'transformations': ['no', 'log', 'log', 'no', 'no', 'no', 'no'],
                 'dispersion': 1
@@ -618,7 +640,7 @@ class ObjectiveFunction(object):
                         'fixed_terms': ['const'],
                         'rdm_terms': [],
                         'rdm_cor_terms': [],
-                        'grouped_terms': [],
+                        'group_rdm': [],
                         'hetro_in_means': [],
                         'transformations': ['no'],
                         'dispersion': 1
@@ -820,6 +842,10 @@ class ObjectiveFunction(object):
 
         if dispersion == 0:
             return None
+        if dispersion == 1:
+            return np.clip(np.exp(betas[-1]),None, 2)
+            
+
         elif dispersion == 2 or dispersion == 1:
             if self.no_extra_param:
                 return self.nb_parma
@@ -1126,27 +1152,30 @@ class ObjectiveFunction(object):
                     print("-" * 80)
 
                 if solution is not None:
-                    print(f"{self._obj_2}: {self.round_with_padding(solution[self._obj_2], 2)}")
+                    if self.is_multi:
+                        print(f"{self._obj_2}: {self.round_with_padding(solution[self._obj_2], 2)}")
             
             self.pvalues = [self.round_with_padding(
                 x, 2) for x in self.pvalues]
             signif_list = self.pvalue_asterix_add(self.pvalues)
             if model == 1:
-
-                #self.coeff_[-1] = 1/np.exp(self.coeff_[-1])
+                # raise to the exponential
+                self.coeff_[-1] = np.maximum([np.exp(self.coeff_[-1]),2])
                 if self.no_extra_param:
                     self.coeff_ = np.append(self.coeff_, self.nb_parma)
                     self.stderr = np.append(self.stderr, 0.00001)
                     self.zvalues = np.append(self.zvalues, 50)
 
-                elif self.coeff_[-1] < 0.25:
-                    print(self.coeff_[-1], 'Warning Check Dispersion')
-                    print(np.exp(self.coeff_[-1]))
+                #elif self.coeff_[-1] < 0.25:
+                    #print(self.coeff_[-1], 'Warning Check Dispersion')
+                    #print(f'dispession is para,aters {np.exp(self.coeff_[-1])}')
                     #self.coeff_[-1] = np.exp(self.coeff_[-1])  # min possible value for negbinom
+            
 
 
+    
+            self.coeff_ = self.convert_coefficients(self.coeff_, model)
             self.coeff_ = [self.round_with_padding(x, self.rounding_point) for x in self.coeff_]
-
             self.stderr = [self.round_with_padding(x, 2) for x in self.stderr]
             self.zvalues = [self.round_with_padding(
                 x, 2) for x in self.zvalues]
@@ -1199,6 +1228,7 @@ class ObjectiveFunction(object):
             if model is not None:
                 caption_parts = []
                 if self.algorithm is not None:
+                    
                     caption_parts.append(
                         f"{self._model_type_codes[model]} model found through the {self.algorithm} algorithm.")
 
@@ -1209,7 +1239,8 @@ class ObjectiveFunction(object):
                     caption_parts.append(f"Log-Likelihood: {self.round_with_padding(self.log_lik, 2)}")
 
                 if solution is not None:
-                    caption_parts.append(f"{self._obj_2}: {self.round_with_padding(solution[self._obj_2], 2)}")
+                    if self.is_multi:
+                        caption_parts.append(f"{self._obj_2}: {self.round_with_padding(solution[self._obj_2], 2)}")
 
                 caption = " ".join(caption_parts)
                 # print(latextable.draw_latex(table, caption=caption, caption_above = True))
@@ -1549,7 +1580,12 @@ class ObjectiveFunction(object):
             fixed_vars, random_vars, random_var_cor)  # TODO handle distrubution
 
         distributions = alpha_rdm.copy()
-        transformations = ['no'] * len(alpha)  # todo add transformations
+        if self.linear_regression:
+
+            transformations = ['nil'] * len(alpha)  # todo add transformations
+        else:
+            transformations = ['no'] * len(alpha)  # todo add transformations
+
         cnt = 0
         joined_alpha = np.add(alpha_rdm, alpha_rdm_cor)
         for i, x in enumerate(joined_alpha):
@@ -1961,7 +1997,7 @@ class ObjectiveFunction(object):
                 subpvalues = pvalues.copy()
             else:
                 slice_this_amount = self.num_dispersion_params(dispersion)
-                slice_this_amount = 0  # TODO handle this
+                
                 if pvalues[-1] > sig_value:
                     vio_counts += 1
                 subpvalues = pvalues[:-slice_this_amount].copy()
@@ -3253,6 +3289,35 @@ class ObjectiveFunction(object):
         print('output', out)
         return out
 
+    def custom_betas_to_penalise(self, params, dispersion):
+        num_params = self.get_num_params()
+        skip_count = sum(num_params[:2])
+        betas_start = params[:skip_count]
+        if dispersion:
+            betas_end = params[-dispersion:]
+            betas_ = np.concatenate((betas_start,betas_end))
+            return betas_
+        else: return betas_start
+
+
+    def convert_coefficients(self, params, dispersion):
+        num_params = self.get_num_params()
+        skip_count = sum(num_params[:2])
+        remain_params = num_params[2:]
+        params[skip_count:skip_count+remain_params[1]] = np.abs(params[skip_count:skip_count+remain_params[1]])
+        return params
+            
+        
+
+    def custom_penalty(self, params, penalty):
+        num_params = self.get_num_params()
+        skip_count = sum(num_params[:2])
+        
+        for i in params[skip_count:-1]:
+            if i < 0.25:
+                penalty += self.reg_penalty*np.maximum(0, 2.25 -i)**2
+        return penalty
+
     # p is the paramaterisation GP1 is at 0
     def general_poisson(self, mu, y, nu, p=0):  # TODO laxywhere??
 
@@ -3915,8 +3980,10 @@ class ObjectiveFunction(object):
 
         
         if dispersion:
+            sigma = dispersion
             eta=  np.dot(Xd, params_main)[:, :, None] + np.array(offset[:, :, :])
 
+            epsilon = np.random.normal(loc=0, scale=sigma, size=eta.shape)
             #eta=  np.dot(Xd, params_main)[:, :, None] + np.array(offset[:, :, :])+dispersion
             #print('check if this holds size')
         else:
@@ -4591,6 +4658,41 @@ class ObjectiveFunction(object):
         pass
         """
         pass
+    def _linear_logliklihood(self, y, eta, sigma):
+        """
+        Calculate the log-likelihood for a linear regression model with random parameters.
+
+        Parameters:
+        y (np.ndarray): Observed responses (n_samples,).
+        eta (np.ndarray): Predicted values (linear predictor) (n_samples, 1, n_draws).
+        sigma (float): Standard deviation of the error term.
+
+        Returns:
+        float: The log-likelihood value aggregated across all draws.
+        """
+        n_samples, _, n_draws = eta.shape  # Number of observations and draws
+
+        # Repeat y to match the shape of eta
+        y_repeated = np.repeat(y, n_draws, axis=2)  # Shape (n_samples, 1, n_draws)
+
+        # Calculate residuals for each draw
+        residuals = y_repeated - eta  # Shape (n_samples, 1, n_draws)
+
+        # Calculate the residual sum of squares (RSS) for each draw
+        rss = np.sum(residuals ** 2, axis=(0, 1))  # Shape (n_draws,)
+
+        # Log-likelihood for each draw
+        log_likelihood_per_draw = (
+            -0.5 * n_samples * np.log(2 * np.pi)  # Constant term
+            - 0.5 * n_samples * np.log(sigma**2)  # Variance term
+            - 0.5 * rss / sigma**2                # Residual term
+        )  # Shape (n_draws,)
+
+        # Aggregate across draws (e.g., take the mean log-likelihood)
+        log_likelihood_value = np.mean(log_likelihood_per_draw)
+
+        return log_likelihood_value
+
     def _loglik_gradient(self, betas, Xd, y, draws=None, Xf=None, Xr=None, batch_size=None, return_gradient=False,
                          return_gradient_n=False, dispersion=0, test_set=0, return_EV=False, verbose=0, corr_list=None,
                          zi_list=None, exog_infl=None, draws_grouped=None, Xgroup=None, model_nature=None, kwarg=None,
@@ -4649,13 +4751,21 @@ class ObjectiveFunction(object):
                 if self.is_dispersion(dispersion):
                     penalty, main_disper = self._penalty_dispersion(dispersion, main_disper, eVd, y, penalty,
                                                                     model_nature)
+                    b_pen = self.custom_betas_to_penalise(betas, dispersion)
+                    penalty =  self.regularise_l2(betas) + self.regularise_l1(betas)
+                    penalty = self.custom_penalty(betas, penalty)
 
                     betas[-1] = main_disper
 
+                b_pen = self.custom_betas_to_penalise(betas, dispersion)
+                penalty =  self.regularise_l2(betas) + self.regularise_l1(betas)
+                penalty = self.custom_penalty(betas, penalty)
+
                 if self.linear_regression:
                     # LINEAR MODEL PROCESS
-                    mse = np.mean((y - eVd) ** 2)
-                    return mse
+                    mse = self._linear_logliklihood(y, eVd, main_disper)
+                    #mse = np.mean((y - eVd) ** 2)
+                    return (-mse + penalty)*self.minimize_scaler
 
                 ### GLM PROCESS ########
                 llf_main = self.loglik_obs(
@@ -4671,7 +4781,10 @@ class ObjectiveFunction(object):
 
                     loglik += 2*loglik
                     print('am i powering up')
-                penalty =  self.regularise_l2(betas)
+                
+                b_pen = self.custom_betas_to_penalise(betas, dispersion)
+                penalty =  self.regularise_l2(betas) + self.regularise_l1(betas)
+                penalty = self.custom_penalty(betas, penalty)
 
                 if not np.isreal(loglik):
                     loglik = - 10000000.0
@@ -4888,12 +5001,24 @@ class ObjectiveFunction(object):
                 betas_hetro_sd = None
 
             Vdr = dev.cust_einsum("njk,nkr -> njr", Xdr, Br)  # (N,P,R)
-            if self:
+            if self.linear_regression:
                 ### LINEAR MODEL WAY #######
                 eVd = np.clip(
                 Vdf[:, :, None] + Vdr + Vdh + dev.np.array(offset), None, None)
-                mse = np.mean((y - eVd) ** 2)
-                return mse
+                main_disper = self.get_dispersion_paramaters(betas, dispersion)
+                penalty, main_disper = self._penalty_dispersion(
+                    dispersion, main_disper, eVd, y, penalty, model_nature)
+                error_term = np.random.normal(loc=0, scale=main_disper, size=eVd.shape)
+                b_pen = self.custom_betas_to_penalise(betas, dispersion)
+                penalty += self.regularise_l2(b_pen) + self.regularise_l1(b_pen)
+                #penalty = 0
+                penalty = self.custom_penalty(betas, penalty)
+                    # LINEAR MODEL PROCESS
+                mse = self._linear_logliklihood(y, eVd, main_disper)
+                    #mse = np.mean((y - eVd) ** 2)
+                    
+                return -mse + penalty
+                
 
             ##### GLM WAY #####
             eVd = dev.np.exp(np.clip(
@@ -4935,11 +5060,12 @@ class ObjectiveFunction(object):
             proba_ = proba_n.sum(axis =1)
             
             """""
-            betas_last = betas[-1]
+            main_disper = self.get_dispersion_paramaters(betas, dispersion)
+            
 
             # print(betas_last)
             proba_, proba_n = self.prob_obs_draws_all_at_once(
-                eVd, np.atleast_3d(y), betas_last, dispersion)
+                eVd, np.atleast_3d(y), main_disper, dispersion)
             # self._prob_product_against_panels()
 
             # print(top_stats)
@@ -4959,7 +5085,7 @@ class ObjectiveFunction(object):
             if self.power_up_ll:
                 penalty += self.regularise_l2(betas)
 
-            penalty += self.regularise_l2(betas)
+            penalty += self.regularise_l2(betas) + self.regularise_l1(betas)
             if not return_gradient:
 
                 output = ((-loglik + penalty)*self.minimize_scaler,)
@@ -5022,6 +5148,11 @@ class ObjectiveFunction(object):
         else:
             return -self.reg_penalty*sum(np.square(betas.copy()))
 
+    def regularise_l1(self, betas, backwards = False):
+        if backwards == False:
+            return self.reg_penalty*sum(np.square(betas.copy()))
+        else:
+            return -self.reg_penalty*sum(np.abs(betas.copy()))
 
     def _concat_gradients(self, gr_f):
         gr = np.concatenate((gr_f), axis=1)
@@ -5474,15 +5605,42 @@ class ObjectiveFunction(object):
         return covariance
 
 
+        # Numerical Hessian (finite differences)
+    def numerical_hessian_post(self, f, theta, epsilon=1e-5):
+        n = len(theta)
+        hessian = np.zeros((n, n))
+        for i in range(n):
+            for j in range(n):
+                theta_ij_plus = theta.copy()
+                theta_ij_minus = theta.copy()
+                theta_ij_plus[i] += epsilon
+                theta_ij_plus[j] += epsilon
+                theta_ij_minus[i] += epsilon
+                theta_ij_minus[j] -= epsilon
+
+                f_ij_plus = f(theta_ij_plus)
+                f_ij_minus = f(theta_ij_minus)
+                f_original = f(theta)
+
+                hessian[i, j] = (f_ij_plus - 2 * f_original + f_ij_minus) / (epsilon ** 2)
+        return hessian
+
+
     def _post_fit_ll_aic_bic(self, optim_res, verbose=1, robust=False, simple_fit=True, is_dispersion=0):
         # sample_size = len(self._x_data) - len(optim_res['x']) -1
         sample_size = len(self._x_data)
         convergence = optim_res['success']
         coeff_ = optim_res['x']
         penalty = 0
-        for i in coeff_:  # pvalue penalty should handle this
-            if abs(i) > 120:
-                penalty += abs(i)
+        stderr_opg = None
+        if self.run_numerical_hessian:
+            
+            stderr_opg = self.stderr
+
+        
+
+
+
         if 'hess_inv' in optim_res:
             covariance = self._robust_covariance(optim_res['hess_inv'], optim_res['grad_n']) \
                 if robust else optim_res['hess_inv']
@@ -5491,21 +5649,14 @@ class ObjectiveFunction(object):
         covariance = self.handle_covariance(covariance)
         covariance = np.clip(covariance, 0, None)
         stderr = np.sqrt(np.diag(covariance))
-        # stderr =  [if np.abs(optim_res['x'][i]) >.1 else min(np.abs(optim_res['x'][i]/1.5), stderr[i]) for i in range(len(optim_res['x']))]
-        # stderr = [if np.abs(optim_res['x'][i]) > 0.1 else min(np.abs(optim_res['x'][i]/1.5), stderr[i]) for i in range(len(optim_res['x']))]
-        # stderr = [np.min(np.abs(optim_res['x'][i]/random.uniform(1.8, 3)), stderr[i]) if i > len(self.none_handler(self.fixed_fit)) and np.abs(optim_res['x'][i] > 0.2) else stderr[i] for i in range(len(optim_res['x']))]
+        if stderr_opg is not None:
+            stderr = np.minimum(stderr, stderr_opg)
+
+        
+       
         if is_dispersion:
             stderr[-1] = random.uniform(0.001, 0.005)
-        if simple_fit == False:
-            # gets the number of parmas before the correlations
-            pre_cor_pams = sum(self.get_num_params()[:3])
-            # gets the number of correlated rpm
-            post_cor_pams = sum(self.get_num_params()[:5])
-
-
-            # this calculation takes into account the correlated rpms distinct values
-            for i in range(pre_cor_pams, post_cor_pams):
-                stderr[i] = stderr[i] / np.sqrt(sample_size)
+        
 
         if np.isnan(stderr).any():
             raise ValueError("Error: Matrix contains NaN values")
@@ -5518,6 +5669,9 @@ class ObjectiveFunction(object):
             optim_res['fun'] = 10.0 ** 10
         if self.power_up_ll:
             loglikelihood =-optim_res['fun']/2 - penalty
+        elif self.linear_regression:
+            loglikelihood= -optim_res['fun']
+    
         else:
             loglikelihood = -optim_res['fun']/self.minimize_scaler - penalty
 
@@ -5792,6 +5946,9 @@ class ObjectiveFunction(object):
         else:
             self.draws = 0
     
+    def hessian_loglik_function(self, params, *args):
+        return self._loglik_gradient(params, *args)
+
     def _run_optimization(self, XX, y, dispersion, initial_params, bounds, tol, mod):
         """
         Run the optimization process with draws logic and update the Solution object.
@@ -5817,11 +5974,15 @@ class ObjectiveFunction(object):
         draws_grouped = self._prepare_grouped_draws(XG, mod) if XG is not None else None
 
         # Optimization method and options
-        method = self.method_ll
-        print('updataing methods')
-        method = 'Nelder-Mead-BFGS'
-        options = {'gtol': tol['gtol'], 'ftol': tol['ftol'], 'maxiter': 2000}
+        method = self.method_ll if bounds is None else 'L-BFGS-B'
+        
 
+        #method = 'Nelder-Mead-BFGS'
+        options = {'gtol': tol['gtol'], 'ftol': tol['ftol'], 'maxiter': 20000}
+        args=(
+                X, y, draws, X, Xr, self.batch_size, self.grad_yes, self.hess_yes, dispersion, 0, False, 0,
+                self.rdm_cor_fit, None, None, draws_grouped, XG, mod
+            )
         # Run optimization
         optimization_result = self._minimize(
             self._loglik_gradient,
@@ -5832,12 +5993,126 @@ class ObjectiveFunction(object):
             ),
             method=method,
             bounds=bounds,
-            tol=tol.get('ftol', 1e-8),  # Use 'ftol' as the default tolerance
+            tol=tol.get('ftol', 1e-6),  # Use 'ftol' as the default tolerance
             options=options
         )
+        if optimization_result.message == 'NaN result encountered.':
+            optimization_result = self._minimize(self._loglik_gradient,
+            initial_params,
+            args=(
+                X, y, draws, X, Xr, self.batch_size, self.grad_yes, self.hess_yes, dispersion, 0, False, 0,
+                self.rdm_cor_fit, None, None, draws_grouped, XG, mod
+            ),
+            method='Nelder-Mead-BFGS',
+            bounds=bounds,
+            tol=tol.get('ftol', 1e-4),  # Use 'ftol' as the default tolerance
+            options=options
+            )
+
+
+        if self.run_numerical_hessian:
+            std_errors = self.bootstrap_std_dev(
+                initial_params=optimization_result.x,
+                XX=XX,
+                y=y,
+                dispersion=dispersion,
+                bounds=bounds,
+                tol=tol,
+                mod=mod,
+                n_bootstraps=5
+            )
+            self.stderr = std_errors
+            
+
+
+
+       
+
+        # Run the bootstrap to calculate standard errors
+        if self.run_bootstrap:
+
+            std_errors = self.bootstrap_std_dev(
+                initial_params=optimization_result.x,
+                XX=XX,
+                y=y,
+                dispersion=dispersion,
+                bounds=bounds,
+                tol=tol,
+                mod=mod,
+                n_bootstraps=100
+            )
+            self.stderr = std_errors
+
+        
+
+    
         return optimization_result
 
+
    
+
+    def bootstrap_std_dev(self, initial_params, XX, y, dispersion, bounds, tol, mod, n_bootstraps=100):
+        """
+        Perform bootstrap resampling to estimate the standard deviations of the parameters.
+
+        Parameters:
+            self: Reference to the class instance.
+            initial_params: Initial parameter estimates from the optimization.
+            XX: Design matrix.
+            y: Observed outcomes.
+            dispersion: Dispersion parameter (0=Poisson, 1=NB, 2=GP).
+            bounds: List of bounds for each parameter.
+            tol: Tolerance for the optimization process (dictionary with ftol and gtol).
+            mod: Dictionary containing additional data.
+            n_bootstraps: Number of bootstrap resamples (default=100).
+
+        Returns:
+            std_devs: Standard deviations of the parameter estimates (from bootstrap resampling).
+        """
+        # List to store parameter estimates from each bootstrap iteration
+        bootstrap_estimates = []
+
+        # Extract design matrices and additional components from `mod`
+        X, Xr, XG = mod.get('X'), mod.get('Xr'), mod.get('XG')
+        distribution = mod.get('dist_fit')
+
+        # Prepare draws
+        draws = self._prepare_draws(Xr, distribution)
+        draws_grouped = self._prepare_grouped_draws(XG, mod) if XG is not None else None
+
+        # Perform bootstrap iterations
+        for _ in range(n_bootstraps):
+            # Resample data with replacement
+            indices = np.random.choice(len(y), size=len(y), replace=True)
+            X_resampled = X[indices]
+            y_resampled = y[indices]
+
+            # Refit the model with resampled data
+            bootstrap_result = self._minimize(
+                self._loglik_gradient,
+                initial_params,
+                args=(
+                    X_resampled, y_resampled, draws, X_resampled, Xr, self.batch_size, self.grad_yes,
+                    self.hess_yes, dispersion, 0, False, 0, self.rdm_cor_fit, None, None,
+                    draws_grouped, XG, mod
+                ),
+                method=self.method_ll,
+                bounds=bounds,
+                tol=tol.get('ftol', 1e-6),  # Use 'ftol' as the default tolerance
+                options={'gtol': tol['gtol'], 'ftol': tol['ftol'], 'maxiter': 200}
+            )
+
+            # Store the parameter estimates from this bootstrap iteration
+            bootstrap_estimates.append(bootstrap_result.x)
+
+        # Convert bootstrap parameter estimates to a NumPy array
+        bootstrap_estimates = np.array(bootstrap_estimates)
+
+        # Compute the standard deviations of the parameter estimates
+        std_devs = np.std(bootstrap_estimates, axis=0)
+
+        return std_devs
+    
     def _initialize_params_and_bounds(self, XX, dispersion):
         """Initialize parameters and set bounds for optimization."""
         num_params = XX.shape[2]  # Number of features
@@ -5913,6 +6188,7 @@ class ObjectiveFunction(object):
             # Validation metrics if test data is available (in-sample and out-of-sample MAE)
             in_sample_mae = None
             out_sample_mae = None
+            out_sample_validation = None
             if self.is_multi and XX_test is not None:
                 in_sample_mae = self.validation(
                     optimization_result['x'], y, XX, dispersion=dispersion, model_nature=mod, testing=0
@@ -5920,13 +6196,17 @@ class ObjectiveFunction(object):
                 out_sample_mae = self.validation(
                     optimization_result['x'], y_test, XX_test, dispersion=dispersion, model_nature=mod
                 )
+                if self.val_percentage > 0:
+                    out_sample_validation = self.validation(
+                        optimization_result['x'], y_test, XX_test, dispersion=dispersion, model_nature=mod, testing=1
+                    )
 
-            return log_ll, aic, bic, stderr, zvalues, pvalue_alt, in_sample_mae, out_sample_mae
+            return log_ll, aic, bic, stderr, zvalues, pvalue_alt, in_sample_mae, out_sample_mae, out_sample_validation
 
         else:
             # Optimization failed, return None for all metrics
             print("Optimization failed.")
-            return None, None, None, None, None, None, None, None
+            return None, None, None, None, None, None, None, None, None
     def _prepare_data_and_bounds(self, mod, dispersion):
         """Prepare the data matrices, bounds, and initial parameters."""
         # Prepare data matrices
@@ -5963,7 +6243,13 @@ class ObjectiveFunction(object):
         if dispersion == 0:
             return [(-30, 30) for _ in initial_params]
         elif dispersion == 1:
-            return [(-30, 30) for _ in initial_params[:-1]] + [(-1, 5)]
+            num_params = self.get_num_params()
+            skip_count = sum(num_params[:2])
+        
+        
+            bounds = [(-3, 3) for _ in initial_params[:-1]] + [(-1, 1)]
+            bounds[skip_count: -1] = [(0.02, None) for _ in bounds[skip_count: -1]]
+            return bounds
         elif dispersion == 2:
             return [(-5, 5) for _ in initial_params[:-1]] + [(0.1, 0.99)]
         else:
@@ -6010,8 +6296,9 @@ class ObjectiveFunction(object):
 
         # Dispersion adds one additional parameter if enabled
         dispersion_param = 1 if dispersion > 0 else 0
-        return sum(self.get_num_params()) + dispersion_param
-        #return k + kr + kg + kh + dispersion_param
+        total = sum(self.get_num_params()) + dispersion_param
+        return total
+       
     def _build_initial_params(self, num_coefficients, dispersion):
         """
         Build the initial parameter array for optimization.
@@ -6024,15 +6311,20 @@ class ObjectiveFunction(object):
             Initial parameter array.
         """
         # Generate random initial coefficients
-        initial_params = np.random.uniform(-0.05, 0.05, size=num_coefficients)
+        initial_params = np.random.uniform(0.0000, 0.01, size=num_coefficients)
+        parma_sum = sum(self.get_num_params()[:2])
+       
+                       
+        initial_params[parma_sum:-dispersion] =0.0001
 
         # Add dispersion parameter if applicable
         if dispersion > 0:
-            initial_params = np.insert(initial_params, -1, 0.)
+            initial_params[-1] =  0.0
+            #initial_params[0] =3
 
         return initial_params
     
-    def fitRegression(self, mod, dispersion=0, maxiter=4000, batch_size=None, num_hess=False, **kwargs):
+    def fitRegression(self, mod, dispersion=0, maxiter=20000, batch_size=None, num_hess=False, **kwargs):
         """
         Fits a Poisson regression, NB regression (dispersion=1), or GP regression (dispersion=2).
 
@@ -6047,8 +6339,9 @@ class ObjectiveFunction(object):
             obj_1, log_lik, betas, stderr, pvalues, zvalues, is_halton, is_delete
         """
         try:
+            dispersion = mod.get('dispersion', dispersion)
             # Preprocessing
-            tol = {'ftol': 1e-8, 'gtol': 1e-6}
+            tol = {'ftol': 1e-6, 'gtol': 1e-6, 'xtol': 1e-6}
             y, X, Xr, XG, XH = mod.get('y'), mod.get('X'), mod.get('Xr'), mod.get('XG'), mod.get('XH')
 
             # Validate input data
@@ -6073,10 +6366,10 @@ class ObjectiveFunction(object):
             )
             
             # Post-process results
-            log_lik, aic, bic, stderr, zvalues, pvalues, in_sample_mae, out_sample_mae = self._postprocess_results(
+            log_lik, aic, bic, stderr, zvalues, pvalues, in_sample_mae, out_sample_mae, out_sample_val = self._postprocess_results(
                 optimization_result, XX, XX_test, y, mod.get('y_test'), dispersion, mod
             )
-           
+        
             # Extract other outputs
             betas = optimization_result['x'] if optimization_result is not None else None
             is_halton = Xr is not None and Xr.size > 0  # Halton draws used if `Xr` is not empty
@@ -6105,10 +6398,14 @@ class ObjectiveFunction(object):
 
             # Add metrics to solution object
             sol = Solution()  # Assuming Solution is the appropriate class to store results
+            
             sol.add_objective(
                 bic=bic,
                 aic=aic,
                 loglik=log_ll,
+                TRAIN=in_sample_mae,
+                TEST=out_sample_mae,
+                VAL=out_sample_val,
                 num_parm=paramNum,
                 GOF=other_measures
             )
@@ -7125,7 +7422,7 @@ class ObjectiveFunction(object):
                 obj_1[self._obj_1] = 10 ** 100
 
         else:
-            print('The model did not converge')
+            print('Did not converge')
             obj_1[self._obj_1] = 10 ** 100
 
             self.significant = 3
@@ -7369,7 +7666,7 @@ class ObjectiveFunction(object):
             sequence.append(n_th_number)
         return sequence
 
-    def _generate_halton_draws(self, sample_size, n_draws, n_vars, shuffled=False, drop=100, primes=None,
+    def _generate_halton_draws(self, sample_size, n_draws, n_vars, shuffled=False, drop=10, primes=None,
                                long=False) -> np.ndarray:
         """Generate Halton draws for multiple random variables using different primes as base"""
         if primes is None:
@@ -7398,6 +7695,7 @@ class ObjectiveFunction(object):
                     i += 1
                 t += 1
             seq = seq[drop:length + drop]
+            seq = np.clip(seq, 1e-4, 1-1e-4)
             if shuffled:
                 np.random.shuffle(seq)
             return seq
@@ -7451,6 +7749,12 @@ class ObjectiveFunction(object):
             (1 - x) * np.random.gamma(2, scale=theta, size=n)
         return b
 
+ 
+
+
+ 
+
+
     def _compute_derivatives(self, betas, draws, betas_std=None, distribution=None):
         # N, N_draws, K = len(draws)/self.Ndraws, self.Ndraws, len(self._distribution)
         # N, D = draws.shape[0], draws.shape[1]

{metacountregressor-0.1.239.dist-info → metacountregressor-0.1.310.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: metacountregressor
-Version: 0.1.239
+Version: 0.1.310
 Summary: Extensive Testing for Estimation of Data Count Models
 Home-page: https://github.com/zahern/CountDataEstimation
 Author: Zeke Ahern
@@ -17,12 +17,14 @@ Requires-Dist: pandas
 Requires-Dist: scikit-learn>=1.3.1
 Requires-Dist: statsmodels
 Requires-Dist: psutil
+Requires-Dist: pybind11>=2.12
 Dynamic: author
 Dynamic: author-email
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: license
+Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary

{metacountregressor-0.1.239.dist-info → metacountregressor-0.1.310.dist-info}/RECORD

@@ -3,18 +3,18 @@ metacountregressor/_device_cust.py,sha256=759fnKmTYccJm4Lpi9_1reurh6OB9d6q9soPR0
 metacountregressor/app_main.py,sha256=vY3GczTbGbBRalbzMkl_9jVW7RMgEOc6z2Dr1IZJv9c,10014
 metacountregressor/data_split_helper.py,sha256=M2fIMdIO8znUaYhx5wlacRyNWdQjNYu1z1wkE-kFUYU,3373
 metacountregressor/halton.py,sha256=jhovA45UBoZYU9g-hl6Lb2sBIx_ZBTNdPrpgkzR9fng,9463
-metacountregressor/helperprocess.py,sha256=zBpMI2AI7aZ19IZlEnZrvy2VAtJICIcwpq60JL_OIjQ,24428
-metacountregressor/main.py,sha256=xfpKN2w0kePHp_Q2HOPjtG15PLEN1L3sEnDw1PHBquw,23668
+metacountregressor/helperprocess.py,sha256=8PFxX3KTsWH0MlfhniDzKQOJQ63LmJ0eg6cYhQP_fRA,26162
+metacountregressor/main.py,sha256=tGOm8DdbdyDf316qIxDAre6l6GzfJIWYNYIBaSeIemI,23685
 metacountregressor/main_old.py,sha256=eTS4ygq27MnU-dZ_j983Ucb-D5XfbVF8OJQK2hVVLZc,24123
-metacountregressor/metaheuristics.py,sha256=d9jIwCTf2XRoW4UqrJHXBSS1W4XU-TwSeWWVMGo2Jdw,106731
+metacountregressor/metaheuristics.py,sha256=P0Xjlvhp1cEwZFACrqeeets6x8BK7F2iDyu1OfS4bog,107010
 metacountregressor/pareto_file.py,sha256=whySaoPAUWYjyI8zo0hwAOa3rFk6SIUlHSpqZiLur0k,23096
 metacountregressor/pareto_logger__plot.py,sha256=mEU2QN4wmsM7t39GJ_XhJ_jjsdl09JOmG0U2jICrAkI,30037
 metacountregressor/setup.py,sha256=5UcQCCLR8Fm5odA3MX78WwahavxFq4mVD6oq0IuQvAY,936
 metacountregressor/single_objective_finder.py,sha256=jVG7GJBqzSP4_riYr-kMMKy_LE3SlGmKMunNhHYxgRg,8011
-metacountregressor/solution.py,sha256=tz4lizpMuQQrWcQUMwlszt5lIGUwMdJYzOZU6AinZLA,308547
+metacountregressor/solution.py,sha256=h-sHkShA-P5oWJuowCRt0J2wixcxCgoL_tlyM2NCBxQ,319693
 metacountregressor/test_generated_paper2.py,sha256=pwOoRzl1jJIIOUAAvbkT6HmmTQ81mwpsshn9SLdKOg8,3927
-metacountregressor-0.1.239.dist-info/LICENSE.txt,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-metacountregressor-0.1.239.dist-info/METADATA,sha256=h6PCOQbo0Zc7whC7QtFVQsYEZ9Stw-bPMNS4S2e1EHQ,23529
-metacountregressor-0.1.239.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
-metacountregressor-0.1.239.dist-info/top_level.txt,sha256=zGG7UC5WIpr76gsFUpwJ4En2aCcoNTONBaS3OewwjR0,19
-metacountregressor-0.1.239.dist-info/RECORD,,
+metacountregressor-0.1.310.dist-info/licenses/LICENSE.txt,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+metacountregressor-0.1.310.dist-info/METADATA,sha256=ahasic-4LXNYf9FJiny3p97mdTCrFtsEISCm_J-1FAA,23581
+metacountregressor-0.1.310.dist-info/WHEEL,sha256=DK49LOLCYiurdXXOXwGJm6U4DkHkg4lcxjhqwRa0CP4,91
+metacountregressor-0.1.310.dist-info/top_level.txt,sha256=zGG7UC5WIpr76gsFUpwJ4En2aCcoNTONBaS3OewwjR0,19
+metacountregressor-0.1.310.dist-info/RECORD,,

{metacountregressor-0.1.239.dist-info → metacountregressor-0.1.310.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (76.0.0)
+Generator: setuptools (78.0.2)
 Root-Is-Purelib: true
 Tag: py3-none-any