Objectives update

epde/operators/common/fitness.py

@@ -127,11 +127,15 @@ def apply(self, objective: Equation, arguments: dict, force_out_of_place: bool =
 
         try:
             if features is None:
-                discr_feats = 0
+                maximum = target.max(axis=0)
+                minimum = target.min(axis=0)
+                discr = (target - target.mean(axis=0) - minimum) / (maximum - minimum)
             else:
                 discr_feats = np.dot(features, objective.weights_final[:-1][objective.weights_internal != 0])
-
-            discr = (discr_feats + np.full(target.shape, objective.weights_final[-1]) - target)
+                discr_feats = discr_feats + np.full(target.shape, objective.weights_final[-1])
+                maximum = np.max([discr_feats.max(axis=0), target.max(axis=0)])
+                minimum = np.min([discr_feats.min(axis=0), target.min(axis=0)])
+                discr = ((discr_feats - minimum) - (target - minimum)) / (maximum - minimum)
             discr = np.multiply(discr, self.g_fun_vals)
             rl_error = np.linalg.norm(discr, ord=2)
         except ValueError:
@@ -141,27 +145,27 @@ def apply(self, objective: Equation, arguments: dict, force_out_of_place: bool =
             raise ValueError('Incorrect penalty coefficient set, value shall be in (0, 1).')
 
         fitness_value = rl_error
-        if np.sum(objective.weights_final) == 0:
-            fitness_value /= self.params['penalty_coeff']
+        # if np.sum(objective.weights_final) == 0:
+        #     fitness_value /= self.params['penalty_coeff']
 
-        # if force_out_of_place:
-        #     return fitness_value
+        if force_out_of_place:
+            return fitness_value
 
         # discr = np.mean(discr ** 2)
         # ll = np.log(discr)
         # aic = 2 * len(objective.weights_final) - 2 * ll
-        ssr = np.sum(discr ** 2)
-        n = len(target)
-        llf = - n / 2 * np.log(2 * np.pi) - n / 2 * np.log(ssr / n) - n / 2
+        # ssr = np.sum(discr ** 2)
+        # n = len(target)
+        # llf = - n / 2 * np.log(2 * np.pi) - n / 2 * np.log(ssr / n) - n / 2
         # aic = 2 * len([_ for _ in objective.weights_final if _ != 0]) - 2 * llf
-        aic = np.log(n) * len([_ for _ in objective.weights_final if _ != 0]) - 2 * llf
+        # aic = np.log(n) * len([_ for _ in objective.weights_final if _ != 0]) - 2 * llf
         # objective.aic = 1/(1 + np.exp(- 1e-4 * ll))
 
-        if force_out_of_place:
-            return 1 / (np.exp(-aic / 3e5))
+        # if force_out_of_place:
+        #     return 1 / (np.exp(-aic / 3e5))
 
-        objective.aic = 1 / (np.exp(-aic / 3e5))
-        # objective.aic = aic
+        # objective.aic = 1 / (np.exp(-aic / 3e5))
+        objective.aic = None
         objective.aic_calculated = True
         # print(aic)
         # print(len([_ for _ in objective.weights_final if _ !=0]))
@@ -201,9 +205,9 @@ def apply(self, objective: Equation, arguments: dict, force_out_of_place: bool =
                     feature_window = features[start_idx:end_idx, :]
                     estimator = LinearRegression(fit_intercept=False)
                     estimator.fit(feature_window, target_window, sample_weight=self.g_fun_vals[start_idx:end_idx])
-                    valuable_weights = estimator.coef_
+                    valuable_weights = estimator.coef_[:-1]
                     eq_window_weights.append(valuable_weights)
-                eq_cv = np.array([np.abs(np.std(_) / np.mean(_)) for _ in zip(*eq_window_weights)])
+                eq_cv = np.array([np.abs(np.std(_) / (np.mean(_) + 1e-12)) for _ in zip(*eq_window_weights)])
                 lr = eq_cv.mean()
 
         elif target_vals.ndim == 2:
@@ -235,9 +239,9 @@ def apply(self, objective: Equation, arguments: dict, force_out_of_place: bool =
                             target_window = target_vals[:, start_idx:end_idx].reshape(-1)
                             feature_window = features.reshape(*data_shape, -1)[:, start_idx:end_idx].reshape(-1, features.shape[-1])
                             estimator.fit(feature_window, target_window, sample_weight=self.g_fun_vals.reshape(*data_shape, -1)[:, start_idx:end_idx].reshape(-1))
-                        valuable_weights = estimator.coef_
+                        valuable_weights = estimator.coef_[:-1]
                         eq_window_weights.append(valuable_weights)
-                    eq_cv = np.array([np.abs(np.std(_) / np.mean(_)) for _ in zip(*eq_window_weights)])
+                    eq_cv = np.array([np.abs(np.std(_) / (np.mean(_) + 1e-12)) for _ in zip(*eq_window_weights)])
                     lr += eq_cv.mean()
 
         elif target_vals.ndim == 3:
@@ -275,9 +279,9 @@ def apply(self, objective: Equation, arguments: dict, force_out_of_place: bool =
                             target_window = target_vals[:, :, start_idx:end_idx].reshape(-1)
                             feature_window = features.reshape(*data_shape, -1)[:, :, start_idx:end_idx].reshape(-1, features.shape[-1])
                             estimator.fit(feature_window, target_window, sample_weight=self.g_fun_vals.reshape(*data_shape, -1)[:, :, start_idx:end_idx].reshape(-1))
-                        valuable_weights = estimator.coef_
+                        valuable_weights = estimator.coef_[:-1]
                         eq_window_weights.append(valuable_weights)
-                    eq_cv = np.array([np.abs(np.std(_) / np.mean(_)) for _ in zip(*eq_window_weights)])
+                    eq_cv = np.array([np.abs(np.std(_) / (np.mean(_) + 1e-12)) for _ in zip(*eq_window_weights)])
                     lr += eq_cv.mean()
 
         objective.fitness_calculated = True

epde/structure/main_structures.py

@@ -913,7 +913,7 @@ def use_pic_multiobjective_function(self):
         self.set_objective_functions(
             # quality_objectives + stability_objectives + complexity_objectives)
             # quality_objectives + stability_objectives + aic_objectives)
-            aic_objectives + stability_objectives)
+            quality_objectives + stability_objectives)
 
     def use_default_singleobjective_function(self):
         from epde.eq_mo_objectives import generate_partial, equation_fitness

projects/pic/data/burgers/burgers.py

@@ -152,7 +152,7 @@ def burgers_discovery(foldername, noise_level):
 
     factors_max_number = {'factors_num': [1, 2], 'probas': [0.65, 0.35]}
 
-    bounds = (1e-5, 1e-0)
+    bounds = (1e-5, 1e2)
     epde_search_obj.fit(data=noised_data, variable_names=['u', ], max_deriv_order=(2, 3), derivs=None,
                         equation_terms_max_number=5, data_fun_pow=3,
                         additional_tokens=[],

projects/pic/data/kdv/kdv.py

@@ -72,15 +72,15 @@ def prepare_suboperators(fitness_operator: CompoundOperator, operator_params: di
     sparsity = LASSOSparsity()
     coeff_calc = LinRegBasedCoeffsEquation()
 
-    sparsity = map_operator_between_levels(sparsity, 'gene level', 'chromosome level')
-    coeff_calc = map_operator_between_levels(coeff_calc, 'gene level', 'chromosome level')
+    # sparsity = map_operator_between_levels(sparsity, 'gene level', 'chromosome level')
+    # coeff_calc = map_operator_between_levels(coeff_calc, 'gene level', 'chromosome level')
 
     fitness_operator.set_suboperators({'sparsity': sparsity,
                                        'coeff_calc': coeff_calc})
     fitness_cond = lambda x: not getattr(x, 'fitness_calculated')
     fitness_operator.params = operator_params
-    # fitness_operator = map_operator_between_levels(fitness_operator, 'gene level', 'chromosome level',
-    #                                                objective_condition=fitness_cond)
+    fitness_operator = map_operator_between_levels(fitness_operator, 'gene level', 'chromosome level',
+                                                   objective_condition=fitness_cond)
     return fitness_operator
 
 
@@ -168,8 +168,10 @@ def KdV_test(operator: CompoundOperator, foldername: str, noise_level: int = 0):
                                       params_equality_ranges=trig_params_equal_ranges,
                                       meaningful=True, unique_token_type=True)
 
-    epde_search_obj.set_preprocessor(default_preprocessor_type='ANN',
-                                     preprocessor_kwargs={'epochs_max': 1e4}) #'epochs_max': 5e4
+    # epde_search_obj.set_preprocessor(default_preprocessor_type='ANN',
+    #                                  preprocessor_kwargs={'epochs_max': 1e4}) #'epochs_max': 5e4
+    epde_search_obj.set_preprocessor(default_preprocessor_type='FD',
+                                     preprocessor_kwargs={})  # 'epochs_max': 5e4
 
     epde_search_obj.create_pool(data=noised_data, variable_names=['u',], max_deriv_order=(2, 3),
                                 additional_tokens = [custom_trig_tokens,]) # data_nn
@@ -250,18 +252,18 @@ def kdv_discovery(foldername, noise_level):
 
     dimensionality = data.ndim - 1
 
-    epde_search_obj = EpdeSearch(use_solver=True, use_pic=True,
-                                      boundary=10,
+    epde_search_obj = EpdeSearch(use_solver=False, use_pic=True,
+                                      boundary=5,
                                       coordinate_tensors=grid, device='cuda')
 
-    epde_search_obj.set_preprocessor(default_preprocessor_type='ANN',
-                                        preprocessor_kwargs={'epochs_max' : 1e3})
-    # epde_search_obj.set_preprocessor(default_preprocessor_type='FD',
-    #                                  preprocessor_kwargs={})
-    popsize = 8
+    # epde_search_obj.set_preprocessor(default_preprocessor_type='ANN',
+    #                                     preprocessor_kwargs={'epochs_max' : 1e3})
+    epde_search_obj.set_preprocessor(default_preprocessor_type='FD',
+                                     preprocessor_kwargs={})
+    popsize = 30
 
     epde_search_obj.set_moeadd_params(population_size=popsize,
-                                      training_epochs=30)
+                                      training_epochs=20)
 
     custom_trigonometric_eval_fun = {
         'cos(t)sin(x)': lambda *grids, **kwargs: (np.cos(grids[0]) * np.sin(grids[1])) ** kwargs['power']}
@@ -283,9 +285,9 @@ def kdv_discovery(foldername, noise_level):
     factors_max_number = {'factors_num': [1, 2], 'probas': [0.65, 0.35]}
 
     bounds = (1e-5, 1e-2)
-    epde_search_obj.fit(data=noised_data, variable_names=['u', ], max_deriv_order=(1, 3), derivs=None,
-                        equation_terms_max_number=5, data_fun_pow=1,
-                        additional_tokens=[custom_trig_tokens],
+    epde_search_obj.fit(data=noised_data, variable_names=['u', ], max_deriv_order=(2, 3), derivs=None,
+                        equation_terms_max_number=5, data_fun_pow=3,
+                        additional_tokens=[trig_tokens], #custom_trig_tokens
                         equation_factors_max_number=factors_max_number,
                         eq_sparsity_interval=bounds, fourier_layers=False) # , data_nn=data_nn
 
@@ -449,9 +451,9 @@ def kdv_sindy_discovery(foldername, noise_level):
 
     factors_max_number = {'factors_num': [1, 2], 'probas': [0.65, 0.35]}
 
-    bounds = (1e-5, 1e-2)
-    epde_search_obj.fit(data=noised_data, variable_names=['u', ], max_deriv_order=(1, 3), derivs=None,
-                        equation_terms_max_number=5, data_fun_pow=1,
+    bounds = (1e-8, 1e0)
+    epde_search_obj.fit(data=noised_data, variable_names=['u', ], max_deriv_order=(2, 3), derivs=None,
+                        equation_terms_max_number=5, data_fun_pow=3,
                         additional_tokens=[custom_trig_tokens],
                         equation_factors_max_number=factors_max_number,
                         eq_sparsity_interval=bounds, fourier_layers=False) # , data_nn=data_nn
@@ -469,22 +471,22 @@ def kdv_sindy_discovery(foldername, noise_level):
     print("CUDA available:", torch.cuda.is_available())
     # Operator = fitness.SolverBasedFitness # Replace by the developed PIC-based operator.
     # Operator = fitness.PIC
-    # Operator = fitness.L2LRFitness
-    # params = EvolutionaryParams()
-    # operator_params = params.get_default_params_for_operator('DiscrepancyBasedFitnessWithCV') #{"penalty_coeff": 0.2, "pinn_loss_mult": 1e4}
+    Operator = fitness.L2LRFitness
+    params = EvolutionaryParams()
+    operator_params = params.get_default_params_for_operator('DiscrepancyBasedFitnessWithCV') #{"penalty_coeff": 0.2, "pinn_loss_mult": 1e4}
     # operator_params = {"penalty_coeff": 0.2, "pinn_loss_mult": 1e4}
-    # print('operator_params ', operator_params)
-    # fit_operator = prepare_suboperators(Operator(list(operator_params.keys())), operator_params)
+    print('operator_params ', operator_params)
+    fit_operator = prepare_suboperators(Operator(list(operator_params.keys())), operator_params)
 
     # Paths
     directory = os.path.dirname(os.path.realpath(__file__))
     kdv_folder_name = os.path.join(directory)
 
-    # KdV_test(fit_operator, kdv_folder_name, 5)
+    # KdV_test(fit_operator, kdv_folder_name, 0)
     # KdV_h_test(fit_operator, kdv_folder_name, 0)
     # KdV_sga_test(fit_operator, kdv_folder_name, 0)
 
-    # kdv_discovery(kdv_folder_name, 5)
+    kdv_discovery(kdv_folder_name, 0)
     # kdv_h_discovery(kdv_folder_name, 0)
     # kdv_sga_discovery(kdv_folder_name, 5)
-    kdv_sindy_discovery(kdv_folder_name, 0)
+    # kdv_sindy_discovery(kdv_folder_name, 0)

projects/pic/data/ode/ode.py

@@ -149,11 +149,11 @@ def ODE_discovery(foldername, noise_level):
 
     factors_max_number = {'factors_num': [1, 2], 'probas': [0.65, 0.35]}
 
-    epde_search_obj.fit(data=[noised_data, ], variable_names=['u', ], max_deriv_order=(2, 2),
-                        equation_terms_max_number=5, data_fun_pow=1,
+    epde_search_obj.fit(data=[noised_data, ], variable_names=['u', ], max_deriv_order=(2, 3),
+                        equation_terms_max_number=5, data_fun_pow=3,
                         additional_tokens=[trig_tokens, grid_tokens],
                         equation_factors_max_number=factors_max_number,
-                        eq_sparsity_interval=(1e-12, 1e-4), data_nn=data_nn) #
+                        eq_sparsity_interval=(1e-10, 1e-0)) # , data_nn=data_nn
 
     epde_search_obj.equations(only_print=True, num=1)
 
@@ -186,15 +186,15 @@ def ODE_simple_discovery(foldername, noise_level):
                                      preprocessor_kwargs={})
 
     popsize = 8
-    epde_search_obj.set_moeadd_params(population_size=popsize, training_epochs=15)
+    epde_search_obj.set_moeadd_params(population_size=popsize, training_epochs=5)
 
     factors_max_number = {'factors_num': [1, 2], 'probas': [0.65, 0.35]}
 
-    epde_search_obj.fit(data=[x, ], variable_names=['u', ], max_deriv_order=(1, 2),
-                        equation_terms_max_number=5, data_fun_pow=1,
+    epde_search_obj.fit(data=[x, ], variable_names=['u', ], max_deriv_order=(2, 3),
+                        equation_terms_max_number=5, data_fun_pow=3,
                         additional_tokens=[trig_tokens, grid_tokens],
                         equation_factors_max_number=factors_max_number,
-                        eq_sparsity_interval=(1e-6, 1e-0)) #
+                        eq_sparsity_interval=(1e-6, 1e0)) #
 
     epde_search_obj.equations(only_print=True, num=1)
 

projects/pic/data/vdp/vdp.py

@@ -106,7 +106,7 @@ def VdP_test(operator: CompoundOperator, foldername: str, noise_level: int = 0):
                                       dimensionality = dimensionality)
     grid_tokens = GridTokens(['x_0',], dimensionality = dimensionality, max_power = 2)
 
-    epde_search_obj = EpdeSearch(use_solver = False, use_pic=True, boundary = 10,
+    epde_search_obj = EpdeSearch(use_solver = False, use_pic=True, boundary = 2,
                                  coordinate_tensors = [t,], verbose_params = {'show_iter_idx' : True},
                                  device = 'cpu')
 
@@ -133,23 +133,23 @@ def vdp_discovery(foldername, noise_level):
                                       dimensionality=dimensionality)
     grid_tokens = GridTokens(['x_0', ], dimensionality=dimensionality, max_power=2)
 
-    epde_search_obj = EpdeSearch(use_solver=False, use_pic=True, boundary=10,
+    epde_search_obj = EpdeSearch(use_solver=False, use_pic=True, boundary=1,
                                  coordinate_tensors=(t,), verbose_params={'show_iter_idx': True},
                                  device='cuda')
 
     epde_search_obj.set_preprocessor(default_preprocessor_type='FD',
                                      preprocessor_kwargs={})
 
     popsize = 8
-    epde_search_obj.set_moeadd_params(population_size=popsize, training_epochs=15)
+    epde_search_obj.set_moeadd_params(population_size=popsize, training_epochs=30)
 
     factors_max_number = {'factors_num': [1, 2], 'probas': [0.65, 0.35]}
 
-    epde_search_obj.fit(data=[noised_data, ], variable_names=['u', ], max_deriv_order=(2, 2),
-                        equation_terms_max_number=5, data_fun_pow=2,
+    epde_search_obj.fit(data=[noised_data, ], variable_names=['u', ], max_deriv_order=(2, 3),
+                        equation_terms_max_number=5, data_fun_pow=3,
                         additional_tokens=[trig_tokens, grid_tokens],
                         equation_factors_max_number=factors_max_number,
-                        eq_sparsity_interval=(1e-8, 1e-0), data_nn=data_nn) #
+                        eq_sparsity_interval=(1e-5, 1e-0)) #
 
     epde_search_obj.equations(only_print=True, num=1)