code: def slice_input_producer(
      tensor_list,
      num_epochs=None,
      shuffle=True,
      seed=None,
      capacity=32,
      shared_name=None,
      name=None,
  ):
      """Produces a slice of each `Tensor` in `tensor_list`.
  
      Implemented using a Queue -- a `QueueRunner` for the Queue
      is added to the current `Graph`'s `QUEUE_RUNNER` collection.
  
      Args:
        tensor_list: A list of `Tensor` objects. Every `Tensor` in
          `tensor_list` must have the same size in the first dimension.
        num_epochs: An integer (optional). If specified, `slice_input_producer`
          produces each slice `num_epochs` times before generating
          an `OutOfRange` error. If not specified, `slice_input_producer` can cycle
          through the slices an unlimited number of times.
        shuffle: Boolean. If true, the integers are randomly shuffled within each
          epoch.
        seed: An integer (optional). Seed used if shuffle == True.
        capacity: An integer. Sets the queue capacity.
        shared_name: (optional). If set, this queue will be shared under the given
          name across multiple sessions.
        name: A name for the operations (optional).
  
      Returns:
        A list of tensors, one for each element of `tensor_list`.  If the tensor
        in `tensor_list` has shape `[N, a, b, .., z]`, then the corresponding output
        tensor will have shape `[a, b, ..., z]`.
  
      Raises:
        ValueError: if `slice_input_producer` produces nothing from `tensor_list`.
  
      @compatibility(eager)
      Input pipelines based on Queues are not supported when eager execution is
      enabled. Please use the `tf.data` API to ingest data under eager execution.
      @end_compatibility
      """
      with ops.name_scope(name, "input_producer", tensor_list):
          tensor_list = (
              indexed_slices.convert_n_to_tensor_or_indexed_slices(
                  tensor_list
              )
          )
          if not tensor_list:
              raise ValueError(
                  "Expected at least one tensor in slice_input_producer()."
              )
          range_size = array_ops.shape(tensor_list[0])[0]
          # TODO(josh11b): Add an assertion that the first dimension of
          # everything in TensorList matches. Maybe just check the inferred shapes?
          queue = range_input_producer(
              range_size,
              num_epochs=num_epochs,
              shuffle=shuffle,
              seed=seed,
              capacity=capacity,
              shared_name=shared_name,
          )
          index = queue.dequeue()
          output = [array_ops.gather(t, index) for t in tensor_list]
          return output
  
imports: from tensorflow.python.eager import context
  from tensorflow.python.framework import constant_op
  from tensorflow.python.framework import dtypes
  from tensorflow.python.framework import indexed_slices
  from tensorflow.python.framework import ops
  from tensorflow.python.framework import sparse_tensor
  from tensorflow.python.framework import tensor
  from tensorflow.python.framework import tensor_shape
  from tensorflow.python.layers import utils
  from tensorflow.python.ops import array_ops
  from tensorflow.python.ops import control_flow_assert
  from tensorflow.python.ops import control_flow_ops
  from tensorflow.python.ops import data_flow_ops
  from tensorflow.python.ops import io_ops
  from tensorflow.python.ops import math_ops
  from tensorflow.python.ops import random_ops
  from tensorflow.python.ops import sparse_ops
  from tensorflow.python.ops import variable_v1
  from tensorflow.python.summary import summary
  from tensorflow.python.training import queue_runner
  from tensorflow.python.util import deprecation
  from tensorflow.python.util.compat import collections_abc
  from tensorflow.python.util.tf_export import tf_export
label_desc: Use image node_id 6 for calling a global function with example usage: slice_input_producer(tensor_list, num_epochs, shuffle, seed, capacity, shared_name, name) and returns: output