def test_laplacian_kernel():
np.random.seed(666)
n_train = 25
n_test = 20
# List of dummy representations
X = np.random.rand(n_train, 1000)
Xs = np.random.rand(n_test, 1000)
sigma = 100.0
Ktest = np.zeros((n_train, n_test))
for i in range(n_train):
for j in range(n_test):
Ktest[i, j] = np.exp(np.sum(np.abs(X[i] - Xs[j])) / (-1.0 * sigma))
K = laplacian_kernel(X, Xs, sigma)
# Compare two implementations:
assert np.allclose(K, Ktest), "Error in Laplacian kernel"
Ksymm = laplacian_kernel(X, X, sigma)
# Check for symmetry:
assert np.allclose(Ksymm, Ksymm.T), "Error in Laplacian kernel"
def test_krr_cmat():
test_dir = os.path.dirname(os.path.realpath(__file__))
# Parse file containing PBE0/def2-TZVP heats of formation and xyz filenames
data = get_energies(test_dir + "/data/hof_qm7.txt")
# Generate a list of qml.Compound() objects
mols = []
for xyz_file in sorted(data.keys())[:1000]:
# Initialize the qml.Compound() objects
mol = qml.Compound(xyz=test_dir + "/qm7/" + xyz_file)
# Associate a property (heat of formation) with the object
mol.properties = data[xyz_file]
# This is a Molecular Coulomb matrix sorted by row norm
mol.generate_coulomb_matrix(size=23, sorting="row-norm")
mols.append(mol)
# Shuffle molecules
np.random.seed(666)
np.random.shuffle(mols)
# Make training and test sets
n_test = 300
n_train = 700
training = mols[:n_train]
test = mols[-n_test:]
# List of representations
X = np.array([mol.representation for mol in training])
Xs = np.array([mol.representation for mol in test])
# List of properties
Y = np.array([mol.properties for mol in training])
Ys = np.array([mol.properties for mol in test])
# Set hyper-parameters
sigma = 10**(4.2)
llambda = 10**(-10.0)
# Generate training Kernel
K = laplacian_kernel(X, X, sigma)
# Solve alpha
K[np.diag_indices_from(K)] += llambda
alpha = cho_solve(K, Y)
# Calculate prediction kernel
Ks = laplacian_kernel(X, Xs, sigma)
Yss = np.dot(Ks.transpose(), alpha)
mae = np.mean(np.abs(Ys - Yss))
assert mae < 6.0, "ERROR: Too high MAE!"
def laplacian_kernel_matrix(self, x_training, x_test):
#create full laplacian kernel matrix
K = laplacian_kernel(x_test, x_training, self.sigma)
self.full_kernel_matrix = K
return (K)
def get_alphas_python(X, Y, sigma):
""" Get alpha vectors through python.
"""
K = laplacian_kernel(X, X, sigma)
alpha, res, sing, rank = lstsq(K, Y, lapack_driver="gelsd")
return alpha
def get_predictions(mols_pred, X, X_pred, alpha, sigma):
''' predicts proerties
'''
K_pred = laplacian_kernel(X, X_pred, sigma)
Yss = np.dot(K_pred.T, alpha)
for i in range(len(Yss)):
print(str(mols_pred[i].name) + "\t" + str(Yss[i]))
def get_alphas(X, Y, sigma, llambda): ''' calculates the regression coefficient alpha ''' K = laplacian_kernel(X, X, sigma) C = deepcopy(K) C[np.diag_indices_from(C)] += llambda alpha = cho_solve(C, Y) return alpha
def test_kernels():
import sys
import numpy as np
import qml
from qml.kernels import laplacian_kernel
from qml.kernels import gaussian_kernel
n_train = 25
n_test = 20
# List of dummy representations
X = np.random.rand(n_train, 1000)
Xs = np.random.rand(n_test, 1000)
sigma = 100.0
Gtest = np.zeros((n_train, n_test))
Ltest = np.zeros((n_train, n_test))
for i in range(n_train):
for j in range(n_test):
Gtest[i,j] = np.exp( np.sum(np.square(X[i] - Xs[j])) / (-2.0 * sigma**2))
Ltest[i,j] = np.exp( np.sum(np.abs(X[i] - Xs[j])) / (-1.0 * sigma))
G = gaussian_kernel(X, Xs, sigma)
L = laplacian_kernel(X, Xs, sigma)
# Compare two implementations:
assert np.allclose(G, Gtest), "Error in Gaussian kernel"
assert np.allclose(L, Ltest), "Error in Laplacian kernel"
Gsymm = gaussian_kernel(X, X, sigma)
Lsymm = laplacian_kernel(X, X, sigma)
# Check for symmetry:
assert np.allclose(Gsymm, Gsymm.T), "Error in Gaussian kernel"
assert np.allclose(Lsymm, Lsymm.T), "Error in Laplacian kernel"
def get_learning_curve(X, X_test, Y, Y_test, sigma, llambda, Ntot):
''' generate data (predictions) for learning curves
'''
K = laplacian_kernel(X, X, sigma)
K_test = laplacian_kernel(X, X_test, sigma)
N = []
j = 10
while(j < Ntot):
N.append(j)
j *= 2
N.append(Ntot)
random.seed(667)
for train in N:
maes = []
for i in range(10):
split = range(Ntot)
random.shuffle(split)
training_index = split[:train]
y = Y[training_index]
C = deepcopy(K[training_index][:,training_index])
C[np.diag_indices_from(C)] += llambda
alpha = cho_solve(C, y)
Yss = np.dot(K_test[training_index].T, alpha)
diff = Yss - Y_test
mae = np.mean(np.abs(diff))
maes.append(mae)
print(str(train) + "\t" + str(sum(maes)/len(maes)))
def get_kernel(X1, X2, charges1, charges2, sigma=1, mode="local"):
"""
mode local or atomic
"""
if len(X1.shape) > 2:
K = get_atomic_local_kernel(X1, X2, charges1, charges2, sigma)
else:
K = laplacian_kernel(X2, X1, sigma)
return K
def cross_validation(X, Y, sigmas, llambdas, Ntot):
""" finds optimal hyperparameters sigma & lambda using cross validation
"""
parameters = []
random.seed(666)
for i in range(len(sigmas)):
K = laplacian_kernel(X, X, sigmas[i])
for j in range(len(llambdas)):
for m in range(5):
maes = []
split = range(Ntot)
random.shuffle(split)
train = int(len(split)*0.8)
test = int(Ntot - train)
training_index = split[:train]
test_index = split[-test:]
y_train = Y[training_index]
y_test = Y[test_index]
C = deepcopy(K[training_index][:,training_index])
C[np.diag_indices_from(C)] += llambdas[j]
alpha = cho_solve(C, y_train)
y_est = np.dot((K[training_index][:,test_index]).T, alpha)
diff = y_est - y_test
mae = np.mean(np.abs(diff))
maes.append(mae)
parameters.append([llambdas[j], sigmas[i], np.mean(maes)])
maes = [mae[2] for mae in parameters]
index = maes.index(min(maes))
print("minimum MAE after CV: ", min(maes))
return parameters[index][0], parameters[index][1]
# List of representations
X = np.array([mol.coulomb_matrix for mol in training])
Xs = np.array([mol.coulomb_matrix for mol in test])
# List of properties
Y = np.array([mol.properties for mol in training])
Ys = np.array([mol.properties for mol in test])
# Set hyper-parameters
sigma = 10**(4.2)
llambda = 10**(-10.0)
# Generate training Kernel
print("Calculating training kernel ...")
K = laplacian_kernel(X, X, sigma)
# Solve alpha
print("Solving alphas ...")
K[np.diag_indices_from(K)] += llambda
alpha = cho_solve(K, Y)
# Calculate prediction kernel
print("Calculating prediction kernel ...")
Ks = laplacian_kernel(X, Xs, sigma)
Yss = np.dot(Ks.transpose(), alpha)
# Print final RMSD
rmsd = np.sqrt(np.mean(np.square(Ys - Yss)))
print("RMSD = %6.2f kcal/mol" % rmsd)
test_filenames = filenames[500:750]
# hyper parameters
sigmas = [1.0, 10.0, 10.0**2, 10.0**3]
cutoffs = [2.0, 3.0, 4.0]
llambda = 1e-8 # doesn't usually need to be changed
# try 3 different cutoffs
for cutoff in cutoffs:
train_x, train_y = get_descriptor_and_property(train_filenames, atype,
cutoff)
test_x, test_y = get_descriptor_and_property(test_filenames, atype, cutoff)
# in this case try out 4 different values of sigma
for sigma in sigmas:
# Get the kernel between all descriptors in the training set
K = laplacian_kernel(train_x, train_x,
sigma) + llambda * np.identity(train_x.shape[0])
# get the KRR prefactors, i.e. this is the training of the network
alpha = cho_solve(K, train_y)
# get the kernel between all descriptors in the training set and all in the test set
Ks = laplacian_kernel(test_x, train_x, sigma)
# predict values of y
y_pred = np.dot(Ks, alpha)
print(
"predicted MAE of %.4f for sigma: %.4g, cutoff: %.1f and %d training points"
% (calc_mae(y_pred, test_y), sigma, cutoff, len(train_x)))
X = get_rep(names)
X = X.reshape(len(mols), 2)
X_test = get_rep(names2)
X_test = X_test.reshape(len(mols_test), 2)
Yprime = np.asarray([mol.properties for mol in mols])
Y_test = np.asarray([mol.properties for mol in mols_test])
random.seed(667)
for j in range(len(sigma)):
print('\n')
for l in ll:
print()
K = laplacian_kernel(X, X, sigma[j])
K_test = laplacian_kernel(X, X_test, sigma[j])
for train in N:
maes = []
for i in range(nModels):
split = list(range(total))
random.shuffle(split)
training_index = split[:train]
Y = Yprime[training_index]
C = deepcopy(K[training_index][:, training_index])
C[np.diag_indices_from(C)] += l
alpha = cho_solve(C, Y)
