bdext 0.1.65__py3-none-any.whl → 0.1.67__py3-none-any.whl

bdext-0.1.67.dist-info/METADATA

@@ -0,0 +1,240 @@
+Metadata-Version: 2.1
+Name: bdext
+Version: 0.1.67
+Summary: Estimation of BDEISS-CT parameters from phylogenetic trees.
+Home-page: https://github.com/modpath/bdeissct
+Author: Anna Zhukova
+Author-email: anna.zhukova@pasteur.fr
+License: UNKNOWN
+Keywords: phylogenetics,birth-death model,incubation,super-spreading,contact tracing
+Platform: UNKNOWN
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Description-Content-Type: text/markdown
+Requires-Dist: tensorflow==2.19.0
+Requires-Dist: six
+Requires-Dist: ete3
+Requires-Dist: numpy==2.0.2
+Requires-Dist: scipy==1.14.1
+Requires-Dist: biopython
+Requires-Dist: scikit-learn==1.5.2
+Requires-Dist: pandas==2.2.3
+Requires-Dist: treesumstats==0.7
+
+# bdext
+
+The bdext package provides scripts to train and assess
+Deep-Learning-enables estimators of BD(EI)(SS)(CT) model parameters from phylogenetic trees 
+
+
+
+[//]: # ([![DOI:10.1093/sysbio/syad059](https://zenodo.org/badge/DOI/10.1093/sysbio/syad059.svg)](https://doi.org/10.1093/sysbio/syad059))
+[//]: # ([![GitHub release](https://img.shields.io/github/v/release/evolbioinfo/bdext.svg)](https://github.com/evolbioinfo/bdext/releases))
+[![PyPI version](https://badge.fury.io/py/bdext.svg)](https://pypi.org/project/bdext/)
+[![PyPI downloads](https://shields.io/pypi/dm/bdext)](https://pypi.org/project/bdext)
+[![Docker pulls](https://img.shields.io/docker/pulls/evolbioinfo/bdext)](https://hub.docker.com/r/evolbioinfo/bdext/tags)
+
+## BDEISS-CT model
+
+The Birth-Death (BD) Exposed-Infectious (EI) with SuperSpreading (SS) and Contact-Tracing (CT) model (BDEISS-CT) 
+can be described with the following 8 parameters:
+
+* average reproduction number R;
+* average total infection duration d;
+* incubation period d<sub>inc</sub>;
+* sampling probability ρ;
+* fraction of superspreaders f<sub>S</sub>;
+* super-spreading transmission increase X<sub>S</sub>;
+* contact tracing probability υ;
+* contact-traced removal speed up X<sub>C</sub>.
+
+Setting d<sub>inc</sub>=0 removes incubation (EI), setting f<sub>S</sub>=0 removes superspreading (SS), while setting υ=0 removes contact-tracing (CT).
+
+For identifiability, we require the sampling probability ρ to be given by the user. 
+The other parameters are estimated from a time-scaled phylogenetic tree.
+
+[//]: # (## BDEISS-CT parameter estimator)
+
+[//]: # ()
+[//]: # (The bdeissct_dl package provides deep-learning-based BDEISS-CT model parameter estimator )
+
+[//]: # (from a user-supplied time-scaled phylogenetic tree. )
+
+[//]: # (User must also provide a value for one of the three BD model parameters &#40;λ, ψ, or ρ&#41;. )
+
+[//]: # (We recommend providing the sampling probability ρ, )
+
+[//]: # (which could be estimated as the number of tree tips divided by the number of declared cases for the same time period.)
+
+[//]: # ()
+[//]: # ()
+[//]: # (## Input data)
+
+[//]: # (One needs to supply a time-scaled phylogenetic tree in newick format. )
+
+[//]: # (In the examples below we will use an HIV tree reconstructed from 200 sequences, )
+
+[//]: # (published in [[Rasmussen _et al._ PLoS Comput. Biol. 2017]]&#40;https://journals.plos.org/ploscompbiol/article?id=10.1371/journal.pcbi.1005448&#41;, )
+
+[//]: # (which you can find at [PairTree GitHub]&#40;https://github.com/davidrasm/PairTree&#41; )
+
+[//]: # (and in [hiv_zurich/Zurich.nwk]&#40;hiv_zurich/Zurich.nwk&#41;. )
+
+[//]: # ()
+[//]: # (## Installation)
+
+[//]: # ()
+[//]: # (There are 4 alternative ways to run __bdeissct_dl__ on your computer: )
+
+[//]: # (with [docker]&#40;https://www.docker.com/community-edition&#41;, )
+
+[//]: # ([apptainer]&#40;https://apptainer.org/&#41;,)
+
+[//]: # (in Python3, or via command line &#40;requires installation with Python3&#41;.)
+
+[//]: # ()
+[//]: # ()
+[//]: # ()
+[//]: # (### Run in python3 or command-line &#40;for linux systems, recommended Ubuntu 21 or newer versions&#41;)
+
+[//]: # ()
+[//]: # (You could either install python &#40;version 3.9 or higher&#41; system-wide and then install bdeissct_dl via pip:)
+
+[//]: # (```bash)
+
+[//]: # (sudo apt install -y python3 python3-pip python3-setuptools python3-distutils)
+
+[//]: # (pip3 install bdeissct_dl)
+
+[//]: # (```)
+
+[//]: # ()
+[//]: # (or alternatively, you could install python &#40;version 3.9 or higher&#41; and bdeissct_dl via [conda]&#40;https://conda.io/docs/&#41; &#40;make sure that conda is installed first&#41;. )
+
+[//]: # (Here we will create a conda environment called _phyloenv_:)
+
+[//]: # (```bash)
+
+[//]: # (conda create --name phyloenv python=3.12)
+
+[//]: # (conda activate phyloenv)
+
+[//]: # (pip install bdeissct_dl)
+
+[//]: # (```)
+
+[//]: # ()
+[//]: # ()
+[//]: # (#### Basic usage in a command line)
+
+[//]: # (If you installed __bdeissct_dl__ in a conda environment &#40;here named _phyloenv_&#41;, do not forget to first activate it, e.g.)
+
+[//]: # ()
+[//]: # (```bash)
+
+[//]: # (conda activate phyloenv)
+
+[//]: # (```)
+
+[//]: # ()
+[//]: # (Run the following command to estimate the BDEISS_CT parameters and their 95% CIs for this tree, assuming the sampling probability of 0.25, )
+
+[//]: # (and save the estimated parameters to a comma-separated file estimates.csv.)
+
+[//]: # (```bash)
+
+[//]: # (bdeissct_infer --nwk Zurich.nwk --ci --p 0.25 --log estimates.csv)
+
+[//]: # (```)
+
+[//]: # ()
+[//]: # (#### Help)
+
+[//]: # ()
+[//]: # (To see detailed options, run:)
+
+[//]: # (```bash)
+
+[//]: # (bdeissct_infer --help)
+
+[//]: # (```)
+
+[//]: # ()
+[//]: # ()
+[//]: # (### Run with docker)
+
+[//]: # ()
+[//]: # (#### Basic usage)
+
+[//]: # (Once [docker]&#40;https://www.docker.com/community-edition&#41; is installed, )
+
+[//]: # (run the following command to estimate BDEISS-CT model parameters:)
+
+[//]: # (```bash)
+
+[//]: # (docker run -v <path_to_the_folder_containing_the_tree>:/data:rw -t evolbioinfo/bdeissct --nwk /data/Zurich.nwk --ci --p 0.25 --log /data/estimates.csv)
+
+[//]: # (```)
+
+[//]: # ()
+[//]: # (This will produce a comma-separated file estimates.csv in the <path_to_the_folder_containing_the_tree> folder,)
+
+[//]: # ( containing the estimated parameter values and their 95% CIs &#40;can be viewed with a text editor, Excel or Libre Office Calc&#41;.)
+
+[//]: # ()
+[//]: # (#### Help)
+
+[//]: # ()
+[//]: # (To see advanced options, run)
+
+[//]: # (```bash)
+
+[//]: # (docker run -t evolbioinfo/bdeissct -h)
+
+[//]: # (```)
+
+[//]: # ()
+[//]: # ()
+[//]: # ()
+[//]: # (### Run with apptainer)
+
+[//]: # ()
+[//]: # (#### Basic usage)
+
+[//]: # (Once [apptainer]&#40;https://apptainer.org/docs/user/latest/quick_start.html#installation&#41; is installed, )
+
+[//]: # (run the following command to estimate BDEISS-CT model parameters &#40;from the folder where the Zurich.nwk tree is contained&#41;:)
+
+[//]: # ()
+[//]: # (```bash)
+
+[//]: # (apptainer run docker://evolbioinfo/bdeissct --nwk Zurich.nwk --ci --p 0.25 --log estimates.csv)
+
+[//]: # (```)
+
+[//]: # ()
+[//]: # (This will produce a comma-separated file estimates.csv,)
+
+[//]: # ( containing the estimated parameter values and their 95% CIs &#40;can be viewed with a text editor, Excel or Libre Office Calc&#41;.)
+
+[//]: # ()
+[//]: # ()
+[//]: # (#### Help)
+
+[//]: # ()
+[//]: # (To see advanced options, run)
+
+[//]: # (```bash)
+
+[//]: # (apptainer run docker://evolbioinfo/bdeissct -h)
+
+[//]: # (```)
+
+[//]: # ()
+[//]: # ()
+
+

bdext-0.1.67.dist-info/RECORD

@@ -0,0 +1,17 @@
+README.md,sha256=Ngj8bt0Yu3LUsvwblmMtUqqjvGyqxv6ku2_cYCb5_DQ,6539
+bdeissct_dl/__init__.py,sha256=QPEiIP-xVqGQgydeqN_9AZgT26IYWeJC4-JlHnd8Rjo,296
+bdeissct_dl/bdeissct_model.py,sha256=sQclYN5V8utw6wEMDN0_Ua-0NeuyuWHG_e0_jQIUe8Q,1986
+bdeissct_dl/dl_model.py,sha256=CT3tRvH7y7_guyR7SUELv0eLEVpGU_PcXci1lIGIb9M,3705
+bdeissct_dl/estimator.py,sha256=QBWA8R0pBPZPd3JvItdJS2lN1J3VqvdJqBMzCi-NADs,3336
+bdeissct_dl/model_serializer.py,sha256=s1yBzQjhtr-w7eT8bTsNkG9_xnYRZrUc3HkeOzNZpQY,2464
+bdeissct_dl/scaler_fitting.py,sha256=9X0O7-Wc9xGTI-iF-Pfp1PPoW7j01wZUfJVZf8ky-IU,1752
+bdeissct_dl/sumstat_checker.py,sha256=TQ0nb86-BXmusqgMnOJusLpR4ul3N3Hi886IWUovrMI,1846
+bdeissct_dl/training.py,sha256=H5wA3V72nhc9Km7kvKmzjCYw0N1itMGDbj9c-Uat5BU,8350
+bdeissct_dl/tree_encoder.py,sha256=vH__CDPNVvayhNoK6_Z4xJA9_R78G1RvneG0RY2aj-0,18340
+bdeissct_dl/tree_manager.py,sha256=UXxUVmEkxwUhKpJeACVgiXZ8Kp1o_hiv8Qb80b6qmVU,11814
+bdext-0.1.67.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+bdext-0.1.67.dist-info/METADATA,sha256=Ky7QOtU9xcrVvo_kjsPpx5jsaIcDwXFOYpoxYoCJaug,7479
+bdext-0.1.67.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+bdext-0.1.67.dist-info/entry_points.txt,sha256=lcAwyk-Fc0G_w4Ex7KDivh7h1tzSA99PRMcy971b-nM,208
+bdext-0.1.67.dist-info/top_level.txt,sha256=z4dadFfcLghr4lwROy7QR3zEICpa-eCPT6mmcoHeEJY,12
+bdext-0.1.67.dist-info/RECORD,,

{bdext-0.1.65.dist-info → bdext-0.1.67.dist-info}/entry_points.txt

@@ -3,6 +3,4 @@ bdeissct_encode = bdeissct_dl.tree_encoder:main
 bdeissct_fit_scaler = bdeissct_dl.scaler_fitting:main
 bdeissct_infer = bdeissct_dl.estimator:main
 bdeissct_train = bdeissct_dl.training:main
-ct_infer = bdeissct_dl.estimator_ct:main
-ct_train = bdeissct_dl.train_ct:main
 

bdeissct_dl/estimator_ct.py

@@ -1,63 +0,0 @@
-import pandas as pd
-
-from bdeissct_dl import MODEL_PATH
-from bdeissct_dl.bdeissct_model import CT_EPI_COLUMNS, CT_RATE_COLUMNS
-from bdeissct_dl.model_serializer import load_model_keras, load_scaler_numpy
-
-
-def predict_parameters(df, model_path=MODEL_PATH):
-    feature_columns = CT_EPI_COLUMNS
-    X = df.loc[:, feature_columns].to_numpy(dtype=float, na_value=0)
-
-    # Standardization of the input features with a
-    # standard scaler
-    scaler_x = load_scaler_numpy(model_path, suffix='ct.x')
-    if scaler_x:
-        X = scaler_x.transform(X)
-
-    target_columns = CT_RATE_COLUMNS
-
-    result = None
-    for col in target_columns:
-        model = load_model_keras(model_path, f'CT.{col}')
-        Y_pred = model.predict(X)
-
-        if len(Y_pred[col].shape) == 2 and Y_pred[col].shape[1] == 1:
-            Y_pred[col] = Y_pred[col].squeeze(axis=1)
-
-        res_df = pd.DataFrame.from_dict(Y_pred, orient='columns')
-        result = result.join(res_df, how='outer') if result is not None else res_df
-
-    return result
-
-
-def main():
-    """
-    Entry point for tree parameter estimation with a BDCT model with command-line arguments.
-    :return: void
-    """
-    import argparse
-
-    parser = \
-        argparse.ArgumentParser(description="Estimate CT rates from other model parameters.")
-    parser.add_argument('--model_path', default=MODEL_PATH,
-                        help='By default our pretrained CT model is used, '
-                             'but it is possible to specify a path to a custom folder here, '
-                             'containing files "CT.keras" (with the model), '
-                             'and scaler-related files to rescale the input data X, and the output Y: '
-                             'for X: "data_scalerct.x_mean.npy", "data_scalerct.x_scale.npy", "data_scalerct.x_var.npy" '
-                             '(unpickled numpy-saved arrays), '
-                             'and "data_scalerct.x_n_samples_seen.txt" '
-                             'a text file containing the number of examples in the training set). '
-                             'For Y the file names are the same, just x replaced by y, e.g., "data_scalerct.y_mean.npy". '
-                             )
-    parser.add_argument('--log', default=None, type=str, help="output log file")
-    parser.add_argument('--sumstats', default=None, type=str, help="input file(s) with epi parameters")
-    params = parser.parse_args()
-
-    df = pd.read_csv(params.sumstats)
-    predict_parameters(df, model_path=params.model_path).to_csv(params.log, header=True)
-
-
-if '__main__' == __name__:
-    main()

bdeissct_dl/main_covid.py

@@ -1,76 +0,0 @@
-import pandas as pd
-
-from bdeissct_dl.tree_encoder import forest2sumstat_df
-from bdeissct_dl.bdeissct_model import MODELS
-from bdeissct_dl.estimator import predict_parameters
-from bdeissct_dl.tree_manager import read_forest
-from bdeissct_dl.sumstat_checker import check_sumstats
-from pybdei import infer as bdei_infer
-from bdct.bd_model import infer as bd_infer
-from bdct.tree_manager import annotate_forest_with_time, get_T
-
-MP = '/home/azhukova/projects/bdeissct_dl/simulations_bdeissct/models/200_500'
-
-NWKS = ['/home/azhukova/projects/bdeissct_dl/covid/wave3.days.nwk',
-        '/home/azhukova/projects/bdeissct_dl/covid/wave4.days.nwk',
-        '/home/azhukova/projects/bdeissct_dl/covid/HIV_Zurich.nwk']
-RHOS = [0.238, 0.154, 0.25, 0.6]
-
-
-# for nwk, rho in zip(NWKS[:2], RHOS):
-#     forest = read_forest(nwk)
-#     if 'wave' in nwk:
-#         for n in forest[0].traverse():
-#             n.dist = n.dist * 365.25  # convert to days
-#             if n.is_leaf():
-#                 n.name = n.name.split('|')[0]
-#         forest[0].write(outfile=nwk.split('.')[0] + '.days.nwk')
-# exit()
-
-# for nwk, rho in zip(NWKS[3:], RHOS):
-#     forest = read_forest(nwk)
-#     forest[0].write(outfile=nwk.replace('nexus', 'nwk'))
-# exit()
-
-for nwk, rho in zip(NWKS, RHOS):
-    forest = read_forest(nwk)
-    check_sumstats(forest2sumstat_df(forest, rho), model_path=MP)
-
-    sumstat_df = forest2sumstat_df(forest, rho)
-    result_df = pd.DataFrame()
-    for model in MODELS:
-        predictions = predict_parameters(sumstat_df, model_name=model, model_path=MP)
-        print(predictions)
-        predictions.index = [model]
-        result_df = pd.concat((result_df, predictions))
-    # result_df['d_E'] = result_df['f_E'] * result_df['d']
-    # result_df['d_I'] = (1 - result_df['f_E']) * result_df['d']
-
-    forest = read_forest(nwk)
-    # resolve_forest(forest)
-    annotate_forest_with_time(forest)
-    T = get_T(T=None, forest=forest)
-
-    (la, psi, _), _ = bd_infer(forest, T, p=rho)
-    result_df.loc['BD-ML', ['R', 'd']] = [la / psi, 1 / psi]
-    # result_df.loc['BD-ML', ['R', 'd', 'd_I']] = [la / psi, 1 / psi, 1 / psi]
-
-    bdei_res, _ = bdei_infer(nwk, p=rho)
-    mu, la, psi = bdei_res.mu, bdei_res.la, bdei_res.psi
-    result_df.loc['BDEI-ML', ['R', 'd']] = [la / psi, 1 / mu + 1 / psi]
-    # result_df.loc['BDEI-ML', ['R', 'd', 'd_E', 'd_I', 'f_E']] = [
-    #     la / psi,
-    #     1 / mu + 1 / psi,
-    #     1 / mu,
-    #     1 / psi,
-    #     (1 / mu) / (1 / mu + 1 / psi)
-    # ]
-
-
-
-    for col in result_df.columns:
-        result_df[col] = result_df[col].apply(lambda x: f'{x:.2f}' if not pd.isna(x) else '')
-
-    result_df[['R', 'd']].to_csv(nwk.replace('.nwk', '.small_est').replace('.nexus', '.small_est'))
-    # result_df[['R', 'd', 'd_E', 'd_I', 'f_S', 'X_S', 'upsilon', 'X_C', 'f_E']].to_csv(nwk.replace('.nwk', '.small_est').replace('.nexus', '.small_est'))
-

bdeissct_dl/model_finder.py

@@ -1,47 +0,0 @@
-import pandas as pd
-
-from bdeissct_dl import MODEL_FINDER_PATH
-from bdeissct_dl.model_serializer import load_model_keras
-from bdeissct_dl.training_model_finder import get_test_data
-from bdeissct_dl.tree_encoder import forest2sumstat_df
-from bdeissct_dl.tree_manager import read_forest
-from bdeissct_dl.bdeissct_model import MODELS
-
-
-def predict_model(forest_sumstats):
-    X = get_test_data(forest_sumstats)
-    model = load_model_keras(MODEL_FINDER_PATH)
-    Y_pred = model.predict(X)
-    return pd.DataFrame(Y_pred, columns=MODELS)
-
-
-def main():
-    """
-    Entry point for BDCT model finder with command-line arguments.
-    :return: void
-    """
-    import argparse
-
-    parser = \
-        argparse.ArgumentParser(description="Find the BDEISSCT model flavour that could have generated this forest.")
-    parser.add_argument('--nwk', required=False, default=None, type=str, help="input tree file")
-    parser.add_argument('--p', required=False, default=0, type=float, help='sampling probability')
-    parser.add_argument('--log', required=True, type=str, help="output log file")
-    parser.add_argument('--sumstats', default=None, type=str, help="input tree file(s) encoded as sumstats")
-    params = parser.parse_args()
-
-    if not params.sumstats:
-        if params.p <= 0 or params.p > 1:
-            raise ValueError('The sampling probability must be grater than 0 and not greater than 1.')
-
-        forest = read_forest(params.nwk)
-        print(f'Read a forest of {len(forest)} trees with {sum(len(_) for _ in forest)} tips in total')
-        forest_df = forest2sumstat_df(forest, rho=params.p)
-    else:
-        forest_df = pd.read_csv(params.sumstats)
-
-    predict_model(forest_df).to_csv(params.log, header=True)
-
-
-if '__main__' == __name__:
-    main()

bdeissct_dl/pinball_loss.py

@@ -1,48 +0,0 @@
-import tensorflow as tf
-
-@tf.keras.utils.register_keras_serializable()
-class MultiQuantilePinballLoss(tf.keras.losses.Loss):
-    def __init__(self, quantiles, name="multi_quantile_pinball_loss"):
-        super().__init__(name=name)
-        self.quantiles = quantiles
-
-    def call(self, y_true, y_pred):
-        """
-        Compute the Pinball loss for multiple quantiles.
-
-        Args:
-        y_true: Tensor of true target values, shape (batch_size, n_targets).
-        y_pred: Tensor of predicted values, shape (batch_size, n_targets * n_quantiles).
-
-        Returns:
-        A scalar tensor representing the aggregated Pinball loss.
-        """
-
-        n_quantiles = len(self.quantiles)
-        n_targets = tf.shape(y_true)[1]
-
-        # Reshape y_pred to (batch_size, n_targets, n_quantiles)
-        y_pred = tf.reshape(y_pred, [-1, n_targets, n_quantiles])
-
-        # Calculate the Pinball loss for each quantile
-        loss = 0
-        for i, tau in enumerate(self.quantiles):
-            error = y_true - y_pred[:, :, i]  # Error for the i-th quantile
-            quantile_loss = tf.maximum(tau * error, (tau - 1) * error)
-            loss += tf.reduce_mean(quantile_loss)
-
-        # Return the mean loss over all quantiles
-        return loss / n_quantiles
-
-    def get_config(self):
-        # Serialize the quantiles
-        config = super().get_config()
-        config.update({
-            "quantiles": self.quantiles
-        })
-        return config
-
-    @classmethod
-    def from_config(cls, config):
-        # Deserialize the quantiles
-        return cls(quantiles=config["quantiles"])

bdeissct_dl/train_ct.py

@@ -1,125 +0,0 @@
-import os
-
-import numpy as np
-import tensorflow as tf
-from sklearn.preprocessing import StandardScaler
-
-from bdeissct_dl import MODEL_PATH, BATCH_SIZE, EPOCHS
-from bdeissct_dl.bdeissct_model import LA, PSI, RHO
-from bdeissct_dl.dl_model import build_model, LEARNING_RATE, LOSS_FUNCTIONS, LOSS_WEIGHTS
-from bdeissct_dl.model_serializer import save_model_keras, save_scaler_joblib, save_scaler_numpy
-from bdeissct_dl.scaler_fitting import fit_scalers
-from bdeissct_dl.training import get_data_characteristics, get_train_data
-from bdeissct_dl.bdeissct_model import CT_EPI_COLUMNS, CT_RATE_COLUMNS
-
-
-def build_model(target_columns, n_x, optimizer=None, metrics=None):
-    """
-    Build a FFNN of funnel shape with 4 hidden layers.
-    We use a 50% dropout after the first 2 hidden layers.
-    This architecture follows the PhyloDeep paper [Voznica et al. Nature 2022].
-
-    :param n_x: input size (number of features)
-    :param optimizer: by default Adam with learning rate of 0.001
-    :param metrics: evaluation metrics, by default no metrics
-    :return: the model instance: tf.keras.models.Sequential
-    """
-
-    inputs = tf.keras.Input(shape=(n_x,))
-
-    # (Your hidden layers go here)
-    x = tf.keras.layers.Dense(8, activation='elu', name=f'layer1_dense8_elu')(inputs)
-    x = tf.keras.layers.Dense(4, activation='elu', name=f'layer2_dense6_elu')(x)
-    x = tf.keras.layers.Dense(4, activation='elu', name=f'layer2_dense4_elu')(x)
-    x = tf.keras.layers.Dense(2, activation='elu', name=f'layer3_dense2_elu')(x)
-
-    outputs = {}
-
-    if LA in target_columns:
-        outputs[LA] = tf.keras.layers.Dense(1, activation="softplus", name=LA)(x) # positive values only
-    if PSI in target_columns:
-        outputs[PSI] = tf.keras.layers.Dense(1, activation="softplus", name=PSI)(x) # positive values only
-    if RHO in target_columns:
-        outputs[RHO] = tf.keras.layers.Dense(1, activation="sigmoid", name=RHO)(x)
-
-    model = tf.keras.models.Model(inputs=inputs, outputs=outputs)
-
-    if optimizer is None:
-        optimizer = tf.keras.optimizers.Adam(learning_rate=LEARNING_RATE)
-
-    model.compile(optimizer=optimizer,
-                  loss={col: LOSS_FUNCTIONS[col] for col in outputs.keys()},
-                  loss_weights={col: LOSS_WEIGHTS[col] for col in outputs.keys()},
-                  metrics=metrics)
-    return model
-
-def main():
-    """
-    Entry point for DL model training with command-line arguments.
-    :return: void
-    """
-    import argparse
-
-    parser = \
-        argparse.ArgumentParser(description="Train -CT model rate parameter estimator from epi parameters.")
-    parser.add_argument('--train_data', type=str, nargs='+',
-                        help="path to the files where the encoded training data are stored")
-    parser.add_argument('--val_data', type=str, nargs='+',
-                        help="path to the files where the encoded validation data are stored")
-
-    parser.add_argument('--epochs', type=int, default=EPOCHS, help='number of epochs to train the model')
-    parser.add_argument('--model_path', default=MODEL_PATH, type=str,
-                        help="path to the folder where the trained model should be stored.")
-    params = parser.parse_args()
-
-    os.makedirs(params.model_path, exist_ok=True)
-
-    # R,f_E,f_S,X_S,upsilon,X_C,kappa,la are given
-    # psi is to be predicted
-
-    feature_columns = CT_EPI_COLUMNS
-    target_columns = CT_RATE_COLUMNS
-    # reshuffle params.train_data order
-    if len(params.train_data) > 1:
-        np.random.shuffle(params.train_data)
-    if len(params.val_data) > 1:
-        np.random.shuffle(params.val_data)
-
-
-    x_indices, y_col2index = get_data_characteristics(paths=params.train_data,
-                                                      feature_columns=feature_columns,
-                                                      target_columns=target_columns)
-
-    scaler_x = StandardScaler()
-    fit_scalers(paths=params.train_data, x_indices=x_indices, scaler_x=scaler_x)
-
-    if scaler_x is not None:
-        save_scaler_joblib(scaler_x, params.model_path, suffix='ct.x')
-        save_scaler_numpy(scaler_x, params.model_path, suffix='ct.x')
-
-    for col, y_idx in y_col2index.items():
-        print(f'Training to predict {col} for CT...')
-
-        model = build_model([col], n_x=len(x_indices))
-        print(f'Building a model from scratch with {len(x_indices)} input features and {col} as output.')
-        print(model.summary())
-
-        ds_train = get_train_data([col], x_indices, [y_idx], file_pattern=None, filenames=params.train_data, \
-                                  scaler_x=scaler_x, batch_size=BATCH_SIZE * 8, shuffle=True)
-        ds_val = get_train_data([col], x_indices, [y_idx], file_pattern=None, filenames=params.val_data, \
-                                scaler_x=scaler_x, batch_size=BATCH_SIZE * 8, shuffle=True)
-
-        #early stopping to avoid overfitting
-        early_stop = tf.keras.callbacks.EarlyStopping(monitor='val_loss', patience=25)
-
-        #Training of the Network, with an independent validation set
-        model.fit(ds_train, verbose=1, epochs=params.epochs, validation_data=ds_val, callbacks=[early_stop])
-
-        print(f'Saving the trained model CT.{col} to {params.model_path}...')
-
-        save_model_keras(model, path=params.model_path, model_name=f'CT.{col}')
-
-
-
-if '__main__' == __name__:
-    main()