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 the pipeline nodes starting with root
  
  Args:
      input_data: data used for operations training
      time_constraint: time constraint for operations fitting (in seconds)
      n_jobs: number of threads for nodes fitting
  
  Returns:
      OutputData: values predicted on the provided ``input_data``
docstr_tok: ["Runs","training","process","in","all","the","pipeline","nodes","starting","with","root","Args",":","input_data",":","data","used","for","operations","training","time_constraint",":","time","constraint","for","operations","fitting","(","in","seconds",")","n_jobs",":","number","of","threads","for","nodes","fitting","Returns",":","OutputData",":","values","predicted","on","the","provided","``","input_data","``"]
code: def fit(
      self,
      input_data: Union[InputData, MultiModalData],
      time_constraint: Optional[timedelta] = None,
      n_jobs: int = 1,
  ) -> OutputData:
      """
      Runs training process in all the pipeline nodes starting with root
  
      Args:
          input_data: data used for operations training
          time_constraint: time constraint for operations fitting (in seconds)
          n_jobs: number of threads for nodes fitting
  
      Returns:
          OutputData: values predicted on the provided ``input_data``
      """
      self.replace_n_jobs_in_nodes(n_jobs)
  
      if (
          isinstance(input_data, InputData)
          and input_data.supplementary_data.is_auto_preprocessed
      ):
          copied_input_data = deepcopy(input_data)
      else:
          copied_input_data = self._preprocess(input_data)
  
      copied_input_data = self._assign_data_to_nodes(copied_input_data)
      if time_constraint is None:
          train_predicted = self._fit(input_data=copied_input_data)
      else:
          train_predicted = self._fit_with_time_limit(
              input_data=copied_input_data, time=time_constraint
          )
      return train_predicted
  
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 7 for calling the Pipeline obj's underlying member method code with example usage: obj.fit(input_data, time_constraint, n_jobs) and returns: train_predicted