From 90f0d4d0e95863f67afc976a818000de886849ac Mon Sep 17 00:00:00 2001
From: Anja Adamov <57316423+adamovanja@users.noreply.github.com>
Date: Sun, 3 Mar 2024 19:55:00 +0100
Subject: [PATCH] ADD: CLI runnable functions

---
 .gitignore                           |   4 +-
 README.md                            |   9 +
 experiments/try_tune.ipynb           | 922 +++++++--------------------
 q2_ritme/config.py                   |   9 -
 q2_ritme/eval_best_trial_overall.py  |  67 ++
 q2_ritme/evaluate_all_experiments.py |  10 +-
 q2_ritme/evaluate_models.py          |  60 +-
 q2_ritme/run_config.json             |  21 +
 q2_ritme/run_n_eval_tune.py          | 118 ++++
 q2_ritme/tune_models.py              |   9 +-
 10 files changed, 483 insertions(+), 746 deletions(-)
 delete mode 100644 q2_ritme/config.py
 create mode 100644 q2_ritme/eval_best_trial_overall.py
 create mode 100644 q2_ritme/run_config.json
 create mode 100644 q2_ritme/run_n_eval_tune.py

diff --git a/.gitignore b/.gitignore
index 857ab3b..3a2d671 100644
--- a/.gitignore
+++ b/.gitignore
@@ -143,8 +143,8 @@ dmypy.json
 # MLflow model logs
 **/mlruns/**
 
-# Best model checkpoints
-**/best_models/**
+# Model checkpoints
+**/models/**
 
 # Sequence and metadata
 **/experiments/data/**
diff --git a/README.md b/README.md
index cd2808a..299a846 100644
--- a/README.md
+++ b/README.md
@@ -13,8 +13,17 @@ make dev
 ```
 
 ## Model training
+To train models with a defined configuration in `q2_ritme/config.json` run:
+````
+python q2_ritme/run_n_eval_tune.py --config q2_ritme/run_config.json
+````
+
 Once you have trained some models, you can check the progress of the trained models by launching `mlflow ui --backend-store-uri experiments/mlruns`.
 
+To evaluate the best trial (trial < experiment) of all launched experiments, run:
+````
+python q2_ritme/eval_best_trial_overall.py --model_path "experiments/models"
+````
 
 ## Background
 ### Why ray tune?
diff --git a/experiments/try_tune.ipynb b/experiments/try_tune.ipynb
index 080c553..f96778e 100644
--- a/experiments/try_tune.ipynb
+++ b/experiments/try_tune.ipynb
@@ -1,736 +1,256 @@
 {
- "cells": [
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Try out framework with simulated data"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "\n",
-    "import pandas as pd\n",
-    "from IPython.display import display\n",
-    "\n",
-    "from q2_ritme.config import (\n",
-    "    HOST_ID,\n",
-    "    MLFLOW_TRACKING_URI,\n",
-    "    SEED_DATA,\n",
-    "    SEED_MODEL,\n",
-    "    TARGET,\n",
-    "    TRAIN_SIZE,\n",
-    ")\n",
-    "from q2_ritme.evaluate_all_experiments import (\n",
-    "    best_trial_name,\n",
-    "    get_all_exp_analyses,\n",
-    "    compare_trials,\n",
-    ")\n",
-    "from q2_ritme.evaluate_models import (\n",
-    "    aggregate_best_models_metrics_and_configs,\n",
-    "    get_predictions,\n",
-    "    plot_best_models_comparison,\n",
-    "    plot_model_training_over_iterations,\n",
-    "    plot_rmse_over_experiments,\n",
-    "    plot_rmse_over_time,\n",
-    "    retrieve_best_models,\n",
-    ")\n",
-    "from q2_ritme.process_data import load_n_split_data\n",
-    "from q2_ritme.tune_models import run_all_trials\n",
-    "\n",
-    "# 30.437 is avg. number of days per month\n",
-    "DAYS_PER_MONTH = 30.437\n",
-    "%matplotlib inline\n",
-    "%load_ext autoreload\n",
-    "%autoreload 2"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "ls_model_types = [\"nn\", \"xgb\", \"linreg\", \"rf\"]\n",
-    "experiment_tag = \"test_synthetic\""
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Load and split data"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
+  "cells": [
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train: (75, 22), Test: (25, 22)\n"
-     ]
-    }
-   ],
-   "source": [
-    "train_val, test = load_n_split_data(None, None, HOST_ID, TARGET, TRAIN_SIZE, SEED_DATA)"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Run all experiments"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "comparison_output = os.path.join(\"best_models\", experiment_tag)\n",
-    "\n",
-    "if os.path.exists(comparison_output):\n",
-    "    raise ValueError(\n",
-    "        f\"This experiment tag already exists: {experiment_tag}. Please use another one.\"\n",
-    "    )"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# Try out framework with simulated data"
+      ]
+    },
     {
-     "data": {
-      "text/html": [
-       "<div class=\"tuneStatus\">\n",
-       "  <div style=\"display: flex;flex-direction: row\">\n",
-       "    <div style=\"display: flex;flex-direction: column;\">\n",
-       "      <h3>Tune Status</h3>\n",
-       "      <table>\n",
-       "<tbody>\n",
-       "<tr><td>Current time:</td><td>2024-03-02 18:30:00</td></tr>\n",
-       "<tr><td>Running for: </td><td>00:00:11.82        </td></tr>\n",
-       "<tr><td>Memory:      </td><td>10.0/16.0 GiB      </td></tr>\n",
-       "</tbody>\n",
-       "</table>\n",
-       "    </div>\n",
-       "    <div class=\"vDivider\"></div>\n",
-       "    <div class=\"systemInfo\">\n",
-       "      <h3>System Info</h3>\n",
-       "      Using AsyncHyperBand: num_stopped=0<br>Bracket: Iter 80.000: None | Iter 20.000: None | Iter 5.000: None<br>Logical resource usage: 1.0/8 CPUs, 0/0 GPUs\n",
-       "    </div>\n",
-       "    \n",
-       "  </div>\n",
-       "  <div class=\"hDivider\"></div>\n",
-       "  <div class=\"trialStatus\">\n",
-       "    <h3>Trial Status</h3>\n",
-       "    <table>\n",
-       "<thead>\n",
-       "<tr><th>Trial name          </th><th>status    </th><th>loc            </th><th>bootstrap  </th><th style=\"text-align: right;\">  data_alr_denom_idx</th><th>data_transform  </th><th style=\"text-align: right;\">  max_depth</th><th>max_features  </th><th style=\"text-align: right;\">       min_impurity_decreas\n",
-       "e</th><th style=\"text-align: right;\">  min_samples_leaf</th><th style=\"text-align: right;\">  min_samples_split</th><th style=\"text-align: right;\">  n_estimators</th><th style=\"text-align: right;\">  iter</th><th style=\"text-align: right;\">  total time (s)</th><th style=\"text-align: right;\">  rmse_val</th><th style=\"text-align: right;\">  rmse_train</th></tr>\n",
-       "</thead>\n",
-       "<tbody>\n",
-       "<tr><td>train_rf_785d2_00000</td><td>TERMINATED</td><td>127.0.0.1:16508</td><td>True       </td><td style=\"text-align: right;\">                  11</td><td>                </td><td style=\"text-align: right;\">          8</td><td>log2          </td><td style=\"text-align: right;\">0.0001</td><td style=\"text-align: right;\">            0.0001</td><td style=\"text-align: right;\">              0.001</td><td style=\"text-align: right;\">           767</td><td style=\"text-align: right;\">     1</td><td style=\"text-align: right;\">        1.78992 </td><td style=\"text-align: right;\">   261.983</td><td style=\"text-align: right;\">     82.0075</td></tr>\n",
-       "<tr><td>train_rf_785d2_00001</td><td>TERMINATED</td><td>127.0.0.1:16509</td><td>False      </td><td style=\"text-align: right;\">                  17</td><td>clr             </td><td style=\"text-align: right;\">         27</td><td>log2          </td><td style=\"text-align: right;\">0.0001</td><td style=\"text-align: right;\">            0.001 </td><td style=\"text-align: right;\">              0.01 </td><td style=\"text-align: right;\">           753</td><td style=\"text-align: right;\">     1</td><td style=\"text-align: right;\">        1.97464 </td><td style=\"text-align: right;\">   277.116</td><td style=\"text-align: right;\">     76.3923</td></tr>\n",
-       "<tr><td>train_rf_785d2_00002</td><td>TERMINATED</td><td>127.0.0.1:16510</td><td>True       </td><td style=\"text-align: right;\">                   8</td><td>ilr             </td><td style=\"text-align: right;\">         15</td><td>0.1           </td><td style=\"text-align: right;\">0.01  </td><td style=\"text-align: right;\">            0.0001</td><td style=\"text-align: right;\">              0.01 </td><td style=\"text-align: right;\">           304</td><td style=\"text-align: right;\">     1</td><td style=\"text-align: right;\">        0.892723</td><td style=\"text-align: right;\">   266.698</td><td style=\"text-align: right;\">     81.9973</td></tr>\n",
-       "<tr><td>train_rf_785d2_00003</td><td>TERMINATED</td><td>127.0.0.1:16511</td><td>True       </td><td style=\"text-align: right;\">                   3</td><td>alr             </td><td style=\"text-align: right;\">         25</td><td>log2          </td><td style=\"text-align: right;\">0.01  </td><td style=\"text-align: right;\">            1e-05 </td><td style=\"text-align: right;\">              0.1  </td><td style=\"text-align: right;\">           517</td><td style=\"text-align: right;\">     1</td><td style=\"text-align: right;\">        1.4045  </td><td style=\"text-align: right;\">   250.474</td><td style=\"text-align: right;\">     80.6112</td></tr>\n",
-       "</tbody>\n",
-       "</table>\n",
-       "  </div>\n",
-       "</div>\n",
-       "<style>\n",
-       ".tuneStatus {\n",
-       "  color: var(--jp-ui-font-color1);\n",
-       "}\n",
-       ".tuneStatus .systemInfo {\n",
-       "  display: flex;\n",
-       "  flex-direction: column;\n",
-       "}\n",
-       ".tuneStatus td {\n",
-       "  white-space: nowrap;\n",
-       "}\n",
-       ".tuneStatus .trialStatus {\n",
-       "  display: flex;\n",
-       "  flex-direction: column;\n",
-       "}\n",
-       ".tuneStatus h3 {\n",
-       "  font-weight: bold;\n",
-       "}\n",
-       ".tuneStatus .hDivider {\n",
-       "  border-bottom-width: var(--jp-border-width);\n",
-       "  border-bottom-color: var(--jp-border-color0);\n",
-       "  border-bottom-style: solid;\n",
-       "}\n",
-       ".tuneStatus .vDivider {\n",
-       "  border-left-width: var(--jp-border-width);\n",
-       "  border-left-color: var(--jp-border-color0);\n",
-       "  border-left-style: solid;\n",
-       "  margin: 0.5em 1em 0.5em 1em;\n",
-       "}\n",
-       "</style>\n"
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import os\n",
+        "\n",
+        "import pandas as pd\n",
+        "\n",
+        "from q2_ritme.config import (\n",
+        "    experiment_tag,\n",
+        "    host_id,\n",
+        "    ls_model_types,\n",
+        "    mlflow_tracking_uri,\n",
+        "    path_to_ft,\n",
+        "    path_to_md,\n",
+        "    seed_data,\n",
+        "    seed_model,\n",
+        "    target,\n",
+        "    train_size,\n",
+        ")\n",
+        "from q2_ritme.evaluate_all_experiments import (\n",
+        "    best_trial_name,\n",
+        "    compare_trials,\n",
+        "    get_all_exp_analyses,\n",
+        ")\n",
+        "from q2_ritme.evaluate_models import (\n",
+        "    aggregate_best_models_metrics_and_configs,\n",
+        "    get_predictions,\n",
+        "    plot_best_models_comparison,\n",
+        "    plot_model_training_over_iterations,\n",
+        "    plot_rmse_over_experiments,\n",
+        "    plot_rmse_over_time,\n",
+        "    retrieve_best_models,\n",
+        ")\n",
+        "from q2_ritme.process_data import load_n_split_data\n",
+        "from q2_ritme.tune_models import run_all_trials\n",
+        "\n",
+        "%matplotlib inline\n",
+        "%load_ext autoreload\n",
+        "%autoreload 2"
       ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
     },
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\u001b[2m\u001b[36m(train_rf pid=16510)\u001b[0m Train: (48, 21), Test: (27, 21)\u001b[32m [repeated 4x across cluster]\u001b[0m\n"
-     ]
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Load and split data"
+      ]
     },
     {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2024-03-02 18:30:00,844\tINFO tune.py:1148 -- Total run time: 11.85 seconds (11.81 seconds for the tuning loop).\n"
-     ]
-    }
-   ],
-   "source": [
-    "result_dic = run_all_trials(\n",
-    "    train_val,\n",
-    "    TARGET,\n",
-    "    HOST_ID,\n",
-    "    SEED_DATA,\n",
-    "    SEED_MODEL,\n",
-    "    MLFLOW_TRACKING_URI,\n",
-    "    experiment_tag,\n",
-    "    model_types=ls_model_types,\n",
-    "    fully_reproducible=False,\n",
-    ")"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Evaluate best models: train_val vs. test - performance"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "train_val, test = load_n_split_data(\n",
+        "    path_to_md, path_to_ft, host_id, target, train_size, seed_data\n",
+        ")"
+      ]
+    },
     {
-     "data": {
-      "text/plain": [
-       "<Figure size 2560x1920 with 0 Axes>"
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Run all experiments"
       ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
     },
     {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "exp_comparison_output = os.path.join(\"best_models\", experiment_tag)\n",
+        "\n",
+        "if os.path.exists(exp_comparison_output):\n",
+        "    raise ValueError(\n",
+        "        f\"This experiment tag already exists: {experiment_tag}. Please use another one.\"\n",
+        "    )"
       ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "best_model_dic = retrieve_best_models(result_dic)\n",
-    "\n",
-    "# Assuming best_model_dic and the datasets are available\n",
-    "non_features = [TARGET, HOST_ID]\n",
-    "features = [x for x in train_val if x not in non_features]\n",
-    "\n",
-    "preds_dic = {}\n",
-    "for model_type, tmodel in best_model_dic.items():\n",
-    "    train_pred = get_predictions(train_val, tmodel, TARGET, features, \"train\")\n",
-    "    test_pred = get_predictions(test, tmodel, TARGET, features, \"test\")\n",
-    "    all_pred = pd.concat([train_pred, test_pred])\n",
-    "\n",
-    "    # save all predictions to model file\n",
-    "    path2save = os.path.join(tmodel.path, \"predictions.csv\")\n",
-    "    all_pred.to_csv(path2save, index=True)\n",
-    "    preds_dic[model_type] = all_pred\n",
-    "\n",
-    "plot_rmse_over_experiments(preds_dic, comparison_output)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [
+    },
     {
-     "data": {
-      "text/plain": [
-       "<Figure size 1920x1440 with 0 Axes>"
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "result_dic = run_all_trials(\n",
+        "    train_val,\n",
+        "    target,\n",
+        "    host_id,\n",
+        "    seed_data,\n",
+        "    seed_model,\n",
+        "    mlflow_tracking_uri,\n",
+        "    experiment_tag,\n",
+        "    model_types=ls_model_types,\n",
+        "    fully_reproducible=False,\n",
+        ")"
       ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
     },
     {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1000x500 with 1 Axes>"
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Evaluate best models: train_val vs. test - performance"
       ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plot_rmse_over_time(preds_dic, ls_model_types, DAYS_PER_MONTH, comparison_output)"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Evaluate best models: train vs. val - performance and config"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [
+    },
     {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1200x600 with 1 Axes>"
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "best_model_dic = retrieve_best_models(result_dic)\n",
+        "\n",
+        "# Assuming best_model_dic and the datasets are available\n",
+        "non_features = [target, host_id]\n",
+        "features = [x for x in train_val if x not in non_features]\n",
+        "\n",
+        "preds_dic = {}\n",
+        "for model_type, tmodel in best_model_dic.items():\n",
+        "    train_pred = get_predictions(train_val, tmodel, target, features, \"train\")\n",
+        "    test_pred = get_predictions(test, tmodel, target, features, \"test\")\n",
+        "    all_pred = pd.concat([train_pred, test_pred])\n",
+        "\n",
+        "    # save all predictions to model file\n",
+        "    path2save = os.path.join(tmodel.path, \"predictions.csv\")\n",
+        "    all_pred.to_csv(path2save, index=True)\n",
+        "    preds_dic[model_type] = all_pred\n",
+        "\n",
+        "plot_rmse_over_experiments(preds_dic, exp_comparison_output)"
       ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
     },
     {
-     "data": {
-      "text/html": [
-       "<div>\n",
-       "<style scoped>\n",
-       "    .dataframe tbody tr th:only-of-type {\n",
-       "        vertical-align: middle;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe tbody tr th {\n",
-       "        vertical-align: top;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe thead th {\n",
-       "        text-align: right;\n",
-       "    }\n",
-       "</style>\n",
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: right;\">\n",
-       "      <th></th>\n",
-       "      <th>nn</th>\n",
-       "      <th>xgb</th>\n",
-       "      <th>linreg</th>\n",
-       "      <th>rf</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>data_transform</th>\n",
-       "      <td>alr</td>\n",
-       "      <td>alr</td>\n",
-       "      <td>None</td>\n",
-       "      <td>alr</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>data_alr_denom_idx</th>\n",
-       "      <td>1</td>\n",
-       "      <td>2</td>\n",
-       "      <td>11</td>\n",
-       "      <td>3</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>n_hidden_layers</th>\n",
-       "      <td>12</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>learning_rate</th>\n",
-       "      <td>0.006464</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>batch_size</th>\n",
-       "      <td>32</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>epochs</th>\n",
-       "      <td>50</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>n_units_hl0</th>\n",
-       "      <td>46</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>n_units_hl1</th>\n",
-       "      <td>47</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>n_units_hl2</th>\n",
-       "      <td>40</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>n_units_hl3</th>\n",
-       "      <td>14</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>n_units_hl4</th>\n",
-       "      <td>56</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>n_units_hl5</th>\n",
-       "      <td>54</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>n_units_hl6</th>\n",
-       "      <td>7</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>n_units_hl7</th>\n",
-       "      <td>56</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>n_units_hl8</th>\n",
-       "      <td>14</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>n_units_hl9</th>\n",
-       "      <td>56</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>n_units_hl10</th>\n",
-       "      <td>46</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>n_units_hl11</th>\n",
-       "      <td>50</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>objective</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>reg:squarederror</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>max_depth</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>6</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>25</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>min_child_weight</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>2</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>subsample</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>0.9</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>eta</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>0.01</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>fit_intercept</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>True</td>\n",
-       "      <td>NaN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>n_estimators</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>517</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>min_samples_split</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>0.1</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>min_samples_leaf</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>0.00001</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>max_features</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>log2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>min_impurity_decrease</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>0.01</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>bootstrap</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>True</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "</div>"
-      ],
-      "text/plain": [
-       "                             nn               xgb linreg       rf\n",
-       "data_transform              alr               alr   None      alr\n",
-       "data_alr_denom_idx            1                 2     11        3\n",
-       "n_hidden_layers              12               NaN    NaN      NaN\n",
-       "learning_rate          0.006464               NaN    NaN      NaN\n",
-       "batch_size                   32               NaN    NaN      NaN\n",
-       "epochs                       50               NaN    NaN      NaN\n",
-       "n_units_hl0                  46               NaN    NaN      NaN\n",
-       "n_units_hl1                  47               NaN    NaN      NaN\n",
-       "n_units_hl2                  40               NaN    NaN      NaN\n",
-       "n_units_hl3                  14               NaN    NaN      NaN\n",
-       "n_units_hl4                  56               NaN    NaN      NaN\n",
-       "n_units_hl5                  54               NaN    NaN      NaN\n",
-       "n_units_hl6                   7               NaN    NaN      NaN\n",
-       "n_units_hl7                  56               NaN    NaN      NaN\n",
-       "n_units_hl8                  14               NaN    NaN      NaN\n",
-       "n_units_hl9                  56               NaN    NaN      NaN\n",
-       "n_units_hl10                 46               NaN    NaN      NaN\n",
-       "n_units_hl11                 50               NaN    NaN      NaN\n",
-       "objective                   NaN  reg:squarederror    NaN      NaN\n",
-       "max_depth                   NaN                 6    NaN       25\n",
-       "min_child_weight            NaN                 2    NaN      NaN\n",
-       "subsample                   NaN               0.9    NaN      NaN\n",
-       "eta                         NaN              0.01    NaN      NaN\n",
-       "fit_intercept               NaN               NaN   True      NaN\n",
-       "n_estimators                NaN               NaN    NaN      517\n",
-       "min_samples_split           NaN               NaN    NaN      0.1\n",
-       "min_samples_leaf            NaN               NaN    NaN  0.00001\n",
-       "max_features                NaN               NaN    NaN     log2\n",
-       "min_impurity_decrease       NaN               NaN    NaN     0.01\n",
-       "bootstrap                   NaN               NaN    NaN     True"
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "plot_rmse_over_time(preds_dic, ls_model_types, exp_comparison_output)"
       ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "metrics_all, best_configs = aggregate_best_models_metrics_and_configs(result_dic)\n",
-    "\n",
-    "plot_best_models_comparison(metrics_all, comparison_output)\n",
-    "display(best_configs)"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Evaluate one model over iterations"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [
+    },
     {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Evaluate best models: train vs. val - performance and config"
       ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plot_model_training_over_iterations(\"xgb\", result_dic, labels=[\"data_transform\"])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Postrun evaluation over all experiments performed\n",
-    "experiment > trial"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "path_overall_comparison = os.path.join(\"best_models\", \"compare_all\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "metrics_all, best_configs = aggregate_best_models_metrics_and_configs(result_dic)\n",
+        "\n",
+        "plot_best_models_comparison(metrics_all, exp_comparison_output)\n",
+        "\n",
+        "# save best_configs to file\n",
+        "best_configs.to_csv(os.path.join(exp_comparison_output, \"config.csv\"), index=True)"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Evaluate one model over iterations"
+      ]
+    },
     {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2024-03-02 18:30:06,444\tINFO experiment_analysis.py:972 -- No trial data passed in during `ExperimentAnalysis` initialization -- you are most likely loading the experiment after it has completed.\n",
-      "Loading trial data from the experiment checkpoint file. This may result in loading some stale information, since checkpointing is periodic.\n",
-      "2024-03-02 18:30:06,478\tINFO experiment_analysis.py:972 -- No trial data passed in during `ExperimentAnalysis` initialization -- you are most likely loading the experiment after it has completed.\n",
-      "Loading trial data from the experiment checkpoint file. This may result in loading some stale information, since checkpointing is periodic.\n",
-      "2024-03-02 18:30:06,579\tINFO experiment_analysis.py:972 -- No trial data passed in during `ExperimentAnalysis` initialization -- you are most likely loading the experiment after it has completed.\n",
-      "Loading trial data from the experiment checkpoint file. This may result in loading some stale information, since checkpointing is periodic.\n",
-      "2024-03-02 18:30:06,598\tINFO experiment_analysis.py:972 -- No trial data passed in during `ExperimentAnalysis` initialization -- you are most likely loading the experiment after it has completed.\n",
-      "Loading trial data from the experiment checkpoint file. This may result in loading some stale information, since checkpointing is periodic.\n"
-     ]
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "plot_model_training_over_iterations(\"xgb\", result_dic, labels=[\"data_transform\"])"
+      ]
     },
     {
-     "data": {
-      "text/plain": [
-       "<Figure size 2560x1920 with 0 Axes>"
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Postrun evaluation over all experiments performed\n",
+        "experiment > trial"
       ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
     },
     {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "overall_comparison_output = os.path.join(\"models\", \"compare_all\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# find best trial over all experiments for each model type\n",
+        "best_trials_overall = {}\n",
+        "for model in ls_model_types:\n",
+        "    # read all ExperimentAnalysis objects from this directory\n",
+        "    experiment_dir = f\"best_models/*/{model}\"\n",
+        "    analyses_ls = get_all_exp_analyses(experiment_dir)\n",
+        "\n",
+        "    # identify best trial from all analyses of this model type\n",
+        "    best_trials_overall[model] = best_trial_name(analyses_ls, \"rmse_val\", mode=\"min\")\n",
+        "\n",
+        "compare_trials(best_trials_overall, overall_comparison_output)"
       ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
     }
-   ],
-   "source": [
-    "# find best trial over all experiments for each model type\n",
-    "best_trials_overall = {}\n",
-    "for model in ls_model_types:\n",
-    "    # read all ExperimentAnalysis objects from this directory\n",
-    "    experiment_dir = f\"best_models/*/{model}\"\n",
-    "    analyses_ls = get_all_exp_analyses(experiment_dir)\n",
-    "\n",
-    "    # identify best trial from all analyses of this model type\n",
-    "    best_trials_overall[model] = best_trial_name(analyses_ls, \"rmse_val\", mode=\"min\")\n",
-    "\n",
-    "compare_trials(best_trials_overall, path_overall_comparison)"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "raytune",
-   "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.8.0"
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": "raytune",
+      "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.8.0"
+    },
+    "orig_nbformat": 4
   },
-  "orig_nbformat": 4
- },
- "nbformat": 4,
- "nbformat_minor": 2
+  "nbformat": 4,
+  "nbformat_minor": 2
 }
diff --git a/q2_ritme/config.py b/q2_ritme/config.py
deleted file mode 100644
index e98762a..0000000
--- a/q2_ritme/config.py
+++ /dev/null
@@ -1,9 +0,0 @@
-# todo: add this to a json file to be fed into functions
-TARGET = "age_days"
-HOST_ID = "host_id"
-SEED_DATA = 12
-SEED_MODEL = 12
-TRAIN_SIZE = 0.8
-# todo: change to "experiments/mlruns" once we launch python scripts instead of
-# notebooks
-MLFLOW_TRACKING_URI = "mlruns"
diff --git a/q2_ritme/eval_best_trial_overall.py b/q2_ritme/eval_best_trial_overall.py
new file mode 100644
index 0000000..a380c77
--- /dev/null
+++ b/q2_ritme/eval_best_trial_overall.py
@@ -0,0 +1,67 @@
+import argparse
+import os
+
+from q2_ritme.evaluate_all_experiments import (
+    best_trial_name,
+    compare_trials,
+    get_all_exp_analyses,
+)
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="Post-run evaluation over all experiments."
+    )
+    parser.add_argument(
+        "--model_path",
+        type=str,
+        default="experiments/models",
+        help="Path where the models are stored.",
+    )
+    parser.add_argument(
+        "--overall_comparison_output",
+        type=str,
+        default=None,
+        help="Output path for the overall comparison. If not provided, it defaults to "
+        "a 'compare_all' directory inside the base path.",
+    )
+    parser.add_argument(
+        "--ls_model_types",
+        type=str,
+        nargs="+",
+        default=["nn", "xgb", "linreg", "rf"],
+        help="List of model types to evaluate. Separate each model type with a space.",
+    )
+    return parser.parse_args()
+
+
+def main():
+    args = parse_args()
+
+    # Use the provided arguments
+    model_path = args.model_path
+    overall_comparison_output = args.overall_comparison_output or os.path.join(
+        model_path, "compare_all"
+    )
+    ls_model_types = args.ls_model_types
+
+    # Ensure the overall comparison output directory exists
+    os.makedirs(overall_comparison_output, exist_ok=True)
+
+    # Find best trial over all experiments for each model type
+    best_trials_overall = {}
+    for model in ls_model_types:
+        # read all ExperimentAnalysis objects from this directory
+        experiment_dir = f"{model_path}/*/{model}"
+        analyses_ls = get_all_exp_analyses(experiment_dir)
+
+        # identify best trial from all analyses of this model type
+        best_trials_overall[model] = best_trial_name(
+            analyses_ls, "rmse_val", mode="min"
+        )
+
+    compare_trials(best_trials_overall, model_path, overall_comparison_output)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/q2_ritme/evaluate_all_experiments.py b/q2_ritme/evaluate_all_experiments.py
index 394b2fb..99076c5 100644
--- a/q2_ritme/evaluate_all_experiments.py
+++ b/q2_ritme/evaluate_all_experiments.py
@@ -50,9 +50,9 @@ def get_all_exp_analyses(experiment_dir):
     return analyses_ls
 
 
-def read_predictions_for_trial(trial_tag):
+def read_predictions_for_trial(trial_tag, path_to_models):
     # read predictions for this trial
-    base_path = Path("best_models")
+    base_path = Path(path_to_models)
     target_path = [p for p in base_path.rglob(f"{trial_tag}*") if p.is_dir()]
 
     if len(target_path) > 1:
@@ -72,12 +72,12 @@ def verify_indices(models_dict, pred_value):
     return all(index.equals(indices[0]) for index in indices)
 
 
-def compare_trials(dic_trials_to_check, path_to_save):
+def compare_trials(dic_trials_to_check, path_to_models, path_to_save):
     # get predictions for each best trial
     pred_dic = {}
     config_dic = {}
     for v in dic_trials_to_check.values():
-        pred_dic[v] = read_predictions_for_trial(v)
+        pred_dic[v] = read_predictions_for_trial(v, path_to_models)
         config_dic[v] = v.config
 
     # Verify that IDs are identical for both splits
@@ -91,4 +91,4 @@ def compare_trials(dic_trials_to_check, path_to_save):
 
     # display config differences
     config_df = pd.DataFrame(config_dic)
-    config_df.to_csv(os.path.join(path_to_save, "config.csv"), index=True)
+    config_df.to_csv(os.path.join(path_to_save, "best_trial_config.csv"), index=True)
diff --git a/q2_ritme/evaluate_models.py b/q2_ritme/evaluate_models.py
index 1d213e4..d1cc4c1 100644
--- a/q2_ritme/evaluate_models.py
+++ b/q2_ritme/evaluate_models.py
@@ -13,6 +13,9 @@
 from q2_ritme.feature_space.transform_features import transform_features
 from q2_ritme.model_space._static_trainables import NeuralNet
 
+# 30.437 is avg. number of days per month
+DAYS_PER_MONTH = 30.437
+
 
 def _get_checkpoint_path(result: Result) -> str:
     """
@@ -161,37 +164,41 @@ def plot_rmse_over_experiments(preds_dic, save_loc, dpi=400):
     plt.show()
 
 
-def plot_rmse_over_time(preds_dic, ls_model_types, DAYS_PER_MONTH, save_loc, dpi=300):
+def plot_rmse_over_time(
+    preds_dic, ls_model_types, save_loc, days_per_month=DAYS_PER_MONTH, dpi=300
+):
     """
     Plot RMSE over true time bins for the first model type in ls_model_types.
 
     Parameters:
     preds_dic (dict): Dictionary containing predictions for each model type.
     ls_model_types (list): List of model types.
-    DAYS_PER_MONTH (float): Average number of days per month to use for binning.
+    days_per_month (float): Average number of days per month to use for binning.
     dpi (int): Resolution of the plot.
     """
-    model_type = ls_model_types[0]
-    pred_df = preds_dic[model_type]
-    split = None
-
-    # Bin true columns by months
-    pred_df["group"] = np.round(pred_df["true"] / DAYS_PER_MONTH, 0).astype(int)
-
-    # Calculate RMSE for each group
-    grouped_ser = pred_df.groupby(["group"]).apply(calculate_rmse)
-    grouped_df = grouped_ser.apply(pd.Series)
-    if split is not None:
-        grouped_df = grouped_df[[split]].copy()
-
-    # Plot
-    plt.figure(dpi=dpi)
-    grouped_df.plot(
-        kind="bar", title=f"Model: {model_type}", ylabel="RMSE", figsize=(10, 5)
-    )
-    path_to_save = os.path.join(save_loc, "rmse_over_time_train_test.png")
-    plt.savefig(path_to_save, dpi=dpi)
-    plt.show()
+    for model_type in ls_model_types:
+        pred_df = preds_dic[model_type]
+        split = None
+
+        # Bin true columns by months
+        pred_df["group"] = np.round(pred_df["true"] / days_per_month, 0).astype(int)
+
+        # Calculate RMSE for each group
+        grouped_ser = pred_df.groupby(["group"]).apply(calculate_rmse)
+        grouped_df = grouped_ser.apply(pd.Series)
+        if split is not None:
+            grouped_df = grouped_df[[split]].copy()
+
+        # Plot
+        plt.figure(dpi=dpi)
+        grouped_df.plot(
+            kind="bar", title=f"Model: {model_type}", ylabel="RMSE", figsize=(10, 5)
+        )
+        path_to_save = os.path.join(
+            save_loc, f"rmse_over_time_train_test_{model_type}.png"
+        )
+        plt.savefig(path_to_save, dpi=dpi)
+        plt.show()
 
 
 def get_best_model_metrics_and_config(
@@ -261,7 +268,7 @@ def plot_best_models_comparison(
     plt.show()
 
 
-def plot_model_training_over_iterations(model_type, result_dic, labels):
+def plot_model_training_over_iterations(model_type, result_dic, labels, save_loc):
     ax = None
     for result in result_dic[model_type]:
         label_str = ""
@@ -278,3 +285,8 @@ def plot_model_training_over_iterations(model_type, result_dic, labels):
     ax.legend(bbox_to_anchor=(1.1, 1.05))
     ax.set_title(f"RMSE_val vs. training iteration for all trials of {model_type}")
     ax.set_ylabel("RMSE_val")
+    plt.tight_layout()
+    path_to_save = os.path.join(
+        save_loc, f"rmse_best_{model_type}_over_training_iteration.png"
+    )
+    plt.savefig(path_to_save, dpi=400)
diff --git a/q2_ritme/run_config.json b/q2_ritme/run_config.json
new file mode 100644
index 0000000..2006132
--- /dev/null
+++ b/q2_ritme/run_config.json
@@ -0,0 +1,21 @@
+{
+  "experiment_tag": "test_synthetic",
+  "host_id": "host_id",
+  "ls_model_types": [
+    "nn",
+    "xgb",
+    "linreg",
+    "rf"
+  ],
+  "mlflow_tracking_uri": "mlruns",
+  "models_to_evaluate_separately": [
+    "xgb",
+    "nn"
+  ],
+  "path_to_ft": null,
+  "path_to_md": null,
+  "seed_data": 12,
+  "seed_model": 12,
+  "target": "age_days",
+  "train_size": 0.8
+}
diff --git a/q2_ritme/run_n_eval_tune.py b/q2_ritme/run_n_eval_tune.py
new file mode 100644
index 0000000..dfd35e5
--- /dev/null
+++ b/q2_ritme/run_n_eval_tune.py
@@ -0,0 +1,118 @@
+import argparse
+import json
+import os
+import shutil
+
+import pandas as pd
+
+from q2_ritme.evaluate_models import (
+    aggregate_best_models_metrics_and_configs,
+    get_predictions,
+    plot_best_models_comparison,
+    plot_model_training_over_iterations,
+    plot_rmse_over_experiments,
+    plot_rmse_over_time,
+    retrieve_best_models,
+)
+from q2_ritme.process_data import load_n_split_data
+from q2_ritme.tune_models import run_all_trials
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Run configuration.")
+    parser.add_argument(
+        "--config",
+        type=str,
+        required=True,
+        help="Path to the run configuration JSON file.",
+    )
+    return parser.parse_args()
+
+
+def main(config_path):
+    with open(config_path, "r") as f:
+        config = json.load(f)
+
+    # ! Define needed paths
+    base_path = os.path.join("experiments", "models")
+
+    exp_comparison_output = os.path.join(base_path, config["experiment_tag"])
+    if os.path.exists(exp_comparison_output):
+        raise ValueError(
+            f"This experiment tag already exists: {config['experiment_tag']}."
+            "Please use another one."
+        )
+
+    # todo: flag mlflow runs also with experiment tag somehow
+    path_mlflow = os.path.join("experiments", config["mlflow_tracking_uri"])
+    path_exp = os.path.join(base_path, config["experiment_tag"])
+
+    # ! Load and split data
+    train_val, test = load_n_split_data(
+        config["path_to_md"],
+        config["path_to_ft"],
+        config["host_id"],
+        config["target"],
+        config["train_size"],
+        config["seed_data"],
+    )
+
+    # ! Run all experiments
+    result_dic = run_all_trials(
+        train_val,
+        config["target"],
+        config["host_id"],
+        config["seed_data"],
+        config["seed_model"],
+        path_mlflow,
+        path_exp,
+        model_types=config["ls_model_types"],
+        fully_reproducible=False,
+    )
+
+    # ! Save run config
+    config_output_path = os.path.join(exp_comparison_output, "run_config.json")
+    shutil.copy(config_path, config_output_path)
+
+    # ! Evaluate best models of this experiment
+    # Eval1: train_val vs. test -> performance
+    best_model_dic = retrieve_best_models(result_dic)
+    non_features = [config["target"], config["host_id"]]
+    features = [x for x in train_val if x not in non_features]
+
+    preds_dic = {}
+    for model_type, tmodel in best_model_dic.items():
+        train_pred = get_predictions(
+            train_val, tmodel, config["target"], features, "train"
+        )
+        test_pred = get_predictions(test, tmodel, config["target"], features, "test")
+        all_pred = pd.concat([train_pred, test_pred])
+
+        # Save all predictions to model file
+        path2save = os.path.join(tmodel.path, "predictions.csv")
+        all_pred.to_csv(path2save, index=True)
+        preds_dic[model_type] = all_pred
+
+    plot_rmse_over_experiments(preds_dic, exp_comparison_output)
+
+    plot_rmse_over_time(preds_dic, config["ls_model_types"], exp_comparison_output)
+
+    # Eval2: train vs. val -> performance and config
+    metrics_all, best_configs = aggregate_best_models_metrics_and_configs(result_dic)
+
+    plot_best_models_comparison(metrics_all, exp_comparison_output)
+
+    best_configs.to_csv(
+        os.path.join(exp_comparison_output, "best_trial_config.csv"), index=True
+    )
+
+    # ! Evaluate one model over training iterations
+    for m in config["models_to_evaluate_separately"]:
+        plot_model_training_over_iterations(
+            m, result_dic, labels=["data_transform"], save_loc=exp_comparison_output
+        )
+
+
+if __name__ == "__main__":
+    args = parse_args()
+    main(args.config)
diff --git a/q2_ritme/tune_models.py b/q2_ritme/tune_models.py
index e2403f3..2f09e01 100644
--- a/q2_ritme/tune_models.py
+++ b/q2_ritme/tune_models.py
@@ -133,16 +133,15 @@ def run_all_trials(
     seed_data: int,
     seed_model: int,
     mlflow_uri: str,
-    experiment_tag: str,
+    path_exp: str,
     model_types: list = ["xgb", "nn", "linreg", "rf"],
     fully_reproducible: bool = False,
 ) -> dict:
     results_all = {}
     for model in model_types:
         # todo: parallelize this for loop
-        path2exp = os.path.join("best_models", experiment_tag)
-        if not os.path.exists(path2exp):
-            os.makedirs(path2exp)
+        if not os.path.exists(path_exp):
+            os.makedirs(path_exp)
         print(f"Ray tune training of: {model}...")
         result = run_trials(
             mlflow_uri,
@@ -154,7 +153,7 @@ def run_all_trials(
             host_id,
             seed_data,
             seed_model,
-            path2exp,
+            path_exp,
             fully_reproducible=fully_reproducible,
         )
         results_all[model] = result