Python tensorflow.segment_mean() Examples

def testGradient(self):
    shape = [4, 4]
    indices = [0, 1, 2, 2]
    for tf_op in [tf.segment_sum,
                  tf.segment_mean,
                  tf.segment_min,
                  tf.segment_max]:
      with self.test_session():
        tf_x, np_x = self._input(shape, dtype=tf.float64)
        s = tf_op(data=tf_x, segment_ids=indices)
        jacob_t, jacob_n = tf.test.compute_gradient(
            tf_x,
            shape,
            s,
            [3, 4],
            x_init_value=np_x.astype(np.double),
            delta=1)
      self.assertAllClose(jacob_t, jacob_n, rtol=1e-3, atol=1e-3) 

def padded_segment_reduce(vecs, segment_inds, num_segments, reduction_mode):
    """
    Reduce the vecs with segment_inds and reduction_mode
    Input:
        vecs: A Tensor of shape (batch_size, vec_dim)
        segment_inds: A Tensor containing the segment index of each
        vec row, should agree with vecs in shape[0]
    Output:
        A tensor of shape (vec_dim)
    """
    if reduction_mode == 'max':
        print('USING MAX POOLING FOR REDUCTION!')
        vecs_reduced = tf.segment_max(vecs, segment_inds)
    elif reduction_mode == 'mean':
        print('USING AVG POOLING FOR REDUCTION!')
        vecs_reduced = tf.segment_mean(vecs, segment_inds)
    vecs_reduced.set_shape([num_segments, vecs.get_shape()[1]])
    return vecs_reduced 

def test_SegmentMean(self):
        t = tf.segment_mean(self.random(4, 2, 3), np.array([0, 1, 1, 2]))
        self.check(t) 

def testValues(self):
    dtypes = [tf.float32,
              tf.float64,
              tf.int64,
              tf.int32,
              tf.complex64,
              tf.complex128]

    # Each item is np_op1, np_op2, tf_op
    ops_list = [(np.add, None, tf.segment_sum),
                (self._mean_cum_op, self._mean_reduce_op,
                 tf.segment_mean),
                (np.ndarray.__mul__, None, tf.segment_prod),
                (np.minimum, None, tf.segment_min),
                (np.maximum, None, tf.segment_max)]

    # A subset of ops has been enabled for complex numbers
    complex_ops_list = [(np.add, None, tf.segment_sum),
                        (np.ndarray.__mul__, None, tf.segment_prod)]

    n = 10
    shape = [n, 2]
    indices = [i // 3 for i in range(n)]
    for dtype in dtypes:
      if dtype in (tf.complex64, tf.complex128):
        curr_ops_list = complex_ops_list
      else:
        curr_ops_list = ops_list

      with self.test_session(use_gpu=False):
        tf_x, np_x = self._input(shape, dtype=dtype)
        for np_op1, np_op2, tf_op in curr_ops_list:
          np_ans = self._segmentReduce(indices, np_x, np_op1, np_op2)
          s = tf_op(data=tf_x, segment_ids=indices)
          tf_ans = s.eval()
          self._assertAllClose(indices, np_ans, tf_ans)
          # NOTE(mrry): The static shape inference that computes
          # `tf_ans.shape` can only infer that sizes from dimension 1
          # onwards, because the size of dimension 0 is data-dependent
          # and may therefore vary dynamically.
          self.assertAllEqual(np_ans.shape[1:], tf_ans.shape[1:]) 

def __init__(self, mode='sum', name=None):
        if mode == 'sum':
            self._reduce = tf.segment_sum
        elif mode == 'mean':
            self._reduce = tf.segment_mean
        super(PoolSegments, self).__init__(name) 

def _segments_1d(values, mode, name=None):
  """Labels consecutive runs of the same value.

  Args:
    values: 1D tensor of any type.
    mode: The SegmentsMode. Returns the start of each segment (STARTS), or the
      rounded center of each segment (CENTERS).
    name: Optional name for the op.

  Returns:
    run_centers: int32 tensor; the centers of each run with the same consecutive
        values.
    run_lengths: int32 tensor; the lengths of each run.

  Raises:
    ValueError: if mode is not recognized.
  """
  with tf.name_scope(name, "segments", [values]):

    def do_segments(values):
      """Actually does segmentation.

      Args:
        values: 1D tensor of any type. Non-empty.

      Returns:
        run_centers: int32 tensor
        run_lengths: int32 tensor

      Raises:
        ValueError: if mode is not recognized.
      """
      length = tf.shape(values)[0]
      values = tf.convert_to_tensor(values)
      # The first run has id 0, so we don't increment the id.
      # Otherwise, the id is incremented when the value changes.
      run_start_bool = tf.concat(
          [[False], tf.not_equal(values[1:], values[:-1])], axis=0)
      # Cumulative sum the run starts to get the run ids.
      segment_ids = tf.cumsum(tf.cast(run_start_bool, tf.int32))
      if mode is SegmentsMode.STARTS:
        run_centers = tf.segment_min(tf.range(length), segment_ids)
      elif mode is SegmentsMode.CENTERS:
        run_centers = tf.segment_mean(
            tf.cast(tf.range(length), tf.float32), segment_ids)
        run_centers = tf.cast(tf.floor(run_centers), tf.int32)
      else:
        raise ValueError("Unexpected mode: %s" % mode)
      run_lengths = tf.segment_sum(tf.ones([length], tf.int32), segment_ids)
      return run_centers, run_lengths

    def empty_segments():
      return (tf.zeros([0], tf.int32), tf.zeros([0], tf.int32))

    return tf.cond(
        tf.greater(tf.shape(values)[0], 0), lambda: do_segments(values),
        empty_segments)