Siapa pun yang pernah berkutat dengan pipeline rekonstruksi 3D berbasis video panjang pasti paham betul mimpi buruk utamanya: memori yang terus membengkak sampai VRAM jebol. Kebanyakan arsitektur modern mencoba mengatasi masalah rekaman berdurasi panjang dengan menumpuk mekanisme memori jangka panjang yang rumit. Hasilnya, makin panjang videonya, komputasi per frame makin berat dan sistem perlahan mulai ngelag. Di sinilah **ABot-Recon** hadir membawa pendekatan yang sangat berani sekaligus pragmatis. Alih-alih mengingat seluruh riwayat visual dari awal sampai akhir, sistem ini justru membatasi pandangannya hanya pada *local context* 12 frame saja.

Idenya terdengar melawan arus utama industri *computer vision*. Bagaimana mungkin sebuah model bisa memetakan rute panjang tanpa ingatan global permanen? Kuncinya terletak pada cara model ini menyederhanakan masalah prediksi menjadi proses lokal yang terikat secara ketat pada setiap *time step*.

## Memangkas Beban Memori dengan Pendekatan Lokal

Alih-alih mempertahankan *state* memori jangka panjang yang berat, ABot-Recon menyelesaikan tugas bounded prediction yang sama persis di setiap langkah waktu. Pipeline ini bekerja secara efisien melalui empat tahapan inti:

1. Melakukan *caching* fitur KV (Key-Value) dari 11 frame sebelumnya untuk melengkapi jendela 12 frame lokal.
2. Memprediksi *point map* $P_i$ langsung pada sistem koordinat kamera saat ini (*current frame*).
3. Mengestimasi *adjacent relative pose* $T_{i-1\leftarrow i}$ antar frame yang bersebelahan.
4. Memulihkan trajektori global dan *point cloud* melalui komposisi pose sekuensial (*sequential pose composition*).

Ibarat menyusun puzzle jalur kereta, Anda tidak perlu melihat stasiun awal yang berjarak puluhan kilometer di belakang. Anda hanya perlu memastikan sambungan rel antara gerbong saat ini dan bantalan rel persis di belakangnya terpasang presisi. 

Tentu saja, menyambung pose secara sekuensial punya risiko akumulasi eror atau *drift*. Untuk mengatasi masalah tersebut, tim pengembang menyematkan *motion-visual rotation refiner* yang ringan serta menerapkan *composition-aware pose loss*. Kombinasi ini menjaga agar komputasi per frame dan penggunaan memori model tetap konstan, tidak peduli seberapa panjang urutan video yang diumpankan.

## Data Benchmark dan Efisiensi Hardware

Klaim efisiensi tanpa angka hanyalah sekadar hype. Berdasarkan pengujian yang dirilis, ABot-Recon membuktikan bahwa pendekatan lokal ini bukan cuma hemat daya komputasi, tetapi juga sangat akurat di berbagai skenario *real-world*.

Berikut adalah ringkasan hasil evaluasi performa dan efisiensi ABot-Recon:

| Pengujian | Metrik / Hasil | Keterangan & Setup |
| :--- | :--- | :--- |
| **Oxford Spires (Camera Pose)** | ATE: 4.35 m, RPE-R: 0.12° | *Streaming model only*, murni tanpa *loop closure* |
| **Oxford Spires (Dense Recon)** | CD: 1.37 m, F1: 91.81% | Ambang batas F1 threshold $\tau=4$ m |
| **KITTI-02 (Streaming Efficiency)** | 24.45 FPS, 6.71 GiB | Resolusi 504×280 di NVIDIA H100 (tanpa input storage) |

Selain dataset di atas, riset ini mengevaluasi estimasi pose kamera pada KITTI, Oxford Spires, dan VBR, serta rekonstruksi padat (*dense reconstruction*) pada 7Scenes, TUM-Dynamic, dan Oxford Spires. Hasil 24.45 FPS dengan konsumsi VRAM 6.71 GiB pada resolusi 504×280 membuktikan arsitektur ini sangat siap untuk kebutuhan *real-time streaming*.

## Setup Lingkungan dan Akselerasi Ekstra

ABot-Recon dibangun di atas fondasi Pi3 serta mengambil inspirasi dari proyek seperti CroCo, DUSt3R, DINOv2, SALAD, FlashInfer, LingBot-Map, HorizonStream, dan LongStream. Untuk menjalankannya, target environment standarnya adalah Linux dengan Python 3.10 atau lebih baru, PyTorch 2.5.1, dan CUDA 12.1. Validasi rilis dilakukan pada NVIDIA A100, sementara pengujian *runtime* menggunakan NVIDIA H100.

Bagi yang ingin langsung mencoba setup dasar, langkah instalasinya cukup ringkas:

```bash
conda create -n abot-recon python=3.11 -y
conda activate abot-recon

pip install torch==2.5.1 torchvision==0.20.1 \
  --index-url https://download.pytorch.org/whl/cu121
pip install -e .
```

Agar kecepatannya makin maksimal, sangat disarankan memasang operator paged KV-cache dari FlashInfer dan mengompilasi cuRoPE untuk akselerasi *rotary position encoding*:

```bash
pip install flashinfer-python
flashinfer show-config
cd abot_recon/modeling/pi3/models/curope
pip install ninja
python setup.py build_ext --inplace
cd -
```

Kerennya lagi, optimasi hardware tidak berhenti di GPU server kelas atas saja. Tim AXERA-TECH telah melakukan *community port* ABot-Recon ke NPU Axera AX650N. Porting ini mencakup dukungan *PCIe inference* berbasis AXCL maupun eksekusi *on-device* langsung di papan *board* AX650N lengkap dengan image Docker dan model precompiled.

## Eksekusi Script dan Loop Closure Opsional

Penggunaan model dasarnya sangat bersih karena tidak memerlukan aset tambahan atau dependensi *loop closure*. Urutan file gambar cukup dinamai dengan format *zero-padded* seperti `000001.jpg`, `000002.jpg`, lalu jalankan *causal pass* sederhana lewat terminal:

```bash
python demo.py \
  --image-dir examples/images \
  --output-dir outputs/demo \
  --attention-backend auto \
  --no-loop-closure
```

Jika Anda memproses video yang merekam rute melingkar dengan banyak area yang dikunjungi ulang (*revisited regions*), ABot-Recon menyediakan backend opsional. Fitur ini memanfaatkan deskriptor DINOv2-SALAD untuk mencari pasangan frame kandidat, menghitung *relative-pose constraints*, lalu memurnikan trajektori lewat *sparse pose-graph optimization*.

```bash
pip install -e ".[loop]"
python scripts/download_loop_assets.py --output-dir checkpoints/loop

python demo.py \
  --image-dir examples/images \
  --output-dir outputs/demo_loop \
  --attention-backend auto \
  --loop-closure
```

Setelah proses inferensi selesai, visualisasi point cloud format PLY dan trajektori Bird's-Eye View (BEV) dapat diekspor secara instan:

```bash
python scripts/export_reconstruction_ply.py \
  --poses outputs/demo/camera_poses.npy \
  --points outputs/demo/local_points.pt \
  --colors outputs/demo/colors.pt \
  --output outputs/demo/reconstruction.ply \
  --bev-output outputs/demo/trajectory_bev.png
```

Pengembang juga dapat mengintegrasikannya langsung ke dalam codebase Python lewat API yang ringkas:

```python
from pathlib import Path
from abot_recon import ABotRecon

images = sorted(Path("examples/images").glob("*.jpg"))
model = ABotRecon.from_pretrained(
    "acvlab/ABot-Recon",
    device="cuda",
    attention_backend="auto",
    loop_closure=False,
)
result = model.infer(images)
trajectory = result.camera_poses
relative_poses = result.relative_poses
local_points = result.local_points
confidence = result.confidence
```

Langkah tim peneliti yang juga mengembangkan proyek lain seperti ABot-Earth dan GS-Voxel ini patut diacungi jempol. Kode sumber ABot-Recon dirilis di bawah lisensi Apache License 2.0 dengan bobot model publik yang sudah tersedia di Hugging Face dan ModelScope. Ini adalah solusi segar bagi komunitas developer yang membutuhkan rekonstruksi 3D streaming tanpa harus tersandera kebutuhan VRAM tanpa batas.

## Referensi
- https://github.com/amap-cvlab/ABot-Recon

ABot-Recon membuktikan rekonstruksi 3D video panjang tidak butuh memori raksasa, cukup memanfaatkan konteks lokal 12 frame dengan efisiensi tinggi.

Rekonstruksi 3D Video Panjang Tanpa Bikin VRAM Jebol: Kenapa ABot-Recon Cuma Butuh 12 Frame?

Reggi

Pernah bayangkan melakukan rekonstruksi 3D dari video input berdurasi ribuan frame tanpa bikin VRAM GPU kamu jebol atau sistem ngelag parah? Masalah klasik di dunia computer vision saat menangani long-horizon video stream adalah akumulasi beban memori. Makin panjang durasi videonya, makin bengkak state memori yang harus disimpan. Di tengah tren arsitektur yang makin rakus hardware, hadir sebuah pendekatan pragmatis bernama **ABot-Recon: Streaming 3D Reconstruction dari Video Input**.

Model open-source ini tidak memaksakan diri menyimpan seluruh riwayat memori dari awal hingga akhir. Pendekatan yang diambil justru berlawanan dari kebiasaan arsitektur AI modern.

## Kenapa Harus 12 Frame Local Context?

Ibarat mengemudi mobil di jalan tol pada malam hari, kamu tidak perlu mengingat bentuk setiap meter jalanan yang sudah dilalui sejauh 100 kilometer ke belakang hanya untuk tetap berada di jalur. Kamu cuma butuh fokus pada beberapa meter ruang di depan mata.

Prinsip itulah yang diterapkan pada arsitektur ini. Di setiap time step, sistem hanya menyelesaikan bounded prediction problem yang sama secara konsisten. 

Model melakukan **cache KV features** dari 11 frame sebelumnya, memprediksi **point map** $P_i$ pada koordinat kamera saat ini, mengevaluasi **adjacent relative pose** $T_{i-1\leftarrow i}$, lalu menyusun trajectory global serta point cloud melalui sequential pose composition.

```
[Frame i-11 ... Frame i-1] -> Cache KV Features
            ↓
       [Frame i]          -> Predict Point Map & Relative Pose
            ↓
  Sequential Pose Composition -> Global Trajectory & Point Cloud
```

Desain ini membuat penggunaan memori GPU dan beban komputasi per frame sama sekali tidak tergantung pada panjang durasi video yang diproses. Mau videonya cuma 100 frame atau sampai batas maksimum **22.000 frame**, beban kerjanya tetap sama.

Lantas, bagaimana dengan masalah akumulasi *drift* (pergeseran eror) saat pose lokal digabungkan dalam skala waktu yang panjang? Pengembangnya menyematkan **lightweight motion-visual rotation refiner** serta **composition-aware pose loss** untuk menekan eror tersebut tetap di batas toleransi terendah.

## Angka Bicara: Performanya Nggak Main-Main

Bicara soal klaim teknis tentu kurang afdal tanpa melihat data pengujian langsung. Pengujian dilakukan pada berbagai dataset populer seperti KITTI, Oxford Spires, VBR, 7Scenes, hingga TUM-Dynamic.

| Evaluasi / Benchmark | Hasil Utama | Setting & Catatan Teknolis |
| :--- | :--- | :--- |
| **Oxford Spires Camera Pose** | ATE: **4.35 m**, RPE-R: **0.12°** | Pure streaming model, tanpa loop closure |
| **Oxford Spires Dense Reconstruction** | CD: **1.37 m**, F1: **91.81%** | F1 threshold $\tau=4$ m |
| **KITTI-02 Streaming Efficiency** | **24.45 FPS**, **6.71 GiB** VRAM | Resolusi 504×280 di NVIDIA H100 |

Angka **24.45 FPS** dengan konsumsi VRAM hanya **6.71 GiB** di resolusi 504×280 membuktikan bahwa model ini bukan sekadar riset di atas kertas, melainkan sangat playable untuk kebutuhan produksi streaming secara real-time.

## Loop Closure Opsional dan Dukungan NPU Lokal

Meskipun model dasarnya bisa berjalan mandiri tanpa butuh pemroses *loop closure*, pengembang tetap menyediakan opsi backend tersebut untuk menangani area yang dikunjungi kembali (revisited regions).

Ketika fitur **loop closure** diaktifkan, sistem mengambil pasangan candidate frame menggunakan deskriptor **DINOv2-SALAD**, memprediksi constraint relative pose via ABot-Recon, lalu memoles trajektori menggunakan **sparse pose-graph optimization**.

Hal menarik lainnya datang dari ekosistem komunitas. Tim **AXERA-TECH** sukses melakukan porting ABot-Recon ke **NPU Axera AX650N**. Adaptasi ini mencakup dukungan inference berbasis PCIe (AXCL) maupun *on-device inference* langsung di atas board AX650N lengkap dengan precompiled models, Docker image, dan web mapping service. Ini berita besar buat developer edge computing yang ingin menjalankan rekonstruksi 3D tanpa tergantung pada GPU kelas server yang mahal.

## Setup Environment dan Eksekusi Pipeline

Untuk kamu yang ingin langsung menjajal codebase ini di environment lokal, persyaratannya cukup spesifik. System requirement resmi menargetkan OS Linux, Python 3.10 atau lebih baru, PyTorch 2.5.1, serta CUDA 12.1. Lingkungan ini divalidasi menggunakan **NVIDIA A100** dan **NVIDIA H100**.

Proses instalasi dasar cukup mudah melalui terminal:

```bash
conda create -n abot-recon python=3.11 -y
conda activate abot-recon

pip install torch==2.5.1 torchvision==0.20.1 --index-url https://download.pytorch.org/whl/cu121
pip install -e .
```

Agar performa komputasinya maksimal, sangat disarankan memasang operator paged KV-cache dari **FlashInfer** dan melakukan kompilasi **cuRoPE** untuk mempercepat rotary position encoding:

```bash
pip install flashinfer-python
cd abot_recon/modeling/pi3/models/curope
pip install ninja
python setup.py build_ext --inplace
cd -
```

Untuk menjalankan eksekusi inferensi dasar tanpa loop closure, kamu hanya perlu mengeksekusi skrip CLI berikut:

```bash
python demo.py \
  --image-dir examples/images \
  --output-dir outputs/demo \
  --attention-backend auto \
  --no-loop-closure
```

Jika kamu lebih nyaman menggunakan Python API langsung ke dalam skrip kustom milikmu, struktur pemanggilannya juga dibuat sangat simpel:

```python
from pathlib import Path
from abot_recon import ABotRecon

images = sorted(Path("examples/images").glob("*.jpg"))

model = ABotRecon.from_pretrained(
    "acvlab/ABot-Recon",
    device="cuda",
    attention_backend="auto",
    loop_closure=False,
)

result = model.infer(images)
trajectory = result.camera_poses
relative_poses = result.relative_poses
local_points = result.local_points
confidence = result.confidence
```

File bobot pretrained (`abot_recon.safetensors`) akan terunduh otomatis dari Hugging Face atau ModelScope. Output yang dihasilkan meliputi file koordinat trajektori kamera (`camera_poses.npy`), point map lokal (`local_points.pt`), hingga confidence map. Seluruh codebase ini dirilis di bawah lisensi terbuka **Apache License 2.0**, dibangun di atas fondasi **Pi3**, serta terinspirasi dari proyek-proyek ternama seperti CroCo, DUSt3R, DINOv2, SALAD, LingBot-Map, HorizonStream, hingga LongStream.

Apakah pendekatan efisiensi lokal ini akan jadi standar baru arsitektur 3D reconstruction di masa depan? Melihat kombinasi FPS yang kencang dan footprint VRAM yang sangat ramah GPU, jawabannya hampir pasti: ya.

## Referensi
https://github.com/amap-cvlab/ABot-Recon

ABot-Recon menghadirkan inovasi streaming 3D reconstruction efisien tanpa memori jangka panjang, cukup mengandalkan 12-frame local context yang hemat VRAM.

Rekonstruksi 3D Video Durasi Panjang Bikin VRAM Siksa? ABot-Recon Buktikan Cukup Pakai 12 Frame Context

Solusi praktis integrasi webmail custom ke dalam dashboard Gmail. Kelola, baca, dan kirim email domain pribadi langsung dari satu tempat tanpa ribet gonta-ganti tab.

Mengapa Kamu Masih Buka Dua Tab Terpisah? Panduan Setup Custom Webmail Langsung di Dashboard Gmail

Pelajari efisiensi merakit mesin tetas telur listrik AC otomatis dengan modal murah untuk mendongkrak hasil ternak unggas tanpa repot bolak-balik telur manual.

Otomasi Ternak Unggas: Kenapa Rakit Sendiri Mesin Penetas Telur AC Jauh Lebih Worth It Dibanding Cara Konvensional?

Pelajari bagaimana mesin tetas telur berbasis arus listrik DC bekerja menjaga suhu dan kelembapan ideal untuk mendongkrak keberhasilan penetasan telur unggas.

Mesin Tetas Telur Arus DC: Solusi Hardware Murah Buat Tingkatin Angka Penetasan Unggas

Kupas tuntas seluk-beluk mobil aki anak dengan kontrol ganda dan fitur multimedia. Pahami batas spesifikasi hardware sebelum eksekusi build sendiri.

EV Versi Mini: Membedah Mobil Listrik Aki Lengkap dengan Remote Control dan Fitur Multimedia

Pelajari cara merakit smart power strip berbasis NodeMCU dan Blynk untuk kontrol daya nirkabel serta integrasi IoT yang aman dan efisien.

Mengapa Beli Mahal Kalau Bisa Bikin Sendiri? Rancang Smart Power Strip Berbasis NodeMCU dan Blynk

Solusi tuntas mengatasi bug sistem dan software bermasalah di MacBook dengan panduan install ulang macOS lewat Internet Recovery secara aman.

#abot-recon

Getting Lastest Post..

Populer Bulan Ini