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()