parameters: (tensors,
                       accept_prob_fn,
                       batch_size,
                       queue_threads=1,
                       enqueue_many=False,
                       prebatch_capacity=16,
                       prebatch_threads=1,
                       runtime_checks=False,
                       name=None)
docstring: Stochastically creates batches by rejection sampling.
  
    Each list of non-batched tensors is evaluated by `accept_prob_fn`, to produce
    a scalar tensor between 0 and 1. This tensor corresponds to the probability of
    being accepted. When `batch_size` tensor groups have been accepted, the batch
    queue will return a mini-batch.
  
    Args:
      tensors: List of tensors for data. All tensors are either one item or a
          batch, according to enqueue_many.
      accept_prob_fn: A python lambda that takes a non-batch tensor from each
          item in `tensors`, and produces a scalar tensor.
      batch_size: Size of batch to be returned.
      queue_threads: The number of threads for the queue that will hold the final
        batch.
      enqueue_many: Bool. If true, interpret input tensors as having a batch
          dimension.
      prebatch_capacity: Capacity for the large queue that is used to convert
        batched tensors to single examples.
      prebatch_threads: Number of threads for the large queue that is used to
        convert batched tensors to single examples.
      runtime_checks: Bool. If true, insert runtime checks on the output of
          `accept_prob_fn`. Using `True` might have a performance impact.
      name: Optional prefix for ops created by this function.
    Raises:
      ValueError: enqueue_many is True and labels doesn't have a batch
          dimension, or if enqueue_many is False and labels isn't a scalar.
      ValueError: enqueue_many is True, and batch dimension on data and labels
          don't match.
      ValueError: if a zero initial probability class has a nonzero target
          probability.
    Returns:
      A list of tensors of the same length as `tensors`, with batch dimension
      `batch_size`.
  
    Example:
      # Get tensor for a single data and label example.
      data, label = data_provider.Get(['data', 'label'])
  
      # Get stratified batch according to data tensor.
      accept_prob_fn = lambda x: (tf.tanh(x[0]) + 1) / 2
      data_batch = tf.contrib.training.rejection_sample(
          [data, label], accept_prob_fn, 16)
  
      # Run batch through network.
      ...
docstring_summary: Stochastically creates batches by rejection sampling.
docstring_tokens: Stochastically creates batches by rejection sampling .
function: def rejection_sample(tensors,
                       accept_prob_fn,
                       batch_size,
                       queue_threads=1,
                       enqueue_many=False,
                       prebatch_capacity=16,
                       prebatch_threads=1,
                       runtime_checks=False,
                       name=None):
    """Stochastically creates batches by rejection sampling.
  
    Each list of non-batched tensors is evaluated by `accept_prob_fn`, to produce
    a scalar tensor between 0 and 1. This tensor corresponds to the probability of
    being accepted. When `batch_size` tensor groups have been accepted, the batch
    queue will return a mini-batch.
  
    Args:
      tensors: List of tensors for data. All tensors are either one item or a
          batch, according to enqueue_many.
      accept_prob_fn: A python lambda that takes a non-batch tensor from each
          item in `tensors`, and produces a scalar tensor.
      batch_size: Size of batch to be returned.
      queue_threads: The number of threads for the queue that will hold the final
        batch.
      enqueue_many: Bool. If true, interpret input tensors as having a batch
          dimension.
      prebatch_capacity: Capacity for the large queue that is used to convert
        batched tensors to single examples.
      prebatch_threads: Number of threads for the large queue that is used to
        convert batched tensors to single examples.
      runtime_checks: Bool. If true, insert runtime checks on the output of
          `accept_prob_fn`. Using `True` might have a performance impact.
      name: Optional prefix for ops created by this function.
    Raises:
      ValueError: enqueue_many is True and labels doesn't have a batch
          dimension, or if enqueue_many is False and labels isn't a scalar.
      ValueError: enqueue_many is True, and batch dimension on data and labels
          don't match.
      ValueError: if a zero initial probability class has a nonzero target
          probability.
    Returns:
      A list of tensors of the same length as `tensors`, with batch dimension
      `batch_size`.
  
    Example:
      # Get tensor for a single data and label example.
      data, label = data_provider.Get(['data', 'label'])
  
      # Get stratified batch according to data tensor.
      accept_prob_fn = lambda x: (tf.tanh(x[0]) + 1) / 2
      data_batch = tf.contrib.training.rejection_sample(
          [data, label], accept_prob_fn, 16)
  
      # Run batch through network.
      ...
    """
    with variable_scope.variable_scope(name, 'rejection_sample', tensors):
      tensor_list = ops.convert_n_to_tensor_or_indexed_slices(tensors)
      # Reduce the case of a batched example to that of a batch of a single
      # example by taking a batch of size one.
      if enqueue_many:
        # Validate that batch dimension of the input is consistent.
        tensor_list = _verify_data_inputs(tensor_list)
  
        # Make a single queue to hold input examples. Reshape output so examples
        # don't have singleton batch dimension.
        batched = input_ops.batch(
            tensor_list,
            batch_size=1,
            num_threads=prebatch_threads,
            capacity=prebatch_capacity,
            enqueue_many=True)
        tensor_list = [array_ops.squeeze(x, [0]) for x in batched]
  
      # Set up a queue containing batches that have the distribution.
      cur_prob = accept_prob_fn(tensor_list)
      if runtime_checks:
        cur_prob = array_ops.identity(
            control_flow_ops.with_dependencies([
                check_ops.assert_less_equal(0.0, cur_prob),
                check_ops.assert_less_equal(cur_prob, 1.0)
            ], cur_prob),
            name='prob_with_checks')
      minibatch = input_ops.maybe_batch(
          tensor_list,
          keep_input=random_ops.random_uniform([]) < cur_prob,
          batch_size=batch_size,
          num_threads=queue_threads)
  
      # Queues return a single tensor if the list of enqueued tensors is one. Since
      # we want the type to always be the same, always return a list.
      if isinstance(minibatch, ops.Tensor):
        minibatch = [minibatch]
  
      return minibatch
function_tokens: def rejection_sample ( tensors , accept_prob_fn , batch_size , queue_threads = 1 , enqueue_many = False , prebatch_capacity = 16 , prebatch_threads = 1 , runtime_checks = False , name = None ) : with variable_scope . variable_scope ( name , 'rejection_sample' , tensors ) : tensor_list = ops . convert_n_to_tensor_or_indexed_slices ( tensors ) # Reduce the case of a batched example to that of a batch of a single # example by taking a batch of size one. if enqueue_many : # Validate that batch dimension of the input is consistent. tensor_list = _verify_data_inputs ( tensor_list ) # Make a single queue to hold input examples. Reshape output so examples # don't have singleton batch dimension. batched = input_ops . batch ( tensor_list , batch_size = 1 , num_threads = prebatch_threads , capacity = prebatch_capacity , enqueue_many = True ) tensor_list = [ array_ops . squeeze ( x , [ 0 ] ) for x in batched ] # Set up a queue containing batches that have the distribution. cur_prob = accept_prob_fn ( tensor_list ) if runtime_checks : cur_prob = array_ops . identity ( control_flow_ops . with_dependencies ( [ check_ops . assert_less_equal ( 0.0 , cur_prob ) , check_ops . assert_less_equal ( cur_prob , 1.0 ) ] , cur_prob ) , name = 'prob_with_checks' ) minibatch = input_ops . maybe_batch ( tensor_list , keep_input = random_ops . random_uniform ( [ ] ) < cur_prob , batch_size = batch_size , num_threads = queue_threads ) # Queues return a single tensor if the list of enqueued tensors is one. Since # we want the type to always be the same, always return a list. if isinstance ( minibatch , ops . Tensor ) : minibatch = [ minibatch ] return minibatch