def testBatch(self):

# Build an arbitrary RGB image

np.random.seed(7)

batch_size = 5

shape = (batch_size, 2, 7, 3)

for nptype in [np.float32, np.float64]:

inp = np.random.rand(*shape).astype(nptype)

# Convert to HSV and back, as a batch and individually

with self.test_session(use_gpu=True) as sess:

batch0 = constant_op.constant(inp)

batch1 = image_ops.rgb_to_hsv(batch0)

batch2 = image_ops.hsv_to_rgb(batch1)

split0 = array_ops.unpack(batch0)

split1 = list(map(image_ops.rgb_to_hsv, split0))

split2 = list(map(image_ops.hsv_to_rgb, split1))

join1 = array_ops.pack(split1)

join2 = array_ops.pack(split2)

batch1, batch2, join1, join2 = sess.run([batch1, batch2, join1, join2])

# Verify that processing batch elements together is the same as separate

self.assertAllClose(batch1, join1)

self.assertAllClose(batch2, join2)

self.assertAllClose(batch2, inp)

def testRGBToHSVRoundTrip(self):

data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1]

for nptype in [np.float32, np.float64]:

rgb_np = np.array(data, dtype=nptype).reshape([2, 2, 3]) / 255.

with self.test_session(use_gpu=True):

hsv = image_ops.rgb_to_hsv(rgb_np)

rgb = image_ops.hsv_to_rgb(hsv)

rgb_tf = rgb.eval()

def _RGBToGrayscale(self, images):

is_batch = True

if len(images.shape) == 3:

is_batch = False

images = np.expand_dims(images, axis=0)

out_shape = images.shape[0:3] + (1,)

out = np.zeros(shape=out_shape, dtype=np.uint8)

for batch in xrange(images.shape[0]):

for y in xrange(images.shape[1]):

for x in xrange(images.shape[2]):

red = images[batch, y, x, 0]

green = images[batch, y, x, 1]

blue = images[batch, y, x, 2]

gray = 0.2989 * red + 0.5870 * green + 0.1140 * blue

out[batch, y, x, 0] = int(gray)

if not is_batch:

out = np.squeeze(out, axis=0)

return out

def _TestRGBToGrayscale(self, x_np):

y_np = self._RGBToGrayscale(x_np)

with self.test_session(use_gpu=True):

x_tf = constant_op.constant(x_np, shape=x_np.shape)

y = image_ops.rgb_to_grayscale(x_tf)

y_tf = y.eval()

self.assertAllEqual(y_tf, y_np)

def testBasicRGBToGrayscale(self):

# 4-D input with batch dimension.

x_np = np.array([[1, 2, 3], [4, 10, 1]],

dtype=np.uint8).reshape([1, 1, 2, 3])

self._TestRGBToGrayscale(x_np)

# 3-D input with no batch dimension.

x_np = np.array([[1, 2, 3], [4, 10, 1]], dtype=np.uint8).reshape([1, 2, 3])

self._TestRGBToGrayscale(x_np)

def testBasicGrayscaleToRGB(self):

# 4-D input with batch dimension.

x_np = np.array([[1, 2]], dtype=np.uint8).reshape([1, 1, 2, 1])

y_np = np.array([[1, 1, 1], [2, 2, 2]],

dtype=np.uint8).reshape([1, 1, 2, 3])

with self.test_session(use_gpu=True):

x_tf = constant_op.constant(x_np, shape=x_np.shape)

y = image_ops.grayscale_to_rgb(x_tf)

y_tf = y.eval()

self.assertAllEqual(y_tf, y_np)

# 3-D input with no batch dimension.

x_np = np.array([[1, 2]], dtype=np.uint8).reshape([1, 2, 1])

y_np = np.array([[1, 1, 1], [2, 2, 2]], dtype=np.uint8).reshape([1, 2, 3])

with self.test_session(use_gpu=True):

x_tf = constant_op.constant(x_np, shape=x_np.shape)

y = image_ops.grayscale_to_rgb(x_tf)

y_tf = y.eval()

self.assertAllEqual(y_tf, y_np)

def testShapeInference(self):

# Shape inference works and produces expected output where possible

rgb_shape = [7, None, 19, 3]

gray_shape = rgb_shape[:-1] + [1]

with self.test_session(use_gpu=True):

rgb_tf = array_ops.placeholder(dtypes.uint8, shape=rgb_shape)

gray = image_ops.rgb_to_grayscale(rgb_tf)

self.assertEqual(gray_shape, gray.get_shape().as_list())

with self.test_session(use_gpu=True):

gray_tf = array_ops.placeholder(dtypes.uint8, shape=gray_shape)

rgb = image_ops.grayscale_to_rgb(gray_tf)

self.assertEqual(rgb_shape, rgb.get_shape().as_list())

# Shape inference does not break for unknown shapes

with self.test_session(use_gpu=True):

rgb_tf_unknown = array_ops.placeholder(dtypes.uint8)

gray_unknown = image_ops.rgb_to_grayscale(rgb_tf_unknown)

self.assertFalse(gray_unknown.get_shape())

with self.test_session(use_gpu=True):

gray_tf_unknown = array_ops.placeholder(dtypes.uint8)

rgb_unknown = image_ops.grayscale_to_rgb(gray_tf_unknown)

def test_adjust_gamma_one(self):

"""Same image should be returned for gamma equal to one"""

with self.test_session():

x_data = np.random.uniform(0, 255, (8, 8))

x_np = np.array(x_data, dtype=np.float32)

x = constant_op.constant(x_np, shape=x_np.shape)

y = image_ops.adjust_gamma(x, gamma=1)

y_tf = y.eval()

y_np = x_np

self.assertAllClose(y_tf, y_np, 1e-6)

def test_adjust_gamma_zero(self):

"""White image should be returned for gamma equal to zero"""

with self.test_session():

x_data = np.random.uniform(0, 255, (8, 8))

x_np = np.array(x_data, dtype=np.float32)

x = constant_op.constant(x_np, shape=x_np.shape)

y = image_ops.adjust_gamma(x, gamma=0)

y_tf = y.eval()

dtype = x.dtype.as_numpy_dtype

y_np = np.array([dtypes.dtype_range[dtype][1]] * x_np.size)

y_np = y_np.reshape((8,8))

self.assertAllClose(y_tf, y_np, 1e-6)

def test_adjust_gamma_less_one(self):

"""Verifying the output with expected results for gamma

with self.test_session():

x_np = np.arange(0, 255, 4, np.uint8).reshape(8,8)

y = image_ops.adjust_gamma(x_np, gamma=0.5)

y_tf = np.trunc(y.eval())

y_np = np.array([[ 0, 31, 45, 55, 63, 71, 78, 84],

[ 90, 95, 100, 105, 110, 115, 119, 123],

[127, 131, 135, 139, 142, 146, 149, 153],

[156, 159, 162, 165, 168, 171, 174, 177],

[180, 183, 186, 188, 191, 194, 196, 199],

[201, 204, 206, 209, 211, 214, 216, 218],

[221, 223, 225, 228, 230, 232, 234, 236],

[238, 241, 243, 245, 247, 249, 251, 253]], dtype=np.float32)

self.assertAllClose(y_tf, y_np, 1e-6)

def test_adjust_gamma_greater_one(self):

"""Verifying the output with expected results for gamma

with self.test_session():

x_np = np.arange(0, 255, 4, np.uint8).reshape(8,8)

y = image_ops.adjust_gamma(x_np, gamma=2)

y_tf = np.trunc(y.eval())

y_np = np.array([[ 0, 0, 0, 0, 1, 1, 2, 3],

[ 4, 5, 6, 7, 9, 10, 12, 14],

[ 16, 18, 20, 22, 25, 27, 30, 33],

[ 36, 39, 42, 45, 49, 52, 56, 60],

[ 64, 68, 72, 76, 81, 85, 90, 95],

[100, 105, 110, 116, 121, 127, 132, 138],

[144, 150, 156, 163, 169, 176, 182, 189],

[196, 203, 211, 218, 225, 233, 241, 249]], dtype=np.float32)

def testAdjustNegativeHue(self):

x_shape = [2, 2, 3]

x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1]

x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape)

delta = -0.25

y_data = [0, 13, 1, 54, 226, 59, 8, 234, 150, 255, 39, 1]

y_np = np.array(y_data, dtype=np.uint8).reshape(x_shape)

with self.test_session(use_gpu=True):

x = constant_op.constant(x_np, shape=x_shape)

y = image_ops.adjust_hue(x, delta)

y_tf = y.eval()

self.assertAllEqual(y_tf, y_np)

def testAdjustPositiveHue(self):

x_shape = [2, 2, 3]

x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1]

x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape)

delta = 0.25

y_data = [13, 0, 11, 226, 54, 221, 234, 8, 92, 1, 217, 255]

y_np = np.array(y_data, dtype=np.uint8).reshape(x_shape)

with self.test_session(use_gpu=True):

x = constant_op.constant(x_np, shape=x_shape)

y = image_ops.adjust_hue(x, delta)

y_tf = y.eval()

self.assertAllEqual(y_tf, y_np)

def _adjustHueNp(self, x_np, delta_h):

self.assertEqual(x_np.shape[-1], 3)

x_v = x_np.reshape([-1, 3])

y_v = np.ndarray(x_v.shape, dtype=x_v.dtype)

channel_count = x_v.shape[0]

for i in xrange(channel_count):

r = x_v[i][0]

g = x_v[i][1]

b = x_v[i][2]

h, s, v = colorsys.rgb_to_hsv(r, g, b)

h += delta_h

h = math.fmod(h + 10.0, 1.0)

r, g, b = colorsys.hsv_to_rgb(h, s, v)

y_v[i][0] = r

y_v[i][1] = g

y_v[i][2] = b

return y_v.reshape(x_np.shape)

def _adjustHueTf(self, x_np, delta_h):

with self.test_session(use_gpu=False):

x = constant_op.constant(x_np)

y = image_ops.adjust_hue(x, delta_h)

y_tf = y.eval()

return y_tf

def testAdjustRandomHue(self):

x_shapes = [

[2, 2, 3],

[4, 2, 3],

[2, 4, 3],

[2, 5, 3],

[1000, 1, 3],

]

test_styles = [

'all_random',

'rg_same',

'rb_same',

'gb_same',

'rgb_same',

]

for x_shape in x_shapes:

for test_style in test_styles:

x_np = np.random.rand(*x_shape) * 255.

delta_h = np.random.rand() * 2.0 - 1.0

if test_style == 'all_random':

pass

elif test_style == 'rg_same':

x_np[..., 1] = x_np[..., 0]

elif test_style == 'rb_same':

x_np[..., 2] = x_np[..., 0]

elif test_style == 'gb_same':

x_np[..., 2] = x_np[..., 1]

elif test_style == 'rgb_same':

x_np[..., 1] = x_np[..., 0]

x_np[..., 2] = x_np[..., 0]

else:

raise AssertionError('Invalid test style: %s' % (test_style))

y_np = self._adjustHueNp(x_np, delta_h)

y_tf = self._adjustHueTf(x_np, delta_h)

self.assertAllClose(y_tf, y_np, rtol=2e-5, atol=1e-5)

def testInvalidShapes(self):

fused = False

if not fused:

# The tests are known to pass with the fused adjust_hue. We will enable

# them when the fused implementation is the default.

return

x_np = np.random.rand(2, 3) * 255.

delta_h = np.random.rand() * 2.0 - 1.0

fused = False

with self.assertRaisesRegexp(ValueError, 'Shape must be at least rank 3'):

self._adjustHueTf(x_np, delta_h)

x_np = np.random.rand(4, 2, 4) * 255.

delta_h = np.random.rand() * 2.0 - 1.0

with self.assertRaisesOpError('input must have 3 channels'):

def _benchmarkAdjustHue(self, device, cpu_count):

image_shape = [299, 299, 3]

warmup_rounds = 100

benchmark_rounds = 1000

config = tf.ConfigProto()

if cpu_count is not None:

config.inter_op_parallelism_threads = 1

config.intra_op_parallelism_threads = cpu_count

with tf.Session('', graph=tf.Graph(), config=config) as sess:

with tf.device(device):

inputs = tf.Variable(

tf.random_uniform(

image_shape, dtype=tf.float32) * 255,

trainable=False,

dtype=tf.float32)

delta = tf.constant(0.1, dtype=tf.float32)

outputs = image_ops.adjust_hue(inputs, delta)

run_op = tf.group(outputs)

sess.run(tf.initialize_all_variables())

for i in xrange(warmup_rounds + benchmark_rounds):

if i == warmup_rounds:

start = time.time()

sess.run(run_op)

end = time.time()

step_time = (end - start) / benchmark_rounds

tag = '%s' % (cpu_count) if cpu_count is not None else '_all'

print('benchmarkAdjustHue_299_299_3_cpu%s step_time: %.2f us' %

(tag, step_time * 1e6))

self.report_benchmark(

name='benchmarkAdjustHue_299_299_3_cpu%s' % (tag),

iters=benchmark_rounds,

wall_time=step_time)

def benchmarkAdjustHueCpu1(self):

self._benchmarkAdjustHue('/cpu:0', 1)

def benchmarkAdjustHueCpuAll(self):

self._benchmarkAdjustHue('/cpu:0', None)

def benchmarkAdjustHueGpu(self):

def testHalfSaturation(self):

x_shape = [2, 2, 3]

x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1]

x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape)

saturation_factor = 0.5

y_data = [6, 9, 13, 140, 180, 226, 135, 121, 234, 172, 255, 128]

y_np = np.array(y_data, dtype=np.uint8).reshape(x_shape)

with self.test_session(use_gpu=True):

x = constant_op.constant(x_np, shape=x_shape)

y = image_ops.adjust_saturation(x, saturation_factor)

y_tf = y.eval()

self.assertAllEqual(y_tf, y_np)

def testTwiceSaturation(self):

x_shape = [2, 2, 3]

x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1]

x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape)

saturation_factor = 2.0

y_data = [0, 5, 13, 0, 106, 226, 30, 0, 234, 89, 255, 0]

y_np = np.array(y_data, dtype=np.uint8).reshape(x_shape)

with self.test_session(use_gpu=True):

x = constant_op.constant(x_np, shape=x_shape)

y = image_ops.adjust_saturation(x, saturation_factor)

y_tf = y.eval()

def testIdempotentLeftRight(self):

x_np = np.array([[1, 2, 3], [1, 2, 3]], dtype=np.uint8).reshape([2, 3, 1])

with self.test_session(use_gpu=True):

x_tf = constant_op.constant(x_np, shape=x_np.shape)

y = image_ops.flip_left_right(image_ops.flip_left_right(x_tf))

y_tf = y.eval()

self.assertAllEqual(y_tf, x_np)

def testLeftRight(self):

x_np = np.array([[1, 2, 3], [1, 2, 3]], dtype=np.uint8).reshape([2, 3, 1])

y_np = np.array([[3, 2, 1], [3, 2, 1]], dtype=np.uint8).reshape([2, 3, 1])

with self.test_session(use_gpu=True):

x_tf = constant_op.constant(x_np, shape=x_np.shape)

y = image_ops.flip_left_right(x_tf)

y_tf = y.eval()

self.assertAllEqual(y_tf, y_np)

def testIdempotentUpDown(self):

x_np = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.uint8).reshape([2, 3, 1])

with self.test_session(use_gpu=True):

x_tf = constant_op.constant(x_np, shape=x_np.shape)

y = image_ops.flip_up_down(image_ops.flip_up_down(x_tf))

y_tf = y.eval()

self.assertAllEqual(y_tf, x_np)

def testUpDown(self):

x_np = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.uint8).reshape([2, 3, 1])

y_np = np.array([[4, 5, 6], [1, 2, 3]], dtype=np.uint8).reshape([2, 3, 1])

with self.test_session(use_gpu=True):

x_tf = constant_op.constant(x_np, shape=x_np.shape)

y = image_ops.flip_up_down(x_tf)

y_tf = y.eval()

self.assertAllEqual(y_tf, y_np)

def testIdempotentTranspose(self):

x_np = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.uint8).reshape([2, 3, 1])

with self.test_session(use_gpu=True):

x_tf = constant_op.constant(x_np, shape=x_np.shape)

y = image_ops.transpose_image(image_ops.transpose_image(x_tf))

y_tf = y.eval()

self.assertAllEqual(y_tf, x_np)

def testTranspose(self):

x_np = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.uint8).reshape([2, 3, 1])

y_np = np.array([[1, 4], [2, 5], [3, 6]], dtype=np.uint8).reshape([3, 2, 1])

with self.test_session(use_gpu=True):

x_tf = constant_op.constant(x_np, shape=x_np.shape)

y = image_ops.transpose_image(x_tf)

y_tf = y.eval()

self.assertAllEqual(y_tf, y_np)

def testPartialShapes(self):

p_unknown_rank = array_ops.placeholder(dtypes.uint8)

p_unknown_dims = array_ops.placeholder(dtypes.uint8,

shape=[None, None, None])

p_unknown_width = array_ops.placeholder(dtypes.uint8, shape=[64, None, 3])

p_wrong_rank = array_ops.placeholder(dtypes.uint8, shape=[None, None])

p_zero_dim = array_ops.placeholder(dtypes.uint8, shape=[64, 0, 3])

for op in [image_ops.flip_left_right,

image_ops.flip_up_down,

image_ops.random_flip_left_right,

image_ops.random_flip_up_down,

image_ops.transpose_image,

image_ops.rot90]:

transformed_unknown_rank = op(p_unknown_rank)

self.assertEqual(3, transformed_unknown_rank.get_shape().ndims)

transformed_unknown_dims = op(p_unknown_dims)

self.assertEqual(3, transformed_unknown_dims.get_shape().ndims)

transformed_unknown_width = op(p_unknown_width)

self.assertEqual(3, transformed_unknown_width.get_shape().ndims)

with self.assertRaisesRegexp(ValueError, 'must be three-dimensional'):

op(p_wrong_rank)

with self.assertRaisesRegexp(ValueError, 'must be > 0'):

op(p_zero_dim)

def testRot90GroupOrder(self):

image = np.arange(24, dtype=np.uint8).reshape([2, 4, 3])

with self.test_session(use_gpu=True):

rotated = image

for _ in xrange(4):

rotated = image_ops.rot90(rotated)

self.assertAllEqual(image, rotated.eval())

def testRot90NumpyEquivalence(self):

image = np.arange(24, dtype=np.uint8).reshape([2, 4, 3])

with self.test_session(use_gpu=True):

k_placeholder = array_ops.placeholder(dtypes.int32, shape=[])

y_tf = image_ops.rot90(image, k_placeholder)

for k in xrange(4):

y_np = np.rot90(image, k=k)

def testRandomLeftRight(self):

x_np = np.array([0, 1], dtype=np.uint8).reshape([1, 2, 1])

num_iterations = 500

hist = [0, 0]

with self.test_session(use_gpu=True):

x_tf = constant_op.constant(x_np, shape=x_np.shape)

y = image_ops.random_flip_left_right(x_tf)

for _ in xrange(num_iterations):

y_np = y.eval().flatten()[0]

hist[y_np] += 1

# Ensure that each entry is observed within 4 standard deviations.

four_stddev = 4.0 * np.sqrt(num_iterations / 2.0)

self.assertAllClose(hist, [num_iterations / 2.0] * 2, atol=four_stddev)

def testRandomUpDown(self):

x_np = np.array([0, 1], dtype=np.uint8).reshape([2, 1, 1])

num_iterations = 500

hist = [0, 0]

with self.test_session(use_gpu=True):

x_tf = constant_op.constant(x_np, shape=x_np.shape)

y = image_ops.random_flip_up_down(x_tf)

for _ in xrange(num_iterations):

y_np = y.eval().flatten()[0]

hist[y_np] += 1

# Ensure that each entry is observed within 4 standard deviations.

four_stddev = 4.0 * np.sqrt(num_iterations / 2.0)

def _testContrast(self, x_np, y_np, contrast_factor):

with self.test_session(use_gpu=True):

x = constant_op.constant(x_np, shape=x_np.shape)

y = image_ops.adjust_contrast(x, contrast_factor)

y_tf = y.eval()

self.assertAllClose(y_tf, y_np, 1e-6)

def testDoubleContrastUint8(self):

x_shape = [1, 2, 2, 3]

x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1]

x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape)

y_data = [0, 0, 0, 62, 169, 255, 28, 0, 255, 135, 255, 0]

y_np = np.array(y_data, dtype=np.uint8).reshape(x_shape)

self._testContrast(x_np, y_np, contrast_factor=2.0)

def testDoubleContrastFloat(self):

x_shape = [1, 2, 2, 3]

x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1]

x_np = np.array(x_data, dtype=np.float).reshape(x_shape) / 255.

y_data = [-45.25, -90.75, -92.5, 62.75, 169.25, 333.5, 28.75, -84.75, 349.5,

134.75, 409.25, -116.5]

y_np = np.array(y_data, dtype=np.float).reshape(x_shape) / 255.

self._testContrast(x_np, y_np, contrast_factor=2.0)

def testHalfContrastUint8(self):

x_shape = [1, 2, 2, 3]

x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1]

x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape)

y_data = [22, 52, 65, 49, 118, 172, 41, 54, 176, 67, 178, 59]

y_np = np.array(y_data, dtype=np.uint8).reshape(x_shape)

self._testContrast(x_np, y_np, contrast_factor=0.5)

def testBatchDoubleContrast(self):

x_shape = [2, 1, 2, 3]

x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1]

x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape)

y_data = [0, 0, 0, 81, 200, 255, 10, 0, 255, 116, 255, 0]

y_np = np.array(y_data, dtype=np.uint8).reshape(x_shape)

self._testContrast(x_np, y_np, contrast_factor=2.0)

def _adjustContrastNp(self, x_np, contrast_factor):

mean = np.mean(x_np, (1, 2), keepdims=True)

y_np = mean + contrast_factor * (x_np - mean)

return y_np

def _adjustContrastTf(self, x_np, contrast_factor):

with self.test_session(use_gpu=True):

x = constant_op.constant(x_np)

y = image_ops.adjust_contrast(x, contrast_factor)

y_tf = y.eval()

return y_tf

def testRandomContrast(self):

x_shapes = [

[1, 2, 2, 3],

[2, 1, 2, 3],

[1, 2, 2, 3],

[2, 5, 5, 3],

[2, 1, 1, 3],

]

for x_shape in x_shapes:

x_np = np.random.rand(*x_shape) * 255.

contrast_factor = np.random.rand() * 2.0 + 0.1

y_np = self._adjustContrastNp(x_np, contrast_factor)

y_tf = self._adjustContrastTf(x_np, contrast_factor)

def _testBrightness(self, x_np, y_np, delta):

with self.test_session(use_gpu=True):

x = constant_op.constant(x_np, shape=x_np.shape)

y = image_ops.adjust_brightness(x, delta)

y_tf = y.eval()

self.assertAllClose(y_tf, y_np, 1e-6)

def testPositiveDeltaUint8(self):

x_shape = [2, 2, 3]

x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1]

x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape)

y_data = [10, 15, 23, 64, 145, 236, 47, 18, 244, 100, 255, 11]

y_np = np.array(y_data, dtype=np.uint8).reshape(x_shape)

self._testBrightness(x_np, y_np, delta=10. / 255.)

def testPositiveDeltaFloat(self):

x_shape = [2, 2, 3]

x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1]

x_np = np.array(x_data, dtype=np.float32).reshape(x_shape) / 255.

y_data = [10, 15, 23, 64, 145, 236, 47, 18, 244, 100, 265, 11]

y_np = np.array(y_data, dtype=np.float32).reshape(x_shape) / 255.

self._testBrightness(x_np, y_np, delta=10. / 255.)

def testNegativeDelta(self):

x_shape = [2, 2, 3]

x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1]

x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape)

y_data = [0, 0, 3, 44, 125, 216, 27, 0, 224, 80, 245, 0]

y_np = np.array(y_data, dtype=np.uint8).reshape(x_shape)

def _NumpyPerImageWhitening(self, x):

num_pixels = np.prod(x.shape)

x2 = np.square(x).astype(np.float32)

mn = np.mean(x)

vr = np.mean(x2) - (mn * mn)

stddev = max(math.sqrt(vr), 1.0 / math.sqrt(num_pixels))

y = x.astype(np.float32)

y -= mn

y /= stddev

return y

def testBasic(self):

x_shape = [13, 9, 3]

x_np = np.arange(0, np.prod(x_shape), dtype=np.int32).reshape(x_shape)

y_np = self._NumpyPerImageWhitening(x_np)

with self.test_session(use_gpu=True):

x = constant_op.constant(x_np, shape=x_shape)

y = image_ops.per_image_standardization(x)

y_tf = y.eval()

self.assertAllClose(y_tf, y_np, atol=1e-4)

def testUniformImage(self):

im_np = np.ones([19, 19, 3]).astype(np.float32) * 249

im = constant_op.constant(im_np)

whiten = image_ops.per_image_standardization(im)

with self.test_session(use_gpu=True):

whiten_np = whiten.eval()

def _CropToBoundingBox(self, x, offset_height, offset_width,

target_height, target_width, use_tensor_inputs):

if use_tensor_inputs:

offset_height = ops.convert_to_tensor(offset_height)

offset_width = ops.convert_to_tensor(offset_width)

target_height = ops.convert_to_tensor(target_height)

target_width = ops.convert_to_tensor(target_width)

x_tensor = array_ops.placeholder(x.dtype, shape=[None]*x.ndim)

feed_dict = {x_tensor: x}

else:

x_tensor = x

feed_dict = {}

y = image_ops.crop_to_bounding_box(x_tensor, offset_height, offset_width,

target_height, target_width)

if not use_tensor_inputs:

self.assertTrue(y.get_shape().is_fully_defined())

with self.test_session(use_gpu=True):

return y.eval(feed_dict=feed_dict)

def _assertReturns(self, x, x_shape, offset_height, offset_width,

y, y_shape, use_tensor_inputs_options=None):

use_tensor_inputs_options = use_tensor_inputs_options or [False, True]

target_height, target_width, _ = y_shape

x = np.array(x).reshape(x_shape)

y = np.array(y).reshape(y_shape)

for use_tensor_inputs in use_tensor_inputs_options:

y_tf = self._CropToBoundingBox(x, offset_height, offset_width,

target_height, target_width,

use_tensor_inputs)

self.assertAllClose(y, y_tf)

def _assertRaises(self, x, x_shape, offset_height, offset_width,

target_height, target_width, err_msg,

use_tensor_inputs_options=None):

use_tensor_inputs_options = use_tensor_inputs_options or [False, True]

x = np.array(x).reshape(x_shape)

for use_tensor_inputs in use_tensor_inputs_options:

try:

self._CropToBoundingBox(x, offset_height, offset_width,

target_height, target_width,

use_tensor_inputs)

except Exception as e:

if err_msg not in str(e):

raise

else:

raise AssertionError('Exception not raised: %s' % err_msg)

def _assertShapeInference(self, pre_shape, height, width, post_shape):

image = array_ops.placeholder(dtypes.float32, shape=pre_shape)

y = image_ops.crop_to_bounding_box(image, 0, 0, height, width)

self.assertEqual(y.get_shape().as_list(), post_shape)

def testNoOp(self):

x_shape = [10, 10, 10]

x = np.random.uniform(size=x_shape)

self._assertReturns(x, x_shape, 0, 0, x, x_shape)

def testCrop(self):

x = [1, 2, 3,

4, 5, 6,

7, 8, 9]

x_shape = [3, 3, 1]

offset_height, offset_width = [1, 0]

y_shape = [2, 3, 1]

y = [4, 5, 6,

7, 8, 9]

self._assertReturns(x, x_shape, offset_height, offset_width, y, y_shape)

offset_height, offset_width = [0, 1]

y_shape = [3, 2, 1]

y = [2, 3,

5, 6,

8, 9]

self._assertReturns(x, x_shape, offset_height, offset_width, y, y_shape)

offset_height, offset_width = [0, 0]

y_shape = [2, 3, 1]

y = [1, 2, 3,

4, 5, 6]

self._assertReturns(x, x_shape, offset_height, offset_width, y, y_shape)

offset_height, offset_width = [0, 0]

y_shape = [3, 2, 1]

y = [1, 2,

4, 5,

7, 8]

self._assertReturns(x, x_shape, offset_height, offset_width, y, y_shape)

def testShapeInference(self):

self._assertShapeInference([55, 66, 3], 55, 66, [55, 66, 3])

self._assertShapeInference([59, 69, 3], 55, 66, [55, 66, 3])

self._assertShapeInference([None, 66, 3], 55, 66, [55, 66, 3])

self._assertShapeInference([None, 69, 3], 55, 66, [55, 66, 3])

self._assertShapeInference([55, None, 3], 55, 66, [55, 66, 3])

self._assertShapeInference([59, None, 3], 55, 66, [55, 66, 3])