NetKet 3.22.3__tar.gz → 3.23.0__tar.gz

{netket-3.22.3 → netket-3.23.0}/.gitignore

@@ -21,6 +21,7 @@ pip-wheel-metadata
 .ipynb_checkpoints
 .pytest_cache
 .benchmarks
+.jax-cache
 .mypy_cache
 .virtual_documents
 .ruff_cache
@@ -43,6 +44,8 @@ uv.lock
 # Logs and databases #
 ######################
 *.log
+# per-rank output of djaxrun
+djaxrunlog-p*
 *.sql
 *.sqlite
 *.json

{netket-3.22.3 → netket-3.23.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: NetKet
-Version: 3.22.3
+Version: 3.23.0
 Summary: Netket : Machine Learning toolbox for many-body quantum systems.
 Project-URL: homepage, https://www.netket.org
 Project-URL: documentation, https://netket.readthedocs.io/en/latest/#
@@ -54,7 +54,7 @@ Requires-Dist: myst-nb<1.5,>=1.0; extra == 'docs'
 Requires-Dist: myst-parser<5.2.0,>=2.0.0; extra == 'docs'
 Requires-Dist: nbconvert>=7.16.6; extra == 'docs'
 Requires-Dist: sphinx-autodoc-typehints<4.0,>=1.22; extra == 'docs'
-Requires-Dist: sphinx-book-theme<1.3,>=1.1; extra == 'docs'
+Requires-Dist: sphinx-book-theme<1.5,>=1.1; extra == 'docs'
 Requires-Dist: sphinx-copybutton>=0.5.2; extra == 'docs'
 Requires-Dist: sphinx-design>=0.4.0; extra == 'docs'
 Requires-Dist: sphinx<9.2.0,>=8.2.3; extra == 'docs'
@@ -66,6 +66,7 @@ Requires-Dist: mlflow>=2.0.0; extra == 'extra'
 Requires-Dist: openfermion>=1.0.0; extra == 'extra'
 Requires-Dist: qutip>=4; extra == 'extra'
 Requires-Dist: tensorboardx>=2.0.0; extra == 'extra'
+Requires-Dist: wandb>=0.19.0; extra == 'extra'
 Provides-Extra: pyscf
 Requires-Dist: pyscf>=2.0; extra == 'pyscf'
 Description-Content-Type: text/markdown

{netket-3.22.3 → netket-3.23.0}/netket/_src/callbacks/base.py

@@ -25,6 +25,23 @@ class StopRun(Exception):
     pass
 
 
+class RunFinished(StopRun):
+    """
+    Exception to be raised by callbacks to end a run that has reached its end,
+    for example the final time of a time evolution.
+
+    It works like :class:`~netket.callbacks.StopRun`, but the driver does not
+    print that the run is stopping early.
+    """
+
+
+#: ``callback_order`` for callbacks that may raise :class:`StopRun`. They run
+#: *last* (after observables at 0 and loggers at 10) so that, on the step a
+#: callback stops the run, no later callback in the hook is skipped — a skipped
+#: collective would deadlock the run under ``jax.distributed``.
+STOPPING_CALLBACK_ORDER = 100
+
+
 class AbstractCallback(struct.Pytree, mutable=True):
     """
     Abstract base class for callbacks in advanced variational drivers.
@@ -71,7 +88,9 @@ class AbstractCallback(struct.Pytree, mutable=True):
         Lower numbers are called first, and higher numbers are called later.
 
         This can be redefined in subclasses to change the order in which callbacks are called.
-        (Default: 0, for all callbacks, 10 for loggers).
+        (Default: 0, for all callbacks, 10 for loggers, and
+        :data:`STOPPING_CALLBACK_ORDER` (100) for callbacks that may raise
+        :class:`StopRun`, so they run after everything else).
         """
         return 0
 

{netket-3.22.3 → netket-3.23.0}/netket/_src/callbacks/convergence_stopping.py

@@ -12,13 +12,16 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from collections import deque
-
 import numpy as np
+from flax import serialization
 
 from netket.utils import struct
 
-from netket._src.callbacks.base import AbstractCallback, StopRun
+from netket._src.callbacks.base import (
+    AbstractCallback,
+    StopRun,
+    STOPPING_CALLBACK_ORDER,
+)
 
 
 class ConvergenceStopping(AbstractCallback, mutable=True):
@@ -37,8 +40,11 @@ class ConvergenceStopping(AbstractCallback, mutable=True):
     """The loss must be consistently below this value for this number of
     iterations in order to stop the optimisation."""
 
-    _loss_window: deque = struct.field(pytree_node=False, serialize=False)
-    _patience_counter: int = struct.field(pytree_node=False, serialize=False, default=0)
+    # Saved, so that a run resumed from a checkpoint keeps its history. The window
+    # has a fixed length: only its last `_n_losses` entries are filled.
+    _loss_window: tuple[float, ...] = struct.field(pytree_node=False, serialize=True)
+    _n_losses: int = struct.field(pytree_node=False, serialize=True, default=0)
+    _patience_counter: int = struct.field(pytree_node=False, serialize=True, default=0)
 
     def __init__(
         self,
@@ -69,14 +75,32 @@ class ConvergenceStopping(AbstractCallback, mutable=True):
         self.smoothing_window = smoothing_window
         self.patience = patience
 
-        self._loss_window = deque([], maxlen=smoothing_window)
+        self._loss_window = (0.0,) * smoothing_window
+        self._n_losses = 0
         self._patience_counter = 0
 
+    def __process_deserialization_state__(self, state):
+        # If the file has no window (older versions) or one of a different size,
+        # start the window over.
+        if len(state.get("_loss_window", ())) != self.smoothing_window:
+            state = {
+                k: v for k, v in state.items() if k not in ("_loss_window", "_n_losses")
+            }
+        names = ("_loss_window", "_n_losses", "_patience_counter")
+        defaults = {n: serialization.to_state_dict(getattr(self, n)) for n in names}
+        return {**defaults, **state}
+
+    @property
+    def callback_order(self) -> int:
+        # Run last, so raising StopRun never skips a later callback's collective.
+        return STOPPING_CALLBACK_ORDER
+
     def on_step_end(self, step, log_data, driver):
-        loss = np.asarray(np.real(getattr(log_data[driver._loss_name], self.monitor)))
+        loss = np.real(getattr(log_data[driver._loss_name], self.monitor))
 
-        self._loss_window.append(loss)
-        loss_smooth = np.mean(self._loss_window)
+        self._loss_window = (*self._loss_window[1:], float(np.mean(loss)))
+        self._n_losses = min(self._n_losses + 1, self.smoothing_window)
+        loss_smooth = np.mean(self._loss_window[-self._n_losses :])
 
         if loss_smooth <= self.target:
             self._patience_counter += 1

{netket-3.22.3 → netket-3.23.0}/netket/_src/callbacks/early_stopping.py

@@ -16,7 +16,11 @@ import numpy as np
 
 from netket.utils import struct
 
-from netket._src.callbacks.base import AbstractCallback, StopRun
+from netket._src.callbacks.base import (
+    AbstractCallback,
+    StopRun,
+    STOPPING_CALLBACK_ORDER,
+)
 
 
 class EarlyStopping(AbstractCallback, mutable=True):
@@ -41,12 +45,14 @@ class EarlyStopping(AbstractCallback, mutable=True):
     start_from_step: int = struct.field(pytree_node=False)
     """Number of steps to wait before the callback has any effect."""
 
-    _best_val: float = struct.field(pytree_node=False, serialize=False, default=np.inf)
+    # Saved, so that a run resumed from a checkpoint keeps counting its patience
+    # instead of starting over.
+    _best_val: float = struct.field(pytree_node=False, serialize=True, default=np.inf)
     """Best value of the loss observed up to this iteration."""
-    _best_iter: int = struct.field(pytree_node=False, serialize=False, default=0)
+    _best_iter: int = struct.field(pytree_node=False, serialize=True, default=0)
     """Iteration at which the `_best_val` was observed."""
     _best_patience_counter: int = struct.field(
-        pytree_node=False, serialize=False, default=0
+        pytree_node=False, serialize=True, default=0
     )
     """Stores how many steps have elapsed without an improvement."""
 
@@ -87,6 +93,19 @@ class EarlyStopping(AbstractCallback, mutable=True):
         self._best_iter = 0
         self._best_patience_counter = 0
 
+    # TODO: backward compatibility for checkpoints saved before September 2026.
+    # Remove in 2027.
+    def __process_deserialization_state__(self, state):
+        # Files saved by older versions do not contain the best-so-far state.
+        names = ("_best_val", "_best_iter", "_best_patience_counter")
+        defaults = {name: self._pytree__fields[name].default for name in names}
+        return {**defaults, **state}
+
+    @property
+    def callback_order(self) -> int:
+        # Run last, so raising StopRun never skips a later callback's collective.
+        return STOPPING_CALLBACK_ORDER
+
     def on_step_end(self, step, log_data, driver):
         if step < self.start_from_step:
             return
@@ -95,7 +114,7 @@ class EarlyStopping(AbstractCallback, mutable=True):
 
         self._best_patience_counter += 1
         if self._is_improvement(loss, self._best_val):
-            self._best_val = loss
+            self._best_val = float(loss)
             self._best_iter = step
 
             if self.baseline is None:

{netket-3.22.3 → netket-3.23.0}/netket/_src/callbacks/invalid_loss_stopping.py

@@ -16,7 +16,11 @@ import numpy as np
 
 from netket.utils import struct
 
-from netket._src.callbacks.base import AbstractCallback, StopRun
+from netket._src.callbacks.base import (
+    AbstractCallback,
+    StopRun,
+    STOPPING_CALLBACK_ORDER,
+)
 
 
 class InvalidLossStopping(AbstractCallback, mutable=True):
@@ -29,7 +33,9 @@ class InvalidLossStopping(AbstractCallback, mutable=True):
     patience: int | float = struct.field(pytree_node=False)
     """Number of epochs with invalid loss after which training will be stopped."""
 
-    _last_valid_iter: int = struct.field(pytree_node=False, serialize=False, default=0)
+    # Saved, so that a run resumed from a checkpoint does not stop at the first
+    # invalid step, as if the loss had been invalid since step 0.
+    _last_valid_iter: int = struct.field(pytree_node=False, serialize=True, default=0)
     """Last valid iteration, to check against patience."""
 
     def __init__(self, monitor: str = "mean", patience: int | float = 0):
@@ -50,6 +56,17 @@ class InvalidLossStopping(AbstractCallback, mutable=True):
         self.patience = patience
         self._last_valid_iter = 0
 
+    # TODO: backward compatibility for checkpoints saved before September 2026.
+    # Remove in 2027.
+    def __process_deserialization_state__(self, state):
+        # Files saved by older versions do not contain it.
+        return {"_last_valid_iter": self._last_valid_iter, **state}
+
+    @property
+    def callback_order(self) -> int:
+        # Run last, so raising StopRun never skips a later callback's collective.
+        return STOPPING_CALLBACK_ORDER
+
     def on_step_end(self, step, log_data, driver):
         # reset if the driver was restarted
         if driver.step_count < self._last_valid_iter:
@@ -58,7 +75,9 @@ class InvalidLossStopping(AbstractCallback, mutable=True):
         if driver._loss_stats is not None:
             loss = np.real(getattr(driver._loss_stats, self.monitor))
 
-            if not np.isfinite(loss):
+            # `loss` may be vector-valued (e.g. a foundation ReplicaStats has one
+            # mean per anchor); stop if ANY component is non-finite.
+            if not np.all(np.isfinite(loss)):
                 if driver.step_count - self._last_valid_iter >= self.patience:
                     raise StopRun(
                         f"InvalidLossStopping: loss is not finite ({loss}) "

{netket-3.22.3 → netket-3.23.0}/netket/_src/callbacks/progressbar.py

@@ -10,28 +10,39 @@ from netket.utils import struct
 from netket._src.callbacks.base import AbstractCallback
 
 
+def _elapsed_time(driver, t_start: float, T_final: float) -> float:
+    """Time elapsed since `t_start`, at most `T_final`."""
+    return min(float(driver.t) - t_start, T_final)
+
+
 class TimeProgressBarCallback(AbstractCallback, mutable=True):
     """
     Progress bar displaying physical time for dynamics drivers.
 
-    Tracks ``driver.t ∈ [0, T_final]`` instead of step count.
+    Tracks the time elapsed since the start of the run, ``driver.t - t_start ∈
+    [0, T_final]``, instead of step count. ``t_start`` is ``driver._t_start`` if
+    the driver sets it (as the TDVP drivers do), and 0 otherwise.
     Used automatically by :class:`~netket.driver.AbstractDynamicsDriver`
     when :meth:`run` is called with a float time argument.
     """
 
     _T_final: float = struct.field(pytree_node=False, serialize=False)
-    _last_t: float = struct.field(pytree_node=False, serialize=False)
+    _t_start: float = struct.field(pytree_node=False, serialize=False)
     _pbar: Any = struct.field(pytree_node=False, serialize=False)
     _leave: bool = struct.field(pytree_node=False, serialize=False)
 
     def __init__(self, T_final: float, leave: bool = True):
         self._T_final = T_final
-        self._last_t = 0.0
+        self._t_start = 0.0
         self._pbar = None
         self._leave = leave
 
     def on_run_start(self, step, driver):
-        self._last_t = float(driver.t)
+        # Count from the time the run started at, even if another callback
+        # changes the time (e.g. when resuming from a checkpoint).
+        t_start = getattr(driver, "_t_start", None)
+        self._t_start = 0.0 if t_start is None else float(t_start)
+
         dt = float(driver.dt)
         n_dec = max(4, math.ceil(-math.log10(dt))) if dt > 0 else 4
         bar_format = (
@@ -46,7 +57,7 @@ class TimeProgressBarCallback(AbstractCallback, mutable=True):
             leave=self._leave,
             bar_format=bar_format,
         )
-        self._pbar.update(float(driver.t))
+        self._pbar.update(_elapsed_time(driver, self._t_start, self._T_final))
         self._pbar.unpause()
         self._pbar.refresh()
 
@@ -57,16 +68,16 @@ class TimeProgressBarCallback(AbstractCallback, mutable=True):
             )
 
     def on_step_end(self, step, log_data, driver):
-        t = float(driver.t)
-        self._pbar.update(t - self._last_t)
-        self._last_t = t
+        self._pbar.update(
+            _elapsed_time(driver, self._t_start, self._T_final) - self._pbar.n
+        )
         self._pbar.refresh()
 
     def on_run_end(self, step, driver):
         if self._pbar is not None:
-            t = float(driver.t)
-            self._pbar.update(t - self._last_t)
-            self._last_t = t
+            self._pbar.update(
+                _elapsed_time(driver, self._t_start, self._T_final) - self._pbar.n
+            )
             self._pbar.close()
             self._pbar = None
 
@@ -80,7 +91,7 @@ class ProgressBarCallback(AbstractCallback, mutable=True):
     _leave: bool = struct.field(pytree_node=False, serialize=False)
 
     _n_steps: int = struct.field(pytree_node=False, serialize=False)
-    _last_step: int = struct.field(pytree_node=False, serialize=False)
+    _start_step: int = struct.field(pytree_node=False, serialize=False)
 
     _pbar: Any = struct.field(pytree_node=False, serialize=False)
 
@@ -90,7 +101,11 @@ class ProgressBarCallback(AbstractCallback, mutable=True):
         self._leave = leave
 
     def on_run_start(self, step, driver):
-        self._last_step = driver.step_count
+        # Count from the step the run started at, even if another callback
+        # changes the step count (e.g. when resuming from a checkpoint).
+        self._start_step = getattr(driver, "_start_step", None)
+        if self._start_step is None:
+            self._start_step = driver.step_count
 
         self._pbar = tqdm(
             total=self._n_steps,
@@ -98,7 +113,7 @@ class ProgressBarCallback(AbstractCallback, mutable=True):
             dynamic_ncols=True,
             leave=self._leave,
         )
-        self._pbar.update(driver.step_count - self._last_step)
+        self._pbar.update(driver.step_count - self._start_step)
         self._pbar.unpause()
         self._pbar.refresh()
 
@@ -110,12 +125,12 @@ class ProgressBarCallback(AbstractCallback, mutable=True):
             )
 
     def on_step_end(self, step, log_data, driver):
-        step_value = driver.step_count - self._last_step
+        step_value = driver.step_count - self._start_step
         self._pbar.update(step_value - self._pbar.n)
         self._pbar.refresh()
 
     def on_run_end(self, step, driver):
-        step_value = driver.step_count - self._last_step
+        step_value = driver.step_count - self._start_step
         if self._pbar is not None:
             self._pbar.update(step_value - self._pbar.n)
             self._pbar.refresh()

{netket-3.22.3 → netket-3.23.0}/netket/_src/callbacks/save_state.py

@@ -1,7 +1,10 @@
+import re
+
 from typing import Any
 from pathlib import Path
 
 import jax
+import jax.experimental.multihost_utils
 
 from netket.utils import struct, timing
 from netket.utils.optional_deps import import_optional_dependency
@@ -37,7 +40,7 @@ class SaveVariationalState(AbstractCallback, mutable=True):
         >>> driver.run(  # doctest: +SKIP
         ...     n_iter=50,
         ...     out="test",
-        ...     callback=nk.callbacks.SaveVariationalStateCallback(path="optimization", interval=10),
+        ...     callback=nk.logging.SaveVariationalState(path="optimization", interval=10),
         ... )
         >>> nqxpack.load("optimization/state_00010.nk")  # doctest: +SKIP
 
@@ -48,6 +51,9 @@ class SaveVariationalState(AbstractCallback, mutable=True):
     _file_name_root: str = struct.field(
         pytree_node=False, serialize=False, default="state"
     )
+    _max_to_keep: int | None = struct.field(
+        pytree_node=False, serialize=False, default=None
+    )
 
     def __init__(
         self,
@@ -55,6 +61,7 @@ class SaveVariationalState(AbstractCallback, mutable=True):
         interval: float | int,
         *,
         file_name_root: str = "state",
+        max_to_keep: int | None = None,
     ):
         r"""
         Constructs the callback to save the variational state at fixed intervals.
@@ -67,12 +74,15 @@ class SaveVariationalState(AbstractCallback, mutable=True):
             path (str | Path): The path where to save the variational state.
             interval (float | int, optional): The interval at which to save the variational state
             file_name_root (str, optional): The root of the file name to save the variational state. Defaults to "state".
+            max_to_keep (int | None, optional): If set, only the most recent ``max_to_keep`` saved states are
+                kept on disk; older ones are deleted after each save. Defaults to None (keep all).
         """
         if not isinstance(path, Path):
             path = Path(path)
         self._path = path
         self._interval = interval
         self._file_name_root = file_name_root
+        self._max_to_keep = max_to_keep
 
         if jax.process_index() == 0:
             self._path.mkdir(parents=True, exist_ok=True)
@@ -82,15 +92,35 @@ class SaveVariationalState(AbstractCallback, mutable=True):
             descr="to save the variational state with SaveVariationalStateCallback.",
         )
 
+    def _save(self, step, driver):
+        path = self._path / f"{self._file_name_root}_{step:05d}.nk"
+        _nqxpack_save(driver.state, path)
+
+        if self._max_to_keep is not None:
+            if jax.process_index() == 0:
+                pattern = re.compile(rf"^{re.escape(self._file_name_root)}_(\d+)\.nk$")
+                saved = sorted(
+                    (
+                        p
+                        for p in self._path.glob(f"{self._file_name_root}_*.nk")
+                        if pattern.match(p.name)
+                    ),
+                    key=lambda p: int(pattern.match(p.name).group(1)),
+                )
+                for old in saved[: -self._max_to_keep]:
+                    old.unlink()
+            # Barrier so that other processes do not race ahead (e.g. saving the
+            # next checkpoint) while rank 0 is still pruning the directory.
+            jax.experimental.multihost_utils.sync_global_devices(
+                "SaveVariationalState._save"
+            )
+
     def before_parameter_update(self, step, log_data, driver):
         if step % self._interval == 0:
-            path = self._path / f"{self._file_name_root}_{step:05d}.nk"
-            _nqxpack_save(driver.state, path)
+            self._save(step, driver)
 
     def on_run_end(self, step, driver):
-        if step % self._interval == 0:
-            path = self._path / f"{self._file_name_root}_{step:05d}.nk"
-            _nqxpack_save(driver.state, path)
+        self._save(step, driver)
 
 
 @timing.timed

{netket-3.22.3 → netket-3.23.0}/netket/_src/callbacks/stop_at_time.py

@@ -12,7 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from netket._src.callbacks.base import AbstractCallback, StopRun
+from netket._src.callbacks.base import (
+    AbstractCallback,
+    StopRun,
+    STOPPING_CALLBACK_ORDER,
+)
 from netket.utils import struct
 
 
@@ -30,6 +34,11 @@ class _StopAtTime(AbstractCallback):
     def __init__(self, T_final: float):
         self.T_final = T_final
 
+    @property
+    def callback_order(self) -> int:
+        # Run last, so raising StopRun never skips a later callback's collective.
+        return STOPPING_CALLBACK_ORDER
+
     def on_step_end(self, step, log_data, driver):
         if driver.t >= self.T_final:
             raise StopRun(f"Reached t={driver.t:.6g} >= T_final={self.T_final:.6g}")

{netket-3.22.3 → netket-3.23.0}/netket/_src/callbacks/timeout.py

@@ -16,7 +16,11 @@ import time
 
 from netket.utils import struct
 
-from netket._src.callbacks.base import AbstractCallback, StopRun
+from netket._src.callbacks.base import (
+    AbstractCallback,
+    StopRun,
+    STOPPING_CALLBACK_ORDER,
+)
 
 
 class Timeout(AbstractCallback, mutable=True):
@@ -47,11 +51,40 @@ class Timeout(AbstractCallback, mutable=True):
         self.timeout = timeout
         self._init_time = None
 
+    @property
+    def callback_order(self) -> int:
+        # Run last, so raising StopRun never skips a later callback's collective.
+        return STOPPING_CALLBACK_ORDER
+
     def on_run_start(self, step, driver):
         self._init_time = time.time()
 
     def on_step_end(self, step, log_data, driver):
-        if time.time() - self._init_time >= self.timeout:
+        elapsed = time.time() - self._init_time
+        # Wall clocks and per-process start instants differ across nodes, so the
+        # raw per-rank decision can disagree and (without this) stop the run on
+        # different steps. Take process 0's decision on every rank, so the whole
+        # run times out in lock-step on a single authoritative clock.
+        if _timed_out_on_master(elapsed >= self.timeout):
             raise StopRun(
                 f"Timeout: training stopped after {self.timeout:.1f} seconds."
             )
+
+
+def _timed_out_on_master(local_timed_out: bool) -> bool:
+    """Return process 0's timeout decision on every process.
+
+    A no-op returning ``local_timed_out`` unchanged in single-process runs.
+    """
+    import jax
+
+    if jax.process_count() == 1:
+        return local_timed_out
+
+    import numpy as np
+    from jax.experimental import multihost_utils
+
+    out = multihost_utils.broadcast_one_to_all(
+        np.asarray(int(local_timed_out), dtype=np.int32)
+    )
+    return bool(int(out))

{netket-3.22.3 → netket-3.23.0}/netket/_src/driver/abstract_dynamics_driver.py

@@ -166,8 +166,7 @@ class AbstractDynamicsDriver(AbstractDriver):
                 callbacks fire normally.
             out: Logger or iterable of loggers for output.
             obs: Observables to compute at each logging step.
-            max_steps: Safety cap on iterations when ``T_or_n`` is a float,
-                to prevent infinite loops if ``dt`` is zero.
+            n_iter: Number of iterations to perform. Mutually exclusive with ``T``.
             show_progress: Show a progress bar (default True).
             callback: User callbacks.
             timeit: If True, print timing information after the run.

{netket-3.22.3 → netket-3.23.0}/netket/_src/driver/abstract_optimization_driver.py

@@ -31,9 +31,10 @@ class AbstractOptimizationDriver(AbstractDriver):
     Adds an `optax <https://optax.readthedocs.io/en/latest/>`_ optimizer and
     implements :meth:`update_parameters` via :func:`apply_gradient`.
 
-    Subclass this when implementing a new optimization driver. The public
-    name :class:`AbstractVariationalDriver` is currently kept as a compatibility
-    alias for this class.
+    Subclass this when implementing a new optimization driver, following the
+    guidelines in :class:`~netket.driver.AbstractDriver` (including how to support
+    checkpointing). The public name :class:`AbstractVariationalDriver` is
+    currently kept as a compatibility alias for this class.
     """
 
     _optimizer: Optimizer = struct.field(pytree_node=False, serialize=False)