TextRank
- README: https://github.com/david-mccullars/text_rank
- Documentation: http://www.rubydoc.info/github/david-mccullars/text_rank
- Bug Reports: https://github.com/david-mccullars/text_rank/issues
Status
Description
TextRank is an unsupervised keyword extraction algorithm based on PageRank. Other strategies for keyword extraction generally rely on either statistics (like inverse document frequency and term frequency) which ignore context, or they rely on machine learning, requiring a corpus of training data which likely will not be suitable for all applications. TextRank is found to produce superior results in many situations with minimal computational cost.
Features
- Multiple PageRank implementations to choose one best suited for the performance needs of your application
- Framework for adding additional PageRank implementations (e.g. a native implemenation)
- Extensible architecture to customize how text is filtered
- Extensible architecture to customize how text is tokenized
- Extensible architecture to customize how tokens are filtered
- Extensible architecture to customize how keywords ranks are filtered/processed
Installation
gem install text_rank
Requirements
- Ruby 3.0.0 or higher
-
engtagger gem is optional but
required for
TextRank::TokenFilter::PartOfSpeech
-
nokogiri gem is optional but
required for
TextRank::CharFilter::StripHtml
Usage
TextRank
require 'text_rank'
text = <<-END
In a castle of Westphalia, belonging to the Baron of Thunder-ten-Tronckh, lived
a youth, whom nature had endowed with the most gentle manners. His countenance
was a true picture of his soul. He combined a true judgment with simplicity of
spirit, which was the reason, I apprehend, of his being called Candide. The old
servants of the family suspected him to have been the son of the Baron's
sister, by a good, honest gentleman of the neighborhood, whom that young lady
would never marry because he had been able to prove only seventy-one
quarterings, the rest of his genealogical tree having been lost through the
injuries of time.
END
# Default, basic keyword extraction. Try this first:
keywords = TextRank.extract_keywords(text)
# Keyword extraction with all of the bells and whistles:
keywords = TextRank.extract_keywords_advanced(text)
# Fully customized extraction:
extractor = TextRank::KeywordExtractor.new(
strategy: :sparse, # Specify PageRank strategy (dense or sparse)
damping: 0.85, # The probability of following the graph vs. randomly choosing a new node
tolerance: 0.0001, # The desired accuracy of the results
char_filters: [...], # A list of filters to be applied prior to tokenization
tokenizers: [...], # A list of tokenizers to perform tokenization
token_filters: [...], # A list of filters to be applied to each token after tokenization
graph_strategy: ..., # A class or strategy instance for producing a graph from tokens
rank_filters: [...], # A list of filters to be applied to the keyword ranks after keyword extraction
)
# Add another filter to the end of the char_filter chain
extractor.add_char_filter(:AsciiFolding)
# Add a part of speech filter to the token_filter chain BEFORE the Stopwords filter
pos_filter = TextRank::TokenFilter::PartOfSpeech.new(parts_to_keep: %w[nn])
extractor.add_token_filter(pos_filter, before: :Stopwords)
# Perform the extraction with at most 100 iterations
extractor.extract(text, max_iterations: 100)
PageRank
It is also possible to use this gem for PageRank only.
require 'page_rank'
PageRank.calculate(strategy: :sparse, damping: 0.8, tolerance: 0.00001) do
add('node_a', 'node_b', weight: 3.2)
add('node_b', 'node_d', weight: 2.1)
add('node_b', 'node_e', weight: 4.7)
add('node_e', 'node_a', weight: 1.3)
end
There are currently two pure Ruby implementations of PageRank:
- sparse: A sparsely-stored strategy which performs multiplication proportional to the number of edges in the graph. For graphs with a very low node-to-edge ratio, this will perform better in a pure Ruby setting. It is recommended to use this strategy until such a time as there are native implementations.
-
dense: A densely-stored matrix strategy which performs up to
max_iterations
matrix multiplications or until the tolerance is reached. This is more of a canonical implementation and is fine for small or dense graphs, but it is not advised for large, sparse graphs as Ruby is not fast when it comes to matrix multiplication. Each iteration is O(N^3) where N is the number of graph nodes.
License
MIT. See the LICENSE
file.
References
R. Mihalcea and P. Tarau, “TextRank: Bringing Order into Texts,” in Proceedings of EMNLP 2004. Association for Computational Linguistics, 2004, pp. 404–411.
Brin, S.; Page, L. (1998). "The anatomy of a large-scale hypertextual Web search engine". Computer Networks and ISDN Systems 30: 107–117.