Update methods.py

methods.py

@@ -60,83 +60,13 @@ def occlusion(img1, img2, model, w_size = 64, stride = 8, batch_size = 32):
 
     heatmap1 = (heatmap1 - base_score.item()) * -1   # or base_score.item() - heatmap1. The higher the drop, the better
     heatmap2 = (heatmap2 - base_score.item()) * -1   # or base_score.item() - heatmap2. The higher the drop, the better
-    
-    return heatmap1, heatmap2
-
-def occlusion_context_agnositc(img1, img2, model, w_size = 64, stride = 8, batch_size = 32):
-    
-    measure = nn.CosineSimilarity(dim=-1) 
-    output_size = int(((img2.size(-1) - w_size) / stride) + 1)
-    out1_condition, out2_condition = model(img1), model(img2)
-
-    images1_occlude_mask = []
-    images2_occlude_mask  = []
-
-    for i in range(output_size):
-        for j in range(output_size):
-            start_i, start_j = i * stride, j * stride
-            image1 = img1.clone().detach()
-            image2 = img2.clone().detach()
-            image1[:, :, start_i : start_i + w_size, start_j : start_j + w_size] = 0  
-            image2[:, :, start_i : start_i + w_size, start_j : start_j + w_size] = 0  
-            images1_occlude_mask.append(image1)
-            images2_occlude_mask.append(image2)
-
-    images1_occlude_mask = torch.cat(images1_occlude_mask, dim=0).to(device)
-    images2_occlude_mask = torch.cat(images2_occlude_mask, dim=0).to(device)
-
-    images1_occlude_backround = []
-    images2_occlude_backround = []
-
-    copy_img1 = img1.clone().detach()
-    copy_img2 = img2.clone().detach()
-
-    for i in range(output_size):
-        for j in range(output_size):
-            start_i, start_j = i * stride, j * stride
-
-            image1 = torch.zeros_like(img1)
-            image2 = torch.zeros_like(img2)
-
-            image1[:, :, start_i : start_i + w_size, start_j : start_j + w_size] = copy_img1[:, :, start_i : start_i + w_size, start_j : start_j + w_size]
-            image2[:, :, start_i : start_i + w_size, start_j : start_j + w_size] = copy_img2[:, :, start_i : start_i + w_size, start_j : start_j + w_size]
-
-            images1_occlude_backround.append(image1)
-            images2_occlude_backround.append(image2)
-
-    images1_occlude_backround = torch.cat(images1_occlude_backround, dim=0).to(device)
-    images2_occlude_backround = torch.cat(images2_occlude_backround, dim=0).to(device)
-
-    score_map1 = []
-    score_map2 = []
-
-    assert images1_occlude_mask.shape[0] == images2_occlude_mask.shape[0]
-
-    for b in range(0, images1_occlude_mask.shape[0], batch_size):
-
-        with torch.no_grad():
-            out1_mask = model(images1_occlude_mask[b : b + batch_size, :])
-            out2_mask = model(images2_occlude_mask[b : b + batch_size, :])
-            out1_backround = model(images1_occlude_backround[b : b + batch_size, :])
-            out2_backround = model(images2_occlude_backround[b : b + batch_size, :])
-
-        out1 = out1_backround - out1_mask
-        out2 = out2_backround - out2_mask
-        score_map1.append(measure(out1, out2_condition))  # or torch.mm(out2_condition, out1.t())[0]
-        score_map2.append(measure(out1_condition, out2))  # or torch.mm(out1_condition, out2.t())[0]
-
-    score_map1 = torch.cat(score_map1, dim = 0)   
-    score_map2 = torch.cat(score_map2, dim = 0)    
-    assert images1_occlude_mask.shape[0] == images2_occlude_mask.shape[0] == score_map2.shape[0] == score_map1.shape[0]
-
-    heatmap1 = score_map1.view(output_size, output_size).cpu().detach().numpy()
-    heatmap2 = score_map2.view(output_size, output_size).cpu().detach().numpy()
 
     heatmap1 = (heatmap1 - heatmap1.min()) / (heatmap1.max() - heatmap1.min())
     heatmap2 = (heatmap2 - heatmap2.min()) / (heatmap2.max() - heatmap2.min())
     
     return heatmap1, heatmap2
 
+
 def pairwise_occlusion(img1, img2, model, batch_size, erase_scale, erase_ratio, num_erases):
 
     measure = nn.CosineSimilarity(dim=-1) 
@@ -338,81 +268,6 @@ def smooth_grad(guided, ssl_model, img1, img2, blur_output, steps = 50):
             
     return sailency1, sailency2
 
-def get_sample_dataset(img_path, num_augments, batch_size, no_shift_transforms, ssl_model, n_components):
-    
-    measure = nn.CosineSimilarity(dim=-1)
-    img = Image.open(img_path).convert('RGB') if isinstance(img_path, str) else img_path
-    no_shift_aug = transforms.Compose([no_shift_transforms['aug'], 
-                                       transforms.RandomErasing(p=0.5, scale=(0.02, 0.33), ratio=(0.3, 3.3))]) 
-
-    augments2 =  [no_shift_aug(img).unsqueeze(0) for _ in range(num_augments)]
-    data_samples1 = no_shift_transforms['pure'](img).unsqueeze(0).expand(num_augments, -1, -1, -1).to(device) 
-    data_samples2 = torch.cat(augments2).to(device) 
-    
-    labels = []
-    feats_invariance = []
-
-    for b in range(0, data_samples1.shape[0], batch_size):
-
-        with torch.no_grad():
-            out1 = ssl_model(data_samples1[b : b + batch_size, :])
-            out2 = ssl_model(data_samples2[b : b + batch_size, :])
-            labels.append(measure(out1, out2))
-            feats_invariance.append(F.relu(out2))
-
-    data_labels = torch.cat(labels).unsqueeze(-1).to(device)
-    feats_invariance = torch.cat(feats_invariance).to(device)
-    nmf_model = NMF(n_components=n_components, init='random')
-    # (T, 2048) = W.H = (2048,N) . (N,T), where H is the matrix representing the features of each transform 
-    H = nmf_model.fit_transform(feats_invariance.cpu().numpy())
-    labels_invariance = torch.from_numpy(H.mean(1)).unsqueeze(-1).to(device)
-    
-    return data_samples1, data_samples2, data_labels, labels_invariance
-
-def pixel_invariance(data_samples1, data_samples2, data_labels, labels_invariance, resize_transform, size, epochs, learning_rate, l1_weight, zero_small_values, blur_output, nmf_weight):
-    
-    """
-    size: resize the image to that when training the surrogate. Later we upsize
-    epochs: number of epochs to train the surrogate model
-    learning_rate: learning rate to train the surrogate model
-    l1_weight: if not None, enables l1 regularization (sparsity)
-    """
-    x1 = resize_transform((size, size))(data_samples1)      # (num_samples, 3, size, size)
-    x2 = resize_transform((size, size))(data_samples2)      # (num_samples, 3, size, size)
-
-    x1 = x1.reshape(x1.size(0), -1).to(device)
-    x2 = x2.reshape(x2.size(0), -1).to(device)
-    
-    surrogate = nn.Linear(size * size * 3, 1).to(device)
-
-    criterion = nn.BCEWithLogitsLoss(reduction = 'sum')
-    invariance_criterion = nn.MSELoss()
-    optimizer = torch.optim.SGD(surrogate.parameters(), lr=learning_rate)
-
-    for epoch in range(epochs):
-        pred1, pred2 = surrogate(x1), surrogate(x2) 
-        preds = (pred1 + pred2) / 2
-        loss = criterion(preds, data_labels)
-        loss += nmf_weight * invariance_criterion(torch.sigmoid(preds), labels_invariance)
-
-        if l1_weight is not None:
-            loss += l1_weight * sum(p.abs().sum() for p in surrogate.parameters())
-
-        optimizer.zero_grad() 
-        loss.backward()
-        optimizer.step()
-    
-    heatmap = surrogate.weight.reshape(3, size, size)
-    heatmap, _ = torch.max(heatmap, 0)
-    heatmap = (heatmap - heatmap.min()) / (heatmap.max() - heatmap.min())
-    
-    if zero_small_values:
-        heatmap[heatmap < 0.5] = 0
-        
-    if blur_output:
-        heatmap = blur_sailency(heatmap.unsqueeze(0)).squeeze(0)
-    
-    return heatmap
 
 class GradCAM(nn.Module):