def polar_codes_mapping(metric, N=8, k=4, nb_pkts = 100, graph = 'BER',channel='BSC'):
print('-------------------Polar Codes + Mapping-----------------------------')
cont = 2
if channel == 'AWGN':
design_parameter = np.linspace(0.0, 10, cont)
else:
design_parameter = np.linspace(0.0001, 0.1, cont)
for key in [0.5]:
e_design = 0.1
# print('===============Design================',key)
G,infoBits = polar.polar_generator_matrix(64, k, channel, e_design)
k = len(G)
Nt = len(G[1])
t = int(Nt /N)
U_k = utils.symbols_generator(k) # all possible messages
X_m = utils.symbols_generator(t) # all possible symbol sequences
C = utils.matrix_codes(U_k, k, G, Nt)
nx = 2**t*key
# print('nx', nx, 't', t)
x = utils.mapping2(C, X_m, t, nx)
N = len(x[1])
if graph == 'BLER':
metric[f"P({e_design})+M({key})"] = utils.block_error_probability(N,k,x,e0,e1)
else:
metric[f"P({e_design})+M({key})"] = utils.bit_error_rate(k,x,nb_pkts,e0,e1)
def integrated_scheme(metric,
N=8,
k=4,
nb_pkts=100,
graph='BER',
channel='BSC'):
print(
'-------------------Integrated Scheme Code-----------------------------'
)
for key in [0.5]:
G, infoBits = polar.polar_generator_matrix(64, k, channel, 0.1)
k = len(G)
Nt = len(G[1])
t = int(Nt / N)
U_k = utils.symbols_generator(k) # all possible messages
C = utils.integrated_function(infoBits, U_k, k, Nt, -1)
X_m = utils.symbols_generator(t) # all possible symbol sequences
nx = 2**t * key
# print('nx', nx, 't', t)
x = utils.mapping(C, X_m, t, nx)
N = len(x[1])
if graph == 'BLER':
metric[f"Int_P({key})"] = utils.block_error_probability(
N, k, C, e0, e1)
else:
metric[f"Int_P({key})"] = utils.bit_error_rate(
k, x, nb_pkts, e0, e1)
def polar_codes(metric, N=8, k=4, nb_pkts = 100, graph = 'BER',channel='BSC'):
print('-------------------Polar Code-----------------------------')
for key in [0.1]:
G, infoBits = polar.polar_generator_matrix(N,k, channel, key)
k = len(G)
N = len(G[1])
U_k = utils.symbols_generator(k) # all possible messages
C = utils.matrix_codes(U_k, k, G, N)
# print('Polar codebook', np.array(C))
if graph == 'BLER':
metric[f"Polar({key})"] = utils.block_error_probability(N,k,C,e0,e1)
else:
metric[f"Polar({key})"] = utils.bit_error_rate(k,C,nb_pkts,e0,e1)
print(metric[f"Polar({key})"])
def polar_codes_NN(metric, N=8, k=4, nb_pkts = 100, graph = 'BER',channel='BSC'):
print('-------------------Polar Code + NN decoder -----------------------------')
key = 'NN_dec'
G,infoBits = polar.polar_generator_matrix(N, k, channel, 0.1)
# print('G = ', np.array(G))
k = len(G)
N = len(G[1])
U_k = utils.symbols_generator(k) # all possible messages
C = utils.matrix_codes(U_k, k, G, N)
print('k ', k, 'N ', N)
if graph == 'BLER':
metric[key] = utils.block_error_probability(N, k, C, e0, e1)
else:
metric[key] = utils.bit_error_rate_NN(N, k, C, nb_pkts, e0, e1, channel)
#### Uncomment these lines and comment the def polar_no_mapping(): to use directly (remember the return at the end)
channel_type = sys.argv[3]
k = int(sys.argv[2])
N = int(sys.argv[1])
cont = 5
if channel_type == 'AWGN':
design_parameter = np.linspace(0.0, 10, cont)
else:
design_parameter = np.linspace(0.1, 0.5, cont)
legends = []
FER = {}
for e_design in design_parameter:
print('===============================', e_design)
legends.append(f"p = {e_design:.2f}")
G, infoBits = polar.polar_generator_matrix(N, k, channel_type, e_design)
# print(G)
k = len(G)
N = len(G[1])
U_k = bac.symbols_generator(k) # all possible messages
Y_n = bac.symbols_generator(N) # all possible symbol sequences
C = bac.matrix_codes(U_k, k, G, N)
e0 = np.linspace(0.1, 0.9, 9)
e1 = np.linspace(0.1, 0.5, 5)
# print("0.00", '|', ["{:.4f}".format(ep1) for ep1 in e1])
# print('------------------------------------------------------------------')
error_probability = {}
for ep0 in e0:
row = []
def bler_metric(u_true, u_predict):
return K.mean(K.not_equal(K.argmax(u_true, 1), K.argmax(u_predict, 1)))
#Parameters
###### \Python3\python.exe decoder.py BAC 8 4 10
channel = sys.argv[1]
N = int(sys.argv[2])
k = int(sys.argv[3])
epoch = int(sys.argv[4])
G = G, infoBits = polar.polar_generator_matrix(N, k, channel, 0.1)
k = len(G) #Nombre de bits � envoyer
N = len(G[1]) #codeword length
rep = 500
train_epsilon = 0.1
S = 5
################### Coding
U_k = utils.symbols_generator(k) # all possible messages
cn = utils.matrix_codes(U_k, k, G, N)
# print('codebook',np.array(cn))
print('size C: ', len(cn), 'size Cn: ', len(cn[0]))
c = np.array(cn)
print(type(c[0]))
import random as rd
import utils
cont = 5
if sys.argv[3] == 'AWGN':
design_parameter = np.linspace(0.0, 10, cont)
else:
design_parameter = np.linspace(0.1, 0.5, cont)
legends = []
BER = {}
for e_design in design_parameter:
print('===============================', e_design)
legends.append(f"p = {e_design:.2f}")
G, infoBits = polar.polar_generator_matrix(int(sys.argv[1]),
int(sys.argv[2]), sys.argv[3],
e_design)
# print(G)
k = len(G)
N = len(G[1])
U_k = bac.symbols_generator(k) # all possible messages
Y_n = bac.symbols_generator(N) # all possible symbol sequences
C = bac.matrix_codes(U_k, k, G, N)
B = 1000
e0 = np.linspace(0.1, 0.9, 9)
e1 = np.linspace(0.1, 0.5, 5)
bep = {}
ber = {}
for ep0 in e0:
