Como usar rede neural PYTORCH ja treinada para prever valores dos dias futuros

07/02/2021

6

Oi amigos estou desesperado, não consigo usar uma rede neural que encontrei para fazer previsões futuras, ,consigo fazer varias alterações, mas não consigo de jeito algum usar o modelo ja treinado para prever valores futuros, alguém sabe como posso fazer isso, não encontro em lugar algum, nem na documentação do pythorch. Segue o código que eu tenho, quero prever os dias seguintes, não testar, usar o ja treinado para prever os dias seguintes, tem como fazer isso?

import pandas as pd
import numpy as np
import math
import torch
import matplotlib.pyplot as plt
import yfinance as yf

#data = pd.DataFrame
#data = pd.read_csv('EURUSD_M1_Pequeno.csv', sep="\t", usecols=[5])

data = yf.download('EURUSD=X', start='2021-01-28', end='2021-02-4', interval = "1m")

data = data.Close

# Quantidades total de dados, treinamento e teste.
print(f'Total: {data.size}')
print(f'Treinamento: {round(data.size*.8)}')
print(f'Teste: {data.size - round(data.size*.8)}')


# Plotar o gráfico todo
plt.figure(figsize=(18, 6))
plt.plot(data, '-')
plt.xlabel('DIAS')
plt.ylabel('VALOR R$')
plt.title('PETR4.SA')
plt.show()

# Plotar treinamento e teste
plt.figure(figsize=(18, 6))
plt.plot(data[:850], 'r-')
plt.plot(data[850:], 'g-')
plt.xlabel('DIAS')
plt.ylabel('VALOR R$')
plt.title('PETR4.SA')
plt.axvline(data.index[850], 0, 30, color='k', linestyle='dashed', label='Teste')
plt.text(data.index[320], 25, 'Treinamento', fontsize='x-large')
plt.text(data.index[910], 15, 'Testes', fontsize='x-large')
plt.show()

# Plotar apenas teste
plt.figure(figsize=(10, 6))
plt.plot(data[850:], 'g-')
plt.xlabel('DIAS')
plt.ylabel('VALOR R$')
plt.title('PETR4.SA')
plt.show()

# Criar janela deslizante
janelas = 50

data_final = np.zeros([data.size - janelas, janelas + 1])

for i in range(len(data_final)):
for j in range(janelas+1):
data_final[i][j] = data.iloc[i+j]
print(data_final[:10])

# Normalizar entre 0 e 1
max = data_final.max()
min = data_final.min()
dif = data_final.max() - data_final.min()
data_final = (data_final - data_final.min())/dif

x = data_final[:, :-1]
y = data_final[:, -1]
print(max, min, dif)

# Converter para tensor
#Entrada do treinamento
#Saída do treinamento
training_input = torch.FloatTensor(x[:10, :])
training_output = torch.FloatTensor(y[:10])

#Entrada do teste
#Saída do teste
test_input = torch.FloatTensor(x[10: , :])
test_output = torch.FloatTensor(y[10:])

#print(test_input)
#print(test_output)

# Classe do modelo da Rede Neural
class Net(torch.nn.Module):
def __init__(self, input_size, hidden_size):
super(Net, self).__init__()
self.input_size = input_size
self.hidden_size = hidden_size
self.fc1 = torch.nn.Linear(self.input_size, self.hidden_size)
self.relu = torch.nn.ReLU()
self.fc2 = torch.nn.Linear(self.hidden_size, 1)
def forward(self, x):
hidden = self.fc1(x)
relu = self.relu(hidden)
output = self.fc2(relu)
output = self.relu(output)
return output


# Criar a instância do modelo
input_size = training_input.size()[1]
hidden_size = 100
model = Net(input_size, hidden_size)
print(f'Entrada: ')
print(f'Escondida: ')
print(model)


# Critério de erro
criterion = torch.nn.MSELoss()

# Criando os paramêtros (learning rate[obrigatória] e momentum[opcional])
lr = 0.09 #0.01
momentum = 0.03 #0.01
optimizer = torch.optim.SGD(model.parameters(), lr, momentum)

# Para visualizar os pesos
for param in model.parameters():
# print(param)
pass


# Treinamento
model.train()
epochs = 10001
errors = []
for epoch in range(epochs):
optimizer.zero_grad()
# Fazer o forward
y_pred = model(training_input)
# Cálculo do erro
loss = criterion(y_pred.squeeze(), training_output)
errors.append(loss.item())
if epoch % 1000 == 0:
print(f'Epoch: . Train loss: {loss.item()}.')
# Backpropagation
loss.backward()
optimizer.step()


# Testar o modelo já treinado
model.eval()
y_pred = model(test_input)
after_train = criterion(y_pred.squeeze(), test_output)
print('Test loss after Training' , after_train.item())
#model.eval()
#y_pred = model(test_input)
#after_train = criterion(y_pred.squeeze(), test_output)
#print('Test loss after Training' , after_train.item())


# Gráficos de erro e de previsão
def plotcharts(errors):
errors = np.array(errors)
lasterrors = np.array(errors[-25000:])
plt.figure(figsize=(18, 5))
graf01 = plt.subplot(1, 3, 1) # nrows, ncols, index
graf01.set_title('Errors')
plt.plot(errors, '-')
plt.xlabel('Epochs')
graf02 = plt.subplot(1, 3, 2) # nrows, ncols, index
graf02.set_title('Last 25k Errors')
plt.plot(lasterrors, '-')
plt.xlabel('Epochs')
graf03 = plt.subplot(1, 3, 3)
graf03.set_title('Tests')
a = plt.plot(test_output.numpy(), 'y-', label='Real')
#plt.setp(a, markersize=10)
a = plt.plot(y_pred.detach().numpy(), 'b-', label='Predicted')
#plt.setp(a, markersize=10)
plt.legend(loc=7)
plt.show()
plotcharts(errors)
Caio

Caio

Responder

Utilizamos cookies para fornecer uma melhor experiência para nossos usuários,
consulte nossa política de privacidade.

Aceitar