MU_MIMO_Pytorch_CSITR_partial_CSIR.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "toc": true
   },
   "source": [
    "<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n",
    "<div class=\"toc\"><ul class=\"toc-item\"></ul></div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 80
    },
    "colab_type": "code",
    "id": "P4eM9iEYBEPm",
    "outputId": "095b40b0-89f5-4be5-884c-397bbbd0d85c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import torch \n",
    "import torch.nn.functional as F\n",
    "from torch import nn\n",
    "import scipy.io as io\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# from keras.utils import to_categorical\n",
    "from torch.optim import SGD, Adam\n",
    "from torch.utils import data\n",
    "\n",
    "device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
    "print(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "iWD-H5xQBEPp"
   },
   "outputs": [],
   "source": [
    "\n",
    "M=4\n",
    "NN_T = 512\n",
    "NN_R=256"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# a = np.random.randn(1,1000000)/np.sqrt(2)\n",
    "\n",
    "# a[a>0.9*np.max(np.abs(a))] = 0.9**np.max(np.abs(a))\n",
    "\n",
    "\n",
    "# counts, bins = np.histogram(a,1000)\n",
    "# plt.hist(bins[:-1], bins, weights=counts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Al9ZMmg1BEPr"
   },
   "outputs": [],
   "source": [
    "class Encoder(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Encoder, self).__init__()\n",
    "        self.fc1 = nn.Linear(M**2 + 8, NN_T) \n",
    "        self.bn1 = nn.BatchNorm1d(NN_T)\n",
    "        \n",
    "        self.fc2 = nn.Linear(NN_T, NN_T)\n",
    "        self.bn2 = nn.BatchNorm1d(NN_T)\n",
    "        self.fc3 = nn.Linear(NN_T, 4)\n",
    "        \n",
    "    def forward(self, in_message, in_channel):\n",
    "        x = torch.cat([in_message,in_channel],-1)\n",
    "        x = self.bn1(F.relu(self.fc1(x)))\n",
    "        x = self.bn2(F.relu(self.fc2(x)))\n",
    "        x = self.fc3(x)\n",
    "        transmitted = x / (torch.sqrt(2*torch.mean(x**2)))\n",
    "        return transmitted\n",
    "        \n",
    "class Decoder(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Decoder, self).__init__()\n",
    "        self.de_fc1 = nn.Linear(2 + 4, NN_R)  \n",
    "        self.bn1 = nn.BatchNorm1d(NN_R)\n",
    "        \n",
    "        self.de_fc2 = nn.Linear(NN_R, NN_R)\n",
    "        self.bn2 = nn.BatchNorm1d(NN_R)\n",
    "        \n",
    "        self.de_fc3 = nn.Linear(NN_R, NN_R)\n",
    "        self.bn3 = nn.BatchNorm1d(NN_R)\n",
    "        \n",
    "        self.de_fc4 = nn.Linear(NN_R, M)\n",
    "        self.bn4 = nn.BatchNorm1d(M)\n",
    "    def forward(self, in_message, in_channel):\n",
    "        x = torch.cat([in_message,in_channel],-1)\n",
    "#         x = in_message\n",
    "        x = self.bn1(F.relu(self.de_fc1(x)))\n",
    "        x = self.bn2(F.relu(self.de_fc2(x)))\n",
    "        x = self.bn3(F.relu(self.de_fc3(x)))\n",
    "#         x = self.de_fc4(x)\n",
    "        x = self.bn4(self.de_fc4(x))\n",
    "        decoded = F.log_softmax(x, dim=-1)\n",
    "        return decoded\n",
    "        \n",
    "        \n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 357
    },
    "colab_type": "code",
    "id": "WnFI9COKBEPu",
    "outputId": "178fc28b-3f21-47a6-f428-672f5d618013"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch= 0\n",
      "epoch= 1\n",
      "epoch= 2\n",
      "epoch= 3\n",
      "epoch= 4\n",
      "epoch= 5\n",
      "epoch= 6\n",
      "epoch= 7\n",
      "epoch= 8\n",
      "epoch= 9\n",
      "epoch= 10\n",
      "epoch= 11\n",
      "epoch= 12\n",
      "epoch= 13\n",
      "epoch= 14\n",
      "epoch= 15\n",
      "epoch= 16\n",
      "epoch= 17\n",
      "epoch= 18\n",
      "epoch= 19\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "encoder = Encoder().to(device)\n",
    "\n",
    "decoder1=Decoder().to(device)\n",
    "decoder2=Decoder().to(device)\n",
    "criterion= nn.NLLLoss()\n",
    "\n",
    "params = list(encoder.parameters()) + list(decoder1.parameters())+ list(decoder2.parameters())\n",
    "\n",
    "\n",
    "opt = Adam(params, lr = 0.001)\n",
    "\n",
    "loss = np.array([])\n",
    "\n",
    "batch = M * 6400000\n",
    "ch_real_set = torch.randn((batch, 2,2))/np.sqrt(2)\n",
    "ch_imag_set = torch.randn((batch, 2,2))/np.sqrt(2)\n",
    "\n",
    "\n",
    "\n",
    "ch_set = data.TensorDataset(ch_real_set, ch_imag_set)\n",
    "training_generator= data.DataLoader(ch_set, batch_size=2048, shuffle=True, num_workers=4)\n",
    "\n",
    "for epochs in range(20):\n",
    "    print('epoch=', epochs)\n",
    "    for csi_real,csi_imag in training_generator:\n",
    "        csi_real = csi_real.to(device)\n",
    "        csi_imag = csi_imag.to(device)\n",
    "        csi = torch.cat([csi_real.view(-1,4), csi_imag.view(-1,4)], -1)\n",
    "        csi1 = torch.cat([csi[:,0:2], csi[:,4:6]], -1)\n",
    "        csi2 = torch.cat([csi[:,2:4], csi[:,6:8]], -1)\n",
    "        \n",
    "        label1 = np.random.randint(0,M, (csi.shape[0]))\n",
    "        label2 = np.random.randint(0,M, (csi.shape[0]))\n",
    "        \n",
    "        \n",
    "        train_data = 4*label1 + label2\n",
    "        \n",
    "        train_data = F.one_hot(torch.from_numpy(train_data)).float().to(device)\n",
    "      \n",
    "    \n",
    "        \n",
    "        label1 = torch.from_numpy(label1).to(device)\n",
    "        label2 = torch.from_numpy(label2).to(device)\n",
    "        \n",
    "    \n",
    "       \n",
    "        transmitted =encoder(train_data, csi)\n",
    "        \n",
    "        \n",
    "        transmitted_real = transmitted[:, np.arange(0,2)]\n",
    "        transmitted_imag = transmitted[:, np.arange(2,4)]\n",
    "        \n",
    "        tx_real = transmitted_real.view(-1, 2,1)\n",
    "        tx_imag = transmitted_imag.view(-1, 2,1)\n",
    "       \n",
    "\n",
    "        rx_real = torch.bmm(csi_real, tx_real) - torch.bmm(csi_imag, tx_imag)\n",
    "        rx_imag = torch.bmm(csi_real, tx_imag) + torch.bmm(csi_imag, tx_real)\n",
    "       \n",
    "        rx1 = torch.cat([rx_real[:,0,:], rx_imag[:,0,:]], axis=-1)\n",
    "       \n",
    "        rx2 = torch.cat([rx_real[:,1,:], rx_imag[:,1,:]], axis=-1)\n",
    "      \n",
    "        \n",
    "        sigma = np.sqrt(0.5/np.power(10, 15/10))\n",
    "        rx1 = rx1 + (torch.randn(rx1.shape)*sigma).to(device)\n",
    "  \n",
    "        rx2 = rx2 + (torch.randn(rx2.shape)*sigma).to(device)\n",
    "    \n",
    "\n",
    "        y_pred1 = decoder1(rx1, csi1)\n",
    "        y_pred2 = decoder2(rx2, csi2)\n",
    "       \n",
    "        \n",
    "        cross_entropy = criterion(y_pred1, label1) + criterion(y_pred2, label2)\n",
    "\n",
    "        opt.zero_grad()\n",
    "        \n",
    "        \n",
    "        cross_entropy.backward()\n",
    "        opt.step()\n",
    "        \n",
    "\n",
    "        l = cross_entropy.item()\n",
    "        loss = np.append(loss, l)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(250000,)\n"
     ]
    }
   ],
   "source": [
    "print(loss.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "colab_type": "code",
    "id": "yI9_517iBEPw",
    "outputId": "f86a9277-671b-4e1f-8505-0d5ed86d2b04"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1  2  3  4  5  6  7  8  9 10]\n",
      "(2500,)\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXwAAAD8CAYAAAB0IB+mAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAfHUlEQVR4nO3dd3xUVf7/8deZmRQSQigJiISAEASUbgRFUcEOuohgAVelCMta9utvvzbW+l0VUXfdFcUCiyAqNqwsKDZYVJASlCYdQQJIkwQSSEKS8/sjMUtJQsJk5t6ZeT8fj3k4t0zmcx6R972599xzjLUWEREJfx6nCxARkeBQ4IuIRAgFvohIhFDgi4hECAW+iEiEUOCLiEQIn9MFVCYpKck2b97c6TJEREJGRkbGbmttcnnbXB34zZs3Z/HixU6XISISMowxmyvapks6IiIRQoEvIhIhFPgiIhFCgS8iEiEU+CIiEUKBLyISIVzdLfNEfbNuN4XFxSTE+oiP8REf7aN2TMn7aJ+OcSISmcIy8B/6aAUbd+eWuy3a5ykNfy+1Y6KoHeMtOSjE+Ego/W98jI/apdtL9vttne+I97FRHowxQW6diMiJCVrgG2PigReAAmCOtfaNQH3XhJvTyTpwiNz8QnJKX7mlr/1l74vYn1fy/tfcAn7+9QA5pcu5BUVV+h6vxxAffdgBIbb0gBBdegCJLTmwlHewOHKdl/hoHx6PDh4iEjh+Bb4x5hXgCmCntbbdYesvA54FvMC/rLVjgKuBadba6caYt4GABX7L5Np+fb642HLgUBE5eRUdLI48cOTkF5YcLApK9t+xL++/ny0ooqi4arOKxUd7jzkg/PbXRtkBJfqwg0VsyUGlVcMETkqM9avNIhL+/D3Dnww8D0z5bYUxxguMAy4GMoFFxpiPgRRgeeluVTuFdojHY8rOvv1lrSW/sLjsr4nfDiD//cujqJKDSSFbsw6Sk3+o7MBSUFhc7vc0TIihQ0pdOqYk0qFpXTo0SaRefLTf9YtI+PAr0ay1c40xzY9a3RVYb63dCGCMeQvoS0n4pwA/UEnvIGPMCGAEQGpqqj/luYIxhtgoL7FRXpITYvz+eQWFxf89cBQUknXgEKu272NZZjZLM7P4YtWOsn1T68fRISWx9FWX9k0Sia+Bg5iIhKZA/OtvAmw5bDkT6AaMBZ43xvQBplf0YWvteGA8QHp6umZYP0q0z0O0L/qIs/ezWjQoe78v7xArMrNZmpnNsswsvv85i38v2w6AMZCWXLvkL4GmJQeBto0TiPF5g94OEQm+QAR+eXcerbU2FxgSgO+Tw9SJjaJ7WhLd05LK1u3OyWdZZhbLMrNZlpnNf9bu5L0lmUDJAeTi0xoxoEsKPVol4fOq26pIuApE4GcCTQ9bTgG2BeB7pIqSasfQq00jerVpBJTcV9iWnceyLVnM37iH6Uu3MWPZdpITYujXuQn9u6TQ+qQEh6sWkZpmrPXvqknpNfx//9ZLxxjjA9YCFwJbgUXAIGvtymr8zCuBK9PS0oavW7fOr/rk+AoKi/lqdclZ/+zVOykstrRrUof+XVLo26kJ9XXzVyRkGGMyrLXp5W7zJ/CNMW8CFwBJwA7gYWvtRGNMb+CflHTLfMVa+/iJ/Pz09HSrCVCCa09OPh8v3cZ7SzJZsXUfUV5Dz9YNufHsZvRoVe4kOiLiIgEL/EBT4Dtr9S/7eC8jkw9/2Mau/fmcf2oyD/RpS6tGutwj4lYKfPFLQWExU+Zv4tkv13GgoIhBXVO586JWNKjtfzdTEalZlQW+umTIcUX7PNzSowX/ubsnN3RLZerCn7ngb3MYP3cD+YWufoZORA7jyjN83bR1t3U79jN65ipmr9lFswZxPHZVO13fF3GJkDvDt9ZOt9aOSExMdLoUKUerRglMGtKVKUO74vMYbnplIeNmr8eNJw8i8l+uDHwJDeedmsz0O87lig4n8/SsNdz6xhJy8gudLktEKqDAF7/ERfsYe30nHujTllkrf6HfuG/5qYK5CETEWQp88Zsxhlt6tOC1Yd3YnZPP7577hq9W7zj+B0UkqBT4UmPOSUti+h3n0iwpjhFTMlj4069OlyQih3Fl4BtjrjTGjM/Ozna6FKmmlHpxTB1+Fqn14/jj6xlszTrodEkiUsqVga9eOqGtTmwU429Kp6CwmBFTFnOwilNGikhguTLwJfSlNazNswM78eP2fdzz3jJ12RRxAQW+BEyvNo24+9LWTF+6jZfnbnS6HJGIp/nuJKD+eH5Lfty2jyc/XU2z+nFc3r6x0yWJRCyd4UtAGWN4ekBHuqTW4443v+eLH9VdU8QpCnwJuFrRXiYNOZPTT67DrW8sYc6anU6XJBKRXBn46pYZfurERjFlaDdaNarNiNcy+Hb9bqdLEok4rgx8dcsMT4lxUbw+rBstkuIZ9uoivtu4x+mSRCKKKwNfwle9+Ghev6UbKfXiGDp5ERmb9TSuSLAo8CXokmrHMPWWbjSqE8vgVxaxdEuW0yWJRAQFvjiiYZ1Ypg7vRr34aG6cuIAVW3W/RiTQFPjimMaJtZg6vBsJsVH8fuICVv+yz+mSRMKaAl8cVTLYWjdifV5umLCA9Tv3O12SSNhS4IvjmjWI543h3fB4DAMnLGDjrhynSxIJS64MfPXDjzwtk2sz9ZZuFBdbBk1YwM97DjhdkkjYcWXgqx9+ZGrVKIHXb+lGXmERAyd8R+Zehb5ITXJl4Evkatu4Dq8P68b+vEPcOHEhe3LynS5JJGwo8MV12jVJ5JXBZ7It6yBDX13MgYJCp0sSCQsKfHGl9Ob1eW5gZ5ZnZnHbG0s4VFTsdEkiIU+BL651yekn8dhV7Zm9Zhej3l+uWbNE/KQJUMTVBnVLZef+PP75xToa1Ynh7kvbOF2SSMhS4Ivr/c+FrdixL59xszfQMCGWm7s3d7okkZCkwBfXM8bwaN/T2Z2TzyPTV5KcEENvTZUoUm2uvIavB6/kaD6vh+cGdqZLaj3ufOsH5m/QWPoi1eXKwNeDV1Ke2CgvE29OJ7VBHCOmLGbVdg22JlIdrgx8kYrUjYvm1aFdiYvxMnjSQj2NK1INCnwJOU3q1uLVoV05UFDEza8sZG9ugdMliYQEBb6EpDYn1WHCTels2XuQYa8u4mBBkdMlibieAl9C1lktGvDsdZ34fksWd7y5hIJCPY0rUhkFvoS0y9s35q992/HFqp0Me3UROfkad0ekIgp8CXk3ntWMpwZ0YN6GPQya8J1G2BSpgAJfwsK16U0Zf+MZrN2xn/4vztNUiSLlUOBL2LiwbSPeuKUbOfmFXDVuHl/8uMPpkkRcRYEvYeWMZvX5+PZzOSUpnlumLOaZz9ZQVKxRNkVAgS9h6OS6tXh35Nlcc0YKY79az6AJ3/FLdp7TZYk4zpWBr7F0xF+xUV6evqYjz1zbkeVbs+k99mtmr9npdFkijnJl4GssHakpV3dJYfod59IwIYYhkxbxxMxVmj1LIpYrA1+kJrVMrs2Ht53D789K5eW5G7n25fls+VVj8EjkUeBLRIiN8vLYVe0ZN6gL63fk0Gfs13y6YrvTZYkElQJfIkqfDo2Z8acenJIUz8jXl3DvtGV6OlcihgJfIk5qgzjeHdmd23um8W7GFno/+zUZm/c6XZZIwCnwJSJF+zzcdWlr3v7D2RRbyzUvzeOZz9eqz76ENQW+RLQzm9fnk//pQb/OKYz9ch2DJ2l8fQlfCnyJeAmxUfz92o6Mubo9Czb+ypXPf8PKbXoGRMKPAl+k1PVdU3n7D2dRWGTp/+I8Pvx+q9MlidQoBb7IYTqn1mP6HefSIaUud779A//4fC3W6rq+hAcFvshRkhNieOOWblxzRgrPfrmOhz5aSbFu5koY8DldgIgbRXk9PDWgA/Xioxk/dyP78w7x5IAOxPi8TpcmcsIU+CIVMMYw6vI2JNaK4ulZa/hlXx4v/z6dxLgop0sTOSG6pCNSCWMMt/VM45/XdSJj8176vzRP4/BIyFLgi1TBVZ2bMGVoN3buy6PfC/NYlpnldEki1abAF6mis1s24P1buxMb5eH68d/x9bpdTpckUi0KfJFqSGuYwPu3die1fhxDJy9i5nKNuCmhw5WBrxmvxM0aJsTy9oiz6ZBSl9unLuHNhT87XZJIlbgy8DXjlbhdYlwUrw3rSo9WyYx6fzl/+WA5BYWaSUvczZWBLxIK4qJ9TLgpncHdmzN1wc8MnrSQPTn5TpclUiEFvogfon0eHvnd6fztmo5kbN7LoAkL+FWjbYpLKfBFasCAM1KYNPhMNu3J5frx89maddDpkkSOocAXqSHd05KYNORMtmfl0f+FeazfmeN0SSJHUOCL1KDuLZN4Z+TZFBYXc93L8/n+Z02dKO6hwBepYW0b1+GdP5xNtM/D1S/OY8Yy9dUXd1DgiwRAi+Ta/PuOc+nUtC73TFvKT7tznS5JRIEvEigNascwblAXon0eRr6WQW5+odMlSYRT4IsE0Ml1a/HcwC6s27mfka9ncLCgyOmSJIIp8EUC7NxWSTw1oCPfrN/NkMkL1U9fHKPAFwmCAWek8M/rOrF40176vfAta3fsd7okiUAKfJEg6dupCW//4Wxy84sYOnkRuzUMgwSZAl8kiM5oVo9/3ZzO7px8hkxapGv6ElQKfJEg69S0LuMGdWHFtmzuencpxcXW6ZIkQijwRRxwYdtGjLq8DTOWb+fJT1djrUJfAs/ndAEikWp4jxZs2JnLy3M3snnPAZ4f1BmfV+dgEjj6v0vEIcYYxvRvz12XnMqnK3/h8ZmrnC5JwpzO8EUcZIzh9l6t+DX3EK98+xOp9eMY3L05xhinS5MwpDN8ERf4S+82XNS2If83/UfuencZRbqRKwGgwBdxAZ/Xw8s3pvOnXmm8tySTp3QjVwJAl3REXMLrMfz5ktbsyS3g5bkb2bU/n79f21GXd6TGKPBFXObRvu2IjfIy8Zuf6NaiPtedmep0SRImdElHxGU8HsMDfdrSrkkdxn65nvxCPY0rNUOBL+JCxhjuvawNW7MOcs6Yr3juy3UcKip2uiwJcUELfGNMC2PMRGPMtGB9p0goOzctiVGXt2F3TgF//3wtj/77R6dLkhBXpcA3xrxijNlpjFlx1PrLjDFrjDHrjTH3VfYzrLUbrbXD/ClWJJIYY/jD+S3ZMLo316U3Zcr8zXy8dJvTZUkIq+oZ/mTgssNXGGO8wDjgcuA0YKAx5jRjTHtjzL+PejWs0apFIojXY3isXztaJMVz51vfM12hLyeoSoFvrZ0L/HrU6q7A+tIz9wLgLaCvtXa5tfaKo147q1qQMWaEMWaxMWbxrl27qtwQkXAW5fXw4e3n0LFpXe6ZtozlmdlOlyQhyJ9r+E2ALYctZ5auK5cxpoEx5iWgszFmVEX7WWvHW2vTrbXpycnJfpQnEl7qxEbxzLWdiInyMGjCd5oqUarNn8Av72mQCh8NtNbusdaOtNa2tNY+4cf3ikSsU5LimXrLWezPL+S+95Yp9KVa/An8TKDpYcspgC4uigTYaSfX4dr0FD77cQfdx3zJj9v2OV2ShAh/An8R0MoYc4oxJhq4Hvi4ZsoSkco8dOXp3H1pa4otjP1yndPlSIioarfMN4H5QGtjTKYxZpi1thC4HZgFrALesdaurImijDFXGmPGZ2frxpRIeWrH+LitZxojz2/Jpyt/4ZqX5rE9+6DTZYnLGTePyJeenm4XL17sdBkirlVYVMyDH63kzYU/kxDr45t7epEYF+V0WeIgY0yGtTa9vG0aWkEkhPm8Hp64uj0v3tCF/XmF9B33DQcLNPaOlE+BLxIGLm/fmKs7N2HTngO0fehTRkxZrPH05RgKfJEwMaZ/B37X8WQAPvtxB5+s+MXhisRtXBn4umkrUn3RPg9jB3Zm1V8vIzkhhlvfWML/vrPU6bLERVwZ+Nba6dbaEYmJiU6XIhJyakV7ufeyNgC8tySTZz5f63BF4hauDHwR8c+AM1JY/WjJeIdjv1zHwx+tYP6GPQ5XJU5T4IuEqdgoL68O7QrAq/M3M3DCdyzdkuVwVeIkBb5IGDv/1GSmDO1KQkzJ9NV9x31LTn6hw1WJU1wZ+LppK1Jzzjs1mYwHL6ZLal0A2j08i1+y8xyuSpzgysDXTVuRmhXt8/DuyO5lyz2e+orsg4ccrEic4MrAF5Ga5/UYNozuzcCuTTlUZOn3wrdOlyRBpsAXiSBej2F0v/Yk1opi465cPvg+0+mSJIgU+CIRxhjDnLsuAOD/vb2U5vfNYH+eLu9EAgW+SASqFx/N4/3alS23f+QzpmXobD/cKfBFItSgrqnMH9WrbPmudzUMQ7hzZeCrW6ZI4BljaJxYi+cHdS5b1+7hWeqnH8ZcGfjqlikSPFd0OJkJN5XMl5GTX8jEr39yuCIJFFcGvogEV/eWDfB6DAD/+GIt6Y997nBFEggKfBEhPsbHhtG9eeyqkhu5u3MKKCwqdrgqqWkKfBEp8/uzmvHUgA4ApN3/icPVSE1T4IvIEfq0b1z2/vMfdzhYidQ0Bb6IHCE+xscrg0tu4g7X3LhhRYEvIsfo1aYRtaK8AJwyaiYvzFnvcEVSE1wZ+OqHL+K8jAcvKnv/1KdreHXeJueKkRrhysBXP3wR58VF+3iyf/uy5Yc/XsnsNTsdrEj85crAFxF3uO7MVDaN6VO2PGTSIjI273WwIvGHAl9EjuunJ3qXve//4jzyDhU5WI2cKAW+iByXMYbJQ84sW+76+BcOViMnSoEvIlVyQeuGfH1PTwD25RXS5sFP+GFLlsNVSXUo8EWkyprWj6Nz6WToeYeKuWrct9ytYZVDhgJfRKrlg1vP4fozm5Ytv5uRyYECDakcChT4IlJtHVLqHrF82kOzNAxDCHBl4OvBKxF3G9i1KTP/1OOIdcOnLOaNBZspLtZQDG5l3DxORnp6ul28eLHTZYhIBfIOFdHrb3PYlp13xPrD++5LcBljMqy16eVtc+UZvoiEhtgoL/NGXci6xy93uhSpAgW+iPgtyuvh+wcvLltuft8MTaDiQgp8EakR9eKjSawVVbacdv8njJ65ysGK5GgKfBGpMZ//+bwjlsfP3cje3AKHqpGjKfBFpMY0TIhl4+jeR6zr/OjnmkTFJRT4IlKjPB7DpjF96NEqqWzdKaNmMmPZdgerElDgi0iATB7SlY5N//uA1m1Tl/DOoi3k5uupXKco8EUkILwew0e3nUP3lg3K1t3z3jJOf3gW+/MOOVhZ5FLgi0hATR1+1jHr2j/ymbptOkCBLyIBN6hb6jHr0u7/hKwD6sETTK4MfI2lIxJeHujTlqnDu/HQFacdsb7TXz/np925DlUVeTSWjogETW5+Iac/PKvcbR/dds4RN3nlxGgsHRFxhfgYH+sev5z/3H3BMdv6jvtW/fUDTIEvIkEV5fXQrEE8X/3v+cdsO2XUTLb8ekBdNwNEgS8ijmiRXJuNo3sfc0O3x1OzOf3hWXy9bpfO+GuYAl9EHOPxGEb3a8/qRy87ZtuNExfy5KdrWLzpVwcqC08KfBFxXGyUl15tGh6z/qX/bGDAS/N57bvNDlQVfhT4IuIKL/6+C6P7tS9324MfrmDeht1Brij8qFumiLjK2h37mb16J098srrc7UsfvoSEGB8ejwlyZaGhsm6ZvmAXIyJSmVMbJZS8TkpgyKRFx2zv+H+fAZo390Toko6IuFLP1g354s/Hdt38zY0TF2gQtmpS4IuIa6U1rM3qRy8jqXb0Mdu+Xreb9o98RubeAw5UFpoU+CLiarFRXhY/cDEf3Nq93O3nPjmbJ2auorjYvfcj3UKBLyIhoXNqPZY+dEm53TdfnruRFn+ZybLMLAoKNexyRdRLR0RCzoqt2Vzx3DcVbj+7RQPeHHHsOPyRQIOniUhYadckkWkjz6Zzavmja87fuIf5G/bw6YrtZB/Ujd3f6AxfREJWYVExafd/Uuk+p59chxl/6hGkipynM3wRCUs+r+e4/fFXbtvHi3M2sDdXs2u58gzfGHMlcGVaWtrwdevWOV2OiLhc5t4DbM/OY+mWLB6bsarSfTeO7h3WT+lWdobvysD/jS7piEh1Tf72Jx6Z/mOl+1zRoTH3XtaGpvXjglRV8CjwRSSiZB84RPcxX5JbUFTpfm1OSuDTO88LUlXBoWv4IhJREuOimHN3T85oVo8G8cc+pfub1b/sZ9bKX1i/c38Qq3OOzvBFJOzNWLad26YuOe5+kwafSc9yHuwKJTrDF5GI1qdDYzaN6cMLN3SpdL8hkxdx0ysL2bU/P0iVBZfO8EUkoqzdsZ9L/jG3Svv2ad+Yp6/pQFx06IwkrzN8EZFSpzZKYNOYPqTUq3XcfWcs385pD81i857cIFQWeAp8EYlI39zbi01j+nB15ybH3ff8p+cwbvZ6cvMLKQrhUTl1SUdEIlphUTF3T1vGB99vrfJnHu/Xjr6dmlA7xn2XenRJR0SkAj6vh39c16lan7n/gxW0e3gWCzbu4VBR6AzHrDN8ERFgf94htmYdJC7Kx3lPz67WZ1c/ehmxUd4AVVY9etJWRKSamt83o9qfufWClvQ/I4UmdWs5dgBQ4IuIVFPm3gP8sCWLaK+HEa9lVOuzibWiWPrwJQGqrHIKfBERPw2dvIivVu+s1mf+c/cF7NyfT53YKFqflBCgyo6kwBcR8dOhomIW/vQrN/xrwQl9/qkBHbg2vWkNV3Us9dIREfFTlNfDOWlJx51wpSL3TFtG8/tmsDvHuWEb3NeJVETE5d4acRa1orzk5BdW+4w//bEvyt7PvbsnDWpHEx+k/vy6pCMi4qf8wiJaP/DpCX/+/FOTmXhzOnsPHCI5IcavWnQNX0QkCAqLinlhzgae+XxttT+bUq8WmXsPsvyRS0iIjTrhGnQNX0QkCHxeD3+6sBWz7jyP2KjqxWvm3oMAXP7s16zdEZgJWRT4IiI1rPVJCSx/5FLuuuTUan82c+/BKg/fXF0KfBGRAIjyeri9Vys2jenDk/3bO10OoMAXEQm4685MZdOYPnx42zlV/kxBYc0PyqbAFxEJkk5N67L+8ctp3iDuuPsWB6BDjfrhi4gEkc/rYc7dPQFYuS2bPmO/KX8/j6nx7w7aGb4x5ipjzARjzEfGGGdGFRIRcZHTT07kzotalbvN5635eK7STzTGvGKM2WmMWXHU+suMMWuMMeuNMfdV9jOstR9aa4cDg4HrTrhiEZEwcudFp7JpTB82jO7NtekpAHRsWjcg31WlB6+MMecBOcAUa2270nVeYC1wMZAJLAIGAl7giaN+xFBr7c7Sz/0deMNau+R436sHr0REqqeyB6+qdA3fWjvXGNP8qNVdgfXW2o2lX/IW0Nda+wRwRTlFGGAM8EllYW+MGQGMAEhNTa1KeSIiUgX+XCRqAmw5bDmzdF1F7gAuAgYYY0ZWtJO1dry1Nt1am56cnOxHeSIicjh/eumUdwu5wutD1tqxwFg/vk9ERPzgzxl+JnD4aP4pwDb/yhERkUDxJ/AXAa2MMacYY6KB64GPa6YsERGpaVXtlvkmMB9obYzJNMYMs9YWArcDs4BVwDvW2pU1UZQx5kpjzPjs7Oya+HEiIoLGwxcRCSsaD19ERNx9hm+M2QVsBhKBw6/vHL5c0fskYLefJRz9vSeyX3nbqrLueG10c/vKWx9pv8OK2hsu7Tt6Wf+PnriabmMza235fdqtta5/AeMrWq7k/eKa/t4T2a+8bVVZd7w2url9x2tPJPwOK2pvuLSvKr9DN7fveO2pSvtCoY1Hv0Llks70SpYreh+I7z2R/crbVpV1wWhjoNpX3vpI+x1W1N5wad/Ry/p/9MQFso1HcPUlHX8YYxbbCm5chINwbx+EfxvVvtAXam0MlTP8EzHe6QICLNzbB+HfRrUv9IVUG8P2DF9ERI4Uzmf4IiJyGAW+iEiEUOCLiESIiAh8Y0y8MebV0jl1b3C6nkAwxrQwxkw0xkxzupZAiIQ5kY0xbY0xLxljphlj/uh0PYFQ+m8xwxhzzCRJ4cAYc4Ex5uvS3+MFTtdztJAN/GrOs3s1MM2WzKn7u6AXe4Kq00Zr7UZr7TBnKj0x1WxfSM6JXM02rrLWjgSuBUKiq98JzHd9L/BOcKv0TzXbaCmZDjaWkiHk3cXfp8ScegHnAV2AFYet8wIbgBZANLAUOA0YBXQq3Weq07UHoo2HbZ/mdN0Bbt/fgS5O1x6oNlJyQjIPGOR07TXdPkpmvLuekoP2FU7XHqA2ekq3N6Jk7m7H6z/8FbJn+NbaucCvR60um2fXWlsAvAX0peRIm1K6T8i0uZptDDnVaZ8p8STHmRPZbar7O7TWfmyt7Q6ExKXHaravJ3AWMAgYbowJiX+L1Wmjtba4dPteICaIZVaJP1MculF58+x2o2RqxeeNMX2o+ceig63cNhpjGgCPA52NMaNsyWTyoaii3+FvcyInGmPSrLUvOVFcDanod3gBJZcfY4CZDtRVU8ptn7X2dgBjzGBg92HhGIoq+h1eDVwK1AWed6KwyoRb4Jc7z661NhcYEuxiAqSiNu4BKpwcPoRU1L5wmhO5ojbOAeYEt5SAqHS+a2vt5OCVEjAV/Q7fB94PdjFVFRJ/UlVDJMyzG+5tDPf2Qfi3MdzbByHaxnAL/EiYZzfc2xju7YPwb2O4tw9CtY1O3zX24875m8B24BAlR9thpet7A2spuYN+v9N1qo2R275IaGO4ty/c2qjB00REIkS4XdIREZEKKPBFRCKEAl9EJEIo8EVEIoQCX0QkQijwRUQihAJfRCRCKPBFRCKEAl9EJEL8f+mIx/m4EoKgAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from scipy.ndimage.filters import gaussian_filter1d\n",
    "from scipy.optimize import curve_fit\n",
    "from scipy.signal import savgol_filter \n",
    "import tikzplotlib\n",
    "\n",
    "\n",
    "qqq = loss\n",
    "# ysmoothed = gaussian_filter1d(qqq, sigma=0.1)\n",
    "\n",
    "\n",
    "# plt.figure()\n",
    "# plt.loglog(loss)\n",
    "\n",
    "aaa = savgol_filter(qqq,101,1)\n",
    "\n",
    "\n",
    "x = np.arange(1,qqq.shape[0]+1)\n",
    "print(x[0:10])\n",
    "# plt.loglog(x,aaa)\n",
    "\n",
    "\n",
    "data = np.concatenate([x.reshape(-1,1), aaa.reshape(-1,1)], -1)\n",
    "plt.loglog(data[::10,0],data[::10,1]/2)\n",
    "\n",
    "print(data[::100,0].shape)\n",
    "\n",
    "\n",
    "\n",
    "np.savetxt('mu_mimo_loss.txt', data[::100,:])\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "frohmjvYBEPz"
   },
   "outputs": [],
   "source": [
    "torch.cuda.empty_cache()\n",
    "SER =np.array([])\n",
    "num_iter=1\n",
    "with torch.no_grad():\n",
    "    for snr in np.arange(0, 40,1):\n",
    "        torch.cuda.empty_cache()\n",
    "        \n",
    "        batch = M * 16*10000\n",
    "        \n",
    "        ch_real = ((torch.randn((batch, 2,2))/np.sqrt(2))).to(device)\n",
    "        ch_imag = ((torch.randn((batch, 2,2))/np.sqrt(2))).to(device)\n",
    "\n",
    "        total_corr = 0\n",
    "        for i in range(num_iter):\n",
    "            test_messages = np.arange(M)\n",
    "            test_messages = np.tile(test_messages, int(batch/M))\n",
    "\n",
    "            test_mess1 = np.random.permutation(test_messages)\n",
    "            test_mess2 = np.random.permutation(test_messages)\n",
    "\n",
    "\n",
    "            csi = torch.cat([ch_real.view(-1,4), ch_imag.view(-1,4)], -1).to(device)\n",
    "            csi1 = torch.cat([csi[:,0:2], csi[:,4:6]], -1).to(device)\n",
    "            csi2 = torch.cat([csi[:,2:4], csi[:,6:8]], -1).to(device)\n",
    "\n",
    "\n",
    "            test_data = 4*test_mess1 + test_mess2\n",
    "            test_data_set= F.one_hot(torch.from_numpy(test_data)).float().to(device)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "            transmitted =encoder(test_data_set, csi)\n",
    "\n",
    "            transmitted_real = transmitted[:, np.arange(0,2)]\n",
    "            transmitted_imag = transmitted[:, np.arange(2,4)]\n",
    "\n",
    "            tx_real = transmitted_real.view(-1, 2,1)\n",
    "            tx_imag = transmitted_imag.view(-1, 2,1)\n",
    "\n",
    "            rx_real = torch.bmm(ch_real, tx_real) - torch.bmm(ch_imag, tx_imag)\n",
    "            rx_imag = torch.bmm(ch_real, tx_imag) + torch.bmm(ch_imag, tx_real)\n",
    "\n",
    "            rx1 = torch.cat([rx_real[:,0,:], rx_imag[:,0,:]], axis=-1)\n",
    "            rx2 = torch.cat([rx_real[:,1,:], rx_imag[:,1,:]], axis=-1)\n",
    "\n",
    "            sigma = np.sqrt(0.5/np.power(10, snr/10))\n",
    "            rx1 = rx1 + (torch.randn(rx1.shape)*sigma).to(device)\n",
    "            rx2 = rx2 + (torch.randn(rx2.shape)*sigma).to(device)\n",
    "\n",
    "            y_pred1 = decoder1(rx1, csi1)\n",
    "            y_pred2 = decoder2(rx2, csi2)\n",
    "\n",
    "\n",
    "            classification1 = torch.argmax(y_pred1, axis=-1).to('cpu').detach().numpy()\n",
    "            classification2 = torch.argmax(y_pred2, axis=-1).to('cpu').detach().numpy()\n",
    "\n",
    "            correct1 = np.equal(classification1 , test_mess1)\n",
    "            correct2 = np.equal(classification2 , test_mess2)\n",
    "            correct = sum(correct1) + sum(correct2)\n",
    "          \n",
    "            total_corr = total_corr + correct\n",
    "        ser =1 - total_corr / (batch*2*num_iter)\n",
    "\n",
    "        SER = np.append(SER, ser)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "s8BtpL0ZBEP1"
   },
   "outputs": [],
   "source": [
    "ser_theory = io.loadmat('baseline/zero_forcing_SER.mat')\n",
    "base_line = ser_theory['SER'] \n",
    "\n",
    "np.savez('CSIT-partial-CSIR-SER.npz', SER = SER)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 279
    },
    "colab_type": "code",
    "id": "LmgYf3kUBEP3",
    "outputId": "56e52534-b153-4d4e-dd34-7bfd9bae7c03"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x648 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(16,9))\n",
    "base=np.array([0.391,0.317, 0.24,0.1744,0.1280, 0.0788,0.056, 0.035, 0.0223, 0.0152, 0.0091])\n",
    "p1,p2 = plt.semilogy(np.arange(0, 40,1), SER, np.arange(0,21,2), base)\n",
    "plt.xlabel('SNR')\n",
    "plt.ylabel('SER')\n",
    "plt.legend([p1,p2],['MU-MIMO','Zero-forcing-transmitter'])\n",
    "plt.grid()\n",
    "\n",
    "import tikzplotlib as tikz\n",
    "tikz.save('ser_vd.tex')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4.08585156e-01 3.68770313e-01 3.26864844e-01 2.85632813e-01\n",
      " 2.42182031e-01 2.00000000e-01 1.60190625e-01 1.23572656e-01\n",
      " 9.23648437e-02 6.57578125e-02 4.42023437e-02 2.87507812e-02\n",
      " 1.75812500e-02 1.03070312e-02 6.00312500e-03 3.50078125e-03\n",
      " 2.12500000e-03 1.38125000e-03 1.02578125e-03 8.21093750e-04\n",
      " 6.43750000e-04 5.65625000e-04 5.05468750e-04 4.97656250e-04\n",
      " 4.40625000e-04 4.30468750e-04 4.08593750e-04 3.98437500e-04\n",
      " 3.56250000e-04 3.81250000e-04 3.85156250e-04 3.71875000e-04\n",
      " 3.32031250e-04 3.56250000e-04 3.85156250e-04 3.62500000e-04\n",
      " 3.41406250e-04 3.34375000e-04 3.39062500e-04 3.22656250e-04]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7fea04d0e3d0>]"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "print(SER)\n",
    "\n",
    "np.savez('mu-mimo-ser.npz',ser=SER)\n",
    "SER1 = np.load('mu-mimo-ser.npz')['ser']\n",
    "plt.semilogy(SER1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# torch.save({\n",
    "#             'encoder': encoder.state_dict(),\n",
    "#             'decoder1': decoder1.state_dict(),\n",
    "#             'decoder2': decoder2.state_dict(), \n",
    "#             }, 'Autoencoder-MU-MIMO')\n",
    "\n",
    "# encoder = Encoder().to(device)\n",
    "# decoder = Decoder().to(device)\n",
    "# tx_opt = Adam(encoder.parameters(), lr = 0.001)\n",
    "# rx_opt = Adam(decoder.parameters(), lr = 0.008)\n",
    "\n",
    "# checkpoint = torch.load('Autoencoder-MU-MIMO')\n",
    "# encoder.load_state_dict(checkpoint['encoder'])\n",
    "# decoder.load_state_dict(checkpoint['decoder1'])\n",
    "# decoder.load_state_dict(checkpoint['decoder2'])\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "name": "MU-MIMO_Pytorch_CSIT.ipynb",
   "provenance": []
  },
  "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.7.7"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": true,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}