利用TextRank算法提取摘要关键词以及Java实现

￡神魔★判官ぃ 2023-10-06 14:00 16阅读 0赞

谈起自动摘要算法，常见的并且最易实现的当属TF-IDF，但是感觉TF-IDF效果一般，不如TextRank好。

# 一. TF-IDF与TextRank #

##    1. TF-IDF简介 ##

TF-IDF（Term Frequency/Inverse Document Frequency）是信息检索领域非常重要的搜索词重要性度量；用以衡量一个关键词w对于查询（Query，可看作文档）所能提供的信息。**词频**（Term Frequency, TF）表示关键词w在文档Di中出现的频率：

![20200731151555155.png][]

其中，count(w)为关键词w的出现次数，|Di|为文档Di中所有词的数量。**逆文档频率**（Inverse Document Frequency, IDF）反映关键词的普遍程度——当一个词越普遍（即有大量文档包含这个词）时，其IDF值越低；反之，则IDF值越高。IDF定义如下：

![20200731151639657.png][]

其中，N为所有的文档总数，I(w,Di)表示文档Di是否包含关键词，若包含则为1，若不包含则为0。若词w在所有文档中均未出现，则IDF公式中的分母为0；因此需要对IDF做平滑（smooth）：

![20200731151719987.png][]

关键词w在文档Di的TF-IDF值：

![format_png][]

从上述定义可以看出：

*  当一个词在文档频率越高并且新鲜度高（即普遍度低），其TF-IDF值越高。
 *  TF-IDF兼顾词频与新鲜度，过滤一些常见词，保留能提供更多信息的重要词。

## **2. TextRank简介** ##

TextRank是在Google的PageRank算法启发下，针对文本里的句子设计的权重算法，目标是自动摘要。它利用投票的原理，让每一个单词给它的邻居（术语称窗口）投赞成票，票的权重取决于自己的票数。这是一个“先有鸡还是先有蛋”的悖论，PageRank采用矩阵迭代收敛的方式解决了这个悖论，TextRank也不例外！

### 2.1 PageRank的计算公式： ###

### 2.2 正规的TextRank公式 ###

正规的TextRank公式在PageRank的公式的基础上，引入了边的权值的概念，代表两个句子的相似度。

![format_png 1][]

但是很明显，如果只想计算关键字，就把一个单词视为一个句子，那么所有句子（单词）构成的边的权重都是0（没有交集，没有相似性），所以分子分母的权值w约掉得了，算法退化为PageRank。所以说，这里称关键字提取算法为PageRank也不为过。

在这里算是简单说明了TextRank的内在原理，以下对其关键词提取应用做进一步说明。

### 2.3 关键词提取算法 ###

TextRank用于关键词提取的算法如下：

*  ①把给定的文本T按照完整句子进行分割，即![format_png 2][]
 *  ②对于每个句子Si属于T，进行分词和词性标注处理，并过滤掉停用词，只保留指定词性的单词，如名词、动词、形容词，即![format_png 3][]

其中 ti,j 是保留后的候选关键词。

*  ③构建候选关键词图G = (V,E)，其中V为节点集，由（2）生成的候选关键词组成，然后采用共现关系（co-occurrence）构造任两点之间的边，两个节点之间存在边仅当它们对应的词汇在长度为K的窗口中共现，K表示窗口大小，即最多共现K个单词。
 *  ④根据上面公式，迭代传播各节点的权重，直至收敛。
 *  ⑤对节点权重进行倒序排序，从而得到最重要的T个单词，作为候选关键词。
 *  ⑥由⑤得到最重要的T个单词，在原始文本中进行标记，若形成相邻词组，则组合成多词关键词。

## **3. 对比总结** ##

*  TextRank与TFIDF均严重依赖于分词结果——如果某词在分词时被切分成了两个词，那么在做关键词提取时无法将两个词黏合在一起（TextRank有部分黏合效果，但需要这两个词均为关键词）。因此是否添加标注关键词进自定义词典，将会造成准确率、召回率大相径庭。
 *  TextRank的效果优于TFIDF。
 *  TextRank并不需要制作特定的语言模型，它只跟当前文章有关。

# 二、TextRank的java实现 #

TextRank的java实现主要参考了[HanLP中开源][HanLP]，将其中的分词工具替换成ANSJ分词

## 1、算法类 ##

import java.util.*;
    
    /**
     * @author summer
     * @date 2020/07/30
     */
    public class Demo {
    
        private static float min_diff = 0.001f; //差值最小
        private static int max_iter = 200;//最大迭代次数
        private static int k = 2;  //窗口大小/2
        private static float d = 0.85f;
    
        private static List<String> textRank(String field, int keywordNum) {
            //分词
            List<WOD<String>> wods = ToAnalysisParse(field);
           // StopWord.filter(wods);//过滤掉不需要的分词，可省略
    
            Map<String, Set<String>> relationWords = new HashMap<>();
            //获取每个关键词 前后k个的组合
            for (int i = 0; i < wods.size(); i++) {
                String keyword = wods.get(i).getName();
                Set<String> keySets = relationWords.get(keyword);
                if (keySets == null) {
                    keySets = new HashSet<>();
                    relationWords.put(keyword, keySets);
                }
    
                for (int j = i - k; j <= i + k; j++) {
                    if (j < 0 || j >= wods.size() || j == i) {
                        continue;
                    } else {
                        keySets.add(wods.get(j).getName());
                    }
                }
            }
    
            Map<String, Float> score = new HashMap<>();
            //迭代
            for (int i = 0; i < max_iter; i++) {
                Map<String, Float> m = new HashMap<>();
                float max_diff = 0;
                for (String key : relationWords.keySet()) {
                    Set<String> value = relationWords.get(key);
                    //先给每个关键词一个默认rank值
                    m.put(key, 1 - d);
                    //一个关键词的TextRank由其它成员投票出来
                    for (String other : value) {
                        int size = relationWords.get(other).size();
                        if (key.equals(other) || size == 0) {
                            continue;
                        } else {
                            m.put(key, m.get(key) + d / size * (score.get(other) == null ? 0 : score.get(other)));
                        }
                    }
                    max_diff = Math.max(max_diff, Math.abs(m.get(key) - (score.get(key) == null ? 0 : score.get(key))));
                }
                score = m;
                if (max_diff <= min_diff) {
    //                System.out.println("迭代次数：" + i);
                    break;
                }
            }
            List<WOD<String>> scores = new ArrayList<>();
            for (String s : score.keySet()) {
                WOD<String> score1 = new WOD(s, score.get(s));
                scores.add(score1);
            }
    
            scores.sort(new Comparator<WOD<String>>() {
                @Override
                public int compare(WOD<String> o1, WOD<String> o2) {
                    return o1.compareTo(o2);
                }
            });
            List<String> keywords = new ArrayList<>();
            int index = 0;
            for (WOD<String> score1 : scores) {
                keywords.add(score1.getName());
                index++;
                if (index==keywordNum)
                    break;
            }
            return keywords;
        }
    
        public static List<WOD<String>> ToAnalysisParse(String str) {
            List<WOD<String>> wods = new ArrayList();
            List<Term> terms = ToAnalysis.parse(str);
            Iterator var4 = terms.iterator();
    
            while(var4.hasNext()) {
                Term term = (Term)var4.next();
                wods.add(new WOD(term.getName(), term.getNatureStr()));
            }
    
            return wods;
        }
    }

## 2、WOD类 ##

import java.io.Serializable;
    
    public class WOD<T> implements Comparable<WOD<T>>, Serializable {
        private static final long serialVersionUID = -2317609898674927526L;
        private T obj;
        private double score;
        private String nature = "";
    
        public WOD() {
        }
    
        public WOD(T obj) {
            this.obj = obj;
        }
    
        public WOD(T obj, double score) {
            this.obj = obj;
            this.score = score;
        }
    
        public WOD(T obj, String nature) {
            this.obj = obj;
            this.nature = nature;
        }
    
        public WOD(T obj, double score, String nature) {
            this.obj = obj;
            this.score = score;
            this.nature = nature;
        }
    
        public String getName() {
            return this.obj.toString();
        }
    
        public void setObj(T obj) {
            this.obj = obj;
        }
    
        public T getObj() {
            return this.obj;
        }
    
        public double getScore() {
            return this.score;
        }
    
        public void setScore(double score) {
            this.score = score;
        }
    
        public String getNature() {
            return this.nature;
        }
    
        public void setNature(String nature) {
            this.nature = nature;
        }
    
        public String toString() {
            return this.getName() + "/" + this.score;
        }
    
        public String toDetailString() {
            return this.getName() + "/" + this.nature + "/" + this.score;
        }
    
        public String toSimpleString() {
            return this.getName();
        }
    
        public int compareTo(WOD<T> o) {
            if (this.score > o.score) {
                return -1;
            } else {
                return this.score == o.score ? 0 : 1;
            }
        }
    
        public boolean equals(Object obj) {
            if (obj instanceof WOD) {
                WOD w = (WOD)obj;
                return w.getName().equals(this.getName());
            } else {
                return false;
            }
        }
    }

## 3、调用方法 ##

public static void main(String[] args) {
            String field = "哈利·波特，40岁生日快乐！ 1991年7月31日，11岁的哈利·波特收到一份特殊的生日礼物——霍格沃兹魔法学校的录取通知书，由此踏上他的魔法之旅……2020年7月31日，陪伴无数青少年长大的哈利迎来了他的40岁生日。 今年也是“哈利·波特”系列小说进入中国20周年，人民文学出版社推出《哈利·波特与魔法石》学院纪念版，包括格兰芬多、斯莱特林、赫奇帕奇和拉文克劳四个学院版本。 31日晚，该社将举办迄今为止最大型的线上直播暨哈利·波特学院杯争夺赛。与此同时，“哈利·波特”系列八部电影正在第23届上海国际电影节展映，第一部电影《哈利·波特与魔法石》4K修复3D版，定档8月14日在内地重映。   ";
    
            List<String> keywords = Demo.textRank(field,10);
            System.out.println("关键词：" + keywords);
        }

4、测试

语料：

> 哈利·波特，40岁生日快乐！
> 
> 1991年7月31日，11岁的哈利·波特收到一份特殊的生日礼物——霍格沃兹魔法学校的录取通知书，由此踏上他的魔法之旅……2020年7月31日，陪伴无数青少年长大的哈利迎来了他的40岁生日。 今年也是“哈利·波特”系列小说进入中国20周年，人民文学出版社推出《哈利·波特与魔法石》学院纪念版，包括格兰芬多、斯莱特林、赫奇帕奇和拉文克劳四个学院版本。 31日晚，该社将举办迄今为止最大型的线上直播暨哈利·波特学院杯争夺赛。与此同时，“哈利·波特”系列八部电影正在第23届上海国际电影节展映，第一部电影《哈利·波特与魔法石》4K修复3D版，定档8月14日在内地重映。

结果：

> 关键词：\[哈利·波特, 学院, 魔法, 电影, 魔法石, 40岁, 无数, 大型, 青少年, 陪伴\]

[20200731151555155.png]: https://img-blog.csdnimg.cn/20200731151555155.png
[20200731151639657.png]: https://img-blog.csdnimg.cn/20200731151639657.png
[20200731151719987.png]: https://img-blog.csdnimg.cn/20200731151719987.png
[format_png]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9waWMxLnpoaW1nLmNvbS84MC92Mi0wYmJhZjlmMWZlZDJmYWFmYTExZDM2ZjJkYjRhYTI0OV83MjB3LmpwZw?x-oss-process=image/format,png
[format_png 1]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9waWNiLnpoaW1nLmNvbS84MC92Mi0wNGIyYzMzMGE3ZjQ3MWU4YjkzZjc4OTYzZTZjMTYxOV83MjB3LmpwZw?x-oss-process=image/format,png
[format_png 2]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9waWMyLnpoaW1nLmNvbS84MC92Mi04YzIwOWVmOTNlNTAzODY0OTYwYTkzNGJjNmE1YjM4OV83MjB3LmpwZw?x-oss-process=image/format,png
[format_png 3]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9waWNiLnpoaW1nLmNvbS84MC92Mi1kOWFiNDU5NjNlMGUyMjdlYmM5OGU4NzE4MDJmYTMxYV83MjB3LmpwZw?x-oss-process=image/format,png
[HanLP]: http://www.hankcs.com/nlp/hanlp.html