temp

app.py

@@ -2,8 +2,6 @@ import gradio as gr
 
 import torch
 
-from how.networks import how_net
-
 import fire_network
 
 import cv2
@@ -30,7 +28,7 @@ sf_idx_ = [55, 14, 5, 4, 52, 57, 40, 9]
 
 col = plt.get_cmap('tab10')
 
-def generate_matching_superfeatures(im1, im2, scale=6):
+def generate_matching_superfeatures(im1, im2, scale_id=6, threshold=50):
     
     im1_tensor = transform(im1)
     im2_tensor = transform(im2)

fire_network.py

@@ -7,11 +7,10 @@ from torch import nn
 import torchvision
 
 from how import layers
-from how.layers import functional as HF
 
 from lit import LocalfeatureIntegrationTransformer
 
-from how.networks.how_net import HOWNet, CORERCF_SIZE
+from how.networks.how_net import HOWNet
 
 class FIReNet(HOWNet):
 
@@ -62,20 +61,9 @@ class FIReNet(HOWNet):
         return feats, attns, strengths
         
     def forward(self, x):
-        if self.return_global:
-            return self.forward_global(x, scales=self.runtime['training_scales'])
         return self.get_superfeatures(x, scales=self.runtime['training_scales'])
         
-    def forward_global(self, x, *, scales):
-        """Return global descriptor"""
-        feats, _, strengths = self.get_superfeatures(x, scales=scales)
-        return HF.weighted_spoc(feats, strengths)
-        
-    def forward_local(self, x, *, features_num, scales):
-        """Return selected super features"""
-        feats, _, strengths = self.get_superfeatures(x, scales=scales)
-        return HF.how_select_local(feats, strengths, scales=scales, features_num=features_num)
-
+    
 def init_network(architecture, pretrained, skip_layer, dim_reduction, lit, runtime):
     """Initialize FIRe network
     :param str architecture: Network backbone architecture (e.g. resnet18)
@@ -115,7 +103,7 @@ def init_network(architecture, pretrained, skip_layer, dim_reduction, lit, runti
         "architecture": architecture,
         "backbone_dim": lit['dim'],
         "outputdim": reduction_layer.out_channels if dim_reduction else lit['dim'],
-        "corercf_size": CORERCF_SIZE[architecture] // (2 ** skip_layer),
+        "corercf_size": 32 // (2 ** skip_layer),
     }
     net = FIReNet(nn.Sequential(*features), att_layer, lit_layer, reduction_layer, meta, runtime)
     

how/networks/how_net.py

@@ -5,20 +5,12 @@ import torch
 import torch.nn as nn
 import torchvision
 
-from cirtorch.networks import imageretrievalnet
-
 from .. import layers
 from ..layers import functional as HF
 from ..utils import io_helpers
 
 NUM_WORKERS = 6
 
-CORERCF_SIZE = {
-    'resnet18': 32,
-    'resnet50': 32,
-    'resnet101': 32,
-}
-
 
 class HOWNet(nn.Module):
     """Network for the HOW method
@@ -100,22 +92,6 @@ class HOWNet(nn.Module):
 
         return feats, masks
 
-    def forward(self, x):
-        return self.forward_global(x, scales=self.runtime['training_scales'])
-
-    def forward_global(self, x, *, scales):
-        """Return global descriptor"""
-        feats, masks = self.features_attentions(x, scales=scales)
-        return HF.weighted_spoc(feats, masks)
-
-    def forward_local(self, x, *, features_num, scales):
-        """Return local descriptors"""
-        feats, masks = self.features_attentions(x, scales=scales)
-        return HF.how_select_local(feats, masks, scales=scales, features_num=features_num)
-
-
-    # String conversion
-
     def __repr__(self):
         meta_str = "\n".join("    %s: %s" % x for x in self.meta.items())
         return "%s(meta={\n%s\n})" % (self.__class__.__name__, meta_str)
@@ -151,7 +127,7 @@ def init_network(architecture, pretrained, skip_layer, dim_reduction, smoothing,
 
     if skip_layer > 0:
         features = features[:-skip_layer]
-    backbone_dim = imageretrievalnet.OUTPUT_DIM[architecture] // (2 ** skip_layer)
+    backbone_dim = 2048 // (2 ** skip_layer)
 
     att_layer = layers.attention.L2Attention()
     smooth_layer = None
@@ -165,57 +141,8 @@ def init_network(architecture, pretrained, skip_layer, dim_reduction, smoothing,
         "architecture": architecture,
         "backbone_dim": backbone_dim,
         "outputdim": reduction_layer.out_channels if dim_reduction else backbone_dim,
-        "corercf_size": CORERCF_SIZE[architecture] // (2 ** skip_layer),
+        "corercf_size": 32 // (2 ** skip_layer),
     }
     return HOWNet(nn.Sequential(*features), att_layer, smooth_layer, reduction_layer, meta, runtime)
 
 
-def extract_vectors(net, dataset, device, *, scales):
-    """Return global descriptors in torch.Tensor"""
-    net.eval()
-    loader = torch.utils.data.DataLoader(dataset, shuffle=False, pin_memory=True, num_workers=NUM_WORKERS)
-
-    with torch.no_grad():
-        vecs = torch.zeros(len(loader), net.meta['outputdim'])
-        for i, inp in io_helpers.progress(enumerate(loader), size=len(loader), print_freq=100):
-            vecs[i] = net.forward_global(inp.to(device), scales=scales).cpu().squeeze()
-
-    return vecs
-
-
-def extract_vectors_local(net, dataset, device, *, features_num, scales):
-    """Return tuple (local descriptors, image ids, strenghts, locations and scales) where locations
-        consists of (coor_x, coor_y, scale) and elements of each list correspond to each other"""
-    net.eval()
-    loader = torch.utils.data.DataLoader(dataset, shuffle=False, pin_memory=True, num_workers=NUM_WORKERS)
-
-    with torch.no_grad():
-        vecs, strengths, locs, scls, imids = [], [], [], [], []
-        for imid, inp in io_helpers.progress(enumerate(loader), size=len(loader), print_freq=100):
-            output = net.forward_local(inp.to(device), features_num=features_num, scales=scales)
-
-            vecs.append(output[0].cpu().numpy())
-            strengths.append(output[1].cpu().numpy())
-            locs.append(output[2].cpu().numpy())
-            scls.append(output[3].cpu().numpy())
-            imids.append(np.full((output[0].shape[0],), imid))
-
-    return np.vstack(vecs), np.hstack(imids), np.hstack(strengths), np.vstack(locs), np.hstack(scls)
-
-
-
-def extract_vectors_all(net, dataset, device, *, features_num, scales):
-    """Return tuple (local descriptors, image ids, strenghts, locations and scales) where locations
-        consists of (coor_x, coor_y, scale) and elements of each list correspond to each other"""
-    net.eval()
-    loader = torch.utils.data.DataLoader(dataset, shuffle=False, pin_memory=True, num_workers=NUM_WORKERS)
-
-    with torch.no_grad():
-        feats, attns, strenghts = [], [], []
-        for imid, inp in io_helpers.progress(enumerate(loader), size=len(loader), print_freq=100):
-            output = net.get_superfeatures(inp.to(device), scales=scales)
-            feats.append(output[0])
-            attns.append(output[1])
-            strenghts.append(output[2])
-
-    return feats, attns, strenghts