def non_cancel_simulation(param: dict, sigma, h_si, h_s) -> np.ndarray:
system_model = PreviousSystemModel(
sigma,
params['gamma'],
params['phi'],
params['PA_IBO_dB'],
params['PA_rho'],
params['LNA_IBO_dB'],
params['LNA_rho'],
h_si,
params['h_si_len'],
h_s,
params['h_s_len'],
)
system_model.set_lna_a_sat(
params['lin_n'],
params['LNA_IBO_dB'],
)
system_model.transceive_si_s(
params['lin_n'],
)
s_hat = system_model.y * h_s.conj() / (np.abs(h_s)**2)
d_hat = m.demodulate_qpsk(s_hat)
d_hat_len = d_hat.shape[0]
error = np.sum(system_model.d_s[0:d_hat_len] != d_hat)
return error
def lin_cancel_simulation(params: dict, sigma, h_si, h_s) -> np.ndarray:
system_model = PreviousSystemModel(
sigma, params['gamma'], params['phi'], params['PA_IBO_dB'],
params['PA_rho'], params['LNA_IBO_dB'], params['LNA_rho'], h_si,
params['h_si_len'], h_s, params['h_s_len'], params['TX_IQI'],
params['PA'], params['LNA'], params['RX_IQI'])
system_model.set_lna_a_sat(
params['lin_n'],
params['LNA_IBO_dB'],
)
system_model.transceive_si(params['lin_n'])
h_lin = fd.ls_estimation(system_model.x[0:int(params['lin_n'] / 2)],
system_model.y, params['h_si_len'])
system_model.transceive_si_s(params['lin_n'], )
yCanc = fd.si_cancellation_linear(
system_model.x[0:int(params['lin_n'] / 2)], h_lin)
cancelled_y = system_model.y - yCanc
s_hat = cancelled_y * h_s.conj() / (np.abs(h_s)**2)
d_hat = m.demodulate_qpsk(s_hat)
d_hat_len = d_hat.shape[0]
error = np.sum(system_model.d_s[0:d_hat_len] != d_hat)
return error
def simulation(block: int,
subcarrier: int,
CP: int,
sigma: float,
gamma: float,
phi: float,
PA_IBO_dB: float,
PA_rho: float,
LNA_alpha_1: float,
LNA_alpha_2: float,
h_si_list: list,
h_s_list: list,
h_si_len: int,
h_s_len: int,
TX_IQI: bool,
PA: bool,
LNA: bool,
RX_IQI: bool,
trainingRatio: float,
compensate_iqi: bool = False,
receive_antenna=1,
equalizer='ZF') -> np.ndarray:
h_si = h_si_list[0:receive_antenna]
h_s = h_s_list[0:receive_antenna]
training_block = int(block * trainingRatio)
test_block = block - training_block
system_model = OFDMSystemModel(test_block, subcarrier, CP, sigma, gamma,
phi, PA_IBO_dB, PA_rho, LNA_alpha_1,
LNA_alpha_2, h_si, h_s, h_si_len, h_s_len,
receive_antenna, TX_IQI, PA, LNA, RX_IQI)
s_hat_array = np.zeros((receive_antenna, system_model.d.shape[0] // 2),
dtype=complex)
for i in range(receive_antenna):
y = system_model.y[:, i]
if compensate_iqi is True:
y = m.compensate_iqi(y.flatten(order='F'), gamma, phi)
if equalizer == 'MMSE':
s_hat_array[i] = system_model.demodulate_ofdm_dft_mmse(
y, h_s_list[i], h_s_len, sigma)
else:
# MMSE以外が指定されている場合は，ZF
s_hat_array[i] = system_model.demodulate_ofdm_dft(
y, h_s_list[i], h_s_len)
s_hat = np.sum(s_hat_array, axis=0)
d_s_hat = m.demodulate_qpsk(s_hat)
error = np.sum(d_s_hat != system_model.d_s.flatten())
return error
def previous_non_lin(params: dict, sigma, h_si, h_s) -> PreviousNNModel:
training_samples = int(np.floor(params['n'] * params['trainingRatio']))
test_n = params['n'] - training_samples
system_model = PreviousSystemModel(
sigma, params['gamma'], params['phi'], params['PA_IBO_dB'],
params['PA_rho'], params['LNA_IBO_dB'], params['LNA_rho'], h_si,
params['h_si_len'], h_s, params['h_s_len'], params['TX_IQI'],
params['PA'], params['LNA'], params['RX_IQI'])
system_model.set_lna_a_sat(
test_n,
params['LNA_IBO_dB'],
)
system_model.transceive_si(params['n'])
previous_nn_model = PreviousNNModel(params['h_si_len'],
params['p_nHidden'],
params['p_learningRate'])
previous_nn_model.learn(system_model.x[0:int(params['n'] / 2)],
system_model.y, params['p_trainingRatio'],
params['h_si_len'], params['p_nEpochs'],
params['p_batchSize'])
system_model.transceive_si_s(test_n, )
previous_nn_model.cancel(
system_model.x[0:int(test_n / 2)],
system_model.y,
params['h_si_len'],
)
s_hat = previous_nn_model.cancelled_y * h_s.conj() / (np.abs(h_s)**2)
d_hat = m.demodulate_qpsk(s_hat)
d_hat_len = d_hat.shape[0]
error = np.sum(system_model.d_s[0:d_hat_len] != d_hat)
previous_nn_model.error = error
return previous_nn_model
def non_cancel_simulation(params: dict, sigma, h_si_list,
h_s_list) -> np.ndarray:
## 受信アンテナ数は1本のみで動作
receive_antenna = 1
h_si = []
h_si.append(h_si_list[0])
h_s = []
h_s.append(h_s_list[0])
system_model = OFDMSystemModel(
params['block'], params['subcarrier'], params['CP'], sigma,
params['gamma'], params['phi'], params['PA_IBO'], params['PA_rho'],
params['LNA_IBO'], params['LNA_rho'], h_si, h_s, params['h_si_len'],
params['h_s_len'], receive_antenna, params['TX_IQI'], params['PA'],
params['LNA'], params['RX_IQI'])
s_hat = system_model.demodulate_ofdm(system_model.y)
d_s_hat = m.demodulate_qpsk(s_hat)
error = np.sum(d_s_hat != system_model.d_s.flatten())
return error
previous_nn_model.cancel(
system_model.x[0:int(test_n / 2)],
system_model.y,
params['h_si_len'],
)
# ISIを含んだ希望信号成分
cancelled_y = previous_nn_model.cancelled_y
size = cancelled_y.shape[0]
y_vec = np.array(
[cancelled_y[i:i + size - L_w] for i in range(L_w + 1)])
z = np.matmul(W.conj().T, y_vec)
d_hat = m.demodulate_qpsk(z)
d_hat_len = d_hat.shape[0]
error = np.sum(system_model.d_s[0:d_hat_len] != d_hat)
error_array[sigma_index][trials_index] = error
result = Result(params, error_array, loss_array, val_loss_array)
with open(output_dir + '/result.pkl', 'wb') as f:
pickle.dump(result, f)
ber_fig, ber_ax = graph.new_snr_ber_canvas(params['SNR_MIN'],
params['SNR_MAX'])
n_sum = d_hat_len * params['SNR_AVERAGE']
errors_sum = np.sum(error_array, axis=1)
bers = errors_sum / n_sum
logging.info("sigma_index:" + str(index))
logging.info("time: %d[sec]" % int(time.time() - start))
system_model = SystemModel(
params['n'],
sigma,
params['gamma'],
params['phi'],
IBO_dB,
params['rho'],
IBO_dB,
params['rho'],
h_si,
h_s,
)
demodulate = m.demodulate_qpsk(system_model.y.squeeze())
error = np.sum(system_model.d_s != demodulate)
errors[IBO_index][index][snr_index] = error
logging.info("learn_end_time: %d[sec]" % int(time.time() - start))
# 結果をdumpしておく
result = Result(params, errors, losss, val_losss)
with open(dirname + '/snr_ber_average_ibo.pkl', 'wb') as f:
pickle.dump(result, f)
# SNR-BERグラフ
fig = plt.figure(figsize=(8, 6))
ax = fig.add_subplot(111)
ax.set_xlabel("SNR (dB)")
def learn(self,
train_system_model: OFDMSystemModel,
test_system_model: OFDMSystemModel,
training_ratio: float,
n_epochs: int,
batch_size: int,
h_si_len: int = 1,
h_s_len: int = 1,
receive_antenna: int = 1,
delay: int = 0,
standardization: bool = False):
self.train_system_model = train_system_model
self.test_system_model = test_system_model
x_1 = np.vstack((np.zeros(
(h_si_len - 1, 1)), train_system_model.x.reshape((-1, 1),
order='F')))
x_train = np.array([
x_1[i:i + h_si_len] for i in range(train_system_model.x.size)
]).reshape(train_system_model.x.size, h_si_len)
y_train = np.zeros(
(train_system_model.block * train_system_model.subcarrier_CP,
h_s_len * receive_antenna),
dtype=complex)
for receive_antenna_i in range(receive_antenna):
y_1 = np.vstack((np.zeros((h_s_len - 1, 1)),
train_system_model.y[:,
receive_antenna_i].reshape(
(-1, 1), order='F')))
y_train[:,
((receive_antenna_i) *
h_s_len):((receive_antenna_i + 1) * h_s_len)] = np.array([
y_1[i:i + h_s_len] for i in range(
train_system_model.y[:, receive_antenna_i].size)
]).reshape(
train_system_model.y[:, receive_antenna_i].size,
h_s_len)
s_train = train_system_model.tilde_s.reshape((-1, 1), order='F')
if delay > 0:
s_train = np.vstack((np.zeros((delay, 1)), s_train))[:-delay]
# 標準化
if standardization is True:
hensa = np.sqrt(np.var(y_train))
y_train = y_train / hensa
# NNの入力に合うように1つのベクトルにする
train = np.zeros((x_train.shape[0],
(2 * h_si_len) + (2 * h_s_len * receive_antenna)))
train[:, 0:(h_si_len)] = x_train.real
train[:, (h_si_len):(2 * h_si_len)] = x_train.imag
train[:, (2 * h_si_len):(2 * h_si_len) +
(receive_antenna * h_s_len)] = y_train.real
train[:, (2 * h_si_len) + (receive_antenna * h_s_len):(2 * h_si_len) +
(receive_antenna * 2 * h_s_len)] = y_train.imag
# テストデータの作成
x_1 = np.vstack((np.zeros(
(h_si_len - 1, 1)), test_system_model.x.reshape((-1, 1),
order='F')))
x_test = np.array([
x_1[i:i + h_si_len] for i in range(test_system_model.x.size)
]).reshape(test_system_model.x.size, h_si_len)
y_test = np.zeros(
(test_system_model.block * test_system_model.subcarrier_CP,
h_s_len * receive_antenna),
dtype=complex)
for receive_antenna_i in range(receive_antenna):
y_1 = np.vstack((np.zeros((h_s_len - 1, 1)),
test_system_model.y[:, receive_antenna_i].reshape(
(-1, 1), order='F')))
y_test[:, ((receive_antenna_i) * h_s_len):(
(receive_antenna_i + 1) * h_s_len)] = np.array([
y_1[i:i + h_s_len]
for i in range(test_system_model.y[:,
receive_antenna_i].size)
]).reshape(test_system_model.y[:, receive_antenna_i].size,
h_s_len)
s_test = test_system_model.tilde_s.reshape((-1, 1), order='F')
if delay > 0:
s_test = np.vstack((np.zeros((delay, 1)), s_test))[:-delay]
# 標準化
if standardization is True:
y_test = y_test / hensa
test = np.zeros((x_test.shape[0],
(2 * h_si_len) + (2 * h_s_len * receive_antenna)))
test[:, 0:(h_si_len)] = x_test.real
test[:, (h_si_len):(2 * h_si_len)] = x_test.imag
test[:, (2 * h_si_len):(2 * h_si_len) +
(receive_antenna * h_s_len)] = y_test.real
test[:, (2 * h_si_len) + (receive_antenna * h_s_len):(2 * h_si_len) +
(receive_antenna * 2 * h_s_len)] = y_test.imag
# 学習
self.history = self.model.fit(
train, [s_train.real, s_train.imag],
epochs=n_epochs,
batch_size=batch_size,
verbose=0,
validation_data=(test, [s_test.real, s_test.imag]))
# 学習したモデルを評価
self.pred = self.model.predict(test)
# 推定した希望信号の取り出し
y = np.squeeze(self.pred[0] + 1j * self.pred[1], axis=1)
if delay > 0:
y = y[delay:(delay + test_system_model.subcarrier_CP *
(test_system_model.block - 1))]
# y = s_test
s_hat = test_system_model.demodulate_ofdm(y)
# 推定信号をデータへ復調する
self.d_s_hat = m.demodulate_qpsk(s_hat)
# 元々の外部信号のデータ
self.d_s_test = test_system_model.d_s[:self.d_s_hat.size].flatten()
self.error = np.sum(self.d_s_test != self.d_s_hat)
def learn(self, system_model: SystemModel, training_ratio: float, n_epochs: int, batch_size: int, h_si_len: int = 1,
h_s_len: int = 1, receive_antenna: int = 1, delay: int = 0, standardization: bool = False):
self.system_model = system_model
# トレーニングデータの生成
training_samples = int(np.floor(system_model.x.size) * training_ratio)
# チャネル数分つくる
x = np.reshape(
np.array([system_model.x[i:i + h_si_len] for i in range(system_model.x.size - 2 * h_si_len + 2)]),
(system_model.x.size - 2 * h_si_len + 2, h_si_len))
y = np.reshape(
np.array([system_model.y[i:i + h_si_len] for i in range(system_model.y.shape[0] - h_si_len + 1)]),
(system_model.y.shape[0] - h_si_len + 1, (h_si_len * receive_antenna)))
x_train = x[0:training_samples]
y_train = y[0:training_samples]
s_train = system_model.s[0 + delay:training_samples + delay] # 遅延をとる
# 標準化
if standardization is True:
hensa = np.sqrt(np.var(y_train))
y_train = y_train / hensa
# NNの入力に合うように1つのベクトルにする
train = np.zeros((x_train.shape[0], (2 * h_si_len) + (receive_antenna * 2 * h_si_len)))
train[:, 0:h_si_len] = x_train.real
train[:, h_si_len:(2 * h_si_len)] = x_train.imag
train[:, (2 * h_si_len):(2 * h_si_len) + (receive_antenna * h_s_len)] = y_train.real
train[:,
(2 * h_si_len) + (receive_antenna * h_s_len):(2 * h_si_len) + (receive_antenna * 2 * h_s_len)] = y_train.imag
# テストデータの作成
x_test = x[training_samples:]
y_test = y[training_samples:]
s_test = system_model.s[
training_samples + delay:(training_samples + x_test.shape[0] + delay)] # 数が合わなくなる時があるのでx_sの大きさを合わせる
# 標準化
if standardization is True:
y_test = y_test / hensa
# NNの入力に合うように1つのベクトルにする
test = np.zeros((x_test.shape[0], (2 * h_si_len) + (receive_antenna * 2 * h_si_len)))
test[:, 0:h_si_len] = x_test.real
test[:, h_si_len:(2 * h_si_len)] = x_test.imag
test[:, (2 * h_si_len):(2 * h_si_len) + (receive_antenna * h_s_len)] = y_test.real
test[:,
(2 * h_si_len) + (receive_antenna * h_s_len):(2 * h_si_len) + (receive_antenna * 2 * h_s_len)] = y_test.imag
# 学習
self.history = self.model.fit(train, [s_train.real, s_train.imag], epochs=n_epochs,
batch_size=batch_size, verbose=0,
validation_data=(test, [s_test.real, s_test.imag]))
# 学習したモデルを評価
self.pred = self.model.predict(test)
# 推定した希望信号の取り出し
s_hat = np.squeeze(self.pred[0] + 1j * self.pred[1], axis=1)
# 推定信号をデータへ復調する
self.d_s_hat = m.demodulate_qpsk(s_hat)
# 元々の外部信号のデータ
self.d_s_test = system_model.d_s[
2 * (training_samples + delay):2 * (training_samples + x_test.shape[0] + delay)]
self.error = np.sum(self.d_s_test != self.d_s_hat)
x_receive = np.zeros((params['chanel_len'] - 1 + x_cp.shape[0], x_cp.shape[1]), dtype=complex)
x_receive[:(params["chanel_len"] - 1), 1:] = x_cp[-(params["chanel_len"] - 1):, :-1]
x_receive[(params["chanel_len"] - 1):, :] = x_cp
noise = m.awgn((params['subcarrier'] + params['CP'], params['block']), sigma)
r = np.matmul(H, x_receive) + noise
r_s = r.flatten()
y_p = r_s.reshape((params['subcarrier'] + params['CP'], params['block']))
y_remove_cp = np.matmul(ofdm_zero, y_p)
y = np.matmul(F, y_remove_cp)
s_hat = np.matmul(D_1, y)
s_n_hat = s_hat.reshape(params['subcarrier'] * params['block'])
d_hat = m.demodulate_qpsk(s_n_hat).reshape((params['subcarrier'] * 2 * params['block'], 1))
error = np.sum(d != d_hat)
errors[sigma_index][trials_index] = error
### QPSK
# q_r = (h_si * s_n) + m.awgn((params['subcarrier'] * params['block'], 1), sigma)
# q_r = q_r * h_si.conj() / (np.abs(h_si) ** 2)
# q_d_hat = m.demodulate_qpsk(q_r.squeeze()).reshape((params['subcarrier'] * 2 * params['block'], 1))
# q_error = np.sum(d != q_d_hat)
#
# q_errors[sigma_index][trials_index] = q_error
ber_fig, ber_ax = graph.new_snr_ber_canvas(params['SNR_MIN'], params['SNR_MAX'], -4, 0)
n_sum = params['subcarrier'] * 2 * params['block'] * params['SNR_AVERAGE']
errors_sum = np.sum(errors, axis=1)
sigma,
params['gamma'],
params['phi'],
params['PA_IBO_dB'],
params['PA_rho'],
params['LNA_IBO_dB'],
params['LNA_rho'],
h_si,
params['h_si_len'],
h_s,
params['h_s_len'],
)
system_model.transceive_s(params['n'])
s_hat = system_model.y * h_s.conj() / (np.abs(h_s)**2)
d_s_hat = m.demodulate_qpsk(s_hat)
n_sum = d_s_hat.shape[0]
error = np.sum(system_model.d_s[0:n_sum] != d_s_hat)
error_array[sigma_index] = error
# errors_sum = np.sum(error_array, axis=1)
errors_sum = error_array
bers = errors_sum / n_sum
ber_fig, ber_ax = graph.new_snr_ber_canvas(params['SNR_MIN'],
params['SNR_MAX'])
ber_ax.plot(snrs_db,
bers,
color="k",
marker='o',
linestyle='--',
system_model = SystemModel(
params['n'],
sigma,
params['gamma'],
params['phi'],
params['PA_IBO_db'],
params['PA_rho'],
params['LNA_IBO_dB'],
params['LNA_rho'],
h_si,
h_s,
params['h_si_len'],
params['h_s_len'],
)
demodulate = m.demodulate_qpsk(
system_model.y.reshape(system_model.y.shape[0]))
error = np.sum(system_model.d_s != demodulate)
non_cancell_error[var_s_index][trials_index] = error
# SNR-BERグラフ
fig = plt.figure(figsize=(8, 6))
ax = fig.add_subplot(111)
ax.set_xlabel(r"$\sigma_{\rm SI}^2 / \sigma_{\rm s}^2$(dB)")
ax.set_ylabel("BER")
ax.set_yscale('log')
y_min = pow(10, 0)
y_max = pow(10, -6)
ax.set_ylim(y_max, y_min)
# ax.set_xlim(params['var_min'], params['var_max'])
ax.set_xlim(-2.5, params['var_max'])
ax.grid(linestyle='--')
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)
noise = m.awgn((params['subcarrier'], params['block']), sigma)
r = np.matmul(Hc, x) + noise
y = np.matmul(F, r)
s_hat = np.matmul(D_1, y)
s_n_hat = s_hat.reshape(params['subcarrier'] * params['block'])
d_hat = m.demodulate_qpsk(s_n_hat).reshape(
(params['subcarrier'] * 2 * params['block'], 1))
error = np.sum(d != d_hat)
errors[sigma_index][trials_index] = error
### QPSK
q_r = (h_si * s_n) + m.awgn(
(params['subcarrier'] * params['block'], 1), sigma)
q_r = q_r * h_si.conj() / (np.abs(h_si)**2)
q_d_hat = m.demodulate_qpsk(q_r.squeeze()).reshape(
(params['subcarrier'] * 2 * params['block'], 1))
q_error = np.sum(d != q_d_hat)
q_errors[sigma_index][trials_index] = q_error
ber_fig, ber_ax = graph.new_snr_ber_canvas(params['SNR_MIN'],
def simulation(block: int,
subcarrier: int,
CP: int,
sigma: float,
gamma: float,
phi: float,
PA_IBO_dB: float,
PA_rho: float,
LNA_alpha_1: float,
LNA_alpha_2: float,
h_si_list: list,
h_s_list: list,
h_si_len: int,
h_s_len: int,
TX_IQI: bool,
PA: bool,
LNA: bool,
RX_IQI: bool,
n_hidden: list,
optimizer_key: str,
learning_rate: float,
momentum: float,
trainingRatio: float,
nEpochs: int,
batchSize: int,
compensate_iqi: bool = False,
receive_antenna=1,
equalizer='ZF') -> PreviousOFDMNNModel:
keras.backend.clear_session() # 複数試行行うとメモリリークするのでその対策
h_si = h_si_list[0:receive_antenna]
h_s = h_s_list[0:receive_antenna]
training_blocks = int(block * trainingRatio)
test_blocks = block - training_blocks
train_system_model = PreviousOFDMSystemModel(
training_blocks,
subcarrier,
CP,
sigma,
gamma,
phi,
PA_IBO_dB,
PA_rho,
LNA_alpha_1,
LNA_alpha_2,
h_si,
h_s,
h_si_len,
h_s_len,
receive_antenna,
TX_IQI,
PA,
LNA,
RX_IQI,
)
test_system_model = PreviousOFDMSystemModel(
test_blocks, subcarrier, CP, sigma, gamma, phi, PA_IBO_dB, PA_rho,
LNA_alpha_1, LNA_alpha_2, h_si, h_s, h_si_len, h_s_len,
receive_antenna, TX_IQI, PA, LNA, RX_IQI)
train_system_model.transceive_s()
test_system_model.transceive_s()
nn_model_list = []
for i in range(receive_antenna):
nn_model = PreviousOFDMNNModel(n_hidden, optimizer_key, learning_rate,
h_si_len, momentum)
nn_model.learn(
train_system_model.x,
train_system_model.y[:, i],
test_system_model.x,
test_system_model.y[:, i],
nEpochs,
batchSize,
h_si_len,
)
nn_model_list.append(nn_model)
pred_system_model = PreviousOFDMSystemModel(
test_blocks, subcarrier, CP, sigma, gamma, phi, PA_IBO_dB, PA_rho,
LNA_alpha_1, LNA_alpha_2, h_si, h_s, h_si_len, h_s_len,
receive_antenna, TX_IQI, PA, LNA, RX_IQI)
pred_system_model.transceive_si_s()
s_hat_array = np.zeros(
(receive_antenna, pred_system_model.d.shape[0] // 2), dtype=complex)
for i in range(receive_antenna):
nn_model = nn_model_list[i]
nn_model.cancel(pred_system_model.x, h_si_len)
cancelled_y = pred_system_model.y[:, i].reshape(1, -1) - nn_model.y_hat
if compensate_iqi is True:
cancelled_y = m.compensate_iqi(cancelled_y.flatten(order='F'),
gamma, phi)
if equalizer == 'MMSE':
s_hat_array[i] = pred_system_model.demodulate_ofdm_mmse(
cancelled_y, h_s[i], sigma)
else:
# MMSE以外が指定されている場合は，ZF
s_hat_array[i] = pred_system_model.demodulate_ofdm(
cancelled_y, h_s[i])
# s_hat_array = s_hat_array[0, :].reshape(1, -1)
# s_hat_array = s_hat_array[1, :].reshape(1, -1)
# s_hat_array = s_hat_array[2, :].reshape(1, -1)
# 推定信号をデータへ復調する
s_hat = np.sum(s_hat_array, axis=0)
# s_hat = s_hat / receive_antenna
d_s_hat = m.demodulate_qpsk(s_hat)
# 元々の外部信号のデータ
d_s_test = pred_system_model.d_s[:d_s_hat.size].flatten()
error = np.sum(d_s_test != d_s_hat)
nn_model.error = error
return nn_model
