Deep Learning-Based AoA Estimation

• No training data (CSI with AoA labels) required
• Requires absolute phase and time synchronization between antennas
• Well-known algorithms such as MUSIC and ESPRIT (and simpler, less optimal alternatives) exist
• Objects in the environment will lead to accuracy issues due to reflections. Antenna properties such as radiation pattern and phase center location also need to be considered for accurate estimates.
• Locations of individual antennas (assignment of channels, orientation of array, distance between antennas, ...) have to be known precisely

• Needs large amounts of labelled training data
• The neural network can learn to compensate any phase and time offsets between antennas as well as other impairments
• Need to tune neural network and training hyperparameters, there is no "optimal" solution
• The neural network can learn to ignore multipath propagation issues caused by the radio environment. Antenna propagation properties are also learned during training.
• No need to specify antenna array properties, the neural network can learn these from the training set

If there is a sufficient amount of training data, neural-network based AoA estimation usually performs better than classical techniques, as we will show in this tutorial. We will put a special focus on testing the ability of the neural network to generalize AoA estimation to physical regions in space that it has not seen during training.

In case you are unfamiliar with DICHASUS datasets, it might be a good idea to have a look at our position estimation tutorial first. It uses a very similar feature extraction and neural network training and explains both in greater detail.

When it comes to angle of arrival estimation, there are two incident angles that one might want to estimate at the antenna array: Elevation and azimuth. Since, at the time of writing, most of our datasets exhibit a much greater variance in azimuth (compared to elevation), we will focus on azimuth angle estimation in this tutorial. Estimating the elevation angle instead is, however, simply a matter of changing which label to train on, no modifications to the neural network are required.

In the above code snippet, we already split the dataset into a training set and a test set. The training set contains all datapoints located at some distance \( d \) that is between \( 0.5 \,\mathrm{m} \) and \( 4 \,\mathrm{m} \) from the antenna array, which, itself, is located at \( (x, y) = (0, 0) \). The test set contains points that are further away than a \( 4\,\mathrm{m} \) radius. Thereby, we ensure that the neural network has to infer angles of arrival for datapoints that it has never seen before in locations that it has not seen either. Let's visualize this:

positions_train = np.vstack([pos for csi, pos, angle, dist in training_set_features])
positions_test = np.vstack([pos for csi, pos, angle, dist in test_set_features])

plt.figure(figsize = (8, 8))
plt.title("Training Set and Test Set", fontsize = 16, pad = 16)
plt.axis("equal")
plt.xlim(-6, 0)
plt.scatter(x = positions_train[:,0], y = positions_train[:,1], marker = ".", s = 1000, label = "Training Set")
plt.scatter(x = positions_test[:,0], y = positions_test[:,1], marker = ".", s = 1000, label = "Test Set")
plt.legend(fontsize = 16)
plt.xlabel("$x$ coordinate [m]", fontsize = 16)
plt.ylabel("$y$ coordinate [m]", fontsize = 16)
plt.tick_params(axis = "both", labelsize = 16)
plt.show()

positions = []
predicted_angles = []
true_angles = []
distances = []

for csi, pos, angle, dist in test_set_features.batch(100):
	positions.append(pos.numpy())
	predicted_angles.append(np.transpose(model.predict(csi))[0])
	true_angles.append(angle.numpy())
	distances.append(dist.numpy())

positions = np.vstack(positions)
predicted_angles = np.hstack(predicted_angles)
true_angles = np.hstack(true_angles)
distances = np.hstack(distances)

errorvectors = np.transpose(distances * np.vstack([-np.cos(predicted_angles), np.sin(predicted_angles)])) - positions
errors_abs_deg = np.rad2deg(np.abs(true_angles - predicted_angles))

We feed the complete test set into the neural network (in batches) and let it predict an azimuth angle estimate. In addition, we store the ground truth positions as well as the true angles and true distances to the antenna array in additional NumPy arrays.

Based on this information, we can compute error vectors, that is, vectors that point from the ground truth position, as provided in the dataset, to the estimated position. We only estimate an angle here, so, to obtain a complete position estimate, we will just use the true (ground truth) distance value to compute the coordinates of the location that the error vector points at.

Before taking a closer look at angle estimation errors (and thereby highlighting all the places where AoA estimation does not work so well), let's first see what does work. We can do this by visualizing the estimated AoA over the UE location in a heatmap. Remember, the antenna array is located at \( 0, 0 \).

plt.figure(figsize=(10, 10))
plt.title("AoA Estimate", fontsize = 16, pad = 16)

plt.axis("equal")
plt.xlim(-6, 0)
plt.hexbin(x = positions[:, 0], y = positions[:, 1], C = np.rad2deg(predicted_angles), gridsize = 30)
cb = plt.colorbar()
cb.set_label("AoA Estimate [deg]", fontsize = 16)
plt.xlabel("$x$ coordinate [m]", fontsize = 16)
plt.ylabel("$y$ coordinate [m]", fontsize = 16)
plt.tick_params(axis = "both", labelsize = 16)
plt.show()

Next, we visualize the estimation errors. We could try to plot all the error vectors, but that's simply too many lines. So, instead, we only plot a few vectors (the first 300 entries from the test set, which was randomly shuffled) and display estimation errors as a heatmap again.

plt.figure(figsize=(10, 10))
plt.title("AoA Estimation Error", fontsize = 16, pad = 16)

plt.axis("equal")
plt.xlim(-6, 0)
plt.hexbin(x = positions[:, 0], y = positions[:, 1], C = errors_abs_deg, gridsize = 30)
plt.quiver(positions[:300, 0], positions[:300, 1], errorvectors[:300, 0], errorvectors[:300, 1], color = "red", angles = "xy", scale_units = "xy", scale = 1)

cb = plt.colorbar()
cb.set_label("AoA Estimation Error [deg]", fontsize = 16)
plt.xlabel("$x$ coordinate [m]", fontsize = 16)
plt.ylabel("$y$ coordinate [m]", fontsize = 16)
plt.tick_params(axis = "both", labelsize = 16)
plt.show()

Clearly, there are some locations where estimation errors are higher than in others, but overall, most estimates are within less than \( 10^\circ \) or so. The comparably bad performance in some places could be due to particularly strong multipath components there. Since the neural network has never seen these areas before, it does not really have a chance to learn to compensate for these.