Pith. sign in

REVIEW 4 major objections 8 minor 61 references

Lego Sketch: A Scalable Memory-augmented Neural Network for Sketching Data Streams

T0 review · 4 major / 8 minor · reviewed 2026-08-07 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read The Lego sketch is a memory-augmented neural network that scales one trained model across space budgets from 100KB to 140MB and across data domains without retraining.

desk verdict A genuinely new neural sketch architecture with strong empirical results, but the paper's headline error bound has a concrete proof gap and the scalability theorem is heuristic. read the letter →

arxiv 2505.19561 v1 pith:HZ4EYXH2 submitted 2025-05-26 cs.LG

Yuan Feng , Yukun Cao , Hairu Wang , Xike Xie , S Kevin Zhou This is my paper · ORCID
classification cs.LG
keywords frequencyestimationdatastreamsketchingmemory-augmentedneuralnetworkssketchesZipfdistributionscalablememorymeta-learningnormalizedhashembedding
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

This paper sets out to show that a neural sketch for frequency estimation in data streams can be made scalable, instead of being retrained whenever the data domain or the space budget changes. It proposes the Lego sketch, a memory-augmented network built from modular memory bricks: items are hashed into sub-streams, each brick stores one sub-stream, and adding bricks enlarges memory. The authors claim that because the embedding is hash-based and L1-normalized, its distribution is the same across all domains, and because each brick sees a sub-stream with nearly the same Zipf skewness as the full stream, a model trained on one brick transfers to any number of bricks. If these claims hold, a single trained sketch can be resized from 100KB to 140MB and deployed on unrelated stream domains without retraining, while lowering average absolute and relative error compared with handcrafted and existing neural sketches.

What carries the argument

The load-bearing mechanism is the pairing of a normalized multi-hash embedding with hash-distributed scalable memory. The embedding looks up $d_1$ entries of one learnable vector through hash functions and L1-normalizes the result, which is what makes the embedding distribution domain-invariant; the memory manager then hashes each item into one of $K$ bricks, each a replica of the trained single-brick module, so the total space is $K$ times one brick and no retraining is needed when $K$ changes. Two supporting components carry the accuracy argument: a Deep Sets-based memory-scanning module that reads one tenth of a brick to reconstruct stream characteristics such as item count and Zipf skewness, and a self-guided weighting loss that reweights each meta-task's errors by the error of a rule-based estimate $\hat{f}_i'' = \min(m_i / v_i)$.

What would settle it

On a synthetic Zipf stream with known $\alpha$, hash items into $K$ bricks and directly estimate the sub-skewness $\alpha'$ inside each brick; if $\alpha'$ deviates from $\alpha$ for items beyond rank 10 by more than the paper's simulation suggests, the transfer premise fails. A behavioral test is to train the model at $K=1$, evaluate at $K=64$ on a stream whose bricks have been deliberately imbalanced (for example, hashing only the highest-frequency items into one brick), and check whether the average relative error on that brick degrades sharply.

Watch

Extended reading notes

Core claim

The central claim is that a neural sketch's two scalability failures—domain shift and memory resizing—can be solved simultaneously by replacing the domain-specific learned embedding with a normalized multi-hash embedding and replacing the fixed dense memory with $K$ hash-partitioned memory bricks. Theorem 4.1 says the normalized embedding vectors follow the same distribution for every data domain; Theorem 4.2 gives a transfer formula showing that the sub-skewness $\alpha'$ inside each brick approximates the global skewness $\alpha$ once the top few items are excluded, so the scanner and decoder trained on one brick carry over to many bricks; Theorem 4.3 gives the first error bound for a neural sketch, $P(|\hat{f}_i'' - f_i| \ge \epsilon N) \le (\epsilon d_2)^{-1}$, for the rule-based estimate, where $d_2$ is the number of address slots in each row of a brick. On top of this scaffolding, the architecture adds a memory-scanning module that reconstructs global stream statistics from a subset of a brick and a self-guided weighting loss that uses the rule-based estimate as a guide during meta-training. The paper reports that the resulting Lego sketch lowers average absolute and relative error relative to count-min, count, learned count, and meta-sketch across five real datasets and synthetic Zipf streams, with memory resized over a 1400-fold range.

Load-bearing premise

The scalability guarantee rests on the assumption that after items are hashed into $K$ memory bricks, the frequency distribution inside each brick has approximately the same shape as the whole stream except for a handful of top items, so the model trained on one brick transfers unchanged to all bricks.

Editorial extensions

If this is right

  • A single pretrained Lego sketch can serve any space budget that is a multiple of one brick, from a 100KB brick up to 140MB, without retraining.
  • Because the embedding distribution is domain-invariant, the same trained model transfers to new stream domains, as demonstrated on five real datasets spanning word, communication, click, edit, and document streams.
  • Stream-level statistics such as the number of distinct items and the Zipf skewness can be recovered from compressed memory by the scanning module, giving the decoder information handcrafted sketches cannot easily access.
  • The rule-based estimate $\hat{f}_i'' = \min(m_i/v_i)$ carries a provable error bound, making the Lego sketch the first neural sketch with an error analysis rather than purely empirical accuracy.
  • Using the Lego sketch as the core of an elastic-style derivative (heavy-part filter plus Lego core) yields further error reduction, so the architecture can replace count-min and count cores inside existing derivative frameworks.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • A testable extension beyond this paper: the 'train on one shard, hash into $K$ shards, transfer' recipe should apply to other learned data structures whose training depends only on frequency ranks, such as learned Bloom filters or graph stream summaries, since Theorems 4.1 and 4.2 do not rely on domain-specific features.
  • The self-guided loss suggests a general meta-learning trick: when a cheap rule-based baseline exists inside a model, reweighting each meta-task's errors by that baseline's error can push the neural estimator to beat the baseline at large budgets, a recipe that could be lifted out of sketching entirely.
  • If the scanning module genuinely recovers $n$ and $\alpha$ from one tenth of a brick, it could serve as a lightweight stream-profiling tool that reports distributional statistics without maintaining separate counters.
  • The memory-scaling argument assumes hash-uniform distribution of items across bricks; in adversarial settings where an attacker controls item-to-hash mappings, per-brick skewness could diverge, so random seed refresh or robust hashing may be needed before the 140MB scaling claim is used in security-sensitive deployments.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

4 major / 8 minor

Summary. The paper introduces the Lego Sketch, a memory-augmented neural network (MANN) for estimating item frequencies in data streams. Its architecture combines (i) a normalized multi-hash embedding that maps any item to an L1-normalized vector using a learnable table and d1 hash functions, (ii) a scalable memory organized as K hash-distributed bricks so the space budget can be changed by adding bricks without retraining, (iii) a DeepSets-based memory-scanning module that reconstructs global stream characteristics (item count n and skewness α) from a subset of a memory brick, and (iv) an ensemble decoder that blends a neural prediction with the rule-based estimate min(m_i / v_i), gated on reconstructed skewness. Training is self-supervised meta-learning on synthetic Zipf streams with a self-guided loss that weights task errors by the inverse of the rule-based error. The paper claims domain-agnostic scalability (Theorem 4.1), memory scalability via a sub-skewness analysis (Theorem 4.2), and what it calls the first error bound for a neural sketch (Theorem 4.3). Experiments cover four real datasets (Lkml, Kosarak, Wiki, Webdocs; the Aol dataset was removed because of its anonymization flaw) and six synthetic Zipf streams, with CMS, CS, LCS, meta-sketch, and a D-Lego derivative as baselines, plus ablations and throughput measurements. Code is provided.

Significance. The paper addresses a genuine limitation of earlier neural sketches — retraining when the domain or space budget changes — and the modular brick design is a credible engineering response. The empirical evaluation is broad (four real and six synthetic streams, several baseline families, ablations, and throughput), the reported results are consistent in direction, and the code is released. If the empirical claims hold, this is a useful practical contribution to learned data structures. The theoretical part is the weak point: Theorem 4.3, advertised as the first error bound for a neural sketch, relies on an unproven expectation step that is false for non-constant positive embeddings, so the stated constant is not established; Theorem 4.2 is a heuristic presented as a theorem; and the experiments report no variance information despite stochastic training. All of these are repairable within the manuscript's scope, but the current text overstates what is guaranteed.

major comments (4)
  1. [§4.3 / Appendix G] Theorem 4.3 states P(|f''_i - f_i| ≥ εN) ≤ (ε d2)^{-1}, and the proof in Appendix G derives this via E[f''_i - f_i] ≤ N/d2. The step from the collision sum to N/d2 requires E[v_j^k / v_i^k] ≤ 1, which is asserted with no justification. Under the paper's own setup this is false: by the proof of Theorem 4.1, v_j^k and v_i^k are independent and identically distributed for distinct items i, j; Appendix C constrains V to [ε, 1] with ε = 0.001; and the ablation in Section 5.5 shows the learned V matters, so the marginal distribution is non-degenerate. For positive i.i.d. X, Y, Jensen's inequality gives E[X/Y] = E[X]E[1/Y] ≥ 1, with strict inequality whenever Y is non-constant, so E[v_j^k / v_i^k] > 1. The Markov step therefore yields only P(f''_i - f_i ≥ εN) ≤ C/(ε d2) with C = E[v_j^k / v_i^k] > 1, not the stated 1/(ε d2). Because the 'first error bound for neural sketch' claim and the comparison in Section 4.3 rest on this constant, the theorem must be restated with an explicit and validated constant (or a genuine bound on C derived from the constraint set), and the proof corrected. It should also be stated that the bound concerns the rule-based fallback branch of Algorithm 2, not the neural prediction f'_i.
  2. [§4.2 / Appendix F] Theorem 4.2 is presented as a guarantee that the sub-stream skewness α' approximates the global skewness α, and the abstract says the analysis 'guarantees' high scalability. The proof is heuristic: the two distributional assumptions D ~ Geometric(1/K) and (r_i - r'_i) ~ NB(r'_i, 1/K) are asserted with only a Bernoulli-process intuition and no derivation; the negative-binomial parameter is off by one relative to the usual 'failures before r'_i - 1 successes' reading (which would give NB(r'_i - 1, 1/K)); and the key conclusion that α' ≈ α outside the top items is supported only by the numerical simulation in Figure 5, not by the stated formula. The formula is the local log-log slope between two points of a Zipf distribution; it does not by itself deliver the transfer claim used to justify multi-brick scaling. I recommend re-framing Section 4.2 as a heuristic/empirical analysis with explicit conditions and tempering the 'guarantees' language, or supplying genuine derivations of the distributional claims and a bound on the approximation error.
  3. [§5.1, Figure 2, Table 2] Section 5.1 states that the Aol dataset was excluded from experiments and ablations because reviewers identified its anonymization flaw, yet Figure 2, the introduction's motivating space-accuracy plot, carries the caption 'Space-accuracy Trade-off (Aol Dataset)', and Table 2 still lists Aol's statistics (n = 197,790, N = 361,115). The paper's motivating figure is therefore based on data the authors themselves exclude, contradicting their own disclosure. This must be resolved — replace Figure 2 with valid datasets and remove Aol from Table 2 and the surrounding discussion. Given the well-known privacy problems of the AOL search-log release, the current state of the manuscript also raises a data-ethics issue that the authors should address explicitly.
  4. [§5.1–§5.5, Figures 6–9] All experimental results in Figures 6–9 are reported as single runs, with no error bars, no numbers of seeds, and no significance tests. Since both the Lego Sketch and the meta-sketch baseline involve stochastic meta-learning, the strength of claims such as 'the ARE of the Lego sketch is only 85% of the error of MS' (Section 5.2) cannot be assessed. At minimum, the key comparisons (real datasets at representative budgets, the robustness sweep, and the four ablations) should be rerun over several seeds and reported as mean ± standard deviation with the seed count stated.
minor comments (8)
  1. [Appendix E] The proof of Theorem 4.1 states P[v'_ij = V_k] = 1/d1, but since the learnable table V has dimension 80 (Appendix C) and each hash function H_j maps to one index of V, the probability should be 1/80; the text should be corrected for consistency.
  2. [§4.3] The sentence 'The above analysis shows a wider margin compared to handcrafted sketch boundaries' is vague, since the stated bound has the same functional form as the classic Count-Min bound; the comparison should be made precise and any difference in constants quantified.
  3. [§5.1] The space budget B counts only the K memory bricks; the parameters of V, gscan, and gdec are not included, and at the smallest budget (0.6 MB) the fixed model overhead may be a material fraction of the footprint, so the accounting should be stated explicitly and the model size quantified.
  4. [Algorithm 2] The gating condition uses I_α, but this skewness interval is never defined in the main text; it should be defined (presumably the training range [0.5, 1.0]) and its role in selecting the neural versus rule-based branch explained.
  5. [§3.2] The self-guided loss weights the neural error by the inverse of the rule-based error produced by the same model; since f' and f'' share inputs, the guide is not independent of the learner, and a brief discussion of possible feedback effects during training would strengthen the presentation, even though the ablation in §5.5 shows an empirical benefit.
  6. [§3.1] The scalable memory is said to supplement m_i with a counting bucket carrying the sub-stream length, but this is not formalized in the memory model or in the proof of Theorem 4.3; please specify how this term enters the estimate f'' and the analysis.
  7. [§4.3 / Theorem 4.3] Since stores and queries are routed by H(x_i) to a single brick, the collision sum for K bricks is over a sub-stream of total frequency ≈ N/K, which would give the stronger bound 1/(ε K d2); the theorem should either state this or explicitly restrict itself to the single-brick training configuration.
  8. [Throughout] Minor typos should be fixed: 'dedicate creations' in the Figure 3 caption, 'theLego sketch' in the abstract, a missing subscript in 'In is set within [1000,50000]' in Appendix C, and 'pascal distribution' in Appendix F.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the Lego sketch's accuracy and scalability claims are tested against external baselines, and the self-citations are not load-bearing.

full rationale

The paper's central empirical claims are validated against external handcrafted and neural baselines (CMS, CS, LCS, meta-sketch) on real and synthetic streams, so the reported accuracy and memory-scaling results do not reduce to the paper's own fitted quantities. The self-citations to Cao et al. (2023, 2024) and Feng et al. (2024) motivate the MANN-based neural-sketch line and the training recipe, but they are not load-bearing: the novel modules (normalized multi-hash embedding, scalable memory, memory scanning, and self-guided loss) are specified and ablated in this paper, and the comparisons are against external methods. The self-guided loss uses the model's own rule-based estimate only as a per-task weighting term in the training objective, not as the target of a reported prediction, so it is not a fit-renamed-as-prediction. Theorem 4.3's proof does contain an unproven (and likely false) inequality E[v_j^k / v_i^k] ≤ 1, which is a correctness concern about the claimed error bound rather than a circularity, since the theorem is not obtained by defining the embedding in terms of the bound or by fitting the bound to data. No step in the derivation chain is equivalent to its input by construction, and no self-citation chain forces the paper's architectural choices.

Assumptions & free parameters 3 free parameters · 5 assumptions · 0 invented entities

The architecture's practical success depends on the learnable parameters and a set of modeling assumptions about Zipf streams and hash randomness. The most fragile are the unproven expectation in Theorem 4.3 and the sub-stream skewness approximation in Theorem 4.2.

free parameters (3)
  • learnable embedding table V = size 80, values in [0.001, 1]
    Trained on synthetic Zipf streams with skewness 0.5-1.0; used for all item embeddings.
  • network parameters for gscan and gdec = 8-layer Deep Sets, hidden size 32, LeakyReLU
    Learned during meta-training; these are the neural predictors and scanners.
  • hyperparameters d1, d2, brick size, subset fraction, beta, loss weight = d1=5, d2=5120, 100KB per brick, 1/10 subset, beta=10,000, 0.1 loss weight
    Chosen by hand; affect the space-accuracy trade-off and the scanning subset.
assumptions (5)
  • domain assumption Item frequencies follow Zipf distributions with skewness alpha in [0.5,1.0] for training meta-tasks.
    Section 3.2 and Appendix D: all synthetic training streams are Zipf; generalization to alpha up to 1.5 is tested but not guaranteed.
  • standard math Hash functions distribute outputs uniformly and independently.
    Used in Theorem 4.1 (Appendix E) and Theorem 4.2 (Appendix F).
  • ad hoc to paper Rank distances in sub-streams follow geometric and negative binomial distributions.
    Appendix F: approximates hash partitioning to K bricks as a Bernoulli process; no proof that ranks are independent or that the distributions hold for finite streams.
  • ad hoc to paper E[v_j^k/v_i^k] = 1 for normalized embeddings used in the error bound.
    Appendix G: the bound relies on this expectation without proof; the ratio can be large when v_i^k is near epsilon.
  • domain assumption Memory content is permutation-invariant, so Deep Sets can reconstruct stream characteristics from a subset.
    Section 3.1: justifies using Deep Sets; relies on a subset of one-tenth of the brick being sufficient.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Lego Sketch: A Scalable Memory-augmented Neural Network for Sketching Data Streams." pith.science (2026). https://pith.science/paper/HZ4EYXH2

@misc{pith2026250519561,
  author       = {Pith},
  title        = {Pith review of: Lego Sketch: A Scalable Memory-augmented Neural Network for Sketching Data Streams},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/HZ4EYXH2}},
  note         = {Machine review of arXiv:2505.19561}
}
read the original abstract

Sketches, probabilistic structures for estimating item frequencies in infinite data streams with limited space, are widely used across various domains. Recent studies have shifted the focus from handcrafted sketches to neural sketches, leveraging memory-augmented neural networks (MANNs) to enhance the streaming compression capabilities and achieve better space-accuracy trade-offs.However, existing neural sketches struggle to scale across different data domains and space budgets due to inflexible MANN configurations. In this paper, we introduce a scalable MANN architecture that brings to life the {\it Lego sketch}, a novel sketch with superior scalability and accuracy. Much like assembling creations with modular Lego bricks, the Lego sketch dynamically coordinates multiple memory bricks to adapt to various space budgets and diverse data domains. Our theoretical analysis guarantees its high scalability and provides the first error bound for neural sketch. Furthermore, extensive experimental evaluations demonstrate that the Lego sketch exhibits superior space-accuracy trade-offs, outperforming existing handcrafted and neural sketches. Our code is available at https://github.com/FFY0/LegoSketch_ICML.

Figures

Figures reproduced from arXiv: 2505.19561 by the authors.

Figure 2
Figure 2. Space-accuracy Trade-off (Aol Dataset) 2014), network measurements (Yu et al., 2013; Yang et al., 2018), and big data analytics (Cormode et al., 2012; Zaharia et al., 2016). Sketches, a typical probabilistic structure, have become essential for representing data streams with sub-linear space and linear time while maintaining accu￾rate item frequency estimates. Two major research direc￾tion in sketching techniques ha… view at source ↗
Figure 3
Figure 3. Lego Sketch Overview: The Lego sketch enables a scalable and unified framework capable of adapting to different domains and space budgets, mirroring the modular design seen in dedicate creations built from multiple Lego bricks. shift in data domains or changes in space budgets. This requirement stems from their reliance on a sample MLP￾based embedding module and a fixed-size memory module within the traditional MANN… view at source ↗
Figure 4
Figure 4. Framework of the Lego Sketch (When an item xi is stored, it undergoes E and A, obtaining the embedding vector vi and address vector ai, which are subsequently stored into the distributed memory brick M within M. When querying an item xi, its embedding vector vi and address vector ai are obtained in the same way. These, combined with stream characteristics s reconstructed from the current memory brick by S, are input… view at source ↗
Figures from the paper (5 more)
Figure 5
Figure 5. Figure 5: Sub-skewness [PITH_FULL_IMAGE:figures/full_fig_p006_5.png]
Figure 6
Figure 6. Figure 6: Errors on Four Real Datasets. 2006), Lkml (Homscheid et al., 2015), Kosarak (Bodon, 2003), Wiki (Kunegis, 2013), and Webdocs (Lucchese et al., 2004). These five datasets are widely used in sketch litera￾tures (Roy et al., 2016; Cao et al., 2023; Hsu et al., 2019; Aaman…
Figure 7
Figure 7. Figure 7: Synthetic Datasets Rae et al., 2019), the space budget B is determined by the total size of K memory bricks M, which in our experiments is 100KB per brick M(d1 = 5, d2 = 5120). The budget allocated for filtering buckets in D-CMS and D-Lego is set to one-fourth of B (Ya…
Figure 9
Figure 9. Figure 9: Ablation Study 5.3. Robustness under Distributional Shift To verify the robustness of the Lego sketch against potential distributional shifts across varying degrees of skewness, we also assess its accuracy under synthetic streams conform￾ing to Zipf distributions with …
Figure 10
Figure 10. Figure 10: Absent Results of Synthetic Datasets Algorithm 3 Training Algorithm 1: Input: Model(K = 1) with all learnable parameters θ 2: while not reaching the max step do 3: Generating a batch b of meta-tasks 4: for meta task T ∈ b do 5: Clear the memory M 6: Store all items in…

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

61 extracted references · 55 canonical work pages

  1. [1]

    write newline

    " write newline "" before.all 'output.state := FUNCTION n.dashify 't := "" t empty not t #1 #1 substring "-" = t #1 #2 substring "--" = not "--" * t #2 global.max substring 't := t #1 #1 substring "-" = "-" * t #2 global.max substring 't := while if t #1 #1 substring * t #2 global.max substring 't := if while FUNCTION format.date year duplicate empty "emp...

  2. [2]

    Improved frequency estimation algorithms with and without predictions

    Aamand, A., Chen, J., Nguyen, H., Silwal, S., and Vakilian, A. Improved frequency estimation algorithms with and without predictions. Advances in Neural Information Processing Systems, 36, 2024

    work page 2024

  3. [3]

    Zipf, power-law, pareto - a ranking tutorial

    Adamic, L. Zipf, power-law, pareto - a ranking tutorial. http://www.hpl.hp.com/research/idl/papers/ranking/, 2000

    work page 2000

  4. [4]

    Aghazadeh, A., Spring, R., LeJeune, D., Dasarathy, G., Shrivastava, A., and Baraniuk, R. G. MISSION: ultra large-scale feature selection using count-sketches. In ICML, volume 80, pp.\ 80--88. PMLR , 2018. URL http://proceedings.mlr.press/v80/aghazadeh18a.html

    work page 2018

  5. [5]

    Models and issues in data stream systems

    Babcock, B., Babu, S., Datar, M., Motwani, R., and Widom, J. Models and issues in data stream systems. In PODS, pp.\ 1--16, 2002

    work page 2002

  6. [6]

    Berinde, R., Indyk, P., Cormode, G., and Strauss, M. J. Space-optimal heavy hitters with strong error bounds. ACM Transactions on Database Systems (TODS), 35 0 (4): 0 1--28, 2010

    work page 2010

  7. [7]

    A fast apriori implementation

    Bodon, F. A fast apriori implementation. In FIMI, volume 3, pp.\ 63. Citeseer, 2003

    work page 2003

  8. [8]

    Web caching and zipf-like distributions: Evidence and implications

    Breslau, L., Cao, P., Fan, L., Phillips, G., and Shenker, S. Web caching and zipf-like distributions: Evidence and implications. In INFOCOM, pp.\ 126--134, 1999

    work page 1999

Show all 61 references
  1. [9]

    Meta-sketch: A neural data structure for estimating item frequencies of data streams

    Cao, Y., Feng, Y., and Xie, X. Meta-sketch: A neural data structure for estimating item frequencies of data streams. Proceedings of the AAAI Conference on Artificial Intelligence, 37 0 (6): 0 6916--6924, Jun. 2023. doi:10.1609/aaai.v37i6.25846. URL https://ojs.aaai.org/index.p...

    2023 doi

  2. [10]

    Cao, Y., Feng, Y., Wang, H., Xie, X., and Zhou, S. K. Learning to sketch: A neural approach to item frequency estimation in streaming data. IEEE Transactions on Pattern Analysis and Machine Intelligence, 2024

    2024

  3. [11]

    C., and Farach - Colton, M

    Charikar, M., Chen, K. C., and Farach - Colton, M. Finding frequent items in data streams. In ICALP, pp.\ 693--703, 2002

    2002

  4. [12]

    Precise error estimation for sketch-based flow measurement

    Chen, P., Wu, Y., Yang, T., Jiang, J., and Liu, Z. Precise error estimation for sketch-based flow measurement. In Proceedings of the 21st ACM Internet Measurement Conference, pp.\ 113--121, 2021

    2021

  5. [13]

    and Hadjieleftheriou, M

    Cormode, G. and Hadjieleftheriou, M. Finding frequent items in data streams. Proceedings of the VLDB Endowment, 1 0 (2): 0 1530--1541, 2008

    2008

  6. [14]

    and Muthukrishnan, S

    Cormode, G. and Muthukrishnan, S. An improved data stream summary: the count-min sketch and its applications. J. Algorithms, 55 0 (1): 0 58--75, 2005

    2005

  7. [15]

    N., Haas, P

    Cormode, G., Garofalakis, M. N., Haas, P. J., and Jermaine, C. Synopses for massive data: Samples, histograms, wavelets, sketches. Foundations and Trends in Databases, 4 0 (1-3): 0 1--294, 2012

    2012

  8. [16]

    Associative long short-term memory

    Danihelka, I., Wayne, G., Uria, B., Kalchbrenner, N., and Graves, A. Associative long short-term memory. In International conference on machine learning, pp.\ 1986--1994. PMLR, 2016

    1986

  9. [17]

    and Rafiei, D

    Deng, F. and Rafiei, D. New estimation algorithms for streaming data: Count-min can do more. Webdocs. Cs. Ualberta. Ca, 2007

    2007

  10. [18]

    and Varghese, G

    Estan, C. and Varghese, G. New directions in traffic measurement and accounting. In SIGCOMM, pp.\ 323--336, 2002

    2002

  11. [19]

    Feng, Y., Cao, Y., Hairu, W., Xie, X., and Zhou, S. K. Mayfly: a neural data structure for graph stream summarization. In The Twelfth International Conference on Learning Representations, 2024. URL https://openreview.net/forum?id=n7Sr8SW4bn

    2024

  12. [20]

    Scout sketch + : Finding both promising and damping items simultaneously in data streams

    Gao, G., Ma, T., Huang, H., Sun, Y.-E., Wang, H., Du, Y., and Chen, S. Scout sketch + : Finding both promising and damping items simultaneously in data streams. IEEE/ACM Transactions on Networking, 2024 a

    2024

  13. [21]

    Tailoredsketch: a fast and adaptive sketch for efficient per-flow size measurement

    Gao, G., Qian, Z., Huang, H., Sun, Y.-E., and Du, Y. Tailoredsketch: a fast and adaptive sketch for efficient per-flow size measurement. IEEE Transactions on Network Science and Engineering, 2024 b

    2024

  14. [22]

    D., and Cormode, G

    Goyal, A., III, H. D., and Cormode, G. Sketch algorithms for estimating point queries in NLP . In Tsujii, J., Henderson, J., and Pasca, M. (eds.), Proceedings of the 2012 Joint Conference on Empirical Methods in Natural Language Processing and Computational Natural Language Le...

    2012

  15. [23]

    Neural turing machines

    Graves, A., Wayne, G., and Danihelka, I. Neural turing machines. arXiv preprint arXiv:1410.5401, 2014

    2014 arXiv

  16. [24]

    G., Grefenstette, E., Ramalho, T., Agapiou, J., et al

    Graves, A., Wayne, G., Reynolds, M., Harley, T., Danihelka, I., Grabska-Barwi \'n ska, A., Colmenarejo, S. G., Grefenstette, E., Ramalho, T., Agapiou, J., et al. Hybrid computing using a neural network with dynamic external memory. Nature, 538 0 (7626): 0 471--476, 2016

    2016

  17. [25]

    Sk-gradient: Efficient communication for distributed machine learning with data sketch

    Gui, J., Song, Y., Wang, Z., He, C., and Huang, Q. Sk-gradient: Efficient communication for distributed machine learning with data sketch. In 2023 IEEE 39th International Conference on Data Engineering (ICDE), pp.\ 2372--2385. IEEE, 2023

    2023

  18. [26]

    Private-collective innovation and open source software: Longitudinal insights from linux kernel development

    Homscheid, D., Kunegis, J., and Schaarschmidt, M. Private-collective innovation and open source software: Longitudinal insights from linux kernel development. In Open and Big Data Management and Innovation: 14th IFIP WG 6.11 Conference on e-Business, e-Services, and e-Society,...

    2015

  19. [27]

    Meta-learning in neural networks: A survey

    Hospedales, T., Antoniou, A., Micaelli, P., and Storkey, A. Meta-learning in neural networks: A survey. IEEE transactions on pattern analysis and machine intelligence, 44 0 (9): 0 5149--5169, 2021

    2021

  20. [28]

    Learning-based frequency estimation algorithms

    Hsu, C.-Y., Indyk, P., Katabi, D., and Vakilian, A. Learning-based frequency estimation algorithms. In ICLR, 2019

    2019

  21. [29]

    Memory-efficient and flexible detection of heavy hitters in high-speed networks

    Huang, H., Yu, J., Du, Y., Liu, J., Dai, H., and Sun, Y.-E. Memory-efficient and flexible detection of heavy hitters in high-speed networks. Proceedings of the ACM on Management of Data, 1 0 (3): 0 1--24, 2023

    2023

  22. [30]

    Communication-efficient distributed sgd with sketching

    Ivkin, N., Rothchild, D., Ullah, E., Stoica, I., Arora, R., et al. Communication-efficient distributed sgd with sketching. Advances in Neural Information Processing Systems, 32, 2019

    2019

  23. [31]

    Multi-task learning using uncertainty to weigh losses for scene geometry and semantics

    Kendall, A., Gal, Y., and Cipolla, R. Multi-task learning using uncertainty to weigh losses for scene geometry and semantics. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp.\ 7482--7491, 2018

    2018

  24. [32]

    On permutation-invariant neural networks, 2024

    Kimura, M., Shimizu, R., Hirakawa, Y., Goto, R., and Saito, Y. On permutation-invariant neural networks, 2024

    2024

  25. [33]

    Konect: the koblenz network collection

    Kunegis, J. Konect: the koblenz network collection. In Proceedings of the 22nd international conference on world wide web, pp.\ 1343--1350, 2013

    2013

  26. [34]

    B., De Wardt, L., Dai, H., and Chen, G

    Liu, J., Basat, R. B., De Wardt, L., Dai, H., and Chen, G. Disco: A dynamically configurable sketch framework in skewed data streams. In 2024 IEEE 40th International Conference on Data Engineering (ICDE), pp.\ 4801--4814. IEEE, 2024

    2024

  27. [35]

    and Xie, X

    Liu, Y. and Xie, X. Xy-sketch: On sketching data streams at web scale. In Proceedings of the Web Conference 2021, pp.\ 1169--1180, 2021

    2021

  28. [36]

    and Xie, X

    Liu, Y. and Xie, X. A probabilistic sketch for summarizing cold items of data streams. IEEE/ACM Transactions on Networking, 32 0 (2): 0 1287--1302, 2023

    2023

  29. [37]

    Webdocs: a real-life huge transactional dataset

    Lucchese, C., Orlando, S., Perego, R., and Silvestri, F. Webdocs: a real-life huge transactional dataset. In FIMI, volume 126, 2004

    2004

  30. [38]

    Scout sketch: Finding promising items in data streams

    Ma, T., Gao, G., Huang, H., Sun, Y.-E., and Du, Y. Scout sketch: Finding promising items in data streams. In IEEE INFOCOM 2024-IEEE Conference on Computer Communications, pp.\ 1561--1570. IEEE, 2024

    2024

  31. [39]

    Efficient computation of frequent and top-k elements in data streams

    Metwally, A., Agrawal, D., and El Abbadi, A. Efficient computation of frequent and top-k elements in data streams. In International conference on database theory, pp.\ 398--412. Springer, 2005

    2005

  32. [40]

    and Gries, D

    Misra, J. and Gries, D. Finding repeated elements. Science of computer programming, 2 0 (2): 0 143--152, 1982

    1982

  33. [41]

    A picture of search

    Pass, G., Chowdhury, A., and Torgeson, C. A picture of search. In Proceedings of the 1st international conference on Scalable information systems, pp.\ 1--es, 2006

    2006

  34. [42]

    Meta-learning neural bloom filters

    Rae, J., Bartunov, S., and Lillicrap, T. Meta-learning neural bloom filters. In International Conference on Machine Learning, pp.\ 5271--5280. PMLR, 2019

    2019

  35. [43]

    Augmented sketch: Faster and more accurate stream processing

    Roy, P., Khan, A., and Alonso, G. Augmented sketch: Faster and more accurate stream processing. In SIGMOD, pp.\ 1449--1463, 2016

    2016

  36. [44]

    Meta-learning with memory-augmented neural networks

    Santoro, A., Bartunov, S., Botvinick, M., Wierstra, D., and Lillicrap, T. Meta-learning with memory-augmented neural networks. In International conference on machine learning, pp.\ 1842--1850. PMLR, 2016

    2016

  37. [45]

    and Mitzenmacher, M

    Shahout, R. and Mitzenmacher, M. Learning-based heavy hitters and flow frequency estimation in streams. In 2024 IEEE 32nd International Conference on Network Protocols (ICNP), pp.\ 1--13. IEEE, 2024

    2024

  38. [46]

    Compressing gradient optimizers via count-sketches

    Spring, R., Kyrillidis, A., Mohan, V., and Shrivastava, A. Compressing gradient optimizers via count-sketches. In International Conference on Machine Learning, pp.\ 5946--5955. PMLR, 2019

    2019

  39. [47]

    Talukdar, P. P. and Cohen, W. W. Scaling graph-based semi supervised learning to large number of labels using count-min sketch. In AISTATS, pp.\ 940--947. JMLR.org, 2014

    2014

  40. [48]

    Graph stream summarization: From big bang to big crunch

    Tang, N., Chen, Q., and Mitra, P. Graph stream summarization: From big bang to big crunch. In Proceedings of the 2016 International Conference on Management of Data, pp.\ 1481--1496, 2016

    2016

  41. [49]

    Count-min: Optimal estimation and tight error bounds using empirical error distributions

    Ting, D. Count-min: Optimal estimation and tight error bounds using empirical error distributions. In Proceedings of the 24th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, pp.\ 2319--2328, 2018

    2018

  42. [50]

    Hash embeddings for efficient word representations

    Tito Svenstrup, D., Hansen, J., and Winther, O. Hash embeddings for efficient word representations. Advances in neural information processing systems, 30, 2017

    2017

  43. [51]

    Matching networks for one shot learning

    Vinyals, O., Blundell, C., Lillicrap, T., Wierstra, D., et al. Matching networks for one shot learning. Advances in neural information processing systems, 29, 2016

    2016

  44. [52]

    Memory networks

    Weston, J., Chopra, S., and Bordes, A. Memory networks. arXiv preprint arXiv:1410.3916, 2014

    2014 arXiv

  45. [53]

    Elastic sketch: Adaptive and fast network-wide measurements

    Yang, T., Jiang, J., Liu, P., Huang, Q., Gong, J., Zhou, Y., Miao, R., Li, X., and Uhlig, S. Elastic sketch: Adaptive and fast network-wide measurements. In Proceedings of the 2018 Conference of the ACM Special Interest Group on Data Communication, pp.\ 561--575, 2018

    2018

  46. [54]

    and Zhu, J

    Yang, Y. and Zhu, J. Write skew and zipf distribution: Evidence and implications. ACM Trans. Storage , 12 0 (4): 0 21:1--21:19, 2016

    2016

  47. [55]

    Software \ Defined \ \ Traffic \ measurement with \ OpenSketch \

    Yu, M., Jose, L., and Miao, R. Software \ Defined \ \ Traffic \ measurement with \ OpenSketch \ . In 10th USENIX Symposium on Networked Systems Design and Implementation (NSDI 13), pp.\ 29--42, 2013

    2013

  48. [56]

    S., Wendell, P., Das, T., Armbrust, M., Dave, A., Meng, X., Rosen, J., Venkataraman, S., Franklin, M

    Zaharia, M., Xin, R. S., Wendell, P., Das, T., Armbrust, M., Dave, A., Meng, X., Rosen, J., Venkataraman, S., Franklin, M. J., et al. Apache spark: a unified engine for big data processing. Communications of the ACM, 59 0 (11): 0 56--65, 2016

    2016

  49. [57]

    R., and Smola, A

    Zaheer, M., Kottur, S., Ravanbakhsh, S., Poczos, B., Salakhutdinov, R. R., and Smola, A. J. Deep sets. Advances in neural information processing systems, 30, 2017

    2017

  50. [58]

    Experimental analysis of large-scale learnable vector storage compression

    Zhang, H., Zhao, P., Miao, X., Shao, Y., Liu, Z., Yang, T., and Cui, B. Experimental analysis of large-scale learnable vector storage compression. arXiv preprint arXiv:2311.15578, 2023

    2023 arXiv

  51. [59]

    I., Agrawal, D., Abbadi, A

    Zhao, F., Khan, P. I., Agrawal, D., Abbadi, A. E., Gupta, A., and Liu, Z. Panakos: Chasing the tails for multidimensional data streams. Proceedings of the VLDB Endowment, 16 0 (6): 0 1291--1304, 2023

    2023

  52. [60]

    Zhao, X., Xie, X., and Jensen, C. S. Higgs: Hierarchy-guided graph stream summarization. In 2025 IEEE 41th International Conference on Data Engineering (ICDE). IEEE, 2025

    2025

  53. [61]

    Cold filter: A meta-framework for faster and more accurate stream processing

    Zhou, Y., Yang, T., Jiang, J., Cui, B., Yu, M., Li, X., and Uhlig, S. Cold filter: A meta-framework for faster and more accurate stream processing. In SIGMOD, pp.\ 741--756, 2018

    2018

Pith tools

Reviewed August 7, 2026 · model on record in the stance chip above.