Merge pull request #56 from Gromwud/main

Cumulitive update

Author: Gromwud

epde/cache/cache.py

@@ -236,7 +236,8 @@ def set_boundaries(self, boundary_width: Union[int, list, tuple]):
         Setting the number of unaccounted elements at the edges
         """
         assert '0' in self.memory_default['numpy'].keys(), 'Boundaries should be specified for grid cache.'
-        shape = self.get('0')[1].shape
+        shape = self.get('0').shape
+        self.initial_shape = shape
         if isinstance(boundary_width, int):
             if any([elem <= 2*boundary_width for elem in shape]):
                 raise IndexError(f'Mismatching shapes: boundary of {boundary_width} does not fit data of shape {shape}')
@@ -247,6 +248,10 @@ def set_boundaries(self, boundary_width: Union[int, list, tuple]):
             raise TypeError(f'Incorrect type of boundaries: {type(boundary_width)}, instead of expected int or list/tuple')
 
         self.boundary_width = boundary_width
+        if isinstance(boundary_width, int):
+            self.inner_shape = np.array(self.get('0').shape) - 2 * boundary_width
+        elif isinstance(boundary_width, (list, tuple)):
+            self.inner_shape = np.array(self.get('0').shape) - np.multiply(np.array(boundary_width), 2)
 
     def memory_usage_properties(self, obj_test_case=None, mem_for_cache_frac=None, mem_for_cache_abs=None):
         """
@@ -444,6 +449,11 @@ def __contains__(self, obj):
                 return (obj[0] in self.memory_normalized['numpy'].keys()) or (obj[0] in self.memory_normalized['torch'].keys())
             else:
                 return (obj[0] in self.memory_default['numpy'].keys()) or (obj[0] in self.memory_default['torch'].keys())
+        elif (type(obj) == tuple or type(obj) == list) and type(obj[0]) == frozenset and type(obj[1]) == bool:
+            if obj[1]:
+                return (obj[0] in self.memory_normalized['numpy'].keys()) or (obj[0] in self.memory_normalized['torch'].keys())
+            else:
+                return (obj[0] in self.memory_default['numpy'].keys()) or (obj[0] in self.memory_default['torch'].keys())
         elif type(obj) == np.ndarray:
             try:
                 return np.any([np.all(obj == entry_values) for entry_values in self.memory_default['numpy'].values()])

epde/eq_mo_objectives.py

@@ -16,7 +16,7 @@ def generate_partial(obj_function, equation_key):
     return partial(obj_function, equation_key=equation_key)
 
 
-def equation_fitness(system, equation_key):
+def equation_fitness(system, equation_key = None):
     '''
     Evaluate the quality of the system of PDEs, using the individual values of fitness function for equations.
 
@@ -30,8 +30,14 @@ def equation_fitness(system, equation_key):
         error : float.
         The value of the error metric.
     '''
-    assert system.vals[equation_key].fitness_calculated, 'Trying to call fitness before its evaluation.'
-    res = system.vals[equation_key].fitness_value
+    if equation_key:
+        assert all(equation.fitness_calculated for equation in system.vals), 'Trying to call fitness before its evaluation.'
+        res = system.vals[equation_key].fitness_calculated
+    else:
+        for equation in system.vals:
+            assert equation.fitness_value
+        # res = np.mean([equation.fitness_value for equation in system.vals])
+        res = tuple([equation.fitness_value for equation in system.vals])
     return res
 
 
@@ -97,9 +103,15 @@ def equation_complexity_by_factors(system, equation_key):
     return eq_compl
 
 
-def equation_terms_stability(system, equation_key):
-    assert system.vals[equation_key].stability_calculated
-    res = system.vals[equation_key].coefficients_stability
+def equation_terms_stability(system, equation_key = None):
+    if equation_key:
+        assert system.vals[equation_key].stability_calculated
+        res = system.vals[equation_key].coefficients_stability
+    else:
+        for equation in system.vals:
+            assert equation.stability_calculated
+        # res = np.mean([equation.coefficients_stability for equation in system.vals])
+        res = tuple([equation.coefficients_stability for equation in system.vals])
     return res
 
 def equation_aic(system, equation_key):

epde/evaluators.py

@@ -84,6 +84,17 @@ def __call__(self, factor, structural: bool = False, func_args: List[Union[torch
                 self.indexes_vect[tensor_idx] = tuple([subarg[tensor_idx]
                                                        for subarg in func_args])
         value = grid_function(self.indexes_vect)
+        if len(global_var.grid_cache.initial_shape) > 1:
+            value = value.reshape(*global_var.grid_cache.initial_shape)
+            if isinstance(global_var.grid_cache.boundary_width, int):
+                for dim in range(value.ndim):
+                    value[dim] = value[global_var.grid_cache.boundary_width:-global_var.grid_cache.boundary_width]
+            elif isinstance(global_var.grid_cache.boundary_width, (list, tuple)):
+                for dim in range(value.ndim):
+                    value[dim] = value[global_var.grid_cache.boundary_width[dim]:-global_var.grid_cache.boundary_width[dim]]
+            value = value.reshape(-1)
+        else:
+            value = value[global_var.grid_cache.boundary_width:-global_var.grid_cache.boundary_width]
         return value
 
 

epde/interface/interface.py

@@ -65,7 +65,7 @@ class InputDataEntry(object):
         derivatives (`np.ndarray`): values of derivatives
         deriv_properties (`dict`): settings of derivatives
     """
-    def __init__(self, var_name: str, var_idx: int, data_tensor: Union[List[np.ndarray], np.ndarray]):
+    def __init__(self, var_name: str, var_idx: int, data_tensor: Union[List[np.ndarray], np.ndarray], boundary):
         self.var_name = var_name
         self.var_idx = var_idx 
         if isinstance(data_tensor, np.ndarray):
@@ -76,6 +76,7 @@ def __init__(self, var_name: str, var_idx: int, data_tensor: Union[List[np.ndarr
             assert all([data_tensor[0].ndim == tensor.ndim for tensor in data_tensor]), 'Mismatching dimensionalities of data tensors.'
             self.ndim = data_tensor[0].ndim
         self.data_tensor = data_tensor
+        self.boundary = boundary
 
 
     def set_derivatives(self, preprocesser: PreprocessingPipe, deriv_tensors: Union[list, np.ndarray] = None,
@@ -135,6 +136,8 @@ def use_global_cache(self): # , var_idx: int, deriv_codes: list
         """
         var_idx = self.var_idx
         deriv_codes = self.d_orders
+        self.data_tensor = self.data_tensor[self.boundary != 0]
+        self.derivatives = np.array([derivative[self.boundary.flatten() != 0] for derivative in self.derivatives.T]).T
         derivs_stacked = prepare_var_tensor(self.data_tensor, self.derivatives, 
                                             time_axis=global_var.time_axis)
         deriv_codes = [(var_idx, code) for code in deriv_codes]
@@ -351,7 +354,7 @@ def set_memory_properties(self, example_tensor, mem_for_cache_frac=None, mem_for
         global_var.tensor_cache.memory_usage_properties(example_tensor, mem_for_cache_frac, mem_for_cache_abs)
 
     def set_moeadd_params(self, population_size: int = 6, solution_params: dict = {},
-                          delta: float = 1/50., neighbors_number: int = 3,
+                          H: int = 15, neighbors_number: int = 3,
                           nds_method: Callable = fast_non_dominated_sorting,
                           ndl_update_method: Callable = ndl_update,
                           subregion_mating_limitation: float = .95,
@@ -367,7 +370,7 @@ def set_moeadd_params(self, population_size: int = 6, solution_params: dict = {}
                 The size of the population of solutions, created during MO - optimization, default 6.
             solution_params (`dict`): optional
                 Dictionary, containing additional parameters to be sent into the newly created solutions.
-            delta (`float`): optional
+            H (`float`): optional
                 parameter of uniform spacing between the weight vectors; *H = 1 / delta*
                 should be integer - a number of divisions along an objective coordinate axis.
             neighbors_number (`int`): *> 0*, optional
@@ -407,8 +410,8 @@ def set_moeadd_params(self, population_size: int = 6, solution_params: dict = {}
         Returns:
             None
         """
-        self.optimizer_init_params = {'weights_num': population_size, 'pop_size': population_size,
-                              'delta': delta, 'neighbors_number': neighbors_number,
+        self.optimizer_init_params = {'pop_size': population_size,
+                              'H': population_size-1, 'neighbors_number': neighbors_number,
                               'solution_params': solution_params,
                               'nds_method' : nds_method, 
                               'ndl_update' : ndl_update_method}
@@ -534,7 +537,12 @@ def uniformize(data):
                         exponent = np.multiply.reduce(exponent_partial, axis=0)
                         return exponent
 
-                    global_var.grid_cache.g_func = decorator(baseline_exp_function)
+                    def return_ones(grids):
+                        ones_partial = np.array([np.ones_like(grid) for grid in grids])
+                        ones = np.multiply.reduce(ones_partial, axis=0)
+                        return ones
+                    # global_var.grid_cache.g_func = decorator(baseline_exp_function)
+                    global_var.grid_cache.g_func = decorator(return_ones)
                 else:
                     global_var.grid_cache.g_func = decorator(function_form)
 
@@ -671,7 +679,7 @@ def create_pool(self, data: Union[np.ndarray, list, tuple], variable_names=['u',
 
         for data_elem_idx, data_tensor in enumerate(data):
             entry = InputDataEntry(var_name=variable_names[data_elem_idx], var_idx=data_elem_idx,
-                                   data_tensor=data_tensor)
+                                   data_tensor=data_tensor, boundary=self.cache[0].g_func)
             derivs_tensor = derivs[data_elem_idx] if derivs is not None else None
             entry.set_derivatives(preprocesser=self.preprocessor_pipeline, deriv_tensors=derivs_tensor,
                                   grid=grid, max_order=max_deriv_order)
@@ -847,18 +855,16 @@ def _create_optimizer(multiobjective_mode: bool, optimizer_init_params: dict,
                           opt_strategy_director: OptimizationPatternDirector,
                           population: List[SoEq] = None, use_pic: bool = False):
         if multiobjective_mode:
+            best_sol_vals = [0., 0.] if use_pic else [0., 1.]
+            optimizer_init_params['best_sol_vals'] = best_sol_vals
             optimizer_init_params['passed_population'] = population
             optimizer = MOEADDOptimizer(**optimizer_init_params)
-
-            # if best_sol_vals is None:
-            best_sol_vals = [0., 0.] if use_pic else [0., 1.]
-            # best_sol_vals = [0., 0.] if use_pic else [0., 1.]
-
             same_obj_count = sum([1 for token_family in optimizer_init_params['population_instruct']['pool'].families
                                   if token_family.status['demands_equation']])
             best_obj = np.concatenate([np.full(same_obj_count, fill_value = fval) for fval in best_sol_vals])
             print('best_obj', len(best_obj))
-            optimizer.pass_best_objectives(*best_obj)
+            # optimizer.pass_best_objectives(*best_obj)
+            optimizer.pass_best_objectives(*best_sol_vals)
         else:
             optimizer_init_params['passed_population'] = population
             optimizer = SimpleOptimizer(**optimizer_init_params)

epde/interface/prepared_tokens.py

@@ -419,6 +419,7 @@ def __init__(self, token_type: str, token_labels: list, token_tensors: dict, par
                  non_default_power = True):
         if set(token_labels) != set(list(token_tensors.keys())):
             raise KeyError('The labels of tokens do not match the labels of passed tensors')
+        token_tensors = {key: value[global_var.grid_cache.g_func != 0] for key, value in token_tensors.items()}
         upload_simple_tokens(list(token_tensors.keys()), global_var.tensor_cache, list(token_tensors.values()))
         super().__init__(token_type=token_type, token_labels=token_labels, evaluator=simple_function_evaluator,
                          params_ranges=params_ranges, params_equality_ranges=params_equality_ranges,

epde/interface/token_family.py

@@ -7,6 +7,7 @@
 """
 
 import numpy as np
+import math
 import itertools
 from typing import Union, Callable, List
 try:
@@ -273,7 +274,7 @@ def chech_constancy(self, **tfkwargs):
             data_label = (label, (1.0,))
             data = global_var.tensor_cache.memory_default["numpy"].get(data_label)
             try:
-                constancy = np.isclose(np.min(data), np.max(data))
+                constancy = math.isclose(np.min(data), np.max(data))
             except TypeError:
                 print(f"No {label} data in cache for constancy check. Functionality of eval-d token check TBD.")
                 continue

epde/operators/common/coeff_calculation.py

@@ -7,7 +7,7 @@
 """
 
 import numpy as np
-from sklearn.linear_model import LinearRegression
+from sklearn.linear_model import LinearRegression, Ridge
 
 import epde.globals as global_var
 from epde.operators.utils.template import CompoundOperator
@@ -67,11 +67,13 @@ def apply(self, objective : Equation, arguments : dict = None):
                     features = np.vstack([features, features_vals[i]])
             features = np.vstack([features, np.ones(features_vals[0].shape)]) # Добавляем константную фичу
             features = np.transpose(features)
-            estimator = LinearRegression(fit_intercept=False)
+            estimator = LinearRegression(copy_X=True, fit_intercept=False, n_jobs=-1,
+                              positive=False, tol=0.0001)
+            # estimator = LinearRegression(fit_intercept=False)
             if features.ndim == 1:
                 features = features.reshape(-1, 1)
             try:
-                self.g_fun_vals = global_var.grid_cache.g_func.reshape(-1)
+                self.g_fun_vals = global_var.grid_cache.g_func[global_var.grid_cache.g_func != 0]
             except AttributeError:
                 self.g_fun_vals = None
             estimator.fit(features, target_vals, sample_weight = self.g_fun_vals)