netket.vqs.MCMixedState#

class netket.vqs.MCMixedState#

Bases: netket.vqs.VariationalMixedState, netket.vqs.MCState

Variational State for a Mixed Variational Neural Quantum State.

The state is sampled according to the provided sampler, and it’s diagonal is sampled according to another sampler.

Inheritance
Inheritance diagram of netket.vqs.MCMixedState
__init__(sampler, model=None, *, sampler_diag=None, n_samples_diag=None, n_samples_per_rank_diag=None, n_discard_per_chain_diag=None, n_discard_diag=None, seed=None, sampler_seed=None, variables=None, **kwargs)[source]#

Constructs the MCMixedState. Arguments are the same as MCState.

Parameters
  • sampler – The sampler

  • model – (Optional) The model. If not provided, you must provide init_fun and apply_fun.

  • n_samples – the total number of samples across chains and processes when sampling (default=1000).

  • n_samples_per_rank – the total number of samples across chains on one process when sampling. Cannot be specified together with n_samples (default=None).

  • n_discard_per_chain – number of discarded samples at the beginning of each monte-carlo chain (default=n_samples/10).

  • n_samples_diag (Optional[int]) – the total number of samples across chains and processes when sampling the diagonal of the density matrix (default=1000).

  • n_samples_per_rank_diag (Optional[int]) – the total number of samples across chains on one process when sampling the diagonal. Cannot be specified together with n_samples_diag (default=None).

  • n_discard_per_chain_diag (Optional[int]) – number of discarded samples at the beginning of each monte-carlo chain used when sampling the diagonal of the density matrix for observables (default=n_samples_diag/10).

  • parameters – Optional PyTree of weights from which to start.

  • seed – rng seed used to generate a set of parameters (only if parameters is not passed). Defaults to a random one.

  • sampler_seed (Optional[int]) – rng seed used to initialise the sampler. Defaults to a random one.

  • mutable – Dict specifing mutable arguments. Use it to specify if the model has a state that can change during evaluation, but that should not be optimised. See also flax.linen.module.apply documentation (default=False)

  • init_fun – Function of the signature f(model, shape, rng_key, dtype) -> Optional_state, parameters used to initialise the parameters. Defaults to the standard flax initialiser. Only specify if your network has a non-standard init method.

  • apply_fun – Function of the signature f(model, variables, Οƒ) that should evaluate the model. Defafults to model.apply(variables, Οƒ). specify only if your network has a non-standard apply method.

  • training_kwargs – a dict containing the optionaal keyword arguments to be passed to the apply_fun during training. Useful for example when you have a batchnorm layer that constructs the average/mean only during training.

  • sampler_diag (Optional[netket.sampler.Sampler]) –

  • n_discard_diag (Optional[int]) –

Attributes
chain_length#

Length of the markov chain used for sampling configurations.

If running under MPI, the total samples will be n_nodes * chain_length * n_batches.

Return type

int

chain_length_diag#

Length of the markov chain used for sampling the diagonal configurations.

If running under MPI, the total samples will be n_nodes * chain_length * n_batches.

Return type

int

chunk_size#

Suggested maximum size of the chunks used in forward and backward evaluations of the Neural Network model. If your inputs are smaller than the chunk size this setting is ignored.

This can be used to lower the memory required to run a computation with a very high number of samples or on a very large lattice. Notice that inputs and outputs must still fit in memory, but the intermediate computations will now require less memory.

This option comes at an increased computational cost. While this cost should be negligible for large-enough chunk sizes, don’t use it unless you are memory bound!

This option is an hint: only some operations support chunking. If you perform an operation that is not implemented with chunking support, it will fall back to no chunking. To check if this happened, set the environment variable NETKET_DEBUG=1.

Return type

int

diagonal#
hilbert#

The descriptor of the Hilbert space on which this variational state is defined.

Return type

AbstractHilbert

hilbert_physical#
Return type

AbstractHilbert

model#

Returns the model definition of this variational state.

This field is optional, and is set to None if the variational state has been initialized using a custom function.

Return type

Optional[Any]

model_state: Optional[Any]#

The optional pytree with the mutable state of the model.

Return type

Optional[Any]

n_discard#

Use n_discard_per_chain instead.

Number of discarded samples at the beginning of the markov chain.

Type

DEPRECATED

Return type

int

n_discard_diag#

Use n_discard_per_chain_diag instead.

Number of discarded samples at the beginning of the markov chain.

Type

DEPRECATED

Return type

int

n_discard_per_chain#

Number of discarded samples at the beginning of the markov chain.

Return type

int

n_discard_per_chain_diag#

Number of discarded samples at the beginning of the markov chain used to sample the diagonal of this mixed state.

Return type

int

n_parameters#

The total number of parameters in the model.

Return type

int

n_samples#

The total number of samples generated at every sampling step.

Return type

int

n_samples_diag#

The total number of samples generated at every sampling step when sampling the diagonal of this mixed state.

Return type

int

n_samples_per_rank#

The number of samples generated on one MPI rank at every sampling step.

Return type

int

parameters#

The pytree of the parameters of the model.

Return type

Any

sampler#

The Monte Carlo sampler used by this Monte Carlo variational state.

Return type

Sampler

sampler_diag#

The Monte Carlo sampler used by this Monte Carlo variational state to sample the diagonal.

Return type

Sampler

samples#

Returns the set of cached samples.

The samples returnede are guaranteed valid for the current state of the variational state. If no cached parameters are available, then they are sampled first and then cached.

To obtain a new set of samples either use reset or sample.

Return type

ndarray

variables#

The PyTreee containing the paramters and state of the model, used when evaluating it.

Return type

Any

sampler_state: netket.sampler.SamplerState#
Methods
evaluate(Οƒ)#

DEPRECATED: use log_value instead.

Return type

ndarray

Parameters

Οƒ (jax._src.numpy.ndarray.ndarray) –

expect(Γ”)#
Estimates the quantum expectation value for a given operator O.

In the case of a pure state $psi$, this is $<O>= <Psi|O|Psi>/<Psi|Psi>$ otherwise for a mixed state $rho$, this is $<O> = Tr[rho hat{O}/Tr[rho]$.

Parameters
Return type

Stats

Returns

An estimation of the quantum expectation value <O>.

expect_and_grad(Γ”, *, mutable=None, use_covariance=None)#

Estimates both the gradient of the quantum expectation value of a given operator O.

Parameters
  • OΜ‚ – the operator OΜ‚ for which we compute the expectation value and it’s gradient

  • mutable (Optional[Any]) – Can be bool, str, or list. Specifies which collections in the model_state 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. This is used to mutate the state of the model while you train it (for example to implement BatchNorm. Consult Flax’s Module.apply documentation for a more in-depth exaplanation).

  • use_covariance (Optional[bool]) – whever to use the covariance formula, usually reserved for hermitian operators, βŸ¨βˆ‚logψ OΛ‘α΅’αΆœβŸ© - βŸ¨βˆ‚logψ⟩⟨OΛ‘α΅’αΆœβŸ©

  • Γ” (netket.operator.AbstractOperator) –

Return type

Tuple[Stats, Any]

Returns

An estimation of the quantum expectation value <O>. An estimation of the average gradient of the quantum expectation value <O>.

expect_and_grad_operator(Γ”, is_hermitian=None)[source]#
Return type

Tuple[Stats, Any]

Parameters

Γ” (netket.operator.AbstractOperator) –

grad(Γ”, *, use_covariance=None, mutable=None)#

Estimates the gradient of the quantum expectation value of a given operator O.

Parameters
Returns

An estimation of the average gradient of the quantum expectation value <O>.

Return type

array

init(seed=None, dtype=None)#

Initialises the variational parameters of the variational state.

init_parameters(init_fun=None, *, seed=None)#

Re-initializes all the parameters with the provided initialization function, defaulting to the normal distribution of standard deviation 0.01.

Warning

The init function will not change the dtype of the parameters, which is determined by the model. DO NOT SPECIFY IT INSIDE THE INIT FUNCTION

Parameters
  • init_fun (Optional[Callable[[Any, Sequence[int], Any], Union[ndarray, DeviceArray, Tracer]]]) – a jax initializer such as jax.nn.initializers.normal. Must be a Callable taking 3 inputs, the jax PRNG key, the shape and the dtype, and outputting an array with the valid dtype and shape. If left unspecified, defaults to jax.nn.initializers.normal(stddev=0.01)

  • seed (Optional[Any]) – Optional seed to be used. The seed is synced across all MPI processes. If unspecified, uses a random seed.

local_estimators(op, *, chunk_size=None)#

Compute the local estimators for the operator op (also known as local energies when op is the Hamiltonian) at the current configuration samples self.samples.

\[O_\mathrm{loc}(s) = \frac{\langle s | \mathtt{op} | \psi \rangle}{\langle s | \psi \rangle}\]

Warning

The samples differ between MPI processes, so returned the local estimators will also take different values on each process. To compute sample averages and similar quantities, you will need to perform explicit operations over all MPI ranks. (Use functions like self.expect to get process-independent quantities without manual reductions.)

Parameters
  • op (AbstractOperator) – The operator.

  • chunk_size (Optional[int]) – Suggested maximum size of the chunks used in forward and backward evaluations of the model. (Default: self.chunk_size)

log_value(Οƒ)#

Evaluate the variational state for a batch of states and returns the logarithm of the amplitude of the quantum state. For pure states, this is \(log(<Οƒ|ψ>)\), whereas for mixed states this is \(log(<Οƒr|ρ|Οƒc>)\), where ψ and ρ are respectively a pure state (wavefunction) and a mixed state (density matrix). For the density matrix, the left and right-acting states (row and column) are obtained as Οƒr=Οƒ[::,0:N] and Οƒc=Οƒ[::,N:].

Given a batch of inputs (Nb, N), returns a batch of outputs (Nb,).

Return type

ndarray

Parameters

Οƒ (jax._src.numpy.ndarray.ndarray) –

quantum_geometric_tensor(qgt_T=QGTAuto())#

Computes an estimate of the quantum geometric tensor G_ij. This function returns a linear operator that can be used to apply G_ij to a given vector or can be converted to a full matrix.

Parameters

qgt_T (LinearOperator) – the optional type of the quantum geometric tensor. By default it’s automatically selected.

Returns

A linear operator representing the quantum geometric tensor.

Return type

nk.optimizer.LinearOperator

reset()[source]#

Resets the internal cache of th variational state. Called automatically when the parameters/state is updated.

sample(*, chain_length=None, n_samples=None, n_discard_per_chain=None)#

Sample a certain number of configurations.

If one among chain_leength or n_samples is defined, that number of samples are gen erated. Otherwise the value set internally is used.

Parameters
  • chain_length (Optional[int]) – The length of the markov chains.

  • n_samples (Optional[int]) – The total number of samples across all MPI ranks.

  • n_discard_per_chain (Optional[int]) – Number of discarded samples at the beginning of the markov chain.

Return type

ndarray

to_array(normalize=True)#

Returns the dense-vector representation of this state.

Parameters

normalize (bool) – If True, the vector is normalized to have L2-norm 1.

Return type

ndarray

Returns

An exponentially large vector representing the state in the computational basis.

to_matrix(normalize=True)[source]#

Returns the dense-matrix representation of this operator.

Parameters

normalize (bool) – If True, the matrix is normalized to have trace 1.

Return type

ndarray

Returns

An exponentially large matrix representing the state in the computational basis.

to_qobj()#

Convert this mixed state to a qutip density matrix Qobj.

Returns

A qutip.Qobj object.