Pytorch学习记录-torchtext学习Field

Pytorch学习记录-torchtext学习Field

昨天写的那个太粗糙了。又找了一个教程来看。
主要包括三个方面

• 使用torchtext进行文本预处理
• 使用Keras和PyTorch构建数据集进行文本预处理
• 使用gensim加载预训练的词向量，并使用PyTorch实现语言模型

和 torchvision 类似 torchtext 是为了处理特定的数据和数据集而存在的。
正如 NLP和 CV的热度一样， torchtext的热度也较 torchvision 少了许多，至今还在积极开发中，甚至在使用过程中你可能会遇见一些 bug。但是， torchtext 的可用性是肯定的，它提供了一整套文本数据处理流程。

本文使用的数据集也是Kaggle的情感分类数据集。

1. 使用torchtext进行文本预处理

1.1 引入库并查看数据

import pandas as pd
import numpy as np
import torch
import time
import random
import os

data1 = pd.read_csv('./data/torchtextdata/train_one_label.csv').head()
data2=pd.read_csv('./data/torchtextdata/test.csv').head()

1.2 使用torchtext构建数据集

和昨天一样，对于评论文本，我们把想对字段做的预处理以传递关键字参数的形式传入。我们给字段一个分词器，告诉它把输入都转换为小写，告诉它输入是顺序序列。

• sequential是否表示顺序数据。默认值：True
• tokenize用于将使用此字段将字符串标记为顺序示例的函数。如果是“spacy”，则使用SpaCy标记器。如果将非序列化函数作为参数传递，则该字段将无法序列化。默认值：string.split。
  因此，如果希望使用spacy，在前面的tokenize部分要加上tokenize = lambda x: x.split('spacy')
• fix_length使用此字段的所有示例都将填充到的固定长度，或者对于灵活的序列长度，为None。默认值：无。
  在这里是200的长度。

from torchtext import data
from torchtext.vocab import Vectors
from torch.nn import init
from tqdm import tqdm

tokenize = lambda x: x.split()
TEXT = data.Field(sequential=True, tokenize=tokenize, lower=True, fix_length=200)
LABEL = data.Field(sequential=False, use_vocab=False)

1.3 自定义Dataset

Fields知道如何处理原始数据，用户告诉Fields去哪里处理，在这里就要使用Dataset。torchtext内置有Dataset。

torchtext的Dataset是继承自pytorch的Dataset，提供了一个可以下载压缩数据并解压的方法（支持.zip, .gz, .tgz）
splits方法可以同时读取训练集，验证集，测试集
TabularDataset可以很方便的读取CSV, TSV, or JSON格式的文件

可以直接使用torchtext.data.Dataset来构建数据集，昨天教程就是这样做的。

# 定义数据路径
train_path = './data/torchtext/train_one_label.csv'
valid_path = './data/torchtext/valid_one_label.csv'
test_path = './data/torchtext/test.csv'


# 定义Dataset
class MyDataset(data.Dataset):
    name = 'grand dataset'

    @staticmethod
    def sort_key(ex):
        return len(ex.text)

    # 配置信息
    def __init__(self, path, text_field, label_field, test=False, aug=False, **kwargs):
        fields = [("id", None),
                  ("comment_text", text_field),
                  ("toxic", label_field),
                  ]
        examples = []
        csv_data = pd.read_csv(path)
        print('read data from {}'.format(path))

        # 如果是测试数据，就没有label，其余的有label
        if test:
            for text in tqdm(csv_data['comment_text'], csv_data['toxic']):
                examples.append(data.Example.fromlist([None, text, None], fields))
        else:
            for text, label in tqdm(zip(csv_data['comment_text'], csv_data['toxic'])):
                if aug:
                    rate = random.random()
                    if rate > 0.5:
                        text = self.dropout(text)
                    else:
                        text = self.shuffle(text)
                examples.append(data.Example.fromlist([None, text, label], fields))
        # 之前是一些预处理操作，此处调用super调用父类构造方法，产生标准Dataset
        super(MyDataset, self).__init__(examples, fields)

    # 使用permutation来打乱数据，但是其shuffle会更快一些
    def shuffle(self, text):
        text = np.random.permutation(text.strip().split())
        return ' '.join(text)

    def dropout(self, text, p=0.5):
        # 字符串处理，删除空白，然后分句？
        text = text.strip().split()
        len_ = len(text)
        indexs = np.random.choice(len_, int(len_ * p))
        for i in indexs:
            text[i] = ''
        return ' '.join(text)

1.4 构建数据集

# 构建数据集
train = MyDataset(train_path, text_field=TEXT, label_field=LABEL, test=False, aug=1)
valid = MyDataset(valid_path, text_field=TEXT, label_field=LABEL, test=False, aug=1)
test = MyDataset(test_path, text_field=TEXT, label_field=None, test=True, aug=1)

1.5 构建词表

TEXT.build_vocab(train)

当然还可以通过预训练的方式来构建词表

cache = 'mycache'
if not os.path.exists(cache):
    os.mkdir(cache)
vectors = Vectors(name='/Users/wyw/Documents/vectors/glove/glove.6B.300d.txt', cache=cache)
# 指定 Vector 缺失值的初始化方式，没有命中的token的初始化方式
vectors.unk_init = init.xavier_uniform_
TEXT.build_vocab(train, min_freq=5, vectors=vectors)
# 查看词表元素
TEXT.vocab.vectors

1.6 构建数据迭代器

from torchtext.data import Iterator, BucketIterator

# 同时对训练集和验证集进行迭代器构建
train_iter, val_iter = BucketIterator.splits(
    (train, valid),
    batch_sizes=(8, 8),
    device=0,
    sort_key=lambda x: len(x.comment_text),
    sort_within_batch=False,
    repeat=False
)
test_iter = Iterator(test, batch_size=8, device=0, sort=False, sort_within_batch=False, repeat=False)


for idx, batch in enumerate(train_iter):
    print(batch)
    text, label = batch.comment_text, batch.toxic
    print(text.shape, label.shape)

1.7 训练LSTM网络进行分类

在这部分，用的是cpu，我没找到怎么使用GPU，好像device那个不行，要调整为cuda什么的

import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim

weight_matrix = TEXT.vocab.vectors
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')


class LSTM(nn.Module):
    def __init__(self):
        super(LSTM, self).__init__()
        self.word_embeddings = nn.Embedding(len(TEXT.vocab), 300)
        self.lstm = nn.LSTM(input_size=300, hidden_size=128, num_layers=1)
        self.decoder = nn.Linear(128, 2)

    def forward(self, sentence):
        embeds = self.word_embeddings(sentence)
        lstm_out = self.lstm(embeds)[0]
        final = lstm_out[-1]
        y = self.decoder(final)
        return y


# model = LSTM().to(device)
model = LSTM()
model.train()
optimizer = optim.Adam(filter(lambda p: p.requires_grad, model.parameters()), lr=0.01)
loss_funtion = F.cross_entropy

for epoch, batch in enumerate(train_iter):
    optimizer.zero_grad()
    predicted = model(batch.comment_text)

    loss = loss_funtion(predicted, batch.toxic)
    loss.backward()
    optimizer.step()
    print(loss)