Thousands of review tuples become a ranked list of product insights — and every piece of evidence stays attached to the insight it supports.
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.
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.
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.
← swipe the diagram →
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})
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.
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.
| Strategy | recall@10 | prec@10 | NDCG@10 | coverage | dup | LLM calls |
|---|---|---|---|---|---|---|
| Software · N ≤ 297 | ||||||
| flat_llmdrops evidence | 0.532 | 0.573 | 0.619 | 0.942 −5.8% | 107 | 1.0 |
| BERTopicdrops evidence | 0.471 | 0.723 | 0.599 | 0.883 −11.7% | 0 | 0.0 |
| hier_agglom (BGE raw) | 0.575 | 0.520 | 0.648 | 1.000 | 0 | 10.0 |
| GraphReduce | 0.609* | 0.551 | 0.667 | 1.000 | 0 | 11.0 |
| Fashion · N ≤ 486 | ||||||
| flat_llmdrops evidence | 0.516 | 0.517 | 0.602 | 0.872 −12.8% | 88 | 1.0 |
| BERTopicdrops evidence | 0.562 | 0.562 | 0.631 | 0.601 −39.9% | 0 | 0.0 |
| hier_agglom (BGE raw) | 0.502 | 0.502 | 0.561 | 1.000 | 0 | 10.0 |
| GraphReduce | 0.536** | 0.536 | 0.581 | 1.000 | 0 | 11.0 |
| Baby · N ≤ 500 | ||||||
| flat_llmdrops evidence | 0.618 | 0.539 | 0.676 | 0.951 −4.9% | 51 | 1.0 |
| BERTopicdrops evidence | 0.430 | 0.792 | 0.575 | 0.879 −12.1% | 0 | 0.0 |
| hier_agglom (BGE raw) | 0.618 | 0.465 | 0.652 | 1.000 | 0 | 10.0 |
| GraphReduce | 0.674** | 0.508 | 0.669 | 1.000 | 0 | 10.6 |
← swipe the table →
| Metric | Δ | 95% CI | p |
|---|---|---|---|
| Software | |||
| recall@10 | +0.034 | +0.006 … +0.062 | 0.015 |
| NDCG@10 | +0.020 | −0.005 … +0.045 | n.s. |
| Fashion | |||
| recall@10 | +0.034 | +0.009 … +0.059 | 0.010 |
| NDCG@10 | +0.020 | −0.005 … +0.045 | n.s. |
| Baby | |||
| recall@10 | +0.056 | +0.023 … +0.090 | 0.005 |
| NDCG@10 | +0.017 | −0.016 … +0.052 | n.s. |
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%.
Software · N ≤ 297
Fashion · N ≤ 486
Baby · N ≤ 500
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.
| Strategy | recall | prec | NDCG | coverage | dup |
|---|---|---|---|---|---|
| flat_llmdrops evidence | 0.480 | 0.491 | 0.481 | 0.228 | 10 |
| batch_directdrops evidence | 0.380 | 0.380 | 0.478 | 0.490 | 1 |
| embed_cluster_llm | 0.400 | 0.400 | 0.486 | 0.977 | 0 |
| embed_cluster | 0.340 | 0.340 | 0.394 | 1.000 | 0 |
| GraphReduce | 0.360 | 0.360 | 0.475 | 1.000 | 0 |
← swipe the table →
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.
| Configuration | recall@10 | prec@10 | NDCG@10 | coverage |
|---|---|---|---|---|
| BGE raw + sklearn agglom + size rank | 0.595 | 0.507 | 0.651 | 0.947 |
| BGE raw + chunk + spectral + LLM rank | 0.589 | 0.503 | 0.680 | 1.000 |
| + ProjHead (Layer-2 pairs) + sklearn | 0.533 | 0.522 | 0.606 | 1.000 |
| + ProjHead (Layer-2 pairs) + chunk + rank | 0.632 | 0.533 | 0.686 | 1.000 |
| + ProjHead (Layer-3 pairs) + sklearn | 0.529 | 0.532 | 0.602 | 1.000 |
| + ProjHead (Layer-3 pairs) + chunk + rank | 0.652 | 0.550 | 0.700 | 1.000 |
| Projection dimension sweep, full pipeline | ||||
| d = 64 | 0.622 | 0.527 | 0.678 | 1.000 |
| d = 128 | 0.652 | 0.550 | 0.700 | 1.000 |
| d = 256 | 0.628 | 0.533 | 0.680 | 1.000 |
| Training length sweep | ||||
| epochs = 3 | 0.652 | 0.550 | 0.700 | 1.000 |
| epochs = 5 (union L2 + L3 pairs) | 0.618 | 0.523 | 0.676 | 1.000 |
| epochs = 10 | 0.609 | 0.507 | 0.664 | 1.000 |
| Negative result — learned soft clustering | ||||
| GraphPool (GraphSAGE) | 0.460 | 0.390 | 0.518 | 1.000 |
| GraphPool + GRPO | 0.478 | 0.404 | 0.537 | 1.000 |
← swipe the table →
| Strategy | LLM calls | median (s) | p90 (s) |
|---|---|---|---|
| Software | |||
| flat_llm | 1.0 | 13.4 | 21.0 |
| BERTopic | 0.0 | 0.2 | 0.3 |
| hier_agglom | 10.0 | 16.4 | 21.7 |
| GraphReduce | 11.0 | 14.8 | 19.5 |
| Fashion | |||
| flat_llm | 1.0 | 27.2 | 37.8 |
| BERTopic | 0.0 | 0.6 | 1.1 |
| hier_agglom | 10.0 | 27.9 | 39.5 |
| GraphReduce | 11.0 | 26.8 | 40.1 |
| Baby | |||
| flat_llm | 1.0 | 21.9 | 34.5 |
| BERTopic | 0.0 | 0.1 | 0.2 |
| hier_agglom | 10.0 | 29.2 | 37.8 |
| GraphReduce | 10.6 | 26.7 | 32.8 |
← swipe the table →
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.
| Model | overall ≥ 4 | overall | correctness | completeness | diversity | abstraction |
|---|---|---|---|---|---|---|
| base (Qwen3.5-9B) | 59.3% | 3.69 | 4.70 | 4.69 | 4.79 | 3.40 |
| SFT (190K teacher labels) | 88.7% | 4.52 | 4.80 | 4.78 | 4.89 | 4.49 |
| DPO (chosen = teacher, rejected = SFT) | 90.8% | 4.62 | 4.85 | 4.80 | 4.94 | 4.64 |
| GRPO (anti-copy) | 93.1% | 4.71 | 4.85 | 4.82 | 4.95 | 4.78 |
← swipe the table →
| Method | Top-3 themes |
|---|---|
| flat_llm | paid app · app crashes · gameplay |
| hier_agglom | gameplay · inaccessible items · app crashes |
| GraphReduce | hidden object gameplay · device compatibility · paid app |
| Gold | progression blocker · device compatibility · blue crystal inaccessible |
← swipe the table →
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.
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.
@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}
}