GraphReduce
EMNLP 2026 Industry Track · Accepted (Poster)

GraphReduce: Coverage-Preserving LLM Aggregation for E-commerce Review Insights

Thousands of review tuples become a ranked list of product insights — and every piece of evidence stays attached to the insight it supports.

Nanyang Technological University, Singapore
100% tuple coverage 0 duplicate assignments +0.034 – 0.056 recall@10 over the best lossless baseline 22.8% coverage kept by a flat LLM at N ≈ 1,500
A product detail page review section showing insight chips: Includes visuals 50, Verified purchase 82, Fit 48, Lightweight 32, Comfortable 21, above the individual customer reviews.

1 — the insight chips a shopper sees, each with a count

The reviews page filtered by one chip, showing the individual verified-purchase reviews that support it.

2 — tapping one has to show the reviews behind it

Figure 1 The deployed setting. A product detail page can surface only a handful of insight chips, but every chip carries a count — and tapping it must show the reviews that back it up. That second requirement, member traceability, is what this paper is about.
Abstract

In e-commerce, product detail pages (PDPs) often contain hundreds or thousands of customer reviews, yet the interface can surface only a small set of concise and reliable insights. A useful review aggregation system must therefore abstract recurring themes while preserving which reviews support each insight. We study this problem as structured review-insight mining: review-level tuples are first extracted and then aggregated into ranked product-level insight clusters with explicit member traceability.

We propose GraphReduce, a coverage-preserving framework for product-scale review insight aggregation. It combines a contrastively trained projection layer over frozen sentence embeddings, graph-based clustering on local neighborhood structure, and an LLM reducer/ranker for naming and ordering canonical clusters. By keeping membership accounting outside the generative step, GraphReduce preserves complete tuple coverage and avoids a common failure mode of direct LLM summarization: producing plausible high-level themes while silently dropping long-tail evidence.

Across three product-category benchmarks, GraphReduce improves recovery of gold insight clusters over strong lossless embedding-based baselines while maintaining comparable ranking quality. We further show that flat LLM and topic-modeling baselines can appear competitive under ranking metrics despite omitting substantial input evidence, and that an anti-copy reinforcement objective improves the quality of upstream tuple extraction.

The task

Two questions, not one

Most opinion summarization work answers what should a summary say? A deployed PDP insight system has to answer a second question at the same time: which reviews support each displayed insight? Without explicit member traceability, a system can generate fluent, useful-looking themes while silently ignoring the long-tail evidence needed for user trust, analytics, and auditability.

So we formulate the problem in two stages. Stage 1 converts each review into one or more structured tuples — an abstracted insight, an aspect, a sentiment label, a language tag, and the supporting review span. Stage 2 groups the tuples of one product into a ranked list of canonical insight clusters, each with a human-readable description and the complete set of member tuple ids.

That coverage requirement changes the nature of the task. A method that emits only salient head themes can score well on NDCG while discarding the evidence that downstream analysis, verification, and audits depend on. Ranking quality and evidence accounting have to be measured separately.

Method

Separate the language from the bookkeeping

A direct LLM aggregation prompt has to do three jobs at once: decide which insights are salient, write their descriptions, and return the exact set of member ids for each cluster. GraphReduce splits those jobs apart. The model is used where linguistic abstraction is genuinely needed — naming a group, ordering the final list — while membership is computed outside the model as a graph operation and a set union.

while |pool| > K LANGUAGE — THE LLM NAMES AND RANKS MEMBERSHIP — DETERMINISTIC, NEVER IN A PROMPT N review tuples one product Frozen encoder BGE-small + ProjHead kNN graph + spectral hard partition LLM reducer names a group, B ≤ 200 LLM ranker orders the final K z C_j pool Row-id sets {i} per tuple Set union R_j = ∪ R_u One cluster each 100% cov · 0 dup ids carried verbatim partition C_j R_j

← swipe the diagram →

Figure 2 The two paths of GraphReduce. Above the line, tuples are embedded, projected and partitioned, and an LLM names each group and ranks the survivors; the pool shrinks one level at a time until it holds at most K items. Below the line, the ids travel separately: the same partition regroups them, a deterministic set union merges them upward, and they arrive attached to the output without ever appearing in a prompt. Because every clustering step returns a partition and every merge is a union, each input tuple ends in exactly one output cluster.

Why this preserves coverage

The guarantee is structural, not behavioural. It does not depend on the LLM reproducing row ids or keeping global state in text — it follows from two facts: each intermediate clustering step returns a partition of the current pool, and each parent's member set is the union of its children's. Cluster assignments are therefore auditable before any language is generated.

The cost is bounded too. Instead of one long-context prompt over all N tuples, GraphReduce issues one reducer call per bounded group plus a single ranking call, so the number of LLM calls is 1 + Σ max(K, ⌈N/Bℓ+1⌉) — 10 to 11 calls per product in our experiments, each over at most B = 200 tuples.

Algorithm 1 — GraphReduce inference  member ids are unioned outside the LLM

input  tuples T = {t_i}, target size K, group size B, projection φ, reducer/ranker π, embedder Emb
output ranked clusters with complete member-id assignments

 1  x_i ← Emb(t_i);  z_i ← φ(x_i)                      for all t_i
 2  pool ← {(t_i, z_i, {row_id_i})}
 3  while |pool| > K do
 4      K′ ← max(K, ⌈|pool| / B⌉)
 5      {C_j} ← SpectralKNN({z}, K′)                   a partition — nothing is dropped
 6      p_j ← π(C_j → NAME)                            ← the only generative step
 7      R_j ← ∪_{u ∈ C_j} R_u;   z̄_j ← mean of z_u    ← deterministic bookkeeping
 8      pool ← {(p_j, z̄_j, R_j)}
 9  end while
10  (top_K, scores) ← π(pool → RANK, K)                ordering only; membership is fixed
11  return (top_K, scores, {R_j})

Two learned pieces

A projection head, not a fine-tuned encoder. Generic sentence embeddings put device compatibility, installation and performance tuples near each other simply because the same product name appears in all three. We train a 384→256→128 MLP over a frozen BGE-small-en-v1.5 with an InfoNCE objective (τ = 0.07), drawing positives from the same gold cluster, hard negatives from other clusters of the same product, and easy negatives from other products. Under 200K trainable parameters; the encoder never moves.

K-way reducer supervision. A reducer trained only on clean single-cluster examples learns that every input collapses to one phrase — and then over-merges the mixed groups an imperfect spectral partition actually produces. We synthesize supervision that matches inference: sample k ∈ {2, 3, 5, 7, 10} gold clusters from one product, draw at most 200 tuples from their union, shuffle, and train the model to recover the partition and its canonical names. The same checkpoint does the naming and the final ranking.

Results

Better recovery, complete evidence

We evaluate on three held-out benchmarks built from Amazon product reviews — Software, Fashion and Baby — each with 100 products, product-level gold insight clusters and importance rankings. Every test product is excluded from both projection-head training and reducer fine-tuning.

Among methods with complete member coverage, GraphReduce has the highest recall@10 in all three categories, and the gains over hier_agglom are significant under paired Wilcoxon tests. NDCG is a different story: the difference sits inside bootstrap uncertainty, so we report ranking parity, not a ranking win. The gain is in gold-cluster recovery under exact evidence coverage.

Stage-2 aggregation on fixed 100-product held-out benchmarks. Coverage is the fraction of input tuple ids assigned to a predicted top-10 cluster; dup counts ids assigned to more than one cluster. Best value per column in bold. * / ** — recall gain over hier_agglom significant at p < 0.05 / p < 0.01.
Strategyrecall@10prec@10NDCG@10coveragedupLLM calls
Software · N ≤ 297
flat_llmdrops evidence0.5320.5730.6190.942  −5.8%1071.0
BERTopicdrops evidence0.4710.7230.5990.883  −11.7%00.0
hier_agglom (BGE raw)0.5750.5200.6481.000010.0
GraphReduce0.609*0.5510.6671.000011.0
Fashion · N ≤ 486
flat_llmdrops evidence0.5160.5170.6020.872  −12.8%881.0
BERTopicdrops evidence0.5620.5620.6310.601  −39.9%00.0
hier_agglom (BGE raw)0.5020.5020.5611.000010.0
GraphReduce0.536**0.5360.5811.000011.0
Baby · N ≤ 500
flat_llmdrops evidence0.6180.5390.6760.951  −4.9%511.0
BERTopicdrops evidence0.4300.7920.5750.879  −12.1%00.0
hier_agglom (BGE raw)0.6180.4650.6521.000010.0
GraphReduce0.674**0.5080.6691.000010.6

← swipe the table →

Table 1 The two baselines that win a column also lose evidence: BERTopic's precision comes from discarding HDBSCAN outliers, and flat prompting's NDCG comes with 51–107 duplicated tuple ids. GraphReduce is the only method that improves recovery over the strongest lossless baseline while keeping the inventory intact.
−0.020+0.02 +0.04+0.06+0.08+0.10 no difference recall@10NDCG@10 recall@10NDCG@10 recall@10NDCG@10 SOFTWAREFASHIONBABY +0.034 · p=0.015 +0.020 · n.s. +0.034 · p=0.010 +0.020 · n.s. +0.056 · p=0.005 +0.017 · n.s.
MetricΔ95% CIp
Software
recall@10+0.034+0.006 … +0.0620.015
NDCG@10+0.020−0.005 … +0.045n.s.
Fashion
recall@10+0.034+0.009 … +0.0590.010
NDCG@10+0.020−0.005 … +0.045n.s.
Baby
recall@10+0.056+0.023 … +0.0900.005
NDCG@10+0.017−0.016 … +0.052n.s.
recall@10 — CI excludes zero in all three categories NDCG@10 — CI crosses zero everywhere
Figure 3 Per-product paired differences, GraphReduce minus hier_agglom (n = 100 products per category). Bars are 95% confidence intervals from a deterministic 10,000-sample paired bootstrap; p-values are two-sided Wilcoxon signed-rank. This is the honest version of the claim: recovery improves, ordering holds steady.
Coverage

What the ranking metrics don't show

Coverage is the fraction of input tuple ids that end up inside some predicted top-10 cluster. It is not a diagnostic detail — it is the difference between an insight you can click through to its reviews and one you cannot. Across the 100-product benchmarks, the omitted inventory of the non-lossless baselines ranges from 4.9% to 39.9%.

tuple ids assigned to an output cluster tuple ids left unassigned

Software · N ≤ 297

flat_llm
94.2%
−5.8%
BERTopic
88.3%
−11.7%
hier_agglom
100%
0 lost
GraphReduce
100%
0 lost

Fashion · N ≤ 486

flat_llm
87.2%
−12.8%
BERTopic
60.1%
−39.9%
hier_agglom
100%
0 lost
GraphReduce
100%
0 lost

Baby · N ≤ 500

flat_llm
95.1%
−4.9%
BERTopic
87.9%
−12.1%
hier_agglom
100%
0 lost
GraphReduce
100%
0 lost
Figure 4 Share of the extracted tuple inventory that survives aggregation. The hatched remainder is evidence the system named nothing for — invisible to recall, precision and NDCG alike.

The stress test

We pushed five Fashion products with N ∈ [800, 1700] tuples through the same pipelines. Five products is not a statistical claim; it is a look at what happens once the inventory outgrows the benchmark. Flat prompting still returns plausible head themes — and keeps 22.8% of the ids.

22.8%
flat_llm coverage
Fluent output, three quarters of the evidence unaccounted for.
100%
GraphReduce coverage
Unchanged by N: the guarantee is structural.
0
duplicate ids
Each tuple belongs to exactly one output cluster.
Large-N Fashion stress test — 5 products, N ≈ 1,500, all metrics @10.
StrategyrecallprecNDCGcoveragedup
flat_llmdrops evidence0.4800.4910.4810.22810
batch_directdrops evidence0.3800.3800.4780.4901
embed_cluster_llm0.4000.4000.4860.9770
embed_cluster0.3400.3400.3941.0000
GraphReduce0.3600.3600.4751.0000

← swipe the table →

Table 2 At this scale the flat LLM tops recall and precision on the ten names it does produce, while assigning barely a fifth of the tuples. Treating review insight aggregation as one long-context generation problem produces output that looks coherent and does not preserve the input inventory.

Losslessness is not slower

GraphReduce issues 10–11 reducer calls per product against the flat LLM's single call, yet its median wall-clock is comparable or lower — each call runs over a bounded chunk of at most 200 tuples instead of one prompt over all N. On Software, 14.8 s median against flat prompting's 13.4 s and hier_agglom's 16.4 s; on Baby, 26.7 s against 21.9 s and 29.2 s. BERTopic is far cheaper than either, at the price of 11.7–39.9% of the inventory.

What matters, and what doesn't

Three things the ablations settle

Full ablation table — 30-product Software benchmark
Configurationrecall@10prec@10NDCG@10coverage
BGE raw + sklearn agglom + size rank0.5950.5070.6510.947
BGE raw + chunk + spectral + LLM rank0.5890.5030.6801.000
+ ProjHead (Layer-2 pairs) + sklearn0.5330.5220.6061.000
+ ProjHead (Layer-2 pairs) + chunk + rank0.6320.5330.6861.000
+ ProjHead (Layer-3 pairs) + sklearn0.5290.5320.6021.000
+ ProjHead (Layer-3 pairs) + chunk + rank0.6520.5500.7001.000
Projection dimension sweep, full pipeline
d = 640.6220.5270.6781.000
d = 1280.6520.5500.7001.000
d = 2560.6280.5330.6801.000
Training length sweep
epochs = 30.6520.5500.7001.000
epochs = 5 (union L2 + L3 pairs)0.6180.5230.6761.000
epochs = 100.6090.5070.6641.000
Negative result — learned soft clustering
GraphPool (GraphSAGE)0.4600.3900.5181.000
GraphPool + GRPO0.4780.4040.5371.000

← swipe the table →

Cost and latency per product
Median and 90th-percentile wall-clock per product, with the number of LLM calls.
StrategyLLM callsmedian (s)p90 (s)
Software
flat_llm1.013.421.0
BERTopic0.00.20.3
hier_agglom10.016.421.7
GraphReduce11.014.819.5
Fashion
flat_llm1.027.237.8
BERTopic0.00.61.1
hier_agglom10.027.939.5
GraphReduce11.026.840.1
Baby
flat_llm1.021.934.5
BERTopic0.00.10.2
hier_agglom10.029.237.8
GraphReduce10.626.732.8

← swipe the table →

Upstream

Teaching the extractor to stop copying

Stage 1 turns a review into tuples: an abstracted insight, an aspect, a sentiment label, a language tag, and the verbatim span that grounds it. The dominant SFT failure is slice copying — the model satisfies grounding by putting the evidence span in the insight field too. The tuple is then perfectly grounded and not abstracted at all.

Our GRPO reward attacks exactly that. The per-tuple insight score starts at +1 and is clipped at −2 after four penalties: −1.5 if the insight equals the generated slice, −0.5 if it is a non-slice verbatim substring of the review, −0.5 if it is not 1–3 words, and −0.7 if it is a vague single token such as good. Auxiliary terms score aspect quality, slice validity, and sentiment/language membership; the insight term carries weight 5.0 in the final weighted sum.

Stage-1 extraction quality on 5,000 held-out Software reviews, judged 1–5 by Gemini 2.5 Pro. Production quality is the rate of overall ≥ 4.
Modeloverall ≥ 4overallcorrectnesscompletenessdiversityabstraction
base (Qwen3.5-9B)59.3%3.694.704.694.793.40
SFT (190K teacher labels)88.7%4.524.804.784.894.49
DPO (chosen = teacher, rejected = SFT)90.8%4.624.854.804.944.64
GRPO (anti-copy)93.1%4.714.854.824.954.78

← swipe the table →

Table 3 Correctness, completeness and diversity are near-saturated from SFT onward; the movement is in abstraction — 3.40 → 4.78 — which is the dimension the reward targets. Production quality rises from 59.3% to 93.1%.
One product, up close

Where it still goes wrong

Top-3 cluster names for one Software product (asin B008BBB388, N = 57 tuples, 12 gold clusters).
MethodTop-3 themes
flat_llmpaid app · app crashes · gameplay
hier_agglomgameplay · inaccessible items · app crashes
GraphReducehidden object gameplay · device compatibility · paid app
Goldprogression blocker · device compatibility · blue crystal inaccessible

← swipe the table →

Table 4 Not a clean win: GraphReduce recovers device compatibility and a more specific gameplay phrase, but misses the gold's fine-grained blue crystal inaccessible. Recall and coverage improve over raw embeddings while phrase aliasing keeps costing NDCG.

Manual analysis of low-NDCG predictions turns up four recurring failures. Phrase aliasing is the most common: two genuinely distinct clusters both get named app crashes, so only one can match the gold theme even when the member partition is sound. Long-tail themes compete with head themes for limited top-K slots. Spectral over-merge shows up when a product has few tuples — the fixed k = 20 graph is too dense below N ≈ 40. And some clusters have essentially correct member sets under an overly generic name.

The fixes those point to are concrete: adaptive graph degree, a diversity-aware ranking objective, a reducer that conditions on the names already chosen, and evaluation that matches semantics rather than phrase tokens.

Limitations

What this evaluation does not establish

The product-level gold is LLM-assisted. Gemini 2.5 Pro participates in importance scoring during gold construction and in evaluation. Held-out product splits guard against train/test leakage, but this is not an anti-circularity guarantee, and human audits with inter-annotator agreement are needed before treating the benchmark as a human gold standard.

Some axes are thin. The large-N Fashion stress test covers five products. Stage-1 extraction is fully evaluated only on Software. And the phrase-token matching metric can miss semantic equivalence or over-credit generic aliases — the same weakness the qualitative analysis surfaces from the other direction.

On data. All experiments use the publicly released Amazon product reviews, already de-identified at release. We collected no new human data, performed no re-identification, and release aggregate product-level insight clusters rather than user-level records.

Cite

BibTeX

@inproceedings{graphreduce2026,
  title     = {GraphReduce: Coverage-Preserving LLM Aggregation for
               E-commerce Review Insights},
  author    = {Jiang, Hao and Li, Xin and Zhang, Yichi and Lin, Weisi},
  booktitle = {Proceedings of the 2026 Conference on Empirical Methods in
               Natural Language Processing: Industry Track},
  year      = {2026}
}