Difficulties in converging to the ground state in bosonic (small) Hilbert spaces

[Jachi9]

I am finding many difficulties in reaching the ground state of some small bosonic Fock Hilbert spaces.

For example, given the following

import netket as nk
from netket.operator.boson import (create as adag, destroy as a)
import jax
import jax.numpy as jnp
import numpy as np
from scipy.sparse import csc_matrix


Lambda = 3  # cutoff of each bosonic Fock space
n_modes = 4  # number of bosons 

hi = nk.hilbert.Fock(n_max=Lambda, N=n_modes) 

print(hi.n_states)

g_l = [0.2251464259241225,0.2865324064263467,0.2758321269750572,0.17774074279427035]
Delta = [0.3219281591738248,0.6071246636841553,0.824902105067684,0.956874237510626]

ham_mod = 0.0 
ham_l = 0.0

for i in range(0,n_modes):
    ham_mod += Delta[i]*adag(hi,i) * a(hi,i)  #freq modificare con un array 

for l in range (0,n_modes):
    ham_l += g_l[l] * (adag(hi,l)+ a(hi,l))

ham = ham_mod + ham_l 

eig_vals = nk.exact.lanczos_ed(
    ham, k=2, compute_eigenvectors=False)  # args to scipy.sparse.linalg.eighs like can be passed with scipy_args={'tol':1e-8}
print(f"Eigenvalues with exact lanczos (sparse): {eig_vals}")

E_gs = eig_vals[0]


import flax.linen as nn

sampler = nk.sampler.MetropolisLocal(hi)


modelRN = nk.models.ARNNConv1D(hi,layers=2,features=8,kernel_size = 2)
model = nk.models.Jastrow()


vstate = nk.vqs.MCState(sampler, model)


def cb_acc(step, logged_data, driver):
        logged_data["acceptance"] = float(driver.state.sampler_state.acceptance)
        return True

log=nk.logging.RuntimeLog()
logRN = nk.logging.RuntimeLog()


optimizer = nk.optimizer.Sgd(learning_rate=0.05)
gs = nk.driver.VMC(ham, optimizer, variational_state=vstate,preconditioner=nk.optimizer.SR(diag_shift = 0.001))
gs.run(n_iter=6000,out=log)

vstateRN = nk.vqs.MCState(sampler, modelRN)
optimizerRN = nk.optimizer.Sgd(learning_rate=0.05)
gs = nk.driver.VMC(ham, optimizerRN, variational_state=vstateRN,preconditioner=nk.optimizer.SR(diag_shift = 0.001))
gs.run(n_iter=6000,out=logRN)

#energy jastrow
ffn_energy=vstate.expect(ham)

error=abs((ffn_energy.mean-eig_vals[0])/eig_vals[0])
print("Optimized energy and relative error: ",ffn_energy,error)
print(f"relative error   : {error*100:.2f}%")

#energy ARNN
ffn_energyRN=vstateRN.expect(ham)

error=abs((ffn_energyRN.mean-eig_vals[0])/eig_vals[0])
print("Optimized energy and relative error: ",ffn_energyRN,error)
print(f"relative error   : {error*100:.2f}%")

Jastrow has some difficulties in reaching the ground state in this small Hilbert (hi.n_states = 256) with a good precision. I think this may be for a non-high enough expressivity of Jastrow.

I know also that RBM may have problems with non-conserved total number of particles and indeed RBM fails to converge with such system and it sticks to zero energy in the optimisation (while the ground state being roughly -0.4). I tried thus to implement an ARNN with 2 layers and 8 features but also with a different number of layers it seems to fail to converge and also here the energy optimisation converges to zero.

Jastrow seems thus the only ansatz which tends to converge to the ground state with such a system

Now my question is, how do we choose the right network to converge for this kind of system ?

[gcarleo]

In general, the Spin Rbm will not be a good ansatz because it is designed for +/- 1 inputs. For FFFN this is not the case, but still it is often better to map the integer configurations onto binary numbers, through (for example) One-hot encoding. This should already work better than what you are seeing now. For a more reliable solution for bosons... you will need to wait for a paper coming out in a month or so