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

谈起自动摘要算法,常见的并且最易实现的当属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中出现的频率:

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

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

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

从上述定义可以看出:

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

2. TextRank简介

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

2.1 PageRank的计算公式:

2.2 正规的TextRank公式

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

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

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

2.3 关键词提取算法

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

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

其中 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中开源,将其中的分词工具替换成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岁, 无数, 大型, 青少年, 陪伴]

  • 3
    点赞
  • 28
    收藏
    觉得还不错? 一键收藏
  • 16
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 16
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值