class netket.models.NDM[source]#

Bases: flax.linen.module.Module

Encodes a Positive-Definite Neural Density Matrix using the ansatz from Torlai and Melko, PRL 120, 240503 (2018).

Assumes real dtype. A discussion on the effect of the feature density for the pure and mixed part is given in Vicentini et Al, PRL 122, 250503 (2019).

alpha: Union[float, int] = 1#

The feature density for the pure-part of the ansatz. Number of features equal to alpha * input.shape[-1]

beta: Union[float, int] = 1#

The feature density for the mixed-part of the ansatz. Number of features equal to beta * input.shape[-1]

precision: Any = None#

numerical precision of the computation see jax.lax.Precision for details.

use_ancilla_bias: bool = True#

if True uses a bias in the dense layer (hidden layer bias).

use_hidden_bias: bool = True#

if True uses a bias in the dense layer (hidden layer bias).

use_visible_bias: bool = True#

if True adds a bias to the input not passed through the nonlinear layer.


Returns the variables in this module.

Return type

Mapping[str, Mapping[str, Any]]


Logarithm of the hyperbolic cosine, implemented in a more stable way.

bias_init(shape, dtype=<class 'jax.numpy.float64'>)#
Return type



Returns true if a PRNGSequence with name name exists.

Return type



name (str) –


Returns True if running under self.init(…) or nn.init(…)().

This is a helper method to handle the common case of simple initialization where we wish to have setup logic occur when only called under module.init or nn.init. For more complicated multi-phase initialization scenarios it is better to test for the mutability of particular variable collections or for the presence of particular variables that potentially need to be initialized.

Return type


kernel_init(shape, dtype=<class 'jax.numpy.float64'>)#
Return type


put_variable(col, name, value)#

Sets the value of a Variable.

  • col (str) – the variable collection.

  • name (str) – the name of the variable.

  • value (Any) – the new value of the variable.


tabulate(rngs, *args, method=None, mutable=True, depth=None, exclude_methods=(), **kwargs)#

Creates a summary of the Module represented as a table.

This method has the same signature as init, but instead of returning the variables, it returns the string summarizing the Module in a table. tabulate uses jax.eval_shape to run the forward computation without consuming any FLOPs or allocating memory.


import jax
import jax.numpy as jnp
import flax.linen as nn

class Foo(nn.Module):
    def __call__(self, x):
        h = nn.Dense(4)(x)
        return nn.Dense(2)(h)

x = jnp.ones((16, 9))

print(Foo().tabulate(jax.random.PRNGKey(0), x))

This gives the following output:

                   Foo Summary
┃ path    ┃ outputs       ┃ params               ┃
β”‚ Inputs  β”‚ float32[16,9] β”‚                      β”‚
β”‚ Dense_0 β”‚ float32[16,4] β”‚ bias: float32[4]     β”‚
β”‚         β”‚               β”‚ kernel: float32[9,4] β”‚
β”‚         β”‚               β”‚                      β”‚
β”‚         β”‚               β”‚ 40 (160 B)           β”‚
β”‚ Dense_1 β”‚ float32[16,2] β”‚ bias: float32[2]     β”‚
β”‚         β”‚               β”‚ kernel: float32[4,2] β”‚
β”‚         β”‚               β”‚                      β”‚
β”‚         β”‚               β”‚ 10 (40 B)            β”‚
β”‚ Foo     β”‚ float32[16,2] β”‚                      β”‚
β”‚         β”‚         Total β”‚ 50 (200 B)           β”‚

          Total Parameters: 50 (200 B)

Note: rows order in the table does not represent execution order, instead it aligns with the order of keys in variables which are sorted alphabetically.

  • rngs (Union[Any, Dict[str, Any]]) – The rngs for the variable collections.

  • *args – The arguments to the forward computation.

  • method (Optional[Callable[..., Any]]) – An optional method. If provided, applies this method. If not provided, applies the __call__ method.

  • mutable (Union[bool, str, Collection[str], DenyList]) – Can be bool, str, or list. Specifies which collections should be treated as mutable: bool: all/no collections are mutable. str: The name of a single mutable collection. list: A list of names of mutable collections. By default all collections except β€˜intermediates’ are mutable.

  • depth (Optional[int]) – controls how many submodule deep the summary can go. By default its None which means no limit. If a submodule is not shown because of the depth limit, its parameter count and bytes will be added to the row of its first shown ancestor such that the sum of all rows always adds up to the total number of parameters of the Module.

  • exclude_methods (Sequence[str]) – A sequence of strings that specifies which methods should be ignored. In case a module calls a helper method from its main method, use this argument to exclude the helper method from the summary to avoid ambiguity.

  • **kwargs – keyword arguments to pass to the forward computation.

Return type



A string summarizing the Module.

visible_bias_init(shape, dtype=<class 'jax.numpy.float64'>)#
Return type