experiments/STT-tensorflow
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Remove remaining uses of tf.reverse() and remove tf.reverse()

Browse Source 
from API. On a subsequent commit tf.reverse() will be reintroduced but
taking a list of integer axes to reverse.
Change: 141325033
This commit is contained in:
Andrew Selle 2016-12-07 10:26:42 -08:00 committed by TensorFlower Gardener
parent 8d191fd0c4
commit 878f5fcb81
10 changed files with 45 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
tensorflow/contrib/distributions/python/ops/dirichlet_multinomial.py
View File

@ -202,7 +202,7 @@ class DirichletMultinomial(distribution.Distribution):
return self.alpha_sum.get_shape()
def _event_shape(self):
return array_ops.reverse(array_ops.shape(self.alpha), [True])[0]
return array_ops.reverse_v2(array_ops.shape(self.alpha), [0])[0]
def _get_event_shape(self):
# Event shape depends only on alpha, not "n".

4
tensorflow/contrib/metrics/python/ops/histogram_ops.py
View File

@ -203,8 +203,8 @@ def _auc_convert_hist_to_auc(hist_true_acc, hist_false_acc, nbins):
math_ops.reduce_sum(hist_false_acc))
# These become delta x, delta y from the paper.
delta_y_t = array_ops.reverse(normed_hist_true, [True], name='delta_y_t')
delta_x_t = array_ops.reverse(normed_hist_false, [True], name='delta_x_t')
delta_y_t = array_ops.reverse_v2(normed_hist_true, [0], name='delta_y_t')
delta_x_t = array_ops.reverse_v2(normed_hist_false, [0], name='delta_x_t')
# strict_1d_cumsum requires float32 args.
delta_y_t = math_ops.cast(delta_y_t, dtypes.float32)

2
tensorflow/contrib/rnn/python/ops/fused_rnn_cell.py
View File

@ -161,7 +161,7 @@ class TimeReversedFusedRNN(FusedRNNCell):
return list(reversed(t))
else:
if lengths is None:
return array_ops.reverse(t, [True, False, False])
return array_ops.reverse_v2(t, [0])
else:
return array_ops.reverse_sequence(t, lengths, 0, 1)

42
tensorflow/python/kernel_tests/array_ops_test.py
View File

@ -201,48 +201,6 @@ class OperatorShapeTest(test_util.TensorFlowTestCase):
self.assertEqual(matrix_squeezed.get_shape(), (3))
class ReverseTest(test_util.TensorFlowTestCase):
def testReverse0DimAuto(self):
x_np = 4
for use_gpu in [False, True]:
with self.test_session(use_gpu=use_gpu):
x_tf = array_ops.reverse(x_np, []).eval()
self.assertAllEqual(x_tf, x_np)
def _reverse1DimAuto(self, np_dtype):
x_np = np.array([1, 2, 3, 4, 5], dtype=np_dtype)
for use_gpu in [False, True]:
with self.test_session(use_gpu=use_gpu):
x_tf = array_ops.reverse(x_np, [True]).eval()
self.assertAllEqual(x_tf, np.asarray(x_np)[::-1])
def testReverse1DimAuto(self):
for dtype in [np.uint8, np.int8, np.int32, np.int64, np.bool, np.float16,
np.float32, np.float64, np.complex64, np.complex128]:
self._reverse1DimAuto(dtype)
def testUnknownDims(self):
data_t = tf.placeholder(tf.float32)
dims_known_t = tf.placeholder(tf.bool, shape=[3])
reverse_known_t = tf.reverse(data_t, dims_known_t)
self.assertEqual(3, reverse_known_t.get_shape().ndims)
dims_unknown_t = tf.placeholder(tf.bool)
reverse_unknown_t = tf.reverse(data_t, dims_unknown_t)
self.assertIs(None, reverse_unknown_t.get_shape().ndims)
data_2d_t = tf.placeholder(tf.float32, shape=[None, None])
dims_2d_t = tf.placeholder(tf.bool, shape=[2])
reverse_2d_t = tf.reverse(data_2d_t, dims_2d_t)
self.assertEqual(2, reverse_2d_t.get_shape().ndims)
dims_3d_t = tf.placeholder(tf.bool, shape=[3])
with self.assertRaisesRegexp(ValueError, "must be rank 3"):
tf.reverse(data_2d_t, dims_3d_t)
class ReverseV2Test(test_util.TensorFlowTestCase):
def testReverse0DimAuto(self):

4
tensorflow/python/ops/array_grad.py
View File

@ -474,7 +474,9 @@ def _ReverseSequenceGrad(op, grad):
@ops.RegisterGradient("Reverse")
def _ReverseGrad(op, grad):
reverse_dims = op.inputs[1]
return array_ops.reverse(grad, reverse_dims), None
# pylint: disable=protected-access
return array_ops._reverse(grad, reverse_dims), None
# pylint: enable=protected-access
@ops.RegisterGradient("ReverseV2")

1
tensorflow/python/ops/array_ops.py
View File

@ -60,7 +60,6 @@ or join multiple tensors together.
@@unstack
@@unpack
@@reverse_sequence
@@reverse
@@reverse_v2
@@transpose
@@extract_image_patches

1
tensorflow/python/ops/hidden_ops.txt
View File

@ -15,6 +15,7 @@ Pack
Pad
Placeholder
RefIdentity
Reverse
SpaceToBatch
Split
SplitV

44
tensorflow/python/ops/image_ops_impl.py
View File

@ -24,6 +24,7 @@ import os
from tensorflow.python.framework import constant_op
from tensorflow.python.framework import dtypes
from tensorflow.python.framework import ops
from tensorflow.python.framework import tensor_shape
from tensorflow.python.framework import tensor_util
from tensorflow.python.ops import array_ops
from tensorflow.python.ops import check_ops
@ -158,6 +159,25 @@ def _CheckAtLeast3DImage(image):
image.get_shape())
def fix_image_flip_shape(image, result):
"""Set the shape to 3 dimensional if we don't know anything else.
Args:
image: original image size
result: flipped or transformed image
Returns:
An image whose shape is at least None,None,None.
"""
image_shape = image.get_shape()
if image_shape == tensor_shape.unknown_shape():
result.set_shape([None, None, None])
else:
result.set_shape(image_shape)
return result
def random_flip_up_down(image, seed=None):
"""Randomly flips an image vertically (upside down).
@ -179,8 +199,10 @@ def random_flip_up_down(image, seed=None):
image = ops.convert_to_tensor(image, name='image')
_Check3DImage(image, require_static=False)
uniform_random = random_ops.random_uniform([], 0, 1.0, seed=seed)
mirror = math_ops.less(array_ops.pack([uniform_random, 1.0, 1.0]), 0.5)
return array_ops.reverse(image, mirror)
mirror_cond = math_ops.less(uniform_random, .5)
stride = array_ops.where(mirror_cond, -1, 1)
result = image[::stride, :, :]
return fix_image_flip_shape(image, result)
def random_flip_left_right(image, seed=None):
@ -204,8 +226,10 @@ def random_flip_left_right(image, seed=None):
image = ops.convert_to_tensor(image, name='image')
_Check3DImage(image, require_static=False)
uniform_random = random_ops.random_uniform([], 0, 1.0, seed=seed)
mirror = math_ops.less(array_ops.pack([1.0, uniform_random, 1.0]), 0.5)
return array_ops.reverse(image, mirror)
mirror_cond = math_ops.less(uniform_random, .5)
stride = array_ops.where(mirror_cond, -1, 1)
result = image[:, ::stride, :]
return fix_image_flip_shape(image, result)
def flip_left_right(image):
@ -227,7 +251,7 @@ def flip_left_right(image):
"""
image = ops.convert_to_tensor(image, name='image')
_Check3DImage(image, require_static=False)
return array_ops.reverse(image, [False, True, False])
return fix_image_flip_shape(image, image[:, ::-1, :])
def flip_up_down(image):
@ -249,7 +273,7 @@ def flip_up_down(image):
"""
image = ops.convert_to_tensor(image, name='image')
_Check3DImage(image, require_static=False)
return array_ops.reverse(image, [True, False, False])
return fix_image_flip_shape(image, array_ops.reverse_v2(image, [0]))
def rot90(image, k=1, name=None):
@ -271,13 +295,13 @@ def rot90(image, k=1, name=None):
k = math_ops.mod(k, 4)
def _rot90():
return array_ops.transpose(array_ops.reverse(image, [False, True, False]),
return array_ops.transpose(array_ops.reverse_v2(image, [1]),
[1, 0, 2])
def _rot180():
return array_ops.reverse(image, [True, True, False])
return array_ops.reverse_v2(image, [0, 1])
def _rot270():
return array_ops.reverse(array_ops.transpose(image, [1, 0, 2]),
[False, True, False])
return array_ops.reverse_v2(array_ops.transpose(image, [1, 0, 2]),
[1])
cases = [(math_ops.equal(k, 1), _rot90),
(math_ops.equal(k, 2), _rot180),
(math_ops.equal(k, 3), _rot270)]

2
tensorflow/python/ops/math_grad.py
View File

@ -921,7 +921,7 @@ def _CastGrad(op, grad):
def _FFTSizeForGrad(grad, rank):
return math_ops.reduce_prod(
array_ops.slice(
array_ops.reverse(array_ops.shape(grad), (True,)), (0,), (rank,)))
array_ops.reverse_v2(array_ops.shape(grad), [0]), (0,), (rank,)))
@ops.RegisterGradient("FFT")

4
tensorflow/python/ops/nn_ops.py
View File

@ -2077,8 +2077,8 @@ def erosion2d(value, kernel, strides, rates, padding, name=None):
with ops.name_scope(name, "erosion2d", [value, kernel]) as name:
# Reduce erosion to dilation by duality.
return math_ops.neg(gen_nn_ops.dilation2d(input=math_ops.neg(value),
filter=array_ops.reverse(
kernel, [True, True, False]),
filter=array_ops.reverse_v2(
kernel, [0, 1]),
strides=strides,
rates=rates,
padding=padding,