def att_layer(self, inputs, W_name="W_att_"):
net = inputs
f = ne.conv2d(net, filters=self.att_filters[W_name+"f_0"], biases=None,
strides=self.att_f_strides, padding=self.att_f_padding) # [b, h, w, c]
g = ne.conv2d(net, filters=self.att_filters[W_name+"g_0"], biases=None,
strides=self.att_g_strides, padding=self.att_g_padding) # [b, h, w, c]
h = ne.conv2d(net, filters=self.att_filters[W_name+"h_0"], biases=None,
strides=self.att_h_strides, padding=self.att_h_padding) # [b, h, w, c]
if self.attention_type == "GOOGLE":
f = ne.max_pool_2x2(f) # [b, h/2, w/2, c]
h = ne.max_pool_2x2(h) # [b, h/2, w/2, c]
elif self.attention_type == "DUOCONV":
f = ne.max_pool_2x2(ne.max_pool_2x2(f)) # [b, h/4, w/4, c]
h = ne.max_pool_2x2(ne.max_pool_2x2(h)) # [b, h/4, w/4, c]
# N = h * w
s = tf.matmul(ne.hw_flatten(g), ne.hw_flatten(f), transpose_b=True) # [b, N, N]
beta = ne.softmax(s) # attention map, [b, N, N]
o = tf.matmul(beta, ne.hw_flatten(h)) # [b, N, C]
o = tf.reshape(o, shape=[tf.shape(inputs)[0]] + inputs.get_shape().as_list()[1:-1]+[self.att_o_channel_size]) # [b, h, w, C]
o = ne.conv2d(o, filters=self.att_filters[W_name+"o_0"], biases=None,
strides=self.att_o_strides, padding=self.att_o_padding) # [b, h, w, c]
net = self.att_gamma * o + net
return net
def res_blocks(self, inputs, W_name, b_name):
net = inputs
for res_id in range(self.num_res_block):
res_net = net
for layer_id in range(self.res_block_size):
filter_name = "{}{}_{}".format(W_name, res_id, layer_id)
bias_name = "{}{}_{}".format(b_name, res_id, layer_id)
curr_filter = self.res_filters[filter_name]
curr_bias = self.res_biases[bias_name]
#net = ne.leaky_brelu(net, self.res_leaky_ratio[layer_id], self.layer_low_bound, self.output_up_bound) # Nonlinear act
net = ne.leaky_relu(net, self.res_leaky_ratio[layer_id])
# convolution
net = ne.conv2d(net,
filters=curr_filter,
biases=curr_bias,
strides=self.res_strides[layer_id],
padding=self.res_padding[layer_id])
net += res_net
if self.use_norm == "BATCH":
net = ne.batch_norm(net, self.is_training)
elif self.use_norm == "LAYER":
net = ne.layer_norm(net, self.is_training)
net = tf.identity(net, name='res_output')
#import pdb; pdb.set_trace()
return net
def conv_res_groups(self, inputs, W_name="W_conv_", b_name="b_conv_"):
#net = tf.reshape(inputs, [-1, FLAGS.IMAGE_ROWS, FLAGS.IMAGE_COLS, self.img_channel])
net = inputs
for layer_id in range(self.num_conv):
filter_name = "{}{}".format(W_name, layer_id)
bias_name = "{}{}".format(b_name, layer_id)
curr_filter = self.conv_filters[filter_name]
curr_bias = self.conv_biases[bias_name]
# convolution
net = ne.conv2d(net,
filters=curr_filter,
biases=curr_bias,
strides=self.conv_strides[layer_id],
padding=self.conv_padding[layer_id])
# batch normalization
if self.use_norm == "BATCH":
net = ne.batch_norm(net, self.is_training)
elif self.use_norm == "LAYER":
net = ne.layer_norm(net, self.is_training)
#net = ne.leaky_brelu(net, self.conv_leaky_ratio[layer_id], self.layer_low_bound, self.output_up_bound) # Nonlinear act
net = ne.leaky_relu(net, self.conv_leaky_ratio[layer_id])
# res blocks
W_res_name = "W_g{}_res".format(layer_id)
b_res_name = "b_g{}_res".format(layer_id)
net = self.res_blocks(net, W_res_name, b_res_name)
net = tf.identity(net, name='conv_output')
#import pdb; pdb.set_trace()
return net
def _form_groups(net, start_layer, end_layer):
for layer_id in range(start_layer, end_layer):
filter_name = "{}{}".format(W_name, layer_id)
bias_name = "{}{}".format(b_name, layer_id)
curr_filter = self.conv_filters[filter_name]
curr_bias = self.conv_biases[bias_name]
# convolution
net = ne.conv2d(net,
filters=curr_filter,
biases=curr_bias,
strides=self.conv_strides[layer_id],
padding=self.conv_padding[layer_id])
# batch normalization
if self.use_norm == "BATCH":
net = ne.batch_norm(net, self.is_training)
elif self.use_norm == "LAYER":
net = ne.layer_norm(net, self.is_training)
#net = ne.leaky_brelu(net, self.conv_leaky_ratio[layer_id], self.layer_low_bound, self.output_up_bound) # Nonlinear act
net = ne.leaky_relu(net, self.conv_leaky_ratio[layer_id])
net = ne.drop_out(net, self.conv_drop_rate[layer_id],
self.is_training)
# res blocks
W_res_name = "W_g{}_res".format(layer_id)
b_res_name = "b_g{}_res".format(layer_id)
net = self.res_blocks(net,
W_res_name,
b_res_name,
scope="RES_{}".format(layer_id))
return net
def out_layer(self, inputs, W_name="W_out_", b_name="b_out_"):
layer_id = 0
net = inputs
filter_name = "{}{}".format(W_name, layer_id)
bias_name = "{}{}".format(b_name, layer_id)
curr_filter = self.out_filter[filter_name]
curr_bias = self.out_bias[bias_name]
# convolution
net = ne.conv2d(net,
filters=curr_filter,
biases=curr_bias,
strides=self.out_stride,
padding=self.out_padding)
if self.use_norm == "BATCH":
net = ne.batch_norm(net, self.is_training)
elif self.use_norm == "LAYER":
net = ne.layer_norm(net, self.is_training)
elif self.use_norm == "INSTA":
net = ne.instance_norm(net, self.is_training)
#net = ne.leaky_brelu(net, self.conv_leaky_ratio[layer_id], self.layer_low_bound, self.output_up_bound) # Nonlinear act
net = ne.leaky_relu(net, self.out_leaky_ratio)
#net = ne.max_pool_2x2(net) # Pooling
net = tf.identity(net, name='out_output')
#import pdb; pdb.set_trace()
return net
def out_layer_(self, inputs, out_name, curr_filter, curr_bias, out_norm):
net = inputs
# convolution
net = ne.conv2d(net, filters=curr_filter, biases=curr_bias,
strides=self.out_stride,
padding=self.out_padding)
if out_norm == "BATCH":
net = ne.batch_norm(net, self.is_training)
elif out_norm == "LAYER":
net = ne.layer_norm(net, self.is_training)
#net = ne.leaky_brelu(net, self.conv_leaky_ratio[layer_id], self.layer_low_bound, self.output_up_bound) # Nonlinear act
net = ne.leaky_relu(net, self.out_leaky_ratio)
#net = ne.max_pool_2x2(net) # Pooling
net = tf.identity(net, name=out_name)
#import pdb; pdb.set_trace()
return net
def conv_layers(self, inputs, W_name="W_conv", b_name="b_conv"):
net = tf.reshape(
inputs,
[-1, FLAGS.IMAGE_ROWS, FLAGS.IMAGE_COLS, FLAGS.NUM_CHANNELS])
for layer_id in range(self.num_conv):
filter_name = "{}{}".format(W_name, layer_id)
bias_name = "{}{}".format(b_name, layer_id)
curr_filter = self.conv_filters[filter_name]
curr_bias = self.conv_biases[bias_name]
# convolution
net = ne.conv2d(net, filters=curr_filter, biases=curr_bias)
# batch normalization
if self.use_batch_norm:
net = ne.batch_norm(net, self.is_training)
#net = ne.leaky_brelu(net, self.conv_leaky_ratio[layer_id], self.layer_low_bound, self.layer_up_bound) # Nonlinear act
net = ne.leaky_relu(net, self.conv_leaky_ratio[layer_id])
#net = ne.max_pool_2x2(net) # Pooling
net = tf.identity(net, name='output')
return net
