def test_from_dict():
pm = ParameterHelper(
species=["O", "C", "H"],
kernels=["twobody", "threebody"],
allseparate=True,
random=True,
parameters={"cutoff_twobody": 7, "cutoff_threebody": 4.5, "cutoff_manybody": 3},
verbose="debug",
)
hm = pm.as_dict()
Parameters.check_instantiation(hm["hyps"], hm["cutoffs"], hm["kernels"], hm)
pm1 = ParameterHelper.from_dict(hm, verbose="debug", init_spec=["O", "C", "H"])
hm1 = pm1.as_dict()
Parameters.compare_dict(hm, hm1)
def update_bounds(self, GP):
rebuild_container = False
# double check the container and the GP is consistent
if not Parameters.compare_dict(GP.hyps_mask, self.hyps_mask):
rebuild_container = True
lower_bound = self.bounds[0]
min_dist = self.search_lower_bound(GP)
# change lower bound only when there appears a smaller distance
if lower_bound is None or min_dist < np.max(lower_bound):
lower_bound = np.max((min_dist - self.lower_bound_relax, 0.0))
rebuild_container = True
warnings.warn(
"The minimal distance in training data is lower than "
f"the current lower bound, will reset lower bound to {lower_bound}"
)
upper_bound = self.bounds[1]
if self.auto_upper or upper_bound is None:
gp_cutoffs = Parameters.get_cutoff(self.kernel_name, self.species,
GP.hyps_mask)
if upper_bound is None or np.any(gp_cutoffs > upper_bound):
upper_bound = gp_cutoffs
rebuild_container = True
if rebuild_container:
self.set_bounds(lower_bound, upper_bound)
self.build_map_container()
def test_from_dict():
pm = ParameterHelper(species=['O', 'C', 'H'],
kernels=['twobody', 'threebody'],
allseparate=True,
random=True,
parameters={'cutoff_twobody': 7,
'cutoff_threebody': 4.5,
'cutoff_manybody': 3},
verbose="debug")
hm = pm.as_dict()
Parameters.check_instantiation(
hm['hyps'], hm['cutoffs'], hm['kernels'], hm)
pm1 = ParameterHelper.from_dict(
hm, verbose="debug", init_spec=['O', 'C', 'H'])
hm1 = pm1.as_dict()
Parameters.compare_dict(hm, hm1)
def predict(self, atom_env):
assert Parameters.compare_dict(
self.hyps_mask, atom_env.cutoffs_mask
), "GP.hyps_mask is not the same as atom_env.cutoffs_mask"
f_spcs = np.zeros(3)
vir_spcs = np.zeros(6)
v_spcs = 0
e_spcs = 0
kern = 0
if len(atom_env.bond_array_2) == 0:
return f_spcs, vir_spcs, kern, v_spcs, e_spcs
en_kernel, cutoffs, hyps, hyps_mask = self.kernel_info
args = from_mask_to_args(hyps, cutoffs, hyps_mask)
if self.var_map == "pca":
kern = en_kernel(atom_env, atom_env, *args)
spcs, comp_r, comp_xyz = self.get_arrays(atom_env)
# predict for each species
rebuild_spc = []
new_bounds = []
for i, spc in enumerate(spcs):
lengths = np.array(comp_r[i])
xyzs = np.array(comp_xyz[i])
map_ind = self.find_map_index(spc)
try:
f, vir, v, e = self.maps[map_ind].predict(lengths, xyzs)
except ValueError as err_msg:
rebuild_spc.append(err_msg.args[0])
new_bounds.append(err_msg.args[1])
if len(rebuild_spc) > 0:
raise ValueError(
rebuild_spc,
new_bounds,
f"The {self.kernel_name} map needs re-constructing.",
)
f_spcs += f
vir_spcs += vir
v_spcs += v
e_spcs += e
return f_spcs, vir_spcs, kern, v_spcs, e_spcs
def test_predict(all_gp, all_mgp, bodies, multihyps):
"""
test the predict for mc_simple kernel
"""
gp_model = all_gp[f"{bodies}{multihyps}"]
mgp_model = all_mgp[f"{bodies}{multihyps}"]
# # debug
# filename = f'grid_{bodies}_{multihyps}.pickle'
# with open(filename, 'rb') as f:
# mgp_model = pickle.load(f)
nenv = 6
cell = 1.0 * np.eye(3)
cutoffs = gp_model.cutoffs
unique_species = gp_model.training_statistics["species"]
struc_test, f = get_random_structure(cell, unique_species, nenv)
test_envi = env.AtomicEnvironment(struc_test,
0,
cutoffs,
cutoffs_mask=gp_model.hyps_mask)
if "2" in bodies:
kernel_name = "twobody"
elif "3" in bodies:
kernel_name = "threebody"
# compare_triplet(mgp_model.maps['threebody'], gp_model, test_envi)
mgp_f, mgp_e_var, mgp_s, mgp_e = mgp_model.predict(test_envi)
assert Parameters.compare_dict(gp_model.hyps_mask,
mgp_model.maps[kernel_name].hyps_mask)
if multihyps:
gp_e, gp_e_var = gp_model.predict_local_energy_and_var(test_envi)
gp_f, gp_f_var = gp_model.predict_force_xyz(test_envi)
else:
gp_e, gp_f, gp_s, gp_e_var, _, _ = gp_model.predict_efs(test_envi)
gp_s = -gp_s[[0, 3, 5, 4, 2, 1]]
# check stress
assert np.allclose(mgp_s, gp_s, rtol=1e-2)
# check mgp is within 2 meV/A of the gp
print("mgp_en, gp_en", mgp_e, gp_e)
assert np.allclose(mgp_e, gp_e, rtol=2e-3), (f"{bodies} body"
f" energy mapping is wrong")
# check forces
print("isclose?", mgp_f - gp_f, gp_f)
assert np.allclose(mgp_f, gp_f,
atol=1e-3), f"{bodies} body force mapping is wrong"
if mgp_model.var_map == "simple":
print(bodies, multihyps)
for i in range(struc_test.nat):
test_envi = env.AtomicEnvironment(struc_test,
i,
cutoffs,
cutoffs_mask=gp_model.hyps_mask)
mgp_pred = mgp_model.predict(test_envi)
mgp_var = mgp_pred[1]
gp_var = predict_atom_diag_var(test_envi, gp_model, kernel_name)
print("mgp_var, gp_var", mgp_var, gp_var)
assert np.allclose(mgp_var, gp_var, rtol=1e-2)
print("struc_test positions", struc_test.positions,
struc_test.species_labels)
def test_predict(all_gp, all_mgp, bodies, multihyps):
"""
test the predict for mc_simple kernel
"""
gp_model = all_gp[f'{bodies}{multihyps}']
mgp_model = all_mgp[f'{bodies}{multihyps}']
# # debug
# filename = f'grid_{bodies}_{multihyps}.pickle'
# with open(filename, 'rb') as f:
# mgp_model = pickle.load(f)
nenv = 6
cell = 1.0 * np.eye(3)
cutoffs = gp_model.cutoffs
unique_species = gp_model.training_statistics['species']
struc_test, f = get_random_structure(cell, unique_species, nenv)
test_envi = env.AtomicEnvironment(struc_test,
0,
cutoffs,
cutoffs_mask=gp_model.hyps_mask)
if '2' in bodies:
kernel_name = 'twobody'
elif '3' in bodies:
kernel_name = 'threebody'
#compare_triplet(mgp_model.maps['threebody'], gp_model, test_envi)
assert Parameters.compare_dict(gp_model.hyps_mask,
mgp_model.maps[kernel_name].hyps_mask)
gp_pred_en, gp_pred_envar = gp_model.predict_local_energy_and_var(
test_envi)
gp_pred = np.array([gp_model.predict(test_envi, d + 1)
for d in range(3)]).T
print('mgp pred')
mgp_pred = mgp_model.predict(test_envi)
# check mgp is within 2 meV/A of the gp
map_str = 'energy'
gp_pred_var = gp_pred_envar
print('mgp_en, gp_en', mgp_pred[3], gp_pred_en)
assert(np.allclose(mgp_pred[3], gp_pred_en, rtol=2e-3), \
f"{bodies} body {map_str} mapping is wrong")
# if multihyps and ('3' in bodies):
# pytest.skip()
print('mgp_pred', mgp_pred[0])
print('gp_pred', gp_pred[0])
print("isclose?", mgp_pred[0] - gp_pred[0], gp_pred[0])
assert(np.allclose(mgp_pred[0], gp_pred[0], atol=1e-3)), \
f"{bodies} body {map_str} mapping is wrong"
if mgp_model.var_map == 'simple':
print(bodies, multihyps)
for i in range(struc_test.nat):
test_envi = env.AtomicEnvironment(struc_test,
i,
cutoffs,
cutoffs_mask=gp_model.hyps_mask)
mgp_pred = mgp_model.predict(test_envi)
mgp_var = mgp_pred[1]
gp_var = predict_atom_diag_var(test_envi, gp_model, kernel_name)
print('mgp_var, gp_var', mgp_var, gp_var)
assert np.allclose(mgp_var, gp_var, rtol=1e-2)
print('struc_test positions', struc_test.positions,
struc_test.species_labels)
