如何进行词干提取或词形还原？

Question

我尝试过 PorterStemmer 和 Snowball，但两者都不能处理所有单词，缺少一些非常常见的单词。

我的测试词是：“猫跑跑仙人掌仙人掌仙人掌社区社区”，两者都答对了一半。

另请参阅：

• 生成真实单词的词干算法
• 词干提取 - 代码示例或开源项目？

Answer 1

如果您了解 Python，自然语言工具包 (NLTK) 有一个非常强大的词形还原器，它利用 WordNet。

请注意，如果您是第一次使用此词形还原器，则必须在使用之前下载语料库。 这可以通过以下方式完成：

>>> import nltk
>>> nltk.download('wordnet')

您只需执行一次。 假设您现在已经下载了语料库，它的工作原理如下：

>>> from nltk.stem.wordnet import WordNetLemmatizer
>>> lmtzr = WordNetLemmatizer()
>>> lmtzr.lemmatize('cars')
'car'
>>> lmtzr.lemmatize('feet')
'foot'
>>> lmtzr.lemmatize('people')
'people'
>>> lmtzr.lemmatize('fantasized','v')
'fantasize'

nltk 中还有其他词形还原器.stem模块，但我自己还没有尝试过。

Answer 2

我使用 stanford nlp 来执行词形还原。 在过去的几天里，我一直被类似的问题困扰。 非常感谢 stackoverflow 帮我解决了这个问题。

import java.util.*; 
import edu.stanford.nlp.pipeline.*;
import edu.stanford.nlp.ling.*; 
import edu.stanford.nlp.ling.CoreAnnotations.*;  

public class example
{
    public static void main(String[] args)
    {
        Properties props = new Properties(); 
        props.put("annotators", "tokenize, ssplit, pos, lemma"); 
        pipeline = new StanfordCoreNLP(props, false);
        String text = /* the string you want */; 
        Annotation document = pipeline.process(text);  

        for(CoreMap sentence: document.get(SentencesAnnotation.class))
        {    
            for(CoreLabel token: sentence.get(TokensAnnotation.class))
            {       
                String word = token.get(TextAnnotation.class);      
                String lemma = token.get(LemmaAnnotation.class); 
                System.out.println("lemmatized version :" + lemma);
            }
        }
    }
}

如果稍后在分类器中使用，使用停用词来最小化输出引理也可能是一个好主意。 请查看 John Conwell 编写的 coreNlp 扩展。

Answer 3

我在这个雪球演示网站上尝试了您的术语列表，结果看起来不错......

• 猫 - > 猫
• 跑-> 跑跑
• -> 跑
• 仙人掌-> 仙人掌 仙人掌
• -> 仙人掌
• 社区-> 社区
• -> 社区 Community

词干提取器应该将单词的变形形式转化为某个共同的词根。 让词根成为“正确的”字典单词并不是词干分析器的工作。 为此，您需要查看形态/正交分析器< /a>.

我认为这个问题或多或少是同一件事，Kaarel 的回答这个问题是我从哪里获取第二个链接的。

Answer 4

词干提取器与词形还原器的争论仍在继续。 这是一个优先考虑精度而非效率的问题。 您应该进行词形还原以获得具有语言意义的单位，并使用最少的计算能力，并且仍然在同一键下索引单词及其变体。

请参阅 Stemmers 与 Lemmatizers

下面是一个使用 python NLTK 的示例：

>>> sent = "cats running ran cactus cactuses cacti community communities"
>>> from nltk.stem import PorterStemmer, WordNetLemmatizer
>>>
>>> port = PorterStemmer()
>>> " ".join([port.stem(i) for i in sent.split()])
'cat run ran cactu cactus cacti commun commun'
>>>
>>> wnl = WordNetLemmatizer()
>>> " ".join([wnl.lemmatize(i) for i in sent.split()])
'cat running ran cactus cactus cactus community community'

Answer 5

Martin Porter 的官方页面包含 Porter Stemmer in PHP 以及 其他语言。

如果您真的很重视良好的词干提取，那么您需要从波特算法之类的东西开始，通过添加规则来修复数据集常见的错误情况来完善它，然后最后在规则中添加很多例外情况。 这可以通过键/值对（dbm/散列/字典）轻松实现，其中键是要查找的单词，值是替换原始单词的词干单词。 我曾经工作过的一个商业搜索引擎最终出现了 800 个修改后的波特算法的例外情况。

Answer 6

根据我遇到的 Stack Overflow 和博客上的各种答案，这就是我正在使用的方法，并且它似乎可以很好地返回真实单词。 其想法是将传入的文本拆分为单词数组（使用您想要的任何方法），然后找到这些单词的词性 (POS)，并使用它来帮助词干和词形还原。

您上面的示例效果不太好，因为无法确定 POS。 然而，如果我们使用真正的句子，事情就会好得多。

import nltk
from nltk.corpus import wordnet

lmtzr = nltk.WordNetLemmatizer().lemmatize


def get_wordnet_pos(treebank_tag):
    if treebank_tag.startswith('J'):
        return wordnet.ADJ
    elif treebank_tag.startswith('V'):
        return wordnet.VERB
    elif treebank_tag.startswith('N'):
        return wordnet.NOUN
    elif treebank_tag.startswith('R'):
        return wordnet.ADV
    else:
        return wordnet.NOUN


def normalize_text(text):
    word_pos = nltk.pos_tag(nltk.word_tokenize(text))
    lemm_words = [lmtzr(sw[0], get_wordnet_pos(sw[1])) for sw in word_pos]

    return [x.lower() for x in lemm_words]

print(normalize_text('cats running ran cactus cactuses cacti community communities'))
# ['cat', 'run', 'ran', 'cactus', 'cactuses', 'cacti', 'community', 'community']

print(normalize_text('The cactus ran to the community to see the cats running around cacti between communities.'))
# ['the', 'cactus', 'run', 'to', 'the', 'community', 'to', 'see', 'the', 'cat', 'run', 'around', 'cactus', 'between', 'community', '.']

Answer 7

http://wordnet.princeton.edu/man/morph.3WN

对于很多在我的项目中，我更喜欢基于词典的 WordNet 词形还原器，而不是更激进的波特词干提取。

http://wordnet.princeton.edu/links#PHP 有一个 PHP 接口的链接WN API。

Answer 8

查看 WordNet，一个大型英语词汇数据库：

http://wordnet.princeton.edu/

有多种语言的 API 可以访问它。

Answer 9

这看起来很有趣：
麻省理工学院 Java WordnetStemmer：
http://projects.csail.mit.edu /jwi/api/edu/mit/jwi/morph/WordnetStemmer.html

Answer 10

看一下 LemmaGen - 用 C# 3.0 编写的开源库。

您的测试词 (http://lemmatise.ijs.si/Services) 的结果

• cats -> 猫
• 跑跑
• -> 运行
• 仙人掌仙人掌
• -> 仙人掌
• 仙人掌 -> 仙人掌
• 社区
• 社区-> 社区

Answer 11

用于词形还原的顶级 Python 包（排名不分先后）是：spacy、nltk、gensim、pattern、 CoreNLP 和 TextBlob。 我更喜欢 spaCy 和 gensim 的实现（基于模式），因为它们识别单词的 POS 标签并自动分配适当的引理。 给出了更多相关的引理，保持了含义的完整。

如果您计划使用 nltk 或 TextBlob，则需要手动查找正确的 POS 标签并找到正确的引理。

使用 spaCy 的词形还原示例：

# Run below statements in terminal once. 
pip install spacy
spacy download en

import spacy

# Initialize spacy 'en' model
nlp = spacy.load('en', disable=['parser', 'ner'])

sentence = "The striped bats are hanging on their feet for best"

# Parse
doc = nlp(sentence)

# Extract the lemma
" ".join([token.lemma_ for token in doc])
#> 'the strip bat be hang on -PRON- foot for good'

使用 Gensim 的词形还原示例：

from gensim.utils import lemmatize
sentence = "The striped bats were hanging on their feet and ate best fishes"
lemmatized_out = [wd.decode('utf-8').split('/')[0] for wd in lemmatize(sentence)]
#> ['striped', 'bat', 'be', 'hang', 'foot', 'eat', 'best', 'fish']

上面的示例借自此 词形还原 页面。

Answer 12

如果我可以引用我对 StompChicken 提到的问题的回答：

这里的核心问题是词干算法在语音基础上运行，没有真正理解他们正在使用的语言。

因为他们没有理解由于它们不是语言的一部分并且不是从术语词典中运行的，因此它们无法识别和适当响应不规则的情况，例如“run”/“ran”。

如果您需要处理不规则的情况，则需要选择不同的方法或使用您自己的自定义更正字典来增强您的词干提取，以便在词干分析器完成其工作后运行。

Answer 13

NLTK 中词干分析器的最新版本是 Snowball。

您可以在此处找到有关如何使用它的示例：

http://nltk.googlecode.com/svn/trunk/doc/api/nltk.stem.snowball2-pysrc.html#demo

Answer 14

您可以使用 Morpha 词干分析器。 如果您打算使用，华盛顿大学已将 Morpha 词干分析器上传到 Maven 中心它来自 Java 应用程序。 有一个包装器可以使它更容易使用。 您只需将其添加为依赖项并使用 edu.washington.cs.knowitall.morpha.MorphaStemmer 类即可。 实例是线程安全的（最初的 JFlex 有不必要的局部变量的类字段）。 实例化一个类并运行 morpha 和您想要提取词干的单词。

new MorphaStemmer().morpha("climbed") // goes to "climb"

Answer 15

搜索 Lucene，我不确定是否有 PHP 端口，但我知道 Lucene 可用于许多平台。 Lucene 是一个 OSS（来自 Apache）索引和搜索库。 当然，它和社区的额外内容可能会有一些有趣的东西值得一看。 至少您可以了解它是如何用一种语言完成的，这样您就可以将“想法”翻译成 PHP。

Answer 16

.Net lucene 有一个内置的 porter 词干分析器。 你可以尝试一下。 但请注意，波特词干提取在推导引理时不考虑单词上下文。 （浏览一下算法及其实现，你就会明白它是如何工作的）

Answer 17

Martin Porter 编写了 Snowball（一种词干算法语言），并在 Snowball 中重写了“英语词干分析器”。 C 和 Java 有一个英语词干分析器。

他明确指出，Porter Stemmer 仅由于历史原因而被重新实现，因此针对 Porter Stemmer 测试词干正确性将得到您（应该）已经知道的结果。

来自http://tartarus.org/~martin/PorterStemmer/index.html< /a>（强调我的）

Porter 词干分析器应被视为“冻结”，即严格定义，并且不适合进一步修改。 作为词干分析器，它略逊于从它派生的 Snowball English 或 Porter2 词干分析器，并且偶尔会进行改进。 因此，对于实际工作，建议使用新的 Snowball 词干分析器。 Porter 词干分析器适用于涉及词干提取的 IR 研究工作，其中实验需要完全可重复。

Porter 博士建议使用 English 或 Porter2 词干分析器而不是 Porter 词干分析器。 英语词干分析器是 演示网站 中实际使用的 @StompChicken之前已经回答过。

Answer 18

在 Java 中，我使用 tartargus-snowball 来词干

Maven:

<dependency>
        <groupId>org.apache.lucene</groupId>
        <artifactId>lucene-snowball</artifactId>
        <version>3.0.3</version>
        <scope>test</scope>
</dependency>

<示例代码：

SnowballProgram stemmer = new EnglishStemmer();
String[] words = new String[]{
    "testing",
    "skincare",
    "eyecare",
    "eye",
    "worked",
    "read"
};
for (String word : words) {
    stemmer.setCurrent(word);
    stemmer.stem();
    //debug
    logger.info("Origin: " + word + " > " + stemmer.getCurrent());// result: test, skincar, eyecar, eye, work, read
}

Answer 19

在这里试试这个：http://www.twinword.com/lemmatizer.php

我输入了您的在演示中查询“cats running ran cactus cactuses cacti Community communications”并得到["cat", "running", "run", "cactus", "cactus", "cactus" , "community", "community"] 带有可选标志 ALL_TOKENS。

示例代码

这是一个 API，因此您可以从任何环境连接到它。 PHP REST 调用可能如下所示。

// These code snippets use an open-source library. http://unirest.io/php
$response = Unirest\Request::post([ENDPOINT],
  array(
    "X-Mashape-Key" => [API KEY],
    "Content-Type" => "application/x-www-form-urlencoded",
    "Accept" => "application/json"
  ),
  array(
    "text" => "cats running ran cactus cactuses cacti community communities"
  )
);

Answer 20

我强烈建议使用 Spacy （基本文本解析和标记）和 Textacy（建立在 Spacy 之上的更高级别的文本处理）。

词形还原的单词默认情况下在 Spacy 中可用作为标记的 .lemma_在使用 textacy 进行许多其他文本预处理时，可以对属性和文本进行词形还原。 例如创建术语包时 或单词或通常在执行某些操作之前需要它的处理。

我鼓励您在编写任何代码之前检查两者，因为这可能会节省您很多时间！

Answer 21

import re
import pymorphy2
from pymorphy2 import MorphAnalyzer
import nltk
from nltk.tokenize import  word_tokenize
from nltk.corpus import stopwords

nltk.download('stopwords')
nltk.download('punkt')

stopwords_ru = stopwords.words("russian")
morph = MorphAnalyzer()

def to_lowercase(data):
    
    data = data.lower()
return data

def noise_remove(data, remove_numbers=True):
    
    data = re.sub(r"(\w+:\/\/\S+)", " ", data)

    
    data = re.sub(r"([^0-9A-Za-zА-Яа-я])", " ", data)


if remove_numbers:
    data = re.sub(r"\d+", " ", data)
return data


def lemmatize(words):
    text = []
    
    for word in words:
        morph_word = morph.parse(word)[0]
        if morph_word.tag.POS in ['NOUN', 'ADJF', 'INFN', 'PRTS'] and morph_word[2] not in stopwords_ru:
            text.append(morph_word[2])
   return text

def tokenize(text):
    words = text.split()
    for elem in words:
        if len(elem) < 3:
            words.remove(elem)
    lemmatize_words = lemmatize(words)
    return ' '.join(lemmatize_words)

Answer 22

df_plots = pd.read_excel("Plot Summary.xlsx", index_col = 0)
df_plots
# Printing first sentence of first row and last sentence of last row
nltk.sent_tokenize(df_plots.loc[1].Plot)[0] + nltk.sent_tokenize(df_plots.loc[len(df)].Plot)[-1]

# Calculating length of all plots by words
df_plots["Length"] = df_plots.Plot.apply(lambda x : 
len(nltk.word_tokenize(x)))

print("Longest plot is for season"),
print(df_plots.Length.idxmax())

print("Shortest plot is for season"),
print(df_plots.Length.idxmin())



#What is this show about? (What are the top 3 words used , excluding the #stop words, in all the #seasons combined)

word_sample = list(["struggled", "died"])
word_list = nltk.pos_tag(word_sample)
[wnl.lemmatize(str(word_list[index][0]), pos = word_list[index][1][0].lower()) for index in range(len(word_list))]

# Figure out the stop words
stop = (stopwords.words('english'))

# Tokenize all the plots
df_plots["Tokenized"] = df_plots.Plot.apply(lambda x : nltk.word_tokenize(x.lower()))

# Remove the stop words
df_plots["Filtered"] = df_plots.Tokenized.apply(lambda x : (word for word in x if word not in stop))

# Lemmatize each word
wnl = WordNetLemmatizer()
df_plots["POS"] = df_plots.Filtered.apply(lambda x : nltk.pos_tag(list(x)))
# df_plots["POS"] = df_plots.POS.apply(lambda x : ((word[1] = word[1][0] for word in word_list) for word_list in x))
df_plots["Lemmatized"] = df_plots.POS.apply(lambda x : (wnl.lemmatize(x[index][0], pos = str(x[index][1][0]).lower()) for index in range(len(list(x)))))



#Which Season had the highest screenplay of "Jesse" compared to "Walt" 
#Screenplay of Jesse =(Occurences of "Jesse")/(Occurences of "Jesse"+ #Occurences of "Walt")

df_plots.groupby("Season").Tokenized.sum()

df_plots["Share"] = df_plots.groupby("Season").Tokenized.sum().apply(lambda x : float(x.count("jesse") * 100)/float(x.count("jesse") + x.count("walter") + x.count("walt")))

print("The highest times Jesse was mentioned compared to Walter/Walt was in season"),
print(df_plots["Share"].idxmax())
#float(df_plots.Tokenized.sum().count('jesse')) * 100 / #float((df_plots.Tokenized.sum().count('jesse') + #df_plots.Tokenized.sum().count('walt') + #df_plots.Tokenized.sum().count('walter')))