AE_Tutorial_symbolwise_GN.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Symbol-wise Autoencoder\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Import lib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt  \n",
    "\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras import Model\n",
    "from tensorflow.keras.layers import Layer, Dense, Softmax"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define the layers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Normalization(Layer):\n",
    "\n",
    "    def __init__(self, **kwargs):\n",
    "        super(Normalization, self).__init__(**kwargs)\n",
    "\n",
    "    def call(self, symbols):        \n",
    "        # Normalize power per symbol to 1\n",
    "        en_moy = tf.sqrt(2 * tf.reduce_mean(tf.square(symbols)))\n",
    "        symbols_norm = tf.divide(symbols, en_moy)\n",
    "        \n",
    "        return symbols_norm\n",
    "\n",
    "class R2C(Layer):\n",
    "\n",
    "    def __init__(self, **kwargs):\n",
    "        super(R2C, self).__init__(**kwargs)\n",
    "\n",
    "    def call(self, x):\n",
    "        # Converts 2Nc real numbers into Nc complex numbers\n",
    "        x_cplx = tf.complex(x[:, :1], x[:, 1:])\n",
    "            \n",
    "        return x_cplx\n",
    "\n",
    "class C2R(Layer):\n",
    "\n",
    "    def __init__(self, **kwargs):\n",
    "        super(C2R, self).__init__(**kwargs)\n",
    "\n",
    "    def call(self, y):\n",
    "        #converts Nc complex numbers into 2Nc real numbers\n",
    "        y_real = tf.concat([tf.math.real(y), tf.math.imag(y)], axis=1)\n",
    "            \n",
    "        return y_real\n",
    "\n",
    "class OneHot(Layer):\n",
    "\n",
    "    def __init__(self, M, **kwargs):\n",
    "        super(OneHot, self).__init__(**kwargs)\n",
    "        self.M = M\n",
    "\n",
    "    def call(self, msg):\n",
    "        \n",
    "        one_hot_msg = tf.one_hot(msg, depth = M)\n",
    "        \n",
    "        return one_hot_msg\n",
    "\n",
    "class Channel(Layer):\n",
    "\n",
    "    def __init__(self, **kwargs):\n",
    "        super(Channel, self).__init__(**kwargs)\n",
    "            \n",
    "    def call(self, x, snr):\n",
    "        # Adds random Gaussian noise to the input\n",
    "        noise_stddev = tf.sqrt( 2 / tf.pow(10., snr/10.0))\n",
    "        noise_r = tf.random.normal(shape = tf.shape(x), stddev = 1) * noise_stddev/tf.sqrt(2.)\n",
    "        noise_i = tf.random.normal(shape = tf.shape(x), stddev = 1) * noise_stddev/tf.sqrt(2.)\n",
    "        noise_cplx = tf.complex(noise_r, noise_i, name=\"noise\")\n",
    "\n",
    "        return x  + noise_cplx"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generate messages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_ds_msg(epoch_len, batch_size, M):\n",
    "    \n",
    "    #Generate a dataset of 'epoch_len' batches of messages.\n",
    "    #Each batch have a size 'batch_size' and consists of messages (symbols) betwen 0 and M-1\n",
    "    rand_msg = tf.random.uniform(shape=[epoch_len, batch_size], minval=0, maxval=M, dtype=tf.int32)\n",
    "    features_ds = tf.data.Dataset.from_tensor_slices(rand_msg)\n",
    "    \n",
    "    #The labels are the same as the features : this is an autoencoder, we want to predict the same message that has been sent.\n",
    "    labels_ds = features_ds\n",
    "    \n",
    "    return (features_ds, labels_ds)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Autoencoder(Model):\n",
    "\n",
    "    def __init__(self, M, **kwargs):\n",
    "        super(Autoencoder, self).__init__(**kwargs)\n",
    "        \n",
    "        #Set the class' attributes\n",
    "        self.M = M\n",
    "\n",
    "        # Initialise the transmitter layers\n",
    "        self.oh = OneHot(self.M)\n",
    "        self.d1 = Dense(64, activation='elu')\n",
    "        self.d2 = Dense(2, activation=None)\n",
    "        self.norm = Normalization()\n",
    "        self.r2c = R2C()\n",
    "        \n",
    "        # Initialise the channel\n",
    "        self.ch = Channel()\n",
    "        \n",
    "        # Initialise the receiver layers\n",
    "        self.c2r = C2R()\n",
    "        self.d3 = Dense(64, activation='elu')\n",
    "        self.d4 = Dense(self.M, activation=None)\n",
    "        self.softm = Softmax()\n",
    "    \n",
    "    def call(self, inputs, snr):\n",
    "        \n",
    "        # Transmitter\n",
    "        self.x1 = self.oh(inputs)\n",
    "        self.x2 = self.d1(self.x1)\n",
    "        self.x3 = self.d2(self.x2)\n",
    "        self.x4 = self.norm(self.x3)\n",
    "        self.x = self.r2c(self.x4)\n",
    "    \n",
    "        #Channel\n",
    "        self.y = self.ch(self.x, snr)\n",
    "        \n",
    "        #Receiver\n",
    "        self.pb1 = self.c2r(self.y)\n",
    "        self.pb2 = self.d3(self.pb1)\n",
    "        self.pb3 = self.d4(self.pb2)\n",
    "        self.pb = self.softm(self.pb3)\n",
    "    \n",
    "        return self.pb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## loss function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "loss_func = tf.keras.losses.SparseCategoricalCrossentropy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Instantiate the autoencoder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Number of messages\n",
    "M = 8\n",
    "#Set the seeds\n",
    "SEED = 1\n",
    "np.random.seed(SEED)\n",
    "tf.random.set_seed(SEED)\n",
    "\n",
    "#Create the autoencoder\n",
    "autoencoder = Autoencoder(M)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# See constellation before training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 450x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "snr_eval = 10\n",
    "\n",
    "# Form a batch containing every message\n",
    "batch_msg = tf.cast(tf.linspace(0., M-1, M), tf.int32)\n",
    "\n",
    "p_b = autoencoder(batch_msg, snr_eval)\n",
    "\n",
    "msg_np = batch_msg.numpy()\n",
    "x_np = autoencoder.x.numpy()\n",
    "\n",
    "plt.figure(figsize=(4.5, 4))\n",
    "plt.scatter(np.real(x_np[:, 0]), np.imag(x_np[:, 0]))\n",
    "for i in range(np.shape(x_np)[0]) :\n",
    "    plt.text(np.real(x_np[i, 0]), np.imag(x_np[i, 0]), str(msg_np[i]), fontsize=18)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Symbol Error Rate after each epoch:\n",
      "0.126, 0.0402, 0.0154, 0.0113, 0.0102, 0.0109, 0.0099, 0.0096, 0.0117, 0.0088, 0.011, 0.0104, 0.0116, 0.0099, 0.01, 0.0118, 0.0106, 0.0099, 0.0104, 0.01, 0.0111, 0.0098, 0.011, 0.0113, 0.0089, Done\n"
     ]
    }
   ],
   "source": [
    "batch_size = 10000\n",
    "epoch_size = 100\n",
    "nb_epoch = 25\n",
    "snr_training = 15\n",
    "\n",
    "print('Symbol Error Rate after each epoch:')\n",
    "\n",
    "#Initialize optimizer\n",
    "optimizer = tf.keras.optimizers.Adam()\n",
    "\n",
    "for epoch in range(nb_epoch):\n",
    "    \n",
    "    # Create a random dataset for each epoch\n",
    "    dataset = tf.data.Dataset.zip(generate_ds_msg(epoch_size, batch_size, M))\n",
    "\n",
    "    # Iterate over the batches of the dataset.\n",
    "    for step, (features, labels) in enumerate(dataset):\n",
    "        # Open a GradientTape.\n",
    "        with tf.GradientTape() as tape:\n",
    "\n",
    "            # Forward pass.\n",
    "            probas = autoencoder(features, snr_training)\n",
    "\n",
    "            # Loss value for this batch.\n",
    "            loss_value =  loss_func(y_true=labels, 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",
    "    #Take the argmax of the probability distribution as the estimated message\n",
    "    m_hat = tf.argmax(probas, axis=1, output_type=tf.int32)\n",
    "    \n",
    "    ser = tf.reduce_sum(tf.clip_by_value(tf.abs(labels-m_hat), 0, 1))/(batch_size)\n",
    "    print(ser.numpy(), end=', ')\n",
    "print('Done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Evaluate the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.76541, 0.7489, 0.73393, 0.71146, 0.68787, 0.65946, 0.62934, 0.59435, 0.55347, 0.50906, 0.45764, 0.40165, 0.34635, 0.28711, 0.22757, 0.17013, 0.12051, 0.07701, 0.045, 0.02259, 0.01017, 0.00402, 0.00113, 0.00027, 3e-05, 0.0, "
     ]
    }
   ],
   "source": [
    "snr_range = np.arange(-5, 21)\n",
    "results=[]\n",
    "bs_eval = 100000\n",
    "\n",
    "for snr_eval in snr_range:\n",
    "    \n",
    "    batch_msg = tf.random.uniform(shape=[bs_eval], minval=0, maxval=M, dtype=tf.int32)\n",
    "    \n",
    "    p_m = autoencoder(batch_msg, snr_eval)\n",
    "    m_hat = tf.argmax(p_m, axis=1, output_type=tf.int32)\n",
    "    \n",
    "    ser = tf.reduce_sum(tf.clip_by_value(tf.abs(batch_msg-m_hat), 0, 1))/(bs_eval)\n",
    "    print(ser.numpy(), end=', ')\n",
    "    results.append(ser.numpy())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "AE_8 = np.array([0.76541, 0.7489, 0.73393, 0.71146, 0.68787, 0.65946, 0.62934, 0.59435, 0.55347, 0.50906, 0.45764, 0.40165, 0.34635, 0.28711, 0.22757, 0.17013, 0.12051, 0.07701, 0.045, 0.02259, 0.01017, 0.00402, 0.00113, 0.00027, 3e-05, 0.0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(8, 5))\n",
    "plt.semilogy(snr_range, AE_8, label='AE 8-PSK')\n",
    "# plt.semilogy(snr_range, results, label='AE 16-QAM')\n",
    "plt.legend()\n",
    "plt.xlabel('SNR(dB)')\n",
    "plt.ylabel('Symbol Eror Rate');\n",
    "plt.ylim(1e-4, 1)\n",
    "plt.grid(which='major', alpha=0.5)\n",
    "plt.grid(which='minor', alpha=0.25)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## See learned constellation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 450x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "snr_eval = 10\n",
    "\n",
    "# Form a batch containing every message\n",
    "batch_msg = tf.cast(tf.linspace(0., M-1, M), tf.int32)\n",
    "\n",
    "p_b = autoencoder(batch_msg, snr_eval)\n",
    "\n",
    "msg_np = batch_msg.numpy()\n",
    "x_np = autoencoder.x.numpy()\n",
    "\n",
    "plt.figure(figsize=(4.5, 4))\n",
    "plt.scatter(np.real(x_np[:, 0]), np.imag(x_np[:, 0]))\n",
    "for i in range(np.shape(x_np)[0]) :\n",
    "    plt.text(np.real(x_np[i, 0]), np.imag(x_np[i, 0]), str(msg_np[i]), fontsize=18)"
   ]
  }
 ],
 "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.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}