Skip to content

A
apachecn-dl-zh

大唐爆破僧 / apachecn-dl-zh
与 Fork 源项目一致

Fork自 OpenDocCN / apachecn-dl-zh

通知 1
Star 0
Fork 0
A
apachecn-dl-zh

前往新版Gitcode，体验更适合开发者的 AI 搜索 >>

提交 4e4f2330 编写于 作者: W wizardforcel
浏览文件
操作

2021-01-17 16:59:16

上级 593fcb16
隐藏空白更改
内联 并排
Showing with 120 addition and 142 deletion
new/handson-nlp-pt-1x/4.md
浏览文件 @ 4e4f2330
# “第 4 章”：文本预处理，词干和词形还原
# “第 4 章”：文本预处理，词干提取和词形还原
文本数据可以从许多不同的来源收集，并采用许多不同的形式。 文本可以整洁，可读或原始且混乱，也可以采用许多不同的样式和格式。 能够对这些数据进行预处理，以便可以在将其转换为 NLP 模型之前将其转换为标准格式，这就是我们将在本章中介绍的内容。
与标记化相似，词干和词根化是 NLP 预处理的其他形式。 但是，与将文档简化成单个单词的标记化不同，词干和词形还原试图将这些单词进一步缩小到其词根。 例如，几乎所有英语动词都有许多不同的变体，具体取决于时态：
与标记化相似，词干提取和词形还原是 NLP 预处理的其他形式。 但是，与将文档简化成单个单词的标记化不同，词干提取和词形还原试图将这些单词进一步缩小到其词根。 例如，几乎所有英语动词都有许多不同的变体，具体取决于时态：
```py
He jumped
......@@ -12,20 +12,20 @@ He is jumping
He jumps
```
尽管所有这些词都不同，但它们都与相同的根词相关–`jump`。 词干和词根去除都是我们可以用来减少单词的共同词根变化的技术。
尽管所有这些词都不同，但它们都与相同的根词相关–`jump`。 词干提取和词形还原都是我们可以用来减少单词的共同词根变化的技术。
在本章中，我们将解释如何对文本数据执行预处理，并探讨词干和词根化，并展示如何在 Python 中实现这些词干。
在本章中，我们将解释如何对文本数据执行预处理，并探讨词干提取和词形还原，并展示如何在 Python 中实现这些。
在本章中，我们将介绍以下主题：
* 文字预处理
* 抽干
* 合法化
* 词干和词根化的用途
* 词干提取和词形还原的用途
# 技术要求
对于本章中的文本预处理，我们将主要使用内置的 Python 函数，但也将使用外部 **BeautifulSoup** 程序包。 对于词干和词根化，我们将使用 NLTK Python 软件包。 本章中的所有代码都可以在[这个页面](https://github.com/PacktPublishing/Hands-On-Natural-Language-Processing-with-PyTorch-1.x/tree/master/Chapter4)中找到。
对于本章中的文本预处理，我们将主要使用内置的 Python 函数，但也将使用外部 **BeautifulSoup** 程序包。 对于词干提取和词形还原，我们将使用 NLTK Python 软件包。 本章中的所有代码都可以在[这个页面](https://github.com/PacktPublishing/Hands-On-Natural-Language-Processing-with-PyTorch-1.x/tree/master/Chapter4)中找到。
# 文本预处理
......@@ -54,13 +54,12 @@ print('Output: ' + output_text)
预处理文本以将所有内容转换为小写形式时，这是标准做法。 这是因为相同的任何两个单词都应被视为语义相同，而不管它们是否大写。 `Cat`，`cat`和`CAT`都是相同的词，只是大小写不同。 我们的模型通常会将这三个词视为单独的实体，因为它们并不相同。 因此，通常的做法是将所有单词都转换为小写，以使这些单词在语义和结构上都相同。 使用以下代码行可以在 Python 中轻松完成此操作：
input_text = ['Cat'，'cat'，'CAT']
output_text = [input_text 中 x 的 x.lower（）]
print（'Input：'+ str（input_text））
print（'输出：'+ str（输出文本））
```py
input_text = ['Cat','cat','CAT']
output_text =  [x.lower() for x in input_text]
print('Input: ' + str(input_text))
print('Output: ' + str(output_text))
```
这将返回以下输出：
......@@ -84,13 +83,12 @@ The panda eats, shoots, and leaves
在这里，加上逗号会将描述熊猫的饮食习惯的句子转换为描述熊猫武装抢劫餐馆的句子！ 尽管如此，为了保持一致性，能够从句子中删除标点符号仍然很重要。 我们可以使用`re`库在 Python 中执行此操作，以使用正则表达式匹配任何标点符号，并使用`sub()`方法将任何匹配的标点符号替换为空字符：
input_text =“这句，包含”-£no ::标点符号？“
output_text = re.sub（r'[^ \ w \ s]'，''，input_text）
print（'Input：'+ input_text）
print（'Output：'+ output_text）
```py
input_text = "This ,sentence.'' contains-£ no:: punctuation?"
output_text = re.sub(r'[^\w\s]', '', input_text)
print('Input: ' + input_text)
print('Output: ' + output_text)
```
这将返回以下输出：
......@@ -102,13 +100,12 @@ print（'Output：'+ output_text）
在某些情况下，我们可能不希望直接删除标点符号。 一个很好的例子是的使用和号（`&`），在几乎每种情况下，它都与单词`and`互换使用。 因此，与其完全删除“＆”号，不如选择直接用`and`一词代替。 我们可以使用`.replace()`函数在 Python 中轻松实现此功能：
input_text =“猫和狗”
output_text = input_text.replace（“＆”，“ and”）
print（'Input：'+ input_text）
print（'Output：'+ output_text）
```py
input_text = "Cats & dogs"
output_text = input_text.replace("&", "and")
print('Input: ' + input_text)
print('Output: ' + output_text)
```
这将返回以下输出：
......@@ -134,27 +131,19 @@ namegmailcom
同样，对于数字，我们也想标准化我们的输出。 数字可以写为数字（9、8、7）或实际单词（九，八，七）。 可能值得将所有这些转换为一个标准化的表示形式，这样就不会将 1 和 1 视为单独的实体。 我们可以使用以下方法在 Python 中执行此操作：
def to_digit（digit）：
我= inflect.engine（）
如果 digit.isdigit（）：
输出= i.number_to_words（数字）
其他：
输出=数字
返回输出
input_text = [“ 1”，“两个”，“ 3”]
output_text = [输入文本中 x 的 to_digit（x）]
print（'Input：'+ str（input_text））
print（'输出：'+ str（输出文本））
```py
def to_digit(digit):
    i = inflect.engine()
    if digit.isdigit():
        output = i.number_to_words(digit)
    else:
        output = digit
    return output
input_text = ["1","two","3"]
output_text = [to_digit(x) for x in input_text]
print('Input: ' + str(input_text))
print('Output: ' + str(output_text))
```
这将返回以下输出：
......@@ -166,13 +155,12 @@ print（'输出：'+ str（输出文本））
但是，以类似于处理电子邮件地址的方式，处理电话号码可能不需要与常规电话号码相同的表示形式。 在以下示例中对此进行了说明：
input_text = [“ 0800118118”]
output_text = [输入文本中 x 的 to_digit（x）]
print（'Input：'+ str（input_text））
print（'输出：'+ str（输出文本））
```py
input_text = ["0800118118"]
output_text = [to_digit(x) for x in input_text]
print('Input: ' + str(input_text))
print('Output: ' + str(output_text))
```
这将返回以下输出：
......@@ -218,25 +206,27 @@ Cat -> Cats' (Plural possessive)
"His cats' fur are different colors" -> "He cat fur be different color"
```
词干和词根去除是我们得出这些词根的过程。 **词干提取**是一个算法过程，其中，切掉单词的末尾以到达一个共同的词根，而词形还原使用单词本身的真实词汇和结构分析来得出它们的真正词根，即**词形**。 在下面的部分中，我们将详细介绍这两种方法。
词干提取和词形还原是我们得出这些词根的过程。 **词干提取**是一个算法过程，其中，切掉单词的末尾以到达一个共同的词根，而词形还原使用单词本身的真实词汇和结构分析来得出它们的真正词根，即**词形**。 在下面的部分中，我们将详细介绍这两种方法。
## 词干提取
**词干提取**是一个算法过程，通过该算法，我们将单词的末尾切掉以达到其词根或**词干**。 为此，我们可以使用不同的**词干提取器**，每个词干都遵循特定算法，以便返回单词的词干。 用英语，最常见的词干之一是 Porter 词干提取器。
**词干提取**是一个算法过程，通过该算法，我们将单词的末尾切掉以达到其词根或**词干**。 为此，我们可以使用不同的**词干提取器**，每个词干都遵循特定算法，以便返回单词的词干。 用英语，最常见的词干提取器之一是 Porter 词干提取器。
**Porter 词干提取器**是具有大量逻辑规则的算法，可用于返回单词的词干。 在继续讨论该算法之前，我们将首先展示如何使用 NLTK 在 Python 中实现 Porter 词干提取器。
1. 首先，我们创建一个 Porter 词干提取器的实例。
搬运工= PorterStemmer（）
```py
porter = PorterStemmer()
```
2. 然后，我们只需在单个单词上调用这个词干提取器的实例，并打印结果。在这里，我们可以看到 Porter 词干提取器返回的词干的一个例子。
word_list = [“ see”，“ saw”，“ cat”，“ cats”，“ stem”，“ stemming”，“ lemma”，“ lemmatization”，“ known”，“ knowing”，“ time”，“ timing” ，“足球”，“足球运动员”]
对于 word_list 中的单词：
打印（word +'->'+ porter.stem（word））
```py
word_list = ["see","saw","cat", "cats", "stem", "stemming","lemma","lemmatization","known","knowing","time", "timing","football", "footballers"]
for word in word_list:
    print(word + ' -> ' + porter.stem(word))
```
结果为以下输出：
......@@ -246,23 +236,21 @@ Cat -> Cats' (Plural possessive)
3. 我们也可以对整个句子应用词干提取，首先将句子符号化，然后对每个词单独进行词干提取。
def SentenceStemmer（sentence）：
tokens = word_tokenize（句子）
stems = [porter.stem（word）表示令牌中的单词]
返回“” .join（stems）
SentenceStemmer（“猫和狗在奔跑”）
```py
def SentenceStemmer(sentence):
    tokens=word_tokenize(sentence)
    stems=[porter.stem(word) for word in tokens]
    return " ".join(stems)
SentenceStemmer('The cats and dogs are running')
```
这将返回以下输出：
![Figure 4.8 – Applying stemming to a sentence ](img/B12365_04_08.jpg)
图 4.8 –对句子应用词干
图 4.8 –对句子应用词干提取
在这里，我们可以看到如何使用 Porter Stemmer 提取不同的单词。 有些词，例如`stemming`和`timing`，减少到`stem`和`time`的预期茎。 但是，某些单词，例如`saw`，并没有还原为它们的逻辑词干（`see`）。 这说明了 Porter Stemmer 的局限性。 由于词干对单词应用了一系列逻辑规则，因此很难定义一组可以正确词干所有单词的规则。 在英语单词中，根据时态（`is/was/be`）完全改变单词的情况下尤其如此。 这是因为没有通用规则可应用于这些单词，以将它们全部转换为相同的词根。
在这里，我们可以看到如何使用 Porter Stemmer 提取不同的单词。 有些词，例如`stemming`和`timing`，减少到`stem`和`time`的预期茎。 但是，某些单词，例如`saw`，并没有还原为它们的逻辑词干（`see`）。 这说明了 Porter Stemmer 的局限性。 由于词干提取器对单词应用了一系列逻辑规则，因此很难定义一组可以正确所有单词的词干的规则。 在英语单词中，根据时态（`is/was/be`）完全改变单词的情况下尤其如此。 这是因为没有通用规则可应用于这些单词，以将它们全部转换为相同的词根。
我们可以更详细地研究 Porter 词干提取器所应用的一些规则，以准确了解向茎的转化是如何发生的。 尽管实际的波特算法有许多详细的步骤，但是在这里，我们将简化一些规则以便于理解：
......@@ -270,25 +258,23 @@ Cat -> Cats' (Plural possessive)
图 4.9 – Porter 词干提取器算法的规则
虽然不必了解 Porter 词干提取器中的每个规则，但关键是要了解其局限性。 虽然已经证明了 Porter 词干提取器在整个语料库中都能很好地工作，但总有人会说它不能正确地还原成它们的真实词干。 由于 Porter 词干提取器的规则集依赖于英语单词结构的约定，因此总会有一些单词不属于常规单词结构，并且不能被这些规则正确转换。 幸运的是，可以通过使用词形来克服这些限制中的某些限制。
虽然不必了解 Porter 词干提取器中的每个规则，但关键是要了解其局限性。 虽然已经证明了 Porter 词干提取器在整个语料库中都能很好地工作，但总有人会说它不能正确地还原成它们的真实词干。 由于 Porter 词干提取器的规则集依赖于英语单词结构的约定，因此总会有一些单词不属于常规单词结构，并且不能被这些规则正确转换。 幸运的是，可以通过使用词形还原来克服这些限制中的某些限制。
## 词形还原
**词形还原**与词干提取的区别在于，词干减少为**词形**而不是词干。 在处理单词的词干并将其简化为字符串时，单词的词形是其真正的词根。 因此，虽然`ran`的词干只是`ran`，但它的词形是该词的真正词根，也就是`run`。
**词形还原**与词干提取的区别在于，它将单词减少为**词形**而不是词干。 虽然单词的词干可以被处理并简化为字符串，单词的词形是其真正的词根。 因此，虽然`ran`的词干只是`ran`，但它的词形是该词的真正词根，也就是`run`。
词义化过程使用内置的预先计算的词法和关联词以及句子中词的上下文来确定给定词的正确词法。 在此示例中，我们将研究在 NLTK 中使用 **WordNet 词形还原器**。 WordNet 是一个庞大的英语单词及其词汇关系数据库。 它包含了英语中最强大，最全面的映射之一，特别是关于单词与其词形的关系。
我们将首先创建词形还原器的实例，并在一系列单词上调用它：
wordnet_lemmatizer = WordNetLemmatizer（）
打印（wordnet_lemmatizer.lemmatize（'horses'））
打印（wordnet_lemmatizer.lemmatize（'wolves'））
打印（wordnet_lemmatizer.lemmatize（'mice'））
打印（wordnet_lemmatizer.lemmatize（'cacti'））
```py
wordnet_lemmatizer = WordNetLemmatizer()
print(wordnet_lemmatizer.lemmatize('horses'))
print(wordnet_lemmatizer.lemmatize('wolves'))
print(wordnet_lemmatizer.lemmatize('mice'))
print(wordnet_lemmatizer.lemmatize('cacti'))
```
结果为以下输出：
......@@ -296,11 +282,12 @@ wordnet_lemmatizer = WordNetLemmatizer（）
图 4.10 –最小化输出
在这里，我们已经可以开始看到使用词形还原胜于词干的优势。 由于 WordNet Lemmatizer 建立在英语所有单词的数据库上，因此知道`mice`是`mouse`的复数形式。 我们将无法使用词干达到相同的根源。 尽管词形还原在大多数情况下效果更好，但由于它依赖于内置的单词索引，因此无法将其推广到新单词或虚构单词：
在这里，我们已经可以开始看到使用词形还原胜于词干提取的优势。 由于 WordNet Lemmatizer 建立在英语所有单词的数据库上，因此知道`mice`是`mouse`的复数形式。 我们将无法使用词干提取达到相同的词根。 尽管词形还原在大多数情况下效果更好，但由于它依赖于内置的单词索引，因此无法将其推广到新单词或虚构单词：
打印（wordnet_lemmatizer.lemmatize（'madeupwords'））
打印（porter.stem（'madeupwords'））
```py
print(wordnet_lemmatizer.lemmatize('madeupwords'))
print(porter.stem('madeupwords'))
```
结果为以下输出：
......@@ -308,13 +295,14 @@ wordnet_lemmatizer = WordNetLemmatizer（）
图 4.11 –虚词的词法输出
在这里，我们可以看到，在这种情况下，我们的词干能够更好地推广到以前看不见的单词。 因此，如果我们要对来源进行词形还原，其语言不一定与*真实*英语匹配，则使用词形还原器可能会是一个问题，例如人们经常会缩写语言的社交媒体网站。
在这里，我们可以看到，在这种情况下，我们的词干提取器能够更好地推广到以前看不见的单词。 因此，如果我们要对来源进行词形还原，其语言不一定与*真实*英语匹配，则使用词形还原器可能会是一个问题，例如人们经常会缩写语言的社交媒体网站。
如果我们使用两个动词调用词形还原器，则会发现这不会将它们简化为预期的常见词形：
打印（wordnet_lemmatizer.lemmatize（'run'））
打印（wordnet_lemmatizer.lemmatize（'ran'））
```py
print(wordnet_lemmatizer.lemmatize('run'))
print(wordnet_lemmatizer.lemmatize('ran'))
```
结果为以下输出：
......@@ -324,9 +312,10 @@ wordnet_lemmatizer = WordNetLemmatizer（）
这是因为我们的 lemmatizer 依靠单词的上下文来返回 lemmas。 回想一下我们的 POS 分析，我们可以轻松地返回句子中单词的上下文并确定给定单词是名词，动词还是形容词。 现在，让我们手动指定我们的单词是动词。 我们可以看到现在可以正确返回词形：
打印（wordnet_lemmatizer.lemmatize（'ran'，pos ='v'））
打印（wordnet_lemmatizer.lemmatize（'run'，pos ='v'））
```py
print(wordnet_lemmatizer.lemmatize('ran', pos='v'))
print(wordnet_lemmatizer.lemmatize('run', pos='v'))
```
结果为以下输出：
......@@ -334,15 +323,14 @@ wordnet_lemmatizer = WordNetLemmatizer（）
图 4.13 –在功能中实现 POS
这意味着为了返回任何给定句子的正确词形，我们必须首先执行 POS 标记以获得句子中词的上下文，然后将其传递给词形处理器以获取每个词的词缀 在句子中。 我们首先创建一个函数，该函数将为句子中的每个单词返回 POS 标签：
句子=“猫和狗在奔跑”
def return_word_pos_tuples（句子）：
返回 nltk.pos_tag（nltk.word_tokenize（句子））
这意味着为了返回任何给定句子的正确词形，我们必须首先执行 POS 标记以获得句子中词的上下文，然后将其传递给词形还原器以获取每个词的词形 在句子中。 我们首先创建一个函数，该函数将为句子中的每个单词返回 POS 标签：
return_word_pos_tuples（句子）
```py
sentence = 'The cats and dogs are running'
def return_word_pos_tuples(sentence):
    return nltk.pos_tag(nltk.word_tokenize(sentence))
return_word_pos_tuples(sentence)
```
结果为以下输出：
......@@ -352,19 +340,15 @@ return_word_pos_tuples（句子）
请注意，这如何为句子中的每个单词返回 NLTK POS 标签。 我们的 WordNet lemmatizer 对 POS 的输入要求略有不同。 这意味着我们首先创建，该函数将 NLTK POS 标签映射到所需的 WordNet POS 标签：
def get_pos_wordnet（pos_tag）：
pos_dict = {“ N”：wordnet.NOUN，
“ V”：wordnet.VERB，
“ J”：wordnet.ADJ，
“ R”：wordnet.ADV}
返回 pos_dict.get（pos_tag [0] .upper（），wordnet.NOUN）
get_pos_wordnet（'VBG'）
```py
def get_pos_wordnet(pos_tag):
    pos_dict = {"N": wordnet.NOUN,
                "V": wordnet.VERB,
                "J": wordnet.ADJ,
                "R": wordnet.ADV}
    return pos_dict.get(pos_tag[0].upper(), wordnet.NOUN)
get_pos_wordnet('VBG')
```
结果为以下输出：
......@@ -374,23 +358,17 @@ get_pos_wordnet（'VBG'）
最后，我们将这些功能组合为一个最终功能，该功能将对整个句子执行词形还原：
def lemmatize_with_pos（句子）：
new_sentence = []
元组= return_word_pos_tuples（句子）
用于元组中的 tup：
pos = get_pos_wordnet（tup [1]）
主题= wordnet_lemmatizer.lemmatize（sup [0]，pos = pos）
new_sentence.append（lemma）
返回 new_sentence
lemmatize_with_pos（句子）
```py
def lemmatize_with_pos(sentence):
    new_sentence = []
    tuples = return_word_pos_tuples(sentence)
    for tup in tuples:
        pos = get_pos_wordnet(tup[1])
        lemma = wordnet_lemmatizer.lemmatize(tup[0], pos=pos)
        new_sentence.append(lemma)
    return new_sentence
lemmatize_with_pos(sentence)
```
结果为以下输出：
......@@ -398,22 +376,22 @@ lemmatize_with_pos（句子）
图 4.16 –最终的 lemmatization 函数的输出
在这里，我们可以看到，与词干相比，词缀通常可以更好地表示单词的真实词根，但有一些明显的例外。 当我们可能决定使用时，词干的词根化取决于当前任务的要求，其中一些我们现在将讨论。
在这里，我们可以看到，与词干提取相比，词形通常可以更好地表示单词的真实词根，但有一些明显的例外。 当我们可能决定使用时，词干提取和词形还原取决于当前任务的要求，其中一些我们现在将讨论。
# 词干和词根化的用途
# 词干提取和词形还原的用途
词干和词根化都是 NLP 的一种形式，可用于从文本中提取信息。 该被称为**文本挖掘**。 文本挖掘任务有多种类别，包括文本聚类，分类，文档汇总和情感分析。 可以将词干和词条限制处理与深度学习一起使用，以解决其中的一些任务，这将在本书的后面看到。
词干提取和词形还原都是 NLP 的一种形式，可用于从文本中提取信息。 该被称为**文本挖掘**。 文本挖掘任务有多种类别，包括文本聚类，分类，文档汇总和情感分析。 可以将词干提取和词形还原与深度学习一起使用，以解决其中的一些任务，这将在本书的后面看到。
通过使用词干和词根化进行预处理，再加上停用词的去除，我们可以更好地减少句子以了解其核心含义。 通过删除对句子的意义没有显着贡献的单词，并通过减少单词的词根或词形，我们可以在深度学习框架内有效地分析句子。 如果能够将 10 个单词的句子减少为由多个核心词形而不是相似单词的多个变体组成的五个单词，则意味着我们需要通过神经网络提供的数据要少得多。 如果我们使用词袋表示法，则由于多个词都归结为相同的词形，我们的语料库会大大缩小，而如果我们计算嵌入表示法，则对于一个词，捕获我们单词的真实表示法所需的维数会更小。 减少语料库。
通过使用词干提取和词形还原进行预处理，再加上停用词的去除，我们可以更好地减少句子以了解其核心含义。 通过删除对句子的意义没有显着贡献的单词，并通过减少到单词的词根或词形，我们可以在深度学习框架内有效地分析句子。 如果能够将 10 个单词的句子减少为由多个核心词形而不是相似单词的多个变体组成的五个单词，则意味着我们需要通过神经网络提供的数据要少得多。 如果我们使用词袋表示法，则由于多个词都归结为相同的词形，我们的语料库会大大缩小，而如果我们计算嵌入表示法，则对于一个词，捕获我们单词的真实表示法所需的维数会更小。 减少语料库。
## 词干和词干的差异
## 词干提取和词形还原的差异
现在我们已经看到了残局化和词根抑制，在的问题上，仍然存在问题，在什么情况下我们应该同时使用这两种技术。 我们看到，两种技术都试图将每个单词的根都减少。 在词根提取中，可能只是目标房间的简化形式，而在词形还原中，它会还原为真正的英语单词词根。
现在我们已经看到了词干提取和词形还原，在的问题上，仍然存在问题，在什么情况下我们应该同时使用这两种技术。 我们看到，两种技术都试图将每个单词的根都减少。 在词干提取中，可能只是目标房间的简化形式，而在词形还原中，它会还原为真正的英语单词词根。
因为词义化需要在 WordNet 语料库中交叉引用目标词，并执行词性分析以确定词义的形式，所以如果必须使用大量词，这可能会花费大量的处理时间。 形容词 这与词干相反，词干使用详细但相对较快的算法来词干。 最终，与计算中的许多问题一样，这是在速度与细节之间进行权衡的问题。 在选择将这些方法中的哪一种纳入我们的深度学习流程时，要在速度和准确率之间进行权衡。 如果时间很重要，那么阻止可能是要走的路。 另一方面，如果您需要模型尽可能详细和准确，则限制词形还原可能会产生更好的模型。
因为词义化需要在 WordNet 语料库中交叉引用目标词，并执行词性分析以确定词义的形式，所以如果必须使用大量词，这可能会花费大量的处理时间。 形容词 这与词干提取相反，词干提取使用详细但相对较快的算法来提取词干。 最终，与计算中的许多问题一样，这是在速度与细节之间进行权衡的问题。 在选择将这些方法中的哪一种纳入我们的深度学习流程时，要在速度和准确率之间进行权衡。 如果时间很重要，那么阻止可能是要走的路。 另一方面，如果您需要模型尽可能详细和准确，则限制词形还原可能会产生更好的模型。
# 摘要
在本章中，我们通过探讨两种方法的功能，它们的用例以及如何实现它们，详细讨论了词干和词根化。 既然我们已经涵盖了深度学习和 NLP 预处理的所有基础知识，我们就可以开始从头开始训练我们自己的深度学习模型。
在本章中，我们通过探讨两种方法的功能，它们的用例以及如何实现它们，详细讨论了词干提取和词形还原。 既然我们已经涵盖了深度学习和 NLP 预处理的所有基础知识，我们就可以开始从头开始训练我们自己的深度学习模型。
在下一章中，我们将探讨 NLP 的基础知识，并演示如何在深度 NLP 领域中建立最广泛使用的模型：循环神经网络。
\ No newline at end of file
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或