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")