def add_apm_losses3(model):
loss_gradients = bpm_heads.add_bpm_losses(model)
prefix = 'global'
im_per_batch = cfg.TRAIN.IMS_PER_BATCH if model.train else 1
strip_num = cfg.REID.BPM_STRIP_NUM
strip_len = cfg.REID.BPM_STRIP_LEN
# roi_per_im = cfg.TRAIN.BATCH_SIZE_PER_IM
roi_per_im = strip_num * strip_len * int(strip_num * strip_len / 3)
model.net.Reshape(
'rois_pred', ['rois_pred_r', 'rois_pred_shape'],
shape=[im_per_batch, roi_per_im, model.num_classes - 1])
model.net.ReduceSum(
'rois_pred_r', prefix + '_prob', axes=[1], keepdims=False)
cross_entropy = model.net.CrossEntropyWithLogits(
[prefix + '_prob', 'labels_oh'], [prefix + '_cross_entropy'])
loss_cls = model.net.AveragedLoss([cross_entropy], [prefix + '_loss'])
loss_gradients.update(
reid_utils.get_loss_gradients_weighted(model, [loss_cls], 0.1))
model.Accuracy([prefix + '_prob', 'labels_int32'], prefix + '_accuracy')
model.AddLosses([prefix + '_loss'])
model.AddMetrics(prefix + '_accuracy')
return loss_gradients
def add_reid_losses(model):
"""Add losses for RoI classification and bounding box regression."""
cls_probs = []
loss_clss = []
N = cfg.TRAIN.IMS_PER_BATCH
if cfg.FPN.FPN_ON and cfg.REID.FPN_SHARED:
labels_int32 = model.net.Tile('labels_int32',
'labels_int32_tiled',
axis=0,
tiles=cfg.REID.FPN_NUM)
N *= cfg.REID.FPN_NUM
else:
labels_int32 = 'labels_int32'
for i in range(len(fc_list)):
prefix = get_prefix(fc_list[i])
fc = fc_list[i]
cls_prob, loss_cls = model.net.SoftmaxWithLoss(
[fc, labels_int32], [prefix + '_prob', prefix + '_loss'],
scale=model.GetLossScale())
cls_probs.append(cls_prob)
loss_clss.append(loss_cls)
model.Accuracy([prefix + '_prob', labels_int32], prefix + '_accuracy')
model.AddMetrics(prefix + '_accuracy')
loss_gradients = reid_utils.get_loss_gradients_weighted(
model, loss_clss, 1.0)
model.AddLosses(loss_clss)
if cfg.REID.CRM:
lg = crm_heads.add_crm_losses(model, preprefix='crm')
loss_gradients.update(lg)
if cfg.REID.TRIPLET_LOSS is False:
return loss_gradients
for i in range(len(feature_list)):
prefix = get_prefix(fc_list[i])
blob_in = feature_list[i]
lg = triplet_loss.add_triplet_losses(model,
blob_in,
labels_int32,
N,
loss_weight=0.14,
margin=1.4,
prefix=prefix)
loss_gradients.update(lg)
return loss_gradients
def add_apm_losses2(model):
prefix = 'global'
model.net.ReduceSum(
'rois_pred', prefix + '_cls_prob', axes=[1], keepdims=False)
cross_entropy = model.net.CrossEntropyWithLogits(
[prefix + '_cls_prob', 'labels_oh'], [prefix + '_cross_entropy'])
loss_cls = model.net.AveragedLoss([cross_entropy], [prefix + '_loss_cls'])
loss_gradients = reid_utils.get_loss_gradients_weighted(
model, [loss_cls], 1.0)
model.Accuracy([prefix + '_cls_prob', 'labels_int32'],
prefix + '_accuracy_cls')
model.AddLosses([prefix + '_loss_cls'])
model.AddMetrics(prefix + '_accuracy_cls')
# loss_gradients.update(bpm_heads.add_bpm_losses(model))
return loss_gradients
def add_crm_losses(model, preprefix='crm'):
loss_gradients = {}
im_per_batch = cfg.TRAIN.IMS_PER_BATCH if model.train else 1
if cfg.FPN.FPN_ON and cfg.REID.FPN_SHARED:
im_per_batch *= cfg.REID.FPN_NUM
if cfg.FPN.FPN_ON and cfg.REID.FPN_SHARED:
labels_oh = model.net.Tile('labels_oh',
'labels_oh_tiled',
axis=0,
tiles=cfg.REID.FPN_NUM)
labels_int32 = 'labels_int32_tiled'
else:
labels_oh = 'labels_oh'
labels_int32 = 'labels_int32'
prefix = preprefix
model.net.Reshape(prefix + '_rois_pred',
[prefix + '_rois_pred_r', prefix + '_rois_pred_shape'],
shape=[im_per_batch, -1, model.num_classes - 1])
model.net.ReduceSum(prefix + '_rois_pred_r',
prefix + '_prob',
axes=[1],
keepdims=False)
cross_entropy = model.net.CrossEntropyWithLogits(
[prefix + '_prob', labels_oh], [prefix + '_cross_entropy'])
loss_cls = model.net.AveragedLoss([cross_entropy], [prefix + '_loss'])
loss_gradients.update(
reid_utils.get_loss_gradients_weighted(model, [loss_cls], 1.0))
model.Accuracy([prefix + '_prob', labels_int32], prefix + '_accuracy')
model.AddLosses([prefix + '_loss'])
model.AddMetrics(prefix + '_accuracy')
return loss_gradients
def add_apm_losses(model, spatial_scale, preprefix='apm'):
loss_gradients = {}
loss_gradients.update(bpm_heads.add_bpm_losses(model, preprefix='bpm'))
loss_gradients.update(bpm_heads.add_bpm_losses(model, preprefix='abpm'))
im_per_batch = cfg.TRAIN.IMS_PER_BATCH if model.train else 1
strip_num = cfg.REID.BPM_STRIP_NUM
strip_len = int(cfg.REID.SCALE[1] * spatial_scale / strip_num)
roi_per_im = int(cfg.REID.SCALE[1] * spatial_scale * cfg.REID.SCALE[0] *
spatial_scale / strip_num)
for i in range(strip_num):
prefix = preprefix + str(i)
model.net.Reshape(
prefix + '_rois_pred',
[prefix + '_rois_pred_r', prefix + '_rois_pred_shape'],
shape=[im_per_batch, roi_per_im, model.num_classes - 1])
model.net.ReduceSum(
prefix + '_rois_pred_r',
prefix + '_prob',
axes=[1],
keepdims=False)
cross_entropy = model.net.CrossEntropyWithLogits(
[prefix + '_prob', 'labels_oh'], [prefix + '_cross_entropy'])
loss_cls = model.net.AveragedLoss([cross_entropy], [prefix + '_loss'])
loss_gradients.update(
reid_utils.get_loss_gradients_weighted(model, [loss_cls], 0.01))
model.Accuracy([prefix + '_prob', 'labels_int32'],
prefix + '_accuracy')
model.AddLosses([prefix + '_loss'])
model.AddMetrics(prefix + '_accuracy')
return loss_gradients
def add_triplet_losses(model,
blob_in,
labels,
N,
loss_weight=1.0,
margin=0.2,
prefix='tri'):
if cfg.REID.NORMALIZE_FEATURE:
feat_norm = normalize(model, blob_in, prefix + '_norm', axis=1)
model.net.Squeeze(feat_norm, prefix + '_x', dims=[2, 3])
# model.net.Squeeze(feat_norm, prefix + '_y', dims=[2, 3])
else:
model.net.Squeeze(blob_in, prefix + '_x', dims=[2, 3])
# model.net.Squeeze(blob_in, prefix + '_y', dims=[2, 3])
# dist = euclidean_dist(
# model, prefix + '_x', prefix + '_y', N, N, prefix=prefix)
model.net.PairWiseDistance(prefix + '_x', prefix + '_dist')
model.net.Clip(prefix + '_dist', prefix + '_dist_clip', min=1e-12)
dist = model.net.Sqrt(prefix + '_dist_clip', prefix + '_dist_sqrt')
# dist_ap, dist_an = hard_example_mining(
# model, dist, labels, N, prefix=prefix)
dist_ap, dist_an = model.net.BatchHard(
[dist, labels], [prefix + '_dist_ap', prefix + '_dist_an'])
Y = model.net.ConstantFill([], [prefix + '_Y'],
shape=[N, 1],
value=-1,
dtype=2)
mrc = model.net.MarginRankingCriterion([dist_ap, dist_an, Y],
[prefix + '_mrc'],
margin=margin)
if cfg.REID.TRIPLET_LOSS_CROSS:
mrc_ave = model.net.ReduceMean([mrc], [prefix + '_ave_mrc'],
axes=[0],
keepdims=False)
model.AddMetrics(prefix + '_ave_mrc')
loss_scale_factor = model.param_init_net.ConstantFill(
[], 'loss_scale_factor', shape=[1], value=0.0)
loss_triplet = model.net.Mul([mrc_ave, loss_scale_factor],
prefix + '_triplet_loss',
broadcast=True)
else:
loss_triplet = model.net.AveragedLoss([mrc],
[prefix + '_triplet_loss'])
loss_gradients = reid_utils.get_loss_gradients_weighted(
model, [loss_triplet], loss_weight)
model.AddLosses([prefix + '_triplet_loss'])
model.net.ReduceMean(prefix + '_dist_ap',
prefix + '_dist_ap_mean',
axes=[0],
keepdims=False)
model.net.ReduceMean(prefix + '_dist_an',
prefix + '_dist_an_mean',
axes=[0],
keepdims=False)
model.AddMetrics(prefix + '_dist_ap_mean')
model.AddMetrics(prefix + '_dist_an_mean')
return loss_gradients