devbox
我家自动化
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

抽取式文本摘要实现_自动摘要抽取式摘要怎么做

作者：我家自动化 | 2024-03-21 15:05:51

赞

踩

自动摘要抽取式摘要怎么做

1、介绍

 

　　　　　1、本文自动文本摘要实现的依据就是词频统计

　　　　　2、文章是由句子组成的，文章的信息都包含在句子中，有些句子包含的信息多，有些句子包含的信息少。

　　　　　3、句子的信息量用"关键词"来衡量。如果包含的关键词越多，就说明这个句子越重要。

　　　　　4、"自动摘要"就是要找出那些包含信息最多的句子，也就是包含关键字最多的句子

　　　　　5、而通过统计句子中关键字的频率的大小，进而进行排序，通过对排序的词频列表对文档中句子逐个进行打分，进而把打分高的句子找出来，就是我们要的摘要。

2、实现步骤

　　　　1、加载停用词

　　　　2、将文档拆分成句子列表

　　　　3、将句子列表分词

　　　　4、统计词频，取出100个最高的关键字

　　　　5、根据词频对句子列表进行打分

　　　　6、取出打分较高的前5个句子

　　3、原理

　　　　这种方法最早出自1958年的IBM公司科学家H.P. Luhn的论文《The Automatic Creation of Literature Abstracts》。Luhn提出用"簇"（cluster）表示关键词的聚集。所谓"簇"就是包含多个关键词的句子片段。

　　　　

　　　　上图就是Luhn原始论文的插图，被框起来的部分就是一个"簇"。只要关键词之间的距离小于"门槛值"，它们就被认为处于同一个簇之中。Luhn建议的门槛值是4或5。

　　　　也就是说，如果两个关键词之间有5个以上的其他词，就可以把这两个关键词分在两个簇。

　　　　簇重要性分值计算公式：

　　　　

　　　　以前图为例，其中的簇一共有7个词，其中4个是关键词。因此，它的重要性分值等于 ( 4 x 4 ) / 7 = 2.3。

　　　　然后，找出包含分值最高的簇的句子（比如前5句），把它们合在一起，就构成了这篇文章的自动摘要

　　4、相关代码

　　python实现代码：

  1. #!/usr/bin/env python
  2. # -*- coding:utf-8 -*- 
  3. # Author: Jia ShiLin
  4.  
  5. #!/user/bin/python
  6. # coding:utf-8
  7.  
  8. import nltk
  9. import numpy
  10. import jieba
  11. import codecs
  12. import os
  13.  
  14. class SummaryTxt:
  15.     def __init__(self,stopwordspath):
  16.         # 单词数量
  17.         self.N = 100
  18.         # 单词间的距离
  19.         self.CLUSTER_THRESHOLD = 5
  20.         # 返回的top n句子
  21.         self.TOP_SENTENCES = 5
  22.         self.stopwrods = {}
  23.         #加载停用词
  24.         if os.path.exists(stopwordspath):
  25.             stoplist = [line.strip() for line in codecs.open(stopwordspath, 'r', encoding='utf8').readlines()]
  26.             self.stopwrods = {}.fromkeys(stoplist)
  27.  
  28.  
  29.     def _split_sentences(self,texts):
  30.         '''
  31.         把texts拆分成单个句子，保存在列表里面，以（.!?。！？）这些标点作为拆分的意见，
  32.         :param texts: 文本信息
  33.         :return:
  34.         '''
  35.         splitstr = '.!?。！？'#.decode('utf8')
  36.         start = 0
  37.         index = 0  # 每个字符的位置
  38.         sentences = []
  39.         for text in texts:
  40.             if text in splitstr:  # 检查标点符号下一个字符是否还是标点
  41.                 sentences.append(texts[start:index + 1])  # 当前标点符号位置
  42.                 start = index + 1  # start标记到下一句的开头
  43.             index += 1
  44.         if start < len(texts):
  45.             sentences.append(texts[start:])  # 这是为了处理文本末尾没有标
  46.  
  47.         return sentences
  48.  
  49.     def _score_sentences(self,sentences, topn_words):
  50.         '''
  51.         利用前N个关键字给句子打分
  52.         :param sentences: 句子列表
  53.         :param topn_words: 关键字列表
  54.         :return:
  55.         '''
  56.         scores = []
  57.         sentence_idx = -1
  58.         for s in [list(jieba.cut(s)) for s in sentences]:
  59.             sentence_idx += 1
  60.             word_idx = []
  61.             for w in topn_words:
  62.                 try:
  63.                     word_idx.append(s.index(w))  # 关键词出现在该句子中的索引位置
  64.                 except ValueError:  # w不在句子中
  65.                     pass
  66.             word_idx.sort()
  67.             if len(word_idx) == 0:
  68.                 continue
  69.             # 对于两个连续的单词，利用单词位置索引，通过距离阀值计算族
  70.             clusters = []
  71.             cluster = [word_idx[0]]
  72.             i = 1
  73.             while i < len(word_idx):
  74.                 if word_idx[i] - word_idx[i - 1] < self.CLUSTER_THRESHOLD:
  75.                     cluster.append(word_idx[i])
  76.                 else:
  77.                     clusters.append(cluster[:])
  78.                     cluster = [word_idx[i]]
  79.                 i += 1
  80.             clusters.append(cluster)
  81.             # 对每个族打分，每个族类的最大分数是对句子的打分
  82.             max_cluster_score = 0
  83.             for c in clusters:
  84.                 significant_words_in_cluster = len(c)
  85.                 total_words_in_cluster = c[-1] - c[0] + 1
  86.                 score = 1.0 * significant_words_in_cluster * significant_words_in_cluster / total_words_in_cluster
  87.                 if score > max_cluster_score:
  88.                     max_cluster_score = score
  89.             scores.append((sentence_idx, max_cluster_score))
  90.         return scores
  91.  
  92.     def summaryScoredtxt(self,text):
  93.         # 将文章分成句子
  94.         sentences = self._split_sentences(text)
  95.  
  96.         # 生成分词
  97.         words = [w for sentence in sentences for w in jieba.cut(sentence) if w not in self.stopwrods if
  98.                  len(w) > 1 and w != '\t']
  99.         # words = []
  100.         # for sentence in sentences:
  101.         #     for w in jieba.cut(sentence):
  102.         #         if w not in stopwords and len(w) > 1 and w != '\t':
  103.         #             words.append(w)
  104.  
  105.         # 统计词频
  106.         wordfre = nltk.FreqDist(words)
  107.  
  108.         # 获取词频最高的前N个词
  109.         topn_words = [w[0] for w in sorted(wordfre.items(), key=lambda d: d[1], reverse=True)][:self.N]
  110.  
  111.         # 根据最高的n个关键词，给句子打分
  112.         scored_sentences = self._score_sentences(sentences, topn_words)
  113.  
  114.         # 利用均值和标准差过滤非重要句子
  115.         avg = numpy.mean([s[1] for s in scored_sentences])  # 均值
  116.         std = numpy.std([s[1] for s in scored_sentences])  # 标准差
  117.         summarySentences = []
  118.         for (sent_idx, score) in scored_sentences:
  119.             if score > (avg + 0.5 * std):
  120.                 summarySentences.append(sentences[sent_idx])
  121.                 print (sentences[sent_idx])
  122.         return summarySentences
  123.  
  124.     def summaryTopNtxt(self,text):
  125.         # 将文章分成句子
  126.         sentences = self._split_sentences(text)
  127.  
  128.         # 根据句子列表生成分词列表
  129.         words = [w for sentence in sentences for w in jieba.cut(sentence) if w not in self.stopwrods if
  130.                  len(w) > 1 and w != '\t']
  131.         # words = []
  132.         # for sentence in sentences:
  133.         #     for w in jieba.cut(sentence):
  134.         #         if w not in stopwords and len(w) > 1 and w != '\t':
  135.         #             words.append(w)
  136.  
  137.         # 统计词频
  138.         wordfre = nltk.FreqDist(words)
  139.  
  140.         # 获取词频最高的前N个词
  141.         topn_words = [w[0] for w in sorted(wordfre.items(), key=lambda d: d[1], reverse=True)][:self.N]
  142.  
  143.         # 根据最高的n个关键词，给句子打分
  144.         scored_sentences = self._score_sentences(sentences, topn_words)
  145.  
  146.         top_n_scored = sorted(scored_sentences, key=lambda s: s[1])[-self.TOP_SENTENCES:]
  147.         top_n_scored = sorted(top_n_scored, key=lambda s: s[0])
  148.         summarySentences = []
  149.         for (idx, score) in top_n_scored:
  150.             print( sentences[idx])
  151.             summarySentences.append(sentences[idx])
  152.  
  153.         return sentences
  154.  
  155.  
  156.  
  157. if __name__=='__main__':
  158.     obj =SummaryTxt('stopword.txt')
  159.  
  160.     # txt=u'十八大以来的五年，是党和国家发展进程中极不平凡的五年。面对世界经济复苏乏力、局部冲突和动荡频发、全球性问题加剧的外部环境，面对我国经济发展进入新常态等一系列深刻变化，我们坚持稳中求进工作总基调，迎难而上，开拓进取，取得了改革开放和社会主义现代化建设的历史性成就。' \
  161.     #     u'为贯彻十八大精神，党中央召开七次全会，分别就政府机构改革和职能转变、全面深化改革、全面推进依法治国、制定“十三五”规划、全面从严治党等重大问题作出决定和部署。五年来，我们统筹推进“五位一体”总体布局、协调推进“四个全面”战略布局，“十二五”规划胜利完成，“十三五”规划顺利实施，党和国家事业全面开创新局面。' \
  162.     #     u'经济建设取得重大成就。坚定不移贯彻新发展理念，坚决端正发展观念、转变发展方式，发展质量和效益不断提升。经济保持中高速增长，在世界主要国家中名列前茅，国内生产总值从五十四万亿元增长到八十万亿元，稳居世界第二，对世界经济增长贡献率超过百分之三十。供给侧结构性改革深入推进，经济结构不断优化，数字经济等新兴产业蓬勃发展，高铁、公路、桥梁、港口、机场等基础设施建设快速推进。农业现代化稳步推进，粮食生产能力达到一万二千亿斤。城镇化率年均提高一点二个百分点，八千多万农业转移人口成为城镇居民。区域发展协调性增强，“一带一路”建设、京津冀协同发展、长江经济带发展成效显著。创新驱动发展战略大力实施，创新型国家建设成果丰硕，天宫、蛟龙、天眼、悟空、墨子、大飞机等重大科技成果相继问世。南海岛礁建设积极推进。开放型经济新体制逐步健全，对外贸易、对外投资、外汇储备稳居世界前列。' \
  163.     #     u'全面深化改革取得重大突破。蹄疾步稳推进全面深化改革，坚决破除各方面体制机制弊端。改革全面发力、多点突破、纵深推进，着力增强改革系统性、整体性、协同性，压茬拓展改革广度和深度，推出一千五百多项改革举措，重要领域和关键环节改革取得突破性进展，主要领域改革主体框架基本确立。中国特色社会主义制度更加完善，国家治理体系和治理能力现代化水平明显提高，全社会发展活力和创新活力明显增强。'
  164.  
  165.     # txt ='The information disclosed by the Film Funds Office of the State Administration of Press, Publication, Radio, Film and Television shows that, the total box office in China amounted to nearly 3 billion yuan during the first six days of the lunar year (February 8 - 13), an increase of 67% compared to the 1.797 billion yuan in the Chinese Spring Festival period in 2015, becoming the "Best Chinese Spring Festival Period in History".' \
  166.     #      'During the Chinese Spring Festival period, "The Mermaid" contributed to a box office of 1.46 billion yuan. "The Man From Macau III" reached a box office of 680 million yuan. "The Journey to the West: The Monkey King 2" had a box office of 650 million yuan. "Kung Fu Panda 3" also had a box office of exceeding 130 million. These four blockbusters together contributed more than 95% of the total box office during the Chinese Spring Festival period.' \
  167.     #      'There were many factors contributing to the popularity during the Chinese Spring Festival period. Apparently, the overall popular film market with good box office was driven by the emergence of a few blockbusters. In fact, apart from the appeal of the films, other factors like film ticket subsidy of online seat-selection companies, cinema channel sinking and the film-viewing heat in the middle and small cities driven by the home-returning wave were all main factors contributing to this blowout. A management of Shanghai Film Group told the 21st Century Business Herald.'
  168.     txt = 'Monetary policy summary The Bank of England’s Monetary Policy Committee (MPC) sets monetary policy in order to meet the 2% inflation target and in a way that helps to sustain growth and employment.  At its meeting ending on 5 August 2015, the MPC voted by a majority of 8-1 to maintain Bank Rate at 0.5%.  The Committee voted unanimously to maintain the stock of purchased assets financed by the issuance of central bank reserves at £375 billion, and so to reinvest the £16.9 billion of cash flows associated with the redemption of the September 2015 gilt held in the Asset Purchase Facility. CPI inflation fell back to zero in June.  As set out in the Governor’s open letter to the Chancellor, around three quarters of the deviation of inflation from the 2% target, or 1½ percentage points, reflects unusually low contributions from energy, food, and other imported goods prices.  The remaining quarter of the deviation of inflation from target, or ½ a percentage point, reflects the past weakness of domestic cost growth, and unit labour costs in particular.  The combined weakness in domestic costs and imported goods prices is evident in subdued core inflation, which on most measures is currently around 1%. With some underutilised resources remaining in the economy and with inflation below the target, the Committee intends to set monetary policy in order to ensure that growth is sufficient to absorb the remaining economic slack so as to return inflation to the target within two years.  Conditional upon Bank Rate following the gently rising path implied by market yields, the Committee judges that this is likely to be achieved. In its latest economic projections, the Committee projects UK-weighted world demand to expand at a moderate pace.  Growth in advanced economies is expected to be a touch faster, and growth in emerging economies a little slower, than in the past few years.  The support to UK exports from steady global demand growth is expected to be counterbalanced, however, by the effect of the past appreciation of sterling.  Risks to global growth are judged to be skewed moderately to the downside reflecting, for example, risks to activity in the euro area and China. Private domestic demand growth in the United Kingdom is expected to remain robust.  Household spending has been supported by the boost to real incomes from lower food and energy prices.  Wage growth has picked up as the labour market has tightened and productivity has strengthened.  Business and consumer confidence remain high, while credit conditions have continued to improve, with historically low mortgage rates providing support to activity in the housing market.  Business investment has made a substantial contribution to growth in recent years.  Firms have invested to expand capacity, supported by accommodative financial conditions.  Despite weakening slightly, surveys suggest continued robust investment growth ahead.  This will support the continuing increase of underlying productivity growth towards past average rates. Robust private domestic demand is expected to produce sufficient momentum to eliminate the margin of spare capacity over the next year or so, despite the continuing fiscal consolidation and modest global growth.  This is judged likely to generate the rise in domestic costs expected to be necessary to return inflation to the target in the medium term. The near-term outlook for inflation is muted.  The falls in energy prices of the past few months will continue to bear down on inflation at least until the middle of next year.  Nonetheless, a range of measures suggest that medium-term inflation expectations remain well anchored.  There is little evidence in wage settlements or spending patterns of any deflationary mindset among businesses and households. Sterling has appreciated by 3½% since May and 20% since its trough in March 2013.  The drag on import prices from this appreciation will continue to push down on inflation for some time to come, posing a downside risk to its path in the near term.  Set against that, the degree of slack in the economy has diminished substantially over the past two and a half years.  The unemployment rate has fallen by more than 2 percentage points since the middle of 2013, and the ratio of job vacancies to unemployment has returned from well below to around its pre-crisis average.  The margin of spare capacity is currently judged to be around ½% of GDP, with a range of views among MPC members around that central estimate.  A further modest tightening of the labour market is expected, supporting a continued firming in the growth of wages and unit labour costs over the next three years, counterbalancing the drag on inflation from sterling. Were Bank Rate to follow the gently rising path implied by market yields, the Committee judges that demand growth would be sufficient to return inflation to the target within two years.  In its projections, inflation then moves slightly above the target in the third year of the forecast period as sustained growth leads to a degree of excess demand. Underlying those projections are significant judgements in a number of areas, as described in the August Inflation Report.  In any one of these areas, developments might easily turn out differently than assumed with implications for the outlook for growth and inflation, and therefore for the appropriate stance of monetary policy.  Reflecting that, there is a spread of views among MPC members about the balance of risks to inflation relative to the best collective judgement presented in the August Report.  At the Committee’s meeting ending on 5 August, the majority of MPC members judged it appropriate to leave the stance of monetary policy unchanged at present.  Ian McCafferty preferred to increase Bank Rate by 25 basis points, given his view that demand growth and wage pressures were likely to be greater, and the margin of spare capacity smaller, than embodied in the Committee’s collective August projections. All members agree that, given the likely persistence of the headwinds weighing on the economy, when Bank Rate does begin to rise, it is expected to do so more gradually and to a lower level than in recent cycles.  This guidance is an expectation, not a promise.  The actual path Bank Rate will follow over the next few years will depend on the economic circumstances.  The Committee will continue to monitor closely the incoming data.'
  169.     print (txt)
  170.     print ("--")
  171.     obj.summaryScoredtxt(txt)
  172.  
  173.     print ("----")
  174.     obj.summaryTopNtxt(txt)

　　java实现代码：

  1. //import com.hankcs.hanlp.HanLP;
  2.  
  3. import java.io.BufferedReader;
  4. import java.io.InputStreamReader;
  5. import java.io.FileInputStream;
  6. import java.io.IOException;
  7. import java.io.Reader;
  8. import java.io.StringReader;
  9. import java.util.ArrayList;
  10. import java.util.Collections;
  11. import java.util.Comparator;
  12. import java.util.HashMap;
  13. import java.util.HashSet;
  14. import java.util.LinkedHashMap;
  15. import java.util.List;
  16. import java.util.Map;
  17. import java.util.Map.Entry;
  18. import java.util.PriorityQueue;
  19. import java.util.Queue;
  20. import java.util.Set;
  21. import java.util.TreeMap;
  22. import java.util.regex.Pattern;
  23. import java.util.regex.Matcher;
  24.  
  25. //import com.hankcs.hanlp.seg.common.Term;
  26. import org.wltea.analyzer.core.IKSegmenter;
  27. import org.wltea.analyzer.core.Lexeme;
  28. /**
  29.  * @Author：sks
  30.  * @Description：文本摘要提取文中重要的关键句子，使用top-n关键词在句子中的比例关系
  31.  * 返回过滤句子方法为：1.均值标准差，2.top-n句子，3.最大边缘相关top-n句子
  32.  * @Date：Created in 16:40 2017/12/22
  33.  * @Modified by：
  34.  **/
  35. public class NewsSummary {
  36.     //保留关键词数量
  37.     int N = 50;
  38.  
  39.     //关键词间的距离阀值
  40.     int CLUSTER_THRESHOLD = 5;
  41.  
  42.     //前top-n句子
  43.     int TOP_SENTENCES = 10;
  44.  
  45.     //最大边缘相关阀值
  46.     double λ = 0.4;
  47.  
  48.     //句子得分使用方法
  49.     final Set<String> styleSet = new HashSet<String>();
  50.  
  51.     //停用词列表
  52.     Set<String> stopWords = new HashSet<String>();
  53.  
  54.     //句子编号及分词列表
  55.     Map<Integer,List<String>> sentSegmentWords = null;
  57.     public NewsSummary(){
  58.         this.loadStopWords("D:\\work\\Solr\\solr-python\\CNstopwords.txt");
  59.         styleSet.add("meanstd");
  60.         styleSet.add("default");
  61.         styleSet.add("MMR");
  62.     }
  63.  
  64.     /**
  65.      * 加载停词
  66.      * @param path
  67.      */
  68.     private void loadStopWords(String path){
  69.         BufferedReader br=null;
  70.         try
  71.         {
  72.             InputStreamReader reader = new InputStreamReader(new FileInputStream(path),"utf-8");
  73.             br = new BufferedReader(reader);
  74.             String line=null;
  75.             while((line=br.readLine())!=null)
  76.             {
  77.                 stopWords.add(line);
  78.             }
  79.             br.close();
  80.         }catch(IOException e){
  81.             e.printStackTrace();
  82.         }
  83.     }
  84.  
  85.     /**
  86.      * @Author：sks
  87.      * @Description：利用正则将文本拆分成句子
  88.      * @Date：
  89.      */
  90.     private List<String> SplitSentences(String text){
  91.         List<String> sentences = new ArrayList<String>();
  92.         String regEx = "[!?。！？.]";
  93.         Pattern p = Pattern.compile(regEx);
  94.         String[] sents = p.split(text);
  95.         Matcher m = p.matcher(text);
  96.  
  97.         int sentsLen = sents.length;
  98.         if(sentsLen>0)
  99.         {  //把每个句子的末尾标点符号加上
  100.             int index = 0;
  101.             while(index < sentsLen)
  102.             {
  103.                 if(m.find())
  104.                 {
  105.                     sents[index] += m.group();
  106.                 }
  107.                 index++;
  108.             }
  109.         }
  110.         for(String sentence:sents){
  111.             //文章从网页上拷贝过来后遗留下来的没有处理掉的html的标志
  112.             sentence=sentence.replaceAll("(&rdquo;|&ldquo;|&mdash;|&lsquo;|&rsquo;|&middot;|&quot;|&darr;|&bull;)", "");
  113.             sentences.add(sentence.trim());
  114.         }
  115.         return sentences;
  116.     }
  117.  
  118.     /**
  119.      * 这里使用IK进行分词
  120.      * @param text
  121.      * @return
  122.      */
  123.     private List<String> IKSegment(String text){
  124.         List<String> wordList = new ArrayList<String>();
  125.         Reader reader = new StringReader(text);
  126.         IKSegmenter ik = new IKSegmenter(reader,true);
  127.         Lexeme lex = null;
  128.         try {
  129.             while((lex=ik.next())!=null)
  130.             {
  131.                 String word=lex.getLexemeText();
  132.                 if(word.equals("nbsp") || this.stopWords.contains(word))
  133.                     continue;
  134.                 if(word.length()>1 && word!="\t")
  135.                     wordList.add(word);
  136.             }
  137.         } catch (IOException e) {
  138.             e.printStackTrace();
  139.         }
  140.         return wordList;
  141.     }
  142.  
  143.  
  144.     /**
  145.      * 每个句子得分  (keywordsLen*keywordsLen/totalWordsLen)
  146.      * @param sentences 分句
  147.      * @param topnWords keywords top-n关键词
  148.      * @return
  149.      */
  150.     private Map<Integer,Double> scoreSentences(List<String> sentences,List<String> topnWords){
  151.         Map<Integer, Double> scoresMap=new LinkedHashMap<Integer,Double>();//句子编号，得分
  152.         sentSegmentWords=new HashMap<Integer,List<String>>();
  153.         int sentence_idx=-1;//句子编号
  154.         for(String sentence:sentences){
  155.             sentence_idx+=1;
  156.             List<String> words=this.IKSegment(sentence);//对每个句子分词
  157. //            List<String> words= HanLP.segment(sentence);
  158.             sentSegmentWords.put(sentence_idx, words);
  159.             List<Integer> word_idx=new ArrayList<Integer>();//每个关词键在本句子中的位置
  160.             for(String word:topnWords){
  161.                 if(words.contains(word)){
  162.                     word_idx.add(words.indexOf(word));
  163.                 }else
  164.                     continue;
  165.             }
  166.             if(word_idx.size()==0)
  167.                 continue;
  168.             Collections.sort(word_idx);
  169.             //对于两个连续的单词，利用单词位置索引，通过距离阀值计算一个族
  170.             List<List<Integer>> clusters=new ArrayList<List<Integer>>();//根据本句中的关键词的距离存放多个词族
  171.             List<Integer> cluster=new ArrayList<Integer>();
  172.             cluster.add(word_idx.get(0));
  173.             int i=1;
  174.             while(i<word_idx.size()){
  175.                 if((word_idx.get(i)-word_idx.get(i-1))<this.CLUSTER_THRESHOLD)
  176.                     cluster.add(word_idx.get(i));
  177.                 else{
  178.                     clusters.add(cluster);
  179.                     cluster=new ArrayList<Integer>();
  180.                     cluster.add(word_idx.get(i));
  181.                 }
  182.                 i+=1;
  183.             }
  184.             clusters.add(cluster);
  185.             //对每个词族打分，选择最高得分作为本句的得分
  186.             double max_cluster_score=0.0;
  187.             for(List<Integer> clu:clusters){
  188.                 int keywordsLen=clu.size();//关键词个数
  189.                 int totalWordsLen=clu.get(keywordsLen-1)-clu.get(0)+1;//总的词数
  190.                 double score=1.0*keywordsLen*keywordsLen/totalWordsLen;
  191.                 if(score>max_cluster_score)
  192.                     max_cluster_score=score;
  193.             }
  194.             scoresMap.put(sentence_idx,max_cluster_score);
  195.         }
  196.         return scoresMap;
  197.     }
  198.  
  199.  
  200.     /**
  201.     * @Author：sks
  202.     * @Description：利用均值方差自动文摘
  203.     * @Date：
  204.     */
  205.     public String SummaryMeanstdTxt(String text){
  206.         //将文本拆分成句子列表
  207.         List<String> sentencesList = this.SplitSentences(text);
  208.  
  209.         //利用IK分词组件将文本分词，返回分词列表
  210.         List<String> words = this.IKSegment(text);
  211. //        List<Term> words1= HanLP.segment(text);
  212.  
  213.         //统计分词频率
  214.         Map<String,Integer> wordsMap = new HashMap<String,Integer>();
  215.         for(String word:words){
  216.             Integer val = wordsMap.get(word);
  217.             wordsMap.put(word,val == null ? 1: val + 1);
  218.  
  219.         }
  220.  
  221.  
  222.         //使用优先队列自动排序
  223.         Queue<Map.Entry<String, Integer>> wordsQueue=new PriorityQueue<Map.Entry<String,Integer>>(wordsMap.size(),new Comparator<Map.Entry<String,Integer>>()
  224.         {
  225.             //            @Override
  226.             public int compare(Entry<String, Integer> o1,
  227.                                Entry<String, Integer> o2) {
  228.                 return o2.getValue()-o1.getValue();
  229.             }
  230.         });
  231.         wordsQueue.addAll(wordsMap.entrySet());
  232.  
  233.         if( N > wordsMap.size())
  234.             N = wordsQueue.size();
  235.  
  236.         //取前N个频次最高的词存在wordsList
  237.         List<String> wordsList = new ArrayList<String>(N);//top-n关键词
  238.         for(int i = 0;i < N;i++){
  239.             Entry<String,Integer> entry= wordsQueue.poll();
  240.             wordsList.add(entry.getKey());
  241.         }
  242.  
  243.         //利用频次关键字，给句子打分，并对打分后句子列表依据得分大小降序排序
  244.         Map<Integer,Double> scoresLinkedMap = scoreSentences(sentencesList,wordsList);//返回的得分,从第一句开始,句子编号的自然顺序
  245.  
  246.  
  247.  
  248.         //approach1,利用均值和标准差过滤非重要句子
  249.         Map<Integer,String> keySentence = new LinkedHashMap<Integer,String>();
  250.  
  251.         //句子得分均值
  252.         double sentenceMean = 0.0;
  253.         for(double value:scoresLinkedMap.values()){
  254.             sentenceMean += value;
  255.         }
  256.         sentenceMean /= scoresLinkedMap.size();
  257.  
  258.         //句子得分标准差
  259.         double sentenceStd=0.0;
  260.         for(Double score:scoresLinkedMap.values()){
  261.             sentenceStd += Math.pow((score-sentenceMean), 2);
  262.         }
  263.         sentenceStd = Math.sqrt(sentenceStd / scoresLinkedMap.size());
  264.  
  265.         for(Map.Entry<Integer, Double> entry:scoresLinkedMap.entrySet()){
  266.             //过滤低分句子
  267.             if(entry.getValue()>(sentenceMean+0.5*sentenceStd))
  268.                 keySentence.put(entry.getKey(), sentencesList.get(entry.getKey()));
  269.         }
  270.  
  271.         StringBuilder sb = new StringBuilder();
  272.         for(int  index:keySentence.keySet())
  273.             sb.append(keySentence.get(index));
  274.         return sb.toString();
  275.     }
  276.  
  277.     /**
  278.     * @Author：sks
  279.     * @Description：默认返回排序得分top-n句子
  280.     * @Date：
  281.     */
  282.     public String SummaryTopNTxt(String text){
  283.         //将文本拆分成句子列表
  284.         List<String> sentencesList = this.SplitSentences(text);
  285.  
  286.         //利用IK分词组件将文本分词，返回分词列表
  287.         List<String> words = this.IKSegment(text);
  288. //        List<Term> words1= HanLP.segment(text);
  289.  
  290.         //统计分词频率
  291.         Map<String,Integer> wordsMap = new HashMap<String,Integer>();
  292.         for(String word:words){
  293.             Integer val = wordsMap.get(word);
  294.             wordsMap.put(word,val == null ? 1: val + 1);
  295.  
  296.         }
  297.  
  298.  
  299.         //使用优先队列自动排序
  300.         Queue<Map.Entry<String, Integer>> wordsQueue=new PriorityQueue<Map.Entry<String,Integer>>(wordsMap.size(),new Comparator<Map.Entry<String,Integer>>()
  301.         {
  302.             //            @Override
  303.             public int compare(Entry<String, Integer> o1,
  304.                                Entry<String, Integer> o2) {
  305.                 return o2.getValue()-o1.getValue();
  306.             }
  307.         });
  308.         wordsQueue.addAll(wordsMap.entrySet());
  309.  
  310.         if( N > wordsMap.size())
  311.             N = wordsQueue.size();
  312.  
  313.         //取前N个频次最高的词存在wordsList
  314.         List<String> wordsList = new ArrayList<String>(N);//top-n关键词
  315.         for(int i = 0;i < N;i++){
  316.             Entry<String,Integer> entry= wordsQueue.poll();
  317.             wordsList.add(entry.getKey());
  318.         }
  319.  
  320.         //利用频次关键字，给句子打分，并对打分后句子列表依据得分大小降序排序
  321.         Map<Integer,Double> scoresLinkedMap = scoreSentences(sentencesList,wordsList);//返回的得分,从第一句开始,句子编号的自然顺序
  322.         List<Map.Entry<Integer, Double>> sortedSentList = new ArrayList<Map.Entry<Integer,Double>>(scoresLinkedMap.entrySet());//按得分从高到底排序好的句子，句子编号与得分
  323.         //System.setProperty("java.util.Arrays.useLegacyMergeSort", "true");
  324.         Collections.sort(sortedSentList, new Comparator<Map.Entry<Integer, Double>>(){
  325.             //            @Override
  326.             public int compare(Entry<Integer, Double> o1,Entry<Integer, Double> o2) {
  327.                 return o2.getValue() == o1.getValue() ? 0 :
  328.                         (o2.getValue() > o1.getValue() ? 1 : -1);
  329.             }
  330.  
  331.         });
  332.  
  333.         //approach2,默认返回排序得分top-n句子
  334.         Map<Integer,String> keySentence = new TreeMap<Integer,String>();
  335.         int count = 0;
  336.         for(Map.Entry<Integer, Double> entry:sortedSentList){
  337.             count++;
  338.             keySentence.put(entry.getKey(), sentencesList.get(entry.getKey()));
  339.             if(count == this.TOP_SENTENCES)
  340.                 break;
  341.         }
  342.  
  343.         StringBuilder sb=new StringBuilder();
  344.         for(int  index:keySentence.keySet())
  345.             sb.append(keySentence.get(index));
  346.         return sb.toString();
  347.     }
  348.  
  349.     /**
  350.     * @Author：sks
  351.     * @Description：利用最大边缘相关自动文摘
  352.     * @Date：
  353.     */
  354.     public String SummaryMMRNTxt(String text){
  355.         //将文本拆分成句子列表
  356.         List<String> sentencesList = this.SplitSentences(text);
  357.  
  358.         //利用IK分词组件将文本分词，返回分词列表
  359.         List<String> words = this.IKSegment(text);
  360. //        List<Term> words1= HanLP.segment(text);
  361.  
  362.         //统计分词频率
  363.         Map<String,Integer> wordsMap = new HashMap<String,Integer>();
  364.         for(String word:words){
  365.             Integer val = wordsMap.get(word);
  366.             wordsMap.put(word,val == null ? 1: val + 1);
  367.  
  368.         }
  369.  
  370.  
  371.         //使用优先队列自动排序
  372.         Queue<Map.Entry<String, Integer>> wordsQueue=new PriorityQueue<Map.Entry<String,Integer>>(wordsMap.size(),new Comparator<Map.Entry<String,Integer>>()
  373.         {
  374.             //            @Override
  375.             public int compare(Entry<String, Integer> o1,
  376.                                Entry<String, Integer> o2) {
  377.                 return o2.getValue()-o1.getValue();
  378.             }
  379.         });
  380.         wordsQueue.addAll(wordsMap.entrySet());
  381.  
  382.         if( N > wordsMap.size())
  383.             N = wordsQueue.size();
  384.  
  385.         //取前N个频次最高的词存在wordsList
  386.         List<String> wordsList = new ArrayList<String>(N);//top-n关键词
  387.         for(int i = 0;i < N;i++){
  388.             Entry<String,Integer> entry= wordsQueue.poll();
  389.             wordsList.add(entry.getKey());
  390.         }
  391.  
  392.         //利用频次关键字，给句子打分，并对打分后句子列表依据得分大小降序排序
  393.         Map<Integer,Double> scoresLinkedMap = scoreSentences(sentencesList,wordsList);//返回的得分,从第一句开始,句子编号的自然顺序
  394.         List<Map.Entry<Integer, Double>> sortedSentList = new ArrayList<Map.Entry<Integer,Double>>(scoresLinkedMap.entrySet());//按得分从高到底排序好的句子，句子编号与得分
  395.         //System.setProperty("java.util.Arrays.useLegacyMergeSort", "true");
  396.         Collections.sort(sortedSentList, new Comparator<Map.Entry<Integer, Double>>(){
  397.             //            @Override
  398.             public int compare(Entry<Integer, Double> o1,Entry<Integer, Double> o2) {
  399.                 return o2.getValue() == o1.getValue() ? 0 :
  400.                         (o2.getValue() > o1.getValue() ? 1 : -1);
  401.             }
  402.  
  403.         });
  404.  
  405.         //approach3,利用最大边缘相关，返回前top-n句子
  406.         if(sentencesList.size()==2)
  407.         {
  408.             return sentencesList.get(0)+sentencesList.get(1);
  409.         }
  410.         else if(sentencesList.size()==1)
  411.             return sentencesList.get(0);
  412.         Map<Integer,String> keySentence = new TreeMap<Integer,String>();
  413.         int count = 0;
  414.         Map<Integer,Double> MMR_SentScore = MMR(sortedSentList);
  415.         for(Map.Entry<Integer, Double> entry:MMR_SentScore.entrySet())
  416.         {
  417.             count++;
  418.             int sentIndex=entry.getKey();
  419.             String sentence=sentencesList.get(sentIndex);
  420.             keySentence.put(sentIndex, sentence);
  421.             if(count==this.TOP_SENTENCES)
  422.                 break;
  423.         }
  424.  
  425.         StringBuilder sb=new StringBuilder();
  426.         for(int  index:keySentence.keySet())
  427.             sb.append(keySentence.get(index));
  428.         return sb.toString();
  429.     }
  430.     /**
  431.      * 计算文本摘要
  432.      * @param text
  433.      * @param style(meanstd,default,MMR)
  434.      * @return
  435.      */
  436.     public String summarize(String text,String style){
  437.         try {
  438.             if(!styleSet.contains(style) || text.trim().equals(""))
  439.                 throw new IllegalArgumentException("方法 summarize(String text,String style)中text不能为空，style必须是meanstd、default或者MMR");
  440.         } catch (Exception e) {
  441.             // TODO Auto-generated catch block
  442.             e.printStackTrace();
  443.             System.exit(1);
  444.         }
  445.  
  446.         //将文本拆分成句子列表
  447.         List<String> sentencesList = this.SplitSentences(text);
  448.  
  449.         //利用IK分词组件将文本分词，返回分词列表
  450.         List<String> words = this.IKSegment(text);
  451. //        List<Term> words1= HanLP.segment(text);
  452.  
  453.         //统计分词频率
  454.         Map<String,Integer> wordsMap = new HashMap<String,Integer>();
  455.         for(String word:words){
  456.             Integer val = wordsMap.get(word);
  457.             wordsMap.put(word,val == null ? 1: val + 1);
  458.  
  459.         }
  460.  
  461.  
  462.         //使用优先队列自动排序
  463.         Queue<Map.Entry<String, Integer>> wordsQueue=new PriorityQueue<Map.Entry<String,Integer>>(wordsMap.size(),new Comparator<Map.Entry<String,Integer>>()
  464.         {
  465. //            @Override
  466.             public int compare(Entry<String, Integer> o1,
  467.                                Entry<String, Integer> o2) {
  468.                 return o2.getValue()-o1.getValue();
  469.             }
  470.         });
  471.         wordsQueue.addAll(wordsMap.entrySet());
  472.  
  473.         if( N > wordsMap.size())
  474.             N = wordsQueue.size();
  475.  
  476.         //取前N个频次最高的词存在wordsList
  477.         List<String> wordsList = new ArrayList<String>(N);//top-n关键词
  478.         for(int i = 0;i < N;i++){
  479.             Entry<String,Integer> entry= wordsQueue.poll();
  480.             wordsList.add(entry.getKey());
  481.         }
  482.  
  483.         //利用频次关键字，给句子打分，并对打分后句子列表依据得分大小降序排序
  484.         Map<Integer,Double> scoresLinkedMap = scoreSentences(sentencesList,wordsList);//返回的得分,从第一句开始,句子编号的自然顺序
  485.  
  486.  
  487.         Map<Integer,String> keySentence=null;
  488.  
  489.         //approach1,利用均值和标准差过滤非重要句子
  490.         if(style.equals("meanstd"))
  491.         {
  492.             keySentence = new LinkedHashMap<Integer,String>();
  493.  
  494.             //句子得分均值
  495.             double sentenceMean = 0.0;
  496.             for(double value:scoresLinkedMap.values()){
  497.                 sentenceMean += value;
  498.             }
  499.             sentenceMean /= scoresLinkedMap.size();
  500.  
  501.             //句子得分标准差
  502.             double sentenceStd=0.0;
  503.             for(Double score:scoresLinkedMap.values()){
  504.                 sentenceStd += Math.pow((score-sentenceMean), 2);
  505.             }
  506.             sentenceStd = Math.sqrt(sentenceStd / scoresLinkedMap.size());
  507.  
  508.             for(Map.Entry<Integer, Double> entry:scoresLinkedMap.entrySet()){
  509.                 //过滤低分句子
  510.                 if(entry.getValue()>(sentenceMean+0.5*sentenceStd))
  511.                     keySentence.put(entry.getKey(), sentencesList.get(entry.getKey()));
  512.             }
  513.         }
  514.  
  515.         List<Map.Entry<Integer, Double>> sortedSentList = new ArrayList<Map.Entry<Integer,Double>>(scoresLinkedMap.entrySet());//按得分从高到底排序好的句子，句子编号与得分
  516.         //System.setProperty("java.util.Arrays.useLegacyMergeSort", "true");
  517.         Collections.sort(sortedSentList, new Comparator<Map.Entry<Integer, Double>>(){
  518.             //            @Override
  519.             public int compare(Entry<Integer, Double> o1,Entry<Integer, Double> o2) {
  520.                 return o2.getValue() == o1.getValue() ? 0 :
  521.                         (o2.getValue() > o1.getValue() ? 1 : -1);
  522.             }
  523.  
  524.         });
  525.  
  526.         //approach2,默认返回排序得分top-n句子
  527.         if(style.equals("default")){
  528.             keySentence = new TreeMap<Integer,String>();
  529.             int count = 0;
  530.             for(Map.Entry<Integer, Double> entry:sortedSentList){
  531.                 count++;
  532.                 keySentence.put(entry.getKey(), sentencesList.get(entry.getKey()));
  533.                 if(count == this.TOP_SENTENCES)
  534.                     break;
  535.             }
  536.         }
  537.  
  538.         //approach3,利用最大边缘相关，返回前top-n句子
  539.         if(style.equals("MMR"))
  540.         {
  541.             if(sentencesList.size()==2)
  542.             {
  543.                 return sentencesList.get(0)+sentencesList.get(1);
  544.             }
  545.             else if(sentencesList.size()==1)
  546.                 return sentencesList.get(0);
  547.             keySentence = new TreeMap<Integer,String>();
  548.             int count = 0;
  549.             Map<Integer,Double> MMR_SentScore = MMR(sortedSentList);
  550.             for(Map.Entry<Integer, Double> entry:MMR_SentScore.entrySet())
  551.             {
  552.                 count++;
  553.                 int sentIndex=entry.getKey();
  554.                 String sentence=sentencesList.get(sentIndex);
  555.                 keySentence.put(sentIndex, sentence);
  556.                 if(count==this.TOP_SENTENCES)
  557.                     break;
  558.             }
  559.         }
  560.         StringBuilder sb=new StringBuilder();
  561.         for(int  index:keySentence.keySet())
  562.             sb.append(keySentence.get(index));
  563.         //System.out.println("summarize out...");
  564.         return sb.toString();
  565.     }
  566.  
  567.     /**
  568.      * 最大边缘相关(Maximal Marginal Relevance)，根据λ调节准确性和多样性
  569.      * max[λ*score(i) - (1-λ)*max[similarity(i,j)]]:score(i)句子的得分，similarity(i,j)句子i与j的相似度
  570.      * User-tunable diversity through λ parameter
  571.      * - High λ= Higher accuracy
  572.      * - Low λ= Higher diversity
  573.      * @param sortedSentList 排好序的句子，编号及得分
  574.      * @return
  575.      */
  576.     private Map<Integer,Double> MMR(List<Map.Entry<Integer, Double>> sortedSentList){
  577.         //System.out.println("MMR In...");
  578.         double[][] simSentArray=sentJSimilarity();//所有句子的相似度
  579.         Map<Integer,Double> sortedLinkedSent=new LinkedHashMap<Integer,Double>();
  580.         for(Map.Entry<Integer, Double> entry:sortedSentList){
  581.             sortedLinkedSent.put(entry.getKey(),entry.getValue());
  582.         }
  583.         Map<Integer,Double> MMR_SentScore=new LinkedHashMap<Integer,Double>();//最终的得分（句子编号与得分）
  584.         Map.Entry<Integer, Double> Entry=sortedSentList.get(0);//第一步先将最高分的句子加入
  585.         MMR_SentScore.put(Entry.getKey(), Entry.getValue());
  586.         boolean flag=true;
  587.         while(flag){
  588.             int index=0;
  589.             double maxScore=Double.NEGATIVE_INFINITY;//通过迭代计算获得最高分句子
  590.             for(Map.Entry<Integer, Double> entry:sortedLinkedSent.entrySet()){
  591.                 if(MMR_SentScore.containsKey(entry.getKey())) continue;
  592.                 double simSentence=0.0;
  593.                 for(Map.Entry<Integer, Double> MMREntry:MMR_SentScore.entrySet()){//这个是获得最相似的那个句子的最大相似值
  594.                     double simSen=0.0;
  595.                     if(entry.getKey()>MMREntry.getKey())
  596.                         simSen=simSentArray[MMREntry.getKey()][entry.getKey()];
  597.                     else
  598.                         simSen=simSentArray[entry.getKey()][MMREntry.getKey()];
  599.                     if(simSen>simSentence){
  600.                         simSentence=simSen;
  601.                     }
  602.                 }
  603.                 simSentence=λ*entry.getValue()-(1-λ)*simSentence;
  604.                 if(simSentence>maxScore){
  605.                     maxScore=simSentence;
  606.                     index=entry.getKey();//句子编号
  607.                 }
  608.             }
  609.             MMR_SentScore.put(index, maxScore);
  610.             if(MMR_SentScore.size()==sortedLinkedSent.size())
  611.                 flag=false;
  612.         }
  613.         //System.out.println("MMR out...");
  614.         return MMR_SentScore;
  615.     }
  616.  
  617.     /**
  618.      * 每个句子的相似度，这里使用简单的jaccard方法，计算所有句子的两两相似度
  619.      * @return
  620.      */
  621.     private double[][] sentJSimilarity(){
  622.         //System.out.println("sentJSimilarity in...");
  623.         int size=sentSegmentWords.size();
  624.         double[][] simSent=new double[size][size];
  625.         for(Map.Entry<Integer, List<String>> entry:sentSegmentWords.entrySet()){
  626.             for(Map.Entry<Integer, List<String>> entry1:sentSegmentWords.entrySet()){
  627.                 if(entry.getKey()>=entry1.getKey()) continue;
  628.                 int commonWords=0;
  629.                 double sim=0.0;
  630.                 for(String entryStr:entry.getValue()){
  631.                     if(entry1.getValue().contains(entryStr))
  632.                         commonWords++;
  633.                 }
  634.                 sim=1.0*commonWords/(entry.getValue().size()+entry1.getValue().size()-commonWords);
  635.                 simSent[entry.getKey()][entry1.getKey()]=sim;
  636.             }
  637.         }
  638.         //System.out.println("sentJSimilarity out...");
  639.         return simSent;
  640.     }
  641.  
  642.     public static void main(String[] args){
  643.  
  644.         NewsSummary summary=new NewsSummary();
  645.  
  646.  
  647.         String text="我国古代历史演义小说的代表作。明代小说家罗贯中依据有关三国的历史、杂记，在广泛吸取民间传说和民间艺人创作成果的基础上，加工、再创作了这部长篇章回小说。" +
  648.                 "作品写的是汉末到晋初这一历史时期魏、蜀、吴三个封建统治集团间政治、军事、外交等各方面的复杂斗争。通过这些描写，揭露了社会的黑暗与腐朽，谴责了统治阶级的残暴与奸诈，" +
  649.                 "反映了人民在动乱时代的苦难和明君仁政的愿望。小说也反映了作者对农民起义的偏见，以及因果报应和宿命论等思想。战争描写是《三国演义》突出的艺术成就。" +
  650.                 "这部小说通过惊心动魄的军事、政治斗争，运用夸张、对比、烘托、渲染等艺术手法，成功地塑造了诸葛亮、曹操、关羽、张飞等一批鲜明、生动的人物形象。" +
  651.                 "《三国演义》结构宏伟而又严密精巧，语言简洁、明快、生动。有的评论认为这部作品在艺术上的不足之处是人物性格缺乏发展变化，有的人物渲染夸张过分导致失真。" +
  652.                 "《三国演义》标志着历史演义小说的辉煌成就。在传播政治、军事斗争经验、推动历史演义创作的繁荣等方面都起过积极作用。" +
  653.                 "《三国演义》的版本主要有明嘉靖刻本《三国志通俗演义》和清毛宗岗增删评点的《三国志演义》";
  654.  
  655.  
  656.         String keySentences=summary.SummaryMeanstdTxt(text);
  657.         System.out.println("summary: "+keySentences);
  658.  
  659.         String topSentences=summary.SummaryTopNTxt(text);
  660.         System.out.println("summary: "+topSentences);
  661.  
  662.         String mmrSentences=summary.SummaryMMRNTxt(text);
  663.         System.out.println("summary: "+mmrSentences);
  664.  
  665.  
  666.     }
  667. }

 

另外也可以引用汉语语言处理包，该包里面有摘要的方法

　　

　　import com.hankcs.hanlp.HanLP;
　　import com.hankcs.hanlp.corpus.tag.Nature;
　　import com.hankcs.hanlp.seg.common.Term;
　　//摘要，200是摘要的最大长度
　　String summary = HanLP.getSummary(txt,200);

　　引用hanlp-portable-1.5.2.jar和hanlp-solr-plugin-1.1.2.jar

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家自动化/article/detail/281703?site
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号