Fixed minor issues with fitness functions

Author: Maslyaev

epde/globals.py

@@ -171,7 +171,7 @@ def reset_data_repr_nn(data: List[np.ndarray], grids: List[np.ndarray], train: b
         t = 0
         min_loss = np.inf
         loss_mean = np.inf
-        print(f'Training NN to represent data for {epochs_max} epochs')
+        print(f'Training ANN to represent input data on {epochs_max} epochs:')
         while loss_mean > 1e-6 and t < epochs_max:
 
             permutation = torch.randperm(grids_tr.size()[0])
@@ -184,8 +184,6 @@ def reset_data_repr_nn(data: List[np.ndarray], grids: List[np.ndarray], train: b
                 indices = permutation[i:i+batch_size]
                 batch_x, batch_y = grids_tr[indices], data_tr[indices]
 
-                # print(f'batch_y {batch_y.get_device()}, batch_x {batch_x.get_device()},, {next(model.parameters()).is_cuda}')
-                # print(f'model(batch_x) {model(batch_x)}') 
                 loss = torch.mean(torch.abs(batch_y - model(batch_x)))
                 if derivs is not None:
                     for var_idx, deriv_axes, deriv_tensor in derivs:
@@ -194,7 +192,6 @@ def reset_data_repr_nn(data: List[np.ndarray], grids: List[np.ndarray], train: b
                                                                                           deriv_tensor.shape)].reshape_as(deriv_autograd).to(device)
 
                         loss_add = 1e2 * torch.mean(torch.abs(batch_derivs - deriv_autograd))
-                        # print(loss, loss_add)
                         loss += loss_add
 
                 if penalised_derivs is not None:
@@ -216,7 +213,7 @@ def reset_data_repr_nn(data: List[np.ndarray], grids: List[np.ndarray], train: b
                 min_loss = loss_mean
             t += 1
         model = best_model
-        print(f'min loss is {min_loss}, in last epoch: {loss_list}, ')
+        print(f'min loss is {min_loss}, in last epoch: {loss_list}.')
         solution_guess_nn = best_model
     else:
         solution_guess_nn = model

epde/integrate/bop.py

@@ -261,7 +261,7 @@ def get_boundary_ind(tensor_shape, axis, rel_loc):
                     operator.set_grid(grid=coords)
                     operator.values = bc_values
                     bconds.append(operator)
-        print('Types of conds:', [type(cond) for cond in bconds])
+        # print('Types of conds:', [type(cond) for cond in bconds])
         self.conditions = bconds
 
 

epde/integrate/pinn_integration.py

@@ -377,7 +377,7 @@ def solve(self, equations: Union[List, SoEq, SolverEquation], domain: Domain,
         else:
             equations_prepared = SolverEquation()
             for form in equations:
-                print(f'form is solve has a type of {type(form)}: {form}')
+                # print(f'form is solve has a type of {type(form)}: {form}')
                 if isinstance(form, dict):
                     equations_prepared.add(form)
                 elif (isinstance(form, list) or isinstance(form, tuple)) and len(form) == 2:

epde/interface/interface.py

@@ -646,7 +646,7 @@ def create_pool(self, data: Union[np.ndarray, list, tuple], variable_names=['u',
                     derivs=None, max_deriv_order=1, additional_tokens=[],
                     data_fun_pow: int = 1, deriv_fun_pow: int = 1, grid: list = None,
                     data_nn: torch.nn.Sequential = None, fourier_layers: bool = True,
-                    fourier_params: dict = {'L' : [4,], 'M' : [3,]}):
+                    fourier_params: dict = {'L' : [4,], 'M' : [3,]}, ann_epochs_max = 1e5):
         '''
         Create pool of tokens to represent elementary functions, that can be included in equations.
         
@@ -699,8 +699,8 @@ def create_pool(self, data: Union[np.ndarray, list, tuple], variable_names=['u',
                 global_var.reset_data_repr_nn(data = data, derivs = base_derivs, train = False, 
                                               grids = grid, predefined_ann = data_nn, device = self._device)
             else:
-                epochs_max = 1e4 # 1e4
-                global_var.reset_data_repr_nn(data = data, derivs = base_derivs, epochs_max=epochs_max,
+                # epochs_max = 1e5 # 1e4
+                global_var.reset_data_repr_nn(data = data, derivs = base_derivs, epochs_max=ann_epochs_max,
                                               grids = grid, predefined_ann = None, device = self._device, 
                                               use_fourier = fourier_layers, fourier_params = fourier_params)
 
@@ -754,7 +754,7 @@ def fit(self, data: Union[np.ndarray, list, tuple] = None, equation_terms_max_nu
             equation_factors_max_number=1, variable_names=['u',], eq_sparsity_interval=(1e-4, 2.5), 
             derivs=None, max_deriv_order=1, additional_tokens = None, data_fun_pow: int = 1, deriv_fun_pow: int = 1,
             optimizer: Union[SimpleOptimizer, MOEADDOptimizer] = None, pool: TFPool = None,
-            population: List[SoEq] = None, data_nn = None, 
+            population: List[SoEq] = None, data_nn = None, ann_epochs_max = 1e5,
             fourier_layers: bool = False, fourier_params: dict = {'L' : [4,], 'M' : [3,]}):
         """
         Fit epde search algorithm to obtain differential equations, describing passed data.
@@ -827,7 +827,8 @@ def fit(self, data: Union[np.ndarray, list, tuple] = None, equation_terms_max_nu
                                  derivs=derivs, max_deriv_order=max_deriv_order, 
                                  additional_tokens=additional_tokens, 
                                  data_fun_pow = data_fun_pow, deriv_fun_pow = deriv_fun_pow, 
-                                 data_nn = data_nn, fourier_layers=fourier_layers, fourier_params=fourier_params)
+                                 data_nn = data_nn, ann_epochs_max = ann_epochs_max,
+                                 fourier_layers=fourier_layers, fourier_params=fourier_params)
         else:
             self.pool = pool; self.pool_params = cur_params
 

epde/operators/common/fitness.py

@@ -194,7 +194,7 @@ def set_adapter(self, net = None):
         if self.adapter is None or net is not None:
             compiling_params = {'mode': 'autograd', 'tol':0.01, 'lambda_bound': 100} #  'h': 1e-1
             optimizer_params = {}
-            training_params = {'epochs': 4e3, 'info_string_every' : 1e3}
+            training_params = {'epochs': 1e3, 'info_string_every' : 1e3}
             early_stopping_params = {'patience': 4, 'no_improvement_patience' : 250}
 
             explicit_cpu = False
@@ -272,7 +272,7 @@ def set_adapter(self, net=None):
         if self.adapter is None or net is not None:
             compiling_params = {'mode': 'autograd', 'tol': 0.01, 'lambda_bound': 100}  # 'h': 1e-1
             optimizer_params = {}
-            training_params = {'epochs': 4e3, 'info_string_every': 1e3}
+            training_params = {'epochs': 1e3, 'info_string_every': 1e3}
             early_stopping_params = {'patience': 4, 'no_improvement_patience': 250}
 
             explicit_cpu = False
@@ -306,10 +306,10 @@ def apply(self, objective: SoEq, arguments: dict, force_out_of_place: bool = Fal
                                                                boundary_conditions=None, use_fourier=True)
 
         _, grids = global_var.grid_cache.get_all(mode='torch')
-
+        grids = [grid[global_var.grid_cache.g_func != 0] for grid in grids]
         grids = torch.stack([grid.reshape(-1) for grid in grids], dim=1).float()
         solution = solution_nn(grids).detach().cpu().numpy()
-        self.g_fun_vals = global_var.grid_cache.g_func
+        self.g_fun_vals = global_var.grid_cache.g_func[global_var.grid_cache.g_func != 0]
 
         if force_out_of_place:
             sum_err = 0
@@ -319,8 +319,6 @@ def apply(self, objective: SoEq, arguments: dict, force_out_of_place: bool = Fal
             if torch.isnan(loss_add):
                 lp = 2 * LOSS_NAN_VAL
             else:
-                print(f'solution shape {solution.shape}')
-                print(f'solution[..., eq_idx] {solution[..., eq_idx].shape}, eq_idx {eq_idx}')
                 referential_data = global_var.tensor_cache.get((eq.main_var_to_explain, (1.0,)))
                 discr = solution[..., eq_idx] - referential_data.reshape(solution[..., eq_idx].shape)
                 discr = np.multiply(discr, self.g_fun_vals.reshape(discr.shape))
@@ -339,7 +337,7 @@ def apply(self, objective: SoEq, arguments: dict, force_out_of_place: bool = Fal
 
             # Calculate r-loss
             _, target, features = eq.evaluate(normalize=False, return_val=False)
-            data_shape = global_var.grid_cache.g_func.shape
+            data_shape = global_var.grid_cache.g_func[global_var.grid_cache.g_func != 0].shape
             target_vals = target.reshape(*data_shape)
 
             if target_vals.ndim == 1: