params, output_dir = settings.init_simulation(SIMULATIONS_NAME)
# データを生成する
snrs_db = np.linspace(params['SNR_MIN'], params['SNR_MAX'],
params['SNR_NUM'])
sigmas = m.sigmas(snrs_db) # SNR(dB)を元に雑音電力を導出
loss_array = np.zeros(
(params['SNR_NUM'], params['SNR_AVERAGE'], params['nEpochs']))
val_loss_array = np.zeros(
(params['SNR_NUM'], params['SNR_AVERAGE'], params['nEpochs']))
error_array = np.zeros((len(snrs_db), params['SNR_AVERAGE']))
for trials_index in tqdm(range(params['SNR_AVERAGE'])):
h_si = m.channel(1, params['h_si_len'])
h_s = m.channel(1, params['h_s_len'])
for sigma_index, sigma in enumerate(sigmas):
logging.info("SNR_AVERAGE_index:" + str(trials_index))
logging.info("sigma_index:" + str(sigma_index))
system_model = PreviousSystemModel(
sigma,
params['gamma'],
params['phi'],
params['PA_IBO_dB'],
params['PA_rho'],
params['LNA_IBO_dB'],
params['LNA_rho'],
h_si,
previous_errors = np.zeros((params['SNR_NUM'], params['SNR_AVERAGE']))
previous_losss = np.zeros(
(params['SNR_NUM'], params['SNR_AVERAGE'], params['nEpochs']))
previous_val_losss = np.zeros(
(params['SNR_NUM'], params['SNR_AVERAGE'], params['nEpochs']))
error_array = np.zeros((len(snrs_db), params['SNR_AVERAGE']))
lin_error_array = np.zeros((len(snrs_db), params['SNR_AVERAGE']))
non_cancell_error_array = np.zeros((len(snrs_db), params['SNR_AVERAGE']))
for trials_index in tqdm(range(params['SNR_AVERAGE'])):
# 通信路は毎回生成する
h_si = []
h_s = []
for i in range(params['receive_antenna_max']):
h_si.append(m.channel(1, params['h_si_len']))
h_s.append(m.channel(1, params['h_s_len']))
for sigma_index, sigma in enumerate(sigmas):
logging.info("SNR_AVERAGE_index:" + str(trials_index))
logging.info("sigma_index:" + str(sigma_index))
for i, receive_antenna_count in enumerate(
range(params['receive_antenna_min'],
params['receive_antenna_max'] + 1)):
proposal_sigma = sigma * receive_antenna_count
nn_model = proposal(params, proposal_sigma, h_si[:i + 1],
h_s[:i + 1], receive_antenna_count)
errors[i][sigma_index][trials_index] = nn_model.error
losss[i][sigma_index][
trials_index][:] = nn_model.history.history['loss']
params['SNR_NUM'])
sigmas = m.sigmas(snrs_db) # SNR(dB)を元に雑音電力を導出
errors = np.zeros(
(len(params['IBO_dB']), params['SNR_NUM'], params['SNR_AVERAGE']))
losss = np.zeros((len(params['IBO_dB']), params['SNR_NUM'],
params['SNR_AVERAGE'], params['nEpochs']))
val_losss = np.zeros((len(params['IBO_dB']), params['SNR_NUM'],
params['SNR_AVERAGE'], params['nEpochs']))
# 実行時の時間を記録する
start = time.time()
for snr_index in range(params['SNR_AVERAGE']):
# 通信路は毎回生成する
h_si = m.channel()
h_s = m.channel()
logging.info('random channel')
logging.info('h_si:{0.real}+{0.imag}i'.format(h_si))
logging.info('h_s:{0.real}+{0.imag}i'.format(h_s))
for IBO_index, IBO_dB in enumerate(params['IBO_dB']):
for index, sigma in enumerate(sigmas):
logging.info("IBO_dB_index:" + str(IBO_index))
logging.info("SNR_AVERAGE_index:" + str(snr_index))
logging.info("sigma_index:" + str(index))
logging.info("time: %d[sec]" % int(time.time() - start))
system_model = SystemModel(
params['n'],
sigma,
params['gamma'],
}
settings.dump_params(params, dirname)
ofdm_zero = np.hstack((np.zeros((params["subcarrier"], params["CP"])), np.eye(params["subcarrier"])))
F = dft(params['subcarrier'], "sqrtn")
FH = F.conj().T
snrs_db = m.snr_db(params['SNR_MIN'], params['SNR_MAX'], params['SNR_NUM'])
sigmas = m.sigmas(snrs_db)
errors = np.zeros((params['SNR_NUM'], params['SNR_AVERAGE']))
q_errors = np.zeros((params['SNR_NUM'], params['SNR_AVERAGE']))
for trials_index in range(params['SNR_AVERAGE']):
h_si = m.channel(1, params['chanel_len'])
H = ofdm.toeplitz_channel(h_si.T, params['chanel_len'], params['subcarrier'], params['CP'])
z_H = np.hstack((np.zeros((H.shape[0], params["subcarrier"] + params["CP"] - 3)), H))
Hc = ofdm.circulant_channel(h_si.T, params['chanel_len'], params['subcarrier'])
D = F @ Hc @ FH
D_1 = np.linalg.inv(D)
for sigma_index, sigma in enumerate(sigmas):
d = np.random.choice([0, 1], (params['subcarrier'] * 2 * params['block'], 1))
s_n = m.modulate_qpsk(d)
s = s_n.reshape(params['subcarrier'], params['block'])
x = np.matmul(FH, s)
x_cp = ofdm.add_cp(x, params['CP'])
x_receive = x_cp
logging.info(params)
# データを生成する
snr = params['snr']
sigma = m.sigmas(snr) # SNR(dB)を元に雑音電力を導出
var_si_var_s_db = np.linspace(params['var_min'], params['var_max'],
params['var_num'])
var_si_var_s = m.to_exact_number(var_si_var_s_db)
var_si = 1
var_s_list = var_si / var_si_var_s
non_cancell_error = np.zeros(
(params['var_num'], params['number_of_trials']))
for trials_index in tqdm(range(params['number_of_trials'])):
for var_s_index, var_s in enumerate(var_s_list):
# 通信路は毎回生成する
h_si = m.channel(1, params['h_si_len'], var_si)
h_s = m.channel(1, params['h_s_len'], var_s)
logging.info('random channel')
logging.info('h_si:{0.real}+{0.imag}i'.format(h_si))
logging.info('h_s:{0.real}+{0.imag}i'.format(h_s))
logging.info("number_of_trials_index:" + str(trials_index))
logging.info("var_s_index:" + str(var_s_index))
system_model = SystemModel(
params['n'],
sigma,
params['gamma'],
params['phi'],
params['PA_IBO_db'],
params['PA_rho'],
params['LNA_IBO_dB'],
H_col[0] = h[0]
H = toeplitz(H_col, r=H_row)
return H
if __name__ == '__main__':
SIMULATIONS_NAME = 'mmse_test'
n = 20000
h_s_len = 2
L_w = h_s_len - 1
noise_var = 0.05
sigma = np.sqrt(noise_var)
h_s = m.channel(1, h_s_len)
print(h_s)
d_s = np.random.choice([0, 1], n)
s = m.modulate_qpsk(d_s)
H = toeplitz_h(h_s.T, h_s_len, L_w)
chanels_s = np.array([
s[i:i + h_s_len] for i in range(s.size - h_s_len + 1)
]) # [[x[n], x[n-1]], x[x-1], x[n-1]]のように通信路の数に合わせる
chanels_s = h_s * chanels_s
y_s = np.sum(chanels_s, axis=1)
r = y_s + m.awgn(y_s.shape, sigma)
(params['var_num'], params['number_of_trials'], params['nEpochs']))
val_losss = np.zeros(
(params['var_num'], params['number_of_trials'], params['nEpochs']))
# 実行時の時間を記録する
start = time.time()
nn_models = [[None] * params['number_of_trials']
for i in range(params['var_num'])]
for trials_index in tqdm(range(params['number_of_trials'])):
for var_s_index, var_s in enumerate(var_s_list):
# 通信路は毎回生成する
h_si = []
h_s = []
for i in range(params['receive_antenna']):
h_si.append(m.channel(1, params['h_si_len'], var_si))
h_s.append(m.channel(1, params['h_s_len'], var_s))
logging.info('random channel')
logging.info("number_of_trials_index:" + str(trials_index))
logging.info("var_s_index:" + str(var_s_index))
logging.info("time: %d[sec]" % int(time.time() - start))
system_model = SystemModel(
params['n'],
sigma,
params['gamma'],
params['phi'],
params['PA_IBO_db'],
params['PA_rho'],
params['LNA_IBO_dB'],
params['LNA_rho'],
def __init__(self,
n,
sigma,
gamma=0.0,
phi=0.0,
PA_IBO_dB=5,
PA_rho=2,
LNA_IBO_dB=5,
LNA_rho=2,
h_si_list=None,
h_s_list=None,
h_si_len=1,
h_s_len=1,
receive_antenna=1,
tx_iqi=True,
pa=True,
lna=True,
rx_iqi=True):
# 送信信号
self.d = np.random.choice([0, 1], n)
self.x = m.modulate_qpsk(self.d)
# 希望信号
self.d_s = np.random.choice([0, 1], n)
self.s = m.modulate_qpsk(self.d_s)
# 送信側非線形
if tx_iqi == True:
self.x_iq = m.iq_imbalance(self.x, gamma, phi)
else:
self.x_iq = self.x
if pa == True:
self.x_pa = m.sspa_rapp_ibo(self.x_iq, PA_IBO_dB, PA_rho)
else:
self.x_pa = self.x_iq
# 通信路
# 通信路がランダムの場合
if h_si_list is None:
h_si_list = [m.channel(size=self.x_pa.size)]
if h_s_list is None:
h_s_list = [m.channel(size=self.s.size)]
self.h_si_list = h_si_list
self.h_s_list = h_s_list
x_len = self.x_pa.size - h_si_len + 1 # 周波数選択性の場合，時間のずれを考慮すると長さがnではなくなる
self.y = np.zeros((x_len, receive_antenna), dtype=complex)
for i, (h_si, h_s) in enumerate(zip(h_si_list, h_s_list)):
chanels_x_pa = np.array([
self.x_pa[i:i + h_si_len]
for i in range(self.x_pa.size - h_si_len + 1)
]) # [[x[n], x[n-1]], x[x-1], x[n-1]]のように通信路の数に合わせる
chanels_y_si = h_si * chanels_x_pa
y_si = np.sum(chanels_y_si, axis=1)
chanels_s = np.array([
self.s[i:i + h_s_len] for i in range(self.s.size - h_s_len + 1)
]) # [[x[n], x[n-1]], x[x-1], x[n-1]]のように通信路の数に合わせる
chanels_s = h_s * chanels_s
y_s = np.sum(chanels_s, axis=1)
r = y_si + y_s + m.awgn(y_s.shape, sigma)
# 受信側非線形
if lna == True:
y_lna = m.sspa_rapp_ibo(r, LNA_IBO_dB, LNA_rho).squeeze()
else:
y_lna = r
if rx_iqi == True:
y_iq = m.iq_imbalance(y_lna, gamma, phi)
else:
y_iq = y_lna
self.y[:, i] = y_iq
