def _forward(self, inputs, targets):
if self.mode == 'cnn':
out_feat = self.model(inputs[0], inputs[1], self.mode)
loss, outputs = self.regular_criterion(out_feat, targets)
prec, = accuracy(outputs.data, targets.data)
prec = prec[0]
return loss, prec, 0, 0
elif self.mode == 'cnn_rnn':
feat, feat_raw = self.model(inputs[0], inputs[1], self.mode)
featsize = feat.size()
featbatch = featsize[0]
seqlen = featsize[1]
## expand the target label ID loss
featX = feat.view(featbatch * seqlen, -1)
targetX = targets.unsqueeze(1)
targetX = targetX.expand(featbatch, seqlen)
targetX = targetX.contiguous()
targetX = targetX.view(featbatch * seqlen, -1)
targetX = targetX.squeeze(1)
loss_id, outputs_id = self.regular_criterion(featX, targetX)
prec_id, = accuracy(outputs_id.data, targetX.data)
prec_id = prec_id[0]
## verification label
featsize = feat.size()
sample_num = featsize[0]
targets = targets.data
targets = targets.view(int(sample_num / 2), -1)
tar_probe = targets[:, 0]
tar_gallery = targets[:, 1]
pooled_probe, pooled_gallery_2, pooled_probe_2, pooled_gallery = self.att_model(feat, feat_raw)
encode_scores = self.classifier_model(pooled_probe, pooled_gallery_2, pooled_probe_2, pooled_gallery)
encode_size = encode_scores.size()
encodemat = encode_scores.view(-1, 2)
encodemat = F.softmax(encodemat)
encodemat = encodemat.view(encode_size[0], encode_size[1], 2)
encodemat = encodemat[:, :, 1]
loss_ver, prec_ver = self.criterion(encodemat, tar_probe, tar_gallery)
loss = loss_id*self.rate + 100*loss_ver
return loss, prec_id, prec_ver, 0
else:
raise ValueError("Unsupported loss:", self.criterion)
def _forward(self, inputs, targets):
if self.mode == 'cnn':
out_feat = self.model(inputs[0], inputs[1], self.mode)
loss, outputs = self.regular_criterion(out_feat, targets)
prec, = accuracy(outputs.data, targets.data)
# prec = prec[0]
return loss, prec, 0, 0
elif self.mode == 'cnn_rnn':
feat, feat_raw = self.model(inputs[0], inputs[1], self.mode)
featsize = feat.size()
featbatch = featsize[0]
seqlen = featsize[1]
# expand the target label ID loss
featX = feat.view(featbatch * seqlen, -1)
targetX = targets.unsqueeze(1)
targetX = targetX.expand(featbatch, seqlen)
targetX = targetX.contiguous()
targetX = targetX.view(featbatch * seqlen, -1)
targetX = targetX.squeeze(1)
loss_id, outputs_id = self.regular_criterion(featX, targetX)
prec_id, = accuracy(outputs_id.data, targetX.data)
# prec_id = prec_id[0]
# verification label
featsize = feat.size()
sample_num = featsize[0]
targets = targets.data
targets = targets.view(int(sample_num / 2), -1)
tar_probe = targets[:, 0]
tar_gallery = targets[:, 1]
pooled_probe, pooled_gallery = self.att_model(feat, feat_raw)
encode_scores = self.classifier_model(pooled_probe, pooled_gallery)
encode_size = encode_scores.size()
encodemat = encode_scores.view(-1, 2)
encodemat = F.softmax(encodemat)
encodemat = encodemat.view(encode_size[0], encode_size[1], 2)
encodemat = encodemat[:, :, 1]
loss_ver, prec_ver = self.criterion(encodemat, tar_probe, tar_gallery)
loss = loss_id * self.rate + 100 * loss_ver
return loss, prec_id, prec_ver
else:
raise ValueError("Unsupported loss:", self.criterion)
def _forward(self, inputs, targets):
if self.mode == 'cnn':
out_feat = self.model(inputs[0], inputs[1], self.mode)
loss, outputs = self.regular_criterion(out_feat, targets)
prec, = accuracy(outputs.data, targets.data)
# prec = prec[0]
return loss, prec, 0, 0
elif self.mode == 'cnn_rnn':
feat, feat_raw = self.model(inputs[0], inputs[1], self.mode)
featsize = feat.size() # torch.Size([8, 8, 128])
featbatch = featsize[0] # 8
seqlen = featsize[1] # 8
# expand the target label ID loss
featX = feat.view(featbatch * seqlen, -1) # torch.Size([64, 128])
targetX = targets.unsqueeze(1) # tensor([[36],[36],[29],[29],[71],[71],[16],[16]], device='cuda:0')
targetX = targetX.expand(featbatch, seqlen) # torch.Size([8, 8])
targetX = targetX.contiguous()
targetX = targetX.view(featbatch * seqlen, -1) # torch.Size([64, 1])
targetX = targetX.squeeze(1) # torch.Size([64])
loss_id, outputs_id = self.regular_criterion(featX, targetX) # tensor(4.6052, device='cuda:0')
prec_id, = accuracy(outputs_id.data, targetX.data) # tensor(0., device='cuda:0')
# prec_id = prec_id[0]
# verification label
featsize = feat.size() # torch.Size([8, 8, 128])
sample_num = featsize[0]
targets = targets.data # tensor([36, 36, 29, 29, 71, 71, 16, 16], device='cuda:0')
targets = targets.view(int(sample_num / 2), -1) # torch.Size([4, 2])
tar_probe = targets[:, 0] # tensor([36, 29, 71, 16], device='cuda:0')
tar_gallery = targets[:, 1] # tensor([36, 29, 71, 16], device='cuda:0')
pooled_probe, pooled_gallery_2, pooled_probe_2, pooled_gallery = self.att_model(feat, feat_raw)
encode_scores = self.classifier_model(pooled_probe, pooled_gallery_2, pooled_probe_2, pooled_gallery)
encode_size = encode_scores.size() # torch.Size([4, 4, 2])
encodemat = encode_scores.view(-1, 2) # torch.Size([16, 2])
encodemat = F.softmax(encodemat) # torch.Size([16, 2])
encodemat = encodemat.view(encode_size[0], encode_size[1], 2) # torch.Size([4, 4, 2])
encodemat = encodemat[:, :, 1] # torch.Size([4, 4])
loss_ver, prec_ver = self.criterion(encodemat, tar_probe, tar_gallery)
loss = loss_id + 100*loss_ver
return loss, prec_id, prec_ver
else:
raise ValueError("Unsupported loss:", self.criterion)
def _forward(self, inputs, targets):
outputs = self.model(*inputs)
if isinstance(self.criterion, torch.nn.CrossEntropyLoss):
loss = self.criterion(outputs, targets)
prec, = accuracy(outputs.data, targets.data)
prec = prec[0]
elif isinstance(self.criterion, OIMLoss):
loss, outputs = self.criterion(outputs, targets)
prec, = accuracy(outputs.data, targets.data)
prec = prec[0]
elif isinstance(self.criterion, TripletLoss):
loss, prec = self.criterion(outputs, targets)
else:
raise ValueError("Unsupported loss:", self.criterion)
return loss, prec
def forward(self, score, tar_probe, tar_gallery):
cls_Size = score.size()
N_probe = cls_Size[0]
N_gallery = cls_Size[1]
tar_gallery = tar_gallery.unsqueeze(0)
tar_probe = tar_probe.unsqueeze(1)
mask = tar_probe.expand(N_probe, N_gallery).eq(
tar_gallery.expand(N_probe, N_gallery))
mask = mask.view(-1).cpu().numpy().tolist()
score = score.contiguous()
samplers = score.view(-1)
labels = Variable(torch.Tensor(mask).cuda())
positivelabel = torch.Tensor(mask)
negativelabel = 1 - positivelabel
positiveweightsum = torch.sum(positivelabel)
negativeweightsum = torch.sum(negativelabel)
neg_relativeweight = positiveweightsum / negativeweightsum * self.sampling_rate
weights = (positivelabel + negativelabel * neg_relativeweight)
weights = weights / torch.sum(weights) / 10
self.BCE.weight = weights.cuda()
loss = self.BCE(samplers, labels)
samplers_data = samplers.data
samplers_neg = 1 - samplers_data
samplerdata = torch.cat(
(samplers_neg.unsqueeze(1), samplers_data.unsqueeze(1)), 1)
labeldata = torch.LongTensor(mask).cuda()
prec, = accuracy(samplerdata, labeldata)
return loss, prec[0]
def forward(self, score, tar_probe, tar_gallery):
cls_Size = score.size() # torch.Size([4, 2])
N_probe = cls_Size[0] # 4
N_gallery = cls_Size[0]
tar_gallery = tar_gallery.unsqueeze(
1) # 6,1 tensor([[ 94],[ 10],[ 15],[ 16],[ 75],[ 39]])
tar_probe = tar_probe.unsqueeze(
0) # 1,6 tensor([[ 94, 10, 15, 16, 75, 39]])
mask = tar_probe.expand(N_probe, N_gallery).eq(
tar_gallery.expand(N_probe, N_gallery))
mask = mask.view(-1).cpu().numpy().tolist()
# [1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1]
score = score.contiguous() # torch.Size([4, 4])
samplers = score.view(-1) # torch.Size([16])
# samplers = self.sigmod(samplers)
# labels = Variable(torch.Tensor(mask).cuda())
labels = torch.Tensor(mask).to(self.device)
loss = self.BCE(samplers, labels)
samplers_data = samplers.data # torch.Size([36])
samplers_neg = 1 - samplers_data
samplerdata = torch.cat(
(samplers_neg.unsqueeze(1), samplers_data.unsqueeze(1)),
1) # torch.Size([36, 2])
labeldata = torch.LongTensor(mask).to(self.device)
prec, = accuracy(samplerdata, labeldata)
return loss, prec
def _forward(self, inputs, targets):
out_feat = self.model(inputs[0])
featsize = out_feat.size()
sample_num = featsize[0]
feat_num = featsize[1]
## identification
loss_oim, outputs = self.regular_criterion(out_feat, targets)
prec_oim, = accuracy(outputs.data, targets.data)
prec_oim = prec_oim[0]
## verification
### labels
targets = targets.data
targets = targets.view(int(sample_num / self.instances_num), -1)
tar_probe = targets[:, 0]
tar_gallery = targets[:, 1:self.instances_num]
tar_gallery = tar_gallery.contiguous()
tar_gallery = tar_gallery.view(-1)
### features
x = out_feat.view(int(sample_num / self.instances_num),
self.instances_num, -1)
probe_x = x[:, 0, :]
probe_x = probe_x.contiguous()
gallery_x = x[:, 1:self.instances_num, :]
gallery_x = gallery_x.contiguous()
gallery_x = gallery_x.view(-1, feat_num)
encode_scores = self.classifier(probe_x, gallery_x)
gallery_scores = self.classifier(gallery_x, gallery_x)
encode_size = encode_scores.size()
encodemat = encode_scores.view(-1, 2)
encodemat = F.softmax(encodemat, 1)
encodemat = encodemat.view(encode_size[0], encode_size[1], 2)
initialscore = encodemat[:, :, 1]
loss_score, prec_score = self.criterion_score(initialscore, tar_probe,
tar_gallery)
gallery_size = gallery_scores.size()
gallerymat = gallery_scores.view(-1, 2)
gallerymat = F.softmax(gallerymat, 1)
gallerymat = gallerymat.view(gallery_size[0], gallery_size[1], 2)
gallerymat = gallerymat[:, :, 1]
finalscores = self.crf_mf(initialscore, gallerymat)
loss_finalscore, prec_finalscore = self.criterion(
finalscores, tar_probe, tar_gallery)
loss = loss_oim * 0.2 + loss_score * 0.4 + loss_finalscore * 0.4
return loss, prec_oim, prec_score, prec_finalscore
def forward(self, cls_encode, tar_probe, tar_gallery):
cls_Size = cls_encode.size()
N_probe = cls_Size[0]
N_gallery = cls_Size[1]
tar_gallery = tar_gallery.unsqueeze(0)
tar_probe = tar_probe.unsqueeze(1)
mask = tar_probe.expand(N_probe, N_gallery).eq(tar_gallery.expand(N_probe, N_gallery))
mask = mask.view(-1).cpu().numpy().tolist()
samplers = cls_encode.view(-1, 2)
labels = Variable(torch.LongTensor(mask).cuda())
loss = self.crossentropy(samplers, labels)
## accuracy
prec, = accuracy(samplers.data, labels.data)
return loss, prec[0]
def forward(self, score, tar_probe, tar_gallery):
cls_Size = score.size() # torch.Size([4, 4])
N_probe = cls_Size[0] # N_probe = 4
N_gallery = cls_Size[1] # N_gallery = 4
tar_gallery = tar_gallery.unsqueeze(
1
) # torch.Size([1, 4]) ==> tensor([[36, 29, 71, 16]], device='cuda:0')
tar_probe = tar_probe.unsqueeze(0) # torch.Size([4, 1])
mask = tar_probe.expand(N_probe, N_gallery).eq(
tar_gallery.expand(N_probe, N_gallery))
mask = mask.view(-1).cpu().numpy().tolist(
) # <class 'list'>: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]
score = score.contiguous()
samplers = score.view(
-1
) # tensor([0.5001, 0.5000,..., 0.5001, 0.5000, 0.5001],device='cuda:0')
labels = torch.Tensor(mask).to(
self.device
) # tensor([1., 0., 0., 0,..., 0., 0., 0., 1.],device='cuda:0')
positivelabel = torch.Tensor(mask)
negativelabel = 1 - positivelabel
positiveweightsum = torch.sum(positivelabel) # tensor(4.)
negativeweightsum = torch.sum(negativelabel) # tensor(12.)
neg_relativeweight = positiveweightsum / negativeweightsum * self.sampling_rate # tensor(1.)
weights = (positivelabel + negativelabel * neg_relativeweight)
weights = weights / torch.sum(weights) / 10
self.BCE.weight = weights.to(self.device)
loss = self.BCE(samplers, labels)
samplers_data = samplers.data
samplers_neg = 1 - samplers_data # torch.Size([16])
samplerdata = torch.cat(
(samplers_neg.unsqueeze(1), samplers_data.unsqueeze(1)),
1) # torch.Size([16, 2])
labeldata = torch.LongTensor(mask).to(
self.device
) # tensor([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1])
prec, = accuracy(samplerdata,
labeldata) # tensor(0.2500, device='cuda:0')
return loss, prec
def _forward(self, inputs, targets):
out_feat = self.model(inputs[0])
featsize = out_feat.size()
sample_num = featsize[0]
feat_num = featsize[1]
## identification
loss1, outputs = self.regular_criterion(out_feat, targets)
prec1, = accuracy(outputs.data, targets.data)
prec1 = prec1[0]
## verification
### labels
targets = targets.data
targets = targets.view(int(sample_num / self.instances_num), -1)
tar_probe = targets[:, 0]
tar_gallery = targets[:, 1:self.instances_num]
tar_gallery = tar_gallery.contiguous()
tar_gallery = tar_gallery.view(-1)
### features
x = out_feat.view(int(sample_num / self.instances_num),
self.instances_num, -1)
probe_x = x[:, 0, :]
probe_x = probe_x.contiguous()
gallery_x = x[:, 1:self.instances_num, :]
gallery_x = gallery_x.contiguous()
gallery_x = gallery_x.view(-1, feat_num)
encode_scores = self.classifier(probe_x, gallery_x)
encode_size = encode_scores.size()
encodemat = encode_scores.view(-1, 2)
encodemat = F.softmax(encodemat)
encodemat = encodemat.view(encode_size[0], encode_size[1], 2)
encodemat = encodemat[:, :, 1]
loss2, prec2 = self.criterion(encodemat, tar_probe, tar_gallery)
loss = loss1 * 0.2 + loss2 * 0.8
prec3 = prec1 * 0.2 + prec2 * 0.8
return loss, prec1, prec2, prec3
def _forward(self, inputs, targets):
out_feat = self.model(inputs[0])
featsize = out_feat.size()
sample_num = featsize[0]
## identification
loss1, outputs = self.regular_criterion(out_feat, targets)
prec1, = accuracy(outputs.data, targets.data)
prec1 = prec1[0]
## verification
scores = self.scoremodel(out_feat)
targets = targets.data
targets = targets.view(int(sample_num / 2), -1)
tar_probe = targets[:, 0]
tar_gallery = targets[:, 1]
loss2, prec2 = self.criterion(scores, tar_probe, tar_gallery)
loss = loss1 * self.rate1 + loss2 * self.rate2
prec3 = prec1 * self.rate1 + prec2 * self.rate2
return loss, prec3
def _forward(self, inputs, targets, it):
input_img = inputs[0]
featlayer4, featlayer3, featlayer2 = self.model(input_img)
## identification
loss_id, outputs4, outputs3, outputs2 = self.regular_criterion(
featlayer4, featlayer3, featlayer2, targets)
precid4, = accuracy(outputs4.data, targets.data)
precid4 = precid4.item()
precid3, = accuracy(outputs3.data, targets.data)
precid3 = precid3.item()
precid2, = accuracy(outputs2.data, targets.data)
precid2 = precid2.item()
precid = (precid2 + precid3 + precid4) / 3
featsize = featlayer4.size()
sample_num = featsize[0]
feat_num = featsize[1]
## verification
### labels
targets = targets.data
targets = targets.view(int(sample_num / self.instances_num), -1)
tar_probe = targets[:, 0]
tar_gallery = targets[:, 1:self.instances_num]
tar_gallery = tar_gallery.contiguous()
tar_gallery = tar_gallery.view(-1)
### features
x4 = featlayer4.view(int(sample_num / self.instances_num),
self.instances_num, -1)
probe_x4 = x4[:, 0, :]
probe_x4 = probe_x4.contiguous()
gallery_x4 = x4[:, 1:self.instances_num, :]
gallery_x4 = gallery_x4.contiguous()
gallery_x4 = gallery_x4.view(-1, feat_num)
x3 = featlayer3.view(int(sample_num / self.instances_num),
self.instances_num, -1)
probe_x3 = x3[:, 0, :]
probe_x3 = probe_x3.contiguous()
gallery_x3 = x3[:, 1:self.instances_num, :]
gallery_x3 = gallery_x3.contiguous()
gallery_x3 = gallery_x3.view(-1, feat_num)
x2 = featlayer2.view(int(sample_num / self.instances_num),
self.instances_num, -1)
probe_x2 = x2[:, 0, :]
probe_x2 = probe_x2.contiguous()
gallery_x2 = x2[:, 1:self.instances_num, :]
gallery_x2 = gallery_x2.contiguous()
gallery_x2 = gallery_x2.view(-1, feat_num)
encode_scores4, encode_scores3, encode_scores2 = self.mulclassifier(
probe_x4, gallery_x4, probe_x3, gallery_x3, probe_x2, gallery_x2)
encode_size4 = encode_scores4.size()
encodemat4 = encode_scores4.view(-1, 2)
encodemat4 = F.softmax(encodemat4, 1)
encodemat4 = encodemat4.view(encode_size4[0], encode_size4[1], 2)
encodemat4 = encodemat4[:, :, 1]
encode_size3 = encode_scores3.size()
encodemat3 = encode_scores3.view(-1, 2)
encodemat3 = F.softmax(encodemat3, 1)
encodemat3 = encodemat3.view(encode_size3[0], encode_size3[1], 2)
encodemat3 = encodemat3[:, :, 1]
encode_size2 = encode_scores2.size()
encodemat2 = encode_scores2.view(-1, 2)
encodemat2 = F.softmax(encodemat2, 1)
encodemat2 = encodemat2.view(encode_size2[0], encode_size2[1], 2)
encodemat2 = encodemat2[:, :, 1]
## joint learning
#encodemat = (encodemat2 + encodemat3 + encodemat4) / 3
## joint learning
#loss_veri, prec_veri = self.criterion(encodemat, tar_probe, tar_gallery)
## CRF loss
gallery_x4_data = Variable(gallery_x4.data, requires_grad=False)
gallery_x3_data = Variable(gallery_x3.data, requires_grad=False)
gallery_x2_data = Variable(gallery_x2.data, requires_grad=False)
gamma = 3
gallery_featdist4 = self.pairwise_dist(gallery_x4_data,
gallery_x4_data)
gallery_featdist3 = self.pairwise_dist(gallery_x3_data,
gallery_x3_data)
gallery_featdist2 = self.pairwise_dist(gallery_x2_data,
gallery_x2_data)
gallery_scores4 = torch.exp(-gallery_featdist4 * gamma)
gallery_scores3 = torch.exp(-gallery_featdist3 * gamma)
gallery_scores2 = torch.exp(-gallery_featdist2 * gamma)
globalscores = self.crf_mf(encodemat4, gallery_scores4, encodemat3,
gallery_scores3, encodemat2,
gallery_scores2)
loss_global, prec_global = self.criterion(globalscores, tar_probe,
tar_gallery)
loss = loss_id + loss_global * 50
return loss, precid, loss_global, prec_global
def _forward(self, inputs, targets):
featlayer4, featlayer3, featlayer2 = self.model(inputs[0])
## identification
loss_id, outputs4, outputs3, outputs2 = self.regular_criterion(
featlayer4, featlayer3, featlayer2, targets)
precid4, = accuracy(outputs4.data, targets.data)
precid4 = precid4[0]
precid3, = accuracy(outputs3.data, targets.data)
precid3 = precid3[0]
precid2, = accuracy(outputs2.data, targets.data)
precid2 = precid2[0]
precid = (precid2 + precid3 + precid4) / 3
featsize = featlayer4.size()
sample_num = featsize[0]
feat_num = featsize[1]
## verification
### labels
targets = targets.data
targets = targets.view(int(sample_num / self.instances_num), -1)
tar_probe = targets[:, 0]
tar_gallery = targets[:, 1:self.instances_num]
tar_gallery = tar_gallery.contiguous()
tar_gallery = tar_gallery.view(-1)
### features
x4 = featlayer4.view(int(sample_num / self.instances_num),
self.instances_num, -1)
probe_x4 = x4[:, 0, :]
probe_x4 = probe_x4.contiguous()
gallery_x4 = x4[:, 1:self.instances_num, :]
gallery_x4 = gallery_x4.contiguous()
gallery_x4 = gallery_x4.view(-1, feat_num)
x3 = featlayer3.view(int(sample_num / self.instances_num),
self.instances_num, -1)
probe_x3 = x3[:, 0, :]
probe_x3 = probe_x3.contiguous()
gallery_x3 = x3[:, 1:self.instances_num, :]
gallery_x3 = gallery_x3.contiguous()
gallery_x3 = gallery_x3.view(-1, feat_num)
x2 = featlayer2.view(int(sample_num / self.instances_num),
self.instances_num, -1)
probe_x2 = x2[:, 0, :]
probe_x2 = probe_x2.contiguous()
gallery_x2 = x2[:, 1:self.instances_num, :]
gallery_x2 = gallery_x2.contiguous()
gallery_x2 = gallery_x2.view(-1, feat_num)
encode_scores4, encode_scores3, encode_scores2 = self.mulclassifier(
probe_x4, gallery_x4, probe_x3, gallery_x3, probe_x2, gallery_x2)
encode_size4 = encode_scores4.size()
encodemat4 = encode_scores4.view(-1, 2)
encodemat4 = F.softmax(encodemat4, 1)
encodemat4 = encodemat4.view(encode_size4[0], encode_size4[1], 2)
encodemat4 = encodemat4[:, :, 1]
encode_size3 = encode_scores3.size()
encodemat3 = encode_scores3.view(-1, 2)
encodemat3 = F.softmax(encodemat3, 1)
encodemat3 = encodemat3.view(encode_size3[0], encode_size3[1], 2)
encodemat3 = encodemat3[:, :, 1]
encode_size2 = encode_scores2.size()
encodemat2 = encode_scores2.view(-1, 2)
encodemat2 = F.softmax(encodemat2, 1)
encodemat2 = encodemat2.view(encode_size2[0], encode_size2[1], 2)
encodemat2 = encodemat2[:, :, 1]
## joint learning
#encodemat = (encodemat2 + encodemat3 + encodemat4) / 3
## joint learning
#loss_veri, prec_veri = self.criterion(encodemat, tar_probe, tar_gallery)
## CRF loss
gallery_scores4, gallery_scores3, gallery_scores2 = self.mulclassifier(
gallery_x4, gallery_x4, gallery_x3, gallery_x3, gallery_x2,
gallery_x2)
gallery_size4 = gallery_scores4.size()
gallerymat4 = gallery_scores4.view(-1, 2)
gallerymat4 = F.softmax(gallerymat4, 1)
gallerymat4 = gallerymat4.view(gallery_size4[0], gallery_size4[1], 2)
gallerymat4 = gallerymat4[:, :, 1]
gallery_size3 = gallery_scores3.size()
gallerymat3 = gallery_scores3.view(-1, 2)
gallerymat3 = F.softmax(gallerymat3, 1)
gallerymat3 = gallerymat3.view(gallery_size3[0], gallery_size3[1], 2)
gallerymat3 = gallerymat3[:, :, 1]
gallery_size2 = gallery_scores2.size()
gallerymat2 = gallery_scores2.view(-1, 2)
gallerymat2 = F.softmax(gallerymat2, 1)
gallerymat2 = gallerymat2.view(gallery_size2[0], gallery_size2[1], 2)
gallerymat2 = gallerymat2[:, :, 1]
globalscores = self.crf_mf(encodemat4, gallerymat4, encodemat3,
gallerymat3, encodemat2, gallerymat2)
loss_global, prec_global = self.criterion(globalscores, tar_probe,
tar_gallery)
loss = loss_id * 0.5 + loss_global
return loss, precid, 0, prec_global
def _forward(self, inputs, targets, i, epoch):
batch_size = inputs[0].size(0)
seq_len = inputs[0].size(1)
x_uncorr, x_corr = self.model(inputs[0])
# uncorr_id_loss_vid, output_id = self.criterion_uncorr(x_uncorr, targets)
# uncorr_prec_id_vid, = accuracy(output_id.data, targets.data)
# expand the target label ID loss
frame_corr = x_corr.view(batch_size * seq_len, -1)
targetX = targets.unsqueeze(1)
targetX = targetX.expand(batch_size, seq_len)
targetX = targetX.contiguous()
targetX = targetX.view(batch_size * seq_len, -1) #
targetX = targetX.squeeze(1)
#######
corr_id_loss_frame, output_id = self.criterion_corr(
frame_corr, targetX)
corr_prec_id_frame, = accuracy(output_id.data, targetX.data)
# verification label
targets = targets.data
targets = targets.view(int(batch_size / 2), -1)
tar_probe = targets[:, 0]
tar_gallery = targets[:, 1]
target = torch.cat((tar_probe, tar_gallery))
encode_scores, siamese_out = self.siamese_model(x_corr)
corr_id_loss_vid, output_id = self.criterion_corr(siamese_out, target)
corr_prec_id_vid, = accuracy(output_id.data, target.data)
corr_loss_tri = criterion_triplet(siamese_out, target).mean()
### verification loss for pair-wise video feature
encode_size = encode_scores.size()
encodemat = encode_scores.view(-1, 2)
encodemat = F.softmax(encodemat, dim=-1)
encodemat = encodemat.view(encode_size[0], encode_size[1], 2)
encodemat0 = encodemat[:, :, 1]
corr_loss_ver, corr_prec_ver = self.criterion_ver(
encodemat0, tar_probe, tar_gallery)
encode_scores, siamese_out = self.siamese_model_uncorr(x_uncorr)
uncorr_id_loss_vid, output_id = self.criterion_uncorr(
siamese_out, target)
uncorr_prec_id_vid, = accuracy(output_id.data, target.data)
# uncorr_loss_tri = criterion_triplet(siamese_out, target).mean()
encode_size = encode_scores.size()
encodemat = encode_scores.view(-1, 2)
encodemat = F.softmax(encodemat, dim=-1)
encodemat = encodemat.view(encode_size[0], encode_size[1], 2)
encodemat0 = encodemat[:, :, 1]
uncorr_loss_ver, uncorr_prec_ver = self.criterion_ver_uncorr(
encodemat0, tar_probe, tar_gallery)
corr_loss = corr_id_loss_frame + corr_id_loss_vid + corr_loss_ver * 20 + corr_loss_tri
uncorr_loss = uncorr_id_loss_vid #+ corr_loss_ver*10
all_loss = uncorr_loss + corr_loss
return all_loss, uncorr_prec_id_vid, corr_prec_id_vid, corr_prec_id_frame
def _forward(self, inputs, targets):
# log
# pp('imgs', inputs[0])
# pp('flows', inputs[1])
# pp('pose', inputs[2])
# flow1: feat, feat_raw
# flow2: feat_2, feat_raw_2
feat, feat_raw = self.model_flow1(inputs[0], inputs[1], inputs[2])
# pp('feat', feat)
# pp('feat_raw', feat_raw)
feat_ = feat
if self.numflow > 1:
feat_2, feat_raw_2 = self.model_flow2(inputs[0], inputs[1],
inputs[2])
# feat_ = self.flow1_rate* feat + (1-self.flow1_rate)* feat_2
# pp('feat_2', feat_2)
# pp('feat_raw_2', feat_raw_2)
featsize = feat.size()
featbatch = featsize[0]
seqlen = featsize[1]
# expand the target label ID loss
featX = feat_.view(featbatch * seqlen, -1)
targetX = targets.unsqueeze(1)
targetX = targetX.expand(featbatch, seqlen)
targetX = targetX.contiguous()
targetX = targetX.view(featbatch * seqlen, -1)
targetX = targetX.squeeze(1)
# pp('featX', featX); pp('targetX', targetX)
loss_id, outputs_id = self.regular_criterion(featX, targetX)
prec_id, = accuracy(outputs_id.data, targetX.data)
# prec_id = prec_id[0]
# verification label
featsize = feat.size()
sample_num = featsize[0]
targets = targets.data
targets = targets.view(int(sample_num / 2), -1)
tar_probe = targets[:, 0]
tar_gallery = targets[:, 1]
# pooled_probe, pooled_gallery = self.att_model(feat, feat_raw,flow_idx=0)
# pooled_probe_2, pooled_gallery_2 = self.att_model(feat_2, feat_raw_2,flow_idx=1)
# pooled_probe, pooled_gallery = (pooled_probe + pooled_probe_2) / 2., (pooled_gallery + pooled_gallery_2) / 2.
if self.numflow > 1:
# -----flow2: HS, flow1: key value-----
probe_x, gallery_x, HS = self.att_model(feat_2,
feat_raw_2,
flow_idx=1)
# pp('probe_x', probe_x)
# pp('gallery_x', gallery_x)
probe_x = probe_x.sum(1)
probe_x = probe_x.squeeze(1)
gallery_x = gallery_x.sum(1)
gallery_x = gallery_x.squeeze(1)
pooled_probe, pooled_gallery = self.att_model(feat,
feat_raw,
flow_idx=0,
HS=HS)
# pp('pooled_probe', pooled_probe)
# pp('pooled_gallery', pooled_gallery)
# pooled_probe, pooled_gallery = (probe_x + pooled_probe) / 2., (galley_x + pooled_gallery) / 2.
pooled_probe, pooled_gallery = (
1 -
self.flow1_rate) * probe_x + self.flow1_rate * pooled_probe, (
1 - self.flow1_rate
) * gallery_x + self.flow1_rate * pooled_gallery
# ----------
else:
# only one flow
pooled_probe, pooled_gallery = self.d(feat, feat_raw, flow_idx=-1)
encode_scores = self.classifier_model(pooled_probe, pooled_gallery)
encode_size = encode_scores.size()
encodemat = encode_scores.view(-1, 2)
encodemat = F.softmax(encodemat)
encodemat = encodemat.view(encode_size[0], encode_size[1], 2)
encodemat = encodemat[:, :, 1]
loss_ver, prec_ver = self.criterion(encodemat, tar_probe, tar_gallery)
# PX:
if loss_ver > 0:
loss = loss_id * self.rate + 100 * loss_ver
# loss = loss_id + 50 * loss_ver
else:
loss = loss_id
# PX
return loss, prec_id, prec_ver
