| # Copyright 2015 The TensorFlow Authors. All Rights Reserved. |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| # ============================================================================== |
| """Functional tests for depthwise convolutional operations.""" |
| |
| import numpy as np |
| |
| from tensorflow.compiler.tests import xla_test |
| from tensorflow.python.framework import constant_op |
| from tensorflow.python.framework import ops |
| from tensorflow.python.framework import test_util |
| from tensorflow.python.ops import array_ops |
| from tensorflow.python.ops import nn_impl |
| from tensorflow.python.ops import nn_ops |
| import tensorflow.python.ops.nn_grad # pylint: disable=unused-import |
| from tensorflow.python.platform import test |
| |
| |
| # Reference implementation of depthwise_conv2d |
| def ReferenceDepthwiseConv2D(input_tensor, filter_tensor, strides, padding, |
| data_format=None): |
| # Reference implementation of depthwise convolution that uses regular |
| # convolution. |
| convs = [] |
| in_channels = filter_tensor.shape[2] |
| # Use a custom implementation of depthwise conv2d using slicing. |
| for channel in range(in_channels): |
| # Slice the input along channel |
| if data_format == "NCHW": |
| input_slice = input_tensor[:, channel:channel+1, :, :] |
| else: |
| input_slice = input_tensor[:, :, :, channel:channel+1] |
| |
| # Slice the filters. Filters are H, W, InC, DepthMultiplier |
| filter_slice = filter_tensor[:, :, channel:channel+1, :] |
| # Do conv |
| convs.append(nn_ops.conv2d(input_slice, filter_slice, |
| strides, padding, |
| data_format=data_format, |
| name="depthwise_slice_%d" % channel)) |
| |
| # Concat along dimension. |
| if data_format == "NCHW": |
| return array_ops.concat(convs, 1) |
| else: |
| return array_ops.concat(convs, 3) |
| |
| |
| def ConfigsToTest(): |
| """Iterator for different convolution shapes, strides and paddings. |
| |
| Yields: |
| Tuple (input_size, filter_size, out_size, stride, padding), the depthwise |
| convolution parameters. |
| """ |
| input_sizes = [[4, 5, 5, 48], [2, 5, 5, 48], [4, 8, 8, 84], [4, 17, 17, 48], |
| [4, 9, 27, 8], [4, 31, 31, 7], [4, 35, 35, 2], |
| [4, 147, 147, 2], [3, 299, 299, 3], [5, 183, 183, 1]] |
| filter_sizes = [[1, 1, 48, 2], [2, 2, 48, 8], [1, 3, 84, 1], [3, 1, 48, 4], |
| [3, 3, 8, 1], [3, 3, 7, 1], [5, 5, 2, 1], [3, 3, 2, 8], |
| [2, 2, 3, 8], [5, 5, 1, 2]] |
| out_sizes = [[4, 5, 5, 96], [2, 5, 5, 384], [4, 8, 8, 84], [4, 17, 17, 192], |
| [4, 9, 27, 8], [4, 31, 31, 7], [4, 35, 35, 2], [4, 49, 49, 16], |
| [3, 150, 150, 24], [5, 92, 92, 2]] |
| strides = [1, 1, 1, 1, 1, 1, 1, 3, 2, 2] |
| # pylint: disable=invalid-name |
| VALID = "VALID" |
| SAME = "SAME" |
| # pylint: enable=invalid-name |
| paddings = [SAME, SAME, SAME, SAME, SAME, SAME, SAME, VALID, SAME, SAME, SAME] |
| for i, f, o, s, p in zip(input_sizes, filter_sizes, out_sizes, strides, |
| paddings): |
| yield i, f, o, s, p |
| |
| |
| def ConfigsWithDilationsToTest(): |
| """Iterator for different convolution shapes, strides and paddings. |
| |
| Yields: |
| Tuple (input_size, filter_size, out_size, stride, dilation, padding), the |
| depthwise |
| convolution parameters. |
| """ |
| input_sizes = [[4, 6, 6, 48], [4, 8, 8, 84], [4, 36, 36, 2], [4, 148, 148, 2], |
| [3, 300, 300, 3]] |
| filter_sizes = [[1, 1, 48, 2], [1, 3, 84, 1], [5, 5, 2, 1], [4, 4, 2, 8], |
| [2, 2, 3, 8]] |
| out_sizes = [[4, 6, 6, 96], [4, 8, 8, 84], [4, 36, 36, 2], [4, 74, 74, 16], |
| [3, 296, 296, 24]] |
| strides = [1, 1, 2, 2, 1] |
| dilations = [2, 2, 4, 2, 4] |
| # pylint: disable=invalid-name |
| VALID = "VALID" |
| SAME = "SAME" |
| # pylint: enable=invalid-name |
| paddings = [SAME, SAME, SAME, SAME, VALID] |
| for i, f, o, s, d, p in zip(input_sizes, filter_sizes, out_sizes, strides, |
| dilations, paddings): |
| yield i, f, o, s, d, p |
| |
| |
| def CheckGradConfigsToTest(): |
| """Iterator for different convolution shapes, strides and paddings. |
| |
| compute_gradient_error() is very expensive. So the configs should be |
| relatively small. |
| |
| Yields: |
| Tuple (input_size, filter_size, out_size, stride, padding), the depthwise |
| convolution parameters. |
| """ |
| input_sizes = [[2, 5, 8, 1], [4, 5, 5, 1], [2, 4, 4, 2], [1, 15, 15, 2], |
| [2, 15, 16, 1]] |
| filter_sizes = [[4, 4, 1, 2], [2, 2, 1, 2], [3, 1, 2, 2], [1, 3, 2, 1], |
| [3, 3, 1, 2]] |
| out_sizes = [[2, 5, 8, 2], [4, 2, 2, 2], [2, 4, 4, 4], [1, 15, 15, 2], |
| [2, 5, 5, 2]] |
| strides = [1, 2, 1, 1, 3] |
| # pylint: disable=invalid-name |
| VALID = "VALID" |
| SAME = "SAME" |
| # pylint: enable=invalid-name |
| paddings = [SAME, VALID, SAME, SAME, VALID] |
| for i, f, o, s, p in zip(input_sizes, filter_sizes, out_sizes, strides, |
| paddings): |
| yield i, f, o, s, p |
| |
| |
| class DepthwiseConv2DTest(xla_test.XLATestCase): |
| |
| # This is testing that depthwise_conv2d and depthwise_conv2d_native |
| # produce the same results. It also tests that NCHW and NWHC |
| # formats agree, by comparing the depthwise_conv2d_native with |
| # 'NCHW' format (with transposition) matches the 'NHWC' format using |
| # the higher level interface. |
| def _VerifyValues(self, |
| tensor_in_sizes, |
| filter_in_sizes, |
| stride, |
| padding, |
| data_type, |
| data_format="NHWC"): |
| """Verifies the output values of the convolution function. |
| |
| Args: |
| tensor_in_sizes: Input tensor dimensions in |
| [batch, input_rows, input_cols, input_depth]. |
| filter_in_sizes: Filter tensor dimensions in |
| [filter_rows, filter_cols, input_depth, depth_multiplier]. |
| stride: Stride. |
| padding: Padding type. |
| data_type: The data type to use. |
| data_format: The data_format of the input. "NHWC" or "NCHW". |
| """ |
| total_size_1 = 1 |
| total_size_2 = 1 |
| for s in tensor_in_sizes: |
| total_size_1 *= s |
| for s in filter_in_sizes: |
| total_size_2 *= s |
| # Initializes the input and filter tensor with numbers incrementing from 1. |
| x1 = np.array([f * 1.0 for f in range(1, total_size_1 + 1)], |
| dtype=data_type).reshape(tensor_in_sizes) |
| x2 = np.array([f * 1.0 for f in range(1, total_size_2 + 1)], |
| dtype=data_type).reshape(filter_in_sizes) |
| with self.session() as sess: |
| if data_type == np.float32: |
| tolerance = 1e-4 |
| else: |
| self.assertEqual(data_type, np.float64) |
| tolerance = 1e-8 |
| |
| t1 = array_ops.placeholder(shape=tensor_in_sizes, dtype=data_type) |
| t2 = array_ops.placeholder(shape=filter_in_sizes, dtype=data_type) |
| |
| native_t1 = t1 |
| strides = [1, stride, stride, 1] |
| if data_format == "NCHW": |
| # Transpose from NWHC input to NCHW |
| # Ex. [4, 5, 5, 48] to [4, 48, 5, 5] |
| native_t1 = array_ops.transpose(t1, [0, 3, 1, 2]) |
| strides = [1, 1, stride, stride] |
| |
| with self.test_scope(): |
| conv_native = nn_ops.depthwise_conv2d_native( |
| native_t1, |
| t2, |
| strides=strides, |
| data_format=data_format, |
| padding=padding) |
| |
| if data_format == "NCHW": |
| # Transpose back from NCHW to NHWC |
| conv_native = array_ops.transpose(conv_native, [0, 2, 3, 1]) |
| |
| with ops.device("CPU"): |
| conv_interface = ReferenceDepthwiseConv2D( |
| t1, t2, strides=[1, stride, stride, 1], padding=padding) |
| |
| native_result = sess.run(conv_native, {t1: x1, t2: x2}) |
| interface_result = sess.run(conv_interface, {t1: x1, t2: x2}) |
| |
| print("data_type:", data_type, "max diff = ", |
| np.amax(np.absolute(native_result - interface_result))) |
| self.assertAllClose( |
| np.ravel(native_result), np.ravel(interface_result), rtol=tolerance) |
| |
| @test_util.run_without_tensor_float_32( |
| "DepthwiseConv2D may use TF32 when available.") |
| def testDepthwiseConv2D(self): |
| for index, (input_size, filter_size, _, stride, |
| padding) in enumerate(ConfigsToTest()): |
| print("Testing DepthwiseConv2D,", index, "th config:", input_size, "*", |
| filter_size, "stride:", stride, "padding:", padding) |
| for data_type in self.float_types: |
| # TODO(phawkins): the reference implementation only supports float32. |
| if data_type == np.float32: |
| self._VerifyValues( |
| input_size, filter_size, stride, padding, data_type) |
| |
| @test_util.run_without_tensor_float_32( |
| "DepthwiseConv2D may use TF32 when available.") |
| def testDepthwiseConv2DFormat(self): |
| for index, (input_size, filter_size, _, stride, |
| padding) in enumerate(ConfigsToTest()): |
| print("Testing DepthwiseConv2DFormat,", index, "th config:", input_size, |
| "*", filter_size, "stride:", stride, "padding:", padding) |
| for data_type in self.float_types: |
| # TODO(phawkins): the reference implementation only supports float32. |
| if data_type == np.float32: |
| self._VerifyValues( |
| input_size, |
| filter_size, |
| stride, |
| padding, |
| data_type, |
| data_format="NCHW") |
| |
| # This is testing against hand calculated results. |
| |
| def _VerifyHandValues(self, tensor_in_sizes, filter_in_sizes, stride, padding, |
| expected): |
| """Verifies the output values of the depthwise convolution function. |
| |
| Args: |
| tensor_in_sizes: Input tensor dimensions in |
| [batch, input_rows, input_cols, input_depth]. |
| filter_in_sizes: Filter tensor dimensions in |
| [filter_rows, filter_cols, input_depth, depth_multiplier]. |
| stride: Stride. |
| padding: Padding type. |
| expected: An array containing the expected operation outputs. |
| """ |
| total_size_1 = 1 |
| total_size_2 = 1 |
| for s in tensor_in_sizes: |
| total_size_1 *= s |
| for s in filter_in_sizes: |
| total_size_2 *= s |
| # Initializes the input tensor with array containing incrementing |
| # numbers from 1. |
| x1 = np.array([f * 1.0 for f in range(1, total_size_1 + 1)], |
| dtype=np.float32).reshape(tensor_in_sizes) |
| x2 = np.array([f * 1.0 for f in range(1, total_size_2 + 1)], |
| dtype=np.float32).reshape(filter_in_sizes) |
| with self.session() as sess: |
| t1 = array_ops.placeholder(shape=tensor_in_sizes, dtype=np.float32) |
| t2 = array_ops.placeholder(shape=filter_in_sizes, dtype=np.float32) |
| with self.test_scope(): |
| conv = nn_ops.depthwise_conv2d_native( |
| t1, t2, strides=[1, stride, stride, 1], padding=padding) |
| value = sess.run(conv, {t1: x1, t2: x2}) |
| print("value = ", value) |
| self.assertArrayNear(expected, np.ravel(value), 1e-4) |
| self.assertShapeEqual(value, conv) |
| |
| def testConv2D2x2Filter(self): |
| # The inputs look like this (it's a 3 x 2 matrix, each of depth 2): |
| # |
| # [ (1.0, 2.0), (3.0, 4.0), ( 5.0, 6.0) ] |
| # [ (7.0, 8.0), (9.0, 10.0), (11.0, 12.0) ] |
| # We can view this as two inputs |
| # |
| # input depth 0: |
| # |
| # [ 1.0, 3.0, 5.0 ] |
| # [ 7.0, 9.0, 11.0 ] |
| # |
| # input depth 1: |
| # |
| # [ 2.0, 4.0, 6.0 ] |
| # [ 8.0, 10.0, 12.0 ] |
| # |
| # The filter looks like this (it has two 2 x 2 patches, each generating 2 |
| # depths): |
| # |
| # filter #0: |
| # |
| # [ (1.0, 3.0), ( 5.0, 7.0)] |
| # [ (9.0, 11.0), (13.0, 15.0)] |
| # |
| # filter #1: |
| # |
| # [ ( 2.0, 4.0), ( 6.0, 8.0)] |
| # [ (10.0, 12.0), (14.0, 16.0)] |
| # |
| # So the outputs are: |
| # |
| # (position 0, 0: in_depth 0, output_depth 0 -- using filter #0) |
| # 1.0 * 1.0 + 7.0 * 9.0 + 3.0 * 5.0 + 9.0 * 13.0 = 196 |
| # (position 0, 0: in_depth 0, output_depth 1 -- using filter #1) |
| # 1.0 * 2.0 + 7.0 * 10.0 + 3.0 * 6.0 + 9.0 * 14.0 = 216 |
| # (position 0, 0: in_depth 1, output_depth 2 -- using filter #0) |
| # 2.0 * 3.0 + 8.0 * 11.0 + 4.0 * 7.0 + 10.0 * 15.0 = 272 |
| # (position 0, 0: in_depth 1, output_depth 3 -- using filter #1) |
| # 2.0 * 4.0 + 8.0 * 12.0 + 4.0 * 8.0 + 10.0 * 16.0 = 296 |
| # |
| # (position 1, 0: in_depth 0, output_depth 0 -- using filter #0) |
| # 3.0 * 1.0 + 9.0 * 9.0 + 5.0 * 5.0 + 11.0 * 13.0 = 252 |
| # (position 1, 0: in_depth 0, output_depth 1 -- using filter #1) |
| # 3.0 * 2.0 + 9.0 * 10.0 + 5.0 * 6.0 + 11.0 * 14.0 = 280 |
| # (position 1, 0: in_depth 1, output_depth 2 -- using filter #0) |
| # 4.0 * 3.0 + 10.0 * 11.0 + 6.0 * 7.0 + 12.0 * 15.0 = 344 |
| # (position 1, 0: in_depth 1, output_depth 3 -- using filter #1) |
| # 4.0 * 4.0 + 10.0 * 12.0 + 6.0 * 8.0 + 12.0 * 16.0 = 376 |
| expected_output = [196, 216, 272, 296, 252, 280, 344, 376] |
| self._VerifyHandValues( |
| tensor_in_sizes=[1, 2, 3, 2], |
| filter_in_sizes=[2, 2, 2, 2], |
| stride=1, |
| padding="VALID", |
| expected=expected_output) |
| |
| # This is testing that depthwise_conv2d with dilation produces |
| # the same results between CPU and TPU. It also tests that NCHW |
| # and NWHC formats agree. |
| def _VerifyValuesWithDilation(self, |
| tensor_in_sizes, |
| filter_in_sizes, |
| stride, |
| dilation, |
| padding, |
| data_type, |
| data_format="NHWC"): |
| """Verifies the output values of the convolution function. |
| |
| Args: |
| tensor_in_sizes: Input tensor dimensions in [batch, input_rows, |
| input_cols, input_depth]. |
| filter_in_sizes: Filter tensor dimensions in [filter_rows, filter_cols, |
| input_depth, depth_multiplier]. |
| stride: Stride. |
| dilation: Dilation. |
| padding: Padding type. |
| data_type: The data type to use. |
| data_format: The data_format of the input. "NHWC" or "NCHW". |
| """ |
| total_size_1 = 1 |
| total_size_2 = 1 |
| for s in tensor_in_sizes: |
| total_size_1 *= s |
| for s in filter_in_sizes: |
| total_size_2 *= s |
| # Initializes the input and filter tensor with numbers incrementing from 1. |
| x1 = np.array([f * 1.0 for f in range(1, total_size_1 + 1)], |
| dtype=data_type).reshape(tensor_in_sizes) |
| x2 = np.array([f * 1.0 for f in range(1, total_size_2 + 1)], |
| dtype=data_type).reshape(filter_in_sizes) |
| with self.session() as sess: |
| if data_type == np.float32: |
| # TODO(b/64210055): Tolerance for TPU is high. |
| tolerance = 1e-2 |
| else: |
| self.assertEqual(data_type, np.float64) |
| tolerance = 1e-8 |
| |
| t1 = array_ops.placeholder(shape=tensor_in_sizes, dtype=data_type) |
| t2 = array_ops.placeholder(shape=filter_in_sizes, dtype=data_type) |
| |
| native_t1 = t1 |
| strides = [1, stride, stride, 1] |
| dilations = [dilation, dilation] |
| if data_format == "NCHW": |
| # Transpose from NWHC input to NCHW |
| # Ex. [4, 5, 5, 48] to [4, 48, 5, 5] |
| native_t1 = array_ops.transpose(t1, [0, 3, 1, 2]) |
| strides = [1, 1, stride, stride] |
| |
| with self.test_scope(): |
| conv_native = nn_impl.depthwise_conv2d( |
| native_t1, |
| t2, |
| strides=strides, |
| rate=dilations, |
| data_format=data_format, |
| padding=padding) |
| |
| if data_format == "NCHW": |
| # Transpose back from NCHW to NHWC |
| conv_native = array_ops.transpose(conv_native, [0, 2, 3, 1]) |
| |
| with ops.device("CPU"): |
| # CPU only support NHWC format |
| strides = [1, stride, stride, 1] |
| conv_interface = nn_impl.depthwise_conv2d( |
| t1, t2, strides=strides, rate=dilations, padding=padding) |
| |
| native_result = sess.run(conv_native, {t1: x1, t2: x2}) |
| interface_result = sess.run(conv_interface, {t1: x1, t2: x2}) |
| |
| print("data_type:", data_type, "max diff = ", |
| np.amax(np.absolute(native_result - interface_result))) |
| self.assertAllClose( |
| np.ravel(native_result), np.ravel(interface_result), rtol=tolerance) |
| |
| def testDilationDepthwiseConv2DWith(self): |
| for index, (input_size, filter_size, _, stride, dilation, |
| padding) in enumerate(ConfigsWithDilationsToTest()): |
| print("Testing DilationDepthwiseConv2D,", index, "th config:", input_size, |
| "*", filter_size, "stride:", stride, "dilation: ", dilation, |
| "padding:", padding) |
| for data_type in self.float_types: |
| # TODO(phawkins): the reference implementation only supports float32. |
| if data_type == np.float32: |
| self._VerifyValuesWithDilation(input_size, filter_size, stride, |
| dilation, padding, data_type) |
| |
| def testDilationDepthwiseConv2DWithFormat(self): |
| for index, (input_size, filter_size, _, stride, dilation, |
| padding) in enumerate(ConfigsWithDilationsToTest()): |
| print("Testing DilationDepthwiseConv2DFormat,", index, "th config:", |
| input_size, "*", filter_size, "stride:", stride, "dilation:", |
| dilation, "padding:", padding) |
| for data_type in self.float_types: |
| # TODO(phawkins): the reference implementation only supports float32. |
| if data_type == np.float32: |
| self._VerifyValuesWithDilation( |
| input_size, |
| filter_size, |
| stride, |
| dilation, |
| padding, |
| data_type, |
| data_format="NCHW") |
| |
| def _CompareBackpropInput(self, input_sizes, filter_sizes, output_sizes, |
| stride, padding): |
| x1 = np.random.rand(*filter_sizes).astype(np.float32) |
| x2 = np.random.rand(*output_sizes).astype(np.float32) |
| |
| def _GetVal(use_xla): |
| with self.session(): |
| t0 = constant_op.constant(input_sizes, shape=[len(input_sizes)]) |
| t1 = array_ops.placeholder(np.float32, shape=filter_sizes) |
| t2 = array_ops.placeholder(np.float32, shape=output_sizes) |
| if use_xla: |
| with self.test_scope(): |
| backprop = nn_ops.depthwise_conv2d_native_backprop_input( |
| t0, t1, t2, strides=[1, stride, stride, 1], padding=padding) |
| else: |
| backprop = nn_ops.depthwise_conv2d_native_backprop_input( |
| t0, t1, t2, strides=[1, stride, stride, 1], padding=padding) |
| |
| ret = backprop.eval({t1: x1, t2: x2}) |
| self.assertShapeEqual(ret, backprop) |
| return ret |
| |
| gpu_value = _GetVal(use_xla=True) |
| cpu_value = _GetVal(use_xla=False) |
| self.assertAllClose(cpu_value, gpu_value, rtol=1e-3, atol=1e-3) |
| |
| def testDepthwiseConv2DInputGradCompare(self): |
| for index, (input_size, filter_size, output_size, stride, |
| padding) in enumerate(ConfigsToTest()): |
| print("Testing DepthwiseConv2DInputGradCompare,", index, "th config:", |
| input_size, "*", filter_size, "stride:", stride, "padding:", |
| padding) |
| self._CompareBackpropInput(input_size, filter_size, output_size, stride, |
| padding) |
| |
| def _CompareBackpropFilter(self, |
| input_sizes, |
| filter_sizes, |
| output_sizes, |
| stride, |
| padding, |
| data_format="NHWC"): |
| x0 = np.random.rand(*input_sizes).astype(np.float32) |
| x2 = np.random.rand(*output_sizes).astype(np.float32) |
| |
| def _GetVal(use_xla): |
| with self.session(): |
| t0 = array_ops.placeholder(np.float32, shape=input_sizes) |
| t1 = constant_op.constant(filter_sizes, shape=[len(filter_sizes)]) |
| t2 = array_ops.placeholder(np.float32, shape=output_sizes) |
| native_t0 = t0 |
| native_t2 = t2 |
| strides = [1, stride, stride, 1] |
| |
| if use_xla: |
| if data_format == "NCHW": |
| # Transpose from NWHC input to NCHW |
| # Ex. [4, 5, 5, 48] to [4, 48, 5, 5] |
| native_t0 = array_ops.transpose(t0, [0, 3, 1, 2]) |
| native_t2 = array_ops.transpose(t2, [0, 3, 1, 2]) |
| strides = [1, 1, stride, stride] |
| with self.test_scope(): |
| backprop = nn_ops.depthwise_conv2d_native_backprop_filter( |
| native_t0, |
| t1, |
| native_t2, |
| strides=strides, |
| padding=padding, |
| data_format=data_format) |
| else: |
| # For CPU, the format NCHW is not supported. Therefore we always use |
| # NHWC here. |
| backprop = nn_ops.depthwise_conv2d_native_backprop_filter( |
| native_t0, t1, native_t2, strides=strides, padding=padding) |
| ret = backprop.eval({t0: x0, t2: x2}) |
| self.assertShapeEqual(ret, backprop) |
| return ret |
| |
| gpu_value = _GetVal(use_xla=True) |
| cpu_value = _GetVal(use_xla=False) |
| self.assertAllClose(cpu_value, gpu_value, rtol=1e-4, atol=1e-4) |
| |
| @test_util.run_without_tensor_float_32( |
| "DepthwiseConv2DFilterGrad may use TF32 when available.") |
| def testDepthwiseConv2DFilterGradCompare(self): |
| for index, (input_size, filter_size, output_size, stride, |
| padding) in enumerate(ConfigsToTest()): |
| print("Testing DepthwiseConv2DFilterGradCompare,", index, "th config:", |
| input_size, "*", filter_size, "producing output", output_size, |
| "stride:", stride, "padding:", padding) |
| self._CompareBackpropFilter(input_size, filter_size, output_size, |
| stride, padding) |
| |
| @test_util.run_without_tensor_float_32( |
| "DepthwiseConv2DFilterGrad may use TF32 when available.") |
| def testDepthwiseConv2DFilterGradFormatNCHWCompare(self): |
| for index, (input_size, filter_size, output_size, stride, |
| padding) in enumerate(ConfigsToTest()): |
| print("Testing DepthwiseConv2DFilterGradFormatNCHWCompare,", index, |
| "th config:", input_size, "*", filter_size, "producing output", |
| output_size, "stride:", stride, "padding:", padding) |
| self._CompareBackpropFilter( |
| input_size, |
| filter_size, |
| output_size, |
| stride, |
| padding, |
| data_format="NCHW") |
| |
| def _CompareBackpropInputWithDilation(self, input_sizes, filter_sizes, |
| output_sizes, stride, dilation, |
| padding): |
| x1 = np.random.rand(*filter_sizes).astype(np.float32) |
| x2 = np.random.rand(*output_sizes).astype(np.float32) |
| |
| def _GetVal(use_xla): |
| with self.session(): |
| t1 = array_ops.placeholder(np.float32, shape=filter_sizes) |
| t2 = array_ops.placeholder(np.float32, shape=output_sizes) |
| if use_xla: |
| with self.test_scope(): |
| t0 = constant_op.constant(input_sizes, shape=[len(input_sizes)]) |
| backprop = nn_ops.depthwise_conv2d_native_backprop_input( |
| t0, |
| t1, |
| t2, |
| strides=[1, stride, stride, 1], |
| dilations=[1, dilation, dilation, 1], |
| padding=padding) |
| else: |
| # TODO(wangtao): figure out gradient with stride > 1. |
| # depthwise_conv2d_native_backprop_input on CPU doesn't support |
| # dilation. |
| t3 = array_ops.space_to_batch( |
| t2, block_size=dilation, paddings=[[0, 0], [0, 0]]) |
| input_sizes_transform = [ |
| input_sizes[0] * dilation * dilation, input_sizes[1] // dilation, |
| input_sizes[2] // dilation, input_sizes[3] |
| ] |
| t0 = constant_op.constant( |
| input_sizes_transform, shape=[len(input_sizes)]) |
| backprop_naive = nn_ops.depthwise_conv2d_native_backprop_input( |
| t0, t1, t3, strides=[1, stride, stride, 1], padding=padding) |
| backprop = array_ops.batch_to_space( |
| backprop_naive, [[0, 0], [0, 0]], block_size=dilation) |
| |
| ret = backprop.eval({t1: x1, t2: x2}) |
| self.assertShapeEqual(ret, backprop) |
| return ret |
| |
| gpu_value = _GetVal(use_xla=True) |
| cpu_value = _GetVal(use_xla=False) |
| |
| # TODO (b/64210055): Tolerance for TPU is high. |
| self.assertAllClose(cpu_value, gpu_value, rtol=1e-2, atol=1e-3) |
| |
| def testDilationDepthwiseConv2DInputGradWithCompare(self): |
| for index, (input_size, filter_size, output_size, stride, dilation, |
| padding) in enumerate(ConfigsWithDilationsToTest()): |
| print("Testing DilationDepthwiseConv2DInputGradWithDilationCompare,", |
| index, "th config:", input_size, "*", filter_size, "stride:", |
| stride, "dilation:", dilation, "padding:", padding) |
| # TODO(wangtao): implement CPU grad computation with stride > 1. |
| if stride == 1: |
| self._CompareBackpropInputWithDilation(input_size, filter_size, |
| output_size, stride, dilation, |
| padding) |
| |
| def _CompareBackpropFilterWithDilation(self, |
| input_sizes, |
| filter_sizes, |
| output_sizes, |
| stride, |
| dilation, |
| padding, |
| data_format="NHWC"): |
| x0 = np.random.rand(*input_sizes).astype(np.float32) |
| x2 = np.random.rand(*output_sizes).astype(np.float32) |
| |
| def _GetVal(use_xla): |
| with self.session(): |
| t0 = array_ops.placeholder(np.float32, shape=input_sizes) |
| t1 = constant_op.constant(filter_sizes, shape=[len(filter_sizes)]) |
| t2 = array_ops.placeholder(np.float32, shape=output_sizes) |
| native_t0 = t0 |
| native_t2 = t2 |
| strides = [1, stride, stride, 1] |
| dilations = [1, dilation, dilation, 1] |
| |
| if use_xla: |
| if data_format == "NCHW": |
| # Transpose from NWHC input to NCHW |
| # Ex. [4, 5, 5, 48] to [4, 48, 5, 5] |
| native_t0 = array_ops.transpose(t0, [0, 3, 1, 2]) |
| native_t2 = array_ops.transpose(t2, [0, 3, 1, 2]) |
| strides = [1, 1, stride, stride] |
| dilations = [1, 1, dilation, dilation] |
| with self.test_scope(): |
| backprop = nn_ops.depthwise_conv2d_native_backprop_filter( |
| native_t0, |
| t1, |
| native_t2, |
| strides=strides, |
| padding=padding, |
| dilations=dilations, |
| data_format=data_format) |
| else: |
| # For CPU, the format NCHW is not supported. Therefore we always use |
| # NHWC here. |
| # depthwise_conv2d_native_backprop_filter on CPU doesn't support |
| # dilation. |
| native_t3 = array_ops.space_to_batch( |
| native_t2, block_size=dilation, paddings=[[0, 0], [0, 0]]) |
| native_t0_transform = array_ops.space_to_batch( |
| native_t0, block_size=dilation, paddings=[[0, 0], [0, 0]]) |
| backprop = nn_ops.depthwise_conv2d_native_backprop_filter( |
| native_t0_transform, |
| t1, |
| native_t3, |
| strides=strides, |
| padding=padding) |
| ret = backprop.eval({t0: x0, t2: x2}) |
| self.assertShapeEqual(ret, backprop) |
| return ret |
| |
| gpu_value = _GetVal(use_xla=True) |
| cpu_value = _GetVal(use_xla=False) |
| # TODO(b/64210055): Tolerance for TPU is high. |
| self.assertAllClose(cpu_value, gpu_value, rtol=1e-3, atol=1e-4) |
| |
| def testDilationDepthwiseConv2DFilterGradCompare(self): |
| for index, (input_size, filter_size, output_size, stride, dilation, |
| padding) in enumerate(ConfigsWithDilationsToTest()): |
| print("Testing DilationDepthwiseConv2DFilterGradCompare,", index, |
| "th config:", input_size, "*", filter_size, "producing output", |
| output_size, "stride:", stride, "dilation:", dilation, "padding:", |
| padding) |
| if stride == 1: |
| # TODO(wangtao): implement CPU grad computation with stride > 1. |
| self._CompareBackpropFilterWithDilation(input_size, filter_size, |
| output_size, stride, dilation, |
| padding) |
| |
| if __name__ == "__main__": |
| test.main() |
