model_investigation.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Matplotlib created a temporary config/cache directory at /tmp/matplotlib-upc19reo because the default path (/.config/matplotlib) is not a writable directory; it is highly recommended to set the MPLCONFIGDIR environment variable to a writable directory, in particular to speed up the import of Matplotlib and to better support multiprocessing.\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "from typing import List, Tuple, Dict\n",
    "from pathlib import Path\n",
    "from copy import deepcopy\n",
    "import hashlib\n",
    "import concurrent.futures\n",
    "\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from stego import FloatBinary, str_to_bits, bits_to_str, dummy_data_generator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Steganography with Neural Network Layers\n",
    "\n",
    "In this notebook I test how I can hide secrets in a model's parameters and then investigate how it effects the model's performance. A secret can be anything (text, image, video, software) as long as it can be converted to bytes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# How many bits (LSB) to use from the fraction (mantissa) of the float values\n",
    "BITS_TO_USE = 16\n",
    "assert BITS_TO_USE <= 23, \"Can't be bigger then 23 bits\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "DATA_FOLDER = \"/data\"\n",
    "\n",
    "IMAGES_TO_TEST_ON = list(map(str, Path(DATA_FOLDER).glob(\"**/*.jpg\")))\n",
    "assert len(IMAGES_TO_TEST_ON) > 0, \"You'll need some images to test the network performance\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Load the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-02-25 15:28:50.699856: I tensorflow/core/platform/cpu_feature_guard.cc:151] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 AVX512F FMA\n",
      "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2022-02-25 15:28:51.545033: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 30983 MB memory:  -> device: 0, name: Tesla V100-SXM2-32GB, pci bus id: 0000:3e:00.0, compute capability: 7.0\n"
     ]
    }
   ],
   "source": [
    "# Any model can be used here\n",
    "model = tf.keras.applications.ResNet50(include_top=True, weights=\"imagenet\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data storage capacity of the layers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "layers_storage_capacity_mb: Dict[str, int] = {}\n",
    "\n",
    "for l in model.layers:\n",
    "    if l.__class__.__name__ == \"Conv2D\":\n",
    "        nb_params = np.prod(l.get_weights()[0].shape)\n",
    "        capacity_in_bytes = np.floor((nb_params * BITS_TO_USE) / 8).astype(int)\n",
    "        layers_storage_capacity_mb[l.name] = capacity_in_bytes / float(1<<20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlcAAAF4CAYAAAB5Kdz6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAABGnUlEQVR4nO3dd7xcVfX//9dKCJ3QEgWEJCCCAiIgAnYQVJQiP0QFBcEGykeFD3w+iqgfwYqiWL/YkCpdikhTRBDpvYUiLYBK702krN8fe19yMpm5s8+9+5TJvJ+Px3lkyrp7rew195x9p5wxd0dERERE8pjQdAEiIiIi8xItrkREREQy0uJKREREJCMtrkREREQy0uJKREREJCMtrkREREQy0uJKpAFm9hEz+1PNOXcys/PrzFmWmc00sw2brmM0Zrahmf1jlPt/YWZfzZTrM2Z2n5k9aWZL5xhz0FlwiJk9YmaX9utHW5jZLDPbpOk6pB5aXMmozOwtZnahmT1mZg+b2QVm9oZ4X+sP1m3l7ke6+7tGrpuZm9nKTdbUBu6+urufm3tcM1vWzE4xs3/FuZ7RJWYTM7vSzJ4ys3+Y2QfHksvdP+3u34hjjvnAb2aTgAOAd7n7ou7+0FjGmQe9BXgnsLy7r5drUDObER8b8+UaU4aXFlfSk5lNBk4FfgosBbwC2Bd4NtP42olJXV4EzgTe3+1OM1sNOAr4MrA48Drgitqq6+7lwILAzG53ziu/P2P4f0wHZrn7U1XUI5KFu2vT1nUD1gUe7XHfa4B/Ay8AT47EEQ5MhwMPAHcCXwEmxPt2Ai4Afgg8BHwTeCXwl3j9QeBIYIlCnnWAq4AngOOBY4FvFu7fHLgaeBS4EFhzlP/P6sBZwMPAfcDe8fb1gIviGPcAPwPmL/ycA58Hbo817l/4P/WrfwXgxDgfDwE/K8zF+fHyeTHHU3EuPwRcD2xRGGdSHH/tLv+vvwLvj5ffHMfaLF7fGLi6mBP4PvAIcAfwnsI4iwO/iXPwz9ifiSk/26UmB1YuXD90pG/AFMKi/dHYi78V5nMWsEm8vA9wHOHx9ARhkbFu6mOjR13zxdpmdNx+FPCNxN+LDYF/AHvHnswCPtL5fwUWAZ4hLOyejNtyhMfb5cDjhMfhAV1yrBIfDx5/7i+Fef0v4Bbgjnjbp4Bb41yeAizX0YddY/wTwDcIj9kLY/7jKDzWu9TxceDG2PM/AtPj7T8Hvt8R+3tgj3h5OeAEwuP+DuDzhbh9gN8Bv401fAV4Gli6o7cPAJM6cnyCOfc7+470o2PfdG58fM0Etizct1l8zDwO3A3sU7jvrsJ8Pwm8sSP3crGfSxVuWzs+BibRf18wi9mP7UOZcz/W+X/oOX/aBmNrvABt7d2AyXFHcRjwHmDJjvt3Ii4QCrcdHneyiwEzgL8DnyjEPw98jnCQWwhYmfAU/wLAVMJC40cxfn7CAm23uPPaGvgPsw/SawP3A+sDE4Ed4w5sgS7/l8UIi4Y9Cc8GLAasH+97PbBBrGkG4WCye+FnHTiH8OzdtPh/+mS8b7T6JwLXEBaTi8S8b+k2d8y9GPkCcGzh+vuA63r06evAT+PlvYHbgO8W7vtxIedzhIPxROAzwL8Ai/efBPwy1voy4FJgl5Sf7VLTaIur7wC/iD2dBLy1UMMs5lxc/Rt4b8z5HeDilMfGKI/pXour2wkLj+vi4+S3FA6iHbEbEh7HB8S+v52wEFq1y/91QwoHzXjbRcAO8fKiwAY98syItc7XMa9nER6LCwHvIBzI14m1/BQ4ryP+94Tf5dUJzzqfDaxEWEzfAOzYI//7CIu218R5+wpwYbzvbYTFyUjfliQsPJYjvCJyBfB/sU8rxfl9d6GvzwFbxdiFgNOBzxRy/5D4mO5S107M+bvz0hzHx8KthN+D+eP8PFHozYbAa2PeNQmL2616zXeX3H8BPlW4vj/wi377gi6P7ZceI13+D6POn7bB2BovQFu7t7hjPZTwl/rzhL+MXx7v69zJTSQc4FYr3LYLcG4h/q4++bYCroqX30Z4BsUK95/P7APXz+l4tgG4GXh7l3G3Gxk34f+8O3BS4boDmxau7wqcnVD/Gwl/ec61s+4yd52LkeXiQWFyvP474As9cm4MXBsvnwl8ktmLkL8CWxdy3lr4uYVj3mUIL0E9CyzUMWfn9PvZHjWNtrj6OuGAv3KXn5vFnIurPxfuWw14JuWxMUpvey2u/hNzr0JY8JwAHNljjA0JvwuLFG47Dvhql//rhsy9uDqP8IzLlD61zqD74uodheu/Ab5XuL4oYeEyoxD/5sL9VwBfLFz/AYUFQEf+M4h/GMXrEwjPME0HjPBMz9vifZ9i9rNr69Pxew58CTik0NfzOu7/EHBBvDwRuBdYr0ddO9F7cfXW+LMTCvcfTeEZqo6xfgT8sNd8d4n/ZOH/aYQF5tt6xG5FYZ9D+uJq1PnTNhib3nMlo3L3G919J3dfHliDcND/UY/wKYS/HO8s3HYn4b1aI+4u/oCZvdzMjjGzf5rZ44RnDKbEu5cD/ulx79Ll56cDe5rZoyMb4WW45brUtgLhGZ25mNkqZnaqmd0ba/h2oYZuee8cydGn/hWAO939+W55R+Pu/yK8hPp+M1uC8MzhkT3CLwJWMbOXA2sRnj1cwcymEF6COq8Qe28hx9Px4qKEuZwE3FOYy18SnsHq97Nl7U94duFPZna7me01Suy9hctPAwvG9+j0e2yU9Qzh4PV3d3+S8Bh47yjxj/ic7/l56TGR4BOERdxNZnaZmW1estbi/3M5Cr9vsfaHmPN37r7C5We6XO/Vw+nAjwuPh4cJC4pXxHk/hrAAB/gwsx+f04HlOn4v9yYs4Lv9HyAstlczsxUJz/485u6X9qhrNMsBd7v7i4XbXtoHmdn6ZnaOmT1gZo8Bn2bu3/XRnAC80cyWJSzwXyS8rN1vX1BGyvxJy2lxJcnc/SbCX1xrjNzUEfIg4a/m6YXbphGeYXhpmI6f+Xa87bXuPhnYnrADh/DyzCvMzArxKxQu3w18y92XKGwLu/vRXcq/m/D0ejc/B24CXhVr2LtQQ7e80wgvifWr/25g2jjeeHxYHO8DwEXu/s9uQXGhcwXhJbLr3f0/hPfU7AHc5u4PJuS6m/DM1ZTCXE5299XHWPvThGe3RixTqPcJd9/T3VcCtgT2MLONS47f77FR1rXM+djsfJx2WtLMFilcLz4miuYax91vcfftCAvX7wK/6xirn+KY/6Lw+xbHWZo5f+fG6m7Cy8LF36+F3P3CeP/RwDZmNp3wbMsJhZ+7o+PnFnP34mJ1jnlx938Tnv3bHtgBOGKMNf+L8IdF8dhW3AcdRXj2fQV3X5zw8vTIY6hfz3H3R4A/EZ5p+zBwTGGBP9q+oNNT9Pj9IG3+pOW0uJKezOzVZranmS0fr69A+Ev14hhyH7C8mc0P4O4vEHaQ3zKzxeJOdw/CX3C9LEZ48+hjZvYK4H8L911EeOPqZ81sPjN7H+GZmBG/Bj4d/xo1M1vEzDYzs8W65DkVWNbMdjezBWJ96xdqeBx40sxeTXg/Uaf/NbMl4xzsRnjzdL/6LyUsAvaLtS1oZm/uMQ/3Mffi72TCe2l2IzwbNZq/Ap+N/0J4Q2/x+qjc/R7CQeMHZjbZzCaY2SvN7O0pP9/F1cCHzWyimW1KeF8SAGa2uZmtHBdGjxF6/GL3YXrq99iYi5ktSHg/DMAC8fqIQ4CPmdlKZrYwsBfhMTOafc1sfjN7K+GDFcd3ibkPWNrMFi/Usb2ZTY3Prjwaby77/x9xdKx7LTNbgHCAv8TdZ41xvKJfAF8ys9UBzGxxM/vAyJ3ufhXhD6qDgD+6+6PxrkuBJ8zsi2a2UHwMrGHxFC6jOJzwkt+WjH1xdQlhYf8FM5tk4ZxpWxCeZYPw+/qwu//bzNYjLJBGPEDoQ68/wkYcBXwU2CZeHjHavqDT1cB7zWwpM1uG8FaEEWOdP2kRLa5kNE8Q/iK9xMyeIiyqrie8KRzCmztnAvea2cizI58j/FV2O+E9MEcBB4+SY1/CAuIx4DTCJ+sAiM/AbE14GeVRwl+CpxJPBeHulxPe6/EzwqeZbiXsnOfi7k8QXm7YgvBS0y3ARvHu/yHsZJ8gLNiO7TLE7wnPDl0d6/xNQv0vxHwrE96f8g/CX7zd7AMcFl8G+GD8+WcIzwasWBy3h78Sdu7n9bie4qOEN9DeQJjP3wHLlvj5ot0I//dHgY8QFoojXgX8mXAgugg40N3PKTN4v8dGD8/EnBCeqXymMN7BhIP7JYSXkZ4lfEK0l3sJc/Qvwsthn47P7HbWeRNhAXR77O1ywKbATDN7EvgxsG3sdWnu/mfgq4THyT2ET6xtO5axuox9EuGZtWPiy1zXE16eLjoK2ITCIiM+7jcnvER9B7MXYIszCne/gLC4udLd7xwtdpQx/kN43L0n5j0Q+GihN7sCXzezJwhvGD+u8LNPA98CLoi92qBHmlMIj+F73f2awu099wVdHEH4sMsswh81L+1zxjp/0i4jn/QQGQhmdgnh0zmH1JjTCS8Z3lpXzkLu/wNWcfft6849aJp4bEheZvYX4Ch3P6jpWkTGQ89cSauZ2dvNbJn40s+OhI9Pn9l0XXUws6UIz8z8qula2miYHxvzoviy1zp0f+ZYZKBocSVttyrh6fNHCS9HbhPfHzRPM7NPEd7Yeoa7l3lpb5gM5WNjXmRmhxFeKt49voQvMtD0sqCIiIhIRnrmSkRERCSjVn3x55QpU3zGjBlNlyEiIiLS1xVXXPGgu0/tvL1Vi6sZM2Zw+eWXN12GiIiISF9m1vW0IXpZUERERCQjLa5EREREMtLiSkRERCQjLa5EREREMtLiSkRERCQjLa5EREREMtLiSkRERCQjLa5EREREMtLiSkRERCSjVp2hXUREZBjN2Ou0nvfN2m+zGiuZ02h1QTW1NZEzNz1zJSIiIpKRFlciIiIiGWlxJSIiIpKRFlciIiIiGWlxJSIiIpKRFlciIiIiGWlxJSIiIpKRFlciIiIiGWlxJSIiIpKRFlciIiIiGWlxJSIiIpKRFlciIiIiGWlxJSIiIpKRFlciIiIiGWlxJSIiIpKRFlciIiIiGWlxJSIiIpKRFlciIiIiGWlxJSIiIpJR5YsrM5toZleZ2alV5xIRERFpWh3PXO0G3FhDHhEREZHGVbq4MrPlgc2Ag6rMIyIiItIW81U8/o+ALwCL9Qows52BnQGmTZtWcTkiIiKDacZep416/6z9NqupEumnsmeuzGxz4H53v2K0OHf/lbuv6+7rTp06tapyRERERGpR5cuCbwa2NLNZwDHAO8zstxXmExEREWlcZYsrd/+Suy/v7jOAbYG/uPv2VeUTERERaQOd50pEREQko6rf0A6Au58LnFtHLhEREZEm6ZkrERERkYy0uBIRERHJSIsrERERkYy0uBIRERHJSIsrERERkYy0uBIRERHJSIsrERERkYy0uBIRERHJSIsrERERkYy0uBIRERHJSIsrERERkYy0uBIRERHJSIsrERERkYy0uBIRERHJSIsrERERkYy0uBIRERHJSIsrERERkYy0uBIRERHJSIsrERERkYy0uBIRERHJSIsrERERkYy0uBIRERHJSIsrERERkYy0uBIRERHJSIsrERERkYy0uBIRERHJSIsrERERkYy0uBIRERHJSIsrERERkYy0uBIRERHJSIsrERERkYy0uBIRERHJSIsrERERkYy0uBIRERHJSIsrERERkYy0uBIRERHJSIsrERERkYwqW1yZ2YJmdqmZXWNmM81s36pyiYiIiLTFfBWO/SzwDnd/0swmAeeb2RnufnGFOUVEREQaVdniyt0deDJenRQ3ryqfiIiISBtU+p4rM5toZlcD9wNnufslXWJ2NrPLzezyBx54oMpyRERERCpX6eLK3V9w97WA5YH1zGyNLjG/cvd13X3dqVOnVlmOiIiISOVq+bSguz8KnANsWkc+ERERkaZU+WnBqWa2RLy8EPBO4Kaq8omIiIi0Qek3tJvZBGBRd3+8T+iywGFmNpGwiDvO3U8dQ40iIiIiAyNpcWVmRwGfBl4ALgMmm9mP3X3/Xj/j7tcCa2epUkRERGRApL4suFp8pmor4AxgRWCHqooSERERGVSpi6tJ8USgWwGnuPtz6JxVIiIiInNJXVz9EpgFLAKcZ2bTgX7vuRIREREZOknvuXL3nwA/Kdx0p5ltVE1JIiIiIoMr6ZkrM3u5mf3GzM6I11cDdqy0MhEREZEBlPqy4KHAH4Hl4vW/A7tXUI+IiIjIQEtdXE1x9+OAFwHc/XnCaRlEREREpCB1cfWUmS1N/ISgmW0APFZZVSIiIiIDKvUM7XsApwCvNLMLgKnAByqrSkRERGRApS6uZgJvB1YFDLiZmr70WURERGSQpC6QLnL35919prtfH08ielGVhYmIiIgMolGfuTKzZYBXAAuZ2dqEZ60AJgMLV1ybiIiIyMDp97Lgu4GdgOWBAwq3Pw7sXVFNIiIiIgNr1MWVux8GHGZm73f3E2qqSURERGRgpb7nan8z29/MXlNpNSIiIiIDLnVx9TrCWdl/Y2YXm9nOZja5wrpEREREBlLS4srdn3D3X7v7m4AvAl8D7jGzw8xs5UorFBERERkgqV/cPNHMtjSzk4AfAT8AVgL+AJxeXXkiIiIigyX1JKK3AOcA+7v7hYXbf2dmb8tfloiIiMhgSl1crenuT3a7w90/n7EeERERkYGW+ob2l5nZH8zsQTO738x+b2YrVVqZiIiIyABKXVwdBRwHLAMsBxwPHF1VUSIiIiKDKnVxtbC7HxG/X/B5d/8tsGCVhYmIiIgMon7fLbhUvHiGme0FHAM48CH0KUERERGRufR7Q/sVhMXUyBc271K4z4EvVVGUiIiIyKDq992CK9ZViIiIiMi8IPVUDJjZGsBqFN5r5e6HV1GUiIiIyKBKWlyZ2deADQmLq9OB9wDnA1pciYiIiBSkflpwG2Bj4F53/xjhi5wXr6wqERERkQGVurh6xt1fBJ43s8nA/cAK1ZUlIiIiMphS33N1uZktAfya8AnCJ4GLqipKREREZFAlLa7cfdd48RdmdiYw2d2vra4sERERkcGU+ob2dbrc9krgTnd/PntVIiIiIgMq9WXBA4F1gGsJJxRdA5gJLG5mn3H3P1VUn4iIiMhASX1D+7+Atd19XXd/PbA2cDvwTuB7VRUnIiIiMmhSF1eruPvMkSvufgPwane/vZqyRERERAZT6suCM83s54Qvbobwxc03mNkCwHOVVCYiIiIygFKfudoJuBXYPW63x9ueAzbq9gNmtoKZnWNmN5jZTDPbbbzFioiIiLRd6qkYnjGzA4FT3f3mjruf7PFjzwN7uvuVZrYYcIWZnRVfUhQRERGZJyU9c2VmWwJXA2fG62uZ2Smj/Yy73+PuV8bLTwA3Aq8YV7UiIiIiLZf6nquvAesB5wK4+9VmtmJqEjObQfiE4SVd7tsZ2Blg2rRpqUOKiIhIFzP2Om3U+2ftt1lSTK6cI2M1kbMpqe+5es7dH+u4zVN+0MwWBU4Adnf3xzvvd/dfxVM8rDt16tTEckRERETaqcynBT8MTDSzVwGfBy7s90NmNomwsDrS3U8ce5kiIiIigyH1mavPAasDzwJHA48TPjXYk5kZ8BvgRnc/YBw1ioiIiAyM1E8LPg18OW6p3gzsAFxnZlfH2/Z299NLVSgiIiIyQEZdXCV8InDLUe47n/A9hCIiIiJDo98zV28E7ia8FHgJWiyJiIiIjKrf4moZwpczbwd8GDgNOLr4PYMiIiIiMtuob2h39xfc/Ux33xHYgPAVOOea2WdrqU5ERERkwPR9Q3v8cubNCM9ezQB+ApxUbVkiIiIig6nfG9oPB9YATgf2dffra6lKREREZED1e+Zqe+ApYDfg8+HUVUB4Y7u7++QKaxMREREZOKMurtw99SSjIiIiIkL6GdpFREREJIEWVyIiIiIZaXElIiIikpEWVyIiIiIZaXElIiIikpEWVyIiIiIZaXElIiIikpEWVyIiIiIZaXElIiIikpEWVyIiIiIZaXElIiIikpEWVyIiIiIZaXElIiIikpEWVyIiIiIZaXElIiIikpEWVyIiIiIZaXElIiIikpEWVyIiIiIZaXElIiIikpEWVyIiIiIZaXElIiIikpEWVyIiIiIZaXElIiIikpEWVyIiIiIZaXElIiIikpEWVyIiIiIZaXElIiIiktF8TRcgIpJqxl6njXr/rP02q6mSuY1WWxV1NTEXylldTpm36JkrERERkYy0uBIRERHJqLLFlZkdbGb3m9n1VeUQERERaZsqn7k6FNi0wvFFREREWqeyxZW7nwc8XNX4IiIiIm3U+KcFzWxnYGeAadOmNVyNiMwL6v7knkgv+uThcGr8De3u/it3X9fd1506dWrT5YiIiIiMS+OLKxEREZF5iRZXIiIiIhlVeSqGo4GLgFXN7B9m9omqcomIiIi0RWVvaHf37aoaW0RERKSt9LKgiIiISEZaXImIiIhkpMWViIiISEZaXImIiIhkpMWViIiISEZaXImIiIhkpMWViIiISEZaXImIiIhkpMWViIiISEZaXImIiIhkpMWViIiISEZaXImIiIhkpMWViIiISEZaXImIiIhkpMWViIiISEZaXImIiIhkpMWViIiISEbzNV2AiEgTZux12qj3z9pvs1JxdeUsk6+NOauY1yZy5q5f5i165kpEREQkIy2uRERERDLS4kpEREQkIy2uRERERDLS4kpEREQkIy2uRERERDLS4kpEREQkIy2uRERERDLS4kpEREQkI52hXQZWm8+QnPNs1+PNNy/lFBEZBFpcyTxPi4DBUPeCVESkKnpZUERERCQjLa5EREREMtLiSkRERCQjLa5EREREMtLiSkRERCQjfVpQhPRPFOb85OGg5iz7yT19WlNEho2euRIRERHJSIsrERERkYwqfVnQzDYFfgxMBA5y9/2qzFe3Nr/cMehnCNcJJUVEZFBVtrgys4nA/wPeCfwDuMzMTnH3G6rK2VYpCwW9/2Zs44mIiLRNlc9crQfc6u63A5jZMcD7gEYXV00sKERERGR4mLtXM7DZNsCm7v7JeH0HYH13/2xH3M7AzvHqqsDNlRTU2xTgwQwxuePaOlYTOQe9/iZyqv5mc6r+ZnMOev1N5ByW+nOb7u5T57rV3SvZgG0I77Maub4D8LOq8o2jzstzxOSOa+tYqn8wcqp+1d+WsVT/YOQclvrr2qr8tOA/gRUK15ePt4mIiIjMs6pcXF0GvMrMVjSz+YFtgVMqzCciIiLSuMre0O7uz5vZZ4E/Ek7FcLC7z6wq3zj8KlNM7ri2jtVEzkGvv4mcqr/ZnKq/2ZyDXn8TOYel/lpU9oZ2ERERkWGkM7SLiIiIZKTFlYiIiEhGWlyJiIiIZKTFldTOzLY2swXalrOtdaXGlRhrnTrrSs2Zm3o+R9w83/M291Kq0eb5H8rFlZntYWav6BPzEzN7U8JYqXEpOfvGpObMWVdqXOpYwBbA383sCDPb3Mzm+tRqzrpScybG1D4XuesHfmBmN5rZN8xsjRrqSsqpnldXP8PR82y9rCBnW/fZ2Y5zuX9/c85/I5o+i2kTG/A1YCbwN+CzwMu7xOwInA7cBnwfWLfHWKlxKTn7xqTmzFlX7vpj7CRgS+BI4E4KZ/PPXVdqzhIxtc5F7vpj3DLA54ELgOuAr1RZV0pO9Vw9H2/Pc/Wygpxt3WdnO85VMK/Z5r+JrfECGv3Pw5rAt4CbgD/3iFkK+BRwNnDLKGOlxqXk7BuTmjNnXRXUP4nwl8eJwINV11UiZ9+YJuYid/0x9rXAEcB/qq6rRE71XD0fz/xn62UFOdu6z852nKvg9zfb/Ne5DeXLggX3A/cCDwEv6xGzMvBqYDqhub2kxqXkTIlJzZmzrtS4UWPM7D1mdihwC/B+4CDCX7iV1ZWSs2RdqbVlmYuc9ZvZa8xsHzO7DvgpcCHh66kqqSs1Z4F6nrn+Yeh5Rb3MnbOt++ycx7mcdY0aN4b5r0/Tq7smNmBX4FzCU477AKt1ifkeoWFnAh8DlugxVmpcSs6+Mak5c9ZVQf1HA1sBC4ynRxXk7BvTxFxUUP9FwG7AchnGyplTPVfPx7P/ydbLCnK2dZ+d7TiXs67c89/E1ngBjfyn4TvAWn1idgGmJIyVGpeSs29Mas6cdeWuP1ePcufM/Pipva5B39Tz4dua6HlDOdu6z852nMs9r4P++zS0X39jZhOBl1P4fkV3v6sj5hWEpz+LMed1GSs1LiVn35jUnDnrylm/mW0NfJfwFK/Fzd19coV19c2ZWldDc5GtfjN7M+EvwZHHxkjcSlXUlZozdc5S49TzOcaa53ueu5cV5GzrPjvbcS5nXSlxZea/bkO5uLLwhdL7APcBL8ab3d3XLMTsB2wL3AC8UIjZsmOs1LiUnH1jUnPmrKuC+m8FtnD3G+khZ10lcvaNSc2Zs64K6r8J+G/gCmY/NnD3h6qoq0RO9by6+uf5nufsZQU527rPznacq+D3N9v8N8Jb8PRZ3RtwK7B0n5ibSXgdt0RcSs6+Mak5c9ZVQf0X1FlXiZx9Y5qYiwrqv6TOukrkVM/V8/HMf7ZeVpCzrfvsbMe5Cn5/s81/E1t7TrhVr7uBx/rE3E74eOezmeJScqbEpObMWVdqXOpYl5vZscDJFOpz9xMrqis1Z0pMas6cdeWu/xwz25/wseVi3JUV1ZWaUz2vrv5h6HnOXubO2dZ9ds7jXO7f35zzX7thXVzdDpxrZqcxZ0MOKMQ8DVxtZmd3xHy+Y6zUuJScKTGpOXPWlbv+ybG+dxVuc8JOuIq6UnOmxKTmzFlX7vrXj/+u2xH3jorqSs2pnldX/zD0PGcvc+ds6z4753Eu9+9vzvmv3bAuru6K2/xx6+aUuPWTGpeSMyUmNWfOulLjksZy94/VXFdSzsS6UnPmnIus9bv7RhnHypYT9bx0nHpevq6GcrZ1n53zOJf19zclrsT816/p1yWb3IBFgUVHuX9+YI24TRpvXErOEjF9c+auK1f9hBMJnkQ4Odz9wAnA8lXWlZKzTF11z0XO+oHFgQOAy+P2A2DxqupKzameq+fj6XkVvcyZk5bus1NzlojLdizJ3fM6t8YLaOQ/HR4cVxG+h+hOwqdZVu+I2TDe91fgPOAO4G1dxkqNS8nZNyY1Z866Kqj/LMKJ6OaL207AWVXVVSJn35gm5qKC+k8A9gVWitvXgBOrqqtETvVcPR/P/idbLyvIuSHt3Gen5kypP/fvb7b5b2JrvIBG/tPhaxg26njgXNgRcwWwauH6KsAVXcZKjUvJ2TcmNWfOuiqo/+p+t+Wsq0TOvjFNzEUF9dc6lnquntfR85y9rCBnW/fZ2Y5zOevKPf9NbBMYTou4+zkjV9z9XGCRjphJ7n5zIebvhE9LdEqNS8mZEpOaM2dduet/yMy2N7OJcdue8L1RVdWVmjMlJjVnzrpy1/+Mmb1l5IqFkz0+U2FdqTnV8+rqH4ae5+xl7pxt3WfnPM7l/v3NOf/1a3p118RGeI32q8CMuH0FOKkj5mDCl0BuGLdfAwd3GSs1LiVn35jUnDnrqqD+6YQ3Rz5AeJ38ZGBaVXWVyNk3pom5qKD+tYBrgFlxuwp4XVV1lcipnqvn49n/ZOtlBTnbus/OdpzLWVfu+W9iG9YztC9JeC/AWwgf2/wbsK+7P1KIWQD4rxhDjDnQ3Z/tGCs1LiVn35jUnDnryl1/ipx15Vb3XFTFzCYDuPvjbcipnldPPW8sZ1v32dmOc7nndRB+n0bV9OqurRvh6ceJhesTgYXHGld3bU3UVaL+wyh8qzqwJF3+Wqo7Z1vryl0/8O0ucd+sqq7UnOq5el7HvDbUy1bus1NzNlFbW3ueXFvTBTTUkLO6NOSPHTEXU/j4J+HjoN3edJcal5Kzb0xqzpx1VVD/Vf1uy1lXiZx9Y5qYiwrq73bblVXVVSKneq6ej2f/k62XFeRs6z4723Gugt/fbPPfxDasb2if4u6Pjlzx8DTjyzpiFnT3JwsxTwILdxkrNS4lZ0pMas6cdeWuf0J8yhcAM1uKuU9om7Ou1JwpMak5c9aVu/6J8Wn+kbiFgAU6YnLWlZpTPa+u/mHoec5e5s7Z1n12zuNc7t/fnPNfu1YU0YAXzWyau98FYGbTCa/pFj1lZut4/B4sM3s9c3/SpUxcSs6UmNScOevKXf8PgIvM7Ph4/QPAtyqsKzVnSkxqzpx15a7/SOBsMzskXv8Y4en1qupKzameV1f/MPQ8Zy9z52zrPjvncS7372/O+a9f00+dNbEBmxJOq38E8FvCCcre3RHzBuA2wpvozid8Q/fru4yVGpeSs29Mas6cdeWuP8auBnw2bqt13LdkzrpSc5aIqXUuctdfqO/7cau8rpSc6rl6Pt6e5+plBTnbus/OdpyrYF6zzX8TWyNJ27ABU4DN4zal477V47+T6HG6f+CdhcupcSk5+8ak5sxZV+76+/Tmytx1peZMjal7LnLX3yfuojrrKuZUz9XzqnpetpcV5GzrPjvbcS73vOac/7q3RpK2fcu802piRzno9V/VQP0pOfvGNDEXFdRf61jq+WD0adB7nrOXTeRs+T67rfUnzX8V27C+ob0fyxSTO66tY+XO6RnHypkzJSY1Z866UuPaOlZqnHpePq6tY6XG5ex5zl42kbPN++y21p86/9lpcdVdW3c0bR0rd85c+XLnTFX3XAwL9Xz4NNHztuZs8z67rfU3RosraaPUv1zqztnWulLj2jpWmbic1PPmxioTl0ubeynVaGz+tbjq7j8JMbMSx0qNS8mZEpOaMyWmTM6k+s1sgplNADCz+c1snXhukqKNc9ZlwfpmtnXc1jezzl+6TTLVlVrbuOfCzBYtWdtcMV3yAeyQKd+4c3ZQz9XznnE19zJ3zlmZYiDvPjs1Z0pczrog7/zn19Sbvdq2Aa9OiHlnx/XJwCu7xK3ZcX1x4EPAHnH7EIUzz8aYZYBl4uWpwNYkfrqos7YSdY0356s7rk/qEjOlcHkr4D7gHuB9wCXA2cA/gC3G0qOEnO8ifGz4DMIXjx4EnBlve1eOupqYizjGXfHf1xLOoHw38Cvm/Cj8pYXLbwZuBGYC6xPOgHxb/Lk3puarOad6rp6POrdV9LKmnGPZZ/c9lsS4Me/bGcNxbjz5mpr/qrfGC2jLVtyJpMQAHwT+BVwddyJvKNxX/PjtR+OO5eeEb/X+CvCLeNtHY8wuwB2E1f9n4gPlN8DNwCfK1F+irpw5N4oP6geBPwEzeuS8Kv4Srgg8Dqwab58OXF5y/lNz3li8r3D7isCNOeqqci6YvRPt3PYEHo4x5xPOCbME8D+x768cyVMY61LCAfKNsb63xNvXAS5IzZc7p3quno+n5zl72UROMh5LYty49u2UPM6NN19T81/1NlRnaDezn/S6i7DDwMxOGSVm6cL1vQknUbvHzNYDjjCzL7n7Scz5Ou+XY9yjHbUsSXgQHk44+dnqwEKEE6Wt7O73xphzCA/U1NpS60rN2XfOgO8RTu4208y2Ac4ysx3c/eKOnLj7vXHcu9z95njbnYWnd1Pylck5H+EXtdM/CedtSaqribmIvg3sDzzfJe9I3GLufma8/H0zuwI408x2YM43fU5y9+tizgfc/fyY80oLX02Smi9rTvVcPS8YU88z9jJ3zpz77JRjCSTs2zMf53IeSyDj/DdpqBZXhK9f2BN4tst928V/3wpsDzzZcb8B6xWuT3T3ewDc/VIz2wg41cxWYM4djdH9Uw0vMvuB8py7Pw08bWa3jTxo3P0RMyv+bEptqXWl5kyZs/ndfWb8+d+Z2Y3AiWb2xc7/u5lNcPcXgY8XbpsIzF8iX5mcBwOXmdkxhJclAFYAtiX+0ifW1cRcAFwJnOzuV3QmNLNPFi4v7u6PxbznmNn7gROA4nsQijudL3UMN5IzKV/mnOq5el5UuucZe5k7Z859dsqxBNL27TmPczmPJZB3/pvjLXj6rK4N+Avwph733RH/PQPYqEfMeYXLF9LxOjSwGOF132cLt+3I7Kdy947byFO5O8WYK4ivLwPLF352QeCawvW+tZWoKzVnypxdTny9vXDf8oSnkp8o3PYGwheAdo4zA9g+NV+ZnPH21wB7AT+N214UviYhpa4m5iJeX5WOMxMX7nt5/PfDwAZd7p8G/LpwfUtg4S5xrwS+kJqvgpzquXo+5p7n7GUFOXPus/seS2Jc3317Sl2ptaXka2r+m9waL6DW/2z462quX/oxjvU6wtOfnbdPAj7ScduShL+a94zbtsz5ZtBpwHxdxnoFsEkVdaXmTJkzYBPgdV1uXxz48hh6dHJCXLac8edOSIg5pc65SK0rxv00R0xDYy0F/Fw9V8+rnNuUXlaQM+Uxlu1YEmNqPZ7kPJY0Mf9VbY0kbXojfJJhgXGO0fe7uHLHtXWsGJeyE0k9aFyVcaycOfvGNDEXMW4YvspCPVfPxzP/2XpZQc4m9tltPebUPv9VbK1441cDtgD+bmZHmNnmZjaW954t2EBcW8cCWClTDKSdeTd1rJw5U2JSc+asa1io58MnZ89z9jJ3zib22W095jQx/9kN5eLK3T8GrAwcT3gj3W1mdlDZYRqIa+tYuXPmypc7Z6q652JYqOfDp4metzVnm/fZba2/McP2acGXuPtzZnYGoUELEU5K9slRf0jq0tavqWhrXalxbR2rTFxO6nlzY5WJy6XNvZRq6Otv6mRm7zGzQ4FbgPcTzuC8TNlhGohr61i5c34x41g5c6bEpObMWRfAjzPFzBVnZi9LGSt3XBfq+ZzU83JxOXs5V5yZLd0lponHT1uPE03Unzr/+TX1Zq8mN+BowjNVY35TO7BG3XFtHSvGvSsh5hOEjwCfRvhY9qHAo4QzOr+m5Pz3zdcvDjgj4ef7xoxxLrYCvgMcAXy4474DC5eXIXz0+v8RTu63D3AdcBywbGpMibGW6tiWJpx5eUlgqcJYWePUc/V8HPO6KbO/1mhxwrnMrgWOonAqiR4/u3RKzs44YD9gm3h5XeB2wtcr3Qm8fQyPnyb22W095qT0/NWE48a4jyVVbY0XMEgbcF3dccUYwokQjwH+RjjHyaTCfSenxpSMezV9FkQpMTHuPMKHCbaLO6FtCX99bAGcnTAXSQe9YhzhKze6ba8H7kmNiXGT6XNwTImJl08g7KC3InxE/ATiYp85v/LiTOBzhPM0XUv4S2yFeNvvU2NKjPUi4assittz8d/bC2NljVPPh6vnwKaF+J4LopS4jrk7CPgm4WtQ/ps592X7Mfu76XouiFLimHO/fA7xa2GAVUj/+ptS+/+ccWQ8TpQYK/U4kXLMGdexpI7NYqFDxcy2Br4LvIzQEAPc3SfH+7r+GPALd59aGCNLXImxziLskC8mPAv0esKXVD5kZle5+9opMaljxbjzCF+NsShhp/NF4Fhgc2B3d984JSaOVRz3Vndf+aX/qNmV7r6Oma0zylyc6u7LxvjUuBeAv9L9KeQN3H2hlJg41gmEl5IvJpwV+DnCwfTZQv19Y+JYV7v7WoX//5eB9xJOwHhWIa44Z3e5+7TCz1zt7mulxJQYa0/gncD/+uyvMLnD3VecY5IzxqnnQ9nz4rwcBNwL/Jpwmpy3u/tWqXF95rg4F9e5+2vj5XMIJzS9zMxWAY5y93VT4+JZw1/r7s+b2cXuvkEhZ/Hnc+7/cx5zsh0nch5LUuNSjiU95qA2w/qG9u8Rmn9jl/uOBY6k+ycRFqwoLnWsqe7+i3j5c2a2PXCemW1Z+NmUmDJxi7n7HwDM7Bvufky8/Q9mtm+JGICJhcsHdPw/R76y4DJ6H/SWKFxOjbsR2MXdb+kMMrO7S8RAOFPx++Plk+PB8S9xzsrEACxgs7++AXf/lpn9k/AX2aKFuOL7Ig/vGGNCiZikOHf/gZkdC/ww/t+/RpfHZeY49Xz4el60bmFB9EMz27Fk3MvMbA/C42KymZn7S88aFP//85nZfO7+PLCQu18W6/27mS1QMu5A4HQz24/w/Yo/Bk4E3kE4k/iInPv/nHE5jxM5jyWpcSnHkmZ5C54+q3tjlG9mJ5zKv+trw8DdVcSVGGsmHaf8J5zN9lZmv9zRN6Zk3LWFy7t2xF+fGhMv7wIs2uX/uDLwo5F44FUJc5Eatw3xG9O7xG2VGhMv3whM6Lh/pziXd6bGxNu+R5ezJRPeP3JL4frXR5mz36XGlIkr3L4l4a/Re3v9vuSIU8+Hsuf/APYgnGX8dgivosT7ri0TR1i8Fbep8fZlgMML8Z8D/kRYAO1DeEP924F9gSPGELchYSFzFeF9bKcDOzPny2I59/85jznZjhMlxko9TqQcc/oeS5reGi+gkf90+GU5lvB67dYjW7zvrcC0Hj+3buFytrgSY/03Xd4sCaxNeFkhKaZkXMqCqNQDnS5vagVWjP+mHvSS4gq3zfXhhc46+sWQcHBMiSlbV676xzIW4TQla/Qbazxx6vlQ9jx1QZQUV+L/uCF9FkQl47p9v13x8ZNz/5/zmJPtOFFirKTjRGrcKI+7Fbv93+veGi+gkf80HNJlO3gsTcsZ19axKsh5ATC5cH01Cn+5xNuyHTTibacx51+UywJXlI1JzZmzrgrqTx1rvsSxssSp5+r5eHpeoq5RF0Rl4krkHPR9dlvr73ssaWprvIC2bqlNyxnX1rEqyLkZ4b0zixLe/DgTWKsjJttBI97+KeAkwmv1MwifOHpX2ZjUnDnrqqD+WscqkVM9H86e51qolell3TkHfZ/d1vr7Hkua2hovoJH/NCwffyHuj9sJwPJjaVrOuLaOlTtnjN0KuJDwlPsqXe7PuqOPsf8F/CHmfNM4YrIdqFJz5qy/ibFS4tTz5vs06D3P1csKcg70Prut9ce4rRjlWNLUNqyfFjyEcJ6UD8Tr28fb3jkS4O6nmdkkwhsbFwP+P3f/e+dAOePaOlaunGb2U+b89MjiwG3AZ80Md/98Yaxfm9n8wMmEHdsu7n5hl7pGjYufInrpKjCN8GmeDcxsA3c/ICWmTM5cdeWuv+6xysSlzFlqnHo+XD2vopcV5BzIfXZb6y9zLGnKsC6uprr7IYXrh5rZ7pDetJxxbR0rd07gcuZ0Rcf1Knbgi3WkOLHL7SkxuQ/aSTlz1t/AWElx6nnjfRr0nmfrZQU5B3qf3db6STiWNG1YF1cPWTgXx9Hx+nbAQ/FyatNyxrV1rKw53f0wADNbBPi3u78Qr08ERs4fk3VH7+770kdKTImc2epKjWvrWCXi1POScW0dq0Rctp5n7mXunAO9z25grKS4xGNJs7wFr03WvRG+GuEU4AHCe65OBlboiFkEmFi4PhFYuMtY2eLaOlYFOS+m8FFbwmvqF1bc87OAJQrXlwT+WDamibpy11/3WG2e27bWpZ5XN68N9XLQ99ltrb/2Y0nqVjx77TD5OrCju09195cRvrKi8y+RswnnZxmxEPDnLmPljGvrWLlzLujuT45ciZcXLgaY2VlmtkTh+pJm9sfOgVLjCC8FP1rI+Qjh64/KxiTlzFxX1vobGCspTj2vrv4GxkqKy9zzbL3MnZPB32e3tf6+x5KmDOvias34SwCAuz9MOOFZUWrTcsa1dazcOZ+ywvfEmdnrgWc6YnLv6F8ws+L3qk1n7q+HSIlJzZmzrtz11z1Wapx6Xl39w9DznL3MnXPQ99ltrT/lWNKIYX3P1QQzW3JkgWVmSzH3XDxlZuu4+5UxplfTcsa1dazcOXcHjjezfxHeMLoM8KGOmBfMbJq73xXHGnUHnhD3ZeB8Mxv5brq3Es64XDYmNWfOunLXX/dYqXHqeXX1D0PPc/Yyd85B32e3tf7d6X8saYa34LXJujfgo8BNwDfidhOwQ0fMGwifUPgbcD7he5Je32WsbHFtHSt3zhg7CVgjbpO63L8pcBdwBPBb4E7g3WONi7FTCN+svjkwZRwxfXPmritn/U2MlRKnnjffp0Hvea5eVpBzoPfZba0/xo16LGlqs1jc0DGz1QhfzAnwF3e/oUvMJGDVePVmd3+ux1jZ4to6Vs6cMeYzwNviTecCv+yMNbMpwAbx6sXu/mCPulLjtizmdPdTxxKTmjNnXRXUX+tYJXKq59XVP8/3PGcvK8g5sPvsttafeixpwrC+LEhcTM21oBrRrWlm1m0BkC2urWPlzgn8nPDXxoHx+g7xtk92xL2pMBZA151WSpyZ7Uf4S+jIeNNuZvYmd9+7TEzJ2rLUlbv+uscqE4d6Xkn9w9DzCnqZLeeg77PbWj/px5LaDe0zV/2Y2UGEph0Wb9oBeMHdP1lVXFvHqiDnNe7+utFu67LT2g64LGEH3ivuWsJXJ7wYr08ErnL3NcvEpObMWVcF9dc6Vomc6nl19c/zPc/ZywpyDvo+u6319z2WNMZb8NpkGzfgmrpva+tYFeS8Enhl4fpKwJUdMdcCEwrXJwLXdhmrTNxShetLdcalxKTmzFlXRfXXNlbJnOq5ej6e+c/SywpyDvo+u6319z2WNLUN7cuCCV4ws1e6+20AZrYS8ELFcW0dK3fO/wXOMbPbASOc1PVjXeKWAB6Olxfvcn+ZuO8AV5nZOTHn24C9xhBTJmeuunLXX/dYZeKWQD2vov5h6HnuXubMOej77LbWn3osqV/Tq7u2bsDGhE+KnEv4Zu5ZwEZVxrV1rNw5Y+wCwJpxW6DL/dsRPp1zKOFp4TuAD401LsYuC2wZt2XGEdM3Z+66ctbfxFgpcep5830a9J7n6mUFOQd6n93W+mPcqMeSpja952oUZrYAc35S4dmq49o6Vo6cZrZ1t3FHuPuJHWMtS3jPA8Cl7n5vj7p6xlnhBHM9cl6ZElMmZ666ctdf91hl4kao5+p52Z5X1csKcg7cPrut9Zc9ljRBi6sOqU3LGdfWsSrIecjoYf7xCnb05/TJ+Y6UmNScOetKjWvrWCVyqufqeWdQmcVhtl5WkHPQ99ltrb/vsWS0MeqgxVWH1KbljGvrWLlzpsi9o88p54FKZlPPh08TPW8o50Dvs9ta/yj3t4YWV1I7M1sa+BrwFsLXSZwPfN3dH6ow54LAroWcfwN+4e7/LhPTRF256697rDJxOannzY1VJi6XNvdSqtHEsSSVFlc9pDYtZ1xbx6og51nAeYSvlAD4CLChu29SiMm9oz8OeKKQ88PAEu7+gTIxqTlz1lVB/bWOVSKnel5d/fN8z3P2soKcg77Pbmv9fY8lTdHiqofUpuWMa+tYFeS83t3X6LjtOnd/beF67h39De6+2mi3pcSk5sxZVwX11zpWiZzqeXX1z/M9z9nLCnIO+j67rfX3PZY0xlvwkcU2bsD1XW67rsq4to5VQc4DgG2BCXH7IPD9jpgbuvzceG77LbBB4fr6wOFlY1Jz5qyrgvprHatETvVcPR/zbTl7WUHOQd9nt7X+vseSpjadRLS3P5nZtsBx8fo2wB8rjmvrWFlymtkThKd3Ddid8G3zEM58/CTwP4WxrjSzDdz94viz6wOXd6lr1Dgzuy7mnARcaGZ3xevTgZtSY8rkzFVX7vrrHmsMc6ueZ65/GHpeUS9z5xzIfXZb6y95LGmEXhbs0NG0RZh9RtiJwJPuPjl3XFvHyp0zRdxpzQ+8SDi/yRw7LY9Pt3fs3EaLmz5aPne/M8ZMBh7vFRPHmhn/bz1z5qwrxr22V11jqL/WsUrkvI7Zf3mq5+p5qZ6XmNe+vawg50Dvs9ta/2hzX2Rmq7v7zNT4nLS4GqPUpuWMa+tYOXPGndZpwGbd7h/Djn5Jd3+kT/mY2ZXuPur5bczs+l51jeQscaDKVldqXIvHUs9L1pUa1+Kxau95Si8ryJk6ZwO7z25irBI5k+a/EmVeQ9Q2x2u9SV8OmTOurWNVkPOqBupPydk3pom5qKD+WsdSzwejT4Pe85y9bCJny/fZba0/af6r2Cb0XnZJH9ZAXFvHyp0z5enU3PWn5Ex9mrfuuUiNa+tYqXHqefm4to6VGpez5zl72UTONu+z21p/Yy/NaXE1dk3saNo6Vu6cufLlzpmq7rkYFur58Gmi523N2eZ9dlvrb4wWV9JG/2kgZ86/vHJq61+OTfwVmpt63txYZeJyaXMvpRpNHEsALa7GI7VpOePaOlapnGY2qfMOM5syctndN0gYK3kHbmYTzGxCvDK/ma1jZkt1xG2SELNxas6MdW2cs/4GxkqO6zlTs435oG1mu3aJ27hsTJmcuepKjWvrWGXiuhhTz2voZe6crd5nt3CsOeLMbNG4X1miGJB4LKmEPi3Yg5lNcvfnOm6b4u4PVhXX1rFy5TSzjQjnI1kQuBLY2d1nxfte+lTHyIHY3V80s/mBNYBZ7v5wYdylgEcT4rYHfkA4tcOngb0J50FZFfiMu//BzLYCfjlaTGG8lNqWBh4Zb10xrm9tqfXXPVaZuE5mtqu7H9hx21LFORwl7svAM8WbgC8B3wZw9wPMbI/OlJ0x3epKrW2sdcW4vrWl1l/3WGXiOo215zHfQsye26y9zJnTzBYFVgFud/dHxxqTO66tY/WKM7MD3X3XePktwFHAbcDKwC7ufnqv8eqik4h2KC4AzGyOBQDwJ2Cd3HFtHSt3TuB7wLvdfaaZbQOcZWY7eDhJn8V8WxEPxmY2x8HYzIoH47clxu0JvI6wI7wGeIO732zho+AnAH8gfH9Vv5ik2krUn1IXibUl1d/AWElxvQ7GFr7brXig2snMUuL2Ak4HZjL72YWJwGKFn903IabnQqGYcySmUNt46kqtLan+BsZKisvc82y9rCBnz0WAme3i7qenxKSO1UTOJuoHis9IfQPYyt2vNLOVCCcdbXxx1chHFNu8AZcBq8fL2wC3EL/egMLHOnPGtXWsCnJe0zHXqwM3A1sRP1YLXAUsA6xIONfMqvH26cDlhZ9Njitcvr4j/5WpMak5c9ZVRf11jlUi5xPAscD/ERZjXwMeGblciE+NmwYcD3wXWDjedntH7r4xqTlz1lVB/bWOVSJntp7n7GUFOYu/C+cA68TLKzF7n9E3JndcW8caY84res15k1vjBbRtI2EBkDuurWNVkPNyYJmO2OWBq4En4vWrCvdlObgDE+Ll9Qq3Txz5uZSY1Jw566qi/jrHKpEz68G9EP8+4ALCgr9rXL+YlJxV1JWr/qbG6hdXRc9z9LKCnH0XASkxuePaOlaJnE8D1wLXERbDS8bbJ9DlOwmb2BovoG0bCQuA3HFtHauCnJsAr+sy54sDX46Xcx/c3wAs2CXnDGD71JjUnDnrqqD+WscqExdvy3pwj7GLAvsD540zJtviJDVnzvqbGCslLnfPc/UyV04SFgEpMbnj2jpWiZzTO7b54+1TgK1He0zWtTVeQNs2EhYAuePaOlbunIXbtwYW6DH/2Q/a/XKmxqTkrKKuXPU3NVbJuJwLha1HdrrjiSmZM0tdueuve6yScbkWall7mSMnCYuAlJjccW0dq0xcYf777lea2BovoK1batNyxrV1rApyHgLcSXgT/ObAfDXUn5Kzb0wTc1FB/bWOVbLnOQ/auXuea3HSyj4Nes9z9rKinIO8z25r/Unz38TWeAFt3Rra0bRyrNw5Y+wkYEvgyPgzB1VZf0rOEjG1zkXu+psYSz0fjD4Nes9z9bKJnBXUNc8fc8o8FuveGi+gzVvdO5o2j5U7ZyF2C+BE4MGq60/JWTKmtrnIXX8TY6nng9GnQe95rl42kbOiuubpY06Zx2KdW+MFtH2re0fT5rFy5QTeAxwKzIr/vpfR/yrJsQPvm7NMXXXPRc766x5LPVfP6+h5Fb1sImeOuprMWWf9Zee/zq3xAtq6NbGjaetYFeQ8mnCahtHePJ67/pScfWOamIsK6q91LPV8MPo06D3P2csmcuasq4mcDdWfNP9NbI0X0NatxC9NK3duba6/ifmv+7HR5l/6tm7q+fBtTfS8rTnbvM9ua/1t3hovQNvwbYRPgdwCPEY4i/kTwONN52xrXbnrr3usNs9tW+tSz6ub10HPqW0w5r/xAtq6NbGjaetYFeS8FXhNzfOfkrNvTBNzUUH9tY6lng9Gnwa95zl72UTOCh7/w3DMSZr/JrbGC2jr1tCOppVjVZDzggbmPyVn35gm5qKC+msdSz0fjD4Nes9z9rKJnC3fZ7e1/qT5b2KbD+nlPne/sea4to6VO+flZnYscDLw7MiN7n5iRXWl5kyJSc2Zs67c9dc9Vmqcel5d/cPQ85y9bCJnm/fZba0/df5rp8VVb03saNo6Vu6ckwnfH/Wuwm1O+KhtVfWn5EyJSc2Zs67c9dc9Vmqcel5d/cPQ85y9bCJnm/fZba0/df5rZ/GpNelgZod0udnd/eNVxbV1rNw5U+SuP6e652JYqOfDp4metzVnm/fZba2/1bwFr01qG64NWB44Cbg/bicAyzeds6115a6/7rHaPLdtrUs9r25eBz2ntsGY/8YLaOvWxI6mrWNVkPMs4GOEl6XnA3YCzqq4/pScfWOamIsK6q91LPVcPa+j5zl72UTOnHU1kbOh+pPmv4mt8QLaupX4pWnlzq3l9V/d77YK6k/J2TemibmooP5ax1LP1fM6ep6zl03krODxPwzHnKT5b2JrvIC2bg3taFo5VgU5zwa2BybGbXvg7IprTcnZN6aJuaig/lrHUs/V8zp6nrOXTeSs4PFfa86G6k+a/ya2CUgvD5nZ9mY2MW7bAw9VHNfWsXLn/DjwQeBe4B5gG8JfJVXWn5IzJSY1Z866ctdf91ipcep5dfUPQ89z9rKJnG3eZ7e1/tT5r1/Tq7u2bsB04BTgAcLrvScDK1QZ19axKsh5GLBk4fpSwMEV15+Ss29ME3NRQf21jqWeq+d19DxnL5vImbOuJnI2VH/S/DexNV5AW7cSvzSt3Lm1vP6r+t1WQf0pOfvGNDEXFdRf61jquXpeR89z9rKJnBU8/ofhmJM0/01selmwtzXd/ZGRK+7+MLB2xXFtHSt3zglmtuTIFTNbirlPaJu7/pScKTGpOXPWlbv+usdKjVPPq6t/GHqes5dN5GzzPrut9afOf+1aUURLTTCzJUea228HkimurWPlzvkD4CIzOz5e/wDwrYrrT8mZEpOaM2ddueuve6zUOPW8uvqHoec5e9lEzjbvs9taf+r8106Lq96a2NG0daysOd39cDO7HHhHvGlrd7+hyvpTcibWlZoz51xkrb/usUrEqecV1T8MPc/cyyZytnaf3db6S8x/7fT1N6Mws9WY3bS/9Gpazri2jpU7Z4rc9edU91wMC/V8+DTR87bmbPM+u631t5UWVyIiIiIZ6Q3tIiIiIhlpcSUiIiKSkRZXIlIbM3uyobwzzMzN7HOF235mZjs1UY+IzNu0uBKReY6Zdfsk9P3AbmY2f931iMhw0eJKRBplZluY2SVmdpWZ/dnMXm5mE8zsFjObGmMmmNmtZjY1bieY2WVxe3OM2cfMjjCzC4AjuqR6gPBFrzt2qeFTcaxr4tgLx9sPNbOfm9nFZna7mW1oZgeb2Y1mdmjh599lZheZ2ZVmdryZLVrBVInIgNDiSkSadj6wgbuvDRwDfMHdXwR+C3wkxmwCXOPuDwA/Bn7o7m8A3g8cVBhrNWATd9+uR67vAv9jZhM7bj/R3d/g7q8DbgQ+UbhvSeCNwH8Tvuvsh8DqwGvNbC0zmwJ8JeZdB7gc2KP0LIjIPEMnERWRpi0PHGtmywLzA3fE2w8Gfg/8CPg4cEi8fRNgNTMb+fnJhWeKTnH3Z3olcvfbzewS4MMdd61hZt8ElgAWBf5YuO8P7u5mdh1wn7tfB2BmM4EZsf7VgAtiTfMDF6X+50Vk3qPFlYg07afAAe5+ipltCOwD4O53m9l9ZvYOYD1mP4s1gfBM17+Lg8SFzVMJ+b4N/A74a+G2Q4Gt3P2a+Cb3DQv3PRv/fbFweeT6fMALwFmjPFsmIkNGLwuKSNMWB/4ZL3e+H+ogwsuDx7v7C/G2PwHFT/2tVSaZu98E3ABsUbh5MeAeM5vE7EVcqouBN5vZyrGeRcxslZJjiMg8RIsrEanTwmb2j8K2B+GZquPN7ArgwY74Uwgv0x1SuO3zwLpmdq2Z3QB8egx1fIvwct6IrwKXABcAN5UZKL4PbCfgaDO7lvCS4KvHUJOIzCP09Tci0lpmti7hzetvbboWEZFUes+ViLSSme0FfIbyL9OJiDRKz1yJiIiIZKT3XImIiIhkpMWViIiISEZaXImIiIhkpMWViIiISEZaXImIiIhk9P8DUNra2DIDc+gAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 720x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(1, 1, figsize=(10, 4))\n",
    "ax.bar(layers_storage_capacity_mb.keys(), layers_storage_capacity_mb.values())\n",
    "ax.tick_params(axis='x', labelrotation = 90)\n",
    "ax.set_xlabel(\"Layer Name\")\n",
    "ax.set_ylabel(\"Megabytes\")\n",
    "ax.set_title(f\"Storage capacity when using {BITS_TO_USE} bits from every float value\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Inspect statistics for selected layers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Layers with the most storage capacity\n",
    "# sorted(layers_storage_capacity_mb.items(), key=lambda x: x[1], reverse=True)[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# These layers will be modified to hide the secret\n",
    "\n",
    "# Selected layers (manual selection)\n",
    "# layer_names = [\"conv5_block1_2_conv\", \"conv5_block2_2_conv\", \"conv5_block3_2_conv\"]\n",
    "\n",
    "# All the Conv2D layers\n",
    "layer_names = list(layers_storage_capacity_mb.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "selected_layers_weights = []\n",
    "for n in layer_names:\n",
    "    v = model.get_layer(n).weights[0].numpy().ravel()\n",
    "    selected_layers_weights.extend(v)\n",
    "selected_layers_weights = np.array(selected_layers_weights)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic statistics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "nb_values = len(selected_layers_weights)\n",
    "min_value = selected_layers_weights.min()\n",
    "abs_min_value = np.abs(selected_layers_weights).min()\n",
    "max_value = selected_layers_weights.max()\n",
    "mean_value = selected_layers_weights.mean()\n",
    "nb_really_small_values = (abs(selected_layers_weights) < 10e-4).sum()\n",
    "nb_small_values = (abs(selected_layers_weights) < 10e-3).sum()\n",
    "nb_negative_values = (selected_layers_weights < 0).sum()\n",
    "nb_positive_values = (selected_layers_weights > 0).sum()\n",
    "overall_storage_capacity_bytes = nb_values * BITS_TO_USE / 8\n",
    "overall_storage_capacity_mb = overall_storage_capacity_bytes // float(1<<20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stats for ['conv1_conv', 'conv2_block1_1_conv', 'conv2_block1_2_conv', 'conv2_block1_0_conv', 'conv2_block1_3_conv', 'conv2_block2_1_conv', 'conv2_block2_2_conv', 'conv2_block2_3_conv', 'conv2_block3_1_conv', 'conv2_block3_2_conv', 'conv2_block3_3_conv', 'conv3_block1_1_conv', 'conv3_block1_2_conv', 'conv3_block1_0_conv', 'conv3_block1_3_conv', 'conv3_block2_1_conv', 'conv3_block2_2_conv', 'conv3_block2_3_conv', 'conv3_block3_1_conv', 'conv3_block3_2_conv', 'conv3_block3_3_conv', 'conv3_block4_1_conv', 'conv3_block4_2_conv', 'conv3_block4_3_conv', 'conv4_block1_1_conv', 'conv4_block1_2_conv', 'conv4_block1_0_conv', 'conv4_block1_3_conv', 'conv4_block2_1_conv', 'conv4_block2_2_conv', 'conv4_block2_3_conv', 'conv4_block3_1_conv', 'conv4_block3_2_conv', 'conv4_block3_3_conv', 'conv4_block4_1_conv', 'conv4_block4_2_conv', 'conv4_block4_3_conv', 'conv4_block5_1_conv', 'conv4_block5_2_conv', 'conv4_block5_3_conv', 'conv4_block6_1_conv', 'conv4_block6_2_conv', 'conv4_block6_3_conv', 'conv5_block1_1_conv', 'conv5_block1_2_conv', 'conv5_block1_0_conv', 'conv5_block1_3_conv', 'conv5_block2_1_conv', 'conv5_block2_2_conv', 'conv5_block2_3_conv', 'conv5_block3_1_conv', 'conv5_block3_2_conv', 'conv5_block3_3_conv']\n",
      "---\n",
      "Min: -0.7719802856445312\n",
      "Abs. Min 8.192913014681835e-10\n",
      "Max: 0.9003667831420898\n",
      "Mean: -0.0007807782967574894\n",
      "---\n",
      "Nb total values: 23454912\n",
      "Nb values < 10e-4: 1486452 - 6.3375%\n",
      "Nb values < 10e-3: 13138630 - 56.0165%\n",
      "Nb negatives: 12746193 - 54.3434%\n",
      "Nb positives: 10708719 - 45.6566%\n",
      "---\n",
      "(Maximum) Storage capacity is 44.0 MB for the 53 layers with the 16 bits modification\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(f\"\"\"Stats for {layer_names}\n",
    "---\n",
    "Min: {min_value}\n",
    "Abs. Min {abs_min_value}\n",
    "Max: {max_value}\n",
    "Mean: {mean_value}\n",
    "---\n",
    "Nb total values: {nb_values}\n",
    "Nb values < 10e-4: {nb_really_small_values} - {nb_really_small_values/nb_values*100:.4f}%\n",
    "Nb values < 10e-3: {nb_small_values} - {nb_small_values/nb_values*100:.4f}%\n",
    "Nb negatives: {nb_negative_values} - {nb_negative_values/nb_values*100:.4f}%\n",
    "Nb positives: {nb_positive_values} - {nb_positive_values/nb_values*100:.4f}%\n",
    "---\n",
    "(Maximum) Storage capacity is {overall_storage_capacity_mb} MB for the {len(layer_names)} layers with the {BITS_TO_USE} bits modification\n",
    "\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hide a secret in the layer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The secret"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# secret_to_hide = \"I am Gabor and I would like to hide this message\"\n",
    "secret_to_hide = dummy_data_generator.generate_dummy_data(overall_storage_capacity_bytes)\n",
    "secret_bits = str_to_bits(secret_to_hide)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "nb_vals_needed = math.ceil(len(secret_bits) / BITS_TO_USE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We need 23454912 float values to store the info\n",
      "Overall number of values we could use: 23454912\n"
     ]
    }
   ],
   "source": [
    "print(f\"We need {nb_vals_needed} float values to store the info\\nOverall number of values we could use: {nb_values}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Hide it"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Store the original weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This dict holds the original weights for the selected layers\n",
    "original_weights_dict: dict = {}\n",
    "for n in layer_names:\n",
    "    original_weights_dict[n] = deepcopy(model.get_layer(n).weights[0].numpy())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create the modified ones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Layer conv1_conv is processed, last index modified: 9407\n",
      "Layer conv2_block1_1_conv is processed, last index modified: 4095\n",
      "Layer conv2_block1_2_conv is processed, last index modified: 36863\n",
      "Layer conv2_block1_0_conv is processed, last index modified: 16383\n",
      "Layer conv2_block1_3_conv is processed, last index modified: 16383\n",
      "Layer conv2_block2_1_conv is processed, last index modified: 16383\n",
      "Layer conv2_block2_2_conv is processed, last index modified: 36863\n",
      "Layer conv2_block2_3_conv is processed, last index modified: 16383\n",
      "Layer conv2_block3_1_conv is processed, last index modified: 16383\n",
      "Layer conv2_block3_2_conv is processed, last index modified: 36863\n",
      "Layer conv2_block3_3_conv is processed, last index modified: 16383\n",
      "Layer conv3_block1_1_conv is processed, last index modified: 32767\n",
      "Layer conv3_block1_2_conv is processed, last index modified: 147455\n",
      "Layer conv3_block1_0_conv is processed, last index modified: 131071\n",
      "Layer conv3_block1_3_conv is processed, last index modified: 65535\n",
      "Layer conv3_block2_1_conv is processed, last index modified: 65535\n",
      "Layer conv3_block2_2_conv is processed, last index modified: 147455\n",
      "Layer conv3_block2_3_conv is processed, last index modified: 65535\n",
      "Layer conv3_block3_1_conv is processed, last index modified: 65535\n",
      "Layer conv3_block3_2_conv is processed, last index modified: 147455\n",
      "Layer conv3_block3_3_conv is processed, last index modified: 65535\n",
      "Layer conv3_block4_1_conv is processed, last index modified: 65535\n",
      "Layer conv3_block4_2_conv is processed, last index modified: 147455\n",
      "Layer conv3_block4_3_conv is processed, last index modified: 65535\n",
      "Layer conv4_block1_1_conv is processed, last index modified: 131071\n",
      "Layer conv4_block1_2_conv is processed, last index modified: 589823\n",
      "Layer conv4_block1_0_conv is processed, last index modified: 524287\n",
      "Layer conv4_block1_3_conv is processed, last index modified: 262143\n",
      "Layer conv4_block2_1_conv is processed, last index modified: 262143\n",
      "Layer conv4_block2_2_conv is processed, last index modified: 589823\n",
      "Layer conv4_block2_3_conv is processed, last index modified: 262143\n",
      "Layer conv4_block3_1_conv is processed, last index modified: 262143\n",
      "Layer conv4_block3_2_conv is processed, last index modified: 589823\n",
      "Layer conv4_block3_3_conv is processed, last index modified: 262143\n",
      "Layer conv4_block4_1_conv is processed, last index modified: 262143\n",
      "Layer conv4_block4_2_conv is processed, last index modified: 589823\n",
      "Layer conv4_block4_3_conv is processed, last index modified: 262143\n",
      "Layer conv4_block5_1_conv is processed, last index modified: 262143\n",
      "Layer conv4_block5_2_conv is processed, last index modified: 589823\n",
      "Layer conv4_block5_3_conv is processed, last index modified: 262143\n",
      "Layer conv4_block6_1_conv is processed, last index modified: 262143\n",
      "Layer conv4_block6_2_conv is processed, last index modified: 589823\n",
      "Layer conv4_block6_3_conv is processed, last index modified: 262143\n",
      "Layer conv5_block1_1_conv is processed, last index modified: 524287\n",
      "Layer conv5_block1_2_conv is processed, last index modified: 2359295\n",
      "Layer conv5_block1_0_conv is processed, last index modified: 2097151\n",
      "Layer conv5_block1_3_conv is processed, last index modified: 1048575\n",
      "Layer conv5_block2_1_conv is processed, last index modified: 1048575\n",
      "Layer conv5_block2_2_conv is processed, last index modified: 2359295\n",
      "Layer conv5_block2_3_conv is processed, last index modified: 1048575\n",
      "Layer conv5_block3_1_conv is processed, last index modified: 1048575\n",
      "Layer conv5_block3_2_conv is processed, last index modified: 2359295\n",
      "Layer conv5_block3_3_conv is processed, last index modified: 1048575\n"
     ]
    }
   ],
   "source": [
    "# This dict will hold the modified (secret hidden) weights for the layers\n",
    "modified_weights_dict = deepcopy(original_weights_dict)\n",
    "# Index of the last value used in a layer - this is needed because we don't necessary need\n",
    "# the same number of params for hiding some bits then all the layer parameters\n",
    "last_index_used_in_layer_dict: dict = {}\n",
    "\n",
    "# We are modifying the layers in a defined order to know what was changed exactly\n",
    "# This order is needed when we would like to recover the message\n",
    "\n",
    "# Variable which tracks the number of values changed so far (used to index the secret message bits)\n",
    "i = 0\n",
    "\n",
    "for n in layer_names:\n",
    "    # Check if we need more values to use to hide the secret, if not then we are done with modifying the layer's weights\n",
    "    if i >= nb_vals_needed:\n",
    "        break\n",
    "\n",
    "    w = modified_weights_dict[n]\n",
    "    w_shape = w.shape\n",
    "    w = w.ravel()\n",
    "\n",
    "    nb_params_in_layer: int = np.prod(w.shape)\n",
    "\n",
    "    for j in range(nb_params_in_layer):\n",
    "        # Chunk of data from the secret to hide\n",
    "        _from_index = i * BITS_TO_USE\n",
    "        _to_index = _from_index + BITS_TO_USE\n",
    "        bits_to_hide = secret_bits[_from_index:_to_index]\n",
    "        bits_to_hide = list(map(bool, bits_to_hide))\n",
    "\n",
    "        # Modify the defined bits of the float value fraction\n",
    "        x = FloatBinary(w[j])\n",
    "        fraction_modified = list(x.fraction)\n",
    "        if len(bits_to_hide) > 0:\n",
    "            fraction_modified[-BITS_TO_USE:] = bits_to_hide\n",
    "\n",
    "        x_modified = x.modify_clone(fraction=tuple(fraction_modified))\n",
    "        w[j] = x_modified.v\n",
    "\n",
    "        i += 1\n",
    "        \n",
    "        # Check if we need more values to use to hide the secret in the current layer, if not then we are done\n",
    "        if i >= nb_vals_needed:\n",
    "            break\n",
    "\n",
    "    last_index_used_in_layer_dict[n] = j\n",
    "    w = w.reshape(w_shape)\n",
    "    modified_weights_dict[n] = w\n",
    "\n",
    "    print(f\"Layer {n} is processed, last index modified: {j}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Let's test the network and inspect the outputs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dataset to test on"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of images will be used for testing: 14241\n"
     ]
    }
   ],
   "source": [
    "print(f\"Number of images will be used for testing: {len(IMAGES_TO_TEST_ON)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def _read_image_from_path(image_path):\n",
    "    image = tf.io.read_file(image_path)\n",
    "    image = tf.image.decode_image(image, channels=3, dtype=tf.uint8, expand_animations=False)\n",
    "    image = tf.image.resize(image, (224, 224))\n",
    "    return image\n",
    "\n",
    "dataset = tf.data.Dataset.from_tensor_slices(IMAGES_TO_TEST_ON)\n",
    "dataset = dataset.map(_read_image_from_path, num_parallel_calls=tf.data.AUTOTUNE)\n",
    "dataset = dataset.batch(batch_size).prefetch(tf.data.AUTOTUNE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Predictions made by the model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Original weights predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load the original weights to the model layers\n",
    "for n in layer_names:\n",
    "    w = original_weights_dict[n]\n",
    "    model.get_layer(n).set_weights([w, model.get_layer(n).get_weights()[1]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-02-25 15:37:11.971562: I tensorflow/stream_executor/cuda/cuda_dnn.cc:366] Loaded cuDNN version 8100\n"
     ]
    }
   ],
   "source": [
    "preds_original = model.predict(dataset)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Modified weights predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load the modified (secret is hidden) weights to the model layers\n",
    "for n in layer_names:\n",
    "    w = modified_weights_dict[n]\n",
    "    model.get_layer(n).set_weights([w, model.get_layer(n).get_weights()[1]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "preds_modified = model.predict(dataset)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Differences in predictions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Raw prediction value comparisons (last layer output)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "diff_abs = np.abs(preds_original - preds_modified).ravel()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.hist(diff_abs[diff_abs > 0]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Min abs difference: 0.0\n",
      "Max abs difference: 0.11202079057693481\n",
      "Number of changed prediction values: 14240972 / 14241000 | 99.9998%\n"
     ]
    }
   ],
   "source": [
    "print(f\"Min abs difference: {diff_abs.min()}\")\n",
    "print(f\"Max abs difference: {diff_abs.max()}\")\n",
    "print(f\"Number of changed prediction values: {(diff_abs > 0).sum()} / {len(diff_abs)} | {(diff_abs > 0).sum()/len(diff_abs)*100:.4f}%\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Change in predicted labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "nb_changed_pred_labels = ((np.argmax(preds_original, 1) - np.argmax(preds_modified, 1)) > 0).sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Changed number of predictions: 146 / 14241 | 1.0252089038691103%\n"
     ]
    }
   ],
   "source": [
    "print(f\"Changed number of predictions: {nb_changed_pred_labels} / {len(IMAGES_TO_TEST_ON)} | {nb_changed_pred_labels / len(IMAGES_TO_TEST_ON)*100}%\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Recover the secret\n",
    "\n",
    "For recovering the secret we only need to know the layer names/indices in the model and the bits which we used for the \"encoding\".\n",
    "\n",
    "(And of course in a real life scenario we need direct access to the model's weights 😉)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Layer conv1_conv is processed, bits are extracted\n",
      "Layer conv2_block1_1_conv is processed, bits are extracted\n",
      "Layer conv2_block1_2_conv is processed, bits are extracted\n",
      "Layer conv2_block1_0_conv is processed, bits are extracted\n",
      "Layer conv2_block1_3_conv is processed, bits are extracted\n",
      "Layer conv2_block2_1_conv is processed, bits are extracted\n",
      "Layer conv2_block2_2_conv is processed, bits are extracted\n",
      "Layer conv2_block2_3_conv is processed, bits are extracted\n",
      "Layer conv2_block3_1_conv is processed, bits are extracted\n",
      "Layer conv2_block3_2_conv is processed, bits are extracted\n",
      "Layer conv2_block3_3_conv is processed, bits are extracted\n",
      "Layer conv3_block1_1_conv is processed, bits are extracted\n",
      "Layer conv3_block1_2_conv is processed, bits are extracted\n",
      "Layer conv3_block1_0_conv is processed, bits are extracted\n",
      "Layer conv3_block1_3_conv is processed, bits are extracted\n",
      "Layer conv3_block2_1_conv is processed, bits are extracted\n",
      "Layer conv3_block2_2_conv is processed, bits are extracted\n",
      "Layer conv3_block2_3_conv is processed, bits are extracted\n",
      "Layer conv3_block3_1_conv is processed, bits are extracted\n",
      "Layer conv3_block3_2_conv is processed, bits are extracted\n",
      "Layer conv3_block3_3_conv is processed, bits are extracted\n",
      "Layer conv3_block4_1_conv is processed, bits are extracted\n",
      "Layer conv3_block4_2_conv is processed, bits are extracted\n",
      "Layer conv3_block4_3_conv is processed, bits are extracted\n",
      "Layer conv4_block1_1_conv is processed, bits are extracted\n",
      "Layer conv4_block1_2_conv is processed, bits are extracted\n",
      "Layer conv4_block1_0_conv is processed, bits are extracted\n",
      "Layer conv4_block1_3_conv is processed, bits are extracted\n",
      "Layer conv4_block2_1_conv is processed, bits are extracted\n",
      "Layer conv4_block2_2_conv is processed, bits are extracted\n",
      "Layer conv4_block2_3_conv is processed, bits are extracted\n",
      "Layer conv4_block3_1_conv is processed, bits are extracted\n",
      "Layer conv4_block3_2_conv is processed, bits are extracted\n",
      "Layer conv4_block3_3_conv is processed, bits are extracted\n",
      "Layer conv4_block4_1_conv is processed, bits are extracted\n",
      "Layer conv4_block4_2_conv is processed, bits are extracted\n",
      "Layer conv4_block4_3_conv is processed, bits are extracted\n",
      "Layer conv4_block5_1_conv is processed, bits are extracted\n",
      "Layer conv4_block5_2_conv is processed, bits are extracted\n",
      "Layer conv4_block5_3_conv is processed, bits are extracted\n",
      "Layer conv4_block6_1_conv is processed, bits are extracted\n",
      "Layer conv4_block6_2_conv is processed, bits are extracted\n",
      "Layer conv4_block6_3_conv is processed, bits are extracted\n",
      "Layer conv5_block1_1_conv is processed, bits are extracted\n",
      "Layer conv5_block1_2_conv is processed, bits are extracted\n",
      "Layer conv5_block1_0_conv is processed, bits are extracted\n",
      "Layer conv5_block1_3_conv is processed, bits are extracted\n",
      "Layer conv5_block2_1_conv is processed, bits are extracted\n",
      "Layer conv5_block2_2_conv is processed, bits are extracted\n",
      "Layer conv5_block2_3_conv is processed, bits are extracted\n",
      "Layer conv5_block3_1_conv is processed, bits are extracted\n",
      "Layer conv5_block3_2_conv is processed, bits are extracted\n",
      "Layer conv5_block3_3_conv is processed, bits are extracted\n"
     ]
    }
   ],
   "source": [
    "# We store the extracted bits of data here\n",
    "hidden_data: List[bool] = []\n",
    "\n",
    "for n in layer_names:\n",
    "    # Check if the layer was used in hiding the secret or not (e.g.: we could hide the secret in the prev. layers)\n",
    "    if n not in last_index_used_in_layer_dict.keys():\n",
    "        continue\n",
    "    \n",
    "    # We could get the modified weights directly from the model: model.get_layer(n).get_weights()...\n",
    "    w = modified_weights_dict[n]\n",
    "    w_shape = w.shape\n",
    "    w = w.ravel()\n",
    "    \n",
    "    nb_params_in_layer: int = np.prod(w.shape)\n",
    "    \n",
    "    for i in range(last_index_used_in_layer_dict[n]+1):\n",
    "        x = FloatBinary(w[i])\n",
    "        hidden_bits = x.fraction[-BITS_TO_USE:]\n",
    "        hidden_data.extend(hidden_bits)\n",
    "        \n",
    "    print(f\"Layer {n} is processed, bits are extracted\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "recovered_message: str = bits_to_str(list(map(int, hidden_data)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--Original string:--\n",
      "'@OrlE33Ul1V %quL{_zs)>zOCp.45|T]p$ynTd++*^B\n",
      "h3~:mu}G\u000b",
      "\tw|\f",
      "9-@%#N_\f",
      "chN<r\"L43S;5Q{)=3Kiq}k\"r=4NoG2Cw#g*...'\n",
      "--Recovered string:--\n",
      "'@OrlE33Ul1V %quL{_zs)>zOCp.45|T]p$ynTd++*^B\n",
      "h3~:mu}G\u000b",
      "\tw|\f",
      "9-@%#N_\f",
      "chN<r\"L43S;5Q{)=3Kiq}k\"r=4NoG2Cw#g*...'\n"
     ]
    }
   ],
   "source": [
    "chars_to_display = 100\n",
    "print(f\"--Original string:--\\n'{secret_to_hide[:chars_to_display]}...'\")\n",
    "print(f\"--Recovered string:--\\n'{recovered_message[:chars_to_display]}...'\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hash_str(s: str) -> str:\n",
    "    return hashlib.md5(s.encode(\"ascii\")).hexdigest()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Successful secret hiding and recovery! 🥳\n"
     ]
    }
   ],
   "source": [
    "if hash_str(recovered_message) == hash_str(secret_to_hide):\n",
    "    print(\"Successful secret hiding and recovery! 🥳\")\n",
    "else:\n",
    "    print(\"Recovered message is not the same as the original one 🤨\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10"
  },
  "toc-autonumbering": true
 },
 "nbformat": 4,
 "nbformat_minor": 4
}