def _CompareMaxPoolingBk(self, input_shape, output_shape, ksize, strides,
padding):
# Generate numbers in a narrow range, so that there are many duplicates
# in the input.
tensor_input = np.random.random_integers(0, 3,
input_shape).astype(np.float32)
tensor_output = np.random.rand(*output_shape).astype(np.float32)
with self.test_session(use_gpu=True):
t = tf.constant(tensor_input, shape=input_shape)
_, argmax_op = tf.nn.max_pool_with_argmax(t, ksize, strides, padding)
argmax = argmax_op.eval()
grad_in = tf.constant(tensor_output, shape=output_shape)
out_op = gen_nn_ops._max_pool_grad_with_argmax(t, grad_in, argmax,
ksize, strides, padding)
gpu_val = out_op.eval()
self.assertShapeEqual(gpu_val, out_op)
with self.test_session(use_gpu=False):
t = tf.constant(tensor_input, shape=input_shape)
out_op = tf.nn.max_pool(t, ksize, strides, padding)
orig_out = out_op.eval()
grad_in = tf.constant(tensor_output, shape=output_shape)
out_op = gen_nn_ops._max_pool_grad(t, orig_out, grad_in, ksize,
strides, padding)
cpu_val = out_op.eval()
self.assertShapeEqual(cpu_val, out_op)
self.assertAllClose(cpu_val, gpu_val, rtol=1e-5, atol=1e-5)
def _MaxPoolGrad(op, grad):
return gen_nn_ops._max_pool_grad(op.inputs[0], op.outputs[0], grad,
op.get_attr("ksize"),
op.get_attr("strides"),
padding=op.get_attr("padding"),
data_format=op.get_attr("data_format")
)
def _CompareMaxPoolingBk(self, input_shape, output_shape, ksize, strides,
padding):
for dtype in np.float32, np.float16:
# Generate numbers in a narrow range, so that there are many duplicates
# in the input.
tensor_input = np.random.random_integers(0, 3, input_shape).astype(dtype)
tensor_output = np.random.rand(*output_shape).astype(dtype)
with self.test_session(use_gpu=True):
t = constant_op.constant(tensor_input, shape=input_shape)
_, argmax_op = nn_ops.max_pool_with_argmax(t, ksize, strides, padding)
argmax = argmax_op.eval()
grad_in = constant_op.constant(tensor_output, shape=output_shape)
out_op = gen_nn_ops._max_pool_grad_with_argmax(t, grad_in, argmax,
ksize, strides, padding)
gpu_val = out_op.eval()
self.assertShapeEqual(gpu_val, out_op)
with self.test_session(use_gpu=False):
t = constant_op.constant(tensor_input, shape=input_shape)
out_op = nn_ops.max_pool(t, ksize, strides, padding)
orig_out = out_op.eval()
grad_in = constant_op.constant(tensor_output, shape=output_shape)
out_op = gen_nn_ops._max_pool_grad(t, orig_out, grad_in, ksize, strides,
padding)
cpu_val = out_op.eval()
self.assertShapeEqual(cpu_val, out_op)
if dtype == np.float16:
# The CPU version accumulates its gradient on fp16, so it's less
# accurate than the GPU version that does the accumulation on fp32
self.assertAllClose(cpu_val, gpu_val, rtol=0.01, atol=0.01)
else:
self.assertAllClose(cpu_val, gpu_val)
def _MaxPoolGradGrad(op, grad):
gradient = gen_nn_ops._max_pool_grad(op.inputs[0], op.outputs[0],
grad, op.get_attr("ksize"), op.get_attr("strides"),
padding=op.get_attr("padding"), data_format=op.get_attr("data_format"))
gradgrad1 = array_ops.zeros(shape = array_ops.shape(op.inputs[1]), dtype=gradient.dtype)
gradgrad2 = array_ops.zeros(shape = array_ops.shape(op.inputs[2]), dtype=gradient.dtype)
return (gradient, gradgrad1, gradgrad2)
def _MaxPoolGrad(op, grad):
return gen_nn_ops._max_pool_grad(op.inputs[0],
op.outputs[0],
grad,
op.get_attr("ksize"),
op.get_attr("strides"),
padding=op.get_attr("padding"),
data_format=op.get_attr("data_format"))
def _MaxPoolWithArgmaxGrad(op, grad, arg):
return gen_nn_ops._max_pool_grad(op.inputs[0],
op.outputs[0],
grad,
op.get_attr("ksize"),
op.get_attr("strides"),
padding=op.get_attr("padding"),
data_format='NHWC')
def _MaxPoolWithArgmaxGrad(op, grad, unused_argmax_grad):
return gen_nn_ops._max_pool_grad(op.inputs[0],
op.outputs[0],
grad,
op.get_attr("ksize"),
op.get_attr("strides"),
padding=op.get_attr("padding"),
data_format='NHWC')
def max_unpool(pool, pooled, ksize, strides):
#最大反池化
unpool = gen_nn_ops._max_pool_grad(
pool, #池化前的tensor，即max pool的输入
pooled, #池化后的tensor，即max pool 的输出
pooled, #需要进行反池化操作的tensor，可以是任意shape和pool1一样的tensor
ksize=ksize,
strides=strides,
padding='SAME')
return unpool
def max_unpool(indata, origin_pooled,name):
with tf.name_scope(name):
op = origin_pooled.op
return gen_nn_ops._max_pool_grad(
op.inputs[0],
op.outputs[0],
indata,
op.get_attr("ksize"),
op.get_attr("strides"),
padding=op.get_attr("padding"),
data_format=op.get_attr("data_format"))
def backprop_pool(self, activation, relevance, ksize, strides, pooling_type, padding='SAME'):
if pooling_type.lower() in 'avg':
z = nn_ops.avg_pool(activation, ksize, strides, padding) + 1e-10
s = relevance / z
c = gen_nn_ops._avg_pool_grad(tf.shape(activation), s, ksize, strides, padding)
return activation * c
else:
z = nn_ops.max_pool(activation, ksize, strides, padding) + 1e-10
s = relevance / z
c = gen_nn_ops._max_pool_grad(activation, z, s, ksize, strides, padding)
return activation * c
def _MaxPoolGradGradGrad(op, grad):
return (array_ops.zeros(shape=array_ops.shape(op.inputs[0]),
dtype=op.inputs[0].dtype),
array_ops.zeros(shape=array_ops.shape(op.inputs[1]),
dtype=op.inputs[1].dtype),
gen_nn_ops._max_pool_grad(op.inputs[0],
op.inputs[1],
grad,
op.get_attr("ksize"),
op.get_attr("strides"),
padding=op.get_attr("padding"),
data_format=op.get_attr("data_format")))
def _MaxPoolGradGradGrad(op, grad):
return (array_ops.zeros(shape=array_ops.shape(op.inputs[0]),
dtype=op.inputs[0].dtype),
array_ops.zeros(shape=array_ops.shape(op.inputs[1]),
dtype=op.inputs[1].dtype),
gen_nn_ops._max_pool_grad(op.inputs[0],
op.inputs[1],
grad,
op.get_attr("ksize"),
op.get_attr("strides"),
padding=op.get_attr("padding"),
data_format=op.get_attr("data_format")))
def _MaxPoolGradGrad(op, grad):
ksize = op.get_attr("ksize")
strides = op.get_attr("strides")
padding = op.get_attr("padding")
data_format = op.get_attr("data_format")
grads = []
for i in op.inputs:
igrad = gen_nn_ops._max_pool_grad(i, op.outputs[0], grad, ksize, strides,
padding=padding,data_format=data_format)
grads.append(igrad)
return grads
def deconv(self, top):
"""
_max_pool_grad(orig_input, orig_output, grad, ksize, strides, padding, data_format=None, name=None)
Computes gradients of the maxpooling function.
Args:
orig_input: A `Tensor`. Must be one of the following types: `float32`, `half`.
The original input tensor.
orig_output: A `Tensor`. Must have the same type as `orig_input`.
The original output tensor.
grad: A `Tensor`. Must have the same type as `orig_input`.
4-D. Gradients w.r.t. the output of `max_pool`.
ksize: A list of `ints` that has length `>= 4`.
The size of the window for each dimension of the input tensor.
strides: A list of `ints` that has length `>= 4`.
The stride of the sliding window for each dimension of the
input tensor.
padding: A `string` from: `"SAME", "VALID"`.
The type of padding algorithm to use.
data_format: An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`.
Specify the data format of the input and output data. With the
default format "NHWC", the data is stored in the order of:
[batch, in_height, in_width, in_channels].
Alternatively, the format could be "NCHW", the data storage order of:
[batch, in_channels, in_height, in_width].
name: A name for the operation (optional).
Returns:
A `Tensor`. Has the same type as `orig_input`.
Gradients w.r.t. the input to `max_pool`.
"""
self.pre_unpool = top
unpool = gen_nn_ops._max_pool_grad(orig_input=self.pre_pool,
orig_output=self.aft_pool,
grad=top,
ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1],
padding="SAME")
self.unpool = unpool
# not reverse operation
feat = tf.nn.relu(unpool)
#feat = feat - self.b
feat = tf.nn.conv2d_transpose(feat,
self.w,
self.input_shape, [1, 1, 1, 1],
padding='SAME')
return feat
def _MaxPoolGradGrad(op, grad):
gradient = gen_nn_ops._max_pool_grad(
op.inputs[0],
op.outputs[0],
grad,
op.get_attr("ksize"),
op.get_attr("strides"),
padding=op.get_attr("padding"),
data_format=op.get_attr("data_format"))
gradgrad1 = array_ops.zeros(shape=array_ops.shape(op.inputs[1]),
dtype=gradient.dtype)
gradgrad2 = array_ops.zeros(shape=array_ops.shape(op.inputs[2]),
dtype=gradient.dtype)
return (gradient, gradgrad1, gradgrad2)
def fprop_pool(F, X, strides=None, ksize=None, padding='SAME'):
xshape = X.get_shape().as_list()
fshape = F.get_shape().as_list()
if len(xshape) != len(fshape):
F = tf.reshape(F, (-1, int(np.ceil(
xshape[1] / 2.0)), int(np.ceil(xshape[2] / 2.0)), xshape[3]))
ksize = [1, 2, 2, 1] if ksize is None else ksize
strides = [1, 2, 2, 1] if strides is None else strides
Z = tf.nn.max_pool(X, strides=strides, ksize=ksize, padding=padding) + 1e-9
S = F / Z
C = gen_nn_ops._max_pool_grad(X, Z, S, ksize, strides, padding)
F = X * C
return F
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.test_session() as _:
input_tensor = constant_op.constant(
self._GenerateUniqueRandomInputTensor(
input_shape))
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.max_pool(
input_tensor, window_size, stride_size,
padding)
output_data = output_tensor.eval()
output_backprop = self._PRNG.randint(
100, size=output_data.shape)
input_backprop_tensor = gen_nn_ops._max_pool_grad(
input_tensor, output_tensor, output_backprop,
window_size, stride_size, padding)
input_backprop = input_backprop_tensor.eval()
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
fmp_input_backprop_tensor = gen_nn_ops._fractional_max_pool_grad(
input_tensor,
output_tensor,
output_backprop,
row_seq,
col_seq,
overlapping=True)
fmp_input_backprop = fmp_input_backprop_tensor.eval(
)
self.assertShapeEqual(input_backprop,
fmp_input_backprop_tensor)
self.assertAllClose(input_backprop,
fmp_input_backprop)
def rec(img):
"""
Reconstruct part of the image after simple pooling
Args:
img: input image
"""
with tf.Graph().as_default():
img_op = tf.placeholder(dtype=tf.float32, shape=[1,300,300,3],name='input')
pool_op = tf.nn.max_pool(img_op, ksize=[1,2,2,1], strides=[1,2,2,1],padding='VALID', name='pool')
unpool_op = gen_nn_ops._max_pool_grad(img_op, pool_op, pool_op, [1,2,2,1], [1,2,2,1],'VALID')
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
pool_out, unpool_out = sess.run([pool_op, unpool_op],feed_dict={img_op:img})
cv2.imwrite('img/pool_out.png', pool_out[0,:,:,:])
cv2.imwrite('img/unpool_out.png', unpool_out[0,:,:,:])
def test_max_pool_grad():
ksize = [1, 2, 2, 1]
strides = [1, 2, 2, 1]
padding = 'VALID'
shape = [1, 4, 4, 1]
with tf.Session():
X = tf.constant(np.random.normal(size=shape).astype(np.float32),
name="x")
XS = tf.constant(np.random.normal(size=shape).astype(np.float32),
name="xs")
Z = tf.nn.max_pool(X, strides=strides, ksize=ksize, padding=padding)
S = tf.nn.max_pool(XS, strides=strides, ksize=ksize, padding=padding)
C = gen_nn_ops._max_pool_grad(X, Z, S, ksize, strides, padding)
err = tf.test.compute_gradient_error(X, shape, C, shape)
assert err <= 1e-4
print '-' * 60
print 'Passed maxPoolGradGrad test!'
print '-' * 60
def _MaxPoolGrad(self, orig_input, orig_output, grad, window_rows, window_cols, row_stride, col_stride, padding):
"""Max Pooling Gradient.
Args:
orig_input: A float Tensor. The original input tensor.
orig_output: A float Tensor. The original output tensor.
grad: A float Tensor.
The 4D (batch x rows x cols x depth) output backprop.
window_rows: integer. Kernel size along rows dimension.
window_cols: integer. Kernel size along cols dimension.
row_stride: integer. Stride along rows dimension
col_stride: integer. Stride along cols dimension
padding: PoolingOpDef.Padding. Padding type.
Returns:
A Tensor.
"""
return gen_nn_ops._max_pool_grad(
orig_input, orig_output, grad, [1, window_rows, window_cols, 1], [1, row_stride, col_stride, 1], padding
)
def unpooling(input,
before_pool,
padding,
ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1],
name=None,
data_format="NHWC"):
"""
apply unpooling given the corresponding pooling op
by using the gradient of pooling op
"""
raise PermissionError('not permitted to use: not tested yet')
unpool = gen_nn_ops._max_pool_grad(orig_input=before_pool,
orig_output=input,
grad=input,
ksize=ksize,
strides=strides,
padding=padding,
data_format=data_format,
name=name)
return unpool
def _MaxPoolGrad(self, orig_input, orig_output, grad, window_rows,
window_cols, row_stride, col_stride, padding):
"""Max Pooling Gradient.
Args:
orig_input: A float Tensor. The original input tensor.
orig_output: A float Tensor. The original output tensor.
grad: A float Tensor.
The 4D (batch x rows x cols x depth) output backprop.
window_rows: integer. Kernel size along rows dimension.
window_cols: integer. Kernel size along cols dimension.
row_stride: integer. Stride along rows dimension
col_stride: integer. Stride along cols dimension
padding: PoolingOpDef.Padding. Padding type.
Returns:
A Tensor.
"""
return gen_nn_ops._max_pool_grad(
orig_input, orig_output, grad,
[1, window_rows, window_cols, 1], [1, row_stride, col_stride, 1],
padding)
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.test_session() as _:
input_tensor = constant_op.constant(
self._GenerateUniqueRandomInputTensor(input_shape))
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.max_pool(input_tensor, window_size,
stride_size, padding)
output_data = output_tensor.eval()
output_backprop = self._PRNG.randint(100, size=output_data.shape)
input_backprop_tensor = gen_nn_ops._max_pool_grad(input_tensor,
output_tensor,
output_backprop,
window_size,
stride_size,
padding)
input_backprop = input_backprop_tensor.eval()
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
fmp_input_backprop_tensor = gen_nn_ops._fractional_max_pool_grad(
input_tensor,
output_tensor,
output_backprop,
row_seq,
col_seq,
overlapping=True)
fmp_input_backprop = fmp_input_backprop_tensor.eval()
self.assertShapeEqual(input_backprop, fmp_input_backprop_tensor)
self.assertAllClose(input_backprop, fmp_input_backprop)
def model_unpool(images, idx_map, is_training, reuse=False):
""" Network model
Args:
images: [batch)size, H, W, C]
is_training: True if traning mode (for batchnorm)
"""
if not reuse:
print('inference::input', images.get_shape())
bn = True
grads_dict = {}
with tf.variable_scope('conv1_1', reuse=reuse) as scope: #1
conv1_1 = tf.layers.conv2d(
inputs=images,
filters=64,
kernel_size=(3, 3),
padding="same",
kernel_initializer=tf.contrib.layers.xavier_initializer())
if bn:
conv1_1 = tf.contrib.layers.batch_norm(conv1_1,
fused=True,
decay=0.9,
is_training=is_training)
conv1_1 = tf.nn.relu(conv1_1)
if not reuse:
print('conv1_1', conv1_1.get_shape())
grads_dict['conv1_1'] = tf.gradients(conv1_1, images)
with tf.variable_scope('conv1_2', reuse=reuse) as scope: #2
conv1_2 = tf.layers.conv2d(
inputs=conv1_1,
filters=64,
kernel_size=(3, 3),
padding="same",
kernel_initializer=tf.contrib.layers.xavier_initializer())
if bn:
conv1_2 = tf.contrib.layers.batch_norm(conv1_2,
fused=True,
decay=0.9,
is_training=is_training)
conv1_2 = tf.nn.relu(conv1_2)
pool1 = tf.nn.max_pool(conv1_2,
ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1],
padding='VALID',
name='pool') #pool1
if not reuse:
print('pool1', pool1.get_shape())
grads_dict['conv1_2'] = tf.gradients(conv1_2, images)
grads_dict['pool1'] = tf.gradients(pool1, images)
with tf.variable_scope('conv2_1', reuse=reuse) as scope: #3
conv2_1 = tf.layers.conv2d(
inputs=pool1,
filters=128,
kernel_size=(3, 3),
padding="same",
kernel_initializer=tf.contrib.layers.xavier_initializer())
if bn:
conv2_1 = tf.contrib.layers.batch_norm(conv2_1,
fused=True,
decay=0.9,
is_training=is_training)
conv2_1 = tf.nn.relu(conv2_1)
if not reuse:
print('conv2_1', conv2_1.get_shape())
grads_dict['conv2_1'] = tf.gradients(conv2_1, images)
with tf.variable_scope('conv2_2', reuse=reuse) as scope: #4
conv2_2 = tf.layers.conv2d(
inputs=conv2_1,
filters=128,
kernel_size=(3, 3),
padding="same",
kernel_initializer=tf.contrib.layers.xavier_initializer())
if bn:
conv2_2 = tf.contrib.layers.batch_norm(conv2_2,
fused=True,
decay=0.9,
is_training=is_training)
conv2_2 = tf.nn.relu(conv2_2)
pool2 = tf.nn.max_pool(conv2_2,
ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1],
padding='VALID',
name='pool') #pool2
if not reuse:
print('pool2', pool2.get_shape())
grads_dict['conv2_2'] = tf.gradients(conv2_2, images)
grads_dict['pool2'] = tf.gradients(pool2, images)
with tf.variable_scope('conv3_1', reuse=reuse) as scope: #5
conv3_1 = tf.layers.conv2d(
inputs=pool2,
filters=256,
kernel_size=(3, 3),
padding="same",
kernel_initializer=tf.contrib.layers.xavier_initializer())
if bn:
conv3_1 = tf.contrib.layers.batch_norm(conv3_1,
fused=True,
decay=0.9,
is_training=is_training)
conv3_1 = tf.nn.relu(conv3_1)
if not reuse:
print('conv3_1', conv3_1.get_shape())
grads_dict['conv3_1'] = tf.gradients(conv3_1, images)
with tf.variable_scope('conv3_2', reuse=reuse) as scope: #6
conv3_2 = tf.layers.conv2d(
inputs=conv3_1,
filters=256,
kernel_size=(3, 3),
padding="same",
kernel_initializer=tf.contrib.layers.xavier_initializer())
if bn:
conv3_2 = tf.contrib.layers.batch_norm(conv3_2,
fused=True,
decay=0.9,
is_training=is_training)
conv3_2 = tf.nn.relu(conv3_2)
if not reuse:
print('conv3_2', conv3_2.get_shape())
grads_dict['conv3_2'] = tf.gradients(conv3_2, images)
with tf.variable_scope('conv3_3', reuse=reuse) as scope: #7
conv3_3 = tf.layers.conv2d(
inputs=conv3_2,
filters=256,
kernel_size=(3, 3),
padding="same",
kernel_initializer=tf.contrib.layers.xavier_initializer())
if bn:
conv3_3 = tf.contrib.layers.batch_norm(conv3_3,
fused=True,
decay=0.9,
is_training=is_training)
conv3_3 = tf.nn.relu(conv3_3)
pool3 = tf.nn.max_pool(conv3_3,
ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1],
padding='VALID',
name='pool') #pool3
if not reuse:
print('pool3', pool3.get_shape())
grads_dict['conv3_3'] = tf.gradients(conv3_3, images)
grads_dict['pool3'] = tf.gradients(pool3, images)
with tf.variable_scope('conv4_1', reuse=reuse) as scope: # 8
conv4_1 = tf.layers.conv2d(
inputs=pool3,
filters=512,
kernel_size=(3, 3),
padding="same",
kernel_initializer=tf.contrib.layers.xavier_initializer())
if bn:
conv4_1 = tf.contrib.layers.batch_norm(conv4_1,
fused=True,
decay=0.9,
is_training=is_training)
conv4_1 = tf.nn.relu(conv4_1)
if not reuse:
print('conv4_1', conv4_1.get_shape())
grads_dict['conv4_1'] = tf.gradients(conv4_1, images)
with tf.variable_scope('conv4_2', reuse=reuse) as scope: #9
conv4_2 = tf.layers.conv2d(
inputs=conv4_1,
filters=512,
kernel_size=(3, 3),
padding="same",
kernel_initializer=tf.contrib.layers.xavier_initializer())
if bn:
conv4_2 = tf.contrib.layers.batch_norm(conv4_2,
fused=True,
decay=0.9,
is_training=is_training)
conv4_2 = tf.nn.relu(conv4_2)
if not reuse:
print('conv4_2', conv4_2.get_shape())
grads_dict['conv4_2'] = tf.gradients(conv4_2, images)
with tf.variable_scope('conv4_3', reuse=reuse) as scope: #10
conv4_3 = tf.layers.conv2d(
inputs=conv4_2,
filters=512,
kernel_size=(3, 3),
padding="same",
kernel_initializer=tf.contrib.layers.xavier_initializer())
if bn:
conv4_3 = tf.contrib.layers.batch_norm(conv4_3,
fused=True,
decay=0.9,
is_training=is_training)
conv4_3 = tf.nn.relu(conv4_3)
pool4 = tf.nn.max_pool(conv4_3,
ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1],
padding='VALID',
name='pool') #pool4
if not reuse:
print('pool4', pool4.get_shape())
grads_dict['conv4_3'] = tf.gradients(conv4_3, images)
grads_dict['pool4'] = tf.gradients(pool4, images)
with tf.variable_scope('conv5_1', reuse=reuse) as scope: #11
conv5_1 = tf.layers.conv2d(
inputs=pool4,
filters=512,
kernel_size=(3, 3),
padding="same",
kernel_initializer=tf.contrib.layers.xavier_initializer())
if bn:
conv5_1 = tf.contrib.layers.batch_norm(conv5_1,
fused=True,
decay=0.9,
is_training=is_training)
conv5_1 = tf.nn.relu(conv5_1)
if not reuse:
print('conv5_1', conv5_1.get_shape())
grads_dict['conv5_1'] = tf.gradients(conv5_1, images)
with tf.variable_scope('conv5_2', reuse=reuse) as scope: #12
conv5_2 = tf.layers.conv2d(
inputs=conv5_1,
filters=512,
kernel_size=(3, 3),
padding="same",
kernel_initializer=tf.contrib.layers.xavier_initializer())
if bn:
conv5_2 = tf.contrib.layers.batch_norm(conv5_2,
fused=True,
decay=0.9,
is_training=is_training)
conv5_2 = tf.nn.relu(conv5_2)
if not reuse:
print('conv5_2', conv5_2.get_shape())
grads_dict['conv5_2'] = tf.gradients(conv5_2, images)
with tf.variable_scope('conv5_3', reuse=reuse) as scope: #13
conv5_3 = tf.layers.conv2d(
inputs=conv5_2,
filters=512,
kernel_size=(3, 3),
padding="same",
kernel_initializer=tf.contrib.layers.xavier_initializer())
if bn:
conv5_3 = tf.contrib.layers.batch_norm(conv5_3,
fused=True,
decay=0.9,
is_training=is_training)
conv5_3 = tf.nn.relu(conv5_3)
pool5 = tf.nn.max_pool(conv5_3,
ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1],
padding='VALID',
name='pool') #pool5
if not reuse:
print('pool5', pool5.get_shape())
grads_dict['conv5_3'] = tf.gradients(conv5_3, images)
grads_dict['pool5'] = tf.gradients(pool5, images)
########################################################################################
#with tf.variable_scope('unpool5', reuse=reuse) as scope:#14
# #unpool5 = gen_nn_ops._max_pool_grad(idx_map, pool5, pool5, [1,3,3,1], [1,2,2,1],'VALID')
# unpool5 = gen_nn_ops._max_pool_grad(conv5_3, pool5, pool5, [1,2,2,1], [1,2,2,1],'VALID')
# print('unpool5', unpool5.get_shape())
# #tf.summary.image('unpool5', unpool5)
#
#with tf.variable_scope('unpool4', reuse=reuse) as scope:#17
# unpool4 = gen_nn_ops._max_pool_grad(conv4_3, pool4, unpool5, [1,2,2,1], [1,2,2,1],'VALID')
# conv4_1D = tf.layers.conv2d(unpool4, filters=256, kernel_size=(1,1),
# padding="same", kernel_initializer=tf.contrib.layers.xavier_initializer())
# print('unpool4', unpool4.get_shape())
# print('conv4_1D', conv4_1D.get_shape())
# #tf.summary.image('unpool4', unpool4)
#with tf.variable_scope('unpool3', reuse=reuse) as scope:#20
# #unpool3 = gen_nn_ops._max_pool_grad(conv3_3, pool3, unpool4, [1,2,2,1], [1,2,2,1],'VALID')
# unpool3 = gen_nn_ops._max_pool_grad(conv3_3, pool3, conv4_1D, [1,2,2,1], [1,2,2,1],'VALID')
# conv3_1D = tf.layers.conv2d(unpool3, filters=128, kernel_size=(1,1),
# padding="same", kernel_initializer=tf.contrib.layers.xavier_initializer())
# print('unpool3', unpool3.get_shape())
# print('conv3_1D', conv3_1D.get_shape())
# #tf.summary.image('unpool3', unpool3)
#with tf.variable_scope('unpool2', reuse=reuse) as scope:#23
# #unpool2 = gen_nn_ops._max_pool_grad(conv2_2, pool2, unpool3, [1,2,2,1], [1,2,2,1],'VALID')
# unpool2 = gen_nn_ops._max_pool_grad(conv2_2, pool2, conv3_1D, [1,2,2,1], [1,2,2,1],'VALID')
# conv2_1D = tf.layers.conv2d(unpool2, filters=64, kernel_size=(1,1),
# padding="same", kernel_initializer=tf.contrib.layers.xavier_initializer())
# print('unpool2', unpool2.get_shape())
# print('conv2_1D', conv2_1D.get_shape())
# #tf.summary.image('unpool2', unpool2)
#with tf.variable_scope('unpool1', reuse=reuse) as scope:#25
# #unpool1 = gen_nn_ops._max_pool_grad(conv1_2, pool1, unpool2, [1,2,2,1], [1,2,2,1],'VALID')
# unpool1 = gen_nn_ops._max_pool_grad(conv1_2, pool1, conv2_1D, [1,2,2,1], [1,2,2,1],'VALID')
# conv1_1D = tf.layers.conv2d(unpool1, filters=1, kernel_size=(1,1),
# padding="same", kernel_initializer=tf.contrib.layers.xavier_initializer())
# print('unpool1', unpool1.get_shape())
# print('conv1_1D', conv1_1D.get_shape())
# tf.summary.image('conv1_1D', conv1_1D)
# print('conv1_1D.shape', conv1_1D.get_shape())
########################################################################################
with tf.variable_scope('unpool5', reuse=reuse) as scope: #14
#unpool5 = gen_nn_ops._max_pool_grad(idx_map, pool5, pool5, [1,3,3,1], [1,2,2,1],'VALID')
unpool5 = gen_nn_ops._max_pool_grad(conv5_3, pool5, pool5,
[1, 2, 2, 1], [1, 2, 2, 1],
'VALID')
if not reuse:
print('unpool5', unpool5.get_shape())
#tf.summary.image('unpool5', unpool5)
with tf.variable_scope('unpool4', reuse=reuse) as scope: #17
unpool4 = gen_nn_ops._max_pool_grad(conv4_3, pool4, unpool5,
[1, 2, 2, 1], [1, 2, 2, 1],
'VALID')
#conv4_1D = tf.layers.conv2d(unpool4, filters=256, kernel_size=(1,1),
# padding="same", kernel_initializer=tf.contrib.layers.xavier_initializer())
if not reuse:
print('unpool4', unpool4.get_shape())
#print('conv4_1D', conv4_1D.get_shape())
#tf.summary.image('unpool4', unpool4)
with tf.variable_scope('unpool3', reuse=reuse) as scope: #20
unpool3 = gen_nn_ops._max_pool_grad(conv3_3, pool3, unpool4,
[1, 2, 2, 1], [1, 2, 2, 1],
'VALID')
#unpool3 = gen_nn_ops._max_pool_grad(conv3_3, pool3, conv4_1D, [1,2,2,1], [1,2,2,1],'VALID')
#conv3_1D = tf.layers.conv2d(unpool3, filters=128, kernel_size=(1,1),
# padding="same", kernel_initializer=tf.contrib.layers.xavier_initializer())
if not reuse:
print('unpool3', unpool3.get_shape())
#print('conv3_1D', conv3_1D.get_shape())
#tf.summary.image('unpool3', unpool3)
with tf.variable_scope('unpool2', reuse=reuse) as scope: #23
unpool2 = gen_nn_ops._max_pool_grad(conv2_2, pool2, unpool3,
[1, 2, 2, 1], [1, 2, 2, 1],
'VALID')
#unpool2 = gen_nn_ops._max_pool_grad(conv2_2, pool2, conv3_1D, [1,2,2,1], [1,2,2,1],'VALID')
#conv2_1D = tf.layers.conv2d(unpool2, filters=64, kernel_size=(1,1),
# padding="same", kernel_initializer=tf.contrib.layers.xavier_initializer())
if not reuse:
print('unpool2', unpool2.get_shape())
#print('conv2_1D', conv2_1D.get_shape())
#tf.summary.image('unpool2', unpool2)
with tf.variable_scope('unpool1', reuse=reuse) as scope: #25
unpool1 = gen_nn_ops._max_pool_grad(conv1_2, pool1, unpool2,
[1, 2, 2, 1], [1, 2, 2, 1],
'VALID')
unpool1 = tf.reduce_max(unpool1, (3), keep_dims=True)
#unpool1 = gen_nn_ops._max_pool_grad(conv1_2, pool1, conv2_1D, [1,2,2,1], [1,2,2,1],'VALID')
#conv1_1D = tf.layers.conv2d(unpool1, filters=1, kernel_size=(1,1),
# padding="same", kernel_initializer=tf.contrib.layers.xavier_initializer())
if not reuse:
print('unpool1', unpool1.get_shape())
#print('conv1_1D', conv1_1D.get_shape())
#tf.summary.image('conv1_1D', conv1_1D)
#print('conv1_1D.shape', conv1_1D.get_shape())
feat = pool5
unpool = unpool1
return feat, unpool, grads_dict
