end_to_end_no_channel.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. End-to-End Learning of Communications Systems Without a Channel Model - Reinforcement Learning\n",
    "\n",
    "The goal of this notebook is to implement the models presented by [Aoudia and Hoydis, 2018](https://arxiv.org/pdf/1804.02276.pdf).\n",
    "\n",
    "We use pytorch to implement the approach presented in the paper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "\n",
    "import numpy as np\n",
    "import math\n",
    "\n",
    "# To make the plots\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "from IPython import display"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If possible we are going to use GPU to train faster"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pytorch device: cuda:0\n"
     ]
    }
   ],
   "source": [
    "device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')\n",
    "print('Pytorch device: %s' % (device))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The models implemented in Pytorch and other necessary utilities are loaded from different files. This is done to have a single point of modification and the modules can be used in different places. It also helps us to keep this notebook as clean as possible and focus on the results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from models import Transmitter, Receiver, Policy\n",
    "from utils import plot_constellation, count_errors, MemoryMessages, recover_models\n",
    "from comms_utils import channel"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All the pretrained models are located at this folder. Also if we use this notebook to train a new model is going to be saved at this folder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "MODELS_FOLDER = 'trained_models'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a flag tha indicates if the notebook should train the models. If the flag is False then it is assumed we have some pre-trained models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "train = True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementation of approach without a channel model\n",
    "\n",
    "Just as in Autoencoders and traditional communications we have a Transmitter (Tx), a channel and a Receiver (Rx). \n",
    "\n",
    "The Tx can take up to $M$ possible messasges and find a representation in $n$ possible bits of each message $m$. To transmit $M$ messages we need at least $k = \\text{log}_2(M)$ bits. Traditionally this is the notation used in communications to present encoders $(n, k)$, which means $k$ bits encoded into $n$ bits. Traditionally $n \\geq k$ to have redundancy bits that can help us in error checking on the reciever side.\n",
    "\n",
    "The Rx takes $n$ bits and tries to guess the original $m$ message. Normally this is presented as a conditional probability $p(y|x)$ where $y$ is the received message and $x$ the original one.\n",
    "\n",
    "Autoencoders rely on having a differentiable channel and then knowing the gradient of such channel. This does not represents accurately communications systems in which most of the time we do not have a model of the channel and much less a gradient over it. To overcome this difficulty the approach proposed by the paper is to have a feedback from the receiver to the transmitter. Then the transmitter can calculate a loss value without knowing the gradient of the channel. \n",
    "\n",
    "The training of the whole system can be divided in two main phases:\n",
    "- Training of the transmitter\n",
    "- Training of the receiver\n",
    "\n",
    "Since the training loop alternates between these two phases we are going to refer to it as **Alternating training**.\n",
    "\n",
    "#### Training of the receiver\n",
    "\n",
    "Training the transmitter is Supervised learning task. The receiver, just as the autoencoder, outputs a set of probabilities. The probability of the $i^{th}$ example that went in the receiver belongs to each $m$ message. Since we also know which are the correct labels for the $i^{th}$ (original transmitted messages) then we can use a Negative Log Likelihood loss function. The original paper suggests using Cross Entropy loss function. Cross Entropy is nothing more than the combination of Log Softmax function with Negative Log Likelihood. So in the end we are in fact using Cross Entropy.\n",
    "\n",
    "#### Training of the transmitter\n",
    "\n",
    "The transmitter uses three parts for calculating its loss\n",
    "- *Per example loss*. This is the feedback from the receiver. Is the negative log likelihood of each received example\n",
    "- $x_p$. The transmitter outputs $x$ and a function generates $x_p$\n",
    "- The log probability of $x_p$ according to some policy $\\pi(x_p|\\cdot)$\n",
    "\n",
    "In the paper the training of the transmitter is referred as a Reinforcement Learning approach. I do not consider it entirely as such since the policy that is used does not have learnable parameters. It is a static policy. The policy used is a Multivariate Gaussian distribution. It takes in $x_p$ and outputs it's probability according to the Gaussian distribution. The covariance matrix of the Gaussian distribution never changes and the mean of it depends entirely on $x$ as we will soon see. In a traditional Policy Gradient Reinforcement Learning approach the purpose is to tune the parameters of the policy (in this case the mean and variance) to get better results.\n",
    "\n",
    "The policy has a static parameter $\\sigma_{\\pi}^2$ that is not learnable. We use it to first generate $x_p$\n",
    "$$\n",
    "\\begin{aligned}\n",
    "x_p &= \\sqrt{1 - \\sigma_{\\pi}^2}x + w \\\\\n",
    "w &\\sim \\mathcal{C}\\mathcal{N}(0, \\sigma_{\\pi}^2I)\n",
    "\\end{aligned}\n",
    "$$\n",
    "Where $x$ is the output of the transmitter.\n",
    "\n",
    "Then the policy $\\pi(x_p|\\cdot)$ has as mean and covariance matrix\n",
    "$$\n",
    "\\begin{aligned}\n",
    "\\mu_{\\pi} &= \\sqrt{1 - \\sigma_{\\pi}^2}x \\\\\n",
    "\\Sigma_{\\pi} &= \\sigma_{\\pi}^2I\n",
    "\\end{aligned}\n",
    "$$\n",
    "\n",
    "We use this policy to evaluate the built $x_p$ and get its log probability\n",
    "$$\n",
    "\\begin{aligned}\n",
    "\\text{log }\\pi(x_p\\ |\\ \\mu_{\\pi}, \\Sigma_{\\pi})\n",
    "\\end{aligned}\n",
    "$$\n",
    "\n",
    "So then the loss for a batch of size $B$ that that comes out of the transmitter is\n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "\\frac{1}{B} \\sum_{i=0}^B l_i \\text{log }\\pi(x_{ip}\\ |\\ \\mu_{i\\pi}, \\Sigma_{\\pi})\n",
    "\\end{aligned}\n",
    "$$\n",
    "\n",
    "Where $l_i$ is the Negative Log Likelihood obtained from the $i^{th}$ example at the receiver and $x_{ip}$ and $\\mu_{i\\pi}$ are obtained for every $x_i$ in the batch."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_loop(m=256, n=4, snr_db=10, sigma_var=0.02, chann_type=\"AWGN\", stop_value=0.005,\n",
    "               n_epochs=1000, lr=0.001, batch_size=32, plot=False):\n",
    "    # Get k. Number of bits necessary to transmit the m messages\n",
    "    k = math.log2(m)\n",
    "    \n",
    "    # Initialize the transmitter, receiver and policy\n",
    "    tx = Transmitter(m=m, n=n)\n",
    "    tx.to(device)\n",
    "    rx = Receiver(m=m, n=n)\n",
    "    rx.to(device)\n",
    "    policy = Policy(m=m, n=n, sigma_var=sigma_var)\n",
    "    policy.to(device)\n",
    "    \n",
    "    # Adam optimizer for both rx and tx\n",
    "    tx_optimizer = torch.optim.Adam(tx.parameters(), lr=lr)\n",
    "    rx_optimizer = torch.optim.Adam(rx.parameters(), lr=lr)\n",
    "\n",
    "    # Variables to keep track of training\n",
    "    losses_tx = []\n",
    "    losses_rx = []\n",
    "    avg_losses_tx = []\n",
    "    avg_losses_rx = []\n",
    "    errors_rx = []\n",
    "    errors_tx = []\n",
    "    \n",
    "    for epoch in range(n_epochs):\n",
    "        # Beginning of the epoch. Fill out the memory\n",
    "        messages = MemoryMessages(m)\n",
    "        error_rx = 0\n",
    "        error_tx = 0\n",
    "        \n",
    "        # Until we have something in the memory the epoch has not finished\n",
    "        while len(messages) > 0:\n",
    "            # Sample from the memory that is left\n",
    "            batch, _ = messages.sample(batch_size)\n",
    "            batch_len = len(batch)\n",
    "\n",
    "            # ** Phase 1 of alternated training - Train receiver **\n",
    "            rx_optimizer.zero_grad()\n",
    "            \n",
    "            # To ensure we are not using gradients from the channel\n",
    "            with torch.no_grad():\n",
    "                inputs_rx = torch.from_numpy(batch).unsqueeze(1).to(device)\n",
    "\n",
    "                tx.eval()\n",
    "                x_encoded = tx(inputs_rx)\n",
    "                tx.train()\n",
    "\n",
    "                x_channel = channel(x=x_encoded, n=n, k=k, snr_db=snr_db, chann_type=chann_type)\n",
    "            \n",
    "            # Get only gradients from the receiver\n",
    "            y = rx(x_channel, chann_type=chann_type)\n",
    "            \n",
    "            # Classification task. Supervised training. Check if what we received is correct\n",
    "            targets = torch.from_numpy(batch).to(device)\n",
    "            loss_rx = F.nll_loss(y, targets)\n",
    "            loss_rx.backward()\n",
    "\n",
    "            # Count the errors that we had in this phase\n",
    "            error_rx += count_errors(y, targets)\n",
    "            rx_optimizer.step()\n",
    "        \n",
    "            # ** Phase 2 of alternated training - Train transmitter **\n",
    "            tx_optimizer.zero_grad()\n",
    "            \n",
    "            inputs_tx = torch.from_numpy(batch).unsqueeze(1).to(device)\n",
    "            \n",
    "            # Get gradients from the transmitter and the policy\n",
    "            x_encoded = tx(inputs_tx)\n",
    "            xp, xp_logprob = policy(x_encoded)\n",
    "            \n",
    "            # To ensure we are not using gradients from the channel\n",
    "            with torch.no_grad():\n",
    "                xp_channel = channel(x=xp, n=n, k=k, snr_db=snr_db, chann_type=chann_type)\n",
    "\n",
    "                rx.eval()\n",
    "                y = rx(xp_channel, chann_type=chann_type)\n",
    "                rx.train()\n",
    "                \n",
    "                targets = torch.from_numpy(batch).to(device)\n",
    "                # Get the per example losses at the receiver\n",
    "                per_example_losses = F.nll_loss(y, targets, reduction='none')\n",
    "            \n",
    "            # With the per example losses calculated at the receiver make the loss of the transmitter\n",
    "            # NB the per example losses do not have a gradient (.detach() in Pytorch)\n",
    "            loss_tx = torch.mean(per_example_losses.detach().unsqueeze(1)*xp_logprob.reshape(batch_len, 2*n))\n",
    "            loss_tx.backward()\n",
    "            \n",
    "            # Count the errors that we had in this phase\n",
    "            error_tx += count_errors(y, targets)\n",
    "            \n",
    "            tx_optimizer.step()\n",
    "        \n",
    "        \n",
    "        losses_rx.append(loss_rx.detach().to(\"cpu\").numpy())\n",
    "        losses_tx.append(loss_tx.detach().to(\"cpu\").numpy())\n",
    "        errors_rx.append(error_rx/m)\n",
    "        errors_tx.append(error_tx/m)\n",
    "        \n",
    "        # If the loss is small enough the model has converged. Stop training\n",
    "        last_losses = np.array(losses_rx[-100:])\n",
    "        if np.all(np.array(losses_rx[-100:]) < stop_value):\n",
    "            return tx, rx, errors_rx, errors_tx\n",
    "        \n",
    "        # If we desire to visualize the training we enter this if\n",
    "        if plot is not None:\n",
    "            print(\"Finished epoch: %d. Error rx: %f. Error tx: %f. Loss rx: %f. Loss tx: %f\" % (epoch,\n",
    "                                                                                                errors_rx[-1], errors_tx[-1],\n",
    "                                                                                                losses_rx[-1], losses_tx[-1]), end=\"\\r\")\n",
    "\n",
    "            if epoch > plot:\n",
    "                avg_rx = np.mean(losses_rx[-plot:])\n",
    "                avg_tx = np.mean(losses_tx[-plot:])\n",
    "            else:\n",
    "                avg_rx = np.mean(losses_rx)\n",
    "                avg_tx = np.mean(losses_tx)\n",
    "            avg_losses_rx.append(avg_rx)\n",
    "            avg_losses_tx.append(avg_tx)\n",
    "\n",
    "            # Make a plot of training\n",
    "            if epoch%plot==0 and epoch != 0:\n",
    "                plt.clf()\n",
    "                plt.plot(errors_rx, label=\"Rx errors. Alternating training\")\n",
    "                plt.plot(errors_tx, label=\"Tx errors. Alternating training\")\n",
    "                plt.legend(loc='upper right')\n",
    "                display.clear_output(wait=True)\n",
    "                display.display(plt.gcf())\n",
    "            \n",
    "            if epoch == n_epochs-1:\n",
    "                print()\n",
    "                print(\"Finished training. Error rx: %f. Error tx: %f. Loss rx: %f. Loss tx: %f\" % (errors_rx[-1], errors_tx[-1],\n",
    "                                                                                                   losses_rx[-1], losses_tx[-1]))\n",
    "\n",
    "\n",
    "    return tx, rx, errors_rx, errors_tx"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This are the original parameters that the paper used for training $(M, n) = (256, 4)$. In a traditional communications notation it is equivalent to $(n, k) = (4, 8)$. This means that the purpose of the trained system is to use 4 bits to represent messages that would need at least 8 bits to be represented. Normally in communcations we try to do the opposite, use more bits $n > k$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Finished epoch: 149. Error rx: 0.003906. Error tx: 0.015625. Loss rx: 0.031029. Loss tx: -132.893417\n",
      "Finished training. Error rx: 0.003906. Error tx: 0.015625. Loss rx: 0.031029. Loss tx: -132.893417\n",
      "Models saved in trained_models/AWGN_256_4_tx.pth, trained_models/AWGN_256_4_rx.pth\n"
     ]
    },
    {
     "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": [
    "chann_type = \"AWGN\"\n",
    "m = 256\n",
    "n = 4\n",
    "\n",
    "if train:\n",
    "    tx, rx, _, _ = train_loop(m=m, n=n, snr_db=10, chann_type=chann_type, n_epochs=150, plot=10)\n",
    "\n",
    "    tx_filename = \"%s/%s_%d_%d_tx.pth\" % (MODELS_FOLDER, chann_type, m, n)\n",
    "    rx_filename = \"%s/%s_%d_%d_rx.pth\" % (MODELS_FOLDER, chann_type, m, n)\n",
    "    torch.save(tx.state_dict(), tx_filename)\n",
    "    torch.save(rx.state_dict(), rx_filename)\n",
    "\n",
    "    print(\"Models saved in %s, %s\" % (tx_filename, rx_filename))\n",
    "    \n",
    "    torch.cuda.empty_cache()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can watch the constellation generated by our Tx. This is done by getting the encoding for all possible messages and then adding 20 noise samples. So for every $m$ message of $M$ we will plot 20 different samples with noise. After adding the noise we will visualize the constellation using 2 dimensional t-SNE. If the encoder is trained properly we would be able to clearly distinguish between the groups of noisy samples of each $m$ message."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 792x648 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(1, 1, figsize=(11, 9), facecolor='w')\n",
    "ax = plot_constellation(m=256, n=4, model=\"alternated\", ax=ax, device=device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can simulate end-to-end communication. We use the pre-trained models to encode a block of messages. First the messages will go through the Tx, then they will go through the channel that will add noise and at the end we will pass them through the Rx. As mentioned before, the Rx will output the probability the received sample corresponds to each $m$ message. We are going to pick the one with highest probability. After this decission we are going to check how many mistakes we had i.e. calculate the Block Error Rate (BLER)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def nn_communication(m, n, snr_db, n_blocks, chann_type=\"AWGN\", model=\"supervised\", verbose=False):\n",
    "    enc, dec = recover_models(device, model=model, m=m, n=n, chann_type=chann_type)\n",
    "    \n",
    "    # Print the parameters of our trained models\n",
    "    if verbose: print(\"Models\")\n",
    "    if verbose: print(enc)\n",
    "    if verbose: print(dec)\n",
    "    if verbose: print()\n",
    "\n",
    "    k = math.log2(m)\n",
    "    # We are not training hence not using gradients. Just evaluating\n",
    "    with torch.no_grad():\n",
    "        # Generate as much data as specified in the parameters\n",
    "        data = torch.randint(0, m, (n_blocks, 1)).to(device)\n",
    "        if verbose: print(\"Original x\")\n",
    "        if verbose: print(data)\n",
    "        \n",
    "        # Encode the data (Tx)\n",
    "        enc_data = enc(data)\n",
    "        if verbose: print(\"Encoded x\")\n",
    "        if verbose: print(enc_data)\n",
    "    \n",
    "        # Pass the data through the channel. Add noise\n",
    "        noise_data = channel(enc_data, n, k, snr_db, chann_type=chann_type)\n",
    "        if verbose: print(\"x with noise\")\n",
    "        if verbose: print(noise_data)\n",
    "        \n",
    "        # Decode the data (Rx)\n",
    "        dec_data = dec(noise_data, chann_type=chann_type)\n",
    "        \n",
    "        # The last layer returns probabilites over all possible messages\n",
    "        # Choos the one that has the highest one\n",
    "        data_dec = torch.argmax(dec_data, dim=1).unsqueeze(1)\n",
    "        if verbose: print(\"Recovered x\")\n",
    "        if verbose: print(data_dec)\n",
    "        \n",
    "        # Count the errors that we had\n",
    "        errors = data_dec != data\n",
    "        total_errors = errors.sum().to(\"cpu\").numpy()\n",
    "\n",
    "    # Get the error. Rate of the errrors\n",
    "    bler = total_errors/n_blocks\n",
    "    if verbose: print(\"BLER\")\n",
    "    if verbose: print(bler)\n",
    "\n",
    "    print(\"Finished calculations for channel (%s). SNR dB: %f.\" % (chann_type, snr_db))\n",
    "    return bler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Models\n",
      "Transmitter(\n",
      "  (transmit): Sequential(\n",
      "    (0): Embedding(256, 256)\n",
      "    (1): ReLU()\n",
      "    (2): Linear(in_features=256, out_features=8, bias=True)\n",
      "  )\n",
      "  (normalization): BatchNorm1d(4, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      ")\n",
      "Receiver(\n",
      "  (receive): Sequential(\n",
      "    (0): Linear(in_features=8, out_features=256, bias=True)\n",
      "    (1): ReLU()\n",
      "    (2): Linear(in_features=256, out_features=256, bias=True)\n",
      "    (3): LogSoftmax()\n",
      "  )\n",
      "  (estimate_h): Sequential(\n",
      "    (0): Linear(in_features=8, out_features=20, bias=True)\n",
      "    (1): Tanh()\n",
      "    (2): Linear(in_features=20, out_features=2, bias=True)\n",
      "  )\n",
      ")\n",
      "\n",
      "Original x\n",
      "tensor([[124],\n",
      "        [ 54],\n",
      "        [187],\n",
      "        [181],\n",
      "        [ 94],\n",
      "        [248],\n",
      "        [144],\n",
      "        [241],\n",
      "        [243],\n",
      "        [212]], device='cuda:0')\n",
      "Encoded x\n",
      "tensor([[[-1.0603, -0.7804],\n",
      "         [-3.1550,  0.3742],\n",
      "         [ 1.1954, -3.9883],\n",
      "         [ 1.3123,  1.3881]],\n",
      "\n",
      "        [[-2.8534, -0.3190],\n",
      "         [-2.7750, -0.8482],\n",
      "         [-1.1436, -1.5230],\n",
      "         [ 0.8136,  3.0270]],\n",
      "\n",
      "        [[-0.0310, -0.1439],\n",
      "         [-2.4237, -0.6460],\n",
      "         [-0.6016, -1.4392],\n",
      "         [ 1.4742,  1.0581]],\n",
      "\n",
      "        [[-0.0549, -0.9103],\n",
      "         [-0.8889, -0.5773],\n",
      "         [-1.7863, -1.5218],\n",
      "         [-0.5447,  0.9439]],\n",
      "\n",
      "        [[-0.3936,  1.4370],\n",
      "         [-1.4442,  0.5031],\n",
      "         [ 0.3706, -1.8702],\n",
      "         [-0.4146,  0.7406]],\n",
      "\n",
      "        [[-1.0538,  0.4520],\n",
      "         [-1.3107,  0.1963],\n",
      "         [-0.7916, -0.1648],\n",
      "         [ 1.1802, -0.4992]],\n",
      "\n",
      "        [[-1.3110, -0.6099],\n",
      "         [ 0.3668,  0.3498],\n",
      "         [ 0.2455, -0.0194],\n",
      "         [ 1.1031,  1.3819]],\n",
      "\n",
      "        [[-3.4581, -0.2963],\n",
      "         [-3.4181,  1.1357],\n",
      "         [ 1.8522, -2.4560],\n",
      "         [-2.4013,  2.5558]],\n",
      "\n",
      "        [[-2.1710, -1.2932],\n",
      "         [-2.4789, -0.4099],\n",
      "         [-0.3769, -3.0968],\n",
      "         [ 0.6672,  3.3071]],\n",
      "\n",
      "        [[-0.7394, -1.1983],\n",
      "         [-1.3529, -0.8554],\n",
      "         [-0.3186, -2.3998],\n",
      "         [-1.9127,  1.5979]]], device='cuda:0')\n",
      "x with noise\n",
      "tensor([[[-0.2038, -1.5493],\n",
      "         [-2.9089,  1.1061],\n",
      "         [ 1.4978, -3.6078],\n",
      "         [ 1.7919,  1.3335]],\n",
      "\n",
      "        [[-3.1206, -0.2032],\n",
      "         [-2.3510, -0.5438],\n",
      "         [-1.3478, -1.8539],\n",
      "         [ 1.2695,  2.7629]],\n",
      "\n",
      "        [[-0.1928, -0.7104],\n",
      "         [-2.4553, -0.2868],\n",
      "         [-0.7019, -2.5271],\n",
      "         [ 1.9287,  1.1062]],\n",
      "\n",
      "        [[-0.5147, -1.3971],\n",
      "         [-1.0226, -0.0432],\n",
      "         [-1.1277, -0.7890],\n",
      "         [-1.6688,  1.6299]],\n",
      "\n",
      "        [[ 0.3060,  1.4514],\n",
      "         [-0.4479,  0.2155],\n",
      "         [ 0.9746, -1.1775],\n",
      "         [-0.0689,  0.7987]],\n",
      "\n",
      "        [[-1.4250,  1.5684],\n",
      "         [-1.2346,  1.0703],\n",
      "         [-0.4828,  0.3553],\n",
      "         [ 1.2606, -0.2567]],\n",
      "\n",
      "        [[-1.4971, -0.2702],\n",
      "         [ 0.2014,  0.3480],\n",
      "         [ 0.8225, -0.0946],\n",
      "         [ 1.6267,  1.8373]],\n",
      "\n",
      "        [[-3.2483,  0.3879],\n",
      "         [-3.5204,  1.4630],\n",
      "         [ 1.5613, -2.5290],\n",
      "         [-2.7234,  3.3408]],\n",
      "\n",
      "        [[-1.8315, -0.6086],\n",
      "         [-1.8465,  0.4740],\n",
      "         [-0.5054, -3.2512],\n",
      "         [ 0.1392,  2.5902]],\n",
      "\n",
      "        [[-0.5413, -1.1410],\n",
      "         [-1.0519, -1.1349],\n",
      "         [-0.8036, -2.1056],\n",
      "         [-2.2980,  1.5315]]], device='cuda:0')\n",
      "Recovered x\n",
      "tensor([[124],\n",
      "        [ 54],\n",
      "        [187],\n",
      "        [ 62],\n",
      "        [ 94],\n",
      "        [248],\n",
      "        [144],\n",
      "        [241],\n",
      "        [219],\n",
      "        [212]], device='cuda:0')\n",
      "BLER\n",
      "0.2\n",
      "Finished calculations for channel (AWGN). SNR dB: 0.000000.\n"
     ]
    }
   ],
   "source": [
    "# Visualize for the alternated approach\n",
    "nn_communication(m=256, n=4, snr_db=0, n_blocks=10, model=\"alternated\", chann_type=\"AWGN\", verbose=True)\n",
    "torch.cuda.empty_cache()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Results\n",
    "\n",
    "We trained our Tx and Rx and a constant noise level of $\\text{SNR}_{\\text{dB}}= 10$. We are going to plot the BLER we obtain from the system with a range of noise levels from -4 to 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Finished calculations for channel (AWGN). SNR dB: -4.000000.\n",
      "Finished calculations for channel (AWGN). SNR dB: -3.000000.\n",
      "Finished calculations for channel (AWGN). SNR dB: -2.000000.\n",
      "Finished calculations for channel (AWGN). SNR dB: -1.000000.\n",
      "Finished calculations for channel (AWGN). SNR dB: 0.000000.\n",
      "Finished calculations for channel (AWGN). SNR dB: 1.000000.\n",
      "Finished calculations for channel (AWGN). SNR dB: 2.000000.\n",
      "Finished calculations for channel (AWGN). SNR dB: 3.000000.\n",
      "Finished calculations for channel (AWGN). SNR dB: 4.000000.\n",
      "Finished calculations for channel (AWGN). SNR dB: 5.000000.\n",
      "Finished calculations for channel (AWGN). SNR dB: 6.000000.\n",
      "Finished calculations for channel (AWGN). SNR dB: 7.000000.\n",
      "Finished calculations for channel (AWGN). SNR dB: 8.000000.\n",
      "Finished calculations for channel (AWGN). SNR dB: 9.000000.\n",
      "Finished calculations for channel (AWGN). SNR dB: 10.000000.\n",
      "Finished calculations for channel (AWGN). SNR dB: 11.000000.\n"
     ]
    }
   ],
   "source": [
    "# Defining all noise levels\n",
    "snrs_db = np.arange(-4, 12, 1)\n",
    "\n",
    "# Number of input messages to simulate\n",
    "n_blocks = 300000\n",
    "\n",
    "# To store the resutls\n",
    "results_y = np.zeros(len(snrs_db))\n",
    "\n",
    "# Iterate over all the (n, k) encodings\n",
    "for snr_n, snr_db in enumerate(snrs_db):\n",
    "    # Get the bler using autoencoder\n",
    "    bler_alternated = nn_communication(m=256, n=4, snr_db=snr_db, n_blocks=n_blocks, chann_type=\"AWGN\")\n",
    "    \n",
    "    # Store the results\n",
    "    results_y[snr_n] = bler_alternated\n",
    "    \n",
    "    torch.cuda.empty_cache()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(9, 7))\n",
    "plt.semilogy(snrs_db, results_y, label=\"Alternated training\")\n",
    "plt.legend(loc='upper right')\n",
    "plt.grid(True)\n",
    "plt.title(\"Channel (m, n)=(256, 4) (n, k)=(4, 8)\")\n",
    "plt.xlabel('Eb/No (dB)')\n",
    "plt.ylabel('BLER')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}