def amp_md(atoms, nstep, dt):
from ase import units
from ase.md.velocitydistribution import MaxwellBoltzmannDistribution
from ase.md import VelocityVerlet
traj = ase.io.Trajectory("traj.traj", 'w')
try:
calc = Amp.load("amp.amp")
except FileNotFoundError:
try:
calc = Amp.load("amp-untrained-parameters.amp")
except FileNotFoundError:
print("Error: amp-pes.amp file does not exist, input amp-pot file by -p")
sys.exit(1)
atoms.set_calculator(calc)
atoms.get_potential_energy()
MaxwellBoltzmannDistribution(atoms, 300 * units.kB)
traj.write(atoms)
dyn = VelocityVerlet(atoms, dt=dt * units.fs)
f = open("md.ene", "w")
f.write("{:^5s} {:^10s} {:^10s} {:^10s}\n".format("time","Etot","Epot","Ekin"))
for step in range(nstep):
pot = atoms.get_potential_energy() #
kin = atoms.get_kinetic_energy()
tot = pot + kin
f.write("{:5d}{:10.5f}{:10.5f}{:10.5f}\n".format(step, tot, pot, kin))
print("{}: Total Energy={}, POT={}, KIN={}".format(step, tot, pot, kin))
dyn.run(2)
traj.write(atoms) # write kinetic energy, but pot is not seen in ase
f.close()
def update(self, rs, es, fs):
"""
training data with machine-learning module given by ml_module
"""
print "Start to train"
if self.train_endpoints:
print "End points used for training"
nimages = self.nimages
n_offset = 0
self.train_endpoints = False
else:
nimages = self.nimages - 2
n_offset = 1
for i in range(nimages):
self.band.path[i + n_offset].set_positions(rs[i])
#self.approxPot_replica.set_positions(r)
#f = f - self.approxPot_replica.get_forces()
#e = e - self.approxPot_replica.get_potential_energy()
pseudoAtoms = self.band.path[i + n_offset].copy()
pseudoAtoms.set_calculator(pseudoCalculator(energy= es[i], \
forces= fs[i]))
pseudoAtoms.get_potential_energy()
pseudoAtoms.get_forces()
self.training_set.append(pseudoAtoms)
self.training_traj.write(pseudoAtoms)
#self.training_set=Trajectory('training.traj','r')
#os.chdir(workdir)
if os.path.exists('amp-fingerprint-primes.ampdb'):
os.system('rm -rf amp-fingerprint-primes.ampdb')
if os.path.exists('amp-fingerprints.ampdb'):
os.system('rm -rf amp-fingerprints.ampdb')
if os.path.exists('amp-fingerprints.ampdb'):
os.system('rm -rf amp-neighborlists.ampdb')
#if os.path.exists('amp.amp'):
# os.system('rm amp.amp')
#if os.path.exists('amp-untrained-parameters.amp'):
#load nn model including lossfunction
# os.system('rm amp-untrained-parameters.amp')
try:
self.progress_log.write("Train ml model\n")
self.ml_module.train(images='training.traj', overwrite=True)
except TrainingConvergenceError:
os.system('mv amp-untrained-parameters.amp amp.amp')
pass
#load ml model
try:
ml_calc = Amp.load('amp.amp')
except:
ml_calc = Amp.load('amp-untrained-parameters.amp')
pass
for i in range(self.nimages):
self.band_ml.path[i].set_calculator(ml_calc)
def calc_test_images(test_images,
amp_pes,
title,
suptitle,
ncore,
Lgraph,
val_id=None,
nmol=1,
Ltwinx=None):
try:
calc = Amp.load(amp_pes)
except FileNotFoundError:
try:
calc = Amp.load("amp-untrained-parameters.amp")
except FileNotFoundError:
print(
"Error: amp-pes.amp file does not exist, input amp-pot file by -p"
)
sys.exit(1)
escale = 1 # my_chem.ev2kj
y = []
y_bar = []
#return # this runs
for mol in test_images:
y.append(mol.get_potential_energy() / nmol)
mol.set_calculator(calc)
y_bar.append(mol.get_potential_energy() / nmol)
with open("amp_test.txt", 'w') as f:
f.write("\ttrue\t\thypothesis\n")
for y1, ybar1 in zip(y, y_bar):
f.write(f"{y1:15.5f} {ybar1:15.5f}\n")
if Lgraph:
modulename = 'myplot2D' ### FOR MLET
if modulename not in sys.modules:
import myplot2D
err, res_max = myplot2D.draw_amp_twinx(y,
y_bar,
title,
suptitle,
Ltwinx=Ltwinx,
Ldiff=True)
else:
h_conv = np.array(y_bar) # * escale
y_conv = np.array(y) # * escale
diff = np.subtract(h_conv, y_conv)
err = np.sqrt((diff**2).mean())
res_max = abs(max(diff, key=abs))
#err = rmse(y, y_bar)*escale
return err, res_max
def re_train_images(images, HL, E_conv):
Hidden_Layer=tuple(HL)
print("Hidden Layer: {}".format(Hidden_Layer))
print("Energy convergence: {}".format(E_conv))
calc = Amp.load("amp.amp", cores=20)
calc.model.lossfunction = LossFunction(convergence={'energy_rmse': E_conv})
calc.train(images=images, overwrite=True)
def main():
calc = Amp.load('amp.amp')
"""Read the reactant coordinates"""
p1 = read('POSCAR_rs', index=0, format='vasp')
# p1.set_cell([[20,0,0],[0,20,0],[0,0,20]],scale_atoms=False)
# p1.set_pbc((True, True, True))
p1.set_calculator(calc)
"""Read the product coordinates"""
p2 = read('POSCAR_fs', index=0, format='vasp')
p2.set_calculator(calc)
nim = 12 # number of images, including end points
band = neb.ssneb(p1, p2, numImages=nim, method='normal', ss=False)
# to restart, uncomment the following lines which read the previous optimized images into the band
# for i in range(1,nim-1):
# filename = str(i)+'.CON'
# b = read(filename,format='vasp')
# band.path[i].set_positions(b.get_positions())
# band.path[i].set_cell(b.get_cell())
# opt = neb.qm_ssneb(band, maxmove =0.1, dt=0.05)
#Uncomment to use fire optimization algorithm
opt = neb.fire_ssneb(band, maxmove=0.1, dtmax=0.05, dt=0.05)
opt.minimize(forceConverged=0.10, maxIterations=400)
def run_md(fdata, atoms):
from ase import units
from ase.md.velocitydistribution import MaxwellBoltzmannDistribution
from ase.md import VelocityVerlet
fdata = fdata[:-7]
traj = ase.io.Trajectory(fdata + ".traj", 'w')
calc = Amp.load("amp.amp")
atoms.set_calculator(calc)
atoms.get_potential_energy()
MaxwellBoltzmannDistribution(atoms,
100. * units.kB) #Boltzmann constant eV/K
traj.write(atoms)
dyn = VelocityVerlet(atoms, dt=1. * units.fs)
for step in range(200):
pot = atoms.get_potential_energy() #
kin = atoms.get_kinetic_energy()
with open(fdata + '.txt', 'a') as f:
f.write("{}: Total Energy={}, POT={}, KIN={}\n".format(
step, pot + kin, pot, kin))
dyn.run(5)
ase.io.write(fdata + '.xyz', ase.io.read(fdata + '.traj'), append=True)
traj.write(atoms)
def get_atomic_electronegativities(self, hash, calc):
"""
Returns
-------
atomic_electronegativity : dict
Dictionary with keys (index, symbol) and value (atomic
electronegativity).
electronegativity_vector : list
List of electronegativities.
"""
atomic_electronegativity = OrderedDict()
electronegativity_vector = []
# calculating fingerprints
self.descriptor.calculate_fingerprints(self.images)
self.descriptor.fingerprints.open()
fingerprints = self.descriptor.fingerprints[hash]
# Load Amp calculator
nn_calc = Amp.load(self.calc)
for index, (symbol, afp) in enumerate(fingerprints):
en = nn_calc.model.calculate_atomic_energy(afp, index, symbol)
atomic_electronegativity[(index, symbol)] = en
electronegativity_vector.append(-en)
electronegativity_vector = np.array(electronegativity_vector)
return atomic_electronegativity, electronegativity_vector
def train_test():
label = 'train_test_g5/calc'
train_images = generate_data(2)
elements = ['Pt', 'Cu']
G = make_symmetry_functions(elements=elements,
type='G2',
etas=np.logspace(np.log10(0.05),
np.log10(5.),
num=4))
G += make_symmetry_functions(elements=elements,
type='G5',
etas=[0.005],
zetas=[1., 4.],
gammas=[+1., -1.])
G = {element: G for element in elements}
calc = Amp(descriptor=Gaussian(Gs=G),
model=NeuralNetwork(hiddenlayers=(3, 3)),
label=label,
cores=1)
loss = LossFunction(convergence={'energy_rmse': 0.02, 'force_rmse': 0.03})
calc.model.lossfunction = loss
calc.train(images=train_images, )
for image in train_images:
print("energy = %s" % str(calc.get_potential_energy(image)))
print("forces = %s" % str(calc.get_forces(image)))
# Test that we can re-load this calculator and call it again.
del calc
calc2 = Amp.load(label + '.amp')
for image in train_images:
print("energy = %s" % str(calc2.get_potential_energy(image)))
print("forces = %s" % str(calc2.get_forces(image)))
def create_calc(self, label, dblabel):
amp_label = os.path.join(self.calc_dir, label)
amp_dblabel = os.path.join(self.calc_dir, dblabel)
amp_name = amp_label + ".amp"
if not os.path.exists(amp_name):
print("Creating calculator {}...".format(amp_name))
loss_function = LossFunction(
convergence=self.convergence,
energy_coefficient=self.energy_coefficient,
force_coefficient=self.force_coefficient,
overfit=self.overfit,
)
model = NeuralNetwork(
hiddenlayers=self.hidden_layers,
activation=self.activation,
lossfunction=loss_function,
weights=None,
scalings=None,
prescale=True,
)
descriptor = Gaussian(cutoff=self.cutoff, Gs=self.Gs, fortran=True)
calc = Amp(descriptor=descriptor,
model=model,
label=amp_label,
dblabel=amp_dblabel)
return calc
else:
print("Calculator {} already exists!".format(amp_name))
calc = Amp.load(amp_name, label=amp_label, dblabel=amp_dblabel)
return calc
def run_md(atoms):
from ase import units
from ase.md.velocitydistribution import MaxwellBoltzmannDistribution
from ase.md import VelocityVerlet
traj = ase.io.Trajectory("traj.traj", 'w')
calc = Amp.load("amp.amp")
atoms.set_calculator(calc)
atoms.get_potential_energy()
MaxwellBoltzmannDistribution(atoms, 10. * units.kB)
traj.write(atoms)
dyn = VelocityVerlet(atoms, dt=1. * units.fs)
f = open("md.ene", "w")
f.write("{:^5s}{:^10s}{:^10s}{:^10s}\n".format("time", "Etot", "Epot",
"Ekin"))
for step in range(100):
pot = atoms.get_potential_energy() #
kin = atoms.get_kinetic_energy()
tot = pot + kin
f.write("{:5d}{:10.5f}{:10.5f}{:10.5f}\n".format(step, tot, pot, kin))
print("{}: Total Energy={}, POT={}, KIN={}".format(
step, tot, pot, kin))
dyn.run(10)
traj.write(atoms)
f.close()
def train_test():
"""Gaussian/KRR train test."""
label = 'train_test/calc'
train_images = generate_data(2)
traj = Trajectory('trainingset.traj', mode='w')
for image in train_images:
traj.write(image)
calc = Amp(descriptor=Gaussian(),
model=KernelRidge(forcetraining=True, trainingimages='trainingset.traj'),
label=label,
cores=1)
calc.train(images=train_images,)
for image in train_images:
print("energy = %s" % str(calc.get_potential_energy(image)))
print("forces = %s" % str(calc.get_forces(image)))
# Test that we can re-load this calculator and call it again.
del calc
calc2 = Amp.load(label + '.amp')
for image in train_images:
print("energy = %s" % str(calc2.get_potential_energy(image)))
print("forces = %s" % str(calc2.get_forces(image)))
def run_amp(fdata, job, ndata):
total_images = ase.io.read(fdata, index=':')
if job == "train":
if not ndata:
#images = ase.io.read(fdata, index=':')
images = total_images
print("Start training using all the data %d" % len(total_images))
else:
#images = ase.io.read(fdata, index=':ndata')
images = total_images[:ndata]
print("number of traing data %d/%d" % (len(images), len(total_images)))
train_images(images)
elif job == "test":
#images = ase.io.read(fdata, index='ndata:')
images = total_images[ndata:]
calc = Amp.load("amp.amp")
#print(images[0])
y=[]
y_bar=[]
for mol in images:
y.append(mol.get_potential_energy())
#print(mol.get_potential_energy())
mol.set_calculator(calc)
y_bar.append(mol.get_potential_energy())
#print(mol.get_potential_energy())
#print(images[0])
draw(y, y_bar)
return
def update(self, r, e, f):
"""
training data with machine-learning module given by ml_module
"""
#workdir = self.cwd+'/training'
#if not os.path.isdir(workdir):
# make_dir(workdir)
r = r.reshape(-1, 3)
self.atoms.set_positions(r)
#self.approxPot_replica.set_positions(r)
#f = f - self.approxPot_replica.get_forces()
#e = e - self.approxPot_replica.get_potential_energy()
pseudoAtoms = self.atoms.copy()
pseudoAtoms.set_calculator(pseudoCalculator(energy= e, \
forces= f))
pseudoAtoms.get_potential_energy()
pseudoAtoms.get_forces()
self.training_set.append(pseudoAtoms)
self.training_traj.write(pseudoAtoms)
#self.training_set=Trajectory('training.traj','r')
#os.chdir(workdir)
if os.path.exists('amp-fingerprint-primes.ampdb'):
os.system('rm -rf amp-fingerprint-primes.ampdb')
if os.path.exists('amp-fingerprints.ampdb'):
os.system('rm -rf amp-fingerprints.ampdb')
if os.path.exists('amp-fingerprints.ampdb'):
os.system('rm -rf amp-neighborlists.ampdb')
#if os.path.exists('amp.amp'):
# os.system('rm amp.amp')
#if os.path.exists('amp-untrained-parameters.amp'):
#load nn model including lossfunction
# os.system('rm amp-untrained-parameters.amp')
try:
self.progress_log.write("Train ml model\n")
self.ml_module.train(images='training.traj', overwrite=True)
except TrainingConvergenceError:
os.system('mv amp-untrained-parameters.amp amp.amp')
pass
#load ml model
try:
self.replica.set_calculator(Amp.load('amp.amp'))
except:
self.replica.set_calculator(
Amp.load('amp-untrained-parameters.amp'))
pass
def exe_test_images(images_4test, amp_pes, title, suptitle):
calc = Amp.load(amp_pes)
y = []
y_bar = []
for mol in images_4test:
y.append(mol.get_potential_energy())
mol.set_calculator(calc)
y_bar.append(mol.get_potential_energy())
draw_dots_two(y, y_bar, title, suptitle)
def test():
# LOAD DATA
path = "/home/unknown/Dropbox/Oscar/Skola/LTU/Project course engineering physics/Results/CNT Capped/data" # Path to data
results = [
y for x in os.walk(path) for y in glob(os.path.join(x[0], '*.db'))
]
print("Files found and imported:")
for i in results:
print i
images = []
for i in results:
images.extend(io.read(i, index=':'))
#images = images[:500]
print('Total number of images imported: %i' % len(images))
# Train the calculator.
#train_images, test_images = randomize_images(images)
train_images = images
#calc = Amp(descriptor=Gaussian(),
# model=NeuralNetwork(hiddenlayers=(20, 20)))
calc = Amp.load('parameters-checkpoint-600.amp')
#calc.model.lossfunction = LossFunction(
# convergence={'energy_rmse': 1,
# 'force_rmse': 0.01})
#calc.train(train_images)
# Plot and test the predictions.
import matplotlib
matplotlib.use('Agg')
from matplotlib import pyplot
fig, ax = pyplot.subplots()
#train = open('train.csv','a')
#test = open('test.csv','a')
#for image in train_images:
# actual_energy = image.get_potential_energy()
# predicted_energy = calc.get_potential_energy(image)
# ax.plot(actual_energy, predicted_energy, 'b.')
# string = "%s,%s\n" %(actual_energy,predicted_energy)
# train.write(string)
#train.close()
for image in train_images:
actual_energy = image.get_potential_energy()
predicted_energy = calc.get_potential_energy(image)
ax.plot(actual_energy, predicted_energy, 'r.')
string = "%s,%s\n" % (actual_energy, predicted_energy)
ax.set_xlabel('Actual energy, eV')
ax.set_ylabel('Amp energy, eV')
fig.savefig('parityplot.png')
def run_amp(fdata, job, ndata, HL, E_conv):
total_images = ase.io.read(fdata, index=':')
if job == "train":
if not ndata:
#images = ase.io.read(fdata, index=':')
images = total_images
print("Start training using all the data %d" % len(total_images))
#images = ase.io.read(fdata, index=':
images = total_images[:ndata]
print("number of traing data %d/%d" %
(len(images), len(total_images)))
train_images(images, HL, E_conv)
elif job == "test":
#images = ase.io.read(fdata, index='ndata:')
images = total_images[ndata:]
import glob
amps = glob.glob('*.amp')
if 'amp.amp' in amps:
calc = Amp.load("amp.amp")
else:
calc = Amp.load("amp-untrained-parameters.amp")
#print(images[0])
y = []
y_bar = []
for mol in images:
y.append(mol.get_potential_energy())
#print(mol.get_potential_energy())
mol.set_calculator(calc)
y_bar.append(mol.get_potential_energy())
#print(mol.get_potential_energy())
#print(images[0])
draw(fdata, y, y_bar)
elif job == 'md':
if not ndata:
atoms = ase.io.read(fdata, index='0')
else:
atoms = ase.io.read(fdata, index=ndata)
run_md(fdata, atoms)
return
def run_amp(fdata, job, ndata, HL, E_conv):
total_images = ase.io.read(fdata, index=':')
if job == "train":
if not ndata:
#images = ase.io.read(fdata, index=':')
images = total_images
print("Start training using all the data %d" % len(total_images))
else:
#images = ase.io.read(fdata, index=':ndata')
images = total_images[:ndata]
print("number of training data %d/%d" % (len(images), len(total_images)))
train_images(images, HL, E_conv)
elif job == "retrain":
if not ndata:
images = total_images
print("Start re-training using all the data %d" % len(total_images))
else:
images = total_images[:ndata]
print("number of re-training data %d/%d" % (len(images), len(total_images)))
re_train_images(images, HL, E_conv)
elif job == "test":
#images = ase.io.read(fdata, index='ndata:')
images = total_images[ndata:]
calc = Amp.load("amp.amp")
#print(title)
#print(images[0])
y=[]
y_bar=[]
for mol in images:
y.append(mol.get_potential_energy())
#print(mol.get_potential_energy())
mol.set_calculator(calc)
y_bar.append(mol.get_potential_energy())
#print(mol.get_potential_energy())
#print(images[0])
h_conv = np.array(y_bar) * kcal2kj
y_conv = np.array(y) * kcal2kj
diff = np.subtract(h_conv,y_conv)
rmse = np.sqrt((diff**2).mean())
max_res = abs(max(diff, key=abs))
with open("score", 'w') as f:
f.write("{}\n".format(0.9*max_res+0.1*rmse))
os.system("cat HL score > ./pop_fit.txt")
if os.path.isfile('HL'):
os.remove('HL')
return
def exe_test_images(job, test_images, amp_pes, title, suptitle, val_id=None):
calc = Amp.load(amp_pes)
y = []
y_bar = []
#return # this runs
for mol in test_images:
y.append(mol.get_potential_energy())
mol.set_calculator(calc)
y_bar.append(mol.get_potential_energy())
return # this evokes error
if re.search("te", job):
draw_dots_two(y, y_bar, title, suptitle)
elif re.search("va", job):
err = rmse(y, y_bar)
print("in job {}-{}: validation error is {}".format(job, val_id, err))
def generate_data(count, filename='cmd.traj'):
"""Generates test or training data with a simple MD simulation."""
if os.path.exists(filename):
return
traj = io.Trajectory(filename, 'w')
atoms = io.read('2.xyz')
atoms.set_calculator(Amp.load('sio2.amp'))
atoms.get_potential_energy()
traj.write(atoms)
mb(atoms, 300. * units.kB)
# dyn = vv(atoms, dt=1. * units.fs, logfile='cmd.log')
dyn = NVTB(atoms,
timestep=0.5 * units.fs,
temperature=300,
taut=2.0 * units.fs,
logfile='cmd.log')
for step in range(count - 1):
dyn.run(1)
traj.write(atoms)
def force_integration(images, amp_calc=None):
"""Compute force integration over images using pure ML
Parameters
----------
images : str
Path to images.
amp_calc : str
Path to .amp file containing information of the machine-learning model.
"""
# Loading data
data = Trajectory(images)
# Computing references E0 can be 0 or a DFT calcualtion of the reference
E0 = 0
p0 = data[0].get_positions()
# Loading Amp calculator
amp_calc = Amp.load(amp_calc)
temp = 0
for index in range(len(data)):
image = data[index]
p1 = image.get_positions()
if index == 0:
forcesi = amp_calc.get_forces(data[0])
else:
p0 = data[index - 1].get_positions()
forcesi = amp_calc.get_forces(data[index - 1])
forcesj = amp_calc.get_forces(image)
forces = (forcesj + forcesi) / 2
E = 0.
for atom in range(len(image)):
driu = p1[atom] - p0[atom]
temp += forces[atom].dot(driu)
E = E0 - temp
print(E)
return E
def run_md(atoms):
from ase import units
from ase.md.velocitydistribution import MaxwellBoltzmannDistribution
from ase.md import VelocityVerlet
traj = ase.io.Trajectory("traj.traj", 'w')
calc = Amp.load("amp.amp")
atoms.set_calculator(calc)
atoms.get_potential_energy()
MaxwellBoltzmannDistribution(atoms, 300. * units.kB)
traj.write(atoms)
dyn = VelocityVerlet(atoms, dt=1. * units.fs)
for step in range(100):
pot = atoms.get_potential_energy() #
kin = atoms.get_kinetic_energy()
print("{}: Total Energy={}, POT={}, KIN={}".format(
step, pot + kin, pot, kin))
dyn.run(10)
traj.write(atoms)
def exe_test_images(job,
test_images,
amp_pes,
title,
suptitle,
Lgraph,
val_id=None):
calc = Amp.load(amp_pes)
y = []
y_bar = []
#return # this runs
for mol in test_images:
y.append(mol.get_potential_energy())
mol.set_calculator(calc)
y_bar.append(mol.get_potential_energy())
if Lgraph:
err = draw_dots_two(y, y_bar, title, suptitle)
else:
err = rmse(y, y_bar) * my_chem.ev2kj
return err
def calc_train_images(images, HL, E_conv, f_conv, f_coeff, ncore, amp_pot=None):
Hidden_Layer=tuple(HL)
print("Hidden Layer: {}".format(Hidden_Layer))
print("Energy convergence: {}".format(E_conv))
cores={'localhost':ncore} # 'localhost' depress SSH, communication between nodes
### load "amp.amp"
if amp_pot:
calc = Amp.load(amp_pot)
calc = Amp(descriptor=Gaussian(), model=NeuralNetwork(hiddenlayers=Hidden_Layer), cores=cores)
### Global Search in Param Space
Annealer(calc=calc, images=images, Tmax=20, Tmin=1, steps=4000)
if f_conv <= 0.0:
E_maxresid = E_conv*3
#convergence={'energy_rmse': E_conv}
convergence={'energy_rmse': E_conv, 'energy_maxresid': E_maxresid}
else:
convergence={'energy_rmse': E_conv, 'force_rmse':f_conv}
calc.model.lossfunction = LossFunction(convergence=convergence, force_coefficient=f_coeff) # setting
calc.train(images=images, overwrite=True)
return
def train_test():
"""Gaussian/Neural train test."""
label = 'train_test/calc'
train_images = generate_data(2)
calc = Amp(descriptor=Gaussian(),
model=NeuralNetwork(hiddenlayers=(3, 3)),
label=label,
cores=1)
loss = LossFunction(convergence={'energy_rmse': 0.02, 'force_rmse': 0.03})
calc.model.lossfunction = loss
calc.train(images=train_images, )
for image in train_images:
print("energy = %s" % str(calc.get_potential_energy(image)))
print("forces = %s" % str(calc.get_forces(image)))
# Test that we can re-load this calculator and call it again.
del calc
calc2 = Amp.load(label + '.amp')
for image in train_images:
print("energy = %s" % str(calc2.get_potential_energy(image)))
print("forces = %s" % str(calc2.get_forces(image)))
def run_amp(fdata, job, ndata):
"""
if nsets == 1:
train_all(images)
else:
job = 'test'
ndata = len(images)
data_sets = divide_dataset(ndata, nsets)
images = ase.io.read(fin, index='250:')
"""
print(ndata)
if job == "all":
images = ase.io.read(fdate, index=':')
train_all(images)
elif job == "train":
images = ase.io.read(fdate, index=':ndata')
ndata = len(images)
calc = Amp.load("amp.amp")
#print(images[0])
y = []
y_bar = []
for mol in images:
y.append(mol.get_potential_energy())
#print(mol.get_potential_energy())
mol.set_calculator(calc)
y_bar.append(mol.get_potential_energy())
#print(mol.get_potential_energy())
#print(images[0])
draw(len(images), y, y_bar)
return
timestep=timestep,
)
label = "energy-trained"
dblabel = label + "-train"
calc = trn.create_calc(label=label, dblabel=dblabel)
ann = Annealer(calc=calc,
images=train_traj,
Tmax=20,
Tmin=1,
steps=2000,
train_forces=False)
amp_name = trn.train_calc(calc, train_traj)
label = os.path.join("calcs", "force-trained")
dblabel = label + "-train"
calc = Amp.load(amp_name, label=label, dblabel=dblabel)
convergence = {
"energy_rmse": 1e-16,
"force_rmse": 1e-16,
"max_steps": max_steps
}
loss_function = LossFunction(
convergence=convergence,
energy_coefficient=1.0,
force_coefficient=0.1,
overfit=overfit,
)
calc.model.lossfunction = loss_function
amp_name = trn.train_calc(calc, train_force_traj)
{% if overwrite %}
overwrite = {{ overwrite }}
{% else %}
overwrite = False
{% endif %}
cores = {{ cores }}
# Set working directory
os.chdir(work_dir)
# Create DB update strings
update_str = "_".join([str(f) for f in framework])
update_key = "nn_" + update_str + "_iter{}".format(iteration)
# Load Amp object
calc = Amp.load(load_path, cores=cores)
# Get atoms from the database
images = []
new_db = os.path.join(os.path.dirname(load_path), "DB.db")
shutil.copyfile(db_path, new_db)
db = connect(new_db)
for d in db.select(selection):
if not overwrite and update_key in d.key_value_pairs.keys():
continue
atoms = db.get_atoms(d.id)
atoms.set_calculator(calc)
energy = atoms.get_potential_energy()
update = {update_key: energy}
from ase import io
from amp import Amp
from amp.descriptor.gaussian import Gaussian
from amp.model.neuralnetwork import NeuralNetwork
from amp.model import LossFunction
import numpy as np
dirName = './'
x = io.read(dirName + 'train.traj', index=':')[200:400]
#y = io.read(dirName + '../' + 'h3o-spe-1.traj', index=':')[50:100]
test_images = x
nimages = len(test_images)
test_energy = [image.get_potential_energy() for image in test_images]
rmse = []
for namp in range(100, 1500, 100):
print('Current amp parameters: %d' % namp)
calc = Amp.load(dirName + 'checkpoint/' + '%d.amp' % namp, cores=1)
nnp_energy = [calc.get_potential_energy(image) for image in test_images]
testfile = open(dirName + 'trained-%d.dat' % namp, 'w')
for i in range(nimages):
print('%15.8f %15.8f' % (test_energy[i], nnp_energy[i]), file=testfile)
testfile.close()
rmse.append(
np.sqrt(
np.sum((np.array(test_energy) - np.array(nnp_energy)))**2 * 1.0 /
nimages))
with open(dirName + 'trained-rmse.dat', 'w') as foo:
for i, value in enumerate(rmse):
print('%5d %15.8f' % ((i + 1) * 100, value), file=foo)
import ase.io
from ase.constraints import FixAtoms
from amp import Amp
atoms = ase.io.read("H2O.xyz")
atoms.center(vacuum=5.0)
atoms.set_pbc([True, True, True])
atoms.write("CENTERED.xsf")
atoms.set_pbc([False, False, False])
atoms.set_constraint(FixAtoms(mask=[0]))
calc = Amp.load("amp.amp")
atoms.set_calculator(calc)
from ase.optimize import BFGS
relax = BFGS(atoms, logfile="LOG_relax_bfgs_AMP", trajectory="geoopt_amp.traj")
relax.run()
print('NodePlot Training Images')
nodeplot2.plot(train_images, filename='node_plot_train.pdf')
#############################################################
import numpy as np
if use_cache:
actual_energy_train, MLIP_energy_train = np.loadtxt('train_energies.txt',
usecols=[0, 1],
unpack=True)
actual_energy_test, MLIP_energy_test = np.loadtxt('test_energies.txt',
usecols=[0, 1],
unpack=True)
else:
from amp import Amp
from amp.utilities import Logger, make_filename
MLIP = Amp.load(MLIP_file_name)
MLIP._log = Logger(make_filename('', log_file))
def MLIP_eval(image):
return MLIP.get_potential_energy(image) / len(image)
from multiprocessing import Pool, cpu_count
my_pool = Pool(cpu_count())
print('Training Images...')
MLIP_energy_train = my_pool.map(MLIP_eval, train_images)
for i in range(len(train_images)):
image = train_images[i]
#if i%100==0: print(i,'/', len(train_images))
actual_energy_train.append(image.get_potential_energy() / len(image))
#MLIP_energy_train.append( MLIP.get_potential_energy(image)/len(image))
#!/home/joonho/anaconda3/bin/python
import numpy as np
from ase.io import read,write
from amp import Amp
from amp.convert import save_to_prophet
import os
#Make PROPHET/lammps potentials
calc = Amp.load('amp.amp', cores = 1)
save_to_prophet(calc)
#Read starting configuration
atoms = read('starting_configuration.traj')
# Number of atoms to create
natoms = len(atoms)
ntypes = len(set(atoms.get_chemical_symbols()))
symbols = ['H', 'O'] #sort them according to atomic number - not alphabetically - to be consistent with masses
masses = list(set(atoms.get_masses()))
masses.sort()
atom_numbers = {}
for i, symbol in enumerate(symbols):
atom_numbers[symbol] = i+1
# System cell
cell = atoms.get_cell()
