Metadata-Version: 1.1
Name: qml
Version: 0.2.1
Summary: Quantum Machine Learning
Home-page: https://github.com/qmlcode/qml
Author: Anders S. Christensen
Author-email: andersbiceps@gmail.com
License: UNKNOWN
Download-URL: https://github.com/qmlcode/qml/archive/0.2.1.tar.gz
Description: # QML: A Python Toolking for Quantum Machine Learning
        
        A Python2/3 toolkit for representation learning of molecules and solids. 
        
        Current author list:
        * Anders S. Christensen (University of Basel)
        * Felix Faber (University of Basel)
        * Bing Huang (University of Basel)
        * O. Anatole von Lilienfeld (University of Basel)
        
        ## 1) Installation
        
        Installing prerequisite modules (for most Linux systems):
        
        ```bash
        sudo apt-get install python-pip gfortran libblas-dev liblapack-dev
        
        ```
        These should already be installed on most systems. Alternatively the Intel compilers and MKL math-libraries are supported as well (see section 1.3).
        
        
        ### 1.1) Installing via `pip`:
        
        The easiest way to install is using the official, built-in Python package manager, `pip`:
        
        ```bash
        pip install git+https://github.com/qmlcode/qml --user --upgrade
        ```
        
        Additionally you can use `pip2 install ...` or `pip3 install ...` to get the Python2 or Python3 versions explicitly. QML supports both flavors.
        
        To uninstall simply use `pip` again. 
        
        ```bash
        pip uninstall qml
        ```
        
        ### 1.2) Installing via `setup.py` with Intel compiler:
        
        If you have Intel compilers installed, you can compile QML with ifort/MKL using the following options:
        
        ```bash
        pip install git+https://github.com/qmlcode/qml.git --user --upgrade --global-option="build" --global-option="--compiler=intelem" --global-option="--fcompiler=intelem"
        ```
        
        ### 1.3) Note on Apple/Mac support:
        
        Install QML requires a Fortran compiler. On Darwin you can install it using `brew`:
        
        ```bash
        brew install gcc
        ```
        
        Note: the Clang Fortran compiler in brew does currently not support OpenMP, so this disables parallelism in QML.
        
        
        ## 2) Representations of compounds:
        
        ### 2.1) Supported representations:
        
        Currently QML supports the following representations for molecules:
        
        * Molecular coulomb matrix (sorted by row-norm, or unsorted)
        * Atomic coulomb matrix (sorted by distance to query atom, or row-norm)
        * ARAD
        
        Currently QML supports the following representations for solids:
        
        * ARAD
        
        ### 2.2) Generating representations using the `Compound` class:
        The following example demonstrates how to generate a representation via the `qml.Compound` class.
        
        ```python
        from qml import Compound
        
        # Read in an xyz or cif file.
        water = Compound(xyz="water.xyz")
        
        # Generate a molecular coulomb matrices sorted by row norm.
        water.generate_coulomb_matrix(size=5, sort="row-norm")
        
        print water.coulomb_matrix
        ```
        
        
        ## 2.3) Generating representations via the `qml.representations` module:
        
        ```python
        from qml.representations import *
        
        # Dummy atomtypes and coordinates
        atomtypes = ["O", "H", H"]
        coordinates = np.array([1.464, 0.707, 1.056],
                               [0.878, 1.218, 0.498],
                               [2.319, 1.126, 0.952])
        
        # Generate a molecular coulomb matrices sorted by row norm.
        cm1 = generate_coulomb_matrix(atomtypes, coordinates,
                                        size=5, sort="row-norm")
        print cm1
        
        # Generate all atomic coulomb matrices sorted by distance to
        # query atom.
        cm2 = generate_atomic_coulomb_matrix(atomtypes, coordinates,
                                        size=5, sort="distance")
        print cm2
        ```
        
        ## 2.4) Benchmarks for QM7:
        Following benchmarks were executed on a single core on an Intel Core i5-6260U @ 1.80 GHz CPU.
        
        Generate ~7K molecular coulomb matrices = 0.06s 
        Generate ~100K atomic coulomb matrices = 0.22s
        
        
         
        ## 3.1) Calculate kernels using the `Compound` class:
        
        ... to be updated
        
        
        ## 3.2) Calculate kernels using the `qml.kernels` module directly
        
        
        ```python
        from qml.kernels import laplacian_kernel
        ```
        ... to be updated
        ## 3.3) Benchmarks for QM7:
        ... to be updated
        
        ## 4.1) 
        ... to be updated
        
Keywords: Quantum Machine Learning
Platform: Any
