class_docstr: Class for applying imputation on tabular data
  
  Args:
      params: OperationParameters with the arguments
class_docstr_tok: ["Class","for","applying","imputation","on","tabular","data","Args",":","params",":","OperationParameters","with","the","arguments"]
docstr: Method for transformation tabular data using ``SimpleImputer``
  
  Args:
      input_data: data with features
  
  Returns:
      data with transformed features attribute
docstr_tok: ["Method","for","transformation","tabular","data","using","``","SimpleImputer","``","Args",":","input_data",":","data","with","features","Returns",":","data","with","transformed","features","attribute"]
code: def transform(self, input_data: InputData) -> OutputData:
      """Method for transformation tabular data using ``SimpleImputer``
  
      Args:
          input_data: data with features
  
      Returns:
          data with transformed features attribute
      """
  
      replace_inf_with_nans(input_data)
  
      if data_type_is_table(
          input_data
      ) and data_has_categorical_features(input_data):
          feature_type_ids = input_data.supplementary_data.col_type_ids[
              "features"
          ]
          (
              self.categorical_ids,
              self.non_categorical_ids,
          ) = find_categorical_columns(
              input_data.features, feature_type_ids
          )
          numerical, categorical = divide_data_categorical_numerical(
              input_data, self.categorical_ids, self.non_categorical_ids
          )
  
          if categorical is not None:
              categorical_features = convert_into_column(
                  categorical.features
              )
              categorical_features = self.imputer_cat.transform(
                  categorical_features
              )
  
          if numerical is not None:
              numerical_features = convert_into_column(
                  numerical.features
              )
  
              # Features with only two unique values must be filled in a specific way
              self._find_binary_features(numerical_features)
              numerical_features = self.imputer_num.transform(
                  numerical_features
              )
              numerical_features = self._correct_binary_ids_features(
                  numerical_features
              )
  
          if categorical is not None and numerical is not None:
              # Stack both categorical and numerical features
              transformed_features = self._categorical_numerical_union(
                  categorical_features, numerical_features
              )
          elif categorical is not None and numerical is None:
              # Dataset contain only categorical features
              transformed_features = categorical_features
          elif categorical is None and numerical is not None:
              # Dataset contain only numerical features
              transformed_features = numerical_features
  
      else:
          input_data.features = convert_into_column(input_data.features)
          transformed_features = self.imputer_num.transform(
              input_data.features
          )
  
      output_data = self._convert_to_output(
          input_data,
          transformed_features,
          data_type=input_data.data_type,
      )
      return output_data
  
imports: import random
  from typing import Optional
  import numpy
  import pandas
  from sklearn.decomposition import FastICA, KernelPCA, PCA
  from sklearn.impute import SimpleImputer
  from sklearn.preprocessing import MinMaxScaler, PolynomialFeatures, StandardScaler
  from fedot.core.data.data import InputData, OutputData, data_type_is_table
  from fedot.core.data.data_preprocessing import convert_into_column, data_has_categorical_features, divide_data_categorical_numerical, find_categorical_columns, replace_inf_with_nans
  from fedot.core.operations.evaluation.operation_implementations.implementation_interfaces import DataOperationImplementation, EncodedInvariantImplementation
  from fedot.core.operations.operation_parameters import OperationParameters
  from fedot.preprocessing.data_types import TYPE_TO_ID
label_desc: Use image node_id 3 for calling the ImputationImplementation obj's underlying member method code with example usage: obj.transform(input_data) and returns: output_data