code: def to_builders(
      self,
      initial_node: Optional[PipelineNode] = None,
      use_input_preprocessing: bool = True,
  ) -> List[PipelineBuilder]:
      # For each data source build its own list of alternatives of initial pipelines.
      subpipelines: List[List[Pipeline]] = []
      initial_node_operation = (
          initial_node.operation.operation_type
          if initial_node is not None
          else None
      )
      for data_source_name, subbuilder in self._subbuilders:
          first_node = (
              PipelineBuilder(
                  use_input_preprocessing=use_input_preprocessing
              )
              .add_node(data_source_name)
              .add_node(initial_node_operation)
              .to_nodes()[0]
          )
          data_pipeline_alternatives = subbuilder.build(
              first_node,
              use_input_preprocessing=use_input_preprocessing,
          )
          subpipelines.append(data_pipeline_alternatives)
  
      # Then zip these alternatives together and add final node to get ensembles.
      ensemble_builders: List[PipelineBuilder] = []
      for pre_ensemble in zip(*subpipelines):
          ensemble_operation = (
              self.assumptions_generator.ensemble_operation()
          )
          ensemble_nodes = map(
              lambda pipeline: pipeline.root_node, pre_ensemble
          )
          ensemble_builder = PipelineBuilder(
              *ensemble_nodes,
              use_input_preprocessing=use_input_preprocessing,
          ).join_branches(ensemble_operation)
          ensemble_builders.append(ensemble_builder)
      return ensemble_builders
  
imports: from abc import abstractmethod
  from typing import List, Union, Optional, Set, Tuple
  from golem.core.log import default_log
  from fedot.api.api_utils.assumptions.operations_filter import OperationsFilter, WhitelistOperationsFilter
  from fedot.api.api_utils.assumptions.preprocessing_builder import PreprocessingBuilder
  from fedot.api.api_utils.assumptions.task_assumptions import TaskAssumptions
  from fedot.core.data.data import InputData
  from fedot.core.data.multi_modal import MultiModalData
  from fedot.core.pipelines.node import PipelineNode
  from fedot.core.pipelines.pipeline import Pipeline
  from fedot.core.pipelines.pipeline_builder import PipelineBuilder
  from fedot.core.repository.dataset_types import DataTypesEnum
  from fedot.core.repository.operation_types_repository import OperationTypesRepository
  from fedot.utilities.custom_errors import AbstractMethodNotImplementError
label_desc: Use image node_id 3 for calling the MultiModalAssumptionsBuilder obj's underlying member method code with example usage: obj.to_builders(initial_node, use_input_preprocessing) and returns: ensemble_builders