PytorchでのSkipGram単語埋め込みトレーニングに失敗する

Question

https://arxiv.org/abs/1310.4546で説明されている有名なモデルを使用して、スキップグラム単語埋め込みをトレーニングしています。私はPyTorchでそれを訓練したいと思っていますが、私はエラーが発生しており、どこから来ているのか分かりません。以下では、モデルクラス、トレーニングループ、およびバッチ処理メソッドを提供しました。誰も何が起こっているかについての洞察を持っていますか？

output = loss(data, target)行にエラーが表示されます。 CrossEntropyLossが長いテンソルを取るので、それは奇妙な<class 'torch.LongTensor'>に問題があります。出力形状が間違っている可能性があります。フィードフォワード後のtorch.Size([1000, 100, 1000])です。

私は私のモデルが定義されている

として：便利な私のバッチ処理がある場合

import torch.optim as optim 
from torch.autograd import Variable 

net = SkipGram(1000, 300) 
optimizer = optim.SGD(net.parameters(), lr=0.01) 

batch_size = 100 
size = len(train_ints) 

batches = batch_index_gen(batch_size, size) 
inputs, targets = build_tensor_from_batch_index(batches[0], train_ints) 


for i in range(100): 
    running_loss = 0.0 

    for batch_idx, batch in enumerate(batches): 
     data, target = build_tensor_from_batch_index(batch, train_ints) 
#   if (torch.cuda.is_available()): 
#    data, target = data.cuda(), target.cuda() 
#    net = net.cuda() 
     data, target = Variable(data), Variable(target) 
     optimizer.zero_grad() 
     output = net.forward(data) 
     loss = nn.CrossEntropyLoss()  
     output = loss(data, target) 
     output.backward() 
     optimizer.step()       
     running_loss += loss.data[0] 
     optimizer.step() 

     print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
       i, batch_idx * len(batch_size), len(size), 
       100. * (batch_idx * len(batch_size))/len(size), loss.data[0])) 

：私のトレーニングは次のように定義されて

import torch 
import torch.nn as nn 

torch.manual_seed(1) 

class SkipGram(nn.Module): 

    def __init__(self, vocab_size, embedding_dim): 
     super(SkipGram, self).__init__() 
     self.embeddings = nn.Embedding(vocab_size, embedding_dim) 
     self.hidden_layer = nn.Linear(embedding_dim, vocab_size) 

     # Loss needs to be input: (minibatch (N), C) target: (minibatch, 1), each label is a class 
     # Calculate loss in training    

    def forward(self, x): 
     embeds = self.embeddings(x) 
     x = self.hidden_layer(embeds) 
     return x 

def build_tensor_from_batch_index(index, train_ints): 
    minibatch = [] 
    for i in range(index[0], index[1]): 
     input_arr = np.zeros((1000,1), dtype=np.int) 
     target_arr = np.zeros((1000,1), dtype=np.int) 
     input_index, target_index = train_ints[i] 
     input_arr[input_index] = 1 
     target_arr[input_index] = 1 

     input_tensor = torch.from_numpy(input_arr) 
     target_tensor = torch.from_numpy(target_arr) 

     minibatch.append((input_tensor, target_tensor)) 

    # Concatenate all tensors into a minibatch 
    #x = [tensor[0] for tensor in minibatch] 
    #print(x) 
    input_minibatch = torch.cat([tensor[0] for tensor in minibatch], 1) 
    target_minibatch = torch.cat([tensor[1] for tensor in minibatch], 1) 

    #target_minibatch = minibatch[0][1] 
    return input_minibatch, target_minibatch 

Answer 1

私はわからないんだけど私はその論文を読んでいないので、元のデータと目標を使って損失を計算しているのは変だと思われます。

output = loss(data, target) 

ネットワークの出力は、私はあなたのようにあなたの損失を計算するべきだと思いoutput = net.forward(data)であることを考慮すると、この問題が解決しない場合は簡単に紙が損失について言っている私を指摘し、

error = loss(output, target) 

関数。