code: def fit(self, X, y=None):
      print("Fitting DataFrameVectorizer")
  
      feature_names = []
      vocab = {}
  
      # Rearrange X so that all the categorical columns are first
      numerical_columns = []
      categorical_columns = []
      for col in X.columns:
          col_desc = self.column_descriptions.get(col, False)
          if col_desc in [
              False,
              "continuous",
              "int",
              "float",
              "numerical",
          ]:
              numerical_columns.append(col)
          elif col_desc in self.vals_to_drop:
              continue
          elif col_desc == "categorical":
              categorical_columns.append(col)
          else:
              print("We are unsure what to do with this column:")
              print(col)
              print(col_desc)
  
      self.num_numerical_cols = len(numerical_columns)
      self.numerical_columns = numerical_columns
      self.categorical_columns = categorical_columns
  
      new_cols = numerical_columns + categorical_columns
      X = X[new_cols]
  
      for col_name in X.columns:
          if (
              self.column_descriptions.get(col_name, False)
              == "categorical"
              and self.keep_cat_features == True
          ):
              # All of these values will go in the same column, but they must be turned into ints first
              self.label_encoders[col_name] = CustomLabelEncoder()
              # Then, we will use the same flow below to make sure they appear in the vocab correctly
              self.label_encoders[col_name].fit(X[col_name])
  
          # We can't do elif here- it has to be inclusive of the logic above
          if (
              self.column_descriptions.get(col_name, False)
              == "categorical"
              and self.keep_cat_features == False
          ):
              # If this is a categorical column, iterate through each row to get all the possible values that we are one-hot-encoding.
              for val in set(X[col_name]):
                  if not isinstance(val, str):
                      if isinstance(val, numbers.Number) or val is None:
                          val = str(val)
                      else:
                          val = val.encode("utf-8").decode("utf-8")
  
                  feature_name = col_name + self.separator + val
  
                  if feature_name not in vocab:
                      feature_names.append(feature_name)
                      vocab[feature_name] = len(vocab)
  
          # If this is a categorical column, do not include the column name itself, just include the feature_names as calculated above
          elif col_name not in vocab:
              feature_names.append(col_name)
              vocab[col_name] = len(vocab)
  
      self.feature_names_ = feature_names
      self.vocabulary_ = vocab
      return self
  
imports: from array import array
  import numbers
  from operator import itemgetter
  import numpy
  import pandas
  import scipy.sparse
  from sklearn.base import BaseEstimator, TransformerMixin
  from sklearn.externals import six
  from auto_ml.utils import CustomLabelEncoder
label_desc: Use image node_id 3 for calling the DataFrameVectorizer obj's underlying member method code with example usage: obj.fit(X, y) and returns: self