def setUp_Options(self):
# CONSTRAINTS, EXCLUSIONS
exclude_center_pids = []
# EXPANSIONS
options = soap.Options()
options.excludeCenters([])
options.excludeTargets([])
options.excludeCenterIds(exclude_center_pids)
options.excludeTargetIds([])
options.set('radialbasis.type', 'gaussian')
options.set('radialbasis.mode', 'adaptive')
options.set('radialbasis.N', 9) # 9
options.set('radialbasis.sigma', 0.5) # 0.9
options.set('radialbasis.integration_steps', 15)
options.set('radialcutoff.Rc', 6.8)
options.set('radialcutoff.Rc_width', 0.5)
options.set('radialcutoff.type', 'heaviside')
options.set('radialcutoff.center_weight', 0.5)
options.set('angularbasis.type', 'spherical-harmonic')
options.set('angularbasis.L', 6) # 6
options.set('densitygrid.N', 20)
options.set('densitygrid.dx', 0.15)
options.set('spectrum.gradients', True)
options.set('spectrum.2l1_norm', False) # <- pull here
# KERNEL OPTIONS
options.set('kernel.adaptor', 'global-generic') # <- pull here
options.set('kernel.type', 'dot')
options.set('kernel.delta', 1.)
options.set('kernel.xi', 4.) # <- pull here
# STORE
self.options = options
return
def compute_ftd(struct, options, fragment_based):
for atom in struct:
atom.sigma = options["fieldtensor.sigma"]
log << atom.name << atom.type << atom.weight << atom.sigma << atom.pos << log.endl
# OPTIONS
options_soap = soap.Options()
for key, val in options.items():
if type(val) == list: continue
options_soap.set(key, val)
# Exclusions
excl_targ_list = options['exclude_targets']
excl_cent_list = options['exclude_centers']
excl_targ_list.append('COM')
if not fragment_based:
excl_cent_list.append('COM')
options_soap.excludeCenters(excl_cent_list)
options_soap.excludeTargets(excl_targ_list)
# SPECTRUM
ftspectrum = soap.FTSpectrum(struct, options_soap)
ftspectrum.compute()
# Adapt spectra
adaptor = soap.soapy.kernel.KernelAdaptorFactory["ftd-specific"](
{}, options["type_list"])
IX, IR, types = adaptor.adapt(ftspectrum, return_pos_matrix=True)
return IX, IR, types
def compute_soap(struct, options):
# OPTIONS
options_soap = soap.Options()
for key, val in options.items():
if isinstance(val, list):
continue
options_soap.set(key, val)
# Exclusions
excl_targ_list = options['exclude_targets']
excl_cent_list = options['exclude_centers']
options_soap.excludeCenters(excl_cent_list)
options_soap.excludeTargets(excl_targ_list)
# Compute spectrum
spectrum = soap.Spectrum(struct, options_soap)
spectrum.compute()
spectrum.computePower()
if options['spectrum.gradients']:
spectrum.computePowerGradients()
if options['spectrum.global']:
spectrum.computeGlobal()
# Adapt spectrum
adaptor = soap.soapy.kernel.KernelAdaptorFactory[options['kernel.adaptor']](
options_soap,
types_global=options['type_list'])
IX, IR, types = adaptor.adapt(spectrum, return_pos_matrix=True)
# Calculate average
X_avg = IX.sum(axis=0)
X_avg = X_avg / X_avg.dot(X_avg)**0.5
return IX, X_avg, IR, types
def compute_spectrum(config, options_dict, exclude_centers, exclude_targets):
# ANNOUNCE
global MP_LOCK
MP_LOCK.acquire()
osio << osio.item \
<< "Soap for: " << config.config_file \
<< "PID=%d" % mp.current_process().pid << endl
MP_LOCK.release()
# SET OPTIONS
options = soap.Options()
for item in options_dict.iteritems():
options.set(*item)
options.excludeCenters(exclude_centers)
options.excludeTargets(exclude_targets)
# PROCESS STRUCTURE
structure = soap.tools.setup_structure_ase(config.config_file,
config.atoms)
for particle in structure:
particle.sigma = 0.5 * element_vdw_radius[particle.type]
particle.weight = element_valence_order[particle.type]
# COMPUTE SPECTRUM
spectrum = soap.Spectrum(structure, options)
spectrum.compute()
spectrum.computePower()
spectrum.save('%s.spectrum' % config.config_file)
return config.config_file
def get_cxx_kernel(options):
options_cxx = soap.Options()
log << "Kernel:" << log.endl
for k, v in options.iteritems():
log << "- Setting %s=%s" % (k, str(v)) << log.endl
options_cxx.set(k, v)
kernel = soap.Kernel(options_cxx)
return kernel
def getCxxOptions(self, options):
options_cxx = soap.Options()
for key, val in options.items():
if type(val) == list: continue
options_cxx.set(key, val)
# Exclusions
excl_targ_list = options['exclude_targets']
excl_cent_list = options['exclude_centers']
options_cxx.excludeCenters(excl_cent_list)
options_cxx.excludeTargets(excl_targ_list)
return options_cxx
def convert_json_to_cxx(options):
options_cxx = soap.Options()
for key, val in options.items():
if type(val) == list: continue
options_cxx.set(key, val)
# Exclusions
excl_targ_list = options['exclude_targets']
excl_cent_list = options['exclude_centers']
options_cxx.excludeCenters(excl_cent_list)
options_cxx.excludeTargets(excl_targ_list)
excl_targ_id_list = options['exclude_target_ids']
excl_cent_id_list = options['exclude_center_ids']
options_cxx.excludeCenterIds(excl_cent_id_list)
options_cxx.excludeTargetIds(excl_targ_id_list)
return options_cxx
def test_reduction_matrix_average(options):
log << log.mg << "<test_reduction_matrix_average>" << log.flush
kernel_options = soap.Options()
kernel_options.set("basekernel_type", "dot")
kernel_options.set("base_exponent", 3.)
kernel_options.set("base_filter", False)
kernel_options.set("topkernel_type", "average")
kernel = soap.Kernel(kernel_options)
for i in range(9):
K_base = np.random.uniform(size=(i + 1, ((i + 2) % 4) + 1))
k = kernel.evaluateTop(K_base, "float64")
P = kernel.attributeTopGetReductionMatrix(K_base, "float64")
k_red = np.sum(K_base * P)
assert_equal(k - k_red, 0.0, 1e-6)
log << log.endl
def test_attribution_average(dset, options):
log << log.mg << "<test_attribution_average>" << log.flush
kernel_options = soap.Options()
kernel_options.set("basekernel_type", "dot")
kernel_options.set("base_exponent", 3.)
kernel_options.set("base_filter", False)
kernel_options.set("topkernel_type", "average")
kernel = soap.Kernel(kernel_options)
K = kernel.evaluate(dset, dset, False, "float64")
for i in range(len(dset)):
KK = kernel.attributeLeft(dset[i], dset, "float64")
KK_sum = np.sum(KK, axis=0)
for j in range(len(dset)):
assert_equal(KK_sum[j] - K[i, j], 0.0, 1e-6)
log << log.endl
def compute_soap(struct, options, fragment_based=False):
# OPTIONS
options_soap = soap.Options()
for key, val in options.items():
if type(val) == list: continue
options_soap.set(key, val)
# Exclusions
excl_targ_list = options['exclude_targets']
excl_cent_list = options['exclude_centers']
excl_targ_list.append('COM')
if not fragment_based:
excl_cent_list.append('COM')
options_soap.excludeCenters(excl_cent_list)
options_soap.excludeTargets(excl_targ_list)
# SPECTRUM
spectrum = soap.Spectrum(struct, options_soap)
# Compute density expansion
if fragment_based:
# Divide onto segments and their COM representatives
seg_by_name = {}
comseg_by_name = {}
for seg in struct.segments:
if seg.name.split('.')[-1] == 'COM':
comseg_by_name[seg.name] = seg
else:
seg_by_name[seg.name] = seg
# Compute segment descriptors
for name, seg in seg_by_name.items():
comseg = comseg_by_name[name + '.COM']
spectrum.compute(comseg, seg)
else:
spectrum.compute()
# Compute power spectrum,
spectrum.computePower()
if options['spectrum.gradients']:
spectrum.computePowerGradients()
if options['spectrum.global']:
spectrum.computeGlobal()
# Adapt spectrum
adaptor = soap.soapy.kernel.KernelAdaptorFactory[
options['kernel.adaptor']](options_soap,
types_global=options['type_list'])
IX, IR, types = adaptor.adapt(spectrum, return_pos_matrix=True)
return IX, IR, types
def optimize(cgraph,
X,
Y,
opt=None,
dropout=None,
method="steep",
do_resample=False,
n_batches=1,
n_steps_batch=100,
rate=0.001,
node_map=None):
# OPTIMIZER
if opt is None:
options = soap.Options()
options.set("opt.type", method)
opt = soap.CGraphOptimizer(options)
# FIT
t0 = time.time()
for i in range(n_batches):
log << "Batch %3d " % i << log.flush
if do_resample:
subsel = np.random.randint(0, X.shape[0], size=(X.shape[0], ))
else:
subsel = np.arange(X.shape[0])
if dropout is not None: dropout.sample()
# >>> assert len(cgraph.outputs()) == 1
# >>> nodes = cgraph.outputs()[0].inputs()
# >>> print len(nodes), len(filter(lambda n: n.active, nodes))
opt.step(cgraph, X[subsel], Y[subsel], str(X.dtype), str(Y.dtype),
n_steps_batch, rate)
# >>> if node_map is not None:
# >>> for k,n in node_map.iteritems():
# >>> if n.active:
# >>> nans = len(np.where(np.isnan(n.vals("float64")))[0])
# >>> if nans > 0:
# >>> print n.vals("float64")
# >>> print "%50s %15s" % (k, n.op), nans
t1 = time.time()
log << "Time taken for optimization: %+1.4fs" % (t1 - t0) << log.endl
#! /usr/bin/env python
import soap
import soap.tools
import os
import numpy as np
import logging
from momo import osio, endl, flush
options = soap.Options()
options.excludeCenters([])
options.excludeTargets([])
options.set('radialbasis.type', 'gaussian')
options.set('radialbasis.mode', 'adaptive')
options.set('radialbasis.N', 9) # 9
options.set('radialbasis.sigma', 0.5) # 0.9
options.set('radialbasis.integration_steps', 15)
options.set('radialcutoff.Rc', 6.8)
options.set('radialcutoff.Rc_width', 0.5)
options.set('radialcutoff.type', 'heaviside')
options.set('radialcutoff.center_weight', 1.)
options.set('angularbasis.type', 'spherical-harmonic')
options.set('angularbasis.L', 6) # 6
options.set('densitygrid.N', 20)
options.set('densitygrid.dx', 0.15)
options.set('spectrum.gradients', True)
options.set('kernel.adaptor', 'generic')
options.set('kernel.type', 'dot')
options.set('kernel.delta', 0.1)
options.set('kernel.xi', 1.)
# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
select_struct_label = 'config.xyz'
exclude_centers = []
adaptor_type = 'global-generic'
kernel_type = 'dot' # 'dot-harmonic'
alpha = +1.
mu = 0.9
sc = 0.1 # 1.5 # 0.1
average_energy = True
lj_sigma = 0.02 # 0.00001 # 0.02
# <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
# NOTE adaptor_type = 'generic' => exclude center if not constrained in optimization
# OPTIONS
options = soap.Options()
options.excludeCenters(['H'])
options.excludeTargets(['H'])
options.excludeCenterIds(exclude_centers)
options.excludeTargetIds([])
# Spectrum
options.set('spectrum.gradients', True)
options.set('spectrum.2l1_norm', False) # <- pull here (True/False)
# Basis
options.set('radialbasis.type', 'gaussian')
options.set('radialbasis.mode', 'adaptive')
options.set('radialbasis.N', 9)
options.set('radialbasis.sigma', 0.5)
options.set('radialbasis.integration_steps', 15)
options.set('radialcutoff.Rc', 6.8)
options.set('radialcutoff.Rc_width', 0.5)
def setupVertexFeatures(self, atoms, options):
n_atoms = len(atoms)
positions = [atom.position for atom in atoms]
descriptor_type = options['graph']['descriptor']
options_descriptor = options['descriptor'][descriptor_type]
if descriptor_type == 'atom_type':
feature_map = {}
feature_list = options_descriptor['type_map']
dim = len(feature_list)
P = np.zeros((n_atoms, dim))
for idx, atom in enumerate(atoms):
p = np.zeros((dim))
atom_type = atom.number
for i in range(dim):
if feature_list[i] == atom_type: p[i] = 1
else: p[i] = 0
P[idx, :] = p
elif descriptor_type == 'soap':
# Structure
structure = soap.tools.setup_structure_ase(self.label, atoms)
# Customize density
density_type = options["atomic_density"]["density_type"]
use_covrad = options["atomic_density"]["use_covrad"]
atom_rad_scale = float(options["atomic_density"]["atomic_radius"])
# ... Particle radii
if use_covrad:
radius_map = soap.soapy.elements.periodic_table.getPropertyDict(
"covrad", convert=lambda x: x * atom_rad_scale)
else:
radius_map = {}
for elem in soap.soapy.elements.PeriodicTable.element_names:
radius_map[elem] = atom_rad_scale
# ... Particle 'charge'
if density_type == "elneg_density":
charge_map = soap.soapy.elements.periodic_table.getPropertyDict(
"elneg")
elif density_type == "z_density":
charge_map = soap.soapy.elements.periodic_table.getPropertyDict(
"z")
elif density_type == "number_density":
charge_map = {}
for elem in soap.soapy.elements.PeriodicTable.element_names:
charge_map[elem] = 1.
elif density_type == "number_density_generic":
charge_map = {}
for elem in soap.soapy.elements.PeriodicTable.element_names:
charge_map[elem] = 1.
elif density_type == "valence_charge_density":
charge_map = soap.soapy.elements.periodic_table.getPropertyDict(
"valence")
else:
raise NotImplementedError("Density type '%s'" % density_type)
# ... Apply
soap.tools.setup_structure_density(structure,
radius_map=radius_map,
charge_map=charge_map)
# Options
options_soap = soap.Options()
for item in options_descriptor.items():
key = item[0]
val = item[1]
if type(val) == list:
continue # TODO Exclusions loaded separately, fix this
options_soap.set(key, val)
options_soap.excludeCenters(options_descriptor['exclude_centers'])
options_soap.excludeTargets(options_descriptor['exclude_targets'])
# Spectrum
spectrum = soap.Spectrum(structure, options_soap)
spectrum.compute()
spectrum.computePower()
if options_descriptor['spectrum.gradients']:
spectrum.computePowerGradients()
spectrum.computeGlobal()
# Adapt spectrum
adaptor = kern.KernelAdaptorFactory[options_soap.get(
'kernel.adaptor')](
options_soap, types_global=options_descriptor['type_list'])
ix = adaptor.adapt(spectrum)
dim = ix.shape[1]
P = ix
if options_soap.get('kernel.adaptor') in [
'global-generic', 'global-specific'
]:
pass
else:
assert P.shape[0] == n_atoms
elif descriptor_type == 'soap-quippy':
atoms_quippy = datasets.gdb.convert_ase2quippy_atomslist([atoms
])[0]
# Read options
options_xml_file = options_descriptor["options_xml"]
opt_interface = momo.OptionsInterface()
xml_options = opt_interface.ParseOptionsFile(
options_xml_file, 'options')
# Finalize options
xml_options.kernel.alchemy = xml_options.kernel.alchemy.As(str)
xml_options.kernel.alchemy_rules = xml_options.kernel.alchemy
xml_options.soap.nocenter = xml_options.soap.nocenter.As(str)
xml_options.soap.noatom = [] # TODO
if xml_options.soap.nocenter and xml_options.soap.nocenter != 'None':
xml_options.soap.nocenter = map(
int, xml_options.soap.nocenter.split())
else:
xml_options.soap.nocenter = []
datasets.soap.finalize_options([], xml_options)
# Process
z_types = options_descriptor["z_type_list"]
struct = libmatch.structures.structure(xml_options.kernel.alchemy)
soap_raw = struct.parse(atoms_quippy,
xml_options.soap.R.As(float),
xml_options.soap.N.As(int),
xml_options.soap.L.As(int),
xml_options.soap.sigma.As(float),
xml_options.soap.w0.As(float),
xml_options.soap.nocenter,
xml_options.soap.noatom,
types=z_types,
kit=xml_options.kernel.kit)
# Assign raw soaps to atoms (currently stored by z-key)
z_idx_counter = {}
for z in soap_raw:
#print z, soap_raw[z].shape
z_idx_counter[z] = 0
ix = []
for i, z in enumerate(atoms.get_atomic_numbers()):
z_idx = z_idx_counter[z]
ix.append(soap_raw[z][z_idx])
z_idx_counter[z] += 1
#print z, z_idx
P = np.array(ix)
dim = P.shape[1]
assert P.shape[0] == n_atoms
#print P.dot(P.T)
elif descriptor_type == 'npy_load':
folder = options_descriptor["folder"]
npy_file = '%s/%s.x.npy' % (folder, self.label)
#print npy_file
P = np.load(npy_file)
dim = P.shape[1]
assert P.shape[0] == n_atoms
elif descriptor_type == 'none':
dim = 1
P = np.zeros((n_atoms, dim))
for idx, atom in enumerate(atoms):
P[idx, 0] = 1.
else:
raise NotImplementedError(descriptor_type)
return P, positions
z = 1. / np.sqrt(K.diagonal())
K = K * np.outer(z, z)
log << "Kernel: Output slot" << slot << log.endl
log << K << log.endl
if __name__ == "__main__":
configs = soap.tools.io.read('data/structures.xyz')
# Compute SOAP descriptors
options = soap.soapy.configure_default()
dset = evaluate_soap(configs, options)
# Multikernel: Variant A
log << log.mg << "Variant A" << log.endl
kernel_options = soap.Options()
kernel_options.set("basekernel_type", "dot")
kernel_options.set("base_exponent", 3.)
kernel_options.set("base_filter", False)
kernel_options.set("topkernel_type", "average;canonical;rematch")
kernel_options.set("canonical_beta", 0.5)
kernel_options.set("rematch_gamma", 0.05)
kernel_options.set("rematch_eps", 1e-6)
kernel_options.set("rematch_omega", 1.0)
evaluate_kernel(dset, options=kernel_options)
# Multikernel: Variant B
log << log.mg << "Variant B" << log.endl
kernel_options.set("topkernel_type", "")
kernel = soap.Kernel(kernel_options)
for beta in [0.01, 0.05, 0.1, 0.5, 1.0, 10.0, 100.0]:
