Deep Steganography (no Keras).ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "KkYV6i61ImJf",
    "tags": []
   },
   "outputs": [],
   "source": [
    "import os\n",
    "os.environ['TF_CPP_MIN_LOG_LEVEL'] = \"3\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "zOPx74naImJh",
    "tags": []
   },
   "outputs": [],
   "source": [
    "BATCH_SIZE = 32\n",
    "EPOCHS = 100\n",
    "LEARNING_RATE = 1e-3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "jodObMFeImJi",
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "tf.config.list_physical_devices('GPU')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "id": "XUUZzgSEImJj",
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/studio-lab-user/.conda/envs/tensorflow/lib/python3.9/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n",
      "Found cached dataset parquet (/home/studio-lab-user/.cache/huggingface/datasets/Maysee___parquet/Maysee--tiny-imagenet-35af7c46a941f08e/0.0.0/2a3b91fbd88a2c90d1dbbb32b460cf621d31bd5b05b934492fdef7d8d6f236ec)\n",
      "100%|██████████| 2/2 [00:00<00:00, 14.40it/s]\n"
     ]
    }
   ],
   "source": [
    "from datasets import load_dataset\n",
    "dataset = load_dataset('Maysee/tiny-imagenet')\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "train_cover, train_secret = train_test_split(dataset['train']['image'][:15000], train_size=0.5, shuffle=True)\n",
    "test_cover, test_secret = train_test_split(dataset['valid']['image'][:1000], train_size=0.5, shuffle=True)\n",
    "\n",
    "del dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "id": "j7OYmSh4ImJj",
    "tags": []
   },
   "outputs": [],
   "source": [
    "STEPS = len(train_cover) // BATCH_SIZE + 1\n",
    "TEST_STEPS = len(test_cover) // BATCH_SIZE + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "id": "JxjS0ZCbImJk",
    "tags": []
   },
   "outputs": [],
   "source": [
    "train_dataset = tf.data.Dataset.from_tensor_slices(\n",
    "    ([np.asarray(x.convert('RGB')) for x in train_cover], \n",
    "     [np.asarray(x.convert('RGB')) for x in train_secret])\n",
    ")\n",
    "\n",
    "del train_cover\n",
    "del train_secret"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "id": "yypM6p0qImJl",
    "tags": []
   },
   "outputs": [],
   "source": [
    "train_dataset = train_dataset.shuffle(64).batch(BATCH_SIZE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "id": "eD6ys0Z2ImJl",
    "tags": []
   },
   "outputs": [],
   "source": [
    "test_dataset = tf.data.Dataset.from_tensor_slices(\n",
    "    ([np.asarray(x.convert('RGB')) for x in test_cover],\n",
    "     [np.asarray(x.convert('RGB')) for x in test_secret])\n",
    ")\n",
    "\n",
    "del test_cover\n",
    "del test_secret"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "id": "mMJrY4I3ImJl",
    "tags": []
   },
   "outputs": [],
   "source": [
    "test_dataset = test_dataset.batch(BATCH_SIZE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "id": "IfdnueRnImJm",
    "tags": []
   },
   "outputs": [],
   "source": [
    "@tf.function\n",
    "def conv2d(input, filters, biases, strides=1):\n",
    "    x = tf.nn.conv2d(input, filters, strides=[1, strides, strides, 1], padding='SAME')\n",
    "    x = tf.nn.bias_add(x, biases)\n",
    "    return tf.nn.relu(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "id": "Quy_4YhLImJm",
    "tags": []
   },
   "outputs": [],
   "source": [
    "initializer = tf.initializers.glorot_normal(12541)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "id": "-v7LD8UOImJm",
    "tags": []
   },
   "outputs": [],
   "source": [
    "WEIGHTS_PREP_NETWORK = {\n",
    "    'conv3x3_1': tf.Variable(initializer([3, 3, 3, 50])),\n",
    "    'conv3x3_2': tf.Variable(initializer([3, 3, 50, 50])),\n",
    "    'conv3x3_3': tf.Variable(initializer([3, 3, 50, 50])),\n",
    "    'conv3x3_4': tf.Variable(initializer([3, 3, 50, 50])),\n",
    "\n",
    "    'conv4x4_1': tf.Variable(initializer([4, 4, 3, 50])),\n",
    "    'conv4x4_2': tf.Variable(initializer([4, 4, 50, 50])),\n",
    "    'conv4x4_3': tf.Variable(initializer([4, 4, 50, 50])),\n",
    "    'conv4x4_4': tf.Variable(initializer([4, 4, 50, 50])),\n",
    "\n",
    "    'conv5x5_1': tf.Variable(initializer([5, 5, 3, 50])),\n",
    "    'conv5x5_2': tf.Variable(initializer([5, 5, 50, 50])),\n",
    "    'conv5x5_3': tf.Variable(initializer([5, 5, 50, 50])),\n",
    "    'conv5x5_4': tf.Variable(initializer([5, 5, 50, 50])),\n",
    "\n",
    "    'conv3x3_5': tf.Variable(initializer([3, 3, 150, 50])),\n",
    "    'conv4x4_5': tf.Variable(initializer([4, 4, 150, 50])),\n",
    "    'conv5x5_5': tf.Variable(initializer([5, 5, 150, 50]))\n",
    "}\n",
    "\n",
    "BIASES_PREP_NETWORK = {\n",
    "    'conv3x3_1': tf.Variable(tf.zeros([50])),\n",
    "    'conv3x3_2': tf.Variable(tf.zeros([50])),\n",
    "    'conv3x3_3': tf.Variable(tf.zeros([50])),\n",
    "    'conv3x3_4': tf.Variable(tf.zeros([50])),\n",
    "\n",
    "    'conv4x4_1': tf.Variable(tf.zeros([50])),\n",
    "    'conv4x4_2': tf.Variable(tf.zeros([50])),\n",
    "    'conv4x4_3': tf.Variable(tf.zeros([50])),\n",
    "    'conv4x4_4': tf.Variable(tf.zeros([50])),\n",
    "\n",
    "    'conv5x5_1': tf.Variable(tf.zeros([50])),\n",
    "    'conv5x5_2': tf.Variable(tf.zeros([50])),\n",
    "    'conv5x5_3': tf.Variable(tf.zeros([50])),\n",
    "    'conv5x5_4': tf.Variable(tf.zeros([50])),\n",
    "\n",
    "\n",
    "    'conv3x3_5': tf.Variable(tf.zeros([50])),\n",
    "    'conv4x4_5': tf.Variable(tf.zeros([50])),\n",
    "    'conv5x5_5': tf.Variable(tf.zeros([50]))\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "id": "i2XC6b9XImJn",
    "tags": []
   },
   "outputs": [],
   "source": [
    "@tf.function\n",
    "def prep_network(secret_tensor):\n",
    "\n",
    "    secret_tensor = tf.reshape(secret_tensor, [-1, 64, 64, 3])\n",
    "    secret_tensor = tf.cast(secret_tensor, tf.float32)\n",
    "    secret_tensor = tf.math.divide(secret_tensor, 255.)\n",
    "\n",
    "    with tf.name_scope('prep_network'):\n",
    "        with tf.name_scope('conv3x3'):\n",
    "            conv3x3 = secret_tensor\n",
    "            conv3x3 = conv2d(conv3x3, WEIGHTS_PREP_NETWORK['conv3x3_1'], BIASES_PREP_NETWORK['conv3x3_1'])\n",
    "            conv3x3 = conv2d(conv3x3, WEIGHTS_PREP_NETWORK['conv3x3_2'], BIASES_PREP_NETWORK['conv3x3_2'])\n",
    "            conv3x3 = conv2d(conv3x3, WEIGHTS_PREP_NETWORK['conv3x3_3'], BIASES_PREP_NETWORK['conv3x3_3'])\n",
    "            conv3x3 = conv2d(conv3x3, WEIGHTS_PREP_NETWORK['conv3x3_4'], BIASES_PREP_NETWORK['conv3x3_4'])\n",
    "\n",
    "        with tf.name_scope('conv4x4'):\n",
    "            conv4x4 = secret_tensor\n",
    "            conv4x4 = conv2d(conv4x4, WEIGHTS_PREP_NETWORK['conv4x4_1'], BIASES_PREP_NETWORK['conv4x4_1'])\n",
    "            conv4x4 = conv2d(conv4x4, WEIGHTS_PREP_NETWORK['conv4x4_2'], BIASES_PREP_NETWORK['conv4x4_2'])\n",
    "            conv4x4 = conv2d(conv4x4, WEIGHTS_PREP_NETWORK['conv4x4_3'], BIASES_PREP_NETWORK['conv4x4_3'])\n",
    "            conv4x4 = conv2d(conv4x4, WEIGHTS_PREP_NETWORK['conv4x4_4'], BIASES_PREP_NETWORK['conv4x4_4'])\n",
    "\n",
    "        with tf.name_scope('conv5x5'):\n",
    "            conv5x5 = secret_tensor\n",
    "            conv5x5 = conv2d(conv5x5, WEIGHTS_PREP_NETWORK['conv5x5_1'], BIASES_PREP_NETWORK['conv5x5_1'])\n",
    "            conv5x5 = conv2d(conv5x5, WEIGHTS_PREP_NETWORK['conv5x5_2'], BIASES_PREP_NETWORK['conv5x5_2'])\n",
    "            conv5x5 = conv2d(conv5x5, WEIGHTS_PREP_NETWORK['conv5x5_3'], BIASES_PREP_NETWORK['conv5x5_3'])\n",
    "            conv5x5 = conv2d(conv5x5, WEIGHTS_PREP_NETWORK['conv5x5_4'], BIASES_PREP_NETWORK['conv5x5_4'])\n",
    "\n",
    "        concat_1 = tf.concat([conv3x3, conv4x4, conv5x5], axis=3)\n",
    "\n",
    "        conv3x3 = conv2d(concat_1, WEIGHTS_PREP_NETWORK['conv3x3_5'], BIASES_PREP_NETWORK['conv3x3_5'])\n",
    "        conv4x4 = conv2d(concat_1, WEIGHTS_PREP_NETWORK['conv4x4_5'], BIASES_PREP_NETWORK['conv4x4_5'])\n",
    "        conv5x5 = conv2d(concat_1, WEIGHTS_PREP_NETWORK['conv5x5_5'], BIASES_PREP_NETWORK['conv5x5_5'])\n",
    "\n",
    "        return tf.concat([conv3x3, conv4x4, conv5x5], axis=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "id": "QD2Bulp5ImJo",
    "tags": []
   },
   "outputs": [],
   "source": [
    "WEIGHTS_HIDE_NETWORK = {\n",
    "    'conv3x3_1': tf.Variable(initializer([3, 3, 153, 50])),\n",
    "    'conv3x3_2': tf.Variable(initializer([3, 3, 50, 50])),\n",
    "    'conv3x3_3': tf.Variable(initializer([3, 3, 50, 50])),\n",
    "    'conv3x3_4': tf.Variable(initializer([3, 3, 50, 50])),\n",
    "\n",
    "    'conv4x4_1': tf.Variable(initializer([4, 4, 153, 50])),\n",
    "    'conv4x4_2': tf.Variable(initializer([4, 4, 50, 50])),\n",
    "    'conv4x4_3': tf.Variable(initializer([4, 4, 50, 50])),\n",
    "    'conv4x4_4': tf.Variable(initializer([4, 4, 50, 50])),\n",
    "\n",
    "    'conv5x5_1': tf.Variable(initializer([5, 5, 153, 50])),\n",
    "    'conv5x5_2': tf.Variable(initializer([5, 5, 50, 50])),\n",
    "    'conv5x5_3': tf.Variable(initializer([5, 5, 50, 50])),\n",
    "    'conv5x5_4': tf.Variable(initializer([5, 5, 50, 50])),\n",
    "\n",
    "    'conv3x3_5': tf.Variable(initializer([3, 3, 150, 50])),\n",
    "    'conv4x4_5': tf.Variable(initializer([4, 4, 150, 50])),\n",
    "    'conv5x5_5': tf.Variable(initializer([5, 5, 150, 50])),\n",
    "\n",
    "    'out': tf.Variable(initializer([1, 1, 150, 3])),\n",
    "}\n",
    "\n",
    "BIASES_HIDE_NETWORK = {\n",
    "    'conv3x3_1': tf.Variable(tf.zeros([50])),\n",
    "    'conv3x3_2': tf.Variable(tf.zeros([50])),\n",
    "    'conv3x3_3': tf.Variable(tf.zeros([50])),\n",
    "    'conv3x3_4': tf.Variable(tf.zeros([50])),\n",
    "\n",
    "    'conv4x4_1': tf.Variable(tf.zeros([50])),\n",
    "    'conv4x4_2': tf.Variable(tf.zeros([50])),\n",
    "    'conv4x4_3': tf.Variable(tf.zeros([50])),\n",
    "    'conv4x4_4': tf.Variable(tf.zeros([50])),\n",
    "\n",
    "    'conv5x5_1': tf.Variable(tf.zeros([50])),\n",
    "    'conv5x5_2': tf.Variable(tf.zeros([50])),\n",
    "    'conv5x5_3': tf.Variable(tf.zeros([50])),\n",
    "    'conv5x5_4': tf.Variable(tf.zeros([50])),\n",
    "\n",
    "\n",
    "    'conv3x3_5': tf.Variable(tf.zeros([50])),\n",
    "    'conv4x4_5': tf.Variable(tf.zeros([50])),\n",
    "    'conv5x5_5': tf.Variable(tf.zeros([50])),\n",
    "\n",
    "    'out': tf.Variable(tf.zeros([3]))\n",
    "}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "id": "e9QPA0F4ImJp",
    "tags": []
   },
   "outputs": [],
   "source": [
    "@tf.function\n",
    "def hide_network(cover_tensor, prep_tensor):\n",
    "\n",
    "    cover_tensor = tf.reshape(cover_tensor, [-1, 64, 64, 3])\n",
    "    cover_tensor = tf.cast(cover_tensor, tf.float32)\n",
    "    cover_tensor = tf.math.divide(cover_tensor, 255.)\n",
    "\n",
    "    with tf.name_scope('hide_network'):\n",
    "        concat_1 = tf.concat([cover_tensor, prep_tensor], axis=3)\n",
    "\n",
    "        with tf.name_scope('conv3x3'):\n",
    "            conv3x3 = concat_1\n",
    "            conv3x3 = conv2d(conv3x3, WEIGHTS_HIDE_NETWORK['conv3x3_1'], BIASES_HIDE_NETWORK['conv3x3_1'])\n",
    "            conv3x3 = conv2d(conv3x3, WEIGHTS_HIDE_NETWORK['conv3x3_2'], BIASES_HIDE_NETWORK['conv3x3_2'])\n",
    "            conv3x3 = conv2d(conv3x3, WEIGHTS_HIDE_NETWORK['conv3x3_3'], BIASES_HIDE_NETWORK['conv3x3_3'])\n",
    "            conv3x3 = conv2d(conv3x3, WEIGHTS_HIDE_NETWORK['conv3x3_4'], BIASES_HIDE_NETWORK['conv3x3_4'])\n",
    "\n",
    "        with tf.name_scope('conv4x4'):\n",
    "            conv4x4 = concat_1\n",
    "            conv4x4 = conv2d(conv4x4, WEIGHTS_HIDE_NETWORK['conv4x4_1'], BIASES_HIDE_NETWORK['conv4x4_1'])\n",
    "            conv4x4 = conv2d(conv4x4, WEIGHTS_HIDE_NETWORK['conv4x4_2'], BIASES_HIDE_NETWORK['conv4x4_2'])\n",
    "            conv4x4 = conv2d(conv4x4, WEIGHTS_HIDE_NETWORK['conv4x4_3'], BIASES_HIDE_NETWORK['conv4x4_3'])\n",
    "            conv4x4 = conv2d(conv4x4, WEIGHTS_HIDE_NETWORK['conv4x4_4'], BIASES_HIDE_NETWORK['conv4x4_4'])\n",
    "\n",
    "        with tf.name_scope('conv5x5'):\n",
    "            conv5x5 = concat_1\n",
    "            conv5x5 = conv2d(conv5x5, WEIGHTS_HIDE_NETWORK['conv5x5_1'], BIASES_HIDE_NETWORK['conv5x5_1'])\n",
    "            conv5x5 = conv2d(conv5x5, WEIGHTS_HIDE_NETWORK['conv5x5_2'], BIASES_HIDE_NETWORK['conv5x5_2'])\n",
    "            conv5x5 = conv2d(conv5x5, WEIGHTS_HIDE_NETWORK['conv5x5_3'], BIASES_HIDE_NETWORK['conv5x5_3'])\n",
    "            conv5x5 = conv2d(conv5x5, WEIGHTS_HIDE_NETWORK['conv5x5_4'], BIASES_HIDE_NETWORK['conv5x5_4'])\n",
    "\n",
    "        concat_2 = tf.concat([conv3x3, conv4x4, conv5x5], axis=3)\n",
    "\n",
    "        conv3x3 = conv2d(concat_2, WEIGHTS_HIDE_NETWORK['conv3x3_5'], BIASES_HIDE_NETWORK['conv3x3_5'])\n",
    "        conv4x4 = conv2d(concat_2, WEIGHTS_HIDE_NETWORK['conv4x4_5'], BIASES_HIDE_NETWORK['conv4x4_5'])\n",
    "        conv5x5 = conv2d(concat_2, WEIGHTS_HIDE_NETWORK['conv5x5_5'], BIASES_HIDE_NETWORK['conv5x5_5'])\n",
    "\n",
    "        concat_final = tf.concat([conv3x3, conv4x4, conv5x5], axis=3)\n",
    "\n",
    "        return conv2d(concat_final, WEIGHTS_HIDE_NETWORK['out'], BIASES_HIDE_NETWORK['out'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "id": "ntl41Jl4ImJp",
    "tags": []
   },
   "outputs": [],
   "source": [
    "WEIGHTS_REVEAL_NETWORK = {\n",
    "    'conv3x3_1': tf.Variable(initializer([3, 3, 3, 50])),\n",
    "    'conv3x3_2': tf.Variable(initializer([3, 3, 50, 50])),\n",
    "    'conv3x3_3': tf.Variable(initializer([3, 3, 50, 50])),\n",
    "    'conv3x3_4': tf.Variable(initializer([3, 3, 50, 50])),\n",
    "\n",
    "    'conv4x4_1': tf.Variable(initializer([4, 4, 3, 50])),\n",
    "    'conv4x4_2': tf.Variable(initializer([4, 4, 50, 50])),\n",
    "    'conv4x4_3': tf.Variable(initializer([4, 4, 50, 50])),\n",
    "    'conv4x4_4': tf.Variable(initializer([4, 4, 50, 50])),\n",
    "\n",
    "    'conv5x5_1': tf.Variable(initializer([5, 5, 3, 50])),\n",
    "    'conv5x5_2': tf.Variable(initializer([5, 5, 50, 50])),\n",
    "    'conv5x5_3': tf.Variable(initializer([5, 5, 50, 50])),\n",
    "    'conv5x5_4': tf.Variable(initializer([5, 5, 50, 50])),\n",
    "\n",
    "    'conv3x3_5': tf.Variable(initializer([3, 3, 150, 50])),\n",
    "    'conv4x4_5': tf.Variable(initializer([4, 4, 150, 50])),\n",
    "    'conv5x5_5': tf.Variable(initializer([5, 5, 150, 50])),\n",
    "\n",
    "    'out': tf.Variable(initializer([1, 1, 150, 3])),\n",
    "}\n",
    "\n",
    "BIASES_REVEAL_NETWORK = {\n",
    "    'conv3x3_1': tf.Variable(tf.zeros([50])),\n",
    "    'conv3x3_2': tf.Variable(tf.zeros([50])),\n",
    "    'conv3x3_3': tf.Variable(tf.zeros([50])),\n",
    "    'conv3x3_4': tf.Variable(tf.zeros([50])),\n",
    "\n",
    "    'conv4x4_1': tf.Variable(tf.zeros([50])),\n",
    "    'conv4x4_2': tf.Variable(tf.zeros([50])),\n",
    "    'conv4x4_3': tf.Variable(tf.zeros([50])),\n",
    "    'conv4x4_4': tf.Variable(tf.zeros([50])),\n",
    "\n",
    "    'conv5x5_1': tf.Variable(tf.zeros([50])),\n",
    "    'conv5x5_2': tf.Variable(tf.zeros([50])),\n",
    "    'conv5x5_3': tf.Variable(tf.zeros([50])),\n",
    "    'conv5x5_4': tf.Variable(tf.zeros([50])),\n",
    "\n",
    "\n",
    "    'conv3x3_5': tf.Variable(tf.zeros([50])),\n",
    "    'conv4x4_5': tf.Variable(tf.zeros([50])),\n",
    "    'conv5x5_5': tf.Variable(tf.zeros([50])),\n",
    "\n",
    "    'out': tf.Variable(tf.zeros([3]))\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "id": "All-WKWhImJq",
    "tags": []
   },
   "outputs": [],
   "source": [
    "@tf.function\n",
    "def reveal_network(hide_tensor):\n",
    "\n",
    "    hide_tensor = tf.reshape(hide_tensor, [-1, 64, 64, 3])\n",
    "    hide_tensor = tf.cast(hide_tensor, tf.float32)\n",
    "    hide_tensor = tf.math.divide(hide_tensor, 255.)\n",
    "\n",
    "    with tf.name_scope('reveal_network'):\n",
    "        with tf.name_scope('conv3x3'):\n",
    "            conv3x3 = hide_tensor\n",
    "            conv3x3 = conv2d(conv3x3, WEIGHTS_REVEAL_NETWORK['conv3x3_1'], BIASES_REVEAL_NETWORK['conv3x3_1'])\n",
    "            conv3x3 = conv2d(conv3x3, WEIGHTS_REVEAL_NETWORK['conv3x3_2'], BIASES_REVEAL_NETWORK['conv3x3_2'])\n",
    "            conv3x3 = conv2d(conv3x3, WEIGHTS_REVEAL_NETWORK['conv3x3_3'], BIASES_REVEAL_NETWORK['conv3x3_3'])\n",
    "            conv3x3 = conv2d(conv3x3, WEIGHTS_REVEAL_NETWORK['conv3x3_4'], BIASES_REVEAL_NETWORK['conv3x3_4'])\n",
    "\n",
    "        with tf.name_scope('conv4x4'):\n",
    "            conv4x4 = hide_tensor\n",
    "            conv4x4 = conv2d(conv4x4, WEIGHTS_REVEAL_NETWORK['conv4x4_1'], BIASES_REVEAL_NETWORK['conv4x4_1'])\n",
    "            conv4x4 = conv2d(conv4x4, WEIGHTS_REVEAL_NETWORK['conv4x4_2'], BIASES_REVEAL_NETWORK['conv4x4_2'])\n",
    "            conv4x4 = conv2d(conv4x4, WEIGHTS_REVEAL_NETWORK['conv4x4_3'], BIASES_REVEAL_NETWORK['conv4x4_3'])\n",
    "            conv4x4 = conv2d(conv4x4, WEIGHTS_REVEAL_NETWORK['conv4x4_4'], BIASES_REVEAL_NETWORK['conv4x4_4'])\n",
    "\n",
    "        with tf.name_scope('conv5x5'):\n",
    "            conv5x5 = hide_tensor\n",
    "            conv5x5 = conv2d(conv5x5, WEIGHTS_REVEAL_NETWORK['conv5x5_1'], BIASES_REVEAL_NETWORK['conv5x5_1'])\n",
    "            conv5x5 = conv2d(conv5x5, WEIGHTS_REVEAL_NETWORK['conv5x5_2'], BIASES_REVEAL_NETWORK['conv5x5_2'])\n",
    "            conv5x5 = conv2d(conv5x5, WEIGHTS_REVEAL_NETWORK['conv5x5_3'], BIASES_REVEAL_NETWORK['conv5x5_3'])\n",
    "            conv5x5 = conv2d(conv5x5, WEIGHTS_REVEAL_NETWORK['conv5x5_4'], BIASES_REVEAL_NETWORK['conv5x5_4'])\n",
    "\n",
    "        concat_1 = tf.concat([conv3x3, conv4x4, conv5x5], axis=3)\n",
    "\n",
    "        conv3x3 = conv2d(concat_1, WEIGHTS_REVEAL_NETWORK['conv3x3_5'], BIASES_REVEAL_NETWORK['conv3x3_5'])\n",
    "        conv4x4 = conv2d(concat_1, WEIGHTS_REVEAL_NETWORK['conv4x4_5'], BIASES_REVEAL_NETWORK['conv4x4_5'])\n",
    "        conv5x5 = conv2d(concat_1, WEIGHTS_REVEAL_NETWORK['conv5x5_5'], BIASES_REVEAL_NETWORK['conv5x5_5'])\n",
    "\n",
    "        concat_final = tf.concat([conv3x3, conv4x4, conv5x5], axis=3)\n",
    "\n",
    "        return conv2d(concat_final, WEIGHTS_REVEAL_NETWORK['out'], BIASES_REVEAL_NETWORK['out'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "id": "aQxTqNb2ImJr",
    "tags": []
   },
   "outputs": [],
   "source": [
    "@tf.function\n",
    "def steganorgraphy_loss(cover_input, secret_input, cover_output, secret_output, beta=1.0):\n",
    "    beta = tf.constant(beta, name=\"beta\")\n",
    "\n",
    "    cover_mse = tf.losses.mean_squared_error(cover_input, cover_output)\n",
    "    secret_mse = tf.losses.mean_squared_error(secret_input, secret_output)\n",
    "\n",
    "    total_loss = cover_mse + beta * secret_mse\n",
    "\n",
    "    return total_loss, cover_mse, secret_mse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "id": "foneC4wrImJr",
    "tags": []
   },
   "outputs": [],
   "source": [
    "optimizer = tf.optimizers.Adam(LEARNING_RATE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "ajYvc18FImJs",
    "outputId": "f7fff4a7-4b9c-47cc-e48b-2fedffa1bbb5",
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 100/100:\n",
      " Step 231/235:\n",
      "  Cover loss: 111.5485\n",
      "  Secret loss 56.5240\n",
      "  Total loss: 168.0725.\n",
      "Seen so far: 7392 samples\n"
     ]
    }
   ],
   "source": [
    "from IPython.display import clear_output\n",
    "\n",
    "for epoch in range(EPOCHS):\n",
    "    for step, (cover, secret) in enumerate(train_dataset):\n",
    "        with tf.GradientTape() as tape:\n",
    "            prep_output = prep_network(secret)\n",
    "            hide_output = hide_network(cover, prep_output)\n",
    "            reveal_output = reveal_network(hide_output)\n",
    "            total_loss, cover_loss, secret_loss = steganorgraphy_loss(cover, secret, hide_output, reveal_output)\n",
    "\n",
    "        trainable_variables = list(WEIGHTS_PREP_NETWORK.values()) + \\\n",
    "            list(WEIGHTS_HIDE_NETWORK.values()) + \\\n",
    "            list(WEIGHTS_REVEAL_NETWORK.values()) + \\\n",
    "            list(BIASES_PREP_NETWORK.values()) + \\\n",
    "            list(BIASES_HIDE_NETWORK.values()) + \\\n",
    "            list(BIASES_REVEAL_NETWORK.values())\n",
    "\n",
    "        grads = tape.gradient(total_loss, trainable_variables)\n",
    "        optimizer.apply_gradients(zip(grads, trainable_variables))\n",
    "\n",
    "        if (step % 10 == 0) or (step == STEPS - 1 == 0):\n",
    "            clear_output()\n",
    "            print(\n",
    "                \"Epoch %d/%d:\\n Step %d/%d:\\n  Cover loss: %.4f\\n  Secret loss %.4f\\n  Total loss: %.4f.\"\n",
    "                % (epoch + 1, EPOCHS, step + 1, STEPS, np.mean(cover_loss), np.mean(secret_loss), np.mean(total_loss))\n",
    "            )\n",
    "\n",
    "            print(\"Seen so far: %s samples\" % ((step + 1) * BATCH_SIZE))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "id": "2f64sC9PWhaX",
    "tags": []
   },
   "outputs": [],
   "source": [
    "import PIL"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "id": "sAnGNbadUYnL",
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total loss: 160.3530\n"
     ]
    }
   ],
   "source": [
    "loss_mean = list()\n",
    "\n",
    "for step, (cover, secret) in enumerate(test_dataset):\n",
    "    prep_output = prep_network(secret)\n",
    "    hide_output = hide_network(cover, prep_output)\n",
    "    reveal_output = reveal_network(hide_output)\n",
    "    total_loss, cover_loss, secret_loss = steganorgraphy_loss(cover, secret, hide_output, reveal_output)\n",
    "\n",
    "    for loss in total_loss:\n",
    "        loss_mean.append(loss)\n",
    "\n",
    "    clear_output()\n",
    "    print(\"Total loss: %.4f\" % (np.mean(loss_mean)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cover image:\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<PIL.Image.Image image mode=RGB size=64x64>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Secret image:\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<PIL.Image.Image image mode=RGB size=64x64>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cover with secret:\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<PIL.Image.Image image mode=RGB size=64x64>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Secret revealed:\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<PIL.Image.Image image mode=RGB size=64x64>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(\"Cover image:\")\n",
    "cover = PIL.Image.open(\"./example/imgs/cover.png\").convert('RGB')\n",
    "cover.show()\n",
    "\n",
    "print(\"Secret image:\")\n",
    "secret = PIL.Image.open(\"./example/imgs/secret.png\").convert('RGB')\n",
    "secret.show()\n",
    "\n",
    "# Hidding revealing the secret\n",
    "prep_output = prep_network(np.array(secret))\n",
    "hide_output = hide_network(np.array(cover), prep_output)\n",
    "reveal_output = reveal_network(hide_output)\n",
    "\n",
    "print(\"Cover with secret:\")\n",
    "PIL.Image.fromarray(\n",
    "  np.array(hide_output[0], dtype=np.uint8), 'RGB'\n",
    ").show()\n",
    "\n",
    "print(\"Secret revealed:\")\n",
    "PIL.Image.fromarray(\n",
    "  np.array(reveal_output[0], dtype=np.uint8), 'RGB'\n",
    ").show()"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "provenance": []
  },
  "gpuClass": "standard",
  "kernelspec": {
   "display_name": "tensorflow:Python",
   "language": "python",
   "name": "conda-env-tensorflow-py"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}