LSKNet gives remote sensing detectors a selective receptive field

The idea is that context requirements differ per object

The abstract explains the motivation in a way that is worth reading closely, because it identifies what the field had been ignoring. Recent work on remote sensing object detection had largely focused on improving the representation of oriented bounding boxes, and had overlooked the prior knowledge specific to remote sensing. That prior knowledge matters for a concrete reason: tiny objects in aerial imagery may be detected incorrectly when the model does not reference a sufficiently long-range context, and the amount of long-range context that different object types need varies. LSKNet addresses this by dynamically adjusting its large spatial receptive field to model the ranging context of each object. The paper claims to be the first to explore large and selective kernel mechanisms in remote sensing object detection, and the design goal was stated as being lightweight, without bells and whistles, while setting new best scores on standard remote sensing classification, object detection and semantic segmentation benchmarks. The mechanism name explains itself: a large kernel gives the model a wide view, and a selection step decides per spatial position which part of that wide view matters.

The code lives inside a fork of MMRotate

This is the single most important practical fact, and it is easy to miss if you arrive from the paper. The repository is a fork of MMRotate rather than a standalone package, and the top level shows it, with the mmrotate/ directory inside the project alongside configs/, demo/, docs/, requirements/, tools/ and tests/. The README states plainly that the master branch is built on MMRotate and works with PyTorch 1.6 or newer, that the LSKNet backbone code is placed under mmrotate/models/backbones/, and that the train and test configuration files are placed under configs/lsknet/. Two README files for the upstream framework are carried along, MMRotate_README.md and MMRotate_README_zh-CN.md, and the setup.py reads the version from mmrotate/version.py, which is how a fork keeps the upstream versioning scheme. The practical consequence is that you adopt the whole framework to get the backbone. If your training pipeline already uses MMRotate, this is a clean fit and the configs are drop-in. If it does not, porting the backbone means porting the framework conventions around it, which is a real project rather than an afternoon.

The DOTA table is the reproducibility contract

The results table is the most useful part of the repository for anyone planning to use this, because it states the exact conditions of every number. Each row gives the model, the input size, the angle convention, the learning rate schedule, the batch size, a link to the config file and a link to both the trained model and the training log. The LSKNet_T row with ORCNN at 1024 by 1024, angle le90, a 1x schedule and a batch of 2*8 gives 81.37 mAP, LSKNet_S with ORCNN gives 81.64, and the EMA finetuned LSKNet_S* variant gives 81.85, against a previous best of 81.33 for RTMDet-l. The same table also shows the framework and config dependence: swapping the detector head changes the result, since LSKNet_S with Roi_Trans gives 81.22 and with R3Det 80.08. Note the table carries the caveat that the comparison is at a different angle setting for some rows, with le90 for the LSKNet entries and oc for the R3Det one. The mAP figures also appear in the abstract as 82.75 percent on DOTA1.0 for the follow-up Strip R-CNN work, which is a different model built on the same idea.

Pretrained backbones and the Strip R-CNN follow-up

Weights are provided, and they are provided in two flavours. There are 300-epoch ImageNet pretrained LSKNet-T and LSKNet-S backbones hosted on Hugging Face, plus 300-epoch ImageNet pretrained Strip R-CNN-T and Strip R-CNN-S backbones on Google Drive. A backbone pretrained on ImageNet is the normal way to start a remote sensing detector, where labelled aerial data is expensive and a general-domain initialisation saves a lot of training. The August 2025 update in the README added support for Strip R-CNN, Large Strip Convolution for Remote Sensing Object Detection, with the config for that work included here and the official code living in a separate repository under YXB-NKU. The Jittor implementation of the work is also documented, at NK-JittorCV/nk-remote, which matters if your organisation standardises on a different deep learning framework than PyTorch and MMRotate. The repository also carries a docs/lsk.png architecture diagram, a CITATION.cff file for citation metadata and a model-index.yml that maps the published models to their weights, which is the convention the OpenMMLab family uses to keep a model zoo navigable.

The requirements are split into four groups

The top level requirements.txt does not list packages itself, it pulls in four separate files, which tells you the project expects you to pick a subset rather than install everything.

-r requirements/build.txt
-r requirements/optional.txt
-r requirements/runtime.txt
-r requirements/tests.txt

The split matters for a fork like this, because the build group is for compiling extensions, the optional group is for features you may not use, the runtime group is what inference needs, and the tests group is for running the suite. Since the repository also ships a docker/ directory, a container is the other route to a working environment, and the demo scripts are the thing to run first in either case, because they tell you whether the weights and the framework agree before you start a training run. The .circleci/ directory, the pre-commit configuration and the pylintrc file show the project runs continuous integration and linting in the usual OpenMMLab style.

Demos for single images and for very large tiles

The demo/ directory is the part that saves you the most time when you are evaluating this. It contains image_demo.py, huge_image_demo.py, a demo.jpg and a dota_demo.jpg, alongside the MMRotate_Tutorial.ipynb notebook. The distinction between the two scripts is the interesting one for remote sensing. A single satellite image is often far larger than the model input size, so a detector has to be applied across a mosaic of overlapping tiles and the results stitched back together, and huge_image_demo.py exists to do that for aerial imagery. For a user who wants to see oriented boxes drawn on a large image, that is the script to reach for first, and it answers the question of whether the model finds objects at all before you spend a day on a training run. The repository also has a docker/ directory and a requirements/ directory split into build, optional, runtime and tests files, with the top level requirements.txt pulling in all four with the -r syntax, so you can install only what you need for inference if you are not planning to train.

Where this codebase will fight you

There are three practical limits. The first is the framework coupling described above, and it is the reason this is not a pip installable backbone for your own training loop. The second is that the published weights are ImageNet backbones and DOTA detectors trained on oriented bounding box data, so if your problem is axis-aligned detection, or a different sensor, or a different image resolution regime, you are starting from a checkpoint and a config rather than from a working solution. The third is the licence. The project is filed under a custom licence that GitHub cannot classify, with the LICENSE file in the repository root, and for a research codebase that is unusual enough to deserve a read before you build anything commercial on top of it. That is a matter for your own legal review rather than a conclusion this article can draw. On the research side, the badges for Papers with Code show the work at the top of the DOTA v1.0 and HRSC2016 leaderboards and second on FAIR1M v1.0, and the abstract mentions a second place finish in the 2022 Greater Bay Area International Algorithm Competition, so the reported results were not only published but also independently contested in a competition setting.

Editorial conclusion

Adopt LSKNet if you are training oriented object detectors on aerial imagery and you want the reference implementation and configs rather than an opinionated training stack, and you are prepared to work inside an MMRotate fork. Skip it if you need a pip installable backbone for a different framework, because the code lives under mmrotate/models/backbones/ and depends on that framework's runtime. Before you start, read the LICENSE file in the repository root, since the licence is custom and GitHub cannot classify it, and pick your configuration from the DOTA table in the README so your input size, angle convention and learning rate schedule match the published results.

Frequently asked questions

Official sources

1. Issues
2. README
3. zcablii/LSKNet on GitHub