# Sphinx build info version 1

# This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done.

config: 0187fd5a56a7fa8e58d48ee8b0e02af9

tags: 645f666f9bcd5a90fca523b33c5a78b7

www.qmlcode.org

Citing use of QML

QML is freely available under the terms of the MIT open-source license.

However, we ask that you properly cite the relevant, underlying work in your published work.

For convenience we provide a list of citations here.

Until the preprint is available from arXiv, please cite use of QML as:

::

Examples

Generating representations using the ``Compound`` class

The following example demonstrates how to generate a representation via

the ``qml.Compound`` class.

.. code:: python

Might print the following representation:

.. code::

Generating representations via the ``qml.representations`` module

.. code:: python

The resulting Coulomb-matrix for water:

.. code::

.. code:: python

.. code::

Calculating a Gaussian kernel

The input for most of the kernels in QML is a numpy array, where the first dimension is the number of representations, and the second dimension is the size of each representation. An brief example is presented here, where ``compounds`` is a list of ``Compound()`` objects:

.. code:: python

Calculating a Gaussian kernel using a local representation

The easiest way to calculate the kernel matrix using an explicit, local representation is via the wrappers module. Note that here the sigmas is a list of sigmas, and the result is a kernel for each sigma. The following examples currently work with the atomic coulomb matrix representation and the local SLATM representation:

.. code:: python

.. code::

Note that ``mol.representation`` is just a 1D numpy array.

Generating the SLATM representation

The Spectrum of London and Axillrod-Teller-Muto potential (SLATM) representation requires additional input to reduce the size of the representation.

This input (the types of many-body terms) is generate via the ``get_slatm_mbtypes()`` function. The function takes a list of the nuclear charges for each molecule in the dataset as input. E.g.:

.. code:: python

The ``local`` keyword in this example specifies that a local representation is produced. Alternatively the SLATM representation can be generate via the ``qml.representations`` module:

.. code:: python

Here ``coordinates`` is an Nx3 numpy array, and ``nuclear_charges`` is simply a list of charges.

Generating the FCHL representation

The FCHL representation does not have an explicit representation in the form of a vector, and the kernel elements must be calculated analytically in a separate kernel function.

The syntax is analogous to the explicit representations (e.g. Coulomb matrix, BoB, SLATM, etc), but is handled by kernels from the separate ``qml.fchl`` module.

The code below show three ways to create the input representations for the FHCL kernel functions.

First using the ``Compound`` class:

.. code:: python

The dimensions of the array should be ``(number_molecules, size, 5, size)``, where ``size`` is the

size keyword used when generating the representations.

In addition to using the ``Compound`` class to generate the representations, FCHL representations can also be generated via the ``qml.fchl.generate_fchl_representation()`` function, using similar notation to the functions in the ``qml.representations.*`` functions.

.. code:: python

To create the representation for a crystal, the notation is as follows:

.. code:: python

The neighbors keyword is the max number of atoms with the cutoff-distance

Generating the FCHL kernel

The following example demonstrates how to calculate the local FCHL kernel elements between FCHL representations. ``X1`` and ``X2`` are numpy arrays with the shape ``(number_compounds,max_size, 5,neighbors)``, as generated in one of the previous examples. You MUST use the same, or larger, cut-off distance to generate the representation, as to calculate the kernel.

.. code:: python

As output you will get a kernel for each kernel-width.

.. code::

In case ``X1`` and ``X2`` are identical, K will be symmetrical. This is handled by a separate function with exploits this symmetry (thus being twice as fast).

.. code:: python

.. code::

In addition to the local kernel, the FCHL module also provides kernels for atomic properties (e.g. chemical shifts, partial charges, etc). These have the name "atomic", rather than "local".

.. code:: python

The only difference between the local and atomic kernels is the shape of the input.

Since the atomic kernel outputs kernels with atomic resolution, the atomic input has the shape ``(number_atoms, 5, size)``.