文本预处理《动手学深度学习》

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]

lines = read_time_machine()
print(f'# 文本总行数: {len(lines)}')
print(lines[0])
print(lines[10])

output:
Downloading ..\data\timemachine.txt from http://d2l-data.s3-accelerate.amazonaws.com/timemachine.txt...
# 文本总行数: 3221
the time machine by h g wells
twinkled and his usually pale face was flushed and animated the

python语法函数官方文档：
10. 完整的语法规范 — Python 3.8.18 文档

#将文本行列表lines作为输入，列表的每个元素是一个文本序列。
#每个文本序列被拆分为一个词元列表。
#所以函数将会返回一个二重的list，词元是list的基本单位。
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)
print(tokens[i])
#一个单词为一个词元 
output:
['the', 'time', 'machine', 'by', 'h', 'g', 'wells']

tokens=tokenize(lines,token='char')
print(tokens[0])
#一个字符为一个词元
output:
['t', 'h', 'e', ' ', 't', 'i', 'm', 'e', ' ', 'm', 'a', 'c', 'h', 'i', 'n', 'e', ' ', 'b', 'y', ' ', 'h', ' ', 'g', ' ', 'w', 'e', 'l', 'l', 's']

str.split(sep=None,maxsplit=-1):

sep作为分隔字符串，maxsplit为最大拆分次数。

当不指定sep和maxsplit时，默认(sep=None,maxsplit=-1)连续空格被视为分隔符，拆分次数无限制，进行所有可能的拆分。

当指定了sep时，连续的分隔符不会被视为一个分隔符组合在一起，而是被视为分隔空字符。

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 = []
        # 按出现频率排序
        counter = count_corpus(tokens)
        self._token_freqs = sorted(counter.items(), key=lambda x: x[1],
                                   reverse=True)
        # 未知词元的索引为0
        self.idx_to_token = ['<unk>'] + reserved_tokens
        self.token_to_idx = {token: idx
                             for idx, token in enumerate(self.idx_to_token)}
        for token, freq in self._token_freqs:
            if freq < min_freq:
                break
            if token not in self.token_to_idx:
                self.idx_to_token.append(token)
                self.token_to_idx[token] = len(self.idx_to_token) - 1

    def __len__(self):
        return len(self.idx_to_token)

    #返回tokens的词表索引，若tokens为iterable则返回一个索引列表。
    def __getitem__(self, tokens):
        if not isinstance(tokens, (list, tuple)):
            return self.token_to_idx.get(tokens, self.unk)
        return [self.__getitem__(token) for token in tokens]
    #dict.get(key[,default]):根据key返回值，若找不到key则返回默认值，
    #若没有指定默认值，则默认返回None。    

    #根据indices返回token
    def to_tokens(self, indices):
        if not isinstance(indices, (list, tuple)):
            return self.idx_to_token[indices]
        return [self.idx_to_token[index] for index in indices]

    @property
    def unk(self):  # 未知词元的索引为0
        return 0

    @property
    def token_freqs(self):
        return self._token_freqs

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)

collections.Counter([iterable or mapping]):

  一个counter是一个dict的子类，用于计数可哈希对象。返回一个（元素，出现次数）对的counter对象。在这里作为一个计数器计算词元出现的次数。counter.items()

sorted(iterable, *, key=None, reverse=False)：根据iterable中的项返回一个新的已排序列表。

key：指定带有单个参数的函数，用于从iterable中提取用于比较的项。默认值为None，直接比较元素。

reverse：为一个布尔值，如果设为True，则每个列表元素将按反向顺序比较进行排序。（False时按从小到大排序，True时从大到小排序）

l=['a','a','a','b','b','c']
c=collections.Counter(l)
for l in c.items():
    print(type(l))
    print(l[1])
l_freq_f=sorted(c.items(),key=lambda x:x[1],reverse=False)
l_freq_t=sorted(c.items(),key=lambda x:x[1],reverse=True)
print('reverse=False:',l_freq_f)
print('reverse=True:',l_freq_t)

output:
<class 'tuple'>
3
<class 'tuple'>
2
<class 'tuple'>
1
reverse=False: [('c', 1), ('b', 2), ('a', 3)]
reverse=True: [('a', 3), ('b', 2), ('c', 1)]

def load_corpus_time_machine(max_tokens=-1):
    lines=read_time_machine()
    tokens=tokenize(lines,'char')
    vocab=Vocab(tokens)
    corpus=[vocab[token] for line in tokens for token in line]
    if max_tokens>0:
        corpus=corpus[:max_tokens]
    return corpus,vocab

corpus,vocab=load_corpus_time_machine()
print(vocab.to_tokens([i for i in range(28)]))
len(corpus),len(vocab)

output:
['<unk>', ' ', 'e', 't', 'a', 'i', 'n', 'o', 's', 'h', 'r', 'd', 'l', 'm', 'u', 'c', 'f', 'w', 'g', 'y', 'p', 'b', 'v', 'k', 'x', 'z', 'j', 'q']
(170580, 28)