Python进行GRU和LSTM

加载包

import numpy as np
import pandas as pd
import math
#Sequential多个网络层的线性堆叠；Dense隐含层
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import LSTM
from keras.layers import SimpleRNN
from keras.layers import GRU
from sklearn.preprocessing import MinMaxScaler
from sklearn.metrics import mean_squared_error, mean_absolute_error

数据定义

def create_dataset(dataset, look_back):
    dataX, dataY = [], []
    for i in range(len(dataset)-look_back):
        a = dataset[i:(i+look_back), 0]
#append向列表的尾部增加元素
        dataX.append(a)
        dataY.append(dataset[i + look_back, 0])
    return np.array(dataX), np.array(dataY)

数据分割

# fix random seed for reproducibility
#seed用于指定随机数生成时所用算法开始的整数值
np.random.seed(7)
# load the dataset/下载数据集 
#usecols获取数据的列，如果取前4列，则usecols=(0,1,2,3)
#print(XXXX)
dataframe = pd.read_csv(r'333.csv' \
                    , usecols=[0], engine='python')
dataset = dataframe.values
dataset = dataset.astype('float32')
# normalize the dataset/标准化数据集 
scaler = MinMaxScaler(feature_range=(0, 1))
dataset = scaler.fit_transform(dataset)

# split into train and test sets/分割训练集与测试集 
    #train_size = int(len(dataset) * 0.84)
       
vsize = 200;
train_size = 800;
#print(train_size )
   # test_size = len(dataset) - train_size
look_back =10
train, test = dataset[0:train_size-1,:], dataset[train_size-look_back-1:train_size+vsize-1,:]
# dataset detail/具体分割后数据集
trainX, trainY = create_dataset(train, look_back)
testX, testY = create_dataset(test, look_back)
#predX, predY = create_dataset(pred, look_back)
# reshape input to be [samples, feature_num, features]

trainX = np.reshape(trainX, (trainX.shape[0], 1, trainX.shape[1]))
testX = np.reshape(testX, (testX.shape[0], 1, testX.shape[1]))

建模预测

#predX = np.reshape(predX,(predX.shape[0], 1, predX.shape[1]))
    #print(trainX ))
   # start_cr_a_fit_net = time.time()
# create and fit the LSTM network/创建并拟合LSTM网络 

model = Sequential()
model.add(GRU(15, input_shape=(None,look_back)))
#model.add(SimpleRNN(18, input_shape=(None,look_back)))
    #model.add(GRU(XXXX[1], input_shape=(None,look_back)))
model.add(Dense(1))
model.summary()
#model.compile(loss='mean_squared_error', optimizer='adam')
model.compile(loss='mean_squared_error', optimizer='sgd')
model.fit(trainX, trainY, epochs=331, batch_size=1, verbose=0)
   # end_cr_a_fit_net = time.time()-start_cr_a_fit_net
   # print('Running time of creating and fitting the LSTM network: %.2f Seconds' % (end_cr_a_fit_net))

# make predictions/进行预测
trainPredict = model.predict(trainX)
testPredict = model.predict(testX)
#NpredY = model.predict(predX)
##### invert predictions start ##### / 将预测值转换为正常数值
# create empty table with 12 fields
trainPredict=scaler.inverse_transform(trainPredict)
trainY=scaler.inverse_transform([trainY])
testPredict=scaler.inverse_transform(testPredict)
testY=scaler.inverse_transform([testY])
#NpredY = scaler.inverse_transform(NpredY)
#predY=scaler.inverse_transform([predY])
  #  print(predY)
   # print(NpredY)
#    print('测试集预测值' )
#    print(testPredict)
     
##### invert predictions end #####
# calculate root mean squared error/计算RMSE和误差率
 #   trainScore = math.sqrt(mean_squared_error(trainY[0], trainPredict[:,0]))
#    print('Train Score: %.8f RMSE' % (trainScore))
  #  testScore = math.sqrt(mean_squared_error(testY[0], testPredict[:,0]))
 #   print('Test Score: %.8f RMSE' % (testScore))
   # df = pd.DataFrame(NpredY[:,0])
   # aa=df.to_excel('12.xlsx',encoding='utf-8')
#df = pd.DataFrame(NpredY[:,0])
#aa=df.to_excel('12.xlsx',encoding='utf-8')
preRMSE = math.sqrt(mean_squared_error(testY[0], testPredict[:,0]))
print('Test RMSE: %.8f RMSE' % (preRMSE))
preMSE = mean_squared_error(testY[0], testPredict[:,0])
print('Test MSE: %.8f MSE' % (preMSE))
trainMAE = mean_absolute_error(testY[0], testPredict[:,0])
print('Test MAE: %.8f MAE' % (trainMAE))
  #  testMAE = mean_absolute_error(testY[0], testPredict[:,0])
   # print('Test MAE: %.8f MAE' % (testMAE))
   #trainMAPE = np.mean(np.abs(trainY[0]-trainPredict[:,0])/trainY[0])
   # print('Train MAPE: %.8f %% MAPE' % (trainMAPE*100))
#testMAPE = np.mean(np.abs(testY[0]-testPredict[:,0])/testY[0])
#print('Test MAPE: %.8f %% MAPE' % (testMAPE*100))
predMAPE = np.mean(np.abs(testY[0]-testPredict[:,0])/testY[0])
print('predY MAPE: %.8f %% MAPE' % (predMAPE*100))