tam

app.py

@@ -1,28 +0,0 @@
-import argparse
-from pathlib import Path
-from common.app_class import ImageMatchingApp
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--server_name",
-        type=str,
-        default="0.0.0.0",
-        help="server name",
-    )
-    parser.add_argument(
-        "--server_port",
-        type=int,
-        default=7860,
-        help="server port",
-    )
-    parser.add_argument(
-        "--config",
-        type=str,
-        default=Path(__file__).parent / "common/config.yaml",
-        help="config file",
-    )
-    args = parser.parse_args()
-    ImageMatchingApp(
-        args.server_name, args.server_port, config=args.config
-    ).run()

test_app_cli.py

@@ -1,114 +0,0 @@
-import cv2
-import warnings
-import numpy as np
-from pathlib import Path
-from hloc import logger
-from common.utils import (
-    get_matcher_zoo,
-    load_config,
-    DEVICE,
-    ROOT,
-)
-from common.api import ImageMatchingAPI
-
-
-def test_all(config: dict = None):
-    img_path1 = ROOT / "datasets/sacre_coeur/mapping/02928139_3448003521.jpg"
-    img_path2 = ROOT / "datasets/sacre_coeur/mapping/17295357_9106075285.jpg"
-    image0 = cv2.imread(str(img_path1))[:, :, ::-1]  # RGB
-    image1 = cv2.imread(str(img_path2))[:, :, ::-1]  # RGB
-
-    matcher_zoo_restored = get_matcher_zoo(config["matcher_zoo"])
-    for k, v in matcher_zoo_restored.items():
-        if image0 is None or image1 is None:
-            logger.error("Error: No images found! Please upload two images.")
-        enable = config["matcher_zoo"][k].get("enable", True)
-        skip_ci = config["matcher_zoo"][k].get("skip_ci", False)
-        if enable and not skip_ci:
-            logger.info(f"Testing {k} ...")
-            api = ImageMatchingAPI(conf=v, device=DEVICE)
-            api(image0, image1)
-            log_path = ROOT / "experiments" / "all"
-            log_path.mkdir(exist_ok=True, parents=True)
-            api.visualize(log_path=log_path)
-        else:
-            logger.info(f"Skipping {k} ...")
-    return 0
-
-
-def test_one():
-    img_path1 = ROOT / "datasets/sacre_coeur/mapping/02928139_3448003521.jpg"
-    img_path2 = ROOT / "datasets/sacre_coeur/mapping/17295357_9106075285.jpg"
-    image0 = cv2.imread(str(img_path1))[:, :, ::-1]  # RGB
-    image1 = cv2.imread(str(img_path2))[:, :, ::-1]  # RGB
-    # sparse
-    conf = {
-        "feature": {
-            "output": "feats-superpoint-n4096-rmax1600",
-            "model": {
-                "name": "superpoint",
-                "nms_radius": 3,
-                "max_keypoints": 4096,
-                "keypoint_threshold": 0.005,
-            },
-            "preprocessing": {
-                "grayscale": True,
-                "force_resize": True,
-                "resize_max": 1600,
-                "width": 640,
-                "height": 480,
-                "dfactor": 8,
-            },
-        },
-        "matcher": {
-            "output": "matches-NN-mutual",
-            "model": {
-                "name": "nearest_neighbor",
-                "do_mutual_check": True,
-                "match_threshold": 0.2,
-            },
-        },
-        "dense": False,
-    }
-    api = ImageMatchingAPI(conf=conf, device=DEVICE)
-    api(image0, image1)
-    log_path = ROOT / "experiments" / "one"
-    log_path.mkdir(exist_ok=True, parents=True)
-    api.visualize(log_path=log_path)
-
-    # dense
-    conf = {
-        "matcher": {
-            "output": "matches-loftr",
-            "model": {
-                "name": "loftr",
-                "weights": "outdoor",
-                "max_keypoints": 2000,
-                "match_threshold": 0.2,
-            },
-            "preprocessing": {
-                "grayscale": True,
-                "resize_max": 1024,
-                "dfactor": 8,
-                "width": 640,
-                "height": 480,
-                "force_resize": True,
-            },
-            "max_error": 1,
-            "cell_size": 1,
-        },
-        "dense": True,
-    }
-
-    api = ImageMatchingAPI(conf=conf, device=DEVICE)
-    api(image0, image1)
-    log_path = ROOT / "experiments" / "one"
-    log_path.mkdir(exist_ok=True, parents=True)
-    api.visualize(log_path=log_path)
-    return 0
-
-
-if __name__ == "__main__":
-    config = load_config(ROOT / "common/config.yaml")
-    test_one()
-    test_all(config)

third_party/ALIKE/LICENSE

@@ -1,29 +0,0 @@
-BSD 3-Clause License
-
-Copyright (c) 2022, Zhao Xiaoming
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-1. Redistributions of source code must retain the above copyright notice, this
-   list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright notice,
-   this list of conditions and the following disclaimer in the documentation
-   and/or other materials provided with the distribution.
-
-3. Neither the name of the copyright holder nor the names of its
-   contributors may be used to endorse or promote products derived from
-   this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

third_party/ALIKE/README.md

@@ -1,131 +0,0 @@
-# News
-
-- The [ALIKED](https://github.com/Shiaoming/ALIKED) is released.
-- The [ALIKE training code](https://github.com/Shiaoming/ALIKE/raw/main/assets/ALIKE_code.zip) is released.
-
-# ALIKE: Accurate and Lightweight Keypoint Detection and Descriptor Extraction
-
-ALIKE applies a differentiable keypoint detection module to detect accurate sub-pixel keypoints. The network can run at 95 frames per second for 640 x 480 images on NVIDIA Titan X (Pascal) GPU and achieve equivalent performance with the state-of-the-arts. ALIKE benefits real-time applications in resource-limited platforms/devices. Technical details are described in [this paper](https://arxiv.org/pdf/2112.02906.pdf).
-
-> ```
-> Xiaoming Zhao, Xingming Wu, Jinyu Miao, Weihai Chen, Peter C. Y. Chen, Zhengguo Li, "ALIKE: Accurate and Lightweight Keypoint
-> Detection and Descriptor Extraction," IEEE Transactions on Multimedia, 2022.
-> ```
-
-![](./assets/alike.png)
-
-
-If you use ALIKE in an academic work, please cite:
-
-```
-@article{Zhao2023ALIKED,
-    title = {ALIKED: A Lighter Keypoint and Descriptor Extraction Network via Deformable Transformation},
-    url = {https://arxiv.org/pdf/2304.03608.pdf},
-    doi = {10.1109/TIM.2023.3271000},
-    journal = {IEEE Transactions on Instrumentation & Measurement},
-    author = {Zhao, Xiaoming and Wu, Xingming and Chen, Weihai and Chen, Peter C. Y. and Xu, Qingsong and Li, Zhengguo},
-    year = {2023},
-    volume = {72},
-    pages = {1-16},
-}
-
-@article{Zhao2022ALIKE,
-    title = {ALIKE: Accurate and Lightweight Keypoint Detection and Descriptor Extraction},
-    url = {http://arxiv.org/abs/2112.02906},
-    doi = {10.1109/TMM.2022.3155927},
-    journal = {IEEE Transactions on Multimedia},
-    author = {Zhao, Xiaoming and Wu, Xingming and Miao, Jinyu and Chen, Weihai and Chen, Peter C. Y. and Li, Zhengguo},
-    month = march,
-    year = {2022},
-}
-```
-
-
-
-## 1. Prerequisites
-
-The required packages are listed in the `requirements.txt` :
-
-```shell
-pip install -r requirements.txt
-```
-
-
-
-## 2. Models
-
-The off-the-shelf weights of four variant ALIKE models are provided in `models/` .
-
-
-
-## 3. Run demo
-
-```shell
-$ python demo.py -h
-usage: demo.py [-h] [--model {alike-t,alike-s,alike-n,alike-l}]
-               [--device DEVICE] [--top_k TOP_K] [--scores_th SCORES_TH]
-               [--n_limit N_LIMIT] [--no_display] [--no_sub_pixel]
-               input
-
-ALike Demo.
-
-positional arguments:
-  input                 Image directory or movie file or "camera0" (for
-                        webcam0).
-
-optional arguments:
-  -h, --help            show this help message and exit
-  --model {alike-t,alike-s,alike-n,alike-l}
-                        The model configuration
-  --device DEVICE       Running device (default: cuda).
-  --top_k TOP_K         Detect top K keypoints. -1 for threshold based mode,
-                        >0 for top K mode. (default: -1)
-  --scores_th SCORES_TH
-                        Detector score threshold (default: 0.2).
-  --n_limit N_LIMIT     Maximum number of keypoints to be detected (default:
-                        5000).
-  --no_display          Do not display images to screen. Useful if running
-                        remotely (default: False).
-  --no_sub_pixel        Do not detect sub-pixel keypoints (default: False).
-```
-
-
-
-## 4. Examples
-
-### KITTI example
-```shell
-python demo.py assets/kitti 
-```
-![](./assets/kitti.gif)
-
-### TUM example
-```shell
-python demo.py assets/tum 
-```
-![](./assets/tum.gif)
-
-## 5. Efficiency and performance
-
-| Models | Parameters | GFLOPs(640x480) | MHA@3 on Hpatches | mAA(10°) on [IMW2020-test](https://www.cs.ubc.ca/research/image-matching-challenge/2021/leaderboard) (Stereo) |
-|:---:|:---:|:---:|:-----------------:|:-------------------------------------------------------------------------------------------------------------:|
-| D2-Net(MS) | 7653KB | 889.40 |      38.33%       |                                                    12.27%                                                     |
-| LF-Net(MS) | 2642KB | 24.37 |      57.78%       |                                                    23.44%                                                     |
-| SuperPoint | 1301KB | 26.11 |      70.19%       |                                                    28.97%                                                     |
-| R2D2(MS) | 484KB | 464.55 |      71.48%       |                                                    39.02%                                                     |
-| ASLFeat(MS) | 823KB | 77.58 |      73.52%       |                                                    33.65%                                                     |
-| DISK | 1092KB | 98.97 |      70.56%       |                                                    51.22%                                                     |
-| ALike-N | 318KB | 7.909 |      75.74%       |                                                    47.18%                                                     |
-| ALike-L | 653KB | 19.685 |      76.85%       |                                                    49.58%                                                     |
-
-### Evaluation on Hpatches
-
-- Download [hpatches-sequences-release](https://hpatches.github.io/) and put it into `hseq/hpatches-sequences-release`.
-- Remove the unreliable sequences as D2-Net.
-- Run the following command to evaluate the performance:
-  ```shell  
-  python hseq/eval.py
-  ```
-
-
-For more details, please refer to the [paper](https://arxiv.org/abs/2112.02906).

third_party/ALIKE/alike.py

@@ -1,198 +0,0 @@
-import logging
-import os
-import cv2
-import torch
-from copy import deepcopy
-import torch.nn.functional as F
-from torchvision.transforms import ToTensor
-import math
-
-from alnet import ALNet
-from soft_detect import DKD
-import time
-
-configs = {
-    "alike-t": {
-        "c1": 8,
-        "c2": 16,
-        "c3": 32,
-        "c4": 64,
-        "dim": 64,
-        "single_head": True,
-        "radius": 2,
-        "model_path": os.path.join(os.path.split(__file__)[0], "models", "alike-t.pth"),
-    },
-    "alike-s": {
-        "c1": 8,
-        "c2": 16,
-        "c3": 48,
-        "c4": 96,
-        "dim": 96,
-        "single_head": True,
-        "radius": 2,
-        "model_path": os.path.join(os.path.split(__file__)[0], "models", "alike-s.pth"),
-    },
-    "alike-n": {
-        "c1": 16,
-        "c2": 32,
-        "c3": 64,
-        "c4": 128,
-        "dim": 128,
-        "single_head": True,
-        "radius": 2,
-        "model_path": os.path.join(os.path.split(__file__)[0], "models", "alike-n.pth"),
-    },
-    "alike-l": {
-        "c1": 32,
-        "c2": 64,
-        "c3": 128,
-        "c4": 128,
-        "dim": 128,
-        "single_head": False,
-        "radius": 2,
-        "model_path": os.path.join(os.path.split(__file__)[0], "models", "alike-l.pth"),
-    },
-}
-
-
-class ALike(ALNet):
-    def __init__(
-        self,
-        # ================================== feature encoder
-        c1: int = 32,
-        c2: int = 64,
-        c3: int = 128,
-        c4: int = 128,
-        dim: int = 128,
-        single_head: bool = False,
-        # ================================== detect parameters
-        radius: int = 2,
-        top_k: int = 500,
-        scores_th: float = 0.5,
-        n_limit: int = 5000,
-        device: str = "cpu",
-        model_path: str = "",
-    ):
-        super().__init__(c1, c2, c3, c4, dim, single_head)
-        self.radius = radius
-        self.top_k = top_k
-        self.n_limit = n_limit
-        self.scores_th = scores_th
-        self.dkd = DKD(
-            radius=self.radius,
-            top_k=self.top_k,
-            scores_th=self.scores_th,
-            n_limit=self.n_limit,
-        )
-        self.device = device
-
-        if model_path != "":
-            state_dict = torch.load(model_path, self.device)
-            self.load_state_dict(state_dict)
-            self.to(self.device)
-            self.eval()
-            logging.info(f"Loaded model parameters from {model_path}")
-            logging.info(
-                f"Number of model parameters: {sum(p.numel() for p in self.parameters() if p.requires_grad) / 1e3}KB"
-            )
-
-    def extract_dense_map(self, image, ret_dict=False):
-        # ====================================================
-        # check image size, should be integer multiples of 2^5
-        # if it is not a integer multiples of 2^5, padding zeros
-        device = image.device
-        b, c, h, w = image.shape
-        h_ = math.ceil(h / 32) * 32 if h % 32 != 0 else h
-        w_ = math.ceil(w / 32) * 32 if w % 32 != 0 else w
-        if h_ != h:
-            h_padding = torch.zeros(b, c, h_ - h, w, device=device)
-            image = torch.cat([image, h_padding], dim=2)
-        if w_ != w:
-            w_padding = torch.zeros(b, c, h_, w_ - w, device=device)
-            image = torch.cat([image, w_padding], dim=3)
-        # ====================================================
-
-        scores_map, descriptor_map = super().forward(image)
-
-        # ====================================================
-        if h_ != h or w_ != w:
-            descriptor_map = descriptor_map[:, :, :h, :w]
-            scores_map = scores_map[:, :, :h, :w]  # Bx1xHxW
-        # ====================================================
-
-        # BxCxHxW
-        descriptor_map = torch.nn.functional.normalize(descriptor_map, p=2, dim=1)
-
-        if ret_dict:
-            return {
-                "descriptor_map": descriptor_map,
-                "scores_map": scores_map,
-            }
-        else:
-            return descriptor_map, scores_map
-
-    def forward(self, img, image_size_max=99999, sort=False, sub_pixel=False):
-        """
-        :param img: np.array HxWx3, RGB
-        :param image_size_max: maximum image size, otherwise, the image will be resized
-        :param sort: sort keypoints by scores
-        :param sub_pixel: whether to use sub-pixel accuracy
-        :return: a dictionary with 'keypoints', 'descriptors', 'scores', and 'time'
-        """
-        H, W, three = img.shape
-        assert three == 3, "input image shape should be [HxWx3]"
-
-        # ==================== image size constraint
-        image = deepcopy(img)
-        max_hw = max(H, W)
-        if max_hw > image_size_max:
-            ratio = float(image_size_max / max_hw)
-            image = cv2.resize(image, dsize=None, fx=ratio, fy=ratio)
-
-        # ==================== convert image to tensor
-        image = (
-            torch.from_numpy(image)
-            .to(self.device)
-            .to(torch.float32)
-            .permute(2, 0, 1)[None]
-            / 255.0
-        )
-
-        # ==================== extract keypoints
-        start = time.time()
-
-        with torch.no_grad():
-            descriptor_map, scores_map = self.extract_dense_map(image)
-            keypoints, descriptors, scores, _ = self.dkd(
-                scores_map, descriptor_map, sub_pixel=sub_pixel
-            )
-            keypoints, descriptors, scores = keypoints[0], descriptors[0], scores[0]
-            keypoints = (keypoints + 1) / 2 * keypoints.new_tensor([[W - 1, H - 1]])
-
-        if sort:
-            indices = torch.argsort(scores, descending=True)
-            keypoints = keypoints[indices]
-            descriptors = descriptors[indices]
-            scores = scores[indices]
-
-        end = time.time()
-
-        return {
-            "keypoints": keypoints.cpu().numpy(),
-            "descriptors": descriptors.cpu().numpy(),
-            "scores": scores.cpu().numpy(),
-            "scores_map": scores_map.cpu().numpy(),
-            "time": end - start,
-        }
-
-
-if __name__ == "__main__":
-    import numpy as np
-    from thop import profile
-
-    net = ALike(c1=32, c2=64, c3=128, c4=128, dim=128, single_head=False)
-
-    image = np.random.random((640, 480, 3)).astype(np.float32)
-    flops, params = profile(net, inputs=(image, 9999, False), verbose=False)
-    print("{:<30}  {:<8} GFLops".format("Computational complexity: ", flops / 1e9))
-    print("{:<30}  {:<8} KB".format("Number of parameters: ", params / 1e3))

third_party/ALIKE/alnet.py

@@ -1,194 +0,0 @@
-import torch
-from torch import nn
-from torchvision.models import resnet
-from typing import Optional, Callable
-
-
-class ConvBlock(nn.Module):
-    def __init__(
-        self,
-        in_channels,
-        out_channels,
-        gate: Optional[Callable[..., nn.Module]] = None,
-        norm_layer: Optional[Callable[..., nn.Module]] = None,
-    ):
-        super().__init__()
-        if gate is None:
-            self.gate = nn.ReLU(inplace=True)
-        else:
-            self.gate = gate
-        if norm_layer is None:
-            norm_layer = nn.BatchNorm2d
-        self.conv1 = resnet.conv3x3(in_channels, out_channels)
-        self.bn1 = norm_layer(out_channels)
-        self.conv2 = resnet.conv3x3(out_channels, out_channels)
-        self.bn2 = norm_layer(out_channels)
-
-    def forward(self, x):
-        x = self.gate(self.bn1(self.conv1(x)))  # B x in_channels x H x W
-        x = self.gate(self.bn2(self.conv2(x)))  # B x out_channels x H x W
-        return x
-
-
-# copied from torchvision\models\resnet.py#27->BasicBlock
-class ResBlock(nn.Module):
-    expansion: int = 1
-
-    def __init__(
-        self,
-        inplanes: int,
-        planes: int,
-        stride: int = 1,
-        downsample: Optional[nn.Module] = None,
-        groups: int = 1,
-        base_width: int = 64,
-        dilation: int = 1,
-        gate: Optional[Callable[..., nn.Module]] = None,
-        norm_layer: Optional[Callable[..., nn.Module]] = None,
-    ) -> None:
-        super(ResBlock, self).__init__()
-        if gate is None:
-            self.gate = nn.ReLU(inplace=True)
-        else:
-            self.gate = gate
-        if norm_layer is None:
-            norm_layer = nn.BatchNorm2d
-        if groups != 1 or base_width != 64:
-            raise ValueError("ResBlock only supports groups=1 and base_width=64")
-        if dilation > 1:
-            raise NotImplementedError("Dilation > 1 not supported in ResBlock")
-        # Both self.conv1 and self.downsample layers downsample the input when stride != 1
-        self.conv1 = resnet.conv3x3(inplanes, planes, stride)
-        self.bn1 = norm_layer(planes)
-        self.conv2 = resnet.conv3x3(planes, planes)
-        self.bn2 = norm_layer(planes)
-        self.downsample = downsample
-        self.stride = stride
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        identity = x
-
-        out = self.conv1(x)
-        out = self.bn1(out)
-        out = self.gate(out)
-
-        out = self.conv2(out)
-        out = self.bn2(out)
-
-        if self.downsample is not None:
-            identity = self.downsample(x)
-
-        out += identity
-        out = self.gate(out)
-
-        return out
-
-
-class ALNet(nn.Module):
-    def __init__(
-        self,
-        c1: int = 32,
-        c2: int = 64,
-        c3: int = 128,
-        c4: int = 128,
-        dim: int = 128,
-        single_head: bool = True,
-    ):
-        super().__init__()
-
-        self.gate = nn.ReLU(inplace=True)
-
-        self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2)
-        self.pool4 = nn.MaxPool2d(kernel_size=4, stride=4)
-
-        self.block1 = ConvBlock(3, c1, self.gate, nn.BatchNorm2d)
-
-        self.block2 = ResBlock(
-            inplanes=c1,
-            planes=c2,
-            stride=1,
-            downsample=nn.Conv2d(c1, c2, 1),
-            gate=self.gate,
-            norm_layer=nn.BatchNorm2d,
-        )
-        self.block3 = ResBlock(
-            inplanes=c2,
-            planes=c3,
-            stride=1,
-            downsample=nn.Conv2d(c2, c3, 1),
-            gate=self.gate,
-            norm_layer=nn.BatchNorm2d,
-        )
-        self.block4 = ResBlock(
-            inplanes=c3,
-            planes=c4,
-            stride=1,
-            downsample=nn.Conv2d(c3, c4, 1),
-            gate=self.gate,
-            norm_layer=nn.BatchNorm2d,
-        )
-
-        # ================================== feature aggregation
-        self.conv1 = resnet.conv1x1(c1, dim // 4)
-        self.conv2 = resnet.conv1x1(c2, dim // 4)
-        self.conv3 = resnet.conv1x1(c3, dim // 4)
-        self.conv4 = resnet.conv1x1(dim, dim // 4)
-        self.upsample2 = nn.Upsample(
-            scale_factor=2, mode="bilinear", align_corners=True
-        )
-        self.upsample4 = nn.Upsample(
-            scale_factor=4, mode="bilinear", align_corners=True
-        )
-        self.upsample8 = nn.Upsample(
-            scale_factor=8, mode="bilinear", align_corners=True
-        )
-        self.upsample32 = nn.Upsample(
-            scale_factor=32, mode="bilinear", align_corners=True
-        )
-
-        # ================================== detector and descriptor head
-        self.single_head = single_head
-        if not self.single_head:
-            self.convhead1 = resnet.conv1x1(dim, dim)
-        self.convhead2 = resnet.conv1x1(dim, dim + 1)
-
-    def forward(self, image):
-        # ================================== feature encoder
-        x1 = self.block1(image)  # B x c1 x H x W
-        x2 = self.pool2(x1)
-        x2 = self.block2(x2)  # B x c2 x H/2 x W/2
-        x3 = self.pool4(x2)
-        x3 = self.block3(x3)  # B x c3 x H/8 x W/8
-        x4 = self.pool4(x3)
-        x4 = self.block4(x4)  # B x dim x H/32 x W/32
-
-        # ================================== feature aggregation
-        x1 = self.gate(self.conv1(x1))  # B x dim//4 x H x W
-        x2 = self.gate(self.conv2(x2))  # B x dim//4 x H//2 x W//2
-        x3 = self.gate(self.conv3(x3))  # B x dim//4 x H//8 x W//8
-        x4 = self.gate(self.conv4(x4))  # B x dim//4 x H//32 x W//32
-        x2_up = self.upsample2(x2)  # B x dim//4 x H x W
-        x3_up = self.upsample8(x3)  # B x dim//4 x H x W
-        x4_up = self.upsample32(x4)  # B x dim//4 x H x W
-        x1234 = torch.cat([x1, x2_up, x3_up, x4_up], dim=1)
-
-        # ================================== detector and descriptor head
-        if not self.single_head:
-            x1234 = self.gate(self.convhead1(x1234))
-        x = self.convhead2(x1234)  # B x dim+1 x H x W
-
-        descriptor_map = x[:, :-1, :, :]
-        scores_map = torch.sigmoid(x[:, -1, :, :]).unsqueeze(1)
-
-        return scores_map, descriptor_map
-
-
-if __name__ == "__main__":
-    from thop import profile
-
-    net = ALNet(c1=16, c2=32, c3=64, c4=128, dim=128, single_head=True)
-
-    image = torch.randn(1, 3, 640, 480)
-    flops, params = profile(net, inputs=(image,), verbose=False)
-    print("{:<30}  {:<8} GFLops".format("Computational complexity: ", flops / 1e9))
-    print("{:<30}  {:<8} KB".format("Number of parameters: ", params / 1e3))

third_party/ALIKE/assets/ALIKE_code.zip

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:891e8431c047e7aeed77c9e5f64ffeed262d92389d8ae6235dde0964a9048a08
-size 62774