def inference(self, x):
with tf.variable_scope("conv0"):
conv1 = utils.relu(utils.Bn(utils.conv2d(x, 64, 7, 7, 2, 2, bias=True), training=self.is_training))
with tf.name_scope("pool1"):
pool1 = utils.max_pool(conv1, 3, 3, 2, 2)
with tf.variable_scope("group0"):
res2a = self.residual(pool1, 256, name='block0')
res2b = self.residual(res2a, 256, name='block1')
res2c = self.residual(res2b, 256, name='block2')
with tf.variable_scope("group1"):
res3a = self.residual(res2c, 512, 2, name='block0')
res3b = self.residual(res3a, 512, name='block1')
res3c = self.residual(res3b, 512, name='block2')
res3d = self.residual(res3c, 512, name='block3')
with tf.variable_scope("group2"):
res4a = self.residual(res3d, 1024, 2, name='block0')
res4b = self.residual(res4a, 1024, name='block1')
res4c = self.residual(res4b, 1024, name='block2')
res4d = self.residual(res4c, 1024, name='block3')
res4e = self.residual(res4d, 1024, name='block4')
res4f = self.residual(res4e, 1024, name='block5')
with tf.variable_scope("group3"):
res5a = self.residual(res4f, 2048, 2, name='block0')
res5b = self.residual(res5a, 2048, name='block1')
res5c = self.residual(res5b, 2048, name='block2')
with tf.name_scope("pool5"):
pool5 = utils.global_pool(res5c)
with tf.variable_scope("linear"):
dropout = tf.nn.dropout(pool5, keep_prob=self.keep_prob)
out = utils.linear(dropout, 1000)
return out
def get_feature(self, X, rois, edge, is_training=False):
output = {}
print('############################')
layer4 = self.run_cnn(X,is_training)
output['gpool5'] = tf.reduce_mean(layer4, axis=[1, 2])
# ROI pooling layer
num_bbox = rois.shape.as_list()[1]
batch_size = rois.shape.as_list()[0]
roi_pool5 = roi_pool_layer(layer4, rois, 7, batch_size, name='ROIPooling')
roi_conv = global_pool(roi_pool5, name='roi_global_pool', ptype='max')
roi_conv = tf.reshape(tf.squeeze(roi_conv), [batch_size, num_bbox, -1])
output['roi_conv'] = roi_conv
v = self.placeholders['num_vertices']
h_dim = self.params['hidden_size']
e_dim = self.params['edge_dims']
o_dim = self.params['out_size']
h = tf.concat([output['gpool5'][:, None, :], output['roi_conv']], axis=1) # [b, v, h]
print(h.shape)
h = tf.nn.l2_normalize(h, axis=-1)
self.norm_init_h = h
in_dim = self.params['in_size']
init_h = tf.pad(h, [[0, 0], [0, 0], [0, o_dim-in_dim]])
big_number = 1e12
diag_I = tf.diag(tf.ones([v]))
diag_I = tf.stop_gradient(diag_I)
mask = tf.stop_gradient(tf.ones([v, v]) - tf.diag(tf.ones([v])))
inf_mask = big_number * tf.diag(tf.ones([v]))
inf_mask = tf.stop_gradient(inf_mask)
# for similarity graph
ph_dim = int(in_dim / 2)
# ph_dim = in_dim
ph = fc(tf.reshape(h, [-1, in_dim]), ph_dim, 'proj_h_sim1', with_bias=False, relu=False, reuse=tf.AUTO_REUSE)
ph = tf.reshape(ph, [-1, v, ph_dim])
ph = tf.nn.l2_normalize(ph, dim=-1)
hv = tf.tile(ph[:, :, None, :], [1, 1, v, 1])
hw = tf.tile(ph[:, None, :, :], [1, v, 1, 1])
att_s = tf.reduce_sum(hv * hw, axis=-1)
att_s -= inf_mask[None, :, :]
sa = tf.nn.softmax(att_s)
sa = sa + diag_I[None, :, :]
self.ops['adjm'] = sa
sd = tf.matrix_diag(1 / tf.reduce_sum(sa, axis=-1))
sa = tf.matmul(sd, sa)
for i in range(self.params['num_timesteps']):
# for similarity graph
sah = tf.matmul(sa, h)
sah = tf.reshape(sah, [-1, in_dim])
smh = fc(sah, h_dim, 'gcn_{}_sim'.format(i), with_bias=False, relu=True, reuse=tf.AUTO_REUSE)
smh = tf.reshape(smh, [-1, v, h_dim])
#h = tf.maximum(ngh, smh)
h = smh
#h = tf.nn.l2_normalize(h, axis=-1)
h += init_h
return h
def inference(self, x, grah):
with tf.variable_scope("conv0"):
if self.res_name == "resnet50":
net = utils.relu(
utils.Bn(utils.conv2d(x, 64, 7, 7, 2, 2, bias=True),
training=self.is_training))
else:
net = utils.relu(
utils.Bn(utils.conv2d(x, 64, 7, 7, 2, 2, bias=False),
training=self.is_training))
with tf.name_scope("pool1"):
net = utils.max_pool(net, 3, 3, 2, 2)
with tf.variable_scope("group0"):
for i in range(grah[0]):
net = self.residual(net, 256, name='block' + str(i))
with tf.variable_scope("group1"):
for i in range(grah[1]):
if i == 0:
net = self.residual(net, 512, 2, name='block' + str(i))
else:
net = self.residual(net, 512, name='block' + str(i))
with tf.variable_scope("group2"):
for i in range(grah[2]):
if i == 0:
net = self.residual(net, 1024, 2, name='block' + str(i))
else:
net = self.residual(net, 1024, name='block' + str(i))
with tf.variable_scope("group3"):
for i in range(grah[3]):
if i == 0:
net = self.residual(net, 2048, 2, name='block' + str(i))
else:
net = self.residual(net, 2048, name='block' + str(i))
with tf.name_scope("pool5"):
net = utils.global_pool(net)
with tf.variable_scope("linear"):
net = tf.nn.dropout(net, keep_prob=self.keep_prob)
net = utils.linear(net, 1000)
return net
def inference(self, x):
with tf.variable_scope("conv0"):
conv1 = utils.relu(utils.Bn(utils.conv2d(x, 64, 7, 7, 2, 2, bias=False), training=self.is_training))
with tf.name_scope("pool1"):
pool1 = utils.max_pool(conv1, 3, 3, 2, 2)
with tf.variable_scope("group0"):
res2a = self.residual(pool1, 64, branch=True, name='block0')
res2b = self.residual(res2a, 64, name='block1')
with tf.variable_scope("group1"):
res3a = self.residual(res2b, 128, 2, name='block0')
res3b = self.residual(res3a, 128, name='block1')
with tf.variable_scope("group2"):
res4a = self.residual(res3b, 256, 2, name='block0')
res4b = self.residual(res4a, 256, name='block1')
with tf.variable_scope("group3"):
res5a = self.residual(res4b, 512, 2, name='block0')
res5b = self.residual(res5a, 512, name='block1')
with tf.name_scope("pool5"):
pool5 = utils.global_pool(res5b)
with tf.variable_scope("linear"):
dropout = tf.nn.dropout(pool5, keep_prob=self.keep_prob)
out = utils.linear(dropout, 1000)
return out
def __init__(self, input_channels, list_channels, list_layer_num, if_att):
super(build_cliquenet, self).__init__()
self.fir_trans = nn.Conv2d(3,
input_channels,
kernel_size=7,
stride=2,
padding=3,
bias=False)
self.fir_bn = nn.BatchNorm2d(input_channels)
self.fir_pool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
self.block_num = len(list_channels)
self.if_att = if_att
self.list_block = nn.ModuleList()
self.list_trans = nn.ModuleList()
self.list_gb = nn.ModuleList()
self.list_gb_channel = []
self.list_compress = nn.ModuleList()
input_size_init = 56
for i in xrange(self.block_num):
if i == 0:
self.list_block.append(
clique_block(input_channels=input_channels,
channels_per_layer=list_channels[0],
layer_num=list_layer_num[0],
loop_num=1,
keep_prob=0.8))
self.list_gb_channel.append(input_channels + list_channels[0] *
list_layer_num[0])
else:
self.list_block.append(
clique_block(input_channels=list_channels[i - 1] *
list_layer_num[i - 1],
channels_per_layer=list_channels[i],
layer_num=list_layer_num[i],
loop_num=1,
keep_prob=0.8))
self.list_gb_channel.append(
list_channels[i - 1] * list_layer_num[i - 1] +
list_channels[i] * list_layer_num[i])
if i < self.block_num - 1:
self.list_trans.append(
transition(self.if_att,
current_size=input_size_init,
input_channels=list_channels[i] *
list_layer_num[i],
keep_prob=0.8))
self.list_gb.append(
global_pool(input_size=input_size_init,
input_channels=self.list_gb_channel[i] // 2))
self.list_compress.append(
compress(input_channels=self.list_gb_channel[i],
keep_prob=0.8))
input_size_init = input_size_init // 2
self.fc = nn.Linear(in_features=sum(self.list_gb_channel) // 2,
out_features=1000)
for m in self.modules():
if isinstance(m, nn.Conv2d):
n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
m.weight.data.normal_(0, math.sqrt(2. / n))
elif isinstance(m, nn.BatchNorm2d):
m.weight.data.fill_(1)
m.bias.data.zero_()
elif isinstance(m, nn.Linear):
m.bias.data.zero_()
def __init__(self,
num_classes,
input_channels=64,
list_channels=[36, 36, 36],
list_layer_num=[4, 4, 4],
if_att=False):
super(cliquenet, self).__init__()
self.fir_trans = nn.Conv2d(3,
input_channels,
kernel_size=3,
stride=1,
padding=1,
bias=False)
# filters=conv_var(kernel_size=(3,3), in_channels=3, out_channels=channels, init_method='msra', name='first_tran')
#conved=tf.nn.conv2d(input_layer, filters, [1, strides, strides, 1], padding='SAME')
self.fir_bn = nn.BatchNorm2d(input_channels)
# self.fir_pool = nn.MaxPool2d(kernel_size=2, stride=1, padding=1)
self.block_num = len(list_channels)
self.if_att = if_att
self.list_block = nn.ModuleList()
self.list_trans = nn.ModuleList()
self.list_gb = nn.ModuleList()
self.list_gb_channel = []
self.list_compress = nn.ModuleList()
input_size_init = 32
for i in xrange(self.block_num): #i=0,1,2
if i == 0:
self.list_block.append(
clique_block(input_channels=input_channels,
channels_per_layer=list_channels[0],
layer_num=list_layer_num[0],
loop_num=1,
keep_prob=0.8))
self.list_gb_channel.append(input_channels + list_channels[0] *
list_layer_num[0])
else:
self.list_block.append(
clique_block(input_channels=list_channels[i - 1] *
list_layer_num[i - 1],
channels_per_layer=list_channels[i],
layer_num=list_layer_num[i],
loop_num=1,
keep_prob=0.8))
self.list_gb_channel.append(
list_channels[i - 1] * list_layer_num[i - 1] +
list_channels[i] * list_layer_num[i])
if i < self.block_num - 1: #i=0,1
self.list_trans.append(
transition(self.if_att,
current_size=input_size_init,
input_channels=list_channels[i] *
list_layer_num[i],
keep_prob=0.8))
self.list_gb.append(
global_pool(input_size=input_size_init,
input_channels=self.list_gb_channel[i] // 2))
self.list_compress.append(
compress(input_channels=self.list_gb_channel[i],
keep_prob=0.8))
input_size_init = input_size_init // 2
self.fc = nn.Linear(in_features=sum(self.list_gb_channel) // 2,
out_features=num_classes)
for m in self.modules():
if isinstance(m, nn.Conv2d):
n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
m.weight.data.normal_(0, math.sqrt(2. / n))
elif isinstance(m, nn.BatchNorm2d):
m.weight.data.fill_(1)
m.bias.data.zero_()
elif isinstance(m, nn.Linear):
m.bias.data.zero_()