def build(self,
images,
num_classes,
labels=None,
index=None,
is_training=True):
with tf.name_scope('PixelNet'):
out, layers_out = vgg_16(images,
num_classes=num_classes,
is_training=is_training,
dropout_keep_prob=0.5,
spatial_squeeze=False,
scope='vgg_16',
fc_conv_padding='VALID',
global_pool=False)
features = []
features.append(layers_out["vgg_16/conv1/conv1_2"])
features.append(layers_out["vgg_16/conv2/conv2_2"])
features.append(layers_out["vgg_16/conv3/conv3_3"])
features.append(layers_out["vgg_16/conv4/conv4_3"])
features.append(layers_out["vgg_16/conv5/conv5_3"])
features.append(layers_out["vgg_16/fc7"])
x, y = self.random_sampling(features, labels, index)
with tf.name_scope('MLP'):
x = slim.fully_connected(
x,
4096,
activation_fn=tf.nn.relu,
weights_initializer=tf.truncated_normal_initializer(
0.0, 0.001),
scope='fc1')
x = slim.dropout(x, 0.5, scope='dropout1')
x = slim.fully_connected(
x,
4096,
activation_fn=tf.nn.relu,
weights_initializer=tf.truncated_normal_initializer(
0.0, 0.001),
scope='fc2')
x = slim.dropout(x, 0.5, scope='dropout2')
x = slim.fully_connected(
x,
num_classes,
activation_fn=tf.nn.relu,
weights_initializer=tf.truncated_normal_initializer(
0.0, 0.001),
scope='fc3')
if labels is not None:
return x, y
else:
return x
def __init__(self, hid, n1_classes, n2_classes, n3_classes, n4_classes, n5_classes, n_classes):
super(multi_head, self).__init__()
with self.init_scope():
self.FE = vgg_16()
self.n1_classes = n1_classes
self.o1 = Linear(hid, n1_classes)
self.n2_classes = n2_classes
self.o2 = Linear(hid, n2_classes)
self.n3_classes = n3_classes
self.o3 = Linear(hid, n3_classes)
self.n4_classes = n4_classes
self.o4 = Linear(hid, n4_classes)
self.n5_classes = n5_classes
self.o5 = Linear(hid, n5_classes)
self.o = Linear(hid, n_classes)
def __init__(self, hid, n_classes2):
super(tr_Classifier_lgl, self).__init__()
with self.init_scope():
self.FE = vgg_16()
self.o1 = Linear(hid, n_classes2)
self.o2 = Linear(hid, n_classes2)
parser.add_argument('--opt')
parser.add_argument('--weights_path')
parser.add_argument('--untrainable_layers', type=int)
parser.add_argument('--debug', type=int)
args = parser.parse_args()
# create result dir
create_result_dir(args)
# load datasets
train_dl, test_dl = load_dataset(args)
# load pre-trained model and train part of the model
if args.weights_path:
# get prediction from conv layers
model = vgg_16(args.joints_num)
model = load_pretrain_weights(args, model)
opt = get_optimizer(args)
model.compile(optimizer=opt,
loss='mean_squared_error',
metrics=['accuracy'])
if args.partial_dataset:
train_dl = train_dl[:args.partial_dataset]
start_time = time.time()
training(args, model, train_dl)
end_time = time.time()
logging.info('Training finished. Time used {}h'.format(
(end_time - start_time) / 3600))
def inference(self, inputs, is_training=True, reuse=False):
"""
网络前向传播计算，输出logits张量，keep_prob为drop out参数，预测时置为1
"""
if self.model == "vgg16":
if self.scope == None:
self.scope = 'vgg_16'
logits = vgg16.vgg_16(inputs=inputs,
num_classes=self.n_classes,
is_training=is_training,
reuse=reuse,
dropout_keep_prob=self.dropprob,
scope=self.scope,
weight_decay=self.l2_rate,
use_batch_norm=self.use_bn,
batch_norm_decay=self.bn_decay,
batch_norm_epsilon=self.bn_epsilon,
batch_norm_scale=self.bn_scale)
elif self.model == "res50":
if self.scope == None:
self.scope = 'resnet_v1_50'
logits = resnet.resnet_50(inputs=inputs,
num_classes=self.n_classes,
is_training=is_training,
reuse=reuse,
use_se_module=False,
scope=self.scope,
weight_decay=self.l2_rate,
use_batch_norm=self.use_bn,
batch_norm_decay=self.bn_decay,
batch_norm_epsilon=self.bn_epsilon,
batch_norm_scale=self.bn_scale)
elif self.model == "res50_senet":
if self.scope == None:
self.scope = 'resnet_v1_50'
logits = resnet.resnet_50(inputs=inputs,
num_classes=self.n_classes,
is_training=is_training,
reuse=reuse,
use_se_module=True,
scope=self.scope,
weight_decay=self.l2_rate,
use_batch_norm=self.use_bn,
batch_norm_decay=self.bn_decay,
batch_norm_epsilon=self.bn_epsilon,
batch_norm_scale=self.bn_scale)
elif self.model == "densenet":
if self.scope == None:
self.scope = 'densenet169'
logits = densenet.densenet169(inputs=inputs,
num_classes=self.n_classes,
is_training=is_training,
reuse=reuse,
dropout_keep_prob=self.dropprob,
scope=self.scope,
weight_decay=self.l2_rate,
use_batch_norm=self.use_bn,
batch_norm_decay=self.bn_decay,
batch_norm_epsilon=self.bn_epsilon,
batch_norm_scale=self.bn_scale)
else:
raise ValueError("Unknown cost function: " % cost_name)
return tf.squeeze(logits)