Repository: qmlcode/qml
Branch: archive
Commit: 607d49eba83f
Files: 7349
Total size: 23.1 MB
Directory structure:
gitextract_jh1lqesx/
├── .gitignore
├── .travis.yml
├── LICENSE
├── README.rst
├── docs/
│ ├── Makefile
│ └── source/
│ ├── citation.rst
│ ├── conf.py
│ ├── force_kernels.rst
│ ├── index.rst
│ ├── installation.rst
│ ├── qml.rst
│ ├── qml_examples/
│ │ └── examples.ipynb
│ └── tutorial.rst
├── examples/
│ ├── ARMP_1.py
│ ├── ARMP_2.py
│ ├── ARMP_3.py
│ ├── ARMP_qm7.py
│ ├── MRMP_1.py
│ ├── MRMP_2.py
│ ├── MRMP_3.py
│ ├── qm7_hyperparam_search/
│ │ ├── config.yaml
│ │ ├── idx.csv
│ │ ├── idx.npy
│ │ ├── make_model_pickle.py
│ │ └── model.pickle
│ ├── qmlearn.py
│ ├── test_qmlearn_energy.py
│ └── test_qmlearn_force.py
├── mkldiscover.py
├── qml/
│ ├── __init__.py
│ ├── aglaia/
│ │ ├── __init__.py
│ │ ├── aglaia.py
│ │ ├── graceful_killer.py
│ │ ├── np_symm_funct.py
│ │ ├── placeholder.py
│ │ ├── symm_funct.py
│ │ ├── tensormol_symm_funct.py
│ │ └── tf_utils.py
│ ├── arad/
│ │ ├── __init__.py
│ │ ├── arad.py
│ │ └── farad_kernels.f90
│ ├── driver/
│ │ └── driver_mpi.f90
│ ├── fchl/
│ │ ├── __init__.py
│ │ ├── fchl_electric_field_kernels.py
│ │ ├── fchl_force_kernels.py
│ │ ├── fchl_kernel_functions.py
│ │ ├── fchl_representations.py
│ │ ├── fchl_scalar_kernels.py
│ │ ├── ffchl_electric_field_kernels.f90
│ │ ├── ffchl_force_kernels.f90
│ │ ├── ffchl_kernel_types.f90
│ │ ├── ffchl_kernels.f90
│ │ ├── ffchl_module.f90
│ │ └── ffchl_scalar_kernels.f90
│ ├── kernels/
│ │ ├── __init__.py
│ │ ├── distance.py
│ │ ├── fdistance.f90
│ │ ├── fgradient_kernels.f90
│ │ ├── fkernels.f90
│ │ ├── fkpca.f90
│ │ ├── gradient_kernels.py
│ │ ├── kernels.py
│ │ └── wrappers.py
│ ├── math/
│ │ ├── __init__.py
│ │ ├── fsolvers.f90
│ │ └── math.py
│ ├── models/
│ │ ├── __init__.py
│ │ ├── kernelridge.py
│ │ └── mlmodel.py
│ ├── qmlearn/
│ │ ├── __init__.py
│ │ ├── data.py
│ │ ├── kernels.py
│ │ ├── models.py
│ │ ├── preprocessing.py
│ │ └── representations.py
│ ├── representations/
│ │ ├── __init__.py
│ │ ├── facsf.f90
│ │ ├── frepresentations.f90
│ │ ├── fslatm.f90
│ │ ├── representations.py
│ │ └── slatm.py
│ └── utils/
│ ├── __init__.py
│ ├── alchemy.py
│ ├── compound.py
│ └── utils.py
├── requirements.txt
├── setup.py
└── test/
├── CN_isobutane/
│ ├── 00000.xyz
│ ├── 00001.xyz
│ ├── 00002.xyz
│ ├── 00003.xyz
│ ├── 00004.xyz
│ ├── 00005.xyz
│ ├── 00006.xyz
│ ├── 00007.xyz
│ ├── 00008.xyz
│ ├── 00009.xyz
│ ├── 00010.xyz
│ ├── 00011.xyz
│ ├── 00012.xyz
│ ├── 00013.xyz
│ ├── 00014.xyz
│ ├── 00015.xyz
│ ├── 00016.xyz
│ ├── 00017.xyz
│ ├── 00018.xyz
│ ├── 00019.xyz
│ ├── 00020.xyz
│ ├── 00021.xyz
│ ├── 00022.xyz
│ ├── 00023.xyz
│ ├── 00024.xyz
│ ├── 00025.xyz
│ ├── 00026.xyz
│ ├── 00027.xyz
│ ├── 00028.xyz
│ ├── 00029.xyz
│ ├── 00030.xyz
│ ├── 00031.xyz
│ ├── 00032.xyz
│ ├── 00033.xyz
│ ├── 00034.xyz
│ ├── 00035.xyz
│ ├── 00036.xyz
│ ├── 00037.xyz
│ ├── 00038.xyz
│ ├── 00039.xyz
│ ├── 00040.xyz
│ ├── 00041.xyz
│ ├── 00042.xyz
│ ├── 00043.xyz
│ ├── 00044.xyz
│ ├── 00045.xyz
│ ├── 00046.xyz
│ ├── 00047.xyz
│ ├── 00048.xyz
│ ├── 00049.xyz
│ ├── 00050.xyz
│ ├── 00051.xyz
│ ├── 00052.xyz
│ ├── 00053.xyz
│ ├── 00054.xyz
│ ├── 00055.xyz
│ ├── 00056.xyz
│ ├── 00057.xyz
│ ├── 00058.xyz
│ ├── 00059.xyz
│ ├── 00060.xyz
│ ├── 00061.xyz
│ ├── 00062.xyz
│ ├── 00063.xyz
│ ├── 00064.xyz
│ ├── 00065.xyz
│ ├── 00066.xyz
│ ├── 00067.xyz
│ ├── 00068.xyz
│ ├── 00069.xyz
│ ├── 00070.xyz
│ ├── 00071.xyz
│ ├── 00072.xyz
│ ├── 00073.xyz
│ ├── 00074.xyz
│ ├── 00075.xyz
│ ├── 00076.xyz
│ ├── 00077.xyz
│ ├── 00078.xyz
│ ├── 00079.xyz
│ ├── 00080.xyz
│ ├── 00081.xyz
│ ├── 00082.xyz
│ ├── 00083.xyz
│ ├── 00084.xyz
│ ├── 00085.xyz
│ ├── 00086.xyz
│ ├── 00087.xyz
│ ├── 00088.xyz
│ ├── 00089.xyz
│ ├── 00090.xyz
│ ├── 00091.xyz
│ ├── 00092.xyz
│ ├── 00093.xyz
│ ├── 00094.xyz
│ ├── 00095.xyz
│ ├── 00096.xyz
│ ├── 00097.xyz
│ ├── 00098.xyz
│ ├── 00099.xyz
│ └── prop_kjmol_training.txt
├── data/
│ ├── CN_isopent_light_UCM.npz
│ ├── K_local_gaussian.txt
│ ├── K_local_laplacian.txt
│ ├── Ks_local_gaussian.txt
│ ├── Ks_local_laplacian.txt
│ ├── acsf_gradients.txt
│ ├── acsf_representation.txt
│ ├── amons_small.csv
│ ├── atomic_coulomb_matrix_representation_distance_sorted.txt
│ ├── atomic_coulomb_matrix_representation_distance_sorted_no_indices.txt
│ ├── atomic_coulomb_matrix_representation_distance_sorted_with_cutoff.txt
│ ├── atomic_coulomb_matrix_representation_row-norm_sorted.txt
│ ├── atomic_coulomb_matrix_representation_row-norm_sorted_with_cutoff.txt
│ ├── bob_representation.txt
│ ├── compound_test.exyz
│ ├── compound_test.xyz
│ ├── coulomb_matrix_representation_row-norm_sorted.txt
│ ├── coulomb_matrix_representation_unsorted.txt
│ ├── data_test_acsf.npz
│ ├── data_test_acsf_01.npz
│ ├── eigenvalue_coulomb_matrix_representation.txt
│ ├── fchl_ef_rep.txt
│ ├── force_test.csv
│ ├── force_train.csv
│ ├── force_valid.csv
│ ├── hcn.xyz
│ ├── hof_qm7.txt
│ ├── local_slatm_ch4cn_light.bz.npz
│ ├── local_slatm_ch4cn_light.npz
│ ├── qm7_testdata.npz
│ ├── slatm_global_representation.txt
│ ├── slatm_local_representation.txt
│ ├── slatm_representation.txt
│ └── y_cho_solve.txt
├── qm7/
│ ├── 0001.xyz
│ ├── 0002.xyz
│ ├── 0003.xyz
│ ├── 0004.xyz
│ ├── 0005.xyz
│ ├── 0006.xyz
│ ├── 0007.xyz
│ ├── 0008.xyz
│ ├── 0009.xyz
│ ├── 0010.xyz
│ ├── 0011.xyz
│ ├── 0012.xyz
│ ├── 0013.xyz
│ ├── 0014.xyz
│ ├── 0015.xyz
│ ├── 0016.xyz
│ ├── 0017.xyz
│ ├── 0018.xyz
│ ├── 0019.xyz
│ ├── 0020.xyz
│ ├── 0021.xyz
│ ├── 0022.xyz
│ ├── 0023.xyz
│ ├── 0024.xyz
│ ├── 0025.xyz
│ ├── 0026.xyz
│ ├── 0027.xyz
│ ├── 0028.xyz
│ ├── 0029.xyz
│ ├── 0030.xyz
│ ├── 0031.xyz
│ ├── 0032.xyz
│ ├── 0033.xyz
│ ├── 0034.xyz
│ ├── 0035.xyz
│ ├── 0036.xyz
│ ├── 0037.xyz
│ ├── 0038.xyz
│ ├── 0039.xyz
│ ├── 0040.xyz
│ ├── 0041.xyz
│ ├── 0042.xyz
│ ├── 0043.xyz
│ ├── 0044.xyz
│ ├── 0045.xyz
│ ├── 0046.xyz
│ ├── 0047.xyz
│ ├── 0048.xyz
│ ├── 0049.xyz
│ ├── 0050.xyz
│ ├── 0051.xyz
│ ├── 0052.xyz
│ ├── 0053.xyz
│ ├── 0054.xyz
│ ├── 0055.xyz
│ ├── 0056.xyz
│ ├── 0057.xyz
│ ├── 0058.xyz
│ ├── 0059.xyz
│ ├── 0060.xyz
│ ├── 0061.xyz
│ ├── 0062.xyz
│ ├── 0063.xyz
│ ├── 0064.xyz
│ ├── 0065.xyz
│ ├── 0066.xyz
│ ├── 0067.xyz
│ ├── 0068.xyz
│ ├── 0069.xyz
│ ├── 0070.xyz
│ ├── 0071.xyz
│ ├── 0072.xyz
│ ├── 0073.xyz
│ ├── 0074.xyz
│ ├── 0075.xyz
│ ├── 0076.xyz
│ ├── 0077.xyz
│ ├── 0078.xyz
│ ├── 0079.xyz
│ ├── 0080.xyz
│ ├── 0081.xyz
│ ├── 0082.xyz
│ ├── 0083.xyz
│ ├── 0084.xyz
│ ├── 0085.xyz
│ ├── 0086.xyz
│ ├── 0087.xyz
│ ├── 0088.xyz
│ ├── 0090.xyz
│ ├── 0091.xyz
│ ├── 0092.xyz
│ ├── 0093.xyz
│ ├── 0094.xyz
│ ├── 0095.xyz
│ ├── 0096.xyz
│ ├── 0097.xyz
│ ├── 0098.xyz
│ ├── 0099.xyz
│ ├── 0100.xyz
│ ├── 0101.xyz
│ ├── 0102.xyz
│ ├── 0103.xyz
│ ├── 0104.xyz
│ ├── 0105.xyz
│ ├── 0106.xyz
│ ├── 0107.xyz
│ ├── 0108.xyz
│ ├── 0109.xyz
│ ├── 0110.xyz
│ ├── 0111.xyz
│ ├── 0112.xyz
│ ├── 0113.xyz
│ ├── 0114.xyz
│ ├── 0115.xyz
│ ├── 0116.xyz
│ ├── 0117.xyz
│ ├── 0118.xyz
│ ├── 0119.xyz
│ ├── 0120.xyz
│ ├── 0121.xyz
│ ├── 0122.xyz
│ ├── 0123.xyz
│ ├── 0124.xyz
│ ├── 0125.xyz
│ ├── 0126.xyz
│ ├── 0127.xyz
│ ├── 0128.xyz
│ ├── 0129.xyz
│ ├── 0130.xyz
│ ├── 0131.xyz
│ ├── 0132.xyz
│ ├── 0133.xyz
│ ├── 0134.xyz
│ ├── 0135.xyz
│ ├── 0136.xyz
│ ├── 0137.xyz
│ ├── 0138.xyz
│ ├── 0139.xyz
│ ├── 0140.xyz
│ ├── 0141.xyz
│ ├── 0142.xyz
│ ├── 0143.xyz
│ ├── 0144.xyz
│ ├── 0145.xyz
│ ├── 0146.xyz
│ ├── 0147.xyz
│ ├── 0148.xyz
│ ├── 0149.xyz
│ ├── 0150.xyz
│ ├── 0151.xyz
│ ├── 0152.xyz
│ ├── 0153.xyz
│ ├── 0154.xyz
│ ├── 0155.xyz
│ ├── 0156.xyz
│ ├── 0157.xyz
│ ├── 0158.xyz
│ ├── 0159.xyz
│ ├── 0160.xyz
│ ├── 0161.xyz
│ ├── 0162.xyz
│ ├── 0163.xyz
│ ├── 0164.xyz
│ ├── 0165.xyz
│ ├── 0166.xyz
│ ├── 0167.xyz
│ ├── 0168.xyz
│ ├── 0169.xyz
│ ├── 0170.xyz
│ ├── 0171.xyz
│ ├── 0172.xyz
│ ├── 0173.xyz
│ ├── 0174.xyz
│ ├── 0175.xyz
│ ├── 0176.xyz
│ ├── 0177.xyz
│ ├── 0178.xyz
│ ├── 0179.xyz
│ ├── 0180.xyz
│ ├── 0181.xyz
│ ├── 0182.xyz
│ ├── 0183.xyz
│ ├── 0184.xyz
│ ├── 0185.xyz
│ ├── 0186.xyz
│ ├── 0187.xyz
│ ├── 0188.xyz
│ ├── 0189.xyz
│ ├── 0190.xyz
│ ├── 0191.xyz
│ ├── 0192.xyz
│ ├── 0193.xyz
│ ├── 0194.xyz
│ ├── 0195.xyz
│ ├── 0196.xyz
│ ├── 0197.xyz
│ ├── 0198.xyz
│ ├── 0199.xyz
│ ├── 0200.xyz
│ ├── 0201.xyz
│ ├── 0202.xyz
│ ├── 0203.xyz
│ ├── 0204.xyz
│ ├── 0205.xyz
│ ├── 0206.xyz
│ ├── 0207.xyz
│ ├── 0208.xyz
│ ├── 0209.xyz
│ ├── 0210.xyz
│ ├── 0211.xyz
│ ├── 0212.xyz
│ ├── 0213.xyz
│ ├── 0214.xyz
│ ├── 0215.xyz
│ ├── 0216.xyz
│ ├── 0217.xyz
│ ├── 0218.xyz
│ ├── 0219.xyz
│ ├── 0220.xyz
│ ├── 0221.xyz
│ ├── 0222.xyz
│ ├── 0223.xyz
│ ├── 0224.xyz
│ ├── 0225.xyz
│ ├── 0226.xyz
│ ├── 0227.xyz
│ ├── 0228.xyz
│ ├── 0229.xyz
│ ├── 0230.xyz
│ ├── 0231.xyz
│ ├── 0232.xyz
│ ├── 0233.xyz
│ ├── 0234.xyz
│ ├── 0235.xyz
│ ├── 0236.xyz
│ ├── 0237.xyz
│ ├── 0238.xyz
│ ├── 0239.xyz
│ ├── 0240.xyz
│ ├── 0241.xyz
│ ├── 0242.xyz
│ ├── 0243.xyz
│ ├── 0244.xyz
│ ├── 0245.xyz
│ ├── 0246.xyz
│ ├── 0247.xyz
│ ├── 0248.xyz
│ ├── 0249.xyz
│ ├── 0250.xyz
│ ├── 0251.xyz
│ ├── 0252.xyz
│ ├── 0253.xyz
│ ├── 0254.xyz
│ ├── 0255.xyz
│ ├── 0256.xyz
│ ├── 0257.xyz
│ ├── 0258.xyz
│ ├── 0259.xyz
│ ├── 0260.xyz
│ ├── 0261.xyz
│ ├── 0262.xyz
│ ├── 0263.xyz
│ ├── 0264.xyz
│ ├── 0265.xyz
│ ├── 0266.xyz
│ ├── 0267.xyz
│ ├── 0268.xyz
│ ├── 0269.xyz
│ ├── 0270.xyz
│ ├── 0271.xyz
│ ├── 0272.xyz
│ ├── 0273.xyz
│ ├── 0274.xyz
│ ├── 0275.xyz
│ ├── 0276.xyz
│ ├── 0277.xyz
│ ├── 0278.xyz
│ ├── 0279.xyz
│ ├── 0280.xyz
│ ├── 0281.xyz
│ ├── 0282.xyz
│ ├── 0283.xyz
│ ├── 0284.xyz
│ ├── 0285.xyz
│ ├── 0286.xyz
│ ├── 0287.xyz
│ ├── 0288.xyz
│ ├── 0289.xyz
│ ├── 0290.xyz
│ ├── 0291.xyz
│ ├── 0292.xyz
│ ├── 0293.xyz
│ ├── 0294.xyz
│ ├── 0295.xyz
│ ├── 0296.xyz
│ ├── 0297.xyz
│ ├── 0299.xyz
│ ├── 0300.xyz
│ ├── 0301.xyz
│ ├── 0302.xyz
│ ├── 0303.xyz
│ ├── 0304.xyz
│ ├── 0305.xyz
│ ├── 0306.xyz
│ ├── 0307.xyz
│ ├── 0308.xyz
│ ├── 0309.xyz
│ ├── 0310.xyz
│ ├── 0311.xyz
│ ├── 0312.xyz
│ ├── 0313.xyz
│ ├── 0314.xyz
│ ├── 0315.xyz
│ ├── 0316.xyz
│ ├── 0317.xyz
│ ├── 0318.xyz
│ ├── 0319.xyz
│ ├── 0320.xyz
│ ├── 0321.xyz
│ ├── 0322.xyz
│ ├── 0323.xyz
│ ├── 0324.xyz
│ ├── 0325.xyz
│ ├── 0326.xyz
│ ├── 0327.xyz
│ ├── 0328.xyz
│ ├── 0329.xyz
│ ├── 0330.xyz
│ ├── 0331.xyz
│ ├── 0332.xyz
│ ├── 0333.xyz
│ ├── 0334.xyz
│ ├── 0335.xyz
│ ├── 0336.xyz
│ ├── 0337.xyz
│ ├── 0338.xyz
│ ├── 0339.xyz
│ ├── 0340.xyz
│ ├── 0341.xyz
│ ├── 0342.xyz
│ ├── 0343.xyz
│ ├── 0344.xyz
│ ├── 0345.xyz
│ ├── 0346.xyz
│ ├── 0347.xyz
│ ├── 0348.xyz
│ ├── 0349.xyz
│ ├── 0350.xyz
│ ├── 0351.xyz
│ ├── 0352.xyz
│ ├── 0353.xyz
│ ├── 0354.xyz
│ ├── 0355.xyz
│ ├── 0356.xyz
│ ├── 0357.xyz
│ ├── 0358.xyz
│ ├── 0359.xyz
│ ├── 0360.xyz
│ ├── 0361.xyz
│ ├── 0362.xyz
│ ├── 0363.xyz
│ ├── 0365.xyz
│ ├── 0366.xyz
│ ├── 0367.xyz
│ ├── 0368.xyz
│ ├── 0369.xyz
│ ├── 0370.xyz
│ ├── 0371.xyz
│ ├── 0372.xyz
│ ├── 0373.xyz
│ ├── 0374.xyz
│ ├── 0375.xyz
│ ├── 0376.xyz
│ ├── 0377.xyz
│ ├── 0378.xyz
│ ├── 0379.xyz
│ ├── 0380.xyz
│ ├── 0381.xyz
│ ├── 0382.xyz
│ ├── 0383.xyz
│ ├── 0384.xyz
│ ├── 0385.xyz
│ ├── 0386.xyz
│ ├── 0387.xyz
│ ├── 0388.xyz
│ ├── 0389.xyz
│ ├── 0390.xyz
│ ├── 0391.xyz
│ ├── 0392.xyz
│ ├── 0393.xyz
│ ├── 0394.xyz
│ ├── 0395.xyz
│ ├── 0396.xyz
│ ├── 0397.xyz
│ ├── 0398.xyz
│ ├── 0399.xyz
│ ├── 0400.xyz
│ ├── 0401.xyz
│ ├── 0402.xyz
│ ├── 0403.xyz
│ ├── 0404.xyz
│ ├── 0405.xyz
│ ├── 0406.xyz
│ ├── 0407.xyz
│ ├── 0408.xyz
│ ├── 0409.xyz
│ ├── 0410.xyz
│ ├── 0411.xyz
│ ├── 0412.xyz
│ ├── 0413.xyz
│ ├── 0414.xyz
│ ├── 0415.xyz
│ ├── 0416.xyz
│ ├── 0417.xyz
│ ├── 0418.xyz
│ ├── 0419.xyz
│ ├── 0420.xyz
│ ├── 0421.xyz
│ ├── 0422.xyz
│ ├── 0423.xyz
│ ├── 0424.xyz
│ ├── 0425.xyz
│ ├── 0426.xyz
│ ├── 0427.xyz
│ ├── 0428.xyz
│ ├── 0429.xyz
│ ├── 0430.xyz
│ ├── 0431.xyz
│ ├── 0432.xyz
│ ├── 0433.xyz
│ ├── 0434.xyz
│ ├── 0435.xyz
│ ├── 0436.xyz
│ ├── 0437.xyz
│ ├── 0438.xyz
│ ├── 0439.xyz
│ ├── 0440.xyz
│ ├── 0441.xyz
│ ├── 0443.xyz
│ ├── 0445.xyz
│ ├── 0446.xyz
│ ├── 0447.xyz
│ ├── 0448.xyz
│ ├── 0449.xyz
│ ├── 0450.xyz
│ ├── 0451.xyz
│ ├── 0452.xyz
│ ├── 0453.xyz
│ ├── 0454.xyz
│ ├── 0455.xyz
│ ├── 0456.xyz
│ ├── 0457.xyz
│ ├── 0458.xyz
│ ├── 0459.xyz
│ ├── 0460.xyz
│ ├── 0461.xyz
│ ├── 0462.xyz
│ ├── 0463.xyz
│ ├── 0464.xyz
│ ├── 0465.xyz
│ ├── 0466.xyz
│ ├── 0467.xyz
│ ├── 0468.xyz
│ ├── 0469.xyz
│ ├── 0470.xyz
│ ├── 0471.xyz
│ ├── 0472.xyz
│ ├── 0473.xyz
│ ├── 0474.xyz
│ ├── 0475.xyz
│ ├── 0476.xyz
│ ├── 0477.xyz
│ ├── 0478.xyz
│ ├── 0479.xyz
│ ├── 0480.xyz
│ ├── 0481.xyz
│ ├── 0482.xyz
│ ├── 0483.xyz
│ ├── 0484.xyz
│ ├── 0485.xyz
│ ├── 0486.xyz
│ ├── 0487.xyz
│ ├── 0488.xyz
│ ├── 0489.xyz
│ ├── 0490.xyz
│ ├── 0491.xyz
│ ├── 0492.xyz
│ ├── 0493.xyz
│ ├── 0494.xyz
│ ├── 0495.xyz
│ ├── 0496.xyz
│ ├── 0497.xyz
│ ├── 0498.xyz
│ ├── 0499.xyz
│ ├── 0500.xyz
│ ├── 0502.xyz
│ ├── 0503.xyz
│ ├── 0504.xyz
│ ├── 0505.xyz
│ ├── 0506.xyz
│ ├── 0507.xyz
│ ├── 0508.xyz
│ ├── 0509.xyz
│ ├── 0510.xyz
│ ├── 0511.xyz
│ ├── 0512.xyz
│ ├── 0513.xyz
│ ├── 0514.xyz
│ ├── 0515.xyz
│ ├── 0516.xyz
│ ├── 0517.xyz
│ ├── 0518.xyz
│ ├── 0519.xyz
│ ├── 0520.xyz
│ ├── 0521.xyz
│ ├── 0522.xyz
│ ├── 0523.xyz
│ ├── 0524.xyz
│ ├── 0525.xyz
│ ├── 0526.xyz
│ ├── 0527.xyz
│ ├── 0528.xyz
│ ├── 0529.xyz
│ ├── 0530.xyz
│ ├── 0531.xyz
│ ├── 0532.xyz
│ ├── 0533.xyz
│ ├── 0534.xyz
│ ├── 0535.xyz
│ ├── 0536.xyz
│ ├── 0537.xyz
│ ├── 0538.xyz
│ ├── 0539.xyz
│ ├── 0540.xyz
│ ├── 0541.xyz
│ ├── 0542.xyz
│ ├── 0543.xyz
│ ├── 0544.xyz
│ ├── 0545.xyz
│ ├── 0546.xyz
│ ├── 0547.xyz
│ ├── 0548.xyz
│ ├── 0549.xyz
│ ├── 0550.xyz
│ ├── 0551.xyz
│ ├── 0552.xyz
│ ├── 0553.xyz
│ ├── 0554.xyz
│ ├── 0555.xyz
│ ├── 0556.xyz
│ ├── 0557.xyz
│ ├── 0558.xyz
│ ├── 0559.xyz
│ ├── 0560.xyz
│ ├── 0561.xyz
│ ├── 0562.xyz
│ ├── 0563.xyz
│ ├── 0564.xyz
│ ├── 0565.xyz
│ ├── 0566.xyz
│ ├── 0567.xyz
│ ├── 0568.xyz
│ ├── 0569.xyz
│ ├── 0570.xyz
│ ├── 0571.xyz
│ ├── 0572.xyz
│ ├── 0573.xyz
│ ├── 0574.xyz
│ ├── 0575.xyz
│ ├── 0576.xyz
│ ├── 0577.xyz
│ ├── 0578.xyz
│ ├── 0579.xyz
│ ├── 0580.xyz
│ ├── 0581.xyz
│ ├── 0582.xyz
│ ├── 0583.xyz
│ ├── 0584.xyz
│ ├── 0585.xyz
│ ├── 0586.xyz
│ ├── 0587.xyz
│ ├── 0588.xyz
│ ├── 0589.xyz
│ ├── 0590.xyz
│ ├── 0591.xyz
│ ├── 0592.xyz
│ ├── 0593.xyz
│ ├── 0594.xyz
│ ├── 0595.xyz
│ ├── 0596.xyz
│ ├── 0597.xyz
│ ├── 0598.xyz
│ ├── 0599.xyz
│ ├── 0600.xyz
│ ├── 0601.xyz
│ ├── 0602.xyz
│ ├── 0603.xyz
│ ├── 0604.xyz
│ ├── 0605.xyz
│ ├── 0606.xyz
│ ├── 0607.xyz
│ ├── 0608.xyz
│ ├── 0609.xyz
│ ├── 0610.xyz
│ ├── 0611.xyz
│ ├── 0612.xyz
│ ├── 0613.xyz
│ ├── 0614.xyz
│ ├── 0615.xyz
│ ├── 0616.xyz
│ ├── 0617.xyz
│ ├── 0618.xyz
│ ├── 0619.xyz
│ ├── 0620.xyz
│ ├── 0621.xyz
│ ├── 0622.xyz
│ ├── 0623.xyz
│ ├── 0624.xyz
│ ├── 0625.xyz
│ ├── 0626.xyz
│ ├── 0627.xyz
│ ├── 0628.xyz
│ ├── 0629.xyz
│ ├── 0630.xyz
│ ├── 0631.xyz
│ ├── 0632.xyz
│ ├── 0633.xyz
│ ├── 0634.xyz
│ ├── 0635.xyz
│ ├── 0636.xyz
│ ├── 0637.xyz
│ ├── 0638.xyz
│ ├── 0640.xyz
│ ├── 0641.xyz
│ ├── 0642.xyz
│ ├── 0643.xyz
│ ├── 0644.xyz
│ ├── 0646.xyz
│ ├── 0647.xyz
│ ├── 0648.xyz
│ ├── 0649.xyz
│ ├── 0650.xyz
│ ├── 0651.xyz
│ ├── 0652.xyz
│ ├── 0653.xyz
│ ├── 0654.xyz
│ ├── 0655.xyz
│ ├── 0656.xyz
│ ├── 0657.xyz
│ ├── 0658.xyz
│ ├── 0659.xyz
│ ├── 0660.xyz
│ ├── 0661.xyz
│ ├── 0662.xyz
│ ├── 0663.xyz
│ ├── 0664.xyz
│ ├── 0665.xyz
│ ├── 0666.xyz
│ ├── 0667.xyz
│ ├── 0668.xyz
│ ├── 0669.xyz
│ ├── 0670.xyz
│ ├── 0671.xyz
│ ├── 0672.xyz
│ ├── 0674.xyz
│ ├── 0675.xyz
│ ├── 0676.xyz
│ ├── 0677.xyz
│ ├── 0678.xyz
│ ├── 0679.xyz
│ ├── 0680.xyz
│ ├── 0681.xyz
│ ├── 0682.xyz
│ ├── 0683.xyz
│ ├── 0684.xyz
│ ├── 0685.xyz
│ ├── 0686.xyz
│ ├── 0687.xyz
│ ├── 0688.xyz
│ ├── 0689.xyz
│ ├── 0690.xyz
│ ├── 0691.xyz
│ ├── 0692.xyz
│ ├── 0693.xyz
│ ├── 0694.xyz
│ ├── 0695.xyz
│ ├── 0697.xyz
│ ├── 0698.xyz
│ ├── 0699.xyz
│ ├── 0700.xyz
│ ├── 0701.xyz
│ ├── 0702.xyz
│ ├── 0703.xyz
│ ├── 0704.xyz
│ ├── 0705.xyz
│ ├── 0706.xyz
│ ├── 0707.xyz
│ ├── 0708.xyz
│ ├── 0709.xyz
│ ├── 0710.xyz
│ ├── 0711.xyz
│ ├── 0712.xyz
│ ├── 0713.xyz
│ ├── 0714.xyz
│ ├── 0715.xyz
│ ├── 0716.xyz
│ ├── 0717.xyz
│ ├── 0718.xyz
│ ├── 0719.xyz
│ ├── 0720.xyz
│ ├── 0721.xyz
│ ├── 0722.xyz
│ ├── 0723.xyz
│ ├── 0724.xyz
│ ├── 0725.xyz
│ ├── 0726.xyz
│ ├── 0727.xyz
│ ├── 0728.xyz
│ ├── 0729.xyz
│ ├── 0730.xyz
│ ├── 0731.xyz
│ ├── 0732.xyz
│ ├── 0733.xyz
│ ├── 0734.xyz
│ ├── 0735.xyz
│ ├── 0736.xyz
│ ├── 0737.xyz
│ ├── 0739.xyz
│ ├── 0740.xyz
│ ├── 0741.xyz
│ ├── 0742.xyz
│ ├── 0743.xyz
│ ├── 0744.xyz
│ ├── 0745.xyz
│ ├── 0746.xyz
│ ├── 0747.xyz
│ ├── 0748.xyz
│ ├── 0749.xyz
│ ├── 0750.xyz
│ ├── 0751.xyz
│ ├── 0752.xyz
│ ├── 0753.xyz
│ ├── 0754.xyz
│ ├── 0755.xyz
│ ├── 0756.xyz
│ ├── 0758.xyz
│ ├── 0759.xyz
│ ├── 0760.xyz
│ ├── 0761.xyz
│ ├── 0762.xyz
│ ├── 0763.xyz
│ ├── 0764.xyz
│ ├── 0765.xyz
│ ├── 0766.xyz
│ ├── 0767.xyz
│ ├── 0768.xyz
│ ├── 0769.xyz
│ ├── 0770.xyz
│ ├── 0771.xyz
│ ├── 0772.xyz
│ ├── 0774.xyz
│ ├── 0775.xyz
│ ├── 0776.xyz
│ ├── 0777.xyz
│ ├── 0778.xyz
│ ├── 0779.xyz
│ ├── 0780.xyz
│ ├── 0781.xyz
│ ├── 0782.xyz
│ ├── 0783.xyz
│ ├── 0784.xyz
│ ├── 0785.xyz
│ ├── 0786.xyz
│ ├── 0787.xyz
│ ├── 0788.xyz
│ ├── 0789.xyz
│ ├── 0790.xyz
│ ├── 0791.xyz
│ ├── 0792.xyz
│ ├── 0793.xyz
│ ├── 0794.xyz
│ ├── 0795.xyz
│ ├── 0796.xyz
│ ├── 0797.xyz
│ ├── 0798.xyz
│ ├── 0799.xyz
│ ├── 0800.xyz
│ ├── 0801.xyz
│ ├── 0802.xyz
│ ├── 0803.xyz
│ ├── 0804.xyz
│ ├── 0805.xyz
│ ├── 0806.xyz
│ ├── 0807.xyz
│ ├── 0808.xyz
│ ├── 0809.xyz
│ ├── 0810.xyz
│ ├── 0811.xyz
│ ├── 0812.xyz
│ ├── 0813.xyz
│ ├── 0814.xyz
│ ├── 0815.xyz
│ ├── 0816.xyz
│ ├── 0817.xyz
│ ├── 0818.xyz
│ ├── 0819.xyz
│ ├── 0820.xyz
│ ├── 0821.xyz
│ ├── 0822.xyz
│ ├── 0823.xyz
│ ├── 0824.xyz
│ ├── 0825.xyz
│ ├── 0826.xyz
│ ├── 0827.xyz
│ ├── 0828.xyz
│ ├── 0829.xyz
│ ├── 0830.xyz
│ ├── 0831.xyz
│ ├── 0832.xyz
│ ├── 0833.xyz
│ ├── 0834.xyz
│ ├── 0835.xyz
│ ├── 0836.xyz
│ ├── 0837.xyz
│ ├── 0838.xyz
│ ├── 0839.xyz
│ ├── 0840.xyz
│ ├── 0841.xyz
│ ├── 0842.xyz
│ ├── 0844.xyz
│ ├── 0845.xyz
│ ├── 0846.xyz
│ ├── 0847.xyz
│ ├── 0848.xyz
│ ├── 0849.xyz
│ ├── 0850.xyz
│ ├── 0851.xyz
│ ├── 0852.xyz
│ ├── 0853.xyz
│ ├── 0854.xyz
│ ├── 0855.xyz
│ ├── 0856.xyz
│ ├── 0857.xyz
│ ├── 0858.xyz
│ ├── 0859.xyz
│ ├── 0860.xyz
│ ├── 0861.xyz
│ ├── 0862.xyz
│ ├── 0863.xyz
│ ├── 0864.xyz
│ ├── 0865.xyz
│ ├── 0866.xyz
│ ├── 0867.xyz
│ ├── 0868.xyz
│ ├── 0869.xyz
│ ├── 0870.xyz
│ ├── 0871.xyz
│ ├── 0872.xyz
│ ├── 0873.xyz
│ ├── 0874.xyz
│ ├── 0875.xyz
│ ├── 0876.xyz
│ ├── 0877.xyz
│ ├── 0878.xyz
│ ├── 0879.xyz
│ ├── 0880.xyz
│ ├── 0881.xyz
│ ├── 0882.xyz
│ ├── 0883.xyz
│ ├── 0884.xyz
│ ├── 0885.xyz
│ ├── 0887.xyz
│ ├── 0888.xyz
│ ├── 0889.xyz
│ ├── 0890.xyz
│ ├── 0891.xyz
│ ├── 0892.xyz
│ ├── 0893.xyz
│ ├── 0894.xyz
│ ├── 0895.xyz
│ ├── 0896.xyz
│ ├── 0897.xyz
│ ├── 0898.xyz
│ ├── 0899.xyz
│ ├── 0900.xyz
│ ├── 0901.xyz
│ ├── 0902.xyz
│ ├── 0903.xyz
│ ├── 0904.xyz
│ ├── 0905.xyz
│ ├── 0906.xyz
│ ├── 0907.xyz
│ ├── 0908.xyz
│ ├── 0909.xyz
│ ├── 0910.xyz
│ ├── 0911.xyz
│ ├── 0912.xyz
│ ├── 0913.xyz
│ ├── 0914.xyz
│ ├── 0915.xyz
│ ├── 0916.xyz
│ ├── 0917.xyz
│ ├── 0918.xyz
│ ├── 0919.xyz
│ ├── 0920.xyz
│ ├── 0921.xyz
│ ├── 0922.xyz
│ ├── 0923.xyz
│ ├── 0924.xyz
│ ├── 0925.xyz
│ ├── 0926.xyz
│ ├── 0927.xyz
│ ├── 0928.xyz
│ ├── 0929.xyz
│ ├── 0930.xyz
│ ├── 0931.xyz
│ ├── 0932.xyz
│ ├── 0933.xyz
│ ├── 0934.xyz
│ ├── 0935.xyz
│ ├── 0936.xyz
│ ├── 0937.xyz
│ ├── 0938.xyz
│ ├── 0939.xyz
│ ├── 0940.xyz
│ ├── 0941.xyz
│ ├── 0942.xyz
│ ├── 0943.xyz
│ ├── 0944.xyz
│ ├── 0945.xyz
│ ├── 0946.xyz
│ ├── 0947.xyz
│ ├── 0948.xyz
│ ├── 0949.xyz
│ ├── 0950.xyz
│ ├── 0951.xyz
│ ├── 0952.xyz
│ ├── 0953.xyz
│ ├── 0954.xyz
│ ├── 0955.xyz
│ ├── 0956.xyz
│ ├── 0957.xyz
│ ├── 0958.xyz
│ ├── 0959.xyz
│ ├── 0960.xyz
│ ├── 0961.xyz
│ ├── 0962.xyz
│ ├── 0963.xyz
│ ├── 0964.xyz
│ ├── 0965.xyz
│ ├── 0966.xyz
│ ├── 0967.xyz
│ ├── 0968.xyz
│ ├── 0969.xyz
│ ├── 0970.xyz
│ ├── 0971.xyz
│ ├── 0972.xyz
│ ├── 0973.xyz
│ ├── 0974.xyz
│ ├── 0975.xyz
│ ├── 0976.xyz
│ ├── 0977.xyz
│ ├── 0978.xyz
│ ├── 0979.xyz
│ ├── 0980.xyz
│ ├── 0981.xyz
│ ├── 0982.xyz
│ ├── 0983.xyz
│ ├── 0984.xyz
│ ├── 0985.xyz
│ ├── 0986.xyz
│ ├── 0987.xyz
│ ├── 0988.xyz
│ ├── 0989.xyz
│ ├── 0990.xyz
│ ├── 0991.xyz
│ ├── 0992.xyz
│ ├── 0993.xyz
│ ├── 0994.xyz
│ ├── 0995.xyz
│ ├── 0996.xyz
│ ├── 0997.xyz
│ ├── 0998.xyz
│ ├── 0999.xyz
│ ├── 1000.xyz
│ ├── 1001.xyz
│ ├── 1002.xyz
│ ├── 1003.xyz
│ ├── 1004.xyz
│ ├── 1005.xyz
│ ├── 1006.xyz
│ ├── 1007.xyz
│ ├── 1008.xyz
│ ├── 1009.xyz
│ ├── 1010.xyz
│ ├── 1011.xyz
│ ├── 1012.xyz
│ ├── 1013.xyz
│ ├── 1014.xyz
│ ├── 1015.xyz
│ ├── 1016.xyz
│ ├── 1017.xyz
│ ├── 1018.xyz
│ ├── 1019.xyz
│ ├── 1020.xyz
│ ├── 1021.xyz
│ ├── 1022.xyz
│ ├── 1023.xyz
│ ├── 1024.xyz
│ ├── 1025.xyz
│ ├── 1026.xyz
│ ├── 1027.xyz
│ ├── 1028.xyz
│ ├── 1029.xyz
│ ├── 1030.xyz
│ ├── 1031.xyz
│ ├── 1032.xyz
│ ├── 1033.xyz
│ ├── 1034.xyz
│ ├── 1035.xyz
│ ├── 1036.xyz
│ ├── 1037.xyz
│ ├── 1038.xyz
│ ├── 1039.xyz
│ ├── 1040.xyz
│ ├── 1041.xyz
│ ├── 1042.xyz
│ ├── 1043.xyz
│ ├── 1044.xyz
│ ├── 1045.xyz
│ ├── 1046.xyz
│ ├── 1047.xyz
│ ├── 1048.xyz
│ ├── 1049.xyz
│ ├── 1050.xyz
│ ├── 1051.xyz
│ ├── 1052.xyz
│ ├── 1053.xyz
│ ├── 1054.xyz
│ ├── 1055.xyz
│ ├── 1056.xyz
│ ├── 1057.xyz
│ ├── 1058.xyz
│ ├── 1059.xyz
│ ├── 1060.xyz
│ ├── 1061.xyz
│ ├── 1062.xyz
│ ├── 1063.xyz
│ ├── 1064.xyz
│ ├── 1065.xyz
│ ├── 1066.xyz
│ ├── 1067.xyz
│ ├── 1068.xyz
│ ├── 1069.xyz
│ ├── 1070.xyz
│ ├── 1071.xyz
│ ├── 1072.xyz
│ ├── 1073.xyz
│ ├── 1074.xyz
│ ├── 1075.xyz
│ ├── 1076.xyz
│ ├── 1077.xyz
│ ├── 1078.xyz
│ ├── 1079.xyz
│ ├── 1080.xyz
│ ├── 1081.xyz
│ ├── 1082.xyz
│ ├── 1083.xyz
│ ├── 1084.xyz
│ ├── 1085.xyz
│ ├── 1086.xyz
│ ├── 1087.xyz
│ ├── 1088.xyz
│ ├── 1089.xyz
│ ├── 1090.xyz
│ ├── 1091.xyz
│ ├── 1092.xyz
│ ├── 1093.xyz
│ ├── 1094.xyz
│ ├── 1095.xyz
│ ├── 1096.xyz
│ ├── 1097.xyz
│ ├── 1098.xyz
│ ├── 1099.xyz
│ ├── 1100.xyz
│ ├── 1101.xyz
│ ├── 1102.xyz
│ ├── 1103.xyz
│ ├── 1104.xyz
│ ├── 1106.xyz
│ ├── 1107.xyz
│ ├── 1108.xyz
│ ├── 1109.xyz
│ ├── 1110.xyz
│ ├── 1111.xyz
│ ├── 1112.xyz
│ ├── 1113.xyz
│ ├── 1114.xyz
│ ├── 1115.xyz
│ ├── 1116.xyz
│ ├── 1117.xyz
│ ├── 1118.xyz
│ ├── 1119.xyz
│ ├── 1120.xyz
│ ├── 1121.xyz
│ ├── 1122.xyz
│ ├── 1123.xyz
│ ├── 1124.xyz
│ ├── 1125.xyz
│ ├── 1126.xyz
│ ├── 1127.xyz
│ ├── 1128.xyz
│ ├── 1129.xyz
│ ├── 1130.xyz
│ ├── 1131.xyz
│ ├── 1132.xyz
│ ├── 1133.xyz
│ ├── 1134.xyz
│ ├── 1135.xyz
│ ├── 1136.xyz
│ ├── 1137.xyz
│ ├── 1138.xyz
│ ├── 1139.xyz
│ ├── 1140.xyz
│ ├── 1141.xyz
│ ├── 1142.xyz
│ ├── 1143.xyz
│ ├── 1144.xyz
│ ├── 1145.xyz
│ ├── 1146.xyz
│ ├── 1147.xyz
│ ├── 1148.xyz
│ ├── 1149.xyz
│ ├── 1150.xyz
│ ├── 1151.xyz
│ ├── 1152.xyz
│ ├── 1153.xyz
│ ├── 1154.xyz
│ ├── 1155.xyz
│ ├── 1156.xyz
│ ├── 1157.xyz
│ ├── 1158.xyz
│ ├── 1159.xyz
│ ├── 1160.xyz
│ ├── 1161.xyz
│ ├── 1162.xyz
│ ├── 1163.xyz
│ ├── 1164.xyz
│ ├── 1165.xyz
│ ├── 1166.xyz
│ ├── 1167.xyz
│ ├── 1168.xyz
│ ├── 1169.xyz
│ ├── 1170.xyz
│ ├── 1171.xyz
│ ├── 1172.xyz
│ ├── 1173.xyz
│ ├── 1174.xyz
│ ├── 1175.xyz
│ ├── 1176.xyz
│ ├── 1177.xyz
│ ├── 1178.xyz
│ ├── 1179.xyz
│ ├── 1180.xyz
│ ├── 1181.xyz
│ ├── 1182.xyz
│ ├── 1183.xyz
│ ├── 1184.xyz
│ ├── 1185.xyz
│ ├── 1186.xyz
│ ├── 1187.xyz
│ ├── 1188.xyz
│ ├── 1189.xyz
│ ├── 1190.xyz
│ ├── 1191.xyz
│ ├── 1192.xyz
│ ├── 1193.xyz
│ ├── 1194.xyz
│ ├── 1195.xyz
│ ├── 1196.xyz
│ ├── 1197.xyz
│ ├── 1198.xyz
│ ├── 1199.xyz
│ ├── 1200.xyz
│ ├── 1201.xyz
│ ├── 1203.xyz
│ ├── 1204.xyz
│ ├── 1205.xyz
│ ├── 1206.xyz
│ ├── 1207.xyz
│ ├── 1208.xyz
│ ├── 1209.xyz
│ ├── 1210.xyz
│ ├── 1211.xyz
│ ├── 1212.xyz
│ ├── 1213.xyz
│ ├── 1214.xyz
│ ├── 1215.xyz
│ ├── 1216.xyz
│ ├── 1217.xyz
│ ├── 1218.xyz
│ ├── 1219.xyz
│ ├── 1220.xyz
│ ├── 1221.xyz
│ ├── 1222.xyz
│ ├── 1223.xyz
│ ├── 1224.xyz
│ ├── 1225.xyz
│ ├── 1226.xyz
│ ├── 1227.xyz
│ ├── 1228.xyz
│ ├── 1229.xyz
│ ├── 1230.xyz
│ ├── 1231.xyz
│ ├── 1232.xyz
│ ├── 1233.xyz
│ ├── 1234.xyz
│ ├── 1235.xyz
│ ├── 1236.xyz
│ ├── 1237.xyz
│ ├── 1238.xyz
│ ├── 1239.xyz
│ ├── 1240.xyz
│ ├── 1241.xyz
│ ├── 1242.xyz
│ ├── 1243.xyz
│ ├── 1244.xyz
│ ├── 1245.xyz
│ ├── 1246.xyz
│ ├── 1247.xyz
│ ├── 1248.xyz
│ ├── 1249.xyz
│ ├── 1250.xyz
│ ├── 1251.xyz
│ ├── 1252.xyz
│ ├── 1253.xyz
│ ├── 1254.xyz
│ ├── 1255.xyz
│ ├── 1256.xyz
│ ├── 1257.xyz
│ ├── 1258.xyz
│ ├── 1259.xyz
│ ├── 1260.xyz
│ ├── 1261.xyz
│ ├── 1262.xyz
│ ├── 1263.xyz
│ ├── 1264.xyz
│ ├── 1265.xyz
│ ├── 1266.xyz
│ ├── 1267.xyz
│ ├── 1268.xyz
│ ├── 1269.xyz
│ ├── 1270.xyz
│ ├── 1271.xyz
│ ├── 1272.xyz
│ ├── 1273.xyz
│ ├── 1274.xyz
│ ├── 1275.xyz
│ ├── 1276.xyz
│ ├── 1277.xyz
│ ├── 1278.xyz
│ ├── 1279.xyz
│ ├── 1280.xyz
│ ├── 1281.xyz
│ ├── 1282.xyz
│ ├── 1283.xyz
│ ├── 1284.xyz
│ ├── 1285.xyz
│ ├── 1286.xyz
│ ├── 1287.xyz
│ ├── 1288.xyz
│ ├── 1289.xyz
│ ├── 1290.xyz
│ ├── 1291.xyz
│ ├── 1292.xyz
│ ├── 1293.xyz
│ ├── 1294.xyz
│ ├── 1295.xyz
│ ├── 1296.xyz
│ ├── 1297.xyz
│ ├── 1298.xyz
│ ├── 1299.xyz
│ ├── 1300.xyz
│ ├── 1301.xyz
│ ├── 1302.xyz
│ ├── 1303.xyz
│ ├── 1304.xyz
│ ├── 1305.xyz
│ ├── 1306.xyz
│ ├── 1307.xyz
│ ├── 1308.xyz
│ ├── 1309.xyz
│ ├── 1310.xyz
│ ├── 1311.xyz
│ ├── 1312.xyz
│ ├── 1313.xyz
│ ├── 1314.xyz
│ ├── 1315.xyz
│ ├── 1316.xyz
│ ├── 1317.xyz
│ ├── 1318.xyz
│ ├── 1319.xyz
│ ├── 1320.xyz
│ ├── 1321.xyz
│ ├── 1323.xyz
│ ├── 1324.xyz
│ ├── 1325.xyz
│ ├── 1326.xyz
│ ├── 1327.xyz
│ ├── 1328.xyz
│ ├── 1329.xyz
│ ├── 1330.xyz
│ ├── 1331.xyz
│ ├── 1332.xyz
│ ├── 1333.xyz
│ ├── 1334.xyz
│ ├── 1335.xyz
│ ├── 1336.xyz
│ ├── 1337.xyz
│ ├── 1338.xyz
│ ├── 1339.xyz
│ ├── 1340.xyz
│ ├── 1341.xyz
│ ├── 1342.xyz
│ ├── 1343.xyz
│ ├── 1344.xyz
│ ├── 1345.xyz
│ ├── 1346.xyz
│ ├── 1347.xyz
│ ├── 1348.xyz
│ ├── 1349.xyz
│ ├── 1350.xyz
│ ├── 1351.xyz
│ ├── 1352.xyz
│ ├── 1353.xyz
│ ├── 1354.xyz
│ ├── 1355.xyz
│ ├── 1356.xyz
│ ├── 1357.xyz
│ ├── 1358.xyz
│ ├── 1359.xyz
│ ├── 1360.xyz
│ ├── 1361.xyz
│ ├── 1362.xyz
│ ├── 1363.xyz
│ ├── 1364.xyz
│ ├── 1365.xyz
│ ├── 1366.xyz
│ ├── 1367.xyz
│ ├── 1368.xyz
│ ├── 1369.xyz
│ ├── 1370.xyz
│ ├── 1371.xyz
│ ├── 1372.xyz
│ ├── 1373.xyz
│ ├── 1374.xyz
│ ├── 1375.xyz
│ ├── 1376.xyz
│ ├── 1377.xyz
│ ├── 1378.xyz
│ ├── 1379.xyz
│ ├── 1380.xyz
│ ├── 1382.xyz
│ ├── 1383.xyz
│ ├── 1384.xyz
│ ├── 1385.xyz
│ ├── 1386.xyz
│ ├── 1387.xyz
│ ├── 1388.xyz
│ ├── 1389.xyz
│ ├── 1390.xyz
│ ├── 1391.xyz
│ ├── 1392.xyz
│ ├── 1393.xyz
│ ├── 1394.xyz
│ ├── 1395.xyz
│ ├── 1396.xyz
│ ├── 1397.xyz
│ ├── 1399.xyz
│ ├── 1400.xyz
│ ├── 1401.xyz
│ ├── 1402.xyz
│ ├── 1403.xyz
│ ├── 1404.xyz
│ ├── 1405.xyz
│ ├── 1406.xyz
│ ├── 1407.xyz
│ ├── 1408.xyz
│ ├── 1409.xyz
│ ├── 1410.xyz
│ ├── 1411.xyz
│ ├── 1412.xyz
│ ├── 1413.xyz
│ ├── 1414.xyz
│ ├── 1415.xyz
│ ├── 1416.xyz
│ ├── 1417.xyz
│ ├── 1418.xyz
│ ├── 1419.xyz
│ ├── 1420.xyz
│ ├── 1421.xyz
│ ├── 1422.xyz
│ ├── 1423.xyz
│ ├── 1424.xyz
│ ├── 1425.xyz
│ ├── 1426.xyz
│ ├── 1427.xyz
│ ├── 1428.xyz
│ ├── 1429.xyz
│ ├── 1430.xyz
│ ├── 1431.xyz
│ ├── 1432.xyz
│ ├── 1433.xyz
│ ├── 1434.xyz
│ ├── 1435.xyz
│ ├── 1436.xyz
│ ├── 1437.xyz
│ ├── 1438.xyz
│ ├── 1439.xyz
│ ├── 1440.xyz
│ ├── 1441.xyz
│ ├── 1442.xyz
│ ├── 1443.xyz
│ ├── 1444.xyz
│ ├── 1445.xyz
│ ├── 1446.xyz
│ ├── 1447.xyz
│ ├── 1448.xyz
│ ├── 1449.xyz
│ ├── 1450.xyz
│ ├── 1451.xyz
│ ├── 1452.xyz
│ ├── 1453.xyz
│ ├── 1454.xyz
│ ├── 1455.xyz
│ ├── 1456.xyz
│ ├── 1457.xyz
│ ├── 1458.xyz
│ ├── 1459.xyz
│ ├── 1460.xyz
│ ├── 1461.xyz
│ ├── 1462.xyz
│ ├── 1463.xyz
│ ├── 1464.xyz
│ ├── 1465.xyz
│ ├── 1466.xyz
│ ├── 1467.xyz
│ ├── 1468.xyz
│ ├── 1469.xyz
│ ├── 1471.xyz
│ ├── 1472.xyz
│ ├── 1473.xyz
│ ├── 1474.xyz
│ ├── 1475.xyz
│ ├── 1476.xyz
│ ├── 1477.xyz
│ ├── 1478.xyz
│ ├── 1479.xyz
│ ├── 1480.xyz
│ ├── 1481.xyz
│ ├── 1482.xyz
│ ├── 1483.xyz
│ ├── 1484.xyz
│ ├── 1485.xyz
│ ├── 1486.xyz
│ ├── 1487.xyz
│ ├── 1488.xyz
│ ├── 1489.xyz
│ ├── 1490.xyz
│ ├── 1491.xyz
│ ├── 1492.xyz
│ ├── 1494.xyz
│ ├── 1495.xyz
│ ├── 1496.xyz
│ ├── 1497.xyz
│ ├── 1498.xyz
│ ├── 1499.xyz
│ ├── 1500.xyz
│ ├── 1501.xyz
│ ├── 1502.xyz
│ ├── 1503.xyz
│ ├── 1504.xyz
│ ├── 1505.xyz
│ ├── 1506.xyz
│ ├── 1507.xyz
│ ├── 1508.xyz
│ ├── 1509.xyz
│ ├── 1510.xyz
│ ├── 1511.xyz
│ ├── 1513.xyz
│ ├── 1514.xyz
│ ├── 1515.xyz
│ ├── 1516.xyz
│ ├── 1517.xyz
│ ├── 1518.xyz
│ ├── 1519.xyz
│ ├── 1520.xyz
│ ├── 1521.xyz
│ ├── 1522.xyz
│ ├── 1523.xyz
│ ├── 1524.xyz
│ ├── 1525.xyz
│ ├── 1527.xyz
│ ├── 1528.xyz
│ ├── 1529.xyz
│ ├── 1530.xyz
│ ├── 1531.xyz
│ ├── 1532.xyz
│ ├── 1533.xyz
│ ├── 1534.xyz
│ ├── 1535.xyz
│ ├── 1536.xyz
│ ├── 1537.xyz
│ ├── 1538.xyz
│ ├── 1539.xyz
│ ├── 1540.xyz
│ ├── 1541.xyz
│ ├── 1542.xyz
│ ├── 1543.xyz
│ ├── 1544.xyz
│ ├── 1545.xyz
│ ├── 1546.xyz
│ ├── 1547.xyz
│ ├── 1548.xyz
│ ├── 1549.xyz
│ ├── 1550.xyz
│ ├── 1551.xyz
│ ├── 1552.xyz
│ ├── 1553.xyz
│ ├── 1554.xyz
│ ├── 1555.xyz
│ ├── 1556.xyz
│ ├── 1557.xyz
│ ├── 1558.xyz
│ ├── 1559.xyz
│ ├── 1560.xyz
│ ├── 1561.xyz
│ ├── 1562.xyz
│ ├── 1563.xyz
│ ├── 1564.xyz
│ ├── 1565.xyz
│ ├── 1566.xyz
│ ├── 1567.xyz
│ ├── 1568.xyz
│ ├── 1569.xyz
│ ├── 1570.xyz
│ ├── 1571.xyz
│ ├── 1572.xyz
│ ├── 1573.xyz
│ ├── 1574.xyz
│ ├── 1575.xyz
│ ├── 1576.xyz
│ ├── 1577.xyz
│ ├── 1578.xyz
│ ├── 1579.xyz
│ ├── 1580.xyz
│ ├── 1581.xyz
│ ├── 1582.xyz
│ ├── 1583.xyz
│ ├── 1584.xyz
│ ├── 1585.xyz
│ ├── 1586.xyz
│ ├── 1587.xyz
│ ├── 1588.xyz
│ ├── 1589.xyz
│ ├── 1590.xyz
│ ├── 1591.xyz
│ ├── 1592.xyz
│ ├── 1593.xyz
│ ├── 1594.xyz
│ ├── 1595.xyz
│ ├── 1596.xyz
│ ├── 1597.xyz
│ ├── 1598.xyz
│ ├── 1599.xyz
│ ├── 1600.xyz
│ ├── 1601.xyz
│ ├── 1602.xyz
│ ├── 1603.xyz
│ ├── 1604.xyz
│ ├── 1605.xyz
│ ├── 1606.xyz
│ ├── 1607.xyz
│ ├── 1608.xyz
│ ├── 1609.xyz
│ ├── 1610.xyz
│ ├── 1611.xyz
│ ├── 1612.xyz
│ ├── 1613.xyz
│ ├── 1614.xyz
│ ├── 1615.xyz
│ ├── 1616.xyz
│ ├── 1617.xyz
│ ├── 1618.xyz
│ ├── 1619.xyz
│ ├── 1620.xyz
│ ├── 1621.xyz
│ ├── 1622.xyz
│ ├── 1623.xyz
│ ├── 1624.xyz
│ ├── 1625.xyz
│ ├── 1626.xyz
│ ├── 1627.xyz
│ ├── 1628.xyz
│ ├── 1629.xyz
│ ├── 1630.xyz
│ ├── 1631.xyz
│ ├── 1632.xyz
│ ├── 1633.xyz
│ ├── 1634.xyz
│ ├── 1635.xyz
│ ├── 1636.xyz
│ ├── 1637.xyz
│ ├── 1638.xyz
│ ├── 1639.xyz
│ ├── 1640.xyz
│ ├── 1641.xyz
│ ├── 1642.xyz
│ ├── 1643.xyz
│ ├── 1644.xyz
│ ├── 1645.xyz
│ ├── 1646.xyz
│ ├── 1647.xyz
│ ├── 1648.xyz
│ ├── 1649.xyz
│ ├── 1650.xyz
│ ├── 1651.xyz
│ ├── 1652.xyz
│ ├── 1653.xyz
│ ├── 1654.xyz
│ ├── 1655.xyz
│ ├── 1656.xyz
│ ├── 1657.xyz
│ ├── 1658.xyz
│ ├── 1659.xyz
│ ├── 1660.xyz
│ ├── 1661.xyz
│ ├── 1662.xyz
│ ├── 1663.xyz
│ ├── 1664.xyz
│ ├── 1665.xyz
│ ├── 1666.xyz
│ ├── 1667.xyz
│ ├── 1668.xyz
│ ├── 1669.xyz
│ ├── 1670.xyz
│ ├── 1671.xyz
│ ├── 1672.xyz
│ ├── 1673.xyz
│ ├── 1674.xyz
│ ├── 1675.xyz
│ ├── 1676.xyz
│ ├── 1677.xyz
│ ├── 1678.xyz
│ ├── 1679.xyz
│ ├── 1680.xyz
│ ├── 1681.xyz
│ ├── 1682.xyz
│ ├── 1683.xyz
│ ├── 1684.xyz
│ ├── 1685.xyz
│ ├── 1686.xyz
│ ├── 1687.xyz
│ ├── 1688.xyz
│ ├── 1689.xyz
│ ├── 1690.xyz
│ ├── 1691.xyz
│ ├── 1692.xyz
│ ├── 1693.xyz
│ ├── 1694.xyz
│ ├── 1695.xyz
│ ├── 1696.xyz
│ ├── 1697.xyz
│ ├── 1698.xyz
│ ├── 1700.xyz
│ ├── 1701.xyz
│ ├── 1702.xyz
│ ├── 1703.xyz
│ ├── 1704.xyz
│ ├── 1705.xyz
│ ├── 1706.xyz
│ ├── 1707.xyz
│ ├── 1708.xyz
│ ├── 1709.xyz
│ ├── 1710.xyz
│ ├── 1711.xyz
│ ├── 1712.xyz
│ ├── 1713.xyz
│ ├── 1715.xyz
│ ├── 1716.xyz
│ ├── 1717.xyz
│ ├── 1719.xyz
│ ├── 1720.xyz
│ ├── 1721.xyz
│ ├── 1722.xyz
│ ├── 1723.xyz
│ ├── 1724.xyz
│ ├── 1725.xyz
│ ├── 1726.xyz
│ ├── 1727.xyz
│ ├── 1728.xyz
│ ├── 1729.xyz
│ ├── 1730.xyz
│ ├── 1731.xyz
│ ├── 1732.xyz
│ ├── 1733.xyz
│ ├── 1734.xyz
│ ├── 1735.xyz
│ ├── 1736.xyz
│ ├── 1737.xyz
│ ├── 1738.xyz
│ ├── 1739.xyz
│ ├── 1740.xyz
│ ├── 1741.xyz
│ ├── 1742.xyz
│ ├── 1743.xyz
│ ├── 1744.xyz
│ ├── 1745.xyz
│ ├── 1746.xyz
│ ├── 1747.xyz
│ ├── 1748.xyz
│ ├── 1749.xyz
│ ├── 1750.xyz
│ ├── 1751.xyz
│ ├── 1752.xyz
│ ├── 1753.xyz
│ ├── 1754.xyz
│ ├── 1755.xyz
│ ├── 1756.xyz
│ ├── 1757.xyz
│ ├── 1758.xyz
│ ├── 1759.xyz
│ ├── 1760.xyz
│ ├── 1762.xyz
│ ├── 1763.xyz
│ ├── 1764.xyz
│ ├── 1765.xyz
│ ├── 1766.xyz
│ ├── 1767.xyz
│ ├── 1768.xyz
│ ├── 1769.xyz
│ ├── 1770.xyz
│ ├── 1771.xyz
│ ├── 1772.xyz
│ ├── 1773.xyz
│ ├── 1774.xyz
│ ├── 1775.xyz
│ ├── 1776.xyz
│ ├── 1777.xyz
│ ├── 1778.xyz
│ ├── 1779.xyz
│ ├── 1780.xyz
│ ├── 1781.xyz
│ ├── 1782.xyz
│ ├── 1783.xyz
│ ├── 1784.xyz
│ ├── 1785.xyz
│ ├── 1786.xyz
│ ├── 1787.xyz
│ ├── 1788.xyz
│ ├── 1789.xyz
│ ├── 1790.xyz
│ ├── 1791.xyz
│ ├── 1792.xyz
│ ├── 1793.xyz
│ ├── 1794.xyz
│ ├── 1795.xyz
│ ├── 1796.xyz
│ ├── 1797.xyz
│ ├── 1798.xyz
│ ├── 1799.xyz
│ ├── 1800.xyz
│ ├── 1801.xyz
│ ├── 1802.xyz
│ ├── 1803.xyz
│ ├── 1804.xyz
│ ├── 1805.xyz
│ ├── 1806.xyz
│ ├── 1807.xyz
│ ├── 1808.xyz
│ ├── 1809.xyz
│ ├── 1810.xyz
│ ├── 1811.xyz
│ ├── 1812.xyz
│ ├── 1813.xyz
│ ├── 1814.xyz
│ ├── 1815.xyz
│ ├── 1816.xyz
│ ├── 1817.xyz
│ ├── 1818.xyz
│ ├── 1819.xyz
│ ├── 1820.xyz
│ ├── 1821.xyz
│ ├── 1822.xyz
│ ├── 1823.xyz
│ ├── 1824.xyz
│ ├── 1825.xyz
│ ├── 1826.xyz
│ ├── 1827.xyz
│ ├── 1828.xyz
│ ├── 1829.xyz
│ ├── 1831.xyz
│ ├── 1832.xyz
│ ├── 1833.xyz
│ ├── 1834.xyz
│ ├── 1835.xyz
│ ├── 1836.xyz
│ ├── 1837.xyz
│ ├── 1838.xyz
│ ├── 1839.xyz
│ ├── 1840.xyz
│ ├── 1841.xyz
│ ├── 1842.xyz
│ ├── 1843.xyz
│ ├── 1844.xyz
│ ├── 1845.xyz
│ ├── 1846.xyz
│ ├── 1847.xyz
│ ├── 1848.xyz
│ ├── 1849.xyz
│ ├── 1850.xyz
│ ├── 1851.xyz
│ ├── 1852.xyz
│ ├── 1853.xyz
│ ├── 1854.xyz
│ ├── 1855.xyz
│ ├── 1856.xyz
│ ├── 1857.xyz
│ ├── 1858.xyz
│ ├── 1859.xyz
│ ├── 1860.xyz
│ ├── 1861.xyz
│ ├── 1862.xyz
│ ├── 1863.xyz
│ ├── 1864.xyz
│ ├── 1865.xyz
│ ├── 1866.xyz
│ ├── 1867.xyz
│ ├── 1868.xyz
│ ├── 1869.xyz
│ ├── 1870.xyz
│ ├── 1871.xyz
│ ├── 1872.xyz
│ ├── 1873.xyz
│ ├── 1874.xyz
│ ├── 1875.xyz
│ ├── 1876.xyz
│ ├── 1877.xyz
│ ├── 1878.xyz
│ ├── 1879.xyz
│ ├── 1880.xyz
│ ├── 1881.xyz
│ ├── 1882.xyz
│ ├── 1883.xyz
│ ├── 1884.xyz
│ ├── 1885.xyz
│ ├── 1886.xyz
│ ├── 1887.xyz
│ ├── 1888.xyz
│ ├── 1889.xyz
│ ├── 1890.xyz
│ ├── 1891.xyz
│ ├── 1892.xyz
│ ├── 1893.xyz
│ ├── 1894.xyz
│ ├── 1895.xyz
│ ├── 1896.xyz
│ ├── 1897.xyz
│ ├── 1898.xyz
│ ├── 1899.xyz
│ ├── 1900.xyz
│ ├── 1901.xyz
│ ├── 1902.xyz
│ ├── 1903.xyz
│ ├── 1904.xyz
│ ├── 1905.xyz
│ ├── 1906.xyz
│ ├── 1907.xyz
│ ├── 1908.xyz
│ ├── 1909.xyz
│ ├── 1910.xyz
│ ├── 1911.xyz
│ ├── 1912.xyz
│ ├── 1913.xyz
│ ├── 1914.xyz
│ ├── 1915.xyz
│ ├── 1916.xyz
│ ├── 1917.xyz
│ ├── 1918.xyz
│ ├── 1919.xyz
│ ├── 1920.xyz
│ ├── 1921.xyz
│ ├── 1922.xyz
│ ├── 1923.xyz
│ ├── 1924.xyz
│ ├── 1925.xyz
│ ├── 1926.xyz
│ ├── 1927.xyz
│ ├── 1928.xyz
│ ├── 1929.xyz
│ ├── 1930.xyz
│ ├── 1931.xyz
│ ├── 1932.xyz
│ ├── 1933.xyz
│ ├── 1934.xyz
│ ├── 1935.xyz
│ ├── 1936.xyz
│ ├── 1937.xyz
│ ├── 1938.xyz
│ ├── 1939.xyz
│ ├── 1940.xyz
│ ├── 1941.xyz
│ ├── 1942.xyz
│ ├── 1943.xyz
│ ├── 1944.xyz
│ ├── 1945.xyz
│ ├── 1947.xyz
│ ├── 1948.xyz
│ ├── 1949.xyz
│ ├── 1950.xyz
│ ├── 1951.xyz
│ ├── 1952.xyz
│ ├── 1953.xyz
│ ├── 1954.xyz
│ ├── 1955.xyz
│ ├── 1956.xyz
│ ├── 1957.xyz
│ ├── 1958.xyz
│ ├── 1959.xyz
│ ├── 1960.xyz
│ ├── 1961.xyz
│ ├── 1962.xyz
│ ├── 1963.xyz
│ ├── 1964.xyz
│ ├── 1965.xyz
│ ├── 1966.xyz
│ ├── 1967.xyz
│ ├── 1968.xyz
│ ├── 1969.xyz
│ ├── 1970.xyz
│ ├── 1971.xyz
│ ├── 1972.xyz
│ ├── 1973.xyz
│ ├── 1974.xyz
│ ├── 1975.xyz
│ ├── 1976.xyz
│ ├── 1977.xyz
│ ├── 1978.xyz
│ ├── 1979.xyz
│ ├── 1980.xyz
│ ├── 1981.xyz
│ ├── 1982.xyz
│ ├── 1983.xyz
│ ├── 1984.xyz
│ ├── 1985.xyz
│ ├── 1986.xyz
│ ├── 1987.xyz
│ ├── 1988.xyz
│ ├── 1989.xyz
│ ├── 1990.xyz
│ ├── 1991.xyz
│ ├── 1992.xyz
│ ├── 1993.xyz
│ ├── 1994.xyz
│ ├── 1995.xyz
│ ├── 1996.xyz
│ ├── 1997.xyz
│ ├── 1998.xyz
│ ├── 1999.xyz
│ ├── 2000.xyz
│ ├── 2001.xyz
│ ├── 2002.xyz
│ ├── 2003.xyz
│ ├── 2004.xyz
│ ├── 2005.xyz
│ ├── 2006.xyz
│ ├── 2007.xyz
│ ├── 2008.xyz
│ ├── 2009.xyz
│ ├── 2010.xyz
│ ├── 2011.xyz
│ ├── 2012.xyz
│ ├── 2013.xyz
│ ├── 2014.xyz
│ ├── 2015.xyz
│ ├── 2016.xyz
│ ├── 2017.xyz
│ ├── 2018.xyz
│ ├── 2019.xyz
│ ├── 2020.xyz
│ ├── 2021.xyz
│ ├── 2022.xyz
│ ├── 2023.xyz
│ ├── 2024.xyz
│ ├── 2025.xyz
│ ├── 2026.xyz
│ ├── 2027.xyz
│ ├── 2029.xyz
│ ├── 2030.xyz
│ ├── 2031.xyz
│ ├── 2032.xyz
│ ├── 2033.xyz
│ ├── 2034.xyz
│ ├── 2035.xyz
│ ├── 2036.xyz
│ ├── 2037.xyz
│ ├── 2038.xyz
│ ├── 2039.xyz
│ ├── 2040.xyz
│ ├── 2041.xyz
│ ├── 2042.xyz
│ ├── 2043.xyz
│ ├── 2044.xyz
│ ├── 2045.xyz
│ ├── 2046.xyz
│ ├── 2047.xyz
│ ├── 2048.xyz
│ ├── 2049.xyz
│ ├── 2050.xyz
│ ├── 2051.xyz
│ ├── 2052.xyz
│ ├── 2053.xyz
│ ├── 2054.xyz
│ ├── 2055.xyz
│ ├── 2056.xyz
│ ├── 2057.xyz
│ ├── 2058.xyz
│ ├── 2059.xyz
│ ├── 2060.xyz
│ ├── 2061.xyz
│ ├── 2062.xyz
│ ├── 2063.xyz
│ ├── 2064.xyz
│ ├── 2065.xyz
│ ├── 2066.xyz
│ ├── 2067.xyz
│ ├── 2068.xyz
│ ├── 2069.xyz
│ ├── 2070.xyz
│ ├── 2071.xyz
│ ├── 2072.xyz
│ ├── 2073.xyz
│ ├── 2074.xyz
│ ├── 2075.xyz
│ ├── 2076.xyz
│ ├── 2077.xyz
│ ├── 2078.xyz
│ ├── 2079.xyz
│ ├── 2080.xyz
│ ├── 2081.xyz
│ ├── 2082.xyz
│ ├── 2083.xyz
│ ├── 2084.xyz
│ ├── 2085.xyz
│ ├── 2086.xyz
│ ├── 2087.xyz
│ ├── 2088.xyz
│ ├── 2089.xyz
│ ├── 2090.xyz
│ ├── 2091.xyz
│ ├── 2092.xyz
│ ├── 2093.xyz
│ ├── 2094.xyz
│ ├── 2095.xyz
│ ├── 2096.xyz
│ ├── 2097.xyz
│ ├── 2098.xyz
│ ├── 2099.xyz
│ ├── 2100.xyz
│ ├── 2101.xyz
│ ├── 2102.xyz
│ ├── 2103.xyz
│ ├── 2104.xyz
│ ├── 2105.xyz
│ ├── 2106.xyz
│ ├── 2107.xyz
│ ├── 2108.xyz
│ ├── 2109.xyz
│ ├── 2110.xyz
│ ├── 2111.xyz
│ ├── 2112.xyz
│ ├── 2113.xyz
│ ├── 2114.xyz
│ ├── 2115.xyz
│ ├── 2116.xyz
│ ├── 2117.xyz
│ ├── 2118.xyz
│ ├── 2119.xyz
│ ├── 2120.xyz
│ ├── 2121.xyz
│ ├── 2122.xyz
│ ├── 2123.xyz
│ ├── 2124.xyz
│ ├── 2125.xyz
│ ├── 2126.xyz
│ ├── 2127.xyz
│ ├── 2129.xyz
│ ├── 2130.xyz
│ ├── 2131.xyz
│ ├── 2132.xyz
│ ├── 2133.xyz
│ ├── 2134.xyz
│ ├── 2135.xyz
│ ├── 2136.xyz
│ ├── 2137.xyz
│ ├── 2138.xyz
│ ├── 2139.xyz
│ ├── 2140.xyz
│ ├── 2141.xyz
│ ├── 2142.xyz
│ ├── 2143.xyz
│ ├── 2144.xyz
│ ├── 2145.xyz
│ ├── 2146.xyz
│ ├── 2147.xyz
│ ├── 2148.xyz
│ ├── 2149.xyz
│ ├── 2150.xyz
│ ├── 2151.xyz
│ ├── 2152.xyz
│ ├── 2153.xyz
│ ├── 2155.xyz
│ ├── 2156.xyz
│ ├── 2157.xyz
│ ├── 2158.xyz
│ ├── 2159.xyz
│ ├── 2160.xyz
│ ├── 2161.xyz
│ ├── 2162.xyz
│ ├── 2163.xyz
│ ├── 2164.xyz
│ ├── 2165.xyz
│ ├── 2166.xyz
│ ├── 2167.xyz
│ ├── 2168.xyz
│ ├── 2169.xyz
│ ├── 2170.xyz
│ ├── 2171.xyz
│ ├── 2172.xyz
│ ├── 2173.xyz
│ ├── 2174.xyz
│ ├── 2175.xyz
│ ├── 2176.xyz
│ ├── 2177.xyz
│ ├── 2178.xyz
│ ├── 2179.xyz
│ ├── 2180.xyz
│ ├── 2181.xyz
│ ├── 2182.xyz
│ ├── 2183.xyz
│ ├── 2184.xyz
│ ├── 2185.xyz
│ ├── 2186.xyz
│ ├── 2187.xyz
│ ├── 2188.xyz
│ ├── 2189.xyz
│ ├── 2190.xyz
│ ├── 2191.xyz
│ ├── 2192.xyz
│ ├── 2193.xyz
│ ├── 2194.xyz
│ ├── 2195.xyz
│ ├── 2196.xyz
│ ├── 2197.xyz
│ ├── 2198.xyz
│ ├── 2199.xyz
│ ├── 2200.xyz
│ ├── 2201.xyz
│ ├── 2202.xyz
│ ├── 2203.xyz
│ ├── 2204.xyz
│ ├── 2205.xyz
│ ├── 2206.xyz
│ ├── 2207.xyz
│ ├── 2208.xyz
│ ├── 2209.xyz
│ ├── 2210.xyz
│ ├── 2211.xyz
│ ├── 2212.xyz
│ ├── 2213.xyz
│ ├── 2214.xyz
│ ├── 2215.xyz
│ ├── 2216.xyz
│ ├── 2217.xyz
│ ├── 2218.xyz
│ ├── 2219.xyz
│ ├── 2220.xyz
│ ├── 2221.xyz
│ ├── 2222.xyz
│ ├── 2223.xyz
│ ├── 2224.xyz
│ ├── 2225.xyz
│ ├── 2226.xyz
│ ├── 2227.xyz
│ ├── 2228.xyz
│ ├── 2229.xyz
│ ├── 2230.xyz
│ ├── 2231.xyz
│ ├── 2232.xyz
│ ├── 2233.xyz
│ ├── 2234.xyz
│ ├── 2235.xyz
│ ├── 2236.xyz
│ ├── 2237.xyz
│ ├── 2238.xyz
│ ├── 2239.xyz
│ ├── 2240.xyz
│ ├── 2241.xyz
│ ├── 2242.xyz
│ ├── 2243.xyz
│ ├── 2244.xyz
│ ├── 2245.xyz
│ ├── 2246.xyz
│ ├── 2247.xyz
│ ├── 2248.xyz
│ ├── 2249.xyz
│ ├── 2250.xyz
│ ├── 2251.xyz
│ ├── 2252.xyz
│ ├── 2253.xyz
│ ├── 2254.xyz
│ ├── 2255.xyz
│ ├── 2256.xyz
│ ├── 2257.xyz
│ ├── 2258.xyz
│ ├── 2259.xyz
│ ├── 2260.xyz
│ ├── 2261.xyz
│ ├── 2262.xyz
│ ├── 2263.xyz
│ ├── 2264.xyz
│ ├── 2265.xyz
│ ├── 2266.xyz
│ ├── 2267.xyz
│ ├── 2268.xyz
│ ├── 2269.xyz
│ ├── 2270.xyz
│ ├── 2271.xyz
│ ├── 2272.xyz
│ ├── 2273.xyz
│ ├── 2274.xyz
│ ├── 2275.xyz
│ ├── 2276.xyz
│ ├── 2277.xyz
│ ├── 2278.xyz
│ ├── 2279.xyz
│ ├── 2280.xyz
│ ├── 2281.xyz
│ ├── 2282.xyz
│ ├── 2283.xyz
│ ├── 2284.xyz
│ ├── 2285.xyz
│ ├── 2286.xyz
│ ├── 2287.xyz
│ ├── 2288.xyz
│ ├── 2289.xyz
│ ├── 2290.xyz
│ ├── 2291.xyz
│ ├── 2292.xyz
│ ├── 2293.xyz
│ ├── 2294.xyz
│ ├── 2295.xyz
│ ├── 2296.xyz
│ ├── 2297.xyz
│ ├── 2298.xyz
│ ├── 2299.xyz
│ ├── 2300.xyz
│ ├── 2301.xyz
│ ├── 2302.xyz
│ ├── 2303.xyz
│ ├── 2304.xyz
│ ├── 2305.xyz
│ ├── 2306.xyz
│ ├── 2307.xyz
│ ├── 2308.xyz
│ ├── 2309.xyz
│ ├── 2310.xyz
│ ├── 2311.xyz
│ ├── 2312.xyz
│ ├── 2313.xyz
│ ├── 2314.xyz
│ ├── 2315.xyz
│ ├── 2316.xyz
│ ├── 2317.xyz
│ ├── 2318.xyz
│ ├── 2319.xyz
│ ├── 2320.xyz
│ ├── 2321.xyz
│ ├── 2322.xyz
│ ├── 2323.xyz
│ ├── 2324.xyz
│ ├── 2325.xyz
│ ├── 2326.xyz
│ ├── 2327.xyz
│ ├── 2328.xyz
│ ├── 2329.xyz
│ ├── 2330.xyz
│ ├── 2331.xyz
│ ├── 2332.xyz
│ ├── 2333.xyz
│ ├── 2334.xyz
│ ├── 2335.xyz
│ ├── 2336.xyz
│ ├── 2337.xyz
│ ├── 2338.xyz
│ ├── 2339.xyz
│ ├── 2340.xyz
│ ├── 2341.xyz
│ ├── 2342.xyz
│ ├── 2343.xyz
│ ├── 2344.xyz
│ ├── 2345.xyz
│ ├── 2346.xyz
│ ├── 2347.xyz
│ ├── 2348.xyz
│ ├── 2349.xyz
│ ├── 2350.xyz
│ ├── 2351.xyz
│ ├── 2352.xyz
│ ├── 2353.xyz
│ ├── 2354.xyz
│ ├── 2355.xyz
│ ├── 2356.xyz
│ ├── 2357.xyz
│ ├── 2358.xyz
│ ├── 2359.xyz
│ ├── 2360.xyz
│ ├── 2361.xyz
│ ├── 2362.xyz
│ ├── 2363.xyz
│ ├── 2364.xyz
│ ├── 2365.xyz
│ ├── 2366.xyz
│ ├── 2367.xyz
│ ├── 2368.xyz
│ ├── 2369.xyz
│ ├── 2370.xyz
│ ├── 2371.xyz
│ ├── 2372.xyz
│ ├── 2373.xyz
│ ├── 2374.xyz
│ ├── 2375.xyz
│ ├── 2376.xyz
│ ├── 2377.xyz
│ ├── 2378.xyz
│ ├── 2379.xyz
│ ├── 2380.xyz
│ ├── 2381.xyz
│ ├── 2382.xyz
│ ├── 2383.xyz
│ ├── 2384.xyz
│ ├── 2385.xyz
│ ├── 2386.xyz
│ ├── 2387.xyz
│ ├── 2388.xyz
│ ├── 2389.xyz
│ ├── 2390.xyz
│ ├── 2391.xyz
│ ├── 2392.xyz
│ ├── 2393.xyz
│ ├── 2395.xyz
│ ├── 2396.xyz
│ ├── 2397.xyz
│ ├── 2398.xyz
│ ├── 2399.xyz
│ ├── 2400.xyz
│ ├── 2401.xyz
│ ├── 2402.xyz
│ ├── 2403.xyz
│ ├── 2404.xyz
│ ├── 2405.xyz
│ ├── 2406.xyz
│ ├── 2407.xyz
│ ├── 2408.xyz
│ ├── 2409.xyz
│ ├── 2410.xyz
│ ├── 2411.xyz
│ ├── 2412.xyz
│ ├── 2413.xyz
│ ├── 2414.xyz
│ ├── 2415.xyz
│ ├── 2416.xyz
│ ├── 2417.xyz
│ ├── 2418.xyz
│ ├── 2419.xyz
│ ├── 2420.xyz
│ ├── 2421.xyz
│ ├── 2422.xyz
│ ├── 2423.xyz
│ ├── 2424.xyz
│ ├── 2425.xyz
│ ├── 2426.xyz
│ ├── 2427.xyz
│ ├── 2428.xyz
│ ├── 2429.xyz
│ ├── 2430.xyz
│ ├── 2431.xyz
│ ├── 2432.xyz
│ ├── 2433.xyz
│ ├── 2434.xyz
│ ├── 2435.xyz
│ ├── 2436.xyz
│ ├── 2437.xyz
│ ├── 2438.xyz
│ ├── 2439.xyz
│ ├── 2440.xyz
│ ├── 2441.xyz
│ ├── 2442.xyz
│ ├── 2443.xyz
│ ├── 2444.xyz
│ ├── 2445.xyz
│ ├── 2446.xyz
│ ├── 2447.xyz
│ ├── 2448.xyz
│ ├── 2449.xyz
│ ├── 2450.xyz
│ ├── 2451.xyz
│ ├── 2452.xyz
│ ├── 2453.xyz
│ ├── 2454.xyz
│ ├── 2455.xyz
│ ├── 2456.xyz
│ ├── 2457.xyz
│ ├── 2458.xyz
│ ├── 2459.xyz
│ ├── 2460.xyz
│ ├── 2461.xyz
│ ├── 2462.xyz
│ ├── 2463.xyz
│ ├── 2464.xyz
│ ├── 2465.xyz
│ ├── 2466.xyz
│ ├── 2467.xyz
│ ├── 2468.xyz
│ ├── 2469.xyz
│ ├── 2470.xyz
│ ├── 2471.xyz
│ ├── 2472.xyz
│ ├── 2473.xyz
│ ├── 2474.xyz
│ ├── 2475.xyz
│ ├── 2476.xyz
│ ├── 2477.xyz
│ ├── 2478.xyz
│ ├── 2479.xyz
│ ├── 2480.xyz
│ ├── 2481.xyz
│ ├── 2482.xyz
│ ├── 2483.xyz
│ ├── 2484.xyz
│ ├── 2485.xyz
│ ├── 2486.xyz
│ ├── 2487.xyz
│ ├── 2488.xyz
│ ├── 2489.xyz
│ ├── 2490.xyz
│ ├── 2491.xyz
│ ├── 2492.xyz
│ ├── 2493.xyz
│ ├── 2494.xyz
│ ├── 2495.xyz
│ ├── 2496.xyz
│ ├── 2497.xyz
│ ├── 2498.xyz
│ ├── 2499.xyz
│ ├── 2500.xyz
│ ├── 2501.xyz
│ ├── 2502.xyz
│ ├── 2503.xyz
│ ├── 2504.xyz
│ ├── 2505.xyz
│ ├── 2506.xyz
│ ├── 2507.xyz
│ ├── 2508.xyz
│ ├── 2509.xyz
│ ├── 2510.xyz
│ ├── 2511.xyz
│ ├── 2512.xyz
│ ├── 2513.xyz
│ ├── 2514.xyz
│ ├── 2515.xyz
│ ├── 2516.xyz
│ ├── 2517.xyz
│ ├── 2518.xyz
│ ├── 2519.xyz
│ ├── 2520.xyz
│ ├── 2521.xyz
│ ├── 2522.xyz
│ ├── 2523.xyz
│ ├── 2524.xyz
│ ├── 2525.xyz
│ ├── 2526.xyz
│ ├── 2527.xyz
│ ├── 2528.xyz
│ ├── 2529.xyz
│ ├── 2530.xyz
│ ├── 2531.xyz
│ ├── 2532.xyz
│ ├── 2533.xyz
│ ├── 2534.xyz
│ ├── 2535.xyz
│ ├── 2536.xyz
│ ├── 2537.xyz
│ ├── 2538.xyz
│ ├── 2539.xyz
│ ├── 2540.xyz
│ ├── 2541.xyz
│ ├── 2542.xyz
│ ├── 2543.xyz
│ ├── 2544.xyz
│ ├── 2545.xyz
│ ├── 2546.xyz
│ ├── 2547.xyz
│ ├── 2548.xyz
│ ├── 2549.xyz
│ ├── 2550.xyz
│ ├── 2551.xyz
│ ├── 2552.xyz
│ ├── 2553.xyz
│ ├── 2554.xyz
│ ├── 2555.xyz
│ ├── 2556.xyz
│ ├── 2557.xyz
│ ├── 2558.xyz
│ ├── 2559.xyz
│ ├── 2560.xyz
│ ├── 2561.xyz
│ ├── 2562.xyz
│ ├── 2563.xyz
│ ├── 2564.xyz
│ ├── 2565.xyz
│ ├── 2566.xyz
│ ├── 2567.xyz
│ ├── 2568.xyz
│ ├── 2569.xyz
│ ├── 2570.xyz
│ ├── 2571.xyz
│ ├── 2572.xyz
│ ├── 2573.xyz
│ ├── 2574.xyz
│ ├── 2575.xyz
│ ├── 2576.xyz
│ ├── 2577.xyz
│ ├── 2578.xyz
│ ├── 2579.xyz
│ ├── 2580.xyz
│ ├── 2581.xyz
│ ├── 2582.xyz
│ ├── 2583.xyz
│ ├── 2584.xyz
│ ├── 2585.xyz
│ ├── 2586.xyz
│ ├── 2587.xyz
│ ├── 2588.xyz
│ ├── 2589.xyz
│ ├── 2590.xyz
│ ├── 2591.xyz
│ ├── 2592.xyz
│ ├── 2593.xyz
│ ├── 2594.xyz
│ ├── 2595.xyz
│ ├── 2596.xyz
│ ├── 2597.xyz
│ ├── 2598.xyz
│ ├── 2599.xyz
│ ├── 2600.xyz
│ ├── 2601.xyz
│ ├── 2602.xyz
│ ├── 2603.xyz
│ ├── 2604.xyz
│ ├── 2605.xyz
│ ├── 2606.xyz
│ ├── 2607.xyz
│ ├── 2608.xyz
│ ├── 2609.xyz
│ ├── 2610.xyz
│ ├── 2611.xyz
│ ├── 2612.xyz
│ ├── 2613.xyz
│ ├── 2614.xyz
│ ├── 2615.xyz
│ ├── 2616.xyz
│ ├── 2617.xyz
│ ├── 2618.xyz
│ ├── 2619.xyz
│ ├── 2620.xyz
│ ├── 2621.xyz
│ ├── 2622.xyz
│ ├── 2623.xyz
│ ├── 2624.xyz
│ ├── 2625.xyz
│ ├── 2626.xyz
│ ├── 2627.xyz
│ ├── 2628.xyz
│ ├── 2629.xyz
│ ├── 2630.xyz
│ ├── 2631.xyz
│ ├── 2632.xyz
│ ├── 2633.xyz
│ ├── 2634.xyz
│ ├── 2635.xyz
│ ├── 2636.xyz
│ ├── 2637.xyz
│ ├── 2638.xyz
│ ├── 2639.xyz
│ ├── 2640.xyz
│ ├── 2641.xyz
│ ├── 2642.xyz
│ ├── 2644.xyz
│ ├── 2645.xyz
│ ├── 2646.xyz
│ ├── 2647.xyz
│ ├── 2648.xyz
│ ├── 2649.xyz
│ ├── 2650.xyz
│ ├── 2651.xyz
│ ├── 2652.xyz
│ ├── 2653.xyz
│ ├── 2654.xyz
│ ├── 2655.xyz
│ ├── 2656.xyz
│ ├── 2657.xyz
│ ├── 2658.xyz
│ ├── 2659.xyz
│ ├── 2660.xyz
│ ├── 2661.xyz
│ ├── 2662.xyz
│ ├── 2663.xyz
│ ├── 2664.xyz
│ ├── 2665.xyz
│ ├── 2666.xyz
│ ├── 2667.xyz
│ ├── 2668.xyz
│ ├── 2669.xyz
│ ├── 2670.xyz
│ ├── 2671.xyz
│ ├── 2672.xyz
│ ├── 2673.xyz
│ ├── 2674.xyz
│ ├── 2675.xyz
│ ├── 2676.xyz
│ ├── 2677.xyz
│ ├── 2678.xyz
│ ├── 2679.xyz
│ ├── 2680.xyz
│ ├── 2681.xyz
│ ├── 2682.xyz
│ ├── 2683.xyz
│ ├── 2684.xyz
│ ├── 2685.xyz
│ ├── 2686.xyz
│ ├── 2687.xyz
│ ├── 2688.xyz
│ ├── 2689.xyz
│ ├── 2690.xyz
│ ├── 2691.xyz
│ ├── 2692.xyz
│ ├── 2693.xyz
│ ├── 2694.xyz
│ ├── 2695.xyz
│ ├── 2696.xyz
│ ├── 2697.xyz
│ ├── 2698.xyz
│ ├── 2699.xyz
│ ├── 2700.xyz
│ ├── 2701.xyz
│ ├── 2702.xyz
│ ├── 2703.xyz
│ ├── 2704.xyz
│ ├── 2705.xyz
│ ├── 2706.xyz
│ ├── 2707.xyz
│ ├── 2708.xyz
│ ├── 2709.xyz
│ ├── 2710.xyz
│ ├── 2711.xyz
│ ├── 2712.xyz
│ ├── 2713.xyz
│ ├── 2714.xyz
│ ├── 2715.xyz
│ ├── 2716.xyz
│ ├── 2717.xyz
│ ├── 2718.xyz
│ ├── 2719.xyz
│ ├── 2720.xyz
│ ├── 2721.xyz
│ ├── 2722.xyz
│ ├── 2723.xyz
│ ├── 2724.xyz
│ ├── 2725.xyz
│ ├── 2726.xyz
│ ├── 2727.xyz
│ ├── 2728.xyz
│ ├── 2729.xyz
│ ├── 2730.xyz
│ ├── 2731.xyz
│ ├── 2732.xyz
│ ├── 2733.xyz
│ ├── 2734.xyz
│ ├── 2735.xyz
│ ├── 2736.xyz
│ ├── 2737.xyz
│ ├── 2738.xyz
│ ├── 2739.xyz
│ ├── 2740.xyz
│ ├── 2741.xyz
│ ├── 2742.xyz
│ ├── 2743.xyz
│ ├── 2744.xyz
│ ├── 2745.xyz
│ ├── 2746.xyz
│ ├── 2747.xyz
│ ├── 2748.xyz
│ ├── 2749.xyz
│ ├── 2750.xyz
│ ├── 2751.xyz
│ ├── 2752.xyz
│ ├── 2753.xyz
│ ├── 2754.xyz
│ ├── 2755.xyz
│ ├── 2756.xyz
│ ├── 2757.xyz
│ ├── 2758.xyz
│ ├── 2759.xyz
│ ├── 2760.xyz
│ ├── 2761.xyz
│ ├── 2762.xyz
│ ├── 2763.xyz
│ ├── 2764.xyz
│ ├── 2765.xyz
│ ├── 2766.xyz
│ ├── 2767.xyz
│ ├── 2768.xyz
│ ├── 2769.xyz
│ ├── 2770.xyz
│ ├── 2771.xyz
│ ├── 2772.xyz
│ ├── 2773.xyz
│ ├── 2774.xyz
│ ├── 2775.xyz
│ ├── 2776.xyz
│ ├── 2777.xyz
│ ├── 2778.xyz
│ ├── 2779.xyz
│ ├── 2780.xyz
│ ├── 2781.xyz
│ ├── 2782.xyz
│ ├── 2783.xyz
│ ├── 2784.xyz
│ ├── 2785.xyz
│ ├── 2786.xyz
│ ├── 2787.xyz
│ ├── 2788.xyz
│ ├── 2789.xyz
│ ├── 2790.xyz
│ ├── 2791.xyz
│ ├── 2792.xyz
│ ├── 2793.xyz
│ ├── 2794.xyz
│ ├── 2795.xyz
│ ├── 2796.xyz
│ ├── 2797.xyz
│ ├── 2798.xyz
│ ├── 2799.xyz
│ ├── 2800.xyz
│ ├── 2801.xyz
│ ├── 2802.xyz
│ ├── 2803.xyz
│ ├── 2804.xyz
│ ├── 2805.xyz
│ ├── 2806.xyz
│ ├── 2807.xyz
│ ├── 2808.xyz
│ ├── 2809.xyz
│ ├── 2810.xyz
│ ├── 2811.xyz
│ ├── 2812.xyz
│ ├── 2813.xyz
│ ├── 2814.xyz
│ ├── 2815.xyz
│ ├── 2816.xyz
│ ├── 2817.xyz
│ ├── 2818.xyz
│ ├── 2819.xyz
│ ├── 2820.xyz
│ ├── 2821.xyz
│ ├── 2822.xyz
│ ├── 2823.xyz
│ ├── 2824.xyz
│ ├── 2825.xyz
│ ├── 2826.xyz
│ ├── 2827.xyz
│ ├── 2828.xyz
│ ├── 2829.xyz
│ ├── 2830.xyz
│ ├── 2831.xyz
│ ├── 2832.xyz
│ ├── 2833.xyz
│ ├── 2834.xyz
│ ├── 2835.xyz
│ ├── 2836.xyz
│ ├── 2837.xyz
│ ├── 2838.xyz
│ ├── 2839.xyz
│ ├── 2840.xyz
│ ├── 2841.xyz
│ ├── 2842.xyz
│ ├── 2843.xyz
│ ├── 2844.xyz
│ ├── 2845.xyz
│ ├── 2846.xyz
│ ├── 2848.xyz
│ ├── 2849.xyz
│ ├── 2850.xyz
│ ├── 2851.xyz
│ ├── 2852.xyz
│ ├── 2853.xyz
│ ├── 2854.xyz
│ ├── 2855.xyz
│ ├── 2856.xyz
│ ├── 2857.xyz
│ ├── 2858.xyz
│ ├── 2859.xyz
│ ├── 2860.xyz
│ ├── 2861.xyz
│ ├── 2862.xyz
│ ├── 2863.xyz
│ ├── 2864.xyz
│ ├── 2865.xyz
│ ├── 2866.xyz
│ ├── 2867.xyz
│ ├── 2868.xyz
│ ├── 2869.xyz
│ ├── 2870.xyz
│ ├── 2871.xyz
│ ├── 2872.xyz
│ ├── 2873.xyz
│ ├── 2874.xyz
│ ├── 2875.xyz
│ ├── 2876.xyz
│ ├── 2877.xyz
│ ├── 2878.xyz
│ ├── 2879.xyz
│ ├── 2880.xyz
│ ├── 2881.xyz
│ ├── 2882.xyz
│ ├── 2883.xyz
│ ├── 2884.xyz
│ ├── 2885.xyz
│ ├── 2886.xyz
│ ├── 2887.xyz
│ ├── 2888.xyz
│ ├── 2889.xyz
│ ├── 2890.xyz
│ ├── 2891.xyz
│ ├── 2892.xyz
│ ├── 2893.xyz
│ ├── 2894.xyz
│ ├── 2895.xyz
│ ├── 2896.xyz
│ ├── 2897.xyz
│ ├── 2898.xyz
│ ├── 2899.xyz
│ ├── 2900.xyz
│ ├── 2901.xyz
│ ├── 2902.xyz
│ ├── 2903.xyz
│ ├── 2904.xyz
│ ├── 2905.xyz
│ ├── 2907.xyz
│ ├── 2908.xyz
│ ├── 2909.xyz
│ ├── 2910.xyz
│ ├── 2911.xyz
│ ├── 2912.xyz
│ ├── 2913.xyz
│ ├── 2914.xyz
│ ├── 2915.xyz
│ ├── 2916.xyz
│ ├── 2917.xyz
│ ├── 2918.xyz
│ ├── 2919.xyz
│ ├── 2920.xyz
│ ├── 2921.xyz
│ ├── 2922.xyz
│ ├── 2923.xyz
│ ├── 2924.xyz
│ ├── 2925.xyz
│ ├── 2926.xyz
│ ├── 2927.xyz
│ ├── 2928.xyz
│ ├── 2929.xyz
│ ├── 2930.xyz
│ ├── 2931.xyz
│ ├── 2932.xyz
│ ├── 2933.xyz
│ ├── 2934.xyz
│ ├── 2935.xyz
│ ├── 2936.xyz
│ ├── 2937.xyz
│ ├── 2938.xyz
│ ├── 2939.xyz
│ ├── 2940.xyz
│ ├── 2941.xyz
│ ├── 2942.xyz
│ ├── 2943.xyz
│ ├── 2944.xyz
│ ├── 2945.xyz
│ ├── 2946.xyz
│ ├── 2947.xyz
│ ├── 2948.xyz
│ ├── 2949.xyz
│ ├── 2950.xyz
│ ├── 2951.xyz
│ ├── 2952.xyz
│ ├── 2953.xyz
│ ├── 2954.xyz
│ ├── 2955.xyz
│ ├── 2956.xyz
│ ├── 2957.xyz
│ ├── 2958.xyz
│ ├── 2959.xyz
│ ├── 2960.xyz
│ ├── 2961.xyz
│ ├── 2962.xyz
│ ├── 2963.xyz
│ ├── 2964.xyz
│ ├── 2965.xyz
│ ├── 2966.xyz
│ ├── 2967.xyz
│ ├── 2968.xyz
│ ├── 2969.xyz
│ ├── 2970.xyz
│ ├── 2971.xyz
│ ├── 2972.xyz
│ ├── 2973.xyz
│ ├── 2974.xyz
│ ├── 2975.xyz
│ ├── 2976.xyz
│ ├── 2977.xyz
│ ├── 2978.xyz
│ ├── 2979.xyz
│ ├── 2980.xyz
│ ├── 2981.xyz
│ ├── 2982.xyz
│ ├── 2983.xyz
│ ├── 2984.xyz
│ ├── 2985.xyz
│ ├── 2986.xyz
│ ├── 2987.xyz
│ ├── 2988.xyz
│ ├── 2989.xyz
│ ├── 2990.xyz
│ ├── 2991.xyz
│ ├── 2992.xyz
│ ├── 2993.xyz
│ ├── 2994.xyz
│ ├── 2995.xyz
│ ├── 2996.xyz
│ ├── 2997.xyz
│ ├── 2998.xyz
│ ├── 2999.xyz
│ ├── 3000.xyz
│ ├── 3001.xyz
│ ├── 3002.xyz
│ ├── 3003.xyz
│ ├── 3004.xyz
│ ├── 3005.xyz
│ ├── 3006.xyz
│ ├── 3007.xyz
│ ├── 3008.xyz
│ ├── 3009.xyz
│ ├── 3010.xyz
│ ├── 3011.xyz
│ ├── 3012.xyz
│ ├── 3013.xyz
│ ├── 3014.xyz
│ ├── 3015.xyz
│ ├── 3016.xyz
│ ├── 3017.xyz
│ ├── 3018.xyz
│ ├── 3019.xyz
│ ├── 3020.xyz
│ ├── 3021.xyz
│ ├── 3022.xyz
│ ├── 3023.xyz
│ ├── 3024.xyz
│ ├── 3025.xyz
│ ├── 3026.xyz
│ ├── 3027.xyz
│ ├── 3028.xyz
│ ├── 3029.xyz
│ ├── 3030.xyz
│ ├── 3031.xyz
│ ├── 3032.xyz
│ ├── 3033.xyz
│ ├── 3034.xyz
│ ├── 3035.xyz
│ ├── 3036.xyz
│ ├── 3037.xyz
│ ├── 3038.xyz
│ ├── 3039.xyz
│ ├── 3040.xyz
│ ├── 3041.xyz
│ ├── 3042.xyz
│ ├── 3043.xyz
│ ├── 3044.xyz
│ ├── 3045.xyz
│ ├── 3046.xyz
│ ├── 3047.xyz
│ ├── 3048.xyz
│ ├── 3049.xyz
│ ├── 3050.xyz
│ ├── 3051.xyz
│ ├── 3052.xyz
│ ├── 3053.xyz
│ ├── 3054.xyz
│ ├── 3055.xyz
│ ├── 3056.xyz
│ ├── 3057.xyz
│ ├── 3058.xyz
│ ├── 3059.xyz
│ ├── 3060.xyz
│ ├── 3061.xyz
│ ├── 3062.xyz
│ ├── 3063.xyz
│ ├── 3064.xyz
│ ├── 3065.xyz
│ ├── 3066.xyz
│ ├── 3067.xyz
│ ├── 3068.xyz
│ ├── 3069.xyz
│ ├── 3070.xyz
│ ├── 3071.xyz
│ ├── 3072.xyz
│ ├── 3073.xyz
│ ├── 3074.xyz
│ ├── 3075.xyz
│ ├── 3076.xyz
│ ├── 3077.xyz
│ ├── 3078.xyz
│ ├── 3079.xyz
│ ├── 3080.xyz
│ ├── 3081.xyz
│ ├── 3082.xyz
│ ├── 3083.xyz
│ ├── 3084.xyz
│ ├── 3085.xyz
│ ├── 3086.xyz
│ ├── 3087.xyz
│ ├── 3088.xyz
│ ├── 3089.xyz
│ ├── 3090.xyz
│ ├── 3091.xyz
│ ├── 3092.xyz
│ ├── 3093.xyz
│ ├── 3094.xyz
│ ├── 3095.xyz
│ ├── 3096.xyz
│ ├── 3097.xyz
│ ├── 3098.xyz
│ ├── 3099.xyz
│ ├── 3100.xyz
│ ├── 3101.xyz
│ ├── 3102.xyz
│ ├── 3103.xyz
│ ├── 3104.xyz
│ ├── 3105.xyz
│ ├── 3106.xyz
│ ├── 3107.xyz
│ ├── 3108.xyz
│ ├── 3109.xyz
│ ├── 3110.xyz
│ ├── 3111.xyz
│ ├── 3112.xyz
│ ├── 3113.xyz
│ ├── 3114.xyz
│ ├── 3115.xyz
│ ├── 3116.xyz
│ ├── 3117.xyz
│ ├── 3118.xyz
│ ├── 3119.xyz
│ ├── 3120.xyz
│ ├── 3121.xyz
│ ├── 3122.xyz
│ ├── 3123.xyz
│ ├── 3124.xyz
│ ├── 3125.xyz
│ ├── 3126.xyz
│ ├── 3127.xyz
│ ├── 3128.xyz
│ ├── 3129.xyz
│ ├── 3130.xyz
│ ├── 3131.xyz
│ ├── 3132.xyz
│ ├── 3133.xyz
│ ├── 3134.xyz
│ ├── 3135.xyz
│ ├── 3136.xyz
│ ├── 3137.xyz
│ ├── 3138.xyz
│ ├── 3139.xyz
│ ├── 3140.xyz
│ ├── 3141.xyz
│ ├── 3142.xyz
│ ├── 3143.xyz
│ ├── 3144.xyz
│ ├── 3145.xyz
│ ├── 3146.xyz
│ ├── 3147.xyz
│ ├── 3148.xyz
│ ├── 3149.xyz
│ ├── 3150.xyz
│ ├── 3151.xyz
│ ├── 3152.xyz
│ ├── 3153.xyz
│ ├── 3154.xyz
│ ├── 3155.xyz
│ ├── 3157.xyz
│ ├── 3158.xyz
│ ├── 3159.xyz
│ ├── 3160.xyz
│ ├── 3161.xyz
│ ├── 3162.xyz
│ ├── 3163.xyz
│ ├── 3164.xyz
│ ├── 3165.xyz
│ ├── 3166.xyz
│ ├── 3167.xyz
│ ├── 3168.xyz
│ ├── 3169.xyz
│ ├── 3170.xyz
│ ├── 3171.xyz
│ ├── 3172.xyz
│ ├── 3173.xyz
│ ├── 3174.xyz
│ ├── 3175.xyz
│ ├── 3176.xyz
│ ├── 3177.xyz
│ ├── 3178.xyz
│ ├── 3179.xyz
│ ├── 3180.xyz
│ ├── 3181.xyz
│ ├── 3182.xyz
│ ├── 3183.xyz
│ ├── 3184.xyz
│ ├── 3185.xyz
│ ├── 3186.xyz
│ ├── 3187.xyz
│ ├── 3188.xyz
│ ├── 3189.xyz
│ ├── 3190.xyz
│ ├── 3191.xyz
│ ├── 3192.xyz
│ ├── 3193.xyz
│ ├── 3194.xyz
│ ├── 3195.xyz
│ ├── 3196.xyz
│ ├── 3197.xyz
│ ├── 3198.xyz
│ ├── 3199.xyz
│ ├── 3200.xyz
│ ├── 3201.xyz
│ ├── 3202.xyz
│ ├── 3203.xyz
│ ├── 3204.xyz
│ ├── 3205.xyz
│ ├── 3206.xyz
│ ├── 3207.xyz
│ ├── 3208.xyz
│ ├── 3209.xyz
│ ├── 3210.xyz
│ ├── 3211.xyz
│ ├── 3212.xyz
│ ├── 3213.xyz
│ ├── 3214.xyz
│ ├── 3215.xyz
│ ├── 3216.xyz
│ ├── 3217.xyz
│ ├── 3218.xyz
│ ├── 3219.xyz
│ ├── 3220.xyz
│ ├── 3221.xyz
│ ├── 3222.xyz
│ ├── 3223.xyz
│ ├── 3224.xyz
│ ├── 3225.xyz
│ ├── 3226.xyz
│ ├── 3227.xyz
│ ├── 3228.xyz
│ ├── 3229.xyz
│ ├── 3230.xyz
│ ├── 3231.xyz
│ ├── 3232.xyz
│ ├── 3233.xyz
│ ├── 3234.xyz
│ ├── 3235.xyz
│ ├── 3236.xyz
│ ├── 3237.xyz
│ ├── 3238.xyz
│ ├── 3239.xyz
│ ├── 3240.xyz
│ ├── 3241.xyz
│ ├── 3242.xyz
│ ├── 3243.xyz
│ ├── 3244.xyz
│ ├── 3245.xyz
│ ├── 3246.xyz
│ ├── 3247.xyz
│ ├── 3248.xyz
│ ├── 3249.xyz
│ ├── 3250.xyz
│ ├── 3251.xyz
│ ├── 3252.xyz
│ ├── 3253.xyz
│ ├── 3254.xyz
│ ├── 3255.xyz
│ ├── 3256.xyz
│ ├── 3257.xyz
│ ├── 3258.xyz
│ ├── 3259.xyz
│ ├── 3260.xyz
│ ├── 3261.xyz
│ ├── 3262.xyz
│ ├── 3263.xyz
│ ├── 3264.xyz
│ ├── 3265.xyz
│ ├── 3266.xyz
│ ├── 3267.xyz
│ ├── 3268.xyz
│ ├── 3269.xyz
│ ├── 3270.xyz
│ ├── 3271.xyz
│ ├── 3272.xyz
│ ├── 3273.xyz
│ ├── 3274.xyz
│ ├── 3275.xyz
│ ├── 3276.xyz
│ ├── 3277.xyz
│ ├── 3278.xyz
│ ├── 3279.xyz
│ ├── 3280.xyz
│ ├── 3281.xyz
│ ├── 3282.xyz
│ ├── 3283.xyz
│ ├── 3284.xyz
│ ├── 3285.xyz
│ ├── 3286.xyz
│ ├── 3287.xyz
│ ├── 3288.xyz
│ ├── 3289.xyz
│ ├── 3290.xyz
│ ├── 3291.xyz
│ ├── 3292.xyz
│ ├── 3293.xyz
│ ├── 3294.xyz
│ ├── 3295.xyz
│ ├── 3296.xyz
│ ├── 3297.xyz
│ ├── 3298.xyz
│ ├── 3299.xyz
│ ├── 3300.xyz
│ ├── 3301.xyz
│ ├── 3302.xyz
│ ├── 3303.xyz
│ ├── 3304.xyz
│ ├── 3305.xyz
│ ├── 3306.xyz
│ ├── 3307.xyz
│ ├── 3308.xyz
│ ├── 3309.xyz
│ ├── 3310.xyz
│ ├── 3311.xyz
│ ├── 3312.xyz
│ ├── 3313.xyz
│ ├── 3314.xyz
│ ├── 3315.xyz
│ ├── 3316.xyz
│ ├── 3317.xyz
│ ├── 3318.xyz
│ ├── 3319.xyz
│ ├── 3320.xyz
│ ├── 3321.xyz
│ ├── 3322.xyz
│ ├── 3323.xyz
│ ├── 3324.xyz
│ ├── 3325.xyz
│ ├── 3326.xyz
│ ├── 3327.xyz
│ ├── 3328.xyz
│ ├── 3329.xyz
│ ├── 3330.xyz
│ ├── 3331.xyz
│ ├── 3332.xyz
│ ├── 3333.xyz
│ ├── 3334.xyz
│ ├── 3335.xyz
│ ├── 3336.xyz
│ ├── 3338.xyz
│ ├── 3339.xyz
│ ├── 3340.xyz
│ ├── 3341.xyz
│ ├── 3342.xyz
│ ├── 3343.xyz
│ ├── 3344.xyz
│ ├── 3345.xyz
│ ├── 3346.xyz
│ ├── 3347.xyz
│ ├── 3348.xyz
│ ├── 3349.xyz
│ ├── 3350.xyz
│ ├── 3351.xyz
│ ├── 3352.xyz
│ ├── 3353.xyz
│ ├── 3354.xyz
│ ├── 3355.xyz
│ ├── 3356.xyz
│ ├── 3357.xyz
│ ├── 3358.xyz
│ ├── 3359.xyz
│ ├── 3360.xyz
│ ├── 3361.xyz
│ ├── 3362.xyz
│ ├── 3363.xyz
│ ├── 3364.xyz
│ ├── 3365.xyz
│ ├── 3366.xyz
│ ├── 3367.xyz
│ ├── 3368.xyz
│ ├── 3369.xyz
│ ├── 3370.xyz
│ ├── 3371.xyz
│ ├── 3372.xyz
│ ├── 3373.xyz
│ ├── 3374.xyz
│ ├── 3375.xyz
│ ├── 3376.xyz
│ ├── 3377.xyz
│ ├── 3378.xyz
│ ├── 3379.xyz
│ ├── 3380.xyz
│ ├── 3381.xyz
│ ├── 3382.xyz
│ ├── 3383.xyz
│ ├── 3384.xyz
│ ├── 3385.xyz
│ ├── 3386.xyz
│ ├── 3387.xyz
│ ├── 3388.xyz
│ ├── 3389.xyz
│ ├── 3390.xyz
│ ├── 3391.xyz
│ ├── 3392.xyz
│ ├── 3393.xyz
│ ├── 3394.xyz
│ ├── 3395.xyz
│ ├── 3396.xyz
│ ├── 3397.xyz
│ ├── 3398.xyz
│ ├── 3399.xyz
│ ├── 3400.xyz
│ ├── 3401.xyz
│ ├── 3402.xyz
│ ├── 3403.xyz
│ ├── 3404.xyz
│ ├── 3405.xyz
│ ├── 3406.xyz
│ ├── 3407.xyz
│ ├── 3408.xyz
│ ├── 3409.xyz
│ ├── 3410.xyz
│ ├── 3411.xyz
│ ├── 3412.xyz
│ ├── 3413.xyz
│ ├── 3414.xyz
│ ├── 3415.xyz
│ ├── 3416.xyz
│ ├── 3417.xyz
│ ├── 3418.xyz
│ ├── 3419.xyz
│ ├── 3420.xyz
│ ├── 3421.xyz
│ ├── 3422.xyz
│ ├── 3423.xyz
│ ├── 3424.xyz
│ ├── 3425.xyz
│ ├── 3426.xyz
│ ├── 3427.xyz
│ ├── 3428.xyz
│ ├── 3429.xyz
│ ├── 3430.xyz
│ ├── 3431.xyz
│ ├── 3432.xyz
│ ├── 3433.xyz
│ ├── 3434.xyz
│ ├── 3435.xyz
│ ├── 3436.xyz
│ ├── 3437.xyz
│ ├── 3438.xyz
│ ├── 3439.xyz
│ ├── 3440.xyz
│ ├── 3441.xyz
│ ├── 3442.xyz
│ ├── 3443.xyz
│ ├── 3444.xyz
│ ├── 3445.xyz
│ ├── 3446.xyz
│ ├── 3447.xyz
│ ├── 3448.xyz
│ ├── 3449.xyz
│ ├── 3450.xyz
│ ├── 3451.xyz
│ ├── 3452.xyz
│ ├── 3453.xyz
│ ├── 3454.xyz
│ ├── 3455.xyz
│ ├── 3456.xyz
│ ├── 3457.xyz
│ ├── 3458.xyz
│ ├── 3459.xyz
│ ├── 3460.xyz
│ ├── 3461.xyz
│ ├── 3462.xyz
│ ├── 3463.xyz
│ ├── 3464.xyz
│ ├── 3465.xyz
│ ├── 3466.xyz
│ ├── 3467.xyz
│ ├── 3468.xyz
│ ├── 3469.xyz
│ ├── 3470.xyz
│ ├── 3471.xyz
│ ├── 3472.xyz
│ ├── 3473.xyz
│ ├── 3474.xyz
│ ├── 3475.xyz
│ ├── 3476.xyz
│ ├── 3477.xyz
│ ├── 3478.xyz
│ ├── 3479.xyz
│ ├── 3480.xyz
│ ├── 3481.xyz
│ ├── 3482.xyz
│ ├── 3483.xyz
│ ├── 3484.xyz
│ ├── 3485.xyz
│ ├── 3486.xyz
│ ├── 3487.xyz
│ ├── 3488.xyz
│ ├── 3489.xyz
│ ├── 3490.xyz
│ ├── 3491.xyz
│ ├── 3492.xyz
│ ├── 3493.xyz
│ ├── 3494.xyz
│ ├── 3495.xyz
│ ├── 3496.xyz
│ ├── 3497.xyz
│ ├── 3498.xyz
│ ├── 3499.xyz
│ ├── 3500.xyz
│ ├── 3501.xyz
│ ├── 3502.xyz
│ ├── 3503.xyz
│ ├── 3504.xyz
│ ├── 3505.xyz
│ ├── 3506.xyz
│ ├── 3507.xyz
│ ├── 3508.xyz
│ ├── 3509.xyz
│ ├── 3510.xyz
│ ├── 3511.xyz
│ ├── 3512.xyz
│ ├── 3513.xyz
│ ├── 3514.xyz
│ ├── 3515.xyz
│ ├── 3516.xyz
│ ├── 3517.xyz
│ ├── 3518.xyz
│ ├── 3519.xyz
│ ├── 3520.xyz
│ ├── 3521.xyz
│ ├── 3522.xyz
│ ├── 3523.xyz
│ ├── 3524.xyz
│ ├── 3525.xyz
│ ├── 3526.xyz
│ ├── 3527.xyz
│ ├── 3528.xyz
│ ├── 3529.xyz
│ ├── 3530.xyz
│ ├── 3531.xyz
│ ├── 3532.xyz
│ ├── 3533.xyz
│ ├── 3534.xyz
│ ├── 3535.xyz
│ ├── 3536.xyz
│ ├── 3537.xyz
│ ├── 3538.xyz
│ ├── 3539.xyz
│ ├── 3540.xyz
│ ├── 3541.xyz
│ ├── 3542.xyz
│ ├── 3543.xyz
│ ├── 3544.xyz
│ ├── 3545.xyz
│ ├── 3546.xyz
│ ├── 3547.xyz
│ ├── 3548.xyz
│ ├── 3549.xyz
│ ├── 3550.xyz
│ ├── 3551.xyz
│ ├── 3552.xyz
│ ├── 3553.xyz
│ ├── 3554.xyz
│ ├── 3555.xyz
│ ├── 3556.xyz
│ ├── 3557.xyz
│ ├── 3558.xyz
│ ├── 3559.xyz
│ ├── 3560.xyz
│ ├── 3561.xyz
│ ├── 3562.xyz
│ ├── 3563.xyz
│ ├── 3564.xyz
│ ├── 3565.xyz
│ ├── 3566.xyz
│ ├── 3567.xyz
│ ├── 3568.xyz
│ ├── 3569.xyz
│ ├── 3570.xyz
│ ├── 3571.xyz
│ ├── 3572.xyz
│ ├── 3573.xyz
│ ├── 3574.xyz
│ ├── 3575.xyz
│ ├── 3576.xyz
│ ├── 3577.xyz
│ ├── 3578.xyz
│ ├── 3579.xyz
│ ├── 3580.xyz
│ ├── 3581.xyz
│ ├── 3582.xyz
│ ├── 3583.xyz
│ ├── 3584.xyz
│ ├── 3585.xyz
│ ├── 3586.xyz
│ ├── 3587.xyz
│ ├── 3588.xyz
│ ├── 3589.xyz
│ ├── 3590.xyz
│ ├── 3591.xyz
│ ├── 3592.xyz
│ ├── 3593.xyz
│ ├── 3594.xyz
│ ├── 3595.xyz
│ ├── 3596.xyz
│ ├── 3597.xyz
│ ├── 3598.xyz
│ ├── 3599.xyz
│ ├── 3600.xyz
│ ├── 3601.xyz
│ ├── 3602.xyz
│ ├── 3603.xyz
│ ├── 3604.xyz
│ ├── 3605.xyz
│ ├── 3606.xyz
│ ├── 3607.xyz
│ ├── 3608.xyz
│ ├── 3609.xyz
│ ├── 3610.xyz
│ ├── 3611.xyz
│ ├── 3612.xyz
│ ├── 3613.xyz
│ ├── 3614.xyz
│ ├── 3615.xyz
│ ├── 3616.xyz
│ ├── 3617.xyz
│ ├── 3618.xyz
│ ├── 3619.xyz
│ ├── 3620.xyz
│ ├── 3621.xyz
│ ├── 3622.xyz
│ ├── 3623.xyz
│ ├── 3624.xyz
│ ├── 3625.xyz
│ ├── 3626.xyz
│ ├── 3627.xyz
│ ├── 3628.xyz
│ ├── 3629.xyz
│ ├── 3630.xyz
│ ├── 3631.xyz
│ ├── 3632.xyz
│ ├── 3633.xyz
│ ├── 3634.xyz
│ ├── 3635.xyz
│ ├── 3636.xyz
│ ├── 3637.xyz
│ ├── 3638.xyz
│ ├── 3639.xyz
│ ├── 3640.xyz
│ ├── 3641.xyz
│ ├── 3642.xyz
│ ├── 3643.xyz
│ ├── 3644.xyz
│ ├── 3645.xyz
│ ├── 3646.xyz
│ ├── 3647.xyz
│ ├── 3648.xyz
│ ├── 3649.xyz
│ ├── 3650.xyz
│ ├── 3651.xyz
│ ├── 3652.xyz
│ ├── 3653.xyz
│ ├── 3654.xyz
│ ├── 3655.xyz
│ ├── 3656.xyz
│ ├── 3657.xyz
│ ├── 3658.xyz
│ ├── 3659.xyz
│ ├── 3660.xyz
│ ├── 3661.xyz
│ ├── 3662.xyz
│ ├── 3663.xyz
│ ├── 3664.xyz
│ ├── 3665.xyz
│ ├── 3666.xyz
│ ├── 3667.xyz
│ ├── 3668.xyz
│ ├── 3669.xyz
│ ├── 3670.xyz
│ ├── 3671.xyz
│ ├── 3672.xyz
│ ├── 3673.xyz
│ ├── 3674.xyz
│ ├── 3675.xyz
│ ├── 3676.xyz
│ ├── 3677.xyz
│ ├── 3678.xyz
│ ├── 3679.xyz
│ ├── 3680.xyz
│ ├── 3681.xyz
│ ├── 3682.xyz
│ ├── 3683.xyz
│ ├── 3684.xyz
│ ├── 3685.xyz
│ ├── 3686.xyz
│ ├── 3687.xyz
│ ├── 3688.xyz
│ ├── 3689.xyz
│ ├── 3690.xyz
│ ├── 3691.xyz
│ ├── 3692.xyz
│ ├── 3693.xyz
│ ├── 3694.xyz
│ ├── 3696.xyz
│ ├── 3697.xyz
│ ├── 3698.xyz
│ ├── 3699.xyz
│ ├── 3700.xyz
│ ├── 3701.xyz
│ ├── 3702.xyz
│ ├── 3703.xyz
│ ├── 3704.xyz
│ ├── 3705.xyz
│ ├── 3706.xyz
│ ├── 3707.xyz
│ ├── 3708.xyz
│ ├── 3709.xyz
│ ├── 3710.xyz
│ ├── 3711.xyz
│ ├── 3712.xyz
│ ├── 3713.xyz
│ ├── 3714.xyz
│ ├── 3715.xyz
│ ├── 3716.xyz
│ ├── 3717.xyz
│ ├── 3718.xyz
│ ├── 3719.xyz
│ ├── 3720.xyz
│ ├── 3721.xyz
│ ├── 3722.xyz
│ ├── 3723.xyz
│ ├── 3724.xyz
│ ├── 3725.xyz
│ ├── 3726.xyz
│ ├── 3727.xyz
│ ├── 3728.xyz
│ ├── 3729.xyz
│ ├── 3730.xyz
│ ├── 3731.xyz
│ ├── 3732.xyz
│ ├── 3733.xyz
│ ├── 3734.xyz
│ ├── 3735.xyz
│ ├── 3736.xyz
│ ├── 3737.xyz
│ ├── 3738.xyz
│ ├── 3739.xyz
│ ├── 3740.xyz
│ ├── 3741.xyz
│ ├── 3742.xyz
│ ├── 3743.xyz
│ ├── 3744.xyz
│ ├── 3745.xyz
│ ├── 3746.xyz
│ ├── 3747.xyz
│ ├── 3748.xyz
│ ├── 3749.xyz
│ ├── 3750.xyz
│ ├── 3751.xyz
│ ├── 3752.xyz
│ ├── 3753.xyz
│ ├── 3754.xyz
│ ├── 3755.xyz
│ ├── 3756.xyz
│ ├── 3757.xyz
│ ├── 3758.xyz
│ ├── 3759.xyz
│ ├── 3760.xyz
│ ├── 3761.xyz
│ ├── 3762.xyz
│ ├── 3763.xyz
│ ├── 3764.xyz
│ ├── 3765.xyz
│ ├── 3766.xyz
│ ├── 3767.xyz
│ ├── 3768.xyz
│ ├── 3769.xyz
│ ├── 3770.xyz
│ ├── 3771.xyz
│ ├── 3772.xyz
│ ├── 3773.xyz
│ ├── 3774.xyz
│ ├── 3775.xyz
│ ├── 3776.xyz
│ ├── 3777.xyz
│ ├── 3778.xyz
│ ├── 3779.xyz
│ ├── 3780.xyz
│ ├── 3781.xyz
│ ├── 3782.xyz
│ ├── 3783.xyz
│ ├── 3784.xyz
│ ├── 3785.xyz
│ ├── 3786.xyz
│ ├── 3787.xyz
│ ├── 3788.xyz
│ ├── 3789.xyz
│ ├── 3790.xyz
│ ├── 3791.xyz
│ ├── 3792.xyz
│ ├── 3793.xyz
│ ├── 3794.xyz
│ ├── 3795.xyz
│ ├── 3796.xyz
│ ├── 3797.xyz
│ ├── 3798.xyz
│ ├── 3799.xyz
│ ├── 3800.xyz
│ ├── 3801.xyz
│ ├── 3802.xyz
│ ├── 3803.xyz
│ ├── 3804.xyz
│ ├── 3805.xyz
│ ├── 3806.xyz
│ ├── 3807.xyz
│ ├── 3808.xyz
│ ├── 3809.xyz
│ ├── 3810.xyz
│ ├── 3811.xyz
│ ├── 3812.xyz
│ ├── 3813.xyz
│ ├── 3814.xyz
│ ├── 3815.xyz
│ ├── 3816.xyz
│ ├── 3817.xyz
│ ├── 3818.xyz
│ ├── 3819.xyz
│ ├── 3820.xyz
│ ├── 3821.xyz
│ ├── 3822.xyz
│ ├── 3823.xyz
│ ├── 3824.xyz
│ ├── 3825.xyz
│ ├── 3826.xyz
│ ├── 3827.xyz
│ ├── 3828.xyz
│ ├── 3829.xyz
│ ├── 3830.xyz
│ ├── 3831.xyz
│ ├── 3832.xyz
│ ├── 3833.xyz
│ ├── 3834.xyz
│ ├── 3835.xyz
│ ├── 3836.xyz
│ ├── 3837.xyz
│ ├── 3838.xyz
│ ├── 3839.xyz
│ ├── 3840.xyz
│ ├── 3841.xyz
│ ├── 3842.xyz
│ ├── 3843.xyz
│ ├── 3844.xyz
│ ├── 3845.xyz
│ ├── 3846.xyz
│ ├── 3847.xyz
│ ├── 3848.xyz
│ ├── 3849.xyz
│ ├── 3850.xyz
│ ├── 3851.xyz
│ ├── 3852.xyz
│ ├── 3853.xyz
│ ├── 3854.xyz
│ ├── 3855.xyz
│ ├── 3856.xyz
│ ├── 3857.xyz
│ ├── 3858.xyz
│ ├── 3859.xyz
│ ├── 3860.xyz
│ ├── 3861.xyz
│ ├── 3862.xyz
│ ├── 3863.xyz
│ ├── 3864.xyz
│ ├── 3865.xyz
│ ├── 3866.xyz
│ ├── 3867.xyz
│ ├── 3868.xyz
│ ├── 3869.xyz
│ ├── 3870.xyz
│ ├── 3871.xyz
│ ├── 3872.xyz
│ ├── 3873.xyz
│ ├── 3874.xyz
│ ├── 3875.xyz
│ ├── 3876.xyz
│ ├── 3877.xyz
│ ├── 3878.xyz
│ ├── 3879.xyz
│ ├── 3880.xyz
│ ├── 3881.xyz
│ ├── 3882.xyz
│ ├── 3883.xyz
│ ├── 3884.xyz
│ ├── 3885.xyz
│ ├── 3886.xyz
│ ├── 3887.xyz
│ ├── 3888.xyz
│ ├── 3889.xyz
│ ├── 3890.xyz
│ ├── 3891.xyz
│ ├── 3892.xyz
│ ├── 3893.xyz
│ ├── 3894.xyz
│ ├── 3895.xyz
│ ├── 3896.xyz
│ ├── 3897.xyz
│ ├── 3898.xyz
│ ├── 3899.xyz
│ ├── 3900.xyz
│ ├── 3901.xyz
│ ├── 3902.xyz
│ ├── 3903.xyz
│ ├── 3904.xyz
│ ├── 3905.xyz
│ ├── 3906.xyz
│ ├── 3907.xyz
│ ├── 3908.xyz
│ ├── 3909.xyz
│ ├── 3910.xyz
│ ├── 3911.xyz
│ ├── 3912.xyz
│ ├── 3913.xyz
│ ├── 3914.xyz
│ ├── 3915.xyz
│ ├── 3916.xyz
│ ├── 3917.xyz
│ ├── 3918.xyz
│ ├── 3919.xyz
│ ├── 3920.xyz
│ ├── 3921.xyz
│ ├── 3922.xyz
│ ├── 3923.xyz
│ ├── 3924.xyz
│ ├── 3925.xyz
│ ├── 3926.xyz
│ ├── 3927.xyz
│ ├── 3928.xyz
│ ├── 3929.xyz
│ ├── 3930.xyz
│ ├── 3931.xyz
│ ├── 3932.xyz
│ ├── 3933.xyz
│ ├── 3934.xyz
│ ├── 3935.xyz
│ ├── 3936.xyz
│ ├── 3937.xyz
│ ├── 3938.xyz
│ ├── 3939.xyz
│ ├── 3940.xyz
│ ├── 3941.xyz
│ ├── 3942.xyz
│ ├── 3943.xyz
│ ├── 3944.xyz
│ ├── 3945.xyz
│ ├── 3946.xyz
│ ├── 3947.xyz
│ ├── 3948.xyz
│ ├── 3949.xyz
│ ├── 3950.xyz
│ ├── 3951.xyz
│ ├── 3952.xyz
│ ├── 3953.xyz
│ ├── 3954.xyz
│ ├── 3955.xyz
│ ├── 3956.xyz
│ ├── 3957.xyz
│ ├── 3958.xyz
│ ├── 3959.xyz
│ ├── 3960.xyz
│ ├── 3961.xyz
│ ├── 3962.xyz
│ ├── 3963.xyz
│ ├── 3964.xyz
│ ├── 3965.xyz
│ ├── 3966.xyz
│ ├── 3967.xyz
│ ├── 3968.xyz
│ ├── 3969.xyz
│ ├── 3970.xyz
│ ├── 3971.xyz
│ ├── 3972.xyz
│ ├── 3973.xyz
│ ├── 3974.xyz
│ ├── 3975.xyz
│ ├── 3976.xyz
│ ├── 3977.xyz
│ ├── 3978.xyz
│ ├── 3979.xyz
│ ├── 3980.xyz
│ ├── 3981.xyz
│ ├── 3982.xyz
│ ├── 3983.xyz
│ ├── 3984.xyz
│ ├── 3985.xyz
│ ├── 3986.xyz
│ ├── 3987.xyz
│ ├── 3988.xyz
│ ├── 3989.xyz
│ ├── 3990.xyz
│ ├── 3991.xyz
│ ├── 3992.xyz
│ ├── 3993.xyz
│ ├── 3994.xyz
│ ├── 3995.xyz
│ ├── 3996.xyz
│ ├── 3997.xyz
│ ├── 3998.xyz
│ ├── 3999.xyz
│ ├── 4000.xyz
│ ├── 4001.xyz
│ ├── 4002.xyz
│ ├── 4003.xyz
│ ├── 4004.xyz
│ ├── 4005.xyz
│ ├── 4006.xyz
│ ├── 4007.xyz
│ ├── 4008.xyz
│ ├── 4009.xyz
│ ├── 4010.xyz
│ ├── 4011.xyz
│ ├── 4012.xyz
│ ├── 4013.xyz
│ ├── 4014.xyz
│ ├── 4015.xyz
│ ├── 4016.xyz
│ ├── 4017.xyz
│ ├── 4018.xyz
│ ├── 4019.xyz
│ ├── 4020.xyz
│ ├── 4021.xyz
│ ├── 4022.xyz
│ ├── 4023.xyz
│ ├── 4024.xyz
│ ├── 4025.xyz
│ ├── 4026.xyz
│ ├── 4027.xyz
│ ├── 4028.xyz
│ ├── 4029.xyz
│ ├── 4030.xyz
│ ├── 4031.xyz
│ ├── 4032.xyz
│ ├── 4033.xyz
│ ├── 4034.xyz
│ ├── 4035.xyz
│ ├── 4036.xyz
│ ├── 4037.xyz
│ ├── 4038.xyz
│ ├── 4039.xyz
│ ├── 4040.xyz
│ ├── 4041.xyz
│ ├── 4042.xyz
│ ├── 4043.xyz
│ ├── 4044.xyz
│ ├── 4045.xyz
│ ├── 4046.xyz
│ ├── 4047.xyz
│ ├── 4048.xyz
│ ├── 4049.xyz
│ ├── 4050.xyz
│ ├── 4051.xyz
│ ├── 4052.xyz
│ ├── 4053.xyz
│ ├── 4054.xyz
│ ├── 4055.xyz
│ ├── 4056.xyz
│ ├── 4057.xyz
│ ├── 4058.xyz
│ ├── 4059.xyz
│ ├── 4060.xyz
│ ├── 4061.xyz
│ ├── 4062.xyz
│ ├── 4063.xyz
│ ├── 4064.xyz
│ ├── 4065.xyz
│ ├── 4066.xyz
│ ├── 4067.xyz
│ ├── 4068.xyz
│ ├── 4069.xyz
│ ├── 4070.xyz
│ ├── 4071.xyz
│ ├── 4072.xyz
│ ├── 4073.xyz
│ ├── 4074.xyz
│ ├── 4075.xyz
│ ├── 4076.xyz
│ ├── 4077.xyz
│ ├── 4078.xyz
│ ├── 4079.xyz
│ ├── 4080.xyz
│ ├── 4081.xyz
│ ├── 4082.xyz
│ ├── 4083.xyz
│ ├── 4084.xyz
│ ├── 4085.xyz
│ ├── 4086.xyz
│ ├── 4087.xyz
│ ├── 4088.xyz
│ ├── 4089.xyz
│ ├── 4090.xyz
│ ├── 4091.xyz
│ ├── 4092.xyz
│ ├── 4093.xyz
│ ├── 4094.xyz
│ ├── 4095.xyz
│ ├── 4096.xyz
│ ├── 4097.xyz
│ ├── 4098.xyz
│ ├── 4099.xyz
│ ├── 4100.xyz
│ ├── 4101.xyz
│ ├── 4102.xyz
│ ├── 4104.xyz
│ ├── 4105.xyz
│ ├── 4106.xyz
│ ├── 4107.xyz
│ ├── 4108.xyz
│ ├── 4109.xyz
│ ├── 4110.xyz
│ ├── 4111.xyz
│ ├── 4112.xyz
│ ├── 4113.xyz
│ ├── 4114.xyz
│ ├── 4115.xyz
│ ├── 4116.xyz
│ ├── 4117.xyz
│ ├── 4118.xyz
│ ├── 4119.xyz
│ ├── 4120.xyz
│ ├── 4121.xyz
│ ├── 4122.xyz
│ ├── 4123.xyz
│ ├── 4124.xyz
│ ├── 4125.xyz
│ ├── 4126.xyz
│ ├── 4127.xyz
│ ├── 4128.xyz
│ ├── 4129.xyz
│ ├── 4130.xyz
│ ├── 4131.xyz
│ ├── 4132.xyz
│ ├── 4133.xyz
│ ├── 4134.xyz
│ ├── 4135.xyz
│ ├── 4136.xyz
│ ├── 4137.xyz
│ ├── 4138.xyz
│ ├── 4139.xyz
│ ├── 4140.xyz
│ ├── 4141.xyz
│ ├── 4142.xyz
│ ├── 4143.xyz
│ ├── 4144.xyz
│ ├── 4145.xyz
│ ├── 4146.xyz
│ ├── 4147.xyz
│ ├── 4148.xyz
│ ├── 4149.xyz
│ ├── 4150.xyz
│ ├── 4151.xyz
│ ├── 4152.xyz
│ ├── 4153.xyz
│ ├── 4154.xyz
│ ├── 4155.xyz
│ ├── 4156.xyz
│ ├── 4157.xyz
│ ├── 4158.xyz
│ ├── 4159.xyz
│ ├── 4160.xyz
│ ├── 4161.xyz
│ ├── 4162.xyz
│ ├── 4163.xyz
│ ├── 4164.xyz
│ ├── 4165.xyz
│ ├── 4166.xyz
│ ├── 4167.xyz
│ ├── 4168.xyz
│ ├── 4169.xyz
│ ├── 4170.xyz
│ ├── 4171.xyz
│ ├── 4172.xyz
│ ├── 4173.xyz
│ ├── 4174.xyz
│ ├── 4175.xyz
│ ├── 4176.xyz
│ ├── 4177.xyz
│ ├── 4178.xyz
│ ├── 4179.xyz
│ ├── 4180.xyz
│ ├── 4181.xyz
│ ├── 4182.xyz
│ ├── 4183.xyz
│ ├── 4184.xyz
│ ├── 4185.xyz
│ ├── 4186.xyz
│ ├── 4187.xyz
│ ├── 4188.xyz
│ ├── 4189.xyz
│ ├── 4190.xyz
│ ├── 4191.xyz
│ ├── 4192.xyz
│ ├── 4193.xyz
│ ├── 4194.xyz
│ ├── 4195.xyz
│ ├── 4196.xyz
│ ├── 4197.xyz
│ ├── 4198.xyz
│ ├── 4199.xyz
│ ├── 4200.xyz
│ ├── 4201.xyz
│ ├── 4202.xyz
│ ├── 4203.xyz
│ ├── 4204.xyz
│ ├── 4205.xyz
│ ├── 4206.xyz
│ ├── 4207.xyz
│ ├── 4208.xyz
│ ├── 4209.xyz
│ ├── 4210.xyz
│ ├── 4211.xyz
│ ├── 4212.xyz
│ ├── 4213.xyz
│ ├── 4214.xyz
│ ├── 4215.xyz
│ ├── 4216.xyz
│ ├── 4217.xyz
│ ├── 4218.xyz
│ ├── 4219.xyz
│ ├── 4220.xyz
│ ├── 4221.xyz
│ ├── 4222.xyz
│ ├── 4223.xyz
│ ├── 4224.xyz
│ ├── 4225.xyz
│ ├── 4226.xyz
│ ├── 4227.xyz
│ ├── 4228.xyz
│ ├── 4229.xyz
│ ├── 4230.xyz
│ ├── 4231.xyz
│ ├── 4232.xyz
│ ├── 4233.xyz
│ ├── 4234.xyz
│ ├── 4235.xyz
│ ├── 4236.xyz
│ ├── 4237.xyz
│ ├── 4238.xyz
│ ├── 4239.xyz
│ ├── 4240.xyz
│ ├── 4241.xyz
│ ├── 4242.xyz
│ ├── 4243.xyz
│ ├── 4244.xyz
│ ├── 4245.xyz
│ ├── 4246.xyz
│ ├── 4247.xyz
│ ├── 4248.xyz
│ ├── 4249.xyz
│ ├── 4250.xyz
│ ├── 4251.xyz
│ ├── 4252.xyz
│ ├── 4253.xyz
│ ├── 4254.xyz
│ ├── 4255.xyz
│ ├── 4256.xyz
│ ├── 4257.xyz
│ ├── 4258.xyz
│ ├── 4259.xyz
│ ├── 4260.xyz
│ ├── 4261.xyz
│ ├── 4262.xyz
│ ├── 4263.xyz
│ ├── 4264.xyz
│ ├── 4265.xyz
│ ├── 4266.xyz
│ ├── 4267.xyz
│ ├── 4268.xyz
│ ├── 4269.xyz
│ ├── 4270.xyz
│ ├── 4271.xyz
│ ├── 4272.xyz
│ ├── 4273.xyz
│ ├── 4274.xyz
│ ├── 4275.xyz
│ ├── 4276.xyz
│ ├── 4277.xyz
│ ├── 4278.xyz
│ ├── 4279.xyz
│ ├── 4280.xyz
│ ├── 4281.xyz
│ ├── 4282.xyz
│ ├── 4283.xyz
│ ├── 4284.xyz
│ ├── 4285.xyz
│ ├── 4286.xyz
│ ├── 4287.xyz
│ ├── 4288.xyz
│ ├── 4289.xyz
│ ├── 4290.xyz
│ ├── 4291.xyz
│ ├── 4292.xyz
│ ├── 4293.xyz
│ ├── 4294.xyz
│ ├── 4295.xyz
│ ├── 4296.xyz
│ ├── 4297.xyz
│ ├── 4298.xyz
│ ├── 4299.xyz
│ ├── 4300.xyz
│ ├── 4301.xyz
│ ├── 4302.xyz
│ ├── 4303.xyz
│ ├── 4304.xyz
│ ├── 4305.xyz
│ ├── 4306.xyz
│ ├── 4307.xyz
│ ├── 4308.xyz
│ ├── 4309.xyz
│ ├── 4310.xyz
│ ├── 4311.xyz
│ ├── 4312.xyz
│ ├── 4313.xyz
│ ├── 4314.xyz
│ ├── 4315.xyz
│ ├── 4316.xyz
│ ├── 4318.xyz
│ ├── 4319.xyz
│ ├── 4320.xyz
│ ├── 4321.xyz
│ ├── 4322.xyz
│ ├── 4323.xyz
│ ├── 4324.xyz
│ ├── 4325.xyz
│ ├── 4326.xyz
│ ├── 4327.xyz
│ ├── 4328.xyz
│ ├── 4329.xyz
│ ├── 4330.xyz
│ ├── 4331.xyz
│ ├── 4332.xyz
│ ├── 4333.xyz
│ ├── 4334.xyz
│ ├── 4335.xyz
│ ├── 4336.xyz
│ ├── 4337.xyz
│ ├── 4338.xyz
│ ├── 4339.xyz
│ ├── 4340.xyz
│ ├── 4341.xyz
│ ├── 4342.xyz
│ ├── 4343.xyz
│ ├── 4344.xyz
│ ├── 4345.xyz
│ ├── 4346.xyz
│ ├── 4347.xyz
│ ├── 4348.xyz
│ ├── 4349.xyz
│ ├── 4350.xyz
│ ├── 4351.xyz
│ ├── 4352.xyz
│ ├── 4353.xyz
│ ├── 4354.xyz
│ ├── 4355.xyz
│ ├── 4356.xyz
│ ├── 4357.xyz
│ ├── 4358.xyz
│ ├── 4359.xyz
│ ├── 4360.xyz
│ ├── 4361.xyz
│ ├── 4362.xyz
│ ├── 4363.xyz
│ ├── 4364.xyz
│ ├── 4365.xyz
│ ├── 4366.xyz
│ ├── 4367.xyz
│ ├── 4368.xyz
│ ├── 4369.xyz
│ ├── 4370.xyz
│ ├── 4371.xyz
│ ├── 4372.xyz
│ ├── 4373.xyz
│ ├── 4374.xyz
│ ├── 4375.xyz
│ ├── 4376.xyz
│ ├── 4377.xyz
│ ├── 4378.xyz
│ ├── 4379.xyz
│ ├── 4380.xyz
│ ├── 4381.xyz
│ ├── 4382.xyz
│ ├── 4383.xyz
│ ├── 4384.xyz
│ ├── 4385.xyz
│ ├── 4387.xyz
│ ├── 4388.xyz
│ ├── 4389.xyz
│ ├── 4390.xyz
│ ├── 4391.xyz
│ ├── 4392.xyz
│ ├── 4393.xyz
│ ├── 4394.xyz
│ ├── 4395.xyz
│ ├── 4396.xyz
│ ├── 4397.xyz
│ ├── 4398.xyz
│ ├── 4399.xyz
│ ├── 4400.xyz
│ ├── 4401.xyz
│ ├── 4402.xyz
│ ├── 4403.xyz
│ ├── 4404.xyz
│ ├── 4405.xyz
│ ├── 4406.xyz
│ ├── 4407.xyz
│ ├── 4408.xyz
│ ├── 4409.xyz
│ ├── 4410.xyz
│ ├── 4411.xyz
│ ├── 4412.xyz
│ ├── 4413.xyz
│ ├── 4414.xyz
│ ├── 4415.xyz
│ ├── 4416.xyz
│ ├── 4417.xyz
│ ├── 4418.xyz
│ ├── 4419.xyz
│ ├── 4420.xyz
│ ├── 4421.xyz
│ ├── 4422.xyz
│ ├── 4423.xyz
│ ├── 4424.xyz
│ ├── 4425.xyz
│ ├── 4426.xyz
│ ├── 4427.xyz
│ ├── 4428.xyz
│ ├── 4429.xyz
│ ├── 4430.xyz
│ ├── 4431.xyz
│ ├── 4432.xyz
│ ├── 4433.xyz
│ ├── 4434.xyz
│ ├── 4435.xyz
│ ├── 4436.xyz
│ ├── 4437.xyz
│ ├── 4438.xyz
│ ├── 4439.xyz
│ ├── 4440.xyz
│ ├── 4441.xyz
│ ├── 4442.xyz
│ ├── 4443.xyz
│ ├── 4444.xyz
│ ├── 4445.xyz
│ ├── 4446.xyz
│ ├── 4447.xyz
│ ├── 4448.xyz
│ ├── 4449.xyz
│ ├── 4450.xyz
│ ├── 4451.xyz
│ ├── 4452.xyz
│ ├── 4453.xyz
│ ├── 4454.xyz
│ ├── 4455.xyz
│ ├── 4456.xyz
│ ├── 4457.xyz
│ ├── 4458.xyz
│ ├── 4459.xyz
│ ├── 4460.xyz
│ ├── 4461.xyz
│ ├── 4462.xyz
│ ├── 4463.xyz
│ ├── 4464.xyz
│ ├── 4465.xyz
│ ├── 4466.xyz
│ ├── 4467.xyz
│ ├── 4468.xyz
│ ├── 4469.xyz
│ ├── 4470.xyz
│ ├── 4471.xyz
│ ├── 4472.xyz
│ ├── 4473.xyz
│ ├── 4474.xyz
│ ├── 4475.xyz
│ ├── 4476.xyz
│ ├── 4477.xyz
│ ├── 4478.xyz
│ ├── 4479.xyz
│ ├── 4480.xyz
│ ├── 4481.xyz
│ ├── 4482.xyz
│ ├── 4483.xyz
│ ├── 4484.xyz
│ ├── 4485.xyz
│ ├── 4486.xyz
│ ├── 4487.xyz
│ ├── 4488.xyz
│ ├── 4489.xyz
│ ├── 4490.xyz
│ ├── 4491.xyz
│ ├── 4492.xyz
│ ├── 4493.xyz
│ ├── 4494.xyz
│ ├── 4495.xyz
│ ├── 4496.xyz
│ ├── 4497.xyz
│ ├── 4498.xyz
│ ├── 4499.xyz
│ ├── 4500.xyz
│ ├── 4501.xyz
│ ├── 4502.xyz
│ ├── 4503.xyz
│ ├── 4504.xyz
│ ├── 4505.xyz
│ ├── 4506.xyz
│ ├── 4507.xyz
│ ├── 4508.xyz
│ ├── 4509.xyz
│ ├── 4510.xyz
│ ├── 4511.xyz
│ ├── 4512.xyz
│ ├── 4513.xyz
│ ├── 4514.xyz
│ ├── 4515.xyz
│ ├── 4516.xyz
│ ├── 4517.xyz
│ ├── 4518.xyz
│ ├── 4519.xyz
│ ├── 4520.xyz
│ ├── 4521.xyz
│ ├── 4522.xyz
│ ├── 4523.xyz
│ ├── 4524.xyz
│ ├── 4525.xyz
│ ├── 4526.xyz
│ ├── 4527.xyz
│ ├── 4528.xyz
│ ├── 4529.xyz
│ ├── 4530.xyz
│ ├── 4531.xyz
│ ├── 4532.xyz
│ ├── 4533.xyz
│ ├── 4534.xyz
│ ├── 4535.xyz
│ ├── 4536.xyz
│ ├── 4537.xyz
│ ├── 4538.xyz
│ ├── 4539.xyz
│ ├── 4540.xyz
│ ├── 4541.xyz
│ ├── 4542.xyz
│ ├── 4543.xyz
│ ├── 4544.xyz
│ ├── 4545.xyz
│ ├── 4546.xyz
│ ├── 4547.xyz
│ ├── 4548.xyz
│ ├── 4549.xyz
│ ├── 4550.xyz
│ ├── 4551.xyz
│ ├── 4552.xyz
│ ├── 4553.xyz
│ ├── 4554.xyz
│ ├── 4555.xyz
│ ├── 4556.xyz
│ ├── 4557.xyz
│ ├── 4558.xyz
│ ├── 4559.xyz
│ ├── 4560.xyz
│ ├── 4561.xyz
│ ├── 4562.xyz
│ ├── 4563.xyz
│ ├── 4564.xyz
│ ├── 4565.xyz
│ ├── 4566.xyz
│ ├── 4567.xyz
│ ├── 4568.xyz
│ ├── 4569.xyz
│ ├── 4570.xyz
│ ├── 4571.xyz
│ ├── 4572.xyz
│ ├── 4573.xyz
│ ├── 4574.xyz
│ ├── 4575.xyz
│ ├── 4576.xyz
│ ├── 4577.xyz
│ ├── 4578.xyz
│ ├── 4579.xyz
│ ├── 4580.xyz
│ ├── 4581.xyz
│ ├── 4582.xyz
│ ├── 4583.xyz
│ ├── 4584.xyz
│ ├── 4585.xyz
│ ├── 4586.xyz
│ ├── 4587.xyz
│ ├── 4588.xyz
│ ├── 4589.xyz
│ ├── 4590.xyz
│ ├── 4591.xyz
│ ├── 4592.xyz
│ ├── 4593.xyz
│ ├── 4594.xyz
│ ├── 4595.xyz
│ ├── 4596.xyz
│ ├── 4597.xyz
│ ├── 4598.xyz
│ ├── 4599.xyz
│ ├── 4600.xyz
│ ├── 4601.xyz
│ ├── 4602.xyz
│ ├── 4603.xyz
│ ├── 4604.xyz
│ ├── 4605.xyz
│ ├── 4606.xyz
│ ├── 4607.xyz
│ ├── 4608.xyz
│ ├── 4609.xyz
│ ├── 4610.xyz
│ ├── 4611.xyz
│ ├── 4612.xyz
│ ├── 4613.xyz
│ ├── 4614.xyz
│ ├── 4615.xyz
│ ├── 4616.xyz
│ ├── 4617.xyz
│ ├── 4618.xyz
│ ├── 4619.xyz
│ ├── 4620.xyz
│ ├── 4621.xyz
│ ├── 4622.xyz
│ ├── 4623.xyz
│ ├── 4624.xyz
│ ├── 4625.xyz
│ ├── 4626.xyz
│ ├── 4627.xyz
│ ├── 4628.xyz
│ ├── 4629.xyz
│ ├── 4630.xyz
│ ├── 4631.xyz
│ ├── 4632.xyz
│ ├── 4633.xyz
│ ├── 4634.xyz
│ ├── 4635.xyz
│ ├── 4636.xyz
│ ├── 4637.xyz
│ ├── 4638.xyz
│ ├── 4639.xyz
│ ├── 4640.xyz
│ ├── 4641.xyz
│ ├── 4642.xyz
│ ├── 4643.xyz
│ ├── 4644.xyz
│ ├── 4645.xyz
│ ├── 4646.xyz
│ ├── 4647.xyz
│ ├── 4648.xyz
│ ├── 4649.xyz
│ ├── 4650.xyz
│ ├── 4651.xyz
│ ├── 4652.xyz
│ ├── 4653.xyz
│ ├── 4654.xyz
│ ├── 4655.xyz
│ ├── 4656.xyz
│ ├── 4657.xyz
│ ├── 4658.xyz
│ ├── 4659.xyz
│ ├── 4660.xyz
│ ├── 4661.xyz
│ ├── 4662.xyz
│ ├── 4663.xyz
│ ├── 4664.xyz
│ ├── 4665.xyz
│ ├── 4666.xyz
│ ├── 4667.xyz
│ ├── 4668.xyz
│ ├── 4669.xyz
│ ├── 4670.xyz
│ ├── 4671.xyz
│ ├── 4672.xyz
│ ├── 4673.xyz
│ ├── 4674.xyz
│ ├── 4675.xyz
│ ├── 4676.xyz
│ ├── 4677.xyz
│ ├── 4678.xyz
│ ├── 4679.xyz
│ ├── 4680.xyz
│ ├── 4681.xyz
│ ├── 4682.xyz
│ ├── 4683.xyz
│ ├── 4684.xyz
│ ├── 4685.xyz
│ ├── 4686.xyz
│ ├── 4687.xyz
│ ├── 4688.xyz
│ ├── 4689.xyz
│ ├── 4690.xyz
│ ├── 4691.xyz
│ ├── 4692.xyz
│ ├── 4693.xyz
│ ├── 4694.xyz
│ ├── 4695.xyz
│ ├── 4696.xyz
│ ├── 4697.xyz
│ ├── 4698.xyz
│ ├── 4699.xyz
│ ├── 4700.xyz
│ ├── 4701.xyz
│ ├── 4702.xyz
│ ├── 4703.xyz
│ ├── 4704.xyz
│ ├── 4705.xyz
│ ├── 4706.xyz
│ ├── 4707.xyz
│ ├── 4708.xyz
│ ├── 4709.xyz
│ ├── 4710.xyz
│ ├── 4711.xyz
│ ├── 4712.xyz
│ ├── 4713.xyz
│ ├── 4714.xyz
│ ├── 4715.xyz
│ ├── 4716.xyz
│ ├── 4717.xyz
│ ├── 4718.xyz
│ ├── 4719.xyz
│ ├── 4720.xyz
│ ├── 4721.xyz
│ ├── 4722.xyz
│ ├── 4723.xyz
│ ├── 4724.xyz
│ ├── 4725.xyz
│ ├── 4726.xyz
│ ├── 4727.xyz
│ ├── 4728.xyz
│ ├── 4729.xyz
│ ├── 4730.xyz
│ ├── 4731.xyz
│ ├── 4732.xyz
│ ├── 4733.xyz
│ ├── 4734.xyz
│ ├── 4735.xyz
│ ├── 4736.xyz
│ ├── 4737.xyz
│ ├── 4738.xyz
│ ├── 4739.xyz
│ ├── 4740.xyz
│ ├── 4741.xyz
│ ├── 4742.xyz
│ ├── 4743.xyz
│ ├── 4744.xyz
│ ├── 4745.xyz
│ ├── 4746.xyz
│ ├── 4747.xyz
│ ├── 4748.xyz
│ ├── 4749.xyz
│ ├── 4750.xyz
│ ├── 4751.xyz
│ ├── 4752.xyz
│ ├── 4753.xyz
│ ├── 4754.xyz
│ ├── 4755.xyz
│ ├── 4756.xyz
│ ├── 4757.xyz
│ ├── 4758.xyz
│ ├── 4759.xyz
│ ├── 4760.xyz
│ ├── 4761.xyz
│ ├── 4762.xyz
│ ├── 4763.xyz
│ ├── 4764.xyz
│ ├── 4765.xyz
│ ├── 4766.xyz
│ ├── 4767.xyz
│ ├── 4768.xyz
│ ├── 4769.xyz
│ ├── 4770.xyz
│ ├── 4771.xyz
│ ├── 4772.xyz
│ ├── 4773.xyz
│ ├── 4774.xyz
│ ├── 4775.xyz
│ ├── 4776.xyz
│ ├── 4777.xyz
│ ├── 4778.xyz
│ ├── 4779.xyz
│ ├── 4780.xyz
│ ├── 4781.xyz
│ ├── 4782.xyz
│ ├── 4783.xyz
│ ├── 4784.xyz
│ ├── 4785.xyz
│ ├── 4786.xyz
│ ├── 4787.xyz
│ ├── 4788.xyz
│ ├── 4789.xyz
│ ├── 4790.xyz
│ ├── 4791.xyz
│ ├── 4792.xyz
│ ├── 4793.xyz
│ ├── 4794.xyz
│ ├── 4795.xyz
│ ├── 4796.xyz
│ ├── 4797.xyz
│ ├── 4798.xyz
│ ├── 4799.xyz
│ ├── 4800.xyz
│ ├── 4801.xyz
│ ├── 4802.xyz
│ ├── 4803.xyz
│ ├── 4804.xyz
│ ├── 4805.xyz
│ ├── 4806.xyz
│ ├── 4807.xyz
│ ├── 4808.xyz
│ ├── 4809.xyz
│ ├── 4810.xyz
│ ├── 4811.xyz
│ ├── 4812.xyz
│ ├── 4813.xyz
│ ├── 4814.xyz
│ ├── 4815.xyz
│ ├── 4816.xyz
│ ├── 4817.xyz
│ ├── 4818.xyz
│ ├── 4819.xyz
│ ├── 4820.xyz
│ ├── 4821.xyz
│ ├── 4822.xyz
│ ├── 4823.xyz
│ ├── 4824.xyz
│ ├── 4825.xyz
│ ├── 4826.xyz
│ ├── 4827.xyz
│ ├── 4828.xyz
│ ├── 4829.xyz
│ ├── 4830.xyz
│ ├── 4831.xyz
│ ├── 4832.xyz
│ ├── 4833.xyz
│ ├── 4834.xyz
│ ├── 4835.xyz
│ ├── 4836.xyz
│ ├── 4837.xyz
│ ├── 4838.xyz
│ ├── 4839.xyz
│ ├── 4840.xyz
│ ├── 4841.xyz
│ ├── 4842.xyz
│ ├── 4843.xyz
│ ├── 4844.xyz
│ ├── 4845.xyz
│ ├── 4846.xyz
│ ├── 4847.xyz
│ ├── 4848.xyz
│ ├── 4849.xyz
│ ├── 4850.xyz
│ ├── 4851.xyz
│ ├── 4852.xyz
│ ├── 4853.xyz
│ ├── 4854.xyz
│ ├── 4855.xyz
│ ├── 4856.xyz
│ ├── 4857.xyz
│ ├── 4858.xyz
│ ├── 4859.xyz
│ ├── 4860.xyz
│ ├── 4861.xyz
│ ├── 4862.xyz
│ ├── 4863.xyz
│ ├── 4864.xyz
│ ├── 4865.xyz
│ ├── 4866.xyz
│ ├── 4867.xyz
│ ├── 4868.xyz
│ ├── 4869.xyz
│ ├── 4870.xyz
│ ├── 4871.xyz
│ ├── 4872.xyz
│ ├── 4873.xyz
│ ├── 4874.xyz
│ ├── 4875.xyz
│ ├── 4876.xyz
│ ├── 4877.xyz
│ ├── 4878.xyz
│ ├── 4879.xyz
│ ├── 4880.xyz
│ ├── 4881.xyz
│ ├── 4882.xyz
│ ├── 4883.xyz
│ ├── 4884.xyz
│ ├── 4885.xyz
│ ├── 4886.xyz
│ ├── 4887.xyz
│ ├── 4888.xyz
│ ├── 4889.xyz
│ ├── 4890.xyz
│ ├── 4891.xyz
│ ├── 4892.xyz
│ ├── 4893.xyz
│ ├── 4894.xyz
│ ├── 4895.xyz
│ ├── 4896.xyz
│ ├── 4897.xyz
│ ├── 4898.xyz
│ ├── 4899.xyz
│ ├── 4900.xyz
│ ├── 4901.xyz
│ ├── 4902.xyz
│ ├── 4903.xyz
│ ├── 4904.xyz
│ ├── 4905.xyz
│ ├── 4906.xyz
│ ├── 4907.xyz
│ ├── 4908.xyz
│ ├── 4909.xyz
│ ├── 4910.xyz
│ ├── 4911.xyz
│ ├── 4912.xyz
│ ├── 4913.xyz
│ ├── 4914.xyz
│ ├── 4915.xyz
│ ├── 4916.xyz
│ ├── 4917.xyz
│ ├── 4918.xyz
│ ├── 4919.xyz
│ ├── 4920.xyz
│ ├── 4921.xyz
│ ├── 4922.xyz
│ ├── 4923.xyz
│ ├── 4924.xyz
│ ├── 4925.xyz
│ ├── 4926.xyz
│ ├── 4927.xyz
│ ├── 4928.xyz
│ ├── 4929.xyz
│ ├── 4930.xyz
│ ├── 4932.xyz
│ ├── 4933.xyz
│ ├── 4934.xyz
│ ├── 4935.xyz
│ ├── 4936.xyz
│ ├── 4937.xyz
│ ├── 4938.xyz
│ ├── 4939.xyz
│ ├── 4940.xyz
│ ├── 4941.xyz
│ ├── 4942.xyz
│ ├── 4943.xyz
│ ├── 4944.xyz
│ ├── 4945.xyz
│ ├── 4946.xyz
│ ├── 4947.xyz
│ ├── 4948.xyz
│ ├── 4949.xyz
│ ├── 4950.xyz
│ ├── 4951.xyz
│ ├── 4952.xyz
│ ├── 4953.xyz
│ ├── 4954.xyz
│ ├── 4955.xyz
│ ├── 4956.xyz
│ ├── 4957.xyz
│ ├── 4958.xyz
│ ├── 4959.xyz
│ ├── 4960.xyz
│ ├── 4961.xyz
│ ├── 4962.xyz
│ ├── 4963.xyz
│ ├── 4964.xyz
│ ├── 4965.xyz
│ ├── 4966.xyz
│ ├── 4967.xyz
│ ├── 4968.xyz
│ ├── 4969.xyz
│ ├── 4970.xyz
│ ├── 4971.xyz
│ ├── 4972.xyz
│ ├── 4973.xyz
│ ├── 4974.xyz
│ ├── 4975.xyz
│ ├── 4976.xyz
│ ├── 4977.xyz
│ ├── 4978.xyz
│ ├── 4979.xyz
│ ├── 4980.xyz
│ ├── 4981.xyz
│ ├── 4982.xyz
│ ├── 4983.xyz
│ ├── 4984.xyz
│ ├── 4985.xyz
│ ├── 4986.xyz
│ ├── 4987.xyz
│ ├── 4988.xyz
│ ├── 4989.xyz
│ ├── 4990.xyz
│ ├── 4991.xyz
│ ├── 4992.xyz
│ ├── 4993.xyz
│ ├── 4994.xyz
│ ├── 4995.xyz
│ ├── 4996.xyz
│ ├── 4997.xyz
│ ├── 4998.xyz
│ ├── 4999.xyz
│ ├── 5000.xyz
│ ├── 5001.xyz
│ ├── 5002.xyz
│ ├── 5003.xyz
│ ├── 5004.xyz
│ ├── 5005.xyz
│ ├── 5006.xyz
│ ├── 5007.xyz
│ ├── 5008.xyz
│ ├── 5009.xyz
│ ├── 5010.xyz
│ ├── 5011.xyz
│ ├── 5012.xyz
│ ├── 5013.xyz
│ ├── 5014.xyz
│ ├── 5015.xyz
│ ├── 5016.xyz
│ ├── 5017.xyz
│ ├── 5018.xyz
│ ├── 5019.xyz
│ ├── 5020.xyz
│ ├── 5021.xyz
│ ├── 5022.xyz
│ ├── 5023.xyz
│ ├── 5024.xyz
│ ├── 5025.xyz
│ ├── 5026.xyz
│ ├── 5027.xyz
│ ├── 5028.xyz
│ ├── 5029.xyz
│ ├── 5030.xyz
│ ├── 5031.xyz
│ ├── 5033.xyz
│ ├── 5034.xyz
│ ├── 5035.xyz
│ ├── 5036.xyz
│ ├── 5037.xyz
│ ├── 5038.xyz
│ ├── 5039.xyz
│ ├── 5040.xyz
│ ├── 5041.xyz
│ ├── 5042.xyz
│ ├── 5043.xyz
│ ├── 5044.xyz
│ ├── 5045.xyz
│ ├── 5046.xyz
│ ├── 5047.xyz
│ ├── 5048.xyz
│ ├── 5049.xyz
│ ├── 5050.xyz
│ ├── 5051.xyz
│ ├── 5052.xyz
│ ├── 5054.xyz
│ ├── 5055.xyz
│ ├── 5056.xyz
│ ├── 5058.xyz
│ ├── 5059.xyz
│ ├── 5060.xyz
│ ├── 5061.xyz
│ ├── 5062.xyz
│ ├── 5063.xyz
│ ├── 5064.xyz
│ ├── 5065.xyz
│ ├── 5066.xyz
│ ├── 5067.xyz
│ ├── 5068.xyz
│ ├── 5069.xyz
│ ├── 5070.xyz
│ ├── 5071.xyz
│ ├── 5072.xyz
│ ├── 5073.xyz
│ ├── 5074.xyz
│ ├── 5075.xyz
│ ├── 5076.xyz
│ ├── 5077.xyz
│ ├── 5078.xyz
│ ├── 5079.xyz
│ ├── 5080.xyz
│ ├── 5081.xyz
│ ├── 5082.xyz
│ ├── 5083.xyz
│ ├── 5084.xyz
│ ├── 5085.xyz
│ ├── 5086.xyz
│ ├── 5087.xyz
│ ├── 5088.xyz
│ ├── 5089.xyz
│ ├── 5090.xyz
│ ├── 5091.xyz
│ ├── 5092.xyz
│ ├── 5093.xyz
│ ├── 5094.xyz
│ ├── 5095.xyz
│ ├── 5096.xyz
│ ├── 5097.xyz
│ ├── 5098.xyz
│ ├── 5099.xyz
│ ├── 5100.xyz
│ ├── 5101.xyz
│ ├── 5102.xyz
│ ├── 5103.xyz
│ ├── 5104.xyz
│ ├── 5105.xyz
│ ├── 5106.xyz
│ ├── 5107.xyz
│ ├── 5108.xyz
│ ├── 5109.xyz
│ ├── 5110.xyz
│ ├── 5111.xyz
│ ├── 5112.xyz
│ ├── 5113.xyz
│ ├── 5114.xyz
│ ├── 5115.xyz
│ ├── 5116.xyz
│ ├── 5117.xyz
│ ├── 5118.xyz
│ ├── 5119.xyz
│ ├── 5120.xyz
│ ├── 5121.xyz
│ ├── 5122.xyz
│ ├── 5123.xyz
│ ├── 5124.xyz
│ ├── 5125.xyz
│ ├── 5126.xyz
│ ├── 5127.xyz
│ ├── 5128.xyz
│ ├── 5129.xyz
│ ├── 5130.xyz
│ ├── 5131.xyz
│ ├── 5132.xyz
│ ├── 5133.xyz
│ ├── 5134.xyz
│ ├── 5135.xyz
│ ├── 5136.xyz
│ ├── 5137.xyz
│ ├── 5138.xyz
│ ├── 5139.xyz
│ ├── 5140.xyz
│ ├── 5141.xyz
│ ├── 5142.xyz
│ ├── 5143.xyz
│ ├── 5144.xyz
│ ├── 5145.xyz
│ ├── 5146.xyz
│ ├── 5147.xyz
│ ├── 5148.xyz
│ ├── 5149.xyz
│ ├── 5150.xyz
│ ├── 5151.xyz
│ ├── 5152.xyz
│ ├── 5153.xyz
│ ├── 5154.xyz
│ ├── 5155.xyz
│ ├── 5156.xyz
│ ├── 5157.xyz
│ ├── 5158.xyz
│ ├── 5159.xyz
│ ├── 5160.xyz
│ ├── 5161.xyz
│ ├── 5162.xyz
│ ├── 5163.xyz
│ ├── 5164.xyz
│ ├── 5165.xyz
│ ├── 5166.xyz
│ ├── 5167.xyz
│ ├── 5168.xyz
│ ├── 5169.xyz
│ ├── 5170.xyz
│ ├── 5171.xyz
│ ├── 5172.xyz
│ ├── 5173.xyz
│ ├── 5174.xyz
│ ├── 5175.xyz
│ ├── 5176.xyz
│ ├── 5177.xyz
│ ├── 5178.xyz
│ ├── 5179.xyz
│ ├── 5180.xyz
│ ├── 5181.xyz
│ ├── 5182.xyz
│ ├── 5183.xyz
│ ├── 5184.xyz
│ ├── 5185.xyz
│ ├── 5186.xyz
│ ├── 5187.xyz
│ ├── 5188.xyz
│ ├── 5189.xyz
│ ├── 5190.xyz
│ ├── 5191.xyz
│ ├── 5192.xyz
│ ├── 5193.xyz
│ ├── 5194.xyz
│ ├── 5195.xyz
│ ├── 5196.xyz
│ ├── 5197.xyz
│ ├── 5198.xyz
│ ├── 5199.xyz
│ ├── 5200.xyz
│ ├── 5201.xyz
│ ├── 5202.xyz
│ ├── 5203.xyz
│ ├── 5204.xyz
│ ├── 5205.xyz
│ ├── 5206.xyz
│ ├── 5207.xyz
│ ├── 5208.xyz
│ ├── 5209.xyz
│ ├── 5210.xyz
│ ├── 5211.xyz
│ ├── 5212.xyz
│ ├── 5213.xyz
│ ├── 5214.xyz
│ ├── 5215.xyz
│ ├── 5216.xyz
│ ├── 5217.xyz
│ ├── 5218.xyz
│ ├── 5219.xyz
│ ├── 5220.xyz
│ ├── 5221.xyz
│ ├── 5222.xyz
│ ├── 5223.xyz
│ ├── 5224.xyz
│ ├── 5225.xyz
│ ├── 5226.xyz
│ ├── 5227.xyz
│ ├── 5228.xyz
│ ├── 5229.xyz
│ ├── 5230.xyz
│ ├── 5231.xyz
│ ├── 5232.xyz
│ ├── 5233.xyz
│ ├── 5234.xyz
│ ├── 5235.xyz
│ ├── 5236.xyz
│ ├── 5237.xyz
│ ├── 5238.xyz
│ ├── 5239.xyz
│ ├── 5240.xyz
│ ├── 5241.xyz
│ ├── 5242.xyz
│ ├── 5243.xyz
│ ├── 5244.xyz
│ ├── 5245.xyz
│ ├── 5246.xyz
│ ├── 5247.xyz
│ ├── 5248.xyz
│ ├── 5249.xyz
│ ├── 5250.xyz
│ ├── 5251.xyz
│ ├── 5252.xyz
│ ├── 5254.xyz
│ ├── 5255.xyz
│ ├── 5256.xyz
│ ├── 5257.xyz
│ ├── 5258.xyz
│ ├── 5259.xyz
│ ├── 5260.xyz
│ ├── 5261.xyz
│ ├── 5262.xyz
│ ├── 5263.xyz
│ ├── 5264.xyz
│ ├── 5265.xyz
│ ├── 5266.xyz
│ ├── 5267.xyz
│ ├── 5268.xyz
│ ├── 5269.xyz
│ ├── 5270.xyz
│ ├── 5271.xyz
│ ├── 5272.xyz
│ ├── 5273.xyz
│ ├── 5274.xyz
│ ├── 5275.xyz
│ ├── 5276.xyz
│ ├── 5278.xyz
│ ├── 5279.xyz
│ ├── 5280.xyz
│ ├── 5281.xyz
│ ├── 5282.xyz
│ ├── 5283.xyz
│ ├── 5284.xyz
│ ├── 5285.xyz
│ ├── 5286.xyz
│ ├── 5287.xyz
│ ├── 5288.xyz
│ ├── 5289.xyz
│ ├── 5290.xyz
│ ├── 5291.xyz
│ ├── 5292.xyz
│ ├── 5293.xyz
│ ├── 5294.xyz
│ ├── 5295.xyz
│ ├── 5296.xyz
│ ├── 5297.xyz
│ ├── 5298.xyz
│ ├── 5299.xyz
│ ├── 5300.xyz
│ ├── 5301.xyz
│ ├── 5302.xyz
│ ├── 5303.xyz
│ ├── 5304.xyz
│ ├── 5305.xyz
│ ├── 5306.xyz
│ ├── 5307.xyz
│ ├── 5308.xyz
│ ├── 5309.xyz
│ ├── 5310.xyz
│ ├── 5311.xyz
│ ├── 5312.xyz
│ ├── 5313.xyz
│ ├── 5314.xyz
│ ├── 5315.xyz
│ ├── 5316.xyz
│ ├── 5317.xyz
│ ├── 5318.xyz
│ ├── 5319.xyz
│ ├── 5320.xyz
│ ├── 5321.xyz
│ ├── 5322.xyz
│ ├── 5323.xyz
│ ├── 5324.xyz
│ ├── 5325.xyz
│ ├── 5326.xyz
│ ├── 5327.xyz
│ ├── 5328.xyz
│ ├── 5329.xyz
│ ├── 5330.xyz
│ ├── 5331.xyz
│ ├── 5332.xyz
│ ├── 5333.xyz
│ ├── 5334.xyz
│ ├── 5335.xyz
│ ├── 5336.xyz
│ ├── 5337.xyz
│ ├── 5338.xyz
│ ├── 5339.xyz
│ ├── 5340.xyz
│ ├── 5341.xyz
│ ├── 5342.xyz
│ ├── 5343.xyz
│ ├── 5345.xyz
│ ├── 5346.xyz
│ ├── 5347.xyz
│ ├── 5348.xyz
│ ├── 5349.xyz
│ ├── 5350.xyz
│ ├── 5351.xyz
│ ├── 5352.xyz
│ ├── 5353.xyz
│ ├── 5354.xyz
│ ├── 5355.xyz
│ ├── 5356.xyz
│ ├── 5357.xyz
│ ├── 5358.xyz
│ ├── 5359.xyz
│ ├── 5360.xyz
│ ├── 5361.xyz
│ ├── 5362.xyz
│ ├── 5363.xyz
│ ├── 5364.xyz
│ ├── 5365.xyz
│ ├── 5366.xyz
│ ├── 5367.xyz
│ ├── 5368.xyz
│ ├── 5369.xyz
│ ├── 5370.xyz
│ ├── 5371.xyz
│ ├── 5372.xyz
│ ├── 5373.xyz
│ ├── 5374.xyz
│ ├── 5375.xyz
│ ├── 5376.xyz
│ ├── 5377.xyz
│ ├── 5378.xyz
│ ├── 5379.xyz
│ ├── 5380.xyz
│ ├── 5381.xyz
│ ├── 5382.xyz
│ ├── 5383.xyz
│ ├── 5384.xyz
│ ├── 5385.xyz
│ ├── 5386.xyz
│ ├── 5387.xyz
│ ├── 5388.xyz
│ ├── 5390.xyz
│ ├── 5391.xyz
│ ├── 5392.xyz
│ ├── 5393.xyz
│ ├── 5394.xyz
│ ├── 5395.xyz
│ ├── 5396.xyz
│ ├── 5397.xyz
│ ├── 5398.xyz
│ ├── 5399.xyz
│ ├── 5400.xyz
│ ├── 5401.xyz
│ ├── 5402.xyz
│ ├── 5403.xyz
│ ├── 5404.xyz
│ ├── 5405.xyz
│ ├── 5406.xyz
│ ├── 5407.xyz
│ ├── 5408.xyz
│ ├── 5409.xyz
│ ├── 5410.xyz
│ ├── 5411.xyz
│ ├── 5412.xyz
│ ├── 5413.xyz
│ ├── 5414.xyz
│ ├── 5415.xyz
│ ├── 5416.xyz
│ ├── 5417.xyz
│ ├── 5418.xyz
│ ├── 5419.xyz
│ ├── 5420.xyz
│ ├── 5421.xyz
│ ├── 5422.xyz
│ ├── 5423.xyz
│ ├── 5424.xyz
│ ├── 5425.xyz
│ ├── 5426.xyz
│ ├── 5427.xyz
│ ├── 5428.xyz
│ ├── 5429.xyz
│ ├── 5430.xyz
│ ├── 5431.xyz
│ ├── 5432.xyz
│ ├── 5433.xyz
│ ├── 5434.xyz
│ ├── 5435.xyz
│ ├── 5436.xyz
│ ├── 5437.xyz
│ ├── 5438.xyz
│ ├── 5439.xyz
│ ├── 5440.xyz
│ ├── 5441.xyz
│ ├── 5442.xyz
│ ├── 5443.xyz
│ ├── 5444.xyz
│ ├── 5445.xyz
│ ├── 5446.xyz
│ ├── 5447.xyz
│ ├── 5448.xyz
│ ├── 5449.xyz
│ ├── 5450.xyz
│ ├── 5451.xyz
│ ├── 5452.xyz
│ ├── 5453.xyz
│ ├── 5454.xyz
│ ├── 5455.xyz
│ ├── 5456.xyz
│ ├── 5457.xyz
│ ├── 5458.xyz
│ ├── 5459.xyz
│ ├── 5460.xyz
│ ├── 5461.xyz
│ ├── 5462.xyz
│ ├── 5463.xyz
│ ├── 5464.xyz
│ ├── 5465.xyz
│ ├── 5466.xyz
│ ├── 5467.xyz
│ ├── 5468.xyz
│ ├── 5469.xyz
│ ├── 5470.xyz
│ ├── 5471.xyz
│ ├── 5472.xyz
│ ├── 5473.xyz
│ ├── 5474.xyz
│ ├── 5475.xyz
│ ├── 5476.xyz
│ ├── 5477.xyz
│ ├── 5478.xyz
│ ├── 5479.xyz
│ ├── 5480.xyz
│ ├── 5481.xyz
│ ├── 5482.xyz
│ ├── 5483.xyz
│ ├── 5484.xyz
│ ├── 5485.xyz
│ ├── 5486.xyz
│ ├── 5487.xyz
│ ├── 5488.xyz
│ ├── 5489.xyz
│ ├── 5490.xyz
│ ├── 5491.xyz
│ ├── 5492.xyz
│ ├── 5493.xyz
│ ├── 5494.xyz
│ ├── 5495.xyz
│ ├── 5496.xyz
│ ├── 5497.xyz
│ ├── 5498.xyz
│ ├── 5499.xyz
│ ├── 5500.xyz
│ ├── 5501.xyz
│ ├── 5502.xyz
│ ├── 5503.xyz
│ ├── 5504.xyz
│ ├── 5505.xyz
│ ├── 5506.xyz
│ ├── 5507.xyz
│ ├── 5508.xyz
│ ├── 5509.xyz
│ ├── 5510.xyz
│ ├── 5511.xyz
│ ├── 5512.xyz
│ ├── 5513.xyz
│ ├── 5514.xyz
│ ├── 5515.xyz
│ ├── 5516.xyz
│ ├── 5517.xyz
│ ├── 5518.xyz
│ ├── 5519.xyz
│ ├── 5520.xyz
│ ├── 5521.xyz
│ ├── 5522.xyz
│ ├── 5523.xyz
│ ├── 5524.xyz
│ ├── 5525.xyz
│ ├── 5526.xyz
│ ├── 5527.xyz
│ ├── 5528.xyz
│ ├── 5529.xyz
│ ├── 5530.xyz
│ ├── 5531.xyz
│ ├── 5532.xyz
│ ├── 5533.xyz
│ ├── 5534.xyz
│ ├── 5535.xyz
│ ├── 5536.xyz
│ ├── 5537.xyz
│ ├── 5538.xyz
│ ├── 5539.xyz
│ ├── 5540.xyz
│ ├── 5541.xyz
│ ├── 5542.xyz
│ ├── 5543.xyz
│ ├── 5544.xyz
│ ├── 5545.xyz
│ ├── 5546.xyz
│ ├── 5547.xyz
│ ├── 5548.xyz
│ ├── 5549.xyz
│ ├── 5550.xyz
│ ├── 5551.xyz
│ ├── 5552.xyz
│ ├── 5553.xyz
│ ├── 5554.xyz
│ ├── 5555.xyz
│ ├── 5556.xyz
│ ├── 5557.xyz
│ ├── 5558.xyz
│ ├── 5559.xyz
│ ├── 5560.xyz
│ ├── 5561.xyz
│ ├── 5562.xyz
│ ├── 5563.xyz
│ ├── 5564.xyz
│ ├── 5565.xyz
│ ├── 5566.xyz
│ ├── 5567.xyz
│ ├── 5568.xyz
│ ├── 5569.xyz
│ ├── 5570.xyz
│ ├── 5571.xyz
│ ├── 5572.xyz
│ ├── 5573.xyz
│ ├── 5574.xyz
│ ├── 5575.xyz
│ ├── 5576.xyz
│ ├── 5577.xyz
│ ├── 5578.xyz
│ ├── 5579.xyz
│ ├── 5580.xyz
│ ├── 5581.xyz
│ ├── 5582.xyz
│ ├── 5583.xyz
│ ├── 5584.xyz
│ ├── 5585.xyz
│ ├── 5586.xyz
│ ├── 5587.xyz
│ ├── 5588.xyz
│ ├── 5589.xyz
│ ├── 5590.xyz
│ ├── 5591.xyz
│ ├── 5592.xyz
│ ├── 5593.xyz
│ ├── 5594.xyz
│ ├── 5595.xyz
│ ├── 5596.xyz
│ ├── 5597.xyz
│ ├── 5598.xyz
│ ├── 5599.xyz
│ ├── 5600.xyz
│ ├── 5601.xyz
│ ├── 5602.xyz
│ ├── 5603.xyz
│ ├── 5604.xyz
│ ├── 5605.xyz
│ ├── 5606.xyz
│ ├── 5607.xyz
│ ├── 5608.xyz
│ ├── 5609.xyz
│ ├── 5610.xyz
│ ├── 5611.xyz
│ ├── 5612.xyz
│ ├── 5613.xyz
│ ├── 5614.xyz
│ ├── 5615.xyz
│ ├── 5616.xyz
│ ├── 5617.xyz
│ ├── 5618.xyz
│ ├── 5619.xyz
│ ├── 5620.xyz
│ ├── 5621.xyz
│ ├── 5622.xyz
│ ├── 5623.xyz
│ ├── 5624.xyz
│ ├── 5625.xyz
│ ├── 5626.xyz
│ ├── 5627.xyz
│ ├── 5628.xyz
│ ├── 5629.xyz
│ ├── 5630.xyz
│ ├── 5631.xyz
│ ├── 5632.xyz
│ ├── 5633.xyz
│ ├── 5634.xyz
│ ├── 5635.xyz
│ ├── 5636.xyz
│ ├── 5637.xyz
│ ├── 5638.xyz
│ ├── 5639.xyz
│ ├── 5640.xyz
│ ├── 5641.xyz
│ ├── 5642.xyz
│ ├── 5643.xyz
│ ├── 5644.xyz
│ ├── 5645.xyz
│ ├── 5646.xyz
│ ├── 5647.xyz
│ ├── 5648.xyz
│ ├── 5649.xyz
│ ├── 5650.xyz
│ ├── 5651.xyz
│ ├── 5652.xyz
│ ├── 5653.xyz
│ ├── 5654.xyz
│ ├── 5655.xyz
│ ├── 5656.xyz
│ ├── 5657.xyz
│ ├── 5658.xyz
│ ├── 5659.xyz
│ ├── 5660.xyz
│ ├── 5661.xyz
│ ├── 5662.xyz
│ ├── 5663.xyz
│ ├── 5664.xyz
│ ├── 5665.xyz
│ ├── 5666.xyz
│ ├── 5667.xyz
│ ├── 5668.xyz
│ ├── 5669.xyz
│ ├── 5670.xyz
│ ├── 5671.xyz
│ ├── 5672.xyz
│ ├── 5673.xyz
│ ├── 5674.xyz
│ ├── 5675.xyz
│ ├── 5676.xyz
│ ├── 5677.xyz
│ ├── 5678.xyz
│ ├── 5679.xyz
│ ├── 5680.xyz
│ ├── 5681.xyz
│ ├── 5682.xyz
│ ├── 5683.xyz
│ ├── 5684.xyz
│ ├── 5685.xyz
│ ├── 5686.xyz
│ ├── 5687.xyz
│ ├── 5688.xyz
│ ├── 5689.xyz
│ ├── 5690.xyz
│ ├── 5691.xyz
│ ├── 5692.xyz
│ ├── 5693.xyz
│ ├── 5694.xyz
│ ├── 5695.xyz
│ ├── 5696.xyz
│ ├── 5697.xyz
│ ├── 5698.xyz
│ ├── 5699.xyz
│ ├── 5700.xyz
│ ├── 5701.xyz
│ ├── 5702.xyz
│ ├── 5703.xyz
│ ├── 5704.xyz
│ ├── 5705.xyz
│ ├── 5706.xyz
│ ├── 5707.xyz
│ ├── 5708.xyz
│ ├── 5709.xyz
│ ├── 5710.xyz
│ ├── 5711.xyz
│ ├── 5712.xyz
│ ├── 5713.xyz
│ ├── 5714.xyz
│ ├── 5715.xyz
│ ├── 5716.xyz
│ ├── 5717.xyz
│ ├── 5718.xyz
│ ├── 5719.xyz
│ ├── 5720.xyz
│ ├── 5721.xyz
│ ├── 5722.xyz
│ ├── 5723.xyz
│ ├── 5724.xyz
│ ├── 5725.xyz
│ ├── 5726.xyz
│ ├── 5727.xyz
│ ├── 5728.xyz
│ ├── 5729.xyz
│ ├── 5730.xyz
│ ├── 5731.xyz
│ ├── 5732.xyz
│ ├── 5733.xyz
│ ├── 5735.xyz
│ ├── 5736.xyz
│ ├── 5737.xyz
│ ├── 5738.xyz
│ ├── 5739.xyz
│ ├── 5740.xyz
│ ├── 5741.xyz
│ ├── 5742.xyz
│ ├── 5743.xyz
│ ├── 5744.xyz
│ ├── 5745.xyz
│ ├── 5746.xyz
│ ├── 5747.xyz
│ ├── 5748.xyz
│ ├── 5749.xyz
│ ├── 5750.xyz
│ ├── 5751.xyz
│ ├── 5752.xyz
│ ├── 5753.xyz
│ ├── 5754.xyz
│ ├── 5755.xyz
│ ├── 5756.xyz
│ ├── 5757.xyz
│ ├── 5758.xyz
│ ├── 5759.xyz
│ ├── 5760.xyz
│ ├── 5761.xyz
│ ├── 5762.xyz
│ ├── 5763.xyz
│ ├── 5764.xyz
│ ├── 5765.xyz
│ ├── 5766.xyz
│ ├── 5767.xyz
│ ├── 5768.xyz
│ ├── 5769.xyz
│ ├── 5770.xyz
│ ├── 5771.xyz
│ ├── 5772.xyz
│ ├── 5773.xyz
│ ├── 5774.xyz
│ ├── 5775.xyz
│ ├── 5776.xyz
│ ├── 5777.xyz
│ ├── 5778.xyz
│ ├── 5779.xyz
│ ├── 5780.xyz
│ ├── 5781.xyz
│ ├── 5782.xyz
│ ├── 5783.xyz
│ ├── 5784.xyz
│ ├── 5785.xyz
│ ├── 5786.xyz
│ ├── 5787.xyz
│ ├── 5788.xyz
│ ├── 5789.xyz
│ ├── 5790.xyz
│ ├── 5791.xyz
│ ├── 5792.xyz
│ ├── 5793.xyz
│ ├── 5794.xyz
│ ├── 5795.xyz
│ ├── 5796.xyz
│ ├── 5799.xyz
│ ├── 5800.xyz
│ ├── 5801.xyz
│ ├── 5802.xyz
│ ├── 5803.xyz
│ ├── 5804.xyz
│ ├── 5805.xyz
│ ├── 5806.xyz
│ ├── 5807.xyz
│ ├── 5808.xyz
│ ├── 5810.xyz
│ ├── 5811.xyz
│ ├── 5812.xyz
│ ├── 5813.xyz
│ ├── 5814.xyz
│ ├── 5815.xyz
│ ├── 5816.xyz
│ ├── 5817.xyz
│ ├── 5818.xyz
│ ├── 5819.xyz
│ ├── 5820.xyz
│ ├── 5821.xyz
│ ├── 5822.xyz
│ ├── 5823.xyz
│ ├── 5824.xyz
│ ├── 5825.xyz
│ ├── 5826.xyz
│ ├── 5827.xyz
│ ├── 5828.xyz
│ ├── 5829.xyz
│ ├── 5830.xyz
│ ├── 5831.xyz
│ ├── 5832.xyz
│ ├── 5833.xyz
│ ├── 5834.xyz
│ ├── 5835.xyz
│ ├── 5836.xyz
│ ├── 5837.xyz
│ ├── 5838.xyz
│ ├── 5839.xyz
│ ├── 5840.xyz
│ ├── 5841.xyz
│ ├── 5842.xyz
│ ├── 5843.xyz
│ ├── 5844.xyz
│ ├── 5845.xyz
│ ├── 5846.xyz
│ ├── 5847.xyz
│ ├── 5848.xyz
│ ├── 5849.xyz
│ ├── 5850.xyz
│ ├── 5851.xyz
│ ├── 5852.xyz
│ ├── 5853.xyz
│ ├── 5854.xyz
│ ├── 5855.xyz
│ ├── 5856.xyz
│ ├── 5857.xyz
│ ├── 5858.xyz
│ ├── 5859.xyz
│ ├── 5860.xyz
│ ├── 5861.xyz
│ ├── 5862.xyz
│ ├── 5863.xyz
│ ├── 5864.xyz
│ ├── 5865.xyz
│ ├── 5866.xyz
│ ├── 5867.xyz
│ ├── 5868.xyz
│ ├── 5869.xyz
│ ├── 5870.xyz
│ ├── 5871.xyz
│ ├── 5873.xyz
│ ├── 5874.xyz
│ ├── 5875.xyz
│ ├── 5876.xyz
│ ├── 5877.xyz
│ ├── 5878.xyz
│ ├── 5879.xyz
│ ├── 5880.xyz
│ ├── 5881.xyz
│ ├── 5882.xyz
│ ├── 5883.xyz
│ ├── 5884.xyz
│ ├── 5885.xyz
│ ├── 5886.xyz
│ ├── 5887.xyz
│ ├── 5888.xyz
│ ├── 5889.xyz
│ ├── 5890.xyz
│ ├── 5891.xyz
│ ├── 5892.xyz
│ ├── 5893.xyz
│ ├── 5894.xyz
│ ├── 5895.xyz
│ ├── 5896.xyz
│ ├── 5897.xyz
│ ├── 5898.xyz
│ ├── 5899.xyz
│ ├── 5900.xyz
│ ├── 5901.xyz
│ ├── 5902.xyz
│ ├── 5903.xyz
│ ├── 5904.xyz
│ ├── 5905.xyz
│ ├── 5906.xyz
│ ├── 5907.xyz
│ ├── 5908.xyz
│ ├── 5909.xyz
│ ├── 5910.xyz
│ ├── 5911.xyz
│ ├── 5912.xyz
│ ├── 5913.xyz
│ ├── 5914.xyz
│ ├── 5915.xyz
│ ├── 5916.xyz
│ ├── 5917.xyz
│ ├── 5918.xyz
│ ├── 5919.xyz
│ ├── 5920.xyz
│ ├── 5921.xyz
│ ├── 5922.xyz
│ ├── 5923.xyz
│ ├── 5924.xyz
│ ├── 5925.xyz
│ ├── 5926.xyz
│ ├── 5927.xyz
│ ├── 5928.xyz
│ ├── 5929.xyz
│ ├── 5930.xyz
│ ├── 5931.xyz
│ ├── 5932.xyz
│ ├── 5933.xyz
│ ├── 5934.xyz
│ ├── 5935.xyz
│ ├── 5936.xyz
│ ├── 5937.xyz
│ ├── 5938.xyz
│ ├── 5939.xyz
│ ├── 5940.xyz
│ ├── 5941.xyz
│ ├── 5942.xyz
│ ├── 5943.xyz
│ ├── 5944.xyz
│ ├── 5945.xyz
│ ├── 5946.xyz
│ ├── 5947.xyz
│ ├── 5948.xyz
│ ├── 5949.xyz
│ ├── 5950.xyz
│ ├── 5951.xyz
│ ├── 5952.xyz
│ ├── 5953.xyz
│ ├── 5954.xyz
│ ├── 5955.xyz
│ ├── 5956.xyz
│ ├── 5957.xyz
│ ├── 5958.xyz
│ ├── 5959.xyz
│ ├── 5960.xyz
│ ├── 5961.xyz
│ ├── 5962.xyz
│ ├── 5963.xyz
│ ├── 5964.xyz
│ ├── 5965.xyz
│ ├── 5966.xyz
│ ├── 5967.xyz
│ ├── 5968.xyz
│ ├── 5969.xyz
│ ├── 5970.xyz
│ ├── 5971.xyz
│ ├── 5972.xyz
│ ├── 5973.xyz
│ ├── 5974.xyz
│ ├── 5975.xyz
│ ├── 5976.xyz
│ ├── 5977.xyz
│ ├── 5978.xyz
│ ├── 5979.xyz
│ ├── 5980.xyz
│ ├── 5981.xyz
│ ├── 5982.xyz
│ ├── 5983.xyz
│ ├── 5984.xyz
│ ├── 5985.xyz
│ ├── 5986.xyz
│ ├── 5987.xyz
│ ├── 5988.xyz
│ ├── 5989.xyz
│ ├── 5990.xyz
│ ├── 5991.xyz
│ ├── 5992.xyz
│ ├── 5993.xyz
│ ├── 5994.xyz
│ ├── 5995.xyz
│ ├── 5996.xyz
│ ├── 5997.xyz
│ ├── 5998.xyz
│ ├── 5999.xyz
│ ├── 6000.xyz
│ ├── 6001.xyz
│ ├── 6002.xyz
│ ├── 6003.xyz
│ ├── 6004.xyz
│ ├── 6005.xyz
│ ├── 6006.xyz
│ ├── 6007.xyz
│ ├── 6008.xyz
│ ├── 6009.xyz
│ ├── 6010.xyz
│ ├── 6011.xyz
│ ├── 6012.xyz
│ ├── 6013.xyz
│ ├── 6014.xyz
│ ├── 6015.xyz
│ ├── 6016.xyz
│ ├── 6017.xyz
│ ├── 6018.xyz
│ ├── 6019.xyz
│ ├── 6020.xyz
│ ├── 6021.xyz
│ ├── 6022.xyz
│ ├── 6023.xyz
│ ├── 6024.xyz
│ ├── 6025.xyz
│ ├── 6026.xyz
│ ├── 6027.xyz
│ ├── 6028.xyz
│ ├── 6029.xyz
│ ├── 6030.xyz
│ ├── 6031.xyz
│ ├── 6032.xyz
│ ├── 6033.xyz
│ ├── 6034.xyz
│ ├── 6035.xyz
│ ├── 6036.xyz
│ ├── 6037.xyz
│ ├── 6038.xyz
│ ├── 6039.xyz
│ ├── 6040.xyz
│ ├── 6041.xyz
│ ├── 6042.xyz
│ ├── 6043.xyz
│ ├── 6044.xyz
│ ├── 6045.xyz
│ ├── 6046.xyz
│ ├── 6047.xyz
│ ├── 6048.xyz
│ ├── 6049.xyz
│ ├── 6050.xyz
│ ├── 6051.xyz
│ ├── 6052.xyz
│ ├── 6053.xyz
│ ├── 6054.xyz
│ ├── 6055.xyz
│ ├── 6056.xyz
│ ├── 6057.xyz
│ ├── 6058.xyz
│ ├── 6059.xyz
│ ├── 6060.xyz
│ ├── 6061.xyz
│ ├── 6062.xyz
│ ├── 6063.xyz
│ ├── 6064.xyz
│ ├── 6065.xyz
│ ├── 6066.xyz
│ ├── 6067.xyz
│ ├── 6068.xyz
│ ├── 6069.xyz
│ ├── 6070.xyz
│ ├── 6071.xyz
│ ├── 6072.xyz
│ ├── 6073.xyz
│ ├── 6074.xyz
│ ├── 6075.xyz
│ ├── 6076.xyz
│ ├── 6077.xyz
│ ├── 6078.xyz
│ ├── 6079.xyz
│ ├── 6080.xyz
│ ├── 6081.xyz
│ ├── 6082.xyz
│ ├── 6083.xyz
│ ├── 6085.xyz
│ ├── 6086.xyz
│ ├── 6087.xyz
│ ├── 6088.xyz
│ ├── 6089.xyz
│ ├── 6090.xyz
│ ├── 6091.xyz
│ ├── 6092.xyz
│ ├── 6093.xyz
│ ├── 6094.xyz
│ ├── 6095.xyz
│ ├── 6096.xyz
│ ├── 6097.xyz
│ ├── 6098.xyz
│ ├── 6099.xyz
│ ├── 6100.xyz
│ ├── 6101.xyz
│ ├── 6102.xyz
│ ├── 6103.xyz
│ ├── 6104.xyz
│ ├── 6105.xyz
│ ├── 6106.xyz
│ ├── 6107.xyz
│ ├── 6108.xyz
│ ├── 6109.xyz
│ ├── 6110.xyz
│ ├── 6111.xyz
│ ├── 6112.xyz
│ ├── 6113.xyz
│ ├── 6114.xyz
│ ├── 6115.xyz
│ ├── 6116.xyz
│ ├── 6117.xyz
│ ├── 6118.xyz
│ ├── 6119.xyz
│ ├── 6120.xyz
│ ├── 6121.xyz
│ ├── 6122.xyz
│ ├── 6123.xyz
│ ├── 6124.xyz
│ ├── 6125.xyz
│ ├── 6126.xyz
│ ├── 6127.xyz
│ ├── 6128.xyz
│ ├── 6129.xyz
│ ├── 6130.xyz
│ ├── 6131.xyz
│ ├── 6132.xyz
│ ├── 6133.xyz
│ ├── 6134.xyz
│ ├── 6135.xyz
│ ├── 6136.xyz
│ ├── 6137.xyz
│ ├── 6138.xyz
│ ├── 6139.xyz
│ ├── 6140.xyz
│ ├── 6141.xyz
│ ├── 6142.xyz
│ ├── 6143.xyz
│ ├── 6144.xyz
│ ├── 6145.xyz
│ ├── 6146.xyz
│ ├── 6147.xyz
│ ├── 6148.xyz
│ ├── 6149.xyz
│ ├── 6150.xyz
│ ├── 6151.xyz
│ ├── 6152.xyz
│ ├── 6153.xyz
│ ├── 6154.xyz
│ ├── 6155.xyz
│ ├── 6156.xyz
│ ├── 6157.xyz
│ ├── 6158.xyz
│ ├── 6159.xyz
│ ├── 6160.xyz
│ ├── 6161.xyz
│ ├── 6162.xyz
│ ├── 6163.xyz
│ ├── 6164.xyz
│ ├── 6165.xyz
│ ├── 6166.xyz
│ ├── 6167.xyz
│ ├── 6168.xyz
│ ├── 6169.xyz
│ ├── 6170.xyz
│ ├── 6171.xyz
│ ├── 6172.xyz
│ ├── 6173.xyz
│ ├── 6174.xyz
│ ├── 6175.xyz
│ ├── 6178.xyz
│ ├── 6179.xyz
│ ├── 6180.xyz
│ ├── 6181.xyz
│ ├── 6182.xyz
│ ├── 6183.xyz
│ ├── 6184.xyz
│ ├── 6185.xyz
│ ├── 6186.xyz
│ ├── 6187.xyz
│ ├── 6188.xyz
│ ├── 6189.xyz
│ ├── 6190.xyz
│ ├── 6191.xyz
│ ├── 6192.xyz
│ ├── 6193.xyz
│ ├── 6194.xyz
│ ├── 6195.xyz
│ ├── 6196.xyz
│ ├── 6197.xyz
│ ├── 6198.xyz
│ ├── 6199.xyz
│ ├── 6200.xyz
│ ├── 6201.xyz
│ ├── 6202.xyz
│ ├── 6203.xyz
│ ├── 6204.xyz
│ ├── 6205.xyz
│ ├── 6206.xyz
│ ├── 6207.xyz
│ ├── 6208.xyz
│ ├── 6209.xyz
│ ├── 6210.xyz
│ ├── 6211.xyz
│ ├── 6213.xyz
│ ├── 6214.xyz
│ ├── 6215.xyz
│ ├── 6216.xyz
│ ├── 6217.xyz
│ ├── 6218.xyz
│ ├── 6219.xyz
│ ├── 6220.xyz
│ ├── 6221.xyz
│ ├── 6222.xyz
│ ├── 6223.xyz
│ ├── 6224.xyz
│ ├── 6225.xyz
│ ├── 6226.xyz
│ ├── 6227.xyz
│ ├── 6228.xyz
│ ├── 6229.xyz
│ ├── 6230.xyz
│ ├── 6231.xyz
│ ├── 6232.xyz
│ ├── 6233.xyz
│ ├── 6234.xyz
│ ├── 6235.xyz
│ ├── 6236.xyz
│ ├── 6238.xyz
│ ├── 6239.xyz
│ ├── 6240.xyz
│ ├── 6241.xyz
│ ├── 6242.xyz
│ ├── 6243.xyz
│ ├── 6244.xyz
│ ├── 6245.xyz
│ ├── 6246.xyz
│ ├── 6247.xyz
│ ├── 6248.xyz
│ ├── 6249.xyz
│ ├── 6250.xyz
│ ├── 6251.xyz
│ ├── 6252.xyz
│ ├── 6253.xyz
│ ├── 6254.xyz
│ ├── 6255.xyz
│ ├── 6256.xyz
│ ├── 6257.xyz
│ ├── 6258.xyz
│ ├── 6259.xyz
│ ├── 6260.xyz
│ ├── 6261.xyz
│ ├── 6262.xyz
│ ├── 6263.xyz
│ ├── 6264.xyz
│ ├── 6265.xyz
│ ├── 6266.xyz
│ ├── 6267.xyz
│ ├── 6268.xyz
│ ├── 6269.xyz
│ ├── 6270.xyz
│ ├── 6271.xyz
│ ├── 6272.xyz
│ ├── 6273.xyz
│ ├── 6274.xyz
│ ├── 6275.xyz
│ ├── 6276.xyz
│ ├── 6277.xyz
│ ├── 6278.xyz
│ ├── 6279.xyz
│ ├── 6280.xyz
│ ├── 6281.xyz
│ ├── 6282.xyz
│ ├── 6283.xyz
│ ├── 6284.xyz
│ ├── 6285.xyz
│ ├── 6286.xyz
│ ├── 6287.xyz
│ ├── 6288.xyz
│ ├── 6289.xyz
│ ├── 6290.xyz
│ ├── 6291.xyz
│ ├── 6292.xyz
│ ├── 6293.xyz
│ ├── 6294.xyz
│ ├── 6295.xyz
│ ├── 6296.xyz
│ ├── 6297.xyz
│ ├── 6298.xyz
│ ├── 6299.xyz
│ ├── 6300.xyz
│ ├── 6301.xyz
│ ├── 6302.xyz
│ ├── 6303.xyz
│ ├── 6305.xyz
│ ├── 6306.xyz
│ ├── 6307.xyz
│ ├── 6308.xyz
│ ├── 6309.xyz
│ ├── 6310.xyz
│ ├── 6311.xyz
│ ├── 6312.xyz
│ ├── 6313.xyz
│ ├── 6314.xyz
│ ├── 6315.xyz
│ ├── 6316.xyz
│ ├── 6317.xyz
│ ├── 6318.xyz
│ ├── 6319.xyz
│ ├── 6320.xyz
│ ├── 6321.xyz
│ ├── 6322.xyz
│ ├── 6323.xyz
│ ├── 6324.xyz
│ ├── 6325.xyz
│ ├── 6326.xyz
│ ├── 6327.xyz
│ ├── 6328.xyz
│ ├── 6329.xyz
│ ├── 6330.xyz
│ ├── 6331.xyz
│ ├── 6332.xyz
│ ├── 6333.xyz
│ ├── 6334.xyz
│ ├── 6335.xyz
│ ├── 6336.xyz
│ ├── 6337.xyz
│ ├── 6338.xyz
│ ├── 6339.xyz
│ ├── 6340.xyz
│ ├── 6341.xyz
│ ├── 6342.xyz
│ ├── 6343.xyz
│ ├── 6344.xyz
│ ├── 6345.xyz
│ ├── 6346.xyz
│ ├── 6347.xyz
│ ├── 6348.xyz
│ ├── 6349.xyz
│ ├── 6350.xyz
│ ├── 6351.xyz
│ ├── 6352.xyz
│ ├── 6353.xyz
│ ├── 6354.xyz
│ ├── 6355.xyz
│ ├── 6356.xyz
│ ├── 6357.xyz
│ ├── 6358.xyz
│ ├── 6359.xyz
│ ├── 6360.xyz
│ ├── 6361.xyz
│ ├── 6362.xyz
│ ├── 6363.xyz
│ ├── 6364.xyz
│ ├── 6365.xyz
│ ├── 6366.xyz
│ ├── 6367.xyz
│ ├── 6368.xyz
│ ├── 6369.xyz
│ ├── 6370.xyz
│ ├── 6371.xyz
│ ├── 6372.xyz
│ ├── 6373.xyz
│ ├── 6374.xyz
│ ├── 6375.xyz
│ ├── 6376.xyz
│ ├── 6377.xyz
│ ├── 6378.xyz
│ ├── 6379.xyz
│ ├── 6380.xyz
│ ├── 6381.xyz
│ ├── 6382.xyz
│ ├── 6383.xyz
│ ├── 6384.xyz
│ ├── 6385.xyz
│ ├── 6386.xyz
│ ├── 6388.xyz
│ ├── 6389.xyz
│ ├── 6390.xyz
│ ├── 6391.xyz
│ ├── 6392.xyz
│ ├── 6393.xyz
│ ├── 6394.xyz
│ ├── 6395.xyz
│ ├── 6396.xyz
│ ├── 6397.xyz
│ ├── 6398.xyz
│ ├── 6399.xyz
│ ├── 6400.xyz
│ ├── 6401.xyz
│ ├── 6402.xyz
│ ├── 6403.xyz
│ ├── 6404.xyz
│ ├── 6405.xyz
│ ├── 6406.xyz
│ ├── 6407.xyz
│ ├── 6408.xyz
│ ├── 6409.xyz
│ ├── 6410.xyz
│ ├── 6411.xyz
│ ├── 6412.xyz
│ ├── 6413.xyz
│ ├── 6414.xyz
│ ├── 6415.xyz
│ ├── 6416.xyz
│ ├── 6417.xyz
│ ├── 6418.xyz
│ ├── 6419.xyz
│ ├── 6420.xyz
│ ├── 6421.xyz
│ ├── 6422.xyz
│ ├── 6424.xyz
│ ├── 6425.xyz
│ ├── 6426.xyz
│ ├── 6427.xyz
│ ├── 6428.xyz
│ ├── 6429.xyz
│ ├── 6430.xyz
│ ├── 6431.xyz
│ ├── 6432.xyz
│ ├── 6433.xyz
│ ├── 6434.xyz
│ ├── 6435.xyz
│ ├── 6436.xyz
│ ├── 6437.xyz
│ ├── 6438.xyz
│ ├── 6439.xyz
│ ├── 6440.xyz
│ ├── 6441.xyz
│ ├── 6442.xyz
│ ├── 6443.xyz
│ ├── 6444.xyz
│ ├── 6445.xyz
│ ├── 6446.xyz
│ ├── 6447.xyz
│ ├── 6448.xyz
│ ├── 6449.xyz
│ ├── 6450.xyz
│ ├── 6451.xyz
│ ├── 6452.xyz
│ ├── 6453.xyz
│ ├── 6454.xyz
│ ├── 6455.xyz
│ ├── 6456.xyz
│ ├── 6457.xyz
│ ├── 6458.xyz
│ ├── 6459.xyz
│ ├── 6460.xyz
│ ├── 6461.xyz
│ ├── 6462.xyz
│ ├── 6463.xyz
│ ├── 6464.xyz
│ ├── 6465.xyz
│ ├── 6466.xyz
│ ├── 6467.xyz
│ ├── 6468.xyz
│ ├── 6469.xyz
│ ├── 6470.xyz
│ ├── 6471.xyz
│ ├── 6472.xyz
│ ├── 6473.xyz
│ ├── 6474.xyz
│ ├── 6475.xyz
│ ├── 6476.xyz
│ ├── 6477.xyz
│ ├── 6478.xyz
│ ├── 6479.xyz
│ ├── 6480.xyz
│ ├── 6481.xyz
│ ├── 6482.xyz
│ ├── 6483.xyz
│ ├── 6484.xyz
│ ├── 6485.xyz
│ ├── 6486.xyz
│ ├── 6487.xyz
│ ├── 6488.xyz
│ ├── 6489.xyz
│ ├── 6490.xyz
│ ├── 6492.xyz
│ ├── 6493.xyz
│ ├── 6494.xyz
│ ├── 6495.xyz
│ ├── 6496.xyz
│ ├── 6497.xyz
│ ├── 6498.xyz
│ ├── 6499.xyz
│ ├── 6500.xyz
│ ├── 6501.xyz
│ ├── 6502.xyz
│ ├── 6503.xyz
│ ├── 6504.xyz
│ ├── 6505.xyz
│ ├── 6506.xyz
│ ├── 6507.xyz
│ ├── 6508.xyz
│ ├── 6509.xyz
│ ├── 6510.xyz
│ ├── 6511.xyz
│ ├── 6512.xyz
│ ├── 6513.xyz
│ ├── 6514.xyz
│ ├── 6515.xyz
│ ├── 6516.xyz
│ ├── 6517.xyz
│ ├── 6518.xyz
│ ├── 6519.xyz
│ ├── 6520.xyz
│ ├── 6521.xyz
│ ├── 6522.xyz
│ ├── 6523.xyz
│ ├── 6524.xyz
│ ├── 6525.xyz
│ ├── 6526.xyz
│ ├── 6527.xyz
│ ├── 6528.xyz
│ ├── 6529.xyz
│ ├── 6530.xyz
│ ├── 6531.xyz
│ ├── 6532.xyz
│ ├── 6533.xyz
│ ├── 6534.xyz
│ ├── 6535.xyz
│ ├── 6536.xyz
│ ├── 6537.xyz
│ ├── 6538.xyz
│ ├── 6539.xyz
│ ├── 6540.xyz
│ ├── 6541.xyz
│ ├── 6542.xyz
│ ├── 6543.xyz
│ ├── 6544.xyz
│ ├── 6545.xyz
│ ├── 6546.xyz
│ ├── 6547.xyz
│ ├── 6548.xyz
│ ├── 6549.xyz
│ ├── 6550.xyz
│ ├── 6551.xyz
│ ├── 6553.xyz
│ ├── 6554.xyz
│ ├── 6555.xyz
│ ├── 6556.xyz
│ ├── 6557.xyz
│ ├── 6558.xyz
│ ├── 6559.xyz
│ ├── 6560.xyz
│ ├── 6561.xyz
│ ├── 6562.xyz
│ ├── 6563.xyz
│ ├── 6564.xyz
│ ├── 6565.xyz
│ ├── 6566.xyz
│ ├── 6567.xyz
│ ├── 6568.xyz
│ ├── 6569.xyz
│ ├── 6570.xyz
│ ├── 6571.xyz
│ ├── 6572.xyz
│ ├── 6573.xyz
│ ├── 6574.xyz
│ ├── 6575.xyz
│ ├── 6576.xyz
│ ├── 6577.xyz
│ ├── 6578.xyz
│ ├── 6579.xyz
│ ├── 6580.xyz
│ ├── 6581.xyz
│ ├── 6582.xyz
│ ├── 6583.xyz
│ ├── 6584.xyz
│ ├── 6585.xyz
│ ├── 6586.xyz
│ ├── 6587.xyz
│ ├── 6588.xyz
│ ├── 6589.xyz
│ ├── 6590.xyz
│ ├── 6591.xyz
│ ├── 6592.xyz
│ ├── 6593.xyz
│ ├── 6594.xyz
│ ├── 6595.xyz
│ ├── 6596.xyz
│ ├── 6597.xyz
│ ├── 6598.xyz
│ ├── 6599.xyz
│ ├── 6600.xyz
│ ├── 6601.xyz
│ ├── 6602.xyz
│ ├── 6603.xyz
│ ├── 6604.xyz
│ ├── 6605.xyz
│ ├── 6606.xyz
│ ├── 6607.xyz
│ ├── 6608.xyz
│ ├── 6609.xyz
│ ├── 6610.xyz
│ ├── 6611.xyz
│ ├── 6612.xyz
│ ├── 6613.xyz
│ ├── 6614.xyz
│ ├── 6615.xyz
│ ├── 6616.xyz
│ ├── 6617.xyz
│ ├── 6618.xyz
│ ├── 6619.xyz
│ ├── 6620.xyz
│ ├── 6621.xyz
│ ├── 6622.xyz
│ ├── 6623.xyz
│ ├── 6624.xyz
│ ├── 6625.xyz
│ ├── 6626.xyz
│ ├── 6627.xyz
│ ├── 6628.xyz
│ ├── 6629.xyz
│ ├── 6630.xyz
│ ├── 6631.xyz
│ ├── 6632.xyz
│ ├── 6633.xyz
│ ├── 6634.xyz
│ ├── 6635.xyz
│ ├── 6636.xyz
│ ├── 6637.xyz
│ ├── 6638.xyz
│ ├── 6639.xyz
│ ├── 6640.xyz
│ ├── 6641.xyz
│ ├── 6642.xyz
│ ├── 6643.xyz
│ ├── 6644.xyz
│ ├── 6645.xyz
│ ├── 6646.xyz
│ ├── 6647.xyz
│ ├── 6648.xyz
│ ├── 6649.xyz
│ ├── 6650.xyz
│ ├── 6651.xyz
│ ├── 6652.xyz
│ ├── 6653.xyz
│ ├── 6654.xyz
│ ├── 6655.xyz
│ ├── 6656.xyz
│ ├── 6657.xyz
│ ├── 6658.xyz
│ ├── 6659.xyz
│ ├── 6660.xyz
│ ├── 6661.xyz
│ ├── 6662.xyz
│ ├── 6663.xyz
│ ├── 6664.xyz
│ ├── 6665.xyz
│ ├── 6666.xyz
│ ├── 6667.xyz
│ ├── 6668.xyz
│ ├── 6669.xyz
│ ├── 6670.xyz
│ ├── 6671.xyz
│ ├── 6672.xyz
│ ├── 6673.xyz
│ ├── 6674.xyz
│ ├── 6675.xyz
│ ├── 6676.xyz
│ ├── 6677.xyz
│ ├── 6678.xyz
│ ├── 6679.xyz
│ ├── 6680.xyz
│ ├── 6681.xyz
│ ├── 6682.xyz
│ ├── 6683.xyz
│ ├── 6685.xyz
│ ├── 6686.xyz
│ ├── 6687.xyz
│ ├── 6688.xyz
│ ├── 6689.xyz
│ ├── 6690.xyz
│ ├── 6691.xyz
│ ├── 6692.xyz
│ ├── 6693.xyz
│ ├── 6694.xyz
│ ├── 6695.xyz
│ ├── 6696.xyz
│ ├── 6697.xyz
│ ├── 6698.xyz
│ ├── 6699.xyz
│ ├── 6700.xyz
│ ├── 6701.xyz
│ ├── 6702.xyz
│ ├── 6703.xyz
│ ├── 6704.xyz
│ ├── 6705.xyz
│ ├── 6706.xyz
│ ├── 6707.xyz
│ ├── 6708.xyz
│ ├── 6709.xyz
│ ├── 6710.xyz
│ ├── 6711.xyz
│ ├── 6712.xyz
│ ├── 6713.xyz
│ ├── 6714.xyz
│ ├── 6715.xyz
│ ├── 6716.xyz
│ ├── 6717.xyz
│ ├── 6718.xyz
│ ├── 6719.xyz
│ ├── 6720.xyz
│ ├── 6721.xyz
│ ├── 6722.xyz
│ ├── 6723.xyz
│ ├── 6724.xyz
│ ├── 6726.xyz
│ ├── 6727.xyz
│ ├── 6728.xyz
│ ├── 6729.xyz
│ ├── 6730.xyz
│ ├── 6731.xyz
│ ├── 6732.xyz
│ ├── 6733.xyz
│ ├── 6734.xyz
│ ├── 6735.xyz
│ ├── 6736.xyz
│ ├── 6737.xyz
│ ├── 6738.xyz
│ ├── 6739.xyz
│ ├── 6740.xyz
│ ├── 6741.xyz
│ ├── 6742.xyz
│ ├── 6743.xyz
│ ├── 6744.xyz
│ ├── 6745.xyz
│ ├── 6746.xyz
│ ├── 6747.xyz
│ ├── 6748.xyz
│ ├── 6749.xyz
│ ├── 6750.xyz
│ ├── 6751.xyz
│ ├── 6752.xyz
│ ├── 6753.xyz
│ ├── 6754.xyz
│ ├── 6755.xyz
│ ├── 6756.xyz
│ ├── 6757.xyz
│ ├── 6758.xyz
│ ├── 6759.xyz
│ ├── 6760.xyz
│ ├── 6761.xyz
│ ├── 6762.xyz
│ ├── 6763.xyz
│ ├── 6764.xyz
│ ├── 6765.xyz
│ ├── 6766.xyz
│ ├── 6767.xyz
│ ├── 6768.xyz
│ ├── 6769.xyz
│ ├── 6770.xyz
│ ├── 6771.xyz
│ ├── 6772.xyz
│ ├── 6773.xyz
│ ├── 6774.xyz
│ ├── 6775.xyz
│ ├── 6776.xyz
│ ├── 6777.xyz
│ ├── 6778.xyz
│ ├── 6779.xyz
│ ├── 6780.xyz
│ ├── 6781.xyz
│ ├── 6782.xyz
│ ├── 6783.xyz
│ ├── 6784.xyz
│ ├── 6785.xyz
│ ├── 6786.xyz
│ ├── 6787.xyz
│ ├── 6788.xyz
│ ├── 6789.xyz
│ ├── 6790.xyz
│ ├── 6791.xyz
│ ├── 6792.xyz
│ ├── 6793.xyz
│ ├── 6794.xyz
│ ├── 6795.xyz
│ ├── 6796.xyz
│ ├── 6797.xyz
│ ├── 6798.xyz
│ ├── 6799.xyz
│ ├── 6800.xyz
│ ├── 6801.xyz
│ ├── 6802.xyz
│ ├── 6803.xyz
│ ├── 6804.xyz
│ ├── 6805.xyz
│ ├── 6806.xyz
│ ├── 6807.xyz
│ ├── 6808.xyz
│ ├── 6809.xyz
│ ├── 6810.xyz
│ ├── 6811.xyz
│ ├── 6812.xyz
│ ├── 6814.xyz
│ ├── 6815.xyz
│ ├── 6816.xyz
│ ├── 6817.xyz
│ ├── 6818.xyz
│ ├── 6819.xyz
│ ├── 6820.xyz
│ ├── 6821.xyz
│ ├── 6822.xyz
│ ├── 6823.xyz
│ ├── 6824.xyz
│ ├── 6825.xyz
│ ├── 6826.xyz
│ ├── 6827.xyz
│ ├── 6828.xyz
│ ├── 6829.xyz
│ ├── 6830.xyz
│ ├── 6831.xyz
│ ├── 6832.xyz
│ ├── 6833.xyz
│ ├── 6834.xyz
│ ├── 6835.xyz
│ ├── 6836.xyz
│ ├── 6837.xyz
│ ├── 6838.xyz
│ ├── 6839.xyz
│ ├── 6840.xyz
│ ├── 6841.xyz
│ ├── 6842.xyz
│ ├── 6843.xyz
│ ├── 6844.xyz
│ ├── 6845.xyz
│ ├── 6846.xyz
│ ├── 6847.xyz
│ ├── 6848.xyz
│ ├── 6849.xyz
│ ├── 6850.xyz
│ ├── 6851.xyz
│ ├── 6852.xyz
│ ├── 6853.xyz
│ ├── 6854.xyz
│ ├── 6855.xyz
│ ├── 6856.xyz
│ ├── 6857.xyz
│ ├── 6858.xyz
│ ├── 6859.xyz
│ ├── 6860.xyz
│ ├── 6861.xyz
│ ├── 6862.xyz
│ ├── 6863.xyz
│ ├── 6864.xyz
│ ├── 6865.xyz
│ ├── 6867.xyz
│ ├── 6868.xyz
│ ├── 6869.xyz
│ ├── 6870.xyz
│ ├── 6871.xyz
│ ├── 6872.xyz
│ ├── 6873.xyz
│ ├── 6874.xyz
│ ├── 6875.xyz
│ ├── 6876.xyz
│ ├── 6877.xyz
│ ├── 6878.xyz
│ ├── 6879.xyz
│ ├── 6880.xyz
│ ├── 6881.xyz
│ ├── 6882.xyz
│ ├── 6883.xyz
│ ├── 6884.xyz
│ ├── 6885.xyz
│ ├── 6886.xyz
│ ├── 6887.xyz
│ ├── 6888.xyz
│ ├── 6889.xyz
│ ├── 6890.xyz
│ ├── 6891.xyz
│ ├── 6893.xyz
│ ├── 6894.xyz
│ ├── 6895.xyz
│ ├── 6896.xyz
│ ├── 6897.xyz
│ ├── 6898.xyz
│ ├── 6899.xyz
│ ├── 6900.xyz
│ ├── 6901.xyz
│ ├── 6902.xyz
│ ├── 6903.xyz
│ ├── 6904.xyz
│ ├── 6905.xyz
│ ├── 6906.xyz
│ ├── 6907.xyz
│ ├── 6908.xyz
│ ├── 6909.xyz
│ ├── 6910.xyz
│ ├── 6911.xyz
│ ├── 6912.xyz
│ ├── 6913.xyz
│ ├── 6914.xyz
│ ├── 6915.xyz
│ ├── 6916.xyz
│ ├── 6917.xyz
│ ├── 6918.xyz
│ ├── 6919.xyz
│ ├── 6920.xyz
│ ├── 6921.xyz
│ ├── 6922.xyz
│ ├── 6923.xyz
│ ├── 6924.xyz
│ ├── 6925.xyz
│ ├── 6926.xyz
│ ├── 6927.xyz
│ ├── 6928.xyz
│ ├── 6929.xyz
│ ├── 6930.xyz
│ ├── 6931.xyz
│ ├── 6932.xyz
│ ├── 6933.xyz
│ ├── 6934.xyz
│ ├── 6935.xyz
│ ├── 6936.xyz
│ ├── 6937.xyz
│ ├── 6938.xyz
│ ├── 6939.xyz
│ ├── 6940.xyz
│ ├── 6941.xyz
│ ├── 6942.xyz
│ ├── 6943.xyz
│ ├── 6944.xyz
│ ├── 6945.xyz
│ ├── 6946.xyz
│ ├── 6947.xyz
│ ├── 6948.xyz
│ ├── 6949.xyz
│ ├── 6950.xyz
│ ├── 6951.xyz
│ ├── 6952.xyz
│ ├── 6953.xyz
│ ├── 6954.xyz
│ ├── 6955.xyz
│ ├── 6956.xyz
│ ├── 6957.xyz
│ ├── 6958.xyz
│ ├── 6959.xyz
│ ├── 6960.xyz
│ ├── 6961.xyz
│ ├── 6962.xyz
│ ├── 6963.xyz
│ ├── 6964.xyz
│ ├── 6965.xyz
│ ├── 6966.xyz
│ ├── 6967.xyz
│ ├── 6968.xyz
│ ├── 6969.xyz
│ ├── 6970.xyz
│ ├── 6971.xyz
│ ├── 6972.xyz
│ ├── 6973.xyz
│ ├── 6974.xyz
│ ├── 6975.xyz
│ ├── 6976.xyz
│ ├── 6977.xyz
│ ├── 6978.xyz
│ ├── 6979.xyz
│ ├── 6980.xyz
│ ├── 6981.xyz
│ ├── 6982.xyz
│ ├── 6983.xyz
│ ├── 6984.xyz
│ ├── 6985.xyz
│ ├── 6986.xyz
│ ├── 6987.xyz
│ ├── 6988.xyz
│ ├── 6989.xyz
│ ├── 6990.xyz
│ ├── 6991.xyz
│ ├── 6992.xyz
│ ├── 6993.xyz
│ ├── 6994.xyz
│ ├── 6995.xyz
│ ├── 6996.xyz
│ ├── 6997.xyz
│ ├── 6998.xyz
│ ├── 6999.xyz
│ ├── 7000.xyz
│ ├── 7001.xyz
│ ├── 7002.xyz
│ ├── 7003.xyz
│ ├── 7004.xyz
│ ├── 7005.xyz
│ ├── 7006.xyz
│ ├── 7007.xyz
│ ├── 7008.xyz
│ ├── 7009.xyz
│ ├── 7010.xyz
│ ├── 7011.xyz
│ ├── 7012.xyz
│ ├── 7013.xyz
│ ├── 7014.xyz
│ ├── 7015.xyz
│ ├── 7016.xyz
│ ├── 7017.xyz
│ ├── 7018.xyz
│ ├── 7019.xyz
│ ├── 7020.xyz
│ ├── 7021.xyz
│ ├── 7022.xyz
│ ├── 7023.xyz
│ ├── 7024.xyz
│ ├── 7025.xyz
│ ├── 7026.xyz
│ ├── 7027.xyz
│ ├── 7028.xyz
│ ├── 7029.xyz
│ ├── 7030.xyz
│ ├── 7031.xyz
│ ├── 7032.xyz
│ ├── 7033.xyz
│ ├── 7034.xyz
│ ├── 7035.xyz
│ ├── 7036.xyz
│ ├── 7037.xyz
│ ├── 7038.xyz
│ ├── 7039.xyz
│ ├── 7040.xyz
│ ├── 7041.xyz
│ ├── 7042.xyz
│ ├── 7043.xyz
│ ├── 7044.xyz
│ ├── 7045.xyz
│ ├── 7046.xyz
│ ├── 7047.xyz
│ ├── 7048.xyz
│ ├── 7049.xyz
│ ├── 7050.xyz
│ ├── 7051.xyz
│ ├── 7052.xyz
│ ├── 7053.xyz
│ ├── 7054.xyz
│ ├── 7055.xyz
│ ├── 7056.xyz
│ ├── 7057.xyz
│ ├── 7058.xyz
│ ├── 7059.xyz
│ ├── 7060.xyz
│ ├── 7061.xyz
│ ├── 7062.xyz
│ ├── 7063.xyz
│ ├── 7064.xyz
│ ├── 7065.xyz
│ ├── 7066.xyz
│ ├── 7067.xyz
│ ├── 7068.xyz
│ ├── 7069.xyz
│ ├── 7070.xyz
│ ├── 7071.xyz
│ ├── 7072.xyz
│ ├── 7073.xyz
│ ├── 7074.xyz
│ ├── 7075.xyz
│ ├── 7076.xyz
│ ├── 7077.xyz
│ ├── 7078.xyz
│ ├── 7079.xyz
│ ├── 7080.xyz
│ ├── 7081.xyz
│ ├── 7082.xyz
│ ├── 7083.xyz
│ ├── 7084.xyz
│ ├── 7085.xyz
│ ├── 7086.xyz
│ ├── 7087.xyz
│ ├── 7088.xyz
│ ├── 7089.xyz
│ ├── 7090.xyz
│ ├── 7091.xyz
│ ├── 7092.xyz
│ ├── 7093.xyz
│ ├── 7094.xyz
│ ├── 7095.xyz
│ ├── 7096.xyz
│ ├── 7097.xyz
│ ├── 7098.xyz
│ ├── 7099.xyz
│ ├── 7100.xyz
│ ├── 7101.xyz
│ ├── 7102.xyz
│ ├── 7103.xyz
│ ├── 7104.xyz
│ ├── 7105.xyz
│ ├── 7106.xyz
│ ├── 7107.xyz
│ ├── 7108.xyz
│ ├── 7109.xyz
│ ├── 7110.xyz
│ ├── 7111.xyz
│ ├── 7112.xyz
│ ├── 7113.xyz
│ ├── 7114.xyz
│ ├── 7115.xyz
│ ├── 7116.xyz
│ ├── 7117.xyz
│ ├── 7118.xyz
│ ├── 7119.xyz
│ ├── 7120.xyz
│ ├── 7121.xyz
│ ├── 7122.xyz
│ ├── 7123.xyz
│ ├── 7124.xyz
│ ├── 7125.xyz
│ ├── 7126.xyz
│ ├── 7127.xyz
│ ├── 7128.xyz
│ ├── 7129.xyz
│ ├── 7130.xyz
│ ├── 7131.xyz
│ ├── 7132.xyz
│ ├── 7133.xyz
│ ├── 7134.xyz
│ ├── 7135.xyz
│ ├── 7136.xyz
│ ├── 7137.xyz
│ ├── 7138.xyz
│ ├── 7139.xyz
│ ├── 7140.xyz
│ ├── 7141.xyz
│ ├── 7142.xyz
│ ├── 7143.xyz
│ ├── 7144.xyz
│ ├── 7145.xyz
│ ├── 7146.xyz
│ ├── 7147.xyz
│ ├── 7148.xyz
│ ├── 7149.xyz
│ ├── 7150.xyz
│ ├── 7151.xyz
│ ├── 7152.xyz
│ ├── 7153.xyz
│ ├── 7154.xyz
│ ├── 7155.xyz
│ ├── 7156.xyz
│ ├── 7157.xyz
│ ├── 7158.xyz
│ ├── 7159.xyz
│ ├── 7160.xyz
│ ├── 7161.xyz
│ ├── 7162.xyz
│ ├── 7163.xyz
│ ├── 7164.xyz
│ ├── 7165.xyz
│ ├── 7166.xyz
│ ├── 7167.xyz
│ ├── 7168.xyz
│ ├── 7169.xyz
│ ├── 7170.xyz
│ ├── 7171.xyz
│ └── 7172.xyz
├── saved_model/
│ ├── saved_model.pb
│ └── variables/
│ ├── variables.data-00000-of-00001
│ └── variables.index
├── test_acsf.py
├── test_acsf_linear_angles.py
├── test_arad.py
├── test_armp.py
├── test_compound.py
├── test_distance.py
├── test_energy_krr_atomic_cmat.py
├── test_energy_krr_bob.py
├── test_energy_krr_cmat.py
├── test_fchl_acsf.py
├── test_fchl_acsf_energy.py
├── test_fchl_acsf_forces.py
├── test_fchl_electric_field.py
├── test_fchl_force.py
├── test_fchl_scalar.py
├── test_kernel_derivatives.py
├── test_kernels.py
├── test_math.py
├── test_mrmp.py
├── test_neural_network.py
├── test_representations.py
├── test_slatm.py
└── test_symm_funct.py
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitignore
================================================
# Byte-compiled / optimized / DLL files
__pycache__/
*.py[cod]
*$py.class
# pytest
.pytest_cache/
# C extensions
*.so
# Distribution / packaging
.Python
build/
develop-eggs/
dist/
downloads/
eggs/
.eggs/
lib/
lib64/
parts/
sdist/
var/
wheels/
*.egg-info/
.installed.cfg
*.egg
MANIFEST
# PyInstaller
# Usually these files are written by a python script from a template
# before PyInstaller builds the exe, so as to inject date/other infos into it.
*.manifest
*.spec
# Installer logs
pip-log.txt
pip-delete-this-directory.txt
# Unit test / coverage reports
htmlcov/
.tox/
.coverage
.coverage.*
.cache
nosetests.xml
coverage.xml
*.cover
.hypothesis/
.pytest_cache/
# Translations
*.mo
*.pot
# Django stuff:
*.log
local_settings.py
db.sqlite3
# Flask stuff:
instance/
.webassets-cache
# Scrapy stuff:
.scrapy
# Sphinx documentation
docs/build/
docs/_build/
# PyBuilder
target/
# Jupyter Notebook
.ipynb_checkpoints
# pyenv
.python-version
# celery beat schedule file
celerybeat-schedule
# SageMath parsed files
*.sage.py
# Environments
.env
.venv
env/
venv/
ENV/
env.bak/
venv.bak/
# Spyder project settings
.spyderproject
.spyproject
# Rope project settings
.ropeproject
# mkdocs documentation
/site
# mypy
.mypy_cache/
# Pycharm
.idea/
================================================
FILE: .travis.yml
================================================
language: python
sudo: required
dist: trusty
group: edge
deploy:
provider: pages
# local_dir: ${TRAVIS_BUILD_DIR}/docs/build/html
local_dir: /docs/build/html
skip_cleanup: true
repo: qmlcode/qmlcode.github.io
target_branch: master
github_token: ${GH_TOKEN} # Set in travis-ci.org dashboard
on:
branch: master
# condition: ${TRAVIS_PYTHON_VERSION} = "3.6"
python:
- "3.6"
before_install:
- sudo apt-get update -qq
install:
- sudo apt-get install -qq gcc gfortran libblas-dev liblapack-dev
- sudo apt-get install -qq gcc-4.8 gfortran-4.8
- sudo apt install pandoc
- sudo apt-get install python3-numpy
- pip3 install scipy
- pip3 install ase
- pip3 install pandas
- pip3 install scikit-learn
- pip3 install tensorflow
- pip install --upgrade attrs==19.1.0
- python3 setup.py build
- python3 setup.py install
- pip3 install sphinx
- pip3 install nbsphinx
- pip3 install sphinx-rtd-theme
- cd ${TRAVIS_BUILD_DIR}/docs
- make html
before_script:
- cd ${TRAVIS_BUILD_DIR}/test/
script:
- pytest -v
notifications:
email: false
================================================
FILE: LICENSE
================================================
MIT License
Copyright (c) 2017 Anders Steen Christensen, Felix Faber, O.Anatole von Lilienfeld
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
================================================
FILE: README.rst
================================================
QML: A Python Toolkit for Quantum Machine Learning
==================================================
.. attention::
Further development of the QML package is now in the https://github.com/qmlcode/qmllib repository.
The pip-package ``qmllib`` is a streamlined version of QML's Fortran core functionality with fewer dependencies, and compatible with numpy 2.0. We'd like to encourage you to direct any future issues or pull requests to the new repository. **This repository is now archived**.
Both the ``master`` and ``develop`` branches have been left for the archive.
================================================
FILE: docs/Makefile
================================================
# Minimal makefile for Sphinx documentation
#
# You can set these variables from the command line.
SPHINXOPTS =
SPHINXBUILD = python3 -msphinx
SPHINXPROJ = QML
SOURCEDIR = source
BUILDDIR = build
# Put it first so that "make" without argument is like "make help".
help:
@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
.PHONY: help Makefile
# Catch-all target: route all unknown targets to Sphinx using the new
# "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS).
%: Makefile
@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
touch build/html/.nojekyll
echo "www.qmlcode.org" > build/html/CNAME
================================================
FILE: docs/source/citation.rst
================================================
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:
::
AS Christensen, LA Bratholm, S Amabilino, JC Kromann, FA Faber, B Huang, GR Glowacki, A Tkatchenko, K.R. Muller, OA von Lilienfeld (2018) "QML: A Python Toolkit for Quantum Machine Learning" https://github.com/qmlcode/qml
================================================
FILE: docs/source/conf.py
================================================
# -*- coding: utf-8 -*-
#
# QML documentation build configuration file, created by
# sphinx-quickstart on Sun Jun 4 14:41:04 2017.
#
# This file is execfile()d with the current directory set to its
# containing dir.
#
# Note that not all possible configuration values are present in this
# autogenerated file.
#
# All configuration values have a default; values that are commented out
# serve to show the default.
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
#
from __future__ import print_function
import os
import sys
print(os.getcwd())
# sys.path.insert(0, os.path.abspath('../../build/lib.linux-x86_64-2.7/'))
import sphinx_rtd_theme
# -- General configuration ------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
#
# needs_sphinx = '1.5.4'
# Add any Sphinx extension module names here, as strings. They can be
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
# ones.
extensions = ['sphinx.ext.autodoc','sphinx.ext.mathjax', 'nbsphinx']
# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']
# The suffix(es) of source filenames.
# You can specify multiple suffix as a list of string:
#
# source_suffix = ['.rst', '.md']
source_suffix = '.rst'
# The master toctree document.
master_doc = 'index'
# General information about the project.
project = u'QML'
copyright = u'2016-2018, Anders S. Christensen'
author = u'Anders S. Christensen'
# The version info for the project you're documenting, acts as replacement for
# |version| and |release|, also used in various other places throughout the
# built documents.
#
# The short X.Y version.
iversion = u'0.5.0.0'
# The full version, including alpha/beta/rc tags.
release = u'0.5.0.0'
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
#
# This is also used if you do content translation via gettext catalogs.
# Usually you set "language" from the command line for these cases.
language = None
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
# This patterns also effect to html_static_path and html_extra_path
exclude_patterns = ['**.ipynb_checkpoints']
# The name of the Pygments (syntax highlighting) style to use.
pygments_style = 'sphinx'
# If true, `todo` and `todoList` produce output, else they produce nothing.
todo_include_todos = False
# -- Options for HTML output ----------------------------------------------
# The theme to use for HTML and HTML Help pages. See the documentation for
# a list of builtin themes.
#
# html_theme = 'alabaster'
html_theme = "sphinx_rtd_theme"
html_theme_path = [sphinx_rtd_theme.get_html_theme_path()]
# Theme options are theme-specific and customize the look and feel of a theme
# further. For a list of options available for each theme, see the
# documentation.
#
# html_theme_options = {}
# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
# html_static_path = ['_static']
# -- Options for HTMLHelp output ------------------------------------------
# Output file base name for HTML help builder.
htmlhelp_basename = 'QMLdoc'
# -- Options for LaTeX output ---------------------------------------------
latex_elements = {
# The paper size ('letterpaper' or 'a4paper').
#
# 'papersize': 'letterpaper',
# The font size ('10pt', '11pt' or '12pt').
#
# 'pointsize': '10pt',
# Additional stuff for the LaTeX preamble.
#
# 'preamble': '',
# Latex figure (float) alignment
#
# 'figure_align': 'htbp',
}
# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title,
# author, documentclass [howto, manual, or own class]).
latex_documents = [
(master_doc, 'QML.tex', u'QML Documentation',
u'Anders S. Christensen', 'manual'),
]
# -- Options for manual page output ---------------------------------------
# One entry per manual page. List of tuples
# (source start file, name, description, authors, manual section).
man_pages = [
(master_doc, 'qml', u'QML Documentation',
[author], 1)
]
# -- Options for Texinfo output -------------------------------------------
# Grouping the document tree into Texinfo files. List of tuples
# (source start file, target name, title, author,
# dir menu entry, description, category)
texinfo_documents = [
(master_doc, 'QML', u'QML Documentation',
author, 'QML', 'One line description of project.',
'Miscellaneous'),
]
html_sidebars = { '**': ['globaltoc.html', 'relations.html', 'sourcelink.html', 'searchbox.html'], }
# -- Options for nbsphinx --------------------------------------------------
nbsphinx_execute = 'never'
================================================
FILE: docs/source/force_kernels.rst
================================================
FCHL19 and force kernels
------------------------
This is a tutorial that shows the FCHL19 representation and corresponding kernels. See the paper (not yet on arxiv) for details on the representation.
Representation
~~~~~~~~~~~~~~
Generating the representation
"""""""""""""""""""""""""""""
.. code:: python
import qml
from qml.representations import generate_fchl_acsf
# Dummy coordinates for a water molecule
coordinates = np.array([[1.464, 0.707, 1.056],
[0.878, 1.218, 0.498],
[2.319, 1.126, 0.952]])
# Oxygen, Hydrogen, Hydrogen
nuclear_charges = np.array([8, 1, 1])
# Generate representations for the atoms in the water molecule
rep = generate_fchl_acsf(nuclear_charges, coordinates)
print(rep)
print(rep.shape)
Should print the following output:
.. code:: python
[[1.16160253e+00 2.11737093e+00 1.42984457e+00 ... 0.00000000e+00
0.00000000e+00 0.00000000e+00]
[4.73880430e-04 8.12967740e-02 3.00106360e-01 ... 0.00000000e+00
0.00000000e+00 0.00000000e+00]
[4.73880430e-04 8.12967740e-02 3.00106360e-01 ... 0.00000000e+00
0.00000000e+00 0.00000000e+00]]
(3, 720)
The representation requires you to specify a list of the possible elements that are in your training/test set. The default is :math:`[1,6,7,8,16]`. The representation increases in in the order of :math:`\mathcal{O}(n^2)` with the number of elements in the list, so it is beneficial to only include the minimal set. In the above example, the vector for each of the three atoms is of length 720. The size can be reduced by only including the elements 1 and 8 (hydrogen and oxygen).
.. code:: python
# Generate a minimal representations for the atoms in the water molecule
rep = generate_fchl_acsf(nuclear_charges, coordinates, elements=[1,8])
print(rep)
print(rep.shape)
Should print the following output:
.. code:: python
[[1.16160253e+00 2.11737093e+00 1.42984457e+00 ... 0.00000000e+00
0.00000000e+00 0.00000000e+00]
[4.73880430e-04 8.12967740e-02 3.00106360e-01 ... 0.00000000e+00
0.00000000e+00 0.00000000e+00]
[4.73880430e-04 8.12967740e-02 3.00106360e-01 ... 0.00000000e+00
0.00000000e+00 0.00000000e+00]]
(3, 168)
The size of the representation is reduced to 168.
Generating the derivative of the representation
"""""""""""""""""""""""""""""
In order to learn and predict forces, it is necessary to also generate the derivatives of the representation with respect to the nuclear coordinates.
This is done with the additional keyword argument ``gradients=True``.
.. code:: python
# Generate a minimal representations and their derivatives for the atoms in the water molecule
rep, drep = generate_fchl_acsf(nuclear_charges, coordinates, gradients=True, elements=[1,8])
print(rep)
print(rep.shape)
print(drep)
print(drep.shape)
Should print the following output:
.. code:: python
[[1.16160253e+00 2.11737093e+00 1.42984457e+00 ... 0.00000000e+00
0.00000000e+00 0.00000000e+00]
[4.73880430e-04 8.12967740e-02 3.00106360e-01 ... 0.00000000e+00
0.00000000e+00 0.00000000e+00]
[4.73880430e-04 8.12967740e-02 3.00106360e-01 ... 0.00000000e+00
0.00000000e+00 0.00000000e+00]]
(3, 168)
[[[[ 1.20693828e+00 4.23137322e+00 -3.01650346e+00]
[ 2.67232755e+00 -2.33030611e+00 2.54463954e+00]
[-3.87926583e+00 -1.90106712e+00 4.71863914e-01]]
...
[[ 0.00000000e+00 0.00000000e+00 0.00000000e+00]
[ 0.00000000e+00 0.00000000e+00 0.00000000e+00]
[ 0.00000000e+00 0.00000000e+00 0.00000000e+00]]]]
(3, 168, 3, 3)
Additional parameters
"""""""""""""""""""""
The representation contains a number of parameters, which can be optimized in order to improve the accuracy of the resulting machine learning model.
The default parameters are optimized for forces on a set of small molecules (see arXiv paper), and will work well for most cases.
Additionally, we also found a different set if parameters to work well for energy learning.
.. code:: python
# Energy-optimized kwargs
kwargs_energy = {
'nRs2': 22,
'nRs3': 17,
'eta2': 0.41,
'eta3': 0.97,
'three_body_weight': 45.83,
'three_body_decay': 2.39,
'two_body_decay': 2.39,
}
# Generate energy-optimized representation for water
rep = generate_fchl_acsf(nuclear_charges, coordinates, elements=[1,8], **kwargs_energy)
Kernels
~~~~~~~
The kernel functions implemented for the representation is a Gaussian function which only compares atomic environments of atoms of the same element type, that is:
:math:`k(\mathbf{q}_I,\mathbf{q}_{J}^{*}) = \delta_{Z_I Z_{J}^{*}} \exp\left(-\frac{\| \mathbf{q}_I - \mathbf{q}_{J}^{*} \|^2_2}{2\sigma^2}\right)`
where :math:`Z_i` and :math:`Z_j` are the nuclear charges of the atoms :math:`i` and :math:`j`.
The ``QML.kernels`` module contains functions to generate kernel functions a number of machine learning approaches as detailed below.
In all cases, the resulting kernels are simply matrices in numpy's ``ndarray`` format.
Kernel Ridge Regression
"""""""""""""""""""""""
Regression model of some property, :math:`U`, for some system, this could correspond to e.g. the atomization energy of a molecule:
:math:`\boldsymbol{\alpha} = (\mathbf{K} + \lambda \mathbf{I})^{-1} \mathbf{U}`
.. code:: python
# Generate representations
reps = np.array([generate_fchl_acsf(mol.nuclear_charges, mol.coordinates, pad=23) for mol in mols]
# Generate lists of nuclear charges
charges = [mol.nuclear_charges for mol in mols]
# Energies for each molecule
energies = np.array([mol.energy for mol in mols])
# Divide in training and test representations
X = reps[:100]
Xs = reps[100:]
# Divide in training and test nuclear charges
Q = nuclear_charges[:100]
Qs = nuclear_charges[100:]
# Divide in training and test energies
U = energies[:100]
Us = energies[100:]
The training kernel is symmetrical and can be calculated faster by using the dedicated kernel function that only calculates the upper triangle.
The test kernel is not symmetrical, and the ordering is first representations/charges for the basis functions (usually the same as the training set), and secondly the query representations/charges.
Additionally, the functions take a kernel width (sigma) as argument.
A minimal kernel ridge regression program is as follows:
.. code:: python
from qml.kernels import get_local_kernel
from qml.kernels import get_local_symmetric_kernel
from qml.math import cho_solve
# Example kernel width
sigma = 20.0
# Generate training and test kernel
K_training = get_local_symmetric_kernel(X, Q, sigma)
K_test = get_local_kernel(X, Xs, Q, Qs, sigma)
# Solve the regression using lambda=1e-9
alphas = cho_solve(K_training, U, l2reg=1e-9)
# Make predictions using the test kernel
U_test = np.dot(K_test, alphas)
Response Operators
""""""""""""""""""
QML with response operators expand the learned properties in a basis of kernel functions centered on the atoms of the training set.
For example, the equation that simultaneously describes the energy (F) and forces (F) of a system is:
.. math::
\begin{bmatrix}
\mathbf{U} \\
\mathbf{F}
\end{bmatrix} = \begin{bmatrix}
\mathbf{K}^{a,u*} \\
\mathbf{K}^{a,g*}
\end{bmatrix} \alpha
Here, the subscripts relate to the two dimensions of the kernel matrices. :math:`a` denotes the first dimension consists of the kernel functions centered on the atomic environments, and :math:`u` and :math:`g` denotes that the second dimension are the zeroth and first derivative of the kernel, respectively.
In addition to the list of representations, nuclear charges and energies in the above example, we also need to generate arrays containgin the derivatives of the representations as well as the derivatives of the energy (the forces).
.. code:: python
# Forces for each molecule
forces = [mol.properties for mol in mols]
# Generate derivatives of representations
dreps = np.array([generate_fchl_acsf(mol.nuclear_charges, mol.coordinates, gradients=True, pad=23)[1] for mol in mols]
# Divide in training and test derivatives
dX = dreps[:100]
dXs = dreps[100:]
# Divide in training and test forces (and flatten to 1-D)
F = np.concatenate(forces[100:]).flatten()
Fs = np.concatenate(forces[:100]).flatten()
A minimal program to train and predict energies and forces with response operator kernels:
.. code:: python
from qml.kernels import get_atomic_local_gradient_kernel
from qml.kernels import get_atomic_local_kernel
from qml.math import svd_solve
# Example kernel width
sigma = 20.0
# Generate training and test kernel for energies
Ke = get_atomic_local_kernel(X, X, Q, Q, SIGMA)
Kes = get_atomic_local_kernel(X, Xs, Q, Qs, SIGMA)
# Generate training and test kernel for forces - note that only
# one set of derivatives is required
Kf = get_atomic_local_gradient_kernel(X, X, dX, Q, Q, SIGMA)
Kfs = get_atomic_local_gradient_kernel(X, Xs, dXs, Q, Qs, SIGMA)
# Concatenate energy and force kernels for the training set
C = np.concatenate(Ke, Kf)
# Concatenate matching energy and force labels
Y = np.concatenate(U, F)
# Solve the regression ignoring singular values smaller than 1e-9
alphas = svd_solve(C, Y, rcond=1e-9)
# Make energy predictions using the test energy kernel
U_test = np.dot(Kes, alphas)
# Make force predictions using the test force kernel
F_test = np.dot(Kfs, alphas)
Gaussian Process Regression
"""""""""""""""""""""""""""
Gaussian process regression with derivatives works similarly to the response operators in the above example.
The only difference is that the basis set consists of kernels placed on the molecules in the training set (rather than the atoms), as well as placed on their derivatives.
The resulting kernel is roughly 3x larger, and requires evaluation of the second derivative of the kernel, but is also usually more accurate, especially for small training set sizes.
.. math::
\begin{bmatrix}
\mathbf{U} \\
\mathbf{F}
\end{bmatrix} = \begin{bmatrix}
\mathbf{K}^{u,u*} && \mathbf{K}^{u,g*} \\
\mathbf{K}^{g,u*} && \mathbf{K}^{g,g*}
\end{bmatrix} \alpha
A minimal program to train and predict energies and forces with Gaussian proces regression:
.. code:: python
from qml.kernels import get_symmetric_gp_kernel
from qml.kernels import get_gp_kernel
from qml.math import cho_solve
# Example kernel width
sigma = 20.0
# Generate training and test kernel for energies
K_train = get_symmetric_gp_kernel(X, dX, Q, SIGMA)
K_test = get_gp_kernel(X, Xs, dX, dXs, Q, Qs, SIGMA)
# Concatenate matching energy and force labels
Y = np.concatenate(U, F)
# Solve alpha coefficients
alphas = cho_solve(K_train, Y, l2reg=1e-9)
# Make predictions using the test energy kernel
Y_test = np.dot(K_test, alphas)
# Get test energies and forces from the prediction
U_test = Y_test[:100]
F_test = Y_test[100:]
================================================
FILE: docs/source/index.rst
================================================
.. QML documentation master file, created by
sphinx-quickstart on Sun Jun 4 14:41:04 2017.
You can adapt this file completely to your liking, but it should at least
contain the root `toctree` directive.
|Build Status| |pypi| |doi| |Beta|
QML: A Python Toolkit for Quantum Machine Learning
==================================================
QML is a Python2/3-compatible toolkit for representation learning of
properties of molecules and solids. QML supplies the the building blocks to
carry out efficient and accurate machine learning on chemical compounds.
The goal is to provide usable and efficient implementations of
concepts such as representations and kernels as well as a high level interface
to make it easy for computational chemists to use these for machine-learning tasks.
Current list of contributors:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
- Anders S. Christensen (University of Basel)
- Lars A. Bratholm (University of Bristol)
- Silvia Amabilino (University of Bristol)
- Jimmy C. Kromann (University of Basel)
- Felix A. Faber (University of Basel)
- Bing Huang (University of Basel)
- David R. Glowacki (University of Bristol)
- Alexandre Tkatchenko (University of Luxembourg)
- Klaus-Robert Müller (Technische Universitat Berlin/Korea University)
- \O. Anatole von Lilienfeld (University of Basel)
Code development
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
The QML code is developed through our GitHub repository:
https://github.com/qmlcode/qml
------------------------------
Please add you code to QML by forking and making pull-requests to the "develop" branch.
Every now and then develop branch is pushed to the "master" branch and automatically deployed to PyPI, where the latest stable version is hosted.
See the "Installing QML" page for up-to-date installation instructions.
Citing QML:
--------------
Until the preprint is available from arXiv, please cite use of QML as:
::
AS Christensen, LA Bratholm, S Amabilino, JC Kromann, FA Faber, B Huang, GR Glowacki, A Tkatchenko, K.R. Muller, OA von Lilienfeld (2018) "QML: A Python Toolkit for Quantum Machine Learning" https://github.com/qmlcode/qml
For citation of the individual procedures of QML, please see the "Citing use of QML" section.
.. toctree::
:maxdepth: 2
:caption: GETTING STARTED:
:name: index
installation
citation
tutorial
force_kernels
qml_examples/examples
.. toctree::
:maxdepth: 2
:caption: SOURCE DOCUMENTATION:
:name: qml
qml
License:
-----------
QML is freely available under the terms of the MIT license.
.. |Build Status| image:: https://travis-ci.org/qmlcode/qml.svg?branch=master
:target: https://travis-ci.org/qmlcode/qml
.. |doi| image:: https://zenodo.org/badge/89045103.svg
:target: https://zenodo.org/badge/latestdoi/89045103
.. |Beta| image:: http://i.imgur.com/5fMAeek.jpg
:width: 90 px
:target: https://github.com/qmlcode/qml
.. |Pypi| image:: https://badge.fury.io/py/qml.svg
:target: https://badge.fury.io/py/qml
================================================
FILE: docs/source/installation.rst
================================================
Installing QML
---------------
Installing prerequisite modules (for most Linux systems):
.. code:: bash
sudo apt-get install python-pip gfortran libblas-dev liblapack-dev
These should already be installed on most systems. The Intel compilers
and MKL math-libraries are supported as well (see section 1.3).
**Additional note:**
For running neural networks, TensorFlow 1.8 is required. Pip does not automatically instal TF, so one should follow
`these ` instructions.
Installing via ``pip``
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
The easiest way to install the stable version from the Python Package
Index (PyPI) is using the official, built-in Python package manager,
``pip``:
.. code:: bash
pip install qml --user -U
To use the Intel compiler, together with the MKL math library:
In addition to the stable version available from the official PyPI repository, you can install the most recent stable development snapshot directly from GitHub:
.. code:: bash
pip install git+https://github.com/qmlcode/qml@develop --user -U
Use ``pip2 install ...`` or ``pip3 install ...`` to get the Python2 or
Python3 versions explicitly. QML supports both flavors.
To uninstall simply use ``pip`` again.
.. code:: bash
pip uninstall qml
Installing via with Intel compilers
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
If you have Intel compilers installed (2016 and newer), you can compile
QML with Ifort/MKL from PyPI using the following options:
.. code:: bash
pip install qml --user -U --global-option="build" --global-option="--compiler=intelem" --global-option="--fcompiler=intelem"
Or alternatively the `develop` branch from GitHub:
.. code:: bash
pip install git+https://github.com/qmlcode/qml@develop --user -U --global-option="build" --global-option="--compiler=intelem" --global-option="--fcompiler=intelem"
Note on Apple/Mac support
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Installing QML requires a Fortran compiler. On MacOS you can install it
using ``brew``:
.. code:: bash
# Update brew
/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
# Install GCC
brew install gcc
Note the Fortran compiler from brew (gfortran) unfortunately does not support OpenMP.
Therefore parallelism via OpenMP is disabled as default for MacOS systems.
Additionally, we found that some users have multiple version of the ``as`` assembler - this might happen if you have GCC from e.g. brew and macports at the same time. Look for the following error:
``FATAL:/opt/local/bin/../libexec/as/x86_64/as: I don't understand 'm' flag!``
If you experience this problems the setting the following path might fix the problem:
.. code:: bash
export PATH=/usr/bin:$PATH
Report Bugs
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Please report any bugs by opening an issue on GitHub: https://github.com/qmlcode/qml/issues
================================================
FILE: docs/source/qml.rst
================================================
Python API documentation
========================
.. Submodules
.. ----------
qml\.representations module
---------------------------
.. automodule:: qml.representations.representations
:members:
:undoc-members:
:show-inheritance:
qml\.kernels module
-------------------
.. automodule:: qml.kernels.kernels
:members:
:undoc-members:
:show-inheritance:
qml\.distance module
--------------------
.. automodule:: qml.kernels.distance
:members:
:undoc-members:
:show-inheritance:
qml\.math module
----------------
.. automodule:: qml.math.math
:members:
:undoc-members:
:show-inheritance:
qml\.Compound class
--------------------
.. autoclass:: qml.data.compound.Compound
:members:
:undoc-members:
:show-inheritance:
qml\.fchl module, representations
---------------------------------
.. automodule:: qml.fchl.fchl_representations
:members:
:show-inheritance:
qml\.fchl module, scalar kernels
--------------------------------
.. automodule:: qml.fchl.fchl_scalar_kernels
:members:
:show-inheritance:
qml\.fchl module, force kernels
-------------------------------
.. automodule:: qml.fchl.fchl_force_kernels
:members:
:show-inheritance:
qml\.fchl module, electric-field kernels
----------------------------------------
.. automodule:: qml.fchl.fchl_electric_field_kernels
:members:
:show-inheritance:
.. qml\.wrappers module
.. --------------------
..
.. .. automodule:: qml.kernels.wrappers
.. :members:
.. :undoc-members:
.. :show-inheritance:
.. qml\.data module
.. ----------------
..
.. .. automodule:: qml.data
.. :members:
.. :undoc-members:
.. :show-inheritance:
.. Module contents
.. ---------------
.. .. automodule:: qml
.. :members:
.. :undoc-members:
.. :show-inheritance:
qml\.arad module
----------------
.. automodule:: qml.arad.arad
:members:
:show-inheritance:
qml\.aglaia module
------------------
.. automodule:: qml.aglaia.aglaia
:inherited-members:
qml\.qmlearn.representations module
-----------------------------------
.. automodule:: qml.qmlearn.representations
:inherited-members:
qml\.qmlearn.kernels module
---------------------------
.. automodule:: qml.qmlearn.kernels
:inherited-members:
================================================
FILE: docs/source/qml_examples/examples.ipynb
================================================
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Examples"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Generating representations using the ``Compound`` class\n",
"\n",
"The following example demonstrates how to generate a representation via\n",
"the ``qml.data.Compound`` class."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from qml.data import Compound\n",
"\n",
"# Read in an xyz or cif file.\n",
"water = Compound(xyz=\"water.xyz\")\n",
"\n",
"# Generate a molecular coulomb matrices sorted by row norm.\n",
"water.generate_coulomb_matrix(size=5, sorting=\"row-norm\")\n",
"\n",
"print(water.representation)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Might print the following representation:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
" [ 73.51669472 8.3593106 0.5 8.35237809 0.66066557 0.5\n",
" 0. 0. 0. 0. 0. 0. 0.\n",
" 0. 0. ]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Generating representations via the ``qml.representations`` module"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Generating the Coulomb-matrix for water:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import numpy as np\n",
"from qml.representations import *\n",
"\n",
"# Dummy coordinates for a water molecule\n",
"coordinates = np.array([[1.464, 0.707, 1.056],\n",
" [0.878, 1.218, 0.498],\n",
" [2.319, 1.126, 0.952]])\n",
"\n",
"# Oxygen, Hydrogen, Hydrogen\n",
"nuclear_charges = np.array([8, 1, 1])\n",
"\n",
"# Generate a molecular coulomb matrices sorted by row norm.\n",
"cm1 = generate_coulomb_matrix(nuclear_charges, coordinates,\n",
" size=5, sorting=\"row-norm\")\n",
"print(cm1)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Generating all atomic coulomb matrices sorted by distance to query atom:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"cm2 = generate_atomic_coulomb_matrix(nuclear_charges, coordinates, size=5, sorting=\"distance\")\n",
"print(cm2)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Calculating a Gaussian kernel\n",
"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:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import numpy as np\n",
"from qml.kernels import gaussian_kernel\n",
"\n",
"# Generate a numpy-array of the representation\n",
"X = np.array([c.representation for c in compounds])\n",
"\n",
"# Kernel-width\n",
"sigma = 100.0\n",
"\n",
"# Calculate the kernel-matrix\n",
"K = gaussian_kernel(X, X, sigma)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Calculating a Gaussian kernel using a local representation\n",
"\n",
"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:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import numpy as np\n",
"from qml.kernels import get_local_kernels_gaussian\n",
"\n",
"# Assume the QM7 dataset is loaded into a list of Compound()\n",
"for compound in qm7:\n",
"\n",
" # Generate the desired representation for each compound\n",
" compound.generate_atomic_coulomb_matrix(size=23, sort=\"row-norm\")\n",
"\n",
"# Make a big array with all the atomic representations\n",
"X = np.concatenate([mol.representation for mol in qm7])\n",
"\n",
"# Make an array with the number of atoms in each compound\n",
"N = np.array([mol.natoms for mol in qm7])\n",
"\n",
"# List of kernel-widths\n",
"sigmas = [50.0, 100.0, 200.0]\n",
"\n",
"# Calculate the kernel-matrix\n",
"K = get_local_kernels_gaussian(X, X, N, N, sigmas)\n",
"\n",
"print(K.shape)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Note that ``mol.representation`` is just a 1D numpy array."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Generating the SLATM representation\n",
"\n",
"The Spectrum of London and Axillrod-Teller-Muto potential (SLATM) representation requires additional input to reduce the size of the representation.\n",
"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.:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from qml.representations import get_slatm_mbtypes\n",
"\n",
"# Assume 'qm7' is a list of Compound() objects.\n",
"mbtypes = get_slatm_mbtypes([mol.nuclear_charges for compound in qm7])\n",
"\n",
"# Assume the QM7 dataset is loaded into a list of Compound()\n",
"for compound in qm7:\n",
"\n",
" # Generate the desired representation for each compound\n",
" compound.generate_slatm(mbtypes, local=True)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"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:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from qml.representations import generate_slatm\n",
"\n",
"# Dummy coordinates\n",
"coordinates = ... \n",
"\n",
"# Dummy nuclear charges\n",
"nuclear_charges = ...\n",
"\n",
"# Dummy mbtypes\n",
"mbtypes = get_slatm_mbtypes( ... )\n",
"\n",
"# Generate one representation\n",
"rep = generate_slatm(coordinates, nuclear_charges, mbtypes)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Here ``coordinates`` is an Nx3 numpy array, and ``nuclear_charges`` is simply a list of charges.\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Generating the FCHL representation\n",
"\n",
"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.\n",
"The syntax is analogous to the explicit representations (e.g. Coulomb matrix, BoB, SLATM, etc), but is handled by kernels from the separate ``qml.representations.fchl`` module.\n",
"\n",
"The code below show three ways to create the input representations for the FHCL kernel functions.\n",
"\n",
"First using the ``Compound`` class:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Assume the dataset is loaded into a list of Compound()\n",
"for compound in mols:\n",
"\n",
" # Generate the desired representation for each compound, cut off in angstrom\n",
" compound.generate_fchl_representation(size=23, cut_off=10.0)\n",
"\n",
"# Make Numpy array of the representation, which can be parsed to the kernel\n",
"X = np.array([c.representation for c in mols])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The dimensions of the array should be ``(number_molecules, size, 5, size)``, where ``size`` is the\n",
"size keyword used when generating the representations. \n",
"\n",
"In addition to using the ``Compound`` class to generate the representations, FCHL representations can also be generated via the ``qml.representations.fchl.generate_fchl_representation()`` function, using similar notation to the functions in the ``qml.representations.*`` functions."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from qml.representations.fchl import generate_representation \n",
"\n",
"# Dummy coordinates for a water molecule\n",
"coordinates = np.array([[1.464, 0.707, 1.056],\n",
" [0.878, 1.218, 0.498],\n",
" [2.319, 1.126, 0.952]])\n",
"\n",
"# Oxygen, Hydrogen, Hydrogen\n",
"nuclear_charges = np.array([8, 1, 1])\n",
"\n",
"rep = generate_representation(coordinates, nuclear_charges)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"To create the representation for a crystal, the notation is as follows:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from qml.representations.fchl import generate_representation \n",
"\n",
"# Dummy fractional coordinates\n",
"fractional_coordinates = np.array(\n",
" [[ 0. , 0. , 0. ],\n",
" [ 0.75000042, 0.50000027, 0.25000015],\n",
" [ 0.15115386, 0.81961403, 0.33154037],\n",
" [ 0.51192691, 0.18038651, 0.3315404 ],\n",
" [ 0.08154025, 0.31961376, 0.40115401],\n",
" [ 0.66846017, 0.81961403, 0.48807366],\n",
" [ 0.08154025, 0.68038678, 0.76192703],\n",
" [ 0.66846021, 0.18038651, 0.84884672],\n",
" [ 0.23807355, 0.31961376, 0.91846033],\n",
" [ 0.59884657, 0.68038678, 0.91846033],\n",
" [ 0.50000031, 0. , 0.50000031],\n",
" [ 0.25000015, 0.50000027, 0.75000042]]\n",
" )\n",
"\n",
"# Dummy nuclear charges\n",
"nuclear_charges = np.array(\n",
" [58, 58, 8, 8, 8, 8, 8, 8, 8, 8, 23, 23]\n",
" )\n",
"\n",
"# Dummy unit cell\n",
"unit_cell = np.array(\n",
" [[ 3.699168, 3.699168, -3.255938],\n",
" [ 3.699168, -3.699168, 3.255938],\n",
" [-3.699168, -3.699168, -3.255938]]\n",
" )\n",
"\n",
"# Generate the representation\n",
"rep = generate_representation(fractional_coordinates, nuclear_charges, cell=unit_cell, neighbors=100, cut_distance=7.0)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The `neighbors` keyword is the max number of atoms with the cutoff-distance"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Generating the FCHL kernel \n",
"\n",
"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.\n",
"\n",
"As output you will get a kernel for each kernel-width."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from qml.representations.fchl import get_local_kernels\n",
"\n",
"# You can get kernels for multiple kernel-widths\n",
"sigmas = [2.5, 5.0, 10.0]\n",
"\n",
"# Calculate the kernel-matrices for each sigma\n",
"K = get_local_kernels(X1, X2, sigmas, cut_distance=10.0)\n",
"\n",
"print(K.shape)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"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).\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from qml.representations.fchl import get_local_symmetric_kernels\n",
"\n",
"# You can get kernels for multiple kernel-widths\n",
"sigmas = [2.5, 5.0, 10.0]\n",
"\n",
"# Calculate the kernel-matrices for each sigma\n",
"K = get_local_kernels(X1, sigmas, cut_distance=10.0)\n",
"\n",
"print(K.shape)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"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\".\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from qml.representations.fchl import get_atomic_kernels\n",
"from qml.representations.fchl import get_atomic_symmetric_kernels"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The only difference between the local and atomic kernels is the shape of the input.\n",
"Since the atomic kernel outputs kernels with atomic resolution, the atomic input has the shape ``(number_atoms, 5, size)``.\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Fitting neural networks\n",
"\n",
"Depending on the representation that one is using, there are two classes of neural networks that can be used: `ARMP` and `MRMP`. These stand for 'Atomic Representation Molecular Properties' and 'Molecular Representation Molecular Properties' respectively."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### `ARMP` class\n",
"\n",
"There are three possible ways of using the `ARMP` class and they are all shown below.\n",
"\n",
"#### 1. Using the `Compound` class\n",
"\n",
"It is possible to include the Cartesian coordinates and the nuclear charges into the `Compound` class and then from the compounds generate the representation. This can be done as follows. \n",
"\n",
"The first step is to load some data: here we use a small data set where a isobutane molecule reacts with a cyano radical. Each data sample is a different configuration of this system."
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"100 files were loaded.\n"
]
}
],
"source": [
"from qml.aglaia.aglaia import ARMP\n",
"import matplotlib.pyplot as plt\n",
"import glob\n",
"import numpy as np\n",
"import os\n",
"\n",
"cwd = os.getcwd()\n",
"dir_name = cwd + \"/../../../test/CN_isobutane/\"\n",
"filenames = glob.glob(dir_name + '*.xyz')\n",
"energies = np.loadtxt(dir_name + 'prop_kjmol_training.txt', usecols=[1])\n",
"filenames.sort()\n",
"\n",
"print(\"%i files were loaded.\" % (len(filenames)))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Then, we can create the estimator and specify all the hyper-parameters needed. For example, below we define an estimator that will do 5000 training epochs, will use the Atom Centered Symmetry Functions (ACSF) as the representation, and will have a L1 and L2 regularisation parameters on the weights of 0.0 and a learning rate of 0.075."
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"acsf_params = {\"nRs2\": 5, \"nRs3\": 5, \"nTs\": 5, \"rcut\": 5, \"acut\": 5, \"zeta\": 220.127, \"eta\": 30.8065}\n",
"estimator = ARMP(iterations=5000, representation_name='acsf', representation_params=acsf_params, learning_rate=0.075, l1_reg=0.0, l2_reg=0.0, scoring_function=\"rmse\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Once the estimator is created, the compounds can be generated as follows. They will be stored inside the class and can be accessed through `estimator.compounds`. The ACSF can be generated from the compounds by calling the `generate_representation()` function."
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"(100, 19, 165)\n"
]
}
],
"source": [
"estimator.generate_compounds(filenames)\n",
"estimator.generate_representation(method=\"fortran\")\n",
"print(estimator.representation.shape)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The shape of the representation is `(n_samples, n_atoms, n_features)`.\n",
"\n",
"Then, we need to set the properties. In this case we are fitting the energies of the different configurations."
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
"estimator.set_properties(energies)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"At this point, we have stored 100 data samples in the class. To train the model, we need to specify the indices of the samples we want to train on. Here, since we have only loaded 100 samples, we are going to use all of them."
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"idx_train = np.arange(0,100)\n",
"\n",
"estimator.fit(idx_train)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Now that the model is fit, we can score it or use it for predictions. The default scoring function is the Mean Absolute Error (MAE). This can be changed when generating the estimator through the keyword `scoring_function`. Here we are using the Root Mean Square Error."
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"The RMSE is 0.05667379826437678 kJ/mol\n"
]
},
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"score = estimator.score(idx_train)\n",
"print(\"The RMSE is %s kJ/mol\" % (str(score)) )\n",
"\n",
"energies_predict = estimator.predict(idx_train)\n",
"\n",
"plt.scatter(energies, energies_predict)\n",
"plt.xlabel(\"True Energies (kJ/mol)\")\n",
"plt.ylabel(\"Predicted Energies (kJ/mol)\")\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### 2. Loading representations\n",
"\n",
"The second way to use the `ARMP` class is useful when you already have generated the representations. For example, if you have a file with the representations, the atom types and the energies, you can load the data into the `ARMP` estimator. Here we load 100 samples of a data set where a methane molecule reacts with a cyano radical. The cartesian coordinates have been transformed into the atomic SLATM representation already."
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [],
"source": [
"cwd = os.getcwd()\n",
"dir_name = cwd + \"/../../../test/data/\"\n",
"filename = \"local_slatm_ch4cn_light.npz\"\n",
"data = np.load(dir_name + filename)\n",
"\n",
"representation = data[\"arr_0\"]\n",
"zs = data[\"arr_1\"]\n",
"energies = data[\"arr_2\"]\n",
"\n",
"estimator = ARMP(iterations=3000, learning_rate=0.075, l1_reg=0.0, l2_reg=0.0, scoring_function=\"rmse\")\n",
"\n",
"estimator.set_representations(representations=representation)\n",
"estimator.set_classes(zs)\n",
"estimator.set_properties(energies)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"In the same way as we did before, now we can use indices to specify on which samples to train, predict and score the model. Again, since we only have loaded 100 samples, we will train and predict on the same sets."
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"The RMSE is 0.30888228285160746 kJ/mol\n"
]
},
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"idx_train = np.arange(0,100)\n",
"\n",
"estimator.fit(idx_train)\n",
"\n",
"score = estimator.score(idx_train)\n",
"\n",
"print(\"The RMSE is %s kJ/mol\" % (str(score)) )\n",
"\n",
"energies_predict = estimator.predict(idx_train)\n",
"\n",
"plt.scatter(energies, energies_predict)\n",
"plt.xlabel(\"True Energies (kJ/mol)\")\n",
"plt.ylabel(\"Predicted Energies (kJ/mol)\")\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### 3. Passing representations straight to the fit function\n",
"\n",
"In this case, there the data is not stored in the class before the fit function is called. Here the data is passed directly to the fit function. When using this way of fitting the estimator it is important to remember that the data that will be passed to the predict/score functions _must_ contain the same element types as the data that was used for the fitting."
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"The RMSE is 0.06417642021013359 kJ/mol\n"
]
},
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"estimator = ARMP(iterations=3000, learning_rate=0.075, l1_reg=0.0, l2_reg=0.0, scoring_function=\"rmse\")\n",
"\n",
"estimator.fit(x=representation, y=energies, classes=zs)\n",
"\n",
"score = estimator.score(x=representation, y=energies, classes=zs)\n",
"\n",
"print(\"The RMSE is %s kJ/mol\" % (str(score)) )\n",
"\n",
"energies_predict = estimator.predict(x=representation, classes=zs)\n",
"\n",
"plt.scatter(energies, energies_predict)\n",
"plt.xlabel(\"True Energies (kJ/mol)\")\n",
"plt.ylabel(\"Predicted Energies (kJ/mol)\")\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### `MRMP` class\n",
"\n",
"There are also three ways of using the `MRMP` class, which are the same as for the `ARMP` class. Therefore, only the second way is shown.\n",
"\n",
"In this class there is no need to specify the nuclear charges for the estimator, because the neural network is not atom decomposed. The representation needs to have a shape `(n_samples, n_features)` instead of `(n_samples, n_atoms, n_features)` which was needed for the `ARMP` class."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"estimator = MRMP(iterations=100, l2_reg=0.0)\n",
"\n",
"estimator.set_representations(representations=representation)\n",
"estimator.set_properties(energies)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Once the data is stored in the class, indices can be used to specify on which samples to train in the same way as for the `ARMP` class."
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.6.6"
}
},
"nbformat": 4,
"nbformat_minor": 2
}
================================================
FILE: docs/source/tutorial.rst
================================================
QML Tutorial
-----------------
This tutorial is a general introduction to kernel-ridge regression with QML.
Theory
~~~~~~~~~~~
Regression model of some property, :math:`y`, for some system, :math:`\widetilde{\mathbf{X}}` - this could correspond to e.g. the atomization energy of a molecule:
:math:`y\left(\widetilde{\mathbf{X}} \right) = \sum_i \alpha_i \ K\left( \widetilde{\mathbf{X}}, \mathbf{X}_i\right)`
E.g. Using Gaussian kernel function with Frobenius norm:
:math:`K_{ij} = K\left( \mathbf{X}_i, \mathbf{X}_j\right) = \exp\left( -\frac{\| \mathbf{X}_i - \mathbf{X}_j\|_2^2}{2\sigma^2}\right)`
Regression coefficients are obtained through kernel matrix inversion and multiplication with reference labels
:math:`\boldsymbol{\alpha} = (\mathbf{K} + \lambda \mathbf{I})^{-1} \mathbf{y}`
Tutorial exercises
~~~~~~~~~~~~~~~~~~~~~
Clone the following GIT repository to access the necessary scripts and QM7 dataset (atomization energies and relaxed geometries at PBE0/def2-TZVP level of theory) for ~7k GDB1-7 molecules. [#rupp]_ [#ruddigkeit]_
.. code:: bash
git clone https://github.com/qmlcode/tutorial.git
Additionally, the repository contains Python3 scripts with the solutions to each exercise.
Exercise 1: Representations
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In this exercise we use \qml~to generate the Coulomb matrix and Bag of bonds (BoB) representations. [#montavon]_
In QML data can be parsed via the ``Compound`` class, which stores data and generates representations in Numpy's ndarray format.
If you run the code below, you will read in the file ``qm7/0001.xyz`` (a methane molecule) and generate a Coulomb matrix representation (sorted by row-norm) and a BoB representation.
.. code:: python
import qml
# Create the compound object mol from the file qm7/0001.xyz which happens to be methane
mol = qml.Compound(xyz="qm7/0001.xyz")
# Generate and print a Coulomb matrix for compound with 5 atoms
mol.generate_coulomb_matrix(size=5, sorting="row-norm")
print(mol.representation)
# Generate and print BoB bags for compound containing C and H
mol.generate_bob(asize={"C":2, "H":5})
print(mol.representation)
The representations are simply stored as 1D-vectors.
Note the keyword ``size`` which is the largest number of atoms in a molecule occurring in test or training set.
Additionally, the Coulomb matrix can take a sorting scheme as keyword, and the BoB representations requires the specifications of how many atoms of a certain type to make room for in the representations.
Lastly, you can print the following properties which is read from the XYZ file:
.. code:: python
# Print other properties stored in the object
print(mol.coordinates)
print(mol.atomtypes)
print(mol.nuclear_charges)
print(mol.name)
print(mol.unit_cell)
Exercise 2: Kernels
~~~~~~~~~~~~~~~~~~~~~
In this exercise we generate a Gaussian kernel matrix, :math:`\mathbf{K}`, using the representations, :math:`\mathbf{X}`, which are generated similarly to the example in the previous exercise:
:math:`K_{ij} = \exp\left( -\frac{\| \mathbf{X}_i - \mathbf{X}_j\|_2^2}{2\sigma^2}\right)`
QML supplies functions to generate the most basic kernels (E.g. Gaussian, Laplacian). In the exercise below, we calculate a Gaussian kernel for the QM7 dataset.
In order to save time you can import the entire QM7 dataset as ``Compound`` objects from the file ``tutorial_data.py`` found in the tutorial GitHub repository.
.. code:: python
import numpy as np
# Import QM7, already parsed to QML
from tutorial_data import compounds
from qml.kernels import gaussian_kernel
# For every compound generate a Coulomb matrix or BoB
for mol in compounds:
mol.generate_coulomb_matrix(size=23, sorting="row-norm")
# mol.generate_bob(size=23, asize={"O":3, "C":7, "N":3, "H":16, "S":1})
# Make a big 2D array with all the representations
X = np.array([mol.representation for mol in compounds])
# Print all representations
print(X)
# Run on only a subset of the first 100 (for speed)
X = X[:100]
# Define the kernel width
sigma = 1000.0
# K is also a Numpy array
K = gaussian_kernel(X, X, sigma)
# Print the kernel
print(K)
Exercise 3: Regression
~~~~~~~~~~~~~~~~~~~~~~~~
With the kernel matrix and representations sorted out in the previous two exercise, we can now solve the :math:`\boldsymbol{\alpha}` regression coefficients:
:math:`\boldsymbol{\alpha} = (\mathbf{K} + \lambda \mathbf{I})^{-1} \mathbf{y}\label{eq:inv}`
One of the most efficient ways of solving this equation is using a Cholesky-decomposition.
QML includes a function named ``cho_solve()`` to do this via the math module ``qml.math``.
In this step it is convenient to only use a subset of the full dataset as training data (see below).
The following builds on the code from the previous step.
To save time, you can import the PBE0/def2-TZVP atomization energies for the QM7 dataset from the file ``tutorial_data.py``.
This has been sorted to match the ordering of the representations generated in the previous exercise.
Extend your code from the previous step with the code below:
.. code:: python
from qml.math import cho_solve
from tutorial_data import energy_pbe0
# Assign first 1000 molecules to the training set
X_training = X[:1000]
Y_training = energy_pbe0[:1000]
sigma = 4000.0
K = gaussian_kernel(X_training, X_training, sigma)
print(K)
# Add a small lambda to the diagonal of the kernel matrix
K[np.diag_indices_from(K)] += 1e-8
# Use the built-in Cholesky-decomposition to solve
alpha = cho_solve(K, Y_training)
print(alpha)
Exercise 4: Prediction
~~~~~~~~~~~~~~~~~~~~~~~~
With the :math:`\boldsymbol{\alpha}` regression coefficients from the previous step, we have (successfully) trained the machine, and we are now ready to do predictions for other compounds.
This is done using the following equation:
:math:`y\left(\widetilde{\mathbf{X}} \right) = \sum_i \alpha_i \ K\left( \widetilde{\mathbf{X}}, \mathbf{X}_i\right)`
In this step we further divide the dataset into a training and a test set. Try using the last 1000 entries as test set.
.. code:: python
# Assign last 1000 molecules to the test set
X_test = X[-1000:]
Y_test = energy_pbe0[-1000:]
# calculate a kernel matrix between test and training data, using the same sigma
Ks = gaussian_kernel(X_test, X_training, sigma)
# Make the predictions
Y_predicted = np.dot(Ks, alpha)
# Calculate mean-absolute-error (MAE):
print(np.mean(np.abs(Y_predicted - Y_test)))
Exercise 5: Learning curves
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Repeat the prediction from Exercise 2.4 with training set sizes of 1000, 2000, and 4000 molecules.
Note the MAE for every training size.
Plot a learning curve of the MAE versus the training set size.
Generate a learning curve for the Gaussian and Laplacian kernels, as well using the Coulomb matrix and bag-of-bonds representations.
Which combination gives the best learning curve? Note you will have to adjust the kernel width (sigma) underway.
Exercise 6: Delta learning
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
A powerful technique in machine learning is the delta learning approach. Instead of predicting the PBE0/def2-TZVP atomization energies, we shall try to predict the difference between DFTB3 (a semi-empirical quantum method) and PBE0 atomization energies.
Instead of importing the ``energy_pbe0`` data, you can import the ``energy_delta`` and use this instead
.. code:: python
from tutorial_data import energy_delta
Y_training = energy_delta[:1000]
Y_test = energy_delta[-1000:]
Finally re-draw one of the learning curves from the previous exercise, and note how the prediction improves.
References
~~~~~~~~~~~~~
.. [#rupp] Rupp et al, Phys Rev Letters, 2012.
.. [#ruddigkeit] Ruddigkeit et al, J Chem Inf Model, 2012.
.. [#montavon] Montavon et al, New J Phys, 2013.
================================================
FILE: examples/ARMP_1.py
================================================
# MIT License
#
# Copyright (c) 2018 Silvia Amabilino
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
"""
This script shows how to set up the ARMP estimator where the XYZ data is used to make QML compounds and the local
descriptors are generated from the QML compounds and then stored.
"""
from qml.aglaia.aglaia import ARMP
import glob
import numpy as np
import os
## ------------- ** Loading the data ** ---------------
current_dir = os.path.dirname(os.path.realpath(__file__))
filenames = glob.glob(current_dir + '/../test/CN_isobutane/*.xyz')
energies = np.loadtxt(current_dir + '/../test/CN_isobutane/prop_kjmol_training.txt', usecols=[1])
filenames.sort()
## ------------- ** Setting up the estimator ** ---------------
acsf_params = {"nRs2": 5, "nRs3": 5, "nTs": 5, "rcut": 5, "acut": 5, "zeta": 220.127, "eta": 30.8065}
estimator = ARMP(iterations=5000, representation_name='acsf', representation_params=acsf_params, tensorboard=False,
learning_rate=0.075, l1_reg=0.0, l2_reg=0.0)
estimator.generate_compounds(filenames)
estimator.set_properties(energies)
estimator.generate_representation()
## ------------- ** Fitting to the data ** ---------------
idx = np.arange(0,100)
estimator.fit(idx)
## ------------- ** Predicting and scoring ** ---------------
score = estimator.score(idx)
print("The mean absolute error is %s kJ/mol." % (str(-score)))
energies_predict = estimator.predict(idx)
================================================
FILE: examples/ARMP_2.py
================================================
# MIT License
#
# Copyright (c) 2018 Silvia Amabilino
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
"""
This script shows how to set up the ARMP estimator where the descriptor is set directly and stored in the class.
"""
from qml.aglaia.aglaia import ARMP
import numpy as np
import os
## ------------- ** Loading the data ** ---------------
current_dir = os.path.dirname(os.path.realpath(__file__))
data = np.load(current_dir + '/../test/data/local_slatm_ch4cn_light.npz')
descriptor = data["arr_0"]
zs = data["arr_1"]
energies = data["arr_2"]
## ------------- ** Setting up the estimator ** ---------------
estimator = ARMP(iterations=3000, learning_rate=0.075, l1_reg=0.0, l2_reg=0.0, tensorboard=True, store_frequency=50)
estimator.set_representations(representations=descriptor)
estimator.set_classes(zs)
estimator.set_properties(energies)
## ------------- ** Fitting to the data ** ---------------
idx = np.arange(0,100)
estimator.fit(idx)
## ------------- ** Predicting and scoring ** ---------------
score = estimator.score(idx)
print("The mean absolute error is %s kJ/mol." % (str(-score)))
energies_predict = estimator.predict(idx)
================================================
FILE: examples/ARMP_3.py
================================================
# MIT License
#
# Copyright (c) 2018 Silvia Amabilino
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
"""
This script shows how to set up the ARMP estimator where the data to be fitted is passed directly to the fit function.
"""
from qml.aglaia.aglaia import ARMP
import os
import numpy as np
## ------------- ** Loading the data ** ---------------
current_dir = os.path.dirname(os.path.realpath(__file__))
data = np.load(current_dir + '/../test/data/local_slatm_ch4cn_light.npz')
representation = data["arr_0"]
zs = data["arr_1"]
energies = data["arr_2"]
## ------------- ** Setting up the estimator ** ---------------
estimator = ARMP(iterations=3000, learning_rate=0.075, l1_reg=0.0, l2_reg=0.0, tensorboard=True, store_frequency=50)
## ------------- ** Fitting to the data ** ---------------
estimator.fit(x=representation, y=energies, classes=zs)
## ------------- ** Predicting and scoring ** ---------------
score = estimator.score(x=representation, y=energies, classes=zs)
print("The mean absolute error is %s kJ/mol." % (str(-score)))
energies_predict = estimator.predict(x=representation, classes=zs)
================================================
FILE: examples/ARMP_qm7.py
================================================
"""
This example shows how to use ARMP to overfit 100 data-points for the QM7 data set. It uses the Atom Centred Symmetry
functions as the representation.
This example takes about 3.5 min to run on a mac.
"""
from qml.aglaia.aglaia import ARMP
import glob
import numpy as np
import matplotlib.pyplot as plt
from sklearn import model_selection as modsel
filenames = sorted(glob.glob("../test/qm7/*.xyz"))
energies = np.loadtxt("../test/data/hof_qm7.txt", usecols=[1])
n_samples = len(filenames)
print("%i files were loaded." % (n_samples))
acsf_params = {"nRs2": 5, "nRs3": 5, "nTs": 5, "rcut": 5, "acut": 5, "zeta": 220.127, "eta": 30.8065}
estimator = ARMP(iterations=6000, representation_name='acsf', representation_params=acsf_params, l1_reg=0.0, l2_reg=0.0,
scoring_function="rmse", tensorboard=False, store_frequency=10, learning_rate=0.075)
estimator.set_properties(energies[:100])
estimator.generate_compounds(filenames[:100])
estimator.generate_representation(method="fortran")
print("The shape of the representation is: %s" % (str(estimator.representation.shape)))
idx = list(range(100))
idx_train, idx_test = modsel.train_test_split(idx, test_size=0, random_state=42, shuffle=True)
estimator.fit(idx_train)
score = estimator.score(idx_train)
print("The RMSE is %s kcal/mol." % (str(score)))
ene_pred = estimator.predict(idx_train)
# Plotting the predictions against the true values
plt.scatter(energies[idx_train], ene_pred)
plt.show()
================================================
FILE: examples/MRMP_1.py
================================================
# MIT License
#
# Copyright (c) 2018 Silvia Amabilino
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
"""
This script shows how to set up the MRMP estimator where the XYZ data is used to make QML compounds and global descriptors
are generated from the QML compounds and stored.
"""
from qml.aglaia.aglaia import MRMP
import glob
import numpy as np
import os
## ------------- ** Loading the data ** ---------------
current_dir = os.path.dirname(os.path.realpath(__file__))
filenames = glob.glob(current_dir + '/../test/CN_isobutane/*.xyz')
energies = np.loadtxt(current_dir + '/../test/CN_isobutane/prop_kjmol_training.txt', usecols=[1])
filenames.sort()
## ------------- ** Setting up the estimator ** ---------------
estimator = MRMP(representation_name='slatm', representation_params={'slatm_dgrid2': 0.06, 'slatm_dgrid1': 0.06})
estimator.generate_compounds(filenames[:100])
estimator.set_properties(energies[:100])
estimator.generate_representation()
## ------------- ** Fitting to the data ** ---------------
idx = np.arange(0,100)
estimator.fit(idx)
## ------------- ** Predicting and scoring ** ---------------
score = estimator.score(idx)
print("The mean absolute error is %s kJ/mol." % (str(-score)))
energies_predict = estimator.predict(idx)
================================================
FILE: examples/MRMP_2.py
================================================
# MIT License
#
# Copyright (c) 2018 Silvia Amabilino
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
"""
This script shows how to set up the MRMP estimator where the descriptor is set directly and stored in the class.
"""
from qml.aglaia.aglaia import MRMP
import numpy as np
import os
## ------------- ** Loading the data ** ---------------
# The data loaded contains 100 samples of the CN + isobutane data set in unsorted CM representation
current_dir = os.path.dirname(os.path.realpath(__file__))
data = np.load(current_dir + '/../test/data/CN_isopent_light_UCM.npz')
representation = data["arr_0"]
energies = data["arr_1"]
## ------------- ** Setting up the estimator ** ---------------
estimator = MRMP(iterations=7000, l2_reg=0.0)
estimator.set_representations(representations=representation)
estimator.set_properties(energies)
## ------------- ** Fitting to the data ** ---------------
idx = np.arange(0,100)
estimator.fit(idx)
## ------------- ** Predicting and scoring ** ---------------
score = estimator.score(idx)
print("The mean absolute error is %s kJ/mol." % (str(-score)))
energies_predict = estimator.predict(idx)
================================================
FILE: examples/MRMP_3.py
================================================
# MIT License
#
# Copyright (c) 2018 Silvia Amabilino
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
"""
This script shows how to set up the MRMP estimator where the data to be fitted is passed directly to the fit function.
"""
from qml.aglaia.aglaia import MRMP
import numpy as np
import os
## ------------- ** Loading the data ** ---------------
# The data loaded contains 100 samples of the CN + isobutane data set in unsorted CM representation
current_dir = os.path.dirname(os.path.realpath(__file__))
data = np.load(current_dir + '/../test/data/CN_isopent_light_UCM.npz')
representation = data["arr_0"]
energies = data["arr_1"]
## ------------- ** Setting up the estimator ** ---------------
estimator = MRMP()
## ------------- ** Fitting to the data ** ---------------
estimator.fit(representation, energies)
## ------------- ** Predicting and scoring ** ---------------
score = estimator.score(representation, energies)
print("The mean absolute error is %s kJ/mol." % (str(-score)))
energies_predict = estimator.predict(representation)
================================================
FILE: examples/qm7_hyperparam_search/config.yaml
================================================
estimator:
pickle: model.pickle
strategy:
name: random
#params:
# seeds: 5
search_space:
hl1:
min: 1
max: 100
type: int
hl2:
min: 0
max: 100
type: int
hl3:
min: 0
max: 100
type: int
l1_reg:
min: 1e-9
max: 1e0
type: float
warp: log
l2_reg:
min: 1e-9
max: 1e0
type: float
warp: log
learning_rate:
min: 1e-9
max: 1e0
type: float
warp: log
cv:
name: kfold
params:
n_splits: 3
shuffle: True
dataset_loader:
name: dsv
params:
filenames: idx.csv
trials:
uri: sqlite:///osprey-trials.db
================================================
FILE: examples/qm7_hyperparam_search/idx.csv
================================================
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
================================================
FILE: examples/qm7_hyperparam_search/make_model_pickle.py
================================================
# MIT License
#
# Copyright (c) 2018 Silvia Amabilino
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
import pickle
import glob
import numpy as np
from aglaia.wrappers import OSPMRMP
estimator = OSPMRMP(batch_size = 100, representation = "sorted_coulomb_matrix")
filenames = glob.glob("qm7/*.xyz")[:1000]
energies = np.loadtxt('qm7/hof_qm7.txt', usecols=[1])[:1000]
estimator.generate_compounds(filenames)
estimator.set_properties(energies)
#real_estimator = OSPMRMP(batch_size = 100, representation = "sorted_coulomb_matrix", compounds = estimator.compounds,
# properties = energies)
#estimator.set_properties(energies)
#print(estimator.properties.size, estimator.compounds.size)
pickle.dump(estimator, open('model.pickle', 'wb'))
with open('idx.csv', 'w') as f:
for i in range(energies.size):
f.write('%s\n' % i)
#np.save('idx.npy', np.arange(0,energies.size)[:,None])
================================================
FILE: examples/qmlearn.py
================================================
import glob
import numpy as np
from qml import qmlearn
import sklearn.pipeline
import sklearn.model_selection
def data():
"""
Using the Data object.
"""
print("*** Begin data examples ***")
# The Data object has the same role as the Compound class.
# Where the Compound class is for one compound, the Data class
# Is for multiple
# One can load in a set of xyz files
filenames = sorted(glob.glob("../test/qm7/00*.xyz"))
data = qmlearn.Data(filenames)
print("length of filenames", len(filenames))
print("length of nuclear_charges", len(data.nuclear_charges))
print("length of coordinates", len(data.coordinates))
# Or just load a glob string
data = qmlearn.Data("../test/qm7/00*.xyz")
print("length of nuclear_charges", len(data.nuclear_charges))
# Energies (or other molecular properties) can be stored in the object
energies = np.loadtxt("../test/data/hof_qm7.txt", usecols=1)[:98]
data.set_energies(energies)
print("length of energies", len(data.energies))
print("*** End data examples ***")
print()
def preprocessing():
"""
Rescaling energies
"""
print("*** Begin preprocessing examples ***")
# The AtomScaler object does a linear fit of the number of each element to the energy.
data = qmlearn.Data("../test/qm7/*.xyz")
energies = np.loadtxt("../test/data/hof_qm7.txt", usecols=1)
# Input can be nuclear_charges and energies
print("Energies before rescaling", energies[:3])
rescaled_energies = qmlearn.preprocessing.AtomScaler().fit_transform(data.nuclear_charges, energies)
print("Energies after rescaling", rescaled_energies[:3])
# Or a data object can be used
data.set_energies(energies)
data2 = qmlearn.preprocessing.AtomScaler().fit_transform(data)
print("Energies after rescaling", data2.energies[:3])
print("*** End preprocessing examples ***")
print()
def representations():
"""
Creating representations. Currently implemented representations are
CoulombMatrix, AtomicCoulombMatrix, AtomicSLATM, GlobalSLATM,
FCHLRepresentations, AtomCenteredSymmetryFunctions.
(BagOfBonds is still missing)
"""
print("*** Begin representations examples ***")
data = qmlearn.Data("../test/qm7/*.xyz")
# Representations can be created from a data object
model = qmlearn.representations.CoulombMatrix(sorting ='row-norm')
representations = model.generate(data)
print("Shape of representations:", representations.shape)
# Alternatively the data object can be passed at initialization of the representation class
# and only select molecule indices can be parsed
model = qmlearn.representations.CoulombMatrix(data)
representations = model.generate([0,5,7,16])
print("Shape of representations:", representations.shape)
print("*** End representations examples ***")
print()
def kernels():
"""
Create kernels. Currently implemented kernels are GaussianKernel,
LaplacianKernel, FCHLKernel.
"""
print("*** Begin kernels examples ***")
data = qmlearn.Data("../test/qm7/*.xyz")
energies = np.loadtxt("../test/data/hof_qm7.txt", usecols=1)
data.set_energies(energies)
# Kernels can be created from representations
model = qmlearn.representations.CoulombMatrix(data)
indices = np.arange(100)
representations = model.generate(indices)
model = qmlearn.kernels.GaussianKernel(sigma='auto')
symmetric_kernels = model.generate(representations[:80])
print("Shape of symmetric kernels:", symmetric_kernels.shape)
asymmetric_kernels = model.generate(representations[:80], representations[80:])
print("Shape of asymmetric kernels:", asymmetric_kernels.shape)
# Atomic representations can be used as well
model = qmlearn.representations.AtomicCoulombMatrix(data)
indices = np.arange(100)
representations = model.generate(indices)
model = qmlearn.kernels.GaussianKernel(sigma='auto')
symmetric_kernels = model.generate(representations[:80], representation_type = 'atomic')
print("Shape of symmetric kernels:", symmetric_kernels.shape)
asymmetric_kernels = model.generate(representations[:80], representations[80:], representation_type = 'atomic')
print("Shape of asymmetric kernels:", asymmetric_kernels.shape)
print("*** End kernels examples ***")
print()
def models():
"""
Regression models. Only KernelRidgeRegression implemented so far.
"""
print("*** Begin models examples ***")
filenames = sorted(glob.glob("../test/qm7/*.xyz"))
data = qmlearn.Data(filenames)
energies = np.loadtxt("../test/data/hof_qm7.txt", usecols=1)
model = qmlearn.representations.CoulombMatrix(data)
# Create 1000 random indices
indices = np.random.choice(np.arange(len(energies)), size=1000, replace=False)
representations = model.generate(indices)
model = qmlearn.kernels.GaussianKernel(sigma='auto')
symmetric_kernels = model.generate(representations[:800])
asymmetric_kernels = model.generate(representations[:800], representations[800:])
# Model can be fit giving kernel matrix and energies
model = qmlearn.models.KernelRidgeRegression()
model.fit(symmetric_kernels, energies[indices[:800]])
print("Fitted KRR weights:", model.alpha[:3])
# Predictions can be had from an asymmetric kernel
predictions = model.predict(asymmetric_kernels)
print("Predicted energies:", predictions[:3])
print("True energies:", energies[indices[:3]])
# Or the score (default negative mae) can be had directly
scores = model.score(asymmetric_kernels, energies[indices[800:]])
print("Negative MAE:", scores)
print("*** End models examples ***")
print()
def pipelines():
"""
Constructing scikit-learn pipelines
"""
print("*** Begin pipelines examples ***")
# It is much easier to do all this with a scikit-learn pipeline
# Create data
data = qmlearn.Data("../test/qm7/*.xyz")
energies = np.loadtxt("../test/data/hof_qm7.txt", usecols=1)
data.set_energies(energies)
# Create model
model = sklearn.pipeline.make_pipeline(
qmlearn.preprocessing.AtomScaler(data),
qmlearn.representations.CoulombMatrix(),
qmlearn.kernels.GaussianKernel(),
qmlearn.models.KernelRidgeRegression(),
)
# Create 1000 random indices
indices = np.random.choice(np.arange(len(energies)), size=1000, replace=False)
model.fit(indices[:800])
scores = model.score(indices[800:])
print("Negative MAE:", scores)
# Passing alchemy=False to kernels makes sure that the atomic kernel only compares C to C, H to H etc.
# This will speed up kernels of some representations dramatically, but only works in pipelines
# Create model
model = sklearn.pipeline.make_pipeline(
qmlearn.preprocessing.AtomScaler(data),
qmlearn.representations.CoulombMatrix(),
qmlearn.kernels.GaussianKernel(alchemy=False),
qmlearn.models.KernelRidgeRegression(),
)
# Create 1000 random indices
indices = np.random.choice(np.arange(len(energies)), size=1000, replace=False)
model.fit(indices[:800])
scores = model.score(indices[800:])
print("Negative MAE without alchemy:", scores)
print("*** End pipelines examples ***")
print()
def pipelines_2():
"""
Scikit learn pipeline with a molecular neural network
"""
print("\n *** Begin pipelines example with molecular Neural Network ***")
data = qmlearn.Data("../test/qm7/*.xyz")
energies = np.loadtxt("../test/data/hof_qm7.txt", usecols=1)
data.set_energies(energies)
# Create model
model = sklearn.pipeline.make_pipeline(
qmlearn.preprocessing.AtomScaler(data),
qmlearn.representations.CoulombMatrix(),
qmlearn.models.NeuralNetwork(iterations=500, batch_size=50, learning_rate=0.005),
)
indices = np.arange(1000)
np.random.shuffle(indices)
model.fit(indices[:100])
# Score on the TRAINING set, since you won't get good predictions in 500 iterations
scores = model.score(indices[:100])
print("Negative MAE:", scores)
print("*** End pipelines example with molecular Neural Network *** \n")
def pipelines_3():
"""
Scikit learn pipeline with an atomic neural network
"""
print("\n *** Begin pipelines example with atomic Neural Network ***")
data = qmlearn.Data("../test/qm7/*.xyz")
energies = np.loadtxt("../test/data/hof_qm7.txt", usecols=1)
data.set_energies(energies)
# Create model
model = sklearn.pipeline.make_pipeline(
qmlearn.preprocessing.AtomScaler(data),
qmlearn.representations.AtomCenteredSymmetryFunctions(),
qmlearn.models.NeuralNetwork(iterations=500, batch_size=50, learning_rate=0.005),
)
indices = np.arange(1000)
np.random.shuffle(indices)
model.fit(indices[:100])
# Score on the TRAINING set, since you won't get good predictions in 500 iterations
scores = model.score(indices[:100])
print("Negative MAE:", scores)
print("*** End pipelines example with atomic Neural Network *** \n")
def cross_validation():
"""
Doing cross validation with qmlearn
"""
print("*** Begin CV examples ***")
# Create data
data = qmlearn.Data("../test/qm7/*.xyz")
energies = np.loadtxt("../test/data/hof_qm7.txt", usecols=1)
data.set_energies(energies)
# Create model
model = sklearn.pipeline.make_pipeline(
qmlearn.preprocessing.AtomScaler(data),
qmlearn.representations.CoulombMatrix(),
qmlearn.kernels.GaussianKernel(),
qmlearn.models.KernelRidgeRegression(),
# memory='/dev/shm/' ### This will cache the previous steps to the virtual memory and might speed up gridsearch
)
# Create 1000 random indices
indices = np.random.choice(np.arange(len(energies)), size=1000, replace=False)
# 3-fold CV of a given model can easily be done
scores = sklearn.model_selection.cross_validate(model, indices, cv=3)
print("Cross-validated scores:", scores['test_score'])
# Doing a grid search over hyper parameters
params = {'gaussiankernel__sigma': [10, 30, 100],
'kernelridgeregression__l2_reg': [1e-8, 1e-4],
}
grid = sklearn.model_selection.GridSearchCV(model, cv=3, refit=False, param_grid=params)
grid.fit(indices)
print("Best hyper parameters:", grid.best_params_)
print("Best score:", grid.best_score_)
# As an alternative the pipeline can be constructed slightly different, which allows more complex CV
# Create model
model = sklearn.pipeline.Pipeline([
('preprocess', qmlearn.preprocessing.AtomScaler(data)),
('representations', qmlearn.representations.CoulombMatrix()),
('kernel', qmlearn.kernels.GaussianKernel()),
('model', qmlearn.models.KernelRidgeRegression())
],
# memory='/dev/shm/' ### This will cache the previous steps to the virtual memory and might speed up gridsearch
)
# Doing a grid search over hyper parameters
# including which kernel to use
params = {'kernel': [qmlearn.kernels.LaplacianKernel(), qmlearn.kernels.GaussianKernel()],
'kernel__sigma': [10, 30, 100, 1000, 3000, 1000],
'model__l2_reg': [1e-8, 1e-4],
}
grid = sklearn.model_selection.GridSearchCV(model, cv=3, refit=False, param_grid=params)
grid.fit(indices)
print("Best hyper parameters:", grid.best_params_)
print("Best score:", grid.best_score_)
print("*** End CV examples ***")
if __name__ == '__main__':
data()
preprocessing()
representations()
kernels()
models()
pipelines()
cross_validation()
pipelines_2()
pipelines_3()
================================================
FILE: examples/test_qmlearn_energy.py
================================================
#!/usr/bin/env python3
import sys
import pickle
import glob
import os
import ast
import numpy as np
import pandas as pd
from qml import qmlearn
import sklearn.pipeline
import sklearn.model_selection
import qml
np.random.seed(666)
TEST_DIR = "/home/andersx/dev/qml/develop/test/"
def parse_qm7_data(num=100):
energies = np.loadtxt(TEST_DIR + "/data/hof_qm7.txt", usecols=1)
indexes = list(range(len(energies)))
np.random.shuffle(indexes)
indexes = indexes[:num]
energies = energies[indexes]
filenames = sorted(glob.glob(TEST_DIR + "/qm7/*.xyz"))# [indexes]
filenames = [filenames[i] for i in indexes]
data = qmlearn.Data(filenames)
data.set_energies(energies)
return data
def parse_qm9_data(num=100):
energies = np.loadtxt("/project/andersx/qm9_dataset/data_characterized.txt", usecols=13) * 627.51
filenames = np.loadtxt("/project/andersx/qm9_dataset/data_characterized.txt", usecols=0, dtype='str')
indexes = list(range(len(energies)))
np.random.shuffle(indexes)
indexes = indexes[:num]
energies = energies[indexes]
filenames = ["/project/andersx/qm9_dataset/characterized_xyz/" + filenames[i] for i in indexes]
data = qmlearn.Data(filenames)
data.set_energies(energies)
return data
def csv2data(csv_filename, num=10):
df = pd.read_csv(csv_filename, delimiter=";")
# print(df_train["forces"])
e = []
f = []
n = []
coords = []
q = []
for i in indexes[:num]:
coordinates = np.array(ast.literal_eval(df["coordinates"][i]))
nuclear_charges = np.array(ast.literal_eval(df["nuclear_charges"][i]), dtype=np.int32)
atomtypes = df["atomtypes"][i]
force = np.array(ast.literal_eval(df["forces"][i])) # * -1
energy = float(df["atomization_energy"][i])
n.append(len(nuclear_charges))
f.append(force)
e.append(energy)
q.append(nuclear_charges)
coords.append(coordinates)
# data = qmlearn.Data()
#
# data.set_energies(np.array(e))
# data.set_forces(np.array(f))
# data.natoms = np.array(n , dtype=np.int32)
# data.coordinates =np.array(coords)
# data.nuclear_charges = np.array(q)
e = np.array(e)
f = np.array(f)
coords = np.array(coords)
n = np.array(n)
q = np.array(q)
print(e.shape)
print(f.shape)
print(coords.shape)
print(n.shape)
print(q.shape)
data = qmlearn.Data()
data.set_energies(e)
data.set_forces(f)
data.natoms = n
data.coordinates = coords
data.nuclear_charges = q
# rescaled_energies = qmlearn.preprocessing.AtomScaler().fit_transform(data.nuclear_charges, e)
# data.set_energies(rescaled_energies)
return data
def npz2data(npy_filename, num=10):
print("PARSING NPY FILE:", npy_filename)
df = np.load(npy_filename)
# print(df_train["forces"])
print([k for k in df.keys()])
indexes = list(range(len(df["E"])))
np.random.shuffle(indexes)
indexes = indexes[:num]
# print(indexes)
print(df["z"])
nuclear_charges = df["z"]
mol_size = len(nuclear_charges)
e = df["E"][indexes].flatten()
f = df["F"][indexes]
coords = df["R"][indexes]
n = np.array([mol_size for _ in e], dtype=np.int32)
q = np.array([nuclear_charges for _ in e])
# print(e.shape)
# print(f.shape)
# print(coords.shape)
# print(n.shape)
# print(q.shape)
data = qmlearn.Data()
data.set_energies(e)
data.set_forces(f)
data.natoms = n
data.coordinates = coords
data.nuclear_charges = q
# data.set_energies(rescaled_energies)
rescaled_energies = qmlearn.preprocessing.AtomScaler().fit_transform(data.nuclear_charges, e)
data.set_energies(rescaled_energies)
return data
def pipeline():
test_dir = os.path.dirname(os.path.realpath(__file__))
DATA_SIZE = 1600
# data = csv2data(test_dir+"/data/force_train.csv", num=DATA_SIZE)
# data = npz2data("/project/andersx/sgdml_npy/toluene_dft.npz", num=DATA_SIZE)
# data = npz2data("/project/andersx/sgdml_npy/naphthalene_dft.npz", num=DATA_SIZE)
npy_names = [
"aspirin_dft.npz", # 0
"azobenzene_dft.npz", # 1
"benzene_dft.npz", # 2
"benzene_old_dft.npz", # 3
"ethanol_dft.npz", # 4
"malonaldehyde_dft.npz", # 5
"naphthalene_dft.npz", # 6
"paracetamol_dft.npz", # 7
"salicylic_dft.npz", # 8
"toluene_dft.npz", # 9
"uracil_dft.npz", # 10
]
# data = npz2data("/project/andersx/sgdml_npy/" + npy_names[0], num=DATA_SIZE)
# data = parse_qm7_data(num=DATA_SIZE)
data = parse_qm9_data(num=DATA_SIZE)
indices = np.arange(len(data.energies))
np.random.shuffle(indices)
# indices = indices[:1600]
# model.fit(indices[:n])
# scores = model.score(indices[-n:])
# print("Negative MAE:", scores)
model = sklearn.pipeline.Pipeline([
# ('preprocess', qmlearn.preprocessing.AtomScaler(data)),
# ('representations', qmlearn.representations.FCHL_ACSF()),
('representations', qmlearn.representations.FCHL_ACSF(data)),
# ('kernel', qmlearn.kernels.OQMLForceKernel()),
# ('model', qmlearn.models.OQMLRegression())
# ('kernel', qmlearn.kernels.GPRForceKernel()),
# ('model', qmlearn.models.GPRRegression())
('kernel', qmlearn.kernels.GPREnergyKernel()),
('model', qmlearn.models.KernelRidgeRegression(scoring="neg_mae"))
],
# memory='/dev/shm/' ### This will cache the previous steps to the virtual memory and might speed up gridsearch
)
# pickle.dump(model, open('pipeline_qm9.pickle', 'wb'))
# exit()
# Doing a grid search over hyper parameters
# including which kernel to use
params = {
# 'kernel__sigma': [2.0, 4.0, 8.0],
# 'model__l2_reg': [1e-14, 1e-12, 1e-10, 1e-9, 1e-8],
# 'model__l2_reg': [1e-9, 1e-8, 1e-7],
'kernel__sigma': [4.0],
'model__l2_reg': [1e-14],
}
# from skopt import BayesSearchCV
grid = sklearn.model_selection.GridSearchCV(model, cv=4, refit=False, param_grid=params, verbose=10000)
grid.fit(indices)
means = grid.cv_results_['mean_test_score']
stds = grid.cv_results_['std_test_score']
for mean, std, params in zip(means, stds, grid.cv_results_['params']):
print("%0.3f (+/-%0.03f) for %r" % (mean, std * 2, params))
print("Best hyper parameters:", grid.best_params_)
print("Best score:", grid.best_score_)
print("*** End CV examples ***")
if __name__ == "__main__":
pipeline()
================================================
FILE: examples/test_qmlearn_force.py
================================================
#!/usr/bin/env python3
import sys
import pickle
import glob
import os
import ast
import numpy as np
import pandas as pd
from qml import qmlearn
import sklearn.pipeline
import sklearn.model_selection
import qml
np.random.seed(666)
TEST_DIR = "/home/andersx/dev/qml/develop/test/"
def parse_qm7_data(num=100):
energies = np.loadtxt(TEST_DIR + "/data/hof_qm7.txt", usecols=1)
indexes = list(range(len(energies)))
np.random.shuffle(indexes)
indexes = indexes[:num]
energies = energies[indexes]
filenames = sorted(glob.glob(TEST_DIR + "/qm7/*.xyz"))# [indexes]
filenames = [filenames[i] for i in indexes]
data = qmlearn.Data(filenames)
data.set_energies(energies)
return data
def parse_qm9_data(num=100):
energies = np.loadtxt("/project/andersx/qm9_dataset/data_characterized.txt", usecols=13) * 627.51
filenames = np.loadtxt("/project/andersx/qm9_dataset/data_characterized.txt", usecols=0, dtype='str')
indexes = list(range(len(energies)))
np.random.shuffle(indexes)
indexes = indexes[:num]
energies = energies[indexes]
filenames = ["/project/andersx/qm9_dataset/characterized_xyz/" + filenames[i] for i in indexes]
data = qmlearn.Data(filenames)
data.set_energies(energies)
return data
def csv2data(csv_filename, num=10):
df = pd.read_csv(csv_filename, delimiter=";")
# print(df_train["forces"])
e = []
f = []
n = []
coords = []
q = []
for i in indexes[:num]:
coordinates = np.array(ast.literal_eval(df["coordinates"][i]))
nuclear_charges = np.array(ast.literal_eval(df["nuclear_charges"][i]), dtype=np.int32)
atomtypes = df["atomtypes"][i]
force = np.array(ast.literal_eval(df["forces"][i])) # * -1
energy = float(df["atomization_energy"][i])
n.append(len(nuclear_charges))
f.append(force)
e.append(energy)
q.append(nuclear_charges)
coords.append(coordinates)
# data = qmlearn.Data()
#
# data.set_energies(np.array(e))
# data.set_forces(np.array(f))
# data.natoms = np.array(n , dtype=np.int32)
# data.coordinates =np.array(coords)
# data.nuclear_charges = np.array(q)
e = np.array(e)
f = np.array(f)
coords = np.array(coords)
n = np.array(n)
q = np.array(q)
print(e.shape)
print(f.shape)
print(coords.shape)
print(n.shape)
print(q.shape)
data = qmlearn.Data()
data.set_energies(e)
data.set_forces(f)
data.natoms = n
data.coordinates = coords
data.nuclear_charges = q
# rescaled_energies = qmlearn.preprocessing.AtomScaler().fit_transform(data.nuclear_charges, e)
# data.set_energies(rescaled_energies)
return data
def npz2data(npy_filename, num=10):
print("PARSING NPY FILE:", npy_filename)
df = np.load(npy_filename)
# print(df_train["forces"])
print([k for k in df.keys()])
indexes = list(range(len(df["E"])))
np.random.shuffle(indexes)
indexes = indexes[:num]
# print(indexes)
print(df["z"])
nuclear_charges = df["z"]
mol_size = len(nuclear_charges)
e = df["E"][indexes].flatten()
f = df["F"][indexes]
coords = df["R"][indexes]
n = np.array([mol_size for _ in e], dtype=np.int32)
q = np.array([nuclear_charges for _ in e])
# print(e.shape)
# print(f.shape)
# print(coords.shape)
# print(n.shape)
# print(q.shape)
data = qmlearn.Data()
data.set_energies(e)
data.set_forces(f)
data.natoms = n
data.coordinates = coords
data.nuclear_charges = q
# data.set_energies(rescaled_energies)
# rescaled_energies = qmlearn.preprocessing.AtomScaler().fit_transform(data.nuclear_charges, e)
# data.set_energies(rescaled_energies)
return data
def pipeline():
test_dir = os.path.dirname(os.path.realpath(__file__))
DATA_SIZE = 200
# data = csv2data(test_dir+"/data/force_train.csv", num=DATA_SIZE)
# data = npz2data("/project/andersx/sgdml_npy/toluene_dft.npz", num=DATA_SIZE)
# data = npz2data("/project/andersx/sgdml_npy/naphthalene_dft.npz", num=DATA_SIZE)
npy_names = [
"aspirin_dft.npz", # 0
"azobenzene_dft.npz", # 1
"benzene_dft.npz", # 2
"benzene_old_dft.npz", # 3
"ethanol_dft.npz", # 4
"malonaldehyde_dft.npz", # 5
"naphthalene_dft.npz", # 6
"paracetamol_dft.npz", # 7
"salicylic_dft.npz", # 8
"toluene_dft.npz", # 9
"uracil_dft.npz", # 10
]
data = npz2data("/project/andersx/sgdml_npy/" + npy_names[4], num=DATA_SIZE)
# data = parse_qm7_data(num=DATA_SIZE)
# data = parse_qm9_data(num=DATA_SIZE)
indices = np.arange(len(data.energies))
np.random.shuffle(indices)
# indices = indices[:1600]
# model.fit(indices[:n])
# scores = model.score(indices[-n:])
# print("Negative MAE:", scores)
model = sklearn.pipeline.Pipeline([
('preprocess', qmlearn.preprocessing.AtomScaler(data)),
('representations', qmlearn.representations.FCHL_ACSF_Force()),
# ('representations', qmlearn.representations.FCHL_ACSF(data)),
# ('kernel', qmlearn.kernels.OQMLForceKernel()),
#('model', qmlearn.models.OQMLRegression())
('kernel', qmlearn.kernels.GPRForceKernel()),
('model', qmlearn.models.GPRRegression())
# ('kernel', qmlearn.kernels.GPREnergyKernel()),
# ('model', qmlearn.models.KernelRidgeRegression(scoring="neg_mae"))
],
# memory='/dev/shm/' ### This will cache the previous steps to the virtual memory and might speed up gridsearch
)
# pickle.dump(model, open('pipeline_qm9.pickle', 'wb'))
# exit()
# Doing a grid search over hyper parameters
# including which kernel to use
params = {
# 'kernel__sigma': [2.0, 4.0, 8.0],
# 'model__l2_reg': [1e-14, 1e-12, 1e-10, 1e-9, 1e-8],
'model__l2_reg': [1e-9, 1e-8, 1e-7],
'kernel__sigma': [4.0],
# 'model__l2_reg': [1e-14],
}
# from skopt import BayesSearchCV
grid = sklearn.model_selection.GridSearchCV(model, cv=2, refit=False, param_grid=params, verbose=10000)
grid.fit(indices)
means = grid.cv_results_['mean_test_score']
stds = grid.cv_results_['std_test_score']
for mean, std, params in zip(means, stds, grid.cv_results_['params']):
print("%0.3f (+/-%0.03f) for %r" % (mean, std * 2, params))
print("Best hyper parameters:", grid.best_params_)
print("Best score:", grid.best_score_)
print("*** End CV examples ***")
if __name__ == "__main__":
pipeline()
================================================
FILE: mkldiscover.py
================================================
#!/usr/bin/env python
# MIT License
#
# Copyright (c) 2017 Anders Steen Christensen
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
from __future__ import print_function
import os
def mkl_exists(verbose=False):
# Get environment variables
__MKLROOT__ = os.environ.get('MKLROOT')
__LD_LIBRARY_PATH__ = os.environ.get('LD_LIBRARY_PATH')
# Check if $MKLROOT is set
if __MKLROOT__ is None:
if verbose:
print("MKL-discover: MKLROOT was not set")
return False
else:
if verbose:
print("MKL-discover: MKLROOT was set to")
print(__MKLROOT__)
# Check if path exists
mklroot_exists = os.path.isdir(__MKLROOT__)
if not mklroot_exists:
if verbose:
print("MKL-discover: MKLROOT path does not exist")
return False
found_libmkl_rt = False
# Check if libmkl_rt.so exists below $MKLROOT
for dirpath, dirnames, filenames in os.walk(__MKLROOT__, followlinks=True):
if "libmkl_rt.so" in filenames:
if verbose:
print("MKL-discover: Found libmkl_rt.so at ", dirpath)
# Check that the dirpath where libmkl_rt.so is in $LD_LIBRARY_PATH
if dirpath in __LD_LIBRARY_PATH__:
if verbose:
print("MKL-discover: Found %s in $LD_LIBRARY_PATH" % dirpath)
print("MKL-discover: Concluding that MKL can be used.")
found_libmkl_rt = True
return found_libmkl_rt
if __name__ == "__main__":
mkl_present = mkl_exists(verbose=False)
if mkl_present:
print("MKL found")
else:
print("MKL could NOT be found")
================================================
FILE: qml/__init__.py
================================================
# MIT License
#
# Copyright (c) 2016 Anders Steen Christensen
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
"""
QML main module
===============
Provides
1. representations
2. kernels
3. math
"""
from __future__ import absolute_import
from . import models
from . import aglaia
from . import math
from . import kernels
from . import arad
from . import fchl
from . import representations
from . import qmlearn
from . import utils
from .utils.compound import Compound
__author__ = "Anders S. Christensen"
__copyright__ = "Copyright 2016"
__credits__ = ["Anders S. Christensen (2016) https://github.com/qmlcode/qml"]
__license__ = "MIT"
__version__ = "0.2.1"
__maintainer__ = "Anders S. Christensen"
__email__ = "andersbiceps@gmail.com"
__status__ = "Beta"
================================================
FILE: qml/aglaia/__init__.py
================================================
# MIT License
#
# Copyright (c) 2017 Silvia Amabilino, Lars Andersen Bratholm
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
"""
Aglaia main module
===============
Provides
1. NN class
2. wrappers
"""
================================================
FILE: qml/aglaia/aglaia.py
================================================
# MIT License
#
# Copyright (c) 2018 Silvia Amabilino, Lars Andersen Bratholm
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
"""
Module containing the general neural network class and the child classes for the molecular and atomic neural networks.
"""
from __future__ import print_function
import os
import numpy as np
import tensorflow as tf
from sklearn.metrics import r2_score, mean_squared_error, mean_absolute_error
from sklearn.base import BaseEstimator
from .symm_funct import generate_acsf_tf
from ..utils.utils import InputError, ceil, is_positive_or_zero, is_positive_integer, is_positive, \
is_bool, is_positive_integer_or_zero, is_string, is_positive_integer_array, is_array_like, \
check_global_representation, check_y, check_sizes, check_dy, check_classes, is_numeric_array, is_non_zero_integer, \
is_positive_integer_or_zero_array, check_local_representation
from qml.aglaia.tf_utils import TensorBoardLogger
from qml.representations import generate_acsf
from qml.aglaia.graceful_killer import _GracefulKiller
from qml import Compound
from qml import representations as qml_rep
import tensorflow
class _NN(BaseEstimator):
"""
Parent class for training multi-layered neural networks on molecular or atomic properties via Tensorflow
"""
def __init__(self, hidden_layer_sizes, l1_reg, l2_reg, batch_size, learning_rate,
iterations, tensorboard, store_frequency, tf_dtype, scoring_function,
activation_function, optimiser, beta1, beta2, epsilon,
rho, initial_accumulator_value, initial_gradient_squared_accumulator_value,
l1_regularization_strength,l2_regularization_strength, tensorboard_subdir):
"""
:param hidden_layer_sizes: Number of hidden layers. The n'th element represents the number of neurons in the n'th
hidden layer.
:type hidden_layer_size: Tuple of integers
:param l1_reg: L1-regularisation parameter for the neural network weights
:type l1_reg: float
:param l2_reg: L2-regularisation parameter for the neural network weights
:type l2_reg: float
:param batch_size: Size of minibatches for the ADAM optimizer. If set to 'auto' ``batch_size = min(200,n_samples)``
:type batch_size: integer
:param learning_rate: The learning rate in the numerical minimisation.
:type learning_rate: float
:param iterations: Total number of iterations that will be carried out during the training process.
:type iterations: integer
:param tf_dtype: Accuracy to use for floating point operations in tensorflow. 64 and 'float64' is recognised as tf.float64
and similar for tf.float32 and tf.float16.
:type tf_dtype: Tensorflow datatype
:param scoring_function: Scoring function to use. Available choices are 'mae', 'rmse', 'r2'.
:type scoring_function: string
:param activation_function: Activation function to use in the neural network. Currently 'sigmoid', 'tanh', 'elu', 'softplus',
'softsign', 'relu', 'relu6', 'crelu' and 'relu_x' is supported.
:type activation_function: Tensorflow datatype
:param beta1: parameter for AdamOptimizer
:type beta1: float
:param beta2: parameter for AdamOptimizer
:type beta2: float
:param epsilon: parameter for AdadeltaOptimizer
:type epsilon: float
:param rho: parameter for AdadeltaOptimizer
:type rho: float
:param initial_accumulator_value: parameter for AdagradOptimizer
:type initial_accumulator_value: float
:param initial_gradient_squared_accumulator_value: parameter for AdagradDAOptimizer
:type initial_gradient_squared_accumulator_value: float
:param l1_regularization_strength: parameter for AdagradDAOptimizer
:type l1_regularization_strength: float
:param l2_regularization_strength: parameter for AdagradDAOptimizer
:type l2_regularization_strength: float
:param tensorboard: Store summaries to tensorboard or not
:type tensorboard: boolean
:param store_frequency: How often to store summaries to tensorboard.
:type store_frequency: integer
:param tensorboard_subdir: Directory to store tensorboard data
:type tensorboard_subdir: string
"""
super(_NN,self).__init__()
# Initialising the parameters
self._set_hidden_layers_sizes(hidden_layer_sizes)
self._set_l1_reg(l1_reg)
self._set_l2_reg(l2_reg)
self._set_batch_size(batch_size)
self._set_learning_rate(learning_rate)
self._set_iterations(iterations)
self._set_tf_dtype(tf_dtype)
self._set_scoring_function(scoring_function)
self._set_tensorboard(tensorboard, store_frequency, tensorboard_subdir)
self._set_activation_function(activation_function)
# Placeholder variables
self.n_features = None
self.n_samples = None
self.training_cost = []
self.session = None
# Setting the optimiser
self._set_optimiser_param(beta1, beta2, epsilon, rho, initial_accumulator_value,
initial_gradient_squared_accumulator_value, l1_regularization_strength,
l2_regularization_strength)
self.optimiser = self._set_optimiser_type(optimiser)
# Placholder variables for data
self.compounds = None
self.representation = None
self.properties = None
self.gradients = None
self.classes = None
# To enable restart model
self.loaded_model = False
def _set_activation_function(self, activation_function):
"""
This function sets which activation function will be used in the model.
:param activation_function: name of the activation function to use
:type activation_function: string or tf class
:return: None
"""
if activation_function in ['sigmoid', tf.nn.sigmoid]:
self.activation_function = tf.nn.sigmoid
elif activation_function in ['tanh', tf.nn.tanh]:
self.activation_function = tf.nn.tanh
elif activation_function in ['elu', tf.nn.elu]:
self.activation_function = tf.nn.elu
elif activation_function in ['softplus', tf.nn.softplus]:
self.activation_function = tf.nn.softplus
elif activation_function in ['softsign', tf.nn.softsign]:
self.activation_function = tf.nn.softsign
elif activation_function in ['relu', tf.nn.relu]:
self.activation_function = tf.nn.relu
elif activation_function in ['relu6', tf.nn.relu6]:
self.activation_function = tf.nn.relu6
elif activation_function in ['crelu', tf.nn.crelu]:
self.activation_function = tf.nn.crelu
elif activation_function in ['relu_x', tf.nn.relu_x]:
self.activation_function = tf.nn.relu_x
else:
raise InputError("Unknown activation function. Got %s" % str(activation_function))
def _set_l1_reg(self, l1_reg):
"""
This function sets the value of the l1 regularisation that will be used on the weights in the model.
:param l1_reg: l1 regularisation on the weights
:type l1_reg: float
:return: None
"""
if not is_positive_or_zero(l1_reg):
raise InputError("Expected positive float value for variable 'l1_reg'. Got %s" % str(l1_reg))
self.l1_reg = l1_reg
def _set_l2_reg(self, l2_reg):
"""
This function sets the value of the l2 regularisation that will be used on the weights in the model.
:param l2_reg: l2 regularisation on the weights
:type l2_reg: float
:return: None
"""
if not is_positive_or_zero(l2_reg):
raise InputError("Expected positive float value for variable 'l2_reg'. Got %s" % str(l2_reg))
self.l2_reg = l2_reg
def _set_batch_size(self, batch_size):
"""
This function sets the value of the batch size. The value of the batch size will be checked again once the data
set is available, to make sure that it is sensible. This will be done by the function _get_batch_size.
:param batch_size: size of the batch size.
:type batch_size: float
:return: None
"""
if batch_size != "auto":
if not is_positive_integer(batch_size):
raise InputError("Expected 'batch_size' to be a positive integer. Got %s" % str(batch_size))
elif batch_size == 1:
raise InputError("batch_size must be larger than 1. Got %s" % str(batch_size))
self.batch_size = int(batch_size)
else:
self.batch_size = batch_size
def _set_learning_rate(self, learning_rate):
"""
This function sets the value of the learning that will be used by the optimiser.
:param learning_rate: step size in the optimisation algorithms
:type l1_reg: float
:return: None
"""
if not is_positive(learning_rate):
raise InputError("Expected positive float value for variable learning_rate. Got %s" % str(learning_rate))
self.learning_rate = float(learning_rate)
def _set_iterations(self, iterations):
"""
This function sets the number of iterations that will be carried out by the optimiser.
:param iterations: number of iterations
:type l1_reg: int
:return: None
"""
if not is_positive_integer(iterations):
raise InputError("Expected positive integer value for variable iterations. Got %s" % str(iterations))
self.iterations = int(iterations)
# TODO check that the estimators actually use this
def _set_tf_dtype(self, tf_dtype):
"""
This sets what data type will be used in the model.
:param tf_dtype: data type
:type tf_dtype: string or tensorflow class or int
:return: None
"""
# 2 == tf.float64 and 1 == tf.float32 for some reason
# np.float64 recognised as tf.float64 as well
if tf_dtype in ['64', 64, 'float64', tf.float64]:
self.tf_dtype = tf.float64
elif tf_dtype in ['32', 32, 'float32', tf.float32]:
self.tf_dtype = tf.float32
elif tf_dtype in ['16', 16, 'float16', tf.float16]:
self.tf_dtype = tf.float16
else:
raise InputError("Unknown tensorflow data type. Got %s" % str(tf_dtype))
def _set_optimiser_param(self, beta1, beta2, epsilon, rho, initial_accumulator_value, initial_gradient_squared_accumulator_value,
l1_regularization_strength, l2_regularization_strength):
"""
This function sets all the parameters that are required by all the optimiser functions. In the end, only the parameters
for the optimiser chosen will be used.
:param beta1: parameter for AdamOptimizer
:type beta1: float
:param beta2: parameter for AdamOptimizer
:type beta2: float
:param epsilon: parameter for AdadeltaOptimizer
:type epsilon: float
:param rho: parameter for AdadeltaOptimizer
:type rho: float
:param initial_accumulator_value: parameter for AdagradOptimizer
:type initial_accumulator_value: float
:param initial_gradient_squared_accumulator_value: parameter for AdagradDAOptimizer
:type initial_gradient_squared_accumulator_value: float
:param l1_regularization_strength: parameter for AdagradDAOptimizer
:type l1_regularization_strength: float
:param l2_regularization_strength: parameter for AdagradDAOptimizer
:type l2_regularization_strength: float
:return: None
"""
if not is_positive(beta1) and not is_positive(beta2):
raise InputError("Expected positive float values for variable beta1 and beta2. Got %s and %s." % (str(beta1),str(beta2)))
self.beta1 = float(beta1)
self.beta2 = float(beta2)
if not is_positive(epsilon):
raise InputError("Expected positive float value for variable epsilon. Got %s" % str(epsilon))
self.epsilon = float(epsilon)
if not is_positive(rho):
raise InputError("Expected positive float value for variable rho. Got %s" % str(rho))
self.rho = float(rho)
if not is_positive(initial_accumulator_value) and not is_positive(initial_gradient_squared_accumulator_value):
raise InputError("Expected positive float value for accumulator values. Got %s and %s" %
(str(initial_accumulator_value), str(initial_gradient_squared_accumulator_value)))
self.initial_accumulator_value = float(initial_accumulator_value)
self.initial_gradient_squared_accumulator_value = float(initial_gradient_squared_accumulator_value)
if not is_positive_or_zero(l1_regularization_strength) and not is_positive_or_zero(l2_regularization_strength):
raise InputError("Expected positive or zero float value for regularisation variables. Got %s and %s" %
(str(l1_regularization_strength), str(l2_regularization_strength)))
self.l1_regularization_strength = float(l1_regularization_strength)
self.l2_regularization_strength = float(l2_regularization_strength)
def _set_optimiser_type(self, optimiser):
"""
This function sets which numerical optimisation algorithm will be used for training.
:param optimiser: Optimiser
:type optimiser: string or tf class
:return: tf optimiser to use
:rtype: tf class
"""
self.AdagradDA = False
if optimiser in ['AdamOptimizer', tf.train.AdamOptimizer]:
optimiser_type = tf.train.AdamOptimizer
elif optimiser in ['AdadeltaOptimizer', tf.train.AdadeltaOptimizer]:
optimiser_type = tf.train.AdadeltaOptimizer
elif optimiser in ['AdagradOptimizer', tf.train.AdagradOptimizer]:
optimiser_type = tf.train.AdagradOptimizer
elif optimiser in ['AdagradDAOptimizer', tf.train.AdagradDAOptimizer]:
optimiser_type = tf.train.AdagradDAOptimizer
self.AdagradDA = True
elif optimiser in ['GradientDescentOptimizer', tf.train.GradientDescentOptimizer]:
optimiser_type = tf.train.GradientDescentOptimizer
else:
raise InputError("Unknown optimiser. Got %s" % str(optimiser))
return optimiser_type
def _set_optimiser(self):
"""
This function instantiates an object from the optimiser class that has been selected by the user. It also sets
the parameters for the optimiser.
:return: Optimiser with set parameters
:rtype: object of tf optimiser class
"""
self.AdagradDA = False
if self.optimiser in ['AdamOptimizer', tf.train.AdamOptimizer]:
optimiser_obj = tf.train.AdamOptimizer(learning_rate=self.learning_rate, beta1=self.beta1, beta2=self.beta2,
epsilon=self.epsilon)
elif self.optimiser in ['AdadeltaOptimizer', tf.train.AdadeltaOptimizer]:
optimiser_obj = tf.train.AdadeltaOptimizer(learning_rate=self.learning_rate, rho=self.rho, epsilon=self.epsilon)
elif self.optimiser in ['AdagradOptimizer', tf.train.AdagradOptimizer]:
optimiser_obj = tf.train.AdagradOptimizer(learning_rate=self.learning_rate,
initial_accumulator_value=self.initial_accumulator_value)
elif self.optimiser in ['AdagradDAOptimizer', tf.train.AdagradDAOptimizer]:
self.global_step = tf.placeholder(dtype=tf.int64)
optimiser_obj = tf.train.AdagradDAOptimizer(learning_rate=self.learning_rate, global_step=self.global_step,
initial_gradient_squared_accumulator_value=self.initial_gradient_squared_accumulator_value,
l1_regularization_strength=self.l1_regularization_strength,
l2_regularization_strength=self.l2_regularization_strength)
self.AdagradDA = True
elif self.optimiser in ['GradientDescentOptimizer', tf.train.GradientDescentOptimizer]:
optimiser_obj = tf.train.GradientDescentOptimizer(learning_rate=self.learning_rate)
else:
raise InputError("Unknown optimiser class. Got %s" % str(self.optimiser))
return optimiser_obj
def _set_scoring_function(self, scoring_function):
"""
This function sets which scoring metrics to use when scoring the results.
:param scoring_function: name of the scoring function to use
:type scoring_function: string
:return: None
"""
if not is_string(scoring_function):
raise InputError("Expected a string for variable 'scoring_function'. Got %s" % str(scoring_function))
if scoring_function.lower() not in ['mae', 'rmse', 'r2']:
raise InputError("Available scoring functions are 'mae', 'rmse', 'r2'. Got %s" % str(scoring_function))
self.scoring_function = scoring_function
def _set_hidden_layers_sizes(self, hidden_layer_sizes):
"""
This function sets the number of hidden layers and the number of neurons in each hidden layer. The length of the
tuple tells the number of hidden layers (n_hidden_layers) while each element of the tuple specifies the number
of hidden neurons in that layer.
:param hidden_layer_sizes: number of hidden layers and hidden neurons.
:type hidden_layer_sizes: tuple of length n_hidden_layer
:return: None
"""
try:
iterator = iter(hidden_layer_sizes)
except TypeError:
raise InputError("'hidden_layer_sizes' must be a tuple of positive integers. Got a non-iterable object.")
if None in hidden_layer_sizes:
raise InputError("'hidden_layer_sizes' must be a tuple of positive integers. Got None elements")
if not is_positive_integer_array(hidden_layer_sizes):
raise InputError("'hidden_layer_sizes' must be a tuple of positive integers")
self.hidden_layer_sizes = np.asarray(hidden_layer_sizes, dtype = int)
def _set_tensorboard(self, tensorboard, store_frequency, tensorboard_subdir):
"""
This function prepares all the things needed to use tensorboard when training the estimator.
:param tensorboard: whether to use tensorboard or not
:type tensorboard: boolean
:param store_frequency: Every how many steps to save data to tensorboard
:type store_frequency: int
:param tensorboard_subdir: directory where to save the tensorboard data
:type tensorboard_subdir: string
:return: None
"""
if not is_bool(tensorboard):
raise InputError("Expected boolean value for variable tensorboard. Got %s" % str(tensorboard))
self.tensorboard = bool(tensorboard)
if not self.tensorboard:
return
if not is_string(tensorboard_subdir):
raise InputError('Expected string value for variable tensorboard_subdir. Got %s' % str(tensorboard_subdir))
# TensorBoardLogger will handle all tensorboard related things
self.tensorboard_logger_training = TensorBoardLogger(tensorboard_subdir + '/training')
self.tensorboard_subdir_training = tensorboard_subdir + '/training'
self.tensorboard_logger_representation = TensorBoardLogger(tensorboard_subdir + '/representation')
self.tensorboard_subdir_representation = tensorboard_subdir + '/representation'
if not is_positive_integer(store_frequency):
raise InputError("Expected positive integer value for variable store_frequency. Got %s" % str(store_frequency))
if store_frequency > self.iterations:
print("Only storing final iteration for tensorboard")
self.tensorboard_logger_training.set_store_frequency(self.iterations)
else:
self.tensorboard_logger_training.set_store_frequency(store_frequency)
def _init_weight(self, n1, n2, name):
"""
This function generates a the matrix of weights to go from layer l to the next layer l+1. It initialises the
weights from a truncated normal distribution where the standard deviation is 1/sqrt(n2) and the mean is zero.
:param n1: size of the layer l+1
:type n1: int
:param n2: size of the layer l
:type n2: int
:param name: name to give to the tensor of weights to make tensorboard clear
:type name: string
:return: weights to go from layer l to layer l+1
:rtype: tf tensor of shape (n1, n2)
"""
w = tf.Variable(tf.truncated_normal([n1,n2], stddev = 1.0 / np.sqrt(n2), dtype = self.tf_dtype),
dtype = self.tf_dtype, name = name)
return w
def _init_bias(self, n, name):
"""
This function initialises the biases to go from layer l to layer l+1.
:param n: size of the layer l+1
:type n: int
:param name: name to give to the tensor of biases to make tensorboard clear
:type name: string
:return: biases
:rtype: tf tensor of shape (n, 1)
"""
b = tf.Variable(tf.zeros([n], dtype = self.tf_dtype), name=name, dtype = self.tf_dtype)
return b
def _generate_weights(self, n_out):
"""
Generates the weights and the biases, by looking at the size of the hidden layers,
the number of features in the representation and the number of outputs. The weights are initialised from
a zero centered normal distribution with precision :math:`\\tau = a_{m}`, where :math:`a_{m}` is the number
of incoming connections to a neuron. Weights larger than two standard deviations from the mean is
redrawn.
:param n_out: Number of outputs
:type n_out: integer
:return: tuple of weights and biases, each being of length (n_hidden_layers + 1)
:rtype: tuple
"""
weights = []
biases = []
# Weights from input layer to first hidden layer
weights.append(self._init_weight(self.hidden_layer_sizes[0], self.n_features, 'weight_in'))
biases.append(self._init_bias(self.hidden_layer_sizes[0], 'bias_in'))
# Weights from one hidden layer to the next
for i in range(1, self.hidden_layer_sizes.size):
weights.append(self._init_weight(self.hidden_layer_sizes[i], self.hidden_layer_sizes[i-1], 'weight_hidden_%d' %i))
biases.append(self._init_bias(self.hidden_layer_sizes[i], 'bias_hidden_%d' % i))
# Weights from last hidden layer to output layer
weights.append(self._init_weight(n_out, self.hidden_layer_sizes[-1], 'weight_out'))
biases.append(self._init_bias(n_out, 'bias_out'))
return weights, biases
def _l2_loss(self, weights):
"""
Creates the expression for L2-regularisation on the weights
:param weights: tensorflow tensors representing the weights
:type weights: list of tf tensors
:return: tensorflow scalar representing the regularisation contribution to the cost function
:rtype: tf.float32
"""
reg_term = tf.zeros([], name="l2_loss")
for i in range(self.hidden_layer_sizes.size):
reg_term += tf.reduce_sum(tf.square(weights[i]))
return self.l2_reg * reg_term
def _l1_loss(self, weights):
"""
Creates the expression for L1-regularisation on the weights
:param weights: tensorflow tensors representing the weights
:type weights: list of tf tensors
:return: tensorflow scalar representing the regularisation contribution to the cost function
:rtype: tf.float32
"""
reg_term = tf.zeros([], name="l1_loss")
for i in range(self.hidden_layer_sizes.size):
reg_term += tf.reduce_sum(tf.abs(weights[i]))
return self.l1_reg * reg_term
def _get_batch_size(self):
"""
Determines the actual batch size. If set to auto, the batch size will be set to 100.
If the batch size is larger than the number of samples, it is truncated and a warning
is printed.
Furthermore the returned batch size will be slightly modified from the user input if
the last batch would be tiny compared to the rest.
:return: Batch size
:rtype: int
"""
if self.batch_size == 'auto':
batch_size = min(100, self.n_samples)
else:
if self.batch_size > self.n_samples:
print("Warning: batch_size larger than sample size. It is going to be clipped")
return min(self.n_samples, self.batch_size)
else:
batch_size = self.batch_size
# see if the batch size can be modified slightly to make sure the last batch is similar in size
# to the rest of the batches
# This is always less that the requested batch size, so no memory issues should arise
better_batch_size = ceil(self.n_samples, ceil(self.n_samples, batch_size))
return better_batch_size
def _set_slatm_parameters(self, params):
"""
This function sets the parameters for the slatm representation.
:param params: dictionary
:return: None
"""
self.slatm_parameters = {'slatm_sigma1': 0.05, 'slatm_sigma2': 0.05, 'slatm_dgrid1': 0.03, 'slatm_dgrid2': 0.03,
'slatm_rcut': 4.8, 'slatm_rpower': 6, 'slatm_alchemy': False}
if params is not None:
for key, value in params.items():
if key in self.slatm_parameters:
self.slatm_parameters[key] = value
self._check_slatm_values()
def _set_acsf_parameters(self, params):
"""
This function sets the parameters for the acsf representation.
:param params: dictionary
:return: None
"""
self.acsf_parameters = {'rcut': 5.0, 'acut': 5.0, 'nRs2': 5, 'nRs3': 5, 'nTs': 5,
'zeta': 220.127, 'eta': 30.8065, 'bin_min': 0.8}
if params is not None:
for key, value in params.items():
if key in self.acsf_parameters:
self.acsf_parameters[key] = value
self._check_acsf_values()
def score(self, x, y=None, dy=None, classes=None):
"""
This function calls the appropriate function to score the model. One needs to pass a representation and some
properties to it or alternatively if the compounds/representations and the properties are stored in the class one
can pass indices.
:param x: either the representations or the indices to the representations
:type x: either a numpy array of shape (n_samples, n_features) or (n_samples, n_atoms, n_features) or a numpy array of ints
:param y: either the properties or None
:type y: either a numpy array of shape (n_samples,) or None
:param dy: either the gradients of the properties or none
:type dy: either a numpy array of shape (n_samples, n_atoms, 3) or None
:param classes: either the classes to do the NN decomposition or None
:type classes: either a numpy array of shape (n_samples, n_atoms) or None
:return: score
:rtype: float
"""
return self._score(x, y, dy, classes)
def _score(self, x, y=None, dy=None, classes=None):
"""
This function calls the appropriate function to score the model. One needs to pass a representation and some
properties to it or alternatively if the compounds/representations and the properties are stored in the class one
can pass indices.
:param x: either the representations or the indices to the representations
:type x: either a numpy array of shape (n_samples, n_features) or (n_samples, n_atoms, n_features) or a numpy array of ints
:param y: either the properties or None
:type y: either a numpy array of shape (n_samples,) or None
:param dy: either the gradients of the properties or none
:type dy: either a numpy array of shape (n_samples, n_atoms, 3) or None
:param classes: either the classes to do the NN decomposition or None
:type classes: either a numpy array of shape (n_samples, n_atoms) or None
:return: score
:rtype: float
"""
if self.scoring_function == 'mae':
return self._score_mae(x, y, dy, classes)
if self.scoring_function == 'rmse':
return self._score_rmse(x, y, dy, classes)
if self.scoring_function == 'r2':
return self._score_r2(x, y, dy, classes)
def generate_compounds(self, filenames):
"""
Creates QML compounds. Needs to be called before fitting.
:param filenames: path of xyz-files
:type filenames: list
"""
# Check that the number of properties match the number of compounds if the properties have already been set
if self.properties is None:
pass
else:
if self.properties.size == len(filenames):
pass
else:
raise InputError("Number of properties (%d) does not match number of compounds (%d)"
% (self.properties.size, len(filenames)))
self.compounds = np.empty(len(filenames), dtype=object)
for i, filename in enumerate(filenames):
self.compounds[i] = Compound(filename)
def generate_representation(self, xyz=None, classes=None, method='fortran'):
"""
This function can generate representations either from the data contained in the compounds or from xyz data passed
through the argument. If the Compounds have already being set and xyz data is given, it complains.
:param xyz: cartesian coordinates
:type xyz: numpy array of shape (n_samples, n_atoms, 3)
:param classes: The classes to do the atomic decomposition of the networks (most commonly nuclear charges)
:type classes: numpy array of shape (n_samples, n_atoms)
:return: None
"""
if self.compounds is None and xyz is None and classes is None:
raise InputError("QML compounds need to be created in advance or Cartesian coordinates need to be passed in "
"order to generate the representation.")
if self.representation is not None:
raise InputError("The representations have already been set!")
if self.compounds is None:
self.representation, self.classes = self._generate_representations_from_data(xyz, classes, method)
elif xyz is None:
# Make representations from compounds
self.representation, self.classes = self._generate_representations_from_compounds(method)
else:
raise InputError("Compounds have already been set but new xyz data is being passed.")
def set_properties(self, properties):
"""
Set properties. Needed to be called before fitting.
:param y: array of properties of size (nsamples,)
:type y: array
"""
if properties is None:
raise InputError("Properties cannot be set to none.")
else:
if is_numeric_array(properties) and np.asarray(properties).ndim == 1:
self.properties = np.asarray(properties)
else:
raise InputError(
'Variable "properties" expected to be array like of dimension 1. Got %s' % str(properties))
def set_representations(self, representations):
"""
This function takes representations as input and stores them inside the class.
:param representations: global or local representations
:type representations: numpy array of shape (n_samples, n_features) or (n_samples, n_atoms, n_features)
"""
if self.representation is not None:
raise InputError("The representations have already been set!")
if representations is None:
raise InputError("Descriptor cannot be set to none.")
else:
if is_numeric_array(representations):
self._set_representation(representations)
else:
raise InputError('Variable "representation" expected to be array like.')
def set_gradients(self, gradients):
"""
This function enables to set the gradient information.
:param gradients: The gradients of the properties with respect to the input. For example, forces.
:type gradients: numpy array (for example, numpy array of shape (n_samples, n_atoms, 3))
:return: None
"""
if gradients is None:
raise InputError("Gradients cannot be set to none.")
else:
if is_numeric_array(gradients):
self.gradients = np.asarray(gradients)
else:
raise InputError('Variable "gradients" expected to be array like.')
# TODO move to ARMP? MRMP does not neet this function
def set_classes(self, classes):
"""
This function stores the classes to be used during training for local networks.
:param classes: what class does each atom belong to.
:type classes: numpy array of shape (n_samples, n_atoms) of ints
:return: None
"""
if classes is None:
raise InputError("Classes cannot be set to none.")
else:
if is_positive_integer_or_zero_array(classes):
self.classes = np.asarray(classes)
else:
raise InputError('Variable "classes" expected to be array like of positive integers.')
def fit(self, x, y=None, dy=None, classes=None):
"""
This function calls the specific fit method of the child classes.
:param x: either the representations or the indices to the representations
:type x: either a numpy array of shape (n_samples, n_features) or (n_samples, n_atoms, n_features) or a numpy array of ints
:param y: either the properties or None
:type y: either a numpy array of shape (n_samples,) or None
:param dy: either the gradients of the properties or none
:type dy: either a numpy array of shape (n_samples, n_atoms, 3) or None
:param classes: either the classes to do the NN decomposition or None
:type classes: either a numpy array of shape (n_samples, n_atoms) or None
:return: None
"""
return self._fit(x, y, dy, classes)
def _check_slatm_values(self):
"""
This function checks that the parameters passed to slatm make sense.
:return: None
"""
if not is_positive(self.slatm_parameters['slatm_sigma1']):
raise InputError("Expected positive float for variable 'slatm_sigma1'. Got %s." % str(self.slatm_parameters['slatm_sigma1']))
if not is_positive(self.slatm_parameters['slatm_sigma2']):
raise InputError("Expected positive float for variable 'slatm_sigma2'. Got %s." % str(self.slatm_parameters['slatm_sigma2']))
if not is_positive(self.slatm_parameters['slatm_dgrid1']):
raise InputError("Expected positive float for variable 'slatm_dgrid1'. Got %s." % str(self.slatm_parameters['slatm_dgrid1']))
if not is_positive(self.slatm_parameters['slatm_dgrid2']):
raise InputError("Expected positive float for variable 'slatm_dgrid2'. Got %s." % str(self.slatm_parameters['slatm_dgrid2']))
if not is_positive(self.slatm_parameters['slatm_rcut']):
raise InputError("Expected positive float for variable 'slatm_rcut'. Got %s." % str(self.slatm_parameters['slatm_rcut']))
if not is_non_zero_integer(self.slatm_parameters['slatm_rpower']):
raise InputError("Expected non-zero integer for variable 'slatm_rpower'. Got %s." % str(self.slatm_parameters['slatm_rpower']))
if not is_bool(self.slatm_parameters['slatm_alchemy']):
raise InputError("Expected boolean value for variable 'slatm_alchemy'. Got %s." % str(self.slatm_parameters['slatm_alchemy']))
def _check_acsf_values(self):
"""
This function checks that the user input parameters to acsf make sense.
:return: None
"""
if not is_positive(self.acsf_parameters['rcut']):
raise InputError(
"Expected positive float for variable 'rcut'. Got %s." % str(self.acsf_parameters['rcut']))
if not is_positive(self.acsf_parameters['acut']):
raise InputError(
"Expected positive float for variable 'acut'. Got %s." % str(self.acsf_parameters['acut']))
if not is_positive_integer(self.acsf_parameters['nRs2']):
raise InputError("Expected positinve integer for 'nRs2. Got %s." % (self.acsf_parameters['nRs2']))
if not is_positive_integer(self.acsf_parameters['nRs3']):
raise InputError("Expected positinve integer for 'nRs3. Got %s." % (self.acsf_parameters['nRs3']))
if not is_positive_integer(self.acsf_parameters['nTs']):
raise InputError("Expected positinve integer for 'nTs. Got %s." % (self.acsf_parameters['nTs']))
if is_numeric_array(self.acsf_parameters['eta']) or is_numeric_array(self.acsf_parameters['eta']):
raise InputError("Expecting a scalar value for eta parameters.")
if is_numeric_array(self.acsf_parameters['zeta']):
raise InputError("Expecting a scalar value for zeta. Got %s." % (self.acsf_parameters['zeta']))
if not is_positive_or_zero(self.acsf_parameters['bin_min']):
raise InputError(
"Expected positive or zero float for variable 'bin_min'. Got %s." % str(self.acsf_parameters['bin_min']))
def _get_msize(self, pad = 0):
"""
Gets the maximum number of atoms in a single molecule. To support larger molecules
an optional padding can be added by the ``pad`` variable.
:param pad: Add an integer padding to the returned dictionary
:type pad: integer
:return: largest molecule with respect to number of atoms.
:rtype: integer
"""
if self.compounds.size == 0:
raise RuntimeError("QML compounds have not been generated")
if not is_positive_integer_or_zero(pad):
raise InputError("Expected variable 'pad' to be a positive integer or zero. Got %s" % str(pad))
nmax = max(mol.natoms for mol in self.compounds)
return nmax + pad
def _get_asize(self, pad = 0):
"""
Gets the maximum occurrences of each element in a single molecule. To support larger molecules
an optional padding can be added by the ``pad`` variable.
:param pad: Add an integer padding to the returned dictionary
:type pad: integer
:return: dictionary of the maximum number of occurences of each element in a single molecule.
:rtype: dictionary
"""
if self.compounds.size == 0:
raise RuntimeError("QML compounds have not been generated")
if not is_positive_integer_or_zero(pad):
raise InputError("Expected variable 'pad' to be a positive integer or zero. Got %s" % str(pad))
asize = {}
for mol in self.compounds:
for key, value in mol.natypes.items():
if key not in asize:
asize[key] = value + pad
continue
asize[key] = max(asize[key], value + pad)
return asize
def _get_slatm_mbtypes(self, arr):
"""
This function takes an array containing all the classes that are present in a data set and returns a list of all
the unique classes present, all the possible pairs and triplets of classes.
:param arr: classes for each atom in a data set
:type arr: numpy array of shape (n_samples, n_atoms)
:return: unique single, pair and triplets of classes
:rtype: list of lists
"""
return qml_rep.get_slatm_mbtypes(arr)
def _get_xyz_from_compounds(self, indices):
"""
This function takes some indices and returns the xyz of the compounds corresponding to those indices.
:param indices: indices of the compounds to use for training
:type indices: numpy array of ints of shape (n_samples, )
:return: the xyz of the specified compounds
:rtype: numpy array of shape (n_samples, n_atoms, 3)
"""
xyzs = []
zs = []
max_n_atoms = 0
for compound in self.compounds[indices]:
xyzs.append(compound.coordinates)
zs.append(compound.nuclear_charges)
if len(compound.nuclear_charges) > max_n_atoms:
max_n_atoms = len(compound.nuclear_charges)
# Padding so that all the samples have the same shape
n_samples = len(zs)
for i in range(n_samples):
current_n_atoms = len(zs[i])
missing_n_atoms = max_n_atoms - current_n_atoms
xyz_padding = np.zeros((missing_n_atoms, 3))
xyzs[i] = np.concatenate((xyzs[i], xyz_padding))
xyzs = np.asarray(xyzs, dtype=np.float32)
return xyzs
def _get_properties(self, indices):
"""
This returns the properties that have been set through QML.
:param indices: The indices of the properties to return
:type indices: numpy array of ints of shape (n_samples, )
:return: the properties of the compounds specified
:rtype: numpy array of shape (n_samples, 1)
"""
return np.atleast_2d(self.properties[indices]).T
def _get_classes(self, indices):
"""
This returns the classes that have been set through QML.
:param indices: The indices of the properties to return
:type indices: numpy array of ints of shape (n_samples, )
:return: classes of the compounds specified
:rtype: numpy array of shape (n_samples, n_atoms)
"""
zs = []
max_n_atoms = 0
for compound in self.compounds[indices]:
zs.append(compound.nuclear_charges)
if len(compound.nuclear_charges) > max_n_atoms:
max_n_atoms = len(compound.nuclear_charges)
# Padding so that all the samples have the same shape
n_samples = len(zs)
for i in range(n_samples):
current_n_atoms = len(zs[i])
missing_n_atoms = max_n_atoms - current_n_atoms
zs_padding = np.zeros(missing_n_atoms)
zs[i] = np.concatenate((zs[i], zs_padding))
return np.asarray(zs, dtype=np.float32)
def _generate_compounds_from_data(self, xyz, classes):
"""
This function generates the compounds from xyz data and nuclear charges.
:param xyz: cartesian coordinates
:type xyz: numpy array of shape (n_samples, n_atoms, 3)
:param classes: classes for atomic decomposition
:type classes: None
:return: array of compound objects
"""
compounds = np.empty(xyz.shape[0], dtype=object)
for i in range(xyz.shape[0]):
compounds[i] = Compound()
compounds[i].set_compounds(xyz=xyz[i], zs=classes[i])
return compounds
def predict(self, x, classes=None):
"""
This function calls the predict function for either ARMP or MRMP.
:param x: representation or indices
:type x: numpy array of shape (n_samples, n_features) or (n_samples, n_atoms, n_features) or an array of ints
:param classes: the classes to use for atomic decomposition
:type classes: numpy array of shape (n_sample, n_atoms)
:return: predictions of the molecular properties.
:rtype: numpy array of shape (n_samples,)
"""
predictions = self._predict(x, classes)
if predictions.ndim > 1 and predictions.shape[1] == 1:
return predictions.ravel()
else:
return predictions
### --------------------- ** Molecular representation - molecular properties network ** --------------------------------
class MRMP(_NN):
"""
Neural network for either
1) predicting global properties, such as energies, using molecular representations, or
2) predicting local properties, such as chemical shieldings, using atomic representations.
"""
def __init__(self, hidden_layer_sizes = (5,), l1_reg = 0.0, l2_reg = 0.0001, batch_size = 'auto', learning_rate = 0.001,
iterations = 500, tensorboard = False, store_frequency = 200, tf_dtype = tf.float32, scoring_function = 'mae',
activation_function = tf.sigmoid, optimiser = tf.train.AdamOptimizer, beta1 = 0.9, beta2 = 0.999, epsilon = 1e-08,
rho = 0.95, initial_accumulator_value = 0.1, initial_gradient_squared_accumulator_value = 0.1,
l1_regularization_strength = 0.0, l2_regularization_strength = 0.0,
tensorboard_subdir = os.getcwd() + '/tensorboard', representation_name='unsorted_coulomb_matrix', representation_params=None):
"""
Descriptors is used as input to a single or multi layered feed-forward neural network with a single output.
This class inherits from the _NN class and all inputs not unique to the NN class is passed to the _NN
parent.
"""
super(MRMP, self).__init__(hidden_layer_sizes, l1_reg, l2_reg, batch_size, learning_rate,
iterations, tensorboard, store_frequency, tf_dtype, scoring_function,
activation_function, optimiser, beta1, beta2, epsilon,
rho, initial_accumulator_value, initial_gradient_squared_accumulator_value,
l1_regularization_strength,l2_regularization_strength, tensorboard_subdir)
self._initialise_representation(representation_name, representation_params)
def _initialise_representation(self, representation, parameters):
"""
This function sets the representation and the parameters of the representation.
:param representation: the name of the representation
:type representation: string
:param parameters: all the parameters of the representation.
:type parameters: dictionary
:return: None
"""
if not is_string(representation):
raise InputError("Expected string for variable 'representation'. Got %s" % str(representation))
if representation.lower() not in ['sorted_coulomb_matrix', 'unsorted_coulomb_matrix', 'bag_of_bonds', 'slatm']:
raise InputError("Unknown representation %s" % representation)
self.representation_name = representation.lower()
if parameters is not None:
if not type(parameters) is dict:
raise InputError("The representation parameters passed should be either None or a dictionary.")
if self.representation_name == 'slatm':
self._set_slatm_parameters(parameters)
else:
if parameters is not None:
raise InputError("The representation %s does not take any additional parameters." % (self.representation_name))
def _set_representation(self, representation):
"""
This function takes representations as input and stores them inside the class.
:param representations: global representations
:type representations: numpy array of shape (n_samples, n_features)
return: None
"""
if len(representation.shape) != 2:
raise InputError("The representation should have a shape (n_samples, n_features). Got %s" % (str(representation.shape)))
self.representation = representation
def _generate_representations_from_data(self, xyz, classes, method):
"""
This function makes the representation from xyz data and nuclear charges.
:param xyz: cartesian coordinates
:type xyz: numpy array of shape (n_samples, n_atoms, 3)
:param classes: classes for atomic decomposition
:type classes: None
:param method: What method to use
:type method: string
:return: numpy array of shape (n_samples, n_features) and None
"""
if method != "fortran":
raise NotImplementedError
self.compounds = self._generate_compounds_from_data(xyz, classes)
return self._generate_representations_from_compounds('fortran')
def _generate_representations_from_compounds(self, method):
"""
This function generates the representations from the compounds.
:param method: flag that tells whether to use fortran or tensrflow implementation when there is a choice (here there is only fortran)
:type method: string
:return: the representation and None (in the ARMP class this would be the classes for atomic decomposition)
:rtype: numpy array of shape (n_samples, n_features) and None
"""
if self.compounds is None:
raise InputError("This should never happen.")
n_samples = len(self.compounds)
if self.representation_name == 'unsorted_coulomb_matrix':
nmax = self._get_msize()
representation_size = (nmax*(nmax+1))//2
x = np.empty((n_samples, representation_size), dtype=float)
for i, mol in enumerate(self.compounds):
mol.generate_coulomb_matrix(size = nmax, sorting = "unsorted")
x[i] = mol.representation
elif self.representation_name == 'sorted_coulomb_matrix':
nmax = self._get_msize()
representation_size = (nmax*(nmax+1))//2
x = np.empty((n_samples, representation_size), dtype=float)
for i, mol in enumerate(self.compounds):
mol.generate_coulomb_matrix(size = nmax, sorting = "row-norm")
x[i] = mol.representation
elif self.representation_name == "bag_of_bonds":
asize = self._get_asize()
x = np.empty(n_samples, dtype=object)
for i, mol in enumerate(self.compounds):
mol.generate_bob(asize = asize)
x[i] = mol.representation
x = np.asarray(list(x), dtype=float)
elif self.representation_name == "slatm":
mbtypes = self._get_slatm_mbtypes([mol.nuclear_charges for mol in self.compounds])
x = np.empty(n_samples, dtype=object)
for i, mol in enumerate(self.compounds):
mol.generate_slatm(mbtypes, local = False, sigmas = [self.slatm_parameters['slatm_sigma1'],
self.slatm_parameters['slatm_sigma2']],
dgrids = [self.slatm_parameters['slatm_dgrid1'], self.slatm_parameters['slatm_dgrid2']],
rcut = self.slatm_parameters['slatm_rcut'],
alchemy = self.slatm_parameters['slatm_alchemy'],
rpower = self.slatm_parameters['slatm_rpower'])
x[i] = mol.representation
x = np.asarray(list(x), dtype=float)
else:
raise InputError("This should never happen. Unrecognised representation. Got %s." % str(self.representation_name))
return x, None
#TODO upgrade so that this uses tf.Dataset like the ARMP class
def _fit(self, x, y, dy, classes):
"""
This function fits a NON atomic decomposed network to the data.
:param x: either the representations or the indices to the data points to use
:type x: either a numpy array of shape (n_samples, n_features) or a numpy array of ints
:param y: either the properties or None
:type y: either a numpy array of shape (n_samples,) or None
:param dy: None
:type dy: None
:param classes: None
:type classes: None
:return: None
"""
x_approved, y_approved, dy_approved, classes_approved = self._check_inputs(x, y, dy, classes)
# Useful quantities
self.n_features = x_approved.shape[1]
self.n_samples = x_approved.shape[0]
# Set the batch size
batch_size = self._get_batch_size()
tf.reset_default_graph()
# Initial set up of the NN
with tf.name_scope("Data"):
tf_x = tf.placeholder(self.tf_dtype, [None, self.n_features], name="Descriptors")
tf_y = tf.placeholder(self.tf_dtype, [None, 1], name="Properties")
# Either initialise the weights and biases or restart training from wherever it was stopped
with tf.name_scope("Weights"):
weights, biases = self._generate_weights(n_out = 1)
# Log weights for tensorboard
if self.tensorboard:
self.tensorboard_logger_training.write_weight_histogram(weights)
with tf.name_scope("Model"):
y_pred = self._model(tf_x, weights, biases)
with tf.name_scope("Cost_func"):
cost = self._cost(y_pred, tf_y, weights)
if self.tensorboard:
cost_summary = tf.summary.scalar('cost', cost)
# optimizer = tf.train.AdamOptimizer(learning_rate=self.learning_rate).minimize(cost)
optimiser = self._set_optimiser()
optimisation_op = optimiser.minimize(cost)
# Initialisation of the variables
init = tf.global_variables_initializer()
if self.tensorboard:
self.tensorboard_logger_training.initialise()
# This is the total number of batches in which the training set is divided
n_batches = ceil(self.n_samples, batch_size)
self.session = tf.Session()
# Running the graph
if self.tensorboard:
self.tensorboard_logger_training.set_summary_writer(self.session)
self.session.run(init)
indices = np.arange(0,self.n_samples, 1)
for i in range(self.iterations):
# This will be used to calculate the average cost per iteration
avg_cost = 0
# Learning over the batches of data
for j in range(n_batches):
batch_x = x_approved[indices][j * batch_size:(j + 1) * batch_size]
batch_y = y_approved[indices][j * batch_size:(j+1) * batch_size]
if self.AdagradDA:
feed_dict = {tf_x: batch_x, tf_y: batch_y, self.global_step:i}
opt, c = self.session.run([optimisation_op, cost], feed_dict=feed_dict)
else:
feed_dict = {tf_x: batch_x, tf_y: batch_y}
opt, c = self.session.run([optimisation_op, cost], feed_dict=feed_dict)
avg_cost += c * batch_x.shape[0] / x_approved.shape[0]
if self.tensorboard and j == 0:
if i % self.tensorboard_logger_training.store_frequency == 0:
self.tensorboard_logger_training.write_summary(self.session, i, feed_dict=feed_dict)
self.training_cost.append(avg_cost)
# Shuffle the dataset at each iteration
np.random.shuffle(indices)
def _model(self, x, weights, biases):
"""
Constructs the molecular neural network.
:param x: representation
:type x: tf.placeholder of shape (n_samples, n_features)
:param weights: Weights used in the network.
:type weights: list of tf.Variables of length hidden_layer_sizes.size + 1
:param biases: Biases used in the network.
:type biases: list of tf.Variables of length hidden_layer_sizes.size + 1
:return: Output
:rtype: tf.Variable of size (n_samples, n_targets)
"""
# Calculate the activation of the first hidden layer
z = tf.add(tf.matmul(x, tf.transpose(weights[0])), biases[0])
h = self.activation_function(z)
# Calculate the activation of the remaining hidden layers
for i in range(self.hidden_layer_sizes.size - 1):
z = tf.add(tf.matmul(h, tf.transpose(weights[i + 1])), biases[i + 1])
h = self.activation_function(z)
# Calculating the output of the last layer
z = tf.add(tf.matmul(h, tf.transpose(weights[-1])), biases[-1], name="output")
return z
def _score_r2(self, x, y=None, dy=None, classes=None):
"""
Calculate the coefficient of determination (R^2).
Larger values corresponds to a better prediction.
:param x: either the representations or the indices to the representations
:type x: either a numpy array of shape (n_samples, n_features) or a numpy array of ints
:param y: either the properties or None
:type y: either a numpy array of shape (n_samples,) or None
:param dy: None
:type dy: None
:param classes: None
:type classes: None
:return: R^2
:rtype: float
"""
x_approved, y_approved, dy_approved, classes_approved = self._check_inputs(x, y, dy, classes)
y_pred = self.predict(x_approved)
r2 = r2_score(y_approved, y_pred, sample_weight = None)
return r2
def _score_mae(self, x, y=None, dy=None, classes=None):
"""
Calculate the mean absolute error.
Smaller values corresponds to a better prediction.
:param x: either the representations or the indices to the representations
:type x: either a numpy array of shape (n_samples, n_features) or a numpy array of ints
:param y: either the properties or None
:type y: either a numpy array of shape (n_samples,) or None
:param dy: None
:type dy: None
:param classes: None
:type classes: None
:return: Mean absolute error
:rtype: float
"""
x_approved, y_approved, dy_approved, classes_approved = self._check_inputs(x, y, dy, classes)
y_pred = self.predict(x_approved)
mae = (-1.0)*mean_absolute_error(y_approved, y_pred, sample_weight = None)
print("Warning! The mae is multiplied by -1 so that it can be minimised in Osprey!")
return mae
def _score_rmse(self, x, y=None, dy=None, classes=None):
"""
Calculate the root mean squared error.
Smaller values corresponds to a better prediction.
:param x: either the representations or the indices to the representations
:type x: either a numpy array of shape (n_samples, n_features) or a numpy array of ints
:param y: either the properties or None
:type y: either a numpy array of shape (n_samples,) or None
:param dy: None
:type dy: None
:param classes: None
:type classes: None
:return: Mean absolute error
:rtype: float
"""
x_approved, y_approved, dy_approved, classes_approved = self._check_inputs(x, y, dy, classes)
y_pred = self.predict(x_approved)
rmse = np.sqrt(mean_squared_error(y_approved, y_pred, sample_weight = None))
return rmse
def _check_inputs(self, x, y, dy, classes):
"""
This function checks whether x contains indices or data. If it contains indices, the data is extracted by the
appropriate compound objects. Otherwise it checks what data is passed through the arguments.
:param x: indices or data
:type x: numpy array of ints of shape (n_samples,) or floats of shape (n_samples, n_atoms, 3)
:param y: None or energies
:type y: None or numpy array of floats of shape (n_samples,)
:param dy: None or forces
:type dy: None or floats of shape (n_samples, n_atoms, 3)
:param classes: None or different NN classes available
:type classes: None or numpy array of ints of shape (n_samples, n_atoms)
:return: the approved x, y dy and classes
:rtype: numpy array of shape (n_samples, n_features), (n_samples, 1), None, None
"""
if not is_array_like(x):
raise InputError("x should be an array either containing indices or data.")
if dy is not None and classes is not None:
raise InputError("MRMP estimator cannot predict gradients and do atomic decomposition.")
# Check if x is made up of indices or data
if is_positive_integer_or_zero_array(x):
if self.representation is None:
if self.compounds is None:
raise InputError("No representations or QML compounds have been set yet.")
else:
self.representation, _ = self._generate_representations_from_compounds()
if self.properties is None:
raise InputError("The properties need to be set in advance.")
approved_x = self.representation[x]
approved_y = self._get_properties(x)
approved_dy = None
approved_classes = None
check_sizes(approved_x, approved_y, approved_dy, approved_classes)
else:
if y is None:
raise InputError("y cannot be of None type.")
approved_x = check_global_representation(x)
approved_y = check_y(y)
approved_dy = None
approved_classes = None
check_sizes(approved_x, approved_y, approved_dy, approved_classes)
return approved_x, approved_y, approved_dy, approved_classes
def _check_predict_input(self, x, classes):
"""
This function checks whether x contains indices or data. If it contains indices, the data is extracted by the
appropriate compound objects. Otherwise it checks what data is passed through the arguments.
:param x: indices or data
:type x: numpy array of ints of shape (n_samples,) or floats of shape (n_samples, n_features)
:param classes: None
:type classes: None
:return: the approved x and classes
:rtype: numpy array of shape (n_samples, n_features), None
"""
if not is_array_like(x):
raise InputError("x should be an array either containing indices or data.")
if classes is not None:
raise InputError("MRMP estimator cannot do atomic decomposition.")
# Check if x is made up of indices or data
if is_positive_integer_or_zero_array(x):
if self.representation is None:
if self.compounds is None:
raise InputError("No representations or QML compounds have been set yet.")
else:
self.representation, _ = self._generate_representations_from_compounds()
if self.properties is None:
raise InputError("The properties need to be set in advance.")
approved_x = self.representation[x]
approved_classes = None
else:
approved_x = check_global_representation(x)
approved_classes = None
return approved_x, approved_classes
def _cost(self, y_pred, y, weights):
"""
Constructs the cost function
:param y_pred: Predicted molecular properties
:type y_pred: tf.Variable of size (n_samples, 1)
:param y: True molecular properties
:type y: tf.placeholder of shape (n_samples, 1)
:param weights: Weights used in the network.
:type weights: list of tf.Variables of length hidden_layer_sizes.size + 1
:return: Cost
:rtype: tf.Variable of size (1,)
"""
err = tf.square(tf.subtract(y,y_pred))
loss = tf.reduce_mean(err, name="loss")
cost = loss
if self.l2_reg > 0:
l2_loss = self._l2_loss(weights)
cost = cost + l2_loss
if self.l1_reg > 0:
l1_loss = self._l1_loss(weights)
cost = cost + l1_loss
return cost
def _predict(self, x, classes):
"""
This function checks whether x contains indices or data. If it contains indices, the data is extracted by the
appropriate compound objects. Otherwise it checks what data is passed through the arguments. Then, the data is
used as input to the trained network to predict some properties.
:param x: indices or data
:type x: numpy array of ints of shape (n_samples,) or floats of shape (n_samples, n_features)
:param classes: None
:type classes: None
:return: the predicted properties
:rtype: numpy array of shape (n_samples,)
"""
approved_x, approved_classes = self._check_predict_input(x, classes)
if self.session == None:
raise InputError("Model needs to be fit before predictions can be made.")
graph = tf.get_default_graph()
with graph.as_default():
tf_x = graph.get_tensor_by_name("Data/Descriptors:0")
model = graph.get_tensor_by_name("Model/output:0")
y_pred = self.session.run(model, feed_dict = {tf_x : approved_x})
return y_pred
# TODO these need to be checked if they still work
def save_nn(self, save_dir="./saved_model"):
"""
This function saves the model to be used for later prediction.
:param save_dir: name of the directory to create to save the model
:type save_dir: string
:return: None
"""
if self.session == None:
raise InputError("Model needs to be fit before predictions can be made.")
if not os.path.exists(save_dir):
pass
else:
ii = 1
while True:
new_save_dir = save_dir + "_" + str(ii)
if not os.path.exists(new_save_dir):
save_dir = new_save_dir
break
graph = tf.get_default_graph()
with graph.as_default():
tf_x = graph.get_tensor_by_name("Data/Descriptors:0")
model = graph.get_tensor_by_name("Model/output:0")
tf.saved_model.simple_save(self.session, export_dir=save_dir,
inputs={"Data/Descriptors:0": tf_x},
outputs={"Model/output:0": model})
def load_nn(self, save_dir="saved_model"):
"""
This function reloads a model for predictions.
:param save_dir: the name of the directory where the model is saved.
:type save_dir: string
:return: None
"""
self.session = tf.Session(graph=tf.get_default_graph())
tf.saved_model.loader.load(self.session, [tf.saved_model.tag_constants.SERVING], save_dir)
### --------------------- ** Atomic representation - molecular properties network ** -----------------------------------
class ARMP(_NN):
"""
The ``ARMP`` class is used to build neural networks that take as an input atomic representations of molecules and
output molecular properties such as the energies.
"""
def __init__(self, hidden_layer_sizes = (5,), l1_reg = 0.0, l2_reg = 0.0001, batch_size = 'auto', learning_rate = 0.001,
iterations = 500, tensorboard = False, store_frequency = 200, tf_dtype = tf.float32, scoring_function = 'mae',
activation_function = tf.sigmoid, optimiser = tf.train.AdamOptimizer, beta1 = 0.9, beta2 = 0.999, epsilon = 1e-08,
rho = 0.95, initial_accumulator_value = 0.1, initial_gradient_squared_accumulator_value = 0.1,
l1_regularization_strength = 0.0, l2_regularization_strength = 0.0,
tensorboard_subdir = os.getcwd() + '/tensorboard', representation_name='acsf', representation_params=None):
"""
To see what parameters are required, look at the description of the _NN class init.
This class inherits from the _NN class and all inputs not unique to the ARMP class are passed to the _NN
parent.
"""
super(ARMP, self).__init__(hidden_layer_sizes, l1_reg, l2_reg, batch_size, learning_rate,
iterations, tensorboard, store_frequency, tf_dtype, scoring_function,
activation_function, optimiser, beta1, beta2, epsilon,
rho, initial_accumulator_value, initial_gradient_squared_accumulator_value,
l1_regularization_strength,l2_regularization_strength, tensorboard_subdir)
self._initialise_representation(representation_name, representation_params)
def _initialise_representation(self, representation, parameters):
"""
This function sets the representation and the parameters of the representation.
:param representation: the name of the representation
:type representation: string
:param parameters: all the parameters of the representation.
:type parameters: dictionary
:return: None
"""
if not is_string(representation):
raise InputError("Expected string for variable 'representation'. Got %s" % str(representation))
if representation.lower() not in ['slatm', 'acsf']:
raise InputError("Representation %s not implemented." % representation)
self.representation_name = representation.lower()
if parameters is not None:
if not type(parameters) is dict:
raise InputError("The representation parameters passed should be either None or a dictionary.")
self._check_representation_parameters(parameters)
if self.representation_name == 'slatm':
self._set_slatm_parameters(parameters)
elif self.representation_name == 'acsf':
self._set_acsf_parameters(parameters)
else:
if parameters is not None:
raise InputError("The representation %s does not take any additional parameters." % (self.representation_name))
def _set_representation(self, representation):
if len(representation.shape) != 3:
raise InputError(
"The representation should have a shape (n_samples, n_atoms, n_features). Got %s" % (str(representation.shape)))
self.representation = representation
def _generate_representations_from_data(self, xyz, classes, method):
"""
This function generates the representations from xyz data
:param xyz: the cartesian coordinates
:type xyz: numpy array of shape (n_samples, n_atoms, 3)
:param classes: classes to use for atomic decomposition
:type classes: numpy array of shape (n_samples, n_atoms)
:param method: What method to use
:type method: string
:return: representations and classes
:rtype: numpy arrays of shape (n_samples, n_atoms, n_features) and (n_samples, n_atoms)
"""
if method not in ['fortran', 'tf']:
raise InputError("The method to generate the acsf can only be 'fortran' or 'tf'. Got %s." % (method))
if isinstance(classes, type(None)):
raise InputError("The classes need to be provided for the ARMP estimator.")
else:
if len(classes.shape) > 2 or np.all(xyz.shape[:2] != classes.shape):
raise InputError("Classes should be a 2D array with shape matching the first 2 dimensions of the xyz data"
". Got shape %s" % (str(classes.shape)))
representation = None
if self.representation_name == 'slatm':
self.compounds = self._generate_compounds_from_data(xyz, classes)
representation, classes = self._generate_representations_from_compounds('fortran')
elif self.representation_name == 'acsf':
if method == 'tf':
representation = self._generate_acsf_tf(xyz, classes)
else:
representation = self._generate_acsf_fortran(xyz, classes)
return representation, classes
def _generate_acsf_tf(self, xyz, classes):
"""
This function generates the acsf from the cartesian coordinates and the classes.
:param xyz: cartesian coordinates
:type xyz: numpy array of shape (n_samples, n_atoms, 3)
:param classes: the classes to use for atomic decomposition
:type classes: numpy array of shape (n_samples, n_atoms)
:return: representation acsf
:rtype: numpy array of shape (n_samples, n_atoms, n_features)
"""
if 0 in classes:
idx_zeros = np.where(classes == 0)[1]
classes_for_elements = classes[:, :idx_zeros[0]]
else:
classes_for_elements = classes
elements, element_pairs = self._get_elements_and_pairs(classes_for_elements)
if self.tensorboard:
self.tensorboard_logger_representation.initialise()
n_samples = xyz.shape[0]
max_n_atoms = xyz.shape[1]
# Turning the quantities into tensors
with tf.name_scope("Inputs"):
zs_tf = tf.placeholder(shape=[n_samples, max_n_atoms], dtype=tf.int32, name="zs")
xyz_tf = tf.placeholder(shape=[n_samples, max_n_atoms, 3], dtype=tf.float32, name="xyz")
dataset = tf.data.Dataset.from_tensor_slices((xyz_tf, zs_tf))
dataset = dataset.batch(20)
iterator = tf.data.Iterator.from_structure(dataset.output_types, dataset.output_shapes)
batch_xyz, batch_zs = iterator.get_next()
representation = generate_acsf_tf(xyzs=batch_xyz, Zs=batch_zs, elements=elements, element_pairs=element_pairs,
rcut=self.acsf_parameters['rcut'],
acut=self.acsf_parameters['acut'],
nRs2=self.acsf_parameters['nRs2'],
nRs3=self.acsf_parameters['nRs3'],
nTs=self.acsf_parameters['nTs'], eta=self.acsf_parameters['eta'],
zeta=self.acsf_parameters['zeta'],
bin_min=self.acsf_parameters['bin_min'])
sess = tf.Session()
sess.run(tf.global_variables_initializer())
sess.run(iterator.make_initializer(dataset), feed_dict={xyz_tf: xyz, zs_tf: classes})
representation_slices = []
if self.tensorboard:
self.tensorboard_logger_representation.set_summary_writer(sess)
batch_counter = 0
while True:
try:
representation_np = sess.run(representation, options=self.tensorboard_logger_representation.options,
run_metadata=self.tensorboard_logger_representation.run_metadata)
self.tensorboard_logger_representation.write_metadata(batch_counter)
representation_slices.append(representation_np)
batch_counter += 1
except tf.errors.OutOfRangeError:
print("Generated all the representations.")
break
else:
batch_counter = 0
while True:
try:
representation_np = sess.run(representation)
representation_slices.append(representation_np)
batch_counter += 1
except tf.errors.OutOfRangeError:
break
representation_conc = np.concatenate(representation_slices, axis=0)
sess.close()
return representation_conc
def _generate_acsf_fortran(self, xyz, classes):
"""
This function uses fortran to generate the representation and the derivative of the representation with respect
to the cartesian coordinates.
:param xyz: cartesian coordinates
:type xyz: numpy array of shape (n_samples, n_atoms, 3)
:param classes: the atom types
:type classes: numpy array of shape (n_samples, n_atoms)
:return: representations and their derivatives wrt to xyz
:rtype: numpy array of shape (n_samples, n_atoms, n_features) and (n_samples, n_atoms, n_features, n_atoms, 3)
"""
initial_natoms = xyz.shape[1]
elements, _ = self._get_elements_and_pairs(classes)
representation = []
for i in range(xyz.shape[0]):
if 0 in classes[i]:
idx_zeros = np.where(classes[i] == 0)[0]
mol_xyz = xyz[i, :idx_zeros[0], :]
mol_classes = classes[i, :idx_zeros[0]]
g = generate_acsf(coordinates=mol_xyz, elements=elements, gradients=False, nuclear_charges=mol_classes,
rcut=self.acsf_parameters['rcut'],
acut=self.acsf_parameters['acut'],
nRs2=self.acsf_parameters['nRs2'],
nRs3=self.acsf_parameters['nRs3'],
nTs=self.acsf_parameters['nTs'],
eta2=self.acsf_parameters['eta'],
eta3=self.acsf_parameters['eta'],
zeta=self.acsf_parameters['zeta'],
bin_min=self.acsf_parameters['bin_min'])
padded_g = np.zeros((initial_natoms, g.shape[-1]))
padded_g[:g.shape[0], :] = g
# Hotfix t make sure the representation is single precision
single_precision_g = padded_g.astype(dtype=np.float32)
del padded_g
representation.append(single_precision_g)
else:
g = generate_acsf(coordinates=xyz[i], elements=elements, gradients=False, nuclear_charges=classes[i],
rcut=self.acsf_parameters['rcut'],
acut=self.acsf_parameters['acut'],
nRs2=self.acsf_parameters['nRs2'],
nRs3=self.acsf_parameters['nRs3'],
nTs=self.acsf_parameters['nTs'],
eta2=self.acsf_parameters['eta'],
eta3=self.acsf_parameters['eta'],
zeta=self.acsf_parameters['zeta'])
single_precision_g = g.astype(dtype=np.float32)
del g
representation.append(single_precision_g)
return np.asarray(representation)
def _generate_representations_from_compounds(self, method):
"""
This function generates the representations from the compounds.
:return: the representations and the classes
:rtype: numpy array of shape (n_samples, n_atoms, n_features) and (n_samples, n_atoms)
"""
if self.compounds is None:
raise InputError("QML compounds needs to be created in advance")
if self.representation_name == 'slatm':
representations, classes = self._generate_slatm_from_compounds()
elif self.representation_name == 'acsf':
xyz, classes = self._extract_and_pad()
if method == "tf":
representations = self._generate_acsf_tf(xyz, classes)
elif method == "fortran":
representations = self._generate_acsf_fortran(xyz, classes)
else:
raise InputError("Method not recognised.")
else:
raise InputError("This should never happen, unrecognised representation %s." % (self.representation_name))
# Hotfix t make sure the representation is single precision
single_precision_representation = representations.astype(dtype=np.float32)
del representations
return single_precision_representation, classes
def _extract_and_pad(self):
"""
This function extracts cartesian coordinates and nuclear charges for the compounds and pads them.
:return: xyz and zs padded
:rtype: numpy arrays of shape (n_samples, max_n_atoms, 3) and (n_samples, max_n_atoms)
"""
# Obtaining the xyz and the nuclear charges from the compounds
xyzs = []
zs = []
max_n_atoms = 0
for compound in self.compounds:
xyzs.append(compound.coordinates)
zs.append(compound.nuclear_charges)
if len(compound.nuclear_charges) > max_n_atoms:
max_n_atoms = len(compound.nuclear_charges)
n_samples = len(xyzs)
# Padding the xyz and the nuclear charges
padded_xyz = np.zeros((n_samples, max_n_atoms, 3))
padded_zs = np.zeros((n_samples, max_n_atoms))
for i in range(n_samples):
current_n_atoms = xyzs[i].shape[0]
padded_xyz[i, :current_n_atoms, :] = xyzs[i]
padded_zs[i, :current_n_atoms] = zs[i]
return padded_xyz, padded_zs
def _generate_slatm_from_compounds(self):
"""
This function generates the slatm using the data in the compounds.
:return: representation slatm and the classes
:rtype: numpy array of shape (n_samples, n_atoms, n_features) and (n_samples, n_atoms)
"""
mbtypes = qml_rep.get_slatm_mbtypes([mol.nuclear_charges for mol in self.compounds])
list_representations = []
max_n_atoms = 0
# Generating the representation in the shape that ARMP requires it
for compound in self.compounds:
compound.generate_slatm(mbtypes, local=True, sigmas=[self.slatm_parameters['slatm_sigma1'],
self.slatm_parameters['slatm_sigma2']],
dgrids=[self.slatm_parameters['slatm_dgrid1'],
self.slatm_parameters['slatm_dgrid2']],
rcut=self.slatm_parameters['slatm_rcut'],
alchemy=self.slatm_parameters['slatm_alchemy'],
rpower=self.slatm_parameters['slatm_rpower'])
representation = compound.representation
if max_n_atoms < representation.shape[0]:
max_n_atoms = representation.shape[0]
list_representations.append(representation)
# Padding the representations of the molecules that have fewer atoms
n_samples = len(list_representations)
n_features = list_representations[0].shape[1]
padded_representations = np.zeros((n_samples, max_n_atoms, n_features))
for i, item in enumerate(list_representations):
padded_representations[i, :item.shape[0], :] = item
# Generating zs in the shape that ARMP requires it
zs = np.zeros((n_samples, max_n_atoms))
for i, mol in enumerate(self.compounds):
zs[i, :mol.nuclear_charges.shape[0]] = mol.nuclear_charges
return padded_representations, zs
def _atomic_model(self, x, hidden_layer_sizes, weights, biases):
"""
Constructs the atomic part of the network. It calculates the output for all atoms as if they all were the same
element.
:param x: Atomic representation
:type x: tf tensor of shape (n_samples, n_atoms, n_features)
:param weights: Weights used in the network for a particular element.
:type weights: list of tf.Variables of length hidden_layer_sizes.size + 1
:param biases: Biases used in the network for a particular element.
:type biases: list of tf.Variables of length hidden_layer_sizes.size + 1
:return: Output
:rtype: tf.Variable of size (n_samples, n_atoms)
"""
# Calculate the activation of the first hidden layer
z = tf.add(tf.tensordot(x, tf.transpose(weights[0]), axes=1), biases[0])
h = self.activation_function(z)
# Calculate the activation of the remaining hidden layers
for i in range(hidden_layer_sizes.size - 1):
z = tf.add(tf.tensordot(h, tf.transpose(weights[i + 1]), axes=1), biases[i + 1])
h = self.activation_function(z)
# Calculating the output of the last layer
z = tf.add(tf.tensordot(h, tf.transpose(weights[-1]), axes=1), biases[-1])
z_squeezed = tf.squeeze(z, axis=[-1])
return z_squeezed
def _model(self, x, zs, element_weights, element_biases):
"""
This generates the molecular model by combining all the outputs from the atomic networks.
:param x: Atomic representation
:type x: tf tensor of shape (n_samples, n_atoms, n_features)
:param zs: Nuclear charges of the systems
:type zs: tf tensor of shape (n_samples, n_atoms)
:param element_weights: Element specific weights
:type element_weights: list of tf.Variables of length hidden_layer_sizes.size + 1
:param element_biases: Element specific biases
:type element_biases: list of tf.Variables of length hidden_layer_sizes.size + 1
:return: Predicted properties for all samples
:rtype: tf tensor of shape (n_samples, 1)
"""
all_atomic_energies = tf.zeros_like(zs, dtype=tf.float32)
for el in self.elements:
# Obtaining the indices of where in Zs there is the current element
current_element = tf.expand_dims(tf.constant(el, dtype=tf.int32), axis=0)
where_element = tf.cast(tf.where(tf.equal(zs, current_element)), dtype=tf.int32)
# Extract the descriptor corresponding to the right element
current_element_in_x = tf.gather_nd(x, where_element)
# Calculate the atomic energy of all the atoms of type equal to the current element
atomic_ene = self._atomic_model(current_element_in_x, self.hidden_layer_sizes, element_weights[el],
element_biases[el])
# Put the atomic energies in a zero array with shape equal to zs and then add it to all the atomic energies
updates = tf.scatter_nd(where_element, atomic_ene, tf.shape(zs))
all_atomic_energies = tf.add(all_atomic_energies, updates)
# Summing the energies of all the atoms
total_energies = tf.reduce_sum(all_atomic_energies, axis=-1, name="output", keepdims=True)
return total_energies
def _cost(self, y_pred, y, weights_dict):
"""
This function calculates the cost function during the training of the neural network.
:param y_pred: the neural network predictions
:type y_pred: tensors of shape (n_samples, 1)
:param y: the truth values
:type y: tensors of shape (n_samples, 1)
:param weights_dict: the dictionary containing all of the weights
:type weights_dict: dictionary where the key is a nuclear charge and the value is a list of tensors of length hidden_layer_sizes.size + 1
:return: value of the cost function
:rtype: tf.Variable of size (1,)
"""
err = tf.square(tf.subtract(y, y_pred))
cost_function = tf.reduce_mean(err, name="loss")
if self.l2_reg > 0:
l2_loss = 0
for element in weights_dict:
l2_loss += self._l2_loss(weights_dict[element])
cost_function += l2_loss
if self.l1_reg > 0:
l1_loss = 0
for element in weights_dict:
l1_loss += self._l1_loss(weights_dict[element])
cost_function += l1_loss
return cost_function
def _check_inputs(self, x, y, dy, classes):
"""
This function checks that all the needed input data is available.
:param x: either the representations or the indices to the data points to use
:type x: either a numpy array of shape (n_samples, n_atoms, n_features) or a numpy array of ints
:param y: either the properties or None
:type y: either a numpy array of shape (n_samples,) or None
:param dy: None
:type dy: None
:param classes: classes to use for the atomic decomposition
:type classes: either a numpy array of shape (n_samples, n_atoms) or None
:return: the approved x, y dy and classes
:rtype: numpy array of shape (n_samples, n_atoms, n_features), (n_samples, 1), None, (n_samples, n_atoms)
"""
if not is_array_like(x):
raise InputError("x should be an array either containing indices or data.")
if dy is not None:
raise InputError("ARMP estimator cannot be used to predict gradients. Use ARMP_G estimator.")
# Check if x is made up of indices or data
if is_positive_integer_or_zero_array(x):
if self.representation is None:
if self.compounds is None:
raise InputError("No representations or QML compounds have been set yet.")
else:
self.representation, self.classes = self._generate_representations_from_compounds()
if self.properties is None:
raise InputError("The properties need to be set in advance.")
if self.classes is None:
raise InputError("The classes need to be set in advance.")
approved_x = self.representation[x]
approved_y = self._get_properties(x)
approved_dy = None
approved_classes = self.classes[x]
check_sizes(approved_x, approved_y, approved_dy, approved_classes)
else:
if y is None:
raise InputError("y cannot be of None type.")
if classes is None:
raise InputError("ARMP estimator needs the classes to do atomic decomposition.")
approved_x = check_local_representation(x)
approved_y = check_y(y)
approved_dy = None
approved_classes = check_classes(classes)
check_sizes(approved_x, approved_y, approved_dy, approved_classes)
return approved_x, approved_y, approved_dy, approved_classes
def _check_predict_input(self, x, classes):
"""
This function checks whether x contains indices or data. If it contains indices, the data is extracted by the
appropriate compound objects. Otherwise it checks what data is passed through the arguments.
:param x: indices or data
:type x: numpy array of ints of shape (n_samples,) or floats of shape (n_samples, n_atoms, n_features)
:param classes: classes to use for the atomic decomposition or None
:type classes: either a numpy array of shape (n_samples, n_atoms) or None
:return: the approved representation and classes
:rtype: numpy array of shape (n_samples, n_atoms, n_features), (n_samples, n_atoms)
"""
if not is_array_like(x):
raise InputError("x should be an array either containing indices or data.")
# Check if x is made up of indices or data
if is_positive_integer_or_zero_array(x):
if self.representation is None:
if self.compounds is None:
raise InputError("No representations or QML compounds have been set yet.")
else:
self.representation, self.classes = self._generate_representations_from_compounds()
if isinstance(self.properties, type(None)):
raise InputError("The properties need to be set in advance.")
approved_x = self.representation[x]
approved_classes = self.classes[x]
check_sizes(x=approved_x, classes=approved_classes)
else:
if isinstance(classes, type(None)):
raise InputError("ARMP estimator needs the classes to do atomic decomposition.")
approved_x = check_local_representation(x)
approved_classes = check_classes(classes)
check_sizes(x=approved_x, classes=approved_classes)
return approved_x, approved_classes
def _check_representation_parameters(self, parameters):
"""
This function checks that the dictionary passed that contains parameters of the representation contains the right
parameters.
:param parameters: all the parameters of the representation.
:type parameters: dictionary
:return: None
"""
if self.representation_name == "slatm":
slatm_parameters = {'slatm_sigma1': 0.05, 'slatm_sigma2': 0.05, 'slatm_dgrid1': 0.03, 'slatm_dgrid2': 0.03,
'slatm_rcut': 4.8, 'slatm_rpower': 6, 'slatm_alchemy': False}
for key, value in parameters.items():
try:
slatm_parameters[key]
except Exception:
raise InputError("Unrecognised parameter for slatm representation: %s" % (key))
elif self.representation_name == "acsf":
acsf_parameters = {'rcut': 5.0, 'acut': 5.0, 'nRs2': 5, 'nRs3': 5, 'nTs': 5,
'zeta': 220.127, 'eta': 30.8065, 'bin_min':0.8}
for key, value in parameters.items():
try:
acsf_parameters[key]
except Exception:
raise InputError("Unrecognised parameter for acsf representation: %s" % (key))
def _get_elements_and_pairs(self, classes):
"""
This function generates the atom centred symmetry functions.
:param classes: The different types of atoms present in the system
:type classes: numpy array of shape (n_samples, n_atoms)
:return: elements and element pairs in the system
:rtype: numpy array of shape (n_elements,) and (n_element_pairs)
"""
elements = np.unique(classes)
elements_no_zero = np.ma.masked_equal(elements,0).compressed()
element_pairs = []
for i, ei in enumerate(elements_no_zero):
for ej in elements_no_zero[i:]:
element_pairs.append([ej, ei])
return np.asarray(elements_no_zero), np.asarray(element_pairs)
def _find_elements(self, zs):
"""
This function finds the unique atomic numbers in Zs and returns them in a list.
:param zs: nuclear charges
:type zs: numpy array of floats of shape (n_samples, n_atoms)
:return: unique nuclear charges
:rtype: numpy array of floats of shape (n_elements,)
"""
# Obtaining the unique atomic numbers (but still includes the dummy atoms)
elements = np.unique(zs)
# Removing the dummy
return np.trim_zeros(elements)
def _fit(self, x, y, dy, classes):
"""
This function calls either fit_from_scratch or fit_from_loaded depending on if a model has been loaded or not.
:param x: either the representations or the indices to the data points to use
:type x: either a numpy array of shape (n_samples, n_atoms, n_features) or a numpy array of ints
:param y: either the properties or None
:type y: either a numpy array of shape (n_samples,) or None
:param dy: None
:type dy: None
:param classes: classes to use for the atomic decomposition or None
:type classes: either a numpy array of shape (n_samples, n_atoms) or None
:return: None
"""
if not self.loaded_model:
self._fit_from_scratch(x, y, dy, classes)
else:
self._fit_from_loaded(x, y, dy, classes)
def _fit_from_scratch(self, x, y, dy, classes):
"""
This function fits an atomic decomposed network to the data.
:param x: either the representations or the indices to the data points to use
:type x: either a numpy array of shape (n_samples, n_atoms, n_features) or a numpy array of ints
:param y: either the properties or None
:type y: either a numpy array of shape (n_samples,) or None
:param dy: None
:type dy: None
:param classes: classes to use for the atomic decomposition or None
:type classes: either a numpy array of shape (n_samples, n_atoms) or None
:return: None
"""
x_approved, y_approved, dy_approved, classes_approved = self._check_inputs(x, y, dy, classes)
# Putting a mask on all the 0 values
classes_for_elements = np.ma.masked_equal(classes_approved, 0).compressed()
self.elements, self.element_pairs = self._get_elements_and_pairs(classes_for_elements)
if self.tensorboard:
self.tensorboard_logger_training.initialise()
# Useful quantities
self.n_samples = x_approved.shape[0]
self.n_atoms = x_approved.shape[1]
self.n_features = x_approved.shape[2]
# Set the batch size
batch_size = self._get_batch_size()
# This is the total number of batches in which the training set is divided
n_batches = ceil(self.n_samples, batch_size)
tf.reset_default_graph()
# Initial set up of the NN
with tf.name_scope("Data"):
x_ph = tf.placeholder(dtype=self.tf_dtype, shape=[None, self.n_atoms, self.n_features], name="Descriptors")
zs_ph = tf.placeholder(dtype=tf.int32, shape=[None, self.n_atoms], name="Atomic-numbers")
y_ph = tf.placeholder(dtype=self.tf_dtype, shape=[None, 1], name="Properties")
buffer_tf = tf.placeholder(dtype=tf.int64, name="buffer")
dataset = tf.data.Dataset.from_tensor_slices((x_ph, zs_ph, y_ph))
dataset = dataset.shuffle(buffer_size=buffer_tf)
dataset = dataset.batch(batch_size)
# batched_dataset = dataset.prefetch(buffer_size=batch_size)
iterator = tf.data.Iterator.from_structure(dataset.output_types, dataset.output_shapes)
tf_x, tf_zs, tf_y = iterator.get_next()
# Creating dictionaries of the weights and biases for each element
element_weights = {}
element_biases = {}
with tf.name_scope("Weights"):
for i in range(self.elements.shape[0]):
weights, biases = self._generate_weights(n_out=1)
element_weights[self.elements[i]] = weights
element_biases[self.elements[i]] = biases
# Log weights for tensorboard
if self.tensorboard:
self.tensorboard_logger_training.write_weight_histogram(weights)
with tf.name_scope("Model"):
molecular_energies = self._model(tf_x, tf_zs, element_weights, element_biases)
with tf.name_scope("Cost_func"):
cost = self._cost(molecular_energies, tf_y, element_weights)
if self.tensorboard:
cost_summary = self.tensorboard_logger_training.write_cost_summary(cost)
optimiser = self._set_optimiser()
optimisation_op = optimiser.minimize(cost, name="optimisation_op")
# Initialisation of the variables
init = tf.global_variables_initializer()
iterator_init = iterator.make_initializer(dataset, name="dataset_init")
if self.representation_name == "acsf":
self._build_model_from_xyz(self.n_atoms, element_weights, element_biases)
self.session = tf.Session()
# Running the graph
if self.tensorboard:
self.tensorboard_logger_training.set_summary_writer(self.session)
self.session.run(init)
# Initialising the object that enables graceful killing of the training
killer = _GracefulKiller()
for i in range(self.iterations):
if i % 2 == 0:
buff = int(3.5 * batch_size)
else:
buff = int(4.5 * batch_size)
self.session.run(iterator_init, feed_dict={x_ph: x_approved, zs_ph: classes_approved, y_ph: y_approved, buffer_tf:buff})
avg_cost = 0
for j in range(n_batches):
if self.tensorboard:
opt, c = self.session.run([optimisation_op, cost], options=self.tensorboard_logger_training.options,
run_metadata=self.tensorboard_logger_training.run_metadata)
else:
opt, c = self.session.run([optimisation_op, cost])
avg_cost += c
if killer.kill_now:
self.save_nn("emergency_save")
exit()
# This seems to run the iterator.get_next() op, which gives problems with end of sequence, hence why I re-initialise the iterator
if self.tensorboard:
if i % self.tensorboard_logger_training.store_frequency == 0:
self.session.run(iterator_init,
feed_dict={x_ph: x_approved, zs_ph: classes_approved, y_ph: y_approved,
buffer_tf: buff})
self.tensorboard_logger_training.write_summary(self.session, i)
self.training_cost.append(avg_cost/n_batches)
def _fit_from_loaded(self, x, y, dy, classes):
"""
This function carries on fitting an atomic decomposed network to the data after it has been loaded.
:param x: either the representations or the indices to the data points to use
:type x: either a numpy array of shape (n_samples, n_atoms, n_features) or a numpy array of ints
:param y: either the properties or None
:type y: either a numpy array of shape (n_samples,) or None
:param dy: None
:type dy: None
:param classes: classes to use for the atomic decomposition or None
:type classes: either a numpy array of shape (n_samples, n_atoms) or None
:return: None
"""
x_approved, y_approved, dy_approved, classes_approved = self._check_inputs(x, y, dy, classes)
if 0 in classes_approved:
idx_zeros = np.where(classes_approved == 0)[1]
classes_for_elements = classes_approved[:, :idx_zeros[0]]
else:
classes_for_elements = classes_approved
self.elements = self._find_elements(classes_for_elements)
if self.tensorboard:
self.tensorboard_logger_training.initialise()
self.tensorboard_logger_training.set_summary_writer(self.session)
self.n_samples = x_approved.shape[0]
self.n_atoms = x_approved.shape[1]
self.n_features = x_approved.shape[2]
batch_size = self._get_batch_size()
n_batches = ceil(self.n_samples, batch_size)
graph = tf.get_default_graph()
with graph.as_default():
# Reloading all the needed operations and tensors
tf_x = graph.get_tensor_by_name("Data/Descriptors:0")
tf_zs = graph.get_tensor_by_name("Data/Atomic-numbers:0")
tf_ene = graph.get_tensor_by_name("Data/Properties:0")
tf_buffer = graph.get_tensor_by_name("Data/buffer:0")
optimisation_op = graph.get_operation_by_name("optimisation_op")
dataset_init_op = graph.get_operation_by_name("dataset_init")
# Initialising the object that enables graceful killing of the training
killer = _GracefulKiller()
for i in range(self.iterations):
if i % 2 == 0:
buff = int(3.5 * batch_size)
else:
buff = int(4.5 * batch_size)
self.session.run(dataset_init_op, feed_dict={tf_x: x_approved, tf_zs: classes_approved, tf_ene: y_approved, tf_buffer: buff})
for j in range(n_batches):
if self.tensorboard:
self.session.run(optimisation_op, options=self.tensorboard_logger_training.options,
run_metadata=self.tensorboard_logger_training.run_metadata)
else:
self.session.run(optimisation_op)
if killer.kill_now:
self.save_nn("emergency_save")
exit()
if self.tensorboard:
if i % self.tensorboard_logger_training.store_frequency == 0:
self.session.run(dataset_init_op,
feed_dict={tf_x: x_approved, tf_zs: classes_approved, tf_ene: y_approved, tf_buffer: buff})
self.tensorboard_logger_training.write_summary(self.session, i)
def _build_model_from_xyz(self, n_atoms, element_weights, element_biases):
"""
This function builds a model that makes it possible to predict energies straight from xyz data. It constructs the
graph needed to do this.
:param n_atoms: number of atoms
:param element_weights: the dictionary of the trained weights in the model
:param element_biases: the dictionary of trained biases in the model
"""
with tf.name_scope("Inputs_pred"):
zs_tf = tf.placeholder(shape=[None, n_atoms], dtype=tf.int32, name="Classes")
xyz_tf = tf.placeholder(shape=[None, n_atoms, 3], dtype=tf.float32, name="xyz")
dataset = tf.data.Dataset.from_tensor_slices((xyz_tf, zs_tf))
dataset = dataset.batch(2)
iterator = tf.data.Iterator.from_structure(dataset.output_types, dataset.output_shapes)
batch_xyz, batch_zs = iterator.get_next()
iterator_init = iterator.make_initializer(dataset, name="dataset_init_pred")
with tf.name_scope("Descriptor_pred"):
batch_representation = generate_acsf_tf(xyzs=batch_xyz, Zs=batch_zs, elements=self.elements,
element_pairs=self.element_pairs,
rcut=self.acsf_parameters['rcut'],
acut=self.acsf_parameters['acut'],
nRs2=self.acsf_parameters['nRs2'],
nRs3=self.acsf_parameters['nRs3'],
nTs=self.acsf_parameters['nTs'],
eta=self.acsf_parameters['eta'],
zeta=self.acsf_parameters['zeta'],
bin_min=self.acsf_parameters['bin_min'])
with tf.name_scope("Model_pred"):
batch_energies_nn = self._model(batch_representation, batch_zs, element_weights, element_biases)
def _predict(self, x, classes):
"""
This function checks whether x contains indices or data. If it contains indices, the data is extracted by the
appropriate compound objects. Otherwise it checks what data is passed through the arguments. Then, the data is
used as input to the trained network to predict some properties.
:param x: indices or data
:type x: numpy array of ints of shape (n_samples,) or of floats of shape (n_samples, n_atoms, n_features)
:param classes: classes to use for the atomic decomposition or None
:type classes: either a numpy array of shape (n_samples, n_atoms) or None
:return: the predicted properties
:rtype: numpy array of shape (n_samples,)
"""
approved_x, approved_classes = self._check_predict_input(x, classes)
empty_ene = np.empty((approved_x.shape[0], 1))
if self.session == None:
raise InputError("Model needs to be fit before predictions can be made.")
graph = tf.get_default_graph()
with graph.as_default():
tf_x = graph.get_tensor_by_name("Data/Descriptors:0")
tf_zs = graph.get_tensor_by_name("Data/Atomic-numbers:0")
tf_true_ene = graph.get_tensor_by_name("Data/Properties:0")
tf_buffer = graph.get_tensor_by_name("Data/buffer:0")
model = graph.get_tensor_by_name("Model/output:0")
dataset_init_op = graph.get_operation_by_name("dataset_init")
self.session.run(dataset_init_op, feed_dict={tf_x: approved_x, tf_zs: approved_classes, tf_true_ene: empty_ene, tf_buffer:1})
tot_y_pred = []
while True:
try:
y_pred = self.session.run(model)
tot_y_pred.append(y_pred)
except tf.errors.OutOfRangeError:
break
return np.concatenate(tot_y_pred, axis=0)
def predict_from_xyz(self, xyz, classes):
"""
This function takes in the cartesian coordinates and the atom types and returns energies.
:param xyz: cartesian coordinates
:type xyz: numpy array of shape (n_samples, n_atoms, 3)
:param classes: atom types
:type classes: numpy array of shape (n_samples, n_atoms)
:return: energies
:rtype: numpy array of shape (n_samples,)
"""
if self.session == None:
raise InputError("Model needs to be fit before predictions can be made.")
graph = tf.get_default_graph()
with graph.as_default():
xyz_tf = graph.get_tensor_by_name("Inputs_pred/xyz:0")
classes_tf = graph.get_tensor_by_name("Inputs_pred/Classes:0")
ene_nn = graph.get_tensor_by_name("Model_pred/output:0")
dataset_init_op = graph.get_operation_by_name("Inputs_pred/dataset_init_pred")
self.session.run(dataset_init_op,
feed_dict={xyz_tf: xyz, classes_tf: classes})
tot_y_pred = []
while True:
try:
y_pred = self.session.run(ene_nn)
tot_y_pred.append(y_pred)
except tf.errors.OutOfRangeError:
break
return np.concatenate(tot_y_pred, axis=0).ravel()
def _score_r2(self, x, y=None, dy=None, classes=None):
"""
Calculate the coefficient of determination (R^2).
Larger values corresponds to a better prediction.
:param x: either the representations or the indices to the representations
:type x: either a numpy array of shape (n_samples, n_atoms, n_features) or a numpy array of ints
:param y: either the properties or None
:type y: either a numpy array of shape (n_samples,) or None
:param dy: None
:type dy: None
:param classes: either the classes or None
:type classes: either a numpy array of shape (n_samples, n_atoms) or None
:return: R^2
:rtype: float
"""
x_approved, y_approved, dy_approved, classes_approved = self._check_inputs(x, y, dy, classes)
y_pred = self.predict(x_approved, classes_approved)
r2 = r2_score(y_approved, y_pred, sample_weight = None)
return r2
def _score_mae(self, x, y=None, dy=None, classes=None):
"""
Calculate the mean absolute error.
Smaller values corresponds to a better prediction.
:param x: either the representations or the indices to the representations
:type x: either a numpy array of shape (n_samples, n_atoms, n_features) or a numpy array of ints
:param y: either the properties or None
:type y: either a numpy array of shape (n_samples,) or None
:param dy: None
:type dy: None
:param classes: either the classes or None
:type classes: either a numpy array of shape (n_samples, n_atoms) or None
:param sample_weight: Weights of the samples. None indicates that that each sample has the same weight.
:type sample_weight: array of shape (n_samples,)
:return: Mean absolute error
:rtype: float
"""
x_approved, y_approved, dy_approved, classes_approved = self._check_inputs(x, y, dy, classes)
y_pred = self.predict(x_approved, classes_approved)
mae = (-1.0) * mean_absolute_error(y_approved, y_pred, sample_weight=None)
print("Warning! The mae is multiplied by -1 so that it can be minimised in Osprey!")
return mae
def _score_rmse(self, x, y=None, dy=None, classes=None):
"""
Calculate the root mean squared error.
Smaller values corresponds to a better prediction.
:param x: either the representations or the indices to the representations
:type x: either a numpy array of shape (n_samples, n_atoms, n_features) or a numpy array of ints
:param y: either the properties or None
:type y: either a numpy array of shape (n_samples,) or None
:param dy: None
:type dy: None
:param classes: either the classes or None
:type classes: either a numpy array of shape (n_samples, n_atoms) or None
:return: Mean absolute error
:rtype: float
"""
x_approved, y_approved, dy_approved, classes_approved = self._check_inputs(x, y, dy, classes)
y_pred = self.predict(x_approved, classes_approved)
rmse = np.sqrt(mean_squared_error(y_approved, y_pred, sample_weight = None))
return rmse
def save_nn(self, save_dir="saved_model"):
"""
This function saves the trained model to be used for later prediction.
:param save_dir: directory in which to save the model
:type save_dir: string
:return: None
"""
counter = 0
dir = save_dir
while True:
if os.path.isdir(save_dir):
counter += 1
save_dir = dir + "_" + str(counter)
else:
break
if self.session == None:
raise InputError("Model needs to be fit before predictions can be made.")
graph = tf.get_default_graph()
with graph.as_default():
tf_x = graph.get_tensor_by_name("Data/Descriptors:0")
tf_zs = graph.get_tensor_by_name("Data/Atomic-numbers:0")
true_ene = graph.get_tensor_by_name("Data/Properties:0")
model = graph.get_tensor_by_name("Model/output:0")
tf.saved_model.simple_save(self.session, export_dir=save_dir,
inputs={"Data/Descriptors:0": tf_x, "Data/Atomic-numbers:0": tf_zs,
"Data/Properties:0": true_ene},
outputs={"Model/output:0": model})
def load_nn(self, save_dir="saved_model"):
"""
This function reloads a model for predictions.
:param save_dir: the name of the directory where the model is saved.
:type save_dir: string
:return: None
"""
self.session = tf.Session(graph=tf.get_default_graph())
tf.saved_model.loader.load(self.session, [tf.saved_model.tag_constants.SERVING], save_dir)
self.loaded_model = True
================================================
FILE: qml/aglaia/graceful_killer.py
================================================
"""
Code adapted from Stack Overflow answer https://stackoverflow.com/a/31464349/7146757
This class is used to process SIGTERM signal gracefully from within the neural network training.
"""
import signal
class _GracefulKiller:
kill_now = False
def __init__(self):
signal.signal(signal.SIGINT, self.exit_gracefully)
signal.signal(signal.SIGTERM, self.exit_gracefully)
def exit_gracefully(self,signum, frame):
self.kill_now = True
================================================
FILE: qml/aglaia/np_symm_funct.py
================================================
# MIT License
#
# Copyright (c) 2018 Silvia Amabilino
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
"""
This module contains an implementation of the symmetry functions used by Parkhill in the Tensormol paper:
https://arxiv.org/pdf/1711.06385.pdf
Here they are implemented with Numpy so that the Tensorflow implementation has something to be compared against.
"""
import numpy as np
def distance(r1, r2):
"""
This function calculates the norm of two vectors.
:param r1: a numpy array of shape (n,)
:param r2: a numpy array of shape (n,)
:return: a scalar
"""
diff = r2-r1
return np.linalg.norm(diff)
def fc(r_ij, r_c):
"""
This function calculates the f_c term of the symmetry functions. r_ij is the distance between atom i and j. r_c is
the cut off distance.
:param r_ij: scalar
:param r_c: scalar
:return: sclar
"""
if r_ij < r_c:
f_c = 0.5 * (np.cos(np.pi * r_ij / r_c) + 1.0)
else:
f_c = 0.0
return f_c
def get_costheta(xyz_i, xyz_j, xyz_k):
"""
This function calculates the cosine of the angle in radiants between three points i, j and k. It requires the
cartesian coordinates of the three points.
:param xyz_i: numpy array of shape (3, )
:param xyz_j: numpy array of shape (3, )
:param xyz_k: numpy array of shape (3, )
:return: scalar
"""
r_ij = xyz_j - xyz_i
r_ik = xyz_k - xyz_i
numerator = np.dot(r_ij, r_ik)
denominator = np.linalg.norm(r_ij) * np.linalg.norm(r_ik)
costheta = numerator/denominator
return costheta
def acsf_rad(xyzs, Zs, elements, radial_cutoff, radial_rs, eta):
"""
This function calculates the radial part of the symmetry functions.
:param xyzs: cartesian coordinates of the atoms. Numpy array of shape (n_samples, n_atoms, 3)
:param Zs: atomic numpers of the atoms. Numpy array of shape (n_samples, n_atoms)
:param elements: array of all the atomic numbers present sorted in descending order. Numpy array of shape (n_elements, )
:param radial_cutoff: cut off length. scalar
:param radial_rs: list of all the radial Rs parameters. Numpy array of shape (n_rad_rs,)
:param eta: parameter. scalar.
:return: numpy array of shape (n_samples, n_atoms, n_rad_rs*n_elements)
"""
n_samples = xyzs.shape[0]
n_atoms = xyzs.shape[1]
n_rs = len(radial_rs)
n_elements = len(elements)
total_descriptor = []
for sample in range(n_samples):
sample_descriptor = []
for main_atom in range(n_atoms):
atom_descriptor = np.zeros((n_rs* n_elements,))
if Zs[sample][main_atom] == 0:
sample_descriptor.append(atom_descriptor)
continue
else:
for i, rs_value in enumerate(radial_rs):
for neighb_atom in range(n_atoms):
if main_atom == neighb_atom:
continue
elif Zs[sample][neighb_atom] == 0:
continue
else:
r_ij = distance(xyzs[sample, main_atom, :], xyzs[sample, neighb_atom, :])
cut_off_term = fc(r_ij, radial_cutoff)
exponent_term = np.exp(-eta * (r_ij - rs_value) ** 2)
g2_term = exponent_term * cut_off_term
# Compare the current neighbouring atom to the list of possible neighbouring atoms and then
# split the terms accordingly
for j in range(len(elements)):
if Zs[sample][neighb_atom] == elements[j]:
atom_descriptor[i * n_elements + j] += g2_term
sample_descriptor.append(atom_descriptor)
total_descriptor.append(sample_descriptor)
total_descriptor = np.asarray(total_descriptor)
return total_descriptor
def acsf_ang(xyzs, Zs, element_pairs, angular_cutoff, angular_rs, theta_s, zeta, eta):
"""
This function calculates the angular part of the symmetry functions.
:param xyzs: cartesian coordinates of the atoms. Numpy array of shape (n_samples, max_n_atoms, 3)
:param Zs: atomic numpers of the atoms. Numpy array of shape (n_samples, max_n_atoms)
:param element_pairs: array of all the possible pairs of atomic numbers, sorted in descending order. Numpy array of shape (n_element_pairs, 2)
:param angular_cutoff: cut off length. scalar
:param angular_rs: list of all the angular Rs parameters. Numpy array of shape (n_ang_rs,)
:param theta_s: list of all the thetas parameters. Numpy array of shape (n_thetas,)
:param zeta: parameter. scalar.
:param eta: parameter. scalar.
:return: numpy array of shape (n_samples, max_n_atoms, n_ang_rs*n_thetas*n_element_pairs)
"""
n_samples = xyzs.shape[0]
max_n_atoms = xyzs.shape[1]
n_rs = len(angular_rs)
n_theta = len(theta_s)
n_elements_pairs = len(element_pairs)
total_descriptor = []
for sample in range(n_samples):
sample_descriptor = []
for i in range(max_n_atoms): # Loop over main atom
atom_descriptor = np.zeros((n_rs*n_theta*n_elements_pairs, ))
if Zs[sample][i] == 0: # Making sure the main atom is not a dummy atom
sample_descriptor.append(atom_descriptor)
continue
else:
counter = 0
for rs_value in angular_rs: # Loop over parameters
for theta_value in theta_s:
for j in range(max_n_atoms): # Loop over 1st neighbour
if j == i:
continue
elif Zs[sample][j] == 0: # Making sure the neighbours are not dummy atoms
continue
for k in range(j+1, max_n_atoms): # Loop over 2nd neighbour
if k == j or k == i:
continue
elif Zs[sample][k] == 0: # Making sure the neighbours are not dummy atoms
continue
r_ij = distance(xyzs[sample, i, :], xyzs[sample, j, :])
r_ik = distance(xyzs[sample, i, :], xyzs[sample, k, :])
cos_theta_ijk = get_costheta(xyzs[sample, i, :], xyzs[sample, j, :], xyzs[sample, k, :])
theta_ijk = np.arccos(cos_theta_ijk)
term_1 = np.power((1.0 + np.cos(theta_ijk - theta_value))/2.0, zeta)
term_2 = np.exp(- eta * np.power(0.5*(r_ij + r_ik) - rs_value, 2))
term_3 = fc(r_ij, angular_cutoff) * fc(r_ik, angular_cutoff)
g_term = term_1 * term_2 * term_3 * 2.0
# Compare the pair of neighbours to all the possible element pairs, then summ accordingly
current_pair = np.flip(np.sort([Zs[sample][j], Zs[sample][k]]), axis=0) # Sorting the pair in descending order
for m, pair in enumerate(element_pairs):
if np.all(current_pair == pair):
atom_descriptor[counter * n_elements_pairs + m] += g_term
counter += 1
sample_descriptor.append(atom_descriptor)
total_descriptor.append(sample_descriptor)
return np.asarray(total_descriptor)
def generate_acsf_np(xyzs, Zs, elements, element_pairs, rcut, acut, nRs2,
nRs3, nTs, zeta, eta, bin_min):
"""
This function calculates the symmetry functions used in the tensormol paper.
:param xyzs: cartesian coordinates of the atoms. Numpy array of shape (n_samples, n_atoms, 3)
:param Zs: atomic numpers of the atoms. Numpy array of shape (n_samples, n_atoms)
:param elements: array of all the atomic numbers present sorted in descending order. Numpy array of shape (n_elements, )
:param element_pairs: array of all the possible pairs of atomic numbers, sorted in descending order. Numpy array of shape (n_element_pairs, 2)
:param radial_cutoff: cut off length for radial part. scalar
:param angular_cutoff: cut off length for angular part. scalar
:param radial_rs: list of all the radial Rs parameters. Numpy array of shape (n_rad_rs,)
:param angular_rs: list of all the angular Rs parameters. Numpy array of shape (n_ang_rs,)
:param theta_s: list of all the thetas parameters. Numpy array of shape (n_thetas,)
:param zeta: parameter. scalar.
:param eta: parameter. scalar.
:param bin_min: value at which to start the binning of the distances
:return: numpy array of shape (n_samples, n_atoms, n_rad_rs*n_elements + n_ang_rs*n_thetas*n_element_pairs)
"""
radial_rs = np.linspace(bin_min, rcut, nRs2)
angular_rs = np.linspace(bin_min, acut, nRs3)
theta_s = np.linspace(0, np.pi, nTs)
rad_term = acsf_rad(xyzs, Zs, elements, rcut, radial_rs, eta)
ang_term = acsf_ang(xyzs, Zs, element_pairs, acut, angular_rs, theta_s, zeta, eta)
acsf = np.concatenate((rad_term, ang_term), axis=-1)
return acsf
================================================
FILE: qml/aglaia/placeholder.py
================================================
# MIT License
#
# Copyright (c) 2018 Silvia Amabilino, Lars Andersen Bratholm
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
#
# fit forces
# # Placeholders for the input/output data
# #with tf.name_scope('Data'):
# # tf_input = tf.placeholder(tf.float32, [None, self.n_coord], name="Coordinates")
# # tf_output= tf.placeholder(tf.float32, [None, self.n_coord + 1], name="Energy_forces")
#
# # Making the descriptor from the Cartesian coordinates
# #with tf.name_scope('Descriptor'):
# # X_des = self.available_descriptors[self.descriptor](in_data, n_atoms=self.n_atoms)
#
# # Number of features in the descriptor
# #self.n_features = int(self.n_atoms * (self.n_atoms - 1) * 0.5)
#
# # Randomly initialisation of the weights and biases
# #with tf.name_scope('weights'):
# # weights, biases = self.__generate_weights(n_out=(1+3*self.n_atoms))
#
# # # Log weights for tensorboard
# # if self.tensorboard:
# # tf.summary.histogram("weights_in", weights[0])
# # for ii in range(len(self.hidden_layer_sizes) - 1):
# # tf.summary.histogram("weights_hidden", weights[ii + 1])
# # tf.summary.histogram("weights_out", weights[-1])
#
#
# # Calculating the output of the neural net
# #with tf.name_scope('model'):
# # out_NN = self.modelNN(X_des, weights, biases)
#
# # Obtaining the derivative of the neural net energy wrt cartesian coordinates
# #with tf.name_scope('grad_ene'):
# # ene_NN = tf.slice(out_NN,begin=[0,0], size=[-1,1], name='ene_NN')
# # grad_ene_NN = tf.gradients(ene_NN, in_data, name='dEne_dr')[0] * (-1)
#
# # Calculating the cost function
# #with tf.name_scope('cost_funct'):
# # err_ene_force = tf.square(tf.subtract(out_NN, out_data), name='err2_ene_force')
# # err_grad = tf.square(tf.subtract(tf.slice(out_data, begin=[0,1], size=[-1,-1]), grad_ene_NN), name='err2_grad')
#
# # cost_ene_force = tf.reduce_mean(err_ene_force, name='cost_ene_force')
# # cost_grad = tf.reduce_mean(err_grad, name='cost_grad')
#
# # reg_term = self.__reg_term(weights)
#
# # cost = cost_ene_force + self.alpha_grad*cost_grad + self.alpha_reg * reg_term
#
# # Training the network
# #optimizer = tf.train.AdamOptimizer(learning_rate=self.learning_rate_init).minimize(cost)
#
# #if self.tensorboard:
# # cost_summary = tf.summary.scalar('cost', cost)
#
# # Initialisation of the variables
# #init = tf.global_variables_initializer()
# #if self.tensorboard:
# # merged_summary = tf.summary.merge_all()
# # options = tf.RunOptions()
# # options.output_partition_graphs = True
# # options.trace_level = tf.RunOptions.SOFTWARE_TRACE
# # run_metadata = tf.RunMetadata()
#
# # Running the graph
# #with tf.Session() as sess:
# # if self.tensorboard:
# # summary_writer = tf.summary.FileWriter(logdir=self.board_dir,graph=sess.graph)
# # sess.run(init)
#
# # for iter in range(self.max_iter):
# # # This is the total number of batches in which the training set is divided
# # n_batches = int(self.n_samples / self.batch_size)
# # # This will be used to calculate the average cost per iteration
# # avg_cost = 0
# # # Learning over the batches of data
# # for i in range(n_batches):
# # batch_x = X[i * self.batch_size:(i + 1) * self.batch_size, :]
# # batch_y = y[i * self.batch_size:(i + 1) * self.batch_size, :]
# # opt, c = sess.run([optimizer, cost], feed_dict={in_data: batch_x, out_data: batch_y})
# # avg_cost += c / n_batches
#
# # if self.tensorboard:
# # if iter % self.print_step == 0:
# # # The options flag is needed to obtain profiling information
# # summary = sess.run(merged_summary, feed_dict={in_data: batch_x, out_data: batch_y}, options=options, run_metadata=run_metadata)
# # summary_writer.add_summary(summary, iter)
# # summary_writer.add_run_metadata(run_metadata, 'iteration %d batch %d' % (iter, i))
#
# # self.trainCost.append(avg_cost)
#
# # # Saving the weights for later re-use
# # self.all_weights = []
# # self.all_biases = []
# # for ii in range(len(weights)):
# # self.all_weights.append(sess.run(weights[ii]))
# # self.all_biases.append(sess.run(biases[ii]))
#
#
# def save(self, path):
# """
# Stores a .meta, .index, .data_0000-0001 and a check point file, which can be used to restore
# the trained model.
#
# :param path: Path of directory where files are stored. The path is assumed to be absolute
# unless there are no forward slashes (/) in the path name.
# :type path: string
# """
#
# if self.is_trained == False:
# raise Exception("The fit function has not been called yet, so the model can't be saved.")
#
# # Creating a new graph
# model_graph = tf.Graph()
#
# with model_graph.as_default():
# # Making the placeholder for the data
# xyz_test = tf.placeholder(tf.float32, [None, self.n_coord], name="Cartesian_coord")
#
# # Making the descriptor from the Cartesian coordinates
# X_des = self.available_descriptors[self.descriptor](xyz_test, n_atoms=self.n_atoms)
#
# # Setting up the trained weights
# weights = []
# biases = []
#
# for ii in range(len(self.all_weights)):
# weights.append(tf.Variable(self.all_weights[ii], name="weights_restore"))
# biases.append(tf.Variable(self.all_biases[ii], name="biases_restore"))
#
# # Calculating the ouputs
# out_NN = self.modelNN(X_des, weights, biases)
#
# init = tf.global_variables_initializer()
#
# # Object needed to save the model
# all_saver = tf.train.Saver(save_relative_paths=True)
#
# with tf.Session() as sess:
# sess.run(init)
#
# # Saving the graph
# all_saver.save(sess, dir)
#
# def load_NN(self, dir):
# """
# Function that loads a trained estimator.
#
# :dir: directory where the .meta, .index, .data_0000-0001 and check point files have been saved.
# """
#
# # Inserting the weights into the model
# with tf.Session() as sess:
# # Loading a saved graph
# file = dir + ".meta"
# saver = tf.train.import_meta_graph(file)
#
# # The model is loaded in the default graph
# graph = tf.get_default_graph()
#
# # Loading the graph of out_NN
# self.out_NN = graph.get_tensor_by_name("output_node:0")
# self.in_data = graph.get_tensor_by_name("Cartesian_coord:0")
#
# saver.restore(sess, dir)
# sess.run(tf.global_variables_initializer())
#
# self.loadedModel = True
================================================
FILE: qml/aglaia/symm_funct.py
================================================
# MIT License
#
# Copyright (c) 2018 Silvia Amabilino
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
"""
This module contains an implementation of the the symmetry functions used in the Parkhill paper https://arxiv.org/pdf/1711.06385.pdf.
This implementation is different. It works for both data sets where all the molecules are the same but in different configurations and
for datasets with all different molecules.
Note: it is all in single precision.
"""
import tensorflow as tf
import numpy as np
def acsf_rad(xyzs, Zs, radial_cutoff, radial_rs, eta):
"""
This does the radial part of the symmetry function (G2 function in Behler's papers). It works only for datasets where
all samples are the same molecule but in different configurations.
:param xyzs: Coordinates of each atom in each data sample
:type xyzs: tf tensor of shape (n_samples, n_atoms, 3)
:param Zs: Atomic number of each atom in each data sample
:type Zs: tf tensor of shape (n_samples, n_atoms)
:param radial_cutoff: cut off used in the radial term
:type radial_cutoff: scalar tensor
:param radial_rs: R_s values
:type radial_rs: tf tensor of shape (n_rs,)
:param eta: parameter in the radial term
:type eta: tf scalar
:return: pre-sum radial term
:rtype: tf tensor of shape (n_samples, n_atoms, n_atoms, n_rs)
"""
# Calculating the distance matrix between the atoms of each sample
with tf.name_scope("Distances"):
dxyzs = tf.expand_dims(xyzs, axis=2) - tf.expand_dims(xyzs, axis=1)
dist_tensor = tf.cast(tf.norm(dxyzs+1.e-16, axis=3), dtype=tf.float32) # (n_samples, n_atoms, n_atoms)
# Indices of terms that need to be zero (diagonal elements)
mask_0 = tf.zeros(tf.shape(dist_tensor))
mask_1 = tf.ones(tf.shape(Zs))
where_eq_idx = tf.cast(tf.matrix_set_diag(mask_0, mask_1), dtype=tf.bool)
# Calculating the exponential term
with tf.name_scope("Exponential_term"):
expanded_rs = tf.expand_dims(tf.expand_dims(tf.expand_dims(radial_rs, axis=0), axis=0), axis=0) # (1, 1, 1, n_rs)
expanded_dist = tf.expand_dims(dist_tensor, axis=-1) # (n_samples, n_atoms, n_atoms, 1)
exponent = - eta * tf.square(tf.subtract(expanded_dist, expanded_rs))
exp_term = tf.exp(exponent) # (n_samples, n_atoms, n_atoms, n_rs)
# Calculating the fc terms
with tf.name_scope("fc_term"):
# Finding where the distances are less than the cutoff
where_less_cutoff = tf.less(dist_tensor, radial_cutoff)
# Calculating all of the fc function terms
fc = 0.5 * (tf.cos(3.14159265359 * dist_tensor / radial_cutoff) + 1.0)
# Setting to zero the terms where the distance is larger than the cutoff
zeros = tf.zeros(tf.shape(dist_tensor), dtype=tf.float32)
cut_off_fc = tf.where(where_less_cutoff, fc, zeros) # (n_samples, n_atoms, n_atoms)
# Cleaning up diagonal terms
clean_fc_term = tf.where(where_eq_idx, zeros, cut_off_fc)
# Cleaning up dummy atoms terms
dummy_atoms = tf.logical_not(tf.equal(Zs, tf.constant(0, dtype=tf.int32))) # False where there are dummy atoms
dummy_mask = tf.logical_and(tf.expand_dims(dummy_atoms, axis=1), tf.expand_dims(dummy_atoms, axis=-1))
cleaner_fc_term = tf.where(dummy_mask, clean_fc_term, zeros)
# Multiplying exponential and fc terms
expanded_fc = tf.expand_dims(cleaner_fc_term, axis=-1) # (n_samples, n_atoms, n_atoms, 1)
with tf.name_scope("Rad_term"):
presum_term = tf.multiply(expanded_fc, exp_term) # (n_samples, n_atoms, n_atoms, n_rs)
return presum_term
def acsf_ang(xyzs, Zs, angular_cutoff, angular_rs, theta_s, zeta, eta):
"""
This does the angular part of the symmetry function as mentioned here: https://arxiv.org/pdf/1711.06385.pdf
It only works for systems where all the samples are the same molecule but in different configurations.
:param xyzs: Coordinates of each atom in each data sample
:type xyzs: tf tensor of shape (n_samples, n_atoms, 3)
:param Zs: Atomic number of each atom in each data sample
:type Zs: tf tensor of shape (n_samples, n_atoms)
:param angular_cutoff: cut off used in the angular term
:type angular_cutoff: scalar tensor
:param angular_rs: angular R_s values
:type angular_rs: tf tensor of shape (n_ang_rs,)
:param theta_s: angular theta_s values
:type theta_s: tf tensor of shape (n_thetas,)
:param zeta: parameter in the angular term
:type zeta: tf tensor of shape (1,)
:param eta: parameter in the angular term
:type eta: tf tensor of shape (1,)
:return: pre-sum angular term
:rtype: tf tensor of shape (n_samples, n_atoms, n_atoms, n_atoms, n_ang_rs * n_thetas)
"""
# Finding the R_ij + R_ik term
with tf.name_scope("Sum_distances"):
dxyzs = tf.expand_dims(xyzs, axis=2) - tf.expand_dims(xyzs, axis=1)
dist_tensor = tf.cast(tf.norm(dxyzs+1.e-16, axis=3), dtype=tf.float32) # (n_samples, n_atoms, n_atoms)
# This is the tensor where element sum_dist_tensor[0,1,2,3] is the R_12 + R_13 in the 0th data sample
sum_dist_tensor = tf.expand_dims(dist_tensor, axis=3) + tf.expand_dims(dist_tensor,
axis=2) # (n_samples, n_atoms, n_atoms, n_atoms)
# Problem with the above tensor: we still have the R_ii + R_ik distances which are non zero and could be summed
# These need to be set to zero
n_atoms = Zs.get_shape().as_list()[1]
zarray = np.zeros((n_atoms, n_atoms, n_atoms))
for i in range(n_atoms):
for j in range(n_atoms):
for k in range(n_atoms):
if i == j or i == k or j == k:
zarray[i, j, k] = 1
# Make a bool tensor of the indices
where_eq_idx = tf.tile(tf.expand_dims(tf.convert_to_tensor(zarray, dtype=tf.bool), axis=0),
multiples=[tf.shape(sum_dist_tensor)[0], 1, 1, 1])
# For all the elements that are true in where_eq_idx, turn the elements of sum_dist_tensor to zero
zeros_1 = tf.zeros(tf.shape(sum_dist_tensor), dtype=tf.float32)
# Now finding the fc terms
with tf.name_scope("Fc_term"):
# 1. Find where Rij and Rik are < cutoff
where_less_cutoff = tf.less(dist_tensor, angular_cutoff)
# 2. Calculate the fc on the Rij and Rik tensors
fc_1 = 0.5 * (tf.cos(3.14159265359 * dist_tensor / angular_cutoff) + 1.0)
# 3. Apply the mask calculated in 1. to zero the values for where the distances are > than the cutoff
zeros_2 = tf.zeros(tf.shape(dist_tensor), dtype=tf.float32)
cut_off_fc = tf.where(where_less_cutoff, fc_1, zeros_2) # (n_samples, n_atoms, n_atoms)
# 4. Multiply the two tensors elementwise
fc_term = tf.multiply(tf.expand_dims(cut_off_fc, axis=3),
tf.expand_dims(cut_off_fc, axis=2)) # (n_samples, n_atoms, n_atoms, n_atoms)
# 5. Cleaning up the terms that should be zero because there are equal indices
clean_fc_term = tf.where(where_eq_idx, zeros_1, fc_term)
# 6. Cleaning up the terms due to the dummy atoms
dummy_atoms = tf.logical_not(tf.equal(Zs, tf.constant(0, dtype=tf.int32))) # False where there are dummy atoms
dummy_mask_2d = tf.logical_and(tf.expand_dims(dummy_atoms, axis=1), tf.expand_dims(dummy_atoms, axis=-1))
dummy_mask_3d = tf.logical_and(tf.expand_dims(dummy_mask_2d, axis=1), tf.expand_dims(tf.expand_dims(dummy_atoms, axis=-1), axis=-1))
cleaner_fc_term = tf.where(dummy_mask_3d, clean_fc_term, zeros_1)
# Now finding the theta_ijk term
with tf.name_scope("Theta"):
# Doing the dot products of all the possible vectors
dots_dxyzs = tf.cast(tf.reduce_sum(tf.multiply(tf.expand_dims(dxyzs, axis=3), tf.expand_dims(dxyzs, axis=2)),
axis=4), dtype=tf.float32) # (n_samples, n_atoms, n_atoms, n_atoms)
# Doing the products of the magnitudes
dist_prod = tf.multiply(tf.expand_dims(dist_tensor, axis=3),
tf.expand_dims(dist_tensor, axis=2)) # (n_samples, n_atoms, n_atoms, n_atoms)
# Dividing the dot products by the magnitudes to obtain cos theta
cos_theta = tf.divide(dots_dxyzs, dist_prod)
# Taking care of the values that due numerical error are just above 1.0 or below -1.0
cut_cos_theta = tf.clip_by_value(cos_theta, tf.constant(-1.0 + 1.0e-7), tf.constant(1.0 - 1.0e-7))
# Applying arc cos to find the theta value
theta = tf.acos(cut_cos_theta) # (n_samples, n_atoms, n_atoms, n_atoms)
# Removing the NaNs created by dividing by zero
clean_theta = tf.where(where_eq_idx, zeros_1, theta)
# cleaning up NaNs due by dummy atoms
dummy_atoms = tf.logical_not(tf.equal(Zs, tf.constant(0, dtype=tf.int32))) # False where there are dummy atoms
dummy_mask_2d = tf.logical_and(tf.expand_dims(dummy_atoms, axis=1), tf.expand_dims(dummy_atoms, axis=-1))
dummy_mask_3d = tf.logical_and(tf.expand_dims(dummy_mask_2d, axis=1),
tf.expand_dims(tf.expand_dims(dummy_atoms, axis=-1), axis=-1))
cleaner_theta = tf.where(dummy_mask_3d, clean_theta, zeros_1)
# Finding the (0.5 * clean_sum_dist - R_s) term
with tf.name_scope("Exp_term"):
# Augmenting the dims of angular_rs
expanded_rs = tf.expand_dims(tf.expand_dims(tf.expand_dims(tf.expand_dims(angular_rs, axis=0), axis=0), axis=0),
axis=0) # (1, 1, 1, 1, n_rs)
# Augmenting the dim of clean_sum_dist *0.5
# expanded_sum = tf.expand_dims(clean_sum_dist * 0.5, axis=-1)
expanded_sum = tf.expand_dims(sum_dist_tensor * 0.5, axis=-1)
# Combining them
brac_term = tf.subtract(expanded_sum, expanded_rs)
# Finally making the exponential term
exponent = - eta * tf.square(brac_term)
exp_term = tf.exp(exponent) # (n_samples, n_atoms, n_atoms, n_atoms, n_rs)
# Finding the cos(theta - theta_s) term
with tf.name_scope("Cos_term"):
# Augmenting the dimensions of theta_s
expanded_theta_s = tf.expand_dims(tf.expand_dims(tf.expand_dims(tf.expand_dims(theta_s, axis=0), axis=0), axis=0),
axis=0)
# Augmenting the dimensions of theta
expanded_theta = tf.expand_dims(cleaner_theta, axis=-1)
# Subtracting them and do the cos
cos_theta_term = tf.cos(
tf.subtract(expanded_theta, expanded_theta_s)) # (n_samples, n_atoms, n_atoms, n_atoms, n_theta_s)
# Make the whole cos term of the sum of shape (n_samples, n_atoms, n_atoms, n_atoms, n_theta_s)
cos_term = tf.pow(tf.divide(tf.add(tf.ones(tf.shape(cos_theta_term), dtype=tf.float32), cos_theta_term),
tf.constant(2, dtype=tf.float32)), zeta)
# cos_term = tf.pow(tf.add(tf.ones(tf.shape(cos_theta_term), dtype=tf.float32), cos_theta_term),
# zeta) # (n_samples, n_atoms, n_atoms, n_atoms, n_theta_s)
# Final product of terms inside the sum time by 2^(1-zeta)
expanded_fc = tf.expand_dims(tf.expand_dims(cleaner_fc_term, axis=-1), axis=-1, name="Expanded_fc")
expanded_cos = tf.expand_dims(cos_term, axis=-2, name="Expanded_cos")
expanded_exp = tf.expand_dims(exp_term, axis=-1, name="Expanded_exp")
const = tf.constant(2.0, dtype=tf.float32)
with tf.name_scope("Ang_term"):
prod_of_terms = const * tf.multiply(tf.multiply(expanded_cos, expanded_exp),
expanded_fc) # (n_samples, n_atoms, n_atoms, n_atoms, n_rs, n_theta_s)
# Reshaping to shape (n_samples, n_atoms, n_atoms, n_atoms, n_rs*n_theta_s)
presum_term = tf.reshape(prod_of_terms,
[tf.shape(prod_of_terms)[0], n_atoms, n_atoms, n_atoms,
theta_s.shape[0] * angular_rs.shape[0]])
return presum_term
def sum_rad(pre_sum, Zs, elements_list, radial_rs):
"""
Sum of the terms in the radial part of the symmetry function. The terms corresponding to the same neighbour identity
are summed together.
:param pre_sum: pre-sum radial term
:type pre_sum: tf tensor of shape (n_samples, n_atoms, n_atoms, n_rs)
:param Zs: Atomic number of each atom in each data sample
:type Zs: tf tensor of shape (n_samples, n_atoms)
:param elements_list: unique atoms in all of the samples
:type elements_list: np.array of shape (n_elements,)
:param radial_rs: radial R_s values
:type radial_rs: tf tensor of shape (n_rad_rs,)
:return: the radial term
:rtype: tf tensor of shape (n_samples, n_atoms, n_rad_rd * n_elements)
"""
n_atoms = Zs.get_shape().as_list()[1]
n_elements = len(elements_list)
n_rs = radial_rs.get_shape().as_list()[0]
## Making a matrix of all the possible neighbouring atoms
# No need to clean up diagonal elements because they are already set to zero in the presum term
neighb_atoms = tf.tile(tf.expand_dims(tf.expand_dims(Zs, axis=1), axis=-1),
multiples=[1, n_atoms, 1, n_rs]) # (n_samples, n_atoms, n_atoms, n_rs)
zeros = tf.zeros(tf.shape(pre_sum), dtype=tf.float32)
# Looping over all the possible elements in the system and extracting the relevant terms from the pre_sum term
pre_sum_terms = []
for i in range(n_elements):
element = tf.constant(elements_list[i], dtype=tf.int32)
equal_elements = tf.equal(neighb_atoms, element)
slice_presum = tf.where(equal_elements, pre_sum, zeros)
slice_sum = tf.reduce_sum(slice_presum, axis=[2])
pre_sum_terms.append(slice_sum)
# Concatenating the extracted terms.
final_term = tf.concat(pre_sum_terms, axis=-1, name="sum_rad")
# Cleaning up the dummy atoms descriptors
dummy_atoms = tf.logical_not(tf.equal(Zs, tf.constant(0, dtype=tf.int32))) # False where there are dummy atoms
mask = tf.tile(tf.expand_dims(dummy_atoms, axis=-1), multiples=[1, 1, n_elements*n_rs])
# clean_final_term = tf.where(mask, final_term, tf.zeros(final_term.shape, dtype=tf.float32))
clean_final_term = tf.where(mask, final_term, tf.zeros(tf.shape(final_term), dtype=tf.float32))
return clean_final_term
def sum_ang(pre_sumterm, Zs, element_pairs_list, angular_rs, theta_s):
"""
This function does the sum of the terms in the radial part of the symmetry function. Three body interactions where
the two neighbours are the same elements are summed together.
:param pre_sumterm: pre-sum angular term
:type pre_sumterm: tf tensor of shape (n_samples, n_atoms, n_ang_rs * n_thetas)
:param Zs: Atomic number of each atom in each data sample
:type Zs: tf tensor of shape (n_samples, n_atoms)
:param element_pairs_list: list of all the atom element pairs
:type element_pairs_list: np array of shape (n_elementpairs, 2)
:param angular_rs: angular R_s values
:type angular_rs: tf tensor of shape (n_ang_rs,)
:param theta_s: angular theta_s values
:type theta_s: tf tensor of shape (n_thetas,)
:return: the angular term
:rtype: tf tensor of shape (n_samples, n_atoms, n_ang_rs * n_thetas * n_elementpairs)
"""
n_atoms = Zs.get_shape().as_list()[1]
n_pairs = len(element_pairs_list)
n_rs = angular_rs.get_shape().as_list()[0]
n_thetas = theta_s.get_shape().as_list()[0]
# Making the pair matrix
Zs_exp_1 = tf.expand_dims(tf.tile(tf.expand_dims(Zs, axis=1), multiples=[1, n_atoms, 1]), axis=-1)
Zs_exp_2 = tf.expand_dims(tf.tile(tf.expand_dims(Zs, axis=-1), multiples=[1, 1, n_atoms]), axis=-1)
neighb_pairs = tf.concat([Zs_exp_1, Zs_exp_2], axis=-1) # (n_samples, n_atoms, n_atoms, 2)
# Cleaning up diagonal elements
zarray = np.zeros((n_atoms, n_atoms, 2))
for i in range(n_atoms):
zarray[i, i, :] = 1
# Make a bool tensor of the indices
where_eq_idx = tf.tile(tf.expand_dims(tf.convert_to_tensor(zarray, dtype=tf.bool), axis=0),
multiples=[tf.shape(Zs)[0], 1, 1, 1]) # (n_samples, n_atoms, n_atoms, 2)
zeros = tf.zeros(tf.shape(neighb_pairs), dtype=tf.int32)
clean_pairs = tf.where(where_eq_idx, zeros, neighb_pairs)
# Sorting the pairs in descending order so that for example pair [7, 1] is the same as [1, 7]
sorted_pairs, _ = tf.nn.top_k(clean_pairs, k=2, sorted=True) # (n_samples, n_atoms, n_atoms, 2)
# Preparing to clean the sorted pairs from where there will be self interactions in the three-body-terms
oarray = np.ones((n_atoms, n_atoms, n_atoms))
for i in range(n_atoms):
for j in range(n_atoms):
for k in range(n_atoms):
if i == j or i == k or j == k:
oarray[i, j, k] = 0
# Make a bool tensor of the indices
where_self_int = tf.tile(tf.expand_dims(tf.convert_to_tensor(oarray, dtype=tf.bool), axis=0),
multiples=[tf.shape(Zs)[0], 1, 1, 1]) # (n_samples, n_atoms, n_atoms, n_atoms)
exp_self_int = tf.expand_dims(where_self_int, axis=-1) # (n_samples, n_atoms, n_atoms, n_atoms, 1)
zeros_large = tf.zeros(tf.shape(pre_sumterm), dtype=tf.float32, name="zero_large")
presum_terms = []
with tf.name_scope("Extract"):
for i in range(n_pairs):
# Making a tensor where all the elements are the pair under consideration
pair = tf.constant(element_pairs_list[i], dtype=tf.int32)
expanded_pair = tf.tile(
tf.expand_dims(tf.expand_dims(tf.expand_dims(pair, axis=0), axis=0), axis=0),
multiples=[tf.shape(Zs)[0], n_atoms, n_atoms, 1], name="expand_pair") # (n_samples, n_atoms, n_atoms, 2)
# Comparing which neighbour pairs correspond to the pair under consideration
equal_pair_mix = tf.equal(expanded_pair, sorted_pairs)
equal_pair_split1, equal_pair_split2 = tf.split(equal_pair_mix, 2, axis=-1)
equal_pair = tf.tile(tf.expand_dims(tf.logical_and(equal_pair_split1, equal_pair_split2), axis=[1]),
multiples=[1, n_atoms, 1, 1, 1]) # (n_samples, n_atoms, n_atoms, n_atoms, 1)
# Removing the pairs where the same atom is present more than once
int_to_keep = tf.logical_and(equal_pair, exp_self_int)
exp_int_to_keep = tf.tile(int_to_keep, multiples=[1, 1, 1, 1, n_rs * n_thetas])
# Extracting the terms that correspond to the pair under consideration
slice_presum = tf.where(exp_int_to_keep, pre_sumterm, zeros_large, name="sl_pr_s")
slice_sum = 0.5 * tf.reduce_sum(slice_presum, axis=[2, 3], name="sum_ang")
presum_terms.append(slice_sum)
# Concatenating all of the terms corresponding to different pair neighbours
final_term = tf.concat(presum_terms, axis=-1, name="concat_presum")
# Cleaning up the dummy atoms descriptors
dummy_atoms = tf.logical_not(tf.equal(Zs, tf.constant(0, dtype=tf.int32))) # False where there are dummy atoms
mask = tf.tile(tf.expand_dims(dummy_atoms, axis=-1), multiples=[1, 1, n_thetas * n_rs * n_pairs])
clean_final_term = tf.where(mask, final_term, tf.zeros(tf.shape(final_term)))
return clean_final_term
def generate_acsf_tf(xyzs, Zs, elements, element_pairs, rcut, acut,
nRs2, nRs3, nTs, zeta, eta, bin_min):
"""
This function generates the atom centred symmetry function as used in the Tensormol paper. Currently only tested for
single systems with many conformations. It requires the coordinates of all the atoms in each data sample, the atomic
charges for each atom (in the same order as the xyz), the overall elements and overall element pairs. Then it
requires the parameters for the ACSF that are used in the Tensormol paper: https://arxiv.org/pdf/1711.06385.pdf
:param xyzs: Coordinates of each atom in each data sample
:type xyzs: tensor of shape (n_samples, n_atoms, 3)
:param Zs: Atomic number of each atom in each data sample
:type Zs: tensor of shape (n_samples, n_atoms)
:param elements: unique atoms in all of the samples
:type elements: np.array of shape (n_elements,)
:param element_pairs: list of all the atom element pairs
:type element_pairs: np.array of shape (n_elementpairs, 2)
:param rcut: radial cut off length
:type rcut: scalar float
:param acut: angular cut off length
:type acut: scalar float
:param nRs2: number of distance bins to use in the radial term
:type nRs2: positive integer
:param nRs3: number of distance bins to use in the angular term
:type nRs3: positive integer
:param nTs: number of angle bins to use in the angular term
:type nTs: positive integer
:param zeta: parameter in the cosine term
:type zeta: scalar float
:param eta: parameter in the exponential terms
:type eta: scalar float
:param bin_min: the value at which to start binning the distances
:type bin_min: positive float
:return: the atom centred symmetry functions
:rtype: a tf tensor of shape a tf tensor of shape (n_samples, n_atoms, nRs2 * n_elements + nRs3 * nTs * n_elementpairs)
"""
radial_rs = np.linspace(bin_min, rcut, nRs2)
angular_rs = np.linspace(bin_min, acut, nRs3)
theta_s = np.linspace(0, np.pi, nTs)
with tf.name_scope("acsf_params"):
rad_cutoff = tf.constant(rcut, dtype=tf.float32)
ang_cutoff = tf.constant(acut, dtype=tf.float32)
rad_rs = tf.constant(radial_rs, dtype=tf.float32)
ang_rs = tf.constant(angular_rs, dtype=tf.float32)
theta_s = tf.constant(theta_s, dtype=tf.float32)
zeta_tf = tf.constant(zeta, dtype=tf.float32)
eta_tf = tf.constant(eta, dtype=tf.float32)
## Calculating the radial part of the symmetry function
# First obtaining all the terms in the sum
with tf.name_scope("Radial_part"):
pre_sum_rad = acsf_rad(xyzs, Zs, rad_cutoff, rad_rs, eta_tf) # (n_samples, n_atoms, n_atoms, n_rad_rs)
with tf.name_scope("Sum_rad"):
# Then summing based on the identity of the atoms interacting
rad_term = sum_rad(pre_sum_rad, Zs, elements, rad_rs) # (n_samples, n_atoms, n_rad_rs*n_elements)
## Calculating the angular part of the symmetry function
# First obtaining all the terms in the sum
with tf.name_scope("Angular_part"):
pre_sum_ang = acsf_ang(xyzs, Zs, ang_cutoff, ang_rs, theta_s, zeta_tf, eta_tf) # (n_samples, n_atoms, n_atoms, n_atoms, n_thetas * n_ang_rs)
with tf.name_scope("Sum_ang"):
# Then doing the sum based on the neighbrouing pair identity
ang_term = sum_ang(pre_sum_ang, Zs, element_pairs, ang_rs, theta_s) # (n_samples, n_atoms, n_thetas * n_ang_rs*n_elementpairs)
with tf.name_scope("ACSF"):
acsf = tf.concat([rad_term, ang_term], axis=-1, name="acsf") # (n_samples, n_atoms, n_rad_rs*n_elements + n_thetas * n_ang_rs*n_elementpairs)
return acsf
================================================
FILE: qml/aglaia/tensormol_symm_funct.py
================================================
# MIT License
#
# Copyright (c) 2018 Silvia Amabilino
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
"""
This module contains the implementation of the symmetry functions from the Tensormol package. They have been extracted
from the package so that the implementation in Aglaia can be compared to them.
"""
import tensorflow as tf
import numpy as np
def tf_symmetry_functions_radial_grid(xyzs, Zs, radial_cutoff, radial_rs, eta, prec=tf.float64):
"""
Encodes the radial grid portion of the symmetry functions. Should be called by tf_symmetry_functions_2()
Args:
xyzs (tf.float): NMol x MaxNAtoms x 3 coordinates tensor
Zs (tf.int32): NMol x MaxNAtoms atomic number tensor
num_atoms (np.int32): NMol number of atoms numpy array
radial_cutoff (tf.float): scalar tensor with the cutoff for radial pairs
radial_rs (tf.float): NRadialGridPoints tensor with R_s values for the radial grid
eta (tf.float): scalar tensor with the eta parameter for the symmetry functions
Returns:
radial_embedding (tf.float): tensor of radial embeddings for all atom pairs within the radial_cutoff
pair_indices (tf.int32): tensor of the molecule, atom, and pair atom indices
pair_elements (tf.int32): tensor of the atomic numbers for the atom and its pair atom
"""
dxyzs = tf.expand_dims(xyzs, axis=2) - tf.expand_dims(xyzs, axis=1)
dist_tensor = tf.norm(dxyzs + 1.e-16,axis=3)
padding_mask = tf.not_equal(Zs, 0)
pair_indices = tf.where(tf.logical_and(tf.logical_and(tf.less(dist_tensor, radial_cutoff),
tf.expand_dims(padding_mask, axis=1)), tf.expand_dims(padding_mask, axis=-1)))
identity_mask = tf.where(tf.not_equal(pair_indices[:,1], pair_indices[:,2]))
pair_indices = tf.cast(tf.squeeze(tf.gather(pair_indices, identity_mask)), tf.int32)
pair_distances = tf.gather_nd(dist_tensor, pair_indices)
pair_elements = tf.cast(tf.stack([tf.gather_nd(Zs, pair_indices[:,0:2]), tf.gather_nd(Zs, pair_indices[:,0:3:2])], axis=-1), dtype=tf.int32)
gaussian_factor = tf.exp(-eta * tf.square(tf.expand_dims(pair_distances, axis=-1) - tf.expand_dims(radial_rs, axis=0)))
cutoff_factor = tf.expand_dims(0.5 * (tf.cos(3.14159265359 * pair_distances / radial_cutoff) + 1.0), axis=-1)
radial_embedding = gaussian_factor * cutoff_factor
return radial_embedding, pair_indices, pair_elements
def tf_symmetry_function_angular_grid(xyzs, Zs, angular_cutoff, angular_rs, theta_s, zeta, eta):
"""
Encodes the radial grid portion of the symmetry functions. Should be called by tf_symmetry_functions_2()
Args:
xyzs (tf.float): NMol x MaxNAtoms x 3 coordinates tensor
Zs (tf.int32): NMol x MaxNAtoms atomic number tensor
angular_cutoff (tf.float): scalar tensor with the cutoff for the angular triples
angular_rs (tf.float): NAngularGridPoints tensor with the R_s values for the radial part of the angular grid
theta_s (tf.float): NAngularGridPoints tensor with the theta_s values for the angular grid
zeta (tf.float): scalar tensor with the zeta parameter for the symmetry functions
eta (tf.float): scalar tensor with the eta parameter for the symmetry functions
Returns:
angular_embedding (tf.float): tensor of radial embeddings for all atom pairs within the radial_cutoff
triples_indices (tf.int32): tensor of the molecule, atom, and triples atom indices
triples_elements (tf.int32): tensor of the atomic numbers for the atom
sorted_triples_element_pairs (tf.int32): sorted tensor of the atomic numbers of triples atoms
"""
num_mols = Zs.get_shape().as_list()[0]
dxyzs = tf.expand_dims(xyzs, axis=2) - tf.expand_dims(xyzs, axis=1)
dist_tensor = tf.norm(dxyzs + 1.e-16, axis=3)
padding_mask = tf.not_equal(Zs, 0)
pair_indices = tf.cast(tf.where(tf.logical_and(tf.logical_and(tf.less(dist_tensor, angular_cutoff),
tf.expand_dims(padding_mask, axis=1)), tf.expand_dims(padding_mask, axis=-1))), tf.int32)
identity_mask = tf.where(tf.not_equal(pair_indices[:,1], pair_indices[:,2]))
pair_indices = tf.cast(tf.squeeze(tf.gather(pair_indices, identity_mask)), tf.int32)
mol_pair_indices = tf.dynamic_partition(pair_indices, pair_indices[:,0], num_mols)
triples_indices = []
tmp = []
for i in range(num_mols):
mol_common_pair_indices = tf.where(tf.equal(tf.expand_dims(mol_pair_indices[i][:,1], axis=1),
tf.expand_dims(mol_pair_indices[i][:,1], axis=0)))
mol_triples_indices = tf.concat([tf.gather(mol_pair_indices[i], mol_common_pair_indices[:,0]),
tf.gather(mol_pair_indices[i], mol_common_pair_indices[:,1])[:,-1:]], axis=1)
permutation_identity_pairs_mask = tf.where(tf.less(mol_triples_indices[:,2], mol_triples_indices[:,3]))
mol_triples_indices = tf.squeeze(tf.gather(mol_triples_indices, permutation_identity_pairs_mask))
triples_indices.append(mol_triples_indices)
triples_indices = tf.concat(triples_indices, axis=0)
triples_elements = tf.gather_nd(Zs, triples_indices[:,0:2])
triples_element_pairs, _ = tf.nn.top_k(tf.stack([tf.gather_nd(Zs, triples_indices[:,0:3:2]),
tf.gather_nd(Zs, triples_indices[:,0:4:3])], axis=-1), k=2)
sorted_triples_element_pairs = tf.cast(tf.reverse(triples_element_pairs, axis=[-1]), dtype=tf.int32)
triples_distances = tf.stack([tf.gather_nd(dist_tensor, triples_indices[:,:3]), tf.gather_nd(dist_tensor,
tf.concat([triples_indices[:,:2], triples_indices[:,3:]], axis=1))], axis=1)
r_ijk_s = tf.square(tf.expand_dims(tf.reduce_sum(triples_distances, axis=1) / 2.0, axis=-1) - tf.expand_dims(angular_rs, axis=0))
exponential_factor = tf.exp(-eta * r_ijk_s)
xyz_ij_ik = tf.reduce_sum(tf.gather_nd(dxyzs, triples_indices[:,:3]) * tf.gather_nd(dxyzs,
tf.concat([triples_indices[:,:2], triples_indices[:,3:]], axis=1)), axis=1)
cos_theta = xyz_ij_ik / (triples_distances[:,0] * triples_distances[:,1])
cos_theta = tf.where(tf.greater_equal(cos_theta, 1.0), tf.ones_like(cos_theta) - 1.0e-16, cos_theta)
cos_theta = tf.where(tf.less_equal(cos_theta, -1.0), -1.0 * tf.ones_like(cos_theta) - 1.0e-16, cos_theta)
triples_angle = tf.acos(cos_theta)
theta_ijk_s = tf.expand_dims(triples_angle, axis=-1) - tf.expand_dims(theta_s, axis=0)
cos_factor = tf.pow((1 + tf.cos(theta_ijk_s)), zeta)
cutoff_factor = 0.5 * (tf.cos(3.14159265359 * triples_distances / angular_cutoff) + 1.0)
scalar_factor = tf.pow(2.0, 1.0-zeta)
angular_embedding = tf.reshape(scalar_factor * tf.expand_dims(cos_factor * tf.expand_dims(cutoff_factor[:,0] * cutoff_factor[:,1], axis=-1), axis=-1) \
* tf.expand_dims(exponential_factor, axis=-2), [tf.shape(triples_indices)[0], tf.shape(theta_s)[0] * tf.shape(angular_rs)[0]])
return angular_embedding, triples_indices, triples_elements, sorted_triples_element_pairs
def tensormol_acsf(xyzs, Zs, elements, element_pairs, radial_cutoff, angular_cutoff,
radial_rs, angular_rs, theta_s, zeta, eta):
"""
This function uses the tensormol atom centred symmetry functions.
:param xyzs: tensor of shape (n_samples, n_atoms, 3)
:param Zs: tensor of shape (n_samples, n_atoms)
:param elements: np.array of shape (n_elements,)
:param element_pairs: np.array of shape (n_elementpairs, 2)
:param radial_cutoff: scalar float
:param angular_cutoff: scalar float
:param radial_rs: np.array of shape (n_rad_rs,)
:param angular_rs: np.array of shape (n_ang_rs,)
:param theta_s: np.array of shape (n_thetas,)
:param zeta: scalar float
:param eta: scalar float
:return: a tf tensor of shape (n_samples, n_atoms, n_rad_rs * n_elements + n_ang_rs * n_thetas * n_elementpairs)
"""
# The data
with tf.name_scope("Params"):
elements = tf.constant(elements, dtype=tf.int32)
element_pairs = tf.constant(np.flip(element_pairs, axis=1), dtype=tf.int32)
radial_cutoff = tf.constant(radial_cutoff, dtype=tf.float32)
angular_cutoff = tf.constant(angular_cutoff, dtype=tf.float32)
radial_rs = tf.constant(radial_rs, dtype=tf.float32)
angular_rs = tf.constant(angular_rs, dtype=tf.float32)
theta_s = tf.constant(theta_s, dtype=tf.float32)
zeta = tf.constant(zeta, dtype=tf.float32)
eta = tf.constant(eta, dtype=tf.float32)
num_molecules = Zs.get_shape().as_list()[0]
num_elements = elements.get_shape().as_list()[0]
num_element_pairs = element_pairs.get_shape().as_list()[0]
with tf.name_scope("Radial"):
radial_embedding, pair_indices_rad, pair_elements = tf_symmetry_functions_radial_grid(xyzs, Zs, radial_cutoff,
radial_rs, eta)
with tf.name_scope("Angular"):
angular_embedding, triples_indices, triples_element, sorted_triples_element_pairs = tf_symmetry_function_angular_grid(
xyzs, Zs, angular_cutoff, angular_rs, theta_s, zeta, eta)
with tf.name_scope("Sum_rad"):
pair_element_indices = tf.cast(
tf.where(tf.equal(tf.expand_dims(pair_elements[:, 1], axis=-1), tf.expand_dims(elements, axis=0))), tf.int32)[:,
1]
triples_elements_indices = tf.cast(tf.where(
tf.reduce_all(tf.equal(tf.expand_dims(sorted_triples_element_pairs, axis=-2), element_pairs), axis=-1)),
tf.int32)[:, 1]
radial_scatter_indices = tf.concat([pair_indices_rad, tf.expand_dims(pair_element_indices, axis=1)], axis=1)
angular_scatter_indices = tf.concat([triples_indices, tf.expand_dims(triples_elements_indices, axis=1)], axis=1)
radial_molecule_embeddings = tf.dynamic_partition(radial_embedding, pair_indices_rad[:, 0], num_molecules)
radial_atom_indices = tf.dynamic_partition(radial_scatter_indices[:, 1:], pair_indices_rad[:, 0], num_molecules)
angular_molecule_embeddings = tf.dynamic_partition(angular_embedding, triples_indices[:, 0], num_molecules)
angular_atom_indices = tf.dynamic_partition(angular_scatter_indices[:, 1:], triples_indices[:, 0], num_molecules)
with tf.name_scope("Sum_ang"):
embeddings = []
mol_atom_indices = []
for molecule in range(num_molecules):
atom_indices = tf.cast(tf.where(tf.not_equal(Zs[molecule], 0)), tf.int32)
molecule_atom_elements = tf.gather_nd(Zs[molecule], atom_indices)
num_atoms = tf.shape(molecule_atom_elements)[0]
radial_atom_embeddings = tf.reshape(
tf.reduce_sum(tf.scatter_nd(radial_atom_indices[molecule], radial_molecule_embeddings[molecule],
[num_atoms, num_atoms, num_elements, tf.shape(radial_rs)[0]]), axis=1),
[num_atoms, -1])
angular_atom_embeddings = tf.reshape(
tf.reduce_sum(tf.scatter_nd(angular_atom_indices[molecule], angular_molecule_embeddings[molecule],
[num_atoms, num_atoms, num_atoms, num_element_pairs,
tf.shape(angular_rs)[0] * tf.shape(theta_s)[0]]),
axis=[1, 2]), [num_atoms, -1])
embeddings.append(tf.concat([radial_atom_embeddings, angular_atom_embeddings], axis=1))
mol_atom_indices.append(tf.concat([tf.fill([num_atoms, 1], molecule), atom_indices], axis=1))
embeddings = tf.concat(embeddings, axis=0)
mol_atom_indices = tf.concat(mol_atom_indices, axis=0)
atom_Zs = tf.cast(tf.gather_nd(Zs, tf.where(tf.not_equal(Zs, 0))), dtype=tf.int32)
atom_Z_indices = tf.cast(tf.where(tf.equal(tf.expand_dims(atom_Zs, axis=1),
tf.expand_dims(elements, axis=0)))[:, 1], tf.int32)
with tf.name_scope("Result"):
element_embeddings = tf.dynamic_partition(embeddings, atom_Z_indices, num_elements)
mol_indices = tf.dynamic_partition(mol_atom_indices, atom_Z_indices, num_elements)
return embeddings
================================================
FILE: qml/aglaia/tf_utils.py
================================================
# MIT License
#
# Copyright (c) 2018 Silvia Amabilino, Lars Andersen Bratholm
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
"""
Various routines related to tensorflow
"""
import os
import numpy as np
import tensorflow as tf
from qml.utils import ceil
class TensorBoardLogger(object):
"""
Helper class for tensorboard functionality
"""
def __init__(self, path):
self.path = path
self.store_frequency = None
def initialise(self):
# Create tensorboard directory
if not os.path.exists(self.path):
os.makedirs(self.path)
self.options = tf.RunOptions(trace_level=tf.RunOptions.SOFTWARE_TRACE,
output_partition_graphs=True)
self.run_metadata = tf.RunMetadata()
def set_store_frequency(self, freq):
self.store_frequency = freq
def set_summary_writer(self, sess):
self.summary_writer = tf.summary.FileWriter(logdir=self.path, graph=sess.graph)
def write_summary(self, sess, iteration, feed_dict=None):
self.merged_summary = tf.summary.merge_all()
if not isinstance(feed_dict, type(None)):
summary = sess.run(self.merged_summary, feed_dict)
else:
summary = sess.run(self.merged_summary)
self.summary_writer.add_summary(summary, iteration)
self.summary_writer.add_run_metadata(self.run_metadata, 'iteration %d' % (iteration))
def write_metadata(self, step):
self.summary_writer.add_run_metadata(self.run_metadata, 'batch %d' % (step))
def write_weight_histogram(self, weights):
tf.summary.histogram("weights_in", weights[0])
for i in range(len(weights) - 1):
tf.summary.histogram("weights_hidden_%d" % i, weights[i + 1])
tf.summary.histogram("weights_out", weights[-1])
def write_cost_summary(self, cost):
tf.summary.scalar('cost', cost)
def generate_weights(n_in, n_out, hl):
weights = []
biases = []
# Support for linear models
if len(hl) == 0:
# Weights from input layer to first hidden layer
w = tf.Variable(tf.truncated_normal([n_out, n_in], stddev = 1.0, dtype = tf.float32),
dtype = tf.float32, name = "weights_in")
b = tf.Variable(tf.zeros([n_out], dtype = tf.float32), name="bias_in", dtype = tf.float32)
weights.append(w)
biases.append(b)
return weights, biases
# Weights from input layer to first hidden layer
w = tf.Variable(tf.truncated_normal([hl[0], n_in], stddev = 1.0 / np.sqrt(hl[0]), dtype = tf.float32),
dtype = tf.float32, name = "weights_in")
b = tf.Variable(tf.zeros([hl[0]], dtype = tf.float32), name="bias_in", dtype = tf.float32)
weights.append(w)
biases.append(b)
# Weights from one hidden layer to the next
for i in range(1, len(hl)):
w = tf.Variable(tf.truncated_normal([hl[i], hl[i-1]], stddev=1.0 / np.sqrt(hl[i-1]), dtype=tf.float32),
dtype=tf.float32, name="weights_hidden_%d" % i)
b = tf.Variable(tf.zeros([hl[i]], dtype=tf.float32), name="bias_hidden_%d" % i, dtype=tf.float32)
weights.append(w)
biases.append(b)
# Weights from last hidden layer to output layer
w = tf.Variable(tf.truncated_normal([n_out, hl[-1]],
stddev=1.0 / np.sqrt(hl[-1]), dtype=tf.float32),
dtype=tf.float32, name="weights_out")
b = tf.Variable(tf.zeros([n_out], dtype=tf.float32), name="bias_out", dtype=tf.float32)
weights.append(w)
biases.append(b)
return weights, biases
================================================
FILE: qml/arad/__init__.py
================================================
# MIT License
#
# Copyright (c) 2017 Anders S. Christensen and Felix A. Faber
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
from .arad import *
================================================
FILE: qml/arad/arad.py
================================================
# MIT License
#
# Copyright (c) 2016 Anders Steen Christensen, Felix Faber
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
from __future__ import print_function
import numpy as np
from .farad_kernels import fget_global_kernels_arad
from .farad_kernels import fget_global_symmetric_kernels_arad
from .farad_kernels import fget_local_kernels_arad
from .farad_kernels import fget_local_symmetric_kernels_arad
from .farad_kernels import fget_atomic_kernels_arad
from .farad_kernels import fget_atomic_symmetric_kernels_arad
from qml.utils.alchemy import PTP
def getAngle(sp,norms):
epsilon = 10.* np.finfo(float).eps
angles = np.zeros(sp.shape)
mask1 = np.logical_and(np.abs(sp - norms) > epsilon ,np.abs(norms) > epsilon)
angles[mask1] = np.arccos(np.clip(sp[mask1]/norms[mask1], -1.0, 1.0))
return angles
def generate_arad_representation(coordinates, nuclear_charges, size=23, cut_distance=5.0):
""" Generates a representation for the ARAD kernel module.
:param coordinates: Input coordinates.
:type coordinates: numpy array
:param nuclear_charges: List of nuclear charges.
:type nuclear_charges: numpy array
:param size: Max number of atoms in representation.
:type size: integer
:param cut_distance: Spatial cut-off distance.
:type cut_distance: float
:return: ARAD representation, shape = (size,5,size).
:rtype: numpy array
"""
# PBC is not supported by the kernels currently
cell = None
maxAts = size
maxMolSize = size
coords = coordinates
occupationList = nuclear_charges
cut = cut_distance
L = coords.shape[0]
occupationList = np.asarray(occupationList)
M = np.zeros((maxMolSize, 5, maxAts))
if cell is not None:
coords = np.dot(coords, cell)
nExtend = (np.floor(cut/np.linalg.norm(cell, 2, axis = 0)) + 1).astype(int)
for i in range(-nExtend[0], nExtend[0] + 1):
for j in range(-nExtend[1], nExtend[1] + 1):
for k in range(-nExtend[2], nExtend[2] + 1):
if i == -nExtend[0] and j == -nExtend[1] and k == -nExtend[2]:
coordsExt = coords + i*cell[0,:] + j*cell[1,:] + k*cell[2,:]
occupationListExt = occupationList.copy()
else:
occupationListExt = np.append(occupationListExt,occupationList)
coordsExt = np.append(coordsExt, coords + i*cell[0,:] + j*cell[1,:] + k*cell[2,:], axis = 0)
else:
coordsExt = coords.copy()
occupationListExt = occupationList.copy()
M[:,0,:] = 1E+100
for i in range(L):
#Calculate Distance
cD = coordsExt[:] - coords[i]
ocExt = np.asarray([PTP[o] for o in occupationListExt])
#Obtaining angles
sp = np.sum(cD[:,np.newaxis] * cD[np.newaxis,:], axis = 2)
D1 = np.sqrt(np.sum(cD**2, axis = 1))
D2 = D1[:, np.newaxis] * D1[np.newaxis, :]
angs = getAngle(sp, D2)
#Obtaining cos and sine terms
cosAngs = np.cos(angs) * (1. - np.sin(np.pi * D1[np.newaxis,:]/(2. * cut)))
sinAngs = np.sin(angs) * (1. - np.sin(np.pi * D1[np.newaxis,:]/(2. * cut)))
args = np.argsort(D1)
D1 = D1[args]
ocExt = np.asarray([ocExt[l] for l in args])
sub_indices = np.ix_(args, args)
cosAngs = cosAngs[sub_indices]
sinAngs = sinAngs[sub_indices]
args = np.where(D1 < cut)[0]
D1 = D1[args]
ocExt = np.asarray([ocExt[l] for l in args])
sub_indices = np.ix_(args, args)
cosAngs = cosAngs[sub_indices]
sinAngs = sinAngs[sub_indices]
norm = np.sum(1.0 - np.sin(np.pi * D1[np.newaxis, :] / (2.0 * cut)))
M[i, 0, :len(D1)] = D1
M[i, 1, :len(D1)] = ocExt[:, 0]
M[i, 2, :len(D1)] = ocExt[:, 1]
M[i, 3, :len(D1)] = np.sum(cosAngs,axis = 1) / norm
M[i, 4, :len(D1)] = np.sum(sinAngs,axis = 1) / norm
return M
def get_global_kernels_arad(X1, X2, sigmas,
width=0.2, cut_distance=5.0, r_width=1.0, c_width=0.5):
""" Calculates the global Gaussian kernel matrix K for atomic ARAD
descriptors for a list of different sigmas. Each kernel element
is the sum of all kernel elements between pairs of atoms in two molecules.
K is calculated using an OpenMP parallel Fortran routine.
:param X1: ARAD descriptors for molecules in set 1.
:type X1: numpy array
:param X2: Array of ARAD descriptors for molecules in set 2.
:type X2: numpy array
:param sigmas: List of sigmas for which to calculate the Kernel matrices.
:type sigmas: list
:return: The kernel matrices for each sigma - shape (number_sigmas, number_molecules1, number_molecules2)
:rtype: numpy array
"""
amax = X1.shape[1]
assert X1.shape[3] == amax, "ERROR: Check ARAD decriptor sizes! code = 1"
assert X2.shape[1] == amax, "ERROR: Check ARAD decriptor sizes! code = 2"
assert X2.shape[3] == amax, "ERROR: Check ARAD decriptor sizes! code = 3"
nm1 = X1.shape[0]
nm2 = X2.shape[0]
N1 = np.empty(nm1, dtype = np.int32)
Z1_arad = np.zeros((nm1, amax, 2))
for i in range(nm1):
N1[i] = len(np.where(X1[i,:,2,0] > 0)[0])
Z1_arad[i] = X1[i,:,1:3,0]
N2 = np.empty(nm2, dtype = np.int32)
Z2_arad = np.zeros((nm2, amax, 2))
for i in range(nm2):
N2[i] = len(np.where(X2[i,:,2,0] > 0)[0])
Z2_arad[i] = X2[i,:,1:3,0]
sigmas = np.array(sigmas)
nsigmas = sigmas.size
return fget_global_kernels_arad(X1, X2, Z1_arad, Z2_arad, N1, N2, sigmas,
nm1, nm2, nsigmas, width, cut_distance, r_width, c_width)
def get_global_symmetric_kernels_arad(X1, sigmas,
width=0.2, cut_distance=5.0, r_width=1.0, c_width=0.5):
""" Calculates the global Gaussian kernel matrix K for atomic ARAD
descriptors for a list of different sigmas. Each kernel element
is the sum of all kernel elements between pairs of atoms in two molecules.
K is calculated using an OpenMP parallel Fortran routine.
:param X1: ARAD descriptors for molecules in set 1.
:type X1: numpy array
:param sigmas: List of sigmas for which to calculate the Kernel matrices.
:type sigmas: list
:return: The kernel matrices for each sigma - shape (number_sigmas, number_molecules1, number_molecules1)
:rtype: numpy array
"""
nm1 = X1.shape[0]
amax = X1.shape[1]
N1 = np.empty(nm1, dtype = np.int32)
Z1_arad = np.zeros((nm1, amax, 2))
for i in range(nm1):
N1[i] = len(np.where(X1[i,:,2,0] > 0)[0])
Z1_arad[i] = X1[i,:,1:3,0]
sigmas = np.array(sigmas)
nsigmas = sigmas.size
return fget_global_symmetric_kernels_arad(X1, Z1_arad, N1, sigmas,
nm1, nsigmas, width, cut_distance, r_width, c_width)
def get_local_kernels_arad(X1, X2, sigmas,
width=0.2, cut_distance=5.0, r_width=1.0, c_width=0.5):
""" Calculates the Gaussian kernel matrix K for atomic ARAD
descriptors for a list of different sigmas. Each kernel element
is the sum of all kernel elements between pairs of atoms in two molecules.
K is calculated using an OpenMP parallel Fortran routine.
:param X1: ARAD descriptors for molecules in set 1.
:type X1: numpy array
:param X2: Array of ARAD descriptors for molecules in set 2.
:type X2: numpy array
:param sigmas: List of sigmas for which to calculate the Kernel matrices.
:type sigmas: list
:return: The kernel matrices for each sigma - shape (number_sigmas, number_molecules1, number_molecules2)
:rtype: numpy array
"""
amax = X1.shape[1]
assert X1.shape[3] == amax, "ERROR: Check ARAD decriptor sizes! code = 1"
assert X2.shape[1] == amax, "ERROR: Check ARAD decriptor sizes! code = 2"
assert X2.shape[3] == amax, "ERROR: Check ARAD decriptor sizes! code = 3"
nm1 = X1.shape[0]
nm2 = X2.shape[0]
N1 = np.empty(nm1, dtype = np.int32)
Z1_arad = np.zeros((nm1, amax, 2))
for i in range(nm1):
N1[i] = len(np.where(X1[i,:,2,0] > 0)[0])
Z1_arad[i] = X1[i,:,1:3,0]
N2 = np.empty(nm2, dtype = np.int32)
Z2_arad = np.zeros((nm2, amax, 2))
for i in range(nm2):
N2[i] = len(np.where(X2[i,:,2,0] > 0)[0])
Z2_arad[i] = X2[i,:,1:3,0]
sigmas = np.array(sigmas)
nsigmas = sigmas.size
return fget_local_kernels_arad(X1, X2, Z1_arad, Z2_arad, N1, N2, sigmas,
nm1, nm2, nsigmas, width, cut_distance, r_width, c_width)
def get_local_symmetric_kernels_arad(X1, sigmas,
width=0.2, cut_distance=5.0, r_width=1.0, c_width=0.5):
""" Calculates the Gaussian kernel matrix K for atomic ARAD
descriptors for a list of different sigmas. Each kernel element
is the sum of all kernel elements between pairs of atoms in two molecules.
K is calculated using an OpenMP parallel Fortran routine.
:param X1: ARAD descriptors for molecules in set 1.
:type X1: numpy array
:param sigmas: List of sigmas for which to calculate the Kernel matrices.
:type sigmas: list
:return: The kernel matrices for each sigma - shape (number_sigmas, number_molecules1, number_molecules1)
:rtype: numpy array
"""
nm1 = X1.shape[0]
amax = X1.shape[1]
N1 = np.empty(nm1, dtype = np.int32)
Z1_arad = np.zeros((nm1, amax, 2))
for i in range(nm1):
N1[i] = len(np.where(X1[i,:,2,0] > 0)[0])
Z1_arad[i] = X1[i,:,1:3,0]
sigmas = np.array(sigmas)
nsigmas = sigmas.size
return fget_local_symmetric_kernels_arad(X1, Z1_arad, N1, sigmas,
nm1, nsigmas, width, cut_distance, r_width, c_width)
def get_atomic_kernels_arad(X1, X2, sigmas,
width=0.2, cut_distance=5.0, r_width=1.0, c_width=0.5):
""" Calculates the Gaussian kernel matrix K for atomic ARAD
descriptors for a list of different sigmas. For atomic properties, e.g.
partial charges, chemical shifts, etc.
K is calculated using an OpenMP parallel Fortran routine.
:param X1: ARAD descriptors for molecules in set 1. shape=(number_atoms,5,size)
:type X1: numpy array
:param X2: ARAD descriptors for molecules in set 1. shape=(number_atoms,5,size)
:type X2: numpy array
:param sigmas: List of sigmas for which to calculate the Kernel matrices.
:type sigmas: list
:return: The kernel matrices for each sigma - shape (number_sigmas, number_atoms1, number_atoms2)
:rtype: numpy array
"""
assert len(X1.shape) == 3
assert len(X2.shape) == 3
na1 = X1.shape[0]
na2 = X2.shape[0]
N1 = np.empty(na1, dtype = np.int32)
N2 = np.empty(na2, dtype = np.int32)
Z1_arad = np.zeros((na1, 2))
Z2_arad = np.zeros((na2, 2))
for i in range(na1):
N1[i] = len(np.where(X1[i,0,:] < cut_distance)[0])
Z1_arad[i] = X1[i,1:3,0]
for i in range(na2):
N2[i] = len(np.where(X2[i,0,:] < cut_distance)[0])
Z2_arad[i] = X2[i,1:3,0]
sigmas = np.array(sigmas)
nsigmas = sigmas.size
return fget_atomic_kernels_arad(X1, X2, Z1_arad, Z2_arad, N1, N2, sigmas,
na1, na2, nsigmas, width, cut_distance, r_width, c_width)
def get_atomic_symmetric_kernels_arad(X1, sigmas,
width=0.2, cut_distance=5.0, r_width=1.0, c_width=0.5):
""" Calculates the Gaussian kernel matrix K for atomic ARAD
descriptors for a list of different sigmas. For atomic properties, e.g.
partial charges, chemical shifts, etc.
K is calculated using an OpenMP parallel Fortran routine.
:param X1: ARAD descriptors for molecules in set 1. shape=(number_atoms,5,size)
:type X1: numpy array
:param sigmas: List of sigmas for which to calculate the Kernel matrices.
:type sigmas: list
:return: The kernel matrices for each sigma - shape (number_sigmas, number_atoms1, number_atoms1)
:rtype: numpy array
"""
assert len(X1.shape) == 3
na1 = X1.shape[0]
N1 = np.empty(na1, dtype = np.int32)
Z1_arad = np.zeros((na1, 2))
for i in range(na1):
N1[i] = len(np.where(X1[i,0,:] < cut_distance)[0])
Z1_arad[i] = X1[i,1:3,0]
sigmas = np.array(sigmas)
nsigmas = sigmas.size
return fget_atomic_symmetric_kernels_arad(X1, Z1_arad, N1, sigmas,
na1, nsigmas, width, cut_distance, r_width, c_width)
================================================
FILE: qml/arad/farad_kernels.f90
================================================
! MIT License
!
! Copyright (c) 2016 Anders Steen Christensen, Felix Faber
!
! Permission is hereby granted, free of charge, to any person obtaining a copy
! of this software and associated documentation files (the "Software"), to deal
! in the Software without restriction, including without limitation the rights
! to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
! copies of the Software, and to permit persons to whom the Software is
! furnished to do so, subject to the following conditions:
!
! The above copyright notice and this permission notice shall be included in all
! copies or substantial portions of the Software.
!
! THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
! IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
! FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
! AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
! LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
! OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
! SOFTWARE.
module arad
implicit none
contains
function atomic_distl2(X1, X2, N1, N2, sin1, sin2, width, cut_distance, r_width, c_width) result(aadist)
implicit none
double precision, dimension(:,:), intent(in) :: X1
double precision, dimension(:,:), intent(in) :: X2
integer, intent(in) :: N1
integer, intent(in) :: N2
double precision, dimension(:), intent(in) :: sin1
double precision, dimension(:), intent(in) :: sin2
double precision, intent(in) :: width
double precision, intent(in) :: cut_distance
double precision, intent(in) :: r_width
double precision, intent(in) :: c_width
double precision :: aadist
double precision :: d
integer :: m_1, m_2
double precision :: maxgausdist2
double precision :: inv_width
double precision :: c_width2, r_width2, r2
inv_width = -1.0d0 / (4.0d0 * width**2)
maxgausdist2 = (8.0d0 * width)**2
r_width2 = r_width**2
c_width2 = c_width**2
aadist = 0.0d0
do m_1 = 1, N1
if (X1(1, m_1) > cut_distance) exit
do m_2 = 1, N2
if (X2(1, m_2) > cut_distance) exit
r2 = (X2(1,m_2) - X1(1,m_1))**2
if (r2 < maxgausdist2) then
d = exp(r2 * inv_width ) * sin1(m_1) * sin2(m_2)
d = d * (r_width2/(r_width2 + (x1(2,m_1) - x2(2,m_2))**2) * &
& c_width2/(c_width2 + (x1(3,m_1) - x2(3,m_2))**2))
aadist = aadist + d * (1.0d0 + x1(4,m_1)*x2(4,m_2) + x1(5,m_1)*x2(5,m_2))
end if
end do
end do
end function atomic_distl2
end module arad
subroutine fget_local_kernels_arad(q1, q2, z1, z2, n1, n2, sigmas, nm1, nm2, nsigmas, &
& width, cut_distance, r_width, c_width, kernels)
use arad, only: atomic_distl2
implicit none
! ARAD descriptors for the training set, format (i,j_1,5,m_1)
double precision, dimension(:,:,:,:), intent(in) :: q1
double precision, dimension(:,:,:,:), intent(in) :: q2
! ARAD atom-types for each atom in each molecule, format (i, j_1, 2)
double precision, dimension(:,:,:), intent(in) :: z1
double precision, dimension(:,:,:), intent(in) :: z2
! List of numbers of atoms in each molecule
integer, dimension(:), intent(in) :: n1
integer, dimension(:), intent(in) :: n2
! Sigma in the Gaussian kernel
double precision, dimension(:), intent(in) :: sigmas
! Number of molecules
integer, intent(in) :: nm1
integer, intent(in) :: nm2
! Number of sigmas
integer, intent(in) :: nsigmas
! -1.0 / sigma^2 for use in the kernel
double precision, dimension(nsigmas) :: inv_sigma2
! ARAD parameters
double precision, intent(in) :: width
double precision, intent(in) :: cut_distance
double precision, intent(in) :: r_width
double precision, intent(in) :: c_width
! Resulting alpha vector
double precision, dimension(nsigmas,nm1,nm2), intent(out) :: kernels
! Internal counters
integer :: i, j, k, ni, nj
integer :: m_1, i_1, j_1
! Pre-computed constants
double precision :: r_width2
double precision :: c_width2
double precision :: inv_cut
! Temporary variables necessary for parallelization
double precision :: l2dist
double precision, allocatable, dimension(:,:) :: atomic_distance
! Pre-computed terms in the full distance matrix
double precision, allocatable, dimension(:,:) :: selfl21
double precision, allocatable, dimension(:,:) :: selfl22
! Pre-computed sine terms
double precision, allocatable, dimension(:,:,:) :: sin1
double precision, allocatable, dimension(:,:,:) :: sin2
! Value of PI at full FORTRAN precision.
double precision, parameter :: pi = 4.0d0 * atan(1.0d0)
r_width2 = r_width**2
c_width2 = c_width**2
inv_cut = pi / (2.0d0 * cut_distance)
inv_sigma2(:) = -1.0d0 / (sigmas(:))**2
allocate(sin1(nm1, maxval(n1), maxval(n1)))
allocate(sin2(nm2, maxval(n2), maxval(n2)))
sin1 = 0.0d0
sin2 = 0.0d0
!$OMP PARALLEL DO PRIVATE(ni)
do i = 1, nm1
ni = n1(i)
do m_1 = 1, ni
do i_1 = 1, ni
if (q1(i,i_1,1,m_1) < cut_distance) then
sin1(i, i_1, m_1) = 1.0d0 - sin(q1(i,i_1,1,m_1) * inv_cut)
endif
enddo
enddo
enddo
!$OMP END PARALLEL DO
!$OMP PARALLEL DO PRIVATE(ni)
do i = 1, nm2
ni = n2(i)
do m_1 = 1, ni
do i_1 = 1, ni
if (q2(i,i_1,1,m_1) < cut_distance) then
sin2(i, i_1, m_1) = 1.0d0 - sin(q2(i,i_1,1,m_1) * inv_cut)
endif
enddo
enddo
enddo
!$OMP END PARALLEL DO
allocate(selfl21(nm1, maxval(n1)))
allocate(selfl22(nm2, maxval(n2)))
!$OMP PARALLEL DO PRIVATE(ni)
do i = 1, nm1
ni = n1(i)
do i_1 = 1, ni
selfl21(i,i_1) = atomic_distl2(q1(i,i_1,:,:), q1(i,i_1,:,:), n1(i), n1(i), &
& sin1(i,i_1,:), sin1(i,i_1,:), width, cut_distance, r_width, c_width)
enddo
enddo
!$OMP END PARALLEL DO
!$OMP PARALLEL DO PRIVATE(ni)
do i = 1, nm2
ni = n2(i)
do i_1 = 1, ni
selfl22(i,i_1) = atomic_distl2(q2(i,i_1,:,:), q2(i,i_1,:,:), n2(i), n2(i), &
& sin2(i,i_1,:), sin2(i,i_1,:), width, cut_distance, r_width, c_width)
enddo
enddo
!$OMP END PARALLEL DO
allocate(atomic_distance(maxval(n1), maxval(n2)))
kernels(:,:,:) = 0.0d0
atomic_distance(:,:) = 0.0d0
!$OMP PARALLEL DO PRIVATE(l2dist,atomic_distance,ni,nj) schedule(dynamic)
do j = 1, nm2
nj = n2(j)
do i = 1, nm1
ni = n1(i)
atomic_distance(:,:) = 0.0d0
do i_1 = 1, ni
do j_1 = 1, nj
l2dist = atomic_distl2(q1(i,i_1,:,:), q2(j,j_1,:,:), n1(i), n2(j), &
& sin1(i,i_1,:), sin2(j,j_1,:), width, cut_distance, r_width, c_width)
l2dist = selfl21(i,i_1) + selfl22(j,j_1) - 2.0d0 * l2dist &
& * (r_width2/(r_width2 + (z1(i,i_1,1) - z2(j,j_1,1))**2) * &
& c_width2/(c_width2 + (z1(i,i_1,2) - z2(j,j_1,2))**2))
atomic_distance(i_1,j_1) = l2dist
enddo
enddo
do k = 1, nsigmas
kernels(k, i, j) = sum(exp(atomic_distance(:ni,:nj) * inv_sigma2(k)))
enddo
enddo
enddo
!$OMP END PARALLEL DO
deallocate(atomic_distance)
deallocate(selfl21)
deallocate(selfl22)
deallocate(sin1)
deallocate(sin2)
end subroutine fget_local_kernels_arad
subroutine fget_local_symmetric_kernels_arad(q1, z1, n1, sigmas, nm1, nsigmas, &
& width, cut_distance, r_width, c_width, kernels)
use arad, only: atomic_distl2
implicit none
! ARAD descriptors for the training set, format (i,j_1,5,m_1)
double precision, dimension(:,:,:,:), intent(in) :: q1
! ARAD atom-types for each atom in each molecule, format (i, j_1, 2)
double precision, dimension(:,:,:), intent(in) :: z1
! List of numbers of atoms in each molecule
integer, dimension(:), intent(in) :: n1
! Sigma in the Gaussian kernel
double precision, dimension(:), intent(in) :: sigmas
! Number of molecules
integer, intent(in) :: nm1
! Number of sigmas
integer, intent(in) :: nsigmas
! -1.0 / sigma^2 for use in the kernel
double precision, dimension(nsigmas) :: inv_sigma2
! ARAD parameters
double precision, intent(in) :: width
double precision, intent(in) :: cut_distance
double precision, intent(in) :: r_width
double precision, intent(in) :: c_width
! Resulting alpha vector
double precision, dimension(nsigmas,nm1,nm1), intent(out) :: kernels
! Internal counters
integer :: i, j, k, ni, nj
integer :: m_1, i_1, j_1
! Pre-computed constants
double precision :: r_width2
double precision :: c_width2
double precision :: inv_cut
! Temporary variables necessary for parallelization
double precision :: l2dist
double precision, allocatable, dimension(:,:) :: atomic_distance
! Pre-computed terms in the full distance matrix
double precision, allocatable, dimension(:,:) :: selfl21
! Pre-computed sine terms
double precision, allocatable, dimension(:,:,:) :: sin1
! Value of PI at full FORTRAN precision.
double precision, parameter :: pi = 4.0d0 * atan(1.0d0)
r_width2 = r_width**2
c_width2 = c_width**2
inv_cut = pi / (2.0d0 * cut_distance)
inv_sigma2(:) = -1.0d0 / (sigmas(:))**2
allocate(sin1(nm1, maxval(n1), maxval(n1)))
!$OMP PARALLEL DO PRIVATE(ni)
do i = 1, nm1
ni = n1(i)
do m_1 = 1, ni
do i_1 = 1, ni
sin1(i, i_1, m_1) = 1.0d0 - sin(q1(i,i_1,1,m_1) * inv_cut)
enddo
enddo
enddo
!$OMP END PARALLEL DO
allocate(selfl21(nm1, maxval(n1)))
!$OMP PARALLEL DO PRIVATE(ni)
do i = 1, nm1
ni = n1(i)
do i_1 = 1, ni
selfl21(i,i_1) = atomic_distl2(q1(i,i_1,:,:), q1(i,i_1,:,:), n1(i), n1(i), &
& sin1(i,i_1,:), sin1(i,i_1,:), width, cut_distance, r_width, c_width)
enddo
enddo
!$OMP END PARALLEL DO
allocate(atomic_distance(maxval(n1), maxval(n1)))
kernels(:,:,:) = 0.0d0
atomic_distance(:,:) = 0.0d0
!$OMP PARALLEL DO PRIVATE(l2dist,atomic_distance,ni,nj) schedule(dynamic)
do j = 1, nm1
nj = n1(j)
do i = 1, j
ni = n1(i)
atomic_distance(:,:) = 0.0d0
do i_1 = 1, ni
do j_1 = 1, nj
l2dist = atomic_distl2(q1(i,i_1,:,:), q1(j,j_1,:,:), n1(i), n1(j), &
& sin1(i,i_1,:), sin1(j,j_1,:), width, cut_distance, r_width, c_width)
l2dist = selfl21(i,i_1) + selfl21(j,j_1) - 2.0d0 * l2dist &
& * (r_width2/(r_width2 + (z1(i,i_1,1) - z1(j,j_1,1))**2) &
& * c_width2/(c_width2 + (z1(i,i_1,2) - z1(j,j_1,2))**2))
atomic_distance(i_1,j_1) = l2dist
enddo
enddo
do k = 1, nsigmas
kernels(k, i, j) = sum(exp(atomic_distance(:ni,:nj) * inv_sigma2(k)))
kernels(k, j, i) = kernels(k, i, j)
enddo
enddo
enddo
!$OMP END PARALLEL DO
deallocate(atomic_distance)
deallocate(selfl21)
deallocate(sin1)
end subroutine fget_local_symmetric_kernels_arad
subroutine fget_atomic_kernels_arad(q1, q2, z1, z2, n1, n2, sigmas, na1, na2, nsigmas, &
& width, cut_distance, r_width, c_width, kernels)
use arad, only: atomic_distl2
implicit none
! ARAD descriptors for each atom in the training set, format (i,5,m_1)
double precision, dimension(:,:,:), intent(in) :: q1
double precision, dimension(:,:,:), intent(in) :: q2
! ARAD atom-types for each atom, format (i, 2)
double precision, dimension(:,:), intent(in) :: z1
double precision, dimension(:,:), intent(in) :: z2
! Sigma in the Gaussian kernel
double precision, dimension(:), intent(in) :: sigmas
! List of numbers of atoms in each molecule
integer, dimension(:), intent(in) :: n1
integer, dimension(:), intent(in) :: n2
! Number of atom
integer, intent(in) :: na1
integer, intent(in) :: na2
! Number of sigmas
integer, intent(in) :: nsigmas
! -1.0 / sigma^2 for use in the kernel
double precision, dimension(nsigmas) :: inv_sigma2
! ARAD parameters
double precision, intent(in) :: width
double precision, intent(in) :: cut_distance
double precision, intent(in) :: r_width
double precision, intent(in) :: c_width
! Resulting alpha vector
double precision, dimension(nsigmas,na1,na2), intent(out) :: kernels
! Internal counters
integer :: i, j, k, ni
integer :: m_1
! Pre-computed constants
double precision :: r_width2
double precision :: c_width2
double precision :: inv_cut
! Temporary variables necessary for parallelization
double precision :: l2dist
! Pre-computed terms in the full distance matrix
double precision, allocatable, dimension(:) :: selfl21
double precision, allocatable, dimension(:) :: selfl22
! Pre-computed sine terms
double precision, allocatable, dimension(:,:) :: sin1
double precision, allocatable, dimension(:,:) :: sin2
! Value of PI at full FORTRAN precision.
double precision, parameter :: pi = 4.0d0 * atan(1.0d0)
r_width2 = r_width**2
c_width2 = c_width**2
inv_cut = pi / (2.0d0 * cut_distance)
inv_sigma2(:) = -1.0d0 / (sigmas(:))**2
allocate(sin1(na1, maxval(n1)))
allocate(sin2(na2, maxval(n2)))
!$OMP PARALLEL DO PRIVATE(ni)
do i = 1, na1
ni = n1(i)
do m_1 = 1, ni
sin1(i, m_1) = 1.0d0 - sin(q1(i,1,m_1) * inv_cut)
enddo
enddo
!$OMP END PARALLEL DO
!$OMP PARALLEL DO PRIVATE(ni)
do i = 1, na2
ni = n2(i)
do m_1 = 1, ni
sin2(i, m_1) = 1.0d0 - sin(q2(i,1,m_1) * inv_cut)
enddo
enddo
!$OMP END PARALLEL DO
allocate(selfl21(na1))
allocate(selfl22(na2))
!$OMP PARALLEL DO PRIVATE(ni)
do i = 1, na1
selfl21(i) = atomic_distl2(q1(i,:,:), q1(i,:,:), n1(i), n1(i), &
& sin1(i,:), sin1(i,:), width, cut_distance, r_width, c_width)
enddo
!$OMP END PARALLEL DO
!$OMP PARALLEL DO PRIVATE(ni)
do i = 1, na2
selfl22(i) = atomic_distl2(q2(i,:,:), q2(i,:,:), n2(i), n2(i), &
& sin2(i,:), sin2(i,:), width, cut_distance, r_width, c_width)
enddo
!$OMP END PARALLEL DO
kernels(:,:,:) = 0.0d0
!$OMP PARALLEL DO PRIVATE(l2dist) schedule(dynamic)
do j = 1, na2
do i = 1, na1
l2dist = atomic_distl2(q1(i,:,:), q2(j,:,:), n1(i), n2(j), &
& sin1(i,:), sin2(j,:), width, cut_distance, r_width, c_width)
l2dist = selfl21(i) + selfl22(j) - 2.0d0 * l2dist &
& * (r_width2/(r_width2 + (z1(i,1) - z2(j,1))**2) * &
& c_width2/(c_width2 + (z1(i,2) - z2(j,2))**2))
do k = 1, nsigmas
kernels(k, i, j) = exp(l2dist * inv_sigma2(k))
enddo
enddo
enddo
!$OMP END PARALLEL DO
deallocate(selfl21)
deallocate(selfl22)
deallocate(sin1)
deallocate(sin2)
end subroutine fget_atomic_kernels_arad
subroutine fget_atomic_symmetric_kernels_arad(q1, z1, n1, sigmas, na1, nsigmas, &
& width, cut_distance, r_width, c_width, kernels)
use arad, only: atomic_distl2
implicit none
! ARAD descriptors for each atom in the training set, format (i,5,m_1)
double precision, dimension(:,:,:), intent(in) :: q1
! ARAD atom-types for each atom, format (i, 2)
double precision, dimension(:,:), intent(in) :: z1
! Sigma in the Gaussian kernel
double precision, dimension(:), intent(in) :: sigmas
! List of numbers of atoms in each molecule
integer, dimension(:), intent(in) :: n1
! Number of atom
integer, intent(in) :: na1
! Number of sigmas
integer, intent(in) :: nsigmas
! -1.0 / sigma^2 for use in the kernel
double precision, dimension(nsigmas) :: inv_sigma2
! ARAD parameters
double precision, intent(in) :: width
double precision, intent(in) :: cut_distance
double precision, intent(in) :: r_width
double precision, intent(in) :: c_width
! Resulting alpha vector
double precision, dimension(nsigmas,na1,na1), intent(out) :: kernels
! Internal counters
integer :: i, j, k, ni
integer :: m_1
! Pre-computed constants
double precision :: r_width2
double precision :: c_width2
double precision :: inv_cut
! Temporary variables necessary for parallelization
double precision :: l2dist
! Pre-computed terms in the full distance matrix
double precision, allocatable, dimension(:) :: selfl21
! Pre-computed sine terms
double precision, allocatable, dimension(:,:) :: sin1
! Value of PI at full FORTRAN precision.
double precision, parameter :: pi = 4.0d0 * atan(1.0d0)
r_width2 = r_width**2
c_width2 = c_width**2
inv_cut = pi / (2.0d0 * cut_distance)
inv_sigma2(:) = -1.0d0 / (sigmas(:))**2
allocate(sin1(na1, maxval(n1)))
!$OMP PARALLEL DO PRIVATE(ni)
do i = 1, na1
ni = n1(i)
do m_1 = 1, ni
sin1(i, m_1) = 1.0d0 - sin(q1(i,1,m_1) * inv_cut)
enddo
enddo
!$OMP END PARALLEL DO
allocate(selfl21(na1))
!$OMP PARALLEL DO PRIVATE(ni)
do i = 1, na1
selfl21(i) = atomic_distl2(q1(i,:,:), q1(i,:,:), n1(i), n1(i), &
& sin1(i,:), sin1(i,:), width, cut_distance, r_width, c_width)
enddo
!$OMP END PARALLEL DO
kernels(:,:,:) = 0.0d0
!$OMP PARALLEL DO PRIVATE(l2dist) schedule(dynamic)
do j = 1, na1
do i = j, na1
l2dist = atomic_distl2(q1(i,:,:), q1(j,:,:), n1(i), n1(j), &
& sin1(i,:), sin1(j,:), width, cut_distance, r_width, c_width)
l2dist = selfl21(i) + selfl21(j) - 2.0d0 * l2dist &
& * (r_width2/(r_width2 + (z1(i,1) - z1(j,1))**2) * &
& c_width2/(c_width2 + (z1(i,2) - z1(j,2))**2))
do k = 1, nsigmas
kernels(k, i, j) = exp(l2dist * inv_sigma2(k))
kernels(k, j, i) = exp(l2dist * inv_sigma2(k))
enddo
enddo
enddo
!$OMP END PARALLEL DO
deallocate(selfl21)
deallocate(sin1)
end subroutine fget_atomic_symmetric_kernels_arad
subroutine fget_global_symmetric_kernels_arad(q1, z1, n1, sigmas, nm1, nsigmas, &
& width, cut_distance, r_width, c_width, kernels)
use arad, only: atomic_distl2
implicit none
! ARAD descriptors for the training set, format (i,j_1,5,m_1)
double precision, dimension(:,:,:,:), intent(in) :: q1
! ARAD atom-types for each atom in each molecule, format (i, j_1, 2)
double precision, dimension(:,:,:), intent(in) :: z1
! List of numbers of atoms in each molecule
integer, dimension(:), intent(in) :: n1
! Sigma in the Gaussian kernel
double precision, dimension(:), intent(in) :: sigmas
! Number of molecules
integer, intent(in) :: nm1
! Number of sigmas
integer, intent(in) :: nsigmas
! -1.0 / sigma^2 for use in the kernel
double precision, dimension(nsigmas) :: inv_sigma2
! ARAD parameters
double precision, intent(in) :: width
double precision, intent(in) :: cut_distance
double precision, intent(in) :: r_width
double precision, intent(in) :: c_width
! Resulting alpha vector
double precision, dimension(nsigmas,nm1,nm1), intent(out) :: kernels
! Internal counters
integer :: i, j, k, ni, nj
integer :: m_1, i_1, j_1
! Pre-computed constants
double precision :: r_width2
double precision :: c_width2
double precision :: inv_cut
! Temporary variables necessary for parallelization
double precision :: l2dist
double precision, allocatable, dimension(:,:) :: atomic_distance
! Pre-computed terms in the full distance matrix
double precision, allocatable, dimension(:) :: selfl21
! Pre-computed sine terms
double precision, allocatable, dimension(:,:,:) :: sin1
! Value of PI at full FORTRAN precision.
double precision, parameter :: pi = 4.0d0 * atan(1.0d0)
double precision :: mol_dist
r_width2 = r_width**2
c_width2 = c_width**2
inv_cut = pi / (2.0d0 * cut_distance)
inv_sigma2(:) = -1.0d0 / (sigmas(:))**2
allocate(sin1(nm1, maxval(n1), maxval(n1)))
!$OMP PARALLEL DO PRIVATE(ni)
do i = 1, nm1
ni = n1(i)
do m_1 = 1, ni
do i_1 = 1, ni
sin1(i, i_1, m_1) = 1.0d0 - sin(q1(i,i_1,1,m_1) * inv_cut)
enddo
enddo
enddo
!$OMP END PARALLEL DO
allocate(selfl21(nm1))
selfl21 = 0.0d0
!$OMP PARALLEL DO PRIVATE(ni) REDUCTION(+:selfl21)
do i = 1, nm1
ni = n1(i)
do i_1 = 1, ni
do j_1 = 1, ni
selfl21(i) = selfl21(i) + atomic_distl2(q1(i,i_1,:,:), q1(i,j_1,:,:), n1(i), n1(i), &
& sin1(i,i_1,:), sin1(i,j_1,:), width, cut_distance, r_width, c_width) &
& * (r_width2/(r_width2 + (z1(i,i_1,1) - z1(i,j_1,1))**2) * &
& c_width2/(c_width2 + (z1(i,i_1,2) - z1(i,j_1,2))**2))
enddo
enddo
enddo
!$OMP END PARALLEL DO
allocate(atomic_distance(maxval(n1), maxval(n1)))
kernels(:,:,:) = 0.0d0
atomic_distance(:,:) = 0.0d0
!$OMP PARALLEL DO PRIVATE(l2dist,atomic_distance,ni,nj,mol_dist) schedule(dynamic)
do j = 1, nm1
nj = n1(j)
do i = 1, j! nm1
ni = n1(i)
atomic_distance(:,:) = 0.0d0
do i_1 = 1, ni
do j_1 = 1, nj
l2dist = atomic_distl2(q1(i,i_1,:,:), q1(j,j_1,:,:), n1(i), n1(j), &
& sin1(i,i_1,:), sin1(j,j_1,:), width, cut_distance, r_width, c_width)
L2dist = l2dist * (r_width2/(r_width2 + (z1(i,i_1,1) - z1(j,j_1,1))**2) * &
& c_width2/(c_width2 + (z1(i,i_1,2) - z1(j,j_1,2))**2))
atomic_distance(i_1,j_1) = l2dist
enddo
enddo
mol_dist = selfl21(i) + selfl21(j) - 2.0d0 * sum(atomic_distance(:ni,:nj))
do k = 1, nsigmas
kernels(k, i, j) = exp(mol_dist * inv_sigma2(k))
kernels(k, j, i) = kernels(k, i, j)
enddo
enddo
enddo
!$OMP END PARALLEL DO
deallocate(atomic_distance)
deallocate(selfl21)
deallocate(sin1)
end subroutine fget_global_symmetric_kernels_arad
subroutine fget_global_kernels_arad(q1, q2, z1, z2, n1, n2, sigmas, nm1, nm2, nsigmas, &
& width, cut_distance, r_width, c_width, kernels)
use arad, only: atomic_distl2
implicit none
! ARAD descriptors for the training set, format (i,j_1,5,m_1)
double precision, dimension(:,:,:,:), intent(in) :: q1
double precision, dimension(:,:,:,:), intent(in) :: q2
! ARAD atom-types for each atom in each molecule, format (i, j_1, 2)
double precision, dimension(:,:,:), intent(in) :: z1
double precision, dimension(:,:,:), intent(in) :: z2
! List of numbers of atoms in each molecule
integer, dimension(:), intent(in) :: n1
integer, dimension(:), intent(in) :: n2
! Sigma in the Gaussian kernel
double precision, dimension(:), intent(in) :: sigmas
! Number of molecules
integer, intent(in) :: nm1
integer, intent(in) :: nm2
! Number of sigmas
integer, intent(in) :: nsigmas
! -1.0 / sigma^2 for use in the kernel
double precision, dimension(nsigmas) :: inv_sigma2
! ARAD parameters
double precision, intent(in) :: width
double precision, intent(in) :: cut_distance
double precision, intent(in) :: r_width
double precision, intent(in) :: c_width
! Resulting alpha vector
double precision, dimension(nsigmas,nm1,nm2), intent(out) :: kernels
! Internal counters
integer :: i, j, k, ni, nj
integer :: m_1, i_1, j_1
! Pre-computed constants
double precision :: r_width2
double precision :: c_width2
double precision :: inv_cut
! Temporary variables necessary for parallelization
double precision :: l2dist
double precision, allocatable, dimension(:,:) :: atomic_distance
! Pre-computed terms in the full distance matrix
double precision, allocatable, dimension(:) :: selfl21
double precision, allocatable, dimension(:) :: selfl22
! Pre-computed sine terms
double precision, allocatable, dimension(:,:,:) :: sin1
double precision, allocatable, dimension(:,:,:) :: sin2
! Value of PI at full FORTRAN precision.
double precision, parameter :: pi = 4.0d0 * atan(1.0d0)
double precision :: mol_dist
r_width2 = r_width**2
c_width2 = c_width**2
inv_cut = pi / (2.0d0 * cut_distance)
inv_sigma2(:) = -1.0d0 / (sigmas(:))**2
allocate(sin1(nm1, maxval(n1), maxval(n1)))
allocate(sin2(nm2, maxval(n2), maxval(n2)))
sin1 = 0.0d0
sin2 = 0.0d0
!$OMP PARALLEL DO PRIVATE(ni)
do i = 1, nm1
ni = n1(i)
do m_1 = 1, ni
do i_1 = 1, ni
if (q1(i,i_1,1,m_1) < cut_distance) then
sin1(i, i_1, m_1) = 1.0d0 - sin(q1(i,i_1,1,m_1) * inv_cut)
endif
enddo
enddo
enddo
!$OMP END PARALLEL DO
!$OMP PARALLEL DO PRIVATE(ni)
do i = 1, nm2
ni = n2(i)
do m_1 = 1, ni
do i_1 = 1, ni
if (q2(i,i_1,1,m_1) < cut_distance) then
sin2(i, i_1, m_1) = 1.0d0 - sin(q2(i,i_1,1,m_1) * inv_cut)
endif
enddo
enddo
enddo
!$OMP END PARALLEL DO
allocate(selfl21(nm1))
allocate(selfl22(nm2))
selfl21 = 0.0d0
selfl22 = 0.0d0
!$OMP PARALLEL DO PRIVATE(ni) REDUCTION(+:selfl21)
do i = 1, nm1
ni = n1(i)
do i_1 = 1, ni
do j_1 = 1, ni
selfl21(i) = selfl21(i) + atomic_distl2(q1(i,i_1,:,:), q1(i,j_1,:,:), n1(i), n1(i), &
& sin1(i,i_1,:), sin1(i,j_1,:), width, cut_distance, r_width, c_width) &
& * (r_width2/(r_width2 + (z1(i,i_1,1) - z1(i,j_1,1))**2) * &
& c_width2/(c_width2 + (z1(i,i_1,2) - z1(i,j_1,2))**2))
enddo
enddo
enddo
!$OMP END PARALLEL DO
!$OMP PARALLEL DO PRIVATE(ni) REDUCTION(+:selfl22)
do i = 1, nm2
ni = n2(i)
do i_1 = 1, ni
do j_1 = 1, ni
selfl22(i) = selfl22(i) + atomic_distl2(q2(i,i_1,:,:), q2(i,j_1,:,:), n2(i), n2(i), &
& sin2(i,i_1,:), sin2(i,j_1,:), width, cut_distance, r_width, c_width) &
&* (r_width2/(r_width2 + (z2(i,i_1,1) - z2(i,j_1,1))**2) * &
& c_width2/(c_width2 + (z2(i,i_1,2) - z2(i,j_1,2))**2))
enddo
enddo
enddo
!$OMP END PARALLEL DO
allocate(atomic_distance(maxval(n1), maxval(n2)))
kernels(:,:,:) = 0.0d0
atomic_distance(:,:) = 0.0d0
!$OMP PARALLEL DO PRIVATE(l2dist,atomic_distance,ni,nj,mol_dist) schedule(dynamic)
do j = 1, nm2
nj = n2(j)
do i = 1, nm1
ni = n1(i)
atomic_distance(:,:) = 0.0d0
do i_1 = 1, ni
do j_1 = 1, nj
l2dist = atomic_distl2(q1(i,i_1,:,:), q2(j,j_1,:,:), n1(i), n2(j), &
& sin1(i,i_1,:), sin2(j,j_1,:), width, cut_distance, r_width, c_width)
L2dist = l2dist * (r_width2/(r_width2 + (z1(i,i_1,1) - z2(j,j_1,1))**2) * &
& c_width2/(c_width2 + (z1(i,i_1,2) - z2(j,j_1,2))**2))
atomic_distance(i_1,j_1) = l2dist
enddo
enddo
mol_dist = selfl21(i) + selfl22(j) - 2.0d0 * sum(atomic_distance(:ni,:nj))
do k = 1, nsigmas
kernels(k, i, j) = exp(mol_dist * inv_sigma2(k))
enddo
enddo
enddo
!$OMP END PARALLEL DO
deallocate(atomic_distance)
deallocate(selfl21)
deallocate(selfl22)
deallocate(sin1)
deallocate(sin2)
end subroutine fget_global_kernels_arad
================================================
FILE: qml/driver/driver_mpi.f90
================================================
! MIT License
!
! Copyright (c) 2016 Anders Steen Christensen, Guido Falk von Rudorff
!
! Permission is hereby granted, free of charge, to any person obtaining a copy
! of this software and associated documentation files (the "Software"), to deal
! in the Software without restriction, including without limitation the rights
! to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
! copies of the Software, and to permit persons to whom the Software is
! furnished to do so, subject to the following conditions:
!
! The above copyright notice and this permission notice shall be included in all
! copies or substantial portions of the Software.
!
! THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
! IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
! FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
! AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
! LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
! OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
! SOFTWARE.
! prototype external calculator of the kernel matrix and solver for alpha coefficients
! makes use of a PBLAS implementation, here the MKL variant
! core idea is to distribute the kernel matrix across MPI ranks to allow out-of-core datasets to be processed
!
! CSCS:
! load modules PrgEnv-cray/6.0.4 cray-mpich/7.6.0 daint-gpu intel/17.0.4.196
! build with ifort driver_mpi.f90 -o driver_mpi -L${MKLROOT}/lib/intel64 -Wl,--no-as-needed -lmkl_scalapack_lp64 -lmkl_gf_lp64 -lmkl_sequential -lmkl_core -lmkl_blacs_openmpi_lp64 -lpthread -lm -ldl -m64 -I${MKLROOT}/include -Og -g -Wall -Wextra -pedantic -fimplicit-none -fcheck=all -fbacktrace
program qml_driver
use mpi
implicit none
double precision, allocatable, dimension(:,:) :: Q
double precision, allocatable, dimension(:):: Y
double precision :: sigma
integer :: rep_size
integer :: n_molecules
double precision, allocatable, dimension(:) :: alphas
integer :: info
integer :: na, i, numroc
integer :: local_i, local_j, global_i, global_j
integer :: lwork
double precision, dimension(:), allocatable :: work
double precision, dimension(:,:), allocatable :: local_K, local_B
! pblacs data structures
integer :: local_K_rows, local_K_cols
integer :: local_B_rows, local_B_cols
integer :: local_id, num_ranks, ranks_rows, ranks_cols, context
integer :: local_rank_col, local_rank_row, block_size
integer :: ierr
integer, dimension(9) :: desca, descb
integer, dimension(2) :: dims
double precision, dimension(2) :: work_query
! init pblacs and set cartesian grid of MPI ranks
call blacs_pinfo(local_id, num_ranks)
dims = 0
call MPI_Dims_create(num_ranks, 2, dims, ierr)
ranks_rows = dims(1)
ranks_cols = dims(2)
block_size = 100
! create BLACS context
call blacs_get(0, 0, context)
call blacs_gridinit(context, 'R', ranks_rows, ranks_cols)
call blacs_gridinfo(context, ranks_rows, ranks_cols, &
local_rank_row, local_rank_col)
! Read hyperparameters and arrat suzes
open(unit = 9, file = "parameters.fout", form="formatted")
read(9,*) sigma, rep_size, n_molecules
! Allocate labels
allocate(Y(n_molecules))
read(9,*) Y(:n_molecules)
close(9)
! allocate alphas
allocate(alphas(n_molecules))
! Allocate representations
allocate(Q(n_molecules, rep_size))
! Read representations
open(unit = 9, file = "representations.fout", form="formatted")
! Read representaions for each molecule
do i = 1, n_molecules
read(9,*) Q(i,:rep_size)
enddo
close(9)
! Size of kernel
na = size(Q, dim=1)
! Allocate kernel and output
local_K_rows = numroc(na, block_size, local_rank_row, 0, ranks_rows)
local_K_cols = numroc(na, block_size, local_rank_col, 0, ranks_cols)
allocate(local_K(local_K_rows, local_K_cols))
local_B_rows = numroc(na, block_size, local_rank_row, 0, ranks_rows)
local_B_cols = numroc(1, block_size, local_rank_col, 0, ranks_cols)
allocate(local_B(local_B_rows, local_B_cols))
! Calculate Laplacian kernel
do local_j = 1, local_K_cols
call l2g(local_j, local_rank_col, ranks_cols, &
block_size, global_j)
do local_i = 1, local_K_rows
call l2g(local_i, local_rank_row, ranks_rows, &
block_size, global_i)
local_K(local_i, local_j) = exp(-sum(abs(Q(global_j,:) - Q(global_i,:)))/sigma)
enddo
enddo
! Setup variables for LAPACK
call descinit(desca, na, na, block_size, block_size, 0, 0, context, MAX(1, local_K_rows), info)
call descinit(descb, na, 1, block_size, block_size, 0, 0, context, MAX(1, local_B_rows), info)
! Allocate local work arrays
call pdgels("N", na, na, 1, local_K, 1, 1, desca, local_B, 1, 1, DESCB, work_query, -1, info)
lwork = INT(work_query(1))
allocate(work(lwork))
! copy data
local_B = 0.0d0
if (local_B_cols .ne. 0) then
do local_i = 1, local_B_rows
call l2g(local_i, local_rank_row, ranks_rows, block_size, global_i)
local_B(local_i, 1) = y(global_i)
enddo
end if
! Solver
call pdgels("N", na, na, 1, local_K, 1, 1, desca, local_B, 1, 1, DESCB, work, lwork, info)
! Copy LAPACK output
alphas = 0.0d0
if (local_B_cols .ne. 0) then
do local_i = 1, local_B_rows
call l2g(local_i, local_rank_row, ranks_rows, block_size, global_i)
alphas(global_i) = local_B(local_i, 1)
enddo
endif
call DGSUM2D(context, "All", "1-tree", na, 1, alphas, 1, -1, -1)
! Save alphas to file
if (local_id .eq. 0) then
open(unit = 9, file = "alphas_mpi.fout", form="formatted")
write(9,*) alphas(:)
close(9)
end if
! Tear down MPI
call blacs_exit(0)
! Clean up
deallocate(work)
deallocate(local_B)
deallocate(Q)
deallocate(local_K)
deallocate(Y)
deallocate(alphas)
end program qml_driver
! convert local index to global index in block-cyclic distribution
subroutine l2g(il,p,np,nb,i)
implicit none
integer :: il ! local array index, input
integer :: p ! processor array index, input
integer :: np ! processor array dimension, input
integer :: nb ! block size, input
integer :: i ! global array index, output
integer :: ilm1
ilm1 = il-1
i = (((ilm1/nb) * np) + p)*nb + mod(ilm1,nb) + 1
return
end subroutine l2g
================================================
FILE: qml/fchl/__init__.py
================================================
# MIT License
#
# Copyright (c) 2017 Anders S. Christensen, Felix A. Faber
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
from .fchl_representations import *
from .fchl_scalar_kernels import *
from .fchl_force_kernels import *
from .fchl_electric_field_kernels import *
================================================
FILE: qml/fchl/fchl_electric_field_kernels.py
================================================
# MIT License
#
# Copyright (c) 2017-2018 Felix Faber and Anders Steen Christensen
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
from __future__ import absolute_import
import numpy as np
import copy
from .ffchl_module import fget_ef_gaussian_process_kernels_fchl
from .ffchl_module import fget_ef_atomic_local_kernels_fchl
from .ffchl_module import fget_ef_atomic_local_gradient_kernels_fchl
from .fchl_kernel_functions import get_kernel_parameters
from qml.utils.alchemy import get_alchemy
# def get_local_kernels_ef(A, B, verbose=False, df=0.01, ef_scaling=0.01,\
# two_body_scaling=np.sqrt(8), three_body_scaling=1.6,
# two_body_width=0.2, three_body_width=np.pi,
# 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,
# kernel="gaussian", kernel_args=None):
# """ Calculates the Gaussian kernel matrix K, where :math:`K_{ij}`:
#
# :math:`K_{ij} = \\exp \\big( -\\frac{\\|A_i - B_j\\|_2^2}{2\sigma^2} \\big)`
#
# Where :math:`A_{i}` and :math:`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.
#
# :param A: Array of FCHL representation - shape=(N, maxsize, 5, maxneighbors).
# :type A: numpy array
# :param B: Array of FCHL representation - shape=(M, maxsize, 5, maxneighbors).
# :type B: numpy array
#
# :param two_body_scaling: Weight for 2-body terms.
# :type two_body_scaling: float
# :param three_body_scaling: Weight for 3-body terms.
# :type three_body_scaling: float
#
# :param two_body_width: Gaussian width for 2-body terms
# :type two_body_width: float
# :param three_body_width: Gaussian width for 3-body terms.
# :type three_body_width: float
#
# :param two_body_power: Powerlaw for :math:`r^{-n}` 2-body terms.
# :type two_body_power: float
# :param three_body_power: Powerlaw for Axilrod-Teller-Muto 3-body term
# :type three_body_power: float
#
# :param cut_start: The fraction of the cut-off radius at which cut-off damping start.
# :type cut_start: float
# :param cut_distance: Cut-off radius. (default=5 angstrom)
# :type cut_distance: float
#
# :param fourier_order: 3-body Fourier-expansion truncation order.
# :type fourier_order: integer
# :param alchemy: Type of alchemical interpolation ``"periodic-table"`` or ``"off"`` are possible options. Disabling alchemical interpolation can yield dramatic speedups.
# :type alchemy: string
#
# :param alchemy_period_width: Gaussian width along periods (columns) in the periodic table.
# :type alchemy_period_width: float
# :param alchemy_group_width: Gaussian width along groups (rows) in the periodic table.
# :type alchemy_group_width: float
#
# :return: Array of FCHL kernel matrices matrix - shape=(n_sigmas, N, M),
# :rtype: numpy array
# """
#
# atoms_max = A.shape[1]
# neighbors_max = A.shape[3]
#
# assert B.shape[1] == atoms_max, "ERROR: Check FCHL representation sizes! code = 2"
# assert B.shape[3] == neighbors_max, "ERROR: Check FCHL representation sizes! code = 3"
#
#
# nm1 = A.shape[0]
# nm2 = B.shape[0]
#
# N1 = np.zeros((nm1),dtype=np.int32)
# N2 = np.zeros((nm2),dtype=np.int32)
#
# for a in range(nm1):
# N1[a] = len(np.where(A[a,:,1,0] > 0.0001)[0])
#
# for a in range(nm2):
# N2[a] = len(np.where(B[a,:,1,0] > 0.0001)[0])
#
# neighbors1 = np.zeros((nm1, atoms_max), dtype=np.int32)
# neighbors2 = np.zeros((nm2, atoms_max), dtype=np.int32)
#
# for a, representation in enumerate(A):
# ni = N1[a]
# for i, x in enumerate(representation[:ni]):
# neighbors1[a,i] = len(np.where(x[0]< cut_distance)[0])
#
# for a, representation in enumerate(B):
# ni = N2[a]
# for i, x in enumerate(representation[:ni]):
# neighbors2[a,i] = len(np.where(x[0]< cut_distance)[0])
#
# doalchemy, pd = get_alchemy(alchemy, emax=100, r_width=alchemy_group_width, c_width=alchemy_period_width)
#
# kernel_idx, kernel_parameters, n_kernels = get_kernel_parameters(kernel, kernel_args)
#
# return fget_kernels_fchl_ef(A, B, N1, N2, neighbors1, neighbors2, nm1, nm2, n_kernels, \
# three_body_width, two_body_width, cut_start, cut_distance, fourier_order, pd, two_body_scaling,
# three_body_scaling, doalchemy, two_body_power, three_body_power, ef_scaling, df, kernel_idx, kernel_parameters)
def get_atomic_local_electric_field_gradient_kernels(A, B, verbose=False, df=0.01, ef_scaling=0.01,\
two_body_scaling=np.sqrt(8), three_body_scaling=1.6,
two_body_width=0.2, three_body_width=np.pi,
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,
kernel="gaussian", kernel_args=None):
""" Calculates the Gaussian kernel matrix K, where :math:`K_{ij}`:
:math:`K_{ij} = \\exp \\big( -\\frac{\\|A_i - B_j\\|_2^2}{2\sigma^2} \\big)`
Where :math:`A_{i}` and :math:`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.
:param A: Array of FCHL representation - shape=(N, maxsize, 5, maxneighbors).
:type A: numpy array
:param B: Array of FCHL representation - shape=(M, maxsize, 5, maxneighbors).
:type B: numpy array
:param two_body_scaling: Weight for 2-body terms.
:type two_body_scaling: float
:param three_body_scaling: Weight for 3-body terms.
:type three_body_scaling: float
:param two_body_width: Gaussian width for 2-body terms
:type two_body_width: float
:param three_body_width: Gaussian width for 3-body terms.
:type three_body_width: float
:param two_body_power: Powerlaw for :math:`r^{-n}` 2-body terms.
:type two_body_power: float
:param three_body_power: Powerlaw for Axilrod-Teller-Muto 3-body term
:type three_body_power: float
:param cut_start: The fraction of the cut-off radius at which cut-off damping start.
:type cut_start: float
:param cut_distance: Cut-off radius. (default=5 angstrom)
:type cut_distance: float
:param fourier_order: 3-body Fourier-expansion truncation order.
:type fourier_order: integer
:param alchemy: Type of alchemical interpolation ``"periodic-table"`` or ``"off"`` are possible options. Disabling alchemical interpolation can yield dramatic speedups.
:type alchemy: string
:param alchemy_period_width: Gaussian width along periods (columns) in the periodic table.
:type alchemy_period_width: float
:param alchemy_group_width: Gaussian width along groups (rows) in the periodic table.
:type alchemy_group_width: float
:return: Array of FCHL kernel matrices matrix - shape=(n_sigmas, N, M),
:rtype: numpy array
"""
atoms_max = A.shape[1]
neighbors_max = A.shape[3]
# assert B.shape[1] == atoms_max, "ERROR: Check FCHL representation sizes! code = 2"
# assert B.shape[3] == neighbors_max, "ERROR: Check FCHL representation sizes! code = 3"
nm1 = A.shape[0]
nm2 = B.shape[0]
N1 = np.zeros((nm1),dtype=np.int32)
N2 = np.zeros((nm2),dtype=np.int32)
for a in range(nm1):
N1[a] = len(np.where(A[a,:,1,0] > 0.0001)[0])
for a in range(nm2):
N2[a] = len(np.where(B[a,:,1,0] > 0.0001)[0])
neighbors1 = np.zeros((nm1, atoms_max), dtype=np.int32)
neighbors2 = np.zeros((nm2, atoms_max), dtype=np.int32)
for a, representation in enumerate(A):
ni = N1[a]
for i, x in enumerate(representation[:ni]):
neighbors1[a,i] = len(np.where(x[0]< cut_distance)[0])
for a, representation in enumerate(B):
ni = N2[a]
for i, x in enumerate(representation[:ni]):
neighbors2[a,i] = len(np.where(x[0]< cut_distance)[0])
doalchemy, pd = get_alchemy(alchemy, emax=100, r_width=alchemy_group_width, c_width=alchemy_period_width)
kernel_idx, kernel_parameters, n_kernels = get_kernel_parameters(kernel, kernel_args)
na1 = np.sum(N1)
return fget_ef_atomic_local_gradient_kernels_fchl(A, B, verbose, N1, N2, neighbors1, neighbors2, nm1, nm2, na1, n_kernels, \
three_body_width, two_body_width, cut_start, cut_distance, fourier_order, pd, two_body_scaling,
three_body_scaling, doalchemy, two_body_power, three_body_power, ef_scaling, df, kernel_idx, kernel_parameters)
def get_gaussian_process_electric_field_kernels(A, B, verbose=False, fields=None, df=0.01, ef_scaling=0.01,
two_body_scaling=np.sqrt(8), three_body_scaling=1.6,
two_body_width=0.2, three_body_width=np.pi,
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,
kernel="gaussian", kernel_args=None):
""" Calculates the Gaussian kernel matrix K, where :math:`K_{ij}`:
:math:`K_{ij} = \\exp \\big( -\\frac{\\|A_i - B_j\\|_2^2}{2\sigma^2} \\big)`
Where :math:`A_{i}` and :math:`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.
:param A: Array of FCHL representation - shape=(N, maxsize, 5, maxneighbors).
:type A: numpy array
:param B: Array of FCHL representation - shape=(M, maxsize, 5, maxneighbors).
:type B: numpy array
:param two_body_scaling: Weight for 2-body terms.
:type two_body_scaling: float
:param three_body_scaling: Weight for 3-body terms.
:type three_body_scaling: float
:param two_body_width: Gaussian width for 2-body terms
:type two_body_width: float
:param three_body_width: Gaussian width for 3-body terms.
:type three_body_width: float
:param two_body_power: Powerlaw for :math:`r^{-n}` 2-body terms.
:type two_body_power: float
:param three_body_power: Powerlaw for Axilrod-Teller-Muto 3-body term
:type three_body_power: float
:param cut_start: The fraction of the cut-off radius at which cut-off damping start.
:type cut_start: float
:param cut_distance: Cut-off radius. (default=5 angstrom)
:type cut_distance: float
:param fourier_order: 3-body Fourier-expansion truncation order.
:type fourier_order: integer
:param alchemy: Type of alchemical interpolation ``"periodic-table"`` or ``"off"`` are possible options. Disabling alchemical interpolation can yield dramatic speedups.
:type alchemy: string
:param alchemy_period_width: Gaussian width along periods (columns) in the periodic table.
:type alchemy_period_width: float
:param alchemy_group_width: Gaussian width along groups (rows) in the periodic table.
:type alchemy_group_width: float
:return: Array of FCHL kernel matrices matrix - shape=(n_sigmas, N, M),
:rtype: numpy array
"""
atoms_max = A.shape[1]
neighbors_max = A.shape[3]
assert B.shape[1] == atoms_max, "ERROR: Check FCHL representation sizes! code = 2"
assert B.shape[3] == neighbors_max, "ERROR: Check FCHL representation sizes! code = 3"
nm1 = A.shape[0]
nm2 = B.shape[0]
N1 = np.zeros((nm1),dtype=np.int32)
N2 = np.zeros((nm2),dtype=np.int32)
for a in range(nm1):
N1[a] = len(np.where(A[a,:,1,0] > 0.0001)[0])
for a in range(nm2):
N2[a] = len(np.where(B[a,:,1,0] > 0.0001)[0])
neighbors1 = np.zeros((nm1, atoms_max), dtype=np.int32)
neighbors2 = np.zeros((nm2, atoms_max), dtype=np.int32)
for a, representation in enumerate(A):
ni = N1[a]
for i, x in enumerate(representation[:ni]):
neighbors1[a,i] = len(np.where(x[0]< cut_distance)[0])
for a, representation in enumerate(B):
ni = N2[a]
for i, x in enumerate(representation[:ni]):
neighbors2[a,i] = len(np.where(x[0]< cut_distance)[0])
doalchemy, pd = get_alchemy(alchemy, emax=100, r_width=alchemy_group_width, c_width=alchemy_period_width)
kernel_idx, kernel_parameters, n_kernels = get_kernel_parameters(kernel, kernel_args)
F1 = np.zeros((nm1,3))
F2 = np.zeros((nm2,3))
if (fields is not None):
F1 = np.array(fields[0])
F2 = np.array(fields[1])
return fget_ef_gaussian_process_kernels_fchl(A, B, verbose, F1, F2, N1, N2, neighbors1, neighbors2, nm1, nm2, n_kernels, \
three_body_width, two_body_width, cut_start, cut_distance, fourier_order, pd, two_body_scaling,
three_body_scaling, doalchemy, two_body_power, three_body_power, ef_scaling, df, kernel_idx, kernel_parameters)
def get_kernels_ef_field(A, B, fields=None, df=0.01, ef_scaling=0.01,\
two_body_scaling=np.sqrt(8), three_body_scaling=1.6,
two_body_width=0.2, three_body_width=np.pi,
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,
kernel="gaussian", kernel_args=None):
atoms_max = A.shape[1]
neighbors_max = A.shape[3]
assert B.shape[1] == atoms_max, "ERROR: Check FCHL representation sizes! code = 2"
assert B.shape[3] == neighbors_max, "ERROR: Check FCHL representation sizes! code = 3"
nm1 = A.shape[0]
nm2 = B.shape[0]
N1 = np.zeros((nm1),dtype=np.int32)
N2 = np.zeros((nm2),dtype=np.int32)
for a in range(nm1):
N1[a] = len(np.where(A[a,:,1,0] > 0.0001)[0])
for a in range(nm2):
N2[a] = len(np.where(B[a,:,1,0] > 0.0001)[0])
neighbors1 = np.zeros((nm1, atoms_max), dtype=np.int32)
neighbors2 = np.zeros((nm2, atoms_max), dtype=np.int32)
for a, representation in enumerate(A):
ni = N1[a]
for i, x in enumerate(representation[:ni]):
neighbors1[a,i] = len(np.where(x[0]< cut_distance)[0])
for a, representation in enumerate(B):
ni = N2[a]
for i, x in enumerate(representation[:ni]):
neighbors2[a,i] = len(np.where(x[0]< cut_distance)[0])
doalchemy, pd = get_alchemy(alchemy, emax=100, r_width=alchemy_group_width, c_width=alchemy_period_width)
kernel_idx, kernel_parameters, n_kernels = get_kernel_parameters(kernel, kernel_args)
F2 = np.zeros((nm2,3))
if (fields is not None):
F2 = np.array(fields)
na1 = np.sum(N1)
return fget_kernels_fchl_ef_field(A, B, F2, N1, N2, neighbors1, neighbors2, nm1, nm2, n_kernels, na1, \
three_body_width, two_body_width, cut_start, cut_distance, fourier_order, pd, two_body_scaling,
three_body_scaling, doalchemy, two_body_power, three_body_power, ef_scaling, kernel_idx, kernel_parameters)
#
# Non-functional kernel for polarizabilites - unsure why it won't work
#
# def get_local_kernels_pol(A, B, df=1e-5, ef_scaling=1.0,\
# two_body_scaling=np.sqrt(8), three_body_scaling=1.6,
# two_body_width=0.2, three_body_width=np.pi,
# 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,
# kernel="gaussian", kernel_args=None):
# """ Calculates the Gaussian kernel matrix K, where :math:`K_{ij}`:
#
# :math:`K_{ij} = \\exp \\big( -\\frac{\\|A_i - B_j\\|_2^2}{2\sigma^2} \\big)`
#
# Where :math:`A_{i}` and :math:`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.
#
# :param A: Array of FCHL representation - shape=(N, maxsize, 5, maxneighbors).
# :type A: numpy array
# :param B: Array of FCHL representation - shape=(M, maxsize, 5, maxneighbors).
# :type B: numpy array
#
# :param two_body_scaling: Weight for 2-body terms.
# :type two_body_scaling: float
# :param three_body_scaling: Weight for 3-body terms.
# :type three_body_scaling: float
#
# :param two_body_width: Gaussian width for 2-body terms
# :type two_body_width: float
# :param three_body_width: Gaussian width for 3-body terms.
# :type three_body_width: float
#
# :param two_body_power: Powerlaw for :math:`r^{-n}` 2-body terms.
# :type two_body_power: float
# :param three_body_power: Powerlaw for Axilrod-Teller-Muto 3-body term
# :type three_body_power: float
#
# :param cut_start: The fraction of the cut-off radius at which cut-off damping start.
# :type cut_start: float
# :param cut_distance: Cut-off radius. (default=5 angstrom)
# :type cut_distance: float
#
# :param fourier_order: 3-body Fourier-expansion truncation order.
# :type fourier_order: integer
# :param alchemy: Type of alchemical interpolation ``"periodic-table"`` or ``"off"`` are possible options. Disabling alchemical interpolation can yield dramatic speedups.
# :type alchemy: string
#
# :param alchemy_period_width: Gaussian width along periods (columns) in the periodic table.
# :type alchemy_period_width: float
# :param alchemy_group_width: Gaussian width along groups (rows) in the periodic table.
# :type alchemy_group_width: float
#
# :return: Array of FCHL kernel matrices matrix - shape=(n_sigmas, N, M),
# :rtype: numpy array
# """
#
# atoms_max = A.shape[1]
# neighbors_max = A.shape[3]
#
# assert B.shape[1] == atoms_max, "ERROR: Check FCHL representation sizes! code = 2"
# assert B.shape[3] == neighbors_max, "ERROR: Check FCHL representation sizes! code = 3"
#
#
# nm1 = A.shape[0]
# nm2 = B.shape[0]
#
# N1 = np.zeros((nm1),dtype=np.int32)
# N2 = np.zeros((nm2),dtype=np.int32)
#
# for a in range(nm1):
# N1[a] = len(np.where(A[a,:,1,0] > 0.0001)[0])
#
# for a in range(nm2):
# N2[a] = len(np.where(B[a,:,1,0] > 0.0001)[0])
#
# neighbors1 = np.zeros((nm1, atoms_max), dtype=np.int32)
# neighbors2 = np.zeros((nm2, atoms_max), dtype=np.int32)
#
# for a, representation in enumerate(A):
# ni = N1[a]
# for i, x in enumerate(representation[:ni]):
# neighbors1[a,i] = len(np.where(x[0]< cut_distance)[0])
#
# for a, representation in enumerate(B):
# ni = N2[a]
# for i, x in enumerate(representation[:ni]):
# neighbors2[a,i] = len(np.where(x[0]< cut_distance)[0])
#
# doalchemy, pd = get_alchemy(alchemy, emax=100, r_width=alchemy_group_width, c_width=alchemy_period_width)
#
# kernel_idx, kernel_parameters, n_kernels = get_kernel_parameters(kernel, kernel_args)
#
# na1 = np.sum(N1)
#
# return fget_kernels_fchl_ef_2ndderiv(A, B, N1, N2, neighbors1, neighbors2, nm1, nm2, na1, n_kernels, \
# three_body_width, two_body_width, cut_start, cut_distance, fourier_order, pd, two_body_scaling,
# three_body_scaling, doalchemy, two_body_power, three_body_power, ef_scaling, df, kernel_idx, kernel_parameters)
#
================================================
FILE: qml/fchl/fchl_force_kernels.py
================================================
# MIT License
#
# Copyright (c) 2017-2018 Felix Faber and Anders Steen Christensen
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
from __future__ import absolute_import
import numpy as np
import copy
from .ffchl_module import fget_gaussian_process_kernels_fchl
from .ffchl_module import fget_local_gradient_kernels_fchl
from .ffchl_module import fget_local_hessian_kernels_fchl
from .ffchl_module import fget_local_symmetric_hessian_kernels_fchl
from .ffchl_module import fget_force_alphas_fchl
from .ffchl_module import fget_atomic_local_gradient_kernels_fchl
from .ffchl_module import fget_atomic_local_gradient_5point_kernels_fchl
from .fchl_kernel_functions import get_kernel_parameters
from qml.utils.alchemy import get_alchemy
def get_gaussian_process_kernels(A, B, verbose=False, dx=0.005, \
two_body_scaling=np.sqrt(8), three_body_scaling=1.6,
two_body_width=0.2, three_body_width=np.pi,
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,
kernel="gaussian", kernel_args=None):
nm1 = A.shape[0]
nm2 = B.shape[0]
assert B.shape[1] == 3
assert B.shape[2] == 2
assert B.shape[5] == 5
assert A.shape[2] == 5
# assert B.shape[2] == 2
# assert B.shape[5] == 5
atoms_max = B.shape[4]
assert A.shape[1] == atoms_max
assert B.shape[3] == atoms_max
neighbors_max = B.shape[6]
assert A.shape[3] == neighbors_max
N1 = np.zeros((nm1),dtype=np.int32)
for a in range(nm1):
N1[a] = len(np.where(A[a,:,1,0] > 0.0001)[0])
neighbors1 = np.zeros((nm1, atoms_max), dtype=np.int32)
for a, representation in enumerate(A):
ni = N1[a]
for i, x in enumerate(representation[:ni]):
neighbors1[a,i] = len(np.where(x[0]< cut_distance)[0])
N2 = np.zeros((nm2),dtype=np.int32)
for a in range(nm2):
N2[a] = len(np.where(B[a,0,0,0,:,1,0] > 0.0001)[0])
neighbors2 = np.zeros((nm2, 3, 2, atoms_max, atoms_max), dtype=np.int32)
for m in range(nm2):
ni = N2[m]
for xyz in range(3):
for pm in range(2):
for i in range(ni):
for a, x in enumerate(B[m,xyz,pm,i,:ni]):
neighbors2[m,xyz,pm,i,a] = len(np.where(x[0]< cut_distance)[0])
doalchemy, pd = get_alchemy(alchemy, emax=100, r_width=alchemy_group_width, c_width=alchemy_period_width)
naq2 = np.sum(N2) * 3
kernel_idx, kernel_parameters, nsigmas = get_kernel_parameters(kernel, kernel_args)
return fget_gaussian_process_kernels_fchl(A, B, verbose, N1, N2, neighbors1, neighbors2, \
nm1, nm2, naq2, nsigmas, three_body_width, two_body_width, cut_start, cut_distance, \
fourier_order, pd, two_body_scaling, three_body_scaling, doalchemy, two_body_power, three_body_power, dx, kernel_idx, kernel_parameters)
def get_local_gradient_kernels(A, B, verbose=False, dx=0.005,
two_body_scaling=np.sqrt(8), three_body_scaling=1.6,
two_body_width=0.2, three_body_width=np.pi,
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,
kernel="gaussian", kernel_args=None):
nm1 = A.shape[0]
nm2 = B.shape[0]
assert B.shape[1] == 3
assert B.shape[2] == 2
assert B.shape[5] == 5
assert A.shape[2] == 5
# assert B.shape[2] == 2
# assert B.shape[5] == 5
atoms_max = B.shape[4]
assert A.shape[1] == atoms_max
assert B.shape[3] == atoms_max
neighbors_max = B.shape[6]
assert A.shape[3] == neighbors_max
N1 = np.zeros((nm1),dtype=np.int32)
for a in range(nm1):
N1[a] = len(np.where(A[a,:,1,0] > 0.0001)[0])
neighbors1 = np.zeros((nm1, atoms_max), dtype=np.int32)
for a, representation in enumerate(A):
ni = N1[a]
for i, x in enumerate(representation[:ni]):
neighbors1[a,i] = len(np.where(x[0]< cut_distance)[0])
N2 = np.zeros((nm2),dtype=np.int32)
for a in range(nm2):
N2[a] = len(np.where(B[a,0,0,0,:,1,0] > 0.0001)[0])
neighbors2 = np.zeros((nm2, 3, 2, atoms_max, atoms_max), dtype=np.int32)
for m in range(nm2):
ni = N2[m]
for xyz in range(3):
for pm in range(2):
for i in range(ni):
for a, x in enumerate(B[m,xyz,pm,i,:ni]):
neighbors2[m,xyz,pm,i,a] = len(np.where(x[0]< cut_distance)[0])
doalchemy, pd = get_alchemy(alchemy, emax=100, r_width=alchemy_group_width, c_width=alchemy_period_width)
kernel_idx, kernel_parameters, nsigmas = get_kernel_parameters(kernel, kernel_args)
naq2 = np.sum(N2) * 3
return fget_local_gradient_kernels_fchl(A, B, verbose, N1, N2, neighbors1, neighbors2, \
nm1, nm2, naq2, nsigmas, three_body_width, two_body_width, cut_start, cut_distance, \
fourier_order, pd, two_body_scaling, three_body_scaling, doalchemy, two_body_power, three_body_power, dx, kernel_idx, kernel_parameters)
def get_local_hessian_kernels(A, B, verbose=False, dx=0.005,
two_body_scaling=np.sqrt(8), three_body_scaling=1.6,
two_body_width=0.2, three_body_width=np.pi,
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,
kernel="gaussian", kernel_args=None):
nm1 = A.shape[0]
nm2 = B.shape[0]
assert A.shape[1] == 3
assert A.shape[2] == 2
assert A.shape[5] == 5
assert B.shape[1] == 3
assert B.shape[2] == 2
assert B.shape[5] == 5
atoms_max = A.shape[4]
assert A.shape[3] == atoms_max
assert B.shape[3] == atoms_max
neighbors_max = A.shape[6]
assert B.shape[6] == neighbors_max
N1 = np.zeros((nm1),dtype=np.int32)
N2 = np.zeros((nm2),dtype=np.int32)
for a in range(nm1):
N1[a] = len(np.where(A[a,0,0,0,:,1,0] > 0.0001)[0])
for a in range(nm2):
N2[a] = len(np.where(B[a,0,0,0,:,1,0] > 0.0001)[0])
neighbors1 = np.zeros((nm1, 3, 2, atoms_max, atoms_max), dtype=np.int32)
neighbors2 = np.zeros((nm2, 3, 2, atoms_max, atoms_max), dtype=np.int32)
for m in range(nm1):
ni = N1[m]
for xyz in range(3):
for pm in range(2):
for i in range(ni):
for a, x in enumerate(A[m,xyz,pm,i,:ni]):
neighbors1[m,xyz,pm,i,a] = len(np.where(x[0]< cut_distance)[0])
for m in range(nm2):
ni = N2[m]
for xyz in range(3):
for pm in range(2):
for i in range(ni):
for a, x in enumerate(B[m,xyz,pm,i,:ni]):
neighbors2[m,xyz,pm,i,a] = len(np.where(x[0]< cut_distance)[0])
doalchemy, pd = get_alchemy(alchemy, emax=100, r_width=alchemy_group_width, c_width=alchemy_period_width)
kernel_idx, kernel_parameters, nsigmas = get_kernel_parameters(kernel, kernel_args)
naq1 = np.sum(N1) * 3
naq2 = np.sum(N2) * 3
# print naq1, naq2, nsigmas
return fget_local_hessian_kernels_fchl(A, B, verbose, N1, N2, neighbors1, neighbors2, \
nm1, nm2, naq1, naq2, nsigmas, three_body_width, two_body_width, cut_start, cut_distance, \
fourier_order, pd, two_body_scaling, three_body_scaling, doalchemy, two_body_power, three_body_power, dx, kernel_idx, kernel_parameters)
def get_local_symmetric_hessian_kernels(A, verbose=False, dx=0.005,
two_body_scaling=np.sqrt(8), three_body_scaling=1.6,
two_body_width=0.2, three_body_width=np.pi,
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,
kernel="gaussian", kernel_args=None):
nm1 = A.shape[0]
assert A.shape[1] == 3
assert A.shape[2] == 2
assert A.shape[5] == 5
atoms_max = A.shape[4]
assert A.shape[3] == atoms_max
neighbors_max = A.shape[6]
N1 = np.zeros((nm1),dtype=np.int32)
for a in range(nm1):
N1[a] = len(np.where(A[a,0,0,0,:,1,0] > 0.0001)[0])
neighbors1 = np.zeros((nm1, 3, 2, atoms_max, atoms_max), dtype=np.int32)
for m in range(nm1):
ni = N1[m]
for xyz in range(3):
for pm in range(2):
for i in range(ni):
for a, x in enumerate(A[m,xyz,pm,i,:ni]):
neighbors1[m,xyz,pm,i,a] = len(np.where(x[0]< cut_distance)[0])
doalchemy, pd = get_alchemy(alchemy, emax=100, r_width=alchemy_group_width, c_width=alchemy_period_width)
kernel_idx, kernel_parameters, nsigmas = get_kernel_parameters(kernel, kernel_args)
naq1 = np.sum(N1) * 3
return fget_local_symmetric_hessian_kernels_fchl(A, verbose, N1, neighbors1, nm1, naq1, nsigmas, \
three_body_width, two_body_width, cut_start, cut_distance, \
fourier_order, pd, two_body_scaling, three_body_scaling, doalchemy, two_body_power, three_body_power, dx, kernel_idx, kernel_parameters)
def get_force_alphas(A, B, F, verbose=False, energy=None, dx=0.005, regularization=1e-7,
two_body_scaling=np.sqrt(8), three_body_scaling=1.6,
two_body_width=0.2, three_body_width=np.pi,
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,
kernel="gaussian", kernel_args=None):
nm1 = A.shape[0]
nm2 = B.shape[0]
assert B.shape[1] == 3
assert B.shape[2] == 2
assert B.shape[5] == 5
assert A.shape[2] == 5
# assert B.shape[2] == 2
# assert B.shape[5] == 5
atoms_max = B.shape[4]
assert A.shape[1] == atoms_max
assert B.shape[3] == atoms_max
neighbors_max = B.shape[6]
assert A.shape[3] == neighbors_max
N1 = np.zeros((nm1),dtype=np.int32)
for a in range(nm1):
N1[a] = len(np.where(A[a,:,1,0] > 0.0001)[0])
neighbors1 = np.zeros((nm1, atoms_max), dtype=np.int32)
for a, representation in enumerate(A):
ni = N1[a]
for i, x in enumerate(representation[:ni]):
neighbors1[a,i] = len(np.where(x[0]< cut_distance)[0])
N2 = np.zeros((nm2),dtype=np.int32)
for a in range(nm2):
N2[a] = len(np.where(B[a,0,0,0,:,1,0] > 0.0001)[0])
neighbors2 = np.zeros((nm2, 3, 2, atoms_max, atoms_max), dtype=np.int32)
for m in range(nm2):
ni = N2[m]
for xyz in range(3):
for pm in range(2):
for i in range(ni):
for a, x in enumerate(B[m,xyz,pm,i,:ni]):
neighbors2[m,xyz,pm,i,a] = len(np.where(x[0]< cut_distance)[0])
doalchemy, pd = get_alchemy(alchemy, emax=100, r_width=alchemy_group_width, c_width=alchemy_period_width)
kernel_idx, kernel_parameters, nsigmas = get_kernel_parameters(kernel, kernel_args)
na1 = np.sum(N1)
naq2 = np.sum(N2) * 3
E = np.zeros((nm1))
if energy is not None:
E = energy
return fget_force_alphas_fchl(A, B, verbose, F, E, N1, N2, neighbors1, neighbors2, \
nm1, nm2, na1, nsigmas, three_body_width, two_body_width, cut_start, cut_distance, \
fourier_order, pd, two_body_scaling, three_body_scaling, doalchemy, two_body_power,
three_body_power, dx, kernel_idx, kernel_parameters, regularization)
def get_atomic_local_gradient_kernels(A, B, verbose=False, dx = 0.005,
two_body_scaling=np.sqrt(8), three_body_scaling=1.6,
two_body_width=0.2, three_body_width=np.pi,
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,
kernel="gaussian", kernel_args=None):
nm1 = A.shape[0]
nm2 = B.shape[0]
assert B.shape[1] == 3
assert B.shape[2] == 2
assert B.shape[5] == 5
assert A.shape[2] == 5
atoms_max = B.shape[4]
assert A.shape[1] == atoms_max
assert B.shape[3] == atoms_max
neighbors_max = B.shape[6]
assert A.shape[3] == neighbors_max
N1 = np.zeros((nm1),dtype=np.int32)
for a in range(nm1):
N1[a] = len(np.where(A[a,:,1,0] > 0.0001)[0])
neighbors1 = np.zeros((nm1, atoms_max), dtype=np.int32)
for a, representation in enumerate(A):
ni = N1[a]
for i, x in enumerate(representation[:ni]):
neighbors1[a,i] = len(np.where(x[0]< cut_distance)[0])
N2 = np.zeros((nm2),dtype=np.int32)
for a in range(nm2):
N2[a] = len(np.where(B[a,0,0,0,:,1,0] > 0.0001)[0])
neighbors2 = np.zeros((nm2, 3, 2, atoms_max, atoms_max), dtype=np.int32)
for m in range(nm2):
ni = N2[m]
for xyz in range(3):
for pm in range(2):
for i in range(ni):
for a, x in enumerate(B[m,xyz,pm,i,:ni]):
neighbors2[m,xyz,pm,i,a] = len(np.where(x[0]< cut_distance)[0])
doalchemy, pd = get_alchemy(alchemy, emax=100, r_width=alchemy_group_width, c_width=alchemy_period_width)
kernel_idx, kernel_parameters, nsigmas = get_kernel_parameters(kernel, kernel_args)
na1 = np.sum(N1)
naq2 = np.sum(N2) * 3
return fget_atomic_local_gradient_kernels_fchl(A, B, verbose, N1, N2, neighbors1, neighbors2, \
nm1, nm2, na1, naq2, nsigmas, three_body_width, two_body_width, cut_start, cut_distance, \
fourier_order, pd, two_body_scaling, three_body_scaling, doalchemy, two_body_power,
three_body_power, dx, kernel_idx, kernel_parameters)
def get_atomic_local_gradient_5point_kernels(A, B, verbose=False, dx = 0.005,
two_body_scaling=np.sqrt(8), three_body_scaling=1.6,
two_body_width=0.2, three_body_width=np.pi,
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,
kernel="gaussian", kernel_args=None):
nm1 = A.shape[0]
nm2 = B.shape[0]
assert B.shape[1] == 3
assert B.shape[2] == 5
assert B.shape[5] == 5
assert A.shape[2] == 5
atoms_max = B.shape[4]
assert A.shape[1] == atoms_max
assert B.shape[3] == atoms_max
neighbors_max = B.shape[6]
assert A.shape[3] == neighbors_max
N1 = np.zeros((nm1),dtype=np.int32)
for a in range(nm1):
N1[a] = len(np.where(A[a,:,1,0] > 0.0001)[0])
neighbors1 = np.zeros((nm1, atoms_max), dtype=np.int32)
for a, representation in enumerate(A):
ni = N1[a]
for i, x in enumerate(representation[:ni]):
neighbors1[a,i] = len(np.where(x[0]< cut_distance)[0])
N2 = np.zeros((nm2),dtype=np.int32)
for a in range(nm2):
N2[a] = len(np.where(B[a,0,0,0,:,1,0] > 0.0001)[0])
neighbors2 = np.zeros((nm2, 3, 5, atoms_max, atoms_max), dtype=np.int32)
for m in range(nm2):
ni = N2[m]
for xyz in range(3):
for pm in range(5):
for i in range(ni):
for a, x in enumerate(B[m,xyz,pm,i,:ni]):
neighbors2[m,xyz,pm,i,a] = len(np.where(x[0]< cut_distance)[0])
doalchemy, pd = get_alchemy(alchemy, emax=100, r_width=alchemy_group_width, c_width=alchemy_period_width)
kernel_idx, kernel_parameters, nsigmas = get_kernel_parameters(kernel, kernel_args)
na1 = np.sum(N1)
naq2 = np.sum(N2) * 3
return fget_atomic_local_gradient_5point_kernels_fchl(A, B, verbose, N1, N2, neighbors1, neighbors2, \
nm1, nm2, na1, naq2, nsigmas, three_body_width, two_body_width, cut_start, cut_distance, \
fourier_order, pd, two_body_scaling, three_body_scaling, doalchemy, two_body_power,
three_body_power, dx, kernel_idx, kernel_parameters)
================================================
FILE: qml/fchl/fchl_kernel_functions.py
================================================
# MIT License
#
# Copyright (c) 2017 Anders Steen Christensen and Felix A. Faber
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
from __future__ import division
from __future__ import print_function
import numpy as np
from copy import copy
import scipy
from scipy.special import binom
from scipy.special import factorial
from .ffchl_module import ffchl_kernel_types as kt
def get_gaussian_parameters(tags):
if tags is None:
tags = {"sigma": [2.5],}
parameters = np.array(tags["sigma"])
for i in range(len(parameters)):
parameters[i] = -0.5 / (parameters[i])**2
np.resize(parameters, (1,len(tags["sigma"])))
n_kernels = len(tags["sigma"])
return kt.gaussian, parameters, n_kernels
def get_linear_parameters(tags):
if tags is None:
tags = {"c": [0.0],}
parameters = np.array(tags["c"])
np.resize(parameters, (1,len(tags["c"])))
n_kernels = len(tags["c"])
return kt.linear, parameters, n_kernels
def get_polynomial_parameters(tags):
if tags is None:
tags = {
"alpha": [1.0],
"c": [0.0],
"d": [1.0]
}
parameters = np.array([
tags["alpha"],
tags["c"],
tags["d"]
]).T
assert len(tags["alpha"]) == len(tags["c"])
assert len(tags["alpha"]) == len(tags["d"])
n_kernels = len(tags["alpha"])
return kt.polynomial, parameters, n_kernels
def get_sigmoid_parameters(tags):
if tags is None:
tags = {
"alpha": [1.0],
"c": [0.0],
}
parameters = np.array([
tags["alpha"],
tags["c"],
]).T
assert len(tags["alpha"]) == len(tags["c"])
n_kernels = len(tags["alpha"])
return kt.sigmoid, parameters, n_kernels
def get_multiquadratic_parameters(tags):
if tags is None:
tags = {
"c": [0.0],
}
parameters = np.array([
tags["c"],
]).T
np.resize(parameters, (1,len(tags["c"])))
n_kernels = len(tags["c"])
return kt.multiquadratic, parameters, n_kernels
def get_inverse_multiquadratic_parameters(tags):
if tags is None:
tags = {
"c": [0.0],
}
parameters = np.array([
tags["c"],
]).T
np.resize(parameters, (1,len(tags["c"])))
n_kernels = len(tags["c"])
return kt.inv_multiquadratic, parameters, n_kernels
def get_bessel_parameters(tags):
if tags is None:
tags = {
"sigma": [1.0],
"v": [1.0],
"n": [1.0]
}
parameters = np.array([
tags["sigma"],
tags["v"],
tags["n"]
]).T
assert len(tags["sigma"]) == len(tags["v"])
assert len(tags["sigma"]) == len(tags["n"])
n_kernels = len(tags["sigma"])
return kt.bessel, parameters, n_kernels
def get_l2_parameters(tags):
if tags is None:
tags = {
"alpha": [1.0],
"c": [0.0],
}
parameters = np.array([
tags["alpha"],
tags["c"],
]).T
assert len(tags["alpha"]) == len(tags["c"])
n_kernels = len(tags["alpha"])
return kt.l2, parameters, n_kernels
def get_matern_parameters(tags):
if tags is None:
tags = {
"sigma": [10.0],
"n": [2.0],
}
assert len(tags["sigma"]) == len(tags["n"])
n_kernels = len(tags["sigma"])
n_max = int(max(tags["n"])) + 1
parameters = np.zeros((2+n_max, n_kernels))
for i in range(n_kernels):
parameters[0,i] = tags["sigma"][i]
parameters[1,i] = tags["n"][i]
n = int(tags["n"][i])
for k in range(0, n+1):
parameters[2+k,i] = float(factorial(n + k) * binom(n, k))/ factorial(2*n)
parameters = parameters.T
return kt.matern, parameters, n_kernels
def get_cauchy_parameters(tags):
if tags is None:
tags = {
"sigma": [1.0],
}
parameters = np.array([
tags["sigma"],
]).T
np.resize(parameters, (1,len(tags["sigma"])))
n_kernels = len(tags["sigma"])
return kt.cauchy, parameters, n_kernels
def get_polynomial2_parameters(tags):
if tags is None:
tags = {
"coeff": [[1.0, 1.0, 1.0]],
}
parameters = np.zeros((10,len(tags["coeff"])))
for i, c in enumerate(tags["coeff"]):
for j, v in enumerate(c):
parameters[j,i] = v
n_kernels = len(tags["coeff"])
parameters = parameters.T
return kt.polynomial2, parameters, n_kernels
def get_kernel_parameters(name, tags):
parameters = None
idx = kt.gaussian
n_kernels = 1
if name == "gaussian":
idx, parameters, n_kernels = get_gaussian_parameters(tags)
elif name == "linear":
idx, parameters, n_kernels = get_linear_parameters(tags)
elif name == "polynomial":
idx, parameters, n_kernels = get_polynomial_parameters(tags)
elif name == "sigmoid":
idx, parameters, n_kernels = get_sigmoid_parameters(tags)
elif name == "multiquadratic":
idx, parameters, n_kernels = get_multiquadratic_parameters(tags)
elif name == "inverse-multiquadratic":
idx, parameters, n_kernels = get_inverse_multiquadratic_parameters(tags)
elif name == "bessel":
idx, parameters, n_kernels = get_bessel_parameters(tags)
elif name == "l2":
idx, parameters, n_kernels = get_l2_parameters(tags)
elif name == "matern":
idx, parameters, n_kernels = get_matern_parameters(tags)
elif name == "cauchy":
idx, parameters, n_kernels = get_cauchy_parameters(tags)
elif name == "polynomial2":
idx, parameters, n_kernels = get_polynomial2_parameters(tags)
else:
print("QML ERROR: Unsupported kernel specification,", name)
exit()
return idx, parameters, n_kernels
================================================
FILE: qml/fchl/fchl_representations.py
================================================
# MIT License
#
# Copyright (c) 2017-2018 Felix Faber and Anders Steen Christensen
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
from __future__ import print_function
import numpy as np
import copy
from qml.utils.alchemy import get_alchemy
from qml.utils import ELEMENT_NAME
def generate_representation(coordinates, nuclear_charges,
max_size=23, neighbors=23, cut_distance = 5.0, cell=None):
""" Generates a representation for the FCHL kernel module.
:param coordinates: Input coordinates.
:type coordinates: numpy array
:param nuclear_charges: List of nuclear charges.
:type nuclear_charges: numpy array
:param max_size: Max number of atoms in representation.
:type max_size: integer
:param neighbors: Max number of atoms within the cut-off around an atom. (For periodic systems)
:type neighbors: integer
:param cell: Unit cell vectors. The presence of this keyword argument will generate a periodic representation.
:type cell: numpy array
:param cut_distance: Spatial cut-off distance - must be the same as used in the kernel function call.
:type cut_distance: float
:return: FCHL representation, shape = (size,5,neighbors).
:rtype: numpy array
"""
size = max_size
if cell is None:
neighbors=size
L = len(coordinates)
coords = np.asarray(coordinates)
ocupationList = np.asarray(nuclear_charges)
M = np.zeros((size,5,neighbors))
if cell is not None:
coords = np.dot(coords,cell)
nExtend = (np.floor(cut_distance/np.linalg.norm(cell,2,axis = 0)) + 1).astype(int)
for i in range(-nExtend[0],nExtend[0] + 1):
for j in range(-nExtend[1],nExtend[1] + 1):
for k in range(-nExtend[2],nExtend[2] + 1):
if i == -nExtend[0] and j == -nExtend[1] and k == -nExtend[2]:
coordsExt = coords + i*cell[0,:] + j*cell[1,:] + k*cell[2,:]
ocupationListExt = copy.copy(ocupationList)
else:
ocupationListExt = np.append(ocupationListExt,ocupationList)
coordsExt = np.append(coordsExt,coords + i*cell[0,:] + j*cell[1,:] + k*cell[2,:],axis = 0)
else:
coordsExt = copy.copy(coords)
ocupationListExt = copy.copy(ocupationList)
M[:,0,:] = 1E+100
for i in range(L):
cD = - coords[i] + coordsExt[:]
ocExt = np.asarray(ocupationListExt)
D1 = np.sqrt(np.sum(cD**2, axis = 1))
args = np.argsort(D1)
D1 = D1[args]
ocExt = np.asarray([ocExt[l] for l in args])
cD = cD[args]
args = np.where(D1 < cut_distance)[0]
D1 = D1[args]
ocExt = np.asarray([ocExt[l] for l in args])
cD = cD[args]
M[i,0,: len(D1)] = D1
M[i,1,: len(D1)] = ocExt[:]
M[i,2:5,: len(D1)] = cD.T
return M
def generate_displaced_representations(coordinates, nuclear_charges,
max_size=23, neighbors=23, cut_distance = 5.0, cell=None, dx=0.005):
""" Generates displaced representations for the FCHL kernel module.
:param coordinates: Input coordinates.
:type coordinates: numpy array
:param nuclear_charges: List of nuclear charges.
:type nuclear_charges: numpy array
:param max_size: Max number of atoms in representation.
:type max_size: integer
:param neighbors: Max number of atoms within the cut-off around an atom. (For periodic systems)
:type neighbors: integer
:param cell: Unit cell vectors. The presence of this keyword argument will generate a periodic representation.
:type cell: numpy array
:param dx: Real-space displacement for numerical derivatives, in units of angstrom.
:type dx: float
:param cut_distance: Spatial cut-off distance - must be the same as used in the kernel function call.
:type cut_distance: float
:return: FCHL representation, shape = (size,5,neighbors).
:rtype: numpy array
"""
size = max_size
if cell is None:
neighbors=size
reps = np.zeros((3,2,size,size,5,neighbors))
compound_size = len(nuclear_charges)
for xyz in range(3):
for i in range(compound_size):
for idisp, disp in enumerate([-dx, dx]):
displaced_coordinates = copy.deepcopy(coordinates)
displaced_coordinates[i,xyz] += disp
rep = generate_representation(displaced_coordinates, nuclear_charges,
max_size=size, neighbors=neighbors, cut_distance=cut_distance, cell=cell)
reps[xyz,idisp,i,:,:,:] = rep[:,:,:]
return reps
def generate_displaced_representations_5point(coordinates, nuclear_charges,
max_size=23, neighbors=23, cut_distance = 5.0, cell=None, dx=0.005):
""" Generates displaced representations for the FCHL kernel module, using a 5-point stencil.
:param coordinates: Input coordinates.
:type coordinates: numpy array
:param nuclear_charges: List of nuclear charges.
:type nuclear_charges: numpy array
:param max_size: Max number of atoms in representation.
:type max_size: integer
:param neighbors: Max number of atoms within the cut-off around an atom. (For periodic systems)
:type neighbors: integer
:param cell: Unit cell vectors. The presence of this keyword argument will generate a periodic representation.
:type cell: numpy array
:param dx: Real-space displacement for numerical derivatives, in units of angstrom.
:type dx: float
:param cut_distance: Spatial cut-off distance - must be the same as used in the kernel function call.
:type cut_distance: float
:return: FCHL representation, shape = (size,5,neighbors).
:rtype: numpy array
"""
size = max_size
if cell is None:
neighbors=size
reps = np.zeros((3,5,size,size,5,neighbors))
compound_size = len(nuclear_charges)
for xyz in range(3):
for i in range(compound_size):
for idisp, disp in enumerate([-2*dx, -dx, 0.0, dx, 2*dx]):
displaced_coordinates = copy.deepcopy(coordinates)
displaced_coordinates[i,xyz] += disp
rep = generate_representation(displaced_coordinates, nuclear_charges,
max_size=size, neighbors=neighbors, cut_distance=cut_distance, cell=cell)
reps[xyz,idisp,i,:,:,:] = rep[:,:,:]
return reps
def generate_representation_electric_field(coordinates, nuclear_charges,
fictitious_charges="gasteiger", max_size=23, neighbors=23, cut_distance = 5.0):
""" Generates a representation for the FCHL kernel module, including fictitious partial charges.
For use with fist-order electric field-dependent properties, such as dipole moments and IR intensity.
Good choices are charges from e.g. a force field model or a QM charge model, e.g. Mulliken, etc.
:param coordinates: Input coordinates.
:type coordinates: numpy array
:param nuclear_charges: List of nuclear charges.
:type nuclear_charges: numpy array
:param partial_charges: Either list of fictitious partial charges, or a string representing the charge model from which these are to be calculated (the latter requires Open Babel with Pybel installed). Default option is "gasteiger". Please see the OpenBabel documentation for list of supported charges models.
:type partial_charges: numpy array or string.
:param max_size: Max number of atoms in representation.
:type max_size: integer
:param neighbors: Max number of atoms within the cut-off around an atom. (For periodic systems)
:type neighbors: integer
:param cell: Unit cell vectors. The presence of this keyword argument will generate a periodic representation.
:type cell: numpy array
:param cut_distance: Spatial cut-off distance - must be the same as used in the kernel function call.
:type cut_distance: float
:return: FCHL representation, shape = (size,5,neighbors).
:rtype: numpy array
"""
partial_charges = None
# If a list is given, assume these are the fictitious charges
if isinstance(fictitious_charges, (list,)) or \
isinstance(fictitious_charges, (np.ndarray,)):
assert(len(fictitious_charges) == len(nuclear_charges)), "Error: incorrect length of fictitious charge list"
partial_charges = fictitious_charges
# Otherwise, if a string is given, assume this is the name of a charge model
# in Open Babel//Pybel.
elif isinstance(fictitious_charges, (basestring,)):
# Dirty hack for now.
try:
import pybel
import openbabel
except ImportError:
print("QML ERROR: Could not generate fictitious charges because OpenBabel/Pybel was not found.")
exit()
temp_xyz = "%i\n\n" % len(nuclear_charges)
for i, nuc in enumerate(nuclear_charges):
temp_xyz += "%s %f %f %f\n" \
% (ELEMENT_NAME[nuc], coordinates[i][0], coordinates[i][1], coordinates[i][2])
mol = pybel.readstring("xyz", temp_xyz)
this_charge_model = openbabel.OBChargeModel.FindType(fictitious_charges)
this_charge_model.ComputeCharges(mol.OBMol)
partial_charges = [atom.partialcharge for atom in mol]
else:
print("QML ERROR: Unable to parse argument for fictitious charges", fictitious_charges)
exit()
size = max_size
neighbors=size
L = len(coordinates)
coords = np.asarray(coordinates)
ocupationList = np.asarray(nuclear_charges)
partial_charges = np.asarray(partial_charges)
M = np.zeros((size,6,neighbors))
coordsExt = copy.copy(coords)
partialExt = copy.copy(partial_charges)
ocupationListExt = copy.copy(ocupationList)
M[:,0,:] = 1E+100
for i in range(L):
cD = - coords[i] + coordsExt[:]
ocExt = np.asarray(ocupationListExt)
qExt = np.asarray(partialExt)
D1 = np.sqrt(np.sum(cD**2, axis = 1))
args = np.argsort(D1)
D1 = D1[args]
ocExt = np.asarray([ocExt[l] for l in args])
qExt = np.asarray([qExt[l] for l in args])
cD = cD[args]
args = np.where(D1 < cut_distance)[0]
D1 = D1[args]
ocExt = np.asarray([ocExt[l] for l in args])
qExt = np.asarray([qExt[l] for l in args])
cD = cD[args]
M[i,0,: len(D1)] = D1
M[i,1,: len(D1)] = ocExt[:]
M[i,2:5,: len(D1)] = cD.T
M[i,5,: len(D1)] = qExt[:]
return M
================================================
FILE: qml/fchl/fchl_scalar_kernels.py
================================================
# MIT License
#
# Copyright (c) 2017-2018 Felix Faber and Anders Steen Christensen
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
from __future__ import absolute_import
import numpy as np
import copy
from .ffchl_module import fget_kernels_fchl
from .ffchl_module import fget_symmetric_kernels_fchl
from .ffchl_module import fget_global_kernels_fchl
from .ffchl_module import fget_global_symmetric_kernels_fchl
from .ffchl_module import fget_atomic_kernels_fchl
from .ffchl_module import fget_atomic_symmetric_kernels_fchl
from .ffchl_module import fget_atomic_local_kernels_fchl
from .fchl_kernel_functions import get_kernel_parameters
from qml.utils.alchemy import get_alchemy
def get_local_kernels(A, B, verbose=False,\
two_body_scaling=np.sqrt(8), three_body_scaling=1.6,
two_body_width=0.2, three_body_width=np.pi,
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,
kernel="gaussian", kernel_args=None):
""" Calculates the Gaussian kernel matrix K, where :math:`K_{ij}`:
:math:`K_{ij} = \\exp \\big( -\\frac{\\|A_i - B_j\\|_2^2}{2\sigma^2} \\big)`
Where :math:`A_{i}` and :math:`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.
:param A: Array of FCHL representation - shape=(N, maxsize, 5, maxneighbors).
:type A: numpy array
:param B: Array of FCHL representation - shape=(M, maxsize, 5, maxneighbors).
:type B: numpy array
:param two_body_scaling: Weight for 2-body terms.
:type two_body_scaling: float
:param three_body_scaling: Weight for 3-body terms.
:type three_body_scaling: float
:param two_body_width: Gaussian width for 2-body terms
:type two_body_width: float
:param three_body_width: Gaussian width for 3-body terms.
:type three_body_width: float
:param two_body_power: Powerlaw for :math:`r^{-n}` 2-body terms.
:type two_body_power: float
:param three_body_power: Powerlaw for Axilrod-Teller-Muto 3-body term
:type three_body_power: float
:param cut_start: The fraction of the cut-off radius at which cut-off damping start.
:type cut_start: float
:param cut_distance: Cut-off radius. (default=5 angstrom)
:type cut_distance: float
:param fourier_order: 3-body Fourier-expansion truncation order.
:type fourier_order: integer
:param alchemy: Type of alchemical interpolation ``"periodic-table"`` or ``"off"`` are possible options. Disabling alchemical interpolation can yield dramatic speedups.
:type alchemy: string
:param alchemy_period_width: Gaussian width along periods (columns) in the periodic table.
:type alchemy_period_width: float
:param alchemy_group_width: Gaussian width along groups (rows) in the periodic table.
:type alchemy_group_width: float
:return: Array of FCHL kernel matrices matrix - shape=(n_sigmas, N, M),
:rtype: numpy array
"""
atoms_max = A.shape[1]
neighbors_max = A.shape[3]
assert B.shape[1] == atoms_max, "ERROR: Check FCHL representation sizes! code = 2"
assert B.shape[3] == neighbors_max, "ERROR: Check FCHL representation sizes! code = 3"
nm1 = A.shape[0]
nm2 = B.shape[0]
N1 = np.zeros((nm1),dtype=np.int32)
N2 = np.zeros((nm2),dtype=np.int32)
for a in range(nm1):
N1[a] = len(np.where(A[a,:,1,0] > 0.0001)[0])
for a in range(nm2):
N2[a] = len(np.where(B[a,:,1,0] > 0.0001)[0])
neighbors1 = np.zeros((nm1, atoms_max), dtype=np.int32)
neighbors2 = np.zeros((nm2, atoms_max), dtype=np.int32)
for a, representation in enumerate(A):
ni = N1[a]
for i, x in enumerate(representation[:ni]):
neighbors1[a,i] = len(np.where(x[0]< cut_distance)[0])
for a, representation in enumerate(B):
ni = N2[a]
for i, x in enumerate(representation[:ni]):
neighbors2[a,i] = len(np.where(x[0]< cut_distance)[0])
doalchemy, pd = get_alchemy(alchemy, emax=100, r_width=alchemy_group_width, c_width=alchemy_period_width)
kernel_idx, kernel_parameters, n_kernels = get_kernel_parameters(kernel, kernel_args)
return fget_kernels_fchl(A, B, verbose, N1, N2, neighbors1, neighbors2, nm1, nm2, n_kernels, \
three_body_width, two_body_width, cut_start, cut_distance, fourier_order, pd, two_body_scaling, three_body_scaling, doalchemy, two_body_power, three_body_power, kernel_idx, kernel_parameters)
def get_local_symmetric_kernels(A, verbose=False, \
two_body_scaling=np.sqrt(8), three_body_scaling=1.6,
two_body_width=0.2, three_body_width=np.pi,
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,
kernel="gaussian", kernel_args=None):
""" Calculates the Gaussian kernel matrix K, where :math:`K_{ij}`:
:math:`K_{ij} = \\exp \\big( -\\frac{\\|A_i - A_j\\|_2^2}{2\sigma^2} \\big)`
Where :math:`A_{i}` and :math:`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.
:param A: Array of FCHL representation - shape=(N, maxsize, 5, maxneighbors).
:type A: numpy array
:param two_body_scaling: Weight for 2-body terms.
:type two_body_scaling: float
:param three_body_scaling: Weight for 3-body terms.
:type three_body_scaling: float
:param two_body_width: Gaussian width for 2-body terms
:type two_body_width: float
:param three_body_width: Gaussian width for 3-body terms.
:type three_body_width: float
:param two_body_power: Powerlaw for :math:`r^{-n}` 2-body terms.
:type two_body_power: float
:param three_body_power: Powerlaw for Axilrod-Teller-Muto 3-body term
:type three_body_power: float
:param cut_start: The fraction of the cut-off radius at which cut-off damping start.
:type cut_start: float
:param cut_distance: Cut-off radius. (default=5 angstrom)
:type cut_distance: float
:param fourier_order: 3-body Fourier-expansion truncation order.
:type fourier_order: integer
:param alchemy: Type of alchemical interpolation ``"periodic-table"`` or ``"off"`` are possible options. Disabling alchemical interpolation can yield dramatic speedups.
:type alchemy: string
:param alchemy_period_width: Gaussian width along periods (columns) in the periodic table.
:type alchemy_period_width: float
:param alchemy_group_width: Gaussian width along groups (rows) in the periodic table.
:type alchemy_group_width: float
:return: Array of FCHL kernel matrices matrix - shape=(n_sigmas, N, N),
:rtype: numpy array
"""
atoms_max = A.shape[1]
neighbors_max = A.shape[3]
nm1 = A.shape[0]
N1 = np.zeros((nm1),dtype=np.int32)
for a in range(nm1):
N1[a] = len(np.where(A[a,:,1,0] > 0.0001)[0])
neighbors1 = np.zeros((nm1, atoms_max), dtype=np.int32)
for a, representation in enumerate(A):
ni = N1[a]
for i, x in enumerate(representation[:ni]):
neighbors1[a,i] = len(np.where(x[0]< cut_distance)[0])
doalchemy, pd = get_alchemy(alchemy, emax=100, r_width=alchemy_group_width, c_width=alchemy_period_width)
kernel_idx, kernel_parameters, n_kernels = get_kernel_parameters(kernel, kernel_args)
return fget_symmetric_kernels_fchl(A, verbose, N1, neighbors1, nm1, n_kernels, \
three_body_width, two_body_width, cut_start, cut_distance, fourier_order, pd, two_body_scaling, three_body_scaling, doalchemy, two_body_power, three_body_power, kernel_idx, kernel_parameters)
def get_global_symmetric_kernels(A, verbose=False, \
two_body_scaling=np.sqrt(8), three_body_scaling=1.6,
two_body_width=0.2, three_body_width=np.pi,
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,
kernel="gaussian", kernel_args=None):
""" Calculates the Gaussian kernel matrix K, where :math:`K_{ij}`:
:math:`K_{ij} = \\exp \\big( -\\frac{\\|A_i - A_j\\|_2^2}{2\sigma^2} \\big)`
Where :math:`A_{i}` and :math:`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.
:param A: Array of FCHL representation - shape=(N, maxsize, 5, maxneighbors).
:type A: numpy array
:param two_body_scaling: Weight for 2-body terms.
:type two_body_scaling: float
:param three_body_scaling: Weight for 3-body terms.
:type three_body_scaling: float
:param two_body_width: Gaussian width for 2-body terms
:type two_body_width: float
:param three_body_width: Gaussian width for 3-body terms.
:type three_body_width: float
:param two_body_power: Powerlaw for :math:`r^{-n}` 2-body terms.
:type two_body_power: float
:param three_body_power: Powerlaw for Axilrod-Teller-Muto 3-body term
:type three_body_power: float
:param cut_start: The fraction of the cut-off radius at which cut-off damping start.
:type cut_start: float
:param cut_distance: Cut-off radius. (default=5 angstrom)
:type cut_distance: float
:param fourier_order: 3-body Fourier-expansion truncation order.
:type fourier_order: integer
:param alchemy: Type of alchemical interpolation ``"periodic-table"`` or ``"off"`` are possible options. Disabling alchemical interpolation can yield dramatic speedups.
:type alchemy: string
:param alchemy_period_width: Gaussian width along periods (columns) in the periodic table.
:type alchemy_period_width: float
:param alchemy_group_width: Gaussian width along groups (rows) in the periodic table.
:type alchemy_group_width: float
:return: Array of FCHL kernel matrices matrix - shape=(n_sigmas, N, N),
:rtype: numpy array
"""
atoms_max = A.shape[1]
neighbors_max = A.shape[3]
nm1 = A.shape[0]
N1 = np.zeros((nm1),dtype=np.int32)
for a in range(nm1):
N1[a] = len(np.where(A[a,:,1,0] > 0.0001)[0])
neighbors1 = np.zeros((nm1, atoms_max), dtype=np.int32)
for a, representation in enumerate(A):
ni = N1[a]
for i, x in enumerate(representation[:ni]):
neighbors1[a,i] = len(np.where(x[0]< cut_distance)[0])
doalchemy, pd = get_alchemy(alchemy, emax=100, r_width=alchemy_group_width, c_width=alchemy_period_width)
kernel_idx, kernel_parameters, nsigmas = get_kernel_parameters(kernel, kernel_args)
return fget_global_symmetric_kernels_fchl(A, verbose, N1, neighbors1, nm1, nsigmas, \
three_body_width, two_body_width, cut_start, cut_distance, fourier_order, pd, two_body_scaling, three_body_scaling, doalchemy, two_body_power, three_body_power, kernel_idx, kernel_parameters)
def get_global_kernels(A, B, verbose=False, \
two_body_scaling=np.sqrt(8), three_body_scaling=1.6,
two_body_width=0.2, three_body_width=np.pi,
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,
kernel="gaussian", kernel_args=None):
""" Calculates the Gaussian kernel matrix K, where :math:`K_{ij}`:
:math:`K_{ij} = \\exp \\big( -\\frac{\\|A_i - B_j\\|_2^2}{2\sigma^2} \\big)`
Where :math:`A_{i}` and :math:`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.
:param A: Array of FCHL representation - shape=(N, maxsize, 5, maxneighbors).
:type A: numpy array
:param B: Array of FCHL representation - shape=(M, maxsize, 5, maxneighbors).
:type B: numpy array
:param two_body_scaling: Weight for 2-body terms.
:type two_body_scaling: float
:param three_body_scaling: Weight for 3-body terms.
:type three_body_scaling: float
:param two_body_width: Gaussian width for 2-body terms
:type two_body_width: float
:param three_body_width: Gaussian width for 3-body terms.
:type three_body_width: float
:param two_body_power: Powerlaw for :math:`r^{-n}` 2-body terms.
:type two_body_power: float
:param three_body_power: Powerlaw for Axilrod-Teller-Muto 3-body term
:type three_body_power: float
:param cut_start: The fraction of the cut-off radius at which cut-off damping start.
:type cut_start: float
:param cut_distance: Cut-off radius. (default=5 angstrom)
:type cut_distance: float
:param fourier_order: 3-body Fourier-expansion truncation order.
:type fourier_order: integer
:param alchemy: Type of alchemical interpolation ``"periodic-table"`` or ``"off"`` are possible options. Disabling alchemical interpolation can yield dramatic speedups.
:type alchemy: string
:param alchemy_period_width: Gaussian width along periods (columns) in the periodic table.
:type alchemy_period_width: float
:param alchemy_group_width: Gaussian width along groups (rows) in the periodic table.
:type alchemy_group_width: float
:return: Array of FCHL kernel matrices matrix - shape=(n_sigmas, N, M),
:rtype: numpy array
"""
atoms_max = A.shape[1]
neighbors_max = A.shape[3]
assert B.shape[1] == atoms_max, "ERROR: Check FCHL representation sizes!"
assert B.shape[3] == neighbors_max, "ERROR: Check FCHL representation sizes!"
nm1 = A.shape[0]
nm2 = B.shape[0]
N1 = np.zeros((nm1),dtype=np.int32)
N2 = np.zeros((nm2),dtype=np.int32)
for a in range(nm1):
N1[a] = len(np.where(A[a,:,1,0] > 0.0001)[0])
for a in range(nm2):
N2[a] = len(np.where(B[a,:,1,0] > 0.0001)[0])
neighbors1 = np.zeros((nm1, atoms_max), dtype=np.int32)
neighbors2 = np.zeros((nm2, atoms_max), dtype=np.int32)
for a, representation in enumerate(A):
ni = N1[a]
for i, x in enumerate(representation[:ni]):
neighbors1[a,i] = len(np.where(x[0]< cut_distance)[0])
for a, representation in enumerate(B):
ni = N2[a]
for i, x in enumerate(representation[:ni]):
neighbors2[a,i] = len(np.where(x[0]< cut_distance)[0])
doalchemy, pd = get_alchemy(alchemy, emax=100, r_width=alchemy_group_width, c_width=alchemy_period_width)
kernel_idx, kernel_parameters, nsigmas = get_kernel_parameters(kernel, kernel_args)
return fget_global_kernels_fchl(A, B, verbose, N1, N2, neighbors1, neighbors2, nm1, nm2, nsigmas, \
three_body_width, two_body_width, cut_start, cut_distance, fourier_order, pd, two_body_scaling, three_body_scaling, doalchemy, two_body_power, three_body_power, kernel_idx, kernel_parameters)
def get_atomic_kernels(A, B, verbose=False, \
two_body_scaling=np.sqrt(8), three_body_scaling=1.6,
two_body_width=0.2, three_body_width=np.pi,
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,
kernel="gaussian", kernel_args=None):
""" Calculates the Gaussian kernel matrix K, where :math:`K_{ij}`:
:math:`K_{ij} = \\exp \\big( -\\frac{\\|A_i - B_j\\|_2^2}{2\sigma^2} \\big)`
Where :math:`A_{i}` and :math:`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.
:param A: Array of FCHL representation - shape=(N, maxsize, 5, size).
:type A: numpy array
:param B: Array of FCHL representation - shape=(M, maxsize, 5, size).
:type B: numpy array
:param sigma: List of kernel-widths.
:type sigma: list
:param two_body_scaling: Weight for 2-body terms.
:type two_body_scaling: float
:param three_body_scaling: Weight for 3-body terms.
:type three_body_scaling: float
:param two_body_width: Gaussian width for 2-body terms
:type two_body_width: float
:param three_body_width: Gaussian width for 3-body terms.
:type three_body_width: float
:param two_body_power: Powerlaw for :math:`r^{-n}` 2-body terms.
:type two_body_power: float
:param three_body_power: Powerlaw for Axilrod-Teller-Muto 3-body term
:type three_body_power: float
:param cut_start: The fraction of the cut-off radius at which cut-off damping start.
:type cut_start: float
:param cut_distance: Cut-off radius. (default=5 angstrom)
:type cut_distance: float
:param fourier_order: 3-body Fourier-expansion truncation order.
:type fourier_order: integer
:param alchemy: Type of alchemical interpolation ``"periodic-table"`` or ``"off"`` are possible options. Disabling alchemical interpolation can yield dramatic speedups.
:type alchemy: string
:param alchemy_period_width: Gaussian width along periods (columns) in the periodic table.
:type alchemy_period_width: float
:param alchemy_group_width: Gaussian width along groups (rows) in the periodic table.
:type alchemy_group_width: float
:return: Array of FCHL kernel matrices matrix - shape=(n_sigmas, N, M),
:rtype: numpy array
"""
assert len(A.shape) == 3
assert len(B.shape) == 3
# assert B.shape[1] == atoms_max, "ERROR: Check FCHL representation sizes! code = 2"
# assert B.shape[3] == neighbors_max, "ERROR: Check FCHL representation sizes! code = 3"
na1 = A.shape[0]
na2 = B.shape[0]
neighbors1 = np.zeros((na1), dtype=np.int32)
neighbors2 = np.zeros((na2), dtype=np.int32)
for i, x in enumerate(A):
neighbors1[i] = len(np.where(x[0]< cut_distance)[0])
for i, x in enumerate(B):
neighbors2[i] = len(np.where(x[0]< cut_distance)[0])
doalchemy, pd = get_alchemy(alchemy, emax=100, r_width=alchemy_group_width, c_width=alchemy_period_width)
kernel_idx, kernel_parameters, nsigmas = get_kernel_parameters(kernel, kernel_args)
return fget_atomic_kernels_fchl(A, B, verbose, neighbors1, neighbors2, na1, na2, nsigmas, \
three_body_width, two_body_width, cut_start, cut_distance, fourier_order, pd, two_body_scaling, three_body_scaling, doalchemy, two_body_power, three_body_power, kernel_idx, kernel_parameters)
def get_atomic_symmetric_kernels(A, verbose=False, \
two_body_scaling=np.sqrt(8), three_body_scaling=1.6,
two_body_width=0.2, three_body_width=np.pi,
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,
kernel="gaussian", kernel_args=None):
""" Calculates the Gaussian kernel matrix K, where :math:`K_{ij}`:
:math:`K_{ij} = \\exp \\big( -\\frac{\\|A_i - B_j\\|_2^2}{2\sigma^2} \\big)`
Where :math:`A_{i}` and :math:`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.
:param A: Array of FCHL representation - shape=(N, maxsize, 5, size).
:type A: numpy array
:param sigma: List of kernel-widths.
:type sigma: list
:param two_body_scaling: Weight for 2-body terms.
:type two_body_scaling: float
:param three_body_scaling: Weight for 3-body terms.
:type three_body_scaling: float
:param two_body_width: Gaussian width for 2-body terms
:type two_body_width: float
:param three_body_width: Gaussian width for 3-body terms.
:type three_body_width: float
:param two_body_power: Powerlaw for :math:`r^{-n}` 2-body terms.
:type two_body_power: float
:param three_body_power: Powerlaw for Axilrod-Teller-Muto 3-body term
:type three_body_power: float
:param cut_start: The fraction of the cut-off radius at which cut-off damping start.
:type cut_start: float
:param cut_distance: Cut-off radius. (default=5 angstrom)
:type cut_distance: float
:param fourier_order: 3-body Fourier-expansion truncation order.
:type fourier_order: integer
:param alchemy: Type of alchemical interpolation ``"periodic-table"`` or ``"off"`` are possible options. Disabling alchemical interpolation can yield dramatic speedups.
:type alchemy: string
:param alchemy_period_width: Gaussian width along periods (columns) in the periodic table.
:type alchemy_period_width: float
:param alchemy_group_width: Gaussian width along groups (rows) in the periodic table.
:type alchemy_group_width: float
:return: Array of FCHL kernel matrices matrix - shape=(n_sigmas, N, M),
:rtype: numpy array
"""
assert len(A.shape) == 3
na1 = A.shape[0]
neighbors1 = np.zeros((na1), dtype=np.int32)
for i, x in enumerate(A):
neighbors1[i] = len(np.where(x[0]< cut_distance)[0])
doalchemy, pd = get_alchemy(alchemy, emax=100, r_width=alchemy_group_width, c_width=alchemy_period_width)
kernel_idx, kernel_parameters, nsigmas = get_kernel_parameters(kernel, kernel_args)
return fget_atomic_symmetric_kernels_fchl(A, verbose, neighbors1, na1, nsigmas, \
three_body_width, two_body_width, cut_start, cut_distance, fourier_order, pd, two_body_scaling, three_body_scaling, doalchemy, two_body_power, three_body_power, kernel_idx, kernel_parameters)
def get_atomic_local_kernels(A, B, verbose=False, \
two_body_scaling=np.sqrt(8), three_body_scaling=1.6,
two_body_width=0.2, three_body_width=np.pi,
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,
kernel="gaussian", kernel_args=None):
""" Calculates the Gaussian kernel matrix K, where :math:`K_{ij}`:
:math:`K_{ij} = \\exp \\big( -\\frac{\\|A_i - B_j\\|_2^2}{2\sigma^2} \\big)`
Where :math:`A_{i}` and :math:`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.
:param A: Array of FCHL representation - shape=(N, maxsize, 5, maxneighbors).
:type A: numpy array
:param B: Array of FCHL representation - shape=(M, maxsize, 5, maxneighbors).
:type B: numpy array
:param sigma: List of kernel-widths.
:type sigma: list
:param t_width: Gaussian width for the angular (theta) terms.
:type t_width: float
:param d_width: Gaussian width for the distance terms.
:type d_width: float
:param cut_start: The fraction of the cut-off radius at which cut-off damping start
:type cut_start: float
:param cut_distance: Cut-off radius.
:type cut_distance: float
:param r_width: Gaussian width along rows in the periodic table.
:type r_width: float
:param c_width: Gaussian width along columns in the periodic table.
:type c_width: float
:param order: Fourier-expansion truncation order.
:type order: integer
:param scale_distance: Weight for distance-dependent terms.
:type scale_distance: float
:param scale_angular: Weight for angle-dependent terms.
:type scale_angular: float
:return: Array of FCHL kernel matrices matrix - shape=(n_sigmas, N, M),
:rtype: numpy array
"""
atoms_max = A.shape[1]
neighbors_max = A.shape[3]
assert B.shape[1] == atoms_max, "ERROR: Check FCHL representation sizes! code = 2"
assert B.shape[3] == neighbors_max, "ERROR: Check FCHL representation sizes! code = 3"
nm1 = A.shape[0]
nm2 = B.shape[0]
N1 = np.zeros((nm1),dtype=np.int32)
N2 = np.zeros((nm2),dtype=np.int32)
for a in range(nm1):
N1[a] = len(np.where(A[a,:,1,0] > 0.0001)[0])
for a in range(nm2):
N2[a] = len(np.where(B[a,:,1,0] > 0.0001)[0])
neighbors1 = np.zeros((nm1, atoms_max), dtype=np.int32)
neighbors2 = np.zeros((nm2, atoms_max), dtype=np.int32)
for a, representation in enumerate(A):
ni = N1[a]
for i, x in enumerate(representation[:ni]):
neighbors1[a,i] = len(np.where(x[0]< cut_distance)[0])
for a, representation in enumerate(B):
ni = N2[a]
for i, x in enumerate(representation[:ni]):
neighbors2[a,i] = len(np.where(x[0]< cut_distance)[0])
doalchemy, pd = get_alchemy(alchemy, emax=100, r_width=alchemy_group_width, c_width=alchemy_period_width)
kernel_idx, kernel_parameters, nsigmas = get_kernel_parameters(kernel, kernel_args)
na1 = np.sum(N1)
return fget_atomic_local_kernels_fchl(A, B, verbose, N1, N2, neighbors1, neighbors2, \
nm1, nm2, na1, nsigmas, three_body_width, two_body_width, cut_start, cut_distance, \
fourier_order, pd, two_body_scaling, three_body_scaling, doalchemy, two_body_power, \
three_body_power, kernel_idx, kernel_parameters)
================================================
FILE: qml/fchl/ffchl_electric_field_kernels.f90
================================================
subroutine fget_ef_gaussian_process_kernels_fchl(x1, x2, verbose, f1, f2, n1, n2, nneigh1, nneigh2, &
& nm1, nm2, nsigmas, t_width, d_width, cut_start, cut_distance, order, pd, &
& distance_scale, angular_scale, alchemy, two_body_power, three_body_power, ef_scale,&
& df, kernel_idx, parameters, kernels)
use ffchl_module, only: scalar, get_angular_norm2, get_pmax, get_ksi_ef_field, init_cosp_sinp_ef_field, &
& get_selfscalar, get_ksi_ef, init_cosp_sinp_ef
use ffchl_kernels, only: kernel
implicit none
! fchl descriptors for the training set, format (i,maxatoms,5,maxneighbors)
double precision, dimension(:,:,:,:), intent(in) :: x1
double precision, dimension(:,:,:,:), intent(in) :: x2
! Display output
logical, intent(in) :: verbose
! List of numbers of atoms in each molecule
integer, dimension(:), intent(in) :: n1
integer, dimension(:), intent(in) :: n2
! Electric field perturbations for each molecule
double precision, dimension(:,:), intent(in) :: f1
double precision, dimension(:,:), intent(in) :: f2
! Number of molecules
integer, intent(in) :: nm1
integer, intent(in) :: nm2
! Number of sigmas
integer, intent(in) :: nsigmas
! Number of neighbors for each atom in each compound
integer, dimension(:,:), intent(in) :: nneigh1
integer, dimension(:,:), intent(in) :: nneigh2
! Angular Gaussian width
double precision, intent(in) :: t_width
! Distance Gaussian width
double precision, intent(in) :: d_width
! Fraction of cut_distance at which cut-off starts
double precision, intent(in) :: cut_start
double precision, intent(in) :: cut_distance
! Truncation order for Fourier terms
integer, intent(in) :: order
! Periodic table distance matrix
double precision, dimension(:,:), intent(in) :: pd
! Scaling for angular and distance terms
double precision, intent(in) :: distance_scale
double precision, intent(in) :: angular_scale
! Switch alchemy on or off
logical, intent(in) :: alchemy
! Decaying power laws for two- and three-body terms
double precision, intent(in) :: two_body_power
double precision, intent(in) :: three_body_power
double precision, intent(in) :: ef_scale
double precision, intent(in) :: df
! Kernel ID and corresponding parameters
integer, intent(in) :: kernel_idx
double precision, dimension(:,:), intent(in) :: parameters
! Resulting alpha vector
double precision, dimension(nsigmas,4*nm1,4*nm2), intent(out) :: kernels
! Internal counters
integer :: i, j
integer :: ni, nj
integer :: a, b
integer :: xyz, pm
integer :: xyz1, pm1
integer :: xyz2, pm2
integer :: idx_a
integer :: idx_b
! Temporary variables necessary for parallelization
double precision :: s12
! Pre-computed terms in the full distance matrix
double precision, allocatable, dimension(:,:) :: self_scalar1
double precision, allocatable, dimension(:,:) :: self_scalar2
double precision, allocatable, dimension(:,:,:,:) :: self_scalar1_ef
double precision, allocatable, dimension(:,:,:,:) :: self_scalar2_ef
! Pre-computed two-body weights for nummerical differentation of electric field
double precision, allocatable, dimension(:,:,:) :: ksi1
double precision, allocatable, dimension(:,:,:) :: ksi2
double precision, allocatable, dimension(:,:,:,:,:) :: ksi1_ef
double precision, allocatable, dimension(:,:,:,:,:) :: ksi2_ef
! Pre-computed terms for the Fourier expansion of the three-body term
double precision, allocatable, dimension(:,:,:,:,:) :: sinp1
double precision, allocatable, dimension(:,:,:,:,:) :: cosp1
double precision, allocatable, dimension(:,:,:,:,:) :: sinp2
double precision, allocatable, dimension(:,:,:,:,:) :: cosp2
double precision, allocatable, dimension(:,:,:,:,:,:,:) :: sinp1_ef
double precision, allocatable, dimension(:,:,:,:,:,:,:) :: cosp1_ef
double precision, allocatable, dimension(:,:,:,:,:,:,:) :: sinp2_ef
double precision, allocatable, dimension(:,:,:,:,:,:,:) :: cosp2_ef
! Max index in the periodic table
integer :: pmax1
integer :: pmax2
! Angular normalization constant
double precision :: ang_norm2
! Max number of neighbors
integer :: maxneigh1
integer :: maxneigh2
kernels(:,:,:) = 0.0d0
! Get max number of neighbors
maxneigh1 = maxval(nneigh1)
maxneigh2 = maxval(nneigh2)
! Calculate angular normalization constant
ang_norm2 = get_angular_norm2(t_width)
! pmax = max nuclear charge
pmax1 = get_pmax(x1, n1)
pmax2 = get_pmax(x2, n2)
! Get two-body weight function
ksi1 = get_ksi_ef_field(x1, n1, nneigh1, two_body_power, cut_start, cut_distance, &
& f1, ef_scale, verbose)
ksi1_ef = get_ksi_ef(x1, n1, nneigh1, two_body_power, cut_start, cut_distance, ef_scale, df, verbose)
! Get two-body weight function
ksi2 = get_ksi_ef_field(x2, n2, nneigh2, two_body_power, cut_start, cut_distance, &
& f2, ef_scale, verbose)
ksi2_ef = get_ksi_ef(x2, n2, nneigh2, two_body_power, cut_start, cut_distance, ef_scale, df, verbose)
! Allocate three-body Fourier terms
allocate(cosp1(nm1, maxval(n1), pmax1, order, maxneigh1))
allocate(sinp1(nm1, maxval(n1), pmax1, order, maxneigh1))
! Initialize and pre-calculate three-body Fourier terms
call init_cosp_sinp_ef_field(x1, n1, nneigh1, three_body_power, order, cut_start, cut_distance, &
& cosp1, sinp1, f1, ef_scale, verbose)
! Allocate three-body Fourier terms
allocate(cosp2(nm2, maxval(n2), pmax2, order, maxneigh2))
allocate(sinp2(nm2, maxval(n2), pmax2, order, maxneigh2))
! Initialize and pre-calculate three-body Fourier terms
call init_cosp_sinp_ef_field(x2, n2, nneigh2, three_body_power, order, cut_start, cut_distance, &
& cosp2, sinp2, f2, ef_scale, verbose)
! Allocate three-body Fourier terms
allocate(cosp1_ef(nm1, 3, 2, maxval(n1), pmax1, order, maxneigh1))
allocate(sinp1_ef(nm1, 3, 2, maxval(n1), pmax1, order, maxneigh1))
! Initialize and pre-calculate three-body Fourier terms
call init_cosp_sinp_ef(x1, n1, nneigh1, three_body_power, order, cut_start, cut_distance, &
& cosp1_ef, sinp1_ef, ef_scale, df, verbose)
! Allocate three-body Fourier terms
allocate(cosp2_ef(nm2, 3, 2, maxval(n2), pmax2, order, maxneigh2))
allocate(sinp2_ef(nm2, 3, 2, maxval(n2), pmax2, order, maxneigh2))
! Initialize and pre-calculate three-body Fourier terms
call init_cosp_sinp_ef(x2, n2, nneigh2, three_body_power, order, cut_start, cut_distance, &
& cosp2_ef, sinp2_ef, ef_scale, df, verbose)
! Pre-calculate self-scalar terms
self_scalar1 = get_selfscalar(x1, nm1, n1, nneigh1, ksi1, sinp1, cosp1, t_width, d_width, &
& cut_distance, order, pd, ang_norm2,distance_scale, angular_scale, alchemy, verbose)
! Pre-calculate self-scalar terms
self_scalar2 = get_selfscalar(x2, nm2, n2, nneigh2, ksi2, sinp2, cosp2, t_width, d_width, &
& cut_distance, order, pd, ang_norm2,distance_scale, angular_scale, alchemy, verbose)
! Self-scalar derivatives
allocate(self_scalar1_ef(nm1, 3,2, maxval(n1)))
do a = 1, nm1
ni = n1(a)
do xyz = 1, 3
do pm = 1, 2
do i = 1, ni
self_scalar1_ef(a,xyz,pm,i) = scalar(x1(a,i,:,:), x1(a,i,:,:), nneigh1(a,i), nneigh1(a,i), &
& ksi1_ef(a,xyz,pm,i,:), ksi1_ef(a,xyz,pm,i,:), &
& sinp1_ef(a,xyz,pm,i,:,:,:), sinp1_ef(a,xyz,pm,i,:,:,:), &
& cosp1_ef(a,xyz,pm,i,:,:,:), cosp1_ef(a,xyz,pm,i,:,:,:), &
& t_width, d_width, cut_distance, order, &
& pd, ang_norm2, distance_scale, angular_scale, alchemy)
enddo
enddo
enddo
enddo
! Self-scalar derivatives
allocate(self_scalar2_ef(nm2, 3,2, maxval(n2)))
do a = 1, nm2
ni = n2(a)
do xyz = 1, 3
do pm = 1, 2
do i = 1, ni
self_scalar2_ef(a,xyz,pm,i) = scalar(x2(a,i,:,:), x2(a,i,:,:), nneigh2(a,i), nneigh2(a,i), &
& ksi2_ef(a,xyz,pm,i,:), ksi2_ef(a,xyz,pm,i,:), &
& sinp2_ef(a,xyz,pm,i,:,:,:), sinp2_ef(a,xyz,pm,i,:,:,:), &
& cosp2_ef(a,xyz,pm,i,:,:,:), cosp2_ef(a,xyz,pm,i,:,:,:), &
& t_width, d_width, cut_distance, order, &
& pd, ang_norm2, distance_scale, angular_scale, alchemy)
enddo
enddo
enddo
enddo
!$OMP PARALLEL DO schedule(dynamic) PRIVATE(s12,ni,nj)
do a = 1, nm1
ni = n1(a)
do i = 1, ni
do b = 1, nm2
nj = n2(b)
do j = 1, nj
s12 = scalar(x1(a,i,:,:), x2(b,j,:,:), &
& nneigh1(a,i), nneigh2(b,j), &
& ksi1(a,i,:), ksi2(b,j,:), &
& sinp1(a,i,:,:,:), sinp2(b,j,:,:,:), &
& cosp1(a,i,:,:,:), cosp2(b,j,:,:,:), &
& t_width, d_width, cut_distance, order, &
& pd, ang_norm2, distance_scale, angular_scale, alchemy)
kernels(:, a, b) = kernels(:, a, b) &
& + kernel(self_scalar1(a,i), self_scalar2(b,j), s12, &
& kernel_idx, parameters)
enddo
enddo
enddo
enddo
!$OMP END PARALLEL DO
!$OMP PARALLEL DO schedule(dynamic) PRIVATE(s12,ni,nj,idx_a,idx_b)
do a = 1, nm1
ni = n1(a)
do i = 1, ni
idx_a = a
do b = 1, nm2
nj = n2(b)
do j = 1, nj
do xyz = 1, 3
idx_b = (b - 1) * 3 + xyz + nm2
do pm = 1, 2
s12 = scalar(x1(a,i,:,:), x2(b,j,:,:), &
& nneigh1(a,i), nneigh2(b,j), &
& ksi1(a,i,:), ksi2_ef(b,xyz,pm,j,:), &
& sinp1(a,i,:,:,:), sinp2_ef(b,xyz,pm,j,:,:,:), &
& cosp1(a,i,:,:,:), cosp2_ef(b,xyz,pm,j,:,:,:), &
& t_width, d_width, cut_distance, order, &
& pd, ang_norm2, distance_scale, angular_scale, alchemy)
if (pm == 1) then
kernels(:, idx_a, idx_b) = kernels(:, idx_a, idx_b) &
& + kernel(self_scalar1(a,i), self_scalar2_ef(b,xyz,pm,j), s12, &
& kernel_idx, parameters) / (2 * df)
else
kernels(:, idx_a, idx_b) = kernels(:, idx_a, idx_b) &
& - kernel(self_scalar1(a,i), self_scalar2_ef(b,xyz,pm,j), s12, &
& kernel_idx, parameters) / (2 * df)
endif
enddo
enddo
enddo
enddo
enddo
enddo
!$OMP END PARALLEL DO
!$OMP PARALLEL DO schedule(dynamic) PRIVATE(s12,ni,nj,idx_a,idx_b)
do a = 1, nm2
ni = n2(a)
do i = 1, ni
idx_a = a
do b = 1, nm1
nj = n1(b)
do j = 1, nj
do xyz = 1, 3
idx_b = (b - 1) * 3 + xyz + nm1
do pm = 1, 2
s12 = scalar(x2(a,i,:,:), x1(b,j,:,:), &
& nneigh2(a,i), nneigh1(b,j), &
& ksi2(a,i,:), ksi1_ef(b,xyz,pm,j,:), &
& sinp2(a,i,:,:,:), sinp1_ef(b,xyz,pm,j,:,:,:), &
& cosp2(a,i,:,:,:), cosp1_ef(b,xyz,pm,j,:,:,:), &
& t_width, d_width, cut_distance, order, &
& pd, ang_norm2, distance_scale, angular_scale, alchemy)
if (pm == 1) then
! kernels(:, idx_a, idx_b) = kernels(:, idx_a, idx_b) &
kernels(:, idx_b, idx_a) = kernels(:, idx_b, idx_a) &
& + kernel(self_scalar2(a,i), self_scalar1_ef(b,xyz,pm,j), s12, &
& kernel_idx, parameters) / (2 * df)
else
! kernels(:, idx_a, idx_b) = kernels(:, idx_a, idx_b) &
kernels(:, idx_b, idx_a) = kernels(:, idx_b, idx_a) &
& - kernel(self_scalar2(a,i), self_scalar1_ef(b,xyz,pm,j), s12, &
& kernel_idx, parameters) / (2 * df)
endif
enddo
enddo
enddo
enddo
enddo
enddo
!$OMP END PARALLEL DO
! should be zero?
!$OMP PARALLEL DO schedule(dynamic) PRIVATE(s12,ni,nj,idx_a,idx_b)
do a = 1, nm1
ni = n1(a)
do i = 1, ni
do xyz1 = 1, 3
idx_a = (a - 1) * 3 + xyz1 + nm1
do pm1 = 1, 2
do b = 1, nm2
nj = n2(b)
do j = 1, nj
do xyz2 = 1, 3
idx_b = (b - 1) * 3 + xyz2 + nm2
do pm2 = 1, 2
s12 = scalar(x1(a,i,:,:), x2(b,j,:,:), &
& nneigh1(a,i), nneigh2(b,j), &
& ksi1_ef(a,xyz1,pm1,i,:), ksi2_ef(b,xyz2,pm2,j,:), &
& sinp1_ef(a,xyz1,pm1,i,:,:,:), sinp2_ef(b,xyz2,pm2,j,:,:,:), &
& cosp1_ef(a,xyz1,pm1,i,:,:,:), cosp2_ef(b,xyz2,pm2,j,:,:,:), &
& t_width, d_width, cut_distance, order, &
& pd, ang_norm2, distance_scale, angular_scale, alchemy)
if (pm1 == pm2) then
kernels(:, idx_a, idx_b) = kernels(:, idx_a, idx_b) &
& + kernel(self_scalar1_ef(a,xyz1,pm1,i), self_scalar2_ef(b,xyz2,pm2,j), s12, &
& kernel_idx, parameters) / (4 * df**2)
else
kernels(:, idx_a, idx_b) = kernels(:, idx_a, idx_b) &
& - kernel(self_scalar1_ef(a,xyz1,pm1,i), self_scalar2_ef(b,xyz2,pm2,j), s12, &
& kernel_idx, parameters) / (4 * df**2)
endif
enddo
enddo
enddo
enddo
enddo
enddo
enddo
enddo
!$OMP END PARALLEL DO
deallocate(self_scalar1)
deallocate(self_scalar1_ef)
deallocate(ksi1)
deallocate(ksi1_ef)
deallocate(cosp1)
deallocate(cosp1_ef)
deallocate(sinp1)
deallocate(sinp1_ef)
end subroutine fget_ef_gaussian_process_kernels_fchl
subroutine fget_ef_atomic_local_kernels_fchl(x1, x2, verbose, f2, n1, n2, nneigh1, nneigh2, nm1, nm2, nsigmas, na1, &
& t_width, d_width, cut_start, cut_distance, order, pd, &
& distance_scale, angular_scale, alchemy, two_body_power, three_body_power, ef_scale,&
& kernel_idx, parameters, kernels)
use ffchl_module, only: scalar, get_angular_norm2, get_pmax, get_ksi_ef_field, init_cosp_sinp_ef_field, &
& get_selfscalar, get_ksi, init_cosp_sinp
use ffchl_kernels, only: kernel
implicit none
! fchl descriptors for the training set, format (i,maxatoms,5,maxneighbors)
double precision, dimension(:,:,:,:), intent(in) :: x1
double precision, dimension(:,:,:,:), intent(in) :: x2
! List of numbers of atoms in each molecule
integer, dimension(:), intent(in) :: n1
integer, dimension(:), intent(in) :: n2
! Display output
logical, intent(in) :: verbose
! Electric field perturbations for each molecule
double precision, dimension(:,:), intent(in) :: f2
! Number of molecules
integer, intent(in) :: nm1
integer, intent(in) :: nm2
! Number of sigmas
integer, intent(in) :: nsigmas
integer, intent(in) :: na1
! Number of neighbors for each atom in each compound
integer, dimension(:,:), intent(in) :: nneigh1
integer, dimension(:,:), intent(in) :: nneigh2
! Angular Gaussian width
double precision, intent(in) :: t_width
! Distance Gaussian width
double precision, intent(in) :: d_width
! Fraction of cut_distance at which cut-off starts
double precision, intent(in) :: cut_start
double precision, intent(in) :: cut_distance
! Truncation order for Fourier terms
integer, intent(in) :: order
! Periodic table distance matrix
double precision, dimension(:,:), intent(in) :: pd
! Scaling for angular and distance terms
double precision, intent(in) :: distance_scale
double precision, intent(in) :: angular_scale
! Switch alchemy on or off
logical, intent(in) :: alchemy
! Decaying power laws for two- and three-body terms
double precision, intent(in) :: two_body_power
double precision, intent(in) :: three_body_power
double precision, intent(in) :: ef_scale
! Kernel ID and corresponding parameters
integer, intent(in) :: kernel_idx
double precision, dimension(:,:), intent(in) :: parameters
! Resulting alpha vector
double precision, dimension(nsigmas,na1,nm2), intent(out) :: kernels
! Internal counters
integer :: i, j
integer :: ni, nj
integer :: a, b
integer :: idx1
! Temporary variables necessary for parallelization
double precision :: s12
! Pre-computed terms in the full distance matrix
double precision, allocatable, dimension(:,:) :: self_scalar1
double precision, allocatable, dimension(:,:) :: self_scalar2
! Pre-computed two-body weights for nummerical differentation of electric field
double precision, allocatable, dimension(:,:,:) :: ksi1
double precision, allocatable, dimension(:,:,:) :: ksi2
! Pre-computed terms for the Fourier expansion of the three-body term
double precision, allocatable, dimension(:,:,:,:,:) :: sinp1
double precision, allocatable, dimension(:,:,:,:,:) :: cosp1
double precision, allocatable, dimension(:,:,:,:,:) :: sinp2
double precision, allocatable, dimension(:,:,:,:,:) :: cosp2
! Max index in the periodic table
integer :: pmax1
integer :: pmax2
! Angular normalization constant
double precision :: ang_norm2
! Max number of neighbors
integer :: maxneigh1
integer :: maxneigh2
kernels(:,:,:) = 0.0d0
! Get max number of neighbors
maxneigh1 = maxval(nneigh1)
maxneigh2 = maxval(nneigh2)
! Calculate angular normalization constant
ang_norm2 = get_angular_norm2(t_width)
! pmax = max nuclear charge
pmax1 = get_pmax(x1, n1)
pmax2 = get_pmax(x2, n2)
! Get two-body weight function
ksi1 = get_ksi(x1, n1, nneigh1, two_body_power, cut_start, cut_distance, verbose)
! Get two-body weight function
ksi2 = get_ksi_ef_field(x2, n2, nneigh2, two_body_power, cut_start, cut_distance, &
& f2, ef_scale, verbose)
! Allocate three-body Fourier terms
allocate(cosp1(nm1, maxval(n1), pmax1, order, maxneigh1))
allocate(sinp1(nm1, maxval(n1), pmax1, order, maxneigh1))
! Initialize and pre-calculate three-body Fourier terms
call init_cosp_sinp(x1, n1, nneigh1, three_body_power, order, cut_start, cut_distance, &
& cosp1, sinp1, verbose)
! Allocate three-body Fourier terms
allocate(cosp2(nm2, maxval(n2), pmax2, order, maxneigh2))
allocate(sinp2(nm2, maxval(n2), pmax2, order, maxneigh2))
! Initialize and pre-calculate three-body Fourier terms
call init_cosp_sinp_ef_field(x2, n2, nneigh2, three_body_power, order, cut_start, cut_distance, &
& cosp2, sinp2, f2, ef_scale, verbose)
! Pre-calculate self-scalar terms
self_scalar1 = get_selfscalar(x1, nm1, n1, nneigh1, ksi1, sinp1, cosp1, t_width, d_width, &
& cut_distance, order, pd, ang_norm2,distance_scale, angular_scale, alchemy, verbose)
! Pre-calculate self-scalar terms
self_scalar2 = get_selfscalar(x2, nm2, n2, nneigh2, ksi2, sinp2, cosp2, t_width, d_width, &
& cut_distance, order, pd, ang_norm2,distance_scale, angular_scale, alchemy, verbose)
kernels(:,:,:) = 0.0d0
!$OMP PARALLEL DO schedule(dynamic) PRIVATE(ni,nj,idx1,s12)
do a = 1, nm1
ni = n1(a)
do i = 1, ni
idx1 = sum(n1(:a)) - ni + i
do b = 1, nm2
nj = n2(b)
do j = 1, nj
s12 = scalar(x1(a,i,:,:), x2(b,j,:,:), &
& nneigh1(a,i), nneigh2(b,j), ksi1(a,i,:), ksi2(b,j,:), &
& sinp1(a,i,:,:,:), sinp2(b,j,:,:,:), &
& cosp1(a,i,:,:,:), cosp2(b,j,:,:,:), &
& t_width, d_width, cut_distance, order, &
& pd, ang_norm2, distance_scale, angular_scale, alchemy)
kernels(:, idx1, b) = kernels(:, idx1, b) &
& + kernel(self_scalar1(a,i), self_scalar2(b,j), s12, &
& kernel_idx, parameters)
enddo
enddo
enddo
enddo
!$OMP END PARALLEL DO
deallocate(self_scalar1)
deallocate(self_scalar2)
deallocate(ksi1)
deallocate(ksi2)
deallocate(cosp1)
deallocate(cosp2)
deallocate(sinp1)
deallocate(sinp2)
end subroutine fget_ef_atomic_local_kernels_fchl
subroutine fget_ef_atomic_local_gradient_kernels_fchl(x1, x2, verbose, n1, n2, nneigh1, nneigh2, nm1, nm2, na1, nsigmas, &
& t_width, d_width, cut_start, cut_distance, order, pd, &
& distance_scale, angular_scale, alchemy, two_body_power, three_body_power, ef_scale,&
& df, kernel_idx, parameters, kernels)
use ffchl_module, only: scalar, get_angular_norm2, get_pmax, get_ksi, init_cosp_sinp, &
& get_selfscalar, get_ksi_ef, init_cosp_sinp_ef
use ffchl_kernels, only: kernel
implicit none
! fchl descriptors for the training set, format (i,maxatoms,5,maxneighbors)
double precision, dimension(:,:,:,:), intent(in) :: x1
double precision, dimension(:,:,:,:), intent(in) :: x2
! Display output
logical, intent(in) :: verbose
! List of numbers of atoms in each molecule
integer, dimension(:), intent(in) :: n1
integer, dimension(:), intent(in) :: n2
! Number of molecules
integer, intent(in) :: nm1
integer, intent(in) :: nm2
! Number of atoms in set 1
integer, intent(in) :: na1
! Number of sigmas
integer, intent(in) :: nsigmas
! Number of neighbors for each atom in each compound
integer, dimension(:,:), intent(in) :: nneigh1
integer, dimension(:,:), intent(in) :: nneigh2
! Angular Gaussian width
double precision, intent(in) :: t_width
! Distance Gaussian width
double precision, intent(in) :: d_width
! Fraction of cut_distance at which cut-off starts
double precision, intent(in) :: cut_start
double precision, intent(in) :: cut_distance
! Truncation order for Fourier terms
integer, intent(in) :: order
! Periodic table distance matrix
double precision, dimension(:,:), intent(in) :: pd
! Scaling for angular and distance terms
double precision, intent(in) :: distance_scale
double precision, intent(in) :: angular_scale
! Switch alchemy on or off
logical, intent(in) :: alchemy
! Decaying power laws for two- and three-body terms
double precision, intent(in) :: two_body_power
double precision, intent(in) :: three_body_power
double precision, intent(in) :: ef_scale
double precision, intent(in) :: df
! Kernel ID and corresponding parameters
integer, intent(in) :: kernel_idx
double precision, dimension(:,:), intent(in) :: parameters
! Resulting alpha vector
double precision, dimension(nsigmas,na1,nm2*3), intent(out) :: kernels
! Internal counters
integer :: i, j
integer :: ni, nj
integer :: a, b
integer :: xyz, pm
integer :: idx_a
integer :: idx_b
! Temporary variables necessary for parallelization
double precision :: s12
! Pre-computed terms in the full distance matrix
double precision, allocatable, dimension(:,:) :: self_scalar1
double precision, allocatable, dimension(:,:,:,:) :: self_scalar2_ef
! Pre-computed two-body weights for nummerical differentation of electric field
double precision, allocatable, dimension(:,:,:) :: ksi1
double precision, allocatable, dimension(:,:,:,:,:) :: ksi2_ef
! Pre-computed terms for the Fourier expansion of the three-body term
double precision, allocatable, dimension(:,:,:,:,:) :: sinp1
double precision, allocatable, dimension(:,:,:,:,:) :: cosp1
double precision, allocatable, dimension(:,:,:,:,:,:,:) :: sinp2_ef
double precision, allocatable, dimension(:,:,:,:,:,:,:) :: cosp2_ef
! Max index in the periodic table
integer :: pmax1
integer :: pmax2
! Angular normalization constant
double precision :: ang_norm2
! Max number of neighbors
integer :: maxneigh1
integer :: maxneigh2
kernels(:,:,:) = 0.0d0
! Get max number of neighbors
maxneigh1 = maxval(nneigh1)
maxneigh2 = maxval(nneigh2)
! Calculate angular normalization constant
ang_norm2 = get_angular_norm2(t_width)
! pmax = max nuclear charge
pmax1 = get_pmax(x1, n1)
pmax2 = get_pmax(x2, n2)
! Get two-body weight function
ksi1 = get_ksi(x1, n1, nneigh1, two_body_power, cut_start, cut_distance, verbose)
ksi2_ef = get_ksi_ef(x2, n2, nneigh2, two_body_power, cut_start, cut_distance, ef_scale, df, verbose)
! Allocate three-body Fourier terms
allocate(cosp1(nm1, maxval(n1), pmax1, order, maxneigh1))
allocate(sinp1(nm1, maxval(n1), pmax1, order, maxneigh1))
! Initialize and pre-calculate three-body Fourier terms
call init_cosp_sinp(x1, n1, nneigh1, three_body_power, order, cut_start, cut_distance, &
& cosp1, sinp1, verbose)
! Allocate three-body Fourier terms
allocate(cosp2_ef(nm2, 3, 2, maxval(n2), pmax2, order, maxneigh2))
allocate(sinp2_ef(nm2, 3, 2, maxval(n2), pmax2, order, maxneigh2))
! Initialize and pre-calculate three-body Fourier terms
call init_cosp_sinp_ef(x2, n2, nneigh2, three_body_power, order, cut_start, cut_distance, &
& cosp2_ef, sinp2_ef, ef_scale, df, verbose)
! Pre-calculate self-scalar terms
self_scalar1 = get_selfscalar(x1, nm1, n1, nneigh1, ksi1, sinp1, cosp1, t_width, d_width, &
& cut_distance, order, pd, ang_norm2,distance_scale, angular_scale, alchemy, verbose)
allocate(self_scalar2_ef(nm2, 3,2, maxval(n2)))
do a = 1, nm2
ni = n2(a)
do xyz = 1, 3
do pm = 1, 2
do i = 1, ni
self_scalar2_ef(a,xyz,pm,i) = scalar(x2(a,i,:,:), x2(a,i,:,:), nneigh2(a,i), nneigh2(a,i), &
& ksi2_ef(a,xyz,pm,i,:), ksi2_ef(a,xyz,pm,i,:), &
& sinp2_ef(a,xyz,pm,i,:,:,:), sinp2_ef(a,xyz,pm,i,:,:,:), &
& cosp2_ef(a,xyz,pm,i,:,:,:), cosp2_ef(a,xyz,pm,i,:,:,:), &
& t_width, d_width, cut_distance, order, &
& pd, ang_norm2, distance_scale, angular_scale, alchemy)
enddo
enddo
enddo
enddo
!$OMP PARALLEL DO schedule(dynamic) PRIVATE(s12,ni,nj,idx_a,idx_b)
do a = 1, nm1
ni = n1(a)
do i = 1, ni
idx_a = sum(n1(:a)) - ni + i
do b = 1, nm2
nj = n2(b)
do j = 1, nj
do xyz = 1, 3
idx_b = (b - 1) * 3 + xyz
do pm = 1, 2
s12 = scalar(x1(a,i,:,:), x2(b,j,:,:), &
& nneigh1(a,i), nneigh2(b,j), &
& ksi1(a,i,:), ksi2_ef(b,xyz,pm,j,:), &
& sinp1(a,i,:,:,:), sinp2_ef(b,xyz,pm,j,:,:,:), &
& cosp1(a,i,:,:,:), cosp2_ef(b,xyz,pm,j,:,:,:), &
& t_width, d_width, cut_distance, order, &
& pd, ang_norm2, distance_scale, angular_scale, alchemy)
if (pm == 1) then
kernels(:, idx_a, idx_b) = kernels(:, idx_a, idx_b) &
& + kernel(self_scalar1(a,i), self_scalar2_ef(b,xyz,pm,j), s12, &
& kernel_idx, parameters)
else
kernels(:, idx_a, idx_b) = kernels(:, idx_a, idx_b) &
& - kernel(self_scalar1(a,i), self_scalar2_ef(b,xyz,pm,j), s12, &
& kernel_idx, parameters)
endif
enddo
enddo
enddo
enddo
enddo
enddo
!$OMP END PARALLEL DO
kernels = kernels / (2 * df)
deallocate(self_scalar1)
deallocate(self_scalar2_ef)
deallocate(ksi1)
deallocate(ksi2_ef)
deallocate(cosp1)
deallocate(cosp2_ef)
deallocate(sinp1)
deallocate(sinp2_ef)
end subroutine fget_ef_atomic_local_gradient_kernels_fchl
! subroutine fget_ef_local_hessian_kernels_fchl(x1, x2, verbose, n1, n2, nneigh1, nneigh2, nm1, nm2, nsigmas, &
! & t_width, d_width, cut_start, cut_distance, order, pd, &
! & distance_scale, angular_scale, alchemy, two_body_power, three_body_power, &
! & ef_scale, df, kernel_idx, parameters, kernels)
!
! use ffchl_module, only: scalar, get_angular_norm2, get_pmax, get_ksi, init_cosp_sinp, &
! & get_selfscalar, get_ksi_ef, init_cosp_sinp_ef
!
! use ffchl_kernels, only: kernel
!
! use omp_lib, only: omp_get_wtime
!
! implicit none
!
! ! fchl descriptors for the training set, format (i,maxatoms,5,maxneighbors)
! double precision, dimension(:,:,:,:), intent(in) :: x1
! double precision, dimension(:,:,:,:), intent(in) :: x2
!
! ! Display output
! logical, intent(in) :: verbose
!
! ! List of numbers of atoms in each molecule
! integer, dimension(:), intent(in) :: n1
! integer, dimension(:), intent(in) :: n2
!
! ! Number of molecules
! integer, intent(in) :: nm1
! integer, intent(in) :: nm2
!
! ! Number of sigmas
! integer, intent(in) :: nsigmas
!
! ! Number of neighbors for each atom in each compound
! integer, dimension(:,:), intent(in) :: nneigh1
! integer, dimension(:,:), intent(in) :: nneigh2
!
! ! Angular Gaussian width
! double precision, intent(in) :: t_width
!
! ! Distance Gaussian width
! double precision, intent(in) :: d_width
!
! ! Fraction of cut_distance at which cut-off starts
! double precision, intent(in) :: cut_start
! double precision, intent(in) :: cut_distance
!
! ! Truncation order for Fourier terms
! integer, intent(in) :: order
!
! ! Periodic table distance matrix
! double precision, dimension(:,:), intent(in) :: pd
!
! ! Scaling for angular and distance terms
! double precision, intent(in) :: distance_scale
! double precision, intent(in) :: angular_scale
!
! ! Switch alchemy on or off
! logical, intent(in) :: alchemy
!
! ! Decaying power laws for two- and three-body terms
! double precision, intent(in) :: two_body_power
! double precision, intent(in) :: three_body_power
!
! double precision, intent(in) :: ef_scale
! double precision, intent(in) :: df
!
! ! Kernel ID and corresponding parameters
! integer, intent(in) :: kernel_idx
! double precision, dimension(:,:), intent(in) :: parameters
!
! ! Resulting alpha vector
! ! double precision, dimension(nsigmas,nm1,nm2), intent(out) :: kernels
! double precision, dimension(nsigmas,nm1*3,nm2*3), intent(out) :: kernels
!
! double precision, dimension(nsigmas):: kernel_sum1
! double precision, dimension(nsigmas):: kernel_sum2
!
! ! Internal counters
! integer :: i, j
! integer :: ni, nj
! integer :: a, b
! integer :: xyz, pm
! integer :: xyz1, pm1
! integer :: xyz2, pm2
!
! integer :: idx_a, idx_b
!
! ! Temporary variables necessary for parallelization
! double precision :: s12
!
! ! Pre-computed terms in the full distance matrix
! double precision, allocatable, dimension(:,:,:,:) :: self_scalar1_ef
! double precision, allocatable, dimension(:,:,:,:) :: self_scalar2_ef
!
! ! Pre-computed two-body weights for nummerical differentation of electric field
! double precision, allocatable, dimension(:,:,:,:,:) :: ksi1_ef
! double precision, allocatable, dimension(:,:,:,:,:) :: ksi2_ef
!
! ! ! Pre-computed terms for the Fourier expansion of the three-body term
! double precision, allocatable, dimension(:,:,:,:,:,:,:) :: sinp1_ef
! double precision, allocatable, dimension(:,:,:,:,:,:,:) :: sinp2_ef
! double precision, allocatable, dimension(:,:,:,:,:,:,:) :: cosp1_ef
! double precision, allocatable, dimension(:,:,:,:,:,:,:) :: cosp2_ef
!
! ! Max index in the periodic table
! integer :: pmax1
! integer :: pmax2
!
! ! Angular normalization constant
! double precision :: ang_norm2
!
! ! Max number of neighbors
! integer :: maxneigh1
! integer :: maxneigh2
!
! ! Variables to calculate time
! double precision :: t_start, t_end
!
! write (*,*) "CLEARING KERNEL MEM"
! kernels(:,:,:) = 0.0d0
!
! ! Get max number of neighbors
! maxneigh1 = maxval(nneigh1)
! maxneigh2 = maxval(nneigh2)
!
! ! Calculate angular normalization constant
! ang_norm2 = get_angular_norm2(t_width)
!
! ! pmax = max nuclear charge
! pmax1 = get_pmax(x1, n1)
! pmax2 = get_pmax(x2, n2)
!
!
! ! Get two-body weight function
! ksi1_ef = get_ksi_ef(x1, n1, nneigh1, two_body_power, cut_start, cut_distance, ef_scale, df)
! ksi2_ef = get_ksi_ef(x2, n2, nneigh2, two_body_power, cut_start, cut_distance, ef_scale, df)
!
!
! ! Allocate three-body Fourier terms
! allocate(cosp1_ef(nm1, 3, 2, maxval(n1), pmax1, order, maxneigh1))
! allocate(sinp1_ef(nm1, 3, 2, maxval(n1), pmax1, order, maxneigh1))
!
! ! Initialize and pre-calculate three-body Fourier terms
! call init_cosp_sinp_ef(x1, n1, nneigh1, three_body_power, order, cut_start, cut_distance, &
! & cosp1_ef, sinp1_ef, ef_scale, df)
!
!
! ! Allocate three-body Fourier terms
! allocate(cosp2_ef(nm2, 3, 2, maxval(n2), pmax2, order, maxneigh2))
! allocate(sinp2_ef(nm2, 3, 2, maxval(n2), pmax2, order, maxneigh2))
!
! ! Initialize and pre-calculate three-body Fourier terms
! call init_cosp_sinp_ef(x2, n2, nneigh2, three_body_power, order, cut_start, cut_distance, &
! & cosp2_ef, sinp2_ef, ef_scale, df)
!
!
! allocate(self_scalar1_ef(nm1, 3,2, maxval(n1)))
! do a = 1, nm1
! ni = n1(a)
! do xyz = 1, 3
! do pm = 1, 2
! do i = 1, ni
!
! self_scalar1_ef(a,xyz,pm,i) = scalar(x1(a,i,:,:), x1(a,i,:,:), nneigh1(a,i), nneigh1(a,i), &
! & ksi1_ef(a,xyz,pm,i,:), ksi1_ef(a,xyz,pm,i,:), &
! & sinp1_ef(a,xyz,pm,i,:,:,:), sinp1_ef(a,xyz,pm,i,:,:,:), &
! & cosp1_ef(a,xyz,pm,i,:,:,:), cosp1_ef(a,xyz,pm,i,:,:,:), &
! & t_width, d_width, cut_distance, order, &
! & pd, ang_norm2, distance_scale, angular_scale, alchemy)
!
! enddo
! enddo
! enddo
! enddo
!
!
! allocate(self_scalar2_ef(nm2, 3,2, maxval(n2)))
! do a = 1, nm2
! ni = n2(a)
! do xyz = 1, 3
! do pm = 1, 2
! do i = 1, ni
!
! self_scalar2_ef(a,xyz,pm,i) = scalar(x2(a,i,:,:), x2(a,i,:,:), nneigh2(a,i), nneigh2(a,i), &
! & ksi2_ef(a,xyz,pm,i,:), ksi2_ef(a,xyz,pm,i,:), &
! & sinp2_ef(a,xyz,pm,i,:,:,:), sinp2_ef(a,xyz,pm,i,:,:,:), &
! & cosp2_ef(a,xyz,pm,i,:,:,:), cosp2_ef(a,xyz,pm,i,:,:,:), &
! & t_width, d_width, cut_distance, order, &
! & pd, ang_norm2, distance_scale, angular_scale, alchemy)
!
! enddo
! enddo
! enddo
! enddo
!
! t_start = omp_get_wtime()
! write (*,"(A)", advance="no") "KERNEL"
!
! !$OMP PARALLEL DO schedule(dynamic) PRIVATE(s12,ni,nj,idx_a,idx_b,kernel_sum1,kernel_sum2)
! do b = 1, nm2
! nj = n2(b)
! do j = 1, nj
!
! do a = 1, nm1
! ni = n1(a)
! do i = 1, ni
!
! do xyz1 = 1, 3
! do xyz2 = 1, 3
!
! idx_a = (a - 1) * 3 + xyz1
! idx_b = (b - 1) * 3 + xyz2
!
! do pm1 = 1, 2
! do pm2 = 1, 2
!
! s12 = scalar(x1(a,i,:,:), x2(b,j,:,:), &
! & nneigh1(a,i), nneigh2(b,j), &
! & ksi1_ef(a,xyz1,pm1,i,:), ksi2_ef(b,xyz2,pm2,j,:), &
! & sinp1_ef(a,xyz1,pm1,i,:,:,:), sinp2_ef(b,xyz2,pm2,j,:,:,:), &
! & cosp1_ef(a,xyz1,pm1,i,:,:,:), cosp2_ef(b,xyz2,pm2,j,:,:,:), &
! & t_width, d_width, cut_distance, order, &
! & pd, ang_norm2, distance_scale, angular_scale, alchemy)
!
!
! if (pm1 == pm2) then
!
! kernels(:, idx_a, idx_b) = kernels(:, idx_a, idx_b) &
! & + kernel(self_scalar1_ef(a,xyz1,pm1,i), self_scalar2_ef(b,xyz2,pm2,j), s12, &
! & kernel_idx, parameters)
! else
!
! kernels(:, idx_a, idx_b) = kernels(:, idx_a, idx_b) &
! & - kernel(self_scalar1_ef(a,xyz1,pm1,i), self_scalar2_ef(b,xyz2,pm2,j), s12, &
! & kernel_idx, parameters)
!
! endif
! enddo
! enddo
! enddo
! enddo
! enddo
! enddo
! enddo
! enddo
! !$OMP END PARALLEL DO
!
! kernels = kernels / (4 * df**2)
!
! t_end = omp_get_wtime()
! write (*,"(A,F12.4,A)") " Time = ", t_end - t_start, " s"
!
! end subroutine fget_ef_local_hessian_kernels_fchl
!
! TODO: Fix, experimental code for polarizability
!
! subroutine fget_kernels_fchl_ef_2ndderiv(x1, x2, n1, n2, nneigh1, nneigh2, nm1, nm2, na1, nsigmas, &
! & t_width, d_width, cut_start, cut_distance, order, pd, &
! & distance_scale, angular_scale, alchemy, two_body_power, three_body_power, ef_scale,&
! & df, kernel_idx, parameters, kernels)
!
! use ffchl_module, only: scalar, get_angular_norm2, get_pmax, get_ksi, init_cosp_sinp, &
! & get_selfscalar, get_ksi_pol, init_cosp_sinp_pol
!
! use ffchl_kernels, only: kernel
!
! use omp_lib, only: omp_get_wtime
!
! implicit none
!
! ! fchl descriptors for the training set, format (i,maxatoms,5,maxneighbors)
! double precision, dimension(:,:,:,:), intent(in) :: x1
! double precision, dimension(:,:,:,:), intent(in) :: x2
!
! ! List of numbers of atoms in each molecule
! integer, dimension(:), intent(in) :: n1
! integer, dimension(:), intent(in) :: n2
!
! ! Number of molecules
! integer, intent(in) :: nm1
! integer, intent(in) :: nm2
!
! ! Number of atoms in set 1
! integer, intent(in) :: na1
!
! ! Number of sigmas
! integer, intent(in) :: nsigmas
!
! ! Number of neighbors for each atom in each compound
! integer, dimension(:,:), intent(in) :: nneigh1
! integer, dimension(:,:), intent(in) :: nneigh2
!
! ! Angular Gaussian width
! double precision, intent(in) :: t_width
!
! ! Distance Gaussian width
! double precision, intent(in) :: d_width
!
! ! Fraction of cut_distance at which cut-off starts
! double precision, intent(in) :: cut_start
! double precision, intent(in) :: cut_distance
!
! ! Truncation order for Fourier terms
! integer, intent(in) :: order
!
! ! Periodic table distance matrix
! double precision, dimension(:,:), intent(in) :: pd
!
! ! Scaling for angular and distance terms
! double precision, intent(in) :: distance_scale
! double precision, intent(in) :: angular_scale
!
! ! Switch alchemy on or off
! logical, intent(in) :: alchemy
!
! ! Decaying power laws for two- and three-body terms
! double precision, intent(in) :: two_body_power
! double precision, intent(in) :: three_body_power
!
!
! double precision, intent(in) :: ef_scale
! double precision, intent(in) :: df
!
! ! Kernel ID and corresponding parameters
! integer, intent(in) :: kernel_idx
! double precision, dimension(:,:), intent(in) :: parameters
!
! ! Resulting alpha vector
! ! double precision, dimension(nsigmas,nm1,nm2), intent(out) :: kernels
! ! double precision, dimension(nsigmas,na1,nm2*3), intent(out) :: kernels
! double precision, dimension(nsigmas,na1,na1*3), intent(out) :: kernels
!
! ! Internal counters
! integer :: i, j
! integer :: ni, nj
! integer :: a, b
! integer :: xyz, pm
! integer :: idx_a
! integer :: idx_b
! integer :: qidx
!
! ! Temporary variables necessary for parallelization
! double precision :: s12
!
! ! Pre-computed terms in the full distance matrix
! double precision, allocatable, dimension(:,:) :: self_scalar1
! double precision, allocatable, dimension(:,:,:) :: self_scalar2_pol
!
! ! Pre-computed two-body weights for nummerical differentation of electric field
! double precision, allocatable, dimension(:,:,:) :: ksi1
! double precision, allocatable, dimension(:,:,:,:) :: ksi2_pol
!
! ! Pre-computed terms for the Fourier expansion of the three-body term
! double precision, allocatable, dimension(:,:,:,:,:) :: sinp1
! double precision, allocatable, dimension(:,:,:,:,:) :: cosp1
! double precision, allocatable, dimension(:,:,:,:,:,:) :: sinp2_pol
! double precision, allocatable, dimension(:,:,:,:,:,:) :: cosp2_pol
!
! double precision, dimension(nsigmas) :: unperturbed
! double precision, dimension(nsigmas) :: test_plus, test_minus
!
! integer, dimension(3,2) :: idx
!
! ! Max index in the periodic table
! integer :: pmax1
! integer :: pmax2
!
! ! Angular normalization constant
! double precision :: ang_norm2
!
! ! Max number of neighbors
! integer :: maxneigh1
! integer :: maxneigh2
!
! ! Variables to calculate time
! double precision :: t_start, t_end
!
! write (*,*) "CLEARING KERNEL MEM"
! kernels(:,:,:) = 0.0d0
!
! ! Get max number of neighbors
! maxneigh1 = maxval(nneigh1)
! maxneigh2 = maxval(nneigh2)
!
! ! Calculate angular normalization constant
! ang_norm2 = get_angular_norm2(t_width)
!
! ! pmax = max nuclear charge
! pmax1 = get_pmax(x1, n1)
! pmax2 = get_pmax(x2, n2)
!
! ! Get two-body weight function
! ksi1 = get_ksi(x1, n1, nneigh1, two_body_power, cut_start, cut_distance)
! ksi2_pol = get_ksi_pol(x2, n2, nneigh2, two_body_power, cut_start, cut_distance, ef_scale, df)
!
! ! Allocate three-body Fourier terms
! allocate(cosp1(nm1, maxval(n1), pmax1, order, maxneigh1))
! allocate(sinp1(nm1, maxval(n1), pmax1, order, maxneigh1))
!
! ! Initialize and pre-calculate three-body Fourier terms
! call init_cosp_sinp(x1, n1, nneigh1, three_body_power, order, cut_start, cut_distance, &
! & cosp1, sinp1)
!
! ! Allocate three-body Fourier terms
! allocate(cosp2_pol(nm2, 19, maxval(n2), pmax2, order, maxneigh2))
! allocate(sinp2_pol(nm2, 19, maxval(n2), pmax2, order, maxneigh2))
!
! ! Initialize and pre-calculate three-body Fourier terms
! call init_cosp_sinp_pol(x2, n2, nneigh2, three_body_power, order, cut_start, cut_distance, &
! & cosp2_pol, sinp2_pol, ef_scale, df)
!
! ! Pre-calculate self-scalar terms
! self_scalar1 = get_selfscalar(x1, nm1, n1, nneigh1, ksi1, sinp1, cosp1, t_width, d_width, &
! & cut_distance, order, pd, ang_norm2,distance_scale, angular_scale, alchemy)
!
! allocate(self_scalar2_pol(nm2, 19, maxval(n2)))
! do a = 1, nm2
! ni = n2(a)
! do xyz = 1, 19
! do i = 1, ni
!
! self_scalar2_pol(a,xyz,i) = scalar(x2(a,i,:,:), x2(a,i,:,:), &
! & nneigh2(a,i), nneigh2(a,i), &
! & ksi2_pol(a,xyz,i,:), ksi2_pol(a,xyz,i,:), &
! & sinp2_pol(a,xyz,i,:,:,:), sinp2_pol(a,xyz,i,:,:,:), &
! & cosp2_pol(a,xyz,i,:,:,:), cosp2_pol(a,xyz,i,:,:,:), &
! & t_width, d_width, cut_distance, order, &
! & pd, ang_norm2, distance_scale, angular_scale, alchemy)
!
! enddo
! enddo
! enddo
!
! t_start = omp_get_wtime()
! write (*,"(A)", advance="no") "KERNEL EF DERIVATIVE"
!
! idx(1,:) = (/ 17, 3 /) !xx = (17) + (3) - 2*10
! idx(2,:) = (/ 11, 9 /) !yy = (11) + (9) - 2*10
! idx(3,:) = (/ 13, 7 /) !zz = (13) + (7) - 2*10
!
! ! Loop over atoms/basis functions
! ! !$OMP PARALLEL DO schedule(dynamic) PRIVATE(s12,ni,nj,idx_a,idx_b)
! do a = 1, nm1
! ni = n1(a)
! do i = 1, ni
! idx_a = sum(n1(:a)) - ni + i
!
!
! do b = 1, nm2
! nj = n2(b)
!
! do j = 1, nj
!
! ! Precalculate L2 for unperturbed kernel (charge index = 10)
! qidx = 10
!
! ! write(*,*) qidx
! ! isotropic (XX, YY and ZZ)
! s12 = scalar(x1(a,i,:,:), x2(b,j,:,:), &
! & nneigh1(a,i), nneigh2(b,j), &
! & ksi1(a,i,:), ksi2_pol(b,qidx,j,:), &
! & sinp1(a,i,:,:,:), sinp2_pol(b,qidx,j,:,:,:), &
! & cosp1(a,i,:,:,:), cosp2_pol(b,qidx,j,:,:,:), &
! & t_width, d_width, cut_distance, order, &
! & pd, ang_norm2, distance_scale, angular_scale, alchemy)
!
! unperturbed(:) = kernel(self_scalar1(a,i), self_scalar2_pol(b,qidx,j), s12, &
! & kernel_idx, parameters)
! ! write(*,*) s12, unperturbed(:)
!
! do xyz = 1, 3
!
! ! idx_b = (b - 1) * 3 + xyz
! idx_b = (sum(n2(:b)) - nj + j) * 3 + xyz
!
! qidx = idx(xyz,1)
! ! write(*,*) xyz, qidx
!
! s12 = scalar(x1(a,i,:,:), x2(b,j,:,:), &
! & nneigh1(a,i), nneigh2(b,j), &
! & ksi1(a,i,:), ksi2_pol(b,qidx,j,:), &
! & sinp1(a,i,:,:,:), sinp2_pol(b,qidx,j,:,:,:), &
! & cosp1(a,i,:,:,:), cosp2_pol(b,qidx,j,:,:,:), &
! & t_width, d_width, cut_distance, order, &
! & pd, ang_norm2, distance_scale, angular_scale, alchemy)
!
! kernels(:, idx_a, idx_b) = kernels(:, idx_a, idx_b) &
! & + kernel(self_scalar1(a,i), self_scalar2_pol(b,qidx,j), s12, &
! & kernel_idx, parameters)
!
! test_plus(:) = kernel(self_scalar1(a,i), self_scalar2_pol(b,qidx,j), s12, &
! & kernel_idx, parameters)
!
! qidx = idx(xyz,2)
! ! write(*,*) qidx
! ! write(*,*) xyz, qidx
!
! ! write(*,*) s12, kernel(self_scalar1(a,i), self_scalar2_pol(b,qidx,j), s12, kernel_idx, parameters)
!
! s12 = scalar(x1(a,i,:,:), x2(b,j,:,:), &
! & nneigh1(a,i), nneigh2(b,j), &
! & ksi1(a,i,:), ksi2_pol(b,qidx,j,:), &
! & sinp1(a,i,:,:,:), sinp2_pol(b,qidx,j,:,:,:), &
! & cosp1(a,i,:,:,:), cosp2_pol(b,qidx,j,:,:,:), &
! & t_width, d_width, cut_distance, order, &
! & pd, ang_norm2, distance_scale, angular_scale, alchemy)
!
! kernels(:, idx_a, idx_b) = kernels(:, idx_a, idx_b) &
! & + kernel(self_scalar1(a,i), self_scalar2_pol(b,qidx,j), s12, &
! & kernel_idx, parameters)
!
! test_minus(:) = kernel(self_scalar1(a,i), self_scalar2_pol(b,qidx,j), s12, &
! & kernel_idx, parameters)
!
! ! write(*,*) s12, kernel(self_scalar1(a,i), self_scalar2_pol(b,qidx,j), s12, kernel_idx, parameters)
!
! write(*,*) kernels(:, idx_a, idx_b)
! kernels(:, idx_a, idx_b) = kernels(:, idx_a, idx_b) - 2* unperturbed(:)
! write(*,*) kernels(:, idx_a, idx_b)
! ! write(*,*) unperturbed(:)
! ! write(*,*) - 2* unperturbed(:)
! ! write(*,*) test_plus(:)
! ! write(*,*) test_minus(:)
! ! write(*,*) kernels(:, idx_a, idx_b)
!
! enddo
! enddo
! enddo
!
! enddo
! enddo
! ! !$OMP END PARALLEL DO
!
! t_end = omp_get_wtime()
! write (*,"(A,F12.4,A)") " Time = ", t_end - t_start, " s"
!
! write(*,*) "DF = ", df
!
! write (*,*) kernels(1,1,1)
! kernels(:,:,:) = kernels(:,:,:) / (df * df)
! write (*,*) kernels(1,1,1)
!
! deallocate(self_scalar1)
! deallocate(self_scalar2_pol)
! deallocate(ksi1)
! deallocate(ksi2_pol)
! deallocate(cosp1)
! deallocate(cosp2_pol)
! deallocate(sinp1)
! deallocate(sinp2_pol)
!
! end subroutine fget_kernels_fchl_ef_2ndderiv
================================================
FILE: qml/fchl/ffchl_force_kernels.f90
================================================
subroutine fget_gaussian_process_kernels_fchl(x1, x2, verbose, n1, n2, nneigh1, nneigh2, &
& nm1, nm2, naq2, nsigmas, &
& t_width, d_width, cut_start, cut_distance, order, pd, &
& distance_scale, angular_scale, alchemy, two_body_power, three_body_power, dx, &
& kernel_idx, parameters, kernels)
use ffchl_module, only: scalar, get_angular_norm2, &
& get_pmax, get_ksi, init_cosp_sinp, get_selfscalar, &
& get_pmax_displaced, get_ksi_displaced, init_cosp_sinp_displaced, get_selfscalar_displaced
use ffchl_kernels, only: kernel
implicit none
! fchl descriptors for the training set, format (nm1,maxatoms,5,maxneighbors)
double precision, dimension(:,:,:,:), intent(in) :: x1
! fchl descriptors for the training set, format (nm2,3,2,maxatoms,maxatoms,5,maxneighbors)
double precision, dimension(:,:,:,:,:,:,:), intent(in) :: x2
! Whether to be verbose with output
logical, intent(in) :: verbose
! List of numbers of atoms in each molecule
integer, dimension(:), intent(in) :: n1
integer, dimension(:), intent(in) :: n2
! Number of neighbors for each atom in each compound
integer, dimension(:,:), intent(in) :: nneigh1
integer, dimension(:,:,:,:,:), intent(in) :: nneigh2
! Number of molecules
integer, intent(in) :: nm1
integer, intent(in) :: nm2
! Total number of force components
integer, intent(in) :: naq2
! Number of kernels
integer, intent(in) :: nsigmas
! Angular Gaussian width
double precision, intent(in) :: t_width
! Distance Gaussian width
double precision, intent(in) :: d_width
! Fraction of cut_distance at which cut-off starts
double precision, intent(in) :: cut_start
double precision, intent(in) :: cut_distance
! Truncation order for Fourier terms
integer, intent(in) :: order
! Periodic table distance matrix
double precision, dimension(:,:), intent(in) :: pd
! Scaling for angular and distance terms
double precision, intent(in) :: distance_scale
double precision, intent(in) :: angular_scale
! Switch alchemy on or off
logical, intent(in) :: alchemy
! Decaying power laws for two- and three-body terms
double precision, intent(in) :: two_body_power
double precision, intent(in) :: three_body_power
! Displacement for numerical differentiation
double precision, intent(in) :: dx
! Kernel ID and corresponding parameters
integer, intent(in) :: kernel_idx
double precision, dimension(:,:), intent(in) :: parameters
! Resulting kernel matrix
double precision, dimension(nsigmas,nm1+naq2,nm1+naq2), intent(out) :: kernels
! Internal counters
integer :: i1, i2, j1, j2
integer :: na, nb
integer :: a, b
! Temporary variables necessary for parallelization
double precision :: s12
! Pre-computed terms in the full distance matrix
double precision, allocatable, dimension(:,:) :: self_scalar1
double precision, allocatable, dimension(:,:,:,:,:) :: self_scalar2
! Pre-computed two-body weights
double precision, allocatable, dimension(:,:,:) :: ksi1
double precision, allocatable, dimension(:,:,:,:,:,:) :: ksi2
! Pre-computed terms for the Fourier expansion of the three-body term
double precision, allocatable, dimension(:,:,:,:,:) :: sinp1
double precision, allocatable, dimension(:,:,:,:,:) :: cosp1
! Pre-computed terms for the Fourier expansion of the three-body term
double precision, allocatable, dimension(:,:,:,:,:,:,:) :: sinp2
double precision, allocatable, dimension(:,:,:,:,:,:,:) :: cosp2
! Indexes for numerical differentiation
integer :: xyz_pm1
integer :: xyz_pm2
integer :: idx1, idx2
integer :: xyz1, pm1
integer :: xyz2, pm2
! Max index in the periodic table
integer :: pmax1
integer :: pmax2
! Angular normalization constant
double precision :: ang_norm2
! Max number of neighbors
integer :: maxneigh1
integer :: maxneigh2
! Angular normalization constant
ang_norm2 = get_angular_norm2(t_width)
kernels = 0.0d0
! Max number of neighbors in the representations
maxneigh1 = maxval(nneigh1)
maxneigh2 = maxval(nneigh2)
! pmax = max nuclear charge
pmax1 = get_pmax(x1, n1)
pmax2 = get_pmax_displaced(x2, n2)
! Get two-body weight function
ksi1 = get_ksi(x1, n1, nneigh1, two_body_power, cut_start, cut_distance, verbose)
ksi2 = get_ksi_displaced(x2, n2, nneigh2, two_body_power, cut_start, cut_distance, verbose)
! Allocate three-body Fourier terms
allocate(cosp1(nm1, maxval(n1), pmax1, order, maxneigh1))
allocate(sinp1(nm1, maxval(n1), pmax1, order, maxneigh1))
! Initialize and pre-calculate three-body Fourier terms
call init_cosp_sinp(x1, n1, nneigh1, three_body_power, order, cut_start, cut_distance, &
& cosp1, sinp1, verbose)
! Allocate three-body Fourier terms
allocate(cosp2(nm2, 3*2, maxval(n2), maxval(n2), pmax2, order, maxneigh2))
allocate(sinp2(nm2, 3*2, maxval(n2), maxval(n2), pmax2, order, maxneigh2))
! Initialize and pre-calculate three-body Fourier terms
call init_cosp_sinp_displaced(x2, n2, nneigh2, three_body_power, order, cut_start, &
& cut_distance, cosp2, sinp2, verbose)
! Pre-calculate self-scalar terms
self_scalar1 = get_selfscalar(x1, nm1, n1, nneigh1, ksi1, sinp1, cosp1, t_width, d_width, &
& cut_distance, order, pd, ang_norm2,distance_scale, angular_scale, alchemy, verbose)
! Pre-calculate self-scalar terms
self_scalar2 = get_selfscalar_displaced(x2, nm2, n2, nneigh2, ksi2, sinp2, cosp2, t_width, &
& d_width, cut_distance, order, pd, ang_norm2,distance_scale, angular_scale, alchemy, verbose)
!$OMP PARALLEL DO schedule(dynamic) PRIVATE(na,nb,s12)
do a = 1, nm1
na = n1(a)
do j1 = 1, na
do b = 1, nm1
nb = n1(b)
do j2 = 1, nb
s12 = scalar(x1(a,j1,:,:), x1(b,j2,:,:), &
& nneigh1(a,j1), nneigh1(b,j2), &
& ksi1(a,j1,:), ksi1(b,j2,:), &
& sinp1(a,j1,:,:,:), sinp1(b,j2,:,:,:), &
& cosp1(a,j1,:,:,:), cosp1(b,j2,:,:,:), &
& t_width, d_width, cut_distance, order, &
& pd, ang_norm2,distance_scale, angular_scale, alchemy)
kernels(:, a, b) = kernels(:, a, b) &
& + kernel(self_scalar1(a,j1), self_scalar1(b,j2), s12, &
& kernel_idx, parameters)
enddo
enddo
enddo
enddo
!$OMP END PARALLEL do
!$OMP PARALLEL DO schedule(dynamic) PRIVATE(na,nb,xyz_pm2,s12),&
!$OMP& PRIVATE(idx1,idx2)
do a = 1, nm1
na = n1(a)
idx1 = a
do j1 = 1, na
do b = 1, nm2
nb = n2(b)
do xyz2 = 1, 3
do pm2 = 1, 2
xyz_pm2 = 2*xyz2 + pm2 - 2
do i2 = 1, nb
idx2 = (sum(n2(:b)) - n2(b))* 3 + (i2 - 1) * 3 + xyz2 + nm1
do j2 = 1, nb
s12 = scalar(x1(a,j1,:,:), x2(b,xyz2,pm2,i2,j2,:,:), &
& nneigh1(a,j1), nneigh2(b,xyz2,pm2,i2,j2), &
& ksi1(a,j1,:), ksi2(b,xyz2,pm2,i2,j2,:), &
& sinp1(a,j1,:,:,:), sinp2(b,xyz_pm2,i2,j2,:,:,:), &
& cosp1(a,j1,:,:,:), cosp2(b,xyz_pm2,i2,j2,:,:,:), &
& t_width, d_width, cut_distance, order, &
& pd, ang_norm2,distance_scale, angular_scale, alchemy)
if (pm2 == 2) then
kernels(:, idx1, idx2) = kernels(:, idx1,idx2) &
& + kernel(self_scalar1(a,j1), self_scalar2(b,xyz2,pm2,i2,j2), s12, &
& kernel_idx, parameters)
kernels(:,idx2,idx1) = kernels(:,idx1,idx2)
else
kernels(:, idx1, idx2) = kernels(:, idx1,idx2) &
& - kernel(self_scalar1(a,j1), self_scalar2(b,xyz2,pm2,i2,j2), s12, &
& kernel_idx, parameters)
kernels(:,idx2,idx1) = kernels(:,idx1,idx2)
end if
enddo
enddo
enddo
enddo
enddo
enddo
enddo
!$OMP END PARALLEL do
kernels(:,:nm1,nm1+1:) = kernels(:,:nm1,nm1+1:) / (2 * dx)
kernels(:,nm1+1:,:nm1) = kernels(:,nm1+1:,:nm1) / (2 * dx)
!$OMP PARALLEL DO schedule(dynamic) PRIVATE(na,nb,xyz_pm1,xyz_pm2,s12),&
!$OMP& PRIVATE(idx1,idx2)
do a = 1, nm1
na = n1(a)
do xyz1 = 1, 3
do pm1 = 1, 2
xyz_pm1 = 2*xyz1 + pm1 - 2
do i1 = 1, na
idx1 = (sum(n1(:a)) - n1(a))* 3 + (i1 - 1) * 3 + xyz1 + nm1
do j1 = 1, na
do b = a, nm1
nb = n1(b)
do xyz2 = 1, 3
do pm2 = 1, 2
xyz_pm2 = 2*xyz2 + pm2 - 2
do i2 = 1, nb
idx2 = (sum(n1(:b)) - n1(b))* 3 + (i2 - 1) * 3 + xyz2 + nm1
do j2 = 1, nb
s12 = scalar(x2(a,xyz1,pm1,i1,j1,:,:), x2(b,xyz2,pm2,i2,j2,:,:), &
& nneigh2(a,xyz1,pm1,i1,j1), nneigh2(b,xyz2,pm2,i2,j2), &
& ksi2(a,xyz1,pm1,i1,j1,:), ksi2(b,xyz2,pm2,i2,j2,:), &
& sinp2(a,xyz_pm1,i1,j1,:,:,:), sinp2(b,xyz_pm2,i2,j2,:,:,:), &
& cosp2(a,xyz_pm1,i1,j1,:,:,:), cosp2(b,xyz_pm2,i2,j2,:,:,:), &
& t_width, d_width, cut_distance, order, &
& pd, ang_norm2,distance_scale, angular_scale, alchemy)
if (pm1 == pm2) then
kernels(:, idx1, idx2) = kernels(:, idx1, idx2) &
& + kernel(self_scalar2(a,xyz1,pm1,i1,j1), self_scalar2(b,xyz2,pm2,i2,j2), s12,&
& kernel_idx, parameters)
if (a /= b) then
kernels(:, idx2, idx1) = kernels(:, idx2, idx1) &
& + kernel(self_scalar2(a,xyz1,pm1,i1,j1), self_scalar2(b,xyz2,pm2,i2,j2), s12,&
& kernel_idx, parameters)
endif
else
kernels(:, idx1, idx2) = kernels(:, idx1, idx2) &
& - kernel(self_scalar2(a,xyz1,pm1,i1,j1), self_scalar2(b,xyz2,pm2,i2,j2), s12,&
& kernel_idx, parameters)
if (a /= b) then
kernels(:, idx2, idx1) = kernels(:, idx2, idx1) &
& - kernel(self_scalar2(a,xyz1,pm1,i1,j1), self_scalar2(b,xyz2,pm2,i2,j2), s12,&
& kernel_idx, parameters)
endif
end if
enddo
enddo
enddo
enddo
enddo
enddo
enddo
enddo
enddo
enddo
!$OMP END PARALLEL do
kernels(:,nm1+1:,nm1+1:) = kernels(:,nm1+1:,nm1+1:) / (4 * dx**2)
end subroutine fget_gaussian_process_kernels_fchl
subroutine fget_local_gradient_kernels_fchl(x1, x2, verbose, n1, n2, nneigh1, nneigh2, &
& nm1, nm2, naq2, nsigmas, &
& t_width, d_width, cut_start, cut_distance, order, pd, &
& distance_scale, angular_scale, alchemy, two_body_power, three_body_power, dx, &
& kernel_idx, parameters, kernels)
use ffchl_module, only: scalar, get_angular_norm2, &
& get_pmax, get_ksi, init_cosp_sinp, get_selfscalar, &
& get_pmax_displaced, get_ksi_displaced, init_cosp_sinp_displaced, get_selfscalar_displaced
use ffchl_kernels, only: kernel
implicit none
! fchl descriptors for the training set, format (nm1,maxatoms,5,maxneighbors)
double precision, dimension(:,:,:,:), intent(in) :: x1
! fchl descriptors for the training set, format (nm2,3,2,maxatoms,maxatoms,5,maxneighbors)
double precision, dimension(:,:,:,:,:,:,:), intent(in) :: x2
! Whether to be verbose with output
logical, intent(in) :: verbose
! List of numbers of atoms in each molecule
integer, dimension(:), intent(in) :: n1
integer, dimension(:), intent(in) :: n2
! Number of neighbors for each atom in each compound
integer, dimension(:,:), intent(in) :: nneigh1
integer, dimension(:,:,:,:,:), intent(in) :: nneigh2
! Number of molecules
integer, intent(in) :: nm1
integer, intent(in) :: nm2
! Total number of force components
integer, intent(in) :: naq2
! Number of kernels
integer, intent(in) :: nsigmas
double precision, intent(in) :: t_width
! Distance Gaussian width
double precision, intent(in) :: d_width
! Fraction of cut_distance at which cut-off starts
double precision, intent(in) :: cut_start
double precision, intent(in) :: cut_distance
! Truncation order for Fourier terms
integer, intent(in) :: order
! Periodic table distance matrix
double precision, dimension(:,:), intent(in) :: pd
! Scaling for angular and distance terms
double precision, intent(in) :: distance_scale
double precision, intent(in) :: angular_scale
! Switch alchemy on or off
logical, intent(in) :: alchemy
! Decaying power laws for two- and three-body terms
double precision, intent(in) :: two_body_power
double precision, intent(in) :: three_body_power
! Displacement for numerical differentiation
double precision, intent(in) :: dx
! Kernel ID and corresponding parameters
integer, intent(in) :: kernel_idx
double precision, dimension(:,:), intent(in) :: parameters
! Resulting alpha vector
double precision, dimension(nsigmas,nm1,naq2), intent(out) :: kernels
! Internal counters
integer :: i2, j1, j2
integer :: na, nb
integer :: a, b
! Temporary variables necessary for parallelization
double precision :: s12
! Pre-computed terms in the full distance matrix
double precision, allocatable, dimension(:,:) :: self_scalar1
double precision, allocatable, dimension(:,:,:,:,:) :: self_scalar2
! Pre-computed two-body weights
double precision, allocatable, dimension(:,:,:) :: ksi1
double precision, allocatable, dimension(:,:,:,:,:,:) :: ksi2
! Pre-computed terms for the Fourier expansion of the three-body term
double precision, allocatable, dimension(:,:,:,:,:) :: sinp1
double precision, allocatable, dimension(:,:,:,:,:) :: cosp1
! Pre-computed terms for the Fourier expansion of the three-body term
double precision, allocatable, dimension(:,:,:,:,:,:,:) :: sinp2
double precision, allocatable, dimension(:,:,:,:,:,:,:) :: cosp2
! Indexes for numerical differentiation
integer :: idx1, idx2
integer :: xyz_pm2
integer :: xyz2, pm2
! Max index in the periodic table
integer :: pmax1
integer :: pmax2
! Angular normalization constant
double precision :: ang_norm2
! Max number of neighbors
integer :: maxneigh1
integer :: maxneigh2
kernels = 0.0d0
! Angular normalization constant
ang_norm2 = get_angular_norm2(t_width)
! Max number of neighbors in the representations
maxneigh1 = maxval(nneigh1)
maxneigh2 = maxval(nneigh2)
! pmax = max nuclear charge
pmax1 = get_pmax(x1, n1)
pmax2 = get_pmax_displaced(x2, n2)
! Get two-body weight function
ksi1 = get_ksi(x1, n1, nneigh1, two_body_power, cut_start, cut_distance, verbose)
ksi2 = get_ksi_displaced(x2, n2, nneigh2, two_body_power, cut_start, cut_distance, verbose)
! Allocate three-body Fourier terms
allocate(cosp1(nm1, maxval(n1), pmax1, order, maxneigh1))
allocate(sinp1(nm1, maxval(n1), pmax1, order, maxneigh1))
! Initialize and pre-calculate three-body Fourier terms
call init_cosp_sinp(x1, n1, nneigh1, three_body_power, order, cut_start, cut_distance, &
& cosp1, sinp1, verbose)
! Allocate three-body Fourier terms
allocate(cosp2(nm2, 3*2, maxval(n2), maxval(n2), pmax2, order, maxneigh2))
allocate(sinp2(nm2, 3*2, maxval(n2), maxval(n2), pmax2, order, maxneigh2))
! Initialize and pre-calculate three-body Fourier terms
call init_cosp_sinp_displaced(x2, n2, nneigh2, three_body_power, order, cut_start, &
& cut_distance, cosp2, sinp2, verbose)
! Pre-calculate self-scalar terms
self_scalar1 = get_selfscalar(x1, nm1, n1, nneigh1, ksi1, sinp1, cosp1, t_width, d_width, &
& cut_distance, order, pd, ang_norm2,distance_scale, angular_scale, alchemy, verbose)
! Pre-calculate self-scalar terms
self_scalar2 = get_selfscalar_displaced(x2, nm2, n2, nneigh2, ksi2, sinp2, cosp2, t_width, &
& d_width, cut_distance, order, pd, ang_norm2,distance_scale, angular_scale, alchemy, verbose)
!$OMP PARALLEL DO schedule(dynamic) PRIVATE(na,nb,xyz_pm2,s12),&
!$OMP& PRIVATE(idx1,idx2)
do a = 1, nm1
na = n1(a)
idx1 = a
do j1 = 1, na
do b = 1, nm2
nb = n2(b)
do xyz2 = 1, 3
do pm2 = 1, 2
xyz_pm2 = 2*xyz2 + pm2 - 2
do i2 = 1, nb
idx2 = (sum(n2(:b)) - n2(b))* 3 + (i2 - 1) * 3 + xyz2
do j2 = 1, nb
s12 = scalar(x1(a,j1,:,:), x2(b,xyz2,pm2,i2,j2,:,:), &
& nneigh1(a,j1), nneigh2(b,xyz2,pm2,i2,j2), &
& ksi1(a,j1,:), ksi2(b,xyz2,pm2,i2,j2,:), &
& sinp1(a,j1,:,:,:), sinp2(b,xyz_pm2,i2,j2,:,:,:), &
& cosp1(a,j1,:,:,:), cosp2(b,xyz_pm2,i2,j2,:,:,:), &
& t_width, d_width, cut_distance, order, &
& pd, ang_norm2,distance_scale, angular_scale, alchemy)
if (pm2 == 2) then
kernels(:,idx1,idx2) = kernels(:,idx1,idx2) &
& + kernel(self_scalar1(a,j1), self_scalar2(b,xyz2,pm2,i2,j2), s12, &
& kernel_idx, parameters)
else
kernels(:,idx1,idx2) = kernels(:,idx1,idx2) &
& - kernel(self_scalar1(a,j1), self_scalar2(b,xyz2,pm2,i2,j2), s12, &
& kernel_idx, parameters)
end if
enddo
enddo
enddo
enddo
enddo
enddo
enddo
!$OMP END PARALLEL do
kernels = kernels / (2 * dx)
end subroutine fget_local_gradient_kernels_fchl
subroutine fget_local_hessian_kernels_fchl(x1, x2, verbose, n1, n2, nneigh1, nneigh2, &
& nm1, nm2, naq1, naq2, nsigmas, &
& t_width, d_width, cut_start, cut_distance, order, pd, &
& distance_scale, angular_scale, alchemy, two_body_power, three_body_power, dx, &
& kernel_idx, parameters, kernels)
use ffchl_module, only: scalar, get_angular_norm2, &
& get_pmax_displaced, get_ksi_displaced, init_cosp_sinp_displaced, get_selfscalar_displaced
use ffchl_kernels, only: kernel
implicit none
! fchl descriptors for the training set, format (nm1,3,2,maxatoms,maxatoms,5,maxneighbors)
double precision, dimension(:,:,:,:,:,:,:), intent(in) :: x1
double precision, dimension(:,:,:,:,:,:,:), intent(in) :: x2
! Whether to be verbose with output
logical, intent(in) :: verbose
! List of numbers of atoms in each molecule
integer, dimension(:), intent(in) :: n1
integer, dimension(:), intent(in) :: n2
! Number of neighbors for each atom in each compound
integer, dimension(:,:,:,:,:), intent(in) :: nneigh1
integer, dimension(:,:,:,:,:), intent(in) :: nneigh2
! Number of molecules
integer, intent(in) :: nm1
integer, intent(in) :: nm2
! Total number of force components
integer, intent(in) :: naq1
integer, intent(in) :: naq2
! Number of kernels
integer, intent(in) :: nsigmas
double precision, intent(in) :: t_width
! Distance Gaussian width
double precision, intent(in) :: d_width
! Fraction of cut_distance at which cut-off starts
double precision, intent(in) :: cut_start
double precision, intent(in) :: cut_distance
! Truncation order for Fourier terms
integer, intent(in) :: order
! Periodic table distance matrix
double precision, dimension(:,:), intent(in) :: pd
! Scaling for angular and distance terms
double precision, intent(in) :: distance_scale
double precision, intent(in) :: angular_scale
! Switch alchemy on or off
logical, intent(in) :: alchemy
! Decaying power laws for two- and three-body terms
double precision, intent(in) :: two_body_power
double precision, intent(in) :: three_body_power
! Displacement for numerical differentiation
double precision, intent(in) :: dx
! Kernel ID and corresponding parameters
integer, intent(in) :: kernel_idx
double precision, dimension(:,:), intent(in) :: parameters
! Resulting alpha vector
double precision, dimension(nsigmas,naq1,naq2), intent(out) :: kernels
! Internal counters
integer :: i1, i2, j1, j2
integer :: na, nb
integer :: a, b
! Temporary variables necessary for parallelization
double precision :: s12
! Pre-computed terms in the full distance matrix
double precision, allocatable, dimension(:,:,:,:,:) :: self_scalar1
double precision, allocatable, dimension(:,:,:,:,:) :: self_scalar2
! Pre-computed two-body weights
double precision, allocatable, dimension(:,:,:,:,:,:) :: ksi1
double precision, allocatable, dimension(:,:,:,:,:,:) :: ksi2
! Pre-computed terms for the Fourier expansion of the three-body term
double precision, allocatable, dimension(:,:,:,:,:,:,:) :: sinp1
double precision, allocatable, dimension(:,:,:,:,:,:,:) :: cosp1
! Pre-computed terms for the Fourier expansion of the three-body term
double precision, allocatable, dimension(:,:,:,:,:,:,:) :: sinp2
double precision, allocatable, dimension(:,:,:,:,:,:,:) :: cosp2
! Indexes for numerical differentiation
integer :: xyz_pm1
integer :: xyz_pm2
integer :: idx1, idx2
integer :: xyz1, pm1
integer :: xyz2, pm2
! Max index in the periodic table
integer :: pmax1
integer :: pmax2
! Angular normalization constant
double precision :: ang_norm2
! Max number of neighbors
integer :: maxneigh1
integer :: maxneigh2
! Angular normalization constant
ang_norm2 = get_angular_norm2(t_width)
kernels = 0.0d0
! Max number of neighbors in the representations
maxneigh1 = maxval(nneigh1)
maxneigh2 = maxval(nneigh2)
! pmax = max nuclear charge
pmax1 = get_pmax_displaced(x1, n1)
pmax2 = get_pmax_displaced(x2, n2)
! Get two-body weight function
ksi1 = get_ksi_displaced(x1, n1, nneigh1, two_body_power, cut_start, cut_distance, verbose)
ksi2 = get_ksi_displaced(x2, n2, nneigh2, two_body_power, cut_start, cut_distance, verbose)
! Allocate three-body Fourier terms
allocate(cosp1(nm1, 3*2, maxval(n1), maxval(n1), pmax1, order, maxval(nneigh1)))
allocate(sinp1(nm1, 3*2, maxval(n1), maxval(n1), pmax1, order, maxval(nneigh1)))
! Initialize and pre-calculate three-body Fourier terms
call init_cosp_sinp_displaced(x1, n1, nneigh1, three_body_power, order, cut_start, cut_distance, &
& cosp1, sinp1, verbose)
! Initialize and pre-calculate three-body Fourier terms
allocate(cosp2(nm2, 3*2, maxval(n2), maxval(n2), pmax2, order, maxneigh2))
allocate(sinp2(nm2, 3*2, maxval(n2), maxval(n2), pmax2, order, maxneigh2))
! Initialize and pre-calculate three-body Fourier terms
call init_cosp_sinp_displaced(x2, n2, nneigh2, three_body_power, order, cut_start, &
& cut_distance, cosp2, sinp2, verbose)
! Pre-calculate self-scalar terms
self_scalar1 = get_selfscalar_displaced(x1, nm1, n1, nneigh1, ksi1, sinp1, cosp1, t_width, &
& d_width, cut_distance, order, pd, ang_norm2,distance_scale, angular_scale, alchemy, verbose)
! Pre-calculate self-scalar terms
self_scalar2 = get_selfscalar_displaced(x2, nm2, n2, nneigh2, ksi2, sinp2, cosp2, t_width, &
& d_width, cut_distance, order, pd, ang_norm2,distance_scale, angular_scale, alchemy, verbose)
!$OMP PARALLEL DO schedule(dynamic) PRIVATE(na,nb,xyz_pm1,xyz_pm2,s12),&
!$OMP& PRIVATE(idx1,idx2)
do a = 1, nm1
na = n1(a)
do xyz1 = 1, 3
do pm1 = 1, 2
xyz_pm1 = 2*xyz1 + pm1 - 2
do i1 = 1, na
idx1 = (sum(n1(:a)) - n1(a))* 3 + (i1 - 1) * 3 + xyz1
do j1 = 1, na
do b = 1, nm2
nb = n2(b)
do xyz2 = 1, 3
do pm2 = 1, 2
xyz_pm2 = 2*xyz2 + pm2 - 2
do i2 = 1, nb
idx2 = (sum(n2(:b)) - n2(b))* 3 + (i2 - 1) * 3 + xyz2
do j2 = 1, nb
s12 = scalar(x1(a,xyz1,pm1,i1,j1,:,:), x2(b,xyz2,pm2,i2,j2,:,:), &
& nneigh1(a,xyz1,pm1,i1,j1), nneigh2(b,xyz2,pm2,i2,j2), &
& ksi1(a,xyz1,pm1,i1,j1,:), ksi2(b,xyz2,pm2,i2,j2,:), &
& sinp1(a,xyz_pm1,i1,j1,:,:,:), sinp2(b,xyz_pm2,i2,j2,:,:,:), &
& cosp1(a,xyz_pm1,i1,j1,:,:,:), cosp2(b,xyz_pm2,i2,j2,:,:,:), &
& t_width, d_width, cut_distance, order, &
& pd, ang_norm2,distance_scale, angular_scale, alchemy)
if (pm1 == pm2) then
kernels(:, idx1, idx2) = kernels(:, idx1, idx2) &
& + kernel(self_scalar1(a,xyz1,pm1,i1,j1), self_scalar2(b,xyz2,pm2,i2,j2), s12,&
& kernel_idx, parameters)
else
kernels(:, idx1, idx2) = kernels(:, idx1, idx2) &
& - kernel(self_scalar1(a,xyz1,pm1,i1,j1), self_scalar2(b,xyz2,pm2,i2,j2), s12,&
& kernel_idx, parameters)
end if
enddo
enddo
enddo
enddo
enddo
enddo
enddo
enddo
enddo
enddo
!$OMP END PARALLEL do
kernels = kernels / (4 * dx**2)
end subroutine fget_local_hessian_kernels_fchl
subroutine fget_local_symmetric_hessian_kernels_fchl(x1, verbose, n1, nneigh1, &
& nm1, naq1, nsigmas, &
& t_width, d_width, cut_start, cut_distance, order, pd, &
& distance_scale, angular_scale, alchemy, two_body_power, three_body_power, dx, &
& kernel_idx, parameters, kernels)
use ffchl_module, only: scalar, get_angular_norm2, &
& get_pmax_displaced, get_ksi_displaced, init_cosp_sinp_displaced, get_selfscalar_displaced
use ffchl_kernels, only: kernel
implicit none
! fchl descriptors for the training set, format (nm1,3,2,maxatoms,maxatoms,5,maxneighbors)
double precision, dimension(:,:,:,:,:,:,:), intent(in) :: x1
! Whether to be verbose with output
logical, intent(in) :: verbose
! List of numbers of atoms in each molecule
integer, dimension(:), intent(in) :: n1
! Number of neighbors for each atom in each compound
integer, dimension(:,:,:,:,:), intent(in) :: nneigh1
! Number of molecules
integer, intent(in) :: nm1
! Total number of force components
integer, intent(in) :: naq1
! Number of kernels
integer, intent(in) :: nsigmas
! Angular Gaussian width
double precision, intent(in) :: t_width
! Distance Gaussian width
double precision, intent(in) :: d_width
! Fraction of cut_distance at which cut-off starts
double precision, intent(in) :: cut_start
double precision, intent(in) :: cut_distance
! Truncation order for Fourier terms
integer, intent(in) :: order
! Periodic table distance matrix
double precision, dimension(:,:), intent(in) :: pd
! Scaling for angular and distance terms
double precision, intent(in) :: distance_scale
double precision, intent(in) :: angular_scale
! Switch alchemy on or off
logical, intent(in) :: alchemy
! Decaying power laws for two- and three-body terms
double precision, intent(in) :: two_body_power
double precision, intent(in) :: three_body_power
! Displacement for numerical differentiation
double precision, intent(in) :: dx
! Kernel ID and corresponding parameters
integer, intent(in) :: kernel_idx
double precision, dimension(:,:), intent(in) :: parameters
! Resulting alpha vector
double precision, dimension(nsigmas,naq1,naq1), intent(out) :: kernels
! Internal counters
integer :: i1, i2, j1, j2
integer :: na, nb
integer :: a, b
! Temporary variables necessary for parallelization
double precision :: s12
! Pre-computed terms in the full distance matrix
double precision, allocatable, dimension(:,:,:,:,:) :: self_scalar1
! Pre-computed two-body weights
double precision, allocatable, dimension(:,:,:,:,:,:) :: ksi1
! Pre-computed terms for the Fourier expansion of the three-body term
double precision, allocatable, dimension(:,:,:,:,:,:,:) :: sinp1
double precision, allocatable, dimension(:,:,:,:,:,:,:) :: cosp1
! Indexes for numerical differentiation
integer :: xyz_pm1
integer :: xyz_pm2
integer :: xyz1, pm1
integer :: xyz2, pm2
integer :: idx1, idx2
! Max index in the periodic table
integer :: pmax1
! Angular normalization constant
double precision :: ang_norm2
! Max number of neighbors
integer :: maxneigh1
! Angular normalization constant
ang_norm2 = get_angular_norm2(t_width)
kernels = 0.0d0
! Max number of neighbors
maxneigh1 = maxval(nneigh1)
! pmax = max nuclear charge
pmax1 = get_pmax_displaced(x1, n1)
! Get two-body weight function
ksi1 = get_ksi_displaced(x1, n1, nneigh1, two_body_power, cut_start, cut_distance, verbose)
! Allocate three-body Fourier terms
allocate(cosp1(nm1, 3*2, maxval(n1), maxval(n1), pmax1, order, maxval(nneigh1)))
allocate(sinp1(nm1, 3*2, maxval(n1), maxval(n1), pmax1, order, maxval(nneigh1)))
! Initialize and pre-calculate three-body Fourier terms
call init_cosp_sinp_displaced(x1, n1, nneigh1, three_body_power, order, cut_start, cut_distance, &
& cosp1, sinp1, verbose)
! Pre-calculate self-scalar terms
self_scalar1 = get_selfscalar_displaced(x1, nm1, n1, nneigh1, ksi1, sinp1, cosp1, t_width,&
& d_width, cut_distance, order, pd, ang_norm2,distance_scale, angular_scale, alchemy, verbose)
!$OMP PARALLEL DO schedule(dynamic) PRIVATE(na,nb,xyz_pm1,xyz_pm2,s12),&
!$OMP& PRIVATE(idx1,idx2)
do a = 1, nm1
na = n1(a)
do xyz1 = 1, 3
do pm1 = 1, 2
xyz_pm1 = 2*xyz1 + pm1 - 2
do i1 = 1, na
idx1 = (sum(n1(:a)) - n1(a))* 3 + (i1 - 1) * 3 + xyz1
do j1 = 1, na
do b = a, nm1
nb = n1(b)
do xyz2 = 1, 3
do pm2 = 1, 2
xyz_pm2 = 2*xyz2 + pm2 - 2
do i2 = 1, nb
idx2 = (sum(n1(:b)) - n1(b))* 3 + (i2 - 1) * 3 + xyz2
do j2 = 1, nb
s12 = scalar(x1(a,xyz1,pm1,i1,j1,:,:), x1(b,xyz2,pm2,i2,j2,:,:), &
& nneigh1(a,xyz1,pm1,i1,j1), nneigh1(b,xyz2,pm2,i2,j2), &
& ksi1(a,xyz1,pm1,i1,j1,:), ksi1(b,xyz2,pm2,i2,j2,:), &
& sinp1(a,xyz_pm1,i1,j1,:,:,:), sinp1(b,xyz_pm2,i2,j2,:,:,:), &
& cosp1(a,xyz_pm1,i1,j1,:,:,:), cosp1(b,xyz_pm2,i2,j2,:,:,:), &
& t_width, d_width, cut_distance, order, &
& pd, ang_norm2,distance_scale, angular_scale, alchemy)
if (pm1 == pm2) then
kernels(:, idx1, idx2) = kernels(:, idx1, idx2) &
& + kernel(self_scalar1(a,xyz1,pm1,i1,j1), self_scalar1(b,xyz2,pm2,i2,j2), s12,&
& kernel_idx, parameters)
if (a /= b) then
kernels(:,idx2,idx1) = kernels(:,idx2,idx1) &
& + kernel(self_scalar1(a,xyz1,pm1,i1,j1), self_scalar1(b,xyz2,pm2,i2,j2), s12,&
& kernel_idx, parameters)
endif
else
kernels(:, idx1, idx2) = kernels(:, idx1, idx2) &
& - kernel(self_scalar1(a,xyz1,pm1,i1,j1), self_scalar1(b,xyz2,pm2,i2,j2), s12,&
& kernel_idx, parameters)
if (a /= b) then
kernels(:,idx2,idx1) = kernels(:,idx2,idx1) &
& - kernel(self_scalar1(a,xyz1,pm1,i1,j1), self_scalar1(b,xyz2,pm2,i2,j2), s12,&
& kernel_idx, parameters)
endif
end if
enddo
enddo
enddo
enddo
enddo
enddo
enddo
enddo
enddo
enddo
!$OMP END PARALLEL do
kernels = kernels / (4 * dx**2)
end subroutine fget_local_symmetric_hessian_kernels_fchl
subroutine fget_force_alphas_fchl(x1, x2, verbose, forces, energies, n1, n2, &
& nneigh1, nneigh2, nm1, nm2, na1, nsigmas, &
& t_width, d_width, cut_start, cut_distance, order, pd, &
& distance_scale, angular_scale, alchemy, two_body_power, three_body_power, dx, &
& kernel_idx, parameters, llambda, alphas)
use ffchl_module, only: scalar, get_angular_norm2, &
& get_pmax, get_ksi, init_cosp_sinp, get_selfscalar, &
& get_pmax_displaced, get_ksi_displaced, init_cosp_sinp_displaced, get_selfscalar_displaced
use ffchl_kernels, only: kernel
implicit none
! fchl descriptors for the training set, format (nm1,3,2,maxatoms,maxatoms,5,maxneighbors)
double precision, dimension(:,:,:,:), intent(in) :: x1
double precision, dimension(:,:,:,:,:,:,:), intent(in) :: x2
! Whether to be verbose with output
logical, intent(in) :: verbose
double precision, dimension(:,:), intent(in) :: forces
double precision, dimension(:), intent(in) :: energies
! List of numbers of atoms in each molecule
integer, dimension(:), intent(in) :: n1
integer, dimension(:), intent(in) :: n2
! Number of neighbors for each atom in each compound
integer, dimension(:,:), intent(in) :: nneigh1
integer, dimension(:,:,:,:,:), intent(in) :: nneigh2
! Number of molecules
integer, intent(in) :: nm1
integer, intent(in) :: nm2
! Number of atoms (and force components in each direction)
integer, intent(in) :: na1
! Number of kernels
integer, intent(in) :: nsigmas
! Angular Gaussian width
double precision, intent(in) :: t_width
! Distance Gaussian width
double precision, intent(in) :: d_width
! Fraction of cut_distance at which cut-off starts
double precision, intent(in) :: cut_start
double precision, intent(in) :: cut_distance
! Truncation order for Fourier terms
integer, intent(in) :: order
! Periodic table distance matrix
double precision, dimension(:,:), intent(in) :: pd
! Scaling for angular and distance terms
double precision, intent(in) :: distance_scale
double precision, intent(in) :: angular_scale
! Switch alchemy on or off
logical, intent(in) :: alchemy
! Decaying power laws for two- and three-body terms
double precision, intent(in) :: two_body_power
double precision, intent(in) :: three_body_power
! Displacement for numerical differentiation
double precision, intent(in) :: dx
! Kernel ID and corresponding parameters
integer, intent(in) :: kernel_idx
double precision, dimension(:,:), intent(in) :: parameters
! Regularization Lambda
double precision, intent(in) :: llambda
double precision, dimension(nsigmas,na1), intent(out) :: alphas
! Internal counters
integer :: i, j, k, i2, j1, j2
integer :: na, nb, ni, nj
integer :: a, b
! Temporary variables necessary for parallelization
double precision :: s12
! Pre-computed terms in the full distance matrix
double precision, allocatable, dimension(:,:) :: self_scalar1
double precision, allocatable, dimension(:,:,:,:,:) :: self_scalar2
! Pre-computed terms
double precision, allocatable, dimension(:,:,:) :: ksi1
double precision, allocatable, dimension(:,:,:,:,:,:) :: ksi2
double precision, allocatable, dimension(:,:,:,:,:) :: sinp1
double precision, allocatable, dimension(:,:,:,:,:) :: cosp1
double precision, allocatable, dimension(:,:,:,:,:,:,:) :: sinp2
double precision, allocatable, dimension(:,:,:,:,:,:,:) :: cosp2
! Indexes for numerical differentiation
integer :: xyz_pm2
integer :: xyz2, pm2
integer :: idx1
integer :: idx2
integer :: idx1_start
integer :: idx2_start
! 1/(2*dx)
double precision :: inv_2dx
! Max index in the periodic table
integer :: pmax1
integer :: pmax2
! Angular normalization constant
double precision :: ang_norm2
! Max number of neighbors
integer :: maxneigh1
integer :: maxneigh2
! Info variable for BLAS/LAPACK calls
integer :: info
! Feature vector multiplied by the kernel derivatives
double precision, allocatable, dimension(:,:) :: y
! Numerical derivatives of kernel
double precision, allocatable, dimension(:,:,:) :: kernel_delta
! Scratch space for products of the kernel derivatives
double precision, allocatable, dimension(:,:,:) :: kernel_scratch
! Kernel between molecules and atom
double precision, allocatable, dimension(:,:,:) :: kernel_ma
inv_2dx = 1.0d0 / (2.0d0 * dx)
! Angular normalization constant
ang_norm2 = get_angular_norm2(t_width)
! Max number of neighbors in the representations
maxneigh1 = maxval(nneigh1)
maxneigh2 = maxval(nneigh2)
! pmax = max nuclear charge
pmax1 = get_pmax(x1, n1)
pmax2 = get_pmax_displaced(x2, n2)
! Get two-body weight function
ksi1 = get_ksi(x1, n1, nneigh1, two_body_power, cut_start, cut_distance, verbose)
ksi2 = get_ksi_displaced(x2, n2, nneigh2, two_body_power, cut_start, cut_distance, verbose)
! Allocate three-body Fourier terms
allocate(cosp1(nm1, maxval(n1), pmax1, order, maxneigh1))
allocate(sinp1(nm1, maxval(n1), pmax1, order, maxneigh1))
! Initialize and pre-calculate three-body Fourier terms
call init_cosp_sinp(x1, n1, nneigh1, three_body_power, order, cut_start, cut_distance, &
& cosp1, sinp1, verbose)
! Allocate three-body Fourier terms
allocate(cosp2(nm2, 3*2, maxval(n2), maxval(n2), pmax2, order, maxneigh2))
allocate(sinp2(nm2, 3*2, maxval(n2), maxval(n2), pmax2, order, maxneigh2))
! Initialize and pre-calculate three-body Fourier terms
call init_cosp_sinp_displaced(x2, n2, nneigh2, three_body_power, order, cut_start, &
& cut_distance, cosp2, sinp2, verbose)
! Pre-calculate self-scalar terms
self_scalar1 = get_selfscalar(x1, nm1, n1, nneigh1, ksi1, sinp1, cosp1, t_width, d_width, &
& cut_distance, order, pd, ang_norm2,distance_scale, angular_scale, alchemy, verbose)
! Pre-calculate self-scalar terms
self_scalar2 = get_selfscalar_displaced(x2, nm2, n2, nneigh2, ksi2, sinp2, cosp2, t_width, &
& d_width, cut_distance, order, pd, ang_norm2,distance_scale, angular_scale, alchemy, verbose)
allocate(kernel_delta(na1,na1,nsigmas))
allocate(y(na1,nsigmas))
y = 0.0d0
allocate(kernel_scratch(na1,na1,nsigmas))
kernel_scratch = 0.0d0
! Calculate kernel derivatives and add to kernel matrix
do xyz2 = 1, 3
kernel_delta = 0.0d0
!$OMP PARALLEL DO schedule(dynamic) PRIVATE(na,nb,xyz_pm2,s12), &
!$OMP& PRIVATE(idx1,idx2,idx1_start,idx2_start)
do a = 1, nm1
na = n1(a)
idx1_start = sum(n1(:a)) - na
do j1 = 1, na
idx1 = idx1_start + j1
do b = 1, nm2
nb = n2(b)
idx2_start = (sum(n2(:b)) - nb)
do pm2 = 1, 2
xyz_pm2 = 2*xyz2 + pm2 - 2
do i2 = 1, nb
idx2 = idx2_start + i2
do j2 = 1, nb
s12 = scalar(x1(a,j1,:,:), x2(b,xyz2,pm2,i2,j2,:,:), &
& nneigh1(a,j1), nneigh2(b,xyz2,pm2,i2,j2), &
& ksi1(a,j1,:), ksi2(b,xyz2,pm2,i2,j2,:), &
& sinp1(a,j1,:,:,:), sinp2(b,xyz_pm2,i2,j2,:,:,:), &
& cosp1(a,j1,:,:,:), cosp2(b,xyz_pm2,i2,j2,:,:,:), &
& t_width, d_width, cut_distance, order, &
& pd, ang_norm2,distance_scale, angular_scale, alchemy)
if (pm2 == 2) then
kernel_delta(idx1,idx2,:) = kernel_delta(idx1,idx2,:) &
& + kernel(self_scalar1(a,j1), self_scalar2(b,xyz2,pm2,i2,j2), s12,&
kernel_idx, parameters) * inv_2dx
else
kernel_delta(idx1,idx2,:) = kernel_delta(idx1,idx2,:) &
& - kernel(self_scalar1(a,j1), self_scalar2(b,xyz2,pm2,i2,j2), s12,&
kernel_idx, parameters) * inv_2dx
end if
enddo
enddo
enddo
enddo
enddo
enddo
!$OMP END PARALLEL do
do k = 1, nsigmas
call dsyrk("U", "N", na1, na1, 1.0d0, kernel_delta(1,1,k), na1, &
& 1.0d0, kernel_scratch(1,1,k), na1)
! kernel_scratch(:,:,k) = kernel_scratch(:,:,k) &
! & + matmul(kernel_delta(:,:,k),transpose(kernel_delta(:,:,k)))! * inv_2dx*inv_2dx
call dgemv("N", na1, na1, 1.0d0, kernel_delta(:,:,k), na1, &
& forces(:,xyz2), 1, 1.0d0, y(:,k), 1)
! y(:,k) = y(:,k) + matmul(kernel_delta(:,:,k), forces(:,xyz2))!* inv_2dx
enddo
enddo
deallocate(kernel_delta)
deallocate(self_scalar2)
deallocate(ksi2)
deallocate(cosp2)
deallocate(sinp2)
allocate(kernel_MA(nm1,na1,nsigmas))
kernel_MA = 0.0d0
!$OMP PARALLEL DO schedule(dynamic) PRIVATE(ni,nj,idx1,s12,idx1_start)
do a = 1, nm1
ni = n1(a)
idx1_start = sum(n1(:a)) - ni
do i = 1, ni
idx1 = idx1_start + i
do b = 1, nm1
nj = n1(b)
do j = 1, nj
s12 = scalar(x1(a,i,:,:), x1(b,j,:,:), &
& nneigh1(a,i), nneigh1(b,j), ksi1(a,i,:), ksi1(b,j,:), &
& sinp1(a,i,:,:,:), sinp1(b,j,:,:,:), &
& cosp1(a,i,:,:,:), cosp1(b,j,:,:,:), &
& t_width, d_width, cut_distance, order, &
& pd, ang_norm2, distance_scale, angular_scale, alchemy)
kernel_MA(b,idx1,:) = kernel_MA(b,idx1,:) &
& + kernel(self_scalar1(a,i), self_scalar1(b,j), s12,&
kernel_idx, parameters)
enddo
enddo
enddo
enddo
!$OMP END PARALLEL DO
deallocate(self_scalar1)
deallocate(ksi1)
deallocate(cosp1)
deallocate(sinp1)
do k = 1, nsigmas
! kernel_scratch(:,:,k) = kernel_scratch(:,:,k) &
! & + matmul(transpose(kernel_MA(:,:,k)),kernel_MA(:,:,k))
! y(:,k) = y(:,k) + matmul(transpose(kernel_MA(:,:,k)), energies(:))
call dsyrk("U", "T", na1, nm1, 1.0d0, kernel_MA(:,:,k), nm1, &
& 1.0d0, kernel_scratch(:,:,k), na1)
call dgemv("T", nm1, na1, 1.0d0, kernel_ma(:,:,k), nm1, &
& energies(:), 1, 1.0d0, y(:,k), 1)
enddo
deallocate(kernel_ma)
! Add regularization
do k = 1, nsigmas
do i = 1, na1
kernel_scratch(i,i,k) = kernel_scratch(i,i,k) + llambda
enddo
enddo
alphas = 0.0d0
! Solve alphas
do k = 1, nsigmas
call dpotrf("U", na1, kernel_scratch(:,:,k), na1, info)
if (info > 0) then
write (*,*) "QML WARNING: Error in LAPACK Cholesky decomposition DPOTRF()."
write (*,*) "QML WARNING: The", info, "-th leading order is not positive definite."
else if (info < 0) then
write (*,*) "QML WARNING: Error in LAPACK Cholesky decomposition DPOTRF()."
write (*,*) "QML WARNING: The", -info, "-th argument had an illegal value."
endif
call dpotrs("U", na1, 1, kernel_scratch(:,:,k), na1, y(:,k), na1, info)
if (info < 0) then
write (*,*) "QML WARNING: Error in LAPACK Cholesky solver DPOTRS()."
write (*,*) "QML WARNING: The", -info, "-th argument had an illegal value."
endif
alphas(k,:) = y(:,k)
enddo
deallocate(y)
deallocate(kernel_scratch)
end subroutine fget_force_alphas_fchl
subroutine fget_atomic_local_gradient_kernels_fchl(x1, x2, verbose, n1, n2, nneigh1, nneigh2, &
& nm1, nm2, na1, naq2, nsigmas, &
& t_width, d_width, cut_start, cut_distance, order, pd, &
& distance_scale, angular_scale, alchemy, two_body_power, three_body_power, dx, &
& kernel_idx, parameters, kernels)
use ffchl_module, only: scalar, get_angular_norm2, &
& get_pmax, get_ksi, init_cosp_sinp, get_selfscalar, &
& get_pmax_displaced, get_ksi_displaced, init_cosp_sinp_displaced, get_selfscalar_displaced
use ffchl_kernels, only: kernel
implicit none
! fchl descriptors for the training set, format (nm1,3,2,maxatoms,maxatoms,5,maxneighbors)
double precision, dimension(:,:,:,:), intent(in) :: x1
double precision, dimension(:,:,:,:,:,:,:), intent(in) :: x2
! Whether to be verbose with output
logical, intent(in) :: verbose
! Number of neighbors for each atom in each compound
integer, dimension(:,:), intent(in) :: nneigh1
integer, dimension(:,:,:,:,:), intent(in) :: nneigh2
! Number of molecules
integer, intent(in) :: nm1
integer, intent(in) :: nm2
integer, intent(in) :: na1
integer, intent(in) :: naq2
! List of numbers of atoms in each molecule
integer, dimension(:), intent(in) :: n1
integer, dimension(:), intent(in) :: n2
! Number of kernels
integer, intent(in) :: nsigmas
! Angular Gaussian width
double precision, intent(in) :: t_width
! Distance Gaussian width
double precision, intent(in) :: d_width
! Fraction of cut_distance at which cut-off starts
double precision, intent(in) :: cut_start
double precision, intent(in) :: cut_distance
! Truncation order for Fourier terms
integer, intent(in) :: order
! Periodic table distance matrix
double precision, dimension(:,:), intent(in) :: pd
! Scaling for angular and distance terms
double precision, intent(in) :: distance_scale
double precision, intent(in) :: angular_scale
! Switch alchemy on or off
logical, intent(in) :: alchemy
! Decaying power laws for two- and three-body terms
double precision, intent(in) :: two_body_power
double precision, intent(in) :: three_body_power
! Displacement for numerical differentiation
double precision, intent(in) :: dx
! Kernel ID and corresponding parameters
integer, intent(in) :: kernel_idx
double precision, dimension(:,:), intent(in) :: parameters
! Resulting alpha vector
double precision, dimension(nsigmas,na1,naq2), intent(out) :: kernels
! Internal counters
integer :: i2, j1, j2
integer :: na, nb
integer :: a, b
! Temporary variables necessary for parallelization
double precision :: s12
! Pre-computed terms in the full distance matrix
double precision, allocatable, dimension(:,:) :: self_scalar1
double precision, allocatable, dimension(:,:,:,:,:) :: self_scalar2
! Pre-computed two-body weights
double precision, allocatable, dimension(:,:,:) :: ksi1
double precision, allocatable, dimension(:,:,:,:,:,:) :: ksi2
! Pre-computed terms for the Fourier expansion of the three-body term
double precision, allocatable, dimension(:,:,:,:,:) :: sinp1
double precision, allocatable, dimension(:,:,:,:,:) :: cosp1
! Pre-computed terms for the Fourier expansion of the three-body term
double precision, allocatable, dimension(:,:,:,:,:,:,:) :: sinp2
double precision, allocatable, dimension(:,:,:,:,:,:,:) :: cosp2
! Indexes for numerical differentiation
integer :: xyz_pm2
integer :: xyz2, pm2
integer :: idx1, idx2
integer :: idx1_start,idx1_end
integer :: idx2_start,idx2_end
! Max index in the periodic table
integer :: pmax1
integer :: pmax2
! Angular normalization constant
double precision :: ang_norm2
! Max number of neighbors
integer :: maxneigh1
integer :: maxneigh2
kernels = 0.0d0
! Angular normalization constant
ang_norm2 = get_angular_norm2(t_width)
! Max number of neighbors in the representations
maxneigh1 = maxval(nneigh1)
maxneigh2 = maxval(nneigh2)
! pmax = max nuclear charge
pmax1 = get_pmax(x1, n1)
pmax2 = get_pmax_displaced(x2, n2)
! Get two-body weight function
ksi1 = get_ksi(x1, n1, nneigh1, two_body_power, cut_start, cut_distance, verbose)
ksi2 = get_ksi_displaced(x2, n2, nneigh2, two_body_power, cut_start, cut_distance, verbose)
! Allocate three-body Fourier terms
allocate(cosp1(nm1, maxval(n1), pmax1, order, maxneigh1))
allocate(sinp1(nm1, maxval(n1), pmax1, order, maxneigh1))
! Initialize and pre-calculate three-body Fourier terms
call init_cosp_sinp(x1, n1, nneigh1, three_body_power, order, cut_start, cut_distance, &
& cosp1, sinp1, verbose)
! Allocate three-body Fourier terms
allocate(cosp2(nm2, 3*2, maxval(n2), maxval(n2), pmax2, order, maxneigh2))
allocate(sinp2(nm2, 3*2, maxval(n2), maxval(n2), pmax2, order, maxneigh2))
! Initialize and pre-calculate three-body Fourier terms
call init_cosp_sinp_displaced(x2, n2, nneigh2, three_body_power, order, cut_start, &
& cut_distance, cosp2, sinp2, verbose)
! Pre-calculate self-scalar terms
self_scalar1 = get_selfscalar(x1, nm1, n1, nneigh1, ksi1, sinp1, cosp1, t_width, d_width, &
& cut_distance, order, pd, ang_norm2,distance_scale, angular_scale, alchemy, verbose)
! Pre-calculate self-scalar terms
self_scalar2 = get_selfscalar_displaced(x2, nm2, n2, nneigh2, ksi2, sinp2, cosp2, t_width, &
& d_width, cut_distance, order, pd, ang_norm2,distance_scale, angular_scale, alchemy, verbose)
!$OMP PARALLEL DO schedule(dynamic) PRIVATE(na,nb,xyz_pm2,s12),&
!$OMP& PRIVATE(idx1,idx2,idx1_start,idx1_end,idx2_start,idx2_end)
do a = 1, nm1
na = n1(a)
idx1_end = sum(n1(:a))
idx1_start = idx1_end - na + 1
do j1 = 1, na
idx1 = idx1_start - 1 + j1
do b = 1, nm2
nb = n2(b)
idx2_end = sum(n2(:b))
idx2_start = idx2_end - nb + 1
do xyz2 = 1, 3
do pm2 = 1, 2
xyz_pm2 = 2*xyz2 + pm2 - 2
do i2 = 1, nb
idx2 = (idx2_start-1)*3 + (i2-1)*3 + xyz2
do j2 = 1, nb
s12 = scalar(x1(a,j1,:,:), x2(b,xyz2,pm2,i2,j2,:,:), &
& nneigh1(a,j1), nneigh2(b,xyz2,pm2,i2,j2), &
& ksi1(a,j1,:), ksi2(b,xyz2,pm2,i2,j2,:), &
& sinp1(a,j1,:,:,:), sinp2(b,xyz_pm2,i2,j2,:,:,:), &
& cosp1(a,j1,:,:,:), cosp2(b,xyz_pm2,i2,j2,:,:,:), &
& t_width, d_width, cut_distance, order, &
& pd, ang_norm2,distance_scale, angular_scale, alchemy)
if (pm2 == 2) then
kernels(:,idx1,idx2) = kernels(:,idx1,idx2) &
& + kernel(self_scalar1(a,j1), self_scalar2(b,xyz2,pm2,i2,j2), s12,&
& kernel_idx, parameters)
else
kernels(:,idx1,idx2) = kernels(:,idx1,idx2) &
& - kernel(self_scalar1(a,j1), self_scalar2(b,xyz2,pm2,i2,j2), s12,&
& kernel_idx, parameters)
end if
enddo
enddo
enddo
enddo
enddo
enddo
enddo
!$OMP END PARALLEL do
kernels = kernels / (2 * dx)
end subroutine fget_atomic_local_gradient_kernels_fchl
subroutine fget_atomic_local_gradient_5point_kernels_fchl(x1, x2, verbose, n1, n2, nneigh1, nneigh2, &
& nm1, nm2, na1, naq2, nsigmas, &
& t_width, d_width, cut_start, cut_distance, order, pd, &
& distance_scale, angular_scale, alchemy, two_body_power, three_body_power, dx, &
& kernel_idx, parameters, kernels)
use ffchl_module, only: scalar, get_angular_norm2, &
& get_pmax, get_ksi, init_cosp_sinp, get_selfscalar, &
& get_pmax_displaced, get_ksi_displaced, init_cosp_sinp_displaced, get_selfscalar_displaced
use ffchl_kernels, only: kernel
implicit none
! fchl descriptors for the training set, format (nm1,3,2,maxatoms,maxatoms,5,maxneighbors)
double precision, dimension(:,:,:,:), intent(in) :: x1
double precision, dimension(:,:,:,:,:,:,:), intent(in) :: x2
! Whether to be verbose with output
logical, intent(in) :: verbose
! Number of neighbors for each atom in each compound
integer, dimension(:,:), intent(in) :: nneigh1
integer, dimension(:,:,:,:,:), intent(in) :: nneigh2
! Number of molecules
integer, intent(in) :: nm1
integer, intent(in) :: nm2
integer, intent(in) :: na1
integer, intent(in) :: naq2
! List of numbers of atoms in each molecule
integer, dimension(:), intent(in) :: n1
integer, dimension(:), intent(in) :: n2
! Number of kernels
integer, intent(in) :: nsigmas
! Angular Gaussian width
double precision, intent(in) :: t_width
! Distance Gaussian width
double precision, intent(in) :: d_width
! Fraction of cut_distance at which cut-off starts
double precision, intent(in) :: cut_start
double precision, intent(in) :: cut_distance
! Truncation order for Fourier terms
integer, intent(in) :: order
! Periodic table distance matrix
double precision, dimension(:,:), intent(in) :: pd
! Scaling for angular and distance terms
double precision, intent(in) :: distance_scale
double precision, intent(in) :: angular_scale
! Switch alchemy on or off
logical, intent(in) :: alchemy
! Decaying power laws for two- and three-body terms
double precision, intent(in) :: two_body_power
double precision, intent(in) :: three_body_power
! Displacement for numerical differentiation
double precision, intent(in) :: dx
! Kernel ID and corresponding parameters
integer, intent(in) :: kernel_idx
double precision, dimension(:,:), intent(in) :: parameters
! Resulting alpha vector
double precision, dimension(nsigmas,na1,naq2), intent(out) :: kernels
! Internal counters
integer :: i2, j1, j2
integer :: na, nb
integer :: a, b
! Temporary variables necessary for parallelization
double precision :: s12
! Pre-computed terms in the full distance matrix
double precision, allocatable, dimension(:,:) :: self_scalar1
double precision, allocatable, dimension(:,:,:,:,:) :: self_scalar2
! Pre-computed two-body weights
double precision, allocatable, dimension(:,:,:) :: ksi1
double precision, allocatable, dimension(:,:,:,:,:,:) :: ksi2
! Pre-computed terms for the Fourier expansion of the three-body term
double precision, allocatable, dimension(:,:,:,:,:) :: sinp1
double precision, allocatable, dimension(:,:,:,:,:) :: cosp1
! Pre-computed terms for the Fourier expansion of the three-body term
double precision, allocatable, dimension(:,:,:,:,:,:,:) :: sinp2
double precision, allocatable, dimension(:,:,:,:,:,:,:) :: cosp2
! Indexes for numerical differentiation
integer :: xyz_pm2
integer :: xyz2, pm2
integer :: idx1, idx2
integer :: idx1_start,idx1_end
integer :: idx2_start,idx2_end
! Max index in the periodic table
integer :: pmax1
integer :: pmax2
! Angular normalization constant
double precision :: ang_norm2
! Max number of neighbors
integer :: maxneigh1
integer :: maxneigh2
! For numerical differentiation
double precision, parameter, dimension(5) :: fact = (/ 1.0d0, -8.0d0, 0.0d0, 8.0d0, -1.0d0/)
! fact(1) = 1.0d0
! fact(2) = -8.0d0
! fact(3) = 0.0d0
! fact(4) = 8.0d0
! fact(5) = -1.0d0
kernels = 0.0d0
! Angular normalization constant
ang_norm2 = get_angular_norm2(t_width)
! Max number of neighbors in the representations
maxneigh1 = maxval(nneigh1)
maxneigh2 = maxval(nneigh2)
! pmax = max nuclear charge
pmax1 = get_pmax(x1, n1)
pmax2 = get_pmax_displaced(x2, n2)
! Get two-body weight function
ksi1 = get_ksi(x1, n1, nneigh1, two_body_power, cut_start, cut_distance, verbose)
ksi2 = get_ksi_displaced(x2, n2, nneigh2, two_body_power, cut_start, cut_distance, verbose)
! Allocate three-body Fourier terms
allocate(cosp1(nm1, maxval(n1), pmax1, order, maxneigh1))
allocate(sinp1(nm1, maxval(n1), pmax1, order, maxneigh1))
! Initialize and pre-calculate three-body Fourier terms
call init_cosp_sinp(x1, n1, nneigh1, three_body_power, order, cut_start, cut_distance, &
& cosp1, sinp1, verbose)
! Allocate three-body Fourier terms
allocate(cosp2(nm2, 3*5, maxval(n2), maxval(n2), pmax2, order, maxneigh2))
allocate(sinp2(nm2, 3*5, maxval(n2), maxval(n2), pmax2, order, maxneigh2))
! Initialize and pre-calculate three-body Fourier terms
call init_cosp_sinp_displaced(x2, n2, nneigh2, three_body_power, order, cut_start, &
& cut_distance, cosp2, sinp2, verbose)
! Pre-calculate self-scalar terms
self_scalar1 = get_selfscalar(x1, nm1, n1, nneigh1, ksi1, sinp1, cosp1, t_width, d_width, &
& cut_distance, order, pd, ang_norm2,distance_scale, angular_scale, alchemy, verbose)
! Pre-calculate self-scalar terms
self_scalar2 = get_selfscalar_displaced(x2, nm2, n2, nneigh2, ksi2, sinp2, cosp2, t_width, &
& d_width, cut_distance, order, pd, ang_norm2,distance_scale, angular_scale, alchemy, verbose)
!$OMP PARALLEL DO schedule(dynamic) PRIVATE(na,nb,xyz_pm2,s12),&
!$OMP& PRIVATE(idx1,idx2,idx1_start,idx1_end,idx2_start,idx2_end)
do a = 1, nm1
na = n1(a)
idx1_end = sum(n1(:a))
idx1_start = idx1_end - na + 1
do j1 = 1, na
idx1 = idx1_start - 1 + j1
do b = 1, nm2
nb = n2(b)
idx2_end = sum(n2(:b))
idx2_start = idx2_end - nb + 1
do xyz2 = 1, 3
do pm2 = 1, 5
if (pm2 /= 3) then
! xyz_pm2 = 2*xyz2 + pm2 - 2
xyz_pm2 = 5*(xyz2 - 1) + pm2
do i2 = 1, nb
idx2 = (idx2_start-1)*3 + (i2-1)*3 + xyz2
do j2 = 1, nb
s12 = scalar(x1(a,j1,:,:), x2(b,xyz2,pm2,i2,j2,:,:), &
& nneigh1(a,j1), nneigh2(b,xyz2,pm2,i2,j2), &
& ksi1(a,j1,:), ksi2(b,xyz2,pm2,i2,j2,:), &
& sinp1(a,j1,:,:,:), sinp2(b,xyz_pm2,i2,j2,:,:,:), &
& cosp1(a,j1,:,:,:), cosp2(b,xyz_pm2,i2,j2,:,:,:), &
& t_width, d_width, cut_distance, order, &
& pd, ang_norm2,distance_scale, angular_scale, alchemy)
kernels(:,idx1,idx2) = kernels(:,idx1,idx2) &
& + kernel(self_scalar1(a,j1), self_scalar2(b,xyz2,pm2,i2,j2), s12,&
& kernel_idx, parameters) * fact(pm2)
enddo
enddo
endif
enddo
enddo
enddo
enddo
enddo
!$OMP END PARALLEL do
kernels = kernels / (12 * dx)
end subroutine fget_atomic_local_gradient_5point_kernels_fchl
================================================
FILE: qml/fchl/ffchl_kernel_types.f90
================================================
module ffchl_kernel_types
implicit none
public
! define kernel enums
integer, parameter :: GAUSSIAN = 1
integer, parameter :: LINEAR = 2
integer, parameter :: POLYNOMIAL = 3
integer, parameter :: SIGMOID = 4
integer, parameter :: MULTIQUADRATIC = 5
integer, parameter :: INV_MULTIQUADRATIC = 6
integer, parameter :: BESSEL = 7
integer, parameter :: L2 = 8
integer, parameter :: MATERN = 9
integer, parameter :: CAUCHY = 10
integer, parameter :: POLYNOMIAL2 = 11
end module ffchl_kernel_types
================================================
FILE: qml/fchl/ffchl_kernels.f90
================================================
! MIT License
!
! Copyright (c) 2018 Anders Steen Christensen and Felix A. Faber
!
! Permission is hereby granted, free of charge, to any person obtaining a copy
! of this software and associated documentation files (the "Software"), to deal
! in the Software without restriction, including without limitation the rights
! to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
! copies of the Software, and to permit persons to whom the Software is
! furnished to do so, subject to the following conditions:
!
! The above copyright notice and this permission notice shall be included in all
! copies or substantial portions of the Software.
!
! THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
! IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
! FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
! AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
! LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
! OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
! SOFTWARE.
! Inspiration from:
! http://crsouza.com/2010/03/17/kernel-functions-for-machine-learning-applications/#kernel_functions
module ffchl_kernels
implicit none
public :: kernel
contains
subroutine gaussian_kernel(s11, s22, s12, parameters, k)
implicit none
double precision, intent(in) :: s11
double precision, intent(in) :: s22
double precision, intent(in) :: s12
double precision, intent(in), dimension(:,:) :: parameters
double precision, intent(out), dimension(:) :: k
integer :: i
double precision :: l2
l2 = s11 + s22 - 2.0d0*s12
do i = 1, size(k)
k(i) = exp(l2 * parameters(i,1))
enddo
end subroutine gaussian_kernel
subroutine linear_kernel(s12, parameters, k)
implicit none
double precision, intent(in) :: s12
double precision, intent(in), dimension(:,:) :: parameters
double precision, intent(out), dimension(:) :: k
integer :: i
do i = 1, size(k)
k(i) = s12 + parameters(i,1)
enddo
end subroutine linear_kernel
subroutine polynomial_kernel(s12, parameters, k)
implicit none
double precision, intent(in) :: s12
double precision, intent(in), dimension(:,:) :: parameters
double precision, intent(out), dimension(:) :: k
integer :: i
do i = 1, size(k)
k(i) = (parameters(i,1) * s12 + parameters(i,2))**parameters(i,3)
enddo
end subroutine polynomial_kernel
subroutine sigmoid_kernel(s12, parameters, k)
implicit none
double precision, intent(in) :: s12
double precision, intent(in), dimension(:,:) :: parameters
double precision, intent(out), dimension(:) :: k
integer :: i
do i = 1, size(k)
k(i) = tanh(parameters(i,1) * s12 + parameters(i,2))
enddo
end subroutine sigmoid_kernel
subroutine multiquadratic_kernel(s11, s22, s12, parameters, k)
implicit none
double precision, intent(in) :: s11
double precision, intent(in) :: s22
double precision, intent(in) :: s12
double precision, intent(in), dimension(:,:) :: parameters
double precision, intent(out), dimension(:) :: k
integer :: i
double precision :: l2
l2 = s11 + s22 - 2.0d0*s12
do i = 1, size(k)
k(i) = sqrt(l2 + parameters(i,1)**2)
enddo
end subroutine multiquadratic_kernel
subroutine inverse_multiquadratic_kernel(s11, s22, s12, parameters, k)
implicit none
double precision, intent(in) :: s11
double precision, intent(in) :: s22
double precision, intent(in) :: s12
double precision, intent(in), dimension(:,:) :: parameters
double precision, intent(out), dimension(:) :: k
integer :: i
double precision :: l2
l2 = s11 + s22 - 2.0d0*s12
do i = 1, size(k)
k(i) = 1.0d0 / sqrt(l2 + parameters(i,1)**2)
enddo
end subroutine inverse_multiquadratic_kernel
subroutine bessel_kernel(s12, parameters, k)
implicit none
double precision, intent(in) :: s12
double precision, intent(in), dimension(:,:) :: parameters
double precision, intent(out), dimension(:) :: k
integer :: i
do i = 1, size(k)
k(i) = BESSEL_JN(int(parameters(i,2)), parameters(i,1) *s12) &
& / (s12**(-parameters(i,3)*(parameters(i,2) + 1)))
enddo
end subroutine bessel_kernel
subroutine l2_kernel(s11, s22, s12, parameters, k)
implicit none
double precision, intent(in) :: s11
double precision, intent(in) :: s22
double precision, intent(in) :: s12
double precision, intent(in), dimension(:,:) :: parameters
double precision, intent(out), dimension(:) :: k
integer :: i
double precision :: l2
l2 = s11 + s22 - 2.0d0*s12
do i = 1, size(k)
k(i) = l2*parameters(i,1) + parameters(i,2)
enddo
end subroutine l2_kernel
subroutine matern_kernel(s11, s22, s12, parameters, kernel)
implicit none
double precision, intent(in) :: s11
double precision, intent(in) :: s22
double precision, intent(in) :: s12
double precision, intent(in), dimension(:,:) :: parameters
double precision, intent(out), dimension(:) :: kernel
double precision :: l2
double precision :: rho
integer :: i, k, n
double precision:: v, fact
l2 = sqrt(s11 + s22 - 2.0d0*s12)
kernel(:) = 0.0d0
do i = 1, size(kernel)
n = int(parameters(i,2))
v = n + 0.5d0
rho = 2.0d0 * sqrt(2.0d0 * v) * l2 / parameters(i,1)
do k = 0, n
fact = parameters(i,3+k)
kernel(i) = kernel(i) + exp(-0.5d0 * rho) * fact * rho**(n-k)
enddo
enddo
end subroutine matern_kernel
subroutine cauchy_kernel(s11, s22, s12, parameters, k)
implicit none
double precision, intent(in) :: s11
double precision, intent(in) :: s22
double precision, intent(in) :: s12
double precision, intent(in), dimension(:,:) :: parameters
double precision, intent(out), dimension(:) :: k
integer :: i
double precision :: l2
l2 = s11 + s22 - 2.0d0*s12
do i = 1, size(k)
k(i) = 1.0d0 /(1.0d0 + l2/parameters(i,1)**2)
enddo
end subroutine cauchy_kernel
subroutine polynomial2_kernel(s12, parameters, k)
implicit none
double precision, intent(in) :: s12
double precision, intent(in), dimension(:,:) :: parameters
double precision, intent(out), dimension(:) :: k
integer :: i
do i = 1, size(k)
k(i) = parameters(i, 1) &
& + parameters(i, 2) * s12 &
& + parameters(i, 3) * s12**2 &
& + parameters(i, 4) * s12**3 &
& + parameters(i, 5) * s12**4 &
& + parameters(i, 6) * s12**5 &
& + parameters(i, 7) * s12**6 &
& + parameters(i, 8) * s12**7 &
& + parameters(i, 9) * s12**8 &
& + parameters(i, 10) * s12**9
enddo
end subroutine polynomial2_kernel
function kernel(s11, s22, s12, kernel_idx, parameters) result(k)
use ffchl_kernel_types
implicit none
double precision, intent(in) :: s11
double precision, intent(in) :: s22
double precision, intent(in) :: s12
integer, intent(in) :: kernel_idx
double precision, intent(in), dimension(:,:) :: parameters
integer :: n
double precision, allocatable, dimension(:) :: k
n = size(parameters, dim=1)
allocate(k(n))
if (kernel_idx == GAUSSIAN) then
call gaussian_kernel(s11, s22, s12, parameters, k)
else if (kernel_idx == LINEAR) then
call linear_kernel(s12, parameters, k)
else if (kernel_idx == POLYNOMIAL) then
call polynomial_kernel(s12, parameters, k)
else if (kernel_idx == SIGMOID) then
call sigmoid_kernel(s12, parameters, k)
else if (kernel_idx == MULTIQUADRATIC) then
call multiquadratic_kernel(s11, s22, s12, parameters, k)
else if (kernel_idx == INV_MULTIQUADRATIC) then
call inverse_multiquadratic_kernel(s11, s22, s12, parameters, k)
else if (kernel_idx == BESSEL) then
call bessel_kernel(s12, parameters, k)
else if (kernel_idx == L2) then
call l2_kernel(s11, s22, s12, parameters, k)
else if (kernel_idx == MATERN) then
call matern_kernel(s11, s22, s12, parameters, k)
else if (kernel_idx == CAUCHY) then
call cauchy_kernel(s11, s22, s12, parameters, k)
else if (kernel_idx == POLYNOMIAL2) then
call polynomial2_kernel(s12, parameters, k)
else
write (*,*) "QML ERROR: Unknown kernel function requested:", kernel_idx
stop
endif
end function kernel
end module ffchl_kernels
================================================
FILE: qml/fchl/ffchl_module.f90
================================================
module ffchl_module
implicit none
! For polarization
! double precision, parameter, dimension(19, 3) :: field_displacement = reshape( &
! & (/ -1, -1, 0, & ! 1 x- y-
! & -1, 0, -1, & ! 2 x- z-
! & -1, 0, 0, & ! 3 x-
! & -1, 0, 1, & ! 4 x- z+
! & -1, 1, 0, & ! 5 x- y+
! & 0, -1, -1, & ! 6 y- z-
! & 0, -1, 0, & ! 7 y-
! & 0, -1, 1, & ! 8 y- z+
! & 0, 0, -1, & ! 9 z-
! & 0, 0, 0, & ! 10 unperturbed = 10
! & 0, 0, 1, & ! 11 z+
! & 0, 1, -1, & ! 12 y+ z-
! & 0, 1, 0, & ! 13 y+
! & 0, 1, 1, & ! 14 y+ z+
! & 1, -1, 0, & ! 15 x+ y-
! & 1, 0, -1, & ! 16 x+ z-
! & 1, 0, 0, & ! 17 x+
! & 1, 0, 1, & ! 18 x+ z+
! & 1, 1, 0 & ! 19 x+ y+
! &/), (/ 19, 3 /))
contains
function get_pmax(x, na) result(pmax)
implicit none
! FCHL descriptors for the set, format (nm1,maxatoms,5,maxneighbors)
double precision, dimension(:,:,:,:), intent(in) :: x
! List of numbers of atoms in each molecule
integer, dimension(:), intent(in) :: na
! Internal counter
integer :: a
! Max nuclear charge
integer :: pmax
pmax = 0
do a = 1, size(na, dim=1)
pmax = max(pmax, int(maxval(x(a,1,2,:na(a)))))
enddo
end function get_pmax
function get_pmax_atomic(x, nneigh) result(pmax)
implicit none
! FCHL descriptors for the set, format (nm1,maxatoms,5,maxneighbors)
double precision, dimension(:,:,:), intent(in) :: x
! List of numbers of atoms in each molecule
integer, dimension(:), intent(in) :: nneigh
! Internal counter
integer :: a
! Max nuclear charge
integer :: pmax
pmax = 0
do a = 1, size(nneigh, dim=1)
pmax = max(pmax, int(maxval(x(a,2,:nneigh(a)))))
enddo
end function get_pmax_atomic
function get_pmax_displaced(x, na) result(pmax)
implicit none
! FCHL descriptors for the training set, format (nm1,3,2,maxatoms,maxatoms,5,maxneighbors)
double precision, dimension(:,:,:,:,:,:,:), intent(in) :: x
! List of numbers of atoms in each molecule
integer, dimension(:), intent(in) :: na
! Internal counter
integer :: a, b, i, xyz, pm
! Max nuclear charge
integer :: pmax
pmax = 0
do a = 1, size(na, dim=1)
b = na(a)
do xyz = 1, 3
do pm = 1, size(x, dim=3)
do i = 1, b
pmax = max(pmax, int(maxval(x(a,xyz,pm,i,1,2,:na(a)))))
enddo
enddo
enddo
enddo
end function get_pmax_displaced
pure function cut_function(r, cut_start, cut_distance) result(f)
implicit none
! Distance
double precision, intent(in) :: r
! Lower limit of damping
double precision, intent(in) :: cut_start
! Upper limit of damping
double precision, intent(in) :: cut_distance
! Intermediate variables
double precision :: x
double precision :: rl
double precision :: ru
! Damping function at distance r
double precision :: f
ru = cut_distance
rl = cut_start * cut_distance
if (r > ru) then
f = 0.0d0
else if (r < rl) then
f = 1.0d0
else
x = (ru - r) / (ru - rl)
f = (10.0d0 * x**3) - (15.0d0 * x**4) + (6.0d0 * x**5)
endif
end function cut_function
pure function get_angular_norm2(t_width) result(ang_norm2)
implicit none
! Theta-width
double precision, intent(in) :: t_width
! The resulting angular norm (squared)
double precision ang_norm2
! Integration limit - bigger than 100 should suffice.
integer, parameter :: limit = 10000
! Pi at double precision.
double precision, parameter :: pi = 4.0d0 * atan(1.0d0)
integer :: n
ang_norm2 = 0.0d0
do n = -limit, limit
ang_norm2 = ang_norm2 + exp(-((t_width * n)**2)) &
& * (2.0d0 - 2.0d0 * cos(n * pi))
end do
ang_norm2 = sqrt(ang_norm2 * pi) * 2.0d0
end function
function get_twobody_weights(x, neighbors, power, cut_start, cut_distance, dim1) result(ksi)
implicit none
double precision, dimension(:,:), intent(in) :: x
integer, intent(in) :: neighbors
double precision, intent(in) :: power
double precision, intent(in) :: cut_start
double precision, intent(in) :: cut_distance
integer, intent(in) :: dim1
double precision, dimension(dim1) :: ksi
integer :: i
ksi = 0.0d0
do i = 2, neighbors
ksi(i) = cut_function(x(1, i), cut_start, cut_distance) / x(1, i)**power
enddo
end function get_twobody_weights
! Calculate the Fourier terms for the FCHL three-body expansion
function get_threebody_fourier(x, neighbors, order, power, cut_start, cut_distance, &
& dim1, dim2, dim3) result(fourier)
implicit none
! Input representation, dimension=(5,n).
double precision, dimension(:,:), intent(in) :: x
! Number of neighboring atoms to iterate over.
integer, intent(in) :: neighbors
! Fourier-expansion order.
integer, intent(in) :: order
! Power law
double precision, intent(in) :: power
! Lower limit of damping function
double precision, intent(in) :: cut_start
! Upper limit of damping function
double precision, intent(in) :: cut_distance
! Dimensions or the output array.
integer, intent(in) :: dim1, dim2, dim3
! dim(1,:,:,:) are cos terms, dim(2,:,:,:) are sine terms.
double precision, dimension(2,dim1,dim2,dim3) :: fourier
! Pi at double precision.
double precision, parameter :: pi = 4.0d0 * atan(1.0d0)
! Internal counters.
integer :: j, k, m
! Indexes for the periodic-table distance matrix.
integer :: pj, pk
! Angle between atoms for the three-body term.
double precision :: theta
! Three-body weight
double precision :: ksi3
! Temporary variables for cos and sine Fourier terms.
double precision :: cos_m, sin_m
fourier = 0.0d0
do j = 2, neighbors
do k = j+1, neighbors
ksi3 = calc_ksi3(X(:,:), j, k, power, cut_start, cut_distance)
theta = calc_angle(x(3:5, j), x(3:5, 1), x(3:5, k))
pj = int(x(2,k))
pk = int(x(2,j))
do m = 1, order
cos_m = (cos(m * theta) - cos((theta + pi) * m))*ksi3
sin_m = (sin(m * theta) - sin((theta + pi) * m))*ksi3
fourier(1, pj, m, j) = fourier(1, pj, m, j) + cos_m
fourier(2, pj, m, j) = fourier(2, pj, m, j) + sin_m
fourier(1, pk, m, k) = fourier(1, pk, m, k) + cos_m
fourier(2, pk, m, k) = fourier(2, pk, m, k) + sin_m
enddo
enddo
enddo
return
end function get_threebody_fourier
pure function calc_angle(a, b, c) result(angle)
implicit none
double precision, intent(in), dimension(3) :: a
double precision, intent(in), dimension(3) :: b
double precision, intent(in), dimension(3) :: c
double precision, dimension(3) :: v1
double precision, dimension(3) :: v2
double precision :: cos_angle
double precision :: angle
v1 = a - b
v2 = c - b
v1 = v1 / norm2(v1)
v2 = v2 / norm2(v2)
cos_angle = dot_product(v1,v2)
! Clipping
if (cos_angle > 1.0d0) cos_angle = 1.0d0
if (cos_angle < -1.0d0) cos_angle = -1.0d0
angle = acos(cos_angle)
end function calc_angle
pure function calc_cos_angle(a, b, c) result(cos_angle)
implicit none
double precision, intent(in), dimension(3) :: a
double precision, intent(in), dimension(3) :: b
double precision, intent(in), dimension(3) :: c
double precision, dimension(3) :: v1
double precision, dimension(3) :: v2
double precision :: cos_angle
v1 = a - b
v2 = c - b
v1 = v1 / norm2(v1)
v2 = v2 / norm2(v2)
cos_angle = dot_product(v1,v2)
end function calc_cos_angle
function calc_ksi3(X, j, k, power, cut_start, cut_distance) result(ksi3)
implicit none
double precision, dimension(:,:), intent(in) :: X
integer, intent(in) :: j
integer, intent(in) :: k
double precision, intent(in) :: power
double precision, intent(in) :: cut_start
double precision, intent(in) :: cut_distance
double precision :: cos_i, cos_j, cos_k
double precision :: di, dj, dk
double precision :: ksi3
double precision :: cut
cos_i = calc_cos_angle(x(3:5, k), x(3:5, 1), x(3:5, j))
cos_j = calc_cos_angle(x(3:5, j), x(3:5, k), x(3:5, 1))
cos_k = calc_cos_angle(x(3:5, 1), x(3:5, j), x(3:5, k))
dk = x(1, j)
dj = x(1, k)
di = norm2(x(3:5, j) - x(3:5, k))
cut = cut_function(dk, cut_start, cut_distance) * &
& cut_function(dj, cut_start, cut_distance) * &
& cut_function(di, cut_start, cut_distance)
ksi3 = cut * (1.0d0 + 3.0d0 * cos_i*cos_j*cos_k) / (di * dj * dk)**power
end function calc_ksi3
pure function scalar(X1, X2, N1, N2, ksi1, ksi2, sin1, sin2, cos1, cos2, &
& t_width, d_width, cut_distance, order, pd, ang_norm2, &
& distance_scale, angular_scale, alchemy) result(aadist)
implicit none
double precision, dimension(:,:), intent(in) :: X1
double precision, dimension(:,:), intent(in) :: X2
integer, intent(in) :: N1
integer, intent(in) :: N2
double precision, dimension(:), intent(in) :: ksi1
double precision, dimension(:), intent(in) :: ksi2
double precision, dimension(:,:,:), intent(in) :: sin1
double precision, dimension(:,:,:), intent(in) :: sin2
double precision, dimension(:,:,:), intent(in) :: cos1
double precision, dimension(:,:,:), intent(in) :: cos2
double precision, intent(in) :: t_width
double precision, intent(in) :: d_width
double precision, intent(in) :: cut_distance
integer, intent(in) :: order
double precision, dimension(:,:), intent(in) :: pd
double precision, intent(in) :: angular_scale
double precision, intent(in) :: distance_scale
double precision :: true_angular_scale
double precision :: true_distance_scale
double precision, intent(in):: ang_norm2
double precision :: aadist
logical, intent(in) :: alchemy
! We changed the convention for the scaling factors when the paper was under review
! so this is a quick fix
true_angular_scale = angular_scale / sqrt(8.0d0)
true_distance_scale = distance_scale / 16.0d0
if (alchemy) then
aadist = scalar_alchemy(X1, X2, N1, N2, ksi1, ksi2, sin1, sin2, cos1, cos2, &
& t_width, d_width, order, pd, ang_norm2, &
& true_distance_scale, true_angular_scale)
else
aadist = scalar_noalchemy(X1, X2, N1, N2, ksi1, ksi2, sin1, sin2, cos1, cos2, &
& t_width, d_width, ang_norm2, &
& true_distance_scale, true_angular_scale)
endif
end function scalar
pure function scalar_noalchemy(X1, X2, N1, N2, ksi1, ksi2, sin1, sin2, cos1, cos2, &
& t_width, d_width, ang_norm2, &
& distance_scale, angular_scale) result(aadist)
implicit none
double precision, dimension(:,:), intent(in) :: X1
double precision, dimension(:,:), intent(in) :: X2
integer, intent(in) :: N1
integer, intent(in) :: N2
double precision, dimension(:), intent(in) :: ksi1
double precision, dimension(:), intent(in) :: ksi2
double precision, dimension(:,:,:), intent(in) :: sin1
double precision, dimension(:,:,:), intent(in) :: sin2
double precision, dimension(:,:,:), intent(in) :: cos1
double precision, dimension(:,:,:), intent(in) :: cos2
double precision, intent(in) :: t_width
double precision, intent(in) :: d_width
double precision, intent(in) :: angular_scale
double precision, intent(in) :: distance_scale
double precision :: aadist
double precision :: d
integer :: i, j, p
double precision :: angular
double precision :: maxgausdist2
integer :: pmax1
integer :: pmax2
integer :: pmax
double precision :: inv_width
double precision :: r2
double precision :: s
double precision, parameter :: pi = 4.0d0 * atan(1.0d0)
double precision :: g1
logical, allocatable, dimension(:) :: mask1
logical, allocatable, dimension(:) :: mask2
double precision, intent(in):: ang_norm2
! cached sine and cos terms
double precision, allocatable, dimension(:,:) :: cos1c, cos2c, sin1c, sin2c
if (int(x1(2,1)) /= int(x2(2,1))) then
aadist = 0.0d0
return
endif
pmax1 = int(maxval(x1(2,:n1)))
pmax2 = int(maxval(x2(2,:n2)))
pmax = min(pmax1,pmax2)
allocate(mask1(pmax1))
allocate(mask2(pmax2))
mask1 = .true.
mask2 = .true.
do i = 1, n1
mask1(int(x1(2,i))) = .false.
enddo
do i = 1, n2
mask2(int(x2(2,i))) = .false.
enddo
allocate(cos1c(pmax,n1))
allocate(cos2c(pmax,n2))
allocate(sin1c(pmax,n1))
allocate(sin2c(pmax,n2))
cos1c = 0.0d0
cos2c = 0.0d0
sin1c = 0.0d0
sin2c = 0.0d0
p = 0
do i = 1, pmax
if (mask1(i)) cycle
if (mask2(i)) cycle
p = p + 1
cos1c(p,:n1) = cos1(i,1,:n1)
cos2c(p,:n2) = cos2(i,1,:n2)
sin1c(p,:n1) = sin1(i,1,:n1)
sin2c(p,:n2) = sin2(i,1,:n2)
enddo
pmax = p
! Pre-computed constants
g1 = sqrt(2.0d0 * pi)/ang_norm2
s = g1 * exp(-(t_width)**2 / 2.0d0)
inv_width = -1.0d0 / (4.0d0 * d_width**2)
maxgausdist2 = (8.0d0 * d_width)**2
! Initialize scalar product
aadist = 1.0d0
do i = 2, n1
do j = 2, n2
if (int(x1(2,i)) /= int(x2(2,j))) cycle
r2 = (x2(1,j) - x1(1,i))**2
if (r2 >= maxgausdist2) cycle
d = exp(r2 * inv_width)
angular = (sum(cos1c(:pmax,i) * cos2c(:pmax,j)) &
& + sum(sin1c(:pmax,i) * sin2c(:pmax,j))) * s
aadist = aadist + d * (ksi1(i) * ksi2(j) * distance_scale &
& + angular * angular_scale)
end do
end do
deallocate(mask1)
deallocate(mask2)
deallocate(cos1c)
deallocate(cos2c)
deallocate(sin1c)
deallocate(sin2c)
end function scalar_noalchemy
pure function scalar_alchemy(X1, X2, N1, N2, ksi1, ksi2, sin1, sin2, cos1, cos2, &
& t_width, d_width, order, pd, ang_norm2, &
& distance_scale, angular_scale) result(aadist)
implicit none
double precision, dimension(:,:), intent(in) :: X1
double precision, dimension(:,:), intent(in) :: X2
integer, intent(in) :: N1
integer, intent(in) :: N2
double precision, dimension(:), intent(in) :: ksi1
double precision, dimension(:), intent(in) :: ksi2
double precision, dimension(:,:,:), intent(in) :: sin1
double precision, dimension(:,:,:), intent(in) :: sin2
double precision, dimension(:,:,:), intent(in) :: cos1
double precision, dimension(:,:,:), intent(in) :: cos2
double precision, intent(in) :: t_width
double precision, intent(in) :: d_width
! double precision, intent(in) :: cut_distance
integer, intent(in) :: order
double precision, dimension(:,:), intent(in) :: pd
double precision, intent(in) :: angular_scale
double precision, intent(in) :: distance_scale
double precision :: aadist
double precision :: d
integer :: m_1, m_2
integer :: i, m, p1, p2
double precision :: angular
double precision :: maxgausdist2
integer :: pmax1
integer :: pmax2
double precision :: inv_width
double precision :: r2
double precision, dimension(order) :: s
double precision, parameter :: pi = 4.0d0 * atan(1.0d0)
double precision :: g1
double precision :: a0
logical, allocatable, dimension(:) :: mask1
logical, allocatable, dimension(:) :: mask2
double precision :: temp, sin1_temp, cos1_temp
double precision, intent(in):: ang_norm2
pmax1 = int(maxval(x1(2,:n1)))
pmax2 = int(maxval(x2(2,:n2)))
allocate(mask1(pmax1))
allocate(mask2(pmax2))
mask1 = .true.
mask2 = .true.
do i = 1, n1
mask1(int(x1(2,i))) = .false.
enddo
do i = 1, n2
mask2(int(x2(2,i))) = .false.
enddo
a0 = 0.0d0
g1 = sqrt(2.0d0 * pi)/ang_norm2
do m = 1, order
s(m) = g1 * exp(-(t_width * m)**2 / 2.0d0)
enddo
inv_width = -1.0d0 / (4.0d0 * d_width**2)
maxgausdist2 = (8.0d0 * d_width)**2
aadist = 1.0d0
do m_1 = 2, N1
! if (X1(1, m_1) > cut_distance) exit
do m_2 = 2, N2
! if (X2(1, m_2) > cut_distance) exit
r2 = (X2(1,m_2) - X1(1,m_1))**2
if (r2 < maxgausdist2) then
d = exp(r2 * inv_width ) * pd(int(x1(2,m_1)), int(x2(2,m_2)))
angular = a0 * a0
do m = 1, order
temp = 0.0d0
do p1 = 1, pmax1
if (mask1(p1)) cycle
cos1_temp = cos1(p1,m,m_1)
sin1_temp = sin1(p1,m,m_1)
do p2 = 1, pmax2
if (mask2(p2)) cycle
temp = temp + (cos1_temp * cos2(p2,m,m_2) &
& + sin1_temp * sin2(p2,m,m_2)) * pd(p2,p1)
enddo
enddo
angular = angular + temp * s(m)
enddo
aadist = aadist + d * (ksi1(m_1) * ksi2(m_2) * distance_scale &
& + angular * angular_scale)
end if
end do
end do
aadist = aadist * pd(int(x1(2,1)), int(x2(2,1)))
deallocate(mask1)
deallocate(mask2)
end function scalar_alchemy
function get_ksi(x, na, nneigh, two_body_power, cut_start, cut_distance, verbose) result(ksi)
implicit none
! FCHL descriptors for the training set, format (i,maxatoms,5,maxneighbors)
double precision, dimension(:,:,:,:), intent(in) :: x
! List of numbers of atoms in each molecule
integer, dimension(:), intent(in) :: na
! Number of neighbors for each atom in each compound
integer, dimension(:,:), intent(in) :: nneigh
! Decaying powerlaws for two-body term
double precision, intent(in) :: two_body_power
! Fraction of cut_distance at which cut-off starts
double precision, intent(in) :: cut_start
double precision, intent(in) :: cut_distance
! Whether to be verbose with output
logical, intent(in) :: verbose
! Pre-computed two-body weights
double precision, allocatable, dimension(:,:,:) :: ksi
! Internal counters
integer :: maxneigh, maxatoms, nm, a, ni, i
maxneigh = maxval(nneigh)
maxatoms = maxval(na)
nm = size(x, dim=1)
allocate(ksi(nm, maxatoms, maxneigh))
ksi = 0.0d0
!$OMP PARALLEL DO PRIVATE(ni)
do a = 1, nm
ni = na(a)
do i = 1, ni
ksi(a, i, :) = get_twobody_weights(x(a,i,:,:), nneigh(a, i), &
& two_body_power, cut_start, cut_distance, maxneigh)
enddo
enddo
!$OMP END PARALLEL do
end function get_ksi
function get_ksi_displaced(x, na, nneigh, two_body_power, cut_start, cut_distance, verbose) result(ksi)
implicit none
! FCHL descriptors for the training set, format (i,maxatoms,5,maxneighbors)
double precision, dimension(:,:,:,:,:,:,:), intent(in) :: x
! List of numbers of atoms in each molecule
integer, dimension(:), intent(in) :: na
! Number of neighbors for each atom in each compound
integer, dimension(:,:,:,:,:), intent(in) :: nneigh
! Decaying powerlaws for two-body term
double precision, intent(in) :: two_body_power
! Fraction of cut_distance at which cut-off starts
double precision, intent(in) :: cut_start
double precision, intent(in) :: cut_distance
! Whether to be verbose with output
logical, intent(in) :: verbose
! Pre-computed two-body weights
double precision, allocatable, dimension(:,:,:,:,:,:) :: ksi
! Internal counters
integer :: maxneigh, maxatoms, nm, a, ni, i, j, pm, xyz, ndisp
maxneigh = maxval(nneigh)
maxatoms = maxval(na)
nm = size(x, dim=1)
ndisp = size(x, dim=3)
allocate(ksi(nm,3,ndisp,maxatoms,maxatoms,maxneigh))
ksi = 0.0d0
!$OMP PARALLEL DO PRIVATE(ni)
do a = 1, nm
ni = na(a)
do xyz = 1, 3
do pm = 1, ndisp
do i = 1, ni
do j = 1, ni
ksi(a, xyz, pm, i, j, :) = get_twobody_weights( &
& x(a,xyz,pm,i,j,:,:), nneigh(a, xyz, pm, i, j), &
& two_body_power, cut_start, cut_distance, maxneigh)
enddo
enddo
enddo
enddo
enddo
!$OMP END PARALLEL do
end function get_ksi_displaced
function get_ksi_atomic(x, na, nneigh, two_body_power, cut_start, cut_distance, verbose) result(ksi)
implicit none
! FCHL descriptors for the training set, format (i,maxatoms,5,maxneighbors)
double precision, dimension(:,:,:), intent(in) :: x
! List of numbers of atoms
integer, intent(in) :: na
! Number of neighbors for each atom in each compound
integer, dimension(:), intent(in) :: nneigh
! Decaying powerlaws for two-body term
double precision, intent(in) :: two_body_power
! Fraction of cut_distance at which cut-off starts
double precision, intent(in) :: cut_start
double precision, intent(in) :: cut_distance
! Whether to be verbose with output
logical, intent(in) :: verbose
! Pre-computed two-body weights
double precision, allocatable, dimension(:,:) :: ksi
! Internal counters
integer :: maxneigh, nm, i
maxneigh = maxval(nneigh)
nm = size(x, dim=1)
allocate(ksi(na, maxneigh))
ksi = 0.0d0
!$OMP PARALLEL DO
do i = 1, na
ksi(i, :) = get_twobody_weights(x(i,:,:), nneigh(i), &
& two_body_power, cut_start, cut_distance, maxneigh)
enddo
!$OMP END PARALLEL do
end function get_ksi_atomic
subroutine init_cosp_sinp(x, na, nneigh, three_body_power, order, cut_start, cut_distance, cosp, sinp, verbose)
implicit none
! FCHL descriptors for the training set, format (i,maxatoms,5,maxneighbors)
double precision, dimension(:,:,:,:), intent(in) :: x
! List of numbers of atoms in each molecule
integer, dimension(:), intent(in) :: na
! Number of neighbors for each atom in each compound
integer, dimension(:,:), intent(in) :: nneigh
! Decaying powerlaws for two-body term
double precision, intent(in) :: three_body_power
integer, intent(in) :: order
! Fraction of cut_distance at which cut-off starts
double precision, intent(in) :: cut_start
double precision, intent(in) :: cut_distance
! Whether to be verbose with output
logical, intent(in) :: verbose
! Cosine and sine terms for each atomtype
double precision, dimension(:,:,:,:,:), intent(out) :: cosp
double precision, dimension(:,:,:,:,:), intent(out) :: sinp
! Internal counters
integer :: maxneigh, maxatoms, pmax, nm, a, ni, i
double precision, allocatable, dimension(:,:,:,:) :: fourier
maxneigh = maxval(nneigh)
maxatoms = maxval(na)
nm = size(x, dim=1)
pmax = get_pmax(x, na)
cosp = 0.0d0
sinp = 0.0d0
!$OMP PARALLEL DO PRIVATE(ni, fourier) schedule(dynamic)
do a = 1, nm
ni = na(a)
do i = 1, ni
fourier = get_threebody_fourier(x(a,i,:,:), &
& nneigh(a, i), order, three_body_power, cut_start, cut_distance, pmax, order, maxneigh)
cosp(a,i,:,:,:) = fourier(1,:,:,:)
sinp(a,i,:,:,:) = fourier(2,:,:,:)
enddo
enddo
!$OMP END PARALLEL DO
end subroutine init_cosp_sinp
subroutine init_cosp_sinp_displaced(x, na, nneigh, three_body_power, order, cut_start, cut_distance, cosp, sinp, verbose)
implicit none
! FCHL descriptors for the training set, format (i,maxatoms,5,maxneighbors)
double precision, dimension(:,:,:,:,:,:,:), intent(in) :: x
! List of numbers of atoms in each molecule
integer, dimension(:), intent(in) :: na
! Number of neighbors for each atom in each compound
integer, dimension(:,:,:,:,:), intent(in) :: nneigh
! Decaying powerlaws for two-body term
double precision, intent(in) :: three_body_power
integer, intent(in) :: order
! Fraction of cut_distance at which cut-off starts
double precision, intent(in) :: cut_start
double precision, intent(in) :: cut_distance
! Whether to be verbose with output
logical, intent(in) :: verbose
! Cosine and sine terms for each atomtype
double precision, dimension(:,:,:,:,:,:,:) :: sinp
double precision, dimension(:,:,:,:,:,:,:) :: cosp
! Internal counters
integer :: maxneigh, maxatoms, pmax, nm, a, ni, i, j, xyz, pm, xyz_pm
double precision, allocatable, dimension(:,:,:,:) :: fourier
integer :: ndisp
maxneigh = maxval(nneigh)
maxatoms = maxval(na)
nm = size(x, dim=1)
ndisp = size(x, dim=3)
pmax = get_pmax_displaced(x, na)
cosp = 0.0d0
sinp = 0.0d0
!$OMP PARALLEL DO PRIVATE(ni, fourier, xyz_pm) schedule(dynamic)
do a = 1, nm
ni = na(a)
do xyz = 1, 3
do pm = 1, ndisp
do i = 1, ni
do j = 1, ni
xyz_pm = ndisp*(xyz - 1) + pm
fourier = get_threebody_fourier(x(a,xyz,pm,i,j,:,:), &
& nneigh(a, xyz, pm, i, j), &
& order, three_body_power, cut_start, cut_distance, &
& pmax, order, maxneigh)
cosp(a,xyz_pm,i,j,:,:,:) = fourier(1,:,:,:)
sinp(a,xyz_pm,i,j,:,:,:) = fourier(2,:,:,:)
enddo
enddo
enddo
enddo
enddo
!$OMP END PARALLEL do
end subroutine init_cosp_sinp_displaced
subroutine init_cosp_sinp_atomic(x, na, nneigh, three_body_power, order, cut_start, cut_distance, cosp, sinp, verbose)
implicit none
! FCHL descriptors for the training set, format (i,maxatoms,5,maxneighbors)
double precision, dimension(:,:,:), intent(in) :: x
! List of numbers of atom
integer, intent(in) :: na
! Number of neighbors for each atom
integer, dimension(:), intent(in) :: nneigh
! Decaying powerlaws for two-body term
double precision, intent(in) :: three_body_power
! Fourier truncation order
integer, intent(in) :: order
! Fraction of cut_distance at which cut-off starts
double precision, intent(in) :: cut_start
double precision, intent(in) :: cut_distance
! Whether to be verbose with output
logical, intent(in) :: verbose
! Cosine and sine terms for each atomtype
double precision, dimension(:,:,:,:), intent(out) :: cosp
double precision, dimension(:,:,:,:), intent(out) :: sinp
! Internal counters
integer :: maxneigh, pmax, nm, i
! Internal temporary variable
double precision, allocatable, dimension(:,:,:,:) :: fourier
maxneigh = maxval(nneigh)
nm = size(x, dim=1)
pmax = get_pmax_atomic(x, nneigh)
cosp = 0.0d0
sinp = 0.0d0
!$OMP PARALLEL DO PRIVATE(fourier)
do i = 1, na
fourier = get_threebody_fourier(x(i,:,:), &
& nneigh(i), order, three_body_power, cut_start, cut_distance, pmax, order, maxneigh)
cosp(i,:,:,:) = fourier(1,:,:,:)
sinp(i,:,:,:) = fourier(2,:,:,:)
enddo
!$OMP END PARALLEL DO
end subroutine init_cosp_sinp_atomic
function get_selfscalar(x, nm, na, nneigh, ksi, sinp, cosp, t_width, d_width, &
& cut_distance, order, pd, ang_norm2,distance_scale, angular_scale, alchemy, verbose) result(self_scalar)
implicit none
! FCHL descriptors for the training set, format (i,maxatoms,5,maxneighbors)
double precision, dimension(:,:,:,:), intent(in) :: x
! Number of molecules molecule
integer, intent(in) :: nm
! List of numbers of atoms in each molecule
integer, dimension(:), intent(in) :: na
! Number of neighbors for each atom in each compound
integer, dimension(:,:), intent(in) :: nneigh
! Pre-computed two-body weights
double precision, dimension(:,:,:), intent(in) :: ksi
! Cosine and sine terms for each atomtype
double precision, dimension(:,:,:,:,:), intent(in) :: sinp
double precision, dimension(:,:,:,:,:), intent(in) :: cosp
! Angular Gaussian width
double precision, intent(in) :: t_width
! Distance Gaussian width
double precision, intent(in) :: d_width
double precision, intent(in) :: cut_distance
! Truncation order for Fourier terms
integer, intent(in) :: order
! Periodic table distance matrix
double precision, dimension(:,:), intent(in) :: pd
! Angular normalization constant
double precision, intent(in) :: ang_norm2
! Scaling for angular and distance terms
double precision, intent(in) :: distance_scale
double precision, intent(in) :: angular_scale
! Switch alchemy on or off
logical, intent(in) :: alchemy
! Whether to be verbose with output
logical, intent(in) :: verbose
double precision, allocatable, dimension(:,:) :: self_scalar
! Internal counters
integer :: a, ni, i
allocate(self_scalar(nm, maxval(na)))
!$OMP PARALLEL DO PRIVATE(ni)
do a = 1, nm
ni = na(a)
do i = 1, ni
self_scalar(a,i) = scalar(x(a,i,:,:), x(a,i,:,:), &
& nneigh(a,i), nneigh(a,i), ksi(a,i,:), ksi(a,i,:), &
& sinp(a,i,:,:,:), sinp(a,i,:,:,:), &
& cosp(a,i,:,:,:), cosp(a,i,:,:,:), &
& t_width, d_width, cut_distance, order, &
& pd, ang_norm2,distance_scale, angular_scale, alchemy)
enddo
enddo
!$OMP END PARALLEL DO
end function get_selfscalar
function get_selfscalar_displaced(x, nm, na, nneigh, ksi, sinp, cosp, t_width, d_width, &
& cut_distance, order, pd, ang_norm2,distance_scale, angular_scale, alchemy, verbose) result(self_scalar)
implicit none
! FCHL descriptors for the training set, format (i,maxatoms,5,maxneighbors)
double precision, dimension(:,:,:,:,:,:,:), intent(in) :: x
! Number of molecules molecule
integer, intent(in) :: nm
! List of numbers of atoms in each molecule
integer, dimension(:), intent(in) :: na
! Number of neighbors for each atom in each compound
integer, dimension(:,:,:,:,:), intent(in) :: nneigh
! Pre-computed two-body weights
double precision, dimension(:,:,:,:,:,:), intent(in) :: ksi
! Cosine and sine terms for each atomtype
double precision, dimension(:,:,:,:,:,:,:), intent(in) :: sinp
double precision, dimension(:,:,:,:,:,:,:), intent(in) :: cosp
! Angular Gaussian width
double precision, intent(in) :: t_width
! Distance Gaussian width
double precision, intent(in) :: d_width
double precision, intent(in) :: cut_distance
! Truncation order for Fourier terms
integer, intent(in) :: order
! Periodic table distance matrix
double precision, dimension(:,:), intent(in) :: pd
! Angular normalization constant
double precision, intent(in) :: ang_norm2
! Scaling for angular and distance terms
double precision, intent(in) :: distance_scale
double precision, intent(in) :: angular_scale
! Switch alchemy on or off
logical, intent(in) :: alchemy
! Whether to be verbose with output
logical, intent(in) :: verbose
double precision, allocatable, dimension(:,:,:,:,:) :: self_scalar
! Internal counters
integer :: a, ni, i, j, pm, xyz, xyz_pm, ndisp
ndisp = size(x, dim=3)
allocate(self_scalar(nm, 3, ndisp, maxval(na), maxval(na)))
self_scalar = 0.0d0
!$OMP PARALLEL DO PRIVATE(ni, xyz_pm) schedule(dynamic)
do a = 1, nm
ni = na(a)
do xyz = 1, 3
do pm = 1, ndisp
do i = 1, ni
do j = 1, ni
! z_pm = 2*xyz + pm - 2
xyz_pm = ndisp*(xyz - 1) + pm
self_scalar(a,xyz,pm,i,j) = scalar(x(a,xyz,pm,i,j,:,:), x(a,xyz,pm,i,j,:,:), &
& nneigh(a,xyz,pm,i,j), nneigh(a,xyz,pm,i,j), &
& ksi(a,xyz,pm,i,j,:), ksi(a,xyz,pm,i,j,:), &
& sinp(a,xyz_pm,i,j,:,:,:), sinp(a,xyz_pm,i,j,:,:,:), &
& cosp(a,xyz_pm,i,j,:,:,:), cosp(a,xyz_pm,i,j,:,:,:), &
& t_width, d_width, cut_distance, order, &
& pd, ang_norm2,distance_scale, angular_scale, alchemy)
enddo
enddo
enddo
enddo
enddo
!$OMP END PARALLEL do
end function get_selfscalar_displaced
function get_ksi_ef(x, na, nneigh, two_body_power, cut_start, cut_distance, ef_scale, df, verbose) result(ksi)
implicit none
! FCHL descriptors for the training set, format (i,maxatoms,5,maxneighbors)
double precision, dimension(:,:,:,:), intent(in) :: x
! List of numbers of atoms in each molecule
integer, dimension(:), intent(in) :: na
! Number of neighbors for each atom in each compound
integer, dimension(:,:), intent(in) :: nneigh
! Decaying powerlaws for two-body term
double precision, intent(in) :: two_body_power
! Fraction of cut_distance at which cut-off starts
double precision, intent(in) :: cut_start
double precision, intent(in) :: cut_distance
! Electric field displacement
double precision, intent(in) :: ef_scale
double precision, intent(in) :: df
! Display output
logical, intent(in) :: verbose
! Pre-computed two-body weights
double precision, allocatable, dimension(:,:,:,:,:) :: ksi
! Internal counters
integer :: maxneigh, maxatoms, nm, a, ni, i, xyz, pm
! Electric field
double precision, dimension(3) :: field
maxneigh = maxval(nneigh)
maxatoms = maxval(na)
nm = size(x, dim=1)
allocate(ksi(nm, 3, 2, maxatoms, maxneigh))
ksi = 0.0d0
!$OMP PARALLEL DO PRIVATE(ni, field)
do a = 1, nm
ni = na(a)
do xyz = 1, 3
do pm = 1, 2
field = 0.0d0
field(xyz) = (pm - 1.5d0)*2.0d0 * df
! write(*,*) xyz, pm, field
do i = 1, ni
ksi(a, xyz, pm, i, :) = get_twobody_weights_ef(x(a,i,:,:), field, nneigh(a, i), &
& two_body_power, cut_start, cut_distance, maxneigh, ef_scale)
enddo
enddo
enddo
enddo
!$OMP END PARALLEL do
end function get_ksi_ef
function get_ksi_ef_field(x, na, nneigh, two_body_power, cut_start, cut_distance, fields, ef_scale, verbose) result(ksi)
implicit none
! FCHL descriptors for the training set, format (i,maxatoms,5,maxneighbors)
double precision, dimension(:,:,:,:), intent(in) :: x
! List of numbers of atoms in each molecule
integer, dimension(:), intent(in) :: na
! Number of neighbors for each atom in each compound
integer, dimension(:,:), intent(in) :: nneigh
! Decaying powerlaws for two-body term
double precision, intent(in) :: two_body_power
! Fraction of cut_distance at which cut-off starts
double precision, intent(in) :: cut_start
double precision, intent(in) :: cut_distance
! Electric fields for each representation
double precision, dimension(:,:), intent(in) :: fields
! Display output
logical, intent(in) :: verbose
! Pre-computed two-body weights
double precision, allocatable, dimension(:,:,:) :: ksi
! Internal counters
integer :: maxneigh, maxatoms, nm, a, ni, i
double precision, intent(in) :: ef_scale
! Electric field displacement
! double precision, intent(in) :: df
maxneigh = maxval(nneigh)
maxatoms = maxval(na)
nm = size(x, dim=1)
allocate(ksi(nm, maxatoms, maxneigh))
ksi = 0.0d0
!$OMP PARALLEL DO PRIVATE(ni)
do a = 1, nm
ni = na(a)
do i = 1, ni
ksi(a, i, :) = get_twobody_weights_ef(x(a,i,:,:), fields(a,:), nneigh(a, i), &
& two_body_power, cut_start, cut_distance, maxneigh, ef_scale)
enddo
enddo
!$OMP END PARALLEL do
end function get_ksi_ef_field
subroutine init_cosp_sinp_ef(x, na, nneigh, three_body_power, order, cut_start, cut_distance, &
& cosp, sinp, ef_scale, df, verbose)
implicit none
! FCHL descriptors for the training set, format (i,maxatoms,5,maxneighbors)
double precision, dimension(:,:,:,:), intent(in) :: x
! List of numbers of atoms in each molecule
integer, dimension(:), intent(in) :: na
! Number of neighbors for each atom in each compound
integer, dimension(:,:), intent(in) :: nneigh
! Decaying powerlaws for two-body term
double precision, intent(in) :: three_body_power
integer, intent(in) :: order
! Fraction of cut_distance at which cut-off starts
double precision, intent(in) :: cut_start
double precision, intent(in) :: cut_distance
double precision, intent(in) :: ef_scale
! Electric field displacement
double precision, intent(in) :: df
! Cosine and sine terms for each atomtype
double precision, dimension(:,:,:,:,:,:,:), intent(out) :: cosp
double precision, dimension(:,:,:,:,:,:,:), intent(out) :: sinp
! Display output
logical, intent(in) :: verbose
! Internal counters
integer :: maxneigh, maxatoms, pmax, nm, a, ni, i
double precision, allocatable, dimension(:,:,:,:) :: fourier
! Internal counters
integer :: xyz, pm
! Electric field
double precision, dimension(3) :: field
maxneigh = maxval(nneigh)
maxatoms = maxval(na)
nm = size(x, dim=1)
pmax = get_pmax(x, na)
cosp = 0.0d0
sinp = 0.0d0
!$OMP PARALLEL DO PRIVATE(ni, fourier, field) schedule(dynamic)
do a = 1, nm
ni = na(a)
do xyz = 1, 3
do pm = 1, 2
field = 0.0d0
field(xyz) = (pm - 1.5d0) * 2.0d0 * df
do i = 1, ni
fourier = get_threebody_fourier_ef(x(a,i,:,:), field, &
& nneigh(a, i), order, three_body_power, cut_start, cut_distance, pmax, order, maxneigh, ef_scale)
cosp(a,xyz,pm,i,:,:,:) = fourier(1,:,:,:)
sinp(a,xyz,pm,i,:,:,:) = fourier(2,:,:,:)
enddo
enddo
enddo
enddo
!$OMP END PARALLEL DO
end subroutine init_cosp_sinp_ef
subroutine init_cosp_sinp_ef_field(x, na, nneigh, three_body_power, &
& order, cut_start, cut_distance, cosp, sinp, fields, ef_scale, verbose)
implicit none
! FCHL descriptors for the training set, format (i,maxatoms,5,maxneighbors)
double precision, dimension(:,:,:,:), intent(in) :: x
! List of numbers of atoms in each molecule
integer, dimension(:), intent(in) :: na
! Number of neighbors for each atom in each compound
integer, dimension(:,:), intent(in) :: nneigh
! Decaying powerlaws for two-body term
double precision, intent(in) :: three_body_power
integer, intent(in) :: order
! Fraction of cut_distance at which cut-off starts
double precision, intent(in) :: cut_start
double precision, intent(in) :: cut_distance
double precision, intent(in) :: ef_scale
! Electric field displacement
! double precision, intent(in) :: df
! Display output
logical, intent(in) :: verbose
! Cosine and sine terms for each atomtype
double precision, dimension(:,:,:,:,:), intent(out) :: cosp
double precision, dimension(:,:,:,:,:), intent(out) :: sinp
! Electric fields for each representation
double precision, dimension(:,:), intent(in) :: fields
! Internal counters
integer :: maxneigh, maxatoms, pmax, nm, a, ni, i
double precision, allocatable, dimension(:,:,:,:) :: fourier
maxneigh = maxval(nneigh)
maxatoms = maxval(na)
nm = size(x, dim=1)
pmax = get_pmax(x, na)
cosp = 0.0d0
sinp = 0.0d0
!$OMP PARALLEL DO PRIVATE(ni, fourier) schedule(dynamic)
do a = 1, nm
ni = na(a)
do i = 1, ni
fourier = get_threebody_fourier_ef(x(a,i,:,:), fields(a,:), &
& nneigh(a, i), order, three_body_power, cut_start, cut_distance, pmax, order, maxneigh, ef_scale)
cosp(a,i,:,:,:) = fourier(1,:,:,:)
sinp(a,i,:,:,:) = fourier(2,:,:,:)
enddo
enddo
!$OMP END PARALLEL DO
end subroutine init_cosp_sinp_ef_field
! Calculate the Fourier terms for the FCHL three-body expansion
function get_threebody_fourier_ef(x, field, neighbors, order, power, cut_start, cut_distance, &
& dim1, dim2, dim3, ef_scale) result(fourier)
implicit none
! Input representation, dimension=(5,n).
double precision, dimension(:,:), intent(in) :: x
double precision, dimension(3), intent(in) :: field
! Number of neighboring atoms to iterate over.
integer, intent(in) :: neighbors
! Fourier-expansion order.
integer, intent(in) :: order
! Power law
double precision, intent(in) :: power
! Lower limit of damping function
double precision, intent(in) :: cut_start
! Upper limit of damping function
double precision, intent(in) :: cut_distance
double precision, intent(in) :: ef_scale
! Dimensions or the output array.
integer, intent(in) :: dim1, dim2, dim3
! dim(1,:,:,:) are cos terms, dim(2,:,:,:) are sine terms.
double precision, dimension(2,dim1,dim2,dim3) :: fourier
! Pi at double precision.
double precision, parameter :: pi = 4.0d0 * atan(1.0d0)
! Internal counters.
integer :: j, k, m
! Indexes for the periodic-table distance matrix.
integer :: pj, pk
! Angle between atoms for the three-body term.
double precision :: theta
! Three-body weight
double precision :: ksi3
! Temporary variables for cos and sine Fourier terms.
double precision :: cos_m, sin_m
fourier = 0.0d0
do j = 2, neighbors
do k = j+1, neighbors
ksi3 = calc_ksi3_ef(X(:,:), field, j, k, neighbors, power, cut_start, cut_distance, ef_scale)
theta = calc_angle(x(3:5, j), x(3:5, 1), x(3:5, k))
pj = int(x(2,k))
pk = int(x(2,j))
do m = 1, order
cos_m = (cos(m * theta) - cos((theta + pi) * m))*ksi3
sin_m = (sin(m * theta) - sin((theta + pi) * m))*ksi3
fourier(1, pj, m, j) = fourier(1, pj, m, j) + cos_m
fourier(2, pj, m, j) = fourier(2, pj, m, j) + sin_m
fourier(1, pk, m, k) = fourier(1, pk, m, k) + cos_m
fourier(2, pk, m, k) = fourier(2, pk, m, k) + sin_m
enddo
enddo
enddo
return
end function get_threebody_fourier_ef
function calc_ksi3_ef(X, field, j, k, neighbors, power, cut_start, cut_distance, ef_scale) result(ksi3)
implicit none
double precision, dimension(:,:), intent(in) :: X
double precision, dimension(3), intent(in) :: field
integer, intent(in) :: j
integer, intent(in) :: k
! Number of neighboring atoms to iterate over.
integer, intent(in) :: neighbors
double precision, intent(in) :: power
double precision, intent(in) :: cut_start
double precision, intent(in) :: cut_distance
double precision, intent(in) :: ef_scale
double precision :: cos_i, cos_j, cos_k
double precision :: di, dj, dk
double precision :: ksi3
double precision :: cut
! Center of nuclear charge
double precision, dimension(3) :: coz
double precision, dimension(3) :: dipole
double precision :: total_charge
integer :: i
! coz
! dipole
cos_i = calc_cos_angle(x(3:5, k), x(3:5, 1), x(3:5, j))
cos_j = calc_cos_angle(x(3:5, j), x(3:5, k), x(3:5, 1))
cos_k = calc_cos_angle(x(3:5, 1), x(3:5, j), x(3:5, k))
dk = x(1, j)
dj = x(1, k)
di = norm2(x(3:5, j) - x(3:5, k))
cut = cut_function(dk, cut_start, cut_distance) * &
& cut_function(dj, cut_start, cut_distance) * &
& cut_function(di, cut_start, cut_distance)
total_charge = 0.0d0
coz = 0.0d0
do i = 1, neighbors
coz = coz + x(3:5, i) * x(2, i)
total_charge = total_charge + x(2, i)
enddo
coz = coz / total_charge
dipole = (x(3:5, 1) - coz) * x(6, 1) + (x(3:5, j) - coz) * x(6, j) &
& + (x(3:5, k) - coz) * x(6, k)
! ksi3 = cut * (1.0d0 + 3.0d0 * cos_i*cos_j*cos_k) / (di * dj * dk)**power
ksi3 = cut * ( (1.0d0 + 3.0d0 * cos_i*cos_j*cos_k) / (di * dj * dk)**power &
& + ef_scale * dot_product(dipole, field) )
! ksi3 = cut * dot_product(dipole, field)
end function calc_ksi3_ef
function get_twobody_weights_ef(x, field, neighbors, power, cut_start, cut_distance, dim1, ef_scale) result(ksi)
implicit none
double precision, dimension(:,:), intent(in) :: x
double precision, dimension(3), intent(in) :: field
integer, intent(in) :: neighbors
double precision, intent(in) :: power
double precision, intent(in) :: cut_start
double precision, intent(in) :: cut_distance
double precision, intent(in) :: ef_scale
integer, intent(in) :: dim1
double precision, dimension(dim1) :: ksi
! Electric field displacement
! double precision, intent(in) :: df
integer :: i
double precision, dimension(3) :: dipole
! Center of nuclear charge
double precision, dimension(3) :: coz
double precision :: total_charge
ksi = 0.0d0
coz = 0.0d0
total_charge = 0.0d0
do i = 1, neighbors
coz = coz + x(3:5, i) * x(2, i)
total_charge = total_charge + x(2, i)
enddo
coz = coz / total_charge
do i = 2, neighbors
dipole = (x(3:5, 1) - coz) * x(6, 1) + (x(3:5, i) - coz) * x(6, i)
ksi(i) = cut_function(x(1, i), cut_start, cut_distance) &
& * (1.0d0/ x(1, i)**power + ef_scale * dot_product(dipole, field))
! ksi(i) = cut_function(x(1, i), cut_start, cut_distance) &
! & * (dot_product(dipole, field))
enddo
end function get_twobody_weights_ef
! Code for polarization
! function get_twobody_weights_pol(x, field, neighbors, power, cut_start, cut_distance, dim1, ef_scale, qidx, df) result(ksi)
!
! implicit none
!
! double precision, dimension(:,:), intent(in) :: x
! double precision, dimension(3), intent(in) :: field
! integer, intent(in) :: neighbors
! double precision, intent(in) :: power
! double precision, intent(in) :: cut_start
! double precision, intent(in) :: cut_distance
! double precision, intent(in) :: ef_scale
! integer, intent(in) :: dim1
!
! integer, intent(in) :: qidx
!
! ! Electric field displacement
! double precision, intent(in) :: df
!
! double precision, dimension(dim1) :: ksi
!
!
! integer :: i
!
! double precision, dimension(3) :: dipole
!
! ! Center of nuclear charge
! double precision, dimension(3) :: coz
! double precision :: total_charge
!
! ksi = 0.0d0
!
! coz = 0.0d0
! total_charge = 0.0d0
! do i = 1, neighbors
! coz = coz + x(3:5, i) * x(2, i)
! total_charge = total_charge + x(2, i)
! enddo
!
! coz = coz / total_charge
!
! write(*,*) "SHAPE", size(x, dim=1), size(x, dim=2)
! do i = 2, neighbors
!
! write(*,*) i, qidx, x(qidx + 5, 1), x(qidx + 5, i), sum(x(qidx + 5, :))
!
! dipole = (x(3:5, 1) - coz) * x(qidx + 5, 1) + (x(3:5, i) - coz) * x(qidx + 5, i)
!
! ! ksi(i) = cut_function(x(1, i), cut_start, cut_distance) &
! ! & * (1.0d0/ x(1, i)**power + ef_scale * dot_product(dipole, field))
!
! ksi(i) = cut_function(x(1, i), cut_start, cut_distance) &
! & * (dot_product(dipole, field))
!
! enddo
!
! end function get_twobody_weights_pol
!
! function get_ksi_pol(x, na, nneigh, two_body_power, cut_start, cut_distance, ef_scale, df) result(ksi)
!
! use omp_lib, only: omp_get_wtime
!
! implicit none
!
! ! FCHL descriptors for the training set, format (i,maxatoms,5,maxneighbors)
! double precision, dimension(:,:,:,:), intent(in) :: x
!
! ! List of numbers of atoms in each molecule
! integer, dimension(:), intent(in) :: na
!
! ! Number of neighbors for each atom in each compound
! integer, dimension(:,:), intent(in) :: nneigh
!
! ! Decaying powerlaws for two-body term
! double precision, intent(in) :: two_body_power
!
! ! Fraction of cut_distance at which cut-off starts
! double precision, intent(in) :: cut_start
! double precision, intent(in) :: cut_distance
!
! ! Electric field displacement
! double precision, intent(in) :: ef_scale
! double precision, intent(in) :: df
!
! ! Pre-computed two-body weights
! double precision, allocatable, dimension(:,:,:,:) :: ksi
!
! ! Internal counters
! integer :: maxneigh, maxatoms, nm, a, ni, i, xyz
!
! ! Electric field
! double precision, dimension(3) :: field
!
! double precision :: t_start, t_end
!
! write (*,"(A)", advance="no") "TWO-BODY TERMS POLARIZABLE"
! t_start = omp_get_wtime()
!
! maxneigh = maxval(nneigh)
! maxatoms = maxval(na)
! nm = size(x, dim=1)
!
! allocate(ksi(nm, 19, maxatoms, maxneigh))
!
! ksi = 0.0d0
!
! ! !$OMP PARALLEL DO PRIVATE(ni, field)
! do a = 1, nm
! ni = na(a)
! do xyz = 1, 19
!
! field(1) = field_displacement(xyz,1) * df
! field(2) = field_displacement(xyz,2) * df
! field(3) = field_displacement(xyz,3) * df
!
! do i = 1, ni
!
! ksi(a, xyz, i, :) = get_twobody_weights_pol(x(a,i,:,:), field, nneigh(a, i), &
! & two_body_power, cut_start, cut_distance, maxneigh, ef_scale, xyz, df)
!
! enddo
! enddo
! enddo
! ! !$OMP END PARALLEL do
!
! t_end = omp_get_wtime()
! write (*,"(A,F12.4,A)") " Time = ", t_end - t_start, " s"
!
! end function get_ksi_pol
!
! subroutine init_cosp_sinp_pol(x, na, nneigh, three_body_power, order, cut_start, cut_distance, cosp, sinp, ef_scale, df)
!
! use omp_lib, only: omp_get_wtime
!
! implicit none
!
! ! FCHL descriptors for the training set, format (i,maxatoms,5,maxneighbors)
! double precision, dimension(:,:,:,:), intent(in) :: x
!
! ! List of numbers of atoms in each molecule
! integer, dimension(:), intent(in) :: na
!
! ! Number of neighbors for each atom in each compound
! integer, dimension(:,:), intent(in) :: nneigh
!
! ! Decaying powerlaws for two-body term
! double precision, intent(in) :: three_body_power
!
! integer, intent(in) :: order
!
! ! Fraction of cut_distance at which cut-off starts
! double precision, intent(in) :: cut_start
! double precision, intent(in) :: cut_distance
! double precision, intent(in) :: ef_scale
!
! ! Electric field displacement
! double precision, intent(in) :: df
!
! ! Cosine and sine terms for each atomtype
! double precision, dimension(:,:,:,:,:,:), intent(out) :: cosp
! double precision, dimension(:,:,:,:,:,:), intent(out) :: sinp
!
!
! ! Internal counters
! integer :: maxneigh, maxatoms, pmax, nm, a, ni, i
!
! double precision, allocatable, dimension(:,:,:,:) :: fourier
!
! double precision :: t_start, t_end
!
! ! Internal counters
! integer :: xyz
!
! ! Electric field
! double precision, dimension(3) :: field
!
! write (*,"(A)", advance="no") "THREE-BODY TERMS POLARIZABLE"
! t_start = omp_get_wtime()
!
! maxneigh = maxval(nneigh)
! maxatoms = maxval(na)
! nm = size(x, dim=1)
!
! pmax = get_pmax(x, na)
!
! cosp = 0.0d0
! sinp = 0.0d0
!
! ! !$OMP PARALLEL DO PRIVATE(ni, fourier, field) schedule(dynamic)
! do a = 1, nm
! ni = na(a)
! do xyz = 1, 19
!
! field(1) = field_displacement(xyz,1) * df
! field(2) = field_displacement(xyz,2) * df
! field(3) = field_displacement(xyz,3) * df
! ! write(*,*) xyz, field_displacement(xyz,:), field
!
! do i = 1, ni
!
! fourier = get_threebody_fourier_ef(x(a,i,:,:), field, &
! & nneigh(a, i), order, three_body_power, cut_start, cut_distance, pmax, order, maxneigh, ef_scale)
!
! cosp(a,xyz,i,:,:,:) = fourier(1,:,:,:)
! sinp(a,xyz,i,:,:,:) = fourier(2,:,:,:)
!
! enddo
! enddo
! enddo
! ! !$OMP END PARALLEL DO
!
! t_end = omp_get_wtime()
! write (*,"(A,F12.4,A)") " Time = ", t_end - t_start, " s"
!
! end subroutine init_cosp_sinp_pol
function get_twobody_weights_ef_field(x, field, neighbors, power, cut_start, cut_distance, dim1, ef_scale) result(ksi)
implicit none
double precision, dimension(:,:), intent(in) :: x
double precision, dimension(3), intent(in) :: field
integer, intent(in) :: neighbors
double precision, intent(in) :: power
double precision, intent(in) :: cut_start
double precision, intent(in) :: cut_distance
double precision, intent(in) :: ef_scale
integer, intent(in) :: dim1
double precision, dimension(dim1) :: ksi
! Electric field displacement
! double precision, intent(in) :: df
integer :: i
double precision, dimension(3) :: dipole
! Center of nuclear charge
double precision, dimension(3) :: coz
double precision :: total_charge
ksi = 0.0d0
coz = 0.0d0
total_charge = 0.0d0
do i = 1, neighbors
coz = coz + x(3:5, i) * x(2, i)
total_charge = total_charge + x(2, i)
enddo
coz = coz / total_charge
do i = 2, neighbors
dipole = (x(3:5, 1) - coz) * x(6, 1) + (x(3:5, i) - coz) * x(6, i)
ksi(i) = cut_function(x(1, i), cut_start, cut_distance) &
& * (1.0d0/ x(1, i)**power + ef_scale * dot_product(dipole, field))
enddo
end function get_twobody_weights_ef_field
end module ffchl_module
================================================
FILE: qml/fchl/ffchl_scalar_kernels.f90
================================================
subroutine fget_kernels_fchl(x1, x2, verbose, n1, n2, nneigh1, nneigh2, nm1, nm2, nsigmas, &
& t_width, d_width, cut_start, cut_distance, order, pd, &
& distance_scale, angular_scale, alchemy, two_body_power, three_body_power, &
& kernel_idx, parameters, kernels)
use ffchl_module, only: scalar, get_angular_norm2, get_pmax, get_ksi, init_cosp_sinp, get_selfscalar
use ffchl_kernels, only: kernel
implicit none
! fchl descriptors for the training set, format (i,maxatoms,5,maxneighbors)
double precision, dimension(:,:,:,:), intent(in) :: x1
double precision, dimension(:,:,:,:), intent(in) :: x2
! Whether to be verbose with output
logical, intent(in) :: verbose
! List of numbers of atoms in each molecule
integer, dimension(:), intent(in) :: n1
integer, dimension(:), intent(in) :: n2
! Number of molecules
integer, intent(in) :: nm1
integer, intent(in) :: nm2
! Number of sigmas
integer, intent(in) :: nsigmas
! Number of neighbors for each atom in each compound
integer, dimension(:,:), intent(in) :: nneigh1
integer, dimension(:,:), intent(in) :: nneigh2
! Angular Gaussian width
double precision, intent(in) :: t_width
! Distance Gaussian width
double precision, intent(in) :: d_width
! Fraction of cut_distance at which cut-off starts
double precision, intent(in) :: cut_start
double precision, intent(in) :: cut_distance
! Truncation order for Fourier terms
integer, intent(in) :: order
! Periodic table distance matrix
double precision, dimension(:,:), intent(in) :: pd
! Scaling for angular and distance terms
double precision, intent(in) :: distance_scale
double precision, intent(in) :: angular_scale
! Switch alchemy on or off
logical, intent(in) :: alchemy
! Decaying power laws for two- and three-body terms
double precision, intent(in) :: two_body_power
double precision, intent(in) :: three_body_power
! Kernel ID and corresponding parameters
integer, intent(in) :: kernel_idx
double precision, dimension(:,:), intent(in) :: parameters
! Resulting alpha vector
double precision, dimension(nsigmas,nm1,nm2), intent(out) :: kernels
! Internal counters
integer :: i, j
integer :: ni, nj
integer :: a, b
! Temporary variables necessary for parallelization
double precision :: s12
! Pre-computed terms in the full distance matrix
double precision, allocatable, dimension(:,:) :: self_scalar1
double precision, allocatable, dimension(:,:) :: self_scalar2
! Pre-computed two-body weights
double precision, allocatable, dimension(:,:,:) :: ksi1
double precision, allocatable, dimension(:,:,:) :: ksi2
! Pre-computed terms for the Fourier expansion of the three-body term
double precision, allocatable, dimension(:,:,:,:,:) :: sinp1
double precision, allocatable, dimension(:,:,:,:,:) :: sinp2
double precision, allocatable, dimension(:,:,:,:,:) :: cosp1
double precision, allocatable, dimension(:,:,:,:,:) :: cosp2
! Max index in the periodic table
integer :: pmax1
integer :: pmax2
! Angular normalization constant
double precision :: ang_norm2
! Max number of neighbors
integer :: maxneigh1
integer :: maxneigh2
kernels(:,:,:) = 0.0d0
! Get max number of neighbors
maxneigh1 = maxval(nneigh1)
maxneigh2 = maxval(nneigh2)
! Calculate angular normalization constant
ang_norm2 = get_angular_norm2(t_width)
! pmax = max nuclear charge
pmax1 = get_pmax(x1, n1)
pmax2 = get_pmax(x2, n2)
! Get two-body weight function
ksi1 = get_ksi(x1, n1, nneigh1, two_body_power, cut_start, cut_distance, verbose)
ksi2 = get_ksi(x2, n2, nneigh2, two_body_power, cut_start, cut_distance, verbose)
! Allocate three-body Fourier terms
allocate(cosp1(nm1, maxval(n1), pmax1, order, maxneigh1))
allocate(sinp1(nm1, maxval(n1), pmax1, order, maxneigh1))
! Initialize and pre-calculate three-body Fourier terms
call init_cosp_sinp(x1, n1, nneigh1, three_body_power, order, cut_start, cut_distance, &
& cosp1,sinp1, verbose)
! Allocate three-body Fourier terms
allocate(cosp2(nm2, maxval(n2), pmax2, order, maxneigh2))
allocate(sinp2(nm2, maxval(n2), pmax2, order, maxneigh2))
! Initialize and pre-calculate three-body Fourier terms
call init_cosp_sinp(x2, n2, nneigh2, three_body_power, order, cut_start, cut_distance, &
& cosp2,sinp2, verbose)
! Pre-calculate self-scalar terms
self_scalar1 = get_selfscalar(x1, nm1, n1, nneigh1, ksi1, sinp1, cosp1, t_width, d_width, &
& cut_distance, order, pd, ang_norm2,distance_scale, angular_scale, alchemy, verbose)
! Pre-calculate self-scalar terms
self_scalar2 = get_selfscalar(x2, nm2, n2, nneigh2, ksi2, sinp2, cosp2, t_width, d_width, &
& cut_distance, order, pd, ang_norm2,distance_scale, angular_scale, alchemy, verbose)
!$OMP PARALLEL DO schedule(dynamic) PRIVATE(s12,ni,nj)
do b = 1, nm2
nj = n2(b)
do a = 1, nm1
ni = n1(a)
do i = 1, ni
do j = 1, nj
s12 = scalar(x1(a,i,:,:), x2(b,j,:,:), &
& nneigh1(a,i), nneigh2(b,j), ksi1(a,i,:), ksi2(b,j,:), &
& sinp1(a,i,:,:,:), sinp2(b,j,:,:,:), &
& cosp1(a,i,:,:,:), cosp2(b,j,:,:,:), &
& t_width, d_width, cut_distance, order, &
& pd, ang_norm2, distance_scale, angular_scale, alchemy)
kernels(:, a, b) = kernels(:, a, b) &
& + kernel(self_scalar1(a,i), self_scalar2(b,j), s12, &
& kernel_idx, parameters)
enddo
enddo
enddo
enddo
!$OMP END PARALLEL DO
deallocate(self_scalar1)
deallocate(self_scalar2)
deallocate(ksi1)
deallocate(ksi2)
deallocate(cosp1)
deallocate(cosp2)
deallocate(sinp1)
deallocate(sinp2)
end subroutine fget_kernels_fchl
subroutine fget_symmetric_kernels_fchl(x1, verbose, n1, nneigh1, nm1, nsigmas, &
& t_width, d_width, cut_start, cut_distance, order, pd, &
& distance_scale, angular_scale, alchemy, two_body_power, three_body_power, &
& kernel_idx, parameters, kernels)
use ffchl_module, only: scalar, get_angular_norm2, get_pmax, get_ksi, init_cosp_sinp, get_selfscalar
use ffchl_kernels, only: kernel
implicit none
! FCHL descriptors for the training set, format (i,j_1,5,m_1)
double precision, dimension(:,:,:,:), intent(in) :: x1
! Whether to be verbose with output
logical, intent(in) :: verbose
! List of numbers of atoms in each molecule
integer, dimension(:), intent(in) :: n1
! Number of neighbors for each atom in each compound
integer, dimension(:,:), intent(in) :: nneigh1
! Number of molecules
integer, intent(in) :: nm1
! Number of sigmas
integer, intent(in) :: nsigmas
double precision, intent(in) :: two_body_power
double precision, intent(in) :: three_body_power
double precision, intent(in) :: t_width
double precision, intent(in) :: d_width
double precision, intent(in) :: cut_start
double precision, intent(in) :: cut_distance
integer, intent(in) :: order
double precision, intent(in) :: distance_scale
double precision, intent(in) :: angular_scale
logical, intent(in) :: alchemy
double precision, dimension(:,:), intent(in) :: pd
! Resulting alpha vector
double precision, dimension(nsigmas,nm1,nm1), intent(out) :: kernels
! Internal counters
integer :: i, j, ni, nj
integer :: a, b
! Temporary variables necessary for parallelization
double precision :: s12
! Pre-computed terms in the full distance matrix
double precision, allocatable, dimension(:,:) :: self_scalar1
! Pre-computed terms
double precision, allocatable, dimension(:,:,:) :: ksi1
double precision, allocatable, dimension(:,:,:,:,:) :: sinp1
double precision, allocatable, dimension(:,:,:,:,:) :: cosp1
integer, intent(in) :: kernel_idx
double precision, dimension(:,:), intent(in) :: parameters
! counter for periodic distance
integer :: pmax1
! integer :: nneighi
double precision :: ang_norm2
integer :: maxneigh1
kernels(:,:,:) = 0.0d0
ang_norm2 = get_angular_norm2(t_width)
maxneigh1 = maxval(nneigh1)
pmax1 = get_pmax(x1, n1)
ksi1 = get_ksi(x1, n1, nneigh1, two_body_power, cut_start, cut_distance, verbose)
allocate(cosp1(nm1, maxval(n1), pmax1, order, maxval(nneigh1)))
allocate(sinp1(nm1, maxval(n1), pmax1, order, maxval(nneigh1)))
call init_cosp_sinp(x1, n1, nneigh1, three_body_power, order, cut_start, cut_distance, &
& cosp1,sinp1, verbose)
self_scalar1 = get_selfscalar(x1, nm1, n1, nneigh1, ksi1, sinp1, cosp1, t_width, d_width, &
& cut_distance, order, pd, ang_norm2,distance_scale, angular_scale, alchemy, verbose)
!$OMP PARALLEL DO schedule(dynamic) PRIVATE(s12,ni,nj)
do b = 1, nm1
nj = n1(b)
do a = b, nm1
ni = n1(a)
do i = 1, ni
do j = 1, nj
s12 = scalar(x1(a,i,:,:), x1(b,j,:,:), &
& nneigh1(a,i), nneigh1(b,j), ksi1(a,i,:), ksi1(b,j,:), &
& sinp1(a,i,:,:,:), sinp1(b,j,:,:,:), &
& cosp1(a,i,:,:,:), cosp1(b,j,:,:,:), &
& t_width, d_width, cut_distance, order, &
& pd, ang_norm2, distance_scale, angular_scale, alchemy)
kernels(:, a, b) = kernels(:, a, b) &
& + kernel(self_scalar1(a,i), self_scalar1(b,j), s12, &
& kernel_idx, parameters)
kernels(:, b, a) = kernels(:, a, b)
enddo
enddo
enddo
enddo
!$OMP END PARALLEL DO
deallocate(self_scalar1)
deallocate(ksi1)
deallocate(cosp1)
deallocate(sinp1)
end subroutine fget_symmetric_kernels_fchl
subroutine fget_global_symmetric_kernels_fchl(x1, verbose, n1, nneigh1, nm1, nsigmas, &
& t_width, d_width, cut_start, cut_distance, order, pd, &
& distance_scale, angular_scale, alchemy, two_body_power, three_body_power, &
& kernel_idx, parameters, kernels)
use ffchl_module, only: scalar, get_angular_norm2, get_pmax, get_ksi, init_cosp_sinp
use ffchl_kernels, only: kernel
implicit none
! FCHL descriptors for the training set, format (i,j_1,5,m_1)
double precision, dimension(:,:,:,:), intent(in) :: x1
! Whether to be verbose with output
logical, intent(in) :: verbose
! List of numbers of atoms in each molecule
integer, dimension(:), intent(in) :: n1
! Number of neighbors for each atom in each compound
integer, dimension(:,:), intent(in) :: nneigh1
! Number of molecules
integer, intent(in) :: nm1
! Number of sigmas
integer, intent(in) :: nsigmas
double precision, intent(in) :: two_body_power
double precision, intent(in) :: three_body_power
double precision, intent(in) :: t_width
double precision, intent(in) :: d_width
double precision, intent(in) :: cut_start
double precision, intent(in) :: cut_distance
integer, intent(in) :: order
double precision, intent(in) :: distance_scale
double precision, intent(in) :: angular_scale
logical, intent(in) :: alchemy
double precision, dimension(:,:), intent(in) :: pd
! Resulting alpha vector
double precision, dimension(nsigmas,nm1,nm1), intent(out) :: kernels
! Internal counters
integer :: i, j, ni, nj
integer :: a, b
! Temporary variables necessary for parallelization
double precision :: s12
! Pre-computed terms in the full distance matrix
double precision, allocatable, dimension(:) :: self_scalar1
! Pre-computed terms
double precision, allocatable, dimension(:,:,:) :: ksi1
double precision, allocatable, dimension(:,:,:,:,:) :: sinp1
double precision, allocatable, dimension(:,:,:,:,:) :: cosp1
integer, intent(in) :: kernel_idx
double precision, dimension(:,:), intent(in) :: parameters
! counter for periodic distance
integer :: pmax1
double precision :: ang_norm2
double precision :: mol_dist
integer :: maxneigh1
maxneigh1 = maxval(nneigh1)
ang_norm2 = get_angular_norm2(t_width)
pmax1 = get_pmax(x1, n1)
ksi1 = get_ksi(x1, n1, nneigh1, two_body_power, cut_start, cut_distance, verbose)
allocate(cosp1(nm1, maxval(n1), pmax1, order, maxval(nneigh1)))
allocate(sinp1(nm1, maxval(n1), pmax1, order, maxval(nneigh1)))
call init_cosp_sinp(x1, n1, nneigh1, three_body_power, order, cut_start, cut_distance, &
& cosp1,sinp1, verbose)
allocate(self_scalar1(nm1))
self_scalar1 = 0.0d0
!$OMP PARALLEL DO PRIVATE(ni) REDUCTION(+:self_scalar1)
do a = 1, nm1
ni = n1(a)
do i = 1, ni
do j = 1, ni
self_scalar1(a) = self_scalar1(a) + scalar(x1(a,i,:,:), x1(a,j,:,:), &
& nneigh1(a,i), nneigh1(a,j), ksi1(a,i,:), ksi1(a,j,:), &
& sinp1(a,i,:,:,:), sinp1(a,j,:,:,:), &
& cosp1(a,i,:,:,:), cosp1(a,j,:,:,:), &
& t_width, d_width, cut_distance, order, &
& pd, ang_norm2,distance_scale, angular_scale, alchemy)
enddo
enddo
enddo
!$OMP END PARALLEL DO
kernels(:,:,:) = 0.0d0
!$OMP PARALLEL DO schedule(dynamic) PRIVATE(s12,ni,nj,mol_dist)
do b = 1, nm1
nj = n1(b)
do a = b, nm1
ni = n1(a)
mol_dist = 0.0d0
do i = 1, ni
do j = 1, nj
s12 = scalar(x1(a,i,:,:), x1(b,j,:,:), &
& nneigh1(a,i), nneigh1(b,j), ksi1(a,i,:), ksi1(b,j,:), &
& sinp1(a,i,:,:,:), sinp1(b,j,:,:,:), &
& cosp1(a,i,:,:,:), cosp1(b,j,:,:,:), &
& t_width, d_width, cut_distance, order, &
& pd, ang_norm2, distance_scale, angular_scale, alchemy)
mol_dist = mol_dist + s12
enddo
enddo
kernels(:, a, b) = kernel(self_scalar1(a), self_scalar1(b), mol_dist, &
& kernel_idx, parameters)
kernels(:, b, a) = kernels(:, a, b)
enddo
enddo
!$OMP END PARALLEL DO
deallocate(self_scalar1)
deallocate(ksi1)
deallocate(cosp1)
deallocate(sinp1)
end subroutine fget_global_symmetric_kernels_fchl
subroutine fget_global_kernels_fchl(x1, x2, verbose, n1, n2, nneigh1, nneigh2, &
& nm1, nm2, nsigmas, &
& t_width, d_width, cut_start, cut_distance, order, pd, &
& distance_scale, angular_scale, alchemy, two_body_power, three_body_power, &
& kernel_idx, parameters, kernels)
use ffchl_module, only: scalar, get_angular_norm2, get_pmax, get_ksi, init_cosp_sinp
use ffchl_kernels, only: kernel
implicit none
! fchl descriptors for the training set, format (i,maxatoms,5,maxneighbors)
double precision, dimension(:,:,:,:), intent(in) :: x1
double precision, dimension(:,:,:,:), intent(in) :: x2
! Whether to be verbose with output
logical, intent(in) :: verbose
! List of numbers of atoms in each molecule
integer, dimension(:), intent(in) :: n1
integer, dimension(:), intent(in) :: n2
! Number of neighbors for each atom in each compound
integer, dimension(:,:), intent(in) :: nneigh1
integer, dimension(:,:), intent(in) :: nneigh2
! Number of molecules
integer, intent(in) :: nm1
integer, intent(in) :: nm2
! Number of sigmas
integer, intent(in) :: nsigmas
double precision, intent(in) :: two_body_power
double precision, intent(in) :: three_body_power
double precision, intent(in) :: t_width
double precision, intent(in) :: d_width
double precision, intent(in) :: cut_start
double precision, intent(in) :: cut_distance
integer, intent(in) :: order
double precision, intent(in) :: distance_scale
double precision, intent(in) :: angular_scale
logical, intent(in) :: alchemy
double precision, dimension(:,:), intent(in) :: pd
! Resulting alpha vector
double precision, dimension(nsigmas,nm1,nm2), intent(out) :: kernels
! Internal counters
integer :: i, j
integer :: ni, nj
integer :: a, b
! Temporary variables necessary for parallelization
double precision :: s12
! double precision, allocatable, dimension(:,:) :: atomic_distance
! Pre-computed terms in the full distance matrix
double precision, allocatable, dimension(:) :: self_scalar1
double precision, allocatable, dimension(:) :: self_scalar2
! Pre-computed terms
double precision, allocatable, dimension(:,:,:) :: ksi1
double precision, allocatable, dimension(:,:,:) :: ksi2
double precision, allocatable, dimension(:,:,:,:,:) :: sinp1
double precision, allocatable, dimension(:,:,:,:,:) :: sinp2
double precision, allocatable, dimension(:,:,:,:,:) :: cosp1
double precision, allocatable, dimension(:,:,:,:,:) :: cosp2
integer, intent(in) :: kernel_idx
double precision, dimension(:,:), intent(in) :: parameters
! counter for periodic distance
integer :: pmax1
integer :: pmax2
! integer :: nneighi
double precision :: ang_norm2
double precision :: mol_dist
integer :: maxneigh1
integer :: maxneigh2
maxneigh1 = maxval(nneigh1)
maxneigh2 = maxval(nneigh2)
ang_norm2 = get_angular_norm2(t_width)
pmax1 = get_pmax(x1, n1)
pmax2 = get_pmax(x2, n2)
ksi1 = get_ksi(x1, n1, nneigh1, two_body_power, cut_start, cut_distance, verbose)
ksi2 = get_ksi(x2, n2, nneigh2, two_body_power, cut_start, cut_distance, verbose)
allocate(cosp1(nm1, maxval(n1), pmax1, order, maxval(nneigh1)))
allocate(sinp1(nm1, maxval(n1), pmax1, order, maxval(nneigh1)))
call init_cosp_sinp(x1, n1, nneigh1, three_body_power, order, cut_start, cut_distance, &
& cosp1,sinp1, verbose)
allocate(cosp2(nm2, maxval(n2), pmax2, order, maxval(nneigh2)))
allocate(sinp2(nm2, maxval(n2), pmax2, order, maxval(nneigh2)))
call init_cosp_sinp(x2, n2, nneigh2, three_body_power, order, cut_start, cut_distance, &
& cosp2,sinp2, verbose)
! Global self-scalar have their own summation and are not a general function
allocate(self_scalar1(nm1))
allocate(self_scalar2(nm2))
self_scalar1 = 0.0d0
self_scalar2 = 0.0d0
!$OMP PARALLEL DO PRIVATE(ni) REDUCTION(+:self_scalar1)
do a = 1, nm1
ni = n1(a)
do i = 1, ni
do j= 1, ni
self_scalar1(a) = self_scalar1(a) + scalar(x1(a,i,:,:), x1(a,j,:,:), &
& nneigh1(a,i), nneigh1(a,j), ksi1(a,i,:), ksi1(a,j,:), &
& sinp1(a,i,:,:,:), sinp1(a,j,:,:,:), &
& cosp1(a,i,:,:,:), cosp1(a,j,:,:,:), &
& t_width, d_width, cut_distance, order, &
& pd, ang_norm2,distance_scale, angular_scale, alchemy)
enddo
enddo
enddo
!$OMP END PARALLEL DO
!$OMP PARALLEL DO PRIVATE(ni) REDUCTION(+:self_scalar2)
do a = 1, nm2
ni = n2(a)
do i = 1, ni
do j= 1, ni
self_scalar2(a) = self_scalar2(a) + scalar(x2(a,i,:,:), x2(a,j,:,:), &
& nneigh2(a,i), nneigh2(a,j), ksi2(a,i,:), ksi2(a,j,:), &
& sinp2(a,i,:,:,:), sinp2(a,j,:,:,:), &
& cosp2(a,i,:,:,:), cosp2(a,j,:,:,:), &
& t_width, d_width, cut_distance, order, &
& pd, ang_norm2, distance_scale, angular_scale, alchemy)
enddo
enddo
enddo
!$OMP END PARALLEL DO
kernels(:,:,:) = 0.0d0
!$OMP PARALLEL DO schedule(dynamic) PRIVATE(s12,ni,nj,mol_dist)
do b = 1, nm2
nj = n2(b)
do a = 1, nm1
ni = n1(a)
mol_dist = 0.0d0
do i = 1, ni
do j = 1, nj
s12 = scalar(x1(a,i,:,:), x2(b,j,:,:), &
& nneigh1(a,i), nneigh2(b,j), ksi1(a,i,:), ksi2(b,j,:), &
& sinp1(a,i,:,:,:), sinp2(b,j,:,:,:), &
& cosp1(a,i,:,:,:), cosp2(b,j,:,:,:), &
& t_width, d_width, cut_distance, order, &
& pd, ang_norm2, distance_scale, angular_scale, alchemy)
mol_dist = mol_dist + s12
enddo
enddo
kernels(:, a, b) = kernel(self_scalar1(a), self_scalar2(b), mol_dist, &
& kernel_idx, parameters)
enddo
enddo
!$OMP END PARALLEL DO
deallocate(self_scalar1)
deallocate(self_scalar2)
deallocate(ksi1)
deallocate(ksi2)
deallocate(cosp1)
deallocate(cosp2)
deallocate(sinp1)
deallocate(sinp2)
end subroutine fget_global_kernels_fchl
subroutine fget_atomic_kernels_fchl(x1, x2, verbose, nneigh1, nneigh2, &
& na1, na2, nsigmas, &
& t_width, d_width, cut_start, cut_distance, order, pd, &
& distance_scale, angular_scale, alchemy, two_body_power, three_body_power, &
& kernel_idx, parameters, kernels)
use ffchl_module, only: scalar, get_angular_norm2, &
& get_pmax_atomic, get_ksi_atomic, init_cosp_sinp_atomic
use ffchl_kernels, only: kernel
implicit none
! fchl descriptors for the training set, format (i,maxatoms,5,maxneighbors)
double precision, dimension(:,:,:), intent(in) :: x1
double precision, dimension(:,:,:), intent(in) :: x2
! Whether to be verbose with output
logical, intent(in) :: verbose
! Number of neighbors for each atom in each compound
integer, dimension(:), intent(in) :: nneigh1
integer, dimension(:), intent(in) :: nneigh2
! Number of molecules
integer, intent(in) :: na1
integer, intent(in) :: na2
! Number of sigmas
integer, intent(in) :: nsigmas
double precision, intent(in) :: two_body_power
double precision, intent(in) :: three_body_power
double precision, intent(in) :: t_width
double precision, intent(in) :: d_width
double precision, intent(in) :: cut_start
double precision, intent(in) :: cut_distance
integer, intent(in) :: order
double precision, intent(in) :: distance_scale
double precision, intent(in) :: angular_scale
logical, intent(in) :: alchemy
double precision, dimension(:,:), intent(in) :: pd
! Resulting alpha vector
double precision, dimension(nsigmas,na1,na2), intent(out) :: kernels
! Internal counters
integer :: i, j
! Temporary variables necessary for parallelization
double precision :: s12
! Pre-computed terms in the full distance matrix
double precision, allocatable, dimension(:) :: self_scalar1
double precision, allocatable, dimension(:) :: self_scalar2
! Pre-computed terms
double precision, allocatable, dimension(:,:) :: ksi1
double precision, allocatable, dimension(:,:) :: ksi2
double precision, allocatable, dimension(:,:,:,:) :: sinp1
double precision, allocatable, dimension(:,:,:,:) :: sinp2
double precision, allocatable, dimension(:,:,:,:) :: cosp1
double precision, allocatable, dimension(:,:,:,:) :: cosp2
integer, intent(in) :: kernel_idx
double precision, dimension(:,:), intent(in) :: parameters
! counter for periodic distance
integer :: pmax1
integer :: pmax2
double precision :: ang_norm2
integer :: maxneigh1
integer :: maxneigh2
maxneigh1 = maxval(nneigh1)
maxneigh2 = maxval(nneigh2)
ang_norm2 = get_angular_norm2(t_width)
pmax1 = get_pmax_atomic(x1, nneigh1)
pmax2 = get_pmax_atomic(x2, nneigh2)
ksi1 = get_ksi_atomic(x1, na1, nneigh1, two_body_power, cut_start, cut_distance, verbose)
ksi2 = get_ksi_atomic(x2, na2, nneigh2, two_body_power, cut_start, cut_distance, verbose)
allocate(cosp1(na1, pmax1, order, maxneigh1))
allocate(sinp1(na1, pmax1, order, maxneigh1))
call init_cosp_sinp_atomic(x1, na1, nneigh1, three_body_power, order, cut_start, cut_distance, &
& cosp1,sinp1, verbose)
allocate(cosp2(na2, pmax2, order, maxneigh2))
allocate(sinp2(na2, pmax2, order, maxneigh2))
call init_cosp_sinp_atomic(x2, na2, nneigh2, three_body_power, order, cut_start, cut_distance, &
& cosp2,sinp2, verbose)
allocate(self_scalar1(na1))
allocate(self_scalar2(na2))
self_scalar1 = 0.0d0
self_scalar2 = 0.0d0
!$OMP PARALLEL DO
do i = 1, na1
self_scalar1(i) = scalar(x1(i,:,:), x1(i,:,:), &
& nneigh1(i), nneigh1(i), ksi1(i,:), ksi1(i,:), &
& sinp1(i,:,:,:), sinp1(i,:,:,:), &
& cosp1(i,:,:,:), cosp1(i,:,:,:), &
& t_width, d_width, cut_distance, order, &
& pd, ang_norm2,distance_scale, angular_scale, alchemy)
enddo
!$OMP END PARALLEL DO
!$OMP PARALLEL DO
do i = 1, na2
self_scalar2(i) = scalar(x2(i,:,:), x2(i,:,:), &
& nneigh2(i), nneigh2(i), ksi2(i,:), ksi2(i,:), &
& sinp2(i,:,:,:), sinp2(i,:,:,:), &
& cosp2(i,:,:,:), cosp2(i,:,:,:), &
& t_width, d_width, cut_distance, order, &
& pd, ang_norm2,distance_scale, angular_scale, alchemy)
enddo
!$OMP END PARALLEL DO
kernels(:,:,:) = 0.0d0
!$OMP PARALLEL DO schedule(dynamic) PRIVATE(s12)
do i = 1, na1
do j = 1, na2
s12 = scalar(x1(i,:,:), x2(j,:,:), &
& nneigh1(i), nneigh2(j), ksi1(i,:), ksi2(j,:), &
& sinp1(i,:,:,:), sinp2(j,:,:,:), &
& cosp1(i,:,:,:), cosp2(j,:,:,:), &
& t_width, d_width, cut_distance, order, &
& pd, ang_norm2, distance_scale, angular_scale, alchemy)
kernels(:, i, j) = kernel(self_scalar1(i), self_scalar2(j), s12, &
& kernel_idx, parameters)
enddo
enddo
!$OMP END PARALLEL DO
deallocate(self_scalar1)
deallocate(self_scalar2)
deallocate(ksi1)
deallocate(ksi2)
deallocate(cosp1)
deallocate(cosp2)
deallocate(sinp1)
deallocate(sinp2)
end subroutine fget_atomic_kernels_fchl
subroutine fget_atomic_symmetric_kernels_fchl(x1, verbose, nneigh1, na1, nsigmas, &
& t_width, d_width, cut_start, cut_distance, order, pd, &
& distance_scale, angular_scale, alchemy, two_body_power, three_body_power, &
& kernel_idx, parameters, kernels)
use ffchl_module, only: scalar, get_angular_norm2, &
& get_pmax_atomic, get_ksi_atomic, init_cosp_sinp_atomic
use ffchl_kernels, only: kernel
implicit none
! fchl descriptors for the training set, format (i,maxatoms,5,maxneighbors)
double precision, dimension(:,:,:), intent(in) :: x1
! Whether to be verbose with output
logical, intent(in) :: verbose
! Number of neighbors for each atom in each compound
integer, dimension(:), intent(in) :: nneigh1
! Number of molecules
integer, intent(in) :: na1
! Number of sigmas
integer, intent(in) :: nsigmas
double precision, intent(in) :: two_body_power
double precision, intent(in) :: three_body_power
double precision, intent(in) :: t_width
double precision, intent(in) :: d_width
double precision, intent(in) :: cut_start
double precision, intent(in) :: cut_distance
integer, intent(in) :: order
double precision, intent(in) :: distance_scale
double precision, intent(in) :: angular_scale
logical, intent(in) :: alchemy
double precision, dimension(:,:), intent(in) :: pd
integer, intent(in) :: kernel_idx
double precision, dimension(:,:), intent(in) :: parameters
! Resulting alpha vector
double precision, dimension(nsigmas,na1,na1), intent(out) :: kernels
! Internal counters
integer :: i, j
! Temporary variables necessary for parallelization
double precision :: s12
! Pre-computed terms in the full distance matrix
double precision, allocatable, dimension(:) :: self_scalar1
! Pre-computed terms
double precision, allocatable, dimension(:,:) :: ksi1
double precision, allocatable, dimension(:,:,:,:) :: sinp1
double precision, allocatable, dimension(:,:,:,:) :: cosp1
! counter for periodic distance
integer :: pmax1
double precision :: ang_norm2
integer :: maxneigh1
maxneigh1 = maxval(nneigh1)
ang_norm2 = get_angular_norm2(t_width)
pmax1 = get_pmax_atomic(x1, nneigh1)
ksi1 = get_ksi_atomic(x1, na1, nneigh1, two_body_power, cut_start, cut_distance, verbose)
allocate(cosp1(na1, pmax1, order, maxneigh1))
allocate(sinp1(na1, pmax1, order, maxneigh1))
call init_cosp_sinp_atomic(x1, na1, nneigh1, three_body_power, order, cut_start, cut_distance, &
& cosp1,sinp1, verbose)
allocate(self_scalar1(na1))
self_scalar1 = 0.0d0
!$OMP PARALLEL DO
do i = 1, na1
self_scalar1(i) = scalar(x1(i,:,:), x1(i,:,:), &
& nneigh1(i), nneigh1(i), ksi1(i,:), ksi1(i,:), &
& sinp1(i,:,:,:), sinp1(i,:,:,:), &
& cosp1(i,:,:,:), cosp1(i,:,:,:), &
& t_width, d_width, cut_distance, order, &
& pd, ang_norm2,distance_scale, angular_scale, alchemy)
enddo
!$OMP END PARALLEL DO
kernels(:,:,:) = 0.0d0
!$OMP PARALLEL DO schedule(dynamic) PRIVATE(s12)
do i = 1, na1
do j = i, na1
s12 = scalar(x1(i,:,:), x1(j,:,:), &
& nneigh1(i), nneigh1(j), ksi1(i,:), ksi1(j,:), &
& sinp1(i,:,:,:), sinp1(j,:,:,:), &
& cosp1(i,:,:,:), cosp1(j,:,:,:), &
& t_width, d_width, cut_distance, order, &
& pd, ang_norm2, distance_scale, angular_scale, alchemy)
kernels(:, i, j) = kernel(self_scalar1(i), self_scalar1(j), s12, &
& kernel_idx, parameters)
kernels(:, j, i) = kernels(:, i, j)
enddo
enddo
!$OMP END PARALLEL DO
deallocate(self_scalar1)
deallocate(ksi1)
deallocate(cosp1)
deallocate(sinp1)
end subroutine fget_atomic_symmetric_kernels_fchl
subroutine fget_atomic_local_kernels_fchl(x1, x2, verbose, n1, n2, nneigh1, nneigh2, &
& nm1, nm2, na1, nsigmas, &
& t_width, d_width, cut_start, cut_distance, order, pd, &
& distance_scale, angular_scale, alchemy, two_body_power, three_body_power, &
& kernel_idx, parameters, kernels)
use ffchl_module, only: scalar, get_threebody_fourier, get_twobody_weights, &
& get_angular_norm2, get_pmax, get_ksi, init_cosp_sinp, get_selfscalar
use ffchl_kernels, only: kernel
implicit none
! fchl descriptors for the training set, format (i,maxatoms,5,maxneighbors)
double precision, dimension(:,:,:,:), intent(in) :: x1
double precision, dimension(:,:,:,:), intent(in) :: x2
! Whether to be verbose with output
logical, intent(in) :: verbose
! List of numbers of atoms in each molecule
integer, dimension(:), intent(in) :: n1
integer, dimension(:), intent(in) :: n2
! Number of neighbors for each atom in each compound
integer, dimension(:,:), intent(in) :: nneigh1
integer, dimension(:,:), intent(in) :: nneigh2
! Number of molecules
integer, intent(in) :: nm1
integer, intent(in) :: nm2
integer, intent(in) :: na1
! Number of sigmas
integer, intent(in) :: nsigmas
double precision, intent(in) :: two_body_power
double precision, intent(in) :: three_body_power
double precision, intent(in) :: t_width
double precision, intent(in) :: d_width
double precision, intent(in) :: cut_start
double precision, intent(in) :: cut_distance
integer, intent(in) :: order
double precision, intent(in) :: distance_scale
double precision, intent(in) :: angular_scale
! -1.0 / sigma^2 for use in the kernel
double precision, dimension(:,:), intent(in) :: pd
integer, intent(in) :: kernel_idx
double precision, dimension(:,:), intent(in) :: parameters
! Resulting alpha vector
double precision, dimension(nsigmas,na1,nm2), intent(out) :: kernels
integer :: idx1
! Internal counters
integer :: i, j
integer :: ni, nj
integer :: a, b
! Temporary variables necessary for parallelization
double precision :: s12
! Pre-computed terms in the full distance matrix
double precision, allocatable, dimension(:,:) :: self_scalar1
double precision, allocatable, dimension(:,:) :: self_scalar2
! Pre-computed terms
double precision, allocatable, dimension(:,:,:) :: ksi1
double precision, allocatable, dimension(:,:,:) :: ksi2
double precision, allocatable, dimension(:,:,:,:,:) :: sinp1
double precision, allocatable, dimension(:,:,:,:,:) :: sinp2
double precision, allocatable, dimension(:,:,:,:,:) :: cosp1
double precision, allocatable, dimension(:,:,:,:,:) :: cosp2
logical, intent(in) :: alchemy
! Value of PI at full FORTRAN precision.
double precision, parameter :: pi = 4.0d0 * atan(1.0d0)
! counter for periodic distance
integer :: pmax1
integer :: pmax2
! integer :: nneighi
double precision :: ang_norm2
integer :: maxneigh1
integer :: maxneigh2
maxneigh1 = maxval(nneigh1)
maxneigh2 = maxval(nneigh2)
ang_norm2 = get_angular_norm2(t_width)
pmax1 = get_pmax(x1, n1)
pmax2 = get_pmax(x2, n2)
ksi1 = get_ksi(x1, n1, nneigh1, two_body_power, cut_start, cut_distance, verbose)
ksi2 = get_ksi(x2, n2, nneigh2, two_body_power, cut_start, cut_distance, verbose)
allocate(cosp1(nm1, maxval(n1), pmax1, order, maxval(nneigh1)))
allocate(sinp1(nm1, maxval(n1), pmax1, order, maxval(nneigh1)))
call init_cosp_sinp(x1, n1, nneigh1, three_body_power, order, cut_start, cut_distance, &
& cosp1,sinp1, verbose)
allocate(cosp2(nm2, maxval(n2), pmax2, order, maxval(nneigh2)))
allocate(sinp2(nm2, maxval(n2), pmax2, order, maxval(nneigh2)))
call init_cosp_sinp(x2, n2, nneigh2, three_body_power, order, cut_start, cut_distance, &
& cosp2,sinp2, verbose)
! Pre-calculate self-scalar terms
self_scalar1 = get_selfscalar(x1, nm1, n1, nneigh1, ksi1, sinp1, cosp1, t_width, d_width, &
& cut_distance, order, pd, ang_norm2,distance_scale, angular_scale, alchemy, verbose)
! Pre-calculate self-scalar terms
self_scalar2 = get_selfscalar(x2, nm2, n2, nneigh2, ksi2, sinp2, cosp2, t_width, d_width, &
& cut_distance, order, pd, ang_norm2,distance_scale, angular_scale, alchemy, verbose)
kernels(:,:,:) = 0.0d0
!$OMP PARALLEL DO schedule(dynamic) PRIVATE(ni,nj,idx1,s12)
do a = 1, nm1
ni = n1(a)
do i = 1, ni
idx1 = sum(n1(:a)) - ni + i
do b = 1, nm2
nj = n2(b)
do j = 1, nj
s12 = scalar(x1(a,i,:,:), x2(b,j,:,:), &
& nneigh1(a,i), nneigh2(b,j), ksi1(a,i,:), ksi2(b,j,:), &
& sinp1(a,i,:,:,:), sinp2(b,j,:,:,:), &
& cosp1(a,i,:,:,:), cosp2(b,j,:,:,:), &
& t_width, d_width, cut_distance, order, &
& pd, ang_norm2, distance_scale, angular_scale, alchemy)
kernels(:, idx1, b) = kernels(:, idx1, b) &
& + kernel(self_scalar1(a,i), self_scalar2(b,j), s12, &
& kernel_idx, parameters)
enddo
enddo
enddo
enddo
!$OMP END PARALLEL DO
deallocate(self_scalar1)
deallocate(self_scalar2)
deallocate(ksi1)
deallocate(ksi2)
deallocate(cosp1)
deallocate(cosp2)
deallocate(sinp1)
deallocate(sinp2)
end subroutine fget_atomic_local_kernels_fchl
================================================
FILE: qml/kernels/__init__.py
================================================
# MIT License
#
# Copyright (c) 2017 Anders S. Christensen
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
from .kernels import *
from .distance import *
from .gradient_kernels import *
================================================
FILE: qml/kernels/distance.py
================================================
# MIT License
#
# Copyright (c) 2016 Anders Steen Christensen
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
import numpy as np
from .fdistance import fmanhattan_distance, fl2_distance
from .fdistance import fp_distance_integer, fp_distance_double
def manhattan_distance(A, B):
""" Calculates the Manhattan distances, D, between two
Numpy arrays of representations.
:math:`D_{ij} = \\|A_i - B_j\\|_1`
Where :math:`A_{i}` and :math:`B_{j}` are representation vectors.
D is calculated using an OpenMP parallel Fortran routine.
:param A: 2D array of descriptors - shape (N, representation size).
:type A: numpy array
:param B: 2D array of descriptors - shape (M, representation size).
:type B: numpy array
:return: The Manhattan-distance matrix.
:rtype: numpy array
"""
if len(A.shape) != 2 or len(B.shape) != 2:
raise ValueError('expected matrices of dimension=2')
if B.shape[1] != A.shape[1]:
raise ValueError('expected matrices containing vectors of same size')
na = A.shape[0]
nb = B.shape[0]
D = np.empty((na, nb), order='F')
fmanhattan_distance(A.T, B.T, D)
return D
def l2_distance(A, B):
""" Calculates the L2 distances, D, between two
Numpy arrays of representations.
:math:`D_{ij} = \\|A_i - B_j\\|_2`
Where :math:`A_{i}` and :math:`B_{j}` are representation vectors.
D is calculated using an OpenMP parallel Fortran routine.
:param A: 2D array of descriptors - shape (N, representation size).
:type A: numpy array
:param B: 2D array of descriptors - shape (M, representation size).
:type B: numpy array
:return: The L2-distance matrix.
:rtype: numpy array
"""
if len(A.shape) != 2 or len(B.shape) != 2:
raise ValueError('expected matrices of dimension=2')
if B.shape[1] != A.shape[1]:
raise ValueError('expected matrices containing vectors of same size')
na = A.shape[0]
nb = B.shape[0]
D = np.empty((na, nb), order='F')
fl2_distance(A.T, B.T, D)
return D
def 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.
.. math:: D_{ij} = \|A_i - B_j\|_p
Where :math:`A_{i}` and :math:`B_{j}` are representation vectors.
D is calculated using an OpenMP parallel Fortran routine.
:param A: 2D array of descriptors - shape (N, representation size).
:type A: numpy array
:param B: 2D array of descriptors - shape (M, representation size).
:type B: numpy array
:param p: The norm order
:type p: float
:return: The distance matrix.
:rtype: numpy array
"""
if len(A.shape) != 2 or len(B.shape) != 2:
raise ValueError('expected matrices of dimension=2')
if B.shape[1] != A.shape[1]:
raise ValueError('expected matrices containing vectors of same size')
na = A.shape[0]
nb = B.shape[0]
D = np.empty((na, nb), order='F')
if (type(p) == type(1)):
if (p == 2):
fl2_distance(A, B, D)
else:
fp_distance_integer(A.T, B.T, D, p)
elif (type(p) == type(1.0)):
if p.is_integer():
p = int(p)
if (p == 2):
fl2_distance(A, B, D)
else:
fp_distance_integer(A.T, B.T, D, p)
else:
fp_distance_double(A.T, B.T, D, p)
else:
raise ValueError('expected exponent of integer or float type')
return D
================================================
FILE: qml/kernels/fdistance.f90
================================================
! MIT License
!
! Copyright (c) 2016 Anders Steen Christensen
!
! Permission is hereby granted, free of charge, to any person obtaining a copy
! of this software and associated documentation files (the "Software"), to deal
! in the Software without restriction, including without limitation the rights
! to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
! copies of the Software, and to permit persons to whom the Software is
! furnished to do so, subject to the following conditions:
!
! The above copyright notice and this permission notice shall be included in all
! copies or substantial portions of the Software.
!
! THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
! IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
! FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
! AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
! LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
! OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
! SOFTWARE.
subroutine fmanhattan_distance(A, B, D)
implicit none
double precision, dimension(:,:), intent(in) :: A
double precision, dimension(:,:), intent(in) :: B
double precision, dimension(:,:), intent(inout) :: D
integer :: na, nb
integer :: i, j
na = size(A, dim=2)
nb = size(B, dim=2)
!$OMP PARALLEL DO
do i = 1, nb
do j = 1, na
D(j,i) = sum(abs(a(:,j) - b(:,i)))
enddo
enddo
!$OMP END PARALLEL DO
end subroutine fmanhattan_distance
subroutine fl2_distance(A, B, D)
implicit none
double precision, dimension(:,:), intent(in) :: A
double precision, dimension(:,:), intent(in) :: B
double precision, dimension(:,:), intent(inout) :: D
integer :: na, nb, nv
integer :: i, j
double precision, allocatable, dimension(:) :: temp
nv = size(A, dim=1)
na = size(A, dim=2)
nb = size(B, dim=2)
allocate(temp(nv))
!$OMP PARALLEL DO PRIVATE(temp)
do i = 1, nb
do j = 1, na
temp(:) = A(:,j) - B(:,i)
D(j,i) = sqrt(sum(temp*temp))
enddo
enddo
!$OMP END PARALLEL DO
deallocate(temp)
end subroutine fl2_distance
subroutine fp_distance_double(A, B, D, p)
implicit none
double precision, dimension(:,:), intent(in) :: A
double precision, dimension(:,:), intent(in) :: B
double precision, dimension(:,:), intent(inout) :: D
double precision, intent(in) :: p
integer :: na, nb, nv
integer :: i, j
double precision, allocatable, dimension(:) :: temp
double precision :: inv_p
nv = size(A, dim=1)
na = size(A, dim=2)
nb = size(B, dim=2)
inv_p = 1.0d0 / p
allocate(temp(nv))
!$OMP PARALLEL DO PRIVATE(temp)
do i = 1, nb
do j = 1, na
temp(:) = abs(A(:,j) - B(:,i))
D(j,i) = (sum(temp**p))**inv_p
enddo
enddo
!$OMP END PARALLEL DO
deallocate(temp)
end subroutine fp_distance_double
subroutine fp_distance_integer(A, B, D, p)
implicit none
double precision, dimension(:,:), intent(in) :: A
double precision, dimension(:,:), intent(in) :: B
double precision, dimension(:,:), intent(inout) :: D
integer, intent(in) :: p
integer :: na, nb, nv
integer :: i, j
double precision, allocatable, dimension(:) :: temp
double precision :: inv_p
nv = size(A, dim=1)
na = size(A, dim=2)
nb = size(B, dim=2)
inv_p = 1.0d0 / dble(p)
allocate(temp(nv))
!$OMP PARALLEL DO PRIVATE(temp)
do i = 1, nb
do j = 1, na
temp(:) = abs(A(:,j) - B(:,i))
D(j,i) = (sum(temp**p))**inv_p
enddo
enddo
!$OMP END PARALLEL DO
deallocate(temp)
end subroutine fp_distance_integer
================================================
FILE: qml/kernels/fgradient_kernels.f90
================================================
! MIT License
!
! Copyright (c) 2018-2019 Anders Steen Christensen
!
! Permission is hereby granted, free of charge, to any person obtaining a copy
! of this software and associated documentation files (the "Software"), to deal
! in the Software without restriction, including without limitation the rights
! to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
! copies of the Software, and to permit persons to whom the Software is
! furnished to do so, subject to the following conditions:
!
! The above copyright notice and this permission notice shall be included in all
! copies or substantial portions of the Software.
!
! THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
! IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
! FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
! AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
! LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
! OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
! SOFTWARE.
subroutine fglobal_kernel(x1, x2, q1, q2, n1, n2, nm1, nm2, sigma, kernel)
implicit none
double precision, dimension(:,:,:), intent(in) :: x1
double precision, dimension(:,:,:), intent(in) :: x2
integer, dimension(:,:), intent(in) :: q1
integer, dimension(:,:), intent(in) :: q2
integer, dimension(:), intent(in) :: n1
integer, dimension(:), intent(in) :: n2
integer, intent(in) :: nm1
integer, intent(in) :: nm2
double precision, intent(in) :: sigma
double precision, dimension(nm2,nm1), intent(out) :: kernel
integer :: i1, i2
integer :: j1, j2
integer :: a, b
integer :: rep_size
double precision :: inv_sigma2
double precision, allocatable, dimension(:) :: d
double precision, dimension(nm1) :: s11
double precision, dimension(nm2) :: s22
double precision :: s12
double precision :: l2
kernel = 0.0d0
rep_size = size(x1, dim=3)
allocate(d(rep_size))
inv_sigma2 = -1.0d0 / (2 * sigma**2)
s11(:) = 0.0d0
!$OMP PARALLEL DO REDUCTION(+:s11)
do a = 1, nm1
do j1 = 1, n1(a)
do i1 = 1, n1(a)
if (q1(j1,a) == q1(i1,a)) then
s11(a) = s11(a) + dot_product(x1(a,j1,:), x1(a,i1,:))
endif
enddo
enddo
enddo
!$OMP END PARALLEL DO
s22(:) = 0.0d0
!$OMP PARALLEL DO REDUCTION(+:s22)
do b = 1, nm2
do j2 = 1, n2(b)
do i2 = 1, n2(b)
if (q2(j2,b) == q2(i2,b)) then
s22(b) = s22(b) + dot_product(x2(b,j2,:), x2(b,i2,:))
endif
enddo
enddo
enddo
!$OMP END PARALLEL DO
!$OMP PARALLEL DO private(s12, l2) schedule(dynamic)
do a = 1, nm1
! Molecule 2
do b = 1, nm2
s12 = 0.0d0
! Atom in Molecule 1
do j1 = 1, n1(a)
!Atom in Molecule2
do j2 = 1, n2(b)
if (q1(j1,a) == q2(j2,b)) then
s12 = s12 + dot_product(x1(a,j1,:), x2(b,j2,:))
endif
enddo
enddo
l2 = s11(a) + s22(b) - 2.0d0*s12
kernel(b, a) = exp(l2 * inv_sigma2)
enddo
enddo
!$OMP END PARALLEL DO
deallocate(d)
end subroutine fglobal_kernel
subroutine flocal_kernels(x1, x2, q1, q2, n1, n2, nm1, nm2, sigmas, nsigmas, kernel)
! use omp_lib, only: omp_get_thread_num, omp_get_wtime
implicit none
double precision, dimension(:,:,:), intent(in) :: x1
double precision, dimension(:,:,:), intent(in) :: x2
integer, dimension(:,:), intent(in) :: q1
integer, dimension(:,:), intent(in) :: q2
integer, dimension(:), intent(in) :: n1
integer, dimension(:), intent(in) :: n2
integer, intent(in) :: nm1
integer, intent(in) :: nm2
double precision, dimension(:), intent(in) :: sigmas
integer, intent(in) :: nsigmas
double precision, dimension(nsigmas,nm2,nm1), intent(out) :: kernel
! integer, external :: omp_get_thread_num
integer :: j1, j2
integer :: a, b
integer :: i
integer :: work_done
integer :: work_total
! integer :: rep_size
double precision, dimension(nsigmas) :: inv_sigma2
double precision :: l2
double precision :: t_start
double precision :: t_elapsed
double precision :: t_eta
kernel = 0.0d0
do i =1, nsigmas
inv_sigma2(i) = -1.0d0 / (2 * sigmas(i)**2)
enddo
! !$OMP PARALLEL private(tid)
! tid = OMP_get_thread_num()
! write(*,*) tid
! !$OMP END PARALLEL
! work_total = nm1 * nm2
! work_done = 0
! t_start = omp_get_wtime()
! write(*,*) "QML: Non-alchemical Gaussian kernel progess:"
!$OMP PARALLEL DO private(l2) shared(work_total) schedule(dynamic)
do a = 1, nm1
! if (omp_get_thread_num() == 0) then
! t_elapsed = omp_get_wtime() - t_start
! t_eta = t_elapsed * work_total / work_done - t_elapsed
! write(*,"(F10.1, A, F10.1, A, F10.1, A, F10.1, A)") dble(work_done) / dble(work_total) * 100.0d0 , " %", &
! & t_eta, " s", t_elapsed, " s", t_elapsed + t_eta, " s"
! write(*,"(A, F10.1, A)") "elapsed", omp_get_wtime() - t_start, "s"
! write(*,"(A, F10.1, A)") "eta", (omp_get_wtime() - t_start) * dble(work_total) / dble(work_done) &
! & - (omp_get_wtime() - t_start), "s"
! endif
! Molecule 2
do b = 1, nm2
! Atom in Molecule 1
do j1 = 1, n1(a)
!Atom in Molecule2
do j2 = 1, n2(b)
if (q1(j1,a) == q2(j2,b)) then
l2 = sum((x1(a,j1,:) - x2(b,j2,:))**2)
kernel(:, b, a) = kernel(:, b, a) + exp(l2 * inv_sigma2(:))
endif
enddo
enddo
enddo
! !$OMP ATOMIC
! work_done = work_done + nm2
! !$OMP END ATOMIC
enddo
!$OMP END PARALLEL do
! write(*,"(F10.1, A)") dble(work_done) / dble(work_total) * 100.0d0 , " %"
! write(*,*) "QML: Non-alchemical Gaussian kernel completed!"
end subroutine flocal_kernels
subroutine fsymmetric_local_kernels(x1, q1, n1, nm1, sigmas, nsigmas, kernel)
! use omp_lib, only: omp_get_thread_num, omp_get_wtime
implicit none
double precision, dimension(:,:,:), intent(in) :: x1
integer, dimension(:,:), intent(in) :: q1
integer, dimension(:), intent(in) :: n1
integer, intent(in) :: nm1
double precision, dimension(:), intent(in) :: sigmas
integer, intent(in) :: nsigmas
double precision, dimension(nsigmas,nm1,nm1), intent(out) :: kernel
integer :: j1, j2
integer :: a, b
integer :: i
integer :: work_done
integer :: work_total
integer :: rep_size
double precision, allocatable, dimension(:) :: inv_sigma2
double precision :: l2
double precision :: t_start
double precision :: t_elapsed
double precision :: t_eta
kernel = 0.0d0
rep_size = size(x1, dim=3)
allocate(inv_sigma2(nsigmas))
do i =1, nsigmas
inv_sigma2(i) = -1.0d0 / (2 * sigmas(i)**2)
enddo
! work_total = (nm1 * (nm1 + 1)) / 2
! work_done = 0
! t_start = omp_get_wtime()
! write(*,*) "QML: Non-alchemical Gaussian kernel progess:"
!$OMP PARALLEL DO private(l2) shared(work_done) schedule(dynamic)
do a = 1, nm1
! ! if (omp_get_thread_num() == 0) then
! ! write(*,"(F10.1, A)") dble(work_done) / dble(work_total) * 100.0d0 , " %"
! ! endif
! if (omp_get_thread_num() == 0) then
! t_elapsed = omp_get_wtime() - t_start
! t_eta = t_elapsed * work_total / work_done - t_elapsed
! write(*,"(F10.1, A, F10.1, A, F10.1, A, F10.1, A)") dble(work_done) / dble(work_total) * 100.0d0 , " %", &
! & t_eta, " s", t_elapsed, " s", t_elapsed + t_eta, " s"
! ! write(*,"(A, F10.1, A)") "elapsed", omp_get_wtime() - t_start, "s"
! ! write(*,"(A, F10.1, A)") "eta", (omp_get_wtime() - t_start) * dble(work_total) / dble(work_done) &
! ! & - (omp_get_wtime() - t_start), "s"
! endif
! Molecule 2
do b = a, nm1
! Atom in Molecule 1
do j1 = 1, n1(a)
!Atom in Molecule2
do j2 = 1, n1(b)
if (q1(j1,a) == q1(j2,b)) then
l2 = sum((x1(a,j1,:) - x1(b,j2,:))**2)
kernel(:, b, a) = kernel(:, b, a) + exp(l2 * inv_sigma2(:))
endif
enddo
enddo
if (b > a) then
kernel(:, a, b) = kernel(:, b, a)
endif
enddo
!$OMP ATOMIC
work_done = work_done + (nm1 - a + 1)
!$OMP END ATOMIC
enddo
!$OMP END PARALLEL do
write(*,"(F10.1, A)") dble(work_done) / dble(work_total) * 100.0d0 , " %"
write(*,*) "QML: Non-alchemical Gaussian kernel completed!"
deallocate(inv_sigma2)
end subroutine fsymmetric_local_kernels
subroutine flocal_kernel(x1, x2, q1, q2, n1, n2, nm1, nm2, sigma, kernel)
implicit none
double precision, dimension(:,:,:), intent(in) :: x1
double precision, dimension(:,:,:), intent(in) :: x2
integer, dimension(:,:), intent(in) :: q1
integer, dimension(:,:), intent(in) :: q2
integer, dimension(:), intent(in) :: n1
integer, dimension(:), intent(in) :: n2
integer, intent(in) :: nm1
integer, intent(in) :: nm2
double precision, intent(in) :: sigma
double precision, dimension(nm2,nm1), intent(out) :: kernel
integer :: j1, j2
integer :: a, b
integer :: rep_size
double precision :: inv_sigma2
double precision :: l2
kernel = 0.0d0
rep_size = size(x1, dim=3)
inv_sigma2 = -1.0d0 / (2 * sigma**2)
!$OMP PARALLEL DO private(l2) schedule(dynamic)
do a = 1, nm1
! Molecule 2
do b = 1, nm2
! Atom in Molecule 1
do j1 = 1, n1(a)
!Atom in Molecule2
do j2 = 1, n2(b)
if (q1(j1,a) == q2(j2,b)) then
l2 = sum((x1(a,j1,:) - x2(b,j2,:))**2)
kernel(b, a) = kernel(b, a) + exp(l2 * inv_sigma2)
endif
enddo
enddo
enddo
enddo
!$OMP END PARALLEL do
end subroutine flocal_kernel
subroutine fsymmetric_local_kernel(x1, q1, n1, nm1, sigma, kernel)
implicit none
double precision, dimension(:,:,:), intent(in) :: x1
integer, dimension(:,:), intent(in) :: q1
integer, dimension(:), intent(in) :: n1
integer, intent(in) :: nm1
double precision, intent(in) :: sigma
double precision, dimension(nm1,nm1), intent(out) :: kernel
integer :: j1, j2
integer :: a, b
integer :: rep_size
double precision :: inv_sigma2
double precision :: l2
kernel = 0.0d0
rep_size = size(x1, dim=3)
inv_sigma2 = -1.0d0 / (2 * sigma**2)
!$OMP PARALLEL DO private(l2) schedule(dynamic)
do a = 1, nm1
! Molecule 2
do b = a, nm1
! Atom in Molecule 1
do j1 = 1, n1(a)
!Atom in Molecule2
do j2 = 1, n1(b)
if (q1(j1,a) == q1(j2,b)) then
l2 = sum((x1(a,j1,:) - x1(b,j2,:))**2)
kernel(a, b) = kernel(a, b) + exp(l2 * inv_sigma2)
endif
enddo
enddo
if (b > a) then
kernel(b, a) = kernel(a, b)
endif
enddo
enddo
!$OMP END PARALLEL do
end subroutine fsymmetric_local_kernel
subroutine fatomic_local_kernel(x1, x2, q1, q2, n1, n2, nm1, nm2, na1, sigma, kernel)
implicit none
double precision, dimension(:,:,:), intent(in) :: x1
double precision, dimension(:,:,:), intent(in) :: x2
integer, dimension(:,:), intent(in) :: q1
integer, dimension(:,:), intent(in) :: q2
integer, dimension(:), intent(in) :: n1
integer, dimension(:), intent(in) :: n2
integer, intent(in) :: nm1
integer, intent(in) :: nm2
integer, intent(in) :: na1
double precision, intent(in) :: sigma
double precision, dimension(nm2,na1), intent(out) :: kernel
integer :: j1, j2
integer :: a, b
integer :: idx1_start, idx1
integer :: rep_size
double precision :: inv_sigma2
double precision :: l2
kernel = 0.0d0
rep_size = size(x1, dim=3)
inv_sigma2 = -1.0d0 / (2 * sigma**2)
!$OMP PARALLEL DO private(idx1_start, idx1, l2) schedule(dynamic)
do a = 1, nm1
idx1_start = sum(n1(:a)) - n1(a)
! Molecule 2
do b = 1, nm2
! Atom in Molecule 1
do j1 = 1, n1(a)
idx1 = idx1_start + j1
!Atom in Molecule2
do j2 = 1, n2(b)
if (q1(j1,a) == q2(j2,b)) then
l2 = sum((x1(a,j1,:) - x2(b,j2,:))**2)
kernel(b,idx1) = kernel(b,idx1) + exp(l2 * inv_sigma2)
endif
enddo
enddo
enddo
enddo
!$OMP END PARALLEL do
end subroutine fatomic_local_kernel
subroutine fatomic_local_gradient_kernel(x1, x2, dx2, q1, q2, n1, n2, nm1, nm2, na1, naq2, sigma, kernel)
implicit none
double precision, dimension(:,:,:), intent(in) :: x1
double precision, dimension(:,:,:), intent(in) :: x2
double precision, dimension(:,:,:,:,:), intent(in) :: dx2
integer, dimension(:,:), intent(in) :: q1
integer, dimension(:,:), intent(in) :: q2
integer, dimension(:), intent(in) :: n1
integer, dimension(:), intent(in) :: n2
integer, intent(in) :: nm1
integer, intent(in) :: nm2
integer, intent(in) :: na1
integer, intent(in) :: naq2
double precision, intent(in) :: sigma
double precision, dimension(naq2,na1), intent(out) :: kernel
integer :: i2, j1, j2
integer :: xyz2
integer :: a, b
integer :: idx1_start, idx2_end, idx2_start, idx2, idx1
integer :: rep_size
double precision :: expd
double precision :: inv_2sigma2
double precision :: inv_sigma2
double precision, allocatable, dimension(:) :: d
double precision, allocatable, dimension(:,:,:,:) :: sorted_derivs
rep_size = size(x1, dim=3)
allocate(d(rep_size))
inv_2sigma2 = -1.0d0 / (2 * sigma**2)
inv_sigma2 = -1.0d0 / (sigma**2)
allocate(sorted_derivs(rep_size,maxval(n2)*3,maxval(n2),nm2))
sorted_derivs = 0.0d0
! Presort the representation derivatives
do b = 1, nm2
do i2 = 1, n2(b)
idx2 = 0
do j2 = 1, n2(b)
do xyz2 = 1, 3
idx2 = idx2 + 1
sorted_derivs(:,idx2,i2,b) = dx2(b, i2,:,j2,xyz2)
enddo
enddo
enddo
enddo
kernel = 0.0d0
!$OMP PARALLEL DO PRIVATE(idx2_end,idx2_start,d,expd,idx1_start,idx1) schedule(dynamic)
do a = 1, nm1
idx1_start = sum(n1(:a)) - n1(a) + 1
! Atom in Molecule 1
do j1 = 1, n1(a)
idx1 = idx1_start - 1 + j1
! Molecule 2
do b = 1, nm2
idx2_start = (sum(n2(:b)) - n2(b))*3 + 1
idx2_end = sum(n2(:b))*3
!Atom in Molecule2
do j2 = 1, n2(b)
if (q1(j1,a) == q2(j2,b)) then
! Calculate the distance vector, and some intermediate results
d(:) = x1(a,j1,:)- x2(b,j2,:)
expd = inv_sigma2 * exp(sum(d**2) * inv_2sigma2)
! Add the dot product to the kernel in one BLAS call
call dgemv("T", rep_size, n2(b)*3, expd, sorted_derivs(:,:n2(b)*3,j2,b), &
& rep_size, d, 1, 1.0d0, kernel(idx2_start:idx2_end,idx1), 1)
endif
enddo
enddo
enddo
enddo
!$OMP END PARALLEL do
deallocate(sorted_derivs)
deallocate(d)
end subroutine fatomic_local_gradient_kernel
! NOTE: Legacy code without any fancy BLAS calls, for reference
!
! subroutine fatomic_local_gradient_kernel(x1, x2, dx2, q1, q2, n1, n2, nm1, nm2, na1, naq2, sigma, kernel)
!
! implicit none
!
! double precision, dimension(:,:,:), intent(in) :: x1
! double precision, dimension(:,:,:), intent(in) :: x2
!
! double precision, dimension(:,:,:,:,:), intent(in) :: dx2
!
! integer, dimension(:,:), intent(in) :: q1
! integer, dimension(:,:), intent(in) :: q2
!
! integer, dimension(:), intent(in) :: n1
! integer, dimension(:), intent(in) :: n2
!
! integer, intent(in) :: nm1
! integer, intent(in) :: nm2
! integer, intent(in) :: na1
! integer, intent(in) :: naq2
!
! double precision, intent(in) :: sigma
!
! double precision, dimension(naq2,na1), intent(out) :: kernel
!
! integer :: i2, j1, j2
! integer :: na, nb, xyz2
! integer :: a, b
! integer :: idx1_end, idx1_start, idx2_end, idx2_start, idx2, idx1
!
! integer :: rep_size
!
! double precision :: expd
! double precision :: inv_2sigma2
! double precision :: inv_sigma2
!
! double precision, allocatable, dimension(:) :: d
!
! rep_size = size(x1, dim=3)
! allocate(d(rep_size))
!
! inv_2sigma2 = -1.0d0 / (2 * sigma**2)
! inv_sigma2 = -1.0d0 / (sigma**2)
!
! kernel = 0.0d0
!
! ! Molecule 1
! do a = 1, nm1
!
! na = n1(a)
!
! idx1_end = sum(n1(:a))
! idx1_start = idx1_end - na + 1
!
!
! ! Atom in Molecule 1
! do j1 = 1, na
! idx1 = idx1_start - 1 + j1
!
! ! Molecule 2
! do b = 1, nm2
! nb = n2(b)
!
! idx2_end = sum(n2(:b))
! idx2_start = idx2_end - nb + 1
!
! !Atom in Molecule2
! do j2 = 1, nb
!
! if (q1(j1,a) == q2(j2,b)) then
!
! d(:) = x1(a,j1,:)- x2(b,j2,:)
! ! expd = -1.0d0/sigma**2 * exp(-(norm2(d)**2) / (2 * sigma**2))
! expd = inv_sigma2 * exp((norm2(d)**2) * inv_2sigma2) ! Possibly 4??
!
! ! Derivative WRT this atom in Molecule 2
! do i2 = 1, nb
!
! ! Loop over XYZ
! do xyz2 = 1, 3
!
! idx2 = (idx2_start-1)*3 + (i2-1)*3 + xyz2
! kernel(idx2, idx1) = kernel(idx2, idx1) + expd * dot_product(d, dx2(b, j2,:,i2,xyz2))
!
! enddo
!
! endif
! enddo
!
! endif
!
! enddo
! enddo
! enddo
! enddo
!
!
!
!
! end subroutine fatomic_local_gradient_kernel
subroutine flocal_gradient_kernel(x1, x2, dx2, q1, q2, n1, n2, nm1, nm2, naq2, sigma, kernel)
implicit none
double precision, dimension(:,:,:), intent(in) :: x1
double precision, dimension(:,:,:), intent(in) :: x2
double precision, dimension(:,:,:,:,:), intent(in) :: dx2
integer, dimension(:,:), intent(in) :: q1
integer, dimension(:,:), intent(in) :: q2
integer, dimension(:), intent(in) :: n1
integer, dimension(:), intent(in) :: n2
integer, intent(in) :: nm1
integer, intent(in) :: nm2
integer, intent(in) :: naq2
double precision, intent(in) :: sigma
double precision, dimension(naq2,nm1), intent(out) :: kernel
integer :: i2, j1, j2
integer :: nb, xyz2
integer :: a, b
integer :: idx2_end, idx2_start, idx2
integer :: rep_size
double precision :: expd, inv_2sigma2, inv_sigma2
double precision, allocatable, dimension(:) :: d
double precision, allocatable, dimension(:,:,:,:) :: sorted_derivs
rep_size = size(x1, dim=3)
allocate(d(rep_size))
inv_2sigma2 = -1.0d0 / (2 * sigma**2)
inv_sigma2 = -1.0d0 / (sigma**2)
kernel = 0.0d0
allocate(sorted_derivs(rep_size,maxval(n2)*3,maxval(n2),nm2))
sorted_derivs = 0.0d0
! Presort the representation derivatives
do b = 1, nm2
do i2 = 1, n2(b)
idx2 = 0
do j2 = 1, n2(b)
do xyz2 = 1, 3
idx2 = idx2 + 1
sorted_derivs(:,idx2,i2,b) = dx2(b, i2,:,j2,xyz2)
enddo
enddo
enddo
enddo
! Molecule 1
!$OMP PARALLEL DO PRIVATE(idx2_end,idx2_start,d,expd) schedule(dynamic)
do a = 1, nm1
! Atom in Molecule 1
do j1 = 1, n1(a)
! Molecule 2
do b = 1, nm2
nb = n2(b)
idx2_start = (sum(n2(:b)) - n2(b))*3 + 1
idx2_end = sum(n2(:b))*3
!Atom in Molecule2
do j2 = 1, n2(b)
if (q1(j1,a) == q2(j2,b)) then
! Calculate the distance vector, and some intermediate results
d(:) = x1(a,j1,:)- x2(b,j2,:)
expd = inv_sigma2 * exp(sum(d**2) * inv_2sigma2)
! Add the dot products to the kernel in one BLAS call
call dgemv("T", rep_size, n2(b)*3, expd, sorted_derivs(:,:n2(b)*3,j2,b), &
& rep_size, d, 1, 1.0d0, kernel(idx2_start:idx2_end,a), 1)
endif
enddo
enddo
enddo
enddo
!$OMP END PARALLEL do
deallocate(sorted_derivs)
deallocate(d)
end subroutine flocal_gradient_kernel
subroutine fgdml_kernel(x1, x2, dx1, dx2, q1, q2, n1, n2, nm1, nm2, na1, na2, sigma, kernel)
implicit none
double precision, dimension(:,:,:), intent(in) :: x1
double precision, dimension(:,:,:), intent(in) :: x2
double precision, dimension(:,:,:,:,:), intent(in) :: dx1
double precision, dimension(:,:,:,:,:), intent(in) :: dx2
integer, dimension(:,:), intent(in) :: q1
integer, dimension(:,:), intent(in) :: q2
integer, dimension(:), intent(in) :: n1
integer, dimension(:), intent(in) :: n2
integer, intent(in) :: nm1
integer, intent(in) :: nm2
integer, intent(in) :: na1
integer, intent(in) :: na2
double precision, intent(in) :: sigma
double precision, dimension(na2*3,na1*3), intent(out) :: kernel
integer :: i1, i2, j2, k
integer :: xyz2
integer :: a, b
integer :: idx1_end, idx1_start, idx2_end, idx2_start, idx2
integer :: rep_size
double precision :: expd, expdiag
double precision :: inv_2sigma2
double precision :: inv_sigma4
double precision :: sigma2
double precision, allocatable, dimension(:) :: d
double precision, allocatable, dimension(:,:) :: hess
double precision, allocatable, dimension(:,:) :: partial
double precision, allocatable, dimension(:,:,:,:) :: sorted_derivs1
double precision, allocatable, dimension(:,:,:,:) :: sorted_derivs2
rep_size = size(x1, dim=3)
allocate(d(rep_size))
allocate(partial(rep_size,maxval(n2)*3))
partial = 0.0d0
allocate(hess(rep_size, rep_size))
allocate(sorted_derivs1(rep_size,maxval(n1)*3,maxval(n1),nm1))
allocate(sorted_derivs2(rep_size,maxval(n2)*3,maxval(n2),nm2))
sorted_derivs1 = 0.0d0
sorted_derivs2 = 0.0d0
! Presort the representation derivatives
do b = 1, nm2
do i2 = 1, n2(b)
idx2 = 0
do j2 = 1, n2(b)
do xyz2 = 1, 3
idx2 = idx2 + 1
sorted_derivs2(:,idx2,i2,b) = dx2(b, i2,:,j2,xyz2)
enddo
enddo
enddo
enddo
! Presort the representation derivatives
do b = 1, nm1
do i2 = 1, n1(b)
idx2 = 0
do j2 = 1, n1(b)
do xyz2 = 1, 3
idx2 = idx2 + 1
sorted_derivs1(:,idx2,i2,b) = dx1(b, i2,:,j2,xyz2)
enddo
enddo
enddo
enddo
! Reset kernel
kernel = 0.0d0
! Calculate these only once
inv_2sigma2 = -1.0d0 / (2 * sigma**2)
inv_sigma4 = -1.0d0 / (sigma**4)
sigma2 = -1.0d0 * sigma**2
!$OMP PARALLEL DO PRIVATE(idx1_start,idx2_start,d,expd,expdiag,hess,idx1_end,idx2_end,partial) schedule(dynamic)
do a = 1, nm1
idx1_start = (sum(n1(:a)) - n1(a))*3 + 1
idx1_end = sum(n1(:a))*3
do b = 1, nm2
idx2_start = (sum(n2(:b)) - n2(b))*3 + 1
idx2_end = sum(n2(:b))*3
! Atoms A and B
do i1 = 1, n1(a)
do i2 = 1, n2(b)
if (q1(i1,a) == q2(i2,b)) then
! Calculate the distance vector, and some intermediate results
d(:) = x1(a,i1,:)- x2(b,i2,:)
expd = inv_sigma4 * exp(sum(d**2) * inv_2sigma2)
expdiag = sigma2 * expd
! Calculate the outer product of the distance
hess = 0.0d0
call dsyr("U", rep_size, expd, d, 1, hess, rep_size)
do k = 1, rep_size
hess(k,k) = hess(k,k) + expdiag
enddo
! ! Do the first half of the dot product, save in partial(:,:)
! call dsymm("L", "U", rep_size, n1(a)*3, 1.0d0, hess(:,:), &
! & rep_size, sorted_derivs1(:,:n1(a)*3,i1,a), rep_size, &
! & 0.0d0, partial(:,:n1(a)*3), rep_size)
! ! Add the dot product to the kernel in one BLAS call
! call dgemm("T", "N", n1(a)*3, n2(b)*3, rep_size, 1.0d0, &
! & partial(:,:n1(a)*3), rep_size, &
! & sorted_derivs2(:,:n2(b)*3,i2,b), rep_size, 1.0d0, &
! & kernel(idx1_start:idx1_end,idx2_start:idx2_end), n1(a)*3, 1)
! Do the first half of the dot product, save in partial(:,:)
call dsymm("L", "U", rep_size, n2(b)*3, 1.0d0, hess(:,:), &
& rep_size, sorted_derivs2(:,:n2(b)*3,i2,b), rep_size, &
& 0.0d0, partial(:,:n2(b)*3), rep_size)
! Add the dot product to the kernel in one BLAS call
call dgemm("T", "N", n2(b)*3, n1(a)*3, rep_size, 1.0d0, &
& partial(:,:n2(b)*3), rep_size, &
& sorted_derivs1(:,:n1(a)*3,i1,a), rep_size, 1.0d0, &
& kernel(idx2_start:idx2_end,idx1_start:idx1_end), n2(b)*3, 1)
endif
enddo
enddo
enddo
enddo
!$OMP END PARALLEL do
deallocate(hess)
deallocate(sorted_derivs1)
deallocate(sorted_derivs2)
deallocate(partial)
deallocate(d)
end subroutine fgdml_kernel
subroutine fsymmetric_gdml_kernel(x1, dx1, q1, n1, nm1, na1, sigma, kernel)
implicit none
double precision, dimension(:,:,:), intent(in) :: x1
double precision, dimension(:,:,:,:,:), intent(in) :: dx1
integer, dimension(:,:), intent(in) :: q1
integer, dimension(:), intent(in) :: n1
integer, intent(in) :: nm1
integer, intent(in) :: na1
double precision, intent(in) :: sigma
double precision, dimension(na1*3,na1*3), intent(out) :: kernel
integer :: i1, i2, j2, k
integer :: xyz2
integer :: a, b
integer :: idx1_end, idx1_start, idx2_end, idx2_start, idx2
integer :: rep_size
double precision :: expd, expdiag
double precision :: inv_2sigma2
double precision :: inv_sigma4
double precision :: sigma2
double precision, allocatable, dimension(:) :: d
double precision, allocatable, dimension(:,:) :: hess
double precision, allocatable, dimension(:,:) :: partial
double precision, allocatable, dimension(:,:,:,:) :: sorted_derivs1
rep_size = size(x1, dim=3)
allocate(d(rep_size))
allocate(partial(rep_size,maxval(n1)*3))
partial = 0.0d0
allocate(hess(rep_size, rep_size))
allocate(sorted_derivs1(rep_size,maxval(n1)*3,maxval(n1),nm1))
sorted_derivs1 = 0.0d0
! Presort the representation derivatives
do b = 1, nm1
do i2 = 1, n1(b)
idx2 = 0
do j2 = 1, n1(b)
do xyz2 = 1, 3
idx2 = idx2 + 1
sorted_derivs1(:,idx2,i2,b) = dx1(b, i2,:,j2,xyz2)
enddo
enddo
enddo
enddo
! Reset kernel
kernel = 0.0d0
! Calculate these only once
inv_2sigma2 = -1.0d0 / (2 * sigma**2)
inv_sigma4 = -1.0d0 / (sigma**4)
sigma2 = -1.0d0 * sigma**2
!$OMP PARALLEL DO PRIVATE(idx1_start,idx2_start,d,expd,expdiag,hess,idx1_end,idx2_end,partial) schedule(dynamic)
do a = 1, nm1
idx1_start = (sum(n1(:a)) - n1(a))*3 + 1
idx1_end = sum(n1(:a))*3
do b = a, nm1
idx2_start = (sum(n1(:b)) - n1(b))*3 + 1
idx2_end = sum(n1(:b))*3
! Atoms A and B
do i1 = 1, n1(a)
do i2 = 1, n1(b)
if (q1(i1,a) == q1(i2,b)) then
! Calculate the distance vector, and some intermediate results
d(:) = x1(a,i1,:)- x1(b,i2,:)
expd = inv_sigma4 * exp(sum(d**2) * inv_2sigma2)
expdiag = sigma2 * expd
! Calculate the outer product of the distance
hess = 0.0d0
call dsyr("U", rep_size, expd, d, 1, hess, rep_size)
do k = 1, rep_size
hess(k,k) = hess(k,k) + expdiag
enddo
! Do the first half of the dot product, save in partial(:,:)
call dsymm("L", "U", rep_size, n1(a)*3, 1.0d0, hess(:,:), &
& rep_size, sorted_derivs1(:,:n1(a)*3,i1,a), rep_size, &
& 0.0d0, partial(:,:n1(a)*3), rep_size)
! Add the dot product to the kernel in one BLAS call
call dgemm("T", "N", n1(a)*3, n1(b)*3, rep_size, 1.0d0, &
& partial(:,:n1(a)*3), rep_size, &
& sorted_derivs1(:,:n1(b)*3,i2,b), rep_size, 1.0d0, &
& kernel(idx1_start:idx1_end,idx2_start:idx2_end), n1(a)*3, 1)
endif
enddo
enddo
if (b > a) then
kernel(idx2_start:idx2_end,idx1_start:idx1_end) &
& = transpose(kernel(idx1_start:idx1_end,idx2_start:idx2_end))
endif
enddo
enddo
!$OMP END PARALLEL do
deallocate(hess)
deallocate(sorted_derivs1)
deallocate(partial)
deallocate(d)
end subroutine fsymmetric_gdml_kernel
subroutine fgaussian_process_kernel(x1, x2, dx1, dx2, q1, q2, n1, n2, nm1, nm2, na1, na2, sigma, kernel)
implicit none
double precision, dimension(:,:,:), intent(in) :: x1
double precision, dimension(:,:,:), intent(in) :: x2
double precision, dimension(:,:,:,:,:), intent(in) :: dx1
double precision, dimension(:,:,:,:,:), intent(in) :: dx2
integer, dimension(:,:), intent(in) :: q1
integer, dimension(:,:), intent(in) :: q2
integer, dimension(:), intent(in) :: n1
integer, dimension(:), intent(in) :: n2
integer, intent(in) :: nm1
integer, intent(in) :: nm2
integer, intent(in) :: na1
integer, intent(in) :: na2
double precision, intent(in) :: sigma
double precision, dimension(na2*3+nm2,na1*3+nm1), intent(out) :: kernel
integer :: i1, i2, j1, j2, k
integer :: xyz2
integer :: a, b
integer :: idx1_end, idx1_start, idx2_end, idx2_start, idx2
integer :: rep_size
double precision :: expd, expdiag
double precision :: inv_2sigma2
double precision :: inv_sigma2
double precision :: inv_sigma4
double precision :: sigma2
double precision, allocatable, dimension(:) :: d
double precision, allocatable, dimension(:,:) :: hess
double precision, allocatable, dimension(:,:) :: partial
double precision, allocatable, dimension(:,:,:,:) :: sorted_derivs1
double precision, allocatable, dimension(:,:,:,:) :: sorted_derivs2
! Reset kernel
kernel = 0.0d0
! Calculate these only once
inv_2sigma2 = -1.0d0 / (2 * sigma**2)
inv_sigma2 = -1.0d0 / (sigma**2)
inv_sigma4 = -1.0d0 / (sigma**4)
sigma2 = -1.0d0 * sigma**2
rep_size = size(x1, dim=3)
allocate(d(rep_size))
allocate(partial(rep_size,maxval(n2)*3))
partial = 0.0d0
allocate(hess(rep_size, rep_size))
allocate(sorted_derivs1(rep_size,maxval(n1)*3,maxval(n1),nm1))
allocate(sorted_derivs2(rep_size,maxval(n2)*3,maxval(n2),nm2))
sorted_derivs1 = 0.0d0
sorted_derivs2 = 0.0d0
! Presort the representation derivatives
do b = 1, nm1
do i2 = 1, n1(b)
idx2 = 0
do j2 = 1, n1(b)
do xyz2 = 1, 3
idx2 = idx2 + 1
sorted_derivs1(:,idx2,i2,b) = dx1(b, i2,:,j2,xyz2)
enddo
enddo
enddo
enddo
! Presort the representation derivatives
do b = 1, nm2
do i2 = 1, n2(b)
idx2 = 0
do j2 = 1, n2(b)
do xyz2 = 1, 3
idx2 = idx2 + 1
sorted_derivs2(:,idx2,i2,b) = dx2(b, i2,:,j2,xyz2)
enddo
enddo
enddo
enddo
! write (*,*) "Kernel"
!$OMP PARALLEL DO private(d) schedule(dynamic)
do a = 1, nm1
! Molecule 2
do b = 1, nm2
! Atom in Molecule 1
do j1 = 1, n1(a)
!Atom in Molecule2
do j2 = 1, n2(b)
if (q1(j1,a) == q2(j2,b)) then
d(:) = x1(a,j1,:)- x2(b,j2,:)
!kernel(a, b) = kernel(a, b) + exp((norm2(d)**2) * inv_2sigma2)
kernel(b, a) = kernel(b, a) + exp(sum(d**2) * inv_2sigma2)
endif
enddo
enddo
enddo
enddo
!$OMP END PARALLEL do
! write (*,*) "Kernel grad 1"
! Molecule 1
!$OMP PARALLEL DO PRIVATE(idx2_end,idx2_start,d,expd) schedule(dynamic)
do a = 1, nm1
! Atom in Molecule 1
do j1 = 1, n1(a)
! Molecule 2
do b = 1, nm2
idx2_start = (sum(n2(:b)) - n2(b))*3 + 1
idx2_end = sum(n2(:b))*3
!Atom in Molecule2
do j2 = 1, n2(b)
if (q1(j1,a) == q2(j2,b)) then
! Calculate the distance vector, and some intermediate results
d(:) = x1(a,j1,:)- x2(b,j2,:)
expd = inv_sigma2 * exp(sum(d**2) * inv_2sigma2)
! Add the dot products to the kernel in one BLAS call
call dgemv("T", rep_size, n2(b)*3, expd, sorted_derivs2(:,:n2(b)*3,j2,b), &
! & rep_size, d, 1, 1.0d0, kernel(a,idx2_start+nm2:idx2_end+nm2), 1)
& rep_size, d, 1, 1.0d0, kernel(idx2_start+nm2:idx2_end+nm2,a), 1)
endif
enddo
enddo
enddo
enddo
!$OMP END PARALLEL do
! write (*,*) "Kernel grad 2"
! Molecule 1
!$OMP PARALLEL DO PRIVATE(idx1_end,idx1_start,d,expd) schedule(dynamic)
do a = 1, nm2
! Atom in Molecule 1
do j1 = 1, n2(a)
! Molecule 2
do b = 1, nm1
idx1_start = (sum(n1(:b)) - n1(b))*3 + 1
idx1_end = sum(n1(:b))*3
!Atom in Molecule2
do j2 = 1, n1(b)
if (q2(j1,a) == q1(j2,b)) then
! Calculate the distance vector, and some intermediate results
d(:) = x2(a,j1,:)- x1(b,j2,:)
expd = inv_sigma2 * exp(sum(d**2) * inv_2sigma2)
! write(*,*) nm1,idx1_start+nm1,idx1_end+nm1,a
! Add the dot products to the kernel in one BLAS call
call dgemv("T", rep_size, n1(b)*3, expd, sorted_derivs1(:,:n1(b)*3,j2,b), &
! & rep_size, d, 1, 1.0d0, kernel(idx1_start+nm1:idx1_end+nm1,a), 1)
& rep_size, d, 1, 1.0d0, kernel(a,idx1_start+nm1:idx1_end+nm1), 1)
endif
enddo
enddo
enddo
enddo
!$OMP END PARALLEL do
! write (*,*) "Kernel hessian"
!$OMP PARALLEL DO PRIVATE(idx1_start,idx2_start,d,expd,expdiag,hess,idx1_end,idx2_end,partial) schedule(dynamic)
do a = 1, nm1
idx1_start = (sum(n1(:a)) - n1(a))*3 + 1 + nm1
idx1_end = sum(n1(:a))*3 + nm1
do b = 1, nm2
idx2_start = (sum(n2(:b)) - n2(b))*3 + 1 + nm2
idx2_end = sum(n2(:b))*3 + nm2
! Atoms A and B
do i1 = 1, n1(a)
do i2 = 1, n2(b)
if (q1(i1,a) == q2(i2,b)) then
! Calculate the distance vector, and some intermediate results
d(:) = x1(a,i1,:)- x2(b,i2,:)
expd = inv_sigma4 * exp(sum(d**2) * inv_2sigma2)
expdiag = sigma2 * expd
! Calculate the outer product of the distance
hess = 0.0d0
call dsyr("U", rep_size, expd, d, 1, hess, rep_size)
do k = 1, rep_size
hess(k,k) = hess(k,k) + expdiag
enddo
! ! Do the first half of the dot product, save in partial(:,:)
! call dsymm("L", "U", rep_size, n1(a)*3, 1.0d0, hess(:,:), &
! & rep_size, sorted_derivs1(:,:n1(a)*3,i1,a), rep_size, &
! & 0.0d0, partial(:,:n1(a)*3), rep_size)
! ! Add the dot product to the kernel in one BLAS call
! call dgemm("T", "N", n1(a)*3, n2(b)*3, rep_size, 1.0d0, &
! & partial(:,:n1(a)*3), rep_size, &
! & sorted_derivs2(:,:n2(b)*3,i2,b), rep_size, 1.0d0, &
! & kernel(idx1_start:idx1_end,idx2_start:idx2_end), n1(a)*3, 1)
! Do the first half of the dot product, save in partial(:,:)
call dsymm("L", "U", rep_size, n2(b)*3, 1.0d0, hess(:,:), &
& rep_size, sorted_derivs2(:,:n2(b)*3,i2,b), rep_size, &
& 0.0d0, partial(:,:n2(b)*3), rep_size)
! Add the dot product to the kernel in one BLAS call
call dgemm("T", "N", n2(b)*3, n1(a)*3, rep_size, 1.0d0, &
& partial(:,:n2(b)*3), rep_size, &
& sorted_derivs1(:,:n1(a)*3,i1,a), rep_size, 1.0d0, &
& kernel(idx2_start:idx2_end,idx1_start:idx1_end), n2(b)*3, 1)
endif
enddo
enddo
enddo
enddo
!$OMP END PARALLEL do
deallocate(hess)
deallocate(sorted_derivs1)
deallocate(sorted_derivs2)
deallocate(partial)
deallocate(d)
end subroutine fgaussian_process_kernel
subroutine fsymmetric_gaussian_process_kernel(x1, dx1, q1, n1, nm1, na1, sigma, kernel)
implicit none
double precision, dimension(:,:,:), intent(in) :: x1
double precision, dimension(:,:,:,:,:), intent(in) :: dx1
integer, dimension(:,:), intent(in) :: q1
integer, dimension(:), intent(in) :: n1
integer, intent(in) :: nm1
integer, intent(in) :: na1
double precision, intent(in) :: sigma
double precision, dimension(na1*3+nm1,na1*3+nm1), intent(out) :: kernel
integer :: i1, i2, j1, j2, k
integer :: xyz2
integer :: a, b
integer :: idx1_end, idx1_start, idx2_end, idx2_start, idx2
integer :: rep_size
double precision :: expd, expdiag
double precision :: inv_2sigma2
double precision :: inv_sigma2
double precision :: inv_sigma4
double precision :: sigma2
double precision, allocatable, dimension(:) :: d
double precision, allocatable, dimension(:,:) :: hess
double precision, allocatable, dimension(:,:) :: partial
double precision, allocatable, dimension(:,:,:,:) :: sorted_derivs1
! Reset kernel
kernel(:,:) = 0.0d0
! Calculate these only once
inv_2sigma2 = -1.0d0 / (2 * sigma**2)
inv_sigma2 = -1.0d0 / (sigma**2)
inv_sigma4 = -1.0d0 / (sigma**4)
sigma2 = -1.0d0 * sigma**2
rep_size = size(x1, dim=3)
allocate(d(rep_size))
allocate(partial(rep_size,maxval(n1)*3))
partial(:,:) = 0.0d0
allocate(hess(rep_size, rep_size))
allocate(sorted_derivs1(rep_size,maxval(n1)*3,maxval(n1),nm1))
sorted_derivs1(:,:,:,:)= 0.0d0
! Presort the representation derivatives
do b = 1, nm1
do i2 = 1, n1(b)
idx2 = 0
do j2 = 1, n1(b)
do xyz2 = 1, 3
idx2 = idx2 + 1
sorted_derivs1(:,idx2,i2,b) = dx1(b, i2,:,j2,xyz2)
enddo
enddo
enddo
enddo
! write (*,*) "Kernel"
!$OMP PARALLEL DO private(d) schedule(dynamic)
do a = 1, nm1
! Molecule 2
do b = a, nm1
! Atom in Molecule 1
do j1 = 1, n1(a)
!Atom in Molecule2
do j2 = 1, n1(b)
if (q1(j1,a) == q1(j2,b)) then
d(:) = x1(a,j1,:)- x1(b,j2,:)
kernel(a, b) = kernel(a, b) + exp(sum(d**2) * inv_2sigma2)
endif
enddo
enddo
if (b > a) then
kernel(b, a) = kernel(a, b)
endif
enddo
enddo
!$OMP END PARALLEL do
! write (*,*) "Kernel grad 1"
! Molecule 1
!$OMP PARALLEL DO PRIVATE(idx2_end,idx2_start,d,expd) schedule(dynamic)
do a = 1, nm1
! Atom in Molecule 1
do j1 = 1, n1(a)
! Molecule 2
do b = 1, nm1
idx2_start = (sum(n1(:b)) - n1(b))*3 + 1
idx2_end = sum(n1(:b))*3
!Atom in Molecule2
do j2 = 1, n1(b)
if (q1(j1,a) == q1(j2,b)) then
! Calculate the distance vector, and some intermediate results
d(:) = x1(a,j1,:)- x1(b,j2,:)
expd = inv_sigma2 * exp(sum(d**2) * inv_2sigma2)
! Add the dot products to the kernel in one BLAS call
call dgemv("T", rep_size, n1(b)*3, expd, sorted_derivs1(:,:n1(b)*3,j2,b), &
& rep_size, d, 1, 1.0d0, kernel(a,idx2_start+nm1:idx2_end+nm1), 1)
endif
enddo
enddo
enddo
enddo
!$OMP END PARALLEL do
kernel(nm1:, :nm1) = transpose(kernel(:nm1, nm1:))
! write (*,*) "Kernel hessian"
!$OMP PARALLEL DO PRIVATE(idx1_start,idx2_start,d,expd,expdiag,hess,idx1_end,idx2_end,partial) schedule(dynamic)
do a = 1, nm1
idx1_start = (sum(n1(:a)) - n1(a))*3 + 1 + nm1
idx1_end = sum(n1(:a))*3 + nm1
do b = a, nm1
idx2_start = (sum(n1(:b)) - n1(b))*3 + 1 + nm1
idx2_end = sum(n1(:b))*3 + nm1
! Atoms A and B
do i1 = 1, n1(a)
do i2 = 1, n1(b)
if (q1(i1,a) == q1(i2,b)) then
! Calculate the distance vector, and some intermediate results
d(:) = x1(a,i1,:)- x1(b,i2,:)
expd = inv_sigma4 * exp(sum(d**2) * inv_2sigma2)
expdiag = sigma2 * expd
! Calculate the outer product of the distance
hess = 0.0d0
call dsyr("U", rep_size, expd, d, 1, hess, rep_size)
do k = 1, rep_size
hess(k,k) = hess(k,k) + expdiag
enddo
! Do the first half of the dot product, save in partial(:,:)
call dsymm("L", "U", rep_size, n1(a)*3, 1.0d0, hess(:,:), &
& rep_size, sorted_derivs1(:,:n1(a)*3,i1,a), rep_size, &
& 0.0d0, partial(:,:n1(a)*3), rep_size)
! Add the dot product to the kernel in one BLAS call
call dgemm("T", "N", n1(a)*3, n1(b)*3, rep_size, 1.0d0, &
& partial(:,:n1(a)*3), rep_size, &
& sorted_derivs1(:,:n1(b)*3,i2,b), rep_size, 1.0d0, &
& kernel(idx1_start:idx1_end,idx2_start:idx2_end), n1(a)*3, 1)
endif
enddo
enddo
if (b > a) then
kernel(idx2_start:idx2_end,idx1_start:idx1_end) &
& = transpose(kernel(idx1_start:idx1_end,idx2_start:idx2_end))
endif
enddo
enddo
!$OMP END PARALLEL do
deallocate(hess)
deallocate(sorted_derivs1)
deallocate(partial)
deallocate(d)
end subroutine fsymmetric_gaussian_process_kernel
================================================
FILE: qml/kernels/fkernels.f90
================================================
! MIT License
!
! Copyright (c) 2016 Anders Steen Christensen, Lars A. Bratholm, Felix A. Faber
!
! Permission is hereby granted, free of charge, to any person obtaining a copy
! of this software and associated documentation files (the "Software"), to deal
! in the Software without restriction, including without limitation the rights
! to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
! copies of the Software, and to permit persons to whom the Software is
! furnished to do so, subject to the following conditions:
!
! The above copyright notice and this permission notice shall be included in all
! copies or substantial portions of the Software.
!
! THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
! IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
! FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
! AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
! LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
! OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
! SOFTWARE.
module searchtools
implicit none
contains
function searchsorted(all_values, sorted) result(cdf_idx)
implicit none
double precision, dimension(:), intent(in) :: all_values
double precision, dimension(:), intent(in) :: sorted
integer, allocatable, dimension(:) :: cdf_idx
double precision :: val
integer :: i, j, n, m
n = size(all_values)-1
m = size(sorted)
allocate(cdf_idx(n))
cdf_idx(:) = 0
do i = 1, n
val = all_values(i)
do j = 1, m
!write (*,*) i, j, sorted(j), val
! if ((sorted(j) <= val) .and. (val < sorted(j+1))) then
if (sorted(j) > val) then
cdf_idx(i) = j - 1
!write(*,*) "found"
exit
! endif
else !iif (val > maxval(sorted)) then
cdf_idx(i) = m
endif
enddo
enddo
end function searchsorted
recursive subroutine quicksort(a, first, last)
implicit none
double precision :: a(*), x, t
integer first, last
integer i, j
x = a( (first+last) / 2 )
i = first
j = last
do
do while (a(i) < x)
i=i+1
end do
do while (x < a(j))
j=j-1
end do
if (i >= j) exit
t = a(i); a(i) = a(j); a(j) = t
i=i+1
j=j-1
end do
if (first < i-1) call quicksort(a, first, i-1)
if (j+1 < last) call quicksort(a, j+1, last)
end subroutine quicksort
end module searchtools
subroutine fget_local_kernels_gaussian(q1, q2, n1, n2, sigmas, &
& nm1, nm2, nsigmas, kernels)
implicit none
double precision, dimension(:,:), intent(in) :: q1
double precision, dimension(:,:), intent(in) :: q2
! List of numbers of atoms in each molecule
integer, dimension(:), intent(in) :: n1
integer, dimension(:), intent(in) :: n2
! Sigma in the Gaussian kernel
double precision, dimension(:), intent(in) :: sigmas
! Number of molecules
integer, intent(in) :: nm1
integer, intent(in) :: nm2
! Number of sigmas
integer, intent(in) :: nsigmas
! -1.0 / sigma^2 for use in the kernel
double precision, dimension(nsigmas) :: inv_sigma2
! Resulting alpha vector
double precision, dimension(nsigmas,nm1,nm2), intent(out) :: kernels
! Internal counters
integer :: a, b, i, j, k, ni, nj
! Temporary variables necessary for parallelization
double precision, allocatable, dimension(:,:) :: atomic_distance
integer, allocatable, dimension(:) :: i_starts
integer, allocatable, dimension(:) :: j_starts
allocate(i_starts(nm1))
allocate(j_starts(nm2))
!$OMP PARALLEL DO
do i = 1, nm1
i_starts(i) = sum(n1(:i)) - n1(i)
enddo
!$OMP END PARALLEL DO
!$OMP PARALLEL DO
do j = 1, nm2
j_starts(j) = sum(n2(:j)) - n2(j)
enddo
!$OMP END PARALLEL DO
inv_sigma2(:) = -0.5d0 / (sigmas(:))**2
kernels(:,:,:) = 0.0d0
allocate(atomic_distance(maxval(n1), maxval(n2)))
atomic_distance(:,:) = 0.0d0
!$OMP PARALLEL DO PRIVATE(atomic_distance,ni,nj) SCHEDULE(dynamic) COLLAPSE(2)
do a = 1, nm1
do b = 1, nm2
nj = n2(b)
ni = n1(a)
atomic_distance(:,:) = 0.0d0
do i = 1, ni
do j = 1, nj
atomic_distance(i, j) = sum((q1(:,i + i_starts(a)) - q2(:,j + j_starts(b)))**2)
enddo
enddo
do k = 1, nsigmas
kernels(k, a, b) = sum(exp(atomic_distance(:ni,:nj) * inv_sigma2(k)))
enddo
enddo
enddo
!$OMP END PARALLEL DO
deallocate(atomic_distance)
deallocate(i_starts)
deallocate(j_starts)
end subroutine fget_local_kernels_gaussian
subroutine fget_local_kernels_laplacian(q1, q2, n1, n2, sigmas, &
& nm1, nm2, nsigmas, kernels)
implicit none
double precision, dimension(:,:), intent(in) :: q1
double precision, dimension(:,:), intent(in) :: q2
! List of numbers of atoms in each molecule
integer, dimension(:), intent(in) :: n1
integer, dimension(:), intent(in) :: n2
! Sigma in the Gaussian kernel
double precision, dimension(:), intent(in) :: sigmas
! Number of molecules
integer, intent(in) :: nm1
integer, intent(in) :: nm2
! Number of sigmas
integer, intent(in) :: nsigmas
! -1.0 / sigma^2 for use in the kernel
double precision, dimension(nsigmas) :: inv_sigma2
! Resulting alpha vector
double precision, dimension(nsigmas,nm1,nm2), intent(out) :: kernels
! Internal counters
integer :: a, b, i, j, k, ni, nj
! Temporary variables necessary for parallelization
double precision, allocatable, dimension(:,:) :: atomic_distance
integer, allocatable, dimension(:) :: i_starts
integer, allocatable, dimension(:) :: j_starts
allocate(i_starts(nm1))
allocate(j_starts(nm2))
!$OMP PARALLEL DO
do i = 1, nm1
i_starts(i) = sum(n1(:i)) - n1(i)
enddo
!$OMP END PARALLEL DO
!$OMP PARALLEL DO
do j = 1, nm2
j_starts(j) = sum(n2(:j)) - n2(j)
enddo
!$OMP END PARALLEL DO
inv_sigma2(:) = -1.0d0 / sigmas(:)
kernels(:,:,:) = 0.0d0
allocate(atomic_distance(maxval(n1), maxval(n2)))
atomic_distance(:,:) = 0.0d0
!$OMP PARALLEL DO PRIVATE(atomic_distance,ni,nj) SCHEDULE(dynamic) COLLAPSE(2)
do a = 1, nm1
do b = 1, nm2
nj = n2(b)
ni = n1(a)
atomic_distance(:,:) = 0.0d0
do i = 1, ni
do j = 1, nj
atomic_distance(i, j) = sum(abs(q1(:,i + i_starts(a)) - q2(:,j + j_starts(b))))
enddo
enddo
do k = 1, nsigmas
kernels(k, a, b) = sum(exp(atomic_distance(:ni,:nj) * inv_sigma2(k)))
enddo
enddo
enddo
!$OMP END PARALLEL DO
deallocate(atomic_distance)
deallocate(i_starts)
deallocate(j_starts)
end subroutine fget_local_kernels_laplacian
subroutine fget_vector_kernels_laplacian(q1, q2, n1, n2, sigmas, &
& nm1, nm2, nsigmas, kernels)
implicit none
! Descriptors for the training set
double precision, dimension(:,:,:), intent(in) :: q1
double precision, dimension(:,:,:), intent(in) :: q2
! List of numbers of atoms in each molecule
integer, dimension(:), intent(in) :: n1
integer, dimension(:), intent(in) :: n2
! Sigma in the Gaussian kernel
double precision, dimension(:), intent(in) :: sigmas
! Number of molecules
integer, intent(in) :: nm1
integer, intent(in) :: nm2
! Number of sigmas
integer, intent(in) :: nsigmas
! -1.0 / sigma^2 for use in the kernel
double precision, dimension(nsigmas) :: inv_sigma
! Resulting alpha vector
double precision, dimension(nsigmas,nm1,nm2), intent(out) :: kernels
! Internal counters
integer :: i, j, k, ni, nj, ia, ja
! Temporary variables necessary for parallelization
double precision, allocatable, dimension(:,:) :: atomic_distance
inv_sigma(:) = -1.0d0 / sigmas(:)
kernels(:,:,:) = 0.0d0
allocate(atomic_distance(maxval(n1), maxval(n2)))
atomic_distance(:,:) = 0.0d0
!$OMP PARALLEL DO PRIVATE(atomic_distance,ni,nj) SCHEDULE(dynamic) COLLAPSE(2)
do j = 1, nm2
do i = 1, nm1
ni = n1(i)
nj = n2(j)
atomic_distance(:,:) = 0.0d0
do ja = 1, nj
do ia = 1, ni
atomic_distance(ia,ja) = sum(abs(q1(:,ia,i) - q2(:,ja,j)))
enddo
enddo
do k = 1, nsigmas
kernels(k, i, j) = sum(exp(atomic_distance(:ni,:nj) * inv_sigma(k)))
enddo
enddo
enddo
!$OMP END PARALLEL DO
deallocate(atomic_distance)
end subroutine fget_vector_kernels_laplacian
subroutine fget_vector_kernels_gaussian(q1, q2, n1, n2, sigmas, &
& nm1, nm2, nsigmas, kernels)
implicit none
! Representations (n_samples, n_max_atoms, rep_size)
double precision, dimension(:,:,:), intent(in) :: q1
double precision, dimension(:,:,:), intent(in) :: q2
! List of numbers of atoms in each molecule
integer, dimension(:), intent(in) :: n1
integer, dimension(:), intent(in) :: n2
! Sigma in the Gaussian kernel
double precision, dimension(:), intent(in) :: sigmas
! Number of molecules
integer, intent(in) :: nm1
integer, intent(in) :: nm2
! Number of sigmas
integer, intent(in) :: nsigmas
! -1.0 / sigma^2 for use in the kernel
double precision, dimension(nsigmas) :: inv_sigma2
! Resulting alpha vector
double precision, dimension(nsigmas,nm1,nm2), intent(out) :: kernels
! Internal counters
integer :: i, j, k, ni, nj, ia, ja
! Temporary variables necessary for parallelization
double precision, allocatable, dimension(:,:) :: atomic_distance
inv_sigma2(:) = -0.5d0 / (sigmas(:))**2
kernels(:,:,:) = 0.0d0
allocate(atomic_distance(maxval(n1), maxval(n2)))
atomic_distance(:,:) = 0.0d0
!$OMP PARALLEL DO PRIVATE(atomic_distance,ni,nj,ja,ia) SCHEDULE(dynamic) COLLAPSE(2)
do j = 1, nm2
do i = 1, nm1
ni = n1(i)
nj = n2(j)
atomic_distance(:,:) = 0.0d0
do ja = 1, nj
do ia = 1, ni
atomic_distance(ia,ja) = sum((q1(:,ia,i) - q2(:,ja,j))**2)
enddo
enddo
do k = 1, nsigmas
kernels(k, i, j) = sum(exp(atomic_distance(:ni,:nj) * inv_sigma2(k)))
enddo
enddo
enddo
!$OMP END PARALLEL DO
deallocate(atomic_distance)
end subroutine fget_vector_kernels_gaussian
subroutine fget_vector_kernels_gaussian_symmetric(q, n, sigmas, &
& nm, nsigmas, kernels)
implicit none
! Representations (rep_size, n_samples, n_max_atoms)
double precision, dimension(:,:,:), intent(in) :: q
! List of numbers of atoms in each molecule
integer, dimension(:), intent(in) :: n
! Sigma in the Gaussian kernel
double precision, dimension(:), intent(in) :: sigmas
! Number of molecules
integer, intent(in) :: nm
! Number of sigmas
integer, intent(in) :: nsigmas
! Resulting kernels
double precision, dimension(nsigmas,nm,nm), intent(out) :: kernels
! Temporary variables necessary for parallelization
double precision, allocatable, dimension(:,:) :: atomic_distance
double precision, allocatable, dimension(:) :: inv_sigma2
! Internal counters
integer :: i, j, k, ni, nj, ia, ja
double precision :: val
allocate(inv_sigma2(nsigmas))
inv_sigma2 = -0.5d0 / (sigmas)**2
kernels = 1.0d0
i = size(q, dim=3)
allocate(atomic_distance(i,i))
atomic_distance(:,:) = 0.0d0
!$OMP PARALLEL DO PRIVATE(atomic_distance,ni,nj,ja,ia,val) SCHEDULE(dynamic) COLLAPSE(2)
do j = 1, nm
do i = 1, nm
if (i .lt. j) cycle
ni = n(i)
nj = n(j)
atomic_distance(:,:) = 0.0d0
do ja = 1, nj
do ia = 1, ni
atomic_distance(ia,ja) = sum((q(:,ia,i) - q(:,ja,j))**2)
enddo
enddo
do k = 1, nsigmas
val = sum(exp(atomic_distance(:ni,:nj) * inv_sigma2(k)))
kernels(k, i, j) = val
kernels(k, j, i) = val
enddo
enddo
enddo
!$OMP END PARALLEL DO
deallocate(atomic_distance)
deallocate(inv_sigma2)
end subroutine fget_vector_kernels_gaussian_symmetric
subroutine fget_vector_kernels_laplacian_symmetric(q, n, sigmas, &
& nm, nsigmas, kernels)
implicit none
! Representations (rep_size, n_samples, n_max_atoms)
double precision, dimension(:,:,:), intent(in) :: q
! List of numbers of atoms in each molecule
integer, dimension(:), intent(in) :: n
! Sigma in the Laplacian kernel
double precision, dimension(:), intent(in) :: sigmas
! Number of molecules
integer, intent(in) :: nm
! Number of sigmas
integer, intent(in) :: nsigmas
! Resulting kernels
double precision, dimension(nsigmas,nm,nm), intent(out) :: kernels
! Temporary variables necessary for parallelization
double precision, allocatable, dimension(:,:) :: atomic_distance
double precision, allocatable, dimension(:) :: inv_sigma2
! Internal counters
integer :: i, j, k, ni, nj, ia, ja
double precision :: val
allocate(inv_sigma2(nsigmas))
inv_sigma2 = -1.0d0 / sigmas
kernels = 1.0d0
i = size(q, dim=3)
allocate(atomic_distance(i,i))
atomic_distance(:,:) = 0.0d0
!$OMP PARALLEL DO PRIVATE(atomic_distance,ni,nj,ja,ia,val) SCHEDULE(dynamic) COLLAPSE(2)
do j = 1, nm
do i = 1, nm
if (i .lt. j) cycle
ni = n(i)
nj = n(j)
atomic_distance(:,:) = 0.0d0
do ja = 1, nj
do ia = 1, ni
atomic_distance(ia,ja) = sum(abs(q(:,ia,i) - q(:,ja,j)))
enddo
enddo
do k = 1, nsigmas
val = sum(exp(atomic_distance(:ni,:nj) * inv_sigma2(k)))
kernels(k, i, j) = val
kernels(k, j, i) = val
enddo
enddo
enddo
!$OMP END PARALLEL DO
deallocate(atomic_distance)
deallocate(inv_sigma2)
end subroutine fget_vector_kernels_laplacian_symmetric
subroutine fgaussian_kernel(a, na, b, nb, k, sigma)
implicit none
double precision, dimension(:,:), intent(in) :: a
double precision, dimension(:,:), intent(in) :: b
integer, intent(in) :: na, nb
double precision, dimension(:,:), intent(inout) :: k
double precision, intent(in) :: sigma
double precision, allocatable, dimension(:) :: temp
double precision :: inv_sigma
integer :: i, j
inv_sigma = -0.5d0 / (sigma*sigma)
allocate(temp(size(a, dim=1)))
!$OMP PARALLEL DO PRIVATE(temp) COLLAPSE(2)
do i = 1, nb
do j = 1, na
temp(:) = a(:,j) - b(:,i)
k(j,i) = exp(inv_sigma * dot_product(temp,temp))
enddo
enddo
!$OMP END PARALLEL DO
deallocate(temp)
end subroutine fgaussian_kernel
subroutine fgaussian_kernel_symmetric(x, n, k, sigma)
implicit none
double precision, dimension(:,:), intent(in) :: x
integer, intent(in) :: n
double precision, dimension(:,:), intent(inout) :: k
double precision, intent(in) :: sigma
double precision, allocatable, dimension(:) :: temp
double precision :: val
double precision :: inv_sigma
integer :: i, j
inv_sigma = -0.5d0 / (sigma*sigma)
k = 1.0d0
allocate(temp(size(x, dim=1)))
!$OMP PARALLEL DO PRIVATE(temp, val) SCHEDULE(dynamic)
do i = 1, n
do j = i, n
temp = x(:,j) - x(:,i)
val = exp(inv_sigma * dot_product(temp,temp))
k(j,i) = val
k(i,j) = val
enddo
enddo
!$OMP END PARALLEL DO
deallocate(temp)
end subroutine fgaussian_kernel_symmetric
subroutine flaplacian_kernel(a, na, b, nb, k, sigma)
implicit none
double precision, dimension(:,:), intent(in) :: a
double precision, dimension(:,:), intent(in) :: b
integer, intent(in) :: na, nb
double precision, dimension(:,:), intent(inout) :: k
double precision, intent(in) :: sigma
double precision :: inv_sigma
integer :: i, j
inv_sigma = -1.0d0 / sigma
!$OMP PARALLEL DO COLLAPSE(2)
do i = 1, nb
do j = 1, na
k(j,i) = exp(inv_sigma * sum(abs(a(:,j) - b(:,i))))
enddo
enddo
!$OMP END PARALLEL DO
end subroutine flaplacian_kernel
subroutine flaplacian_kernel_symmetric(x, n, k, sigma)
implicit none
double precision, dimension(:,:), intent(in) :: x
integer, intent(in) :: n
double precision, dimension(:,:), intent(inout) :: k
double precision, intent(in) :: sigma
double precision :: val
double precision :: inv_sigma
integer :: i, j
inv_sigma = -1.0d0 / sigma
k = 1.0d0
!$OMP PARALLEL DO PRIVATE(val) SCHEDULE(dynamic)
do i = 1, n
do j = i, n
val = exp(inv_sigma * sum(abs(x(:,j) - x(:,i))))
k(j,i) = val
k(i,j) = val
enddo
enddo
!$OMP END PARALLEL DO
end subroutine flaplacian_kernel_symmetric
subroutine flinear_kernel(a, na, b, nb, k)
implicit none
double precision, dimension(:,:), intent(in) :: a
double precision, dimension(:,:), intent(in) :: b
integer, intent(in) :: na, nb
double precision, dimension(:,:), intent(inout) :: k
integer :: i, j
!$OMP PARALLEL DO COLLAPSE(2)
do i = 1, nb
do j = 1, na
k(j,i) = dot_product(a(:,j), b(:,i))
enddo
enddo
!$OMP END PARALLEL DO
end subroutine flinear_kernel
subroutine fmatern_kernel_l2(a, na, b, nb, k, sigma, order)
implicit none
double precision, dimension(:,:), intent(in) :: a
double precision, dimension(:,:), intent(in) :: b
integer, intent(in) :: na, nb
double precision, dimension(:,:), intent(inout) :: k
double precision, intent(in) :: sigma
integer, intent(in) :: order
double precision, allocatable, dimension(:) :: temp
double precision :: inv_sigma, inv_sigma2, d, d2
integer :: i, j
allocate(temp(size(a, dim=1)))
if (order == 0) then
inv_sigma = - 1.0d0 / sigma
!$OMP PARALLEL DO PRIVATE(temp) COLLAPSE(2)
do i = 1, nb
do j = 1, na
temp(:) = a(:,j) - b(:,i)
k(j,i) = exp(inv_sigma * sqrt(sum(temp*temp)))
enddo
enddo
!$OMP END PARALLEL DO
else if (order == 1) then
inv_sigma = - sqrt(3.0d0) / sigma
!$OMP PARALLEL DO PRIVATE(temp, d) COLLAPSE(2)
do i = 1, nb
do j = 1, na
temp(:) = a(:,j) - b(:,i)
d = sqrt(sum(temp*temp))
k(j,i) = exp(inv_sigma * d) * (1.0d0 - inv_sigma * d)
enddo
enddo
!$OMP END PARALLEL DO
else
inv_sigma = - sqrt(5.0d0) / sigma
inv_sigma2 = 5.0d0 / (3.0d0 * sigma * sigma)
!$OMP PARALLEL DO PRIVATE(temp, d, d2) COLLAPSE(2)
do i = 1, nb
do j = 1, na
temp(:) = a(:,j) - b(:,i)
d2 = sum(temp*temp)
d = sqrt(d2)
k(j,i) = exp(inv_sigma * d) * (1.0d0 - inv_sigma * d + inv_sigma2 * d2)
enddo
enddo
!$OMP END PARALLEL DO
end if
deallocate(temp)
end subroutine fmatern_kernel_l2
subroutine fsargan_kernel(a, na, b, nb, k, sigma, gammas, ng)
implicit none
double precision, dimension(:,:), intent(in) :: a
double precision, dimension(:,:), intent(in) :: b
double precision, dimension(:), intent(in) :: gammas
integer, intent(in) :: na, nb, ng
double precision, dimension(:,:), intent(inout) :: k
double precision, intent(in) :: sigma
double precision, allocatable, dimension(:) :: prefactor
double precision :: inv_sigma
double precision :: d
integer :: i, j, m
inv_sigma = -1.0d0 / sigma
! Allocate temporary
allocate(prefactor(ng))
!$OMP PARALLEL DO PRIVATE(d, prefactor) SCHEDULE(dynamic) COLLAPSE(2)
do i = 1, nb
do j = 1, na
d = sum(abs(a(:,j) - b(:,i)))
do m = 1, ng
prefactor(m) = gammas(m) * (- inv_sigma * d) ** m
enddo
k(j,i) = exp(inv_sigma * d) * (1 + sum(prefactor(:)))
enddo
enddo
!$OMP END PARALLEL DO
! Clean up
deallocate(prefactor)
end subroutine fsargan_kernel
subroutine fwasserstein_kernel(a, na, b, nb, k, sigma, p, q)
use searchtools
implicit none
double precision, dimension(:,:), intent(in) :: a
double precision, dimension(:,:), intent(in) :: b
double precision, allocatable, dimension(:,:) :: asorted
double precision, allocatable, dimension(:,:) :: bsorted
double precision, allocatable, dimension(:) :: rep
integer, intent(in) :: na, nb
double precision, dimension(:,:), intent(inout) :: k
double precision, intent(in) :: sigma
integer, intent(in) :: p
integer, intent(in) :: q
double precision :: inv_sigma
integer :: i, j, l
integer :: rep_size
double precision, allocatable, dimension(:) :: deltas
double precision, allocatable, dimension(:) :: all_values
double precision, allocatable, dimension(:) :: a_cdf
double precision, allocatable, dimension(:) :: b_cdf
integer, allocatable, dimension(:) :: a_cdf_idx
integer, allocatable, dimension(:) :: b_cdf_idx
rep_size = size(a, dim=1)
allocate(asorted(rep_size,na))
allocate(bsorted(rep_size,nb))
allocate(rep(rep_size))
allocate(all_values(rep_size*2))
allocate(deltas(rep_size*2-1))
allocate(a_cdf(rep_size*2-1))
allocate(b_cdf(rep_size*2-1))
allocate(a_cdf_idx(rep_size*2-1))
allocate(b_cdf_idx(rep_size*2-1))
asorted(:,:) = a(:,:)
bsorted(:,:) = b(:,:)
do i = 1, na
rep(:) = asorted(:,i)
call quicksort(rep,1,rep_size)
asorted(:,i) = rep(:)
enddo
do i= 1, nb
rep(:) = bsorted(:,i)
call quicksort(rep,1,rep_size)
bsorted(:,i) = rep(:)
enddo
!$OMP PARALLEL DO PRIVATE(all_values,a_cdf_idx,b_cdf_idx,a_cdf,b_cdf,deltas)
do j = 1, nb
do i = 1, na
all_values(:rep_size) = asorted(:,i)
all_values(rep_size+1:) = bsorted(:,j)
call quicksort(all_values,1,2*rep_size)
do l = 1, 2*rep_size - 1
deltas(l) = all_values(l+1) - all_values(l)
enddo
a_cdf_idx = searchsorted(all_values, asorted(:,i))
b_cdf_idx = searchsorted(all_values, bsorted(:,j))
a_cdf(:) = a_cdf_idx(:)
b_cdf(:) = b_cdf_idx(:)
a_cdf(:) = a_cdf(:) / rep_size
b_cdf(:) = b_cdf(:) / rep_size
! k(i,j) = exp(-sum(abs(a_cdf-b_cdf)*deltas)/sigma)
k(i,j) = exp( -(sum((abs(a_cdf-b_cdf)**p) * deltas) ** (1.0d0/p)) ** q /sigma)
enddo
enddo
!$OMP END PARALLEL DO
end subroutine fwasserstein_kernel
================================================
FILE: qml/kernels/fkpca.f90
================================================
! MIT License
!
! Copyright (c) 2018 Anders Steen Christensen
!
! Permission is hereby granted, free of charge, to any person obtaining a copy
! of this software and associated documentation files (the "Software"), to deal
! in the Software without restriction, including without limitation the rights
! to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
! copies of the Software, and to permit persons to whom the Software is
! furnished to do so, subject to the following conditions:
!
! The above copyright notice and this permission notice shall be included in all
! copies or substantial portions of the Software.
!
! THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
! IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
! FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
! AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
! LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
! OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
! SOFTWARE.
subroutine fkpca(k, n, centering, kpca)
implicit none
double precision, dimension(:,:), intent(in) :: k
integer, intent(in) :: n
logical, intent(in) :: centering
double precision, dimension(n,n), intent(out) :: kpca
! Eigenvalues
double precision, dimension(n) :: eigenvals
double precision, allocatable, dimension(:) :: work
integer :: lwork
integer :: info
integer :: i
double precision :: inv_n
double precision, allocatable, dimension(:) :: temp
double precision :: temp_sum
kpca(:,:) = k(:,:)
! This first part centers the matrix,
! basically Kpca = K - G@K - K@G + G@K@G, with G = 1/n
! It is a bit hard to follow, sry, but it is very fast
! and requires very little memory overhead.
if (centering) then
inv_n = 1.0d0 / n
allocate(temp(n))
temp(:) = 0.0d0
!$OMP PARALLEL DO
do i = 1, n
temp(i) = sum(k(i,:)) * inv_n
enddo
!$OMP END PARALLEL DO
temp_sum = sum(temp(:)) * inv_n
!$OMP PARALLEL DO
do i = 1, n
kpca(i,:) = kpca(i,:) + temp_sum
enddo
!$OMP END PARALLEL DO
!$OMP PARALLEL DO
do i = 1, n
kpca(:,i) = kpca(:,i) - temp(i)
enddo
!$OMP END PARALLEL DO
!$OMP PARALLEL DO
do i = 1, n
kpca(i,:) = kpca(i,:) - temp(i)
enddo
!$OMP END PARALLEL DO
deallocate(temp)
endif
! This 2nd part solves the eigenvalue problem with the least
! memory intensive solver, namely DSYEV(). DSYEVD() is twice
! as fast, but requires a lot more memory, which quickly
! becomes prohibitive.
! Dry run which returns the optimal "lwork"
allocate(work(1))
call dsyev("V", "U", n, kpca, n, eigenvals, work, -1, info)
lwork = nint(work(1)) + 1
deallocate(work)
! Get eigenvectors
allocate(work(lwork))
call dsyev("V", "U", n, kpca, n, eigenvals, work, lwork, info)
deallocate(work)
if (info < 0) then
write (*,*) "ERROR: The ", -info, "-th argument to DSYEV() had an illegal value."
else if (info > 0) then
write (*,*) "ERROR: DSYEV() failed to compute an eigenvalue."
end if
! This 3rd part sorts the kernel PCA matrix such that the first PCA is kpca(1)
kpca = kpca(:,n:1:-1)
kpca = transpose(kpca)
!$OMP PARALLEL DO
do i = 1, n
kpca(i,:) = kpca(i,:) * sqrt(eigenvals(n - i + 1))
enddo
!$OMP END PARALLEL DO
end subroutine fkpca
================================================
FILE: qml/kernels/gradient_kernels.py
================================================
# MIT License
#
# Copyright (c) 2018-2019 Anders Steen Christensen
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
import ctypes
import os
import numpy as np
from .fgradient_kernels import fglobal_kernel
from .fgradient_kernels import flocal_kernel
from .fgradient_kernels import flocal_kernels
from .fgradient_kernels import fsymmetric_local_kernel
from .fgradient_kernels import fsymmetric_local_kernels
from .fgradient_kernels import fatomic_local_kernel
from .fgradient_kernels import fatomic_local_gradient_kernel
from .fgradient_kernels import flocal_gradient_kernel
from .fgradient_kernels import fgdml_kernel
from .fgradient_kernels import fsymmetric_gdml_kernel
from .fgradient_kernels import fgaussian_process_kernel
from .fgradient_kernels import fsymmetric_gaussian_process_kernel
def mkl_set_num_threads(cores):
if cores is None:
return
try:
mkl_rt = ctypes.CDLL('libmkl_rt.so')
mkl_rt.mkl_set_num_threads(ctypes.byref(ctypes.c_int(cores)))
except:
pass
def mkl_get_num_threads():
try:
mkl_rt = ctypes.CDLL('libmkl_rt.so')
mkl_num_threads = mkl_rt.mkl_get_max_threads()
return mkl_num_threads
except:
return None
def get_global_kernel(X1, X2, Q1, Q2, SIGMA):
""" Calculates the Gaussian kernel matrix K with the local decomposition where :math:`K_{ij}`:
:math:`K_{ij} = \\sum_{I\\in i} \\sum_{J\\in j}\\exp \\big( -\\frac{\\|X_I - X_J\\|_2^2}{2\\sigma^2} \\big)`
Where :math: X_{I}` and :math:`X_{J}` are representation vectors of the atomic environments.
The kernel is the normal Gaussian kernel with the local decomposition of atomic environments.
For instance atom-centered symmetry functions could be used here.
K is calculated analytically using an OpenMP parallel Fortran routine.
:param X1: Array of representations - shape=(N1, rep_size, max_atoms).
:type X1: numpy array
:param X2: Array of representations - shape=(N2, rep_size, max_atoms).
:type X2: numpy array
:param Q1: List of lists containing the nuclear charges for each molecule.
:type Q1: list
:param Q2: List of lists containing the nuclear charges for each molecule.
:type Q2: list
:param SIGMA: Gaussian kernel width.
:type SIGMA: float
:return: 2D matrix of kernel elements shape=(N1, N2),
:rtype: numpy array
"""
N1 = np.array([len(Q) for Q in Q1], dtype=np.int32)
N2 = np.array([len(Q) for Q in Q2], dtype=np.int32)
assert N1.shape[0] == X1.shape[0], "Error: List of charges does not match shape of representations"
assert N2.shape[0] == X2.shape[0], "Error: List of charges does not match shape of representations"
Q1_input = np.zeros((max(N1), X1.shape[0]), dtype=np.int32)
Q2_input = np.zeros((max(N2), X2.shape[0]), dtype=np.int32)
for i, q in enumerate(Q1):
Q1_input[:len(q),i] = q
for i, q in enumerate(Q2):
Q2_input[:len(q),i] = q
K = fglobal_kernel(
X1,
X2,
Q1_input,
Q2_input,
N1,
N2,
len(N1),
len(N2),
SIGMA
)
return K
def get_local_kernels(X1, X2, Q1, Q2, SIGMAS):
""" Calculates the Gaussian kernel matrix K with the local decomposition where :math:`K_{ij}`:
:math:`K_{ij} = \\sum_{I\\in i} \\sum_{J\\in j}\\exp \\big( -\\frac{\\|X_I - X_J\\|_2^2}{2\\sigma^2} \\big)`
Where :math: X_{I}` and :math:`X_{J}` are representation vectors of the atomic environments.
The kernel is the normal Gaussian kernel with the local decomposition of atomic environments.
For instance atom-centered symmetry functions could be used here.
K is calculated analytically using an OpenMP parallel Fortran routine.
:param X1: Array of representations - shape=(N1, rep_size, max_atoms).
:type X1: numpy array
:param X2: Array of representations - shape=(N2, rep_size, max_atoms).
:type X2: numpy array
:param Q1: List of lists containing the nuclear charges for each molecule.
:type Q1: list
:param Q2: List of lists containing the nuclear charges for each molecule.
:type Q2: list
:param SIGMA: Gaussian kernel width.
:type SIGMA: float
:return: 2D matrix of kernel elements shape=(N1, N2),
:rtype: numpy array
"""
N1 = np.array([len(Q) for Q in Q1], dtype=np.int32)
N2 = np.array([len(Q) for Q in Q2], dtype=np.int32)
assert N1.shape[0] == X1.shape[0], "Error: List of charges does not match shape of representations"
assert N2.shape[0] == X2.shape[0], "Error: List of charges does not match shape of representations"
Q1_input = np.zeros((max(N1), X1.shape[0]), dtype=np.int32)
Q2_input = np.zeros((max(N2), X2.shape[0]), dtype=np.int32)
sigmas_input = np.array(SIGMAS, dtype=np.float64)
nsigmas = len(SIGMAS)
for i, q in enumerate(Q1):
Q1_input[:len(q),i] = q
for i, q in enumerate(Q2):
Q2_input[:len(q),i] = q
K = flocal_kernels(
X1,
X2,
Q1_input,
Q2_input,
N1,
N2,
len(N1),
len(N2),
sigmas_input,
nsigmas
)
return K
def get_local_kernel(X1, X2, Q1, Q2, SIGMA):
""" Calculates the Gaussian kernel matrix K with the local decomposition where :math:`K_{ij}`:
:math:`K_{ij} = \\sum_{I\\in i} \\sum_{J\\in j}\\exp \\big( -\\frac{\\|X_I - X_J\\|_2^2}{2\\sigma^2} \\big)`
Where :math: X_{I}` and :math:`X_{J}` are representation vectors of the atomic environments.
The kernel is the normal Gaussian kernel with the local decomposition of atomic environments.
For instance atom-centered symmetry functions could be used here.
K is calculated analytically using an OpenMP parallel Fortran routine.
:param X1: Array of representations - shape=(N1, rep_size, max_atoms).
:type X1: numpy array
:param X2: Array of representations - shape=(N2, rep_size, max_atoms).
:type X2: numpy array
:param Q1: List of lists containing the nuclear charges for each molecule.
:type Q1: list
:param Q2: List of lists containing the nuclear charges for each molecule.
:type Q2: list
:param SIGMA: Gaussian kernel width.
:type SIGMA: float
:return: 2D matrix of kernel elements shape=(N1, N2),
:rtype: numpy array
"""
N1 = np.array([len(Q) for Q in Q1], dtype=np.int32)
N2 = np.array([len(Q) for Q in Q2], dtype=np.int32)
assert N1.shape[0] == X1.shape[0], "Error: List of charges does not match shape of representations"
assert N2.shape[0] == X2.shape[0], "Error: List of charges does not match shape of representations"
Q1_input = np.zeros((max(N1), X1.shape[0]), dtype=np.int32)
Q2_input = np.zeros((max(N2), X2.shape[0]), dtype=np.int32)
for i, q in enumerate(Q1):
Q1_input[:len(q),i] = q
for i, q in enumerate(Q2):
Q2_input[:len(q),i] = q
K = flocal_kernel(
X1,
X2,
Q1_input,
Q2_input,
N1,
N2,
len(N1),
len(N2),
SIGMA
)
return K
def get_local_symmetric_kernels(X1, Q1, SIGMAS):
""" Calculates the Gaussian kernel matrix K with the local decomposition where :math:`K_{ij}`:
:math:`K_{ij} = \\sum_{I\\in i} \\sum_{J\\in j}\\exp \\big( -\\frac{\\|X_I - X_J\\|_2^2}{2\\sigma^2} \\big)`
Where :math: X_{I}` and :math:`X_{J}` are representation vectors of the atomic environments.
The kernel is the normal Gaussian kernel with the local decomposition of atomic environments.
For instance atom-centered symmetry functions could be used here.
K is calculated analytically using an OpenMP parallel Fortran routine.
:param X1: Array of representations - shape=(N1, rep_size, max_atoms).
:type X1: numpy array
:param X2: Array of representations - shape=(N2, rep_size, max_atoms).
:type X2: numpy array
:param Q1: List of lists containing the nuclear charges for each molecule.
:type Q1: list
:param Q2: List of lists containing the nuclear charges for each molecule.
:type Q2: list
:param SIGMA: Gaussian kernel width.
:type SIGMA: float
:return: 2D matrix of kernel elements shape=(N1, N2),
:rtype: numpy array
"""
N1 = np.array([len(Q) for Q in Q1], dtype=np.int32)
assert N1.shape[0] == X1.shape[0], "Error: List of charges does not match shape of representations"
Q1_input = np.zeros((max(N1), X1.shape[0]), dtype=np.int32)
for i, q in enumerate(Q1):
Q1_input[:len(q),i] = q
nsigmas = len(SIGMAS)
K = fsymmetric_local_kernels(
X1,
Q1_input,
N1,
len(N1),
SIGMAS,
nsigmas
)
return K
def get_local_symmetric_kernel(X1, Q1, SIGMA):
""" Calculates the Gaussian kernel matrix K with the local decomposition where :math:`K_{ij}`:
:math:`K_{ij} = \\sum_{I\\in i} \\sum_{J\\in j}\\exp \\big( -\\frac{\\|X_I - X_J\\|_2^2}{2\\sigma^2} \\big)`
Where :math: X_{I}` and :math:`X_{J}` are representation vectors of the atomic environments.
The kernel is the normal Gaussian kernel with the local decomposition of atomic environments.
For instance atom-centered symmetry functions could be used here.
K is calculated analytically using an OpenMP parallel Fortran routine.
:param X1: Array of representations - shape=(N1, rep_size, max_atoms).
:type X1: numpy array
:param X2: Array of representations - shape=(N2, rep_size, max_atoms).
:type X2: numpy array
:param Q1: List of lists containing the nuclear charges for each molecule.
:type Q1: list
:param Q2: List of lists containing the nuclear charges for each molecule.
:type Q2: list
:param SIGMA: Gaussian kernel width.
:type SIGMA: float
:return: 2D matrix of kernel elements shape=(N1, N2),
:rtype: numpy array
"""
N1 = np.array([len(Q) for Q in Q1], dtype=np.int32)
assert N1.shape[0] == X1.shape[0], "Error: List of charges does not match shape of representations"
Q1_input = np.zeros((max(N1), X1.shape[0]), dtype=np.int32)
for i, q in enumerate(Q1):
Q1_input[:len(q),i] = q
K = fsymmetric_local_kernel(
X1,
Q1_input,
N1,
len(N1),
SIGMA
)
return K
def get_atomic_local_kernel(X1, X2, Q1, Q2, SIGMA):
""" Calculates the Gaussian kernel matrix K with the local decomposition where :math:`K_{ij}`:
:math:`K_{Ij} = \\sum_{J\\in j}\\exp \\big( -\\frac{\\|X_I - X_J\\|_2^2}{2\\sigma^2} \\big)`
Where :math: X_{I}` and :math:`X_{J}` are representation vectors of the atomic environments.
This means that the kernel matrix consists of the local decomposition of atomic environments
in a basis of kernel function placed on single atomic environments.
Thus the dimensions in number of molecules times total number of atoms.
For instance atom-centered symmetry functions could be used here.
K is calculated analytically using an OpenMP parallel Fortran routine.
:param X1: Array of representations - shape=(N1, rep_size, max_atoms).
:type X1: numpy array
:param X2: Array of representations - shape=(N2, rep_size, max_atoms).
:type X2: numpy array
:param Q1: List of lists containing the nuclear charges for each molecule.
:type Q1: list
:param Q2: List of lists containing the nuclear charges for each molecule.
:type Q2: list
:param SIGMA: Gaussian kernel width.
:type SIGMA: float
:return: 2D matrix of kernel elements shape=(N1, N2),
:rtype: numpy array
"""
N1 = np.array([len(Q) for Q in Q1], dtype=np.int32)
N2 = np.array([len(Q) for Q in Q2], dtype=np.int32)
assert N1.shape[0] == X1.shape[0], "Error: List of charges does not match shape of representations"
assert N2.shape[0] == X2.shape[0], "Error: List of charges does not match shape of representations"
Q1_input = np.zeros((max(N1), X1.shape[0]), dtype=np.int32)
Q2_input = np.zeros((max(N2), X2.shape[0]), dtype=np.int32)
for i, q in enumerate(Q1):
Q1_input[:len(q),i] = q
for i, q in enumerate(Q2):
Q2_input[:len(q),i] = q
K = fatomic_local_kernel(
X1,
X2,
Q1_input,
Q2_input,
N1,
N2,
len(N1),
len(N2),
np.sum(N1),
SIGMA
)
return K
def get_atomic_local_gradient_kernel(X1, X2, dX2, Q1, Q2, SIGMA):
""" Calculates the Gaussian kernel matrix K with the local decomposition where :math:`K_{ij}`:
:math:`K_{Ij} = \\frac{\\part}{\\part x}\\sum_{J\\in j}\\exp \\big( -\\frac{\\|X_I - X_J\\|_2^2}{2\\sigma^2} \\big)`
Where :math: X_{I}` and :math:`X_{J}` are representation vectors of the atomic environments.
For instance atom-centered symmetry functions could be used here.
The kernel has the dimensions number of nuclear kernel gradients times total number of atoms.
K is calculated analytically using an OpenMP parallel Fortran routine.
:param X1: Array of representations - shape=(N1, rep_size, max_atoms).
:type X1: numpy array
:param X2: Array of representations - shape=(N2, rep_size, max_atoms).
:type X2: numpy array
:param dX2: Array of representation derivatives - shape=(N2, rep_size, 3, rep_size, max_atoms).
:type dX2: numpy array
:param Q1: List of lists containing the nuclear charges for each molecule.
:type Q1: list
:param Q2: List of lists containing the nuclear charges for each molecule.
:type Q2: list
:param SIGMA: Gaussian kernel width.
:type SIGMA: float
:return: 2D matrix of kernel elements shape=(N1, N2),
:rtype: numpy array
"""
N1 = np.array([len(Q) for Q in Q1], dtype=np.int32)
N2 = np.array([len(Q) for Q in Q2], dtype=np.int32)
assert N1.shape[0] == X1.shape[0], "Error: List of charges does not match shape of representations"
assert N2.shape[0] == X2.shape[0], "Error: List of charges does not match shape of representations"
Q1_input = np.zeros((max(N1), X1.shape[0]), dtype=np.int32)
Q2_input = np.zeros((max(N2), X2.shape[0]), dtype=np.int32)
for i, q in enumerate(Q1):
Q1_input[:len(q),i] = q
for i, q in enumerate(Q2):
Q2_input[:len(q),i] = q
# This kernel must run with MKL_NUM_THREADS=1
original_mkl_threads = mkl_get_num_threads()
mkl_set_num_threads(1)
K = fatomic_local_gradient_kernel(
X1,
X2,
dX2,
Q1_input,
Q2_input,
N1,
N2,
len(N1),
len(N2),
np.sum(N1),
np.sum(N2)*3,
SIGMA
)
# Reset MKL_NUM_THREADS back to its original value
mkl_set_num_threads(original_mkl_threads)
return K
def get_local_gradient_kernel(X1, X2, dX2, Q1, Q2, SIGMA):
""" Calculates the Gaussian kernel matrix K with the local decomposition where :math:`K_{ij}`:
:math:`K_{ij} = \\frac{\\part}{\\part x}\\sum_{J\\in j}\\exp \\big( -\\frac{\\|X_I - X_J\\|_2^2}{2\\sigma^2} \\big)`
Where :math: X_{I}` and :math:`X_{J}` are representation vectors of the atomic environments.
For instance atom-centered symmetry functions could be used here.
The kernel has the dimensions number of nuclear kernel gradients times total number of molecules.
K is calculated analytically using an OpenMP parallel Fortran routine.
:param X1: Array of representations - shape=(N1, rep_size, max_atoms).
:type X1: numpy array
:param X2: Array of representations - shape=(N2, rep_size, max_atoms).
:type X2: numpy array
:param dX2: Array of representation derivatives - shape=(N2, rep_size, 3, rep_size, max_atoms).
:type dX2: numpy array
:param Q1: List of lists containing the nuclear charges for each molecule.
:type Q1: list
:param Q2: List of lists containing the nuclear charges for each molecule.
:type Q2: list
:param SIGMA: Gaussian kernel width.
:type SIGMA: float
:return: 2D matrix of kernel elements shape=(N1, N2),
:rtype: numpy array
"""
N1 = np.array([len(Q) for Q in Q1], dtype=np.int32)
N2 = np.array([len(Q) for Q in Q2], dtype=np.int32)
assert N1.shape[0] == X1.shape[0], "Error: List of charges does not match shape of representations"
assert N2.shape[0] == X2.shape[0], "Error: List of charges does not match shape of representations"
Q1_input = np.zeros((max(N1), X1.shape[0]), dtype=np.int32)
Q2_input = np.zeros((max(N2), X2.shape[0]), dtype=np.int32)
for i, q in enumerate(Q1):
Q1_input[:len(q),i] = q
for i, q in enumerate(Q2):
Q2_input[:len(q),i] = q
# This kernel must run with MKL_NUM_THREADS=1
original_mkl_threads = mkl_get_num_threads()
mkl_set_num_threads(1)
K = flocal_gradient_kernel(
X1,
X2,
dX2,
Q1_input,
Q2_input,
N1,
N2,
len(N1),
len(N2),
np.sum(N2)*3,
SIGMA
)
# Reset MKL_NUM_THREADS back to its original value
mkl_set_num_threads(original_mkl_threads)
return K
def get_gdml_kernel(X1, X2, dX1, dX2, Q1, Q2, SIGMA):
""" Calculates the Gaussian kernel matrix K with the local decomposition where :math:`K_{ij}`:
:math:`K_{Ij} = \\frac{\\part^2}{\\part x_i\\part x_j}\\sum_{J\\in j}\\exp \\big( -\\frac{\\|X_I - X_J\\|_2^2}{2\\sigma^2} \\big)`
Where :math: X_{I}` and :math:`X_{J}` are representation vectors of the atomic environments.
For instance atom-centered symmetry functions could be used here.
This Hessian-kernel corresponds to the "gradient-domain machine learning" (GDML) approach.
This means that the surface is only trained on its derivatives.
K is calculated analytically using an OpenMP parallel Fortran routine.
:param X1: Array of representations - shape=(N1, rep_size, max_atoms).
:type X1: numpy array
:param X2: Array of representations - shape=(N2, rep_size, max_atoms).
:type X2: numpy array
:param dX1: Array of representation derivatives - shape=(N1, rep_size, 3, rep_size, max_atoms).
:type dX1: numpy array
:param dX2: Array of representation derivatives - shape=(N2, rep_size, 3, rep_size, max_atoms).
:type dX2: numpy array
:param Q1: List of lists containing the nuclear charges for each molecule.
:type Q1: list
:param Q2: List of lists containing the nuclear charges for each molecule.
:type Q2: list
:param SIGMA: Gaussian kernel width.
:type SIGMA: float
:return: 2D matrix of kernel elements shape=(N1, N2),
:rtype: numpy array
"""
N1 = np.array([len(Q) for Q in Q1], dtype=np.int32)
N2 = np.array([len(Q) for Q in Q2], dtype=np.int32)
assert N1.shape[0] == X1.shape[0], "Error: List of charges does not match shape of representations"
assert N2.shape[0] == X2.shape[0], "Error: List of charges does not match shape of representations"
Q1_input = np.zeros((max(N1), X1.shape[0]), dtype=np.int32)
Q2_input = np.zeros((max(N2), X2.shape[0]), dtype=np.int32)
for i, q in enumerate(Q1):
Q1_input[:len(q),i] = q
for i, q in enumerate(Q2):
Q2_input[:len(q),i] = q
# This kernel must run with MKL_NUM_THREADS=1
original_mkl_threads = mkl_get_num_threads()
mkl_set_num_threads(1)
K = fgdml_kernel(
X1,
X2,
dX1,
dX2,
Q1_input,
Q2_input,
N1,
N2,
len(N1),
len(N2),
np.sum(N1),
np.sum(N2),
SIGMA
)
# Reset MKL_NUM_THREADS back to its original value
mkl_set_num_threads(original_mkl_threads)
return K
def get_symmetric_gdml_kernel(X1, dX1, Q1, SIGMA):
""" Calculates the Gaussian kernel matrix K with the local decomposition where :math:`K_{ij}`:
:math:`K_{Ij} = \\frac{\\part^2}{\\part x_i\\part x_j}\\sum_{J\\in j}\\exp \\big( -\\frac{\\|X_I - X_J\\|_2^2}{2\\sigma^2} \\big)`
Where :math: X_{I}` and :math:`X_{J}` are representation vectors of the atomic environments.
For instance atom-centered symmetry functions could be used here.
This symmetric Hessian-kernel corresponds to the "gradient-domain machine learning" (GDML) approach.
This means that the surface is only trained on its derivatives.
K is calculated analytically using an OpenMP parallel Fortran routine.
:param X1: Array of representations - shape=(N1, rep_size, max_atoms).
:type X1: numpy array
:param dX1: Array of representation derivatives - shape=(N1, rep_size, 3, rep_size, max_atoms).
:type dX1: numpy array
:param Q1: List of lists containing the nuclear charges for each molecule.
:type Q1: list
:param SIGMA: Gaussian kernel width.
:type SIGMA: float
:return: 2D matrix of kernel elements shape=(N1, N2),
:rtype: numpy array
"""
N1 = np.array([len(Q) for Q in Q1], dtype=np.int32)
assert N1.shape[0] == X1.shape[0], "Error: List of charges does not match shape of representations"
Q1_input = np.zeros((max(N1), X1.shape[0]), dtype=np.int32)
for i, q in enumerate(Q1):
Q1_input[:len(q),i] = q
# This kernel must run with MKL_NUM_THREADS=1
original_mkl_threads = mkl_get_num_threads()
mkl_set_num_threads(1)
K = fsymmetric_gdml_kernel(
X1,
dX1,
Q1_input,
N1,
len(N1),
np.sum(N1),
SIGMA
)
# Reset MKL_NUM_THREADS back to its original value
mkl_set_num_threads(original_mkl_threads)
return K
def get_gp_kernel(X1, X2, dX1, dX2, Q1, Q2, SIGMA):
""" Calculates the Gaussian kernel matrix K with the local decomposition where :math:`K_{ij}`:
This kernel corresponds to a Gaussian process regression (GPR) approach.
The kernel has four blocks, consisting of the 0'th, 1st and 2nd derivatives.
The size is (the number of gradients plus the number of molecules) squared.
K is calculated analytically using an OpenMP parallel Fortran routine.
:param X1: Array of representations - shape=(N1, rep_size, max_atoms).
:type X1: numpy array
:param X2: Array of representations - shape=(N2, rep_size, max_atoms).
:type X2: numpy array
:param dX1: Array of representation derivatives - shape=(N1, rep_size, 3, rep_size, max_atoms).
:type dX1: numpy array
:param dX2: Array of representation derivatives - shape=(N2, rep_size, 3, rep_size, max_atoms).
:type dX2: numpy array
:param Q1: List of lists containing the nuclear charges for each molecule.
:type Q1: list
:param Q2: List of lists containing the nuclear charges for each molecule.
:type Q2: list
:param SIGMA: Gaussian kernel width.
:type SIGMA: float
:return: 2D matrix of kernel elements shape=(N1, N2),
:rtype: numpy array
"""
N1 = np.array([len(Q) for Q in Q1], dtype=np.int32)
N2 = np.array([len(Q) for Q in Q2], dtype=np.int32)
assert N1.shape[0] == X1.shape[0], "Error: List of charges does not match shape of representations"
assert N2.shape[0] == X2.shape[0], "Error: List of charges does not match shape of representations"
Q1_input = np.zeros((max(N1), X1.shape[0]), dtype=np.int32)
Q2_input = np.zeros((max(N2), X2.shape[0]), dtype=np.int32)
for i, q in enumerate(Q1):
Q1_input[:len(q),i] = q
for i, q in enumerate(Q2):
Q2_input[:len(q),i] = q
# This kernel must run with MKL_NUM_THREADS=1
original_mkl_threads = mkl_get_num_threads()
mkl_set_num_threads(1)
K = fgaussian_process_kernel(
X1,
X2,
dX1,
dX2,
Q1_input,
Q2_input,
N1,
N2,
len(N1),
len(N2),
np.sum(N1),
np.sum(N2),
SIGMA
)
# Reset MKL_NUM_THREADS back to its original value
mkl_set_num_threads(original_mkl_threads)
return K
def get_symmetric_gp_kernel(X1, dX1, Q1, SIGMA):
"""
This symmetric kernel corresponds to a Gaussian process regression (GPR) approach.
The kernel has four blocks, consisting of the 0'th, 1st and 2nd derivatives.
The size is (the number of gradients plus the number of molecules) squared.
K is calculated analytically using an OpenMP parallel Fortran routine.
:param X1: Array of representations - shape=(N1, rep_size, max_atoms).
:type X1: numpy array
:param dX1: Array of representation derivatives - shape=(N1, rep_size, 3, rep_size, max_atoms).
:type dX1: numpy array
:param Q1: List of lists containing the nuclear charges for each molecule.
:type Q1: list
:param Q2: List of lists containing the nuclear charges for each molecule.
:type Q2: list
:param SIGMA: Gaussian kernel width.
:type SIGMA: float
:return: 2D matrix of kernel elements shape=(N1, N2),
:rtype: numpy array
"""
N1 = np.array([len(Q) for Q in Q1], dtype=np.int32)
assert N1.shape[0] == X1.shape[0], "Error: List of charges does not match shape of representations"
Q1_input = np.zeros((max(N1), X1.shape[0]), dtype=np.int32)
for i, q in enumerate(Q1):
Q1_input[:len(q),i] = q
# This kernel must run with MKL_NUM_THREADS=1
original_mkl_threads = mkl_get_num_threads()
mkl_set_num_threads(1)
K = fsymmetric_gaussian_process_kernel(
X1,
dX1,
Q1_input,
N1,
len(N1),
np.sum(N1),
SIGMA
)
# Reset MKL_NUM_THREADS back to its original value
mkl_set_num_threads(original_mkl_threads)
return K
================================================
FILE: qml/kernels/kernels.py
================================================
# MIT License
#
# Copyright (c) 2016 Anders Steen Christensen, Felix A. Faber, Lars A. Bratholm
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
from __future__ import print_function
import numpy as np
from .fkernels import fgaussian_kernel, fgaussian_kernel_symmetric
from .fkernels import fwasserstein_kernel
from .fkernels import flaplacian_kernel
from .fkernels import fgaussian_kernel_symmetric
from .fkernels import flaplacian_kernel_symmetric
from .fkernels import flinear_kernel
from .fkernels import fsargan_kernel
from .fkernels import fmatern_kernel_l2
from .fkernels import fget_local_kernels_gaussian
from .fkernels import fget_local_kernels_laplacian
from .fkernels import fget_vector_kernels_gaussian, fget_vector_kernels_gaussian_symmetric
from .fkernels import fkpca
def wasserstein_kernel(A, B, sigma, p=1, q=1):
""" Calculates the Wasserstein kernel matrix K, where :math:`K_{ij}`:
:math:`K_{ij} = \\exp \\big( -\\frac{(W_p(A_i, B_i))^q}{\sigma} \\big)`
Where :math:`A_{i}` and :math:`B_{j}` are representation vectors.
K is calculated using an OpenMP parallel Fortran routine.
:param A: 2D array of representations - shape (N, representation size).
:type A: numpy array
:param B: 2D array of representations - shape (M, representation size).
:type B: numpy array
:param sigma: The value of sigma in the kernel matrix.
:type sigma: float
:return: The Wasserstein kernel matrix - shape (N, M)
:rtype: numpy array
"""
na = A.shape[0]
nb = B.shape[0]
K = np.empty((na, nb), order='F')
# Note: Transposed for Fortran
fwasserstein_kernel(A.T, na, B.T, nb, K, sigma, p, q)
return K
def laplacian_kernel(A, B, sigma):
""" Calculates the Laplacian kernel matrix K, where :math:`K_{ij}`:
:math:`K_{ij} = \\exp \\big( -\\frac{\\|A_i - B_j\\|_1}{\sigma} \\big)`
Where :math:`A_{i}` and :math:`B_{j}` are representation vectors.
K is calculated using an OpenMP parallel Fortran routine.
:param A: 2D array of representations - shape (N, representation size).
:type A: numpy array
:param B: 2D array of representations - shape (M, representation size).
:type B: numpy array
:param sigma: The value of sigma in the kernel matrix.
:type sigma: float
:return: The Laplacian kernel matrix - shape (N, M)
:rtype: numpy array
"""
na = A.shape[0]
nb = B.shape[0]
K = np.empty((na, nb), order='F')
# Note: Transposed for Fortran
flaplacian_kernel(A.T, na, B.T, nb, K, sigma)
return K
def laplacian_kernel_symmetric(A, sigma):
""" Calculates the symmetric Laplacian kernel matrix K, where :math:`K_{ij}`:
:math:`K_{ij} = \\exp \\big( -\\frac{\\|A_i - A_j\\|_1}{\sigma} \\big)`
Where :math:`A_{i}` are representation vectors.
K is calculated using an OpenMP parallel Fortran routine.
:param A: 2D array of representations - shape (N, representation size).
:type A: numpy array
:param sigma: The value of sigma in the kernel matrix.
:type sigma: float
:return: The Laplacian kernel matrix - shape (N, N)
:rtype: numpy array
"""
na = A.shape[0]
K = np.empty((na, na), order='F')
# Note: Transposed for Fortran
flaplacian_kernel_symmetric(A.T, na, K, sigma)
return K
def gaussian_kernel(A, B, sigma):
""" Calculates the Gaussian kernel matrix K, where :math:`K_{ij}`:
:math:`K_{ij} = \\exp \\big( -\\frac{\\|A_i - B_j\\|_2^2}{2\sigma^2} \\big)`
Where :math:`A_{i}` and :math:`B_{j}` are representation vectors.
K is calculated using an OpenMP parallel Fortran routine.
:param A: 2D array of representations - shape (N, representation size).
:type A: numpy array
:param B: 2D array of representations - shape (M, representation size).
:type B: numpy array
:param sigma: The value of sigma in the kernel matrix.
:type sigma: float
:return: The Gaussian kernel matrix - shape (N, M)
:rtype: numpy array
"""
na = A.shape[0]
nb = B.shape[0]
K = np.empty((na, nb), order='F')
# Note: Transposed for Fortran
fgaussian_kernel(A.T, na, B.T, nb, K, sigma)
return K
def gaussian_kernel_symmetric(A, sigma):
""" Calculates the symmetric Gaussian kernel matrix K, where :math:`K_{ij}`:
:math:`K_{ij} = \\exp \\big( -\\frac{\\|A_i - A_j\\|_2^2}{2\sigma^2} \\big)`
Where :math:`A_{i}` are representation vectors.
K is calculated using an OpenMP parallel Fortran routine.
:param A: 2D array of representations - shape (N, representation size).
:type A: numpy array
:param sigma: The value of sigma in the kernel matrix.
:type sigma: float
:return: The Gaussian kernel matrix - shape (N, N)
:rtype: numpy array
"""
na = A.shape[0]
K = np.empty((na, na), order='F')
# Note: Transposed for Fortran
fgaussian_kernel_symmetric(A.T, na, K, sigma)
return K
def linear_kernel(A, B):
""" Calculates the linear kernel matrix K, where :math:`K_{ij}`:
:math:`K_{ij} = A_i \cdot B_j`
VWhere :math:`A_{i}` and :math:`B_{j}` are representation vectors.
K is calculated using an OpenMP parallel Fortran routine.
:param A: 2D array of representations - shape (N, representation size).
:type A: numpy array
:param B: 2D array of representations - shape (M, representation size).
:type B: numpy array
:return: The Gaussian kernel matrix - shape (N, M)
:rtype: numpy array
"""
na = A.shape[0]
nb = B.shape[0]
K = np.empty((na, nb), order='F')
# Note: Transposed for Fortran
flinear_kernel(A.T, na, B.T, nb, K)
return K
def sargan_kernel(A, B, sigma, gammas):
""" Calculates the Sargan kernel matrix K, where :math:`K_{ij}`:
:math:`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 :math:`A_{i}` and :math:`B_{j}` are representation vectors.
K is calculated using an OpenMP parallel Fortran routine.
:param A: 2D array of representations - shape (N, representation size).
:type A: numpy array
:param B: 2D array of representations - shape (M, representation size).
:type B: numpy array
:param sigma: The value of sigma in the kernel matrix.
:type sigma: float
:param gammas: 1D array of parameters in the kernel matrix.
:type gammas: numpy array
:return: The Sargan kernel matrix - shape (N, M).
:rtype: numpy array
"""
ng = len(gammas)
if ng == 0:
return laplacian_kernel(A, B, sigma)
na = A.shape[0]
nb = B.shape[0]
K = np.empty((na, nb), order='F')
# Note: Transposed for Fortran
fsargan_kernel(A.T, na, B.T, nb, K, sigma, gammas, ng)
return K
def matern_kernel(A, B, sigma, order = 0, metric = "l1"):
""" Calculates the Matern kernel matrix K, where :math:`K_{ij}`:
for order = 0:
:math:`K_{ij} = \\exp\\big( -\\frac{d}{\sigma} \\big)`
for order = 1:
:math:`K_{ij} = \\exp\\big( -\\frac{\\sqrt{3} d}{\sigma} \\big) \\big(1 + \\frac{\\sqrt{3} d}{\sigma} \\big)`
for order = 2:
:math:`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 :math:`A_i` and :math:`B_j` are representation vectors, and d is a distance measure.
K is calculated using an OpenMP parallel Fortran routine.
:param A: 2D array of representations - shape (N, representation size).
:type A: numpy array
:param B: 2D array of representations - shape (M, representation size).
:type B: numpy array
:param sigma: The value of sigma in the kernel matrix.
:type sigma: float
:param order: The order of the polynomial (0, 1, 2)
:type order: integer
:param metric: The distance metric ('l1', 'l2')
:type metric: string
:return: The Matern kernel matrix - shape (N, M)
:rtype: numpy array
"""
if metric == "l1":
if order == 0:
gammas = []
elif order == 1:
gammas = [1]
sigma /= np.sqrt(3)
elif order == 2:
gammas = [1,1/3.0]
sigma /= np.sqrt(5)
else:
print("Order:%d not implemented in Matern Kernel" % order)
raise SystemExit
return sargan_kernel(A, B, sigma, gammas)
elif metric == "l2":
pass
else:
print("Error: Unknown distance metric %s in Matern kernel" % str(metric))
raise SystemExit
na = A.shape[0]
nb = B.shape[0]
K = np.empty((na, nb), order='F')
# Note: Transposed for Fortran
fmatern_kernel_l2(A.T, na, B.T, nb, K, sigma, order)
return K
def get_local_kernels_gaussian(A, B, na, nb, sigmas):
""" Calculates the Gaussian kernel matrix K, for a local representation where :math:`K_{ij}`:
:math:`K_{ij} = \sum_{a \in i} \sum_{b \in j} \\exp \\big( -\\frac{\\|A_a - B_b\\|_2^2}{2\sigma^2} \\big)`
Where :math:`A_{a}` and :math:`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.
:param A: 2D array of descriptors - shape (total atoms A, representation size).
:type A: numpy array
:param B: 2D array of descriptors - shape (total atoms B, representation size).
:type B: numpy array
:param na: 1D array containing numbers of atoms in each compound.
:type na: numpy array
:param nb: 1D array containing numbers of atoms in each compound.
:type nb: numpy array
:param sigma: The value of sigma in the kernel matrix.
:type sigma: float
:return: The Gaussian kernel matrix - shape (nsigmas, N, M)
:rtype: numpy array
"""
assert np.sum(na) == A.shape[0], "Error in A input"
assert np.sum(nb) == B.shape[0], "Error in B input"
assert A.shape[1] == B.shape[1], "Error in representation sizes"
nma = len(na)
nmb = len(nb)
sigmas = np.asarray(sigmas)
nsigmas = len(sigmas)
return fget_local_kernels_gaussian(A.T, B.T, na, nb, sigmas, nma, nmb, nsigmas)
def get_local_kernels_laplacian(A, B, na, nb, sigmas):
""" Calculates the Local Laplacian kernel matrix K, for a local representation where :math:`K_{ij}`:
:math:`K_{ij} = \sum_{a \in i} \sum_{b \in j} \\exp \\big( -\\frac{\\|A_a - B_b\\|_1}{\sigma} \\big)`
Where :math:`A_{a}` and :math:`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.
:param A: 2D array of descriptors - shape (N, representation size).
:type A: numpy array
:param B: 2D array of descriptors - shape (M, representation size).
:type B: numpy array
:param na: 1D array containing numbers of atoms in each compound.
:type na: numpy array
:param nb: 1D array containing numbers of atoms in each compound.
:type nb: numpy array
:param sigmas: List of the sigmas.
:type sigmas: list
:return: The Laplacian kernel matrix - shape (nsigmas, N, M)
:rtype: numpy array
"""
assert np.sum(na) == A.shape[0], "Error in A input"
assert np.sum(nb) == B.shape[0], "Error in B input"
assert A.shape[1] == B.shape[1], "Error in representation sizes"
nma = len(na)
nmb = len(nb)
sigmas = np.asarray(sigmas)
nsigmas = len(sigmas)
return fget_local_kernels_laplacian(A.T, B.T, na, nb, sigmas, nma, nmb, nsigmas)
def kpca(K, n=2, centering=True):
""" Calculates `n` first principal components for the kernel :math:`K`.
The PCA is calculated using an OpenMP parallel Fortran routine.
A square, symmetric kernel matrix is required. Centering of the kernel matrix
is enabled by default, although this isn't a strict requirement.
:param K: 2D kernel matrix
:type K: numpy array
:param n: Number of kernel PCAs to return (default=2)
:type n: integer
:param centering: Whether to center the kernel matrix (default=True)
:type centering: bool
:return: array containing the principal components
:rtype: numpy array
"""
assert K.shape[0] == K.shape[1], "ERROR: Square matrix required for Kernel PCA."
assert np.allclose(K, K.T, atol=1e-8), "ERROR: Symmetric matrix required for Kernel PCA."
assert n <= K.shape[0], "ERROR: Requested more principal components than matrix size."
size = K.shape[0]
pca = fkpca(K, size, centering)
return pca[:n]
================================================
FILE: qml/kernels/wrappers.py
================================================
# MIT License
#
# Copyright (c) 2016-2017 Anders Steen Christensen, Felix A. Faber, Lars A. Bratholm
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
import numpy as np
from .fkernels import fget_vector_kernels_gaussian
from .fkernels import fget_vector_kernels_laplacian
from .fkernels import fget_vector_kernels_gaussian_symmetric
from .fkernels import fget_vector_kernels_laplacian_symmetric
from .fkernels import fget_local_kernels_gaussian
from ..arad import get_local_kernels_arad
from ..arad import get_local_symmetric_kernels_arad
def get_atomic_kernels_laplacian(mols1, mols2, sigmas):
n1 = np.array([mol.natoms for mol in mols1], dtype=np.int32)
n2 = np.array([mol.natoms for mol in mols2], dtype=np.int32)
max1 = np.max(n1)
max2 = np.max(n2)
nm1 = n1.size
nm2 = n2.size
cmat_size = mols1[0].representation.shape[1]
x1 = np.zeros((nm1, max1, cmat_size), dtype=np.float64, order="F")
x2 = np.zeros((nm2, max2, cmat_size), dtype=np.float64, order="F")
for imol in range(nm1):
x1[imol,:n1[imol],:cmat_size] = mols1[imol].representation
for imol in range(nm2):
x2[imol,:n2[imol],:cmat_size] = mols2[imol].representation
# Reorder for Fortran speed
x1 = np.swapaxes(x1, 0, 2)
x2 = np.swapaxes(x2, 0, 2)
sigmas = np.asarray(sigmas, dtype=np.float64)
nsigmas = sigmas.size
return fget_vector_kernels_laplacian(x1, x2, n1, n2, sigmas,
nm1, nm2, nsigmas)
def get_atomic_kernels_laplacian_symmetric(mols, sigmas):
n = np.array([mol.natoms for mol in mols], dtype=np.int32)
max_atoms = np.max(n)
nm = n.size
cmat_size = mols[0].representation.shape[1]
x = np.zeros((nm, max_atoms, cmat_size), dtype=np.float64, order="F")
for imol in range(nm):
x[imol,:n[imol],:cmat_size] = mols[imol].representation
# Reorder for Fortran speed
x = np.swapaxes(x, 0, 2)
sigmas = np.asarray(sigmas, dtype=np.float64)
nsigmas = sigmas.size
return fget_vector_kernels_laplacian(x1, n, sigmas, nm, nsigmas)
def arad_local_kernels(mols1, mols2, sigmas,
width=0.2, cut_distance=5.0, r_width=1.0, c_width=0.5):
amax = mols1[0].representation.shape[0]
nm1 = len(mols1)
nm2 = len(mols2)
X1 = np.array([mol.representation for mol in mols1]).reshape((nm1, amax, 5, amax))
X2 = np.array([mol.representation for mol in mols2]).reshape((nm2, amax, 5, amax))
K = get_local_kernels_arad(X1, X2, sigmas,
width=width, cut_distance=cut_distance, r_width=r_width, c_width=c_width)
return K
def arad_local_symmetric_kernels(mols1, sigmas,
width=0.2, cut_distance=5.0, r_width=1.0, c_width=0.5):
amax = mols1[0].representation.shape[0]
nm1 = len(mols1)
X1 = np.array([mol.representation for mol in mols1]).reshape((nm1,amax,5,amax))
K = get_local_symmetric_kernels_arad(X1, sigmas, \
width=width, cut_distance=cut_distance, r_width=r_width, c_width=c_width)
return K
def get_atomic_kernels_laplacian(mols1, mols2, sigmas):
n1 = np.array([mol.natoms for mol in mols1], dtype=np.int32)
n2 = np.array([mol.natoms for mol in mols2], dtype=np.int32)
max1 = np.max(n1)
max2 = np.max(n2)
nm1 = n1.size
nm2 = n2.size
cmat_size = mols1[0].representation.shape[1]
x1 = np.zeros((nm1, max1, cmat_size), dtype=np.float64, order="F")
x2 = np.zeros((nm2, max2, cmat_size), dtype=np.float64, order="F")
for imol in range(nm1):
x1[imol,:n1[imol],:cmat_size] = mols1[imol].representation
for imol in range(nm2):
x2[imol,:n2[imol],:cmat_size] = mols2[imol].representation
# Reorder for Fortran speed
x1 = np.swapaxes(x1, 0, 2)
x2 = np.swapaxes(x2, 0, 2)
sigmas = np.asarray(sigmas, dtype=np.float64)
nsigmas = sigmas.size
return fget_vector_kernels_laplacian(x1, x2, n1, n2, sigmas,
nm1, nm2, nsigmas)
def get_atomic_kernels_gaussian(mols1, mols2, sigmas):
n1 = np.array([mol.natoms for mol in mols1], dtype=np.int32)
n2 = np.array([mol.natoms for mol in mols2], dtype=np.int32)
max1 = np.max(n1)
max2 = np.max(n2)
nm1 = n1.size
nm2 = n2.size
cmat_size = mols1[0].representation.shape[1]
x1 = np.zeros((nm1, max1, cmat_size), dtype=np.float64, order="F")
x2 = np.zeros((nm2, max2, cmat_size), dtype=np.float64, order="F")
for imol in range(nm1):
x1[imol,:n1[imol],:cmat_size] = mols1[imol].representation
for imol in range(nm2):
x2[imol,:n2[imol],:cmat_size] = mols2[imol].representation
# Reorder for Fortran speed
x1 = np.swapaxes(x1, 0, 2)
x2 = np.swapaxes(x2, 0, 2)
sigmas = np.array(sigmas, dtype=np.float64)
nsigmas = sigmas.size
return fget_vector_kernels_gaussian(x1, x2, n1, n2, sigmas,
nm1, nm2, nsigmas)
def get_atomic_kernels_gaussian_symmetric(mols, sigmas):
n = np.array([mol.natoms for mol in mols], dtype=np.int32)
max_atoms = np.max(n)
nm = n.size
cmat_size = mols[0].representation.shape[1]
x1 = np.zeros((nm, max_atoms, cmat_size), dtype=np.float64, order="F")
for imol in range(nm1):
x[imol,:n[imol],:cmat_size] = mols[imol].representation
# Reorder for Fortran speed
x = np.swapaxes(x, 0, 2)
sigmas = np.array(sigmas, dtype=np.float64)
nsigmas = sigmas.size
return fget_vector_kernels_gaussian_symmetric(x, n, sigmas, nm, nsigmas)
================================================
FILE: qml/math/__init__.py
================================================
# MIT License
#
# Copyright (c) 2017 Anders S. Christensen
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
from .math import *
================================================
FILE: qml/math/fsolvers.f90
================================================
! MIT License
!
! Copyright (c) 2016 Anders Steen Christensen
!
! Permission is hereby granted, free of charge, to any person obtaining a copy
! of this software and associated documentation files (the "Software"), to deal
! in the Software without restriction, including without limitation the rights
! to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
! copies of the Software, and to permit persons to whom the Software is
! furnished to do so, subject to the following conditions:
!
! The above copyright notice and this permission notice shall be included in all
! copies or substantial portions of the Software.
!
! THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
! IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
! FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
! AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
! LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
! OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
! SOFTWARE.
subroutine fcho_solve(A,y,x)
implicit none
double precision, dimension(:,:), intent(in) :: A
double precision, dimension(:), intent(in) :: y
double precision, dimension(:), intent(inout) :: x
integer :: info, na
na = size(A, dim=1)
call dpotrf("U", na, A, na, info)
if (info > 0) then
write (*,*) "WARNING: Error in LAPACK Cholesky decomposition DPOTRF()."
write (*,*) "WARNING: The", info, "-th leading order is not positive definite."
else if (info < 0) then
write (*,*) "WARNING: Error in LAPACK Cholesky decomposition DPOTRF()."
write (*,*) "WARNING: The", -info, "-th argument had an illegal value."
endif
x(:na) = y(:na)
call dpotrs("U", na, 1, A, na, x, na, info)
if (info < 0) then
write (*,*) "WARNING: Error in LAPACK Cholesky solver DPOTRS()."
write (*,*) "WARNING: The", -info, "-th argument had an illegal value."
endif
end subroutine fcho_solve
subroutine fcho_invert(A)
implicit none
double precision, dimension(:,:), intent(inout) :: A
integer :: info, na
na = size(A, dim=1)
call dpotrf("L", na, A , na, info)
if (info > 0) then
write (*,*) "WARNING: Cholesky decomposition DPOTRF() exited with error code:", info
endif
call dpotri("L", na, A , na, info )
if (info > 0) then
write (*,*) "WARNING: Cholesky inversion DPOTRI() exited with error code:", info
endif
end subroutine fcho_invert
subroutine fbkf_invert(A)
implicit none
double precision, dimension(:,:), intent(inout) :: A
integer :: info, na, nb
integer, dimension(size(A,1)) :: ipiv ! pivot indices
integer :: ilaenv
integer :: lwork
double precision, allocatable, dimension(:) :: work
na = size(A, dim=1)
nb = ilaenv( 1, 'DSYTRF', "L", na, -1, -1, -1 )
lwork = na*nb
allocate(work(lwork))
! call dpotrf("L", na, A , na, info)
call dsytrf("L", na, A, na, ipiv, work, lwork, info)
if (info > 0) then
write (*,*) "WARNING: Bunch-Kaufman factorization DSYTRI() exited with error code:", info
endif
! call dpotri("L", na, A , na, info )
call dsytri( "L", na, a, na, ipiv, work, info )
if (info > 0) then
write (*,*) "WARNING: BKF inversion DPOTRI() exited with error code:", info
endif
deallocate(work)
end subroutine fbkf_invert
subroutine fbkf_solve(A,y,x)
implicit none
double precision, dimension(:,:), intent(in) :: A
double precision, dimension(:), intent(in) :: y
double precision, dimension(:), intent(inout) :: x
double precision, allocatable, dimension(:) :: work
integer :: ilaenv
integer, dimension(size(A,1)) :: ipiv ! pivot indices
integer :: info, na, nb, lwork
na = size(A, dim=1)
nb = ilaenv( 1, 'DSYTRF', "L", na, -1, -1, -1 )
lwork = na*nb
allocate(work(lwork))
call dsytrf("L", na, A, na, ipiv, work, lwork, info)
if (info > 0) then
write (*,*) "WARNING: Bunch-Kaufman factorization DSYTRI() exited with error code:", info
endif
x(:na) = y(:na)
call dsytrs("L", na, 1, A, na, ipiv, x, na, info )
if (info > 0) then
write (*,*) "WARNING: Bunch-Kaufman solver DSYTRS() exited with error code:", info
endif
deallocate(work)
end subroutine fbkf_solve
subroutine fqrlq_solve(A, y, la, x)
implicit none
double precision, dimension(:,:), intent(inout) :: A
double precision, dimension(:), intent(inout):: y
integer, intent(in):: la
double precision, allocatable, dimension(:,:) :: b
double precision, dimension(la), intent(out) :: x
integer :: m, n, nrhs, lda, ldb, info
integer :: lwork
double precision, dimension(:), allocatable :: work
m = size(A, dim=1)
n = size(A, dim=2)
nrhs = 1
lda = m
ldb = max(m,n)
allocate(b(ldb,1))
b = 0.0d0
b(:m,1) = y(:m)
lwork = (min(m,n) + max(m,n)) * 10
allocate(work(lwork))
! write (*,*) info, lda, ldb, m, n
call dgels("N", m, n, nrhs, a, lda, b, ldb, work, lwork, info)
if (info < 0) then
write (*,*) "QML WARNING: Could not perform QRLQ solver DGELS: info =", info
else if (info > 0) then
write (*,*) "QML WARNING: QRLQ solver (DGELS) the", -info, "th"
write (*,*) "diagonal element of the triangular factor of A is zero,"
write (*,*) "so that A does not have full rank; the least squares"
write (*,*) "solution could not be computed."
endif
x(:n) = b(:n,1)
end subroutine fqrlq_solve
subroutine fsvd_solve(A, y, la, rcond, x)
implicit none
double precision, dimension(:,:), intent(inout) :: A
double precision, dimension(:), intent(inout):: y
integer, intent(in):: la
double precision, intent(in) :: rcond
double precision, allocatable, dimension(:,:) :: b
double precision, dimension(la), intent(out) :: x
integer :: m, n, nrhs, lda, ldb, info
integer :: lwork
integer :: liwork
double precision, dimension(:), allocatable :: work
integer, dimension(:), allocatable :: iwork
double precision, dimension(:), allocatable :: s
integer :: rank
m = size(A, dim=1)
n = size(A, dim=2)
nrhs = 1
lda = m
ldb = max(m,n)
allocate(b(ldb,1))
b = 0.0d0
b(:m,1) = y(:m)
allocate(s(ldb))
! rcond = 0.0d0
allocate(work(1))
allocate(iwork(1))
lwork = -1
call dgelsd(m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, iwork, info)
liwork = int(iwork(1))
lwork = int(work(1))
deallocate(work)
deallocate(iwork)
allocate(work(lwork))
allocate(iwork(liwork))
call dgelsd(m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, iwork, info)
! write (*,*) "DGELSD(): matrix rank =", rank, "/", n
! write (*,*) "DGELSD(): matrix rcond =", rcond
! write (*,*) "DGELSD(): matrix cond =", 1.0d0/rcond
! allocate(x(m))
x(:n) = b(:n,1)
end subroutine fsvd_solve
subroutine fcond(A, rcond)
implicit none
double precision, dimension(:,:), intent(inout) :: A
double precision, intent(out) :: rcond
double precision :: anorm
character, parameter :: norm = "1"
character, parameter :: uplo = "U"
double precision, allocatable, dimension(:) :: work
integer, allocatable, dimension(:) :: iwork
double precision, allocatable, dimension(:) :: A_diag
integer :: info, na, nb
integer :: n, lda
integer :: i
double precision :: dlansy
na = size(A, dim=1)
nb = size(A, dim=2)
n = na
lda = na
! Save diagonal
allocate(a_diag(n))
do i = 1, na
a_diag(i) = a(i,i)
enddo
allocate(work(n))
anorm = dlansy(norm, uplo, n, a, lda, work )
deallocate(work)
! Cholesky factorization
call dpotrf("U", n, A , lda, info)
if (info > 0) then
write (*,*) "WARNING: Cholesky decompositon failed because A is not positive definite. info = ", info
else if (info < 0) then
write (*,*) "WARNING: Cholesky decompositon DPOTRF() failed. info = ", info
endif
! Condition number from Cholesky factorization
allocate(work(n*3))
allocate(iwork(n))
call dpocon(uplo, n, a, lda, anorm, rcond, work, iwork, info)
if (info < 0) then
write (*,*) "WARNING: Calculating condition number DPOCON() failed. info = ", info
endif
deallocate(work)
deallocate(iwork)
! Restore lower triangle and diagonal
do i = 1, na
a(i,i) = a_diag(i)
a(i,i+1:) = a(i+1:,i)
enddo
deallocate(a_diag)
rcond = 1.0d0 / rcond
end subroutine fcond
subroutine fcond_ge(K, rcond)
implicit none
double precision, dimension(:,:), intent(in) :: K
double precision, intent(out) :: rcond
double precision :: anorm
character, parameter :: norm = "1"
! character, parameter :: uplo = "U"
double precision, allocatable, dimension(:) :: work
double precision, allocatable, dimension(:,:) :: A
integer, allocatable, dimension(:) :: iwork
integer, allocatable, dimension(:) :: ipiv
integer :: info
integer :: n, m, lda
double precision :: dlange
m = size(K, dim=1)
n = size(K, dim=2)
allocate(A(m,n))
A(:,:) = K(:,:)
lda = n
allocate(work(max(m,n)))
anorm = dlange( norm, m, n, a, lda, work )
deallocate(work)
allocate(ipiv(min(m,n)))
call dgetrf( m, n, a, lda, ipiv, info )
deallocate(ipiv)
if (info > 0) then
write (*,*) "WARNING: LU-decompositon failed because A is exactly singular. info = ", info
else if (info < 0) then
write (*,*) "WARNING: LU-decompositon DGETRF() failed. info = ", info
endif
allocate(work(n*4))
allocate(iwork(n))
call dgecon( norm, n, a, lda, anorm, rcond, work, iwork, info )
if (info < 0) then
write (*,*) "WARNING: Calculating condition number DGECON() failed. info = ", info
endif
deallocate(work)
deallocate(iwork)
deallocate(a)
rcond = 1.0d0 / rcond
end subroutine fcond_ge
================================================
FILE: qml/math/math.py
================================================
# MIT License
#
# Copyright (c) 2016 Anders Steen Christensen
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
import numpy as np
from copy import deepcopy
from .fsolvers import fcho_solve
from .fsolvers import fcho_invert
from .fsolvers import fbkf_solve
from .fsolvers import fbkf_invert
from .fsolvers import fsvd_solve
from .fsolvers import fqrlq_solve
from .fsolvers import fcond
from .fsolvers import fcond_ge
def 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.
:param A: Matrix (symmetric and positive definite, left-hand side).
:type A: numpy array
:return: The inverse matrix
:rtype: numpy array
"""
if len(A.shape) != 2 or A.shape[0] != A.shape[1]:
raise ValueError('expected square matrix')
I = np.asfortranarray(A)
fcho_invert(I)
# Matrix to store the inverse
i_lower = np.tril_indices_from(A)
# Copy lower triangle to upper
I.T[i_lower] = I[i_lower]
return I
def cho_solve(A, y, l2reg=0.0, destructive=False):
""" Solves the equation
:math:`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.
:param A: Matrix (symmetric and positive definite, left-hand side).
:type A: numpy array
:param y: Vector (right-hand side of the equation).
:type y: numpy array
:param l2reg: Small number to add to the diagonal as L2-regularization when solving.
:type l2reg: float
:param destructive: Whether to preserve the lower triangle after solving(=False) or destroy it, which is faster(=True).
:type destructive: bool
:return: The solution vector.
:rtype: numpy array
"""
if len(A.shape) != 2 or A.shape[0] != A.shape[1]:
raise ValueError('expected square matrix')
if len(y.shape) != 1 or y.shape[0] != A.shape[1]:
raise ValueError('expected matrix and vector of same stride size')
n = A.shape[0]
# Backup diagonal before Cholesky-decomposition
A_diag = A[np.diag_indices_from(A)]
for i in range(len(y)):
A[i,i] += l2reg
x = np.zeros(n)
fcho_solve(A, y, x)
# Reset diagonal after Cholesky-decomposition
A[np.diag_indices_from(A)] = A_diag
if destructive is False:
# Copy lower triangle to upper
i_lower = np.tril_indices_from(A)
A.T[i_lower] = A[i_lower]
return x
def bkf_invert(A):
""" Returns the inverse of a positive definite matrix, using a Bausch-Kauffman decomposition
via calls to LAPACK dpotrf and dpotri in the F2PY module.
:param A: Matrix (symmetric and positive definite, left-hand side).
:type A: numpy array
:return: The inverse matrix
:rtype: numpy array
"""
if len(A.shape) != 2 or A.shape[0] != A.shape[1]:
raise ValueError('expected square matrix')
I = np.asfortranarray(A)
fbkf_invert(I)
# Matrix to store the inverse
i_lower = np.tril_indices_from(A)
# Copy lower triangle to upper
I.T[i_lower] = I[i_lower]
return I
def bkf_solve(A, y):
""" Solves the equation
:math:`A x = y`
for x using a Bausch-Kauffma decomposition via calls to LAPACK in the F2PY module. Preserves the input matrix A.
:param A: Matrix (symmetric and positive definite, left-hand side).
:type A: numpy array
:param y: Vector (right-hand side of the equation).
:type y: numpy array
:return: The solution vector.
:rtype: numpy array
"""
if len(A.shape) != 2 or A.shape[0] != A.shape[1]:
raise ValueError('expected square matrix')
if len(y.shape) != 1 or y.shape[0] != A.shape[1]:
raise ValueError('expected matrix and vector of same stride size')
n = A.shape[0]
# Backup diagonal before Cholesky-decomposition
A_diag = A[np.diag_indices_from(A)]
x = np.zeros(n)
fbkf_solve(A, y, x)
# Reset diagonal after Cholesky-decomposition
A[np.diag_indices_from(A)] = A_diag
# Copy lower triangle to upper
i_lower = np.tril_indices_from(A)
A.T[i_lower] = A[i_lower]
return x
def svd_solve(A, y, rcond=None):
""" Solves the equation
:math:`A x = y`
for x using a singular-value decomposition (SVD) via calls to
LAPACK DGELSD in the F2PY module. Preserves the input matrix A.
:param A: Matrix (symmetric and positive definite, left-hand side).
:type A: numpy array
:param y: Vector (right-hand side of the equation).
:type y: numpy array
:param rcond: Optional parameater for lowest singular-value
:type rcond: float
:return: The solution vector.
:rtype: numpy array
"""
if len(y.shape) != 1 or y.shape[0] != A.shape[0]:
raise ValueError('expected matrix and vector of same stride size')
if rcond is None:
rcond=0.0
x_dim = A.shape[1]
A = np.asarray(A, order="F")
x = fsvd_solve(A, y, x_dim, rcond)
return x
def qrlq_solve(A, y):
""" Solves the equation
:math:`A x = y`
for x using a QR or LQ decomposition (depending on matrix dimensions)
via calls to LAPACK DGELSD in the F2PY module. Preserves the input matrix A.
:param A: Matrix (symmetric and positive definite, left-hand side).
:type A: numpy array
:param y: Vector (right-hand side of the equation).
:type y: numpy array
:return: The solution vector.
:rtype: numpy array
"""
if len(y.shape) != 1 or y.shape[0] != A.shape[0]:
raise ValueError('expected matrix and vector of same stride size')
x_dim = A.shape[1]
A = np.asarray(A, order="F")
x = fqrlq_solve(A, y, x_dim)
return x
def condition_number(A, method="cholesky"):
""" Returns the condition number for the square matrix A.
Two different methods are implemented:
Cholesky (requires a positive-definite matrix), but barely any additional memory overhead.
LU: Does not require a positive definite matrix, but requires additional memory.
"""
if len(A.shape) != 2 or A.shape[0] != A.shape[1]:
raise ValueError('expected square matrix')
if (method.lower() == "cholesky"):
assert np.allclose(A, A.T), \
"ERROR: Can't use a Cholesky-decomposition for a non-symmetric matrix."
cond = fcond(A)
return cond
elif (method.lower() == "lu"):
cond = fcond_ge(A)
return cond
================================================
FILE: qml/models/__init__.py
================================================
# MIT License
#
# Copyright (c) 2017 Anders S. Christensen
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
from .kernelridge import GenericKRR
================================================
FILE: qml/models/kernelridge.py
================================================
# MIT License
#
# Copyright (c) 2017 Anders S. Christensen
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
from __future__ import division, absolute_import, print_function
from time import time
import numpy as np
from ..representations import generate_coulomb_matrix
from ..kernels import gaussian_kernel
from ..math import cho_solve
from .mlmodel import MLModel
class GenericKRR(MLModel):
def __init__(self, targets, representation="coulomb-matrix",
kernel="gaussian", sigma=4000.0, llambda=1e-10):
super(GenericKRR,self).__init__(targets)
self.representation = representation
self.kernel = kernel
self.sigma = sigma
self.llambda = llambda
def _train(self, data):
start = time()
X = []
(properties, compounds) = data.get_properties()
for row in compounds.select():
# for key in row:
# print('{0:22}: {1}'.format(key, row[key]))
X.append(generate_coulomb_matrix(row["numbers"],
row["positions"]))
self.Y = np.array(properties)
self.X = np.array(X)
self.K = gaussian_kernel(self.X, self.X, self.sigma)
self.K[np.diag_indices_from(self.K)] += self.llambda
self.alpha = cho_solve(self.K, self.Y)
Yss = np.dot(self.K, self.alpha)
mae_training_error = np.mean(np.abs(Yss - self.Y))
rmse_training_error = np.sqrt(np.mean(np.square(Yss - self.Y)))
result = {
"MAETrainingError": mae_training_error,
"RMSETrainingError": rmse_training_error,
"ElapsedTime": time() - start,
}
return result
def _predict(self, data):
Xs = []
(properties, compounds) = data.get_properties()
for row in compounds.select():
# for key in row:
# print('{0:22}: {1}'.format(key, row[key]))
Xs.append(generate_coulomb_matrix(row["numbers"],
row["positions"]))
Xs = np.array(Xs)
Ks = gaussian_kernel(Xs, self.X, self.sigma)
return np.dot(Ks, self.alpha)
def _restore(self, path, load_kernel=False):
self.Y = np.load(path + "/Y.npy")
self.X = np.load(path + "/X.npy")
self.alpha = np.load(path + "/alpha.npy")
if load_kernel:
self.K = np.load(path + "/K.npy")
def _save(self, path, save_kernel=False):
np.save(path + "/X.npy", self.X)
np.save(path + "/Y.npy", self.Y)
np.save(path + "/alpha.npy", self.alpha)
if save_kernel:
np.save(path + "/K.npy")
================================================
FILE: qml/models/mlmodel.py
================================================
# MIT License
#
# Copyright (c) 2017 Anders S. Christensen
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
from __future__ import division, absolute_import, print_function
class MLModel(object):
def __init__(self, targets):
self._targes = targets
def train(self, data):
return self._train(data)
def predict(self, data):
return self._predict(data)
def save(self, path):
return self._save(path)
def restore(self, path):
return self._restore(path)
def _train(self, data):
raise NotImplementedError
def _predict(self, data):
raise NotImplementedError
def _save(self, path):
raise NotImplementedError
def _restore(self, path):
raise NotImplementedError
================================================
FILE: qml/qmlearn/__init__.py
================================================
# MIT License
#
# Copyright (c) 2018 Lars Andersen Bratholm
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
from .data import Data
from . import representations
from . import kernels
from . import preprocessing
from . import models
================================================
FILE: qml/qmlearn/data.py
================================================
from __future__ import print_function
import glob
import numpy as np
from ..utils import NUCLEAR_CHARGE
import copy
class Data(object):
"""
Temporary data class which should be replaced at some point by the ASE-interface.
This could in principle also be replaced by a dictionary
"""
def __init__(self, filenames=None, property_type = "energy"):
"""
:param filenames: list of filenames or a string to be read by glob. e.g. 'dir/*.xyz'
:type filenames: list or string
:param property_type: What kind of property will be predicted ('energy')
:type property_type: string
"""
self.property_type = property_type
self._set_ncompounds(0)
self.coordinates = None
self.nuclear_charges = None
self.natoms = None
self.energies = None
self.forces = None
if isinstance(filenames, str):
filenames = sorted(glob.glob(filenames))
if isinstance(filenames, list):
self._parse_xyz_files(filenames)
# Overwritten in various parts of a standard prediction pipeline
# so don't use these within the class
#self._has_transformed_labels
#self._representations
#self._kernel
#self._indices
#self._representation_type
#self._representation_short_name
#self._representation_cutoff
#self._representation_alchemy
def _set_ncompounds(self, n):
self.ncompounds = n
# Hack for sklearn CV
self.shape = (n,)
def take(self, i, axis=None):
"""
Hack for sklearn CV
"""
other = copy.copy(self)
other._indices = i
return other
# Hack for sklearn CV
def __getitem__(self, i):
return i
# Hack for sklearn CV but also convenience
def __len__(self):
if hasattr(self, '_indices'):
return len(self._indices)
return self.ncompounds
# Hack for sklearn CV but also convenience
def __eq__(self, other):
"""
Overrides the == operator.
"""
if type(self) != type(other):
return False
self_vars = vars(self)
other_vars = vars(other)
if len(self_vars) != len(other_vars):
return False
for key, val in self_vars.items():
if val is not other_vars[key]:
return False
return True
# Hack for sklearn CV but also convenience
def __ne__(self, other):
"""
Overrides the != operator (unnecessary in Python 3)
"""
return not self.__eq__(other)
def set_energies(self, energies):
self.energies = energies
def set_forces(self, forces):
self.forces = forces
def _parse_xyz_files(self, filenames):
"""
Parse a list of xyz files.
"""
self._set_ncompounds(len(filenames))
self.coordinates = np.empty(self.ncompounds, dtype=object)
self.nuclear_charges = np.empty(self.ncompounds, dtype=object)
self.natoms = np.empty(self.ncompounds, dtype = int)
for i, filename in enumerate(filenames):
with open(filename, "r") as f:
lines = f.readlines()
natoms = int(lines[0])
self.natoms[i] = natoms
self.nuclear_charges[i] = np.empty(natoms, dtype=int)
self.coordinates[i] = np.empty((natoms, 3), dtype=float)
for j, line in enumerate(lines[2:natoms+2]):
tokens = line.split()
if len(tokens) < 4:
break
self.nuclear_charges[i][j] = NUCLEAR_CHARGE[tokens[0]]
self.coordinates[i][j] = np.asarray(tokens[1:4], dtype=float)
# Try to convert dtype to int/float in cases where you have the
# same molecule, just different conformers
try:
self.nuclear_charges = np.asarray([self.nuclear_charges[i] for i in range(self.ncompounds)],
dtype=int)
self.coordinates = np.asarray([self.coordinates[i] for i in range(self.ncompounds)],
dtype=float)
except ValueError:
pass
================================================
FILE: qml/qmlearn/kernels.py
================================================
# MIT License
#
# Copyright (c) 2018 Lars Andersen Bratholm
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
from __future__ import print_function
import numpy as np
from sklearn.base import BaseEstimator
from .data import Data
from ..kernels.fkernels import fget_vector_kernels_gaussian
from ..kernels.fkernels import fget_vector_kernels_gaussian_symmetric
from ..kernels.fkernels import fget_vector_kernels_laplacian
from ..kernels.fkernels import fget_vector_kernels_laplacian_symmetric
from ..kernels import gaussian_kernel
from ..kernels import gaussian_kernel_symmetric
from ..kernels import laplacian_kernel
from ..kernels import laplacian_kernel_symmetric
from ..fchl import get_global_symmetric_kernels
from ..fchl import get_global_kernels
from ..fchl import get_local_symmetric_kernels
from ..fchl import get_local_kernels
from ..utils.alchemy import get_alchemy
from ..utils import get_unique
from ..kernels.gradient_kernels import get_atomic_local_kernel
from ..kernels.gradient_kernels import get_atomic_local_gradient_kernel
from ..kernels.gradient_kernels import get_local_kernel
from ..kernels.gradient_kernels import get_local_symmetric_kernel
from ..kernels.gradient_kernels import get_symmetric_gp_kernel
from ..kernels.gradient_kernels import get_gp_kernel
class _BaseKernel(BaseEstimator):
"""
Base class for kernels
"""
def fit(self, X):
"""
The fit routine is needed for scikit-learn pipelines.
This is actually never used but has to be here.
"""
raise NotImplementedError
def transform(self, X, y = None):
"""
The transform routine is needed for scikit-learn pipelines.
"""
raise NotImplementedError
def generate(self, **params):
raise NotImplementedError
def _check_data_object(self, X):
# Check that we have a data object
if not isinstance(X, Data):
print("Error: Expected Data object as input in %s" % self.__class__.__name__)
raise SystemExit
if not hasattr(X, '_representation_short_name'):
print("Error: No representations found in Data object")
raise SystemExit
if X._representation_short_name == 'fchl' and self.__class__.__name__ != 'FCHLKernel' or \
X._representation_short_name != 'fchl' and self.__class__.__name__ == 'FCHLKernel':
print("Error: The FCHL representation is only compatible with the FCHL kernel")
raise SystemExit
def _set_representations(self, rep):
self.representations = rep
def _set_nuclear_charges(self, charge):
self.nuclear_charges = charge
def transform(self, X):
self._check_data_object(X)
# Kernel between representation stored in fit and representation
# given in data object. The order matters
if X._representation_type is None:
# For FCHL to keep the documentation tidy, since self.local overrides
# X._representation_type
kernel = self.generate(X._representations, self.representations)
elif X._representation_type == 'molecular':
# Ignore constant features
constant_features = (np.std(X._representations, axis=0) == 0) * self._constant_features * \
(X._representations[0] == self.representations[0])
kernel = self.generate(X._representations[:,~constant_features], self.representations[:,~constant_features], 'molecular')
elif self.representation_type == "atomic-force":
kernel = self.generate(X._representations, self.representations)
elif (self.alchemy == 'auto' and X._representation_alchemy) or self.alchemy:
# Ignore constant features
flat_representations = np.asarray([item for sublist in X._representations for item in sublist])
constant_features = (np.std(flat_representations, axis=0) == 0) * self._constant_features * \
(X._representations[0][0] == self.representations[0][0])
X_representations = [np.asarray([rep[~constant_features] for rep in mol]) for mol in X._representations]
self_representations = [np.asarray([rep[~constant_features] for rep in mol]) for mol in self.representations]
kernel = self.generate(X_representations, self_representations, 'atomic')
else:
# Find elements used in representations from X
elements1 = get_unique(X.nuclear_charges[X._indices])
# Get the elements common to both X and the fitted representations
# stored in self
elements = list(set(elements1).intersection(self.elements))
## Get list in the form [H_representations, C_representations, ...]
# And ignore constant features
rep1, rep2 = self._get_elementwise_representations_transform(X._representations, X.nuclear_charges[X._indices], elements)
# Sum elementwise contributions to the kernel
kernel = np.zeros((len(X._representations), len(self.representations)))
for i in range(len(rep1)):
kernel += self.generate(rep1[i], rep2[i], representation_type='atomic')
X._kernel = kernel
return X
def _get_elementwise_representations_transform(self, representations, nuclear_charges, elements):
"""
Create a set of lists where the each item only contain representations of a specific element
"""
# Ignore constant features
flat_nuclear_charges1 = np.asarray([item for sublist in nuclear_charges for item in sublist], dtype=int)
flat_representations1 = np.asarray([item for sublist in representations for item in sublist])
flat_nuclear_charges2 = np.asarray([item for sublist in self.nuclear_charges for item in sublist], dtype=int)
flat_representations2 = np.asarray([item for sublist in self.representations for item in sublist])
constant_features = {element: None for element in elements}
for ele in elements:
rep1 = flat_representations1[flat_nuclear_charges1 == ele]
rep2 = flat_representations2[flat_nuclear_charges2 == ele]
rep = np.concatenate([rep1, rep2])
constant_features[ele] = (np.std(rep, axis=0) == 0)
# Create the representations
elementwise_representations1 = [[np.atleast_2d(
[v[~constant_features[element]] for j,v in enumerate(representations[i])
if nuclear_charges[i][j] == element]) for i in range(len(nuclear_charges))]
for element in elements]
elementwise_representations2 = [[np.atleast_2d(
[v[~constant_features[element]] for j,v in enumerate(self.representations[i])
if self.nuclear_charges[i][j] == element]) for i in range(len(self.nuclear_charges))]
for element in elements]
return elementwise_representations1, elementwise_representations2
def _get_elementwise_representations_fit(self, representations, nuclear_charges):
"""
Create a list where the each item only contain representations of a specific element
"""
elements = get_unique(nuclear_charges)
self.elements = elements
# Ignore constant features
flat_nuclear_charges = np.asarray([item for sublist in nuclear_charges for item in sublist], dtype=int)
flat_representations = np.asarray([item for sublist in representations for item in sublist])
constant_features = {element: None for element in elements}
for ele in elements:
rep = flat_representations[flat_nuclear_charges == ele]
constant_features[ele] = (np.std(rep, axis=0) == 0)
# Create the representations
elementwise_representations = [[np.atleast_2d(
[v[~constant_features[element]] for j,v in enumerate(representations[i])
if nuclear_charges[i][j] == element]) for i in range(len(nuclear_charges))]
for element in elements]
return elementwise_representations
def _fit_transform(self, X):
self._check_data_object(X)
# Store representation / nuclear_charges for future transform calls
self._set_representations(X._representations)
self._set_nuclear_charges(X.nuclear_charges[X._indices])
if X._representation_type is None:
# For FCHL to keep the documentation tidy, since self.local overrides
# X._representation_type
kernel = self.generate(X._representations)
elif X._representation_type == 'molecular':
# Ignore constant features
self._constant_features = (np.std(X._representations, axis=0) == 0)
kernel = self.generate(X._representations[:,~self._constant_features], representation_type='molecular')
elif self.representation_type == "atomic-force":
kernel = self.generate(X._representations)
elif (self.alchemy == 'auto' and X._representation_alchemy) or self.alchemy:
# Ignore constant features
flat_representations = np.asarray([item for sublist in X._representations for item in sublist])
self._constant_features = (np.std(flat_representations, axis=0) == 0)
representations = [np.asarray([rep[~self._constant_features] for rep in mol]) for mol in X._representations]
kernel = self.generate(representations, representation_type='atomic')
else:
# Get list in the form [H_representations, C_representations, ...]
# And ignore constant features
rep = self._get_elementwise_representations_fit(X._representations, X.nuclear_charges[X._indices])
# Sum elementwise contributions to the kernel
kernel = np.zeros((len(X._representations),)*2)
for r in rep:
kernel += self.generate(r, representation_type='atomic')
# Store kernel
X._kernel = kernel
return X
def fit_transform(self, X, y=None):
return self._fit_transform(X)
class GaussianKernel(_BaseKernel):
"""
Gaussian kernel
"""
def __init__(self, sigma='auto', alchemy='auto'):
"""
:param sigma: Scale parameter of the gaussian kernel. `sigma='auto'` will try to guess
a good value (very approximate).
:type sigma: float
:param alchemy: Determines if contributions from atoms of differing elements should be
included in the kernel. If alchemy='auto', this will be automatically
determined from the representation used
:type alchemy: bool
"""
self.sigma = sigma
self.alchemy = alchemy
self.representations = None
self._elements = None
self._constant_features = None
def _quick_estimate_sigma(self, X, representation_type, sigma_init=100, count=1):
"""
Use 50 random points for atomic, 200 for molecular, to get an approximate guess for sigma
"""
if count > 10:
print("Error. Could not automatically determine parameter `sigma` in the kernel %s"
% self.__class__.__name__)
raise SystemExit
if representation_type == 'molecular':
n = 200
else:
n = 50
if len(X) < n:
n = len(X)
self.sigma = sigma_init
# Generate kernel for a random subset
indices = np.random.choice(np.arange(len(X)), size=n, replace=False)
kernel = self.generate([X[i] for i in indices], representation_type=representation_type)
if representation_type == 'molecular':
# min smallest kernel element
smallest_kernel_element = np.min(kernel)
# Rescale sigma such that smallest kernel element will be equal to 1/2
self.sigma *= np.sqrt(-np.log(smallest_kernel_element) / np.log(2))
# Update sigma if the given sigma was completely wrong
if np.isinf(self.sigma):
self._quick_estimate_sigma(X, representation_type, sigma_init * 10, count + 1)
elif self.sigma <= 1e-12:
self._quick_estimate_sigma(X, representation_type, sigma_init / 10, count + 1)
else:
sizes = np.asarray([len(X[i]) for i in indices])
kernel /= sizes[:,None] * sizes[None,:]
smallest_kernel_element = np.min(kernel)
if smallest_kernel_element < 0.5:
self._quick_estimate_sigma(X, representation_type, sigma_init * 2.5, count + 1)
elif smallest_kernel_element > 0.95:
self._quick_estimate_sigma(X, representation_type, sigma_init / 2.5, count + 1)
def generate(self, X, Y=None, representation_type='molecular'):
"""
Create a gaussian kernel from representations `X`. Optionally
an asymmetric kernel can be constructed between representations
`X` and `Y`.
If `representation_type=='molecular` it is assumed that the representations
are molecular and of shape (n_samples, representation_size).
If `representation_type=='atomic` the representations are assumed to be atomic
and the kernel will be computed as an atomic decomposition.
:param X: representations
:type X: array
:param Y: (Optional) representations
:type Y: array
:return: Gaussian kernel matrix of shape (n_samplesX, n_samplesX) if \
Y=None else (n_samplesX, n_samplesY)
:rtype: array
"""
if self.sigma == 'auto':
if representation_type == 'molecular':
auto_sigma = True
else:
auto_sigma = False
# Do a quick and dirty initial estimate of sigma
self._quick_estimate_sigma(X, representation_type)
else:
auto_sigma = False
if representation_type == 'molecular':
kernel = self._generate_molecular(X,Y)
elif representation_type == 'atomic':
kernel = self._generate_atomic(X,Y)
else:
# Should never get here for users
print("Error: representation_type needs to be 'molecular' or 'atomic'. Got %s" % representation_type)
raise SystemExit
if auto_sigma:
# Find smallest kernel element
smallest_kernel_element = np.min(kernel)
largest_kernel_element = np.max(kernel)
# Rescale kernel such that we don't have to calculate it again for a new sigma
alpha = - np.log(2) / np.log(smallest_kernel_element/largest_kernel_element)
self.sigma /= np.sqrt(alpha)
return kernel ** alpha
return kernel
def _generate_molecular(self, X, Y=None):
if Y is None or X is Y:
# Do symmetric matrix
return gaussian_kernel_symmetric(np.array(X), self.sigma)
else:
return gaussian_kernel(np.array(X), np.array(Y), self.sigma)
def _generate_atomic(self, X, Y=None):
n1 = np.array([len(x) for x in X], dtype=np.int32)
max1 = np.max(n1)
nm1 = n1.size
# This is a bit of a mess to get kernels without
# alchemy working
for i in range(len(X)):
rep_size = X[0].shape[1]
if rep_size == 0:
continue
break
else:
if Y is None:
return np.zeros((nm1, nm1))
return np.zeros((nm1, len(Y)))
x1 = np.zeros((nm1, max1, rep_size), dtype=np.float64, order="F")
# This is a bit of a mess to get kernels without
# alchemy working
for i in range(nm1):
if X[i].shape[1] == 0:
n1[i] = 0
continue
x1[i,:n1[i]] = X[i]
# Reorder for Fortran speed
x1 = np.swapaxes(x1, 0, 2)
sigmas = np.array([self.sigma], dtype=np.float64)
nsigmas = sigmas.size
if Y is None or X is Y:
# Do symmetric matrix
return fget_vector_kernels_gaussian_symmetric(x1, n1, [self.sigma],
nm1, nsigmas)[0]
else:
# Do asymmetric matrix
n2 = np.array([len(y) for y in Y], dtype=np.int32)
max2 = np.max(n2)
nm2 = n2.size
x2 = np.zeros((nm2, max2, rep_size), dtype=np.float64, order="F")
# This is a bit of a mess to get kernels without
# alchemy working
for i in range(nm2):
if Y[i].shape[1] == 0:
n2[i] = 0
continue
x2[i,:n2[i]] = Y[i]
x2 = np.swapaxes(x2, 0, 2)
return fget_vector_kernels_gaussian(x1, x2, n1, n2, [self.sigma],
nm1, nm2, nsigmas)[0]
class LaplacianKernel(_BaseKernel):
"""
Laplacian kernel
"""
def __init__(self, sigma='auto', alchemy='auto'):
"""
:param sigma: Scale parameter of the gaussian kernel. `sigma='auto'` will try to guess
a good value (very approximate).
:type sigma: float or string
:param alchemy: Determines if contributions from atoms of differing elements should be
included in the kernel.
:type alchemy: bool
"""
self.sigma = sigma
self.alchemy = alchemy
self.representations = None
self._elements = None
self._constant_features = None
def _quick_estimate_sigma(self, X, representation_type, sigma_init=100, count=1):
"""
Use 50 random points for atomic, 200 for molecular, to get an approximate guess for sigma
"""
if count > 10:
print("Error. Could not automatically determine parameter `sigma` in the kernel %s"
% self.__class__.__name__)
raise SystemExit
if representation_type == 'molecular':
n = 200
else:
n = 50
if len(X) < n:
n = len(X)
self.sigma = sigma_init
# Generate kernel for a random subset
indices = np.random.choice(np.arange(len(X)), size=n, replace=False)
kernel = self.generate([X[i] for i in indices], representation_type=representation_type)
if representation_type == 'molecular':
# min smallest kernel element
smallest_kernel_element = np.min(kernel)
# Rescale sigma such that smallest kernel element will be equal to 1/2
self.sigma *= - np.log(smallest_kernel_element) / np.log(2)
# Update sigma if the given sigma was completely wrong
if np.isinf(self.sigma):
self._quick_estimate_sigma(X, representation_type, sigma_init * 10, count + 1)
elif self.sigma <= 1e-12:
self._quick_estimate_sigma(X, representation_type, sigma_init / 10, count + 1)
else:
sizes = np.asarray([len(X[i]) for i in indices])
kernel /= sizes[:,None] * sizes[None,:]
smallest_kernel_element = np.min(kernel)
if smallest_kernel_element < 0.5:
self._quick_estimate_sigma(X, representation_type, sigma_init * 2.5, count + 1)
elif smallest_kernel_element > 1:
self._quick_estimate_sigma(X, representation_type, sigma_init / 2.5, count + 1)
def generate(self, X, Y=None, representation_type='molecular'):
"""
Create a gaussian kernel from representations `X`. Optionally
an asymmetric kernel can be constructed between representations
`X` and `Y`.
If `representation_type=='molecular` it is assumed that the representations
are molecular and of shape (n_samples, representation_size).
If `representation_type=='atomic` the representations are assumed to be atomic
and the kernel will be computed as an atomic decomposition.
:param X: representations
:type X: array
:param Y: (Optional) representations
:type Y: array
:return: Gaussian kernel matrix of shape (n_samplesX, n_samplesX) if \
Y=None else (n_samplesX, n_samplesY)
:rtype: array
"""
if self.sigma == 'auto':
if representation_type == 'molecular':
auto_sigma = True
else:
auto_sigma = False
# Do a quick and dirty initial estimate of sigma
self._quick_estimate_sigma(X, representation_type)
else:
auto_sigma = False
if representation_type == 'molecular':
kernel = self._generate_molecular(X,Y)
elif representation_type == 'atomic':
kernel = self._generate_atomic(X,Y)
else:
# Should never get here for users
print("Error: representation_type needs to be 'molecular' or 'atomic'. Got %s" % representation_type)
raise SystemExit
if auto_sigma:
# Find smallest kernel element
smallest_kernel_element = np.min(kernel)
largest_kernel_element = np.max(kernel)
# Rescale kernel such that we don't have to calculate it again for a new sigma
alpha = - np.log(2) / np.log(smallest_kernel_element/largest_kernel_element)
self.sigma /= alpha
return kernel ** alpha
return kernel
def _generate_molecular(self, X, Y=None):
if Y is None or X is Y:
# Do symmetric matrix
return laplacian_kernel_symmetric(np.array(X), self.sigma)
else:
return laplacian_kernel(np.array(X), np.array(Y), self.sigma)
def _generate_atomic(self, X, Y=None):
n1 = np.array([len(x) for x in X], dtype=np.int32)
max1 = np.max(n1)
nm1 = n1.size
# This is a bit of a mess to get kernels without
# alchemy working
for i in range(len(X)):
rep_size = X[0].shape[1]
if rep_size == 0:
continue
break
else:
if Y is None:
return np.zeros((nm1, nm1))
return np.zeros((nm1, len(Y)))
x1 = np.zeros((nm1, max1, rep_size), dtype=np.float64, order="F")
# This is a bit of a mess to get kernels without
# alchemy working
for i in range(nm1):
if X[i].shape[1] == 0:
n1[i] = 0
continue
x1[i,:n1[i]] = X[i]
#for i,j in zip(x1[:,:,2], n1):
# print(i,j)
# Reorder for Fortran speed
x1 = np.swapaxes(x1, 0, 2)
sigmas = np.array([self.sigma], dtype=np.float64)
nsigmas = sigmas.size
if Y is None or X is Y:
# Do symmetric matrix
return fget_vector_kernels_laplacian_symmetric(x1, n1, [self.sigma],
nm1, nsigmas)[0]
else:
# Do asymmetric matrix
n2 = np.array([len(y) for y in Y], dtype=np.int32)
max2 = np.max(n2)
nm2 = n2.size
x2 = np.zeros((nm2, max2, rep_size), dtype=np.float64, order="F")
# This is a bit of a mess to get kernels without
# alchemy working
for i in range(nm2):
if Y[i].shape[1] == 0:
n2[i] = 0
continue
x2[i,:n2[i]] = Y[i]
x2 = np.swapaxes(x2, 0, 2)
return fget_vector_kernels_laplacian(x1, x2, n1, n2, [self.sigma],
nm1, nm2, nsigmas)[0]
class FCHLKernel(_BaseKernel):
"""
FCHL kernel
"""
def __init__(self, sigma='auto', alchemy=True, two_body_scaling=np.sqrt(8),
three_body_scaling=1.6, two_body_width=0.2, three_body_width=np.pi,
two_body_power=4.0, three_body_power=2.0, damping_start=1.0, cutoff=5.0,
fourier_order=1, alchemy_period_width=1.6, alchemy_group_width=1.6,
local=True):
"""
:param sigma: Scale parameter of the gaussian basis functions. `sigma='auto'` will try to guess
a good value (very approximate).
:type sigma: float or string
:param alchemy: Determines if contributions from atoms of differing elements should be
included in the kernel.
:type alchemy: bool
:param two_body_scaling: Weight for 2-body terms.
:type two_body_scaling: float
:param three_body_scaling: Weight for 3-body terms.
:type three_body_scaling: float
:param two_body_width: Gaussian width for 2-body terms
:type two_body_width: float
:param three_body_width: Gaussian width for 3-body terms.
:type three_body_width: float
:param two_body_power: Powerlaw for :math:`r^{-n}` 2-body terms.
:type two_body_power: float
:param three_body_power: Powerlaw for Axilrod-Teller-Muto 3-body term
:type three_body_power: float
:param damping_start: The fraction of the cutoff radius at which cut-off damping start.
:type damping_start: float
:param cutoff: Cut-off radius.
:type cutoff: float
:param fourier_order: 3-body Fourier-expansion truncation order.
:type fourier_order: integer
:param alchemy_period_width: Gaussian width along periods (columns) in the periodic table.
:type alchemy_period_width: float
:param alchemy_group_width: Gaussian width along groups (rows) in the periodic table.
:type alchemy_group_width: float
:param local: Do local decomposition
:param local: bool
"""
self.sigma = sigma
self.alchemy = alchemy
self.two_body_scaling = two_body_scaling
self.three_body_scaling = three_body_scaling
self.two_body_width = two_body_width
self.three_body_width = three_body_width
self.two_body_power = two_body_power
self.three_body_power = three_body_power
self.damping_start = damping_start
self.cutoff = cutoff
self.fourier_order = fourier_order
self.alchemy_period_width = alchemy_period_width
self.alchemy_group_width = alchemy_group_width
self.local = local
self.representations = None
def _quick_estimate_sigma(self, X, sigma_init=1, count=1):
"""
Use 50 random points for atomic, 200 for molecular, to get an approximate guess for sigma
"""
if count > 10:
print("Error. Could not automatically determine parameter `sigma` in the kernel %s"
% self.__class__.__name__)
raise SystemExit
n = 50
if len(X) < n:
n = len(X)
self.sigma = sigma_init
# Generate kernel for a random subset
indices = np.random.choice(np.arange(len(X)), size=n, replace=False)
kernel = self.generate([X[i] for i in indices])
if not self.local:
# min smallest kernel element
smallest_kernel_element = np.min(kernel)
if smallest_kernel_element < 0.3:
self._quick_estimate_sigma(X, sigma_init * 2.5, count + 1)
elif smallest_kernel_element > 0.9:
self._quick_estimate_sigma(X, sigma_init / 2.5, count + 1)
else:
sizes = np.asarray([len(X[i]) for i in indices])
kernel /= sizes[:,None] * sizes[None,:]
smallest_kernel_element = np.min(kernel)
if smallest_kernel_element < 0.1:
self._quick_estimate_sigma(X, sigma_init * 2.5, count + 1)
elif smallest_kernel_element > 0.3:
self._quick_estimate_sigma(X, sigma_init / 2.5, count + 1)
def generate(self, X, Y=None):
"""
Create a kernel from representations `X`. Optionally
an asymmetric kernel can be constructed between representations
`X` and `Y`.
:param X: representations
:type X: array
:param Y: (Optional) representations
:type Y: array
:return: Gaussian kernel matrix of shape (n_samplesX, n_samplesX) if \
Y=None else (n_samplesX, n_samplesY)
:rtype: array
"""
if self.sigma == 'auto':
# Do a quick and dirty initial estimate of sigma
self._quick_estimate_sigma(X)
if not self.local:
kernel = self._generate_molecular(X,Y)
else:
kernel = self._generate_atomic(X,Y)
return kernel
def _generate_molecular(self, X, Y=None):
if self.alchemy:
alchemy = 'periodic-table'
else:
alchemy = 'off'
if Y is None or X is Y:
return get_global_symmetric_kernels(X, two_body_scaling=self.two_body_scaling,
three_body_scaling=self.three_body_scaling, two_body_width=self.two_body_width,
three_body_width=self.three_body_width, two_body_power=self.two_body_power,
three_body_power=self.three_body_power, cut_start=self.damping_start,
cut_distance=self.cutoff, fourier_order=self.fourier_order, alchemy=alchemy,
alchemy_period_width=self.alchemy_period_width, alchemy_group_width=self.alchemy_group_width,
kernel_args={'sigma': [self.sigma]})[0]
else:
return get_global_kernels(X, Y, two_body_scaling=self.two_body_scaling,
three_body_scaling=self.three_body_scaling, two_body_width=self.two_body_width,
three_body_width=self.three_body_width, two_body_power=self.two_body_power,
three_body_power=self.three_body_power, cut_start=self.damping_start,
cut_distance=self.cutoff, fourier_order=self.fourier_order, alchemy=alchemy,
alchemy_period_width=self.alchemy_period_width, alchemy_group_width=self.alchemy_group_width,
kernel_args={'sigma': [self.sigma]})[0]
def _generate_atomic(self, X, Y=None):
if self.alchemy:
alchemy = 'periodic-table'
else:
alchemy = 'off'
if Y is None or X is Y:
return get_local_symmetric_kernels(X, two_body_scaling=self.two_body_scaling,
three_body_scaling=self.three_body_scaling, two_body_width=self.two_body_width,
three_body_width=self.three_body_width, two_body_power=self.two_body_power,
three_body_power=self.three_body_power, cut_start=self.damping_start,
cut_distance=self.cutoff, fourier_order=self.fourier_order, alchemy=alchemy,
alchemy_period_width=self.alchemy_period_width, alchemy_group_width=self.alchemy_group_width,
kernel_args={'sigma': [self.sigma]})[0]
else:
return get_local_kernels(X, Y, two_body_scaling=self.two_body_scaling,
three_body_scaling=self.three_body_scaling, two_body_width=self.two_body_width,
three_body_width=self.three_body_width, two_body_power=self.two_body_power,
three_body_power=self.three_body_power, cut_start=self.damping_start,
cut_distance=self.cutoff, fourier_order=self.fourier_order, alchemy=alchemy,
alchemy_period_width=self.alchemy_period_width, alchemy_group_width=self.alchemy_group_width,
kernel_args={'sigma': [self.sigma]})[0]
def fit_transform(self, X, y=None):
# Check that the cutoff is less than the cutoff used to make the representation
if self.cutoff > X._representation_cutoff:
print("Error: Cutoff used in the FCHL kernel (%.2f) must be lower or equal" % self.cutoff,
"to the cutoff used in the FCHL representation (%.2f)" % X._representation_cutoff)
raise SystemExit
return self._fit_transform(X)
class OQMLForceKernel(_BaseKernel):
def __init__(self, sigma=10.0, local=True):
self.sigma = sigma
self.alchemy = "off"
self.representation_type = "atomic-force"
self.local = True
def _quick_estimate_sigma(self, X, sigma_init=1, count=1):
print("Error. Could not automatically determine parameter `sigma` in the kernel %s"
% self.__class__.__name__)
raise SystemExit
def generate(self, X, Y=None, representation_type="atomic"):
"""
Create a kernel from representations `X`. Optionally
an asymmetric kernel can be constructed between representations
`X` and `Y`.
:param X: representations
:type X: array
:param Y: (Optional) representations
:type Y: array
:return: Gaussian kernel matrix of shape (n_samplesX, n_samplesX) if \
Y=None else (n_samplesX, n_samplesY)
:rtype: array
"""
if self.sigma == 'auto':
# Do a quick and dirty initial estimate of sigma
self._quick_estimate_sigma(X)
if not self.local:
kernel = self._generate_molecular(X,Y)
else:
kernel = self._generate_atomic(X,Y)
return kernel
def _generate_molecular(self, X, Y=None):
print("OQML doesn't support global kernels")
raise SystemExit
def _generate_atomic(self, X, Y=None):
X1 = np.array([rep[0] for rep in X])
dX1 = np.array([rep[1] for rep in X])
Q1 = [rep[2] for rep in X]
if Y is None or X is Y:
K_energy = get_atomic_local_kernel(X1, X1, Q1, Q1, self.sigma)
K_force = get_atomic_local_gradient_kernel(X1, X1, dX1, Q1, Q1, self.sigma)
K_return = np.concatenate((K_energy, K_force))
return K_return
else:
X2 = np.array([rep[0] for rep in Y])
dX2 = np.array([rep[1] for rep in Y])
Q2 = [rep[2] for rep in Y]
K_energy = get_atomic_local_kernel(X2, X1, Q2, Q1, self.sigma)
K_force = get_atomic_local_gradient_kernel(X2, X1, dX1, Q2, Q1, self.sigma)
K_return = np.concatenate((K_energy, K_force))
return K_return
def fit_transform(self, X, y=None):
return self._fit_transform(X)
class GPRForceKernel(_BaseKernel):
def __init__(self, sigma=10.0, local=True):
self.sigma = sigma
self.alchemy = "off"
self.representation_type = "atomic-force"
self.local = True
def _quick_estimate_sigma(self, X, sigma_init=1, count=1):
print("Error. Could not automatically determine parameter `sigma` in the kernel %s"
% self.__class__.__name__)
raise SystemExit
def generate(self, X, Y=None, representation_type="atomic"):
"""
Create a kernel from representations `X`. Optionally
an asymmetric kernel can be constructed between representations
`X` and `Y`.
:param X: representations
:type X: array
:param Y: (Optional) representations
:type Y: array
:return: Gaussian kernel matrix of shape (n_samplesX, n_samplesX) if \
Y=None else (n_samplesX, n_samplesY)
:rtype: array
"""
if self.sigma == 'auto':
# Do a quick and dirty initial estimate of sigma
self._quick_estimate_sigma(X)
if not self.local:
kernel = self._generate_molecular(X,Y)
else:
kernel = self._generate_atomic(X,Y)
return kernel
def _generate_molecular(self, X, Y=None):
print("OQML doesn't support global kernels")
raise SystemExit
def _generate_atomic(self, X, Y=None):
X1 = np.array([rep[0] for rep in X])
dX1 = np.array([rep[1] for rep in X])
Q1 = [rep[2] for rep in X]
if Y is None or X is Y:
K_return = get_symmetric_gp_kernel(X1, dX1, Q1, self.sigma)
return K_return
else:
X2 = np.array([rep[0] for rep in Y])
dX2 = np.array([rep[1] for rep in Y])
Q2 = [rep[2] for rep in Y]
K_return = get_gp_kernel(X2, X1, dX2, dX1, Q2, Q1, self.sigma)
return K_return
def fit_transform(self, X, y=None):
return self._fit_transform(X)
class GPREnergyKernel(_BaseKernel):
def __init__(self, sigma=10.0, local=True):
self.sigma = sigma
self.alchemy = "off"
self.representation_type = "atomic-force"
self.local = True
def _quick_estimate_sigma(self, X, sigma_init=1, count=1):
print("Error. Could not automatically determine parameter `sigma` in the kernel %s"
% self.__class__.__name__)
raise SystemExit
def generate(self, X, Y=None, representation_type="atomic"):
"""
Create a kernel from representations `X`. Optionally
an asymmetric kernel can be constructed between representations
`X` and `Y`.
:param X: representations
:type X: array
:param Y: (Optional) representations
:type Y: array
:return: Gaussian kernel matrix of shape (n_samplesX, n_samplesX) if \
Y=None else (n_samplesX, n_samplesY)
:rtype: array
"""
if self.sigma == 'auto':
# Do a quick and dirty initial estimate of sigma
self._quick_estimate_sigma(X)
# print(type(Y))
if not self.local:
kernel = self._generate_molecular(X,Y)
else:
kernel = self._generate_atomic(X,Y)
return kernel
def _generate_molecular(self, X, Y=None):
print("OQML doesn't support global kernels")
raise SystemExit
def _generate_atomic(self, X, Y=None):
X1 = np.array([rep[0] for rep in X])
dX1 = np.array([rep[1] for rep in X])
Q1 = [rep[2] for rep in X]
if Y is None or X is Y:
K_return = get_local_symmetric_kernel(X1, Q1, self.sigma)
return K_return
else:
X2 = np.array([rep[0] for rep in Y])
dX2 = np.array([rep[1] for rep in Y])
Q2 = [rep[2] for rep in Y]
K_return = get_local_kernel(X2, X1, Q2, Q1, self.sigma)
return K_return
def fit_transform(self, X, y=None):
return self._fit_transform(X)
================================================
FILE: qml/qmlearn/models.py
================================================
# MIT License
#
# Copyright (c) 2018 Lars A. Bratholm
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
from __future__ import division, absolute_import, print_function
import numpy as np
from sklearn.base import BaseEstimator
from sklearn.metrics import mean_absolute_error
from sklearn.metrics import mean_squared_error
import scipy
import scipy.stats
try:
import tensorflow as tf
from ..aglaia.tf_utils import generate_weights
except ImportError:
tf = None
from ..utils import is_numeric_array, is_numeric, is_numeric_1d_array, is_positive_integer_1d_array
from ..utils import get_unique, is_positive_integer_or_zero, get_batch_size, is_positive_integer
from ..utils import is_positive, is_positive_or_zero
from ..utils import InputError
from .data import Data
from ..math import cho_solve
from ..math import svd_solve
class _BaseModel(BaseEstimator):
"""
Base class for all regression models
"""
_estimator_type = "regressor"
def fit(self, X):
raise NotImplementedError
def predict(self, X):
return NotImplementedError
def score(self, X, y=None):
"""
Make predictions on `X` and return a score
:param X: Data object
:type X: object
:param y: Energies
:type y: array
:return: score
:rtype: float
"""
# Make predictions
y_pred = self.predict(X)
# Get the true values
if is_numeric_1d_array(y):
pass
elif isinstance(X, Data):
try:
y = X.energies[X._indices]
except:
print("No kernel energies found in data object in module %s" % self.__class__.__name__)
raise SystemExit
else:
print("Expected variable 'X' to be Data object. Got %s" % str(X))
raise SystemExit
# Return the score
if self.scoring == 'mae':
return mean_absolute_error(y, y_pred)
elif self.scoring == 'neg_mae':
return - mean_absolute_error(y, y_pred)
elif self.scoring == 'rmsd':
return np.sqrt(mean_squared_error(y, y_pred))
elif self.scoring == 'neg_rmsd':
return - np.sqrt(mean_squared_error(y, y_pred))
elif self.scoring == 'neg_log_mae':
return - np.log(mean_absolute_error(y, y_pred))
def _set_scoring(self, scoring):
if not scoring in ['mae', 'neg_mae', 'rmsd', 'neg_rmsd', 'neg_log_mae']:
raise InputError("Unknown scoring function")
self.scoring = scoring
class KernelRidgeRegression(_BaseModel):
"""
Standard Kernel Ridge Regression using a Cholesky solver
:param l2_reg: l2 regularization
:type l2_reg: float
:param scoring: Metric used for scoring ('mae', 'neg_mae', 'rmsd', 'neg_rmsd', 'neg_log_mae')
:type scoring: string
"""
def __init__(self, l2_reg=1e-10, scoring='neg_mae'):
self.l2_reg = l2_reg
self.scoring = scoring
self.alpha = None
def fit(self, X, y=None):
"""
Fit the Kernel Ridge Regression model using a cholesky solver
:param X: Data object or kernel
:type X: object or array
:param y: Energies
:type y: array
"""
if isinstance(X, Data):
try:
K, y = X._kernel, X.energies[X._indices]
except:
print("No kernel matrix and/or energies found in data object in module %s" % self.__class__.__name__)
raise SystemExit
elif is_numeric_array(X) and X.ndim == 2 and X.shape[0] == X.shape[1] and y is not None:
K = X
else:
print("Expected variable 'X' to be kernel matrix or Data object. Got %s" % str(X))
raise SystemExit
K[np.diag_indices_from(K)] += self.l2_reg
self.alpha = cho_solve(K, y)
def predict(self, X):
"""
Fit the Kernel Ridge Regression model using a cholesky solver
:param X: Data object
:type X: object
:param y: Energies
:type y: array
"""
# Check if model has been fit
if self.alpha is None:
print("Error: The %s model has not been trained yet" % self.__class__.__name__)
raise SystemExit
if isinstance(X, Data):
try:
K = X._kernel
except:
print("No kernel matrix found in data object in module %s" % self.__class__.__name__)
raise SystemExit
elif is_numeric_array(X) and X.ndim == 2 and X.shape[1] == self.alpha.size:
K = X
elif is_numeric_array(X) and X.ndim == 2 and X.shape[0] == self.alpha.size:
K = X.T
else:
print("Expected variable 'X' to be kernel matrix or Data object. Got %s" % str(X))
raise SystemExit
return np.dot(K, self.alpha)
class NeuralNetwork(_BaseModel):
"""
Feed forward neural network that takes molecular or atomic representations for predicting molecular properties.
:param hl1: number of hidden nodes in the 1st hidden layer
:type hl1: int
:param hl2: number of hidden nodes in the 2nd hidden layer
:type hl2: int
:param hl3: number of hidden nodes in the 3rd hidden layer
:type hl3: int
:param hl4: number of hidden nodes in the 4th hidden layer
:type hl4: int
:param batch_size: Number of samples to have in each batch during training
:type batch_size: int
:param learning_rate: Step size in optimisation algorithm
:type learning_rate: float
:param iterations: Number of iterations to do during training
:type iterations: int
:param l1_reg: L1 regularisation parameter
:type l1_reg: float
:param l2_reg: L2 regularisation parameter
:type l2_reg: float
:param scoring: What function to use for scoring. Available options are "neg_mae", "mae", "rmsd", "neg_rmsd",
"neg_log_mae"
:type scoring: string
:param size: Maximum number of atoms in a molecule to support. 'auto' will determine this automatically.
Is ignored when using molecular representations.
:type size: int
"""
def __init__(self, hl1=20, hl2=10, hl3=5, hl4=0, batch_size=200, learning_rate=0.001, iterations=500, l1_reg=0.0,
l2_reg=0.0, scoring="neg_mae", size='auto'):
# Check if tensorflow is available
self.tf_check()
self._set_hl(hl1, hl2, hl3, hl4)
self._set_batch_size(batch_size)
self._set_learning_rate(learning_rate)
self._set_iterations(iterations)
self._set_reg(l1_reg, l2_reg)
self._set_scoring(scoring)
self._set_size(size)
# Will be overwritten at fit time
self.elements = None
self._representation_type = None
self._constant_features = None
def _set_hl(self, hl1, hl2, hl3, hl4):
for hl in hl1, hl2, hl3, hl4:
if not is_positive_integer_or_zero(hl1):
print("Error: Expected the number of hidden nodes in a layer to be positive. Got %s" % str(hl))
raise SystemExit
self.hl1 = hl1
self.hl2 = hl2
self.hl3 = hl3
self.hl4 = hl4
def _set_batch_size(self, bs):
if not is_positive_integer(bs) or int(bs) == 1:
print("'batch_size' should be larger than 1.")
raise SystemExit
self.batch_size = bs
def _set_size(self, size):
if not is_positive_integer(size) and size != 'auto':
print("Variable 'size' should be a positive integer. Got %s" % str(size))
raise SystemExit
self.size = size
def _set_learning_rate(self, lr):
if not is_positive(lr):
print("Expected positive float value for variable 'learning_rate'. Got %s" % str(lr))
raise SystemExit
self.learning_rate = lr
def _set_iterations(self, it):
if not is_positive_integer(it):
print("Expected positive integer value for variable 'iterations'. Got %s" % str(it))
raise SystemExit
self.iterations = it
def _set_reg(self, l1_reg, l2_reg):
if not is_positive_or_zero(l1_reg) or not is_positive_or_zero(l2_reg):
raise InputError("Expected positive float value for regularisation variables 'l1_reg' and 'l2_reg. Got %s and %s" % (str(l1_reg), str(l2_reg)))
self.l1_reg = l1_reg
self.l2_reg = l2_reg
def fit(self, X, y=None, nuclear_charges=None):
"""
Fit the neural network. A molecular/atomic network will be fit if
molecular/atomic representations are given.
:param X: Data object or representations
:type X: Data object or array
:param y: Energies. Only used if X is representations.
:type y: numpy array of shape (n_samples,)
:param nuclear_charges: Nuclear charges. Only used if X is representations.
:type nuclear_charges: array
"""
# Obtaining the representations and the energies from the data object
if isinstance(X, Data):
if y is not None or nuclear_charges is not None:
print("Parameter 'y' and 'nuclear_charges' are expected to be 'None'",
"when 'X' is a Data object")
raise SystemExit
representations = X._representations
nuclear_charges = X.nuclear_charges[X._indices]
# 2D for tensorflow
energies = np.reshape(X.energies[X._indices], (-1,1))
self._representation_type = X._representation_type
else:
# y must be an array
if not is_numeric_1d_array(y):
print("Expected parameter 'y' to be a numeric 1d-array. Got %s" % type(y))
raise SystemExit
# 2D for tensorflow
energies = np.reshape(y, (-1,1))
representations = np.asarray(X)
# Check if the representations are molecular or atomic
if len(representations) > 0 and len(representations[0]) > 0:
item = representations[0][0]
if is_numeric(item):
self._representation_type = 'molecular'
elif is_numeric_1d_array(item):
self._representation_type = 'atomic'
else:
print("Could not recognise format of representations (parameter 'X')")
raise SystemExit
else:
print("Could not recognise format of representations (parameter 'X')")
raise SystemExit
# Check that nuclear charges are also provided if the representation is atomic
if self._representation_type == 'atomic' and nuclear_charges is None:
print("Expected parameter 'nuclear_charges' to be a numeric array.")
raise SystemExit
if self._representation_type == 'atomic':
representations, nuclear_charges = self._padding(representations, nuclear_charges)
# Get all unique elements
self.elements = get_unique(nuclear_charges)
# Remove constant features
representations = self._remove_constant_features(representations)
# Generate the model
self._generate_model(representations.shape)
# Train the model
self._train(representations, energies, nuclear_charges)
def _remove_constant_features(self, representations):
"""
Removes constant features of the representations, and stores
which features should be removed at predict time.
"""
if self._representation_type == 'atomic':
# Due to how the atomic neural network is constructed,
# this cannot be done elementwise
rep = representations.reshape(-1, representations.shape[-1])
if self._constant_features is None:
self._constant_features = np.all(rep == rep[0], axis=0)
rep = rep[:,~self._constant_features]
rep = rep.reshape(representations.shape[0:2] + (-1,))
return rep
else:
if self._constant_features is None:
self._constant_features = np.all(representations == representations[0], axis=0)
return representations[:,~self._constant_features]
def predict(self, X, nuclear_charges=None):
"""
Predict the molecular properties from a trained model.
:param X: Data object
:type X: object from class Data
:param nuclear_charges: Nuclear charges. Only used if X is representations.
:type nuclear_charges: array
:return: predicted properties
:rtype: numpy array of shape (n_samples,)
"""
if self._representation_type is None:
print("The model have not been fitted")
raise SystemExit
if isinstance(X, Data):
if self._representation_type == 'molecular' and nuclear_charges is not None:
print("Parameter 'nuclear_charges' is expected to be 'None'",
"when 'X' is a Data object")
raise SystemExit
representations, nuclear_charges = X._representations, X.nuclear_charges[X._indices]
else:
representations = X
if self._representation_type == 'atomic' and nuclear_charges is None:
print("Parameter 'nuclear_charges' is expected to be numeric array")
raise SystemExit
if self._representation_type == "atomic":
representations, nuclear_charges = self._padding(representations, nuclear_charges)
# Remove constant features
representations = self._remove_constant_features(representations)
y_pred = self._predict(representations, nuclear_charges)
return y_pred
# TODO support for different activation functions
def _generate_model(self, shape):
"""
Generate the Tensorflow graph for the molecular feed forward neural net.
:param shape: Shape of representations
:type shape: tuple
"""
n_features = shape[-1]
self.graph = tf.Graph()
hidden_layers = []
for item in [self.hl1, self.hl2, self.hl3, self.hl4]:
if item != 0:
hidden_layers.append(int(item))
else:
break
# Initial set up of the NN
with self.graph.as_default():
with tf.name_scope("Data"):
ph_y = tf.placeholder(tf.float32, [None, 1], name="True_energies")
if self._representation_type == 'atomic':
n_atoms = shape[1]
ph_zs = tf.placeholder(dtype=tf.int32, shape=[None, n_atoms], name="Atomic-numbers")
ph_x = tf.placeholder(tf.float32, [None, n_atoms, n_features], name="Representation")
else:
ph_x = tf.placeholder(tf.float32, [None, n_features], name="Representation")
# Has to be int64 for tf.data.Dataset
batch_size_tf = tf.placeholder(dtype=tf.int64, name="Batch_size")
buffer_tf = tf.placeholder(dtype=tf.int64, name="Buffer")
if self._representation_type == 'atomic':
dataset = tf.data.Dataset.from_tensor_slices((ph_x, ph_zs, ph_y))
else:
dataset = tf.data.Dataset.from_tensor_slices((ph_x, ph_y))
dataset = dataset.shuffle(buffer_size=buffer_tf)
dataset = dataset.batch(batch_size_tf)
iterator = tf.data.Iterator.from_structure(dataset.output_types, dataset.output_shapes)
if self._representation_type == 'atomic':
tf_x, tf_zs, tf_y = iterator.get_next()
else:
tf_x, tf_y = iterator.get_next()
with tf.name_scope("Weights"):
if self._representation_type == 'atomic':
weights = {}
biases = {}
for i, element in enumerate(self.elements):
w, b = generate_weights(n_in=n_features, n_out=1, hl=hidden_layers)
weights[element] = w
biases[element] = b
else:
weights, biases = generate_weights(n_in=n_features, n_out=1, hl=hidden_layers)
with tf.name_scope("Model"):
if self._representation_type == 'atomic':
all_atomic_energies = tf.zeros_like(tf_zs, dtype=tf.float32)
for el in self.elements:
# Obtaining the indices where the current element occurs
current_element = tf.expand_dims(tf.constant(el, dtype=tf.int32), axis=0)
where_element = tf.cast(tf.where(tf.equal(tf_zs, current_element)), dtype=tf.int32)
# Extract the descriptor corresponding to the right element
current_element_in_x = tf.gather_nd(tf_x, where_element)
# Calculate the atomic energy of all the atoms of type equal to the current element
atomic_ene = self._atomic_nn(current_element_in_x, hidden_layers, weights[el],
biases[el])
# Put the atomic energies in a zero array with shape equal to zs and then add it to all the atomic energies
updates = tf.scatter_nd(where_element, atomic_ene, tf.shape(tf_zs))
all_atomic_energies = tf.add(all_atomic_energies, updates)
# Summing the energies of all the atoms
y_pred = tf.reduce_sum(all_atomic_energies, axis=-1, name="Predicted_energies", keepdims=True)
else:
if len(hidden_layers) > 0:
z = tf.add(tf.matmul(tf_x, tf.transpose(weights[0])), biases[0])
h = tf.sigmoid(z)
# Calculate the activation of the remaining hidden layers
for i in range(1, len(weights) - 1):
z = tf.add(tf.matmul(h, tf.transpose(weights[i])), biases[i])
h = tf.sigmoid(z)
# Calculating the output of the last layer
y_pred = tf.add(tf.matmul(h, tf.transpose(weights[-1])), biases[-1], name="Predicted_energies")
with tf.name_scope("Cost_func"):
cost = self._cost(y_pred, tf_y, weights)
with tf.name_scope("Optimiser"):
optimisation_op = tf.train.AdamOptimizer(learning_rate=self.learning_rate).minimize(cost)
iter_init_op = iterator.make_initializer(dataset, name="dataset_init")
def _atomic_nn(self, x, hidden_layer_sizes, weights, biases):
"""
Constructs the atomic part of the network. It calculates the atomic property for all atoms and then sums them
together to obtain the molecular property.
:param x: Atomic representation
:type x: tf tensor of shape (n_samples, n_atoms, n_features)
:param weights: Weights used in the network for a particular element.
:type weights: list of tf.Variables of length hidden_layer_sizes.size + 1
:param biases: Biases used in the network for a particular element.
:type biases: list of tf.Variables of length hidden_layer_sizes.size + 1
:return: Output
:rtype: tf.Variable of size (n_samples, n_atoms)
"""
# Calculate the activation of the first hidden layer
z = tf.add(tf.tensordot(x, tf.transpose(weights[0]), axes=1), biases[0])
h = tf.sigmoid(z)
# Calculate the activation of the remaining hidden layers
for i in range(len(hidden_layer_sizes) - 1):
z = tf.add(tf.tensordot(h, tf.transpose(weights[i + 1]), axes=1), biases[i + 1])
h = tf.sigmoid(z)
# Calculating the output of the last layer
z = tf.add(tf.tensordot(h, tf.transpose(weights[-1]), axes=1), biases[-1])
z_squeezed = tf.squeeze(z, axis=[-1])
return z_squeezed
def _train(self, representations, energies, nuclear_charges):
"""
Train the neural network.
:param representations: the representations of the molecules (either atomic or molecular)
:type representations: numpy array of shape (n_samples, max_n_atoms, n_features) or (n_samples, n_features)
:param energies: the true molecular properties to be learnt
:type energies: numpy array of shape (n_samples, )
:param nuclear_charges: the nuclear charges of all the atoms in the molecules
:type nuclear_charges: numpy array of shape (n_samples, max_n_atoms)
:param representation_type: flag setting whether the representation is "atomic" or "molecular".
:type representation_type: string
"""
batch_size = get_batch_size(self.batch_size, representations.shape[0])
with self.graph.as_default():
tf_x = self.graph.get_tensor_by_name("Data/Representation:0")
tf_y = self.graph.get_tensor_by_name("Data/True_energies:0")
if self._representation_type == "atomic":
tf_zs = self.graph.get_tensor_by_name("Data/Atomic-numbers:0")
batch_size_tf = self.graph.get_tensor_by_name("Data/Batch_size:0")
buffer_tf = self.graph.get_tensor_by_name("Data/Buffer:0")
optimisation_op = self.graph.get_operation_by_name("Optimiser/Adam")
iter_init_op = self.graph.get_operation_by_name("dataset_init")
self.session = tf.Session(graph=self.graph)
self.session.run(tf.global_variables_initializer())
for i in range(self.iterations):
# Alternate buffer size to improve global shuffling (Not sure that this is needed)
if i % 2 == 0:
buff = int(3.5 * batch_size)
else:
buff = int(4.5 * batch_size)
if self._representation_type == "atomic":
self.session.run(iter_init_op, feed_dict={tf_x: representations, tf_y: energies, tf_zs: nuclear_charges, buffer_tf: buff,
batch_size_tf: batch_size})
else:
self.session.run(iter_init_op, feed_dict={tf_x: representations, tf_y: energies, buffer_tf: buff,
batch_size_tf:batch_size})
# Iterate to the end of the given data
while True:
try:
self.session.run(optimisation_op)
except tf.errors.OutOfRangeError:
break
def _cost(self, y_pred, y, weights):
"""
Constructs the cost function
:param y_pred: Predicted molecular properties
:type y_pred: tf.Variable of size (n_samples, 1)
:param y: True molecular properties
:type y: tf.placeholder of shape (n_samples, 1)
:param weights: Weights used in the network.
:type weights: list of tf.Variables of length hidden_layer_sizes.size + 1
:return: Cost
:rtype: tf.Variable of size (1,)
"""
err = tf.square(tf.subtract(y, y_pred))
loss = tf.reduce_mean(err, name="loss")
if self._representation_type == 'atomic':
cost = loss
if self.l2_reg > 0:
l2_loss = 0
for element in weights:
l2_loss += self._l2_loss(weights[element])
cost += l2_loss
if self.l1_reg > 0:
l1_loss = 0
for element in weights:
l1_loss += self._l1_loss(weights[element])
cost += l1_loss
else:
cost = loss
if self.l2_reg > 0:
l2_loss = self._l2_loss(weights)
cost += l2_loss
if self.l1_reg > 0:
l1_loss = self._l1_loss(weights)
cost += l1_loss
return cost
def _l2_loss(self, weights):
"""
Creates the expression for L2-regularisation on the weights
:param weights: tensorflow tensors representing the weights
:type weights: list of tf tensors
:return: tensorflow scalar representing the regularisation contribution to the cost function
:rtype: tf.float32
"""
reg_term = tf.zeros([], name="l2_loss")
for i in range(len(weights)):
reg_term += tf.reduce_sum(tf.square(weights[i]))
return self.l2_reg * reg_term
def _l1_loss(self, weights):
"""
Creates the expression for L1-regularisation on the weights
:param weights: tensorflow tensors representing the weights
:type weights: list of tf tensors
:return: tensorflow scalar representing the regularisation contribution to the cost function
:rtype: tf.float32
"""
reg_term = tf.zeros([], name="l1_loss")
for i in range(len(weights)):
reg_term += tf.reduce_sum(tf.abs(weights[i]))
return self.l1_reg * reg_term
def _predict(self, representations, nuclear_charges=None):
"""
Predicts the molecular properties from the representations.
:param representations: representations of the molecules, can be atomic or molecular
:type representations: numpy array of shape (n_samples, n_max_atoms, n_features) or (n_samples, n_features)
:param nuclear_charges: nuclear charges of the molecules. Only required for atomic representations.
:type nuclear_charges: numpy array of shape (n_samples, n_max_atoms)
:return: molecular properties predictions
:rtype: numpy array of shape (n_samples,)
"""
batch_size = get_batch_size(self.batch_size, representations.shape[0])
with self.graph.as_default():
tf_x = self.graph.get_tensor_by_name("Data/Representation:0")
tf_y = self.graph.get_tensor_by_name("Data/True_energies:0")
if self._representation_type == "atomic":
tf_zs = self.graph.get_tensor_by_name("Data/Atomic-numbers:0")
batch_size_tf = self.graph.get_tensor_by_name("Data/Batch_size:0")
buffer_tf = self.graph.get_tensor_by_name("Data/Buffer:0")
iter_init_op = self.graph.get_operation_by_name("dataset_init")
y_pred = self.graph.get_tensor_by_name("Model/Predicted_energies:0")
if self._representation_type == "atomic":
self.session.run(iter_init_op, feed_dict={tf_x: representations, tf_y: np.empty((representations.shape[0], 1)),
tf_zs: nuclear_charges, buffer_tf: 1, batch_size_tf: batch_size})
else:
self.session.run(iter_init_op,
feed_dict={tf_x: representations, tf_y: np.empty((representations.shape[0], 1)),
batch_size_tf: batch_size, buffer_tf:1})
tot_y_pred = []
# Predict until reaching the end of the iterator
while True:
try:
ene_predictions = self.session.run(y_pred)
tot_y_pred.append(ene_predictions)
except tf.errors.OutOfRangeError:
break
return np.concatenate(tot_y_pred, axis=0).ravel()
def _padding(self, representation, nuclear_charges):
"""
This function takes atomic representations for molecules of different sizes and pads them with 0 so that they
all have the same size.
:param representation: list of numby arrays of shape (n_atoms, n_features)
:param nuclear_charges: list of numpy arrays of shape (n_atoms,)
:return: numpy array of shape (n_samples, max_n_atoms, n_features) and (n_samples, max_n_atoms)
"""
max_n_atoms = 0
for i in range(len(representation)):
n_atoms = representation[i].shape[0]
if n_atoms > max_n_atoms:
max_n_atoms = n_atoms
if self.size == 'auto':
self.size = max_n_atoms
elif max_n_atoms > self.size:
print("Trying to predict on larger molecules than given by the 'size' parameter at initialization")
raise SystemExit
padded_rep = np.zeros((len(representation), self.size, representation[0].shape[1]))
padded_zs = np.zeros((len(representation), self.size))
for i in range(len(representation)):
n_atoms = representation[i].shape[0]
padded_rep[i, :n_atoms] = representation[i]
padded_zs[i, :n_atoms] = nuclear_charges[i]
return padded_rep, padded_zs
def tf_check(self):
if tf is None:
print("Tensorflow not found but is needed for %s" % self.__class__.__name__)
raise SystemExit
class OQMLRegression(_BaseModel):
"""
Standard Kernel Ridge Regression using a Cholesky solver
:param l2_reg: l2 regularization
:type l2_reg: float
:param scoring: Metric used for scoring ('mae', 'neg_mae', 'rmsd', 'neg_rmsd', 'neg_log_mae')
:type scoring: string
"""
def __init__(self, l2_reg=1e-10, scoring='neg_mae'):
self.l2_reg = l2_reg
self.scoring = scoring
self.alpha = None
def fit(self, X, y=None):
"""
Fit the Kernel Ridge Regression model using a cholesky solver
:param X: Data object or kernel
:type X: object or array
:param y: Energies
:type y: array
"""
if isinstance(X, Data):
try:
K, E, F = X._kernel, X.energies[X._indices], np.concatenate(X.forces[X._indices])
y = np.concatenate((E, F.flatten()))
except:
print("33No kernel matrix and/or energies found in data object in module %s" % self.__class__.__name__)
raise SystemExit
elif is_numeric_array(X) and X.ndim == 2 and X.shape[0] == X.shape[1] and y is not None:
K = X
else:
print("Expected variable 'X' to be kernel matrix or Data object. Got %s" % str(X))
raise SystemExit
self.alpha = svd_solve(K, y, rcond=self.l2_reg)
def score(self, X, y=None):
"""
Make predictions on `X` and return a score
:param X: Data object
:type X: object
:param y: Energies
:type y: array
:return: score
:rtype: float
"""
# Make predictions
y_pred = self.predict(X)
# Get the true values
if is_numeric_1d_array(y):
pass
elif isinstance(X, Data):
try:
e = X.energies[X._indices]
f = np.concatenate(X.forces[X._indices])
y = np.concatenate((e, f.flatten()))
except:
print("No kernel energies found in data object in module %s" % self.__class__.__name__)
raise SystemExit
else:
print("Expected variable 'X' to be Data object. Got %s" % str(X))
raise SystemExit
nE = len(X.energies[X._indices])
E = y[:nE]
F = y[nE:]
eYt = y_pred[:nE]
fYt = y_pred[nE:]
natoms = X.natoms[X._indices]
total_score = 0.0
for i, idx in enumerate(X._indices):
dE = 0.01 * np.square(E[i] - eYt[i])
n_start = np.sum(natoms[:i])*3 + len(E)
n_end = n_start + 3 * natoms[i]
dF = np.sum(np.square(y[n_start:n_end] - y_pred[n_start:n_end])) / natoms[i]
# print("%5i %5i %8.2f %8.2f %8.2f %8.2f %6i %6i" % (i, natoms[i], E[i], eYt[i], dE, dF, n_start, n_end))
total_score += dE + dF
total_score *= -1
slope, intercept, r_value, p_value, std_err = scipy.stats.linregress(E, eYt)
print("QMLEARN ENERGY MAE = %10.4f slope = %10.4f intercept = %10.4f r^2 = %9.6f" % \
(np.mean(np.abs(E - eYt)), slope, intercept, r_value ))
slope, intercept, r_value, p_value, std_err = scipy.stats.linregress(F.flatten(), fYt.flatten())
print("QMLEARN FORCE MAE = %10.4f slope = %10.4f intercept = %10.4f r^2 = %9.6f" % \
(np.mean(np.abs(F.flatten() - fYt.flatten())), slope, intercept, r_value ))
print("QMLEARN SCORE %10.2f" % total_score)
return total_score
# # Return the score
# if self.scoring == 'mae':
# return mean_absolute_error(y, y_pred)
# elif self.scoring == 'neg_mae':
# return - mean_absolute_error(y, y_pred)
# elif self.scoring == 'rmsd':
# return np.sqrt(mean_squared_error(y, y_pred))
# elif self.scoring == 'neg_rmsd':
# return - np.sqrt(mean_squared_error(y, y_pred))
# elif self.scoring == 'neg_log_mae':
# return - np.log(mean_absolute_error(y, y_pred))
def predict(self, X):
"""
Fit the Kernel Ridge Regression model using a cholesky solver
:param X: Data object
:type X: object
:param y: Energies
:type y: array
"""
# Check if model has been fit
if self.alpha is None:
print("Error: The %s model has not been trained yet" % self.__class__.__name__)
raise SystemExit
if isinstance(X, Data):
try:
K = X._kernel
except:
print("44No kernel matrix found in data object in module %s" % self.__class__.__name__)
raise SystemExit
elif is_numeric_array(X) and X.ndim == 2 and X.shape[1] == self.alpha.size:
K = X
elif is_numeric_array(X) and X.ndim == 2 and X.shape[0] == self.alpha.size:
K = X.T
else:
print("Expected variable 'X' to be kernel matrix or Data object. Got %s" % str(X))
raise SystemExit
return np.dot(K, self.alpha)
class GPRRegression(_BaseModel):
"""
Standard Kernel Ridge Regression using a Cholesky solver
:param l2_reg: l2 regularization
:type l2_reg: float
:param scoring: Metric used for scoring ('mae', 'neg_mae', 'rmsd', 'neg_rmsd', 'neg_log_mae')
:type scoring: string
"""
def __init__(self, l2_reg=1e-10, scoring='neg_mae'):
self.l2_reg = l2_reg
self.scoring = scoring
self.alpha = None
def fit(self, X, y=None):
"""
Fit the Kernel Ridge Regression model using a cholesky solver
:param X: Data object or kernel
:type X: object or array
:param y: Energies
:type y: array
"""
if isinstance(X, Data):
try:
# print(X._kernel)
# print(X.energies[X._indices])
# print(X.forces[X._indices])
# print(X._kernel)
K, E, F = X._kernel, X.energies[X._indices], np.concatenate(X.forces[X._indices])
# print(F.flatten())
y = np.concatenate((E, F.flatten()))
# print(y.shape)
# print(K.shape)
except:
print("33No kernel matrix and/or energies found in data object in module %s" % self.__class__.__name__)
raise SystemExit
elif is_numeric_array(X) and X.ndim == 2 and X.shape[0] == X.shape[1] and y is not None:
K = X
else:
print("Expected variable 'X' to be kernel matrix or Data object. Got %s" % str(X))
raise SystemExit
K[np.diag_indices_from(K)] += self.l2_reg
self.alpha = cho_solve(K, y)
def score(self, X, y=None):
"""
Make predictions on `X` and return a score
:param X: Data object
:type X: object
:param y: Energies
:type y: array
:return: score
:rtype: float
"""
# Make predictions
y_pred = self.predict(X)
# Get the true values
if is_numeric_1d_array(y):
pass
elif isinstance(X, Data):
try:
e = X.energies[X._indices]
f = np.concatenate(X.forces[X._indices])
y = np.concatenate((e, f.flatten()))
except:
print("No kernel energies found in data object in module %s" % self.__class__.__name__)
raise SystemExit
else:
print("Expected variable 'X' to be Data object. Got %s" % str(X))
raise SystemExit
nE = len(X.energies[X._indices])
E = y[:nE]
F = y[nE:]
eYt = y_pred[:nE]
fYt = y_pred[nE:]
natoms = X.natoms[X._indices]
# print(y.shape)
total_score = 0.0
for i, idx in enumerate(X._indices):
dE = 0.01 * np.square(E[i] - eYt[i])
n_start = np.sum(natoms[:i])*3 + len(E)
n_end = n_start + 3 * natoms[i]
dF = np.sum(np.square(y[n_start:n_end] - y_pred[n_start:n_end])) / natoms[i]
total_score += dE + dF
total_score *= -1
return total_score
def predict(self, X):
"""
Fit the Kernel Ridge Regression model using a cholesky solver
:param X: Data object
:type X: object
:param y: Energies
:type y: array
"""
# Check if model has been fit
if self.alpha is None:
print("Error: The %s model has not been trained yet" % self.__class__.__name__)
raise SystemExit
if isinstance(X, Data):
try:
K = X._kernel
except:
print("44No kernel matrix found in data object in module %s" % self.__class__.__name__)
raise SystemExit
elif is_numeric_array(X) and X.ndim == 2 and X.shape[1] == self.alpha.size:
K = X
elif is_numeric_array(X) and X.ndim == 2 and X.shape[0] == self.alpha.size:
K = X.T
else:
print("Expected variable 'X' to be kernel matrix or Data object. Got %s" % str(X))
raise SystemExit
return np.dot(K, self.alpha)
================================================
FILE: qml/qmlearn/preprocessing.py
================================================
# MIT License
#
# Copyright (c) 2018 Lars Andersen Bratholm
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
from __future__ import print_function
import copy
import numpy as np
from sklearn.base import BaseEstimator
from sklearn.linear_model import Lasso
from .data import Data
from ..utils import is_numeric_array, get_unique, is_positive_integer_or_zero_array
class AtomScaler(BaseEstimator):
"""
Subtracts any constant offset or linear dependency on the number of atoms of each element from the property
"""
def __init__(self, data=None, elements='auto'):
"""
:param data: Data object (optional)
:type data: Data object
:param elements: Elements to support. If `elements='auto'` try to determine this automatically.
:type elements: array
:param normalize: Normalize the transformed data such that the standard deviation is 1
:type normalize: bool
"""
# Shallow copy should be fine
self._set_data(data)
self.elements = elements
# Initialize model
self.model = Lasso(alpha=1e-9)
def _preprocess_input(self, X):
"""
Convenience function that processes X in a way such that
X can both be a data object, or an array of indices. And y
can be either values to transform or None.
:param X: Data object, floating values or integer array of indices
:type X: Data object or array
:param y: Values or None
:type y: array or None
:return: Nuclear charges and values to transform
:rtype: tuple
"""
if isinstance(X, Data):
self._check_data(X)
data = copy.copy(X)
# Part of the sklearn CV hack.
if not hasattr(data, '_indices'):
data._indices = np.arange(len(data))
if hasattr(data, '_has_transformed_labels'):
print("Error: Target data has already been transformed by %s" % self.__class__.__name__)
raise SystemExit
transformed_labels = np.zeros(len(data), dtype=bool)
transformed_labels[data._indices] = True
data._has_transformed_labels = transformed_labels
elif self.data is not None and is_positive_integer_or_zero_array(X) \
and max(X) <= self.data.natoms.size:
# A copy here might avoid some unintended behaviour
# if multiple models is used sequentially.
data = copy.copy(self.data)
data._indices = np.asarray(X, dtype=int).ravel()
if hasattr(data, '_has_transformed_labels'):
if any(data._has_transformed_labels[data._indices] == True):
print("Error: Target data has already been transformed by %s" % self.__class__.__name__)
raise SystemExit
data._has_transformed_labels[data._indices] = True
else:
transformed_labels = np.zeros(len(data.energies), dtype=bool)
transformed_labels[data._indices] = True
data._has_transformed_labels = transformed_labels
else:
print("Expected X to be array of indices or Data object. Got %s" % str(X))
raise SystemExit
return data
def _check_data(self, X):
if X.natoms is None:
print("Error: Empty Data object passed to the %s transformer" % self.__class__.__name__)
raise SystemExit
if X.energies is None:
print("Error: Expected Data object to have non-empty attribute 'energies'" % self.__class__.__name__)
raise SystemExit
def _set_data(self, data):
if data:
self._check_data(data)
self.data = data
def _parse_input(self, X, y):
if not isinstance(X, Data) and y is not None:
data = None
nuclear_charges = X
else:
data = self._preprocess_input(X)
nuclear_charges = data.nuclear_charges[data._indices]
y = data.energies[data._indices]
return data, nuclear_charges, y
def fit(self, X, y=None):
"""
Fit the data with a linear model.
Supports three different types of input.
1) X is a list of nuclear charges and y is values to transform.
2) X is an array of indices of which to transform.
3) X is a data object
:param X: List with nuclear charges or Data object.
:type X: list
:param y: Values to transform
:type y: array or None
"""
self._fit(X, y)
return self
def _fit(self, X, y=None):
"""
Does the work of the fit method, but returns variables
that the fit_transform method can reuse.
"""
data, nuclear_charges, y = self._parse_input(X, y)
if self.elements == 'auto':
self.elements = get_unique(nuclear_charges)
else:
self._check_elements(nuclear_charges)
features = self._featurizer(nuclear_charges)
self.model.fit(features, y)
return data, features, y
def fit_transform(self, X, y=None):
"""
Fit and transform the data with a linear model.
Supports three different types of input.
1) X is a list of nuclear charges and y is values to transform.
2) X is an array of indices of which to transform.
3) X is a data object
:param X: List with nuclear charges or Data object.
:type X: list
:param y: Values to transform
:type y: array or None
:return: Array of transformed values or Data object, depending on input
:rtype: array or Data object
"""
data, features, y = self._fit(X, y)
return self._transform(data, features, y)
def _transform(self, data, features, y):
"""
Does the work of the transform method, but can be reused by
the fit_transform method.
"""
delta_y = y - self.model.predict(features)
if data:
# Force copy
data.energies = data.energies.copy()
data.energies[data._indices] = delta_y
return data
else:
return delta_y
def _revert_transform(self, data, features, y):
"""
Reverts the work of the transform method.
"""
full_y = y + self.model.predict(features)
if data:
# Force copy
data.energies = data.energies.copy()
data.energies[data._indices] = full_y
return data
else:
return full_y
def _check_elements(self, nuclear_charges):
"""
Check that the elements in the given nuclear_charges was
included in the fit.
"""
elements_transform = get_unique(nuclear_charges)
if not np.isin(elements_transform, self.elements).all():
print("Warning: Trying to transform molecules with elements",
"not included during fit in the %s method." % self.__class__.__name__,
"%s used in training but trying to transform %s" % (str(self.elements), str(elements_transform)))
def _featurizer(self, X):
"""
Get the counts of each element as features.
"""
n = len(X)
m = len(self.elements)
element_to_index = {v:i for i, v in enumerate(self.elements)}
features = np.zeros((n,m), dtype=int)
for i, x in enumerate(X):
count_dict = {k:v for k,v in zip(*np.unique(x, return_counts=True))}
for key, value in count_dict.items():
if key not in element_to_index:
continue
j = element_to_index[key]
features[i, j] = value
return features
def transform(self, X, y=None):
"""
Transform the data with the fitted linear model.
Supports three different types of input.
1) X is a list of nuclear charges and y is values to transform.
2) X is an array of indices of which to transform.
3) X is a data object
:param X: List with nuclear charges or Data object.
:type X: list
:param y: Values to transform
:type y: array or None
:return: Array of transformed values or Data object, depending on input
:rtype: array or Data object
"""
data, nuclear_charges, y = self._parse_input(X, y)
self._check_elements(nuclear_charges)
features = self._featurizer(nuclear_charges)
return self._transform(data, features, y)
def revert_transform(self, X, y=None):
"""
Transforms data back to what it originally would have been if it hadn't been transformed with the fitted linear
model. Supports three different types of input.
1) X is a list of nuclear charges and y is values to transform.
2) X is an array of indices of which to transform.
3) X is a data object
:param X: List with nuclear charges or Data object.
:type X: list
:param y: Values to revert to before transform
:type y: array or None
:return: Array of untransformed values or Data object, depending on input
:rtype: array or Data object
"""
data, nuclear_charges, y = self._parse_input(X, y)
self._check_elements(nuclear_charges)
features = self._featurizer(nuclear_charges)
return self._revert_transform(data, features, y)
================================================
FILE: qml/qmlearn/representations.py
================================================
# MIT License
#
# Copyright (c) 2018 Lars Andersen Bratholm
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
from __future__ import print_function
import copy
import itertools
import numpy as np
from sklearn.base import BaseEstimator
from .data import Data
from ..utils import is_positive_integer_or_zero_array, get_unique, get_pairs, is_string
from ..representations.frepresentations import fgenerate_coulomb_matrix
from ..representations.frepresentations import fgenerate_unsorted_coulomb_matrix
from ..representations.frepresentations import fgenerate_local_coulomb_matrix
from ..representations.frepresentations import fgenerate_atomic_coulomb_matrix
from ..representations.representations import get_slatm_mbtypes
from ..representations.representations import generate_slatm
from ..representations.facsf import fgenerate_acsf
from ..representations import generate_fchl_acsf
from ..fchl.fchl_representations import generate_representation
class _BaseRepresentation(BaseEstimator):
"""
Base class for representations
"""
# Variables that has to be set in child methods
_representation_short_name = None
_representation_type = None
alchemy = None
def fit(self, X, y=None):
"""
The fit routine is needed for scikit-learn pipelines.
Must return self.
"""
raise NotImplementedError
def transform(self, X):
"""
The transform routine is needed for scikit-learn pipelines.
Needs to store the representations in self.data.representations
and return self.data.
"""
raise NotImplementedError
def _extract_data(self, X):
"""
Convenience function that processes X in a way such that
X can both be a data object or an array of indices.
:param X: Data object or array of indices
:type X: Data object or array
:return: Data object
:rtype: Data object
"""
if isinstance(X, Data):
self._check_data(X)
data = copy.copy(X)
if not hasattr(data, "_indices"):
data._indices = np.arange(len(data))
elif is_positive_integer_or_zero_array(X) \
and max(X) <= self.data.natoms.size:
# A copy here might avoid some unintended behaviour
# if multiple models is used sequentially.
data = copy.copy(self.data)
data._indices = np.asarray(X, dtype=int).ravel()
else:
print("Expected X to be array of indices or Data object. Got %s" % str(X))
raise SystemExit
# Store representation type / name for later use
data._representation_type = self._representation_type
data._representation_short_name = self._representation_short_name
data._representation_alchemy = self.alchemy
return data
def _check_data(self, X):
if X.natoms is None:
print("Error: Empty Data object passed to %s" % self.__class__.__name__)
raise SystemExit
def _set_data(self, data):
if data:
self._check_data(data)
self.data = data
def _check_elements(self, nuclear_charges):
"""
Check that the elements in the given nuclear_charges was
included in the fit.
"""
elements_transform = get_unique(nuclear_charges)
if not np.isin(elements_transform, self.elements).all():
print("Warning: Trying to transform molecules with elements",
"not included during fit in the %s method." % self.__class__.__name__,
"%s used in training but trying to transform %s" % (str(self.elements), str(element_transform)))
# TODO Make it possible to pass data in other ways as well
# e.g. dictionary
def generate(self, X):
"""
:param X: Data object or indices to use from the \
Data object passed at initialization
:type X: Data object or array of indices
:return: Representations of shape (n_samples, representation_size)
:rtype: array
"""
return self.fit(X).transform(X)._representations
class _MolecularRepresentation(_BaseRepresentation):
"""
Base class for molecular representations
"""
_representation_type = "molecular"
class _AtomicRepresentation(_BaseRepresentation):
"""
Base class for molecular representations
"""
_representation_type = "atomic"
alchemy = None
class CoulombMatrix(_MolecularRepresentation):
"""
Coulomb Matrix representation as described in 10.1103/PhysRevLett.108.058301
Sorting of the elements can either be done by ``sorting="row-norm"`` or ``sorting="unsorted"``.
A matrix :math:`M` is constructed with elements
.. math::
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},
where :math:`i` and :math:`j` are atom indices, :math:`Z` is nuclear charge and
:math:`\\bf R` is the coordinate in euclidean space.
If ``sorting = 'row-norm'``, the atom indices are reordered such that
:math:`\\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.
:param size: The size of the largest molecule supported by the representation.
`size='auto'` will try to determine this automatically.
:type size: integer
:param sorting: How the atom indices are sorted ('row-norm', 'unsorted')
:type sorting: string
:param data: Optional Data object containing all molecules used in training \
and/or prediction
:type data: Data object
"""
_representation_short_name = "cm"
def __init__(self, data=None, size='auto', sorting="row-norm"):
self.size = size
self.sorting = sorting
self._set_data(data)
def fit(self, X, y=None):
"""
:param X: Data object or indices to use from the \
Data object passed at initialization
:type X: Data object or array of indices
:param y: Dummy argument for scikit-learn
:type y: NoneType
:return: self
:rtype: object
"""
data = self._extract_data(X)
natoms = data.natoms#[data._indices]
if self.size == 'auto':
self.size = max(natoms)
if self.size < max(natoms):
print("Warning: Maximum size of system increased from %d to %d"
% (self.size, max(natoms)))
self.size = max(natoms)
return self
def transform(self, X):
"""
:param X: Data object or indices to use from the \
Data object passed at initialization
:type X: Data object or array of indices
:return: Data object
:rtype: Data object
"""
data = self._extract_data(X)
nuclear_charges = data.nuclear_charges[data._indices]
coordinates = data.coordinates[data._indices]
natoms = data.natoms[data._indices]
if max(natoms) > self.size:
print("Error: Representation can't be generated for molecule of size \
%d when variable 'size' is %d" % (max(natoms), self.size))
raise SystemExit
representations = []
if (self.sorting == "row-norm"):
for charge, xyz in zip(nuclear_charges, coordinates):
representations.append(
fgenerate_coulomb_matrix(charge, xyz, self.size))
elif (self.sorting == "unsorted"):
for charge, xyz in zip(nuclear_charges, coordinates):
representations.append(
fgenerate_unsorted_coulomb_matrix(charge, xyz, self.size))
else:
print("ERROR: Unknown sorting scheme requested")
raise SystemExit
data._representations = np.asarray(representations)
return data
# TODO add reference
# TODO add support for atomic properties
# The representation can be calculated for a subset by either specifying
# ``indices = [0,1,...]``, where :math:`[0,1,...]` are the requested atom indices,
# or by specifying ``indices = 'C'`` to only calculate central carbon atoms.
class AtomicCoulombMatrix(_AtomicRepresentation):
"""
Atomic Coulomb Matrix representation as described in
"""
_representation_short_name = "acm"
alchemy = True
def __init__(self, data=None, size=23, sorting="distance", central_cutoff=10.0,
central_decay=-1, interaction_cutoff=10.0, interaction_decay=-1):
"""
Creates a Coulomb Matrix representation of the local environment of a central atom.
For each central atom :math:`k`, a matrix :math:`M` is constructed with elements
.. math::
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},
where :math:`i`, :math:`j` and :math:`k` are atom indices, :math:`Z` is nuclear charge and
:math:`\\bf R` is the coordinate in euclidean space.
:math:`f_{ij}` is a function that masks long range effects:
.. math::
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},
where the parameters ``central_cutoff`` and ``central_decay`` corresponds to the variables
:math:`r` and :math:`\Delta r` respectively for interactions involving the central atom,
and ``interaction_cutoff`` and ``interaction_decay`` corresponds to the variables
:math:`r` and :math:`\Delta r` respectively for interactions not involving the central atom.
if ``sorting = 'row-norm'``, the atom indices are ordered such that
:math:`\\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
.. math::
\\|{\\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 is calculated using an OpenMP parallel Fortran routine.
:param data: Optional Data object containing all molecules used in training \
and/or prediction
:type data: Data object
:param size: The maximum number of atoms within the cutoff radius supported by the representation.
`size='auto'` will try to determine this automatically.
:type size: integer
:param sorting: How the atom indices are sorted ('row-norm', 'distance')
:type sorting: string
:param central_cutoff: The distance from the central atom, where the coulomb interaction
element will be zero
:type central_cutoff: float
:param central_decay: The distance over which the the coulomb interaction decays from full to none
:type central_decay: float
:param interaction_cutoff: The distance between two non-central atom, where the coulomb interaction
element will be zero
:type interaction_cutoff: float
:param interaction_decay: The distance over which the coulomb interaction decays from full to none
:type interaction_decay: float
"""
self._set_data(data)
self.size = size
self.sorting = sorting
self.central_cutoff = central_cutoff
self.central_decay = central_decay
self.interaction_cutoff = interaction_cutoff
self.interaction_decay = interaction_decay
def fit(self, X, y=None):
"""
:param X: Data object or indices to use from the \
Data object passed at initialization
:type X: Data object or array of indices
:param y: Dummy argument for scikit-learn
:type y: NoneType
:return: self
:rtype: object
"""
data = self._extract_data(X)
natoms = data.natoms#[data._indices]
if self.size == 'auto':
self.size = min(max(natoms), 2 * self.central_cutoff**3)
return self
def transform(self, X):
"""
:param X: Data object or indices to use from the \
Data object passed at initialization
:type X: Data object or array of indices
:return: Data object
:rtype: Data object
"""
data = self._extract_data(X)
nuclear_charges = data.nuclear_charges[data._indices]
coordinates = data.coordinates[data._indices]
natoms = data.natoms[data._indices]
representations = []
if (self.sorting == "row-norm"):
for charge, xyz, n in zip(nuclear_charges, coordinates, natoms):
representations.append(fgenerate_local_coulomb_matrix(np.arange(n)+1, n, charge,
xyz, n, self.size, self.central_cutoff,
self.central_decay, self.interaction_cutoff, self.interaction_decay))
elif (self.sorting == "distance"):
for charge, xyz, n in zip(nuclear_charges, coordinates, natoms):
representations.append(fgenerate_atomic_coulomb_matrix(np.arange(1,n+1), n, charge,
xyz, n, self.size, self.central_cutoff,
self.central_decay, self.interaction_cutoff, self.interaction_decay))
else:
print("ERROR: Unknown sorting scheme requested")
raise SystemExit
data._representations = representations
return data
class _SLATM(object):
"""
Routines for global and local SLATM
"""
def _fit(self, X, y=None):
"""
:param X: Data object or indices to use from the \
Data object passed at initialization
:type X: Data object or array of indices
:param y: Dummy argument for scikit-learn
:type y: NoneType
:return: self
:rtype: object
"""
data = self._extract_data(X)
if is_string(self.elements) and self.elements == 'auto' \
and is_string(self.element_pairs) and self.element_pairs == 'auto':
nuclear_charges = data.nuclear_charges#[data._indices]
self.elements = get_unique(nuclear_charges)
self.element_pairs = get_slatm_mbtypes(nuclear_charges)
elif not is_string(self.elements) and is_string(self.element_pairs) \
and self.element_pairs == 'auto':
self.element_pairs = get_slatm_mbtypes(self.elements * 3)
elif is_string(self.elements) and self.elements == 'auto' and \
not is_string(self.element_pairs):
self.elements = get_unique(self.element_pairs)
return self
def _transform(self, X, local):
"""
:param X: Data object or indices to use from the \
Data object passed at initialization
:type X: Data object or array of indices
:param local: Use local or global version
:type local: bool
:return: Data object
:rtype: Data object
"""
data = self._extract_data(X)
nuclear_charges = data.nuclear_charges[data._indices]
coordinates = data.coordinates[data._indices]
natoms = data.natoms[data._indices]
# Check that the molecules being transformed doesn't contain elements
# not used in the fit.
self._check_elements(nuclear_charges)
representations = []
for charge, xyz in zip(nuclear_charges, coordinates):
representations.append(
np.asarray(
generate_slatm(xyz, charge, self.element_pairs, local=local,
sigmas=[self.sigma2, self.sigma3],
dgrids=[self.dgrid2, self.dgrid3], rcut=self.rcut,
alchemy=self.alchemy, rpower=self.rpower)))
data._representations = np.asarray(representations)
return data
# TODO add reference
class GlobalSLATM(_SLATM, _MolecularRepresentation):
"""
Global version of SLATM.
"""
_representation_short_name = "slatm"
def __init__(self, data=None, sigma2=0.05, sigma3=0.05, dgrid2=0.03,
dgrid3=0.03, rcut=4.8, alchemy=False, rpower=6, elements='auto',
element_pairs='auto'):
"""
Generate Spectrum of London and Axillrod-Teller-Muto potential (SLATM) representation.
:param sigma2: Width of Gaussian smearing function for 2-body part.
:type sigma2: float
:param sigma3: Width of Gaussian smearing function for 3-body part.
:type sigma3: float
:param dgrid2: The interval between two sampled internuclear distances.
:type dgrid2: float
:param dgrid3: The interval between two sampled internuclear angles.
:type dgrid3: float
:param rcut: Cut-off radius.
:type rcut: float
:param alchemy: Use the alchemy version of SLATM.
:type alchemy: bool
:param rpower: The scaling power of R in 2-body potential.
:type rpower: float
:param elements: Atomnumber of elements that the representation should support.
`elements='auto'` will try to determine this automatically.
:type elements: list
:param element_pairs: Atomnumbers of element pairs that the representation should support.
`element_pairs='auto'` will try to determine this automatically.
:type element_pairs: list
:param data: Optional Data object containing all molecules used in training \
and/or prediction
:type data: Data object
"""
self._set_data(data)
self.sigma2 = sigma2
self.sigma3 = sigma3
self.dgrid2 = dgrid2
self.dgrid3 = dgrid3
self.rcut = rcut
self.alchemy = alchemy
self.rpower = rpower
# Will be changed during fit
self.elements = elements
self.element_pairs = element_pairs
def fit(self, X, y=None):
"""
:param X: Data object or indices to use from the \
Data object passed at initialization
:type X: Data object or array of indices
:param y: Dummy argument for scikit-learn
:type y: NoneType
:return: self
:rtype: object
"""
return self._fit(X, y)
def transform(self, X):
"""
:param X: Data object or indices to use from the \
Data object passed at initialization
:type X: Data object or array of indices
:return: Data object
:rtype: Data object
"""
return self._transform(X, False)
# TODO add reference
class AtomicSLATM(_SLATM, _AtomicRepresentation):
"""
Local version of SLATM.
"""
_representation_short_name = "aslatm"
def __init__(self, data=None, sigma2=0.05, sigma3=0.05, dgrid2=0.03,
dgrid3=0.03, rcut=4.8, alchemy=False, rpower=6, elements='auto',
element_pairs='auto'):
"""
Generate Spectrum of London and Axillrod-Teller-Muto potential (SLATM) representation.
:param data: Optional Data object containing all molecules used in training \
and/or prediction
:type data: Data object
:param sigma2: Width of Gaussian smearing function for 2-body part.
:type sigma2: float
:param sigma3: Width of Gaussian smearing function for 3-body part.
:type sigma3: float
:param dgrid2: The interval between two sampled internuclear distances.
:type dgrid2: float
:param dgrid3: The interval between two sampled internuclear angles.
:type dgrid3: float
:param rcut: Cut-off radius.
:type rcut: float
:param alchemy: Use the alchemy version of SLATM.
:type alchemy: bool
:param rpower: The scaling power of R in 2-body potential.
:type rpower: float
:param elements: Atomnumber of elements that the representation should support.
`elements='auto'` will try to determine this automatically.
:type elements: list
:param element_pairs: Atomnumbers of element pairs that the representation should support.
`element_pairs='auto'` will try to determine this automatically.
:type element_pairs: list
"""
self._set_data(data)
self.sigma2 = sigma2
self.sigma3 = sigma3
self.dgrid2 = dgrid2
self.dgrid3 = dgrid3
self.rcut = rcut
self.alchemy = alchemy
self.rpower = rpower
# Will be changed during fit
self.elements = elements
self.element_pairs = element_pairs
def fit(self, X, y=None):
"""
:param X: Data object or indices to use from the \
Data object passed at initialization
:type X: Data object or array of indices
:param y: Dummy argument for scikit-learn
:type y: NoneType
:return: self
:rtype: object
"""
return self._fit(X, y)
def transform(self, X):
"""
:param X: Data object or indices to use from the \
Data object passed at initialization
:type X: Data object or array of indices
:return: Data object
:rtype: Data object
"""
return self._transform(X, True)
class AtomCenteredSymmetryFunctions(_AtomicRepresentation):
"""
The variant of Atom-Centered Symmetry Functions used in 10.1039/C7SC04934J
:param data: Optional Data object containing all molecules used in training \
and/or prediction
:type data: Data object
:param nbasis: Number of basis functions to use
:type nbasis: integer
:param cutoff: Cutoff radius
:type cutoff: float
:param precision: Precision in the basis functions. A value of 2 corresponds to the \
basis functions intersecting at half maximum. Higher values makes \
the basis functions narrower.
:type precision: float
:param elements: Atomnumber of elements that the representation should support.
`elements='auto'` will try to determine this automatically.
:type elements: list
"""
_representation_short_name = "acsf"
alchemy = False
def __init__(self, data=None, nbasis=3, precision=2, cutoff=5.0, elements='auto'):
self._set_data(data)
self.nbasis = nbasis
self.precision = precision
self.cutoff = cutoff
# Will be changed during fit
self.elements = elements
def fit(self, X, y=None):
"""
:param X: Data object or indices to use from the \
Data object passed at initialization
:type X: Data object or array of indices
:param y: Dummy argument for scikit-learn
:type y: NoneType
:return: self
:rtype: object
"""
data = self._extract_data(X)
if is_string(self.elements) and self.elements == 'auto':
nuclear_charges = data.nuclear_charges#[data._indices]
self.elements = get_unique(nuclear_charges)
return self
def transform(self, X):
"""
:param X: Data object or indices to use from the \
Data object passed at initialization
:type X: Data object or array of indices
:return: Data object
:rtype: Data object
"""
data = self._extract_data(X)
nuclear_charges = data.nuclear_charges[data._indices]
coordinates = data.coordinates[data._indices]
natoms = data.natoms[data._indices]
# Check that the molecules being transformed doesn't contain elements
# not used in the fit.
self._check_elements(nuclear_charges)
# Calculate parameters needed for fortran input.
# This is a heuristic that cuts down the number of hyper-parameters
# and might be subject to future change.
min_distance = 0.8
Rs = np.linspace(min_distance, self.cutoff, self.nbasis)
eta = 4 * np.log(self.precision) * ((self.nbasis-1)/(self.cutoff-min_distance))**2
Ts = np.linspace(0, np.pi, self.nbasis)
zeta = - np.log(self.precision) / np.log(np.cos(np.pi / (4 * (self.nbasis - 1)))**2)
n_elements = len(self.elements)
size = n_elements * self.nbasis + (n_elements * (n_elements + 1)) // 2 * self.nbasis ** 2
representations = []
for charge, xyz, n in zip(nuclear_charges, coordinates, natoms):
representations.append(np.asarray(
fgenerate_acsf(xyz, charge, self.elements, Rs, Rs, Ts,
eta, eta, zeta, self.cutoff, self.cutoff, n, size)))
# Check to make sure there are no NANs
# if np.any(np.isnan(representations)):
# print("There are NANs in the representations.")
# exit()
data._representations = np.asarray(representations)
return data
class FCHLRepresentation(_BaseRepresentation):
"""
The representation from 10.1063/1.5020710
"""
_representation_short_name = "fchl"
def __init__(self, data=None, size='auto', cutoff=10.0):
"""
:param data: Optional Data object containing all molecules used in training \
and/or prediction
:type data: Data object
:param size: Max number of atoms in representation. `max_size='auto'` Will try to determine this
automatically.
:type size: integer
:param cutoff: Spatial cut-off distance - must be the same as used in the kernel function call.
:type cutoff: float
"""
self._set_data(data)
self.size = size
self.cutoff = cutoff
def fit(self, X, y=None):
"""
:param X: Data object or indices to use from the \
Data object passed at initialization
:type X: Data object or array of indices
:param y: Dummy argument for scikit-learn
:type y: NoneType
:return: self
:rtype: object
"""
data = self._extract_data(X)
natoms = data.natoms#[data._indices]
if self.size == 'auto':
self.size = max(natoms)
if self.size < max(natoms):
print("Warning: Maximum size of system increased from %d to %d"
% (self.size, max(natoms)))
self.size = max(natoms)
return self
def transform(self, X):
"""
:param X: Data object or indices to use from the \
Data object passed at initialization
:type X: Data object or array of indices
:return: Data object
:rtype: Data object
"""
data = self._extract_data(X)
# Store cutoff to make sure that the kernel cutoff is less
data._representation_cutoff = self.cutoff
nuclear_charges = data.nuclear_charges[data._indices]
coordinates = data.coordinates[data._indices]
natoms = data.natoms[data._indices]
if max(natoms) > self.size:
print("Error: Representation can't be generated for molecule of size \
%d when variable 'size' is %d" % (max(natoms), self.size))
raise SystemExit
representations = []
for charge, xyz in zip(nuclear_charges, coordinates):
representations.append(
generate_representation(xyz, charge, max_size=self.size, cut_distance=self.cutoff))
data._representations = np.asarray(representations)
return data
class FCHL_ACSF(_AtomicRepresentation):
"""
The variant of Atom-Centered Symmetry Functions
:param data: Optional Data object containing all molecules used in training \
and/or prediction
:type data: Data object
:param elements: Atomnumber of elements that the representation should support.
`elements='auto'` will try to determine this automatically.
:type elements: list
"""
_representation_short_name = "fchl_acsf"
_representation_type = "atomic-force"
alchemy = False
def __init__(self, data=None, elements='auto',
nRs2=24, nRs3=20, nFourier=1, eta2=0.32, eta3=2.7, zeta=np.pi, rcut=8.0, acut=8.0,
two_body_decay=1.8, three_body_decay=0.57, three_body_weight=13.4):
self._set_data(data)
self.nRs2 = nRs2
self.nRs3 = nRs3
self.nFourier = nFourier
self.eta2 = eta2
self.eta3 = eta3
self.zeta = zeta
self.rcut = rcut
self.acut = acut
self.two_body_decay = two_body_decay
self.three_body_decay = three_body_decay
self.three_body_weight = three_body_weight
# self.cutoff = cutoff
# Will be changed during fit
self.elements = elements
def fit(self, X, y=None):
"""
:param X: Data object or indices to use from the \
Data object passed at initialization
:type X: Data object or array of indices
:param y: Dummy argument for scikit-learn
:type y: NoneType
:return: self
:rtype: object
"""
data = self._extract_data(X)
if is_string(self.elements) and self.elements == 'auto':
nuclear_charges = data.nuclear_charges#[data._indices]
self.elements = get_unique(nuclear_charges)
return self
def transform(self, X):
"""
:param X: Data object or indices to use from the \
Data object passed at initialization
:type X: Data object or array of indices
:return: Data object
:rtype: Data object
"""
data = self._extract_data(X)
nuclear_charges = data.nuclear_charges[data._indices]
coordinates = data.coordinates[data._indices]
natoms = data.natoms[data._indices]
max_atoms = np.amax(data.natoms)
self._check_elements(nuclear_charges)
representations = []
for charge, xyz, n in zip(nuclear_charges, coordinates, natoms):
# representations.append(np.asarray(
# fgenerate_acsf(xyz, charge, self.elements, Rs, Rs, Ts,
# eta, eta, zeta, self.cutoff, self.cutoff, n, size)))
# (rep, grad) = generate_fchl_acsf(charge, xyz , elements=self.elements,
# nRs2=self.nRs2, nRs3=self.nRs3, nFourier=self.nFourier, eta2=self.eta2,
# eta3=self.eta3, zeta=self.zeta, rcut=self.rcut, acut=self.acut,
# two_body_decay=self.two_body_decay, three_body_decay=self.three_body_decay,
# three_body_weight=self.three_body_weight,
# pad=max_atoms, gradients=True)
rep = generate_fchl_acsf(charge, xyz , elements=self.elements,
nRs2=self.nRs2, nRs3=self.nRs3, nFourier=self.nFourier, eta2=self.eta2,
eta3=self.eta3, zeta=self.zeta, rcut=self.rcut, acut=self.acut,
two_body_decay=self.two_body_decay, three_body_decay=self.three_body_decay,
three_body_weight=self.three_body_weight,
pad=max_atoms, gradients=False)
representations.append([rep, None, charge])
data._representations = representations
# Won't work with force representation
# data._representations = np.asarray(data._representations)
return data
class FCHL_ACSF_Force(_AtomicRepresentation):
"""
The variant of Atom-Centered Symmetry Functions
:param data: Optional Data object containing all molecules used in training \
and/or prediction
:type data: Data object
:param elements: Atomnumber of elements that the representation should support.
`elements='auto'` will try to determine this automatically.
:type elements: list
"""
_representation_short_name = "fchl_acsf"
_representation_type = "atomic-force"
alchemy = False
def __init__(self, data=None, elements='auto',
nRs2=24, nRs3=20, nFourier=1, eta2=0.32, eta3=2.7, zeta=np.pi, rcut=8.0, acut=8.0,
two_body_decay=1.8, three_body_decay=0.57, three_body_weight=13.4):
self._set_data(data)
self.nRs2 = nRs2
self.nRs3 = nRs3
self.nFourier = nFourier
self.eta2 = eta2
self.eta3 = eta3
self.zeta = zeta
self.rcut = rcut
self.acut = acut
self.two_body_decay = two_body_decay
self.three_body_decay = three_body_decay
self.three_body_weight = three_body_weight
# self.cutoff = cutoff
# Will be changed during fit
self.elements = elements
def fit(self, X, y=None):
"""
:param X: Data object or indices to use from the \
Data object passed at initialization
:type X: Data object or array of indices
:param y: Dummy argument for scikit-learn
:type y: NoneType
:return: self
:rtype: object
"""
data = self._extract_data(X)
if is_string(self.elements) and self.elements == 'auto':
nuclear_charges = data.nuclear_charges#[data._indices]
self.elements = get_unique(nuclear_charges)
return self
def transform(self, X):
"""
:param X: Data object or indices to use from the \
Data object passed at initialization
:type X: Data object or array of indices
:return: Data object
:rtype: Data object
"""
data = self._extract_data(X)
nuclear_charges = data.nuclear_charges[data._indices]
coordinates = data.coordinates[data._indices]
natoms = data.natoms[data._indices]
max_atoms = np.amax(data.natoms)
self._check_elements(nuclear_charges)
representations = []
for charge, xyz, n in zip(nuclear_charges, coordinates, natoms):
(rep, grad) = generate_fchl_acsf(charge, xyz , elements=self.elements,
nRs2=self.nRs2, nRs3=self.nRs3, nFourier=self.nFourier, eta2=self.eta2,
eta3=self.eta3, zeta=self.zeta, rcut=self.rcut, acut=self.acut,
two_body_decay=self.two_body_decay, three_body_decay=self.three_body_decay,
three_body_weight=self.three_body_weight,
pad=max_atoms, gradients=True)
representations.append([rep, grad, charge])
data._representations = representations
# Won't work with force representation
# data._representations = np.asarray(data._representations)
return data
================================================
FILE: qml/representations/__init__.py
================================================
# MIT License
#
# Copyright (c) 2017 Anders S. Christensen
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
from .representations import *
================================================
FILE: qml/representations/facsf.f90
================================================
! MIT License
!
! Copyright (c) 2018 Lars Andersen Bratholm
!
! Permission is hereby granted, free of charge, to any person obtaining a copy
! of this software and associated documentation files (the "Software"), to deal
! in the Software without restriction, including without limitation the rights
! to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
! copies of the Software, and to permit persons to whom the Software is
! furnished to do so, subject to the following conditions:
!
! The above copyright notice and this permission notice shall be included in all
! copies or substantial portions of the Software.
!
! THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
! IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
! FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
! AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
! LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
! OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
! SOFTWARE.
module acsf_utils
implicit none
contains
function decay(r, invrc, natoms) result(f)
implicit none
double precision, intent(in), dimension(:,:) :: r
double precision, intent(in) :: invrc
integer, intent(in) :: natoms
double precision, dimension(natoms, natoms) :: f
double precision, parameter :: pi = 4.0d0 * atan(1.0d0)
! Decaying function reaching 0 at rc
f = 0.5d0 * (cos(pi * r * invrc) + 1.0d0)
end function decay
function calc_angle(a, b, c) result(angle)
implicit none
double precision, intent(in), dimension(3) :: a
double precision, intent(in), dimension(3) :: b
double precision, intent(in), dimension(3) :: c
double precision, dimension(3) :: v1
double precision, dimension(3) :: v2
double precision :: cos_angle
double precision :: angle
v1 = a - b
v2 = c - b
v1 = v1 / norm2(v1)
v2 = v2 / norm2(v2)
cos_angle = dot_product(v1,v2)
! Clipping
if (cos_angle > 1.0d0) cos_angle = 1.0d0
if (cos_angle < -1.0d0) cos_angle = -1.0d0
angle = acos(cos_angle)
end function calc_angle
function calc_cos_angle(a, b, c) result(cos_angle)
implicit none
double precision, intent(in), dimension(3) :: a
double precision, intent(in), dimension(3) :: b
double precision, intent(in), dimension(3) :: c
double precision, dimension(3) :: v1
double precision, dimension(3) :: v2
double precision :: cos_angle
v1 = a - b
v2 = c - b
v1 = v1 / norm2(v1)
v2 = v2 / norm2(v2)
cos_angle = dot_product(v1,v2)
end function calc_cos_angle
end module acsf_utils
subroutine fgenerate_acsf(coordinates, nuclear_charges, elements, &
& Rs2, Rs3, Ts, eta2, eta3, zeta, rcut, acut, natoms, rep_size, rep)
use acsf_utils, only: decay, calc_angle
implicit none
double precision, intent(in), dimension(:, :) :: coordinates
integer, intent(in), dimension(:) :: nuclear_charges
integer, intent(in), dimension(:) :: elements
double precision, intent(in), dimension(:) :: Rs2
double precision, intent(in), dimension(:) :: Rs3
double precision, intent(in), dimension(:) :: Ts
double precision, intent(in) :: eta2
double precision, intent(in) :: eta3
double precision, intent(in) :: zeta
double precision, intent(in) :: rcut
double precision, intent(in) :: acut
integer, intent(in) :: natoms
integer, intent(in) :: rep_size
double precision, intent(out), dimension(natoms, rep_size) :: rep
integer :: i, j, k, l, n, m, p, q, s, z, nelements, nbasis2, nbasis3, nabasis
integer, allocatable, dimension(:) :: element_types
double precision :: rij, rik, angle, invcut
double precision, allocatable, dimension(:) :: radial, angular, a, b, c
double precision, allocatable, dimension(:, :) :: distance_matrix, rdecay, rep_subset
double precision, parameter :: pi = 4.0d0 * atan(1.0d0)
if (natoms /= size(nuclear_charges, dim=1)) then
write(*,*) "ERROR: Atom Centered Symmetry Functions creation"
write(*,*) natoms, "coordinates, but", &
& size(nuclear_charges, dim=1), "atom_types!"
stop
endif
! number of element types
nelements = size(elements)
! Allocate temporary
allocate(element_types(natoms))
! Store element index of every atom
!$OMP PARALLEL DO
do i = 1, natoms
do j = 1, nelements
if (nuclear_charges(i) .eq. elements(j)) then
element_types(i) = j
cycle
endif
enddo
enddo
!$OMP END PARALLEL DO
! Get distance matrix
! Allocate temporary
allocate(distance_matrix(natoms, natoms))
distance_matrix = 0.0d0
!$OMP PARALLEL DO PRIVATE(rij)
do i = 1, natoms
do j = i+1, natoms
rij = norm2(coordinates(j,:) - coordinates(i,:))
distance_matrix(i, j) = rij
distance_matrix(j, i) = rij
enddo
enddo
!$OMP END PARALLEL DO
! number of basis functions in the two body term
nbasis2 = size(Rs2)
! Inverse of the two body cutoff
invcut = 1.0d0 / rcut
! pre-calculate the radial decay in the two body terms
rdecay = decay(distance_matrix, invcut, natoms)
! Allocate temporary
allocate(radial(nbasis2))
allocate(rep_subset(natoms, nelements * nbasis2))
rep_subset = 0.0d0
!$OMP PARALLEL DO PRIVATE(n,m,rij,radial) COLLAPSE(2) REDUCTION(+:rep_subset) SCHEDULE(dynamic)
do i = 1, natoms
do j = 1, natoms
if (j .le. i) cycle
rij = distance_matrix(i,j)
if (rij <= rcut) then
! index of the element of atom i
m = element_types(i)
! index of the element of atom j
n = element_types(j)
! distance between atoms i and j
! two body term of the representation
radial = exp(-eta2*(rij - Rs2)**2) * rdecay(i,j)
rep_subset(i, (n-1)*nbasis2 + 1:n*nbasis2) = rep_subset(i, (n-1)*nbasis2 + 1:n*nbasis2) + radial
rep_subset(j, (m-1)*nbasis2 + 1:m*nbasis2) = rep_subset(j, (m-1)*nbasis2 + 1:m*nbasis2) + radial
endif
enddo
enddo
!$OMP END PARALLEL DO
rep(:, 1:nelements * nbasis2) = rep_subset(:,:)
deallocate(radial)
deallocate(rep_subset)
! number of radial basis functions in the three body term
nbasis3 = size(Rs3)
! number of radial basis functions in the three body term
nabasis = size(Ts)
! Inverse of the three body cutoff
invcut = 1.0d0 / acut
! pre-calculate the radial decay in the three body terms
rdecay = decay(distance_matrix, invcut, natoms)
! Allocate temporary
allocate(rep_subset(natoms,rep_size - nelements * nbasis2))
allocate(a(3))
allocate(b(3))
allocate(c(3))
allocate(radial(nbasis3))
allocate(angular(nabasis))
rep_subset = 0.0d0
! This could probably be done more efficiently if it's a bottleneck
! Also the order is a bit wobbly compared to the tensorflow implementation
!$OMP PARALLEL DO PRIVATE(rij, n, rik, m, a, b, c, angle, radial, angular, &
!$OMP p, q, s, z) REDUCTION(+:rep_subset) COLLAPSE(2) SCHEDULE(dynamic)
do i = 1, natoms
do j = 1, natoms - 1
if (i .eq. j) cycle
! distance between atoms i and j
rij = distance_matrix(i,j)
if (rij > acut) cycle
! index of the element of atom j
n = element_types(j)
do k = j + 1, natoms
if (i .eq. k) cycle
! distance between atoms i and k
rik = distance_matrix(i,k)
if (rik > acut) cycle
! index of the element of atom k
m = element_types(k)
! coordinates of atoms j, i, k
a = coordinates(j,:)
b = coordinates(i,:)
c = coordinates(k,:)
! angle between atoms i, j and k centered on i
angle = calc_angle(a,b,c)
! The radial part of the three body terms including decay
radial = exp(-eta3*(0.5d0 * (rij+rik) - Rs3)**2) * rdecay(i,j) * rdecay(i,k)
! The angular part of the three body terms
angular = 2.0d0 * ((1.0d0 + cos(angle - Ts)) * 0.5d0) ** zeta
! The lowest of the element indices for atoms j and k
p = min(n,m) - 1
! The highest of the element indices for atoms j and k
q = max(n,m) - 1
! calculate the indices that the three body terms should be added to
s = nbasis3 * nabasis * (-(p * (p + 1))/2 + q + nelements * p) + 1
do l = 1, nbasis3
! calculate the indices that the three body terms should be added to
z = s + (l-1) * nabasis
! Add the contributions from atoms i,j and k
rep_subset(i, z:z + nabasis - 1) = rep_subset(i, z:z + nabasis - 1) + angular * radial(l)
enddo
enddo
enddo
enddo
!$OMP END PARALLEL DO
rep(:, nelements * nbasis2 + 1:) = rep_subset(:,:)
deallocate(element_types)
deallocate(rdecay)
deallocate(distance_matrix)
deallocate(rep_subset)
deallocate(a)
deallocate(b)
deallocate(c)
deallocate(radial)
deallocate(angular)
end subroutine fgenerate_acsf
subroutine fgenerate_acsf_and_gradients(coordinates, nuclear_charges, elements, &
& Rs2, Rs3, Ts, eta2, eta3, zeta, rcut, acut, natoms, &
& rep_size, rep, grad)
use acsf_utils, only: decay, calc_angle
implicit none
double precision, intent(in), dimension(:, :) :: coordinates
integer, intent(in), dimension(:) :: nuclear_charges
integer, intent(in), dimension(:) :: elements
double precision, intent(in), dimension(:) :: Rs2
double precision, intent(in), dimension(:) :: Rs3
double precision, intent(in), dimension(:) :: Ts
double precision, intent(in) :: eta2
double precision, intent(in) :: eta3
double precision, intent(in) :: zeta
double precision, intent(in) :: rcut
double precision, intent(in) :: acut
integer, intent(in) :: natoms
integer, intent(in) :: rep_size
double precision, intent(out), dimension(natoms, rep_size) :: rep
double precision, intent(out), dimension(natoms, rep_size, natoms, 3) :: grad
integer :: i, j, k, l, n, m, p, q, s, t, z, nelements, nbasis2, nbasis3, nabasis, twobody_size
integer, allocatable, dimension(:) :: element_types
double precision :: rij, rik, angle, dot, rij2, rik2, invrij, invrik, invrij2, invrik2, invcut
double precision, allocatable, dimension(:) :: radial_base, radial, angular, a, b, c, atom_rep
double precision, allocatable, dimension(:) :: angular_base, d_radial, d_radial_d_i
double precision, allocatable, dimension(:) :: d_radial_d_j, d_radial_d_k, d_ijdecay, d_ikdecay
double precision, allocatable, dimension(:) :: d_angular, part, radial_part
double precision, allocatable, dimension(:) :: d_angular_d_i, d_angular_d_j, d_angular_d_k
double precision, allocatable, dimension(:, :) :: distance_matrix, rdecay, sq_distance_matrix
double precision, allocatable, dimension(:, :) :: inv_distance_matrix, inv_sq_distance_matrix
double precision, allocatable, dimension(:, :) :: rep_subset
double precision, allocatable, dimension(:, :, :) :: atom_grad
double precision, allocatable, dimension(:, :, :, :) :: grad_subset
double precision, parameter :: pi = 4.0d0 * atan(1.0d0)
if (natoms /= size(nuclear_charges, dim=1)) then
write(*,*) "ERROR: Atom Centered Symmetry Functions creation"
write(*,*) natoms, "coordinates, but", &
& size(nuclear_charges, dim=1), "atom_types!"
stop
endif
! Number of unique elements
nelements = size(elements)
! Allocate temporary
allocate(element_types(natoms))
! Store element index of every atom
!$OMP PARALLEL DO
do i = 1, natoms
do j = 1, nelements
if (nuclear_charges(i) .eq. elements(j)) then
element_types(i) = j
cycle
endif
enddo
enddo
!$OMP END PARALLEL DO
! Get distance matrix
! Allocate temporary
allocate(distance_matrix(natoms, natoms))
allocate(sq_distance_matrix(natoms, natoms))
allocate(inv_distance_matrix(natoms, natoms))
allocate(inv_sq_distance_matrix(natoms, natoms))
distance_matrix = 0.0d0
sq_distance_matrix = 0.0d0
inv_distance_matrix = 0.0d0
inv_sq_distance_matrix = 0.0d0
!$OMP PARALLEL DO PRIVATE(rij,rij2,invrij,invrij2) SCHEDULE(dynamic)
do i = 1, natoms
do j = 1, natoms
if (j .le. i) cycle
rij = norm2(coordinates(j,:) - coordinates(i,:))
distance_matrix(i, j) = rij
distance_matrix(j, i) = rij
rij2 = rij * rij
sq_distance_matrix(i, j) = rij2
sq_distance_matrix(j, i) = rij2
invrij = 1.0d0 / rij
inv_distance_matrix(i, j) = invrij
inv_distance_matrix(j, i) = invrij
invrij2 = invrij * invrij
inv_sq_distance_matrix(i, j) = invrij2
inv_sq_distance_matrix(j, i) = invrij2
enddo
enddo
!$OMP END PARALLEL DO
! Number of two body basis functions
nbasis2 = size(Rs2)
! Inverse of the two body cutoff distance
invcut = 1.0d0 / rcut
! Pre-calculate the two body decay
rdecay = decay(distance_matrix, invcut, natoms)
! Allocate temporary
allocate(radial_base(nbasis2))
allocate(radial(nbasis2))
allocate(radial_part(nbasis2))
allocate(part(nbasis2))
allocate(rep_subset(natoms, nelements * nbasis2))
allocate(grad_subset(natoms, nelements * nbasis2, natoms, 3))
grad_subset = 0.0d0
rep_subset = 0.0d0
!$OMP PARALLEL DO PRIVATE(m,n,rij,invrij,radial_base,radial,radial_part,part) REDUCTION(+:rep_subset,grad_subset) &
!$OMP SCHEDULE(dynamic)
do i = 1, natoms
! The element index of atom i
m = element_types(i)
do j = i + 1, natoms
! The element index of atom j
n = element_types(j)
! Distance between atoms i and j
rij = distance_matrix(i,j)
if (rij <= rcut) then
invrij = inv_distance_matrix(i,j)
! part of the two body terms
radial_base = exp(-eta2*(rij - Rs2)**2)
! The full two body term between atom i and j
radial = radial_base * rdecay(i,j)
! Add the contributions from atoms i and j
rep_subset(i, (n-1)*nbasis2 + 1:n*nbasis2) = rep_subset(i, (n-1)*nbasis2 + 1:n*nbasis2) + radial
rep_subset(j, (m-1)*nbasis2 + 1:m*nbasis2) = rep_subset(j, (m-1)*nbasis2 + 1:m*nbasis2) + radial
! Part of the gradients that can be reused for x,y and z coordinates
radial_part = - radial_base * invrij * (2.0d0 * eta2 * (rij - Rs2) * rdecay(i,j) + &
& 0.5d0 * pi * sin(pi*rij * invcut) * invcut)
do k = 1, 3
! The gradients wrt coordinates
part = radial_part * (coordinates(i,k) - coordinates(j,k))
grad_subset(i, (n-1)*nbasis2 + 1:n*nbasis2, i, k) = &
grad_subset(i, (n-1)*nbasis2 + 1:n*nbasis2, i, k) + part
grad_subset(i, (n-1)*nbasis2 + 1:n*nbasis2, j, k) = &
grad_subset(i, (n-1)*nbasis2 + 1:n*nbasis2, j, k) - part
grad_subset(j, (m-1)*nbasis2 + 1:m*nbasis2, j, k) = &
grad_subset(j, (m-1)*nbasis2 + 1:m*nbasis2, j, k) - part
grad_subset(j, (m-1)*nbasis2 + 1:m*nbasis2, i, k) = &
grad_subset(j, (m-1)*nbasis2 + 1:m*nbasis2, i, k) + part
enddo
endif
enddo
enddo
!$OMP END PARALLEL DO
rep(:,:nelements*nbasis2) = rep_subset(:,:)
grad(:,:nelements*nbasis2,:,:) = grad_subset(:,:,:,:)
deallocate(radial_base)
deallocate(radial)
deallocate(radial_part)
deallocate(part)
deallocate(rep_subset)
deallocate(grad_subset)
! Number of radial basis functions in the three body term
nbasis3 = size(Rs3)
! Number of angular basis functions in the three body term
nabasis = size(Ts)
! Size of two body terms
twobody_size = nelements * nbasis2
! Inverse of the three body cutoff distance
invcut = 1.0d0 / acut
! Pre-calculate the three body decay
rdecay = decay(distance_matrix, invcut, natoms)
! Allocate temporary
allocate(atom_rep(rep_size - twobody_size))
allocate(atom_grad(rep_size - twobody_size, natoms, 3))
allocate(a(3))
allocate(b(3))
allocate(c(3))
allocate(radial(nbasis3))
allocate(angular_base(nabasis))
allocate(angular(nabasis))
allocate(d_angular(nabasis))
allocate(d_angular_d_i(3))
allocate(d_angular_d_j(3))
allocate(d_angular_d_k(3))
allocate(d_radial(nbasis3))
allocate(d_radial_d_i(3))
allocate(d_radial_d_j(3))
allocate(d_radial_d_k(3))
allocate(d_ijdecay(3))
allocate(d_ikdecay(3))
! This could probably be done more efficiently if it's a bottleneck
! The order is a bit wobbly compared to the tensorflow implementation
!$OMP PARALLEL DO PRIVATE(atom_rep,atom_grad,a,b,c,radial,angular_base, &
!$OMP angular,d_angular,rij,n,rij2,invrij,invrij2,d_angular_d_i, &
!$OMP d_angular_d_j,d_angular_d_k,rik,m,rik2,invrik,invrik2,angle, &
!$OMP p,q,dot,d_radial,d_radial_d_i,d_radial_d_j,d_radial_d_k,s,z, &
!$OMP d_ijdecay,d_ikdecay) SCHEDULE(dynamic)
do i = 1, natoms
atom_rep = 0.0d0
atom_grad = 0.0d0
do j = 1, natoms - 1
if (i .eq. j) cycle
! distance between atom i and j
rij = distance_matrix(i,j)
if (rij > acut) cycle
! index of the element of atom j
n = element_types(j)
! squared distance between atom i and j
rij2 = sq_distance_matrix(i,j)
! inverse distance between atom i and j
invrij = inv_distance_matrix(i,j)
! inverse squared distance between atom i and j
invrij2 = inv_sq_distance_matrix(i,j)
do k = j + 1, natoms
if (i .eq. k) cycle
! distance between atom i and k
rik = distance_matrix(i,k)
if (rik > acut) cycle
! index of the element of atom k
m = element_types(k)
! squared distance between atom i and k
rik2 = sq_distance_matrix(i,k)
! inverse distance between atom i and k
invrik = inv_distance_matrix(i,k)
! inverse squared distance between atom i and k
invrik2 = inv_sq_distance_matrix(i,k)
! coordinates of atoms j, i, k
a = coordinates(j,:)
b = coordinates(i,:)
c = coordinates(k,:)
! angle between atom i, j and k, centered on i
angle = calc_angle(a,b,c)
! part of the radial part of the 3body terms
radial = exp(-eta3*(0.5d0 * (rij+rik) - Rs3)**2)
! used in the angular part of the 3body terms and in gradients
angular_base = ((1.0d0 + cos(angle - Ts)) * 0.5d0)
! angular part of the 3body terms
angular = 2.0d0 * angular_base ** zeta
! the lowest index of the elements of j,k
p = min(n,m) - 1
! the highest index of the elements of j,k
q = max(n,m) - 1
! Dot product between the vectors connecting atom i,j and i,k
dot = dot_product(a-b,c-b)
! Part of the derivative of the angular basis functions wrt coordinates (dim(nabasis))
! including decay
d_angular = (zeta * angular * sin(angle-Ts) * rdecay(i,j) * rdecay(i,k)) / &
! & (2.0d0 * sqrt(rij2 * rik2 - dot**2) * angular_base)
& (2.0d0 * max(1d-10, sqrt(abs(rij2 * rik2 - dot**2)) * angular_base))
! write(*,*) angular_base
! Part of the derivative of the angular basis functions wrt atom j (dim(3))
d_angular_d_j = c - b + dot * ((b - a) * invrij2)
! Part of the derivative of the angular basis functions wrt atom k (dim(3))
d_angular_d_k = a - b + dot * ((b - c) * invrik2)
! Part of the derivative of the angular basis functions wrt atom i (dim(3))
d_angular_d_i = - (d_angular_d_j + d_angular_d_k)
! Part of the derivative of the radial basis functions wrt coordinates (dim(nbasis3))
! including decay
d_radial = radial * eta3 * (0.5d0 * (rij+rik) - Rs3) * rdecay(i,j) * rdecay(i,k)
! Part of the derivative of the radial basis functions wrt atom j (dim(3))
d_radial_d_j = (b - a) * invrij
! Part of the derivative of the radial basis functions wrt atom k (dim(3))
d_radial_d_k = (b - c) * invrik
! Part of the derivative of the radial basis functions wrt atom i (dim(3))
d_radial_d_i = - (d_radial_d_j + d_radial_d_k)
! Part of the derivative of the i,j decay functions wrt coordinates (dim(3))
d_ijdecay = - pi * (b - a) * sin(pi * rij * invcut) * 0.5d0 * invrij * invcut
! Part of the derivative of the i,k decay functions wrt coordinates (dim(3))
d_ikdecay = - pi * (b - c) * sin(pi * rik * invcut) * 0.5d0 * invrik * invcut
! Get index of where the contributions of atoms i,j,k should be added
s = nbasis3 * nabasis * (-(p * (p + 1))/2 + q + nelements * p) + 1
do l = 1, nbasis3
! Get index of where the contributions of atoms i,j,k should be added
z = s + (l-1) * nabasis
! Add the contributions for atoms i,j,k
atom_rep(z:z + nabasis - 1) = atom_rep(z:z + nabasis - 1) + angular * radial(l) * rdecay(i,j) * rdecay(i,k)
do t = 1, 3
! Add up all gradient contributions wrt atom i
atom_grad(z:z + nabasis - 1, i, t) = atom_grad(z:z + nabasis - 1, i, t) + &
& d_angular * d_angular_d_i(t) * radial(l) + &
& angular * d_radial(l) * d_radial_d_i(t) + &
& angular * radial(l) * (d_ijdecay(t) * rdecay(i,k) + rdecay(i,j) * d_ikdecay(t))
! Add up all gradient contributions wrt atom j
atom_grad(z:z + nabasis - 1, j, t) = atom_grad(z:z + nabasis - 1, j, t) + &
& d_angular * d_angular_d_j(t) * radial(l) + &
& angular * d_radial(l) * d_radial_d_j(t) - &
& angular * radial(l) * d_ijdecay(t) * rdecay(i,k)
! Add up all gradient contributions wrt atom k
atom_grad(z:z + nabasis - 1, k, t) = atom_grad(z:z + nabasis - 1, k, t) + &
& d_angular * d_angular_d_k(t) * radial(l) + &
& angular * d_radial(l) * d_radial_d_k(t) - &
& angular * radial(l) * rdecay(i,j) * d_ikdecay(t)
enddo
enddo
enddo
enddo
rep(i, twobody_size + 1:) = atom_rep
grad(i, twobody_size + 1:,:,:) = atom_grad
enddo
!$OMP END PARALLEL DO
deallocate(rdecay)
deallocate(element_types)
deallocate(distance_matrix)
deallocate(inv_distance_matrix)
deallocate(sq_distance_matrix)
deallocate(inv_sq_distance_matrix)
deallocate(atom_rep)
deallocate(atom_grad)
deallocate(a)
deallocate(b)
deallocate(c)
deallocate(radial)
deallocate(angular_base)
deallocate(angular)
deallocate(d_angular)
deallocate(d_angular_d_i)
deallocate(d_angular_d_j)
deallocate(d_angular_d_k)
deallocate(d_radial)
deallocate(d_radial_d_i)
deallocate(d_radial_d_j)
deallocate(d_radial_d_k)
deallocate(d_ijdecay)
deallocate(d_ikdecay)
end subroutine fgenerate_acsf_and_gradients
subroutine fgenerate_fchl_acsf(coordinates, nuclear_charges, elements, &
& Rs2, Rs3, Ts, eta2, eta3, zeta, rcut, acut, natoms, rep_size, &
& two_body_decay, three_body_decay, three_body_weight, rep)
use acsf_utils, only: decay, calc_angle, calc_cos_angle
implicit none
double precision, intent(in), dimension(:, :) :: coordinates
integer, intent(in), dimension(:) :: nuclear_charges
integer, intent(in), dimension(:) :: elements
double precision, intent(in), dimension(:) :: Rs2
double precision, intent(in), dimension(:) :: Rs3
double precision, intent(in), dimension(:) :: Ts
double precision, intent(in) :: eta2
double precision, intent(in) :: eta3
double precision, intent(in) :: zeta
double precision, intent(in) :: rcut
double precision, intent(in) :: acut
integer, intent(in) :: natoms
integer, intent(in) :: rep_size
double precision, intent(in) :: two_body_decay
double precision, intent(in) :: three_body_decay
double precision, intent(in) :: three_body_weight
double precision, intent(out), dimension(natoms, rep_size) :: rep
integer :: i, j, k, l, n, m, o, p, q, s, z, nelements, nbasis2, nbasis3, nabasis
integer, allocatable, dimension(:) :: element_types
double precision :: rij, rik, angle, cos_1, cos_2, cos_3, invcut
! double precision :: angle_1, angle_2, angle_3
double precision, allocatable, dimension(:) :: radial, angular, a, b, c
double precision, allocatable, dimension(:, :) :: distance_matrix, rdecay, rep3
double precision :: mu, sigma, ksi3
double precision, parameter :: pi = 4.0d0 * atan(1.0d0)
if (natoms /= size(nuclear_charges, dim=1)) then
write(*,*) "ERROR: Atom Centered Symmetry Functions creation"
write(*,*) natoms, "coordinates, but", &
& size(nuclear_charges, dim=1), "atom_types!"
stop
endif
! number of element types
nelements = size(elements)
! Allocate temporary
allocate(element_types(natoms))
! Store element index of every atom
! !$OMP PARALLEL DO
do i = 1, natoms
do j = 1, nelements
if (nuclear_charges(i) .eq. elements(j)) then
element_types(i) = j
continue
endif
enddo
enddo
! !$OMP END PARALLEL DO
! Get distance matrix
! Allocate temporary
allocate(distance_matrix(natoms, natoms))
distance_matrix = 0.0d0
! !$OMP PARALLEL DO PRIVATE(rij)
do i = 1, natoms
do j = i+1, natoms
rij = norm2(coordinates(j,:) - coordinates(i,:))
distance_matrix(i, j) = rij
distance_matrix(j, i) = rij
enddo
enddo
! !$OMP END PARALLEL DO
! number of basis functions in the two body term
nbasis2 = size(Rs2)
! Inverse of the two body cutoff
invcut = 1.0d0 / rcut
! pre-calculate the radial decay in the two body terms
rdecay = decay(distance_matrix, invcut, natoms)
! Allocate temporary
allocate(radial(nbasis2))
radial = 0.0d0
! !$OMP PARALLEL DO PRIVATE(n,m,rij,radial) REDUCTION(+:rep)
do i = 1, natoms
! index of the element of atom i
m = element_types(i)
do j = i + 1, natoms
! index of the element of atom j
n = element_types(j)
! distance between atoms i and j
rij = distance_matrix(i,j)
if (rij <= rcut) then
! two body term of the representation
mu = log(rij / sqrt(1.0d0 + eta2 / rij**2))
sigma = sqrt(log(1.0d0 + eta2 / rij**2))
radial(:) = 0.0d0
do k = 1, nbasis2
radial(k) = 1.0d0/(sigma* sqrt(2.0d0*pi) * Rs2(k)) * rdecay(i,j) &
& * exp( - (log(Rs2(k)) - mu)**2 / (2.0d0 * sigma**2) ) / rij**two_body_decay
enddo
rep(i, (n-1)*nbasis2 + 1:n*nbasis2) = rep(i, (n-1)*nbasis2 + 1:n*nbasis2) + radial
rep(j, (m-1)*nbasis2 + 1:m*nbasis2) = rep(j, (m-1)*nbasis2 + 1:m*nbasis2) + radial
endif
enddo
enddo
! !$OMP END PARALLEL DO
deallocate(radial)
! number of radial basis functions in the three body term
nbasis3 = size(Rs3)
! number of radial basis functions in the three body term
nabasis = size(Ts)
! Inverse of the three body cutoff
invcut = 1.0d0 / acut
! pre-calculate the radial decay in the three body terms
rdecay = decay(distance_matrix, invcut, natoms)
! Allocate temporary
allocate(rep3(natoms,rep_size))
allocate(a(3))
allocate(b(3))
allocate(c(3))
allocate(radial(nbasis3))
allocate(angular(nabasis))
rep3 = 0.0d0
! This could probably be done more efficiently if it's a bottleneck
! Also the order is a bit wobbly compared to the tensorflow implementation
! !$OMP PARALLEL DO PRIVATE(rij, n, rik, m, a, b, c, angle, radial, angular, &
! !$OMP cos_1, cos_2, cos_3, mu, sigma, o, ksi3, &
! !$OMP p, q, s, z) REDUCTION(+:rep3) COLLAPSE(2) SCHEDULE(dynamic)
do i = 1, natoms
do j = 1, natoms - 1
if (i .eq. j) cycle
! distance between atoms i and j
rij = distance_matrix(i,j)
if (rij > acut) cycle
! index of the element of atom j
n = element_types(j)
do k = j + 1, natoms
if (i .eq. k) cycle
if (j .eq. k) cycle
! distance between atoms i and k
rik = distance_matrix(i,k)
if (rik > acut) cycle
! index of the element of atom k
m = element_types(k)
! coordinates of atoms j, i, k
a = coordinates(j,:)
b = coordinates(i,:)
c = coordinates(k,:)
! angle between atoms i, j and k centered on i
angle = calc_angle(a,b,c)
cos_1 = calc_cos_angle(a,b,c)
cos_2 = calc_cos_angle(a,c,b)
cos_3 = calc_cos_angle(b,a,c)
! The radial part of the three body terms including decay
radial = exp(-eta3*(0.5d0 * (rij+rik) - Rs3)**2) * rdecay(i,j) * rdecay(i,k)
ksi3 = (1.0d0 + 3.0d0 * cos_1 * cos_2 * cos_3) &
& / (distance_matrix(i,k) * distance_matrix(i,j) * distance_matrix(j,k) &
& )**three_body_decay * three_body_weight
angular = 0.0d0
do l = 1, nabasis/2
o = l*2-1
angular(2*l-1) = angular(2*l-1) + 2*cos(o * angle) &
& * exp(-(zeta * o)**2 /2)
angular(2*l) = angular(2*l) + 2*sin(o * angle) &
& * exp(-(zeta * o)**2 /2)
enddo
! The lowest of the element indices for atoms j and k
p = min(n,m) - 1
! The highest of the element indices for atoms j and k
q = max(n,m) - 1
! calculate the indices that the three body terms should be added to
s = nelements * nbasis2 + nbasis3 * nabasis * (-(p * (p + 1))/2 + q + nelements * p) + 1
do l = 1, nbasis3
! calculate the indices that the three body terms should be added to
z = s + (l-1) * nabasis
! Add the contributions from atoms i,j and k
rep3(i, z:z + nabasis - 1) = rep3(i, z:z + nabasis - 1) + angular * radial(l) * ksi3
enddo
enddo
enddo
enddo
! !$OMP END PARALLEL DO
rep = rep + rep3
deallocate(element_types)
deallocate(rdecay)
deallocate(distance_matrix)
deallocate(rep3)
deallocate(a)
deallocate(b)
deallocate(c)
deallocate(radial)
deallocate(angular)
end subroutine fgenerate_fchl_acsf
subroutine fgenerate_fchl_acsf_and_gradients(coordinates, nuclear_charges, elements, &
& Rs2, Rs3, Ts, eta2, eta3, zeta, rcut, acut, natoms, rep_size, &
& two_body_decay, three_body_decay, three_body_weight, rep, grad)
use acsf_utils, only: decay, calc_angle, calc_cos_angle
implicit none
double precision, intent(in), dimension(:, :) :: coordinates
integer, intent(in), dimension(:) :: nuclear_charges
integer, intent(in), dimension(:) :: elements
double precision, intent(in), dimension(:) :: Rs2
double precision, intent(in), dimension(:) :: Rs3
double precision, intent(in), dimension(:) :: Ts
double precision, intent(in) :: eta2
double precision, intent(in) :: eta3
double precision, intent(in) :: zeta
double precision, intent(in) :: rcut
double precision, intent(in) :: acut
double precision, intent(in) :: two_body_decay
double precision, intent(in) :: three_body_decay
double precision, intent(in) :: three_body_weight
double precision :: mu, sigma, dx, exp_s2, scaling, dscal, ddecay
double precision :: cos_i, cos_j, cos_k
double precision, allocatable, dimension(:) :: exp_ln
double precision, allocatable, dimension(:) :: log_Rs2
integer, intent(in) :: natoms
integer, intent(in) :: rep_size
double precision, intent(out), dimension(natoms, rep_size) :: rep
double precision, intent(out), dimension(natoms, rep_size, natoms, 3) :: grad
integer :: i, j, k, l, m, n, p, q, s, t, z, nelements, nbasis2, nbasis3, nabasis, twobody_size
integer, allocatable, dimension(:) :: element_types
double precision :: rij, rik, angle, dot, rij2, rik2, invrij, invrik, invrij2, invrik2, invcut
double precision, allocatable, dimension(:) :: radial_base, radial, angular, a, b, c, atom_rep
double precision, allocatable, dimension(:) :: angular_base, d_radial, d_radial_d_i
double precision, allocatable, dimension(:) :: d_radial_d_j, d_radial_d_k, d_ijdecay, d_ikdecay
double precision, allocatable, dimension(:) :: d_angular, part, radial_part
double precision, allocatable, dimension(:) :: d_angular_d_i, d_angular_d_j, d_angular_d_k
double precision, allocatable, dimension(:, :) :: distance_matrix, rdecay, sq_distance_matrix
double precision, allocatable, dimension(:, :) :: inv_distance_matrix, inv_sq_distance_matrix
double precision, allocatable, dimension(:, :, :) :: atom_grad
double precision :: atm, atm_i, atm_j, atm_k
double precision :: invrjk, invr_atm, vi, vj, vk
double precision, allocatable, dimension(:) :: d_atm_i, d_atm_j, d_atm_k
double precision, allocatable, dimension(:) :: d_atm_ii, d_atm_ji, d_atm_ki
double precision, allocatable, dimension(:) :: d_atm_ij, d_atm_jj, d_atm_kj
double precision, allocatable, dimension(:) :: d_atm_ik, d_atm_jk, d_atm_kk
double precision, allocatable, dimension(:) :: d_atm_i2, d_atm_j2, d_atm_k2
double precision, allocatable, dimension(:) :: d_atm_i3, d_atm_j3, d_atm_k3
double precision, allocatable, dimension(:) :: d_atm_extra_i, d_atm_extra_j, d_atm_extra_k
double precision, parameter :: pi = 4.0d0 * atan(1.0d0)
if (natoms /= size(nuclear_charges, dim=1)) then
write(*,*) "ERROR: Atom Centered Symmetry Functions creation"
write(*,*) natoms, "coordinates, but", &
& size(nuclear_charges, dim=1), "atom_types!"
stop
endif
! Number of unique elements
nelements = size(elements)
! Allocate temporary
allocate(element_types(natoms))
! Store element index of every atom
! !$OMP PARALLEL DO
do i = 1, natoms
do j = 1, nelements
if (nuclear_charges(i) .eq. elements(j)) then
element_types(i) = j
continue
endif
enddo
enddo
! !$OMP END PARALLEL DO
! Get distance matrix
! Allocate temporary
allocate(distance_matrix(natoms, natoms))
allocate(sq_distance_matrix(natoms, natoms))
allocate(inv_distance_matrix(natoms, natoms))
allocate(inv_sq_distance_matrix(natoms, natoms))
distance_matrix = 0.0d0
sq_distance_matrix = 0.0d0
inv_distance_matrix = 0.0d0
inv_sq_distance_matrix = 0.0d0
! !$OMP PARALLEL DO PRIVATE(rij,rij2,invrij,invrij2) SCHEDULE(dynamic)
do i = 1, natoms
do j = i+1, natoms
rij = norm2(coordinates(j,:) - coordinates(i,:))
distance_matrix(i, j) = rij
distance_matrix(j, i) = rij
rij2 = rij * rij
sq_distance_matrix(i, j) = rij2
sq_distance_matrix(j, i) = rij2
invrij = 1.0d0 / rij
inv_distance_matrix(i, j) = invrij
inv_distance_matrix(j, i) = invrij
invrij2 = invrij * invrij
inv_sq_distance_matrix(i, j) = invrij2
inv_sq_distance_matrix(j, i) = invrij2
enddo
enddo
! !$OMP END PARALLEL DO
! Number of two body basis functions
nbasis2 = size(Rs2)
! Inverse of the two body cutoff distance
invcut = 1.0d0 / rcut
! Pre-calculate the two body decay
rdecay = decay(distance_matrix, invcut, natoms)
! Allocate temporary
allocate(radial_base(nbasis2))
allocate(radial(nbasis2))
allocate(radial_part(nbasis2))
allocate(part(nbasis2))
allocate(exp_ln(nbasis2))
allocate(log_Rs2(nbasis2))
grad =0.0d0
rep = 0.0d0
log_Rs2(:) = log(Rs2(:))
! !$OMP PARALLEL DO PRIVATE(m,n,rij,invrij,radial_base,radial,radial_part,part) REDUCTION(+:rep,grad) &
! !$OMP SCHEDULE(dynamic)
do i = 1, natoms
! The element index of atom i
m = element_types(i)
do j = i + 1, natoms
! The element index of atom j
n = element_types(j)
! Distance between atoms i and j
rij = distance_matrix(i,j)
if (rij <= rcut) then
invrij = inv_distance_matrix(i,j)
mu = log(rij / sqrt(1.0d0 + eta2 * inv_sq_distance_matrix(i, j)))
sigma = sqrt(log(1.0d0 + eta2 * inv_sq_distance_matrix(i, j)))
exp_s2 = exp(sigma**2)
exp_ln = exp(-(log_Rs2(:) - mu)**2 / sigma**2 * 0.5d0) * sqrt(2.0d0)
scaling = 1.0d0 / rij**two_body_decay
radial_base(:) = 1.0d0/(sigma* sqrt(2.0d0*pi) * Rs2(:)) * exp(-(log_Rs2(:) - mu)**2 / (2.0d0 * sigma**2))
radial(:) = radial_base(:) * scaling * rdecay(i,j)
rep(i, (n-1)*nbasis2 + 1:n*nbasis2) = rep(i, (n-1)*nbasis2 + 1:n*nbasis2) + radial
rep(j, (m-1)*nbasis2 + 1:m*nbasis2) = rep(j, (m-1)*nbasis2 + 1:m*nbasis2) + radial
do k = 1, 3
dx = -(coordinates(i,k) - coordinates(j,k))
part(:) = ((log_Rs2(:) - mu) * (-dx *(rij**2 * exp_s2 + eta2) / (rij * sqrt(exp_s2))**3) &
&* sqrt(exp_s2) / (sigma**2 * rij) + (log_Rs2(:) - mu) ** 2 * eta2 * dx / &
&(sigma**4 * rij**4 * exp_s2)) * exp_ln / (Rs2(:) * sigma * sqrt(pi) * 2) &
&- exp_ln * eta2 * dx / (Rs2(:) * sigma**3 *sqrt(pi) * rij**4 * exp_s2 * 2.0d0)
dscal = two_body_decay * dx / rij**(two_body_decay+2.0d0)
ddecay = dx * 0.5d0 * pi * sin(pi*rij * invcut) * invcut * invrij
part(:) = part(:) * scaling * rdecay(i,j) + radial_base(:) * dscal * rdecay(i,j) &
& + radial_base(:) * scaling * ddecay
! The gradients wrt coordinates
grad(i, (n-1)*nbasis2 + 1:n*nbasis2, i, k) = grad(i, (n-1)*nbasis2 + 1:n*nbasis2, i, k) + part
grad(i, (n-1)*nbasis2 + 1:n*nbasis2, j, k) = grad(i, (n-1)*nbasis2 + 1:n*nbasis2, j, k) - part
grad(j, (m-1)*nbasis2 + 1:m*nbasis2, j, k) = grad(j, (m-1)*nbasis2 + 1:m*nbasis2, j, k) - part
grad(j, (m-1)*nbasis2 + 1:m*nbasis2, i, k) = grad(j, (m-1)*nbasis2 + 1:m*nbasis2, i, k) + part
enddo
endif
enddo
enddo
! !$OMP END PARALLEL DO
deallocate(radial_base)
deallocate(radial)
deallocate(radial_part)
deallocate(part)
! Number of radial basis functions in the three body term
nbasis3 = size(Rs3)
! Number of angular basis functions in the three body term
nabasis = size(Ts)
! Size of two body terms
twobody_size = nelements * nbasis2
! Inverse of the three body cutoff distance
invcut = 1.0d0 / acut
! Pre-calculate the three body decay
rdecay = decay(distance_matrix, invcut, natoms)
! Allocate temporary
allocate(atom_rep(rep_size - twobody_size))
allocate(atom_grad(rep_size - twobody_size, natoms, 3))
allocate(a(3))
allocate(b(3))
allocate(c(3))
allocate(radial(nbasis3))
allocate(radial_base(nbasis3))
allocate(angular_base(nabasis))
allocate(angular(nabasis))
allocate(d_angular(nabasis))
allocate(d_angular_d_i(3))
allocate(d_angular_d_j(3))
allocate(d_angular_d_k(3))
allocate(d_radial(nbasis3))
allocate(d_radial_d_i(3))
allocate(d_radial_d_j(3))
allocate(d_radial_d_k(3))
allocate(d_ijdecay(3))
allocate(d_ikdecay(3))
allocate(d_atm_i(3))
allocate(d_atm_j(3))
allocate(d_atm_k(3))
allocate(d_atm_ii(3))
allocate(d_atm_ij(3))
allocate(d_atm_ik(3))
allocate(d_atm_ji(3))
allocate(d_atm_jj(3))
allocate(d_atm_jk(3))
allocate(d_atm_ki(3))
allocate(d_atm_kj(3))
allocate(d_atm_kk(3))
allocate(d_atm_i2(3))
allocate(d_atm_j2(3))
allocate(d_atm_k2(3))
allocate(d_atm_i3(3))
allocate(d_atm_j3(3))
allocate(d_atm_k3(3))
allocate(d_atm_extra_i(3))
allocate(d_atm_extra_j(3))
allocate(d_atm_extra_k(3))
! ! This could probably be done more efficiently if it's a bottleneck
! ! The order is a bit wobbly compared to the tensorflow implementation
! !$OMP PARALLEL DO PRIVATE(atom_rep,atom_grad,a,b,c,radial,angular_base, &
! !$OMP angular,d_angular,rij,n,rij2,invrij,invrij2,d_angular_d_i, &
! !$OMP d_angular_d_j,d_angular_d_k,rik,m,rik2,invrik,invrik2,angle, &
! !$OMP p,q,dot,d_radial,d_radial_d_i,d_radial_d_j,d_radial_d_k,s,z, &
! !$OMP d_ijdecay,d_ikdecay) SCHEDULE(dynamic)
do i = 1, natoms
atom_rep = 0.0d0
atom_grad = 0.0d0
do j = 1, natoms - 1
if (i .eq. j) cycle
! distance between atom i and j
rij = distance_matrix(i,j)
if (rij > acut) cycle
! index of the element of atom j
n = element_types(j)
! squared distance between atom i and j
rij2 = sq_distance_matrix(i,j)
! inverse distance between atom i and j
invrij = inv_distance_matrix(i,j)
! inverse squared distance between atom i and j
invrij2 = inv_sq_distance_matrix(i,j)
do k = j + 1, natoms
if (i .eq. k) cycle
! distance between atom i and k
rik = distance_matrix(i,k)
if (rik > acut) cycle
! index of the element of atom k
m = element_types(k)
! squared distance between atom i and k
rik2 = sq_distance_matrix(i,k)
! inverse distance between atom i and k
invrik = inv_distance_matrix(i,k)
! inverse distance between atom j and k
invrjk = inv_distance_matrix(j,k)
! inverse squared distance between atom i and k
invrik2 = inv_sq_distance_matrix(i,k)
! coordinates of atoms j, i, k
a = coordinates(j,:)
b = coordinates(i,:)
c = coordinates(k,:)
! angle between atom i, j and k, centered on i
angle = calc_angle(a,b,c)
cos_i = calc_cos_angle(a,b,c)
cos_k = calc_cos_angle(a,c,b)
cos_j = calc_cos_angle(b,a,c)
! part of the radial part of the 3body terms
radial_base(:) = exp(-eta3*(0.5d0 * (rij+rik) - Rs3(:))**2)
radial(:) = radial_base(:) ! * scaling
p = min(n,m) - 1
! the highest index of the elements of j,k
q = max(n,m) - 1
! Dot product between the vectors connecting atom i,j and i,k
dot = dot_product(a-b,c-b)
angular(1) = exp(-(zeta**2)*0.5d0) * 2 * cos(angle)
angular(2) = exp(-(zeta**2)*0.5d0) * 2 * sin(angle)
d_angular(1) = exp(-(zeta**2)*0.5d0) * 2 * sin(angle) / sqrt(max(1d-10, rij2 * rik2 - dot**2))
d_angular(2) = -exp(-(zeta**2)*0.5d0) * 2 * cos(angle) / sqrt(max(1d-10, rij2 * rik2 - dot**2))
! Part of the derivative of the angular basis functions wrt atom j (dim(3))
d_angular_d_j = c - b + dot * ((b - a) * invrij2)
! Part of the derivative of the angular basis functions wrt atom k (dim(3))
d_angular_d_k = a - b + dot * ((b - c) * invrik2)
! Part of the derivative of the angular basis functions wrt atom i (dim(3))
d_angular_d_i = - (d_angular_d_j + d_angular_d_k)
! Part of the derivative of the radial basis functions wrt coordinates (dim(nbasis3))
! including decay
d_radial = radial * eta3 * (0.5d0 * (rij+rik) - Rs3) ! * rdecay(i,j) * rdecay(i,k)
! Part of the derivative of the radial basis functions wrt atom j (dim(3))
d_radial_d_j = (b - a) * invrij
! Part of the derivative of the radial basis functions wrt atom k (dim(3))
d_radial_d_k = (b - c) * invrik
! Part of the derivative of the radial basis functions wrt atom i (dim(3))
d_radial_d_i = - (d_radial_d_j + d_radial_d_k)
! Part of the derivative of the i,j decay functions wrt coordinates (dim(3))
d_ijdecay = - pi * (b - a) * sin(pi * rij * invcut) * 0.5d0 * invrij * invcut
! Part of the derivative of the i,k decay functions wrt coordinates (dim(3))
d_ikdecay = - pi * (b - c) * sin(pi * rik * invcut) * 0.5d0 * invrik * invcut
invr_atm = (invrij * invrjk *invrik)**three_body_decay
! Axilrod-Teller-Muto term
atm = (1.0d0 + 3.0d0 * cos_i * cos_j * cos_k) * invr_atm * three_body_weight
atm_i = (3.0d0 * cos_j * cos_k) * invr_atm * invrij * invrik
atm_j = (3.0d0 * cos_k * cos_i) * invr_atm * invrij * invrjk
atm_k = (3.0d0 * cos_i * cos_j) * invr_atm * invrjk * invrik
vi = dot_product(a-b,c-b)
vj = dot_product(c-a,b-a)
vk = dot_product(b-c,a-c)
d_atm_ii(:) = 2 * b - a - c - vi * ((b-a)*invrij**2 + (b-c)*invrik**2)
d_atm_ij(:) = c - a - vj * (b-a)*invrij**2
d_atm_ik(:) = a - c - vk * (b-c)*invrik**2
d_atm_ji(:) = c - b - vi * (a-b)*invrij**2
d_atm_jj(:) = 2 * a - b - c - vj * ((a-b)*invrij**2 + (a-c)*invrjk**2)
d_atm_jk(:) = b - c - vk * (a-c)*invrjk**2
d_atm_ki(:) = a - b - vi * (c-b)*invrik**2
d_atm_kj(:) = b - a - vj * (c-a)*invrjk**2
d_atm_kk(:) = 2 * c - a - b - vk * ((c-a)*invrjk**2 + (c-b)*invrik**2)
d_atm_extra_i(:) = ((a-b)*invrij**2 + (c-b)*invrik**2) * atm * three_body_decay / three_body_weight
d_atm_extra_j(:) = ((b-a)*invrij**2 + (c-a)*invrjk**2) * atm * three_body_decay / three_body_weight
d_atm_extra_k(:) = ((a-c)*invrjk**2 + (b-c)*invrik**2) * atm * three_body_decay / three_body_weight
! Get index of where the contributions of atoms i,j,k should be added
s = nbasis3 * nabasis * (-(p * (p + 1))/2 + q + nelements * p) + 1
do l = 1, nbasis3
! Get index of where the contributions of atoms i,j,k should be added
z = s + (l-1) * nabasis
! Add the contributions for atoms i,j,k
atom_rep(z:z + nabasis - 1) = atom_rep(z:z + nabasis - 1) &
& + angular * radial(l) * atm * rdecay(i,j) * rdecay(i,k)
do t = 1, 3
! Add up all gradient contributions wrt atom i
atom_grad(z:z + nabasis - 1, i, t) = atom_grad(z:z + nabasis - 1, i, t) + &
& d_angular * d_angular_d_i(t) * radial(l) * atm * rdecay(i,j) * rdecay(i,k) + &
& angular * d_radial(l) * d_radial_d_i(t) * atm * rdecay(i,j) * rdecay(i,k) + &
& angular * radial(l) * (atm_i * d_atm_ii(t) + atm_j * d_atm_ij(t) &
& + atm_k * d_atm_ik(t) + d_atm_extra_i(t)) * three_body_weight * rdecay(i,j) * rdecay(i,k) + &
& angular * radial(l) * (d_ijdecay(t) * rdecay(i,k) + rdecay(i,j) * d_ikdecay(t)) * atm
! Add up all gradient contributions wrt atom j
atom_grad(z:z + nabasis - 1, j, t) = atom_grad(z:z + nabasis - 1, j, t) + &
& d_angular * d_angular_d_j(t) * radial(l) * atm * rdecay(i,j) * rdecay(i,k) + &
& angular * d_radial(l) * d_radial_d_j(t) * atm * rdecay(i,j) * rdecay(i,k) + &
& angular * radial(l) * (atm_i * d_atm_ji(t) + atm_j * d_atm_jj(t) &
& + atm_k * d_atm_jk(t) + d_atm_extra_j(t)) * three_body_weight * rdecay(i,j) * rdecay(i,k) - &
& angular * radial(l) * d_ijdecay(t) * rdecay(i,k) * atm
! Add up all gradient contributions wrt atom k
atom_grad(z:z + nabasis - 1, k, t) = atom_grad(z:z + nabasis - 1, k, t) + &
& d_angular * d_angular_d_k(t) * radial(l) * atm * rdecay(i,j) * rdecay(i,k) + &
& angular * d_radial(l) * d_radial_d_k(t) * atm * rdecay(i,j) * rdecay(i,k) + &
& angular * radial(l) * (atm_i * d_atm_ki(t) + atm_j * d_atm_kj(t) &
& + atm_k * d_atm_kk(t) + d_atm_extra_k(t)) * three_body_weight * rdecay(i,j) * rdecay(i,k) - &
& angular * radial(l) * rdecay(i,j) * d_ikdecay(t) * atm
enddo
enddo
enddo
enddo
rep(i, twobody_size + 1:) = rep(i, twobody_size + 1:) + atom_rep
grad(i, twobody_size + 1:,:,:) = grad(i, twobody_size + 1:,:,:) + atom_grad
enddo
! !$OMP END PARALLEL DO
deallocate(rdecay)
deallocate(element_types)
deallocate(distance_matrix)
deallocate(inv_distance_matrix)
deallocate(sq_distance_matrix)
deallocate(inv_sq_distance_matrix)
deallocate(atom_rep)
deallocate(atom_grad)
deallocate(a)
deallocate(b)
deallocate(c)
deallocate(radial)
deallocate(angular_base)
deallocate(angular)
deallocate(d_angular)
deallocate(d_angular_d_i)
deallocate(d_angular_d_j)
deallocate(d_angular_d_k)
deallocate(d_radial)
deallocate(d_radial_d_i)
deallocate(d_radial_d_j)
deallocate(d_radial_d_k)
deallocate(d_ijdecay)
deallocate(d_ikdecay)
end subroutine fgenerate_fchl_acsf_and_gradients
================================================
FILE: qml/representations/frepresentations.f90
================================================
! MIT License
!
! Copyright (c) 2016-2017 Anders Steen Christensen, Lars Andersen Bratholm
!
! Permission is hereby granted, free of charge, to any person obtaining a copy
! of this software and associated documentation files (the "Software"), to deal
! in the Software without restriction, including without limitation the rights
! to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
! copies of the Software, and to permit persons to whom the Software is
! furnished to do so, subject to the following conditions:
!
! The above copyright notice and this permission notice shall be included in all
! copies or substantial portions of the Software.
!
! THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
! IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
! FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
! AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
! LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
! OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
! SOFTWARE.
module representations
implicit none
contains
subroutine get_indices(natoms, nuclear_charges, type1, n, type1_indices)
integer, intent(in) :: natoms
integer, intent(in) :: type1
integer, dimension(:), intent(in) :: nuclear_charges
integer, intent(inout) :: n
integer, dimension(:), intent(out) :: type1_indices
integer :: j
do j = 1, natoms
if (nuclear_charges(j) == type1) then
n = n + 1
type1_indices(n) = j
endif
enddo
end subroutine get_indices
end module representations
subroutine fgenerate_coulomb_matrix(atomic_charges, coordinates, nmax, cm)
implicit none
double precision, dimension(:), intent(in) :: atomic_charges
double precision, dimension(:,:), intent(in) :: coordinates
integer, intent(in) :: nmax
double precision, dimension(((nmax + 1) * nmax) / 2), intent(out):: cm
double precision, allocatable, dimension(:) :: row_norms
double precision :: pair_norm
double precision :: huge_double
integer, allocatable, dimension(:) :: sorted_atoms
double precision, allocatable, dimension(:,:) :: pair_distance_matrix
integer :: i, j, m, n, idx
integer :: natoms
if (size(coordinates, dim=1) /= size(atomic_charges, dim=1)) then
write(*,*) "ERROR: Coulomb matrix generation"
write(*,*) size(coordinates, dim=1), "coordinates, but", &
& size(atomic_charges, dim=1), "atom_types!"
stop
else
natoms = size(atomic_charges, dim=1)
endif
! Allocate temporary
allocate(pair_distance_matrix(natoms,natoms))
allocate(row_norms(natoms))
allocate(sorted_atoms(natoms))
huge_double = huge(row_norms(1))
! Calculate row-2-norms and store pair-distances in pair_distance_matrix
row_norms = 0.0d0
!$OMP PARALLEL DO PRIVATE(pair_norm) REDUCTION(+:row_norms)
do i = 1, natoms
pair_norm = 0.5d0 * atomic_charges(i) ** 2.4d0
row_norms(i) = row_norms(i) + pair_norm * pair_norm
pair_distance_matrix(i, i) = pair_norm
enddo
!$OMP END PARALLEL DO
!$OMP PARALLEL DO PRIVATE(pair_norm) REDUCTION(+:row_norms)
do i = 1, natoms
do j = i+1, natoms
pair_norm = atomic_charges(i) * atomic_charges(j) &
& / sqrt(sum((coordinates(j,:) - coordinates(i,:))**2))
pair_distance_matrix(i, j) = pair_norm
pair_distance_matrix(j, i) = pair_norm
pair_norm = pair_norm * pair_norm
row_norms(j) = row_norms(j) + pair_norm
row_norms(i) = row_norms(i) + pair_norm
enddo
enddo
!$OMP END PARALLEL DO
!Generate sorted list of atom ids by row_norms - not really (easily) parallelizable
do i = 1, natoms
j = minloc(row_norms, dim=1)
sorted_atoms(natoms - i + 1) = j
row_norms(j) = huge_double
enddo
! Fill coulomb matrix according to sorted row-2-norms
cm = 0.0d0
!$OMP PARALLEL DO PRIVATE(idx, i, j)
do m = 1, natoms
i = sorted_atoms(m)
idx = (m*m+m)/2 - m
do n = 1, m
j = sorted_atoms(n)
cm(idx+n) = pair_distance_matrix(i, j)
enddo
enddo
!$OMP END PARALLEL DO
! Clean up
deallocate(pair_distance_matrix)
deallocate(row_norms)
deallocate(sorted_atoms)
end subroutine fgenerate_coulomb_matrix
subroutine fgenerate_unsorted_coulomb_matrix(atomic_charges, coordinates, nmax, cm)
implicit none
double precision, dimension(:), intent(in) :: atomic_charges
double precision, dimension(:,:), intent(in) :: coordinates
integer, intent(in) :: nmax
double precision, dimension(((nmax + 1) * nmax) / 2), intent(out):: cm
double precision :: pair_norm
double precision, allocatable, dimension(:,:) :: pair_distance_matrix
integer :: i, j, m, n, idx
integer :: natoms
if (size(coordinates, dim=1) /= size(atomic_charges, dim=1)) then
write(*,*) "ERROR: Coulomb matrix generation"
write(*,*) size(coordinates, dim=1), "coordinates, but", &
& size(atomic_charges, dim=1), "atom_types!"
stop
else
natoms = size(atomic_charges, dim=1)
endif
! Allocate temporary
allocate(pair_distance_matrix(natoms,natoms))
!$OMP PARALLEL DO PRIVATE(pair_norm)
do i = 1, natoms
pair_norm = 0.5d0 * atomic_charges(i) ** 2.4d0
pair_distance_matrix(i, i) = pair_norm
enddo
!$OMP END PARALLEL DO
!$OMP PARALLEL DO PRIVATE(pair_norm)
do i = 1, natoms
do j = i+1, natoms
pair_norm = atomic_charges(i) * atomic_charges(j) &
& / sqrt(sum((coordinates(j,:) - coordinates(i,:))**2))
pair_distance_matrix(i, j) = pair_norm
pair_distance_matrix(j, i) = pair_norm
enddo
enddo
!$OMP END PARALLEL DO
cm = 0.0d0
!$OMP PARALLEL DO PRIVATE(idx)
do m = 1, natoms
idx = (m*m+m)/2 - m
do n = 1, m
cm(idx+n) = pair_distance_matrix(m, n)
enddo
enddo
!$OMP END PARALLEL DO
! Clean up
deallocate(pair_distance_matrix)
end subroutine fgenerate_unsorted_coulomb_matrix
subroutine fgenerate_local_coulomb_matrix(central_atom_indices, central_natoms, &
& atomic_charges, coordinates, natoms, nmax, cent_cutoff, cent_decay, &
& int_cutoff, int_decay, cm)
implicit none
integer, intent(in) :: central_natoms
integer, dimension(:), intent(in) :: central_atom_indices
double precision, dimension(:), intent(in) :: atomic_charges
double precision, dimension(:,:), intent(in) :: coordinates
integer,intent(in) :: natoms
integer, intent(in) :: nmax
double precision, intent(inout) :: cent_cutoff, cent_decay, int_cutoff, int_decay
double precision, dimension(central_natoms, ((nmax + 1) * nmax) / 2), intent(out):: cm
integer :: idx
double precision, allocatable, dimension(:, :) :: row_norms
double precision, allocatable, dimension(:) :: row_norms_l
double precision :: pair_norm
double precision :: prefactor
double precision :: norm
double precision :: huge_double
integer, allocatable, dimension(:, :) :: sorted_atoms_all
integer, allocatable, dimension(:) :: cutoff_count
double precision, allocatable, dimension(:, :, :) :: pair_distance_matrix
double precision, allocatable, dimension(:, :) :: distance_matrix
integer i, j, m, n, k, l
double precision, parameter :: pi = 4.0d0 * atan(1.0d0)
if (size(coordinates, dim=1) /= size(atomic_charges, dim=1)) then
write(*,*) "ERROR: Coulomb matrix generation"
write(*,*) size(coordinates, dim=1), "coordinates, but", &
& size(atomic_charges, dim=1), "atom_types!"
stop
endif
! Allocate temporary
allocate(distance_matrix(natoms,natoms))
allocate(cutoff_count(natoms))
huge_double = huge(distance_matrix(1,1))
if (cent_cutoff < 0) then
cent_cutoff = huge_double
endif
if ((int_cutoff < 0) .OR. (int_cutoff > 2 * cent_cutoff)) then
int_cutoff = 2 * cent_cutoff
endif
if (cent_decay < 0) then
cent_decay = 0.0d0
else if (cent_decay > cent_cutoff) then
cent_decay = cent_cutoff
endif
if (int_decay < 0) then
int_decay = 0.0d0
else if (int_decay > int_cutoff) then
int_decay = int_cutoff
endif
cutoff_count = 1
!$OMP PARALLEL DO PRIVATE(norm) REDUCTION(+:cutoff_count)
do i = 1, natoms
distance_matrix(i, i) = 0.0d0
do j = i+1, natoms
norm = sqrt(sum((coordinates(j,:) - coordinates(i,:))**2))
distance_matrix(i, j) = norm
distance_matrix(j, i) = norm
if (norm < cent_cutoff) then
cutoff_count(i) = cutoff_count(i) + 1
cutoff_count(j) = cutoff_count(j) + 1
endif
enddo
enddo
!$OMP END PARALLEL DO
do i = 1, central_natoms
j = central_atom_indices(i)
if (cutoff_count(j) > nmax) then
write(*,*) "ERROR: Coulomb matrix generation"
write(*,*) nmax, "size set, but", &
& cutoff_count(j), "size needed!"
stop
endif
enddo
! Allocate temporary
allocate(pair_distance_matrix(natoms, natoms, central_natoms))
allocate(row_norms(natoms, central_natoms))
allocate(row_norms_l(natoms))
pair_distance_matrix = 0.0d0
row_norms = 0.0d0
!$OMP PARALLEL DO PRIVATE(pair_norm, prefactor, k, row_norms_l)
do l = 1, central_natoms
k = central_atom_indices(l)
row_norms_l = 0.0d0
do i = 1, natoms
! self interaction
if (distance_matrix(i,k) > cent_cutoff) then
cycle
endif
prefactor = 1.0d0
if (distance_matrix(i,k) > cent_cutoff - cent_decay) then
prefactor = 0.5d0 * (cos(pi &
& * (distance_matrix(i,k) - cent_cutoff + cent_decay) / cent_decay) + 1)
endif
pair_norm = prefactor * prefactor * 0.5d0 * atomic_charges(i) ** 2.4d0
pair_distance_matrix(i,i,l) = pair_norm
row_norms_l(i) = row_norms_l(i) + pair_norm * pair_norm
do j = i+1, natoms
if (distance_matrix(j,k) > cent_cutoff) then
cycle
endif
if (distance_matrix(i,j) > int_cutoff) then
cycle
endif
pair_norm = prefactor * atomic_charges(i) * atomic_charges(j) &
& / distance_matrix(j, i)
if (distance_matrix(i,j) > int_cutoff - int_decay) then
pair_norm = pair_norm * 0.5d0 * (cos(pi &
& * (distance_matrix(i,j) - int_cutoff + int_decay) / int_decay) + 1)
endif
if (distance_matrix(j,k) > cent_cutoff - cent_decay) then
pair_norm = pair_norm * 0.5d0 * (cos(pi &
& * (distance_matrix(j,k) - cent_cutoff + cent_decay) / cent_decay) + 1)
endif
pair_distance_matrix(i, j, l) = pair_norm
pair_distance_matrix(j, i, l) = pair_norm
pair_norm = pair_norm * pair_norm
row_norms_l(i) = row_norms_l(i) + pair_norm
row_norms_l(j) = row_norms_l(j) + pair_norm
enddo
enddo
row_norms(:,l) = row_norms_l
enddo
!$OMP END PARALLEL DO
! Clean up
deallocate(row_norms_l)
! Allocate temporary
allocate(sorted_atoms_all(natoms, central_natoms))
!$OMP PARALLEL DO PRIVATE(k)
do l = 1, central_natoms
k = central_atom_indices(l)
row_norms(k,l) = huge_double
enddo
!$OMP END PARALLEL DO
!$OMP PARALLEL DO PRIVATE(j,k)
do l = 1, central_natoms
k = central_atom_indices(l)
do i = 1, cutoff_count(k)
j = maxloc(row_norms(:,l), dim=1)
sorted_atoms_all(i, l) = j
row_norms(j,l) = 0.0d0
enddo
enddo
!$OMP END PARALLEL DO
! Clean up
deallocate(row_norms)
! Fill coulomb matrix according to sorted row-2-norms
cm = 0.0d0
!$OMP PARALLEL DO PRIVATE(i, j, k, idx)
do l = 1, central_natoms
k = central_atom_indices(l)
do m = 1, cutoff_count(k)
i = sorted_atoms_all(m, l)
idx = (m*m+m)/2 - m
do n = 1, m
j = sorted_atoms_all(n, l)
cm(l, idx+n) = pair_distance_matrix(i,j,l)
enddo
enddo
enddo
!$OMP END PARALLEL DO
! Clean up
deallocate(sorted_atoms_all)
deallocate(pair_distance_matrix)
end subroutine fgenerate_local_coulomb_matrix
subroutine fgenerate_atomic_coulomb_matrix(central_atom_indices, central_natoms, atomic_charges, &
& coordinates, natoms, nmax, cent_cutoff, cent_decay, int_cutoff, int_decay, cm)
implicit none
integer, dimension(:), intent(in) :: central_atom_indices
integer, intent(in) :: central_natoms
double precision, dimension(:), intent(in) :: atomic_charges
double precision, dimension(:,:), intent(in) :: coordinates
integer,intent(in) :: natoms
integer, intent(in) :: nmax
double precision, intent(inout) :: cent_cutoff, cent_decay, int_cutoff, int_decay
double precision, dimension(central_natoms, ((nmax + 1) * nmax) / 2), intent(out):: cm
integer :: idx
double precision :: pair_norm
double precision :: prefactor
double precision :: norm
double precision :: huge_double
integer, allocatable, dimension(:, :) :: sorted_atoms_all
integer, allocatable, dimension(:) :: cutoff_count
double precision, allocatable, dimension(:, :) :: pair_distance_matrix
double precision, allocatable, dimension(:, :) :: distance_matrix
double precision, allocatable, dimension(:, :) :: distance_matrix_tmp
integer i, j, m, n, k, l
double precision, parameter :: pi = 4.0d0 * atan(1.0d0)
if (size(coordinates, dim=1) /= size(atomic_charges, dim=1)) then
write(*,*) "ERROR: Coulomb matrix generation"
write(*,*) size(coordinates, dim=1), "coordinates, but", &
& size(atomic_charges, dim=1), "atom_types!"
stop
endif
! Allocate temporary
allocate(distance_matrix(natoms,natoms))
allocate(cutoff_count(natoms))
huge_double = huge(distance_matrix(1,1))
if (cent_cutoff < 0) then
cent_cutoff = huge_double
endif
if ((int_cutoff < 0) .OR. (int_cutoff > 2 * cent_cutoff)) then
int_cutoff = 2 * cent_cutoff
endif
if (cent_decay < 0) then
cent_decay = 0.0d0
else if (cent_decay > cent_cutoff) then
cent_decay = cent_cutoff
endif
if (int_decay < 0) then
int_decay = 0.0d0
else if (int_decay > int_cutoff) then
int_decay = int_cutoff
endif
cutoff_count = 1
!$OMP PARALLEL DO PRIVATE(norm) REDUCTION(+:cutoff_count)
do i = 1, natoms
distance_matrix(i, i) = 0.0d0
do j = i+1, natoms
norm = sqrt(sum((coordinates(j,:) - coordinates(i,:))**2))
distance_matrix(i, j) = norm
distance_matrix(j, i) = norm
if (norm < cent_cutoff) then
cutoff_count(i) = cutoff_count(i) + 1
cutoff_count(j) = cutoff_count(j) + 1
endif
enddo
enddo
!$OMP END PARALLEL DO
do i = 1, central_natoms
k = central_atom_indices(i)
if (cutoff_count(k) > nmax) then
write(*,*) "ERROR: Coulomb matrix generation"
write(*,*) nmax, "size set, but", &
& cutoff_count(k), "size needed!"
stop
endif
enddo
! Allocate temporary
allocate(pair_distance_matrix(natoms, natoms))
pair_distance_matrix = 0.0d0
!$OMP PARALLEL DO PRIVATE(pair_norm)
do i = 1, natoms
pair_distance_matrix(i, i) = 0.5d0 * atomic_charges(i) ** 2.4d0
do j = i+1, natoms
if (distance_matrix(j,i) > int_cutoff) then
cycle
endif
pair_norm = atomic_charges(i) * atomic_charges(j) &
& / distance_matrix(j, i)
if (distance_matrix(j,i) > int_cutoff - int_decay) then
pair_norm = pair_norm * 0.5d0 * (cos(pi &
& * (distance_matrix(j,i) - int_cutoff + int_decay) / int_decay) + 1)
endif
pair_distance_matrix(i, j) = pair_norm
pair_distance_matrix(j, i) = pair_norm
enddo
enddo
!$OMP END PARALLEL DO
! Allocate temporary
allocate(distance_matrix_tmp(natoms, natoms))
allocate(sorted_atoms_all(natoms, central_natoms))
distance_matrix_tmp = distance_matrix
!Generate sorted list of atom ids by distance matrix
!$OMP PARALLEL DO PRIVATE(j, k)
do l = 1, central_natoms
k = central_atom_indices(l)
!$OMP CRITICAL
do i = 1, cutoff_count(k)
j = minloc(distance_matrix_tmp(:,k), dim=1)
sorted_atoms_all(i, l) = j
distance_matrix_tmp(j, k) = huge_double
enddo
!$OMP END CRITICAL
enddo
!$OMP END PARALLEL DO
! Clean up
deallocate(distance_matrix_tmp)
! Fill coulomb matrix according to sorted distances
cm = 0.0d0
pair_norm = 0.0d0
!$OMP PARALLEL DO PRIVATE(i, prefactor, idx, j, pair_norm, k)
do l = 1, central_natoms
k = central_atom_indices(l)
do m = 1, cutoff_count(k)
i = sorted_atoms_all(m, l)
if (distance_matrix(i,k) > cent_cutoff) then
cycle
endif
prefactor = 1.0d0
if (distance_matrix(i,k) > cent_cutoff - cent_decay) then
prefactor = 0.5d0 * (cos(pi &
& * (distance_matrix(i,k) - cent_cutoff + cent_decay) &
& / cent_decay) + 1.0d0)
endif
idx = (m*m+m)/2 - m
do n = 1, m
j = sorted_atoms_all(n, l)
pair_norm = prefactor * pair_distance_matrix(i, j)
if (distance_matrix(j,k) > cent_cutoff - cent_decay) then
pair_norm = pair_norm * 0.5d0 * (cos(pi &
& * (distance_matrix(j,k) - cent_cutoff + cent_decay) &
& / cent_decay) + 1)
endif
cm(l, idx+n) = pair_norm
enddo
enddo
enddo
! Clean up
deallocate(distance_matrix)
deallocate(pair_distance_matrix)
deallocate(sorted_atoms_all)
deallocate(cutoff_count)
end subroutine fgenerate_atomic_coulomb_matrix
subroutine fgenerate_eigenvalue_coulomb_matrix(atomic_charges, coordinates, nmax, sorted_eigenvalues)
implicit none
double precision, dimension(:), intent(in) :: atomic_charges
double precision, dimension(:,:), intent(in) :: coordinates
integer, intent(in) :: nmax
double precision, dimension(nmax), intent(out) :: sorted_eigenvalues
double precision :: pair_norm
double precision :: huge_double
double precision, allocatable, dimension(:,:) :: pair_distance_matrix
double precision, allocatable, dimension(:) :: work
double precision, allocatable, dimension(:) :: eigenvalues
integer :: i, j, info, lwork
integer :: natoms
if (size(coordinates, dim=1) /= size(atomic_charges, dim=1)) then
write(*,*) "ERROR: Coulomb matrix generation"
write(*,*) size(coordinates, dim=1), "coordinates, but", &
& size(atomic_charges, dim=1), "atom_types!"
stop
else
natoms = size(atomic_charges, dim=1)
endif
! Allocate temporary
allocate(pair_distance_matrix(nmax,nmax))
huge_double = huge(pair_distance_matrix(1,1))
pair_distance_matrix(:,:) = 0.0d0
!$OMP PARALLEL DO PRIVATE(pair_norm)
do i = 1, natoms
pair_norm = 0.5d0 * atomic_charges(i) ** 2.4d0
pair_distance_matrix(i, i) = pair_norm
enddo
!$OMP END PARALLEL DO
!$OMP PARALLEL DO PRIVATE(pair_norm)
do i = 1, natoms
do j = i+1, natoms
pair_norm = atomic_charges(i) * atomic_charges(j) &
& / sqrt(sum((coordinates(j,:) - coordinates(i,:))**2))
pair_distance_matrix(i, j) = pair_norm
enddo
enddo
!$OMP END PARALLEL DO
lwork = 4 * nmax
! Allocate temporary
allocate(work(lwork))
allocate(eigenvalues(nmax))
call dsyev("N", "U", nmax, pair_distance_matrix, nmax, eigenvalues, work, lwork, info)
if (info > 0) then
write (*,*) "WARNING: Eigenvalue routine DSYEV() exited with error code:", info
endif
! Clean up
deallocate(work)
deallocate(pair_distance_matrix)
!sort
do i = 1, nmax
j = minloc(eigenvalues, dim=1)
sorted_eigenvalues(nmax - i + 1) = eigenvalues(j)
eigenvalues(j) = huge_double
enddo
! Clean up
deallocate(eigenvalues)
end subroutine fgenerate_eigenvalue_coulomb_matrix
subroutine fgenerate_bob(atomic_charges, coordinates, nuclear_charges, id, &
& nmax, ncm, cm)
use representations, only: get_indices
implicit none
double precision, dimension(:), intent(in) :: atomic_charges
double precision, dimension(:,:), intent(in) :: coordinates
integer, dimension(:), intent(in) :: nuclear_charges
integer, dimension(:), intent(in) :: id
integer, dimension(:), intent(in) :: nmax
integer, intent(in) :: ncm
double precision, dimension(ncm), intent(out):: cm
integer :: n, i, j, k, l, idx1, idx2, nid, nbag
integer :: natoms, natoms1, natoms2, type1, type2
integer, allocatable, dimension(:) :: type1_indices
integer, allocatable, dimension(:) :: type2_indices
integer, allocatable, dimension(:) :: start_indices
double precision :: pair_norm
double precision :: huge_double
double precision, allocatable, dimension(:) :: bag
double precision, allocatable, dimension(:,:) :: pair_distance_matrix
if (size(coordinates, dim=1) /= size(atomic_charges, dim=1)) then
write(*,*) "ERROR: Bag of Bonds generation"
write(*,*) size(coordinates, dim=1), "coordinates, but", &
& size(atomic_charges, dim=1), "atom_types!"
stop
else if (size(coordinates, dim=1) /= size(nuclear_charges, dim=1)) then
write(*,*) "ERROR: Coulomb matrix generation"
write(*,*) size(coordinates, dim=1), "coordinates, but", &
& size(nuclear_charges, dim=1), "atom_types!"
stop
else
natoms = size(atomic_charges, dim=1)
endif
if (size(id, dim=1) /= size(nmax, dim=1)) then
write(*,*) "ERROR: Bag of Bonds generation"
write(*,*) size(id, dim=1), "unique atom types, but", &
& size(nmax, dim=1), "max size!"
stop
else
nid = size(id, dim=1)
endif
n = 0
!$OMP PARALLEL DO REDUCTION(+:n)
do i = 1, nid
n = n + nmax(i) * (1 + nmax(i))
do j = 1, i - 1
n = n + 2 * nmax(i) * nmax(j)
enddo
enddo
!$OMP END PARALLEL DO
if (n /= 2*ncm) then
write(*,*) "ERROR: Bag of Bonds generation"
write(*,*) "Inferred vector size", n, "but given size", ncm
stop
endif
! Allocate temporary
allocate(pair_distance_matrix(natoms,natoms))
huge_double = huge(pair_distance_matrix(1,1))
!$OMP PARALLEL DO PRIVATE(pair_norm)
do i = 1, natoms
do j = i+1, natoms
pair_norm = atomic_charges(i) * atomic_charges(j) &
& / sqrt(sum((coordinates(j,:) - coordinates(i,:))**2))
pair_distance_matrix(i, j) = pair_norm
pair_distance_matrix(j, i) = pair_norm
enddo
enddo
!$OMP END PARALLEL DO
! Allocate temporary
! Too large but easier
allocate(type1_indices(maxval(nmax, dim=1)))
allocate(type2_indices(maxval(nmax, dim=1)))
! Get max bag size
nbag = 0
do i = 1, nid
nbag = max(n, (nmax(i) * (nmax(i) - 1))/2)
do j = 1, i - 1
nbag = max(n, nmax(i) * nmax(j))
enddo
enddo
! Allocate temporary
! Too large but easier
allocate(bag(nbag))
allocate(start_indices(nid))
! get start indices
start_indices(1) = 0
do i = 2, nid
start_indices(i) = (nmax(i-1) * (nmax(i-1) + 1)) / 2 + start_indices(i-1)
do j = i, nid
start_indices(i) = start_indices(i) + nmax(j) * nmax(i-1)
enddo
enddo
cm = 0.0d0
!$OMP PARALLEL DO PRIVATE(type1, type1_indices, l, &
!$OMP& bag, natoms1, idx1, idx2, k, nbag, type2, natoms2, type2_indices)
do i = 1, nid
type1 = id(i)
natoms1 = 0
call get_indices(natoms, nuclear_charges, type1, natoms1, type1_indices)
bag = 0.0d0
do j = 1, natoms1
idx1 = type1_indices(j)
cm(start_indices(i) + j) = 0.5d0 * atomic_charges(idx1) ** 2.4d0
k = (j * j - 3 * j) / 2
do l = 1, j - 1
idx2 = type1_indices(l)
bag(k + l + 1) = pair_distance_matrix(idx1, idx2)
enddo
enddo
start_indices(i) = start_indices(i) + nmax(i)
nbag = (nmax(i) * nmax(i) - nmax(i)) / 2
! sort
do j = 1, nbag
k = minloc(bag(:nbag), dim=1)
cm(start_indices(i) + nbag - j + 1) = bag(k)
bag(k) = huge_double
enddo
start_indices(i) = start_indices(i) + nbag
do j = i + 1, nid
type2 = id(j)
natoms2 = 0
call get_indices(natoms, nuclear_charges, type2, natoms2, type2_indices)
bag = 0.0d0
do k = 1, natoms1
idx1 = type1_indices(k)
do l = 1, natoms2
idx2 = type2_indices(l)
bag(natoms2 * (k - 1) + l) = pair_distance_matrix(idx1, idx2)
enddo
enddo
! sort
nbag = nmax(i) * nmax(j)
do k = 1, nbag
l = minloc(bag(:nbag), dim=1)
cm(start_indices(i) + nbag - k + 1) = bag(l)
bag(l) = huge_double
enddo
start_indices(i) = start_indices(i) + nbag
enddo
enddo
!$OMP END PARALLEL DO
! Clean up
deallocate(pair_distance_matrix)
deallocate(bag)
deallocate(type1_indices)
deallocate(type2_indices)
deallocate(start_indices)
end subroutine fgenerate_bob
================================================
FILE: qml/representations/fslatm.f90
================================================
! MIT License
!
! Copyright (c) 2017 Anders Steen Christensen, Bing Huang
!
! Permission is hereby granted, free of charge, to any person obtaining a copy
! of this software and associated documentation files (the "Software"), to deal
! in the Software without restriction, including without limitation the rights
! to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
! copies of the Software, and to permit persons to whom the Software is
! furnished to do so, subject to the following conditions:
!
! The above copyright notice and this permission notice shall be included in all
! copies or substantial portions of the Software.
!
! THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
! IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
! FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
! AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
! LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
! OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
! SOFTWARE.
module slatm_utils
implicit none
contains
function linspace(x0, x1, nx) result(xs)
implicit none
double precision, intent(in) :: x0
double precision, intent(in) :: x1
integer, intent(in) :: nx
double precision, dimension(nx) :: xs
integer :: i
double precision :: step
step = (x1 - x0) / (nx - 1)
!$OMP PARALLEL DO
do i = 1, nx
xs(i) = x0 + (i - 1) * step
enddo
!$OMP END PARALLEL DO
end function linspace
function calc_angle(a, b, c) result(angle)
implicit none
double precision, intent(in), dimension(3) :: a
double precision, intent(in), dimension(3) :: b
double precision, intent(in), dimension(3) :: c
double precision, dimension(3) :: v1
double precision, dimension(3) :: v2
double precision :: cos_angle
double precision :: angle
v1 = a - b
v2 = c - b
v1 = v1 / norm2(v1)
v2 = v2 / norm2(v2)
cos_angle = dot_product(v1,v2)
! Clipping
if (cos_angle > 1.0d0) cos_angle = 1.0d0
if (cos_angle < -1.0d0) cos_angle = -1.0d0
angle = acos(cos_angle)
end function calc_angle
function calc_cos_angle(a, b, c) result(cos_angle)
implicit none
double precision, intent(in), dimension(3) :: a
double precision, intent(in), dimension(3) :: b
double precision, intent(in), dimension(3) :: c
double precision, dimension(3) :: v1
double precision, dimension(3) :: v2
double precision :: cos_angle
v1 = a - b
v2 = c - b
v1 = v1 / norm2(v1)
v2 = v2 / norm2(v2)
cos_angle = dot_product(v1,v2)
end function calc_cos_angle
end module slatm_utils
subroutine fget_sbot(coordinates, nuclear_charges, z1, z2, z3, rcut, nx, dgrid, sigma, coeff, ys)
use slatm_utils, only: linspace, calc_angle, calc_cos_angle
implicit none
double precision, dimension(:,:), intent(in) :: coordinates
double precision, dimension(:), intent(in) :: nuclear_charges
double precision, intent(in) :: rcut
integer, intent(in) :: nx
double precision, intent(in) :: dgrid
double precision, intent(in) :: sigma
double precision, intent(in) :: coeff
double precision, dimension(nx), intent(out) :: ys
! MBtype
integer, intent(in) :: z1, z2, z3
integer, dimension(:), allocatable :: ias1, ias2, ias3
integer :: nias1, nias2, nias3
integer :: ia1, ia2, ia3
double precision, allocatable, dimension(:, :) :: distance_matrix
double precision :: norm
integer :: i, j, k
integer :: natoms
double precision, parameter :: eps = epsilon(0.0d0)
double precision, parameter :: pi = 4.0d0 * atan(1.0d0)
double precision :: d2r
double precision :: c0
double precision :: ang
double precision :: cak
double precision :: cai
double precision :: prefactor
double precision :: r
double precision :: a0, a1
double precision, dimension(nx) :: xs
double precision, dimension(nx) :: cos_xs
double precision :: inv_sigma
natoms = size(coordinates, dim=1)
if (size(coordinates, dim=1) /= size(nuclear_charges, dim=1)) then
write(*,*) "ERROR: Coulomb matrix generation"
write(*,*) size(coordinates, dim=1), "coordinates, but", &
& size(nuclear_charges, dim=1), "atom_types!"
stop
endif
! Allocate temporary
allocate(distance_matrix(natoms, natoms))
distance_matrix = 0.0d0
!$OMP PARALLEL DO PRIVATE(norm)
do i = 1, natoms
do j = i+1, natoms
norm = sqrt(sum((coordinates(j,:) - coordinates(i,:))**2))
distance_matrix(i, j) = norm
distance_matrix(j, i) = norm
enddo
enddo
!$OMP END PARALLEL DO
allocate(ias1(natoms))
allocate(ias2(natoms))
allocate(ias3(natoms))
ias1 = 0
ias2 = 0
ias3 = 0
nias1 = 0
do i = 1, natoms
if (int(nuclear_charges(i)).eq.z1) then
nias1 = nias1 + 1
ias1(nias1) = i
endif
enddo
nias2 = 0
do i = 1, natoms
if (int(nuclear_charges(i)).eq.z2) then
nias2 = nias2 + 1
ias2(nias2) = i
endif
enddo
nias3 = 0
do i = 1, natoms
if (int(nuclear_charges(i)).eq.z3) then
nias3 = nias3 + 1
ias3(nias3) = i
endif
enddo
d2r = pi/180.0d0
a0 = -20.0d0 * d2r
a1 = pi + 20.0d0 * d2r
xs = linspace(a0, a1, nx)
prefactor = 1.0d0 / 3.0d0
c0 = prefactor * (mod(z1,1000)*mod(z2,1000)*mod(z3,1000)) * coeff * dgrid
ys = 0.0d0
inv_sigma = -1.0d0 / (2*sigma**2)
!$OMP PARALLEL DO
do i = 1, nx
cos_xs(i) = cos(xs(i)) * c0
enddo
!$OMP END PARALLEL do
if (z1 == z3) then
!$OMP PARALLEL DO PRIVATE(i,j,k,ang,cai,cak,r) REDUCTION(+:ys) SCHEDULE(DYNAMIC)
do ia1 = 1, nias1
do ia2 = 1, nias2
if (.not. ((distance_matrix(ias1(ia1),ias2(ia2)) > eps) .and. &
& (distance_matrix(ias1(ia1),ias2(ia2)) <= rcut))) cycle
do ia3 = ia1 + 1, nias3
if (distance_matrix(ias1(ia1),ias3(ia3)) > rcut) cycle
if (.not. ((distance_matrix(ias2(ia2),ias3(ia3)) > eps) .and. &
& (distance_matrix(ias2(ia2),ias3(ia3)) <= rcut))) cycle
i = ias1(ia1)
j = ias2(ia2)
k = ias3(ia3)
ang = calc_angle(coordinates(i, :), coordinates(j, :), coordinates(k, :))
cak = calc_cos_angle(coordinates(i, :), coordinates(k, :), coordinates(j, :))
cai = calc_cos_angle(coordinates(k, :), coordinates(i, :), coordinates(j, :))
r = distance_matrix(i,j) * distance_matrix(i,k) * distance_matrix(k,j)
ys = ys + (c0 + cos_xs*cak*cai)/(r**3) * ( exp((xs-ang)**2 * inv_sigma) )
enddo
enddo
enddo
!$OMP END PARALLEL do
else
!$OMP PARALLEL DO PRIVATE(i,j,k,ang,cai,cak,r) REDUCTION(+:ys) SCHEDULE(DYNAMIC)
do ia1 = 1, nias1
do ia2 = 1, nias2
if (.not. ((distance_matrix(ias1(ia1),ias2(ia2)) > eps) .and. &
& (distance_matrix(ias1(ia1),ias2(ia2)) <= rcut))) cycle
do ia3 = 1, nias3
if (distance_matrix(ias1(ia1),ias3(ia3)) > rcut) cycle
if (.not. ((distance_matrix(ias2(ia2),ias3(ia3)) > eps) .and. &
& (distance_matrix(ias2(ia2),ias3(ia3)) <= rcut))) cycle
i = ias1(ia1)
j = ias2(ia2)
k = ias3(ia3)
ang = calc_angle(coordinates(i, :), coordinates(j, :), coordinates(k, :))
cak = calc_cos_angle(coordinates(i, :), coordinates(k, :), coordinates(j, :))
cai = calc_cos_angle(coordinates(k, :), coordinates(i, :), coordinates(j, :))
r = distance_matrix(i,j) * distance_matrix(i,k) * distance_matrix(k,j)
ys = ys + (c0 + cos_xs*cak*cai)/(r**3 ) * ( exp((xs-ang)**2 * inv_sigma) )
enddo
enddo
enddo
!$OMP END PARALLEL do
endif
! !$OMP PARALLEL DO PRIVATE(i,j,k,ang,cai,cak,r) REDUCTION(+:ys) SCHEDULE(DYNAMIC)
! do ia1 = 1, nias1
! do ia2 = 1, nias2
! if (.not. ((distance_matrix(ias1(ia1),ias2(ia2)) > eps) .and. &
! & (distance_matrix(ias1(ia1),ias2(ia2)) <= rcut))) cycle
! do ia3 = 1, nias3
! if ((z1 == z3) .and. (ias1(ia1) < ias3(ia3))) cycle
! if (.not. ((distance_matrix(ias1(ia1),ias3(ia3)) > eps) .and. &
! & (distance_matrix(ias1(ia1),ias3(ia3)) <= rcut))) cycle
! if (.not. ((distance_matrix(ias2(ia2),ias3(ia3)) > eps) .and. &
! & (distance_matrix(ias2(ia2),ias3(ia3)) <= rcut))) cycle
! i = ias1(ia1)
! j = ias2(ia2)
! k = ias3(ia3)
! ang = calc_angle(coordinates(i, :), coordinates(j, :), coordinates(k, :))
! cak = calc_cos_angle(coordinates(i, :), coordinates(k, :), coordinates(j, :))
! cai = calc_cos_angle(coordinates(k, :), coordinates(i, :), coordinates(j, :))
! r = distance_matrix(i,j) * distance_matrix(i,k) * distance_matrix(k,j)
! ! ys = ys + c0 *( (1.0d0 + cos_xs*cak*cai)/(r**3 ) ) * ( exp((xs-ang)**2 * inv_sigma) )
! ys = ys + (c0 + cos_xs*cak*cai)/(r**3 ) * ( exp((xs-ang)**2 * inv_sigma) )
! enddo
! enddo
! enddo
! !$OMP END PARALLEL do
deallocate(ias1)
deallocate(ias2)
deallocate(ias3)
deallocate(distance_matrix)
end subroutine fget_sbot
subroutine fget_sbot_local(coordinates, nuclear_charges, ia_python, z1, z2, z3, rcut, nx, dgrid, sigma, coeff, ys)
use slatm_utils, only: linspace, calc_angle, calc_cos_angle
implicit none
double precision, dimension(:,:), intent(in) :: coordinates
double precision, dimension(:), intent(in) :: nuclear_charges
double precision, intent(in) :: rcut
integer, intent(in) :: nx
integer, intent(in) :: ia_python
double precision, intent(in) :: dgrid
double precision, intent(in) :: sigma
double precision, intent(in) :: coeff
double precision, dimension(nx), intent(out) :: ys
! MBtype
integer, intent(in) :: z1, z2, z3
integer, dimension(:), allocatable :: ias1, ias2, ias3
integer :: nias1, nias2, nias3
integer :: ia1, ia2, ia3
double precision, allocatable, dimension(:, :) :: distance_matrix
double precision :: norm
integer :: i, j, k
integer :: natoms
double precision, parameter :: eps = epsilon(0.0d0)
double precision, parameter :: pi = 4.0d0 * atan(1.0d0)
double precision :: d2r
double precision :: c0
double precision :: ang
double precision :: cak
double precision :: cai
double precision :: prefactor
double precision :: r
double precision :: a0, a1
double precision, dimension(nx) :: xs
double precision, dimension(nx) :: cos_xs
double precision :: inv_sigma
logical :: stop_flag
integer :: ia
ia = ia_python + 1
natoms = size(coordinates, dim=1)
if (size(coordinates, dim=1) /= size(nuclear_charges, dim=1)) then
write(*,*) "ERROR: Coulomb matrix generation"
write(*,*) size(coordinates, dim=1), "coordinates, but", &
& size(nuclear_charges, dim=1), "atom_types!"
stop
endif
! Allocate temporary
allocate(distance_matrix(natoms, natoms))
distance_matrix = 0.0d0
!$OMP PARALLEL DO PRIVATE(norm)
do i = 1, natoms
do j = i+1, natoms
norm = sqrt(sum((coordinates(j,:) - coordinates(i,:))**2))
distance_matrix(i, j) = norm
distance_matrix(j, i) = norm
enddo
enddo
!$OMP END PARALLEL DO
allocate(ias1(natoms))
allocate(ias2(natoms))
allocate(ias3(natoms))
ias1 = 0
ias2 = 0
ias3 = 0
nias1 = 0
do i = 1, natoms
if (int(nuclear_charges(i)).eq.z1) then
nias1 = nias1 + 1
ias1(nias1) = i
endif
enddo
nias2 = 0
do i = 1, natoms
if (int(nuclear_charges(i)).eq.z2) then
nias2 = nias2 + 1
ias2(nias2) = i
endif
enddo
nias3 = 0
do i = 1, natoms
if (int(nuclear_charges(i)).eq.z3) then
nias3 = nias3 + 1
ias3(nias3) = i
endif
enddo
stop_flag = .true.
do ia2 = 1, nias2
if (ias2(ia2) == ia) stop_flag = .false.
enddo
if (stop_flag) return
d2r = pi/180.0d0
a0 = -20.0d0 * d2r
a1 = pi + 20.0d0 * d2r
xs = linspace(a0, a1, nx)
prefactor = 1.0d0 / 3.0d0
c0 = prefactor * (mod(z1,1000)*mod(z2,1000)*mod(z3,1000)) * coeff * dgrid
ys = 0.0d0
inv_sigma = -1.0d0 / (2*sigma**2)
!$OMP PARALLEL DO
do i = 1, nx
cos_xs(i) = cos(xs(i)) * c0
enddo
!$OMP END PARALLEL do
if (z1 == z3) then
!$OMP PARALLEL DO PRIVATE(i,j,k,ang,cai,cak,r) REDUCTION(+:ys) SCHEDULE(DYNAMIC)
do ia1 = 1, nias1
if (.not. ((distance_matrix(ias1(ia1),ia) > eps) .and. &
& (distance_matrix(ias1(ia1),ia) <= rcut))) cycle
do ia3 = ia1 + 1, nias3
if (distance_matrix(ias1(ia1),ias3(ia3)) > rcut) cycle
if (.not. ((distance_matrix(ia,ias3(ia3)) > eps) .and. &
& (distance_matrix(ia,ias3(ia3)) <= rcut))) cycle
i = ias1(ia1)
j = ia
k = ias3(ia3)
ang = calc_angle(coordinates(i, :), coordinates(j, :), coordinates(k, :))
cak = calc_cos_angle(coordinates(i, :), coordinates(k, :), coordinates(j, :))
cai = calc_cos_angle(coordinates(k, :), coordinates(i, :), coordinates(j, :))
r = distance_matrix(i,j) * distance_matrix(i,k) * distance_matrix(k,j)
ys = ys + (c0 + cos_xs*cak*cai)/(r**3) * ( exp((xs-ang)**2 * inv_sigma) )
enddo
enddo
!$OMP END PARALLEL do
else
!$OMP PARALLEL DO PRIVATE(i,j,k,ang,cai,cak,r) REDUCTION(+:ys) SCHEDULE(DYNAMIC)
do ia1 = 1, nias1
if (.not. ((distance_matrix(ias1(ia1),ia) > eps) .and. &
& (distance_matrix(ias1(ia1),ia) <= rcut))) cycle
do ia3 = 1, nias3
if (distance_matrix(ias1(ia1),ias3(ia3)) > rcut) cycle
if (.not. ((distance_matrix(ia,ias3(ia3)) > eps) .and. &
& (distance_matrix(ia,ias3(ia3)) <= rcut))) cycle
i = ias1(ia1)
j = ia
k = ias3(ia3)
ang = calc_angle(coordinates(i, :), coordinates(j, :), coordinates(k, :))
cak = calc_cos_angle(coordinates(i, :), coordinates(k, :), coordinates(j, :))
cai = calc_cos_angle(coordinates(k, :), coordinates(i, :), coordinates(j, :))
r = distance_matrix(i,j) * distance_matrix(i,k) * distance_matrix(k,j)
ys = ys + (c0 + cos_xs*cak*cai)/(r**3 ) * ( exp((xs-ang)**2 * inv_sigma) )
enddo
enddo
!$OMP END PARALLEL do
endif
deallocate(ias1)
deallocate(ias2)
deallocate(ias3)
deallocate(distance_matrix)
end subroutine fget_sbot_local
subroutine fget_sbop(coordinates, nuclear_charges, z1, z2, rcut, nx, dgrid, sigma, coeff, rpower, ys)
use slatm_utils, only: linspace
implicit none
double precision, dimension(:,:), intent(in) :: coordinates
double precision, dimension(:), intent(in) :: nuclear_charges
double precision, intent(in) :: rcut
integer, intent(in) :: nx
double precision, intent(in) :: dgrid
double precision, intent(in) :: sigma
double precision, intent(in) :: rpower
double precision, intent(in) :: coeff
double precision, dimension(nx), intent(out) :: ys
integer, intent(in) :: z1, z2
double precision :: r0
double precision :: r
double precision :: rcut2
integer :: i
integer :: natoms
integer, dimension(:), allocatable :: ias1, ias2
integer :: nias1, nias2
integer :: ia1, ia2
double precision, parameter :: eps = epsilon(0.0d0)
double precision, dimension(nx) :: xs
double precision, parameter :: pi = 4.0d0 * atan(1.0d0)
double precision :: c0
double precision :: inv_sigma
double precision, dimension(nx) :: xs0
natoms = size(coordinates, dim=1)
if (size(coordinates, dim=1) /= size(nuclear_charges, dim=1)) then
write(*,*) "ERROR: Coulomb matrix generation"
write(*,*) size(coordinates, dim=1), "coordinates, but", &
& size(nuclear_charges, dim=1), "atom_types!"
stop
endif
allocate(ias1(natoms))
allocate(ias2(natoms))
ias1 = 0
ias2 = 0
nias1 = 0
do i = 1, natoms
if (int(nuclear_charges(i)).eq.z1) then
nias1 = nias1 + 1
ias1(nias1) = i
endif
enddo
nias2 = 0
do i = 1, natoms
if (int(nuclear_charges(i)).eq.z2) then
nias2 = nias2 + 1
ias2(nias2) = i
endif
enddo
r0 = 0.1d0
xs = linspace(r0, rcut, nx)
ys = 0.0d0
c0 = (mod(z1,1000)*mod(z2,1000)) * coeff
inv_sigma = -0.5d0 / sigma**2
xs0 = c0/(xs**rpower) * dgrid
rcut2 = rcut**2
if (z1.eq.z2) then
!$OMP PARALLEL DO REDUCTION(+:ys)
do ia1 = 1, nias1
do ia2 = ia1 + 1, nias2
r = sum((coordinates(ias1(ia1),:) - coordinates(ias2(ia2),:))**2)
if (r < rcut2) ys = ys + xs0 * exp( inv_sigma * (xs - sqrt(r))**2 )
enddo
enddo
!$OMP END PARALLEL DO
else
!$OMP PARALLEL DO REDUCTION(+:ys)
do ia1 = 1, nias1
do ia2 = 1, nias2
r = sum((coordinates(ias1(ia1),:) - coordinates(ias2(ia2),:))**2)
if (r < rcut2) ys = ys + xs0 * exp( inv_sigma * (xs - sqrt(r))**2 )
enddo
enddo
!$OMP END PARALLEL DO
endif
deallocate(ias1)
deallocate(ias2)
end subroutine fget_sbop
subroutine fget_sbop_local(coordinates, nuclear_charges, ia_python, z1, z2, rcut, nx, dgrid, sigma, coeff, rpower, ys)
use slatm_utils, only: linspace
implicit none
double precision, dimension(:,:), intent(in) :: coordinates
double precision, dimension(:), intent(in) :: nuclear_charges
double precision, intent(in) :: rcut
integer, intent(in) :: nx
integer, intent(in) :: ia_python
double precision, intent(in) :: dgrid
double precision, intent(in) :: sigma
double precision, intent(in) :: rpower
double precision, intent(in) :: coeff
double precision, dimension(nx), intent(out) :: ys
integer, intent(in) :: z1, z2
double precision :: r0
double precision :: r
double precision :: rcut2
integer :: i
integer :: natoms
integer, dimension(:), allocatable :: ias1, ias2
integer :: nias1, nias2
integer :: ia1, ia2
double precision, parameter :: eps = epsilon(0.0d0)
double precision, dimension(nx) :: xs
double precision, parameter :: pi = 4.0d0 * atan(1.0d0)
double precision :: c0
double precision :: inv_sigma
double precision, dimension(nx) :: xs0
integer :: ia
ia = ia_python + 1
natoms = size(coordinates, dim=1)
if (size(coordinates, dim=1) /= size(nuclear_charges, dim=1)) then
write(*,*) "ERROR: Coulomb matrix generation"
write(*,*) size(coordinates, dim=1), "coordinates, but", &
& size(nuclear_charges, dim=1), "atom_types!"
stop
endif
allocate(ias1(natoms))
allocate(ias2(natoms))
ias1 = 0
ias2 = 0
nias1 = 0
do i = 1, natoms
if (int(nuclear_charges(i)).eq.z1) then
nias1 = nias1 + 1
ias1(nias1) = i
endif
enddo
nias2 = 0
do i = 1, natoms
if (int(nuclear_charges(i)).eq.z2) then
nias2 = nias2 + 1
ias2(nias2) = i
endif
enddo
r0 = 0.1d0
xs = linspace(r0, rcut, nx)
ys = 0.0d0
c0 = (mod(z1,1000)*mod(z2,1000)) * coeff
inv_sigma = -0.5d0 / sigma**2
xs0 = c0/(xs**rpower) * dgrid
rcut2 = rcut**2
if (z1.eq.z2) then
!$OMP PARALLEL DO REDUCTION(+:ys)
do ia1 = 1, nias1
do ia2 = ia1 + 1, nias2
if ((ias1(ia1) /= ia).and.(ias2(ia2)/= ia)) cycle
r = sum((coordinates(ias1(ia1),:) - coordinates(ias2(ia2),:))**2)
if (r < rcut2) ys = ys + xs0 * exp( inv_sigma * (xs - sqrt(r))**2 )
enddo
enddo
!$OMP END PARALLEL DO
else
!$OMP PARALLEL DO REDUCTION(+:ys)
do ia1 = 1, nias1
do ia2 = 1, nias2
if ((ias1(ia1) /= ia).and.(ias2(ia2)/= ia)) cycle
r = sum((coordinates(ias1(ia1),:) - coordinates(ias2(ia2),:))**2)
if (r < rcut2) ys = ys + xs0 * exp( inv_sigma * (xs - sqrt(r))**2 )
enddo
enddo
!$OMP END PARALLEL DO
endif
deallocate(ias1)
deallocate(ias2)
end subroutine fget_sbop_local
================================================
FILE: qml/representations/representations.py
================================================
# MIT License
#
# Copyright (c) 2017-2018 Anders Steen Christensen, Lars Andersen Bratholm, Bing Huang
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
from __future__ import print_function
import numpy as np
import itertools as itl
from .frepresentations import fgenerate_coulomb_matrix
from .frepresentations import fgenerate_unsorted_coulomb_matrix
from .frepresentations import fgenerate_local_coulomb_matrix
from .frepresentations import fgenerate_atomic_coulomb_matrix
from .frepresentations import fgenerate_eigenvalue_coulomb_matrix
from .frepresentations import fgenerate_bob
from qml.utils import NUCLEAR_CHARGE
from .slatm import get_boa
from .slatm import get_sbop
from .slatm import get_sbot
from .facsf import fgenerate_acsf, fgenerate_acsf_and_gradients
from .facsf import fgenerate_fchl_acsf, fgenerate_fchl_acsf_and_gradients
def 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
"""
if not (np.sqrt(8*v.shape[0]+1) == int(np.sqrt(8*v.shape[0]+1))):
print("ERROR: Can not make a square matrix.")
exit(1)
n = v.shape[0]
l = (-1 + int(np.sqrt(8*n+1)))//2
M = np.empty((l,l))
index = 0
for i in range(l):
for j in range(l):
if j > i:
continue
M[i,j] = v[index]
M[j,i] = M[i,j]
index += 1
return M
def 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 :math:`M` is constructed with elements
.. math::
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},
where :math:`i` and :math:`j` are atom indices, :math:`Z` is nuclear charge and
:math:`\\bf R` is the coordinate in euclidean space.
If ``sorting = 'row-norm'``, the atom indices are reordered such that
:math:`\\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.
:param nuclear_charges: Nuclear charges of the atoms in the molecule
:type nuclear_charges: numpy array
:param coordinates: 3D Coordinates of the atoms in the molecule
:type coordinates: numpy array
:param size: The size of the largest molecule supported by the representation
:type size: integer
:param sorting: How the atom indices are sorted ('row-norm', 'unsorted')
:type sorting: string
:return: 1D representation - shape (size(size+1)/2,)
:rtype: numpy array
"""
if (sorting == "row-norm"):
return fgenerate_coulomb_matrix(nuclear_charges, \
coordinates, size)
elif (sorting == "unsorted"):
return fgenerate_unsorted_coulomb_matrix(nuclear_charges, \
coordinates, size)
else:
print("ERROR: Unknown sorting scheme requested")
raise SystemExit
def generate_atomic_coulomb_matrix(nuclear_charges, coordinates, size = 23, sorting = "distance",
central_cutoff = 1e6, central_decay = -1, interaction_cutoff = 1e6, interaction_decay = -1,
indices = None):
""" Creates a Coulomb Matrix representation of the local environment of a central atom.
For each central atom :math:`k`, a matrix :math:`M` is constructed with elements
.. math::
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},
where :math:`i`, :math:`j` and :math:`k` are atom indices, :math:`Z` is nuclear charge and
:math:`\\bf R` is the coordinate in euclidean space.
:math:`f_{ij}` is a function that masks long range effects:
.. math::
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},
where the parameters ``central_cutoff`` and ``central_decay`` corresponds to the variables
:math:`r` and :math:`\Delta r` respectively for interactions involving the central atom,
and ``interaction_cutoff`` and ``interaction_decay`` corresponds to the variables
:math:`r` and :math:`\Delta r` respectively for interactions not involving the central atom.
if ``sorting = 'row-norm'``, the atom indices are ordered such that
:math:`\\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
.. math::
\\|{\\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 :math:`[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.
:param nuclear_charges: Nuclear charges of the atoms in the molecule
:type nuclear_charges: numpy array
:param coordinates: 3D Coordinates of the atoms in the molecule
:type coordinates: numpy array
:param size: The size of the largest molecule supported by the representation
:type size: integer
:param sorting: How the atom indices are sorted ('row-norm', 'distance')
:type sorting: string
:param central_cutoff: The distance from the central atom, where the coulomb interaction
element will be zero
:type central_cutoff: float
:param central_decay: The distance over which the the coulomb interaction decays from full to none
:type central_decay: float
:param interaction_cutoff: The distance between two non-central atom, where the coulomb interaction
element will be zero
:type interaction_cutoff: float
:param interaction_decay: The distance over which the the coulomb interaction decays from full to none
:type interaction_decay: float
:param indices: Subset indices or atomtype
:type indices: Nonetype/array/string
:return: nD representation - shape (:math:`N_{atoms}`, size(size+1)/2)
:rtype: numpy array
"""
if indices == None:
nindices = len(nuclear_charges)
indices = np.arange(1,1+nindices, 1, dtype = int)
elif type("") == type(indices):
if indices in NUCLEAR_CHARGE:
indices = np.where(nuclear_charges == NUCLEAR_CHARGE[indices])[0] + 1
nindices = indices.size
if nindices == 0:
return np.zeros((0,0))
else:
print("ERROR: Unknown value %s given for 'indices' variable" % indices)
raise SystemExit
else:
indices = np.asarray(indices, dtype = int) + 1
nindices = indices.size
if (sorting == "row-norm"):
return fgenerate_local_coulomb_matrix(indices, nindices, nuclear_charges,
coordinates, nuclear_charges.size, size,
central_cutoff, central_decay, interaction_cutoff, interaction_decay)
elif (sorting == "distance"):
return fgenerate_atomic_coulomb_matrix(indices, nindices, nuclear_charges,
coordinates, nuclear_charges.size, size,
central_cutoff, central_decay, interaction_cutoff, interaction_decay)
else:
print("ERROR: Unknown sorting scheme requested")
raise SystemExit
def generate_eigenvalue_coulomb_matrix(nuclear_charges, coordinates, size = 23):
""" Creates an eigenvalue Coulomb Matrix representation of a molecule.
A matrix :math:`M` is constructed with elements
.. math::
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},
where :math:`i` and :math:`j` are atom indices, :math:`Z` is nuclear charge and
:math:`\\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.
:param nuclear_charges: Nuclear charges of the atoms in the molecule
:type nuclear_charges: numpy array
:param coordinates: 3D Coordinates of the atoms in the molecule
:type coordinates: numpy array
:param size: The size of the largest molecule supported by the representation
:type size: integer
:return: 1D representation - shape (size, )
:rtype: numpy array
"""
return fgenerate_eigenvalue_coulomb_matrix(nuclear_charges,
coordinates, size)
def generate_bob(nuclear_charges, coordinates, atomtypes, size=23, asize = {"O":3, "C":7, "N":3, "H":16, "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 :math:`I` is given by
:math:`\\tfrac{1}{2} Z_{I}^{2.4}`,
with :math:`Z_{i}` being the nuclear charge of element :math:`i`
The interaction between atom :math:`i` of element :math:`I` and
atom :math:`j` of element :math:`J` is given by
:math:`\\frac{Z_{I}Z_{J}}{\\| {\\bf R}_{i} - {\\bf R}_{j}\\|}`
with :math:`R_{i}` being the euclidean coordinate of atom :math:`i`.
The sorted bags are concatenated to an 1D vector representation.
The representation is calculated using an OpenMP parallel Fortran routine.
:param nuclear_charges: Nuclear charges of the atoms in the molecule
:type nuclear_charges: numpy array
:param coordinates: 3D Coordinates of the atoms in the molecule
:type coordinates: numpy array
:param size: The maximum number of atoms in the representation
:type size: integer
:param asize: The maximum number of atoms of each element type supported by the representation
:type asize: dictionary
:return: 1D representation
:rtype: numpy array
"""
n = 0
atoms = sorted(asize, key=asize.get)
nmax = [asize[key] for key in atoms]
ids = np.zeros(len(nmax), dtype=int)
for i, (key, value) in enumerate(zip(atoms,nmax)):
n += value * (1+value)
ids[i] = NUCLEAR_CHARGE[key]
for j in range(i):
v = nmax[j]
n += 2 * value * v
n /= 2
return fgenerate_bob(nuclear_charges, coordinates, nuclear_charges, ids, nmax, n)
def 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.
:param nuclear_charges: A list of the nuclear charges for each compound in the dataset.
:type nuclear_charges: list of numpy arrays
:param pbc: periodic boundary condition along x,y,z direction, defaulted to '000', i.e., molecule
:type pbc: string
:return: A list containing the types of many-body terms.
:rtype: list
"""
zs = nuclear_charges
nm = len(zs)
zsmax = set()
nas = []
zs_ravel = []
for zsi in zs:
na = len(zsi); nas.append(na)
zsil = list(zsi); zs_ravel += zsil
zsmax.update( zsil )
zsmax = np.array( list(zsmax) )
nass = []
for i in range(nm):
zsi = np.array(zs[i],np.int)
nass.append( [ (zi == zsi).sum() for zi in zsmax ] )
nzmax = np.max(np.array(nass), axis=0)
nzmax_u = []
if pbc != '000':
# the PBC will introduce new many-body terms, so set
# nzmax to 3 if it's less than 3
for nzi in nzmax:
if nzi <= 2:
nzi = 3
nzmax_u.append(nzi)
nzmax = nzmax_u
boas = [ [zi,] for zi in zsmax ]
bops = [ [zi,zi] for zi in zsmax ] + list( itl.combinations(zsmax,2) )
bots = []
for i in zsmax:
for bop in bops:
j,k = bop
tas = [ [i,j,k], [i,k,j], [j,i,k] ]
for tasi in tas:
if (tasi not in bots) and (tasi[::-1] not in bots):
nzsi = [ (zj == tasi).sum() for zj in zsmax ]
if np.all(nzsi <= nzmax):
bots.append( tasi )
mbtypes = boas + bops + bots
return mbtypes #, np.array(zs_ravel), np.array(nas)
def 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).
:param coordinates: Input coordinates
:type coordinates: numpy array
:param nuclear_charges: List of nuclear charges.
:type nuclear_charges: numpy array
:param mbtypes: Many-body types for the whole dataset, including 1-, 2- and 3-body types. Could be obtained by calling ``get_slatm_mbtypes()``.
:type mbtypes: list
:param local: Generate a local representation. Defaulted to False (i.e., global representation); otherwise, atomic version.
:type local: bool
:param sigmas: 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.
:type sigmas: list
:param dgrids: The interval between two sampled internuclear distances and angles, defaulted to [0.03,0.03], no need for change, compromised for speed and accuracy.
:type dgrids: list
:param rcut: Cut-off radius, defaulted to 4.8 Angstrom.
:type rcut: float
:param alchemy: Swith to use the alchemy version of SLATM. (default=False)
:type alchemy: bool
:param pbc: defaulted to '000', meaning it's a molecule; the three digits in the string corresponds to x,y,z direction
:type pbc: string
:param rpower: The power of R in 2-body potential, defaulted to London potential (=6).
:type rpower: float
:return: 1D SLATM representation
:rtype: numpy array
"""
c = unit_cell
iprt=False
if c is None:
c = np.array([[1,0,0],[0,1,0],[0,0,1]])
if pbc != '000':
# print(' -- handling systems with periodic boundary condition')
assert c != None, 'ERROR: Please specify unit cell for SLATM'
# =======================================================================
# PBC may introduce new many-body terms, so at the stage of get statistics
# info from db, we've already considered this point by letting maximal number
# of nuclear charges being 3.
# =======================================================================
zs = nuclear_charges
na = len(zs)
coords = coordinates
obj = [ zs, coords, c ]
iloc = local
if iloc:
mbs = []
X2Ns = []
for ia in range(na):
# if iprt: print ' -- ia = ', ia + 1
n1 = 0; n2 = 0; n3 = 0
mbs_ia = np.zeros(0)
icount = 0
for mbtype in mbtypes:
if len(mbtype) == 1:
mbsi = get_boa(mbtype[0], np.array([zs[ia],]))
#print ' -- mbsi = ', mbsi
if alchemy:
n1 = 1
n1_0 = mbs_ia.shape[0]
if n1_0 == 0:
mbs_ia = np.concatenate( (mbs_ia, mbsi), axis=0 )
elif n1_0 == 1:
mbs_ia += mbsi
else:
raise '#ERROR'
else:
n1 += len(mbsi)
mbs_ia = np.concatenate( (mbs_ia, mbsi), axis=0 )
elif len(mbtype) == 2:
#print ' 001, pbc = ', pbc
mbsi = get_sbop(mbtype, obj, iloc=iloc, ia=ia, \
sigma=sigmas[0], dgrid=dgrids[0], rcut=rcut, \
pbc=pbc, rpower=rpower)
mbsi *= 0.5 # only for the two-body parts, local rpst
#print ' 002'
if alchemy:
n2 = len(mbsi)
n2_0 = mbs_ia.shape[0]
if n2_0 == n1:
mbs_ia = np.concatenate( (mbs_ia, mbsi), axis=0 )
elif n2_0 == n1 + n2:
t = mbs_ia[n1:n1+n2] + mbsi
mbs_ia[n1:n1+n2] = t
else:
raise '#ERROR'
else:
n2 += len(mbsi)
mbs_ia = np.concatenate( (mbs_ia, mbsi), axis=0 )
else: # len(mbtype) == 3:
mbsi = get_sbot(mbtype, obj, iloc=iloc, ia=ia, \
sigma=sigmas[1], dgrid=dgrids[1], rcut=rcut, pbc=pbc)
if alchemy:
n3 = len(mbsi)
n3_0 = mbs_ia.shape[0]
if n3_0 == n1 + n2:
mbs_ia = np.concatenate( (mbs_ia, mbsi), axis=0 )
elif n3_0 == n1 + n2 + n3:
t = mbs_ia[n1+n2:n1+n2+n3] + mbsi
mbs_ia[n1+n2:n1+n2+n3] = t
else:
raise '#ERROR'
else:
n3 += len(mbsi)
mbs_ia = np.concatenate( (mbs_ia, mbsi), axis=0 )
mbs.append( mbs_ia )
X2N = [n1,n2,n3];
if X2N not in X2Ns:
X2Ns.append(X2N)
assert len(X2Ns) == 1, '#ERROR: multiple `X2N ???'
else:
n1 = 0; n2 = 0; n3 = 0
mbs = np.zeros(0)
for mbtype in mbtypes:
if len(mbtype) == 1:
mbsi = get_boa(mbtype[0], zs)
if alchemy:
n1 = 1
n1_0 = mbs.shape[0]
if n1_0 == 0:
mbs = np.concatenate( (mbs, [sum(mbsi)] ), axis=0 )
elif n1_0 == 1:
mbs += sum(mbsi )
else:
raise '#ERROR'
else:
n1 += len(mbsi)
mbs = np.concatenate( (mbs, mbsi), axis=0 )
elif len(mbtype) == 2:
mbsi = get_sbop(mbtype, obj, sigma=sigmas[0], \
dgrid=dgrids[0], rcut=rcut, rpower=rpower)
if alchemy:
n2 = len(mbsi)
n2_0 = mbs.shape[0]
if n2_0 == n1:
mbs = np.concatenate( (mbs, mbsi), axis=0 )
elif n2_0 == n1 + n2:
t = mbs[n1:n1+n2] + mbsi
mbs[n1:n1+n2] = t
else:
raise '#ERROR'
else:
n2 += len(mbsi)
mbs = np.concatenate( (mbs, mbsi), axis=0 )
else: # len(mbtype) == 3:
mbsi = get_sbot(mbtype, obj, sigma=sigmas[1], \
dgrid=dgrids[1], rcut=rcut)
if alchemy:
n3 = len(mbsi)
n3_0 = mbs.shape[0]
if n3_0 == n1 + n2:
mbs = np.concatenate( (mbs, mbsi), axis=0 )
elif n3_0 == n1 + n2 + n3:
t = mbs[n1+n2:n1+n2+n3] + mbsi
mbs[n1+n2:n1+n2+n3] = t
else:
raise '#ERROR'
else:
n3 += len(mbsi)
mbs = np.concatenate( (mbs, mbsi), axis=0 )
return mbs
def generate_acsf(nuclear_charges, coordinates, elements = [1,6,7,8,16], nRs2 = 3, nRs3 = 3, nTs = 3, eta2 = 1,
eta3 = 1, zeta = 1, rcut = 5, acut = 5, bin_min=0.8, gradients = False, pad=None):
"""
Generate the variant of atom-centered symmetry functions used in https://doi.org/10.1039/C7SC04934J
:param nuclear_charges: List of nuclear charges.
:type nuclear_charges: numpy array
:param coordinates: Input coordinates
:type coordinates: numpy array
:param elements: list of unique nuclear charges (atom types)
:type elements: numpy array
:param nRs2: Number of gaussian basis functions in the two-body terms
:type nRs2: integer
:param nRs3: Number of gaussian basis functions in the three-body radial part
:type nRs3: integer
:param nTs: Number of basis functions in the three-body angular part
:type nTs: integer
:param eta2: Precision in the gaussian basis functions in the two-body terms
:type eta2: float
:param eta3: Precision in the gaussian basis functions in the three-body radial part
:type eta3: float
:param zeta: Precision parameter of basis functions in the three-body angular part
:type zeta: float
:param rcut: Cut-off radius of the two-body terms
:type rcut: float
:param acut: Cut-off radius of the three-body terms
:type acut: float
:param bin_min: the value at which to start binning the distances
:type bin_min: positive float
:param gradients: To return gradients or not
:type gradients: boolean
:param pad: `None` if no padding is to be applied other, otherwise an integer corresponding to the desired size
:type gradients: NoneType or integer
:return: Atom-centered symmetry functions representation
:rtype: numpy array
"""
Rs2 = np.linspace(bin_min, rcut, nRs2)
Rs3 = np.linspace(bin_min, acut, nRs3)
Ts = np.linspace(0, np.pi, nTs)
n_elements = len(elements)
natoms = len(coordinates)
descr_size = n_elements * nRs2 + (n_elements * (n_elements + 1)) // 2 * nRs3*nTs
if gradients is False:
rep = fgenerate_acsf(coordinates, nuclear_charges, elements, Rs2, Rs3,
Ts, eta2, eta3, zeta, rcut, acut, natoms, descr_size)
if pad is not None:
rep_pad = np.zeros((pad, descr_size))
rep_pad[:natoms,:] += rep
return rep_pad
else:
return rep
else:
(rep, grad) = fgenerate_acsf_and_gradients(coordinates, nuclear_charges, elements, Rs2, Rs3,
Ts, eta2, eta3, zeta, rcut, acut, natoms, descr_size)
if pad is not None:
rep_pad = np.zeros((pad, descr_size))
grad_pad = np.zeros((pad, descr_size, pad, 3))
rep_pad[:natoms,:] += rep
grad_pad[:natoms,:,:natoms,:] += grad
return rep_pad, grad_pad
else:
return rep, grad
def generate_fchl_acsf(nuclear_charges, coordinates, elements = [1,6,7,8,16],
nRs2=24, nRs3=20, nFourier=1, eta2=0.32, eta3=2.7, zeta=np.pi, rcut=8.0, acut=8.0,
two_body_decay=1.8, three_body_decay=0.57, three_body_weight=13.4,
pad=False, gradients=False):
"""
FCHL-ACSF
Reasonable hyperparameters:
Sigma ~ 21.0
Lambda ~ 1e-8
Max singular value ~ 1e-12
:param nuclear_charges: List of nuclear charges.
:type nuclear_charges: numpy array
:param coordinates: Input coordinates
:type coordinates: numpy array
:param elements: list of unique nuclear charges (atom types)
:type elements: numpy array
:param nRs2: Number of gaussian basis functions in the two-body terms
:type nRs2: integer
:param nRs3: Number of gaussian basis functions in the three-body radial part
:type nRs3: integer
:param nFourier: Order of Fourier expansion
:type nFourier: integer
:param eta2: Precision in the gaussian basis functions in the two-body terms
:type eta2: float
:param eta3: Precision in the gaussian basis functions in the three-body radial part
:type eta3: float
:param zeta: Precision parameter of basis functions in the three-body angular part
:type zeta: float
:param rcut: Cut-off radius of the two-body terms
:type rcut: float
:param acut: Cut-off radius of the three-body terms
:type acut: float
:param gradients: To return gradients or not
:type gradients: boolean
:return: Atom-centered symmetry functions representation
:rtype: numpy array
"""
Rs2 = np.linspace(0, rcut, 1+nRs2)[1:]
Rs3 = np.linspace(0, acut, 1+nRs3)[1:]
Ts = np.linspace(0, np.pi, 2*nFourier)
n_elements = len(elements)
natoms = len(coordinates)
descr_size = n_elements * nRs2 + (n_elements * (n_elements + 1)) * nRs3* nFourier
# Normalization constant for three-body
three_body_weight = np.sqrt(eta3/np.pi) * three_body_weight
if gradients is False:
rep = fgenerate_fchl_acsf(coordinates, nuclear_charges, elements, Rs2, Rs3,
Ts, eta2, eta3, zeta, rcut, acut, natoms, descr_size,
two_body_decay, three_body_decay, three_body_weight)
if pad is not False:
rep_pad = np.zeros((pad, descr_size))
rep_pad[:natoms,:] += rep
return rep_pad
else:
return rep
else:
if (nFourier > 1):
print("Error: FCHL-ACSF only supports nFourier=1, requested", nfourier)
exit()
(rep, grad) = fgenerate_fchl_acsf_and_gradients(coordinates, nuclear_charges, elements, Rs2, Rs3,
Ts, eta2, eta3, zeta, rcut, acut, natoms, descr_size,
two_body_decay, three_body_decay, three_body_weight)
if pad is not False:
rep_pad = np.zeros((pad, descr_size))
grad_pad = np.zeros((pad, descr_size, pad, 3))
rep_pad[:natoms,:] += rep
grad_pad[:natoms,:,:natoms,:] += grad
return rep_pad, grad_pad
else:
return rep, grad
================================================
FILE: qml/representations/slatm.py
================================================
# MIT License
#
# Copyright (c) 2016 Bing Huang and Anders S. Christensen
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
from __future__ import print_function
import scipy.spatial.distance as ssd
import itertools as itl
import numpy as np
from .fslatm import fget_sbot
from .fslatm import fget_sbot_local
from .fslatm import fget_sbop
from .fslatm import fget_sbop_local
def update_m(obj, ia, rcut=9.0, pbc=None):
"""
retrieve local structure around atom `ia
for periodic systems (or very large system)
"""
zs, coords, c = obj
v1, v2, v3 = c
vs = ssd.norm(c, axis=0)
nns = []
for i,vi in enumerate(vs):
n1_doulbe = rcut/li
n1 = int(n1_doulbe)
if n1 - n1_doulbe == 0:
n1s = range(-n1, n1+1) if pbc[i] else [0,]
elif n1 == 0:
n1s = [-1,0,1] if pbc[i] else [0,]
else:
n1s = range(-n1-1, n1+2) if pbc[i] else [0,]
nns.append(n1s)
n1s,n2s,n3s = nns
n123s_ = np.array( list( itl.product(n1s,n2s,n3s) ) )
n123s = []
for n123 in n123s_:
n123u = list(n123)
if n123u != [0,0,0]: n123s.append(n123u)
nau = len(n123s)
n123s = np.array(n123s, np.float)
na = len(zs)
cia = coords[ia]
if na == 1:
ds = np.array([[0.]])
else:
ds = ssd.squareform( ssd.pdist(coords) )
zs_u = []; coords_u = []
zs_u.append( zs[ia] ); coords_u.append( coords[ia] )
for i in range(na) :
di = ds[i,ia]
if (di > 0) and (di <= rcut):
zs_u.append(zs[i]); coords_u.append(coords[ia])
# add new coords by translation
ts = np.zeros((nau,3))
for iau in range(nau):
ts[iau] = np.dot(n123s[iau],c)
coords_iu = coords[i] + ts #np.dot(n123s, c)
dsi = ssd.norm(coords_iu - cia, axis=1);
filt = np.logical_and(dsi > 0, dsi <= rcut); nx = filt.sum()
zs_u += [zs[i],]*nx
coords_u += [ list( coords_iu[filt,:] ), ]
obj_u = [zs_u, coords_u]
return obj_u
def get_boa(z1, zs_):
return z1*np.array( [(zs_ == z1).sum(), ])
#return -0.5*z1**2.4*np.array( [(zs_ == z1).sum(), ])
def get_sbop(mbtype, obj, iloc=False, ia=None, normalize=True, sigma=0.05, \
rcut=4.8, dgrid=0.03, pbc='000', rpower=6):
"""
two-body terms
:param obj: molecule object, consisting of two parts: [ zs, coords ]
:type obj: list
"""
z1, z2 = mbtype
zs, coords, c = obj
if iloc:
assert ia != None, '#ERROR: plz specify `za and `ia '
if pbc != '000':
if rcut < 9.0: raise '#ERROR: rcut too small for systems with pbc'
assert iloc, '#ERROR: for periodic system, plz use atomic rpst'
zs, coords = update_m(obj, ia, rcut=rcut, pbc=pbc)
# after update of `m, the query atom `ia will become the first atom
ia = 0
# bop potential distribution
r0 = 0.1
nx = int((rcut - r0)/dgrid) + 1
coeff = 1/np.sqrt(2*sigma**2*np.pi) if normalize else 1.0
if iloc:
ys = fget_sbop_local(coords, zs, ia, z1, z2, rcut, nx, dgrid, sigma, coeff, rpower)
else:
ys = fget_sbop(coords, zs, z1, z2, rcut, nx, dgrid, sigma, coeff, rpower)
return ys
def get_sbot(mbtype, obj, iloc=False, ia=None, normalize=True, sigma=0.05, \
rcut=4.8, dgrid=0.0262, pbc='000'):
"""
sigma -- standard deviation of gaussian distribution centered on a specific angle
defaults to 0.05 (rad), approximately 3 degree
dgrid -- step of angle grid
defaults to 0.0262 (rad), approximately 1.5 degree
"""
z1, z2, z3 = mbtype
zs, coords, c = obj
if iloc:
assert ia != None, '#ERROR: plz specify `za and `ia '
if pbc != '000':
assert iloc, '#ERROR: for periodic system, plz use atomic rpst'
zs, coords = update_m(obj, ia, rcut=rcut, pbc=pbc)
# after update of `m, the query atom `ia will become the first atom
ia = 0
# for a normalized gaussian distribution, u should multiply this coeff
coeff = 1/np.sqrt(2*sigma**2*np.pi) if normalize else 1.0
# Setup grid in Python
d2r = np.pi/180 # degree to rad
a0 = -20.0*d2r
a1 = np.pi + 20.0*d2r
nx = int((a1-a0)/dgrid) + 1
if iloc:
ys = fget_sbot_local(coords, zs, ia, z1, z2, z3, rcut, nx, dgrid, sigma, coeff)
else:
ys = fget_sbot(coords, zs, z1, z2, z3, rcut, nx, dgrid, sigma, coeff)
return ys
================================================
FILE: qml/utils/__init__.py
================================================
# MIT License
#
# Copyright (c) 2017-2018 Silvia Amabilino, Lars Andersen Bratholm
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
from . import alchemy
from .utils import *
from .alchemy import ELEMENT_NAME, NUCLEAR_CHARGE
================================================
FILE: qml/utils/alchemy.py
================================================
# MIT License
#
# Copyright (c) 2017 Anders Steen Christensen and Felix A. Faber
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
from __future__ import division
from __future__ import print_function
import numpy as np
from copy import copy
ELEMENT_NAME = {
1: 'H' ,
2: 'He' ,
3: 'Li' ,
4: 'Be' ,
5: 'B' ,
6: 'C' ,
7: 'N' ,
8: 'O' ,
9: 'F' ,
10: 'Ne' ,
11: 'Na' ,
12: 'Mg' ,
13: 'Al' ,
14: 'Si' ,
15: 'P' ,
16: 'S' ,
17: 'Cl' ,
18: 'Ar' ,
19: 'K' ,
20: 'Ca' ,
21: 'Sc' ,
22: 'Ti' ,
23: 'V' ,
24: 'Cr' ,
25: 'Mn' ,
26: 'Fe' ,
27: 'Co' ,
28: 'Ni' ,
29: 'Cu' ,
30: 'Zn' ,
31: 'Ga' ,
32: 'Ge' ,
33: 'As' ,
34: 'Se' ,
35: 'Br' ,
36: 'Kr' ,
37: 'Rb' ,
38: 'Sr' ,
39: 'Y' ,
40: 'Zr' ,
41: 'Nb' ,
42: 'Mo' ,
43: 'Tc' ,
44: 'Ru' ,
45: 'Rh' ,
46: 'Pd' ,
47: 'Ag' ,
48: 'Cd' ,
49: 'In' ,
50: 'Sn' ,
51: 'Sb' ,
52: 'Te' ,
53: 'I' ,
54: 'Xe' ,
55: 'Cs' ,
56: 'Ba' ,
57: 'La' ,
58: 'Ce' ,
59: 'Pr' ,
60: 'Nd' ,
61: 'Pm' ,
62: 'Sm' ,
63: 'Eu' ,
64: 'Gd' ,
65: 'Tb' ,
66: 'Dy' ,
67: 'Ho' ,
68: 'Er' ,
69: 'Tm' ,
70: 'Yb' ,
71: 'Lu' ,
72: 'Hf' ,
73: 'Ta' ,
74: 'W' ,
75: 'Re' ,
76: 'Os' ,
77: 'Ir' ,
78: 'Pt' ,
79: 'Au' ,
80: 'Hg' ,
81: 'Tl' ,
82: 'Pb' ,
83: 'Bi' ,
84: 'Po' ,
85: 'At' ,
86: 'Rn' ,
87: 'Fr' ,
88: 'Ra' ,
89: 'Ac' ,
90: 'Th' ,
91: 'Pa' ,
92: 'U' ,
93: 'Np' ,
94: 'Pu' ,
95: 'Am' ,
96: 'Cm' ,
97: 'Bk' ,
98: 'Cf' ,
99: 'Es' ,
100: 'Fm' ,
101: 'Md' ,
102: 'No' ,
103: 'Lr' ,
104: 'Rf' ,
105: 'Db' ,
106: 'Sg' ,
107: 'Bh' ,
108: 'Hs' ,
109: 'Mt' ,
110: 'Ds' ,
111: 'Rg' ,
112: 'Cn' ,
114: 'Uuq',
116: 'Uuh'}
NUCLEAR_CHARGE = {
'H' : 1,
'He' : 2,
'Li' : 3,
'Be' : 4,
'B' : 5,
'C' : 6,
'N' : 7,
'O' : 8,
'F' : 9,
'Ne' : 10,
'Na' : 11,
'Mg' : 12,
'Al' : 13,
'Si' : 14,
'P' : 15,
'S' : 16,
'Cl' : 17,
'Ar' : 18,
'K' : 19,
'Ca' : 20,
'Sc' : 21,
'Ti' : 22,
'V' : 23,
'Cr' : 24,
'Mn' : 25,
'Fe' : 26,
'Co' : 27,
'Ni' : 28,
'Cu' : 29,
'Zn' : 30,
'Ga' : 31,
'Ge' : 32,
'As' : 33,
'Se' : 34,
'Br' : 35,
'Kr' : 36,
'Rb' : 37,
'Sr' : 38,
'Y' : 39,
'Zr' : 40,
'Nb' : 41,
'Mo' : 42,
'Tc' : 43,
'Ru' : 44,
'Rh' : 45,
'Pd' : 46,
'Ag' : 47,
'Cd' : 48,
'In' : 49,
'Sn' : 50,
'Sb' : 51,
'Te' : 52,
'I' : 53,
'Xe' : 54,
'Cs' : 55,
'Ba' : 56,
'La' : 57,
'Ce' : 58,
'Pr' : 59,
'Nd' : 60,
'Pm' : 61,
'Sm' : 62,
'Eu' : 63,
'Gd' : 64,
'Tb' : 65,
'Dy' : 66,
'Ho' : 67,
'Er' : 68,
'Tm' : 69,
'Yb' : 70,
'Lu' : 71,
'Hf' : 72,
'Ta' : 73,
'W' : 74,
'Re' : 75,
'Os' : 76,
'Ir' : 77,
'Pt' : 78,
'Au' : 79,
'Hg' : 80,
'Tl' : 81,
'Pb' : 82,
'Bi' : 83,
'Po' : 84,
'At' : 85,
'Rn' : 86,
'Fr' : 87,
'Ra' : 88,
'Ac' : 89,
'Th' : 90,
'Pa' : 91,
'U' : 92,
'Np' : 93,
'Pu' : 94,
'Am' : 95,
'Cm' : 96,
'Bk' : 97,
'Cf' : 98,
'Es' : 99,
'Fm' : 100,
'Md' : 101,
'No' : 102,
'Lr' : 103,
'Rf' : 104,
'Db' : 105,
'Sg' : 106,
'Bh' : 107,
'Hs' : 108,
'Mt' : 109,
'Ds' : 110,
'Rg' : 111,
'Cn' : 112,
'Uuq': 114,
'Uuh': 116}
# Periodic table indexes
PTP = {
1 :[1,1] ,2: [1,8]#Row1
,3 :[2,1] ,4: [2,2]#Row2\
,5 :[2,3] ,6: [2,4] ,7 :[2,5] ,8 :[2,6] ,9 :[2,7] ,10 :[2,8]\
,11 :[3,1] ,12: [3,2]#Row3\
,13 :[3,3] ,14: [3,4] ,15 :[3,5] ,16 :[3,6] ,17 :[3,7] ,18 :[3,8]\
,19 :[4,1] ,20: [4,2]#Row4\
,31 :[4,3] ,32: [4,4] ,33 :[4,5] ,34 :[4,6] ,35 :[4,7] ,36 :[4,8]\
,21 :[4,9] ,22: [4,10],23 :[4,11],24 :[4,12],25 :[4,13],26 :[4,14],27 :[4,15],28 :[4,16],29 :[4,17],30 :[4,18]\
,37 :[5,1] ,38: [5,2]#Row5\
,49 :[5,3] ,50: [5,4] ,51 :[5,5] ,52 :[5,6] ,53 :[5,7] ,54 :[5,8]\
,39 :[5,9] ,40: [5,10],41 :[5,11],42 :[5,12],43 :[5,13],44 :[5,14],45 :[5,15],46 :[5,16],47 :[5,17],48 :[5,18]\
,55 :[6,1] ,56: [6,2]#Row6\
,81 :[6,3] ,82: [6,4] ,83 :[6,5] ,84 :[6,6] ,85 :[6,7] ,86 :[6,8]
,72: [6,10],73 :[6,11],74 :[6,12],75 :[6,13],76 :[6,14],77 :[6,15],78 :[6,16],79 :[6,17],80 :[6,18]\
,57 :[6,19],58: [6,20],59 :[6,21],60 :[6,22],61 :[6,23],62 :[6,24],63 :[6,25],64 :[6,26],65 :[6,27],66 :[6,28],67 :[6,29],68 :[6,30],69 :[6,31],70 :[6,32],71 :[6,33]\
,87 :[7,1] ,88: [7,2]#Row7\
,113:[7,3] ,114:[7,4] ,115:[7,5] ,116:[7,6] ,117:[7,7] ,118:[7,8]\
,104:[7,10],105:[7,11],106:[7,12],107:[7,13],108:[7,14],109:[7,15],110:[7,16],111:[7,17],112:[7,18]\
,89 :[7,19],90: [7,20],91 :[7,21],92 :[7,22],93 :[7,23],94 :[7,24],95 :[7,25],96 :[7,26],97 :[7,27],98 :[7,28],99 :[7,29],100:[7,30],101:[7,31],101:[7,32],102:[7,14],103:[7,33]}
QtNm = {
#Row1
1 :[1,0,0,1./2.]
,2: [1,0,0,-1./2.]
#Row2
,3 :[2,0,0,1./2.]
,4: [2,0,0,-1./2.]
,5 :[2,-1,1,1./2.], 6: [2,0,1,1./2.] , 7 : [2,1,1,1./2.]
,8 : [2,-1,1,-1./2.] ,9: [2,0,1,-1./2.] ,10 :[2,1,1,-1./2.]
#Row3
,11 :[3,0,0,1./2.]
,12: [3,0,0,-1./2.]
,13 :[3,-1,1,1./2.] , 14: [3,0,1,1./2.] , 15 :[3,1,1,1./2.]
,16 :[3,-1,1,-1./2.] ,17 :[3,0,1,-1./2.] ,18 :[3,1,1,-1./2.]
#Row3
,19 :[4,0,0,1./2.]
,20: [4,0,0,-1./2.]
,31 :[4,-1,2,1./2.] , 32: [4,0,1,1./2.] , 33 :[4,1,1,1./2.]
,34 :[4,-1,1,-1./2.] ,35 :[4,0,1,-1./2.] ,36 :[4,1,1,-1./2.]
,21 :[4,-2,2,1./2.], 22:[4,-1,2,1./2.], 23 :[4,0,2,1./2.], 24 :[4,1,2,1./2.], 25 :[4,2,2,1./2.]
,26 :[4,-2,2,-1./2.], 27:[4,-1,2,-1./2.], 28 :[4,0,2,-1./2.],29 :[4,1,2,-1./2.],30 :[4,2,2,-1./2.]
#Row5
,37 :[5,0,0,1./2.]
,38: [5,0,0,-1./2.]
,49 :[5,-1,1,1./2.] , 50: [5,0,1,1./2.] , 51 :[5,1,1,1./2.]
,52 :[5,-1,1,-1./2.] ,53 :[5,0,1,-1./2.] ,54 :[5,1,1,-1./2.]
,39 :[5,-2,2,1./2.], 40:[5,-1,2,1./2.], 41 :[5,0,2,1./2.], 42 :[5,1,2,1./2.], 43 :[5,2,2,1./2.]
,44 :[5,-2,2,-1./2.],45 :[5,-1,2,-1./2.],46 :[5,0,2,-1./2.],47 :[5,1,2,-1./2.],48 :[5,2,2,-1./2.]
#Row6
,55 :[6,0,0,1./2.]
,56: [6,0,0,-1./2.]
,81 :[6,-1,1,1./2.] ,82: [6,0,1,1./2.] ,83: [6,1,1,1./2.]
,84 :[6,-1,1,-1./2.] ,85 :[6,0,1,-1./2.] ,86 :[6,1,1,-1./2.]
,71 :[6,-2,2,1./2.], 72: [6,-1,2,1./2.], 73 :[6,0,2,1./2.], 74 :[6,1,2,1./2.], 75 :[6,2,2,1./2.]
,76 :[6,-2,2,-1./2.],77 :[6,-1,2,-1./2.],78 :[6,0,2,-1./2.],79 :[6,1,2,-1./2.],80 :[6,2,2,-1./2.]
,57 :[6,-3,3,1./2.], 58: [6,-2,3,1./2.], 59 :[6,-1,3,1./2.], 60 :[6,0,3,1./2.], 61 :[6,1,3,1./2.], 62 :[6,2,3,1./2.], 63 :[6,3,3,1./2.]
,64 :[6,-3,3,-1./2.],65 :[6,-2,3,-1./2.],66 :[6,-1,3,-1./2.],67 :[6,0,3,-1./2.],68 :[6,1,3,-1./2.],69 :[6,2,3,-1./2.],70 :[6,3,3,-1./2.]
#Row7
,87 :[7,0,0,1./2.]
,88: [7,0,0,-1./2.]
,113:[7,-1,1,1./2.] , 114:[7,0,1,1./2.] , 115:[7,1,1,1./2.]
,116:[7,-1,1,-1./2.] ,117:[7,0,1,-1./2.] ,118:[7,1,1,-1./2.]
,103:[7,-2,2,1./2.], 104:[7,-1,2,1./2.], 105:[7,0,2,1./2.], 106:[7,1,2,1./2.], 107:[7,2,2,1./2.]
,108:[7,-2,2,-1./2.],109:[7,-1,2,-1./2.],110:[7,0,2,-1./2.],111:[7,1,2,-1./2.],112:[7,2,2,-1./2.]
,89 :[7,-3,3,1./2.], 90: [7,-2,3,1./2.], 91 :[7,-1,3,1./2.], 92 :[7,0,3,1./2.], 93 :[7,1,3,1./2.], 94 :[7,2,3,1./2.], 95 :[7,3,3,1./2.]
,96 :[7,-3,3,-1./2.],97 :[7,-2,3,-1./2.],98 :[7,-1,3,-1./2.],99 :[7,0,3,-1./2.],100:[7,1,3,-1./2.],101:[7,2,3,-1./2.],102:[7,3,3,-1./2.]}
def QNum_distance(a,b, n_width, m_width, l_width, s_width):
""" Calculate stochiometric distance
a -- nuclear charge of element a
b -- nuclear charge of element b
r_width -- sigma in row-direction
c_width -- sigma in column direction
"""
na = QtNm[int(a)][0]
nb = QtNm[int(b)][0]
ma = QtNm[int(a)][1]
mb = QtNm[int(b)][1]
la = QtNm[int(a)][2]
lb = QtNm[int(b)][2]
sa = QtNm[int(a)][3]
sb = QtNm[int(b)][3]
return np.exp(-(na - nb)**2/(4 * n_width**2)
-(ma - mb)**2/(4 * m_width**2)
-(la - lb)**2/(4 * l_width**2)
-(sa - sb)**2/(4 * s_width**2))
def gen_QNum_distances(emax=100, n_width = 0.001, m_width = 0.001, l_width = 0.001, s_width = 0.001):
""" Generate stochiometric ditance matrix
emax -- Largest element
r_width -- sigma in row-direction
c_width -- sigma in column direction
"""
pd = np.zeros((emax,emax))
for i in range(emax):
for j in range(emax):
pd[i,j] = QNum_distance(i+1, j+1, n_width, m_width, l_width, s_width)
return pd
def periodic_distance(a, b, r_width, c_width):
""" Calculate stochiometric distance
a -- nuclear charge of element a
b -- nuclear charge of element b
r_width -- sigma in row-direction
c_width -- sigma in column direction
"""
ra = PTP[int(a)][0]
rb = PTP[int(b)][0]
ca = PTP[int(a)][1]
cb = PTP[int(b)][1]
# return (r_width**2 * c_width**2) / ((r_width**2 + (ra - rb)**2) * (c_width**2 + (ca - cb)**2))
return np.exp(-(ra - rb)**2/(4 * r_width**2)-(ca - cb)**2/(4 * c_width**2))
def gen_pd(emax=100, r_width=0.001, c_width=0.001):
""" Generate stochiometric ditance matrix
emax -- Largest element
r_width -- sigma in row-direction
c_width -- sigma in column direction
"""
pd = np.zeros((emax,emax))
for i in range(emax):
for j in range(emax):
pd[i,j] = periodic_distance(i+1, j+1, r_width, c_width)
return pd
def gen_custom(e_vec, emax=100):
""" Generate stochiometric ditance matrix
emax -- Largest element
r_width -- sigma in row-direction
c_width -- sigma in column direction
"""
def check_if_unique(iterator):
return len(set(iterator)) == 1
num_dims = []
for k,v in e_vec.items():
assert isinstance(k,int), 'Error! Keys need to be int'
num_dims.append(len(v))
assert check_if_unique(num_dims), 'Error! Unequal number of dimensions'
tmp = np.zeros((emax,num_dims[0]))
for k,v in e_vec.items():
tmp[k,:] = copy(v)
pd = np.dot(tmp,tmp.T)
return pd
def get_alchemy(alchemy, emax=100, r_width=0.001, c_width=0.001, elemental_vectors={}, \
n_width = 0.001, m_width = 0.001, l_width = 0.001, s_width = 0.001):
if (type(alchemy) == np.ndarray):
doalchemy = True
return doalchemy, alchemy
elif (alchemy == "off"):
pd = np.eye(emax)
doalchemy = False
return doalchemy, pd
elif (alchemy == "periodic-table"):
pd = gen_pd(emax=emax, r_width=r_width, c_width=c_width)
doalchemy = True
return doalchemy, pd
elif (alchemy == "quantum-numbers"):
pd = gen_QNum_distances(emax=emax, n_width = n_width, m_width = m_width,
l_width = l_width, s_width = s_width)
doalchemy = True
return doalchemy, pd
elif (alchemy == "custom"):
pd = gen_custom(elemental_vectors,emax)
doalchemy = True
return doalchemy, pd
else:
print("QML ERROR: Unknown alchemical method specified:", alchemy)
exit(1)
================================================
FILE: qml/utils/compound.py
================================================
# MIT License
#
# Copyright (c) 2016-2018 Anders Steen Christensen, Felix Faber, Lars Andersen Bratholm
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
from __future__ import print_function
from six import string_types
import numpy as np
import collections
from ..utils import NUCLEAR_CHARGE
from ..representations import generate_coulomb_matrix
from ..representations import generate_atomic_coulomb_matrix
from ..representations import generate_bob
from ..representations import generate_eigenvalue_coulomb_matrix
from ..representations import generate_slatm
from ..fchl import generate_representation as generate_fchl_representation
from ..representations.facsf import fgenerate_acsf, fgenerate_acsf_and_gradients
class Compound(object):
""" The ``Compound`` class is used to store data from
:param xyz: Option to initialize the ``Compound`` with data from an XYZ file.
:type xyz: string
"""
def __init__(self, xyz = None):
empty_array = np.asarray([], dtype = float)
self.molid = float("nan")
self.name = None
# Information about the compound
self.natoms = float("nan")
self.natypes = {}
self.atomtypes = []
self.atomtype_indices = collections.defaultdict(list)
self.nuclear_charges = empty_array
self.coordinates = empty_array
self.active_atoms = empty_array
self.unit_cell = None
# Container for misc properties
self.energy = float("nan")
self.properties = empty_array
self.properties2 = empty_array
# Representations:
self.representation = empty_array
if xyz is not None:
self.read_xyz(xyz)
def generate_coulomb_matrix(self, size = 23, sorting = "row-norm", indices = None):
""" Creates a Coulomb Matrix representation of a molecule.
A matrix :math:`M` is constructed with elements
.. math::
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},
where :math:`i` and :math:`j` are atom indices, :math:`Z` is nuclear charge and
:math:`\\bf R` is the coordinate in euclidean space.
if ``sorting = 'row-norm'``, the atom indices are reordered such that
:math:`\\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.
:param size: The size of the largest molecule supported by the representation
:type size: integer
:param sorting: How the atom indices are sorted ('row-norm', 'unsorted')
:type sorting: string
:return: 1D representation - shape (size(size+1)/2,)
:rtype: numpy array
"""
self.representation = generate_coulomb_matrix(self.nuclear_charges,
self.coordinates, size = size, sorting = sorting)
def generate_eigenvalue_coulomb_matrix(self, size = 23):
""" Creates an eigenvalue Coulomb Matrix representation of a molecule.
A matrix :math:`M` is constructed with elements
.. math::
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},
where :math:`i` and :math:`j` are atom indices, :math:`Z` is nuclear charge and
:math:`\\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.
:param size: The size of the largest molecule supported by the representation
:type size: integer
:return: 1D representation - shape (size, )
:rtype: numpy array
"""
self.representation = generate_eigenvalue_coulomb_matrix(
self.nuclear_charges, self.coordinates, size = size)
def generate_atomic_coulomb_matrix(self, size = 23, sorting = "row-norm",
central_cutoff = 1e6, central_decay = -1, interaction_cutoff = 1e6, interaction_decay = -1,
indices = None):
""" Creates a Coulomb Matrix representation of the local environment of a central atom.
For each central atom :math:`k`, a matrix :math:`M` is constructed with elements
.. math::
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},
where :math:`i`, :math:`j` and :math:`k` are atom indices, :math:`Z` is nuclear charge and
:math:`\\bf R` is the coordinate in euclidean space.
:math:`f_{ij}` is a function that masks long range effects:
.. math::
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},
where the parameters ``central_cutoff`` and ``central_decay`` corresponds to the variables
:math:`r` and :math:`\Delta r` respectively for interactions involving the central atom,
and ``interaction_cutoff`` and ``interaction_decay`` corresponds to the variables
:math:`r` and :math:`\Delta r` respectively for interactions not involving the central atom.
if ``sorting = 'row-norm'``, the atom indices are ordered such that
:math:`\\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
.. math::
\\|{\\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 :math:`[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.
:param size: The size of the largest molecule supported by the representation
:type size: integer
:param sorting: How the atom indices are sorted ('row-norm', 'distance')
:type sorting: string
:param central_cutoff: The distance from the central atom, where the coulomb interaction
element will be zero
:type central_cutoff: float
:param central_decay: The distance over which the the coulomb interaction decays from full to none
:type central_decay: float
:param interaction_cutoff: The distance between two non-central atom, where the coulomb interaction
element will be zero
:type interaction_cutoff: float
:param interaction_decay: The distance over which the the coulomb interaction decays from full to none
:type interaction_decay: float
:param indices: Subset indices or atomtype
:type indices: Nonetype/array/string
:return: nD representation - shape (:math:`N_{atoms}`, size(size+1)/2)
:rtype: numpy array
"""
self.representation = generate_atomic_coulomb_matrix(
self.nuclear_charges, self.coordinates, size = size, indices = indices,
sorting = sorting, central_cutoff = central_cutoff, central_decay = central_decay,
interaction_cutoff = interaction_cutoff, interaction_decay = interaction_decay)
def generate_bob(self, size=23, asize = {"O":3, "C":7, "N":3, "H":16, "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 :math:`I` is given by
:math:`\\tfrac{1}{2} Z_{I}^{2.4}`,
with :math:`Z_{i}` being the nuclear charge of element :math:`i`
The interaction between atom :math:`i` of element :math:`I` and
atom :math:`j` of element :math:`J` is given by
:math:`\\frac{Z_{I}Z_{J}}{\\| {\\bf R}_{i} - {\\bf R}_{j}\\|}`
with :math:`R_{i}` being the euclidean coordinate of atom :math:`i`.
The sorted bags are concatenated to an 1D vector representation.
The representation is calculated using an OpenMP parallel Fortran routine.
:param asize: The maximum number of atoms of each element type supported by the representation
:type size: dictionary
:return: 1D representation
:rtype: numpy array
"""
self.representation = generate_bob(self.nuclear_charges, self.coordinates,
self.atomtypes, asize = asize)
def generate_fchl_representation(self, 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
"""
self.representation = generate_fchl_representation(self.coordinates,
self.nuclear_charges, max_size=max_size, cell=cell, neighbors=neighbors,cut_distance=cut_distance)
assert (self.representation).shape[0] == max_size, "ERROR: Check FCHL descriptor size!"
def generate_slatm(self, 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).
:param mbtypes: Many-body types for the whole dataset, including 1-, 2- and 3-body types. Could be obtained by calling ``get_slatm_mbtypes()``.
:type mbtypes: list
:param local: Generate a local representation. Defaulted to False (i.e., global representation); otherwise, atomic version.
:type local: bool
:param sigmas: 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.
:type sigmas: list
:param dgrids: The interval between two sampled internuclear distances and angles, defaulted to [0.03,0.03], no need for change, compromised for speed and accuracy.
:type dgrids: list
:param rcut: Cut-off radius, defaulted to 4.8 Angstrom.
:type rcut: float
:param alchemy: Swith to use the alchemy version of SLATM. (default=False)
:type alchemy: bool
:param pbc: defaulted to '000', meaning it's a molecule; the three digits in the string corresponds to x,y,z direction
:type pbc: string
:param rpower: The power of R in 2-body potential, defaulted to London potential (=6).
:type rpower: float
:return: 1D SLATM representation
:rtype: numpy array
"""
slatm = generate_slatm(self.coordinates, self.nuclear_charges, mbtypes, local=local,
sigmas=sigmas, dgrids=dgrids, rcut=rcut, unit_cell=self.unit_cell,
alchemy=alchemy, rpower=rpower)
if local: slatm = np.asarray(slatm)
self.representation = slatm
def generate_acsf(self, elements = [1,6,7,8,16], nRs2 = 3, nRs3 = 3, nTs = 3, eta2 = 1,
eta3 = 1, zeta = 1, rcut = 5, acut = 5, bin_min=0.8, gradients = False):
"""
Generate the variant of atom-centered symmetry functions used in https://doi.org/10.1039/C7SC04934J
:param elements: list of unique nuclear charges (atom types)
:type elements: numpy array
:param nRs2: Number of gaussian basis functions in the two-body terms
:type nRs2: integer
:param nRs3: Number of gaussian basis functions in the three-body radial part
:type nRs3: integer
:param nTs: Number of basis functions in the three-body angular part
:type nTs: integer
:param eta2: Precision in the gaussian basis functions in the two-body terms
:type eta2: float
:param eta3: Precision in the gaussian basis functions in the three-body radial part
:type eta3: float
:param zeta: Precision parameter of basis functions in the three-body angular part
:type zeta: float
:param rcut: Cut-off radius of the two-body terms
:type rcut: float
:param acut: Cut-off radius of the three-body terms
:type acut: float
:param bin_min: the value at which to start binning the distances
:type bin_min: positive float
:param gradients: To return gradients or not
:type gradients: boolean
"""
Rs2 = np.linspace(bin_min, rcut, nRs2)
Rs3 = np.linspace(bin_min, acut, nRs3)
Ts = np.linspace(0, np.pi, nTs)
n_elements = len(elements)
natoms = len(self.coordinates)
rep_size = n_elements * nRs2 + (n_elements * (n_elements + 1)) // 2 * nRs3*nTs
if gradients:
self.representation, self.gradients = fgenerate_acsf_and_gradients(self.coordinates,
self.nuclear_charges, elements, Rs2, Rs3, Ts, eta2, eta3, zeta, rcut, acut, natoms, rep_size)
else:
self.representation = fgenerate_acsf(self.coordinates, self.nuclear_charges, elements, Rs2, Rs3,
Ts, eta2, eta3, zeta, rcut, acut, natoms, rep_size)
def read_xyz(self, filename):
"""(Re-)initializes the Compound-object with data from an xyz-file.
:param filename: Input xyz-filename or file-like obejct
:type filename: string or file-like object
"""
if isinstance(filename, string_types):
with open(filename, "r") as f:
lines = f.readlines()
else:
lines = filename.readlines()
self.natoms = int(lines[0])
self.atomtypes = []
self.nuclear_charges = np.empty(self.natoms, dtype=int)
self.coordinates = np.empty((self.natoms, 3), dtype=float)
# Give the Compound a name if it is a string
self.name = filename if isinstance(filename, string_types) else "Compound"
for i, line in enumerate(lines[2:self.natoms+2]):
tokens = line.split()
if len(tokens) <