GNN_decoder_reg_LDPC.ipynb

{
 "cells": [
  {
   "cell_type": "raw",
   "id": "3fc5d4a8",
   "metadata": {},
   "source": [
    "# SPDX-FileCopyrightText: Copyright (c) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n",
    "# SPDX-License-Identifier: LicenseRef-NvidiaProprietary\n",
    "#\n",
    "# NVIDIA CORPORATION, its affiliates and licensors retain all intellectual\n",
    "# property and proprietary rights in and to this material, related\n",
    "# documentation and any modifications thereto. Any use, reproduction,\n",
    "# disclosure or distribution of this material and related documentation\n",
    "# without an express license agreement from NVIDIA CORPORATION or\n",
    "# its affiliates is strictly prohibited."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6be5146",
   "metadata": {},
   "source": [
    "# GNN Decoder Experiments for Regular LDPC Codes\n",
    "\n",
    "This notebook reproduces the regular LDPC code results in the paper [Graph Neural Networks for Channel Decoding](https://arxiv.org/pdf/2207.14742.pdf).\n",
    "\n",
    "**Remark**: the training can take several hours. However, pre-trained weights are stored in this repository and can be directly loaded to reproduce the results.\n",
    "\n",
    "This notebook requires [Sionna](https://nvlabs.github.io/sionna/)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "0a65e588",
   "metadata": {},
   "outputs": [],
   "source": [
    "# general imports\n",
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# load required Sionna components\n",
    "from sionna.fec.utils import load_parity_check_examples, LinearEncoder, gm2pcm\n",
    "from sionna.utils.plotting import PlotBER\n",
    "from sionna.fec.ldpc import LDPCBPDecoder\n",
    "\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "from gnn import * # load GNN functions\n",
    "from wbp import * # load weighted BP functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "bfcba1be-cac2-4316-803b-d7715674d5bc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of GPUs available : 2\n",
      "Only GPU number 0 used.\n"
     ]
    }
   ],
   "source": [
    "tf.get_logger().setLevel('INFO') # ignore tf warnings related to autograph\n",
    "\n",
    "gpus = tf.config.list_physical_devices('GPU')\n",
    "print('Number of GPUs available :', len(gpus))\n",
    "if gpus:\n",
    "    gpu_num = 0 # Number of the GPU to be used\n",
    "    try:\n",
    "        #tf.config.set_visible_devices([], 'GPU')\n",
    "        tf.config.set_visible_devices(gpus[gpu_num], 'GPU')\n",
    "        print('Only GPU number', gpu_num, 'used.')\n",
    "        tf.config.experimental.set_memory_growth(gpus[gpu_num], True)\n",
    "    except RuntimeError as e:\n",
    "        print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d293650",
   "metadata": {},
   "source": [
    "## Define Hyperparameters and Load Code\n",
    "\n",
    "We define all parameters as dictionary to support different architectures for different codes.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "89b34d4c",
   "metadata": {},
   "outputs": [],
   "source": [
    "#----- BCH -----\n",
    "params={\n",
    "    # --- Code Parameters ---\n",
    "        \"code\": \"reg-LDPC\",\n",
    "        \"n_des\": 100, # target codeword length (code generation may slightly increase n)\n",
    "        \"v\": 3, # VN degree\n",
    "        \"c\": 6, # VN degree\n",
    "    # --- GNN Architecture ----\n",
    "        \"num_embed_dims\": 16,\n",
    "        \"num_msg_dims\": 16,\n",
    "        \"num_hidden_units\": 64,\n",
    "        \"num_mlp_layers\": 2,\n",
    "        \"num_iter\": 10,\n",
    "        \"reduce_op\": \"mean\",\n",
    "        \"activation\": \"tanh\",\n",
    "        \"clip_llr_to\": None,\n",
    "        \"use_attributes\": False,\n",
    "        \"node_attribute_dims\": 0,\n",
    "        \"msg_attribute_dims\": 0,\n",
    "        \"return_infobits\": False,\n",
    "        \"use_bias\": True,        \n",
    "    # --- Training ---- # \n",
    "        \"batch_size\": [150, 150, 150], # bs, iter, lr must have same dim\n",
    "        \"train_iter\": [50000, 200000, 300000],\n",
    "        \"learning_rate\": [2e-4, 1e-4, 1e-5],\n",
    "        \"ebno_db_train\": [2., 4.],\n",
    "        \"ebno_db_eval\": 2.5,          \n",
    "        \"batch_size_eval\": 2000, # batch size only used for evaluation during training\n",
    "        \"eval_train_steps\": 1000, # evaluate model every N iters\n",
    "    # --- Log ----\n",
    "        \"save_weights_iter\": 10000, # save weights every X iters\n",
    "        \"run_name\": \"LDPC_reg_01\", # name of the stored weights/logs\n",
    "        \"save_dir\": \"results/\", # folder to store results\n",
    "    # --- MC Simulation parameters ----\n",
    "        \"eval_dec_iter\": 20, # number of decoding iters to evaluate\n",
    "        \"mc_iters\": 1000,\n",
    "        \"mc_batch_size\": 2000,\n",
    "        \"num_target_block_errors\": 1000,\n",
    "        \"ebno_db_min\": 0.,\n",
    "        \"ebno_db_max\": 4.,\n",
    "        \"ebno_db_stepsize\": 0.25,\n",
    "        \"eval_ns\": [100, 500, 1000],        \n",
    "    # --- Weighted BP parameters ----\n",
    "        \"simulate_wbp\": True, # simulate weighted BP as baseline\n",
    "        \"wbp_batch_size\" : [1000, 1000, 1000],\n",
    "        \"wbp_train_iter\" : [300, 2000, 2000],\n",
    "        \"wbp_learning_rate\" : [1e-2, 1e-3, 1e-3],\n",
    "        \"wbp_ebno_train\" : [2.5, 3., 3.5],\n",
    "        \"wbp_ebno_val\" : 5., # validation SNR during training\n",
    "        \"wbp_batch_size_val\" : 2000,\n",
    "        \"wbp_clip_value_grad\" : 10, \n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eee184a0",
   "metadata": {},
   "source": [
    "## Load / Generate the Graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "cbb298dd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# code construction; this will be integrated in Sionna in one of the next releases\n",
    "def generate_reg_ldpc(v, c, n, allow_flex_len=True, verbose=True):\n",
    "    \"\"\"Generate random regular (v,c) LDPC code.\n",
    "\n",
    "    This functions generates a random LDPC parity-check matrix of length ``n``\n",
    "    where each variable node (VN) has degree ``v`` and each check node (CN) has\n",
    "    degree ``c``. Please note that the LDPC code is not optimized to avoid\n",
    "    short cycles. For encoding, the :class:`~sionna.fec.utils.LinearEncoder`\n",
    "    layer can be used.\n",
    "\n",
    "    Input\n",
    "    -----\n",
    "    v : int\n",
    "        Desired variable node (VN) degree.\n",
    "\n",
    "    c : int\n",
    "        Desired check node (CN) degree.\n",
    "\n",
    "    n : int\n",
    "        Desired codeword length.\n",
    "\n",
    "    allow_flex_len: bool\n",
    "        Defaults to True. If True, the resulting codeword length can be\n",
    "        (slightly) increased.\n",
    "\n",
    "    verbose : bool\n",
    "        Defaults to True. If True, code parameters are printed.\n",
    "\n",
    "    Output\n",
    "    ------\n",
    "    (pcm, k, n, coderate):\n",
    "        Tuple:\n",
    "\n",
    "    pcm: ndarray\n",
    "        NumPy array of shape `[n-k, n]` containing the parity-check matrix.\n",
    "\n",
    "    k: int\n",
    "        Number of information bits per codeword.\n",
    "\n",
    "    n: int\n",
    "        Number of codewords bits.\n",
    "\n",
    "    coderate: float\n",
    "        Coderate of the code.\n",
    "\n",
    "\n",
    "    Note\n",
    "    ----\n",
    "    This algorithm only works for regular node degrees. For state-of-the-art\n",
    "    bit-error-rate performance, usually one needs to optimize irregular LDPC\n",
    "    codes.\n",
    "    \"\"\"\n",
    "\n",
    "    # check input values for consistency\n",
    "    assert isinstance(allow_flex_len, bool), \\\n",
    "                                    'allow_flex_len must be bool.'\n",
    "\n",
    "    # allow slight change in n to keep num edges\n",
    "    # from CN and VN perspective an integer\n",
    "    if allow_flex_len:\n",
    "        for n_mod in range(n, n+2*c):\n",
    "            if np.mod((v/c) * n_mod, 1.)==0:\n",
    "                n = n_mod\n",
    "                if verbose:\n",
    "                    print(\"Changing n to: \", n)\n",
    "                break\n",
    "\n",
    "    # calculate number of nodes\n",
    "    coderate = 1 - (v/c) # to be checked\n",
    "    n_v = n\n",
    "    n_c = int((v/c) * n)\n",
    "    k = n_v - n_c\n",
    "\n",
    "    # generate sockets\n",
    "    v_socks = np.tile(np.arange(n_v),v)\n",
    "    c_socks = np.tile(np.arange(n_c),c)\n",
    "    if verbose:\n",
    "        print(\"Number of edges (VN perspective): \", len(v_socks))\n",
    "        print(\"Number of edges (CN perspective): \", len(c_socks))\n",
    "    assert len(v_socks) == len(c_socks), \"Number of edges from VN and CN \" \\\n",
    "        \"perspective does not match. Consider to (slightly) change n.\"\n",
    "\n",
    "    # apply random permutations\n",
    "    np.random.shuffle(v_socks)\n",
    "    np.random.shuffle(c_socks)\n",
    "\n",
    "    # and generate matrix\n",
    "    pcm = np.zeros([n_c, n_v])\n",
    "\n",
    "    idx = 0\n",
    "    shuffle_max = 1000 # stop if no success\n",
    "    shuffle_counter = 0\n",
    "    cont = True\n",
    "    while cont:\n",
    "        # if edge is available, take it\n",
    "        if pcm[c_socks[idx],v_socks[idx]]==0:\n",
    "            pcm[c_socks[idx],v_socks[idx]] = 1\n",
    "            idx += 1 # and go to next socket\n",
    "            shuffle_counter = 0 # reset counter\n",
    "            if idx==len(v_socks):\n",
    "                cont=False\n",
    "        else: # shuffle sockets\n",
    "            shuffle_counter += 1\n",
    "            if shuffle_counter<shuffle_max:\n",
    "                np.random.shuffle(v_socks[idx:])\n",
    "                np.random.shuffle(c_socks[idx:])\n",
    "            else:\n",
    "                print(\"Stopping - no solution found!\")\n",
    "                cont=False\n",
    "\n",
    "    v_deg = np.sum(pcm, axis=0)\n",
    "    c_deg = np.sum(pcm, axis=1)\n",
    "\n",
    "    assert((v_deg==v).all()), \"VN degree not always v.\"\n",
    "    assert((c_deg==c).all()), \"CN degree not always c.\"\n",
    "\n",
    "    if verbose:\n",
    "        print(f\"Generated regular ({v},{c}) LDPC code of length n={n}\")\n",
    "        print(f\"Code rate is r={coderate}.\")\n",
    "        plt.spy(pcm)\n",
    "\n",
    "    return pcm, k, n, coderate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "d8c3ddcb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading LDPC code\n",
      "Changing n to:  100\n",
      "Number of edges (VN perspective):  300\n",
      "Number of edges (CN perspective):  300\n",
      "Generated regular (3,6) LDPC code of length n=100\n",
      "Code rate is r=0.5.\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# all codes must provide an encoder-layer and a pcm\n",
    "if params[\"code\"]==\"reg-LDPC\":    \n",
    "    print(\"Loading LDPC code\")\n",
    "    pcm, k, n, coderate = generate_reg_ldpc(v=params[\"v\"], \n",
    "                                            c=params[\"c\"],  \n",
    "                                            n=params[\"n_des\"], \n",
    "                                            allow_flex_len=True, \n",
    "                                            verbose=True)\n",
    "\n",
    "    encoder = LinearEncoder(pcm, is_pcm=True)\n",
    "    params[\"k\"] = k\n",
    "    params[\"n\"] = n\n",
    "else:\n",
    "    raise ValueError(\"Unknown code type\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ada6da9",
   "metadata": {},
   "source": [
    "## Simulate Baseline BER Performance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "343e2676-5791-45da-b7f8-812304dc79e8",
   "metadata": {},
   "outputs": [],
   "source": [
    "ber_plot = PlotBER(f\"GNN-based Decoding - {params['code']}, (k,n)=({k},{n})\")\n",
    "ebno_dbs = np.arange(params[\"ebno_db_min\"],\n",
    "                     params[\"ebno_db_max\"]+1,\n",
    "                     params[\"ebno_db_stepsize\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "3d360c58-668a-4eff-a6f9-acaeef510fc0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EbNo [dB] |        BER |       BLER |  bit errors |    num bits | block errors |  num blocks | runtime [s] |    status\n",
      "---------------------------------------------------------------------------------------------------------------------------------------\n",
      "      0.0 | 7.9590e-02 | 1.0000e+00 |       15918 |      200000 |         2000 |        2000 |         1.7 |reached target block errors\n",
      "     0.25 | 7.2575e-02 | 9.9950e-01 |       14515 |      200000 |         1999 |        2000 |         0.0 |reached target block errors\n",
      "      0.5 | 6.6960e-02 | 9.9900e-01 |       13392 |      200000 |         1998 |        2000 |         0.0 |reached target block errors\n",
      "     0.75 | 6.0840e-02 | 9.9750e-01 |       12168 |      200000 |         1995 |        2000 |         0.0 |reached target block errors\n",
      "      1.0 | 5.6340e-02 | 9.9650e-01 |       11268 |      200000 |         1993 |        2000 |         0.0 |reached target block errors\n",
      "     1.25 | 5.0950e-02 | 9.9600e-01 |       10190 |      200000 |         1992 |        2000 |         0.0 |reached target block errors\n",
      "      1.5 | 4.6230e-02 | 9.9200e-01 |        9246 |      200000 |         1984 |        2000 |         0.0 |reached target block errors\n",
      "     1.75 | 4.1850e-02 | 9.8800e-01 |        8370 |      200000 |         1976 |        2000 |         0.0 |reached target block errors\n",
      "      2.0 | 3.8155e-02 | 9.7500e-01 |        7631 |      200000 |         1950 |        2000 |         0.0 |reached target block errors\n",
      "     2.25 | 3.3215e-02 | 9.6050e-01 |        6643 |      200000 |         1921 |        2000 |         0.0 |reached target block errors\n",
      "      2.5 | 2.9880e-02 | 9.5500e-01 |        5976 |      200000 |         1910 |        2000 |         0.0 |reached target block errors\n",
      "     2.75 | 2.6855e-02 | 9.2800e-01 |        5371 |      200000 |         1856 |        2000 |         0.0 |reached target block errors\n",
      "      3.0 | 2.2925e-02 | 9.0150e-01 |        4585 |      200000 |         1803 |        2000 |         0.0 |reached target block errors\n",
      "     3.25 | 1.9510e-02 | 8.5700e-01 |        3902 |      200000 |         1714 |        2000 |         0.0 |reached target block errors\n",
      "      3.5 | 1.7595e-02 | 8.3350e-01 |        3519 |      200000 |         1667 |        2000 |         0.0 |reached target block errors\n",
      "     3.75 | 1.4415e-02 | 7.6950e-01 |        2883 |      200000 |         1539 |        2000 |         0.0 |reached target block errors\n",
      "      4.0 | 1.2550e-02 | 7.1700e-01 |        2510 |      200000 |         1434 |        2000 |         0.0 |reached target block errors\n",
      "     4.25 | 1.0395e-02 | 6.5450e-01 |        2079 |      200000 |         1309 |        2000 |         0.0 |reached target block errors\n",
      "      4.5 | 8.6700e-03 | 6.0100e-01 |        1734 |      200000 |         1202 |        2000 |         0.0 |reached target block errors\n",
      "     4.75 | 7.1750e-03 | 5.0650e-01 |        1435 |      200000 |         1013 |        2000 |         0.0 |reached target block errors\n"
     ]
    }
   ],
   "source": [
    "# uncoded QPSK\n",
    "e2e_uncoded = E2EModel(None, None, k=100, n=100) # k and n are not relevant here\n",
    "ber_plot.simulate(e2e_uncoded,\n",
    "                  ebno_dbs=ebno_dbs,\n",
    "                  batch_size=params[\"mc_batch_size\"],\n",
    "                  num_target_block_errors=params[\"num_target_block_errors\"],\n",
    "                  legend=\"Uncoded\",\n",
    "                  soft_estimates=True,\n",
    "                  max_mc_iter=params[\"mc_iters\"],\n",
    "                  forward_keyboard_interrupt=False,\n",
    "                  show_fig=False);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "27bb82b9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iter: 0 loss: 0.003037 ber: 0.0001 bmi: 0.999\n",
      "Iter: 50 loss: 0.002917 ber: 0.0000 bmi: 1.000\n",
      "Iter: 100 loss: 0.002769 ber: 0.0000 bmi: 1.000\n",
      "Iter: 150 loss: 0.002290 ber: 0.0000 bmi: 1.000\n",
      "Iter: 200 loss: 0.002667 ber: 0.0001 bmi: 1.000\n",
      "Iter: 250 loss: 0.002765 ber: 0.0001 bmi: 0.999\n",
      "Iter: 0 loss: 0.002426 ber: 0.0000 bmi: 1.000\n",
      "Iter: 50 loss: 0.002623 ber: 0.0000 bmi: 1.000\n",
      "Iter: 100 loss: 0.002768 ber: 0.0001 bmi: 1.000\n",
      "Iter: 150 loss: 0.002689 ber: 0.0000 bmi: 1.000\n",
      "Iter: 200 loss: 0.002897 ber: 0.0001 bmi: 0.999\n",
      "Iter: 250 loss: 0.002492 ber: 0.0000 bmi: 1.000\n",
      "Iter: 300 loss: 0.002486 ber: 0.0000 bmi: 1.000\n",
      "Iter: 350 loss: 0.002876 ber: 0.0000 bmi: 1.000\n",
      "Iter: 400 loss: 0.002809 ber: 0.0000 bmi: 1.000\n",
      "Iter: 450 loss: 0.002554 ber: 0.0000 bmi: 1.000\n",
      "Iter: 500 loss: 0.003199 ber: 0.0001 bmi: 0.999\n",
      "Iter: 550 loss: 0.002936 ber: 0.0001 bmi: 0.999\n",
      "Iter: 600 loss: 0.002664 ber: 0.0000 bmi: 1.000\n",
      "Iter: 650 loss: 0.002330 ber: 0.0000 bmi: 1.000\n",
      "Iter: 700 loss: 0.003071 ber: 0.0001 bmi: 0.999\n"
     ]
    }
   ],
   "source": [
    "# train and simulate Weighted BP as additional baseline\n",
    "# please note that the training parameters could be critical \n",
    "if params[\"simulate_wbp\"]:\n",
    "    evaluate_wbp(params, pcm, encoder, ebno_dbs, ber_plot)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38e1ced8",
   "metadata": {},
   "source": [
    "### GNN-based Decoding\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "76868915-620b-4abe-a620-dfcb1d308b50",
   "metadata": {},
   "outputs": [],
   "source": [
    "tf.random.set_seed(2) # we fix the seed to ensure stable convergence \n",
    "\n",
    "# init the GNN decoder\n",
    "gnn_decoder = GNN_BP(pcm=pcm,\n",
    "                     num_embed_dims=params[\"num_embed_dims\"],\n",
    "                     num_msg_dims=params[\"num_msg_dims\"],\n",
    "                     num_hidden_units=params[\"num_hidden_units\"],\n",
    "                     num_mlp_layers=params[\"num_mlp_layers\"],\n",
    "                     num_iter=params[\"num_iter\"],\n",
    "                     reduce_op=params[\"reduce_op\"],\n",
    "                     activation=params[\"activation\"],\n",
    "                     output_all_iter=True,\n",
    "                     clip_llr_to=params[\"clip_llr_to\"],\n",
    "                     use_attributes=params[\"use_attributes\"],\n",
    "                     node_attribute_dims=params[\"node_attribute_dims\"],\n",
    "                     msg_attribute_dims=params[\"msg_attribute_dims\"],\n",
    "                     use_bias=params[\"use_bias\"])\n",
    "                     \n",
    "e2e_gnn = E2EModel(encoder, gnn_decoder, k, n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9f251a37",
   "metadata": {},
   "outputs": [],
   "source": [
    "# init model and print summary\n",
    "e2e_gnn(1, 1.)\n",
    "e2e_gnn.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cfb6dc52-1f2e-4651-b8a7-641bc1702dd4",
   "metadata": {},
   "source": [
    "and let's train the model..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "56256283-07d4-42b6-9340-9985edb98159",
   "metadata": {},
   "outputs": [],
   "source": [
    "train = False # remark: training takes several hours\n",
    "if train:\n",
    "    train_gnn(e2e_gnn, params)\n",
    "else:\n",
    "    # you can also load the precomputed weights\n",
    "    load_weights(e2e_gnn, \"weights/LDPC_reg_precomputed.npy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "959ac1d6",
   "metadata": {},
   "source": [
    "## Evaluate Final Performance\n",
    "\n",
    "We now evaluate the performance for different codeword lengths."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c08a030a-5d6a-44da-bd7f-570f59ac139b",
   "metadata": {},
   "outputs": [],
   "source": [
    "for n_eval in params[\"eval_ns\"]:\n",
    "    # generate new code for each length\n",
    "    pcm, k, n, coderate = generate_reg_ldpc(v=params[\"v\"], \n",
    "                                            c=params[\"c\"],  \n",
    "                                            n=n_eval, \n",
    "                                            allow_flex_len=True, \n",
    "                                            verbose=False)\n",
    "\n",
    "    encoder = LinearEncoder(pcm, is_pcm=True)\n",
    "\n",
    "    # simulate \"conventional\" BP performance first\n",
    "    bp_decoder = LDPCBPDecoder(pcm,\n",
    "                               num_iter=params[\"eval_dec_iter\"],\n",
    "                               hard_out=False)\n",
    "    e2e_bp = E2EModel(encoder, bp_decoder, k, n)\n",
    "    ber_plot.simulate(e2e_bp,\n",
    "                      ebno_dbs=ebno_dbs,\n",
    "                      batch_size=params[\"mc_batch_size\"],\n",
    "                      num_target_block_errors=params[\"num_target_block_errors\"],\n",
    "                      legend=f\"BP-{bp_decoder._num_iter.numpy()} n={n}\",\n",
    "                      soft_estimates=True,\n",
    "                      max_mc_iter=params[\"mc_iters\"],\n",
    "                      forward_keyboard_interrupt=False,\n",
    "                      show_fig=False);\n",
    "\n",
    "    # instantiate new decoder for each number of iter (otherwise no retracing)\n",
    "    gnn_dec_temp = GNN_BP(pcm=pcm,\n",
    "                          num_embed_dims=params[\"num_embed_dims\"],\n",
    "                          num_msg_dims=params[\"num_msg_dims\"],\n",
    "                          num_hidden_units=params[\"num_hidden_units\"],\n",
    "                          num_mlp_layers=params[\"num_mlp_layers\"],\n",
    "                          num_iter=params[\"eval_dec_iter\"],\n",
    "                          reduce_op=params[\"reduce_op\"],\n",
    "                          activation=params[\"activation\"],\n",
    "                          output_all_iter=False,\n",
    "                          clip_llr_to=params[\"clip_llr_to\"],\n",
    "                          use_attributes=params[\"use_attributes\"],\n",
    "                          node_attribute_dims=params[\"node_attribute_dims\"],\n",
    "                          msg_attribute_dims=params[\"msg_attribute_dims\"],\n",
    "                          use_bias=params[\"use_bias\"])    \n",
    "    # generate new model   \n",
    "    model = E2EModel(encoder, gnn_dec_temp, k, n)\n",
    "    model(1,1.) # init model\n",
    "    # copy weights from trained decoder\n",
    "    model._decoder.set_weights(gnn_decoder.get_weights())\n",
    "\n",
    "    # and run the BER simulations\n",
    "    ber_plot.simulate(model,\n",
    "                     ebno_dbs=ebno_dbs,\n",
    "                     batch_size=params[\"mc_batch_size\"],\n",
    "                     num_target_block_errors=500,\n",
    "                     legend=f\"GNN-{params['eval_dec_iter']} n={n}\",\n",
    "                     soft_estimates=True,\n",
    "                     max_mc_iter=params[\"mc_iters\"],\n",
    "                     forward_keyboard_interrupt=False,\n",
    "                     show_fig=False);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94323c4b-8f15-44ff-94be-98fc228e64a3",
   "metadata": {},
   "source": [
    "## Add GNN BCH Decoder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "1a814d6e-4815-4218-9be1-e8ae6e5949a5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EbNo [dB] |        BER |       BLER |  bit errors |    num bits | block errors |  num blocks | runtime [s] |    status\n",
      "---------------------------------------------------------------------------------------------------------------------------------------\n",
      "      0.0 | 1.9010e-01 | 1.0000e+00 |       38020 |      200000 |         2000 |        2000 |        13.8 |reached target block errors\n",
      "     0.25 | 1.8003e-01 | 1.0000e+00 |       36006 |      200000 |         2000 |        2000 |         0.1 |reached target block errors\n",
      "      0.5 | 1.7280e-01 | 1.0000e+00 |       34561 |      200000 |         2000 |        2000 |         0.1 |reached target block errors\n",
      "     0.75 | 1.6429e-01 | 1.0000e+00 |       32858 |      200000 |         2000 |        2000 |         0.1 |reached target block errors\n",
      "      1.0 | 1.5651e-01 | 1.0000e+00 |       31302 |      200000 |         2000 |        2000 |         0.1 |reached target block errors\n",
      "     1.25 | 1.4577e-01 | 1.0000e+00 |       29153 |      200000 |         2000 |        2000 |         0.1 |reached target block errors\n",
      "      1.5 | 1.3562e-01 | 1.0000e+00 |       27124 |      200000 |         2000 |        2000 |         0.1 |reached target block errors\n",
      "     1.75 | 1.2796e-01 | 1.0000e+00 |       25592 |      200000 |         2000 |        2000 |         0.1 |reached target block errors\n",
      "      2.0 | 1.1853e-01 | 1.0000e+00 |       23706 |      200000 |         2000 |        2000 |         0.1 |reached target block errors\n",
      "     2.25 | 1.1016e-01 | 1.0000e+00 |       22031 |      200000 |         2000 |        2000 |         0.1 |reached target block errors\n",
      "      2.5 | 1.0251e-01 | 1.0000e+00 |       20502 |      200000 |         2000 |        2000 |         0.1 |reached target block errors\n",
      "     2.75 | 9.3345e-02 | 9.9950e-01 |       18669 |      200000 |         1999 |        2000 |         0.1 |reached target block errors\n",
      "      3.0 | 8.6190e-02 | 1.0000e+00 |       17238 |      200000 |         2000 |        2000 |         0.1 |reached target block errors\n",
      "     3.25 | 7.9090e-02 | 1.0000e+00 |       15818 |      200000 |         2000 |        2000 |         0.1 |reached target block errors\n",
      "      3.5 | 7.2440e-02 | 9.9900e-01 |       14488 |      200000 |         1998 |        2000 |         0.1 |reached target block errors\n",
      "     3.75 | 6.7890e-02 | 1.0000e+00 |       13578 |      200000 |         2000 |        2000 |         0.1 |reached target block errors\n",
      "      4.0 | 6.0255e-02 | 9.9750e-01 |       12051 |      200000 |         1995 |        2000 |         0.1 |reached target block errors\n",
      "     4.25 | 5.4970e-02 | 9.9950e-01 |       10994 |      200000 |         1999 |        2000 |         0.1 |reached target block errors\n",
      "      4.5 | 4.8735e-02 | 9.9500e-01 |        9747 |      200000 |         1990 |        2000 |         0.1 |reached target block errors\n",
      "     4.75 | 4.6035e-02 | 9.8950e-01 |        9207 |      200000 |         1979 |        2000 |         0.1 |reached target block errors\n"
     ]
    }
   ],
   "source": [
    "# define BCH architecture\n",
    "params_bch={\n",
    "    # --- Code Parameters ---\n",
    "        \"code\": \"BCH\", # (63,45)\n",
    "    # --- GNN Architecture ----\n",
    "        \"num_embed_dims\": 20,\n",
    "        \"num_msg_dims\": 20,\n",
    "        \"num_hidden_units\": 40,\n",
    "        \"num_mlp_layers\": 2,\n",
    "        \"num_iter\": 8,\n",
    "        \"reduce_op\": \"mean\",\n",
    "        \"activation\": \"tanh\",\n",
    "        \"clip_llr_to\": 20.,\n",
    "        \"use_attributes\": False,\n",
    "        \"node_attribute_dims\": 0,\n",
    "        \"msg_attribute_dims\": 0,\n",
    "        \"use_bias\": False,\n",
    "}\n",
    "\n",
    "pcm, k, n, coderate = generate_reg_ldpc(v=params[\"v\"], \n",
    "                                            c=params[\"c\"],  \n",
    "                                            n=100, # we only evaluate for n=100\n",
    "                                            allow_flex_len=True, \n",
    "                                            verbose=False)\n",
    "\n",
    "encoder = LinearEncoder(pcm, is_pcm=True)\n",
    "\n",
    "gnn_dec_eval = GNN_BP(pcm=pcm,\n",
    "                      num_embed_dims=params_bch[\"num_embed_dims\"],\n",
    "                      num_msg_dims=params_bch[\"num_msg_dims\"],\n",
    "                      num_hidden_units=params_bch[\"num_hidden_units\"],\n",
    "                      num_mlp_layers=params_bch[\"num_mlp_layers\"],\n",
    "                      num_iter=params[\"eval_dec_iter\"],\n",
    "                      reduce_op=params_bch[\"reduce_op\"],\n",
    "                      activation=params_bch[\"activation\"],\n",
    "                      output_all_iter=False,\n",
    "                      clip_llr_to=params_bch[\"clip_llr_to\"],\n",
    "                      use_attributes=params_bch[\"use_attributes\"],\n",
    "                      node_attribute_dims=params_bch[\"node_attribute_dims\"],\n",
    "                      msg_attribute_dims=params_bch[\"msg_attribute_dims\"],\n",
    "                      use_bias=params_bch[\"use_bias\"])    \n",
    "\n",
    "# generate new model   \n",
    "model = E2EModel(encoder, gnn_dec_eval, k, n)\n",
    "model(1,1.) # init model\n",
    "# copy weights from trained decoder\n",
    "load_weights(model, \"weights/BCH_precomputed.npy\")\n",
    "\n",
    "# and run the BER simulations\n",
    "ber_plot.simulate(model,\n",
    "                  ebno_dbs=ebno_dbs,\n",
    "                  batch_size=params[\"mc_batch_size\"],\n",
    "                  num_target_block_errors=500,\n",
    "                  legend=f\"GNN-{params['eval_dec_iter']} n={n}; BCH weights\",\n",
    "                  soft_estimates=True,\n",
    "                  max_mc_iter=params[\"mc_iters\"],\n",
    "                  forward_keyboard_interrupt=False,\n",
    "                  show_fig=False);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "1eb7ce24-3f08-4c8a-9763-970dc524e23f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1152x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "ber_plot(xlim=[0, 4.5], ylim=[1e-5, 0.2]) # show final figure"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d33de9ce-6c01-4d37-89fe-3ea9a6e406c6",
   "metadata": {},
   "source": [
    "*Remark*: as we use a non-optimized random LDPC code construction, the resulting LDPC code has a significant error-floor.\n",
    "This is an artefact of the code construction method and not a related to the decoder itself."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "3f518bcd-e463-48c0-ab28-4b6a564f3a35",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "snr, \tuncoded, \twbp-20, \tbp_n100, \tgnn_n100, \tbp_n500, \tgnn_n500, \tbp_n1000, \tgnn_n1000, \tgnn_n100_bch, \t\n",
      "0.000,\t7.959000E-02,\t1.305650E-01,\t1.253900E-01,\t1.241400E-01,\t1.293100E-01,\t1.295820E-01,\t1.297725E-01,\t1.302065E-01,\t1.901000E-01,\t\n",
      "0.250,\t7.257500E-02,\t1.173950E-01,\t1.100850E-01,\t1.108750E-01,\t1.171340E-01,\t1.167670E-01,\t1.169960E-01,\t1.187355E-01,\t1.800300E-01,\t\n",
      "0.500,\t6.696000E-02,\t1.023250E-01,\t9.600000E-02,\t9.782000E-02,\t1.003250E-01,\t1.027090E-01,\t1.016290E-01,\t1.041950E-01,\t1.728050E-01,\t\n",
      "0.750,\t6.084000E-02,\t8.967000E-02,\t7.773000E-02,\t8.462500E-02,\t8.144300E-02,\t8.358300E-02,\t8.525500E-02,\t8.699850E-02,\t1.642900E-01,\t\n",
      "1.000,\t5.634000E-02,\t7.527000E-02,\t7.184000E-02,\t6.730500E-02,\t6.439500E-02,\t6.555700E-02,\t6.006900E-02,\t6.715150E-02,\t1.565100E-01,\t\n",
      "1.250,\t5.095000E-02,\t6.033500E-02,\t5.762000E-02,\t5.579000E-02,\t4.378700E-02,\t4.490400E-02,\t3.934700E-02,\t4.264200E-02,\t1.457650E-01,\t\n",
      "1.500,\t4.623000E-02,\t4.872500E-02,\t4.374500E-02,\t4.304000E-02,\t2.583800E-02,\t2.886300E-02,\t1.821025E-02,\t2.249000E-02,\t1.356200E-01,\t\n",
      "1.750,\t4.185000E-02,\t3.636500E-02,\t3.443250E-02,\t3.341000E-02,\t1.442000E-02,\t1.488700E-02,\t7.517875E-03,\t8.235500E-03,\t1.279600E-01,\t\n",
      "2.000,\t3.815500E-02,\t2.491250E-02,\t2.409500E-02,\t2.279000E-02,\t6.766400E-03,\t6.242000E-03,\t2.200889E-03,\t2.225500E-03,\t1.185300E-01,\t\n",
      "2.250,\t3.321500E-02,\t1.756500E-02,\t1.868000E-02,\t1.592000E-02,\t2.762900E-03,\t2.317600E-03,\t5.394545E-04,\t4.485000E-04,\t1.101550E-01,\t\n",
      "2.500,\t2.988000E-02,\t1.163125E-02,\t1.323000E-02,\t1.047750E-02,\t1.075227E-03,\t7.482500E-04,\t1.121743E-04,\t6.488806E-05,\t1.025100E-01,\t\n",
      "2.750,\t2.685500E-02,\t6.985000E-03,\t7.998333E-03,\t6.806250E-03,\t3.755345E-04,\t2.021000E-04,\t2.110368E-05,\t7.129797E-06,\t9.334500E-02,\t\n",
      "3.000,\t2.292500E-02,\t4.203000E-03,\t5.644375E-03,\t3.951000E-03,\t1.168780E-04,\t4.819708E-05,\t3.694000E-06,\t7.115000E-07,\t8.619000E-02,\t\n",
      "3.250,\t1.951000E-02,\t2.308824E-03,\t3.388333E-03,\t2.361875E-03,\t3.763364E-05,\t9.313297E-06,\t8.870000E-07,\t1.510000E-07,\t7.909000E-02,\t\n",
      "3.500,\t1.759500E-02,\t1.327500E-03,\t1.906750E-03,\t1.337308E-03,\t1.207600E-05,\t2.329000E-06,\t1.465000E-07,\t4.900000E-08,\t7.244000E-02,\t\n",
      "3.750,\t1.441500E-02,\t6.490000E-04,\t1.136774E-03,\t7.197917E-04,\t3.270000E-06,\t6.340000E-07,\t5.700000E-08,\t2.000000E-08,\t6.789000E-02,\t\n",
      "4.000,\t1.255000E-02,\t3.509596E-04,\t6.912500E-04,\t3.453333E-04,\t1.117000E-06,\t2.480000E-07,\t2.150000E-08,\t1.550000E-08,\t6.025500E-02,\t\n",
      "4.250,\t1.039500E-02,\t1.683929E-04,\t3.649412E-04,\t1.786538E-04,\t4.370000E-07,\t1.770000E-07,\t2.250000E-08,\t4.000000E-09,\t5.497000E-02,\t\n",
      "4.500,\t8.670000E-03,\t7.736973E-05,\t2.001351E-04,\t9.210345E-05,\t1.540000E-07,\t8.000000E-08,\t4.500000E-09,\t2.000000E-09,\t4.873500E-02,\t\n",
      "4.750,\t7.175000E-03,\t3.703883E-05,\t1.113780E-04,\t5.019231E-05,\t4.800000E-08,\t5.000000E-08,\t3.000000E-09,\t0.000000E+00,\t4.603500E-02,\t\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# save results for pgf plots\n",
    "col_names = [\"uncoded\"]\n",
    "if params[\"simulate_wbp\"]:\n",
    "    col_names.append(\"wbp-20\")\n",
    "for n in params[\"eval_ns\"]:\n",
    "    col_names.append(\"bp_n\" + str(n))\n",
    "    col_names.append(\"gnn_n\" + str(n))\n",
    "col_names.append(\"gnn_n100_bch\")\n",
    "export_pgf(ber_plot, col_names)"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6"
  },
  "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}