📄 Opinosis: A Graph Based Approach to Abstractive Summarization of Highly Redundant Opinions

Summary

Opinion texts such as product reviews, tweets or blog comments often repeat the same few points with small variations. Choosing whole sentences (extractive summarization) then gives biased or wordy results, and earlier abstractive systems relied on hand-built templates or deep, domain-specific generation. Opinosis is a lightweight alternative that needs no domain knowledge and only shallow NLP (POS tagging).

All sentences on one topic are merged into a single directed word graph. Each node is a word plus its POS tag and stores where that word appeared in which sentence. Summaries are produced by searching for paths that:

• start at nodes that typically open a sentence,
• end at punctuation or a coordinating conjunction,
• match simple POS patterns,
• are shared by many input sentences.

Compatible paths can be merged at "hub" nodes. The output is a set of new, compressed sentences built from fused fragments.

On user reviews, these summaries agreed with human summaries better than an extractive baseline did. In a readability test, over 60% of the generated sentences were judged indistinguishable from human-written ones. This makes the method attractive for redundant content in other domains and possibly other languages.

Key points

• The Opinosis-Graph has one node per unique word:POS unit (e.g., "service:nn"). Each node keeps a Positional Reference Information (PRI) list of SID:PID pairs (sentence ID, position in sentence). Directed edges preserve the original word order.
• Three graph properties drive summary generation:
  • Redundancy Capture: heavy subpaths signal salient content.
  • Gapped Subsequence Capture: phrasings with minor differences reinforce each other.
  • Collapsible Structures: hub-like nodes, often linking verbs such as "is" or "are", allow merging several phrases into one sentence.
• A path is valid only if it meets all of these conditions:
  • its start node has an average position ≤ σ_vsn;
  • its end node is punctuation or a coordinating conjunction ("but", "yet");
  • it matches one of four regex patterns over POS tags.
• Path redundancy counts the input sentences that overlap along the path. Overlaps are found by intersecting SID sets, and a position gap of up to σ_gap is tolerated.
• Results:
  • Better agreement with human summaries than the extractive baseline.
  • More than 60% of generated sentences rated as no different from human ones; some errors came from the allowed gaps.
• The dataset and demo software were released by the authors (timan.cs.uiuc.edu).

Interesting ideas

• I1. Positions stored in graph nodes. Keeping SID:PID lists in each node lets one structure answer both "how many sentences share this fragment" and "is this a plausible sentence start". The same trick would work for mining frequent phrasings in other redundant corpora, such as support tickets or customer comments.
• I2. Word-level extraction as cheap abstraction. Fusing and compressing fragments yields new sentences without a full generation system. This is a practical middle ground for languages or domains that lack heavy NLP tooling.
• I3. POS regex filters as a control knob. The well-formedness patterns can be swapped to produce only particular sentence types, such as comparative or strongly opinionated ones. This is a simple, interpretable way to steer output without retraining anything.
• I4. Gap-tolerant overlap counting. Letting sentence paths match within a small positional gap groups near-paraphrases ("drop frequently" vs. "drop too frequently") as the same idea. This fits noisy user-generated text in any language.
• I5. Honest diagnosis of the limitation. The authors note that relying on surface word order prevents grouping sentences by deeper meaning, and suggest overlaying parse trees instead. For richly inflected languages with freer word order, this points to building the graph over syntactic structures, such as dependency trees, rather than raw word sequences.