def pricepre():
result = {"success": 'False'}
class LSTM(nn.Module):
def __init__(self, input_size=1, hidden_layer_size=6, output_size=1):
super().__init__()
self.hidden_layer_size = hidden_layer_size
self.lstm = nn.LSTM(input_size, hidden_layer_size)
self.linear = nn.Linear(hidden_layer_size, output_size)
self.hidden_cell = (
torch.zeros(1, 1, self.hidden_layer_size),
torch.zeros(1, 1, self.hidden_layer_size)
) # (num_layers * num_directions, batch_size, hidden_size)
def forward(self, input_seq):
lstm_out, self.hidden_cell = self.lstm(
input_seq.view(len(input_seq), 1, -1), self.hidden_cell)
predictions = self.linear(lstm_out.view(len(input_seq), -1))
return predictions[-1]
#model = LSTM()
model = LSTM(1, 6)
model.load_state_dict(
torch.load('model_parameters.pkl')) # 提取net1的状态参数，将状态参数给net3
#单维最大最小归一化和反归一化函数
data_csv = pd.read_csv('price.csv', usecols=[1]) #导入第一列，即价格那一列的数据
data_csv = data_csv.dropna() #去掉na数据
dataset = data_csv.values #dataframe 转为 ndarray
dataset = dataset.astype('float32')
# 数据集分为训练集和测试集
test_data_size = 8
train_data = dataset[:-test_data_size]
test_data = dataset[-test_data_size:]
def Normalize(list):
list = np.array(list)
low, high = np.percentile(list, [0, 100])
delta = high - low
if delta != 0:
for i in range(0, len(list)):
list[i] = (list[i] - low) / delta
return list, low, high
def FNoramlize(list, low, high):
delta = high - low
if delta != 0:
for i in range(0, len(list)):
list[i] = list[i] * delta + low
return list
list, low, high = Normalize(train_data)
##3.模型预测
fut_pred = 8
train_window = 5
data = request.get_data()
print('data=%s' % data)
json_data = json.loads(data.decode("utf-8"))
print(json_data)
test_list = json_data.get('test_list')
print(test_list)
def Normalize2(list, low, high):
list = np.array(test_list)
delta = high - low
if delta != 0:
for i in range(0, len(list)):
list[i] = (list[i] - low) / delta
return list.tolist()
test_inputs = Normalize2(test_list, low, high)
print(test_inputs)
###预测
model.eval()
for i in range(fut_pred):
seq = torch.FloatTensor(test_inputs[-train_window:]) ##是个张量
print(seq)
with torch.no_grad():
model.hidden = (torch.zeros(1, 1, model.hidden_layer_size),
torch.zeros(1, 1, model.hidden_layer_size))
pre = model(seq) ########################## 预测的结果
print(pre)
test_inputs.append(
model(seq).item()) ########################## 模型预测时模型的输入
print(test_inputs) #它包含13个元素。5+8
print(len(test_inputs)) #13
test_pre = test_inputs[-fut_pred:] #最后8个预测结果
def FNoramlize(list, low, high):
delta = high - low
if delta != 0:
for i in range(0, len(list)):
list[i] = list[i] * delta + low
return list
test_real = FNoramlize(test_pre, low, high)
print(test_real)
result["prediction"] = test_real
result["success"] = True
return jsonify(result)
def experiment(repeats):
"""
Runs the experiment itself.
:param repeats: Number of times to repeat the experiment. When we are trying to create a good network, it is reccomended to use 1.
:return: Error scores for each repeat.
"""
# create data
raw_timestamp = range(600)
raw_timestamp = array(raw_timestamp) + numpy.random.rand(
len(raw_timestamp))
diff_timestamp = difference(
numpy.array(raw_timestamp) +
2 * numpy.random.rand(raw_timestamp.shape[0]) - 1, 1)
raw_pos = [fake_position(i / 30) for i in range(-300, 300)]
raw_pos = array(raw_pos)
diff_pos = difference(raw_pos, 1)
diff_pos = array(diff_pos)
raw_accel = [fake_acceleration(i / 30) for i in range(-300, 300)]
raw_accel = array(raw_accel)
diff_accel = difference(raw_accel, 1)
diff_accel = array(diff_accel)
# Scaling data
X_scaler = StandardScaler()
raw_accel = X_scaler.fit_transform(raw_accel.reshape(-1, 1))
y_scaler = MinMaxScaler(feature_range=(-1, 1))
diff_pos = y_scaler.fit_transform(diff_pos.reshape(-1, 1))
raw_timestamp = raw_timestamp[1:]
raw_pos = raw_pos[1:]
raw_accel = raw_accel[1:]
raw_accel = raw_accel.reshape(-1)
diff_pos = diff_pos.reshape(-1)
X, y = timeseries_dataloader(data_x=raw_accel,
data_y=diff_pos,
enable_asymetrical=True)
model = LSTM(input_size=1,
hidden_layer_size=80,
n_lstm_units=3,
bidirectional=False,
output_size=1,
training_batch_size=60,
epochs=20000,
device=device)
# enabling CUDA
model.to(device)
# Let's go fit! Comment if only loading pretrained model.
model.fit(X, y)
X_graphic = torch.from_numpy(raw_accel.astype("float32")).to(device)
y_graphic = diff_pos.astype("float32")
# =====================TEST=================================================
model = torch.load("best_model.pth")
model.to(device)
yhat = []
model.hidden_cell = (torch.zeros(model.num_directions * model.n_lstm_units,
1,
model.hidden_layer_size).to(model.device),
torch.zeros(model.num_directions * model.n_lstm_units,
1,
model.hidden_layer_size).to(model.device))
model.eval()
for X in X_graphic:
yhat.append(model(X.view(1, -1, 1)).detach().cpu().numpy())
# from list to numpy array
yhat = array(yhat).reshape(-1)
# ======================PLOT================================================
plt.close()
plt.plot(range(yhat.shape[0]), yhat, range(y_graphic.shape[0]), y_graphic)
plt.savefig("output_reconstruction.png", dpi=800)
# plt.show()
rmse = mean_squared_error(yhat, y_graphic)**1 / 2
print("RMSE trajetoria inteira: ", rmse)
error_scores = []
return error_scores
def experiment(repeats):
"""
Runs the experiment itself.
:param repeats: Number of times to repeat the experiment. When we are trying to create a good network, it is reccomended to use 1.
:return: Error scores for each repeat.
"""
# transform data to be stationary
raw_pos = [fake_position(i / 30) for i in range(-300, 300)]
diff_pos = difference(raw_pos, 1)
raw_accel = [fake_acceleration(i / 30) for i in range(-300, 300)]
diff_accel = difference(raw_accel, 1)
# diff_accel = numpy.array(raw_accel)
# raw_timestamp = range(len(raw_pos))
# # diff_timestamp = difference(numpy.array(raw_timestamp) + numpy.random.rand(len(raw_pos)), 1)
# diff_timestamp = array(raw_timestamp)
# testar com lstm BIDIRECIONAL
model = LSTM(input_size=1,
hidden_layer_size=40,
n_lstm_units=3,
bidirectional=False,
output_size=1,
training_batch_size=60,
epochs=2000,
device=device)
raw_pos = raw_pos[1:]
raw_accel = raw_accel[1:]
raw_accel = array(raw_accel)
raw_pos = array(raw_pos)
diff_accel = array(diff_accel)
diff_pos = array(diff_pos)
X_scaler = StandardScaler()
raw_accel = X_scaler.fit_transform(raw_accel.reshape(-1, 1))
y_scaler = MinMaxScaler(feature_range=(-1, 1))
diff_pos = y_scaler.fit_transform(diff_pos.reshape(-1, 1))
raw_accel = raw_accel.reshape(-1)
diff_pos = diff_pos.reshape(-1)
X, y = timeseries_dataloader(data_x=raw_accel,
data_y=diff_pos,
enable_asymetrical=True)
# Invertendo para a sequencia ser DEcrescente.
# X = X[::-1]
# y = y[::-1]
# enabling CUDA
model.to(device)
# Let's go fit
model.fit(X, y)
X_graphic = torch.from_numpy(raw_accel.astype("float32")).to(device)
y_graphic = torch.from_numpy(diff_pos.astype("float32")).to(device)
model = torch.load("best_model.pth")
model.to(device)
yhat = []
model.hidden_cell = (torch.zeros(model.num_directions * model.n_lstm_units,
1,
model.hidden_layer_size).to(model.device),
torch.zeros(model.num_directions * model.n_lstm_units,
1,
model.hidden_layer_size).to(model.device))
model.eval()
for X in X_graphic:
yhat.append(model(X.view(1, -1, 1)))
# report performance
plt.close()
plt.plot(range(len(yhat)), yhat, range(len(y)), y)
plt.savefig("output_train.png", dpi=800)
plt.show()
# rmse = mean_squared_error(raw_pos[:len(train_scaled)], predictions)
error_scores = []
return error_scores
