dpdata/stat.py at master · tuoping/dpdata · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
from __future__ import annotations

from abc import ABCMeta, abstractmethod
from functools import lru_cache
from typing import Any

import numpy as np

from dpdata.system import LabeledSystem, MultiSystems


def mae(errors: np.ndarray) -> np.floating[Any]:
    """Compute the mean absolute error (MAE).

    Parameters
    ----------
    errors : np.ndarray
        errors between two values

    Returns
    -------
    floating[Any]
        mean absolute error (MAE)
    """
    return np.mean(np.abs(errors))


def rmse(errors: np.ndarray) -> np.floating[Any]:
    """Compute the root mean squared error (RMSE).

    Parameters
    ----------
    errors : np.ndarray
        errors between two values

    Returns
    -------
    floating[Any]
        root mean squared error (RMSE)
    """
    return np.sqrt(np.mean(np.square(errors)))


class ErrorsBase(metaclass=ABCMeta):
    """Compute errors (deviations) between two systems. The type of system is assigned by SYSTEM_TYPE.

    Parameters
    ----------
    system_1 : object
        system 1
    system_2 : object
        system 2
    """

    SYSTEM_TYPE = object

    def __init__(self, system_1: SYSTEM_TYPE, system_2: SYSTEM_TYPE) -> None:
        assert isinstance(system_1, self.SYSTEM_TYPE), (
            f"system_1 should be {self.SYSTEM_TYPE.__name__}"
        )
        assert isinstance(system_2, self.SYSTEM_TYPE), (
            f"system_2 should be {self.SYSTEM_TYPE.__name__}"
        )
        self.system_1 = system_1
        self.system_2 = system_2

    @property
    @abstractmethod
    def e_errors(self) -> np.ndarray:
        """Energy errors."""

    @property
    @abstractmethod
    def f_errors(self) -> np.ndarray:
        """Force errors."""

    @property
    def e_mae(self) -> np.floating[Any]:
        """Energy MAE."""
        return mae(self.e_errors)

    @property
    def e_rmse(self) -> np.floating[Any]:
        """Energy RMSE."""
        return rmse(self.e_errors)

    @property
    def f_mae(self) -> np.floating[Any]:
        """Force MAE."""
        return mae(self.f_errors)

    @property
    def f_rmse(self) -> np.floating[Any]:
        """Force RMSE."""
        return rmse(self.f_errors)


class Errors(ErrorsBase):
    """Compute errors (deviations) between two LabeledSystems.

    Parameters
    ----------
    system_1 : object
        system 1
    system_2 : object
        system 2

    Examples
    --------
    Get errors between referenced system and predicted system:

    >>> e = dpdata.stat.Errors(system_1, system_2)
    >>> print("%.4f %.4f %.4f %.4f" % (e.e_mae, e.e_rmse, e.f_mae, e.f_rmse))
    """

    SYSTEM_TYPE = LabeledSystem

    @property
    @lru_cache
    def e_errors(self) -> np.ndarray:
        """Energy errors."""
        assert isinstance(self.system_1, self.SYSTEM_TYPE)
        assert isinstance(self.system_2, self.SYSTEM_TYPE)
        return self.system_1["energies"] - self.system_2["energies"]

    @property
    @lru_cache
    def f_errors(self) -> np.ndarray:
        """Force errors."""
        assert isinstance(self.system_1, self.SYSTEM_TYPE)
        assert isinstance(self.system_2, self.SYSTEM_TYPE)
        return (self.system_1["forces"] - self.system_2["forces"]).ravel()


class MultiErrors(ErrorsBase):
    """Compute errors (deviations) between two MultiSystems.

    Parameters
    ----------
    system_1 : object
        system 1
    system_2 : object
        system 2

    Examples
    --------
    Get errors between referenced system and predicted system:

    >>> e = dpdata.stat.MultiErrors(system_1, system_2)
    >>> print("%.4f %.4f %.4f %.4f" % (e.e_mae, e.e_rmse, e.f_mae, e.f_rmse))
    """

    SYSTEM_TYPE = MultiSystems

    @property
    @lru_cache
    def e_errors(self) -> np.ndarray:
        """Energy errors."""
        assert isinstance(self.system_1, self.SYSTEM_TYPE)
        assert isinstance(self.system_2, self.SYSTEM_TYPE)
        errors = []
        for nn in self.system_1.systems.keys():
            ss1 = self.system_1[nn]
            ss2 = self.system_2[nn]
            errors.append(Errors(ss1, ss2).e_errors.ravel())
        return np.concatenate(errors)

    @property
    @lru_cache
    def f_errors(self) -> np.ndarray:
        """Force errors."""
        assert isinstance(self.system_1, self.SYSTEM_TYPE)
        assert isinstance(self.system_2, self.SYSTEM_TYPE)
        errors = []
        for nn in self.system_1.systems.keys():
            ss1 = self.system_1[nn]
            ss2 = self.system_2[nn]
            errors.append(Errors(ss1, ss2).f_errors.ravel())
        return np.concatenate(errors)