使用torchtext导入NLP数据集的操作

如果你是pytorch的用户，可能你会很熟悉pytorch生态圈中专门预处理图像数据集的torchvision库。

从torchtext这个名字我们也能大概猜到该库是pytorch圈中用来预处理文本数据集的库，但这方面的教程网络上比较少，今天我就讲讲这个特别有用的文本分析库。

简介

torchtext在文本数据预处理方面特别强大，但我们要知道ta能做什么、不能做什么，并如何将我们的需求用torchtext实现。虽然torchtext是为pytorch而设计的，但是也可以与keras、tensorflow等结合使用。

官方文档地址 https://torchtext.readthedocs.io/en/latest/index.html

# 安装
!pip3 install torchtext

自然语言处理预处理的工作流程：

1、Train/Validation/Test数据集分割

2、文件数据导入（File Loading）

3、分词（Tokenization） 文本字符串切分为词语列表

4、构建词典(Vocab) 根据训练的预料数据集构建词典

5、数字映射(Numericalize/Indexify) 根据词典，将数据从词语映射成数字，方便机器学习

6、导入预训练好的词向量(word vector)

7、分批(Batch) 数据集太大的话，不能一次性让机器读取，否则机器会内存崩溃。解决办法就是将大的数据集分成更小份的数据集，分批处理

8、向量映射（Embedding Lookup） 根据预处理好的词向量数据集，将5的结果中每个词语对应的索引值变成 词语向量

上面8个步骤，torchtext实现了2-7。第一步需要我们自己diy，好在这一步没什么难度

"The quick fox jumped over a lazy dog."
# 分词
["The", "quick", "fox", "jumped", "over", "a", "lazy", "dog", "."]
# 构建词典
{"The" -> 0,
"quick"-> 1,
"fox" -> 2,
...}
# 数字映射（将每个词根据词典映射为对应的索引值）
[0, 1, 2, ...]
# 向量映射（按照导入的预训练好的词向量数据集，把词语映射成向量）
[
  [0.3, 0.2, 0.5],
  [0.6, 0., 0.1],
  [0.8, 01., 0.4],
  ...
]

一、数据集分割

一般我们做机器学习会将数据分为训练集和测试集，而在深度学习中，需要多轮训练学习，每次的学习过程都包括训练和验证，最后再进行测试。所以需要将数据分成训练、验证和测试数据。

import pandas as pd
import numpy as np
def split_csv(infile, trainfile, valtestfile, seed=999, ratio=0.2):
    df = pd.read_csv(infile)
    df["text"] = df.text.str.replace("\n", " ")
    idxs = np.arange(df.shape[0])
    np.random.seed(seed)
    np.random.shuffle(idxs)
    val_size = int(len(idxs) * ratio)
    df.iloc[idxs[:val_size], :].to_csv(valtestfile, index=False)
    df.iloc[idxs[val_size:], :].to_csv(trainfile, index=False)
#先将sms_spam.csv数据分为train.csv和test.csv
split_csv(infile='data/sms_spam.csv',
          trainfile='data/train.csv',
          valtestfile='data/test.csv',
          seed=999,
          ratio=0.2)
#再将train.csv分为dataset_train.csv和dataset_valid.csv
split_csv(infile='data/train.csv',
          trainfile='data/dataset_train.csv',
          valtestfile='data/dataset_valid.csv',
          seed=999,
          ratio=0.2)

1.1 参数解读

split_csv(infile, trainfile, valtestfile, seed, ratio)

infile:待分割的csv文件

trainfile:分割出的训练cs文件

valtestfile：分割出的测试或验证csv文件

seed:随机种子，保证每次的随机分割随机性一致

ratio:测试（验证）集占数据的比例

经过上面的操作，我们已经构建出实验所需的数据：

训练数据（这里说的是dataset_train.csv而不是train.csv）

验证数据（dataset_train.csv）

测试数据（test.csv）。

二、分词

导入的数据是字符串形式的文本，我们需要将其分词成词语列表。英文最精准的分词器如下：

import re
import spacy
import jieba	

#英文的分词器
NLP = spacy.load('en_core_web_sm')
MAX_CHARS = 20000  #为了降低处理的数据规模，可以设置最大文本长度,超过的部分忽略，
def tokenize1(text):
    text = re.sub(r"\s", " ", text)
    if (len(text) > MAX_CHARS):
        text = text[:MAX_CHARS]
    return [
        x.text for x in NLP.tokenizer(text) if x.text != " " and len(x.text)>1]
#有的同学tokenize1用不了，可以使用tokenize2。
def tokenize2(text):
    text = re.sub(r"\s", " ", text)
    if (len(text) > MAX_CHARS):
        text = text[:MAX_CHARS]
    return [w for w in text.split(' ') if len(w)>1]
#中文的分类器比较简单
def tokenize3(text):
    if (len(text) > MAX_CHARS):
        text = text[:MAX_CHARS]
    return [w for w in jieba.lcut(text) if len(w)>1]	

print(tokenize1('Python is powerful and beautiful!'))
print(tokenize2('Python is powerful and beautiful!'))
print(tokenize3('Python强大而美丽！'))

Run

['Python', 'is', 'powerful', 'and', 'beautiful']
['Python', 'is', 'powerful', 'and', 'beautiful!']
['Python', '强大', '美丽']

三、 导入数据

torchtext中使用torchtext.data.TabularDataset来导入自己的数据集，并且我们需要先定义字段的数据类型才能导入。要按照csv中的字段顺序来定义字段的数据类型，我们的csv文件中有两个字段（label、text）

import pandas as pd
df = pd.read_csv('data/train.csv')
df.head()

import torch
import torchtext
from torchtext import data
import logging
LABEL = data.LabelField(dtype = torch.float)
TEXT = data.Field(tokenize = tokenize1,
                      lower=True,
                      fix_length=100,
                      stop_words=None)
train, valid, test = data.TabularDataset.splits(path='data', #数据所在文件夹
                                                train='dataset_train.csv',
                                                validation='dataset_valid.csv',
                                                test = 'test.csv',
                                                format='csv',
                                                skip_header=True,
                                                fields = [('label', LABEL),('text', TEXT)])
train

Run

<torchtext.data.dataset.TabularDataset at 0x120d8ab38>

四、构建词典

根据训练（上面得到的train）的预料数据集构建词典。这两有两种构建方式，一种是常规的不使用词向量，而另一种是使用向量的。

区别仅仅在于vectors是否传入参数

vects =  torchtext.vocab.Vectors(name = 'glove.6B.100d.txt',
                                 cache = 'data/')
TEXT.build_vocab(train,
                 max_size=2000,
                 min_freq=50,
                 vectors=vects,  #vects替换为None则不使用词向量
                 unk_init = torch.Tensor.normal_)

4.1 TEXT是Field对象，该对象的方法有

print(type(TEXT))
print(type(TEXT.vocab))

Run

<class 'torchtext.data.field.Field'>
<class 'torchtext.vocab.Vocab'>

词典-词语列表形式，这里只显示前20个

TEXT.vocab.itos[:20]

['<unk>',
 '<pad>',
 'to',
 'you',
 'the',
 '...',
 'and',
 'is',
 'in',
 'me',
 'it',
 'my',
 'for',
 'your',
 '..',
 'do',
 'of',
 'have',
 'that',
 'call']

词典-字典形式

TEXT.vocab.stoi

defaultdict(<bound method Vocab._default_unk_index of <torchtext.vocab.Vocab object at 0x1214b1e48>>,
            {'<unk>': 0,
             '<pad>': 1,
             'to': 2,
             'you': 3,
             'the': 4,
             '...': 5,
             'and': 6,
             'is': 7,
             'in': 8,
             ....
             'mother': 0,
             'english': 0,
             'son': 0,
             'gradfather': 0,
             'father': 0,
             'german': 0)

4.2 注意

train数据中生成的词典，里面有，这里有两个要注意:

是指不认识的词语都编码为

german、father等都编码为0,这是因为我们要求词典中出现的词语词频必须大于50，小于50的都统一分配一个索引值。

词语you对应的词向量

TEXT.vocab.vectors[3]

tensor([-0.4989,  0.7660,  0.8975, -0.7855, -0.6855,  0.6261, -0.3965,  0.3491,
         0.3333, -0.4523,  0.6122,  0.0759,  0.2253,  0.1637,  0.2810, -0.2476,
         0.0099,  0.7111, -0.7586,  0.8742,  0.0031,  0.3580, -0.3523, -0.6650,
         0.3845,  0.6268, -0.5154, -0.9665,  0.6152, -0.7545, -0.0124,  1.1188,
         0.3572,  0.0072,  0.2025,  0.5011, -0.4405,  0.1066,  0.7939, -0.8095,
        -0.0156, -0.2289, -0.3420, -1.0065, -0.8763,  0.1516, -0.0853, -0.6465,
        -0.1673, -1.4499, -0.0066,  0.0048, -0.0124,  1.0474, -0.1938, -2.5991,
         0.4053,  0.4380,  1.9332,  0.4581, -0.0488,  1.4308, -0.7864, -0.2079,
         1.0900,  0.2482,  1.1487,  0.5148, -0.2183, -0.4572,  0.1389, -0.2637,
         0.1365, -0.6054,  0.0996,  0.2334,  0.1365, -0.1846, -0.0477, -0.1839,
         0.5272, -0.2885, -1.0742, -0.0467, -1.8302, -0.2120,  0.0298, -0.3096,
        -0.4339, -0.3646, -0.3274, -0.0093,  0.4721, -0.5169, -0.5918, -0.3234,
         0.2005, -0.4118,  0.4054,  0.7850])

4.3 计算词语的相似性

得用词向量构建特征工程时能保留更多的信息量（词语之间的关系）

这样可以看出词语的向量方向

是同义还是反义

距离远近。

而这里我们粗糙的用余弦定理计算词语之间的关系，没有近义反义关系，只能体现出距离远近（相似性）。

from sklearn.metrics.pairwise import cosine_similarity
import numpy as np
def simalarity(word1, word2):
    word_vec1 = TEXT.vocab.vectors[TEXT.vocab.stoi[word1]].tolist()
    word_vec2 = TEXT.vocab.vectors[TEXT.vocab.stoi[word2]].tolist()
    vectors = np.array([word_vec1, word_vec2])
    return cosine_similarity(vectors)
print(simalarity('you', 'your'))

Run

[[1.         0.83483314]
 [0.83483314 1.        ]]

五、get_dataset函数

相似的功能合并成模块，可以增加代码的可读性。这里我们把阶段性合并三四的成果get_dataset函数

from torchtext import data
import torchtext
import torch
import logging
LOGGER = logging.getLogger("导入数据")
def get_dataset(stop_words=None):
    #定义字段的数据类型
    LABEL = data.LabelField(dtype = torch.float)
    TEXT = data.Field(tokenize = tokenize1,
                      lower=True,
                      fix_length=100,
                      stop_words=stop_words)
    LOGGER.debug("准备读取csv数据...")
    train, valid, test = data.TabularDataset.splits(path='data', #数据所在文件夹
                                         train='dataset_train.csv',
                                         validation='dataset_valid.csv',
                                         test = 'test.csv',
                                         format='csv',
                                         skip_header=True,
                                         fields = [('label', LABEL),('text', TEXT)])
    LOGGER.debug("准备导入词向量...")
    vectors = torchtext.vocab.Vectors(name = 'glove.6B.100d.txt',
                                      cache = 'data/')
    LOGGER.debug("准备构建词典...")
    TEXT.build_vocab(
        train,
        max_size=2000,
        min_freq=50,
        vectors=vectors,
        unk_init = torch.Tensor.normal_)
    LOGGER.debug("完成数据导入!")
    return train,valid, test, TEXT

get_dataset函数内部参数解读

data.Field(tokenize,fix_length)定义字段

tokenize=tokenize1 使用英文的分词器tokenize1函数。

fix_length=100 让每个文本分词后的长度均为100个词；不足100的，可以填充为100。超过100的，只保留100

data.TabularDataset.splits(train, validation,test, format,skip_header,fields)读取训练验证数据，可以一次性读取多个文件

train/validation/test 训练验证测试对应的csv文件名

skip_header=True 如果csv有抬头，设置为True可以避免pytorch将抬头当成一条记录

fields = [('label', LABEL), ('text', TEXT)] 定义字段的类型，注意fields要按照csv抬头中字段的顺序设置

torchtext.vocab.Vectors(name, cache)导入词向量数据文件

name= 'glove.6B.100d.txt' 从网上下载预训练好的词向量glove.6B.100d.txt文件（该文件有6B个词，每个词向量长度为100）

cache = 'data/' 文件夹位置。glove文件存放在data文件夹内

TEXT.buildvocab(maxsize,minfreq,unkinit) 构建词典，其中

max_size=2000 设定了词典最大词语数

min_freq=50设定了词典中的词语保证最少出现50次

unkinit=torch.Tensor.normal 词典中没有的词语对应的向量统一用torch.Tensor.normal_填充

六、分批次

数据集太大的话，一次性让机器读取容易导致内存崩溃。解决办法就是将大的数据集分成更小份的数据集，分批处理

def split2batches(batch_size=32, device='cpu'):
    train, valid, test, TEXT = get_dataset() #datasets按顺序包含train、valid、test三部分
    LOGGER.debug("准备数据分批次...")
    train_iterator, valid_iterator, test_iterator = data.BucketIterator.splits((train, valid, test),
                                                                               batch_size = batch_size,
                                                                               sort = False,
                                                                               device = device)
    LOGGER.debug("完成数据分批次!")
    return train_iterator, valid_iterator, test_iterator, TEXT

6.1参数解读

split2batches(batch_size=32, device=0)

batch_size 每批次最多加入多少条评论

device device='cpu'在CPU中运行，device='gpu' 在GPU中运行。普通电脑都只有CPU的 该函数返回的是BucketIterator对象

train_iterator, valid_iterator, test_iterator, TEXT = split2batches()
train_iterator

Run

<torchtext.data.iterator.BucketIterator at 0x12b0c7898>

查看train_iterator数据类型

type(train_iterator)
torchtext.data.iterator.BucketIterator

6.2BucketIterator对象

这里以trainiterator为例（validiterator, test_iterator都是相同的对象）。因为本例中数据有两个字段label和text，所以

获取train_iterator的dataset

train_iterator.dataset
<torchtext.data.dataset.TabularDataset at 0x12e9c57b8>

获取train_iterator中的第8个对象

train_iterator.dataset.examples[7]
<torchtext.data.example.Example at 0x12a82dcf8>

获取train_iterator中的第8个对象的lebel字段的内容

train_iterator.dataset.examples[7].label
'ham'

获取train_iterator中的第8个对象的text字段的内容

train_iterator.dataset.examples[7].text
['were', 'trying', 'to', 'find', 'chinese', 'food', 'place', 'around', 'here']

总结

到这里我们已经学习了torchtext的常用知识。使用本代码要注意：

我们假设数据集是csv文件，torchtext可以还可以处理tsv、json。但如果你想使用本代码，请先转为csv

本教程的csv文件只有两个字段，label和text。如果你的数据有更多的字段，记得再代码中增加字段定义

本教程默认场景是英文，且使用词向量。所以记得对应位置下载本教程的glove.6B.100d.txt。

glove下载地址https://nlp.stanford.edu/projects/glove/

以上为个人经验，希望能给大家一个参考，也希望大家多多支持我们。