code: def sequence_numeric_column(
      key,
      shape=(1,),
      default_value=0.0,
      dtype=dtypes.float32,
      normalizer_fn=None,
  ):
      """Returns a feature column that represents sequences of numeric data.
  
      Example:
  
      ```python
      temperature = sequence_numeric_column('temperature')
      columns = [temperature]
  
      features = tf.io.parse_example(..., features=make_parse_example_spec(columns))
      sequence_feature_layer = SequenceFeatures(columns)
      sequence_input, sequence_length = sequence_feature_layer(features)
      sequence_length_mask = tf.sequence_mask(sequence_length)
  
      rnn_cell = tf.keras.layers.SimpleRNNCell(hidden_size)
      rnn_layer = tf.keras.layers.RNN(rnn_cell)
      outputs, state = rnn_layer(sequence_input, mask=sequence_length_mask)
      ```
  
      Args:
        key: A unique string identifying the input features.
        shape: The shape of the input data per sequence id. E.g. if `shape=(2,)`,
          each example must contain `2 * sequence_length` values.
        default_value: A single value compatible with `dtype` that is used for
          padding the sparse data into a dense `Tensor`.
        dtype: The type of values.
        normalizer_fn: If not `None`, a function that can be used to normalize the
          value of the tensor after `default_value` is applied for parsing.
          Normalizer function takes the input `Tensor` as its argument, and returns
          the output `Tensor`. (e.g. lambda x: (x - 3.0) / 4.2). Please note that
          even though the most common use case of this function is normalization, it
          can be used for any kind of Tensorflow transformations.
  
      Returns:
        A `SequenceNumericColumn`.
  
      Raises:
        TypeError: if any dimension in shape is not an int.
        ValueError: if any dimension in shape is not a positive integer.
        ValueError: if `dtype` is not convertible to `tf.float32`.
      """
      shape = fc._check_shape(shape=shape, key=key)
      if not (dtype.is_integer or dtype.is_floating):
          raise ValueError(
              "dtype must be convertible to float. "
              "dtype: {}, key: {}".format(dtype, key)
          )
      if normalizer_fn is not None and not callable(normalizer_fn):
          raise TypeError(
              "normalizer_fn must be a callable. Given: {}".format(
                  normalizer_fn
              )
          )
  
      return SequenceNumericColumn(
          key,
          shape=shape,
          default_value=default_value,
          dtype=dtype,
          normalizer_fn=normalizer_fn,
      )
  
imports: import collections
  from tensorflow.python.feature_column import feature_column_v2
  from tensorflow.python.feature_column import serialization
  from tensorflow.python.feature_column import utils
  from tensorflow.python.framework import dtypes
  from tensorflow.python.framework import ops
  from tensorflow.python.framework import tensor_shape
  from tensorflow.python.ops import array_ops
  from tensorflow.python.ops import check_ops
  from tensorflow.python.ops import parsing_ops
  from tensorflow.python.ops import sparse_ops
  from tensorflow.python.util import deprecation
  from tensorflow.python.util.tf_export import tf_export
  from tensorflow.tools.docs import doc_controls
label_desc: Use image node_id 6 for calling a global function with example usage: sequence_numeric_column(key, shape, default_value, dtype, normalizer_fn) and returns: SequenceNumericColumn