{
"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",
"* [Implementation of an Advanced Neural Receiver](#Implementation-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": 1,
"id": "d84bd69e-59f2-4a42-8dd3-730c8c1d821e",
"metadata": {
"execution": {
"iopub.execute_input": "2026-08-06T15:54:46.148092Z",
"iopub.status.busy": "2026-08-06T15:54:46.147979Z",
"iopub.status.idle": "2026-08-06T15:54:49.212692Z",
"shell.execute_reply": "2026-08-06T15:54:49.211601Z"
}
},
"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",
"import warnings\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\n",
"warnings.filterwarnings(\n",
" \"ignore\",\n",
" message=\"Torchinductor does not support code generation for complex operators.*\",\n",
")\n",
"warnings.filterwarnings(\n",
" \"ignore\",\n",
" message=\"`torch._prims_common.check` is deprecated.*\",\n",
" category=FutureWarning,\n",
")"
]
},
{
"cell_type": "markdown",
"id": "64d17183",
"metadata": {},
"source": [
"## Simulation Parameters"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "4dea9622",
"metadata": {
"execution": {
"iopub.execute_input": "2026-08-06T15:54:49.215286Z",
"iopub.status.busy": "2026-08-06T15:54:49.215011Z",
"iopub.status.idle": "2026-08-06T15:54:49.481218Z",
"shell.execute_reply": "2026-08-06T15:54:49.480096Z"
}
},
"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": [
"## Implementation 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-08-06T15:54:49.484028Z",
"iopub.status.busy": "2026-08-06T15:54:49.483872Z",
"iopub.status.idle": "2026-08-06T15:54:49.490338Z",
"shell.execute_reply": "2026-08-06T15:54:49.489729Z"
}
},
"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 achievable 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 parameter `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 transmitted information and corresponding LLRs are returned."
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "c5d2605f-3b5f-481e-b5d1-48e638b9afd1",
"metadata": {
"execution": {
"iopub.execute_input": "2026-08-06T15:54:49.492350Z",
"iopub.status.busy": "2026-08-06T15:54:49.492226Z",
"iopub.status.idle": "2026-08-06T15:54:49.497392Z",
"shell.execute_reply": "2026-08-06T15:54:49.496741Z"
}
},
"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 neural receiver weights are saved to a PyTorch checkpoint using [`torch.save`](https://docs.pytorch.org/docs/stable/generated/torch.save.html).\n",
"\n",
"Training will take quite a while. It is disabled by default in the next cell; set `train = True` to train your own neural receiver. Otherwise, download the weights [here](https://drive.google.com/file/d/1LAYC_leizwvmDnaKqRUjP5szZgJc799S/view?usp=sharing) before running the evaluation below."
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "c53960db-28ee-4f33-8840-7b1373348162",
"metadata": {
"execution": {
"iopub.execute_input": "2026-08-06T15:54:49.499491Z",
"iopub.status.busy": "2026-08-06T15:54:49.499374Z",
"iopub.status.idle": "2026-08-06T15:54:49.502929Z",
"shell.execute_reply": "2026-08-06T15:54:49.502210Z"
}
},
"outputs": [],
"source": [
"train = False # 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=\"default\")\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-08-06T15:54:49.504787Z",
"iopub.status.busy": "2026-08-06T15:54:49.504670Z",
"iopub.status.idle": "2026-08-06T15:54:49.509334Z",
"shell.execute_reply": "2026-08-06T15:54:49.508623Z"
}
},
"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-08-06T15:54:49.510979Z",
"iopub.status.busy": "2026-08-06T15:54:49.510855Z",
"iopub.status.idle": "2026-08-06T15:55:11.654686Z",
"shell.execute_reply": "2026-08-06T15:55:11.653739Z"
}
},
"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.7139e-01 | 1.0000e+00 | 43354 | 116736 | 128 | 128 | 0.3 |reached target block errors\n",
" -2.579 | 3.6054e-01 | 1.0000e+00 | 42088 | 116736 | 128 | 128 | 0.0 |reached target block errors\n",
" -2.158 | 3.4489e-01 | 1.0000e+00 | 40261 | 116736 | 128 | 128 | 0.0 |reached target block errors\n",
" -1.737 | 3.3224e-01 | 1.0000e+00 | 38784 | 116736 | 128 | 128 | 0.0 |reached target block errors\n",
" -1.316 | 3.1914e-01 | 1.0000e+00 | 37255 | 116736 | 128 | 128 | 0.0 |reached target block errors\n",
" -0.895 | 3.0871e-01 | 1.0000e+00 | 36037 | 116736 | 128 | 128 | 0.0 |reached target block errors\n",
" -0.474 | 2.9658e-01 | 1.0000e+00 | 34621 | 116736 | 128 | 128 | 0.0 |reached target block errors\n",
" -0.053 | 2.7489e-01 | 1.0000e+00 | 32089 | 116736 | 128 | 128 | 0.0 |reached target block errors\n",
" 0.368 | 2.6085e-01 | 1.0000e+00 | 30451 | 116736 | 128 | 128 | 0.0 |reached target block errors\n",
" 0.789 | 2.4248e-01 | 1.0000e+00 | 28306 | 116736 | 128 | 128 | 0.0 |reached target block errors\n",
" 1.211 | 2.2065e-01 | 1.0000e+00 | 25758 | 116736 | 128 | 128 | 0.0 |reached target block errors\n",
" 1.632 | 1.9237e-01 | 1.0000e+00 | 22456 | 116736 | 128 | 128 | 0.0 |reached target block errors\n",
" 2.053 | 1.5677e-01 | 9.9219e-01 | 18301 | 116736 | 127 | 128 | 0.0 |reached target block errors\n",
" 2.474 | 9.9258e-02 | 8.8281e-01 | 11587 | 116736 | 113 | 128 | 0.0 |reached target block errors\n",
" 2.895 | 2.5489e-02 | 4.1016e-01 | 5951 | 233472 | 105 | 256 | 0.1 |reached target block errors\n",
" 3.316 | 1.8408e-03 | 4.3837e-02 | 3868 | 2101248 | 101 | 2304 | 0.6 |reached target block errors\n",
" 3.737 | 1.4657e-04 | 2.5781e-03 | 1711 | 11673600 | 33 | 12800 | 3.2 |reached max iterations\n",
" 4.158 | 1.3706e-05 | 1.5625e-04 | 160 | 11673600 | 2 | 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.1703e-01 | 1.0000e+00 | 25335 | 116736 | 128 | 128 | 0.0 |reached target block errors\n",
" -2.579 | 1.9808e-01 | 1.0000e+00 | 23123 | 116736 | 128 | 128 | 0.0 |reached target block errors\n",
" -2.158 | 1.7710e-01 | 1.0000e+00 | 20674 | 116736 | 128 | 128 | 0.0 |reached target block errors\n",
" -1.737 | 1.3034e-01 | 9.8438e-01 | 15215 | 116736 | 126 | 128 | 0.0 |reached target block errors\n",
" -1.316 | 7.5007e-02 | 8.8281e-01 | 8756 | 116736 | 113 | 128 | 0.0 |reached target block errors\n",
" -0.895 | 1.4863e-02 | 3.3854e-01 | 5205 | 350208 | 130 | 384 | 0.1 |reached target block errors\n",
" -0.474 | 5.6925e-04 | 2.5958e-02 | 2060 | 3618816 | 103 | 3968 | 1.0 |reached target block errors\n",
" -0.053 | 2.9725e-05 | 7.0312e-04 | 347 | 11673600 | 9 | 12800 | 3.2 |reached max iterations\n",
" 0.368 | 2.1502e-05 | 7.8125e-05 | 251 | 11673600 | 1 | 12800 | 3.2 |reached max iterations\n",
" 0.789 | 0.0000e+00 | 0.0000e+00 | 0 | 11673600 | 0 | 12800 | 3.2 |reached max iterations\n",
"\n",
"Simulation stopped as no error occurred @ EbNo = 0.8 dB.\n",
"\n"
]
},
{
"data": {
"text/plain": [
"(tensor([2.1703e-01, 1.9808e-01, 1.7710e-01, 1.3034e-01, 7.5007e-02, 1.4863e-02,\n",
" 5.6925e-04, 2.9725e-05, 2.1502e-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.8438e-01, 8.8281e-01, 3.3854e-01,\n",
" 2.5958e-02, 7.0313e-04, 7.8125e-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'))"
]
},
"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",
" verbose=True,\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",
" verbose=True,\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-08-06T15:55:11.656891Z",
"iopub.status.busy": "2026-08-06T15:55:11.656752Z",
"iopub.status.idle": "2026-08-06T15:55:11.946129Z",
"shell.execute_reply": "2026-08-06T15:55:11.945300Z"
}
},
"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-08-06T15:55:11.948399Z",
"iopub.status.busy": "2026-08-06T15:55:11.948260Z",
"iopub.status.idle": "2026-08-06T15:55:56.182707Z",
"shell.execute_reply": "2026-08-06T15:55:56.181828Z"
}
},
"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.2563e-01 | 1.0000e+00 | 26339 | 116736 | 128 | 128 | 0.1 |reached target block errors\n",
" -2.579 | 2.0393e-01 | 1.0000e+00 | 23806 | 116736 | 128 | 128 | 0.0 |reached target block errors\n",
" -2.158 | 1.7988e-01 | 1.0000e+00 | 20998 | 116736 | 128 | 128 | 0.0 |reached target block errors\n",
" -1.737 | 1.4813e-01 | 1.0000e+00 | 17292 | 116736 | 128 | 128 | 0.0 |reached target block errors\n",
" -1.316 | 9.6705e-02 | 9.5312e-01 | 11289 | 116736 | 122 | 128 | 0.0 |reached target block errors\n",
" -0.895 | 3.0813e-02 | 5.5469e-01 | 7194 | 233472 | 142 | 256 | 0.1 |reached target block errors\n",
" -0.474 | 2.2529e-03 | 7.0312e-02 | 3156 | 1400832 | 108 | 1536 | 0.6 |reached target block errors\n",
" -0.053 | 2.4491e-04 | 4.2188e-03 | 2859 | 11673600 | 54 | 12800 | 4.8 |reached max iterations\n",
" 0.368 | 9.6114e-05 | 1.0156e-03 | 1122 | 11673600 | 13 | 12800 | 4.8 |reached max iterations\n",
" 0.789 | 4.8057e-05 | 3.9063e-04 | 561 | 11673600 | 5 | 12800 | 4.8 |reached max iterations\n",
" 1.211 | 2.7327e-05 | 2.3437e-04 | 319 | 11673600 | 3 | 12800 | 4.8 |reached max iterations\n",
" 1.632 | 1.0108e-05 | 1.5625e-04 | 118 | 11673600 | 2 | 12800 | 4.8 |reached max iterations\n",
" 2.053 | 5.4825e-06 | 7.8125e-05 | 64 | 11673600 | 1 | 12800 | 4.8 |reached max iterations\n",
" 2.474 | 1.3106e-05 | 7.8125e-05 | 153 | 11673600 | 1 | 12800 | 4.8 |reached max iterations\n",
" 2.895 | 3.3237e-05 | 2.3437e-04 | 388 | 11673600 | 3 | 12800 | 4.8 |reached max iterations\n",
" 3.316 | 0.0000e+00 | 0.0000e+00 | 0 | 11673600 | 0 | 12800 | 4.8 |reached max iterations\n",
"\n",
"Simulation stopped as no error occurred @ EbNo = 3.3 dB.\n",
"\n"
]
},
{
"data": {
"text/plain": [
"(tensor([2.2563e-01, 2.0393e-01, 1.7988e-01, 1.4813e-01, 9.6705e-02, 3.0813e-02,\n",
" 2.2529e-03, 2.4491e-04, 9.6114e-05, 4.8057e-05, 2.7327e-05, 1.0108e-05,\n",
" 5.4825e-06, 1.3106e-05, 3.3237e-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.5312e-01, 5.5469e-01,\n",
" 7.0312e-02, 4.2188e-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",
" verbose=True,\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.12"
},
"widgets": {
"application/vnd.jupyter.widget-state+json": {
"state": {},
"version_major": 2,
"version_minor": 0
}
}
},
"nbformat": 4,
"nbformat_minor": 5
}