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

（2-2）文本预处理算法：词干化与词形还原（Stemming and Lemmatization）_英文的词根化 文本预处理

作者：小小林熬夜学编程 | 2024-05-02 01:54:20

赞

踩

英文的词根化 文本预处理

2.2  词干化与词形还原（Stemming and Lemmatization）

词干化（Stemming）和词形还原（Lemmatization）都是文本预处理的技术，用于将单词转化为它们的基本形式，以减少词汇的多样性，提高文本处理和分析的效果。

2.2.1  词干化与词形还原的区别

词干化（Stemming）和词形还原（Lemmatization）有不同的原理和适用场景，具体说明如下所示。

1. 词干化（Stemming）

  1. 原理：词干化是一种基于规则的文本处理技术，它尝试通过去除单词的后缀来将单词还原到它们的词干或根形式。这通常涉及到简单的字符串操作，如去除常见的后缀（如-ing、-ed、-s等）。
  2. 适用场景：词干化通常用于快速文本处理，例如信息检索或文档分类。它的目标是将不同形式的单词映射到它们的共同词干，以减少不同形式的单词的数量。
  3. 示例：例如，将单词“running”、“ran”和“runs”都还原为词干“run”。

2. 词形还原（Lemmatization）

  1. 原理：词形还原是一种更复杂的文本处理技术，它考虑了单词的词法和语法，以将单词还原为它们的基本词形（词元或词根），通常需要使用词典和语法规则。它确保还原后的词语是合法的词汇形式。
  2. 适用场景：词形还原通常用于需要更准确的文本处理，如自然语言理解、机器翻译等。它有助于确保还原后的单词仍然具有语法上的合法性。
  3. 示例：例如，将单词“running”还原为词形“run”以及将“better”还原为“good”。

总之，词干化和词形还原都有其用武之地，但根据任务需求和精确性要求的不同，选择哪种方法会有所不同。词形还原通常更复杂且准确，但需要更多的计算资源和语言资源（如词典）。词干化更加简单和快速，但可能不如词形还原准确。

2.2.2  词干化算法

词干化是一种将单词转化为它们的基本形式（词干）的文本处理技术，在下面的内容中，将详细讲解常用的词干化算法技术。

1. Porter Stemming算法

Porter词干化算法是最早和最常用的词干化算法之一，它是一种基于规则的算法，通过一系列规则和模式匹配来截断单词的后缀。这个算法在许多自然语言处理任务中广泛使用，尤其是信息检索领域。例如下面是一个使用Natural Language Toolkit (NLTK)库来执行Porter Stemming算法的例子，这个例子将一些单词进行词干化，以演示将单词还原到它们的基本形式的过程。

实例2-3：将单词还原到它们的基本形式（源码路径：daima/2/gan.py）

实例文件gan.py的具体实现代码如下所示。

  1. import nltk
  2. from nltk.stem import PorterStemmer
  3.  
  4. # 初始化Porter词干化器
  5. stemmer = PorterStemmer()
  6.  
  7. # 待词干化的单词列表
  8. words = ["running", "flies", "happily", "stemmer", "jumps", "easily"]
  9.  
  10. # 对每个单词执行词干化
  11. stemmed_words = [stemmer.stem(word) for word in words]
  12.  
  13. # 显示原始单词和词干化后的结果
  14. for original, stemmed in zip(words, stemmed_words):
  15.     print(f"原始单词: {original} -> 词干化后: {stemmed}")

在上述代码中，使用Porter Stemming算法对单词列表进行词干化，然后将原始单词和词干化后的结果进行对比显示。你可以看到算法如何将单词“running”还原为“run”等。执行后会输出：

  1. 原始单词: running -> 词干化后: run
  2. 原始单词: flies -> 词干化后: fli
  3. 原始单词: happily -> 词干化后: happili
  4. 原始单词: stemmer -> 词干化后: stemmer
  5. 原始单词: jumps -> 词干化后: jump
  6. 原始单词: easily -> 词干化后: easili

2. Snowball Stemming算法(Porter2)

Snowball是Porter词干化算法的改进版本，也被称为Porter2。它修复了Porter算法中的一些问题，提供了更准确的词干化，同时支持多种语言。例如下面是一个使用NLTK库来执行Snowball Stemming算法的例子，功能是将一些单词进行词干化，以演示将单词还原到它们的基本形式的过程。

实例2-4：使用Porter2算法将单词还原到它们的基本形式（源码路径：daima/2/gan02.py）

实例文件gan02.py的具体实现代码如下所示。

  1. import nltk
  2. from nltk.stem import SnowballStemmer
  3.  
  4. # 初始化Snowball词干化器
  5. stemmer = SnowballStemmer("english")
  6.  
  7. # 待词干化的单词列表
  8. words = ["jumping", "flies", "happily", "stemming", "jumps", "easily"]
  9.  
  10. # 对每个单词执行词干化
  11. stemmed_words = [stemmer.stem(word) for word in words]
  12.  
  13. # 显示原始单词和词干化后的结果
  14. for original, stemmed in zip(words, stemmed_words):
  15.     print(f"原始单词: {original} -> 词干化后: {stemmed}")

在上述代码中，Snowball Stemming算法的执行结果会将单词"jumping"还原为"jump"，而Porter Stemming算法的结果可能为"jump"。这是两种不同的词干化方法在特定情况下的区别。这个示例突出了Snowball Stemming算法的优势，它更准确地考虑了一些特定的英语语法规则，使得在不同单词上可能产生不同的词干。执行后会输出：

  1. 原始单词: jumping -> 词干化后: jump
  2. 原始单词: flies -> 词干化后: fli
  3. 原始单词: happily -> 词干化后: happili
  4. 原始单词: stemming -> 词干化后: stem
  5. 原始单词: jumps -> 词干化后: jump
  6. 原始单词: easily -> 词干化后: easili

3. Lancaster Stemming算法

Lancaster词干化算法是另一种基于规则的词干化算法，它较Porter算法更加激进，更倾向于将单词截断至更短的形式。它适用于某些任务，但可能会导致一些不常见的单词被切割过度。例如下面是一个使用NLTK库执行Lancaster Stemming算法的例子。

实例2-5：使用Lancaster Stemming算法（源码路径：daima/2/gan03.py）

实例文件gan03.py的具体实现代码如下所示。

  1. import nltk
  2. from nltk.stem import LancasterStemmer
  3.  
  4. # 初始化Lancaster词干化器
  5. stemmer = LancasterStemmer()
  6.  
  7. # 待词干化的单词列表
  8. words = ["running", "flies", "happily", "stemmer", "jumps", "easily"]
  9.  
  10. # 对每个单词执行词干化
  11. stemmed_words = [stemmer.stem(word) for word in words]
  12.  
  13. # 显示原始单词和词干化后的结果
  14. for original, stemmed in zip(words, stemmed_words):
  15.     print(f"原始单词: {original} -> 词干化后: {stemmed}")

在上述代码中，使用Lancaster Stemming算法对单词列表进行词干化，然后将原始单词和词干化后的结果进行对比显示。你可以看到，Lancaster Stemming算法的结果可能更短和更激进，例如将单词"running"词干化为"run"，而不是像Porter Stemming或Snowball Stemming那样产生更多保留的词干。这个示例突出了Lancaster Stemming算法的激进特性，可能适合某些特定的文本处理需求。执行后会输出：

  1. 原始单词: running -> 词干化后: run
  2. 原始单词: flies -> 词干化后: fli
  3. 原始单词: happily -> 词干化后: happy
  4. 原始单词: stemmer -> 词干化后: stem
  5. 原始单词: jumps -> 词干化后: jump
  6. 原始单词: easily -> 词干化后: easy

4. Lovins Stemming算法

Lovins词干化算法是另一种基于规则的算法，与Porter和Lancaster相比，它更简单和保守。它保留了更多的单词形式，不太容易将单词切割过度。请看下面的例子，功能是使用自定义的Lovins Stemming算法来词干化单词。

实例2-6：使用Lovins Stemming算法词干化单词（源码路径：daima/2/gan04.py）

实例文件gan04.py的具体实现代码如下所示。

  1. # 定义Lovins Stemming规则
  2. def apply_lovins_rules(word):
  3.     # Lovins Stemming的简化规则示例
  4.     if word.endswith("ing"):
  5.         return word[:-3]  # 移除-ing后缀
  6.     elif word.endswith("ly"):
  7.         return word[:-2]  # 移除-ly后缀
  8.     else:
  9.         return word  # 保留原始单词
  10.  
  11. # 待词干化的单词列表
  12. words = ["running", "flies", "happily", "stemmer", "jumps", "easily"]
  13.  
  14. # 对每个单词执行词干化
  15. stemmed_words = [apply_lovins_rules(word) for word in words]
  16.  
  17. # 显示原始单词和词干化后的结果
  18. for original, stemmed in zip(words, stemmed_words):
  19.     print(f"原始单词: {original} -> 词干化后: {stemmed}")

上述代码演示了一个简化的Lovins Stemming规则，将以"ing"和"ly"结尾的单词进行处理。请注意，这只是一个示例，实际的Lovins Stemming算法包含更多复杂的规则。执行后会输出：

  1. 原始单词: running -> 词干化后: runn
  2. 原始单词: flies -> 词干化后: flies
  3. 原始单词: happily -> 词干化后: happi
  4. 原始单词: stemmer -> 词干化后: stemmer
  5. 原始单词: jumps -> 词干化后: jumps
  6. 原始单词: easily -> 词干化后: easi

5. Regex-Based Stemming算法

正则表达式也可以用于词干化，根据需要定义一些规则和模式，然后应用正则表达式来匹配和替换单词的后缀。这种方法可以针对特定任务定制，但通常不如基于规则的算法通用。请看下面的例子，功能是使用正则表达式来执行Regex-Based Stemming，对单词应用自定义的词干化规则。

实例2-7：使用正则表达式来执行Regex-Based Stemming（源码路径：daima/2/gan05.py）

实例文件gan05.py的具体实现代码如下所示。

  1. import re
  2.  
  3. # 自定义词干化规则
  4. def custom_stemmer(word):
  5.     # 使用正则表达式匹配规则
  6.     if re.search(r"ing$", word):
  7.         return re.sub(r"ing$", "", word)  # 移除-ing后缀
  8.     elif re.search(r"ly$", word):
  9.         return re.sub(r"ly$", "", word)  # 移除-ly后缀
  10.     else:
  11.         return word  # 保留原始单词
  12.  
  13. # 待词干化的单词列表
  14. words = ["running", "flies", "happily", "stemmer", "jumps", "easily"]
  15.  
  16. # 对每个单词执行词干化
  17. stemmed_words = [custom_stemmer(word) for word in words]
  18.  
  19. # 显示原始单词和词干化后的结果
  20. for original, stemmed in zip(words, stemmed_words):
  21.     print(f"原始单词: {original} -> 词干化后: {stemmed}")

在上述代码中，使用自定义的Regex-Based Stemming规则，使用正则表达式来匹配特定的后缀，然后应用规则来移除这些后缀。在示例中，我们定义了规则以移除以"ing"和"ly"结尾的后缀，但是可以根据需要扩展和定制规则，以适应特定的文本处理需求。执行后会输出：

  1. 原始单词: running -> 词干化后: runn
  2. 原始单词: flies -> 词干化后: flies
  3. 原始单词: happily -> 词干化后: happi
  4. 原始单词: stemmer -> 词干化后: stemmer
  5. 原始单词: jumps -> 词干化后: jumps
  6. 原始单词: easily -> 词干化后: easi

2.2.3  词形还原算法

词形还原（Lemmatization）是自然语言处理中的文本处理技术，旨在将单词还原为它们的基本形式，也被称为词元（lemma）或词根（root）。与词干化（Stemming）不同，词形还原考虑了单词的语法和语境，以确保还原后的单词是合法的，有词法准确性。在下面的内容中，将详细讲解常用的词形还原算法技术。

1. WordNet Lemmatizer

WordNet是一个英语词汇数据库，WordNet Lemmatizer使用WordNet中的词形还原数据来将单词还原为它们的基本形式。在NLTK库中提供了WordNet Lemmatizer。例如下面是一个使用NLTK库中的WordNet Lemmatizer来执行词形还原的示例。在此示例中，我们将一些单词进行词形还原，以演示如何将单词还原为它们的基本形式。

实例2-8：使用WordNet Lemmatizer执行词形还原（源码路径：daima/2/huan.py）

实例文件huan.py的具体实现代码如下所示。

  1. import nltk
  2. from nltk.stem import WordNetLemmatizer
  3.  
  4. # 初始化WordNet Lemmatizer
  5. lemmatizer = WordNetLemmatizer()
  6.  
  7. # 待词形还原的单词列表
  8. words = ["running", "flies", "happily", "stemmer", "jumps", "easily"]
  9.  
  10. # 对每个单词执行词形还原
  11. lemmatized_words = [lemmatizer.lemmatize(word, pos='v') for word in words]
  12.  
  13. # 显示原始单词和词形还原后的结果
  14. for original, lemmatized in zip(words, lemmatized_words):
  15.     print(f"原始单词: {original} -> 词形还原后: {lemmatized}")

在上述代码中，使用了WordNet Lemmatizer来将单词还原为它们的基本形式。参数pos用于指定单词的词性，这里我们将其设置为'verb'（动词），因为示例中的大多数单词都是动词。如果你的文本包含不同词性的单词，可以根据需要进一步调整参数pos。执行后会输出：

  1. 原始单词: running -> 词形还原后: run
  2. 原始单词: flies -> 词形还原后: fly
  3. 原始单词: happily -> 词形还原后: happily
  4. 原始单词: stemmer -> 词形还原后: stemmer
  5. 原始单词: jumps -> 词形还原后: jump
  6. 原始单词: easily -> 词形还原后: easily

2. spaCy

spaCy是一个自然语言处理库，它提供了强大的词形还原功能，包括多语言支持。spaCy的词形还原能力非常出色。请看下面的例子，演示了使用spaCy词形还原单词的过程。

实例2-9：使用spaCy词形还原单词（源码路径：daima/2/huan02.py）

（1）要使用spaCy库来执行词形还原，首先确保你已经安装了spaCy并下载了相应的模型。可以使用以下命令来安装spaCy和下载英语模型：

  1. pip install spacy
  2. python -m spacy download en_core_web_sm

（2）然后可以使用spaCy的词形还原功能，实例文件huan02.py的具体实现代码如下所示。

  1. import spacy
  2.  
  3. # 加载spaCy英语模型
  4. nlp = spacy.load("en_core_web_sm")
  5.  
  6. # 待词形还原的文本
  7. text = "I was running and he jumps easily."
  8.  
  9. # 使用spaCy进行词形还原
  10. doc = nlp(text)
  11.  
  12. # 提取词形还原后的结果
  13. lemmatized_text = " ".join([token.lemma_ for token in doc])
  14.  
  15. # 显示原始文本和词形还原后的结果
  16. print(f"原始文本: {text}")
  17. print(f"词形还原后: {lemmatized_text}")

在上述代码中，首先加载了spaCy的英语模型，然后将文本传递给spaCy的NLP处理管道。最后，我们提取词形还原后的结果，并显示原始文本和词形还原后的结果。执行后会输出：

  1. 原始文本: I was running and he jumps easily.
  2. 词形还原后: -PRON- be run and -PRON- jump easily .

3. StanfordNLP

StanfordNLP是斯坦福大学开发的自然语言处理工具包，它提供了高质量的词形还原功能。请看下面的例子，功能是使用StanfordNLP进行词形还原。

实例2-10：使用StanfordNLP进行词形还原（源码路径：daima/2/huan03.py）

实例文件huan03.py的具体实现代码如下所示。

  1. import stanfordnlp
  2.  
  3. # 初始化StanfordNLP
  4. stanfordnlp.download('en')  # 下载英语模型，如果尚未下载
  5. nlp = stanfordnlp.Pipeline()  # 初始化NLP处理管道
  6.  
  7. # 待词形还原的文本
  8. text = "I was running and he jumps easily."
  9.  
  10. # 使用StanfordNLP进行词形还原
  11. doc = nlp(text)
  12.  
  13. # 提取词形还原后的结果
  14. lemmatized_text = " ".join([word.lemma for sent in doc.sentences for word in sent.words])
  15.  
  16. # 显示原始文本和词形还原后的结果
  17. print(f"原始文本: {text}")
  18. print(f"词形还原后: {lemmatized_text}")

在上述代码中，首先，下载了英语模型，然后初始化了StanfordNLP的处理管道。接着，我们将文本传递给处理管道，提取词形还原后的结果，并最后显示原始文本和词形还原后的文本。执行后会输出：

  1. 原始文本: I was running and he jumps easily.
  2. 词形还原后: I be run and he jump easily .

4. TextBlob

TextBlob是一个简单的自然语言处理库，它包含了词形还原功能，适用于简单的文本处理任务。例如下面是一个使用TextBlob库来实现词形还原的例子。

实例2-11：使用TextBlob库实现词形还原（源码路径：daima/2/huan04.py）

（1）下载NLTK的WordNet数据，因为TextBlob的词形还原功能依赖于WordNet：

python -m textblob.download_corpora

（2）实例文件huan04.py的具体实现代码如下所示。

  1. from textblob import Word
  2.  
  3. # 待词形还原的单词列表
  4. words = ["running", "flies", "happily", "stemmer", "jumps", "easily"]
  5.  
  6. # 对每个单词执行词形还原
  7. lemmatized_words = [Word(word).lemmatize() for word in words]
  8.  
  9. # 显示原始单词和词形还原后的结果
  10. for original, lemmatized in zip(words, lemmatized_words):
  11.     print(f"原始单词: {original} -> 词形还原后: {lemmatized}")

在上述代码中，使用TextBlob的Word类来执行词形还原。对于提供的单词列表，TextBlob会自动将它们还原为它们的基本形式。执行后会输出：

  1. 原始单词: running -> 词形还原后: running
  2. 原始单词: flies -> 词形还原后: fly
  3. 原始单词: happily -> 词形还原后: happily
  4. 原始单词: stemmer -> 词形还原后: stemmer
  5. 原始单词: jumps -> 词形还原后: jump
  6. 原始单词: easily -> 词形还原后: easily

5. 自定义规则

我们还可以创建自定义的词形还原规则，使用正则表达式或特定的语法规则来还原单词，这一方法对于特定任务非常有用。假设你正在处理一个文本中的动物名称，想将这些动物名称还原为它们的单数形式。例如，将"cats"还原为"cat"，"dogs"还原为"dog"等。下面的例子实现了这一功能。

实例2-12：使用特定规则还原单词（源码路径：daima/2/huan05.py）

实例文件huan05.py的具体实现代码如下所示。

  1. # 自定义词形还原规则，将动物名称还原为单数形式
  2. def custom_lemmatize(word):
  3.     # 自定义规则示例：将复数名词还原为单数形式
  4.     if word.lower().endswith("s"):
  5.         return word[:-1]
  6.     return word
  7.  
  8. # 待词形还原的单词列表
  9. animal_names = ["cats", "dogs", "elephants", "puppies", "kangaroos"]
  10.  
  11. # 对每个动物名称执行词形还原
  12. lemmatized_animals = [custom_lemmatize(word) for word in animal_names]
  13.  
  14. # 显示原始动物名称和词形还原后的结果
  15. for original, lemmatized in zip(animal_names, lemmatized_animals):
  16.     print(f"原始动物名称: {original} -> 词形还原后: {lemmatized}")

上述代码演示了使用自定义规则将动物名称还原为它们的单数形式的过程，可以根据具体需求自定义规则，这在某些特定领域或任务中非常有用。执行后会输出：

  1. 原始动物名称: cats -> 词形还原后: cat
  2. 原始动物名称: dogs -> 词形还原后: dog
  3. 原始动物名称: elephants -> 词形还原后: elephant
  4. 原始动物名称: puppies -> 词形还原后: puppie
  5. 原始动物名称: kangaroos -> 词形还原后: kangaroo

未完待续

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

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

  

闽ICP备14008679号