Mutation operator

Created by: YamLyubov

Mutation functions are wraped in a Mutation class. #706

fedot/core/optimisers/gp_comp/operators/mutation.py

from functools import partial
from random import choice, randint, random, sample
from typing import TYPE_CHECKING, Any, Callable, List, Optional, Union
import numpy as np
from fedot.core.composer.advisor import RemoveType
+from fedot.core.dag.graph_node import GraphNode
from fedot.core.log import default_log
from fedot.core.optimisers.gp_comp.gp_operators import random_graph
from fedot.core.optimisers.gp_comp.individual import Individual, ParentOperator
+from fedot.core.optimisers.gp_comp.operators.operator import PopulationT
from fedot.core.optimisers.graph import OptGraph
from fedot.core.utilities.data_structures import ComparableEnum as Enum
if TYPE_CHECKING:

fedot/core/optimisers/gp_comp/gp_optimiser.py

selected_individuals = selection(types=self.parameters.selection_types,
population=individuals_to_select,
-                                                pop_size=pop_size,
+                                                pop_size=self.requirements.pop_size,
params=self.graph_generation_params)
new_population = self._reproduce(selected_individuals)
+               new_population = self.mutation(new_population)
+
new_population = evaluator(new_population)
-               new_population = self._inheritance(new_population, pop_size)
+               new_population = self._inheritance(new_population)
# Adding of new population to history
self._next_population(new_population)
+               self._update_requirements()

fedot/core/optimisers/gp_comp/gp_optimiser.py

def current_generation_num(self) -> int:
return self.generations.generation_num
-   def _extend_population(self, initial_individuals, pop_size: int, max_depth: int):
+   def _extend_population(self, initial_individuals):
iter_num = 0
-       initial_graphs = [ind.graph for ind in self.initial_individuals]
-       while len(initial_individuals) < pop_size:
+       initial_graphs = [ind.graph for ind in initial_individuals]
+       while len(initial_individuals) < self.requirements.pop_size:
initial_req = deepcopy(self.requirements)
initial_req.mutation_prob = 1
-
-           new_ind = self._mutate(choice(self.initial_individuals), max_depth, custom_requirements=initial_req)
+           self.mutation.update_requirements(initial_req)
+           new_ind = self.mutation(choice(self.initial_individuals))

fedot/core/composer/gp_composer/specific_operators.py

 from random import choice, random
 from typing import Any, List
 
-from fedot.core.optimisers.gp_comp.operators.mutation import get_mutation_prob
+from fedot.core.optimisers.gp_comp.operators.mutation import Mutation
 from fedot.core.pipelines.node import PrimaryNode, SecondaryNode
 from fedot.core.pipelines.pipeline import Pipeline
 from fedot.core.pipelines.tuning.hyperparams import ParametersChanger
@@ -15,8 +15,8 @@ def parameter_change_mutation(pipeline: Pipeline, requirements, **kwargs) -> Any
     hyperparameters of the operations with probability - 'node mutation probability'
     which is initialised inside the function
     """
-    node_mutation_probability = get_mutation_prob(mut_id=requirements.mutation_strength,
-                                                  node=pipeline.root_node)
+    node_mutation_probability = Mutation.get_mutation_prob(mut_id=requirements.mutation_strength,
+                                                           node=pipeline.root_node)
     for node in pipeline.nodes:
         if random() < node_mutation_probability:
             operation_name = node.operation.operation_type

fedot/core/optimisers/gp_comp/gp_optimiser.py

@@ -13,7 +13,7 @@ from fedot.core.optimisers.gp_comp.individual import Individual
 from fedot.core.optimisers.gp_comp.operators.crossover import CrossoverTypesEnum, crossover
 from fedot.core.optimisers.gp_comp.operators.elitism import Elitism, ElitismTypesEnum
 from fedot.core.optimisers.gp_comp.operators.inheritance import GeneticSchemeTypesEnum, inheritance
-from fedot.core.optimisers.gp_comp.operators.mutation import MutationTypesEnum, mutation
+from fedot.core.optimisers.gp_comp.operators.mutation import MutationTypesEnum, Mutation
 from fedot.core.optimisers.gp_comp.operators.operator import PopulationT
 from fedot.core.optimisers.gp_comp.operators.regularization import RegularizationTypesEnum, regularized_population
 from fedot.core.optimisers.gp_comp.operators.selection import SelectionTypesEnum, crossover_parents_selection, selection
@@ -96,6 +96,7 @@ class EvoGraphOptimiser(GraphOptimiser):
         super().__init__(objective, initial_graphs, requirements, graph_generation_params, parameters)
         self.parameters = parameters or GPGraphOptimiserParameters()
         self.elitism = Elitism(self.parameters.elitism_type, requirements, objective.is_multi_objective)
+        self.mutation = Mutation(parameters.mutation_types, graph_generation_params, requirements)
         self.population = None
         self.generations = GenerationKeeper(self.objective, keep_n_best=requirements.keep_n_best)
         self.timer = OptimisationTimer(timeout=self.requirements.timeout)
@@ -126,15 +127,19 @@ class EvoGraphOptimiser(GraphOptimiser):
         self._operators_prob = \
             init_adaptive_operators_prob(parameters.genetic_scheme_type, requirements)
 
-        # Define parameters
-
         start_depth = requirements.start_depth or requirements.max_depth
+
         self._graph_depth = AdaptiveGraphDepth(self.generations,
                                                start_depth=start_depth,
                                                max_depth=requirements.max_depth,
                                                max_stagnated_generations=parameters.depth_increase_step,
                                                adaptive=parameters.with_auto_depth_configuration)
-        self.max_depth = self._graph_depth.initial
+
+        # Define parameters
+
+        self.requirements.max_depth = self._graph_depth.initial
+
+        self.requirements.pop_size = self._pop_size.initial
 
         self.initial_individuals = \
             [Individual(self.graph_generation_params.adapter.adapt(graph)) for graph in initial_graphs]
@@ -143,14 +148,14 @@ class EvoGraphOptimiser(GraphOptimiser):
     def current_generation_num(self) -> int:
         return self.generations.generation_num
 
-    def _extend_population(self, initial_individuals, pop_size: int, max_depth: int):
+    def _extend_population(self, initial_individuals):
         iter_num = 0
-        initial_graphs = [ind.graph for ind in self.initial_individuals]
-        while len(initial_individuals) < pop_size:
+        initial_graphs = [ind.graph for ind in initial_individuals]
+        while len(initial_individuals) < self.requirements.pop_size:
             initial_req = deepcopy(self.requirements)
             initial_req.mutation_prob = 1
-
-            new_ind = self._mutate(choice(self.initial_individuals), max_depth, custom_requirements=initial_req)
+            self.mutation.update_requirements(initial_req)
+            new_ind = self.mutation(choice(self.initial_individuals))
             new_graph = new_ind.graph
             iter_num += 1
             if new_graph not in initial_graphs and self.graph_generation_params.verifier(new_graph):
@@ -158,8 +163,10 @@ class EvoGraphOptimiser(GraphOptimiser):
                 initial_graphs.append(new_graph)
             if iter_num > MAXIMAL_ATTEMPTS_NUMBER:
                 self.log.warning(f'Exceeded max number of attempts for extending initial graphs, stopping.'
-                                 f'Current size {len(self.initial_individuals)} instead of {pop_size} graphs.')
+                                 f'Current size {len(self.initial_individuals)} '
+                                 f'instead of {self.requirements.pop_size} graphs.')
                 break
+        self.mutation.update_requirements(self.requirements)
         return initial_individuals
 
     def _next_population(self, next_population: PopulationT):
@@ -167,18 +174,12 @@ class EvoGraphOptimiser(GraphOptimiser):
         self.generations.append(next_population)
         self._optimisation_callback(next_population, self.generations)
         self.population = next_population
-        self._operators_prob_update()
 
         self.log.info(f'Generation num: {self.current_generation_num}')
         self.log.info(f'Best individuals: {str(self.generations)}')
         self.log.info(f'no improvements for {self.generations.stagnation_duration} iterations')
         self.log.info(f'spent time: {round(self.timer.minutes_from_start, 1)} min')
 
-    def _operators_prob_update(self):
-        if not self.generations.is_any_improved:
-            self.requirements.mutation_prob, self.requirements.crossover_prob = \
-                self._operators_prob.next(self.population)
-
     def set_evaluation_callback(self, callback: Optional[GraphFunction]):
         # Redirect callback to evaluation dispatcher
         self.eval_dispatcher.set_evaluation_callback(callback)
@@ -199,17 +200,14 @@ class EvoGraphOptimiser(GraphOptimiser):
 
             # Adding of initial assumptions to history as zero generation
             self._next_population(evaluator(self.initial_individuals))
-            pop_size = self._pop_size.initial
-            if len(self.initial_individuals) < pop_size:
-                self.initial_individuals = self._extend_population(self.initial_individuals, pop_size, self.max_depth)
-                # Adding of extended population to history as zero generation
+
+            if len(self.initial_individuals) < self.requirements.pop_size:
+                self.initial_individuals = self._extend_population(self.initial_individuals)
+                # Adding of extended population to history
                 self._next_population(evaluator(self.initial_individuals))
 
             while not self.stop_optimisation():
-                pop_size = self._pop_size.next(self.population)
-                self.max_depth = self._graph_depth.next()
-                self.log.info(f'Next population size: {pop_size}; max graph depth: {self.max_depth}')
-
+                self._update_requirements()
                 individuals_to_select = regularized_population(self.parameters.regularization_type,
                                                                self.population,
                                                                evaluator,
@@ -217,13 +215,15 @@ class EvoGraphOptimiser(GraphOptimiser):
 
                 selected_individuals = selection(types=self.parameters.selection_types,
                                                  population=individuals_to_select,
-                                                 pop_size=pop_size,
+                                                 pop_size=self.requirements.pop_size,
                                                  params=self.graph_generation_params)
                 new_population = self._reproduce(selected_individuals)
 
+                new_population = self.mutation(new_population)
+
                 new_population = evaluator(new_population)
 
-                new_population = self._inheritance(new_population, pop_size)
+                new_population = self._inheritance(new_population)
 
                 new_population = self.elitism(self.generations.best_individuals, new_population)
 
@@ -232,27 +232,28 @@ class EvoGraphOptimiser(GraphOptimiser):
         all_best_graphs = [ind.graph for ind in self.generations.best_individuals]
         return all_best_graphs
 
-    def _inheritance(self, offspring: PopulationT, pop_size: int) -> PopulationT:
-        """Gather next population given new offspring and previous population.
+    def _update_requirements(self):
+        if not self.generations.is_any_improved:
+            self.requirements.mutation_prob, self.requirements.crossover_prob = \
+                self._operators_prob.next(self.population)
+        self.requirements.pop_size = self._pop_size.next(self.population)
+        self.requirements.max_depth = self._graph_depth.next()
+        self.log.info(
+            f'Next population size: {self.requirements.pop_size}; max graph depth: {self.requirements.max_depth}')
+        self.mutation.update_requirements(self.requirements)
+
+    def _inheritance(self, offspring: PopulationT) -> PopulationT:
+        """Gather next population given new offspring, previous population and elite individuals.
         :param offspring: offspring of current population.
-        :param pop_size: size of the next population.
         :return: next population."""
 
         # TODO: from inheritance together with elitism we can get duplicate inds!
         offspring = inheritance(self.parameters.genetic_scheme_type, self.parameters.selection_types,
                                 self.population,
-                                offspring, pop_size,
+                                offspring, self.requirements.pop_size,
                                 graph_params=self.graph_generation_params)
         return offspring
 
-    def _mutate(self, individual: Individual,
-                max_depth: Optional[int] = None,
-                custom_requirements: Optional[PipelineComposerRequirements] = None) -> Individual:
-        max_depth = max_depth or self.max_depth
-        requirements = custom_requirements or self.requirements
-        return mutation(types=self.parameters.mutation_types, params=self.graph_generation_params,
-                        individual=individual, requirements=requirements, max_depth=max_depth)
-
     def _reproduce(self, population: PopulationT) -> PopulationT:
         if len(population) == 1:
             new_population = population
@@ -260,12 +261,12 @@ class EvoGraphOptimiser(GraphOptimiser):
             new_population = []
             for ind_1, ind_2 in crossover_parents_selection(population):
                 new_population += self._crossover_pair(ind_1, ind_2)
-        new_population = list(map(self._mutate, new_population))
         return new_population
 
     def _crossover_pair(self, individual1: Individual, individual2: Individual) -> Sequence[Individual]:
-        return crossover(self.parameters.crossover_types, individual1, individual2, max_depth=self.max_depth,
-                         crossover_prob=self.requirements.crossover_prob, params=self.graph_generation_params)
+        return crossover(self.parameters.crossover_types, individual1, individual2,
+                         max_depth=self.requirements.max_depth, crossover_prob=self.requirements.crossover_prob,
+                         params=self.graph_generation_params)
 
 
 def _unfit_pipeline(graph: Any):

test/unit/composer/test_composer.py

@@ -15,18 +15,14 @@ from fedot.core.composer.composer_builder import ComposerBuilder
 from fedot.core.composer.gp_composer.gp_composer import GPComposer, PipelineComposerRequirements
 from fedot.core.composer.random_composer import RandomGraphFactory, RandomSearchComposer, RandomSearchOptimiser
 from fedot.core.data.data import InputData
-from fedot.core.optimisers.adapters import PipelineAdapter
 from fedot.core.optimisers.gp_comp.gp_operators import random_graph
 from fedot.core.optimisers.gp_comp.gp_optimiser import GeneticSchemeTypesEnum, GPGraphOptimiserParameters
 from fedot.core.optimisers.gp_comp.operators.mutation import MutationStrengthEnum
 from fedot.core.optimisers.gp_comp.operators.selection import SelectionTypesEnum
 from fedot.core.optimisers.objective import Objective
-from fedot.core.optimisers.optimizer import GraphGenerationParams
 from fedot.core.pipelines.node import PrimaryNode, SecondaryNode
 from fedot.core.pipelines.pipeline import Pipeline
 from fedot.core.pipelines.pipeline_graph_generation_params import get_pipeline_generation_params
-from fedot.core.pipelines.pipeline_node_factory import PipelineOptNodeFactory
-from fedot.core.pipelines.verification import verifier_for_task
 from fedot.core.repository.dataset_types import DataTypesEnum
 from fedot.core.repository.operation_types_repository import OperationTypesRepository, get_operations_for_task
 from fedot.core.repository.quality_metrics_repository import ClassificationMetricsEnum, ComplexityMetricsEnum
@@ -275,7 +271,7 @@ def test_gp_composer_with_start_depth(data_fixture, request):
     composer = builder.build()
     composer.compose_pipeline(data=dataset_to_compose)
     assert all([ind.graph.depth <= 3 for ind in composer.history.individuals[0]])
-    assert composer.optimiser.max_depth == 2
+    assert composer.optimiser.requirements.max_depth == 2
 
 
 @pytest.mark.parametrize('data_fixture', ['file_data_setup'])

test/unit/composer/test_history.py

@@ -17,7 +17,7 @@ from fedot.core.optimisers.fitness import SingleObjFitness
 from fedot.core.optimisers.gp_comp.evaluation import MultiprocessingDispatcher
 from fedot.core.optimisers.gp_comp.individual import Individual, ParentOperator
 from fedot.core.optimisers.gp_comp.operators.crossover import crossover, CrossoverTypesEnum
-from fedot.core.optimisers.gp_comp.operators.mutation import MutationTypesEnum, mutation
+from fedot.core.optimisers.gp_comp.operators.mutation import MutationTypesEnum, Mutation
 from fedot.core.optimisers.objective.data_objective_builder import DataObjectiveBuilder
 from fedot.core.optimisers.objective.objective import Objective
 from fedot.core.optimisers.opt_history import OptHistory
@@ -66,13 +66,15 @@ def test_ancestor_for_mutation():
 
     available_operations = ['linear']
     composer_requirements = PipelineComposerRequirements(primary=available_operations,
-                                                         secondary=available_operations, mutation_prob=1)
+                                                         secondary=available_operations, mutation_prob=1,
+                                                         max_depth=2)
 
     graph_params = get_pipeline_generation_params(requirements=composer_requirements,
                                                   rules_for_constraint=DEFAULT_DAG_RULES)
+    mutation = Mutation(mutation_types=[MutationTypesEnum.simple], graph_generation_params=graph_params,
+                        requirements=composer_requirements)
 
-    mutation_result = mutation(types=[MutationTypesEnum.simple], params=graph_params, individual=parent_ind,
-                               requirements=composer_requirements, max_depth=2)
+    mutation_result = mutation(parent_ind)
 
     assert len(mutation_result.parent_operators) > 0
     assert mutation_result.parent_operators[-1].operator_type == 'mutation'

[Elizaveta Lutsenko]

Created by: codecov[bot]

Codecov Report

Merging #776 (d3f6d7ae) into master (4389b7f4) will decrease coverage by 0.34%. The diff coverage is 92.62%.

@@            Coverage Diff             @@
##           master     #776      +/-   ##
==========================================
- Coverage   88.14%   87.79%   -0.35%     
==========================================
  Files         182      182              
  Lines       12496    12508      +12     
==========================================
- Hits        11014    10981      -33     
- Misses       1482     1527      +45     

Impacted Files	Coverage Δ
...edot/core/optimisers/gp_comp/operators/mutation.py	92.85% <91.62%> (+2.29%)
...ot/core/composer/gp_composer/specific_operators.py	95.45% <100.00%> (ø)
fedot/core/optimisers/gp_comp/gp_optimiser.py	97.16% <100.00%> (ø)
...lementations/data_operations/ts_transformations.py	74.48% <0.00%> (-13.27%)
...ore/optimisers/gp_comp/parameters/mutation_prob.py	96.00% <0.00%> (-4.00%)
fedot/core/data/merge/data_merger.py	97.87% <0.00%> (-1.07%)
fedot/core/optimisers/gp_comp/evaluation.py	97.63% <0.00%> (-0.79%)
...entations/models/ts_implementations/statsmodels.py	91.83% <0.00%> (-0.69%)
fedot/core/composer/advisor.py	92.00% <0.00%> (ø)
fedot/core/pipelines/pipeline.py	99.42% <0.00%> (+0.57%)
... and 4 more

---

Continue to review full report at Codecov.

Legend - Click here to learn more Δ = absolute <relative> (impact), ø = not affected, ? = missing data Powered by Codecov. Last update 4389b7f...d3f6d7a. Read the comment docs.

[Elizaveta Lutsenko]

Created by: gkirgizov

Тут этот if правда нужен? Можно ли избежать циклического импорта?

[Elizaveta Lutsenko]

Created by: YamLyubov

Здесь можно вынести из под if GraphGenerationParams, но c PipelineComposerRequirements не получится. Проблема в том, что мы в mutation определяем MutationStrengthEnum, который импортится в gp_composer. В тоже время мы импортим PipelineComposerRequirements в mutation из gp_optimiser. Я так понимаю, что решить это можно переносом класса MutationStrengthEnum в gp_composer, что не интуитивно.

[Elizaveta Lutsenko]

Created by: gkirgizov

Посмотрел на это тоже. Скорее,стоит передвинуть ComposerRequirements -> optimizer.py и PipelineComposerRequirements -> gp_opimiser.py. Они и по использованиям принадлежат этим модулям и логически, тк описывают параметры, используемые именно оптимизатором. Вроде бы это должно разорвать циклы. Также в pipeline_node_factory есть такой цикл с if. Может еще где есть, я бы просмотрел импорты в usages

[Elizaveta Lutsenko]

Created by: gkirgizov

может, вместо того, чтобы вызывать и перед, и в конце цикла, можно вызывать этот метод в начале цикла?

[Elizaveta Lutsenko]

Created by: gkirgizov

я бы тут добавил откат к исходным requirements, чтобы было очевидно, что это временная подмена параметров

[Elizaveta Lutsenko]

Created by: gkirgizov

Review: Approved

пара небольших комментов, в остальном все хорошо. удобно, что все изменения параметров из requirements теперь находятся в одном месте в оптимизаторе -- логика стала чуть очевиднее

[Elizaveta Lutsenko]

Merged by: YamLyubov at 2022-07-25 10:43:53 UTC

[Elizaveta Lutsenko]

Created by: gkirgizov

может, вместо того, чтобы вызывать и перед, и в конце цикла, можно вызывать этот метод в начале цикла?