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