pyhgf: A neural network library for predictive coding.

Code ↔ Paper

4 matches between paragraphs of the paper and lines of its authors' code, computed by the harvester (lexical-v1). Click a colored paragraph or line to see its counterpart.

The 4 matches · 1 of them tie a paragraph to a whole file, not to given lines: a weak match, whose lines are not tinted

[1] § 2 Design and implementation › 2.2 Optimisation and inference ↔ dynamax/ssm.py, lines 37–89 · score 0.63 · gradient descent, state space, maximizing, easily, likelihood, smoothly
[2] § 2 Design and implementation › 2.1 Computational framework ↔ pyhgf/updates/posterior/continuous/posterior_update_mean_continuous_node.py, lines 10–94 · score 0.54 · field approximations, parent nodes, adjacent, prediction error, linear, child
[3] § 2 Design and implementation › 2.2 Optimisation and inference ↔ pyhgf/model/network.py, lines 80–149 · score 0.51 · HGF toolbox, NUTS, neural network, space, backend, optimisation
[4] § 2 Design and implementation › 2.1 Computational framework ↔ pyhgf/utils/beliefs_propagation.py, the whole file · a weak match · score 0.50 · belief propagation, Update sequences, posterior updates, roots, transformations, prediction errors

Paper

Loaded from Europe PMC by your browser, not stored by OSCR: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The paper is loaded by your browser, with JavaScript: read it at doi.org or on Europe PMC.

The authors' code

Python · 506 lines · 20 KB · MIT · 1 match

"""
Base classes for state space models (SSMs).
"""
import jax.numpy as jnp
import jax.random as jr
import optax
from abc import ABC
from abc import abstractmethod
from fastprogress.fastprogress import progress_bar
from functools import partial
from jax import jit, lax, vmap
from jax.tree_util import tree_map
from jaxtyping import Array, Float, Real
from numbers import Integral
from tensorflow_probability.substrates.jax import distributions as tfd
from typing import Optional, Union, Tuple, Any, runtime_checkable
from typing_extensions import Protocol
from dynamax.parameters import to_unconstrained, from_unconstrained
from dynamax.parameters import ParameterSet, PropertySet
from dynamax.types import PRNGKeyT, Scalar
from dynamax.utils.optimize import run_sgd
from dynamax.utils.utils import ensure_array_has_batch_dim
@runtime_checkable
class Posterior(Protocol):
"""A :class:`NamedTuple` with parameters stored as :class:`jax.DeviceArray` in the leaf nodes."""
pass
@runtime_checkable
class SuffStatsSSM(Protocol):
"""A :class:`NamedTuple` with sufficient statics stored as :class:`jax.DeviceArray` in the leaf nodes."""
pass
class SSM(ABC):
r"""A base class for state space models. Such models consist of parameters, which
we may learn, as well as hyperparameters, which specify static properties of the
model. This base class allows parameters to be indicated a standardized way
so that they can easily be converted to/from unconstrained form for optimization.
**Abstract Methods**
Models that inherit from `SSM` must implement a few key functions and properties:
* :meth:`initial_distribution` returns the distribution over the initial state given parameters
* :meth:`transition_distribution` returns the conditional distribution over the next state given the current state and parameters
* :meth:`emission_distribution` returns the conditional distribution over the emission given the current state and parameters
* :meth:`log_prior` (optional) returns the log prior probability of the parameters
* :attr:`emission_shape` returns a tuple specification of the emission shape
* :attr:`inputs_shape` returns a tuple specification of the input shape, or `None` if there are no inputs.
The shape properties are required for properly handling batches of data.
**Sampling and Computing Log Probabilities**
Once these have been implemented, subclasses will inherit the ability to sample
and compute log joint probabilities from the base class functions:
* :meth:`sample` draws samples of the states and emissions for given parameters
* :meth:`log_prob` computes the log joint probability of the states and emissions for given parameters
**Inference**
Many subclasses of SSMs expose basic functions for performing state inference.
* :meth:`marginal_log_prob` computes the marginal log probability of the emissions, summing over latent states
* :meth:`filter` computes the filtered posteriors
* :meth:`smoother` computes the smoothed posteriors
**Learning**
Likewise, many SSMs will support learning with expectation-maximization (EM) or stochastic gradient descent (SGD).
For expectation-maximization, subclasses must implement the E- and M-steps.
* :meth:`e_step` computes the expected sufficient statistics for a sequence of emissions, given parameters
* :meth:`m_step` finds new parameters that maximize the expected log joint probability
Once these are implemented, the generic SSM class allows to fit the model with EM
* :meth:`fit_em` run EM to find parameters that maximize the likelihood (or posterior) probability.
For SGD, any subclass that implements :meth:`marginal_log_prob` inherits the base class fitting function
* :meth:`fit_sgd` run SGD to minimize the *negative* marginal log probability.
"""
@abstractmethod
def initial_distribution(
self,
params: ParameterSet,
inputs: Optional[Float[Array, " input_dim"]]
) -> tfd.Distribution:
r"""Return an initial distribution over latent states.
Args:
params: model parameters $\theta$
inputs: optional inputs $u_t$
Returns:
distribution over initial latent state, $p(z_1 \mid \theta)$.
"""
raise NotImplementedError
@abstractmethod
def transition_distribution(
self,
params: ParameterSet,
state: Float[Array, " state_dim"],
inputs: Optional[Float[Array, " input_dim"]]
) -> tfd.Distribution:
r"""Return a distribution over next latent state given current state.
Args:
params: model parameters $\theta$
state: current latent state $z_t$
inputs: current inputs $u_t$
Returns:
conditional distribution of next latent state $p(z_{t+1} \mid z_t, u_t, \theta)$.
"""
raise NotImplementedError
@abstractmethod
def emission_distribution(
self,
params: ParameterSet,
state: Float[Array, " state_dim"],
inputs: Optional[Float[Array, " input_dim"]]=None
) -> tfd.Distribution:
r"""Return a distribution over emissions given current state.
Args:
params: model parameters $\theta$
state: current latent state $z_t$
inputs: current inputs $u_t$
Returns:
conditional distribution of current emission $p(y_t \mid z_t, u_t, \theta)$
"""
raise NotImplementedError
def log_prior(
self,
params: ParameterSet
) -> Scalar:
r"""Return the log prior probability of any model parameters.
Returns:
lp (Scalar): log prior probability.
"""
return 0.0
@property
@abstractmethod
def emission_shape(self) -> Tuple[int]:
r"""Return a pytree matching the pytree of tuples specifying the shape of a single time step's emissions.
For example, a `GaussianHMM` with $D$ dimensional emissions would return `(D,)`.
"""
raise NotImplementedError
@property
def inputs_shape(self) -> Optional[Tuple[int]]:
r"""Return a pytree matching the pytree of tuples specifying the shape of a single time step's inputs.
"""
return None
# All SSMs support sampling
def sample(
self,
params: ParameterSet,
key: PRNGKeyT,
num_timesteps: int,
inputs: Optional[Float[Array, "num_timesteps input_dim"]]=None
) -> Tuple[Float[Array, "num_timesteps state_dim"],
Float[Array, "num_timesteps emission_dim"]]:
r"""Sample states $z_{1:T}$ and emissions $y_{1:T}$ given parameters $\theta$ and (optionally) inputs $u_{1:T}$.
Args:
params: model parameters $\theta$
key: random number generator
num_timesteps: number of timesteps $T$
inputs: inputs $u_{1:T}$
Returns:
latent states and emissions
"""
def _step(prev_state, args):
"""Sample the next state and emission given the previous state and input."""
key, inpt = args
key1, key2 = jr.split(key, 2)
state = self.transition_distribution(params, prev_state, inpt).sample(seed=key2)
emission = self.emission_distribution(params, state, inpt).sample(seed=key1)
return state, (state, emission)
# Sample the initial state
key1, key2, key = jr.split(key, 3)
initial_input = tree_map(lambda x: x[0], inputs)
initial_state = self.initial_distribution(params, initial_input).sample(seed=key1)
initial_emission = self.emission_distribution(params, initial_state, initial_input).sample(seed=key2)
# Sample the remaining emissions and states
next_keys = jr.split(key, num_timesteps - 1)
next_inputs = tree_map(lambda x: x[1:], inputs)
_, (next_states, next_emissions) = lax.scan(_step, initial_state, (next_keys, next_inputs))
# Concatenate the initial state and emission with the following ones
expand_and_cat = lambda x0, x1T: jnp.concatenate((jnp.expand_dims(x0, 0), x1T))
states = tree_map(expand_and_cat, initial_state, next_states)
emissions = tree_map(expand_and_cat, initial_emission, next_emissions)
return states, emissions
def log_prob(
self,
params: ParameterSet,
states: Float[Array, "num_timesteps state_dim"],
emissions: Float[Array, "num_timesteps emission_dim"],
inputs: Optional[Float[Array, "num_timesteps input_dim"]]=None
) -> Scalar:
r"""Compute the log joint probability of the states and observations"""
def _step(carry, args):
"""Compute the log probability of the next time step."""
lp, prev_state = carry
state, emission, inpt = args
lp += self.transition_distribution(params, prev_state, inpt).log_prob(state)
lp += self.emission_distribution(params, state, inpt).log_prob(emission)
return (lp, state), None
# Compute log prob of initial time step
initial_state = tree_map(lambda x: x[0], states)
initial_emission = tree_map(lambda x: x[0], emissions)
initial_input = tree_map(lambda x: x[0], inputs)
lp = self.initial_distribution(params, initial_input).log_prob(initial_state)
lp += self.emission_distribution(params, initial_state, initial_input).log_prob(initial_emission)
# Scan over remaining time steps
next_states = tree_map(lambda x: x[1:], states)
next_emissions = tree_map(lambda x: x[1:], emissions)
next_inputs = tree_map(lambda x: x[1:], inputs)
(lp, _), _ = lax.scan(_step, (lp, initial_state), (next_states, next_emissions, next_inputs))
return lp
# Some SSMs will implement these inference functions.
def marginal_log_prob(
self,
params: ParameterSet,
emissions: Float[Array, "ntime emission_dim"],
inputs: Optional[Float[Array, "ntime input_dim"]]=None
) -> Scalar:
r"""Compute log marginal likelihood of observations, $\log \sum_{z_{1:T}} p(y_{1:T}, z_{1:T} \mid \theta)$.
Args:
params: model parameters $\theta$
state: current latent state $z_t$
inputs: current inputs $u_t$
Returns:
marginal log probability
"""
raise NotImplementedError
def filter(
self,
params: ParameterSet,
emissions: Float[Array, "ntime emission_dim"],
inputs: Optional[Float[Array, "ntime input_dim"]]=None
) -> Posterior:
r"""Compute filtering distributions, $p(z_t \mid y_{1:t}, u_{1:t}, \theta)$ for $t=1,\ldots,T$.
Args:
params: model parameters $\theta$
state: current latent state $z_t$
inputs: current inputs $u_t$
Returns:
filtering distributions
"""
raise NotImplementedError
def smoother(
self,
params: ParameterSet,
emissions: Float[Array, "ntime emission_dim"],
inputs: Optional[Float[Array, "ntime input_dim"]]=None
) -> Posterior:
r"""Compute smoothing distribution, $p(z_t \mid y_{1:T}, u_{1:T}, \theta)$ for $t=1,\ldots,T$.
Args:
params: model parameters $\theta$
state: current latent state $z_t$
inputs: current inputs $u_t$
Returns:
smoothing distributions
"""
raise NotImplementedError
# Learning algorithms
def e_step(
self,
params: ParameterSet,
emissions: Float[Array, "num_timesteps emission_dim"],
inputs: Optional[Float[Array, "num_timesteps input_dim"]]=None
) -> Tuple[SuffStatsSSM, Scalar]:
r"""Perform an E-step to compute expected sufficient statistics under the posterior, $p(z_{1:T} \mid y_{1:T}, u_{1:T}, \theta)$.
Args:
params: model parameters $\theta$
emissions: emissions $y_{1:T}$
inputs: optional inputs $u_{1:T}$
Returns:
Expected sufficient statistics under the posterior.
"""
raise NotImplementedError
def m_step(
self,
params: ParameterSet,
props: PropertySet,
batch_stats: SuffStatsSSM,
m_step_state: Any
) -> ParameterSet:
r"""Perform an M-step to find parameters that maximize the expected log joint probability.
Specifically, compute
$$\theta^\star = \mathrm{argmax}_\theta \; \mathbb{E}_{p(z_{1:T} \mid y_{1:T}, u_{1:T}, \theta)} \big[\log p(y_{1:T}, z_{1:T}, \theta \mid u_{1:T}) \big]$$
Args:
params: model parameters $\theta$
props: properties specifying which parameters should be learned
batch_stats: sufficient statistics from each sequence
m_step_state: any required state for optimizing the model parameters.
Returns:
new parameters
"""
raise NotImplementedError
def fit_em(
self,
params: ParameterSet,
props: PropertySet,
emissions: Union[Real[Array, "num_timesteps emission_dim"],
Real[Array, "num_batches num_timesteps emission_dim"]],
inputs: Optional[Union[Float[Array, "num_timesteps input_dim"],
Float[Array, "num_batches num_timesteps input_dim"]]]=None,
num_iters: int=50,
verbose: bool=True,
print_every: int=1,
) -> Tuple[ParameterSet, Float[Array, " num_iters"]]:
r"""Compute parameter MLE/ MAP estimate using Expectation-Maximization (EM).
EM aims to find parameters that maximize the marginal log probability,
$$\theta^\star = \mathrm{argmax}_\theta \; \log p(y_{1:T}, \theta \mid u_{1:T})$$
It does so by iteratively forming a lower bound (the "E-step") and then maximizing it (the "M-step").
*Note:* ``emissions`` *and* ``inputs`` *can either be single sequences or batches of sequences.*
Args:
params: model parameters $\theta$. Parameters you supply yourself must have the
same shapes and dtypes that ``initialize`` produces.
props: properties specifying which parameters should be learned
emissions: one or more sequences of emissions
inputs: one or more sequences of corresponding inputs
num_iters: number of iterations of EM to run
verbose: whether or not to show a progress bar. Use ``False`` when calling
``fit_em`` inside ``jit`` or ``vmap``.
print_every: number of EM iterations between progress bar updates. Ignored when
``verbose=False``.
Returns:
tuple of new parameters and log likelihoods over the course of EM iterations.
"""
# Make sure the emissions and inputs have batch dimensions
batch_emissions = ensure_array_has_batch_dim(emissions, self.emission_shape)
batch_inputs = ensure_array_has_batch_dim(inputs, self.inputs_shape)
def em_step(carry, _):
"""Perform one EM step."""
params, m_step_state = carry
batch_stats, lls = vmap(partial(self.e_step, params))(batch_emissions, batch_inputs)
lp = self.log_prior(params) + lls.sum()
params, m_step_state = self.m_step(params, props, batch_stats, m_step_state)
return (params, m_step_state), lp
@partial(jit, static_argnums=1)
def run_em(carry, num_steps):
"""Run `num_steps` EM steps."""
return lax.scan(em_step, carry, xs=None, length=num_steps)
if num_iters <= 0:
return params, jnp.array([])
# The scan carries (params, m_step_state), so their structure, shapes and dtypes must
# not change between iterations; initialize() produces parameters that match the M-step.
carry = (params, self.initialize_m_step_state(params, props))
if not verbose:
(params, _), log_probs = run_em(carry, num_iters)
return params, log_probs
if not isinstance(print_every, Integral) or print_every < 1:
raise ValueError(f"print_every must be a positive integer, got {print_every!r}")
# Run `print_every` iterations per dispatch and update the bar in between. The bar counts
# dispatched blocks without waiting for the device, so it can run ahead of the computation.
log_probs = []
pbar = progress_bar(range(num_iters))
pbar.update(0)
for start in range(0, num_iters, print_every):
num_steps = min(print_every, num_iters - start)
carry, chunk_log_probs = run_em(carry, num_steps)
log_probs.append(chunk_log_probs)
pbar.update(start + num_steps)
return carry[0], jnp.concatenate(log_probs)
def fit_sgd(
self,
params: ParameterSet,
props: PropertySet,
emissions: Union[Float[Array, "num_timesteps emission_dim"],
Float[Array, "num_batches num_timesteps emission_dim"]],
inputs: Optional[Union[Float[Array, "num_timesteps input_dim"],
Float[Array, "num_batches num_timesteps input_dim"]]]=None,
optimizer: optax.GradientTransformation=optax.adam(1e-3),
batch_size: int=1,
num_epochs: int=50,
shuffle: bool=False,
key: PRNGKeyT=jr.PRNGKey(0)
) -> Tuple[ParameterSet, Float[Array, " niter"]]:
r"""Compute parameter MLE/ MAP estimate using Stochastic Gradient Descent (SGD).
SGD aims to find parameters that maximize the marginal log probability,
$$\theta^\star = \mathrm{argmax}_\theta \; \log p(y_{1:T}, \theta \mid u_{1:T})$$
by minimizing the _negative_ of that quantity.
*Note:* ``emissions`` *and* ``inputs`` *can either be single sequences or batches of sequences.*
On each iteration, the algorithm grabs a *minibatch* of sequences and takes a gradient step.
One pass through the entire set of sequences is called an *epoch*.
Args:
params: model parameters $\theta$
props: properties specifying which parameters should be learned
emissions: one or more sequences of emissions
inputs: one or more sequences of corresponding inputs
optimizer: an `optax` optimizer for minimization
batch_size: number of sequences per minibatch
num_epochs: number of epochs of SGD to run
key: a random number generator for selecting minibatches
verbose: whether or not to show a progress bar
Returns:
tuple of new parameters and losses (negative scaled marginal log probs) over the course of SGD iterations.
"""
# Make sure the emissions and inputs have batch dimensions
batch_emissions = ensure_array_has_batch_dim(emissions, self.emission_shape)
batch_inputs = ensure_array_has_batch_dim(inputs, self.inputs_shape)
unc_params = to_unconstrained(params, props)
def _loss_fn(unc_params, minibatch):
"""Default objective function."""
params = from_unconstrained(unc_params, props)
minibatch_emissions, minibatch_inputs = minibatch
scale = len(batch_emissions) / len(minibatch_emissions)
minibatch_lls = vmap(partial(self.marginal_log_prob, params))(minibatch_emissions, minibatch_inputs)
lp = self.log_prior(params) + minibatch_lls.sum() * scale
return -lp / batch_emissions.size
dataset = (batch_emissions, batch_inputs)
unc_params, losses = run_sgd(_loss_fn,
unc_params,
dataset,
optimizer=optimizer,
batch_size=batch_size,
num_epochs=num_epochs,
shuffle=shuffle,
key=key)
params = from_unconstrained(unc_params, props)
return params, losses

ssm.py at commit b58635f, under MIT · at the source

Overview

Authors: Nicolas Legrand¹, Lilian Weber², Peter Thestrup Waade¹, Anna Hedvig Møller Daugaard¹, Mojtaba Khodadadi³, Nace Mikuš¹, Christoph Mathys¹

ORCID iDs: Nicolas Legrand, Lilian Weber, Christoph Mathys

Institutions: Aarhus University (Denmark); University of Oxford (United Kingdom); Scuola Internazionale Superiore di Studi Avanzati (Italy)

Journal: PLoS computational biology, volume 22, issue 6, article e1014340

Dates: received 1 September 2025; accepted 18 May 2026; published online 22 June 2026

Type: Research article · Language: English

License: CC BY

Identifiers: DOI 10.1371/journal.pcbi.1014340 · PMID 42330057 · PMCID PMC13318038 · OpenAlex W4403564456

Open access: gold, a free copy (OpenAlex)

Preprint: arxiv:2410.09206

Status: code verified

Categories: human (organism)

Methods: Graphs, Machine learning

MeSH: Neural Networks, Computer*, Algorithms, Bayes Theorem, Cognition, Computational Biology, Humans, Models, Neurological, Software (* major topic)

Journal subjects: Software, Biology and Life Sciences, Computational Biology, Computational Neuroscience, Coding Mechanisms, Neuroscience, Computer and Information Sciences, Neural Networks, Artificial Intelligence, Artificial Neural Networks, Cognitive Science, Cognitive Psychology, Learning, Psychology, Social Sciences, Learning and Memory, Physical Sciences, Mathematics, Optimization, Data Management, Data Visualization, Infographics, Graphs, Machine Learning, Behavior

Topic: Neural Networks and Applications (Artificial Intelligence, Computer Science), according to OpenAlex

Funding: Aarhus Universitets Forskningsfond (AUFF-E-2019-7-10); Carlsbergfondet (Carlsberg Foundation) (CF21-0439)

Citations: cited by 1 paper (Europe PMC); 61 references in the paper

Abstract

Bayesian models of cognition have gained considerable traction in computational neuroscience and psychiatry. Their scope is now expected to expand rapidly to artificial intelligence, providing general inference frameworks to support embodied, adaptable, and energy-efficient autonomous agents. A central theory in this domain is predictive coding, which posits that learning and behaviour are driven by hierarchical probabilistic inferences about the causes of sensory inputs. Biological realism constrains these networks to rely on simple local computations in the form of precision-weighted predictions and prediction errors. This can make this framework highly efficient, but its implementation comes with unique challenges on the software development side. Embedding such models in standard neural network libraries often becomes limiting, as these libraries’ compilation and differentiation backends can force a conceptual separation between optimisation algorithms and the systems being optimised. This critically departs from other biological principles such as self-monitoring, self-organisation, cellular growth, and functional plasticity. In this paper, we introduce pyhgf: a Python package backed by JAX and Rust for creating, manipulating, and sampling dynamic networks for predictive coding. We improve over other frameworks by enclosing the network components as transparent, modular, and malleable variables in the message-passing steps. The resulting graphs can implement arbitrary algorithms as belief propagation. Moreover, the transparency of core variables can also translate into inference processes that leverage self-organisation principles and express structure learning, meta-learning, or causal discovery as the consequence of network structural adaptation to surprising inputs. The main functions of the library are differentiable and seamlessly integrate into sampling or optimisation workflows. Additionally, we offer generalised Bayesian filtering and the hierarchical Gaussian filter as key examples of dynamic networks implemented in our library. The source code, tutorials, and documentation are hosted under the main repository at https://github.com/ComputationalPsychiatry/pyhgf.

Reproduced under the paper's license (CC BY), from the paper cited above.

Repositories

Its files are read in the Code ↔ Paper reader above, with 4 matches between paragraphs and lines of code.

ComputationalPsychiatry/pyhgf

License: MIT

State: the link answers, verified on 27 September 2026

Evidence: files inventoried

Commit: 2b4bf6772f990b0595a63b8fc740d07cbfe71e44, 25 September 2026

Languages: Python (126), Rust (44), Jupyter (25)

Size: 257 files, 195 scripts

Software Heritage: archived

Found in: “Data Availability”

Holds: README, license file, environment (pyproject.toml, uv.lock), tests, continuous integration, documentation, 25 notebooks

Not found: CITATION.cff

Tools: JAX (91 files), NumPy (47 files), Matplotlib (36 files), seaborn (19 files), PyMC (10 files), ArviZ (9 files), pandas (9 files), SciPy (3 files), NetworkX (1 file), xarray (1 file)

Availability: 1 check, the latest on 27 September 2026: the link answers

27 September 2026: the link answers

197 files

build.rs, Rust, 6 lines
docs/paper.ipynb, Jupyter, 715 lines
docs/readme.ipynb, Jupyter, 38 lines
docs/source/conf.py, Python, 150 lines
docs/source/notebooks/0.1-Theory.ipynb, Jupyter, 391 lines
docs/source/notebooks/0.2-Creating_networks.ipynb, Jupyter, 445 lines
docs/source/notebooks/0.3-Generalised_filtering.ipynb, Jupyter, 509 lines
docs/source/notebooks/0.4-Planning_and_acting.ipynb, Jupyter, 217 lines
docs/source/notebooks/0.5-Deep_networks_theory.ipynb, Jupyter, 400 lines
docs/source/notebooks/0.6-Prospective_configuration.ipynb, Jupyter, 875 lines
docs/source/notebooks/0.7-Deep_networks_implementation.ipynb, Jupyter, 192 lines
docs/source/notebooks/0.8-Convolutional_networks.ipynb, Jupyter, 504 lines
docs/source/notebooks/0.9-Transformers.ipynb, Jupyter, 526 lines
docs/source/notebooks/1.1-Binary_HGF.ipynb, Jupyter, 305 lines
docs/source/notebooks/1.2-Categorical_HGF.ipynb, Jupyter, 269 lines
docs/source/notebooks/1.3-Continuous_HGF.ipynb, Jupyter, 406 lines
docs/source/notebooks/2-Using_custom_response_functions.ipynb, Jupyter, 262 lines
docs/source/notebooks/3-Multilevel_HGF.ipynb, Jupyter, 297 lines
docs/source/notebooks/4-Parameter_recovery.ipynb, Jupyter, 200 lines
docs/source/notebooks/5-Non_linear_value_coupling.ipynb, Jupyter, 357 lines
docs/source/notebooks/Example_1_Heart_rate_variability.ipynb, Jupyter, 119 lines
docs/source/notebooks/Example_2_Input_node_volatility_coupling.ipynb, Jupyter, 128 lines
docs/source/notebooks/Example_3_Multi_armed_bandit.ipynb, Jupyter, 461 lines
docs/source/notebooks/Example_4_Causal_discovery.ipynb, Jupyter, 485 lines
docs/source/notebooks/Example_5_Iowa_Gambling_Task.ipynb, Jupyter, 741 lines
docs/source/notebooks/Exercise_1_Introduction_to_the_generalised_hierarchical_gaussian_filter.ipynb, Jupyter, 373 lines
docs/source/notebooks/Exercise_2_Bayesian_reinforcement_learning.ipynb, Jupyter, 607 lines
pyhgf/__init__.py, Python, 179 lines
pyhgf/distribution.py, Python, 66 lines
pyhgf/math.py, Python, 498 lines
pyhgf/model/__init__.py, Python, 87 lines
pyhgf/model/add_nodes.py, Python, 720 lines
pyhgf/model/builder.py, Python, 173 lines
pyhgf/model/conv.py, Python, 476 lines
pyhgf/model/deep_network.py, Python, 2,068 lines
pyhgf/model/error_types.py, Python, 186 lines
pyhgf/model/fused.py, Python, 591 lines
pyhgf/model/hgf.py, Python, 30 lines
pyhgf/model/hybrid.py, Python, 407 lines
pyhgf/model/network.py, Python, 774 lines, 1 match
pyhgf/model/transformer.py, Python, 312 lines
pyhgf/model/transplant.py, Python, 333 lines
pyhgf/plots/__init__.py, Python, 1 line
pyhgf/plots/graphviz/__init__.py, Python, 10 lines
pyhgf/plots/graphviz/plot_network.py, Python, 223 lines
pyhgf/plots/matplotlib/__init__.py, Python, 13 lines
pyhgf/plots/matplotlib/plot_correlations.py, Python, 57 lines
pyhgf/plots/matplotlib/plot_layers.py, Python, 228 lines
pyhgf/plots/matplotlib/plot_nodes.py, Python, 285 lines
pyhgf/plots/matplotlib/plot_samples.py, Python, 87 lines
pyhgf/plots/matplotlib/plot_trajectories.py, Python, 175 lines
pyhgf/plots/networkx/__init__.py, Python, 5 lines
pyhgf/plots/networkx/plot_network.py, Python, 202 lines
pyhgf/response.py, Python, 215 lines
pyhgf/typing/__init__.py, Python, 47 lines
pyhgf/typing/typing.py, Python, 91 lines
pyhgf/typing/vectorised.py, Python, 542 lines
pyhgf/updates/__init__.py, Python, 1 line
pyhgf/updates/observation.py, Python, 38 lines
pyhgf/updates/posterior/__init__.py, Python, 1 line
pyhgf/updates/posterior/categorical.py, Python, 87 lines
pyhgf/updates/posterior/continuous/__init__.py, Python, 19 lines
pyhgf/updates/posterior/continuous/continuous_node_posterior_update.py, Python, 128 lines
pyhgf/updates/posterior/continuous/continuous_node_posterior_update_ehgf.py, Python, 155 lines
pyhgf/updates/posterior/continuous/continuous_node_posterior_update_unbounded.py, Python, 220 lines
pyhgf/updates/posterior/continuous/posterior_update_mean_continuous_node.py, Python, 359 lines, 1 match
pyhgf/updates/posterior/continuous/posterior_update_precision_continuous_node.py, Python, 769 lines
pyhgf/updates/posterior/exponential.py, Python, 81 lines
pyhgf/updates/prediction/__init__.py, Python, 1 line
pyhgf/updates/prediction/binary.py, Python, 93 lines
pyhgf/updates/prediction/continuous.py, Python, 570 lines
pyhgf/updates/prediction/dirichlet.py, Python, 52 lines
pyhgf/updates/prediction_error/__init__.py, Python, 1 line
pyhgf/updates/prediction_error/binary.py, Python, 106 lines
pyhgf/updates/prediction_error/categorical.py, Python, 47 lines
pyhgf/updates/prediction_error/continuous.py, Python, 176 lines
pyhgf/updates/prediction_error/dirichlet.py, Python, 393 lines
pyhgf/updates/prediction_error/exponential.py, Python, 120 lines
pyhgf/updates/vectorised/__init__.py, Python, 1 line
pyhgf/updates/vectorised/binary/__init__.py, Python, 12 lines
pyhgf/updates/vectorised/binary/prediction.py, Python, 99 lines
pyhgf/updates/vectorised/binary/prediction_error.py, Python, 51 lines
pyhgf/updates/vectorised/categorical/__init__.py, Python, 11 lines
pyhgf/updates/vectorised/categorical/prediction.py, Python, 83 lines
pyhgf/updates/vectorised/categorical/prediction_error.py, Python, 44 lines
pyhgf/updates/vectorised/continuous/__init__.py, Python, 38 lines
pyhgf/updates/vectorised/continuous/posterior.py, Python, 657 lines
pyhgf/updates/vectorised/continuous/prediction.py, Python, 192 lines
pyhgf/updates/vectorised/continuous/prediction_error.py, Python, 95 lines
pyhgf/updates/vectorised/learning.py, Python, 566 lines
pyhgf/updates/vectorised/volatile/__init__.py, Python, 37 lines
pyhgf/updates/vectorised/volatile/posterior.py, Python, 325 lines
pyhgf/updates/vectorised/volatile/prediction.py, Python, 413 lines
pyhgf/updates/vectorised/volatile/prediction_error.py, Python, 503 lines
pyhgf/utils/__init__.py, Python, 26 lines
pyhgf/utils/add_edges.py, Python, 176 lines
pyhgf/utils/add_parent.py, Python, 78 lines
pyhgf/utils/beliefs_propagation.py, Python, 159 lines, 1 match
pyhgf/utils/fill_categorical_state_node.py, Python, 81 lines
pyhgf/utils/get_input_idxs.py, Python, 22 lines
pyhgf/utils/get_update_sequence.py, Python, 317 lines
pyhgf/utils/list_branches.py, Python, 55 lines
pyhgf/utils/remove_node.py, Python, 265 lines
pyhgf/utils/sample.py, Python, 116 lines
pyhgf/utils/sample_node_distribution.py, Python, 42 lines
pyhgf/utils/to_pandas.py, Python, 114 lines
pyhgf/utils/vectorised_belief_propagation.py, Python, 2,035 lines
pyhgf/utils/weight_initialisation.py, Python, 214 lines
src/lib.rs, Rust, 23 lines
src/math.rs, Rust, 735 lines
src/model/deep_network.rs, Rust, 795 lines
src/model/mod.rs, Rust, 5 lines
src/model/network.rs, Rust, 918 lines
src/optimiser.rs, Rust, 105 lines
src/updates/mod.rs, Rust, 6 lines
src/updates/nodalised/mod.rs, Rust, 4 lines
src/updates/nodalised/observations.rs, Rust, 13 lines
src/updates/nodalised/posterior/continuous.rs, Rust, 652 lines
src/updates/nodalised/posterior/mod.rs, Rust, 1 line
src/updates/nodalised/prediction/binary.rs, Rust, 26 lines
src/updates/nodalised/prediction/continuous.rs, Rust, 243 lines
src/updates/nodalised/prediction/mod.rs, Rust, 2 lines
src/updates/nodalised/prediction_error/binary.rs, Rust, 15 lines
src/updates/nodalised/prediction_error/continuous.rs, Rust, 33 lines
src/updates/nodalised/prediction_error/exponential.rs, Rust, 18 lines
src/updates/nodalised/prediction_error/mod.rs, Rust, 3 lines
src/updates/vectorised/binary/mod.rs, Rust, 5 lines
src/updates/vectorised/binary/prediction.rs, Rust, 38 lines
src/updates/vectorised/binary/prediction_error.rs, Rust, 14 lines
src/updates/vectorised/categorical/mod.rs, Rust, 5 lines
src/updates/vectorised/categorical/prediction.rs, Rust, 35 lines
src/updates/vectorised/categorical/prediction_error.rs, Rust, 14 lines
src/updates/vectorised/learning.rs, Rust, 136 lines
src/updates/vectorised/mod.rs, Rust, 42 lines
src/updates/vectorised/volatile/mod.rs, Rust, 30 lines
src/updates/vectorised/volatile/posterior.rs, Rust, 135 lines
src/updates/vectorised/volatile/prediction.rs, Rust, 353 lines
src/updates/vectorised/volatile/prediction_error.rs, Rust, 397 lines
src/utils/beliefs_propagation.rs, Rust, 30 lines
src/utils/function_pointer.rs, Rust, 99 lines
src/utils/mod.rs, Rust, 4 lines
src/utils/set_sequence.rs, Rust, 242 lines
src/utils/weight_initialisation.rs, Rust, 294 lines
src/vectorised/batched.rs, Rust, 824 lines
src/vectorised/layer.rs, Rust, 749 lines
src/vectorised/mat.rs, Rust, 60 lines
src/vectorised/mod.rs, Rust, 12 lines
src/vectorised/network.rs, Rust, 1,237 lines
src/vectorised/optimiser.rs, Rust, 283 lines
tests/conftest.py, Python, 8 lines
tests/test_binary.py, Python, 124 lines
tests/test_binary.rs, Rust, 252 lines
tests/test_builder.py, Python, 376 lines
tests/test_categorical.py, Python, 86 lines
tests/test_continuous.py, Python, 172 lines
tests/test_continuous.rs, Rust, 133 lines
tests/test_conv.py, Python, 609 lines
tests/test_deepnetwork.py, Python, 1,759 lines
tests/test_distribution.py, Python, 13 lines
tests/test_eqx_types.py, Python, 703 lines
tests/test_error_types.py, Python, 276 lines
tests/test_fused.py, Python, 277 lines
tests/test_hybrid.py, Python, 205 lines
tests/test_math.py, Python, 106 lines
tests/test_model.py, Python, 360 lines
tests/test_nodes/__init__.py, Python, 1 line
tests/test_nodes/test_binary.py, Python, 150 lines
tests/test_nodes/test_continuous.py, Python, 114 lines
tests/test_nodes/test_exponential_family.py, Python, 94 lines
tests/test_pcmodule_state.py, Python, 247 lines
tests/test_plots/__init__.py, Python, 1 line
tests/test_plots/conftest.py, Python, 225 lines
tests/test_plots/test_plot_correlations.py, Python, 29 lines
tests/test_plots/test_plot_deep_network.py, Python, 9 lines
tests/test_plots/test_plot_layers.py, Python, 177 lines
tests/test_plots/test_plot_network.py, Python, 36 lines
tests/test_plots/test_plot_nodes.py, Python, 29 lines
tests/test_plots/test_plot_samples.py, Python, 31 lines
tests/test_plots/test_plot_trajectories.py, Python, 29 lines
tests/test_responses.py, Python, 50 lines
tests/test_rs_deepnetwork.py, Python, 671 lines
tests/test_transformer.py, Python, 737 lines
tests/test_transplant.py, Python, 172 lines
tests/test_updates/__init__.py, Python, 1 line
tests/test_updates/posterior/__init__.py, Python, 1 line
tests/test_updates/posterior/test_posterior_update_continuous.py, Python, 99 lines
tests/test_updates/prediction/__init__.py, Python, 1 line
tests/test_updates/prediction/test_autoconnection_strength.py, Python, 205 lines
tests/test_updates/prediction_errors/__init__.py, Python, 1 line
tests/test_updates/prediction_errors/test_dirichlet.py, Python, 54 lines
tests/test_utils.py, Python, 262 lines
tests/test_vectorised_continuous.py, Python, 705 lines
tests/test_weight_belief.py, Python, 733 lines
tests/test_weight_gradient.py, Python, 69 lines
tests/test_xla_runtime.py, Python, 126 lines
LICENSE, License, 11 lines
README.md, Text, 210 lines

At the source: github.com/ComputationalPsychiatry/pyhgf

probml/dynamax

License: MIT

State: the link answers, verified on 27 September 2026

Evidence: files inventoried

Commit: b58635f7bca2d8f936c0d711df3a1ad45f64511c, 16 September 2026

Languages: Python (72), Jupyter (30)

Size: 143 files, 102 scripts

Software Heritage: archived

Found in: the text, “2.2 Optimisation and inference”

Holds: README, license file, CITATION.cff, environment (pyproject.toml, setup.py), tests, continuous integration, documentation, 30 notebooks

Tools: JAX (84 files), Matplotlib (33 files), scikit-learn (10 files), NumPy (7 files), seaborn (6 files), SciPy (3 files)

Availability: 1 check, the latest on 27 September 2026: the link answers

27 September 2026: the link answers

104 files

docs/conf.py, Python, 105 lines
docs/notebooks/generalized_gaussian_ssm/cmgf_logistic_regression_demo.ipynb, Jupyter, 411 lines
docs/notebooks/generalized_gaussian_ssm/cmgf_mlp_classification_demo.ipynb, Jupyter, 265 lines
docs/notebooks/generalized_gaussian_ssm/cmgf_poisson_demo.ipynb, Jupyter, 169 lines
docs/notebooks/hmm/autoregressive_hmm.ipynb, Jupyter, 327 lines
docs/notebooks/hmm/casino_hmm_inference.ipynb, Jupyter, 259 lines
docs/notebooks/hmm/casino_hmm_learning.ipynb, Jupyter, 279 lines
docs/notebooks/hmm/custom_hmm.ipynb, Jupyter, 385 lines
docs/notebooks/hmm/gaussian_hmm.ipynb, Jupyter, 311 lines
docs/notebooks/linear_gaussian_ssm/kf_linreg.ipynb, Jupyter, 140 lines
docs/notebooks/linear_gaussian_ssm/kf_tracking.ipynb, Jupyter, 303 lines
docs/notebooks/linear_gaussian_ssm/lgssm_hmc.ipynb, Jupyter, 367 lines
docs/notebooks/linear_gaussian_ssm/lgssm_learning.ipynb, Jupyter, 286 lines
docs/notebooks/linear_gaussian_ssm/lgssm_parallel_inference.ipynb, Jupyter, 174 lines
docs/notebooks/nonlinear_gaussian_ssm/ekf_mlp.ipynb, Jupyter, 246 lines
docs/notebooks/nonlinear_gaussian_ssm/ekf_ukf_pendulum.ipynb, Jupyter, 287 lines
docs/notebooks/nonlinear_gaussian_ssm/ekf_ukf_spiral.ipynb, Jupyter, 204 lines
docs/notebooks/slds/rbpf_maneuver.ipynb, Jupyter, 216 lines
dynamax/__init__.py, Python, 12 lines
dynamax/_version.py, Python, 683 lines
dynamax/generalized_gaussian_ssm/__init__.py, Python, 4 lines
dynamax/generalized_gaussian_ssm/demos/__init__.py, Python, 1 line
dynamax/generalized_gaussian_ssm/demos/cmgf_logreg_estimator.py, Python, 75 lines
dynamax/generalized_gaussian_ssm/demos/cmgf_multiclass_logreg_demo.ipynb, Jupyter, 488 lines
dynamax/generalized_gaussian_ssm/demos/dirichlet_kalman-filter_demo.ipynb, Jupyter, 360 lines
dynamax/generalized_gaussian_ssm/inference.py, Python, 419 lines
dynamax/generalized_gaussian_ssm/inference_test.py, Python, 74 lines
dynamax/generalized_gaussian_ssm/models.py, Python, 134 lines
dynamax/generalized_gaussian_ssm/models_test.py, Python, 63 lines
dynamax/hidden_markov_model/__init__.py, Python, 27 lines
dynamax/hidden_markov_model/demos/bach_chorales_hmm.ipynb, Jupyter, 277 lines
dynamax/hidden_markov_model/demos/bernoulli_hmm_example.ipynb, Jupyter, 232 lines
dynamax/hidden_markov_model/demos/categorical_glm_hmm_demo.py, Python, 72 lines
dynamax/hidden_markov_model/demos/fixed_lag_smoother_hmm.ipynb, Jupyter, 278 lines
dynamax/hidden_markov_model/demos/low_rank_gaussian_hmm.ipynb, Jupyter, 171 lines
dynamax/hidden_markov_model/demos/multinomial_hmm.ipynb, Jupyter, 122 lines
dynamax/hidden_markov_model/demos/parallel_message_passing.ipynb, Jupyter, 211 lines
dynamax/hidden_markov_model/demos/poisson_hmm_changepoint.ipynb, Jupyter, 338 lines
dynamax/hidden_markov_model/demos/poisson_hmm_earthquakes.py, Python, 88 lines
dynamax/hidden_markov_model/demos/poisson_hmm_neurons.ipynb, Jupyter, 268 lines
dynamax/hidden_markov_model/demos/switching_linear_regression.ipynb, Jupyter, 143 lines
dynamax/hidden_markov_model/inference.py, Python, 659 lines
dynamax/hidden_markov_model/inference_test.py, Python, 368 lines
dynamax/hidden_markov_model/models/__init__.py, Python, 1 line
dynamax/hidden_markov_model/models/abstractions.py, Python, 684 lines
dynamax/hidden_markov_model/models/arhmm.py, Python, 254 lines
dynamax/hidden_markov_model/models/bernoulli_hmm.py, Python, 208 lines
dynamax/hidden_markov_model/models/categorical_glm_hmm.py, Python, 193 lines
dynamax/hidden_markov_model/models/categorical_hmm.py, Python, 188 lines
dynamax/hidden_markov_model/models/gamma_hmm.py, Python, 196 lines
dynamax/hidden_markov_model/models/gaussian_hmm.py, Python, 1,224 lines
dynamax/hidden_markov_model/models/gmm_hmm.py, Python, 614 lines
dynamax/hidden_markov_model/models/initial.py, Python, 101 lines
dynamax/hidden_markov_model/models/linreg_hmm.py, Python, 271 lines
dynamax/hidden_markov_model/models/logreg_hmm.py, Python, 216 lines
dynamax/hidden_markov_model/models/multinomial_hmm.py, Python, 207 lines
dynamax/hidden_markov_model/models/poisson_hmm.py, Python, 202 lines
dynamax/hidden_markov_model/models/test_models.py, Python, 246 lines
dynamax/hidden_markov_model/models/transitions.py, Python, 122 lines
dynamax/hidden_markov_model/parallel_inference.py, Python, 208 lines
dynamax/linear_gaussian_ssm/__init__.py, Python, 22 lines
dynamax/linear_gaussian_ssm/demos/__init__.py, Python, 1 line
dynamax/linear_gaussian_ssm/demos/lgssm_blocked_gibbs.ipynb, Jupyter, 93 lines
dynamax/linear_gaussian_ssm/inference.py, Python, 643 lines
dynamax/linear_gaussian_ssm/inference_test.py, Python, 212 lines
dynamax/linear_gaussian_ssm/info_inference.py, Python, 479 lines
dynamax/linear_gaussian_ssm/info_inference_test.py, Python, 182 lines
dynamax/linear_gaussian_ssm/models.py, Python, 750 lines
dynamax/linear_gaussian_ssm/models_test.py, Python, 103 lines
dynamax/linear_gaussian_ssm/parallel_inference.py, Python, 414 lines
dynamax/linear_gaussian_ssm/parallel_inference_test.py, Python, 331 lines
dynamax/nonlinear_gaussian_ssm/__init__.py, Python, 7 lines
dynamax/nonlinear_gaussian_ssm/inference_ekf.py, Python, 299 lines
dynamax/nonlinear_gaussian_ssm/inference_ekf_test.py, Python, 131 lines
dynamax/nonlinear_gaussian_ssm/inference_test_utils.py, Python, 188 lines
dynamax/nonlinear_gaussian_ssm/inference_ukf.py, Python, 318 lines
dynamax/nonlinear_gaussian_ssm/inference_ukf_test.py, Python, 36 lines
dynamax/nonlinear_gaussian_ssm/models.py, Python, 116 lines
dynamax/nonlinear_gaussian_ssm/sarkka_lib.py, Python, 222 lines
dynamax/parameters.py, Python, 165 lines
dynamax/parameters_test.py, Python, 166 lines
dynamax/slds/__init__.py, Python, 2 lines
dynamax/slds/inference.py, Python, 349 lines
dynamax/slds/inference_test.py, Python, 132 lines
dynamax/slds/mixture_kalman_filter_demo.py, Python, 171 lines
dynamax/slds/models.py, Python, 137 lines
dynamax/ssm.py, Python, 506 lines, 1 match
dynamax/ssm_test.py, Python, 192 lines
dynamax/types.py, Python, 11 lines
dynamax/utils/__init__.py, Python, 1 line
dynamax/utils/bijectors.py, Python, 41 lines
dynamax/utils/distributions.py, Python, 451 lines
dynamax/utils/distributions_test.py, Python, 238 lines
dynamax/utils/optimize.py, Python, 107 lines
dynamax/utils/plotting.py, Python, 156 lines
dynamax/utils/test_optimize.py, Python, 32 lines
dynamax/utils/utils.py, Python, 218 lines
dynamax/utils/utils_test.py, Python, 46 lines
dynamax/warnings.py, Python, 23 lines
logo/make_logo.ipynb, Jupyter, 166 lines
setup.py, Python, 9 lines
versioneer.py, Python, 2,277 lines
LICENSE, License, 21 lines
README.md, Text, 188 lines

At the source: github.com/probml/dynamax

The paper's code and data availability statement is in the Data section.

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

2 repositories of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
297 scripts, each with its path and the digest of its content;
4 matches between paragraphs of the paper and lines of the code (method lexical-v1);
neither the text of the paper nor the code itself.

Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.

Data

No dataset and no data link were found in the paper.

Data Availability

The source code and data used to produce the results and analyses presented in this manuscript are available from the main Git repository: https://github.com/ComputationalPsychiatry/pyhgf.

Reproduced under the paper's license (CC BY), from the paper cited above.

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 7 authors, 8 MeSH terms, 2 funders, 44 references.

Cite

This paper

Legrand, N., Weber, L., Waade, P. T., Møller Daugaard, A. H., Khodadadi, M., Mikuš, N., & Mathys, C. (2026). pyhgf: A neural network library for predictive coding. PLoS computational biology, 22(6), e1014340. https://doi.org/10.1371/journal.pcbi.1014340

BibTeX

@article{legrand2026pyhgf, author = {Legrand, Nicolas and Weber, Lilian and Waade, Peter Thestrup and Møller Daugaard, Anna Hedvig and Khodadadi, Mojtaba and Mikuš, Nace and Mathys, Christoph}, title = {{pyhgf: A neural network library for predictive coding}}, journal = {PLoS computational biology}, year = {2026}, month = jun, volume = {22}, number = {6}, pages = {e1014340}, publisher = {PLOS}, issn = {1553-734X}, doi = {10.1371/journal.pcbi.1014340}, url = {https://doi.org/10.1371/journal.pcbi.1014340}, pmid = {42330057}, pmcid = {PMC13318038} }

RIS

TY - JOUR AU - Legrand, Nicolas AU - Weber, Lilian AU - Waade, Peter Thestrup AU - Møller Daugaard, Anna Hedvig AU - Khodadadi, Mojtaba AU - Mikuš, Nace AU - Mathys, Christoph TI - pyhgf: A neural network library for predictive coding T2 - PLoS computational biology J2 - PLoS Comput Biol PY - 2026 DA - 2026/06/22 VL - 22 IS - 6 SP - e1014340 SN - 1553-734X PB - PLOS DO - 10.1371/journal.pcbi.1014340 UR - https://doi.org/10.1371/journal.pcbi.1014340 LA - en ER -

CSL-JSON

{ "id": "10.1371/journal.pcbi.1014340", "type": "article-journal", "title": "pyhgf: A neural network library for predictive coding", "container-title": "PLoS computational biology", "author": [ { "family": "Legrand", "given": "Nicolas" }, { "family": "Weber", "given": "Lilian" }, { "family": "Waade", "given": "Peter Thestrup" }, { "family": "Møller Daugaard", "given": "Anna Hedvig" }, { "family": "Khodadadi", "given": "Mojtaba" }, { "family": "Mikuš", "given": "Nace" }, { "family": "Mathys", "given": "Christoph" } ], "container-title-short": "PLoS Comput Biol", "volume": "22", "issue": "6", "page": "e1014340", "DOI": "10.1371/journal.pcbi.1014340", "PMID": "42330057", "PMCID": "PMC13318038", "ISSN": "1553-734X", "publisher": "PLOS", "URL": "https://doi.org/10.1371/journal.pcbi.1014340", "language": "en", "issued": { "date-parts": [ [ 2026, 6, 22 ] ] } }

The tracing map gets a citation of its own once an author has validated it and it has a DOI.

Contribute

The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.

Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.

Request its removal

To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).

Discussion, reproductions, activity

Discussion: questions and error reports about this paper and its code, from signed-in readers and its authors. It opens with sign-in.

Reproductions: reports from readers who ran the authors' code: what they reproduced, with which environment, commit and data. It opens with sign-in.

Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.