def build_model(self, inputs, labels, is_training):
# pad inputs to size 224x224x3 - NOTE: may change to bilinear upsampling
pad = int((self.image_size - self.height) / 2)
inputs = tf.pad(inputs, [[0, 0], [pad, pad], [pad, pad], [0, 0]])
# convolution with 11x11 kernel and stride 4 (new size: 55x55x96)
self.network = ops.convolution(inputs, self.channels, 96, 11, 96, stride=4,
padding='VALID', is_training=is_training, scope='conv1')
# pooling with 3x3 kernel and stride 2 (new size: 27x27x96)
self.network = ops.pooling(self.network, k_size=3, scope='pool1')
# convolution with 5x5 kernel and stride 1 (new size: 27x27x256)
self.network = ops.convolution(self.network, 96, 256, 5, 256,
is_training=is_training, scope='conv2')
# pooling with 3x3 kernel and stride 2 (new size: 13x13x256)
self.network = ops.pooling(self.network, k_size=3, scope='pool2')
# convolution with 3x3 kernel and stride 1 (new size: 13x13x384)
self.network = ops.convolution(self.network, 256, 384, 3, 384, batch_norm=False,
is_training=is_training, scope='conv3')
# convolution with 3x3 kernel and stride 1 (new size: 13x13x384)
self.network = ops.convolution(self.network, 384, 384, 3, 384, batch_norm=False,
is_training=is_training, scope='conv4')
# convolution with 3x3 kernel and stride 1 (new size: 13x13x256)
self.network = ops.convolution(self.network, 384, 256, 3, 256, batch_norm=False,
is_training=is_training, scope='conv5')
# pooling with 3x3 kernel and stride 2 (new size: 6x6x256)
self.network = ops.pooling(self.network, k_size=3, scope='pool3')
# flatten (new size: 9216)
self.network = ops.flatten(self.network, scope='flatten')
# fully connected layer (new size: 4096)
self.network = ops.dense(self.network, 9216, 4096, dropout=True, dropout_rate=0.2,
is_training=is_training, scope='fc1')
# fully connected layer (new size: 1024) -- Original Paper Size: 4096 (for ImageNet)
self.network = ops.dense(self.network, 4096, 1024, dropout=True, dropout_rate=0.2,
is_training=is_training, scope='fc2')
# output layer (new size: 10) -- Original Paper Size: 1000 (for ImageNet)
self.network = ops.dense(self.network, 1024, 10, activation=None,
is_training=is_training, scope='fc3')
self.loss = ops.loss(self.network, labels, scope='loss')
if is_training:
self.optimizer = ops.optimize(self.loss, self.learning_rate, scope='update')
def build_model(self, inputs, labels, is_training=False):
self.network = ops.convolution(inputs,
self.channels,
50,
5,
50,
is_training=is_training,
scope='conv1')
self.network = ops.pooling(self.network, scope='pool1')
self.network = ops.convolution(self.network,
50,
20,
5,
20,
is_training=is_training,
scope='conv2')
self.network = ops.pooling(self.network, scope='pool2')
self.network = ops.flatten(self.network, scope='flatten')
self.network = ops.dense(self.network,
self.network.get_shape().as_list()[1],
200,
scope='fc1')
self.network = ops.dense(self.network, 200, 50, scope='fc2')
self.network = ops.dense(self.network,
50,
10,
activation=None,
scope='fc3')
self.loss = ops.loss(self.network, labels, scope='loss')
self.accuracy = ops.accuracy(self.network, labels, scope='accuracy')
if is_training:
self.optimizer = ops.optimize(self.loss,
self.learning_rate,
scope='update')
def inception_module(self, inputs, output_sizes, final_pool=False, scope=None):
"""
Inception module allowing for deeper networks with fewer parameters.
"""
with tf.variable_scope(scope, reuse=tf.AUTO_REUSE):
input_channels = tf.shape(inputs)[3]
net1 = ops.convolution(inputs, input_channels, output_sizes[0, 0], 1,
output_sizes[0, 0], is_training=is_training,
scope='net1')
net2 = ops.convolution(inputs, input_channels, output_sizes[0, 1], 1,
output_sizes[0, 1], is_training=is_training,
scope='net2a')
net2 = ops.convolution(net2, output_sizes[0, 1], output_sizes[1, 0],
3, output_sizes[1, 0], is_training=is_training,
scope='net2b')
net3 = ops.convolution(inputs, input_channels, output_sizes[0, 2], 1,
output_sizes[0, 2], is_training=is_training,
scope='net3a')
net3 = ops.convolution(net3, output_sizes[0, 2], output_sizes[1, 1],
5, output_sizes[1, 1], is_training=is_training,
scope='net3b')
net4 = ops.pooling(inputs, k_size=3, stride=1, padding='SAME', scope='pool')
net4 = ops.convolution(net4, input_channels, output_sizes[1, 2], 1,
output_sizes[1, 2], is_training=is_training,
scope='net4')
network = tf.concat([net1, net2, net3, net4], -1)
if final_pool:
network = ops.pooling(network, k_size=3, scope='outpool')
return network
def generator(masked_image,
batch_size,
image_dim,
is_train=True,
no_reuse=False):
with tf.variable_scope('generator') as scope:
if not (is_train or no_reuse):
scope.reuse_variables()
# input 180x256ximage_dim
#conv0_1
layer_num = 1
with tf.variable_scope('hidden' + str(layer_num)):
hidden = conv2d(masked_image,
32, (3, 3), (1, 1),
trainable=is_train)
hidden = tf.nn.relu(batch_norm(hidden, train=is_train))
#conv0_2
layer_num += 1
with tf.variable_scope('hidden' + str(layer_num)):
hidden = conv2d(hidden, 32, (3, 3), (1, 1), trainable=is_train)
hidden = tf.nn.relu(batch_norm(hidden, train=is_train))
# output 180*256*32
#pool0
layer_num += 1
with tf.variable_scope('hidden' + str(layer_num)):
hidden = pooling(hidden, (2, 2), (2, 2))
# output 90*128*32
#conv1_1_new
layer_num += 1
with tf.variable_scope('hidden' + str(layer_num)):
hidden = conv2d(hidden, 64, (3, 3), (1, 1), trainable=is_train)
hidden = tf.nn.relu(batch_norm(hidden, train=is_train))
#conv1_2
layer_num += 1
with tf.variable_scope('hidden' + str(layer_num)):
hidden = conv2d(hidden, 64, (3, 3), (1, 1), trainable=is_train)
hidden = tf.nn.relu(batch_norm(hidden, train=is_train))
#pool1
layer_num += 1
with tf.variable_scope('hidden' + str(layer_num)):
hidden = pooling(hidden, (2, 2), (2, 2))
#output 45*64*64
#conv2_1
layer_num += 1
with tf.variable_scope('hidden' + str(layer_num)):
hidden = conv2d(hidden, 128, (3, 3), (1, 1), trainable=is_train)
hidden = tf.nn.relu(batch_norm(hidden, train=is_train))
#conv2_2
layer_num += 1
with tf.variable_scope('hidden' + str(layer_num)):
hidden = conv2d(hidden, 128, (3, 3), (3, 2),
trainable=is_train) ###
hidden = tf.nn.relu(batch_norm(hidden, train=is_train))
#pool2
layer_num += 1
with tf.variable_scope('hidden' + str(layer_num)):
hidden = pooling(hidden, (2, 2), (1, 1)) ###
#output 15*32*128
#conv3_1
layer_num += 1
with tf.variable_scope('hidden' + str(layer_num)):
hidden = conv2d(hidden, 256, (3, 3), (1, 1), trainable=is_train)
hidden = tf.nn.relu(batch_norm(hidden, train=is_train))
#conv3_2
layer_num += 1
with tf.variable_scope('hidden' + str(layer_num)):
hidden = conv2d(hidden, 256, (3, 3), (1, 1), trainable=is_train)
hidden = tf.nn.relu(batch_norm(hidden, train=is_train))
#conv3_3
layer_num += 1
with tf.variable_scope('hidden' + str(layer_num)):
hidden = conv2d(hidden, 256, (3, 3), (1, 1), trainable=is_train)
hidden = tf.nn.relu(batch_norm(hidden, train=is_train))
#conv3_4
layer_num += 1
with tf.variable_scope('hidden' + str(layer_num)):
hidden = conv2d(hidden, 512, (3, 3), (3, 2), trainable=is_train)
hidden = tf.nn.relu(batch_norm(hidden, train=is_train))
#pool3
layer_num += 1
with tf.variable_scope('hidden' + str(layer_num)):
hidden = pooling(hidden, (2, 2), (1, 2))
#output 5*8*512
#fc3
layer_num += 1
with tf.variable_scope('hidden' + str(layer_num)):
hidden = tf.reshape(hidden, [batch_size, 5 * 8 * 512])
hidden = fully_connect(hidden, 5120, trainable=is_train)
hidden = tf.nn.relu(batch_norm(hidden, train=is_train))
# output 5120
#defc3
layer_num += 1
with tf.variable_scope('hidden' + str(layer_num)):
hidden = fully_connect(hidden, 20480, trainable=is_train)
hidden = tf.reshape(hidden, [batch_size, 5, 8, 512])
hidden = tf.nn.relu(batch_norm(hidden, train=is_train))
# output 5*8*512
#conv_decode3_4
layer_num += 1
with tf.variable_scope('hidden' + str(layer_num)):
hidden = transconv2d(hidden,
output_channel=512,
kernel=(3, 3),
stride=(1, 1),
trainable=is_train)
hidden = tf.nn.relu(batch_norm(hidden, train=is_train))
#output 5*8*512
#conv_decode3_3
layer_num += 1
with tf.variable_scope('hidden' + str(layer_num)):
hidden = transconv2d(hidden,
output_channel=512,
kernel=(3, 3),
stride=(1, 1),
trainable=is_train)
hidden = tf.nn.relu(batch_norm(hidden, train=is_train))
#conv_decode3_2
layer_num += 1
with tf.variable_scope('hidden' + str(layer_num)):
hidden = transconv2d(hidden,
output_channel=512,
kernel=(3, 3),
stride=(3, 2),
trainable=is_train)
hidden = tf.nn.relu(batch_norm(hidden, train=is_train))
#output 15*16*512
#conv_decode3_1
layer_num += 1
with tf.variable_scope('hidden' + str(layer_num)):
hidden = transconv2d(hidden,
output_channel=512,
kernel=(3, 3),
stride=(1, 1),
trainable=is_train)
hidden = tf.nn.relu(batch_norm(hidden, train=is_train))
#conv_decode2_2
layer_num += 1
with tf.variable_scope('hidden' + str(layer_num)):
hidden = transconv2d(hidden,
output_channel=256,
kernel=(3, 3),
stride=(3, 1),
trainable=is_train)
hidden = tf.nn.relu(batch_norm(hidden, train=is_train))
#output 45*16*256
#conv_decode2_1
layer_num += 1
with tf.variable_scope('hidden' + str(layer_num)):
hidden = transconv2d(hidden,
output_channel=256,
kernel=(3, 3),
stride=(1, 1),
trainable=is_train)
hidden = tf.nn.relu(batch_norm(hidden, train=is_train))
#conv_decode1_2
layer_num += 1
with tf.variable_scope('hidden' + str(layer_num)):
hidden = transconv2d(hidden,
output_channel=128,
kernel=(3, 3),
stride=(1, 2),
trainable=is_train)
hidden = tf.nn.relu(batch_norm(hidden, train=is_train))
#output 45*32*128
#conv_decode1_1
layer_num += 1
with tf.variable_scope('hidden' + str(layer_num)):
hidden = transconv2d(hidden,
output_channel=128,
kernel=(3, 3),
stride=(1, 1),
trainable=is_train)
hidden = tf.nn.relu(batch_norm(hidden, train=is_train))
#conv_decode0_2
layer_num += 1
with tf.variable_scope('hidden' + str(layer_num)):
hidden = transconv2d(hidden,
output_channel=64,
kernel=(3, 3),
stride=(2, 2),
trainable=is_train)
hidden = tf.nn.relu(batch_norm(hidden, train=is_train))
#output 90*64*64
#conv_decode0_1
layer_num += 1
with tf.variable_scope('hidden' + str(layer_num)):
hidden = transconv2d(hidden,
output_channel=64,
kernel=(3, 3),
stride=(1, 1),
trainable=is_train)
hidden = tf.nn.relu(batch_norm(hidden, train=is_train))
#reconstruction
layer_num += 1
with tf.variable_scope('hidden' + str(layer_num)):
hidden = transconv2d(hidden,
output_channel=1,
kernel=(3, 3),
stride=(2, 1),
trainable=is_train)
hidden = tf.nn.relu(batch_norm(hidden, train=is_train))
#output 180*64*image_dim
return hidden
def build_model(self, inputs, labels, is_training):
pad = int((self.image_size - self.height) / 2)
inputs = tf.pad(inputs, [[0, 0], [pad, pad], [pad, pad], [0, 0]])
# convolution with 7x7 kernel and stride 2 (new size: 112x112x64)
self.network = ops.convolution(inputs,
self.channels,
64,
7,
64,
stride=2,
is_training=is_training,
scope='conv1')
# pooling with 3x3 kernel and stride 2 (new size: 56x56x64)
self.network = ops.pooling(self.network, k_size=3, scope='pool1')
# convolution with 1x1 kernel and stride 1 (new size: 56x56x192)
self.network = ops.convolution(self.network,
64,
192,
1,
192,
batch_norm=False,
is_training=is_training,
scope='conv2')
# convolution with 3x3 kernel and stride 1 (new size: 56x56x192)
self.network = ops.convolution(self.network,
192,
192,
3,
192,
is_training=is_training,
scope='conv3')
# pooling with 3x3 kernel and stride 2 (new size: 28x28x192)
self.network = ops.pooling(self.network, k_size=3, scope='pool2')
# inception module (3a)
self.network = self.inception_module(self.network,
[[64, 96, 16], [128, 32, 32]],
scope='incept1')
# inception module (3b)
self.network = self.inception_module(self.network,
[[128, 128, 32], [192, 96, 64]],
final_pool=True,
scope='incept' + str(i))
# inception module (4a)
self.network = self.inception_module(self.network,
[[192, 96, 16], [208, 48, 64]],
scope='incept' + str(i))
# auxiliary classifier
if is_training:
aux_loss1 = self.aux_classifier(self.network,
labels,
512,
is_training,
scope='auxclass1')
# inception module (4b)
self.network = self.inception_module(self.network,
[[160, 112, 24], [224, 64, 64]],
scope='incept' + str(i))
# inception module (4c)
self.network = self.inception_module(self.network,
[[128, 128, 24], [256, 64, 64]],
scope='incept' + str(i))
# inception module (4d)
self.network = self.inception_module(self.network,
[[112, 144, 32], [288, 64, 64]],
scope='incept' + str(i))
# auxiliary classifier
if is_training:
aux_loss2 = self.aux_classifier(self.network,
labels,
528,
is_training,
scope='auxclass2')
# inception module (4e)
self.network = self.inception_module(self.network,
[[256, 160, 32], [320, 128, 128]],
final_pool=True,
scope='incept' + str(i))
# inception module (5a)
self.network = self.inception_module(self.network,
[[256, 160, 32], [320, 128, 128]],
scope='incept' + str(i))
# inception module (5b)
self.network = self.inception_module(self.network,
[[384, 192, 48], [384, 128, 128]],
scope='incept' + str(i))
# pooling with 7x7 kernel and stride 1 (new size: 1x1x1024)
with tf.variable_scope('final_pool', reuse=tf.AUTO_REUSE):
self.network = tf.nn.avg_pool(self.network,
7,
1,
'SAME',
scope='pool')
# flatten (new size: 1024)
self.network = ops.flatten(self.network, scope='flatten')
# fully connected layer (new size: 1024)
self.network = ops.dense(self.network,
1024,
1024,
dropout=True,
dropout_rate=0.4,
is_training=is_training,
scope='fc1')
# output layer (new size: 10) -- Original Paper Size: 1000 (for ImageNet)
self.network = ops.dense(self.network,
1024,
10,
activation=None,
is_training=is_training,
scope='fc2')
loss = ops.loss(self.network, labels, scope='loss')
self.accuracy = ops.accuracy(self.network, labels, scope='accuracy')
if is_training: # if training use auxiliary classifiers as well
self.loss = loss + aux_loss1 + aux_loss2
self.optimizer = ops.optimize(self.loss,
self.learning_rate,
scope='update')
else:
self.loss = loss
def build_model(self, inputs, labels, is_training):
def res_block(inputs, in_channels, out_channels, is_training, idx):
net = ops.convolution(inputs,
in_channels[0],
out_channels[0],
1,
out_channels[0],
is_training=is_training,
scope='res%s_conv1' % idx)
net = ops.convolution(net,
in_channels[1],
out_channels[1],
3,
out_channels[1],
is_training=is_training,
scope='res%s_conv2' % idx)
net = ops.convolution(net,
in_channels[2],
out_channels[2],
1,
out_channels[2],
activation=None,
is_training=is_training,
scope='res%s_conv3' % idx)
return tf.nn.relu(inputs + net, scope='res%s_relu' % idx)
def res_conv_block(inputs, in_channel, out_channel, stride,
is_training, idx):
skip = ops.convolution(inputs,
in_channels[0],
out_channels[2],
1,
out_channels[2],
stride=stride,
activation=None,
is_training=is_training,
scope='res%s_skip' % idx)
net = ops.convolution(inputs,
in_channels[0],
out_channels[0],
1,
out_channels[0],
is_training=is_training,
scope='res%s_conv1' % idx)
net = ops.convolution(net,
in_channels[1],
out_channels[1],
3,
out_channels[1],
is_training=is_training,
scope='res%s_conv2' % idx)
net = ops.convolution(net,
in_channels[2],
out_channels[2],
1,
out_channels[2],
stride=stride,
activation=None,
is_training=is_training,
scope='res%s_conv3' % idx)
return tf.nn.relu(skip + net, scope='res%s_relu' % idx)
# pad inputs to size 224x224x3 - NOTE: may change to bilinear upsampling
pad = int((self.image_size - self.height) / 2)
inputs = tf.pad(inputs, [[0, 0], [pad, pad], [pad, pad], [0, 0]])
# convolution with 7x7 kernel and stride 2 (new size: 112x112x64)
self.network = ops.convolution(inputs,
self.channels,
64,
7,
64,
stride=2,
is_training=is_training,
scope='conv1')
# pooling with 3x3 kernel and stride 2 (new size: 56x56x64)
self.network = ops.pooling(self.network, k_size=3, scope='pool1')
# residual block 1
stride = 1
out_channels = [64, 64, 256]
self.network = res_conv_block(self.network, [64, 64, 64], out_channels,
stride, is_training, 1)
self.network = res_block(self.network, [256, 64, 64], out_channels,
is_training, 2)
self.network = res_block(self.network, [256, 64, 64], out_channels,
is_training, 3)
# residual block 2
stride = 2
out_channels = [128, 128, 512]
self.network = res_conv_block(self.network, [256, 128, 128],
out_channels, stride, is_training, 4)
self.network = res_block(self.network, [512, 128, 128], out_channels,
is_training, 5)
self.network = res_block(self.network, [512, 128, 128], out_channels,
is_training, 6)
self.network = res_block(self.network, [512, 128, 128], out_channels,
is_training, 7)
# residual block 3
stride = 2
out_channels = [256, 256, 1024]
self.network = res_conv_block(self.network, [512, 256, 256],
out_channels, stride, is_training, 8)
self.network = res_block(self.network, [1024, 256, 256], out_channels,
is_training, 9)
self.network = res_block(self.network, [1024, 256, 256], out_channels,
is_training, 10)
self.network = res_block(self.network, [1024, 256, 256], out_channels,
is_training, 11)
self.network = res_block(self.network, [1024, 256, 256], out_channels,
is_training, 12)
self.network = res_block(self.network, [1024, 256, 256], out_channels,
is_training, 13)
# residual block 4
stride = 2
out_channels = [512, 512, 2048]
self.network = res_conv_block(self.network, [1024, 512, 512],
out_channels, stride, is_training, 14)
self.network = res_block(self.network, [2048, 512, 512], out_channels,
is_training, 15)
self.network = res_block(self.network, [2048, 512, 512], out_channels,
is_training, 16)
# average pooling
self.network = tf.nn.avg_pool(self.network,
7,
1,
'SAME',
scope='avg_pool')
self.network = ops.flatten(self.network, scope='flatten')
# fully connected
self.network = ops.dense(self.network,
2048,
10,
activation=None,
is_training=is_training,
scope='fc')
self.loss = ops.loss(self.network, labels, scope='loss')
self.accuracy = ops.accuracy(self.network, labels, scope='accuracy')
if is_training:
self.optimizer = ops.optimize(self.loss,
self.learning_rate,
scope='update')
def build_model(self, inputs, labels, is_training):
# pad inputs to size 224x224x3 - NOTE: may change to bilinear upsampling
pad = int((self.image_size - self.height) / 2)
inputs = tf.pad(inputs, [[0, 0], [pad, pad], [pad, pad], [0, 0]])
# convolution with 3x3 kernel and stride 1 (new size: 224x224x64)
self.network = ops.convolution(inputs,
self.channels,
64,
3,
64,
is_training=is_training,
scope='conv1')
# convolution with 3x3 kernel and stride 1 (new size: 224x224x64)
self.network = ops.convolution(self.network,
64,
64,
3,
64,
is_training=is_training,
scope='conv2')
# pooling with 2x2 kernel and stride 2 (new size: 112x112x64)
self.network = ops.pooling(self.network, scope='pool1')
# convolution with 3x3 kernel and stride 1 (new size: 112x112x128)
self.network = ops.convolution(self.network,
64,
128,
3,
128,
is_training=is_training,
scope='conv3')
# convolution with 3x3 kernel and stride 1 (new size: 112x112x128)
self.network = ops.convolution(self.network,
128,
128,
3,
128,
is_training=is_training,
scope='conv4')
# pooling with 2x2 kernel and stride 2 (new size: 56x56x128)
self.network = ops.pooling(self.network, scope='pool2')
# convolution with 3x3 kernel and stride 1 (new size: 56x56x256)
self.network = ops.convolution(self.network,
128,
256,
3,
256,
is_training=is_training,
scope='conv5')
# 3 convolutions with 3x3 kernel and stride 1 (new size: 56x56x256)
for idx in range(6, 9):
self.network = ops.convolution(self.network,
256,
256,
3,
256,
is_training=is_training,
scope='conv' + str(idx))
# pooling with 2x2 kernel and stride 2 (new size: 28x28x256)
self.network = ops.pooling(self.network, scope='pool3')
# convolution with 3x3 kernel and stride 1 (new size: 28x28x512)
self.network = ops.convolution(self.network,
256,
512,
3,
512,
is_training=is_training,
scope='conv9')
# 3 convolutions with 3x3 kernel and stride 1 (new size: 28x28x512)
for idx in range(10, 13):
self.network = ops.convolution(self.network,
512,
512,
3,
512,
is_training=is_training,
scope='conv' + str(idx))
# pooling with 2x2 kernel and stride 2 (new size: 14x14x512)
self.network = ops.pooling(self.network, scope='pool4')
# 4 convolutions with 3x3 kernel and stride 1 (new size: 14x14x512)
for idx in range(13, 17):
self.network = ops.convolution(self.network,
512,
512,
3,
512,
is_training=is_training,
scope='conv' + str(idx))
# pooling with 2x2 kernel and stride 2 (new size: 7x7x512)
self.network = ops.pooling(self.network, scope='pool5')
# flatten (new size: 25088)
self.network = ops.flatten(self.network, scope='flatten')
# fully connected layer (new size: 4096)
self.network = ops.dense(self.network,
25088,
4096,
dropout=True,
dropout_rate=0.2,
is_training=is_training,
scope='fc1')
# fully connected layer (new size: 1024) -- Original Paper Size: 4096 (for ImageNet)
self.network = ops.dense(self.network,
4096,
1024,
dropout=True,
dropout_rate=0.2,
is_training=is_training,
scope='fc2')
# output layer (new size: 10) -- Original Paper Size: 1000 (for ImageNet)
self.network = ops.dense(self.network,
1024,
10,
activation=None,
is_training=is_training,
scope='fc3')
self.loss = ops.loss(self.network, labels, scope='loss')
self.accuracy = ops.accuracy(self.network, labels, scope='accuracy')
if is_training:
self.optimizer = ops.optimize(self.loss,
self.learning_rate,
scope='update')
def __call__(self, input):
with tf.variable_scope(self.name, reuse=self.reuse):
conv1_1 = ops.conv2d(input, [3, 3, 1, 64],
'conv1_1',
reuse=self.reuse)
conv1_2 = ops.conv2d(conv1_1, [3, 3, 64, 64],
'conv1_2',
reuse=self.reuse)
pooling_1 = ops.pooling(conv1_2, 'max', 'pooling_1')
conv2_1 = ops.conv2d(pooling_1, [3, 3, 64, 128],
'conv2_1',
reuse=self.reuse)
conv2_2 = ops.conv2d(conv2_1, [3, 3, 128, 128],
'conv2_2',
reuse=self.reuse)
pooling_2 = ops.pooling(conv2_2, 'max', 'pooling_2')
conv3_1 = ops.conv2d(pooling_2, [3, 3, 128, 256],
'conv3_1',
reuse=self.reuse)
conv3_2 = ops.conv2d(conv3_1, [3, 3, 256, 256],
'conv3_2',
reuse=self.reuse)
conv3_3 = ops.conv2d(conv3_2, [3, 3, 256, 256],
'conv3_3',
reuse=self.reuse)
pooling_3 = ops.pooling(conv3_3, 'max', 'pooling_3')
conv4_1 = ops.conv2d(pooling_3, [3, 3, 256, 512],
'conv4_1',
reuse=self.reuse)
conv4_2 = ops.conv2d(conv4_1, [3, 3, 512, 512],
'conv4_2',
reuse=self.reuse)
conv4_3 = ops.conv2d(conv4_2, [3, 3, 512, 512],
'conv4_3',
reuse=self.reuse)
pooling_4 = ops.pooling(conv4_3, 'max', 'pooling_4')
conv5_1 = ops.conv2d(pooling_4, [3, 3, 512, 512],
'conv5_1',
reuse=self.reuse)
conv5_2 = ops.conv2d(conv5_1, [3, 3, 512, 512],
'conv5_2',
reuse=self.reuse)
conv5_3 = ops.conv2d(conv5_2, [3, 3, 512, 512],
'conv5_3',
reuse=self.reuse)
pooling_5 = ops.pooling(conv5_3, 'max', 'pooling_5')
flatten = tf.contrib.layers.flatten(pooling_5)
fc_shape = flatten.get_shape().as_list()
fc_1 = ops.dense(flatten, [fc_shape[-1], 4096],
'fc_1',
reuse=self.reuse)
fc_2 = ops.dense(fc_1, [4096, 4096], 'fc_2', reuse=self.reuse)
fc_3 = ops.dense(fc_2, [4096, 4096], 'fc_3', reuse=self.reuse)
output = ops.dense(fc_3, [4096, 3],
'output',
activation='linear',
reuse=self.reuse)
self.reuse = True
return output
