- Rating
- 2
- Confidence
- 2
- Informativeness
- 2
- Presentation
- 3
- Soundness
- 2
Read review
Paper summary
This paper introduces TraceCodec. The central idea is to separate learnable packet behavior from deterministic protocol constraints. Instead of directly reconstructing raw packet fields, TraceCodec first converts packet traces into structured PacketActions containing flow identity, timing, transport events, and selected protocol-related information. A packet-aligned variational autoencoder then maps these actions into continuous latent representations. During decoding, a state-aware deterministic compiler converts the reconstructed actions into packet captures (PCAPs) while maintaining flow identity, TCP sequence and acknowledgment state, and packet-rendering constraints. The authors evaluate TraceCodec on CICIDS2017 Monday, MAWI, and VNAT, comparing it with several generic tabular generative models adapted to raw-packet reconstruction. The proposed approach achieves substantially better packet-level and flow-level reconstruction fidelity than the evaluated raw-field baselines. TraceCodec achieves 100% usable suffixes on CICIDS2017 and 98.44% on MAWI, outperforming the evaluated raw-field latent controls.
Critical strengths
Strength 1
The paper identifies an important challenge in packet-trace generation: raw packet fields contain both behavioral information and protocol-dependent values that must remain consistent across packets. The proposed PacketAction representation provides an explicit interface between these two types of information. By delegating endpoint assignment, TCP state maintenance, and packet rendering to a deterministic compiler, TraceCodec avoids requiring the neural decoder to reproduce every protocol-dependent field. This separation is the most compelling contribution of the paper.
Strength 2
The authors evaluate the proposed codec across three public network traffic datasets and provide multiple complementary metrics, including packet counts, protocol composition, timing distributions, TCP diagnostic events, flow counts, and flow durations. The results consistently demonstrate substantial improvements over the evaluated raw-field tabular baselines, particularly in preserving flow identity and transport-level structure. Importantly, the authors explicitly compare deterministic compilation with a learned causal LSTM realizer receiving the same PacketAction inputs.
Critical weaknesses
Weakness 1
The central claim of the paper is that TraceCodec provides a better generator-facing latent interface for packet traces. However, the experimental comparisons do not sufficiently establish whether the improvements arise from the learned latent representation itself or primarily from the handcrafted PacketAction schema and deterministic protocol compiler. The primary baselines are generic tabular generative models operating on raw packet fields. These models must reconstruct high-cardinality endpoint identifiers, absolute TCP sequence and acknowledgment numbers, and other fields involving cross-packet dependencies. In contrast, TraceCodec explicitly removes several of these difficult prediction targets and delegates their reconstruction to deterministic state management. Without these controls, it is difficult to determine which components are responsible for the reported improvements and how much of the contribution is attributable to neural representation learning.
Weakness 2
The paper positions TraceCodec as a generator-facing latent interface and highlights its ability to produce complete decoded packet continuations. But, the main continuation metric, "usable suffixes," is defined as the fraction of decoded PCAPs containing exactly the requested number of packets. While this is a useful measure of decoder compatibility, it primarily evaluates whether the generated latent sequence can be converted into a complete packet artifact. Because TraceCodec employs a packet-aligned representation and deterministic compiler, successful packet materialization is strongly supported by the architecture itself. Consequently, a high usable-suffix rate does not necessarily imply that the generated traffic accurately captures realistic network behavior. For example, Table 4 reports 100% usable suffixes on CICIDS2017, but the same generated continuations exhibit coverage-adjusted total variation distances of 39.35% for packets per flow and 40.44% for session duration. These errors indicate that important flow-level and temporal characteristics are not yet reproduced. Overall, the experiments convincingly demonstrate that the proposed interface improves decode reliability, but provide less conclusive evidence that it enables high-fidelity generation of realistic, stateful network traffic.
Questions for authors
Q1
Could the authors provide controlled comparisons using alternative neural codecs operating on the same PacketAction representation and sharing the same deterministic compiler? For example, would a simpler MLP-based VAE or another packet-aligned representation achieve comparable reconstruction and continuation performance?
Q2
Appendix reports that the causal LSTM realizer predicts original endpoint identifiers, ports, and absolute sequence and acknowledgment values, although these fields are not uniquely determined by its PacketAction inputs. Could the authors clarify how this information mismatch affects the comparison?
Q3
Could the authors provide additional evaluations using downstream networking tasks, such as traffic classification, anomaly detection, or protocol-state analysis, to demonstrate that generated traces preserve application-relevant statistical properties?
Q4
Appendix reports that the stateful compilation and rendering stage achieves approximately 1.40–1.75k packets/s on a single CPU process, substantially slower than the neural encoding and decoding stages. Since the proposed codec targets packet-level network traces, could the authors clarify the intended throughput and deployment scenarios? Is the compiler parallelizable across independent flows or trace segments without compromising state consistency?
5 comments
Response to npQa (Part 2/3)
Weakness 2: What continuation does and does not establish
We agree that usable-suffix rate measures materialization reliability, not traffic realism. It checks whether each output contains the requested packet count, while valid coverage measures how much of that output is tokenizable. We therefore report both separately from transport and flow diagnostics.
All representations use the same downstream generator, training protocol, and horizon so that their behavior is compared under matched conditions. The executable PacketAction/compiler interface provides a defined realization path, but does not by itself teach the generator how flows evolve over time.
To locate the reported CICIDS2017 gaps--39.35% packets-per-flow TV and 40.44% session-duration TV--we added per-case flow diagnostics. In this follow-up evaluation, median session count increases from 79.5 to 180.5 and singleton-session share from 9.66% to 41.31%. These results show substantial flow fragmentation, consistent with the observed flow-level mismatch. The corresponding MAWI gaps are much smaller, at 4.33% and 5.12%.
The duration mismatch is not solely a histogram artifact: under the submitted bins, duration JSD is 0.180 bits, and the unbinned KS distance is 0.379. We also evaluated 128 paired generated/reference suffixes per method:
| Continuation interface | TCP transition TV | Flow-switch error | Same-flow run KS | Session-duration KS |
|---|---|---|---|---|
| TraceCodec | 0.175 | 0.180 | 0.268 | 0.379 |
| TVAE | 0.370 | 0.504 | 0.384 | 0.480 |
| TabSyn-VAE | 0.235 | 0.486 | 0.349 | 0.394 |
TraceCodec is closest among the evaluated interfaces on all four diagnostics, although absolute errors remain: median flow-switch rate rises from 0.323 to 0.510 and mean same-flow run length falls from 3.09 to 1.96 packets. These results show better structural preservation than the evaluated controls, while long-range flow generation remains imperfect. We will add these diagnostics and distinguish materialization reliability from behavioral fidelity in the revision.
Q3: Utility of reconstructed PCAPs
To isolate codec-specific downstream retention, we added a capture-disjoint VNAT-style application-classification evaluation of reconstructed PCAPs using timing, size, direction, and flow features represented by TraceCodec. The classifier is trained only on real training captures and then frozen:
| Held-out evaluation input | Captures | Valid windows | Capture-balanced macro-F1 | 95% capture-bootstrap CI |
|---|---|---|---|---|
| Real PCAP | 12 | 484 | 0.714 | [0.657, 0.772] |
| Reference PacketActions + compiler | 12 | 483 | 0.711 | [0.656, 0.769] |
| TraceCodec-decoded PacketActions + compiler | 12 | 526 | 0.687 | [0.607, 0.767] |
The reference-action arm nearly matches real PCAP (0.711 vs. 0.714), while decoded actions achieve 0.687. Thus reconstructed PCAPs retain application-relevant information represented by the codec. This frozen-classifier test measures task-level feature retention after reconstruction; the continuation diagnostics above complement it with generated TCP-transition and flow-behavior measurements. Windows are formed independently per bidirectional connection, and the capture-balanced metric gives each capture equal weight, preventing captures with more retained windows from receiving greater aggregate weight. The task deliberately uses features within the submitted codec's scope: timing, size, direction, flow lifecycle, and transport behavior remain observable for encrypted traffic even when plaintext application content is unavailable.
Response to npQa (Part 3/3)
Q4: Throughput, deployment, and safe parallelism
The current compiler is intended for offline PCAP materialization, synthetic-dataset construction, evaluation, and trace preparation before replay, not line-rate inline generation. The reported 1.40--1.75k packets/s is a single-process Python/Scapy CPU baseline for stateful materialization. State execution performs work for actions, packet construction and serialization additionally scale with emitted bytes, and mutable protocol state is . Neural stages and compilation were measured on different hardware, so their reported rates are not directly comparable.
Independent captures and generated samples can run in parallel without shared protocol state. Complete bidirectional flows could also be assigned to separate workers, provided packets within each flow remain ordered and the outputs are merged back into global timestamp order. Splitting a trace by time additionally requires transferring the state of flows crossing segment boundaries. The reported benchmark uses the single-process implementation; we will clarify these safe parallelization boundaries and distinguish them from time partitioning in the revision.
Response to npQa (Part 1/3)
We thank the reviewer for identifying the separation between learned behavior and deterministic protocol consequences as the paper's central contribution. We agree that reliable packet materialization and realistic long-range generation are distinct claims. We report matched controls for the neural backbone and TCP-state executor, additional continuation diagnostics, a codec-specific downstream utility test, and the deployment boundaries of the current compiler.
Q1 and Weakness 1: Complete interface versus neural codec
With PacketAction and the compiler fixed, a parameter-matched two-layer MLP β-VAE performs comparably to the Transformer codec, and both achieve 100% tokenizable coverage. Because TraceCodec already uses MLP decoder heads, this control replaces only the Transformer encoder while holding the 128-dimensional latent, decoder, objective, split, training protocol, and compiler fixed. It uses one training seed and approximately matched parameter counts:
The MLP has higher action/TCP-field accuracy and lower TCP analysis-profile error, but higher timing error (1.098% vs. 0.487% IAT TV); packet-size TV is nearly identical (2.636% vs. 2.634%). Neither backbone dominates, and high-fidelity reconstruction and realization are not specific to self-attention. Both arms remain learned β-VAE codecs. This control isolates the encoder family within the fixed executable interface.
This isolates the neural backbone because the remainder of the executable interface is fixed. Changing the action representation would also redefine the compiler contract; applying state-aware execution to conflicting raw fields additionally requires a policy that interprets those fields as an intended transition. The main tables therefore compare complete decode interfaces, while this control isolates neural architecture.
Q2: Purpose of the learned-realizer control
The reviewer is correct that source-specific endpoint identities, ports, and absolute transport coordinates are not uniquely determined by PacketAction. Appendix E.1 was intended to compare learned and deterministic state execution, but its targets also included these unidentifiable source-capture fields. We reran it with matched synthetic initialization, actions, timing, flow routing, and serialization; only the TCP-state backend changes.
TCP analysis-profile error sums the absolute differences in per-TCP-packet rates across eight TShark diagnostic events. The learned rows report mean ± sample standard deviation over three seeds. The learned backend has substantially higher error even with reference actions; this applies to the tested LSTM, not every possible learned realizer. The deterministic backend's increase from 4.52 to 15.20 pp is consistent with decoded-action errors propagating into realized TCP behavior. The compiler has no access to the reference suffix and does not optimize toward it. We will replace the original Appendix E.1 comparison with this input-matched control.