mlatom 2.0.0__py3-none-any.whl

MLatom/interfaces/GAP/interface_GAP.py

@@ -0,0 +1,415 @@
+#!/usr/bin/python3
+'''
+  !---------------------------------------------------------------------------! 
+  ! Interface_GAP: Interface between GAP and MLatom                           ! 
+  ! Implementations by: Fuchun Ge                                             ! 
+  !---------------------------------------------------------------------------! 
+'''
+import numpy as np
+import os, sys, subprocess, time, shutil, re, math, random
+import stopper
+from args_class import ArgsBase
+
+filedir = os.path.dirname(__file__)
+
+class Args(ArgsBase):
+    def __init__(self):
+        super().__init__()
+        self.add_default_dict_args([
+            'learningCurve'
+            ],
+            bool
+        )
+        self.add_default_dict_args([
+            'mlmodeltype'
+            ],
+            'gap-soap'
+        )
+        self.add_default_dict_args([
+            'xyzfile', 'yfile', 'ygradxyzfile','itrainin','itestin','isubtrainin','ivalidatein','mlmodelin','setname'
+            ],
+            ""
+        )        
+        self.add_dict_args({
+            'mlmodelout': "GAPmodel.xml",
+            'sampling': "random",
+            'yestfile': "enest.dat",
+            'ygradxyzestfile': "gradest.dat"
+        })
+        self.parse_input_content('gapfit.gap.type=soap')
+
+    def parse(self, argsraw):
+        self.parse_input_content(argsraw)
+        self.argProcess()
+
+    def argProcess(self):
+        GAPCls.gapdict.update(self.gapfit.gap)
+        gap = '{'+' '.join([str(k)+'='+str(v) for k,v in GAPCls.gapdict.items()])[5:]+'}'
+        GAPCls.gapfitdict.update(self.gapfit)
+        GAPCls.gapfitdict.update({
+            'gp_file': self.mlmodelout, 
+            'gap': gap,
+        })
+        with open(self.xyzfile,'r') as f:
+            GAPCls.natom = int(f.readline())
+            exec('f.readline()')
+            GAPCls.atype = [f.readline().split()[0] for i in range(GAPCls.natom)]
+
+        if not self.mlmodelin:
+                self.mlmodelin = self.mlmodelout
+        if 'default_sigma_e' in GAPCls.gapfitdict.keys(): 
+            GAPCls.gapfitdict['default_sigma']=GAPCls.gapfitdict['default_sigma'].replace(
+                GAPCls.gapfitdict['default_sigma'][1:-1].split(',')[0],
+                GAPCls.gapfitdict['default_sigma_e']
+            )
+            GAPCls.gapfitdict.pop('default_sigma_e')
+        if 'default_sigma_f' in GAPCls.gapfitdict.keys(): 
+            GAPCls.gapfitdict['default_sigma']=GAPCls.gapfitdict['default_sigma'].replace(
+                GAPCls.gapfitdict['default_sigma'][1:-1].split(',')[1],
+                GAPCls.gapfitdict['default_sigma_f']
+            )
+            GAPCls.gapfitdict.pop('default_sigma_f')
+        GAPCls.gapfitdict['default_sigma'] = " ".join(GAPCls.gapfitdict['default_sigma'].replace(',',', ').split())
+        GAPCls.gapfitdict['gp_file']=self.mlmodelout
+        if self.yfile: GAPCls.gapfitdict['energy_parameter_name']='energy'
+        if self.ygradxyzfile: GAPCls.gapfitdict['force_parameter_name']='forces'
+        # if self.setname: GAPCls.gapfitdict['at_file']='GAP.exyz_'+self.setname
+        GAPCls.gapfit          = [GAPbin]
+        for k, v in GAPCls.gapfitdict.items():
+            GAPCls.gapfit.append(k+'='+v)
+
+class GAPCls(object):
+    dataConverted = False
+    gapdict = {
+        'type': 'soap',
+        'l_max': '6',
+        'n_max': '6',
+        'atom_sigma': '0.5',
+        'zeta': '4',
+        'cutoff': '6',
+        'cutoff_transition_width': '0.5',
+        'n_sparse': '1000000',
+        'delta': '1',
+        'covariance_type': 'dot_product',   
+        'sparse_method': 'cur_points',
+        'add_species': 'T'
+    }
+    # gap = '{'+' '.join([k+'='+v for k,v in args.gapdic.items()])[5:]+'}'
+    gapfitdict = {
+        'at_file':'GAP.exyz_train',
+        'default_sigma':'{0.0005,0.001,0.1,0.1}', 
+        'gp_file': '', 
+        'gap': '', 
+        'e0_method':'average',
+        'sparse_separate_file': 'F'
+    }
+    gapfit = []
+    natom = 0 
+    atype = ''
+
+    @classmethod
+    def load(cls):
+        loaded=False
+        if not loaded:
+            
+            try:
+                GAPbin = os.environ['gap_fit']
+            except:
+                print('please set $gap_fit')
+            try:
+                QUIPbin = os.environ['quip']
+            except:
+                print('please set $quip')
+            globals()['QUIPbin'] = QUIPbin
+            globals()['GAPbin'] = GAPbin
+            loaded=True
+
+        
+
+    def __init__(self, args = sys.argv[1:]):
+        print(' ___________________________________________________________\n\n%s' % __doc__)
+
+    @classmethod
+    def convertdata(cls, GAPargs, subdatasets):
+        cls.load()
+        def convert(fileout, setname, yorgrad=False):
+            # convert data to .exyz format
+            prefix = ''
+            if args.learningcurve: prefix = '../'
+            if setname: 
+                coordfile = prefix+'xyz.dat_'+setname
+                yfile = prefix+'y.dat_'+setname
+                gradfile = prefix+'grad.dat_'+setname
+            else: 
+                coordfile = args.xyzfile
+                if args.yfile and yorgrad: yfile = args.yfile
+                if args.ygradxyzfile and yorgrad: gradfile = args.ygradxyzfile
+
+            with open(fileout, 'w') as fo, open(coordfile ,'r') as fxyz:
+                if args.yfile and yorgrad: fy =  open(yfile,'r')
+                if args.ygradxyzfile and yorgrad: fgrad = open(gradfile,'r')
+                for line in fxyz:
+                    natom = int(line)
+                    fo.write(line)
+                    if args.ygradxyzfile and yorgrad: fgrad.readline()
+
+                    if args.yfile and yorgrad: fo.write('energy=%s '% fy.readline()[:-1])
+                    fo.write('pbc="T T T" Lattice="10.0 0.0 0.0 0.0 10.0 0.0 0.0 0.0 10.0" Properties=species:S:1:pos:R:3')
+                    if args.ygradxyzfile and yorgrad: fo.write(':forces:R:3')
+                    fo.write('\n')
+                    fxyz.readline()
+                    if args.ygradxyzfile and yorgrad: fgrad.readline()
+
+                    for i in range(natom):
+                        fo.write(fxyz.readline()[:-1])
+                        if args.ygradxyzfile and yorgrad: 
+                            fo.write('%24.15f%24.15f%24.15f' % tuple(-1*float(i) for i in fgrad.readline().split()[-3:]))
+                        fo.write('\n')
+                if args.yfile and yorgrad: fy.close()
+                if args.ygradxyzfile and yorgrad: fgrad.close()
+        args = Args()
+        args.parse(GAPargs)
+        print('\n Converting data...\n\n')
+        if subdatasets:
+            if 'Subtrain' in subdatasets:
+                for i in subdatasets:
+                    if i == 'Subtrain' or 'Train': convert('GAP.exyz_'+i.lower(), i.lower(),True)
+                    else: convert('GAP.exyz_'+i.lower(), i.lower())
+            else:
+                for i in subdatasets:
+                    if i == 'Train': convert('GAP.exyz_'+i.lower(), i.lower(),True)
+                    else: convert('GAP.exyz_'+i.lower(), i.lower())
+        else:   convert('GAP.exyz', '')
+
+    @classmethod
+    def createMLmodel(cls, GAPargs, subdatasets):        
+        cls.load()
+
+        args = Args()
+        args.parse(GAPargs)
+
+        if not cls.dataConverted or args.learningcurve:
+            cls.convertdata(GAPargs, subdatasets)
+            cls.dataConverted = True
+        
+        FNULL = open(os.devnull, 'w')
+
+        os.system('rm '+args.mlmodelout+'* > /dev/null 2>&1 ')
+        # call gap_fitr
+        starttime = time.time()
+        print('> '+' '.join(cls.gapfit))
+        sys.stdout.flush()
+
+        subprocess.call(cls.gapfit, stdout=FNULL, stderr=FNULL)
+        # subprocess.call(args.gapfit)
+        FNULL.close()
+        endtime = time.time()
+        wallclock = endtime - starttime
+
+        return wallclock
+
+    @classmethod
+    def useMLmodel(cls, GAPargs, subdatasets):
+        cls.load()
+
+        args = Args()
+
+        if not cls.dataConverted: 
+            cls.convertdata(GAPargs, subdatasets)
+            cls.dataConverted = True
+
+        args.parse(GAPargs)
+        if args.setname: args.setname='_'+args.setname
+        
+        starttime = time.time()
+
+        p1 = subprocess.Popen([
+            QUIPbin,
+            'E=T',
+            'F=T',
+            'atoms_filename=GAP.exyz'+args.setname,
+            'param_filename='+args.mlmodelin,
+        ], stdout=subprocess.PIPE)
+        p2 = subprocess.Popen(['grep','AT'], stdin=p1.stdout, stdout=subprocess.PIPE)
+        (stdout, stderr) = p2.communicate() 
+        p1.stdout.close()
+        with open('GAPest.exyz'+args.setname,'w') as f: 
+            f.write(stdout.decode('ascii'))
+
+        endtime = time.time()
+        wallclock = endtime - starttime
+        
+        # convert results back to MLatom format
+        with open('GAPest.exyz'+args.setname,'r') as f, open(args.yestfile,'w') as fy, open(args.ygradxyzestfile,'w') as fgrad:
+            for i, line in enumerate(f):
+                if i%(cls.natom+2) == 0:
+                    fgrad.write(line[3:])
+                elif i%(cls.natom+2) ==1:
+                    fgrad.write('\n')
+                    fy.write(line.split()[1].split('=')[1]+'\n')
+                else:
+                    fgrad.write('%20s%20s%20s\n' % tuple([-1*float(i) for i in line.split()[-3:]]))
+        sys.stdout.flush()
+        os.system('rm GAP.exyz'+args.setname+'.idx > /dev/null 2>&1 ')
+        args.setname='train'
+        return wallclock
+
+
+# class args(object):
+#     # MLatom args
+#     learningcurve       = False
+#     xyzfile             = ""
+#     yfile               = ""
+#     ygradxyzfile            = ""
+#     virialfile          = ""
+#     ntrain              = 0
+#     ntest               = 0
+#     nsubtrain           = 0
+#     nvalidate           = 0
+#     sampling            = "random"
+#     itrainin            = ""
+#     itestin             = ""
+#     isubtrainin         = ""
+#     ivalidatein         = ""
+#     mlmodelout          = "GAPmodel.xml"
+#     mlmodelin           = ""
+#     yestfile            = "enest.dat"
+#     ygradxyzestfile     = "gradest.dat"
+
+#     # args for this interface
+#     setname             = ''
+#     natom               = 0
+#     atype               = []
+#     gapdic              = {
+#         'type': 'soap',
+#         'l_max': '6',
+#         'n_max': '6',
+#         'atom_sigma': '0.5',
+#         'zeta': '4',
+#         'cutoff': '6',
+#         'cutoff_transition_width': '0.5',
+#         'n_sparse': '1000000',
+#         'delta': '1',
+#         'covariance_type': 'dot_product',   
+#         'sparse_method': 'cur_points',
+#         'add_species': 'T'
+#     }
+#     gap                 = '{'+' '.join([k+'='+v for k,v in gapdic.items()])[5:]+'}'
+#     gapfitdic           = {
+#         'at_file':'GAP.exyz_train',
+#         'default_sigma':'{0.0005,0.001,0.1,0.1}', 
+#         'gp_file': mlmodelout, 
+#         'gap': gap, 
+#         'e0_method':'average',
+#         'sparse_separate_file': 'F'
+#     }
+#     gapfit               = []
+
+    # @classmethod
+    # def parse(cls,argsraw):
+    #     if len(argsraw) == 0:
+    #         printHelp()
+    #         stopper.stopMLatom('At least one option should be provided')
+    #     for arg in argsraw:
+    #         if (arg.lower() == 'help'
+    #           or arg.lower() == '-help'
+    #           or arg.lower() == '-h'
+    #           or arg.lower() == '--help'):
+    #             printHelp()
+    #             stopper.stopMLatom('')
+    #         elif arg.lower().split('=')[0] == 'gapfit':
+    #             exec(arg)
+    #             print(gapfit)
+    #             test=gapfit['gap']
+    #         elif arg.lower().split('.')[0] in ['gap-soap', 'gap', 'gap_fit', 'gapfit']:
+    #             if arg.lower().split('.')[1]=="gap":
+    #                 exec('cls.gapdic[arg.split(".")[2].split("=")[0]]=arg.split("=",1)[1]')
+    #                 cls.gap = '{'+' '.join([k+'='+v for k,v in cls.gapdic.items()])[5:]+'}'
+    #                 GAPCls.gapfitdict['gap']=cls.gap
+    #             else:
+    #                 exec('GAPCls.gapfitdict[arg.split(".")[1].split("=")[0]]=arg.split("=",1)[1]')   
+    #         elif len(arg.lower().split('=')) == 1:                             # parse boolean args
+    #             try:
+    #                 exec('cls.'+arg.lower())
+    #                 exec('cls.'+arg.lower()+'=True')
+    #             except: pass
+    #         else:                                               # parse other args
+    #             try:
+    #                 exec('cls.'+arg.split('=')[0].lower())
+    #                 if type(eval('cls.'+arg.split('=')[0].lower())) == str :
+    #                     exec('cls.'+arg.split('=')[0].lower()+'='+"arg.split('=')[1]")
+    #                 else:
+    #                     exec('cls.'+arg.split('=')[0].lower()+'='+arg.split('=')[1])
+    #             except:
+    #                 pass
+
+
+    #     # calc. & fix something args that useful and you don't want users to change...
+    #     with open(cls.xyzfile,'r') as f:
+    #         cls.natom = int(f.readline())
+    #         exec('f.readline()')
+    #         cls.atype = [f.readline().split()[0] for i in range(cls.natom)]
+        
+    #     # for estAccMLmodel that MLmodelIn may not be provided
+    #     if not cls.mlmodelin:
+    #         cls.mlmodelin = cls.mlmodelout
+    #     if 'default_sigma_e' in GAPCls.gapfitdict.keys(): 
+    #         GAPCls.gapfitdict['default_sigma']=GAPCls.gapfitdict['default_sigma'].replace(
+    #             GAPCls.gapfitdict['default_sigma'][1:-1].split(',')[0],
+    #             GAPCls.gapfitdict['default_sigma_e']
+    #         )
+    #         GAPCls.gapfitdict.pop('default_sigma_e')
+    #     if 'default_sigma_f' in GAPCls.gapfitdict.keys(): 
+    #         GAPCls.gapfitdict['default_sigma']=GAPCls.gapfitdict['default_sigma'].replace(
+    #             GAPCls.gapfitdict['default_sigma'][1:-1].split(',')[1],
+    #             GAPCls.gapfitdict['default_sigma_f']
+    #         )
+    #         GAPCls.gapfitdict.pop('default_sigma_f')
+    #     GAPCls.gapfitdict['default_sigma'] = " ".join(GAPCls.gapfitdict['default_sigma'].replace(',',', ').split())
+    #     GAPCls.gapfitdict['gp_file']=cls.mlmodelout
+    #     if cls.yfile: GAPCls.gapfitdict['energy_parameter_name']='energy'
+    #     if cls.ygradxyzfile: GAPCls.gapfitdict['force_parameter_name']='forces'
+    #     if cls.setname: GAPCls.gapfitdict['at_file']='GAP.exyz_'+cls.setname
+    #     cls.gapfit          = [GAPbin]
+    #     for k, v in GAPCls.gapfitdict.items():
+    #         cls.gapfit.append(k+'='+v)
+        
+            
+def printHelp():
+    helpText = __doc__ + '''
+  To use Interface_GAP, please define $gap_fit and $quip
+  to corresponding executables
+  
+  Arguments with their default values:
+    MLprog=GAP                 enables this interface
+    MLmodelType=GAP-SOAP       requests GAP-SOAP model
+    
+    gapfit.xxx=x               xxx could be any option for gap_fit
+                               Note that at_file and gp_file are not required
+    gapfit.gap.xxx=x           xxx could be any option for gap
+    gapfit.default_sigma={0.0005,0.001,0,0}
+                               sigmas for energies, forces, virals, Hessians
+    gapfit.e0_method=average   method for determining e0
+    gapfit.gap.type=soap       descriptor type
+    gapfit.gap.l_max=6         max number of angular basis functions
+    gapfit.gap.n_max=6         max number of radial  basis functions
+    gapfit.gap.atom_sigma=0.5  Gaussian smearing of atom density hyperparameter
+                                                  
+    gapfit.gap.zeta=4          hyperparameter for kernel sensitivity              
+    gapfit.gap.cutoff=6.0      cutoff radius of local environment
+    gapfit.gap.cutoff_transition_width=0.5  
+                               cutoff transition width
+    gapfit.gap.delta=1         hyperparameter delta for kernel scaling
+
+  Cite GAP method:
+    A. P. Bartok, M. C. Payne, R. Konor, G. Csanyi,
+    Phys. Rev. Lett. 2010, 104, 136403
+    
+  Cite SOAP descriptor:
+    A. P. Bartok,              R. Konor, G. Csanyi,
+    Phys. Rev. B     2013,  87, 184115
+'''
+    print(helpText)
+
+if __name__ == '__main__':
+    GAPCls()

MLatom/interfaces/PhysNet/PhysNet_predict.py

@@ -0,0 +1,180 @@
+#!/usr/bin/env python3
+
+import numpy as np
+import os
+import sys
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
+
+PhysNetdir = os.environ['PhysNet']
+sys.path.append(PhysNetdir)
+
+import tensorflow.compat.v1 as tf
+tf.disable_v2_behavior()
+import time
+import argparse
+import logging
+logging.getLogger('tensorflow').disabled = True
+
+from datetime import datetime
+from neural_network.NeuralNetwork  import *
+from neural_network.activation_fn  import *
+from training.DataContainer import *
+from training.DataProvider  import *
+
+def predict(PNargs):
+    tf.compat.v1.reset_default_graph()
+    #define command line arguments
+    parser = argparse.ArgumentParser(fromfile_prefix_chars='@')
+    parser.add_argument("--restart", type=str, default=None,  help="restart training from a specific folder")
+    parser.add_argument("--num_features", type=int,   help="dimensionality of feature vectors")
+    parser.add_argument("--num_basis", type=int,   help="number of radial basis functions")
+    parser.add_argument("--num_blocks", type=int,   help="number of interaction blocks")
+    parser.add_argument("--num_residual_atomic", type=int,   help="number of residual layers for atomic refinements")
+    parser.add_argument("--num_residual_interaction", type=int,   help="number of residual layers for the message phase")
+    parser.add_argument("--num_residual_output", type=int,   help="number of residual layers for the output blocks")
+    parser.add_argument("--cutoff", default=10.0, type=float, help="cutoff distance for short range interactions")
+    parser.add_argument("--use_electrostatic", default=1, type=int,   help="use electrostatics in energy prediction (0/1)")
+    parser.add_argument("--use_dispersion", default=1, type=int,   help="use dispersion in energy prediction (0/1)")
+    parser.add_argument("--grimme_s6", default=None, type=float, help="grimme s6 dispersion coefficient")
+    parser.add_argument("--grimme_s8", default=None, type=float, help="grimme s8 dispersion coefficient")
+    parser.add_argument("--grimme_a1", default=None, type=float, help="grimme a1 dispersion coefficient")
+    parser.add_argument("--grimme_a2", default=None, type=float, help="grimme a2 dispersion coefficient")
+    parser.add_argument("--num_train", type=int,   help="number of training samples")
+    parser.add_argument("--num_valid", type=int,   help="number of validation samples")
+    parser.add_argument("--seed", default=42, type=int,   help="seed for splitting dataset into training/validation/test")
+    parser.add_argument("--max_steps", type=int,   help="maximum number of training steps")
+    parser.add_argument("--learning_rate", default=0.001, type=float, help="learning rate used by the optimizer")
+    parser.add_argument("--max_norm", default=1000.0, type=float, help="max norm for gradient clipping")
+    parser.add_argument("--ema_decay", default=0.999, type=float, help="exponential moving average decay used by the trainer")
+    parser.add_argument("--keep_prob", default=1.0, type=float, help="keep probability for dropout regularization of rbf layer")
+    parser.add_argument("--l2lambda", type=float, help="lambda multiplier for l2 loss (regularization)")
+    parser.add_argument("--nhlambda", type=float, help="lambda multiplier for non-hierarchicality loss (regularization)")
+    parser.add_argument("--decay_steps", type=int, help="decay the learning rate every N steps by decay_rate")
+    parser.add_argument("--decay_rate", type=float, help="factor with which the learning rate gets multiplied by every decay_steps steps")
+    parser.add_argument("--batch_size", type=int, help="batch size used per training step")
+    parser.add_argument("--valid_batch_size", type=int, help="batch size used for going through validation_set")
+    parser.add_argument('--force_weight',  default=52.91772105638412, type=float, help="this defines the force contribution to the loss function relative to the energy contribution (to take into account the different numerical range)")
+    parser.add_argument('--charge_weight', default=14.399645351950548, type=float, help="this defines the charge contribution to the loss function relative to the energy contribution (to take into account the different numerical range)")
+    parser.add_argument('--dipole_weight', default=27.211386024367243, type=float, help="this defines the dipole contribution to the loss function relative to the energy contribution (to take into account the different numerical range)")
+    parser.add_argument('--summary_interval', type=int, help="write a summary every N steps")
+    parser.add_argument('--validation_interval', type=int, help="check performance on validation set every N steps")
+    parser.add_argument('--save_interval', type=int, help="save progress every N steps")
+    parser.add_argument('--record_run_metadata', type=int, help="records metadata like memory consumption etc.")
+
+    #if no command line arguments are present, config file is parsed
+    config_file = os.path.join(PNargs.mlmodelin, 'config.txt')
+
+    if os.path.isfile(config_file):
+        args = parser.parse_args(["@"+config_file])
+    else:
+        args = parser.parse_args(["--help"])
+    if PNargs.setname: PNargs.setname='_'+PNargs.setname
+    #construct file path to directory which stores the best checkpoint files
+    best_dir = os.path.join(PNargs.mlmodelin, 'best')
+    testfile = 'PhysNet'+PNargs.setname+'.npz'
+    #load dataset
+    data = DataContainer(testfile)
+
+    data_provider = DataProvider(data, 0, 0, 0, 0, seed=args.seed)
+
+    #create neural network
+    # NASdict = np.load(os.path.join(PNargs.mlmodelin, 'NAS.npz'))
+    # tf.reset_default_graph()
+    nn = NeuralNetwork(F=args.num_features,           
+                    K=args.num_basis,                
+                    sr_cut=args.cutoff,              
+                    num_blocks=args.num_blocks, 
+                    num_residual_atomic=args.num_residual_atomic,
+                    num_residual_interaction=args.num_residual_interaction,
+                    num_residual_output=args.num_residual_output,
+                    use_electrostatic=(args.use_electrostatic==1),
+                    use_dispersion=(args.use_dispersion==1),
+                    s6=args.grimme_s6,
+                    s8=args.grimme_s8,
+                    a1=args.grimme_a1,
+                    a2=args.grimme_a2,
+                    # Eshift=NASdict['Eshift'],  
+                    # Escale=NASdict['Escale'],   
+                    activation_fn=shifted_softplus, 
+                    seed=None,
+                    scope="neural_network")
+    #create placeholders for feeding data
+    Eref      = tf.placeholder(tf.float32, shape=[None, ], name="Eref")
+    Fref      = tf.placeholder(tf.float32, shape=[None,3], name="Fref") 
+    Z         = tf.placeholder(tf.int32,   shape=[None, ], name="Z")     
+    Dref      = tf.placeholder(tf.float32, shape=[None,3], name="Dref") 
+    Qref      = tf.placeholder(tf.float32, shape=[None, ], name="Qref")   
+    R         = tf.placeholder(tf.float32, shape=[None,3], name="R")      
+    idx_i     = tf.placeholder(tf.int32,   shape=[None, ], name="idx_i") 
+    idx_j     = tf.placeholder(tf.int32,   shape=[None, ], name="idx_j") 
+    batch_seg = tf.placeholder(tf.int32,   shape=[None, ], name="batch_seg") 
+
+    #model energy/forces
+    Ea, Qa, Dij, nhloss = nn.atomic_properties(Z, R, idx_i, idx_j)
+    energy, forces = nn.energy_and_forces_from_atomic_properties(Ea, Qa, Dij, Z, R, idx_i, idx_j, Qref, batch_seg)
+    #total charge
+    Qtot = tf.segment_sum(Qa, batch_seg)
+    #dipole moment vector
+    QR = tf.stack([Qa*R[:,0], Qa*R[:,1], Qa*R[:,2]],1)
+    D  = tf.segment_sum(QR, batch_seg)
+
+ 
+
+    #helper function to fill a feed dictionary
+    def fill_feed_dict(data):
+        feed_dict = { 
+            Eref:      data["E"], 
+            Fref:      data["F"],
+            Z:         data["Z"], 
+            Dref:      data["D"],
+            Qref:      data["Q"],
+            R:         data["R"],
+            idx_i:     data["idx_i"],
+            idx_j:     data["idx_j"],
+            batch_seg: data["batch_seg"] 
+        }
+        return feed_dict
+
+    #helper function to print errors
+
+    def output_est(sess, all_data, data_count):
+        with open(PNargs.yestfile,'w') as fy, open(PNargs.ygradxyzestfile,'wb') as fgrad:
+            line="%d\n\n" % PNargs.natom
+            for i in range(data_count):
+                data = all_data[i]
+                feed_dict = fill_feed_dict(data)
+                E_tmp, F_tmp = sess.run([energy, forces], feed_dict=feed_dict)
+                fy.write('%f\n' % E_tmp)
+                fgrad.write(line.encode('utf-8'))
+                np.savetxt(fgrad, -1*F_tmp, fmt='%20.12f', delimiter=" ")
+
+    
+
+    #create tensorflow session
+    with tf.Session() as sess:
+        #restore latest checkpoint
+        checkpoint = tf.train.latest_checkpoint(best_dir)
+        assert checkpoint is not None
+        nn.restore(sess, checkpoint)
+
+        #calculate errors on test data
+        print(' ')
+        # print('##### ------------ Estimating ------------ #####')
+        
+        start = time.time()
+    
+        output_est(sess, data, len(data))
+
+        end = time.time()
+        hours, rem = divmod(end-start, 3600)
+        minutes, seconds = divmod(rem, 60)
+
+        # print(' ')
+        # print('--------------------------------------------------')
+        # print('Total CPU time for estimating - {:0>2}:{:0>2}:{:05.2f}'.format(int(hours),int(minutes),seconds))
+        # print('--------------------------------------------------')
+        # print(' ')
+
+    
+
+