temp

how/layers/functional.py

@@ -3,7 +3,7 @@
 import torch
 import torch.nn.functional as F
 
-import cirtorch.layers.functional as CF
+# import cirtorch.layers.functional as CF
 
 
 def smoothing_avg_pooling(feats, kernel_size):
@@ -18,17 +18,17 @@ def smoothing_avg_pooling(feats, kernel_size):
                         count_include_pad=False)
 
 
-def weighted_spoc(ms_feats, ms_weights):
-    """Weighted SPoC pooling, summed over scales.
+# def weighted_spoc(ms_feats, ms_weights):
+#     """Weighted SPoC pooling, summed over scales.
 
-    :param list ms_feats: A list of feature maps, each at a different scale
-    :param list ms_weights: A list of weights, each at a different scale
-    :return torch.Tensor: L2-normalized global descriptor
-    """
-    desc = torch.zeros((1, ms_feats[0].shape[1]), dtype=torch.float32, device=ms_feats[0].device)
-    for feats, weights in zip(ms_feats, ms_weights):
-        desc += (feats * weights).sum((-2, -1)).squeeze()
-    return CF.l2n(desc)
+#     :param list ms_feats: A list of feature maps, each at a different scale
+#     :param list ms_weights: A list of weights, each at a different scale
+#     :return torch.Tensor: L2-normalized global descriptor
+#     """
+#     desc = torch.zeros((1, ms_feats[0].shape[1]), dtype=torch.float32, device=ms_feats[0].device)
+#     for feats, weights in zip(ms_feats, ms_weights):
+#         desc += (feats * weights).sum((-2, -1)).squeeze()
+#     return CF.l2n(desc)
 
 
 def how_select_local(ms_feats, ms_masks, *, scales, features_num):

how/networks/how_net.py

@@ -5,12 +5,6 @@ import torch
 import torch.nn as nn
 import torchvision
 
-from .. import layers
-from ..layers import functional as HF
-from ..utils import io_helpers
-
-NUM_WORKERS = 6
-
 
 class HOWNet(nn.Module):
     """Network for the HOW method
@@ -70,7 +64,6 @@ class HOWNet(nn.Module):
 
 
     # Forward
-
     def features_attentions(self, x, *, scales):
         """Return a tuple (features, attentions) where each is a list containing requested scales"""
         feats = []
@@ -99,50 +92,3 @@ class HOWNet(nn.Module):
     def meta_repr(self):
         """Return meta representation"""
         return str(self)
-
-
-def init_network(architecture, pretrained, skip_layer, dim_reduction, smoothing, runtime):
-    """Initialize HOW network
-
-    :param str architecture: Network backbone architecture (e.g. resnet18)
-    :param bool pretrained: Whether to start with a network pretrained on ImageNet
-    :param int skip_layer: How many layers of blocks should be skipped (from the end)
-    :param dict dim_reduction: Options for the dimensionality reduction layer
-    :param dict smoothing: Options for the smoothing layer
-    :param dict runtime: Runtime options to be stored in the network
-    :return HOWNet: Initialized network
-    """
-    # Take convolutional layers as features, always ends with ReLU to make last activations non-negative
-    net_in = getattr(torchvision.models, architecture)(pretrained=pretrained)
-    if architecture.startswith('alexnet') or architecture.startswith('vgg'):
-        features = list(net_in.features.children())[:-1]
-    elif architecture.startswith('resnet'):
-        features = list(net_in.children())[:-2]
-    elif architecture.startswith('densenet'):
-        features = list(net_in.features.children()) + [nn.ReLU(inplace=True)]
-    elif architecture.startswith('squeezenet'):
-        features = list(net_in.features.children())
-    else:
-        raise ValueError('Unsupported or unknown architecture: {}!'.format(architecture))
-
-    if skip_layer > 0:
-        features = features[:-skip_layer]
-    backbone_dim = 2048 // (2 ** skip_layer)
-
-    att_layer = layers.attention.L2Attention()
-    smooth_layer = None
-    if smoothing:
-        smooth_layer = layers.pooling.SmoothingAvgPooling(**smoothing)
-    reduction_layer = None
-    if dim_reduction:
-        reduction_layer = layers.dim_reduction.ConvDimReduction(**dim_reduction, input_dim=backbone_dim)
-
-    meta = {
-        "architecture": architecture,
-        "backbone_dim": backbone_dim,
-        "outputdim": reduction_layer.out_channels if dim_reduction else backbone_dim,
-        "corercf_size": 32 // (2 ** skip_layer),
-    }
-    return HOWNet(nn.Sequential(*features), att_layer, smooth_layer, reduction_layer, meta, runtime)
-
-