Closing the Loop on the Channel: Receiver-Driven Feature Requests for Cooperative Perception over Fading Links

Self-driving cars that share sensor data can see around occluding objects. The best current systems save bandwidth by talking back and forth. A car first announces where it is uncertain, and its neighbors then send only the features that fill those gaps. The savings are enormous, but every such protocol has been tested as if the wireless link were a perfect wire. Conversely, the studies that do simulate realistic radio links, with signal fading, path loss and thermal noise, only consider one-way broadcast. When the link is bad, the receiver can only discount what arrives, and it falls back to seeing alone.

This note proposes a second use for the back-channel. After a first round of transmission over a fading link, the receiver fuses what it got and looks at where it is still uncertain. That residual uncertainty mixes two causes: regions it never observed, and regions whose incoming features were damaged by the channel. Its reply tells neighbors which regions to resend, which neighbor should send them given its current link quality, and how many channel uses to spend. The claim is that this loop earns its keep precisely when the channel is bad, where one-way schemes collapse. We also want to find the signal-to-noise and latency regime where extra rounds stop paying.

Core Claim

Interactive protocols such as Where2comm build requests from the receiver's local, pre-communication confidence. This answers "what do I not see?" but not "what did I fail to receive?" Over a clean link the two questions coincide; over a fading link they do not. We claim three things:

  1. A request built from post-fusion residual uncertainty, weighted by each helper's measured link quality, will beat both of the natural alternatives at the same total number of channel uses. Those alternatives are one-shot learned joint source-channel coding with receiver gating, and Where2comm-style confidence requests carried over the same channel.
  2. The gain should grow as signal-to-noise ratio (SNR) falls.
  3. The number of useful rounds should shrink as SNR falls. This would directly contradict Where2comm's report that more rounds steadily improve the trade-off, which was measured on clean links.

Joint source-channel coding (JSCC) means a neural encoder maps features straight to analog channel symbols and is trained with channel noise in the loop, rather than quantizing and then error-correcting. The theory motivates this choice. For distributed inference over noisy channels, separate digital compression followed by channel coding cannot reach the optimal error exponent, the rate at which detection error decays (Distributed Hypothesis Testing over a Noisy Channel: Error-Exponents Trade-Off; Gunduz et al.). So we keep the forward payload analog and apply interaction on top of it. By contrast, RDcomm does interactive pruning with discrete entropy-coded indices, which are fragile to bit flips.

Research Program

Channel model. We will follow Cooperative Perception With Learning-Based V2V Communications and Self-Supervised Adaptive Weighting closely: single-antenna links with path loss, Rician fading and thermal noise at SNR from −10 to 30 dB, plus WINNER II multipath for held-out testing. We add one thing those studies did not need, which is time. Fading is simulated per slot, with a coherence time set by relative vehicle speed. This lets a retransmission in round two see either the same fade or a fresh one. Both the forward feature link and the reverse request link pass through this channel.

Protocol. In round one, each helper sends a low-rate analog JSCC encoding of its bird's-eye-view features. The receiver fuses them with a gating network in the style of Liu et al. It then computes a per-region score from three quantities: post-fusion detection uncertainty, which helpers cover that region, and each helper's estimated link SNR, obtained from pilots. From this score it issues a compact request map, sent with heavy repetition coding because it is tiny. In round two, each addressed helper resends the requested regions, spending the number of channel uses assigned by the receiver. The fixed resource constraint is the total channel budget,

$$K = \sum_{r=1}^{R}\left(K_r^{\text{fwd}} + K_r^{\text{rev}}\right),$$

where $R$ is the number of rounds and $K_r^{\text{fwd}}$, $K_r^{\text{rev}}$ are the forward-feature and reverse-request channel uses in round $r$. Every comparison below holds $K$ fixed. We also charge each round a slot delay and propagate that delay into pose misalignment. This matters because V2V4Real found that even 100 ms of delay noticeably hurts detection.

Training. The encoder, the request policy and the gated fusion are trained end to end, with channel realizations sampled during training. The request policy is trained through a differentiable top-k relaxation under the budget $K$.

Analysis. We will measure detection accuracy as a function of $R$, SNR and coherence time. The aim is to map where interaction helps, where it is neutral, and where corrupted or delayed rounds hurt. This is an empirical counterpart to the concern that noisy feedback loops can diverge. Diffusion Strategies Outperform Consensus Strategies proved exactly this kind of divergence for consensus averaging over noisy links, and it constrains our design: each round's features are adapted locally before being combined, rather than recursively averaged. The theoretical ceiling here comes from On Slepian-Wolf Theorem with Interaction, which shows that a few rounds capture most of the benefit of interaction on clean channels. We expect the curve to saturate even earlier on noisy ones.

Baselines

No fusion and full broadcast. The naive reference points are single-vehicle detection and uncompressed full-feature broadcast over the same channel. On clean OPV2V with PIXOR, OPV2V reports [email protected] of 0.406 without fusion and 0.734 for attentive intermediate fusion. These numbers bracket the achievable range.

One-shot JSCC with receiver gating. This is the strongest competitor. It combines the autoencoder transmitter of Liu et al. (2023) with the self-supervised gating receiver of Liu et al. (2024). It is proven over the same channel models and needs no feedback. The file reports about 57.6% [email protected] at −10 dB SNR for adaptive weighting, versus near 2% for unweighted fusion (Self-Supervised Adaptive Weighting). The 2023 paper reports intermediate fusion above 76% [email protected] from −10 to 30 dB with a SECOND backbone (Cooperative Perception With Learning-Based V2V Communications). These setups differ, so we will retrain both under our channel with the same backbone, data and tuning budget. The one-shot scheme receives the entire budget $K$ as forward channel uses. It may spread those uses over the same number of slots as our protocol, which gives it the same time diversity. Beating it means higher [email protected] at equal $K$ and equal wall-clock latency, at −10 dB and 0 dB, averaged over seeds, with non-overlapping confidence intervals.

Where2comm over fading. This is the strongest interactive competitor. We run Where2comm unchanged, with requests from local confidence, but with its payload sent through our JSCC encoder so that only the request logic differs. No reported result was found on Lacuna for Where2comm under fading channels.

Ablations. Two ablations isolate the key ingredient. The first builds requests from pre-fusion confidence only, so the receiver is blind to channel damage. The second keeps residual-uncertainty requests but ignores link SNR when choosing which helper answers.

Why not just…?

Why not just give a one-shot autoencoder the extra bandwidth? This is the real threat. If fades are fast, a one-shot encoder that spreads its symbols across slots already gets time diversity, and feedback may add nothing. Our matched-$K$, matched-slot comparison is designed to settle this. We expect interaction to win in two cases. The first is slow fading, where only the receiver knows which link and region were hit, and it can reroute the request to a different helper. The second is when much of the scene is redundant to the receiver, since Where2comm and RDcomm report most transmitted content is unneeded. If the one-shot baseline matches us across all coherence times, we will report that interaction does not survive realistic channels in this setting.

Why not just protect Where2comm's messages with strong channel codes and retransmission requests? Its request maps are small enough to protect cheaply, and we do exactly that. So request corruption is not the story here. The issue is that Where2comm's requests cannot express channel damage to the forward payload. Standard retransmission requests resend whole packets without regard to task value. The pre-fusion-confidence ablation and a uniform-resend variant measure exactly these two gaps.

Why not just share bounding boxes with standard retransmission? Late fusion is cheap, but Liu et al. (2023) report it collapsing once the path-loss exponent exceeds 2.5. It also cannot recover objects that no single car detects. We include late fusion with retransmission at matched latency as a sanity check.

Proposed Experiments

Datasets. We will train and test on OPV2V (up to five vehicles, which allows helper choice), V2V4Real (real LiDAR, two vehicles, so link and region reallocation but no helper diversity) and DAIR-V2X. All three are overlaid with the fading channel described above.

Metrics. We report [email protected] and [email protected] against total channel uses $K$ and against end-to-end latency, swept over SNR from −10 to 30 dB and three coherence times.

Decisive checks. There are three:

  1. At −10 dB with matched $K$ and latency, does the two-round protocol beat one-shot JSCC with gating on OPV2V?
  2. Does the gain shrink toward zero at 30 dB? This is expected, because clean links reduce to the Where2comm regime.
  3. Does accuracy against $R$ peak earlier as SNR falls? A peak at $R=1$ everywhere would falsify the proposal.

Held-out test. We will also train on Rician fading and test on WINNER II, following Liu et al. This checks that the request policy has not overfit one channel model.