class_docstr: Base class for decomposing target. The idea is to find the difference
  between the actual and predicted values - the residuals. Then the residuals
  replace the original target.
class_docstr_tok: ["Base","class","for","decomposing","target",".","The","idea","is","to","find","the","difference","between","the","actual","and","predicted","values","-","the","residuals",".","Then","the","residuals","replace","the","original","target","."]
docstr: Method for dividing InputData into parts:
  first came from Model parent and second came from Data parent
  
  :param input_data: InputData object
  :return prev_prediction: data obtained from "Model parent" at the previous node
  :return prev_features: data obtained from "Data parent" at the previous node
docstr_tok: ["Method","for","dividing","InputData","into","parts",":","first","came","from","Model","parent","and","second","came","from","Data","parent",":","param","input_data",":","InputData","object",":","return","prev_prediction",":","data","obtained","from","``","Model","parent","''","at","the","previous","node",":","return","prev_features",":","data","obtained","from","``","Data","parent","''","at","the","previous","node"]
code: def divide_inputs(input_data: InputData) -> (np.array, np.array):
      """Method for dividing InputData into parts:
      first came from Model parent and second came from Data parent
  
      :param input_data: InputData object
      :return prev_prediction: data obtained from "Model parent" at the previous node
      :return prev_features: data obtained from "Data parent" at the previous node
      """
  
      features = np.array(input_data.features)
      # Array with masks
      features_mask = np.array(
          input_data.supplementary_data.compound_mask
      )
      unique_features_masks = np.unique(features_mask)
  
      if len(unique_features_masks) < 2:
          prefix = (
              "Decompose operation must have at least two parents nodes"
          )
          raise ValueError(
              f"{prefix}, but got {len(unique_features_masks)}"
          )
  
      # Get amount of nodes data already visited
      flow_lengths = input_data.supplementary_data.flow_mask
  
      # Find minimum and maximum of visited nodes and first indices of them
      min_flow_length_i = np.argmin(flow_lengths)
      max_flow_length_i = np.argmax(flow_lengths)
  
      # For case when data from "Model parent" and "Data parent" go through equal number of nodes
      if min_flow_length_i == max_flow_length_i:
          # Find data models
          (
              model_parent,
              data_parent,
          ) = input_data.supplementary_data.define_parents(
              unique_features_masks, task=input_data.task.task_type
          )
      else:
          model_parent = features_mask[max_flow_length_i]
          data_parent = features_mask[min_flow_length_i]
  
      # Get prediction from "Model parent"
      prev_prediction_id = np.ravel(
          np.argwhere(features_mask == model_parent)
      )
      prev_prediction = features[:, prev_prediction_id]
  
      # Get prediction from "Data parent" - it must be the last parent in parent list
      prev_features_id = np.ravel(
          np.argwhere(features_mask == data_parent)
      )
      prev_features = features[:, prev_features_id]
  
      return prev_prediction, prev_features
  
imports: from typing import Optional
  import numpy
  from sklearn.preprocessing import OneHotEncoder
  from fedot.core.data.data import InputData, OutputData
  from fedot.core.operations.evaluation.operation_implementations.implementation_interfaces import DataOperationImplementation
  from fedot.core.operations.operation_parameters import OperationParameters
  from fedot.core.repository.tasks import Task, TaskTypesEnum
label_desc: Use image node_id 3 for calling the DecomposerImplementation obj's underlying member method code with example usage: obj.divide_inputs(input_data) and returns: prev_prediction,  prev_features