class_docstr: Base class used for composite model structure definition
  
  Args:
      nodes: :obj:`PipelineNode` object(s)
      use_input_preprocessing: whether to do input preprocessing or not, ``True`` by default.
docstr: Runs training process in all of the pipeline nodes starting with root
  
  Args:
      input_data: data used for operation training
      process_state_dict: dictionary used for saving required pipeline parameters
          (which were changed inside the process) in case of operations fit time control (when process created)
      fitted_operations: list used for saving fitted operations of pipeline nodes
  
  Returns:
      Optional[OutputData]: values predicted on the provided ``input_data`` or nothing
      in case of the time controlled call
docstr_tok: ["Runs","training","process","in","all","of","the","pipeline","nodes","starting","with","root","Args",":","input_data",":","data","used","for","operation","training","process_state_dict",":","dictionary","used","for","saving","required","pipeline","parameters","(","which","were","changed","inside","the","process",")","in","case","of","operations","fit","time","control","(","when","process","created",")","fitted_operations",":","list","used","for","saving","fitted","operations","of","pipeline","nodes","Returns",":","Optional","[","OutputData","]",":","values","predicted","on","the","provided","``","input_data","``","or","nothing","in","case","of","the","time","controlled","call"]
code: def _fit(
      self,
      input_data: Optional[InputData] = None,
      process_state_dict: dict = None,
      fitted_operations: list = None,
  ) -> Optional[OutputData]:
      """Runs training process in all of the pipeline nodes starting with root
  
      Args:
          input_data: data used for operation training
          process_state_dict: dictionary used for saving required pipeline parameters
              (which were changed inside the process) in case of operations fit time control (when process created)
          fitted_operations: list used for saving fitted operations of pipeline nodes
  
      Returns:
          Optional[OutputData]: values predicted on the provided ``input_data`` or nothing
          in case of the time controlled call
      """
  
      with Timer() as t:
          computation_time_update = (
              not self.root_node.fitted_operation
              or self.computation_time is None
          )
          train_predicted = self.root_node.fit(input_data=input_data)
          if computation_time_update:
              self.computation_time = round(t.minutes_from_start, 3)
  
      if process_state_dict is None:
          return train_predicted
      else:
          process_state_dict["train_predicted"] = train_predicted
          process_state_dict[
              "computation_time_in_seconds"
          ] = self.computation_time
          for node in self.nodes:
              fitted_operations.append(node.fitted_operation)
  
imports: from copy import deepcopy
  from datetime import timedelta
  from os import PathLike
  from typing import Optional, Tuple, Union, Sequence, List, Dict
  import func_timeout
  from golem.core.dag.graph import Graph
  from golem.core.dag.graph_delegate import GraphDelegate
  from golem.core.dag.graph_node import GraphNode
  from golem.core.dag.graph_utils import distance_to_primary_level, graph_structure
  from golem.core.dag.linked_graph import LinkedGraph
  from golem.core.log import default_log
  from golem.core.optimisers.timer import Timer
  from golem.core.paths import copy_doc
  from golem.utilities.serializable import Serializable
  from golem.visualisation.graph_viz import NodeColorType
  from fedot.core.caching.pipelines_cache import OperationsCache
  from fedot.core.caching.preprocessing_cache import PreprocessingCache
  from fedot.core.data.data import InputData, OutputData
  from fedot.core.data.multi_modal import MultiModalData
  from fedot.core.operations.data_operation import DataOperation
  from fedot.core.operations.model import Model
  from fedot.core.pipelines.node import PipelineNode
  from fedot.core.pipelines.template import PipelineTemplate
  from fedot.core.repository.tasks import TaskTypesEnum
  from fedot.core.visualisation.pipeline_specific_visuals import PipelineVisualizer
  from fedot.preprocessing.dummy_preprocessing import DummyPreprocessor
  from fedot.preprocessing.preprocessing import DataPreprocessor
label_desc: Use image node_id 4 for calling the Pipeline obj's underlying member method code with example usage: obj._fit(input_data, process_state_dict, fitted_operations) and returns: train_predicted