> This is the documentation for LibreYOLO 1.5.0. Current version: https://www.libreyolo.com/docs/models/lingbot-vision

# LingBot-Vision
LingBot-Vision is a family of self-supervised vision transformer backbones trained with boundary-centric masked modeling for dense spatial perception, released by Robbyant. LibreYOLO pairs the backbone with a dense head and supports it for one task, semantic segmentation.
Tasks: semantic. Install: pip install libreyolo.
Verified against LibreYOLO v1.5.0.

## Install

LingBot-Vision needs no optional extra. Everything it imports is in the base
install.

```bash
pip install libreyolo
```

## Predict

Weights download from Hugging Face on first use and are cached locally.

**Python**

```python
from libreyolo import LibreYOLO, SAMPLE_IMAGE

model = LibreYOLO("LibreLingBotVisions-sem.pt")
result = model(SAMPLE_IMAGE, save=True)

mask = result.semantic_mask
print(mask.data.shape, mask.classes)
```

**CLI**

```bash
libreyolo predict model=LibreLingBotVisions-sem.pt source=https://raw.githubusercontent.com/LibreYOLO/libreyolo/release/libreyolo/assets/parkour.jpg save=True
```

`result.semantic_mask` carries the dense class map: `.data` is an `(H, W)`
tensor of class IDs on the original image size, and `.classes` lists the class
IDs actually present. `result.boxes` is `None`, since there are no
per-instance detections. `conf` and `iou` are accepted for API parity but do
not change the output, since the model returns one class per pixel rather than
detections to filter. See [prediction](/docs/v1.5.0/predict) for sources, streaming
and result handling.

## Variants

Three published sizes, s, b and l, distilled from a 1.1B-parameter ViT-g/16
teacher. The teacher itself, size `g`, loads and fine-tunes in LibreYOLO but
LibreYOLO does not host a `g` checkpoint of its own.

| File | Input (px) | Task | Weights license |
| --- | --- | --- | --- |
| `LibreLingBotVisions-sem.pt` |  | semantic | apache-2.0 |
| `LibreLingBotVisionb-sem.pt` |  | semantic | apache-2.0 |
| `LibreLingBotVisionl-sem.pt` |  | semantic | apache-2.0 |

## Train

`train()` fine-tunes a published checkpoint. The default recipe is the
upstream report's linear probe: the ViT backbone is frozen and only the 1x1
dense head trains, matching how the LibreYOLO-hosted weights above were
produced. Pass `freeze_backbone=False` to fine-tune the whole network instead,
and expect to lower `lr0` accordingly.

**Python (linear probe)**

```python
from libreyolo import LibreYOLO

# Backbone frozen by default, matching the upstream evaluation
# protocol: only the 1x1 dense head trains.
model = LibreYOLO("LibreLingBotVisions-sem.pt")
model.train(data="my-dataset.yaml", epochs=20, imgsz=512, batch=16)
```

**CLI**

```bash
libreyolo train model=LibreLingBotVisions-sem.pt data=my-dataset.yaml \
  epochs=20 imgsz=512 batch=16
```

**Full fine-tune**

```python
from libreyolo import LibreYOLO

model = LibreYOLO("LibreLingBotVisions-sem.pt")
model.train(
    data="my-dataset.yaml", epochs=20, imgsz=512, batch=16,
    freeze_backbone=False,
)
```

**Multi-GPU**

```bash
libreyolo train model=LibreLingBotVisions-sem.pt data=my-dataset.yaml \
  epochs=20 device=0,1 batch=32
```

See [training](/docs/v1.5.0/train) for datasets, augmentation, multi-GPU and loggers.

## Validate

`val()` returns a dictionary of `metrics/` keys: mIoU and pixel accuracy,
measured against any dataset in the format you trained on.

**Python**

```python
from libreyolo import LibreYOLO

model = LibreYOLO("LibreLingBotVisions-sem.pt")
metrics = model.val(data="my-dataset.yaml")

print(metrics["metrics/mIoU"])
print(metrics["metrics/pixel_accuracy"])
```

**CLI**

```bash
libreyolo val model=LibreLingBotVisions-sem.pt data=my-dataset.yaml
```

## Export

| Task | ONNX | TorchScript | ExecuTorch | TensorRT | OpenVINO | Paddle | MNN | RKNN | ncnn | TFLite | CoreML | Core AI |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| semantic | yes | yes | yes | yes | yes |  |  |  |  |  |  | yes |

A "yes" means the export is supported. An empty cell means the exporter refuses that combination.

An exported artifact loads back through `LibreYOLO()` on its file suffix, so a
`.onnx` or `.engine` file behaves like a checkpoint and returns the same
`Results`. [Export](/docs/v1.5.0/export) lists the arguments every format accepts.

**Python**

```python
from libreyolo import LibreYOLO

model = LibreYOLO("LibreLingBotVisions-sem.pt")
model.export(format="onnx", imgsz=512)
model.export(format="coreai", imgsz=512)
```

**CLI**

```bash
libreyolo export model=LibreLingBotVisions-sem.pt format=onnx imgsz=512
```

**Use the exported file**

```python
from libreyolo import LibreYOLO, SAMPLE_IMAGE

# The factory routes on the file suffix, so an exported artifact loads
# like any checkpoint and returns the same Results object.
model = LibreYOLO("LibreLingBotVisions-sem.onnx")
result = model(SAMPLE_IMAGE)

print(result.semantic_mask.data.shape)
```

## Checkpoints

Every published weight file for this family.

| File | Input (px) | Task | Weights license |
| --- | --- | --- | --- |
| `LibreLingBotVisions-sem.pt` |  | semantic | apache-2.0 |
| `LibreLingBotVisionb-sem.pt` |  | semantic | apache-2.0 |
| `LibreLingBotVisionl-sem.pt` |  | semantic | apache-2.0 |

## Licensing

Check the license on the Hugging Face repository of the specific weights you download. That repository is authoritative and licenses are not always uniform across a family. This is a description of the licenses involved, not legal advice.

- Original work: LingBot-Vision, Robbyant (Ant Group)
- Upstream license: Apache-2.0
- Upstream source: https://github.com/robbyant/lingbot-vision
- LibreYOLO code: Apache-2.0
- Weights: Apache-2.0, republished at https://huggingface.co/LibreYOLO
- Interpretation: Apache-2.0 is a permissive license, so these weights can be used in commercial and closed-source products. It asks you to keep its license text and attribution notices with any copy of the weights you redistribute, and it grants a patent license. The LibreYOLO-hosted checkpoints combine Robbyant's Apache-2.0 backbone weights with a dense segmentation head LibreYOLO trained itself, so the whole checkpoint file carries the same permissive terms end to end.

The upstream release documents its ViT as built on the DINOv2/DINOv3
architecture published by Meta AI. Robbyant distributes their implementation
under Apache-2.0, and this LibreYOLO port was made only from the Robbyant
repository, never from Meta's DINOv2 or DINOv3 code.

## Citation

```bibtex
@article{lingbot-vision2026,
  title={Vision Pretraining for Dense Spatial Perception},
  author={Fu, Zelin and Tan, Bin and Sun, Changjiang and Liu, Shaohui and Zheng, Kecheng and Xu, Yinghao and Zhu, Xing and Shen, Yujun and Xue, Nan},
  journal={arXiv preprint arXiv:2607.05247},
  year={2026}
}
```

Copied from https://github.com/robbyant/lingbot-vision#-citation


## LingBot-Vision architecture

- s: [SVG](/diagrams/models/lingbot-vision/s-semantic.svg), [interactive diagram](/diagrams/models/lingbot-vision/s-semantic.html)
- b: [SVG](/diagrams/models/lingbot-vision/b-semantic.svg), [interactive diagram](/diagrams/models/lingbot-vision/b-semantic.html)
- l: [SVG](/diagrams/models/lingbot-vision/l-semantic.svg), [interactive diagram](/diagrams/models/lingbot-vision/l-semantic.html)
- g: [SVG](/diagrams/models/lingbot-vision/g-semantic.svg), [interactive diagram](/diagrams/models/lingbot-vision/g-semantic.html)
- Shared s/b/l topology: [SVG](/diagrams/models/lingbot-vision/mlp-family.svg), [interactive diagram](/diagrams/models/lingbot-vision/mlp-family.html)