def model(self):
d, s, m, r = self.model_params
# Feature Extraction
size = self.padding + 1
weights = tf.get_variable('w1', shape=[size, size, 1, d], initializer=tf.variance_scaling_initializer(0.1))
biases = tf.get_variable('b1', initializer=tf.zeros([d]))
features = tf.nn.conv2d(self.images, weights, strides=[1,1,1,1], padding='VALID', data_format='NHWC')
features = tf.nn.bias_add(features, biases, data_format='NHWC')
# Shrinking
if self.model_params[1] > 0:
features = self.prelu(features, 1)
weights = tf.get_variable('w2', shape=[1, 1, d, s], initializer=tf.variance_scaling_initializer(2))
biases = tf.get_variable('b2', initializer=tf.zeros([s]))
features = tf.nn.conv2d(features, weights, strides=[1,1,1,1], padding='SAME', data_format='NHWC')
features = tf.nn.bias_add(features, biases, data_format='NHWC')
else:
s = d
conv = features
# Mapping (# mapping layers = m)
with tf.variable_scope("mapping_block") as scope:
for ri in range(r):
for i in range(3, m + 3):
weights = tf.get_variable('w{}'.format(i), shape=[3, 3, s, s], initializer=tf.variance_scaling_initializer(2))
biases = tf.get_variable('b{}'.format(i), initializer=tf.zeros([s]))
if i > 3:
conv = self.prelu(conv, i)
conv = tf.nn.conv2d(conv, weights, strides=[1,1,1,1], padding='SAME', data_format='NHWC')
conv = tf.nn.bias_add(conv, biases, data_format='NHWC')
if i == m + 2:
conv = self.prelu(conv, m + 3)
weights = tf.get_variable('w{}'.format(m + 3), shape=[1, 1, s, s], initializer=tf.variance_scaling_initializer(2))
biases = tf.get_variable('b{}'.format(m + 3), initializer=tf.zeros([s]))
conv = tf.nn.conv2d(conv, weights, strides=[1,1,1,1], padding='SAME', data_format='NHWC')
conv = tf.nn.bias_add(conv, biases, data_format='NHWC')
conv = tf.add(conv, features)
scope.reuse_variables()
conv = self.prelu(conv, 2)
# Expanding
if self.model_params[1] > 0:
expand_weights = tf.get_variable('w{}'.format(m + 4), shape=[1, 1, s, d], initializer=tf.variance_scaling_initializer(2))
expand_biases = tf.get_variable('b{}'.format(m + 4), initializer=tf.zeros([d]))
conv = tf.nn.conv2d(conv, expand_weights, strides=[1,1,1,1], padding='SAME', data_format='NHWC')
conv = tf.nn.bias_add(conv, expand_biases, data_format='NHWC')
conv = self.prelu(conv, m + 4)
# Sub-pixel convolution
size = self.radius * 2 + 1
deconv_weights = tf.get_variable('deconv_w', shape=[size, size, d, self.scale**2], initializer=tf.variance_scaling_initializer(0.01))
deconv_biases = tf.get_variable('deconv_b', initializer=tf.zeros([self.scale**2]))
deconv = tf.nn.conv2d(conv, deconv_weights, strides=[1,1,1,1], padding='SAME', data_format='NHWC')
deconv = tf.nn.bias_add(deconv, deconv_biases, data_format='NHWC')
if self.scale > 1:
deconv = tf.depth_to_space(deconv, self.scale, name='pixel_shuffle', data_format='NHWC')
return deconv
def SubpixelConv2D(*args, **kwargs):
kwargs['output_dim'] = 4 * kwargs['output_dim']
output = lib.ops.conv2d.Conv2D(*args, **kwargs)
output = tf.transpose(output, [0, 2, 3, 1])
output = tf.depth_to_space(output, 2)
output = tf.transpose(output, [0, 3, 1, 2])
return output
def build_generator(self,input_shapeA,input_shapeB):#unet
if(self.load(self.config.resource.generator_json_path,self.config.resource.generator_weights_path)):
return self.model
else:#init
print(f'init network parameters')
inputsA = Input(input_shapeA,name='imageSmall')#None,None,6
inputsB = Input(input_shapeB,name='imageUp')#None,None,3
#layer 1
F_ = Conv2D(filters = 32, kernel_size = (3, 3), strides = (1,1), padding = 'same')(inputsA)#conv1
F_0 = self.__unet1(F_)#32
F_1 = self.__RDB(F_0,32,6,32)#RDB1
F_2 = self.__RDB(F_1,32,6,32)#RDB2
F_3 = self.__RDB(F_2,32,6,32)#RDB3
FF = concatenate([F_1, F_2,F_3], axis=3)
FdLF = Conv2D(filters = 32, kernel_size = (1, 1), strides = (1,1), padding = 'same')(FF)
FGF = Conv2D(filters = 32, kernel_size = (3, 3), strides = (1,1), padding = 'same')(FdLF)
FDF = Add()([FGF, F_])
us = Conv2D(filters = 32*4, kernel_size = (3, 3), strides = (1,1), padding = 'same')(FDF)
us = Lambda(lambda x: tf.depth_to_space(x,2))(us)#x2(upsample),32
d3 = Conv2D(filters = 3, kernel_size = (3, 3), strides = (1,1), padding = 'same')(us)
d3 = Activation('tanh')(d3)
d3 = Lambda(lambda x: x/2+0.5)(d3)
combined = concatenate([inputsB, d3], axis=3)#blur-generator,6
o2 = self.__unet2(combined)
model = Model(inputs=[inputsA,inputsB], outputs=o2, name='generator')
return model
def hyper_decode(self, inputs):
with tf.variable_scope('decoder', reuse=tf.AUTO_REUSE):
hyper_decoder_rnn_input = tf.layers.conv2d(inputs=inputs, filters=128, kernel_size=[
3, 3], strides=(1, 1), padding='same', name='hyper_decoder_rnn_input')
self.hiddens1 = rnn_conv('hyper_decoder_rnn_conv_1',
hyper_decoder_rnn_input, self.hiddens1, 128, [3, 3], (1, 1))
d_rnn_h1 = tf.depth_to_space(self.hiddens1[0], 2)
self.hiddens2 = rnn_conv('hyper_decoder_rnn_conv_2',
d_rnn_h1, self.hiddens2, 128, [3, 3], (1, 1))
d_rnn_h2 = tf.depth_to_space(self.hiddens2[0], 2)
hyper_output = tf.layers.conv2d(inputs=d_rnn_h2, filters=128, kernel_size=[
3, 3], strides=(1, 1), padding='same', name='hyper_outputs', activation=None)
return hyper_output
def decoder(self, x):
with tf.variable_scope(f"codebook", reuse=True):
embedding = tf.get_variable("codebook",
shape=[self.n_hid, self.num_tokens],
dtype=tf.float32)
x = tf.matmul(x, embedding, transpose_b=True)
if self.bf16:
x = tf.cast(x, tf.bfloat16)
with tf.variable_scope("decoder"):
for block, (stack,
channels) in enumerate(reversed(self.convblocks)):
with tf.variable_scope(f"block_{block}"):
for i in range(stack):
with tf.variable_scope(f"layer_{i}"):
if i == 0:
# upsample
x = self.conv2dtranspose(x,
channels, (4, 4),
(2, 2),
padding="SAME",
name=f"conv_upsample")
else:
# normal residual block
def decoder_block(x, channels=channels):
out = self.conv2d(x,
channels, (3, 3), (1, 1),
padding="SAME",
name=f"conv_in")
# out = self.norm(out, name=f"bn_in")
out = self.activation(out, name=f"activ")
out = self.conv2d(out,
channels, (3, 3), (1, 1),
padding="SAME",
name=f"conv_out")
# out = self.norm(out, name=f"bn_out")
return out
res_out = recompute_grad(
decoder_block, self.bf16
)(x) if self.recompute_grad else decoder_block(
x)
x = x + res_out
x = self.conv2d(x, self.num_ch * self.stack_factor**2, (1, 1),
(1, 1))
if self.bf16:
x = tf.cast(x, tf.float32)
if self.stack_factor > 1:
x = tf.depth_to_space(x, self.stack_factor)
return x
def model(self):
d = self.model_params
m = len(d) + 2
# Feature Extraction
size = self.padding + 1
weights = tf.get_variable(
'w1',
shape=[size, size, 1, d[0]],
initializer=tf.variance_scaling_initializer(0.1))
biases = tf.get_variable('b1', initializer=tf.zeros([d[0]]))
conv = tf.nn.conv2d(self.images,
weights,
strides=[1, 1, 1, 1],
padding='VALID',
data_format='NHWC')
conv = tf.nn.bias_add(conv, biases, data_format='NHWC')
conv = self.prelu(conv, 1)
# Mapping (# mapping layers = m)
for i in range(3, m):
weights = tf.get_variable(
'w{}'.format(i),
shape=[3, 3, d[i - 3], d[i - 2]],
initializer=tf.variance_scaling_initializer(2))
biases = tf.get_variable('b{}'.format(i),
initializer=tf.zeros([d[i - 2]]))
conv = tf.nn.conv2d(conv,
weights,
strides=[1, 1, 1, 1],
padding='SAME',
data_format='NHWC')
conv = tf.nn.bias_add(conv, biases, data_format='NHWC')
conv = self.prelu(conv, i)
# Sub-pixel convolution
size = self.radius * 2 + 1
deconv_weights = tf.get_variable(
'deconv_w',
shape=[size, size, d[-1], self.scale**2],
initializer=tf.variance_scaling_initializer(0.01))
deconv_biases = tf.get_variable('deconv_b',
initializer=tf.zeros([self.scale**2]))
deconv = tf.nn.conv2d(conv,
deconv_weights,
strides=[1, 1, 1, 1],
padding='SAME',
data_format='NHWC')
deconv = tf.nn.bias_add(deconv, deconv_biases, data_format='NHWC')
deconv = tf.depth_to_space(deconv,
self.scale,
name='pixel_shuffle',
data_format='NHWC')
return deconv
def decode(self, inputs):
with tf.variable_scope('decoder', reuse=tf.AUTO_REUSE):
decoder_rnn_input = tf.layers.conv2d(inputs=inputs, filters=128, kernel_size=[
3, 3], strides=(1, 1), padding='same', name='decoder_rnn_input')
self.hiddens1 = rnn_conv('decoder_rnn_conv_1',
decoder_rnn_input, self.hiddens1, 512, [2, 2], (1, 1))
d_rnn_h1 = tf.depth_to_space(self.hiddens1[0], 2)
self.hiddens2 = rnn_conv('decoder_rnn_conv_2',
d_rnn_h1, self.hiddens2, 512, [3, 3], (1, 1))
d_rnn_h2 = tf.depth_to_space(self.hiddens2[0], 2)
self.hiddens3 = rnn_conv('decoder_rnn_conv_3',
d_rnn_h2, self.hiddens3, 256, [3, 3], (1, 1))
d_rnn_h3 = tf.depth_to_space(self.hiddens3[0], 2)
self.hiddens4 = rnn_conv('decoder_rnn_conv_4',
d_rnn_h3, self.hiddens4, 128, [3, 3], (1, 1))
d_rnn_h4 = tf.depth_to_space(self.hiddens4[0], 2)
output = tf.layers.conv2d(inputs=d_rnn_h4, filters=3, kernel_size=[
3, 3], strides=(1, 1), padding='same', name='output', activation=tf.nn.tanh)
return output / 2
def build_pixel_shuffler_layer(self, name, h, scale, input_filters, output_filters, activator=None, depthwise_separable=False):
with tf.variable_scope(name):
if (depthwise_separable):
self.build_depthwise_separable_conv(name + "_CNN", h, self.cnn_size, input_filters, scale * scale * output_filters,
use_batch_norm=False,
use_bias=True)
else:
self.build_conv(name + "_CNN", h, self.cnn_size, input_filters, scale * scale * output_filters,
use_batch_norm=False,
use_bias=True)
self.H.append(tf.depth_to_space(self.H[-1], scale))
self.build_activator(self.H[-1], output_filters, activator, base_name=name)
def setUp(self):
super(DepthToSpaceOpHandlerTest, self).setUp()
# Test a Identity -> DepthToSpace -> Identity chain of ops.
inputs = tf.zeros([2, 4, 4, 4])
id1 = tf.identity(inputs)
dts = tf.depth_to_space(id1, 2)
tf.identity(dts)
g = tf.get_default_graph()
# Declare OpSlice and OpGroup for ops of interest.
self.id1_op = g.get_operation_by_name('Identity')
self.id1_op_slice = orm.OpSlice(self.id1_op, orm.Slice(0, 4))
self.id1_op_group = orm.OpGroup(
self.id1_op_slice, omit_source_op_slices=[self.id1_op_slice])
self.id1_op_slice0 = orm.OpSlice(self.id1_op, orm.Slice(0, 1))
self.id1_op_slice1 = orm.OpSlice(self.id1_op, orm.Slice(1, 1))
self.id1_op_slice2 = orm.OpSlice(self.id1_op, orm.Slice(2, 1))
self.id1_op_slice3 = orm.OpSlice(self.id1_op, orm.Slice(3, 1))
self.dts_op = g.get_operation_by_name('DepthToSpace')
self.dts_op_slice = orm.OpSlice(self.dts_op, orm.Slice(0, 1))
self.dts_op_group = orm.OpGroup(
self.dts_op_slice, omit_source_op_slices=[self.dts_op_slice])
self.id2_op = g.get_operation_by_name('Identity_1')
self.id2_op_slice = orm.OpSlice(self.id2_op, orm.Slice(0, 1))
self.id2_op_group = orm.OpGroup(
self.id2_op_slice, omit_source_op_slices=[self.id2_op_slice])
# Create mock OpRegularizerManager with custom mapping of OpSlice and
# OpGroup.
self.mock_op_reg_manager = mock.create_autospec(
orm.OpRegularizerManager)
self.op_slice_dict = {
self.id1_op: [self.id1_op_slice],
self.dts_op: [self.dts_op_slice],
self.id2_op: [self.id2_op_slice],
}
def get_op_slices(op):
return self.op_slice_dict.get(op)
def get_op_group(op_slice):
return self.op_group_dict.get(op_slice)
self.mock_op_reg_manager.get_op_slices.side_effect = get_op_slices
self.mock_op_reg_manager.get_op_group.side_effect = get_op_group
self.mock_op_reg_manager.is_source_op.return_value = False
self.mock_op_reg_manager.ops = [self.id1_op, self.dts_op, self.id2_op]
def decompress_step(source, hparams, first_relu, is_2d, name):
"""Decompression function."""
with tf.variable_scope(name):
shape = common_layers.shape_list(source)
multiplier = 4 if is_2d else 2
kernel = (1, 1) if is_2d else (1, 1)
thicker = common_layers.conv_block(source,
hparams.hidden_size * multiplier,
[((1, 1), kernel)],
first_relu=first_relu,
name="decompress_conv")
if is_2d:
return tf.depth_to_space(thicker, 2)
return tf.reshape(thicker,
[shape[0], shape[1] * 2, 1, hparams.hidden_size])
def demosaic(bayer_images):
"""Bilinearly demosaics a batch of RGGB Bayer images."""
bayer_images.shape.assert_is_compatible_with((None, None, None, 4))
# This implementation exploits how edges are aligned when upsampling with
# tf.image.resize_bilinear().
with tf.name_scope(None, 'demosaic'):
shape = tf.shape(bayer_images)
shape = [shape[1] * 2, shape[2] * 2]
red = bayer_images[Ellipsis, 0:1]
red = tf.image.resize_bilinear(red, shape)
green_red = bayer_images[Ellipsis, 1:2]
green_red = tf.image.flip_left_right(green_red)
green_red = tf.image.resize_bilinear(green_red, shape)
green_red = tf.image.flip_left_right(green_red)
green_red = tf.space_to_depth(green_red, 2)
green_blue = bayer_images[Ellipsis, 2:3]
green_blue = tf.image.flip_up_down(green_blue)
green_blue = tf.image.resize_bilinear(green_blue, shape)
green_blue = tf.image.flip_up_down(green_blue)
green_blue = tf.space_to_depth(green_blue, 2)
green_at_red = (green_red[Ellipsis, 0] + green_blue[Ellipsis, 0]) / 2
green_at_green_red = green_red[Ellipsis, 1]
green_at_green_blue = green_blue[Ellipsis, 2]
green_at_blue = (green_red[Ellipsis, 3] + green_blue[Ellipsis, 3]) / 2
green_planes = [
green_at_red, green_at_green_red, green_at_green_blue,
green_at_blue
]
green = tf.depth_to_space(tf.stack(green_planes, axis=-1), 2)
blue = bayer_images[Ellipsis, 3:4]
blue = tf.image.flip_up_down(tf.image.flip_left_right(blue))
blue = tf.image.resize_bilinear(blue, shape)
blue = tf.image.flip_up_down(tf.image.flip_left_right(blue))
rgb_images = tf.concat([red, green, blue], axis=-1)
return rgb_images
def UpsampleConv(name,
input_dim,
output_dim,
filter_size,
inputs,
he_init=True,
biases=True):
output = inputs
output = tf.concat([output, output, output, output], axis=1)
output = tf.transpose(output, [0, 2, 3, 1])
output = tf.depth_to_space(output, 2)
output = tf.transpose(output, [0, 3, 1, 2])
output = lib.ops.conv2d.Conv2D(name,
input_dim,
output_dim,
filter_size,
output,
he_init=he_init,
biases=biases)
return output
def position_sensitive_crop_regions(image,
boxes,
crop_size,
num_spatial_bins,
global_pool):
"""Position-sensitive crop and pool rectangular regions from a feature grid.
The output crops are split into `spatial_bins_y` vertical bins
and `spatial_bins_x` horizontal bins. For each intersection of a vertical
and a horizontal bin the output values are gathered by performing
`tf.image.crop_and_resize` (bilinear resampling) on a a separate subset of
channels of the image. This reduces `depth` by a factor of
`(spatial_bins_y * spatial_bins_x)`.
When global_pool is True, this function implements a differentiable version
of position-sensitive RoI pooling used in
[R-FCN detection system](https://arxiv.org/abs/1605.06409).
When global_pool is False, this function implements a differentiable version
of position-sensitive assembling operation used in
[instance FCN](https://arxiv.org/abs/1603.08678).
Args:
image: A `Tensor`. Must be one of the following types: `uint8`, `int8`,
`int16`, `int32`, `int64`, `half`, `float32`, `float64`.
A 3-D tensor of shape `[image_height, image_width, depth]`.
Both `image_height` and `image_width` need to be positive.
boxes: A `Tensor` of type `float32`.
A 2-D tensor of shape `[num_boxes, 4]`. Each box is specified in
normalized coordinates `[y1, x1, y2, x2]`. A normalized coordinate value
of `y` is mapped to the image coordinate at `y * (image_height - 1)`, so
as the `[0, 1]` interval of normalized image height is mapped to
`[0, image_height - 1] in image height coordinates. We do allow y1 > y2,
in which case the sampled crop is an up-down flipped version of the
original image. The width dimension is treated similarly.
crop_size: A list of two integers `[crop_height, crop_width]`. All
cropped image patches are resized to this size. The aspect ratio of the
image content is not preserved. Both `crop_height` and `crop_width` need
to be positive.
num_spatial_bins: A list of two integers `[spatial_bins_y, spatial_bins_x]`.
Represents the number of position-sensitive bins in y and x directions.
Both values should be >= 1. `crop_height` should be divisible by
`spatial_bins_y`, and similarly for width.
The number of image channels should be divisible by
(spatial_bins_y * spatial_bins_x).
Suggested value from R-FCN paper: [3, 3].
global_pool: A boolean variable.
If True, we perform average global pooling on the features assembled from
the position-sensitive score maps.
If False, we keep the position-pooled features without global pooling
over the spatial coordinates.
Note that using global_pool=True is equivalent to but more efficient than
running the function with global_pool=False and then performing global
average pooling.
Returns:
position_sensitive_features: A 4-D tensor of shape
`[num_boxes, K, K, crop_channels]`,
where `crop_channels = depth / (spatial_bins_y * spatial_bins_x)`,
where K = 1 when global_pool is True (Average-pooled cropped regions),
and K = crop_size when global_pool is False.
Raises:
ValueError: Raised in four situations:
`num_spatial_bins` is not >= 1;
`num_spatial_bins` does not divide `crop_size`;
`(spatial_bins_y*spatial_bins_x)` does not divide `depth`;
`bin_crop_size` is not square when global_pool=False due to the
constraint in function space_to_depth.
"""
total_bins = 1
bin_crop_size = []
for (num_bins, crop_dim) in zip(num_spatial_bins, crop_size):
if num_bins < 1:
raise ValueError('num_spatial_bins should be >= 1')
if crop_dim % num_bins != 0:
raise ValueError('crop_size should be divisible by num_spatial_bins')
total_bins *= num_bins
bin_crop_size.append(crop_dim // num_bins)
if not global_pool and bin_crop_size[0] != bin_crop_size[1]:
raise ValueError('Only support square bin crop size for now.')
ymin, xmin, ymax, xmax = tf.unstack(boxes, axis=1)
spatial_bins_y, spatial_bins_x = num_spatial_bins
# Split each box into spatial_bins_y * spatial_bins_x bins.
position_sensitive_boxes = []
for bin_y in range(spatial_bins_y):
step_y = (ymax - ymin) / spatial_bins_y
for bin_x in range(spatial_bins_x):
step_x = (xmax - xmin) / spatial_bins_x
box_coordinates = [ymin + bin_y * step_y,
xmin + bin_x * step_x,
ymin + (bin_y + 1) * step_y,
xmin + (bin_x + 1) * step_x,
]
position_sensitive_boxes.append(tf.stack(box_coordinates, axis=1))
image_splits = tf.split(value=image, num_or_size_splits=total_bins, axis=2)
image_crops = []
for (split, box) in zip(image_splits, position_sensitive_boxes):
if split.shape.is_fully_defined() and box.shape.is_fully_defined():
crop = tf.squeeze(
matmul_crop_and_resize(
tf.expand_dims(split, axis=0), tf.expand_dims(box, axis=0),
bin_crop_size),
axis=0)
else:
crop = tf.image.crop_and_resize(
tf.expand_dims(split, 0), box,
tf.zeros(tf.shape(boxes)[0], dtype=tf.int32), bin_crop_size)
image_crops.append(crop)
if global_pool:
# Average over all bins.
position_sensitive_features = tf.add_n(image_crops) / len(image_crops)
# Then average over spatial positions within the bins.
position_sensitive_features = tf.reduce_mean(
position_sensitive_features, [1, 2], keepdims=True)
else:
# Reorder height/width to depth channel.
block_size = bin_crop_size[0]
if block_size >= 2:
image_crops = [tf.space_to_depth(
crop, block_size=block_size) for crop in image_crops]
# Pack image_crops so that first dimension is for position-senstive boxes.
position_sensitive_features = tf.stack(image_crops, axis=0)
# Unroll the position-sensitive boxes to spatial positions.
position_sensitive_features = tf.squeeze(
tf.batch_to_space_nd(position_sensitive_features,
block_shape=[1] + num_spatial_bins,
crops=tf.zeros((3, 2), dtype=tf.int32)),
axis=[0])
# Reorder back the depth channel.
if block_size >= 2:
position_sensitive_features = tf.depth_to_space(
position_sensitive_features, block_size=block_size)
return position_sensitive_features
def network(input):
#Xavier initializer
initializer = tf.initializers.glorot_uniform()
filter0 = tf.Variable(initializer([3, 3, 4, 32]))
b0 = tf.Variable(tf.zeros([32]))
conv1 = tf.nn.conv2d(input, filter0, [1, 1, 1, 1], padding='SAME')
conv1 = tf.nn.bias_add(conv1, b0)
conv1 = lrelu(conv1)
filter1 = tf.Variable(initializer([3, 3, 32, 32]))
b1 = tf.Variable(tf.zeros([32]))
conv1 = tf.nn.conv2d(conv1, filter1, [1, 1, 1, 1], padding='SAME')
conv1 = tf.nn.bias_add(conv1, b1)
conv1 = lrelu(conv1)
pool1 = tf.nn.max_pool(conv1, [1, 2, 2, 1], [1, 2, 2, 1], padding='SAME')
filter2 = tf.Variable(initializer([3, 3, 32, 64]))
b2 = tf.Variable(tf.zeros([64]))
conv2 = tf.nn.conv2d(pool1, filter2, [1, 1, 1, 1], padding='SAME')
conv2 = tf.nn.bias_add(conv2, b2)
conv2 = lrelu(conv2)
filter3 = tf.Variable(initializer([3, 3, 64, 64]))
b3 = tf.Variable(tf.zeros([64]))
conv2 = tf.nn.conv2d(conv2, filter3, [1, 1, 1, 1], padding='SAME')
conv2 = tf.nn.bias_add(conv2, b3)
conv2 = lrelu(conv2)
pool2 = tf.nn.max_pool(conv2, [1, 2, 2, 1], [1, 2, 2, 1], padding='SAME')
filter4 = tf.Variable(initializer([3, 3, 64, 128]))
b4 = tf.Variable(tf.zeros([128]))
conv3 = tf.nn.conv2d(pool2, filter4, [1, 1, 1, 1], padding='SAME')
conv3 = tf.nn.bias_add(conv3, b4)
conv3 = lrelu(conv3)
filter5 = tf.Variable(initializer([3, 3, 128, 128]))
b5 = tf.Variable(tf.zeros([128]))
conv3 = tf.nn.conv2d(conv3, filter5, [1, 1, 1, 1], padding='SAME')
conv3 = tf.nn.bias_add(conv3, b5)
conv3 = lrelu(conv3)
pool3 = tf.nn.max_pool(conv3, [1, 2, 2, 1], [1, 2, 2, 1], padding='SAME')
filter6 = tf.Variable(initializer([3, 3, 128, 256]))
b6 = tf.Variable(tf.zeros([256]))
conv4 = tf.nn.conv2d(pool3, filter6, [1, 1, 1, 1], padding='SAME')
conv4 = tf.nn.bias_add(conv4, b6)
conv4 = lrelu(conv4)
filter7 = tf.Variable(initializer([3, 3, 256, 256]))
b7 = tf.Variable(tf.zeros([256]))
conv4 = tf.nn.conv2d(conv4, filter7, [1, 1, 1, 1], padding='SAME')
conv4 = tf.nn.bias_add(conv4, b7)
conv4 = lrelu(conv4)
pool4 = tf.nn.max_pool(conv4, [1, 2, 2, 1], [1, 2, 2, 1], padding='SAME')
filter8 = tf.Variable(initializer([3, 3, 256, 512]))
b8 = tf.Variable(tf.zeros([512]))
conv5 = tf.nn.conv2d(pool4, filter8, [1, 1, 1, 1], padding='SAME')
conv5 = tf.nn.bias_add(conv5, b8)
conv5 = lrelu(conv5)
filter9 = tf.Variable(initializer([3, 3, 512, 512]))
b9 = tf.Variable(tf.zeros([512]))
conv5 = tf.nn.conv2d(conv5, filter9, [1, 1, 1, 1], padding='SAME')
conv5 = tf.nn.bias_add(conv5, b9)
conv5 = lrelu(conv5)
up6 = upsample_and_concat(conv5, conv4, 256, 512) #todo:bug
filter10 = tf.Variable(initializer([3, 3, 512, 256]))
b10 = tf.Variable(tf.zeros([256]))
conv6 = tf.nn.conv2d(up6, filter10, [1, 1, 1, 1], padding='SAME')
conv6 = tf.nn.bias_add(conv6, b10)
conv6 = lrelu(conv6)
filter11 = tf.Variable(initializer([3, 3, 256, 256]))
b11 = tf.Variable(tf.zeros([256]))
conv6 = tf.nn.conv2d(conv6, filter11, [1, 1, 1, 1], padding='SAME')
conv6 = tf.nn.bias_add(conv6, b11)
conv6 = lrelu(conv6)
up7 = upsample_and_concat(conv6, conv3, 128, 256)
filter12 = tf.Variable(initializer([3, 3, 256, 128]))
b12 = tf.Variable(tf.zeros([128]))
conv7 = tf.nn.conv2d(up7, filter12, [1, 1, 1, 1], padding='SAME')
conv7 = tf.nn.bias_add(conv7, b12)
conv7 = lrelu(conv7)
filter13 = tf.Variable(initializer([3, 3, 128, 128]))
b13 = tf.Variable(tf.zeros([128]))
conv7 = tf.nn.conv2d(conv7, filter13, [1, 1, 1, 1], padding='SAME')
conv7 = tf.nn.bias_add(conv7, b13)
conv7 = lrelu(conv7)
up8 = upsample_and_concat(conv7, conv2, 64, 128)
filter14 = tf.Variable(initializer([3, 3, 128, 64]))
b14 = tf.Variable(tf.zeros([64]))
conv8 = tf.nn.conv2d(up8, filter14, [1, 1, 1, 1], padding='SAME')
conv8 = tf.nn.bias_add(conv8, b14)
conv8 = lrelu(conv8)
filter15 = tf.Variable(initializer([3, 3, 64, 64]))
b15 = tf.Variable(tf.zeros([64]))
conv8 = tf.nn.conv2d(conv8, filter15, [1, 1, 1, 1], padding='SAME')
conv8 = tf.nn.bias_add(conv8, b15)
conv8 = lrelu(conv8)
up9 = upsample_and_concat(conv8, conv1, 32, 64)
filter16 = tf.Variable(initializer([3, 3, 64, 32]))
b16 = tf.Variable(tf.zeros([32]))
conv9 = tf.nn.conv2d(up9, filter16, [1, 1, 1, 1], padding='SAME')
conv9 = tf.nn.bias_add(conv9, b16)
conv9 = lrelu(conv9)
filter17 = tf.Variable(initializer([3, 3, 32, 32]))
b17 = tf.Variable(tf.zeros([32]))
conv9 = tf.nn.conv2d(conv9, filter17, [1, 1, 1, 1], padding='SAME')
conv9 = tf.nn.bias_add(conv9, b17)
conv9 = lrelu(conv9)
filter18 = tf.Variable(initializer([1, 1, 32, 12]))
b18 = tf.Variable(tf.zeros([12]))
conv10 = tf.nn.conv2d(conv9, filter18, [1, 1, 1, 1], padding='SAME')
conv10 = tf.nn.bias_add(conv10, b18)
out = tf.depth_to_space(conv10, 2)
return out
def network(input):
conv1 = slim.conv2d(input,
32, [3, 3],
rate=1,
activation_fn=lrelu,
scope='g_conv1_1')
conv1 = slim.conv2d(conv1,
32, [3, 3],
rate=1,
activation_fn=lrelu,
scope='g_conv1_2')
pool1 = slim.max_pool2d(conv1, [2, 2], padding='SAME')
conv2 = slim.conv2d(pool1,
64, [3, 3],
rate=1,
activation_fn=lrelu,
scope='g_conv2_1')
conv2 = slim.conv2d(conv2,
64, [3, 3],
rate=1,
activation_fn=lrelu,
scope='g_conv2_2')
pool2 = slim.max_pool2d(conv2, [2, 2], padding='SAME')
conv3 = slim.conv2d(pool2,
128, [3, 3],
rate=1,
activation_fn=lrelu,
scope='g_conv3_1')
conv3 = slim.conv2d(conv3,
128, [3, 3],
rate=1,
activation_fn=lrelu,
scope='g_conv3_2')
pool3 = slim.max_pool2d(conv3, [2, 2], padding='SAME')
conv4 = slim.conv2d(pool3,
256, [3, 3],
rate=1,
activation_fn=lrelu,
scope='g_conv4_1')
conv4 = slim.conv2d(conv4,
256, [3, 3],
rate=1,
activation_fn=lrelu,
scope='g_conv4_2')
pool4 = slim.max_pool2d(conv4, [2, 2], padding='SAME')
conv5 = slim.conv2d(pool4,
512, [3, 3],
rate=1,
activation_fn=lrelu,
scope='g_conv5_1')
conv5 = slim.conv2d(conv5,
512, [3, 3],
rate=1,
activation_fn=lrelu,
scope='g_conv5_2')
up6 = upsample_and_concat(conv5, conv4, 256, 512)
conv6 = slim.conv2d(up6,
256, [3, 3],
rate=1,
activation_fn=lrelu,
scope='g_conv6_1')
conv6 = slim.conv2d(conv6,
256, [3, 3],
rate=1,
activation_fn=lrelu,
scope='g_conv6_2')
up7 = upsample_and_concat(conv6, conv3, 128, 256)
conv7 = slim.conv2d(up7,
128, [3, 3],
rate=1,
activation_fn=lrelu,
scope='g_conv7_1')
conv7 = slim.conv2d(conv7,
128, [3, 3],
rate=1,
activation_fn=lrelu,
scope='g_conv7_2')
up8 = upsample_and_concat(conv7, conv2, 64, 128)
conv8 = slim.conv2d(up8,
64, [3, 3],
rate=1,
activation_fn=lrelu,
scope='g_conv8_1')
conv8 = slim.conv2d(conv8,
64, [3, 3],
rate=1,
activation_fn=lrelu,
scope='g_conv8_2')
up9 = upsample_and_concat(conv8, conv1, 32, 64)
conv9 = slim.conv2d(up9,
32, [3, 3],
rate=1,
activation_fn=lrelu,
scope='g_conv9_1')
conv9 = slim.conv2d(conv9,
32, [3, 3],
rate=1,
activation_fn=lrelu,
scope='g_conv9_2')
conv10 = slim.conv2d(conv9,
32, [2, 2],
stride=2,
rate=1,
activation_fn=None,
scope='g_conv10_1')
conv10 = slim.conv2d(conv10,
12, [1, 1],
rate=1,
activation_fn=None,
scope='g_conv10_2')
out = tf.depth_to_space(conv10, 2)
return out
