M1_cv_with_ion_channel_genes_2d_bottleneck.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Cross-validation of models for Scala et al. with ion channel genes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import packages\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "import pandas as pd\n",
    "import matplotlib\n",
    "import seaborn as sns\n",
    "import sparseRRR\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "import importlib\n",
    "\n",
    "import bottleneck_networks_tf2\n",
    "\n",
    "import time\n",
    "import pickle\n",
    "import warnings\n",
    "\n",
    "dtype = tf.float32\n",
    "\n",
    "def sns_styleset():\n",
    "    sns.set_style('ticks', {'axes.linewidth': .75, \"xtick.major.size\":4, \"ytick.major.size\":4})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loading data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "scala = pickle.load(open('data/scala_2020/scala2020_with_ion_channel_genes.pickle', 'rb'))\n",
    "genes=scala['X']\n",
    "ephys=scala['Y']\n",
    "gene_names=scala['gene_names']\n",
    "cell_types=scala['celltypes']\n",
    "cell_id_to_cell_type=scala['map']\n",
    "ephys_names=scala['ephys_features']\n",
    "colors=scala['colors']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us find K-mean clusters to perform pre-training. One could also pre-train on celltype classification. This has actually improved performance even more but could be argued to be biasing the results too much. K-means allows for an unsupervised more general setting."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You can cluster according to amounts of classes or amounts of celltypes. Change the argument of n_clusters accordingly.\n",
    "from sklearn.cluster import KMeans\n",
    "kmeans = KMeans(n_clusters=20, random_state=17, n_init=1000).fit(ephys)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "clusters = kmeans.labels_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "amount_of_cells_in_clusters = {cluster_id: sum(clusters==cluster_id) for cluster_id in np.unique(clusters)}\n",
    "for_every_cell_number_of_cells_of_their_cluster = np.array([amount_of_cells_in_clusters[cell] for cell in clusters])\n",
    "ind_pre_training_clusters = for_every_cell_number_of_cells_of_their_cluster >= 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Keras initialisations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow import keras\n",
    "from tensorflow.keras.datasets import mnist\n",
    "from tensorflow.keras.models import Sequential, Model\n",
    "from tensorflow.keras.layers import Dense\n",
    "from tensorflow.keras.optimizers import Adam\n",
    "from tensorflow.keras import regularizers\n",
    "from tensorflow.keras.wrappers.scikit_learn import KerasClassifier\n",
    "from tensorflow.keras.utils import to_categorical\n",
    "from tensorflow.keras import metrics\n",
    "from tensorflow.keras.losses import CategoricalCrossentropy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.callbacks import EarlyStopping\n",
    "from tensorflow.keras.callbacks import ModelCheckpoint\n",
    "from tensorflow.keras.models import load_model\n",
    "import tensorflow.keras.backend as K"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "tf.compat.v1.disable_eager_execution()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You should assume you get two TensorFlow variables as input\n",
    "y_actual = tf.compat.v1.placeholder(dtype = tf.float32)\n",
    "y_predicted = tf.compat.v1.placeholder(dtype = tf.float32)\n",
    "def r2_score(y_truth, y_pred):\n",
    "    residual = tf.add(y_truth, -y_pred, name='residual')\n",
    "    return 1-tf.reduce_sum(input_tensor=tf.square(residual)) / tf.reduce_sum(input_tensor=tf.square(y_truth))\n",
    "r2_score_result = r2_score(y_actual, y_predicted)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ElasticNet(tf.keras.regularizers.Regularizer): \n",
    "    def __init__(self, l1=1e-8, l2=1.0): \n",
    "        self.l1 = l1\n",
    "        self.l2 = l2\n",
    "\n",
    "    def __call__(self, x): \n",
    "        return self.l2*tf.math.reduce_sum(input_tensor=tf.math.square(x)) + \\\n",
    "                             self.l1*tf.reduce_sum(input_tensor=tf.norm(tensor=x, ord = 2, axis = 1))\n",
    "\n",
    "    def get_config(self): \n",
    "        return {'l1': float(self.l1), 'l2': float(self.l2)}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cross validation to various training strategies"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Group lasso + ridge penalty straight regression (no pre-training) model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "from bottleneck_networks_tf2 import StraightRegression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "CVFOLD:  0\n",
      "WARNING:tensorflow:AutoGraph could not transform <function r2_score at 0x7f08c4ae7d40> and will run it as-is.\n",
      "Please report this to the TensorFlow team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output.\n",
      "Cause: 'arguments' object has no attribute 'posonlyargs'\n",
      "To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert\n",
      "WARNING: AutoGraph could not transform <function r2_score at 0x7f08c4ae7d40> and will run it as-is.\n",
      "Please report this to the TensorFlow team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output.\n",
      "Cause: 'arguments' object has no attribute 'posonlyargs'\n",
      "To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert\n",
      "[INFO] training network...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.7/dist-packages/keras/engine/training_v1.py:2057: UserWarning: `Model.state_updates` will be removed in a future version. This property should not be used in TensorFlow 2.0, as `updates` are applied automatically.\n",
      "  updates = self.state_updates\n",
      "/usr/local/lib/python3.7/dist-packages/keras/engine/training_v1.py:2079: UserWarning: `Model.state_updates` will be removed in a future version. This property should not be used in TensorFlow 2.0, as `updates` are applied automatically.\n",
      "  updates=self.state_updates,\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The 25 genes that make it:  ['Itgav' 'Clca4b' 'Kcnd3' 'Itpr1' 'Kcnab1' 'Grik1' 'Slc24a4' 'Hcn1'\n",
      " 'Kcnv1' 'Cacna2d2' 'Ano3' 'Scn1b' 'Gabrd' 'Cacng3' 'Cnr1' 'Kcnc2'\n",
      " 'Cacna1e' 'Kcnh4' 'Kcnc1' 'Kcnab3' 'Grin3a' 'Gabra1' 'Htr3a' 'Cacna2d1'\n",
      " 'Slc17a7']\n",
      "[INFO] training network...\n",
      "Train R^2 before pruning:  0.38215428590774536\n",
      "Test R^2 after pruning:  0.39717817306518555\n",
      "Train R^2 after pruning:  0.38328319787979126\n",
      "Test R^2 after pruning:  0.3951018452644348\n",
      "\n",
      "CVFOLD:  1\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Cacna2d2' 'Hcn1' 'Kcnab1' 'Itpr1' 'Cacng3' 'Ano3' 'Slc24a2' 'Gria3'\n",
      " 'Kcnh4' 'Kcnip2' 'Gabrd' 'Scn1b' 'Kcnip4' 'Cnr1' 'Cacna1e' 'Kcnv1'\n",
      " 'Grik1' 'Kcnc1' 'Gabra1' 'Kcnc2' 'Kcnab3' 'Grin3a' 'Slc17a7' 'Htr3a'\n",
      " 'Cacna2d1']\n",
      "[INFO] training network...\n",
      "Train R^2 before pruning:  0.3834921717643738\n",
      "Test R^2 after pruning:  0.35278254747390747\n",
      "Train R^2 after pruning:  0.37650346755981445\n",
      "Test R^2 after pruning:  0.3546901345252991\n",
      "\n",
      "CVFOLD:  2\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Hcn1' 'Chrne' 'Chrna4' 'Scn10a' 'Kcnip4' 'Cacng3' 'Cacna1e' 'Kcnf1'\n",
      " 'Ano3' 'Kcnab3' 'Kcnv1' 'Gria3' 'Cnr1' 'Kcnip2' 'Kcnh4' 'Kcnc2' 'Kcnc1'\n",
      " 'Itpr1' 'Grik1' 'Gabrd' 'Gabra1' 'Htr3a' 'Cacna2d1' 'Grin3a' 'Slc17a7']\n",
      "[INFO] training network...\n",
      "Train R^2 before pruning:  0.3850126266479492\n",
      "Test R^2 after pruning:  0.32670092582702637\n",
      "Train R^2 after pruning:  0.3920474648475647\n",
      "Test R^2 after pruning:  0.3125283718109131\n",
      "\n",
      "CVFOLD:  3\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Gria3' 'Slc24a4' 'Hcn1' 'Htr1b' 'Kcnab1' 'Cacna2d2' 'Itpr1' 'Ano3'\n",
      " 'Chrna1' 'Kcnh4' 'Cacna2d3' 'Cacng3' 'Kcnab3' 'Cacna1e' 'Kcnc1' 'Kcnip2'\n",
      " 'Kcnv1' 'Cnr1' 'Gabra1' 'Gabrd' 'Kcnc2' 'Grin3a' 'Cacna2d1' 'Htr3a'\n",
      " 'Slc17a7']\n",
      "[INFO] training network...\n",
      "Train R^2 before pruning:  0.37521064281463623\n",
      "Test R^2 after pruning:  0.3094140887260437\n",
      "Train R^2 after pruning:  0.3887837529182434\n",
      "Test R^2 after pruning:  0.3167978525161743\n",
      "\n",
      "CVFOLD:  4\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Kcnv1' 'Pex5l' 'Kcnab1' 'Itgav' 'Cacna2d3' 'Trpm2' 'Kcnip4' 'Kcnip2'\n",
      " 'Hcn1' 'Cacng3' 'Slc24a4' 'Grik1' 'Kcnh4' 'Itpr1' 'Cacna1e' 'Kcnc1'\n",
      " 'Kcnab3' 'Gabrd' 'Kcnc2' 'Cnr1' 'Grin3a' 'Gabra1' 'Cacna2d1' 'Slc17a7'\n",
      " 'Htr3a']\n",
      "[INFO] training network...\n"
     ]
    }
   ],
   "source": [
    "# Settings\n",
    "l2_params = np.logspace(-10, -10, num=1)\n",
    "l1_params = np.array([1e-1])\n",
    "\n",
    "act = 'elu'\n",
    "folds = 10\n",
    "seed = 42\n",
    "lr=0.0001\n",
    "epochs=50\n",
    "bs=32\n",
    "prune=True\n",
    "patience=epochs\n",
    "\n",
    "r2_straight_regr = np.zeros((folds, l1_params.shape[0], l2_params.shape[0]))\n",
    "r2_straight_regr_tr = np.zeros((folds, l1_params.shape[0], l2_params.shape[0]))\n",
    "r2_straight_regr_ap = np.zeros((folds, l1_params.shape[0], l2_params.shape[0]))\n",
    "r2_straight_regr_ap_tr = np.zeros((folds, l1_params.shape[0], l2_params.shape[0]))\n",
    "r2_straight_regr_hist = np.zeros((folds, l1_params.shape[0], l2_params.shape[0], 4*epochs))\n",
    "r2_straight_regr_hist_tr = np.zeros((folds, l1_params.shape[0], l2_params.shape[0], 4*epochs))\n",
    "\n",
    "t = time.time()\n",
    "np.random.seed(seed)\n",
    "n = genes.shape[0]\n",
    "ind = np.random.permutation(n)\n",
    "X = genes[ind,:]\n",
    "Y = ephys[ind,:]\n",
    "\n",
    "nodes_list=[512,128,2,128,512]\n",
    "\n",
    "# CV folds\n",
    "for cvfold in range(folds):\n",
    "    print('\\nCVFOLD: ', cvfold)\n",
    "    indtest  = np.arange(cvfold*int(n/folds), (cvfold+1)*int(n/folds))\n",
    "    indtrain = np.setdiff1d(np.arange(n), indtest)\n",
    "    x_train = np.copy(X[indtrain,:])\n",
    "    y_train = np.copy(Y[indtrain,:])\n",
    "    x_test = np.copy(X[indtest,:])\n",
    "    y_test = np.copy(Y[indtest,:])\n",
    "\n",
    "    # Mean centering (like sRRR)\n",
    "    X_mean = np.mean(x_train, axis=0)\n",
    "    x_train -= X_mean\n",
    "    x_test -= X_mean\n",
    "    Y_mean = np.mean(y_train, axis=0)\n",
    "    y_train -= Y_mean\n",
    "    y_test -= Y_mean\n",
    "    \n",
    "    input_dim = x_train.shape[1]\n",
    "    output_dim = y_train.shape[1]\n",
    "    \n",
    "    for i, l2 in enumerate(l2_params):\n",
    "        #print('Ridge penalty: ', l2)\n",
    "        for j, l1 in enumerate(l1_params):\n",
    "            #print('Lasso penalty: ', l1)\n",
    "            BN_StraightRegression = StraightRegression(l1=l1, l2=l2, lr=lr, act=act, \\\n",
    "                                                       input_dim=input_dim, output_dim=output_dim, nodes_list=nodes_list)\n",
    "            r2_train, r2_test, \\\n",
    "                r2_ap_train, r2_ap_test, \\\n",
    "                train_hist, test_hist = BN_StraightRegression.train(x_train=x_train, y_train=y_train, \\\n",
    "                                                                                   x_test=x_test, y_test=y_test, \\\n",
    "                                                                                   epochs=epochs, bs=bs, patience=patience, \\\n",
    "                                                                                   cvfold_id=cvfold, l1_id=j, l2_id=i, \\\n",
    "                                                                                   prune=prune, geneNames=gene_names, \\\n",
    "                                                                                   verbose=0)\n",
    "            r2_straight_regr[cvfold, j, i] = r2_test\n",
    "            r2_straight_regr_tr[cvfold, j, i] = r2_train\n",
    "            r2_straight_regr_ap[cvfold, j, i] = r2_ap_test\n",
    "            r2_straight_regr_ap_tr[cvfold, j, i] = r2_ap_train\n",
    "            r2_straight_regr_hist[cvfold, j, i] = test_hist\n",
    "            r2_straight_regr_hist_tr[cvfold, j, i] = train_hist\n",
    "            #print('Test R^2 score (straight regression, no pre-tr): ', r2_straight_regr[cvfold, j, i])\n",
    "            #print('Test R^2 score after pruning (straight regression, no pre-tr): ', r2_straight_regr_ap[cvfold, j, i])\n",
    "\n",
    "t = time.time() - t\n",
    "m,s = divmod(t, 60)\n",
    "h,m = divmod(m, 60)\n",
    "print('Time: {}h {:2.0f}m {:2.0f}s'.format(h,m,s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('KerasSavedModels/scala_2020_with_ion_channel_genes_tf2/Bottleneck_r2_straight_regr_lasso.pickle', 'wb') as f:\n",
    "    pickle.dump([r2_straight_regr, r2_straight_regr_tr, \\\n",
    "                 r2_straight_regr_ap, r2_straight_regr_ap_tr, \\\n",
    "                 r2_straight_regr_hist, r2_straight_regr_hist_tr], f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Group lasso + ridge penalty classification pre-training model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from bottleneck_networks_tf2 import ClassificationPreTrain"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Immediately for different penalties, but we'll be only interested in the 1e-1 penalty (for now), i.e. see extensions later\n",
    "l2_params = np.logspace(-10, -10, num=1)\n",
    "l1_params = np.array([1e-4, 1e-2, 1e-1, 1])\n",
    "\n",
    "act = 'elu'\n",
    "folds = 10\n",
    "seed = 42\n",
    "lr=0.0001\n",
    "epochs=50\n",
    "bs=32\n",
    "patience=epochs\n",
    "\n",
    "\n",
    "t = time.time()\n",
    "np.random.seed(seed)\n",
    "n = genes.shape[0]\n",
    "ind = np.random.permutation(n)\n",
    "X = genes[ind,:]\n",
    "Y = ephys[ind,:]\n",
    "clusters_ = clusters[ind]\n",
    "ind_pre_train = ind_pre_training_clusters[ind]\n",
    "\n",
    "CE_loss = np.zeros((folds, l1_params.shape[0], l2_params.shape[0]))\n",
    "CE_loss_tr = np.zeros((folds, l1_params.shape[0], l2_params.shape[0]))\n",
    "pre_tr_hist = np.zeros((folds, l1_params.shape[0], l2_params.shape[0], epochs))\n",
    "pre_tr_hist_tr = np.zeros((folds, l1_params.shape[0], l2_params.shape[0], epochs))\n",
    "\n",
    "nodes_list=[512,128,2,128,512]\n",
    "\n",
    "# CV folds\n",
    "for cvfold in range(folds):\n",
    "    print('\\nCVFOLD: ', cvfold)\n",
    "    indtest  = np.arange(cvfold*int(n/folds), (cvfold+1)*int(n/folds))\n",
    "    indtrain = np.setdiff1d(np.arange(n), indtest)\n",
    "    x_train = np.copy(X[indtrain,:])\n",
    "    clusters_train = np.copy(clusters_[indtrain])\n",
    "    y_train = np.copy(Y[indtrain,:])\n",
    "    x_test = np.copy(X[indtest,:])\n",
    "    clusters_test = np.copy(clusters_[indtest])\n",
    "    y_test = np.copy(Y[indtest,:])\n",
    "\n",
    "    # Mean centering (like sRRR)\n",
    "    X_mean = np.mean(x_train, axis=0)\n",
    "    x_train -= X_mean\n",
    "    x_test -= X_mean\n",
    "    Y_mean = np.mean(y_train, axis=0)\n",
    "    y_train -= Y_mean\n",
    "    y_test -= Y_mean\n",
    "\n",
    "    # In our training set we now look for a 'pretraining' training and test data set that we can use\n",
    "    # for pretraing a classification network, i.e. picking the best model will be dones with a seperate val set in our\n",
    "    # training set for regression.\n",
    "\n",
    "    x_train_pre_tr = x_train[ind_pre_train[indtrain], :]\n",
    "    clusters_train_pre_tr = clusters_train[ind_pre_train[indtrain]]\n",
    "    \n",
    "    pre_train_size = 0.6\n",
    "    train_cnt = round(x_train_pre_tr.shape[0]*pre_train_size)\n",
    "    x_train_pre_tr_ = x_train_pre_tr[:train_cnt, :]\n",
    "    x_test_pre_tr_ = x_train_pre_tr[train_cnt:, :]\n",
    "    clusters_train_pre_tr_ = clusters_train_pre_tr[:train_cnt]\n",
    "    clusters_test_pre_tr_ = clusters_train_pre_tr[train_cnt:]\n",
    "    \n",
    "    for i, l2 in enumerate(l2_params):\n",
    "        #print('Ridge penalty: ', l2)\n",
    "        for j, l1 in enumerate(l1_params):\n",
    "            #print('Lasso penalty: ', l1)\n",
    "\n",
    "\n",
    "            input_dim = x_train.shape[1]\n",
    "            output_dim = to_categorical(clusters_train_pre_tr).shape[1]\n",
    "            BN_Classification = ClassificationPreTrain(l1=l1, l2=l2, lr=lr, act=act, input_dim=input_dim, \\\n",
    "                                                       output_dim=output_dim, nodes_list=nodes_list)\n",
    "            CE_train, CE_test, train_hist, test_hist = BN_Classification.train(x_train=x_train_pre_tr_, \\\n",
    "                                                                               cluster_train=clusters_train_pre_tr_, \\\n",
    "                                                                               x_test=x_test_pre_tr_, \\\n",
    "                                                                               cluster_test=clusters_test_pre_tr_, \\\n",
    "                                                                               epochs=epochs, bs=bs, patience=patience, \\\n",
    "                                                                               cvfold_id=cvfold, l1_id=j, l2_id=i, \\\n",
    "                                                                               verbose=0)\n",
    "            CE_loss[cvfold, j, i] = CE_test\n",
    "            CE_loss_tr[cvfold, j, i] = CE_train\n",
    "            pre_tr_hist[cvfold, j, i] = test_hist\n",
    "            pre_tr_hist_tr[cvfold, j, i] = train_hist\n",
    "            #print('Test CE loss (pre-trainin): ', CE_loss[cvfold, j, i])\n",
    "            \n",
    "t = time.time() - t\n",
    "m,s = divmod(t, 60)\n",
    "h,m = divmod(m, 60)\n",
    "print('Time: {}h {:2.0f}m {:2.0f}s'.format(h,m,s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('KerasSavedModels/scala_2020_with_ion_channel_genes_tf2/Bottleneck_pre_tr_lasso.pickle', 'wb') as f:\n",
    "    pickle.dump([CE_loss, CE_loss_tr, pre_tr_hist, pre_tr_hist_tr], f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Group lasso + ridge penalty pre-train and regression model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Settings\n",
    "l2_params = np.logspace(-10, -10, num=1)\n",
    "l1_params = np.array([1e-1])\n",
    "\n",
    "act = 'elu'\n",
    "folds = 10\n",
    "seed = 42\n",
    "lr=0.0001\n",
    "epochs=50\n",
    "bs=32\n",
    "patience=epochs\n",
    "pre_trained_weights=True\n",
    "prune=True\n",
    "\n",
    "r2_pretr_straight_regr = np.zeros((folds, l1_params.shape[0], l2_params.shape[0]))\n",
    "r2_pretr_straight_regr_tr = np.zeros((folds, l1_params.shape[0], l2_params.shape[0]))\n",
    "r2_pretr_straight_regr_ap = np.zeros((folds, l1_params.shape[0], l2_params.shape[0]))\n",
    "r2_pretr_straight_regr_ap_tr = np.zeros((folds, l1_params.shape[0], l2_params.shape[0]))\n",
    "r2_pretr_straight_regr_hist = np.zeros((folds, l1_params.shape[0], l2_params.shape[0], 4*epochs))\n",
    "r2_pretr_straight_regr_hist_tr = np.zeros((folds, l1_params.shape[0], l2_params.shape[0], 4*epochs))\n",
    "\n",
    "t = time.time()\n",
    "np.random.seed(seed)\n",
    "n = genes.shape[0]\n",
    "ind = np.random.permutation(n)\n",
    "X = genes[ind,:]\n",
    "Y = ephys[ind,:]\n",
    "\n",
    "nodes_list=[512,128,2,128,512]\n",
    "\n",
    "# CV folds\n",
    "for cvfold in range(folds):\n",
    "    print('\\nCVFOLD: ', cvfold)\n",
    "    indtest  = np.arange(cvfold*int(n/folds), (cvfold+1)*int(n/folds))\n",
    "    indtrain = np.setdiff1d(np.arange(n), indtest)\n",
    "    x_train = np.copy(X[indtrain,:])\n",
    "    y_train = np.copy(Y[indtrain,:])\n",
    "    x_test = np.copy(X[indtest,:])\n",
    "    y_test = np.copy(Y[indtest,:])\n",
    "\n",
    "    # Mean centering (like sRRR)\n",
    "    X_mean = np.mean(x_train, axis=0)\n",
    "    x_train -= X_mean\n",
    "    x_test -= X_mean\n",
    "    Y_mean = np.mean(y_train, axis=0)\n",
    "    y_train -= Y_mean\n",
    "    y_test -= Y_mean\n",
    "    \n",
    "    input_dim = x_train.shape[1]\n",
    "    output_dim = y_train.shape[1]\n",
    "    \n",
    "    for i, l2 in enumerate(l2_params):\n",
    "        #print('Ridge penalty: ', l2)\n",
    "        for j, l1 in enumerate(l1_params):\n",
    "            #print('Lasso penalty: ', l1)\n",
    "            \n",
    "            pre_trained_weights_h5 = 'KerasSavedModels/Classification_last_weights_{}_{}_{}.h5'.format(cvfold, 2, i)\n",
    "            \n",
    "            BN_PreTrStraightRegression = StraightRegression(l1=l1, l2=l2, lr=lr, act=act, \\\n",
    "                                            input_dim=input_dim, output_dim=output_dim, \\\n",
    "                                            pre_trained_weights=pre_trained_weights, \\\n",
    "                                            pre_trained_weights_h5=pre_trained_weights_h5, nodes_list=nodes_list)\n",
    "            r2_train, r2_test, \\\n",
    "                r2_train_ap, r2_test_ap, \\\n",
    "                train_hist, test_hist = BN_PreTrStraightRegression.train(x_train=x_train, y_train=y_train, \\\n",
    "                                                                                   x_test=x_test, y_test=y_test, \\\n",
    "                                                                                   epochs=epochs, bs=bs, patience=patience, \\\n",
    "                                                                                   cvfold_id=cvfold, l1_id=j, l2_id=i, \\\n",
    "                                                                                   prune=prune, geneNames=gene_names, \\\n",
    "                                                                                   verbose=0)\n",
    "            r2_pretr_straight_regr[cvfold, j, i] = r2_test\n",
    "            r2_pretr_straight_regr_tr[cvfold, j, i] = r2_train\n",
    "            r2_pretr_straight_regr_ap[cvfold, j, i] = r2_test_ap\n",
    "            r2_pretr_straight_regr_ap_tr[cvfold, j, i] = r2_train_ap            \n",
    "            r2_pretr_straight_regr_hist[cvfold, j, i] = test_hist\n",
    "            r2_pretr_straight_regr_hist_tr[cvfold, j, i] = train_hist\n",
    "            #print('Test R^2 score (regression, after pre-tr): ', r2_pretr_straight_regr[cvfold, j, i])\n",
    "            #print('Test R^2 score (regression, after pre-tr), after pruning: ', r2_pretr_straight_regr_ap[cvfold, j, i])\n",
    "\n",
    "t = time.time() - t\n",
    "m,s = divmod(t, 60)\n",
    "h,m = divmod(m, 60)\n",
    "print('Time: {}h {:2.0f}m {:2.0f}s'.format(h,m,s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('KerasSavedModels/scala_2020_with_ion_channel_genes_tf2/Bottleneck_r2_pre_tr_and_straight_regr_lasso.pickle', 'wb') as f:\n",
    "    pickle.dump([r2_pretr_straight_regr, r2_pretr_straight_regr_tr, \\\n",
    "                 r2_pretr_straight_regr_ap, r2_pretr_straight_regr_ap_tr, \\\n",
    "                 r2_pretr_straight_regr_hist, r2_pretr_straight_regr_hist_tr], f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Group lasso + ridge penalty pre-train + freeze the first 2 layers + unfreeze model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from bottleneck_networks_tf2 import FreezeUnfreeze"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Settings\n",
    "l2_params = np.logspace(-10, -10, num=1)\n",
    "l1_params = np.array([1e-4, 1e-2, 1e-1, 1])\n",
    "\n",
    "act = 'elu'\n",
    "folds = 10\n",
    "seed = 42\n",
    "lr=0.0001\n",
    "epochs=50\n",
    "bs=32\n",
    "patience=epochs\n",
    "pre_trained_weights=True\n",
    "unfreeze = [False, False, True, True, True, True] # last 4 layers can be trained only first\n",
    "prune=True\n",
    "\n",
    "r2_before_unfreezing = np.zeros((folds, l1_params.shape[0], l2_params.shape[0]))\n",
    "r2_before_unfreezing_tr = np.zeros((folds, l1_params.shape[0], l2_params.shape[0]))\n",
    "r2_after_unfreezing = np.zeros((folds, l1_params.shape[0], l2_params.shape[0]))\n",
    "r2_after_unfreezing_tr = np.zeros((folds, l1_params.shape[0], l2_params.shape[0]))\n",
    "r2_after_unfreezing_ap = np.zeros((folds, l1_params.shape[0], l2_params.shape[0]))\n",
    "r2_after_unfreezing_ap_tr = np.zeros((folds, l1_params.shape[0], l2_params.shape[0]))\n",
    "r2_freeze_unfreeze_hist = np.zeros((folds, l1_params.shape[0], l2_params.shape[0], 4*epochs))\n",
    "r2_freeze_unfreeze_hist_tr = np.zeros((folds, l1_params.shape[0], l2_params.shape[0], 4*epochs))\n",
    "\n",
    "t = time.time()\n",
    "np.random.seed(seed)\n",
    "n = genes.shape[0]\n",
    "ind = np.random.permutation(n)\n",
    "X = genes[ind,:]\n",
    "Y = ephys[ind,:]\n",
    "\n",
    "nodes_list=[512,128,2,128,512]\n",
    "\n",
    "# CV folds\n",
    "for cvfold in range(folds):\n",
    "    print('\\nCVFOLD: ', cvfold)\n",
    "    indtest  = np.arange(cvfold*int(n/folds), (cvfold+1)*int(n/folds))\n",
    "    indtrain = np.setdiff1d(np.arange(n), indtest)\n",
    "    x_train = np.copy(X[indtrain,:])\n",
    "    y_train = np.copy(Y[indtrain,:])\n",
    "    x_test = np.copy(X[indtest,:])\n",
    "    y_test = np.copy(Y[indtest,:])\n",
    "\n",
    "    # Mean centering (like sRRR)\n",
    "    X_mean = np.mean(x_train, axis=0)\n",
    "    x_train -= X_mean\n",
    "    x_test -= X_mean\n",
    "    Y_mean = np.mean(y_train, axis=0)\n",
    "    y_train -= Y_mean\n",
    "    y_test -= Y_mean\n",
    "    \n",
    "    input_dim = x_train.shape[1]\n",
    "    output_dim = y_train.shape[1]\n",
    "    \n",
    "    for i, l2 in enumerate(l2_params):\n",
    "        #print('Ridge penalty: ', l2)\n",
    "        for j, l1 in enumerate(l1_params):\n",
    "            #print('Lasso penalty: ', l1)\n",
    "            \n",
    "            pre_trained_weights_h5 = 'KerasSavedModels/Classification_last_weights_{}_{}_{}.h5'.format(cvfold, j, i)\n",
    "            input_dim = x_train.shape[1]\n",
    "            output_dim = y_train.shape[1]\n",
    "            BN_PreTrFreezeUnfreeze = FreezeUnfreeze(l1=l1, l2=l2, lr=lr, act=act, input_dim=input_dim, output_dim=output_dim, \\\n",
    "                                                       unfreeze = unfreeze, \\\n",
    "                                                       pre_trained_weights=pre_trained_weights, \\\n",
    "                                                       pre_trained_weights_h5=pre_trained_weights_h5, nodes_list=nodes_list)\n",
    "            r2_before_unfreezing_train, r2_before_unfreezing_test, \\\n",
    "                r2_after_unfreezing_train, r2_after_unfreezing_test, \\\n",
    "                r2_after_unfreezing_train_ap, r2_after_unfreezing_test_ap, \\\n",
    "                train_hist, test_hist = BN_PreTrFreezeUnfreeze.train(x_train=x_train, y_train=y_train, \\\n",
    "                                                                    x_test=x_test, y_test=y_test, \\\n",
    "                                                                    epochs=epochs, bs=bs, patience=patience, \\\n",
    "                                                                    cvfold_id=cvfold, l1_id=j, l2_id=i, \\\n",
    "                                                                    prune=prune, geneNames=gene_names, \\\n",
    "                                                                    verbose=0,\n",
    "                                                                    report_individual_ephys_feature_test_R2=True)\n",
    "            r2_before_unfreezing[cvfold, j, i] = r2_before_unfreezing_test\n",
    "            r2_before_unfreezing_tr[cvfold, j, i] = r2_before_unfreezing_train\n",
    "            r2_after_unfreezing[cvfold, j, i] = r2_after_unfreezing_test\n",
    "            r2_after_unfreezing_tr[cvfold, j, i] = r2_after_unfreezing_train\n",
    "            r2_after_unfreezing_ap[cvfold, j, i] = r2_after_unfreezing_test_ap\n",
    "            r2_after_unfreezing_ap_tr[cvfold, j, i] = r2_after_unfreezing_train_ap\n",
    "            r2_freeze_unfreeze_hist[cvfold, j, i] = test_hist\n",
    "            r2_freeze_unfreeze_hist_tr[cvfold, j, i] = train_hist\n",
    "            #print('Test R^2 score (before unfreezing): ', r2_before_unfreezing[cvfold, j, i])\n",
    "            #print('Test R^2 score (after unfreezing): ', r2_after_unfreezing[cvfold, j, i])\n",
    "            #print('Test R^2 score (after unfreezing and after pruning): ', r2_after_unfreezing_ap[cvfold, j, i])\n",
    "            \n",
    "t = time.time() - t\n",
    "m,s = divmod(t, 60)\n",
    "h,m = divmod(m, 60)\n",
    "print('Time: {}h {:2.0f}m {:2.0f}s'.format(h,m,s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#with ion channel genes\n",
    "np.load('KerasSavedModels/individual_ephys_feature_test_R2_{}_2_0.npz'\\\n",
    "                                                             .format(0))['R2']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# For the revision, with ion channel genes:\n",
    "individual_ephys_test_R2_scores=np.zeros((folds,Y.shape[1]))\n",
    "for i in range(folds):\n",
    "    individual_ephys_test_R2_scores[i,:]=np.load('KerasSavedModels/individual_ephys_feature_test_R2_{}_2_0.npz'\\\n",
    "                                                             .format(i))['R2']\n",
    "individual_R2_scores={}\n",
    "individual_R2_scores_std={}\n",
    "for i in range(Y.shape[1]):\n",
    "    individual_R2_scores.update(\n",
    "        {ephys_names[i]:np.mean(individual_ephys_test_R2_scores, axis=0)[i]}\n",
    "                               )\n",
    "    individual_R2_scores_std.update(\n",
    "        {ephys_names[i]:np.std(individual_ephys_test_R2_scores, axis=0)[i]}\n",
    "                               )\n",
    "R2_full=np.mean(r2_freeze_unfreeze_hist[:,2,0,-1],axis=0)\n",
    "print('R^2 score on all: ', R2_full)\n",
    "print('\\nindividual contributions: ')\n",
    "individual_R2_scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# For the revision, with ion channel genes:\n",
    "print(\"individual contributions \\w their std's\")\n",
    "individual_R2_scores_std"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('KerasSavedModels/scala_2020_with_ion_channel_genes/ind_feature_scores.pickle', 'wb') as f:\n",
    "    pickle.dump([individual_R2_scores, individual_R2_scores_std], f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# For the revision, with human ion channel genes:\n",
    "order=np.argsort(np.array([individual_R2_scores[key] for key in individual_R2_scores]))[::-1]\n",
    "fig, ax = plt.subplots(1,1,figsize=(8,5))\n",
    "# ax.scatter(\n",
    "#            np.array([key for key in individual_R2_scores])[order],\n",
    "#            np.array([individual_R2_scores[key] for key in individual_R2_scores])[order],\n",
    "#            color='k'\n",
    "#           )\n",
    "ax.errorbar(np.array([key for key in individual_R2_scores])[order],\n",
    "            np.array([individual_R2_scores[key] for key in individual_R2_scores])[order],\n",
    "            np.array([individual_R2_scores_std[key] for key in individual_R2_scores_std])[order],\n",
    "            marker='.', color='k', markersize=10, capsize=5, linestyle='none')\n",
    "ax.hlines(R2_full,\n",
    "          xmin=ax.get_xlim()[0],\n",
    "          xmax=ax.get_xlim()[1],\n",
    "          linestyle='dashed')\n",
    "ax.set_ylim(ymin=0,ymax=1)\n",
    "ax.annotate(r'Multivariate $R^2$={0:.2f}'.format(R2_full),\n",
    "           (ax.get_xlim()[0]+1.3*(ax.get_xlim()[1]-ax.get_xlim()[0])/2, R2_full+0.02),\n",
    "            fontsize=13)\n",
    "plt.xticks(rotation='80', fontsize=13)\n",
    "ax.set_ylabel(r'Cross validated $R^2$', fontsize=13)\n",
    "sns.despine()\n",
    "plt.savefig('./figures/preliminary/individual_ephys_prediction_scores_with_ion_channel_genes.png',\n",
    "            bbox_inches = 'tight',\n",
    "            pad_inches = 0)\n",
    "plt.savefig('./figures/preliminary/individual_ephys_prediction_scores_with_ion_channel_genes.pdf',\n",
    "            bbox_inches = 'tight',\n",
    "            pad_inches = 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# For the revision, with mouse ion channel genes:\n",
    "order=np.argsort(np.array([individual_R2_scores[key] for key in individual_R2_scores]))[::-1]\n",
    "fig, ax = plt.subplots(1,1,figsize=(8,5))\n",
    "# ax.scatter(\n",
    "#            np.array([key for key in individual_R2_scores])[order],\n",
    "#            np.array([individual_R2_scores[key] for key in individual_R2_scores])[order],\n",
    "#            color='k'\n",
    "#           )\n",
    "ax.errorbar(np.array([key for key in individual_R2_scores])[order],\n",
    "            np.array([individual_R2_scores[key] for key in individual_R2_scores])[order],\n",
    "            np.array([individual_R2_scores_std[key] for key in individual_R2_scores_std])[order],\n",
    "            marker='.', color='k', markersize=10, capsize=5, linestyle='none')\n",
    "ax.hlines(R2_full,\n",
    "          xmin=ax.get_xlim()[0],\n",
    "          xmax=ax.get_xlim()[1],\n",
    "          linestyle='dashed')\n",
    "ax.set_ylim(ymin=0,ymax=1)\n",
    "ax.annotate(r'Multivariate $R^2$={0:.2f}'.format(R2_full),\n",
    "           (ax.get_xlim()[0]+1.3*(ax.get_xlim()[1]-ax.get_xlim()[0])/2, R2_full+0.02),\n",
    "            fontsize=13)\n",
    "plt.xticks(rotation='80', fontsize=13)\n",
    "ax.set_ylabel(r'Cross validated $R^2$', fontsize=13)\n",
    "sns.despine()\n",
    "plt.savefig('./figures/preliminary/individual_ephys_prediction_scores_with_ion_channel_genes.png',\n",
    "            bbox_inches = 'tight',\n",
    "            pad_inches = 0)\n",
    "plt.savefig('./figures/preliminary/individual_ephys_prediction_scores_with_ion_channel_genes.pdf',\n",
    "            bbox_inches = 'tight',\n",
    "            pad_inches = 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('KerasSavedModels/scala_2020_with_ion_channel_genes_tf2/Bottleneck_r2_pre_tr_and_freeze_unfreeze_lasso.pickle', 'wb') as f:\n",
    "    pickle.dump([r2_before_unfreezing, r2_before_unfreezing_tr, \\\n",
    "                 r2_after_unfreezing, r2_after_unfreezing_tr, \\\n",
    "                 r2_after_unfreezing_ap, r2_after_unfreezing_ap_tr, \\\n",
    "                 r2_freeze_unfreeze_hist, r2_freeze_unfreeze_hist_tr], f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the next section we perform reduced-rank regression cross validation (rank = 2 and full rank)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CV sRRR rank = 2\n",
    "\n",
    "lambdas = np.arange(.1,2,.1)\n",
    "alphas = np.array([1])\n",
    "\n",
    "rank = 2\n",
    "folds = 10\n",
    "seed = 42\n",
    "\n",
    "r2_sRRR_rank2 = np.zeros((folds, alphas.shape[0], lambdas.shape[0]))\n",
    "r2_sRRR_rank2_tr = np.zeros((folds, alphas.shape[0], lambdas.shape[0]))\n",
    "r2_sRRR_relaxed_rank2 = np.zeros((folds, alphas.shape[0], lambdas.shape[0]))\n",
    "r2_sRRR_relaxed_rank2_tr = np.zeros((folds, alphas.shape[0], lambdas.shape[0]))\n",
    "nonzero_rank2 = np.zeros((folds, alphas.shape[0], lambdas.shape[0]))\n",
    "corrs_rank2 = np.zeros((folds, alphas.shape[0], lambdas.shape[0], rank))\n",
    "corrs_relaxed_rank2 = np.zeros((folds, alphas.shape[0], lambdas.shape[0], rank))\n",
    "\n",
    "\n",
    "t = time.time()\n",
    "\n",
    "np.random.seed(seed)\n",
    "n = genes.shape[0]\n",
    "ind = np.random.permutation(n)\n",
    "X = genes[ind,:]\n",
    "Y = ephys[ind,:]\n",
    "\n",
    "# CV folds\n",
    "for cvfold in range(folds):\n",
    "    print('\\nCVFOLD: ', cvfold)\n",
    "    indtest  = np.arange(cvfold*int(n/folds), (cvfold+1)*int(n/folds))\n",
    "    indtrain = np.setdiff1d(np.arange(n), indtest)\n",
    "    x_train = np.copy(X[indtrain,:])\n",
    "    y_train = np.copy(Y[indtrain,:])\n",
    "    x_test = np.copy(X[indtest,:])\n",
    "    y_test = np.copy(Y[indtest,:])\n",
    "\n",
    "    # Mean centering (like sRRR)\n",
    "    X_mean = np.mean(x_train, axis=0)\n",
    "    x_train -= X_mean\n",
    "    x_test -= X_mean\n",
    "    Y_mean = np.mean(y_train, axis=0)\n",
    "    y_train -= Y_mean\n",
    "    y_test -= Y_mean\n",
    "    \n",
    "    x_train = x_train.astype('float64')\n",
    "    y_train = y_train.astype('float64')\n",
    "    x_test = x_test.astype('float64')\n",
    "    y_test = y_test.astype('float64')\n",
    "    \n",
    "    for i,a in enumerate(lambdas):\n",
    "        #print('Lambdau: ', a)\n",
    "        for j, b in enumerate(alphas):\n",
    "            #print('Alpha: ', b)\n",
    "            vx,vy = sparseRRR.elastic_rrr(x_train, y_train, lambdau=a, alpha=b, rank=rank, sparsity='row-wise')\n",
    "\n",
    "            nz = np.sum(np.abs(vx), axis=1) != 0\n",
    "            if np.sum(nz) < rank:\n",
    "                nonzero_rank2[cvfold, j, i] = np.nan\n",
    "                continue\n",
    "\n",
    "            if np.allclose(np.std(x_test @ vx, axis=0), 0):\n",
    "                nonzero_rank2[cvfold, j, i] = np.nan\n",
    "                continue\n",
    "\n",
    "            nonzero_rank2[cvfold, j, i] = np.sum(nz)\n",
    "            r2_sRRR_rank2[cvfold, j, i] = 1 - np.sum((y_test - x_test @ vx @ vy.T)**2) / np.sum(y_test**2)\n",
    "            r2_sRRR_rank2_tr[cvfold, j, i] = 1 - np.sum((y_train - x_train @ vx @ vy.T)**2) / np.sum(y_train**2)\n",
    "            for r in range(rank):\n",
    "                corrs_rank2[cvfold, j, i, r] = np.corrcoef(x_test @ vx[:,r], y_test @ vy[:,r], rowvar=False)[0,1]\n",
    "\n",
    "            # Relaxation\n",
    "            vx[nz,:],vy = sparseRRR.elastic_rrr(x_train[:,nz], y_train, lambdau=a, alpha=0, rank=rank, sparsity='row-wise')\n",
    "\n",
    "            if np.allclose(np.std(x_test @ vx, axis=0), 0):\n",
    "                nonzero_rank2[cvfold, j, i] = np.nan\n",
    "                continue\n",
    "\n",
    "            r2_sRRR_relaxed_rank2[cvfold, j, i] = 1 - np.sum((y_test - x_test @ vx @ vy.T)**2) / np.sum(y_test**2)\n",
    "            r2_sRRR_relaxed_rank2_tr[cvfold, j, i] = 1 - np.sum((y_train - x_train @ vx @ vy.T)**2) / np.sum(y_train**2)\n",
    "            for r in range(rank):\n",
    "                corrs_relaxed_rank2[cvfold, j, i, r] = np.corrcoef(x_test @ vx[:,r], y_test @ vy[:,r], rowvar=False)[0,1]\n",
    "            #print(r2_sRRR_relaxed_rank2[cvfold, j, i])\n",
    "\n",
    "t = time.time() - t\n",
    "m,s = divmod(t, 60)\n",
    "h,m = divmod(m, 60)\n",
    "print('Time: {}h {:2.0f}m {:2.0f}s'.format(h,m,s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('KerasSavedModels/scala_2020_with_ion_channel_genes_tf2/sRRR_vs_Bottleneck_rank2_CV_lasso.pickle', 'wb') as f:\n",
    "    pickle.dump([r2_sRRR_rank2, r2_sRRR_relaxed_rank2, r2_sRRR_rank2_tr, r2_sRRR_relaxed_rank2_tr, \\\n",
    "                nonzero_rank2, corrs_rank2, corrs_relaxed_rank2], f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CV sRRR full rank\n",
    "\n",
    "lambdas = np.arange(.1,2,.1)\n",
    "alphas = np.array([1])\n",
    "\n",
    "rank = ephys.shape[1]\n",
    "folds = 10\n",
    "seed = 42\n",
    "\n",
    "r2_sRRR_rank16 = np.zeros((folds, alphas.shape[0], lambdas.shape[0]))\n",
    "r2_sRRR_rank16_tr = np.zeros((folds, alphas.shape[0], lambdas.shape[0]))\n",
    "r2_sRRR_relaxed_rank16 = np.zeros((folds, alphas.shape[0], lambdas.shape[0]))\n",
    "r2_sRRR_relaxed_rank16_tr = np.zeros((folds, alphas.shape[0], lambdas.shape[0]))\n",
    "nonzero_rank16 = np.zeros((folds, alphas.shape[0], lambdas.shape[0]))\n",
    "corrs_rank16 = np.zeros((folds, alphas.shape[0], lambdas.shape[0], rank))\n",
    "corrs_relaxed_rank16 = np.zeros((folds, alphas.shape[0], lambdas.shape[0], rank))\n",
    "\n",
    "\n",
    "t = time.time()\n",
    "\n",
    "np.random.seed(seed)\n",
    "n = genes.shape[0]\n",
    "ind = np.random.permutation(n)\n",
    "X = genes[ind,:]\n",
    "Y = ephys[ind,:]\n",
    "\n",
    "# CV folds\n",
    "for cvfold in range(folds):\n",
    "    print('\\nCVFOLD: ', cvfold)\n",
    "    indtest  = np.arange(cvfold*int(n/folds), (cvfold+1)*int(n/folds))\n",
    "    indtrain = np.setdiff1d(np.arange(n), indtest)\n",
    "    x_train = np.copy(X[indtrain,:])\n",
    "    y_train = np.copy(Y[indtrain,:])\n",
    "    x_test = np.copy(X[indtest,:])\n",
    "    y_test = np.copy(Y[indtest,:])\n",
    "\n",
    "    # Mean centering (like sRRR)\n",
    "    X_mean = np.mean(x_train, axis=0)\n",
    "    x_train -= X_mean\n",
    "    x_test -= X_mean\n",
    "    Y_mean = np.mean(y_train, axis=0)\n",
    "    y_train -= Y_mean\n",
    "    y_test -= Y_mean\n",
    "    \n",
    "    x_train = x_train.astype('float64')\n",
    "    y_train = y_train.astype('float64')\n",
    "    x_test = x_test.astype('float64')\n",
    "    y_test = y_test.astype('float64')\n",
    "    \n",
    "    for i,a in enumerate(lambdas):\n",
    "        #print('Labmdau: ', a)\n",
    "        for j, b in enumerate(alphas):\n",
    "            #print('Alpha: ', b)\n",
    "            vx,vy = sparseRRR.elastic_rrr(x_train, y_train, lambdau=a, alpha=b, rank=rank, sparsity='row-wise')\n",
    "\n",
    "            nz = np.sum(np.abs(vx), axis=1) != 0\n",
    "            if np.sum(nz) < rank:\n",
    "                nonzero_rank16[cvfold, j, i] = np.nan\n",
    "                continue\n",
    "\n",
    "            if np.allclose(np.std(x_test @ vx, axis=0), 0):\n",
    "                nonzero_rank16[cvfold, j, i] = np.nan\n",
    "                continue\n",
    "\n",
    "            nonzero_rank16[cvfold, j, i] = np.sum(nz)\n",
    "            r2_sRRR_rank16[cvfold, j, i] = 1 - np.sum((y_test - x_test @ vx @ vy.T)**2) / np.sum(y_test**2)\n",
    "            r2_sRRR_rank16_tr[cvfold, j, i] = 1 - np.sum((y_train - x_train @ vx @ vy.T)**2) / np.sum(y_train**2)\n",
    "            for r in range(rank):\n",
    "                corrs_rank16[cvfold, j, i, r] = np.corrcoef(x_test @ vx[:,r], y_test @ vy[:,r], rowvar=False)[0,1]\n",
    "\n",
    "            # Relaxation\n",
    "            vx[nz,:],vy = sparseRRR.elastic_rrr(x_train[:,nz], y_train, lambdau=a, alpha=0, rank=rank, sparsity='row-wise')\n",
    "\n",
    "            if np.allclose(np.std(x_test @ vx, axis=0), 0):\n",
    "                nonzero_rank16[cvfold, j, i] = np.nan\n",
    "                continue\n",
    "\n",
    "            r2_sRRR_relaxed_rank16[cvfold, j, i] = 1 - np.sum((y_test - x_test @ vx @ vy.T)**2) / np.sum(y_test**2)\n",
    "            r2_sRRR_relaxed_rank16_tr[cvfold, j, i] = 1 - np.sum((y_train - x_train @ vx @ vy.T)**2) / np.sum(y_train**2)\n",
    "            for r in range(rank):\n",
    "                corrs_relaxed_rank16[cvfold, j, i, r] = np.corrcoef(x_test @ vx[:,r], y_test @ vy[:,r], rowvar=False)[0,1]\n",
    "            #print(r2_sRRR_relaxed_rank16[cvfold, j, i])\n",
    "\n",
    "t = time.time() - t\n",
    "m,s = divmod(t, 60)\n",
    "h,m = divmod(m, 60)\n",
    "print('Time: {}h {:2.0f}m {:2.0f}s'.format(h,m,s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('KerasSavedModels/scala_2020_with_ion_channel_genes_tf2/sRRR_vs_Bottleneck_rank16_CV_lasso.pickle', 'wb') as f:\n",
    "    pickle.dump([r2_sRRR_rank16, r2_sRRR_relaxed_rank16, r2_sRRR_rank16_tr, r2_sRRR_relaxed_rank16_tr, \\\n",
    "                nonzero_rank16, corrs_rank16, corrs_relaxed_rank16], f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us now analyse and visualise the differences."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "lambdas = np.arange(.1,2,.1)\n",
    "alphas = np.array([1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('KerasSavedModels/scala_2020_with_ion_channel_genes_tf2/sRRR_vs_Bottleneck_rank2_CV_lasso.pickle', 'rb') as f:\n",
    "    r2_sRRR_rank2, r2_sRRR_relaxed_rank2, r2_sRRR_rank2_tr, r2_sRRR_relaxed_rank2_tr, \\\n",
    "                nonzero_rank2, corrs_rank2, corrs_relaxed_rank2 = pickle.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('KerasSavedModels/scala_2020_with_ion_channel_genes_tf2/sRRR_vs_Bottleneck_rank16_CV_lasso.pickle', 'rb') as f:\n",
    "    r2_sRRR_rank16, r2_sRRR_relaxed_rank16, r2_sRRR_rank16_tr, r2_sRRR_relaxed_rank16_tr, \\\n",
    "                nonzero_rank16, corrs_rank16, corrs_relaxed_rank16 = pickle.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('KerasSavedModels/scala_2020_with_ion_channel_genes_tf2/Bottleneck_pre_tr_lasso.pickle', 'rb') as f:\n",
    "    CE_loss, CE_loss_tr, pre_tr_hist, pre_tr_hist_tr = pickle.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('KerasSavedModels/scala_2020_with_ion_channel_genes_tf2/Bottleneck_r2_straight_regr_lasso.pickle', 'rb') as f:\n",
    "    r2_straight_regr, r2_straight_regr_tr, \\\n",
    "    r2_straight_regr_ap, r2_straight_regr_ap_tr, \\\n",
    "    r2_straight_regr_hist, r2_straight_regr_hist_tr = pickle.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('KerasSavedModels/scala_2020_with_ion_channel_genes_tf2/Bottleneck_r2_pre_tr_and_straight_regr_lasso.pickle', 'rb') as f:\n",
    "    r2_pretr_straight_regr, r2_pretr_straight_regr_tr, \\\n",
    "    r2_pretr_straight_regr_ap, r2_pretr_straight_regr_ap_tr, \\\n",
    "    r2_pretr_straight_regr_hist, r2_pretr_straight_regr_hist_tr = pickle.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('KerasSavedModels/scala_2020_with_ion_channel_genes_tf2/Bottleneck_r2_pre_tr_and_freeze_unfreeze_lasso.pickle', 'rb') as f:\n",
    "    r2_before_unfreezing, r2_before_unfreezing_tr, \\\n",
    "    r2_after_unfreezing, r2_after_unfreezing_tr, \\\n",
    "    r2_after_unfreezing_ap, r2_after_unfreezing_ap_tr, \\\n",
    "    r2_freeze_unfreeze_hist, r2_freeze_unfreeze_hist_tr = pickle.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Select closest to 25 genes value\n",
    "# suppressing \"mean of empty slice\" warnings\n",
    "with warnings.catch_warnings():\n",
    "    warnings.simplefilter(\"ignore\", category=RuntimeWarning)\n",
    "    n_rank2 = np.nanmean(nonzero_rank2, axis=0)[0, :]\n",
    "    r_rank2_r = np.nanmean(r2_sRRR_relaxed_rank2, axis=0)[0, :]\n",
    "    n_rank16 = np.nanmean(nonzero_rank16, axis=0)[0, :]\n",
    "    r_rank16_r = np.nanmean(r2_sRRR_relaxed_rank16, axis=0)[0, :]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "before's and after's"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.35837160167006094 +/- 0.025765047569708776\n"
     ]
    }
   ],
   "source": [
    "print(r_rank16_r[np.isclose(n_rank16, 25, atol=5)][0], '+/-',\n",
    "      np.nanstd(r2_sRRR_relaxed_rank16, axis=0)[0, :][np.isclose(n_rank16, 25, atol=5)][0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.3280056711845399 +/- 0.02555138380070412\n"
     ]
    }
   ],
   "source": [
    "print(r_rank2_r[np.isclose(n_rank2, 25, atol=5)][0], '+/-',\n",
    "      np.nanstd(r2_sRRR_relaxed_rank2, axis=0)[0, :][np.isclose(n_rank2, 25, atol=5)][0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.3490114152431488 +/- 0.026578726918978498\n"
     ]
    }
   ],
   "source": [
    "print(np.mean(r2_freeze_unfreeze_hist,axis=0)[2,0,-1], '+/-', np.std(r2_freeze_unfreeze_hist,axis=0)[2,0,-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.33916009962558746 +/- 0.02517795704387026\n"
     ]
    }
   ],
   "source": [
    "print(np.mean(r2_straight_regr_hist,axis=0)[0,0,-1], '+/-', np.std(r2_straight_regr_hist,axis=0)[0,0,-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1368x324 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# For the revision, with ion channel genes:\n",
    "linewidth = 2\n",
    "sns_styleset()\n",
    "\n",
    "# suppressing \"mean of empty slice\" warnings\n",
    "with warnings.catch_warnings():\n",
    "    warnings.simplefilter(\"ignore\", category=RuntimeWarning)\n",
    "    n_2 = np.nanmean(nonzero_rank2, axis=0)[0, :]\n",
    "    cr_2 = np.nanmean(r2_sRRR_relaxed_rank2, axis=0)[0, :]\n",
    "    n_16 = np.nanmean(nonzero_rank16, axis=0)[0, :]\n",
    "    cr_16= np.nanmean(r2_sRRR_relaxed_rank16, axis=0)[0, :]\n",
    "    \n",
    "    \n",
    "\n",
    "# suppressing \"mean of empty slice\" warnings\n",
    "with warnings.catch_warnings():\n",
    "    warnings.simplefilter(\"ignore\", category=RuntimeWarning)\n",
    "    n_rank2 = np.nanmean(nonzero_rank2, axis=0)[0, :]\n",
    "    r_rank2_r = np.nanmean(r2_sRRR_relaxed_rank2, axis=0)[0, :]\n",
    "    n_rank16 = np.nanmean(nonzero_rank16, axis=0)[0, :]\n",
    "    r_rank16_r = np.nanmean(r2_sRRR_relaxed_rank16, axis=0)[0, :]\n",
    "\n",
    "# All together in one plot for the paper\n",
    "fig = plt.figure(figsize=(19, 4.5))\n",
    "widths = [1, 1, 2]\n",
    "heights = [1]\n",
    "spec = fig.add_gridspec(ncols=3, nrows=1, width_ratios=widths,\n",
    "                          height_ratios=heights)\n",
    "ax1 = fig.add_subplot(spec[0, 0])\n",
    "ax1.plot(n_2, cr_2, '.-', c = np.array([0, 0, 0])/256, linewidth=2)\n",
    "ax1.plot(n_16[1:], cr_16[1:], '.-', c = np.array([0, 0, 0]) / 256, linewidth=2)\n",
    "ax1.set_ylim([0.25,0.4])\n",
    "ax1.set_xlabel('Number of selected genes', fontsize = 17)\n",
    "ax1.set_ylabel(r'Cross validated $R^2$', fontsize = 17)\n",
    "ax1.set_title('Sparse reduced-rank regression', fontsize = 20, y=1.02)\n",
    "ax1.tick_params(axis='both', which='major', labelsize=15)\n",
    "ax1.tick_params(axis='both', which='minor', labelsize=15)\n",
    "ax1.vlines(x=25, ymin=ax1.get_ylim()[0], ymax=ax1.get_ylim()[1], linestyles='dashed')\n",
    "ax1.annotate('sRRR, r=16', (50, np.max(cr_16)+0.0003), fontsize=15)\n",
    "ax1.annotate('sRRR, r=2', (50, np.max(cr_2)+0.0003), fontsize=15)\n",
    "\n",
    "\n",
    "ax2 = fig.add_subplot(spec[0, 1])\n",
    "ax2.plot(range(50), np.mean(pre_tr_hist_tr, axis=(0, 2))[2, :], \\\n",
    "         '--', c = 'k', linewidth=linewidth)\n",
    "ax2.plot(range(50), np.mean(pre_tr_hist, axis=(0, 2))[2, :], \\\n",
    "         c = 'k', linewidth=linewidth)\n",
    "ax2.set_title('Pretraining', fontsize = 19, y=1.02)\n",
    "ax2.set_xlabel('Epoch', fontsize = 17)\n",
    "ax2.set_ylabel('Cross entropy loss', fontsize = 17)\n",
    "ax2.tick_params(axis='both', which='major', labelsize=15)\n",
    "ax2.tick_params(axis='both', which='minor', labelsize=15)\n",
    "ax2.set_ylim([0, ax2.get_ylim()[1]])\n",
    "ax2.annotate('Training', (35, 1.65), fontsize=15)\n",
    "ax2.annotate('Test', (35, 2.36), fontsize=15)\n",
    "ax2.set_xticks(np.arange(0, 60, 10))\n",
    "\n",
    "epochs_used=200\n",
    "ax3 = fig.add_subplot(spec[0, 2])\n",
    "ax3.plot(range(epochs_used), np.mean(r2_freeze_unfreeze_hist_tr, axis=(0))[2,0,:], \\\n",
    "         '--', c = '#1b9e77', linewidth=linewidth)\n",
    "ax3.plot(range(epochs_used), np.mean(r2_freeze_unfreeze_hist, axis=(0))[2,0,:], \\\n",
    "         c = '#1b9e77', linewidth=linewidth, label='With pre-training')\n",
    "# ax3.plot(range(epochs_used), np.mean(r2_pretr_straight_regr_hist_tr, axis=(0))[0,0,:], \\\n",
    "#          '--', c = '#d95f02', linewidth=linewidth)\n",
    "# ax3.plot(range(epochs_used), np.mean(r2_pretr_straight_regr_hist, axis=(0))[0,0,:], \\\n",
    "#          c = '#d95f02', linewidth=linewidth, label='Pre-training + no freezing')\n",
    "ax3.plot(range(epochs_used), np.mean(r2_straight_regr_hist_tr, axis=(0))[0,0,:], \\\n",
    "         '--', c = '#d95f02', linewidth=linewidth)\n",
    "ax3.plot(range(epochs_used), np.mean(r2_straight_regr_hist, axis=(0))[0,0,:], \\\n",
    "         c = '#d95f02', linewidth=linewidth, label='No pre-training')\n",
    "ax3.hlines(r_rank16_r[np.isclose(n_rank16, 25, atol=5)], xmin = 0, xmax = epochs_used, \\\n",
    "            colors = np.array([0, 0, 0])/256, linewidth=linewidth)\n",
    "ax3.hlines(r_rank2_r[np.isclose(n_rank2, 25, atol=5)], xmin = 0, xmax = epochs_used, \\\n",
    "            colors = np.array([0, 0, 0])/256, linewidth=linewidth)\n",
    "ax3.set_ylim([0.25,0.4])\n",
    "ax3.set_xlim([0,200])\n",
    "ax3.set_xticks(np.arange(0, 225, 25))\n",
    "ax3.annotate('sRRR, r=16', (178, r_rank16_r[np.isclose(n_rank16, 25, atol=5)]+0.01), fontsize=15)\n",
    "ax3.annotate('sRRR, r=2', (178, r_rank2_r[np.isclose(n_rank2, 25, atol=5)]+0.003), fontsize=15)\n",
    "ax3.set_title('Bottleneck neural network', fontsize = 19, y=1.02)\n",
    "ax3.set_xlabel('Epoch', fontsize = 17)\n",
    "ax3.set_ylabel(r'$R^2$', fontsize = 17)\n",
    "ax3.tick_params(axis='both', which='major', labelsize=15)\n",
    "ax3.tick_params(axis='both', which='minor', labelsize=15)\n",
    "ax3.legend(loc='lower right', fontsize=15)\n",
    "ax3.vlines(x=50, ymin=ax3.get_ylim()[0], ymax=ax3.get_ylim()[1], linestyles='dashed')\n",
    "ax3.vlines(x=100, ymin=ax3.get_ylim()[0], ymax=ax3.get_ylim()[1], linestyles='dashed')\n",
    "\n",
    "plt.text(-0.25, 1.04, 'a', transform = ax1.transAxes, fontsize=25, fontweight='bold')\n",
    "plt.text(-0.11, 1.04, 'b', transform = ax2.transAxes, fontsize=25, fontweight='bold')\n",
    "plt.text(-0.13, 1.04, 'c', transform = ax3.transAxes, fontsize=25, fontweight='bold')\n",
    "sns.despine()\n",
    "\n",
    "# plt.savefig('figures/Lasso_training_curves_with_mouse_ion_channel_genes.pdf', bbox_inches='tight',\n",
    "#     pad_inches=0)\n",
    "# plt.savefig('figures/Lasso_training_curves_with_mouse_ion_channel_genes.png', bbox_inches='tight',\n",
    "#     pad_inches=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Extensions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How many nodes in the bottleneck do we need to really perform clearly above (and relatively soon above) the full rank linear model?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<module 'bottleneck_networks' from '/gpfs01/berens/user/ybernaerts/EphysAnalysis/data/ephys/sBNN/bottleneck_networks.py'>"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "importlib.reload(bottleneck_networks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "from bottleneck_networks import ClassificationPreTrain"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bottleneck with 2 nodes\n",
      "\n",
      "CVFOLD:  0\n",
      "[INFO] training network...\n",
      "655/655 [==============================] - 0s 201us/sample - loss: 55.4119 - categorical_crossentropy: 1.7637\n",
      "437/437 [==============================] - 0s 84us/sample - loss: 55.8082 - categorical_crossentropy: 2.1601\n",
      "\n",
      "CVFOLD:  1\n",
      "[INFO] training network...\n",
      "655/655 [==============================] - 0s 186us/sample - loss: 48.2314 - categorical_crossentropy: 1.6103\n",
      "437/437 [==============================] - 0s 83us/sample - loss: 48.6748 - categorical_crossentropy: 2.0537\n",
      "\n",
      "CVFOLD:  2\n",
      "[INFO] training network...\n",
      "655/655 [==============================] - 0s 195us/sample - loss: 48.4081 - categorical_crossentropy: 1.4603\n",
      "437/437 [==============================] - 0s 82us/sample - loss: 48.9267 - categorical_crossentropy: 1.9789\n",
      "\n",
      "CVFOLD:  3\n",
      "[INFO] training network...\n",
      "655/655 [==============================] - 0s 197us/sample - loss: 54.9541 - categorical_crossentropy: 1.7625\n",
      "437/437 [==============================] - 0s 91us/sample - loss: 55.2931 - categorical_crossentropy: 2.1016\n",
      "\n",
      "CVFOLD:  4\n",
      "[INFO] training network...\n",
      "655/655 [==============================] - 0s 190us/sample - loss: 47.9313 - categorical_crossentropy: 1.6738\n",
      "437/437 [==============================] - 0s 87us/sample - loss: 48.2927 - categorical_crossentropy: 2.0351\n",
      "\n",
      "CVFOLD:  5\n",
      "[INFO] training network...\n",
      "655/655 [==============================] - 0s 194us/sample - loss: 54.9445 - categorical_crossentropy: 1.7551\n",
      "437/437 [==============================] - 0s 91us/sample - loss: 55.3030 - categorical_crossentropy: 2.1135\n",
      "\n",
      "CVFOLD:  6\n",
      "[INFO] training network...\n",
      "655/655 [==============================] - 0s 198us/sample - loss: 55.0913 - categorical_crossentropy: 1.7652\n",
      "437/437 [==============================] - 0s 94us/sample - loss: 55.5487 - categorical_crossentropy: 2.2226\n",
      "\n",
      "CVFOLD:  7\n",
      "[INFO] training network...\n",
      "655/655 [==============================] - 0s 204us/sample - loss: 44.8284 - categorical_crossentropy: 1.5517\n",
      "437/437 [==============================] - 0s 89us/sample - loss: 45.3527 - categorical_crossentropy: 2.0761\n",
      "\n",
      "CVFOLD:  8\n",
      "[INFO] training network...\n",
      "655/655 [==============================] - 0s 190us/sample - loss: 48.2556 - categorical_crossentropy: 1.6212\n",
      "437/437 [==============================] - 0s 88us/sample - loss: 48.7155 - categorical_crossentropy: 2.0811\n",
      "\n",
      "CVFOLD:  9\n",
      "[INFO] training network...\n",
      "655/655 [==============================] - 0s 185us/sample - loss: 2.1244 - categorical_crossentropy: 1.4778\n",
      "437/437 [==============================] - 0s 91us/sample - loss: 2.7875 - categorical_crossentropy: 2.1410\n",
      "Bottleneck with 4 nodes\n",
      "\n",
      "CVFOLD:  0\n",
      "[INFO] training network...\n",
      "655/655 [==============================] - 0s 211us/sample - loss: 55.1463 - categorical_crossentropy: 1.4156\n",
      "437/437 [==============================] - 0s 91us/sample - loss: 55.6218 - categorical_crossentropy: 1.8911\n",
      "\n",
      "CVFOLD:  1\n",
      "[INFO] training network...\n",
      "655/655 [==============================] - 0s 189us/sample - loss: 55.1325 - categorical_crossentropy: 1.3862\n",
      "437/437 [==============================] - 0s 88us/sample - loss: 55.6342 - categorical_crossentropy: 1.8879\n",
      "\n",
      "CVFOLD:  2\n",
      "[INFO] training network...\n",
      "655/655 [==============================] - 0s 186us/sample - loss: 52.1214 - categorical_crossentropy: 1.2930\n",
      "437/437 [==============================] - 0s 92us/sample - loss: 52.6955 - categorical_crossentropy: 1.8671\n",
      "\n",
      "CVFOLD:  3\n",
      "[INFO] training network...\n",
      "655/655 [==============================] - 0s 209us/sample - loss: 55.2445 - categorical_crossentropy: 1.4362\n",
      "437/437 [==============================] - 0s 93us/sample - loss: 55.7900 - categorical_crossentropy: 1.9817\n",
      "\n",
      "CVFOLD:  4\n",
      "[INFO] training network...\n",
      "655/655 [==============================] - 0s 197us/sample - loss: 55.2091 - categorical_crossentropy: 1.3547\n",
      "437/437 [==============================] - 0s 99us/sample - loss: 55.7478 - categorical_crossentropy: 1.8934\n",
      "\n",
      "CVFOLD:  5\n",
      "[INFO] training network...\n",
      "655/655 [==============================] - 0s 196us/sample - loss: 52.0018 - categorical_crossentropy: 1.3450\n",
      "437/437 [==============================] - 0s 87us/sample - loss: 52.5989 - categorical_crossentropy: 1.9421\n",
      "\n",
      "CVFOLD:  6\n",
      "[INFO] training network...\n",
      "655/655 [==============================] - 0s 194us/sample - loss: 48.6819 - categorical_crossentropy: 1.2080\n",
      "437/437 [==============================] - 0s 94us/sample - loss: 49.3798 - categorical_crossentropy: 1.9058\n",
      "\n",
      "CVFOLD:  7\n",
      "[INFO] training network...\n",
      "655/655 [==============================] - 0s 189us/sample - loss: 51.7470 - categorical_crossentropy: 1.3080\n",
      "437/437 [==============================] - 0s 88us/sample - loss: 52.4490 - categorical_crossentropy: 2.0100\n",
      "\n",
      "CVFOLD:  8\n",
      "[INFO] training network...\n",
      "655/655 [==============================] - 0s 240us/sample - loss: 55.2262 - categorical_crossentropy: 1.4300\n",
      "437/437 [==============================] - 0s 107us/sample - loss: 55.6850 - categorical_crossentropy: 1.8888\n",
      "\n",
      "CVFOLD:  9\n",
      "[INFO] training network...\n",
      "655/655 [==============================] - 0s 204us/sample - loss: 55.3545 - categorical_crossentropy: 1.4004\n",
      "437/437 [==============================] - 0s 100us/sample - loss: 56.0590 - categorical_crossentropy: 2.1049\n",
      "Bottleneck with 6 nodes\n",
      "\n",
      "CVFOLD:  0\n",
      "[INFO] training network...\n",
      "655/655 [==============================] - 0s 218us/sample - loss: 55.8366 - categorical_crossentropy: 1.2569\n",
      "437/437 [==============================] - 0s 94us/sample - loss: 56.5091 - categorical_crossentropy: 1.9293\n",
      "\n",
      "CVFOLD:  1\n",
      "[INFO] training network...\n",
      "655/655 [==============================] - 0s 218us/sample - loss: 55.4811 - categorical_crossentropy: 1.2833\n",
      "437/437 [==============================] - 0s 93us/sample - loss: 56.0830 - categorical_crossentropy: 1.8853\n",
      "\n",
      "CVFOLD:  2\n",
      "[INFO] training network...\n",
      "655/655 [==============================] - 0s 264us/sample - loss: 52.6407 - categorical_crossentropy: 1.1392\n",
      "437/437 [==============================] - 0s 94us/sample - loss: 53.3792 - categorical_crossentropy: 1.8777\n",
      "\n",
      "CVFOLD:  3\n",
      "[INFO] training network...\n",
      "655/655 [==============================] - 0s 201us/sample - loss: 55.8897 - categorical_crossentropy: 1.2592\n",
      "437/437 [==============================] - 0s 92us/sample - loss: 56.5516 - categorical_crossentropy: 1.9210\n",
      "\n",
      "CVFOLD:  4\n",
      "[INFO] training network...\n",
      "655/655 [==============================] - 0s 204us/sample - loss: 55.4784 - categorical_crossentropy: 1.3029\n",
      "437/437 [==============================] - 0s 92us/sample - loss: 56.0578 - categorical_crossentropy: 1.8823\n",
      "\n",
      "CVFOLD:  5\n",
      "[INFO] training network...\n",
      "655/655 [==============================] - 0s 211us/sample - loss: 52.5329 - categorical_crossentropy: 1.1650\n",
      "437/437 [==============================] - 0s 98us/sample - loss: 53.3122 - categorical_crossentropy: 1.9443\n",
      "\n",
      "CVFOLD:  6\n",
      "[INFO] training network...\n",
      "655/655 [==============================] - 0s 195us/sample - loss: 52.4399 - categorical_crossentropy: 1.1580\n",
      "437/437 [==============================] - 0s 94us/sample - loss: 53.1854 - categorical_crossentropy: 1.9036\n",
      "\n",
      "CVFOLD:  7\n",
      "[INFO] training network...\n",
      "655/655 [==============================] - 0s 200us/sample - loss: 52.0401 - categorical_crossentropy: 1.1984\n",
      "437/437 [==============================] - 0s 83us/sample - loss: 52.7621 - categorical_crossentropy: 1.9204\n",
      "\n",
      "CVFOLD:  8\n",
      "[INFO] training network...\n",
      "655/655 [==============================] - 0s 193us/sample - loss: 55.5457 - categorical_crossentropy: 1.3065\n",
      "437/437 [==============================] - 0s 91us/sample - loss: 56.1306 - categorical_crossentropy: 1.8915\n",
      "\n",
      "CVFOLD:  9\n",
      "[INFO] training network...\n",
      "655/655 [==============================] - 0s 194us/sample - loss: 52.6862 - categorical_crossentropy: 1.0562\n",
      "437/437 [==============================] - 0s 92us/sample - loss: 53.5295 - categorical_crossentropy: 1.8994\n",
      "Bottleneck with 8 nodes\n",
      "\n",
      "CVFOLD:  0\n",
      "[INFO] training network...\n",
      "655/655 [==============================] - 0s 261us/sample - loss: 52.9488 - categorical_crossentropy: 1.0813\n",
      "437/437 [==============================] - 0s 88us/sample - loss: 53.8297 - categorical_crossentropy: 1.9622\n",
      "\n",
      "CVFOLD:  1\n",
      "[INFO] training network...\n",
      "655/655 [==============================] - 0s 205us/sample - loss: 55.8577 - categorical_crossentropy: 1.2539\n",
      "437/437 [==============================] - 0s 97us/sample - loss: 56.5162 - categorical_crossentropy: 1.9123\n",
      "\n",
      "CVFOLD:  2\n",
      "[INFO] training network...\n",
      "655/655 [==============================] - 0s 207us/sample - loss: 55.8588 - categorical_crossentropy: 1.2338\n",
      "437/437 [==============================] - 0s 98us/sample - loss: 56.5722 - categorical_crossentropy: 1.9472\n",
      "\n",
      "CVFOLD:  3\n",
      "[INFO] training network...\n",
      "655/655 [==============================] - 0s 191us/sample - loss: 52.6194 - categorical_crossentropy: 1.0931\n",
      "437/437 [==============================] - 0s 98us/sample - loss: 53.4165 - categorical_crossentropy: 1.8901\n",
      "\n",
      "CVFOLD:  4\n",
      "[INFO] training network...\n",
      "655/655 [==============================] - 0s 224us/sample - loss: 55.9441 - categorical_crossentropy: 1.2632\n",
      "437/437 [==============================] - 0s 94us/sample - loss: 56.6229 - categorical_crossentropy: 1.9420\n",
      "\n",
      "CVFOLD:  5\n",
      "[INFO] training network...\n",
      "655/655 [==============================] - 0s 188us/sample - loss: 56.3906 - categorical_crossentropy: 1.1557\n",
      "437/437 [==============================] - 0s 85us/sample - loss: 57.0775 - categorical_crossentropy: 1.8427\n",
      "\n",
      "CVFOLD:  6\n",
      "[INFO] training network...\n",
      "655/655 [==============================] - 0s 197us/sample - loss: 52.6805 - categorical_crossentropy: 1.1113\n",
      "437/437 [==============================] - 0s 84us/sample - loss: 53.4330 - categorical_crossentropy: 1.8638\n",
      "\n",
      "CVFOLD:  7\n",
      "[INFO] training network...\n",
      "655/655 [==============================] - 0s 199us/sample - loss: 55.8537 - categorical_crossentropy: 1.2911\n",
      "437/437 [==============================] - 0s 96us/sample - loss: 56.5173 - categorical_crossentropy: 1.9548\n",
      "\n",
      "CVFOLD:  8\n",
      "[INFO] training network...\n",
      "655/655 [==============================] - 0s 192us/sample - loss: 52.8761 - categorical_crossentropy: 1.0805\n",
      "437/437 [==============================] - 0s 84us/sample - loss: 53.6829 - categorical_crossentropy: 1.8873\n",
      "\n",
      "CVFOLD:  9\n",
      "[INFO] training network...\n",
      "655/655 [==============================] - 0s 194us/sample - loss: 49.4251 - categorical_crossentropy: 1.0839\n",
      "437/437 [==============================] - 0s 84us/sample - loss: 50.1944 - categorical_crossentropy: 1.8533\n",
      "Bottleneck with 10 nodes\n",
      "\n",
      "CVFOLD:  0\n",
      "[INFO] training network...\n",
      "655/655 [==============================] - 0s 200us/sample - loss: 59.4730 - categorical_crossentropy: 1.2990\n",
      "437/437 [==============================] - 0s 92us/sample - loss: 60.1367 - categorical_crossentropy: 1.9626\n",
      "\n",
      "CVFOLD:  1\n",
      "[INFO] training network...\n",
      "655/655 [==============================] - 0s 194us/sample - loss: 52.5257 - categorical_crossentropy: 1.0145\n",
      "437/437 [==============================] - 0s 96us/sample - loss: 53.4483 - categorical_crossentropy: 1.9372\n",
      "\n",
      "CVFOLD:  2\n",
      "[INFO] training network...\n",
      "655/655 [==============================] - 0s 191us/sample - loss: 49.4724 - categorical_crossentropy: 0.9493\n",
      "437/437 [==============================] - 0s 86us/sample - loss: 50.3929 - categorical_crossentropy: 1.8698\n",
      "\n",
      "CVFOLD:  3\n",
      "[INFO] training network...\n",
      "655/655 [==============================] - 0s 192us/sample - loss: 56.1256 - categorical_crossentropy: 1.1870\n",
      "437/437 [==============================] - 0s 89us/sample - loss: 56.8543 - categorical_crossentropy: 1.9158\n",
      "\n",
      "CVFOLD:  4\n",
      "[INFO] training network...\n",
      "655/655 [==============================] - 0s 194us/sample - loss: 59.4855 - categorical_crossentropy: 1.3589\n",
      "437/437 [==============================] - 0s 93us/sample - loss: 60.0183 - categorical_crossentropy: 1.8917\n",
      "\n",
      "CVFOLD:  5\n",
      "[INFO] training network...\n",
      "655/655 [==============================] - 0s 194us/sample - loss: 56.4221 - categorical_crossentropy: 1.1952\n",
      "437/437 [==============================] - 0s 86us/sample - loss: 57.1311 - categorical_crossentropy: 1.9042\n",
      "\n",
      "CVFOLD:  6\n",
      "[INFO] training network...\n",
      "655/655 [==============================] - 0s 191us/sample - loss: 56.0703 - categorical_crossentropy: 1.2020\n",
      "437/437 [==============================] - 0s 93us/sample - loss: 56.7437 - categorical_crossentropy: 1.8754\n",
      "\n",
      "CVFOLD:  7\n",
      "[INFO] training network...\n",
      "655/655 [==============================] - 0s 222us/sample - loss: 56.5335 - categorical_crossentropy: 1.0828\n",
      "437/437 [==============================] - 0s 98us/sample - loss: 57.4306 - categorical_crossentropy: 1.9799\n",
      "\n",
      "CVFOLD:  8\n",
      "[INFO] training network...\n",
      "655/655 [==============================] - 0s 214us/sample - loss: 49.7945 - categorical_crossentropy: 0.9095\n",
      "437/437 [==============================] - 0s 92us/sample - loss: 50.7298 - categorical_crossentropy: 1.8447\n",
      "\n",
      "CVFOLD:  9\n",
      "[INFO] training network...\n",
      "655/655 [==============================] - 0s 194us/sample - loss: 56.2597 - categorical_crossentropy: 1.2291\n",
      "437/437 [==============================] - 0s 97us/sample - loss: 56.9155 - categorical_crossentropy: 1.8849\n",
      "Time: 0.0h  8m 43s\n"
     ]
    }
   ],
   "source": [
    "# What about using different amount of nodes in the bottleneck?\n",
    "l2_params = np.logspace(-10, -10, num=1)\n",
    "l1_params = np.array([1e-1])\n",
    "\n",
    "act = 'elu'\n",
    "folds = 10\n",
    "seed = 42\n",
    "lr=0.0001\n",
    "epochs=50\n",
    "bs=32\n",
    "patience=epochs\n",
    "\n",
    "\n",
    "t = time.time()\n",
    "np.random.seed(seed)\n",
    "n = genes.shape[0]\n",
    "ind = np.random.permutation(n)\n",
    "X = genes[ind,:]\n",
    "Y = ephys[ind,:]\n",
    "clusters_ = clusters[ind]\n",
    "ind_pre_train = ind_pre_training_clusters[ind]\n",
    "\n",
    "CE_loss = np.zeros((len(range(2,12,2)), folds, l1_params.shape[0], l2_params.shape[0]))\n",
    "CE_loss_tr = np.zeros((len(range(2,12,2)), folds, l1_params.shape[0], l2_params.shape[0]))\n",
    "pre_tr_hist = np.zeros((len(range(2,12,2)), folds, l1_params.shape[0], l2_params.shape[0], epochs))\n",
    "pre_tr_hist_tr = np.zeros((len(range(2,12,2)), folds, l1_params.shape[0], l2_params.shape[0], epochs))\n",
    "\n",
    "\n",
    "for u,f in enumerate(range(2,12,2)):\n",
    "    nodes_list=[512, 128, f, 128, 512]\n",
    "    print('Bottleneck with {} nodes'.format(f))\n",
    "    # CV folds\n",
    "    for cvfold in range(folds):\n",
    "        print('\\nCVFOLD: ', cvfold)\n",
    "        indtest  = np.arange(cvfold*int(n/folds), (cvfold+1)*int(n/folds))\n",
    "        indtrain = np.setdiff1d(np.arange(n), indtest)\n",
    "        x_train = np.copy(X[indtrain,:])\n",
    "        clusters_train = np.copy(clusters_[indtrain])\n",
    "        y_train = np.copy(Y[indtrain,:])\n",
    "        x_test = np.copy(X[indtest,:])\n",
    "        clusters_test = np.copy(clusters_[indtest])\n",
    "        y_test = np.copy(Y[indtest,:])\n",
    "\n",
    "        # Mean centering (like sRRR)\n",
    "        X_mean = np.mean(x_train, axis=0)\n",
    "        x_train -= X_mean\n",
    "        x_test -= X_mean\n",
    "        Y_mean = np.mean(y_train, axis=0)\n",
    "        y_train -= Y_mean\n",
    "        y_test -= Y_mean\n",
    "\n",
    "        # In our training set we now look for a 'pretraining' training and test data set that we can use\n",
    "        # for pretraing a classification network, i.e. picking the best model will be dones with a seperate val set in our\n",
    "        # training set for regression.\n",
    "\n",
    "        x_train_pre_tr = x_train[ind_pre_train[indtrain], :]\n",
    "        clusters_train_pre_tr = clusters_train[ind_pre_train[indtrain]]\n",
    "\n",
    "        pre_train_size = 0.6\n",
    "        train_cnt = round(x_train_pre_tr.shape[0]*pre_train_size)\n",
    "        x_train_pre_tr_ = x_train_pre_tr[:train_cnt, :]\n",
    "        x_test_pre_tr_ = x_train_pre_tr[train_cnt:, :]\n",
    "        clusters_train_pre_tr_ = clusters_train_pre_tr[:train_cnt]\n",
    "        clusters_test_pre_tr_ = clusters_train_pre_tr[train_cnt:]\n",
    "\n",
    "        for i, l2 in enumerate(l2_params):\n",
    "            #print('Ridge penalty: ', l2)\n",
    "            for j, l1 in enumerate(l1_params):\n",
    "                #print('Lasso penalty: ', l1)\n",
    "\n",
    "\n",
    "                input_dim = x_train.shape[1]\n",
    "                output_dim = to_categorical(clusters_train_pre_tr).shape[1]\n",
    "                BN_Classification = ClassificationPreTrain(l1=l1, l2=l2, lr=lr, act=act, input_dim=input_dim, \\\n",
    "                                                           output_dim=output_dim, nodes_list=nodes_list)\n",
    "                CE_train, CE_test, train_hist, test_hist = BN_Classification.train(x_train=x_train_pre_tr_, \\\n",
    "                                                                                   cluster_train=clusters_train_pre_tr_, \\\n",
    "                                                                                   x_test=x_test_pre_tr_, \\\n",
    "                                                                                   cluster_test=clusters_test_pre_tr_, \\\n",
    "                                                                                   epochs=epochs, bs=bs, patience=patience, \\\n",
    "                                                                                   cvfold_id=cvfold, l1_id=j, l2_id=i, \\\n",
    "                                                                                   verbose=0, \\\n",
    "                                                                                   output_name='nodes_list_{}'.format(u))\n",
    "                CE_loss[u, cvfold, j, i] = CE_test\n",
    "                CE_loss_tr[u, cvfold, j, i] = CE_train\n",
    "                pre_tr_hist[u, cvfold, j, i] = test_hist\n",
    "                pre_tr_hist_tr[u, cvfold, j, i] = train_hist\n",
    "                #print('Test CE loss (pre-trainin): ', CE_loss[cvfold, j, i])\n",
    "            \n",
    "t = time.time() - t\n",
    "m,s = divmod(t, 60)\n",
    "h,m = divmod(m, 60)\n",
    "print('Time: {}h {:2.0f}m {:2.0f}s'.format(h,m,s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [],
   "source": [
    "from bottleneck_networks import FreezeUnfreeze"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bottleneck with 2 nodes\n",
      "\n",
      "CVFOLD:  0\n",
      "[INFO] training network...\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Erbb4' 'Mical2' 'Nell2' 'Phactr1' 'Kcnc2' 'Gabra1' 'Atp1a3' 'Gm11549'\n",
      " 'Plch2' 'Cplx1' 'Unc13c' 'Gabrd' 'Kcnip2' 'Enpp2' 'Grm7' 'Gm49948'\n",
      " 'Elfn1' 'Htr3a' 'Galnt14' 'Ndn' 'Lamp5' 'Gad1' 'Tac2' 'Pvalb' 'Sst']\n",
      "[INFO] training network...\n",
      "Train R^2 before unfreezing:  0.33830320835113525\n",
      "Test R^2 before unfreezing:  0.33475446701049805\n",
      "Train R^2 after unfreezing:  0.4302493929862976\n",
      "Test R^2 after unfreezing:  0.4383460283279419\n",
      "Train R^2 after unfreezing and pruning:  0.4181750416755676\n",
      "Test R^2 after unfreezing and pruning:  0.4496825337409973\n",
      "\n",
      "CVFOLD:  1\n",
      "[INFO] training network...\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Slc5a7' 'Nrip3' 'Elfn1' 'Gpm6b' 'Elmo1' 'Cdc42se2' 'Cplx1' 'Pfkp'\n",
      " 'Grip1' 'Sparcl1' 'Galnt14' 'Col24a1' 'Pcp4l1' 'Enpp2' 'Tac2' 'Plch2'\n",
      " 'Erbb4' 'Atp1a3' 'Ndn' 'Gm49948' 'Lamp5' 'Gad1' 'Sst' 'Pvalb' 'Vip']\n",
      "[INFO] training network...\n",
      "Train R^2 before unfreezing:  0.39688485860824585\n",
      "Test R^2 before unfreezing:  0.35895901918411255\n",
      "Train R^2 after unfreezing:  0.42294520139694214\n",
      "Test R^2 after unfreezing:  0.4182964563369751\n",
      "Train R^2 after unfreezing and pruning:  0.4203861951828003\n",
      "Test R^2 after unfreezing and pruning:  0.39681845903396606\n",
      "\n",
      "CVFOLD:  2\n",
      "[INFO] training network...\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Gm11549' 'Cacna1e' 'Phactr1' 'Kcnc2' 'Plch2' 'Arpp19' 'Kcnip2' 'Enpp2'\n",
      " 'Atp1a3' 'Cplx1' 'Htr3a' 'Galnt14' 'Ptk2b' 'Gm49948' 'Unc13c' 'Pcp4l1'\n",
      " 'Elfn1' 'Gad1' 'Sparcl1' 'Tac2' 'Lamp5' 'Ndn' 'Sst' 'Pvalb' 'Vip']\n",
      "[INFO] training network...\n",
      "Train R^2 before unfreezing:  0.39260631799697876\n",
      "Test R^2 before unfreezing:  0.3531184196472168\n",
      "Train R^2 after unfreezing:  0.44052737951278687\n",
      "Test R^2 after unfreezing:  0.39485108852386475\n",
      "Train R^2 after unfreezing and pruning:  0.43114393949508667\n",
      "Test R^2 after unfreezing and pruning:  0.38378679752349854\n",
      "\n",
      "CVFOLD:  3\n",
      "[INFO] training network...\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Gad2' 'Enpp2' 'Cnr1' 'Mas1' 'Cacna2d3' 'Pde1a' 'Phactr1' 'Gabra1'\n",
      " 'Cacna1e' 'Galnt14' 'Rit2' 'Zfp873' 'Satb1' 'Adcyap1' 'Mybpc1' 'Grip1'\n",
      " 'Ndn' 'Htr3a' 'Erbb4' 'Plch2' 'Lamp5' 'Sst' 'Tafa1' 'Pvalb' 'Gad1']\n",
      "[INFO] training network...\n",
      "Train R^2 before unfreezing:  0.3804553747177124\n",
      "Test R^2 before unfreezing:  0.3265131115913391\n",
      "Train R^2 after unfreezing:  0.4241916537284851\n",
      "Test R^2 after unfreezing:  0.3756125569343567\n",
      "Train R^2 after unfreezing and pruning:  0.41903239488601685\n",
      "Test R^2 after unfreezing and pruning:  0.3755820393562317\n",
      "\n",
      "CVFOLD:  4\n",
      "[INFO] training network...\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Kcnab1' 'Kcnip2' 'Sema3c' 'Enpp2' 'Col24a1' 'Satb1' 'Phactr1' 'Gm49948'\n",
      " 'Elfn1' 'Grm7' 'Unc13c' 'Galnt14' 'Nell2' 'Sparcl1' 'Tac2' 'Plch2'\n",
      " 'Htr3a' 'Synpr' 'Ndn' 'Ndst3' 'Lamp5' 'Sst' 'Gad1' 'Pvalb' 'Vip']\n",
      "[INFO] training network...\n",
      "Train R^2 before unfreezing:  0.4054067134857178\n",
      "Test R^2 before unfreezing:  0.3661343455314636\n",
      "Train R^2 after unfreezing:  0.4414098858833313\n",
      "Test R^2 after unfreezing:  0.3785017728805542\n",
      "Train R^2 after unfreezing and pruning:  0.4290449023246765\n",
      "Test R^2 after unfreezing and pruning:  0.38072025775909424\n",
      "\n",
      "CVFOLD:  5\n",
      "[INFO] training network...\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Galnt14' 'Npy1r' 'Unc13c' 'Rab3b' 'Reln' 'Cbln2' 'Tac2' 'Elmo1' 'Kcnip2'\n",
      " 'Phactr1' 'Enpp2' 'Cacna1e' 'Htr3a' 'Chrnb3' 'Nell1' 'Mybpc1' 'Slc6a1'\n",
      " 'Ndn' 'Erbb4' 'Plch2' 'Tafa1' 'Lamp5' 'Sst' 'Gad1' 'Pvalb']\n",
      "[INFO] training network...\n",
      "Train R^2 before unfreezing:  0.38144975900650024\n",
      "Test R^2 before unfreezing:  0.31532806158065796\n",
      "Train R^2 after unfreezing:  0.4294703006744385\n",
      "Test R^2 after unfreezing:  0.37394464015960693\n",
      "Train R^2 after unfreezing and pruning:  0.4253888726234436\n",
      "Test R^2 after unfreezing and pruning:  0.3689362406730652\n",
      "\n",
      "CVFOLD:  6\n",
      "[INFO] training network...\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Caln1' 'Cbln2' 'Cacna2d3' 'Ntm' 'Npy1r' 'Grip1' 'Elmo1' 'Npy' 'Tac1'\n",
      " 'Kcnab1' 'Sparcl1' 'Cplx1' 'Atp1a3' 'Synpr' 'Ptk2b' 'Adarb2' 'Tafa1'\n",
      " 'Fxyd6' 'Kit' 'Coro6' 'Slc6a1' 'Erbb4' 'Vip' 'Pvalb' 'Gad1']\n",
      "[INFO] training network...\n",
      "Train R^2 before unfreezing:  0.3662559390068054\n",
      "Test R^2 before unfreezing:  0.34128981828689575\n",
      "Train R^2 after unfreezing:  0.4236394762992859\n",
      "Test R^2 after unfreezing:  0.39210373163223267\n",
      "Train R^2 after unfreezing and pruning:  0.42557066679000854\n",
      "Test R^2 after unfreezing and pruning:  0.3951880931854248\n",
      "\n",
      "CVFOLD:  7\n",
      "[INFO] training network...\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Pcp4l1' 'Kcnip2' 'Phactr1' 'Gabrd' 'Afap1' 'Satb1' 'Mical2' 'Slc6a1'\n",
      " 'Npy1r' 'Atp1a3' 'Nell2' 'Htr3a' 'Cplx1' 'Plch2' 'Ndst3' 'Galnt14' 'Tac2'\n",
      " 'Gad1' 'Sparcl1' 'Gm49948' 'Ndn' 'Lamp5' 'Sst' 'Pvalb' 'Vip']\n",
      "[INFO] training network...\n",
      "Train R^2 before unfreezing:  0.37272173166275024\n",
      "Test R^2 before unfreezing:  0.38088470697402954\n",
      "Train R^2 after unfreezing:  0.4402594566345215\n",
      "Test R^2 after unfreezing:  0.43877410888671875\n",
      "Train R^2 after unfreezing and pruning:  0.42279261350631714\n",
      "Test R^2 after unfreezing and pruning:  0.4141160249710083\n",
      "\n",
      "CVFOLD:  8\n",
      "[INFO] training network...\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Galnt14' 'Bcl2l11' 'Pcdh7' 'Atp1b2' 'Cplx1' 'Htr3a' 'Grip1' 'Satb1'\n",
      " 'Cacna1e' 'Cbln2' 'Gabra1' 'Kcnab1' 'Adcyap1' 'Mybpc1' 'Thsd7a' 'Plch2'\n",
      " 'Atp1a3' 'Ptk2b' 'Reln' 'Ndn' 'Lamp5' 'Erbb4' 'Tafa1' 'Pvalb' 'Gad1']\n",
      "[INFO] training network...\n",
      "Train R^2 before unfreezing:  0.3713184595108032\n",
      "Test R^2 before unfreezing:  0.29688572883605957\n",
      "Train R^2 after unfreezing:  0.422140896320343\n",
      "Test R^2 after unfreezing:  0.37861037254333496\n",
      "Train R^2 after unfreezing and pruning:  0.41251134872436523\n",
      "Test R^2 after unfreezing and pruning:  0.3580824136734009\n",
      "\n",
      "CVFOLD:  9\n",
      "[INFO] training network...\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Mas1' 'Enpp2' 'Elfn1' 'Ptk2b' 'Satb1' 'Grip1' 'Grm7' 'Dlx6os1' 'Cacna1e'\n",
      " 'Sema3c' 'Unc13c' 'Cplx1' 'Erbb4' 'Atp1a3' 'Htr3a' 'Tac2' 'Ndst3' 'Synpr'\n",
      " 'Lamp5' 'Ndn' 'Coro6' 'Gad1' 'Sst' 'Pvalb' 'Vip']\n",
      "[INFO] training network...\n",
      "Train R^2 before unfreezing:  0.39657121896743774\n",
      "Test R^2 before unfreezing:  0.35908085107803345\n",
      "Train R^2 after unfreezing:  0.4349355101585388\n",
      "Test R^2 after unfreezing:  0.41218888759613037\n",
      "Train R^2 after unfreezing and pruning:  0.4258487820625305\n",
      "Test R^2 after unfreezing and pruning:  0.3858872652053833\n",
      "Bottleneck with 4 nodes\n",
      "\n",
      "CVFOLD:  0\n",
      "[INFO] training network...\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Mical2' 'Ndst3' 'Arhgap32' 'Gabra1' 'Tafa1' 'Syt1' 'Thsd7a' 'Enpp2'\n",
      " 'Kcnab3' 'Plch2' 'Elmo1' 'Galnt14' 'Pde1a' 'Htr3a' 'Fxyd6' 'Gm49948'\n",
      " 'Ndn' 'Cplx1' 'Lamp5' 'Gad1' 'Tac2' 'Erbb4' 'Sst' 'Pvalb' 'Vip']\n",
      "[INFO] training network...\n",
      "Train R^2 before unfreezing:  0.45504993200302124\n",
      "Test R^2 before unfreezing:  0.4081570506095886\n",
      "Train R^2 after unfreezing:  0.48931223154067993\n",
      "Test R^2 after unfreezing:  0.4636467695236206\n",
      "Train R^2 after unfreezing and pruning:  0.4678577184677124\n",
      "Test R^2 after unfreezing and pruning:  0.4461802840232849\n",
      "\n",
      "CVFOLD:  1\n",
      "[INFO] training network...\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Atp1a3' 'Ak5' 'Unc13c' 'Coro6' 'Kcnip2' 'Kcnv1' 'Elfn1' 'Ndst3' 'Tafa1'\n",
      " 'Plch2' 'Pde1a' 'Htr3a' 'Phactr1' 'Enpp2' 'Cplx1' 'Fxyd6' 'Ndn' 'Lamp5'\n",
      " 'Erbb4' 'Gm49948' 'Tac2' 'Gad1' 'Sst' 'Pvalb' 'Vip']\n",
      "[INFO] training network...\n",
      "Train R^2 before unfreezing:  0.4489845633506775\n",
      "Test R^2 before unfreezing:  0.3485860824584961\n",
      "Train R^2 after unfreezing:  0.490619421005249\n",
      "Test R^2 after unfreezing:  0.44636404514312744\n",
      "Train R^2 after unfreezing and pruning:  0.46183186769485474\n",
      "Test R^2 after unfreezing and pruning:  0.43066179752349854\n",
      "\n",
      "CVFOLD:  2\n",
      "[INFO] training network...\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Sparcl1' 'Phactr1' 'Mas1' 'Kcnc2' 'Gm11549' 'Gm49948' 'Lingo2' 'Atp1a3'\n",
      " 'Elfn1' 'Gabra1' 'Unc13c' 'Plch2' 'Htr3a' 'Cplx1' 'Enpp2' 'Galnt14'\n",
      " 'Fxyd6' 'Tac2' 'Ndn' 'Lamp5' 'Erbb4' 'Sst' 'Gad1' 'Pvalb' 'Vip']\n",
      "[INFO] training network...\n",
      "Train R^2 before unfreezing:  0.4606274366378784\n",
      "Test R^2 before unfreezing:  0.34698760509490967\n",
      "Train R^2 after unfreezing:  0.4891992211341858\n",
      "Test R^2 after unfreezing:  0.41572123765945435\n",
      "Train R^2 after unfreezing and pruning:  0.45432722568511963\n",
      "Test R^2 after unfreezing and pruning:  0.40093719959259033\n",
      "\n",
      "CVFOLD:  3\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] training network...\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Syt1' 'Plch2' 'Phactr1' 'Sparcl1' 'Cacna1e' 'Gabra1' 'Pdyn' 'Coro6'\n",
      " 'Elmo1' 'Tafa1' 'Galnt14' 'Ndst3' 'Satb1' 'Tac2' 'Thsd7a' 'Cplx1' 'Fxyd6'\n",
      " 'Erbb4' 'Ndn' 'Lamp5' 'Htr3a' 'Sst' 'Pvalb' 'Gad1' 'Vip']\n",
      "[INFO] training network...\n",
      "Train R^2 before unfreezing:  0.4395413398742676\n",
      "Test R^2 before unfreezing:  0.3468536138534546\n",
      "Train R^2 after unfreezing:  0.4916002154350281\n",
      "Test R^2 after unfreezing:  0.44237321615219116\n",
      "Train R^2 after unfreezing and pruning:  0.4629012942314148\n",
      "Test R^2 after unfreezing and pruning:  0.436553955078125\n",
      "\n",
      "CVFOLD:  4\n",
      "[INFO] training network...\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Gabra1' 'Afap1' 'Fxyd6' 'Tac2' 'Pamr1' 'Plch2' 'Cplx3' 'Coro6' 'Enpp2'\n",
      " 'Phactr1' 'Tafa1' 'Gm49948' 'Cbln2' 'Lamp5' 'Atp1a3' 'Ndst3' 'Cplx1'\n",
      " 'Ndn' 'Galnt14' 'Gad1' 'Htr3a' 'Erbb4' 'Sst' 'Vip' 'Pvalb']\n",
      "[INFO] training network...\n",
      "Train R^2 before unfreezing:  0.4619518518447876\n",
      "Test R^2 before unfreezing:  0.3825035095214844\n",
      "Train R^2 after unfreezing:  0.49391859769821167\n",
      "Test R^2 after unfreezing:  0.43460679054260254\n",
      "Train R^2 after unfreezing and pruning:  0.4653380513191223\n",
      "Test R^2 after unfreezing and pruning:  0.4374505281448364\n",
      "\n",
      "CVFOLD:  5\n",
      "[INFO] training network...\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Unc13c' 'Thsd7a' 'Pdyn' 'Coro6' 'Phactr1' 'Chrnb3' 'Elmo1' 'Atp1a3'\n",
      " 'Slc6a1' 'Cplx1' 'Npy' 'Plch2' 'Gm49948' 'Galnt14' 'Ndst3' 'Fxyd6'\n",
      " 'Erbb4' 'Ndn' 'Htr3a' 'Tac2' 'Lamp5' 'Sst' 'Gad1' 'Pvalb' 'Vip']\n",
      "[INFO] training network...\n",
      "Train R^2 before unfreezing:  0.41735249757766724\n",
      "Test R^2 before unfreezing:  0.32488131523132324\n",
      "Train R^2 after unfreezing:  0.4836316704750061\n",
      "Test R^2 after unfreezing:  0.41656434535980225\n",
      "Train R^2 after unfreezing and pruning:  0.45754969120025635\n",
      "Test R^2 after unfreezing and pruning:  0.395940363407135\n",
      "\n",
      "CVFOLD:  6\n",
      "[INFO] training network...\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Elfn1' 'Tafa1' 'Cdh13' 'Pcp4l1' 'Gabra1' 'Pcdh7' 'Galnt14' 'Sema5a'\n",
      " 'Plch2' 'Elmo1' 'Lingo2' 'Cplx1' 'Enpp2' 'Gm49948' 'Fxyd6' 'Htr3a' 'Tac2'\n",
      " 'Ndn' 'Atp1a3' 'Gad1' 'Lamp5' 'Erbb4' 'Sst' 'Pvalb' 'Vip']\n",
      "[INFO] training network...\n",
      "Train R^2 before unfreezing:  0.42840999364852905\n",
      "Test R^2 before unfreezing:  0.3583688735961914\n",
      "Train R^2 after unfreezing:  0.5004495084285736\n",
      "Test R^2 after unfreezing:  0.439289927482605\n",
      "Train R^2 after unfreezing and pruning:  0.46409904956817627\n",
      "Test R^2 after unfreezing and pruning:  0.4244677424430847\n",
      "\n",
      "CVFOLD:  7\n",
      "[INFO] training network...\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Mas1' 'Cbln2' 'Tafa1' 'Mical2' 'Npy1r' 'Plch2' 'Enpp2' 'Htr3a' 'Elmo1'\n",
      " 'Slc6a1' 'Tac2' 'Phactr1' 'Fxyd6' 'Atp1a3' 'Ndst3' 'Coro6' 'Ndn' 'Lamp5'\n",
      " 'Galnt14' 'Erbb4' 'Gad1' 'Cplx1' 'Sst' 'Pvalb' 'Vip']\n",
      "[INFO] training network...\n",
      "Train R^2 before unfreezing:  0.4126642942428589\n",
      "Test R^2 before unfreezing:  0.3552681803703308\n",
      "Train R^2 after unfreezing:  0.48190003633499146\n",
      "Test R^2 after unfreezing:  0.45912206172943115\n",
      "Train R^2 after unfreezing and pruning:  0.4606616497039795\n",
      "Test R^2 after unfreezing and pruning:  0.4755675196647644\n",
      "\n",
      "CVFOLD:  8\n",
      "[INFO] training network...\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Calb1' 'Kcnip2' 'Kcnab3' 'Cacna1e' 'Arhgap32' 'Gabra1' 'Foxred1' 'Cck'\n",
      " 'Tac2' 'Gabrd' 'Tafa1' 'Enpp2' 'Fxyd6' 'Atp1a3' 'Cplx1' 'Sst' 'Lamp5'\n",
      " 'Gm49948' 'Galnt14' 'Erbb4' 'Htr3a' 'Ndn' 'Pvalb' 'Gad1' 'Vip']\n",
      "[INFO] training network...\n",
      "Train R^2 before unfreezing:  0.42941397428512573\n",
      "Test R^2 before unfreezing:  0.33999162912368774\n",
      "Train R^2 after unfreezing:  0.4763185977935791\n",
      "Test R^2 after unfreezing:  0.42408281564712524\n",
      "Train R^2 after unfreezing and pruning:  0.46659839153289795\n",
      "Test R^2 after unfreezing and pruning:  0.3876916766166687\n",
      "\n",
      "CVFOLD:  9\n",
      "[INFO] training network...\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Tafa1' 'Npy' 'Ndst3' 'Satb1' 'Chrnb3' 'Atp1a3' 'Gpc3' 'Reln' 'Gm49948'\n",
      " 'Cplx1' 'Enpp2' 'Fxyd6' 'Pdyn' 'Plch2' 'Calb1' 'Galnt14' 'Tac2' 'Ndn'\n",
      " 'Erbb4' 'Lamp5' 'Htr3a' 'Sst' 'Gad1' 'Pvalb' 'Vip']\n",
      "[INFO] training network...\n",
      "Train R^2 before unfreezing:  0.4429005980491638\n",
      "Test R^2 before unfreezing:  0.3855038285255432\n",
      "Train R^2 after unfreezing:  0.5124344229698181\n",
      "Test R^2 after unfreezing:  0.45129042863845825\n",
      "Train R^2 after unfreezing and pruning:  0.43402570486068726\n",
      "Test R^2 after unfreezing and pruning:  0.41219788789749146\n",
      "Bottleneck with 6 nodes\n",
      "\n",
      "CVFOLD:  0\n",
      "[INFO] training network...\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Elmo1' 'Ndnf' 'Syt1' 'Pde1a' 'Plch2' 'Ndst3' 'Pdyn' 'Enpp2' 'Atp1a3'\n",
      " 'Gpc3' 'Kcnab3' 'Fxyd6' 'Thsd7a' 'Gm49948' 'Htr3a' 'Galnt14' 'Cplx1'\n",
      " 'Erbb4' 'Ndn' 'Lamp5' 'Tac2' 'Gad1' 'Sst' 'Pvalb' 'Vip']\n",
      "[INFO] training network...\n",
      "Train R^2 before unfreezing:  0.4797060489654541\n",
      "Test R^2 before unfreezing:  0.4111354351043701\n",
      "Train R^2 after unfreezing:  0.5046976804733276\n",
      "Test R^2 after unfreezing:  0.46776437759399414\n",
      "Train R^2 after unfreezing and pruning:  0.47263914346694946\n",
      "Test R^2 after unfreezing and pruning:  0.4450472593307495\n",
      "\n",
      "CVFOLD:  1\n",
      "[INFO] training network...\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Kcnip2' 'Pde1a' 'Phactr1' 'Atp1a3' 'Pdyn' 'Lingo2' 'Kcnc2' 'Enpp2'\n",
      " 'Thsd7a' 'Gabrd' 'Fxyd6' 'Galnt14' 'Elmo1' 'Htr3a' 'Plch2' 'Cplx1' 'Ndn'\n",
      " 'Erbb4' 'Gm49948' 'Tac2' 'Lamp5' 'Gad1' 'Sst' 'Pvalb' 'Vip']\n",
      "[INFO] training network...\n",
      "Train R^2 before unfreezing:  0.4739954471588135\n",
      "Test R^2 before unfreezing:  0.4046570658683777\n",
      "Train R^2 after unfreezing:  0.5033937096595764\n",
      "Test R^2 after unfreezing:  0.45595651865005493\n",
      "Train R^2 after unfreezing and pruning:  0.46950429677963257\n",
      "Test R^2 after unfreezing and pruning:  0.44014793634414673\n",
      "\n",
      "CVFOLD:  2\n",
      "[INFO] training network...\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Kcnc2' 'Cxcl14' 'Fxyd6' 'Satb1' 'Gm49948' 'Sparcl1' 'Ndst3' 'Gabra1'\n",
      " 'Elfn1' 'Enpp2' 'Cbln2' 'Htr3a' 'Cplx1' 'Npy' 'Galnt14' 'Thsd7a' 'Unc13c'\n",
      " 'Ndn' 'Erbb4' 'Gad1' 'Tac2' 'Lamp5' 'Sst' 'Pvalb' 'Vip']\n",
      "[INFO] training network...\n",
      "Train R^2 before unfreezing:  0.465053915977478\n",
      "Test R^2 before unfreezing:  0.343349814414978\n",
      "Train R^2 after unfreezing:  0.4793083071708679\n",
      "Test R^2 after unfreezing:  0.41351479291915894\n",
      "Train R^2 after unfreezing and pruning:  0.46984565258026123\n",
      "Test R^2 after unfreezing and pruning:  0.41879427433013916\n",
      "\n",
      "CVFOLD:  3\n",
      "[INFO] training network...\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Gas7' 'Cck' 'Gabra1' 'Mas1' 'Lingo2' 'Elmo1' 'Gm49948' 'Afap1' 'Erbb4'\n",
      " 'Cbln2' 'Cplx1' 'Tac2' 'Enpp2' 'Ndn' 'Lamp5' 'Fxyd6' 'Galnt14' 'Pdyn'\n",
      " 'Ndst3' 'Thsd7a' 'Htr3a' 'Sst' 'Gad1' 'Pvalb' 'Vip']\n",
      "[INFO] training network...\n",
      "Train R^2 before unfreezing:  0.48361116647720337\n",
      "Test R^2 before unfreezing:  0.3992483615875244\n",
      "Train R^2 after unfreezing:  0.5011844336986542\n",
      "Test R^2 after unfreezing:  0.4489162564277649\n",
      "Train R^2 after unfreezing and pruning:  0.4695670008659363\n",
      "Test R^2 after unfreezing and pruning:  0.4263859987258911\n",
      "\n",
      "CVFOLD:  4\n",
      "[INFO] training network...\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Col24a1' 'Enpp2' 'Coro6' 'Cxcl14' 'Plch2' 'Gabra1' 'Elmo1' 'Pamr1'\n",
      " 'Gm49948' 'Atp1a3' 'Thsd7a' 'Galnt14' 'Tafa1' 'Ndst3' 'Ndn' 'Erbb4'\n",
      " 'Cplx1' 'Cbln2' 'Calb1' 'Htr3a' 'Lamp5' 'Gad1' 'Vip' 'Sst' 'Pvalb']\n",
      "[INFO] training network...\n",
      "Train R^2 before unfreezing:  0.4984232187271118\n",
      "Test R^2 before unfreezing:  0.4205175042152405\n",
      "Train R^2 after unfreezing:  0.5090925991535187\n",
      "Test R^2 after unfreezing:  0.44150376319885254\n",
      "Train R^2 after unfreezing and pruning:  0.47944629192352295\n",
      "Test R^2 after unfreezing and pruning:  0.4461103081703186\n",
      "\n",
      "CVFOLD:  5\n",
      "[INFO] training network...\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Cck' 'Fxyd6' 'Reln' 'Enpp2' 'Foxred1' 'Coro6' 'Npy' 'Plch2' 'Gm49948'\n",
      " 'Kcnc2' 'Cxcl14' 'Slc6a1' 'Ndst3' 'Chat' 'Lamp5' 'Cplx1' 'Galnt14' 'Gad1'\n",
      " 'Tac2' 'Htr3a' 'Erbb4' 'Ndn' 'Sst' 'Pvalb' 'Vip']\n",
      "[INFO] training network...\n",
      "Train R^2 before unfreezing:  0.4810309410095215\n",
      "Test R^2 before unfreezing:  0.3819783329963684\n",
      "Train R^2 after unfreezing:  0.5021086037158966\n",
      "Test R^2 after unfreezing:  0.4248879551887512\n",
      "Train R^2 after unfreezing and pruning:  0.4769202470779419\n",
      "Test R^2 after unfreezing and pruning:  0.38318562507629395\n",
      "\n",
      "CVFOLD:  6\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] training network...\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Atp1a3' 'Afap1' 'Gabrd' 'Pcdh7' 'Cdh13' 'Galnt14' 'Pik3r5' 'Tac2'\n",
      " 'Gm49948' 'Cplx1' 'Cplx3' 'Elmo1' 'Fxyd6' 'Calb1' 'Cbln2' 'Enpp2' 'Htr3a'\n",
      " 'Ndn' 'Erbb4' 'Ndst3' 'Gad1' 'Lamp5' 'Sst' 'Pvalb' 'Vip']\n",
      "[INFO] training network...\n",
      "Train R^2 before unfreezing:  0.45131832361221313\n",
      "Test R^2 before unfreezing:  0.36073189973831177\n",
      "Train R^2 after unfreezing:  0.5129768252372742\n",
      "Test R^2 after unfreezing:  0.44795727729797363\n",
      "Train R^2 after unfreezing and pruning:  0.47178345918655396\n",
      "Test R^2 after unfreezing and pruning:  0.4241349697113037\n",
      "\n",
      "CVFOLD:  7\n",
      "[INFO] training network...\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Calb1' 'Mical2' 'Chrnb3' 'Afap1' 'Npy1r' 'Lingo2' 'Sparcl1' 'Atp1a3'\n",
      " 'Gm49948' 'Phactr1' 'Enpp2' 'Elmo1' 'Ndst3' 'Fxyd6' 'Htr3a' 'Cplx1'\n",
      " 'Tac2' 'Lamp5' 'Galnt14' 'Erbb4' 'Ndn' 'Gad1' 'Sst' 'Pvalb' 'Vip']\n",
      "[INFO] training network...\n",
      "Train R^2 before unfreezing:  0.45242971181869507\n",
      "Test R^2 before unfreezing:  0.3540414571762085\n",
      "Train R^2 after unfreezing:  0.4975619912147522\n",
      "Test R^2 after unfreezing:  0.46653592586517334\n",
      "Train R^2 after unfreezing and pruning:  0.4716110825538635\n",
      "Test R^2 after unfreezing and pruning:  0.45860445499420166\n",
      "\n",
      "CVFOLD:  8\n",
      "[INFO] training network...\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Pde1a' 'Cxcl14' 'Elmo1' 'Tac2' 'Afap1' 'Erbb4' 'Gabra1' 'Gm49948'\n",
      " 'Thsd7a' 'Chrnb3' 'Enpp2' 'Calb1' 'Lamp5' 'Gabrd' 'Cbln2' 'Ndst3' 'Cplx1'\n",
      " 'Pdyn' 'Htr3a' 'Sst' 'Ndn' 'Galnt14' 'Gad1' 'Pvalb' 'Vip']\n",
      "[INFO] training network...\n",
      "Train R^2 before unfreezing:  0.4635109305381775\n",
      "Test R^2 before unfreezing:  0.3670450448989868\n",
      "Train R^2 after unfreezing:  0.49031633138656616\n",
      "Test R^2 after unfreezing:  0.4309723377227783\n",
      "Train R^2 after unfreezing and pruning:  0.47941309213638306\n",
      "Test R^2 after unfreezing and pruning:  0.4019090533256531\n",
      "\n",
      "CVFOLD:  9\n",
      "[INFO] training network...\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Mas1' 'Thsd7a' 'Reln' 'Pamr1' 'Gabra1' 'Atp1a3' 'Plch2' 'Calb1' 'Ndst3'\n",
      " 'Tac2' 'Galnt14' 'Enpp2' 'Pdyn' 'Cplx1' 'Npy' 'Ndn' 'Cbln2' 'Fxyd6'\n",
      " 'Htr3a' 'Erbb4' 'Lamp5' 'Gad1' 'Sst' 'Pvalb' 'Vip']\n",
      "[INFO] training network...\n",
      "Train R^2 before unfreezing:  0.4550028443336487\n",
      "Test R^2 before unfreezing:  0.3472493886947632\n",
      "Train R^2 after unfreezing:  0.5163717567920685\n",
      "Test R^2 after unfreezing:  0.4535292387008667\n",
      "Train R^2 after unfreezing and pruning:  0.46528273820877075\n",
      "Test R^2 after unfreezing and pruning:  0.41009825468063354\n",
      "Bottleneck with 8 nodes\n",
      "\n",
      "CVFOLD:  0\n",
      "[INFO] training network...\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Tafa1' 'Elmo1' 'Ndnf' 'Sparcl1' 'Calb1' 'Scg2' 'Gabra1' 'Gm49948' 'Gpc3'\n",
      " 'Cbln2' 'Atp1a3' 'Enpp2' 'Galnt14' 'Htr3a' 'Fxyd6' 'Thsd7a' 'Lamp5' 'Ndn'\n",
      " 'Tac2' 'Erbb4' 'Cplx1' 'Gad1' 'Sst' 'Vip' 'Pvalb']\n",
      "[INFO] training network...\n",
      "Train R^2 before unfreezing:  0.47494661808013916\n",
      "Test R^2 before unfreezing:  0.4171813726425171\n",
      "Train R^2 after unfreezing:  0.4930551052093506\n",
      "Test R^2 after unfreezing:  0.47801220417022705\n",
      "Train R^2 after unfreezing and pruning:  0.47224318981170654\n",
      "Test R^2 after unfreezing and pruning:  0.4589442014694214\n",
      "\n",
      "CVFOLD:  1\n",
      "[INFO] training network...\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Coro6' 'Ndst3' 'Galnt14' 'Gabra1' 'Lingo2' 'Reln' 'Plch2' 'Cbln2'\n",
      " 'Cplx1' 'Ndn' 'Gm43670' 'Htr3a' 'Atp1a3' 'Gm49948' 'Elmo1' 'Npy' 'Fxyd6'\n",
      " 'Erbb4' 'Enpp2' 'Tac2' 'Sst' 'Lamp5' 'Gad1' 'Pvalb' 'Vip']\n",
      "[INFO] training network...\n",
      "Train R^2 before unfreezing:  0.4776516556739807\n",
      "Test R^2 before unfreezing:  0.38364285230636597\n",
      "Train R^2 after unfreezing:  0.4906173348426819\n",
      "Test R^2 after unfreezing:  0.4546438455581665\n",
      "Train R^2 after unfreezing and pruning:  0.4709377884864807\n",
      "Test R^2 after unfreezing and pruning:  0.4350373148918152\n",
      "\n",
      "CVFOLD:  2\n",
      "[INFO] training network...\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Pamr1' 'Phactr1' 'Cbln2' 'Gm49948' 'Fxyd6' 'Kcnc2' 'Gabra1' 'Thsd7a'\n",
      " 'Atp1a3' 'Elfn1' 'Cxcl14' 'Enpp2' 'Pdyn' 'Htr3a' 'Unc13c' 'Galnt14'\n",
      " 'Cplx1' 'Erbb4' 'Ndn' 'Tac2' 'Sst' 'Lamp5' 'Gad1' 'Pvalb' 'Vip']\n",
      "[INFO] training network...\n",
      "Train R^2 before unfreezing:  0.5044629573822021\n",
      "Test R^2 before unfreezing:  0.3934682607650757\n",
      "Train R^2 after unfreezing:  0.5079914033412933\n",
      "Test R^2 after unfreezing:  0.41068869829177856\n",
      "Train R^2 after unfreezing and pruning:  0.4743708372116089\n",
      "Test R^2 after unfreezing and pruning:  0.4066714644432068\n",
      "\n",
      "CVFOLD:  3\n",
      "[INFO] training network...\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Sparcl1' 'Cbln2' 'Afap1' 'Pdyn' 'Erbb4' 'Galnt14' 'Reln' 'Lingo2'\n",
      " 'Gm49948' 'Gabra1' 'Tac2' 'Fxyd6' 'Enpp2' 'Thsd7a' 'Ndn' 'Cplx1' 'Elmo1'\n",
      " 'Lamp5' 'Htr3a' 'Calb1' 'Ndst3' 'Sst' 'Pvalb' 'Vip' 'Gad1']\n",
      "[INFO] training network...\n",
      "Train R^2 before unfreezing:  0.49562740325927734\n",
      "Test R^2 before unfreezing:  0.4352419972419739\n",
      "Train R^2 after unfreezing:  0.5054943859577179\n",
      "Test R^2 after unfreezing:  0.44264113903045654\n",
      "Train R^2 after unfreezing and pruning:  0.479306161403656\n",
      "Test R^2 after unfreezing and pruning:  0.4304403066635132\n",
      "\n",
      "CVFOLD:  4\n",
      "[INFO] training network...\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Ncald' 'Thsd7a' 'Enpp2' 'Elmo1' 'Fxyd6' 'Gabra1' 'Pde1a' 'Gm49948'\n",
      " 'Ndst3' 'Tac2' 'Npy' 'Galnt14' 'Coro6' 'Cplx1' 'Tafa1' 'Pamr1' 'Phactr1'\n",
      " 'Erbb4' 'Htr3a' 'Ndn' 'Lamp5' 'Gad1' 'Sst' 'Vip' 'Pvalb']\n",
      "[INFO] training network...\n",
      "Train R^2 before unfreezing:  0.4909994602203369\n",
      "Test R^2 before unfreezing:  0.38079196214675903\n",
      "Train R^2 after unfreezing:  0.4868382215499878\n",
      "Test R^2 after unfreezing:  0.4299784302711487\n",
      "Train R^2 after unfreezing and pruning:  0.4772832989692688\n",
      "Test R^2 after unfreezing and pruning:  0.43334078788757324\n",
      "\n",
      "CVFOLD:  5\n",
      "[INFO] training network...\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Tafa1' 'Pde1a' 'Ak5' 'Slc6a1' 'Gm49948' 'Plch2' 'Kcnc2' 'Thsd7a'\n",
      " 'Cxcl14' 'Pdyn' 'Chat' 'Fxyd6' 'Reln' 'Galnt14' 'Cplx1' 'Erbb4' 'Tac2'\n",
      " 'Calb1' 'Ndn' 'Gad1' 'Lamp5' 'Htr3a' 'Pvalb' 'Sst' 'Vip']\n",
      "[INFO] training network...\n",
      "Train R^2 before unfreezing:  0.48957252502441406\n",
      "Test R^2 before unfreezing:  0.37835150957107544\n",
      "Train R^2 after unfreezing:  0.4918166399002075\n",
      "Test R^2 after unfreezing:  0.4236915707588196\n",
      "Train R^2 after unfreezing and pruning:  0.4831313490867615\n",
      "Test R^2 after unfreezing and pruning:  0.41539502143859863\n",
      "\n",
      "CVFOLD:  6\n",
      "[INFO] training network...\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Coro6' 'Arhgap32' 'Col24a1' 'Ndnf' 'Pamr1' 'Tiam2' 'Unc13c' 'Magel2'\n",
      " 'Chat' 'Lingo2' 'Galnt14' 'Ndn' 'Cplx1' 'Fxyd6' 'Enpp2' 'Atp1a3' 'Ndst3'\n",
      " 'Tac2' 'Erbb4' 'Htr3a' 'Gad1' 'Lamp5' 'Pvalb' 'Vip' 'Sst']\n",
      "[INFO] training network...\n",
      "Train R^2 before unfreezing:  0.4844343662261963\n",
      "Test R^2 before unfreezing:  0.37983113527297974\n",
      "Train R^2 after unfreezing:  0.5103184282779694\n",
      "Test R^2 after unfreezing:  0.4416477084159851\n",
      "Train R^2 after unfreezing and pruning:  0.4714086055755615\n",
      "Test R^2 after unfreezing and pruning:  0.4161716103553772\n",
      "\n",
      "CVFOLD:  7\n",
      "[INFO] training network...\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Plch2' 'Chrnb3' 'Slc5a7' 'Phactr1' 'Thsd7a' 'Mical2' 'Gm49948' 'Fxyd6'\n",
      " 'Chat' 'Tafa1' 'Ndst3' 'Cck' 'Atp1a3' 'Cplx1' 'Enpp2' 'Ndn' 'Erbb4'\n",
      " 'Tac2' 'Galnt14' 'Htr3a' 'Gad1' 'Lamp5' 'Sst' 'Pvalb' 'Vip']\n",
      "[INFO] training network...\n",
      "Train R^2 before unfreezing:  0.4918721318244934\n",
      "Test R^2 before unfreezing:  0.4104999303817749\n",
      "Train R^2 after unfreezing:  0.495225191116333\n",
      "Test R^2 after unfreezing:  0.46650445461273193\n",
      "Train R^2 after unfreezing and pruning:  0.4721791744232178\n",
      "Test R^2 after unfreezing and pruning:  0.4693877696990967\n",
      "\n",
      "CVFOLD:  8\n",
      "[INFO] training network...\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Npy' 'Elmo1' 'Erbb4' 'Syt1' 'Fxyd6' 'Gabra1' 'Gabrd' 'Ndst3' 'Tac2'\n",
      " 'Thsd7a' 'Cbln2' 'Reln' 'Enpp2' 'Calb1' 'Pdyn' 'Gm49948' 'Cplx1' 'Htr3a'\n",
      " 'Galnt14' 'Lamp5' 'Sst' 'Pvalb' 'Ndn' 'Gad1' 'Vip']\n",
      "[INFO] training network...\n",
      "Train R^2 before unfreezing:  0.4929240345954895\n",
      "Test R^2 before unfreezing:  0.3583058714866638\n",
      "Train R^2 after unfreezing:  0.4991375207901001\n",
      "Test R^2 after unfreezing:  0.4234549403190613\n",
      "Train R^2 after unfreezing and pruning:  0.47855281829833984\n",
      "Test R^2 after unfreezing and pruning:  0.40464597940444946\n",
      "\n",
      "CVFOLD:  9\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] training network...\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Atp1a3' 'Scg2' 'Npy' 'Gabra1' 'Fxyd6' 'Reln' 'Pde1a' 'Satb1' 'Thsd7a'\n",
      " 'Elmo1' 'Galnt14' 'Cplx1' 'Coro6' 'Pamr1' 'Tac2' 'Plch2' 'Erbb4' 'Ndn'\n",
      " 'Htr3a' 'Pdyn' 'Lamp5' 'Gad1' 'Pvalb' 'Sst' 'Vip']\n",
      "[INFO] training network...\n",
      "Train R^2 before unfreezing:  0.467689573764801\n",
      "Test R^2 before unfreezing:  0.39991146326065063\n",
      "Train R^2 after unfreezing:  0.5149269998073578\n",
      "Test R^2 after unfreezing:  0.44602882862091064\n",
      "Train R^2 after unfreezing and pruning:  0.4800705909729004\n",
      "Test R^2 after unfreezing and pruning:  0.4118685722351074\n",
      "Bottleneck with 10 nodes\n",
      "\n",
      "CVFOLD:  0\n",
      "[INFO] training network...\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Pcdh7' 'Gm43670' 'Gm11549' 'Gabra1' 'Cbln2' 'Gm49948' 'Pamr1' 'Elmo1'\n",
      " 'Ndst3' 'Atp1a3' 'Fxyd6' 'Pdyn' 'Htr3a' 'Enpp2' 'Ndn' 'Thsd7a' 'Erbb4'\n",
      " 'Galnt14' 'Lamp5' 'Cplx1' 'Tac2' 'Sst' 'Gad1' 'Pvalb' 'Vip']\n",
      "[INFO] training network...\n",
      "Train R^2 before unfreezing:  0.4854303002357483\n",
      "Test R^2 before unfreezing:  0.42420703172683716\n",
      "Train R^2 after unfreezing:  0.5112215578556061\n",
      "Test R^2 after unfreezing:  0.47600817680358887\n",
      "Train R^2 after unfreezing and pruning:  0.4766654968261719\n",
      "Test R^2 after unfreezing and pruning:  0.4651910662651062\n",
      "\n",
      "CVFOLD:  1\n",
      "[INFO] training network...\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Galnt14' 'Chrnb3' 'Elmo1' 'Gabra1' 'Pde1a' 'Thsd7a' 'Phactr1' 'Gm43670'\n",
      " 'Htr3a' 'Lingo2' 'Gm49948' 'Fxyd6' 'Plch2' 'Cplx1' 'Enpp2' 'Atp1a3'\n",
      " 'Kcnc2' 'Erbb4' 'Ndn' 'Tac2' 'Sst' 'Lamp5' 'Gad1' 'Vip' 'Pvalb']\n",
      "[INFO] training network...\n",
      "Train R^2 before unfreezing:  0.49801135063171387\n",
      "Test R^2 before unfreezing:  0.4178023934364319\n",
      "Train R^2 after unfreezing:  0.5169212520122528\n",
      "Test R^2 after unfreezing:  0.4526793956756592\n",
      "Train R^2 after unfreezing and pruning:  0.4768184423446655\n",
      "Test R^2 after unfreezing and pruning:  0.4264286160469055\n",
      "\n",
      "CVFOLD:  2\n",
      "[INFO] training network...\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Gabra1' 'Tmem44' 'Npy' 'Ndst3' 'Col24a1' 'Unc13c' 'Sparcl1' 'Pamr1'\n",
      " 'Phactr1' 'Htr3a' 'Galnt14' 'Cxcl14' 'Lingo2' 'Enpp2' 'Mybpc1' 'Cbln2'\n",
      " 'Erbb4' 'Tac2' 'Cplx1' 'Gad1' 'Ndn' 'Sst' 'Lamp5' 'Vip' 'Pvalb']\n",
      "[INFO] training network...\n",
      "Train R^2 before unfreezing:  0.5035943984985352\n",
      "Test R^2 before unfreezing:  0.38261204957962036\n",
      "Train R^2 after unfreezing:  0.5009875893592834\n",
      "Test R^2 after unfreezing:  0.4172888398170471\n",
      "Train R^2 after unfreezing and pruning:  0.46941351890563965\n",
      "Test R^2 after unfreezing and pruning:  0.3852958083152771\n",
      "\n",
      "CVFOLD:  3\n",
      "[INFO] training network...\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Pde1a' 'Gm49948' 'Cbln2' 'Plch2' 'Reln' 'Tac2' 'Enpp2' 'Elmo1' 'Kcnc2'\n",
      " 'Gabra1' 'Fxyd6' 'Erbb4' 'Pdyn' 'Galnt14' 'Ndn' 'Thsd7a' 'Calb1' 'Cplx1'\n",
      " 'Htr3a' 'Ndst3' 'Lamp5' 'Pvalb' 'Gad1' 'Vip' 'Sst']\n",
      "[INFO] training network...\n",
      "Train R^2 before unfreezing:  0.5008496642112732\n",
      "Test R^2 before unfreezing:  0.426347017288208\n",
      "Train R^2 after unfreezing:  0.5233005285263062\n",
      "Test R^2 after unfreezing:  0.44646120071411133\n",
      "Train R^2 after unfreezing and pruning:  0.4846115708351135\n",
      "Test R^2 after unfreezing and pruning:  0.4418221116065979\n",
      "\n",
      "CVFOLD:  4\n",
      "[INFO] training network...\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Gabra1' 'Npy' 'Cbln2' 'Kcnc2' 'Tac2' 'Phactr1' 'Gas7' 'Fxyd6' 'Pde1a'\n",
      " 'Thsd7a' 'Pdyn' 'Ndst3' 'Pamr1' 'Tafa1' 'Gm49948' 'Cplx1' 'Galnt14' 'Ndn'\n",
      " 'Erbb4' 'Lamp5' 'Htr3a' 'Gad1' 'Sst' 'Vip' 'Pvalb']\n",
      "[INFO] training network...\n",
      "Train R^2 before unfreezing:  0.4870743155479431\n",
      "Test R^2 before unfreezing:  0.390325665473938\n",
      "Train R^2 after unfreezing:  0.5049058198928833\n",
      "Test R^2 after unfreezing:  0.43411147594451904\n",
      "Train R^2 after unfreezing and pruning:  0.473488450050354\n",
      "Test R^2 after unfreezing and pruning:  0.4178714156150818\n",
      "\n",
      "CVFOLD:  5\n",
      "[INFO] training network...\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Cck' 'Chrnb3' 'Enpp2' 'Lingo2' 'Pde1a' 'Chat' 'Ndst3' 'Phactr1' 'Fxyd6'\n",
      " 'Plch2' 'Pdyn' 'Kcnc2' 'Slc6a1' 'Gm49948' 'Galnt14' 'Ndn' 'Cplx1' 'Erbb4'\n",
      " 'Lamp5' 'Htr3a' 'Tac2' 'Gad1' 'Sst' 'Vip' 'Pvalb']\n",
      "[INFO] training network...\n",
      "Train R^2 before unfreezing:  0.4980517029762268\n",
      "Test R^2 before unfreezing:  0.4016329050064087\n",
      "Train R^2 after unfreezing:  0.522284746170044\n",
      "Test R^2 after unfreezing:  0.426754891872406\n",
      "Train R^2 after unfreezing and pruning:  0.4590870141983032\n",
      "Test R^2 after unfreezing and pruning:  0.3918052315711975\n",
      "\n",
      "CVFOLD:  6\n",
      "[INFO] training network...\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Sparcl1' 'Afap1' 'Cdh13' 'Col24a1' 'Lingo2' 'Tafa1' 'Galnt14' 'Cbln2'\n",
      " 'Atp1a3' 'Pdyn' 'Cplx1' 'Enpp2' 'Fxyd6' 'Elmo1' 'Tac2' 'Calb1' 'Ndn'\n",
      " 'Ndst3' 'Erbb4' 'Htr3a' 'Gad1' 'Lamp5' 'Pvalb' 'Sst' 'Vip']\n",
      "[INFO] training network...\n",
      "Train R^2 before unfreezing:  0.4936996102333069\n",
      "Test R^2 before unfreezing:  0.3911195993423462\n",
      "Train R^2 after unfreezing:  0.5199171602725983\n",
      "Test R^2 after unfreezing:  0.4406498074531555\n",
      "Train R^2 after unfreezing and pruning:  0.4889776110649109\n",
      "Test R^2 after unfreezing and pruning:  0.42985910177230835\n",
      "\n",
      "CVFOLD:  7\n",
      "[INFO] training network...\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Pamr1' 'Nell1' 'Atp1a3' 'Fxyd6' 'Thsd7a' 'Cck' 'Enpp2' 'Pdyn' 'Plch2'\n",
      " 'Chat' 'Gm49948' 'Cplx1' 'Ndst3' 'Elmo1' 'Htr3a' 'Kcnc2' 'Ndn' 'Erbb4'\n",
      " 'Galnt14' 'Tac2' 'Sst' 'Lamp5' 'Gad1' 'Vip' 'Pvalb']\n",
      "[INFO] training network...\n",
      "Train R^2 before unfreezing:  0.4893275499343872\n",
      "Test R^2 before unfreezing:  0.3827494978904724\n",
      "Train R^2 after unfreezing:  0.5233786404132843\n",
      "Test R^2 after unfreezing:  0.4737047553062439\n",
      "Train R^2 after unfreezing and pruning:  0.4766926169395447\n",
      "Test R^2 after unfreezing and pruning:  0.47221559286117554\n",
      "\n",
      "CVFOLD:  8\n",
      "[INFO] training network...\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Elmo1' 'Syt1' 'Foxred1' 'Calb1' 'Enpp2' 'Kcnc2' 'Pdyn' 'Thsd7a' 'Gabra1'\n",
      " 'Fxyd6' 'Erbb4' 'Gabrd' 'Ndst3' 'Tafa1' 'Tac2' 'Cplx1' 'Gm49948' 'Lamp5'\n",
      " 'Htr3a' 'Galnt14' 'Ndn' 'Sst' 'Pvalb' 'Gad1' 'Vip']\n",
      "[INFO] training network...\n",
      "Train R^2 before unfreezing:  0.4836857318878174\n",
      "Test R^2 before unfreezing:  0.35674989223480225\n",
      "Train R^2 after unfreezing:  0.5202333629131317\n",
      "Test R^2 after unfreezing:  0.4345073103904724\n",
      "Train R^2 after unfreezing and pruning:  0.4840177297592163\n",
      "Test R^2 after unfreezing and pruning:  0.39411330223083496\n",
      "\n",
      "CVFOLD:  9\n",
      "[INFO] training network...\n",
      "[INFO] training network...\n",
      "The 25 genes that make it:  ['Gabra1' 'Gm49948' 'Gpc3' 'Kcnc2' 'Pamr1' 'Plch2' 'Scg2' 'Enpp2' 'Reln'\n",
      " 'Cbln2' 'Ndst3' 'Galnt14' 'Tac2' 'Cplx1' 'Ndn' 'Fxyd6' 'Calb1' 'Erbb4'\n",
      " 'Htr3a' 'Lamp5' 'Pdyn' 'Gad1' 'Sst' 'Pvalb' 'Vip']\n",
      "[INFO] training network...\n",
      "Train R^2 before unfreezing:  0.47417908906936646\n",
      "Test R^2 before unfreezing:  0.3829360008239746\n",
      "Train R^2 after unfreezing:  0.5175437033176422\n",
      "Test R^2 after unfreezing:  0.4573664665222168\n",
      "Train R^2 after unfreezing and pruning:  0.4641934633255005\n",
      "Test R^2 after unfreezing and pruning:  0.40709686279296875\n",
      "Time: 0.0h 34m 35s\n"
     ]
    }
   ],
   "source": [
    "# Settings\n",
    "l2_params = np.logspace(-10, -10, num=1)\n",
    "l1_params = np.array([1e-1])\n",
    "\n",
    "act = 'elu'\n",
    "folds = 10\n",
    "seed = 42\n",
    "lr=0.0001\n",
    "epochs=50\n",
    "bs=32\n",
    "patience=epochs\n",
    "pre_trained_weights=True\n",
    "unfreeze = [False, False, True, True, True, True] # last 4 layers can be trained only first\n",
    "prune=True\n",
    "\n",
    "r2_before_unfreezing = np.zeros((len(range(2,12,2)), folds, l1_params.shape[0], l2_params.shape[0]))\n",
    "r2_before_unfreezing_tr = np.zeros((len(range(2,12,2)), folds, l1_params.shape[0], l2_params.shape[0]))\n",
    "r2_after_unfreezing = np.zeros((len(range(2,12,2)), folds, l1_params.shape[0], l2_params.shape[0]))\n",
    "r2_after_unfreezing_tr = np.zeros((len(range(2,12,2)), folds, l1_params.shape[0], l2_params.shape[0]))\n",
    "r2_after_unfreezing_ap = np.zeros((len(range(2,12,2)), folds, l1_params.shape[0], l2_params.shape[0]))\n",
    "r2_after_unfreezing_ap_tr = np.zeros((len(range(2,12,2)), folds, l1_params.shape[0], l2_params.shape[0]))\n",
    "r2_freeze_unfreeze_hist = np.zeros((len(range(2,12,2)), folds, l1_params.shape[0], l2_params.shape[0], 4*epochs))\n",
    "r2_freeze_unfreeze_hist_tr = np.zeros((len(range(2,12,2)), folds, l1_params.shape[0], l2_params.shape[0], 4*epochs))\n",
    "\n",
    "t = time.time()\n",
    "np.random.seed(seed)\n",
    "n = genes.shape[0]\n",
    "ind = np.random.permutation(n)\n",
    "X = genes[ind,:]\n",
    "Y = ephys[ind,:]\n",
    "\n",
    "for u,f in enumerate(range(2,12,2)):\n",
    "    nodes_list=[512, 128, f, 128, 512]\n",
    "    print('Bottleneck with {} nodes'.format(f))\n",
    "    # CV folds\n",
    "    for cvfold in range(folds):\n",
    "        print('\\nCVFOLD: ', cvfold)\n",
    "        indtest  = np.arange(cvfold*int(n/folds), (cvfold+1)*int(n/folds))\n",
    "        indtrain = np.setdiff1d(np.arange(n), indtest)\n",
    "        x_train = np.copy(X[indtrain,:])\n",
    "        y_train = np.copy(Y[indtrain,:])\n",
    "        x_test = np.copy(X[indtest,:])\n",
    "        y_test = np.copy(Y[indtest,:])\n",
    "\n",
    "        # Mean centering (like sRRR)\n",
    "        X_mean = np.mean(x_train, axis=0)\n",
    "        x_train -= X_mean\n",
    "        x_test -= X_mean\n",
    "        Y_mean = np.mean(y_train, axis=0)\n",
    "        y_train -= Y_mean\n",
    "        y_test -= Y_mean\n",
    "\n",
    "        input_dim = x_train.shape[1]\n",
    "        output_dim = y_train.shape[1]\n",
    "\n",
    "        for i, l2 in enumerate(l2_params):\n",
    "            #print('Ridge penalty: ', l2)\n",
    "            for j, l1 in enumerate(l1_params):\n",
    "                #print('Lasso penalty: ', l1)\n",
    "\n",
    "                pre_trained_weights_h5 = 'KerasSavedModels/{}/Classification_last_weights_{}_{}_{}.h5'.\\\n",
    "                                                format('nodes_list_{}'.format(u),cvfold, j, i)\n",
    "                input_dim = x_train.shape[1]\n",
    "                output_dim = y_train.shape[1]\n",
    "                BN_PreTrFreezeUnfreeze = FreezeUnfreeze(l1=l1, l2=l2, lr=lr, act=act, input_dim=input_dim, output_dim=output_dim, \\\n",
    "                                                           unfreeze = unfreeze, \\\n",
    "                                                           pre_trained_weights=pre_trained_weights, \\\n",
    "                                                           pre_trained_weights_h5=pre_trained_weights_h5, \\\n",
    "                                                           nodes_list=nodes_list)\n",
    "                r2_before_unfreezing_train, r2_before_unfreezing_test, \\\n",
    "                    r2_after_unfreezing_train, r2_after_unfreezing_test, \\\n",
    "                    r2_after_unfreezing_train_ap, r2_after_unfreezing_test_ap, \\\n",
    "                    train_hist, test_hist = BN_PreTrFreezeUnfreeze.train(x_train=x_train, y_train=y_train, \\\n",
    "                                                                        x_test=x_test, y_test=y_test, \\\n",
    "                                                                        epochs=epochs, bs=bs, patience=patience, \\\n",
    "                                                                        cvfold_id=cvfold, l1_id=j, l2_id=i, \\\n",
    "                                                                        prune=prune, geneNames=gene_names, \\\n",
    "                                                                        verbose=0)\n",
    "                r2_before_unfreezing[u, cvfold, j, i] = r2_before_unfreezing_test\n",
    "                r2_before_unfreezing_tr[u, cvfold, j, i] = r2_before_unfreezing_train\n",
    "                r2_after_unfreezing[u, cvfold, j, i] = r2_after_unfreezing_test\n",
    "                r2_after_unfreezing_tr[u, cvfold, j, i] = r2_after_unfreezing_train\n",
    "                r2_after_unfreezing_ap[u, cvfold, j, i] = r2_after_unfreezing_test_ap\n",
    "                r2_after_unfreezing_ap_tr[u, cvfold, j, i] = r2_after_unfreezing_train_ap\n",
    "                r2_freeze_unfreeze_hist[u, cvfold, j, i] = test_hist\n",
    "                r2_freeze_unfreeze_hist_tr[u, cvfold, j, i] = train_hist\n",
    "                #print('Test R^2 score (before unfreezing): ', r2_before_unfreezing[cvfold, j, i])\n",
    "                #print('Test R^2 score (after unfreezing): ', r2_after_unfreezing[cvfold, j, i])\n",
    "                #print('Test R^2 score (after unfreezing and after pruning): ', r2_after_unfreezing_ap[cvfold, j, i])\n",
    "            \n",
    "t = time.time() - t\n",
    "m,s = divmod(t, 60)\n",
    "h,m = divmod(m, 60)\n",
    "print('Time: {}h {:2.0f}m {:2.0f}s'.format(h,m,s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('KerasSavedModels/scala_2020/Bottleneck_r2_pre_tr_and_freeze_unfreeze_lasso_multiple_nodes.pickle', 'wb') as f:\n",
    "    pickle.dump([r2_before_unfreezing, r2_before_unfreezing_tr, \\\n",
    "                 r2_after_unfreezing, r2_after_unfreezing_tr, \\\n",
    "                 r2_after_unfreezing_ap, r2_after_unfreezing_ap_tr, \\\n",
    "                 r2_freeze_unfreeze_hist, r2_freeze_unfreeze_hist_tr], f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('KerasSavedModels/scala_2020/Bottleneck_r2_pre_tr_and_freeze_unfreeze_lasso_multiple_nodes.pickle', 'rb') as f:\n",
    "    r2_before_unfreezing, r2_before_unfreezing_tr, \\\n",
    "    r2_after_unfreezing, r2_after_unfreezing_tr, \\\n",
    "    r2_after_unfreezing_ap, r2_after_unfreezing_ap_tr, \\\n",
    "    r2_freeze_unfreeze_hist, r2_freeze_unfreeze_hist_tr = pickle.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x324 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# The learning curves for our favourite model: pre-tr + train last 4 layers only + train all + prune\n",
    "linewidth = 2\n",
    "\n",
    "# suppressing \"mean of empty slice\" warnings\n",
    "with warnings.catch_warnings():\n",
    "    warnings.simplefilter(\"ignore\", category=RuntimeWarning)\n",
    "    n_rank2 = np.nanmean(nonzero_rank2, axis=0)[0, :]\n",
    "    r_rank2_r = np.nanmean(r2_sRRR_relaxed_rank2, axis=0)[0, :]\n",
    "    n_rank16 = np.nanmean(nonzero_rank16, axis=0)[0, :]\n",
    "    r_rank16_r = np.nanmean(r2_sRRR_relaxed_rank16, axis=0)[0, :]\n",
    "\n",
    "epochs_used = 200\n",
    "fig = plt.figure(figsize = (16, 4.5))\n",
    "ax = fig.add_subplot(111)\n",
    "colours = ['#99d8c9', '#66c2a4', '#41ae76', '#238b45', '#005824']\n",
    "for u,f in enumerate(range(2,12,2)):\n",
    "    ax.plot(range(epochs_used), np.mean(r2_freeze_unfreeze_hist_tr, axis = (1, 2))[u, 0, :], \\\n",
    "             '--', c = colours[u], linewidth=linewidth, label=None)\n",
    "    ax.plot(range(epochs_used), np.mean(r2_freeze_unfreeze_hist, axis = (1, 2))[u, 0, :], \\\n",
    "             c = colours[u], linewidth=linewidth, label='{} nodes'.format(f))\n",
    "ax.hlines(r_rank16_r[np.isclose(n_rank16, 25, atol=3)], xmin = 0, xmax = epochs_used, \\\n",
    "            colors = np.array([0, 0, 0])/256, linewidth=linewidth)\n",
    "ax.hlines(r_rank2_r[np.isclose(n_rank2, 25, atol=3)], xmin = 0, xmax = epochs_used, \\\n",
    "            colors = np.array([0, 0, 0])/256, linewidth=linewidth)\n",
    "ax.annotate('RRR, r=16', (180, r_rank16_r[np.isclose(n_rank16, 25, atol=3)]+0.005), fontsize=15)\n",
    "ax.annotate('RRR, r=2', (180, r_rank2_r[np.isclose(n_rank2, 25, atol=3)]+0.005), fontsize=15)\n",
    "ax.vlines(x=50, ymin=ax.get_ylim()[0], ymax=ax.get_ylim()[1], linestyles='dashed')\n",
    "ax.vlines(x=100, ymin=ax.get_ylim()[0], ymax=ax.get_ylim()[1], linestyles='dashed')\n",
    "ax.set_ylim([0.3, 0.49])\n",
    "ax.set_xlim([0, 200])\n",
    "ax.set_title('Training and validation set R^2 scores', fontsize = 19)\n",
    "ax.set_xlabel('Epoch', fontsize = 17)\n",
    "ax.set_ylabel('R^2', fontsize = 17)\n",
    "ax.legend(loc='lower right', ncol=5, fontsize = 15)\n",
    "ax.tick_params(axis='both', which='major', labelsize=15)\n",
    "ax.tick_params(axis='both', which='minor', labelsize=15)\n",
    "sns.despine()\n",
    "\n",
    "plt.savefig('figures/Lasso_training_curves_different_nodes.pdf', bbox_inches='tight',\n",
    "    pad_inches=0)\n",
    "plt.savefig('figures/Lasso_training_curves_different_nodes.png', bbox_inches='tight',\n",
    "    pad_inches=0)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.5"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}