Pith. sign in

REVIEW 4 major objections 5 minor 53 references

Stack Trace-Based Crash Deduplication with Transformer Adaptation

T0 review · 4 major / 5 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 A stack-trace-tuned transformer ranks duplicate crash reports up to 9% better than the best alignment method.

desk verdict The core idea is sensible and the empirical study is broad, but preprocessing hyperparameters appear to be selected on the test split, making the reported margins optimistic. read the letter →

arxiv 2508.19449 v1 pith:ZZLU5FFU submitted 2025-08-26 cs.SE cs.LG

Md Afif Al Mamun , Gias Uddin , Lan Xia , Longyu Zhang This is my paper · ORCID
classification cs.SEcs.LG
keywords crashdeduplicationstacktracetransformeradaptationcontrastivelearningMeanReciprocalRankreporttriagepretrainedlanguagemodelduplicatereports
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

Automated crash reporting systems generate many duplicate reports, and deduplicating them from stack traces is a ranking problem: for each new report, list the already-known reports most likely to be the same crash. The paper proposes dedupT, a transformer-based pipeline that treats a stack trace as one contextual passage rather than a set of isolated frames. It fine-tunes a pretrained sentence-embedding model on stack traces with a contrastive loss, then trains a small fully-connected network to rank duplicate reports. On four public datasets (Netbeans, Eclipse, Gnome, Ubuntu) dedupT reports higher Mean Reciprocal Rank than all ten baselines—often over 15% higher than the best deep-learning baseline and up to 9% higher than traditional methods—and higher ROC-AUC for spotting reports with no known duplicate. If that holds, crash triage could become more accurate while relying only on stack traces.

What carries the argument

The load-bearing mechanism is the adapted embedding model: a pretrained sentence-transformer embedding model (a model that maps text to a fixed vector; the default is bge-base) fine-tuned on stack-trace pairs with Multiple Negatives Ranking Loss, a contrastive objective that pulls duplicate traces together and pushes non-duplicates apart. Around this core, dedupT stacks three further components: a preprocessor that removes duplicate frames, keeps the top ten frames, and adds positional coding; a parametric max-mean aggregation that combines the most similar stack-trace pair's embeddings with the mean embedding of all traces in a report, weighted by a learnable parameter; and a two-layer fully-connected classifier, trained with RankNet loss, that consumes the difference, mean, and element-wise product of the two report embeddings and outputs a duplication score.

What would settle it

A reader could rerun dedupT and the strongest baselines (Tracesim and PDM) on several chronological splits of the four datasets, especially Ubuntu, and compare MRR with confidence intervals. If on a split outside the reported ones dedupT no longer beats Tracesim—the reported Ubuntu margin of 0.034 is smaller than the paper's own split-to-split spread of 0.077—the ranking advantage would not be confirmed.

Watch

Extended reading notes

Core claim

dedupT's central claim is that stack traces should be embedded as whole, ordered passages, with positional coding and contrastive fine-tuning, rather than analyzed frame-by-frame or subframe-by-subframe as in LSTM-based predecessors. The paper argues that a pretrained language model fine-tuned on stack-trace pairs learns an embedding space in which duplicate traces sit closer together even when exact frame alignment fails, and that combining the best-matching stack trace with the mean of all traces in a report gives a better report-level representation than either alone. The result is a duplication score from a two-layer fully-connected network trained with RankNet loss. Across the four datasets, dedupT reports the highest MRR and RR@k of all methods compared, and ROC-AUC above alignment and information-retrieval baselines; DeepCrash has a higher ROC-AUC on Gnome, but a much lower RR@1, so the paper argues the practical ranking advantage remains with dedupT.

Load-bearing premise

The headline comparisons assume the single chronological train/validation/test split chosen per dataset is representative of how crash reports arrive; the paper's own sensitivity table shows Ubuntu MRR varying from 0.761 to 0.838 across splits, a spread larger than dedupT's reported 0.786-versus-0.752 margin over the closest baseline on that dataset.

Editorial extensions

If this is right

  • Stack-trace-only deduplication can be built from an open, fine-tunable embedding model plus a small classifier, avoiding the hours of per-project hyperparameter tuning that alignment methods require; the paper notes TraceSim tuning alone took over 12 hours on Netbeans.
  • Which pretrained model is chosen matters less than the stack-trace fine-tuning itself, so teams can swap in whatever sentence-embedding model fits their deployment constraints.
  • Multi-stack reports are handled without concatenating traces: parametric max-mean pooling outperforms max pooling, mean pooling, and multi-head attention in the paper's ablation on Netbeans and Eclipse.
  • The same pipeline also flags unique crashes, with ROC-AUC above all alignment and information-retrieval baselines and competitive with LSTM models, though the paper notes DeepCrash has higher ROC-AUC on Gnome but far lower RR@1.
  • Embeddings can be precomputed and cached, so inference stays cheap enough for live triage even before approximate-nearest-neighbor indexing is added.

Reading between the lines

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

  • Beyond the four datasets, the same adaptation recipe should transfer to other statically typed languages and to reports that mix stack traces with logs, because only the frame-cleaning stage is language-specific; the paper does not test this.
  • The reported latency gap between dedupT (~2s per query) and the LLM reranking pipeline (~30s) suggests the most practical division of labor is dedupT for first-stage retrieval followed by an LLM on only the top candidates; the paper lists this as future work, not a demonstrated result.
  • The Ubuntu result—the largest adaptation gain on the dataset with the most specialized naming conventions—implies the method's advantage may grow as traces move further from natural-language vocabulary; that is a testable prediction, not a claim the paper makes.
  • ROC-AUC and RR@1 can disagree, as the Gnome DeepCrash numbers show; a fair deployment comparison should fix the target operating point (top-1 vs top-10 ranking) before choosing a model.
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 / 5 minor

Summary. This paper proposes dedupT, a transformer-based pipeline for stack-trace crash deduplication. It preprocesses stack traces by removing consecutive duplicate frames, retaining a top-N frame budget, cleaning language-specific syntax, and adding positional coding. It then fine-tunes a pretrained sentence embedding model (bge-base) with a multiple-negatives ranking loss on positive/negative stack-trace pairs sampled from training buckets, and aggregates multiple stack traces per report using a parametric max-mean combination. A fully connected network trained with RankNet loss scores candidate reports. The evaluation compares dedupT against ten baselines (PDM/Rebucket, Tracesim, DURFEX, Moroo, PrefixMatching, Brodie, Needleman-Wunsch, TF-IDF, S3M, DeepCrash) on Netbeans, Eclipse, Gnome, and Ubuntu, reporting MRR, RR@k, and ROC-AUC, plus ablation and sensitivity analyses. The central claim is that dedupT improves MRR by over 9% over the best IR baseline and over 15% over the best DL baseline and achieves higher ROC-AUC on unique-crash detection.

Significance. Should the reported gains hold under a clean evaluation protocol, the paper makes a useful contribution: it demonstrates that domain-adapted transformer embeddings improve duplicate-crash ranking over both lexical/alignment methods and prior LSTM-based models on four public datasets. The work is careful in several respects: it uses multiple real-world datasets, includes ten baselines, reports ablations for frame count, trimming level, aggregation method, and embedding model choice, and provides a split-sensitivity analysis. These elements are valuable. The main reservations are methodological: the headline numbers appear to reflect preprocessing hyperparameters chosen on the test split, the main comparison is a single chronological split without confidence intervals or significance tests, and the split-sensitivity analysis shows variance on Ubuntu that is comparable to the reported margin over the best baseline. These issues must be addressed before the claimed advantage is established.

major comments (4)
  1. [Section VI-D, Tables II and IX, Figure 8] The selection of the frame budget N and the Java trimming level appears to be made on the test split. Section IV-A says N is 'determined empirically' and Figure 8 reports MRR for N=10, 15, and 20; Table IX reports MRR for trimming levels L0/L1/L2. The Table II entries for dedupT match the per-dataset best of these choices (Netbeans L0: MRR 0.771; Eclipse L2: MRR 0.791). The paper does not state that these choices were locked using only the training or validation split before test labels were inspected. If these ablations were computed on the same test split, dedupT's reported margins over baselines (which receive no equivalent per-split tuning) are inflated by test-set fitting. Please rerun the pipeline with N and the trimming level selected on the validation split, or clearly document a separate model-selection split, and report the resulting Table II numbers.
  2. [Section V-B and Table III] The headline comparison rests on a single chronological split per dataset. Table III's sensitivity analysis shows that on Ubuntu, dedupT's MRR ranges from 0.761 to 0.838 (SD 0.032) across three splits, a spread larger than the 0.034 MRR margin over Tracesim on the chosen split (0.786 vs 0.752). Without confidence intervals or significance tests across multiple splits, the reported ranking advantages may not be robust. Please report results across the three splits for dedupT and at least the top baselines, or provide bootstrap confidence intervals for the Table II comparisons.
  3. [Section IV-B] Negative pairs for embedding-model adaptation are constructed by sampling from 'a random subset of stack traces drawn from the top 50 buckets identified by Lerch and Mezini [22]'. It is unclear whether this bucket list was derived from the full datasets including the test period. If so, the fine-tuning of the embedding model (and the classifier negative sampling) could leak test information. Please clarify the provenance of this list and, if needed, restrict it to training-period data.
  4. [Section V-A] DeepCrash was reimplemented because no public code was available and then modified for ranking; small implementation differences can change relative performance. Please provide the reimplementation and a validation that it reproduces the published behavior on the original clustering task, or make the code available. This is needed to trust the DL comparisons in Table II.
minor comments (5)
  1. [Section VI-D] There is a typo in the stack-frame-selection paragraph: 'Exceeding this may limit may result in incomplete frame' should be 'Exceeding this limit may result in an incomplete frame'. Also, the RQ3 heading contains 'perfoms' instead of 'performs'.
  2. [Equation 4] The symbol '∥' is used for concatenation in Equation 4 but is not defined; please define it explicitly as the concatenation operator.
  3. [Section V-C] The embedding-quality evaluation reports Pearson, Spearman, and Euclidean similarities, but the text does not state which split (training, validation, or test) these correlation values are computed on; please clarify.
  4. [Table X] The comparison with LLM-based pipelines uses the full test set for Ubuntu but only 200 samples for NetBeans; this makes the cross-dataset comparison difficult to interpret. Please state the sample-size limitation explicitly and consider reporting standard errors for the smaller sample.
  5. [Section VI-A, Table II] The main comparison table does not report standard deviations or significance tests for any method. Since the sensitivity analysis shows non-negligible variance on Ubuntu, adding at least bootstrap confidence intervals for the key rows would substantially strengthen the claims.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: dedupT is a supervised empirical benchmark with held-out test splits; the reported MRR/ROC-AUC are measured, not derived from the model's own training labels.

full rationale

The paper's central claim is an empirical comparison against ten baselines on four public datasets. The embedding model is fine-tuned with a contrastive loss and the duplicate classifier is trained with RankNet loss using only the training split (Section IV-B: 'This whole adaptation process only use data from the training split'; Section IV-D describes classifier training on triplets). Test splits are held out chronologically (Section V-B), and metrics MRR, RR@k, and ROC-AUC are computed on those held-out queries. No load-bearing result is defined into existence: the fine-tuned embeddings are not constructed from the evaluation labels, and the classifier output is not an algebraic restatement of the input similarities. The possible concerns raised in the review—preprocessing hyperparameters (top-N frames, trimming level) whose selection split is not explicitly stated, and the unstated provenance of the external top-50 bucket list used for negative sampling—are threats to benchmark validity or reproducibility, not circularity. There is no self-definitional fit, no fitted parameter renamed as a prediction, no load-bearing self-citation chain, and no uniqueness theorem imported from the authors' prior work. Under the hard rule that circularity must be shown by an explicit reduction of Eq. X to Eq. Y or a fitted input masquerading as a prediction, none is present; therefore the appropriate finding is no significant circularity.

Assumptions & free parameters 2 free parameters · 4 assumptions · 0 invented entities

The method is a supervised pipeline. The free parameters are the frame count N and the aggregation weight alpha. The main axioms are dataset label reliability, split representativeness, the validity of the external top-50 bucket list, and the transferability of fine-tuned embeddings. No new entities are postulated.

free parameters (2)
  • Number of top frames N = 10 (reported as best in Figure 8)
    Selected empirically by measuring embedding similarity and MRR at 10, 15, and 20 frames (Sections IV-A and VI-D). If this selection used test labels, the reported gains are partly selected.
  • Parametric max-mean weight alpha = learned during classifier training (value not reported)
    Introduced in Equation 4 to balance the most-similar pair against the mean-pooled embedding for multi-stack reports; trained on the validation split.
assumptions (4)
  • domain assumption Bucket labels from human triage are correct and complete ground truth for duplicate and non-duplicate relationships.
    All supervised training and all metrics use the buckets described in Section V-B. Label noise would bias both the contrastive fine-tuning and the evaluation.
  • domain assumption Time-based splits prevent leakage and are representative of deployment conditions.
    Section V-B defines splits. If reports near the boundary are mislabeled or if the split is not representative, the Table II margins may not hold.
  • domain assumption The top-50 bucket list from Lerch and Mezini, used to sample negatives, can be applied without leaking test-period information.
    Section IV-B says negative pairs are sampled from this external list. Its provenance is not described in this paper, so it is not verifiable that the list is free of test-period information.
  • domain assumption Pretrained sentence embeddings, after contrastive fine-tuning on stack traces, capture the structural and semantic information needed for deduplication.
    The entire approach rests on this transfer. Section III-B argues for it, but there is no formal guarantee.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Stack Trace-Based Crash Deduplication with Transformer Adaptation." pith.science (2026). https://pith.science/paper/ZZLU5FFU

@misc{pith2026250819449,
  author       = {Pith},
  title        = {Pith review of: Stack Trace-Based Crash Deduplication with Transformer Adaptation},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/ZZLU5FFU}},
  note         = {Machine review of arXiv:2508.19449}
}
read the original abstract

Automated crash reporting systems generate large volumes of duplicate reports, overwhelming issue-tracking systems and increasing developer workload. Traditional stack trace-based deduplication methods, relying on string similarity, rule-based heuristics, or deep learning (DL) models, often fail to capture the contextual and structural relationships within stack traces. We propose dedupT, a transformer-based approach that models stack traces holistically rather than as isolated frames. dedupT first adapts a pretrained language model (PLM) to stack traces, then uses its embeddings to train a fully-connected network (FCN) to rank duplicate crashes effectively. Extensive experiments on real-world datasets show that dedupT outperforms existing DL and traditional methods (e.g., sequence alignment and information retrieval techniques) in both duplicate ranking and unique crash detection, significantly reducing manual triage effort. On four public datasets, dedupT improves Mean Reciprocal Rank (MRR) often by over 15% compared to the best DL baseline and up to 9% over traditional methods while achieving higher Receiver Operating Characteristic Area Under the Curve (ROC-AUC) in detecting unique crash reports. Our work advances the integration of modern natural language processing (NLP) techniques into software engineering, providing an effective solution for stack trace-based crash deduplication.

Figures

Figures reproduced from arXiv: 2508.19449 by the authors.

Figure 1
Figure 1. Example of a Java stack trace. 1 #0 0x40990b in crash_func() at example.c:6 2 #1 0x40250a in inter_function() at example.c:10 3 #2 0x40150a in main() at example.c:15 [PITH_FULL_IMAGE:figures/full_fig_p001_1.png] view at source ↗
Figure 3
Figure 3. Cosine similarity of stack trace embeddings between a [PITH_FULL_IMAGE:figures/full_fig_p002_3.png] view at source ↗
Figure 4
Figure 4. Cosine distance of stack trace pairs before and after [PITH_FULL_IMAGE:figures/full_fig_p003_4.png] view at source ↗
Figures from the paper (4 more)
Figure 5
Figure 5. Figure 5: Architecture diagram of dedupT. QTx, QEx represents x-th stack trace and its embedding from report Q. followed by a sequence of stack frames that represent method calls, each containing details such as the class name, method name, and line number. In contrast, C++ stac…
Figure 6
Figure 6. Figure 6: Stacktrace Preprocessor. Sampling Relevant Frames. Prior studies show that the top stack frames are most informative for debugging [7], whereas frames from standard libraries or deep recursion often add little value. Moreover, pretrained language models impose token le…
Figure 7
Figure 7. Figure 7: RR@k for fine-tuned models across datasets. [PITH_FULL_IMAGE:figures/full_fig_p009_7.png]
Figure 8
Figure 8. Figure 8: Pre-fine-tuning comparison of embedding similarity [PITH_FULL_IMAGE:figures/full_fig_p010_8.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

53 extracted references · 34 canonical work pages

  1. [22]

    Finding duplicates of your yet unwritten bug report,

    J. Lerch and M. Mezini, “Finding duplicates of your yet unwritten bug report,” in 2013 17th European Conference on Software Maintenance and Reengineering, 2013, pp. 69–78

    2013

  2. [1]

    The unreasonable effectiveness of traditional information retrieval in crash report dedupli- cation,

    J. C. Campbell, E. A. Santos, and A. Hindle, “The unreasonable effectiveness of traditional information retrieval in crash report dedupli- cation,” in Proceedings of the 13th International Conference on Mining Software Repositories, ser. MSR ’16. New York, NY , USA: Association for Computing Machinery, 2016, p. 269–280

    work page 2016

  3. [2]

    Tracesim: An alignment method for computing stack trace similarity,

    I. M. Rodrigues, A. Khvorov, D. Aloise, R. Vasiliev, D. Koznov, E. R. Fernandes, G. Chernishev, D. Luciv, and N. Povarov, “Tracesim: An alignment method for computing stack trace similarity,” Empirical Software Engineering, vol. 27, no. 2, p. 53, 2022

    work page 2022

  4. [3]

    Durfex: A feature extraction technique for efficient detection of duplicate bug reports,

    K. K. Sabor, A. Hamou-Lhadj, and A. Larsson, “Durfex: A feature extraction technique for efficient detection of duplicate bug reports,” 2017 IEEE International Conference on Software Quality, Reliability and Security (QRS) , pp. 240–250, 2017

    work page 2017

  5. [4]

    Quickly finding known software problems via automated symptom matching,

    M. Brodie, S. Ma, G. M. Lohman, L. Mignet, N. Modani, M. Wilding, J. Champlin, and P. Sohn, “Quickly finding known software problems via automated symptom matching,” in ICAC, 2005, pp. 101–110

    work page 2005

  6. [5]

    Classifying field crash reports for fixing bugs: A case study of mozilla firefox,

    T. Dhaliwal, F. Khomh, and Y . Zou, “Classifying field crash reports for fixing bugs: A case study of mozilla firefox,” in 2011 27th IEEE International Conference on Software Maintenance (ICSM) , 2011, pp. 333–342

    work page 2011

  7. [6]

    S3m: Siamese stack (trace) similarity mea- sure,

    A. Khvorov, R. Vasiliev, G. A. Chernishev, I. M. Rodrigues, D. V . Koznov, and N. Povarov, “S3m: Siamese stack (trace) similarity mea- sure,” 2021 IEEE/ACM 18th International Conference on Mining Soft- ware Repositories (MSR) , pp. 266–270, 2021

    work page 2021

  8. [7]

    Do stack traces help developers fix bugs?

    A. Schroter, A. Schr ¨oter, N. Bettenburg, and R. Premraj, “Do stack traces help developers fix bugs?” in 2010 7th IEEE Working Conference on Mining Software Repositories (MSR 2010) , 2010, pp. 118–121

    work page 2010

Show all 53 references
  1. [8]

    Boosting bug-report-oriented fault localization with segmentation and stack-trace analysis,

    C.-P. Wong, Y . Xiong, H. Zhang, D. Hao, L. Zhang, and H. Mei, “Boosting bug-report-oriented fault localization with segmentation and stack-trace analysis,” in 2014 IEEE international conference on software maintenance and evolution . IEEE, 2014, pp. 181–190. 12

    2014

  2. [9]

    Rebucket: A method for clustering duplicate crash reports based on call stack simi- larity,

    Y . Dang, R. Wu, H. Zhang, D. Zhang, and P. Nobel, “Rebucket: A method for clustering duplicate crash reports based on call stack simi- larity,” in 2012 34th International Conference on Software Engineering (ICSE). IEEE, 2012, pp. 1084–1093

    2012

  3. [10]

    Deep- crash: deep metric learning for crash bucketing based on stack trace,

    L. Chao, X. Qiaoluan, L. Yong, X. Yang, and C. Hyun-Deok, “Deep- crash: deep metric learning for crash bucketing based on stack trace,” in Proceedings of the 6th International Workshop on Machine Learning Techniques for Software Quality Evaluation , ser. MaLTeSQuE 2022. New Yo...

    2022

  4. [11]

    Attention is all you need,

    A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, Ł. Kaiser, and I. Polosukhin, “Attention is all you need,” Advances in neural information processing systems , vol. 30, 2017

    2017

  5. [12]

    BERT: Pre- training of deep bidirectional transformers for language understanding,

    J. Devlin, M.-W. Chang, K. Lee, and K. Toutanova, “BERT: Pre- training of deep bidirectional transformers for language understanding,” in Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technolog...

    2019

  6. [13]

    Roberta: A robustly optimized BERT pretraining approach,

    Y . Liu, M. Ott, N. Goyal, J. Du, M. Joshi, D. Chen, O. Levy, M. Lewis, L. Zettlemoyer, and V . Stoyanov, “Roberta: A robustly optimized BERT pretraining approach,” CoRR, vol. abs/1907.11692, 2019

    1907 arXiv

  7. [14]

    Deep contextualized word representations,

    M. E. Peters, M. Neumann, M. Iyyer, M. Gardner, C. Clark, K. Lee, and L. Zettlemoyer, “Deep contextualized word representations,” CoRR, vol. abs/1802.05365, 2018

    2018 arXiv

  8. [15]

    Deberta: Decoding-enhanced BERT with disentangled attention,

    P. He, X. Liu, J. Gao, and W. Chen, “Deberta: Decoding-enhanced BERT with disentangled attention,” CoRR, vol. abs/2006.03654, 2020

    2006 arXiv

  9. [16]

    Comprehensive review and comparative analysis of transformer models in sentiment analysis,

    H. Bashiri and H. Naderi, “Comprehensive review and comparative analysis of transformer models in sentiment analysis,” Knowledge and Information Systems, vol. 66, no. 12, pp. 7305–7361, 2024

    2024

  10. [17]

    Bertscore: Evaluating text generation with bert,

    T. Zhang, V . Kishore, F. Wu, K. Q. Weinberger, and Y . Artzi, “Bertscore: Evaluating text generation with bert,” ArXiv, vol. abs/1904.09675, 2019

    1904 arXiv

  11. [18]

    Pre-trained lan- guage models for text generation: A survey,

    J. Li, T. Tang, W. X. Zhao, J.-Y . Nie, and J.-R. Wen, “Pre-trained lan- guage models for text generation: A survey,” ACM Computing Surveys, vol. 56, no. 9, pp. 1–39, 2024

    2024

  12. [19]

    Sentence-bert: Sentence embeddings using siamese bert-networks,

    N. Reimers and I. Gurevych, “Sentence-bert: Sentence embeddings using siamese bert-networks,” in Conference on Empirical Methods in Natural Language Processing, 2019

    2019

  13. [20]

    Automatically identifying known software problems,

    N. Modani, R. Gupta, G. Lohman, T. Syeda-Mahmood, and L. Mignet, “Automatically identifying known software problems,” in 2007 IEEE 23rd International Conference on Data Engineering Workshop , 2007, pp. 433–441

    2007

  14. [21]

    Finding similar failures using callstack similarity,

    K. Bartz, J. W. Stokes, J. C. Platt, R. Kivett, D. Grant, S. Calinoiu, and G. Loihle, “Finding similar failures using callstack similarity,” in USENIX workshop on Tackling computer systems problems with machine learning techniques, 2008

    2008

  15. [23]

    Tracesim: a method for calculating stack trace similarity,

    R. Vasiliev, D. Koznov, G. Chernishev, A. Khvorov, D. Luciv, and N. Povarov, “Tracesim: a method for calculating stack trace similarity,” in Proceedings of the 4th ACM SIGSOFT International Workshop on Machine-Learning Techniques for Software-Quality Evaluation , ser. MaLTeSQu...

    2020

  16. [24]

    Fast: A linear time stack trace alignment heuristic for crash report deduplication,

    I. M. Rodrigues, D. Aloise, and E. R. Fernandes, “Fast: A linear time stack trace alignment heuristic for crash report deduplication,” in Proceedings of the 19th International Conference on Mining Software Repositories, 2022, pp. 549–560

    2022

  17. [25]

    Abaci-finder: Linux kernel crash classification through stack trace similarity learning,

    H. Shi, G. Wang, Y . Fu, C. Hu, H. Song, J. Dong, K. Tang, and K. Liang, “Abaci-finder: Linux kernel crash classification through stack trace similarity learning,” Journal of Parallel and Distributed Computing, vol. 168, pp. 70–79, 2022

    2022

  18. [26]

    Sentencepiece: A simple and language inde- pendent subword tokenizer and detokenizer for neural text processing,

    T. Kudo and J. Richardson, “Sentencepiece: A simple and language inde- pendent subword tokenizer and detokenizer for neural text processing,” arXiv preprint arXiv:1808.06226 , 2018

    2018 arXiv

  19. [27]

    A comparative study on transformer vs rnn in speech applications,

    S. Karita, N. Chen, T. Hayashi, T. Hori, H. Inaguma, Z. Jiang, M. Someki, N. E. Y . Soplin, R. Yamamoto, X. Wang et al. , “A comparative study on transformer vs rnn in speech applications,” in 2019 IEEE automatic speech recognition and understanding workshop (ASRU). IEEE, 2019...

    2019

  20. [28]

    A simple framework for contrastive learning of visual representations,

    T. Chen, S. Kornblith, M. Norouzi, and G. E. Hinton, “A simple framework for contrastive learning of visual representations,”CoRR, vol. abs/2002.05709, 2020

    2002 arXiv

  21. [29]

    Ms marco: A human generated machine reading comprehension dataset,

    P. Bajaj, D. Campos, N. Craswell, L. Deng, J. Gao, X. Liu, R. Majumder, A. McNamara, B. Mitra, T. Nguyen, M. Rosenberg, X. Song, A. Stoica, S. Tiwary, and T. Wang, “Ms marco: A human generated machine reading comprehension dataset,” 2018

    2018

  22. [30]

    Open Question Answering Over Curated and Extracted Knowledge Bases,

    A. Fader, L. Zettlemoyer, and O. Etzioni, “Open Question Answering Over Curated and Extracted Knowledge Bases,” in KDD, 2014

    2014

  23. [31]

    Efficient natural language response suggestion for smart reply,

    M. Henderson, R. Al-Rfou, B. Strope, Y . hsuan Sung, L. Lukacs, R. Guo, S. Kumar, B. Miklos, and R. Kurzweil, “Efficient natural language response suggestion for smart reply,” 2017

    2017

  24. [32]

    Detecting duplicate questions with deep learning,

    Y . Homma and C. Yeh, “Detecting duplicate questions with deep learning,” 2017

    2017

  25. [33]

    Dropout: a simple way to prevent neural networks from over- fitting,

    N. Srivastava, G. Hinton, A. Krizhevsky, I. Sutskever, and R. Salakhut- dinov, “Dropout: a simple way to prevent neural networks from over- fitting,” The journal of machine learning research , vol. 15, no. 1, pp. 1929–1958, 2014

    1929

  26. [34]

    Learning to rank using gradient descent,

    C. Burges, T. Shaked, E. Renshaw, A. Lazier, M. Deeds, N. Hamilton, and G. Hullender, “Learning to rank using gradient descent,” in Proceed- ings of the 22nd international conference on Machine learning , 2005, pp. 89–96

    2005

  27. [35]

    Adam: A method for stochastic optimization,

    D. P. Kingma and J. Ba, “Adam: A method for stochastic optimization,” CoRR, vol. abs/1412.6980, 2014

    2014 arXiv

  28. [36]

    Reranking-based crash report deduplication

    A. Moroo, A. Aizawa, and T. Hamamoto, “Reranking-based crash report deduplication.” in SEKE, vol. 17, 2017, pp. 507–510

    2017

  29. [37]

    Duplicate bug report detection using dual-channel convolutional neural networks,

    J. He, L. Xu, M. Yan, X. Xia, and Y . Lei, “Duplicate bug report detection using dual-channel convolutional neural networks,” in Proceedings of the 28th International Conference on Program Comprehension , 2020, pp. 117–127

    2020

  30. [38]

    Hindbr: Heterogeneous information network based duplicate bug report prediction,

    G. Xiao, X. Du, Y . Sui, and T. Yue, “Hindbr: Heterogeneous information network based duplicate bug report prediction,” in 2020 IEEE 31st international symposium on software reliability engineering (ISSRE) . IEEE, 2020, pp. 195–206

    2020

  31. [39]

    A soft alignment model for bug deduplication,

    I. M. Rodrigues, D. Aloise, E. R. Fernandes, and M. Dagenais, “A soft alignment model for bug deduplication,” in Proceedings of the 17th International Conference on Mining Software Repositories , 2020, pp. 43–53

    2020

  32. [40]

    Towards more accurate retrieval of duplicate bug reports,

    C. Sun, D. Lo, S.-C. Khoo, and J. Jiang, “Towards more accurate retrieval of duplicate bug reports,” in2011 26th IEEE/ACM International Conference on Automated Software Engineering (ASE 2011) , 2011, pp. 253–262

    2011

  33. [41]

    Deeplsh: Deep locality-sensitive hash learning for fast and efficient near-duplicate crash report detection,

    Y . Remil, A. Bendimerad, R. Mathonat, C. Raissi, and M. Kaytoue, “Deeplsh: Deep locality-sensitive hash learning for fast and efficient near-duplicate crash report detection,” in Proceedings of the IEEE/ACM 46th International Conference on Software Engineering, 2024, pp. 1–12

    2024

  34. [42]

    Stack trace deduplication: Faster, more accurately, and in more realistic scenarios,

    E. Shibaev, D. Sushentsev, Y . Golubev, and A. Khvorov, “Stack trace deduplication: Faster, more accurately, and in more realistic scenarios,” arXiv preprint arXiv:2412.14802 , 2024

    2024 arXiv

  35. [43]

    Impact of word embedding models on text analytics in deep learning environment: a review,

    D. S. Asudani, N. K. Nagwani, and P. Singh, “Impact of word embedding models on text analytics in deep learning environment: a review,” Artif. Intell. Rev., vol. 56, no. 9, p. 10345–10425, Feb. 2023

    2023

  36. [44]

    all-mpnet-base-v2

    HuggingFace, “all-mpnet-base-v2.” [Online]. Available: https: //huggingface.co/sentence-transformers/all-mpnet-base-v2

  37. [45]

    distilroberta-v1

    ——, “distilroberta-v1.” [Online]. Available: https://huggingface.co/ sentence-transformers/all-distilroberta-v1

  38. [46]

    C- pack: Packed resources for general chinese embeddings,

    S. Xiao, Z. Liu, P. Zhang, N. Muennighoff, D. Lian, and J.-Y . Nie, “C- pack: Packed resources for general chinese embeddings,” in Proceedings of the 47th international ACM SIGIR conference on research and development in information retrieval , 2024, pp. 641–649

    2024

  39. [47]

    Revisiting the perfor- mance evaluation of automated approaches for the retrieval of duplicate issue reports,

    M. S. Rakha, C.-P. Bezemer, and A. E. Hassan, “Revisiting the perfor- mance evaluation of automated approaches for the retrieval of duplicate issue reports,” IEEE Transactions on Software Engineering , vol. 44, no. 12, pp. 1245–1268, 2018

    2018

  40. [48]

    text-embedding-3-small

    OpenAI, “text-embedding-3-small.” [Online]. Available: https: //platform.openai.com/docs/models/text-embedding-3-small

  41. [49]

    Codebert: A pre-trained model for programming and natural languages,

    Z. Feng, D. Guo, D. Tang, N. Duan, X. Feng, M. Gong, L. Shou, B. Qin, T. Liu, D. Jiang et al., “Codebert: A pre-trained model for programming and natural languages,” arXiv preprint arXiv:2002.08155 , 2020

    2002 arXiv

  42. [50]

    Large language models for information retrieval: A survey,

    Y . Zhu, H. Yuan, S. Wang, J. Liu, W. Liu, C. Deng, H. Chen, Z. Liu, Z. Dou, and J.-R. Wen, “Large language models for information retrieval: A survey,” arXiv preprint arXiv:2308.07107 , 2023

    2023

  43. [51]

    Chromadb

    ChromaDB, “Chromadb.” [Online]. Available: https://www.trychroma. com/

  44. [52]

    Approximate nearest neighbor search in high dimensions,

    A. Andoni, P. Indyk, and I. Razenshteyn, “Approximate nearest neighbor search in high dimensions,” 2018

    2018

  45. [53]

    The faiss library,

    M. Douze, A. Guzhva, C. Deng, J. Johnson, G. Szilvasy, P.-E. Mazar ´e, M. Lomeli, L. Hosseini, and H. J ´egou, “The faiss library,” 2024

    2024

Pith tools

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