04_beam_selection_analog_mimo.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"https://colab.research.google.com/github/aldebaro/ai6g/blob/main/04_beam_selection_analog_mimo.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc42cc4f",
   "metadata": {},
   "source": [
    "**Inteligência Artificial e Aprendizado de Máquina Aplicados a Redes 5G e 6G**.\n",
    "*Aldebaro Klautau* (UFPA). Minicurso 5 do SBrT - 25 de setembro de 2022."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Clone the repository if running in Colab and install all the dependencies\n",
    "if 'google.colab' in str(get_ipython()):\n",
    "    from google.colab import drive\n",
    "    drive.mount('/content/drive/')\n",
    "    import sys\n",
    "    import os\n",
    "    try:\n",
    "      !git clone https://github.com/aldebaro/ai6g.git\n",
    "    except:\n",
    "      print(\"ai6g is already in the contents\")\n",
    "    %cd ai6g\n",
    "    !ln -s /content/drive/MyDrive/ai6g_files/files_04_beam/* ./files_04_beam\n",
    "    !pip install -r requirements.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "import matplotlib.pyplot as plt\n",
    "from tensorflow.keras.utils import to_categorical\n",
    "from tensorflow.keras import metrics\n",
    "from tensorflow.keras.models import Model\n",
    "from tensorflow.keras.layers import Conv2D, \\\n",
    "    Flatten, MaxPooling2D, Dense, Input, Dropout, ReLU\n",
    "from tensorflow.keras.losses import categorical_crossentropy\n",
    "from tensorflow.keras.optimizers import Adam\n",
    "from keras.metrics import top_k_categorical_accuracy\n",
    "from sklearn.model_selection import train_test_split\n",
    "from scipy.special import softmax\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ModelHandler:\n",
    "    def createArchitecture(self,num_classes,input_shape):\n",
    "        '''\n",
    "        Returns a NN model.\n",
    "        numClasses: a scalar which denotes the number of classes to be predicted\n",
    "        input_shape: a tuple with the dimensions of the input of the model\n",
    "        '''\n",
    "        dropProb=0.3\n",
    "        input_lid = Input(shape = input_shape)\n",
    "                    \n",
    "        layer = Conv2D(10,kernel_size=(13,13),\n",
    "                            activation='relu',\n",
    "                            padding=\"SAME\",\n",
    "                            input_shape=input_shape)(input_lid)\n",
    "        layer = Conv2D(10, (11, 11), padding=\"SAME\", activation='relu')(layer) #original value=30 filters\n",
    "        layer = Conv2D(10, (9, 9), padding=\"SAME\", activation='relu')(layer) #original value=25 filters\n",
    "        layer = MaxPooling2D(pool_size=(1, 4))(layer)\n",
    "        layer = Dropout(dropProb)(layer)\n",
    "        layer = Conv2D(10, (7, 7), padding=\"SAME\", activation='relu')(layer) #original value=20 filters\n",
    "        layer = MaxPooling2D(pool_size=(2, 4))(layer)\n",
    "        layer = Conv2D(10, (5, 5), padding=\"SAME\", activation='relu')(layer) #original value=15 filters\n",
    "        layer = Dropout(dropProb)(layer)\n",
    "        layer = Conv2D(10, (3, 3), padding=\"SAME\", activation='relu')(layer)\n",
    "        layer = MaxPooling2D(pool_size=(2, 2))(layer)\n",
    "        #layer = Conv2D(1, (1, 1), padding=\"SAME\", activation='relu')(layer)\n",
    "        layer = Flatten()(layer)\n",
    "        out = Dense(num_classes,activation='softmax')(layer)\n",
    "        \n",
    "        architecture = Model(inputs = input_lid, outputs = out)\n",
    "        \n",
    "        return architecture\n",
    "\n",
    "    def build_resblock(self, input_shape, nChannels, maxpooling=True):\n",
    "        input = Input(shape=input_shape)\n",
    "        x = Conv2D(nChannels, (3, 3), padding=\"same\", activation=\"relu\")(input)\n",
    "        x = Conv2D(nChannels, (3, 3), padding=\"same\", activation=None)(x)\n",
    "        x = input + x\n",
    "        x = ReLU()(x)\n",
    "        if maxpooling:\n",
    "            x = MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding=\"valid\")(x)\n",
    "        return Model(inputs=input, outputs=x)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "###############################################################################\n",
    "# Support functions\n",
    "###############################################################################\n",
    "\n",
    "# For description about top-k, including the explanation on how they treat ties (which can be misleading\n",
    "# if your classifier is outputting a lot of ties (e.g. all 0's will lead to high top-k)\n",
    "# https://www.tensorflow.org/api_docs/python/tf/nn/in_top_k\n",
    "\n",
    "\n",
    "def top_10_accuracy(y_true, y_pred):\n",
    "    return metrics.top_k_categorical_accuracy(y_true, y_pred, k=10)\n",
    "\n",
    "\n",
    "def top_30_accuracy(y_true, y_pred):\n",
    "    return metrics.top_k_categorical_accuracy(y_true, y_pred, k=30)\n",
    "\n",
    "\n",
    "def top_50_accuracy(y_true, y_pred):\n",
    "    return metrics.top_k_categorical_accuracy(y_true, y_pred, k=50)\n",
    "\n",
    "\n",
    "def top_100_accuracy(y_true, y_pred):\n",
    "    return metrics.top_k_categorical_accuracy(y_true, y_pred, k=100)\n",
    "\n",
    "\n",
    "def sub2ind(array_shape, rows, cols):\n",
    "    ind = rows * array_shape[1] + cols\n",
    "    ind[ind < 0] = -1\n",
    "    ind[ind >= array_shape[0] * array_shape[1]] = -1\n",
    "    return ind\n",
    "\n",
    "\n",
    "def ind2sub(array_shape, ind):\n",
    "    ind[ind < 0] = -1\n",
    "    ind[ind >= array_shape[0] * array_shape[1]] = -1\n",
    "    rows = ind.astype(\"int\") / array_shape[1]\n",
    "    cols = ind % array_shape[1]\n",
    "    return (rows, cols)\n",
    "\n",
    "\n",
    "def beamsLogScale(y, thresholdBelowMax):\n",
    "    y_shape = y.shape\n",
    "\n",
    "    for i in range(0, y_shape[0]):\n",
    "        thisOutputs = y[i, :]\n",
    "        logOut = 20 * np.log10(thisOutputs + 1e-30)\n",
    "        minValue = np.amax(logOut) - thresholdBelowMax\n",
    "        zeroedValueIndices = logOut < minValue\n",
    "        thisOutputs[zeroedValueIndices] = 0\n",
    "        thisOutputs = thisOutputs / sum(thisOutputs)\n",
    "        y[i, :] = thisOutputs\n",
    "\n",
    "    return y\n",
    "\n",
    "#converts the combined channel gains into the label vector y\n",
    "#to be used for training the model. For instance, if a softmax\n",
    "#activation is used in the DNN output, then make y sum up to 1.\n",
    "def prepare_output_labels(original_gains):  \n",
    "    method = 1 #for using DNN output with softmax activation    \n",
    "    if method == 1:\n",
    "        thresholdBelowMax = 60 #threshold in dB for zeroing gains in log domain\n",
    "        y = log_normalize_channel_gain(original_gains,thresholdBelowMax)\n",
    "    return y\n",
    "\n",
    "#converts to log scale and make zero the values below the specified threshold\n",
    "def log_normalize_channel_gain(y,thresholdBelowMax):\n",
    "    num_gains = len(y)\n",
    "    #print('AK',num_gains)\n",
    "    for i in range(0,y.shape[0]):            \n",
    "            thisOutputs = y[i,:]\n",
    "            logOut = 20*np.log10(thisOutputs + 1e-30)\n",
    "            minValue = np.amax(logOut) - thresholdBelowMax\n",
    "            zeroedValueIndices = logOut < minValue\n",
    "            thisOutputs[zeroedValueIndices]=0\n",
    "            #normalize to sum up to 1, and enable using softmax activation\n",
    "            thisOutputs = thisOutputs / sum(thisOutputs)\n",
    "            y[i,:] = thisOutputs        \n",
    "    return y\n",
    "\n",
    "#instead of representing the pair of beam indices with two integers, use only one integer.\n",
    "#for instance, if yMatrix has a shape of (11194, 8, 32), where 8 is the number of Rx antennas\n",
    "#and 32 the number of Tx antennas, then y_output has the shape (11194, 256) because 256=8*32.\n",
    "#this way, a single index will indicate the pair of indices\n",
    "def convert_pair_to_index(yMatrix):\n",
    "    yMatrix = np.abs(yMatrix)\n",
    "    yMatrix /= np.max(yMatrix)\n",
    "    yMatrixShape = yMatrix.shape\n",
    "    num_classes = yMatrix.shape[1] * yMatrix.shape[2]\n",
    "    y = yMatrix.reshape(yMatrix.shape[0],num_classes)\n",
    "    return y, num_classes\n",
    "\n",
    "\n",
    "def getBeamOutput(output_file):\n",
    "\n",
    "    print(\"Reading dataset...\", output_file)\n",
    "    output_cache_file = np.load(output_file)\n",
    "    yMatrix = output_cache_file[\"output_classification\"]\n",
    "\n",
    "    num_classes = 256\n",
    "\n",
    "    pairs = [[i, j] for i in range(8) for j in range(32)]\n",
    "    yMatrix = yMatrix.tolist()\n",
    "    indexes = [pairs.index(yMatrix[item]) for item in range(len(yMatrix))]\n",
    "\n",
    "    y = to_categorical(indexes, num_classes)\n",
    "\n",
    "    return y, num_classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reading dataset...  ./files_04_beam/lidar_input/lidar_input.npz\n"
     ]
    }
   ],
   "source": [
    "###############################################################################\n",
    "# Data configuration\n",
    "###############################################################################\n",
    "#tf.device(\"/device:GPU:0\") #commented out because we will run on CPU\n",
    "\n",
    "num_epochs = 1 #only one epoch because training takes long\n",
    "batch_size = 32\n",
    "tgtRec = 3\n",
    "seed = 0\n",
    "\n",
    "np.random.seed(seed)\n",
    "\n",
    "lidar_train_input_file = \"./files_04_beam/lidar_input/lidar_input.npz\"\n",
    "lidar_train_cache_file = np.load(lidar_train_input_file)\n",
    "X_lidar = lidar_train_cache_file[\"input\"]\n",
    "X_lidar_train, X_lidar_validation = train_test_split(\n",
    "    X_lidar, test_size=0.2, random_state=seed, shuffle=True\n",
    ")\n",
    "print(\"Reading dataset... \", lidar_train_input_file)\n",
    "lidar_train_input_shape = X_lidar_train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reading dataset... ./files_04_beam/beam_output/beams_output.npz\n"
     ]
    }
   ],
   "source": [
    "###############################################################################\n",
    "# Output configuration\n",
    "output_file = \"./files_04_beam/beam_output/beams_output.npz\"\n",
    "\n",
    "print(\"Reading dataset...\", output_file)\n",
    "output_cache_file = np.load(output_file)\n",
    "yMatrix = output_cache_file['output_classification']\n",
    "y_output, num_classes = convert_pair_to_index(yMatrix)\n",
    "y = prepare_output_labels(y_output)\n",
    "\n",
    "(\n",
    "    X_lidar_train,\n",
    "    X_lidar_validation,\n",
    "    y_train,\n",
    "    y_validation,\n",
    ") = train_test_split(\n",
    "    X_lidar, y_output, test_size=0.2, random_state=seed, shuffle=True\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model_5\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " input_6 (InputLayer)        [(None, 20, 200, 10)]     0         \n",
      "                                                                 \n",
      " conv2d_32 (Conv2D)          (None, 20, 200, 10)       16910     \n",
      "                                                                 \n",
      " conv2d_33 (Conv2D)          (None, 20, 200, 10)       12110     \n",
      "                                                                 \n",
      " conv2d_34 (Conv2D)          (None, 20, 200, 10)       8110      \n",
      "                                                                 \n",
      " max_pooling2d_13 (MaxPoolin  (None, 20, 50, 10)       0         \n",
      " g2D)                                                            \n",
      "                                                                 \n",
      " dropout_10 (Dropout)        (None, 20, 50, 10)        0         \n",
      "                                                                 \n",
      " conv2d_35 (Conv2D)          (None, 20, 50, 10)        4910      \n",
      "                                                                 \n",
      " max_pooling2d_14 (MaxPoolin  (None, 10, 12, 10)       0         \n",
      " g2D)                                                            \n",
      "                                                                 \n",
      " conv2d_36 (Conv2D)          (None, 10, 12, 10)        2510      \n",
      "                                                                 \n",
      " dropout_11 (Dropout)        (None, 10, 12, 10)        0         \n",
      "                                                                 \n",
      " conv2d_37 (Conv2D)          (None, 10, 12, 10)        910       \n",
      "                                                                 \n",
      " max_pooling2d_15 (MaxPoolin  (None, 5, 6, 10)         0         \n",
      " g2D)                                                            \n",
      "                                                                 \n",
      " flatten_5 (Flatten)         (None, 300)               0         \n",
      "                                                                 \n",
      " dense_5 (Dense)             (None, 256)               77056     \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 122,516\n",
      "Trainable params: 122,516\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "280/280 [==============================] - 16s 53ms/step - loss: 4.8894 - categorical_accuracy: 0.2116 - top_k_categorical_accuracy: 0.5419 - top_10_accuracy: 0.6984 - top_30_accuracy: 0.8997 - top_50_accuracy: 0.9463 - top_100_accuracy: 0.9788 - val_loss: 4.8234 - val_categorical_accuracy: 0.2818 - val_top_k_categorical_accuracy: 0.6280 - val_top_10_accuracy: 0.7655 - val_top_30_accuracy: 0.9469 - val_top_50_accuracy: 0.9683 - val_top_100_accuracy: 0.9875\n"
     ]
    }
   ],
   "source": [
    "##############################################################################\n",
    "# Model configuration\n",
    "##############################################################################\n",
    "\n",
    "modelHand = ModelHandler()\n",
    "opt = Adam(\n",
    "    learning_rate=0.001,\n",
    "    beta_1=0.9,\n",
    "    beta_2=0.999,\n",
    "    epsilon=1e-07,\n",
    "    amsgrad=True,\n",
    "    name=\"Adam\",\n",
    ")\n",
    "\n",
    "model = modelHand.createArchitecture(\n",
    "    num_classes,\n",
    "    [\n",
    "        lidar_train_input_shape[1],\n",
    "        lidar_train_input_shape[2],\n",
    "        lidar_train_input_shape[3],\n",
    "    ],\n",
    ")\n",
    "\n",
    "model.compile(\n",
    "    loss=categorical_crossentropy,\n",
    "    optimizer=opt,\n",
    "    metrics=[\n",
    "        metrics.categorical_accuracy,\n",
    "        metrics.top_k_categorical_accuracy,\n",
    "        top_10_accuracy,\n",
    "        top_30_accuracy,\n",
    "        top_50_accuracy,\n",
    "        top_100_accuracy,\n",
    "    ],\n",
    ")\n",
    "model.summary()\n",
    "hist = model.fit(\n",
    "    X_lidar_train,\n",
    "    y_train,\n",
    "    epochs=num_epochs,\n",
    "    batch_size=batch_size,\n",
    "    validation_data=(X_lidar_validation, y_validation),\n",
    ")\n",
    "\n",
    "# with open(\"history.txt\", \"w\") as f:\n",
    "#     f.write(str(hist.history))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"##Baselines cores\"\"\"\n",
    "\n",
    "beam_weights = {}\n",
    "for i in range(y_train.shape[1]):\n",
    "    beam_weights[i] = 0\n",
    "\n",
    "for i in range(y_train.shape[0]):\n",
    "    scene_array = y_train[i, :]\n",
    "    beam_weights[np.argmax(scene_array)] += 1\n",
    "\n",
    "ocurrence = np.zeros((1, y_validation.shape[1]))\n",
    "oc_factor = sum(beam_weights.values())\n",
    "for b_index in beam_weights.keys():\n",
    "    ocurrence[0, b_index] = beam_weights[b_index] / oc_factor\n",
    "\n",
    "# ocurrence\n",
    "ocurrence_input = np.repeat(ocurrence, y_validation.shape[0], axis=0)\n",
    "ocurrence_output = softmax(ocurrence_input, axis=1)\n",
    "# rand\n",
    "rand_input = np.random.rand(X_lidar_validation.shape[0], 256)\n",
    "rand_output = softmax(rand_input, axis=1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'LIDAR data')"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 700x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\"\"\"#Accuracy / epochs\"\"\"\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(7, 4))\n",
    "ax.plot(\n",
    "    hist.history[\"categorical_accuracy\"], \"b\", label=\"Categorical accuracy\", linewidth=2\n",
    ")\n",
    "ax.plot(hist.history[\"top_k_categorical_accuracy\"], \"k--\", label=\"Top 5\", linewidth=2)\n",
    "ax.plot(hist.history[\"top_10_accuracy\"], \"m\", label=\"Top 10\", linewidth=2)\n",
    "ax.plot(hist.history[\"top_30_accuracy\"], \"g--\", label=\"Top 30\", linewidth=2)\n",
    "ax.plot(hist.history[\"top_50_accuracy\"], \"r\", label=\"Top 50\", linewidth=2)\n",
    "ax.set(xlabel=\"Epochs\", ylabel=\"Accuracy\")\n",
    "ax.grid()\n",
    "plt.legend()\n",
    "plt.title('LIDAR data')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "ocurrence_output = np.float32(ocurrence_output)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "rand_output = np.float32(rand_output)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "70/70 [==============================] - 1s 9ms/step\n"
     ]
    }
   ],
   "source": [
    "\"\"\"##Creating Baselines\"\"\"\n",
    "\n",
    "predict_top_k = {}\n",
    "ocurrence_top_k = {}\n",
    "random_top_k = {}\n",
    "y_predict = model.predict(X_lidar_validation)\n",
    "for i in range(1, 51):\n",
    "    predict_top_k[f\"top_{i}\"] = (\n",
    "        np.sum(top_k_categorical_accuracy(y_validation, y_predict, k=i))\n",
    "        / y_predict.shape[0]\n",
    "    )\n",
    "    ocurrence_top_k[f\"top_{i}\"] = (\n",
    "        np.sum(top_k_categorical_accuracy(y_validation, ocurrence_output, k=i))\n",
    "        / y_predict.shape[0]\n",
    "    )\n",
    "    random_top_k[f\"top_{i}\"] = (\n",
    "        np.sum(top_k_categorical_accuracy(y_validation, rand_output, k=i))\n",
    "        / y_predict.shape[0]\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x24b4343c6a0>"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 700x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\"\"\"## TOP 10 acurracy\"\"\"\n",
    "if False: #we disable when there is a small number of data to create the histograms\n",
    "    plt.figure(figsize=(7, 4))\n",
    "    plt.hist(predict_top_k[\"top_10\"])\n",
    "    plt.hist(ocurrence_top_k[\"top_10\"])\n",
    "    plt.hist(random_top_k[\"top_10\"])\n",
    "\n",
    "plt.figure(figsize=(7, 4))\n",
    "plt.xlabel(\"Top k\")\n",
    "plt.ylabel(\"Accuracy\")\n",
    "plt.plot(list(predict_top_k.values()), label=\"NN\")\n",
    "plt.plot(list(ocurrence_top_k.values()), label=\"Ocurrence\")\n",
    "plt.plot(list(random_top_k.values()), label=\"Dummy\")\n",
    "plt.grid()\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "52e85753",
   "metadata": {},
   "source": [
    "## Authors\n",
    "\n",
    "- [João Borges - LASSE/UFPA](https://github.com/joaotavares43)\n",
    "- [Luan Gonçalves - LASSE/UFPA](https://github.com/LuanAGoncalves)\n",
    "- [Ailton Oliveira - LASSE/UFPA](https://github.com/AiltonOliveir)\n",
    "- [Daniel Takashi - LASSE/UFPA](https://github.com/orgs/lasseufpa/people/TakashiDan0)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python (ai6genv)",
   "language": "python",
   "name": "ai6g"
  },
  "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.9.7"
  },
  "vscode": {
   "interpreter": {
    "hash": "dac2514730ec6dd4fc1d04cb6927967d7376870f25ae7edf50b318831380a3e7"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}