def build_model(tparams, model_options):
x = T.matrix('x', dtype='float64')
u = T.matrix('u', dtype='float64')
h_1 = batchnorm(
T.nnet.relu(
fflayer(tparams,
x,
model_options,
prefix='layer_1',
activ='linear')))
h_2 = batchnorm(
T.nnet.relu(
fflayer(tparams,
h_1,
model_options,
prefix='layer_2',
activ='linear')))
h_L = h_2
v = fflayer(tparams, h_L, model_options, prefix='layer_v', activ='linear')
m = fflayer(tparams, h_L, model_options, prefix='layer_m', activ='linear')
l = fflayer(tparams, h_L, model_options, prefix='layer_l', activ='linear')
p = T.sqr(l)
a = (-(u - m)**2 * p)
q = v + a
return x, u, m, v, q
def class_subnet(inputs, is_training):
with tf.variable_scope("class_subnet", reuse=tf.AUTO_REUSE):
for i in range(D_class):
inputs = swish(
batchnorm(
"bn1" + str(i),
conv("conv1" + str(i), inputs, W_bifpn, 3, 1, "SAME"),
is_training))
inputs = swish(
batchnorm(
"bn2" + str(i),
conv("conv2" + str(i), inputs, W_bifpn, 3, 1, "SAME"),
is_training))
inputs = swish(
batchnorm(
"bn3" + str(i),
conv("conv3" + str(i), inputs, W_bifpn, 3, 1, "SAME"),
is_training))
inputs = swish(
batchnorm(
"bn4" + str(i),
conv("conv4" + str(i), inputs, W_bifpn, 3, 1, "SAME"),
is_training))
inputs = conv("conv5", inputs, K * A, 3, 1, "SAME", True)
H, W = tf.shape(inputs)[1], tf.shape(inputs)[2]
inputs = tf.reshape(inputs, [-1, H * W * A, K])
return inputs
def encoder_block(inputs, kernel_size, stride, channel_out, name, mode):
with tf.variable_scope(name):
convolved = conv(inputs,
channel_out,
stride=stride,
kernel_size=kernel_size)
normalized = batchnorm(convolved, mode)
rectified = lrelu(normalized, 0.2)
return rectified
def decoder_block(inputs, kernel_size, stride, channel_out, name, mode, add):
with tf.variable_scope(name):
output = deconv(inputs,
channel_out,
kernel_size=kernel_size,
stride=stride,
add=add)
output = batchnorm(output, mode)
rectified = relu(output)
return rectified
def residual_block(inputs, output_channel, stride, scope):
with tf.variable_scope(scope):
net1 = Op.conv2(inputs,
3,
output_channel,
stride,
use_bias=False,
scope='conv_1')
net1 = Op.batchnorm(net1)
net1 = tf.nn.relu(net1)
net2 = Op.conv2(tf.concat([inputs, net1], -1),
3,
output_channel,
stride,
use_bias=False,
scope='conv_2')
net2 = Op.batchnorm(net2)
net2 = tf.nn.relu(net2)
return net2
def residual_block(inputs, output_channel, stride, scope):
with tf.variable_scope(scope):
net = Op.conv2(inputs,
3,
output_channel,
stride,
use_bias=False,
scope='conv_1')
net = Op.batchnorm(net)
net = Op.prelu_tf(net)
net = Op.conv2(net,
3,
output_channel,
stride,
use_bias=False,
scope='conv_2')
net = Op.batchnorm(net)
net = net + inputs
return net
def __call__(self, inputs, train_phase):
with tf.variable_scope(self.name):
inputs = tf.nn.relu(ops.conv("conv0", inputs, 64, 3, 1))
for d in np.arange(1, config.DEPTH - 1):
inputs = tf.nn.relu(
ops.batchnorm(
ops.conv("conv_" + str(d + 1), inputs, 64, 3, 1),
train_phase, "bn" + str(d)))
inputs = ops.conv("conv" + str(config.DEPTH - 1), inputs,
config.IMG_C, 3, 1)
return inputs
def __call__(self, inputs, train_phase):
with tf.variable_scope(self.name, reuse=tf.AUTO_REUSE):
# inputs = tf.random_crop(inputs, [-1, 70, 70, 3])
inputs = conv("conv1_1", inputs, 64, 3, 2)
inputs = leaky_relu(inputs, 0.2)
# inputs = conv("conv1_2", inputs, 64, 3, is_SN=True)
# inputs = leaky_relu(inputs, 0.2)
inputs = conv("conv2_1", inputs, 128, 3, 2)
inputs = batchnorm(inputs, train_phase, "BN1")
inputs = leaky_relu(inputs, 0.2)
# inputs = conv("conv2_2", inputs, 128, 3, is_SN=True)
# inputs = leaky_relu(inputs, 0.2)
inputs = conv("conv3_1", inputs, 256, 3, 2)
inputs = batchnorm(inputs, train_phase, "BN2")
inputs = leaky_relu(inputs, 0.2)
# inputs = conv("conv3_2", inputs, 256, 3, is_SN=True)
# inputs = leaky_relu(inputs, 0.2)
inputs = conv("conv4_1", inputs, 512, 3, 2)
inputs = batchnorm(inputs, train_phase, "BN3")
inputs = leaky_relu(inputs, 0.2)
# inputs = fully_connected("fc", inputs, 512, is_SN=True)
output = fully_connected("output", inputs, 1)
return output
def resnet_PanSharpening_model_dense(self, pan_img, ms_img):
def residual_block(inputs, output_channel, stride, scope):
with tf.variable_scope(scope):
net1 = Op.conv2(inputs,
3,
output_channel,
stride,
use_bias=False,
scope='conv_1')
net1 = Op.batchnorm(net1)
net1 = tf.nn.relu(net1)
net2 = Op.conv2(tf.concat([inputs, net1], -1),
3,
output_channel,
stride,
use_bias=False,
scope='conv_2')
net2 = Op.batchnorm(net2)
net2 = tf.nn.relu(net2)
return net2
with tf.variable_scope('Pan_model'):
if self.is_training:
with tf.name_scope('upscale'):
ms_img = tf.image.resize_images(
ms_img, [self.pan_size, self.pan_size], method=2)
inputs = tf.concat([ms_img, pan_img], axis=-1)
with tf.variable_scope('generator_unit'):
# The input layer
with tf.variable_scope('input_stage'):
net = Op.conv2(inputs, 3, 64, 1, scope='conv')
net = Op.batchnorm(net)
net = tf.nn.relu(net)
net = tf.concat([inputs, net], -1)
# The residual block parts
for i in range(1, 5 + 1, 1):
name_scope = 'resblock_%d' % (i)
net = residual_block(net, 64, 1, name_scope)
with tf.variable_scope('resblock_output'):
net = Op.conv2(net, 3, 4, 1, use_bias=False, scope='conv')
net = tf.tanh(net)
return net
def DenseNet(inputs, nums_out, growth_rate, train_phase, depth):
inputs = preprocess(inputs)
n = (depth - 4) // 3
inputs = conv("conv1", inputs, nums_out=16, k_size=3)
inputs = DenseBlock("DenseBlock1", inputs, n, growth_rate, train_phase)
inputs = Transition("Transition_Layer1",
inputs,
nums_out=growth_rate,
train_phase=train_phase)
inputs = DenseBlock("DenseBlock2", inputs, n, growth_rate, train_phase)
inputs = Transition("Transition_Layer2",
inputs,
nums_out=growth_rate,
train_phase=train_phase)
inputs = DenseBlock("DenseBlock3", inputs, n, growth_rate, train_phase)
inputs = batchnorm(inputs, train_phase, "BN")
inputs = relu(inputs)
inputs = global_avg_pooling(inputs)
inputs = fully_connected("FC", inputs, nums_out)
return inputs
def __init__(self, rng, input, n_in, n_out, W=None, b=None, activation=nnet.relu, prefix="hidden", batchnorm=False):
"""Generic hidden layer."""
self.input = input
if W is None:
if activation == tensor.tanh:
W_values = numpy.asarray(rng.uniform(
low=-numpy.sqrt(6. / (n_in + n_out)),
high=numpy.sqrt(6. / (n_in + n_out)),
size=(n_in, n_out)
), dtype=theano.config.floatX)
elif activation == nnet.sigmoid:
W_values = 4 * numpy.asarray(rng.uniform(
low=-numpy.sqrt(6. / (n_in + n_out)),
high=numpy.sqrt(6. / (n_in + n_out)),
size=(n_in, n_out)
), dtype=theano.config.floatX)
elif activation == nnet.relu or activation == nnet.softmax or activation is None:
W_values = numpy.asarray(0.01*rng.randn(n_in, n_out), dtype=theano.config.floatX)
else:
raise ValueError("Invalid activation: " + str(activation))
W = theano.shared(value=W_values, name="%s_W" % prefix,
borrow=True)
if b is None:
b_values = numpy.zeros((n_out,), dtype=theano.config.floatX)
# if activation == theano_utils.relu:
# b_values = 0.01*np.ones((d_out,), dtype=theano.config.floatX)
b = theano.shared(value=b_values, name="%s_b" % prefix,
borrow=True)
self.W = W
self.b = b
linear_output = tensor.dot(input, self.W) + self.b
if batchnorm:
lienar_output = ops.batchnorm(linear_output)
self.output = (linear_output
if activation is None else activation(linear_output))
self.parameters = [self.W, self.b]
def __call__(self, inputs, train_phase):
with tf.variable_scope(self.name):
inputs = conv("conv1", inputs, 64, 9)
inputs = prelu("alpha1", inputs)
skip_connection = tf.identity(inputs)
#The paper has 16 residual blocks
for b in range(1, self.B + 1):
inputs = B_residual_blocks("B"+str(b), inputs, train_phase)
# inputs = B_residual_blocks("B2", inputs, train_phase)
# inputs = B_residual_blocks("B3", inputs, train_phase)
# inputs = B_residual_blocks("B4", inputs, train_phase)
# inputs = B_residual_blocks("B5", inputs, train_phase)
inputs = conv("conv2", inputs, 64, 3)
inputs = batchnorm(inputs, train_phase, "BN")
inputs = inputs + skip_connection
inputs = conv("conv3", inputs, 256, 3)
inputs = pixelshuffler(inputs, 2)
inputs = prelu("alpha2", inputs)
inputs = conv("conv4", inputs, 256, 3)
inputs = pixelshuffler(inputs, 2)
inputs = prelu("alpha3", inputs)
inputs = conv("conv5", inputs, 3, 9)
return tf.nn.tanh(inputs)
def backbone(inputs, is_training):
arg_scope = resnet_arg_scope()
with slim.arg_scope(arg_scope):
_, end_points = resnet_v2_50(inputs, is_training=is_training)
C3 = end_points["resnet_v2_50/block2/unit_3/bottleneck_v2"]
C4 = end_points["resnet_v2_50/block3/unit_5/bottleneck_v2"]
C5 = end_points["resnet_v2_50/block4/unit_3/bottleneck_v2"]
P3 = swish(
batchnorm("bn1", conv("conv3", C3, W_bifpn, 3, 1, "SAME"),
is_training))
P4 = swish(
batchnorm("bn2", conv("conv4", C4, W_bifpn, 3, 1, "SAME"),
is_training))
P5 = swish(
batchnorm("bn3", conv("conv5", C5, W_bifpn, 3, 1, "SAME"),
is_training))
P6 = swish(
batchnorm("bn4", conv("conv6", C5, W_bifpn, 3, 2, "SAME"),
is_training))
P7 = swish(
batchnorm("bn5", conv("conv7", P6, W_bifpn, 3, 2, "SAME"),
is_training))
for i in range(D_bifpn):
P3, P4, P5, P6, P7 = bifpn_layer("bifpn" + str(i), P3, P4, P5, P6, P7,
is_training)
P3_class_logits = class_subnet(P3, is_training)
P3_box_logits = box_subnet(P3, is_training)
P4_class_logits = class_subnet(P4, is_training)
P4_box_logits = box_subnet(P4, is_training)
P5_class_logits = class_subnet(P5, is_training)
P5_box_logits = box_subnet(P5, is_training)
P6_class_logits = class_subnet(P6, is_training)
P6_box_logits = box_subnet(P6, is_training)
P7_class_logits = class_subnet(P7, is_training)
P7_box_logits = box_subnet(P7, is_training)
class_logits = tf.concat([
P3_class_logits, P4_class_logits, P5_class_logits, P6_class_logits,
P7_class_logits
],
axis=1)
box_logits = tf.concat([
P3_box_logits, P4_box_logits, P5_box_logits, P6_box_logits,
P7_box_logits
],
axis=1)
class_logits_dict = {
"P3": P3_class_logits,
"P4": P4_class_logits,
"P5": P5_class_logits,
"P6": P6_class_logits,
"P7": P7_class_logits
}
box_logits_dict = {
"P3": P3_box_logits,
"P4": P4_box_logits,
"P5": P5_box_logits,
"P6": P6_box_logits,
"P7": P7_box_logits
}
return class_logits, box_logits, class_logits_dict, box_logits_dict
# inputs = tf.placeholder(tf.float32, [None, IMG_H, IMG_W, 3])
# is_training = tf.placeholder(tf.bool)
# backbone(inputs, is_training)