How to transfer the Hamiltonian into a neural network?

[usernamesjh]

(This is a question due to lack of experience)
I want to use NetKet to simulate a new model (with two additional terms similar to U, V, J, mu). I have already modified the base.py, jax.py, and numba.py in nk.operator.Bosehubbard so that the Hamiltonian matches the Hamiltonian of the model I need.


However, when we use the neural network to simulate this model, changing the two additional terms does not have an impact on the results （energy） of the neural network.

So I would like to ask where else I need to make modifications?

[PhilipVinc]

Sorry it's all very unclear.

It would be useful if you made an example that we can run

Also, in general you should. not need to modify netket's internal.
You can define a new operator type yourself (like BoseHubbard) without touching netket internals.
This makes it easier to share a reproducer.

[usernamesjh]

I'm terribly sorry to bother you again.
What I'd like to know is whether I only need to modify "nk.operator.BoseHubbard" when constructing a new model. And can I get the optimization result of the new model by passing the modified Hamiltonian into 'gs = nk.driver.VMC(hamiltonian, optimizer, variational_state=vstate, preconditioner=nk.optimizer.SR(diag_shift=0.1))'?
Or do I need to modify not only the content in "nk.operator.BoseHubbard" but also other parts?

[usernamesjh]

I'm terribly sorry that I didn't make this question clear. Next, I'll provide a simple piece of code.

import netket as nk
import jax.numpy as jnp

L = 2
lattice = nk.graph.Hypercube(length=L, n_dim=2, pbc=True)

N = lattice.n_nodes
n_max = 1
n_particles = 2
hilbert_space = nk.hilbert.Fock(n_max=n_max, N=N, n_particles=n_particles)
U = 0.0
V = 2
J = 1
t2 =6
t1 =0
mu = 0
hamiltonian = nk.operator.BoseHubbard(U=U, V=V, hilbert=hilbert_space, graph=lattice, J=J, t1=t1,t2=t2, mu=mu)
sa = nk.sampler.MetropolisLocal(hilbert_space)

In this code, I added new terms named t1, t2 to the Hamiltonian (I modified the content of _BoseHubbard so that this function can accept a new parameter).

sp_h=hamiltonian.to_sparse()
dense_matrix = sp_h.toarray()
print(dense_matrix)
from scipy.sparse.linalg import eigsh

eig_vals, eig_vecs = eigsh(sp_h, k=2, which="SA")

print("eigenvalues with scipy sparse:", eig_vals)
E_gs = eig_vals[0]

Next, I printed out the Hamiltonian matrix and solved its exact solution.

This Hamiltonian matrix matches the Hamiltonian that I defined.

optimizer = nk.optimizer.Sgd(learning_rate=0.01)

gs = nk.driver.VMC(hamiltonian, optimizer, variational_state=vstate,preconditioner=nk.optimizer.SR(diag_shift=0.1))

log=nk.logging.RuntimeLog()
gs.run(n_iter=1000,out=log)

ffn_energy=vstate.expect(hamiltonian)
error=abs((ffn_energy.mean-eig_vals[0])/eig_vals[0])
print("Optimized energy and relative error: ",ffn_energy,error)

I ran the optimization program to optimize VSTATE and output the final ground state energy. However, the ground state energy has nothing to do with t1 and t2 that I added. No matter what values I set for t1 and t2, the optimization result (energy) is the same as that when t1 = 0 and t2 = 0.

We can see that after I modify t2, the exact solution obtained by solving the Hamiltonian matrix will change, but the result of the neural network, FFN, will not change at all.

[usernamesjh]

I'm terribly sorry to bother you again.
What I'd like to know is whether I only need to modify "nk.operator.BoseHubbard" when constructing a new model. And can I get the optimization result of the new model by passing the modified Hamiltonian into 'gs = nk.driver.VMC(hamiltonian, optimizer, variational_state=vstate, preconditioner=nk.optimizer.SR(diag_shift=0.1))'?
Or do I need to modify not only the content in "nk.operator.BoseHubbard" but also other parts?

[PhilipVinc]

In general I'd advise against editing the inner workings of netket.

If you need to define your own operator, let's say SpecialBoseHubbard, simply create a new class, potentially, copy-pasting the code from the inside of netket as a starting point.

This makes it much easier to debug through your code, and share it if you have problems.
It's easier to share a python file, then an edited copy of netket.

NetKet is designed such that you can do practically everything by defining new classes like ours.

Also, for this particular case, you can also just use standard creation/destruction operators in nk.operator.boson.create/destroy/number to create an arbitrary hamiltonian without changing the insides of netket at all.
It might be slightly slower, but at least you're sure there are no bugs.

--

It's impossible to tell you why what is happening is happening without access to a clear reproducer.
Possible common errors are :

• your network might be real, so the wave function is positive, but your hamiltonian has a ground state that has a sign structure. So you must make your network complex.
• You have a huge diagonal shift. This will not give you a good solution. Try reducing learning rate and diagnosing shift and see if you go down in energy.
• You hit some eigenstate, or your wave function became very peaked and your autocorrelation time in the sampler is very high, so you have few effective samples.