def pdist(self, fX): """Compute pdist à-la scipy.spatial.distance.pdist Parameters ---------- fX : (n, d) torch.Tensor Embeddings. Returns ------- distances : (n * (n-1) / 2,) torch.Tensor Condensed pairwise distance matrix """ n_sequences, _ = fX.size() distances = [] for i in range(n_sequences - 1): if self.metric in ('cosine', 'angular'): d = 1. - F.cosine_similarity( fX[i, :].expand(n_sequences - 1 - i, -1), fX[i+1:, :], dim=1, eps=1e-8) if self.metric == 'angular': d = torch.acos(torch.clamp(1. - d, -1 + 1e-6, 1 - 1e-6)) elif self.metric == 'euclidean': d = F.pairwise_distance( fX[i, :].expand(n_sequences - 1 - i, -1), fX[i+1:, :], p=2, eps=1e-06).view(-1) distances.append(d) return torch.cat(distances)
def validate(self,val_loader,criterion): batch_time=AverageMeter() top1=AverageMeter() val_loss=AverageMeter() #switch to evaluate mode self.model.eval() end=time.time() for i,valdata in enumerate(val_loader,0): batch_time.update(i) input_var=list() [img0,img1,label]=valdata opts.cuda=torch.cuda.is_available() img0,img1,label=Variable(img0,volatile=True),Variable(img1,volatile=True),Variable(label,volatile=True) if opts.cuda: img0,img1,label=img0.cuda(),img1.cuda(),label.cuda() output1,output2=self.model(img0,img1) #use euclidean distance of two image euclidean_distance =F.pairwise_distance(output1,output2)# output=euclidean_distance.cpu().data.numpy() target=label.cpu().data.numpy() loss_=self.criterion(output1,output2,label) val_loss.update(loss_) res=Accuracy(output,target) top1.update(res) print('validate :abs(output_euclidean_distance-label) => {} '.format(top1.avg[0])) return top1.avg[0]
def __init__(self, dset, args): super(LabelEmbedPlus, self).__init__(dset, args) if 'conv' in args.image_extractor: self.image_embedder = torch.nn.Sequential( torch.nn.Conv2d(dset.feat_dim, args.emb_dim, 7), torch.nn.ReLU(True), Reshape(-1, args.emb_dim)) else: self.image_embedder = MLP(dset.feat_dim, args.emb_dim) self.compare_metric = lambda img_feats, pair_embed: -F.pairwise_distance( img_feats, pair_embed) self.train_forward = self.train_forward_triplet self.val_forward = self.val_forward_distance_fast input_dim = dset.feat_dim if args.clf_init else args.emb_dim self.attr_embedder = nn.Embedding(len(dset.attrs), input_dim) self.obj_embedder = nn.Embedding(len(dset.objs), input_dim) self.T = MLP(2 * input_dim, args.emb_dim, num_layers=args.nlayers) # init with word embeddings if args.emb_init: pretrained_weight = load_word_embeddings(args.emb_init, dset.attrs) self.attr_embedder.weight.data.copy_(pretrained_weight) pretrained_weight = load_word_embeddings(args.emb_init, dset.objs) self.obj_embedder.weight.data.copy_(pretrained_weight) # init with classifier weights elif args.clf_init: for idx, attr in enumerate(dset.attrs): at_id = dset.attrs.index(attr) weight = torch.load('%s/svm/attr_%d' % (args.data_dir, at_id)).coef_.squeeze() self.attr_embedder.weight[idx].data.copy_( torch.from_numpy(weight)) for idx, obj in enumerate(dset.objs): obj_id = dset.objs.index(obj) weight = torch.load('%s/svm/obj_%d' % (args.data_dir, obj_id)).coef_.squeeze() self.obj_emb.weight[idx].data.copy_(torch.from_numpy(weight)) # static inputs if args.static_inp: for param in self.attr_embedder.parameters(): param.requires_grad = False for param in self.obj_embedder.parameters(): param.requires_grad = False
def triplet_evaluate(device, model, train_batch, test_batch): train_batch = train_batch.to(device) test_batch = test_batch.to(device) assert not model.training with torch.no_grad(): train_embeds, *_ = model(train_batch) test_embeds, *_ = model(test_batch) dist_matrix = torch.stack([ F.pairwise_distance(train_embeds, test_embeds[i], p=2) for i in range(test_embeds.size(0)) ]) preds = torch.argmin(dist_matrix, dim=1) labels = torch.tensor(range(train_batch.size(0)), device=device) corrects = torch.sum(preds == labels).item() acc = corrects / train_batch.size(0) return 1 - acc
def forward(self, feature_l, feature_r, label): if self.opt_style == 'resample': #feature contrain E_w_f = F.pairwise_distance(feature_l, feature_r, p=1, keepdim=True) Q = self.margin e = 2.71828 iden_contrastive = label * (2 / Q) * E_w_f**2 + ( 1 - label) * 2 * Q * e**(-2.77 * E_w_f / Q) total_loss = iden_contrastive.mean() return total_loss else: raise Exception(f'Unknown opt style: {self.opt_style}')
def perceptual_features_reconstruction(list_attentions_a, list_attentions_b, factor=1.): loss = 0. for i, (a, b) in enumerate(zip(list_attentions_a, list_attentions_b)): bs, c, w, h = a.shape # a of shape (b, c, w, h) to (b, c * w * h) a = a.view(bs, -1) b = b.view(bs, -1) a = F.normalize(a, p=2, dim=-1) b = F.normalize(b, p=2, dim=-1) layer_loss = (F.pairwise_distance(a, b, p=2)**2) / (c * w * h) loss += torch.mean(layer_loss) return factor * (loss / len(list_attentions_a))
def _algo_2_vert_comp(self, sent1_block_a, sent2_block_a): comparison_feats = [] ws_no_inf = [w for w in self.filter_widths if not np.isinf(w)] for ws1 in self.filter_widths: x1 = sent1_block_a[ws1]['max'] for ws2 in self.filter_widths: x2 = sent2_block_a[ws2]['max'] if (not np.isinf(ws1) and not np.isinf(ws2)) or (np.isinf(ws1) and np.isinf(ws2)): comparison_feats.append( F.cosine_similarity(x1, x2).unsqueeze(1)) comparison_feats.append( F.pairwise_distance(x1, x2).unsqueeze(1)) comparison_feats.append(torch.abs(x1 - x2)) return torch.cat(comparison_feats, dim=1)
def get_accuracy(test, threshold, model): correct = 0 for i in range(len(test)): img0 = test_data[test[i][0]].unsqueeze(0) img1 = test_data[test[i][1]].unsqueeze(0) true_label = test[i][2] img0, img1 = img0.cuda(), img1.cuda() output_f0, output_f1 = model(img0, img1) euclidean_distance = F.pairwise_distance(output_f0, output_f1) if euclidean_distance > threshold and true_label == -1: correct += 1 if euclidean_distance <= threshold and true_label == 1: correct += 1 return correct / len(test)
def forward(self, x, target_z): z, logp = x[:2] d = F.pairwise_distance( z, target_z, p=self.norm, eps=1e-6, keepdim=False, # Default value ) if len(d.shape) == 2: d = torch.mean(d, dim=1) # Drop 1 dimension per_ex = self.weight * d - logp retval = torch.mean(per_ex) if retval != retval: raise ValueError("NaN") return retval return torch.mean(d)
def evaluate(dataiter, net, split, device): for i in range(2): x0, _, _ = next(dataiter) for j in range(10): _, x1, _ = next(dataiter) concatenated = torch.cat((x0, x1), 0) output1, output2 = net( Variable(x0).to(device), Variable(x1).to(device)) euclidean_distance = F.pairwise_distance(output1, output2) #imshow(torchvision.utils.make_grid(concatenated),'%s, dissimilarity:%.2f'%(split, euclidean_distance.item())) imshow( torchvision.utils.make_grid(concatenated), '%s, dissimilarity:%.2f' % (split, torch.mean(euclidean_distance))) plt.savefig('%s_%d_%d.png' % (split, i, j)) plt.close()
def test_inference_hmm_posterior_importance_sampling(self): observation = self._observation posterior_mean_correct = self._posterior_mean_correct posterior = self._model.posterior_distribution(samples, observation=observation) posterior_mean_unweighted = posterior.mean_unweighted posterior_mean = posterior.mean l2_distance = float( F.pairwise_distance(posterior_mean, posterior_mean_correct).sum()) util.debug('samples', 'posterior_mean_unweighted', 'posterior_mean', 'posterior_mean_correct', 'l2_distance') add_perf_score_importance_sampling(l2_distance) self.assertLess(l2_distance, 6)
def compute(a_feats, b_feats): cmc = np.zeros(100, ) for i in xrange(a_feats.size()[0]): query_feat = a_feats[i].view(1, -1) query_feat = query_feat.expand(a_feats.size()) dis = F.pairwise_distance(query_feat, b_feats, 2) dis, order = torch.sort(dis, 0) order = order.numpy().reshape(-1, ) a = np.where(order == i)[0][0] for j in xrange(a, 100): cmc[j] += 1 #print 'cmc[0]',cmc[0]*1.0/100 return cmc[0] * 1.0 / 100
def contrastive_loss(anchor_features, simense_features, flags): total_loss = 0 for i in range(4): _feature1 = anchor_features[i] _feature1 = torch.div(_feature1, torch.norm(_feature1, 2)) _feature1 = torch.unsqueeze(_feature1, 0) _feature2 = simense_features[i] _feature2 = torch.div(_feature2, torch.norm(_feature1, 2)) _feature2 = torch.unsqueeze(_feature2, 0) dis = F.pairwise_distance(_feature1, _feature2, p=2) if flags[i] == 1: total_loss += dis else: total_loss += torch.clamp(1.5 - dis, 0) return total_loss
def construct_graph_object(self): """ Constructs the entire Graph object to serve as input to the MPN, and stores it in self.graph_obj, """ # Load Appearance Data reid_embeddings, node_feats = self._load_appearance_data() # Determine graph connectivity (i.e. edges) and compute edge features edge_ixs = self._get_edge_ixs(reid_embeddings) edge_feats_dict = compute_edge_feats_dict( edge_ixs=edge_ixs, det_df=self.graph_df, fps=self.seq_info_dict['fps'], use_cuda=self.inference_mode) edge_feats = [ edge_feats_dict[feat_names] for feat_names in self.dataset_params['edge_feats_to_use'] if feat_names in edge_feats_dict ] edge_feats = torch.stack(edge_feats).T # Compute embeddings distances. Pairwise distance computation might create out of memmory errors, hence we batch it emb_dists = [] for i in range(0, edge_ixs[0].shape[0], 50000): emb_dists.append( F.pairwise_distance( reid_embeddings[edge_ixs[0][i:i + 50000]], reid_embeddings[edge_ixs[1][i:i + 50000]]).view(-1, 1)) emb_dists = torch.cat(emb_dists, dim=0) # Add embedding distances to edge features if needed if 'emb_dist' in self.dataset_params['edge_feats_to_use']: edge_feats = torch.cat((edge_feats, emb_dists), dim=1) self.graph_obj = Graph( x=node_feats, edge_attr=torch.cat((edge_feats, edge_feats), dim=0), edge_index=torch.cat( (edge_ixs, torch.stack((edge_ixs[1], edge_ixs[0]))), dim=1)) if self.inference_mode: self.graph_obj.reid_emb_dists = torch.cat((emb_dists, emb_dists)) self.graph_obj.to( torch.device("cuda" if torch.cuda.is_available() and self.inference_mode else "cpu"))
def forward(self, output1, id1, output2, id2, flag): _, inx1 = torch.sort(id1) out1 = output1[inx1] _, inx2 = torch.sort(id2) out2 = output2[inx2] euclidean_distance = F.pairwise_distance(out1, out2) loss_contrastive = torch.mean( (1 - flag) * torch.pow(torch.clamp(euclidean_distance - 0, min=0.0), 2) + (flag) * torch.pow(torch.clamp(self.margin - euclidean_distance, min=0.0), 2)) return loss_contrastive
def kNN(self, n, input, target): dict = {} tmp = input.shape[1] length = len(target) for i in range(length): if n != i and target[n] == target[i]: dist = func.pairwise_distance(input[n].view(tmp, -1), input[i].view(tmp, -1)).sum() dict[i] = dist dict = sorted(dict.items(), key=lambda item: item[1]) nums = [] for i in range(len(dict)): if i < self.k: nums.append(dict[i][0]) else: return nums return nums
def forward(self, output1, output2, label): ''' Args: output1: 图片1(经过网路层的) output2: 图片2(经过网路层的) label: 表示是否为同一个类别,1 表示他们属于不同的类别, 反之为0 Returns: 返回损失 ''' euclidean_distance = F.pairwise_distance(output1, output2) # 计算距离 # 计算损失:当为同一类别时,我们希望距离小,那么计算出的损失小;当不为同一个类别的时候,我们希望距离大,距离小 loss_contrastive = torch.mean( (1 - label) * torch.pow(euclidean_distance, 2) + (label) * torch.pow(torch.clamp(self.margin - euclidean_distance, min=0.0), 2)) return loss_contrastive
def forward(self, x, label=None): out_anchor = torch.mean(x[:, 1:, :], 1) out_positive = x[:, 0, :] stepsize = out_anchor.size()[0] output = -1 * (F.pairwise_distance( out_positive.unsqueeze(-1).expand(-1, -1, stepsize), out_anchor.unsqueeze(-1).expand(-1, -1, stepsize).transpose(0, 2)) **2) label = torch.from_numpy(numpy.asarray(range(0, stepsize))).cuda() nloss = self.criterion(output, label) prec1, _ = accuracy(output.detach().cpu(), label.detach().cpu(), topk=(1, 5)) return nloss, prec1
def get_embedding_score(self, support_xf_ori, query_xf_ori, n_way, query_sz): # sum up samples with support k_shot = int(support_xf_ori.size(0) / n_way) if self.use_relation_net: ch_sz, spatial_sz = support_xf_ori.size(1), support_xf_ori.size(2) # support_xf_ori: 25/5, 256, 5, 5 # query_xf_ori: 75, 256, 5, 5 # first expand support_xf_ori = support_xf_ori.unsqueeze(0).expand( query_sz, -1, -1, -1, -1).contiguous().view(query_sz * n_way * k_shot, ch_sz, spatial_sz, spatial_sz) query_xf_ori = query_xf_ori.unsqueeze(1).expand( -1, n_way * k_shot, -1, -1, -1).contiguous().view(query_sz * n_way * k_shot, ch_sz, spatial_sz, spatial_sz) embed_combine = torch.stack([support_xf_ori, query_xf_ori], dim=1).view(query_sz * n_way * k_shot, -1, spatial_sz, spatial_sz) _out = self.relation2(self.relation1(embed_combine)) _out = _out.view(_out.size(0), -1) score = self.fc(_out).view(query_sz, n_way, k_shot) else: support_xf = support_xf_ori.view( support_xf_ori.size(0), -1) # size: 25/5 (support_sz/n_way) x feat_dim query_xf = query_xf_ori.view( query_xf_ori.size(0), -1) # size: 75 (query_size) x feat_dim feat_dim = support_xf.size(-1) support_xf = support_xf.unsqueeze(0).expand(query_sz, -1, -1).contiguous().view( -1, feat_dim) query_xf = query_xf.unsqueeze(1).expand(-1, n_way * k_shot, -1).contiguous().view( -1, feat_dim) score = -F.pairwise_distance(support_xf, query_xf, p=2) score = score.view(query_sz, n_way, k_shot) # sum up here score = torch.sum(score, dim=2, keepdim=False) return score
def triple_loss(args,targets, output,identity, eucledian): """ output: [N,3,100,100] tensor identity: tuple of 2x [N,512-args.num_dims,1,1 ] tensors eucledian: tuple of 2x [N,args.num_dims,1,1 ] tensors """ #Extract arguments x_eucledian=eucledian[0] # [N,args.num_dims,1,1 ] x_eucledian=x_eucledian.view(-1,x_eucledian.size(1)) #collapse to 2d [N,args.num_dims] y_eucledian=eucledian[1] #[N,args.num_dims,1,1 ] y_eucledian=y_eucledian.view(-1,y_eucledian.size(1)) #collapse to 2d [N,args.num_dims] x_identity=identity[0] #[N,512-args.num_dims,1,1 ] x_identity=x_identity.view(-1,x_identity.size(1)) #[N,512-args.num_dims] y_identity=identity[1] #[N,512-args.num_dims,1,1 ] y_identity=y_identity.view(-1,y_identity.size(1)) #[N,512-args.num_dims] #1 Reconstriction Loss recon_loss=reconstruction_loss(args,output,targets) #2 Eucledian space loss eucledian_loss=EucledianVectorLoss(type=args.loss_type) rotation_loss=eucledian_loss(x_eucledian,y_eucledian) #3 Idenity loss (L2 distance) identity_loss=F.pairwise_distance(x_identity,y_identity, p=2) identity_loss=identity_loss.mean() total_loss=args.alpha*rotation_loss + args.gamma * identity_loss + (1-args.alpha-args.gamma)*recon_loss return (total_loss,rotation_loss,identity_loss,recon_loss)
def vector(): dataloader_pre_post = DataLoader(dataset_pre_post, shuffle=True, num_workers=1, batch_size=1) data_iter = iter(dataloader_pre_post) while True: anchor_tuple, positive_tuple, _, anchor, positive, negative = next( data_iter) anchor_in, positive_in, negative_in = Variable(anchor).cuda( ), Variable(positive).cuda(), Variable(negative).cuda() (anchor_output, positive_output, _) = net_pre_post(anchor_in, positive_in, negative_in) same_distance = F.pairwise_distance(anchor_output, positive_output) anchor_output = anchor_output.data.cpu().numpy()[0] anchor_output = (np.array2string(anchor_output, precision=3, separator='\t,\t', suppress_small=True)) positive_output = positive_output.data.cpu().numpy()[0] positive_output = (np.array2string(positive_output, precision=3, separator='\t,\t', suppress_small=True)) same_distance = str(same_distance.data.cpu().numpy()[0][0]) same_distance = same_distance[:4] # output = str(anchor_output[:3]) + " ...." + str(anchor_output[-3:-1]) time.sleep(3) socketio.emit( 'vector', { 'img_a': anchor_tuple, 'img_p': positive_tuple, 'vector_a': str(anchor_output), 'vector_p': str(positive_output), 'distance': same_distance })
def forward_multi(self, x1, x2): ys = [] for i, x_s in enumerate([x1, x2]): if i == 0: x_mt = self.activation(self.fc1_left(x_s)) else: x_mt = self.activation(self.fc1_right(x_s)) x_mt = self.activation(self.fc3(x_mt)) x_mt = self.activation(self.fc4(x_mt)) ys.append(x_mt) if self.dist == 'linear': y = torch.cat((ys), 1) y = self.mt_activation(self.fc5(y)) elif self.dist == 'euclidean': y = torch.exp(-F.pairwise_distance(ys[0], ys[1])) elif self.dist == 'cosine': y = torch.exp(-F.cosine_similarity(ys[0], ys[1])) return (y)
def get_index(gf, query, qf): if opts.use_siamese: qf = qf.unsqueeze_(0).repeat(len(gf), 1) distance = F.pairwise_distance(qf, gf, keepdim=True) distance = distance.squeeze(1).cpu() distance = distance.numpy() # predict index index = np.argsort(distance) # from small to large else: score = torch.mm(gf, query) score = score.squeeze(1).cpu() score = score.numpy() # predict index index = np.argsort(score) # from small to large index = index[::-1] # index = index[0:2000] # good index return index
def test(model, loader, criterion, test_losses, write_pred, out_file): with torch.no_grad(): model.eval() N = 0 test_loss = 0.0 for i, (x1, x2, targets) in enumerate(loader): output1, output2 = model(x1,x2) N += x1.shape[0] test_loss += x1.shape[0] * criterion(output1, output2 , targets).item() #problem here test_losses.append(test_loss/N) eudist = F.pairwise_distance(output1, output2, keepdim = True) auc_results = auc_scores(targets, eudist[:,0]) target_log = targets.numpy() pred_log = eudist[:,0].numpy() assert len(target_log) == len(pred_log) if write_pred is True: np.savetxt(out_file, np.c_[target_log, pred_log], fmt='\t'.join(['%i'] + ['%1.15f'])) return test_loss/N, test_losses, auc_results
def get_loss(self, logits, gt_labels): cls_logits, pixel_loss, batch_center_vecs = logits gt = gt_labels.long() loss_cls = F.cross_entropy(cls_logits, gt) batch_size = gt_labels.size(0) unique_gt_labels = gt_labels.view(int(batch_size / 2), 2)[:, 0] # aux_loss_cls = F.cross_entropy(aux_logits, unique_gt_labels.long()) aux_loss_cls = F.pairwise_distance( self.center_feat_bank[unique_gt_labels].cuda().detach(), batch_center_vecs, 2) self.update_center_vec(gt_labels, batch_center_vecs.detach()) loss = loss_cls + self.loss_local_factor * pixel_loss.mean( ) + self.loss_global_factor * aux_loss_cls.mean() return loss, loss_cls, self.loss_local_factor * pixel_loss.mean( ), self.loss_global_factor * aux_loss_cls.mean()
def Test(net): folder_dataset_test = dset.ImageFolder(root=Config.testing_dir) siamese_dataset = SiameseNetworkDataset( imageFolderDataset=folder_dataset_test, should_invert=False) test_dataloader = DataLoader(siamese_dataset, num_workers=0, batch_size=1, shuffle=True) dataiter = iter(test_dataloader) x0, _, _ = next(dataiter) for i in range(10): _, x1, _ = next(dataiter) concatenated = torch.cat((x0, x1), 0) output1, output2 = net(Variable(x0).cuda(), Variable(x1).cuda()) euclidean_distance = F.pairwise_distance(output1, output2) imshow(torchvision.utils.make_grid(concatenated), 'Dissimilarity: {:.2f}'.format(euclidean_distance.item()))
def forward(self, output1, output2, output_class, siamese_label, class_label): euclidean_distance = F.pairwise_distance(output1, output2, 2) label = siamese_label.view(siamese_label.size()[0]) loss_same = label * torch.pow(euclidean_distance, 2) loss_diff = (1 - label) * torch.pow( torch.clamp(self.margin - euclidean_distance, min=0.0), 2) # print("same{}\t\tdiff{}".format(torch.mean(loss_same), torch.mean(loss_diff))) loss_contrastive = torch.mean(loss_same + loss_diff) loss_classify = self.loss_function(output_class, class_label) print("loss_classify{}\t\tloss_contrastive{}".format( loss_classify, loss_contrastive)) loss = loss_contrastive + loss_classify return loss
def cal_dis(x, y, num_category=20, all=False, n_frames=8): ave_dis = [] for s in range(num_category): idx = [] for i in range(x.shape[0]): category = info[str((i // n_frames if all else i) + start)] #category = int(info['video' + str(i + start)]) value = category * 0.05 if s != -1 and category != s: continue idx.append(i) cluster = torch.stack( [torch.from_numpy(x[idx]), torch.from_numpy(y[idx])], dim=1) center = cluster.mean(0).unsqueeze(0) ave_dis.append(F.pairwise_distance(center, cluster, p=2).view(-1)) ave_dis = torch.cat(ave_dis, 0).mean(0) print(ave_dis)
def is_goal_unreachable(a_net, state, goal, goal_dim, margin, device, absolute_goal=False): state = torch.from_numpy(state[:goal_dim]).float().to(device) goal = torch.from_numpy(goal).float().to(device) if not absolute_goal: goal = state + goal inputs = torch.stack((state, goal), dim=0) outputs = a_net(inputs) s_embedding = outputs[0] g_embedding = outputs[1] dist = F.pairwise_distance(s_embedding.unsqueeze(0), g_embedding.unsqueeze(0)).squeeze() return dist > margin
def test(): model.load_state_dict(torch.load('./checkpoints/2.pth')['model']) dataset = dset.ImageFolder(cfg.training_dir) siamese_dataset = FaceData(dataset, transform=transforms.Compose([ transforms.Resize((100, 100)), transforms.ToTensor() ])) train_loader = DataLoader(siamese_dataset, batch_size=1, shuffle=True) for sample in train_loader: img0, img1, label = sample output1, output2 = model(img0, img1) euclidean_distance = F.pairwise_distance(output1, output2, keepdim=True) print(euclidean_distance, label) concatenated = torch.cat((sample[0], sample[1]), 0) imshow(torchvision.utils.make_grid(concatenated))
def api(face_im): face_input = torch.unsqueeze(img_transform(face_im), dim=0) model.load_state_dict( torch.load(r'E:\code\FaceRecognition-tensorflow\checkpoints\2.pth') ['model']) dataset = dset.ImageFolder(cfg.training_dir) clss = dataset.class_to_idx.keys() for cls in clss: print(cls) cls_dir = os.path.join(cfg.training_dir, cls) for im in os.listdir(cls_dir): cls_im = Image.open(os.path.join(cls_dir, im)) cls_input = torch.unsqueeze(img_transform(cls_im), dim=0) output1, output2 = model(face_input, cls_input) euclidean_distance = F.pairwise_distance(output1, output2, keepdim=True) print(int(euclidean_distance.detach()))
def forward(self, output1, output2, label): # Euclidean distance of two output feature vectors euclidean_distance = F.pairwise_distance(output1, output2) euclidean_distance = torch.pow(euclidean_distance, 2) # Normalization of the distance normalized_distance = 2 * (1 / (1 + torch.exp(-euclidean_distance)) - 0.5) # Contrastive Loss Function # # perform contrastive loss calculation with the distance # loss_contrastive = torch.mean((1 - label) * torch.pow(euclidean_distance, 2) + # (label) * torch.pow(torch.clamp(self.margin - euclidean_distance, min=0.0), 2)) # Normalized Double-Margin Contrastive Loss Function loss = 0.5 * torch.mean(label * torch.clamp(normalized_distance - self.margin_positive, min=0.0) + (1 - label) * torch.clamp(self.margin_negative - normalized_distance, min=0.0)) return loss, normalized_distance
def deepcompare_siam2stream_l2(input, params): def single(patch): return F.normalize(streams(patch, params)) return - F.pairwise_distance(*map(single, input.split(1, dim=1)))
def forward(self,output1,output2,label): euclidean_distance=F.pairwise_distance(output1,output2) loss_contrastive=torch.mean((1-label)*torch.pow(euclidean_distance,2)+label*torch.pow(torch.clamp(self.margin-euclidean_distance,min=0.0),2)) return loss_contrastive