def _setup_vmc(n_samples=200,
diag_shift=0,
use_iterative=False,
lsq_solver=None,
**kwargs):
L = 8
nk.random.seed(SEED)
hi = nk.hilbert.Spin(s=0.5)**L
ma = nk.machine.RbmSpin(hilbert=hi, alpha=1)
ma.init_random_parameters(sigma=0.01, seed=SEED)
ha = nk.operator.Ising(hi, nk.graph.Hypercube(length=L, n_dim=1), h=1.0)
sa = nk.sampler.MetropolisLocal(machine=ma)
op = nk.optimizer.Sgd(ma, learning_rate=0.1)
sr = nk.optimizer.SR(ma,
use_iterative=use_iterative,
diag_shift=diag_shift,
lsq_solver=lsq_solver)
vmc = nk.Vmc(ha, sa, op, n_samples=n_samples, **kwargs)
# Add custom observable
X = [[0, 1], [1, 0]]
sx = nk.operator.LocalOperator(hi, [X] * 8, [[i] for i in range(8)])
return ma, vmc, sx
def _vmc(n_iter=20):
nk.random.seed(SEED)
hi = nk.hilbert.Spin(s=0.5)**L
ma = nk.machine.RbmSpin(hilbert=hi, alpha=1)
ma.init_random_parameters(sigma=0.01, seed=SEED)
ha = nk.operator.Ising(hi, nk.graph.Hypercube(length=L, n_dim=1), h=1.0)
sa = nk.sampler.MetropolisLocal(machine=ma)
op = nk.optimizer.Sgd(ma, learning_rate=0.1)
return nk.Vmc(hamiltonian=ha, sampler=sa, optimizer=op, n_samples=500)
st = time.time()
vmc.run(n_iter, callback=callbacks)
runtime = time.time() - st
return vmc.step_count, runtime
def _setup_vmc(lsq_solver=None):
L = 4
g = nk.graph.Hypercube(length=L, n_dim=1)
hi = nk.hilbert.Spin(s=0.5, N=g.n_nodes)
ma = nk.machine.RbmSpin(hilbert=hi, alpha=1)
ma.init_random_parameters(sigma=0.01)
ha = nk.operator.Ising(hi, graph=g, h=1.0)
sa = nk.sampler.ExactSampler(machine=ma, sample_size=16)
op = nk.optimizer.Sgd(ma, learning_rate=0.05)
# Add custom observable
X = [[0, 1], [1, 0]]
sx = nk.operator.LocalOperator(hi, [X] * L, [[i] for i in range(8)])
sr = nk.optimizer.SR(ma, use_iterative=False, lsq_solver=lsq_solver)
driver = nk.Vmc(ha, sa, op, 1000, sr=sr)
return ha, sx, ma, sa, driver
g = nk.graph.Hypercube(length=8, n_dim=1, pbc=True)
# Boson Hilbert Space
hi = nk.hilbert.Boson(N=g.n_nodes, n_max=3, n_bosons=8)
# Bose Hubbard Hamiltonian
ha = nk.operator.BoseHubbard(hilbert=hi, graph=g, U=4.0)
# RBM Machine with one-hot encoding, real parameters, and symmetries
ma = nk.machine.RbmMultiVal(hilbert=hi, alpha=1, dtype=float, automorphisms=g)
ma.init_random_parameters(seed=1234, sigma=0.01)
# Sampler using Hamiltonian moves, thus preserving the total number of particles
sa = nk.sampler.MetropolisHamiltonian(machine=ma,
hamiltonian=ha,
batch_size=16)
# Stochastic gradient descent optimization
op = nk.optimizer.Sgd(ma, 0.05)
# Variational Monte Carlo
sr = nk.optimizer.SR(ma, diag_shift=0.1)
vmc = nk.Vmc(hamiltonian=ha,
sampler=sa,
optimizer=op,
n_samples=4000,
n_discard=0,
sr=sr)
vmc.run(n_iter=300, out="test")
# Hilbert space of spins on the graph
hi = nk.hilbert.Spin(s=1 / 2, N=g.n_nodes, total_sz=0)
ha = nk.operator.Ising(hilbert=hi, graph=g, h=1.0)
alpha = 1
ma = nk.machine.JaxRbm(hi, alpha, dtype=complex)
ma.init_random_parameters(seed=1232)
# Jax Sampler
sa = nk.sampler.MetropolisLocal(machine=ma, n_chains=2)
# Using Sgd
op = nk.optimizer.Sgd(ma, 0.05)
# Stochastic Reconfiguration
sr = nk.optimizer.SR(ma, diag_shift=0.1)
# Create the optimization driver
gs = nk.Vmc(hamiltonian=ha,
sampler=sa,
optimizer=op,
n_samples=1000,
sr=sr,
n_discard=2)
# The first iteration is slower because of start-up jit times
gs.run(out="test", n_iter=2)
gs.run(out="test", n_iter=300)
L = 20
g = nk.graph.Hypercube(length=L, n_dim=1, pbc=True)
# Hilbert space of spins on the graph
hi = nk.hilbert.Spin(s=1 / 2, N=g.n_nodes)
# Ising spin hamiltonian
ha = nk.operator.Ising(hilbert=hi, graph=g, h=1.0)
# RBM Spin Machine
ma = nk.nn.models.RBM(alpha=1)
# Metropolis Local Sampling
sa = nk.sampler.MetropolisLocal(hi, n_chains=32)
# Optimizer
op = nk.optim.GradientDescent(learning_rate=0.1)
# Create the optimization driver
vs = nk.variational_states.ClassicalVariationalState(ma,
sa,
n_samples=1000,
n_discard=100)
gs = nk.Vmc(ha, op, variational_state=vs)
# Run the optimization for 300 iterations
gs.run(n_iter=2, out=None)
gs.run(n_iter=300, out=None)
# Ising spin hamiltonian
ha = nk.operator.Ising(hilbert=hi, graph=g, h=1.0)
# RBM Spin Machine
ma = nk.machine.RbmSpinReal(alpha=1, hilbert=hi)
ma.init_random_parameters(seed=1234, sigma=0.01)
# Metropolis Local Sampling
sa = nk.sampler.MetropolisLocal(machine=ma)
# Optimizer
op = nk.optimizer.Sgd(learning_rate=0.1)
# Stochastic reconfiguration
gs = nk.Vmc(
hamiltonian=ha,
sampler=sa,
optimizer=op,
n_samples=1000,
sr=nk.optimizer.SR(ma, diag_shift=0.1),
)
# Adding an observable
# The sum of sigma_x on all sites
X = [[0, 1], [1, 0]]
sx = nk.operator.LocalOperator(hi, [X] * L, [[i] for i in range(L)])
obs = {"SigmaX": sx}
gs.run(n_iter=300, out="test", obs=obs)
# Hilbert space of spins on the graph
# with total Sz equal to 0
hi = nk.hilbert.Spin(s=1 / 2, N=g.n_nodes, total_sz=0)
# Heisenberg hamiltonian
ha = nk.operator.Heisenberg(hilbert=hi)
# Symmetric RBM Spin Machine
ma = nk.machine.JastrowSymm(hilbert=hi, automorphisms=g, dtype=float)
ma.init_random_parameters(seed=1234, sigma=0.01)
# Metropolis Exchange Sampling
# Notice that this sampler exchanges two neighboring sites
# thus preservers the total magnetization
sa = nk.sampler.MetropolisExchange(machine=ma)
# Optimizer
op = nk.optimizer.Sgd(ma, learning_rate=0.05)
# Stochastic reconfiguration
gs = nk.Vmc(
hamiltonian=ha,
sampler=sa,
optimizer=op,
n_samples=1000,
sr=nk.optimizer.SR(diag_shift=0.1, lsq_solver="QR"),
)
gs.run(out="test", n_iter=300)
# Spin based Hilbert Space
hi = nk.hilbert.Spin(s=0.5, total_sz=0.0, N=g.n_nodes)
# Custom Hamiltonian operator
ha = nk.operator.LocalOperator(hi)
for mat, site in zip(mats, sites):
ha += nk.operator.LocalOperator(hi, mat, site)
# Restricted Boltzmann Machine
ma = nk.machine.RbmSpin(hi, alpha=1, automorphisms=g)
ma.init_random_parameters(seed=1234, sigma=0.01)
# Exchange Sampler randomly exchange up to next-to-nearest neighbours
sa = nk.sampler.MetropolisExchange(machine=ma, n_chains=16, d_max=2)
# Optimizer
opt = nk.optimizer.Sgd(ma, learning_rate=0.02)
# Stochastic reconfiguration
sr = nk.optimizer.SR(ma, diag_shift=0.1)
# Variational Monte Carlo
gs = nk.Vmc(hamiltonian=op,
sampler=sa,
optimizer=opt,
sr=sr,
n_samples=4000,
n_discard=5)
vmc.run(n_iter=300, out="test")
hi = nk.hilbert.Spin(s=1 / 2, N=g.n_nodes)
# Ising spin hamiltonian
ha = nk.operator.Ising(hilbert=hi, graph=g, h=1.0)
input_size = hi.size
alpha = 1
model = torch.nn.Sequential(
torch.nn.Linear(input_size, alpha * input_size),
torch.nn.ReLU(),
torch.nn.Linear(alpha * input_size, 2),
torch.nn.ReLU(),
)
ma = nk.machine.Torch(model, hilbert=hi)
# Metropolis Local Sampling
sa = nk.sampler.MetropolisLocal(machine=ma, n_chains=8)
# Optimizer
op = nk.optimizer.Sgd(ma, learning_rate=0.1)
# Stochastic reconfiguration
sr = nk.optimizer.SR(ma, diag_shift=0.1, use_iterative=True)
# Driver
gs = nk.Vmc(hamiltonian=ha, sampler=sa, optimizer=op, n_samples=500, sr=sr)
gs.run(n_iter=300, out="test")
