AE_closed_loop_MIMO.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "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.4"
    },
    "colab": {
      "name": " SVD_AlternativeLearning_copy3.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "machine_shape": "hm"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "gk_D0EK3xW1c",
        "colab_type": "code",
        "outputId": "f21587ac-d2a2-4ac7-ec65-e6cbab7c5957",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "import warnings\n",
        "warnings.filterwarnings('ignore')\n",
        "\n",
        "import numpy as np\n",
        "import tensorflow as tf\n",
        "import keras\n",
        "from keras.layers import Input, Dense, GaussianNoise,Lambda,Dropout, Concatenate, Add\n",
        "from keras  import layers\n",
        "from keras.models import Model\n",
        "from keras import regularizers \n",
        "from keras.layers.normalization import BatchNormalization\n",
        "from keras.optimizers import Adam,SGD\n",
        "from keras import backend as K\n",
        "from keras.utils import to_categorical\n",
        "import matplotlib.pyplot as plt\n",
        "import pandas as pd\n",
        "\n",
        "import scipy.io as io"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Using TensorFlow backend.\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "M_xKwSEhxoE0",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# from tensorflow.python.client import device_lib\n",
        "# from keras import backend as K\n",
        "# K.tensorflow_backend._get_available_gpus()\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "om_dpmqWxW1p",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "M=16\n",
        "\n",
        "Tx=2\n",
        "Rx=2\n",
        "\n",
        "Tx_NN=256\n",
        "Rx_NN=2048\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rnG52zUvJi9L",
        "colab_type": "code",
        "outputId": "fa42e108-8ef2-44e5-c489-a7ad6459b08c",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "np.arange(0,20,3)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 0,  3,  6,  9, 12, 15, 18])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qBs--jbFxW2L",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Build encoder\n",
        "\n",
        "M_input=Input(shape=(M,), name='M')\n",
        "V_input = Input(shape=(8,), name='V')\n",
        "Ch_input =Input(shape=(8,), name='CH')\n",
        "Sigma = Input(shape=(1,), name='SIGMA')\n",
        "U_input = Input(shape=(8,), name='U')\n",
        "\n",
        "Tx_input = keras.layers.Concatenate(axis=-1, name='sig2Tx')([M_input, V_input])\n",
        "\n",
        "layer = Dense(units =Tx_NN, activation='relu')(Tx_input)\n",
        "layer = Dense(units =Tx_NN, activation='relu')(layer)\n",
        "\n",
        "Tx_output = Dense(units =2*Tx, activation='linear')(layer)\n",
        "Tx_output =  Lambda(lambda x: x / K.sqrt(2*K.mean(K.square(x))), name='Power_Constrain')(Tx_output)\n",
        "\n",
        "to_mimo = keras.layers.Concatenate(axis=-1, name='sig2Channel')([Tx_output, Ch_input, Sigma])\n",
        "\n",
        "\n",
        "def mimo_channel(in_know):    \n",
        "    sig = in_know[:, 0:4]\n",
        "    ch = in_know[:, 4:12]\n",
        "    sigma = in_know[0, 12]\n",
        "    \n",
        "    sig_real = tf.reshape(sig[:, 0:2], (-1, 2,1))\n",
        "    sig_imag = tf.reshape(sig[:, 2:4], (-1, 2,1))\n",
        "    \n",
        "    ch_real = tf.reshape(ch[:, 0:4], (-1,2,2))\n",
        "    ch_imag = tf.reshape(ch[:, 4:8], (-1,2,2))\n",
        "    \n",
        "    rx_real = tf.matmul(ch_real, sig_real) - tf.matmul(ch_imag, sig_imag) \n",
        "    rx_imag = tf.matmul(ch_real, sig_imag) + tf.matmul(ch_imag, sig_real)\n",
        "    rx = tf.reshape(tf.concat([rx_real, rx_imag], axis=1), (-1, 4))\n",
        "    rx = rx + tf.random.normal(mean=0, stddev=sigma, shape=tf.shape(rx))\n",
        "    return rx\n",
        "Rx= Lambda(mimo_channel, name='Channel_Layer')(to_mimo)\n",
        "\n",
        "\n",
        "# Build Decoder\n",
        "\n",
        "# Rx_input = keras.layers.Concatenate(axis=-1, name='sig2Rx')([Rx, U_input])\n",
        "# layer = Dense(units=Rx_NN, activation='relu')(Rx_input)\n",
        "layer = Dense(units=Rx_NN, activation='relu')(Rx)\n",
        "layer = Dense(units=Rx_NN, activation='relu')(layer)\n",
        "layer = Dense(units=Rx_NN, activation='relu')(layer)\n",
        "Rx_output = Dense(units=M, activation='softmax')(layer)\n",
        "\n",
        "auto_encoder = Model(inputs=[M_input, Ch_input, U_input,Sigma, V_input], outputs= Rx_output)\n",
        "\n",
        "opt = Adam(lr=0.001)\n",
        "auto_encoder.compile(optimizer=opt, loss='categorical_crossentropy')\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eiik1gJ37rHi",
        "colab_type": "code",
        "outputId": "9df0bf5f-a3ed-4f42-cc05-71f6a0bc3750",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 537
        }
      },
      "source": [
        "M_input3=Input(shape=(M,), name='M')\n",
        "Ch_input3 =Input(shape=(8,), name='CH')\n",
        "Sigma3 = Input(shape=(1,), name='SIGMA')\n",
        "\n",
        "Tx_input3 = keras.layers.Concatenate(axis=-1, name='sig2Tx')([M_input3, Ch_input3])\n",
        "\n",
        "layer3 = Dense(units =Tx_NN, activation='relu')(Tx_input3)\n",
        "layer3 = Dense(units =Tx_NN, activation='relu')(layer3)\n",
        "\n",
        "Tx_output3 = Dense(units =2*Tx, activation='linear')(layer3)\n",
        "Tx_output3 =  Lambda(lambda x: x / K.sqrt(2*K.mean(K.square(x))), name='Power_Constrain')(Tx_output3)\n",
        "\n",
        "to_mimo3 = keras.layers.Concatenate(axis=-1, name='sig2Channel')([Tx_output3, Ch_input3, Sigma3])\n",
        "\n",
        "\n",
        "Rx3= Lambda(mimo_channel, name='Channel_Layer')(to_mimo3)\n",
        "\n",
        "\n",
        "# Build Decoder\n",
        "\n",
        "Rx_input3 = keras.layers.Concatenate(axis=-1, name='sig2Rx')([Rx3, Ch_input3])\n",
        "Rx_input3 = BatchNormalization()(Rx_input3)\n",
        "# Rx_input3 = BatchNormalization()(Rx3)\n",
        "layer3 = Dense(units=Rx_NN, activation='relu')(Rx_input3)\n",
        "layer3 = BatchNormalization()(layer3)\n",
        "layer3 = Dense(units=Rx_NN, activation='relu')(layer3)\n",
        "layer3 = BatchNormalization()(layer3)\n",
        "layer3 = Dense(units=Rx_NN, activation='relu')(layer3)\n",
        "layer3 = BatchNormalization()(layer3)\n",
        "layer3 = Dense(units=Rx_NN, activation='relu')(layer3)\n",
        "layer3 = BatchNormalization()(layer3)\n",
        "Rx_output3 = Dense(units=M, activation='softmax')(layer3)\n",
        "\n",
        "auto_encoder3 = Model(inputs=[M_input3, Ch_input3, Sigma3], outputs= Rx_output3)\n",
        "\n",
        "opt3 = Adam(lr=0.001)\n",
        "#configures the model for training\n",
        "auto_encoder3.compile(optimizer=opt3, loss='categorical_crossentropy')\n",
        "\n",
        "\n",
        "batch=6400 * 400\n",
        "\n",
        "train_messages = np.arange(M)\n",
        "train_messages = np.tile(train_messages, batch)\n",
        "train_labels = to_categorical(train_messages)\n",
        "\n",
        "channel = (np.random.normal(size=[batch * 16, 2, 2]) + 1j*np.random.normal(size=[batch * 16, 2, 2]))/np.sqrt(2)\n",
        "ch = np.reshape(channel, (-1, 4))\n",
        "ch = np.concatenate([ch.real, ch.imag], axis=-1)\n",
        "\n",
        "T_SNR = 15\n",
        "snr_linear = np.power(10, T_SNR/10)\n",
        "sigma_train = np.sqrt(0.5/snr_linear)\n",
        "sigma_train = sigma_train * np.ones((ch.shape[0],1))\n",
        "\n",
        "history = auto_encoder3.fit(x=[train_labels, ch,sigma_train], y=train_labels, batch_size=2048, verbose=1, epochs=15)\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch 1/15\n",
            "40960000/40960000 [==============================] - 751s 18us/step - loss: 0.0152\n",
            "Epoch 2/15\n",
            "40960000/40960000 [==============================] - 749s 18us/step - loss: 0.0033\n",
            "Epoch 3/15\n",
            "40960000/40960000 [==============================] - 751s 18us/step - loss: 0.0026\n",
            "Epoch 4/15\n",
            "40960000/40960000 [==============================] - 750s 18us/step - loss: 0.0022\n",
            "Epoch 5/15\n",
            "40960000/40960000 [==============================] - 752s 18us/step - loss: 0.0021\n",
            "Epoch 6/15\n",
            "40960000/40960000 [==============================] - 750s 18us/step - loss: 0.0019\n",
            "Epoch 7/15\n",
            "40960000/40960000 [==============================] - 745s 18us/step - loss: 0.0018\n",
            "Epoch 8/15\n",
            "40960000/40960000 [==============================] - 743s 18us/step - loss: 0.0018\n",
            "Epoch 9/15\n",
            "40960000/40960000 [==============================] - 739s 18us/step - loss: 0.0017\n",
            "Epoch 10/15\n",
            "40960000/40960000 [==============================] - 739s 18us/step - loss: 0.0017\n",
            "Epoch 11/15\n",
            "40960000/40960000 [==============================] - 740s 18us/step - loss: 0.0016\n",
            "Epoch 12/15\n",
            "40960000/40960000 [==============================] - 742s 18us/step - loss: 0.0016\n",
            "Epoch 13/15\n",
            "40960000/40960000 [==============================] - 746s 18us/step - loss: 0.0016\n",
            "Epoch 14/15\n",
            "40960000/40960000 [==============================] - 746s 18us/step - loss: 0.0015\n",
            "Epoch 15/15\n",
            "40960000/40960000 [==============================] - 744s 18us/step - loss: 0.0015\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "e_h3sfqdZQgq",
        "colab_type": "code",
        "outputId": "009ed7a1-67f9-49b4-86d1-57c27857604c",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        }
      },
      "source": [
        "plt.semilogy(history.history['loss'], label='MAE (testing data)')\n",
        "\n",
        "plt.title('MAE for Chennai Reservoir Levels')\n",
        "plt.ylabel('MAE value')\n",
        "plt.xlabel('No. epoch')\n",
        "plt.legend(loc=\"upper left\")\n",
        "plt.show()"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "i3RwsYTE0vYu",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "auto_encoder3.save('path_to_my_model.h5')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "u1knO1cA1Do7",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# new_model = keras.models.load_model('path_to_my_model.h5')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "th1dy_ovi00D",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# SNR_array = np.arange(0, 22)\n",
        "# SER3 = []\n",
        "# for snr in SNR_array:\n",
        "#     snr_linear = np.power(10, snr/10)\n",
        "#     sigma_train = np.sqrt(0.5/snr_linear)\n",
        "\n",
        "#     batch=6400\n",
        "#     train_messages = np.arange(M)\n",
        "#     train_messages = np.tile(train_messages, batch)\n",
        "#     train_labels = to_categorical(train_messages)\n",
        "\n",
        "#     channel = (np.random.normal(size=[batch * 16, 2, 2]) + 1j*np.random.normal(size=[batch * 16, 2, 2]))/np.sqrt(2)\n",
        "#     ch = np.reshape(channel, (-1, 4))\n",
        "#     ch = np.concatenate([ch.real, ch.imag], axis=-1)\n",
        "\n",
        "    \n",
        "#     sigma_train = sigma_train * np.ones((ch.shape[0],1))\n",
        "\n",
        "#     prob_distribution = auto_encoder3.predict(x=[train_labels, ch, sigma_train], batch_size=1024*10)\n",
        "   \n",
        "#     classification = np.argmax(prob_distribution, axis=1)\n",
        "#     correct = np.equal(classification , train_messages)\n",
        "#     ser = 1- np.mean(correct)\n",
        "#     SER3 = np.append(SER3, ser)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WInqVl_qkLIy",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "SNR_array = np.arange(0, 25,2)\n",
        "SER3 = []\n",
        "for snr in SNR_array:\n",
        "    ser_flag = 0\n",
        "    for temp in np.arange(20):\n",
        "        ser = 0\n",
        "        snr_linear = np.power(10, snr/10)\n",
        "        sigma_train = np.sqrt(0.5/snr_linear)\n",
        "        frames = 15\n",
        "        batch=64000\n",
        "        train_messages = np.arange(M)\n",
        "        train_messages = np.tile(train_messages, batch)\n",
        "        train_labels = to_categorical(train_messages)\n",
        "\n",
        "        channel = (np.random.normal(size=[frames * 16, 2, 2]) + 1j*np.random.normal(size=[frames * 16, 2, 2]))/np.sqrt(2)\n",
        "        channel = np.tile(channel, (batch,1,1))\n",
        "        ch = np.reshape(channel, (-1, 4))\n",
        "        ch = np.concatenate([ch.real, ch.imag], axis=-1)\n",
        "\n",
        "        \n",
        "        sigma_train = sigma_train * np.ones((ch.shape[0],1))\n",
        "\n",
        "        prob_distribution = auto_encoder3.predict(x=[train_labels, ch, sigma_train], batch_size=1024*10)\n",
        "      \n",
        "        classification = np.argmax(prob_distribution, axis=1)\n",
        "        correct = np.equal(classification , train_messages)\n",
        "        ser = 1- np.mean(correct)\n",
        "        ser_flag = ser_flag + ser\n",
        "        \n",
        "    SER3 = np.append(SER3, ser_flag/20)\n",
        "    # print(SER3)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EKiGeFjK5_Jn",
        "colab_type": "code",
        "outputId": "164a96b9-c032-4167-d04f-5d51a82a85d0",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 354
        }
      },
      "source": [
        "print(SER3)\n",
        "plt.figure()\n",
        "SNR = np.arange(0, 22)\n",
        "\n",
        "base_line = np.array([0.51663, 0.47059, 0.42939 ,0.3782,  0.34221, 0.30084 ,0.26423, 0.22573 ,0.1949,\n",
        " 0.16623, 0.14124, 0.1161 , 0.09486 ,0.07995, 0.06518 ,0.05308, 0.04256, 0.03233,\n",
        " 0.02639 ,0.02132, 0.0185 , 0.01276])\n",
        "csitr, base = plt.semilogy(SNR_array, SER3, SNR, base_line)\n",
        "plt.grid(True)\n",
        "plt.legend([ csitr, base], ['simulation_with_csitr', 'Base_line'])"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[6.29755420e-01 5.19213770e-01 3.82001270e-01 2.36681250e-01\n",
            " 1.28499121e-01 4.73665039e-02 1.48571777e-02 3.05795898e-03\n",
            " 2.15478516e-04 1.93847656e-05 4.88281250e-08 0.00000000e+00\n",
            " 0.00000000e+00]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.legend.Legend at 0x7fcb260e16d8>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 12
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pygnGD6jtohB",
        "colab_type": "code",
        "outputId": "a5de13af-e635-4bed-cb6d-7ea7a9edde12",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 551
        }
      },
      "source": [
        "from google.colab import files\n",
        "plt.figure(figsize=(12,9))\n",
        "SNR = np.arange(0, 22)\n",
        "\n",
        "base_line = np.array([0.51663, 0.47059, 0.42939 ,0.3782,  0.34221, 0.30084 ,0.26423, 0.22573 ,0.1949,\n",
        " 0.16623, 0.14124, 0.1161 , 0.09486 ,0.07995, 0.06518 ,0.05308, 0.04256, 0.03233,\n",
        " 0.02639 ,0.02132, 0.0185 , 0.01276])\n",
        "\n",
        "SNR2 = np.array([0 ,  0.457574905606751,   0.969100130080564 ,  1.549019599857432,   2.218487496163564,\n",
        "   3.010299956639812,   3.979400086720376,   5.228787452803376  , 6.989700043360188  ,10.000000000000000,\n",
        "  10.969100130080564 , 12.218487496163563 , 13.979400086720377,  15.228787452803376 , 16.989700043360187,\n",
        "  20.000000000000000])\n",
        "\n",
        "base_line2 = np.array([4.037860e-01, 3.083340e-01, 2.132100e-01, 1.382575e-01, 7.183750e-02,\n",
        "  3.136500e-02, 1.133280e-02 ,3.339900e-03 ,7.619000e-04 ,1.655000e-04,\n",
        "  2.330000e-05 ,3.010000e-06, 3.700000e-07, 6.000000e-08])\n",
        "\n",
        "csitr, base, base2 = plt.semilogy( SNR_array, SER3, SNR, base_line,np.arange(0,27,2), base_line2)\n",
        "plt.grid(True)\n",
        "plt.legend([ csitr, base, base2], ['ser_with_csitr', 'QPSK','Bits-and-power-allocation'])\n",
        "plt.xlabel('SNR')\n",
        "plt.ylabel('SER')\n",
        "plt.savefig('svd_ser.pdf')\n",
        "# files.download('svd_ser.pdf') \n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 864x648 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cLmUtOVPAgA5",
        "colab_type": "code",
        "outputId": "06bf311f-930d-47be-b0b1-a9d23626dc7e",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 131
        }
      },
      "source": [
        "auth.authenticate_user()\n",
        "gauth = GoogleAuth()\n",
        "gauth.credentials = GoogleCredentials.get_application_default()                       drive = GoogleDrive(gauth)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "error",
          "ename": "SyntaxError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-14-eb878f30e756>\"\u001b[0;36m, line \u001b[0;32m3\u001b[0m\n\u001b[0;31m    gauth.credentials = GoogleCredentials.get_application_default()                       drive = GoogleDrive(gauth)\u001b[0m\n\u001b[0m                                                                                              ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Q_25dHOyJNL_",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "auto_encoder3.save('model.h5')\n",
        "model_file = drive.CreateFile({'title' : 'model.h5'})                       model_file.SetContentFile('model.h5')                       model_file.Upload()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ICtOMizFAroT",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NgqfYCCq2tHC",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}