Link Adaptation - OLLA and BayesLA.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numerical Experiments\n",
    "\n",
    "Simulation code for running the numerical experiments reported in the paper:  \n",
    "**Vidit Saxena and Joakim Jaldén,\"Bayesian Link Adaptation under a BLER Target\", In 2020 IEEE 21st International Workshop on Signal Processing Advances in Wireless Communications (SPAWC) on May 26-29, 2020.** \n",
    "\n",
    "This simulation code is written in Python3. Running each of the subsequent cells in sequence will execute the experiments and generate a results file (in .npy format) that is saved to the disk.\n",
    "\n",
    "The simulations make extensive use of the [py-itpp](https://github.com/vidits-kth/py-itpp), [Numpy](https://github.com/numpy/numpy), and [Matplotlib](https://github.com/matplotlib/matplotlib) packages.\n",
    "\n",
    "Additionally, to speed up the generation of results, the simulations are parallezlized using the [Ray](http://ray.readthedocs.io/en/latest/index.html) package. It is possible to run single-threaded simulations at the cost of slowness, by commenting out the Ray-specific lines in the notebook - this is indicated in the appropriate sections of the code.\n",
    "\n",
    "The user-defined parameters are highlighted with the USER-DEFINED tag below; set these values below to setup and run the experiments for the desired parameters."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Import Dependencies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "\n",
    "import numpy as np\n",
    "import ray\n",
    "import time\n",
    "\n",
    "from source import simluate_rayleigh_fading_channel\n",
    "from source import ThompsonSamplingBandit, OuterLoopLinkAdaptation\n",
    "\n",
    "plt.rcParams.update({'font.size': 22, 'lines.linewidth' : 3})\n",
    "\n",
    "# RAY: If Ray is installed on this machine, initialize it properly below. \n",
    "# It is also possible to run the experiments without Ray. In that case, comment out the lines below and in \n",
    "# subsequent cells, where identified with the RAY: comment.\n",
    "ray_redis_address = \"10.0.0.5:15672\"\n",
    "ray.init(address=ray_redis_address, ignore_reinit_error=True, log_to_driver=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load SNR-to-CQI Lookup Data\n",
    "The CQI values are calculated using an offline lookup table of AWGN BLER values. For a complete description of the CQI generation technique, refer to [11] referenced in the pabler. This lookup data is used for AMC part of the AMC-OLLA technique.\n",
    "\n",
    "The AWGN_DATASET is generated offline using a separate simulation (not reported here since it is not relevant to this pabler). This dataset contains the measured BLER for a large range of average SNRs, for each of the MCSs simulated in this pabler."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "awgn_datafile = 'AWGN_DATASET.npy'\n",
    "awgn_data = np.load( awgn_datafile, allow_pickle=True )[ ( ) ]\n",
    "\n",
    "snr_vs_bler = awgn_data['snr_vs_per']\n",
    "snr_range_dB = awgn_data['snr_range_dB']\n",
    "\n",
    "nrof_snr, nrof_rates = snr_vs_bler.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Visualize the lookup data\n",
    "plt.figure(figsize=[20,5])\n",
    "\n",
    "legend = []\n",
    "for i in range( nrof_rates ):\n",
    "    plt.semilogy( snr_range_dB, snr_vs_bler[:,i] )\n",
    "    legend.append('MCS %d'%(i))\n",
    "    \n",
    "plt.legend(legend, ncol=2)\n",
    "plt.title('SNR-vs-BLER data for CQI lookup')\n",
    "plt.xlabel('Average SNR [dB]')\n",
    "plt.ylabel('BLER')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simulation parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Standard-defined transport block sizes from [12, Tab. 7.1.7.2.1-1]\n",
    "packet_sizes = [152, 200, 248, 320, 408, 504, 600, 712, 808, 936, \n",
    "                936, 1032, 1192, 1352, 1544, 1736, 1800, \n",
    "                1800, 1928, 2152, 2344, 2600, 2792, 2984, 3240, 3496, 3624, 3752, 4008]\n",
    "\n",
    "# Standard-defined Modulation orders from [12, Tab. 7.1.7.1-1]\n",
    "modorders    = [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, \n",
    "                4, 4, 4, 4, 4, 4, 4, \n",
    "                6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6]\n",
    "\n",
    "# USER-DEFINED target BLER and OLLA parameters\n",
    "target_bler = 0.1\n",
    "olla_step_size = 0.1\n",
    "\n",
    "# USER-DEFINED wireless channel configuration\n",
    "norm_doppler = 0.01\n",
    "avg_snr_dB = 15\n",
    "\n",
    "# USER-DEFINED exbleriment parameters\n",
    "nrof_ttis = 50\n",
    "nrof_experiments = 10\n",
    "\n",
    "# Parameter settings for Figs. 1(a) and 1(b) in the paper:\n",
    "# target_bler = 0.1, olla_step_size = 0.1, norm_doppler = 0.01, avg_snr_dB = 15, nrof_ttis = 5000, nrof_experiments = 1000\n",
    "\n",
    "# Parameter settings for Figs. 1(a) and 1(b) in the paper:\n",
    "# target_bler = 0.3, olla_step_size = 0.1, norm_doppler = 0.01, avg_snr_dB = 15, nrof_ttis = 5000, nrof_experiments = 1000"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Extract prior BLER corresponding to each CQI value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from source import estimate_sinr_from_cqi, determine_bler_at_sinr\n",
    "\n",
    "nrof_cqi = 16\n",
    "bler_bler_cqi = np.ndarray( ( len( packet_sizes ), nrof_cqi ) )\n",
    "for cqi in range( nrof_cqi ):\n",
    "    snr_dB = estimate_sinr_from_cqi(cqi, awgn_data)\n",
    "    bler_bler_cqi[ :, cqi ] = determine_bler_at_sinr(snr_dB, awgn_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### OLLA and BaysLA for link adaptation over a Rayleigh Fading channel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# RAY: The following method is packaged using Ray. To remove this dependence, comment out the line below.\n",
    "@ray.remote  # Comment this out if Ray is not used\n",
    "def run_experiment( seed, nrof_ttis, avg_snr_dB, target_bler, olla_step_size, norm_doppler ):\n",
    "    \n",
    "    from source import simluate_rayleigh_fading_channel\n",
    "    from source import ThompsonSamplingBandit, OuterLoopLinkAdaptation\n",
    "\n",
    "    packet_error_probabilities, channel_quality_indices = simluate_rayleigh_fading_channel( nrof_ttis, \n",
    "                                                                                            avg_snr_dB, \n",
    "                                                                                            awgn_data, \n",
    "                                                                                            packet_sizes, \n",
    "                                                                                            norm_doppler, \n",
    "                                                                                            seed = seed )\n",
    "\n",
    "    # Pre-generate ACK events for all rates for all channel samples\n",
    "    packet_acks = np.ndarray( ( nrof_ttis, nrof_rates ) )\n",
    "    for tti in range( nrof_ttis ):\n",
    "        for rate_index in range( nrof_rates ):\n",
    "            packet_acks[tti, rate_index] = np.random.uniform( ) > packet_error_probabilities[tti, rate_index]\n",
    "\n",
    "            \n",
    "    # Outer Loop Link Adaptation\n",
    "    olla_bandit = OuterLoopLinkAdaptation(nrof_rates, packet_sizes, awgn_data, target_bler, olla_step_size)\n",
    "    \n",
    "    cqi_delay = 0 \n",
    "    \n",
    "    olla_rates  = []\n",
    "    olla_acks  = []\n",
    "    olla_tputs = []\n",
    "    for tti in range( nrof_ttis ):\n",
    "        \n",
    "        # Skip the first few samples to account for CQI delay\n",
    "        if tti < cqi_delay:\n",
    "            selected_rate_index = np.random.randint(0, nrof_cqi)\n",
    "            ack = packet_acks[tti, selected_rate_index]\n",
    "        else:  \n",
    "            cqi = channel_quality_indices[tti - cqi_delay]    \n",
    "            selected_rate_index = olla_bandit.act( cqi )\n",
    "\n",
    "            ack = packet_acks[tti, selected_rate_index]\n",
    "            olla_bandit.update( selected_rate_index, cqi, ack )\n",
    "\n",
    "        olla_rates.append(selected_rate_index)\n",
    "        olla_acks.append(ack)\n",
    "        olla_tputs.append( packet_sizes[ selected_rate_index ] * ack )\n",
    "        \n",
    "    \n",
    "    # Thompson Sampling with Informed Priors\n",
    "    bayesla_bandit = ThompsonSamplingBandit(nrof_rates, packet_sizes, target_bler, bler_bler_cqi)\n",
    "    \n",
    "    bayesla_rates  = []\n",
    "    bayesla_acks  = []\n",
    "    bayesla_tputs = []\n",
    "    for tti in range( nrof_ttis ):\n",
    "        \n",
    "        # Skip the first few samples to account for CQI delay\n",
    "        if tti < cqi_delay:\n",
    "            selected_rate_index = np.random.randint(0, nrof_cqi)\n",
    "            ack = packet_acks[tti, selected_rate_index]\n",
    "        else:    \n",
    "            cqi = channel_quality_indices[tti - cqi_delay]    \n",
    "            selected_rate_index = bayesla_bandit.act( cqi )\n",
    "\n",
    "            ack = packet_acks[tti, selected_rate_index]\n",
    "            bayesla_bandit.update( selected_rate_index, cqi, ack )\n",
    "\n",
    "        bayesla_rates.append(selected_rate_index)\n",
    "        bayesla_acks.append(ack)\n",
    "        bayesla_tputs.append( packet_sizes[ selected_rate_index ] * ack )\n",
    "    \n",
    "    return ( olla_rates, olla_acks, olla_tputs, \n",
    "             bayesla_rates, bayesla_acks, bayesla_tputs, )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Run the experiments and collect results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "olla_mcs = []\n",
    "olla_ack = []\n",
    "olla_tput = []\n",
    "\n",
    "bayesla_mcs = []\n",
    "bayesla_ack = []\n",
    "bayesla_tput = []\n",
    "\n",
    "\n",
    "# RAY: The following line runs the Ray-packaged method. To avoid using Ray, comment out the next line and uncomment\n",
    "# the line that immediately follows it in order to run the experiments.\n",
    "results = ray.get( [ run_experiment.remote( i,\n",
    "                                            nrof_ttis, \n",
    "                                            avg_snr_dB, \n",
    "                                            target_bler,\n",
    "                                            olla_step_size,\n",
    "                                            norm_doppler ) for i in range(nrof_experiments) ] )\n",
    "\n",
    "# RAY: uncomment the next line to run a single-threaded simulation that does not depend on Ray.\n",
    "#results = [ run_experiment( i, nrof_ttis, avg_snr_dB, target_bler, olla_step_size, norm_doppler ) for i in range(nrof_experiments) ]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Extract the results in separate variables for OLLA and BayesLA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for res in results:\n",
    "    olla_mcs.append( res[0] )\n",
    "    olla_ack.append( res[1] )\n",
    "    olla_tput.append( res[2] )\n",
    "    \n",
    "    bayesla_mcs.append( res[3] )\n",
    "    bayesla_ack.append( res[4] )\n",
    "    bayesla_tput.append( res[5] )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Save the results to disk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data= { 'olla': ([], olla_ack, olla_tput),\n",
    "        'bayesla': ([], bayesla_ack, bayesla_tput)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#result_file = 'RESULT_SNR_%d_TARGET_%0.1f_DELAY_%d.npy'%( avg_snr_dB, target_bler, cqi_delay)\n",
    "\n",
    "result_file = 'TEST.npy'\n",
    "\n",
    "np.save(result_file, data)\n",
    "\n",
    "print('Saved to %s'%(result_file))"
   ]
  },
  {
   "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": 2
}