💰 quantitative finance

Zero-Copy Semantic Contagion: An In-Memory Streaming Architecture for Evolving Attention Graphs

This paper presents a zero-copy, heterogeneous Rust-Python streaming architecture that leverages a dynamic Neural Hawkes Process on evolving attention graphs to achieve sub-13ms latency and significantly outperform single-asset and sector-baseline models in forecasting next-day equity returns by capturing cross-company semantic contagion from news.

Original authors: Kabir Murjani

Published 2026-06-05

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Kabir Murjani

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine the stock market not as a collection of isolated islands, but as a giant, bustling city where news travels like a virus. Usually, when a piece of bad news hits one company (like a factory closing in Taiwan), traditional computer models only look at that specific company's price history. They are "blind" to the fact that the news might spread to other companies connected to it, like a supplier or a customer, until those other companies' prices have already started to move. By then, it's too late.

This paper introduces a new system designed to catch that "contagion" the moment the news breaks, predicting which other companies will get hit next. Here is how it works, broken down into simple parts:

1. The Super-Fast Scanner (The Rust Edge)

Think of the news feed as a massive, high-speed conveyor belt of text messages.

The Problem: Most computers are too slow to read these messages fast enough. By the time a standard computer finishes reading a headline, the market has already reacted.
The Solution: The authors built a "scanner" using a programming language called Rust. It's like a specialized robot that reads the text without ever stopping to organize its thoughts or write things down on a notepad (this is called "zero-copy").
The Speed: It reads a news record in about 100 nanoseconds (a billionth of a second). To put that in perspective, a human blink takes about 300 million times longer. It can scan a list of 47 different companies in the time it takes to snap your fingers.

2. The "Infection" Tracker (The Neural Hawkes Process)

Once the scanner reads the news, it passes it to a "brain" built with Python. This brain doesn't just look at the words; it looks at the connections between companies.

The Metaphor: Imagine a graph where every company is a node (a dot) and the lines between them represent how much they pay attention to each other.
How it learns: The system uses a special type of math called a Neural Hawkes Process. Think of this as a "contagion model." If Company A gets a shock (like a scandal), the model calculates how much that shock "excites" or "infects" Company B, Company C, and so on.
The Twist: Unlike older models that treat all connections as equal, this one learns that the connection is one-way. A news event about a chip manufacturer might heavily impact a phone maker, but the reverse isn't always true. The system captures this directionality.

3. The "Pruning" Mechanism (Keeping it Tidy)

In a real-time stream, connections could theoretically grow forever, making the computer slow down.

The Fix: The system has an automatic "gardener." If a connection between two companies becomes too weak (the "infection" dies out), the system cuts the line. This ensures the computer never gets bogged down, no matter how much news comes in.

4. The Results: Catching the Wave

The team tested this system on one month of real financial news involving 47 major companies (like Apple, NVIDIA, and Microsoft).

The Test: They asked: "When a news event hits Company A, can the system predict which other company will have a big price move the next day?"
The Outcome:
- Random Guessing: If you just picked companies at random, you'd be right about 8.9% of the time.
- Same-Sector Guessing: If you just guessed companies in the same industry (e.g., guessing a tech company when another tech company had news), you'd be right about 4.5% of the time.
- This System: It was right 15.1% of the time.
- The Takeaway: This is 1.7 times better than random guessing and 3.3 times better than just guessing within the same industry.

5. The "Aha!" Moment

The most important finding was a "control experiment." The researchers turned off the "connection map" (the graph) and let the system run on companies individually.

The Result: The system's accuracy dropped to zero.
The Meaning: This proves that the system's success wasn't due to the news reading or the math alone; it was entirely because it understood how companies are connected. The "contagion" is the only thing driving the signal.

Summary

The paper describes a system that acts like a high-speed radar for financial news. It reads text instantly, maps out how companies are linked, and predicts how a shock to one company will ripple through the network to others. While it currently runs on a standard computer chip, the authors show that with faster hardware, it could operate fast enough to be useful for high-frequency trading, spotting market moves before they fully happen.

Key Limitation: The paper notes that while the system is incredibly fast at processing the news (milliseconds), the actual test data only had daily price updates. So, while the system could theoretically work in real-time, the proof of its ability to predict moves within the same day is reserved for future work.

Technical Summary: Zero-Copy Semantic Contagion

Problem Statement

Financial forecasting models currently operate in silos, treating each ticker as an isolated time series. While numerical signals (price ticks, volume) are arbitraged in microseconds, qualitative information (news) requires semantic parsing before impacting prices, unfolding over a 20–60 minute horizon. Existing approaches fail to capture cross-company propagation: a supply-chain disruption (e.g., a foundry issue in Taiwan) does not register in a single-asset model until that asset's price moves or the asset is explicitly named in the text.

Two engineering barriers prevent resolving this at microsecond latencies:

Latency: Off-the-shelf semantic extractors introduce hundreds of milliseconds of latency, exceeding the predictive horizon.
Representation: Static graphs poorly represent attention, which decays rapidly between events and requires explicit continuous-time dynamics.

Methodology

The authors propose a heterogeneous Rust-Python streaming architecture that maps cross-company attention as a continuous-time graph driven directly from text. The system is decoupled into a microsecond-scale ingestion edge and a millisecond-scale inference engine.

1. System Architecture

Ingestion Edge (Rust): A zero-copy parser processes CSV/FIX records without heap allocation, returning byte-slice references to the input buffer. It enforces monotonic timestamps and performs a semantic clustering gate to filter redundant headlines based on cosine similarity.
- Performance: Parses records in ~100 ns and scans a 47-ticker universe in ~1.2 µs.
Inference Engine (PyTorch): A Multivariate Neural Hawkes Process that updates an in-memory continuous-time attention graph over $N=47$ $N = 47$ equity nodes.
- Continuous-Time LSTM (c-LSTM): Each node maintains a hidden state that decays exponentially between events and updates via standard LSTM gates upon event arrival, conditioned on projected text embeddings.
- Bilinear Latent Projection: Directed excitation ( $\alpha_{ij}$ ) is computed via a bilinear attention mechanism. This allows for asymmetric edge weighting ( $\alpha_{ij} \neq \alpha_{ji}$ ), capturing directional contagion (e.g., supplier to customer) rather than symmetric correlation.
- Adaptive Edge Pruning: An algorithmic rule prunes edges when their instantaneous excitation falls below a threshold, guaranteeing bounded graph density ( $O(1)$ amortized cost per node) regardless of stream length.

2. Graph Construction

The initial adjacency matrix is a learnable convex combination of three data-driven sources:

Co-Mention ( $A_{cm}$ ): Frequency of joint mentions in articles.
Semantic Similarity ( $A_{sem}$ ): Cosine similarity of averaged article embeddings.
Return Correlation ( $A_{corr}$ ): Pearson correlation of daily log-returns.
These weights are optimized jointly with the model parameters during maximum likelihood training.

3. Training Objective

Parameters are optimized by maximizing the log-likelihood of the observed event sequence. The loss function rewards high intensity at observed events while penalizing background activation during quiescent periods to prevent trivial intensity elevation.

Key Contributions

Zero-Copy Rust Ingestion: A parser that achieves ~100 ns parsing and ~1.2 µs ticker scanning on commodity hardware (Apple M2), with potential for further reduction on x86-64 via RDTSC and kernel-bypass networking.
Asymmetric Neural Hawkes Process: A continuous-time model featuring per-node c-LSTM states and bilinear latent projections that enable directed, context-aware edge weighting, a capability symmetric constructions lack.
Bounded Computational Cost: An adaptive pruning rule (Proposition 1) that guarantees bounded graph density, ensuring the system remains scalable for perpetual streaming.
Contagion Detection Protocol: An evaluation framework distinct from per-ticker price prediction, focusing on identifying which other companies will experience abnormal returns following a news event.

Experimental Results

The system was evaluated on a one-month temporal holdout of the FNSPID corpus (638 articles, 47 tickers, July 2022).

Precision Lift: At the 90th-percentile next-day return threshold, the full model achieved 15.1% precision.
- This represents a 1.70× lift over uniform random selection (8.9%).
- This represents a 3.36× lift over a same-sector heuristic (4.5%).
Ablation Studies:
- Graph Topology: Removing the graph (setting adjacency to zero) collapsed precision to 0.000 across all thresholds, confirming the graph is the sole driver of cross-company signal.
- Bilinear Projection: On this specific corpus, the bilinear weights did not measurably improve precision over a static adjacency, though they provided necessary structural directionality.
- Pruning: On this naturally sparse corpus, pruning had no empirical effect on precision but remains critical for worst-case computational guarantees.
Latency: The end-to-end processing latency is ~13 ms per record on a single CPU. The Rust ingestion layer contributes less than 0.02% of this total.
Portfolio Signal: An intensity-weighted long/short strategy (long top-10, short bottom-10 by intensity) yielded a positive annualized return with a 57.1% daily win rate over the holdout period.

Significance and Claims

The paper claims to address a complementary task to traditional per-ticker forecasting: given a shock to one company, predicting which other companies will move and when.

Architectural Invariance: The mathematical model is invariant to the deployment target; only the ingestion layer requires recompilation for different hardware (e.g., moving from ARM to x86-64 with kernel-bypass networking).
Signal Source: The results confirm that the dynamic attention network is the exclusive driver of cross-company signal in this architecture; without the graph topology, the c-LSTM dynamics and baseline rates contribute no cross-ticker discrimination.
Scalability: The system projects to handle over 400,000 records per second on a single ARM core, with potential for sub-10 ms inference on larger universes using batched computation.

The authors note that while the absolute precision (15.1%) is modest due to the complexity of next-day returns, the systematic lift over baselines demonstrates that the architecture successfully captures structural contagion that isolated models miss. Future work is deferred to intraday evaluation and higher-order propagation modeling.