Thanks for the library! I'm trying to update the mu of a prior factor based on the optimized pose of another graph's node. However I'm stuck figuring out how the rows of graph.factor_stacks[1].factor.mu.unit_complex_xy correspond to which nodes. Any help? Thanks

Hi Brent,

It seems that the solution_assignments is not consistent with the order of pose_variables in pose_graph_simple.py(https://github.com/brentyi/jaxfg/blob/f5204945bb6afa444810e6163e9a913bdbdd636b/scripts/pose_graph_simple.py). For the original code, the outputs of

# Grab and print a single variable value at a time.
print("First pose (jaxlie.SE2 object):")
print(solution_assignments.get_value(pose_variables[0]))
print()

print("Second pose (jaxlie.SE2 object):")
print(solution_assignments.get_value(pose_variables[1]))
print()

was

First pose (jaxlie.SE2 object): 
SE2(unit_complex=[1. 0.], xy=[0.33333 0.     ])

Second pose (jaxlie.SE2 object):
SE2(unit_complex=[1. 0.], xy=[1.66667 0.     ])

However, if I change the code of creating the factor graph to (switch the order of the two PriorFactors)

factors: List[jaxfg.core.FactorBase] = [
jaxfg.geometry.PriorFactor.make(
        variable=pose_variables[1],
        mu=jaxlie.SE2.from_xy_theta(2.0, 0.0, 0.0),
        noise_model=jaxfg.noises.DiagonalGaussian(jnp.ones(3)),
    ),
    jaxfg.geometry.PriorFactor.make(
        variable=pose_variables[0],
        mu=jaxlie.SE2.from_xy_theta(0.0, 0.0, 0.0),
        noise_model=jaxfg.noises.DiagonalGaussian(jnp.ones(3)),
    ),
    jaxfg.geometry.BetweenFactor.make(
        variable_T_world_a=pose_variables[0],
        variable_T_world_b=pose_variables[1],
        T_a_b=jaxlie.SE2.from_xy_theta(1.0, 0.0, 0.0),
        noise_model=jaxfg.noises.DiagonalGaussian(jnp.ones(3)),
    ),
]

Then, the outputs become

First pose (jaxlie.SE2 object):
SE2(unit_complex=[1. 0.], xy=[1.66667 0.     ])

Second pose (jaxlie.SE2 object):
SE2(unit_complex=[1. 0.], xy=[0.33333 0.     ])

It seems that the order in the solution_assignments is determined by the order of the factors?

Hey @brentyi this PR should fix: https://github.com/brentyi/jaxfg/issues/12 Not sure about sorting the full list of variables as sorted is not in-place afaik. If performance is an issue, we could scan over the full list first and extract all unique type(variable)-keys and sort them rather the full list. Let me know what you think :)

Hi, this projects looks awesome! I definitely see some potential synergy/overlap with JAXopt: https://github.com/google/jaxopt

Would you consider adding an open source license so others can use your code? GitHub has some good guidance here: https://docs.github.com/en/github/creating-cloning-and-archiving-repositories/creating-a-repository-on-github/licensing-a-repository

Thanks!

https://github.com/brentyi/jaxfg/blob/master/jaxfg/core/_variables.py#L151

I tried to use the RealVectorVariable[dim] to instantiate a real vector variable. But I got an TypeError: Parameter list is too short. I fixed error by changing the code from

        class _RealVectorVariable(VariableBase[hints.Array]):
            @staticmethod
            @overrides
            @final
            def get_default_value() -> hints.Array:
                return jnp.zeros(dim)

to

        class _RealVectorVariable(VariableBase[hints.Array]):
            @classmethod
            @overrides
            @final
            def get_default_value(cls) -> hints.Array:
                return jnp.zeros(dim)

Hey @brentyi In the latest jax-version jax.partial was replaced in favor of functools.partial. Should be fixed by this PR https://github.com/google/jax/releases/tag/jax-v0.2.21

@SuperN1ck would be nice if you could skim through this and let me know if it makes sense!

Thing that affects you: after this is merged, factor classes will need to be decorated with @register_pytree_dataclass*.

Main change is to refactor the logic used for designating static dataclass fields. Allows us to:

• Specify static fields using dataclasses.field metadata.
• Unify registration logic used across the library. Factors used to do their own thing.

*I may just pull all this dataclass code into its own library and do some renaming, it seems somewhat generally useful and could help reduce boilerplate in jaxlie as well.

Hi, is there any comparison of performance between this library and others( such as ceres solver, g2o, gtsam)? And, since the jaxfg is based on Jax, can the jaxfg use cuda to significantly speed up optimization speed.?

These are simple least squares examples of how to apply a factor graph and how to use this codebase. This would have helped me a lot in understanding both the concepts and implementation. I was a bit confused first what Lie groups have to do with factor graphs... :)

Hello

This project seems very interesting, thanks for sharing it.

Could you please provide an example of a SLAM implementation using in the examples section using a popular dataset (KITTI or oxford dataset for example)?

This would be a very helpful example to learn how to use the library.

Thanks in advance