From b3a925d63471cb47efd62ad5d5a07c0cf55ba1e9 Mon Sep 17 00:00:00 2001 From: sum Date: Mon, 10 Feb 2025 16:47:09 +0800 Subject: [PATCH 01/11] fix and ut --- deepmd/entrypoints/test.py | 126 ++++++++++++--------------- source/tests/pt/test_weighted_avg.py | 103 ++++++++++++++++++++++ 2 files changed, 158 insertions(+), 71 deletions(-) create mode 100644 source/tests/pt/test_weighted_avg.py diff --git a/deepmd/entrypoints/test.py b/deepmd/entrypoints/test.py index 90147ac3af..a9afe61bea 100644 --- a/deepmd/entrypoints/test.py +++ b/deepmd/entrypoints/test.py @@ -134,7 +134,7 @@ def test( ) if isinstance(dp, DeepPot): - err = test_ener( + err, find_energy, find_force, find_virial = test_ener( dp, data, system, @@ -143,6 +143,29 @@ def test( atomic, append_detail=(cc != 0), ) + err_part = {} + + if find_energy == 1: + err_part['mae_e'] = err['mae_e'] + err_part['mae_ea'] = err['mae_ea'] + err_part['rmse_e'] = err['rmse_e'] + err_part['rmse_ea'] = err['rmse_ea'] + + if find_force == 1: + if 'rmse_f' in err: + err_part['mae_f'] = err['mae_f'] + err_part['rmse_f'] = err['rmse_f'] + else: + err_part['mae_fr'] = err['mae_fr'] + err_part['rmse_fr'] = err['rmse_fr'] + err_part['mae_fm'] = err['mae_fm'] + err_part['rmse_fm'] = err['rmse_fm'] + if find_virial == 1: + err_part['mae_v'] = err['mae_v'] + err_part['rmse_v'] = err['rmse_v'] + + err = err_part + elif isinstance(dp, DeepDOS): err = test_dos( dp, @@ -303,10 +326,11 @@ def test_ener( if dp.has_spin: data.add("spin", 3, atomic=True, must=True, high_prec=False) data.add("force_mag", 3, atomic=True, must=False, high_prec=False) - if dp.has_hessian: - data.add("hessian", 1, atomic=True, must=True, high_prec=False) test_data = data.get_test() + find_energy = test_data.get('find_energy') + find_force = test_data.get('find_force') + find_virial = test_data.get('find_virial') mixed_type = data.mixed_type natoms = len(test_data["type"][0]) nframes = test_data["box"].shape[0] @@ -354,9 +378,6 @@ def test_ener( energy = energy.reshape([numb_test, 1]) force = force.reshape([numb_test, -1]) virial = virial.reshape([numb_test, 9]) - if dp.has_hessian: - hessian = ret[3] - hessian = hessian.reshape([numb_test, -1]) if has_atom_ener: ae = ret[3] av = ret[4] @@ -420,10 +441,6 @@ def test_ener( rmse_ea = rmse_e / natoms mae_va = mae_v / natoms rmse_va = rmse_v / natoms - if dp.has_hessian: - diff_h = hessian - test_data["hessian"][:numb_test] - mae_h = mae(diff_h) - rmse_h = rmse(diff_h) if has_atom_ener: diff_ae = test_data["atom_ener"][:numb_test].reshape([-1]) - ae.reshape([-1]) mae_ae = mae(diff_ae) @@ -439,16 +456,17 @@ def test_ener( log.info(f"Energy RMSE : {rmse_e:e} eV") log.info(f"Energy MAE/Natoms : {mae_ea:e} eV") log.info(f"Energy RMSE/Natoms : {rmse_ea:e} eV") - if not out_put_spin: - log.info(f"Force MAE : {mae_f:e} eV/A") - log.info(f"Force RMSE : {rmse_f:e} eV/A") - else: - log.info(f"Force atom MAE : {mae_fr:e} eV/A") - log.info(f"Force atom RMSE : {rmse_fr:e} eV/A") - log.info(f"Force spin MAE : {mae_fm:e} eV/uB") - log.info(f"Force spin RMSE : {rmse_fm:e} eV/uB") + if find_force == 1: + if not out_put_spin: + log.info(f"Force MAE : {mae_f:e} eV/A") + log.info(f"Force RMSE : {rmse_f:e} eV/A") + else: + log.info(f"Force atom MAE : {mae_fr:e} eV/A") + log.info(f"Force atom RMSE : {rmse_fr:e} eV/A") + log.info(f"Force spin MAE : {mae_fm:e} eV/uB") + log.info(f"Force spin RMSE : {rmse_fm:e} eV/uB") - if data.pbc and not out_put_spin: + if data.pbc and not out_put_spin and find_virial == 1: log.info(f"Virial MAE : {mae_v:e} eV") log.info(f"Virial RMSE : {rmse_v:e} eV") log.info(f"Virial MAE/Natoms : {mae_va:e} eV") @@ -456,9 +474,6 @@ def test_ener( if has_atom_ener: log.info(f"Atomic ener MAE : {mae_ae:e} eV") log.info(f"Atomic ener RMSE : {rmse_ae:e} eV") - if dp.has_hessian: - log.info(f"Hessian MAE : {mae_h:e} eV/A^2") - log.info(f"Hessian RMSE : {rmse_h:e} eV/A^2") if detail_file is not None: detail_path = Path(detail_file) @@ -542,24 +557,8 @@ def test_ener( "pred_vyy pred_vyz pred_vzx pred_vzy pred_vzz", append=append_detail, ) - if dp.has_hessian: - data_h = test_data["hessian"][:numb_test].reshape(-1, 1) - pred_h = hessian.reshape(-1, 1) - h = np.concatenate( - ( - data_h, - pred_h, - ), - axis=1, - ) - save_txt_file( - detail_path.with_suffix(".h.out"), - h, - header=f"{system}: data_h pred_h (3Na*3Na matrix in row-major order)", - append=append_detail, - ) if not out_put_spin: - dict_to_return = { + return { "mae_e": (mae_e, energy.size), "mae_ea": (mae_ea, energy.size), "mae_f": (mae_f, force.size), @@ -570,9 +569,9 @@ def test_ener( "rmse_f": (rmse_f, force.size), "rmse_v": (rmse_v, virial.size), "rmse_va": (rmse_va, virial.size), - } + }, find_energy, find_force, find_virial else: - dict_to_return = { + return { "mae_e": (mae_e, energy.size), "mae_ea": (mae_ea, energy.size), "mae_fr": (mae_fr, force_r.size), @@ -585,11 +584,7 @@ def test_ener( "rmse_fm": (rmse_fm, force_m.size), "rmse_v": (rmse_v, virial.size), "rmse_va": (rmse_va, virial.size), - } - if dp.has_hessian: - dict_to_return["mae_h"] = (mae_h, hessian.size) - dict_to_return["rmse_h"] = (rmse_h, hessian.size) - return dict_to_return + }, find_energy, find_force, find_virial def print_ener_sys_avg(avg: dict[str, float]) -> None: @@ -616,9 +611,6 @@ def print_ener_sys_avg(avg: dict[str, float]) -> None: log.info(f"Virial RMSE : {avg['rmse_v']:e} eV") log.info(f"Virial MAE/Natoms : {avg['mae_va']:e} eV") log.info(f"Virial RMSE/Natoms : {avg['rmse_va']:e} eV") - if "rmse_h" in avg.keys(): - log.info(f"Hessian MAE : {avg['mae_h']:e} eV/A^2") - log.info(f"Hessian RMSE : {avg['rmse_h']:e} eV/A^2") def test_dos( @@ -739,9 +731,9 @@ def test_dos( frame_output = np.hstack((test_out, pred_out)) save_txt_file( - detail_path.with_suffix(f".dos.out.{ii}"), + detail_path.with_suffix(".dos.out.%.d" % ii), frame_output, - header=f"{system} - {ii}: data_dos pred_dos", + header="%s - %.d: data_dos pred_dos" % (system, ii), append=append_detail, ) @@ -753,9 +745,9 @@ def test_dos( frame_output = np.hstack((test_out, pred_out)) save_txt_file( - detail_path.with_suffix(f".ados.out.{ii}"), + detail_path.with_suffix(".ados.out.%.d" % ii), frame_output, - header=f"{system} - {ii}: data_ados pred_ados", + header="%s - %.d: data_ados pred_ados" % (system, ii), append=append_detail, ) @@ -814,17 +806,9 @@ def test_property( tuple[list[np.ndarray], list[int]] arrays with results and their shapes """ - var_name = dp.get_var_name() - assert isinstance(var_name, str) - data.add(var_name, dp.task_dim, atomic=False, must=True, high_prec=True) + data.add("property", dp.task_dim, atomic=False, must=True, high_prec=True) if has_atom_property: - data.add( - f"atom_{var_name}", - dp.task_dim, - atomic=True, - must=False, - high_prec=True, - ) + data.add("atom_property", dp.task_dim, atomic=True, must=False, high_prec=True) if dp.get_dim_fparam() > 0: data.add( @@ -875,12 +859,12 @@ def test_property( aproperty = ret[1] aproperty = aproperty.reshape([numb_test, natoms * dp.task_dim]) - diff_property = property - test_data[var_name][:numb_test] + diff_property = property - test_data["property"][:numb_test] mae_property = mae(diff_property) rmse_property = rmse(diff_property) if has_atom_property: - diff_aproperty = aproperty - test_data[f"atom_{var_name}"][:numb_test] + diff_aproperty = aproperty - test_data["atom_property"][:numb_test] mae_aproperty = mae(diff_aproperty) rmse_aproperty = rmse(diff_aproperty) @@ -897,29 +881,29 @@ def test_property( detail_path = Path(detail_file) for ii in range(numb_test): - test_out = test_data[var_name][ii].reshape(-1, 1) + test_out = test_data["property"][ii].reshape(-1, 1) pred_out = property[ii].reshape(-1, 1) frame_output = np.hstack((test_out, pred_out)) save_txt_file( - detail_path.with_suffix(f".property.out.{ii}"), + detail_path.with_suffix(".property.out.%.d" % ii), frame_output, - header=f"{system} - {ii}: data_property pred_property", + header="%s - %.d: data_property pred_property" % (system, ii), append=append_detail, ) if has_atom_property: for ii in range(numb_test): - test_out = test_data[f"atom_{var_name}"][ii].reshape(-1, 1) + test_out = test_data["atom_property"][ii].reshape(-1, 1) pred_out = aproperty[ii].reshape(-1, 1) frame_output = np.hstack((test_out, pred_out)) save_txt_file( - detail_path.with_suffix(f".aproperty.out.{ii}"), + detail_path.with_suffix(".aproperty.out.%.d" % ii), frame_output, - header=f"{system} - {ii}: data_aproperty pred_aproperty", + header="%s - %.d: data_aproperty pred_aproperty" % (system, ii), append=append_detail, ) diff --git a/source/tests/pt/test_weighted_avg.py b/source/tests/pt/test_weighted_avg.py new file mode 100644 index 0000000000..8ca3c888a3 --- /dev/null +++ b/source/tests/pt/test_weighted_avg.py @@ -0,0 +1,103 @@ +from deepmd.utils.weight_avg import ( + weighted_average, +) +import unittest +import numpy as np + +def test(all_sys): + err_coll = [] + for sys_data in all_sys: + err, find_energy, find_force, find_virial = sys_data + err_part = {} + if find_energy == 1: + err_part['mae_e'] = err['mae_e'] + err_part['mae_ea'] = err['mae_ea'] + err_part['rmse_e'] = err['rmse_e'] + err_part['rmse_ea'] = err['rmse_ea'] + if find_force == 1: + if 'rmse_f' in err: + err_part['mae_f'] = err['mae_f'] + err_part['rmse_f'] = err['rmse_f'] + else: + err_part['mae_fr'] = err['mae_fr'] + err_part['rmse_fr'] = err['rmse_fr'] + err_part['mae_fm'] = err['mae_fm'] + err_part['rmse_fm'] = err['rmse_fm'] + if find_virial == 1: + err_part['mae_v'] = err['mae_v'] + err_part['rmse_v'] = err['rmse_v'] + err_coll.append(err_part) + avg_err = weighted_average(err_coll) + return avg_err + +def test_ori(all_sys): + err_coll = [] + for sys_data in all_sys: + err, _, _, _ = sys_data + err_coll.append(err) + avg_err = weighted_average(err_coll) + return avg_err + +class TestWeightedAverage(unittest.TestCase): + + def test_case1_energy_only(self): + + all_sys = [ + ({'mae_e': (2,2), 'mae_ea': (4,2), 'rmse_e': (3,2), 'rmse_ea': (5,2),'mae_f': (2,3), 'rmse_f': (1,3), 'mae_v': (3,5), 'rmse_v': (3,3)}, 1,0,0), + ({'mae_e': (4,3), 'mae_ea': (6,3), 'rmse_e': (5,3), 'rmse_ea': (7,3),'mae_f': (2,3), 'rmse_f': (1,3), 'mae_v': (3,5), 'rmse_v': (3,3)}, 1,0,0), + ({'mae_e': (6,5), 'mae_ea': (8,5), 'rmse_e': (7,5), 'rmse_ea': (9,5),'mae_f': (2,3), 'rmse_f': (1,3), 'mae_v': (3,5), 'rmse_v': (3,3)}, 1,0,0), + ] + expected_mae_e = (2*2 +4*3 +6*5)/(2+3+5) + expected_rmse_e = np.sqrt((3**2*2 +5**2*3 +7**2*5)/(2+3+5)) + expected_mae_ea = (4*2 +6*3 +8*5)/10 + expected_rmse_ea = np.sqrt((5**2*2 +7**2*3 +9**2*5)/10) + + avg_err = test(all_sys) + self.assertAlmostEqual(avg_err['mae_e'], expected_mae_e) + self.assertAlmostEqual(avg_err['rmse_e'], expected_rmse_e) + self.assertAlmostEqual(avg_err['mae_ea'], expected_mae_ea) + self.assertAlmostEqual(avg_err['rmse_ea'], expected_rmse_ea) + self.assertAlmostEqual(avg_err['mae_f'], 0) + self.assertAlmostEqual(avg_err['mae_v'], 0) + + avg_err_ori = test_ori(all_sys) + self.assertAlmostEqual(avg_err['mae_e'], avg_err_ori['mae_e']) + self.assertNotEqual(avg_err['mae_f'], avg_err_ori['rmse_f']) + self.assertNotEqual(avg_err['mae_v'], avg_err_ori['rmse_v']) + + + + def test_case2_energy_force(self): + all_sys = [ + ({'mae_e': (2,2), 'mae_ea': (4,2), 'rmse_e': (3,2), 'rmse_ea': (5,2),'mae_f': (2,3), 'rmse_f': (1,3), 'mae_v': (3,5), 'rmse_v': (3,3)}, 1,1,0), + ({'mae_e': (4,3), 'mae_ea': (6,3), 'rmse_e': (5,3), 'rmse_ea': (7,3),'mae_f': (1,3), 'rmse_f': (1,3), 'mae_v': (3,5), 'rmse_v': (3,3)}, 1,1,0), + ({'mae_e': (6,5), 'mae_ea': (8,5), 'rmse_e': (7,5), 'rmse_ea': (9,5),'mae_f': (2,3), 'rmse_f': (1,3), 'mae_v': (3,5), 'rmse_v': (3,3)}, 1,0,0), + ] + + avg_err = test(all_sys) + expected_mae_f = (2*3 +1*3 )/(3+3) + self.assertAlmostEqual(avg_err['mae_f'], expected_mae_f) + + avg_err_ori = test_ori(all_sys) + self.assertAlmostEqual(avg_err['mae_e'], avg_err_ori['mae_e']) + self.assertNotEqual(avg_err['mae_f'], avg_err_ori['mae_f']) + self.assertNotEqual(avg_err['mae_v'], avg_err_ori['mae_v']) + + def test_case3_all_components(self): + all_sys = [ + ({'mae_e': (2,2), 'mae_ea': (4,2), 'rmse_e': (3,2), 'rmse_ea': (5,2),'mae_f': (2,3), 'rmse_f': (1,3), 'mae_v': (3,5), 'rmse_v': (3,3)}, 1,1,1), + ({'mae_e': (4,3), 'mae_ea': (6,3), 'rmse_e': (5,3), 'rmse_ea': (7,3),'mae_f': (2,3), 'rmse_f': (1,3), 'mae_v': (1,5), 'rmse_v': (2,3)}, 1,1,1), + ({'mae_e': (6,5), 'mae_ea': (8,5), 'rmse_e': (7,5), 'rmse_ea': (9,5),'mae_f': (2,3), 'rmse_f': (1,3), 'mae_v': (3,5), 'rmse_v': (3,3)}, 1,1,0), + ] + + avg_err = test(all_sys) + expected_mae_v = (3*5 +1*5 )/(5+5) + self.assertAlmostEqual(avg_err['mae_v'], expected_mae_v) + + avg_err_ori = test_ori(all_sys) + self.assertAlmostEqual(avg_err['mae_e'], avg_err_ori['mae_e']) + self.assertAlmostEqual(avg_err['mae_f'], avg_err_ori['mae_f']) + self.assertNotEqual(avg_err['mae_v'], avg_err_ori['rmse_v']) + +if __name__ == '__main__': + unittest.main() \ No newline at end of file From 08e4a5549bf04a027458d409783b599e21a23e85 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Mon, 10 Feb 2025 08:51:22 +0000 Subject: [PATCH 02/11] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- deepmd/entrypoints/test.py | 96 ++++++----- source/tests/pt/test_weighted_avg.py | 243 ++++++++++++++++++++------- 2 files changed, 239 insertions(+), 100 deletions(-) diff --git a/deepmd/entrypoints/test.py b/deepmd/entrypoints/test.py index a9afe61bea..565ec3303e 100644 --- a/deepmd/entrypoints/test.py +++ b/deepmd/entrypoints/test.py @@ -146,24 +146,24 @@ def test( err_part = {} if find_energy == 1: - err_part['mae_e'] = err['mae_e'] - err_part['mae_ea'] = err['mae_ea'] - err_part['rmse_e'] = err['rmse_e'] - err_part['rmse_ea'] = err['rmse_ea'] + err_part["mae_e"] = err["mae_e"] + err_part["mae_ea"] = err["mae_ea"] + err_part["rmse_e"] = err["rmse_e"] + err_part["rmse_ea"] = err["rmse_ea"] if find_force == 1: - if 'rmse_f' in err: - err_part['mae_f'] = err['mae_f'] - err_part['rmse_f'] = err['rmse_f'] + if "rmse_f" in err: + err_part["mae_f"] = err["mae_f"] + err_part["rmse_f"] = err["rmse_f"] else: - err_part['mae_fr'] = err['mae_fr'] - err_part['rmse_fr'] = err['rmse_fr'] - err_part['mae_fm'] = err['mae_fm'] - err_part['rmse_fm'] = err['rmse_fm'] + err_part["mae_fr"] = err["mae_fr"] + err_part["rmse_fr"] = err["rmse_fr"] + err_part["mae_fm"] = err["mae_fm"] + err_part["rmse_fm"] = err["rmse_fm"] if find_virial == 1: - err_part['mae_v'] = err['mae_v'] - err_part['rmse_v'] = err['rmse_v'] - + err_part["mae_v"] = err["mae_v"] + err_part["rmse_v"] = err["rmse_v"] + err = err_part elif isinstance(dp, DeepDOS): @@ -328,9 +328,9 @@ def test_ener( data.add("force_mag", 3, atomic=True, must=False, high_prec=False) test_data = data.get_test() - find_energy = test_data.get('find_energy') - find_force = test_data.get('find_force') - find_virial = test_data.get('find_virial') + find_energy = test_data.get("find_energy") + find_force = test_data.get("find_force") + find_virial = test_data.get("find_virial") mixed_type = data.mixed_type natoms = len(test_data["type"][0]) nframes = test_data["box"].shape[0] @@ -558,33 +558,43 @@ def test_ener( append=append_detail, ) if not out_put_spin: - return { - "mae_e": (mae_e, energy.size), - "mae_ea": (mae_ea, energy.size), - "mae_f": (mae_f, force.size), - "mae_v": (mae_v, virial.size), - "mae_va": (mae_va, virial.size), - "rmse_e": (rmse_e, energy.size), - "rmse_ea": (rmse_ea, energy.size), - "rmse_f": (rmse_f, force.size), - "rmse_v": (rmse_v, virial.size), - "rmse_va": (rmse_va, virial.size), - }, find_energy, find_force, find_virial + return ( + { + "mae_e": (mae_e, energy.size), + "mae_ea": (mae_ea, energy.size), + "mae_f": (mae_f, force.size), + "mae_v": (mae_v, virial.size), + "mae_va": (mae_va, virial.size), + "rmse_e": (rmse_e, energy.size), + "rmse_ea": (rmse_ea, energy.size), + "rmse_f": (rmse_f, force.size), + "rmse_v": (rmse_v, virial.size), + "rmse_va": (rmse_va, virial.size), + }, + find_energy, + find_force, + find_virial, + ) else: - return { - "mae_e": (mae_e, energy.size), - "mae_ea": (mae_ea, energy.size), - "mae_fr": (mae_fr, force_r.size), - "mae_fm": (mae_fm, force_m.size), - "mae_v": (mae_v, virial.size), - "mae_va": (mae_va, virial.size), - "rmse_e": (rmse_e, energy.size), - "rmse_ea": (rmse_ea, energy.size), - "rmse_fr": (rmse_fr, force_r.size), - "rmse_fm": (rmse_fm, force_m.size), - "rmse_v": (rmse_v, virial.size), - "rmse_va": (rmse_va, virial.size), - }, find_energy, find_force, find_virial + return ( + { + "mae_e": (mae_e, energy.size), + "mae_ea": (mae_ea, energy.size), + "mae_fr": (mae_fr, force_r.size), + "mae_fm": (mae_fm, force_m.size), + "mae_v": (mae_v, virial.size), + "mae_va": (mae_va, virial.size), + "rmse_e": (rmse_e, energy.size), + "rmse_ea": (rmse_ea, energy.size), + "rmse_fr": (rmse_fr, force_r.size), + "rmse_fm": (rmse_fm, force_m.size), + "rmse_v": (rmse_v, virial.size), + "rmse_va": (rmse_va, virial.size), + }, + find_energy, + find_force, + find_virial, + ) def print_ener_sys_avg(avg: dict[str, float]) -> None: diff --git a/source/tests/pt/test_weighted_avg.py b/source/tests/pt/test_weighted_avg.py index 8ca3c888a3..d48e391b4e 100644 --- a/source/tests/pt/test_weighted_avg.py +++ b/source/tests/pt/test_weighted_avg.py @@ -1,8 +1,12 @@ +# SPDX-License-Identifier: LGPL-3.0-or-later +import unittest + +import numpy as np + from deepmd.utils.weight_avg import ( weighted_average, ) -import unittest -import numpy as np + def test(all_sys): err_coll = [] @@ -10,26 +14,27 @@ def test(all_sys): err, find_energy, find_force, find_virial = sys_data err_part = {} if find_energy == 1: - err_part['mae_e'] = err['mae_e'] - err_part['mae_ea'] = err['mae_ea'] - err_part['rmse_e'] = err['rmse_e'] - err_part['rmse_ea'] = err['rmse_ea'] + err_part["mae_e"] = err["mae_e"] + err_part["mae_ea"] = err["mae_ea"] + err_part["rmse_e"] = err["rmse_e"] + err_part["rmse_ea"] = err["rmse_ea"] if find_force == 1: - if 'rmse_f' in err: - err_part['mae_f'] = err['mae_f'] - err_part['rmse_f'] = err['rmse_f'] + if "rmse_f" in err: + err_part["mae_f"] = err["mae_f"] + err_part["rmse_f"] = err["rmse_f"] else: - err_part['mae_fr'] = err['mae_fr'] - err_part['rmse_fr'] = err['rmse_fr'] - err_part['mae_fm'] = err['mae_fm'] - err_part['rmse_fm'] = err['rmse_fm'] + err_part["mae_fr"] = err["mae_fr"] + err_part["rmse_fr"] = err["rmse_fr"] + err_part["mae_fm"] = err["mae_fm"] + err_part["rmse_fm"] = err["rmse_fm"] if find_virial == 1: - err_part['mae_v'] = err['mae_v'] - err_part['rmse_v'] = err['rmse_v'] + err_part["mae_v"] = err["mae_v"] + err_part["rmse_v"] = err["rmse_v"] err_coll.append(err_part) avg_err = weighted_average(err_coll) return avg_err + def test_ori(all_sys): err_coll = [] for sys_data in all_sys: @@ -38,66 +43,190 @@ def test_ori(all_sys): avg_err = weighted_average(err_coll) return avg_err -class TestWeightedAverage(unittest.TestCase): +class TestWeightedAverage(unittest.TestCase): def test_case1_energy_only(self): - all_sys = [ - ({'mae_e': (2,2), 'mae_ea': (4,2), 'rmse_e': (3,2), 'rmse_ea': (5,2),'mae_f': (2,3), 'rmse_f': (1,3), 'mae_v': (3,5), 'rmse_v': (3,3)}, 1,0,0), - ({'mae_e': (4,3), 'mae_ea': (6,3), 'rmse_e': (5,3), 'rmse_ea': (7,3),'mae_f': (2,3), 'rmse_f': (1,3), 'mae_v': (3,5), 'rmse_v': (3,3)}, 1,0,0), - ({'mae_e': (6,5), 'mae_ea': (8,5), 'rmse_e': (7,5), 'rmse_ea': (9,5),'mae_f': (2,3), 'rmse_f': (1,3), 'mae_v': (3,5), 'rmse_v': (3,3)}, 1,0,0), + ( + { + "mae_e": (2, 2), + "mae_ea": (4, 2), + "rmse_e": (3, 2), + "rmse_ea": (5, 2), + "mae_f": (2, 3), + "rmse_f": (1, 3), + "mae_v": (3, 5), + "rmse_v": (3, 3), + }, + 1, + 0, + 0, + ), + ( + { + "mae_e": (4, 3), + "mae_ea": (6, 3), + "rmse_e": (5, 3), + "rmse_ea": (7, 3), + "mae_f": (2, 3), + "rmse_f": (1, 3), + "mae_v": (3, 5), + "rmse_v": (3, 3), + }, + 1, + 0, + 0, + ), + ( + { + "mae_e": (6, 5), + "mae_ea": (8, 5), + "rmse_e": (7, 5), + "rmse_ea": (9, 5), + "mae_f": (2, 3), + "rmse_f": (1, 3), + "mae_v": (3, 5), + "rmse_v": (3, 3), + }, + 1, + 0, + 0, + ), ] - expected_mae_e = (2*2 +4*3 +6*5)/(2+3+5) - expected_rmse_e = np.sqrt((3**2*2 +5**2*3 +7**2*5)/(2+3+5)) - expected_mae_ea = (4*2 +6*3 +8*5)/10 - expected_rmse_ea = np.sqrt((5**2*2 +7**2*3 +9**2*5)/10) - - avg_err = test(all_sys) - self.assertAlmostEqual(avg_err['mae_e'], expected_mae_e) - self.assertAlmostEqual(avg_err['rmse_e'], expected_rmse_e) - self.assertAlmostEqual(avg_err['mae_ea'], expected_mae_ea) - self.assertAlmostEqual(avg_err['rmse_ea'], expected_rmse_ea) - self.assertAlmostEqual(avg_err['mae_f'], 0) - self.assertAlmostEqual(avg_err['mae_v'], 0) - - avg_err_ori = test_ori(all_sys) - self.assertAlmostEqual(avg_err['mae_e'], avg_err_ori['mae_e']) - self.assertNotEqual(avg_err['mae_f'], avg_err_ori['rmse_f']) - self.assertNotEqual(avg_err['mae_v'], avg_err_ori['rmse_v']) + expected_mae_e = (2 * 2 + 4 * 3 + 6 * 5) / (2 + 3 + 5) + expected_rmse_e = np.sqrt((3**2 * 2 + 5**2 * 3 + 7**2 * 5) / (2 + 3 + 5)) + expected_mae_ea = (4 * 2 + 6 * 3 + 8 * 5) / 10 + expected_rmse_ea = np.sqrt((5**2 * 2 + 7**2 * 3 + 9**2 * 5) / 10) + avg_err = test(all_sys) + self.assertAlmostEqual(avg_err["mae_e"], expected_mae_e) + self.assertAlmostEqual(avg_err["rmse_e"], expected_rmse_e) + self.assertAlmostEqual(avg_err["mae_ea"], expected_mae_ea) + self.assertAlmostEqual(avg_err["rmse_ea"], expected_rmse_ea) + self.assertAlmostEqual(avg_err["mae_f"], 0) + self.assertAlmostEqual(avg_err["mae_v"], 0) + avg_err_ori = test_ori(all_sys) + self.assertAlmostEqual(avg_err["mae_e"], avg_err_ori["mae_e"]) + self.assertNotEqual(avg_err["mae_f"], avg_err_ori["rmse_f"]) + self.assertNotEqual(avg_err["mae_v"], avg_err_ori["rmse_v"]) def test_case2_energy_force(self): all_sys = [ - ({'mae_e': (2,2), 'mae_ea': (4,2), 'rmse_e': (3,2), 'rmse_ea': (5,2),'mae_f': (2,3), 'rmse_f': (1,3), 'mae_v': (3,5), 'rmse_v': (3,3)}, 1,1,0), - ({'mae_e': (4,3), 'mae_ea': (6,3), 'rmse_e': (5,3), 'rmse_ea': (7,3),'mae_f': (1,3), 'rmse_f': (1,3), 'mae_v': (3,5), 'rmse_v': (3,3)}, 1,1,0), - ({'mae_e': (6,5), 'mae_ea': (8,5), 'rmse_e': (7,5), 'rmse_ea': (9,5),'mae_f': (2,3), 'rmse_f': (1,3), 'mae_v': (3,5), 'rmse_v': (3,3)}, 1,0,0), + ( + { + "mae_e": (2, 2), + "mae_ea": (4, 2), + "rmse_e": (3, 2), + "rmse_ea": (5, 2), + "mae_f": (2, 3), + "rmse_f": (1, 3), + "mae_v": (3, 5), + "rmse_v": (3, 3), + }, + 1, + 1, + 0, + ), + ( + { + "mae_e": (4, 3), + "mae_ea": (6, 3), + "rmse_e": (5, 3), + "rmse_ea": (7, 3), + "mae_f": (1, 3), + "rmse_f": (1, 3), + "mae_v": (3, 5), + "rmse_v": (3, 3), + }, + 1, + 1, + 0, + ), + ( + { + "mae_e": (6, 5), + "mae_ea": (8, 5), + "rmse_e": (7, 5), + "rmse_ea": (9, 5), + "mae_f": (2, 3), + "rmse_f": (1, 3), + "mae_v": (3, 5), + "rmse_v": (3, 3), + }, + 1, + 0, + 0, + ), ] - + avg_err = test(all_sys) - expected_mae_f = (2*3 +1*3 )/(3+3) - self.assertAlmostEqual(avg_err['mae_f'], expected_mae_f) + expected_mae_f = (2 * 3 + 1 * 3) / (3 + 3) + self.assertAlmostEqual(avg_err["mae_f"], expected_mae_f) avg_err_ori = test_ori(all_sys) - self.assertAlmostEqual(avg_err['mae_e'], avg_err_ori['mae_e']) - self.assertNotEqual(avg_err['mae_f'], avg_err_ori['mae_f']) - self.assertNotEqual(avg_err['mae_v'], avg_err_ori['mae_v']) + self.assertAlmostEqual(avg_err["mae_e"], avg_err_ori["mae_e"]) + self.assertNotEqual(avg_err["mae_f"], avg_err_ori["mae_f"]) + self.assertNotEqual(avg_err["mae_v"], avg_err_ori["mae_v"]) def test_case3_all_components(self): all_sys = [ - ({'mae_e': (2,2), 'mae_ea': (4,2), 'rmse_e': (3,2), 'rmse_ea': (5,2),'mae_f': (2,3), 'rmse_f': (1,3), 'mae_v': (3,5), 'rmse_v': (3,3)}, 1,1,1), - ({'mae_e': (4,3), 'mae_ea': (6,3), 'rmse_e': (5,3), 'rmse_ea': (7,3),'mae_f': (2,3), 'rmse_f': (1,3), 'mae_v': (1,5), 'rmse_v': (2,3)}, 1,1,1), - ({'mae_e': (6,5), 'mae_ea': (8,5), 'rmse_e': (7,5), 'rmse_ea': (9,5),'mae_f': (2,3), 'rmse_f': (1,3), 'mae_v': (3,5), 'rmse_v': (3,3)}, 1,1,0), + ( + { + "mae_e": (2, 2), + "mae_ea": (4, 2), + "rmse_e": (3, 2), + "rmse_ea": (5, 2), + "mae_f": (2, 3), + "rmse_f": (1, 3), + "mae_v": (3, 5), + "rmse_v": (3, 3), + }, + 1, + 1, + 1, + ), + ( + { + "mae_e": (4, 3), + "mae_ea": (6, 3), + "rmse_e": (5, 3), + "rmse_ea": (7, 3), + "mae_f": (2, 3), + "rmse_f": (1, 3), + "mae_v": (1, 5), + "rmse_v": (2, 3), + }, + 1, + 1, + 1, + ), + ( + { + "mae_e": (6, 5), + "mae_ea": (8, 5), + "rmse_e": (7, 5), + "rmse_ea": (9, 5), + "mae_f": (2, 3), + "rmse_f": (1, 3), + "mae_v": (3, 5), + "rmse_v": (3, 3), + }, + 1, + 1, + 0, + ), ] - + avg_err = test(all_sys) - expected_mae_v = (3*5 +1*5 )/(5+5) - self.assertAlmostEqual(avg_err['mae_v'], expected_mae_v) + expected_mae_v = (3 * 5 + 1 * 5) / (5 + 5) + self.assertAlmostEqual(avg_err["mae_v"], expected_mae_v) avg_err_ori = test_ori(all_sys) - self.assertAlmostEqual(avg_err['mae_e'], avg_err_ori['mae_e']) - self.assertAlmostEqual(avg_err['mae_f'], avg_err_ori['mae_f']) - self.assertNotEqual(avg_err['mae_v'], avg_err_ori['rmse_v']) + self.assertAlmostEqual(avg_err["mae_e"], avg_err_ori["mae_e"]) + self.assertAlmostEqual(avg_err["mae_f"], avg_err_ori["mae_f"]) + self.assertNotEqual(avg_err["mae_v"], avg_err_ori["rmse_v"]) + -if __name__ == '__main__': - unittest.main() \ No newline at end of file +if __name__ == "__main__": + unittest.main() From bdc260a5d4d81a193eb77156ebbf74fcf8698b82 Mon Sep 17 00:00:00 2001 From: sum Date: Tue, 11 Feb 2025 09:08:18 +0800 Subject: [PATCH 03/11] fix ut bug (make the def name not start with 'test' --- source/tests/pt/test_weighted_avg.py | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/source/tests/pt/test_weighted_avg.py b/source/tests/pt/test_weighted_avg.py index 8ca3c888a3..d9dd465968 100644 --- a/source/tests/pt/test_weighted_avg.py +++ b/source/tests/pt/test_weighted_avg.py @@ -4,7 +4,7 @@ import unittest import numpy as np -def test(all_sys): +def fake_test(all_sys): err_coll = [] for sys_data in all_sys: err, find_energy, find_force, find_virial = sys_data @@ -30,7 +30,7 @@ def test(all_sys): avg_err = weighted_average(err_coll) return avg_err -def test_ori(all_sys): +def fake_test_ori(all_sys): err_coll = [] for sys_data in all_sys: err, _, _, _ = sys_data @@ -52,7 +52,7 @@ def test_case1_energy_only(self): expected_mae_ea = (4*2 +6*3 +8*5)/10 expected_rmse_ea = np.sqrt((5**2*2 +7**2*3 +9**2*5)/10) - avg_err = test(all_sys) + avg_err = fake_test(all_sys) self.assertAlmostEqual(avg_err['mae_e'], expected_mae_e) self.assertAlmostEqual(avg_err['rmse_e'], expected_rmse_e) self.assertAlmostEqual(avg_err['mae_ea'], expected_mae_ea) @@ -60,7 +60,7 @@ def test_case1_energy_only(self): self.assertAlmostEqual(avg_err['mae_f'], 0) self.assertAlmostEqual(avg_err['mae_v'], 0) - avg_err_ori = test_ori(all_sys) + avg_err_ori = fake_test_ori(all_sys) self.assertAlmostEqual(avg_err['mae_e'], avg_err_ori['mae_e']) self.assertNotEqual(avg_err['mae_f'], avg_err_ori['rmse_f']) self.assertNotEqual(avg_err['mae_v'], avg_err_ori['rmse_v']) @@ -74,11 +74,11 @@ def test_case2_energy_force(self): ({'mae_e': (6,5), 'mae_ea': (8,5), 'rmse_e': (7,5), 'rmse_ea': (9,5),'mae_f': (2,3), 'rmse_f': (1,3), 'mae_v': (3,5), 'rmse_v': (3,3)}, 1,0,0), ] - avg_err = test(all_sys) + avg_err = fake_test(all_sys) expected_mae_f = (2*3 +1*3 )/(3+3) self.assertAlmostEqual(avg_err['mae_f'], expected_mae_f) - avg_err_ori = test_ori(all_sys) + avg_err_ori = fake_test_ori(all_sys) self.assertAlmostEqual(avg_err['mae_e'], avg_err_ori['mae_e']) self.assertNotEqual(avg_err['mae_f'], avg_err_ori['mae_f']) self.assertNotEqual(avg_err['mae_v'], avg_err_ori['mae_v']) @@ -90,11 +90,11 @@ def test_case3_all_components(self): ({'mae_e': (6,5), 'mae_ea': (8,5), 'rmse_e': (7,5), 'rmse_ea': (9,5),'mae_f': (2,3), 'rmse_f': (1,3), 'mae_v': (3,5), 'rmse_v': (3,3)}, 1,1,0), ] - avg_err = test(all_sys) + avg_err = fake_test(all_sys) expected_mae_v = (3*5 +1*5 )/(5+5) self.assertAlmostEqual(avg_err['mae_v'], expected_mae_v) - avg_err_ori = test_ori(all_sys) + avg_err_ori = fake_test_ori(all_sys) self.assertAlmostEqual(avg_err['mae_e'], avg_err_ori['mae_e']) self.assertAlmostEqual(avg_err['mae_f'], avg_err_ori['mae_f']) self.assertNotEqual(avg_err['mae_v'], avg_err_ori['rmse_v']) From 7d137d62317b4a19bcd3407d91e21de29392fbf3 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Tue, 11 Feb 2025 01:10:54 +0000 Subject: [PATCH 04/11] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- source/tests/pt/test_weighted_avg.py | 58 ++++++++++++++-------------- 1 file changed, 29 insertions(+), 29 deletions(-) diff --git a/source/tests/pt/test_weighted_avg.py b/source/tests/pt/test_weighted_avg.py index 9b28f78811..39c78c6200 100644 --- a/source/tests/pt/test_weighted_avg.py +++ b/source/tests/pt/test_weighted_avg.py @@ -34,6 +34,7 @@ def fake_test(all_sys): avg_err = weighted_average(err_coll) return avg_err + def fake_test_ori(all_sys): err_coll = [] for sys_data in all_sys: @@ -92,25 +93,23 @@ def test_case1_energy_only(self): 0, ), ] - expected_mae_e = (2*2 +4*3 +6*5)/(2+3+5) - expected_rmse_e = np.sqrt((3**2*2 +5**2*3 +7**2*5)/(2+3+5)) - expected_mae_ea = (4*2 +6*3 +8*5)/10 - expected_rmse_ea = np.sqrt((5**2*2 +7**2*3 +9**2*5)/10) - - avg_err = fake_test(all_sys) - self.assertAlmostEqual(avg_err['mae_e'], expected_mae_e) - self.assertAlmostEqual(avg_err['rmse_e'], expected_rmse_e) - self.assertAlmostEqual(avg_err['mae_ea'], expected_mae_ea) - self.assertAlmostEqual(avg_err['rmse_ea'], expected_rmse_ea) - self.assertAlmostEqual(avg_err['mae_f'], 0) - self.assertAlmostEqual(avg_err['mae_v'], 0) - - avg_err_ori = fake_test_ori(all_sys) - self.assertAlmostEqual(avg_err['mae_e'], avg_err_ori['mae_e']) - self.assertNotEqual(avg_err['mae_f'], avg_err_ori['rmse_f']) - self.assertNotEqual(avg_err['mae_v'], avg_err_ori['rmse_v']) + expected_mae_e = (2 * 2 + 4 * 3 + 6 * 5) / (2 + 3 + 5) + expected_rmse_e = np.sqrt((3**2 * 2 + 5**2 * 3 + 7**2 * 5) / (2 + 3 + 5)) + expected_mae_ea = (4 * 2 + 6 * 3 + 8 * 5) / 10 + expected_rmse_ea = np.sqrt((5**2 * 2 + 7**2 * 3 + 9**2 * 5) / 10) + avg_err = fake_test(all_sys) + self.assertAlmostEqual(avg_err["mae_e"], expected_mae_e) + self.assertAlmostEqual(avg_err["rmse_e"], expected_rmse_e) + self.assertAlmostEqual(avg_err["mae_ea"], expected_mae_ea) + self.assertAlmostEqual(avg_err["rmse_ea"], expected_rmse_ea) + self.assertAlmostEqual(avg_err["mae_f"], 0) + self.assertAlmostEqual(avg_err["mae_v"], 0) + avg_err_ori = fake_test_ori(all_sys) + self.assertAlmostEqual(avg_err["mae_e"], avg_err_ori["mae_e"]) + self.assertNotEqual(avg_err["mae_f"], avg_err_ori["rmse_f"]) + self.assertNotEqual(avg_err["mae_v"], avg_err_ori["rmse_v"]) def test_case2_energy_force(self): all_sys = [ @@ -160,15 +159,15 @@ def test_case2_energy_force(self): 0, ), ] - + avg_err = fake_test(all_sys) - expected_mae_f = (2*3 +1*3 )/(3+3) - self.assertAlmostEqual(avg_err['mae_f'], expected_mae_f) + expected_mae_f = (2 * 3 + 1 * 3) / (3 + 3) + self.assertAlmostEqual(avg_err["mae_f"], expected_mae_f) avg_err_ori = fake_test_ori(all_sys) - self.assertAlmostEqual(avg_err['mae_e'], avg_err_ori['mae_e']) - self.assertNotEqual(avg_err['mae_f'], avg_err_ori['mae_f']) - self.assertNotEqual(avg_err['mae_v'], avg_err_ori['mae_v']) + self.assertAlmostEqual(avg_err["mae_e"], avg_err_ori["mae_e"]) + self.assertNotEqual(avg_err["mae_f"], avg_err_ori["mae_f"]) + self.assertNotEqual(avg_err["mae_v"], avg_err_ori["mae_v"]) def test_case3_all_components(self): all_sys = [ @@ -218,15 +217,16 @@ def test_case3_all_components(self): 0, ), ] - + avg_err = fake_test(all_sys) - expected_mae_v = (3*5 +1*5 )/(5+5) - self.assertAlmostEqual(avg_err['mae_v'], expected_mae_v) + expected_mae_v = (3 * 5 + 1 * 5) / (5 + 5) + self.assertAlmostEqual(avg_err["mae_v"], expected_mae_v) avg_err_ori = fake_test_ori(all_sys) - self.assertAlmostEqual(avg_err['mae_e'], avg_err_ori['mae_e']) - self.assertAlmostEqual(avg_err['mae_f'], avg_err_ori['mae_f']) - self.assertNotEqual(avg_err['mae_v'], avg_err_ori['rmse_v']) + self.assertAlmostEqual(avg_err["mae_e"], avg_err_ori["mae_e"]) + self.assertAlmostEqual(avg_err["mae_f"], avg_err_ori["mae_f"]) + self.assertNotEqual(avg_err["mae_v"], avg_err_ori["rmse_v"]) + if __name__ == "__main__": unittest.main() From 8ab5ab9ef44d66d1f3db9f826117dd30bb2b75a0 Mon Sep 17 00:00:00 2001 From: sum Date: Tue, 11 Feb 2025 09:11:00 +0800 Subject: [PATCH 05/11] Make code simple --- source/tests/pt/test_weighted_avg.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/source/tests/pt/test_weighted_avg.py b/source/tests/pt/test_weighted_avg.py index 9b28f78811..2203aa4bcc 100644 --- a/source/tests/pt/test_weighted_avg.py +++ b/source/tests/pt/test_weighted_avg.py @@ -42,7 +42,6 @@ def fake_test_ori(all_sys): avg_err = weighted_average(err_coll) return avg_err - class TestWeightedAverage(unittest.TestCase): def test_case1_energy_only(self): all_sys = [ @@ -110,8 +109,6 @@ def test_case1_energy_only(self): self.assertNotEqual(avg_err['mae_f'], avg_err_ori['rmse_f']) self.assertNotEqual(avg_err['mae_v'], avg_err_ori['rmse_v']) - - def test_case2_energy_force(self): all_sys = [ ( From db637f99df366930081a5622cbd89d4b4ef32ced Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Tue, 11 Feb 2025 01:14:04 +0000 Subject: [PATCH 06/11] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- source/tests/pt/test_weighted_avg.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/source/tests/pt/test_weighted_avg.py b/source/tests/pt/test_weighted_avg.py index 95425989b9..39c78c6200 100644 --- a/source/tests/pt/test_weighted_avg.py +++ b/source/tests/pt/test_weighted_avg.py @@ -43,6 +43,7 @@ def fake_test_ori(all_sys): avg_err = weighted_average(err_coll) return avg_err + class TestWeightedAverage(unittest.TestCase): def test_case1_energy_only(self): all_sys = [ @@ -106,9 +107,9 @@ def test_case1_energy_only(self): self.assertAlmostEqual(avg_err["mae_v"], 0) avg_err_ori = fake_test_ori(all_sys) - self.assertAlmostEqual(avg_err['mae_e'], avg_err_ori['mae_e']) - self.assertNotEqual(avg_err['mae_f'], avg_err_ori['rmse_f']) - self.assertNotEqual(avg_err['mae_v'], avg_err_ori['rmse_v']) + self.assertAlmostEqual(avg_err["mae_e"], avg_err_ori["mae_e"]) + self.assertNotEqual(avg_err["mae_f"], avg_err_ori["rmse_f"]) + self.assertNotEqual(avg_err["mae_v"], avg_err_ori["rmse_v"]) def test_case2_energy_force(self): all_sys = [ From fa0aa4fc3de084d7723a5b991f1e5563ab760fba Mon Sep 17 00:00:00 2001 From: sum Date: Wed, 12 Feb 2025 10:58:12 +0800 Subject: [PATCH 07/11] check change --- deepmd/entrypoints/test.py | 57 +++++++++++++++++--------------------- 1 file changed, 26 insertions(+), 31 deletions(-) diff --git a/deepmd/entrypoints/test.py b/deepmd/entrypoints/test.py index 565ec3303e..521bc0cc18 100644 --- a/deepmd/entrypoints/test.py +++ b/deepmd/entrypoints/test.py @@ -134,7 +134,8 @@ def test( ) if isinstance(dp, DeepPot): - err, find_energy, find_force, find_virial = test_ener( + #err, find_energy, find_force, find_virial = test_ener( + err = test_ener( dp, data, system, @@ -143,28 +144,28 @@ def test( atomic, append_detail=(cc != 0), ) - err_part = {} - - if find_energy == 1: - err_part["mae_e"] = err["mae_e"] - err_part["mae_ea"] = err["mae_ea"] - err_part["rmse_e"] = err["rmse_e"] - err_part["rmse_ea"] = err["rmse_ea"] - - if find_force == 1: - if "rmse_f" in err: - err_part["mae_f"] = err["mae_f"] - err_part["rmse_f"] = err["rmse_f"] - else: - err_part["mae_fr"] = err["mae_fr"] - err_part["rmse_fr"] = err["rmse_fr"] - err_part["mae_fm"] = err["mae_fm"] - err_part["rmse_fm"] = err["rmse_fm"] - if find_virial == 1: - err_part["mae_v"] = err["mae_v"] - err_part["rmse_v"] = err["rmse_v"] - - err = err_part + # err_part = {} + + # if find_energy == 1: + # err_part["mae_e"] = err["mae_e"] + # err_part["mae_ea"] = err["mae_ea"] + # err_part["rmse_e"] = err["rmse_e"] + # err_part["rmse_ea"] = err["rmse_ea"] + + # if find_force == 1: + # if "rmse_f" in err: + # err_part["mae_f"] = err["mae_f"] + # err_part["rmse_f"] = err["rmse_f"] + # else: + # err_part["mae_fr"] = err["mae_fr"] + # err_part["rmse_fr"] = err["rmse_fr"] + # err_part["mae_fm"] = err["mae_fm"] + # err_part["rmse_fm"] = err["rmse_fm"] + # if find_virial == 1: + # err_part["mae_v"] = err["mae_v"] + # err_part["rmse_v"] = err["rmse_v"] + + # err = err_part elif isinstance(dp, DeepDOS): err = test_dos( @@ -570,10 +571,7 @@ def test_ener( "rmse_f": (rmse_f, force.size), "rmse_v": (rmse_v, virial.size), "rmse_va": (rmse_va, virial.size), - }, - find_energy, - find_force, - find_virial, + }#find_energy,find_force,find_virial, ) else: return ( @@ -590,10 +588,7 @@ def test_ener( "rmse_fm": (rmse_fm, force_m.size), "rmse_v": (rmse_v, virial.size), "rmse_va": (rmse_va, virial.size), - }, - find_energy, - find_force, - find_virial, + }#find_energy,find_force,find_virial, ) From d2c9c4bbbf3346e4aae65c4a200f011503d9b866 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Wed, 12 Feb 2025 03:00:05 +0000 Subject: [PATCH 08/11] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- deepmd/entrypoints/test.py | 58 ++++++++++++++++++-------------------- 1 file changed, 27 insertions(+), 31 deletions(-) diff --git a/deepmd/entrypoints/test.py b/deepmd/entrypoints/test.py index 521bc0cc18..c3aa5d5bbf 100644 --- a/deepmd/entrypoints/test.py +++ b/deepmd/entrypoints/test.py @@ -134,7 +134,7 @@ def test( ) if isinstance(dp, DeepPot): - #err, find_energy, find_force, find_virial = test_ener( + # err, find_energy, find_force, find_virial = test_ener( err = test_ener( dp, data, @@ -559,37 +559,33 @@ def test_ener( append=append_detail, ) if not out_put_spin: - return ( - { - "mae_e": (mae_e, energy.size), - "mae_ea": (mae_ea, energy.size), - "mae_f": (mae_f, force.size), - "mae_v": (mae_v, virial.size), - "mae_va": (mae_va, virial.size), - "rmse_e": (rmse_e, energy.size), - "rmse_ea": (rmse_ea, energy.size), - "rmse_f": (rmse_f, force.size), - "rmse_v": (rmse_v, virial.size), - "rmse_va": (rmse_va, virial.size), - }#find_energy,find_force,find_virial, - ) + return { + "mae_e": (mae_e, energy.size), + "mae_ea": (mae_ea, energy.size), + "mae_f": (mae_f, force.size), + "mae_v": (mae_v, virial.size), + "mae_va": (mae_va, virial.size), + "rmse_e": (rmse_e, energy.size), + "rmse_ea": (rmse_ea, energy.size), + "rmse_f": (rmse_f, force.size), + "rmse_v": (rmse_v, virial.size), + "rmse_va": (rmse_va, virial.size), + } # find_energy,find_force,find_virial, else: - return ( - { - "mae_e": (mae_e, energy.size), - "mae_ea": (mae_ea, energy.size), - "mae_fr": (mae_fr, force_r.size), - "mae_fm": (mae_fm, force_m.size), - "mae_v": (mae_v, virial.size), - "mae_va": (mae_va, virial.size), - "rmse_e": (rmse_e, energy.size), - "rmse_ea": (rmse_ea, energy.size), - "rmse_fr": (rmse_fr, force_r.size), - "rmse_fm": (rmse_fm, force_m.size), - "rmse_v": (rmse_v, virial.size), - "rmse_va": (rmse_va, virial.size), - }#find_energy,find_force,find_virial, - ) + return { + "mae_e": (mae_e, energy.size), + "mae_ea": (mae_ea, energy.size), + "mae_fr": (mae_fr, force_r.size), + "mae_fm": (mae_fm, force_m.size), + "mae_v": (mae_v, virial.size), + "mae_va": (mae_va, virial.size), + "rmse_e": (rmse_e, energy.size), + "rmse_ea": (rmse_ea, energy.size), + "rmse_fr": (rmse_fr, force_r.size), + "rmse_fm": (rmse_fm, force_m.size), + "rmse_v": (rmse_v, virial.size), + "rmse_va": (rmse_va, virial.size), + } # find_energy,find_force,find_virial, def print_ener_sys_avg(avg: dict[str, float]) -> None: From 99d69426f518e9d619fa60e95eaadc53f412c953 Mon Sep 17 00:00:00 2001 From: sum Date: Wed, 12 Feb 2025 13:56:57 +0800 Subject: [PATCH 09/11] reverse --- deepmd/entrypoints/test.py | 51 +++++++++++++++++++------------------- 1 file changed, 25 insertions(+), 26 deletions(-) diff --git a/deepmd/entrypoints/test.py b/deepmd/entrypoints/test.py index c3aa5d5bbf..a2f435e933 100644 --- a/deepmd/entrypoints/test.py +++ b/deepmd/entrypoints/test.py @@ -134,8 +134,7 @@ def test( ) if isinstance(dp, DeepPot): - # err, find_energy, find_force, find_virial = test_ener( - err = test_ener( + err, find_energy, find_force, find_virial = test_ener( dp, data, system, @@ -144,28 +143,28 @@ def test( atomic, append_detail=(cc != 0), ) - # err_part = {} - - # if find_energy == 1: - # err_part["mae_e"] = err["mae_e"] - # err_part["mae_ea"] = err["mae_ea"] - # err_part["rmse_e"] = err["rmse_e"] - # err_part["rmse_ea"] = err["rmse_ea"] - - # if find_force == 1: - # if "rmse_f" in err: - # err_part["mae_f"] = err["mae_f"] - # err_part["rmse_f"] = err["rmse_f"] - # else: - # err_part["mae_fr"] = err["mae_fr"] - # err_part["rmse_fr"] = err["rmse_fr"] - # err_part["mae_fm"] = err["mae_fm"] - # err_part["rmse_fm"] = err["rmse_fm"] - # if find_virial == 1: - # err_part["mae_v"] = err["mae_v"] - # err_part["rmse_v"] = err["rmse_v"] - - # err = err_part + err_part = {} + + if find_energy == 1: + err_part["mae_e"] = err["mae_e"] + err_part["mae_ea"] = err["mae_ea"] + err_part["rmse_e"] = err["rmse_e"] + err_part["rmse_ea"] = err["rmse_ea"] + + if find_force == 1: + if "rmse_f" in err: + err_part["mae_f"] = err["mae_f"] + err_part["rmse_f"] = err["rmse_f"] + else: + err_part["mae_fr"] = err["mae_fr"] + err_part["rmse_fr"] = err["rmse_fr"] + err_part["mae_fm"] = err["mae_fm"] + err_part["rmse_fm"] = err["rmse_fm"] + if find_virial == 1: + err_part["mae_v"] = err["mae_v"] + err_part["rmse_v"] = err["rmse_v"] + + err = err_part elif isinstance(dp, DeepDOS): err = test_dos( @@ -570,7 +569,7 @@ def test_ener( "rmse_f": (rmse_f, force.size), "rmse_v": (rmse_v, virial.size), "rmse_va": (rmse_va, virial.size), - } # find_energy,find_force,find_virial, + } ,find_energy,find_force,find_virial, else: return { "mae_e": (mae_e, energy.size), @@ -585,7 +584,7 @@ def test_ener( "rmse_fm": (rmse_fm, force_m.size), "rmse_v": (rmse_v, virial.size), "rmse_va": (rmse_va, virial.size), - } # find_energy,find_force,find_virial, + } ,find_energy,find_force,find_virial, def print_ener_sys_avg(avg: dict[str, float]) -> None: From 984a78ea38284ce47e7a772a25c5ef7b026747fc Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Wed, 12 Feb 2025 05:58:50 +0000 Subject: [PATCH 10/11] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- deepmd/entrypoints/test.py | 62 ++++++++++++++++++++++---------------- 1 file changed, 36 insertions(+), 26 deletions(-) diff --git a/deepmd/entrypoints/test.py b/deepmd/entrypoints/test.py index a2f435e933..565ec3303e 100644 --- a/deepmd/entrypoints/test.py +++ b/deepmd/entrypoints/test.py @@ -558,33 +558,43 @@ def test_ener( append=append_detail, ) if not out_put_spin: - return { - "mae_e": (mae_e, energy.size), - "mae_ea": (mae_ea, energy.size), - "mae_f": (mae_f, force.size), - "mae_v": (mae_v, virial.size), - "mae_va": (mae_va, virial.size), - "rmse_e": (rmse_e, energy.size), - "rmse_ea": (rmse_ea, energy.size), - "rmse_f": (rmse_f, force.size), - "rmse_v": (rmse_v, virial.size), - "rmse_va": (rmse_va, virial.size), - } ,find_energy,find_force,find_virial, + return ( + { + "mae_e": (mae_e, energy.size), + "mae_ea": (mae_ea, energy.size), + "mae_f": (mae_f, force.size), + "mae_v": (mae_v, virial.size), + "mae_va": (mae_va, virial.size), + "rmse_e": (rmse_e, energy.size), + "rmse_ea": (rmse_ea, energy.size), + "rmse_f": (rmse_f, force.size), + "rmse_v": (rmse_v, virial.size), + "rmse_va": (rmse_va, virial.size), + }, + find_energy, + find_force, + find_virial, + ) else: - return { - "mae_e": (mae_e, energy.size), - "mae_ea": (mae_ea, energy.size), - "mae_fr": (mae_fr, force_r.size), - "mae_fm": (mae_fm, force_m.size), - "mae_v": (mae_v, virial.size), - "mae_va": (mae_va, virial.size), - "rmse_e": (rmse_e, energy.size), - "rmse_ea": (rmse_ea, energy.size), - "rmse_fr": (rmse_fr, force_r.size), - "rmse_fm": (rmse_fm, force_m.size), - "rmse_v": (rmse_v, virial.size), - "rmse_va": (rmse_va, virial.size), - } ,find_energy,find_force,find_virial, + return ( + { + "mae_e": (mae_e, energy.size), + "mae_ea": (mae_ea, energy.size), + "mae_fr": (mae_fr, force_r.size), + "mae_fm": (mae_fm, force_m.size), + "mae_v": (mae_v, virial.size), + "mae_va": (mae_va, virial.size), + "rmse_e": (rmse_e, energy.size), + "rmse_ea": (rmse_ea, energy.size), + "rmse_fr": (rmse_fr, force_r.size), + "rmse_fm": (rmse_fm, force_m.size), + "rmse_v": (rmse_v, virial.size), + "rmse_va": (rmse_va, virial.size), + }, + find_energy, + find_force, + find_virial, + ) def print_ener_sys_avg(avg: dict[str, float]) -> None: From 603b6f2ea1e22d90aca0c15101e4d64033395161 Mon Sep 17 00:00:00 2001 From: sum Date: Wed, 12 Feb 2025 14:05:37 +0800 Subject: [PATCH 11/11] reverse2 --- deepmd/entrypoints/test.py | 96 +++++++++++++++++++++++++++----------- 1 file changed, 69 insertions(+), 27 deletions(-) diff --git a/deepmd/entrypoints/test.py b/deepmd/entrypoints/test.py index a2f435e933..91de39f24c 100644 --- a/deepmd/entrypoints/test.py +++ b/deepmd/entrypoints/test.py @@ -326,6 +326,8 @@ def test_ener( if dp.has_spin: data.add("spin", 3, atomic=True, must=True, high_prec=False) data.add("force_mag", 3, atomic=True, must=False, high_prec=False) + if dp.has_hessian: + data.add("hessian", 1, atomic=True, must=True, high_prec=False) test_data = data.get_test() find_energy = test_data.get("find_energy") @@ -378,6 +380,9 @@ def test_ener( energy = energy.reshape([numb_test, 1]) force = force.reshape([numb_test, -1]) virial = virial.reshape([numb_test, 9]) + if dp.has_hessian: + hessian = ret[3] + hessian = hessian.reshape([numb_test, -1]) if has_atom_ener: ae = ret[3] av = ret[4] @@ -441,6 +446,10 @@ def test_ener( rmse_ea = rmse_e / natoms mae_va = mae_v / natoms rmse_va = rmse_v / natoms + if dp.has_hessian: + diff_h = hessian - test_data["hessian"][:numb_test] + mae_h = mae(diff_h) + rmse_h = rmse(diff_h) if has_atom_ener: diff_ae = test_data["atom_ener"][:numb_test].reshape([-1]) - ae.reshape([-1]) mae_ae = mae(diff_ae) @@ -456,15 +465,14 @@ def test_ener( log.info(f"Energy RMSE : {rmse_e:e} eV") log.info(f"Energy MAE/Natoms : {mae_ea:e} eV") log.info(f"Energy RMSE/Natoms : {rmse_ea:e} eV") - if find_force == 1: - if not out_put_spin: - log.info(f"Force MAE : {mae_f:e} eV/A") - log.info(f"Force RMSE : {rmse_f:e} eV/A") - else: - log.info(f"Force atom MAE : {mae_fr:e} eV/A") - log.info(f"Force atom RMSE : {rmse_fr:e} eV/A") - log.info(f"Force spin MAE : {mae_fm:e} eV/uB") - log.info(f"Force spin RMSE : {rmse_fm:e} eV/uB") + if not out_put_spin: + log.info(f"Force MAE : {mae_f:e} eV/A") + log.info(f"Force RMSE : {rmse_f:e} eV/A") + else: + log.info(f"Force atom MAE : {mae_fr:e} eV/A") + log.info(f"Force atom RMSE : {rmse_fr:e} eV/A") + log.info(f"Force spin MAE : {mae_fm:e} eV/uB") + log.info(f"Force spin RMSE : {rmse_fm:e} eV/uB") if data.pbc and not out_put_spin and find_virial == 1: log.info(f"Virial MAE : {mae_v:e} eV") @@ -474,6 +482,9 @@ def test_ener( if has_atom_ener: log.info(f"Atomic ener MAE : {mae_ae:e} eV") log.info(f"Atomic ener RMSE : {rmse_ae:e} eV") + if dp.has_hessian: + log.info(f"Hessian MAE : {mae_h:e} eV/A^2") + log.info(f"Hessian RMSE : {rmse_h:e} eV/A^2") if detail_file is not None: detail_path = Path(detail_file) @@ -557,8 +568,24 @@ def test_ener( "pred_vyy pred_vyz pred_vzx pred_vzy pred_vzz", append=append_detail, ) + if dp.has_hessian: + data_h = test_data["hessian"][:numb_test].reshape(-1, 1) + pred_h = hessian.reshape(-1, 1) + h = np.concatenate( + ( + data_h, + pred_h, + ), + axis=1, + ) + save_txt_file( + detail_path.with_suffix(".h.out"), + h, + header=f"{system}: data_h pred_h (3Na*3Na matrix in row-major order)", + append=append_detail, + ) if not out_put_spin: - return { + dict_to_return = { "mae_e": (mae_e, energy.size), "mae_ea": (mae_ea, energy.size), "mae_f": (mae_f, force.size), @@ -569,9 +596,9 @@ def test_ener( "rmse_f": (rmse_f, force.size), "rmse_v": (rmse_v, virial.size), "rmse_va": (rmse_va, virial.size), - } ,find_energy,find_force,find_virial, + },find_energy,find_force,find_virial else: - return { + dict_to_return = { "mae_e": (mae_e, energy.size), "mae_ea": (mae_ea, energy.size), "mae_fr": (mae_fr, force_r.size), @@ -584,7 +611,11 @@ def test_ener( "rmse_fm": (rmse_fm, force_m.size), "rmse_v": (rmse_v, virial.size), "rmse_va": (rmse_va, virial.size), - } ,find_energy,find_force,find_virial, + },find_energy,find_force,find_virial + if dp.has_hessian: + dict_to_return["mae_h"] = (mae_h, hessian.size) + dict_to_return["rmse_h"] = (rmse_h, hessian.size) + return dict_to_return def print_ener_sys_avg(avg: dict[str, float]) -> None: @@ -611,6 +642,9 @@ def print_ener_sys_avg(avg: dict[str, float]) -> None: log.info(f"Virial RMSE : {avg['rmse_v']:e} eV") log.info(f"Virial MAE/Natoms : {avg['mae_va']:e} eV") log.info(f"Virial RMSE/Natoms : {avg['rmse_va']:e} eV") + if "rmse_h" in avg.keys(): + log.info(f"Hessian MAE : {avg['mae_h']:e} eV/A^2") + log.info(f"Hessian RMSE : {avg['rmse_h']:e} eV/A^2") def test_dos( @@ -731,9 +765,9 @@ def test_dos( frame_output = np.hstack((test_out, pred_out)) save_txt_file( - detail_path.with_suffix(".dos.out.%.d" % ii), + detail_path.with_suffix(f".dos.out.{ii}"), frame_output, - header="%s - %.d: data_dos pred_dos" % (system, ii), + header=f"{system} - {ii}: data_dos pred_dos", append=append_detail, ) @@ -745,9 +779,9 @@ def test_dos( frame_output = np.hstack((test_out, pred_out)) save_txt_file( - detail_path.with_suffix(".ados.out.%.d" % ii), + detail_path.with_suffix(f".ados.out.{ii}"), frame_output, - header="%s - %.d: data_ados pred_ados" % (system, ii), + header=f"{system} - {ii}: data_ados pred_ados", append=append_detail, ) @@ -806,9 +840,17 @@ def test_property( tuple[list[np.ndarray], list[int]] arrays with results and their shapes """ - data.add("property", dp.task_dim, atomic=False, must=True, high_prec=True) + var_name = dp.get_var_name() + assert isinstance(var_name, str) + data.add(var_name, dp.task_dim, atomic=False, must=True, high_prec=True) if has_atom_property: - data.add("atom_property", dp.task_dim, atomic=True, must=False, high_prec=True) + data.add( + f"atom_{var_name}", + dp.task_dim, + atomic=True, + must=False, + high_prec=True, + ) if dp.get_dim_fparam() > 0: data.add( @@ -859,12 +901,12 @@ def test_property( aproperty = ret[1] aproperty = aproperty.reshape([numb_test, natoms * dp.task_dim]) - diff_property = property - test_data["property"][:numb_test] + diff_property = property - test_data[var_name][:numb_test] mae_property = mae(diff_property) rmse_property = rmse(diff_property) if has_atom_property: - diff_aproperty = aproperty - test_data["atom_property"][:numb_test] + diff_aproperty = aproperty - test_data[f"atom_{var_name}"][:numb_test] mae_aproperty = mae(diff_aproperty) rmse_aproperty = rmse(diff_aproperty) @@ -881,29 +923,29 @@ def test_property( detail_path = Path(detail_file) for ii in range(numb_test): - test_out = test_data["property"][ii].reshape(-1, 1) + test_out = test_data[var_name][ii].reshape(-1, 1) pred_out = property[ii].reshape(-1, 1) frame_output = np.hstack((test_out, pred_out)) save_txt_file( - detail_path.with_suffix(".property.out.%.d" % ii), + detail_path.with_suffix(f".property.out.{ii}"), frame_output, - header="%s - %.d: data_property pred_property" % (system, ii), + header=f"{system} - {ii}: data_property pred_property", append=append_detail, ) if has_atom_property: for ii in range(numb_test): - test_out = test_data["atom_property"][ii].reshape(-1, 1) + test_out = test_data[f"atom_{var_name}"][ii].reshape(-1, 1) pred_out = aproperty[ii].reshape(-1, 1) frame_output = np.hstack((test_out, pred_out)) save_txt_file( - detail_path.with_suffix(".aproperty.out.%.d" % ii), + detail_path.with_suffix(f".aproperty.out.{ii}"), frame_output, - header="%s - %.d: data_aproperty pred_aproperty" % (system, ii), + header=f"{system} - {ii}: data_aproperty pred_aproperty", append=append_detail, )