【动手学深度学习-Pytorch版】文本预处理（使用d2l库）

Coisíní℘

已于 2023-11-15 21:22:04 修改

阅读量364

点赞数

分类专栏：动手学深度学习-Pytorch版文章标签：深度学习 pytorch 人工智能

于 2023-09-12 21:46:48 首次发布

本文链接：https://blog.csdn.net/qq_43858783/article/details/132840580

版权

动手学深度学习-Pytorch版专栏收录该内容

29 篇文章 4 订阅

订阅专栏

在项目的开始，首先需要明确相关的基本概念：词元、词表、语料、未知词元


词元	词元（token）是指在自然语言处理中，将文本拆分成最小的语言单元或符号的过程。它可以是一个词、一个字符、一个标点符号，或者在一些情况下可以是一个子词或特定的字符序列。
词表	将字符串类型的词元映射到从数字0开始的索引中，通常词表是一个字典类型
语料	将训练集中的所有文档合并在一起，对它们唯一的词元进行统计，其得到的统计结果就是语料
未知词元	语料库中不存在或已删除的任何词元都将映射到一个特定的未知词元“”。我们可以选择增加一个列表，用于保存那些被保留的词元，例如：填充词元 $（ “ < p a d > ” ）$ ；序列开始词元 $（ “ < b os > ” ）$ ；序列结束词元 $（ “ < eos > ” ）$

算法流程

数据集下载与字符处理

首先是数据集的下载与字符的处理。read_time_machine()函数利用d2l.download()函数下载数据集，并将数据集加载到文本行的列表中，同时re.sub()函数替换文本中除了a到z和A到Z以外的所有内容为空格。另外，使用strip()函数移除字符串头尾默认的空格；使用lower()函数将文档中所有的字符统一改写为小写格式。

代码块

def read_time_machine():  # @save
    """将时间机器数据集加载到文本行的列表中"""
    with open(d2l.download('time_machine'), 'r') as f:
        lines = f.readlines()
    #return [re.sub('[^A-Za-z]+', ' ', line).strip().lower() for line in lines]
    return [re.sub('[^A-Za-z]+', ' ', line).strip().lower() for line in lines]
    # re.sub()函数共有5个参数：
    # pattern：表示正则中的模式字符串；
    # repl：表示要替换的字符串（即匹配到pattern后替换为repl），也可以是个函数；
    # string：表示要被处理（查找替换）的原始字符串；
    # count：可选参数，表示要替换的最大次数，而且必须是非负整数，该参数默认为0，即所有的匹配都会替换；
    # flags：可选参数，表示编译时用的匹配模式（如忽略大小写、多行模式等），数字形式，默认为0。

    # sub:将非大小写的东西都变成' '
    # strip: 用于移除字符串头尾指定的字符 ( 默认为空白符 ) 空格
    # lower: Python中的lower()方法是用于转换字符串中所有大写字符为小写。
    # count_corpus()
lines = read_time_machine()
# print(lines)
print(f'# 文本总行数: {len(lines)}')
print(lines[0])
print(lines[10])

词元化

tokenize()操作通常是自然语言处理中常用操作，即将整篇文本拆成单词(word)或字符(char)等词元。同时，这里还枚举了前11个拆分的词元。

代码块

def tokenize(lines,token='word'):
    """将文本拆分成单词或者字符词元"""
    if token == 'word':
        return [line.split() for line in lines]
    elif token == 'char':
        return [list(line) for line in lines]
    else:
        print('错误，未知词元类型'+token)
tokens = tokenize(lines)
for i in range(11):
    print(tokens[i])

构建词表

词元的类型是字符串，而模型需要的输入是数字，因此这种类型不方便模型使用。现在，让我们构建一个字典，通常也叫做词表（vocabulary），用来将字符串类型的词元映射到从开始的数字索引中。我们先将训练集中的所有文档合并在一起，对它们的唯一词元进行统计，得到的统计结果称之为语料（corpus）。然后根据每个唯一词元的出现频率，为其分配一个数字索引。很少出现的词元通常被移除，这可以降低复杂性。另外，语料库中不存在或已删除的任何词元都将映射到一个特定的未知词元“”。我们可以选择增加一个列表，用于保存那些被保留的词元，例如：填充词元 $（ “ < p a d > ” ）$ ；序列开始词元 $（ “ < b os > ” ）$ ；序列结束词元 $（ “ < eos > ” ）$ 。[来自: d2l官网]
在__init__()函数中完成了以下操作：

判断token是否为空，如果为空则将其对应的列表对象赋空
判断reserved_tokens是否为空，如果为空则将其对应的列表对象赋空
再次利用count_corpus()函数根据词元出现的频率进行排序，采用关键字第一维度的降序排列，即高频词在前，低频词在后的形式
将 ${"<unk>"}$ 类型token放到下标为0的位置，即其索引位置为0
uniq_tokens的位置位于 ${"<unk>"}$ 类型与reserved_tokens的后面
将上述排序后的tokens根据其频率大小放入uniq_tokens里面且每个tokens有且仅有一个，频率大于min_freq
构造idx_to_token 的列表并构造 token_to_idx的字典
构造求uniq_tokens的长度的函数
构造给出tokens返回其对应索引idx的函数
10.构造给出索引idx返回其对应的tokens的函数

代码段

"""词表——构建的一个字典用来将字符串类型的词元映射到从0开始的数字索引中"""
class Vocab:  #@save
    """构建词表"""
    def __init__(self,tokens=None,min_freq=0,reserved_tokens=None):
        if tokens is None:
            tokens = []
        if reserved_tokens is None:
            reserved_tokens = []
        # 根据词元出现的频率进行排序：降序【关键字为x的第一维度】
        counter = count_corpus(tokens)
        # print('counter的类型：',type(counter))
        # print('counter中的内容:',counter.items())# 键值对
        self.token_freqs = sorted(counter.items(), key=lambda x: x[1],
                                   reverse=True)
        self.unk,uniq_tokens = 0,['<unk>']+reserved_tokens
        print('uniq_tokens的值:',uniq_tokens)
        # 字典中的token
        uniq_tokens += [
            token for token,freq in self.token_freqs
            if freq >= min_freq and token not in uniq_tokens
        ]
        self.idx_to_token,self.token_to_idx = [],dict()
        # 构造idx_to_token 的列表 并构造 token_to_idx的字典
        for token in uniq_tokens:
            self.idx_to_token.append(token)
            self.token_to_idx[token] = len(self.idx_to_token)-1 #因为token_to_idx的下标从0开始，比idx_to_token自身长度小1
    def __len__(self):
        # 长度是uniq_token的个数
        return len(self.idx_to_token)
    def __getitem__(self, tokens):
        #给出token返回其对应的idx
        if not isinstance(tokens,(list,tuple)):
            return self.token_to_idx.get(tokens,self.unk)
        return [self.__getitem__(token) for token in tokens]
    def to_tokens(self,indices):
        #给出idx返回其对应的字符串token
        if not isinstance(indices,(list,tuple)):
            return self.idx_to_token[indices]
        return [self.idx_to_token[index] for index in indices]

功能整合

在使用上述函数时，我们将所有功能打包到load_corpus_time_machine函数中，该函数返回corpus（词元索引列表）和vocab（时光机器语料库的词表）。我们在这里所做的改变是：

为了简化后面章节中的训练，我们使用字符（而不是单词）实现文本词元化；
时光机器数据集中的每个文本行不一定是一个句子或一个段落，还可能是一个单词，因此返回的corpus仅处理为单个列表，而不是使用多词元列表构成的一个列表。

代码块

"""整合所有功能"""
"""
在使用上述函数时，我们将所有功能打包到load_corpus_time_machine函数中， 
该函数返回corpus（词元索引列表）和vocab（时光机器语料库的词表）。 
我们在这里所做的改变是：
为了简化后面章节中的训练，我们使用字符（而不是单词）实现文本词元化；
时光机器数据集中的每个文本行不一定是一个句子或一个段落，还可能是一个
单词，因此返回的corpus仅处理为单个列表，而不是使用多词元列表构成的一个列表。
"""
def load_corpus_time_machine(max_tokens=-1):  #@save
    """返回时光机器数据集的词元索引列表和词表"""
    lines = read_time_machine()
    tokens = tokenize(lines, 'char')
    vocab = Vocab(tokens)
    # 因为时光机器数据集中的每个文本行不一定是一个句子或一个段落，
    # 所以将所有文本行展平到一个列表中
    corpus = [vocab[token] for line in tokens for token in line] #因为它拿到vacab中的是token 所以出来的是idx的值
    # corpus是一长串的整数,每一个整数对应的是一个token
    print('corpus的值:',corpus)
    if max_tokens > 0:
        corpus = corpus[:max_tokens]
    return corpus, vocab

corpus, vocab = load_corpus_time_machine()
print('corpus的长度：',len(corpus),'vocab的长度：',len(vocab))

省流版-完整代码

"""
需要注意的是：对于训练数据形成的vocab 其也应该应用于测试数据集上，而不是根据测试数据集重新生成一个vocab
"""

import collections
import re

from d2l import torch as d2l

# @save
d2l.DATA_HUB['time_machine'] = (d2l.DATA_URL + 'timemachine.txt',
                                '090b5e7e70c295757f55df93cb0a180b9691891a')


def read_time_machine():  # @save
    """将时间机器数据集加载到文本行的列表中"""
    with open(d2l.download('time_machine'), 'r') as f:
        lines = f.readlines()
    #return [re.sub('[^A-Za-z]+', ' ', line).strip().lower() for line in lines]
    return [re.sub('[^A-Za-z]+', ' ', line).strip().lower() for line in lines]
    # re.sub()函数共有5个参数：
    # pattern：表示正则中的模式字符串；
    # repl：表示要替换的字符串（即匹配到pattern后替换为repl），也可以是个函数；
    # string：表示要被处理（查找替换）的原始字符串；
    # count：可选参数，表示要替换的最大次数，而且必须是非负整数，该参数默认为0，即所有的匹配都会替换；
    # flags：可选参数，表示编译时用的匹配模式（如忽略大小写、多行模式等），数字形式，默认为0。

    # sub:将非大小写的东西都变成' '
    # strip: 用于移除字符串头尾指定的字符 ( 默认为空白符 ) 空格
    # lower: Python中的lower()方法是用于转换字符串中所有大写字符为小写。
    # count_corpus()
lines = read_time_machine()
# print(lines)
print(f'# 文本总行数: {len(lines)}')
print(lines[0])
print(lines[10])

def tokenize(lines,token='word'):
    """将文本拆分成单词或者字符词元"""
    if token == 'word':
        return [line.split() for line in lines]
    elif token == 'char':
        return [list(line) for line in lines]
    else:
        print('错误，未知词元类型'+token)
tokens = tokenize(lines)
for i in range(11):
    print(tokens[i])


"""词表——构建的一个字典用来将字符串类型的词元映射到从0开始的数字索引中"""
class Vocab:  #@save
    """构建词表"""
    def __init__(self,tokens=None,min_freq=0,reserved_tokens=None):
        if tokens is None:
            tokens = []
        if reserved_tokens is None:
            reserved_tokens = []
        # 根据词元出现的频率进行排序：降序【关键字为x的第一维度】
        counter = count_corpus(tokens)
        # print('counter的类型：',type(counter))
        # print('counter中的内容:',counter.items())# 键值对
        self.token_freqs = sorted(counter.items(), key=lambda x: x[1],
                                   reverse=True)
        self.unk,uniq_tokens = 0,['<unk>']+reserved_tokens
        print('uniq_tokens的值:',uniq_tokens)
        # 字典中的token
        uniq_tokens += [
            token for token,freq in self.token_freqs
            if freq >= min_freq and token not in uniq_tokens
        ]
        self.idx_to_token,self.token_to_idx = [],dict()
        # 构造idx_to_token 的列表 并构造 token_to_idx的字典
        for token in uniq_tokens:
            self.idx_to_token.append(token)
            self.token_to_idx[token] = len(self.idx_to_token)-1 #因为token_to_idx的下标从0开始，比idx_to_token自身长度小1
    def __len__(self):
        # 长度是uniq_token的个数
        return len(self.idx_to_token)
    def __getitem__(self, tokens):
        #给出token返回其对应的idx
        if not isinstance(tokens,(list,tuple)):
            return self.token_to_idx.get(tokens,self.unk)
        return [self.__getitem__(token) for token in tokens]
    def to_tokens(self,indices):
        #给出idx返回其对应的字符串token
        if not isinstance(indices,(list,tuple)):
            return self.idx_to_token[indices]
        return [self.idx_to_token[index] for index in indices]
def count_corpus(tokens):  #@save
    """统计词元的频率"""
    # 这里的tokens是1D列表或2D列表
    if len(tokens) == 0 or isinstance(tokens[0], list):
        # 将词元列表展平成一个列表
        tokens = [token for line in tokens for token in line]
    return collections.Counter(tokens)
vocab = Vocab(tokens)
print(list(vocab.token_to_idx.items())[:10])
# 现在，我们可以将每一条文本行转换成一个数字索引列表。
for i in [0, 10]:
    print('文本:', tokens[i])  #对应的词元
    print('索引:', vocab[tokens[i]]) #词元对应的索引

"""整合所有功能"""
"""
在使用上述函数时，我们将所有功能打包到load_corpus_time_machine函数中， 
该函数返回corpus（词元索引列表）和vocab（时光机器语料库的词表）。 
我们在这里所做的改变是：
为了简化后面章节中的训练，我们使用字符（而不是单词）实现文本词元化；
时光机器数据集中的每个文本行不一定是一个句子或一个段落，还可能是一个
单词，因此返回的corpus仅处理为单个列表，而不是使用多词元列表构成的一个列表。
"""
def load_corpus_time_machine(max_tokens=-1):  #@save
    """返回时光机器数据集的词元索引列表和词表"""
    lines = read_time_machine()
    tokens = tokenize(lines, 'char')
    vocab = Vocab(tokens)
    # 因为时光机器数据集中的每个文本行不一定是一个句子或一个段落，
    # 所以将所有文本行展平到一个列表中
    corpus = [vocab[token] for line in tokens for token in line] #因为它拿到vacab中的是token 所以出来的是idx的值
    # corpus是一长串的整数,每一个整数对应的是一个token
    print('corpus的值:',corpus)
    if max_tokens > 0:
        corpus = corpus[:max_tokens]
    return corpus, vocab

corpus, vocab = load_corpus_time_machine()
print('corpus的长度：',len(corpus),'vocab的长度：',len(vocab))