Hi. I’m studying pytorch and RNN.
I can configure simple integer seqeunce prediction model wth embedding.
So, I’m trying to make a model that predict stock price.
This is my idea and model configuration code.

stock.PNG715×399 7.43 KB

The results shown are completely different from the estimates.

And this is my code.
import numpy as np
import torch
import torch.nn as nn
from torch.autograd import Variable
from custom_data_loader import TimeSeries
from torch.utils.data import Dataset, DataLoader

import time, math


class myRNN(nn.Module):
    def __init__(self, input_size, hidden_size, num_layer):
        super(myRNN, self).__init__()
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.num_layer = num_layer

        #embedded = nn.Embedding(input_size, hidden_size)
        self.lstm1 = nn.LSTM(input_size, hidden_size, num_layer)

    def forward(self, input, hidden, cell):
        #embedded_input = self.embedded(input)
        output, hidden = self.lstm1(input, (hidden, cell))
        #deembedded_output = output.view(-1, hidden_size) @ self.embedded.weight.transpose(0,1)
        return output,(hidden, cell)

    def init_hidden(self):
        hidden = Variable(torch.zeros(num_layer, batch_size, hidden_size))
        return hidden



if __name__ == '__main__':

    seq_len = 7
    input_size = 1
    hidden_size = 12000
    num_layer = 1
    batch_size = 1

    #
    rnn = myRNN(input_size, hidden_size, num_layer)
    #loss, optimizer
    optimizer = torch.optim.Adam(rnn.parameters(), lr = 0.0001)


    data_from = TimeSeries(seq_len)
    train_loader = DataLoader(dataset= data_from,
                              batch_size = batch_size,
                              shuffle = True,
                              num_workers = 2)


    for epoch in range(300):
        for i , data in enumerate(train_loader,0):

            inputs, labels = data
            inputs = Variable(inputs.view(-1, batch_size, input_size))
            labels = Variable(labels.view(-1, batch_size, input_size))

            print('Input/Label Size :::: ', inputs.size(), labels.size())

            state = Variable(torch.zeros(num_layer,batch_size,hidden_size))
            cell = Variable(torch.zeros(num_layer,batch_size,hidden_size))

            out, state = rnn(inputs, state, cell)

            optimizer.zero_grad()

            out = out.view(-1, hidden_size)
            labels = labels.view(-1).long()

            print('Output/Label Size :::: ', out.size(), labels.size())

            loss = nn.CrossEntropyLoss()
            err = loss(out, labels)
            err.backward()
            optimizer.step()

            print('[input]', inputs.view(1,-1))
            print('[target]', labels.view(1,-1))
            print('[prediction] ', out.data.max(1)[1])


print('-------done')

import torch
import numpy as np
from torch.autograd import Variable
from torch.utils.data import Dataset, DataLoader
from numpy import genfromtxt
import csv
class TimeSeries(Dataset):
    def __init__(self, seq_len):

        self.seq_len = seq_len
        self.data = []

        f = open('C:/Users/asdfw/Desktop/ICC_Example/data/BTCUSD.csv', 'r')
        csvReader = csv.reader(f)
        for i in csvReader:
            if i[1] != 'High':
                self.data.append(i[1])
        f.close()
        self.data = np.asarray(self.data, dtype=int)

        self.len = self.data.shape[0]


        self.x_data = torch.from_numpy(self.data[:-1])
        self.y_data = torch.from_numpy(self.data[1:])

        self.input = torch.FloatTensor(self.len-seq_len,seq_len)
        self.label = torch.FloatTensor(self.len-seq_len,seq_len)

        for i in range(self.len-seq_len):
            for j in range(seq_len):
                self.input[i][j] =  self.x_data[i+j]

        for i in range(self.len-seq_len):
            for j in range(seq_len):
                self.label[i][j] =  self.y_data[i+j]

        print(self.input.size())
        print(self.label.size())

        self.len = self.input.shape[0]

    def __getitem__(self, item):
        return self.input[item], self.label[item]

    def __len__(self):
        return self.len

So, can i get a appropriate source code that works well ?