def bit_error_rate_NN(N, k, C, Nb_sequences, e0, e1, channel='BSC'): print( '*******************NN-Decoder********************************************' ) # model_decoder = keras.models.load_model("autoencoder/model_decoder_bsc_16_8_array.h5") # model_decoder = keras.models.load_model("./model/model_decoder_16_4_std.h5") print("Decoder Loaded from disk, ready to be used") U_k = utils.symbols_generator(k) # all possible messages ber = {} bler = {} count = 0 Nb_iter_max = 10 Nb_words = int(Nb_sequences / Nb_iter_max) for ep0 in e0: ber_row = [] bler_row = [] for ep1 in (ep1 for ep1 in e1 if ep1 + ep0 <= 1 and ep1 <= ep0): if ep1 == ep0 or ep1 == e0[0]: N_errors = 0 N_errors_bler = 0 N_iter = 0 while N_iter < Nb_iter_max: # and N_errors < N_errors_mini: N_iter += 1 idx = np.random.randint(0, len(U_k) - 1, size=(1, Nb_words)).tolist()[0] u = [U_k[a] for a in idx] x = [C[a] for a in idx] # coded bits y_bac = [utils.BAC_channel(xi, ep0, ep1) for xi in x] # received symbols yh = np.reshape(y_bac, [Nb_words, N]).astype(np.float64) u_nn = [ U_k[idy] for idy in np.argmax(model_dec.predict(yh), 1) ] # NN Detector for i in range(len(u)): N_errors += np.sum( np.abs(np.array(u[i]) - np.array(u_nn[i])) ) # bit error rate compute with NN N_errors_bler += np.sum(1.0 * (u[i] != u_nn[i])) ber_row.append( N_errors / (k * 1.0 * Nb_sequences)) # bit error rate compute with NN bler_row.append( N_errors_bler / (1.0 * Nb_sequences)) # block error rate compute with NN ber[ep0] = ber_row bler[ep0] = bler_row print("{:.2f}".format(ep0), '|', ["{:.4f}".format(a) for a in ber_row]) print("{:.2f}".format(ep0), '|', ["{:.4f}".format(a) for a in bler_row]) count += 1 print("{:.3f}".format(count / len(e0) * 100), '% completed ') return ber, bler
def bit_error_rate_NN(N, k, C, N_iter_max, e0, e1, channel='BSC'): print( '******************* NN-Decoder ********************************************', channel) N_errors_mini = 100 U_k = utils.symbols_generator(k) # all possible messages ber = {} count = 0 for ep0 in e0: ber_row = [] interval = np.zeros(4) # interval[int(ep1*4)] = 1.0 interval[int(3 * np.log10(ep0) + 4) if ep0 >= 0.1 else 0] = 1.0 for ep1 in (ep1 for ep1 in e1 if ep1 + ep0 <= 1 and ep1 <= ep0): if ep1 == ep0 or ep1 == e0[0]: N_errors = 0 N_iter = 0 while N_iter < N_iter_max: # and N_errors < N_errors_mini: N_iter += 1 idx = np.random.randint(0, len(U_k) - 1) u = U_k[idx] # Bits to be sent x = C[idx] # coded bits y_bac = utils.BAC_channel(x, ep0, ep1) # received symbols yh = np.reshape( np.concatenate((y_bac, interval), axis=0), [1, N + 4] ) #if channel == 'BAC' else np.reshape(y_bac, [1, N]).astype(np.float64) u_nn = U_k[np.argmax(model_decoder(yh))] # NN Detector N_errors += utils.NbOfErrors( u, u_nn) # bit error rate compute with NN ber_tmp = N_errors / (k * 1.0 * N_iter ) # bit error rate compute with NN ber_row.append(ber_tmp) ber[ep0] = ber_row print("{:.2f}".format(ep0), '|', ["{:.4f}".format(a) for a in ber_row]) count += 1 print("{:.3f}".format(count / len(e0) * 100), '% completed ') return ber
def bit_error_rate_NN_decoder_irregular(N, k, C, nb_packets, e0, e1, model_decoder, output): """ computes the bit an block error rate using the NN-model decoder when external irregular interval @param C: codebook @param nb_packets: number of packets used in the computation @param e0 and e1: linspaces containing all the values of epsilon_0 and epsilon_1 to be evaluated @param model_decoder: the NN-model of the decoder, previously trained @param output: type of output 'array' or 'one' (One-hot coding) it must agree with the type of the decoder model @return: two dictionaries 'ber' and 'bler' containing metrics, as keys use the ep0 """ print( f'*******************NN-Decoder******************************************** {nb_packets} packets' ) U_k = utils.symbols_generator(k) # all possible messages ber = {} bler = {} count = 0 Nb_iter_max = 10 Nb_words = int(nb_packets / Nb_iter_max) for ep0 in e0: ber_row = [] bler_row = [] # interval = np.eye(4)[int(ep0*4/e_t-0.5) if ep0 < e_t else 3] interval = np.eye(4)[int(9.30 * ep0**0.5) if int(9.30 * ep0**0.5) < 4 else 3] inter_list = np.array(np.tile(interval, (Nb_words, 1))) for ep1 in (ep1 for ep1 in e1 if ep1 + ep0 <= 1 and ep1 <= ep0): # if ep1 == ep0 or ep1 == e0[0]: #change to this if wants to compute for all epsilon if ep1 == e0[0]: #just for the most asymmetric case N_errors = 0 N_errors_bler = 0 N_iter = 0 while N_iter < Nb_iter_max: # and N_errors < N_errors_mini: N_iter += 1 idx = np.random.randint(0, len(U_k) - 1, size=(1, Nb_words)).tolist()[0] u = [U_k[a] for a in idx] x = [C[a] for a in idx] # coded bits # print('uk\n',u,'\nc\n',x) y_bac = [utils.BAC_channel(xi, ep0, ep1) for xi in x] # received symbols yh = np.reshape(y_bac, [Nb_words, N]).astype(np.float64) yh = np.concatenate((yh, inter_list), 1) if output == 'one': u_nn = [ U_k[idy] for idy in np.argmax(model_decoder.predict(yh), 1) ] # NN Detector elif output == 'array': u_nn = [ idy for idy in np.round( model_decoder.predict(yh + inter_list)).astype( 'int').tolist() ] # NN Detector for i in range(len(u)): N_errors += np.sum( np.abs(np.array(u[i]) - np.array(u_nn[i])) ) # bit error rate compute with NN N_errors_bler += np.sum(1.0 * (u[i] != u_nn[i])) ber_row.append( N_errors / (k * 1.0 * nb_packets)) # bit error rate compute with NN bler_row.append( N_errors_bler / (1.0 * nb_packets)) # block error rate compute with NN ber[ep0] = ber_row bler[ep0] = bler_row # print("{:.2f}".format(ep0), '|', ["{:.4f}".format(a) for a in ber_row]) # print("{:.2f}".format(ep0), '|', ["{:.4f}".format(a) for a in bler_row]) count += 1 print("{:.3f}".format(count / len(e0) * 100), '% completed ') return ber, bler