metacountregressor 0.1.34__py3-none-any.whl → 0.1.36__py3-none-any.whl

metacountregressor/solution.py

@@ -144,7 +144,8 @@ class ObjectiveFunction(object):
         self.MAE = None
         self.best_obj_1 = 100000000
         self._obj_1 = 'bic'
-        self._obj_2 = 'MAE'
+        self._obj_2 = 'MSE'
+        self.numerical_hessian_calc = 1 # calculates hessian by statsmodels otherwise scipy
         self.full_model = None
         self.GP_pararameter = 0
         self.is_multi = 0
@@ -518,8 +519,8 @@ class ObjectiveFunction(object):
 
         for_testing_purposes = 0
         if "Manual_Fit" in kwargs and  kwargs['Manual_Fit'] is not None:
-            for_testing_purposes = 0
-            print('off for now turn back on')
+            for_testing_purposes = 1
+            
         if for_testing_purposes:
             self.initial_sig = 1  # pass the test of a single model
             self.pvalue_sig_value = 1
@@ -1055,7 +1056,7 @@ class ObjectiveFunction(object):
             except Exception as e:
                 print(e)
 
-    def summary_alternative(self, long_print=0, model=0, solution=None):
+    def summary_alternative(self, long_print=0, model=0, solution=None, save_state = 0):
         fmt = "{:19} {:13} {:13.10f} {:13.10f}{:13.10f} {:13.3g} {:3}"
         coeff_name_str_length = 19
 
@@ -1075,17 +1076,17 @@ class ObjectiveFunction(object):
             raise Exception
 
         
-        self.pvalues= [self.round_with_padding(x, 2) for x in self.pvalues]
+        #self.pvalues= [self.round_with_padding(x, 2) for x in self.pvalues]
         #self.pvalues= [self.round_with_scientific(x, 2) for x in self.pvalues]
         
         for i in range(len(self.coeff_)):
             signif = ""
         
-            if self.pvalues[i] < 0.01:
+            if float(self.pvalues[i]) < 0.01:
                 signif = "***"
-            elif self.pvalues[i] < 0.05:
+            elif float(self.pvalues[i]) < 0.05:
                 signif = "**"
-            elif self.pvalues[i] < 0.1:
+            elif float(self.pvalues[i]) < 0.1:
                 signif = "*"
                 
             ''' 
@@ -1180,8 +1181,10 @@ class ObjectiveFunction(object):
                     file_name = self.instance_number + "/sln" + \
                         str(solution['sol_num']) + \
                         "_with_BIC_"+str(self.bic)+".tex"
-                self.save_to_file(latextable.draw_latex(
-                    table, caption=caption, caption_above = True), file_name)
+                        
+                if save_state:   
+                    self.save_to_file(latextable.draw_latex(
+                        table, caption=caption, caption_above = True), file_name)
                 
                 
                 #print('change this')
@@ -1419,11 +1422,20 @@ class ObjectiveFunction(object):
         if np.size(y) != np.size(eVy):
             y = np.tile(y, self.Ndraws).ravel()
             eVy = eVy.ravel()
+            
+       # y_avg = np.mean(y, axis = (1,2))
+       # eVy_avg = np.mean(eVy, axis = (1,2))
+        #mspe1 = np.nan_to_num(MSPE(np.squeeze(y_avg), np.squeeze(eVy_avg)), nan=100000, posinf=100000)
         eVy = np.nan_to_num(eVy, nan=100000, posinf=100000)
         eVy = np.clip(eVy, None, 1000)
         mae = np.nan_to_num(MAE(np.squeeze(y), np.squeeze(eVy)), nan=100000, posinf=100000)
         mspe = np.nan_to_num(MSPE(np.squeeze(y), np.squeeze(eVy)), nan=100000, posinf=100000)
-        
+        if self._obj_2 == 'MAE':
+            return mae
+        elif self._obj_2 == 'MSE':
+            return mspe
+        elif self._obj_2 == "MAD":
+            raise Exception
         return mspe
 
     def get_solution_vector(self, fixed_vars, random_vars, random_var_cor, distribution_vars, dispersion=None):
@@ -1603,7 +1615,7 @@ class ObjectiveFunction(object):
 
                 if (self.get_num_discrete_values(get_rdm_i) - 1) == 0:
                     # TODO: must be a better way to avoid selecting this
-                    print('ignore replacemenet')
+                    print('repair constraint violated, skipping over..')
                 
                 
                 else:
@@ -3455,15 +3467,22 @@ class ObjectiveFunction(object):
         return covariance
 
     def _numerical_hessian(self, betas, args, jac):
-        Xd, y, draws, Xf, Xr, corr_list, dispersion = args
+        #Xd, y, draws, Xf, Xr, corr_list, dispersion = args
         def loglike(p): return self._loglik_gradient(
-            p, Xd, y, draws, Xf, Xr, None, False, False, dispersion, corr_list=corr_list)
+            p, *args)
+        robust = False
         hess = approx_hess(betas, loglike)
+        hess /= self.N
         hess_inv1 = np.linalg.pinv(hess)
-        hess = self._hessian_prot(betas, loglike)
-        hess = np.nan_to_num(hess)
-        hess_inv = np.linalg.pinv(hess)
-        return hess_inv
+        if robust:
+           
+            scores = approx_fprime(betas, loglike)
+            score_cov = np.cov(scores.T)
+            inv_hess =  hess_inv1.dot(score_cov).dot(hess_inv1) / self.N
+        else:
+            inv_hess =  hess_inv1 / self.N
+        
+        return inv_hess
 
     def _chol_mat(self, correlationLength, br, Br_w, correlation):
         # if correlation = True correlation pos is randpos, if list get correct pos
@@ -5940,65 +5959,26 @@ class ObjectiveFunction(object):
                     
                     if dispersion ==1:
                         mod['dispersion_penalty'] = abs(b[-1])
-                    
-                    betas_est = self._minimize(self._loglik_gradient, b,  args=(X, y, draws, X, Xr, self.batch_size, True, True, dispersion, 0, False, 0, self.rdm_cor_fit, self.zi_fit, exog_infl, draws_grouped, XG, mod),
+                    grad_args = (X, y, draws, X, Xr, self.batch_size,False, False, dispersion, 0, False, 0, self.rdm_cor_fit, self.zi_fit, exog_infl, draws_grouped, XG, mod)
+                    betas_est = self._minimize(self._loglik_gradient, b,  args=(X, y, draws, X, Xr, self.batch_size,False, False, dispersion, 0, False, 0, self.rdm_cor_fit, self.zi_fit, exog_infl, draws_grouped, XG, mod),
                                                method=method2, tol=tol['ftol'],
                                                options={'gtol': tol['gtol']}, bounds = bounds)
+                    
+                    if self.numerical_hessian_calc:
+                        try:
+                            bb_hess = self._numerical_hessian(betas_est.x, grad_args, False)
+                        except Exception as e:
+                            bb_hess = None
+                    else:
+                        bb_hess = None        
                    # betas_est = self._minimize(self._loglik_gradient, b,  args=(X, y, draws, X, Xr, self.batch_size, True, True, dispersion, 0, False, 0, self.rdm_cor_fit, self.zi_fit, exog_infl,  draws_grouped, XG, mod),
                                              #          method=method2, tol=tol['ftol'], options={'gtol': tol['gtol']})
                   #  betas_est = self._minimize(self._loglik_gradient, b,  args=(X, y, draws, X, Xr, self.batch_size, False, False, dispersion, 0, False, 0, self.rdm_cor_fit, self.zi_fit, exog_infl,  draws_grouped, XG, mod),
                                              #          method=method2, tol=tol['ftol'], options={'gtol': tol['gtol']})
                     
-                    '''
-                    
-                    print('detlet the fuck out of this ...')
-                    
-                    if dispersion:
-                        bb = b[0:-1]
-                        dispersion_coef = b[-1]
-                        constant_coef = None
-                    else:
-                        bb = b[1:]
-                        dispersion_coef = None
-                        constant_coef = b[0]
-                            
-                        
+                  
                     
-                    beta_est_alt = self._minimize(self._loglik_gradient_wrapper, bb,  args=(constant_coef, dispersion_coef, X, y, draws, X, Xr, self.batch_size, True, True, dispersion, 0, False, 0, self.rdm_cor_fit, self.zi_fit, exog_infl, draws_grouped, XG, mod),
-                                                method=method, tol=tol['ftol'],
-                                                options={'gtol': tol['gtol']})
-                    print(beta_est_alt)
-                    '''
                     
-                    old_code = 0
-                    if old_code:
-                        gb_best = betas_est.copy()
-                        if betas_est['success'] == False:
-                            #b[0] += b[0] -len(b)/5
-                            # for i in range(1, len(bb) -self.is_dispersion(dispersion)):
-                            #    b[i] += b[i]/5 +.5
-                            # for i, j in enumerate(b):
-                            #    b[i] = 0
-                            start_time = time.time()
-                            #print('starint slow')
-                            betas_est = self._minimize(self._loglik_gradient, b,  args=(X, y, draws, X, Xr, self.batch_size, True, True, dispersion, 0, False, 0, self.rdm_cor_fit, self.zi_fit, exog_infl),
-                                                       method=method2, tol=tol['ftol'], options={'gtol': tol['gtol']})
-                            print("--- %s seconds ---" %
-                                  (time.time() - start_time))
-                            #ll, grad, hess = self._loglik_gradient(betas_est['x'] , X, y, draws, X, Xr, self.batch_size, True, True, dispersion, 0, False, 0, self.rdm_cor_fit, self.zi_fit, exog_infl)
-                            #hess_inv = np.linalg.pinv(np.dot(hess.T, hess))
-                            #betas_est['hess_inv'] = hess_inv
-                            if betas_est['fun'] <= gb_best['fun']:
-                                gb_best = betas_est.copy()
-                                bb = gb_best['x'].copy()
-
-                            betas_est = gb_best.copy()
-
-                            ll, grad, hess = self._loglik_gradient(
-                                betas_est['x'], X, y, draws, X, Xr, self.batch_size, True, True, dispersion, 0, False, 0, self.rdm_cor_fit, self.zi_fit, exog_infl)
-                            hess_inv = np.linalg.pinv(np.dot(hess.T, hess))
-                            betas_est['hess_inv'] = hess_inv
-                    # this is causing more problems, lets reconsider
                    
                     if betas_est['message'] == 'NaN result encountered.':
 
@@ -6015,7 +5995,8 @@ class ObjectiveFunction(object):
                         betas_est['x'], 0, dispersion, zi_fit=sub_zi, model_nature = mod)
                 if hasattr(betas_est.hess_inv, 'todense'):
                     betas_est['hess_inv'] = betas_est.hess_inv.todense() if hasattr(betas_est.hess_inv, 'todense') else np.array([betas_est.hess_inv(np.eye(len(b))[i]) for i in range(len(b))])
-                 
+                    if bb_hess is not None:
+                        betas_est['hess_inv'] = bb_hess
                 if betas_est['hess_inv'] is None:
 
                     self.convergance = 1
@@ -6540,11 +6521,14 @@ class ObjectiveFunction(object):
                     if self.is_multi:
                    
                         if self.pareto_printer.check_if_dominance(self._pareto_population, obj_1):
+                            print('dominate soltuion')
                             try:
                                 self.summary_alternative(
                                 long_print=1, model=dispersion, solution=obj_1)
                             except Exception as e:
                                 print('e', obj_1)    
+                        else:
+                            print('non_dominant solution.')        
                         if obj_1['layout'] is None:
                             print('no layout??')
                     else: