acceptodds
Under review as a conference paper at ICLR 2027

End-to-End Subgraph Detection with GraphDETR

Abstract

Subgraph detection seeks to identify whether and where instances of given patterns occur within a larger graph. This problem is fundamental across scientific domains and is closely related to subgraph isomorphism, which is NP-complete, limiting combinatorial approaches to small patterns or moderately sized graphs. We introduce GraphDETR, a deep learning framework that formulates subgraph detection as a set prediction problem, analogous to DETR in object detection. GraphDETR encodes the target graph with a graph neural network, and employs a fixed set of learnable query vectors, decoded via a transformer decoder, to predict all pattern occurrences jointly in a single forward pass. This is enabled by training the model end-to-end with bipartite matching. Unlike traditional combinatorial methods that only solve exact structural matching, GraphDETR naturally extends to approximate matching, enabling detection beyond exact pattern correspondence. Empirically, we show that GraphDETR can detect diverse patterns, such as molecular structures, cycles, cliques, and fuzzy patterns of up to 50 nodes, in target graphs with up to 1000 nodes. We further evaluate on molecular functional group detection over the ChEMBL dataset, where GraphDETR predicts the complete set of functional groups per molecule, achieving a strong performance of .

Primary area:
learning on graphs and other geometries & topologies
Keywords:
subgraph detection, graph neural networks, random walk neural networks, set prediction

Reviews

Among:
Shape:
1234this paper, Top 15%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.00 over 2 reviews, above 85% of the others.
Reviewer_AwCbOpenReview ↗
Rating
3(+1)
Confidence
4
Informativeness
2
Presentation
2
Soundness
3(+1)
Read review
Paper summary

The paper proposes GraphDETR, which frames subgraph detection as a set prediction task. A variety of GNN encoders (GCN, GIN, GatedGCN, GraphGPS, and NeuralWalker) are tested to produce node embeddings. A DETR/SAM-style two-way transformer decoder with learnable queries then predicts (class, node-mask) pairs, and is trained with Hungarian matching and a graph-cut regularizer. Then there is an evaluation on molecular functional-group detection (ChEMBL, 95 classes) and on synthetic benchmarks (cactus, cliques, ZINC12k, Mol-Reddit), with a comparison against VF2 on runtime.

Critical strengths
  • The set-prediction formulation of subgraph detection is clear. The analogy to object detection is natural, and the pipeline is end-to-end with no NMS or combinatorial search at inference.
  • The evaluation is broad. They evaluate on a large scaffold-split ChEMBL dataset, several synthetic families, exact and fuzzy matching, 5 seeds for the main tables, and runtime measurements.
  • Subgraph detection is a useful test for comparing the expressivity of graph encoders. The finding that global or walk-based encoders outperform local MPNNs is informative.
  • The ablations (loss terms, decoder capacity, and NeuralWalker settings), the appendix details, and the limitations section are useful.
Critical weaknesses
  • The technical/methodological noveltyis limited. The model uses DETR plus the SAM two-way decoder plus off-the-shelf encoders. The only graph-specific component is the cut penalty, which is a standard graph-cut/total-variation-style regulariser.

  • Insufficient baselines. The encoder comparison (section 4.1) compares backbones only inside the framework of the authors, so it can't show the gain of the framework itself. As far as I saw, the only external learned baseline is NeuroMatch, which gets one paragraph in the main text and reaches under 1% AP100. Its adaptation is only described in Appendix D and adds several components that are not part of NeuroMatch (a canonical exemplar per class, calibrated thresholds, region growing for masks, and duplicate suppression). The authors mention these choices affect the result, so it is not clear to me whether the near-zero score reflects NeuroMatch or the pipeline built around it. For me, missing comparisons are:

    1. node-level tagging plus connected components, or instance embeddings plus clustering.
    2. a standard DETR or Mask2Former-style head without the two-way decoder.
    3. other neural subgraph matching and counting methods.
    4. for molecules, the rule-based detector that produced the labels (Peter Ertl's algorithm). It is exact by construction, so the relevant comparison is runtime, which is not reported.
  • The practical value for the main task is unclear. Functional-group detection in molecules is already well served by rule-based tools that are exact and fast. The motivating benefits (differentiability, retrosynthesis, and property prediction) are not tested/evaluated, and the paper does not say in which setting a learned detector would be well-suited.

  • Design claims that lack supporting experiments.

    1. "Using H_ref rather than the raw encoder output H is critical". Why is it critical? I cannot find results showing this.
    2. The two-way decoder is designed for overlapping instances, does a benchmark contain them?
    3. The symmetry-breaking argument for random walks is never shown with an experiment.
  • Tables 2–4 report no standard deviations and many conclusions rest on 1-2 point differences. NeuralWalker is also the only encoder with two λ_mask settings and has more parameters (7.4M versus 3.9 to 6.6M). There's no parameter-matched or equally tuned comparison.

  • The claim that GraphDETR is "the first model to jointly predict all instances of a fixed pattern set in a single differentiable forward pass" is strong. There are models like query-based instance segmentation on point clouds and substructure-counting GNNs that are close analogues and should be discussed. The closed vocabulary setting also limits applicability, since the pattern set must be fixed and a model retrained for each new one.

Questions for authors
  • How does GraphDETR compare to simple non-query-based alternatives built on the same encoders, namely node-level multi-label tagging with connected components, or instance embeddings with clustering? How does it compare to a standard one-way DETR decoder?
  • Can you ablate the use of H_ref versus the raw encoder output H in the mask head? Can you also report what fraction of instances overlap in each benchmark, with performance on graphs with and without overlaps? Finally, can the random-walk symmetry-breaking argument be tested directly, for example on molecules with automorphic nodes (such as CF3 groups), or by adding random node features to an MPNN?
  • On ChEMBL, in which setting would a learned detector be preferable to a rule-based functional-group detector, given that it is less exact? Can you show a downstream benefit (e.g. property prediction or retrosynthesis) or a case where rule-based labels are unavailable?
  • Can you report standard deviations for the ablation tables (Tables 2-4), and confirm that λ_mask and other hyperparameters were tuned equally for all encoders, ideally with a parameter-matched NeuralWalker vs. GraphGPS comparison?
5 comments

We thank the reviewer for the detailed review and address each point below.

Limited methodological novelty and the broad “first model” claim.

We agree that GraphDETR builds on several established components, and we do not claim novelty for these components individually. We believe, however, that our work should not be judged only by the novelty of its components, but by the problem it solves. Finding all occurrences of given patterns is a fundamental task in graph analysis, for example in motif analysis and frequent pattern mining. Classical solvers such as VF2 enumerate occurrences by combinatorial search, but only for exact patterns and one pattern at a time. Existing neural approaches, in contrast, answer only whether a pattern occurs, or recover a single node mapping. To our knowledge, GraphDETR is the first neural model to enumerate all occurrences of given patterns in a graph. We would also argue that it is not a straightforward combination of existing components. Formulating the task as direct set prediction and identifying which components are suitable for it is part of our contribution, and our ablations show that these choices are crucial (Appendix G.4). In addition, we provide an evaluation setup with exact, fuzzy and overlapping instances, which allows future methods to be compared on this task. We revised the related work section accordingly.

Does the near-zero NeuroMatch score reflect the model or the adaptation?

The NeuroMatch numbers must indeed be interpreted in light of the adaptation. Since NeuroMatch natively answers whether a query occurs around a given anchor, enumerating all instances requires significant changes (App. D). It should therefore not be considered a direct competitor. We include it as the most established neural matcher. Our results show that a matcher answering only whether a pattern occurs does not directly extend to enumerating its instances. We include a brief discussion in Appendix D.1 in the revision.

We ran additional experiments to identify the cause of the low scores of NeuroMatch. With its original local k-hop neighbourhoods instead of the full graph, NeuroMatch reliably detects where patterns occur (AUC increased from 0.5 up to 1.00), yet completely fails to recover the instances themselves (AP100 at or below 1%). Even when the correct anchor nodes are given, building the instances from them reaches only 39.2 / 1.2 / 0.0 AP100 on ChEMBL12k / Cactus40 / Cliques100. The bottleneck is thus turning detected occurrences into instance sets.

Missing baselines.

We agree that comparing encoders within our framework does not show the benefit of the framework itself. We therefore ran the proposed comparisons, using the same encoder and training setup (see Table R1 in general response). We now report these results in Section 4.2 and Appendix G.4 of the revised paper.

1a. Tagging + connected components is strong when same-class instances are separated (best AP100 on ChEMBL12k, 98.8 vs 93.7), but merges adjacent same-class instances into one component (Cactus40 ExactMatch 33.6 vs 84.0).

1b. Instance embeddings + clustering is strong when instances are node-disjoint (ChEMBL12k ExactMatch 94.8 vs 83.4), but assigns each node to a single instance and cannot represent shared nodes (Cactus40 ExactMatch 41.2 vs 84.0).

2. A one-way DETR-style decoder lowers AP100 and ExactMatch on all three datasets (Cactus40 ExactMatch 36.6 vs 84.0). Since it uses our set-prediction formulation, we consider it an ablation rather than a baseline.

3. Other neural matching and counting methods answer whether a pattern occurs, return a single node mapping (Sub-GMN, xNeuSM), or predict counts. None enumerates instances without substantial adaptation, as discussed for NeuroMatch above. We are happy to include a specific method if the reviewer has one in mind.

Comparison to Ertl; Practical value on ChEMBL; where is a learned detector preferable?

We would like to clarify that functional-group prediction is meant as a case study, not the main task of the paper. ChEMBL provides a large set of real molecules, and Ertl's algorithm labels their functional groups exactly, which makes it a well-suited testbed for our method. We do not aim to replace this algorithm itself. We clarify this in the revision.

Ertl's algorithm is a rule set designed specifically for functional groups. GraphDETR instead learns any given pattern library from labelled data, and therefore applies where hand-crafted tools fall short, such as (i) fuzzy patterns, where exact methods do not apply, (ii) large graphs, where exact search becomes impractical, and (iii) pipelines that require a differentiable detector. The downstream applications named in App. B, retrosynthesis and property prediction, were meant as motivation rather than tested claims.

Is H_ref critical compared with raw H?

We ran the suggested ablation. Table R1 above compares masks computed from H_ref and raw H. Raw H decreases ExactMatch significantly on ChEMBL12k / Cliques100. Thus H_ref does help on two of the three datasets. We report these results in Appendix G.4 and revised the claim in Section 3.3 accordingly.

Overlap prevalence and performance on graphs with/without overlap.

Yes, several benchmarks contain shared-node instances. The following test-split measurements distinguish shared-node overlap from the broader case of instances that share a node or are connected by an edge. Percentages refer to instances, not graphs.

BenchmarkShared-node overlap (%)Overlap or edge adjacency (%)
Cactus4086.997.8
Cactus20056.379.3
Cactus100032.049.9
Cliques1000.038.8
Cliques2000.037.6
Cliques4000.037.0
ZINC12k85.589.2
Cliques-fuzzy0.019.7
Cactus-fuzzy58.176.8
Mol-Reddit0.00.0
Chembl12k0.010.2

Cactus40 is the only dataset in Table R1 with shared-node overlap, so we split its test graphs into those with and without shared nodes (AP100 / ExactMatch). These numbers come from a separate evaluation pass and differ slightly from Table R1.

DetectorNo shared-node overlap (9 graphs)Shared-node overlap (1,191 graphs)
GraphDETR99.8 / 88.997.2 / 86.7
Tagging + CC75.9 / 51.961.0 / 33.2
Instance embeddings + clustering100.0 / 100.067.4 / 40.5
One-way decoder97.1 / 70.494.1 / 36.6
Raw-H mask head100.0 / 100.098.5 / 87.4

Note that only 9 of the 1,200 Cactus40 test graphs contain no shared node, so the left column should be read with caution. The comparison between graphs with and without overlap is best seen across datasets. ChEMBL12k and Cliques100 contain no shared-node overlap, while in Cactus40 87% of instances share a node. Table R1 shows that instance embeddings + clustering is competitive on the former but fails on the latter, whereas GraphDETR performs well on both.

We now include these results in Appendix E.3 in the revision.

Evidence for symmetry breaking, including automorphic nodes and random features.

Following the suggestion, we evaluated molecules with automorphic nodes. On ChEMBL12k, 166 of 1,000 test molecules contain several instances of the same functional group whose atoms are automorphic to each other, such as the three fluorines of CF3. On this subset, GIN reaches only 7.2% ExactMatch, compared to 79.7% on the remaining molecules, whereas NeuralWalker degrades much less (69.9% vs 83.4%). This is consistent with sampled walks breaking the symmetry between automorphic nodes, which deterministic encoders cannot, even with RWSE. The subsets may, however, differ in other respects, so this does not establish a causal explanation. Fig. 7 (Success 12 and 24) shows CF3 groups recovered by NeuralWalker trained on full ChEMBL. We include these results in Appendix G.2 in the revision.

We note that our goal is not to exhaustively identify the best encoder for subgraph detection, but rather compare existing representative graph encoders under our unified setting. Our subgraph detection benchmark could be a valuable testbed for expressive GNNs, and we leave testing with random feature GNNs for future work.

Standard deviations for Tables 2–4 and claims based on small differences.

Running full five-seed experiments for every configuration in Tables 3–5 would require thousands of GPU-hours, which is beyond the compute budget available during the response period. The current single-run ablations provide an initial picture of how performance changes with each hyperparameter and help identify trends that guide the model configuration, which serves as justifications for our hyperparameter choices. They do not establish the statistical significance of individual differences or a definitive ranking of nearby settings. We agree that these ablations are exploratory and do not support conclusions from small differences. Variability measured in other experiments cannot substitute for standard deviations for these configurations. For all new results, we now report mean and standard deviation over multiple seeds (Tables 2 and 18 of the revised paper).

Were λ_mask and the other hyperparameters tuned equally for all encoders?

Yes. Every encoder was swept over the same grid on ChEMBL12k: λ_mask = α in {2, 4, 8}, background weight in {0.1, 0.5}, λ_cut in {0, 0.001, 0.01}, with the same architecture setting (5 layers, hidden 256, RWSE 20). Table 1 lists two NeuralWalker settings because the two best λ_mask values rank very differently, as one wins on AP100 and the other on ExactMatch. The other encoders rank consistently across metrics, so one setting suffices. We keep both NeuralWalker rows to show this, rather than pick one metric. Table 1 is a study of how encoders behave on subgraph detection, not necessarily a search for an encoder that is best on every metric. We now state this explicitly in Appendix F.2 of the revised paper.

Parameter-matched NeuralWalker–GraphGPS comparison.

All encoders use the same number of layers and hidden dimension, so their parameter counts differ only through the architecture itself. In fact, several observations indicate that the ranking is not driven by model size:

  • GraphGPS is slightly smaller than NeuralWalker (6.6M vs 7.4M), yet outperforms it on Cliques100/200/400 and on Cactus40 ExactMatch.
  • The smallest encoders, GCN (3.9M) and GIN (4.9M), still reach 90.9 and 93.3 AP100 on Cliques100.
  • The gaps to message-passing encoders on Cactus200 and Cactus1000 (50 and 37 AP100) are arguably too large to stem from at most 3.5M parameters.

A fully parameter-matched comparison was unfortunately not feasible within the response period. Note that our goal is not to identify the best encoder for subgraph detection, but rather compare existing representative graph encoders under our unified setting. Our subgraph detection benchmark could be a valuable testbed for expressive GNNs, and we leave a more comprehensive comparison for future work.

Query-based segmentation and counting methods as related work.

Query-based segmentation methods are architectural precedents for GraphDETR, but operate on pixels or points with spatial coordinates, whereas graph instances must be separated by their connectivity alone. Substructure-counting GNNs predict how often a pattern occurs, but not where. We thank the reviewer for these suggestions and extended the related work section accordingly.

Closed vocabulary and retraining for new patterns.

A fixed pattern library is a standard use case for subgraph detection, for example functional groups or network motifs, which are defined once and then searched in various graphs. GraphDETR learns such a library once and predicts all instances of all patterns jointly, so retraining is only needed when the library itself changes. This mirrors object detection, where closed-vocabulary models such as DETR preceded open-vocabulary extensions. We acknowledge this limitation and discuss such an extension of GraphDETR in Appendix A.

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

The paper proposes a model that finds multiple occurrences of known patterns in a graph. For each occurrence, it predicts the pattern type and the nodes involved. It combines a graph encoder with a Transformer decoder and evaluates the approach on molecular and synthetic graphs. The authors conducted empirical simulation as well as evaluation on ChEMBL dataset on which the proposed model shows strong performance.

Critical strengths
  1. Predicting all occurrences together is a useful formulation that naturally handles multiple, overlapping patterns.
  2. The experiments examine different graph encoders, model components, and both exact and approximate pattern matching.
Critical weaknesses
  1. I don't see clearly how the comparisons can justify the benefit of the proposed decoder. Would a simpler detector using the same graph encoder be already more informative than the poorly performing NeuroMatch adaptation? More explanation would be appreciated.
  2. I think the interpretation of the graph-cut penalty is overstated. Disconnected node sets can receive zero penalty, so it does not establish the claimed connectivity property?
Questions for authors

Please see weaknesses.

1 comment

We thank the reviewer for the positive assessment. We address both questions below.

Decoder benefit and simpler detectors.

We ran both suggested comparisons, using the same encoder and training setup (see Table R1 in general response). Replacing the two-way decoder by a one-way DETR-style decoder lowers AP100 and ExactMatch on all three datasets, for example ExactMatch from 84.0 to 36.6 on Cactus40 and from 83.4 to 60.3 on ChEMBL12k. Concerning the simpler detectors, we compared against two approaches, node tagging + connected components and instance embeddings + clustering. While both perform well on node-disjoint instances such as in ChEMBL12k, they fail where instances share nodes (Cactus40 ExactMatch 33.6 and 41.2 vs 84.0 for GraphDETR). We now report these results in Section 4.2 and Appendix G.4 of the revised paper.

Cut penalty.

Yes, the penalty does not by itself guarantee connectivity. For a hard mask SS, it counts edges crossing from SS to its complement, normalised by ∣E∣|E|. It is zero for any union of connected components, including disconnected unions. On connected hosts it therefore never vanishes for a non-trivial mask, but it does not enforce connectivity either. A disconnected set can have a smaller cut than a connected one (e.g., two isolated leaves). It is a boundary-length (total-variation-style) regularizer that discourages fragmented masks, and the gradient analysis of App. C (majority-vote smoothing) remains valid for that reading. We reword "differentiable relaxation of the connectivity constraint" accordingly in the revision.

Comments on the paper

4 comments
AuthorsOpenReview ↗

General response

We thank the reviewers for their constructive feedback and for highlighting several strong points, such as the clear and well-motivated set-prediction formulation (3XTY, AwCb, G7Ki), the broad evaluation (3XTY, AwCb, G7Ki) and the useful ablations (AwCb, G7Ki). Below we present new results suggested by the reviewers. We have uploaded a revised version of the paper with changes marked in red, and all table references refer to this revised version.

New baselines (Table R1)

Following the reviewers' suggestions, we compare GraphDETR to alternative detection formulations and decoder variants. All new detectors except NeuroMatch use the NeuralWalker encoder with the same data and training budget (3 seeds). Entries are AP100 / Rec100 / ExactMatch in percent.

ChEMBL12kCactus40Cliques100
tagging + connected components98.8 / 91.2 / 78.361.1 / 68.8 / 33.649.9 / 61.2 / 7.8
tagging + connected components on ground-truth labels99.5 / 91.2 / 79.060.5 / 69.1 / 33.949.4 / 61.2 / 7.9
instance embeddings + clustering84.2 / 99.3 / 94.867.6 / 74.5 / 41.299.0 / 99.9 / 99.6
NeuroMatch (adapted)0.0 / 0.3 / 0.00.3 / 22.7 / 0.00.0 / 0.2 / 0.0
Ours (set prediction, two-way decoder)93.7 / 97.2 / 83.497.4 / 98.7 / 84.096.2 / 97.7 / 95.9
ablation: one-way decoder84.7 / 91.3 / 60.394.1 / 97.1 / 36.695.0 / 96.7 / 83.4
ablation: mask head on raw H90.7 / 94.3 / 74.198.5 / 99.0 / 87.687.6 / 91.0 / 68.7

The results show that the relative performance of the formulations depends on whether instances share nodes. On Cactus40, where 87% of instances share a node with another, GraphDETR clearly outperforms all baselines. On the node-disjoint ChEMBL12k and Cliques100, embeddings + clustering achieves a higher ExactMatch, and tagging has the best ChEMBL12k AP100.

These differences reflect inherent limitations of the baseline formulations:

  • Tagging + connected components labels each node with a class and then groups connected same-class nodes into instances. Two same-class instances that touch therefore become one instance. Even with perfect node labels, this reaches only 79.0 / 33.9 / 7.9 ExactMatch on ChEMBL12k / Cactus40 / Cliques100, about the same as the trained model (78.3 / 33.6 / 7.8). So a better tagger would not help, since even perfect labels give the same result.
  • Instance embeddings + clustering assigns each node to exactly one instance. It therefore cannot express that a node belongs to two instances, which happens in 87% of Cactus40 instances. Accordingly, it reaches only 41.2 ExactMatch on Cactus40 against 84.0 for GraphDETR, while it performs best on the node-disjoint ChEMBL12k and Cliques100 (94.8 and 99.6).
  • NeuroMatch only answers whether a pattern occurs around a node. Turning these answers into a list of instances requires additional steps that are not part of the model, and the resulting detector recovers almost no instances.

GraphDETR addresses these limitations directly, since each query predicts its own node mask. Several masks can therefore share a node, and no grouping, clustering or duplicate removal is needed. We provide details of these alternative formulations in Appendix D.2, and report the new results in Section 4.2 in the revised paper.

Decoder evidence. Replacing two-way attention with a one-way decoder reduces both AP100 and ExactMatch on all 3 datasets. This isolates the benefit of the second attention direction under the tested configuration. Using raw H for mask prediction is competitive on Cactus40, but reduces ExactMatch on ChEMBL12k and Cliques100. We report these results in Appendix G.4 in the revision.

We thank the reviewer for the detailed review and address each point below.

Fixed-vocabulary detection versus arbitrary query-conditioned matching.

GraphDETR addresses closed-vocabulary detection, finding all occurrences of every pattern in a library fixed at training time, rather than query-conditioned matching, where a pattern is supplied at inference. This setting is standard in applications that search a known library, such as functional groups or network motifs, in many graphs, and it allows all patterns to be detected jointly, including overlapping and approximate instances. The VF2 comparison should be read in this light, as an exact reference on the same task rather than as a competitor in query-conditioned matching. We make this distinction more explicit in the abstract in the revision.

Fairness of the VF2 comparison, training cost and amortisation.

We agree that the comparison is not apples-to-apples. VF2 accepts arbitrary queries without training and returns exact matches only, while GraphDETR learns a fixed library and can also detect approximate patterns, at the cost of no exactness guarantee. VF2 is therefore not meant as a competitor, but as the closest available reference, since no existing solver detects all instances of a pattern library, including approximate ones. While not directly comparable, the runtimes show that GraphDETR is useful where exact solvers no longer finish in feasible time.

Regarding training cost and amortisation, GraphDETR is trained once and then reused across graphs. Training takes a few GPU-hours on small graphs and over a day on Cactus1000 and Mol-Reddit (App. F.3). As a rough estimate from Table 7, one GPU-hour of training is recovered after at most about 60 graphs where VF2 exceeds its time budget, as on Cliques200/400, but only after tens to hundreds of thousands of graphs on small graphs such as Cactus40 and ZINC12k, where we claim no runtime advantage. This estimate is only indicative, since GraphDETR's predictions are not guaranteed to be exact, the two methods run on different hardware (CPU vs GPU), and preprocessing is not included.

Weak NeuroMatch baseline and stronger learned alternatives under comparable supervision.

We agree that NeuroMatch alone is not a sufficient baseline and added the suggested graph instance-segmentation baselines, node tagging + connected components and instance embeddings + clustering, trained with the same encoder and supervision as GraphDETR (see Table R1 in the general response and Section 4.2 of the revised paper). Both perform well on node-disjoint instances such as in ChEMBL12k, but fail where instances share nodes (Cactus40 ExactMatch 33.6 and 41.2 vs 84.0), as detailed in the general response. A reliable NeuroMatch adaptation additionally requires instance reconstruction, anchor acceptance and duplicate handling. In additional experiments, NeuroMatch with its original local neighbourhoods detects where patterns occur almost perfectly (AUC up to 1.00), yet still fails to recover the instances (AP100 at or below 1%). We believe developing a consistently effective matching-based detector requires a separate methodological investigation beyond this paper's scope. We therefore use the direct detection baselines to assess GraphDETR, and retain NeuroMatch as a qualified adaptation study rather than evidence of general superiority over neural matching.

Accuracy, runtime and practical utility relative to the functional-group generator.

We would like to clarify that functional-group prediction is only meant to be a case study. We do not aim to replace Ertl's algorithm, which generates these labels. Since the algorithm defines the ground truth, our ChEMBL results measure how closely GraphDETR reproduces it, rather than competing with it. The task instead serves as a testbed for methodological validation.

Ertl's algorithm is a rule set designed specifically for functional groups. GraphDETR is more general, as it learns any given pattern library from data. It therefore also applies to settings where hand-crafted tools fall short, such as (i) fuzzy patterns, where exact methods do not apply, (ii) large graphs, where exact search becomes impractical, and (iii) pipelines that require a differentiable detector.

Thank you to the authors for the careful and comprehensive response. Most of my concerns have been adequately addressed, and I will keep my score unchanged.

Thank you for your response and for confirming that most of your concerns have been adequately addressed. Since your score remains a weak reject, we would be grateful if you could point out which concerns or questions remain open, so that we can address them before the discussion closes.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.