keras_g3_cae_true-table_merged-cl.ana.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import uproot4\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.patches as patches\n",
    "from matplotlib.collections import PatchCollection\n",
    "from matplotlib import cm\n",
    "from matplotlib.colors import LogNorm, Normalize\n",
    "import os\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import itertools\n",
    "\n",
    "from event_display import  build_calorimeter_section"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "pics_prefix = os.path.join(\"plots\", \"v1_\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time open 0.3551018238067627\n",
      "Time split 0.2823452949523926\n",
      "Inputs shape original = (10000, 11, 11)\n",
      "max hit value = 0.7586345789791428\n",
      "Merging clusters...\n"
     ]
    }
   ],
   "source": [
    "from data_tools import merge_clusters\n",
    "from geant3_parser import build_true_answers_train_set\n",
    "from geant3_parser import Geant3DataFile\n",
    "\n",
    "def norm_func(e):\n",
    "    return np.float64(np.log(e) / 11)\n",
    "\n",
    "file_name = os.path.join('data', 'shower_geant3_new.dat')\n",
    "data_file = Geant3DataFile(file_name, skip_lines=3)\n",
    "\n",
    "events_to_read = 5000\n",
    "inputs, answers, values = build_true_answers_train_set(data_file, events_to_read*2, norm_func=norm_func, rnd_shift=((-2,2), (-2,2)))\n",
    "\n",
    "print(f\"Inputs shape original = {np.shape(inputs)}\")\n",
    "print(f\"max hit value = {np.max(inputs)}\")\n",
    "\n",
    "inputs = np.reshape(inputs, (len(inputs), 11, 11, 1))  # -1 => autodetermine\n",
    "answers = np.reshape(answers, (len(answers), 11, 11, 1))  # -1 => autodetermine\n",
    "# # Pad with 1 row and column of zeroes, so it divides by 2\n",
    "inputs = np.pad(inputs, ((0,0), (0,1), (0,1), (0,0)), mode='constant', constant_values=0)\n",
    "answers = np.pad(answers, ((0,0), (0,1), (0,1), (0,0)), mode='constant', constant_values=0)\n",
    "\n",
    "# Merge clusters\n",
    "print(\"Merging clusters...\")\n",
    "inputs, answers = merge_clusters(inputs, answers)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def display_event(event_data, fig=None, ax=None, cal_size=12, cell_size=1):\n",
    "    # constants\n",
    "    size_x = cell_size\n",
    "    size_y = cell_size\n",
    "    dx = size_x / 2.0\n",
    "    dy = size_y / 2.0\n",
    "\n",
    "    # go through all cells and calculate their centers\n",
    "    centers = np.arange(-cal_size/2.0 + cell_size/2, cal_size/2 + cell_size/2, 1)\n",
    "    positions = []\n",
    "    for y_iter in range(cal_size):\n",
    "        for x_iter in range(cal_size):\n",
    "            positions.append((centers[x_iter], centers[y_iter]))\n",
    "\n",
    "    # plot calorimeter with empty cells\n",
    "    if not fig or not ax:\n",
    "        fig, ax = plt.subplots()\n",
    "    build_calorimeter_section(ax, positions, 1, 1)\n",
    "\n",
    "    # Create a heat map\n",
    "    norm = LogNorm()\n",
    "    norm.autoscale(event_data)\n",
    "    cmap = cm.get_cmap('inferno')\n",
    "\n",
    "    # Convert data to rectangular patches    \n",
    "    module_rects = []\n",
    "    for y_iter in range(cal_size):\n",
    "        for x_iter in range(cal_size):\n",
    "            x = centers[x_iter]\n",
    "            y = centers[y_iter]\n",
    "            weight = event_data[x_iter][y_iter][0]\n",
    "            #print(x,y,weight)\n",
    "            patch = patches.Rectangle((x-dx, y-dy), size_x, size_y, edgecolor='black', facecolor=cmap(norm(weight)))\n",
    "            module_rects.append(patch)\n",
    "\n",
    "    # plot rectangles with data\n",
    "    col = PatchCollection(module_rects, match_original=True)\n",
    "    ax.add_collection(col)\n",
    "\n",
    "    # plot heatmap legend\n",
    "    sm = plt.cm.ScalarMappable(cmap=cmap, norm=norm)\n",
    "    sm.set_array(event_data)\n",
    "    fig.colorbar(sm)\n",
    "    \n",
    "    return fig, ax\n",
    "\n",
    "\n",
    "def display_event_comparison(left_data, right_data, fig=None, cal_size=12, cell_size=1):\n",
    "    # constants\n",
    "    size_x = cell_size\n",
    "    size_y = cell_size\n",
    "    dx = size_x / 2.0\n",
    "    dy = size_y / 2.0\n",
    "\n",
    "    # go through all cells and calculate their centers\n",
    "    centers = np.arange(-cal_size/2.0 + cell_size/2, cal_size/2 + cell_size/2, 1)\n",
    "    positions = []\n",
    "    for y_iter in range(cal_size):\n",
    "        for x_iter in range(cal_size):\n",
    "            positions.append((centers[x_iter], centers[y_iter]))\n",
    "\n",
    "    # plot calorimeter with empty cells\n",
    "    if not fig:\n",
    "        fig = plt.figure(figsize=(12,9))\n",
    "\n",
    "    ax_left, ax_right = fig.subplots(1, 2)\n",
    "    build_calorimeter_section(ax_left, positions, 1, 1)\n",
    "    build_calorimeter_section(ax_right, positions, 1, 1)\n",
    "\n",
    "    # Create a heat map\n",
    "    norm = LogNorm()    \n",
    "    norm.autoscale(np.vstack((left_data,right_data)))\n",
    "    cmap = cm.get_cmap('inferno')\n",
    "\n",
    "    def display_event_values(data, ax):\n",
    "        # Convert data to rectangular patches    \n",
    "        module_rects = []\n",
    "        for y_iter in range(cal_size):\n",
    "            for x_iter in range(cal_size):\n",
    "                x = centers[x_iter]\n",
    "                y = centers[y_iter]\n",
    "                weight = data[x_iter][y_iter][0]\n",
    "                #print(x,y,weight)\n",
    "                patch = patches.Rectangle((x-dx, y-dy), size_x, size_y, edgecolor='black', facecolor=cmap(norm(weight)))\n",
    "                module_rects.append(patch)\n",
    "\n",
    "        # plot rectangles with data\n",
    "        col = PatchCollection(module_rects, match_original=True)\n",
    "        ax.add_collection(col)\n",
    "\n",
    "    display_event_values(left_data, ax_left)\n",
    "    display_event_values(right_data, ax_right)\n",
    "\n",
    "    # plot heatmap legend\n",
    "    sm = plt.cm.ScalarMappable(cmap=cmap, norm=norm)\n",
    "    sm.set_array(np.vstack((left_data,right_data)))\n",
    "    fig.colorbar(sm, orientation=\"horizontal\", ax=[ax_left,ax_right], extend=\"both\")\n",
    "\n",
    "    ax_left.set_aspect('equal', 'box')\n",
    "    ax_right.set_aspect('equal', 'box')\n",
    "    \n",
    "    return fig, ax_left, ax_right\n",
    "\n",
    "def get_bin_centers(bins):\n",
    "    \"\"\"Calculates bin centers out of bin boundaries\"\"\"\n",
    "    assert len(bins) >= 2\n",
    "    return bins[:-1] + (bins[1:] - bins[:-1]) / 2\n",
    "\n",
    "# Prints 11x11 cells event\n",
    "def print_event(table):\n",
    "    if not len(table):\n",
    "        print(\"EMPTY TABLE\")\n",
    "        return\n",
    "    \n",
    "    split_line = \"\"\n",
    "    for irow, row in enumerate(table):\n",
    "        if irow == 0:\n",
    "            # First row => making title\n",
    "            col_names = \"ROW   \" +  \" \".join([f\"{column_num:<5}\" for column_num in range(len(row))])\n",
    "            spaces = int((len(col_names) - len(\"COLUMNS\"))/2)\n",
    "            header = \"{0}COLUMNS{0}\".format(spaces*\" \")\n",
    "            split_line = \"-\"*len(col_names)\n",
    "            print()            \n",
    "            print(header)\n",
    "            print(col_names)\n",
    "            print(split_line)\n",
    "        cells = f\"{irow:<4}| \" + \" \".join([f\"{cell[0]*11:<5.2}\" for cell in row])\n",
    "        print(cells)\n",
    "\n",
    "    # Footer\n",
    "    print(split_line)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-05-18 17:47:32.575498: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcudart.so.10.1\n",
      "2022-05-18 17:47:33.752473: I tensorflow/compiler/jit/xla_cpu_device.cc:41] Not creating XLA devices, tf_xla_enable_xla_devices not set\n",
      "2022-05-18 17:47:33.753066: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcuda.so.1\n",
      "2022-05-18 17:47:33.809919: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1720] Found device 0 with properties: \n",
      "pciBusID: 0000:0a:00.0 name: NVIDIA GeForce GTX 1080 Ti computeCapability: 6.1\n",
      "coreClock: 1.683GHz coreCount: 28 deviceMemorySize: 10.91GiB deviceMemoryBandwidth: 451.17GiB/s\n",
      "2022-05-18 17:47:33.809957: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcudart.so.10.1\n",
      "2022-05-18 17:47:33.811661: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcublas.so.10\n",
      "2022-05-18 17:47:33.811711: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcublasLt.so.10\n",
      "2022-05-18 17:47:33.813384: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcufft.so.10\n",
      "2022-05-18 17:47:33.813653: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcurand.so.10\n",
      "2022-05-18 17:47:33.815418: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcusolver.so.10\n",
      "2022-05-18 17:47:33.816486: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcusparse.so.10\n",
      "2022-05-18 17:47:33.820085: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcudnn.so.7\n",
      "2022-05-18 17:47:33.820566: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1862] Adding visible gpu devices: 0\n",
      "2022-05-18 17:47:33.820959: I tensorflow/core/platform/cpu_feature_guard.cc:142] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  SSE4.1 SSE4.2 AVX AVX2 FMA\n",
      "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2022-05-18 17:47:33.822661: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1720] Found device 0 with properties: \n",
      "pciBusID: 0000:0a:00.0 name: NVIDIA GeForce GTX 1080 Ti computeCapability: 6.1\n",
      "coreClock: 1.683GHz coreCount: 28 deviceMemorySize: 10.91GiB deviceMemoryBandwidth: 451.17GiB/s\n",
      "2022-05-18 17:47:33.822700: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcudart.so.10.1\n",
      "2022-05-18 17:47:33.822720: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcublas.so.10\n",
      "2022-05-18 17:47:33.822733: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcublasLt.so.10\n",
      "2022-05-18 17:47:33.822746: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcufft.so.10\n",
      "2022-05-18 17:47:33.822758: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcurand.so.10\n",
      "2022-05-18 17:47:33.822770: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcusolver.so.10\n",
      "2022-05-18 17:47:33.822783: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcusparse.so.10\n",
      "2022-05-18 17:47:33.822795: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcudnn.so.7\n",
      "2022-05-18 17:47:33.823126: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1862] Adding visible gpu devices: 0\n",
      "2022-05-18 17:47:33.823161: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcudart.so.10.1\n",
      "2022-05-18 17:47:34.159296: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1261] Device interconnect StreamExecutor with strength 1 edge matrix:\n",
      "2022-05-18 17:47:34.159326: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1267]      0 \n",
      "2022-05-18 17:47:34.159331: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1280] 0:   N \n",
      "2022-05-18 17:47:34.159898: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1406] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:0 with 9447 MB memory) -> physical GPU (device: 0, name: NVIDIA GeForce GTX 1080 Ti, pci bus id: 0000:0a:00.0, compute capability: 6.1)\n",
      "2022-05-18 17:47:34.160114: I tensorflow/compiler/jit/xla_gpu_device.cc:99] Not creating XLA devices, tf_xla_enable_xla_devices not set\n",
      "2022-05-18 17:47:34.633904: I tensorflow/compiler/mlir/mlir_graph_optimization_pass.cc:116] None of the MLIR optimization passes are enabled (registered 2)\n",
      "2022-05-18 17:47:34.653475: I tensorflow/core/platform/profile_utils/cpu_utils.cc:112] CPU Frequency: 3493250000 Hz\n",
      "2022-05-18 17:47:34.748387: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcudnn.so.7\n",
      "2022-05-18 17:47:35.165164: W tensorflow/stream_executor/gpu/asm_compiler.cc:63] Running ptxas --version returned 256\n",
      "2022-05-18 17:47:35.204303: W tensorflow/stream_executor/gpu/redzone_allocator.cc:314] Internal: ptxas exited with non-zero error code 256, output: \n",
      "Relying on driver to perform ptx compilation. \n",
      "Modify $PATH to customize ptxas location.\n",
      "This message will be only logged once.\n",
      "2022-05-18 17:47:35.592071: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcublas.so.10\n"
     ]
    }
   ],
   "source": [
    "# Load NN model\n",
    "from keras.models import load_model\n",
    "model_file_name = os.path.join(\"trained_models\", \"keras_g3_cae_true-table_merged-cl.hd5\")\n",
    "model = load_model(model_file_name)\n",
    "\n",
    "# Run ML on data\n",
    "ml_events = model.predict(inputs)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "max true 3029.0 max eval 4514.76171875\n",
      "sum true 6087.0 sum eval 5558.7861328125\n"
     ]
    },
    {
     "data": {
      "text/plain": "<Figure size 864x648 with 3 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "event_number = 7\n",
    "true_event = np.exp(inputs[event_number]*11)\n",
    "ml_event = np.exp(ml_events[event_number]*11)\n",
    "ml_event[ml_event<2] = 0\n",
    "true_event[true_event<5] = 0\n",
    "display_event_comparison(true_event, ml_event)\n",
    "print(f\"max true {np.max(true_event)} max eval {np.max(ml_event)}\")\n",
    "print(f\"sum true {np.sum(true_event)} sum eval {np.sum(ml_event)}\")"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "outputs": [],
   "source": [],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "a707b6ce8c685eb936424fcc3009d4b4b7a52543c4db09380a3fc49186ceb509"
  },
  "kernelspec": {
   "display_name": "Python 3.7.11 ('base')",
   "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.9.12"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}