hls4ml_conversion.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loading _not quantized_ ML models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:No training configuration found in the save file, so the model was *not* compiled. Compile it manually.\n",
      "WARNING:tensorflow:No training configuration found in the save file, so the model was *not* compiled. Compile it manually.\n",
      "WARNING:tensorflow:No training configuration found in the save file, so the model was *not* compiled. Compile it manually.\n",
      "WARNING:tensorflow:No training configuration found in the save file, so the model was *not* compiled. Compile it manually.\n"
     ]
    }
   ],
   "source": [
    "from tensorflow.keras.models import load_model\n",
    "###### AE MODEL LOAD ######\n",
    "ae_wo_classifier = load_model('model/AE_model/KERAS_check_best_model.h5')\n",
    "ae_wo_classifier_pruned = load_model('model/AE_model/KERAS_check_pruned_best_model.h5')\n",
    "ae_w_classifier = load_model('model/AE_model/KERAS_check_best_model_classifier.h5')\n",
    "ae_w_classifier_pruned = load_model('model/AE_model/KERAS_check_pruned_best_model_classifier.h5')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loading _quantized_ ML models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:No training configuration found in the save file, so the model was *not* compiled. Compile it manually.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:No training configuration found in the save file, so the model was *not* compiled. Compile it manually.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:No training configuration found in the save file, so the model was *not* compiled. Compile it manually.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:No training configuration found in the save file, so the model was *not* compiled. Compile it manually.\n"
     ]
    }
   ],
   "source": [
    "from tensorflow.keras.models import load_model\n",
    "from qkeras.utils import _add_supported_quantized_objects\n",
    "co = {}\n",
    "_add_supported_quantized_objects(co)\n",
    "###### QAE MODEL LOAD ######\n",
    "\n",
    "#qae_wo_classifier = load_model('model/QAE_model/KERAS_check_best_model.h5', custom_objects=co)\n",
    "qae_wo_classifier_pruned = load_model('model/QAE_model/KERAS_check_pruned_best_model.h5', custom_objects=co)\n",
    "#qae_w_classifier = load_model('model/QAE_model/KERAS_check_best_model_classifier.h5', custom_objects=co)\n",
    "\n",
    "#qae_w_classifier_pruned = load_model('model/QAE_model/KERAS_check_pruned_best_model_only_classifier.h5', custom_objects=co)\n",
    "qae_w_classifier_pruned = load_model('model/QAE_model/KERAS_check_pruned_best_model_classifier1.h5', custom_objects=co)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Check sparsity\n",
    "Make a quick check that the model was indeed trained sparse. We'll just make a histogram of the weights of the 1st layer, and hopefully observe a large peak in the bin containing '0'. Note logarithmic y axis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "weights:\n",
      "225 \n",
      " 34\n",
      "bias:\n",
      "15 \n",
      " 14\n",
      "layer2 \n",
      "\n",
      "weights:\n",
      "225 \n",
      " 34\n",
      "bias:\n",
      "15 \n",
      " 15\n",
      "layer3 \n",
      "\n",
      "weights:\n",
      "32 \n",
      " 5\n",
      "bias:\n",
      "16 \n",
      " 10\n",
      "layer5 \n",
      "\n",
      "528 \n",
      " 416\n"
     ]
    }
   ],
   "source": [
    "sum = 0\n",
    "sum_pru = 0\n",
    "\n",
    "for i in [2,3,5]:\n",
    "    for j in [0,1]:\n",
    "        w= ae_w_classifier.layers[i].weights[j].numpy()\n",
    "        sum +=w.size \n",
    "        w_prun = ae_w_classifier_pruned.layers[i].weights[j].numpy()\n",
    "        sum_pru += w.size - np.sum(w_prun==0)\n",
    "\n",
    "        if j==0:\n",
    "            print('weights:')\n",
    "        else:\n",
    "            print('bias:')\n",
    "        \n",
    "        print(w.size,'\\n', w.size - np.sum(w_prun==0))\n",
    "\n",
    "    print(\"layer\"+str(i),'\\n')\n",
    "print (sum, '\\n',  sum -sum_pru)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 720x720 with 7 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "w = 10\n",
    "h = 10\n",
    "fig = plt.figure(figsize=(10, 10))\n",
    "columns = 2\n",
    "rows = 4\n",
    "fig.subplots_adjust(hspace=0.4, wspace=0.4)\n",
    "\n",
    "num_layers = [1,2,3,4,7,9,11]#,11,14,15]\n",
    "#this applies for the quantized loop\n",
    "num_layers = [1,3,5,7,8,10,12]#,11,14,15]\n",
    "\n",
    "\n",
    "j = 1\n",
    "\n",
    "for i in num_layers:\n",
    "#for i in range(1, columns*rows +1):  \n",
    "    fig.add_subplot(rows, columns, j)\n",
    "    w = qae_w_classifier_pruned.layers[i].weights[0].numpy()\n",
    "    h, b = np.histogram(w, bins=100)\n",
    "    plt.bar(b[:-1], h, width=b[1]-b[0])\n",
    "    plt.semilogy()\n",
    "    plt.title('Weight distribution of layer '+ str(j))\n",
    "    j += 1\n",
    "\n",
    "plt.savefig('./Report/images/section4/ae_pruned_weightsdistr.png')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Make an hls4ml config & model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\loren\\miniconda3\\lib\\site-packages\\hls4ml\\converters\\__init__.py:16: UserWarning: WARNING: Pytorch converter is not enabled!\n",
      "  warnings.warn(\"WARNING: Pytorch converter is not enabled!\")\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Interpreting Model\n",
      "Topology:\n",
      "Layer name: encoder_input, layer type: Input\n",
      "Layer name: fc1, layer type: QDense\n",
      "Layer name: relu1, layer type: QActivation\n",
      "Layer name: fc2_prun, layer type: QDense\n",
      "Layer name: relu2, layer type: QActivation\n",
      "Layer name: fc3_prun, layer type: QDense\n",
      "Layer name: relu3, layer type: QActivation\n",
      "Layer name: encoder_output, layer type: Dense\n",
      "  -> Activation (relu), layer name: encoder_output\n",
      "Layer name: fc4_prunedclass, layer type: QDense\n",
      "Layer name: prunclass_relu4, layer type: QActivation\n",
      "Layer name: fc5_class, layer type: QDense\n",
      "Layer name: class_relu5, layer type: QActivation\n",
      "Layer name: classifier_out, layer type: QDense\n",
      "Layer name: classifier_output, layer type: Activation\n",
      "-----------------------------------\n",
      "Model\n",
      "  Precision:         ap_fixed<16,6>\n",
      "  ReuseFactor:       1\n",
      "  Strategy:          Latency\n",
      "LayerName\n",
      "  encoder_input\n",
      "    Precision:       ap_fixed<6,0>\n",
      "  fc1\n",
      "    Precision\n",
      "      weight:        ap_fixed<5,1>\n",
      "      bias:          ap_fixed<5,1>\n",
      "    ReuseFactor:     1\n",
      "  relu1\n",
      "    Precision\n",
      "      result:        ap_ufixed<5,0>\n",
      "    ReuseFactor:     1\n",
      "  fc2_prun\n",
      "    Precision\n",
      "      weight:        ap_fixed<5,1>\n",
      "      bias:          ap_fixed<5,1>\n",
      "    ReuseFactor:     1\n",
      "  relu2\n",
      "    Precision\n",
      "      result:        ap_ufixed<5,0>\n",
      "    ReuseFactor:     1\n",
      "  fc3_prun\n",
      "    Precision\n",
      "      weight:        ap_fixed<5,1>\n",
      "      bias:          ap_fixed<5,1>\n",
      "    ReuseFactor:     1\n",
      "  relu3\n",
      "    Precision\n",
      "      result:        ap_ufixed<5,0>\n",
      "    ReuseFactor:     1\n",
      "  encoder_output\n",
      "    Precision\n",
      "      weight:        ap_fixed<16,6>\n",
      "      bias:          ap_fixed<16,6>\n",
      "      result:        ap_fixed<16,6>\n",
      "    ReuseFactor:     1\n",
      "  encoder_output_relu\n",
      "    Precision:       ap_fixed<16,6>\n",
      "    ReuseFactor:     1\n",
      "    table_size:      1024\n",
      "    table_t:         ap_fixed<18,8>\n",
      "  fc4_prunedclass\n",
      "    Precision\n",
      "      weight:        ap_fixed<6,1>\n",
      "      bias:          ap_fixed<6,1>\n",
      "    ReuseFactor:     1\n",
      "  prunclass_relu4\n",
      "    Precision\n",
      "      result:        ap_ufixed<6,0>\n",
      "    ReuseFactor:     1\n",
      "  fc5_class\n",
      "    Precision\n",
      "      weight:        ap_fixed<6,1>\n",
      "      bias:          ap_fixed<6,1>\n",
      "    ReuseFactor:     1\n",
      "  class_relu5\n",
      "    Precision\n",
      "      result:        ap_ufixed<6,0>\n",
      "    ReuseFactor:     1\n",
      "  classifier_out\n",
      "    Precision\n",
      "      weight:        ap_fixed<16,7>\n",
      "      bias:          ap_fixed<16,7>\n",
      "    ReuseFactor:     1\n",
      "  classifier_output\n",
      "    Precision:       ap_fixed<16,6>\n",
      "    ReuseFactor:     1\n",
      "    table_size:      1024\n",
      "    exp_table_t:     ap_fixed<18,8>\n",
      "    inv_table_t:     ap_fixed<18,4>\n",
      "-----------------------------------\n",
      "Interpreting Model\n",
      "Topology:\n",
      "Layer name: encoder_input, layer type: InputLayer, input shapes: [[None, 64]], output shape: [None, 64]\n",
      "Layer name: fc1, layer type: QDense, input shapes: [[None, 64]], output shape: [None, 15]\n",
      "Layer name: relu1, layer type: Activation, input shapes: [[None, 15]], output shape: [None, 15]\n",
      "Layer name: fc2_prun, layer type: QDense, input shapes: [[None, 15]], output shape: [None, 15]\n",
      "Layer name: relu2, layer type: Activation, input shapes: [[None, 15]], output shape: [None, 15]\n",
      "Layer name: fc3_prun, layer type: QDense, input shapes: [[None, 15]], output shape: [None, 15]\n",
      "Layer name: relu3, layer type: Activation, input shapes: [[None, 15]], output shape: [None, 15]\n",
      "Layer name: encoder_output, layer type: Dense, input shapes: [[None, 15]], output shape: [None, 2]\n",
      "Layer name: fc4_prunedclass, layer type: QDense, input shapes: [[None, 2]], output shape: [None, 16]\n",
      "Layer name: prunclass_relu4, layer type: Activation, input shapes: [[None, 16]], output shape: [None, 16]\n",
      "Layer name: fc5_class, layer type: QDense, input shapes: [[None, 16]], output shape: [None, 40]\n",
      "Layer name: class_relu5, layer type: Activation, input shapes: [[None, 40]], output shape: [None, 40]\n",
      "Layer name: classifier_out, layer type: QDense, input shapes: [[None, 40]], output shape: [None, 10]\n",
      "Layer name: classifier_output, layer type: Softmax, input shapes: [[None, 10]], output shape: [None, 10]\n",
      "Creating HLS model\n"
     ]
    }
   ],
   "source": [
    "import plotting\n",
    "import hls4ml\n",
    "hls4ml.model.optimizer.OutputRoundingSaturationMode.layers = ['Activation']\n",
    "hls4ml.model.optimizer.OutputRoundingSaturationMode.rounding_mode = 'AP_RND'\n",
    "hls4ml.model.optimizer.OutputRoundingSaturationMode.saturation_mode = 'AP_SAT'\n",
    "\n",
    "config = hls4ml.utils.config_from_keras_model(qae_w_classifier_pruned, granularity='name')\n",
    "config['LayerName']['encoder_input']['Precision']='ap_ufixed<6,0>'\n",
    "\n",
    "#config['LayerName']['classifier_output']['Precision'] = 'ap_fixed<32,12>'\n",
    "config['LayerName']['classifier_output']['exp_table_t'] = 'ap_fixed<18,8>'\n",
    "config['LayerName']['classifier_output']['inv_table_t'] = 'ap_fixed<18,4>'\n",
    "print(\"-----------------------------------\")\n",
    "plotting.print_dict(config)\n",
    "print(\"-----------------------------------\")\n",
    "hls_model = hls4ml.converters.convert_from_keras_model(qae_w_classifier_pruned,\n",
    "                                                       hls_config=config,\n",
    "                                                       output_dir='model/QAE_model/hls4ml_prj',\n",
    "                                                       part='xcu250-figd2104-2L-e')\n",
    "                                                       #part='xcvu9p-flgc2104aaz')\n",
    "                                                       #part='xc7vx690t-ffg176-2')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Compile"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hls_model.compile()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Build"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hls_model.build(csim=True, cosim=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Prediction results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import MNIST_database as mnist\n",
    "\n",
    "#Choose the final size of your image dataset\n",
    "size_final = 8\n",
    "\n",
    "data_zoom = mnist.MNISTData(size_initial=20, size_final=size_final, color_depth=5, flat=True)\n",
    "\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "#           0  1  2  3  4  5  6  7  8  9          \n",
    "num_list = [3, 2, 1, 32,4, 15,21,0, 61,12] \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#img = np.flip(data_zoom.x_test[num_list[3]].reshape(1,-1))\n",
    "#img = data_zoom.x_test[32].reshape(1,-1)\n",
    "#plt.imshow(img.reshape(size_final,size_final), cmap='gray_r')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.      0.      0.      0.09375 0.84375 0.      0.      0.      0.\n",
      "  0.      0.09375 0.96875 0.96875 0.15625 0.      0.      0.      0.\n",
      "  0.96875 0.96875 0.6875  0.875   0.      0.      0.      0.      0.96875\n",
      "  0.      0.      0.125   0.96875 0.      0.      0.3125  0.53125 0.\n",
      "  0.      0.125   0.96875 0.      0.      0.59375 0.5625  0.      0.28125\n",
      "  0.96875 0.59375 0.      0.      0.15625 0.96875 0.9375  0.9375  0.875\n",
      "  0.      0.      0.      0.      0.0625  0.96875 0.28125 0.      0.\n",
      "  0.     ]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x22241f426d0>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#img = []\n",
    "ax = plt.subplot(1, 1 , 1)\n",
    "img = data_zoom.x_test[num_list[0]].reshape(1,-1)\n",
    "\n",
    "plt.imshow(img.reshape(size_final,size_final), cmap='gray_r')\n",
    "print(img)\n",
    "plt.imshow(img.reshape(size_final,size_final), cmap='gray_r')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- 0.061026573181152344 seconds ---\n",
      "[[3.8145399e-03 9.8177010e-01 1.7132721e-03 2.4785351e-03 2.4927363e-05\n",
      "  9.2737708e-04 2.3345661e-04 7.2462396e-03 1.0432226e-04 1.6870706e-03]]\n",
      "0.99999976\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import time\n",
    "import numpy as np\n",
    "img = data_zoom.x_test[num_list[1]].reshape(1,-1)\n",
    "plt.imshow(img.reshape(size_final,size_final), cmap='gray_r')\n",
    "start_time = time.time()\n",
    "out = qae_w_classifier_pruned.predict(img)\n",
    "print(\"--- %s seconds ---\" % (time.time() - start_time))\n",
    "print(out)\n",
    "print(np.sum(out))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = hls_model.predict(img)[1]\n"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "789093bb736187c46b4a361b2c83e244a48ff9bb7ad40e66e5ffb40455c8edff"
  },
  "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}