devbox
喵喵爱编程
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

自然语言处理（NLP）库_opennlp

作者：喵喵爱编程 | 2024-07-22 10:05:39

赞

踩

opennlp

自然语言处理（NLP）库

工具一

NLTK、spaCy和TextBlob都是常见的自然语言处理（NLP）库，但它们在功能、性能和使用方面有一些差异。下面是它们的对比：

  1. NLTK（Natural Language Toolkit）：
  • 功能广泛：NLTK提供了丰富的功能，包括文本分词、词性标注、命名实体识别、情感分析、文本分类等。
  • 教育性质：NLTK是教育性质的工具，主要用于教学和研究，提供了大量的教程和示例代码。
  • 灵活性高：NLTK提供了丰富的API和工具，可以根据需要进行自定义操作和扩展。
  1. spaCy：
  • 高性能：spaCy是一个优秀的NLP库，具有出色的性能和处理速度。它使用Cython实现，可以高效地处理大规模文本数据。
  • 内置模型：spaCy内置了一些强大的模型，如分词、词性标注、句法分析和命名实体识别等，可以快速进行NLP任务。
  • 丰富的特性：spaCy提供了许多有用的特性，如文本向量化、实体关系提取和实体链接等。
  1. TextBlob：
  • 简单易用：TextBlob是基于NLTK开发的一个简单易用的NLP库，提供了一些方便的功能，如情感分析、词性标注、文本分类等。
  • 文本处理工具：TextBlob提供了方便的文本处理工具，如分词、词形还原、拼写纠正等，可以快速进行文本预处理。
  • 适合快速原型开发：TextBlob的设计目标是简化NLP任务，因此适合用于快速原型开发和探索性分析。

选择使用哪个库取决于具体的需求和项目要求。如果需要丰富的功能和教育性质的工具，可以选择NLTK；如果需要高性能和内置模型，可以选择spaCy；如果需要简单易用的工具和快速原型开发，可以选择TextBlob。

工具二

有一些综合性的自然语言处理工具可以满足提取中文文本的主题、事件、情感、实体和摘要的需求。以下是几个常用的工具：

1. HanLP：HanLP是一个开源的中文自然语言处理工具包，提供了包括分词、词性标注、命名实体识别、依存句法分析、关键词提取、摘要提取等功能。HanLP使用Java语言编写，提供了Java、Python等多种语言的API接口。

2. LTP（Language Technology Platform）：LTP是由哈工大社会计算与信息检索研究中心开发的中文语言处理平台，集成了分词、词性标注、命名实体识别、依存句法分析、情感分析、事件抽取等功能。LTP提供了C++、Java、Python等多种语言版本的API接口。

3. THULAC：THULAC是由清华大学自然语言处理与社会人文计算实验室开发的中文词法分析工具，支持分词、词性标注、命名实体识别等功能。THULAC使用C++语言编写，同时提供了Python的接口。

这些工具都是经过多年的研发和实践，在中文自然语言处理领域有较好的效果和性能。在选择使用时，可以根据具体需求、语言偏好和开发环境等因素进行评估和选择。

OpenNLP

OpenNLP可以实现的功能场景

  1. 自然语言处理：OpenNLP提供了一系列的自然语言处理功能，包括句子分割、词性标注、命名实体识别、词干提取、词性归一化等。通过整合Spring Boot，可以将这些功能用于构建聊天机器人、智能问答系统等。

  2. 文本分类：OpenNLP提供了文本分类功能，可以对文本进行分类，比如判断一封邮件是垃圾邮件还是正常邮件。通过整合Spring Boot，可以将这个功能用于构建垃圾邮件过滤器等。

  3. 情感分析：OpenNLP可以对文本进行情感分析，判断文本的情感倾向，比如判断一段评论是正面的还是负面的。通过整合Spring Boot，可以将这个功能用于构建舆情监测系统、社交媒体分析等。

  4. 文本摘要：OpenNLP可以对文本进行摘要提取，将一篇文章或一个文本段落中的重要信息提取出来。通过整合Spring Boot，可以将这个功能用于构建新闻摘要生成器、文本自动摘要工具等。

  5. 信息抽取：OpenNLP可以从文本中提取一些特定的信息，比如从一篇新闻文章中提取人物、地点、组织等实体。通过整合Spring Boot，可以将这个功能用于构建新闻信息提取系统、知识图谱构建等。

Spring Boot整合OpenNLP

  1. 添加OpenNLP依赖：在项目的pom.xml文件中添加OpenNLP的依赖项。可以选择所需的OpenNLP模块，例如opennlp-tools来包括所有主要的OpenNLP功能。
  1. <dependency>
  2.     <groupId>org.apache.opennlp</groupId>
  3.     <artifactId>opennlp-tools</artifactId>
  4.     <version>1.9.3</version>
  5. </dependency>

  1. 创建OpenNLP服务类：创建一个Spring Bean来实现OpenNLP的功能。这个类将负责加载和初始化OpenNLP模型，并提供相应的方法来调用OpenNLP的功能。将训练的或者网上下载的模型文件放到resources/models目录下。
  1. @Service
  2. public class OpenNLPService {
  3.  
  4.     private SentenceDetectorME sentenceDetector;
  5.     private TokenizerME tokenizer;
  6.     
  7.     // 初始化OpenNLP模型
  8.     @PostConstruct
  9.     public void init() throws IOException {
  10.         InputStream sentenceModelStream = getClass().getResourceAsStream("/models/en-sent.bin");
  11.         SentenceModel sentenceModel = new SentenceModel(sentenceModelStream);
  12.         sentenceDetector = new SentenceDetectorME(sentenceModel);
  13.  
  14.         InputStream tokenizerModelStream = getClass().getResourceAsStream("/models/en-token.bin");
  15.         TokenizerModel tokenizerModel = new TokenizerModel(tokenizerModelStream);
  16.         tokenizer = new TokenizerME(tokenizerModel);
  17.     }
  18.  
  19.     // 实现句子分割功能
  20.     public String[] sentenceDetect(String text) {
  21.         return sentenceDetector.sentDetect(text);
  22.     }
  23.  
  24.     // 实现单词分割功能
  25.     public String[] tokenize(String sentence) {
  26.         return tokenizer.tokenize(sentence);
  27.     }
  28.     
  29.     // 其他OpenNLP功能的实现...
  30. }

  1. 创建Controller类：创建一个Spring MVC的Controller类，用于处理请求和响应。在这个类中，将OpenNLP服务类注入为一个依赖，并使用它来实现相应的功能。
  1. @RestController
  2. @RequestMapping("/api")
  3. public class NlpController {
  4.  
  5.     @Autowired
  6.     private OpenNLPService openNLPService;
  7.  
  8.     @PostMapping("/sentence")
  9.     public ResponseEntity<String[]> sentenceDetect(@RequestBody String text) {
  10.         String[] sentences = openNLPService.sentenceDetect(text);
  11.         return ResponseEntity.ok(sentences);
  12.     }
  13.  
  14.     @PostMapping("/tokenize")
  15.     public ResponseEntity<String[]> tokenize(@RequestBody String sentence) {
  16.         String[] tokens = openNLPService.tokenize(sentence);
  17.         return ResponseEntity.ok(tokens);
  18.     }
  19.     
  20.     // 其他功能的实现...
  21. }

  1. 运行应用程序：使用Spring Boot的插件或命令行运行应用程序。然后可以通过发送HTTP请求到相应的端点来调用OpenNLP的功能。
curl -X POST -H "Content-Type: application/json" -d "I love OpenNLP. It's a great tool." http://localhost:8080/api/sentence

这样就可以在Spring Boot应用程序中整合OpenNLP，并使用其提供的自然语言处理功能。可以根据需要实现其他OpenNLP的功能，继续扩展和完善应用程序。

提取文本语种

OpenNLP工具包提供了一种称为Language Detector的组件，它可以用于判断文本的语种。Language Detector使用了一个预训练好的模型来对文本进行分类，将其归类为不同的语种。

以下是一个使用OpenNLP进行语种检测的示例代码：

  1. package com.example.modules.opennlp.service;
  2.  
  3. import com.example.modules.opennlp.utils.LanguageMappingUtil;
  4. import javafx.scene.transform.Translate;
  5. import opennlp.tools.langdetect.Language;
  6. import opennlp.tools.langdetect.LanguageDetectorME;
  7. import opennlp.tools.langdetect.LanguageDetectorModel;
  8. import org.springframework.stereotype.Service;
  9.  
  10. import javax.annotation.PostConstruct;
  11. import java.io.IOException;
  12. import java.io.InputStream;
  13.  
  14. @Service
  15. public class OpenNLPService {
  16.     /**
  17.      * 语种检测服务
  18.      */
  19.     private LanguageDetectorME languageDetector;
  20.  
  21.     @PostConstruct
  22.     public void init() throws IOException {
  23.         /**
  24.          * 初始化语种检测服务
  25.          */
  26.         InputStream languageModelIn = getClass().getResourceAsStream("/langdetect-183.bin");//加载语种检测模型
  27.         LanguageDetectorModel languageModel = new LanguageDetectorModel(languageModelIn);
  28.         this.languageDetector = new LanguageDetectorME(languageModel);
  29.     }
  30.  
  31.     /**
  32.      **获取文本中的语种
  33.      * @param text
  34.      * @return java.lang.String
  35.      * @author yinqi
  36.      * @create 2023/12/26 15:29
  37.      **/
  38.     public String detectLanguage(String text) {
  39.         Language[] languages = languageDetector.predictLanguages(text);
  40.         Language language = languages[0];// 预测结果中概率最高的语种
  41.         String langCode = language.getLang();//语种代码
  42.         return LanguageMappingUtil.getLanguageStr(langCode);
  43.     }
  44. }

 语种检测模型从官网下载

 

 

  1. package com.example.modules.opennlp.utils;
  2.  
  3. import org.apache.commons.lang3.StringUtils;
  4.  
  5. import java.util.HashMap;
  6. import java.util.Map;
  7.  
  8. /**
  9.  * @author yinqi
  10.  * @description
  11.  * @create 2023/12/26 18:18
  12.  **/
  13. public class LanguageMappingUtil {
  14.  
  15.     /**
  16.      * 根据语种代码获取语种名称
  17.      * @param languageCode
  18.      * @return
  19.      */
  20.     public static String getLanguageStr(String languageCode){
  21.         if (StringUtils.isBlank(languageCode)){
  22.             return null;
  23.         }
  24.  
  25.         Map<String, String> languageMap = getLanguageMapping();
  26.         String languageName = languageMap.get(languageCode);
  27.         return languageName;
  28.     }
  29.  
  30.     /**
  31.      * 语种代码--语种名称映射关系
  32.      * @return
  33.      */
  34.     private static Map<String, String> getLanguageMapping() {
  35.         Map<String, String> languageMap = new HashMap<>();
  36.         languageMap.put("afr", "南非荷兰语");
  37.         languageMap.put("ara", "阿拉伯语");
  38.         languageMap.put("ast", "阿斯图里亚斯语");
  39.         languageMap.put("aze", "阿塞拜疆语");
  40.         languageMap.put("bak", "巴什基尔语");
  41.         languageMap.put("bel", "白俄罗斯语");
  42.         languageMap.put("ben", "孟加拉语");
  43.         languageMap.put("bos", "波斯尼亚语");
  44.         languageMap.put("bre", "布列塔尼语");
  45.         languageMap.put("bul", "保加利亚语");
  46.         languageMap.put("cat", "加泰罗尼亚语");
  47.         languageMap.put("ceb", "宿务语");
  48.         languageMap.put("ces", "捷克语");
  49.         languageMap.put("che", "车臣语");
  50.         languageMap.put("cmn", "中文");
  51.         languageMap.put("cym", "威尔士语");
  52.         languageMap.put("dan", "丹麦语");
  53.         languageMap.put("deu", "德语");
  54.         languageMap.put("ekk", "爱沙尼亚语");
  55.         languageMap.put("ell", "现代希腊语");
  56.         languageMap.put("eng", "英语");
  57.         languageMap.put("epo", "世界语");
  58.         languageMap.put("est", "爱沙尼亚语");
  59.         languageMap.put("eus", "巴斯克语");
  60.         languageMap.put("fao", "法罗语");
  61.         languageMap.put("fas", "波斯语");
  62.         languageMap.put("fin", "芬兰语");
  63.         languageMap.put("fra", "法语");
  64.         languageMap.put("fry", "西弗里西亚语");
  65.         languageMap.put("gle", "爱尔兰语");
  66.         languageMap.put("glg", "加利西亚语");
  67.         languageMap.put("gsw", "瑞士德语");
  68.         languageMap.put("guj", "古吉拉特语");
  69.         languageMap.put("heb", "希伯来语");
  70.         languageMap.put("hin", "印地语");
  71.         languageMap.put("hrv", "克罗地亚语");
  72.         languageMap.put("hun", "匈牙利语");
  73.         languageMap.put("hye", "亚美尼亚语");
  74.         languageMap.put("ind", "印尼语");
  75.         languageMap.put("isl", "冰岛语");
  76.         languageMap.put("ita", "意大利语");
  77.         languageMap.put("jav", "爪哇语");
  78.         languageMap.put("jpn", "日语");
  79.         languageMap.put("kan", "卡纳达语");
  80.         languageMap.put("kat", "格鲁吉亚语");
  81.         languageMap.put("kaz", "哈萨克语");
  82.         languageMap.put("kir", "柯尔克孜语");
  83.         languageMap.put("kor", "韩语");
  84.         languageMap.put("lat", "拉丁语");
  85.         languageMap.put("lav", "拉脱维亚语");
  86.         languageMap.put("lim", "林堡语");
  87.         languageMap.put("lit", "立陶宛语");
  88.         languageMap.put("ltz", "卢森堡语");
  89.         languageMap.put("lvs", "标准拉脱维亚语");
  90.         languageMap.put("mal", "马拉雅拉姆语");
  91.         languageMap.put("mar", "马拉地语");
  92.         languageMap.put("min", "米南卡瓦乌语");
  93.         languageMap.put("mkd", "马其顿语");
  94.         languageMap.put("mlt", "马耳他语");
  95.         languageMap.put("mon", "蒙古语");
  96.         languageMap.put("mri", "毛利语");
  97.         languageMap.put("msa", "马来语");
  98.         languageMap.put("nan", "闽南语");
  99.         languageMap.put("nds", "低地德语");
  100.         languageMap.put("nep", "尼泊尔语");
  101.         languageMap.put("nld", "荷兰语");
  102.         languageMap.put("nno", "挪威尼诺斯克语");
  103.         languageMap.put("nob", "挪威博克马尔语");
  104.         languageMap.put("oci", "奥克西塔尼语");
  105.         languageMap.put("pan", "旁遮普语");
  106.         languageMap.put("pes", "伊朗波斯语");
  107.         languageMap.put("plt", "高原马达加斯加语");
  108.         languageMap.put("pnb", "西旁遮普语");
  109.         languageMap.put("pol", "波兰语");
  110.         languageMap.put("por", "葡萄牙语");
  111.         languageMap.put("pus", "普什图语");
  112.         languageMap.put("ron", "罗马尼亚语");
  113.         languageMap.put("rus", "俄语");
  114.         languageMap.put("san", "梵文");
  115.         languageMap.put("sin", "僧伽罗语");
  116.         languageMap.put("slk", "斯洛伐克语");
  117.         languageMap.put("slv", "斯洛文尼亚语");
  118.         languageMap.put("som", "索马里语");
  119.         languageMap.put("spa", "西班牙语");
  120.         languageMap.put("sqi", "阿尔巴尼亚语");
  121.         languageMap.put("srp", "塞尔维亚语");
  122.         languageMap.put("sun", "巽他语");
  123.         languageMap.put("swa", "斯瓦希里语");
  124.         languageMap.put("swe", "瑞典语");
  125.         languageMap.put("tam", "泰米尔语");
  126.         languageMap.put("tat", "鞑靼语");
  127.         languageMap.put("tel", "泰卢固语");
  128.         languageMap.put("tgk", "塔吉克语");
  129.         languageMap.put("tgl", "菲律宾语");
  130.         languageMap.put("tha", "泰语");
  131.         languageMap.put("tur", "土耳其语");
  132.         languageMap.put("ukr", "乌克兰语");
  133.         languageMap.put("urd", "乌尔都语");
  134.         languageMap.put("uzb", "乌兹别克语");
  135.         languageMap.put("vie", "越南语");
  136.         languageMap.put("vol", "沃拉普克语");
  137.         languageMap.put("war", "沃瑞语");
  138.         languageMap.put("zul", "祖鲁语");
  139.         return languageMap;
  140.     }
  141. }

在上述示例中，我们加载了一个预训练的语种检测模型（langdetect-model.bin），然后使用LanguageDetectorME类对给定的文本进行语种检测。最后，返回检测到的语种。

需要注意的是，预训练模型的准确性和性能可能会受到模型的质量和适用性的限制。对于特定的文本类型和领域，语种检测的准确性可能会有所下降。因此，如果需要更高的准确性和适应性，可能需要进行更多的训练或使用其他更专门的语种检测工具。

提取文本的主题

OpenNLP工具包本身没有直接提供提取文本主题的功能。主题提取是一种文本挖掘技术，它可以识别文本中的关键主题或主要内容。要提取文本的主题，通常可以使用一些机器学习和自然语言处理技术。

一种常见的主题提取方法是使用主题模型，如Latent Dirichlet Allocation (LDA)。LDA模型可以根据每个单词在文档中的出现频率和上下文关系来识别主题。你可以使用其他工具或框架，如Gensim或Mallet，来实现LDA模型的训练和主题提取。

另外，你也可以使用词袋模型（Bag-of-Words Model）来提取文本主题。词袋模型将文本表示为词的集合，忽略了单词的顺序和语法结构。你可以使用OpenNLP的词性标注器（POS Tagger）和词块划分器（Chunker）来帮助提取文本中的名词短语或实体，以获得更有意义的词袋表示。

总结来说，OpenNLP工具包可以在一定程度上辅助进行文本主题提取，但实际的主题提取任务可能需要结合其他工具、库或算法来完成。

提取文本的事件

OpenNLP工具包本身提供了一些用于实体识别和关系抽取等任务的模型，因此可以用于提取文本中的事件信息。具体来说，OpenNLP的命名实体识别模型可以帮助识别出文本中的人名、地名、组织名等实体，而关系抽取模型可以帮助识别出文本中实体之间的关系，如人物之间的关系、公司与员工之间的关系等。

然而，OpenNLP提供的模型可能不是针对特定事件的预训练模型，因此在提取特定事件的信息时，可能需要对模型进行训练或微调。你可以使用OpenNLP提供的训练工具，根据自己的数据和任务需求，训练一个适合特定事件提取的模型。

另外，如果你需要更复杂的事件提取功能，可能需要考虑使用其他更专业的工具包或自然语言处理技术。

提取文本的情感

OpenNLP工具包本身不提供直接的情感分析功能。然而，可以使用OpenNLP工具包中的一些特性和技术来进行情感分析。

情感分析是一种通过自然语言处理和机器学习技术来识别文本中的情感信息的技术。要提取文本的情感，可以使用以下步骤：

  1. 分词（Tokenization）：使用OpenNLP中的分词器将文本拆分成单词或符号。
  2. 词性标注（POS Tagging）：使用OpenNLP中的词性标注器标记每个单词的词性。
  3. 特征提取：根据词性、情感词典或其他特征，提取文本中可能与情感相关的特征。
  4. 情感分类（Sentiment Classification）：使用机器学习算法（如朴素贝叶斯、支持向量机等）训练一个情感分类器，将文本进行情感分类。

OpenNLP可以用于分词和词性标注步骤，并且还可以使用其他工具或框架（如NLTK、Scikit-learn等）完成情感分析的特征提取和分类步骤。

另外，还有一些基于预训练模型的工具可用于情感分析，如TextBlob、VADER（Valence Aware Dictionary and sEntiment Reasoner）等。这些工具可以直接使用，无需额外训练。

总结来说，OpenNLP工具包可以在一定程度上辅助进行情感分析，但实际的情感分析任务可能需要结合其他工具、库或算法来完成。

提取文本的实体

是的，OpenNLP工具包可以提取文本中的实体信息，例如人名、地名、组织名等。它包含了一些预训练模型，可以用来识别和提取实体。

要使用OpenNLP工具包提取实体，你需要进行以下步骤：

  1. 下载OpenNLP工具包，并导入到你的项目中。
  2. 下载并加载适用于你的语言的实体识别模型，如英语的"en-ner-person.bin"或"en-ner-location.bin"。
  3. 使用OpenNLP提供的实体识别器，对文本进行实体识别，可以使用NameFinderME类。
  4. 解析识别结果，提取出实体信息。

以下是一个简单的示例代码，用于使用OpenNLP工具包提取英语文本中的人名实体：

  1. import opennlp.tools.namefind.NameFinderME;
  2. import opennlp.tools.namefind.TokenNameFinderModel;
  3. import opennlp.tools.util.Span;
  4.  
  5. import java.io.FileInputStream;
  6. import java.io.IOException;
  7. import java.io.InputStream;
  8.  
  9. public class EntityExtractor {
  10.     public static void main(String[] args) throws IOException {
  11.         // 加载人名实体识别模型
  12.         InputStream inputStream = new FileInputStream("en-ner-person.bin");
  13.         TokenNameFinderModel model = new TokenNameFinderModel(inputStream);
  14.         NameFinderME nameFinder = new NameFinderME(model);
  15.  
  16.         // 待处理文本
  17.         String text = "John Doe is a software engineer at XYZ Corporation.";
  18.  
  19.         // 切分文本为单词
  20.         String[] words = text.split(" ");
  21.  
  22.         // 对文本进行实体识别
  23.         Span[] spans = nameFinder.find(words);
  24.  
  25.         // 输出提取出的人名实体
  26.         for (Span span : spans) {
  27.             String personName = "";
  28.             for (int i = span.getStart(); i < span.getEnd(); i++) {
  29.                 personName += words[i] + " ";
  30.             }
  31.             System.out.println("Person name: " + personName.trim());
  32.         }
  33.  
  34.         // 关闭输入流
  35.         inputStream.close();
  36.     }
  37. }

上述代码加载了预训练的人名实体识别模型"en-ner-person.bin"，并对文本中的人名实体进行识别。最后通过循环遍历识别结果，并输出提取出的人名实体。

注意，你可以使用类似的方法，加载其他实体识别模型，如地名、组织名等。

提取文本的摘要

OpenNLP工具包本身不提供用于提取文本摘要的功能。OpenNLP主要用于自然语言处理任务，如词性标注、命名实体识别等。但是，OpenNLP可以作为一个基础工具，用于构建文本摘要系统的一部分。

文本摘要是一个独立的任务，通常需要使用不同的算法和技术来实现。常见的文本摘要方法包括提取式摘要和生成式摘要。

提取式摘要方法从文本中直接提取一些重要的句子、短语或关键词作为摘要。这种方法通常基于统计信息和文本特征来选择重要的信息片段，不需要额外的训练数据。你可以使用OpenNLP工具包中的句子检测器（Sentence Detector）和词性标注器（POS Tagger）来帮助实现提取式摘要。

生成式摘要方法则尝试生成一个新的摘要，通常需要基于机器学习和自然语言处理技术，如序列到序列模型、递归神经网络等。这种方法需要训练使用大量摘要数据的模型，而OpenNLP本身并不提供训练这些模型的功能。

因此，如果你想要实现文本摘要功能，你可以使用OpenNLP工具包中的一些组件来辅助实现提取式摘要。如果你需要生成式摘要，你可能需要使用其他工具或框架，如NLTK、Gensim、TensorFlow等，以及相关的机器学习和自然语言处理技术。

HanLP提取文本的实体、摘要

引入依赖：

  1.         <dependency>
  2.             <groupId>com.hankcs</groupId>
  3.             <artifactId>hanlp</artifactId>
  4.             <version>portable-1.8.3</version>
  5.         </dependency>

  1. package com.example.modules.HanLP.controller;
  2.  
  3. import com.example.modules.utils.EmailContentUtil;
  4. import com.example.modules.HanLP.utils.TextAnalyzer;
  5. import io.swagger.annotations.Api;
  6. import io.swagger.annotations.ApiOperation;
  7. import org.springframework.web.bind.annotation.GetMapping;
  8. import org.springframework.web.bind.annotation.RequestMapping;
  9. import org.springframework.web.bind.annotation.RequestParam;
  10. import org.springframework.web.bind.annotation.RestController;
  11.  
  12. import java.util.List;
  13.  
  14. @RestController
  15. @RequestMapping("/hanLPController")
  16. @Api(tags = "HanLP提取文本的实体、摘要")
  17. public class HanLPController {
  18.     private TextAnalyzer textAnalyzer = new TextAnalyzer();
  19.  
  20.     @GetMapping("/keywords")
  21.     @ApiOperation("从文本中提取关键词")
  22.     public List<String> extractKeywords(@RequestParam("text") String text, @RequestParam("count") int count) {
  23.         text = EmailContentUtil.getContentA();
  24.         List<String> keywords = textAnalyzer.extractKeywords(text, count);
  25.         return keywords;
  26.     }
  27.  
  28.     @GetMapping("/summaryA")
  29.     @ApiOperation("从文本中提取摘要A")
  30.     public List<String> extractSummary(@RequestParam("text") String text, @RequestParam("count") int count) {
  31.         text = EmailContentUtil.getContentA();
  32.         List<String> summary = textAnalyzer.extractSummary(text, count);
  33.         return summary;
  34.     }
  35.  
  36.     @GetMapping("/summaryB")
  37.     @ApiOperation("从文本中提取摘要B")
  38.     public String summarizeText(@RequestParam("text") String text, @RequestParam("count") int count) {
  39.         text = EmailContentUtil.getContentA();
  40.         String summary = textAnalyzer.extractSummaryB(text, count);
  41.         return summary;
  42.     }
  43.  
  44.     @GetMapping("/sentences")
  45.     @ApiOperation("从文本中提取句子")
  46.     public List<String> extractSentences(@RequestParam("text") String text) {
  47.         text = EmailContentUtil.getContentA();
  48.         List<String> sentences = textAnalyzer.extractSentences(text);
  49.         return sentences;
  50.     }
  51.  
  52.     @GetMapping("/entities")
  53.     @ApiOperation("从文本中提取实体")
  54.     public List<String> extractEntities(@RequestParam("text") String text) {
  55.         text = EmailContentUtil.getContentA();
  56.  
  57.         text = "七夕节是中国传统节日之一，又被称为牛郎织女节，是每年农历七月初七的日子。七夕节起源于古代中国的一个浪漫的传说。相传，牛郎织女是两个天界的仙人，他们一见钟情并结为夫妻，但由于天界和人间不能相通，他们被迫分开，只能在每年的七夕这一天，通过一座银河上的鹊桥相会一次。\n" +
  58.                 "\n" +
  59.                 "因此，七夕节被视为中国的情人节。在这一天，人们会庆祝爱情的美好，表达对爱人的思念和祝福。很多年轻人都会选择在七夕节这天向心仪的人表白或者庆祝自己的恋爱关系。\n" +
  60.                 "\n" +
  61.                 "七夕节有许多传统的习俗和活动。最常见的是放风筝和观赏街头巷尾悬挂的彩纸。人们还会在七夕节这天给对方送花、送巧克力或者其他浪漫的礼物，以表达爱意。";
  62.  
  63.         text = "雷锋（1940年12月18日 - 1962年8月5日），是中国共产党的优秀党员、伟大的共产主义战士。他以无私奉献、艰苦奋斗的精神和高尚品德，深受人民群众的爱戴和崇敬。" +
  64.                 "雷锋曾在中国人民解放军从事军需工作，后来受命到东北铁路上任职，他始终牢记为人民服务的宗旨，默默地奉献自己，无私地帮助他人。" +
  65.                 "雷锋的事迹被广大人民群众传为佳话，成为中华民族的精神符号。";
  66.  
  67.         List<String> entities = textAnalyzer.extractEntities(text);
  68.         return entities;
  69.     }
  70. }

  1. package com.example.modules.HanLP.utils;
  2.  
  3. import com.hankcs.hanlp.HanLP;
  4. import com.hankcs.hanlp.seg.common.Term;
  5. import com.hankcs.hanlp.summary.TextRankSentence;
  6. import com.hankcs.hanlp.tokenizer.StandardTokenizer;
  7.  
  8. import java.util.List;
  9. import java.util.stream.Collectors;
  10.  
  11. public class TextAnalyzer {
  12.     public List<String> extractKeywords(String text, int keywordCount) {
  13.         List<String> keywords = HanLP.extractKeyword(text, keywordCount);
  14.         return keywords;
  15.     }
  16.  
  17.     public List<String> extractSummary(String text, int sentenceCount) {
  18.         List<String> summary = HanLP.extractSummary(text, sentenceCount);
  19.         return summary;
  20.     }
  21.  
  22.     public List<String> extractSentences(String text) {
  23.         List<Term> terms = StandardTokenizer.segment(text);
  24.         List<String> sentences = terms.stream()
  25.                 .map(Term::toString)
  26.                 .collect(Collectors.toList());
  27.         return sentences;
  28.     }
  29.  
  30.     public List<String> extractEntities(String text) {
  31.         List<String> entities = HanLP.extractPhrase(text, 5); // 提取前5个实体
  32.         return entities;
  33.     }
  34.  
  35.     public String extractSummaryB(String text, int count) {
  36.         // 使用HanLP的TextRank算法进行摘要提取
  37.         List<String> sentenceList = TextRankSentence.getTopSentenceList(text, count);
  38.  
  39.         // 将提取的摘要句子拼接成一个摘要文本
  40.         StringBuilder summary = new StringBuilder();
  41.         for (String sentence : sentenceList) {
  42.             summary.append(sentence).append("。");
  43.         }
  44.         return summary.toString();
  45.     }
  46.  
  47. //    public String analyzeSentiment(String text) {
  48. //        String sentiment = HanLP.sentiment(text).toString();
  49. //        return sentiment;
  50. //    }
  51. }

 访问提取摘要的接口：

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

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

  

闽ICP备14008679号