def forward(self, symbols: torch.Tensor) -> torch.Tensor:
data_si = symbols_to_integers(symbols)
data_si = data_si.long()
# print("premod:" , data_si)
cartesian_points = self.symbol_map[data_si[:], :]
# print("after", cartesian_points)
# cartesian_points = cartesian_points.numpy()
# sigma = [[0.01, 0], [0, 0.01]]
# cartesian_points = cartesian_points + np.random.multivariate_normal([0, 0], sigma,
# size=cartesian_points.shape[0])
# cartesian_points = torch.from_numpy(cartesian_points)
return cartesian_points
def update(self, signal, true_symbols, times, **kwargs):
if len(signal.shape) == 2:
cartesian_points = torch.from_numpy(signal).float()
elif len(signal.shape) == 1:
cartesian_points = torch.from_numpy(
np.stack((signal.real.astype(np.float32), signal.imag.astype(np.float32)), axis=-1))
X = cartesian_points.numpy()
y = symbols_to_integers(true_symbols)
# sliding window
if times == 0:
self.X_train = X
self.y_train = y
elif times <= 22:
self.X_train = np.vstack((self.X_train, X))
self.y_train = np.append(self.y_train, y)
else:
# delete the head of the existing data
# self.X_train = np.vstack((self.X_train[signal.shape[0]:, :], X))
# self.y_train = np.append(self.y_train[signal.shape[0]:], y)
# delete the random rows of the existing data
row = self.X_train.shape[0]
row_added = X.shape[0]
delete_row = random.sample(range(0, row), row_added)
self.X_train = np.delete(self.X_train, delete_row, axis=0)
self.y_train = np.delete(self.y_train, delete_row)
# add the new data
self.X_train = np.vstack((self.X_train, X))
self.y_train = np.append(self.y_train, y)
# shuffle
self.X_train, self.y_train = shuffle(self.X_train, self.y_train, random_state=0)
X_ = self.X_train
for i in range(self.proj_num):
pro = np.array([self.X_train[:, 0] * self.a_list[i] + self.X_train[:, 1] * self.b_list[i]]).T
X_ = np.hstack((X_, pro))
self.clf.fit(X_, self.y_train)
def update(self, signal: np.ndarray, true_symbols: np.ndarray, times,
**kwargs):
model = self.model
if hasattr(model, "update"):
kwargs['signal'] = signal
kwargs['true_symbols'] = true_symbols
kwargs['times'] = times
model.update(**kwargs)
return
else:
assert self.optimizer, "Demodulator is not initialized with an optimizer"
# train
if len(signal.shape) == 2:
cartesian_points = torch.from_numpy(signal).float()
elif len(signal.shape) == 1:
cartesian_points = torch.from_numpy(
np.stack((signal.real.astype(
np.float32), signal.imag.astype(np.float32)),
axis=-1))
l1, l2, cross_entropy_weight, optimizer = [
self.lambda_l1, self.lambda_l2, self.cross_entropy_weight,
self.optimizer
]
criterion = nn.CrossEntropyLoss()
for _ in range(self.epochs):
logits = model.forward(cartesian_points)
target = torch.from_numpy(symbols_to_integers(true_symbols))
loss = cross_entropy_weight * torch.mean(
criterion(logits, target))
if l1 > 0:
loss += l1 * model.l1_loss()
if l2 > 0:
loss += l2 * model.l2_loss()
# Backprop
optimizer.zero_grad()
loss.backward()
optimizer.step()
return
def roundtrip_evaluate(*,
agent1,
agent2=None,
bits_per_symbol,
test_batch_size: int,
signal_power: float,
verbose: bool = False,
completed_iterations: int = None,
total_iterations: int = None,
**kwargs):
grid_2d = get_grid_2d(grid=[-1.5, 1.5], points_per_dim=100) # For getting demod boundaries
test_SNR_dbs = get_test_SNR_dbs()[bits_per_symbol]['ber_roundtrip']
A = agent1
if agent2 is None:
B = agent1
else:
B = agent2
# Calculate Roundtrip Testing Accuracy on different SNRs
preamble = get_random_preamble(n=test_batch_size, bits_per_symbol=bits_per_symbol)
c_signal_forward = A.mod.modulate(preamble, mode='exploit', dtype='cartesian')
_c_signal_forward = B.mod.modulate(preamble, mode='exploit', dtype='cartesian')
# c_signal_forward = A.mod.modulate(preamble, mode='classic', dtype='cartesian')
# _c_signal_forward = B.mod.modulate(preamble, mode='classic', dtype='cartesian')
test_bers = [[], []]
test_sers = [[], []]
test_preamble = symbols_to_integers(preamble)
# count , acc = 0, 0;
for test_SNR_db in test_SNR_dbs:
# count += 1
c_signal_forward_noisy = add_awgn(c_signal_forward, SNR_db=test_SNR_db, signal_power=signal_power)
preamble_halftrip = B.demod.demodulate(c_signal_forward_noisy) #
# c_signal_backward = B.mod.modulate(preamble_halftrip, mode='classic', dtype='cartesian')
c_signal_backward = B.mod.modulate(preamble_halftrip, mode='exploit', dtype='cartesian')
c_signal_backward_noisy = add_awgn(c_signal_backward, SNR_db=test_SNR_db, signal_power=signal_power)
preamble_roundtrip = A.demod.demodulate(c_signal_backward_noisy)
# test accuracy
test_roundtrip = symbols_to_integers(preamble_roundtrip)
# acc += sum(test_roundtrip[i] == test_preamble[i] for i in range(len(preamble)))/len(preamble)
# print('accuracy', sum(test_roundtrip[i] == test_preamble[i] for i in range(len(preamble)))/len(preamble))
test_bers[0].append(float(get_ber(preamble, preamble_roundtrip)))
test_sers[0].append(float(get_ser(preamble, preamble_roundtrip)))
if not agent2 is None:
_c_signal_forward_noisy = add_awgn(_c_signal_forward, SNR_db=test_SNR_db, signal_power=signal_power)
_preamble_halftrip = A.demod.demodulate(_c_signal_forward_noisy) #
# _c_signal_backward = A.mod.modulate(_preamble_halftrip, mode='classic', dtype='cartesian')
_c_signal_backward = A.mod.modulate(_preamble_halftrip, mode='exploit', dtype='cartesian')
_c_signal_backward_noisy = add_awgn(_c_signal_backward, SNR_db=test_SNR_db, signal_power=signal_power)
_preamble_roundtrip = B.demod.demodulate(_c_signal_backward_noisy)
test_bers[1].append(float(get_ber(preamble, _preamble_roundtrip)))
test_sers[1].append(float(get_ser(preamble, _preamble_roundtrip)))
# print('accuracy', acc/count)
if agent2 is not None:
avg_test_sers = np.mean([test_sers[0], test_sers[1]], axis=0)
avg_test_bers = np.mean([test_bers[0], test_bers[1]], axis=0)
else:
avg_test_sers = test_sers[0]
avg_test_bers = test_bers[0]
if verbose is True: # IF you want to manually debug:
print(" ")
if agent2 is not None:
print("\t\t\t(%s --> %s --> %s), \n\t\t\t[%s --> %s --> %s], \n\t\t\t<Means>" % (
A.name, B.name, A.name, B.name, A.name, B.name))
for k in range(len(test_SNR_dbs)):
print(
"Test SNR_db :% 5.1f | "
"(BER: %7.6f) [BER: %7.6f] <BER: %7.6f> | "
"(SER: %7.6f) [SER: %7.6f] <SER: %7.6f>"
% (test_SNR_dbs[k],
test_bers[0][k], test_bers[1][k], avg_test_bers[k],
test_sers[0][k], test_sers[1][k], avg_test_sers[k]))
else:
print("\t\t\t(%s --> %s --> %s)" % (A.name, B.name, A.name))
for k in range(len(test_SNR_dbs)):
print(
"Test SNR_db :% 5.1f | BER: %7.6f | SER: %7.6f" %
(test_SNR_dbs[k],
test_bers[0][k],
test_sers[0][k],))
print(" ")
elif (total_iterations is not None) and (completed_iterations is not None):
print("[%s]" % ("." * completed_iterations + " " * (total_iterations - completed_iterations)), end='\r',
flush=True)
r2 = {}
if agent2 is not None:
r2 = {
'test_bers_1': test_bers[0],
'test_sers_1': test_sers[0],
'test_bers_2': test_bers[1],
'test_sers_2': test_sers[1],
'mod_std_2': agent2.mod.get_std(),
'constellation_2': agent2.mod.get_constellation(),
'demod_grid_2': agent2.demod.get_demod_grid(grid_2d),
}
return {
'test_SNR_dbs': test_SNR_dbs,
'test_bers': avg_test_bers, # mean
'test_sers': avg_test_sers, # mean
'mod_std_1': agent1.mod.get_std(),
# 'constellation_1': agent1.mod.get_constellation(),
'constellation_1': add_awgn(agent1.mod.get_constellation(), SNR_db=test_SNR_db, signal_power=signal_power),
'demod_grid_1': agent1.demod.get_demod_grid(grid_2d),
**r2
}
def get_demod_grid(self, grid_2d: np.ndarray):
symbols = self.demodulate(grid_2d)
classes = symbols_to_integers(symbols)
return classes
def forward(self, symbols:torch.Tensor) -> torch.Tensor:
data_si = symbols_to_integers(symbols)
data_si = data_si.long()
cartesian_points = self.symbol_map[data_si[:],:]
return cartesian_points