{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import sparseconvnet as scn\n",
    "import numpy as np\n",
    "import csv\n",
    "import uproot\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import argparse\n",
    "import math\n",
    "import re\n",
    "import sys\n",
    "from timeit import default_timer as timer\n",
    "\n",
    "import os\n",
    "import shutil\n",
    "\n",
    "from tqdm.notebook import tqdm\n",
    "import pickle\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_name = \"train_v1\"\n",
    "\n",
    "train_test_file = \"voxelized_toy_data_v1.pkl\"\n",
    "train_frac = 1.\n",
    "\n",
    "start_epoch = 0\n",
    "num_epochs = 100\n",
    "\n",
    "resolution = 1\n",
    "loose_cut = 2\n",
    "lr0 = 1e-5\n",
    "lr_decay = 0.05\n",
    "\n",
    "vertex_assign_cut = 0.0\n",
    "\n",
    "nIn = 1\n",
    "# Use the GPU if there is one and sparseconvnet can use it, otherwise CPU\n",
    "use_cuda = torch.cuda.is_available() and scn.SCN.is_cuda_build()\n",
    "# use_cuda = False\n",
    "device = 'cuda:0' if use_cuda else 'cpu'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ResNet(nn.Module):\n",
    "    '''\n",
    "    dimention\n",
    "    '''\n",
    "    def __init__(self, dimension = 3, device = 'cuda'):\n",
    "        nn.Module.__init__(self)\n",
    "        self.sparseModel = scn.Sequential(\n",
    "            scn.SubmanifoldConvolution(dimension, nIn=1, nOut=8, filter_size=3, bias=False),\n",
    "            # scn.MaxPooling(dimension, pool_size=3, pool_stride=2),\n",
    "            scn.MaxPooling(dimension, pool_size=2, pool_stride=2),\n",
    "            scn.SparseResNet(dimension, 8, [\n",
    "                        #['b', 8, 2, 1],\n",
    "                        #['b', 16, 2, 2],\n",
    "                        #['b', 24, 2, 2],\n",
    "                        ['b', 32, 2, 2]]),\n",
    "            scn.Convolution(dimension,  nIn=32, nOut=64, filter_size=5, filter_stride=1, bias=False),\n",
    "            # scn.BatchNormReLU(64),\n",
    "            scn.SparseToDense(dimension, 64)).to(device)\n",
    "        self.spatial_size= self.sparseModel.input_spatial_size(torch.LongTensor([1]*dimension))\n",
    "        self.inputLayer = scn.InputLayer(dimension,self.spatial_size,mode=4)\n",
    "        self.linear = nn.Linear(64, 1).to(device)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.inputLayer(x)\n",
    "        x = self.sparseModel(x)\n",
    "        x = x.view(-1, 64)\n",
    "        x = self.linear(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def scheduler_exp(optimizer, lr0, gamma, epoch):\n",
    "    lr = lr0*math.exp(-gamma*epoch)\n",
    "    for param_group in optimizer.param_groups:\n",
    "        param_group['lr'] = lr\n",
    "    return optimizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(train_test_file, \"rb\") as f:\n",
    "    all_dics, true_vtxs, all_angles, all_e_dirs, all_p_dirs, all_e_energies, all_p_energies = pickle.load(f)\n",
    "\n",
    "\n",
    "train_index = round(len(all_dics) * train_frac)\n",
    "\n",
    "train_dics = all_dics[:train_index]\n",
    "#test_dics = all_dics[train_index:]\n",
    "\n",
    "train_angles = all_angles[:train_index]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "path = \"train_files/\" + train_name\n",
    "if os.path.exists(path):\n",
    "    shutil.rmtree(path)\n",
    "\n",
    "os.mkdir(path)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.set_num_threads(1)\n",
    "\n",
    "model = ResNet(dimension=3, device=device)\n",
    "model.train()\n",
    "\n",
    "criterion = nn.MSELoss().to(device)\n",
    "\n",
    "# optimizer = optim.Adam(model.parameters(), lr=lr0)\n",
    "optimizer = optim.SGD(model.parameters(), lr=lr0, momentum=0.9, weight_decay=0.0005)\n",
    "\n",
    "outfile_loss = open(path + '/loss.csv','a+')\n",
    "outfile_log = open(path + \"/log\", \"a+\")\n",
    "\n",
    "print('lr: {:.2e}*exp-{:.2e}*epoch start: {} train_index: {} device: {} nIn: {} resolution:{} loose_cut: {}'.format(\n",
    "        lr0, lr_decay, start_epoch, train_index, device, nIn, resolution, loose_cut\n",
    "    ), file=outfile_log, flush=True)\n",
    "print('train_test_file: {} '.format(\n",
    "    train_test_file\n",
    "), file=outfile_log, flush=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c8bf928688ab4cf492a633f076e04172",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/100 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0  epoch_loss:  34.47136243626301\n",
      "1  epoch_loss:  52.18174560251646\n",
      "2  epoch_loss:  107.38114540145034\n",
      "3  epoch_loss:  145.43948320949858\n",
      "4  epoch_loss:  1650.826270330872\n",
      "5  epoch_loss:  46.11272055404697\n",
      "6  epoch_loss:  4.888167758055715\n",
      "7  epoch_loss:  4.815167440097198\n",
      "8  epoch_loss:  4.781113420739075\n",
      "9  epoch_loss:  4.7664207829391785\n",
      "10  epoch_loss:  4.74539823016238\n",
      "11  epoch_loss:  4.734203832420064\n",
      "12  epoch_loss:  4.718810319808995\n",
      "13  epoch_loss:  4.707294648009679\n",
      "14  epoch_loss:  4.696910591208507\n",
      "15  epoch_loss:  4.683524145508386\n",
      "16  epoch_loss:  4.67123756648499\n",
      "17  epoch_loss:  4.665681323553031\n",
      "18  epoch_loss:  4.657601034672666\n",
      "19  epoch_loss:  4.6494481159699035\n",
      "20  epoch_loss:  4.639980512210968\n",
      "21  epoch_loss:  4.575454176472537\n",
      "22  epoch_loss:  4.555821801105878\n",
      "23  epoch_loss:  4.549440746570557\n",
      "24  epoch_loss:  4.5414464151511424\n",
      "25  epoch_loss:  4.537680577202423\n",
      "26  epoch_loss:  4.534584557836297\n",
      "27  epoch_loss:  4.528850428144324\n",
      "28  epoch_loss:  4.5210152812442175\n",
      "29  epoch_loss:  4.518750337203073\n",
      "30  epoch_loss:  4.515979877904158\n",
      "31  epoch_loss:  4.512897198756036\n",
      "32  epoch_loss:  4.509010593001221\n",
      "33  epoch_loss:  4.504654717756239\n",
      "34  epoch_loss:  4.502572535724539\n",
      "35  epoch_loss:  4.498983256258725\n",
      "36  epoch_loss:  4.495160802052851\n",
      "37  epoch_loss:  4.492525281499184\n",
      "38  epoch_loss:  4.487848694627246\n",
      "39  epoch_loss:  4.486885002894269\n",
      "40  epoch_loss:  4.48461178276375\n",
      "41  epoch_loss:  4.480680757174923\n",
      "42  epoch_loss:  4.478968967614492\n",
      "43  epoch_loss:  4.477192615378954\n",
      "44  epoch_loss:  4.474563690317154\n",
      "45  epoch_loss:  4.472732199556049\n",
      "46  epoch_loss:  4.470647265361549\n",
      "47  epoch_loss:  4.468922526395545\n",
      "48  epoch_loss:  4.46723783995003\n",
      "49  epoch_loss:  4.465321907566249\n",
      "50  epoch_loss:  4.462743994632547\n",
      "51  epoch_loss:  4.462206040256206\n",
      "52  epoch_loss:  4.459858207763318\n",
      "53  epoch_loss:  4.459035031921303\n",
      "54  epoch_loss:  4.457976237285038\n",
      "55  epoch_loss:  4.45609806253924\n",
      "56  epoch_loss:  4.455374477334772\n",
      "57  epoch_loss:  4.454525379222105\n",
      "58  epoch_loss:  4.4527675924036885\n",
      "59  epoch_loss:  4.451799672613561\n",
      "60  epoch_loss:  4.450753999046356\n",
      "61  epoch_loss:  4.449650999482401\n",
      "62  epoch_loss:  4.4485880549054855\n",
      "63  epoch_loss:  4.448019092318646\n",
      "64  epoch_loss:  4.447365622701909\n",
      "65  epoch_loss:  4.44628954991822\n",
      "66  epoch_loss:  4.445601630679448\n",
      "67  epoch_loss:  4.4444790331817785\n",
      "68  epoch_loss:  4.444130081616095\n",
      "69  epoch_loss:  4.443126252959701\n",
      "70  epoch_loss:  4.44281126763417\n",
      "71  epoch_loss:  4.442360073640884\n",
      "72  epoch_loss:  4.441385587306286\n",
      "73  epoch_loss:  4.441006177523377\n",
      "74  epoch_loss:  4.4405768259439355\n",
      "75  epoch_loss:  4.439907366851912\n",
      "76  epoch_loss:  4.439528184635492\n",
      "77  epoch_loss:  4.439278642137651\n",
      "78  epoch_loss:  4.438606015075493\n",
      "79  epoch_loss:  4.438183704256517\n",
      "80  epoch_loss:  4.4378248634111515\n",
      "81  epoch_loss:  4.437407607480054\n",
      "82  epoch_loss:  4.436975683627679\n",
      "83  epoch_loss:  4.436698220499238\n",
      "84  epoch_loss:  4.436217530155773\n",
      "85  epoch_loss:  4.436123480943934\n",
      "86  epoch_loss:  4.435847207936604\n",
      "87  epoch_loss:  4.435379333350284\n",
      "88  epoch_loss:  4.435284151290034\n",
      "89  epoch_loss:  4.435051310760173\n",
      "90  epoch_loss:  4.434656441217157\n",
      "91  epoch_loss:  4.434562712896877\n",
      "92  epoch_loss:  4.434371380182711\n",
      "93  epoch_loss:  4.43404298023961\n",
      "94  epoch_loss:  4.433908703205816\n",
      "95  epoch_loss:  4.433757271255672\n",
      "96  epoch_loss:  4.43351362085923\n",
      "97  epoch_loss:  4.433403469874975\n",
      "98  epoch_loss:  4.4331843799991475\n",
      "99  epoch_loss:  4.433070441806194\n"
     ]
    }
   ],
   "source": [
    "all_epoch_losses = []\n",
    "\n",
    "#all_pred_angles = [] # for one event training\n",
    "\n",
    "final_preds = []\n",
    "final_truths = []\n",
    "\n",
    "def plot_SCT(x, q):\n",
    "    fig = plt.figure()\n",
    "    ax = plt.subplot(111)\n",
    "    img = ax.scatter(x[:,0], x[:,2], c=q, cmap=\"jet\", alpha=1.0)\n",
    "    fig.colorbar(img)\n",
    "    plt.show()\n",
    "\n",
    "for epoch in tqdm(range(start_epoch, start_epoch + num_epochs), desc=\"Epochs\"):\n",
    "    optimizer = scheduler_exp(optimizer, lr0, lr_decay, epoch)\n",
    "    epoch_loss = 0\n",
    "    optimizer.zero_grad()\n",
    "    \n",
    "    if len(train_dics) > 1000: \n",
    "        gen = tqdm(enumerate(train_dics), total=len(train_dics), leave=False, desc=\"Training events\")\n",
    "    else:\n",
    "        gen = enumerate(train_dics)\n",
    "    \n",
    "    for i, dic in gen: # looping over training events     \n",
    "        #if i == 0: continue\n",
    "        charges_list = list(dic.values())\n",
    "        coords = torch.LongTensor(list(dic.keys()))\n",
    "        charges = torch.FloatTensor(np.array(charges_list).reshape(len(charges_list), 1)).to(device)\n",
    "        # plot_SCT(coords, charges.cpu())\n",
    "        prediction = model([coords, charges])\n",
    "        pred_angle_conf = torch.FloatTensor(prediction.cpu().detach().numpy())\n",
    "        true_angle_conf = torch.FloatTensor(np.array(train_angles[i] / 180.).reshape((1,1))) # converting to range -1 to 0\n",
    "        loss = criterion(prediction, true_angle_conf.to(device))\n",
    "        # print(epoch, i, loss.cpu().detach().numpy(), 'pred: ',pred_angle_conf[0,0], 'true: ', true_angle_conf[0,0])\n",
    "        epoch_loss += loss.item()\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        if epoch == start_epoch + num_epochs - 1: # final training round, converting back to degrees\n",
    "            final_preds.append(180. * pred_angle_conf.numpy())\n",
    "            final_truths.append(180. * true_angle_conf.numpy())\n",
    "    print(epoch, ' epoch_loss: ', epoch_loss)        \n",
    "    if num_epochs < 100:\n",
    "        torch.save(model.state_dict(), path + '/CP{}.pth'.format(epoch))\n",
    "    \n",
    "    all_epoch_losses.append(epoch_loss)\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10,7))\n",
    "plt.plot(range(num_epochs), all_epoch_losses)\n",
    "plt.ylabel(\"total loss\")\n",
    "plt.xlabel(\"epoch\")\n",
    "plt.yscale(\"log\")\n",
    "plt.show()\n",
    "\n",
    "\"\"\"\n",
    "plt.figure(figsize=(10,7))\n",
    "plt.plot(range(num_epochs), all_pred_angles)\n",
    "plt.ylabel(f\"predicted angle (true = {all_angles[0]})\")\n",
    "plt.xlabel(\"epoch\")\n",
    "#plt.yscale(\"log\")\n",
    "plt.show()\n",
    "\"\"\"\n",
    "\n",
    "plt.figure(figsize=(10,7))\n",
    "plt.scatter(final_truths, final_preds)\n",
    "plt.ylabel(\"predicted opening angles\")\n",
    "plt.xlabel(\"true opening angles\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([[141.75325]], dtype=float32),\n",
       " array([[94.55261]], dtype=float32),\n",
       " array([[94.55241]], dtype=float32),\n",
       " array([[94.55222]], dtype=float32),\n",
       " array([[94.55206]], dtype=float32),\n",
       " array([[94.55191]], dtype=float32),\n",
       " array([[94.55178]], dtype=float32),\n",
       " array([[94.55167]], dtype=float32),\n",
       " array([[94.551544]], dtype=float32),\n",
       " array([[94.55144]], dtype=float32),\n",
       " array([[94.551346]], dtype=float32),\n",
       " array([[45.905743]], dtype=float32),\n",
       " array([[94.551186]], dtype=float32),\n",
       " array([[107.633316]], dtype=float32),\n",
       " array([[94.55109]], dtype=float32),\n",
       " array([[97.5194]], dtype=float32),\n",
       " array([[93.07583]], dtype=float32),\n",
       " array([[66.99821]], dtype=float32),\n",
       " array([[82.892586]], dtype=float32),\n",
       " array([[94.55132]], dtype=float32),\n",
       " array([[94.55143]], dtype=float32),\n",
       " array([[94.551544]], dtype=float32),\n",
       " array([[94.55167]], dtype=float32),\n",
       " array([[94.55178]], dtype=float32),\n",
       " array([[94.5519]], dtype=float32),\n",
       " array([[94.55202]], dtype=float32),\n",
       " array([[84.844604]], dtype=float32),\n",
       " array([[94.55225]], dtype=float32),\n",
       " array([[95.128685]], dtype=float32),\n",
       " array([[94.55249]], dtype=float32),\n",
       " array([[96.402756]], dtype=float32),\n",
       " array([[94.552704]], dtype=float32),\n",
       " array([[94.55281]], dtype=float32),\n",
       " array([[94.55292]], dtype=float32),\n",
       " array([[91.361176]], dtype=float32),\n",
       " array([[94.553116]], dtype=float32),\n",
       " array([[94.55319]], dtype=float32),\n",
       " array([[94.553246]], dtype=float32),\n",
       " array([[41.135864]], dtype=float32),\n",
       " array([[85.42209]], dtype=float32),\n",
       " array([[94.55333]], dtype=float32),\n",
       " array([[100.32768]], dtype=float32),\n",
       " array([[94.55335]], dtype=float32),\n",
       " array([[94.553375]], dtype=float32),\n",
       " array([[66.88956]], dtype=float32),\n",
       " array([[94.55341]], dtype=float32),\n",
       " array([[95.09435]], dtype=float32),\n",
       " array([[94.55347]], dtype=float32),\n",
       " array([[93.06059]], dtype=float32),\n",
       " array([[94.44888]], dtype=float32),\n",
       " array([[94.55352]], dtype=float32),\n",
       " array([[94.55354]], dtype=float32),\n",
       " array([[94.553566]], dtype=float32),\n",
       " array([[105.97214]], dtype=float32),\n",
       " array([[94.55362]], dtype=float32),\n",
       " array([[94.55365]], dtype=float32),\n",
       " array([[99.08419]], dtype=float32),\n",
       " array([[100.90983]], dtype=float32),\n",
       " array([[94.55381]], dtype=float32),\n",
       " array([[86.03918]], dtype=float32),\n",
       " array([[94.55395]], dtype=float32),\n",
       " array([[94.55404]], dtype=float32),\n",
       " array([[94.55547]], dtype=float32),\n",
       " array([[94.55424]], dtype=float32),\n",
       " array([[94.55435]], dtype=float32),\n",
       " array([[94.55447]], dtype=float32),\n",
       " array([[94.55458]], dtype=float32),\n",
       " array([[94.47228]], dtype=float32),\n",
       " array([[108.308716]], dtype=float32),\n",
       " array([[94.554886]], dtype=float32),\n",
       " array([[121.195526]], dtype=float32),\n",
       " array([[94.555]], dtype=float32),\n",
       " array([[94.555046]], dtype=float32),\n",
       " array([[94.55508]], dtype=float32),\n",
       " array([[94.5551]], dtype=float32),\n",
       " array([[101.64308]], dtype=float32),\n",
       " array([[96.62083]], dtype=float32),\n",
       " array([[94.55516]], dtype=float32),\n",
       " array([[96.246155]], dtype=float32),\n",
       " array([[95.45714]], dtype=float32),\n",
       " array([[94.55516]], dtype=float32),\n",
       " array([[94.555145]], dtype=float32),\n",
       " array([[94.55511]], dtype=float32),\n",
       " array([[95.17529]], dtype=float32),\n",
       " array([[94.555]], dtype=float32),\n",
       " array([[97.5581]], dtype=float32),\n",
       " array([[97.21443]], dtype=float32),\n",
       " array([[94.66654]], dtype=float32),\n",
       " array([[94.55465]], dtype=float32),\n",
       " array([[95.84652]], dtype=float32),\n",
       " array([[94.554405]], dtype=float32),\n",
       " array([[94.55426]], dtype=float32),\n",
       " array([[102.89837]], dtype=float32),\n",
       " array([[94.553986]], dtype=float32),\n",
       " array([[103.898384]], dtype=float32),\n",
       " array([[94.553665]], dtype=float32),\n",
       " array([[81.13678]], dtype=float32),\n",
       " array([[94.55325]], dtype=float32),\n",
       " array([[93.58315]], dtype=float32),\n",
       " array([[94.552795]], dtype=float32)]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "final_preds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
