torchtext 埋め込みベクトルのサイズ指定について

前提・実現したいこと

Pytorchを用いて文書分類がしたいです。
ネットワーク等は以下サイトを参考にしました。
https://qiita.com/itok_msi/items/1f3746f7e89a19dafac5

　Text.vocabのサイズが教師データの語彙数に依存してしまい、推定用のデータを利用する際に
新たに埋め込みベクトルを生成すると入力層の次元数が合わなくなるので
入力のベクトルファイル（model.vec）を基準に次元数を指定したいです

発生している問題・エラーメッセージ

下記の処理で入力データの行列のサイズが決定するのですが

行数:min_freq以上出現した単語数+特殊トークン数(<unk> , <pad>)
列数:単語ベクトルの次元。デフォルトだとfasttextは300次元

となるため出現単語の種類数を学習データと全く同じにしないと入力できない状況です。

該当のソースコード

・入力データ
train_ja.tsv（val_ja.tsv,test_ja.tsvも一緒の形式）

text
1あなたをが好きです。  1
2私はマイクが嫌いです。 0
3私はマキが好きです。  1
4ボブが嫌いです。    0

model.vec　… FastTextの学習済みベクトル

・ソースコード
model.py

python
1# coding:utf-8
2import torchtext
3from torchtext import data
4from torchtext import datasets
5from torchtext.vocab import FastText
6from torchtext.vocab import Vectors
7
8import torch
9import torch.nn as nn
10import torch.optim as optim
11import torch.nn.functional as F
12from torch.autograd import Variable
13
14class EncoderRNN(nn.Module):
15    def __init__(self, emb_dim, h_dim, v_size, gpu=True, v_vec=None, batch_first=True):
16        super(EncoderRNN, self).__init__()
17        self.gpu = gpu
18        self.h_dim = h_dim
19        self.embed = nn.Embedding(v_size, emb_dim)
20        if v_vec is not None:
21            self.embed.weight.data.copy_(v_vec)
22        self.lstm = nn.LSTM(emb_dim, h_dim, batch_first=batch_first,
23                            bidirectional=True)
24
25    def init_hidden(self, b_size):
26        h0 = Variable(torch.zeros(1*2, b_size, self.h_dim))
27        c0 = Variable(torch.zeros(1*2, b_size, self.h_dim))
28        if self.gpu:
29            h0 = h0.cuda()
30            c0 = c0.cuda()
31        return (h0, c0)
32
33    def forward(self, sentence, lengths=None):
34        self.hidden = self.init_hidden(sentence.size(0))
35        emb = self.embed(sentence)
36        packed_emb = emb
37
38        if lengths is not None:
39            lengths = lengths.view(-1).tolist()
40            packed_emb = nn.utils.rnn.pack_padded_sequence(emb, lengths)
41        out, hidden = self.lstm(packed_emb, self.hidden)
42        if lengths is not None:
43            out = nn.utils.rnn.pad_packed_sequence(output)[0]
44        out = out[:, :, :self.h_dim] + out[:, :, self.h_dim:]
45        return out
46
47class Attn(nn.Module):
48    def __init__(self, h_dim):
49        super(Attn, self).__init__()
50        self.h_dim = h_dim
51        self.main = nn.Sequential(
52            nn.Linear(h_dim, 24),
53            nn.ReLU(True),
54            nn.Linear(24,1)
55        )
56
57    def forward(self, encoder_outputs):
58        b_size = encoder_outputs.size(0)
59        output_cont = encoder_outputs.contiguous()
60        output_view = output_cont.view(-1, self.h_dim)
61        attn_ene = self.main(output_view.to("cpu")) # (b, s, h) -> (b * s, 1)
62        return F.softmax(attn_ene.view(b_size, -1), dim=1).unsqueeze(2) # (b*s, 1) -> (b, s, 1)
63
64class AttnClassifier(nn.Module):
65    def __init__(self, h_dim, c_num):
66        super(AttnClassifier, self).__init__()
67        self.attn = Attn(h_dim)
68        self.main = nn.Linear(h_dim, c_num)
69
70
71    def forward(self, encoder_outputs):
72        attns = self.attn(encoder_outputs) #(b, s, 1)
73        feats = (encoder_outputs.to("cuda:0") * attns.to("cuda:0")).sum(dim=1) # (b, s, h) -> (b, h)
74        return F.log_softmax(self.main(feats.to("cpu")),dim=1), attns

train.py

python
1# coding:utf-8
2import janome
3from janome.tokenizer import Tokenizer
4
5import torch
6import torch.nn as nn
7import torch.optim as optim
8import torch.nn.functional as F
9from torch.autograd import Variable
10
11from torchtext import data, datasets
12
13from bs4 import BeautifulSoup
14import pandas as pd
15import io
16
17#from model import *
18
19emb_dim = 300 #単語埋め込み次元
20h_dim = 3 #lstmの隠れ層の次元
21class_num = 2 #予測クラス数
22lr = 0.001 #学習係数
23epochs = 30 #エポック数
24
25#device = torch.device('cuda:0')
26device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
27#print(device)
28torch.manual_seed(0)
29torch.cuda.manual_seed(0)
30j_t = Tokenizer()
31
32def tokenizer(text): 
33    #return text.split(' ')
34    return [tok for tok in j_t.tokenize(text, wakati=True)]
35
36def clean_tokenizer(text):
37    soup = BeautifulSoup(text,"lxml")
38    clean_text = soup.get_text()
39    return [tok for tok in j_t.tokenize(clean_text, wakati=True)]
40
41class JaFastText(Vectors):
42    def __init__(self, name=None, **kwargs):
43        super(JaFastText, self).__init__(name, url=None, **kwargs)
44
45
46def train_model(epoch, train_iter, optimizer, log_interval=1, batch_size=2):
47    encoder.train()
48    classifier.train()
49    correct = 0
50    for idx, batch in enumerate(train_iter):
51        (x, x_l), y = batch.Text, batch.Label
52        optimizer.zero_grad()
53        encoder_outputs = encoder(x)
54        output, attn = classifier(encoder_outputs)
55        loss = F.nll_loss(output.to(device), y.to(device))
56        loss.backward()
57        optimizer.step()
58        pred = output.data.max(1, keepdim=True)[1]
59        correct += pred.eq(y.data.view_as(pred).to("cpu")).cpu().sum()
60        if idx % log_interval == 0:
61            print('train epoch: {} [{}/{}], acc:{}, loss:{}'.format(
62            epoch, (idx+1)*len(x), len(train_iter)*batch_size,
63            correct/float(log_interval * len(x)),
64            loss.item()))
65            correct = 0
66
67
68def test_model(epoch, test_iter):
69    encoder.eval()
70    classifier.eval()
71    correct = 0
72    for idx, batch in enumerate(test_iter):
73        (x, x_l), y = batch.Text, batch.Label
74        encoder_outputs = encoder(x)
75        output, attn = classifier(encoder_outputs)
76        pred = output.data.max(1, keepdim=True)[1]
77        correct += pred.eq(y.data.view_as(pred).to("cpu")).cpu().sum()
78    print('test epoch:{}, acc:{}'.format(epoch, correct/float(len(test))))
79
80# init model
81def weights_init(m):
82    classname = m.__class__.__name__
83    if hasattr(m, 'weight') and (classname.find('Embedding') == -1):
84        nn.init.xavier_uniform(m.weight.data, gain=nn.init.calculate_gain('relu'))
85
86if __name__ == '__main__':
87    #TEXT = data.Field(sequential=True, tokenize=tokenizer, lower=True, include_lengths=True, batch_first=True)
88    TEXT = data.Field(sequential=True, tokenize=tokenizer, lower=True, include_lengths=True, batch_first=True)
89    LABEL = data.Field(sequential=False, use_vocab=False)
90    train, val, test = data.TabularDataset.splits(
91            path='./', train='train_ja.tsv',
92            validation='val_ja.tsv', test='test_ja.tsv', format='tsv',
93            fields=[('Text', TEXT), ('Label', LABEL)])
94
95    print('len(train)', len(train))
96    print('vars(train[0])', vars(train[0]))
97
98    fasttext = JaFastText(name='model.vec')
99    TEXT.build_vocab(train, vectors=fasttext, min_freq=1)
100    TEXT.vocab.freqs
101    TEXT.vocab.stoi
102    TEXT.vocab.itos
103    TEXT.vocab.vectors.size()
104    torch.save(TEXT,"TEXT.pkl") 
105
106    train_iter, val_iter, test_iter = data.Iterator.splits(
107        (train, val, test), batch_sizes=(2, 2, 1), device=device, repeat=False,sort=False)
108    batch = next(iter(train_iter))
109    print(batch.Text)
110    print(batch.Label)
111
112    # make model
113    encoder = EncoderRNN(emb_dim, h_dim, len(TEXT.vocab),gpu=True, v_vec = TEXT.vocab.vectors)
114    encoder.cuda()
115    classifier = AttnClassifier(h_dim, class_num)
116
117    for m in encoder.modules():
118        print(m.__class__.__name__)
119        weights_init(m)
120
121    for m in classifier.modules():
122        print(m.__class__.__name__)
123        weights_init(m)
124
125    # optim
126    from itertools import chain
127    optimizer = optim.Adam(chain(encoder.parameters(),classifier.parameters()), lr=lr)
128
129    # train model
130    for epoch in range(epochs):
131        train_model(epoch + 1, train_iter, optimizer)
132        test_model(epoch + 1, val_iter)
133        #torch.save(encoder.state_dict(), "model/encoder_epoch"+ str(epoch + 1) +".pkl")
134        #torch.save(classifier.state_dict(), "model/classifier_epoch"+ str(epoch + 1) +".pkl")
135
136    # save model
137    torch.save(encoder.state_dict(),"encoder.pkl")
138    torch.save(classifier.state_dict(),"classifier.pkl")

補足情報（FW/ツールのバージョンなど）

colaboratory　Python3 GPU ランタイム

pytorch 1.1.0
torchtext 0.4.0

m3yrin

2019/08/14 03:05

お疲れ様です。問題認識について、少し確認させてください。 > 推定用のデータこちらの推定用のデータというのは、モデルの学習で使用する「train_ja.tsv, val_ja.tsv, test_ja.tsv」とは別に投稿者様で用意したデータという認識でよろしいでしょうか。新しいデータに対する推論を行う場合、新しいテキストで単語とidの対応させる辞書を作ってしまう、具体的には ```python TEXT.build_vocab( new_data , vectors=fasttext, min_freq=1) ``` としてしまうと、ご質問の通り入力の語彙数が変わってしまうので学習済みモデルをそのまま使用できません。学習済みモデルをそのまま使うには、学習に使用した辞書もそのまま使う必要があります。