{
"cells": [
{
"cell_type": "markdown",
"id": "f543de9b-3858-45dd-bddf-cddddcc60da3",
"metadata": {},
"source": [
"# Part 4: Toward Learned Receivers"
]
},
{
"cell_type": "markdown",
"id": "c55670f1-3ee6-481d-9661-d59e61074818",
"metadata": {},
"source": [
"This tutorial will guide you through Sionna, from its basic principles to the implementation of a point-to-point link with a 5G NR compliant code and a 3GPP channel model.\n",
"You will also learn how to write custom trainable layers by implementing a state of the art neural receiver, and how to train and evaluate end-to-end communication systems.\n",
"\n",
"The tutorial is structured in four notebooks:\n",
"\n",
"- Part I: Getting started with Sionna\n",
"\n",
"- Part II: Differentiable Communication Systems\n",
"\n",
"- Part III: Advanced Link-level Simulations\n",
"\n",
"- **Part IV: Toward Learned Receivers**"
]
},
{
"cell_type": "markdown",
"id": "3c13c44e",
"metadata": {},
"source": [
"The [official documentation](https://nvlabs.github.io/sionna/index.html) provides key material on how to use Sionna and how its components are implemented."
]
},
{
"cell_type": "markdown",
"id": "d7c4211f-beee-4142-9289-c385d0180877",
"metadata": {},
"source": [
"* [Imports](#Imports)\n",
"* [Simulation Parameters](#Simulation-Parameters)\n",
"* [Implemention of an Advanced Neural Receiver](#Implemention-of-an-Advanced-Neural-Receiver)\n",
"* [Training the Neural Receiver](#Training-the-Neural-Receiver)\n",
"* [Benchmarking the Neural Receiver](#Benchmarking-the-Neural-Receiver)\n",
"* [Conclusion](#Conclusion)"
]
},
{
"cell_type": "markdown",
"id": "74a184ac-1f64-407f-9a24-c53d40799be2",
"metadata": {},
"source": [
"## Imports"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d84bd69e-59f2-4a42-8dd3-730c8c1d821e",
"metadata": {
"execution": {
"iopub.execute_input": "2026-02-13T15:21:38.971837Z",
"iopub.status.busy": "2026-02-13T15:21:38.971728Z",
"iopub.status.idle": "2026-02-13T15:21:41.806484Z",
"shell.execute_reply": "2026-02-13T15:21:41.805510Z"
}
},
"outputs": [],
"source": [
"# Import Sionna\n",
"try:\n",
" import sionna.phy\n",
"except ImportError as e:\n",
" import os\n",
" import sys\n",
" if 'google.colab' in sys.modules:\n",
" # Install Sionna in Google Colab\n",
" print(\"Installing Sionna and restarting the runtime. Please run the cell again.\")\n",
" os.system(\"pip install sionna\")\n",
" os.kill(os.getpid(), 5)\n",
" else:\n",
" raise e\n",
"\n",
"import torch\n",
"import torch.nn as nn\n",
"import torch.nn.functional as F\n",
"\n",
"import numpy as np\n",
"\n",
"# For plotting\n",
"%matplotlib inline\n",
"import matplotlib.pyplot as plt\n",
"\n",
"# Sionna imports\n",
"from sionna.phy import Block\n",
"from sionna.phy.channel.tr38901 import Antenna, AntennaArray, CDL\n",
"from sionna.phy.channel import OFDMChannel\n",
"from sionna.phy.mimo import StreamManagement\n",
"from sionna.phy.ofdm import (ResourceGrid, ResourceGridMapper, LSChannelEstimator,\n",
" LMMSEEqualizer, ResourceGridDemapper)\n",
"from sionna.phy.utils import ebnodb2no, insert_dims, expand_to_rank, PlotBER\n",
"from sionna.phy.fec.ldpc import LDPC5GEncoder, LDPC5GDecoder\n",
"from sionna.phy.mapping import Mapper, Demapper, BinarySource\n",
"\n",
"# Set seed for reproducible random number generation\n",
"sionna.phy.config.seed = 42\n",
"device = sionna.phy.config.device"
]
},
{
"cell_type": "markdown",
"id": "64d17183",
"metadata": {},
"source": [
"## Simulation Parameters"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "4dea9622",
"metadata": {
"execution": {
"iopub.execute_input": "2026-02-13T15:21:41.808729Z",
"iopub.status.busy": "2026-02-13T15:21:41.808448Z",
"iopub.status.idle": "2026-02-13T15:21:42.099625Z",
"shell.execute_reply": "2026-02-13T15:21:42.098713Z"
}
},
"outputs": [],
"source": [
"# Bit per channel use\n",
"NUM_BITS_PER_SYMBOL = 2 # QPSK\n",
"\n",
"# Minimum value of Eb/N0 [dB] for simulations\n",
"EBN0_DB_MIN = -3.0\n",
"\n",
"# Maximum value of Eb/N0 [dB] for simulations\n",
"EBN0_DB_MAX = 5.0\n",
"\n",
"# How many examples are processed by Sionna in parallel\n",
"BATCH_SIZE = 128\n",
"\n",
"# Coding rate\n",
"CODERATE = 0.5\n",
"\n",
"# Define the number of UT and BS antennas\n",
"NUM_UT = 1\n",
"NUM_BS = 1\n",
"NUM_UT_ANT = 1\n",
"NUM_BS_ANT = 2\n",
"\n",
"# The number of transmitted streams is equal to the number of UT antennas\n",
"# in both uplink and downlink\n",
"NUM_STREAMS_PER_TX = NUM_UT_ANT\n",
"\n",
"# Create an RX-TX association matrix.\n",
"# RX_TX_ASSOCIATION[i,j]=1 means that receiver i gets at least one stream\n",
"# from transmitter j. Depending on the transmission direction (uplink or downlink),\n",
"# the role of UT and BS can change.\n",
"# For example, considering a system with 2 RX and 4 TX, the RX-TX\n",
"# association matrix could be\n",
"# [ [1 , 1, 0, 0],\n",
"# [0 , 0, 1, 1] ]\n",
"# which indicates that the RX 0 receives from TX 0 and 1, and RX 1 receives from\n",
"# TX 2 and 3.\n",
"#\n",
"# In this notebook, as we have only a single transmitter and receiver,\n",
"# the RX-TX association matrix is simply:\n",
"RX_TX_ASSOCIATION = np.array([[1]])\n",
"\n",
"# Instantiate a StreamManagement object\n",
"# This determines which data streams are determined for which receiver.\n",
"# In this simple setup, this is fairly easy. However, it can get more involved\n",
"# for simulations with many transmitters and receivers.\n",
"STREAM_MANAGEMENT = StreamManagement(RX_TX_ASSOCIATION, NUM_STREAMS_PER_TX)\n",
"\n",
"# Resource grid configuration\n",
"NUM_OFDM_SYMBOLS = 14\n",
"FFT_SIZE = 76\n",
"\n",
"RESOURCE_GRID = ResourceGrid(num_ofdm_symbols=NUM_OFDM_SYMBOLS,\n",
" fft_size=FFT_SIZE,\n",
" subcarrier_spacing=30e3,\n",
" num_tx=NUM_UT,\n",
" num_streams_per_tx=NUM_STREAMS_PER_TX,\n",
" cyclic_prefix_length=6,\n",
" pilot_pattern=\"kronecker\",\n",
" pilot_ofdm_symbol_indices=[2, 11])\n",
"\n",
"# Carrier frequency in Hz.\n",
"CARRIER_FREQUENCY = 2.6e9\n",
"\n",
"# Antenna setting\n",
"UT_ARRAY = Antenna(polarization=\"single\",\n",
" polarization_type=\"V\",\n",
" antenna_pattern=\"38.901\",\n",
" carrier_frequency=CARRIER_FREQUENCY)\n",
"BS_ARRAY = AntennaArray(num_rows=1,\n",
" num_cols=int(NUM_BS_ANT / 2),\n",
" polarization=\"dual\",\n",
" polarization_type=\"cross\",\n",
" antenna_pattern=\"38.901\",\n",
" carrier_frequency=CARRIER_FREQUENCY)\n",
"\n",
"# Nominal delay spread in [s]. Please see the CDL documentation\n",
"# about how to choose this value.\n",
"DELAY_SPREAD = 100e-9\n",
"\n",
"# The `direction` determines if the UT or BS is transmitting.\n",
"# In the `uplink`, the UT is transmitting.\n",
"DIRECTION = \"uplink\"\n",
"\n",
"# Suitable values are [\"A\", \"B\", \"C\", \"D\", \"E\"]\n",
"CDL_MODEL = \"C\"\n",
"\n",
"# UT speed [m/s]. BSs are always assumed to be fixed.\n",
"# The direction of travel will chosen randomly within the x-y plane.\n",
"SPEED = 10.0\n",
"\n",
"# Configure a channel impulse reponse (CIR) generator for the CDL model.\n",
"CDL_CHANNEL = CDL(CDL_MODEL,\n",
" DELAY_SPREAD,\n",
" CARRIER_FREQUENCY,\n",
" UT_ARRAY,\n",
" BS_ARRAY,\n",
" DIRECTION,\n",
" min_speed=SPEED)\n",
"\n",
"# Number of coded bits and information bits\n",
"N = int(RESOURCE_GRID.num_data_symbols * NUM_BITS_PER_SYMBOL) # Number of coded bits\n",
"K = int(N * CODERATE) # Number of information bits\n"
]
},
{
"cell_type": "markdown",
"id": "232db833-d1ca-41bb-a5a8-130969387682",
"metadata": {},
"source": [
"## Implemention of an Advanced Neural Receiver"
]
},
{
"cell_type": "markdown",
"id": "52d6ad1e-0208-47de-8ede-0414b2138e1c",
"metadata": {},
"source": [
"We will implement a state-of-the-art neural receiver that operates over the entire resource grid of received symbols."
]
},
{
"cell_type": "markdown",
"id": "cd15d2f4",
"metadata": {},
"source": [
"The neural receiver computes LLRs on the coded bits from the received resource grid of frequency-domain baseband symbols."
]
},
{
"cell_type": "markdown",
"id": "6e35de8c",
"metadata": {},
"source": [
""
]
},
{
"cell_type": "markdown",
"id": "34c86917",
"metadata": {},
"source": [
"As shown in the following figure, the neural receiver substitutes to the channel estimator, equalizer, and demapper."
]
},
{
"cell_type": "markdown",
"id": "88b13bfe-2025-4df6-8aeb-54291a279afd",
"metadata": {},
"source": [
""
]
},
{
"cell_type": "markdown",
"id": "fc67f0ea-4d2a-43cf-bf5e-5d167b8657a8",
"metadata": {},
"source": [
"As in [1] and [2], a neural receiver using residual convolutional layers is implemented.\n",
"\n",
"Convolutional layers are leveraged to efficienly process the 2D resource grid that is fed as an input to the neural receiver."
]
},
{
"cell_type": "markdown",
"id": "f407f34f",
"metadata": {},
"source": [
"Residual (skip) connections are used to avoid gradient vanishing [3].\n",
"\n",
"For convenience, a PyTorch module that implements a *residual block* is first defined. The neural receiver module is built by stacking such blocks. The following figure shows the architecture of the neural receiver.\n"
]
},
{
"cell_type": "markdown",
"id": "c87da393-c820-498b-82af-f95ed7789e60",
"metadata": {},
"source": [
""
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "bf95e03d-882b-4af7-aafa-4b86a3ab334a",
"metadata": {
"execution": {
"iopub.execute_input": "2026-02-13T15:21:42.102482Z",
"iopub.status.busy": "2026-02-13T15:21:42.102344Z",
"iopub.status.idle": "2026-02-13T15:21:42.108791Z",
"shell.execute_reply": "2026-02-13T15:21:42.108043Z"
}
},
"outputs": [],
"source": [
"class ResidualBlock(nn.Module):\n",
" \"\"\"\n",
" Convolutional residual block with two convolutional layers, ReLU activation,\n",
" layer normalization, and a skip connection.\n",
"\n",
" The number of convolutional channels of the input must match num_conv_channels\n",
" for the skip connection to work.\n",
"\n",
" Input shape: [batch_size, num_conv_channels, num_ofdm_symbols, num_subcarriers]\n",
" Output shape: [batch_size, num_conv_channels, num_ofdm_symbols, num_subcarriers]\n",
" \"\"\"\n",
"\n",
" def __init__(self, num_conv_channels: int = 128):\n",
" super().__init__()\n",
" # Layer normalization over the last three dimensions (C, H, W)\n",
" self._layer_norm_1 = nn.LayerNorm([num_conv_channels, NUM_OFDM_SYMBOLS, FFT_SIZE])\n",
" self._conv_1 = nn.Conv2d(\n",
" in_channels=num_conv_channels,\n",
" out_channels=num_conv_channels,\n",
" kernel_size=3,\n",
" padding=1, # 'same' padding\n",
" )\n",
" self._layer_norm_2 = nn.LayerNorm([num_conv_channels, NUM_OFDM_SYMBOLS, FFT_SIZE])\n",
" self._conv_2 = nn.Conv2d(\n",
" in_channels=num_conv_channels,\n",
" out_channels=num_conv_channels,\n",
" kernel_size=3,\n",
" padding=1,\n",
" )\n",
"\n",
" def forward(self, inputs: torch.Tensor) -> torch.Tensor:\n",
" z = self._layer_norm_1(inputs)\n",
" z = F.relu(z)\n",
" z = self._conv_1(z)\n",
" z = self._layer_norm_2(z)\n",
" z = F.relu(z)\n",
" z = self._conv_2(z)\n",
" # Skip connection\n",
" z = z + inputs\n",
" return z\n",
"\n",
"\n",
"class NeuralReceiver(nn.Module):\n",
" \"\"\"\n",
" Residual convolutional neural receiver.\n",
"\n",
" This neural receiver is fed with the post-DFT received samples, forming a\n",
" resource grid of size num_ofdm_symbols x fft_size, and computes LLRs on\n",
" the transmitted coded bits.\n",
"\n",
" Input\n",
" -----\n",
" y : [batch_size, num_rx_antenna, num_ofdm_symbols, num_subcarriers], complex\n",
" Received post-DFT samples.\n",
" no : [batch_size], float\n",
" Noise variance.\n",
"\n",
" Output\n",
" ------\n",
" llr : [batch_size, num_ofdm_symbols, num_subcarriers, num_bits_per_symbol], float\n",
" LLRs on the transmitted bits.\n",
" \"\"\"\n",
"\n",
" def __init__(self, num_conv_channels: int = 128):\n",
" super().__init__()\n",
" self._num_bits_per_symbol = NUM_BITS_PER_SYMBOL\n",
"\n",
" # Input convolution: 2*num_rx_antenna + 1 input channels (real, imag, noise)\n",
" num_input_channels = 2 * NUM_BS_ANT + 1\n",
" self._input_conv = nn.Conv2d(\n",
" in_channels=num_input_channels,\n",
" out_channels=num_conv_channels,\n",
" kernel_size=3,\n",
" padding=1,\n",
" )\n",
" # Residual blocks\n",
" self._res_block_1 = ResidualBlock(num_conv_channels)\n",
" self._res_block_2 = ResidualBlock(num_conv_channels)\n",
" self._res_block_3 = ResidualBlock(num_conv_channels)\n",
" self._res_block_4 = ResidualBlock(num_conv_channels)\n",
" # Output convolution\n",
" self._output_conv = nn.Conv2d(\n",
" in_channels=num_conv_channels,\n",
" out_channels=NUM_BITS_PER_SYMBOL,\n",
" kernel_size=3,\n",
" padding=1,\n",
" )\n",
"\n",
" def forward(self, y: torch.Tensor, no: torch.Tensor) -> torch.Tensor:\n",
" # y: [batch, num_rx_ant, num_ofdm_symbols, num_subcarriers]\n",
" # no: [batch]\n",
"\n",
" # Feeding the noise power in log10 scale helps with the performance\n",
" no = torch.log10(no)\n",
"\n",
" # Stack real and imaginary components\n",
" y_real = y.real # [batch, num_rx_ant, time, freq]\n",
" y_imag = y.imag # [batch, num_rx_ant, time, freq]\n",
"\n",
" # Reshape noise to [batch, 1, 1, 1] and broadcast\n",
" batch_size = y.shape[0]\n",
" no = no.view(-1, 1, 1, 1)\n",
" no = no.expand(batch_size, 1, y.shape[2], y.shape[3]) # [batch, 1, time, freq]\n",
"\n",
" # Concatenate: [batch, 2*num_rx_ant + 1, time, freq]\n",
" # PyTorch Conv2d expects channels-first format\n",
" z = torch.cat([y_real, y_imag, no], dim=1)\n",
"\n",
" # Input conv\n",
" z = self._input_conv(z)\n",
" # Residual blocks\n",
" z = self._res_block_1(z)\n",
" z = self._res_block_2(z)\n",
" z = self._res_block_3(z)\n",
" z = self._res_block_4(z)\n",
" # Output conv: [batch, num_bits_per_symbol, time, freq]\n",
" z = self._output_conv(z)\n",
"\n",
" # Transpose to [batch, time, freq, num_bits_per_symbol]\n",
" z = z.permute(0, 2, 3, 1)\n",
"\n",
" return z\n"
]
},
{
"cell_type": "markdown",
"id": "30d51dcd-0ccf-4401-9e1e-dac765e22973",
"metadata": {},
"source": [
"The task of the receiver is to jointly solve, for each resource element, `NUM_BITS_PER_SYMBOL` binary classification problems in order to reconstruct the transmitted bits.\n",
"Therefore, a natural choice for the loss function is the *binary cross-entropy* (BCE) applied to each bit and to each received symbol.\n",
"\n",
"*Remark:* The LLRs computed by the demapper are *logits* on the transmitted bits, and can therefore be used as-is to compute the BCE without any additional processing.\n",
"*Remark 2:* The BCE is closely related to an achieveable information rate for bit-interleaved coded modulation systems [4,5]\n",
"\n",
"The next cell defines an end-to-end communication system using the neural receiver layer.\n",
"\n",
"At initialization, the paramater `training` indicates if the system is instantiated to be trained (`True`) or evaluated (`False`).\n",
"\n",
"If the system is instantiated to be trained, the outer encoder and decoder are not used as they are not required for training. Moreover, the estimated BCE is returned.\n",
"This significantly reduces the computational complexity of training.\n",
"\n",
"If the system is instantiated to be evaluated, the outer encoder and decoder are used, and the transmited information and corresponding LLRs are returned."
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "c5d2605f-3b5f-481e-b5d1-48e638b9afd1",
"metadata": {
"execution": {
"iopub.execute_input": "2026-02-13T15:21:42.110880Z",
"iopub.status.busy": "2026-02-13T15:21:42.110743Z",
"iopub.status.idle": "2026-02-13T15:21:42.115927Z",
"shell.execute_reply": "2026-02-13T15:21:42.115123Z"
}
},
"outputs": [],
"source": [
"class OFDMSystemNeuralReceiver(Block): # Inherits from Sionna Block\n",
" \"\"\"\n",
" End-to-end OFDM system with neural receiver.\n",
"\n",
" Inherits from Sionna Block for lazy building and device/precision management.\n",
" \"\"\"\n",
"\n",
" def __init__(self, training: bool):\n",
" super().__init__() # Must call the parent class initializer\n",
"\n",
" self._training = training\n",
" self._k = K\n",
" self._n = N\n",
"\n",
" # Transmitter components\n",
" self._binary_source = BinarySource()\n",
" if not training:\n",
" self._encoder = LDPC5GEncoder(K, N)\n",
" self._mapper = Mapper(\"qam\", NUM_BITS_PER_SYMBOL)\n",
" self._rg_mapper = ResourceGridMapper(RESOURCE_GRID)\n",
"\n",
" # Channel\n",
" self._channel = OFDMChannel(CDL_CHANNEL, RESOURCE_GRID, add_awgn=True,\n",
" normalize_channel=True, return_channel=False)\n",
"\n",
" # Neural receiver\n",
" self._neural_receiver = NeuralReceiver().to(device)\n",
" self._rg_demapper = ResourceGridDemapper(RESOURCE_GRID, STREAM_MANAGEMENT)\n",
"\n",
" # Decoder (only for evaluation)\n",
" if not training:\n",
" self._decoder = LDPC5GDecoder(self._encoder, hard_out=True)\n",
"\n",
" def call(self, batch_size: int, ebno_db: torch.Tensor):\n",
" \"\"\"\n",
" Forward pass through the end-to-end system.\n",
"\n",
" Parameters\n",
" ----------\n",
" batch_size : int\n",
" Number of samples in the batch\n",
" ebno_db : torch.Tensor\n",
" Eb/N0 in dB, shape [batch_size] or scalar\n",
"\n",
" Returns\n",
" -------\n",
" If training: loss (scalar)\n",
" If not training: (bits, bits_hat) tuple\n",
" \"\"\"\n",
" no = ebnodb2no(ebno_db, num_bits_per_symbol=NUM_BITS_PER_SYMBOL,\n",
" coderate=CODERATE, resource_grid=RESOURCE_GRID)\n",
"\n",
" # Ensure no has shape [batch_size]\n",
" if no.dim() == 0:\n",
" no = no.expand(batch_size)\n",
"\n",
" # Transmitter\n",
" if self._training:\n",
" codewords = self._binary_source([batch_size, NUM_UT, NUM_UT_ANT, self._n])\n",
" else:\n",
" bits = self._binary_source([batch_size, NUM_UT, NUM_UT_ANT, self._k])\n",
" codewords = self._encoder(bits)\n",
"\n",
" x = self._mapper(codewords)\n",
" x_rg = self._rg_mapper(x)\n",
"\n",
" # Channel\n",
" no_ = expand_to_rank(no, x_rg.ndim)\n",
" y = self._channel(x_rg, no_)\n",
"\n",
" # Receiver\n",
" y = y.squeeze(1) # Remove num_rx dimension (assuming single receiver)\n",
" llr = self._neural_receiver(y, no)\n",
" llr = insert_dims(llr, 2, 1) # Add dimensions for rg_demapper\n",
" llr = self._rg_demapper(llr)\n",
" llr = llr.reshape(batch_size, NUM_UT, NUM_UT_ANT, self._n)\n",
"\n",
" if self._training:\n",
" # Compute BCE loss\n",
" loss = F.binary_cross_entropy_with_logits(llr, codewords.float())\n",
" return loss\n",
" else:\n",
" bits_hat = self._decoder(llr)\n",
" return bits, bits_hat\n"
]
},
{
"cell_type": "markdown",
"id": "4982feda-3b93-46dc-a936-bd225d7260dd",
"metadata": {},
"source": [
"## Training the Neural Receiver"
]
},
{
"cell_type": "markdown",
"id": "257d7e00-7341-4542-bc75-d9a612fba091",
"metadata": {},
"source": [
"The next cell implements a training loop of `NUM_TRAINING_ITERATIONS` iterations.\n",
"\n",
"At each iteration:\n",
"- A batch of SNRs $E_b/N_0$ is sampled\n",
"- A forward pass through the end-to-end system is performed within a gradient tape\n",
"- The gradients are computed using the gradient tape, and applied using the Adam optimizer\n",
"- A progress bar is periodically updated to follow the progress of training\n",
"\n",
"After training, the weights of the models are saved in a file using [pickle](https://docs.python.org/3/library/pickle.html).\n",
"\n",
"Executing the next cell will take quite a while. If you do not want to train your own neural receiver, you can download the weights [here](https://drive.google.com/file/d/1LAYC_leizwvmDnaKqRUjP5szZgJc799S/view?usp=sharing) and use them later on."
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "c53960db-28ee-4f33-8840-7b1373348162",
"metadata": {
"execution": {
"iopub.execute_input": "2026-02-13T15:21:42.117985Z",
"iopub.status.busy": "2026-02-13T15:21:42.117860Z",
"iopub.status.idle": "2026-02-13T15:49:01.432068Z",
"shell.execute_reply": "2026-02-13T15:49:01.430831Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"29900/30000 Loss: 2.19E-01\r"
]
}
],
"source": [
"train = True # Change to True to train your own model\n",
"if train:\n",
" # Number of iterations used for training\n",
" NUM_TRAINING_ITERATIONS = 30000\n",
"\n",
" # Instantiating the end-to-end model for training\n",
" model = OFDMSystemNeuralReceiver(training=True)\n",
"\n",
" # Use torch.compile for faster execution\n",
" try:\n",
" compiled_model = torch.compile(model, mode=\"reduce-overhead\")\n",
" except Exception:\n",
" print(\"torch.compile not available, using eager mode\")\n",
" compiled_model = model\n",
"\n",
" # Adam optimizer (SGD variant)\n",
" optimizer = torch.optim.Adam(model.parameters())\n",
"\n",
" # Training loop\n",
" for i in range(NUM_TRAINING_ITERATIONS):\n",
" # Sample a batch of SNRs\n",
" ebno_db = torch.empty(BATCH_SIZE, device=device).uniform_(EBN0_DB_MIN, EBN0_DB_MAX)\n",
"\n",
" # Forward pass\n",
" loss = compiled_model(BATCH_SIZE, ebno_db)\n",
"\n",
" # Computing and applying gradients\n",
" optimizer.zero_grad()\n",
" loss.backward()\n",
" optimizer.step()\n",
"\n",
" # Print progress\n",
" if i % 100 == 0:\n",
" print(f\"{i}/{NUM_TRAINING_ITERATIONS} Loss: {loss.item():.2E}\", end=\"\\r\")\n",
"\n",
" # Save the weights in a file\n",
" torch.save(model._neural_receiver.state_dict(), 'weights-ofdm-neuralrx.pt')\n"
]
},
{
"cell_type": "markdown",
"id": "0c374949",
"metadata": {},
"source": [
"## Benchmarking the Neural Receiver"
]
},
{
"cell_type": "markdown",
"id": "6bc9252a-47ee-4c2b-9224-194c90d7f4f2",
"metadata": {},
"source": [
"We evaluate the trained model and benchmark it against the previously introduced baselines.\n",
"\n",
"We first define and evaluate the baselines."
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "22f04eb2",
"metadata": {
"execution": {
"iopub.execute_input": "2026-02-13T15:49:01.434915Z",
"iopub.status.busy": "2026-02-13T15:49:01.434570Z",
"iopub.status.idle": "2026-02-13T15:49:01.440398Z",
"shell.execute_reply": "2026-02-13T15:49:01.439406Z"
}
},
"outputs": [],
"source": [
"class OFDMSystem(Block): # Inherits from Sionna Block\n",
" \"\"\"\n",
" End-to-end OFDM system with conventional receiver (LS estimation + LMMSE equalization).\n",
"\n",
" Inherits from Sionna Block for lazy building and device/precision management.\n",
" \"\"\"\n",
"\n",
" def __init__(self, perfect_csi: bool):\n",
" super().__init__() # Must call the parent class initializer\n",
"\n",
" self._perfect_csi = perfect_csi\n",
" self._k = K\n",
"\n",
" # Transmitter components\n",
" self._binary_source = BinarySource()\n",
" self._encoder = LDPC5GEncoder(K, N)\n",
" self._mapper = Mapper(\"qam\", NUM_BITS_PER_SYMBOL)\n",
" self._rg_mapper = ResourceGridMapper(RESOURCE_GRID)\n",
"\n",
" # Channel (return_channel=True to get channel frequency response)\n",
" self._channel = OFDMChannel(CDL_CHANNEL, RESOURCE_GRID, add_awgn=True,\n",
" normalize_channel=True, return_channel=True)\n",
"\n",
" # Receiver components\n",
" self._ls_est = LSChannelEstimator(RESOURCE_GRID, interpolation_type=\"nn\")\n",
" self._lmmse_equ = LMMSEEqualizer(RESOURCE_GRID, STREAM_MANAGEMENT)\n",
" self._demapper = Demapper(\"app\", \"qam\", NUM_BITS_PER_SYMBOL)\n",
" self._decoder = LDPC5GDecoder(self._encoder, hard_out=True)\n",
"\n",
" def call(self, batch_size: int, ebno_db: torch.Tensor):\n",
" \"\"\"\n",
" Forward pass through the end-to-end system.\n",
"\n",
" Parameters\n",
" ----------\n",
" batch_size : int\n",
" Number of samples in the batch\n",
" ebno_db : torch.Tensor\n",
" Eb/N0 in dB, shape [batch_size] or scalar\n",
"\n",
" Returns\n",
" -------\n",
" (bits, bits_hat) tuple\n",
" \"\"\"\n",
" no = ebnodb2no(ebno_db, num_bits_per_symbol=NUM_BITS_PER_SYMBOL,\n",
" coderate=CODERATE, resource_grid=RESOURCE_GRID)\n",
"\n",
" # Transmitter\n",
" bits = self._binary_source([batch_size, NUM_UT, RESOURCE_GRID.num_streams_per_tx, self._k])\n",
" codewords = self._encoder(bits)\n",
" x = self._mapper(codewords)\n",
" x_rg = self._rg_mapper(x)\n",
"\n",
" # Channel\n",
" no_ = expand_to_rank(no, x_rg.ndim)\n",
" y, h_freq = self._channel(x_rg, no_)\n",
"\n",
" # Receiver\n",
" if self._perfect_csi:\n",
" h_hat, err_var = h_freq, 0.0\n",
" else:\n",
" h_hat, err_var = self._ls_est(y, no)\n",
"\n",
" x_hat, no_eff = self._lmmse_equ(y, h_hat, err_var, no)\n",
" no_eff_ = expand_to_rank(no_eff, x_hat.ndim)\n",
" llr = self._demapper(x_hat, no_eff_)\n",
" bits_hat = self._decoder(llr)\n",
"\n",
" return bits, bits_hat\n"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "2226b31a",
"metadata": {
"execution": {
"iopub.execute_input": "2026-02-13T15:49:01.442480Z",
"iopub.status.busy": "2026-02-13T15:49:01.442348Z",
"iopub.status.idle": "2026-02-13T15:49:21.697675Z",
"shell.execute_reply": "2026-02-13T15:49:21.696727Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"EbNo [dB] | BER | BLER | bit errors | num bits | block errors | num blocks | runtime [s] | status\n",
"---------------------------------------------------------------------------------------------------------------------------------------\n",
" -3.0 | 3.7178e-01 | 1.0000e+00 | 43400 | 116736 | 128 | 128 | 0.1 |reached target block errors\n",
" -2.579 | 3.6117e-01 | 1.0000e+00 | 42161 | 116736 | 128 | 128 | 0.0 |reached target block errors\n",
" -2.158 | 3.4515e-01 | 1.0000e+00 | 40292 | 116736 | 128 | 128 | 0.0 |reached target block errors\n",
" -1.737 | 3.3232e-01 | 1.0000e+00 | 38794 | 116736 | 128 | 128 | 0.0 |reached target block errors\n",
" -1.316 | 3.1903e-01 | 1.0000e+00 | 37242 | 116736 | 128 | 128 | 0.0 |reached target block errors\n",
" -0.895 | 3.0887e-01 | 1.0000e+00 | 36056 | 116736 | 128 | 128 | 0.0 |reached target block errors\n",
" -0.474 | 2.9605e-01 | 1.0000e+00 | 34560 | 116736 | 128 | 128 | 0.0 |reached target block errors\n",
" -0.053 | 2.7512e-01 | 1.0000e+00 | 32116 | 116736 | 128 | 128 | 0.0 |reached target block errors\n",
" 0.368 | 2.6070e-01 | 1.0000e+00 | 30433 | 116736 | 128 | 128 | 0.0 |reached target block errors\n",
" 0.789 | 2.4271e-01 | 1.0000e+00 | 28333 | 116736 | 128 | 128 | 0.0 |reached target block errors\n",
" 1.211 | 2.2145e-01 | 1.0000e+00 | 25851 | 116736 | 128 | 128 | 0.0 |reached target block errors\n",
" 1.632 | 1.9261e-01 | 1.0000e+00 | 22484 | 116736 | 128 | 128 | 0.0 |reached target block errors\n",
" 2.053 | 1.5621e-01 | 9.9219e-01 | 18235 | 116736 | 127 | 128 | 0.0 |reached target block errors\n",
" 2.474 | 9.8778e-02 | 8.9062e-01 | 11531 | 116736 | 114 | 128 | 0.0 |reached target block errors\n",
" 2.895 | 2.6594e-02 | 4.0234e-01 | 6209 | 233472 | 103 | 256 | 0.1 |reached target block errors\n",
" 3.316 | 1.7423e-03 | 4.3837e-02 | 3661 | 2101248 | 101 | 2304 | 0.6 |reached target block errors\n",
" 3.737 | 1.2498e-04 | 2.1875e-03 | 1459 | 11673600 | 28 | 12800 | 3.1 |reached max iterations\n",
" 4.158 | 1.5077e-05 | 7.8125e-05 | 176 | 11673600 | 1 | 12800 | 3.2 |reached max iterations\n",
" 4.579 | 0.0000e+00 | 0.0000e+00 | 0 | 11673600 | 0 | 12800 | 3.2 |reached max iterations\n",
"\n",
"Simulation stopped as no error occurred @ EbNo = 4.6 dB.\n",
"\n",
"EbNo [dB] | BER | BLER | bit errors | num bits | block errors | num blocks | runtime [s] | status\n",
"---------------------------------------------------------------------------------------------------------------------------------------\n",
" -3.0 | 2.1718e-01 | 1.0000e+00 | 25353 | 116736 | 128 | 128 | 0.0 |reached target block errors\n",
" -2.579 | 1.9822e-01 | 1.0000e+00 | 23139 | 116736 | 128 | 128 | 0.0 |reached target block errors\n",
" -2.158 | 1.7697e-01 | 1.0000e+00 | 20659 | 116736 | 128 | 128 | 0.0 |reached target block errors\n",
" -1.737 | 1.3037e-01 | 9.9219e-01 | 15219 | 116736 | 127 | 128 | 0.0 |reached target block errors\n",
" -1.316 | 7.4656e-02 | 8.8281e-01 | 8715 | 116736 | 113 | 128 | 0.0 |reached target block errors\n",
" -0.895 | 1.4948e-02 | 3.4635e-01 | 5235 | 350208 | 133 | 384 | 0.1 |reached target block errors\n",
" -0.474 | 5.6842e-04 | 2.6210e-02 | 2057 | 3618816 | 104 | 3968 | 1.0 |reached target block errors\n",
" -0.053 | 3.1181e-05 | 5.4688e-04 | 364 | 11673600 | 7 | 12800 | 3.1 |reached max iterations\n",
" 0.368 | 2.1673e-05 | 1.5625e-04 | 253 | 11673600 | 2 | 12800 | 3.1 |reached max iterations\n",
" 0.789 | 0.0000e+00 | 0.0000e+00 | 0 | 11673600 | 0 | 12800 | 3.1 |reached max iterations\n",
"\n",
"Simulation stopped as no error occurred @ EbNo = 0.8 dB.\n",
"\n"
]
},
{
"data": {
"text/plain": [
"(tensor([2.1718e-01, 1.9822e-01, 1.7697e-01, 1.3037e-01, 7.4656e-02, 1.4948e-02,\n",
" 5.6842e-04, 3.1181e-05, 2.1673e-05, 0.0000e+00, 0.0000e+00, 0.0000e+00,\n",
" 0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00,\n",
" 0.0000e+00, 0.0000e+00], device='cuda:0'),\n",
" tensor([1.0000e+00, 1.0000e+00, 1.0000e+00, 9.9219e-01, 8.8281e-01, 3.4635e-01,\n",
" 2.6210e-02, 5.4688e-04, 1.5625e-04, 0.0000e+00, 0.0000e+00, 0.0000e+00,\n",
" 0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00,\n",
" 0.0000e+00, 0.0000e+00], device='cuda:0'))"
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"ber_plots = PlotBER(\"Advanced neural receiver\")\n",
"\n",
"baseline_ls = OFDMSystem(False)\n",
"ber_plots.simulate(baseline_ls,\n",
" ebno_dbs=np.linspace(EBN0_DB_MIN, EBN0_DB_MAX, 20),\n",
" batch_size=BATCH_SIZE,\n",
" num_target_block_errors=100, # simulate until 100 block errors occurred\n",
" legend=\"Baseline: LS Estimation\",\n",
" soft_estimates=True,\n",
" max_mc_iter=100, # run 100 Monte-Carlo simulations (each with batch_size samples)\n",
" show_fig=False)\n",
"\n",
"baseline_pcsi = OFDMSystem(True)\n",
"ber_plots.simulate(baseline_pcsi,\n",
" ebno_dbs=np.linspace(EBN0_DB_MIN, EBN0_DB_MAX, 20),\n",
" batch_size=BATCH_SIZE,\n",
" num_target_block_errors=100, # simulate until 100 block errors occurred\n",
" legend=\"Baseline: Perfect CSI\",\n",
" soft_estimates=True,\n",
" max_mc_iter=100, # run 100 Monte-Carlo simulations (each with batch_size samples)\n",
" show_fig=False)\n"
]
},
{
"cell_type": "markdown",
"id": "3de79d49",
"metadata": {},
"source": [
"We then instantiate and evaluate the end-to-end system equipped with the neural receiver."
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "6a0e6e6b-3650-4524-9c83-46c715493e3f",
"metadata": {
"execution": {
"iopub.execute_input": "2026-02-13T15:49:21.700328Z",
"iopub.status.busy": "2026-02-13T15:49:21.700198Z",
"iopub.status.idle": "2026-02-13T15:49:21.854995Z",
"shell.execute_reply": "2026-02-13T15:49:21.854221Z"
}
},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Instantiating the end-to-end model for evaluation\n",
"model_neuralrx = OFDMSystemNeuralReceiver(training=False)\n",
"\n",
"# Run one inference to build the model\n",
"model_neuralrx(1, torch.tensor(10.0))\n",
"\n",
"# Load the trained weights\n",
"model_neuralrx._neural_receiver.load_state_dict(\n",
" torch.load('weights-ofdm-neuralrx.pt', weights_only=True)\n",
")"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "fc0e47a5-7d61-4e8b-b077-8fc63a33057f",
"metadata": {
"execution": {
"iopub.execute_input": "2026-02-13T15:49:21.857425Z",
"iopub.status.busy": "2026-02-13T15:49:21.857292Z",
"iopub.status.idle": "2026-02-13T15:50:03.214301Z",
"shell.execute_reply": "2026-02-13T15:50:03.213366Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"EbNo [dB] | BER | BLER | bit errors | num bits | block errors | num blocks | runtime [s] | status\n",
"---------------------------------------------------------------------------------------------------------------------------------------\n",
" -3.0 | 2.2578e-01 | 1.0000e+00 | 26357 | 116736 | 128 | 128 | 0.0 |reached target block errors\n",
" -2.579 | 2.0454e-01 | 1.0000e+00 | 23877 | 116736 | 128 | 128 | 0.0 |reached target block errors\n",
" -2.158 | 1.7964e-01 | 1.0000e+00 | 20971 | 116736 | 128 | 128 | 0.0 |reached target block errors\n",
" -1.737 | 1.4847e-01 | 1.0000e+00 | 17332 | 116736 | 128 | 128 | 0.0 |reached target block errors\n",
" -1.316 | 9.6765e-02 | 9.4531e-01 | 11296 | 116736 | 121 | 128 | 0.0 |reached target block errors\n",
" -0.895 | 3.1104e-02 | 5.3906e-01 | 7262 | 233472 | 138 | 256 | 0.1 |reached target block errors\n",
" -0.474 | 2.2294e-03 | 6.5755e-02 | 3123 | 1400832 | 101 | 1536 | 0.6 |reached target block errors\n",
" -0.053 | 2.4962e-04 | 4.6094e-03 | 2914 | 11673600 | 59 | 12800 | 4.6 |reached max iterations\n",
" 0.368 | 1.0948e-04 | 1.0156e-03 | 1278 | 11673600 | 13 | 12800 | 4.6 |reached max iterations\n",
" 0.789 | 5.1912e-05 | 3.9063e-04 | 606 | 11673600 | 5 | 12800 | 4.6 |reached max iterations\n",
" 1.211 | 3.5379e-05 | 2.3437e-04 | 413 | 11673600 | 3 | 12800 | 4.7 |reached max iterations\n",
" 1.632 | 1.7133e-05 | 1.5625e-04 | 200 | 11673600 | 2 | 12800 | 4.6 |reached max iterations\n",
" 2.053 | 4.1118e-06 | 7.8125e-05 | 48 | 11673600 | 1 | 12800 | 4.7 |reached max iterations\n",
" 2.474 | 1.0879e-05 | 7.8125e-05 | 127 | 11673600 | 1 | 12800 | 4.6 |reached max iterations\n",
" 2.895 | 4.1461e-05 | 2.3437e-04 | 484 | 11673600 | 3 | 12800 | 4.6 |reached max iterations\n",
" 3.316 | 0.0000e+00 | 0.0000e+00 | 0 | 11673600 | 0 | 12800 | 4.6 |reached max iterations\n",
"\n",
"Simulation stopped as no error occurred @ EbNo = 3.3 dB.\n",
"\n"
]
},
{
"data": {
"text/plain": [
"(tensor([2.2578e-01, 2.0454e-01, 1.7964e-01, 1.4847e-01, 9.6765e-02, 3.1104e-02,\n",
" 2.2294e-03, 2.4962e-04, 1.0948e-04, 5.1912e-05, 3.5379e-05, 1.7133e-05,\n",
" 4.1118e-06, 1.0879e-05, 4.1461e-05, 0.0000e+00, 0.0000e+00, 0.0000e+00,\n",
" 0.0000e+00, 0.0000e+00], device='cuda:0'),\n",
" tensor([1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00, 9.4531e-01, 5.3906e-01,\n",
" 6.5755e-02, 4.6094e-03, 1.0156e-03, 3.9063e-04, 2.3437e-04, 1.5625e-04,\n",
" 7.8125e-05, 7.8125e-05, 2.3437e-04, 0.0000e+00, 0.0000e+00, 0.0000e+00,\n",
" 0.0000e+00, 0.0000e+00], device='cuda:0'))"
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# Computing and plotting BER\n",
"ber_plots.simulate(model_neuralrx,\n",
" ebno_dbs=np.linspace(EBN0_DB_MIN, EBN0_DB_MAX, 20),\n",
" batch_size=BATCH_SIZE,\n",
" num_target_block_errors=100,\n",
" legend=\"Neural Receiver\",\n",
" soft_estimates=True,\n",
" max_mc_iter=100,\n",
" show_fig=True)\n"
]
},
{
"cell_type": "markdown",
"id": "dc0e6bc1-cd3f-4ecb-86b3-d30c4499c1f5",
"metadata": {},
"source": [
"## Conclusion "
]
},
{
"cell_type": "markdown",
"id": "d2cceaaa-35bc-479e-8006-773c1172e117",
"metadata": {},
"source": [
"We hope you are excited about Sionna - there is much more to be discovered:\n",
"\n",
"- PyTorch profiling and debugging tools available\n",
"- Scaling to multi-GPU simulation is simple\n",
"- See the [available tutorials](https://nvlabs.github.io/sionna/phy/tutorials/index.html) for more examples\n",
"\n",
"And if something is still missing - the project is open-source: you can modify, add, and extend any component at any time.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "f1712c31-04f3-4c71-b7ba-b8e63c4ac126",
"metadata": {},
"source": [
"## References"
]
},
{
"cell_type": "markdown",
"id": "3887c8aa-23ed-4a27-ad9d-0a1e3174c2c2",
"metadata": {},
"source": [
"[1] [M. Honkala, D. Korpi and J. M. J. Huttunen, \"DeepRx: Fully Convolutional Deep Learning Receiver,\" in IEEE Transactions on Wireless Communications, vol. 20, no. 6, pp. 3925-3940, June 2021, doi: 10.1109/TWC.2021.3054520](https://ieeexplore.ieee.org/abstract/document/9345504).\n",
"\n",
"[2] [F. Ait Aoudia and J. Hoydis, \"End-to-end Learning for OFDM: From Neural Receivers to Pilotless Communication,\" in IEEE Transactions on Wireless Communications, doi: 10.1109/TWC.2021.3101364](https://ieeexplore.ieee.org/abstract/document/9508784).\n",
"\n",
"[3] [Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun, \"Deep Residual Learning for Image Recognition\", Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2016, pp. 770-778](https://openaccess.thecvf.com/content_cvpr_2016/html/He_Deep_Residual_Learning_CVPR_2016_paper.html)"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "venv",
"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.12.3"
},
"widgets": {
"application/vnd.jupyter.widget-state+json": {
"state": {},
"version_major": 2,
"version_minor": 0
}
}
},
"nbformat": 4,
"nbformat_minor": 5
}