def test_ideal_harmonic_oscillator():
omega, N, D = 1, 5, 3
H = HarmonicOscillator(omega_ho=omega)
psi = SimpleGaussian(alpha=0.5 * omega)
sampler = ImportanceSampler(np.empty((N, D)), psi, 0.1)
sampler.thermalize(10000)
# Energy:
E = compute_statistics_for_series(H.local_energy_array(
sampler, psi, 2**10))
assert N * D * omega / 2 == E["mean"], "Energy should be exactly equal."
assert E["var"] < 1e-16
# Squared radius:
r2 = compute_statistics_for_series(H.mean_squared_radius_array(
sampler, 2**16),
method="blocking")
print(r2)
assert (abs(3 / omega / 2 - r2["mean"]) <
1.96 * r2["sem"]), "Should be withing 95% CI of analytic result."
# Radius:
r = compute_statistics_for_series(H.mean_radius_array(sampler, 2**16),
method="blocking")
print(r)
assert (abs(2 / np.sqrt(np.pi * omega) - r["mean"]) <
1.96 * r["sem"]), "Should be withing 95% CI of analytic result."
import matplotlib.pyplot as plt
import matplotlib2tikz
from qflow.wavefunctions import SimpleGaussian
from qflow.hamiltonians import HarmonicOscillator
from qflow.samplers import ImportanceSampler
from qflow.optimizers import SgdOptimizer, AdamOptimizer
from qflow.training import EnergyCallback, train
from qflow.mpi import master_rank
N, D = 1, 1
system = np.empty((N, D))
H = HarmonicOscillator(omega_ho=1)
psi = SimpleGaussian(0.8)
org_params = psi.parameters[:]
sampler = ImportanceSampler(system, psi, 0.5)
labels = [
r"Sgd($\eta=0.1$)",
r"Sgd($\eta=0.050$)",
r"Sgd($\eta=0.025$)",
r"Sgd($\eta=0.010$)",
r"Adam($\eta=0.05,\beta_1=0.9$)",
r"Adam($\eta=0.05,\beta_1=0.7$)",
]
optimizers = [
SgdOptimizer(0.1),
SgdOptimizer(0.05),
SgdOptimizer(0.025),
SgdOptimizer(0.01),
AdamOptimizer(len(psi.parameters), 0.05, 0.9),
# Wave functions:
simple_gaussian = SimpleGaussian(alpha=0.5)
jastrow = JastrowPade(alpha=1, beta=1)
simple_and_jastrow = WavefunctionProduct(simple_gaussian, jastrow)
layers = [
DenseLayer(P * D, 32, activation=tanh, scale_factor=0.001),
DenseLayer(32, 16, activation=tanh),
DenseLayer(16, 1, activation=exponential),
]
dnn = Dnn()
for l in layers:
dnn.add_layer(l)
psi = WavefunctionProduct(simple_and_jastrow, dnn)
psi_sampler = ImportanceSampler(system, psi, step_size=0.1)
# Sorted
simple_gaussian2 = SimpleGaussian(alpha=0.5)
jastrow2 = JastrowPade(alpha=1, beta=1)
simple_and_jastrow2 = WavefunctionProduct(simple_gaussian2, jastrow2)
layers2 = [
DenseLayer(P * D, 32, activation=tanh, scale_factor=0.001),
DenseLayer(32, 16, activation=tanh),
DenseLayer(16, 1, activation=exponential),
]
dnn2 = Dnn()
for l in layers2:
dnn2.add_layer(l)
psi_sorted_base = WavefunctionProduct(simple_and_jastrow2, dnn2)
eax.legend()
pax.plot(np.asarray(parameters)[:, [0, 3]])
pax.set_xlabel(r"% of training")
pax.legend([r"$\alpha_G$", r"$\beta_{PJ}$"])
matplotlib2tikz.save(__file__ + ".tex")
P, D = 2, 2 # Particles, dimensions
system = np.empty((P, D))
H = CoulombHarmonicOscillator()
simple_gaussian = SimpleGaussian(alpha=0.5)
jastrow = JastrowPade(alpha=1, beta=1)
psi = WavefunctionProduct(simple_gaussian, jastrow)
psi_sampler = ImportanceSampler(system, psi, step_size=0.1)
psi_simple_sampler = ImportanceSampler(system, simple_gaussian, step_size=0.1)
psi_energies = EnergyCallback(samples=100000)
psi_parameters = ParameterCallback()
train(
psi,
H,
psi_sampler,
iters=2000,
samples=1000,
gamma=0,
optimizer=AdamOptimizer(len(psi.parameters)),
call_backs=(psi_energies, psi_parameters),
)
# Wave functions:
simple_gaussian = SimpleGaussian(alpha=0.5)
jastrow = JastrowPade(alpha=1, beta=1)
simple_and_jastrow = WavefunctionProduct(simple_gaussian, jastrow)
layers = [
DenseLayer(P * D, 32, activation=tanh, scale_factor=0.001),
DenseLayer(32, 16, activation=tanh),
DenseLayer(16, 1, activation=exponential),
]
dnn = Dnn()
for l in layers:
dnn.add_layer(l)
psi = WavefunctionProduct(simple_and_jastrow, dnn)
psi_sampler = ImportanceSampler(system, psi, step_size=0.1)
psi.parameters = np.loadtxt("QD-parameters-dnn-regular.txt")
# Sorted
simple_gaussian2 = SimpleGaussian(alpha=0.5)
jastrow2 = JastrowPade(alpha=1, beta=1)
simple_and_jastrow2 = WavefunctionProduct(simple_gaussian2, jastrow2)
layers2 = [
DenseLayer(P * D, 32, activation=tanh, scale_factor=0.001),
DenseLayer(32, 16, activation=tanh),
DenseLayer(16, 1, activation=exponential),
]
dnn2 = Dnn()
for l in layers2:
dnn2.add_layer(l)
def test_mean_dist_large_cached(benchmark):
with DistanceCache(large_system):
result = benchmark(H0.mean_distance_array,
ImportanceSampler(large_system, psi0), samples)
assert np.isfinite(result).all()
def test_E_L_grad_large(benchmark):
result = benchmark(H0.local_energy_gradient,
ImportanceSampler(large_system, psi0), psi0, samples)
assert np.isfinite(result).all()
def test_mean_dist_small(benchmark):
result = benchmark(H0.mean_distance_array,
ImportanceSampler(small_system, psi0), samples)
assert np.isfinite(result).all()
def test_E_L_small(benchmark):
result = benchmark(H0.local_energy, ImportanceSampler(small_system, psi0),
psi0, samples)
assert np.isfinite(result).all()
import numpy as np
import matplotlib.pyplot as plt
import matplotlib2tikz
from qflow.wavefunctions import JastrowPade, SimpleGaussian, WavefunctionProduct
from qflow.hamiltonians import CoulombHarmonicOscillator
from qflow.samplers import ImportanceSampler
from qflow.mpi import master_rank
P, D = 2, 2 # Particles, dimensions
system = np.empty((P, D))
H = CoulombHarmonicOscillator()
simple_gaussian = SimpleGaussian(alpha=0.4950)
jastrow = JastrowPade(alpha=1, beta=0.3978)
psi = WavefunctionProduct(simple_gaussian, jastrow)
sampler = ImportanceSampler(system, psi, step_size=0.1)
sampler.thermalize(10000)
samples = 2**27
n_bins = 100
max_r = 3.0
r = np.linspace(0, max_r, n_bins)
bins = H.onebodydensity(sampler, n_bins, max_r, samples)
rho = bins / np.trapz(bins, x=r)
exact_ideal = np.exp(-r**2)
exact_ideal /= np.trapz(exact_ideal, x=r)
if master_rank():
print(rho)
plt.plot(r, rho, label=r"$\psi_{PJ}$")
plt.plot(r, exact_ideal, "--", label=r"$\exp(-r^2)$")
import numpy as np
from qflow.wavefunctions import SimpleGaussian
from qflow.hamiltonians import HarmonicOscillator
from qflow.samplers import ImportanceSampler
from qflow.statistics import compute_statistics_for_series, statistics_to_tex
from qflow.mpi import mpiprint
N, D = 100, 3
system = np.empty((N, D))
H = HarmonicOscillator(omega_ho=1)
psi_opt = SimpleGaussian(alpha=0.5)
psi_nopt = SimpleGaussian(alpha=0.51)
sampler_opt = ImportanceSampler(system, psi_opt, 0.1)
sampler_nopt = ImportanceSampler(system, psi_nopt, 0.1)
sampler_opt.thermalize(10000)
sampler_nopt.thermalize(10000)
samples = 2**23
stats = [
compute_statistics_for_series(
H.local_energy_array(sampler_opt, psi_opt, 100) / N),
compute_statistics_for_series(
H.local_energy_array(sampler_nopt, psi_nopt, samples) / N,
method="blocking"),
]
labels = [r"$\alpha_G = 0.5$", r"$\alpha_G=0.51$"]
from qflow.training import train, EnergyCallback, ParameterCallback
from qflow.statistics import compute_statistics_for_series
from qflow.mpi import mpiprint, master_rank
P, D = 2, 2 # Particles, dimensions
# Define Hamiltonian:
H = CoulombHarmonicOscillator(omega_ho=1)
# Define trial wave function:
gaussian = SimpleGaussian(alpha=0.8)
jastrow = JastrowPade(alpha=1, beta=1)
psi = WavefunctionProduct(gaussian, jastrow)
# Set up sampling strategy:
sampler = ImportanceSampler(np.empty((P, D)), psi, step_size=0.1)
# Train wave function:
training_energies = EnergyCallback(samples=100000)
training_params = ParameterCallback()
train(
psi,
H,
sampler,
iters=150, # Optimization steps.
samples=1000, # MC cycles per optimization step.
gamma=0, # Regularization parameter (disabled here).
optimizer=SgdOptimizer(0.1),
call_backs=(training_energies, training_params),
)
def test_mean_dist_large(benchmark):
result = benchmark(H0.mean_distance, ImportanceSampler(large_system, psi0), samples)
assert np.isfinite(result).all()
import numpy as np
import matplotlib.pyplot as plt
import matplotlib2tikz
from qflow.wavefunctions import SimpleGaussian
from qflow.hamiltonians import HarmonicOscillator
from qflow.samplers import ImportanceSampler
from qflow.optimizers import SgdOptimizer
from qflow.training import train, EnergyCallback, ParameterCallback
N, D = 10, 3
system = np.empty((N, D))
H = HarmonicOscillator(omega_ho=1)
psi_G = SimpleGaussian(alpha=0.3)
isampler_G = ImportanceSampler(system, psi_G, 0.1)
isampler_G.thermalize(10000)
E_training = EnergyCallback(samples=50000, verbose=True)
G_training = ParameterCallback()
train(
psi_G,
H,
isampler_G,
iters=100,
samples=1000,
gamma=0,
optimizer=SgdOptimizer(0.001),
call_backs=[E_training, G_training],
)
E_training = np.asarray(E_training) / N
system = np.empty((P, D))
simple_gaussian = SimpleGaussian(alpha=0.5)
jastrow = JastrowOrion(beta=2, gamma=1.5)
layers = [
DenseLayer(2 * D, 32, activation=tanh, scale_factor=0.001),
DenseLayer(32, 1, activation=exponential),
]
dnn = Dnn()
for l in layers:
dnn.add_layer(l)
simple_and_jastrow = WavefunctionProduct(simple_gaussian, jastrow)
pooled_dnn = SumPooling(dnn)
psi = WavefunctionProduct(simple_and_jastrow, pooled_dnn)
psi_sampler = ImportanceSampler(system, psi, step_size=0.1)
psi_energies = EnergyCallback(samples=5000, verbose=True)
psi_symmetries = SymmetryCallback(samples=100)
psi_parameters = ParameterCallback()
train(
psi,
H1,
psi_sampler,
iters=50,
samples=1000,
gamma=0,
optimizer=AdamOptimizer(len(psi.parameters)),
# call_backs=(psi_energies, psi_symmetries, psi_parameters),
)
from qflow.mpi import master_rank
N, D = 10, 3
system = np.empty((N, D))
H = HarmonicOscillator(omega_ho=1)
psi = SimpleGaussian(alpha=0.51)
n_thermal = 50000
n_energy = 2**21
arm, ari = [], []
semm, semi = [], []
steps = np.logspace(-6.5, 1.1, 150)
for step in tqdm(steps):
ms = MetropolisSampler(system, psi, step)
si = ImportanceSampler(system, psi, step)
ms.thermalize(n_thermal)
si.thermalize(n_thermal)
arm.append(ms.acceptance_rate * 100)
ari.append(si.acceptance_rate * 100)
semm.append(
compute_statistics_for_series(H.local_energy_array(ms, psi, n_energy),
method="blocking")["sem"])
semi.append(
compute_statistics_for_series(H.local_energy_array(si, psi, n_energy),
method="blocking")["sem"])
if master_rank():
mask = np.asarray(semi) < np.max(semm)
