From dd3842da17b990d0a3f53c3aad154b83d5143c31 Mon Sep 17 00:00:00 2001 From: Jinzhe Zeng Date: Tue, 29 Aug 2023 08:48:18 -0400 Subject: [PATCH 1/3] fix dp test atomic polar; add UTs for dp test Signed-off-by: Jinzhe Zeng --- deepmd/entrypoints/test.py | 66 ++++++-- source/tests/test_dp_test.py | 308 +++++++++++++++++++++++++++++++++++ 2 files changed, 364 insertions(+), 10 deletions(-) create mode 100644 source/tests/test_dp_test.py diff --git a/deepmd/entrypoints/test.py b/deepmd/entrypoints/test.py index e348318f41..f79ae158b0 100644 --- a/deepmd/entrypoints/test.py +++ b/deepmd/entrypoints/test.py @@ -848,19 +848,65 @@ def test_polar( if detail_file is not None: detail_path = Path(detail_file) - pe = np.concatenate( - ( - np.reshape(test_data["polarizability"][:numb_test], [-1, 9]), - np.reshape(polar, [-1, 9]), - ), - axis=1, - ) + if not atomic: + pe = np.concatenate( + ( + np.reshape(test_data["polarizability"][:numb_test], [-1, 9]), + np.reshape(polar, [-1, 3]), + ), + axis=1, + ) + header_text = ( + "data_pxx data_pxy data_pxz data_pyx data_pyy data_pyz data_pzx " + ) + "data_pzy data_pzz pred_pxx pred_pxy pred_pxz pred_pyx pred_pyy pred_pyz " + "pred_pzx pred_pzy pred_pzz" + else: + pe = np.concatenate( + ( + np.reshape( + test_data["atomic_polarizability"][:numb_test], + [-1, 9 * sel_natoms], + ), + np.reshape(polar, [-1, 9 * sel_natoms]), + ), + axis=1, + ) + header_text = [ + f"{letter}{number}" + for number in range(1, sel_natoms + 1) + for letter in [ + "data_pxx", + "data_pxy", + "data_pxz", + "data_pyx", + "data_pyy", + "data_pyz", + "data_pzx", + "data_pzy", + "data_pzz", + ] + ] + [ + f"{letter}{number}" + for number in range(1, sel_natoms + 1) + for letter in [ + "pred_pxx", + "pred_pxy", + "pred_pxz", + "pred_pyx", + "pred_pyy", + "pred_pyz", + "pred_pzx", + "pred_pzy", + "pred_pzz", + ] + ] + header_text = " ".join(header_text) + np.savetxt( detail_path.with_suffix(".out"), pe, - header="data_pxx data_pxy data_pxz data_pyx data_pyy data_pyz data_pzx " - "data_pzy data_pzz pred_pxx pred_pxy pred_pxz pred_pyx pred_pyy pred_pyz " - "pred_pzx pred_pzy pred_pzz", + header=header_text, ) return {"rmse": (rmse_f, polar.size)} diff --git a/source/tests/test_dp_test.py b/source/tests/test_dp_test.py new file mode 100644 index 0000000000..9e7c7d29aa --- /dev/null +++ b/source/tests/test_dp_test.py @@ -0,0 +1,308 @@ +# SPDX-License-Identifier: LGPL-3.0-or-later +import os +import shutil +import unittest +from pathlib import ( + Path, +) + +import dpdata +import numpy as np +from common import ( + tests_path, +) + +from deepmd.entrypoints.test import test as dp_test +from deepmd.utils.convert import ( + convert_pbtxt_to_pb, +) + +default_places = 6 + + +class TestDPTest: + def setUp(self): + self.coords = np.array( + [ + 12.83, + 2.56, + 2.18, + 12.09, + 2.87, + 2.74, + 00.25, + 3.32, + 1.68, + 3.36, + 3.00, + 1.81, + 3.51, + 2.51, + 2.60, + 4.27, + 3.22, + 1.56, + ] + ) + self.atype = [0, 1, 1, 0, 1, 1] + self.box = np.array([13.0, 0.0, 0.0, 0.0, 13.0, 0.0, 0.0, 0.0, 13.0]) + self.test_data = "test_dp_test" + dpdata.System( + data={ + "orig": np.zeros(3), + "atom_names": ["O", "H"], + "atom_numbs": [2, 4], + "atom_types": np.array(self.atype), + "cells": self.box.reshape(1, 3, 3), + "coords": self.coords.reshape(1, 6, 3), + } + ).to_deepmd_npy(self.test_data) + + def tearDown(self): + shutil.rmtree(self.test_data, ignore_errors=True) + + @classmethod + def tearDownClass(cls): + os.remove(cls.model_name) + + +class TestDPTestEner(unittest.TestCase, TestDPTest): + @classmethod + def setUpClass(cls): + cls.model_name = "deeppot.pb" + convert_pbtxt_to_pb( + str(tests_path / os.path.join("infer", "deeppot.pbtxt")), cls.model_name + ) + + def setUp(self): + TestDPTest.setUp(self) + self.expected_e = np.array( + [ + -9.275780747115504710e01, + -1.863501786584258468e02, + -1.863392472863538103e02, + -9.279281325486221021e01, + -1.863671545232153903e02, + -1.863619822847602165e02, + ] + ) + self.expected_f = np.array( + [ + -3.034045420701179663e-01, + 8.405844663871177014e-01, + 7.696947487118485642e-02, + 7.662001266663505117e-01, + -1.880601391333554251e-01, + -6.183333871091722944e-01, + -5.036172391059643427e-01, + -6.529525836149027151e-01, + 5.432962643022043459e-01, + 6.382357912332115024e-01, + -1.748518296794561167e-01, + 3.457363524891907125e-01, + 1.286482986991941552e-03, + 3.757251165286925043e-01, + -5.972588700887541124e-01, + -5.987006197104716154e-01, + -2.004450304880958100e-01, + 2.495901655353461868e-01, + ] + ) + self.expected_v = np.array( + [ + -2.912234126853306959e-01, + -3.800610846612756388e-02, + 2.776624987489437202e-01, + -5.053761003913598976e-02, + -3.152373041953385746e-01, + 1.060894290092162379e-01, + 2.826389131596073745e-01, + 1.039129970665329250e-01, + -2.584378792325942586e-01, + -3.121722367954994914e-01, + 8.483275876786681990e-02, + 2.524662342344257682e-01, + 4.142176771106586414e-02, + -3.820285230785245428e-02, + -2.727311173065460545e-02, + 2.668859789777112135e-01, + -6.448243569420382404e-02, + -2.121731470426218846e-01, + -8.624335220278558922e-02, + -1.809695356746038597e-01, + 1.529875294531883312e-01, + -1.283658185172031341e-01, + -1.992682279795223999e-01, + 1.409924999632362341e-01, + 1.398322735274434292e-01, + 1.804318474574856390e-01, + -1.470309318999652726e-01, + -2.593983661598450730e-01, + -4.236536279233147489e-02, + 3.386387920184946720e-02, + -4.174017537818433543e-02, + -1.003500282164128260e-01, + 1.525690815194478966e-01, + 3.398976109910181037e-02, + 1.522253908435125536e-01, + -2.349125581341701963e-01, + 9.515545977581392825e-04, + -1.643218849228543846e-02, + 1.993234765412972564e-02, + 6.027265332209678569e-04, + -9.563256398907417355e-02, + 1.510815124001868293e-01, + -7.738094816888557714e-03, + 1.502832772532304295e-01, + -2.380965783745832010e-01, + -2.309456719810296654e-01, + -6.666961081213038098e-02, + 7.955566551234216632e-02, + -8.099093777937517447e-02, + -3.386641099800401927e-02, + 4.447884755740908608e-02, + 1.008593228579038742e-01, + 4.556718179228393811e-02, + -6.078081273849572641e-02, + ] + ) + + def test_1frame(self): + detail_file = "test_dp_test_ener_detail" + dp_test( + model=self.model_name, + system=self.test_data, + datafile=None, + set_prefix="set", + numb_test=0, + rand_seed=None, + shuffle_test=False, + detail_file=detail_file, + atomic=False, + ) + # TODO: see #2721 + idx_map = np.lexsort((np.arange(len(self.atype)), self.atype)) + pred_e = np.loadtxt(detail_file + ".e.out", ndmin=2)[0, 1] + pred_f = np.loadtxt(detail_file + ".f.out", ndmin=2)[:, 3:6] + pred_v = np.loadtxt(detail_file + ".v.out", ndmin=2)[:, 9:18] + pred_e_peratom = np.loadtxt(detail_file + ".e_peratom.out", ndmin=2)[0, 1] + pred_v_peratom = np.loadtxt(detail_file + ".v_peratom.out", ndmin=2)[:, 9:18] + self.assertAlmostEqual(pred_e, np.sum(self.expected_e), places=default_places) + np.testing.assert_almost_equal( + pred_f, self.expected_f.reshape(-1, 3)[idx_map], decimal=default_places + ) + np.testing.assert_almost_equal( + pred_v, + np.sum(self.expected_v.reshape(1, -1, 9), axis=1), + decimal=default_places, + ) + np.testing.assert_almost_equal( + pred_e_peratom, pred_e / len(self.atype), decimal=default_places + ) + np.testing.assert_almost_equal( + pred_v_peratom, pred_v / len(self.atype), decimal=default_places + ) + + self.expected_d = np.array( + [ + -9.274180565967479195e-01, + 2.698028341272042496e00, + 2.521268387140979117e-01, + 2.927260638453461628e00, + -8.571926301526779923e-01, + 1.667785136187720063e00, + ] + ) + + +class TestDPTestDipole(unittest.TestCase, TestDPTest): + @classmethod + def setUpClass(cls): + cls.model_name = "deepdipole.pb" + convert_pbtxt_to_pb( + str(tests_path / os.path.join("infer", "deepdipole.pbtxt")), cls.model_name + ) + + def setUp(self): + TestDPTest.setUp(self) + self.expected_d = np.array( + [ + -9.274180565967479195e-01, + 2.698028341272042496e00, + 2.521268387140979117e-01, + 2.927260638453461628e00, + -8.571926301526779923e-01, + 1.667785136187720063e00, + ] + ) + np.save(Path(self.test_data) / "set.000" / "atomic_dipole.npy", self.expected_d) + + def test_1frame(self): + detail_file = "test_dp_test_dipole_detail" + dp_test( + model=self.model_name, + system=self.test_data, + datafile=None, + set_prefix="set", + numb_test=0, + rand_seed=None, + shuffle_test=False, + detail_file=detail_file, + atomic=True, + ) + dipole = np.loadtxt(detail_file + ".out", ndmin=2)[0, 6:12] + np.testing.assert_almost_equal(dipole, self.expected_d, decimal=default_places) + + +class TestDPTestPolar(unittest.TestCase, TestDPTest): + @classmethod + def setUpClass(cls): + cls.model_name = "deeppolar.pb" + convert_pbtxt_to_pb( + str(tests_path / os.path.join("infer", "deeppolar.pbtxt")), cls.model_name + ) + + def setUp(self): + TestDPTest.setUp(self) + self.expected_d = np.array( + [ + 1.061407927405987051e-01, + -3.569013342133873778e-01, + -2.862108976089940138e-02, + -3.569013342133875444e-01, + 1.304367268874677244e00, + 1.037647501453442256e-01, + -2.862108976089940138e-02, + 1.037647501453441284e-01, + 8.100521520762453409e-03, + 1.236797829492216616e00, + -3.717307430531632262e-01, + 7.371515676976750919e-01, + -3.717307430531630041e-01, + 1.127222682121889058e-01, + -2.239181552775717510e-01, + 7.371515676976746478e-01, + -2.239181552775717787e-01, + 4.448255365635306879e-01, + ] + ) + np.save( + Path(self.test_data) / "set.000" / "atomic_polarizability.npy", + self.expected_d, + ) + + def test_1frame(self): + detail_file = "test_dp_test_polar_detail" + dp_test( + model=self.model_name, + system=self.test_data, + datafile=None, + set_prefix="set", + numb_test=0, + rand_seed=None, + shuffle_test=False, + detail_file=detail_file, + atomic=True, + ) + dipole = np.loadtxt(detail_file + ".out", ndmin=2)[0, 18:36] + np.testing.assert_almost_equal(dipole, self.expected_d, decimal=default_places) From 76e4eec54f5512642c20f96eee6bca348001d1bd Mon Sep 17 00:00:00 2001 From: Jinzhe Zeng Date: Mon, 4 Sep 2023 21:29:16 -0400 Subject: [PATCH 2/3] fix polar shape Co-authored-by: Han Wang <92130845+wanghan-iapcm@users.noreply.github.com> Signed-off-by: Jinzhe Zeng --- deepmd/entrypoints/test.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/deepmd/entrypoints/test.py b/deepmd/entrypoints/test.py index f79ae158b0..a2da497e5d 100644 --- a/deepmd/entrypoints/test.py +++ b/deepmd/entrypoints/test.py @@ -852,7 +852,7 @@ def test_polar( pe = np.concatenate( ( np.reshape(test_data["polarizability"][:numb_test], [-1, 9]), - np.reshape(polar, [-1, 3]), + np.reshape(polar, [-1, 9]), ), axis=1, ) From af172e785a8bd917c03fa25e4c94ceb095a68a83 Mon Sep 17 00:00:00 2001 From: Jinzhe Zeng Date: Tue, 29 Aug 2023 11:19:42 -0400 Subject: [PATCH 3/3] add tests; fix styles Signed-off-by: Jinzhe Zeng --- deepmd/entrypoints/test.py | 4 +-- source/tests/test_dp_test.py | 58 ++++++++++++++++++++++++++++-------- 2 files changed, 47 insertions(+), 15 deletions(-) diff --git a/deepmd/entrypoints/test.py b/deepmd/entrypoints/test.py index a2da497e5d..b2fb30dfc0 100644 --- a/deepmd/entrypoints/test.py +++ b/deepmd/entrypoints/test.py @@ -858,9 +858,9 @@ def test_polar( ) header_text = ( "data_pxx data_pxy data_pxz data_pyx data_pyy data_pyz data_pzx " + "data_pzy data_pzz pred_pxx pred_pxy pred_pxz pred_pyx pred_pyy " + "pred_pyz pred_pzx pred_pzy pred_pzz" ) - "data_pzy data_pzz pred_pxx pred_pxy pred_pxz pred_pyx pred_pyy pred_pyz " - "pred_pzx pred_pzy pred_pzz" else: pe = np.concatenate( ( diff --git a/source/tests/test_dp_test.py b/source/tests/test_dp_test.py index 9e7c7d29aa..df1b51db0d 100644 --- a/source/tests/test_dp_test.py +++ b/source/tests/test_dp_test.py @@ -203,17 +203,6 @@ def test_1frame(self): pred_v_peratom, pred_v / len(self.atype), decimal=default_places ) - self.expected_d = np.array( - [ - -9.274180565967479195e-01, - 2.698028341272042496e00, - 2.521268387140979117e-01, - 2.927260638453461628e00, - -8.571926301526779923e-01, - 1.667785136187720063e00, - ] - ) - class TestDPTestDipole(unittest.TestCase, TestDPTest): @classmethod @@ -235,7 +224,9 @@ def setUp(self): 1.667785136187720063e00, ] ) + self.expected_global_d = np.sum(self.expected_d.reshape(1, -1, 3), axis=1) np.save(Path(self.test_data) / "set.000" / "atomic_dipole.npy", self.expected_d) + np.save(Path(self.test_data) / "set.000" / "dipole.npy", self.expected_global_d) def test_1frame(self): detail_file = "test_dp_test_dipole_detail" @@ -253,6 +244,24 @@ def test_1frame(self): dipole = np.loadtxt(detail_file + ".out", ndmin=2)[0, 6:12] np.testing.assert_almost_equal(dipole, self.expected_d, decimal=default_places) + def test_1frame_global(self): + detail_file = "test_dp_test_global_dipole_detail" + dp_test( + model=self.model_name, + system=self.test_data, + datafile=None, + set_prefix="set", + numb_test=0, + rand_seed=None, + shuffle_test=False, + detail_file=detail_file, + atomic=False, + ) + dipole = np.loadtxt(detail_file + ".out", ndmin=2)[:, 3:6] + np.testing.assert_almost_equal( + dipole, self.expected_global_d, decimal=default_places + ) + class TestDPTestPolar(unittest.TestCase, TestDPTest): @classmethod @@ -286,10 +295,15 @@ def setUp(self): 4.448255365635306879e-01, ] ) + self.expected_global_d = np.sum(self.expected_d.reshape(1, -1, 9), axis=1) np.save( Path(self.test_data) / "set.000" / "atomic_polarizability.npy", self.expected_d, ) + np.save( + Path(self.test_data) / "set.000" / "polarizability.npy", + self.expected_global_d, + ) def test_1frame(self): detail_file = "test_dp_test_polar_detail" @@ -304,5 +318,23 @@ def test_1frame(self): detail_file=detail_file, atomic=True, ) - dipole = np.loadtxt(detail_file + ".out", ndmin=2)[0, 18:36] - np.testing.assert_almost_equal(dipole, self.expected_d, decimal=default_places) + polar = np.loadtxt(detail_file + ".out", ndmin=2)[0, 18:36] + np.testing.assert_almost_equal(polar, self.expected_d, decimal=default_places) + + def test_1frame_global(self): + detail_file = "test_dp_test_global_polar_detail" + dp_test( + model=self.model_name, + system=self.test_data, + datafile=None, + set_prefix="set", + numb_test=0, + rand_seed=None, + shuffle_test=False, + detail_file=detail_file, + atomic=False, + ) + polar = np.loadtxt(detail_file + ".out", ndmin=2)[:, 9:18] + np.testing.assert_almost_equal( + polar, self.expected_global_d, decimal=default_places + )