param_dict=param_dict,
        n_permutations=24,
        kwarg_key_list=[
            'conv_filters1', 'kernel_sizes', 'maps_per_kernel', 'dropout1',
            'dropout2', 'pool_size', 'conv_filters2', 'dense_units', 'lr'
        ])
elif ACTION == 'train_final_model':
    fncs.train_final_model()

elif ACTION == 'cross_validation':
    fncs.run_cross_validation(nn_architechture='CNNPAR',
                              in_kwargs={
                                  'conv_filters1': 75,
                                  'conv_filters2': 300,
                                  'dense_units': 120,
                                  'dropout1': 0.0,
                                  'dropout2': 0.0,
                                  'kernel_sizes': [6, 8, 10],
                                  'lr': 0.001,
                                  'maps_per_kernel': 2,
                                  'pool_size': 3
                              })

elif ACTION == 'test_final_model':
    importlib.reload(fncs)
    weights_path = (
        "code_modules/nn_training/BAC_UNI_len2006/final_elmo_CNNPAR"
        "_BAC_UNI_len2006/final_elmo_CNNPAR_BAC_UNI_len2006"
        "_1565079880")
    fncs.train_final_model(just_test_model=True, weights_path=weights_path)

else:
import importlib

import code_modules.nn_training.functions as fncs

importlib.reload(fncs)
fncs.run_cross_validation(nn_architechture='CNN')
import importlib

import code_modules.nn_training.functions as fncs

importlib.reload(fncs)

DO_GRIDSEARCH = False
if DO_GRIDSEARCH:
    param_dict = {
        'l1_units': [32, 64, 320],
        'l2_units': [32, 64, 320],
        'dropout1': [0.0, 0.2, 0.5],
        'dropout2': [0.0, 0.2, 0.5],
        'regularizer_vals': [0, 0.01, 0.001],
        'epochs': [20, 50, 100],
        'batch_size': [32, 32 * 4, 32 * 8]
    }

    results = fncs.hyperparameter_gridsearch(param_dict=param_dict)

else:
    fncs.run_cross_validation(nn_architechture='DNN',
                              in_kwargs=dict(dropout1=0.5,
                                             dropout2=0.5,
                                             l1_units=32,
                                             l2_units=64,
                                             regularizer_vals=0),
                              epochs=50,
                              batch_size=256)
import code_modules.nn_training.functions as fncs

fncs.run_cross_validation(nn_architechture='BIDGRU', do_w2v=True,
                          dataset_to_use='GLYLIP')
        'dropout1': [0.2],
        'dropout2': [0.0],
        'epochs': [150],
        'batch_size': [256]
    }

    results = fncs.hyperparameter_gridsearch(nn_architechture='RNNCNN',
                                             param_dict=param_dict,
                                             n_permutations=6,
                                             kwarg_key_list=[
                                                 'lr', 'conv_filters',
                                                 'kernel_size', 'pool_size',
                                                 'lstm_units', 'dropout1',
                                                 'dropout2'
                                             ])
else:
    fncs.run_cross_validation(nn_architechture='RNNCNN',
                              fold_i_to_skip=tuple(),
                              **{
                                  'batch_size': 1024,
                                  'epochs': 75,
                                  'in_kwargs': {
                                      'conv_filters': 640,
                                      'dropout1': 0.2,
                                      'dropout2': 0.0,
                                      'kernel_size': 26,
                                      'lr': 0.0001,
                                      'pool_size': 26
                                  }
                              })
import code_modules.nn_training.functions as fncs

fncs.run_cross_validation(nn_architechture='BIDGRU')