imt-ring 1.3.0__tar.gz → 1.3.1__tar.gz

{imt_ring-1.3.0 → imt_ring-1.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: imt-ring
-Version: 1.3.0
+Version: 1.3.1
 Summary: RING: Recurrent Inertial Graph-based Estimator
 Author-email: Simon Bachhuber <simon.bachhuber@fau.de>
 Project-URL: Homepage, https://github.com/SimiPixel/ring

{imt_ring-1.3.0 → imt_ring-1.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "imt-ring"
-version = "1.3.0"
+version = "1.3.1"
 authors = [
   { name="Simon Bachhuber", email="simon.bachhuber@fau.de" },
 ]

{imt_ring-1.3.0 → imt_ring-1.3.1}/src/imt_ring.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: imt-ring
-Version: 1.3.0
+Version: 1.3.1
 Summary: RING: Recurrent Inertial Graph-based Estimator
 Author-email: Simon Bachhuber <simon.bachhuber@fau.de>
 Project-URL: Homepage, https://github.com/SimiPixel/ring

{imt_ring-1.3.0 → imt_ring-1.3.1}/src/ring/algorithms/generator/base.py

@@ -4,6 +4,8 @@ import warnings
 
 import jax
 import jax.numpy as jnp
+import tree_utils
+
 from ring import base
 from ring import utils
 from ring.algorithms import jcalc
@@ -13,7 +15,6 @@ from ring.algorithms.generator import motion_artifacts
 from ring.algorithms.generator import randomize
 from ring.algorithms.generator import transforms
 from ring.algorithms.generator import types
-import tree_utils
 
 
 class RCMG:
@@ -108,23 +109,20 @@ class RCMG:
                         partial_build_gen(sys=_sys, config=_config, sys_ml=sys_ml)
                     )
 
-    def _to_data(self, sizes, seed, jit):
-        return batch.batch_generators_eager_to_list(
-            self.gens, sizes, seed=seed, jit=jit
-        )
+    def _to_data(self, sizes, seed):
+        return batch.batch_generators_eager_to_list(self.gens, sizes, seed=seed)
 
-    def to_list(self, sizes: int | list[int] = 1, seed: int = 1, jit: bool = False):
-        return self._to_data(sizes, seed, jit)
+    def to_list(self, sizes: int | list[int] = 1, seed: int = 1):
+        return self._to_data(sizes, seed)
 
     def to_pickle(
         self,
         path: str,
         sizes: int | list[int] = 1,
         seed: int = 1,
-        jit: bool = False,
         overwrite: bool = True,
     ) -> None:
-        data = tree_utils.tree_batch(self._to_data(sizes, seed, jit))
+        data = tree_utils.tree_batch(self._to_data(sizes, seed))
         utils.pickle_save(data, path, overwrite=overwrite)
 
     def to_hdf5(
@@ -132,10 +130,9 @@ class RCMG:
         path: str,
         sizes: int | list[int] = 1,
         seed: int = 1,
-        jit: bool = False,
         overwrite: bool = True,
     ) -> None:
-        data = tree_utils.tree_batch(self._to_data(sizes, seed, jit))
+        data = tree_utils.tree_batch(self._to_data(sizes, seed))
         utils.hdf5_save(path, data, overwrite=overwrite)
 
     def to_eager_gen(
@@ -143,11 +140,8 @@ class RCMG:
         batchsize: int = 1,
         sizes: int | list[int] = 1,
         seed: int = 1,
-        jit: bool = False,
     ) -> types.BatchedGenerator:
-        return batch.batch_generators_eager(
-            self.gens, sizes, batchsize, seed=seed, jit=jit
-        )
+        return batch.batch_generators_eager(self.gens, sizes, batchsize, seed=seed)
 
     def to_lazy_gen(
         self, sizes: int | list[int] = 1, jit: bool = True

{imt_ring-1.3.0 → imt_ring-1.3.1}/src/ring/algorithms/generator/batch.py

@@ -6,12 +6,13 @@ import warnings
 import jax
 import jax.numpy as jnp
 import numpy as np
-from ring import utils
-from ring.algorithms.generator import types
 from tqdm import tqdm
 import tree_utils
 from tree_utils import tree_batch
 
+from ring import utils
+from ring.algorithms.generator import types
+
 
 def _build_batch_matrix(batchsizes: list[int]) -> jax.Array:
     arr = []
@@ -61,11 +62,24 @@ def batch_generators_lazy(
     return generator
 
 
+def _number_of_executions_required(size: int) -> int:
+    vmap_threshold = 128
+    _, vmap = utils.distribute_batchsize(size)
+
+    primes = iter(utils.primes(vmap))
+    n_calls = 1
+    while vmap > vmap_threshold:
+        prime = next(primes)
+        n_calls *= prime
+        vmap /= prime
+
+    return n_calls
+
+
 def batch_generators_eager_to_list(
     generators: types.Generator | list[types.Generator],
     sizes: int | list[int],
     seed: int = 1,
-    jit: bool = True,
 ) -> list[tree_utils.PyTree]:
     "Returns list of unbatched sequences as numpy arrays."
     generators, sizes = _process_sizes_batchsizes_generators(generators, sizes)
@@ -73,11 +87,20 @@ def batch_generators_eager_to_list(
     key = jax.random.PRNGKey(seed)
     data = []
     for gen, size in tqdm(zip(generators, sizes), desc="eager data generation"):
-        key, consume = jax.random.split(key)
-        sample = batch_generators_lazy(gen, size, jit=jit)(consume)
-        # converts also to numpy
-        sample = jax.device_get(sample)
-        data.extend([jax.tree_map(lambda a: a[i], sample) for i in range(size)])
+
+        n_calls = _number_of_executions_required(size)
+        # decrease size by n_calls times
+        size = int(size / n_calls)
+        jit = True if n_calls > 1 else False
+        gen_jit = batch_generators_lazy(gen, size, jit=jit)
+
+        for _ in range(n_calls):
+            key, consume = jax.random.split(key)
+            sample = gen_jit(consume)
+            # converts also to numpy
+            sample = jax.device_get(sample)
+            data.extend([jax.tree_map(lambda a: a[i], sample) for i in range(size)])
+
     return data
 
 
@@ -243,12 +266,11 @@ def batch_generators_eager(
     shuffle: bool = True,
     drop_last: bool = True,
     seed: int = 1,
-    jit: bool = True,
 ) -> types.BatchedGenerator:
     """Eagerly create a large precomputed generator by calling multiple generators
     and stacking their output."""
 
-    data = batch_generators_eager_to_list(generators, sizes, seed=seed, jit=jit)
+    data = batch_generators_eager_to_list(generators, sizes, seed=seed)
     return batched_generator_from_list(data, batchsize, shuffle, drop_last)
 
 
@@ -270,7 +292,7 @@ def _process_sizes_batchsizes_generators(
 
     assert len(generators) == len(list_sizes)
 
-    _WARN_SIZE = 4096
+    _WARN_SIZE = 1e6  # disable this warning
     for size in list_sizes:
         if size >= _WARN_SIZE:
             warnings.warn(

{imt_ring-1.3.0 → imt_ring-1.3.1}/src/ring/base.py

@@ -99,15 +99,15 @@ class _Base:
     def ndim(self):
         return tu.tree_ndim(self)
 
-    def shape(self, axis=0) -> int:
-        return tu.tree_shape(self, axis)
-
-    def __len__(self) -> int:
-        Bs = tree_map(lambda arr: arr.shape[0], self)
+    def shape(self, axis: int = 0) -> int:
+        Bs = tree_map(lambda arr: arr.shape[axis], self)
         Bs = set(jax.tree_util.tree_flatten(Bs)[0])
         assert len(Bs) == 1
         return list(Bs)[0]
 
+    def __len__(self) -> int:
+        return self.shape(axis=0)
+
 
 @struct.dataclass
 class Transform(_Base):
@@ -685,14 +685,13 @@ class System(_Base):
         self,
         xs: Transform | list[Transform],
         yhat: dict | jax.Array | np.ndarray,
-        stepframe: int = 1,
         # by default we don't predict the global rotation
         transparent_segment_to_root: bool = True,
         **kwargs,
     ):
         "`xs` matches `sys`. `yhat` matches `sys_noimu`. `yhat` are child-to-parent."
         return ring.rendering.render_prediction(
-            self, xs, yhat, stepframe, transparent_segment_to_root, **kwargs
+            self, xs, yhat, transparent_segment_to_root, **kwargs
         )
 
     def delete_system(self, link_name: str | list[str], strict: bool = True):

{imt_ring-1.3.0 → imt_ring-1.3.1}/src/ring/ml/__init__.py

@@ -12,6 +12,8 @@ from .optimizer import make_optimizer
 from .ringnet import RING
 from .train import train_fn
 
+_lpf_cutoff_freq = 10.0
+
 
 def RING_ICML24(params=None, eval: bool = True, **kwargs):
     """Create the RING network used in the icml24 paper.
@@ -29,7 +31,7 @@ def RING_ICML24(params=None, eval: bool = True, **kwargs):
     ringnet = RING(params=params, **kwargs)  # noqa: F811
     ringnet = base.ScaleX_FilterWrapper(ringnet)
     if eval:
-        ringnet = base.LPF_FilterWrapper(ringnet, 10.0, samp_freq=None)
+        ringnet = base.LPF_FilterWrapper(ringnet, _lpf_cutoff_freq, samp_freq=None)
     ringnet = base.GroundTruthHeading_FilterWrapper(ringnet)
     return ringnet
 
@@ -55,7 +57,7 @@ def RNNO(
     ringnet = base.NoGraph_FilterWrapper(ringnet, quat_normalize=return_quats)
     ringnet = base.ScaleX_FilterWrapper(ringnet)
     if eval and return_quats:
-        ringnet = base.LPF_FilterWrapper(ringnet, 10.0, samp_freq=None)
+        ringnet = base.LPF_FilterWrapper(ringnet, _lpf_cutoff_freq, samp_freq=None)
     if return_quats:
         ringnet = base.GroundTruthHeading_FilterWrapper(ringnet)
     return ringnet

{imt_ring-1.3.0 → imt_ring-1.3.1}/src/ring/rendering/base_render.py

@@ -136,12 +136,15 @@ def render_prediction(
     sys: base.System,
     xs: base.Transform | list[base.Transform],
     yhat: dict | jax.Array | np.ndarray,
-    stepframe: int = 1,
     # by default we don't predict the global rotation
     transparent_segment_to_root: bool = True,
     **kwargs,
 ):
     "`xs` matches `sys`. `yhat` matches `sys_noimu`. `yhat` are child-to-parent."
+
+    offset_truth = kwargs.pop("offset_truth", [0, 0, 0])
+    offset_pred = kwargs.pop("offset_pred", [0, 0, 0])
+
     if isinstance(xs, list):
         # list -> batched Transform
         xs = xs[0].batch(*xs[1:])
@@ -180,18 +183,23 @@ def render_prediction(
 
     # swap time axis, and link axis
     xs, xshat = xs.transpose((1, 0, 2)), xshat.transpose((1, 0, 2))
+
+    add_offset = lambda x, offset: algebra.transform_mul(
+        x, base.Transform.create(pos=jnp.array(offset, dtype=jnp.float32))
+    )
+
     # create mapping from `name` -> Transform
     xs_dict = dict(
         zip(
             ["hat_" + name for name in sys_noimu.link_names],
-            [xshat[i] for i in range(sys_noimu.num_links())],
+            [add_offset(xshat[i], offset_pred) for i in range(sys_noimu.num_links())],
         )
     )
     xs_dict.update(
         dict(
             zip(
                 sys.link_names,
-                [xs[i] for i in range(sys.num_links())],
+                [add_offset(xs[i], offset_truth) for i in range(sys.num_links())],
             )
         )
     )
@@ -202,11 +210,8 @@ def render_prediction(
         xs_render.append(xs_dict[name])
     xs_render = xs_render[0].batch(*xs_render[1:])
     xs_render = xs_render.transpose((1, 0, 2))
-    N = xs_render.shape()
-    xs_render = [xs_render[t] for t in range(0, N, stepframe)]
 
     frames = render(sys_render, xs_render, **kwargs)
-
     return frames
 
 

{imt_ring-1.3.0 → imt_ring-1.3.1}/src/ring/utils/__init__.py

@@ -15,6 +15,7 @@ from .utils import dict_union
 from .utils import import_lib
 from .utils import pickle_load
 from .utils import pickle_save
+from .utils import primes
 from .utils import pytree_deepcopy
 from .utils import sys_compare
 from .utils import to_list

{imt_ring-1.3.0 → imt_ring-1.3.1}/src/ring/utils/utils.py

@@ -159,3 +159,17 @@ def pickle_load(
     with open(path, "rb") as file:
         obj = pickle.load(file)
     return obj
+
+
+def primes(n: int) -> list[int]:
+    "Primefactor decomposition in ascending order."
+    primfac = []
+    d = 2
+    while d * d <= n:
+        while (n % d) == 0:
+            primfac.append(d)  # supposing you want multiple factors repeated
+            n //= d
+        d += 1
+    if n > 1:
+        primfac.append(n)
+    return primfac