Tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "da5f8d1c",
   "metadata": {},
   "source": [
    "# Go through all steps of building an AMN model"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "021d08de",
   "metadata": {},
   "source": [
    "With *in silico* datasets generated with the E. coli core model."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f46cc923",
   "metadata": {
    "id": "725c9c6d"
   },
   "source": [
    "# Install conda on your Colab environment"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4b87c7d",
   "metadata": {},
   "source": [
    "Ignore this first cell if you are running the notebook in a local environment.\n",
    "\n",
    "One can still run it locally but it will have no effect."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "bfa4a4ab",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 40951,
     "status": "ok",
     "timestamp": 1664526150927,
     "user": {
      "displayName": "Leon Faure",
      "userId": "06483081905364613855"
     },
     "user_tz": -120
    },
    "id": "c4f08880",
    "outputId": "eaae29a9-4739-4b0f-a2a7-56bfa89f0bf0",
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Run this cell first - it will install a conda distribution (mamba)\n",
    "# on your Drive then restart the kernel automatically \n",
    "# (don't worry about the crashing/restarting kernel messages)\n",
    "# It HAS to be runned FIRST everytime you use the notebook in colab\n",
    "\n",
    "import os\n",
    "import sys\n",
    "RunningInCOLAB  = 'google.colab' in str(get_ipython())\n",
    "\n",
    "if RunningInCOLAB:\n",
    "    !pip install -q condacolab\n",
    "    import condacolab\n",
    "    condacolab.install()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62d5de79",
   "metadata": {},
   "source": [
    "# Set up your Colab or local environment"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce2c6a47",
   "metadata": {},
   "source": [
    "Run this cell in both cases of use (local or Colab)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "e3746f76",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 117260,
     "status": "ok",
     "timestamp": 1664526767265,
     "user": {
      "displayName": "Leon Faure",
      "userId": "06483081905364613855"
     },
     "user_tz": -120
    },
    "id": "BYwheAEcr-ME",
    "outputId": "8ba41a54-6751-4c00-ed1a-938db78cafb6"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['.git', '.gitignore', '.ipynb_checkpoints', 'Build_Dataset.ipynb', 'Build_Experimental.ipynb', 'Build_Model_AMN.ipynb', 'Build_Model_ANN_Dense.ipynb', 'Build_Model_MM.ipynb', 'Build_Model_RC.ipynb', 'Dataset_experimental', 'Dataset_input', 'Dataset_model', 'Duplicate_Model.ipynb', 'environment_amn.yml', 'environment_amn_light.yml', 'Figures', 'Figures.ipynb', 'Library', 'LICENSE', 'README.md', 'Reservoir', 'Result', 'Tutorial.ipynb']\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import sys\n",
    "RunningInCOLAB  = 'google.colab' in str(get_ipython())\n",
    "\n",
    "if RunningInCOLAB:\n",
    "    \n",
    "    # Check everything is fine with conda in Colab\n",
    "    import condacolab\n",
    "    condacolab.check()\n",
    "    \n",
    "    # Mount your drive environment in the colab runtime\n",
    "    from google.colab import drive\n",
    "    drive.mount('/content/drive',force_remount=True)\n",
    "    \n",
    "    # Change this variable to your path on Google Drive to which the repo has been cloned\n",
    "    # If you followed the colab notebook 'repo_cloning.ipynb', nothing to change here\n",
    "    repo_path_in_drive = '/content/drive/My Drive/Github/amn_release/'\n",
    "    # Change directory to your repo cloned in your drive\n",
    "    DIRECTORY = repo_path_in_drive\n",
    "    os.chdir(repo_path_in_drive)\n",
    "    # Copy the environment given in the environment_amn_light.yml\n",
    "    !mamba env update -n base -f environment_amn_light.yml\n",
    "    \n",
    "    # This is one of the few Colab-compatible font\n",
    "    font = 'Liberation Sans'\n",
    "    \n",
    "else:\n",
    "    \n",
    "    # In this case the local root of the repo is our working directory\n",
    "    DIRECTORY = './'\n",
    "    font = 'arial'\n",
    "\n",
    "# printing the working directory files. One can check you see the same folders and files as in the git webpage.\n",
    "print(os.listdir(DIRECTORY))\n",
    "\n",
    "# We declare this function here and not in the\n",
    "# function-storing python file to modify it easily\n",
    "# as it can change the printouts of the methods\n",
    "def printout(V, Stats, model): \n",
    "    # printing Stats\n",
    "    print(\"R2 = %.2f (+/- %.2f) Constraint = %.2f (+/- %.2f)\" % \\\n",
    "          (Stats.train_objective[0], Stats.train_objective[1],\n",
    "           Stats.train_loss[0], Stats.train_loss[1]))\n",
    "    Vout = tf.convert_to_tensor(np.float32(model.Y))\n",
    "    Loss_norm, dLoss = Loss_Vout(V, model.Pout, Vout)\n",
    "    print('Loss Targets', np.mean(Loss_norm))\n",
    "    Loss_norm, dLoss = Loss_SV(V, model.S)\n",
    "    print('Loss SV', np.mean(Loss_norm))\n",
    "    Vin = tf.convert_to_tensor(np.float32(model.X))\n",
    "    Pin = tf.convert_to_tensor(np.float32(model.Pin))\n",
    "    if Vin.shape[1] == model.S.shape[1]: # special case\n",
    "        Vin  = tf.linalg.matmul(Vin, tf.transpose(Pin), b_is_sparse=True)\n",
    "    Loss_norm, dLoss = Loss_Vin(V, model.Pin, Vin, model.mediumbound)\n",
    "    print('Loss Vin bound', np.mean(Loss_norm))\n",
    "    Loss_norm, dLoss = Loss_Vpos(V, model)\n",
    "    print('Loss V positive', np.mean(Loss_norm))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8526745a",
   "metadata": {},
   "source": [
    "# 1° Duplicate reactions of the E. coli core model"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "404e1d70",
   "metadata": {},
   "source": [
    "The goal is to obtain a positive flux only model, to be then used for neural computations "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "569c4171",
   "metadata": {},
   "source": [
    "To perform this step, refer to the notebook `Duplicate_Model.ipynb`. In this tutorial we will use the output of this notebook, i.e. the duplicated-reactions model of E. coli core. It is already present in the git, no need to run the notebook again."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "647ca37b",
   "metadata": {},
   "source": [
    "# 2° Generate a training set by running cobrapy with different inputs"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b632cd84",
   "metadata": {},
   "source": [
    "Import required functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "8a0e7a70",
   "metadata": {},
   "outputs": [],
   "source": [
    "from Library.Build_Dataset import *\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "77d3927b",
   "metadata": {},
   "source": [
    "Set the parameters for your training set generation.\n",
    "\n",
    "We call a 'medium file', containing information on which exchange reaction to consider, in which range to draw random values for these, and at which ratio the exchange reactions are turned on. This file is in the folder `Dataset_model/`, one can access and modify it for generating other training sets. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "0c0a136f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generate training set with E coli core model with pFBA simulation\n",
    "\n",
    "# What you can change\n",
    "seed = 10\n",
    "np.random.seed(seed=seed)  # seed for random number generator\n",
    "cobraname =  'e_coli_core_duplicated'  # name of the model, stored in Dataset_model/ with .xml suffix\n",
    "mediumname = 'e_coli_core' # name of the medium file, stored in Dataset_model/ with .csv suffix\n",
    "mediumbound = 'UB' # Exact bound (EB) or upper bound (UB)\n",
    "method = 'pFBA' # FBA, pFBA or EXP\n",
    "size  = 50 # training set size\n",
    "reduce = False # Set at True if you want to reduce the model\n",
    "# End of What you can change"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b646bba4",
   "metadata": {},
   "source": [
    "Run cobra with specified parameters and 'medium file'.\n",
    "\n",
    "Then save the training set and test the loading to verify it is well built and accessible."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "63fa627d",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model file name: ./Dataset_model/e_coli_core_UB_50\n",
      "reduced model: False\n",
      "medium file name: ./Dataset_input/e_coli_core\n",
      "medium bound: UB\n",
      "list of reactions in objective: ['BIOMASS_Ecoli_core_w_GAM']\n",
      "method: pFBA\n",
      "trainingsize: 50\n",
      "list of medium reactions: 20\n",
      "list of medium levels: 20\n",
      "list of medium values: 20\n",
      "ratio of variable medium turned on: 0.5\n",
      "list of measured reactions: 154\n",
      "Stoichiometric matrix (72, 154)\n",
      "Boundary matrix from reactions to medium: (20, 154)\n",
      "Measurement matrix from reaction to measures: (154, 154)\n",
      "Reaction to metabolite matrix: (72, 154)\n",
      "Metabolite to reaction matrix: (154, 72)\n",
      "Training set X: (50, 20)\n",
      "Training set Y: (50, 154)\n",
      "S_int matrix (67, 154)\n",
      "S_ext matrix (154, 298)\n",
      "Q matrix (154, 67)\n",
      "P matrix (154, 154)\n",
      "b_int vector (67,)\n",
      "b_ext vector (50, 298)\n",
      "Sb matrix (154, 72)\n",
      "c vector (154,)\n"
     ]
    }
   ],
   "source": [
    "# Run cobra\n",
    "cobrafile  = DIRECTORY+'Dataset_input/'+cobraname\n",
    "mediumfile = DIRECTORY+'Dataset_input/'+mediumname\n",
    "parameter = TrainingSet(cobraname=cobrafile, \n",
    "                        mediumname=mediumfile, mediumbound=mediumbound, \n",
    "                        method=method,objective=[],\n",
    "                        measure=[])\n",
    "parameter.get(sample_size=size)\n",
    "\n",
    "# Saving file\n",
    "trainingfile  = DIRECTORY+'Dataset_model/'+mediumname+'_'+parameter.mediumbound+'_'+str(size)\n",
    "parameter.save(trainingfile, reduce=reduce)\n",
    "\n",
    "# Verifying\n",
    "parameter = TrainingSet()\n",
    "parameter.load(trainingfile)\n",
    "parameter.printout()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "079e4f40",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['M2V',\n",
       " 'P',\n",
       " 'Pin',\n",
       " 'Pout',\n",
       " 'Q',\n",
       " 'S',\n",
       " 'S_ext',\n",
       " 'S_int',\n",
       " 'Sb',\n",
       " 'V2M',\n",
       " 'X',\n",
       " 'Y',\n",
       " '__class__',\n",
       " '__delattr__',\n",
       " '__dict__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__le__',\n",
       " '__lt__',\n",
       " '__module__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " '__weakref__',\n",
       " 'allmatrices',\n",
       " 'b_ext',\n",
       " 'b_int',\n",
       " 'c',\n",
       " 'cobraname',\n",
       " 'filter_measure',\n",
       " 'get',\n",
       " 'levmed',\n",
       " 'load',\n",
       " 'measure',\n",
       " 'medium',\n",
       " 'mediumbound',\n",
       " 'mediumname',\n",
       " 'method',\n",
       " 'model',\n",
       " 'objective',\n",
       " 'printout',\n",
       " 'ratmed',\n",
       " 'reduce',\n",
       " 'reduce_and_run',\n",
       " 'save',\n",
       " 'size',\n",
       " 'valmed']"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The object 'parameter' has many attributes, listed here below\n",
    "dir(parameter)\n",
    "# This object is created when generating a training set and loaded when training a model on that training set."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0e595f7",
   "metadata": {},
   "source": [
    "We can plot a heatmap of the generated training set. First, the X values (i.e. the exchange reactions upper bounds) and then the Y values (i.e. the whole flux distribution solved by cobrapy with pFBA)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "d00d84e3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgIAAAGiCAYAAACVsa6/AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAABJBUlEQVR4nO3de1yUVf4H8M9wJwQUFIF1QRQT8QLeFcsroax5SUtrveClNAMV2DW1XcIy85IppYSXn9cts9LFyDaNVFA3UUFpdSs0c7UkJFcFUUFknt8fBuvoKMzMF+Zh5vPe1/N6rQ8z3+cMzMThnOecj0ZRFAVERERklWzM3QAiIiIyH3YEiIiIrBg7AkRERFaMHQEiIiIrxo4AERGRFWNHgIiIyIqxI0BERGTF2BEgIiKyYuwIEBERWTF2BIiIiKwYOwJEREQqtX//fgwZMgS+vr7QaDTYsWOHztcVRcGrr74KHx8fODs7Izw8HKdPnzboGuwIEBERqdT169cREhKC5ORkvV9fsmQJ3n33XaxatQqHDx+Gi4sLBg4ciNLS0hpfo9Y6AsnJyWjevDmcnJzQvXt3HDlypLYuRUREZJEiIyPxxhtv4Kmnnrrva4qiICkpCX/9618xbNgwdOjQAZs3b0Z+fv59IwcPUysdgY8++gjx8fFITEzEsWPHEBISgoEDB6KwsLA2LkdERFRvlJWVobi4WOcoKyszuM7Zs2dRUFCA8PDwqnPu7u7o3r07Dh06VOM6dgZfuQaWLVuGF154ARMnTgQArFq1Cp9//jnWr1+POXPmVPv88ks/1kazyAI5+z5u7iY81HjfnuZuwkNtzq/5fyxq4mb+AdF6ksrXzRetF5NyTbSe2n8Wkp816c/F+v9sE62nj+TvpYUrN+O1117TOZeYmIh58+YZVKegoAAA0LRpU53zTZs2rfpaTYh3BG7duoWcnBzMnTu36pyNjQ3Cw8MN6qEQERGphrZCrNTcuXMRHx+vc87R0VGsvqHEOwKXLl1CRUWF3h7K999/f9/jy8rK7hsSsSkrM+s3hYiIqLY4OjqK/I7z9vYGAFy8eBE+Pj5V5y9evIjQ0NAa1zH7qoGFCxfC3d1d51j8zipzN4uIiOh/FK3cISQgIADe3t7Ys2dP1bni4mIcPnwYPXvWfPpFfESgcePGsLW1xcWLF3XOX7x4sar3cjd9QyQ21y5IN4uIiMh4Wrlf4IYoKSnBDz/8UPXvs2fPIjc3Fx4eHvDz80NsbCzeeOMNtGrVCgEBAUhISICvry+GDx9e42uIdwQcHBzQuXNn7Nmzp6ohWq0We/bsQUxMzH2P1zdEUn7rknSziIiIjKYI/iVviOzsbPTr16/q35V/OEdFRWHjxo14+eWXcf36dUyZMgVXr17FY489hl27dsHJyanG16iVVQPx8fGIiopCly5d0K1bNyQlJeH69etVqwiIiIioen379oWiKA/8ukajweuvv47XX3/d6GvUSkdg9OjR+PXXX/Hqq6+ioKAAoaGh2LVr1303EBKZSnoZkvQSrpXTXEXrSS9Zk/ZNaHz1D6qhHoVHxWoBQPH8CNF60u8V6fapeWntS7dvm7sJhjPT1EBdqJWOAADExMTonQogIiKqd8w0NVAXzL5qgIiIiMyn1kYEiIiILIbghkJqw44AERFRdTg1QERERJZIvCOwcOFCdO3aFa6urvDy8sLw4cORl5cnfRkiIqK6o9XKHSqjUR62QNEIgwYNwrPPPouuXbvi9u3beOWVV3Dy5El8++23cHFxqVENpg+SuUgn1LklfClaT+3LJSUT79S8/A1Q/89Cejmi5HtZOhnRvnEL0Xr6lJ3JEqvl2LKHWC0J4vcI7Nq1S+ffGzduhJeXF3JyctC7d2/pyxEREZEJav1mwaKiIgCAh4dHbV+KiIiodqhwSF9KrXYEtFotYmNj0atXL7Rr107vYxhDTEREqsdVA8aJjo7GyZMnsXXr1gc+hjHERESketoKuUNlanWL4Z07d2L//v1o1qzZAx/HGGIiIiLzEe8IKIqC6dOnIzU1FRkZGQgICHjo4xlDTEREqmfBUwPiHYHo6Ghs2bIFn376KVxdXVFQUAAAcHd3h7Ozs/TliIiIah9vFqy5lJQUAHcylO+2YcMGTJgwQfpyZOWsba25dKzx5gTRcqLUvk5fWpZXV3M3oc5I79dhP3uDaD1rUytTA0RERBaFUwNERERWzIKnBhg6REREZMU4IkBERFQNRVHf+n8p7AgQERFVx4LvEaj1qYFFixZBo9EgNja2ti9FREREBqrVEYGjR49i9erV6NChQ21ehqyY6pdc3b5t7hY8lPQSPTUv55R+rwQLL+W0nyy7lvOb0PjqH2Qm0vHct2eLltOPNwsarqSkBGPGjMHatWvRqFGj2roMERFR7VO0cofK1FpHIDo6GoMHD0Z4eHhtXYKIiKhuMHTIMFu3bsWxY8dw9OjRah/LGGIiIiLzER8R+OmnnzBz5kx88MEHcHJyqvbxjCEmIiLVs+CpAfERgZycHBQWFqJTp05V5yoqKrB//36sXLkSZWVlsLW1rfoaY4iJiEj1LPhmQfGOwIABA3DixAmdcxMnTkRQUBBmz56t0wkAGENMRERkTuIdAVdXV7Rr107nnIuLCzw9Pe87T0REVC+ocEhfCncWpHqtR2H1N6RaFBXHBgPq3tdB/L0i/bMQXltPwjg1YJqMjIy6uAwREREZiCMCRERE1eGIABERkfWy5PTBWg8dIiIiIvXiiAAREVF1LHhqoFZGBC5cuICxY8fC09MTzs7OaN++PbKzs2vjUkRERLWPOwvW3JUrV9CrVy/069cPX3zxBZo0aYLTp08zgZCsknTMr7SXhGOSQ3KXidWSjtFV+89ic/4hczeBHsaCRwTEOwKLFy/G73//e2zYsKHqXEBAgPRliIiISID41EBaWhq6dOmCZ555Bl5eXujYsSPWrl0rfRkiIqK6Y8FTA+IdgR9//BEpKSlo1aoVdu/ejWnTpmHGjBnYtGmT3seXlZWhuLhY57g3lpiIiMistFq5Q2XEOwJarRadOnXCm2++iY4dO2LKlCl44YUXsGqV/mhhxhATERGZj/g9Aj4+PggODtY516ZNG2zfvl3v4xlDTEREqqfCIX0p4h2BXr16IS8vT+fcqVOn4O/vr/fxjCEmIiLVU+GQvhTxjkBcXBzCwsLw5ptvYtSoUThy5AjWrFmDNWvWSF+KSNzN/AOi9Zx9HxetJ+0l4bTAqV1eFqu1WTgtUDoZUTrNULp9wdNll2y7MR3RYol3BLp27YrU1FTMnTsXr7/+OgICApCUlIQxY8ZIX4qIiKhucETAME8++SSefPLJ2ihNRERU9yz4HgGGDhEREVkxhg4RERFVh1MDREREVoxTAzVXUVGBhIQEBAQEwNnZGS1btsT8+fOhKIr0pYiIiOqGBe8sWCuhQykpKdi0aRPatm2L7OxsTJw4Ee7u7pgxY4b05YiIiMgE4h2Br7/+GsOGDcPgwYMBAM2bN8eHH36II0eOSF+KSDxaVnrdv9rXrkvGBgPAZhXvmyD9vSueHyFaz35ygmg96fey5B4bat9fQy9ODdRcWFgY9uzZg1OnTgEAvvnmGxw8eBCRkZHSlyIiIqobnBqouTlz5qC4uBhBQUGwtbVFRUUFFixYwA2FiIiIVEi8I/Dxxx/jgw8+wJYtW9C2bVvk5uYiNjYWvr6+iIqKuu/xZWVl98UO25SV3Zc/QEREZDYq/EteivjUwKxZszBnzhw8++yzaN++PcaNG4e4uDgsXLhQ7+MZQ0xERKqnKHKHyoiPCNy4cQM2Nrr9C1tbW2gf0JtiDDEREZH5iHcEhgwZggULFsDPzw9t27bF8ePHsWzZMkyaNEnv4xlDTEREqmfBUwPiHYEVK1YgISEBL730EgoLC+Hr64upU6fi1Vdflb4UEVZnLxGtJ738TToKdnyK7HJJNZOOhP4mNL76BxlA7cv9pKm9fbWOHYGac3V1RVJSEpKSkqRLExERkTBmDRAREVXHgjcUYkeAiIioOhY8NSC+fJCIiMjimGH5YF2F+HFEgIiISIXqKsTP4BGB/fv3Y8iQIfD19YVGo8GOHTt0vq4oCl599VX4+PjA2dkZ4eHhOH36tFR7iYiI6p4ZsgbuDvFr3rw5nn76aURERIiH+BncEbh+/TpCQkKQnJys9+tLlizBu+++i1WrVuHw4cNwcXHBwIEDUVpaanJjiYiIzEKwI1BWVobi4mKd496t9oG6C/HTKCZMNmg0GqSmpmL48OEA7owG+Pr64k9/+hP+/Oc/AwCKiorQtGlTbNy4Ec8++2yN6pZf+tHYJpGVkV4bLk065lfta7klo3ljUq6J1QKAldNcRetZ2z4Ckj/bb1dcEasFAF1+3iFaT5+b6/4sVmvxTw3w2muv6ZxLTEzEvHnzdM5ptVq88sorWLJkiU6I39y5c8XaAgjfI3D27FkUFBQgPDy86py7uzu6d++OQ4cO1bgjQEREpCqCywf1ba2vL2jP0BA/Y4l2BAoKCgAATZs21TnftGnTqq/di+mDRESkdopW7k59fVvr63N3iB8AtG/fHufOncPChQtFOwJmXz7I9EEiIqL7GRriZyzREQFvb28AwMWLF+Hj41N1/uLFiwgNDdX7HKYPEhGR6plhQyFDQ/yMJdoRCAgIgLe3N/bs2VP1i7+4uBiHDx/GtGnT9D6H6YNERKR6ZthiuK5C/AzuCJSUlOCHH36o+vfZs2eRm5sLDw8P+Pn5ITY2Fm+88QZatWqFgIAAJCQkwNfXt2plAREREVWvrkL8DO4IZGdno1+/flX/rhzWj4qKwsaNG/Hyyy/j+vXrmDJlCq5evYrHHnsMu3btgpOTk1yriX7To/CoaD3p6FvpJWHjfWVjiDfnHxKtJ7ksbLXw0ku1y/LqKlpP+rMh6T072U1t14tWewDBmwXVxuCfRt++fR+6z7FGo8Hrr7+O119/3aSGERERqYYFhw4xa4CIiKg6FtwRMPvyQSIiIjIfjggQERFVRzj6V03YESAiIqoOpwb+52ExxOXl5Zg9ezbat28PFxcX+Pr6Yvz48cjPz5dsMxEREQkxeESgMoZ40qRJGDFihM7Xbty4gWPHjiEhIQEhISG4cuUKZs6ciaFDhyI7O1us0US1ZWqXl83dhIdanb1EtqDw6w0WTPhTexqfNMl0PwAYnyK71NQt4UuxWtLLYOsElw/+T2Rk5AOzkN3d3ZGenq5zbuXKlejWrRvOnz8PPz8/41pJRERkTmbYWbCu1PqqgaKiImg0GjRs2LC2L0VEREQGqtWbBUtLSzF79mw899xzcHNz0/sYxhATEZHqWfDUQK2NCJSXl2PUqFFQFAUpKSkPfBxjiImISO0UrVbsUJtaGRGo7AScO3cOe/fufeBoAMAYYiIiInMS7whUdgJOnz6Nffv2wdPT86GPZwwxERGpngVPDYjGEPv4+ODpp5/GsWPHsHPnTlRUVKCgoAAA4OHhAQcHB7mWExER1RULXjWgUR4WJahHRkaGTgxxpaioKMybNw8BAQF6n7dv3z707du3Rtcov/SjIU0iK2Zta82lSa/nfun2bbFawdMbidUCZNfBk2mk33fr/7NNtJ4+118fI1bL5dUPxGpJEI8hNrBfQURERGbErAEiIqLqqPBufynsCBAREVXHgm8WrPWdBYmIiEi9OCJARERUHQteNSAaQ3yvF198ERqNBklJSSY0kYiIyMy0ityhMqIxxHdLTU1FVlYWfH19TWog0cNIR7da2xIzyeV+ANCj8KhYrWLI/mylSS+Bk46YLl83X7ReTMo1sVqb8w+J1QKA9aLVrI9oDHGlCxcuYPr06di9ezcGDx5sdOOIiIjUQI0ZAVLE7xHQarUYN24cZs2ahbZt20qXJyIiqnsqHNKXIt4RWLx4Mezs7DBjxowaPZ4xxEREROYjunwwJycH77zzDjZu3AiNRlOj5zCGmIiIVM+CbxYU7QgcOHAAhYWF8PPzg52dHezs7HDu3Dn86U9/QvPmzfU+Z+7cuSgqKtI5Zs98UbJZREREplG0cofKiE4NjBs3DuHh4TrnBg4ciHHjxmHixIl6n8MYYiIiUj0V/iUvRTSG2M/PD56enjqPt7e3h7e3N1q3bm16a4mIiEiUwR2B7OxsnRji+Ph4AHdiiDdu3CjWMKKakF73L702XJr0+mvpqN+sFV3Fakn/bNW+58Rm4Ujtm/kHROuthOC+BCnq/pzpo3BE4H+qiyG+13/+8x9DL0FERKQuFtwRYOgQERGRFWPoEBERUXW4syAREZEV49TA/9QkffC7777D0KFD4e7uDhcXF3Tt2hXnz5+XaC8REREJMrgjUJk+mJycrPfrZ86cwWOPPYagoCBkZGTgX//6FxISEuDk5GRyY4mIiMzCgncWFE8f/Mtf/oI//OEPWLLkf5GaLVu2NK51RHVs5TRX0Xr2kxNE60kvMZMWkrtMrpjwa/12xRXRetLLEaXfK84qfq9kecktM60rhqyWq29EVw1otVp8/vnnePTRRzFw4EB4eXmhe/fueqcPiIiIyPxEOwKFhYUoKSnBokWLMGjQIHz55Zd46qmnMGLECGRmZkpeioiIqO5waqBmtL8trxg2bBji4uIAAKGhofj666+xatUq9OnT577nMIaYiIhUT4W/wKWIjgg0btwYdnZ2CA4O1jnfpk2bB64aYAwxERGpnaJVxA61ER0RcHBwQNeuXZGXl6dz/tSpU/D399f7nLlz51blFVSyuXZBsllERET0AOLpg7NmzcLo0aPRu3dv9OvXD7t27cJnn32GjIwMvfUYQ0xERKqnwr/kpYinDz711FNYtWoVFi5ciBkzZqB169bYvn07HnvsMblWE9UTU7u8bO4mPFRMyjXRepsT1LtkrUfhUdF6xZBdPqjm5X7SpFMv64Tl7jBcO+mDkyZNwqRJk4xuFBEREdUNZg0QERFVQ403+UlhR4CIiKg6FtwREF0+SERERPULRwSIiIiqY8E3C4rHEJeUlCAmJgbNmjWDs7MzgoODsWoVNwgiIqL6y5I3FBKPIY6Pj8euXbvw/vvv47vvvkNsbCxiYmKQlpZmcmOJiIhIlngM8ddff42oqCj07dsXADBlyhSsXr0aR44cwdChQ41uKFFdcEv4UrSedFTtZtmkWlWT/t5JxxBLv1du5h8QrSe9h8Xm/ENitaS/d7dni5bTj1MDNRcWFoa0tDRcuHABiqJg3759OHXqFCIiZD/UREREdcWSpwbEbxZcsWIFpkyZgmbNmsHOzg42NjZYu3YtevfurffxTB8kIiLV44hAza1YsQJZWVlIS0tDTk4O3n77bURHR+Orr77S+3imDxIREZmP6IjAzZs38corryA1NRWDBw8GAHTo0AG5ublYunQpwsPD73sO0weJiEjtFAseERDtCJSXl6O8vBw2NroDDba2ttBq9X8XmT5IRESqx47A/1QXQ9ynTx/MmjULzs7O8Pf3R2ZmJjZv3oxly5aJNpyIiIhMp1GqixK8R0ZGhk4McaXKGOKCggLMnTsXX375JS5fvgx/f39MmTIFcXFx0Gg0NbpG+aUfDWkSWTFrim4FgPG+PUXrSS4JA2Tbtzp7iVgtQH453Uu3b4vWk45JVrMsr66i9br8vEO0nj6XIvuI1Wr8RaZYLQniMcTe3t7YsGGDSY0iIiJSFQueGmDoEBERkRVj6BAREVE1LHnVAEcEiIiIqqFo5Q5DXLhwAWPHjoWnpyecnZ3Rvn17ZGdni742jggQERFVwxwjAleuXEGvXr3Qr18/fPHFF2jSpAlOnz6NRo0aiV7HoBGBhQsXomvXrnB1dYWXlxeGDx+OvLw8nceUlpYiOjoanp6eaNCgAUaOHImLFy+KNpqIiMjSLV68GL///e+xYcMGdOvWDQEBAYiIiEDLli1Fr2NQRyAzMxPR0dHIyspCeno6ysvLERERgevXr1c9Ji4uDp999hk++eQTZGZmIj8/HyNGjBBtNBERUZ1SNGJHWVkZiouLdY57M3cAIC0tDV26dMEzzzwDLy8vdOzYEWvXrhV/aQbvI3C3X3/9FV5eXsjMzETv3r1RVFSEJk2aYMuWLXj66acBAN9//z3atGmDQ4cOoUePHjWqy30EqKbK180XrScdVSvNmtaaS5OONY5JuSZaT3pPB2ty+1btb0tf0LuvWK1V/fvitdde0zmXmJiIefPm6ZxzcnICAMTHx+OZZ57B0aNHMXPmTKxatQpRUVFi7THpHoGioiIAgIeHBwAgJycH5eXlOpkCQUFB8PPzM6gjQEREZKn0ZezoS9zVarXo0qUL3nzzTQBAx44dcfLkSfV0BLRaLWJjY9GrVy+0a9cOAFBQUAAHBwc0bNhQ57FNmzZFQUGB3jqMISYiIrVTtDXbGbcm9GXs6OPj44Pg4GCdc23atMH27dvF2gKYsHwwOjoaJ0+exNatW01qAGOIiYhI7cyxfLBXr1733ZB/6tQp+Pv7i742o0YEYmJisHPnTuzfvx/NmjWrOu/t7Y1bt27h6tWrOqMCFy9ehLe3t95ajCEmIiK6X1xcHMLCwvDmm29i1KhROHLkCNasWYM1a9aIXsegEQFFURATE4PU1FTs3bsXAQEBOl/v3Lkz7O3tsWfPnqpzeXl5OH/+PHr21B9G4ujoCDc3N52D0wJERKQmiqIRO2qqa9euSE1NxYcffoh27dph/vz5SEpKwpgxY0Rfm0EjAtHR0diyZQs+/fRTuLq6Vs37u7u7w9nZGe7u7pg8eTLi4+Ph4eEBNzc3TJ8+HT179uSNgkREVG+Za4vhJ598Ek8++WStXsOgjkBKSgqAOwmEd9uwYQMmTJgAAFi+fDlsbGwwcuRIlJWVYeDAgXjvvfdEGktU29S+PE86vlWa5PdP+rWqfbmf9OsNni67+5z95ASxWtLLfsk0BnUEarLlgJOTE5KTk5GcnGx0o4iIiNREctWA2jBrgIiIqBrGb72nfuwIEBERVcOSRwQYQ0xERGTFOCJARERUDY4I/Ka6GOLLly9j+vTpaN26NZydneHn54cZM2ZUZRIQERHVR4oid6iNQSMClTHEXbt2xe3bt/HKK68gIiIC3377LVxcXJCfn4/8/HwsXboUwcHBOHfuHF588UXk5+dj27ZttfUayIq5JXxp7ibUKenljTfzD4jWG9/lZbFaPawsjU/6Zzs+Rf8mbsZaPVmulvTn9vZs0XJWx6COwK5du3T+vXHjRnh5eSEnJwe9e/dGu3btdMIQWrZsiQULFmDs2LG4ffs27Ow4E0FERPWPJU8NiMYQP+gxbm5u7AQQEVG9ZcjWwPWNaAzxvS5duoT58+djypQpD6zDGGIiIiLzqbUY4uLiYgwePBjBwcGYN2/eA+swhpiIiNTOHDHEdUU0hrjStWvXMGjQILi6uiI1NRX29vYPrMUYYiIiUjstpwbuUBQF06dPR2pqKjIyMu6LIQbujAQMHDgQjo6OSEtLg5OT00NrOjo63jcNUH7rkiHNIiIiIiOJxhAXFxcjIiICN27cwPvvv4/i4mIUFxcDAJo0aQJbW1v5V0BERFTLLPlmQY1Sk0jBygdr9H8jKmOIMzIy0K9fP72POXv2LJo3b16j65Rf+rGmTSIr5+z7uLmbQPWEdMyv2iOrrcntW7U/nfz9o38QqxV06h9itSSIxhD37du3RlHFRERE9Ykl/2pj6BAREZEV4y4/RERE1eDOgkRERFbMkpcPcmqAiIjIionGEN9NURRERkZCo9Fgx44dEm0lIiIyC0XRiB1qIxpDfLekpKQHLjckklI8P0K0nrXFGkuTXKInvTxP7RHO0ri0VpYlrxoQjSGulJubi7fffhvZ2dnw8fGRaSkRERGJE48hvnHjBv74xz8iOTkZ3t7eprWOiIhIBSz5ZkHxGOK4uDiEhYVh2LBhNarDGGIiIlI7Nc7tSxGNIU5LS8PevXuRlJRU4zqMISYiIjIf0RjivXv34syZM2jYsKHO40eOHInHH38cGRkZ99ViDDEREakdbxb8TXUxxHPmzMHzzz+vc659+/ZYvnw5hgwZorcmY4iJiEjteI/Ab6qLIfb29tZ7g6Cfn999nQYiNWJCnWmCpzeSK5YgV6o2TO3ysmi9zfmHROtJk/xsiL5P6gjvEfhNSkoKioqK0LdvX/j4+FQdH330UW21j4iIiGqRaAyx1HOIiIjUhFMDREREVsyS/6Rl6BAREZEV44gAERFRNSx5aqBW0gcPHTqE/v37w8XFBW5ubujduzdu3rwp1mgiIqK6ZMnpgwZ1BCrTB7OyspCeno7y8nJERETg+vXrVY85dOgQBg0ahIiICBw5cgRHjx5FTEwMbGw4C0FERKQ2GsWE2/p//fVXeHl5ITMzsyp9sEePHnjiiScwf/58oxtVfulHo59L1kU6alU61jgm5ZpoPem15uN9e4rWWznNVayW2iOhpWOI1f5e/nbFFbFa0vtr3L5V+7vRHvB+WqzW4wXbxGpJMOnP9HvTBwsLC3H48GF4eXkhLCwMTZs2RZ8+fXDw4EHTW0pERGQmCjRih9oY3RHQlz744493/pKfN28eXnjhBezatQudOnXCgAEDcPr0aZkWExERkRijVw1Upg/e/de+VqsFAEydOhUTJ04EAHTs2BF79uzB+vXrsXDhwvvqMIaYiIjUTmvBGwkYNSJQmT64b98+nfRBHx8fAEBwcLDO49u0aYPz58/rrcUYYiIiUjstNGKH2oimDzZv3hy+vr73LSk8deoUIiMj9dZkDDEREamdGuf2pYimD2o0GsyaNQuJiYkICQlBaGgoNm3ahO+//x7btum/S5IxxEREROZjUEcgJSUFANC3b1+d8xs2bMCECRMAALGxsSgtLUVcXBwuX76MkJAQpKeno2XLliINJqpPXrp9W7ag8HK/1dlLROtJL4GTJB0xrebXCgD2k2VznN9LkY1drm+05m5ALaqV9ME5c+Zgzpw5RjWIiIhIbSx5aoDb/REREVkxhg4RERFVg1MDREREVsySOwKcGiAiIrJi4jHEBQUFGDduHLy9veHi4oJOnTph+/btoo0mIiKqS8wa+E1NYojHjx+PvLw8pKWl4cSJExgxYgRGjRqF48ePizeeiIioLmg1cofaiMcQN2jQACkpKRg3blzV4zw9PbF48WI8//zzNarLGGKqqW9C46t/kAGk41Glo2ClqT0m2ZqoORIakI2Flt7TocvPO0Tr6fOZ93NitYYUfChWS4JoDDEAhIWF4aOPPsLly5eh1WqxdetWlJaW3rcJERERUX3BrAE99MUQA8DHH3+M0aNHw9PTE3Z2dnjkkUeQmpqKwMBAvXWYPkhERGpnweGDxo8IVMYQb926Ved8QkICrl69iq+++grZ2dmIj4/HqFGjcOLECb11mD5IRERqpxU81MaoEYHKGOL9+/frxBCfOXMGK1euxMmTJ9G2bVsAQEhICA4cOIDk5GSsWnX/L3imDxIREZmPaAzxjRs3AAA2NroDDba2ttBq9feDmD5IRERqp9Wob25fimgMcVBQEAIDAzF16lQsXboUnp6e2LFjB9LT07Fz585aeQFERES1zZLvETBo+aDmAT2iu2OIT58+jTlz5uDgwYMoKSlBYGAg/vznP+ssJ6wOlw9STUlHwUov95Nenqf22GDJJXDSSxGll6xJLzW1pvZJt+32rdqfTv7EZ4xYrWd++UCslgTxGOJWrVpxJ0EiIrIoarzJTwpDh4iIiKqhxh0BpTB0iIiIyIqxI0BERFQNNewsuGjRImg0GsTGxsq9MHBqgIiIqFrmXjVw9OhRrF69Gh06dBCvbdCIQEpKCjp06AA3Nze4ubmhZ8+e+OKLL6q+XlpaiujoaHh6eqJBgwYYOXIkLl68KN5oIiKi+qqsrAzFxcU6x71b7d+tpKQEY8aMwdq1a9GoUSPx9hi0fPCzzz6Dra0tWrVqBUVRsGnTJrz11ls4fvw42rZti2nTpuHzzz/Hxo0b4e7ujpiYGNjY2OCf//ynQY3i8kGqKenlb9ZGesla8HS5/0h9u+KKWC1A3cvpAPn2SVPz0tC6WD64+XdjxWr9+EIgXnvtNZ1ziYmJmDdvnt7HR0VFwcPDA8uXL0ffvn0RGhqKpKQksfYYNDUwZMgQnX8vWLAAKSkpyMrKQrNmzbBu3Tps2bIF/fv3B3Bnf4E2bdogKysLPXr0EGs0ERFRXZJcPqhva/0HBe1t3boVx44dw9GjtddRNPoegYqKCnzyySe4fv06evbsiZycHJSXlyM8PLzqMUFBQfDz88OhQ4fYESAionpL8h4BfVvr6/PTTz9h5syZSE9Ph5OTk2ALdBncEThx4gR69uyJ0tJSNGjQAKmpqQgODkZubi4cHBzQsGFDncc3bdq0aitifRhDTEREdL+cnBwUFhaiU6dOVecqKiqwf/9+rFy5EmVlZbC1tTX5OgYvH2zdujVyc3Nx+PBhTJs2DVFRUfj222+NbgBjiImISO20GrmjpgYMGIATJ04gNze36ujSpQvGjBmD3NxckU4AYMSIgIODAwIDAwEAnTt3xtGjR/HOO+9g9OjRuHXrFq5evaozKnDx4kV4e3s/sB5jiImISO3MscWwq6sr2rVrp3POxcUFnp6e9503hckbCmm1WpSVlaFz586wt7fHnj17qr6Wl5eH8+fPo2fPB99t6ujoWLUcsfLgtAAREVHdMGhEYO7cuYiMjISfnx+uXbuGLVu2ICMjA7t374a7uzsmT56M+Ph4eHh4wM3NDdOnT0fPnj15oyAREdVragkdysjIEK9pUEegsLAQ48ePxy+//AJ3d3d06NABu3fvxhNPPAEAWL58OWxsbDBy5EiUlZVh4MCBeO+998QbTVRbJNdKA/LrpaWJr61fod6oWumfrbX9l03t7+Xaplhw6JBBHYF169Y99OtOTk5ITk5GcnKySY0iIiKiusGsASIiomqoZWqgNrAjQEREVA1L7ggwhpiIiMiKcUSAiIioGuaOIa5NYjHEly9fxvTp09G6dWs4OzvDz88PM2bMQFFRUa00nIiIqK6YY2fBumLQiECzZs2waNEinRjiYcOG4fjx41AUBfn5+Vi6dCmCg4Nx7tw5vPjii8jPz8e2bdtqq/1EolZnL5GtJ1oNmNrlZdF60q9XzbHQal/+djP/gGg96feK2r9/tc2S7xEQiyGePHkytm/fXvW1li1bYsGCBRg7dixu374NOzvOQhAREamNWAyxPkVFRXBzc2MngIiI6jWOCNzlQTHE97p06RLmz5+PKVOmPLQeY4iJiEjteLPgXWoSQ1xcXIzBgwcjODgY8+bNe2g9xhATERGZj1gM8erVd26LunbtGgYNGgRXV1ekpqbC3t7+ofUYQ0xERGqnxrv9pZg8eV8ZQwzcGQkYOHAgHB0dkZaWBicnp2qf7+joeN80QPmtS6Y2i4iISAzvEfjNw2KIi4uLERERgRs3buD9999HcXExiouLAQBNmjSBra1trbwAIiIiMp5YDHFGRgYOHz4MAFVTB5XOnj2L5s2bizWaqLaoeR18bdis4tcrva5e+mer9vZJK54fIVbr2xVXxGrVFUu+WVAshrhv375QFEv+VhERkbXSWnBXgKFDREREVow7/RAREVWDNwsSERFZMcudGGBHgIiIqFqWPCIgFkN8N0VREBkZCY1Ggx07dki1lYiIiISJxRC3bdu26nFJSUnQaCx4GyaiGsry6ipa7z3hAC/paFnJJWZqX07H5YjGk34frxetph93FvzNw2KIKzsCubm5ePvtt5GdnQ0fHx+5lhIREZmJJS8fFI0hvnHjBv74xz8iOTkZ3t7eYo0kIiKi2iEaQxwXF4ewsDAMGzasxvUYQ0xERGpnueMBgjHEaWlp2Lt3L5KSkgyqxxhiIiJSO63goTZiMcTOzs44c+YMGjZsqPP4kSNH4vHHH0dGRobeeowhJiIiMh+xGOLXXnsNzz//vM7X2rdvj+XLl993k+HdGENMRERqx5sFf/OwGGJvb2+9Nwj6+fkhICBArMFEd5NcrgYA9pMTROtJk04LlP7+uSV8KVpPktqXcqp5uR8gmxi4ufCoWC2gbpYPWm43QDCGmIiIiOofsRhifRhLTERElkCNN/lJYdYAERFRNXiPABERkRWz3G6AEfsIEBERkeUQTx88dOgQ+vfvDxcXF7i5uaF37964efOmaKOJiIjqEjcU+k116YOHDh3CoEGDMHfuXKxYsQJ2dnb45ptvYGPDgQciIqq/FAueHNAoJt7a7+HhgbfeeguTJ09Gjx498MQTT2D+/PkmNar80o8mPZ+sh/Taa7Wvqx/v21O0nnQMsSTpdf8huctE66l93b/0ezkm5ZpYLen33e1btb8b7Yzmo8Vqvfufj8RqSTD6T/WKigps3bq1Kn2wsLAQhw8fhpeXF8LCwtC0aVP06dMHBw8elGwvERFRnePUwF0elD6YlZUFAJg3bx6WLl2K0NBQbN68GQMGDMDJkyfRqlUrvfWYPkhERGpnycsHxdIHtdo7/ZypU6di4sSJ6NixI5YvX47WrVtj/foHbwDJ9EEiIiLzEUsfnDNnDgAgODhY5/Ft2rTB+fPnH1iP6YNERKR2ljseIJg+2Lx5c/j6+iIvL0/n66dOnUJkZOQDn8/0QSIiUjtLnhoQSx/UaDSYNWsWEhMTERISgtDQUGzatAnff/89tm3bVlvtJyIiIhOIpg/GxsaitLQUcXFxuHz5MkJCQpCeno6WLVvWSuOJpJeYqTlGFwBWTnMVrbdZxanLPYSjaiG83E/tSzmlI7VXwrRl4Xd7aYXs57YuqPFufyni6YNz5sypul+AiIjIEljyhkIMHSIiIqqGJY8IcO9fIiIiK8YRASIiompwaoCIiMiKcWrgN9XFEBcUFGDcuHHw9vaGi4sLOnXqhO3bt4s3moiIiGQY1BGojCHOyclBdnY2+vfvj2HDhuHf//43AGD8+PHIy8tDWloaTpw4gREjRmDUqFE4fvx4rTSeiIioLmgVRexQG9EY4gYNGiAlJQXjxo2r+rqnpycWL16M559/vsY1GUNM5qL2aFnptevSJPc5UPueDqQedRFDPNZ/hFit98/9XayWBLEYYgAICwvDRx99hMuXL0Or1WLr1q0oLS1F3759pdpLREREgsRiiAHg448/xujRo+Hp6Qk7Ozs88sgjSE1NrQop0ocxxEREpHaWnDUgFkMMAAkJCbh69Sq++uorZGdnIz4+HqNGjcKJEyceWI8xxEREpHaK4P/UxuR7BMLDw9GyZUu8/PLLCAwMxMmTJ9G2bVudrwcGBmLVKv2/3PWOCFy7wBEBMgveI2Aa3iNA5lAX9wg85z9crNaH53aI1ZIgFkN848YNAICNje4gg62tLbTaB6/AZAwxERGpnSXvIyAWQxwUFITAwEBMnToVS5cuhaenJ3bs2IH09HTs3LmzttpPRERU6yz5HgHRGOJ//OMfmDNnDoYMGYKSkhIEBgZi06ZN+MMf/lArjSea2uVlczehTq3OXiJaT3oqZCUixGrdzD8gVgtQ/7RP8Xy57x0gH0Ms+f2Tjg+vC2qc25ciGkPcqlUr7iRIRERUjzBrgIiIqBq8R4CIiMiKmbjATtWM3lmQiIiIas/ChQvRtWtXuLq6wsvLC8OHD0deXp74ddgRICIiqoYWithRU5mZmYiOjkZWVhbS09NRXl6OiIgIXL9+XfS1mdQRWLRoETQaDWJjY6vOlZaWIjo6Gp6enmjQoAFGjhyJixcvmtpOIiIis9EKHmVlZSguLtY57t1YDwB27dqFCRMmoG3btggJCcHGjRtx/vx55OTkiL42o+8ROHr0KFavXo0OHTronI+Li8Pnn3+OTz75BO7u7oiJicGIESPwz3/+0+TGEt1LejndynXzRetJ744nvQROeslaTMo1sVqrJ4uVAiC/ZO09O9lbrKTfK+MFfxaA7K6WIcKf2/pm4cKFeO2113TOJSYmYt68eQ99XlFREYA7qb+SjHonl5SUYMyYMVi7di3eeOONqvNFRUVYt24dtmzZgv79+wMANmzYgDZt2iArKws9evSQaTUREVEdktxHYO7cuYiPj9c5V922+lqtFrGxsejVqxfatWsn1hbAyKmB6OhoDB48GOHh4Trnc3JyUF5ernM+KCgIfn5+OHTokGktJSIiMhPJewQcHR3h5uamc1TXEYiOjsbJkyexdetW8ddm8IjA1q1bcezYMRw9evS+rxUUFMDBwQENGzbUOd+0aVMUFBTorccYYiIiogeLiYnBzp07sX//fjRr1ky8vkEjAj/99BNmzpyJDz74AE5OTiINYAwxERGpnaIoYoch14yJiUFqair27t2LgICAWnltBo0I5OTkoLCwEJ06dao6V1FRgf3792PlypXYvXs3bt26hatXr+qMCly8eBHe3t56a+qbK7G5VvuRkkRERDVljp0Fo6OjsWXLFnz66adwdXWtGll3d3eHs7Oz2HUM6ggMGDAAJ06c0Dk3ceJEBAUFYfbs2fj9738Pe3t77NmzByNHjgQA5OXl4fz58+jZU/8dp4whJiIitTNH6FBKSgoAoG/fvjrnN2zYgAkTJohdx6COgKur6313K7q4uMDT07Pq/OTJkxEfHw8PDw+4ublh+vTp6NmzJ1cMEBERGaCutjUWzxpYvnw5bGxsMHLkSJSVlWHgwIF47733pC9DVCuk13JLk47mlbY5QW6fg80qjw1Wu835siu1JPdh+CY0vvoHGaDLzztE6+ljyI6A9Y3JHYGMjAydfzs5OSE5ORnJycmmliYiIlIFhg4RERGRRWIMMRERUTU4NUBERGTFzLFqoK5waoCIiMiKicYQX758GdOnT0fr1q3h7OwMPz8/zJgxoyoxiYiIqD7SKorYoTaiMcT5+fnIz8/H0qVLERwcjHPnzuHFF19Efn4+tm3bJtJgortJx/KqnfSyqx6F92eGWCrppZfS7z21ty8kd5lYLem23Ratpp/6fn3LEY0hbteuHbZv317175YtW2LBggUYO3Ysbt++DTvh/G4iIiIyjWgMsT5FRUVwc3NjJ4CIiOotyRhitRGNIb7XpUuXMH/+fEyZMuWBj2EMMRERqZ0af4FLqbUY4uLiYgwePBjBwcGYN2/eAx/HGGIiIlI7c8QQ1xXRGOKysjLY2tri2rVrGDRoEFxdXZGamgp7e/sH1mQMMRERkfmIxhDb2tqiuLgYAwcOhKOjI9LS0qodOWAMMRERqZ0lTw2IxhAXFxcjIiICN27cwPvvv4/i4mIUFxcDAJo0aQJbW1u5lhMREdURS95ZUPRW/mPHjuHw4cMAgMDAQJ2vnT17Fs2bN5e8HJH42uupXV4WrScdBSu97l/ta9clqbltANtH5iMaQ9y3b19V3ghBRERkCkv+3cbF/URERNWw5HsEGDpERERkxTgiQEREVA1LnhoQTR+8m6IoiIyMhEajwY4dO0y5DBERkVlZ8hbDRncE9KUP3i0pKQkajcbohhEREVHtE00frJSbm4u3334b2dnZ8PHxMbmRRHVldfYS0XqbhZdcjfftKVpPOtZYsn3SSy+lv3fSpN97XO4ny5L3ERBPH7xx4wb++Mc/Ijk5Gd7e3iY3kIiIyNy0iiJ2qI14+mBcXBzCwsIwbNgwkxtHRESkBpY8ImBQR6AyfTA9PV1vhkBaWhr27t2L48eP17gmY4iJiIjMx6CpgbvTB+3s7GBnZ4fMzEy8++67sLOzQ3p6Os6cOYOGDRtWfR0ARo4cib59++qtyRhiIiJSO04N/Ka69MHGjRtj6tSpOl9v3749li9fjiFDhuityRhiIiJSO04N/Ka69EEAem8Q9PPzQ0BAgN6ajCEmIiIyH+4sSPWa9BIptS8xk15St1m0mrpJf++K50eI1pN+L2d5dRWtJ5l8qfbPmT5qHNKXIpo+qI8lb8tIRETWwZKnBhg6REREZMU4NUBERFQNTg0QERFZMU4NEBERkUWqlRjiQ4cOoX///nBxcYGbmxt69+6NmzdvmnIpIiIis1EUrdihNkZPDTwohvjQoUMYNGgQ5s6dixUrVsDOzg7ffPMNbGw4+EBERPWT1oKnBjSKEev7SkpK0KlTJ7z33nt44403EBoaiqSkJABAjx498MQTT2D+/PlGN6r80o9GP5esC6NWyVzUvhZ+5TRX0XpuCV+K1bqZf0CsFgDYN24hWk8fP4/2YrXOXz5R/YPqkGgMcWFhIQ4fPgwvLy+EhYWhadOm6NOnDw4ePCjSWCIiIpIlGkP84493/pKfN28eli5ditDQUGzevBkDBgzAyZMn0apVq/uew/RBIiJSO0ueGjBoRKAyhviDDz7QG0Os1d65CWLq1KmYOHEiOnbsiOXLl6N169ZYv3693ppMHyQiIrVTFEXsUBuDRgTujiGuVFFRgf3792PlypXIy8sDAAQHB+s8r02bNjh//rzemkwfJCIiMh/RGOIWLVrA19e3qkNQ6dSpU4iMjNRbk+mDRESkdtxZ8Dc1iSGeNWsWEhMTERISgtDQUGzatAnff/89tm3bJtdqIiKiOmTJOwuKbzEcGxuL0tJSxMXF4fLlywgJCUF6ejpatmwpfSkicdJLwqSjb6WpOapWum3B0xuJ1pMmuTwPAF5aIfv9k/RNaHz1DzJAl593iNazNrUSQzxnzhzMmTPH1NJERESqoMab/KQwdIiIiKgaXD5IREREFokjAkRERNXg1AAREZEVs+Tlg+IxxAUFBRg3bhy8vb3h4uKCTp06Yfv27aa2k4iIyGy4s6AeD4ohHj9+PK5evYq0tDQ0btwYW7ZswahRo5CdnY2OHTua3GCiu4kvf1P5cj/p5Y0h2UtE60EwDVJyKSIAFCNCtJ795ATResWi1eSXI0qS/tneFq1mfYwaESgpKcGYMWOwdu1aNGqkuzb366+/xvTp09GtWze0aNECf/3rX9GwYUPk5OSINJiIiKiuaaGIHWojGkMMAGFhYfjoo49w+fJlaLVabN26FaWlpejbt6+pbSUiIjILTg3c5WExxADw8ccfY/To0fD09ISdnR0eeeQRpKamIjAwUO/jGUNMRERkPqIxxACQkJCAq1ev4quvvkJ2djbi4+MxatSo+8KKKjGGmIiI1E6rKGKH2ojHEK9cuRInT55E27ZtAQAhISE4cOAAkpOTsWrV/b/gGUNMRERqx9Ch31QXQ3zjxg0AgI2N7kCDra0ttFqt3pqMISYiIjIf0Rji8vJyBAYGYurUqVi6dCk8PT2xY8cOpKenY+fOnaINJyIiqitqHNKXIrqzoL29Pf7xj39gzpw5GDJkCEpKShAYGIhNmzbhD3/4g+SliADIr0e+mX9AtJ6z4Lp6QD7WeLNw+yT3OXjptuzqcOl19VkrrojWk34vqzlSu3i+7J4OdUGNd/tLEY8hbtWqFXcSJCIiqieYNUBERFQN3ixIRERkxSx5asCk0CEiIiJrYM6dBZOTk9G8eXM4OTmhe/fuOHLkiOhrY0eAiIhIpT766CPEx8cjMTERx44dQ0hICAYOHIjCwkKxa7AjQEREVA1F8CgrK0NxcbHOce9W+5WWLVuGF154ARMnTkRwcDBWrVqFRx55BOvXrxd8cfVUaWmpkpiYqJSWlrKehdVTc9tYTz21WM+y60m3TU0SExPv6x8kJibe97iysjLF1tZWSU1N1Tk/fvx4ZejQoWLtqbcdgaKiIgWAUlRUxHoWVk/NbWM99dRiPcuuJ902NSktLVWKiop0Dn0dngsXLigAlK+//lrn/KxZs5Ru3bqJtYerBoiIiOqQvq31zYn3CBAREalQ48aNYWtri4sXL+qcv3jxIry9vcWuw44AERGRCjk4OKBz587Ys2dP1TmtVos9e/agZ0+5LaTr7dSAo6MjEhMTxYZXWE899dTcNtZTTy3Ws+x60m2rr+Lj4xEVFYUuXbqgW7duSEpKwvXr1zFx4kSxa2gUxYK3SyIiIqrnVq5cibfeegsFBQUIDQ3Fu+++i+7du4vVZ0eAiIjIivEeASIiIivGjgAREZEVY0eAiIjIirEjQEREZMXqbUdAKpZx//79GDJkCHx9faHRaLBjxw6T2rVw4UJ07doVrq6u8PLywvDhw5GXl2d0vZSUFHTo0AFubm5wc3NDz5498cUXX5jUxkqLFi2CRqNBbGysUc+fN28eNBqNzhEUFGRSmy5cuICxY8fC09MTzs7OaN++PbKzs42q1bx58/vap9FoEB0dbVS9iooKJCQkICAgAM7OzmjZsiXmz59vdE75tWvXEBsbC39/fzg7OyMsLAxHjx6t8fOre+8qioJXX30VPj4+cHZ2Rnh4OE6fPm1Urb///e+IiIiAp6cnNBoNcnNzjW5beXk5Zs+ejfbt28PFxQW+vr4YP3488vPzjX6t8+bNQ1BQEFxcXNCoUSOEh4fj8OHDRte724svvgiNRoOkpCSj602YMOG+9+GgQYNMat93332HoUOHwt3dHS4uLujatSvOnz9vcC19nxGNRoO33nrLqLaVlJQgJiYGzZo1g7Ozc1VQjrGv9eLFi5gwYQJ8fX3xyCOPYNCgQQ98H5Nx6mVHQDKW8fr16wgJCUFycrJI2zIzMxEdHY2srCykp6ejvLwcERERuH79ulH1mjVrhkWLFiEnJwfZ2dno378/hg0bhn//+98mtfPo0aNYvXo1OnToYFKdtm3b4pdffqk6Dh48aHStK1euoFevXrC3t8cXX3yBb7/9Fm+//TYaNWpkVL2jR4/qtC09PR0A8MwzzxhVb/HixUhJScHKlSvx3XffYfHixViyZAlWrFhhVL3nn38e6enp+Nvf/oYTJ04gIiIC4eHhuHDhQo2eX917d8mSJXj33XexatUqHD58GC4uLhg4cCBKS0sNrnX9+nU89thjWLx4scltu3HjBo4dO4aEhAQcO3YMf//735GXl4ehQ4ca/VofffRRrFy5EidOnMDBgwfRvHlzRERE4NdffzWqXqXU1FRkZWXB19f3oY+rSb1BgwbpvB8//PBDo+udOXMGjz32GIKCgpCRkYF//etfSEhIgJOTk8G17m7TL7/8gvXr10Oj0WDkyJFGtS0+Ph67du3C+++/j++++w6xsbGIiYlBWlqawfUURcHw4cPx448/4tNPP8Xx48fh7++P8PBwo/+bSnqIpRbUoW7duinR0dFV/66oqFB8fX2VhQsXmlQXwH0pT6YqLCxUACiZmZliNRs1aqT83//9n9HPv3btmtKqVSslPT1d6dOnjzJz5kyj6iQmJiohISFGt+Nes2fPVh577DGxeveaOXOm0rJlS0Wr1Rr1/MGDByuTJk3SOTdixAhlzJgxBte6ceOGYmtrq+zcuVPnfKdOnZS//OUvBte7972r1WoVb29v5a233qo6d/XqVcXR0VH58MMPDap1t7NnzyoAlOPHjxvdNn2OHDmiAFDOnTsnUq8ysOarr74yut7PP/+s/O53v1NOnjyp+Pv7K8uXL6+21oPqRUVFKcOGDavR82tSb/To0crYsWNFat1r2LBhSv/+/Y2u17ZtW+X111/XOVfT9/W99fLy8hQAysmTJ6vOVVRUKE2aNFHWrl1bozZS9erdiMCtW7eQk5OD8PDwqnM2NjYIDw/HoUOHzNgy/YqKigAAHh4eJteqqKjA1q1bcf36dZO2l4yOjsbgwYN1vofGOn36NHx9fdGiRQuMGTNG79BkTaWlpaFLly545pln4OXlhY4dO2Lt2rUmtxG48755//33MWnSJGg0GqNqhIWFYc+ePTh16hQA4JtvvsHBgwcRGRlpcK3bt2+joqLivr/gnJ2dTRpVqXT27FkUFBTo/Izd3d3RvXt31X5ONBoNGjZsaHKtW7duYc2aNXB3d0dISIhRNbRaLcaNG4dZs2ahbdu2JrcJADIyMuDl5YXWrVtj2rRp+O9//2t02z7//HM8+uijGDhwILy8vNC9e3eTpzWBO8Pwn3/+OSZPnmx0jbCwMKSlpeHChQtQFAX79u3DqVOnEBERYXCtsrIyAND5nNjY2MDR0VHkc0J31LuOwKVLl1BRUYGmTZvqnG/atCkKCgrM1Cr9tFotYmNj0atXL7Rr187oOidOnECDBg3g6OiIF198EampqQgODjaq1tatW3Hs2DEsXLjQ6PZU6t69OzZu3Ihdu3YhJSUFZ8+exeOPP45r164ZVe/HH39ESkoKWrVqhd27d2PatGmYMWMGNm3aZHJbd+zYgatXr2LChAlG15gzZw6effZZBAUFwd7eHh07dkRsbCzGjBljcC1XV1f07NkT8+fPR35+PioqKvD+++/j0KFD+OWXX4xuY6XKz0J9+JyUlpZi9uzZeO655+Dm5mZ0nZ07d6JBgwZwcnLC8uXLkZ6ejsaNGxtVa/HixbCzs8OMGTOMbs/dBg0ahM2bN2PPnj1YvHgxMjMzERkZiYqKCoNrFRYWoqSkBIsWLcKgQYPw5Zdf4qmnnsKIESOQmZlpUjs3bdoEV1dXjBgxwugaK1asQHBwMJo1awYHBwcMGjQIycnJ6N27t8G1goKC4Ofnh7lz5+LKlSu4desWFi9ejJ9//lnkc0J31NusgfogOjoaJ0+eNLnn2rp1a+Tm5qKoqAjbtm1DVFQUMjMzDe4M/PTTT5g5cybS09P1ziUa6u6/hDt06IDu3bvD398fH3/8sVF/UWi1WnTp0gVvvvkmAKBjx444efIkVq1ahaioKJPaum7dOkRGRlY71/swH3/8MT744ANs2bIFbdu2RW5uLmJjY+Hr62tU+/72t79h0qRJ+N3vfgdbW1t06tQJzz33HHJycoxuY31TXl6OUaNGQVEUpKSkmFSrX79+yM3NxaVLl7B27VqMGjUKhw8fhpeXl0F1cnJy8M477+DYsWNGjx7d69lnn636/+3bt0eHDh3QsmVLZGRkYMCAAQbV0mq1AIBhw4YhLi4OABAaGoqvv/4aq1atQp8+fYxu5/r16zFmzBiT/vuwYsUKZGVlIS0tDf7+/ti/fz+io6Ph6+tr8Cikvb09/v73v2Py5Mnw8PCAra0twsPDERkZafRNunS/ejciUFexjKaKiYnBzp07sW/fPjRr1sykWg4ODggMDETnzp2xcOFChISE4J133jG4Tk5ODgoLC9GpUyfY2dnBzs4OmZmZePfdd2FnZ2fUXyd3a9iwIR599FH88MMPRj3fx8fnvs5NmzZtTJpuAIBz587hq6++wvPPP29SnVmzZlWNCrRv3x7jxo1DXFyc0aMrLVu2RGZmJkpKSvDTTz/hyJEjKC8vR4sWLUxqJ4Cqz4KaPyeVnYBz584hPT3dpNEAAHBxcUFgYCB69OiBdevWwc7ODuvWrTO4zoEDB1BYWAg/P7+qz8m5c+fwpz/9Cc2bNzepjZVatGiBxo0bG/VZady4Mezs7MQ/KwcOHEBeXp5Jn5ObN2/ilVdewbJlyzBkyBB06NABMTExGD16NJYuXWpUzc6dOyM3NxdXr17FL7/8gl27duG///2vyOeE7qh3HYG6imU0lqIoiImJQWpqKvbu3YuAgADxa2i12qq5M0MMGDAAJ06cQG5ubtXRpUsXjBkzBrm5ubC1tTWpXSUlJThz5gx8fHyMen6vXr3uW2p56tQp+Pv7m9SuDRs2wMvLC4MHDzapzo0bN2Bjo/uRsbW1rfoLzVguLi7w8fHBlStXsHv3bgwbNsykegAQEBAAb29vnc9JcXExDh8+rIrPSWUn4PTp0/jqq6/g6ekpfg1jPyfjxo3Dv/71L53Pia+vL2bNmoXdu3eLtO3nn3/Gf//7X6M+Kw4ODujatav4Z2XdunXo3Lmz0fdVAHd+ruXl5bXyOXF3d0eTJk1w+vRpZGdni3xO6I56OTUgGctYUlKi0ys/e/YscnNz4eHhAT8/P4PrRUdHY8uWLfj000/h6upaNR/r7u4OZ2dng+vNnTsXkZGR8PPzw7Vr17BlyxZkZGQY9R8kV1fX++5VcHFxgaenp1H3MPz5z3/GkCFD4O/vj/z8fCQmJsLW1hbPPfecwbUAIC4uDmFhYXjzzTcxatQoHDlyBGvWrMGaNWuMqgfc+WWwYcMGREVFwc7OtLf7kCFDsGDBAvj5+aFt27Y4fvw4li1bhkmTJhlVb/fu3VAUBa1bt8YPP/yAWbNmISgoqMbv4+reu7GxsXjjjTfQqlUrBAQEICEhAb6+vhg+fLjBtS5fvozz589XrfWv/CXk7e2td4ThYfV8fHzw9NNP49ixY9i5cycqKiqqPiceHh5wcHAwqJ6npycWLFiAoUOHwsfHB5cuXUJycjIuXLjwwKWi1b3eezsm9vb28Pb2RuvWrQ2u5+Hhgddeew0jR46Et7c3zpw5g5dffhmBgYEYOHCgUe2bNWsWRo8ejd69e6Nfv37YtWsXPvvsM2RkZBhcC7jTSfzkk0/w9ttv622PIfX69OmDWbNmwdnZGf7+/sjMzMTmzZuxbNkyo+p98sknaNKkCfz8/HDixAnMnDkTw4cPN+rmQ3oAs65ZMMGKFSsUPz8/xcHBQenWrZuSlZVlVJ19+/YpAO47oqKijKqnrxYAZcOGDUbVmzRpkuLv7684ODgoTZo0UQYMGKB8+eWXRtXSx5Tlg6NHj1Z8fHwUBwcH5Xe/+50yevRo5YcffjCpPZ999pnSrl07xdHRUQkKClLWrFljUr3du3crAJS8vDyT6iiKohQXFyszZ85U/Pz8FCcnJ6VFixbKX/7yF6WsrMyoeh999JHSokULxcHBQfH29laio6OVq1ev1vj51b13tVqtkpCQoDRt2lRxdHRUBgwY8MDvQ3W1NmzYoPfriYmJBterXIKo79i3b5/B9W7evKk89dRTiq+vr+Lg4KD4+PgoQ4cOVY4cOWL09+5e1S0ffFi9GzduKBEREUqTJk0Ue3t7xd/fX3nhhReUgoICk9q3bt06JTAwUHFyclJCQkKUHTt2GF1r9erVirOzc43ef9XV++WXX5QJEyYovr6+ipOTk9K6dWvl7bfffuCy3erqvfPOO0qzZs0Ue3t7xc/PT/nrX/9q9GeO9GMMMRERkRWrd/cIEBERkRx2BIiIiKwYOwJERERWjB0BIiIiK8aOABERkRVjR4CIiMiKsSNARERkxdgRICIismLsCBAREVkxdgSIiIisGDsCREREVuz/AcVdF2OhIjfHAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.heatmap(pd.DataFrame(parameter.X))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "6252d40c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.heatmap(pd.DataFrame(parameter.Y))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2bb48273",
   "metadata": {},
   "source": [
    "# 3° Build different kind of models: mechanistic, neural or hybrid"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c751b323",
   "metadata": {},
   "source": [
    "## 3.1° Mechanistic model: AMN-suitable mechanistic methods alone"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4a4c737",
   "metadata": {},
   "source": [
    "This step aims to check if in-house AMN-suitable mechanistic methods reach satisfactory solutions, i.e. solutions that have the same value for the objective reaction set for generating the training set (here, the default objective `BIOMASS_Ecoli_core_w_GAM`), and if the constraints of the metabolic network are well respected: SV=0, V>0, exchange reactions bounds (Vin) respected.\n",
    "\n",
    "NB: no learning is performed here. We solve each element of the training set independently from each other, with the in-house solvers QP or LP."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65f6aea2",
   "metadata": {},
   "source": [
    "Import required functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4e7e6b6e-9baa-45e4-9310-58bef0e886f7",
   "metadata": {},
   "outputs": [],
   "source": [
    "from Library.Build_Model import *"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bdfc963b",
   "metadata": {},
   "source": [
    "Set the parameters for your mechanistic methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "3a9a06f0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "training file: ./Dataset_model/e_coli_core_UB_50\n",
      "model type: MM_LP\n",
      "model scaler: 0.0\n",
      "model input dim: 20\n",
      "model output dim: 1\n",
      "model medium bound: UB\n",
      "timestep: 10000\n",
      "training set size (50, 20) (50, 1)\n"
     ]
    }
   ],
   "source": [
    "# Run Mechanistic model (no training) QP (quadratic program) or LP (linear program)\n",
    "# using E. coli core simulation training sets and EB (or UB) bounds\n",
    "\n",
    "# What you can change\n",
    "seed = 10\n",
    "np.random.seed(seed=seed)  \n",
    "trainname = 'e_coli_core_UB_50' # the training set file name (generated at previous step)\n",
    "size = 5 # number of runs must be lower than the number of element in trainname\n",
    "timestep = int(1.0e4) # LP 1.0e4 QP 1.0e5\n",
    "learn_rate = 0.3 # for LP: 0.3; for QP: 1.0\n",
    "decay_rate = 0.9 # only in QP, 0.9\n",
    "solver = 'MM_LP' # choose between MM_LP or MM_QP\n",
    "# End of What you can change\n",
    "\n",
    "# Create model and run GD for X and Y randomly drawn from trainingfile\n",
    "trainingfile = DIRECTORY+'Dataset_model/'+trainname\n",
    "model = Neural_Model(trainingfile = trainingfile, \n",
    "              objective=['BIOMASS_Ecoli_core_w_GAM'], \n",
    "              model_type = solver, \n",
    "              timestep = timestep, \n",
    "              learn_rate = learn_rate, \n",
    "              decay_rate = decay_rate)\n",
    "# Prints a summary of the model before running\n",
    "\n",
    "model.printout()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "25e343cf",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LP-Loss 1 0.22319156 0.056573782\n",
      "LP-Loss 10 0.20051904 0.056685936\n",
      "LP-Loss 100 0.06593693 0.03126802\n",
      "LP-Loss 1000 0.00020193856 0.00027553688\n",
      "LP-Loss 2000 2.8318558e-05 3.9392e-05\n",
      "LP-Loss 3000 1.0665081e-05 1.9738318e-05\n",
      "LP-Loss 4000 4.465483e-06 1.235451e-05\n",
      "LP-Loss 5000 2.8441675e-06 1.0824294e-05\n",
      "LP-Loss 6000 2.258871e-06 9.068624e-06\n",
      "LP-Loss 7000 1.8383274e-06 7.662022e-06\n",
      "LP-Loss 8000 1.4816699e-06 6.3611906e-06\n",
      "LP-Loss 9000 1.1949011e-06 5.2127994e-06\n",
      "LP-Loss 10000 9.49317e-07 4.226952e-06\n",
      "AMN output shapes for PoutV, SV, PinV, Vpos, V, outputs (50, 1) (50, 1) (50, 1) (50, 1) (50, 154) (50, 312)\n",
      "R2 = 1.00 (+/- 0.00) Constraint = 0.00 (+/- 0.00)\n",
      "Loss Targets 0.0005201458\n",
      "Loss SV 7.477279e-07\n",
      "Loss Vin bound 5.2814652e-05\n",
      "Loss V positive 1.1901792e-05\n"
     ]
    }
   ],
   "source": [
    "# Runs the appropriate method\n",
    "\n",
    "if model.model_type is 'MM_QP':\n",
    "    Ypred, Stats = MM_QP(model, verbose=True)\n",
    "if model.model_type is 'MM_LP':\n",
    "    Ypred, Stats = MM_LP(model, verbose=True)\n",
    "\n",
    "# Printing results\n",
    "printout(Ypred, Stats, model)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3cdeb12f",
   "metadata": {
    "id": "AZh8eS0TS9Xh",
    "tags": []
   },
   "source": [
    "## 3.2° Neural: classical Artificial Neural Networks (ANN)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bcaaebbc",
   "metadata": {},
   "source": [
    "This step aims to use classical neural networks for learning on the cobrapy-generated dataset, looking at the performance of a pure black-box without any computation using the stoichiometric matrix of the network or other 'knowledge'.\n",
    "\n",
    "We use a 5-fold cross-validation scheme on 90% of the data and an independent test-set of 10% of the data."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49a78389",
   "metadata": {},
   "source": [
    "Import required functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "9972b961",
   "metadata": {},
   "outputs": [],
   "source": [
    "from Library.Build_Model import *\n",
    "# We declare this function here and not in the\n",
    "# function-storing python file to modify it easily\n",
    "# as it can change the printouts of the methods\n",
    "def printout(filename, Stats, model, time): \n",
    "    # printing Stats\n",
    "    print('Stats for %s CPU-time %.4f' % (filename, time))\n",
    "    print('R2 = %.4f (+/- %.4f) Constraint = %.4f (+/- %.4f)' % \\\n",
    "          (Stats.train_objective[0], Stats.train_objective[1],\n",
    "           Stats.train_loss[0], Stats.train_loss[1]))\n",
    "    print('Q2 = %.4f (+/- %.4f) Constraint = %.4f (+/- %.4f)' % \\\n",
    "          (Stats.test_objective[0], Stats.test_objective[1],\n",
    "           Stats.test_loss[0], Stats.test_loss[1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "329bd0fa",
   "metadata": {
    "id": "rLJUJ4kCxjf8",
    "outputId": "aeca8606-f76b-4a28-9efb-bc0297ccbde9",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "training file: ./Dataset_model/e_coli_core_UB_50\n",
      "model type: ANN_Dense\n",
      "model scaler: 0.0\n",
      "model input dim: 20\n",
      "model output dim: 1\n",
      "model medium bound: UB\n",
      "timestep: 0\n",
      "training set size (50, 20) (50, 1)\n",
      "nbr hidden layer: 1\n",
      "hidden layer size: 50\n",
      "activation function: relu\n",
      "training epochs: 500\n",
      "training regression: True\n",
      "training learn rate: 0.001\n",
      "training dropout: 0.25\n",
      "training batch size: 5\n",
      "training validation iter: 0\n",
      "training xfold: 5\n",
      "training early stopping: False\n",
      "nbr parameters: 1101\n",
      "train = 0.99 test = 0.97 loss-train = -1.000000 loss-test = -1.000000 iter=0\n",
      "nbr parameters: 1101\n",
      "train = 0.95 test = 0.89 loss-train = -1.000000 loss-test = -1.000000 iter=0\n",
      "nbr parameters: 1101\n",
      "train = 0.94 test = 0.93 loss-train = -1.000000 loss-test = -1.000000 iter=0\n",
      "nbr parameters: 1101\n",
      "train = 0.97 test = 0.92 loss-train = -1.000000 loss-test = -1.000000 iter=0\n",
      "nbr parameters: 1101\n",
      "train = 0.97 test = 0.96 loss-train = -1.000000 loss-test = -1.000000 iter=0\n",
      "Stats for e_coli_core_UB_50_ANN_Dense CPU-time 275.3546\n",
      "R2 = 0.9625 (+/- 0.0163) Constraint = -1.0000 (+/- 0.0000)\n",
      "Q2 = 0.9367 (+/- 0.0267) Constraint = -1.0000 (+/- 0.0000)\n",
      "./Reservoir/e_coli_core_UB_50_ANN_Dense_param.csv\n",
      "training file: ./Dataset_model/e_coli_core_UB_50\n",
      "model type: ANN_Dense\n",
      "model scaler: 0.0\n",
      "model input dim: 20\n",
      "model output dim: 1\n",
      "model medium bound: UB\n",
      "timestep: 0\n",
      "training set size (50, 20) (50, 1)\n",
      "nbr hidden layer: 1\n",
      "hidden layer size: 50\n",
      "activation function: relu\n",
      "training epochs: 500\n",
      "training regression: True\n",
      "training learn rate: 0.001\n",
      "training dropout: 0.25\n",
      "training batch size: 5\n",
      "training validation iter: 0\n",
      "training xfold: 5\n",
      "training early stopping: False\n",
      "Stats for Test set CPU-time 0.0707\n",
      "R2 = 0.6795 (+/- 0.0000) Constraint = -1.0000 (+/- 0.0000)\n",
      "Q2 = 0.6795 (+/- 0.0000) Constraint = -1.0000 (+/- 0.0000)\n"
     ]
    }
   ],
   "source": [
    "# Create, train and evaluate ANN model with FBA simulated training set for E. coli core\n",
    "\n",
    "# What you can change \n",
    "seed = 10\n",
    "ratio_test = 0.1 # part of the training set removed for test\n",
    "np.random.seed(seed=seed)  \n",
    "trainname = 'e_coli_core_UB_50'\n",
    "# End of What you can change\n",
    "\n",
    "# Create model\n",
    "trainingfile = DIRECTORY+'Dataset_model/'+trainname\n",
    "model = Neural_Model(trainingfile = trainingfile, \n",
    "              objective=['BIOMASS_Ecoli_core_w_GAM'], \n",
    "              model_type = 'ANN_Dense',\n",
    "              n_hidden = 1, hidden_dim = 50, \n",
    "              epochs = 500, xfold = 5)\n",
    "ID = np.random.choice(model.X.shape[0], \n",
    "                      size=int(model.X.shape[0]*ratio_test), replace=False)\n",
    "Xtest,  Ytest  = model.X[ID,:], model.Y[ID,:]\n",
    "Xtrain, Ytrain = np.delete(model.X, ID, axis=0), np.delete(model.Y, ID, axis=0) \n",
    "model.printout()\n",
    "\n",
    "# Train and evaluate\n",
    "reservoirname = trainname +'_'+model.model_type\n",
    "reservoirfile = DIRECTORY+'Reservoir/'+reservoirname\n",
    "start_time = time.time()\n",
    "model.X, model.Y = Xtrain, Ytrain\n",
    "reservoir, pred, stats, _ = train_evaluate_model(model, verbose=False)\n",
    "delta_time = time.time() - start_time\n",
    "\n",
    "# Printing cross-validation results\n",
    "printout(reservoirname, stats, model, delta_time)\n",
    "\n",
    "# Save, reload and run idependent test set\n",
    "reservoir.save(reservoirfile)\n",
    "reservoir.load(reservoirfile)\n",
    "reservoir.printout()\n",
    "if len(Xtest) > 0:\n",
    "    start_time = time.time()\n",
    "    reservoir.X, reservoir.Y = Xtest, Ytest\n",
    "    X, Y = model_input(reservoir,verbose=False)\n",
    "    pred, stats = evaluate_model(reservoir.model, X, Y, reservoir, verbose=False)\n",
    "    delta_time = time.time() - start_time\n",
    "    printout('Test set', stats, model, delta_time)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e753651e",
   "metadata": {},
   "source": [
    "NB: a Constraint=-1.00 is expected with such black box architecture, it is the default value when no constraint is computed. \n",
    "\n",
    "With the given parameters we should obtain Q2=0.68 on the test set."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "466463f8",
   "metadata": {},
   "source": [
    "## 3.3° Hybrid: Artificial Metabolic Network (AMN) architecture"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30927732",
   "metadata": {},
   "source": [
    "This step aims to use an AMN architecture for learning on the cobrapy-generated dataset, looking at the performance of a hybrid model with computations using the stoichiometric matrix of the network and other 'knowledge'.\n",
    "\n",
    "We use a 5-fold cross-validation scheme on 90% of the data and an independent test-set of 10% of the data."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "249f2774",
   "metadata": {},
   "source": [
    "Import required functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "a3d30f66",
   "metadata": {},
   "outputs": [],
   "source": [
    "from Library.Build_Model import *\n",
    "\n",
    "# We declare this function here and not in the\n",
    "# function-storing python file to modify it easily\n",
    "# as it can change the printouts of the methods\n",
    "def printout(filename, Stats, model, time): \n",
    "    # printing Stats\n",
    "    print('Stats for %s CPU-time %.4f' % (filename, time))\n",
    "    print('R2 = %.4f (+/- %.4f) Constraint = %.4f (+/- %.4f)' % \\\n",
    "          (Stats.train_objective[0], Stats.train_objective[1],\n",
    "           Stats.train_loss[0], Stats.train_loss[1]))\n",
    "    print('Q2 = %.4f (+/- %.4f) Constraint = %.4f (+/- %.4f)' % \\\n",
    "          (Stats.test_objective[0], Stats.test_objective[1],\n",
    "           Stats.test_loss[0], Stats.test_loss[1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "449c09a5",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of reactions:  154 154\n",
      "number of metabolites:  72\n",
      "filtered measurements size:  1\n",
      "training file: ./Dataset_model/e_coli_core_UB_50\n",
      "model type: AMN_QP\n",
      "model scaler: 1.0\n",
      "model input dim: 20\n",
      "model output dim: 1\n",
      "model medium bound: UB\n",
      "timestep: 4\n",
      "training set size (50, 20) (50, 1)\n",
      "nbr hidden layer: 1\n",
      "hidden layer size: 50\n",
      "activation function: relu\n",
      "gradient learn rate: 0.01\n",
      "gradient decay rate: 0.9\n",
      "training epochs: 500\n",
      "training regression: True\n",
      "training learn rate: 0.001\n",
      "training dropout: 0.25\n",
      "training batch size: 5\n",
      "training validation iter: 0\n",
      "training xfold: 5\n",
      "training early stopping: False\n",
      "nbr parameters: 8904\n",
      "train = 0.98 test = 0.98 loss-train = 0.002290 loss-test = 0.002122 iter=0\n",
      "nbr parameters: 8904\n",
      "train = 0.91 test = 0.87 loss-train = 0.004192 loss-test = 0.003801 iter=0\n",
      "nbr parameters: 8904\n",
      "train = 0.81 test = 0.79 loss-train = 0.003999 loss-test = 0.005352 iter=0\n",
      "nbr parameters: 8904\n",
      "train = 0.93 test = 0.86 loss-train = 0.004553 loss-test = 0.005119 iter=0\n",
      "nbr parameters: 8904\n",
      "train = 0.99 test = 0.97 loss-train = 0.002111 loss-test = 0.001826 iter=0\n",
      "Stats for e_coli_core_UB_50_AMN_QP CPU-time 530.8478\n",
      "R2 = 0.9229 (+/- 0.0632) Constraint = 0.0034 (+/- 0.0010)\n",
      "Q2 = 0.8954 (+/- 0.0706) Constraint = 0.0036 (+/- 0.0015)\n",
      "./Reservoir/e_coli_core_UB_50_AMN_QP_param.csv\n",
      "training file: ./Dataset_model/e_coli_core_UB_50\n",
      "model type: AMN_QP\n",
      "model scaler: 10.0\n",
      "model input dim: 20\n",
      "model output dim: 312\n",
      "model medium bound: UB\n",
      "timestep: 4\n",
      "training set size (50, 20) (50, 1)\n",
      "nbr hidden layer: 1\n",
      "hidden layer size: 50\n",
      "activation function: relu\n",
      "gradient learn rate: 0.01\n",
      "gradient decay rate: 0.9\n",
      "training epochs: 500\n",
      "training regression: True\n",
      "training learn rate: 0.001\n",
      "training dropout: 0.25\n",
      "training batch size: 5\n",
      "training validation iter: 0\n",
      "training xfold: 5\n",
      "training early stopping: False\n",
      "Stats for Test set CPU-time 0.7601\n",
      "R2 = 0.9340 (+/- 0.0000) Constraint = 0.0015 (+/- 0.0000)\n",
      "Q2 = 0.9340 (+/- 0.0000) Constraint = 0.0015 (+/- 0.0000)\n"
     ]
    }
   ],
   "source": [
    "# Create, train and evaluate AMN_QP o models with FBA simulated training set for E. coli core\n",
    "# with EB or UB with a mechanistic layer\n",
    "\n",
    "# What you can change \n",
    "seed = 10\n",
    "ratio_test = 0.1 # part of the training set removed for test\n",
    "np.random.seed(seed=seed)  \n",
    "trainname = 'e_coli_core_UB_50' # can change EB by UB\n",
    "timestep = 4\n",
    "# End of What you can change\n",
    "  \n",
    "# Create model 90% for training 10% for testing\n",
    "trainingfile = DIRECTORY+'Dataset_model/'+trainname\n",
    "model = Neural_Model(trainingfile = trainingfile, \n",
    "                     objective=['BIOMASS_Ecoli_core_w_GAM'],  \n",
    "                     model_type='AMN_QP', \n",
    "                     timestep = timestep, learn_rate=0.01,\n",
    "                     scaler=True,\n",
    "                     n_hidden = 1, hidden_dim = 50,\n",
    "                     epochs=500, xfold=5,\n",
    "                     verbose=True)\n",
    "ID = np.random.choice(model.X.shape[0], \n",
    "                      size=int(model.X.shape[0]*ratio_test), replace=False)\n",
    "Xtest,  Ytest  = model.X[ID,:], model.Y[ID,:]\n",
    "Xtrain, Ytrain = np.delete(model.X, ID, axis=0), np.delete(model.Y, ID, axis=0)\n",
    "model.printout()\n",
    "\n",
    "# Train and evaluate\n",
    "reservoirname = trainname+'_'+model.model_type\n",
    "reservoirfile = DIRECTORY+'Reservoir/'+reservoirname\n",
    "start_time = time.time()\n",
    "model.X, model.Y = Xtrain, Ytrain\n",
    "reservoir, pred, stats, _ = train_evaluate_model(model, verbose=False)\n",
    "delta_time = time.time() - start_time\n",
    "\n",
    "# Printing cross-validation results\n",
    "printout(reservoirname, stats, model, delta_time)\n",
    "\n",
    "# Save, reload and run idependent test set\n",
    "reservoir.save(reservoirfile)\n",
    "reservoir.load(reservoirfile)\n",
    "reservoir.printout()\n",
    "if len(Xtest) > 0:\n",
    "    start_time = time.time()\n",
    "    reservoir.X, reservoir.Y = Xtest, Ytest\n",
    "    X, Y = model_input(reservoir, verbose=False)\n",
    "    pred, stats = evaluate_model(reservoir.model, X, Y, reservoir, verbose=False)\n",
    "    delta_time = time.time() - start_time\n",
    "    printout('Test set', stats, model, delta_time)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cbaceeca",
   "metadata": {},
   "source": [
    "With the given parameters the AMN should outperform the ANN and get to 0.93 of Q2. Moreover, it should comply with the constraints of the metabolic network, obtaining an aggregated constraint (see research paper or source code) of roughly 0.001."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.8.10 64-bit",
   "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.10"
  },
  "vscode": {
   "interpreter": {
    "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}