LibreYOLO
Copyright (c) The LibreYOLO contributors.

LibreYOLO is licensed under the MIT License (see LICENSE).

This product bundles third-party source code under non-MIT licenses. The
bundled files retain their original copyright headers. A copy of each
upstream license accompanies the corresponding code.

------------------------------------------------------------------------
Bundled third-party source code
------------------------------------------------------------------------

DINOv3 (Meta DINOv3 License Agreement)
    Path:    libreyolo/models/deimv2/engine/backbone/dinov3/
    License: libreyolo/models/deimv2/engine/backbone/dinov3/LICENSE.md
    Source:  https://github.com/facebookresearch/dinov3

    The DINOv3 backbone code shipped with the DEIMv2 family is
    redistributed under the DINOv3 License Agreement, a custom
    non-OSI license from Meta Platforms, Inc.

    Key obligations propagated to downstream users (see LICENSE.md
    for the authoritative text):
      * Redistribution must include a copy of the DINOv3 License
        Agreement (provided as LICENSE.md alongside the code).
      * The DINO Materials may not be used for activities subject
        to ITAR, military or warfare purposes, nuclear industries,
        espionage, or weapons development.
      * The DINO Materials are provided "as is" without warranty.

    These terms apply only to the DINOv3 subtree listed above. The
    rest of LibreYOLO remains under the MIT License.

SenseNova-Vision / Bagel (Apache License 2.0 code; CC BY-NC 4.0 weights,
not redistributed)
    Path:    libreyolo/models/sensenova/
    License: libreyolo/models/sensenova/NOTICE  (Apache-2.0 code sources)
    Source:  https://github.com/OpenSenseNova/SenseNova-Vision

    The SenseNova-Vision family vendors an inference-only port of the
    upstream Apache-2.0 implementation (SenseTime 2026, building on
    ByteDance's Bagel, Hugging Face transformers, and the Black Forest
    Labs FLUX autoencoder, all Apache-2.0). The upstream file
    modeling/bagel/modeling_utils.py is CC BY-NC 4.0 (DiT-derived) and is
    NOT ported; its standard components are re-derived from Apache/MIT
    sources in modeling/layers.py (see the family NOTICE). Model weights
    are CC BY-NC 4.0, mirrored byte-identically with attribution at
    huggingface.co/LibreYOLO/SenseNovaVision7b; the loader prints the
    non-commercial notice before every automatic download.

MODUS / Bagel (Apache License 2.0 code; external custom-term weights)
    Path:    libreyolo/models/modus/
    License: libreyolo/models/modus/NOTICE
    Source:  https://github.com/EPFL-VILAB/Modus
    Commit:  c299ef0fbba1cfe7c93336c45d7085afd770c0fa

    LibreMODUS vendors only the analysis-inference portions of the upstream
    Apache-2.0 implementation and reuses LibreYOLO's audited Apache-2.0 Bagel
    runtime. The upstream CC BY-NC 4.0 modeling_utils.py file is explicitly
    excluded. Weights are never redistributed or mirrored: they remain in the
    user's local cache and are fetched directly from EPFL-VILAB/MODUS at a
    pinned revision using the user's own authenticated account. The upstream
    model card declares custom
    ``bagel-derived`` terms and requests research-only use. See the family
    NOTICE for the code/weights separation and exact provenance.

MobileNetV4 / timm (Apache License 2.0)
    Path:    libreyolo/models/mobilenetv4/
    License: libreyolo/models/mobilenetv4/NOTICE  (Apache-2.0)
    Source:  https://github.com/huggingface/pytorch-image-models

    The MobileNetV4 architecture (libreyolo/models/mobilenetv4/nn.py) is a
    native re-implementation derived from timm's MobileNetV4
    (Ross Wightman and the timm contributors), licensed Apache-2.0. Module
    naming mirrors timm so its Apache-2.0 ImageNet-1k pretrained weights load
    unchanged and inference is bit-identical. Apache-2.0 is MIT-compatible;
    these terms add only attribution obligations.

ConvNeXt / timm (MIT code + Apache-2.0 weights)
    Path:    libreyolo/models/convnext/
    License: libreyolo/models/convnext/NOTICE
    Source:  https://github.com/facebookresearch/ConvNeXt
             https://github.com/huggingface/pytorch-image-models

    The ConvNeXt V1 architecture (libreyolo/models/convnext/nn.py) is a native
    re-implementation derived from Meta's ConvNeXt (MIT) and timm's ConvNeXt.
    Module naming mirrors timm so its Apache-2.0 ImageNet-1k `fb_in1k` weights
    load unchanged and inference is bit-identical. ConvNeXt-V2's small
    checkpoints are CC-BY-NC and are intentionally NOT used.

DeiT / timm (Apache License 2.0)
    Path:    libreyolo/models/deit/, libreyolo/data/imagenet1k_synsets.txt
    License: libreyolo/models/deit/NOTICE  (Apache-2.0)
    Source:  https://github.com/facebookresearch/deit
             commit 7e160fe43f0252d17191b71cbb5826254114ea5b
             https://github.com/huggingface/pytorch-image-models
             commit e98c05a5a15e81188ec62dd5380b8f5c3251075a

    The plain DeiT patch-16 tiny, small, and base classifiers are a native
    inference port derived from the Apache-2.0 timm Vision Transformer graph
    and the Apache-2.0 facebookresearch/deit variant contract. Module naming
    mirrors timm so its Apache-2.0 ImageNet-1k tensors load unchanged and
    produce bit-identical eager logits. The bundled ImageNet WNID index is an
    unmodified timm data file from the pinned commit above. Distillation-token,
    DeiT III, and 384-pixel variants are not included.

EfficientNetV2 / timm (Apache License 2.0)
    Path:    libreyolo/models/efficientnetv2/
    License: libreyolo/models/efficientnetv2/NOTICE  (Apache-2.0)
    Source:  https://github.com/huggingface/pytorch-image-models
             https://github.com/google/automl

    The EfficientNetV2 architecture (libreyolo/models/efficientnetv2/nn.py) is a
    native re-implementation derived from timm's EfficientNetV2 (Ross Wightman)
    and Google's EfficientNetV2 (google/automl), licensed Apache-2.0. Module
    naming mirrors timm so its Apache-2.0 ImageNet-1k weights load unchanged and
    inference is bit-identical.

ResNet / timm (Apache License 2.0)
    Path:    libreyolo/models/resnet/
    License: libreyolo/models/resnet/NOTICE  (Apache-2.0)
    Source:  https://github.com/huggingface/pytorch-image-models

    The ResNet architecture (libreyolo/models/resnet/nn.py) is a native
    re-implementation of the vanilla ResNet (He et al. 2015, v1.5). Weights are
    timm's `resnet*.a1_in1k` (Ross Wightman), Apache-2.0, ImageNet-1k. Module
    naming mirrors timm/torchvision so weights load unchanged and inference is
    bit-identical.

Swin Transformer V1 / timm (Apache-2.0 code + MIT weights)
    Path:    libreyolo/models/swin/
    License: libreyolo/models/swin/NOTICE
    Source:  https://github.com/huggingface/pytorch-image-models
             https://github.com/microsoft/Swin-Transformer
             https://github.com/SwinTransformer/storage

    The shared Swin V1 tower is a native implementation derived from timm
    v1.0.28 (Apache-2.0). The standalone classifier integration is original
    LibreYOLO work and preserves timm parameter names for strict, bit-exact
    loading. The four released patch-4/window-7 Microsoft checkpoints are MIT;
    conversion retains learned tensors and adds only LibreYOLO metadata and
    canonical ImageNet-1k class names.

OMDet-Turbo / Transformers (Apache License 2.0)
    Path:    libreyolo/models/openvocab/omdet_turbo.py
    License: licenses/Apache-2.0.txt
    Source:  https://github.com/huggingface/transformers
    Architecture: https://github.com/om-ai-lab/OmDet

    LibreYOLO ships no OMDet-Turbo model source. The adapter calls the
    Apache-2.0 Transformers OmDetTurboForObjectDetection implementation, its
    processor, and its post-processing. Apache-2.0 checkpoint assets are
    mirrored unchanged from omlab/omdet-turbo-swin-tiny-hf revision
    7fe93cecfb770c4d76cf71163956221249cab566 at LibreYOLO/LibreOMDetTurbot.

OV-DEIM (Apache License 2.0)
    Path:    libreyolo/models/openvocab/ov_deim.py,
             libreyolo/models/openvocab/ovdeim/
    License: licenses/Apache-2.0.txt
    Source:  https://github.com/wleilei/OV-DEIM
             (pinned at commit dfbf394672407b7f837ec08e7d68e8127548b254)

    The vendored architecture modules are taken from OV-DEIM under
    Apache-2.0, with the RT-DETR (Apache-2.0, Copyright (c) 2023 lyuwenyu)
    and DEIMv2 (Apache-2.0) lineage headers preserved. Licensing was
    confirmed by the upstream author (wleilei/OV-DEIM#4). See
    docs/provenance/ov_deim.md.

SegFormer / transformers (Apache License 2.0)
    Path:    libreyolo/models/segformer/
    License: libreyolo/models/segformer/NOTICE  (Apache-2.0 code source)
    Source:  https://github.com/huggingface/transformers

    The SegFormer architecture (libreyolo/models/segformer/nn.py) is a
    PyTorch port derived from (and in parts copied from) HuggingFace
    Transformers' Apache-2.0 modeling_segformer.py, not from NVIDIA's
    original non-permissive NVlabs/SegFormer repository (cited for
    attribution only).

    The semantic training recipe it uses -- the resize_crop /
    cat_max_ratio sampling in libreyolo/data/semantic_dataset.py and the
    ADE20K hyper-parameters in SegformerConfig -- is derived from
    open-mmlab/mmsegmentation (Apache-2.0). See THIRD_PARTY_NOTICES.txt.

    WEIGHTS ARE NON-COMMERCIAL. The pretrained ADE20K checkpoints
    (LibreSegformer{b0..b5}-sem) are converted from NVIDIA's SegFormer
    release, whose license permits redistribution but restricts use to
    research or evaluation only. They are not covered by LibreYOLO's
    permissive license. See libreyolo/models/segformer/NOTICE.

LingBot-Vision (Apache License 2.0)
    Path:    libreyolo/models/lingbotvision/
    License: libreyolo/models/lingbotvision/NOTICE
    Source:  https://github.com/robbyant/lingbot-vision

    The LingBot-Vision ViT backbone (libreyolo/models/lingbotvision/nn.py)
    is a native PyTorch port of Robbyant's Apache-2.0 lingbot-vision
    release ("Vision Pretraining for Dense Spatial Perception", Fu et
    al., 2026, arXiv:2607.05247). The upstream release documents its ViT
    as building on DINOv2/DINOv3 (Meta AI); the port was made from the
    Robbyant repository only, which distributes that code under
    Apache-2.0. The dense head and training recipe are LibreYOLO's own
    (the report's linear-probing protocol).

    Pretrained backbone weights are Apache-2.0 (Robbyant). Hosted
    LibreLingBotVision{s,b,l}-sem checkpoints combine those backbones
    with a LibreYOLO-trained ADE20K head.

Depth Anything 3 (Apache License 2.0)
    Path:    libreyolo/models/depth_anything3/_vendor/
    License: libreyolo/models/depth_anything3/NOTICE
    Source:  https://github.com/ByteDance-Seed/Depth-Anything-3
    Commit:  41736238f5bced4debf3f2a12375d2466874866d

    The DA3MONO-LARGE ViT-L encoder and DPT head are adapted from ByteDance
    Seed's Apache-2.0 implementation. DINOv2 subcomponents retain Meta
    Platforms Apache-2.0 headers. Package-relative imports and dependency-free
    tensor reshapes do not alter learned parameters or monocular outputs.

NAFNet (MIT License)
    Path:    libreyolo/models/nafnet/
    License: libreyolo/models/nafnet/NOTICE  (MIT)
    Source:  https://github.com/megvii-research/NAFNet

    The NAFNet restoration architecture (libreyolo/models/nafnet/nn.py) is a
    native PyTorch implementation derived from Megvii Research's NAFNet
    (MIT). LibreYOLO does not bundle NAFNet pretrained checkpoint files. Some
    published GoPro-trained NAFNet weights do not carry an explicit standalone
    weights license; convert only weights that you have the right to use and
    redistribute. The SIDD denoising weights are trained on the Smartphone
    Image Denoising Dataset (SIDD), which is distributed under the MIT License.

Real-ESRGAN / BasicSR (BSD-3-Clause / Apache-2.0)
    Path:    libreyolo/models/realesrgan/, libreyolo/postprocess/realesrgan.py
    License: libreyolo/models/realesrgan/NOTICE
    Source:  https://github.com/xinntao/Real-ESRGAN (BSD-3-Clause),
             https://github.com/XPixelGroup/BasicSR (Apache-2.0)

    The LibreRealESRGAN super-resolution architectures (RRDBNet,
    SRVGGNetCompact, pixel_unshuffle in libreyolo/models/realesrgan/nn.py) are a
    native PyTorch implementation whose lineage is BasicSR (Apache-2.0,
    Copyright 2018-2022 BasicSR Authors). The seam-free tiled forward in
    libreyolo/models/realesrgan/utils.py is ported from Real-ESRGAN's inference
    helper (BSD-3-Clause, Copyright (c) 2021 Xintao Wang). The released
    Real-ESRGAN generator weights (RealESRGAN_x4plus, RealESRGAN_x2plus,
    realesr-general-x4v3) are distributed under the BSD-3-Clause License;
    LibreYOLO mirrors converted checkpoints with this provenance stated in the
    model cards.

PaddleOCR / PP-OCRv5 (Apache-2.0)
    Path:    libreyolo/models/ppocr/, libreyolo/postprocess/ppocr.py
    License: libreyolo/models/ppocr/NOTICE
    Source:  https://github.com/PaddlePaddle/PaddleOCR

    The LibrePPOCR text detection + recognition family is a native PyTorch
    port of PP-OCRv5 from PaddleOCR (Apache-2.0, Copyright (c) 2020
    PaddlePaddle Authors): the PP-LCNetV3 and PP-HGNetV2-B4 backbones,
    RSEFPN/LKPAN necks, DB heads, SVTR sequence encoder, CTC head, DB quad
    postprocess, and CTC greedy decode. The published LibrePPOCR checkpoints
    are converted from the official Apache-2.0 PP-OCRv5 training checkpoints
    and embed the PP-OCRv5 recognition dictionary as charset metadata.

SwinIR (Apache-2.0)
    Path:    libreyolo/models/swinir/
    License: libreyolo/models/swinir/NOTICE
    Source:  https://github.com/JingyunLiang/SwinIR
             commit 6545850fbf8df298df73d81f3e8cba638787c8bd

    The LibreSwinIR generator is a modified port of the official SwinIR
    network_swinir.py implementation. Upstream parameter names are preserved
    for strict loading of the Apache-2.0 released checkpoints. LibreYOLO adds
    restore-task integration, preprocessing, postprocessing, validation, and
    checkpoint metadata.

Darknet YOLOv1 / YOLOv2 / YOLOv3 / YOLOv4 (public domain)
    Path:    libreyolo/models/darknet/, libreyolo/models/yolo1|yolo2|yolo3|yolo4/
    License: libreyolo/models/darknet/cfgs/NOTICE  (public domain)
    Source:  https://github.com/pjreddie/darknet  (YOLOv1/v2/v3)
             https://github.com/AlexeyAB/darknet   (YOLOv4)

    The LibreYOLO1/2/3/4 families reproduce the YOLOv1, YOLOv2, YOLOv3, and
    YOLOv4 architectures from the Darknet project, which is public domain (the
    "YOLO LICENSE": "Darknet is public domain. Do whatever you want with
    it."). The model-definition (.cfg) files are bundled under
    libreyolo/models/darknet/cfgs/ and drive both the runtime graph builder
    and the weight converter. Only the .cfg format and the numerical
    behaviour of the Darknet layers are reproduced; no Darknet C source is
    copied. Being public domain, these terms impose no obligations on
    LibreYOLO or its downstream users.

YOLOv7 / MultimediaTechLab/YOLO (MIT License)
    Path:    libreyolo/models/yolo7/
    Source:  https://github.com/MultimediaTechLab/YOLO

    The LibreYOLO7 family is a native port of YOLOv7 from
    MultimediaTechLab/YOLO (MIT, (c) 2024 Kin-Yiu Wong & Hao-Tang Tsui) —
    the authors' own MIT re-release, NOT the GPL-3.0 WongKinYiu/yolov7.
    Module names mirror upstream so the MIT v7.pt weights load unchanged;
    the model-definition v7.yaml is bundled under libreyolo/models/yolo7/.
    MIT is MIT-compatible; these terms add only attribution obligations.

DETR (Apache License 2.0)
    Path:    libreyolo/models/detr/, libreyolo/postprocess/detr.py,
             weights/convert_detr_weights.py
    License: licenses/Apache-2.0.txt
    Source:  https://github.com/facebookresearch/detr
             commit 29901c51d7fe8712168b8d0d64351170bc0f83e0
             Copyright (c) Facebook, Inc. and its affiliates.
    Weights: https://dl.fbaipublicfiles.com/detr/ (Apache-2.0), rehosted at
             LibreYOLO/LibreDETR{r50,r50dc5,r101,r101dc5}

    LibreDETR is a native inference port of the original DETR ResNet-50/101
    and DC5 detector variants. Module names mirror upstream so all four
    official COCO checkpoints load unchanged. The transformer source inherits
    its stated ``torch.nn.Transformer`` lineage from PyTorch (BSD-3-Clause).
    Copyright headers are retained in the ported architecture; family-level
    details live in libreyolo/models/detr/NOTICE.

CenterNet (MIT and BSD-3-Clause)
    Path:    libreyolo/models/centernet/,
             libreyolo/postprocess/centernet.py,
             weights/convert_centernet_weights.py
    License: libreyolo/models/centernet/NOTICE
    Source:  https://github.com/xingyizhou/CenterNet
             commit 4c50fd3a46bdf63dbf2082c5cbb3458d39579e6c
             Copyright (c) 2019 Xingyi Zhou

    LibreCenterNet ports the official fixed-512 ResDCN-18 and DLA-34
    detection graphs, affine preprocessing, and top-100 no-NMS decoder. The
    CenterNet source is MIT; its DLA, DCNv2, CornerNet, and Microsoft pose
    lineages are permissively licensed and reproduced in the family NOTICE.
    LibreYOLO does not bundle or compile the legacy DCNv2 extension. Native
    inference calls torchvision's BSD-3-Clause deform_conv2d operator, while
    export uses LibreYOLO's portable equivalent. Official COCO checkpoints are
    not bundled in the source distribution. Their separate mirrors disclose
    that MIT is implied by the releasing project, not a checkpoint-specific
    publisher statement.

Faster R-CNN / TorchVision (BSD-3-Clause)
    Path:    libreyolo/models/faster_rcnn/,
             libreyolo/postprocess/faster_rcnn.py
    License: libreyolo/models/faster_rcnn/NOTICE
    Source:  https://github.com/pytorch/vision
             commit 336d36e8db990a905498c73933e35231876e28bc

    The native LibreFasterRCNN inference graph is derived from torchvision
    v0.26.0's Faster R-CNN, RPN, RoI box heads, transform, box coder, and FPN
    backbone builders (BSD-3-Clause, Copyright (c) Soumith Chintala 2016).
    Upstream state-dict names are retained for strict local conversion. The
    port adds LibreYOLO metadata, contiguous COCO-80 mapping, validation, and
    fixed-batch ONNX integration; it excludes training-only matching,
    sampling, and losses. Official COCO checkpoints are not bundled in the
    source distribution. Separate weight mirrors disclose that their
    BSD-3-Clause redistribution basis is implied by the releasing project,
    not an explicit checkpoint-specific grant, and repeat torchvision's
    pretrained-model terms caveat.

SSD300 / TorchVision (BSD-3-Clause; VGG weight lineage CC BY 4.0)
    Path:    libreyolo/models/ssd/, libreyolo/postprocess/ssd.py,
             weights/convert_ssd_weights.py
    License: libreyolo/models/ssd/NOTICE
    Source:  https://github.com/pytorch/vision
             commit 336d36e8db990a905498c73933e35231876e28bc

    The native LibreSSD300 inference graph is derived from torchvision
    v0.26.0's SSD300, VGG feature extractor, default-box generator, box coder,
    transform, and postprocessing utilities (BSD-3-Clause, Copyright (c)
    Soumith Chintala 2016). The official COCO checkpoint is mirrored
    separately under BSD-3-Clause on an explicitly disclosed implied basis;
    it has no per-object license file. Its VGG-16 initialization traces to
    Oxford Visual Geometry Group feature weights released under CC BY 4.0.
    The family notice supplies the full BSD text, VGG attribution, license
    link, changes statement, and pretrained-model/data caveats.
Mask R-CNN / TorchVision (BSD-3-Clause)
    Path:    libreyolo/models/mask_rcnn/
    License: libreyolo/models/mask_rcnn/NOTICE
    Source:  https://github.com/pytorch/vision
             commit 336d36e8db990a905498c73933e35231876e28bc

    LibreMaskRCNN adds the pinned torchvision v0.26.0 Mask R-CNN RoIAlign mask
    head and class-specific mask selection to LibreYOLO's native Faster R-CNN
    graph (BSD-3-Clause, Copyright (c) Soumith Chintala 2016). The port keeps
    upstream state-dict names and adds LibreYOLO task dispatch, contiguous
    COCO-80 mapping, validation, mask postprocessing, and ONNX integration.
    Training-only sampling and loss code is excluded. The official COCO
    checkpoint is not bundled. Its separate weight mirror discloses that the
    BSD-3-Clause redistribution basis is implied by the releasing project, not
    an explicit checkpoint-specific grant, and repeats the pretrained-model
    terms caveat.

FCOS / TorchVision (BSD-3-Clause)
    Path:    libreyolo/models/fcos/, libreyolo/postprocess/fcos.py
    License: libreyolo/models/fcos/NOTICE
    Source:  https://github.com/pytorch/vision
             commit 336d36e8db990a905498c73933e35231876e28bc

    The native LibreFCOS inference graph is derived from torchvision v0.26.0's
    FCOS detector, dense heads, anchor generator, transform, box coder, and
    postprocessing (BSD-3-Clause, Copyright (c) Soumith Chintala 2016).
    Upstream state-dict names are retained so the 319 official entries load
    strictly. LibreYOLO adds metadata, validation, contiguous COCO-80 mapping,
    and dynamic-spatial export integration; training assignment and losses are
    excluded. The official checkpoint is not bundled in the source
    distribution. Its separate weight mirror discloses that BSD-3-Clause
    redistribution is implied by the releasing project, not an explicit
    checkpoint-specific grant, and repeats torchvision's pretrained-model
    terms caveat.
AlexNet / TorchVision (BSD-3-Clause)
    Path:    libreyolo/models/alexnet/, libreyolo/postprocess/alexnet.py
    License: libreyolo/models/alexnet/NOTICE
    Source:  https://github.com/pytorch/vision
             commit 336d36e8db990a905498c73933e35231876e28bc

    The native LibreAlexNet graph is derived from torchvision v0.26.0's
    AlexNet implementation (BSD-3-Clause, Copyright (c) Soumith Chintala
    2016). It retains the upstream features/avgpool/classifier state-dict
    layout for strict conversion and bit-exact logits. The official
    ImageNet-1K checkpoint is not bundled in the source distribution. Its
    separate weight mirror discloses that BSD-3-Clause is an implied
    redistribution basis rather than a checkpoint-specific publisher grant,
    and repeats torchvision's pretrained-model terms caveat.
DeepLabv3 / TorchVision (BSD-3-Clause)
    Path:    libreyolo/models/deeplabv3/,
             libreyolo/postprocess/deeplabv3.py,
             weights/convert_deeplabv3_weights.py
    License: libreyolo/models/deeplabv3/NOTICE
    Source:  https://github.com/pytorch/vision
             commit 336d36e8db990a905498c73933e35231876e28bc

    The native LibreDeepLabv3 inference graph is derived from torchvision
    v0.26.0's DeepLabv3 orchestration, ASPP head, and ResNet/MobileNetV3
    backbone builders (BSD-3-Clause, Copyright (c) Soumith Chintala 2016).
    Upstream runtime state-dict names are retained for strict conversion. The
    port adds LibreYOLO metadata, semantic results, validation, and fixed-520
    export/backend integration; it excludes the training-only auxiliary FCN
    classifier and training recipe. Official COCO checkpoints are not bundled
    in the source distribution. Separate weight mirrors disclose that their
    BSD-3-Clause redistribution basis is implied by the releasing project,
    not an explicit checkpoint-specific grant, and repeat torchvision's
    pretrained-model terms caveat.

LW-DETR (Apache License 2.0)
    Path:    libreyolo/models/lwdetr/, libreyolo/postprocess/lwdetr.py,
             weights/convert_lwdetr_weights.py
    License: licenses/Apache-2.0.txt
    Source:  https://github.com/Atten4Vis/LW-DETR
             Copyright (c) 2024 Baidu. All Rights Reserved.
    Weights: https://huggingface.co/xbsu/LW-DETR (apache-2.0), rehosted at
             LibreYOLO/LibreLWDETR{t,s,m,l,x}

    The LibreLWDETR family is a native port of Atten4Vis/LW-DETR: plain-ViT
    encoder with interleaved window/global attention, multi-scale projector,
    and a shallow deformable DETR decoder. Module names mirror upstream so the
    Apache-2.0 COCO checkpoints load unchanged; ported outputs are bit-exact
    against the official implementation for all five released sizes. Upstream's
    own Conditional DETR / DETR / Deformable DETR / ViTDet lineage headers are
    preserved in the ported modules and cited separately in
    THIRD_PARTY_NOTICES.txt. Ported inference only — the Group-DETR training
    recipe is not included. See docs/provenance/lwdetr.md.

Deformable DETR (Apache License 2.0)
    Path:    libreyolo/models/deformable_detr/,
             libreyolo/postprocess/deformable_detr.py,
             weights/convert_deformable_detr_weights.py
    License: licenses/Apache-2.0.txt
    Source:  https://github.com/fundamentalvision/Deformable-DETR
             commit 11169a60c33333af00a4849f1808023eba96a931
    Copyright (c) 2020 SenseTime. All Rights Reserved.
    Modified from DETR, Copyright (c) Facebook, Inc. and its affiliates.

    LibreYOLO ports the original ResNet-50 inference architecture and its
    pure-PyTorch multi-scale deformable-attention reference path. The upstream
    custom CUDA extension and all training-only code are excluded. Official
    Apache-2.0 SenseTime COCO weights are converted and rehosted for all five
    released variants. Source-file lineage headers are preserved; see
    docs/provenance/deformable_detr.md.

Dome-DETR (Apache License 2.0)
    Path:    libreyolo/models/domedetr/,
             libreyolo/postprocess/domedetr.py,
             weights/convert_domedetr_weights.py,
             weights/parity_domedetr.py
    License: licenses/Apache-2.0.txt
    Source:  https://github.com/RicePasteM/Dome-DETR
             commit 2dde3bc1946a3e9fad9abd0612b59fc39bd6b861
             The upstream LICENSE is the standard Apache-2.0 text but leaves
             the copyright line as the "[yyyy] [name of copyright owner]"
             placeholder, so there is no named holder to record. Source
             headers carry "Copyright (c) 2025 The Dome-DETR Authors".

    The DeFE density head, the MWAS window processor, and the PAQI query
    initialiser are ported from src/zoo/dome/. The MWAS static-shape path
    follows the same repository's onnx-export branch. Everything the port
    shares with D-FINE (HGNetv2, the CSP encoder blocks, the FDR decoder
    stack, MS-deformable attention) is imported from libreyolo/models/dfine/
    rather than re-vendored, so the D-FINE entry above continues to cover it.

    Model weights are NOT redistributed by LibreYOLO. The upstream model
    card at https://huggingface.co/RicePasteM/Dome-DETR states no license in
    its card metadata, and its prose simultaneously claims Apache-2.0 and
    restricts use to "academic research purposes only". Users download from
    upstream and convert locally.

D-FINE-seg (Apache License 2.0)
    Path:    libreyolo/models/dfine/, libreyolo/postprocess/dfine.py
    Source:  https://github.com/ArgoHA/D-FINE-seg

    LibreDFINE segment support adapts D-FINE-seg's mask decoder/head,
    mask matching, mask loss, and mask postprocess references. The
    D-FINE-seg repository is Apache-2.0; its maintainer approved reuse
    with attribution in ArgoHA/D-FINE-seg#70.

EdgeTAM runtime preprocessing and Transformers checkpoint converter (Apache License 2.0)
    Path:    libreyolo/models/sam/edgetam.py,
             weights/convert_edgetam_weights.py
    License: licenses/Apache-2.0.txt
    Source:  https://github.com/facebookresearch/EdgeTAM
             commit 7711e012a30a2402c4eaab637bdb00a521302c91
    Converter: https://github.com/huggingface/transformers
             commit bd37c453544e83eb875ed3608980a1660376007a
    Payload reference: https://huggingface.co/yonigozlan/EdgeTAM-hf
             revision c266ce53b3fc00f0f495b583f6a116c4e57f53bb

    The EdgeTAM checkpoint key mapping is adapted from Hugging Face
    Transformers' Apache-2.0 converter. LibreYOLO replaces its direct pickle
    load with the repository's safe untrusted-checkpoint loader, pins and
    verifies both source and reference artifact digests, and builds a
    provenance-complete mirror payload. The runtime adapter uses Transformers
    for the model architecture and reproduces the pinned EdgeTAM square image
    transform and prompt-coordinate scaling from sam2/utils/transforms.py.
    The mirror's hash-pinned configuration and processor files are copied from
    the Apache-2.0-declared payload reference; learned tensors are independently
    converted from the official checkpoint and checked exactly.

------------------------------------------------------------------------
Pretrained model weights
------------------------------------------------------------------------

No pretrained weights are distributed in this source tree. LibreYOLO
weights are published separately on Hugging Face under the LibreYOLO
organization (https://huggingface.co/LibreYOLO). Each Hugging Face
model repository ships its own LICENSE and NOTICE reflecting the
license of the upstream project the weights were derived from. See
weights/LICENSE_NOTICE.txt for a per-family summary.
