docstr: Sets up the content transforms.
code: def _setup_from_data(self, data):
      """
      Sets up the content transforms.
      """
  
      fitted_state = {}
  
      _raise_error_if_not_of_type(data, [_SFrame])
  
      feature_columns = _internal_utils.get_column_names(
          data, self._exclude, self._features
      )
  
      if not feature_columns:
          raise RuntimeError(
              "No valid feature columns specified in transformation."
          )
  
      fitted_state["features"] = feature_columns
  
      ################################################################################
      # Helper functions
  
      def get_valid_interpretations():
          return list(
              n.split("__")[0]
              for n in dir(_interpretations)
              if not n.startswith("_")
          )
  
      ################################################################################
      # Check input data.
  
      if not isinstance(data, _SFrame):
          raise TypeError("`data` parameter must be an SFrame.")
  
      all_col_names = set(feature_columns)
  
      column_interpretations = self._get(
          "column_interpretations"
      ).copy()
  
      # Make sure all the interpretations are valid.
      for k, v in column_interpretations.items():
          if k not in all_col_names:
              raise ValueError(
                  "Column '%s' in column_interpretations, but not found in `data`."
                  % k
              )
  
      # Get the automatic column interpretations.
      for col_name in feature_columns:
          if col_name not in column_interpretations:
              n = column_interpretations[
                  col_name
              ] = infer_column_interpretation(data[col_name])
  
              if n.startswith("unknown"):
                  raise ValueError(
                      "Interpretation inference failed on column '%s'; %s"
                      % (col_name, n[len("unknown") :].strip())
                  )
  
      # Now, build up the feature transforms.
      transforms = {}
      input_types = {}
  
      output_column_prefix = self._get("output_column_prefix")
  
      assert (
          output_column_prefix is None
          or type(output_column_prefix) is str
      )
  
      tr_chain = []
      for col_name in feature_columns:
          in_type = input_types[col_name] = data[col_name].dtype
  
          intr_func = _get_interpretation_function(
              column_interpretations[col_name], in_type
          )
          tr_list = intr_func(col_name, output_column_prefix)
          transforms[col_name] = tr_list
          tr_chain += tr_list
  
      fitted_state["transform_chain"] = _TransformerChain(tr_chain)
      fitted_state["transforms"] = transforms
      fitted_state["input_types"] = input_types
  
      fitted_state["column_interpretations"] = column_interpretations
  
      self.__proxy__.update(fitted_state)
  
imports: from __future__ import print_function
  from __future__ import division
  from __future__ import absolute_import
  from .None import TransformerBase
  from .None import TransformerChain
  from .None import TransformToFlatDictionary
  from turicreate.toolkits._model import PythonProxy
  from turicreate.toolkits._model import ExposeAttributesFromProxy
  from turicreate.toolkits._internal_utils import _toolkit_repr_print
  from turicreate.toolkits._internal_utils import _precomputed_field
  from turicreate.toolkits._internal_utils import _raise_error_if_not_sframe
  from turicreate.util import _raise_error_if_not_of_type
  from turicreate.toolkits._internal_utils import _check_categorical_option_type
  from .None import _internal_utils
  from array import array
  import textwrap
  from turicreate import SFrame
  import turicreate
label_desc: Use image node_id 4 for calling the AutoVectorizer obj's underlying member method code with example usage: obj._setup_from_data(data) and returns: list