PyTorch学习笔记

PyTorch

记录自己在使用PyTorch及其相关框架时遇到的问题和解决方法。

torchtext数据预处理

torchtext是一个PyTorch的非官方的框架，用来处理NLP中数据加载的任务。torchtext为文本数据的读取提供了很好的pipeline，可以方便的把数据送给PyTorch。但是其功能实现上存在着一些bug，仍存在着大量的坑。本节利用torchtext讲述从数据的读取到生成Batch的过程，方便以后的复习使用。

torchtext读取数据

首先导入相应的框架。

1
2
import jieba
from torchtext import data

定义分词函数。分词函数使用结巴分词的lcut函数，得到分词后的列表。

1
2
3
def tokenizer(text):
    return jieba.lcut(text)

定义torchtext.data.Field。Field类似于数据库中的域，像是一个规则，把数据限定在这个规则下。

1
2
TEXT = data.Field(sequential=True, tokenize=tokenizer)
LABEL = data.Field(sequential=False, use_vocab=False)

读取CSV数据

获取训练集和验证集时可以torchtext.data.TabularDataset.splits这个函数，若待读取的数据为如下的CSV文件时：

1
2
3
4
5
6
id,content,label
1,妞妞啊，今天又承办了一个发文登记文号是126~嘻~么么哒~晚安哟,happy
2,这里还值得注意另一个事实，就是张鞠存原有一个东溪草堂为其读书处。,neural
3,这在前华约国家(尤其是东德)使用R-73的首次联合演习期间，被一些北约组织的飞行员所证实。,neural
4,TinyThief上wii了？！,surprise
5,每天都以紧张的心情工作，真的是太累，太不放松了，想要爆发一下,angry

torchtext读取的方法为：

1
2
3
4
5
6
7
8
9
10
11
12
13
train_data, valid_data, test_data = data.TabularDataset.splits(
                    path = './data/',
                    train = 'weibo_train.csv',
                    validation = 'weibo_valid.csv',
                    test = 'weibo_test.csv',
                    format = 'csv',
                    skip_header = True,
                    fields = [	# fields顺序必须与文件中列的顺序一致
                    ('id', None),
                    ('text', TEXT), 
                    ('label', LABEL), #在test文件里面没有第三列，会自动忽略
                    ])

CSV数据是以英文,来分隔数据的，但是文本数据中很大概率存在大量英文,，很容易导致读取数据时产生意外的问题。

读取JSON数据

在读取torchtext所理解的”JSON”数据时会遇到坑。torchtext加载数据时有可能是按行去读取，所以并不能处理传统意义上的JSON数据，torchtext所理解的”JSON”数据是每一行为一个Python中的字典：

1
2
3
4
5
{"id": 1, "content": "妞妞啊，今天又承办了一个发文登记文号是126~嘻~么么哒~晚安哟", "label": "happy"}
{"id": 2, "content": "这里还值得注意另一个事实，就是张鞠存原有一个东溪草堂为其读书处。", "label": "neural"}
{"id": 3, "content": "这在前华约国家(尤其是东德)使用R-73的首次联合演习期间，被一些北约组织的飞行员所证实。", "label": "neural"}
{"id": 4, "content": "TinyThief上wii了？！", "label": "surprise"}
{"id": 5, "content": "每天都以紧张的心情工作，真的是太累，太不放松了，想要爆发一下", "label": "angry"}

针对以上数据，torchtext的解决方法为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
train_data, valid_data = data.TabularDataset.splits(
                    path = './data/',
                    train = 'weibo_train.json',
                    validation = 'weibo_valid.json',
                    format = 'json',
                    fields = {
                    'content': ('text', TEXT), #content为数据文件中的key，text为读取数据后给其定义的名字
                    'label': ('label', LABEL),
                    })

# test文件的key里面没有label，需要单独读取test_data
test_data = data.TabularDataset( #这里没有.splites()
                    path = './data/weibo_test.json',
                    format = 'json',
                    fields = { #test文件的key里面没有label，不需要添加
                    'content': ('text', TEXT), 
                    })

上述JSON数据不是标准的JSON格式，还需要把数据处理成上述格式才能调用函数。所以对于JSON数据还是自己定义DataLoader比较好。

自定义DataLoader

自定义DataLoader的主要思想是首先手动读取数据，然后把数据构造成torchtext.data.Example，再利用torchtext.data.Dataset构造成数据集。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import json
def get_dataset(json_file, text_field, label_field, test=False):
    if test: # 如果为test，则没有label
        label_field = None
    # 定义fields
    fields = [('text', text_field), ('label', label_field)]

    # 读取文件
    with open(json_file, 'r') as rf:
        filedata = json.load(rf)
    
    # 生成examples
    examples = []
    for i in filedata:
        text = i.get('content', None)
        label = i.get('label', None) #此处的label需要改成数字，可以构造个字典，把标签映射成数字
        examples.append(data.Example.fromlist([text, label], fields))

    return data.Dataset(examples, fields)


train_data = get_dataset('./data/weibo_train.json', TEXT, LABEL)
valid_data = get_dataset('./data/weibo_valid.json', TEXT, LABEL)
test_data = get_dataset('./data/weibo_test.json', TEXT, LABEL, test=True)

打印一下：

1
2
3
4

print(train_data[0].__dict__)
print(valid_data[0].__dict__)
print(test_data[0].__dict__)

结果：

1
2
3
{'text': ['气死', '姐姐', '了', '，', '快二是', '阵亡', '了', '吗', '，', '尼玛', '，', '一个半', '小时', '过去', '了', '也', '没', '上车'], 'label': 'angry'}
{'text': ['韩国', '漫画', '，', '妻子', '的', '记忆', '，', '结尾', '让', '人', '流泪', '。'], 'label': 'sad'}
{'text': ['所以', '注定', '我', '这辈子', '是', '做不了', '商人', '妈蛋']}

可以看出train_data和valid_data都有label，test_data没有label。

torchtext构建Vocab（单词表）

对train_data构建Vocab

1
2
3
4
TEXT.build_vocab(train_data)

print(TEXT.vocab.__dict__.keys()) 
# TEXT.vocab.freqs TEXT.vocab.stoi可以获得相应的值

结果

1
dict_keys(['freqs', 'itos', 'unk_index', 'stoi', 'vectors'])

构建迭代器

利用torchtext.data.BucketIterator和torchtext.data.Iterator构建迭代器

1
2
3
train_iter = data.BucketIterator(dataset=train_data, batch_size=64, shuffle=True, sort_within_batch=False, repeat=False)
valid_iter = data.BucketIterator(dataset=valid_data, batch_size=8, shuffle=True, sort_within_batch=False, repeat=False)
test_iter=data.Iterator(test_data, batch_size=8, device=-1, sort=False, sort_within_batch=False, repeat=False)

构建LSTM

构建LSTM模型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 定义LSTM
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim

weight_matrix=TEXT.vocab.vectors
class LSTM(nn.Module):
    def __init__(self):
        super(LSTM,self).__init__()
        self.word_embedding=nn.Embedding(len(TEXT.vocab),300)
        self.lstm=nn.LSTM(input_size=300,hidden_size=128,num_layers=1)
        self.decoder=nn.Linear(128,6)
    def forward(self, sentence):
        embeds=self.word_embedding(sentence)
        #print(embeds.shape)
        lstm_out=self.lstm(embeds)[0]
        #print(lstm_out.shape)
        final=lstm_out[-1]
        y=self.decoder(final)
        return y

训练数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
model=LSTM()
model.train()
optimizer=optim.Adam(filter(lambda p:p.requires_grad,model.parameters()),lr=0.01)
crition=F.cross_entropy

print('Start training...')
EPOCHES = 20
for epoch in range(1, EPOCHES+1):
    losses = 0
    for batch in train_iter:
        optimizer.zero_grad()
        predicted=model(batch.text)
        #print(predicted, batch.label)
        loss=crition(predicted,batch.label)
        loss.backward()
        optimizer.step()
        losses += loss.item()
    print('Epoch: %d | Loss: %f' % (epoch, losses/(len(train_iter))))

完整代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
import torch
import jieba
from torchtext import data

def tokenizer(text):
    return jieba.lcut(text)

TEXT = data.Field(sequential=True, tokenize=tokenizer)
LABEL = data.Field(sequential=False, use_vocab=False)

label_to_index = {
    'neural': 0,
    'happy': 1,
    'angry': 2,
    'sad': 3,
    'fear': 4,
    'surprise': 5,
}

import json
def get_dataset(json_file, text_field, label_field, test=False):
    if test: # 如果为test，则没有label
        label_field = None
    # 定义fields
    fields = [('text', text_field), ('label', label_field)]

    # 读取文件
    with open(json_file, 'r') as rf:
        filedata = json.load(rf)
    
    # 生成examples
    examples = []
    for i in filedata:
        text = i.get('content', None)
        label = i.get('label', None)
        if not text:
            continue 
        label_index = label_to_index.get(label, None) #得到数字label
        examples.append(data.Example.fromlist([text, label_index], fields))

    return data.Dataset(examples, fields)

train_data = get_dataset('./data/train/usual_train.txt', TEXT, LABEL)

TEXT.build_vocab(train_data)
#print(TEXT.vocab.__dict__)

train_iter = data.BucketIterator(dataset=train_data, batch_size=64, shuffle=True, sort_within_batch=False, repeat=False)

# 定义LSTM
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim

weight_matrix=TEXT.vocab.vectors
class LSTM(nn.Module):
    def __init__(self):
        super(LSTM,self).__init__()
        self.word_embedding=nn.Embedding(len(TEXT.vocab),300)
        self.lstm=nn.LSTM(input_size=300,hidden_size=128,num_layers=1)
        self.decoder=nn.Linear(128,6)
    def forward(self, sentence):
        embeds=self.word_embedding(sentence)
        #print(embeds.shape)
        lstm_out=self.lstm(embeds)[0]
        #print(lstm_out.shape)
        final=lstm_out[-1]
        y=self.decoder(final)
        return y

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

print('Start training...')
EPOCHES = 20
for epoch in range(1, EPOCHES+1):
    losses = 0
    for batch in train_iter:
        optimizer.zero_grad()
        predicted=model(batch.text)
        #print(predicted, batch.label)
        loss=crition(predicted,batch.label)
        loss.backward()
        optimizer.step()
        losses += loss.item()
    print('Epoch: %d | Loss: %f' % (epoch, losses/(len(train_iter))))

参考：

TorchText用法示例及完整代码
Pytorch学习记录-更深的TorchText学习01
Pytorch学习记录-torchtext数据预处理
TorchText使用
Torchtext读取JSON数据
使用pytorch和torchtext进行文本分类

赏

谢谢你请我喝奶茶

支付宝
微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

👨‍💻算法工程师<br>🧘‍♂️发呆艺术家<br>📖汪曾祺迷弟