Pith. sign in

REVIEW 4 major objections 6 minor 27 references

The Future is Sparse: Embedding Compression for Scalable Retrieval in Recommender Systems

T0 review · 4 major / 6 minor · reviewed 2026-08-15 · deepseek-v4-flash

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

Pith's one-line read The paper claims that CompresSAE, a sparse autoencoder trained with cosine reconstruction loss, compresses dense embeddings 12x while preserving retrieval quality and beating same-size Matryoshka compression by +1.52% CTR in an online A/B…

desk verdict CompresSAE is a sound, practically motivated compression method with strong online evidence, but the paper undersells its own offline protocol and overextends the A/B claim as a pure retrieval-quality result. read the letter →

arxiv 2505.11388 v1 pith:EEMSR24O submitted 2025-05-16 cs.IR cs.LG

Petr Kasalický , Martin Spišák , Vojtěch Vančura , Daniel Bohuněk , Rodrigo Alves , Pavel Kordík This is my paper · ORCID
classification cs.IRcs.LG
keywords embeddingcompressionsparseautoencodercandidateretrievalrecommendersystemscosinesimilarityMatryoshkarepresentationlearningclick-throughratememoryefficiency
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

Sparse autoencoders can compress large embedding tables in recommender systems far more aggressively than simple dimension truncation, without retraining the original embedding model. The paper's method, CompresSAE, maps a dense vector into a high-dimensional sparse vector with a fixed number of nonzero entries, for example 4096 dimensions with 32 nonzeros, and is trained to preserve cosine similarity instead of Euclidean distance. Stored in a sparse row format, a 768-dimensional embedding shrinks to one twelfth of its memory footprint. In an online test with about 8.5 million users per arm, the 12x compressed model lost only 1.35% of click-through rate relative to the uncompressed 768-dimensional embeddings, and outperformed a same-size Matryoshka-compressed embedding by +1.52% CTR. If these results hold, recommender systems facing strict memory budgets can use much richer frozen embeddings at a fraction of the storage cost.

What carries the argument

The load-bearing object is the CompresSAE sparse autoencoder, whose two design choices carry the argument. The first is the sparsification function $\phi(\cdot, k)$, which keeps the $k$ entries with largest absolute value rather than applying a ReLU and then a top-$k$, so negative directions survive; the second is training against cosine distance between input and reconstruction. The kernel trick for retrieval in the reconstructed space is the identity $K = W_{\text{dec}}^{\top}W_{\text{dec}}$, which turns cosine similarity in the reconstructed dense space into $s_x^{\top}K s_y / (\sqrt{s_x^{\top}K s_x}\sqrt{s_y^{\top}K s_y})$, computable in $O(k^2)$ using only the sparse codes. Because the decoder is bias-free, the same matrix $K$ works for every pair, so the method offers two inference modes: a fast $O(k)$ dot product directly in the sparse space, and a slower but more accurate $O(k^2)$ kernel-based mode aligned with the original dense space.

What would settle it

Run the online comparison again with the downstream ranker frozen and identical candidate-set sizes, logging CTR per user: if the +1.52% advantage over Matryoshka disappears or reverses, the central claim fails; offline, a public embedding dataset showing CompresSAE Recall@100 below a same-memory Matryoshka d=64 would also undermine it.

Watch

Extended reading notes

Core claim

On the paper's own terms, the central discovery is that a sparse autoencoder trained with a cosine reconstruction objective can almost perfectly distill a dense embedding's direction into a k-sparse high-dimensional code, and that this code retains enough information for candidate retrieval. Formally, the encoder $f_{\text{enc}}(x) = \phi(W_{\text{enc}}x + b_{\text{enc}}, k)$ keeps the $k$ entries with largest absolute values, and the decoder $f_{\text{dec}}(s) = W_{\text{dec}}s$ is linear and bias-free; the loss is $\mathcal{L} = 1 - x^{\top}\hat{x}/(\|x\|_2\|\hat{x}\|_2)$, combined for $k$ and $4k$ to avoid dead neurons. The paper reports that in production retrieval, a 4096-dimensional CompresSAE code with $k=32$ achieves a +3.44% CTR lift over the SBERT baseline at 25.6 GB per 100 million embeddings, while the uncompressed 768-dimensional Nomic model gives +4.86% at 307.2 GB and a same-size 64-dimensional Matryoshka gives +1.89%. That is the 12x memory reduction with a 1.35% CTR sacrifice against the uncompressed model, and a statistically significant +1.52% CTR advantage over Matryoshka of the same size.

Load-bearing premise

The online A/B test assumes that the click-through-rate difference between the two compression methods comes from the compressed embeddings themselves, even though the full recommender pipeline can change how the downstream ranker responds to each candidate set.

Editorial extensions

If this is right

  • A 768-dimensional dense embedding can be replaced by a 4096-dimensional 32-nonzero sparse vector, cutting memory from 307.2 GB to 25.6 GB per 100 million embeddings while keeping most of the retrieval quality.
  • CompresSAE can be applied on top of any frozen pretrained embedding model, because it trains only the autoencoder and does not require retraining the backbone encoder as Matryoshka-style compression does.
  • Retrieval cost in the sparse space depends on $k$, not on the embedding dimension, so high-dimensional sparse codes do not slow down dot-product search.
  • The reconstructed-space retrieval path gives a better accuracy-compression trade-off than direct sparse retrieval in the paper's offline experiments, at a modest $O(k^2)$ cost.
  • At equal memory, CompresSAE outperforms Matryoshka by +1.52% CTR in an online A/B test with about 8.5 million users per variant.

Reading between the lines

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

  • A testable consequence not run in the paper: if cosine-loss, absolute-top-$k$ sparsification is what drives the gains, then ablating to ReLU-and-top-$k$ or to $\ell_2$ reconstruction at constant sparsity should lower Recall@100 on a public embedding benchmark; without such an ablation, the attribution to direction preservation is an interpretation rather than a demonstrated mechanism.
  • Because the kernel mode uses $K = W_{\text{dec}}^{\top}W_{\text{dec}}$ and only sparse vectors, one could build an approximate search index over the sparse codes that computes $K$-weighted similarities, potentially recovering dense-space ranking without ever materializing dense vectors.
  • CompresSAE is orthogonal to quantization, so combining it with 4-bit storage could compound the memory reduction well beyond 12x, but this combination is not tested in the paper.
  • The A/B comparison measures downstream CTR through the full recommender pipeline; if the downstream ranker re-ranks differently for different candidate sets, the +1.52% figure may not isolate retrieval quality. A cleaner test would fix the ranker and candidate-set size while varying only the embedding compressor.
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 / 6 minor

Summary. The paper introduces CompresSAE, a sparse autoencoder that compresses dense embeddings into high-dimensional k-sparse vectors for candidate retrieval in large-scale recommender systems. The encoder maps a normalized dense embedding to a k-sparse latent vector, and a linear, row-normalized, bias-free decoder reconstructs the input; training minimizes cosine reconstruction loss, optionally with a multi-sparsity auxiliary term. The authors claim a 12x memory reduction over a 768-dimensional Nomic embedding with only a 1.35% CTR sacrifice, and report an online A/B test in which CompresSAE outperforms a same-size 64-dimensional Matryoshka variant by +1.52% CTR. They also describe a kernel-trick retrieval mode that computes similarities in the reconstructed space using the decoder Gram matrix with O(k^2) cost, and they release code. The main evidence is a proprietary offline experiment (Figure 3) and a large online A/B test (Figures 1 and 3, right).

Significance. If the claims hold, CompresSAE is a practically useful post-hoc compression method: it requires no retraining of the backbone encoder, is applicable to any pretrained embedding model, and reduces memory by an order of magnitude with a small measured CTR penalty. The paper's strengths include a released implementation, an online experiment with roughly 8.5 million users per variant, and a clean algebraic observation that reconstructed-space similarity can be computed from sparse codes via a precomputed kernel matrix. The method is also clearly positioned against Matryoshka-style truncation. However, the significance of the central quantitative claims depends on experimental details that are currently missing: the offline recall protocol is underspecified and lacks error bars, and the online A/B test does not report enough information to rule out downstream-ranker confounding. The paper is therefore potentially valuable, but the evidence as written is not yet sufficient to support the strongest statements.

major comments (4)
  1. [Section 4, Online Experiment (Figure 1, Figure 3 right)] The online A/B test is the load-bearing evidence for the +1.52% CTR claim and the 1.35% CTR sacrifice claim, but the protocol is not described. The paper does not state how users were randomized or whether the user was the randomization unit, how CTR was aggregated and over what time window, whether candidate-set size was equal across variants, or whether the downstream ranker was retrained or held fixed for each retrieval variant. If the ranker was trained on candidates from one retrieval distribution and then evaluated on candidates from another, the observed CTR differences could reflect ranker miscalibration rather than retrieval quality. Please report the full protocol, including confidence intervals for the treatment effects, and either control the candidate-set size or explicitly analyze how candidate-set composition interacts with the ranker.
  2. [Section 3, Eq. (3) vs. Section 4] There is a mismatch between the training objective and the retrieval mode used in the online A/B test. The loss in Eq. (3) aligns the input x with the reconstructed vector x_hat = W_dec s, i.e., it optimizes cosine similarity in the reconstructed space. However, Section 4 states that the online experiment computes similarity 'directly in the sparse compressed space', i.e., with dot products between sparse codes s, not between reconstructions. These two similarities are equal only if the decoder Gram matrix K = W_dec^T W_dec is the identity (or if the sparse codes are suitably orthogonalized), which is not established. The paper itself shows in Figure 3 (center) that the reconstructed-space retrieval is the better mode, which suggests the direct sparse-space mode is not theoretically aligned with the training objective. The authors should either provide a theoretical justification relating the sparse-code dot product to the cosine loss, or report the online and offline results separately for direct sparse retrieval and reconstructed-space retrieval.
  3. [Section 4, Offline Experiments (Figure 3 center)] The central offline claim that 'CompresSAE can match the performance of Matryoshka models up to four times larger' is not verifiable in its current form. The figure reports Recall@100 on a proprietary dataset, but the paper does not describe the ground-truth definition, the candidate pool size, the query set, the split, or the number of evaluation items, and no error bars or repeated-run statistics are provided. The reader cannot tell whether the apparent advantage at high compression ratios is within noise. Please specify the evaluation protocol, report variability across runs or seeds, and state how the proprietary dataset is constructed.
  4. [Section 4, Online Experiment (Figure 1)] The claim of statistical significance for the +1.52% effect is mentioned only in the text, and the confidence intervals in Figure 1 are said to be 'anytime-valid 99% confidence intervals' but are not defined or tabulated. The paper should state the exact interval for the comparison against Matryoshka of the same size and clarify the multiple-testing or sequential-testing procedure used, since anytime-valid intervals can depend on stopping rules.
minor comments (6)
  1. [Section 3.1] The notation in Eq. (3) is slightly malformed; the loss should be written as a function of x and f(x; theta, k) with proper parentheses, e.g., L_cosine(x, f(x; theta, k)).
  2. [Section 3.2] There is a typo in 'PostgresSQL'; the correct project name is 'PostgreSQL'.
  3. [Figure 3 (center)] The center panel is difficult to read: the x-axis 'Compression factor' is not labeled as logarithmic, and the mapping between the k values and the 'd=' annotations is unclear. Please add axis labels, a legend, and error bars or shaded bands.
  4. [Section 3] The paper does not discuss how the hyperparameters h, k, and the loss-combination weights were chosen. A short sensitivity study or a statement of the default values and their selection procedure would improve reproducibility.
  5. [Section 4] The phrase 'statistically significantly outperforms Matryoshka of the same size by +1.52%' should be accompanied by the corresponding confidence interval in the same sentence, rather than only in a figure.
  6. [Section 1] The claim that SBERT is '8x larger' than the Nomic variant is based on dimensions (512 vs 64) but the comparison is between different embedding models; a brief clarification that this is a dimensionality comparison and not a model-parameter comparison would avoid confusion.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the core derivation is a trained alignment plus an algebraic kernel identity, benchmarked against external baselines.

full rationale

The paper's central derivation is not circular. CompresSAE is trained to minimize the cosine distance between input embeddings and their reconstructions (Eq. 3); the claim that reconstructed-space similarity approximates original-space similarity is therefore a direct consequence of the training objective, not an assumption smuggled in as a prediction. The kernel trick in Section 3.2 is an algebraic identity: (W_dec s_x)^T (W_dec s_y) = s_x^T (W_dec^T W_dec) s_y, so no hidden equivalence between input and output is being asserted by construction. The method is compared against external baselines (SBERT, Nomic, Matryoshka), and the sparse-embedding storage calculation (768 float32 values vs. 32 nonzero values plus 32 indices) is arithmetic. No load-bearing argument reduces to a self-citation: the cited SAE works ([5], [21]) are by other authors and are used only as prior art, not as justification for the present results. The online A/B test and offline Recall@100 protocol are underspecified and may present correctness or external-validity risks, but those are not circularity concerns under the stated criteria. No fitted parameter is renamed as a prediction, and no uniqueness theorem or ansatz is imported from the authors' own prior work.

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

No new physical or conceptual entities are introduced. The method relies on standard matrix operations. The key ingredients are hyperparameters (sparsity k, hidden dimension h) and domain assumptions about cosine retrieval and the sufficiency of sparse projections. The online A/B test adds empirical grounding, but the proprietary data limits independent validation.

free parameters (3)
  • sparsity k = 32 (also 8, 16, 64, 128, 256 in sweeps)
    Number of nonzero entries in the compressed embedding; controls memory vs quality trade-off, chosen by the authors in experiments.
  • hidden dimension h = 4096 (main experiment)
    Dimension of the sparse latent space; chosen to provide sufficient capacity, with memory cost dominated by k, not h.
  • loss combination weights = unspecified
    The final loss combines cosine losses at k and 4k; the weighting is not stated, so it is an implicit free parameter.
assumptions (3)
  • domain assumption Cosine similarity is the appropriate retrieval metric for the embeddings used.
    The entire method and loss are built on cosine distance, which is standard for retrieval but not universal; if the downstream task used Euclidean distance or a learned metric, the compression might not transfer.
  • domain assumption A fixed k-sparse projection retains enough information from the dense embedding to support retrieval.
    This is the central empirical bet of the method; it is validated only on one dataset and one encoder (Nomic).
  • domain assumption The pretrained embeddings are fixed and high quality; the SAE does not need to adjust for encoder-specific artifacts.
    CompresSAE operates post-hoc on the encoder outputs and cannot fix errors in the original embeddings.

how reviews work

0 comments
Cite this review

Pith. "Pith review of The Future is Sparse: Embedding Compression for Scalable Retrieval in Recommender Systems." pith.science (2026). https://pith.science/paper/EEMSR24O

@misc{pith2026250511388,
  author       = {Pith},
  title        = {Pith review of: The Future is Sparse: Embedding Compression for Scalable Retrieval in Recommender Systems},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/EEMSR24O}},
  note         = {Machine review of arXiv:2505.11388}
}
read the original abstract

Industry-scale recommender systems face a core challenge: representing entities with high cardinality, such as users or items, using dense embeddings that must be accessible during both training and inference. However, as embedding sizes grow, memory constraints make storage and access increasingly difficult. We describe a lightweight, learnable embedding compression technique that projects dense embeddings into a high-dimensional, sparsely activated space. Designed for retrieval tasks, our method reduces memory requirements while preserving retrieval performance, enabling scalable deployment under strict resource constraints. Our results demonstrate that leveraging sparsity is a promising approach for improving the efficiency of large-scale recommenders. We release our code at https://github.com/recombee/CompresSAE.

Figures

Figures reproduced from arXiv: 2505.11388 by the authors.

Figure 1
Figure 1. Comparison of embedding models used for can [PITH_FULL_IMAGE:figures/full_fig_p001_1.png] view at source ↗
Figure 2
Figure 2. Left: Training. Right: Two modes of inference [PITH_FULL_IMAGE:figures/full_fig_p002_2.png] view at source ↗
Figure 3
Figure 3. Left: Training convergence. Center: Accuracy–compression trade-off. Right: A/B test results (baseline: [PITH_FULL_IMAGE:figures/full_fig_p003_3.png] view at source ↗

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

27 extracted references · 7 canonical work pages

  1. [1]

    Trenton Bricken, Adly Templeton, Joshua Batson, Brian Chen, Adam Jermyn, Tom Conerly, Nick Turner, Cem Anil, Carson Denison, Amanda Askell, et al

  2. [2]

    Paul Covington, Jay Adams, and Emre Sargin. 2016. Deep Neural Networks for YouTube Recommendations. In Proceedings of the 10th ACM Conference on Recommender Systems (Boston, Massachusetts, USA) (RecSys ’16). Association for Computing Machinery, New York, NY, USA, 191–198. doi:10.1145/2959100. 2959190

    doi:10.1145/2959100 2016

  3. [3]

    Hoagy Cunningham, Aidan Ewart, Logan Riggs, Robert Huben, and Lee Sharkey

  4. [4]

    S. C. Eisenstat, M. C. Gursky, M. H. Schultz, and A. H. Sherman. 1982. Yale sparse matrix package I: The symmetric codes. Internat. J. Nu- mer. Methods Engrg. 18, 8 (1982), 1145–1151. doi:10.1002/nme.1620180804 arXiv:https://onlinelibrary.wiley.com/doi/pdf/10.1002/nme.1620180804

    work page doi:10.1002/nme.1620180804 1982

  5. [5]

    arXiv:2309.08600 [cs.LG] https://arxiv.org/abs/2309.08600

    Sparse Autoencoders Find Highly Interpretable Features in Language Models. arXiv:2309.08600 [cs.LG] https://arxiv.org/abs/2309.08600

    arXiv

  6. [6]

    Hui Guan, Andrey Malevich, Jiyan Yang, Jongsoo Park, and Hector Yuen. 2019. Post-Training 4-bit Quantization on Embedding Tables. CoRR abs/1911.02079 (2019). http://arxiv.org/abs/1911.02079

    arXiv 2019

  7. [7]

    Leo Gao, Tom Dupré la Tour, Henk Tillman, Gabriel Goh, Rajan Troll, Alec Radford, Ilya Sutskever, Jan Leike, and Jeffrey Wu. 2024. Scaling and evaluating sparse autoencoders. arXiv:2406.04093 [cs.LG] https://arxiv.org/abs/2406.04093

    arXiv 2024

  8. [8]

    Aditya Kusupati, Gantavya Bhatt, Aniket Rege, Matthew Wallingford, Aditya Sinha, Vivek Ramanujan, William Howard-Snyder, Kaifeng Chen, Sham Kakade, Prateek Jain, and Ali Farhadi. 2024. Matryoshka Representation Learning. arXiv:2205.13147 [cs.LG] https://arxiv.org/abs/2205.13147

    arXiv 2024

Show all 27 references
  1. [9]

    Kingma and Jimmy Ba

    Diederik P. Kingma and Jimmy Ba. 2017. Adam: A Method for Stochastic Opti- mization. arXiv:1412.6980 [cs.LG] https://arxiv.org/abs/1412.6980

    2017 arXiv

  2. [10]

    Shiwei Li, Huifeng Guo, Xing Tang, Ruiming Tang, Lu Hou, Ruixuan Li, and Rui Zhang. 2024. Embedding compression in recommender systems: A survey. Comput. Surveys 56, 5 (2024), 1–21

    2024

  3. [11]

    Shiwei Li, Huifeng Guo, Lu Hou, Wei Zhang, Xing Tang, Ruiming Tang, Rui Zhang, and Ruixuan Li. 2023. Adaptive low-precision training for embeddings in click-through rate prediction. In Proceedings of the AAAI Conference on Artificial Intelligence, Vol. 37. 4435–4443

    2023

  4. [12]

    Alireza Makhzani and Brendan Frey. 2014. k-Sparse Autoencoders. arXiv:1312.5663 [cs.LG] https://arxiv.org/abs/1312.5663

    2014 arXiv

  5. [13]

    Zhuoran Liu, Leqi Zou, Xuan Zou, Caihua Wang, Biao Zhang, Da Tang, Bolin Zhu, Yijie Zhu, Peng Wu, Ke Wang, et al. 2022. Monolith: real time recommendation system with collisionless embedding table.arXiv preprint arXiv:2209.07663 (2022)

    2022 arXiv

  6. [14]

    Morris, Brandon Duderstadt, and Andriy Mulyar

    Zach Nussbaum, John X. Morris, Brandon Duderstadt, and Andriy Mulyar

  7. [15]

    Malkov and D

    Yu A. Malkov and D. A. Yashunin. 2020. Efficient and Robust Approximate Nearest Neighbor Search Using Hierarchical Navigable Small World Graphs. IEEE Transactions on Pattern Analysis and Machine Intelligence 42, 4 (2020), 824–

    2020

  8. [16]

    Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, Alban Des- maison, Andreas Kopf, Edward Yang, Zachary DeVito, Martin Raison, Alykhan Tejani, Sasank Chilamkurthy, Benoit Steiner, L...

    2019

  9. [17]

    Vikas Raunak, Vivek Gupta, and Florian Metze. 2019. Effective dimensionality reduction for word embeddings. In Proceedings of the 4th Workshop on Represen- tation Learning for NLP (RepL4NLP-2019) . 235–243

    2019

  10. [18]

    Nils Reimers and Iryna Gurevych. 2019. Sentence-BERT: Sentence Embeddings using Siamese BERT-Networks. In Proceedings of the 2019 Conference on Em- pirical Methods in Natural Language Processing . Association for Computational Linguistics. http://arxiv.org/abs/1908.10084

    2019 arXiv

  11. [19]

    Intaik Park, Ehsan Ardestani, Damian Reeves, Sarunya Pumma, Henry Tsang, Levy Zhao, Jian He, Joshua Deng, Dennis Van der Staay, Yu Guo, and Paul Zhang

  12. [20]

    In Proceedings of the 18th ACM Conference on Recommender Systems (Bari, Italy) (RecSys ’24)

    Toward 100TB Recommendation Models with Embedding Offloading. In Proceedings of the 18th ACM Conference on Recommender Systems (Bari, Italy) (RecSys ’24). Association for Computing Machinery, New York, NY, USA, 841–843. doi:10.1145/3640457.3688037

  13. [21]

    Tiansheng Wen, Yifei Wang, Zequn Zeng, Zhong Peng, Yudi Su, Xinyang Liu, Bo Chen, Hongwei Liu, Stefanie Jegelka, and Chenyu You. 2025. Beyond Matryoshka: Revisiting Sparse Coding for Adaptive Representation. arXiv:2503.01776 [cs.LG] https://arxiv.org/abs/2503.01776

    2025 arXiv

  14. [24]

    Adly Templeton, Tom Conerly, Jonathan Marcus, Jack Lindsey, Trenton Bricken, Brian Chen, Adam Pearce, Craig Citro, Emmanuel Ameisen, Andy Jones, et al

  15. [25]

    Transformer Circuits Thread

    Scaling monosemanticity: Extracting interpretable features from claude 3 sonnet. Transformer Circuits Thread

  16. [26]

    Oliphant, Matt Haberland, Tyler Reddy, David Cournapeau, Evgeni Burovski, Pearu Peterson, Warren Weckesser, Jonathan Bright, Stéfan J

    Pauli Virtanen, Ralf Gommers, Travis E. Oliphant, Matt Haberland, Tyler Reddy, David Cournapeau, Evgeni Burovski, Pearu Peterson, Warren Weckesser, Jonathan Bright, Stéfan J. van der Walt, Matthew Brett, Joshua Wilson, K. Jar- rod Millman, Nikolay Mayorov, Andrew R. J. Nelson,...

    2020

  17. [836]

    doi:10.1109/TPAMI.2018.2889473

    2018

  18. [2023]

    Transformer Circuits Thread 2 (2023)

    Towards monosemanticity: Decomposing language models with dictionary learning. Transformer Circuits Thread 2 (2023)

    2023

  19. [2024]

    arXiv:2402.01613 [cs.CL]

    Nomic Embed: Training a Reproducible Long Context Text Embedder. arXiv:2402.01613 [cs.CL]

    arXiv

Pith tools

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