class_docstr: Notes
  -----
  An implementation of auto feature engineering method Deepgl [#]_ ,which iteratively generates features by aggregating neighbour features
  and select a fixed number of  features to automatically add important graph-aware features.
  References
  ----------
  .. [#] Rossi, R. A., Zhou, R., & Ahmed, N. K. (2020).
      Deep Inductive Graph Representation Learning.
      IEEE Transactions on Knowledge and Data Engineering, 32(3), 438–452.
      https://doi.org/10.1109/TKDE.2018.2878247
  Parameters
  ----------
  fixlen : int
      fixed number of features for every epoch. The final number of features added will be
      ``fixlen`` \times ``max_epoch``, 200 \times 5 in default.
  max_epoch : int
      number of epochs in total process.
  timebudget : int
      timebudget(seconds) for the feature engineering process, None for no time budget . Note that
      this time budget is a soft budget ,which is obtained by rough time estimation through previous iterations and
      may finally exceed the actual timebudget
  y_sel_func : Callable
      feature selector function object for selection at each iteration ,lightgbm in default. Note that in original paper,
      connected components of feature graph is used , and you may implement it by yourself if you want.
  verbosity : int
      hide any infomation except error and fatal if ``verbosity`` < 1
code: def _fit(self, data):
      self._init(data)
      x = self._x.copy()
      gx = x.copy()
      verbs = []
      data = self._data
      max_epoch = self._max_epoch
      timebudget = self._timebudget
      y_sel_func = self._y_sel_func
      soft_timer = Timer(timebudget)
      self._sel = []
      for epoch in tqdm(range(max_epoch), disable=self._verbosity <= 0):
          soft_timer.start()
          verb = [epoch, gx.shape[1]]
          gx = self._gen(gx)
          gx = scale(gx)
          verb.append(gx.shape[1])
          data.x = gx
          #             data = feat_diffuse(data)
          y_sel_func._fit(data)
          self._sel.append(y_sel_func._sel)
          data = y_sel_func._transform(data)
          gx = data.x
          verb.append(gx.shape[1])
          x = np.concatenate([x, gx], axis=1)
          verbs.append(verb)
          soft_timer.end()
          if soft_timer.is_timeout():
              break
      if self._verbosity >= 1:
          LOGGER.info(
              tabulate(
                  verbs,
                  headers="epoch origin after-gen after-sel".split(),
              )
          )
      data.x = x
      return data
  
imports: from sklearn import preprocessing
  import numpy
  from sklearn.metrics.pairwise import cosine_similarity
  import copy
  from tqdm import tqdm
  from tabulate import tabulate
  import time
  from .base import BaseFeature, BaseFeatureEngineer
  from .selectors import SeGBDT
  from .None import register_feature
  from ...utils import get_logger
  import torch
label_desc: Use image node_id 4 for calling the AutoFeatureEngineer obj's underlying member method code with example usage: obj._fit(data) and returns: data