structure update

Author: Gromwud

epde/operators/common/right_part_selection.py

@@ -49,13 +49,15 @@ def apply(self, objective : Equation, arguments : dict):
         while not (objective.simplified and objective.is_correct_right_part):
             objective.reset_state(True)
             min_fitness = np.inf
-            weights_internal = np.zeros_like(objective.structure)
+            weights_internal = np.zeros(len(objective.structure) - 1)
             min_idx = 0
-            if not any(term.contains_deriv(objective.main_var_to_explain) for term in objective.structure):
+            while not any(term.contains_deriv(objective.main_var_to_explain) for term in objective.structure):
+            # while not any(term.contains_deriv() for term in objective.structure):
                 objective.restore_property(mandatory_family=False, deriv=True)
 
             for target_idx, target_term in enumerate(objective.structure):
                 if not objective.structure[target_idx].contains_deriv(objective.main_var_to_explain):
+                # if not objective.structure[target_idx].contains_deriv():
                     continue
                 objective.target_idx = target_idx
                 fitness = self.suboperators['fitness_calculation'].apply(objective, arguments = subop_args['fitness_calculation'], force_out_of_place = True)
@@ -66,12 +68,17 @@ def apply(self, objective : Equation, arguments : dict):
                 else:
                     pass
 
+            if all(weights_internal == 0):
+                objective.randomize()
+                continue
+
             objective.weights_internal = weights_internal
             objective.weights_internal_evald = True
             objective.target_idx = min_idx
             if not self.simplify_equation(objective):
                 objective.simplified = True
             if objective.structure[objective.target_idx].contains_deriv(objective.main_var_to_explain):
+            # if objective.structure[objective.target_idx].contains_deriv():
                 objective.is_correct_right_part = True
         else:
             objective.right_part_selected = True

epde/operators/multiobjective/moeadd_specific.py

@@ -225,7 +225,7 @@ def apply(self, objective: Tuple[Union[SoEq, ParetoLevels]], arguments: dict):
 
         # TODO: Init normalizer here!
         # print('objective is ', objective)
-        objective[1].set_normalizer()
+        # objective[1].set_normalizer()
 
         objective[1].update(objective[0])  # levels_updated = ndl_update(offspring, levels)
         if len(objective[1].levels) == 1:
@@ -582,17 +582,19 @@ def has_subset_pair(collection_of_sets):
     return False, None, None
 
 def is_rps_in_other_equation(objective):
-    rsterms = set()
+    rsterms = [None for _ in objective.vals]
     replaced = [False for _ in objective.vals]
-    for equation in objective.vals:
-        rsterms.add(equation.structure[equation.target_idx].described_variables_full)
     for equation_idx, equation in enumerate(objective.vals):
+        rsterms[equation_idx] = equation.structure[equation.target_idx].described_variables_full
+
+    for equation_idx, equation in enumerate(objective.vals):
+        rs = rsterms[:equation_idx] + rsterms[equation_idx + 1:]
         for term_idx, term in enumerate(equation.structure):
-            if term_idx != equation.target_idx and term.described_variables_full in rsterms:
+            if any(rsterm.issubset(term.described_variables_full) for rsterm in rs):
                 replaced[equation_idx] = True
                 term.randomize()
                 term.reset_saved_state()
-                while len(equation.described_variables_full) != len(equation.structure):
+                while any(rsterm.issubset(term.described_variables_full) for rsterm in rs) or len(equation.described_variables_full) != len(equation.structure):
                     term.randomize()
                     term.reset_saved_state()
     return replaced

epde/operators/multiobjective/variation.py

@@ -87,11 +87,11 @@ def apply(self, objective : ParetoLevels, arguments : dict):
 
                                                                                          arguments = subop_args['chromosome_crossover'])
 
-            # if len(new_system_1.vars_to_describe) > 1 and np.random.random() < 0.2:
-            #     key = np.random.choice(new_system_1.vars_to_describe)
-            #     temp = deepcopy(new_system_1.vals.chromosome[key])
-            #     new_system_1.vals.chromosome[key] = new_system_2.vals.chromosome[key]
-            #     new_system_2.vals.chromosome[key] = temp
+            if len(new_system_1.vars_to_describe) > 1 and np.random.random() < 0.2:
+                key = np.random.choice(new_system_1.vars_to_describe)
+                temp = deepcopy(new_system_1.vals.chromosome[key])
+                new_system_1.vals.chromosome[key] = new_system_2.vals.chromosome[key]
+                new_system_2.vals.chromosome[key] = temp
 
             offsprings.extend([new_system_1, new_system_2])
 

epde/optimizers/moeadd/population_constr.py

@@ -39,17 +39,29 @@ def applyToPassed(self, passed_solution: SoEq, **kwargs):
             passed_solution.use_default_multiobjective_function(self.use_pic)
 
     def create(self, **kwargs):
-        sparsity = kwargs.get('sparsity', 10 ** (np.random.uniform(low = np.log10(self.sparsity_interval[0]),
-                                                                      high = np.log10(self.sparsity_interval[1]),
-                                                                      size = len(self.vars_demand_equation))))
+        # sparsity = kwargs.get('sparsity', 10 ** (np.random.uniform(low = np.log10(self.sparsity_interval[0]),
+        #                                                               high = np.log10(self.sparsity_interval[1]),
+        #                                                               size = len(self.vars_demand_equation))))
+        # # nonzero_terms = kwargs.get('nonzero_terms', np.random.randint(low=1,
+        #                                                            high=self.terms_number,
+        #                                                            size=len(self.vars_demand_equation)))
+        # nu = kwargs.get('nu', 10 ** (np.random.uniform(low=np.log10(self.sparsity_interval[0]),
+        #                                                              high=np.log10(self.sparsity_interval[1]),
+        #                                                              size=len(self.vars_demand_equation))))
+        # threshold = kwargs.get('threshold', 10 ** (np.random.uniform(low=np.log10(self.sparsity_interval[0]),
+        #                                                            high=np.log10(self.sparsity_interval[1]),
+        #                                                            size=len(self.vars_demand_equation))))
         terms_number = kwargs.get('terms_number', self.terms_number)
         max_factors_in_term = kwargs.get('max_factors_in_term', self.max_factors_in_term)
 
-        print(f'Creating new equation, sparsity value {sparsity}')
+        # print(f'Creating new equation, sparsity value {sparsity}')
         metaparameters = {'terms_number'        : {'optimizable' : False, 'value' : terms_number},
                           'max_factors_in_term' : {'optimizable' : False, 'value' : max_factors_in_term}}
-        for idx, variable in enumerate(self.vars_demand_equation):
-            metaparameters[('sparsity', variable)] = {'optimizable' : True, 'value' : sparsity[idx]}
+        # for idx, variable in enumerate(self.vars_demand_equation):
+        #     metaparameters[('sparsity', variable)] = {'optimizable' : True, 'value' : sparsity[idx]}
+            # metaparameters[('nonzero_terms', variable)] = {'optimizable': True, 'value': nonzero_terms[idx]}
+            # metaparameters[('threshold', variable)] = {'optimizable': True, 'value': threshold[idx]}
+            # metaparameters[('nu', variable)] = {'optimizable': True, 'value': nu[idx]}
 
         created_solution = SoEq(pool = self.pool, metaparameters = metaparameters)
 

epde/structure/main_structures.py

@@ -306,13 +306,13 @@ def latex_form(self):
 
     def contains_deriv(self, variable=None):
         if variable is None:
-            return any([factor.is_deriv and factor.deriv_code != [None,] and
+            return sum([factor.is_deriv and factor.deriv_code != [None,] and
                         factor.evaluator._evaluator == simple_function_evaluator
-                        for factor in self.structure])
+                        for factor in self.structure]) == 1
         else:
-            return any([factor.variable == variable and factor.deriv_code != [None,] and
+            return sum([factor.variable == variable and factor.is_deriv and factor.deriv_code != [None,] and
                         factor.evaluator._evaluator == simple_function_evaluator
-                        for factor in self.structure])
+                        for factor in self.structure]) == 1
 
     def contains_variable(self, variable):
         return any([factor.variable == variable for factor in self.structure])
@@ -369,7 +369,13 @@ def described_variables(self):
     def described_variables_full(self):
         described = set()
         for factor in self.structure:
-            described.add(factor.cache_label)
+            if factor.ftype == 'trigonometric':
+                label = (factor.cache_label[0], tuple(
+                    factor.cache_label[1][i] for i, param in factor.params_description.items() if
+                    param['name'] != 'freq'))
+                described.add(label)
+            else:
+                described.add(factor.cache_label)
         described = frozenset(described)
         return described
 
@@ -443,16 +449,18 @@ def __init__(self, pool: TFPool, basic_structure: Union[list, tuple, set], var_t
 
         force_var_to_explain = True   # False
         for i in range(len(basic_structure), int(self.metaparameters['terms_number']['value'])):
-            check_test = 0
-            while True:
-                check_test += 1
-                mf = var_to_explain if force_var_to_explain else None
-                new_term = Term(self.pool, max_factors_in_term=self.metaparameters['max_factors_in_term']['value'],
-                                mandatory_family=mf, passed_term=None)
+            new_term = Term(self.pool, max_factors_in_term=self.metaparameters['max_factors_in_term']['value'],
+                            mandatory_family=None, passed_term=None)
+            while new_term.described_variables_full in self.described_variables_full:
+                new_term.randomize()
+                new_term.reset_saved_state()
+                # check_test += 1
+                #
+
 
-                if new_term.described_variables_full not in self.described_variables_full:
-                    force_var_to_explain = False
-                    break
+                # if new_term.described_variables_extra not in self.described_variables_full:
+                #     force_var_to_explain = False
+                #     break
 
             self.structure.append(new_term)
 
@@ -462,6 +470,7 @@ def __init__(self, pool: TFPool, basic_structure: Union[list, tuple, set], var_t
 
     def randomize(self):
         self.__init__(self.pool, [], self.main_var_to_explain, metaparameters=self.metaparameters)
+        self.reset_saved_state()
 
     def manual_reconst(self, attribute:str, value, except_attrs:dict):
         from epde.loader import attrs_from_dict, get_typespec_attrs
@@ -562,7 +571,7 @@ def reconstruct_by_right_part(self, right_part_idx):
         return new_eq
 
     def evaluate(self, normalize=True, return_val=False, grids=None):
-        target = self.structure[self.target_idx].evaluate(normalize, grids=grids)
+        target = self.structure[self.target_idx].evaluate(False, grids=grids)
 
         # Place for improvent: introduce shifted_idx where necessary
         def shifted_idx(idx):
@@ -580,9 +589,9 @@ def shifted_idx(idx):
             feature_indexes = [idx for idx in range(len(self.structure))
                                if self.weights_internal[shifted_idx(idx)] != 0 and idx != self.target_idx]
         if len(feature_indexes) > 0:
-            features = self.structure[feature_indexes[0]].evaluate(normalize, grids=grids)
+            features = self.structure[feature_indexes[0]].evaluate(False, grids=grids)
             for feat_idx in range(1, len(feature_indexes)):
-                temp = self.structure[feature_indexes[feat_idx]].evaluate(normalize, grids=grids)
+                temp = self.structure[feature_indexes[feat_idx]].evaluate(False, grids=grids)
                 features = np.vstack([features, temp])
             if features.ndim == 1:
                 features = np.expand_dims(features, 1).T