acceptodds
Under review as a conference paper at ICLR 2027

TraceCodec: A Compiler-Backed Neural Codec for Network Traffic Traces

Abstract

Critical networking workflows need high-fidelity packet captures (PCAPs) for testing, security analysis, and protocol validation; flow-level summaries are not enough. Existing packet generators often learn raw or near-raw packet fields. Such representations mix behavioral choices with fields determined by protocol state, so decoding may require ambiguous post-hoc repair. We present TraceCodec, a packet-aligned neural codec for stateful multi-flow traces. TraceCodec represents each packet as a timed PacketAction with explicit flow slots and transport cues, learns a continuous per-packet latent sequence, and uses a deterministic stateful compiler to reconstruct PCAPs. The compiler assigns endpoints, advances transport state, enforces packet legality, and renders packet bytes, while the neural codec reconstructs the actions and timing. On CICIDS2017 Monday, TraceCodec has 0.00% packet-count and protocol error and 0.03% flow-count error. Raw-field baselines produce substantially larger flow-count and TCP-event errors under the same non-repair policy. With the same flow-matching continuation model, TraceCodec produces complete decoded suffixes in 100% of CICIDS2017 cases and 98.44% of MAWI cases, compared with at most 10.94% for raw-field latent controls. Additional diagnostics show that it preserves TCP transitions and multi-flow interleaving. These results support TraceCodec as a generator-facing latent interface with a deterministic path back to usable packet traces.

Primary area:
generative models
Keywords:
network traffic generation, packet traces, generative modeling, representation learning, neural codecs, protocol-aware generation

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 3 reviews, above 27% of the others.
Reviewer_npQaOpenReview ↗
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
AuthorsOpenReview ↗

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 β\beta-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:

EncoderParametersMean action-field acc. ↑\uparrowTCP-field acc. ↑\uparrowTiming MAE ↓\downarrowTokenizable coverage ↑\uparrowTCP analysis-profile error ↓\downarrow
Transformer11.49M99.653%99.631%2.015 ms100%12.51 pp
MLP11.51M99.863%99.864%4.106 ms100%11.04 pp

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 β\beta-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.

Action inputTCP-state backendTCP analysis-profile error (pp) ↓\downarrow
Reference PacketActionsDeterministic execution4.52
Reference PacketActionsLearned LSTM36.19 ±\pm 2.09
Decoded PacketActionsDeterministic execution15.20
Decoded PacketActionsLearned LSTM36.17 ±\pm 2.83

TCP analysis-profile error sums the absolute differences in per-TCP-packet rates across eight TShark diagnostic events. The learned rows report mean ±\pm 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.

AuthorsOpenReview ↗

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 interfaceTCP transition TV ↓\downarrowFlow-switch error ↓\downarrowSame-flow run KS ↓\downarrowSession-duration KS ↓\downarrow
TraceCodec0.1750.1800.2680.379
TVAE0.3700.5040.3840.480
TabSyn-VAE0.2350.4860.3490.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 inputCapturesValid windowsCapture-balanced macro-F1 ↑\uparrow95% capture-bootstrap CI
Real PCAP124840.714[0.657, 0.772]
Reference PacketActions + compiler124830.711[0.656, 0.769]
TraceCodec-decoded PacketActions + compiler125260.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.

AuthorsOpenReview ↗

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 O(T)O(T) work for TT actions, packet construction and serialization additionally scale with emitted bytes, and mutable protocol state is O(Factive)O(F_{\mathrm{active}}). 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.

Reviewer_iaC4OpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

The paper proposes TraceCodec, a compiler-backed neural codec for packet-level network traffic. It introduces a PacketAction representation that captures packet behavior, including timing, flow identity, direction, and TCP control events. A per-packet VAE learns continuous representations, while a deterministic compiler reconstructs packets using flow and transport state. The paper evaluates reconstruction on three public datasets (CICIDS2017 Monday, MAWI, and VNAT) and traffic continuation on CICIDS2017 Monday and MAWI. The results show better packet, timing, and flow-level fidelity than the evaluated raw-field baselines.

Critical strengths
  • The paper introduces a useful separation between learned packet behavior and deterministic protocol operations. The PacketAction representation and state-aware compiler allow the model to reconstruct packet traces without directly learning TCP sequence numbers, acknowledgment arithmetic, and other derived fields.

  • The experimental evaluation covers three different traffic datasets and measures fidelity after PCAP reconstruction. The TCP transition and multi-flow analyses provide useful evidence beyond packet-level statistics. The ablations also demonstrate the importance of timing and TCP progression information.

Critical weaknesses
  • The reviewer finds it difficult to separate the contribution of the neural codec from the PacketAction representation and deterministic compiler. The raw-field baselines operate without stateful repair, whereas TraceCodec uses an explicit protocol-aware compiler. Furthermore, the learned LSTM realizer in Appendix E.1 predicts source-specific fields that are not determined by its PacketAction inputs. A simpler neural codec using the same representation and compiler would provide a more meaningful comparison.

  • The traffic-continuation evaluation does not sufficiently establish whether generated traces preserve realistic network behavior. Section 4.4 defines usable suffixes based on the requested packet count. Although TraceCodec achieves 100% usable suffixes on CICIDS2017 Monday, Table 4 reports differences of 39.35% in packets per flow and 40.44% in session duration. The paper does not report TCP transition consistency for these generated continuations or demonstrate their usefulness in a downstream networking task.

Questions for authors

Q1. How would a simpler neural encoder-decoder perform with the same PacketAction representation and compiler? This would help clarify how much improvement comes from the learned codec itself.

Q2. Can the paper evaluate TCP transitions and flow behavior specifically for the generated continuations? The reviewer also recommends a downstream evaluation, such as feature extraction or trace replay within the supported protocol scope, to establish practical usefulness.

Q3. What is the configured active-flow slot capacity, and how does the compiler handle cases where that capacity is exceeded? The paper should clarify how these constraints affect highly concurrent traffic.

4 comments
AuthorsOpenReview ↗

Response to iaC4 (Part 1/2)

We thank the reviewer for recognizing the separation between learned packet behavior and protocol-state execution. We added the requested parameter-matched MLP control, reran the learned-realizer comparison with matched targets, and report additional continuation, reconstructed-PCAP utility, and flow-capacity results below.

Q1: Component attribution and a simpler neural codec

With PacketAction and the compiler fixed, a parameter-matched two-layer MLP β\beta-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:

EncoderParametersMean action-field acc. ↑\uparrowTCP-field acc. ↑\uparrowTiming MAE ↓\downarrowTokenizable coverage ↑\uparrowTCP analysis-profile error ↓\downarrow
Transformer11.49M99.653%99.631%2.015 ms100%12.51 pp
MLP11.51M99.863%99.864%4.106 ms100%11.04 pp

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%). Both materialize the full held-out split. Thus neither backbone dominates, and high-fidelity reconstruction and realization are not specific to self-attention. Both arms remain learned β\beta-VAE codecs; this control isolates the encoder family within the fixed executable interface.

This isolates the backbone because the remainder of the decode interface is fixed. Attaching state-aware execution to conflicting raw fields instead requires a policy that interprets those fields as an intended transition, thereby changing the decode interface rather than only the compiler. The main tables therefore compare complete decode interfaces; we will clarify this distinction in the revision.

Matched control for Appendix E.1

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 endpoints and ports, initial sequence values, actions, timing, flow routing, and serialization; only the TCP-state backend changes.

Action inputTCP-state backendTCP analysis-profile error (pp) ↓\downarrow
Reference PacketActionsDeterministic execution4.52
Reference PacketActionsLearned LSTM36.19 ±\pm 2.09
Decoded PacketActionsDeterministic execution15.20
Decoded PacketActionsLearned LSTM36.17 ±\pm 2.83

TCP analysis-profile error sums the absolute differences in per-TCP-packet rates across eight TShark diagnostic events. The learned rows report mean ±\pm 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 pp with reference actions to 15.20 pp with decoded actions 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.

AuthorsOpenReview ↗

Response to iaC4 (Part 2/2)

Q2: Continuation behavior and reconstructed-PCAP utility

Continuation behavior

A 100% usable-suffix rate means that each output contains the requested packet count; it does not establish realistic flow behavior. Valid-packet coverage separately measures how much of that output is accepted as tokenizable by the evaluator. We therefore report these materialization measures separately from TCP-transition, multi-flow, and duration diagnostics. All representations use the same downstream generator and training protocol.

To locate the CICIDS2017 gaps cited by the reviewer--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 two-sample KS distance is 0.379. We also evaluated event-to-event TCP transitions and multi-flow interleaving on 128 paired generated/reference suffixes per method:

Continuation interfaceTCP transition TV ↓\downarrowFlow-switch error ↓\downarrowSame-flow run KS ↓\downarrowSession-duration KS ↓\downarrow
TraceCodec0.1750.1800.2680.379
TVAE0.3700.5040.3840.480
TabSyn-VAE0.2350.4860.3490.394

TraceCodec is closest among the evaluated interfaces on all four diagnostics, although absolute errors remain: the median flow-switch rate rises from 0.323 in the reference suffixes to 0.510 after generation, 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.

Reconstructed-PCAP utility

We also added a capture-disjoint VNAT-style application-classification evaluation of reconstructed PCAPs. The classifier is trained only on real training captures and then frozen:

Held-out evaluation inputCapturesValid windowsCapture-balanced macro-F1 ↑\uparrow95% capture-bootstrap CI
Real PCAP124840.714[0.657, 0.772]
Reference PacketActions + compiler124830.711[0.656, 0.769]
TraceCodec-decoded PacketActions + compiler125260.687[0.607, 0.767]

Compiling reference PacketActions nearly preserves real-PCAP utility (0.711 vs. 0.714 macro-F1), while codec decoding gives 0.687. Thus reconstructed PCAPs retain task-relevant information. This task evaluates feature retention after codec reconstruction, while the continuation diagnostics above evaluate TCP and flow behavior after generation. The classifier uses timing, size, direction, flow-lifecycle, and transport features within the submitted codec's scope. The capture-balanced metric gives each capture equal weight, preventing captures with more retained windows from receiving greater aggregate weight.

Q3: Active-flow capacity and overflow

The evaluated codec supports 4,096 concurrently retained flow episodes. Slots are reusable, so this is not a limit on the total number of episodes in a trace. Capacity is configurable when constructing the preparation and codec contract, but changing it requires rebuilding preparation and retraining because the flow-slot vocabulary and runtime-state contract change.

An explicit END or 60 seconds of inactivity releases a slot. If all slots are occupied, encoding uses LRU eviction by default; a strict error policy is also available. Eviction releases the old runtime state rather than inserting an artificial END, so a later packet from that five-tuple is encoded as a new flow episode. Sustained concurrency above capacity can therefore fragment flow lifecycles, which is the relevant fidelity trade-off.

Held-out test splitPeak occupied slotsFiles with evictionEviction events
CICIDS2017 Monday5810/2390
VNAT430/120
MAWI4,0964/300152

MAWI reaches capacity in 4 of 300 test captures, with 152 eviction events across 1,459,195 held-out packet rows; CICIDS2017 and VNAT incur none. We will add the configured capacity, overflow policy, and observed occupancy to the revision.

AuthorsOpenReview ↗

Follow-up: MLP Continuation and Downstream Utility

We have completed two follow-up evaluations corresponding to Q1 and Q2: continuation through the matched MLP codec, and downstream training utility of generated PCAPs.

Q1: Continuation through the matched MLP codec

To extend our parameter-matched MLP β\beta-VAE reconstruction control to downstream generation, we trained separate flow-matching models for the Transformer and MLP codecs using the same downstream architecture and 32k-step budget. We evaluated their validation-selected checkpoints on the same 128 CICIDS2017 continuation cases. To match the aggregation used in our initial response, the distribution distances below are per-case medians.

MetricTransformerMLP
Usable / valid coverage ↑\uparrow100% / 100%100% / 100%
Median CA IAT TV ↓\downarrow13.54%12.81%
Median CA packet-size TV ↓\downarrow19.97%16.31%
Median protocol TV ↓\downarrow8.01%5.42%
Median CA packets/flow TV ↓\downarrow37.62%36.95%
Median CA session-duration TV ↓\downarrow40.03%40.43%
Median TCP-transition TV ↓\downarrow0.1750.182

Both codecs materialize every requested suffix with full valid coverage. The MLP has lower median distance for timing, packet size, protocol composition, and packets per flow, while the Transformer has slightly lower session-duration and TCP-transition distances. These results extend the reconstruction control to downstream generation: both encoder families support the executable latent interface, with different fidelity trade-offs.

Q2: Downstream utility of generated continuations

For the same four-category VNAT application-classification task reported in our initial response, we generated 512 class- and source-balanced suffixes from prefixes drawn exclusively from labeled real training captures, yielding 866 valid feature windows. Each generated suffix is paired with the application label of the real capture providing its prefix. We selected the synthetic-to-real objective weight from {0,0.1,0.25,0.5,1.0}\{0,0.1,0.25,0.5,1.0\} using only real validation captures, where 0 denotes real-only training; the selected weight was 0.1. We evaluated both classifiers on held-out real test captures. Both arms fit separate multinomial logistic-regression classifiers using a shared scaler fitted only on real training data and identical optimization settings. Sample weights are normalized to the same total mass; the augmented arm additionally includes generated windows at the validation-selected weight.

Classifier training dataHeld-out real capture-balanced macro-F1 ↑\uparrow
Real only0.714
Real + generated0.732

On held-out real captures, the pre-specified capture-balanced macro-F1 increases from 0.714 to 0.732 (+0.018; 95% paired source-capture bootstrap CI: [−0.009,0.063][-0.009, 0.063]). This experiment directly evaluates generated-PCAP training utility and suggests that the generated continuations can provide complementary training signal for application classification.

Since the rebuttal period is approaching the end, we’d like to kindly ask whether you’ve gone through our new results and whether they’ve addressed your previous concerns. We understand that you might be busy with other reviewing tasks and your own submissions, but we sincerely appreciate your latest comments on our rebuttal contents and your willingness of updating the score. Thank you so much!

Reviewer_x1aXOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

The paper introduces TraceCodec, a neural codec for packet-level network traffic traces. Rather than directly reconstructing raw packet fields, it first converts packets into structured PacketActions containing timing, flow identity, direction, TCP control events, payload lengths, and transport progression cues. A packet-wise VAE maps these actions to continuous latent vectors. A deterministic state-aware compiler converts decoded actions into PCAPs, maintaining flow identity, TCP sequence and acknowledgment state, and protocol compatibility. The evaluation covers datasets such as CICIDS2017 Monday, MAWI, and VNAT, comparing reconstruction against four adapted tabular generative models. The authors additionally evaluate latent-space traffic continuation using a shared flow-matching generator and conduct ablations of timing, TCP cues, KL regularization, and deterministic realization. The results show reconstruction fidelity and substantially better decoded-packet coverage than the evaluated raw-field baselines.

Critical strengths
  • Paper presents a well-motivated representation problem for network traffic generators. This problem of protocol-aware data generation is a challenging problem that is worth spending time as it can bring many benefits.
  • The design of the architecture is sound and the components seem to be carefully designed
Critical weaknesses
  • The baselines shown do not test the paper’s central claim. ‘The decode interface is the bottleneck’ has not been proven with the chosen baselines. TraceCodec is compared against generic tabular models that reconstruct raw packet fields without equivalent protocol-state information or a deterministic compiler. Therefore, the improvements cannot be attributed to the proposed representation.
  • Though NetSSM and NetDiffusion have been stated as the nearest work. Yet they haven’t been compared as baselines.
  • Paper could benefit from downstream utility tests to showcase the utility of the synthetic data. Good fidelity doesn’t necessarily mean that the utility is also good.
  • I feel that the value of the learned latent is not sufficiently established. The necessity of the latent representation has not been proven with sufficient experiments.
  • The novelty seems to be narrower than that is conveyed in the paper. The idea of learning structured representations and using deterministic mechanisms to enforce validity has been explored in prior research, including network traffic generation. The paper does not sufficiently acknowledge these earlier approaches or distinguish its contributions from them. Since the neural components are largely standard, the novelty appears to lie primarily in the proposed PacketAction representation and its integration with the state-aware compiler.
Questions for authors
  • TraceCodec's downstream generator receives an explicit inter-packet timing coordinate, whereas raw-field baselines must reconstruct timing through their latent decoders. Since timing fidelity is a key evaluation metric, doesn’t this difference favor TraceCodec?
  • The reported 100% continuation success primarily measures whether the decoder produces the requested number of packets, rather than whether the generated traffic is realistic. Are there any experiments that evaluate TCP consistency and flow behavior?
5 comments
AuthorsOpenReview ↗

Response to x1aX (Part 1/3)

We thank the reviewer for recognizing the importance of protocol-aware traffic generation and the care in the system design. For attribution, a substitution isolates one component only when the rest of the prediction-to-PCAP mapping remains fixed. Our main tables compare complete decode interfaces; the matched controls below separately vary the neural backbone and TCP-state executor in settings where the remaining mapping is unchanged.

Decode interface and raw-field baselines

PacketAction and the compiler jointly define the proposed interface. At step tt, PacketAction AtA_t specifies the intended direction, control event, payload length, transport progression, and whether to start a new flow episode. Given runtime state StS_t, the compiler emits packet WtW_t and updates St+1S_{t+1}; sequence/acknowledgment history and other derived values remain in the runtime. After prefix initialization, compilation uses neither reference suffix fields nor future packets.

The raw-field baselines in the submission use a literal renderer that recomputes only packet-local quantities required for serialization. Repeatable serialization is not the deterministic decoding claimed by TraceCodec. If a predicted ACK is inconsistent with the peer's current sequence state, or if endpoint, direction, flags, payload, and transport fields imply incompatible histories, the raw row does not identify whether the intended operation was to continue the flow, start a new episode, or override one of the conflicting values. A state-aware raw-field backend could be designed, but it would need its own precedence, repair, or constraint rules to interpret these conflicts. Those rules supply transition semantics absent from the raw prediction and therefore define a different decode interface, rather than a simple substitution of an equivalent compiler.

PacketAction and the executor therefore form one decode contract: the action supplies transition semantics, while the runtime supplies accumulated state. This is the distinction among literal rendering, post-hoc repair, and state-transition execution.

In the matched state-executor control, we held actions, timing, routing, synthetic endpoint materialization, and serialization fixed and replaced only deterministic TCP-state execution with the causal LSTM realizer. TCP analysis-profile error, the sum of absolute differences across eight TShark diagnostic-event rates, increases from 4.52 to 36.19 ±\pm 2.09 pp with reference actions, and from 15.20 to 36.17 ±\pm 2.83 pp with TraceCodec-decoded actions (mean ±\pm sample standard deviation over three seeds). This result is specific to the realizer tested, but it shows that a learned replacement does not recover the same protocol behavior even when the actions and the rest of the realization path are fixed.

Role of the learned latent and neural backbone

The learned latent is the packet-aligned continuous interface consumed by downstream flow matching. It must accurately reconstruct executable PacketActions and timing while providing a regularized continuous space for sequence generation. We use a β\beta-VAE for these two requirements. Because accumulated protocol state is externalized, the decoder predicts intended transitions rather than independently reconstructing history-dependent absolute fields.

To test whether the result depends on self-attention, we replaced only the Transformer encoder with a parameter-matched two-layer MLP over the same inputs. The PacketAction schema, 128-dimensional latent, decoder, β\beta-VAE objective, compiler, split, and training protocol were fixed; the comparison uses one training seed.

On the 660,916-packet CICIDS2017 test split, the MLP reaches 99.863% mean action-field accuracy versus 99.653% for the Transformer, and both produce 100% tokenizable coverage. The MLP has higher timing error (4.106 vs. 2.015 ms MAE; 1.098% vs. 0.487% IAT TV) but lower TCP analysis-profile error (11.04 vs. 12.51 pp). Neither backbone dominates every metric. This result strengthens the interface claim: high-fidelity reconstruction and realization are not specific to self-attention. Both models remain learned β\beta-VAE codecs, so the control changes the encoder family rather than removing the neural codec.

AuthorsOpenReview ↗

Response to x1aX (Part 2/3)

Explicit timing coordinate

The submitted continuation comparison enabled a separate inter-packet-time coordinate for TraceCodec; this was a configuration error. The downstream model generated this coordinate jointly with the latent sequence; it did not receive the target suffix's timing at inference, and the coordinate is not required by TraceCodec decoding. We reran the comparison with timing reconstructed through the generated 128-dimensional latent alone. CA-TV is the coverage-adjusted TV used in the submission; it penalizes missing or invalid packet mass in addition to the distance between decoded and reference distributions.

Continuation inputUsable suffixes ↑\uparrowValid coverage ↑\uparrowCA IAT TV ↓\downarrowCA packet-size TV ↓\downarrowCA packets/flow TV ↓\downarrowCA session-duration TV ↓\downarrow
Explicit timing coordinate100%100%12.56%18.60%36.49%39.55%
Latent only100%100%13.54%19.97%37.62%40.03%

In this matched single-seed control, the two settings are close and the source-PCAP-clustered paired bootstrap does not resolve a difference. We will report the latent-only configuration and correct the description of the timing input in the revision.

What the continuation experiment establishes

Usable suffixes intentionally measure decode reliability: whether a generated latent sequence can be materialized into the requested packet artifact. This is a necessary codec property and the failure mode targeted by the proposed interface; it is not a sufficient measure of traffic realism. Valid-packet coverage separately measures how much of that output is accepted as tokenizable by the evaluator. We therefore report packet-count materialization and valid coverage separately from transport and flow diagnostics.

All representations use the same downstream generator and training protocol so that their behavior is compared under matched conditions. The executable PacketAction/compiler interface provides a defined realization path, but the downstream generator still has to learn long-range flow dynamics.

The CICIDS2017 flow-level gaps remain substantial in the latent-only follow-up: packets-per-flow TV is 37.62% and session-duration TV is 40.03%. The generated suffixes are more fragmented: median per-case 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 large packets-per-flow and session-duration discrepancies; the corresponding MAWI gaps are much smaller, at 4.33% and 5.12%.

Although its magnitude varies with binning, the duration mismatch is not a TV-only artifact: under the submitted bins, JSD is 0.180 bits, and the unbinned KS distance is 0.379. We retain TV as the primary submitted metric and report JSD and KS as sensitivity checks.

We also evaluated event-to-event TCP transitions and multi-flow interleaving on 128 paired generated/reference suffixes per method:

Continuation interfaceTCP transition TV ↓\downarrowFlow-switch error ↓\downarrowSame-flow run KS ↓\downarrowSession-duration KS ↓\downarrow
TraceCodec, latent only0.1750.1800.2680.379
TVAE0.3700.5040.3840.480
TabSyn-VAE0.2350.4860.3490.394

TraceCodec is closest among the evaluated interfaces on all four diagnostics, although absolute errors remain: the median flow-switch rate rises from 0.323 in the reference suffixes to 0.510 after generation, 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 make this distinction explicit in the revision.

AuthorsOpenReview ↗

Response to x1aX (Part 3/3)

NetDiffusion and NetSSM comparisons

We distinguish a full-system generator comparison from the codec-level comparison at issue here. NetDiffusion and NetSSM are native end-to-end generators, not interchangeable PCAP -> latent -> PCAP codecs that can be placed under our flow-matching model. A full-system comparison would simultaneously change the representation, sequence generator, conditioning, timing policy, and realization procedure. We therefore do not present the following experiment as an end-to-end NetDiffusion baseline.

As a narrower, controllable comparison, we evaluated the frozen autoencoder exposed by NetDiffusion's public network implementation on the same held-out CICIDS2017 traffic. nPrint-space accuracy is not directly comparable to PacketAction accuracy, so we evaluate the resulting PCAPs. Directly converting the decoded nPrint rows without field completion or protocol repair yields 89 tokenizable packets out of 660,916 reference packets. We also evaluate the released repair path.

Reconstruction pathTokenizable packet coverage ↑\uparrowProtocol TV ↓\downarrowTCP analysis-profile error ↓\downarrowTiming in reconstructed PCAP
NetDiffusion AE, direct0.0135%N/A (insufficient coverage)N/A (insufficient coverage)Not represented
NetDiffusion AE + published repair99.9979%10.85%42.85 ppNot represented
TraceCodec100.00%0.00%14.51 ppIAT TV: 0.84%

Because nPrint omits fields supplied during realization, direct-path coverage is an interface diagnostic rather than a standalone measure of autoencoder quality. The released repair path recovers nearly complete coverage but still has 10.85% protocol TV and 42.85 pp TCP analysis-profile error; it also uses additional realization rules and source-window context, and does not represent timing. We therefore treat it as a reference path rather than an equivalent codec. These results motivate the distinction between a learned field representation and a state-aware executable interface.

NetSSM does not expose an analogous paired codec component, so constructing one would change its native autoregressive method rather than provide a controlled codec comparison. A full-system benchmark would provide complementary evidence rather than an attribution control. We will clarify this scope and discuss the related structured-validity systems more explicitly.

Reconstructed-PCAP utility

We added a VNAT-style four-category application-classification evaluation of reconstructed PCAPs on a capture-disjoint split. The classifier is trained only on real training captures and then frozen:

Held-out evaluation inputCapturesValid windowsCapture-balanced macro-F1 ↑\uparrow95% capture-bootstrap CI
Real PCAP124840.714[0.657, 0.772]
Reference PacketActions + compiler124830.711[0.656, 0.769]
TraceCodec-decoded PacketActions + compiler125260.687[0.607, 0.767]

Compiling reference PacketActions nearly preserves real-PCAP utility (0.711 vs. 0.714 macro-F1), while decoded actions retain task-relevant information at 0.687 macro-F1. Together, this classification result and the continuation diagnostics evaluate complementary properties: downstream feature retention after codec reconstruction and transport/flow behavior after latent-space generation.

Scope of the contribution

Our contribution is the executable learned interface formed by explicit PacketActions, a continuous neural codec, and an external state-aware executor. The model predicts intended packet transitions, the runtime maintains protocol history, and the compiler executes the corresponding state updates without inferring which conflicting raw field should take precedence. This gives imperfect neural predictions a defined path to executable PCAPs rather than relying on post-hoc conflict resolution. We will revise the related-work discussion to acknowledge earlier structured-validity systems and make this distinction from NetDiffusion, NetSSM, and related approaches explicit.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.