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

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)