AE_Tutorial_bitwise_GN.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Bitwise Autoencoder"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "yLtCXQTVSTRI"
   },
   "source": [
    "# Import required libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "9xJCHzD6STRN"
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt  \n",
    "import tensorflow as tf\n",
    "\n",
    "from tensorflow.keras import Model\n",
    "from tensorflow.keras.layers import Layer, Dense"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-1NC4VDiSTRP"
   },
   "source": [
    "# Predefined functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "id": "0ostg1AUSTRP"
   },
   "outputs": [],
   "source": [
    "def visualize (model, SNRs_db):\n",
    "    K = model.K\n",
    "    msg = np.arange(2**K)\n",
    "    res = []\n",
    "    for i in range(2**K):\n",
    "        temp=msg[i]\n",
    "        res_ = []\n",
    "        for j in 2**np.linspace(K-1, 0, K):\n",
    "            if temp - j >= 0 :\n",
    "                res_.append(1)\n",
    "                temp -= j\n",
    "            else:\n",
    "                res_.append(0)\n",
    "        res.append(res_)\n",
    "    bits = np.array(res, dtype=np.float32) \n",
    "    \n",
    "    fig, axes = plt.subplots(1, len(SNRs_db), figsize=(len(SNRs_db)*7, 6))\n",
    "    if len(SNRs_db) == 1 :\n",
    "        axes = np.array([axes])\n",
    "    for i in range(len(SNRs_db)):\n",
    "                   \n",
    "        llrs = model(bits, tf.ones(shape=(tf.shape(bits)[0], 1))*SNRs_db[i])\n",
    "        x = model.x\n",
    "        if tf.size(tf.shape(x)) == 1 :\n",
    "            x = x[:, tf.newaxis]\n",
    "                   \n",
    "        axes[i].set_title('SNR_db = '+str(SNRs_db[i]))\n",
    "        for j in range(2**K):\n",
    "            axes[i].scatter(np.real(x[j, 0]), np.imag(x[j, 0]), s=100)\n",
    "            axes[i].set_xlim([-1.65, 1.65])\n",
    "            axes[i].set_ylim([-1.65, 1.65])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "id": "Gfi2KO35STRR"
   },
   "outputs": [],
   "source": [
    "def evaluate_rate(model, SNRs_eval, DS_size=10240):\n",
    "    \n",
    "    print('K = '+str(model.K))\n",
    "    \n",
    "    DS_bits, DS_SNRs = gen_DS(DS_size, model.K, 1., 1.)\n",
    "    TF_DS_test = tf.data.Dataset.from_tensor_slices((DS_bits, DS_SNRs)).shuffle(DS_size).batch(1024)\n",
    "    \n",
    "    print(\"SNR (dB) = \", end='')\n",
    "    rates = []\n",
    "    for snr_i in SNRs_eval :\n",
    "\n",
    "        rates_temp = []\n",
    "        for step, (bits, SNRs) in enumerate(TF_DS_test):\n",
    "            pb_eq_1 = model(bits, SNRs*snr_i)\n",
    "            err_loss =  tf.reduce_mean(tf.keras.losses.binary_crossentropy(bits, pb_eq_1))\n",
    "            rates_temp.append(model.K-err_loss.numpy())\n",
    "        rates.append(np.mean(rates_temp))\n",
    "        print(str(snr_i)+', ', end='')\n",
    "    print('')\n",
    "    return rates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "id": "hdxPNRA0STRS"
   },
   "outputs": [],
   "source": [
    "def gen_DS(DS_size, K, SNR_db_low, SNR_db_high):\n",
    " \n",
    "    DS_bits = tf.random.uniform(shape=[DS_size, K], minval=0, maxval=2, dtype=tf.int32)\n",
    "    DS_SNRs = tf.random.uniform(shape=[DS_size, 1], minval=SNR_db_low, maxval=SNR_db_high)\n",
    "    return tf.cast(DS_bits, tf.float32), DS_SNRs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# AWGN Channel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "id": "osNgVli3STRT"
   },
   "outputs": [],
   "source": [
    "class Channel(Layer):\n",
    "\n",
    "    def __init__(self, **kwargs):\n",
    "        super(Channel, self).__init__(**kwargs)           \n",
    "    def call(self, x, SNR_db):        \n",
    "        noise_std = tf.sqrt( 1 / tf.pow(10., SNR_db/10.0))\n",
    "        noise_r = tf.random.normal(shape = [tf.shape(x)[0], 1], stddev = 1) * noise_std/tf.sqrt(2.)\n",
    "        noise_i = tf.random.normal(shape = [tf.shape(x)[0], 1], stddev = 1) * noise_std/tf.sqrt(2.)\n",
    "        return x + tf.complex(noise_r, noise_i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "lQzX4bTgSTRZ"
   },
   "source": [
    "# Autoencoder Model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wb90JVMUSTRZ"
   },
   "source": [
    "### 1. Define Autoencoder model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Autoencoder(Model):\n",
    "\n",
    "    def __init__(self, K, **kwargs):\n",
    "        super(Autoencoder, self).__init__(**kwargs)\n",
    "        \n",
    "        self.K = K\n",
    "        self.powtwo = tf.constant([float(tf.pow(2, i)) for i in range(self.K)])\n",
    "        \n",
    "        self.tx_layer_1 = Dense(128, activation='relu') \n",
    "        self.tx_layer_2 = Dense(128, activation='relu') \n",
    "        self.tx_layer_3 = Dense(128, activation='relu') \n",
    "        self.tx_layer_4 = Dense(128, activation='relu') \n",
    "        self.tx_layer_5 = Dense(128, activation='relu') \n",
    "        self.tx_layer_6 = Dense(2 * tf.pow(2, K)) \n",
    "        \n",
    "        self.channel = Channel() \n",
    "        \n",
    "        self.rx_layer_1 = Dense(128, activation='relu') \n",
    "        self.rx_layer_2 = Dense(128, activation='relu') \n",
    "        self.rx_layer_3 = Dense(128, activation='relu') \n",
    "        self.rx_layer_4 = Dense(128, activation='relu') \n",
    "        self.rx_layer_5 = Dense(128, activation='relu') \n",
    "        self.rx_layer_6 = Dense(self.K, activation='sigmoid') \n",
    "    \n",
    "    def call(self, bits, SNR_db):        \n",
    "        ### Encoder\n",
    "        self.x = SNR_db\n",
    "        self.x = self.tx_layer_1(self.x)\n",
    "        self.x = self.tx_layer_2(self.x)\n",
    "        self.x = self.tx_layer_3(self.x)\n",
    "        self.x = self.tx_layer_4(self.x)\n",
    "        self.x = self.tx_layer_5(self.x)\n",
    "        self.x = self.tx_layer_6(self.x)\n",
    "        self.x = tf.complex(self.x[:,:(tf.pow(2,K))], self.x[:,(tf.pow(2,K)):])\n",
    "\n",
    "        ### Normalization & Channel\n",
    "        bit = tf.math.reduce_sum(bits * self.powtwo, 1)\n",
    "        bit = tf.cast(bit, tf.int32)\n",
    "        bit = tf.one_hot(bit, tf.pow(2, K))\n",
    "        self.energy = tf.reduce_mean(tf.square(tf.abs(self.x)), axis=1, keepdims=True)\n",
    "        self.x = self.x/tf.cast(tf.sqrt(self.energy),tf.complex64)\n",
    "        self.x = tf.reduce_sum(tf.math.multiply(self.x, tf.cast(bit,tf.complex64)), axis=1, keepdims=True)\n",
    "        \n",
    "        self.y = self.channel(self.x, SNR_db)\n",
    "        self.yc = tf.concat([tf.math.real(self.y), tf.math.imag(self.y)], axis=1)\n",
    "        \n",
    "        ### Receiver\n",
    "        self.y = tf.concat([SNR_db, self.yc], axis=1)\n",
    "        self.y = self.rx_layer_1(self.y)\n",
    "        self.y = self.rx_layer_2(self.y)\n",
    "        self.y = self.rx_layer_3(self.y)\n",
    "        self.y = self.rx_layer_4(self.y)\n",
    "        self.y = self.rx_layer_5(self.y)\n",
    "        self.pb = self.rx_layer_6(self.y)\n",
    "        \n",
    "        return self.pb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "CjA1bKUxSTRa"
   },
   "source": [
    "### 2 -  Instantiate the model, the loss, and the optimizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "id": "LyCfZJyASTRa"
   },
   "outputs": [],
   "source": [
    "K = 4\n",
    "\n",
    "# Instantiate an autoencoder\n",
    "autoencoder = Autoencoder(K)\n",
    "\n",
    "#Initialize optimizer and loss function\n",
    "optimizer = tf.keras.optimizers.Adam(learning_rate=0.0001) # Optimizer\n",
    "loss_func = tf.keras.losses.BinaryCrossentropy() # Loss function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "CbDZxDPfSTRa"
   },
   "source": [
    "### 3 - generate and create optimized Tensorflow datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "dYcem6-_STRa",
    "outputId": "3bf849a3-7ac4-4f8f-8630-cd7890dad5df"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataset generated with K = 4\n"
     ]
    }
   ],
   "source": [
    "DS_size_train = 100000+352\n",
    "DS_size_test = 1000\n",
    "\n",
    "batch_size = 1024\n",
    "DS_bits, DS_SNRs_db = gen_DS(DS_size_train+DS_size_test+24, K, SNR_db_low=-5, SNR_db_high=30)\n",
    "print('Dataset generated with K =', K)\n",
    "TF_DS_train = tf.data.Dataset.from_tensor_slices((DS_bits[:DS_size_train], DS_SNRs_db[:DS_size_train])).shuffle(10000).batch(batch_size)\n",
    "TF_DS_test = tf.data.Dataset.from_tensor_slices((DS_bits[DS_size_train:], DS_SNRs_db[DS_size_train:])).batch(batch_size)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "MF3AJNwrSTRb"
   },
   "source": [
    "### 4 - Train the model\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Cp5BNLwlSTRb",
    "outputId": "76f9e4eb-7e37-4e87-faa7-6473db511ed2"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loss after each epoch:\n",
      "0.589051, 0.41748828, 0.3923183, 0.37660277, 0.3380716, 0.29445857, 0.25941473, 0.24180242, 0.2374564, 0.22810134, 0.20396677, 0.20484404, 0.22254667, 0.21040282, 0.2016527, 0.20309141, 0.19186632, 0.1979613, 0.19741394, 0.19443755, 0.19068995, 0.1854867, 0.18767655, 0.1861771, 0.19545613, 0.20823014, 0.19139694, 0.1867503, 0.18738425, 0.1979741, Done\n"
     ]
    }
   ],
   "source": [
    "### Training loop \n",
    "nb_epoch = 30\n",
    "\n",
    "print('Loss after each epoch:')\n",
    "\n",
    "for epoch in range(nb_epoch):\n",
    "    \n",
    "    # Iterate over the batches of the dataset.\n",
    "    for step, (DS_bits, DS_SNRs_db) in enumerate(TF_DS_train):\n",
    "        # print(\"DS_SNRs_db size = \", DS_SNRs_db.shape)\n",
    "        \n",
    "        # Open a GradientTape.\n",
    "        with tf.GradientTape() as tape:\n",
    "\n",
    "            # Forward pass.\n",
    "            probas = autoencoder(DS_bits, DS_SNRs_db)\n",
    "\n",
    "            # Loss value for this batch.\n",
    "            loss_value = loss_func(y_true=DS_bits, y_pred=probas)\n",
    "\n",
    "        # Get gradients of loss wrt the weights.\n",
    "        gradients = tape.gradient(loss_value, autoencoder.trainable_weights)\n",
    "\n",
    "        # Update the weights of our linear layer.\n",
    "        optimizer.apply_gradients(zip(gradients, autoencoder.trainable_weights))\n",
    "    \n",
    "    #Test the model on the test datasets\n",
    "    test_loss = 0.\n",
    "    for step, (DS_bits, DS_SNRs_db) in enumerate(TF_DS_test):\n",
    "        probas = autoencoder(DS_bits, DS_SNRs_db)\n",
    "        test_loss += loss_func(y_true=DS_bits, y_pred=probas)\n",
    "    print((test_loss/(step+1)).numpy(), end=', ')\n",
    "print('Done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "YPuAoVlqSTRb"
   },
   "source": [
    "### 5 - Evaluate the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 763
    },
    "id": "FyQqc6ZlSTRb",
    "outputId": "e347c09c-3e7c-4edf-c3a0-573d0f113f2a"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2100x600 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "visualize(autoencoder, SNRs_db=[0, 10, 25])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, BER = np.array( [0.29728825, 0.2693855, 0.2418215, 0.2160345, 0.191, 0.1667015, 0.14274325, 0.120013, 0.09852825, 0.078941, 0.0613385, 0.0460825, 0.0333185, 0.02281625, 0.01487075, 0.008843, 0.00490075, 0.00244525, 0.00104975, 0.000416, 0.0001305, 3.775e-05, 8e-06, 7.5e-07, 2.5e-07, 0.0, 0.0, 0.0, 0.0, 0.0]) "
     ]
    }
   ],
   "source": [
    "snr_range = np.arange(0, 30)\n",
    "results=[]\n",
    "bs_eval = 1000000\n",
    "\n",
    "for eval_snr in snr_range:\n",
    "    batch_bits = tf.random.uniform(shape=[bs_eval, K], minval=0, maxval=2, dtype=tf.int32)\n",
    "    batch_snr = eval_snr*tf.ones(shape=[bs_eval, 1])\n",
    "       \n",
    "    \n",
    "    p_b = autoencoder(tf.cast(batch_bits, tf.float32), tf.cast(batch_snr, tf.float32))\n",
    "    # rot = autoencoder2.yc\n",
    "    # matplotlib.pyplot.scatter((rot[:, 0]), (rot[:, 0]))\n",
    "    b_hat = tf.cast(tf.sign(p_b-0.5)/2+1, dtype=tf.int32)\n",
    "    ber = tf.reduce_sum(tf.abs(b_hat - batch_bits))/(bs_eval*K)\n",
    "    results.append(ber.numpy())\n",
    "    print(eval_snr, end=', ')\n",
    "print(\"BER = np.array(\", results, end=') ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot\n",
    "plt.figure(figsize=(8, 5))\n",
    "plt.semilogy(snr_range, results, 'bo-', label='AE bitwise')\n",
    "plt.xlabel('SNR(dB)')\n",
    "plt.ylabel('BER');\n",
    "plt.legend(loc='lower left')\n",
    "plt.grid(which='major', alpha=0.5)\n",
    "plt.grid(which='minor', alpha=0.25)"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "name": "DL_project_correction.ipynb",
   "provenance": []
  },
  "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.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}