Мини-дозировка Pytorch удерживает модель от обучения - PullRequest
Новая
       71

Мини-дозировка Pytorch удерживает модель от обучения

0 голосов
/ 24 июня 2019

Я пытаюсь классифицировать последовательности по двоичной функции. У меня есть набор данных пар последовательности / метка, и я использую простой однослойный LSTM для классификации каждой последовательности. До того, как я внедрил минибатчинг, я получал разумную точность на тестовом наборе (80%), и потери при обучении составляли от 0,6 до 0,3 (в среднем).

Я реализовал мини-пакетирование, используя части этого урока: https://pytorch.org/tutorials/beginner/chatbot_tutorial.html

Однако, теперь моя модель не будет работать лучше, чем 70-72% (70% данных имеют одну метку) с размером пакета, установленным в 1, и всеми остальными параметрами точно так же. Кроме того, потери начинаются с 0,0106 и быстро становятся действительно очень маленькими, без существенных изменений в результатах. Я чувствую, что результаты между отсутствием дозирования и дозированием с размером 1 должны быть одинаковыми, поэтому, возможно, у меня есть ошибка, но я не могу ее найти. Мой код ниже.

Учебный код (одна эпоха): 

for i in t:
    model.zero_grad()

    # prep inputs
    last = i+self.params['batch_size']
    last = last if last < len(train_data) else len(train_data)
    batch_in, lengths, batch_targets = self.batch2TrainData(train_data[shuffled][i:last], word_to_ix, label_to_ix)

    iters += 1

    # forward pass.
    tag_scores = model(batch_in, lengths)

    # compute loss, then do backward pass, then update gradients
    loss = loss_function(tag_scores, batch_targets)
    loss.backward()

    # Clip gradients: gradients are modified in place
    nn.utils.clip_grad_norm_(model.parameters(), 50.0)

    optimizer.step()

Функции: 

def prep_sequence(self, seq, to_ix):
    idxs = [to_ix[w] for w in seq]
    return torch.tensor(idxs, dtype=torch.long)

# transposes batch_in
def zeroPadding(self, l, fillvalue=0):
    return list(itertools.zip_longest(*l, fillvalue=fillvalue))

# Returns padded input sequence tensor and lengths
def inputVar(self, batch_in, word_to_ix):
    idx_batch = [self.prep_sequence(seq, word_to_ix) for seq in batch_in]
    lengths = torch.tensor([len(idxs) for idxs in idx_batch])
    padList = self.zeroPadding(idx_batch)
    padVar = torch.LongTensor(padList)
    return padVar, lengths

# Returns all items for a given batch of pairs
def batch2TrainData(self, batch, word_to_ix, label_to_ix):
    # sort by dec length
    batch = batch[np.argsort([len(x['turn']) for x in batch])[::-1]]
    input_batch, output_batch = [], []
    for pair in batch:
        input_batch.append(pair['turn'])
        output_batch.append(pair['label'])
    inp, lengths = self.inputVar(input_batch, word_to_ix)
    output = self.prep_sequence(output_batch, label_to_ix)
    return inp, lengths, output

Модель: 

class LSTMClassifier(nn.Module):

    def __init__(self, params, vocab_size, tagset_size, weights_matrix=None):
        super(LSTMClassifier, self).__init__()
        self.hidden_dim = params['hidden_dim']

        if weights_matrix is not None:
            self.word_embeddings = nn.Embedding.from_pretrained(weights_matrix)
        else:
            self.word_embeddings = nn.Embedding(vocab_size, params['embedding_dim'])

        self.lstm = nn.LSTM(params['embedding_dim'], self.hidden_dim, bidirectional=False)

        # The linear layer that maps from hidden state space to tag space
        self.hidden2tag = nn.Linear(self.hidden_dim, tagset_size)

    def forward(self, batch_in, lengths):
        embeds = self.word_embeddings(batch_in)
        packed = nn.utils.rnn.pack_padded_sequence(embeds, lengths)
        lstm_out, _ = self.lstm(packed)
        outputs, _ = nn.utils.rnn.pad_packed_sequence(lstm_out)
        tag_space = self.hidden2tag(outputs)
        tag_scores = F.log_softmax(tag_space, dim=0)
        return tag_scores[-1]

1 Ответ

0 голосов
/ 26 июня 2019

Для всех, кто сталкивался с подобной проблемой, я получил его на работу.Я удалил вычисление log_softmax, поэтому: 

tag_space = self.hidden2tag(outputs)
tag_scores = F.log_softmax(tag_space, dim=0)
return tag_scores[-1]

становится таким: 

tag_space = self.hidden2tag(outputs)
return tag_space[-1]

Я также изменил NLLLoss на CrossEntropyLoss (не показано выше) и инициализировал CrossEntropyLoss без параметров (aka no ignore_index).

Я не уверен, почему эти изменения были необходимы (в документах даже говорится, что NLLLoss следует запускать после слоя log_softmax), но они заставили мою модель работать и довели мою потерю до разумногодиапазон (~ 0,5).

...