def turbo_compute((idx, x)):
'''
Compute Turbo Decoding in 1 iterations for one SNR point.
'''
np.random.seed()
message_bits = np.random.randint(0, 2, args.block_len)
[sys, par1, par2] = turbo.turbo_encode(message_bits, trellis1,
trellis2, interleaver)
sys_r = corrupt_signal(sys,
noise_type=args.noise_type,
sigma=test_sigmas[idx])
par1_r = corrupt_signal(par1,
noise_type=args.noise_type,
sigma=test_sigmas[idx])
par2_r = corrupt_signal(par2,
noise_type=args.noise_type,
sigma=test_sigmas[idx])
decoded_bits = turbo.hazzys_turbo_decode(sys_r,
par1_r,
par2_r,
trellis1,
test_sigmas[idx]**2,
args.num_dec_iteration,
interleaver,
L_int=None)
num_bit_errors = hamming_dist(message_bits, decoded_bits)
return num_bit_errors
def turbo_enc(X_train_raw, args, p_array):
num_block = X_train_raw.shape[0]
x_code = []
if args.encoder == 'Turbo_rate3_lte': # Turbo-LTE
M = np.array(
[3]) # Number of delay elements in the convolutional encoder
generator_matrix = np.array([[13,
11]]) # Encoder of convolutional encoder
feedback = 13 # Feedback of convolutional encoder
else: # Turbo-757
M = np.array(
[2]) # Number of delay elements in the convolutional encoder
generator_matrix = np.array([[7,
5]]) # Encoder of convolutional encoder
feedback = 7 # Feedback of convolutional encoder
trellis1 = cc.Trellis(M, generator_matrix, feedback=feedback)
trellis2 = cc.Trellis(M, generator_matrix, feedback=feedback)
interleaver = RandInterlv.RandInterlv(args.block_len, 0)
interleaver.p_array = p_array
for idx in range(num_block):
#print(X_train_raw[idx, :, 0])
np_inputs = np.array(X_train_raw[idx, :,
0].type(torch.IntTensor).detach())
[sys, par1, par2] = turbo.turbo_encode(np_inputs, trellis1, trellis2,
interleaver)
xx = np.array([sys, par1, par2]).T
x_code.append(xx)
return torch.from_numpy(np.array(x_code)).type(torch.FloatTensor)
def build_rnn_data_feed(num_block, block_len, noiser, codec, is_all_zero = False ,is_same_code = False, **kwargs):
'''
:param num_block:
:param block_len:
:param noiser: list, 0:noise_type, 1:sigma, 2:v for t-dist, 3:radar_power, 4:radar_prob
:param codec: list, 0:trellis1, 1:trellis2 , 2:interleaver
:param kwargs:
:return: X_feed, X_message
'''
# Unpack Noiser
noise_type = noiser[0]
noise_sigma = noiser[1]
vv = 5.0
radar_power = 20.0
radar_prob = 5e-2
denoise_thd = 10.0
snr_mix = [0, 0, 0]
if noise_type == 't-dist':
vv = noiser[2]
elif noise_type == 'awgn+radar' or noise_type == 'hyeji_bursty':
radar_power = noiser[3]
radar_prob = noiser[4]
elif noise_type == 'awgn+radar+denoise' or noise_type == 'hyeji_bursty+denoise':
radar_power = noiser[3]
radar_prob = noiser[4]
denoise_thd = noiser[5]
elif noise_type == 'mix_snr_turbo' or noise_type == 'random_snr_turbo':
snr_mix = noiser[6]
elif noise_type == 'customize':
'''
TBD, noise model shall be open to other user, for them to train their own decoder.
'''
print('[Debug] Customize noise model not supported yet')
else: # awgn
pass
#print '[Build RNN Data] noise type is ', noise_type, ' noiser', noiser
# Unpack Codec
trellis1 = codec[0]
trellis2 = codec[1]
interleaver = codec[2]
p_array = interleaver.p_array
X_feed = []
X_message = []
same_code = np.random.randint(0, 2, block_len)
for nbb in range(num_block):
if is_same_code:
message_bits = same_code
else:
if is_all_zero == False:
message_bits = np.random.randint(0, 2, block_len)
else:
message_bits = np.random.randint(0, 1, block_len)
X_message.append(message_bits)
[sys, par1, par2] = turbo.turbo_encode(message_bits, trellis1, trellis2, interleaver)
sys_r = corrupt_signal(sys, noise_type =noise_type, sigma = noise_sigma,
vv =vv, radar_power = radar_power, radar_prob = radar_prob, denoise_thd = denoise_thd,
snr_mixture = snr_mix)
par1_r = corrupt_signal(par1, noise_type =noise_type, sigma = noise_sigma,
vv =vv, radar_power = radar_power, radar_prob = radar_prob, denoise_thd = denoise_thd,
snr_mixture = snr_mix)
par2_r = corrupt_signal(par2, noise_type =noise_type, sigma = noise_sigma,
vv =vv, radar_power = radar_power, radar_prob = radar_prob, denoise_thd = denoise_thd,
snr_mixture = snr_mix)
rnn_feed_raw = np.stack([sys_r, par1_r, np.zeros(sys_r.shape), intleave(sys_r, p_array), par2_r], axis = 0).T
rnn_feed = rnn_feed_raw
X_feed.append(rnn_feed)
X_feed = np.stack(X_feed, axis=0)
X_message = np.array(X_message)
X_message = X_message.reshape((-1,block_len, 1))
return X_feed, X_message
trellis1 = cc.Trellis(np.array([2]), np.array([[7, 5]]), feedback=7)
trellis2 = cc.Trellis(np.array([2]), np.array([[7, 5]]), feedback=7)
print('trellis: cc.Trellis(np.array([2]), np.array([[7,5]]),feedback=7) ')
interleaver = RandInterlv.RandInterlv(k, 0)
nb_errors = np.zeros(test_sigmas.shape)
map_nb_errors = np.zeros(test_sigmas.shape)
nb_block_no_errors = np.zeros(test_sigmas.shape)
tic = time.clock()
for iterations in range(iterations_number):
print(iterations)
message_bits = np.random.randint(0, 2, k)
[sys, par1, par2] = turbo.turbo_encode(message_bits, trellis1, trellis2,
interleaver)
for idx in range(len(test_sigmas)):
if NType == 'iid':
noise = test_sigmas[idx] * np.random.standard_normal(
sys.shape) # Define noise
sys_r = (2 * sys - 1) + noise # Modulation plus noise
noise = test_sigmas[idx] * np.random.standard_normal(
par1.shape) # Define noise
par1_r = (2 * par1 - 1) + noise # Modulation plus noise
noise = test_sigmas[idx] * np.random.standard_normal(
par2.shape) # Define noise
par2_r = (2 * par2 - 1) + noise # Modulation plus noise
decoded_bits = hazzys_turbo_decode(sys_r,
def generate_viterbi_batch(batch_size=100,
block_len=200,
code_rate=2,
batch_criteria={},
seed=0):
noise_type = batch_criteria["noise_type"]
SNR = batch_criteria["snr"]
rng = np.random.RandomState(seed)
# print("[generate_viterbi_batch] block_len, code_rate", block_len, code_rate)
trellis1 = cc.Trellis(np.array([2]), np.array([[7, 5]]))
trellis2 = cc.Trellis(np.array([2]), np.array([[7, 5]]))
#print('trellis: cc.Trellis(np.array([2]), np.array([[7,5]]))') # G(D) corresponding to the convolutional encoder
tic = time.time()
### TEST EXAMPLES
# Initialize Test Examples/
noisy_codewords = np.zeros([1, batch_size, block_len, 2])
true_messages = np.zeros([1, batch_size, block_len, 1])
iterations_number = batch_size
#for idx in range(SNR_points):
nb_errors = np.zeros([iterations_number, 1])
tic = time.time()
noise_sigmas = 10**(-SNR * 1.0 / 20)
mb_test_collect = np.zeros([iterations_number, block_len])
interleaver = RandInterlv.RandInterlv(block_len, 0)
message_bits = rng.randint(0, 2, block_len)
# mb_test_collect[iterations,:] = message_bits
[sys, par1, par2] = turbo.turbo_encode(message_bits, trellis1, trellis2,
interleaver)
# print("[debug] noise type ", noise_type, " noise_sigmas ", noise_sigmas,
# "vv", vv, "radar_power", radar_pow, "radar_prob", radar_prob)
for iterations in range(iterations_number):
noise_seed1 = rng.randint(1, 999999)
noise_seed2 = rng.randint(1, 999999)
noise_seed3 = rng.randint(1, 999999)
# print("seeds ", noise_seed1, noise_seed2)
sys_r = corrupt_signal(input_signal = sys, noise_type = noise_type, sigma = noise_sigmas, \
metrics = batch_criteria, seed = noise_seed1)
par1_r = corrupt_signal(input_signal = par1, noise_type = noise_type, sigma = noise_sigmas, \
metrics = batch_criteria, seed = noise_seed2)
par2_r = corrupt_signal(input_signal = par2, noise_type = noise_type, sigma = noise_sigmas ,\
metrics = batch_criteria, seed = noise_seed3)
# print("sys_r ", sys_r, flush=True)
# print("par1_r", par1_r, flush=True)
# ADD Training Examples
noisy_codewords[0, iterations, :, :] = np.concatenate(
[sys_r.reshape(block_len, 1),
par1_r.reshape(block_len, 1)],
axis=1)
# Message sequence
true_messages[0, iterations, :, :] = message_bits.reshape(block_len, 1)
noisy_codewords = noisy_codewords.reshape(batch_size, block_len, code_rate)
true_messages = true_messages.reshape(batch_size, block_len)
# target_true_messages = mb_test_collect.reshape([mb_test_collect.shape[0],mb_test_collect.shape[1],1])
toc = time.time()
#print('time to generate test examples:', toc-tic)
return (noisy_codewords, true_messages)
def encoder(self, x):
[sys, par1,
par2] = dturbo.turbo_encode(x, self.trellis1, self.trellis2,
self.interleaver)
# code_rate=3
return (sys, par1, par2)
def generate_examples(k_test=1000, step_of_history=200, SNR=0, code_rate=2):
trellis1 = cc.Trellis(np.array([2]), np.array([[7, 5]]))
trellis2 = cc.Trellis(np.array([2]), np.array([[7, 5]]))
#print('trellis: cc.Trellis(np.array([2]), np.array([[7,5]]))') # G(D) corresponding to the convolutional encoder
tic = time.time()
### TEST EXAMPLES
# Initialize Test Examples/
noisy_codewords = np.zeros(
[1, int(k_test / step_of_history), step_of_history, 2])
true_messages = np.zeros(
[1, int(k_test / step_of_history), step_of_history, 1])
iterations_number = int(k_test / step_of_history)
#for idx in range(SNR_points):
nb_errors = np.zeros([iterations_number, 1])
tic = time.time()
noise_sigmas = 10**(-SNR * 1.0 / 20)
mb_test_collect = np.zeros([iterations_number, step_of_history])
interleaver = RandInterlv.RandInterlv(step_of_history, 0)
for iterations in range(iterations_number):
# print(iterations)
message_bits = np.random.randint(0, 2, step_of_history)
mb_test_collect[iterations, :] = message_bits
[sys, par1, par2] = turbo.turbo_encode(message_bits, trellis1,
trellis2, interleaver)
noise = noise_sigmas * np.random.standard_normal(
sys.shape) # Generate noise
sys_r = (2 * sys - 1) + noise # Modulation plus noise
noise = noise_sigmas * np.random.standard_normal(
par1.shape) # Generate noise
par1_r = (2 * par1 - 1) + noise # Modulation plus noise
noise = noise_sigmas * np.random.standard_normal(
par2.shape) # Generate noise
par2_r = (2 * par2 - 1) + noise # Modulation plus noise
sys_symbols = sys_r
non_sys_symbols_1 = par1_r
non_sys_symbols_2 = par2_r
# ADD Training Examples
noisy_codewords[0, iterations, :, :] = np.concatenate([
sys_r.reshape(step_of_history, 1),
par1_r.reshape(step_of_history, 1)
],
axis=1)
# Message sequence
true_messages[0, iterations, :, :] = message_bits.reshape(
step_of_history, 1)
noisy_codewords = noisy_codewords.reshape(int(k_test / step_of_history),
step_of_history, code_rate)
true_messages = true_messages.reshape(int(k_test / step_of_history),
step_of_history, 1)
target_true_messages = mb_test_collect.reshape(
[mb_test_collect.shape[0], mb_test_collect.shape[1], 1])
toc = time.time()
#print('time to generate test examples:', toc-tic)
return (noisy_codewords, true_messages, target_true_messages)
def generate_bcjr_example(num_block, block_len, codec, num_iteration, is_save = True, train_snr_db = 0.0, save_path = './tmp/',
**kwargs ):
'''
Generate BCJR feature and target for training BCJR-like RNN codec from scratch
'''
start_time = time.time()
# print
print('[BCJR] Block Length is ', block_len)
print('[BCJR] Number of Block is ', num_block)
input_feature_num = 3
noise_type = 'awgn'
noise_sigma = snr_db2sigma(train_snr_db)
identity = str(np.random.random()) # random id for saving
# Unpack Codec
trellis1 = codec[0]
trellis2 = codec[1]
interleaver = codec[2]
# Initialize BCJR input/output Pair for training (Is that necessary?)
bcjr_inputs = np.zeros([2*num_iteration, num_block, block_len ,input_feature_num])
bcjr_outputs = np.zeros([2*num_iteration, num_block, block_len ,1 ])
for block_idx in range(num_block):
# Generate Noisy Input For Turbo Decoding
message_bits = np.random.randint(0, 2, block_len)
[sys, par1, par2] = turbo.turbo_encode(message_bits, trellis1, trellis2, interleaver)
sys_r = corrupt_signal(sys, noise_type =noise_type, sigma = noise_sigma,)
par1_r = corrupt_signal(par1, noise_type =noise_type, sigma = noise_sigma)
par2_r = corrupt_signal(par2, noise_type =noise_type, sigma = noise_sigma)
# Use the Commpy BCJR decoding algorithm
sys_symbols = sys_r
non_sys_symbols_1 = par1_r
non_sys_symbols_2 = par2_r
noise_variance = noise_sigma**2
#print("+++++++++++++++++++")
#print("SYS_SYMBOLS: ", sys_symbols)
#print("+++++++++++++++++++")
sys_symbols_i = interleaver.interlv(sys_symbols)
trellis = trellis1
L_int = None
if L_int is None:
L_int = np.zeros(len(sys_symbols))
L_int_1 = L_int
L_ext_2 = L_int_1
weighted_sys = 2*sys_symbols*1.0/noise_variance # Is gonna be used in the final step of decoding.
weighted_sys_int = interleaver.interlv(weighted_sys)
for turbo_iteration_idx in range(num_iteration-1):
L_int_1 = interleaver.deinterlv(L_ext_2)
# MAP 1
[L_ext_1, decoded_bits] = turbo.map_decode(sys_symbols, non_sys_symbols_1,
trellis, noise_variance, L_int_1, 'compute')
L_ext_1 -= L_int_1
L_ext_1 -= weighted_sys
# ADD Training Examples
bcjr_inputs[2*turbo_iteration_idx,block_idx,:,:] = np.concatenate([sys_symbols.reshape(block_len,1),
non_sys_symbols_1.reshape(block_len,1),
L_int_1.reshape(block_len,1)],
axis=1)
bcjr_outputs[2*turbo_iteration_idx,block_idx,:,:]= L_ext_1.reshape(block_len,1)
# MAP 2
L_int_2 = interleaver.interlv(L_ext_1)
#print("+++++++++++++++++++++++++++++++++++")
#print(sys_symbols_i)
#print(sys_symbols_i.shape)
#print("+++++++++++++++++++++++++++++++++++")
[L_ext_2, decoded_bits] = turbo.map_decode(sys_symbols_i, non_sys_symbols_2,
trellis, noise_variance, L_int_2, 'compute')
L_ext_2 -= L_int_2
L_ext_2 -= weighted_sys_int
# ADD Training Examples
bcjr_inputs[2*turbo_iteration_idx+1,block_idx,:,:] = np.concatenate([sys_symbols_i.reshape(block_len,1),
non_sys_symbols_2.reshape(block_len,1),
L_int_2.reshape(block_len,1)],
axis=1)
bcjr_outputs[2*turbo_iteration_idx+1,block_idx,:,:] = L_ext_2.reshape(block_len,1)
# MAP 1
L_int_1 = interleaver.deinterlv(L_ext_2)
[L_ext_1, decoded_bits] = turbo.map_decode(sys_symbols, non_sys_symbols_1,
trellis, noise_variance, L_int_1, 'compute')
L_ext_1 -= L_int_1
L_ext_1 -= weighted_sys
# ADD Training Examples
bcjr_inputs[2*num_iteration-2,block_idx,:,:] = np.concatenate([sys_symbols.reshape(block_len,1),
non_sys_symbols_1.reshape(block_len,1),
L_int_1.reshape(block_len,1)],
axis=1)
bcjr_outputs[2*num_iteration-2,block_idx,:,:] = L_ext_1.reshape(block_len,1)
# MAP 2
L_int_2 = interleaver.interlv(L_ext_1)
[L_2, decoded_bits] = turbo.map_decode(sys_symbols_i, non_sys_symbols_2,
trellis, noise_variance, L_int_2, 'decode')
L_ext_2 = L_2 - L_int_2
L_ext_2 -= weighted_sys_int
# ADD Training Examples
bcjr_inputs[2*num_iteration-1,block_idx,:,:] = np.concatenate([sys_symbols_i.reshape(block_len,1),
non_sys_symbols_2.reshape(block_len,1),
L_int_2.reshape(block_len,1)],
axis=1)
bcjr_outputs[2*num_iteration-1,block_idx,:,:] = L_ext_2.reshape(block_len,1)
end_time = time.time()
print('[BCJR] The input feature has shape', bcjr_inputs.shape,'the output has shape', bcjr_outputs.shape)
print('[BCJR] Generating Training Example takes ', end_time - start_time , 'secs')
print('[BCJR] file id is', identity)
bcjr_inputs_train = bcjr_inputs.reshape((-1, block_len,input_feature_num ))
bcjr_outputs_train = bcjr_outputs.reshape((-1, block_len, 1))
target_train_select = bcjr_outputs_train[:,:,0] + bcjr_inputs_train[:,:,2]
target_train_select[:,:] = math.e**target_train_select[:,:]*1.0/(1+math.e**target_train_select[:,:])
X_input = bcjr_inputs_train.reshape(-1,block_len,input_feature_num)
X_target = target_train_select.reshape(-1,block_len,1)
return X_input, X_target
