def __call__(self, task_embedding, training=False, keep_prob=1.0):
"""
:param task_images: images from a task
:param training:
:return:
"""
with tf.variable_scope("TaskTransformer", reuse=self.reuse):
# 11*11
with tf.variable_scope('t_conv1'):
te = tf.layers.conv2d(task_embedding, self.layer_sizes[0], [3, 3], strides=(1, 1),
padding='SAME')
te = relu(te, name='relu')
te = normalization(te, training=training, type='batch_norm')
te = max_pool(te, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
# 6*6
with tf.variable_scope('t_conv2'):
te = tf.layers.conv2d(te, self.layer_sizes[1], [3, 3], strides=(1, 1), padding='SAME')
te = relu(te, name='relu')
te = normalization(te, training=training, type='batch_norm')
te = max_pool(te, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
# 3*3
with tf.variable_scope("t_conv3"):
te = tf.layers.conv2d(te, self.layer_sizes[2], [3, 3], strides=(1, 1), padding='SAME')
te = tf.reduce_mean(te, axis=[1, 2])
self.reuse = True
return te
def __call__(self, image_embedding, task_context, training=False, keep_prob=1.0):
"""
Runs the CNN producing the embeddings and the gradients.
:param image_input: Image input to produce embeddings for.
:param training: A flag indicating training or evaluation
:param keep_prob: A tf placeholder of type tf.float32 indicating the amount of dropout applied
:return: Embeddings of size [batch_size, 64]
"""
print("task_context shape ", task_context.get_shape())
with tf.variable_scope('Classifier', reuse=self.reuse):
# 11*11
with tf.variable_scope("meta_conv1"):
m_conv1, m_conv1_w, m_conv1_b = self.meta_conv(image_embedding, task_context, self.layer_sizes[0], [3, 3], training=training)
m_conv1 = relu(m_conv1, name='outputs')
m_conv1 = max_pool(m_conv1, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1],
padding='SAME')
# 6*6
with tf.variable_scope("meta_conv2"):
m_conv2, m_conv2_w, m_conv2_b = self.meta_conv(m_conv1, task_context, self.layer_sizes[1], [3, 3], training=training)
m_conv2 = tf.contrib.layers.flatten(m_conv2)
print("m_conv2 ", m_conv2.get_shape())
gen_weights_list = [m_conv1_w, m_conv1_b, m_conv2_w, m_conv2_b]
self.reuse = True
self.variables = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='Classifier')
# print_params(self.variables, name="Feature Extractor")
return m_conv2, gen_weights_list
def GetSingleEngineGraphDef(dtype=dtypes.float32):
"""Create a graph containing single segment."""
g = ops.Graph()
with g.as_default():
inp = array_ops.placeholder(dtype=dtype,
shape=[None] + INPUT_DIMS[1:],
name=INPUT_NAME)
with g.device("/GPU:0"):
conv_filter = constant_op.constant(
[[[[1., 0.5, 4., 6., 0.5, 1.], [1., 0.5, 1., 1., 0.5, 1.]]]],
name="weights",
dtype=dtype)
conv = nn.conv2d(input=inp,
filter=conv_filter,
strides=[1, 2, 2, 1],
padding="SAME",
name="conv")
bias = constant_op.constant([4., 1.5, 2., 3., 5., 7.],
name="bias",
dtype=dtype)
added = nn.bias_add(conv, bias, name="bias_add")
relu = nn.relu(added, "relu")
identity = array_ops.identity(relu, "identity")
pool = nn_ops.max_pool(identity, [1, 2, 2, 1], [1, 2, 2, 1],
"VALID",
name="max_pool")
array_ops.squeeze(pool, name=OUTPUT_NAME)
return g.as_graph_def()
def testDepthwiseMaxPoolInvalidConfigs(self):
self._testDepthwiseMaxPoolInvalidConfig(
[1, 2, 2, 4], [1, 2, 2, 2], [1, 1, 1, 2],
"exactly one of pooling across depth")
self._testDepthwiseMaxPoolInvalidConfig(
[1, 2, 2, 4], [1, 1, 1, 2], [1, 1, 1, 1],
"depth window to equal the depth stride")
self._testDepthwiseMaxPoolInvalidConfig([1, 2, 2, 4], [1, 1, 1, 3],
[1, 1, 1, 3], "evenly divide")
if test.is_gpu_available():
with self.test_session(use_gpu=True):
t = constant_op.constant(1.0, shape=[1, 2, 2, 4])
with self.assertRaisesOpError("for CPU devices"):
nn_ops.max_pool(
t, ksize=[1, 1, 1, 2], strides=[1, 1, 1, 2],
padding="SAME").eval()
def GetParams(self):
"""Single vgg layer test in TF-TRT conversion."""
dtype = dtypes.float32
input_name = "input"
input_dims = [5, 8, 8, 2]
output_name = "output"
g = ops.Graph()
with g.as_default():
x = array_ops.placeholder(dtype=dtype, shape=input_dims, name=input_name)
x, _, _ = nn_impl.fused_batch_norm(
x, [1.0, 1.0], [0.0, 0.0],
mean=[0.5, 0.5],
variance=[1.0, 1.0],
is_training=False)
e = constant_op.constant(
np.random.randn(1, 1, 2, 6), name="weights", dtype=dtype)
conv = nn.conv2d(
input=x, filter=e, strides=[1, 2, 2, 1], padding="SAME", name="conv")
b = constant_op.constant(np.random.randn(6), name="bias", dtype=dtype)
t = nn.bias_add(conv, b, name="biasAdd")
relu = nn.relu(t, "relu")
idty = array_ops.identity(relu, "ID")
v = nn_ops.max_pool(
idty, [1, 2, 2, 1], [1, 2, 2, 1], "VALID", name="max_pool")
array_ops.squeeze(v, name=output_name)
return trt_test.TfTrtIntegrationTestParams(
gdef=g.as_graph_def(),
input_names=[input_name],
input_dims=[input_dims],
output_names=[output_name],
expected_output_dims=[(5, 2, 2, 6)])
def GraphFn(self, x):
dtype = x.dtype
x, _, _ = nn_impl.fused_batch_norm(
x, [1.0, 1.0], [0.0, 0.0],
mean=[0.5, 0.5],
variance=[1.0, 1.0],
data_format="NCHW",
is_training=False)
e = constant_op.constant(
np.random.randn(1, 1, 2, 6), name="weights", dtype=dtype)
conv = nn.conv2d(
input=x,
filter=e,
data_format="NCHW",
strides=[1, 1, 2, 2],
padding="SAME",
name="conv")
b = constant_op.constant(np.random.randn(6), name="bias", dtype=dtype)
t = nn.bias_add(conv, b, data_format="NCHW", name="biasAdd")
relu = nn.relu(t, "relu")
idty = array_ops.identity(relu, "ID")
v = nn_ops.max_pool(
idty, [1, 1, 2, 2], [1, 1, 2, 2],
"VALID",
data_format="NCHW",
name="max_pool")
return array_ops.squeeze(v, name="output_0")
def _testMaxPoolGradDirect(self, input_data, output_backprop,
expected_input_backprop, input_sizes, output_sizes,
window_rows, window_cols, row_stride, col_stride,
padding, use_gpu):
with self.test_session(use_gpu=use_gpu) as sess:
input_tensor = constant_op.constant(input_data, shape=input_sizes)
output_tensor = nn_ops.max_pool(input_tensor,
[1, window_rows, window_cols, 1],
[1, row_stride, col_stride, 1], padding)
output_backprop_tensor = constant_op.constant(
output_backprop, shape=output_sizes)
input_backprop_tensor = self._MaxPoolGrad(input_tensor, output_tensor,
output_backprop_tensor,
window_rows, window_cols,
row_stride, col_stride, padding)
actual_input_backprop = input_backprop_tensor.eval()
self.assertShapeEqual(actual_input_backprop, input_backprop_tensor)
actual_input_backprop = actual_input_backprop.flatten()
actual_input_backprop = self._GetNdArray(actual_input_backprop)
actual_output = output_tensor.eval().flatten()
actual_output = self._GetNdArray(actual_output)
self.assertAllClose(
expected_input_backprop, actual_input_backprop, rtol=1e-6, atol=1e-6)
def GetSingleEngineGraphDef(dtype=dtypes.float32):
"""Create a graph containing single segment."""
g = ops.Graph()
with g.as_default():
inp = array_ops.placeholder(
dtype=dtype, shape=[None] + INPUT_DIMS[1:], name=INPUT_NAME)
with g.device("/GPU:0"):
conv_filter = constant_op.constant(
[[[[1., 0.5, 4., 6., 0.5, 1.], [1., 0.5, 1., 1., 0.5, 1.]]]],
name="weights",
dtype=dtype)
conv = nn.conv2d(
input=inp,
filter=conv_filter,
strides=[1, 2, 2, 1],
padding="SAME",
name="conv")
bias = constant_op.constant(
[4., 1.5, 2., 3., 5., 7.], name="bias", dtype=dtype)
added = nn.bias_add(conv, bias, name="bias_add")
relu = nn.relu(added, "relu")
identity = array_ops.identity(relu, "identity")
pool = nn_ops.max_pool(
identity, [1, 2, 2, 1], [1, 2, 2, 1], "VALID", name="max_pool")
array_ops.squeeze(pool, name=OUTPUT_NAME)
return g.as_graph_def()
def testDirectNotUseOverlapping(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 * 5
num_cols = col_window_size * 7
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._GenerateUniqueRandomInputTensor(input_shape))
window_size = [1, row_window_size, col_window_size, 1]
stride_size = [1, row_window_size, col_window_size, 1]
padding = "VALID"
output_tensor = nn_ops.max_pool(input_tensor, window_size,
stride_size, padding)
output_data = self.evaluate(output_tensor)
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 = self.evaluate(input_backprop_tensor)
row_seq = list(range(0, num_rows + 1, row_window_size))
col_seq = list(range(0, num_cols + 1, col_window_size))
fmp_input_backprop_tensor = gen_nn_ops.fractional_max_pool_grad(
input_tensor,
output_tensor,
output_backprop,
row_seq,
col_seq,
overlapping=False)
fmp_input_backprop = self.evaluate(fmp_input_backprop_tensor)
self.assertShapeEqual(input_backprop, fmp_input_backprop_tensor)
self.assertAllClose(input_backprop, fmp_input_backprop)
def __call__(self, image_input, training=False, dropout_rate=0.0):
"""
Runs the CNN producing the embeddings and the gradients.
:param image_input: Image input to produce embeddings for. [batch_size, 28, 28, 1]
:param training: A flag indicating training or evaluation
:param dropout_rate: A tf placeholder of type tf.float32 indicating the amount of dropout applied
:return: Embeddings of size [batch_size, 64]
"""
with tf.variable_scope(self.name, reuse=self.reuse):
outputs = image_input
with tf.variable_scope('conv_layers'):
for idx, num_filters in enumerate(self.layer_sizes):
with tf.variable_scope('g_conv_{}'.format(idx)):
if idx == len(self.layer_sizes) - 1:
outputs = tf.layers.conv2d(outputs, num_filters, [2, 2], strides=(1, 1),
padding='VALID')
else:
outputs = tf.layers.conv2d(outputs, num_filters, [3, 3], strides=(1, 1),
padding='VALID')
outputs = leaky_relu(outputs)
outputs = tf.contrib.layers.batch_norm(outputs, updates_collections=None,
decay=0.99,
scale=True, center=True,
is_training=training)
outputs = max_pool(outputs, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1],
padding='SAME')
outputs = tf.layers.dropout(outputs, rate=dropout_rate, training=training)
image_embedding = tf.contrib.layers.flatten(outputs)
self.reuse = tf.AUTO_REUSE
self.variables = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope=self.name)
return image_embedding
def get_simple_graph_def(self):
"""Create a simple graph and return its graph_def."""
g = ops.Graph()
with g.as_default():
a = aops.placeholder(
dtype=dtypes.float32, shape=(None, 24, 24, 2), name="input")
e = cop.constant(
[[[[1., 0.5, 4., 6., 0.5, 1.], [1., 0.5, 1., 1., 0.5, 1.]]]],
name="weights",
dtype=dtypes.float32)
conv = nn.conv2d(
input=a,
filter=e,
strides=[1, 2, 2, 1],
padding="SAME",
name="conv")
b = cop.constant(
[4., 1.5, 2., 3., 5., 7.], name="bias", dtype=dtypes.float32)
t = nn.bias_add(conv, b, name="biasAdd")
relu = nn.relu(t, "relu")
idty = aops.identity(relu, "ID")
v = nn_ops.max_pool(
idty, [1, 2, 2, 1], [1, 2, 2, 1], "VALID", name="max_pool")
aops.squeeze(v, name="output")
return g.as_graph_def()
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 get_simple_graph_def():
"""Create a simple graph and return its graph_def."""
g = ops.Graph()
with g.as_default():
a = aops.placeholder(dtype=dtypes.float32,
shape=(None, 24, 24, 2),
name="input")
e = cop.constant(
[[[[1., 0.5, 4., 6., 0.5, 1.], [1., 0.5, 1., 1., 0.5, 1.]]]],
name="weights",
dtype=dtypes.float32)
conv = nn.conv2d(input=a,
filter=e,
strides=[1, 2, 2, 1],
padding="SAME",
name="conv")
b = cop.constant([4., 1.5, 2., 3., 5., 7.],
name="bias",
dtype=dtypes.float32)
t = nn.bias_add(conv, b, name="biasAdd")
relu = nn.relu(t, "relu")
idty = aops.identity(relu, "ID")
v = nn_ops.max_pool(idty, [1, 2, 2, 1], [1, 2, 2, 1],
"VALID",
name="max_pool")
aops.squeeze(v, name="output")
return g.as_graph_def()
def test2DNumpy(self):
x = np.ones([3, 6, 6, 5])
ksize = 2
strides = 2
y1 = nn_ops.max_pool_v2(x, ksize, strides, "SAME")
y2 = nn_ops.max_pool(x, ksize, strides, "SAME")
self.assertAllEqual(self.evaluate(y1), self.evaluate(y2))
def test2DNumpy(self):
x = np.ones([3, 6, 6, 5])
ksize = 2
strides = 2
y1 = nn_ops.max_pool_v2(x, ksize, strides, "SAME")
y2 = nn_ops.max_pool(x, ksize, strides, "SAME")
self.assertAllEqual(self.evaluate(y1), self.evaluate(y2))
def __call__(self, image_input, training=False, dropout_rate=0.0):
"""
Runs the CNN producing the embeddings and the gradients.
:param image_input: Image input to produce embeddings for. [batch_size, 28, 28, 1]
:param training: A flag indicating training or evaluation
:param dropout_rate: A tf placeholder of type tf.float32 indicating the amount of dropout applied
:return: Embeddings of size [batch_size, 64]
"""
with tf.variable_scope(self.name, reuse=self.reuse):
outputs = image_input #image_input.shape: (32,28,28,1)
with tf.variable_scope('conv_layers'):
for idx, num_filters in enumerate(self.layer_sizes):
with tf.variable_scope('g_conv_{}'.format(idx)):
if idx == len(self.layer_sizes) - 1:
outputs = tf.layers.conv2d(outputs,
num_filters, [2, 2],
strides=(1, 1),
padding='VALID')
else:
outputs = tf.layers.conv2d(outputs,
num_filters, [3, 3],
strides=(1, 1),
padding='VALID')
outputs = leaky_relu(outputs)
outputs = tf.contrib.layers.batch_norm(
outputs,
updates_collections=None,
decay=0.99,
scale=True,
center=True,
is_training=training)
outputs = max_pool(outputs,
ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1],
padding='SAME')
#outputs = tf.layers.dropout(outputs, rate=dropout_rate, training=training)
# # 全连接层1
# W_fc1 = weight_variable([64,1024])
# b_fc1 = bias_variable([1024])
# h_pool2_flat = tf.reshape(outputs, [-1,7*7*64]) #[n_samples,1,1,64]->>[n_samples,1*1*64]
# h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)
# h_fc1_drop = tf.nn.dropout(h_fc1, dropout_rate) # 减少计算量dropout
# # 全连接层2
# W_fc2 = weight_variable([1024, 所有标签种类数])
# b_fc2 = bias_variable([所有标签种类数])
# prediction = tf.matmul(h_fc1_drop, W_fc2) + b_fc2
image_embedding = tf.contrib.layers.flatten(
outputs) #image_embedding: (32,64)
self.reuse = True
self.variables = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES,
scope=self.name)
return image_embedding
def _testDepthwiseMaxPoolInvalidConfig(self,
in_size,
ksize,
strides,
error_msg,
use_gpu=False):
with self.test_session(use_gpu=use_gpu) as sess:
t = constant_op.constant(1.0, shape=in_size)
with self.assertRaisesRegexp(errors_impl.UnimplementedError, error_msg):
t = nn_ops.max_pool(
t, ksize=ksize, strides=strides, padding="SAME").eval()
def _max_pool_2d(_input,
kh=2,
kw=2,
sh=2,
sw=2,
name="max_pool_2d",
padding='SAME'):
return nn_ops.max_pool(_input,
ksize=[1, kh, kw, 1],
strides=[1, sh, sw, 1],
padding=padding,
name=name)
def _CompareMaxPoolingFwd(self, input_shape, ksize, strides, padding):
for dtype in np.float32, np.float16:
tensor_input = np.random.rand(*input_shape).astype(dtype)
with self.test_session(use_gpu=True):
t = constant_op.constant(tensor_input, shape=input_shape)
out_op, _ = nn_ops.max_pool_with_argmax(t, ksize, strides, padding)
gpu_val = out_op.eval()
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)
cpu_val = out_op.eval()
self.assertAllCloseAccordingToType(cpu_val, gpu_val)
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 inference(x):
with vs.variable_scope('all', use_resource=True):
x = conv(x, 7, 2, 64)
x = nn_ops.relu(x)
x = max_pool(x, ksize=3, stride=2)
x = block("b1", 64, 1, 2, x)
x = nn_ops.max_pool(x, [1, x.shape[1], x.shape[2], 1], [1, 1, 1, 1],
'VALID')
x = array_ops.reshape(x, [x.shape[0], x.shape[3]])
x = fc("fc1", x, 1000)
return x
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 backprop_pool(activation,
relevance,
ksize,
strides,
pooling_type,
padding='VALID'):
if pooling_type.lower() is 'avg': # avg pooling
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: # max pooling
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 _conv_and_pool_1(self, inp):
dtype = inp.dtype
conv_filter = constant_op.constant(
[[[[1., 0.5], [4., 6.], [0.5, 1.]]]], name="weights", dtype=dtype)
conv = nn.conv2d(input=inp,
filter=conv_filter,
strides=[1, 2, 2, 1],
padding="SAME",
name="conv")
bias = constant_op.constant([4., 1.5], name="bias", dtype=dtype)
added = nn.bias_add(conv, bias, name="bias_add")
relu = nn.relu(added, "relu")
identity = array_ops.identity(relu, "identity")
pool = nn_ops.max_pool(identity, [1, 2, 2, 1], [1, 2, 2, 1],
"VALID",
name="max_pool")
return array_ops.squeeze(pool)
def GetParams(self):
"""Single vgg layer in NCHW unit tests in TF-TRT."""
dtype = dtypes.float32
input_name = "input"
input_dims = [5, 2, 8, 8]
g = ops.Graph()
with g.as_default():
x = array_ops.placeholder(dtype=dtype,
shape=input_dims,
name=input_name)
x, _, _ = nn_impl.fused_batch_norm(
x,
np.random.randn(2).astype(np.float32),
np.random.randn(2).astype(np.float32),
mean=np.random.randn(2).astype(np.float32),
variance=np.random.randn(2).astype(np.float32),
data_format="NCHW",
is_training=False)
e = constant_op.constant(np.random.randn(1, 1, 2, 6),
name="weights",
dtype=dtype)
conv = nn.conv2d(input=x,
filter=e,
data_format="NCHW",
strides=[1, 1, 2, 2],
padding="SAME",
name="conv")
b = constant_op.constant(np.random.randn(6),
name="bias",
dtype=dtype)
t = nn.bias_add(conv, b, data_format="NCHW", name="biasAdd")
relu = nn.relu(t, "relu")
idty = array_ops.identity(relu, "ID")
v = nn_ops.max_pool(idty, [1, 1, 2, 2], [1, 1, 2, 2],
"VALID",
data_format="NCHW",
name="max_pool")
array_ops.squeeze(v, name="output")
return trt_test.TfTrtIntegrationTestParams(gdef=g.as_graph_def(),
input_names=[input_name],
input_dims=[input_dims],
num_expected_engines=1,
expected_output_dims=(5, 6,
2, 2),
allclose_atol=1.e-03,
allclose_rtol=1.e-03)
def _get_plugin_graph_def(self):
"""Create a simple graph and return its graph_def."""
g = ops.Graph()
with g.as_default():
a = array_ops.placeholder(
dtype=dtypes.float32, shape=(None, 24, 24, 2), name="input")
relu = nn.relu(a, "relu")
v = nn_ops.max_pool(
relu, [1, 2, 2, 1], [1, 2, 2, 1], "VALID", name="max_pool")
# insert custom_op in the graph
v = custom_plugin_examples.inc_op(v, inc=[16.5], name="plugin_test")
v *= 2.0
v = nn.relu(v)
v = nn.relu(v)
array_ops.squeeze(v, name="output")
return g.as_graph_def()
def GetParams(self):
"""Create a graph containing single segment."""
# TODO(aaroey): test graph with different dtypes.
dtype = dtypes.float32
input_name = "input"
input_dims = [100, 24, 24, 2]
g = ops.Graph()
with g.as_default():
inp = array_ops.placeholder(dtype=dtype,
shape=[None] + input_dims[1:],
name=input_name)
with g.device("/GPU:0"):
conv_filter = constant_op.constant(
[[[[1., 0.5, 4., 6., 0.5, 1.], [1., 0.5, 1., 1., 0.5, 1.]]]
],
name="weights",
dtype=dtype)
conv = nn.conv2d(input=inp,
filter=conv_filter,
strides=[1, 2, 2, 1],
padding="SAME",
name="conv")
bias = constant_op.constant([4., 1.5, 2., 3., 5., 7.],
name="bias",
dtype=dtype)
added = nn.bias_add(conv, bias, name="bias_add")
relu = nn.relu(added, "relu")
identity = array_ops.identity(relu, "identity")
pool = nn_ops.max_pool(identity, [1, 2, 2, 1], [1, 2, 2, 1],
"VALID",
name="max_pool")
array_ops.squeeze(pool, name=self.output_name)
return trt_test.TfTrtIntegrationTestParams(
gdef=g.as_graph_def(),
input_names=[input_name],
input_dims=[input_dims],
# TODO(aaroey): LayoutOptimizer adds additional nodes to the graph which
# breaks the connection check, fix it.
# - my_trt_op_0 should have ["weights", "conv", "bias", "bias_add",
# "relu", "identity", "max_pool"]
expected_engines=["my_trt_op_0"],
expected_output_dims=(100, 6, 6, 6),
allclose_atol=1.e-03,
allclose_rtol=1.e-03)
def GetParams(self):
"""Single vgg layer in NCHW unit tests in TF-TRT."""
dtype = dtypes.float32
input_name = "input"
input_dims = [5, 2, 8, 8]
g = ops.Graph()
with g.as_default():
x = array_ops.placeholder(dtype=dtype, shape=input_dims, name=input_name)
x, _, _ = nn_impl.fused_batch_norm(
x,
np.random.randn(2).astype(np.float32),
np.random.randn(2).astype(np.float32),
mean=np.random.randn(2).astype(np.float32),
variance=np.random.randn(2).astype(np.float32),
data_format="NCHW",
is_training=False)
e = constant_op.constant(
np.random.randn(1, 1, 2, 6), name="weights", dtype=dtype)
conv = nn.conv2d(
input=x,
filter=e,
data_format="NCHW",
strides=[1, 1, 2, 2],
padding="SAME",
name="conv")
b = constant_op.constant(np.random.randn(6), name="bias", dtype=dtype)
t = nn.bias_add(conv, b, data_format="NCHW", name="biasAdd")
relu = nn.relu(t, "relu")
idty = array_ops.identity(relu, "ID")
v = nn_ops.max_pool(
idty, [1, 1, 2, 2], [1, 1, 2, 2],
"VALID",
data_format="NCHW",
name="max_pool")
array_ops.squeeze(v, name="output")
return trt_test.TfTrtIntegrationTestParams(
gdef=g.as_graph_def(),
input_names=[input_name],
input_dims=[input_dims],
num_expected_engines=1,
expected_output_dims=(5, 6, 2, 2),
allclose_atol=1.e-03,
allclose_rtol=1.e-03)
def GetParams(self):
"""Create a graph containing single segment."""
# TODO(aaroey): test graph with different dtypes.
dtype = dtypes.float32
input_name = "input"
input_dims = [100, 24, 24, 2]
g = ops.Graph()
with g.as_default():
inp = array_ops.placeholder(
dtype=dtype, shape=[None] + input_dims[1:], name=input_name)
with g.device("/GPU:0"):
conv_filter = constant_op.constant(
[[[[1., 0.5, 4., 6., 0.5, 1.], [1., 0.5, 1., 1., 0.5, 1.]]]],
name="weights",
dtype=dtype)
conv = nn.conv2d(
input=inp,
filter=conv_filter,
strides=[1, 2, 2, 1],
padding="SAME",
name="conv")
bias = constant_op.constant(
[4., 1.5, 2., 3., 5., 7.], name="bias", dtype=dtype)
added = nn.bias_add(conv, bias, name="bias_add")
relu = nn.relu(added, "relu")
identity = array_ops.identity(relu, "identity")
pool = nn_ops.max_pool(
identity, [1, 2, 2, 1], [1, 2, 2, 1], "VALID", name="max_pool")
array_ops.squeeze(pool, name=self.output_name)
return trt_test.TfTrtIntegrationTestParams(
gdef=g.as_graph_def(),
input_names=[input_name],
input_dims=[input_dims],
# TODO(aaroey): LayoutOptimizer adds additional nodes to the graph which
# breaks the connection check, fix it.
# - my_trt_op_0 should have ["weights", "conv", "bias", "bias_add",
# "relu", "identity", "max_pool"]
expected_engines=["my_trt_op_0"],
expected_output_dims=(100, 6, 6, 6),
allclose_atol=1.e-03,
allclose_rtol=1.e-03)
def GetParams(self):
"""Create a graph containing single segment."""
# TODO(aaroey): test graph with different dtypes.
dtype = dtypes.float32
input_name = "input"
input_dims = [100, 24, 24, 2]
output_name = "output"
g = ops.Graph()
with g.as_default():
inp = array_ops.placeholder(dtype=dtype,
shape=[None] + input_dims[1:],
name=input_name)
with g.device("/GPU:0"):
conv_filter = constant_op.constant(
[[[[1., 0.5, 4., 6., 0.5, 1.], [1., 0.5, 1., 1., 0.5, 1.]]]
],
name="weights",
dtype=dtype)
conv = nn.conv2d(input=inp,
filter=conv_filter,
strides=[1, 2, 2, 1],
padding="SAME",
name="conv")
bias = constant_op.constant([4., 1.5, 2., 3., 5., 7.],
name="bias",
dtype=dtype)
added = nn.bias_add(conv, bias, name="bias_add")
relu = nn.relu(added, "relu")
identity = array_ops.identity(relu, "identity")
pool = nn_ops.max_pool(identity, [1, 2, 2, 1], [1, 2, 2, 1],
"VALID",
name="max_pool")
array_ops.squeeze(pool, name=output_name)
return trt_test.TfTrtIntegrationTestParams(gdef=g.as_graph_def(),
input_names=[input_name],
input_dims=[input_dims],
output_names=[output_name],
expected_output_dims=[
(100, 6, 6, 6)
])
def GraphFn(self, inp):
"""Create a graph containing single segment."""
dtype = inp.dtype
conv_filter = constant_op.constant(
[[[[1., 0.5, 4., 6., 0.5, 1.], [1., 0.5, 1., 1., 0.5, 1.]]]],
name="weights",
dtype=dtype)
conv = nn.conv2d(input=inp,
filter=conv_filter,
strides=[1, 2, 2, 1],
padding="SAME",
name="conv")
bias = constant_op.constant([4., 1.5, 2., 3., 5., 7.],
name="bias",
dtype=dtype)
added = nn.bias_add(conv, bias, name="bias_add")
relu = nn.relu(added, "relu")
identity = array_ops.identity(relu, "identity")
pool = nn_ops.max_pool(identity, [1, 2, 2, 1], [1, 2, 2, 1],
"VALID",
name="max_pool")
return array_ops.squeeze(pool, name="output_0")
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 GetParams(self):
"""Create a graph containing single segment."""
# TODO(aaroey): test graph with different dtypes.
dtype = dtypes.float32
input_name = "input"
input_dims = [100, 24, 24, 2]
output_name = "output"
g = ops.Graph()
with g.as_default():
inp = array_ops.placeholder(
dtype=dtype, shape=[None] + input_dims[1:], name=input_name)
with g.device("/GPU:0"):
conv_filter = constant_op.constant(
[[[[1., 0.5, 4., 6., 0.5, 1.], [1., 0.5, 1., 1., 0.5, 1.]]]],
name="weights",
dtype=dtype)
conv = nn.conv2d(
input=inp,
filter=conv_filter,
strides=[1, 2, 2, 1],
padding="SAME",
name="conv")
bias = constant_op.constant([4., 1.5, 2., 3., 5., 7.],
name="bias",
dtype=dtype)
added = nn.bias_add(conv, bias, name="bias_add")
relu = nn.relu(added, "relu")
identity = array_ops.identity(relu, "identity")
pool = nn_ops.max_pool(
identity, [1, 2, 2, 1], [1, 2, 2, 1], "VALID", name="max_pool")
array_ops.squeeze(pool, name=output_name)
return trt_test.TfTrtIntegrationTestParams(
gdef=g.as_graph_def(),
input_names=[input_name],
input_dims=[input_dims],
output_names=[output_name],
expected_output_dims=[(100, 6, 6, 6)])
def test_maxpool2d():
''' Run tests on the Wave custom maxpool2d operator.
'''
tf.reset_default_graph()
# Turn off graph-rewriting optimizations
config = tf.ConfigProto(graph_options=tf.GraphOptions(
optimizer_options=tf.OptimizerOptions(
opt_level=tf.OptimizerOptions.L0)))
iterations = 100
for i in range(iterations):
tf.reset_default_graph()
# NCHW
t_n = 1
t_h = 64
t_w = 64
t_c = 1
# window
w_n = 1
w_h = 2
w_w = 2
w_c = 1
#strides
s_n = 1
s_h = 2
s_w = 2
s_c = 1
# N H W C
max_in_tmp = tf.get_variable(
"a", [t_n, t_h, t_w, t_c],
dtype=tf.float32,
initializer=tf.truncated_normal_initializer(stddev=0.1))
max_in = waveflow.wavecomp_ops_module.wave_quantize_dfx(
max_in_tmp, [16, 14])
t_init = tf.global_variables_initializer()
# SAME variant
with tf.Session('', config=config) as sess:
t_init.run()
z1_op = nn_ops.max_pool(max_in,
ksize=[w_n, w_h, w_w, w_c],
strides=[s_n, s_h, s_w, s_c],
padding='SAME',
data_format='NHWC')
z2_grad = tf.gradients(z1_op, max_in)[0]
z3_op = waveflow.wavecomp_ops_module.wave_max_pool_dfx(
max_in,
ksize=[w_n, w_h, w_w, w_c],
strides=[s_n, s_h, s_w, s_c],
padding='SAME',
data_format='NHWC')
z4_grad = tf.gradients(z3_op, max_in)[0]
z1, z2, z3, z4 = sess.run([z1_op, z2_grad, z3_op, z4_grad])
assert_str = "Failure on i: %d, mode: SAME" % (i)
if not compare_tensor(z2, z4, assert_str):
print("z2: shape: %s, %s" % (z2.shape, z2))
print("z4 (np): shape: %s, %s" % (z4.shape, z4))
print("\n\n")
assert False
# # Valid variant
with tf.Session('', config=config) as sess:
t_init.run()
z1_op = nn_ops.max_pool(max_in,
ksize=[w_n, w_h, w_w, w_c],
strides=[s_n, s_h, s_w, s_c],
padding='VALID',
data_format='NHWC')
z2_grad = tf.gradients(z1_op, max_in)[0]
z3_op = waveflow.wavecomp_ops_module.wave_max_pool_dfx(
max_in,
ksize=[w_n, w_h, w_w, w_c],
strides=[s_n, s_h, s_w, s_c],
padding='VALID',
data_format='NHWC')
z4_grad = tf.gradients(z3_op, max_in)[0]
z1, z2, z3, z4 = sess.run([z1_op, z2_grad, z3_op, z4_grad])
assert_str = "Failure on i: %d, mode: VALID" % (i)
if not compare_tensor(z2, z4, assert_str):
print("z2: shape: %s, %s" % (z2.shape, z2))
print("z4 (np): shape: %s, %s" % (z4.shape, z4))
print("\n\n")
assert False
return True
def test_maxpool2d():
''' Run tests on the Wave custom maxpool2d operator.
'''
tf.reset_default_graph()
# Turn off graph-rewriting optimizations
config = tf.ConfigProto(graph_options=tf.GraphOptions(optimizer_options=tf.OptimizerOptions(opt_level=tf.OptimizerOptions.L0)))
iterations = 100
for i in range(iterations):
tf.reset_default_graph()
# NCHW
t_n = 1
t_h = 64
t_w = 64
t_c = 1
# window
w_n = 1
w_h = 2
w_w = 2
w_c = 1
#strides
s_n = 1
s_h = 2
s_w = 2
s_c = 1
# N H W C
max_in = tf.get_variable("a", [t_n, t_h, t_w, t_c], dtype=tf.float32, initializer=tf.truncated_normal_initializer(stddev=0.1))
t_init = tf.global_variables_initializer()
# SAME variant
with tf.Session('', config=config) as sess:
t_init.run()
# print("Wave Kernel:\n-------------------------------------------------")
z_op = waveflow.wavecomp_ops_module.wave_max_pool_dfx(
max_in,
ksize=[w_n, w_h, w_w, w_c],
strides=[s_n, s_h, s_w, s_c],
padding='SAME',
data_format='NHWC')
# Base tensorflow. Only supports NHWC.
z2_op = nn_ops.max_pool(
max_in,
ksize=[w_n, w_h, w_w, w_c],
strides=[s_n, s_h, s_w, s_c],
padding='SAME',
data_format='NHWC')
# z = z_op.eval()
# z2 = z2_op.eval()
z, z2 = sess.run([z_op, z2_op])
# print("\nTF:\n-------------------------------------------------")
assert_str = "Failure on i: %d, mode: SAME" % (i)
if not compare_tensor(z, z2, assert_str):
print("z: shape: %s, %s" % (z.shape, z))
print("z (np): shape: %s, %s" % (z2.shape, z2))
print("\n\n")
assert False
# Valid variant
with tf.Session('', config=config) as sess:
t_init.run()
# print("Wave Kernel:\n-------------------------------------------------")
z_op = waveflow.wavecomp_ops_module.wave_max_pool_dfx(
max_in,
ksize=[w_n, w_h, w_w, w_c],
strides=[s_n, s_h, s_w, s_c],
padding='VALID',
data_format='NHWC')
# Base tensorflow. Only supports NHWC.
z2_op = nn_ops.max_pool(
max_in,
ksize= [w_n, w_h, w_w, w_c],
strides=[s_n, s_h, s_w, s_c],
padding='VALID',
data_format='NHWC')
z, z2 = sess.run([z_op, z2_op])
# print("\nTF:\n-------------------------------------------------")
assert_str = "Failure on i: %d, mode: VALID" % (i)
if not compare_tensor(z, z2, assert_str):
print("z: shape: %s, %s" % (z.shape, z))
print("z (np): shape: %s, %s" % (z2.shape, z2))
print("\n\n")
assert False
return True
def __call__(self, image_input, training=False, keep_prob=1.0):
"""
Runs the CNN producing the embeddings and the gradients.
:param image_input: Image input to produce embeddings for. [batch_size, 28, 28, 1]
:param training: A flag indicating training or evaluation
:param keep_prob: A tf placeholder of type tf.float32 indicating the amount of dropout applied
:return: Embeddings of size [batch_size, 64]
"""
with tf.variable_scope('g'):
if self.reuse:
tf.get_variable_scope().reuse_variables()
with tf.variable_scope('conv_layers'):
input_channel = image_input.get_shape().as_list()[-1]
w0 = tf.get_variable(
'w0', [3, 3, input_channel, self.layer_sizes[0]])
w1 = tf.get_variable(
'w1', [3, 3, self.layer_sizes[0], self.layer_sizes[1]])
w2 = tf.get_variable(
'w2', [3, 3, self.layer_sizes[1], self.layer_sizes[2]])
w3 = tf.get_variable(
'w3', [2, 2, self.layer_sizes[2], self.layer_sizes[3]])
with tf.variable_scope('g_conv1'):
g_conv1_encoder = tf.nn.conv2d(image_input,
w0,
strides=[1, 1, 1, 1],
padding='VALID')
g_conv1_encoder = tf.nn.relu(g_conv1_encoder,
name='outputs')
g_conv1_encoder = tf.contrib.layers.batch_norm(
g_conv1_encoder, is_training=training)
g_conv1_encoder = max_pool(g_conv1_encoder,
ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1],
padding='SAME')
g_conv1_encoder = tf.nn.dropout(g_conv1_encoder,
keep_prob=keep_prob)
with tf.variable_scope('g_conv2'):
g_conv2_encoder = tf.nn.conv2d(g_conv1_encoder,
w1,
strides=[1, 1, 1, 1],
padding='VALID')
g_conv2_encoder = tf.nn.relu(g_conv2_encoder,
name='outputs')
g_conv2_encoder = tf.contrib.layers.batch_norm(
g_conv2_encoder, is_training=training, reuse=None)
g_conv2_encoder = max_pool(g_conv2_encoder,
ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1],
padding='SAME')
g_conv2_encoder = tf.nn.dropout(g_conv2_encoder,
keep_prob=keep_prob)
with tf.variable_scope('g_conv3'):
g_conv3_encoder = tf.nn.conv2d(g_conv2_encoder,
w2,
strides=[1, 1, 1, 1],
padding='VALID')
g_conv3_encoder = tf.nn.relu(g_conv3_encoder,
name='outputs')
g_conv3_encoder = tf.contrib.layers.batch_norm(
g_conv3_encoder, is_training=training, reuse=None)
g_conv3_encoder = max_pool(g_conv3_encoder,
ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1],
padding='SAME')
g_conv3_encoder = tf.nn.dropout(g_conv3_encoder,
keep_prob=keep_prob)
with tf.variable_scope('g_conv4'):
g_conv4_encoder = tf.nn.conv2d(g_conv3_encoder,
w3,
strides=[1, 1, 1, 1],
padding='VALID')
g_conv4_encoder = tf.nn.relu(g_conv4_encoder,
name='outputs')
g_conv4_encoder = tf.contrib.layers.batch_norm(
g_conv4_encoder, is_training=training, reuse=None)
g_conv4_encoder = max_pool(g_conv4_encoder,
ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1],
padding='SAME')
g_conv4_encoder = tf.nn.dropout(g_conv4_encoder,
keep_prob=keep_prob)
g_conv_encoder = g_conv4_encoder
g_conv_encoder = tf.contrib.layers.flatten(g_conv_encoder)
#
self.reuse = True
self.variables = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES,
scope='g')
return g_conv_encoder
def max_pool(x, ksize=3, stride=2):
return nn_ops.max_pool(x,
ksize=[1, ksize, ksize, 1],
strides=[1, stride, stride, 1],
padding='SAME')
def __call__(self, image_input, training=False, keep_prob=1.0):
"""
this module use to implement relstion module
"""
def leaky_relu(x, leak=0.2, name=''):
return tf.maximum(x, x * leak, name=name)
with tf.variable_scope('RelationModule', reuse=self.reuse):
with tf.variable_scope('conv_layers'):
with tf.variable_scope('RelationModule_conv1'):
# pdb.set_trace()
g_conv1_encoder = tf.layers.conv2d(image_input,
64, [3, 3],
strides=(1, 1),
padding='SAME')
g_conv1_encoder = leaky_relu(g_conv1_encoder,
name='outputs')
g_conv1_encoder = tf.contrib.layers.batch_norm(
g_conv1_encoder,
updates_collections=None,
decay=0.99,
scale=True,
center=True,
is_training=training)
g_conv1_encoder = max_pool(g_conv1_encoder,
ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1],
padding='SAME')
g_conv1_encoder = tf.nn.dropout(g_conv1_encoder,
keep_prob=keep_prob)
with tf.variable_scope('RelationModule_conv2'):
g_conv2_encoder = tf.layers.conv2d(g_conv1_encoder,
64, [3, 3],
strides=(1, 1),
padding='SAME')
g_conv2_encoder = leaky_relu(g_conv2_encoder,
name='outputs')
g_conv2_encoder = tf.contrib.layers.batch_norm(
g_conv2_encoder,
updates_collections=None,
decay=0.99,
scale=True,
center=True,
is_training=training)
g_conv2_encoder = max_pool(g_conv2_encoder,
ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1],
padding='SAME')
g_conv2_encoder = tf.nn.dropout(g_conv2_encoder,
keep_prob=keep_prob)
with tf.variable_scope('fully_connected_relu'):
# pdb.set_trace()
g_fc1_encoder = tf.contrib.layers.flatten(g_conv2_encoder)
g_fc1_encoder = tf.contrib.layers.fully_connected(
g_fc1_encoder, 8, trainable=True, scope='fc_relu')
with tf.variable_scope('fully_connected_sigmoid'):
g_fc2_encoder = tf.contrib.layers.fully_connected(
g_fc1_encoder,
1,
activation_fn=tf.nn.sigmoid,
trainable=True,
scope='fc_sigmoid')
g_conv_encoder = g_fc2_encoder
# need to concatenate feature map
# g_conv_encoder = tf.contrib.layers.flatten(g_conv_encoder)
self.reuse = True
self.variables = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES,
scope='RelationModule')
return g_conv_encoder
def atrous_pool2d(value, ksize, rate, padding, name=None, pooling_type="MAX"):
with ops.name_scope(name, "atrous_pool2d", [value]) as name:
value = ops.convert_to_tensor(value, name="value")
if rate < 1:
raise ValueError("rate {} cannot be less than one".format(rate))
if rate == 1:
if pooling_type == "MAX":
value = nn_ops.max_pool(value=value,
ksize=ksize,
strides=[1, 1, 1, 1],
padding=padding)
return value
elif pooling_type == "AVG":
value = nn_ops.avg_pool(value=value,
ksize=ksize,
strides=[1, 1, 1, 1],
padding=padding)
return value
else:
raise ValueError("Invalid pooling type")
# We have two padding contributions. The first is used for converting "SAME"
# to "VALID". The second is required so that the height and width of the
# zero-padded value tensor are multiples of rate.
# Padding required to reduce to "VALID" convolution
if padding == "SAME":
# Handle filters whose shape is unknown during graph creation.
# if filters.get_shape().is_fully_defined():
# filter_shape = filters.get_shape().as_list()
# else:
# filter_shape = array_ops.shape(filters)
# filter_height, filter_width = filter_shape[0], filter_shape[1]
kernel_height, kernel_width = ksize[1], ksize[2]
# Spatial dimensions of the filters and the upsampled filters in which we
# introduce (rate - 1) zeros between consecutive filter values.
kernel_height_up = kernel_height + (kernel_height - 1) * (rate - 1)
kernel_width_up = kernel_width + (kernel_width - 1) * (rate - 1)
pad_height = kernel_height_up - 1
pad_width = kernel_width_up - 1
# When pad_height (pad_width) is odd, we pad more to bottom (right),
# following the same convention as conv2d().
pad_top = pad_height // 2
pad_bottom = pad_height - pad_top
pad_left = pad_width // 2
pad_right = pad_width - pad_left
elif padding == "VALID":
pad_top = 0
pad_bottom = 0
pad_left = 0
pad_right = 0
else:
raise ValueError("Invalid padding")
# Handle input whose shape is unknown during graph creation.
if value.get_shape().is_fully_defined():
value_shape = value.get_shape().as_list()
else:
value_shape = array_ops.shape(value)
in_height = value_shape[1] + pad_top + pad_bottom
in_width = value_shape[2] + pad_left + pad_right
# More padding so that rate divides the height and width of the input.
pad_bottom_extra = (rate - in_height % rate) % rate
pad_right_extra = (rate - in_width % rate) % rate
# The paddings argument to space_to_batch includes both padding components.
space_to_batch_pad = [[pad_top, pad_bottom + pad_bottom_extra],
[pad_left, pad_right + pad_right_extra]]
value = array_ops.space_to_batch(input=value,
paddings=space_to_batch_pad,
block_size=rate)
if pooling_type == "MAX":
value = nn_ops.max_pool(value=value,
ksize=ksize,
strides=[1, 1, 1, 1],
padding="VALID",
name=name)
elif pooling_type == "AVG":
value = nn_ops.avg_pool(value=value,
ksize=ksize,
strides=[1, 1, 1, 1],
padding="VALID",
name=name)
else:
raise ValueError("Invalid pooling type")
# The crops argument to batch_to_space is just the extra padding component.
batch_to_space_crop = [[0, pad_bottom_extra], [0, pad_right_extra]]
value = array_ops.batch_to_space(input=value,
crops=batch_to_space_crop,
block_size=rate)
return value
def __call__(self, support_target_images, training=False, keep_prob=1.0):
"""
Runs the CNN producing the embeddings and the gradients.
:param image_input: Image input to produce embeddings for. [batch_size, 28, 28, 1]
:param training: A flag indicating training or evaluation
:param keep_prob: A tf placeholder of type tf.float32 indicating the amount of dropout applied
:return: Embeddings of size [batch_size, 64]
"""
[bs, kn, w, h, c] = support_target_images.get_shape().as_list()
support_target_images = tf.reshape(support_target_images, shape=[bs*kn, w, h, c])
with tf.variable_scope('extractor', reuse=self.reuse):
with tf.variable_scope('conv_layers'):
# 84*84
with tf.variable_scope('g_conv1'):
g_conv1_encoder = tf.layers.conv2d(support_target_images, self.layer_sizes[0], [3, 3], strides=(1, 1),
padding='SAME')
g_conv1_encoder = tf.contrib.layers.batch_norm(g_conv1_encoder, updates_collections=None, decay=0.99,
scale=True, center=True, is_training=training)
g_conv1_encoder = relu(g_conv1_encoder, name='outputs')
g_conv1_encoder = max_pool(g_conv1_encoder, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1],
padding='SAME')
g_conv1_encoder = tf.nn.dropout(g_conv1_encoder, keep_prob=keep_prob)
# 42*42
with tf.variable_scope('g_conv2'):
g_conv2_encoder = tf.layers.conv2d(g_conv1_encoder, self.layer_sizes[1], [3, 3], strides=(1, 1),
padding='SAME')
g_conv2_encoder = tf.contrib.layers.batch_norm(g_conv2_encoder, updates_collections=None, decay=0.99,
scale=True, center=True, is_training=training)
g_conv2_encoder = relu(g_conv2_encoder, name='outputs')
g_conv2_encoder = max_pool(g_conv2_encoder, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1],
padding='SAME')
# 21*21
with tf.variable_scope('g_conv3'):
g_conv3_encoder = tf.layers.conv2d(g_conv2_encoder, self.layer_sizes[2], [3, 3], strides=(1, 1),
padding='SAME')
g_conv3_encoder = tf.contrib.layers.batch_norm(g_conv3_encoder, updates_collections=None, decay=0.99,
scale=True, center=True, is_training=training)
g_conv3_encoder = relu(g_conv3_encoder, name='outputs')
g_conv3_encoder = max_pool(g_conv3_encoder, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1],
padding='SAME')
# 11*11
with tf.variable_scope('g_conv4'):
g_conv4_encoder = tf.layers.conv2d(g_conv3_encoder, self.layer_sizes[3], [3, 3], strides=(1, 1),
padding='SAME')
g_conv4_encoder = tf.contrib.layers.batch_norm(g_conv4_encoder, updates_collections=None, decay=0.99,
scale=True, center=True, is_training=training)
g_conv4_encoder = relu(g_conv4_encoder, name='outputs') # ?
self.reuse = True
self.variables = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='conv_layers')
[bskn, we, he, ce] = g_conv4_encoder.get_shape().as_list()
embeddings = tf.reshape(g_conv4_encoder, [bs, kn, we, he, ce])
# print_params(self.variables, name="Feature Extractor")
return embeddings
def atrous_pool2d(value,ksize, rate, padding, name=None, pooling_type="MAX"):
with ops.name_scope(name, "atrous_pool2d", [value]) as name:
value = ops.convert_to_tensor(value, name="value")
if rate < 1:
raise ValueError("rate {} cannot be less than one".format(rate))
if rate == 1:
if pooling_type == "MAX":
value = nn_ops.max_pool(value=value,
ksize=ksize,
strides=[1, 1, 1, 1],
padding=padding)
return value
elif pooling_type == "AVG":
value = nn_ops.avg_pool(value=value,
ksize=ksize,
strides=[1, 1, 1, 1],
padding=padding)
return value
else:
raise ValueError("Invalid pooling type")
# We have two padding contributions. The first is used for converting "SAME"
# to "VALID". The second is required so that the height and width of the
# zero-padded value tensor are multiples of rate.
# Padding required to reduce to "VALID" convolution
if padding == "SAME":
# Handle filters whose shape is unknown during graph creation.
# if filters.get_shape().is_fully_defined():
# filter_shape = filters.get_shape().as_list()
# else:
# filter_shape = array_ops.shape(filters)
# filter_height, filter_width = filter_shape[0], filter_shape[1]
kernel_height, kernel_width = ksize[1], ksize[2]
# Spatial dimensions of the filters and the upsampled filters in which we
# introduce (rate - 1) zeros between consecutive filter values.
kernel_height_up = kernel_height + (kernel_height - 1) * (rate - 1)
kernel_width_up = kernel_width + (kernel_width - 1) * (rate - 1)
pad_height = kernel_height_up - 1
pad_width = kernel_width_up - 1
# When pad_height (pad_width) is odd, we pad more to bottom (right),
# following the same convention as conv2d().
pad_top = pad_height // 2
pad_bottom = pad_height - pad_top
pad_left = pad_width // 2
pad_right = pad_width - pad_left
elif padding == "VALID":
pad_top = 0
pad_bottom = 0
pad_left = 0
pad_right = 0
else:
raise ValueError("Invalid padding")
# Handle input whose shape is unknown during graph creation.
if value.get_shape().is_fully_defined():
value_shape = value.get_shape().as_list()
else:
value_shape = array_ops.shape(value)
in_height = value_shape[1] + pad_top + pad_bottom
in_width = value_shape[2] + pad_left + pad_right
# More padding so that rate divides the height and width of the input.
pad_bottom_extra = (rate - in_height % rate) % rate
pad_right_extra = (rate - in_width % rate) % rate
# The paddings argument to space_to_batch includes both padding components.
space_to_batch_pad = [[pad_top, pad_bottom + pad_bottom_extra],
[pad_left, pad_right + pad_right_extra]]
value = array_ops.space_to_batch(input=value,
paddings=space_to_batch_pad,
block_size=rate)
if pooling_type == "MAX":
value = nn_ops.max_pool(value=value,
ksize=ksize,
strides=[1, 1, 1, 1],
padding="VALID",
name=name)
elif pooling_type == "AVG":
value = nn_ops.avg_pool(value=value,
ksize=ksize,
strides=[1, 1, 1, 1],
padding="VALID",
name=name)
else:
raise ValueError("Invalid pooling type")
# The crops argument to batch_to_space is just the extra padding component.
batch_to_space_crop = [[0, pad_bottom_extra], [0, pad_right_extra]]
value = array_ops.batch_to_space(input=value,
crops=batch_to_space_crop,
block_size=rate)
return value
def __call__(self, image_input, training=False, keep_prob=1.0):
"""
Runs the CNN producing the embeddings and the gradients.
:param image_input: Image input to produce embeddings for. [batch_size, 320, 480, 1]
:param training: A flag indicating training or evaluation
:param keep_prob: A tf placeholder of type tf.float32 indicating the amount of dropout applied
:return: Embeddings of size [batch_size, 64]
"""
def leaky_relu(x, leak=0.2, name=''):
return tf.maximum(x, x * leak, name=name)
with tf.variable_scope('g', reuse=self.reuse):
with tf.variable_scope('conv_layers'):
with tf.variable_scope('g_conv1'):
self.g_conv1_encoder = tf.layers.conv2d(image_input, self.layer_sizes[0], [3, 3], strides=(1, 1),
padding='VALID')
self.g_conv1_encoder = leaky_relu(self.g_conv1_encoder, name='outputs')
self.g_conv1_encoder = tf.contrib.layers.batch_norm(self.g_conv1_encoder, updates_collections=None, decay=0.99,
scale=True, center=True, is_training=training)
self.g_conv1_encoder = max_pool(self.g_conv1_encoder, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1],
padding='SAME')
self.g_conv1_encoder = tf.nn.dropout(self.g_conv1_encoder, keep_prob=keep_prob)
with tf.variable_scope('g_conv2'):
self.g_conv2_encoder = tf.layers.conv2d(self.g_conv1_encoder, self.layer_sizes[1], [3, 3], strides=(1, 1),
padding='VALID')
self.g_conv2_encoder = leaky_relu(self.g_conv2_encoder, name='outputs')
self.g_conv2_encoder = tf.contrib.layers.batch_norm(self.g_conv2_encoder, updates_collections=None,
decay=0.99,
scale=True, center=True, is_training=training)
self.g_conv2_encoder = max_pool(self.g_conv2_encoder, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1],
padding='SAME')
self.g_conv2_encoder = tf.nn.dropout(self.g_conv2_encoder, keep_prob=keep_prob)
with tf.variable_scope('g_conv3'):
self.g_conv3_encoder = tf.layers.conv2d(self.g_conv2_encoder, self.layer_sizes[2], [3, 3], strides=(2, 2),
padding='VALID')
self.g_conv3_encoder = leaky_relu(self.g_conv3_encoder, name='outputs')
self.g_conv3_encoder = tf.contrib.layers.batch_norm(self.g_conv3_encoder, updates_collections=None,
decay=0.99,
scale=True, center=True, is_training=training)
self.g_conv3_encoder = max_pool(self.g_conv3_encoder, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1],
padding='SAME')
self.g_conv3_encoder = tf.nn.dropout(self.g_conv3_encoder, keep_prob=keep_prob)
with tf.variable_scope('g_conv4'):
self.g_conv4_encoder = tf.layers.conv2d(self.g_conv3_encoder, self.layer_sizes[3], [3, 3], strides=(2, 2),
padding='VALID')
self.g_conv4_encoder = leaky_relu(self.g_conv4_encoder, name='outputs')
self.g_conv4_encoder = tf.contrib.layers.batch_norm(self.g_conv4_encoder, updates_collections=None,
decay=0.99,
scale=True, center=True, is_training=training)
self.g_conv4_encoder = max_pool(self.g_conv4_encoder, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1],
padding='SAME')
self.g_conv4_encoder = tf.nn.dropout(self.g_conv4_encoder, keep_prob=keep_prob)
conv4_oneimage = tf.expand_dims(tf.maximum(self.g_conv4_encoder[0,], 0), 0) # summary_image request [batch_size, height, width, nchannels]
conv4_max = tf.reduce_max(conv4_oneimage)
conv4_oneimage = tf.reduce_mean(conv4_oneimage, 3, keep_dims = True) / conv4_max * 255
tf.summary.image('conv4%d' % 0, conv4_oneimage)
image_oneimage = tf.expand_dims(image_input[0], 0)
tf.summary.image('image%d' % 0, image_oneimage)
self.g_conv_encoder = self.g_conv4_encoder
# g_conv_encoder = tf.contrib.layers.flatten(g_conv_encoder)
self.reuse = True
self.variables = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='g')
self.layers['g_conv1'] = self.g_conv1_encoder
self.layers['g_conv2'] = self.g_conv2_encoder
self.layers['g_conv3'] = self.g_conv3_encoder
self.layers['g_conv4'] = self.g_conv4_encoder
return self.g_conv_encoder
def __call__(self, image_input, training=False, keep_prob=1.0):
"""
Runs the CNN producing the embeddings and the gradients.
:param image_input: Image input to produce embeddings for. [batch_size, 28, 28, 1]
:param training: A flag indicating training or evaluation
:param keep_prob: A tf placeholder of type tf.float32 indicating the amount of dropout applied
:return: Embeddings of size [batch_size, 64]
"""
def leaky_relu(x, leak=0.2, name=''):
return tf.maximum(x, x * leak, name=name)
with tf.variable_scope('g', reuse=self.reuse):
with tf.variable_scope('conv_layers'):
with tf.variable_scope('g_conv1'):
g_conv1_encoder = tf.layers.conv2d(image_input,
self.layer_sizes[0],
[3, 3],
strides=(1, 1),
padding='VALID')
g_conv1_encoder = leaky_relu(g_conv1_encoder,
name='outputs')
g_conv1_encoder = tf.contrib.layers.batch_norm(
g_conv1_encoder,
updates_collections=None,
decay=0.99,
scale=True,
center=True,
is_training=training)
g_conv1_encoder = max_pool(g_conv1_encoder,
ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1],
padding='SAME')
g_conv1_encoder = tf.nn.dropout(g_conv1_encoder,
keep_prob=keep_prob)
with tf.variable_scope('g_conv2'):
g_conv2_encoder = tf.layers.conv2d(g_conv1_encoder,
self.layer_sizes[1],
[3, 3],
strides=(1, 1),
padding='VALID')
g_conv2_encoder = leaky_relu(g_conv2_encoder,
name='outputs')
g_conv2_encoder = tf.contrib.layers.batch_norm(
g_conv2_encoder,
updates_collections=None,
decay=0.99,
scale=True,
center=True,
is_training=training)
g_conv2_encoder = max_pool(g_conv2_encoder,
ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1],
padding='SAME')
g_conv2_encoder = tf.nn.dropout(g_conv2_encoder,
keep_prob=keep_prob)
with tf.variable_scope('g_conv3'):
g_conv3_encoder = tf.layers.conv2d(g_conv2_encoder,
self.layer_sizes[2],
[3, 3],
strides=(1, 1),
padding='VALID')
g_conv3_encoder = leaky_relu(g_conv3_encoder,
name='outputs')
g_conv3_encoder = tf.contrib.layers.batch_norm(
g_conv3_encoder,
updates_collections=None,
decay=0.99,
scale=True,
center=True,
is_training=training)
g_conv3_encoder = max_pool(g_conv3_encoder,
ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1],
padding='SAME')
g_conv3_encoder = tf.nn.dropout(g_conv3_encoder,
keep_prob=keep_prob)
with tf.variable_scope('g_conv4'):
g_conv4_encoder = tf.layers.conv2d(g_conv3_encoder,
self.layer_sizes[3],
[2, 2],
strides=(1, 1),
padding='VALID')
g_conv4_encoder = leaky_relu(g_conv4_encoder,
name='outputs')
g_conv4_encoder = tf.contrib.layers.batch_norm(
g_conv4_encoder,
updates_collections=None,
decay=0.99,
scale=True,
center=True,
is_training=training)
g_conv4_encoder = max_pool(g_conv4_encoder,
ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1],
padding='SAME')
g_conv4_encoder = tf.nn.dropout(g_conv4_encoder,
keep_prob=keep_prob)
g_conv_encoder = g_conv4_encoder
g_conv_encoder = tf.contrib.layers.flatten(g_conv_encoder)
self.reuse = True
self.variables = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES,
scope='g')
return g_conv_encoder
