{ "cells": [ { "cell_type": "markdown", "id": "c2d46536-45b7-472d-a4e4-a998fea2afab", "metadata": {}, "source": [ "# Evaluating End-to-End Communication Performance Using BLER\n", "\n", "This notebook evaluates the trained channel estimation model within a complete end-to-end communication pipeline using **Block Error Rate (BLER)** as the performance metric. Unlike the NMSE evaluation, which measures channel estimation accuracy directly, BLER quantifies the impact of channel estimation on the successful decoding of transmitted data.\n", "\n", "The evaluation compares several channel estimation approaches across a range of signal-to-noise ratio (SNR) values, including the trained neural network and conventional estimation methods. For each SNR value, the communication system transmits multiple transport blocks, performs channel estimation and decoding, and records the resulting BLER.\n", "\n", "The generated BLER curves provide a practical measure of receiver performance and illustrate how improvements in channel estimation translate into improved communication reliability." ] }, { "cell_type": "code", "execution_count": 1, "id": "2415601e", "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import time, os, torch\n", "import matplotlib.pyplot as plt\n", "\n", "from neoradium import BandwidthPart, PDSCH, CdlChannel, AntennaPanel, random, SnrScheduler\n", "\n", "from ChEstNet import ChEstNet\n", "from ChEstUtils import estimateChannelML, getPseudoPilotIndices\n" ] }, { "cell_type": "code", "execution_count": 2, "id": "12efc621", "metadata": {}, "outputs": [], "source": [ "# Load the trained model\n", "modelPath = 'Models/Pretrained.pth' # Use the pre-trained model\n", "# modelPath = 'Models/Trained.pth' # Use the model trained in the previous step (see MLChEstTrain.ipynb)\n", "device = \"cuda:0\" if torch.cuda.is_available() else \"mps\" if torch.backends.mps.is_available() else \"cpu\"\n", "model = ChEstNet(device) # Instantiate the model on the target device\n", "model.loadParams(modelPath); # Load the trained model parameters" ] }, { "cell_type": "code", "execution_count": 3, "id": "5183e9c1-5de0-4496-aec5-bb2a1d4b17fd", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Evaluating BLER with LS (DMRS) channel estimation\n", "SNR(dB) TX Blocks Block Errors BLER(%)\n", "------- --------- ------------ -------\n", " -12.0 1,000 980 98.00 \n", " -12.2 1,000 1,000 100.00 \n", " -12.4 1,000 1,000 100.00 \n", " -11.8 1,000 888 88.80 \n", " -11.6 1,000 737 73.70 \n", " -11.4 1,000 629 62.90 \n", " -11.2 1,000 556 55.60 \n", " -11.0 1,000 494 49.40 \n", " -10.8 1,000 438 43.80 \n", " -10.6 1,000 390 39.00 \n", " -10.4 1,000 358 35.80 \n", " -10.2 1,000 307 30.70 \n", " -10.0 1,000 261 26.10 \n", " -9.8 1,000 215 21.50 \n", " -9.6 1,000 156 15.60 \n", " -9.4 1,000 87 8.70 \n", " -9.2 1,000 49 4.90 \n", " -9.0 1,000 20 2.00 \n", " -8.8 1,000 7 0.70 \n", " -8.6 1,000 1 0.10 \n", " -8.4 1,000 0 0.00 \n", " -8.2 1,000 0 0.00 \n", "\n", "Evaluating BLER with ML (DMRS) channel estimation\n", "SNR(dB) TX Blocks Block Errors BLER(%)\n", "------- --------- ------------ -------\n", " -12.0 1,000 309 30.90 \n", " -12.2 1,000 358 35.80 \n", " -12.4 1,000 406 40.60 \n", " -12.6 1,000 450 45.00 \n", " -12.8 1,000 514 51.40 \n", " -13.0 1,000 602 60.20 \n", " -13.2 1,000 713 71.30 \n", " -13.4 1,000 892 89.20 \n", " -13.6 1,000 991 99.10 \n", " -13.8 1,000 1,000 100.00 \n", " -14.0 1,000 1,000 100.00 \n", " -11.8 1,000 260 26.00 \n", " -11.6 1,000 217 21.70 \n", " -11.4 1,000 169 16.90 \n", " -11.2 1,000 124 12.40 \n", " -11.0 1,000 71 7.10 \n", " -10.8 1,000 29 2.90 \n", " -10.6 1,000 10 1.00 \n", " -10.4 1,000 1 0.10 \n", " -10.2 1,000 0 0.00 \n", " -10.0 1,000 0 0.00 \n", "\n", "Evaluating BLER with Self-Refining channel estimation\n", "SNR(dB) TX Blocks Block Errors BLER(%) Ret. Saved Rec. Code Blocks\n", "------- --------- ------------ ------- ---------- ----------------\n", " -12.0 1,000 185 18.50 124 248\n", " -12.2 1,000 229 22.90 129 254\n", " -12.4 1,000 278 27.80 128 249\n", " -12.6 1,000 323 32.30 128 241\n", " -12.8 1,000 364 36.40 150 295\n", " -13.0 1,000 427 42.70 175 296\n", " -13.2 1,000 477 47.70 236 395\n", " -13.4 1,000 538 53.80 355 605\n", " -13.6 1,000 615 61.50 376 815\n", " -13.8 1,000 786 78.60 214 582\n", " -14.0 1,000 945 94.50 55 186\n", " -14.2 1,000 999 99.90 1 10\n", " -14.4 1,000 1,000 100.00 0 0\n", " -14.6 1,000 1,000 100.00 0 0\n", " -11.8 1,000 132 13.20 128 280\n", " -11.6 1,000 73 7.30 144 313\n", " -11.4 1,000 18 1.80 151 285\n", " -11.2 1,000 0 0.00 124 205\n", " -11.0 1,000 0 0.00 71 88\n", "\n", "Evaluating BLER with Perfect channel knowledge\n", "SNR(dB) TX Blocks Block Errors BLER(%)\n", "------- --------- ------------ -------\n", " -12.0 1,000 82 8.20 \n", " -12.2 1,000 152 15.20 \n", " -12.4 1,000 201 20.10 \n", " -12.6 1,000 253 25.30 \n", " -12.8 1,000 299 29.90 \n", " -13.0 1,000 345 34.50 \n", " -13.2 1,000 399 39.90 \n", " -13.4 1,000 445 44.50 \n", " -13.6 1,000 511 51.10 \n", " -13.8 1,000 571 57.10 \n", " -14.0 1,000 685 68.50 \n", " -14.2 1,000 850 85.00 \n", " -14.4 1,000 982 98.20 \n", " -14.6 1,000 1,000 100.00 \n", " -14.8 1,000 1,000 100.00 \n", " -11.8 1,000 32 3.20 \n", " -11.6 1,000 7 0.70 \n", " -11.4 1,000 2 0.20 \n", " -11.2 1,000 1 0.10 \n", " -11.0 1,000 0 0.00 \n", " -10.8 1,000 0 0.00 \n" ] } ], "source": [ "# Calculate block error rates (BLER)\n", "seed = 123\n", "\n", "# Using maxSlots = 1000 may cause this experiment to take a long time to complete.\n", "# You can use a smaller value to obtain quicker (though less precise) results.\n", "maxSlots = 1000 # Number of Slots\n", "snrScheduler = SnrScheduler(-12,0.2, fastStep=1) # Start at -13 dB, use increments of 0.2 dB\n", "\n", "freqDomain = True # Apply channel in frequency domain\n", "modulation = \"16QAM\"\n", "numLayers = 2\n", "\n", "bwp = BandwidthPart(numRbs=45, spacing=30) # Create a BandwidthPart object\n", "\n", "# Create a two-layer PDSCH object with type-2 DMRS on symbols 2 and 11\n", "pdsch = PDSCH(bwp, numLayers=numLayers, modulation=modulation)\n", "pdsch.setDMRS(configType=2, additionalPos=1) # DMRS configuration\n", "\n", "# Create the LDPC codec\n", "# Note: The code that generated the results in the paper used LDPC numIter=20. Here\n", "# we use the default value, numIter=5. Therefore, the results here may be\n", "# slightly worse than those reported in the paper.\n", "ldpc = pdsch.getLdpcCodec(coderates=490/1024)\n", "channel = CdlChannel(bwp, 'C', delaySpread=300, carrierFreq=4e9, dopplerShift=5,\n", " txAntenna = AntennaPanel([2,4], polarization=\"x\"), # 16 TX antennas\n", " rxAntenna = AntennaPanel([1,2], polarization=\"x\")) # 4 RX antennas\n", "\n", "def equalizeAndDecode(rxGrid, chanEst, errVar=None):\n", " eqGrid, llrScales = pdsch.equalize(rxGrid, chanEst, errVar) # Equalization\n", " llrs = pdsch.getLLRs(eqGrid, llrScales) # Demodulation (to LLRs)\n", " decodedTxBlock, crcMatch = ldpc.decode(llrs[0]) # LDPC decoding\n", "\n", " cbErrors = (crcMatch[1:]==False).sum() # Number of code block errors\n", " return [cbErrors, len(crcMatch)-1], [decodedTxBlock, crcMatch]\n", "\n", "chEstMethods = [\"LS (DMRS)\", \"ML (DMRS)\", \"Self-Refining\", \"Perfect\"]\n", "results = {}\n", "\n", "for chEstMethod in chEstMethods:\n", " print(f'\\nEvaluating BLER with {chEstMethod} channel {\"knowledge\" if chEstMethod=='Perfect' else \"estimation\"}')\n", " if chEstMethod==\"Self-Refining\":\n", " print(\"SNR(dB) TX Blocks Block Errors BLER(%) Ret. Saved Rec. Code Blocks\")\n", " print(\"------- --------- ------------ ------- ---------- ----------------\")\n", " else:\n", " print(\"SNR(dB) TX Blocks Block Errors BLER(%)\")\n", " print(\"------- --------- ------------ -------\")\n", " \n", " snrScheduler.reset()\n", " for snrDb in snrScheduler:\n", " random.setSeed(seed)\n", " channel.restart() # Reset the channel and the bandwidth part\n", " \n", " totalRetransmissions = 0\n", " retransmissionsSaved = 0\n", " codeBlocksRecovered = 0\n", " \n", " t0 = time.time() # Start the timer\n", " blockErrors = 0\n", " totalBlocks = 0\n", " for s in range(maxSlots): # The inner loop doing 'numSlot' transmissions\n", " pdsch.initGrid() # Create and initialize PDSCH's internal grid\n", " numBits = pdsch.getBitCapacity()[0] # Number of bits available in the resource grid\n", " txBlock = random.bits(ldpc.txBlockSizes[0]) # Create random transport block\n", " rateMatchedCBs = ldpc.encode(txBlock, numBits)\n", " \n", " pdsch.setPdschData(rateMatchedCBs) # Map/modulate the data to the resource grid\n", "\n", " channelMatrix = channel.getChannelMatrix() # Get the channel matrix\n", " precoder = pdsch.getPrecodingMatrix(channelMatrix) # Get the precoder matrix from the PDSCH object\n", " perfectChannel = channel.getEffChannel(channelMatrix, precoder) # Get ground-truth effective channel\n", " txGrid = bwp.createGrid(channelMatrix.shape[3]) # Create the transmitted resource grid\n", " pdsch.precodeTo(txGrid, precoder) # Precode PDSCH data into the txGrid\n", " \n", " if freqDomain:\n", " rxGrid = txGrid.applyChannel(channelMatrix) # Apply the channel in the frequency domain\n", " noisyRxGrid = rxGrid.addNoise(snrDb=snrDb) # Add noise in the frequency domain\n", " else:\n", " txWaveform = txGrid.ofdmModulate() # OFDM modulation\n", " maxDelay = channel.getMaxDelay() # Calculate the maximum channel delay\n", " txWaveform = txWaveform.pad(maxDelay) # Pad the waveform with zeros\n", " rxWaveform = channel.applyToSignal(txWaveform) # Apply the channel to the waveform\n", " noisyRxWaveform = rxWaveform.addNoise(snrDb=snrDb, bwp=bwp) # Add noise\n", " offset = channel.getTimingOffset() # Get the timing offset for synchronization\n", " syncedWaveform = noisyRxWaveform.sync(offset) # Synchronize the received waveform\n", " noisyRxGrid = syncedWaveform.ofdmDemodulate(bwp) # OFDM-demodulate the synchronized waveform\n", "\n", " if chEstMethod==\"LS (DMRS)\":\n", " # LS channel estimation using DMRS\n", " lsChannelMatrix, errVar = pdsch.estimateChannel(noisyRxGrid)\n", " blerInfo, (decodedTxBlock, crcMatch) = equalizeAndDecode(noisyRxGrid, lsChannelMatrix, errVar)\n", "\n", " elif chEstMethod==\"ML (DMRS)\":\n", " # ML channel estimation using DMRS only\n", " dmrsIdx = pdsch.grid.getReIndexes(\"DMRS\")\n", " mlChannelMatrix = estimateChannelML(model, dmrsIdx, pdsch.grid, noisyRxGrid)\n", " blerInfo, (decodedTxBlock, crcMatch) = equalizeAndDecode(noisyRxGrid, mlChannelMatrix)\n", "\n", " elif chEstMethod==\"Self-Refining\":\n", " dmrsIdx = pdsch.grid.getReIndexes(\"DMRS\")\n", " mlChannelMatrix = estimateChannelML(model, dmrsIdx, pdsch.grid, noisyRxGrid)\n", " blerInfo, (decodedTxBlock, crcMatch) = equalizeAndDecode(noisyRxGrid, mlChannelMatrix)\n", "\n", " cbErrors, numCB = blerInfo\n", " # Now try using pseudo-pilots\n", " # Pseudo-pilots are relevant only when cbErrors ∈ {1,...,numCB-1}\n", " relevantCbErrors = np.arange(1,numCB)\n", " orgCbErrors = cbErrors\n", " while cbErrors in relevantCbErrors:\n", " pseudoPilotIndices = getPseudoPilotIndices(pdsch, ldpc, decodedTxBlock, crcMatch)\n", " allPilotIndices = tuple(np.append(pseudoPilotIndices[i],dmrsIdx[i]) for i in [0,1,2])\n", " mlChannelMatrix = estimateChannelML(model, allPilotIndices, pdsch.grid, noisyRxGrid)\n", " \n", " blerInfo, (decodedTxBlock, crcMatch) = equalizeAndDecode(noisyRxGrid, mlChannelMatrix)\n", " if blerInfo[0] >= cbErrors: break # No improvement\n", " cbErrors = blerInfo[0]\n", " \n", " totalRetransmissions += 1*(orgCbErrors in relevantCbErrors) # The retransmissions that could be saved\n", " codeBlocksRecovered += orgCbErrors - cbErrors\n", " retransmissionsSaved += 1*(cbErrors==0 and orgCbErrors>0)\n", "\n", " elif chEstMethod==\"Perfect\":\n", " blerInfo, (decodedTxBlock, crcMatch) = equalizeAndDecode(noisyRxGrid, perfectChannel)\n", " \n", " channel.goNext() # Prepare the channel model for the next slot\n", " blockErrors += 0 if crcMatch[0] else 1\n", " totalBlocks += 1\n", " bler = blockErrors*100/totalBlocks\n", " print(f\"\\r{snrDb:7.1f} {totalBlocks:9,d} {blockErrors:12,d} {bler:7.2f} \" +\n", " (f\"{retransmissionsSaved:10,d} {codeBlocksRecovered:17,d}\" if chEstMethod==\"Self-Refining\" else \"\"), end='')\n", "\n", " snrScheduler.setData(bler)\n", " print(\"\")\n", "\n", " results[chEstMethod] = snrScheduler.getSnrsAndData()\n" ] }, { "cell_type": "code", "execution_count": 4, "id": "3e18be6b-b5ed-4dc2-92ea-74e4fe7eb8fd", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "for i,chEstMethod in enumerate(chEstMethods):\n", " snrDbs, blers = results[chEstMethod]\n", " plt.plot(snrDbs, blers, label=chEstMethod)\n", "plt.legend()\n", "plt.title(\"Block Error Rate for Different Channel Estimation Methods\")\n", "plt.grid()\n", "plt.xlabel(\"SNR (dB)\")\n", "plt.ylabel(\"BLER (%)\")\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, "id": "c8b12473-861d-4508-8293-6375414670df", "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "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.10" } }, "nbformat": 4, "nbformat_minor": 5 }