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),
AdamOptimizer(len(psi.parameters), 0.05, 0.7),
]
E = []
for opt in optimizers:
# psi.parameters = org_params
psi = SimpleGaussian(0.8)
sampler = ImportanceSampler(system, psi, 0.1)
sampler.thermalize(10000)
E_training = EnergyCallback(samples=1000000, verbose=True)
train(
psi,
H,
sampler,
iters=150,
samples=1000,
samples = 1000
gamma = 0.0
evaluation_points = 2**23
psi_energies = EnergyCallback(samples=plot_samples, verbose=True)
psi_symmetries = SymmetryCallback(samples=plot_samples)
psi_parameters = ParameterCallback()
train(
psi,
H,
psi_sampler,
iters=iters,
samples=samples,
gamma=gamma,
optimizer=AdamOptimizer(len(psi.parameters)),
call_backs=(psi_energies, psi_symmetries, psi_parameters),
)
mpiprint("Training regular dnn complete")
np.savetxt("QD-parameters-dnn-regular.txt", psi.parameters)
psi_sorted_energies = EnergyCallback(samples=plot_samples, verbose=True)
psi_sorted_parameters = ParameterCallback()
train(
psi_sorted,
H,
psi_sorted_sampler,
iters=iters,
samples=samples,
# DenseLayer(P * D, 144, activation=tanh, scale_factor=0.001),
# DenseLayer(144, 36, activation=tanh),
# DenseLayer(36, 1, activation=exponential),
# ]
# dnn = Dnn()
# for l in layers:
# dnn.add_layer(l)
# mcmillian_fixed = FixedWavefunction(mcmillian)
# psi_total = WavefunctionProduct(mcmillian_fixed, dnn)
# psi = InputSorter(psi_total)
psi = mcmillian
sampler = HeliumSampler(system, psi, 0.5, L)
sampler.thermalize(10000)
mpiprint(f"AR: {sampler.acceptance_rate}")
optimizer = AdamOptimizer(len(psi.parameters), 0.0001)
steps = 0
t_average = 0
E_training = []
b_training = []
for _ in range(steps):
t0 = time.time()
H.optimize_wavefunction(psi, sampler, 50, 1000, optimizer, 0.00001, False)
t1 = time.time() - t0
t_average = (t_average * _ + t1) / (_ + 1)
E = H.local_energy_array(sampler, psi, 5000) / P
E_training.append(np.mean(E))
b_training.append(psi.parameters[0])
eta = timedelta(seconds=round(t_average * (steps - _)))
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),
)
mpiprint("Training complete")
stats = [
compute_statistics_for_series(
H.local_energy_array(psi_simple_sampler, simple_gaussian, 2**22),
method="blocking",
),
compute_statistics_for_series(H.local_energy_array(psi_sampler, psi,
2**22),
method="blocking"),
]
labels = [r"$\Phi$", r"$\psi_{PJ}$"]
for l in layers2:
dnn2.add_layer(l)
mcmillian2 = JastrowMcMillian(5, 2.85, L)
psi_total2 = WavefunctionProduct(mcmillian2, dnn2)
psi_sorted = InputSorter(psi_total2)
psi_sorted.parameters = psi.parameters
sampler_sorted = HeliumSampler(system, psi_sorted, 0.5, L)
sampler_sorted.thermalize(10000)
mpiprint(f"AR: {sampler_sorted.acceptance_rate}")
mcmillian_bench = JastrowMcMillian(5, 2.85, L)
sampler_bench = HeliumSampler(system, mcmillian_bench, 0.5, L)
sampler_bench.thermalize(10000)
mpiprint(f"AR (bench): {sampler_bench.acceptance_rate}")
optimizer = AdamOptimizer(len(psi.parameters), 0.0001)
optimizer_sorted = AdamOptimizer(len(psi_sorted.parameters), 0.0001)
optimizer_bench = AdamOptimizer(len(mcmillian_bench.parameters), 0.0001)
iter_per_step = 500
samples_per_iter = 5000
plot_samples = 1_000_000
gamma = 0.00001
steps = 500
t_average = 0
E_training = []
b_training = []
b_bench_training = []
parameters = []
for _ in range(steps):
# psi = SimpleGaussian(0.3)
org_params = psi.parameters[:]
sampler = ImportanceSampler(system, psi, 0.5)
labels = [
r"Sgd($\eta=1$)",
r"Sgd($\eta=0.1$)",
r"Sgd($\eta=0.05$)",
r"Adam($\eta=0.1,\beta_1=0.9$)",
r"Adam($\eta=0.1,\beta_1=0.8$)",
]
optimizers = [
SgdOptimizer(1),
SgdOptimizer(0.1),
SgdOptimizer(0.05),
AdamOptimizer(len(psi.parameters), 0.1, 0.9),
AdamOptimizer(len(psi.parameters), 0.1, 0.8),
]
E = []
for opt in optimizers:
# psi.parameters = org_params
psi = RBMWavefunction(N * D, 2)
# psi = SimpleGaussian(0.8)
sampler = ImportanceSampler(system, psi, 0.1)
sampler.thermalize(10000)
E_training = EnergyCallback(samples=1000000, verbose=True)
train(
psi,
H,
sampler,
iters=500,