def energyANDforceLC():
np.random.seed(455)
Ndata = 1500
Natoms = 7
# parameters for potential
eps, r0, sigma = 1.8, 1.1, np.sqrt(0.02)
params = (eps, r0, sigma)
# parameters for kernel and regression
reg = 1e-5
sig = 10
X = np.array([makeConstrainedStructure(Natoms) for i in range(Ndata)])
featureCalculator = bob_features()
G, I = featureCalculator.get_featureMat(X)
comparator = gaussComparator(sigma=sig)
krr = krr_class(comparator=comparator, featureCalculator=featureCalculator)
E = np.zeros(Ndata)
F = np.zeros((Ndata, 2 * Natoms))
for i in range(Ndata):
E[i], grad = doubleLJ(X[i], eps, r0, sigma)
F[i] = -grad
NpointsLC = 10
Ndata_array = np.logspace(1, 3, NpointsLC).astype(int)
FVU_energy_array = np.zeros(NpointsLC)
FVU_force_array = np.zeros((NpointsLC, 2 * Natoms))
for i in range(NpointsLC):
N = int(3 / 2 * Ndata_array[i])
Esub = E[:N]
Fsub = F[:N]
Xsub = X[:N]
Gsub = G[:N]
Isub = I[:N]
t0 = time.time()
FVU_energy_array[i], FVU_force_array[
i, :] = krr.cross_validation_EandF(Esub,
Fsub,
Gsub,
Isub,
Xsub,
reg=reg)
print('dt:', time.time() - t0)
print(FVU_energy_array[i])
np.savetxt('LC_bob_gauss_N7.txt',
np.c_[Ndata_array, FVU_energy_array, FVU_force_array],
delimiter='\t')
plt.figure(1)
plt.loglog(Ndata_array, FVU_energy_array)
plt.figure(2)
plt.loglog(Ndata_array, FVU_force_array)
plt.show()
def energyANDforceLC_searchData():
# np.random.seed(455)
Ndata = 150
Natoms = 7
# parameters for potential
eps, r0, sigma = 1.8, 1.1, np.sqrt(0.02)
# parameters for kernel and regression
reg = 1e-5
sig = 3
def Efun(X):
params = (1.8, 1.1, np.sqrt(0.02))
return doubleLJ_energy(X, params[0], params[1], params[2])
def gradfun(X):
params = (1.8, 1.1, np.sqrt(0.02))
return doubleLJ_gradient(X, params[0], params[1], params[2])
# Generate data form search
optim = globalOptim(Efun, gradfun, Natoms=Natoms, dmax=2.5,
Niter=200, Nstag=400, sigma=1, maxIterLocal=3)
optim.runOptimizer()
X = optim.Xsaved[:Ndata]
# Initialize KRR model
featureCalculator = bob_features()
comparator = gaussComparator(sigma=sig)
krr = krr_force_class(comparator=comparator, featureCalculator=featureCalculator)
# Calculate Energy and force of generated structures
E = np.zeros(Ndata)
F = np.zeros((Ndata, 2*Natoms))
for i in range(Ndata):
E[i], grad = doubleLJ(X[i], eps, r0, sigma)
F[i] = -grad
# Generate Learning Curve by performing cross validation for a sequence of Ntrain
NpointsLC = 10
Ndata_array = np.logspace(1,2,NpointsLC).astype(int)
FVU_energy_array = np.zeros(NpointsLC)
FVU_force_array = np.zeros((NpointsLC, 2*Natoms))
for i in range(NpointsLC):
N = int(3/2*Ndata_array[i])
Esub = E[:N]
Fsub = F[:N]
Xsub = X[:N]
FVU_force_array[i, :] = krr.cross_validation(Fsub, Xsub, reg=reg)
print(np.mean(FVU_force_array[i]))
np.savetxt('LC_bob_N7_search2.txt', np.c_[Ndata_array, FVU_force_array], delimiter='\t')
plt.figure(1)
plt.loglog(Ndata_array, FVU_force_array)
plt.show()
def energyANDforceLC():
np.random.seed(455)
Ndata = 150
Natoms = 7
# parameters for potential
eps, r0, sigma = 1.8, 1.1, np.sqrt(0.02)
params = (eps, r0, sigma)
# parameters for kernel and regression
reg = 1e-7
sig = 0.3
X = np.array([makeConstrainedStructure(Natoms) for i in range(Ndata)])
featureCalculator = bob_features()
G, I = featureCalculator.get_featureMat(X)
comparator = gaussComparator(sigma=sig)
krr = krr_force_class(comparator=comparator,
featureCalculator=featureCalculator)
E = np.zeros(Ndata)
F = np.zeros((Ndata, 2 * Natoms))
for i in range(Ndata):
E[i], grad = doubleLJ(X[i], eps, r0, sigma)
F[i] = -grad
NpointsLC = 10
Ndata_array = np.logspace(1, 2, NpointsLC).astype(int)
FVU_energy_array = np.zeros(NpointsLC)
FVU_force_array = np.zeros((NpointsLC, 2 * Natoms))
for i in range(NpointsLC):
N = int(3 / 2 * Ndata_array[i])
Esub = E[:N]
Fsub = F[:N]
Xsub = X[:N]
Gsub = G[:N]
Isub = I[:N]
t0 = time.time()
FVU_force_array[i, :] = krr.cross_validation(Fsub, Xsub, reg=reg)
print('dt:', time.time() - t0)
print(FVU_force_array[i])
np.savetxt('LC_bob_FT.txt',
np.c_[Ndata_array, FVU_force_array],
delimiter='\t')
plt.figure(2)
plt.title('Force learning curve (Model trained on forces)')
plt.loglog(Ndata_array, np.mean(FVU_force_array, axis=1))
plt.xlabel('# training data')
plt.ylabel('mean FVU')
plt.ylim([10**(-2), 10**(-0.6)])
plt.show()
def test2():
traj = read('graphene_data/all_every10th.traj', index='0::5')
a_train = traj[:100]
E_train = np.array([a.get_potential_energy() for a in a_train])
Natoms = a_train[0].get_number_of_atoms()
Rc1 = 5
binwidth1 = 0.2
sigma1 = 0.2
Rc2 = 4
Nbins2 = 30
sigma2 = 0.2
gamma = 1
eta = 30
use_angular = False
featureCalculator = Angular_Fingerprint(a_train[0],
Rc1=Rc1,
Rc2=Rc2,
binwidth1=binwidth1,
Nbins2=Nbins2,
sigma1=sigma1,
sigma2=sigma2,
gamma=gamma,
eta=eta,
use_angular=use_angular)
comparator = gaussComparator()
krr = krr_class(comparator=comparator,
featureCalculator=featureCalculator)
GSkwargs = {'reg': [1e-5], 'sigma': [5]}
MAE, params = krr.train(atoms_list=a_train,
data_values=E_train,
k=3,
add_new_data=False,
**GSkwargs)
print(MAE, params)
a_test = traj[99]
print(krr.predict_energy(a_test, return_error=True))
F = krr.predict_force(a_test, with_error=True).reshape((-1, 3))
Fnum = finite_diff(krr, a_test)
print(F)
print('')
print(Fnum)
print('')
print((F - Fnum) / F)
def predictE(atoms_train,
atoms_predict,
featureCalculator,
feature_filename,
eta=1):
Etrain = np.array([a.get_potential_energy() for a in atoms_train])
try:
features = np.load(feature_filename + '.npy')
except IOError:
features = featureCalculator.get_featureMat(atoms_train,
show_progress=True)
np.save(feature_filename, features)
# Apply eta
Nbins1 = featureCalculator.Nbins1
Nbondtypes_2body = len(featureCalculator.bondtypes_2body)
if featureCalculator.use_angular:
features[:, Nbondtypes_2body * Nbins1:] *= eta
# Set up KRR-model
comparator = gaussComparator()
krr = krr_class(comparator=comparator, featureCalculator=featureCalculator)
# Perform training
GSkwargs = {'reg': [1e-5], 'sigma': np.logspace(0, 2, 10)}
FVU, params = krr.train(data_values=Etrain,
featureMat=features,
add_new_data=False,
k=5,
**GSkwargs)
# Predict
Npredict = len(atoms_predict)
Epred = np.zeros(Npredict)
Epred_error = np.zeros(Npredict)
theta0 = np.zeros(Npredict)
for i, a in enumerate(atoms_predict):
Epred[i], Epred_error[i], theta0[i] = krr.predict_energy(
atoms=a, return_error=True)
return Epred, Epred_error, theta0
def main_Nnext():
def Efun(X):
params = (1.8, 1.1, np.sqrt(0.02))
return doubleLJ_energy(X, params[0], params[1], params[2])
def gradfun(X):
params = (1.8, 1.1, np.sqrt(0.02))
return doubleLJ_gradient(X, params[0], params[1], params[2])
sig = 3
reg = 1e-5
Natoms = 7
comparator = gaussComparator(sigma=sig)
featureCalculator = bob_features()
krr = krr_class(comparator=comparator, featureCalculator=featureCalculator, reg=reg)
Nruns = 5
Nstructs = 1200
optimData = np.zeros((Nruns, Nstructs, 2*Natoms))
for i in range(Nruns):
print('Data creation: {}/{}'.format(i, Nruns))
optim = globalOptim(Efun, gradfun, krr, Natoms=Natoms, dmax=2.5,
Niter=200, Nstag=400, sigma=1, maxIterLocal=3)
optim.runOptimizer()
optimData[i,:] = optim.Xsaved[:Nstructs]
print('optimData created with shape:', optimData.shape)
optimData = np.array(optimData)
Npoints = 1
FVU_energy = np.zeros(Npoints)
FVU_force = np.zeros((Npoints, 2*Natoms))
FVU_force_finite = np.zeros((Npoints, 2*Natoms))
Ntrain_array = np.logspace(3, 3, Npoints).astype(int)
for i in range(Nruns):
# Calculate all energies and forces for this run
E = np.zeros(Nstructs)
F = np.zeros((Nstructs, 2*Natoms))
for s in range(Nstructs):
E[s], grad = doubleLJ(optimData[i,s], 1.8, 1.1, np.sqrt(0.02))
F[s,:] = -grad
# Calculate LC
for n in range(Npoints):
print('i:{}/{} , n:{}/{}'.format(i,Nruns,n,Npoints))
Ntrain = Ntrain_array[n]
Ntest = 10 # int(max(10, np.round(Ntrain/5)))
posTrain = optimData[i, :Ntrain]
posTest = optimData[i, Ntrain:Ntrain+Ntest]
krr.fit(E[:Ntrain], positionMat=posTrain)
Etest = E[Ntrain:Ntrain+Ntest]
Ftest = F[Ntrain:Ntrain+Ntest]
FVU_energy[n] += krr.get_MAE_energy(Etest, positionMat=posTest)
FVU_force[n,:] += krr.get_MAE_force(Ftest, positionMat=posTest)
Ffinite = np.array([finiteDiff(krr, pos) for pos in posTest])
FVU_force_finite[n,:] += calcFVU_force(Ftest, Ffinite)
if n == 9:
print(np.c_[Ftest[0].T, Ffinite[0].T])
FVU_energy /= Nruns
FVU_force /= Nruns
FVU_force_finite /= Nruns
np.savetxt('LC_search_bob_N7.txt', np.c_[Ntrain_array, FVU_energy, FVU_force], delimiter='\t')
plt.figure(1)
plt.title('Energy FVU vs training size (from search)')
plt.loglog(Ntrain_array, FVU_energy)
plt.xlabel('# training data')
plt.ylabel('FVU')
plt.figure(2)
plt.title('Force FVU vs training size (from search)')
plt.loglog(Ntrain_array, FVU_force)
plt.xlabel('# training data')
plt.ylabel('FVU')
plt.figure(3)
plt.title('finite difference Force FVU vs training size (from search)')
plt.loglog(Ntrain_array, FVU_force_finite)
plt.xlabel('# training data')
plt.ylabel('FVU')
plt.show()
def mainEnergyAndForceCurve():
#np.random.seed(455)
Ndata = 1000
Natoms = 7
# parameters for potential
eps, r0, sigma = 1.8, 1.1, np.sqrt(0.02)
params = (eps, r0, sigma)
# parameters for kernel and regression
reg = 1e-5
sig = 3
def Efun(X):
params = (1.8, 1.1, np.sqrt(0.02))
return doubleLJ_energy(X, params[0], params[1], params[2])
def gradfun(X):
params = (1.8, 1.1, np.sqrt(0.02))
return doubleLJ_gradient(X, params[0], params[1], params[2])
featureCalculator = bob_features()
comparator = gaussComparator(sigma=sig)
krr = krr_class(comparator=comparator, featureCalculator=featureCalculator, reg=reg)
optim = globalOptim(Efun, gradfun, krr, Natoms=Natoms, dmax=2.5,
Niter=200, Nstag=400, sigma=1, maxIterLocal=3)
optim.runOptimizer()
X = optim.Xsaved[:Ndata]
# Calculate energy and forces
E = np.zeros(Ndata)
F = np.zeros((Ndata, 2*Natoms))
for i in range(Ndata):
E[i], grad = doubleLJ(X[i], eps, r0, sigma)
F[i] = -grad
Xtrain = X[:-1]
Xtest = X[-1]
Etrain = E[:-1]
Etest = E[-1]
krr.fit(Etrain, positionMat=Xtrain)
Npoints = 1000
dx_array = np.linspace(-0.05, 0.05, Npoints)
dx_diff = dx_array[1]-dx_array[0]
# choose coordinate to perturb
i_perturb = 0
ei = np.zeros(2*Natoms)
ei[i_perturb] = 1
# Calculate energy and forces of perturbed structures
Etrue = np.zeros(Npoints)
Ftrue = np.zeros((Npoints, 2*Natoms))
for i in range(Npoints):
Etrue[i], grad = doubleLJ(Xtest+dx_array[i]*ei, eps, r0, sigma)
Ftrue[i] = -grad
Ftrue0 = Ftrue[:,i_perturb]
Epred = np.array([krr.predict_energy(pos=Xtest+dx*ei) for dx in dx_array])
Fpred = np.array([krr.predict_force(pos=Xtest+dx*ei) for dx in dx_array])
Fpred0 = Fpred[:,i_perturb]
Ffinite0 = -(Epred[1:] - Epred[:-1]) / dx_diff
plt.figure(1)
plt.title('Energy with one coordinate varied')
plt.plot(dx_array, Etrue, label='True energy')
plt.plot(dx_array, Epred, label='Predicted energy')
plt.xlabel('dx (perturbation of single coordinate)')
plt.ylabel('Energy')
plt.legend()
plt.figure(2)
plt.title('Force with one coordinate varied')
plt.plot(dx_array, Ftrue0, label='True force')
plt.plot(dx_array, Fpred0, label='Predicted force')
plt.plot(dx_array[:-1]+dx_diff/2, Ffinite0, linestyle=':', label='finite difference force')
plt.xlabel('dx (perturbation of single coordinate)')
plt.ylabel('Energy')
plt.legend()
boxsize = 1.5 * np.sqrt(Natoms)
xbox = np.array([0, boxsize, boxsize, 0, 0])
ybox = np.array([0, 0, boxsize, boxsize, 0])
x = Xtest[0::2]
y = Xtest[1::2]
# Perturbation line
xline = np.array([x[0]-0.05*ei, x[0]+0.05*ei])
yline = y[0]*np.ones(2)
plt.figure(3)
#plt.plot(xbox, ybox, color='k')
plt.scatter(x, y, color='r', s=8)
plt.plot(xline, yline)
plt.xlabel('x')
plt.ylabel('y')
plt.gca().set_aspect('equal', adjustable='box')
plt.show()
filename = 'SnO_features/SnO_radialAngFeatures_gauss{7:s}_Rc1_2_{0:d}_{1:d}_binwidth1_{2:.1f}_Nbins2_{3:d}_sigma1_2_{4:.1f}_{5:.2f}_gamma_{6:d}.txt'.format(
Rc1, Rc2, binwidth1, Nbins2, sigma1, sigma2, gamma, name)
fingerprints = np.loadtxt(filename, delimiter='\t')
print(sigma2)
# Set up KRR-model
featureCalculator = Angular_Fingerprint(atoms[0],
Rc1=Rc1,
Rc2=Rc2,
binwidth1=binwidth1,
Nbins2=Nbins2,
sigma1=sigma1,
sigma2=sigma2,
gamma=gamma,
use_angular=True)
comparator = gaussComparator()
krr = krr_class(comparator=comparator,
featureCalculator=featureCalculator)
MAEcurve = np.zeros(Neta)
for i, eta in enumerate(eta_array):
Nradial = int(Rc1 / binwidth1)
fingerprints_eta = fingerprints.copy()
fingerprints_eta[:, 3 * Nradial:] *= eta
MAEcurve[i] = FVU_train(fingerprints_eta,
E,
krr,
Npoints=10,
Npermutations=5)
print(MAEcurve)
plt.plot(eta_array,
Ndata = args.Ndata
Ntest = args.Ntest
Natoms = args.Natoms
hlr = args.hlr
savefile = args.savefile
m = args.m
q = args.q
# Parameters for double well LJ potential
eps, r0, sigma = 1.8, 1.1, np.sqrt(0.02)
params = (eps, r0, sigma)
# Initialize KRR class instance
krr = krr_class(featureCalculator=bob_features,
comparator=gaussComparator(sigma=1), # Initialize with sigma = 1. It is changed after gridsearch/optimization
Ntrain=Ndata)
# Generate coordinates for atoms
X = getConstrainedStructureDataset(Ndata,Natoms)
Xtest = getConstrainedStructureDataset(Ntest,Natoms)
# Generate corresponding features
G, I = bob_features().get_featureMat(X)
Gtest, Itest = bob_features().get_featureMat(Xtest)
# Get energies and forecs
E,F = getEnergyAndForces(doubleLJ,X,Natoms,params)
Etest,Ftest = getEnergyAndForces(doubleLJ,Xtest,Natoms,params)
sigma1=sigma1,
sigma2=sigma2,
gamma=gamma,
eta=eta,
use_angular=use_angular)
### Set up calculator ###
calc = GPAW(mode=PW(400), xc='PBE', basis='dzp', kpts=(1, 1, 1))
### Set up KRR-model ###
reg = [1e-5]
sigma_a = [3]
sigma_b = [0.3]
kwargs1 = {'sigma': sigma_a[0]}
kwargs2 = {'sigma': sigma_b[0]}
k1 = gaussComparator(featureCalculator=featureCalculator, **kwargs1)
k2 = gaussComparator(featureCalculator=featureCalculator, **kwargs2)
comparator = 0.99 * k1 + 0.01 * k2
def bias_func(x):
return np.mean(x)
delta = deltaFunc(atoms=a, rcut=6)
gpr = GPR(comparator=comparator,
featureCalculator=featureCalculator,
delta_function=delta,
bias_func=bias_func,
regGS=reg)
def energyANDforceLC():
#np.random.seed(455)
Ndata = 1500
Natoms = 24
# parameters for potential
eps, r0, sigma = 1.8, 1.1, np.sqrt(0.02)
params = (eps, r0, sigma)
# parameters for kernel and regression
reg = 1e-7
sig = 30
X, E, F = loadTraj(Ndata)
featureCalculator = fingerprintFeature(dim=3,
rcut=6,
binwidth=0.1,
sigma=0.3)
t0 = time.time()
G = featureCalculator.get_featureMat(X)
print('Time to calculate features:', time.time() - t0)
"""
np.savetxt('work_folder/graphene_all_positions.txt', X, delimiter='\t')
np.savetxt('work_folder/graphene_all_features.txt', G, delimiter='\t')
np.savetxt('work_folder/graphene_all_Energies.txt', E, delimiter='\t')
np.savetxt('work_folder/graphene_all_Forces.txt', F, delimiter='\t')
"""
comparator = gaussComparator(sigma=sig)
krr = krr_class(comparator=comparator, featureCalculator=featureCalculator)
NpointsLC = 10
Ndata_array = np.logspace(1, 3, NpointsLC).astype(int)
FVU_energy_array = np.zeros(NpointsLC)
FVU_force_array = np.zeros((NpointsLC, 2 * Natoms))
for i in range(NpointsLC):
N = int(3 / 2 * Ndata_array[i])
Esub = E[:N]
Fsub = F[:N]
Xsub = X[:N]
Gsub = G[:N]
t0 = time.time()
GSkwargs = {'reg': [1e-7], 'sigma': np.logspace(0, 2, 6)}
#FVU_energy_array[i], FVU_force_array[i, :] = krr.train(Esub, Fsub, Gsub, Xsub, reg=reg)
FVU_energy_array[i], params = krr.train(Esub,
featureMat=Gsub,
positionMat=Xsub,
add_new_data=False,
**GSkwargs)
print('Ntrain:', N)
print('dt:', time.time() - t0)
print('params:', params)
print('FVU_energy: {}\n'.format(FVU_energy_array[i]))
#np.savetxt('grapheneLCdata.txt', np.c_[Ndata_array, FVU_energy_array, FVU_force_array], delimiter='\t')
plt.figure(1)
plt.title('Energy learning curve (random structures)')
plt.loglog(Ndata_array, FVU_energy_array)
plt.xlabel('# training data')
plt.ylabel('unexplained variance')
"""
plt.figure(2)
plt.title('Force learning curve (random structures)')
plt.loglog(Ndata_array, FVU_force_array)
plt.xlabel('# training data')
plt.ylabel('unexplained variance')
"""
plt.show()
def test1():
a_train = [createData(r) for r in [0.9, 1, 1.3, 2, 3]]
#traj = read('graphene_data/all_every10th.traj', index='0::5')
#a_train = traj[:100]
E_train = np.array([a.get_potential_energy() for a in a_train])
Natoms = a_train[0].get_number_of_atoms()
#view(a_train)
Rc1 = 5
binwidth1 = 0.2
sigma1 = 0.2
Rc2 = 4
Nbins2 = 30
sigma2 = 0.2
gamma = 1
eta = 30
use_angular = False
featureCalculator = Angular_Fingerprint(a_train[0],
Rc1=Rc1,
Rc2=Rc2,
binwidth1=binwidth1,
Nbins2=Nbins2,
sigma1=sigma1,
sigma2=sigma2,
gamma=gamma,
eta=eta,
use_angular=use_angular)
# Set up KRR-model
comparator = gaussComparator()
krr = krr_class(comparator=comparator,
featureCalculator=featureCalculator)
GSkwargs = {'reg': [1e-5], 'sigma': [5]}
MAE, params = krr.train(atoms_list=a_train,
data_values=E_train,
k=3,
add_new_data=False,
**GSkwargs)
print(MAE, params)
Ntest = 100
r_test = np.linspace(0.87, 3.5, Ntest)
E_test = np.zeros(Ntest)
err_test = np.zeros(Ntest)
F_test = np.zeros(Ntest)
E_true = np.zeros(Ntest)
F_true = np.zeros(Ntest)
F_num = np.zeros(Ntest)
for i, r in enumerate(r_test):
ai = createData(r)
E, err, _ = krr.predict_energy(ai, return_error=True)
E_test[i] = E
err_test[i] = err
F_test[i] = krr.predict_force(ai, with_error=True)[0]
F_num[i] = finite_diff(krr, ai)[0, 0]
E_true[i] = ai.get_potential_energy()
F_true[i] = ai.get_forces()[0, 0]
plt.figure()
plt.plot(r_test, E_true, label='true')
plt.plot(r_test, E_test, label='model')
plt.plot(r_test, E_test - err_test, label='model')
plt.legend()
plt.figure()
plt.plot(r_test, F_true, label='true')
plt.plot(r_test, F_test, label='model')
plt.plot(r_test, F_num, 'k:', label='num')
plt.legend()
def mainML():
def Efun(X):
params = (1.8, 1.1, np.sqrt(0.02))
return doubleLJ_energy(X, params[0], params[1], params[2])
def gradfun(X):
params = (1.8, 1.1, np.sqrt(0.02))
return doubleLJ_gradient(X, params[0], params[1], params[2])
sig = 3
reg = 1e-5
comparator = gaussComparator(sigma=sig)
featureCalculator = bob_features()
krr = krr_class(comparator=comparator,
featureCalculator=featureCalculator,
reg=reg)
optim = globalOptim(Efun,
gradfun,
krr,
Natoms=7,
dmax=2.5,
Niter=200,
Nstag=400,
sigma=1,
maxIterLocal=3)
optim.runOptimizer()
GSkwargs = {'reg': [reg], 'sigma': [sig]}
MAE, params = krr.gridSearch(optim.Esaved[:optim.ksaved],
positionMat=optim.Xsaved[:optim.ksaved],
**GSkwargs)
print('MAE:', MAE)
print(optim.Esaved.T[:optim.ksaved])
print('best E:', optim.Ebest)
# Make into numpy arrays
ktrain = np.array(optim.ktrain)
EunrelML = np.array(optim.EunrelML)
Eunrel = np.array(optim.Eunrel)
FunrelML = np.array(optim.FunrelML)
FunrelTrue = np.array(optim.FunrelTrue)
dErel = np.fabs(np.array(optim.ErelML) - np.array(optim.ErelTrue))
dErelTrue = np.fabs(np.array(optim.ErelML) - np.array(optim.ErelMLTrue))
dE2rel = np.fabs(np.array(optim.ErelML) - np.array(optim.E2rel))
dEunrel = np.fabs(EunrelML - Eunrel)
dFunrel = np.fabs(FunrelML=FunrelTrue)
np.savetxt('dErel_vs_ktrain2.txt',
np.c_[ktrain, dErel, dErelTrue, EunrelML, Eunrel],
delimiter='\t')
print(FunrelTrue)
print(FunrelTrue.shape)
plt.figure(1)
plt.title('Structure Example')
plotStructure(optim.Xbest)
plt.xlabel('x')
plt.ylabel('y')
plt.figure(2)
plt.title('Energies of relaxed struxtures')
plt.loglog(ktrain, dErel, color='r')
plt.loglog(ktrain, dErelTrue, color='b')
plt.loglog(ktrain, dE2rel, color='g')
plt.xlabel('NData')
plt.ylabel('Energy')
# plt.legend()
plt.figure(3)
plt.title('Energies of unrelaxed structures')
plt.loglog(ktrain, dEunrel)
plt.xlabel('NData')
plt.ylabel('Energy')
plt.figure(4)
plt.title('Difference between ML and True force of unrelaxed structures')
plt.loglog(ktrain, dFunrel)
plt.xlabel('NData')
plt.ylabel('Force')
plt.show()
def energyANDforceLC_searchData():
# np.random.seed(455)
Ndata = 1500
Natoms = 7
# parameters for potential
eps, r0, sigma = 1.8, 1.1, np.sqrt(0.02)
# parameters for kernel and regression
reg = 1e-5
sig = 3
def Efun(X):
params = (1.8, 1.1, np.sqrt(0.02))
return doubleLJ_energy(X, params[0], params[1], params[2])
def gradfun(X):
params = (1.8, 1.1, np.sqrt(0.02))
return doubleLJ_gradient(X, params[0], params[1], params[2])
featureCalculator = bob_features()
comparator = gaussComparator(sigma=sig)
krr = krr_class(comparator=comparator, featureCalculator=featureCalculator)
optim = globalOptim(Efun,
gradfun,
krr,
Natoms=Natoms,
dmax=2.5,
Niter=200,
Nstag=400,
sigma=1,
maxIterLocal=3)
optim.runOptimizer()
X = optim.Xsaved[:Ndata]
G, I = featureCalculator.get_featureMat(X)
E = np.zeros(Ndata)
F = np.zeros((Ndata, 2 * Natoms))
for i in range(Ndata):
E[i], grad = doubleLJ(X[i], eps, r0, sigma)
F[i] = -grad
NpointsLC = 10
Ndata_array = np.logspace(1, 3, NpointsLC).astype(int)
FVU_energy_array = np.zeros(NpointsLC)
FVU_force_array = np.zeros((NpointsLC, 2 * Natoms))
for i in range(NpointsLC):
N = int(3 / 2 * Ndata_array[i])
Esub = E[:N]
Fsub = F[:N]
Xsub = X[:N]
Gsub = G[:N]
Isub = I[:N]
FVU_energy_array[i], FVU_force_array[
i, :] = krr.cross_validation_EandF(Esub,
Fsub,
Gsub,
Isub,
Xsub,
reg=reg)
print(FVU_energy_array[i])
#print(FVU_force_array[i])
np.savetxt('LC_bob_N7_search2.txt',
np.c_[Ndata_array, FVU_energy_array, FVU_force_array],
delimiter='\t')
plt.figure(1)
plt.loglog(Ndata_array, FVU_energy_array)
plt.figure(2)
plt.loglog(Ndata_array, FVU_force_array)
plt.show()
X = createData(Ndata, theta)
featureCalculator = bob_features()
G = featureCalculator.get_featureMat(X)[0]
# Calculate energies for each structure
E = np.zeros(Ndata)
F = np.zeros((Ndata, 2 * Natoms))
for i in range(Ndata):
E[i], F[i, :] = doubleLJ(X[i], eps, r0, sigma)
Xtrain = X[:-1]
Gtrain = G[:-1]
Ftrain = F[:-1]
# Train model
comparator = gaussComparator(sigma=sig)
krr = krr_force_class(comparator=comparator,
featureCalculator=featureCalculator)
GSkwargs = {'sigma': np.logspace(-2, 0, 10), 'reg': [1e-7]}
FVU, params = krr.gridSearch(F, X, **GSkwargs)
#krr.fit(Ftrain, Xtrain, reg=reg)
Npoints = 1000
Epred = np.zeros(Npoints)
Fpredx = np.zeros(Npoints)
Etest = np.zeros(Npoints)
Ftestx = np.zeros(Npoints)
Xtest0 = X[-1]
Xtest = np.zeros((Npoints, 2 * Natoms))
binwidth1 = 0.2
sigma1 = 0.2
Rc2 = 4
Nbins2 = 30
sigma2 = 0.2
gamma = 1
eta = 5
use_angular = True
"""
featureCalculator = Angular_Fingerprint(a, Rc1=Rc1, Rc2=Rc2, binwidth1=binwidth1, Nbins2=Nbins2, sigma1=sigma1, sigma2=sigma2, gamma=gamma, eta=eta, use_angular=use_angular)
# Set up KRR-model
comparator = gaussComparator(featureCalculator=featureCalculator)
delta_function = deltaFunc(atoms=a, rcut=6)
krr = krr_class(comparator=comparator,
featureCalculator=featureCalculator,
delta_function=delta_function)
# Savefile setup
savefiles_path = sys.argv[1]
try:
run_num = sys.argv[2]
except IndexError:
run_num = ''
savefiles_namebase = savefiles_path + 'global' + run_num + '_'
try:
def test3():
traj = read('graphene_data/all_every10th.traj', index='0::5')
a_train = traj[:100]
E_train = np.array([a.get_potential_energy() for a in a_train])
Natoms = a_train[0].get_number_of_atoms()
Rc1 = 5
binwidth1 = 0.2
sigma1 = 0.2
Rc2 = 4
Nbins2 = 30
sigma2 = 0.2
gamma = 1
eta = 30
use_angular = False
featureCalculator = Angular_Fingerprint(a_train[0],
Rc1=Rc1,
Rc2=Rc2,
binwidth1=binwidth1,
Nbins2=Nbins2,
sigma1=sigma1,
sigma2=sigma2,
gamma=gamma,
eta=eta,
use_angular=use_angular)
comparator = gaussComparator()
krr = krr_class(comparator=comparator,
featureCalculator=featureCalculator)
GSkwargs = {'reg': [1e-5], 'sigma': [5]}
MAE, params = krr.train(atoms_list=a_train,
data_values=E_train,
k=3,
add_new_data=False,
**GSkwargs)
print(MAE, params)
a_test = traj[99]
def createData2(a0, r):
a = a0.copy()
positions = a.get_positions()
positions[0, 0] += r
a.set_positions(positions)
return a
Ntest = 100
r_test = np.linspace(-0.3, 0.3, Ntest)
E_test = np.zeros(Ntest)
err_test = np.zeros(Ntest)
F_test = np.zeros(Ntest)
F_num = np.zeros(Ntest)
val_up = np.zeros(Ntest)
val_down = np.zeros(Ntest)
for i, r in enumerate(r_test):
ai = createData2(a_test, r)
E, err, _ = krr.predict_energy(ai, return_error=True)
E_test[i] = E
err_test[i] = err
F_test[i] = krr.predict_force(ai, with_error=True)[0]
#F_num[i] = finite_diff(krr, ai)[0,0]
F_num[i], val_up[i], val_down[i] = finite_diff(krr,
ai,
with_ud=True)
plt.figure()
plt.plot(r_test, E_test, label='model')
plt.plot(r_test, E_test - err_test, label='val')
plt.legend()
plt.figure()
val = E_test - err_test
plt.plot(r_test, val_up - val, label='val up')
plt.plot(r_test, val_down - val, label='val down')
plt.legend()
plt.figure()
plt.plot(r_test, F_test, label='model')
plt.plot(r_test, F_num, 'k:', label='num')
plt.legend()
