molSimplify 1.7.4__py3-none-any.whl

molSimplify/python_nn/clf_analysis_tool.py

@@ -0,0 +1,125 @@
+# import matplotlib.pyplot as plt
+import numpy as np
+from sklearn.metrics.pairwise import pairwise_distances
+from packaging import version
+import tensorflow as tf
+from tensorflow.keras import backend as K
+from tensorflow.keras import Model
+
+
+def get_acc(pred_std, pred_err, stds):
+    pred_err_arr = []
+    for target_std in stds:
+        _pred_err = []
+        for idx, _std in enumerate(pred_std):
+            if _std < target_std:
+                _pred_err.append(pred_err[idx])
+        pred_err_arr.append(_pred_err)
+    acc, ratio = [], []
+    for idx, _ in enumerate(pred_err_arr):
+        pred_err_now = pred_err_arr[idx]
+        acc_arr = [1 if pred_err_now[ii] < 0.5 else 0 for ii in range(len(pred_err_now))]
+        acc.append(np.mean(acc_arr))
+        ratio.append(1.0 * len(pred_err_now) / len(pred_std))
+    print(('stds', stds))
+    print(('accuracy', acc))
+    print(('ratio', ratio))
+    return stds, np.array(acc), np.array(ratio)
+
+
+def dist_neighbor(fmat1, fmat2, labels, l=5, dist_ref=1):  # noqa: E741
+    dist_mat = pairwise_distances(fmat1, fmat2, 'manhattan')
+    dist_mat = dist_mat * 1.0 / dist_ref
+    dist_avrg, dist_list, labels_list = [], [], []
+    # print('shape of dist_mat:', dist_mat.shape)
+    for ele in dist_mat:
+        dist_arr = np.round(np.array(ele), 4)
+        if not dist_ref == 1:
+            _count = (dist_arr < 10).sum()
+            _count = l if _count < l else _count
+            _count = _count if _count < 300 else 300
+        else:
+            _count = l
+        ind = dist_arr.argsort()[:_count]
+        _dist = dist_arr[ind]
+        dist_list.append(_dist)
+        _labels = np.array([labels[x][0] for x in ind])
+        labels_list.append(_labels)
+        if _dist.all() > 1e-4:
+            dist_avrg.append(np.mean(_dist[:l]))
+        else:
+            dist_avrg.append(np.mean(_dist[:l]) * float(l) / (l - 1))
+    # print('-----mean: %f, std: %f---' % (np.mean(dist_avrg), np.std(dist_avrg)))
+    dist_avrg = np.array(dist_avrg)
+    dist_list = np.array(dist_list)
+    labels_list = np.array(labels_list)
+    return dist_avrg, dist_list, labels_list
+
+
+def array_stack(array, _idx):
+    for ii in range(len(array)):
+        if not ii == _idx:
+            if 'out_arr' not in dir():
+                out_arr = array[ii]
+            else:
+                out_arr = np.concatenate((out_arr, array[ii]))
+    return out_arr
+
+
+def dist_penalty(d):
+    return np.exp(-1 * d ** 2)
+
+
+def get_entropy(dists, neighbor_targets) -> np.ndarray:
+    entropies = []
+    for ii, _neighbor_targets in enumerate(neighbor_targets):
+        p0, p1 = dist_penalty(2), dist_penalty(2)
+        for idx, tar in enumerate(_neighbor_targets):
+            tar = int(tar)
+            d = dists[ii][idx]
+            if d <= 10:
+                if d != 0:
+                    if tar == 0:
+                        p0 += dist_penalty(d)
+                    elif tar == 1:
+                        p1 += dist_penalty(d)
+                else:
+                    if tar == 0:
+                        p0 += 100
+                    elif tar == 1:
+                        p1 += 100
+            _sum = p0 + p1
+        p0 = p0 / _sum
+        p1 = p1 / _sum
+        if p1 == 0 or p0 == 0:
+            entropies.append(0)
+        else:
+            entropies.append(-(p0 * np.log(p0) + p1 * np.log(p1)))
+    return np.array(entropies)
+
+
+def get_layer_outputs(model, layer_index, input,
+                      training_flag=False) -> np.ndarray:
+    if not version.parse(tf.__version__) >= version.parse('2.0.0'):
+        get_outputs = K.function([model.layers[0].input, K.learning_phase()],
+                                 [model.layers[layer_index].output])
+        nn_outputs = get_outputs([input, training_flag])[0]
+    else:
+        partial_model = Model(model.inputs, model.layers[layer_index].output)
+        nn_outputs = partial_model([input], training=training_flag).numpy()  # runs the model in training mode
+    return nn_outputs
+
+
+def lse_trust(lse):
+    level = False
+    if lse < 0.2:
+        level = 'very high'
+    elif lse < 0.3:
+        level = 'high'
+    elif lse < 0.4:
+        level = 'medium'
+    elif lse < 0.5:
+        level = 'low'
+    else:
+        level = 'very low'
+    return level

molSimplify/python_nn/dictionary_toolbox.py

@@ -0,0 +1,49 @@
+
+def write_dictionary(dictionary, path):
+    emsg = False
+    try:
+        with open(path, 'w') as f:
+            for keys in list(dictionary.keys()):
+                f.write(str(keys).strip("\n") + ',' + str(dictionary[keys]) + '\n')
+    except FileNotFoundError:
+        emsg = "Error, could not write dictionary space: " + path
+    return emsg
+
+
+def read_dictionary(path):
+    emsg = False
+    dictionary = dict()
+    try:
+        with open(path, 'r') as f:
+            for lines in f:
+                ll = lines.split(",")
+                key = ll[0]
+                value = ll[1].rstrip("\n")
+                dictionary[key] = value
+    except (FileNotFoundError, IndexError):
+        emsg = "Error, could not read dictionary space: " + path
+    return emsg, dictionary
+
+
+if __name__ == "__main__":
+    sfd = {
+        "split_energy": [-54.19, 142.71],
+        "slope": [-174.20, 161.58],
+        "ls_min": [1.8146, 0.6910],
+        "hs_min": [1.8882, 0.6956],
+        "ox": [2, 1],
+        "alpha": [0, 0.3],
+        "ax_charge": [-2, 2],
+        "eq_charge": [-2, 2],
+        "ax_dent": [1, 1],
+        "eq_dent": [1, 3],
+        "sum_delen": [-5.34, 12.54],
+        "max_delen": [-0.89, 2.09],
+        "ax_bo": [0, 3],
+        "eq_bo": [0.00, 3],
+        "ax_ki": [0.00, 4.29],
+        "eq_ki": [0.00, 6.96]
+    }
+    write_dictionary(sfd, 'scaling.csv')
+
+    rect = read_dictionary('scaling.csv')

molSimplify/python_nn/ensemble_test.py

@@ -0,0 +1,309 @@
+import glob
+import math
+
+import numpy as np
+import scipy as sp
+import os
+from tensorflow.keras.callbacks import EarlyStopping
+from tensorflow.keras.models import model_from_json
+from tensorflow.keras import backend as K
+
+from importlib_resources import files as resource_files
+from sklearn.utils import shuffle
+from molSimplify.python_nn.clf_analysis_tool import (dist_neighbor,
+                                                     get_entropy)
+from molSimplify.python_nn.tf_ANN import (data_normalize,
+                                          data_rescale,
+                                          get_key,
+                                          load_keras_ann,
+                                          load_normalization_data,
+                                          load_test_data,
+                                          load_test_labels,
+                                          load_train_info,
+                                          load_training_data,
+                                          load_training_labels,
+                                          save_model,
+                                          tf_ANN_excitation_prepare)
+
+
+def reset_weights(model):
+    session = K.get_session()
+    for layer in model.layers:
+        if hasattr(layer, 'kernel_initializer'):
+            layer.kernel.initializer.run(session=session)
+    return model
+
+
+def array_stack(array, _idx):
+    for ii in range(len(array)):
+        if not ii == _idx:
+            if 'out_arr' not in dir():
+                out_arr = array[ii]
+            else:
+                out_arr = np.concatenate((out_arr, array[ii]))
+    return out_arr
+
+
+def mc_dropout_logp(tau, err):
+    T = err.shape[0]
+    logp = sp.misc.logsumexp(-0.5 * tau * err)
+    logp -= np.log(T)
+    logp -= 0.5 * np.log(np.power(tau, -1))
+    logp -= 0.5 * np.log(2 * math.pi)
+    return (logp)
+
+
+def ensemble_maker_inner(train_mat, labels, model_gen_function, info_dict,
+                         num=10):
+    ## contains core functions to make ensemble models
+    ## from training data and labels
+    ## model_gen_function is a functiont that takes NO arguments and returns a keras model
+    ## info_dict is a dictionary of training info
+    train_mat, labels = shuffle(train_mat, labels)
+    train_mat = np.array_split(train_mat, num, axis=0)
+    labels = np.array_split(labels, num, axis=0)
+    earlystop = EarlyStopping(monitor=info_dict['monitor'],
+                              min_delta=info_dict['min_delta'],
+                              patience=info_dict['patience'],
+                              verbose=0,
+                              mode='auto')
+    callbacks_list = [earlystop]
+    model_list = []
+    for ii in range(num):
+        train_feature = array_stack(train_mat, ii)
+        train_labels = array_stack(labels, ii)
+        loaded_model = model_gen_function()  # note the call to gen new model
+        current_model = reset_weights(loaded_model)
+        current_model.fit(train_feature, train_labels,
+                          epochs=info_dict['epochs'], verbose=0,
+                          batch_size=info_dict['batch_size'],
+                          callbacks=callbacks_list)
+        model_list.append(current_model)
+    return(model_list)
+
+
+def ensemble_maker(predictor, num=10):
+    train_mean_x, train_mean_y, train_var_x, train_var_y = load_normalization_data(predictor)
+    mat = load_training_data(predictor)
+    mat = np.array(mat, dtype='float64')
+    train_mat = data_normalize(mat, train_mean_x, train_var_x)
+    labels = load_training_labels(predictor)
+    if "clf" not in predictor:
+        labels = np.array(labels, dtype='float64')
+        labels = data_normalize(labels, train_mean_y, train_var_y)
+    info_dict = load_train_info(predictor)
+    model_list = ensemble_maker_inner(train_mat=train_mat,
+                                      labels=labels,
+                                      model_gen_function=lambda: load_keras_ann(predictor),
+                                      info_dict=info_dict, num=num)
+    for ii, current_model in enumerate(model_list):
+        save_model(current_model, predictor, ii)
+
+
+def ensemble_uq(predictor, descriptors=False, descriptor_names=False, suffix=False):
+    key = get_key(predictor, suffix)
+    base_path = str(resource_files("molSimplify.tf_nn").joinpath(f'{key}.csv'))
+    base_path = base_path + 'ensemble_models'
+    if not os.path.exists(base_path):
+        print('Ensemble models do not exist now, training...')
+        ensemble_maker(predictor)
+    print(('ANN activated for ' + str(predictor)))
+    model_list = glob.glob(base_path + '/*.h5')
+
+    labels = load_test_labels(predictor)
+    if 'clf' not in predictor:
+        labels = np.array(labels, dtype='float64')
+    else:
+        labels = np.array(labels, dtype='int')
+    train_mean_x, train_mean_y, train_var_x, train_var_y = load_normalization_data(predictor)
+    if (descriptors and descriptor_names):
+        excitation = tf_ANN_excitation_prepare(predictor, descriptors, descriptor_names)
+        excitation = data_normalize(excitation, train_mean_x, train_var_x)
+    else:
+        mat = load_test_data(predictor)
+        mat = np.array(mat, dtype='float64')
+        train_mat = data_normalize(mat, train_mean_x, train_var_x)
+        excitation = np.array(train_mat)
+    print(('excitation is ' + str(excitation.shape)))
+    print(('actual label:', labels[:3]))
+    results_list = []
+    # print('models', model_list)
+    for idx, model in enumerate(model_list):
+        _base = model.split('.')[0]
+        with open(_base + '.json', 'r') as json_file:
+            loaded_model_json = json_file.read()
+        loaded_model = model_from_json(loaded_model_json)
+        # load weights into  model
+        loaded_model.load_weights(model)
+        # complile model
+        loaded_model.compile(loss="mse", optimizer='adam',
+                             metrics=['mse', 'mae', 'mape'])
+        if 'clf' not in predictor:
+            result = data_rescale(loaded_model.predict(excitation), train_mean_y, train_var_y)
+        else:
+            result = loaded_model.predict(excitation)
+            result = np.squeeze(result, axis=1)
+        results_list.append(result)
+    results_list = np.transpose(np.array(results_list))
+    # print(results_list.shape)
+    result_mean, result_std = np.mean(results_list, axis=1), np.std(results_list, axis=1)
+    labels = np.squeeze(labels, axis=1)
+    print((labels.shape, result_mean.shape))
+    error_for_mean = np.abs(labels - result_mean)
+    return result_mean, result_std, error_for_mean
+
+
+def mc_dropout_uq(predictor, descriptors=False, descriptor_names=False, num=500):
+    labels = load_test_labels(predictor)
+    if 'clf' not in predictor:
+        labels = np.array(labels, dtype='float64')
+    else:
+        labels = np.array(labels, dtype='int')
+    train_mean_x, train_mean_y, train_var_x, train_var_y = load_normalization_data(predictor)
+    if (descriptors and descriptor_names):
+        excitation = tf_ANN_excitation_prepare(predictor, descriptors, descriptor_names)
+        excitation = data_normalize(excitation, train_mean_x, train_var_x)
+    else:
+        mat = load_test_data(predictor)
+        mat = np.array(mat, dtype='float64')
+        train_mat = data_normalize(mat, train_mean_x, train_var_x)
+        excitation = np.array(train_mat)
+    print(('excitation is ' + str(excitation.shape)))
+    loaded_model = load_keras_ann(predictor)
+    get_outputs = K.function([loaded_model.layers[0].input, K.learning_phase()],
+                             [loaded_model.layers[-1].output])
+    print(('LOADED MODEL HAS ' + str(
+        len(loaded_model.layers)) + ' layers, so latent space measure will be from first ' + str(
+        len(loaded_model.layers) - 1) + ' layers'))
+    results_list = []
+    err_list = []
+    for ii in range(num):
+        if not np.mod(ii, int(num / 10)):
+            print(('%d / %d' % (ii, num)))
+        if 'clf' not in predictor:
+            results = data_rescale(np.array(get_outputs([excitation, 1])), train_mean_y,
+                                   train_var_y)[0]
+        else:
+            results = np.array(get_outputs([excitation, 1]))[0]
+        results = results.squeeze(axis=1)
+        err = np.linalg.norm(labels - results) ** 2
+        results_list.append(results)
+        err_list.append(err)
+    results_list = np.transpose(np.array(results_list))
+
+    def f(tau):
+        return mc_dropout_logp(tau, np.array(err_list))
+    tau = sp.optimize.minimize(f, 10).x
+    result_mean, result_std = np.mean(results_list, axis=1), np.std(results_list, axis=1)
+    result_std = np.sqrt(1 / tau + result_std ** 2)
+    # print(tau, result_std[:3])
+    labels = np.squeeze(labels, axis=1)
+    error_for_mean = np.abs(labels - result_mean)
+    return result_mean, result_std, error_for_mean
+
+
+def latent_space_uq(predictor, layer_index=-2, descriptors=False, descriptor_names=False, entropy=False):
+    key = get_key(predictor, suffix=False)
+    base_path = str(resource_files("molSimplify.tf_nn").joinpath(f'{key}.csv'))
+    base_path = base_path + 'ensemble_models'
+    if not os.path.exists(base_path):
+        print('Ensemble models do not exist now, training...')
+        ensemble_maker(predictor)
+    print(('ANN activated for ' + str(predictor)))
+    model_list = glob.glob(base_path + '/*.h5')
+    train_mean_x, train_mean_y, train_var_x, train_var_y = load_normalization_data(predictor)
+    if (descriptors and descriptor_names):
+        excitation = tf_ANN_excitation_prepare(predictor, descriptors, descriptor_names)
+        excitation = data_normalize(excitation, train_mean_x, train_var_x)
+    else:
+        mat = load_training_data(predictor)
+        mat = np.array(mat, dtype='float64')
+        train_mat = data_normalize(mat, train_mean_x, train_var_x)
+        excitation = np.array(train_mat)
+    ### load test data
+    if (descriptors and descriptor_names):
+        excitation = tf_ANN_excitation_prepare(predictor, descriptors, descriptor_names)
+        excitation_test = data_normalize(excitation, train_mean_x, train_var_x)
+    else:
+        mat = load_test_data(predictor)
+        mat = np.array(mat, dtype='float64')
+        test_mat = data_normalize(mat, train_mean_x, train_var_x)
+        excitation_test = np.array(test_mat)
+    labels = load_test_labels(predictor)
+    labels_train = load_training_labels(predictor)
+    if 'clf' not in predictor:
+        labels = np.array(labels, dtype='float64')
+        labels_train = np.array(labels_train, dtype='float64')
+    else:
+        labels = np.array(labels, dtype='int')
+        labels_train = np.array(labels_train, dtype='int')
+    results_list = []
+    err_list = []
+    dist_list = []
+    for model in model_list:
+        _base = model.split('.')[0]
+        with open(_base + '.json', 'r') as json_file:
+            loaded_model_json = json_file.read()
+        loaded_model = model_from_json(loaded_model_json)
+        loaded_model.load_weights(model)
+        loaded_model.compile(loss="mse", optimizer='adam',
+                             metrics=['mse', 'mae', 'mape'])
+        get_outputs = K.function([loaded_model.layers[0].input, K.learning_phase()],
+                                 [loaded_model.layers[-1].output])
+        get_latent = K.function([loaded_model.layers[0].input, K.learning_phase()],
+                                [loaded_model.layers[layer_index].output])
+        print(('NOTE: you are choosing:', loaded_model.layers[layer_index], loaded_model.layers[layer_index].name,
+              'for the latence space!'))
+        if 'clf' not in predictor:
+            results = data_rescale(np.array(get_outputs([excitation_test, 0])), train_mean_y,
+                                   train_var_y)[0]
+        else:
+            results = np.array(get_outputs([excitation_test, 0]))[0]
+        ## get latent dist
+        training_latent_distance = np.array(get_latent([excitation, 0]))[0]
+        nn_latent_dist_train, _, __ = dist_neighbor(training_latent_distance, training_latent_distance, labels_train,
+                                                    l=5, dist_ref=1)
+        nn_dist_avrg_train = np.mean(nn_latent_dist_train)
+        # print(nn_dist_avrg_train)
+        test_latent_distance = np.array(get_latent([excitation_test, 0]))[0]
+        nn_latent_dist_test, nn_dists, nn_labels = dist_neighbor(test_latent_distance, training_latent_distance,
+                                                                 labels_train,
+                                                                 l=5, dist_ref=nn_dist_avrg_train)
+        if not entropy:
+            # print(nn_latent_dist_test.shape)
+            # print(min(nn_latent_dist_test), max(nn_latent_dist_test))
+            dist_list.append(nn_latent_dist_test)
+        else:
+            entropy = []
+            for idx, _dists in enumerate(nn_dists):
+                entropy.append(get_entropy(_dists, nn_labels[idx]))
+            dist_list.append(np.array(entropy))
+        results = results.squeeze(axis=1)
+        err = np.linalg.norm(labels - results) ** 2
+        results_list.append(results)
+        err_list.append(err)
+    dist_list = np.transpose(np.array(dist_list))
+    results_list = np.transpose(np.array(results_list))
+    result_mean = np.mean(results_list, axis=1)
+    latent_dist = np.mean(dist_list, axis=1)
+    labels = np.squeeze(labels, axis=1)
+    error_for_mean = np.abs(labels - result_mean)
+    return result_mean, latent_dist, error_for_mean
+
+###########
+# predictor = 'geo_static_clf'
+# ensemble_maker(predictor, num=10)
+# _result_mean, _result_std, _error_for_mean = ensemble_uq(predictor)
+# result_mean, result_std, error_for_mean = mc_dropout_uq(predictor)
+# result_mean, latent_dist, error_for_mean = latent_space_uq(predictor, layer_index=-4, entropy=True)
+
+# stds = [0.01, 0.02, 0.03, 0.05, 0.075, 0.1, 0.125, 0.15, 0.175, 0.2, 0.225, 0.25, 0.3, 0.35]  # for variance
+# stds = [0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.8]  # for latent distances
+# stds = [0.01, 0.02, 0.04, 0.06, 0.08, 0.1, 0.125, 0.15, 0.175, 0.2, 0.25, 0.3, 0.35, 0.4, 0.5, 0.6, 0.7]  # for entropy
+# plot_scatter(latent_dist, error_for_mean, xlabel='entropy', ylabel='prediction error',
+#              figname='entropy_err.pdf')
+# plot_dist_err(pred_std=latent_dist, pred_err=error_for_mean, stds=stds,
+#               label_x='entropy', label_y='accuracy',
+#               lable_y2='ratio of data', figname='entropy_acc_ratio.pdf')
+# plot_metrics_correlation(metric1=latent_dist, metric2=_result_std, pred_err=error_for_mean,
+#                          xlabel='entropy', ylabel='ensemble std', figname='dist_relations_entropy_ensemblestd.pdf')

molSimplify/python_nn/hs_center.csv

@@ -0,0 +1,26 @@
+2.136969522
+0.199834847
+0.239471511
+0.268373245
+0.208918249
+0.083402147
+2.445086705
+0.150082576
+-0.415359207
+-0.478943022
+1.242774566
+1.495458299
+0.053674649
+0.328654005
+0.233691164
+0.034682081
+0.024772915
+0.41370768
+0.312964492
+0.014863749
+2.248505367
+0.570049546
+1.938893476
+1.767960363
+1.325765483
+1.947052436

molSimplify/python_nn/hs_scale.csv

@@ -0,0 +1,26 @@
+0.112806743
+0.400041286
+0.426937259
+0.443295972
+0.406703826
+0.27660334
+0.497180701
+0.09941977
+0.629885414
+0.733052627
+0.428937066
+0.586856749
+0.225467646
+0.469917969
+0.423352812
+0.183048909
+0.155496572
+0.492700815
+0.463891603
+0.121057505
+3.37445425
+0.599294625
+0.868873174
+0.880362839
+1.401356536
+1.565485427

molSimplify/python_nn/ls_center.csv

@@ -0,0 +1,26 @@
+1.998290653
+0.193228737
+0.247729149
+0.274153592
+0.199009083
+0.085879438
+2.45912469
+0.148843931
+-0.423616846
+-0.493806771
+1.251032205
+1.50206441
+0.055326177
+0.327002477
+0.244426094
+0.035507845
+0.027250206
+0.397192403
+0.326176713
+0.01734104
+2.273526012
+0.572130471
+1.909991742
+1.739058629
+1.356769612
+1.973370768

molSimplify/python_nn/ls_scale.csv

@@ -0,0 +1,26 @@
+0.09847215
+0.394993959
+0.431872011
+0.446271058
+0.399419838
+0.280301695
+0.498532286
+0.099724337
+0.634858322
+0.741175942
+0.433786147
+0.591080282
+0.228710265
+0.46931198
+0.429923957
+0.185136007
+0.162878912
+0.489518615
+0.469006509
+0.130592541
+3.361758744
+0.598396275
+0.880077523
+0.893291123
+1.405013531
+1.565100226

molSimplify/python_nn/ms_hs_b1.csv

@@ -0,0 +1,50 @@
+2.93155552948668
+0.145515594829442
+-2.43360048262547
+-0.395157480282928
+-0.637796603638759
+0.930146106836688
+-0.579524142895491
+0.820626949144907
+-0.777253783464289
+0.29215692472564
+0.626961509771671
+2.44330097887685
+-0.114308691579229
+0.208927253397649
+-1.1547541817769
+2.37792109238942
+1.73020053910489
+0.0354183411959639
+1.01037447839548
+-1.147846585035
+0.93779592438205
+2.63165432155493
+0.599279379070505
+3.27174010720937
+0.490135127953323
+-2.16587669549562
+-0.722977897819559
+0.947350315047321
+-0.264109742306947
+2.54463856916042
+0.029884855079517
+-2.69607015251569
+-0.521392807565805
+1.94846941214027
+1.42039316055551
+-1.45812048290532
+-1.37562155241263
+1.24489712820888
+-1.67964384941915
+0.301571663456907
+-0.224679255157492
+-0.300143586984905
+0.71755740409976
+1.1278507970158
+1.42092339643375
+0.397904412800722
+0.682084109695825
+-0.991586223845188
+2.05738727567306
+-0.32091166977298

molSimplify/python_nn/ms_hs_b2.csv

@@ -0,0 +1,50 @@
+0.0610984936356544
+0.0166297517716885
+-0.0736834183335304
+0.0157422479242086
+0.0615338534116745
+-0.556233763694763
+-0.0763034969568253
+-0.578255236148834
+-0.00821118988096714
+0.329997718334198
+-0.0450253896415234
+-0.0596241429448128
+0.40295821428299
+-0.394725888967514
+0.0263551324605942
+-0.0676112771034241
+0.342610031366348
+0.157034784555435
+0.0200989171862602
+0.213467597961426
+0.00311096734367311
+0.0461217276751995
+-0.334931492805481
+0.0107353795319796
+0.227196827530861
+0.0135542759671807
+0.160586997866631
+0.054229624569416
+0.0179113112390041
+0.0118232732638717
+0.464570730924606
+0.530038118362427
+-0.0641885846853256
+0.0990450754761696
+-0.0292500946670771
+-0.118187084794044
+-0.0402664169669151
+-0.0201399587094784
+-0.0397170968353748
+-0.0894053429365158
+0.298441380262375
+0.223844051361084
+-0.118292838335037
+0.0230815000832081
+-0.00469169579446316
+0.0141284568235278
+-0.400922119617462
+0.22510838508606
+0.286137253046036
+0.00674713868647814

molSimplify/python_nn/ms_hs_b3.csv

@@ -0,0 +1 @@
+0.509552240371704