code: def build(self) -> Composer:
      multi_objective = len(self.metrics) > 1
      if not self.composer_requirements:
          self.composer_requirements = (
              self._get_default_composer_params(self.task)
          )
      if not self.graph_generation_params:
          self.graph_generation_params = (
              self._get_default_graph_generation_params()
          )
      if not self.optimizer_parameters:
          self.optimizer_parameters = GPAlgorithmParameters(
              multi_objective=multi_objective
          )
      if not multi_objective:
          # Add default complexity metric for supplementary comparison of individuals with equal fitness
          self.metrics = (
              self.metrics + self._get_default_complexity_metrics()
          )
      if RemoteEvaluator().is_enabled:
          # This explicit passing of singleton evaluator isolates optimizer
          #  from knowing about it. Needed for separation of FEDOT from GOLEM.
          #  Best solution would be to avoid singleton init & access altogether,
          #  instead passing remote evaluator & its params explicitly through API.
          self.graph_generation_params.remote_evaluator = (
              RemoteEvaluator()
          )
  
      objective = MetricsObjective(self.metrics, multi_objective)
  
      initial_population = (
          InitialPopulationGenerator(
              self.optimizer_parameters.pop_size,
              self.graph_generation_params,
              self.composer_requirements,
          )
          .with_initial_graphs(self.initial_population)
          .with_custom_generation_function(
              self.initial_population_generation_function
          )()
      )
  
      optimiser = self.optimizer_cls(
          objective=objective,
          initial_graphs=initial_population,
          requirements=self.composer_requirements,
          graph_generation_params=self.graph_generation_params,
          graph_optimizer_params=self.optimizer_parameters,
      )
  
      composer = self.composer_cls(
          optimiser,
          self.composer_requirements,
          self.pipelines_cache,
          self.preprocessing_cache,
      )
  
      return composer
  
imports: import platform
  from multiprocessing import set_start_method
  from pathlib import Path
  from typing import List, Optional, Sequence, Type, Union
  from golem.core.log import LoggerAdapter, default_log
  from golem.core.optimisers.genetic.gp_optimizer import EvoGraphOptimizer
  from golem.core.optimisers.genetic.gp_params import GPAlgorithmParameters
  from golem.core.optimisers.initial_graphs_generator import GenerationFunction, InitialPopulationGenerator
  from golem.core.optimisers.optimizer import AlgorithmParameters, GraphGenerationParams, GraphOptimizer
  from golem.utilities.data_structures import ensure_wrapped_in_sequence
  from fedot.core.caching.pipelines_cache import OperationsCache
  from fedot.core.caching.preprocessing_cache import PreprocessingCache
  from fedot.core.composer.composer import Composer
  from fedot.core.composer.gp_composer.gp_composer import GPComposer
  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
  from fedot.core.pipelines.pipeline_graph_generation_params import get_pipeline_generation_params
  from fedot.core.pipelines.verification import rules_by_task
  from fedot.core.repository.operation_types_repository import get_operations_for_task
  from fedot.core.repository.metrics_repository import ComplexityMetricsEnum, MetricIDType, MetricsEnum
  from fedot.core.repository.tasks import Task
  from fedot.remote.remote_evaluator import RemoteEvaluator
  from fedot.utilities.define_metric_by_task import MetricByTask
label_desc: Use image node_id 14 for calling the ComposerBuilder obj's underlying member method code with example usage: obj.build() and returns: composer