# Python API documentation¶

## qml.representations module¶

qml.representations.generate_atomic_coulomb_matrix(nuclear_charges, coordinates, size=23, sorting='distance', central_cutoff=1000000.0, central_decay=-1, interaction_cutoff=1000000.0, interaction_decay=-1, indices=None)

Creates a Coulomb Matrix representation of the local environment of a central atom. For each central atom $$k$$, a matrix $$M$$ is constructed with elements

$\begin{split}M_{ij}(k) = \begin{cases} \tfrac{1}{2} Z_{i}^{2.4} \cdot f_{ik}^2 & \text{if } i = j \\ \frac{Z_{i}Z_{j}}{\| {\bf R}_{i} - {\bf R}_{j}\|} \cdot f_{ik}f_{jk}f_{ij} & \text{if } i \neq j \end{cases},\end{split}$

where $$i$$, $$j$$ and $$k$$ are atom indices, $$Z$$ is nuclear charge and $$\bf R$$ is the coordinate in euclidean space.

$$f_{ij}$$ is a function that masks long range effects:

$\begin{split}f_{ij} = \begin{cases} 1 & \text{if } \|{\bf R}_{i} - {\bf R}_{j} \| \leq r - \Delta r \\ \tfrac{1}{2} \big(1 + \cos\big(\pi \tfrac{\|{\bf R}_{i} - {\bf R}_{j} \| - r + \Delta r}{\Delta r} \big)\big) & \text{if } r - \Delta r < \|{\bf R}_{i} - {\bf R}_{j} \| \leq r - \Delta r \\ 0 & \text{if } \|{\bf R}_{i} - {\bf R}_{j} \| > r \end{cases},\end{split}$

where the parameters central_cutoff and central_decay corresponds to the variables $$r$$ and $$\Delta r$$ respectively for interactions involving the central atom, and interaction_cutoff and interaction_decay corresponds to the variables $$r$$ and $$\Delta r$$ respectively for interactions not involving the central atom.

if sorting = 'row-norm', the atom indices are ordered such that

$$\sum_j M_{1j}(k)^2 \geq \sum_j M_{2j}(k)^2 \geq ... \geq \sum_j M_{nj}(k)^2$$

if sorting = 'distance', the atom indices are ordered such that

$\|{\bf R}_{1} - {\bf R}_{k}\| \leq \|{\bf R}_{2} - {\bf R}_{k}\| \leq ... \leq \|{\bf R}_{n} - {\bf R}_{k}\|$

The upper triangular of M, including the diagonal, is concatenated to a 1D vector representation.

The representation can be calculated for a subset by either specifying indices = [0,1,...], where $$[0,1,...]$$ are the requested atom indices, or by specifying indices = 'C' to only calculate central carbon atoms.

The representation is calculated using an OpenMP parallel Fortran routine.

Parameters: nuclear_charges (numpy array) – Nuclear charges of the atoms in the molecule coordinates (numpy array) – 3D Coordinates of the atoms in the molecule size (integer) – The size of the largest molecule supported by the representation sorting (string) – How the atom indices are sorted (‘row-norm’, ‘distance’) central_cutoff (float) – The distance from the central atom, where the coulomb interaction element will be zero central_decay (float) – The distance over which the the coulomb interaction decays from full to none interaction_cutoff (float) – The distance between two non-central atom, where the coulomb interaction element will be zero interaction_decay (float) – The distance over which the the coulomb interaction decays from full to none indices (Nonetype/array/string) – Subset indices or atomtype nD representation - shape ($$N_{atoms}$$, size(size+1)/2) numpy array
qml.representations.generate_bob(nuclear_charges, coordinates, atomtypes, size=23, asize={'C': 7, 'H': 16, 'N': 3, 'O': 3, 'S': 1})

Creates a Bag of Bonds (BOB) representation of a molecule. The representation expands on the coulomb matrix representation. For each element a bag (vector) is constructed for self interactions (e.g. (‘C’, ‘H’, ‘O’)). For each element pair a bag is constructed for interatomic interactions (e.g. (‘CC’, ‘CH’, ‘CO’, ‘HH’, ‘HO’, ‘OO’)), sorted by value. The self interaction of element $$I$$ is given by

$$\tfrac{1}{2} Z_{I}^{2.4}$$,

with $$Z_{i}$$ being the nuclear charge of element $$i$$ The interaction between atom $$i$$ of element $$I$$ and atom $$j$$ of element $$J$$ is given by

$$\frac{Z_{I}Z_{J}}{\| {\bf R}_{i} - {\bf R}_{j}\|}$$

with $$R_{i}$$ being the euclidean coordinate of atom $$i$$. The sorted bags are concatenated to an 1D vector representation. The representation is calculated using an OpenMP parallel Fortran routine.

Parameters: nuclear_charges (numpy array) – Nuclear charges of the atoms in the molecule coordinates (numpy array) – 3D Coordinates of the atoms in the molecule size (integer) – The maximum number of atoms in the representation asize (dictionary) – The maximum number of atoms of each element type supported by the representation 1D representation numpy array
qml.representations.generate_coulomb_matrix(nuclear_charges, coordinates, size=23, sorting='row-norm')

Creates a Coulomb Matrix representation of a molecule. Sorting of the elements can either be done by sorting="row-norm" or sorting="unsorted". A matrix $$M$$ is constructed with elements

$\begin{split}M_{ij} = \begin{cases} \tfrac{1}{2} Z_{i}^{2.4} & \text{if } i = j \\ \frac{Z_{i}Z_{j}}{\| {\bf R}_{i} - {\bf R}_{j}\|} & \text{if } i \neq j \end{cases},\end{split}$

where $$i$$ and $$j$$ are atom indices, $$Z$$ is nuclear charge and $$\bf R$$ is the coordinate in euclidean space. If sorting = 'row-norm', the atom indices are reordered such that

$$\sum_j M_{1j}^2 \geq \sum_j M_{2j}^2 \geq ... \geq \sum_j M_{nj}^2$$

The upper triangular of M, including the diagonal, is concatenated to a 1D vector representation.

If sorting = 'unsorted, the elements are sorted in the same order as the input coordinates and nuclear charges.

The representation is calculated using an OpenMP parallel Fortran routine.

Parameters: nuclear_charges (numpy array) – Nuclear charges of the atoms in the molecule coordinates (numpy array) – 3D Coordinates of the atoms in the molecule size (integer) – The size of the largest molecule supported by the representation sorting (string) – How the atom indices are sorted (‘row-norm’, ‘unsorted’) 1D representation - shape (size(size+1)/2,) numpy array
qml.representations.generate_eigenvalue_coulomb_matrix(nuclear_charges, coordinates, size=23)

Creates an eigenvalue Coulomb Matrix representation of a molecule. A matrix $$M$$ is constructed with elements

$\begin{split}M_{ij} = \begin{cases} \tfrac{1}{2} Z_{i}^{2.4} & \text{if } i = j \\ \frac{Z_{i}Z_{j}}{\| {\bf R}_{i} - {\bf R}_{j}\|} & \text{if } i \neq j \end{cases},\end{split}$

where $$i$$ and $$j$$ are atom indices, $$Z$$ is nuclear charge and $$\bf R$$ is the coordinate in euclidean space. The molecular representation of the molecule is then the sorted eigenvalues of M. The representation is calculated using an OpenMP parallel Fortran routine.

Parameters: nuclear_charges (numpy array) – Nuclear charges of the atoms in the molecule coordinates (numpy array) – 3D Coordinates of the atoms in the molecule size (integer) – The size of the largest molecule supported by the representation 1D representation - shape (size, ) numpy array
qml.representations.generate_slatm(coordinates, nuclear_charges, mbtypes, unit_cell=None, local=False, sigmas=[0.05, 0.05], dgrids=[0.03, 0.03], rcut=4.8, alchemy=False, pbc='000', rpower=6)

Generate Spectrum of London and Axillrod-Teller-Muto potential (SLATM) representation. Both global (local=False) and local (local=True) SLATM are available.

A version that works for periodic boundary conditions will be released soon.

NOTE: You will need to run the get_slatm_mbtypes() function to get the mbtypes input (or generate it manually).

Parameters: coordinates (numpy array) – Input coordinates nuclear_charges (numpy array) – List of nuclear charges. mbtypes (list) – Many-body types for the whole dataset, including 1-, 2- and 3-body types. Could be obtained by calling get_slatm_mbtypes(). local (bool) – Generate a local representation. Defaulted to False (i.e., global representation); otherwise, atomic version. sigmas (list) – Controlling the width of Gaussian smearing function for 2- and 3-body parts, defaulted to [0.05,0.05], usually these do not need to be adjusted. dgrids (list) – The interval between two sampled internuclear distances and angles, defaulted to [0.03,0.03], no need for change, compromised for speed and accuracy. rcut (float) – Cut-off radius, defaulted to 4.8 Angstrom. alchemy (bool) – Swith to use the alchemy version of SLATM. (default=False) pbc (string) – defaulted to ‘000’, meaning it’s a molecule; the three digits in the string corresponds to x,y,z direction rpower (float) – The power of R in 2-body potential, defaulted to London potential (=6). 1D SLATM representation numpy array
qml.representations.get_slatm_mbtypes(nuclear_charges, pbc='000')

Get the list of minimal types of many-body terms in a dataset. This resulting list is necessary as input in the generate_slatm_representation() function.

Parameters: nuclear_charges (list of numpy arrays) – A list of the nuclear charges for each compound in the dataset. pbc (string) – periodic boundary condition along x,y,z direction, defaulted to ‘000’, i.e., molecule A list containing the types of many-body terms. list
qml.representations.vector_to_matrix(v)

Converts a representation from 1D vector to 2D square matrix. :param v: 1D input representation. :type v: numpy array :return: Square matrix representation. :rtype: numpy array

## qml.kernels module¶

qml.kernels.gaussian_kernel(A, B, sigma)

Calculates the Gaussian kernel matrix K, where $$K_{ij}$$:

$$K_{ij} = \exp \big( -\frac{\|A_i - B_j\|_2^2}{2\sigma^2} \big)$$

Where $$A_{i}$$ and $$B_{j}$$ are representation vectors. K is calculated using an OpenMP parallel Fortran routine.

Parameters: A (numpy array) – 2D array of representations - shape (N, representation size). B (numpy array) – 2D array of representations - shape (M, representation size). sigma (float) – The value of sigma in the kernel matrix. The Gaussian kernel matrix - shape (N, M) numpy array
qml.kernels.get_local_kernels_gaussian(A, B, na, nb, sigmas)

Calculates the Gaussian kernel matrix K, for a local representation where $$K_{ij}$$:

$$K_{ij} = \sum_{a \in i} \sum_{b \in j} \exp \big( -\frac{\|A_a - B_b\|_2^2}{2\sigma^2} \big)$$

Where $$A_{a}$$ and $$B_{b}$$ are representation vectors.

Note that the input array is one big 2D array with all atoms concatenated along the same axis. Further more a series of kernels is produced (since calculating the distance matrix is expensive but getting the resulting kernels elements for several sigmas is not.)

K is calculated using an OpenMP parallel Fortran routine.

Parameters: A (numpy array) – 2D array of descriptors - shape (total atoms A, representation size). B (numpy array) – 2D array of descriptors - shape (total atoms B, representation size). na (numpy array) – 1D array containing numbers of atoms in each compound. nb (numpy array) – 1D array containing numbers of atoms in each compound. sigma (float) – The value of sigma in the kernel matrix. The Gaussian kernel matrix - shape (nsigmas, N, M) numpy array
qml.kernels.get_local_kernels_laplacian(A, B, na, nb, sigmas)

Calculates the Local Laplacian kernel matrix K, for a local representation where $$K_{ij}$$:

$$K_{ij} = \sum_{a \in i} \sum_{b \in j} \exp \big( -\frac{\|A_a - B_b\|_1}{\sigma} \big)$$

Where $$A_{a}$$ and $$B_{b}$$ are representation vectors.

Note that the input array is one big 2D array with all atoms concatenated along the same axis. Further more a series of kernels is produced (since calculating the distance matrix is expensive but getting the resulting kernels elements for several sigmas is not.)

K is calculated using an OpenMP parallel Fortran routine.

Parameters: A (numpy array) – 2D array of descriptors - shape (N, representation size). B (numpy array) – 2D array of descriptors - shape (M, representation size). na (numpy array) – 1D array containing numbers of atoms in each compound. nb (numpy array) – 1D array containing numbers of atoms in each compound. sigmas (list) – List of the sigmas. The Laplacian kernel matrix - shape (nsigmas, N, M) numpy array
qml.kernels.laplacian_kernel(A, B, sigma)

Calculates the Laplacian kernel matrix K, where $$K_{ij}$$:

$$K_{ij} = \exp \big( -\frac{\|A_i - B_j\|_1}{\sigma} \big)$$

Where $$A_{i}$$ and $$B_{j}$$ are representation vectors. K is calculated using an OpenMP parallel Fortran routine.

Parameters: A (numpy array) – 2D array of representations - shape (N, representation size). B (numpy array) – 2D array of representations - shape (M, representation size). sigma (float) – The value of sigma in the kernel matrix. The Laplacian kernel matrix - shape (N, M) numpy array
qml.kernels.linear_kernel(A, B)

Calculates the linear kernel matrix K, where $$K_{ij}$$:

$$K_{ij} = A_i \cdot B_j$$

VWhere $$A_{i}$$ and $$B_{j}$$ are representation vectors.

K is calculated using an OpenMP parallel Fortran routine.

Parameters: A (numpy array) – 2D array of representations - shape (N, representation size). B (numpy array) – 2D array of representations - shape (M, representation size). The Gaussian kernel matrix - shape (N, M) numpy array
qml.kernels.matern_kernel(A, B, sigma, order=0, metric='l1')

Calculates the Matern kernel matrix K, where $$K_{ij}$$:

for order = 0:
$$K_{ij} = \exp\big( -\frac{d}{\sigma} \big)$$
for order = 1:
$$K_{ij} = \exp\big( -\frac{\sqrt{3} d}{\sigma} \big) \big(1 + \frac{\sqrt{3} d}{\sigma} \big)$$
for order = 2:
$$K_{ij} = \exp\big( -\frac{\sqrt{5} d}{d} \big) \big( 1 + \frac{\sqrt{5} d}{\sigma} + \frac{5 d^2}{3\sigma^2} \big)$$

Where $$A_i$$ and $$B_j$$ are representation vectors, and d is a distance measure.

K is calculated using an OpenMP parallel Fortran routine.

Parameters: A (numpy array) – 2D array of representations - shape (N, representation size). B (numpy array) – 2D array of representations - shape (M, representation size). sigma (float) – The value of sigma in the kernel matrix. order (integer) – The order of the polynomial (0, 1, 2) metric (string) – The distance metric (‘l1’, ‘l2’) The Matern kernel matrix - shape (N, M) numpy array
qml.kernels.sargan_kernel(A, B, sigma, gammas)

Calculates the Sargan kernel matrix K, where $$K_{ij}$$:

$$K_{ij} = \exp \big( -\frac{\| A_i - B_j \|_1)}{\sigma} \big) \big(1 + \sum_{k} \frac{\gamma_{k} \| A_i - B_j \|_1^k}{\sigma^k} \big)$$

Where $$A_{i}$$ and $$B_{j}$$ are representation vectors. K is calculated using an OpenMP parallel Fortran routine.

Parameters: A (numpy array) – 2D array of representations - shape (N, representation size). B (numpy array) – 2D array of representations - shape (M, representation size). sigma (float) – The value of sigma in the kernel matrix. gammas (numpy array) – 1D array of parameters in the kernel matrix. The Sargan kernel matrix - shape (N, M). numpy array

## qml.distance module¶

qml.distance.l2_distance(A, B)

Calculates the L2 distances, D, between two Numpy arrays of representations.

$$D_{ij} = \|A_i - B_j\|_2$$

Where $$A_{i}$$ and $$B_{j}$$ are representation vectors. D is calculated using an OpenMP parallel Fortran routine.

Parameters: A (numpy array) – 2D array of descriptors - shape (N, representation size). B (numpy array) – 2D array of descriptors - shape (M, representation size). The L2-distance matrix. numpy array
qml.distance.manhattan_distance(A, B)

Calculates the Manhattan distances, D, between two Numpy arrays of representations.

$$D_{ij} = \|A_i - B_j\|_1$$

Where $$A_{i}$$ and $$B_{j}$$ are representation vectors. D is calculated using an OpenMP parallel Fortran routine.

Parameters: A (numpy array) – 2D array of descriptors - shape (N, representation size). B (numpy array) – 2D array of descriptors - shape (M, representation size). The Manhattan-distance matrix. numpy array
qml.distance.p_distance(A, B, p=2)

Calculates the p-norm distances between two Numpy arrays of representations. The value of the keyword argument p = sets the norm order. E.g. p = 1.0 and p = 2.0 with yield the Manhattan and L2 distances, respectively.

$D_{ij} = \|A_i - B_j\|_p$

Where $$A_{i}$$ and $$B_{j}$$ are representation vectors. D is calculated using an OpenMP parallel Fortran routine.

Parameters: A (numpy array) – 2D array of descriptors - shape (N, representation size). B (numpy array) – 2D array of descriptors - shape (M, representation size). p (float) – The norm order The distance matrix. numpy array

## qml.math module¶

qml.math.bkf_invert(A)

Returns the inverse of a positive definite matrix, using a Cholesky decomposition via calls to LAPACK dpotrf and dpotri in the F2PY module.

Parameters: A (numpy array) – Matrix (symmetric and positive definite, left-hand side). The inverse matrix numpy array
qml.math.bkf_solve(A, y)

Solves the equation

$$A x = y$$

for x using a Cholesky decomposition via calls to LAPACK dpotrf and dpotrs in the F2PY module. Preserves the input matrix A.

Parameters: A (numpy array) – Matrix (symmetric and positive definite, left-hand side). y (numpy array) – Vector (right-hand side of the equation). The solution vector. numpy array
qml.math.cho_invert(A)

Returns the inverse of a positive definite matrix, using a Cholesky decomposition via calls to LAPACK dpotrf and dpotri in the F2PY module.

Parameters: A (numpy array) – Matrix (symmetric and positive definite, left-hand side). The inverse matrix numpy array
qml.math.cho_solve(A, y)

Solves the equation

$$A x = y$$

for x using a Cholesky decomposition via calls to LAPACK dpotrf and dpotrs in the F2PY module. Preserves the input matrix A.

Parameters: A (numpy array) – Matrix (symmetric and positive definite, left-hand side). y (numpy array) – Vector (right-hand side of the equation). The solution vector. numpy array

## qml.Compound class¶

class qml.Compound(xyz=None)

Bases: object

The Compound class is used to store data from

Parameters: xyz (string) – Option to initialize the Compound with data from an XYZ file.
generate_atomic_coulomb_matrix(size=23, sorting='row-norm', central_cutoff=1000000.0, central_decay=-1, interaction_cutoff=1000000.0, interaction_decay=-1, indices=None)

Creates a Coulomb Matrix representation of the local environment of a central atom. For each central atom $$k$$, a matrix $$M$$ is constructed with elements

$\begin{split}M_{ij}(k) = \begin{cases} \tfrac{1}{2} Z_{i}^{2.4} \cdot f_{ik}^2 & \text{if } i = j \\ \frac{Z_{i}Z_{j}}{\| {\bf R}_{i} - {\bf R}_{j}\|} \cdot f_{ik}f_{jk}f_{ij} & \text{if } i \neq j \end{cases},\end{split}$

where $$i$$, $$j$$ and $$k$$ are atom indices, $$Z$$ is nuclear charge and $$\bf R$$ is the coordinate in euclidean space.

$$f_{ij}$$ is a function that masks long range effects:

$\begin{split}f_{ij} = \begin{cases} 1 & \text{if } \|{\bf R}_{i} - {\bf R}_{j} \| \leq r - \Delta r \\ \tfrac{1}{2} \big(1 + \cos\big(\pi \tfrac{\|{\bf R}_{i} - {\bf R}_{j} \| - r + \Delta r}{\Delta r} \big)\big) & \text{if } r - \Delta r < \|{\bf R}_{i} - {\bf R}_{j} \| \leq r - \Delta r \\ 0 & \text{if } \|{\bf R}_{i} - {\bf R}_{j} \| > r \end{cases},\end{split}$

where the parameters central_cutoff and central_decay corresponds to the variables $$r$$ and $$\Delta r$$ respectively for interactions involving the central atom, and interaction_cutoff and interaction_decay corresponds to the variables $$r$$ and $$\Delta r$$ respectively for interactions not involving the central atom.

if sorting = 'row-norm', the atom indices are ordered such that

$$\sum_j M_{1j}(k)^2 \geq \sum_j M_{2j}(k)^2 \geq ... \geq \sum_j M_{nj}(k)^2$$

if sorting = 'distance', the atom indices are ordered such that

$\|{\bf R}_{1} - {\bf R}_{k}\| \leq \|{\bf R}_{2} - {\bf R}_{k}\| \leq ... \leq \|{\bf R}_{n} - {\bf R}_{k}\|$

The upper triangular of M, including the diagonal, is concatenated to a 1D vector representation.

The representation can be calculated for a subset by either specifying indices = [0,1,...], where $$[0,1,...]$$ are the requested atom indices, or by specifying indices = 'C' to only calculate central carbon atoms.

The representation is calculated using an OpenMP parallel Fortran routine.

Parameters: size (integer) – The size of the largest molecule supported by the representation sorting (string) – How the atom indices are sorted (‘row-norm’, ‘distance’) central_cutoff (float) – The distance from the central atom, where the coulomb interaction element will be zero central_decay (float) – The distance over which the the coulomb interaction decays from full to none interaction_cutoff (float) – The distance between two non-central atom, where the coulomb interaction element will be zero interaction_decay (float) – The distance over which the the coulomb interaction decays from full to none indices (Nonetype/array/string) – Subset indices or atomtype nD representation - shape ($$N_{atoms}$$, size(size+1)/2) numpy array
generate_bob(size=23, asize={'C': 7, 'H': 16, 'N': 3, 'O': 3, 'S': 1})

Creates a Bag of Bonds (BOB) representation of a molecule. The representation expands on the coulomb matrix representation. For each element a bag (vector) is constructed for self interactions (e.g. (‘C’, ‘H’, ‘O’)). For each element pair a bag is constructed for interatomic interactions (e.g. (‘CC’, ‘CH’, ‘CO’, ‘HH’, ‘HO’, ‘OO’)), sorted by value. The self interaction of element $$I$$ is given by

$$\tfrac{1}{2} Z_{I}^{2.4}$$,

with $$Z_{i}$$ being the nuclear charge of element $$i$$ The interaction between atom $$i$$ of element $$I$$ and atom $$j$$ of element $$J$$ is given by

$$\frac{Z_{I}Z_{J}}{\| {\bf R}_{i} - {\bf R}_{j}\|}$$

with $$R_{i}$$ being the euclidean coordinate of atom $$i$$. The sorted bags are concatenated to an 1D vector representation. The representation is calculated using an OpenMP parallel Fortran routine.

Parameters: asize – The maximum number of atoms of each element type supported by the representation 1D representation numpy array
generate_coulomb_matrix(size=23, sorting='row-norm', indices=None)

Creates a Coulomb Matrix representation of a molecule. A matrix $$M$$ is constructed with elements

$\begin{split}M_{ij} = \begin{cases} \tfrac{1}{2} Z_{i}^{2.4} & \text{if } i = j \\ \frac{Z_{i}Z_{j}}{\| {\bf R}_{i} - {\bf R}_{j}\|} & \text{if } i \neq j \end{cases},\end{split}$

where $$i$$ and $$j$$ are atom indices, $$Z$$ is nuclear charge and $$\bf R$$ is the coordinate in euclidean space. if sorting = 'row-norm', the atom indices are reordered such that

$$\sum_j M_{1j}^2 \geq \sum_j M_{2j}^2 \geq ... \geq \sum_j M_{nj}^2$$

The upper triangular of M, including the diagonal, is concatenated to a 1D vector representation. The representation is calculated using an OpenMP parallel Fortran routine.

Parameters: size (integer) – The size of the largest molecule supported by the representation sorting (string) – How the atom indices are sorted (‘row-norm’, ‘unsorted’) 1D representation - shape (size(size+1)/2,) numpy array
generate_eigenvalue_coulomb_matrix(size=23)

Creates an eigenvalue Coulomb Matrix representation of a molecule. A matrix $$M$$ is constructed with elements

$\begin{split}M_{ij} = \begin{cases} \tfrac{1}{2} Z_{i}^{2.4} & \text{if } i = j \\ \frac{Z_{i}Z_{j}}{\| {\bf R}_{i} - {\bf R}_{j}\|} & \text{if } i \neq j \end{cases},\end{split}$

where $$i$$ and $$j$$ are atom indices, $$Z$$ is nuclear charge and $$\bf R$$ is the coordinate in euclidean space. The molecular representation of the molecule is then the sorted eigenvalues of M. The representation is calculated using an OpenMP parallel Fortran routine.

Parameters: size (integer) – The size of the largest molecule supported by the representation 1D representation - shape (size, ) numpy array
generate_fchl_representation(max_size=23, cell=None, neighbors=24, cut_distance=5.0)

Generates the representation for the FCHL-kernel. Note that this representation is incompatible with generic qml.kernel.* kernels. :param size: Max number of atoms in representation. :type size: integer

generate_slatm(mbtypes, local=False, sigmas=[0.05, 0.05], dgrids=[0.03, 0.03], rcut=4.8, pbc='000', alchemy=False, rpower=6)

Generate Spectrum of London and Axillrod-Teller-Muto potential (SLATM) representation. Both global (local=False) and local (local=True) SLATM are available.

A version that works for periodic boundary conditions will be released soon.

NOTE: You will need to run the get_slatm_mbtypes() function to get the mbtypes input (or generate it manually).

Parameters: mbtypes (list) – Many-body types for the whole dataset, including 1-, 2- and 3-body types. Could be obtained by calling get_slatm_mbtypes(). local (bool) – Generate a local representation. Defaulted to False (i.e., global representation); otherwise, atomic version. sigmas (list) – Controlling the width of Gaussian smearing function for 2- and 3-body parts, defaulted to [0.05,0.05], usually these do not need to be adjusted. dgrids (list) – The interval between two sampled internuclear distances and angles, defaulted to [0.03,0.03], no need for change, compromised for speed and accuracy. rcut (float) – Cut-off radius, defaulted to 4.8 Angstrom. alchemy (bool) – Swith to use the alchemy version of SLATM. (default=False) pbc (string) – defaulted to ‘000’, meaning it’s a molecule; the three digits in the string corresponds to x,y,z direction rpower (float) – The power of R in 2-body potential, defaulted to London potential (=6). 1D SLATM representation numpy array
read_xyz(filename)

(Re-)initializes the Compound-object with data from an xyz-file.

Parameters: filename (string) – Input xyz-filename.

## qml.fchl module¶

qml.fchl.generate_representation(coordinates, nuclear_charges, max_size=23, neighbors=23, cut_distance=5.0, cell=None)

Generates a representation for the FCHL kernel module.

Parameters: coordinates (numpy array) – Input coordinates. nuclear_charges (numpy array) – List of nuclear charges. max_size (integer) – Max number of atoms in representation. neighbors (integer) – Max number of atoms within the cut-off around an atom. (For periodic systems) cell (numpy array) – Unit cell vectors. The presence of this keyword argument will generate a periodic representation. cut_distance (float) – Spatial cut-off distance - must be the same as used in the kernel function call. FCHL representation, shape = (size,5,neighbors). numpy array
qml.fchl.get_atomic_kernels(A, B, sigmas, two_body_scaling=2.8284271247461903, three_body_scaling=1.6, two_body_width=0.2, three_body_width=3.141592653589793, two_body_power=4.0, three_body_power=2.0, cut_start=1.0, cut_distance=5.0, fourier_order=1, alchemy='periodic-table', alchemy_period_width=1.6, alchemy_group_width=1.6)

Calculates the Gaussian kernel matrix K, where $$K_{ij}$$:

$$K_{ij} = \exp \big( -\frac{\|A_i - B_j\|_2^2}{2\sigma^2} \big)$$

Where $$A_{i}$$ and $$B_{j}$$ are FCHL representation vectors. K is calculated analytically using an OpenMP parallel Fortran routine. Note, that this kernel will ONLY work with FCHL representations as input.

Parameters: A (numpy array) – Array of FCHL representation - shape=(N, maxsize, 5, size). B (numpy array) – Array of FCHL representation - shape=(M, maxsize, 5, size). sigma (list) – List of kernel-widths. two_body_scaling (float) – Weight for 2-body terms. three_body_scaling (float) – Weight for 3-body terms. two_body_width (float) – Gaussian width for 2-body terms three_body_width (float) – Gaussian width for 3-body terms. two_body_power (float) – Powerlaw for $$r^{-n}$$ 2-body terms. three_body_power (float) – Powerlaw for Axilrod-Teller-Muto 3-body term cut_start (float) – The fraction of the cut-off radius at which cut-off damping start. cut_distance (float) – Cut-off radius. (default=5 angstrom) fourier_order (integer) – 3-body Fourier-expansion truncation order. alchemy (string) – Type of alchemical interpolation "periodic-table" or "off" are possible options. Disabling alchemical interpolation can yield dramatic speedups. alchemy_period_width (float) – Gaussian width along periods (columns) in the periodic table. alchemy_group_width (float) – Gaussian width along groups (rows) in the periodic table. Array of FCHL kernel matrices matrix - shape=(n_sigmas, N, M), numpy array
qml.fchl.get_atomic_symmetric_kernels(A, sigmas, two_body_scaling=2.8284271247461903, three_body_scaling=1.6, two_body_width=0.2, three_body_width=3.141592653589793, two_body_power=4.0, three_body_power=2.0, cut_start=1.0, cut_distance=5.0, fourier_order=1, alchemy='periodic-table', alchemy_period_width=1.6, alchemy_group_width=1.6)

Calculates the Gaussian kernel matrix K, where $$K_{ij}$$:

$$K_{ij} = \exp \big( -\frac{\|A_i - B_j\|_2^2}{2\sigma^2} \big)$$

Where $$A_{i}$$ and $$B_{j}$$ are FCHL representation vectors. K is calculated analytically using an OpenMP parallel Fortran routine. Note, that this kernel will ONLY work with FCHL representations as input.

Parameters: A (numpy array) – Array of FCHL representation - shape=(N, maxsize, 5, size). sigma (list) – List of kernel-widths. two_body_scaling (float) – Weight for 2-body terms. three_body_scaling (float) – Weight for 3-body terms. two_body_width (float) – Gaussian width for 2-body terms three_body_width (float) – Gaussian width for 3-body terms. two_body_power (float) – Powerlaw for $$r^{-n}$$ 2-body terms. three_body_power (float) – Powerlaw for Axilrod-Teller-Muto 3-body term cut_start (float) – The fraction of the cut-off radius at which cut-off damping start. cut_distance (float) – Cut-off radius. (default=5 angstrom) fourier_order (integer) – 3-body Fourier-expansion truncation order. alchemy (string) – Type of alchemical interpolation "periodic-table" or "off" are possible options. Disabling alchemical interpolation can yield dramatic speedups. alchemy_period_width (float) – Gaussian width along periods (columns) in the periodic table. alchemy_group_width (float) – Gaussian width along groups (rows) in the periodic table. Array of FCHL kernel matrices matrix - shape=(n_sigmas, N, M), numpy array
qml.fchl.get_global_kernels(A, B, sigmas, two_body_scaling=2.8284271247461903, three_body_scaling=1.6, two_body_width=0.2, three_body_width=3.141592653589793, two_body_power=4.0, three_body_power=2.0, cut_start=1.0, cut_distance=5.0, fourier_order=1, alchemy='periodic-table', alchemy_period_width=1.6, alchemy_group_width=1.6)

Calculates the Gaussian kernel matrix K, where $$K_{ij}$$:

$$K_{ij} = \exp \big( -\frac{\|A_i - B_j\|_2^2}{2\sigma^2} \big)$$

Where $$A_{i}$$ and $$B_{j}$$ are FCHL representation vectors. K is calculated analytically using an OpenMP parallel Fortran routine. Note, that this kernel will ONLY work with FCHL representations as input.

Parameters: A (numpy array) – Array of FCHL representation - shape=(N, maxsize, 5, maxneighbors). B (numpy array) – Array of FCHL representation - shape=(M, maxsize, 5, maxneighbors). sigma (list) – List of kernel-widths. two_body_scaling (float) – Weight for 2-body terms. three_body_scaling (float) – Weight for 3-body terms. two_body_width (float) – Gaussian width for 2-body terms three_body_width (float) – Gaussian width for 3-body terms. two_body_power (float) – Powerlaw for $$r^{-n}$$ 2-body terms. three_body_power (float) – Powerlaw for Axilrod-Teller-Muto 3-body term cut_start (float) – The fraction of the cut-off radius at which cut-off damping start. cut_distance (float) – Cut-off radius. (default=5 angstrom) fourier_order (integer) – 3-body Fourier-expansion truncation order. alchemy (string) – Type of alchemical interpolation "periodic-table" or "off" are possible options. Disabling alchemical interpolation can yield dramatic speedups. alchemy_period_width (float) – Gaussian width along periods (columns) in the periodic table. alchemy_group_width (float) – Gaussian width along groups (rows) in the periodic table. Array of FCHL kernel matrices matrix - shape=(n_sigmas, N, M), numpy array
qml.fchl.get_global_symmetric_kernels(A, sigmas, two_body_scaling=2.8284271247461903, three_body_scaling=1.6, two_body_width=0.2, three_body_width=3.141592653589793, two_body_power=4.0, three_body_power=2.0, cut_start=1.0, cut_distance=5.0, fourier_order=1, alchemy='periodic-table', alchemy_period_width=1.6, alchemy_group_width=1.6)

Calculates the Gaussian kernel matrix K, where $$K_{ij}$$:

$$K_{ij} = \exp \big( -\frac{\|A_i - A_j\|_2^2}{2\sigma^2} \big)$$

Where $$A_{i}$$ and $$A_{j}$$ are FCHL representation vectors. K is calculated analytically using an OpenMP parallel Fortran routine. Note, that this kernel will ONLY work with FCHL representations as input.

Parameters: A (numpy array) – Array of FCHL representation - shape=(N, maxsize, 5, maxneighbors). sigma (list) – List of kernel-widths. two_body_scaling (float) – Weight for 2-body terms. three_body_scaling (float) – Weight for 3-body terms. two_body_width (float) – Gaussian width for 2-body terms three_body_width (float) – Gaussian width for 3-body terms. two_body_power (float) – Powerlaw for $$r^{-n}$$ 2-body terms. three_body_power (float) – Powerlaw for Axilrod-Teller-Muto 3-body term cut_start (float) – The fraction of the cut-off radius at which cut-off damping start. cut_distance (float) – Cut-off radius. (default=5 angstrom) fourier_order (integer) – 3-body Fourier-expansion truncation order. alchemy (string) – Type of alchemical interpolation "periodic-table" or "off" are possible options. Disabling alchemical interpolation can yield dramatic speedups. alchemy_period_width (float) – Gaussian width along periods (columns) in the periodic table. alchemy_group_width (float) – Gaussian width along groups (rows) in the periodic table. Array of FCHL kernel matrices matrix - shape=(n_sigmas, N, N), numpy array
qml.fchl.get_local_kernels(A, B, sigmas, two_body_scaling=2.8284271247461903, three_body_scaling=1.6, two_body_width=0.2, three_body_width=3.141592653589793, two_body_power=4.0, three_body_power=2.0, cut_start=1.0, cut_distance=5.0, fourier_order=1, alchemy='periodic-table', alchemy_period_width=1.6, alchemy_group_width=1.6)

Calculates the Gaussian kernel matrix K, where $$K_{ij}$$:

$$K_{ij} = \exp \big( -\frac{\|A_i - B_j\|_2^2}{2\sigma^2} \big)$$

Where $$A_{i}$$ and $$B_{j}$$ are FCHL representation vectors. K is calculated analytically using an OpenMP parallel Fortran routine. Note, that this kernel will ONLY work with FCHL representations as input.

Parameters: A (numpy array) – Array of FCHL representation - shape=(N, maxsize, 5, maxneighbors). B (numpy array) – Array of FCHL representation - shape=(M, maxsize, 5, maxneighbors). sigma (list) – List of kernel-widths. two_body_scaling (float) – Weight for 2-body terms. three_body_scaling (float) – Weight for 3-body terms. two_body_width (float) – Gaussian width for 2-body terms three_body_width (float) – Gaussian width for 3-body terms. two_body_power (float) – Powerlaw for $$r^{-n}$$ 2-body terms. three_body_power (float) – Powerlaw for Axilrod-Teller-Muto 3-body term cut_start (float) – The fraction of the cut-off radius at which cut-off damping start. cut_distance (float) – Cut-off radius. (default=5 angstrom) fourier_order (integer) – 3-body Fourier-expansion truncation order. alchemy (string) – Type of alchemical interpolation "periodic-table" or "off" are possible options. Disabling alchemical interpolation can yield dramatic speedups. alchemy_period_width (float) – Gaussian width along periods (columns) in the periodic table. alchemy_group_width (float) – Gaussian width along groups (rows) in the periodic table. Array of FCHL kernel matrices matrix - shape=(n_sigmas, N, M), numpy array
qml.fchl.get_local_symmetric_kernels(A, sigmas, two_body_scaling=2.8284271247461903, three_body_scaling=1.6, two_body_width=0.2, three_body_width=3.141592653589793, two_body_power=4.0, three_body_power=2.0, cut_start=1.0, cut_distance=5.0, fourier_order=1, alchemy='periodic-table', alchemy_period_width=1.6, alchemy_group_width=1.6)

Calculates the Gaussian kernel matrix K, where $$K_{ij}$$:

$$K_{ij} = \exp \big( -\frac{\|A_i - A_j\|_2^2}{2\sigma^2} \big)$$

Where $$A_{i}$$ and $$A_{j}$$ are FCHL representation vectors. K is calculated analytically using an OpenMP parallel Fortran routine. Note, that this kernel will ONLY work with FCHL representations as input.

Parameters: A (numpy array) – Array of FCHL representation - shape=(N, maxsize, 5, maxneighbors). sigma (list) – List of kernel-widths. two_body_scaling (float) – Weight for 2-body terms. three_body_scaling (float) – Weight for 3-body terms. two_body_width (float) – Gaussian width for 2-body terms three_body_width (float) – Gaussian width for 3-body terms. two_body_power (float) – Powerlaw for $$r^{-n}$$ 2-body terms. three_body_power (float) – Powerlaw for Axilrod-Teller-Muto 3-body term cut_start (float) – The fraction of the cut-off radius at which cut-off damping start. cut_distance (float) – Cut-off radius. (default=5 angstrom) fourier_order (integer) – 3-body Fourier-expansion truncation order. alchemy (string) – Type of alchemical interpolation "periodic-table" or "off" are possible options. Disabling alchemical interpolation can yield dramatic speedups. alchemy_period_width (float) – Gaussian width along periods (columns) in the periodic table. alchemy_group_width (float) – Gaussian width along groups (rows) in the periodic table. Array of FCHL kernel matrices matrix - shape=(n_sigmas, N, N), numpy array

## qml.wrappers module¶

qml.wrappers.arad_local_kernels(mols1, mols2, sigmas, width=0.2, cut_distance=5.0, r_width=1.0, c_width=0.5)
qml.wrappers.arad_local_symmetric_kernels(mols1, sigmas, width=0.2, cut_distance=5.0, r_width=1.0, c_width=0.5)
qml.wrappers.get_atomic_kernels_gaussian(mols1, mols2, sigmas)
qml.wrappers.get_atomic_kernels_laplacian(mols1, mols2, sigmas)