def test_training(request, quantum_state_training_data):
qucumber.set_random_seed(SEED, cpu=True, gpu=False, quiet=True)
fidelities = []
KLs = []
qstd = quantum_state_training_data
print("Training 10 times and checking fidelity and KL at 5 epochs...\n")
for i in range(10):
print(f"Iteration: {i + 1}")
qstd["reinit_params_fn"](request, qstd["nn_state"])
qstd["nn_state"].fit(time=True, progbar=False, **qstd)
fidelities.append(ts.fidelity(**qstd))
KLs.append(ts.KL(**qstd))
print(f"Fidelity: {fidelities[-1]}; KL: {KLs[-1]}.")
print("\nStatistics")
print("----------")
print(
"Fidelity: ",
np.average(fidelities),
"+/-",
np.std(fidelities) / np.sqrt(len(fidelities)),
"\n",
)
print("KL: ", np.average(KLs), "+/-",
np.std(KLs) / np.sqrt(len(KLs)), "\n")
assert abs(np.average(fidelities) - qstd["fid_target"]) < 0.02
assert abs(np.average(KLs) - qstd["kl_target"]) < 0.02
assert (np.std(fidelities) / np.sqrt(len(fidelities))) < 0.02
assert (np.std(KLs) / np.sqrt(len(KLs))) < 0.02
def compute_numerical_kl(self, target_psi, vis):
return ts.KL(self.nn_state, target_psi, vis)
def compute_numerical_kl(self, psi_dict, vis, bases):
return ts.KL(self.nn_state, psi_dict, vis, bases=bases)
def test_trainingcomplex(self):
print("Complex Wavefunction")
print("--------------------")
train_samples_path = os.path.join(
__tests_location__,
"..",
"examples",
"Tutorial2_TrainComplexWavefunction",
"qubits_train.txt",
)
train_bases_path = os.path.join(
__tests_location__,
"..",
"examples",
"Tutorial2_TrainComplexWavefunction",
"qubits_train_bases.txt",
)
bases_path = os.path.join(
__tests_location__,
"..",
"examples",
"Tutorial2_TrainComplexWavefunction",
"qubits_bases.txt",
)
psi_path = os.path.join(
__tests_location__,
"..",
"examples",
"Tutorial2_TrainComplexWavefunction",
"qubits_psi.txt",
)
train_samples, target_psi, train_bases, bases = data.load_data(
train_samples_path, psi_path, train_bases_path, bases_path)
unitary_dict = unitaries.create_dict()
nv = nh = train_samples.shape[-1]
fidelities = []
KLs = []
epochs = 5
batch_size = 50
num_chains = 10
CD = 10
lr = 0.1
log_every = 5
print(
"Training 10 times and checking fidelity and KL at 5 epochs...\n")
for i in range(10):
print("Iteration: ", i + 1)
nn_state = ComplexWavefunction(unitary_dict=unitary_dict,
num_visible=nv,
num_hidden=nh,
gpu=False)
space = nn_state.generate_hilbert_space(nv)
callbacks = [
MetricEvaluator(
log_every,
{
"Fidelity": ts.fidelity,
"KL": ts.KL
},
target_psi=target_psi,
bases=bases,
space=space,
verbose=True,
)
]
self.initialize_complex_params(nn_state)
nn_state.fit(
data=train_samples,
epochs=epochs,
pos_batch_size=batch_size,
neg_batch_size=num_chains,
k=CD,
lr=lr,
time=True,
input_bases=train_bases,
progbar=False,
callbacks=callbacks,
)
fidelities.append(ts.fidelity(nn_state, target_psi, space).item())
KLs.append(ts.KL(nn_state, target_psi, space, bases=bases).item())
print("\nStatistics")
print("----------")
print(
"Fidelity: ",
np.average(fidelities),
"+/-",
np.std(fidelities) / np.sqrt(len(fidelities)),
"\n",
)
print("KL: ", np.average(KLs), "+/-",
np.std(KLs) / np.sqrt(len(KLs)), "\n")
self.assertTrue(abs(np.average(fidelities) - 0.38) < 0.05)
self.assertTrue(abs(np.average(KLs) - 0.33) < 0.05)
self.assertTrue((np.std(fidelities) / np.sqrt(len(fidelities))) < 0.01)
self.assertTrue((np.std(KLs) / np.sqrt(len(KLs))) < 0.01)
def test_trainingpositive(self):
print("Positive Wavefunction")
print("---------------------")
train_samples_path = os.path.join(
__tests_location__,
"..",
"examples",
"Tutorial1_TrainPosRealWavefunction",
"tfim1d_data.txt",
)
psi_path = os.path.join(
__tests_location__,
"..",
"examples",
"Tutorial1_TrainPosRealWavefunction",
"tfim1d_psi.txt",
)
train_samples, target_psi = data.load_data(train_samples_path,
psi_path)
nv = nh = train_samples.shape[-1]
fidelities = []
KLs = []
epochs = 5
batch_size = 100
num_chains = 200
CD = 10
lr = 0.1
log_every = 5
print(
"Training 10 times and checking fidelity and KL at 5 epochs...\n")
for i in range(10):
print("Iteration: ", i + 1)
nn_state = PositiveWavefunction(num_visible=nv,
num_hidden=nh,
gpu=False)
space = nn_state.generate_hilbert_space(nv)
callbacks = [
MetricEvaluator(
log_every,
{
"Fidelity": ts.fidelity,
"KL": ts.KL
},
target_psi=target_psi,
space=space,
verbose=True,
)
]
self.initialize_posreal_params(nn_state)
nn_state.fit(
data=train_samples,
epochs=epochs,
pos_batch_size=batch_size,
neg_batch_size=num_chains,
k=CD,
lr=lr,
time=True,
progbar=False,
callbacks=callbacks,
)
fidelities.append(ts.fidelity(nn_state, target_psi, space).item())
KLs.append(ts.KL(nn_state, target_psi, space).item())
print("\nStatistics")
print("----------")
print(
"Fidelity: ",
np.average(fidelities),
"+/-",
np.std(fidelities) / np.sqrt(len(fidelities)),
"\n",
)
print("KL: ", np.average(KLs), "+/-",
np.std(KLs) / np.sqrt(len(KLs)), "\n")
self.assertTrue(abs(np.average(fidelities) - 0.85) < 0.02)
self.assertTrue(abs(np.average(KLs) - 0.29) < 0.05)
self.assertTrue((np.std(fidelities) / np.sqrt(len(fidelities))) < 0.01)
self.assertTrue((np.std(KLs) / np.sqrt(len(KLs))) < 0.01)
def compute_numerical_KL(self, target, space, all_bases=None):
return ts.KL(self.nn_state, target, space, bases=all_bases)
