diff --git a/HCAL_bicycleGAN.ipynb b/HCAL_bicycleGAN.ipynb
index aa7d171..e862f9f 100644
--- a/HCAL_bicycleGAN.ipynb
+++ b/HCAL_bicycleGAN.ipynb
@@ -9,13 +9,14 @@
     "import scipy as sp\n",
     "import numpy as np\n",
     "import os \n",
+    "\n",
     "import pickle\n",
     "\n",
     "import tensorflow as tf\n",
     "import matplotlib.pyplot as plt\n",
     "from datetime import datetime\n",
     "\n",
-    "from architectures.bicycle_GAN import *"
+    "from architectures.bicycle_GAN import *\n"
    ]
   },
   {
@@ -29,14 +30,44 @@
     "\n",
     "# Option to save and restore hyperparameters\n",
     "\n",
-    "PATH='HCAL_bycicleGAN_test35'"
+    "PATH='HCAL_bycicleGAN_test110'"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 3,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "LEARNING_RATE:8e-05\n",
+      "BETA1:0.5\n",
+      "BATCH_SIZE:16\n",
+      "EPOCHS:4\n",
+      "SAVE_SAMPLE_PERIOD:400\n",
+      "SEED:1\n",
+      "d_sizes:{'conv_layers': [(8.0, 4, 2, False, 1, <function lrelu at 0x7f2e40f839d8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f2e3b1f6a90>), (16, 4, 2, 'bn', 0.8, <function lrelu at 0x7f2e40f839d8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f2e3b1f6c50>), (32, 4, 2, 'bn', 1, <function lrelu at 0x7f2e40f839d8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f2e3b1f6c88>), (64, 4, 2, 'bn', 0.8, <function lrelu at 0x7f2e40f839d8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f2e3b1f6cc0>), (128, 4, 1, 'bn', 1, <function lrelu at 0x7f2e40f839d8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f2e3b1f6cf8>)], 'dense_layers': [(512, 'bn', 0.8, <function lrelu at 0x7f2e40f839d8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f2e3b1f6d30>), (64, 'bn', 0.8, <function lrelu at 0x7f2e40f839d8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f2e3b1f6d68>), (16, False, 0.8, <function lrelu at 0x7f2e40f839d8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f2e3b1f6da0>)], 'readout_layer_w_init': <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f2e3b1f6dd8>}\n",
+      "g_sizes_dec:{'deconv_layers': [(64, 4, 2, 'bn', 1, <function lrelu at 0x7f2e40f839d8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f2e3b1f6e10>), (32, 4, 2, 'bn', 0.8, <function lrelu at 0x7f2e40f839d8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f2e3b1f6e48>), (16, 4, 2, 'bn', 1, <function lrelu at 0x7f2e40f839d8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f2e3b1f6e80>), (8.0, 4, 2, 'bn', 1, <function lrelu at 0x7f2e40f839d8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f2e3b1f6eb8>), (1, 4, 2, False, 0.8, <function identity at 0x7f2e4fad6400>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f2e3b1f6ef0>)]}\n",
+      "g_sizes_enc:{'latent_dims': 16, 'conv_layers': [(8.0, 4, 2, False, 1, <function lrelu at 0x7f2e40f839d8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f2e3b1f6f28>), (16, 4, 2, 'bn', 0.8, <function lrelu at 0x7f2e40f839d8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f2e3b1f6f60>), (32, 4, 2, 'bn', 1, <function lrelu at 0x7f2e40f839d8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f2e3b1f6f98>), (64, 4, 2, 'bn', 1, <function lrelu at 0x7f2e40f839d8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f2e3b1f6fd0>), (128, 4, 2, 'bn', 0.8, <function lrelu at 0x7f2e40f839d8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f2e3b20b048>)]}\n",
+      "e_sizes:{'latent_dims': 16, 'conv_layers': [(8.0, 4, 2, False, 1, <function lrelu at 0x7f2e40f839d8>, <tensorflow.python.ops.init_ops.RandomNormal object at 0x7f2e3b20b0b8>), (16, 4, 2, 'bn', 1, <function lrelu at 0x7f2e40f839d8>, <tensorflow.python.ops.init_ops.RandomNormal object at 0x7f2e3b20b0f0>), (32, 4, 2, 'bn', 0.8, <function lrelu at 0x7f2e40f839d8>, <tensorflow.python.ops.init_ops.RandomNormal object at 0x7f2e3b20b128>), (64, 4, 2, 'bn', 1, <function lrelu at 0x7f2e40f839d8>, <tensorflow.python.ops.init_ops.RandomNormal object at 0x7f2e3b20b160>), (128, 4, 2, 'bn', 0.8, <function lrelu at 0x7f2e40f839d8>, <tensorflow.python.ops.init_ops.RandomNormal object at 0x7f2e3b20b198>)], 'dense_layers': [(256, 'bn', 0.8, <function lrelu at 0x7f2e40f839d8>, <tensorflow.python.ops.init_ops.RandomNormal object at 0x7f2e3b20b1d0>), (128, 'bn', 0.8, <function lrelu at 0x7f2e40f839d8>, <tensorflow.python.ops.init_ops.RandomNormal object at 0x7f2e3b20b208>), (16, False, 0.8, <function lrelu at 0x7f2e40f839d8>, <tensorflow.python.ops.init_ops.RandomNormal object at 0x7f2e3b20b240>)], 'readout_layer_w_init': <tensorflow.python.ops.init_ops.RandomNormal object at 0x7f2e3b20b278>}\n",
+      "preprocess:False\n",
+      "cost_type:FEATURE\n",
+      "validating_size:2000\n",
+      "test_size:2000\n",
+      "n_batches:2\n",
+      "reco_path:/disk/lhcb_data/davide/HCAL_project_full_event/reco/\n",
+      "true_path:/disk/lhcb_data/davide/HCAL_project_full_event/true/\n",
+      "discr_steps:1\n",
+      "gen_steps:1\n",
+      "vae_steps:1\n",
+      "latent_weight:2\n",
+      "cycl_weight:1\n",
+      "kl_weight:1\n"
+     ]
+    }
+   ],
    "source": [
     "if task =='TRAIN' and os.path.exists(PATH+'/hyper_parameters.pkl'):\n",
     "    with open(PATH+'/hyper_parameters.pkl', 'rb') as f:  \n",
@@ -70,29 +101,29 @@
     "    \n",
     "elif task=='TRAIN' and not os.path.exists(PATH+'/hyper_parameters.pkl'):\n",
     "    \n",
-    "    reco_path = '/disk/lhcb_data/davide/HCAL_project/piplus_cells_inout/piplus/reco/'\n",
-    "    true_path = '/disk/lhcb_data/davide/HCAL_project/piplus_cells_inout/piplus/true/'\n",
-    "    #reco_path = '/disk/lhcb_data/davide/HCAL_project_full_event/reco/'\n",
-    "    #true_path = '/disk/lhcb_data/davide/HCAL_project_full_event/true/'\n",
-    "    n_batches = 1\n",
-    "    test_size = 5000\n",
-    "    validating_size=1000\n",
+    "    reco_path = '/disk/lhcb_data/davide/HCAL_project_full_event/reco/'\n",
+    "    true_path = '/disk/lhcb_data/davide/HCAL_project_full_event/true/'\n",
+    "    #reco_path = '/disk/lhcb_data/davide/HCAL_project_single_pion/piplus_cells_inout/piplus/reco/'\n",
+    "    #true_path = '/disk/lhcb_data/davide/HCAL_project_single_pion/piplus_cells_inout/piplus/true/'\n",
+    "    n_batches = 2\n",
+    "    test_size = 2000\n",
+    "    validating_size=2000\n",
     "    \n",
-    "    LEARNING_RATE = 2e-4\n",
+    "    LEARNING_RATE = 8e-5\n",
     "    BETA1 = 0.5\n",
     "    BATCH_SIZE = 16\n",
     "    EPOCHS = 4\n",
-    "    SAVE_SAMPLE_PERIOD = 200\n",
+    "    SAVE_SAMPLE_PERIOD = 400\n",
     "    SEED = 1\n",
     "    preprocess=False\n",
-    "    cost_type='GAN'\n",
+    "    cost_type='FEATURE'\n",
     "    \n",
-    "    latent_weight=100\n",
-    "    cycl_weight=10\n",
+    "    latent_weight=2\n",
+    "    cycl_weight=1\n",
     "    kl_weight=1\n",
     "    discr_steps=1\n",
-    "    gen_steps=4\n",
-    "    vae_steps=4\n",
+    "    gen_steps=1\n",
+    "    vae_steps=1\n",
     "    \n",
     "    latent_dims=16\n",
     "    ndf = 16\n",
@@ -126,11 +157,11 @@
     "         \n",
     "         'deconv_layers': [\n",
     "    \n",
-    "                            (ngf*4, f,   s,  'bn',   1, tf.nn.softplus, tf.truncated_normal_initializer(stddev_g)),#(batch, 1, 1, ngf*4) => (batch, 2, 2, ngf*4*2)\n",
-    "                            (ngf*2, f,   s,  'bn',   d, tf.nn.softplus, tf.truncated_normal_initializer(stddev_g)),#(batch, 2, 2, ngf*4*2) => (batch, 4, 4, ngf*4*2)\n",
-    "                            (ngf,   f,   s,  'bn',   1, tf.nn.softplus, tf.truncated_normal_initializer(stddev_g)),#(batch, 4, 4, ngf*4*2) => (batch, 7, 8, ngf*4*2)\n",
-    "                            (ngf/2, f,   s,  'bn',   1, tf.nn.softplus, tf.truncated_normal_initializer(stddev_g)),#(batch, 7, 8, ngf*4*2) => (batch, 13, 16, ngf*2*2)\n",
-    "                            (1,     f,   s,   False, d, tf.nn.softplus, tf.truncated_normal_initializer(stddev_g)),#(batch, 26, 32, ngf*2) => (batch, 52, 64, 1)\n",
+    "                            (ngf*4, f,   s,  'bn',   1, lrelu, tf.truncated_normal_initializer(stddev_g)),#(batch, 1, 1, ngf*4) => (batch, 2, 2, ngf*4*2)\n",
+    "                            (ngf*2, f,   s,  'bn',   d, lrelu, tf.truncated_normal_initializer(stddev_g)),#(batch, 2, 2, ngf*4*2) => (batch, 4, 4, ngf*4*2)\n",
+    "                            (ngf,   f,   s,  'bn',   1, lrelu, tf.truncated_normal_initializer(stddev_g)),#(batch, 4, 4, ngf*4*2) => (batch, 7, 8, ngf*4*2)\n",
+    "                            (ngf/2, f,   s,  'bn',   1, lrelu, tf.truncated_normal_initializer(stddev_g)),#(batch, 7, 8, ngf*4*2) => (batch, 13, 16, ngf*2*2)\n",
+    "                            (1,     f,   s,   False, d, tf.identity, tf.truncated_normal_initializer(stddev_g)),#(batch, 26, 32, ngf*2) => (batch, 52, 64, 1)\n",
     "                       \n",
     "                         ],  \n",
     "    }\n",
@@ -150,7 +181,7 @@
     "         \n",
     "         'dense_layers': [\n",
     "                             (ndf*32, 'bn',  d, lrelu, tf.truncated_normal_initializer(stddev_d)),\n",
-    "                             #(ndf*4,  'bn',  d, lrelu, tf.truncated_normal_initializer(stddev_d)),             \n",
+    "                             (ndf*4,  'bn',  d, lrelu, tf.truncated_normal_initializer(stddev_d)),             \n",
     "                             (ndf,   False,  d, lrelu, tf.truncated_normal_initializer(stddev_d))],\n",
     "        \n",
     "         'readout_layer_w_init':tf.truncated_normal_initializer(stddev_d),\n",
@@ -266,7 +297,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 49,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -283,12 +314,32 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 50,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfsAAACtCAYAAAC3K9aMAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAHJJJREFUeJzt3XncHVWd5/HPl4QQZV9kDRBkUUFbULRBXBgBAQWlp8FGESJjQ7fSioMLi+IyozYoA4wzLTYtTliNCAiIKLKLjaaNI6jsO4kJm2SBsIb8+o9zLqnn5q7P3ev5vl+v+8qtqlNVv1t57jn3nFN1jiICMzMzK69VBh2AmZmZ9ZYLezMzs5JzYW9mZlZyLuzNzMxKzoW9mZlZybmwNzMzKzkX9mZWl6TbJO3eg+NOlxSSJo9z/xMkfa/bcZmVlQt7szokPShpz6p1H5X0q6p1H5Y0R9LTkhZI+pmkt9fYLyR9sGr97pLmtRjPDfkYb6xaf2lev3th3XaSfiTpCUmLJf1B0jGSJrX48QGIiB0i4oZ29um2WtcoIr4REX8/qJjMRo0Le7MOSDoGOB34BrARsAXwHeADVUlnAE/mfztxN3BY4fzrA7sAjxfWbQ3MBuYCb4iItYGDgJ2BNTs8v5mNIBf2ZuMkaW3gfwBHRcQlEbE0Il6MiJ9ExOcK6bYE3gUcCewtaaMOTns+8HeFGvqHgB8DLxTSfBW4OSKOiYgFABFxV0R8OCIW1fgcG0i6QtIiSU9KuknSKnnby60bkr6SWwvOk/SUpD/mFoTjJT0maa6k9xSOO6ZlJO9/Xq0PJelwSXfk494v6R/y+tWBnwGb5paTpyVtWn0sSe/PXQ6LcgvI66ri+Gxu3Vgs6YeSprZ32c1Gmwt7s/HbFZhKKmwbOQyYExEXA3cAh3RwzvnA7UClUD0MOKcqzZ7ARW0c8zPAPOBVpNaJE4B642jvD5wLrAv8HriKlI9sRvrh869tnLfoMWA/YC3gcOA0SW+KiKXAvsD8iFgjv+YXd5S0HfAD4NP5M1wJ/ETSlEKyDwL7AFsBfwV8dJxxmo0kF/ZmjV2aa4uLJC0iNdFXrA88ERHLmhzjMOCC/P4COm/KPwc4TNJrgHUi4tdV29cHFrRxvBeBTYAtc8vETVF/0oybIuKq/Jl/RCpcT4qIF4FZwHRJ67T1aYCI+GlE3BfJjcAvgHe0uPvfAT+NiKtzHKcArwDeVkjz7YiYHxFPAj8Bdmw3RrNR5sLerLEDImKdygv4RGHbX4ANGt1RLmk3Um1yVl51AfAGSZ0UNpcA7wY+SaplV/sLqfBu1beAe4Ff5Cb04xqkfbTw/lnSj52XCssAa7RxbgAk7SvpN7kbYRHwXmCDFnffFHioshARy0n3K2xWSPNI4f0z44nRbJS5sDcbv18DzwEHNEgzAxBwi6RHSDfOQeEmu3ZFxDOkfuyPU7uwvwb42zaO91REfCYiXk1qpj9G0h7jja9gKfDKwvLGtRJJWg24mFQj3yj/qLqSdN2gfpdCxXxgy8LxBGwO/Hl8YZuVjwt7s3GKiMXAl4B/kXSApFdKWjXXUr+ZbwL7IOnGvB0Lr08ChxRbBCRNrXqpximLTgDeFREP1tj2ZeBtkr4laeN8/G3yjXUrNbFL2i9vF7AEeCm/OnULcHC+JjsDB9ZJNwVYjfREwTJJ+7LingRIrQnr5xsia7kQeJ+kPSStSroH4Xng5i58BrNScGFv1oGIOBU4BvgiqbCaC/wTcCmpxv8scE5EPFJ5AWcBk0g3jEFqbn626rV1k/POj4hf1dl2H+nmwenAbZIWk2rOc4CnauyyLak14GlSa8V3uvRs/Ymkz7GQ9ITABbUSRcRTwKdIhfZC4MPA5YXtd5JuwLs/3zuxadX+dwEfAf4P8ASpdWL/iCg+oWA2oan+fThmZmZWBq7Zm5mZlZwLezMzs5JzYW9mZlZyLuzNzMxKbuCFfWG866clLZf0bGG5k2FFWz3/eZJeqIrjdw3S715It1RptrHivpvW27dwjAslPSJpiaQ7JRUnNlld0sWSHsrH3qVq31UknSZpodKMZl8rbNuzKpZKfO9rEs+G+XjXVK3/iKS7tGIc9LrHkTQrn+s9Veu/m9cf3CQGSXpA0odrbDtWVTPNmVlzeV6ASp76iKSZkvo6oFA+Z3Uee2uD9O9oksdu0eR8k6rSPy3pJUmnFdKsnvOmvyjNl3B9Ydtncl60RNKfJf0v5cdkJW2c87oFeb+bJL2lQSxfy/F/omr9Z/P6L7Zw/a6V9KUa6/82x9daOR4RQ/MCHgT2bJJmcpfPeR7wlXHuu026hG3vtwMwpfD+ceD1efmVpMeQdiPNkrZL1b5HA38ijZC2BXAP8NE659mH9CjTak3iORf4JXBNYd1WpGeV9yANbvJfSYOkrFPnGLOAu4DzC+tWI41c9gBwcAvX5avAz2us/xNwxKD/Pv3ya9RexTyVNKjRrcDX+xzDTOBr49x3OmlQpXHn+6T5Fp4B3lZYNyvn/RuQHoN9c2Hb1sDa+f0GwI3Ap/LyNqQ5GDbO+32cNK/DK+uc+2s5X5xdtf7WvP6LLcR/KHBPjfWXAie3eh0GXrNvJv8y+qGkH0h6CvhIro1/pZBmT0kPFpanSfqxpMfzL7SjBhB6XRFxW6x4BjhIhemr87ZnIuLbEfHvwPIau88AvhkRCyLiYdL0qh+tc6oZwKyIeL5eLEpzoG/Bys9AbwE8GhHXRnJJjmerBh/tEmBPSZVpVPcnPbf9l6pz/kNuMXhS0k8lVYY1PQfYQ9ImhbRvIn35LmxwXjNrItIYD1dRmBdA0mqSTpH0sKRHc233FYXtH5B0S67l3idpn7x+U0mX5+/wvZKO6P8natlBwJ8j4mYASTuQJlf6x4h4IiJeioiXW3MjzdGwuLD/clIhT0TcGxGnRxoz46WIOANYnTRWRT2/BtZTmssCpaGyVyFNJPUypZkbb1UaS+JXkl6fN10CbCzpbYW065OGlK6eBKuuoS/ss78hFUZrAz9slFBp6s8rgN+SBivZC/icujP8Z0skfVlSw1nHJJ0l6VngNuA+4OoWD7896Vdhxa2k1oHq469NmlP97AYxrAp8mzQITLWbgbmS9s7NYh8kFdp3NIhtKSkzqYyUttKMbLk5/9OkHwIbkf7gz4OXB4P5DWNnhTsUuKzqy2dmbZI0jVTI3VtYfTKwHekHwDakPPNLOf1bSd/fzwHrAO8ktRRAGuRoHmleggOBb/Q5j/2CpEtbTD6DsfngXwP3A19X6gr9g6QxQ15LOjRXLh8n5a9n1oljZ1Jl7f4mMZzLiiGya+WLbwH+Dfh70kRW3wcukzQl0syPFzF2iO2DgT9ExG1NzrtCP5tzWmiueJCqZnxSM8h1VevGNL2TpvR8ML/fDbi/Kv2JwL/VOed5pPHNFxVeZ7UY77ia8Qv7TyLNc34CMKnG9icoNOMDq5JaAqYX1r0BeK7GvkcAdzY5//HAafn9P1Joxi+sewZYRhp5ba8Gx5pFGkVuT+B6UvPXAtJQqHPIzfh52yFVn+lF0pjokP7Y/5DfTyZ1A+w76L9Nv/waxVfOU5/O398AriV3xZEKqaXA1oX0uwIP5Pf/Wskfqo65OWk45TUL6/4ZmFknhpk18tizW4x/Oh0045NaTF8Ctiis+1I+5ok5f3p3vg7b1dj/NcD/BDassW1tUmXtcw3O/7X8+bfK/xersuJH0ixyMz6poP9y1b73Abvl97uTunVXy8uzgU+2cy1GpWY/t420WwJbaOy0pJ+nziQc2UlRmNksIj7WUbQtitQMdCPpl3XTc0aavvN5Uh9UxVrUHgK1+tfsGJK2JBWsX66zfX9SH/rbSF+IvYFzJW3fJMzrSF+w44BLYuUhS7cEvlv4v3mc9GNiWt5+IbBNbup6D+lL+Ysm5zSz+g6IiDVJBcZrWTGb4KtI9wj9rvB9/HleD6lQv6/G8TYFnow0zHHFQ4ydZbDaKVV5bKfTPLfqMOCGSF2eFc+Sfnx8IyJeiIjrSPcs7VW9c6ShmO8C/m9xvaTVgZ8Cv4yIbzULIiIeAB4GvgHcFhHzq5JsCRxbVW5twopreiOwGNhf0nbATqTWlZbVnZpzyFSP6dtoNq25pJsZXtfzqLpnMk3GQi+4HXgj8Ie8/EbSr8uXSdoa2IXU1FPPrqQv7d1Kc668ApgqaV5ETMvHvS4ibsnpb5Z0C+lX8O31DhoRyyX9gPQDa9caSeaSfglfXGf/Jbl57jDSH/v5sWIKVTMbp4i4UdJM0uyCB5BaDp8FdoiIWjMEzqV2vjSf1Ae9ZqHA34Ihm2VQKWM7lFRpKarkna2OFT8mf1aa4OoyUtP9J+rtVMM5pO6AQ2tsmwt8NSJOrrVjRISkSlfArcCVEfFEG+cemZp9tVtIs1ytm2/m+lRh26+BF/LjE1Nzf/MbJL15MKGOlW9sOVDp0Y/JkvYjTUd6XSHNavkPCmBK4T3kPjSlR0A2J/V/z6w6zQxSQT2vQSiXkpqWKjOxfZ3UNFS5Tr8F/kvlJpHcf7cLK74ojZxC6o6ZXWPbd4EvFm5WWVdS9XSsZ5P67Rvec2BmbTsd2EvSjhGxnNR8fJqkDQEkbSZp75z2LOBwpdkEV8nbXhsRc0n39PxzzmP/itQyef4APk8j7wA2JE0CVXQ9qXvw2JwHvxN4O7kFUdIRheuxA3AsqfsDSVNIN8wtBg6P3KbeogtIrZW1KjpnAkdJeouSNSTtn1sQKs4mPWH13xhHvjiqhf1M0o1iD5GanWZVNkTEMtJdim8l9ZE8Qep7Wqv6IAUnaOwzmY90Epykr0r6cYMkR5N+Hf+FVMh+PCKuKmx/iPSLe31S882zylOVkm6ou5b0+W8BfhQRMwvnrvyaXemPQdLHlMcQiIjnYuxMbEuAFyLi0bz9KuCbwOX5RpUfACdGxC+bff5Id7heV2fbD0hNYpdIWpI/Q3Xz2dWkfvy7IuKPzc5nZq2JiMdJFYYT86pjSTfs/SZ/H68h9VMTEf8BHA6cRircbiQ1NwN8iNSfPh/4Mam/udFNxp+vymPbqpVWk3SipJ80STYDuCjSDW4vy12L7ydVJhYDZ5DuI7onJ3kn8CdJS0k3e1/Oiuv1DtJNjvsCiwufp1Yr5hiRnrS6JiKeq7FtNukxvjNIj0vfTZrJsZjmPuA/gKmkLoS2eNY7MzOzkhvVmr2ZmZm1aCCFvaR9lAZVuVfScYOIoRlJM7TykIsNh3k0M+ulUcg7WyXpkDp5bOvPjlvL+t6MrzTozd2kftp5pBvBPhQRde/wNjOb6Jx3WicGUbN/K3BvRNyfb5SYRbpRwszM6nPeaeM2iOfsN2PsIDnzSMMX1jVFq8VUVm+UxEbccyzlhXheg47DbIj1Nu+s/vY1a/RtlL6bx+pUv47d7UbyRscubHsuWss7B1HY1wpqpcsk6UjgSICpvJK/7t+wyzYAs+PaQYdgNux6mndq8tjiIJYtG3f6bh6rU/06djeP2+zYxW2/WXYVrRhEM/480jCMFdNIz2qOERFnRsTOEbHzqqzWt+DMzIaU804bt0EU9r8FtpW0VR6N6GDSoAVmZlaf804bt74340fEMkn/RJoKdRLw/Whnmj4zswmo13lnp83QnTRpt9PM326XQC91u+m+3rG78ZkGMhFORFwJXDmIc5uZjSrnnTZeHkHPzMys5FzYm5mZldyozGdvZmZDrJ3+62Z90NXH6qRvvJf96v3S8DO0+Hy/a/ZmZmYl58LezMys5NyMb2ZmbRtU03qzEfFGcfS9ZsfuRhyu2ZuZmZWcC3szM7OSc2FvZmZWcu6zNzOzvuqkD7rRDHCtHKudoXf7NRxuN9PW45q9mZlZybmwNzMzKzkX9mZmZiXnPnszM1tJu0PatqPdfvdGsfSyX72Xz9n3m2v2ZmZmJefC3szMrORc2JuZmZWc++zNzGwl7Tyv3iz9pHXXBeClhQtrLvfieffKOSpaPVen562nk/5/j41vZmZmTblmb2ZmPVFdg6+oXm6WvlHa6mNWr69Y/q6dAFjlxt+P63zNYhjvMfrFNXszM7OSc83ezGyCamec+GqtpG+3tttJjb56uZJu4b6vAWCd25cAsLxwnGbna1bz76Q23844Bg3HHWjxv801ezMzs5JzzX5EXDX/FgD23nTHAUdiZtZf4+kbr6Sr1Oh/duUFALz5Kx8HYKMf3Vn3PJV96z09MIpc2I8IF/Jm1ql2HuHq5HGvZk3trRaetdK1W/Auv+V2APa7e18A1rvrOQCW7rYtq//7PQ3jbLa+qNn16uQxvobHjtaO4WZ8MzOzknPN3szMuqpZTbjdpvjx7Fuxyo7bA7D8bxak5YXp0bupACVonm+Va/ZmZmYl55q9mdkE0as++maa9bN34wa4esdYZfFSAJZ10ErQixv0OpnWdzx6VrOXtLmk6yXdIek2SUfn9etJulrSPfnf2sMdmZlNQM47rRd62Yy/DPhMRLwO2AU4StL2wHHAtRGxLXBtXjYzs6R0eedLCxfy0sKFTFp33brD2RZV0hVfrZ6jWixaQixaMq64K+eud+xiumHXs8I+IhZExP/P758C7gA2Az4AnJ2TnQ0c0KsYzMxGjfNO64W+9NlLmg7sBMwGNoqIBZD+qCVt2I8YzMxGTcd5p1ofErebffQV9QapqdZs8JpGNedm+9SbIKfS0tBKXM3UStfuPRDjHgNhWIbLlbQGcDHw6YhouS1F0pGS5kia8yLP9y5AM7Mh1JW8M5x3WtLTmr2kVUl/rOdHxCV59aOSNsm/TDcBHqu1b0ScCZwJsJbWa3GMIDOz0de1vHOVweSdnd5938rd7+3WymvV/CfC8/UVvbwbX8BZwB0RcWph0+XAjPx+BnBZr2IwMxs1zjutF3pZs98NOBT4o6Rb8roTgJOACyV9DHgYOKiHMZiZjZru5Z3Rm774TnVjytjx1sq70WrQSrpmz8138v8ynrHxe1bYR8SvANXZvEevzmtmNsqcd1oveAQ9MzPrqk77wlu9i388WjlWGfvyPTa+mZlZydWt2Uu6EvhERDzYv3DMzEbbUOWdbTxnP5E1eya/otkd/o0M+to3qtnPBH4h6Qv5MRAzM2tuJs47bcjUrdlHxIWSfgp8CZgj6VxgeWH7qfX2NTObqJx31q8p92JWu17oZtzDotkNei8CS4HVgDUp/MGamVldI5d3dvPRsE4Ly1rpu13gFgfV6cajgMOuUZ/9PsCppIEc3hQRz/QtKjOzEeW804ZRo5r9F4CDIuK2fgVjZlYCzjuzZhPajKfm3I1jTESN+uzf0c9AzMzKwHmnDSMPqmNmVlZtDJfby+Fdu6nbA/b0a9/q61mt2fVvlLYVHlTHzMys5FyzNzOznmh32NtGNedWB7ppppvT5o4S1+zNzMxKzjV7MzNbSS/76OvVoOvVnIvPxPdSL8/RtSltx8k1ezMzs5Jzzd7MzPqq3oQz9Z7L76Sfvd104zlGv1oeOuGavZmZWcm5Zm9mZk21+5w4NK9Fd6M23Oo4/I3u8G81jn7W3ovXsxtjHrhmb2ZmVnKu2ZuZWU80eza+UR94rfWNjKfPfpCj8fWba/ZmZmYl55q9mVlZaWx/b7+f9e60z76Xd9B3Y59G27s5t0DDcfNbPKxr9mZmZiXnmr2ZmfVEpzXzYt9+p8fo9T7DzjV7MzOzknPN3sysrNqYz76b6t2F36pad+tXtxI0G32vGzp5WqCX133MsaO1fVzYm5lZV9UrkFvVymNy/SjcyzTVrZvxzczMSs41ezMzmzAadQ2Mt8Y+nhsIu/loXit6XrOXNEnS7yVdkZe3kjRb0j2SfihpSq9jMDMbNc47rZv60Yx/NHBHYflk4LSI2BZYCHysDzGYmY2akc87X1q4sO3BbIr9/NXL3dSN41biG4U+/J4W9pKmAe8DvpeXBbwbuCgnORs4oJcxmJmNGued1m297rM/Hfg8sGZeXh9YFBGVzol5wGY9jsHMbNT0Je/s1lC67Zyn0bn6UUPu5jk6GS63349E9qxmL2k/4LGI+F1xdY2kNZ8SlHSkpDmS5rzI8z2J0cxs2DjvtF7oZc1+N+D9kt4LTAXWIv1aXUfS5PwLdRowv9bOEXEmcCbAWlqvxWEDzMxGnvNO67qe1ewj4viImBYR04GDgesi4hDgeuDAnGwGcFmvYjAzGzXOO60XBjGozrHAMZLuJfVDnTWAGMzMRk3X885YtuzlVzOaPHnMq520xfN0+1yD1M0Yqz9ztz9/X65iRNwA3JDf3w+8tR/nNTMbZc47rVs8XK6ZmVnJubA3MzMrueHtDDEzs6FR3dfe6DnyQT6z386Y852OT98ofbNjNeuL7/Y1dM3ezMys5FzYm5mZlZwLezMzs5Jzn72ZmbWtl33hnWinr7zf49MXlWZsfDMzMxsOLuzNzMxKzs34ZmYTVDtN2u00zXfaRD2oY5eZa/ZmZmYl58LezMys5FzYm5mZlZz77M3MJqhu9l/3qv/fusM1ezMzs5JzYW9mZlZyLuzNzMxKThEx6BiakvQ4sBR4YtCx1LABjqsd9eLaMiJe1e9gzMrMeee4jFpcLeWdI1HYA0iaExE7DzqOao6rPcMal1lZDet3znG1p9O43IxvZmZWci7szczMSm6UCvszBx1AHY6rPcMal1lZDet3znG1p6O4RqbP3szMzMZnlGr2ZmZmNg5DX9hL2kfSXZLulXTcAOPYXNL1ku6QdJuko/P69SRdLeme/O+6A4pvkqTfS7oiL28laXaO64eSpgwgpnUkXSTpznzddh2W62VWds47W45vQuSdQ13YS5oE/AuwL7A98CFJ2w8onGXAZyLidcAuwFE5luOAayNiW+DavDwIRwN3FJZPBk7LcS0EPjaAmP438POIeC3wxhzfsFwvs9Jy3tmWiZF3RsTQvoBdgasKy8cDxw86rhzLZcBewF3AJnndJsBdA4hlWv7PfzdwBSDS4AuTa13HPsW0FvAA+b6QwvqBXy+//Cr7y3lny7FMmLxzqGv2wGbA3MLyvLxuoCRNB3YCZgMbRcQCgPzvhgMI6XTg88DyvLw+sCgiKlNJDeK6vRp4HPh/uYnse5JWZziul1nZOe9szYTJO4e9sFeNdQN9fEDSGsDFwKcjYskgY8nx7Ac8FhG/K66ukbTf120y8CbgjIjYiTRkp5vszfpjGPKAMZx3tqwneeewF/bzgM0Ly9OA+QOKBUmrkv5Yz4+IS/LqRyVtkrdvAjzW57B2A94v6UFgFqk56nRgHUmVSaMHcd3mAfMiYnZevoj0Bzzo62U2ETjvbG5C5Z3DXtj/Ftg23x05BTgYuHwQgUgScBZwR0ScWth0OTAjv59B6o/qm4g4PiKmRcR00vW5LiIOAa4HDhxgXI8AcyW9Jq/aA7idAV8vswnCeWcTEy3vHPpBdSS9l/RraxLw/Yj4+oDieDtwE/BHVvTvnEDqe7oQ2AJ4GDgoIp4cUIy7A5+NiP0kvZr0a3U94PfARyLi+T7HsyPwPWAKcD9wOOkH5lBcL7Myc97ZVoy7U/K8c+gLezMzM+vMsDfjm5mZWYdc2JuZmZWcC3szM7OSc2FvZmZWci7szczMSs6F/RDJs0M9IGm9vLxuXt5y0LGZmQ0j55utcWE/RCJiLnAGcFJedRJwZkQ8NLiozMyGl/PN1vg5+yGTh5X8HfB94Ahgp4h4YbBRmZkNL+ebzU1unsT6KSJelPQ54OfAe/wHa2bWmPPN5tyMP5z2BRYArx90IGZmI8L5ZgMu7IdMHhN5L2AX4L9XZjkyM7PanG8258J+iOTZoc4gzff8MPAt4JTBRmVmNrycb7bGhf1wOQJ4OCKuzsvfAV4r6V0DjMnMbJg532yB78Y3MzMrOdfszczMSs6FvZmZWcm5sDczMys5F/ZmZmYl58LezMys5FzYm5mZlZwLezMzs5JzYW9mZlZy/wnwUSqKXTE11AAAAABJRU5ErkJggg==\n",
+      "text/plain": [
+       "(42695, 52, 64, 1)"
+      ]
+     },
+     "execution_count": 50,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "train_true.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 792x288 with 2 Axes>"
       ]
@@ -310,7 +361,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 52,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#train_reco_dict={}\n",
+    "#train_true_dict={}\n",
+    "#\n",
+    "#for i in range(train_true.shape[0]//10):\n",
+    "#    train_true_dict[i]=train_true[10*i:10*(i+1)]\n",
+    "#    train_reco_dict[i]=train_reco[10*i:10*(i+1)]\n",
+    "#\n",
+    "#train_reco_dict_summed=np.array([train_reco_dict[i].sum(axis=0) for i in range(train_true.shape[0]//10)])\n",
+    "#train_true_dict_summed=np.array([train_true_dict[i].sum(axis=0) for i in range(train_true.shape[0]//10)])\n",
+    "#train_reco=train_reco_dict_summed\n",
+    "#train_true=train_true_dict_summed"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -318,6 +388,7 @@
     "\n",
     "    \n",
     "    tf.reset_default_graph()\n",
+    "    tf.add_check_numerics_ops()\n",
     "    \n",
     "    _, n_H_A, n_W_A ,n_C = train_true.shape\n",
     "    _, n_H_B, n_W_B ,n_C = train_reco.shape\n",
@@ -349,7 +420,7 @@
     "    saver=tf.train.Saver()\n",
     "    # Add ops to save and restore all the variables.\n",
     "    \n",
-    "    gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.33)\n",
+    "    gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.15)\n",
     "    \n",
     "    with tf.Session(config=tf.ConfigProto(gpu_options=gpu_options)) as sess:\n",
     "        \n",
@@ -389,7 +460,7 @@
     "        done = False\n",
     "\n",
     "        while not done:\n",
-    "            \n",
+    "            plt.clf()\n",
     "            #j = int(input(\"Input event number\"))\n",
     "            if preprocess:\n",
     "                draw_nn_sample(test_true, test_reco, 1, preprocess,\n",
@@ -398,34 +469,18 @@
     "                              f=gan.get_sample_A_to_B, save=False, is_training=False, PATH=PATH)\n",
     "            else:\n",
     "                draw_nn_sample(test_true, test_reco, 1, preprocess,\n",
-    "                              f=gan.get_sample_A_to_B, save=False, is_training=False)\n",
+    "                              f=gan.get_sample_A_to_B, save=True, is_training=False, PATH=PATH)\n",
     "            \n",
     "            ans = input(\"Generate another?\")\n",
     "            if ans and ans[0] in ('n' or 'N'):\n",
     "                done = True\n",
     "        \n",
-    "        done = False\n",
-    "        while not done:\n",
-    "            \n",
-    "            if preprocess:\n",
-    "                draw_nn_sample(test_true, test_reco, 20, preprocess,\n",
-    "                              min_true=min_true, max_true=max_true, \n",
-    "                              min_reco=min_reco, max_reco=max_reco,\n",
-    "                              f=gan.get_sample_A_to_B, save=False, is_training=False)\n",
-    "            else:\n",
-    "                draw_nn_sample(test_true, test_reco, 20, preprocess,\n",
-    "                              f=gan.get_sample_A_to_B, save=False, is_training=False)\n",
-    "                \n",
-    "            ans = input(\"Generate another?\")\n",
-    "            if ans and ans[0] in ('n' or 'N'):\n",
-    "                done = True\n",
-    "        \n",
     "        return test_reco_NN"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 54,
    "metadata": {
     "scrolled": false
    },
@@ -442,13 +497,49 @@
       "Encoder output shape (?, 16)\n",
       "Generator_A_to_B\n",
       "Input for generator encoded shape (?, 52, 64, 1)\n",
+      "After conv layer1\n",
+      "shape:  (?, 26, 32, 24)\n",
+      "After conv layer2\n",
+      "shape:  (?, 13, 16, 32)\n",
+      "After conv layer3\n",
+      "shape:  (?, 7, 8, 48)\n",
+      "After conv layer4\n",
+      "shape:  (?, 4, 4, 80)\n",
+      "After conv layer5\n",
+      "shape:  (?, 2, 2, 144)\n",
       "Output of generator encoder, \n",
-      " and input for generator decoder shape (?, 1, 1, 512)\n",
+      " and input for generator decoder shape (?, 1, 1, 576)\n",
+      "After deconv layer 1\n",
+      "Shape (?, 4, 4, 80)\n",
+      "After deconv layer 2\n",
+      "Shape (?, 7, 8, 48)\n",
+      "After deconv layer 3\n",
+      "Shape (?, 13, 16, 32)\n",
+      "After deconv layer 4\n",
+      "Shape (?, 26, 32, 24)\n",
       "Generator output shape (?, 52, 64, 1)\n",
       "Generator_A_to_B\n",
       "Input for generator encoded shape (?, 52, 64, 1)\n",
+      "After conv layer1\n",
+      "shape:  (?, 26, 32, 24)\n",
+      "After conv layer2\n",
+      "shape:  (?, 13, 16, 32)\n",
+      "After conv layer3\n",
+      "shape:  (?, 7, 8, 48)\n",
+      "After conv layer4\n",
+      "shape:  (?, 4, 4, 80)\n",
+      "After conv layer5\n",
+      "shape:  (?, 2, 2, 144)\n",
       "Output of generator encoder, \n",
-      " and input for generator decoder shape (?, 1, 1, 512)\n",
+      " and input for generator decoder shape (?, 1, 1, 576)\n",
+      "After deconv layer 1\n",
+      "Shape (?, 4, 4, 80)\n",
+      "After deconv layer 2\n",
+      "Shape (?, 7, 8, 48)\n",
+      "After deconv layer 3\n",
+      "Shape (?, 13, 16, 32)\n",
+      "After deconv layer 4\n",
+      "Shape (?, 26, 32, 24)\n",
       "Generator output shape (?, 52, 64, 1)\n",
       "Encoder_B\n",
       "Convolution\n",
@@ -457,126 +548,54 @@
       "Discriminator_B\n",
       "Input for convolution shape  (?, 52, 64, 1)\n",
       "minibatch features shape (?, 10)\n",
-      "Feature output shape (?, 16)\n",
+      "Feature output shape (?, 32)\n",
       "Logits shape (?, 1)\n",
       "Discriminator_B\n",
       "Input for convolution shape  (?, 52, 64, 1)\n",
       "minibatch features shape (?, 10)\n",
-      "Feature output shape (?, 16)\n",
+      "Feature output shape (?, 32)\n",
       "Logits shape (?, 1)\n",
       "Discriminator_B\n",
       "Input for convolution shape  (?, 52, 64, 1)\n",
       "minibatch features shape (?, 10)\n",
-      "Feature output shape (?, 16)\n",
+      "Feature output shape (?, 32)\n",
       "Logits shape (?, 1)\n",
       "Generator_A_to_B\n",
       "Input for generator encoded shape (?, 52, 64, 1)\n",
+      "After conv layer1\n",
+      "shape:  (?, 26, 32, 24)\n",
+      "After conv layer2\n",
+      "shape:  (?, 13, 16, 32)\n",
+      "After conv layer3\n",
+      "shape:  (?, 7, 8, 48)\n",
+      "After conv layer4\n",
+      "shape:  (?, 4, 4, 80)\n",
+      "After conv layer5\n",
+      "shape:  (?, 2, 2, 144)\n",
       "Output of generator encoder, \n",
-      " and input for generator decoder shape (?, 1, 1, 512)\n",
+      " and input for generator decoder shape (?, 1, 1, 576)\n",
+      "After deconv layer 1\n",
+      "Shape (?, 4, 4, 80)\n",
+      "After deconv layer 2\n",
+      "Shape (?, 7, 8, 48)\n",
+      "After deconv layer 3\n",
+      "Shape (?, 13, 16, 32)\n",
+      "After deconv layer 4\n",
+      "Shape (?, 26, 32, 24)\n",
       "Generator output shape (?, 52, 64, 1)\n",
       "\n",
-      " ****** \n",
-      "\n",
-      "Training bicycleGAN with a total of 16767 samples distributed in 1047 batches of size 16\n",
-      "\n",
-      "The validation set consists of 1000 images\n",
-      "The learning rate is 0.0002, and every 200 batches a generated sample will be saved to HCAL_bycicleGAN_test35\n",
-      "\n",
-      " ****** \n",
-      "\n",
-      "Epoch: 0\n",
-      "At iter: 200  -  dt: 0:00:00.260050 - d_acc: 0.59, - d_acc_enc: 0.59\n",
-      "Discriminator cost 54.03, Generator cost 5920, VAE Cost 3509, KL divergence cost 545.2\n",
-      "Saving a sample...\n",
-      "At iter: 400  -  dt: 0:00:00.371186 - d_acc: 0.47, - d_acc_enc: 0.50\n",
-      "Discriminator cost 73.59, Generator cost 2396, VAE Cost 2247, KL divergence cost 198.6\n",
-      "Saving a sample...\n",
-      "At iter: 600  -  dt: 0:00:00.378116 - d_acc: 0.66, - d_acc_enc: 0.62\n",
-      "Discriminator cost 49.52, Generator cost 686.4, VAE Cost 1286, KL divergence cost 67.42\n",
-      "Saving a sample...\n",
-      "At iter: 800  -  dt: 0:00:00.373615 - d_acc: 0.53, - d_acc_enc: 0.50\n",
-      "Discriminator cost 41.43, Generator cost 315.8, VAE Cost 1015, KL divergence cost 99.63\n",
-      "Saving a sample...\n",
-      "At iter: 1000  -  dt: 0:00:00.367530 - d_acc: 0.56, - d_acc_enc: 0.59\n",
-      "Discriminator cost 41.54, Generator cost 297, VAE Cost 742.2, KL divergence cost 53.33\n",
-      "Saving a sample...\n",
-      "Printing validation set histograms at epoch 0\n",
-      "ET Distribution plots are being printed...\n",
-      "Done\n",
-      "Resolution plots are being printed...\n",
-      "Done\n",
-      "Epoch: 1\n",
-      "At iter: 1200  -  dt: 0:00:00.298434 - d_acc: 0.72, - d_acc_enc: 0.72\n",
-      "Discriminator cost 41.07, Generator cost 247.4, VAE Cost 633.6, KL divergence cost 39.22\n",
-      "Saving a sample...\n",
-      "At iter: 1400  -  dt: 0:00:00.373918 - d_acc: 0.56, - d_acc_enc: 0.47\n",
-      "Discriminator cost 35.16, Generator cost 144.5, VAE Cost 616, KL divergence cost 41.35\n",
-      "Saving a sample...\n",
-      "At iter: 1600  -  dt: 0:00:00.370199 - d_acc: 0.44, - d_acc_enc: 0.44\n",
-      "Discriminator cost 47.92, Generator cost 110.3, VAE Cost 484.1, KL divergence cost 36.05\n",
-      "Saving a sample...\n",
-      "At iter: 1800  -  dt: 0:00:00.366162 - d_acc: 0.53, - d_acc_enc: 0.47\n",
-      "Discriminator cost 44.97, Generator cost 99.2, VAE Cost 376.2, KL divergence cost 30.15\n",
-      "Saving a sample...\n",
-      "At iter: 2000  -  dt: 0:00:00.372570 - d_acc: 0.53, - d_acc_enc: 0.41\n",
-      "Discriminator cost 38.9, Generator cost 108.8, VAE Cost 383.8, KL divergence cost 27.91\n",
-      "Saving a sample...\n",
-      "Printing validation set histograms at epoch 1\n",
-      "ET Distribution plots are being printed...\n",
-      "Done\n",
-      "Resolution plots are being printed...\n",
-      "Done\n",
-      "Epoch: 2\n",
-      "At iter: 2200  -  dt: 0:00:00.287552 - d_acc: 0.66, - d_acc_enc: 0.53\n",
-      "Discriminator cost 18.25, Generator cost 87.42, VAE Cost 334.6, KL divergence cost 28.26\n",
-      "Saving a sample...\n",
-      "At iter: 2400  -  dt: 0:00:00.366586 - d_acc: 0.44, - d_acc_enc: 0.44\n",
-      "Discriminator cost 34.34, Generator cost 82.36, VAE Cost 353.6, KL divergence cost 29.78\n",
-      "Saving a sample...\n",
-      "At iter: 2600  -  dt: 0:00:00.362463 - d_acc: 0.50, - d_acc_enc: 0.50\n",
-      "Discriminator cost 38.3, Generator cost 79.64, VAE Cost 326, KL divergence cost 27.11\n",
-      "Saving a sample...\n",
-      "At iter: 2800  -  dt: 0:00:00.363595 - d_acc: 0.47, - d_acc_enc: 0.47\n",
-      "Discriminator cost 33.89, Generator cost 79.25, VAE Cost 246, KL divergence cost 26.67\n",
-      "Saving a sample...\n",
-      "At iter: 3000  -  dt: 0:00:00.373816 - d_acc: 0.56, - d_acc_enc: 0.53\n",
-      "Discriminator cost 16.85, Generator cost 80.94, VAE Cost 293.6, KL divergence cost 27.16\n",
-      "Saving a sample...\n",
-      "Printing validation set histograms at epoch 2\n",
-      "ET Distribution plots are being printed...\n",
-      "Done\n",
-      "Resolution plots are being printed...\n",
-      "Done\n",
-      "Epoch: 3\n",
-      "At iter: 3200  -  dt: 0:00:00.300006 - d_acc: 0.53, - d_acc_enc: 0.53\n",
-      "Discriminator cost 23.1, Generator cost 82.69, VAE Cost 251.7, KL divergence cost 26.43\n",
-      "Saving a sample...\n",
-      "At iter: 3400  -  dt: 0:00:00.373295 - d_acc: 0.56, - d_acc_enc: 0.50\n",
-      "Discriminator cost 16.79, Generator cost 72.6, VAE Cost 221.8, KL divergence cost 26.54\n",
-      "Saving a sample...\n",
-      "At iter: 3600  -  dt: 0:00:00.372298 - d_acc: 0.38, - d_acc_enc: 0.38\n",
-      "Discriminator cost 38.19, Generator cost 71.64, VAE Cost 212.6, KL divergence cost 26.76\n",
-      "Saving a sample...\n",
-      "At iter: 3800  -  dt: 0:00:00.369248 - d_acc: 0.38, - d_acc_enc: 0.44\n",
-      "Discriminator cost 17.12, Generator cost 63.71, VAE Cost 223.1, KL divergence cost 25.36\n",
-      "Saving a sample...\n",
-      "At iter: 4000  -  dt: 0:00:00.367608 - d_acc: 0.50, - d_acc_enc: 0.44\n",
-      "Discriminator cost 21.59, Generator cost 84.74, VAE Cost 213.5, KL divergence cost 26.49\n",
-      "Saving a sample...\n",
-      "Printing validation set histograms at epoch 3\n",
-      "ET Distribution plots are being printed...\n",
-      "Done\n",
-      "Resolution plots are being printed...\n",
-      "Done\n",
-      "Model saved in path: HCAL_bycicleGAN_test35/HCAL_bycicleGAN_test35bicycle.ckpt\n",
-      "Per event simulation time 0:00:00.001866\n"
+      " Evaluate model on test set...\n",
+      "INFO:tensorflow:Restoring parameters from HCAL_bycicleGAN_test97/HCAL_bycicleGAN_test97bicycle.ckpt\n",
+      "Model restored.\n",
+      "Per event simulation time 0:00:00.002158\n",
+      "Generate another?n\n"
      ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
-       "<Figure size 720x576 with 3 Axes>"
+       "<Figure size 720x576 with 6 Axes>"
       ]
      },
      "metadata": {},
@@ -620,196 +639,254 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 55,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(6120.0, 1530.0)"
+      ]
+     },
+     "execution_count": 55,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "max_MC=train_reco.max()\n",
-    "max_NN=test_reco_NN.max()"
+    "train_reco[:,12:40,16:48,:].max(),train_reco[:,0:12,0:16,:].max()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 56,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "31.492105"
+      ]
+     },
+     "execution_count": 56,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "print('Max NN {0}, Max_MC {1}'.format(max_NN, max_MC, ))"
+    "test_reco.std()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 57,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "55.924515"
+      ]
+     },
+     "execution_count": 57,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "test_reco_NN_rescaled=(test_reco_NN/test_reco_NN.max())*max_MC"
+    "test_reco_NN.std()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 93,
    "metadata": {},
    "outputs": [],
    "source": [
-    "print(test_reco_NN_rescaled.max())"
+    "test_reco_MC_hist= test_reco.reshape(test_reco.shape[0],test_reco.shape[1]*test_reco.shape[2])\n",
+    "test_reco_MC_hist = np.sum(test_reco_MC_hist,axis=1)\n",
+    "max_MC_hist = np.max(test_reco_MC_hist)\n",
+    "\n",
+    "test_reco_NN_test=test_reco_NN/2.2\n",
+    "test_reco_NN_hist= test_reco_NN_test.reshape(test_reco_NN.shape[0],test_reco_NN.shape[1]*test_reco_NN.shape[2])\n",
+    "test_reco_NN_hist = np.sum(test_reco_NN_hist,axis=1)\n",
+    "max_NN_hist = np.max(test_reco_NN_hist)\n",
+    "\n",
+    "test_true_hist= test_true.reshape(test_true.shape[0],test_true.shape[1]*test_true.shape[2])\n",
+    "test_true_hist = np.sum(test_true_hist,axis=1)\n",
+    "max_true_hist = np.max(test_true_hist)\n",
+    "\n",
+    "#test_reco_NN_hist_rescaled=(test_reco_NN_hist/max_NN_hist)*max_MC_hist\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 94,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(27216.0, 21176.656)"
+      ]
+     },
+     "execution_count": 94,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "if preprocess:\n",
-    "    reco_MC_hist = denormalise(test_reco, min_reco, max_reco).reshape(test_reco.shape[0], test_reco.shape[1]*test_reco.shape[2])\n",
-    "    reco_MC_hist = np.sum(reco_MC_hist,axis=1)\n",
-    "    max_E=np.max(reco_MC_hist)\n",
-    "    \n",
-    "    reco_NN_hist = denormalise(test_reco_NN, min_reco, max_reco).reshape(test_reco_NN.shape[0], test_reco_NN.shape[1]*test_reco_NN.shape[2])\n",
-    "    reco_NN_hist = np.sum(reco_NN_hist,axis=1)\n",
-    "    max_NN = np.max(reco_NN_hist)\n",
-    "    \n",
-    "    true_hist = denormalise(test_true, min_reco, max_true).reshape(test_true.shape[0], test_true.shape[1]*test_true.shape[2])\n",
-    "    true_hist = np.sum(true_hist,axis=1)\n",
-    "    max_true_E=np.max(true_hist)\n",
-    "else:\n",
-    "    reco_MC_hist = test_reco.reshape(test_reco.shape[0], test_reco.shape[1]*test_reco.shape[2])\n",
-    "    reco_MC_hist = np.sum(reco_MC_hist,axis=1)\n",
-    "    max_E=np.max(reco_MC_hist)\n",
-    "    \n",
-    "    reco_NN_hist = test_reco_NN_rescaled.reshape(test_reco_NN_rescaled.shape[0], test_reco_NN.shape[1]*test_reco_NN.shape[2])\n",
-    "    reco_NN_hist = np.sum(reco_NN_hist,axis=1)\n",
-    "    max_NN = np.max(reco_NN_hist)\n",
-    "    \n",
-    "    true_hist = test_true.reshape(test_true.shape[0], test_true.shape[1]*test_true.shape[2])\n",
-    "    true_hist = np.sum(true_hist,axis=1)\n",
-    "    max_true_E=np.max(true_hist)"
+    "max_MC_hist, max_NN_hist"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 95,
    "metadata": {},
    "outputs": [],
    "source": [
-    "reco_NN_hist=(reco_NN_hist/reco_NN_hist.max())*reco_MC_hist.max()"
+    "diffNN = test_reco_NN_hist-test_true_hist\n",
+    "diffMC = test_reco_MC_hist-test_true_hist"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 96,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x360 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
-    "#if preprocess:\n",
-    "#    reco_MC_hist = denormalise(train_reco, min_reco, max_reco).reshape(train_reco.shape[0], train_reco.shape[1]*train_reco.shape[2])\n",
-    "#    reco_MC_hist = np.sum(reco_MC_hist,axis=1)\n",
-    "#    max_E=np.max(reco_MC_hist)\n",
-    "#    \n",
-    "#    reco_NN_hist = denormalise(test_reco_NN, min_reco, max_reco).reshape(test_reco_NN.shape[0], test_reco_NN.shape[1]*test_reco_NN.shape[2])\n",
-    "#    reco_NN_hist = np.sum(reco_NN_hist,axis=1)\n",
-    "#    max_NN = np.max(reco_NN_hist)\n",
-    "#    \n",
-    "#    true_hist = denormalise(train_true, min_true, max_true).reshape(train_true.shape[0], train_true.shape[1]*train_true.shape[2])\n",
-    "#    true_hist = np.sum(true_hist,axis=1)\n",
-    "#    max_true_E=np.max(true_hist)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "diffNN = reco_NN_hist-true_hist\n",
-    "diffMC = reco_MC_hist-true_hist\n",
     "\n",
     "plt.subplot(1,2,1)\n",
     "plt.tick_params(labelsize=15);\n",
-    "h_reco = plt.hist(diffMC,bins=30, edgecolor='black');\n",
-    "plt.xlabel('ET recoMC - ET true', fontsize=15)\n",
+    "h_reco = plt.hist(diffMC/1000,bins=30,edgecolor='black');\n",
+    "plt.xlabel('ET recoMC - ET tracking (GeV)', fontsize=15)\n",
     "plt.ylabel('dN/dETdiff', fontsize=15)\n",
     "plt.title('Resolution as simulated by MC', fontsize=15)\n",
     "plt.subplot(1,2,2)\n",
     "plt.tick_params(labelsize=15);\n",
-    "h_nn = plt.hist(diffNN,bins=30, edgecolor='black');\n",
-    "plt.xlabel('ET recoNN - ET true', fontsize=15)\n",
+    "h_nn = plt.hist(diffNN/1000,bins=30, edgecolor='black');\n",
+    "plt.xlabel('ET recoNN - ET tracking (GeV)', fontsize=15)\n",
     "plt.ylabel('dN/dETdiff', fontsize=15)\n",
     "plt.title('Resolution as simulated by NN', fontsize=15)\n",
     "fig = plt.gcf()\n",
-    "fig.set_size_inches(12,4)\n",
+    "fig.set_size_inches(12,5)\n",
     "plt.savefig(PATH+'/resolution.eps', format='eps', dpi=100)\n",
     "\n",
-    "\n",
-    "plt.hist(diffNN, bins=30);"
+    "\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 97,
    "metadata": {},
-   "outputs": [],
-   "source": [
-    "diffNN.mean(), diffNN.std()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "diffMC.mean(), diffMC.std()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "np.where(true_hist==0)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1296x432 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "plt.subplot(1,3,1)\n",
     "plt.tick_params(labelsize=12);\n",
-    "h_reco = plt.hist(true_hist/1000,bins=30, edgecolor='black');\n",
+    "h_reco = plt.hist(test_true_hist/1000,bins=30, edgecolor='black');\n",
     "plt.xlabel('E_T (GeV)', fontsize=15)\n",
     "plt.ylabel('dN/dE_T', fontsize=15)\n",
-    "plt.title('Pion True E_T', fontsize=15)\n",
+    "plt.title('Pion E_T from tracking', fontsize=15)\n",
     "plt.subplot(1,3,2)\n",
     "plt.tick_params(labelsize=12);\n",
-    "h_reco = plt.hist(reco_MC_hist/1000,bins=30, edgecolor='black');\n",
+    "h_reco = plt.hist(test_reco_MC_hist/1000,bins=30,  edgecolor='black');\n",
     "plt.xlabel('E_T (GeV)', fontsize=15)\n",
     "\n",
-    "plt.title('Pion Reco E_T from MC', fontsize=15)\n",
+    "plt.title('Pion Reco E_T from Geant4', fontsize=15)\n",
     "plt.subplot(1,3,3)\n",
     "plt.tick_params(labelsize=12);\n",
-    "h_nn = plt.hist(reco_NN_hist/1000,bins=30, edgecolor='black');\n",
+    "h_nn = plt.hist(test_reco_NN_hist/1000, bins=30,  edgecolor='black');\n",
     "plt.xlabel('E_T (GeV)', fontsize=15)\n",
     "\n",
     "plt.title('Pion Reco E_T from BicycleGAN', fontsize=15)\n",
     "fig = plt.gcf()\n",
-    "fig.set_size_inches(16,4)\n",
+    "fig.set_size_inches(18,6)\n",
     "plt.savefig(PATH+'/distribution.eps', format='eps', dpi=100)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 98,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
-    "diff=plt.bar(np.arange(0, 30), \n",
+    "plt.hist2d(test_true_hist/1000,test_reco_NN_hist/1000,bins=30);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 99,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.hist2d(test_true_hist/1000,test_reco_MC_hist/1000,bins=30);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 100,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "idx = np.arange(0,110, step=110/30)\n",
+    "diff=plt.bar(idx, \n",
     "             height=(h_nn[0]-h_reco[0]), edgecolor='black', \n",
-    "             linewidth=1, color='lightblue',width = 1, align = 'edge') \n",
+    "             linewidth=1, color='lightblue',width = 3.4, align = 'edge') \n",
     "plt.xlabel('E (GeV)')\n",
     "plt.ylabel('dN/dE')\n",
     "plt.title(\"NN output - MC output\")\n",
@@ -820,23 +897,76 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 138,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "32.47053"
+      ]
+     },
+     "execution_count": 138,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "test_reco_NN.mean()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 139,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "11.406392"
+      ]
+     },
+     "execution_count": 139,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "test_reco.mean()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 140,
    "metadata": {
-    "scrolled": true
+    "scrolled": false
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 576x432 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "four_cells_diff_NN= np.array([\n",
-    "       four_cells(test_reco_NN_rescaled[i]).sum() - test_true[i].sum()  for i in range(len(test_reco))\n",
+    "       four_cells(test_reco_NN_test[i]).sum()- test_true[i].sum()  for i in range(len(test_reco))\n",
     "])    \n",
     "four_cells_diff_MC= np.array([\n",
     "       four_cells(test_reco[i]).sum() - test_true[i].sum() for i in range(len(test_reco))\n",
     "])\n",
-    "plt.hist(four_cells_diff_NN, bins=30, label = 'NN-ET_true')\n",
-    "plt.hist(four_cells_diff_MC, bins=30, label = 'MC-ET_true', histtype='step')\n",
+    "plt.hist(four_cells_diff_NN/1000, bins=30, range=(-200,30), label = 'NN max 4 cells ET - E tracking',histtype='step')\n",
+    "plt.hist(four_cells_diff_MC/1000, bins=30, range=(-200,30), label = 'MC max 4 cells ET - E tracking', histtype='step')\n",
     "plt.legend(loc=2);\n",
     "plt.xlabel('Sum of 4 max cells ET  - ET true (GeV)')\n",
     "plt.ylabel('dN/dET')\n",
+    "fig = plt.gcf()\n",
+    "fig.set_size_inches(8,6)\n",
     "plt.savefig(PATH+'/four_cells_diff_combined.eps', format='eps', dpi=100)"
    ]
   },
@@ -849,15 +979,19 @@
    "outputs": [],
    "source": [
     "four_cells_diff= four_cells_diff_NN-four_cells_diff_MC\n",
-    "plt.hist(four_cells_diff_NN-four_cells_diff_MC, bins=20, label = 'MC-NN');\n",
+    "plt.title('4 max_cells ET from Geant4  - 4 max cells ET from NN (GeV)')\n",
+    "plt.hist((four_cells_diff)/1000, bins=30, label = 'MC-NN',  histtype='step');\n",
+    "plt.xlabel('E_T (GeV)')\n",
     "plt.legend();\n",
     "print('four cells diff mean {0}, std {1}'.format(four_cells_diff.mean(), four_cells_diff.std()))\n",
+    "fig = plt.gcf()\n",
+    "fig.set_size_inches(8,6)\n",
     "plt.savefig(PATH+'/four_cells_diff.eps', format='eps', dpi=100)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 142,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -889,7 +1023,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 143,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -910,13 +1044,6 @@
    "metadata": {},
    "outputs": [],
    "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {