SCMA_Python.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "SCMA-Python.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/ekagra-ranjan/Auto-SCMA/blob/main/SCMA_Python.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oDMhaO8y3j24",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f0582f51-d101-4184-e02f-8a3c8f51c04f"
      },
      "source": [
        "import os, random\n",
        "import numpy as np\n",
        "from sklearn.preprocessing import OneHotEncoder\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import torchvision\n",
        "import torchvision.transforms as transforms\n",
        "import matplotlib.pyplot as plt\n",
        "import matplotlib.pyplot as plt2\n",
        "from torch.optim.lr_scheduler import ReduceLROnPlateau\n",
        "import itertools\n",
        "import math\n",
        "\n",
        "torch.autograd.set_detect_anomaly(True)\n",
        "\n",
        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
        "# device = \"cpu\"\n",
        "print(\"\\nDevice:\", device)\n",
        "\n",
        "seed = 6789 # also 0, 6789\n",
        "random.seed(seed)\n",
        "np.random.seed(seed)\n",
        "torch.manual_seed(seed)\n",
        "if device is not \"cpu\":\n",
        "    torch.cuda.manual_seed_all(seed)\n",
        "    torch.cuda.set_rng_state(torch.cuda.get_rng_state())\n",
        "torch.backends.cudnn.deterministic = True\n",
        "torch.backends.cudnn.benchmark = False\n",
        "os.environ['PYTHONHASHSEED'] = str(seed)\n",
        "\n",
        "eps = 1e-8"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Device: cuda:0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "67tG4PIq34FZ"
      },
      "source": [
        "# Number of symbols\n",
        "M = 4\n",
        "# Number of users\n",
        "J = 6\n",
        "# Number of orthogonal resources\n",
        "K = 4\n",
        "\n",
        "'''\n",
        "Throughout the code we will refer Paper 10 as\n",
        "S. Zhang, K. Xiao, B. Xiao, Z. Chen, B. Xia, D. Chen, and S. Ma,\n",
        "“A capacity-based codebook design method for sparse code multiple\n",
        "access systems,” in 2016 8th International Conference on Wireless\n",
        "Communications & Signal Processing (WCSP). IEEE, 2016.\n",
        "\n",
        "and Paper 11 as\n",
        "M. Vaezi, Z. Ding, and H. V. Poor, Multiple access techniques for 5G\n",
        "wireless networks and beyond. Springer, 2019.\n",
        "\n",
        "This naming convention is taken from our paper https://ieeexplore.ieee.org/document/9530173\n",
        "'''\n",
        "\n",
        "# Paper 10: sparse mapping matrix V: K x J\n",
        "V = torch.tensor([[1, 0, 1, 0, 1, 0],\n",
        "                  [0, 1, 1, 0, 0, 1],\n",
        "                  [1, 0, 0, 1, 0, 1],\n",
        "                  [0, 1, 0, 1, 1, 0]\n",
        "            ], dtype = torch.int32, device=device)\n",
        "\n",
        "\n",
        "# Paper 11: sparse mapping matrix V: K x J\n",
        "# V = torch.tensor([[0, 1, 1, 0, 1, 0],\n",
        "#                   [1, 0, 1, 0, 0, 1],\n",
        "#                   [0, 1, 0, 1, 0, 1],\n",
        "#                   [1, 0, 0, 1, 1, 0]\n",
        "#                 ], dtype = torch.int32, device=device)"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PHC0-v_zJ5eU"
      },
      "source": [
        "# paper 10 codebook \n",
        "user_1_code_real = np.array([[ -1.3498, -0.4218, 0.4218, 1.3498],\n",
        "             [0, 0, 0, 0],\n",
        "             [-0.1980, 0.6337, -0.6337, 0.1980],\n",
        "             [0, 0, 0, 0]])\n",
        "user_1_code_imag = np.array([[0, 0, 0, 0],\n",
        "             [0, 0, 0, 0],\n",
        "             [-0.3724, 1.1918, -1.1918, 0.3724],\n",
        "             [ 0, 0, 0, 0]])\n",
        "\n",
        "user_2_code_real = np.array([[0, 0, 0, 0],\n",
        "             [-0.1980, 0.6337, -0.6337, 0.1980],\n",
        "             [0, 0, 0, 0],\n",
        "            [-1.3498, -0.4218, 0.4218, 1.3498]])\n",
        "user_2_code_imag = np.array([[0, 0, 0, 0],\n",
        "             [-0.3724, 1.1918, -1.1918, 0.3724],\n",
        "             [0, 0, 0, 0],\n",
        "             [0, 0, 0, 0]])\n",
        "\n",
        "user_3_code_real = np.array([[-0.6337, -0.1980, 0.1980, 0.6337],\n",
        "             [0.2109, -0.6749, 0.6749, -0.2109],\n",
        "             [0, 0, 0, 0],\n",
        "             [0, 0, 0, 0]])\n",
        "user_3_code_imag = np.array([[-1.1918, -0.3724, 0.3724, 1.1918],\n",
        "             [-0.3653, 1.1690, -1.1690, 0.3653],\n",
        "             [0, 0, 0, 0],\n",
        "             [0, 0, 0, 0]])\n",
        "\n",
        "user_4_code_real = np.array([[0, 0, 0, 0],\n",
        "             [0, 0, 0, 0],\n",
        "             [-1.3498, -0.4218, 0.4218, 1.3498],\n",
        "             [0.2109, -0.6749, 0.6749, -0.2109]])\n",
        "user_4_code_imag = np.array([[0, 0, 0, 0],\n",
        "             [0, 0, 0, 0],\n",
        "             [0, 0, 0, 0],\n",
        "             [-0.3653, 1.1690, -1.1690, 0.3653]])\n",
        "\n",
        "user_5_code_real = np.array([[0.2109, -0.6749, 0.6749, -0.2109],\n",
        "             [0, 0, 0, 0],\n",
        "             [0, 0, 0, 0],\n",
        "             [-0.6337, -0.1980, 0.1980, 0.6337]])\n",
        "user_5_code_imag = np.array([[-0.3653, 1.1690, -1.1690, 0.3653],\n",
        "             [0, 0, 0, 0],\n",
        "             [0, 0, 0, 0],\n",
        "             [-1.1918, -0.3724, 0.3724, 1.1918]])\n",
        "\n",
        "user_6_code_real = np.array([[0, 0, 0, 0],\n",
        "             [ -1.3498, -0.4218, 0.4218, 1.3498],\n",
        "             [0.2109, -0.6749, 0.6749, -0.2109],\n",
        "             [ 0, 0, 0, 0]])\n",
        "user_6_code_imag = np.array([[0, 0, 0, 0],\n",
        "             [0, 0, 0, 0],\n",
        "             [-0.3653, 1.1690, -1.1690, 0.3653],\n",
        "             [ 0, 0, 0, 0]])\n",
        "\n",
        "# Paper 11 scma codebook\n",
        "# user_1_code_real = np.array([[ 0                 , 0                 , 0                 , 0],\n",
        "#              [-0.1815  ,-0.6351  , 0.6351  , 0.1815],\n",
        "#              [ 0                 , 0                 , 0                 , 0],\n",
        "#              [ 0.7851            ,-0.2243            , 0.2243            ,-0.7851 ]])\n",
        "# user_1_code_imag = np.array([[ 0                 , 0                 , 0                 , 0],\n",
        "#              [-0.1318  ,-0.4615  ,0.4615  ,0.1318],\n",
        "#              [ 0                 , 0                 , 0                 , 0],\n",
        "#              [ 0            ,0            , 0            ,0 ]])\n",
        "\n",
        "# user_2_code_real = np.array([[ 0.7851            ,-0.2243            , 0.2243            ,-0.7851],\n",
        "#              [ 0                 , 0                 , 0                 , 0],\n",
        "#              [-0.1815  ,-0.6351  , 0.6351  , 0.1815],\n",
        "#              [ 0                 , 0                 , 0                 , 0 ]])\n",
        "# user_2_code_imag = np.array([[ 0            ,0            , 0            ,0],\n",
        "#              [ 0                 , 0                 , 0                 , 0],\n",
        "#              [-0.1318  ,-0.4615  ,0.4615  ,0.1318],\n",
        "#              [ 0                 , 0                 , 0                 , 0 ]])\n",
        "\n",
        "# user_3_code_real = np.array([[-0.6351  , 0.1815  ,-0.1815  , 0.6351],\n",
        "#              [ 0.1392  , 0.4873  ,-0.4873  ,-0.1392],\n",
        "#              [ 0                 , 0                 , 0                 , 0],\n",
        "#              [ 0                 , 0                 , 0                 , 0 ]])\n",
        "# user_3_code_imag = np.array([[0.4615  ,-0.1318  ,0.1318  ,-0.4615],\n",
        "#              [-0.1759  ,-0.6156  ,0.6156  ,0.1759],\n",
        "#              [ 0                 , 0                 , 0                 , 0],\n",
        "#              [ 0                 , 0                 , 0                 , 0 ]])\n",
        "\n",
        "# user_4_code_real = np.array( [[ 0                 , 0                 , 0                 , 0],\n",
        "#              [ 0                 , 0                 , 0                 , 0],\n",
        "#              [ 0.7851            ,-0.2243            , 0.2243            ,-0.7851],\n",
        "#              [-0.0055  ,-0.0193  , 0.0193  , 0.0055 ]])\n",
        "# user_4_code_imag = np.array([[ 0                 , 0                 , 0                 , 0],\n",
        "#              [ 0                 , 0                 , 0                 , 0],\n",
        "#              [0            ,0            , 0            ,0],\n",
        "#              [-0.2242  ,-0.7848  ,0.7848  ,0.2242 ]])\n",
        "\n",
        "# user_5_code_real = np.array([[-0.0055  ,-0.0193  , 0.0193  , 0.0055],\n",
        "#              [ 0                 , 0                 , 0                 , 0],\n",
        "#              [ 0                 , 0                 , 0                 , 0],\n",
        "#              [-0.6351  , 0.1815  ,-0.1815  , 0.6351 ]])\n",
        "# user_5_code_imag = np.array([[-0.2242  ,-0.7848  ,0.7848  ,0.2242],\n",
        "#              [ 0                 , 0                 , 0                 , 0],\n",
        "#              [ 0                 , 0                 , 0                 , 0],\n",
        "#              [0.4615  ,-0.1318  ,0.1318  ,-0.4615 ]])\n",
        "\n",
        "# user_6_code_real = np.array([[ 0                 , 0                 , 0                 , 0],\n",
        "#              [ 0.7851            ,-0.2243            , 0.2243            ,-0.7851],\n",
        "#              [ 0.1392  , 0.4873  ,-0.4873  ,-0.1392],\n",
        "#              [ 0                 , 0                 , 0                 , 0 ]])\n",
        "# user_6_code_imag = np.array([[ 0                 , 0                 , 0                 , 0],\n",
        "#              [ 0            ,0            , 0            ,0],\n",
        "#              [-0.1759  ,-0.6156  ,0.6156  ,0.1759],\n",
        "#              [ 0                 , 0                 , 0                 , 0 ]])\n",
        "\n",
        "codebook = np.stack([np.stack([user_1_code_real, user_1_code_imag], axis=2), np.stack([user_2_code_real, user_2_code_imag], axis=2),\n",
        "                    np.stack([user_3_code_real, user_3_code_imag], axis=2), np.stack([user_4_code_real, user_4_code_imag], axis=2),\n",
        "                    np.stack([user_5_code_real, user_5_code_imag], axis=2), np.stack([user_6_code_real, user_6_code_imag], axis=2)])\n",
        "codebook = np.transpose(codebook, (0, 2, 1, 3))\n",
        "# codebook shape : [J, M, K, 2]"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ovwCuxyp3_6l"
      },
      "source": [
        "codebook = codebook[:J, :M, :K]\n",
        "codebook = torch.Tensor(codebook).to(device)\n",
        "# codebook shape : [J, M, K, 2]"
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IK7sP8VW33_A"
      },
      "source": [
        "def encode(symbols, codebook, h=None):\n",
        "    '''\n",
        "    Inputs: symbols: [BS, J], h: [BS, J, 2*K], codebook: [J, M, K, 2],\n",
        "    Returns [BS, 2*K]\n",
        "    '''\n",
        "\n",
        "    batch_size = symbols.shape[0]\n",
        "    encoded = torch.zeros((batch_size, 2*K)).to(device)\n",
        "    encoded_without_h = torch.zeros((batch_size, 2*K)).to(device)\n",
        "    \n",
        "    for user in range(J):\n",
        "        # pdb()\n",
        "        codeword = codebook[user][symbols[:, user]-1] # [BS, K, 2]\n",
        "        codeword = codeword * V[:, user].reshape(1, -1, 1) # makes sure that codeword for resources not connected dont exist\n",
        "        codeword = codeword.view(-1, 2*K) # [BS, 2*K]\n",
        "        encoded_without_h = encoded_without_h + codeword\n",
        "        codeword_faded = torch.zeros_like(codeword)\n",
        "        \n",
        "        if h is not None:\n",
        "            '''CORRECT THE MULT WITH H'''\n",
        "            real_idx = 2 * torch.arange(K).long()\n",
        "            img_idx = 2 * torch.arange(K).long() + 1\n",
        "            codeword_faded[:, real_idx] = codeword_faded[:, real_idx] + \\\n",
        "                                          (h[:, user, real_idx] * codeword[:, real_idx]) - \\\n",
        "                                          (h[:, user, img_idx] * codeword[:, img_idx])\n",
        "            codeword_faded[:, img_idx]  = codeword_faded[:, img_idx] + \\\n",
        "                                          (h[:, user, real_idx] * codeword[:, img_idx]) + \\\n",
        "                                          (h[:, user, img_idx] * codeword[:, real_idx])\n",
        "        else:\n",
        "            codeword_faded = codeword_faded + codeword\n",
        "\n",
        "        encoded = encoded + codeword_faded\n",
        "    \n",
        "    return encoded, encoded_without_h"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vGe0ih9BLaMS"
      },
      "source": [
        "def calc_distance(a, b):\n",
        "    '''\n",
        "    Args: a: [BS, 2]    b: [BS, M**df, 2]\n",
        "    Returns: distance: [BS, M**df]\n",
        "    '''\n",
        "    a = a.view(-1, 1, 2)\n",
        "    return ((a-b)**2).sum(-1).squeeze(-1)\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "def get_codebook_centre_resource(codebook, h, resource_id):\n",
        "    '''\n",
        "    Inputs:\n",
        "        codebook: [J, M, K, 2]\n",
        "        h dim: [batch_size, J, 2*K]\n",
        "        V: K x J\n",
        "\n",
        "    Outputs:\n",
        "        centres_all [BS, M**df, 2]: contains the real and img part of\n",
        "                                    codewords for all permutation\n",
        "                                    (i.e., M**df) of user symbols\n",
        "                                    connected to kth resource,\n",
        "                                    i.e., \\sum_{j} h^{T}x_{j}\n",
        "        x_centres_all [BS, M**df, 2*df]: contains the real and img part of\n",
        "                                         each df users in codewords for all\n",
        "                                         permutation (i.e., M**df) of user\n",
        "                                         symbols connected to kth resource, x_{j}\n",
        "    '''\n",
        "    centres_all = torch.zeros((h.shape[0], M**df, 2), device=device)        # [BS, M**df, 2]\n",
        "    x_centres_all = torch.zeros((M**df, 2*df), device=device)               # [M**sd, 2*df]\n",
        "            \n",
        "\n",
        "    #---Create centres_all\n",
        "    resource_user_idx = V[resource_id].nonzero().reshape(-1)\n",
        "    alphabets = np.arange(1, M+1)\n",
        "    symbols_resource = [torch.tensor(p) for p in itertools.product(alphabets, repeat=df)] \n",
        "    symbols_resource = torch.stack(symbols_resource).to(device)             # [M**df, df]\n",
        "\n",
        "    symbols_resource.unsqueeze_(0)                                          # [1, M**df, df]\n",
        "    symbols_resource = symbols_resource.repeat(h.shape[0], 1, 1)            # [BS, M**df, df]\n",
        "    \n",
        "    symbols_resource_all = torch.zeros((M**df, J),\\\n",
        "                                        dtype = torch.int64, device=device) # [M**df, J]\n",
        "    symbols_resource_all[:, resource_user_idx] = symbols_resource[0]        # [M**df, J]\n",
        "    \n",
        "    h_repeat_perm = h.unsqueeze(1).repeat(1, M**df, 1, 1)                   # [BS, M**df, J, 2*K]\n",
        "    h_repeat_perm = h_repeat_perm.view(-1, J, 2*K)                          # [BS * M**df, J, 2*K]\n",
        "    \n",
        "     \n",
        "    symbols_resource = symbols_resource.view(-1, df)                        # [BS * M**df, df]\n",
        "    codeword_faded_k = torch.zeros((symbols_resource.shape[0], 2), device=device)\n",
        "    \n",
        "    for user_idx, user in enumerate(resource_user_idx):\n",
        "        codeword = codebook[user][symbols_resource[:, user_idx]-1]          # [BS, K, 2]\n",
        "        codeword_k = codeword[:, resource_id, :]                            # [BS, 2]\n",
        "        codeword_k = codeword_k * V[resource_id, user] # makes sure that codeword for resources not connected dont exist\n",
        "        \n",
        "        '''CORRECT THE MULT WITH H'''\n",
        "        real_idx = 2 * resource_id\n",
        "        img_idx = 2 * resource_id + 1\n",
        "        codeword_faded_k[:, 0] = codeword_faded_k[:, 0] + \\\n",
        "                                        (h_repeat_perm[:, user, real_idx] * codeword_k[:, 0]) - \\\n",
        "                                        (h_repeat_perm[:, user, img_idx] * codeword_k[:, 1])\n",
        "        codeword_faded_k[:, 1]  = codeword_faded_k[:, 1] + \\\n",
        "                                        (h_repeat_perm[:, user, real_idx] * codeword_k[:, 1]) + \\\n",
        "                                        (h_repeat_perm[:, user, img_idx] * codeword_k[:, 0])\n",
        "    \n",
        "    centres_all[:, :, :] = codeword_faded_k.view(h.shape[0], M**df, 2) \n",
        "    \n",
        "\n",
        "    # ---Create x_centres_all\n",
        "    symbols_resource_all = symbols_resource_all.unsqueeze(1).repeat(1, df, 1) # [M**df, df, J]\n",
        "    symbols_resource_all = symbols_resource_all.view(-1, J)                 # [M**df * df, J]\n",
        "    h_x = torch.zeros((df, J, 2*K), device=device)                          # [df, J, 2*K]\n",
        "    real_idx = 2 * torch.arange(K).long()\n",
        "    temp = torch.zeros((2*K), device=device)\n",
        "    temp[real_idx] = 1.0\n",
        "    \n",
        "    for idx, val in enumerate(V[resource_id].nonzero().reshape(-1)):\n",
        "        h_x[idx, val, :] = temp\n",
        "    \n",
        "    h_x = h_x.view(1, df, J, 2*K)\n",
        "    h_x = h_x.repeat(M**df, 1, 1, 1)                                        # [M**df, df, J, 2*K]\n",
        "    h_x = h_x.view(-1, J, 2*K)\n",
        "    x_centres, _ = encode(symbols_resource_all, codebook, h=h_x)            # [M**df * df, 2*K]\n",
        "    x_centres = x_centres.view(M**df, df,2*K)\\\n",
        "                [:, :, 2 * resource_id: 2 * resource_id + 2]                # [M**df, df, 2]\n",
        "    x_centres = x_centres.reshape(M**df, 2 * df)\n",
        "    x_centres_all[:, :] = x_centres\n",
        "    \n",
        "    return centres_all, x_centres_all"
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ngnDFBGaDbBe"
      },
      "source": [
        "df = (V[0]==1).sum() # num of users connected to kth resource\n",
        "dv = (V.t()[0]==1).sum() # num of resources connected to jth user\n",
        "\n",
        "\n",
        "class MPA():\n",
        "\n",
        "    def resource_to_user(self, x, u2r, codebook, h, sigma_square, beta):\n",
        "        '''\n",
        "        Inputs:  x: [BS, 2*K] , i.e., received signal, u2r: [BS, J, K, M], h: [BS, J, 2*K]\n",
        "        Output: [BS, K, J, M]\n",
        "        '''\n",
        "\n",
        "        message_all = torch.zeros((h.shape[0], K, J, M), device=device)\n",
        "        \n",
        "        for i in range(0, K):\n",
        "            '''\n",
        "            centres_all: [batch_size, M**df, 2]\n",
        "            x_centres_all: [BS, M**df, 2*df]\n",
        "            '''\n",
        "            centres_all, x_centres_all = get_codebook_centre_resource(codebook, h, i)\n",
        "            x_centres_all = x_centres_all.view(1, M**df, df, 2) # [1, M**df, df, 2]\n",
        "\n",
        "            distance = calc_distance(x[:, 2*i:2*i+2], centres_all) # distance([BS, 2], [BS, M**df, 2]) -> [BS, M**df]\n",
        "            distance = - (1.0/(2.0 * sigma_square)) * distance\n",
        "            assert distance.dtype == torch.float32, \"distance is not float32\"\n",
        "            M_k = torch.zeros((h.shape[0], J, M), device=device) # conditional prob of x_{j} given r_{k}\n",
        "\n",
        "            u2r_ = u2r.permute(0, 2, 1, 3) # [BS, K, J, M]\n",
        "\n",
        "\n",
        "            '''Check from here'''\n",
        "            alphabets = np.arange(0, M)\n",
        "            symbols_resource = [torch.tensor(p) for p in itertools.product(alphabets, repeat=df)] \n",
        "            symbols_resource = torch.stack(symbols_resource) # [M**df, df]\n",
        "            \n",
        "            u2r_resource = u2r_[:, i, V[i]==1] # [BS, df, M]\n",
        "            prior_big = torch.zeros((h.shape[0], M**df, df), device=device) # [BS, M**df, df]\n",
        "\n",
        "            for df_idx in range(df):\n",
        "                \n",
        "                # if df_idx == idx: # do not add the current user message\n",
        "                #     continue\n",
        "                \n",
        "                u2r_resource_df = u2r_resource[:, df_idx, :] # [BS, M]\n",
        "                u2r_resource_df = u2r_resource_df.reshape(1, -1) # [1, BS * M]\n",
        "                symbols_resource_df = symbols_resource[:, df_idx].unsqueeze(0).repeat(h.shape[0], 1) # [BS, M**df]\n",
        "                incrementor = torch.arange(0, M * h.shape[0], M).view(-1, 1) # [BS, 1]\n",
        "                symbols_resource_df_mask = symbols_resource_df + incrementor # [BS, M**df]\n",
        "                symbols_resource_df_mask = symbols_resource_df_mask.view(1, -1) # [1, BS * M**df]\n",
        "                prior_big_df = u2r_resource_df[0, symbols_resource_df_mask] # [1, BS * M**df]\n",
        "                prior_big_df = prior_big_df.view(-1, M**df) # [BS, M**df]\n",
        "                prior_big[:, :, df_idx] = prior_big_df # [BS, M**df, df]\n",
        "\n",
        "            prior_big_sum = prior_big.sum(-1) # [BS, M**df]\n",
        "            \n",
        "            user_idx = (V[i]).nonzero().reshape(-1)\n",
        "            \n",
        "            for idx, j in enumerate(user_idx):    \n",
        "                '''Careful: codebook is [J, M, K, 2] which is numpy'''\n",
        "                df_unique = codebook[j, :, i, :] # [M, 2]\n",
        "                x_centres_all_temp = x_centres_all[:, :, idx] # [1, M**df, 2]\n",
        "                assert df_unique.dtype == x_centres_all_temp.dtype, \"comparison vars dont have same dtype for mask_temp\"\n",
        "\n",
        "                mask_temp = (df_unique.view(1, M, 1, 2) == x_centres_all_temp.view(1, 1, M**df, 2)) # [1, M, M**df, 2]\n",
        "                mask = (mask_temp.sum(-1)==2) # [1, M, M**df]: for matching, both real and img parts will match hence 2.\n",
        "                mask = mask.repeat(h.shape[0], 1, 1) # [BS, M, M**df]\n",
        "\n",
        "                prior_big_m = prior_big_sum - prior_big[:, :, idx] # [BS, M**df]\n",
        "                message = distance + prior_big_m # [BS, M**df]\n",
        "                lowest_message = message.min()\n",
        "\n",
        "                message = message.unsqueeze(1).repeat(1, M, 1) # [BS, M, M**df]\n",
        "                message = torch.where(mask, message, lowest_message) # [BS, M, M**df]\n",
        "                \n",
        "                #---log-sum-MPA\n",
        "                message_max = message.max(-1)[0] # [BS, M]: 0 is used to use take the max and not the indices\n",
        "                message = message - message_max.view(-1, M, 1)\n",
        "                message = torch.exp(message) # [BS, M, M**df]\n",
        "                message = torch.where(mask, message, torch.tensor([0.0], device=device))\n",
        "                message = message.sum(-1) # [BS, M]\n",
        "                \n",
        "                message = torch.log(message) # [BS, M]\n",
        "                message = message + message_max # [BS, M]\n",
        "                \n",
        "                #---Max log MPA\n",
        "                # message = message.max(-1)[0] # [BS]: 0 is used to use take the max and not the indices\n",
        "                \n",
        "                message_all[:, i, j] = message + beta\n",
        "                 \n",
        "        return message_all\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "    def user_to_resource(self, r2u, gamma):\n",
        "        '''\n",
        "        Input: r2u: [BS, K, J, M]\n",
        "        Returns [BS, J, K, M]\n",
        "        '''\n",
        "        assert (r2u == float(\"-inf\")).sum() == 0, \"r2u has -inf values!\" # if -inf, then need to implement the counting of -inf freq\n",
        "\n",
        "        message_all = torch.zeros((r2u.shape[0], J, K, M), device=device)\n",
        "        r2u_ = r2u.permute(0, 2, 1, 3) # [BS, J, K, M]\n",
        "        # to filter out messages to those resources which are not onnected to the user\n",
        "        mask = torch.where(r2u_!=0, torch.tensor([1.0], device=device), torch.tensor([0.0], device=device))\n",
        "\n",
        "        ''' Need to change'''\n",
        "        message_all = -r2u_ # [BS, J, K, M]\n",
        "        for i in range(J):\n",
        "            message_all[:, i, :, :] = message_all[:, i, :, :] + r2u_[:, i].sum(-2).view(-1, 1, M) + gamma # [BS, 1, M]\n",
        "        message_all = mask * message_all\n",
        "        \n",
        "        #---normalisation\n",
        "\n",
        "        Z = torch.exp(message_all)\n",
        "        Z = torch.where(message_all!=0, Z, torch.tensor([torch.exp(-gamma) / M], device=device)) # [BS, J, K, M]\n",
        "        Z = torch.log(Z.sum(-1))\n",
        "\n",
        "        message_all = message_all - Z.view(-1, J, K, 1) # [BS, J, K, M]\n",
        "\n",
        "        return message_all\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "    def calc_output(self, r2u):\n",
        "        '''\n",
        "        Input: r2u: [BS, K, J, M]\n",
        "        Output: [BS, J, M]\n",
        "        '''\n",
        "        r2u_ = r2u.permute(0, 2, 3, 1) # [BS, J, M, K]\n",
        "        return r2u_.sum(-1) + gamma\n",
        "\n",
        "\n",
        "\n",
        "    def forward(self, x, codebook, h, sigma_square, beta, gamma):\n",
        "        ''' \n",
        "        Inputs:\n",
        "        x: [BS, 2*K] , i.e., received signal\n",
        "        h: [BS, J, 2*K]\n",
        "\n",
        "        Variables used:\n",
        "        u2r [BS, J, K, M]: user to resource message\n",
        "        r2u [BS, K, J, M]: resource to user message\n",
        "        '''\n",
        "        \n",
        "        u2r = torch.zeros((x.shape[0], J, K, M), device=device) # Initialise u2r with 0\n",
        "        u2r = u2r + gamma\n",
        "        \n",
        "        r2u = self.resource_to_user(x, u2r, codebook, h, sigma_square, beta) # [BS, K, J, M]\n",
        "        u2r = self.user_to_resource(r2u, gamma) # [BS, J, K, M]\n",
        "        \n",
        "        for i in range(n_iter - 1):\n",
        "            r2u = self.resource_to_user(x, u2r, codebook, h, sigma_square, beta) # [BS, K, J, M]\n",
        "            u2r = self.user_to_resource(r2u, gamma) # [BS, J, K, M]\n",
        "        \n",
        "        y = self.calc_output(r2u)\n",
        "        return y"
      ],
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "J14v_J1_330_"
      },
      "source": [
        "def add_noise(codewords, J, snr):\n",
        "    '''\n",
        "    codewords: [batch_size, 2*K]\n",
        "    snr: scalar\n",
        "    '''\n",
        "    batch_size = codewords.shape[0]\n",
        "    Es = torch.mean(codewords**2) # per real value or img value\n",
        "    Es_db = 10*torch.log10(Es)\n",
        "    noise_db = Es_db - torch.as_tensor(snr).to(device)\n",
        "    noise_power = 10**(noise_db/10)\n",
        "    noise = torch.randn(batch_size, 2*K).to(device) * torch.sqrt(noise_power).to(device)\n",
        "    output = codewords + noise\n",
        "\n",
        "    return noise, noise_power"
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HkcaPNWb33xj"
      },
      "source": [
        "def compute_ber(symbols, decoded_symbols, M):\n",
        "    '''\n",
        "    Inputs: symbols, decoded_symbols: [BS*J]\n",
        "    '''\n",
        "    symbols_0 = symbols - 1\n",
        "    decoded_symbols_0 = decoded_symbols - 1\n",
        "    true = np.unpackbits(symbols_0.reshape(-1, 1).astype('uint8'), axis=1)[:, -int(np.log2(M)):] # [BS*J, log2(M)]\n",
        "    predicted = np.unpackbits(decoded_symbols_0.reshape(-1, 1).astype('uint8'), axis=1)[:, -int(np.log2(M)):] # [BS*J, log2(M)]\n",
        "\n",
        "    Nerr_check = (true!=predicted) # [BS*J, log2(M)]\n",
        "    ber_batch = (true!=predicted).mean() # [1]\n",
        "    \n",
        "    Nerr_per_user = np.sum(Nerr_check, axis=-1) # [BS*J]\n",
        "    Nerr_per_user = np.sum(Nerr_per_user.reshape(-1, J), axis=0) # [J]\n",
        "    \n",
        "\n",
        "    return ber_batch, Nerr_per_user"
      ],
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "F_5LZkaD33t8"
      },
      "source": [
        "batch_size = 10000\n",
        "n_iter = 3\n",
        "df = (V[0]==1).sum() # num of users connected to a resource (needs to be same for all resources)\n",
        "dv = (V[:, 0]==1).sum() # num of resources connected to a user (needs to be same for all users)\n",
        "\n",
        "#---Create MPA\n",
        "mpa = MPA()"
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xBlwYUQh33rp",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "13b67d00-fac0-4b62-f2ab-150e557c2b61"
      },
      "source": [
        "symbols = np.random.randint(1, M+1, (batch_size, J))\n",
        "enc = OneHotEncoder(categories=np.stack(J*[range(1,M+1)]))\n",
        "_ = enc.fit(symbols)"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/sklearn/preprocessing/_encoders.py:76: FutureWarning: elementwise comparison failed; returning scalar instead, but in the future will perform elementwise comparison\n",
            "  if self.categories != 'auto':\n",
            "/usr/local/lib/python3.7/dist-packages/sklearn/preprocessing/_encoders.py:85: FutureWarning: elementwise comparison failed; returning scalar instead, but in the future will perform elementwise comparison\n",
            "  if self.categories == 'auto':\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jSDMB-mksikk",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9610319d-291c-43eb-e046-a9c1e573d4e0"
      },
      "source": [
        "#---Testing\n",
        "is_fading = False # controls fading\n",
        "is_noise  = True # controls AWGN \n",
        "EbN = np.arange(0, 15+1)\n",
        "\n",
        "accuracy_all = np.zeros_like(EbN ,dtype=np.float64)\n",
        "ber_all = np.zeros_like(EbN ,dtype=np.float64)\n",
        "test_samples = 10000\n",
        "steps = 10 # total_samples = step * test_samples\n",
        "\n",
        "maxNumErrs = 100 # min number of bits error to be seen before ending the run\n",
        "maxNumBits = 1e7 # max number of bits per user to be processed\n",
        "\n",
        "with torch.no_grad():\n",
        "    for i, ebn in enumerate(EbN):\n",
        "\n",
        "        Nerr_per_user = np.zeros([J])\n",
        "        Nbits = 0 # number of bits processed till now\n",
        "        accuracy_ebn = []\n",
        "        wrong_symbols_ebn = []\n",
        "        ber_ebn = []\n",
        "        wrong_bits_ebn = []\n",
        "\n",
        "        # steps = test_samples // 10000\n",
        "        step = 1\n",
        "\n",
        "        # NOTE: Use the 1st while condition when using AWGN for faster results\n",
        "        while(step <= steps):\n",
        "        # while( (Nerr_per_user.min() < maxNumErrs) and (Nbits < maxNumBits) ):\n",
        "        \n",
        "            step = step + 1\n",
        "\n",
        "            snr = ebn + 10*np.log10(np.log2(M)*J/K)\n",
        "\n",
        "            # codebook = get_codebook_from_condensed_codebook()\n",
        "\n",
        "            #---Generate symbols and channel parameters\n",
        "            symbols = np.random.randint(1, M+1, (test_samples, J))\n",
        "            symbols_one_hot = torch.Tensor(enc.transform(symbols).toarray().reshape((test_samples, J, M))).to(device) # [test_samples, J, M]\n",
        "\n",
        "            #---Fading\n",
        "            if is_fading is True:\n",
        "                h = (torch.randn(test_samples, J, 2*K)/torch.sqrt(torch.tensor(2.0))).to(device)\n",
        "            else:\n",
        "                h = torch.zeros(test_samples, J, 2*K).to(device)\n",
        "                real_idx = 2 * torch.arange(K).long()\n",
        "                h[:, :, real_idx] = 1.0\n",
        "                \n",
        "            #---Encode\n",
        "            codewords_faded, codewords_faded_without_h = encode(symbols, codebook, h = h)    \n",
        "            received_signal = codewords_faded\n",
        "            \n",
        "            #---Noise\n",
        "            '''noise is being calc using codewords_faded_without_h '''\n",
        "            noise, sigma_square = add_noise(codewords_faded_without_h, J, snr)\n",
        "            \n",
        "            if is_noise is True:\n",
        "                received_signal = received_signal + noise\n",
        "            \n",
        "\n",
        "            #---Decode\n",
        "            beta = torch.log((1/(2* math.pi * sigma_square)**0.5))\n",
        "            gamma = torch.log(torch.tensor((1.0/M), device=device, dtype=torch.float32)) # log(p_x{j})\n",
        "            decoded_symbols_one_hot = mpa.forward(received_signal, codebook, h, sigma_square, beta, gamma)\n",
        "            \n",
        "            \n",
        "            #---Compute metrics\n",
        "            decoded_symbols = torch.argmax(decoded_symbols_one_hot, dim=-1) + 1\n",
        "            accuracy_batch = np.mean(symbols == decoded_symbols.cpu().data.numpy())\n",
        "            wrong_symbols_batch = (symbols != decoded_symbols.cpu().data.numpy()).sum()\n",
        "            ber_batch, Nerr_per_user = compute_ber(symbols.reshape(test_samples*J), decoded_symbols.cpu().data.numpy().reshape(test_samples*J), M)\n",
        "            wrong_bits_batch = Nerr_per_user.sum()\n",
        "\n",
        "            accuracy_ebn.append(accuracy_batch)\n",
        "            wrong_symbols_ebn.append(wrong_symbols_batch)\n",
        "            ber_ebn.append(ber_batch)\n",
        "            wrong_bits_ebn.append(wrong_bits_batch)\n",
        "\n",
        "            Nerr_per_user += Nerr_per_user\n",
        "            Nbits += test_samples * np.log2(M)\n",
        "\n",
        "        accuracy = np.array(accuracy_ebn).mean()\n",
        "        wrong_symbols = np.array(wrong_symbols_ebn).sum()\n",
        "        ber = np.array(ber_ebn).mean()\n",
        "        wrong_bits = np.array(wrong_bits_ebn).sum()\n",
        "        accuracy_all[i] = accuracy\n",
        "        ber_all[i] = ber\n",
        "\n",
        "        print(\"EbN:\", ebn, ' Acc: {:.8f}'.format(accuracy),\n",
        "            ' SER: {:.8f}'.format(1-accuracy),'BER: {:.8f}'.format(ber),\n",
        "            ' Wrong Symbols: ', wrong_symbols, '/', test_samples*steps*J,\n",
        "            ' Wrong Bits: ', wrong_bits, '/', test_samples*steps*J*np.log2(M))\n"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "EbN: 0  Acc: 0.72987500  SER: 0.27012500 BER: 0.14854083  Wrong Symbols:  162075 / 600000  Wrong Bits:  178249 / 1200000.0\n",
            "EbN: 1  Acc: 0.76745500  SER: 0.23254500 BER: 0.12864500  Wrong Symbols:  139527 / 600000  Wrong Bits:  154374 / 1200000.0\n",
            "EbN: 2  Acc: 0.80808333  SER: 0.19191667 BER: 0.10695083  Wrong Symbols:  115150 / 600000  Wrong Bits:  128341 / 1200000.0\n",
            "EbN: 3  Acc: 0.85187333  SER: 0.14812667 BER: 0.08359667  Wrong Symbols:  88876 / 600000  Wrong Bits:  100316 / 1200000.0\n",
            "EbN: 4  Acc: 0.89292667  SER: 0.10707333 BER: 0.06091000  Wrong Symbols:  64244 / 600000  Wrong Bits:  73092 / 1200000.0\n",
            "EbN: 5  Acc: 0.92835500  SER: 0.07164500 BER: 0.04091000  Wrong Symbols:  42987 / 600000  Wrong Bits:  49092 / 1200000.0\n",
            "EbN: 6  Acc: 0.95593500  SER: 0.04406500 BER: 0.02518667  Wrong Symbols:  26439 / 600000  Wrong Bits:  30224 / 1200000.0\n",
            "EbN: 7  Acc: 0.97499167  SER: 0.02500833 BER: 0.01421333  Wrong Symbols:  15005 / 600000  Wrong Bits:  17056 / 1200000.0\n",
            "EbN: 8  Acc: 0.98776833  SER: 0.01223167 BER: 0.00695000  Wrong Symbols:  7339 / 600000  Wrong Bits:  8340 / 1200000.0\n",
            "EbN: 9  Acc: 0.99383833  SER: 0.00616167 BER: 0.00339250  Wrong Symbols:  3697 / 600000  Wrong Bits:  4071 / 1200000.0\n",
            "EbN: 10  Acc: 0.99719167  SER: 0.00280833 BER: 0.00155417  Wrong Symbols:  1685 / 600000  Wrong Bits:  1865 / 1200000.0\n",
            "EbN: 11  Acc: 0.99883000  SER: 0.00117000 BER: 0.00061667  Wrong Symbols:  702 / 600000  Wrong Bits:  740 / 1200000.0\n",
            "EbN: 12  Acc: 0.99956167  SER: 0.00043833 BER: 0.00023333  Wrong Symbols:  263 / 600000  Wrong Bits:  280 / 1200000.0\n",
            "EbN: 13  Acc: 0.99978667  SER: 0.00021333 BER: 0.00010750  Wrong Symbols:  128 / 600000  Wrong Bits:  129 / 1200000.0\n",
            "EbN: 14  Acc: 0.99987667  SER: 0.00012333 BER: 0.00006167  Wrong Symbols:  74 / 600000  Wrong Bits:  74 / 1200000.0\n",
            "EbN: 15  Acc: 0.99992000  SER: 0.00008000 BER: 0.00004000  Wrong Symbols:  48 / 600000  Wrong Bits:  48 / 1200000.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wcK9bak8wTqB",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 545
        },
        "outputId": "ffa784a8-f0fc-40a3-c44c-f77ff6278c01"
      },
      "source": [
        "#---Plot Metrics across different channels\n",
        "ymin = 1e-3\n",
        "ymax = 1e-0\n",
        "xmin = EbN[0]\n",
        "xmax = EbN[-1]\n",
        "\n",
        "\n",
        "f1 = plt.figure()\n",
        "f2 = plt.figure()\n",
        "\n",
        "ax1 = f1.add_subplot(111)\n",
        "ax1.set_title('SER vs EbN')\n",
        "ax1.set_yscale('log')\n",
        "ax1.set_ylim([ymin,ymax])\n",
        "# ax1.set_xlim([xmin,xmax])\n",
        "ax1.set_xticks(EbN)\n",
        "ax1.grid(which=\"both\")\n",
        "ax1.plot(EbN, 1-accuracy_all, '-or')\n",
        "\n",
        "ax2 = f2.add_subplot(111)\n",
        "ax2.set_title('BER vs EbN')\n",
        "ax2.set_yscale('log')\n",
        "ax2.set_ylim([ymin,ymax])\n",
        "# ax1.set_xlim([xmin,xmax])\n",
        "ax2.set_xticks(EbN)\n",
        "ax2.grid(which=\"both\")\n",
        "ax2.plot(EbN, ber_all, '-or')\n",
        "plt.show()"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hAxxnJeHG9An"
      },
      "source": [
        ""
      ],
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "S7_MDz6szq8m",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "aeddcd21-7427-4982-8569-9a8516372e10"
      },
      "source": [
        "#---See the learned Codebook\n",
        "batch_size_plot = M\n",
        "symbols = np.arange(M)+1\n",
        "symbols = np.stack(J*[symbols], axis=0).transpose()\n",
        "\n",
        "#---Get codebook\n",
        "# codebook = get_codebook_from_condensed_codebook()\n",
        "\n",
        "h_all = []\n",
        "real_idx = 2 * torch.arange(K).long()\n",
        "\n",
        "for i in range(J):\n",
        "  h = np.zeros([J, 2*K])\n",
        "#   h[i, :] = np.ones([1, 2*K])\n",
        "  h[i, real_idx] = 1.0\n",
        "  h = np.stack(batch_size_plot*[h], axis = 0)\n",
        "  h = torch.Tensor(h).to(device)\n",
        "  h_all.append(h)\n",
        "\n",
        "\n",
        "#---Forward Pass\n",
        "codewords_faded_all = []\n",
        "for i in range(J):\n",
        "    codewords_faded, codewords_faded_without_h = encode(symbols, codebook, h = h_all[i])\n",
        "    codewords_faded_all.append(codewords_faded)\n",
        "\n",
        "\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "#---code for color assignment for arbitrary num of users\n",
        "# user_colors = {}\n",
        "# users = np.arange(J)\n",
        "# unique_users = list(set(users)) \n",
        "# step_size = (256**3) // len(unique_users)\n",
        "# for i, user in enumerate(unique_users):\n",
        "#     temp = step_size*i\n",
        "#     color = np.zeros([3], dtype=np.float32) # RGB\n",
        "#     for pigment in range(3):\n",
        "#       r = temp % 256\n",
        "#       color[pigment] = r/256\n",
        "#       temp = temp//256\n",
        "#     user_colors[user] = color.tolist()\n",
        "# colors = [user_colors[user] for user in users]\n",
        "\n",
        "colors = ['cyan', 'green', 'blue', 'magenta', 'orange', 'red']\n",
        "\n",
        "for k in range(K):\n",
        "  fig, ax = plt.subplots()\n",
        "  for user in range(J):\n",
        "    data = codewords_faded_all[user].cpu().detach().numpy()\n",
        "    if np.abs(data[:, 2*k]).sum()!=0:\n",
        "    #   pdb()\n",
        "      ax.scatter(data[:, 2*k], data[:, 2*k+1], c=colors[user], label='User '+str(user+1))\n",
        "#   pdb()\n",
        "  ax.legend()\n",
        "  ax.axhline(y=0, color='k')\n",
        "  ax.axvline(x=0, color='k')\n",
        "  ax.set_title('Resource: '+str(k+1))\n",
        "  ax.imshow"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RXwnOW9CXhVF"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}