diff --git a/final/hls4ml.ipynb b/final/hls4ml.ipynb
new file mode 100644
index 0000000..8d4c8fa
--- /dev/null
+++ b/final/hls4ml.ipynb
@@ -0,0 +1,583 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "vivado v2023.2.1 (64-bit)\n",
+      "Tool Version Limit: 2023.10\n",
+      "SW Build 4081461 on Thu Dec 14 12:22:04 MST 2023\n",
+      "IP Build 4080415 on Thu Dec 14 21:01:57 MST 2023\n",
+      "SharedData Build 4077621 on Mon Dec 11 00:23:44 MST 2023\n",
+      "Copyright 1986-2022 Xilinx, Inc. All Rights Reserved.\n",
+      "Copyright 2022-2023 Advanced Micro Devices, Inc. All Rights Reserved.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# source /data/Xilinx_no_Vitis/Vivado/2020.1/settings64.sh\n",
+    "!vivado -version"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os \n",
+    "import hashlib\n",
+    "\n",
+    "import keras\n",
+    "from tensorflow.keras.layers import BatchNormalization\n",
+    "from sklearn.metrics import accuracy_score\n",
+    "import numpy as np\n",
+    "\n",
+    "from qkeras.qlayers import QDense\n",
+    "from qkeras.quantizers import ternary\n",
+    "\n",
+    "os.environ['PATH'] = os.environ['XILINX_VIVADO'] + '/bin:' + os.environ['PATH']\n",
+    "keras.utils.set_random_seed(32)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Download data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_data_dir = \"../data/malab_05282024/npz/\"\n",
+    "test_data_dir = \"../data/malab_05282024/npz/\"\n",
+    "start_location = 100\n",
+    "window_size = 400\n",
+    "end_window = start_location + window_size"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\"\"\"Loadning training split\"\"\"\n",
+    "x_train_path = os.path.join(train_data_dir, f'0528_X_train_0_770.npy')\n",
+    "y_train_path = os.path.join(train_data_dir, f'0528_y_train_0_770.npy')\n",
+    "\n",
+    "assert os.path.exists(x_train_path), f\"ERROR: File {x_train_path} does not exist.\"\n",
+    "assert os.path.exists(y_train_path), f\"ERROR: File {y_train_path} does not exist.\"\n",
+    "\n",
+    "X_train_val = np.load(x_train_path)\n",
+    "y_train_val = np.load(y_train_path)\n",
+    "\n",
+    "# Insure same dataset is loaded \n",
+    "assert hashlib.md5(X_train_val).hexdigest() == 'b61226c86b7dee0201a9158455e08ffb',  \"Checksum failed. Wrong file was loaded or file may be corrupted.\"\n",
+    "assert hashlib.md5(y_train_val).hexdigest() == 'c59ce37dc7c73d2d546e7ea180fa8d31',  \"Checksum failed. Wrong file was loaded or file may be corrupted.\"\n",
+    "\n",
+    "# Get readout window\n",
+    "X_train_val = X_train_val[:,start_location*2:end_window*2]\n",
+    "assert len(X_train_val[0]) == (end_window-start_location)*2, f\"ERROR: X_test sample size {len(X_train_val[0])} does not match (start window, end window) ({start_location},{end_window}) size.\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\"\"\"Loading testing split\"\"\"\n",
+    "x_test_path = os.path.join(test_data_dir, f'0528_X_test_0_770.npy')\n",
+    "y_test_path = os.path.join(test_data_dir, f'0528_y_test_0_770.npy')\n",
+    "\n",
+    "assert os.path.exists(x_test_path), f\"ERROR: File {x_test_path} does not exist.\"\n",
+    "assert os.path.exists(y_test_path), f\"ERROR: File {y_test_path} does not exist.\"\n",
+    "\n",
+    "X_test = np.load(x_test_path)\n",
+    "y_test = np.load(y_test_path)\n",
+    "\n",
+    "# Insure same dataset is loaded \n",
+    "assert hashlib.md5(X_test).hexdigest() == 'b7d85f42522a0a57e877422bc5947cde', \"Checksum failed. Wrong file was loaded or file may be corrupted.\"\n",
+    "assert hashlib.md5(y_test).hexdigest() == '8c9cce1821372380371ade5f0ccfd4a2', \"Checksum failed. Wrong file was loaded or file may be corrupted.\"\n",
+    "\n",
+    "# Get readout window\n",
+    "X_test = X_test[:,start_location*2:end_window*2]\n",
+    "assert len(X_test[0]) == (end_window-start_location)*2, f\"ERROR: X_test sample size {len(X_test[0])} does not match (start window, end window) ({start_location},{end_window}) size.\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Build our model \n",
+    "QKeras is \"Quantized Keras\" for deep heterogeneous quantization of ML models. We're using QDense layer instead of Dense. We're also training with model sparsity, since QKeras layers are prunable."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model: \"sequential_1\"\n",
+      "_________________________________________________________________\n",
+      " Layer (type)                Output Shape              Param #   \n",
+      "=================================================================\n",
+      " fc1 (QDense)                (None, 4)                 3204      \n",
+      "                                                                 \n",
+      " batchnorm1 (BatchNormalizat  (None, 4)                16        \n",
+      " ion)                                                            \n",
+      "                                                                 \n",
+      " fc2 (QDense)                (None, 1)                 5         \n",
+      "                                                                 \n",
+      "=================================================================\n",
+      "Total params: 3,225\n",
+      "Trainable params: 3,217\n",
+      "Non-trainable params: 8\n",
+      "_________________________________________________________________\n",
+      "None\n"
+     ]
+    }
+   ],
+   "source": [
+    "keras_model = keras.models.Sequential()\n",
+    "keras_model.add(QDense(\n",
+    "    4, \n",
+    "    activation=None, \n",
+    "    name='fc1',\n",
+    "    input_shape=(800,), \n",
+    "    kernel_quantizer=ternary(),\n",
+    "    bias_quantizer=ternary(),\n",
+    "))\n",
+    "keras_model.add(BatchNormalization(name='batchnorm1'))\n",
+    "keras_model.add(QDense(\n",
+    "    1, \n",
+    "    name='fc2', \n",
+    "    activation=None, \n",
+    "    kernel_quantizer=ternary(),\n",
+    "    bias_quantizer=ternary(),\n",
+    "))\n",
+    "\n",
+    "print(keras_model.summary())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Load model and check performance"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "init_learning_rate = 1e-3\n",
+    "validation_split = 0.05  # 45,000 sample size \n",
+    "batch_size = 256\n",
+    "epochs = 50\n",
+    "early_stopping_patience = 10\n",
+    "\n",
+    "checkpoint_dir = f'checkpoints/'\n",
+    "checkpoint_filename = f'qkeras_model_best.h5'\n",
+    "\n",
+    "if os.path.exists(checkpoint_dir) == False:\n",
+    "    print(f'Checkpoint directory {checkpoint_dir} does not exist.')\n",
+    "    print('Creating directory...')\n",
+    "    os.mkdir(checkpoint_dir)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "3125/3125 [==============================] - 3s 1ms/step\n",
+      "\n",
+      "===================================\n",
+      "Start location = 100, Window size = 400\n",
+      "    Accuracy 0.95999\n",
+      "    Fidelity 0.91998\n"
+     ]
+    }
+   ],
+   "source": [
+    "keras_model.load_weights(os.path.join(checkpoint_dir, checkpoint_filename))\n",
+    "y_keras = keras_model.predict(X_test)\n",
+    "test_acc = accuracy_score(y_test, np.where(y_keras < 0, 0, 1).reshape(-1))\n",
+    "\n",
+    "print('\\n===================================')\n",
+    "print(f'Start location = {start_location}, Window size = {window_size}')\n",
+    "print('    Accuracy', test_acc)\n",
+    "print('    Fidelity', test_acc*2-1)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Convert the model to FPGA firmware "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Make an hls4ml config and model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Interpreting Sequential\n",
+      "Topology:\n",
+      "Layer name: fc1_input, layer type: InputLayer, input shapes: [[None, 800]], output shape: [None, 800]\n",
+      "Layer name: fc1, layer type: QDense, input shapes: [[None, 800]], output shape: [None, 4]\n",
+      "Layer name: batchnorm1, layer type: BatchNormalization, input shapes: [[None, 4]], output shape: [None, 4]\n",
+      "Layer name: fc2, layer type: QDense, input shapes: [[None, 4]], output shape: [None, 1]\n"
+     ]
+    }
+   ],
+   "source": [
+    "import hls4ml\n",
+    "\n",
+    "# Create HLS configuration \n",
+    "hls_config = {}\n",
+    "hls_config['Model'] = {}\n",
+    "hls_config = hls4ml.utils.config_from_keras_model(keras_model, granularity='name')\n",
+    "hls_config['Model']['Precision'] = 'ap_fixed<16,6>'  # Default precision\n",
+    "hls_config['Model']['ReuseFactor'] = 1  # parallelized \n",
+    "hls_config['Model']['Strategy'] = 'Resource'\n",
+    "\n",
+    "keras_layers = ['fc1', 'fc1_alpha', 'fc1_linear', 'batchnorm1', 'fc2', 'fc2_alpha', 'fc2_linear']\n",
+    "for layer in keras_layers:\n",
+    "    hls_config['LayerName'][layer] = {}\n",
+    "    hls_config['LayerName'][layer]['Precision'] = {}\n",
+    "    if 'alpha' in layer: continue\n",
+    "    hls_config['LayerName'][layer]['Trace'] = True\n",
+    "\n",
+    "# Input - ZCU216 uses 14-bit ADCS \n",
+    "hls_config['LayerName']['fc1_input'] = {}\n",
+    "hls_config['LayerName']['fc1_input']['Precision'] = {}\n",
+    "hls_config['LayerName']['fc1_input']['Trace'] = False\n",
+    "hls_config['LayerName']['fc1_input']['Precision'] = 'ap_fixed<14,14>' \n",
+    "\n",
+    "# Fc1\n",
+    "hls_config['LayerName']['fc1']['Precision']['result'] = 'ap_fixed<20,20>'\n",
+    "hls_config['LayerName']['fc1']['accum_t'] = 'ap_fixed<20,20>'\n",
+    "\n",
+    "# Fc1 activation \n",
+    "hls_config['LayerName']['fc1_alpha']['Precision']['result'] = 'ap_fixed<20,20>'\n",
+    "hls_config['LayerName']['fc1_linear']['Precision']['result'] = 'ap_fixed<20,20>'\n",
+    "\n",
+    "# Batchnormalization\n",
+    "hls_config['LayerName']['batchnorm1']['Precision']['scale'] = 'ap_fixed<18,4>'\n",
+    "hls_config['LayerName']['batchnorm1']['Precision']['bias'] = 'ap_fixed<18,4>'\n",
+    "hls_config['LayerName']['batchnorm1']['Precision']['result'] = 'ap_fixed<10,4>'\n",
+    "hls_config['LayerName']['batchnorm1']['accum_t'] = 'ap_fixed<10,4>'\n",
+    "\n",
+    "# Fc2\n",
+    "hls_config['LayerName']['fc2']['Precision']['result'] = 'ap_fixed<21,21>'\n",
+    "hls_config['LayerName']['fc2']['accum_t'] = 'ap_fixed<21,21>'\n",
+    "\n",
+    "# Fc2 activation \n",
+    "hls_config['LayerName']['fc2_alpha']['Precision']['result'] = 'ap_fixed<21,21>'\n",
+    "hls_config['LayerName']['fc2_linear']['Precision']['result'] = 'ap_fixed<21,21>'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Interpreting Sequential\n",
+      "Topology:\n",
+      "Layer name: fc1_input, layer type: InputLayer, input shapes: [[None, 800]], output shape: [None, 800]\n",
+      "Layer name: fc1, layer type: QDense, input shapes: [[None, 800]], output shape: [None, 4]\n",
+      "Layer name: batchnorm1, layer type: BatchNormalization, input shapes: [[None, 4]], output shape: [None, 4]\n",
+      "Layer name: fc2, layer type: QDense, input shapes: [[None, 4]], output shape: [None, 1]\n",
+      "Creating HLS model\n",
+      "WARNING: Changing pipeline style to \"dataflow\".\n",
+      "WARNING: Config parameter \"accum_t\" overwrites an existing attribute in layer \"fc1\" (Dense)\n",
+      "WARNING: Config parameter \"accum_t\" overwrites an existing attribute in layer \"fc2\" (Dense)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<IPython.core.display.Image object>"
+      ]
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "hls_model = hls4ml.converters.convert_from_keras_model(\n",
+    "    model=keras_model,\n",
+    "    hls_config=hls_config,\n",
+    "    output_dir='hls4ml_prj/',\n",
+    "    part= 'xczu49dr-ffvf1760-2-e',\n",
+    "    io_type='io_parallel',\n",
+    "    clock_period=3.225,\n",
+    "    backend='VivadoAccelerator',\n",
+    "    board='zcu216',\n",
+    "    interface='axi_stream',\n",
+    "    project_name='NN'\n",
+    ")\n",
+    "\n",
+    "# Visualize model\n",
+    "hls4ml.utils.plot_model(hls_model, show_shapes=True, show_precision=True, to_file=None)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Compile and predict"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Writing HLS project\n",
+      "WARNING:tensorflow:Compiled the loaded model, but the compiled metrics have yet to be built. `model.compile_metrics` will be empty until you train or evaluate the model.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Done\n"
+     ]
+    }
+   ],
+   "source": [
+    "hls_model.compile()  # Must compile for C Sim. \n",
+    "X_test = np.ascontiguousarray(X_test)\n",
+    "y_hls = hls_model.predict(X_test)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Compare hls4ml and keras model\n",
+    "#### Accuracy"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Keras Acc: 95.999%\n",
+      "Keras Fidelity: 91.998%\n",
+      "HLS Acc: 96.022:%\n",
+      "HLS Fidelity: 92.044:%\n"
+     ]
+    }
+   ],
+   "source": [
+    "y_hls = hls_model.predict(np.ascontiguousarray(X_test.astype(np.float32))) \n",
+    "\n",
+    "keras_acc = accuracy_score(y_test, np.where(y_keras <= 0, 0, 1).reshape(-1))\n",
+    "hls_acc = accuracy_score(y_test, np.where(y_hls < 0, 0, 1).reshape(-1))\n",
+    "\n",
+    "print(f'Keras Acc: {keras_acc*100:.5}%')\n",
+    "print(f'HLS Acc: {hls_acc*100:.5}:%')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Fidelity "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# get ground and excited indices \n",
+    "e_indices = np.where(y_test == 1)[0]\n",
+    "g_indices = np.where(y_test == 0)[0]\n",
+    "\n",
+    "# separate ground and excited samples \n",
+    "Xe_test = X_test[e_indices]\n",
+    "ye_test = y_test[e_indices]\n",
+    "\n",
+    "Xg_test = X_test[g_indices]\n",
+    "yg_test = y_test[g_indices]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1563/1563 [==============================] - 1s 340us/step\n",
+      "1563/1563 [==============================] - 1s 343us/step\n",
+      "\n",
+      "===================================\n",
+      "    Keras Fidelity 0.979995\n",
+      "    HLS Fidelity 0.98011\n"
+     ]
+    }
+   ],
+   "source": [
+    "# compute total correct for excited state \n",
+    "ye_keras = keras_model.predict(Xe_test)\n",
+    "ye_keras = np.where(ye_keras < 0, 0, 1).reshape(-1)\n",
+    "e_accuracy = accuracy_score(ye_test, ye_keras)\n",
+    "\n",
+    "total_correct = (ye_test==ye_keras).astype(np.int8).sum()\n",
+    "total_incorrect = (ye_test!=ye_keras).astype(np.int8).sum()\n",
+    "\n",
+    "# compute total correct for ground state \n",
+    "yg_keras = keras_model.predict(Xg_test)\n",
+    "yg_keras = np.where(yg_keras < 0, 0, 1)\n",
+    "g_accuracy = accuracy_score(yg_test, yg_keras)\n",
+    "\n",
+    "total_correct = (yg_test==yg_keras).astype(np.int8).sum()\n",
+    "total_incorrect = (yg_test!=yg_keras).astype(np.int8).sum()\n",
+    "\n",
+    "# compute fidelity \n",
+    "keras_fidelity = 0.5*(e_accuracy + g_accuracy)\n",
+    "keras_fidelity = 1/2 + (0.5*keras_fidelity)\n",
+    "\n",
+    "\n",
+    "# compute total correct for excited state \n",
+    "ye_hls = hls_model.predict(Xe_test)\n",
+    "ye_hls = np.where(ye_hls < 0, 0, 1).reshape(-1)\n",
+    "e_accuracy = accuracy_score(ye_test, ye_hls)\n",
+    "\n",
+    "total_correct = (ye_test==ye_hls).astype(np.int8).sum()\n",
+    "total_incorrect = (ye_test!=ye_hls).astype(np.int8).sum()\n",
+    "\n",
+    "# compute total correct for ground state \n",
+    "yg_hls = hls_model.predict(Xg_test)\n",
+    "yg_hls = np.where(yg_hls < 0, 0, 1)\n",
+    "g_accuracy = accuracy_score(yg_test, yg_hls)\n",
+    "\n",
+    "total_correct = (yg_test==yg_hls).astype(np.int8).sum()\n",
+    "total_incorrect = (yg_test!=yg_hls).astype(np.int8).sum()\n",
+    "\n",
+    "# compute fidelity \n",
+    "hls_fidelity = 0.5*(e_accuracy + g_accuracy)\n",
+    "hls_fidelity = 1/2 + (0.5*hls_fidelity)\n",
+    "\n",
+    "\n",
+    "print('\\n===================================')\n",
+    "print('    Keras Fidelity', keras_fidelity)\n",
+    "print('    HLS Fidelity', hls_fidelity)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Synthesize "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "hls_model.build(\n",
+    "    csim=False,\n",
+    "    synth=True,\n",
+    "    cosim=False,\n",
+    "    export=False,\n",
+    "    vsynth=True,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Check the report"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "hls4ml.report.read_vivado_report('hls4ml_prj/')"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "ml4qick-test-env",
+   "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.10.14"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/final/train.ipynb b/final/train.ipynb
new file mode 100644
index 0000000..3fe0d0b
--- /dev/null
+++ b/final/train.ipynb
@@ -0,0 +1,394 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2024-12-02 10:50:03.729385: I tensorflow/core/platform/cpu_feature_guard.cc:193] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 AVX_VNNI FMA\n",
+      "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
+      "2024-12-02 10:50:03.793060: I tensorflow/core/util/port.cc:104] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n",
+      "2024-12-02 10:50:03.794942: W tensorflow/compiler/xla/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudart.so.11.0'; dlerror: libcudart.so.11.0: cannot open shared object file: No such file or directory\n",
+      "2024-12-02 10:50:03.794954: I tensorflow/compiler/xla/stream_executor/cuda/cudart_stub.cc:29] Ignore above cudart dlerror if you do not have a GPU set up on your machine.\n",
+      "2024-12-02 10:50:06.943195: W tensorflow/compiler/xla/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libnvinfer.so.7'; dlerror: libnvinfer.so.7: cannot open shared object file: No such file or directory\n",
+      "2024-12-02 10:50:06.943319: W tensorflow/compiler/xla/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libnvinfer_plugin.so.7'; dlerror: libnvinfer_plugin.so.7: cannot open shared object file: No such file or directory\n",
+      "2024-12-02 10:50:06.943333: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Cannot dlopen some TensorRT libraries. If you would like to use Nvidia GPU with TensorRT, please make sure the missing libraries mentioned above are installed properly.\n"
+     ]
+    }
+   ],
+   "source": [
+    "import os \n",
+    "import pickle\n",
+    "import hashlib\n",
+    "\n",
+    "import keras\n",
+    "from tensorflow.keras.optimizers import Adam\n",
+    "from tensorflow.keras.layers import BatchNormalization\n",
+    "from tensorflow.keras.callbacks import ModelCheckpoint, EarlyStopping\n",
+    "from tensorflow.keras.losses import BinaryCrossentropy \n",
+    "from sklearn.metrics import accuracy_score\n",
+    "import numpy as np\n",
+    "\n",
+    "from qkeras.qlayers import QDense\n",
+    "from qkeras.quantizers import ternary\n",
+    "\n",
+    "os.environ['PATH'] = os.environ['XILINX_VIVADO'] + '/bin:' + os.environ['PATH']\n",
+    "keras.utils.set_random_seed(32)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Download data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Setup data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_data_dir = \"../data/malab_05282024/npz/\"\n",
+    "test_data_dir = \"../data/malab_05282024/npz/\"\n",
+    "start_location = 100\n",
+    "window_size = 400\n",
+    "end_window = start_location + window_size"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\"\"\"Loadning training split\"\"\"\n",
+    "x_train_path = os.path.join(train_data_dir, f'0528_X_train_0_770.npy')\n",
+    "y_train_path = os.path.join(train_data_dir, f'0528_y_train_0_770.npy')\n",
+    "\n",
+    "assert os.path.exists(x_train_path), f\"ERROR: File {x_train_path} does not exist.\"\n",
+    "assert os.path.exists(y_train_path), f\"ERROR: File {y_train_path} does not exist.\"\n",
+    "\n",
+    "X_train_val = np.load(x_train_path)\n",
+    "y_train_val = np.load(y_train_path)\n",
+    "\n",
+    "# Insure same dataset is loaded \n",
+    "assert hashlib.md5(X_train_val).hexdigest() == 'b61226c86b7dee0201a9158455e08ffb',  \"Checksum failed. Wrong file was loaded or file may be corrupted.\"\n",
+    "assert hashlib.md5(y_train_val).hexdigest() == 'c59ce37dc7c73d2d546e7ea180fa8d31',  \"Checksum failed. Wrong file was loaded or file may be corrupted.\"\n",
+    "\n",
+    "# Get readout window\n",
+    "X_train_val = X_train_val[:,start_location*2:end_window*2]\n",
+    "assert len(X_train_val[0]) == (end_window-start_location)*2, f\"ERROR: X_test sample size {len(X_train_val[0])} does not match (start window, end window) ({start_location},{end_window}) size.\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\"\"\"Loading testing split\"\"\"\n",
+    "x_test_path = os.path.join(test_data_dir, f'0528_X_test_0_770.npy')\n",
+    "y_test_path = os.path.join(test_data_dir, f'0528_y_test_0_770.npy')\n",
+    "\n",
+    "assert os.path.exists(x_test_path), f\"ERROR: File {x_test_path} does not exist.\"\n",
+    "assert os.path.exists(y_test_path), f\"ERROR: File {y_test_path} does not exist.\"\n",
+    "\n",
+    "X_test = np.load(x_test_path)\n",
+    "y_test = np.load(y_test_path)\n",
+    "\n",
+    "# Insure same dataset is loaded \n",
+    "assert hashlib.md5(X_test).hexdigest() == 'b7d85f42522a0a57e877422bc5947cde', \"Checksum failed. Wrong file was loaded or file may be corrupted.\"\n",
+    "assert hashlib.md5(y_test).hexdigest() == '8c9cce1821372380371ade5f0ccfd4a2', \"Checksum failed. Wrong file was loaded or file may be corrupted.\"\n",
+    "\n",
+    "# Get readout window\n",
+    "X_test = X_test[:,start_location*2:end_window*2]\n",
+    "assert len(X_test[0]) == (end_window-start_location)*2, f\"ERROR: X_test sample size {len(X_test[0])} does not match (start window, end window) ({start_location},{end_window}) size.\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Construct the model\n",
+    " \n",
+    "QKeras is \"Quantized Keras\" for deep heterogeneous quantization of ML models. We're using QDense layer instead of Dense. We're also training with model sparsity, since QKeras layers are prunable."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "WARNING:tensorflow:From /data/jcampos/miniforge3/envs/ml4qick-env/lib/python3.10/site-packages/tensorflow/python/autograph/pyct/static_analysis/liveness.py:83: Analyzer.lamba_check (from tensorflow.python.autograph.pyct.static_analysis.liveness) is deprecated and will be removed after 2023-09-23.\n",
+      "Instructions for updating:\n",
+      "Lambda fuctions will be no more assumed to be used in the statement where they are used, or at least in the same block. https://github.com/tensorflow/tensorflow/issues/56089\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2024-12-02 10:51:09.801613: W tensorflow/compiler/xla/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcuda.so.1'; dlerror: libcuda.so.1: cannot open shared object file: No such file or directory\n",
+      "2024-12-02 10:51:09.801630: W tensorflow/compiler/xla/stream_executor/cuda/cuda_driver.cc:265] failed call to cuInit: UNKNOWN ERROR (303)\n",
+      "2024-12-02 10:51:09.801640: I tensorflow/compiler/xla/stream_executor/cuda/cuda_diagnostics.cc:156] kernel driver does not appear to be running on this host (correlator7.fnal.gov): /proc/driver/nvidia/version does not exist\n",
+      "2024-12-02 10:51:09.801767: I tensorflow/core/platform/cpu_feature_guard.cc:193] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 AVX_VNNI FMA\n",
+      "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model: \"sequential\"\n",
+      "_________________________________________________________________\n",
+      " Layer (type)                Output Shape              Param #   \n",
+      "=================================================================\n",
+      " fc1 (QDense)                (None, 4)                 3204      \n",
+      "                                                                 \n",
+      " batchnorm1 (BatchNormalizat  (None, 4)                16        \n",
+      " ion)                                                            \n",
+      "                                                                 \n",
+      " fc2 (QDense)                (None, 1)                 5         \n",
+      "                                                                 \n",
+      "=================================================================\n",
+      "Total params: 3,225\n",
+      "Trainable params: 3,217\n",
+      "Non-trainable params: 8\n",
+      "_________________________________________________________________\n",
+      "None\n"
+     ]
+    }
+   ],
+   "source": [
+    "model = keras.models.Sequential()\n",
+    "model.add(QDense(\n",
+    "    4, \n",
+    "    activation=None, \n",
+    "    name='fc1',\n",
+    "    input_shape=(800,), \n",
+    "    kernel_quantizer=ternary(),\n",
+    "    bias_quantizer=ternary(),\n",
+    "))\n",
+    "model.add(BatchNormalization(name='batchnorm1'))\n",
+    "model.add(QDense(\n",
+    "    1, \n",
+    "    name='fc2', \n",
+    "    activation='sigmoid', \n",
+    "    kernel_quantizer=ternary(),\n",
+    "    bias_quantizer=ternary(),\n",
+    "))\n",
+    "\n",
+    "print(model.summary())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Train the model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "init_learning_rate = 1e-3\n",
+    "validation_split = 0.05  # 45,000 sample size \n",
+    "batch_size = 256\n",
+    "epochs = 50\n",
+    "early_stopping_patience = 10\n",
+    "\n",
+    "checkpoint_dir = f'checkpoints/'\n",
+    "checkpoint_filename = f'qkeras_ckp_model_best.h5'\n",
+    "ckp_filename = os.path.join(checkpoint_dir, checkpoint_filename)\n",
+    "\n",
+    "if os.path.exists(checkpoint_dir) == False:\n",
+    "    print(f'Checkpoint directory {checkpoint_dir} does not exist.')\n",
+    "    print('Creating directory...')\n",
+    "    os.mkdir(checkpoint_dir)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1/50\n",
+      "3340/3340 [==============================] - 9s 2ms/step - loss: 0.1959 - accuracy: 0.9558 - val_loss: 0.1810 - val_accuracy: 0.9581\n",
+      "Epoch 2/50\n",
+      "3340/3340 [==============================] - 10s 3ms/step - loss: 0.1802 - accuracy: 0.9592 - val_loss: 0.1770 - val_accuracy: 0.9583\n",
+      "Epoch 3/50\n",
+      "3340/3340 [==============================] - 3s 800us/step - loss: 0.1787 - accuracy: 0.9595 - val_loss: 0.1783 - val_accuracy: 0.9584\n",
+      "Epoch 4/50\n",
+      "3340/3340 [==============================] - 8s 2ms/step - loss: 0.1782 - accuracy: 0.9598 - val_loss: 0.1776 - val_accuracy: 0.9585\n",
+      "Epoch 5/50\n",
+      "3340/3340 [==============================] - 9s 3ms/step - loss: 0.1792 - accuracy: 0.9593 - val_loss: 0.1770 - val_accuracy: 0.9583\n",
+      "Epoch 6/50\n",
+      "3340/3340 [==============================] - 6s 2ms/step - loss: 0.1791 - accuracy: 0.9593 - val_loss: 0.1796 - val_accuracy: 0.9582\n",
+      "Epoch 7/50\n",
+      "3340/3340 [==============================] - 6s 2ms/step - loss: 0.1784 - accuracy: 0.9598 - val_loss: 0.1783 - val_accuracy: 0.9588\n",
+      "Epoch 8/50\n",
+      "3340/3340 [==============================] - 2s 671us/step - loss: 0.1779 - accuracy: 0.9597 - val_loss: 0.1783 - val_accuracy: 0.9584\n",
+      "Epoch 9/50\n",
+      "3340/3340 [==============================] - 6s 2ms/step - loss: 0.1779 - accuracy: 0.9601 - val_loss: 0.1783 - val_accuracy: 0.9586\n",
+      "Epoch 10/50\n",
+      "3340/3340 [==============================] - 11s 3ms/step - loss: 0.1778 - accuracy: 0.9599 - val_loss: 0.1777 - val_accuracy: 0.9587\n",
+      "Epoch 11/50\n",
+      "3340/3340 [==============================] - 8s 2ms/step - loss: 0.1778 - accuracy: 0.9599 - val_loss: 0.1775 - val_accuracy: 0.9584\n",
+      "Epoch 12/50\n",
+      "3340/3340 [==============================] - 11s 3ms/step - loss: 0.1779 - accuracy: 0.9599 - val_loss: 0.1781 - val_accuracy: 0.9583\n",
+      "Epoch 13/50\n",
+      "3340/3340 [==============================] - 11s 3ms/step - loss: 0.1779 - accuracy: 0.9599 - val_loss: 0.1779 - val_accuracy: 0.9584\n",
+      "Epoch 14/50\n",
+      "3340/3340 [==============================] - 6s 2ms/step - loss: 0.1779 - accuracy: 0.9599 - val_loss: 0.1775 - val_accuracy: 0.9586\n",
+      "Epoch 15/50\n",
+      "3340/3340 [==============================] - 8s 2ms/step - loss: 0.1778 - accuracy: 0.9600 - val_loss: 0.1772 - val_accuracy: 0.9585\n"
+     ]
+    }
+   ],
+   "source": [
+    "train = True\n",
+    "\n",
+    "if train: \n",
+    "    opt = Adam(learning_rate=init_learning_rate)\n",
+    "    callbacks = [\n",
+    "        EarlyStopping(\n",
+    "            monitor='val_loss',\n",
+    "            patience=early_stopping_patience,\n",
+    "            restore_best_weights=True,\n",
+    "        ),\n",
+    "    ] \n",
+    "    model.compile(\n",
+    "        optimizer=opt, \n",
+    "        loss=BinaryCrossentropy(from_logits=False), \n",
+    "        metrics=['accuracy']\n",
+    "    )\n",
+    "    history = model.fit(\n",
+    "        X_train_val, \n",
+    "        y_train_val, \n",
+    "        batch_size=batch_size,\n",
+    "        epochs=epochs, \n",
+    "        validation_split=validation_split, \n",
+    "        shuffle=True, \n",
+    "        callbacks=callbacks,\n",
+    "    )\n",
+    "    \n",
+    "    model.save_weights(os.path.join(checkpoint_dir, 'qkeras_model_best.h5'))\n",
+    "    # Save the history dictionary\n",
+    "    with open(os.path.join(checkpoint_dir, f'qkeras_training_history.pkl'), 'wb') as f:\n",
+    "        pickle.dump(history.history, f)    \n",
+    "else: \n",
+    "    model.load_weights(os.path.join(checkpoint_dir, checkpoint_filename))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Check performance"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1563/1563 [==============================] - 1s 484us/step\n",
+      "1563/1563 [==============================] - 1s 359us/step\n",
+      "3125/3125 [==============================] - 1s 391us/step\n",
+      "\n",
+      "===================================\n",
+      "    Accuracy 0.95999\n",
+      "    Fidelity 0.979995\n"
+     ]
+    }
+   ],
+   "source": [
+    "# get ground and excited indices \n",
+    "e_indices = np.where(y_test == 1)[0]\n",
+    "g_indices = np.where(y_test == 0)[0]\n",
+    "\n",
+    "# separate ground and excited samples \n",
+    "Xe_test = X_test[e_indices]\n",
+    "ye_test = y_test[e_indices]\n",
+    "\n",
+    "Xg_test = X_test[g_indices]\n",
+    "yg_test = y_test[g_indices]\n",
+    "\n",
+    "# compute total correct for excited state \n",
+    "ye_pred = model.predict(Xe_test)\n",
+    "ye_pred = np.where(ye_pred < 0.5, 0, 1).reshape(-1)\n",
+    "e_accuracy = accuracy_score(ye_test, ye_pred)\n",
+    "\n",
+    "total_correct = (ye_test==ye_pred).astype(np.int8).sum()\n",
+    "total_incorrect = (ye_test!=ye_pred).astype(np.int8).sum()\n",
+    "\n",
+    "# compute total correct for ground state \n",
+    "yg_pred = model.predict(Xg_test)\n",
+    "yg_pred = np.where(yg_pred < 0.5, 0, 1)\n",
+    "g_accuracy = accuracy_score(yg_test, yg_pred)\n",
+    "\n",
+    "total_correct = (yg_test==yg_pred).astype(np.int8).sum()\n",
+    "total_incorrect = (yg_test!=yg_pred).astype(np.int8).sum()\n",
+    "\n",
+    "# compute fidelity \n",
+    "test_fidelity = 0.5*(e_accuracy + g_accuracy)\n",
+    "test_fidelity = 1/2 + (0.5*test_fidelity)\n",
+    "\n",
+    "y_pred = model.predict(X_test)\n",
+    "test_acc = accuracy_score(y_test, np.where(y_pred < 0.5, 0, 1).reshape(-1))\n",
+    "\n",
+    "print('\\n===================================')\n",
+    "print('    Accuracy', test_acc)\n",
+    "print('    Fidelity', test_fidelity)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "ml4qick-test-env",
+   "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.10.14"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}