Simple LDPC 5G sample (encoding - induce errors - decoding) not working.

[dyle71]

#!/bin/hi *

First of all: thx for this most inspiring framework!

Then: I tried some very basic simple stuff based on https://nvlabs.github.io/sionna/examples/Sionna_tutorial_part1.html#Forward-Error-Correction-(FEC):

1. Create some infowords.
2. Create simple codewords with the LDPC5GEncoder.
3. Apply some errors.
4. Run the LDPC5GDecoder.

I somehow fail to successfully get my infoword right out of the decoder. Almost no single codeword will be decoded correctly. I fail miserably. Where is my misunderstanding?

In detail here (full file is attached: fec.py.txt)

Step 1: Create input some input words.

#!/usr/bin/env python3

import numpy as np
import sionna as sn
import tensorflow as tf

# Based on https://nvlabs.github.io/sionna/examples/Sionna_tutorial_part1.html#Forward-Error-Correction-(FEC)

k = 12
n = 20

binary_source = sn.utils.BinarySource()

BATCH_SIZE = 8

u = binary_source([BATCH_SIZE, k])
print("Input bits are: \n", u.numpy())

Step 2: Create a codeword of each input word.

encoder = sn.fec.ldpc.LDPC5GEncoder(k, n)
c = encoder(u)
print("Encoded bits are: \n", c.numpy())

Step 3: "Introduce" some errors in the codeword.

Yes, this is just some simply, cheap bit flipping.

ber = 0.05
flipped_bits = int(n * ber)
flipped_positions = np.zeros((BATCH_SIZE, flipped_bits), dtype=int)
for i in range(BATCH_SIZE):
  flipped_positions[i] = np.random.permutation(n)[:flipped_bits]
print(f"Applying BER {ber:0.2f} - {flipped_bits} Bits.")
print("Bit error positions (0-indexed):\n", flipped_positions)

e = c.numpy()
for i in range(e.shape[0]):
  for j in flipped_positions[i]:
    e[i][j] = 1.0 if e[i][j] == 0.0 else 0.0
    
e = tf.convert_to_tensor(e, np.float32)
print("Codeword with errors: \n", e.numpy())

Step 4: Decode the "received" codeword.

decoder = sn.fec.ldpc.LDPC5GDecoder(encoder,
                                    hard_out=True,
                                    return_infobits=True,
                                    num_iter=20,
                                    cn_type="minsum")

w = decoder(e)
print("Decoded bits are: \n", w.numpy())

Step 5: Check, if the LDPC5GDecoder successfully recreated the infoword.

for i in range(u.shape[0]):
    errors_corrected = 'Success.' if (u[i].numpy() == w[i].numpy()).all() else 'Failed!'
    print(f"Corrected all errors in word {i + 1}: {errors_corrected}")

Which nearly always results in

Corrected all errors in word 1: Failed!
Corrected all errors in word 2: Failed!
Corrected all errors in word 3: Failed!
Corrected all errors in word 4: Failed!
Corrected all errors in word 5: Failed!
Corrected all errors in word 6: Failed!
Corrected all errors in word 7: Failed!
Corrected all errors in word 8: Failed!

---

In short, I do not see what am I doing wrong.

Until yet, I did not decode a single word successfully with Sionna. What is my misconception here?

[dyle71]

Add-on: this is a simple output when running fec.py:

Input bits are: 
 [[1. 0. 1. 0. 0. 1. 1. 0. 1. 1. 1. 1.]
 [1. 1. 0. 0. 1. 1. 0. 1. 1. 1. 1. 1.]
 [0. 0. 0. 0. 0. 0. 1. 1. 0. 0. 1. 0.]
 [0. 0. 0. 1. 0. 1. 0. 0. 1. 1. 0. 1.]
 [1. 0. 0. 0. 0. 0. 1. 1. 1. 1. 0. 0.]
 [0. 1. 1. 1. 0. 1. 1. 1. 0. 1. 0. 1.]
 [0. 1. 1. 0. 1. 0. 0. 0. 1. 1. 1. 0.]
 [1. 0. 0. 0. 0. 1. 1. 1. 1. 1. 0. 1.]]
Encoded bits are: 
 [[0. 1. 1. 0. 1. 1. 1. 1. 1. 0. 0. 1. 1. 0. 0. 1. 0. 1. 0. 1.]
 [1. 1. 0. 1. 1. 1. 1. 1. 1. 0. 1. 1. 0. 1. 0. 1. 0. 0. 1. 1.]
 [0. 0. 1. 1. 0. 0. 1. 0. 0. 0. 1. 1. 0. 1. 1. 0. 1. 1. 0. 1.]
 [0. 1. 0. 0. 1. 1. 0. 1. 0. 1. 1. 0. 1. 1. 1. 1. 0. 0. 1. 0.]
 [0. 0. 1. 1. 1. 1. 0. 0. 1. 0. 0. 0. 0. 1. 0. 1. 0. 1. 0. 1.]
 [0. 1. 1. 1. 0. 1. 0. 1. 1. 1. 0. 0. 0. 1. 0. 1. 0. 1. 0. 0.]
 [1. 0. 0. 0. 1. 1. 1. 0. 1. 1. 1. 0. 1. 0. 1. 0. 0. 1. 0. 0.]
 [0. 1. 1. 1. 1. 1. 0. 1. 0. 1. 1. 0. 0. 1. 1. 0. 0. 0. 0. 1.]]
Applying BER 0.05 - 1 Bits.
Bit error positions (0-indexed):
 [[ 4]
 [ 9]
 [ 4]
 [15]
 [ 1]
 [19]
 [ 8]
 [13]]
Codeword with errors: 
 [[0. 1. 1. 0. 0. 1. 1. 1. 1. 0. 0. 1. 1. 0. 0. 1. 0. 1. 0. 1.]
 [1. 1. 0. 1. 1. 1. 1. 1. 1. 1. 1. 1. 0. 1. 0. 1. 0. 0. 1. 1.]
 [0. 0. 1. 1. 1. 0. 1. 0. 0. 0. 1. 1. 0. 1. 1. 0. 1. 1. 0. 1.]
 [0. 1. 0. 0. 1. 1. 0. 1. 0. 1. 1. 0. 1. 1. 1. 0. 0. 0. 1. 0.]
 [0. 1. 1. 1. 1. 1. 0. 0. 1. 0. 0. 0. 0. 1. 0. 1. 0. 1. 0. 1.]
 [0. 1. 1. 1. 0. 1. 0. 1. 1. 1. 0. 0. 0. 1. 0. 1. 0. 1. 0. 1.]
 [1. 0. 0. 0. 1. 1. 1. 0. 0. 1. 1. 0. 1. 0. 1. 0. 0. 1. 0. 0.]
 [0. 1. 1. 1. 1. 1. 0. 1. 0. 1. 1. 0. 0. 0. 1. 0. 0. 0. 0. 1.]]
Decoded bits are: 
 [[0. 0. 0. 0. 0. 1. 1. 0. 0. 1. 1. 1.]
 [0. 1. 1. 1. 1. 1. 0. 1. 1. 1. 1. 1.]
 [1. 0. 0. 1. 0. 0. 1. 1. 1. 0. 1. 0.]
 [0. 0. 0. 0. 0. 1. 0. 0. 1. 1. 0. 1.]
 [0. 0. 0. 0. 0. 1. 1. 1. 1. 1. 0. 0.]
 [0. 0. 0. 1. 0. 1. 1. 1. 0. 1. 0. 1.]
 [0. 0. 0. 0. 1. 0. 0. 0. 1. 1. 1. 0.]
 [0. 0. 0. 0. 0. 1. 1. 1. 1. 1. 0. 1.]]
Corrected all errors in word 1: Failed!
Corrected all errors in word 2: Failed!
Corrected all errors in word 3: Failed!
Corrected all errors in word 4: Failed!
Corrected all errors in word 5: Failed!
Corrected all errors in word 6: Failed!
Corrected all errors in word 7: Failed!
Corrected all errors in word 8: Failed!

[SebastianCa]

Please note that the LDPC5GDecoder expects log-likelihood ratio (LLR) values as input.
As “minsum” decoding is already applied, a simple solution is to apply BPSK mapping to the decoder’s input
w = decoder(2*e-1))

Further, for the given code parameters 5% error rate is too large and decoding fails.
When going to longer codewords and less errors, all errors can be recovered in our experiment. For example you can try the following parameters:

• k = 120
• n = 200
• ber = 0.03

[dyle71]

Ah! LLR! m(
Thx!

So, applying your changes gives me:

$ for i in $(seq 1 10); do ./fec.py | grep ^Corrected ; done > ldpc-res
$ grep Success ldpc-res | wc -l; echo "out of $(wc -l ldpc-res) runs"
71
out of 80 ldpc-res runs

... ~89% success ratio of decoding with k=120, n=200 (this is a code-rate of 0.6, right?) and 0.03 BER.

Are these reasonable numbers?

[SebastianCa]

The results sound reasonable. However, most 5G LDPC BER curves in literature are provided for the AWGN channel (e.g., in [1]).

[1] T. Richardson and S. Kudekar, "Design of Low-Density Parity Check Codes for 5G New Radio," in IEEE Communications Magazine, vol. 56, no. 3, pp. 28-34, March 2018.