removed default_backend

Author: PavelMarian

fedot/api/api_utils/api_composer.py

@@ -25,9 +25,10 @@ class ApiParamsRepository:
 
     STATIC_INDIVIDUAL_METADATA_KEYS = {'use_input_preprocessing'}
 
-    def __init__(self, task_type: TaskTypesEnum):
+    def __init__(self, task_type: TaskTypesEnum, context: Optional[ExecutionContext] = None):
         self.task_type = task_type
         self.default_params = ApiParamsRepository.default_params_for_task(self.task_type)
+        self.context = context
 
     @staticmethod
     def default_params_for_task(task_type: TaskTypesEnum) -> dict:
@@ -75,14 +76,21 @@ def get_params_for_gp_algorithm_params(self, params: dict) -> dict:
         if params.get('genetic_scheme') == 'steady_state':
             gp_algorithm_params['genetic_scheme_type'] = GeneticSchemeTypesEnum.steady_state
 
-        # gp_algorithm_params['mutation_types'] = ApiParamsRepository._get_default_mutations(self.task_type, params)
-        gp_algorithm_params['mutation_types'] = context.api_params_repository__get_default_mutations(self.task_type,
-                                                                                                     params)
+        gp_algorithm_params['mutation_types'] = ApiParamsRepository._get_default_mutations(self.task_type, params,
+                                                                                           self.context)
         gp_algorithm_params['seed'] = params['seed']
         return gp_algorithm_params
 
+
+    @staticmethod
+    def _get_default_mutations(task_type: TaskTypesEnum, params, context: Optional[ExecutionContext] = None) -> Sequence[MutationTypesEnum]:
+        if context:
+            return context.default_mutations.get_default_mutation(task_type, params)
+        else:
+            return _get_default_mutations_core(task_type, params)
+
     @staticmethod
-    def _get_default_mutations(task_type: TaskTypesEnum, params) -> Sequence[MutationTypesEnum]:
+    def _get_default_mutations_core(task_type: TaskTypesEnum, params) -> Sequence[MutationTypesEnum]:
         mutations = [parameter_change_mutation,
                      MutationTypesEnum.single_change,
                      MutationTypesEnum.single_drop,

fedot/api/api_utils/api_params_repository.py

@@ -51,7 +51,7 @@
 from fedot.utilities.define_metric_by_task import MetricByTask
 from fedot.utilities.memory import MemoryAnalytics
 from fedot.utilities.project_import_export import export_project_to_zip, import_project_from_zip
-from fedot.core.context.context import ExecutionContext
+from fedot.core.contex.context import ExecutionContext
 
 NOT_FITTED_ERR_MSG = 'Model not fitted yet'
 
@@ -107,11 +107,11 @@ def __init__(self,
                  **composer_tuner_params
                  ):
 
+        self.context = ExecutionContext(extension_name=context)
+
         set_random_seed(seed)
         self.log = self._init_logger(logging_level)
 
-        self.context = ExecutionContext(extension_name=context)
-
         # Attributes for dealing with metrics, data sources and hyperparameters
         self.params = ApiParams(composer_tuner_params, problem, task_params, n_jobs, timeout, seed)
 
@@ -303,7 +303,8 @@ def tune_tensordata(self,
                               .with_n_jobs(common_tune_plan.n_jobs)
                               .with_metric(common_tune_plan.metric)
                               .with_iterations(iterations)
-                              .with_timeout(timeout))
+                              .with_timeout(timeout)
+                              .with_context(self.context))
             pipeline_tuner = getattr(pipeline_tuner, tune_plan.builder_method_name)(
                 tensor_data if tune_plan.use_tensor_runtime else common_tune_plan.input_data
             )
@@ -377,6 +378,7 @@ def tune(self,
                               .with_metric(tune_plan.metric)
                               .with_iterations(iterations)
                               .with_timeout(timeout)
+                              .with_context(self.context)
                               .build(tune_input_data))
 
             self.current_pipeline = pipeline_tuner.tune(self.current_pipeline, show_progress=show_progress)
@@ -682,7 +684,8 @@ def get_metrics(self,
                                              data_producer=lambda: (yield self.train_data, self.test_data),
                                              validation_blocks=validation_blocks,
                                              eval_n_jobs=self.params.n_jobs,
-                                             do_unfit=False)
+                                             do_unfit=False,
+                                             context=self.context)
 
         metrics = obj_eval.evaluate(self.current_pipeline).values
         metrics = {metric_name: round(abs(metric), rounding_order) for (metric_name, metric) in

fedot/api/main.py

@@ -13,9 +13,9 @@
 from fedot.core.caching.operations_cache import OperationsCache
 from fedot.core.caching.preprocessing_cache import PreprocessingCache
 from fedot.core.caching.predictions_cache import PredictionsCache
-from fedot.core.context import ExecutionContext
 from fedot.core.composer.composer import Composer
 from fedot.core.composer.gp_composer.gp_composer import GPComposer
+from fedot.core.context.context import ExecutionContext
 from fedot.core.optimisers.objective.metrics_objective import MetricsObjective
 from fedot.core.pipelines.pipeline import Pipeline
 from fedot.core.pipelines.pipeline_composer_requirements import PipelineComposerRequirements
@@ -61,8 +61,9 @@ def __init__(self, task: Task):
 
         self.context: Optional[ExecutionContext] = None
 
-    def with_context(self, context: ExecutionContext):
-        self.context = context or ExecutionContext()
+    def with_context(self, context):
+        if context:
+            self.context = context
         return self
 
     def with_composer(self, composer_cls: Optional[Type[Composer]]):
@@ -118,8 +119,7 @@ def with_cache(self,
     @staticmethod
     def _get_default_composer_params(task: Task) -> PipelineComposerRequirements:
         # Get all available operations for task
-        # operations = get_operations_for_task(task=task, mode='all')
-        operations = self.context.operation_registry.get_operation_for_task(task=task, mode='all')
+        operations = get_operations_for_task(task=task, mode='all')
         return PipelineComposerRequirements(primary=operations, secondary=operations)
 
     def _get_default_graph_generation_params(self) -> GraphGenerationParams:
@@ -169,7 +169,6 @@ def build(self) -> Composer:
                                      self.composer_requirements,
                                      self.operations_cache,
                                      self.preprocessing_cache,
-                                     self.predictions_cache,
-                                     self.context)
+                                     self.predictions_cache)
 
         return composer

fedot/core/composer/composer_builder.py

@@ -11,10 +11,10 @@
 from fedot.core.caching.operations_cache import OperationsCache
 from fedot.core.caching.predictions_cache import PredictionsCache
 from fedot.core.caching.preprocessing_cache import PreprocessingCache
-from fedot.core.context.context import ExecutionContext
 from fedot.core.composer.composer import Composer
 from fedot.core.data.data import InputData
 from fedot.core.data.multi_modal import MultiModalData
+from fedot.core.context.context import ExecutionContext
 from fedot.core.optimisers.objective.data_objective_eval import (
     PipelineObjectiveEvaluate,
 )
@@ -25,7 +25,6 @@
 )
 from fedot.core.utils import default_fedot_data_dir
 
-from functools import partial
 
 class GPComposer(Composer):
     """
@@ -43,23 +42,23 @@ def __init__(self, optimizer: GraphOptimizer,
                  operations_cache: Optional[OperationsCache] = None,
                  preprocessing_cache: Optional[PreprocessingCache] = None,
                  predictions_cache: Optional[PredictionsCache] = None,
-                 context: Optional[ExecutionContext] = None):
+                 context: Optional[str] = None,):
         super().__init__(optimizer, composer_requirements)
         self.composer_requirements = composer_requirements
         self.operations_cache: Optional[OperationsCache] = operations_cache
         self.preprocessing_cache: Optional[PreprocessingCache] = preprocessing_cache
         self.predictions_cache: Optional[PredictionsCache] = predictions_cache
 
         self.best_models: Collection[Pipeline] = ()
-
-        self.context = context or ExecutionContext()
+        self.context = ExecutionContext(extension_name=context)
 
     def compose_pipeline(self, data: Union[InputData, MultiModalData]) -> Union[Pipeline, Sequence[Pipeline]]:
         # Define data source
         data_splitter = DataSourceSplitter(self.composer_requirements.cv_folds,
                                            shuffle=True)
-
-        data_producer = self.context.data_source_splitter_build(data_splitter, data)
+        if self.context:
+            data_splitter.build = self.context.data_source_splitter.build
+        data_producer = data_splitter.build(data)
 
         parallelization_mode = self.composer_requirements.parallelization_mode
         if parallelization_mode == 'populational':
@@ -77,10 +76,10 @@ def compose_pipeline(self, data: Union[InputData, MultiModalData]) -> Union[Pipe
                                                         preprocessing_cache=self.preprocessing_cache,
                                                         predictions_cache=self.predictions_cache,
                                                         validation_blocks=data_splitter.validation_blocks,
-                                                        eval_n_jobs=n_jobs_for_evaluation)
+                                                        eval_n_jobs=n_jobs_for_evaluation,
+                                                        context=context)
 
-        # objective_function = objective_evaluator.evaluate
-        objective_function = partial(self.context.evaluator_evaluate, objective_evaluator)
+        objective_function = objective_evaluator.evaluate
 
         # Define callback for computing intermediate metrics if needed
         if self.composer_requirements.collect_intermediate_metric:

fedot/core/composer/gp_composer/gp_composer.py

@@ -1,69 +1,33 @@
 from typing import Dict, Any, Optional, Callable
 from fedot.extensions.registry import get_registered_extension, register_extension
-from fedot.core.context.industrial_manifest import FEDOT_INDUSTRIAL_MANIFEST
 
-register_extension(FEDOT_INDUSTRIAL_MANIFEST)
 
 class ExecutionContext:
-    def __init__(self, extension_name: str = "core", extra_params: Optional[Dict[str, Any]] = None):
+    def __init__(self, extension_name: str = "industrial", extra_params: Optional[Dict[str, Any]] = None):
         self.extension_name = extension_name
         self.extra_params = extra_params or {}
         self._instances: Dict[str, Any] = {}
         self._overridden: Dict[str, Any] = {}
 
-        self._manifest = None
-        if extension_name != "core":
-            from fedot.extensions.registry import _REGISTERED_EXTENSIONS
-            manifest = _REGISTERED_EXTENSIONS.get(extension_name)
-            if manifest is None:
-                raise ValueError(f"Extension '{extension_name}' not registered")
-            self._manifest = manifest
-
-        self._core_implementations = self._get_core_implementations()
-
-        self._protocol_classes = self._core_implementations.copy()
-        if self._manifest and self._manifest.protocols:
-            self._protocol_classes.update(self._manifest.protocols)
-
-    def _get_core_implementations(self) -> Dict[str, Callable]:
-        from fedot.core.context.default_backend import (
-            CoreSplitter, CoreDataMerger, CoreImageMerger,
-            CoreTSMerger, CoreTextMerger, CoreTuner,
-            CoreDataSourceSplitter, CoreOperationPredict,
-            CoreLaggedTransformer, CoreTopologicalFeatures,
-            CoreTsSmoothing, CoreApiComposerTune, CoreReproduction,
-            CoreSearchSpace, CoreDefaultMutations, CoreEvaluator
-        )
-        return {
-            "splitter": CoreSplitter,
-            "data_merger": CoreDataMerger,
-            "image_merger": CoreImageMerger,
-            "ts_merger": CoreTSMerger,
-            "text_merger": CoreTextMerger,
-            "tuner_class": CoreTuner,
-            "data_source_splitter": CoreDataSourceSplitter,
-            "operation_predict": CoreOperationPredict,
-            "lagged_transformer": CoreLaggedTransformer,
-            "topological_features": CoreTopologicalFeatures,
-            "ts_smoothing": CoreTsSmoothing,
-            "api_composer_tune": CoreApiComposerTune,
-            "reproduction": CoreReproduction,
-            "search_space": CoreSearchSpace,
-            "default_mutations": CoreDefaultMutations,
-            "evaluator": CoreEvaluator,
-        }
+        manifest = get_registered_extension(extension_name)
+        if manifest is None:
+            raise ValueError(f"Extension '{extension_name}' not registered")
+        self._manifest = manifest
 
-    def _get_protocol_class(self, protocol_name: str) -> Callable:
-        if self._manifest and self._manifest.protocols:
-            if protocol_name in self._manifest.protocols:
-                return self._manifest.protocols[protocol_name]
-
-        if protocol_name in self._core_implementations:
-            return self._core_implementations[protocol_name]
+        self._protocol_classes = self._manifest.protocols or {}
 
+    def _get_protocol_class(self, protocol_name: str) -> Callable:
+        if protocol_name in self._protocol_classes:
+            return self._protocol_classes[protocol_name]
         raise ValueError(f"No implementation for protocol '{protocol_name}'")
 
     def _get_instance(self, protocol_name: str) -> Any:
+        if protocol_name in self._overridden:
+            override = self._overridden[protocol_name]
+            if isinstance(override, type):
+                return override(**self.extra_params)
+            return override
+
         if protocol_name not in self._instances:
             protocol_class = self._get_protocol_class(protocol_name)
             self._instances[protocol_name] = protocol_class(**self.extra_params)
@@ -135,7 +99,7 @@ def evaluator(self):
 
     def __setattr__(self, name: str, value: Any) -> None:
         if name in ('extra_params', '_instances', '_overridden', '_protocol_classes',
-                    '_manifest', '_core_implementations', 'extension_name'):
+                    '_manifest', 'extension_name'):
             super().__setattr__(name, value)
         else:
             self._overridden[name] = value
@@ -144,7 +108,7 @@ def __getattr__(self, name: str):
         if name in self._overridden:
             return self._overridden[name]
 
-        if name in ('_protocol_classes', '_instances', '_manifest', '_core_implementations'):
+        if name in ('_protocol_classes', '_instances', '_manifest'):
             return super().__getattribute__(name)
 
-        raise AttributeError(f"'{type(self).__name__}' object has no attribute '{name}'")
+        raise AttributeError(f"'{type(self).__name__}' object has no attribute '{name}'")