Top AI Repos — open-source AI, indexed and scored
Top AI Repos tracks AI repositories on GitHub and answers two different questions about each one: is it moving right now, and would you bet a product on it.
Top AI Repos tracks AI repositories on GitHub and answers two different questions about each one: is it moving right now, and would you bet a product on it.
For an education purpose, from-scratch, single-file, python-only pose-graph optimization implementation
| Date | Stars |
|---|---|
| 2026-07-24 | 298 |
| 2026-07-25 | 298 |
| 2026-07-28 | 298 |
| 2026-07-30 | 298 |
| 2026-08-06 | 298 |
Today
— stars today
This week
— stars this week
This month
— stars this month
Momentum
0.0
growth rate 0.00%/day
# nano-pgo
*Figure 1: Example Results Visualization. More examples can be found [here](docs/results/visualization).*
- Features
- For an education purpose
- From-scratch pose-graph optimization implementation
- This tried to maximize the code-level transparency of the process of generating the H and b matrices, building a linear system, and controlling the LM iterations.
- A single file
- Miminum dependencies: numpy/scipy/symforce/sksparse (and open3d for visualization).
- numpy for basic matrix handling
- scipy for basic rotation functions and sparse matrix containers
- symforce for the auto-generated symbolic Jacobian (optional)
- sksparse for cholmod and solve function
- open3d for large-sized point cloud (pose-graph) visualization
- I hope this hands-on tutorial code can also be used as training material for Symforce's auto-generated optimized Jacobian code generation (codegen).
- For the details, see below [Symforce-based Auto-generated Jacobians](#symforce-based-auto-generated-jacobians).
- ps. This tutorial supports only batch pose-graph optimization (but with a sparse solver!) and does not cover incrementally expanding pose-graph optimization (e.g., iSAM).
## Overview
*Figure 2: The pipeline of nano-pgo*
## Direct demo page
- You can enjoy [nano-pgo via colab](https://colab.research.google.com/drive/1SmUaaiExfMV9EzAIGDuVPSV-K5655YQE?usp=sharing)!
## Preparation (dependencies)
- Recommend to use python<3.12 and numpy<2, for example,
- `$ python3.11 -m venv ~/envs/py311`
- `$ source ~/envs/py311/bin/activate`
- `$ pip install "numpy<2.0"`
- `$ pip install scipy`
- `$ sudo apt-get install libsuitesparse-dev`
- `$ pip install scikit-sparse`
- `$ pip install symforce`
- `$ pip install matplotlib`
- `$ pip install open3d`
## How to use
- `$ python nano_pgo.py`
- It's also recommended to compare the results from GTSAM (better and faster!) by using `baseline_gtsam.py`.
- Note that the nano_pgo.py's goal is a maximized transparency of all logics and theories from state representations to building and solving linear systems.
- [Demo video can be found here](https://youtu.be/tEdIfHYY3uQ?si=sKo4jC2UZS_uiSSR).
## Goal
- Understand
- what is pose-graph optimization.
- what is a g2o-format pose-graph data.
- what is se(3) and SE(3) (the tangent space and the manifold).
- what is iterative least-square optimization and solving normal equation.
- what is the error and jacobians of between factors and how to be derived.
- what is the gauge freedom of pose-graph SLAM.
- why sparse solver is necessary (here, we used sksparse.cholmod).
- why damping is necessary (i.e., LM iterative optimization method).
- why robust loss is necessary (here, we used Cauchy deweighting).
- what are the differences between numerical and symbolic diffs.
- how to use symforce APIs.
- how to use GTSAM APIs.
- why rotation initialization is important
- what is the real-world problems, use-cases, and state-of-the arts.
## Symforce-based Auto-generated Jacobians
- SymForce eliminates the need for tedious and error-prone manual Jacobian derivations.
- You can enjoy this feature by setting `self.use_symforce_generated_jacobian=True` and `debug_compare_jacobians=True`.
*Figure 3: Auto-generated Symbolic Jacobian's effectiveness.*
- You can first automatically generate the (symbolic) Jacobian of the relative SE(3) error like this,
```python
import symforce.symbolic as sf
from symforce.ops import LieGroupOps
# Define rotation variables (rotation vectors for each axis)
sf_ri = sf.V3.symbolic("ri") # Rotation of pose_i
sf_rj = sf.V3.symbolic("rj") # Rotation of poseExcerpt of 13,064 characters
Read on GitHubWould you bet a product on this? Bounded 0–100 and slow moving.
matched fp:98058d1c18a148af, topic:slam, readme:slam