Update: seeding

Author: heptaflar

kaleidoscope/algorithms/randomize.py

@@ -9,33 +9,12 @@
 
 import dask.array as da
 import numpy as np
-from numpy.random import SeedSequence
 
 from ..generators import DefaultNormal
 from ..interface.algorithm import InformedBlockAlgorithm
 from ..interface.generating import Normal
 
 
-def _block_seed(
-    block_id: tuple[int, ...], root_seed: np.ndarray
-) -> np.ndarray:
-    """Returns a random seed array for a given block."""
-    work_seed = SeedSequence(_hash(block_id)).generate_state(1)
-    return np.array([i for i in work_seed] + [i for i in root_seed])
-
-
-def _hash(block_id: tuple[int, ...]) -> int:
-    """
-    Daniel J. Bernstein hash function.
-
-    Returns a positive hash value.
-    """
-    h = 5381
-    for i in block_id:
-        h = ((h << 5) + h) + i
-    return h
-
-
 def _chlorophyll(
     seed: np.ndarray, x: np.ndarray, u: np.ndarray
 ) -> np.ndarray:
@@ -78,19 +57,19 @@ def __init__(
         dtype: np.dtype = np.single,
         m: int = 2,
         dist: Literal["normal", "lognormal", "chlorophyll"] | str = "normal",
-        entropy: int | list[int] | None = None,
+        seed: np.ndarray | None = None,
     ):
         """
         Creates a new algorithm instance.
 
         :param dtype: The result data type.
         :param m: The number of input data dimensions.
         :param dist: The type of measurement error distribution.
-        :param entropy: The entropy to create the seed sequence.
+        :param seed: The root seed.
         """
         super().__init__(dtype, m, m)
         self._dist = dist
-        self._root_seed = SeedSequence(entropy).generate_state(8)
+        self._root_seed = seed
 
     def chunks(self, *inputs: da.Array) -> tuple[int, ...] | None:
         return None
@@ -120,7 +99,7 @@ def randomize(
         :param clip: Where to clip measurement errors.
         :return: The measurement values randomized.
         """
-        seed = _block_seed(kwargs["block_id"], self._root_seed)
+        seed = self.block_seed(kwargs["block_id"])
 
         x = data[0]
         u = (
@@ -143,10 +122,14 @@ def randomize(
                 y = x
         if clip is not None:
             y = np.clip(y, a_min=clip[0], a_max=clip[1])
-        return y
+        return np.where(np.isfinite(y), y, x)
 
     compute_block = randomize
 
+    def block_seed(self, block_id: tuple[int, ...]) -> np.ndarray:
+        """Returns the block seed."""
+        return np.array([i for i in block_id] + [i for i in self._root_seed])
+
     @property
     def name(self) -> str:
         return "randomize"

kaleidoscope/operators/randomizeop.py

@@ -24,18 +24,6 @@
 from ..logger import get_logger
 
 
-def _hash(name: str) -> int:
-    """
-    Daniel J. Bernstein hash function.
-
-    Returns a positive hash value.
-    """
-    h = 5381
-    for c in name:
-        h = ((h << 5) + h) + ord(c)
-    return h
-
-
 def _decode(x: da.Array, a: dict[str:Any]) -> da.Array:
     """Returns decoded data."""
     f = Decode(np.single if x.dtype == np.single else np.double, x.ndim)
@@ -101,7 +89,7 @@ def run(self, source: Dataset) -> Dataset:  # noqa: D102
             if v not in config or self._args.selector == 0:
                 continue
             get_logger().info(f"starting graph for variable: {v}")
-            self.randomize(source, target, v, x, config[v])
+            self.randomize(target, v, x, config[v])
             get_logger().info(f"finished graph for variable: {v}")
         return target
 
@@ -116,28 +104,8 @@ def config(self) -> dict[str : dict[str:Any]]:
                 config = json.load(r)
         return config
 
-    # noinspection PyShadowingNames
-    def entropy(self, name: str, uuid: str, n: int = 4) -> list[int]:
-        """
-        Returns the entropy of the seed sequence used for a given variable.
-
-        Entropy is generated using the Philox bit generator, which produces
-        truly independent sequences for different values of the seed.
-
-        :param name: The variable name.
-        :param uuid: The dataset UUID.
-        :param n: The length of the seed sequence.
-        :return: The entropy.
-        """
-        from numpy.random import Philox
-
-        seed = _hash(f"{name}-{uuid}") + self._args.selector
-        g = DefaultGenerator(Philox(seed))
-        return [g.next() for _ in range(n)]
-
     def randomize(
         self,
-        source: Dataset,
         target: Dataset,
         v: str,
         x: DataArray,
@@ -146,22 +114,14 @@ def randomize(
         """
         Creates the graph to randomize a variable.
 
-        :param source: The source dataset.
         :param target: The target dataset.
         :param v: The name of the variable.
         :param x: The data of the variable.
         :param config: The randomization configuration.
         """
-        if "total" in config:
-            s: list[int] = []
-            z = _decode(x.data, x.attrs)
-            for ref in config["total"]:
-                a = _decode(target[ref].data, target[ref].attrs)
-                b = _decode(source[ref].data, source[ref].attrs)
-                z = z + (a - b)
-        elif "uncertainty" in config:
-            s: list[int] = self.entropy(v, self.uuid)
-            f = Randomize(m=x.ndim, dist=config["distribution"], entropy=s)
+        if "uncertainty" in config:
+            s = self.seed(self.uuid(v))
+            f = Randomize(m=x.ndim, dist=config["distribution"], seed=s)
             u = (
                 target[config["uncertainty"]]
                 if isinstance(config["uncertainty"], str)
@@ -182,8 +142,8 @@ def randomize(
                 clip=config.get("clip", None),
             )
         else:
-            s: list[int] = self.entropy(v, self.uuid)
-            f = Randomize(m=x.ndim, dist=config["distribution"], entropy=s)
+            s = self.seed(self.uuid(v))
+            f = Randomize(m=x.ndim, dist=config["distribution"], seed=s)
             b = target[config["bias"]]
             r = target[config["rmsd"]]
             z = f.apply_to(
@@ -206,20 +166,38 @@ def randomize(
                 ],
                 dtype=z.dtype,
             )
-        if s:
-            target[v].attrs["entropy"] = np.array(s, dtype=np.int64)
+        target[v].attrs["seed"] = s
         if get_logger().is_enabled(Logging.DEBUG):
-            get_logger().debug(f"entropy: {s}")
+            get_logger().debug(f"seed: {s}")
             get_logger().debug(f"min:  {da.nanmin(z).compute() :.3f}")
             get_logger().debug(f"max:  {da.nanmax(z).compute() :.3f}")
             get_logger().debug(f"mean: {da.nanmean(z).compute() :.3f}")
             get_logger().debug(f"std:  {da.nanstd(z).compute() :.3f}")
 
-    @property
-    def uuid(self) -> str:
+    # noinspection PyShadowingNames
+    def seed(self, uuid: uuid.UUID, n: int = 4) -> np.ndarray:
+        """
+        Returns the seed sequence used for a given variable.
+
+        The seed sequence is generated using the Philox bit generator,
+        which produces truly independent sequences of random numbers for
+        different values of the seed.
+
+        :param uuid: The variable and dataset UUID.
+        :param n: The length of the seed sequence.
+        :return: The seed sequence.
+        """
+        from numpy.random import Philox
+
+        seed = uuid.int + self._args.selector
+        g = DefaultGenerator(Philox(seed))
+        return np.array([g.next() for _ in range(n)], dtype=np.int64)
+
+    def uuid(self, v: str) -> uuid.UUID:
         """
-        Returns a UUID constructed from the basename of the source file.
+        Returns a UUID constructed from the variable name and the
+        basename of the source file.
         """
-        return (
-            f"{uuid.uuid5(uuid.NAMESPACE_URL, self._args.source_file.stem)}"
+        return uuid.uuid5(
+            uuid.NAMESPACE_URL, f"{v}-{self._args.source_file.stem}"
         )