Merge pull request #9 from vanderhe/mixedTargetsFnetout

Support for data extraction when trained on mixed target types

Author: vanderhe

src/fortformat/fnetout.py

@@ -40,6 +40,8 @@ def __init__(self, fname):
                 raise FnetoutError('Invalid running mode specification.')
 
             output = fnetoutfile['fnetout']['output']
+
+            # read number of datapoints
             self._ndatapoints = output.attrs.get('ndatapoints')
             if len(self._ndatapoints) == 1:
                 # number of datapoints stored in array of size 1
@@ -48,6 +50,28 @@ def __init__(self, fname):
                 msg = "Error while reading fnetout file '" + self._fname + \
                     "'. Unrecognized number of datapoints obtained."
                 raise FnetoutError(msg)
+
+            # read number of system-wide targets
+            self._nglobaltargets = output.attrs.get('nglobaltargets')
+            if len(self._nglobaltargets) == 1:
+                # number of system-wide targets stored in array of size 1
+                self._nglobaltargets = self._nglobaltargets[0]
+            else:
+                msg = "Error while reading fnetout file '" + self._fname + \
+                    "'. Unrecognized number of global targets obtained."
+                raise FnetoutError(msg)
+
+            # read number of atomic targets
+            self._natomictargets = output.attrs.get('natomictargets')
+            if len(self._natomictargets) == 1:
+                # number of atomic targets stored in array of size 1
+                self._natomictargets = self._natomictargets[0]
+            else:
+                msg = "Error while reading fnetout file '" + self._fname + \
+                    "'. Unrecognized number of atomic targets obtained."
+                raise FnetoutError(msg)
+
+            # read force specification
             self._tforces = output.attrs.get('tforces')
             # account for legacy files where no force entry is present
             if self._tforces is None:
@@ -60,18 +84,6 @@ def __init__(self, fname):
                     "'. Unrecognized force specification obtained."
                 raise FnetoutError(msg)
 
-            self._targettype = \
-                output.attrs.get('targettype').decode('UTF-8').strip()
-            if not self._targettype in ('atomic', 'global'):
-                raise FnetoutError('Invalid running mode obtained.')
-
-            # get number of atomic or global predictions/targets
-            self._npredictions = np.shape(
-                np.array(output['datapoint1']['output']))[1]
-
-            if self._mode == 'validate':
-                self._npredictions = int(self._npredictions / 2)
-
 
     @property
     def mode(self):
@@ -100,16 +112,29 @@ def ndatapoints(self):
 
 
     @property
-    def targettype(self):
-        '''Defines property, providing the target type.
+    def nglobaltargets(self):
+        '''Defines property, providing the number of system-wide targets.
+
+        Returns:
+
+            nglobaltargets (int): number of global targets per datapoint
+
+        '''
+
+        return self._nglobaltargets
+
+
+    @property
+    def natomictargets(self):
+        '''Defines property, providing the number of atomic targets.
 
         Returns:
 
-            targettype (str): type of targets the network was trained on
+            natomictargets (int): number of atomic targets per datapoint
 
         '''
 
-        return self._targettype
+        return self._natomictargets
 
 
     @property
@@ -126,75 +151,134 @@ def tforces(self):
 
 
     @property
-    def predictions(self):
-        '''Defines property, providing the predictions of Fortnet.
+    def globalpredictions(self):
+        '''Defines property, providing the system-wide predictions of Fortnet.
 
         Returns:
 
-            predictions (list or 2darray): predictions of the network
+            predictions (2darray): predictions of the network
 
         '''
 
+        if not self._nglobaltargets > 0:
+            return None
+
+        predictions = np.empty((self._ndatapoints, self._nglobaltargets),
+                               dtype=float)
+
         with h5py.File(self._fname, 'r') as fnetoutfile:
             output = fnetoutfile['fnetout']['output']
-            if self._targettype == 'atomic':
-                predictions = []
-                for idata in range(self._ndatapoints):
-                    dataname = 'datapoint' + str(idata + 1)
-                    if self._mode == 'validate':
-                        predictions.append(
-                            np.array(output[dataname]['output'],
-                                     dtype=float)[:, :self._npredictions])
-                    else:
-                        predictions.append(
-                            np.array(output[dataname]['output'], dtype=float))
-            else:
-                predictions = np.empty(
-                    (self._ndatapoints, self._npredictions), dtype=float)
-                for idata in range(self._ndatapoints):
-                    dataname = 'datapoint' + str(idata + 1)
-                    if self._mode == 'validate':
-                        predictions[idata, :] = \
-                            np.array(output[dataname]['output'],
-                                     dtype=float)[0, :self._npredictions]
-                    else:
-                        predictions[idata, :] = \
-                            np.array(output[dataname]['output'],
-                                     dtype=float)[0, :]
+            for idata in range(self._ndatapoints):
+                dataname = 'datapoint' + str(idata + 1)
+                predictions[idata, :] = np.array(
+                    output[dataname]['globalpredictions'],
+                    dtype=float)
 
         return predictions
 
 
     @property
-    def targets(self):
-        '''Defines property, providing the targets during training.
+    def globalpredictions_atomic(self):
+        '''Defines property, providing the (atom-resolved) system-wide
+           predictions of Fortnet.
 
         Returns:
 
-            targets (list or 2darray): targets during training
+            predictions (list): predictions of the network
 
         '''
 
-        if self._mode == 'predict':
+        if not self._nglobaltargets > 0:
             return None
 
+        predictions = []
+
         with h5py.File(self._fname, 'r') as fnetoutfile:
             output = fnetoutfile['fnetout']['output']
-            if self._targettype == 'atomic':
-                targets = []
-                for idata in range(self._ndatapoints):
-                    dataname = 'datapoint' + str(idata + 1)
-                    targets.append(
-                        np.array(output[dataname]['output'],
-                                 dtype=float)[:, self._npredictions:])
-            else:
-                targets = np.empty(
-                    (self._ndatapoints, self._npredictions), dtype=float)
-                for idata in range(self._ndatapoints):
-                    dataname = 'datapoint' + str(idata + 1)
-                    targets[idata, :] = \
-                        np.array(output[dataname]['output'],
-                                 dtype=float)[0, self._npredictions:]
+            for idata in range(self._ndatapoints):
+                dataname = 'datapoint' + str(idata + 1)
+                predictions.append(
+                    np.array(output[dataname]['rawpredictions'],
+                             dtype=float)[:, 0:self._nglobaltargets])
+
+        return predictions
+
+
+    @property
+    def atomicpredictions(self):
+        '''Defines property, providing the atomic predictions of Fortnet.
+
+        Returns:
+
+            predictions (list): predictions of the network
+
+        '''
+
+        if not self._natomictargets > 0:
+            return None
+
+        predictions = []
+
+        with h5py.File(self._fname, 'r') as fnetoutfile:
+            output = fnetoutfile['fnetout']['output']
+            for idata in range(self._ndatapoints):
+                dataname = 'datapoint' + str(idata + 1)
+                predictions.append(
+                    np.array(output[dataname]
+                             ['rawpredictions'], dtype=float)
+                    [:, self._nglobaltargets:])
+
+        return predictions
+
+
+    @property
+    def globaltargets(self):
+        '''Defines property, providing the system-wide targets during training.
+
+        Returns:
+
+            targets (2darray): system-wide targets during training
+
+        '''
+
+        if self._mode == 'predict' or self._nglobaltargets == 0:
+            return None
+
+        targets = np.empty((self._ndatapoints, self._nglobaltargets),
+                           dtype=float)
+
+        with h5py.File(self._fname, 'r') as fnetoutfile:
+            output = fnetoutfile['fnetout']['output']
+            for idata in range(self._ndatapoints):
+                dataname = 'datapoint' + str(idata + 1)
+                targets[idata, :] = np.array(
+                    output[dataname]['globaltargets'],
+                    dtype=float)
+
+        return targets
+
+
+    @property
+    def atomictargets(self):
+        '''Defines property, providing the atomic targets during training.
+
+        Returns:
+
+            targets (list): atomic targets during training
+
+        '''
+
+        if self._mode == 'predict' or self._natomictargets == 0:
+            return None
+
+        targets = []
+
+        with h5py.File(self._fname, 'r') as fnetoutfile:
+            output = fnetoutfile['fnetout']['output']
+            for idata in range(self._ndatapoints):
+                dataname = 'datapoint' + str(idata + 1)
+                targets.append(np.array(output[dataname]
+                                        ['atomictargets'], dtype=float))
 
         return targets
 
@@ -214,10 +298,10 @@ def forces(self):
 
         tmp1 = []
 
-        if self._targettype == 'atomic':
+        if self._natomictargets > 0:
             msg = "Error while extracting forces from fnetout file '" \
                 + self._fname + \
-                "'. Forces only supplied for global property targets."
+                "'. Forces supplied for global property targets only."
             raise FnetoutError(msg)
 
         with h5py.File(self._fname, 'r') as fnetoutfile:

test/common.py

@@ -80,11 +80,15 @@ def compare_fnetout_references(ref, fname, atol=ATOL, rtol=RTOL):
 
     mode = fnetout.mode
     ndatapoints = fnetout.ndatapoints
-    targettype = fnetout.targettype
-    targets = fnetout.targets
+    nglobaltargets = fnetout.nglobaltargets
+    natomictargets = fnetout.natomictargets
+    globaltargets = fnetout.globaltargets
+    atomictargets = fnetout.atomictargets
     tforces = fnetout.tforces
     forces = fnetout.forces
-    predictions = fnetout.predictions
+    atomicpredictions = fnetout.atomicpredictions
+    globalpredictions = fnetout.globalpredictions
+    globalpredictions_atomic = fnetout.globalpredictions_atomic
 
     equal = mode == ref['mode']
 
@@ -98,19 +102,35 @@ def compare_fnetout_references(ref, fname, atol=ATOL, rtol=RTOL):
         warnings.warn('Mismatch in number of training datapoints.')
         return False
 
-    equal = targettype == ref['targettype']
+    equal = nglobaltargets == ref['nglobaltargets']
 
     if not equal:
-        warnings.warn('Mismatch in target type specification.')
+        warnings.warn('Mismatch in number of system-wide targets.')
         return False
 
-    if ref['targets'] is not None:
-        for ii, target in enumerate(targets):
-            equal = np.allclose(target, ref['targets'][ii],
+    equal = natomictargets == ref['natomictargets']
+
+    if not equal:
+        warnings.warn('Mismatch in number of atomic targets.')
+        return False
+
+    if ref['globaltargets'] is not None:
+        for ii, target in enumerate(globaltargets):
+            equal = np.allclose(target, ref['globaltargets'][ii],
                                 rtol=rtol, atol=atol)
 
             if not equal:
-                warnings.warn('Mismatch in targets of datapoint ' \
+                warnings.warn('Mismatch in global targets of datapoint ' \
+                              + str(ii + 1) + '.')
+                return False
+
+    if ref['atomictargets'] is not None:
+        for ii, target in enumerate(atomictargets):
+            equal = np.allclose(target, ref['atomictargets'][ii],
+                                rtol=rtol, atol=atol)
+
+            if not equal:
+                warnings.warn('Mismatch in atomic targets of datapoint ' \
                               + str(ii + 1) + '.')
                 return False
 
@@ -133,17 +153,39 @@ def compare_fnetout_references(ref, fname, atol=ATOL, rtol=RTOL):
                                   str(itarget + 1) + '.')
                     return False
 
-    for ii, prediction in enumerate(predictions):
-        equal = np.allclose(prediction, ref['predictions'][ii],
-                            rtol=rtol, atol=atol)
+    if ref['atomicpredictions'] is not None:
+        for ii, prediction in enumerate(atomicpredictions):
+            equal = np.allclose(prediction, ref['atomicpredictions'][ii],
+                                rtol=rtol, atol=atol)
 
-        if not equal:
-            warnings.warn('Mismatch in predictions of datapoint ' \
-                          + str(ii + 1) + '.')
-            return False
+            if not equal:
+                warnings.warn('Mismatch in atomic predictions of datapoint ' \
+                              + str(ii + 1) + '.')
+                return False
+
+    if ref['globalpredictions'] is not None:
+        for ii, target in enumerate(globalpredictions):
+            equal = np.allclose(target, ref['globalpredictions'][ii],
+                                rtol=rtol, atol=atol)
+
+            if not equal:
+                warnings.warn('Mismatch in global predictions' \
+                              + ' of datapoint ' + str(ii + 1) + '.')
+                return False
+
+    if ref['globalpredictions_atomic'] is not None:
+        for ii, target in enumerate(globalpredictions_atomic):
+            equal = np.allclose(target, ref['globalpredictions_atomic'][ii],
+                                rtol=rtol, atol=atol)
+
+            if not equal:
+                warnings.warn('Mismatch in (atom-resolved) global predictions' \
+                              + ' of datapoint ' + str(ii + 1) + '.')
+                return False
 
     return True
 
+
 def get_mixed_geometries():
     '''Generates six geometries with(out) periodic boundary conditions.'''