code: def fit(self, ctx: Context, train_data, validate_data=None) -> None:
      if self.select_col is None:
          self.select_col = train_data.schema.columns.to_list()
      select_data = train_data[self.select_col]
      header = select_data.schema.columns.to_list()
      for i, filter_type in enumerate(self.method):
          if filter_type == "manual":
              selection_obj = ManualSelection(
                  method=filter_type,
                  header=header,
                  param=self.manual_param,
                  keep_one=self.keep_one,
              )
          elif filter_type == "iv":
              model = self.isometric_model_dict.get("binning", None)
              if model is None:
                  raise ValueError(
                      f"Cannot find binning model in input, please check"
                  )
              selection_obj = StandardSelection(
                  method=filter_type,
                  header=header,
                  param=self.iv_param,
                  model=model,
                  keep_one=self.keep_one,
              )
          elif filter_type == "statistics":
              model = self.isometric_model_dict.get("statistics", None)
              if model is None:
                  raise ValueError(
                      f"Cannot find statistics model in input, please check"
                  )
              selection_obj = StandardSelection(
                  method=filter_type,
                  header=header,
                  param=self.statistic_param,
                  model=model,
                  keep_one=self.keep_one,
              )
  
          else:
              raise ValueError(
                  f"{type} selection method not supported, please check"
              )
          self._selection_obj.append(selection_obj)
          self._inner_method.append(filter_type)
  
      prev_selection_obj = None
      for method, selection_obj in zip(
          self._inner_method, self._selection_obj
      ):
          if prev_selection_obj:
              selection_obj.set_prev_selected_mask(
                  copy.deepcopy(prev_selection_obj.selected_mask)
              )
          selection_obj.fit(ctx, train_data, validate_data)
          if method == "iv":
              if self.iv_param.get("select_federated"):
                  HeteroSelectionModuleHost.sync_select_federated(
                      ctx, selection_obj, train_data
                  )
          prev_selection_obj = selection_obj
  
imports: import copy
  import logging
  import math
  import random
  import numpy
  import pandas
  from fate.arch import Context
  from ..abc.module import HeteroModule, Module
label_desc: Use image node_id 2 for calling the HeteroSelectionModuleHost obj's underlying member method code with example usage: obj.fit(ctx, train_data, validate_data) without return types