def test_nchw(self, padding):
self.ksize = [1, 1, 3, 1]
np_nchw = self.grad_input_nchw[padding]
if padding == "VALID":
grad_input = tf.placeholder(tf.float32, shape=(128, 3, 74, 224))
elif padding == "SAME":
grad_input = tf.placeholder(tf.float32, shape=(128, 3, 75, 224))
out_ngtf = avg_pool_grad(self.forward_arg_shape_NCHW,
grad_input,
self.ksize,
self.strides,
padding=padding,
data_format="NCHW")
# To validate on the CPU side we will need to run in NHWC, because the CPU
# implementation of avgpool backprop does not support NCHW. We will
# transpose on the way in and on the way out
grad_input_transposed = tf.transpose(grad_input, [0, 2, 3, 1])
self.ksize = [1, 3, 1, 1]
self.strides = [1, 3, 1, 2]
b = avg_pool_grad(self.forward_arg_shape_NHWC,
grad_input_transposed,
self.ksize,
self.strides,
padding=padding,
data_format="NHWC")
out_tf = tf.transpose(b, [0, 3, 1, 2])
assert np.isclose(
self.with_ngraph(lambda sess: sess.run(
out_ngtf,
feed_dict={grad_input: self.grad_input_nchw[padding]})),
self.without_ngraph(lambda sess: sess.run(
out_tf, feed_dict={grad_input: self.grad_input_nchw[padding]}))
).all()
def _AvgPoolGrad(op, grad):
return gen_nn_ops.avg_pool_grad(array_ops.shape(op.inputs[0]),
grad,
op.get_attr("ksize"),
op.get_attr("strides"),
op.get_attr("padding"),
data_format=op.get_attr("data_format"))
def dfa_backward(self, AI, AO, E, DO):
grad = gen_nn_ops.avg_pool_grad(orig_input_shape=self.size,
grad=DO,
ksize=self.ksize,
strides=self.strides,
padding=self.padding)
return grad
def backward(self, AI, AO, DO, cache):
DI = gen_nn_ops.avg_pool_grad(orig_input_shape=self.size,
grad=DO,
ksize=self.ksize,
strides=self.strides,
padding=self.padding)
return {'dout': DI, 'cache': {}}
def relprop_pool(self, x, r, ksize=(1, 2, 2, 1), strides=(1, 2, 2, 1), padding='SAME'):
"""Implements relevance propagation through pooling layers.
Args:
x: array of activations
r: array of relevance scores
ksize: pooling kernel dimensions used during forward path
strides: step size of pooling kernel used during forward path
padding: parameter for SAME or VALID padding
Returns:
array of relevance scores of same dimensions as a
"""
if self.pooling_type == "avg":
z = tf.nn.avg_pool(x, ksize, strides, padding) + self.epsilon
s = r / z
c = gen_nn_ops.avg_pool_grad(tf.shape(x), s, ksize, strides, padding)
elif self.pooling_type == "max":
z = tf.nn.max_pool(x, ksize, strides, padding) + self.epsilon
s = r / z
c = gen_nn_ops.max_pool_grad_v2(x, z, s, ksize, strides, padding)
else:
raise Exception("Error: no such unpooling operation implemented.")
return c * x
def _AvgPoolGrad(op, grad):
return gen_nn_ops.avg_pool_grad(
array_ops.shape(op.inputs[0]),
grad,
op.get_attr("ksize"),
op.get_attr("strides"),
op.get_attr("padding"),
data_format=op.get_attr("data_format"))
def AvgPoolGrad(inputs, outputs, output_gradients, ksize, strides,
padding, data_format):
del outputs # Unused by average-pooling gradients.
return gen_nn_ops.avg_pool_grad(inputs.get_shape().as_list(),
output_gradients,
ksize=ksize,
strides=strides,
padding=padding,
data_format=data_format)
def AvgPoolGrad(inputs, outputs, output_gradients, ksize, strides, padding,
data_format):
del outputs # Unused by average-pooling gradients.
return gen_nn_ops.avg_pool_grad(
inputs.get_shape().as_list(),
output_gradients,
ksize=ksize,
strides=strides,
padding=padding,
data_format=data_format)
def relprop_pool(self, a, r, ksize=(1, 2, 2, 1), strides=(1, 2, 2, 1), padding='SAME', operation='avg'):
if operation == 'avg':
z = tf.nn.avg_pool(a, ksize, strides, padding) + self.epsilon
s = r / z
c = gen_nn_ops.avg_pool_grad(tf.shape(a), s, ksize, strides, padding)
elif operation == 'max':
z = tf.nn.max_pool(a, ksize, strides, padding) + self.epsilon
s = r / z
c = gen_nn_ops.max_pool_grad_v2(a, z, s, ksize, strides, padding)
else:
raise Exception('No such unpooling operation.')
return c * a
def testDirectUseOverlapping(self):
for num_batches in [1, 3]:
for row_window_size in [2, 5]:
for col_window_size in [2, 4]:
num_rows = (row_window_size - 1) * 5 + 1
num_cols = (col_window_size - 1) * 7 + 1
for num_channels in [1, 2]:
input_shape = (num_batches, num_rows, num_cols,
num_channels)
with self.cached_session() as _:
input_tensor = constant_op.constant(
self._GenerateRandomInputTensor(
input_shape).astype(np.float32))
window_size = [
1, row_window_size, col_window_size, 1
]
stride_size = [
1, row_window_size - 1, col_window_size - 1, 1
]
padding = "VALID"
output_tensor = nn_ops.avg_pool(
input_tensor, window_size, stride_size,
padding)
output_data = self.evaluate(output_tensor)
num_elements = 1
for dim_size in output_data.shape:
num_elements *= dim_size
output_backprop = (self._PRNG.rand(num_elements) *
1000).reshape(output_data.shape)
input_backprop_tensor = gen_nn_ops.avg_pool_grad(
input_tensor.get_shape(), output_backprop,
window_size, stride_size, padding)
input_backprop = self.evaluate(
input_backprop_tensor)
row_seq = list(
range(0, num_rows, row_window_size - 1))
col_seq = list(
range(0, num_cols, col_window_size - 1))
row_seq[-1] += 1
col_seq[-1] += 1
fap_input_backprop_tensor = gen_nn_ops.fractional_avg_pool_grad(
input_tensor.get_shape(),
output_backprop,
row_seq,
col_seq,
overlapping=True)
fap_input_backprop = self.evaluate(
fap_input_backprop_tensor)
self.assertShapeEqual(input_backprop,
fap_input_backprop_tensor)
self.assertAllClose(input_backprop,
fap_input_backprop)
def lel_backward(self, AI, AO, E, DO, Y):
shape_AO = tf.shape(AO)[3]
shape_DO = tf.shape(DO)[3]
assert_op = tf.assert_equal(shape_AO, shape_DO)
with tf.control_dependencies([assert_op]):
grad = gen_nn_ops.avg_pool_grad(orig_input_shape=self.size,
grad=DO,
ksize=self.ksize,
strides=self.strides,
padding=self.padding)
# grad = tf.Print(grad, [tf.shape(AI), tf.shape(AO), tf.shape(DO)], message='', summarize=1000)
# grad = tf.Print(grad, ['pool', tf.reduce_sum(DO), tf.reduce_sum(grad)], message='', summarize=1000)
return grad
def custom_grad(op, grad):
if self.data_format == 'NHWC':
ksizes = [1, self.pool_size[0], self.pool_size[1], 1]
strides = [1, self.strides[0], self.strides[1], 1]
else:
ksizes = [1, 1, self.pool_size[0], self.pool_size[1]]
strides = [1, 1, self.strides[0], self.strides[1]]
#return gen_nn_ops.max_pool_grad(
return gen_nn_ops.avg_pool_grad(
array_ops.shape(op.inputs[0]),
grad,
ksizes,
strides,
self.padding,
data_format=self.data_format), K.tf.constant(0.0)
def predict(self, img, cv, lrl):
fts = cv
for i in range(len(encs) - 1):
fts = conv(self, 'enc%d' % i, fts, [1, encs[i + 1], encs[i]], ifbn)
fts = tf.concat([lrl, fts], axis=3)
fts = conv(self, 'cenc', fts, [3, encs[-1], 3 + encs[-1]], ifbn)
for i in range(nfinal - 1):
fts = conv(self, 'cenc%d' % (i + 1), fts, [3, encs[-1], encs[-1]],
ifbn)
fshp = tf.shape(fts)
inp = tf.concat([lrl, fts], axis=3)
ypad = tf.mod(topad - tf.mod(fshp[1], topad), topad)
ypad = [ypad // 2, ypad - ypad // 2]
xpad = tf.mod(topad - tf.mod(fshp[2], topad), topad)
xpad = [xpad // 2, xpad - xpad // 2]
inp = tf.pad(
inp, tf.stack([[0, 0],
tf.stack(ypad),
tf.stack(xpad), [0, 0]]), 'REFLECT')
out = unet(self, inp, numCh, nChInc, nlev, 'u1', encs[-1] + 3)
out = tf.slice(out, tf.stack([0, ypad[0], xpad[0], 0]),
tf.stack([-1, fshp[1], fshp[2], -1]))
out = tf.nn.relu(
conv(self, 'out', out, [1, 1, numCh], 0, False) + 128.0)
shp = tf.shape(img)
out1 = gen_nn_ops.avg_pool_grad(
tf.stack([fshp[0], fshp[1] * 2, fshp[2] * 2, 1]), out,
[1, 2, 2, 1], [1, 2, 2, 1], 'VALID') * 4.0
if upsamp:
out2 = tf.image.resize_bilinear(
out, tf.stack([fshp[1] * 2, fshp[2] * 2]))
out = tf.where(tf.abs(out1 - out2) < 1, out2, out1)
else:
out = out1
out = tf.slice(
out, tf.stack([0, fshp[1] * 2 - shp[1], fshp[2] * 2 - shp[2], 0]),
[-1, -1, -1, -1])
return tf.squeeze(out, axis=-1)
def test_nhwc(self, padding):
np_nhwc = self.grad_input_nhwc[padding]
if padding == "VALID":
grad_input = tf.placeholder(tf.float32, shape=(128, 112, 74, 3))
elif padding == "SAME":
grad_input = tf.placeholder(tf.float32, shape=(128, 112, 75, 3))
out = avg_pool_grad(self.forward_arg_shape_NHWC,
grad_input,
self.ksize,
self.strides,
padding=padding,
data_format="NHWC")
def run_test(sess):
return sess.run(out, feed_dict={grad_input: np_nhwc})
assert np.isclose(self.with_ngraph(run_test),
self.without_ngraph(run_test)).all()
def testDirectUseOverlapping(self):
for num_batches in [1, 3]:
for row_window_size in [2, 5]:
for col_window_size in [2, 4]:
num_rows = (row_window_size - 1) * 5 + 1
num_cols = (col_window_size - 1) * 7 + 1
for num_channels in [1, 2]:
input_shape = (num_batches, num_rows, num_cols, num_channels)
with self.cached_session() as _:
input_tensor = constant_op.constant(
self._GenerateRandomInputTensor(input_shape).astype(
np.float32))
window_size = [1, row_window_size, col_window_size, 1]
stride_size = [1, row_window_size - 1, col_window_size - 1, 1]
padding = "VALID"
output_tensor = nn_ops.avg_pool(input_tensor, window_size,
stride_size, padding)
output_data = self.evaluate(output_tensor)
num_elements = 1
for dim_size in output_data.shape:
num_elements *= dim_size
output_backprop = (self._PRNG.rand(num_elements) *
1000).reshape(output_data.shape)
input_backprop_tensor = gen_nn_ops.avg_pool_grad(
input_tensor.get_shape(), output_backprop, window_size,
stride_size, padding)
input_backprop = self.evaluate(input_backprop_tensor)
row_seq = list(range(0, num_rows, row_window_size - 1))
col_seq = list(range(0, num_cols, col_window_size - 1))
row_seq[-1] += 1
col_seq[-1] += 1
fap_input_backprop_tensor = gen_nn_ops.fractional_avg_pool_grad(
input_tensor.get_shape(),
output_backprop,
row_seq,
col_seq,
overlapping=True)
fap_input_backprop = self.evaluate(fap_input_backprop_tensor)
self.assertShapeEqual(input_backprop, fap_input_backprop_tensor)
self.assertAllClose(input_backprop, fap_input_backprop)
conv3 = conv_op(pool2, w3) pool3 = tf.nn.avg_pool(conv3, ksize=[1,2,2,1], strides=[1,2,2,1], padding='SAME') flat = tf.reshape(pool3, [batch_size, 4*4*2*f3]) fc1 = tf.matmul(flat, w4) loss = tf.nn.softmax_cross_entropy_with_logits_v2(labels=y, logits=fc1) [grad] = tf.gradients(loss, [conv1]) #################################### do = tf.nn.softmax(fc1) - y dfc1 = tf.matmul(do, tf.transpose(w4)) dflat = tf.reshape(dfc1, [1, 4, 4, 256]) dpool3 = gen_nn_ops.avg_pool_grad(orig_input_shape=[1,8,8,256], grad=dflat, ksize=[1,2,2,1], strides=[1,2,2,1], padding='SAME') dact3 = dpool3 * tf.cast(tf.abs(conv3) > 0.0, dtype=tf.float32) dconv3 = tf.nn.conv2d_backprop_input(input_sizes=[1,8,8,192], filter=tf.sign(tf.concat([w3[0], -1.0 * w3[1]], axis=3)), out_backprop=dact3, strides=[1,1,1,1], padding='SAME') dpool2 = gen_nn_ops.avg_pool_grad(orig_input_shape=[1,16,16,192], grad=dconv3, ksize=[1,2,2,1], strides=[1,2,2,1], padding='SAME') dact2 = dpool2 * tf.cast(tf.abs(conv2) > 0.0, dtype=tf.float32) dconv2 = tf.nn.conv2d_backprop_input(input_sizes=[1,16,16,128], filter=tf.sign(tf.concat([w2[0], -1.0 * w2[1]], axis=3)), out_backprop=dact2, strides=[1,1,1,1], padding='SAME') dpool1 = gen_nn_ops.avg_pool_grad(orig_input_shape=[1,32,32,128], grad=dconv2, ksize=[1,2,2,1], strides=[1,2,2,1], padding='SAME') dact1 = dpool1 * tf.cast(tf.abs(conv1) > 0.0, dtype=tf.float32) dconv1 = tf.nn.conv2d_backprop_input(input_sizes=[1,32,32,6], filter=tf.sign(tf.concat([w1[0], -1.0 * w1[1]], axis=3)), out_backprop=dact1, strides=[1,1,1,1], padding='SAME') #################################### sess = tf.InteractiveSession() tf.global_variables_initializer().run()
