Python进行GRU和LSTM

你的名字 2023-07-17 12:55 27阅读 0赞

## 加载包 ##

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))