# 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 convolutional operations."""

from __future__ import absolute_import

from __future__ import division

from __future__ import print_function

import os

import time

import numpy as np

from tensorflow.contrib import layers

from tensorflow.python.client import session as session_lib

from tensorflow.python.framework import constant_op

from tensorflow.python.framework import dtypes

from tensorflow.python.framework import errors_impl

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 gradient_checker

from tensorflow.python.ops import nn_impl

from tensorflow.python.ops import nn_ops

from tensorflow.python.ops import random_ops

from tensorflow.python.ops import variables

import tensorflow.python.ops.nn_grad # pylint: disable=unused-import

from tensorflow.python.platform import test

from tensorflow.python.platform import tf_logging

def GetShrunkInceptionShapes(shrink=10):

"""Iterator for smaller versions of convolution shapes in 2015 Inception.

Relative to inception, each depth value is `depth // shrink`.

Args:

shrink: Factor to shrink each depth value by relative to Inception.

Yields:

Tuple (input_size, filter_size, out_size, stride, padding), the convolution

parameters of Inception layers.

"""

input_sizes = [[4, 5, 5, 1248], [4, 8, 8, 384], [4, 8, 8, 384],

[4, 8, 8, 2048], [4, 8, 8, 448], [4, 8, 8, 2048],

[4, 8, 8, 2048], [4, 8, 8, 2048], [4, 8, 8, 1760],

[4, 8, 8, 1760], [4, 8, 8, 1760], [4, 8, 8, 1760],

[4, 17, 17, 192], [4, 17, 17, 192], [4, 17, 17, 1248],

[4, 17, 17, 128], [4, 17, 17, 1248], [4, 17, 17, 224],

[4, 17, 17, 192], [4, 17, 17, 192], [4, 17, 17, 1216],

[4, 17, 17, 1216], [4, 17, 17, 224], [4, 17, 17, 192],

[4, 17, 17, 192], [4, 17, 17, 1152], [4, 17, 17, 1152],

[4, 17, 17, 192], [4, 17, 17, 160], [4, 17, 17, 1152],

[4, 17, 17, 1024], [4, 17, 17, 128], [4, 17, 17, 1024],

[4, 17, 17, 128], [4, 17, 17, 1024], [4, 17, 17, 128],

[4, 17, 17, 768], [4, 17, 17, 128], [4, 17, 17, 128],

[4, 17, 17, 768], [4, 17, 17, 768], [4, 35, 35, 96],

[4, 35, 35, 288], [4, 35, 35, 64], [4, 35, 35, 288],

[4, 35, 35, 256], [4, 35, 35, 48], [4, 35, 35, 256],

[4, 35, 35, 96], [4, 35, 35, 192], [4, 35, 35, 192],

[4, 35, 35, 192], [4, 73, 73, 64], [4, 73, 73, 64],

[4, 147, 147, 24]]

filter_sizes = [[1, 1, 1248, 128], [1, 3, 384, 384], [3, 1, 384, 384],

[1, 1, 2048, 192], [3, 3, 448, 384], [1, 1, 2048, 320],

[1, 1, 2048, 448], [1, 1, 2048, 384], [1, 1, 1760, 384],

[1, 1, 1760, 192], [1, 1, 1760, 448], [1, 1, 1760, 320],

[3, 3, 192, 192], [3, 3, 192, 192], [1, 1, 1248, 192],

[3, 3, 128, 320], [1, 1, 1248, 128], [1, 3, 224, 224],

[3, 1, 192, 256], [1, 3, 192, 256], [1, 1, 1216, 192],

[1, 1, 1216, 96], [3, 1, 224, 224], [3, 3, 192, 224],

[1, 3, 192, 192], [1, 1, 1152, 192], [1, 1, 1152, 128],

[3, 1, 192, 192], [3, 3, 160, 192], [1, 1, 1152, 160],

[1, 1, 1024, 128], [1, 3, 128, 192], [1, 1, 1024, 160],

[3, 1, 128, 192], [1, 1, 1024, 256], [3, 1, 128, 128],

[1, 1, 768, 192], [1, 3, 128, 128], [3, 3, 128, 128],

[1, 1, 768, 128], [1, 1, 768, 320], [3, 3, 96, 96],

[3, 3, 288, 384], [3, 3, 64, 96], [1, 1, 288, 64],

[1, 1, 256, 64], [5, 5, 48, 64], [1, 1, 256, 48],

[3, 3, 96, 96], [1, 1, 192, 32], [1, 1, 192, 64],

[1, 1, 192, 48], [3, 3, 64, 192], [1, 1, 64, 64],

[1, 1, 24, 64]]

out_sizes = [[4, 5, 5, 128], [4, 8, 8, 384], [4, 8, 8, 384],

[4, 8, 8, 192], [4, 8, 8, 384], [4, 8, 8, 320],

[4, 8, 8, 448], [4, 8, 8, 384], [4, 8, 8, 384],

[4, 8, 8, 192], [4, 8, 8, 448], [4, 8, 8, 320],

[4, 8, 8, 192], [4, 17, 17, 192], [4, 17, 17, 192],

[4, 8, 8, 320], [4, 17, 17, 128], [4, 17, 17, 224],

[4, 17, 17, 256], [4, 17, 17, 256], [4, 17, 17, 192],

[4, 17, 17, 96], [4, 17, 17, 224], [4, 17, 17, 224],

[4, 17, 17, 192], [4, 17, 17, 192], [4, 17, 17, 128],

[4, 17, 17, 192], [4, 17, 17, 192], [4, 17, 17, 160],

[4, 17, 17, 128], [4, 17, 17, 192], [4, 17, 17, 160],

[4, 17, 17, 192], [4, 17, 17, 256], [4, 17, 17, 128],

[4, 17, 17, 192], [4, 17, 17, 128], [4, 17, 17, 128],

[4, 17, 17, 128], [4, 17, 17, 320], [4, 17, 17, 96],

[4, 17, 17, 384], [4, 35, 35, 96], [4, 35, 35, 64],

[4, 35, 35, 64], [4, 35, 35, 64], [4, 35, 35, 48],

[4, 35, 35, 96], [4, 35, 35, 32], [4, 35, 35, 64],

[4, 35, 35, 48], [4, 71, 71, 192], [4, 73, 73, 64],

[4, 147, 147, 64]]

strides = [

1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1,

1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1, 1, 1, 1, 1, 1,

1, 1, 1, 1, 1

]

# Shrink sizes to make the test faster

for i in input_sizes:

i[3] //= shrink

for f in filter_sizes:

f[2] //= shrink

f[3] //= shrink

for o in out_sizes:

o[3] //= shrink

# pylint: disable=invalid-name

VALID = "VALID"

SAME = "SAME"

# pylint: enable=invalid-name

paddings = [

SAME, SAME, SAME, SAME, SAME, SAME, SAME, SAME, SAME, SAME, SAME, SAME,

VALID, SAME, SAME, VALID, SAME, SAME, SAME, SAME, SAME, SAME, SAME, SAME,

SAME, SAME, SAME, SAME, SAME, SAME, SAME, SAME, SAME, SAME, SAME, SAME,

SAME, SAME, SAME, SAME, SAME, VALID, VALID, SAME, SAME, SAME, SAME, SAME,

SAME, SAME, SAME, SAME, VALID, VALID, VALID

]

for i, f, o, s, p in zip(input_sizes, filter_sizes, out_sizes, strides,

paddings):

yield i, f, o, s, p

def GetTestConfigs():

"""Get all the valid tests configs to run.

Returns:

all the valid test configs as tuples of data_format and use_gpu.

"""

test_configs = [("NHWC", False), ("NHWC", True)]

if test.is_gpu_available(cuda_only=True):

# "NCHW" format is only supported on CUDA.

test_configs += [("NCHW", True)]

return test_configs

class Conv2DTest(test.TestCase):

def _DtypesToTest(self, use_gpu):

if use_gpu and not test_util.CudaSupportsHalfMatMulAndConv():

return [dtypes.float32]

else:

# It is important that float32 comes before float16 here,

# as we will be using its gradients as reference for fp16 gradients.

return [dtypes.float32, dtypes.float16]

def _SetupValuesForDevice(self, tensor_in_sizes, filter_in_sizes, strides,

padding, data_format, dtype, use_gpu):

"""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

[kernel_rows, kernel_cols, input_depth, output_depth].

strides: Stride: [col_stride, row_stride]

padding: Padding type.

data_format: Format of the data tensors.

dtype: Data type for inputs and outputs.

use_gpu: True if the operations should be run on GPU

Returns:

Symbolic tensor value that can be used to execute the computation

"""

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 = [f * 1.0 for f in range(1, total_size_1 + 1)]

x2 = [f * 1.0 for f in range(1, total_size_2 + 1)]

with test_util.device(use_gpu):

t1 = constant_op.constant(x1, shape=tensor_in_sizes, dtype=dtype)

t2 = constant_op.constant(x2, shape=filter_in_sizes, dtype=dtype)

strides = [1] + strides + [1]

if data_format == "NCHW":

t1 = test_util.NHWCToNCHW(t1)

strides = test_util.NHWCToNCHW(strides)

conv = nn_ops.conv2d(

t1, t2, strides=strides, padding=padding, data_format=data_format)

if data_format == "NCHW":

conv = test_util.NCHWToNHWC(conv)

return conv

def _CompareFwdValues(self, tensor_in_sizes, filter_in_sizes, conv_strides,

padding):

"""Verifies that CPU and GPU produce the same values.

Args:

tensor_in_sizes: Input tensor dimensions in

[batch, input_rows, input_cols, input_depth].

filter_in_sizes: Filter tensor dimensions in

[kernel_rows, kernel_cols, input_depth, output_depth].

conv_strides: [row_stride, col_stride] for the convolution;

padding: Padding type.

"""

x1 = np.random.rand(*tensor_in_sizes).astype(np.float32)

x2 = np.random.rand(*filter_in_sizes).astype(np.float32)

def _SetupVal(data_format, use_gpu):

with test_util.device(use_gpu):

t1 = constant_op.constant(x1, shape=tensor_in_sizes)

t2 = constant_op.constant(x2, shape=filter_in_sizes)

strides = [1] + conv_strides + [1]

if data_format == "NCHW":

t1 = test_util.NHWCToNCHW(t1)

strides = test_util.NHWCToNCHW(strides)

conv = nn_ops.conv2d(

t1, t2, strides=strides, padding=padding, data_format=data_format)

if data_format == "NCHW":

conv = test_util.NCHWToNHWC(conv)

return conv

tensors = []

for (data_format, use_gpu) in GetTestConfigs():

tensors.append(_SetupVal(data_format, use_gpu))

values = self.evaluate(tensors)

for i in range(1, len(values)):

self.assertAllClose(values[0], values[i], rtol=1e-5, atol=1e-5)

def _VerifyValues(self, tensor_in_sizes, filter_in_sizes, strides, padding,

expected):

tensors = []

for (data_format, use_gpu) in GetTestConfigs():

for dtype in self._DtypesToTest(use_gpu):

result = self._SetupValuesForDevice(

tensor_in_sizes,

filter_in_sizes,

strides,

padding,

data_format,

dtype,

use_gpu=use_gpu)

tensors.append(result)

values = self.evaluate(tensors)

for i in range(len(tensors)):

conv = tensors[i]

value = values[i]

print("expected = ", expected)

print("actual = ", value)

tol = 1e-5

if value.dtype == np.float16:

tol = 1e-3

self.assertAllClose(expected, np.ravel(value), atol=tol, rtol=tol)

self.assertShapeEqual(value, conv)

@test_util.run_in_graph_and_eager_modes()

def testConv2D1x1Filter(self):

expected_output = [

30.0, 36.0, 42.0, 66.0, 81.0, 96.0, 102.0, 126.0, 150.0, 138.0, 171.0,

204.0, 174.0, 216.0, 258.0, 210.0, 261.0, 312.0

]

self._VerifyValues(

tensor_in_sizes=[1, 2, 3, 3],

filter_in_sizes=[1, 1, 3, 3],

strides=[1, 1],

padding="VALID",

expected=expected_output)

@test_util.run_in_graph_and_eager_modes()

def testConv2DEmpty(self):

expected_output = []

self._VerifyValues(

tensor_in_sizes=[0, 2, 3, 3],

filter_in_sizes=[1, 1, 3, 3],

strides=[1, 1],

padding="VALID",

expected=expected_output)

@test_util.run_in_graph_and_eager_modes()

def testConv2D2x2Filter(self):

# The outputs are computed using third_party/py/IPython/notebook.

expected_output = [2271.0, 2367.0, 2463.0, 2901.0, 3033.0, 3165.0]

self._VerifyValues(

tensor_in_sizes=[1, 2, 3, 3],

filter_in_sizes=[2, 2, 3, 3],

strides=[1, 1],

padding="VALID",

expected=expected_output)

@test_util.run_in_graph_and_eager_modes()

def testConv2D1x2Filter(self):

# The outputs are computed using third_party/py/IPython/notebook.

expected_output = [

231.0, 252.0, 273.0, 384.0, 423.0, 462.0, 690.0, 765.0, 840.0, 843.0,

936.0, 1029.0

]

self._VerifyValues(

tensor_in_sizes=[1, 2, 3, 3],

filter_in_sizes=[1, 2, 3, 3],

strides=[1, 1],

padding="VALID",

expected=expected_output)

@test_util.run_in_graph_and_eager_modes()

def testConv2D2x2FilterStride2(self):

expected_output = [2271.0, 2367.0, 2463.0]

self._VerifyValues(

tensor_in_sizes=[1, 2, 3, 3],

filter_in_sizes=[2, 2, 3, 3],

strides=[2, 2],

padding="VALID",

expected=expected_output)

@test_util.run_in_graph_and_eager_modes()

def testConv2D2x2FilterStride2Same(self):

expected_output = [2271.0, 2367.0, 2463.0, 1230.0, 1305.0, 1380.0]

self._VerifyValues(

tensor_in_sizes=[1, 2, 3, 3],

filter_in_sizes=[2, 2, 3, 3],

strides=[2, 2],

padding="SAME",

expected=expected_output)

@test_util.run_in_graph_and_eager_modes()

def testConv2D2x2FilterStride1x2(self):

expected_output = [58.0, 78.0, 98.0, 118.0, 138.0, 158.0]

self._VerifyValues(

tensor_in_sizes=[1, 3, 6, 1],

filter_in_sizes=[2, 2, 1, 1],

strides=[1, 2],

padding="VALID",

expected=expected_output)

@test_util.run_in_graph_and_eager_modes()

def testConv2DKernelSmallerThanStrideValid(self):

expected_output = [65, 95, 275, 305]

self._VerifyValues(

tensor_in_sizes=[1, 7, 7, 1],

filter_in_sizes=[2, 2, 1, 1],

strides=[3, 3],

padding="VALID",

expected=expected_output)

@test_util.run_in_graph_and_eager_modes()

def testConv2DKernelSmallerThanStrideSame(self):

self._VerifyValues(

tensor_in_sizes=[1, 3, 3, 1],

filter_in_sizes=[1, 1, 1, 1],

strides=[2, 2],

padding="SAME",

expected=[1, 3, 7, 9])

self._VerifyValues(

tensor_in_sizes=[1, 4, 4, 1],

filter_in_sizes=[1, 1, 1, 1],

strides=[2, 2],

padding="SAME",

expected=[1, 3, 9, 11])

self._VerifyValues(

tensor_in_sizes=[1, 4, 4, 1],

filter_in_sizes=[2, 2, 1, 1],

strides=[3, 3],

padding="SAME",

expected=[44, 28, 41, 16])

@test_util.run_in_graph_and_eager_modes()

def testConv2DKernelSizeMatchesInputSize(self):

self._VerifyValues(

tensor_in_sizes=[1, 2, 2, 1],

filter_in_sizes=[2, 2, 1, 2],

strides=[1, 1],

padding="VALID",

expected=[50, 60])

# TODO this currently fails.

# self._VerifyValues(tensor_in_sizes=[1, 8, 8, 1],

# filter_in_sizes=[2, 2, 1, 1],

# strides=[4, 4], padding="SAME",

# expected=[72, 112, 392, 432])

# Testing for backprops

def _RunAndVerifyBackpropInput(self, input_sizes, filter_sizes, output_sizes,

strides, padding, expected, data_format,

use_gpu, err):

total_output_size = 1

total_filter_size = 1

for s in output_sizes:

total_output_size *= s

for s in filter_sizes:

total_filter_size *= s

# Initializes the input tensor with array containing incrementing

# numbers from 1.

x1 = [f * 1.0 for f in range(1, total_filter_size + 1)]

x2 = [f * 1.0 for f in range(1, total_output_size + 1)]

with test_util.device(use_gpu):

if data_format == "NCHW":

input_sizes = test_util.NHWCToNCHW(input_sizes)

t0 = constant_op.constant(input_sizes, shape=[len(input_sizes)])

t1 = constant_op.constant(x1, shape=filter_sizes)

t2 = constant_op.constant(x2, shape=output_sizes)

strides = [1] + strides + [1]

if data_format == "NCHW":

t2 = test_util.NHWCToNCHW(t2)

strides = test_util.NHWCToNCHW(strides)

conv = nn_ops.conv2d_backprop_input(

t0, t1, t2, strides=strides, padding=padding, data_format=data_format)

if data_format == "NCHW":

conv = test_util.NCHWToNHWC(conv)

# "values" consists of two tensors for two backprops

value = self.evaluate(conv)

self.assertShapeEqual(value, conv)

print("expected = ", expected)

print("actual = ", value)

self.assertArrayNear(expected, value.flatten(), err)

def _CompareBackpropInput(self, input_sizes, filter_sizes, output_sizes,

conv_strides, padding):

x1 = np.random.rand(*filter_sizes).astype(np.float32)

x2 = np.random.rand(*output_sizes).astype(np.float32)

def _GetVal(data_format, use_gpu):

with test_util.device(use_gpu):

if data_format == "NCHW":

new_input_sizes = test_util.NHWCToNCHW(input_sizes)

else:

new_input_sizes = input_sizes

t0 = constant_op.constant(new_input_sizes, shape=[len(new_input_sizes)])

t1 = constant_op.constant(x1, shape=filter_sizes)

t2 = constant_op.constant(x2, shape=output_sizes)

strides = [1] + conv_strides + [1]

if data_format == "NCHW":

t2 = test_util.NHWCToNCHW(t2)

strides = test_util.NHWCToNCHW(strides)

conv = nn_ops.conv2d_backprop_input(

t0,

t1,

t2,

strides=strides,

padding=padding,

data_format=data_format)

if data_format == "NCHW":

conv = test_util.NCHWToNHWC(conv)

ret = self.evaluate(conv)

self.assertShapeEqual(ret, conv)

return ret

values = []

for (data_format, use_gpu) in GetTestConfigs():

values.append(_GetVal(data_format, use_gpu))

for i in range(1, len(values)):

self.assertAllClose(values[0], values[i], rtol=1e-4, atol=1e-4)

@test_util.run_in_graph_and_eager_modes()

def testConv2D2x2Depth1ValidBackpropInput(self):

expected_output = [1.0, 4.0, 4.0, 3.0, 10.0, 8.0]

for (data_format, use_gpu) in GetTestConfigs():

self._RunAndVerifyBackpropInput(

input_sizes=[1, 2, 3, 1],

filter_sizes=[2, 2, 1, 1],

output_sizes=[1, 1, 2, 1],

strides=[1, 1],

padding="VALID",

expected=expected_output,

data_format=data_format,

use_gpu=use_gpu,

err=1e-5)

@test_util.run_in_graph_and_eager_modes()

def testConv2D2x2Depth3ValidBackpropInput(self):

expected_output = [

14.0, 32.0, 50.0, 100.0, 163.0, 226.0, 167.0, 212.0, 257.0, 122.0,

140.0, 158.0, 478.0, 541.0, 604.0, 437.0, 482.0, 527.0

]

for (data_format, use_gpu) in GetTestConfigs():

# The GPU version of this test is not very stable. So adjusting the

# error threshold to 1e-4.

self._RunAndVerifyBackpropInput(

input_sizes=[1, 2, 3, 3],

filter_sizes=[2, 2, 3, 3],

output_sizes=[1, 1, 2, 3],

strides=[1, 1],

padding="VALID",

expected=expected_output,

data_format=data_format,

use_gpu=use_gpu,

err=1e-4)

@test_util.run_in_graph_and_eager_modes()

def testConv2D2x2Depth3ValidBackpropInputStride1x2(self):

expected_output = [

1.0, 2.0, 2.0, 4.0, 3.0, 6.0, 7.0, 12.0, 11.0, 18.0, 15.0, 24.0, 12.0,

16.0, 15.0, 20.0, 18.0, 24.0

]

for (data_format, use_gpu) in GetTestConfigs():

self._RunAndVerifyBackpropInput(

input_sizes=[1, 3, 6, 1],

filter_sizes=[2, 2, 1, 1],

output_sizes=[1, 2, 3, 1],

strides=[1, 2],

padding="VALID",

expected=expected_output,

data_format=data_format,

use_gpu=use_gpu,

err=1e-5)

@test_util.run_in_graph_and_eager_modes()

def testConv2DStrideTwoFilterOneSameBackpropInput(self):

expected_output = [

1.0, 0.0, 2.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3.0, 0.0, 4.0, 0.0, 0.0, 0.0,

0.0, 0.0

]

for (data_format, use_gpu) in GetTestConfigs():

self._RunAndVerifyBackpropInput(

input_sizes=[1, 4, 4, 1],

filter_sizes=[1, 1, 1, 1],

output_sizes=[1, 2, 2, 1],

strides=[2, 2],

padding="SAME",

expected=expected_output,

data_format=data_format,

use_gpu=use_gpu,

err=1e-5)

@test_util.run_in_graph_and_eager_modes()

def testConv2DKernelSizeMatchesInputSizeBackpropInput(self):

expected_output = [5.0, 11.0, 17.0, 23.0]

for (data_format, use_gpu) in GetTestConfigs():

self._RunAndVerifyBackpropInput(

input_sizes=[1, 2, 2, 1],

filter_sizes=[2, 2, 1, 2],

output_sizes=[1, 1, 1, 2],

strides=[1, 1],

padding="VALID",

expected=expected_output,

data_format=data_format,

use_gpu=use_gpu,

err=1e-5)

# Testing for backprops

def _RunAndVerifyBackpropFilter(self, input_sizes, filter_sizes, output_sizes,

strides, padding, expected, data_format,

use_gpu):

total_input_size = 1

total_output_size = 1

for s in input_sizes:

total_input_size *= s

for s in output_sizes:

total_output_size *= s

# Initializes the input tensor with array containing incrementing

# numbers from 1.

x0 = [f * 1.0 for f in range(1, total_input_size + 1)]

x2 = [f * 1.0 for f in range(1, total_output_size + 1)]

for dtype in self._DtypesToTest(use_gpu=use_gpu):

with test_util.device(use_gpu):

t0 = constant_op.constant(x0, shape=input_sizes, dtype=dtype)

t1 = constant_op.constant(filter_sizes, shape=[len(filter_sizes)])

t2 = constant_op.constant(x2, shape=output_sizes, dtype=dtype)

explicit_strides = [1] + strides + [1]

if data_format == "NCHW":

t0 = test_util.NHWCToNCHW(t0)

t2 = test_util.NHWCToNCHW(t2)

explicit_strides = test_util.NHWCToNCHW(explicit_strides)

conv = nn_ops.conv2d_backprop_filter(

t0,

t1,

t2,

strides=explicit_strides,

padding=padding,

data_format=data_format)

value = self.evaluate(conv)

self.assertShapeEqual(value, conv)

print("expected = ", expected)

print("actual = ", value)

self.assertArrayNear(expected, value.flatten(), 1e-5)

def _CompareBackFilter(self, input_sizes, filter_sizes, output_sizes,

conv_strides, padding):

x0 = np.random.rand(*input_sizes).astype(np.float32)

x2 = np.random.rand(*output_sizes).astype(np.float32)

def _GetVal(data_format, use_gpu):

with test_util.device(use_gpu):

t0 = constant_op.constant(x0, shape=input_sizes)

t1 = constant_op.constant(filter_sizes, shape=[len(filter_sizes)])

t2 = constant_op.constant(x2, shape=output_sizes)

strides = [1] + conv_strides + [1]

if data_format == "NCHW":

t0 = test_util.NHWCToNCHW(t0)

t2 = test_util.NHWCToNCHW(t2)

strides = test_util.NHWCToNCHW(strides)

conv = nn_ops.conv2d_backprop_filter(

t0,

t1,

t2,

strides=strides,

padding=padding,

data_format=data_format)

ret = self.evaluate(conv)

self.assertShapeEqual(ret, conv)

return ret

values = []

for (data_format, use_gpu) in GetTestConfigs():

values.append(_GetVal(data_format, use_gpu))

for i in range(1, len(values)):

self.assertAllClose(values[0], values[i], rtol=1e-4, atol=1e-4)

@test_util.run_in_graph_and_eager_modes()

def testConv2D2x2Depth1ValidBackpropFilter(self):

expected = [5.0, 8.0, 14.0, 17.0]

for (data_format, use_gpu) in GetTestConfigs():

self._RunAndVerifyBackpropFilter(

input_sizes=[1, 2, 3, 1],

filter_sizes=[2, 2, 1, 1],

output_sizes=[1, 1, 2, 1],

strides=[1, 1],

padding="VALID",

expected=expected,

data_format=data_format,

use_gpu=use_gpu)

@test_util.run_in_graph_and_eager_modes()

def testConv2D2x2Depth3ValidBackpropFilter(self):

expected = [

17.0, 22.0, 27.0, 22.0, 29.0, 36.0, 27.0, 36.0, 45.0, 32.0, 43.0, 54.0,

37.0, 50.0, 63.0, 42.0, 57.0, 72.0, 62.0, 85.0, 108.0, 67.0, 92.0,

117.0, 72.0, 99.0, 126.0, 77.0, 106.0, 135.0, 82.0, 113.0, 144.0, 87.0,

120.0, 153.0

]

for (data_format, use_gpu) in GetTestConfigs():

self._RunAndVerifyBackpropFilter(

input_sizes=[1, 2, 3, 3],

filter_sizes=[2, 2, 3, 3],

output_sizes=[1, 1, 2, 3],

strides=[1, 1],

padding="VALID",

expected=expected,

data_format=data_format,

use_gpu=use_gpu)

@test_util.run_in_graph_and_eager_modes()

def testConv2D2x2Depth3ValidBackpropFilterStride1x2(self):

expected = [161.0, 182.0, 287.0, 308.0]

for (data_format, use_gpu) in GetTestConfigs():

self._RunAndVerifyBackpropFilter(

input_sizes=[1, 3, 6, 1],

filter_sizes=[2, 2, 1, 1],

output_sizes=[1, 2, 3, 1],

strides=[1, 2],

padding="VALID",

expected=expected,

data_format=data_format,

use_gpu=use_gpu)

@test_util.run_in_graph_and_eager_modes()

def testConv2DStrideTwoFilterOneSameBackpropFilter(self):

expected_output = [78.]

for (data_format, use_gpu) in GetTestConfigs():

self._RunAndVerifyBackpropFilter(

input_sizes=[1, 4, 4, 1],

filter_sizes=[1, 1, 1, 1],

output_sizes=[1, 2, 2, 1],

strides=[2, 2],

padding="SAME",

expected=expected_output,

data_format=data_format,

use_gpu=use_gpu)

@test_util.run_in_graph_and_eager_modes()

def testConv2DKernelSizeMatchesInputSizeBackpropFilter(self):

expected_output = [1.0, 2.0, 2.0, 4.0, 3.0, 6.0, 4.0, 8.0]

for (data_format, use_gpu) in GetTestConfigs():

self._RunAndVerifyBackpropFilter(

input_sizes=[1, 2, 2, 1],

filter_sizes=[2, 2, 1, 2],

output_sizes=[1, 1, 1, 2],

strides=[1, 1],

padding="VALID",

expected=expected_output,

data_format=data_format,

use_gpu=use_gpu)

# Gradient checkers

def ConstructAndTestGradient(self, batch, input_rows, input_cols, filter_rows,

filter_cols, in_depth, out_depth, stride_rows,

stride_cols, padding, test_input, data_format,

use_gpu):

input_shape = [batch, input_rows, input_cols, in_depth]

filter_shape = [filter_rows, filter_cols, in_depth, out_depth]

# TODO(yangke): re-factor the computation of output shape.

if padding == "VALID":

output_rows = (input_rows - filter_rows + stride_rows) // stride_rows

output_cols = (input_cols - filter_cols + stride_cols) // stride_cols

else:

output_rows = (input_rows + stride_rows - 1) // stride_rows

output_cols = (input_cols + stride_cols - 1) // stride_cols

output_shape = [batch, output_rows, output_cols, out_depth]

input_size = 1

for x in input_shape:

input_size *= x

filter_size = 1

for x in filter_shape:

filter_size *= x

input_data = [x * 1.0 / input_size for x in range(0, input_size)]

filter_data = [x * 1.0 / filter_size for x in range(0, filter_size)]

# Conv2DGrad functions are not compiled for double due to

# a problem in the way Eigen's Conv2DGrad works for double.

# So we disable the DOUBLE path. We should re-enable this

# when double support returns for CPU and/or GPU.

for dtype in self._DtypesToTest(use_gpu=use_gpu):

with self.test_session(use_gpu=use_gpu):

input_tensor = constant_op.constant(

input_data, shape=input_shape, dtype=dtype, name="input")

filter_tensor = constant_op.constant(

filter_data, shape=filter_shape, dtype=dtype, name="filter")

strides = [1, stride_rows, stride_cols, 1]

if data_format == "NCHW":

new_input_tensor = test_util.NHWCToNCHW(input_tensor)

strides = test_util.NHWCToNCHW(strides)

else:

new_input_tensor = input_tensor

conv = nn_ops.conv2d(

new_input_tensor,

filter_tensor,

strides,

padding,

data_format=data_format,

name="conv")

if data_format == "NCHW":

conv = test_util.NCHWToNHWC(conv)

self.assertEqual(output_shape, conv.get_shape())

if test_input:

jacob_t, jacob_n = gradient_checker.compute_gradient(input_tensor,

input_shape,

conv,

output_shape)

else:

jacob_t, jacob_n = gradient_checker.compute_gradient(filter_tensor,

filter_shape,

conv,

output_shape)

if dtype == dtypes.float32:

reference_jacob_t = jacob_t

err = np.fabs(jacob_t - jacob_n).max()

else:

# Compare fp16 theoretical gradients to fp32 theoretical gradients,

# since fp16 numerical gradients are too imprecise.

err = np.fabs(jacob_t - reference_jacob_t).max()

print("conv_2d gradient error = ", err)

self.assertLess(err, 0.002)

def testInputGradientValidPaddingStrideOne(self):

for (data_format, use_gpu) in GetTestConfigs():

self.ConstructAndTestGradient(

batch=2,

input_rows=5,

input_cols=4,

filter_rows=3,

filter_cols=3,

in_depth=2,

out_depth=3,

stride_rows=1,

stride_cols=1,

padding="VALID",

test_input=True,

data_format=data_format,

use_gpu=use_gpu)

def testFilterGradientValidPaddingStrideOne(self):

for (data_format, use_gpu) in GetTestConfigs():

self.ConstructAndTestGradient(

batch=4,

input_rows=6,

input_cols=5,

filter_rows=2,

filter_cols=2,

in_depth=2,

out_depth=3,

stride_rows=1,

stride_cols=1,

padding="VALID",

test_input=False,

data_format=data_format,

use_gpu=use_gpu)

def testInputGradientValidPaddingStrideTwo(self):

for (data_format, use_gpu) in GetTestConfigs():

self.ConstructAndTestGradient(

batch=2,

input_rows=4,

input_cols=5,

filter_rows=3,

filter_cols=3,

in_depth=2,

out_depth=3,

stride_rows=2,

stride_cols=2,

padding="VALID",

test_input=True,

data_format=data_format,

use_gpu=use_gpu)

def testFilterGradientValidPaddingStrideTwo(self):

for (data_format, use_gpu) in GetTestConfigs():

self.ConstructAndTestGradient(

batch=4,

input_rows=6,

input_cols=5,

filter_rows=2,

filter_cols=2,

in_depth=2,

out_depth=3,

stride_rows=2,

stride_cols=2,

padding="VALID",

test_input=False,

data_format=data_format,

use_gpu=use_gpu)

def testInputGradientValidPaddingStrideThree(self):

for (data_format, use_gpu) in GetTestConfigs():

self.ConstructAndTestGradient(

batch=2,

input_rows=7,

input_cols=6,

filter_rows=3,

filter_cols=3,

in_depth=4,

out_depth=5,

stride_rows=3,

stride_cols=3,

padding="VALID",

test_input=True,

data_format=data_format,

use_gpu=use_gpu)

def testFilterGradientValidPaddingStrideThree(self):

for (data_format, use_gpu) in GetTestConfigs():

self.ConstructAndTestGradient(

batch=2,

input_rows=8,

input_cols=7,

filter_rows=4,

filter_cols=4,

in_depth=2,

out_depth=3,

stride_rows=3,

stride_cols=3,

padding="VALID",

test_input=False,

data_format=data_format,

use_gpu=use_gpu)

def testInputGradientSamePaddingStrideOne(self):

for (data_format, use_gpu) in GetTestConfigs():

self.ConstructAndTestGradient(

batch=2,

input_rows=7,

input_cols=6,

filter_rows=3,

filter_cols=3,

in_depth=2,

out_depth=3,

stride_rows=1,

stride_cols=1,

padding="SAME",

test_input=True,

data_format=data_format,

use_gpu=use_gpu)

def testFilterGradientSamePaddingStrideOne(self):

for (data_format, use_gpu) in GetTestConfigs():

self.ConstructAndTestGradient(

batch=4,

input_rows=6,

input_cols=5,

filter_rows=2,

filter_cols=2,

in_depth=2,

out_depth=3,

stride_rows=1,

stride_cols=1,

padding="SAME",

test_input=False,

data_format=data_format,

use_gpu=use_gpu)

def testInputGradientSamePaddingStrideTwo(self):

for (data_format, use_gpu) in GetTestConfigs():

self.ConstructAndTestGradient(

batch=2,

input_rows=5,

input_cols=4,

filter_rows=3,

filter_cols=3,

in_depth=3,

out_depth=3,

stride_rows=2,

stride_cols=2,

padding="SAME",

test_input=True,

data_format=data_format,

use_gpu=use_gpu)

def testFilterGradientSamePaddingStrideTwo(self):

for (data_format, use_gpu) in GetTestConfigs():

self.ConstructAndTestGradient(

batch=4,

input_rows=6,

input_cols=5,

filter_rows=2,

filter_cols=2,

in_depth=2,

out_depth=3,

stride_rows=2,

stride_cols=2,

padding="SAME",

test_input=False,

data_format=data_format,

use_gpu=use_gpu)

def testInputGradientSamePaddingStrideThree(self):

for (data_format, use_gpu) in GetTestConfigs():

self.ConstructAndTestGradient(

batch=2,

input_rows=7,

input_cols=6,

filter_rows=3,

filter_cols=3,

in_depth=4,

out_depth=5,

stride_rows=3,

stride_cols=3,

padding="SAME",

test_input=True,

data_format=data_format,

use_gpu=use_gpu)

def testFilterGradientSamePaddingStrideThree(self):

for (data_format, use_gpu) in GetTestConfigs():

self.ConstructAndTestGradient(

batch=2,

input_rows=8,

input_cols=7,

filter_rows=4,

filter_cols=4,

in_depth=2,

out_depth=3,

stride_rows=3,

stride_cols=3,

padding="SAME",

test_input=False,

data_format=data_format,

use_gpu=use_gpu)

def testFilterGradientSamePaddingStride2x1(self):

for (data_format, use_gpu) in GetTestConfigs():

self.ConstructAndTestGradient(

batch=2,

input_rows=8,

input_cols=7,

filter_rows=4,

filter_cols=4,

in_depth=2,

out_depth=3,

stride_rows=2,

stride_cols=1,

padding="SAME",

test_input=False,

data_format=data_format,

use_gpu=use_gpu)

def testInputGradientKernelSizeMatchesInputSize(self):

for (data_format, use_gpu) in GetTestConfigs():

self.ConstructAndTestGradient(

batch=2,

input_rows=4,

input_cols=3,

filter_rows=4,

filter_cols=3,

in_depth=2,

out_depth=3,

stride_rows=1,

stride_cols=1,