нелинейная регрессия по Pytorch - PullRequest
Новая
       32

нелинейная регрессия по Pytorch

1 голос
/ 01 июля 2019

Я пытаюсь реализовать задачу нелинейной регрессии с помощью PyTorch. Входными данными являются некоторые предложения, а выходными являются их оценки (Эти оценки представляют собой числа с плавающей запятой) Для понимания предложений с помощью компьютера я преобразовываю каждое предложение в реальный вектор 50d (это векторы вложения) с помощью слоя torch.nn.RNN (Recurrent Neural Network). Затем я использую слой torch.nn.Linear, чтобы предсказать результат.

Это моя модель: 

import torch
import torch.nn as nn
from torch.nn.utils.rnn import pack_padded_sequence
import text_processing as tp
import torch.nn.functional as F


class RNNModel(nn.Module):
##################        __init__          ####################
    def __init__(self, vocab_size, input_size,hidden_size, output_size,my_embeddings,n_layers,bidirectional=True):
        super(RNNModel, self).__init__()
        self.hidden_size = hidden_size
        self.n_layers = n_layers
        self.n_directions = int(bidirectional) + 1

        self.embedding = nn.Embedding(vocab_size, hidden_size)
        self.rnn = nn.RNN(input_size,hidden_size,n_layers,bidirectional=bidirectional)
        self.fc = nn.Linear(hidden_size, output_size)
####################          forward          #################
    def forward(self, batch_of_sentences, batch_of_len):
        """
        input shape: B x S ([num of sentences in this batch] x [max sent len in this batch] )
        transpose to make S x B
        """
        input=batch_of_sentences
        input = input.t()
        batch_size = input.size(1)

        # Make a hidden
        hidden = self._init_hidden(batch_size)

        # Embedding S x B -> S x B x I (embedding size)
        embedded = self.embedding(input)
        # Pack them up nicely
        rnn_input = pack_padded_sequence(embedded, batch_of_len.data.cpu().numpy())

        # To compact weights again call flatten_parameters().
        self.rnn.flatten_parameters()
        output, hidden = self.rnn(rnn_input, hidden)
        fc_output = self.fc(hidden[-1])
        return fc_output

##################          _init_hidden          ##################
    def _init_hidden(self, batch_size):
        hidden = torch.zeros(self.n_layers * self.n_directions,
                             batch_size, self.hidden_size)
        return tp.create_variable(hidden)

Я назвал модель в основной программе: 

my_rnn_model = RNNModel(VOCAB_SIZE,INPUT_SIZE, HIDDEN_SIZE,OUTPUT_SIZE, tp.my_embeddings_train_dev,N_LAYERS, bidirectional=True)
criterion = torch.nn.MSELoss(size_average=False)
LR = 0.001
optimizer = torch.optim.Adam(my_rnn_model.parameters(), lr=LR, betas=(0.9, 0.99)
for epoch in range(1, N_EPOCHS + 1):
   loss=train()

Вот функция train (): 

def train():

    #Loading Data From TrainLoader
    for i, (batch_sents, batch_target_scores) in enumerate(train_loader, 1):
        #Zero Padding
        zero_padded_batch_sent, sorted_batch_len, sorted_batch_target_scores = tp.make_variables(batch_sents, batch_target_scores,"train")

        #Compute Output for Each Batch of Sentences
        output = my_rnn_model(zero_padded_batch_sent, sorted_batch_len)

        #Compute Loss
        loss = criterion(output, sorted_batch_target_scores)

        #Updating Parameters by Backward Propagation
        my_rnn_model.zero_grad()
        loss.backward()
        optimizer.step()

Но я думаю, что моя модель не может запоминать данные, потому что после пробега 30 эпох кривая потерь для данных поезда и теста очень вибрирует. Пока я ожидаю, что ошибка замедлится со временем, и она не будет колебательной.

Это кривая потерь-эпох для данных о поездах и тестах за 30 эпох: enter image description here

Я думаю, что модель не работает должным образом. какая часть моего кода неверна? Заранее спасибо.

...