def statefulRNNforecasting(dataset,lookBack,inputDim = 1,hiddenNum = 100 ,outputDim = 1 ,unit = "GRU",epoch = 50,batchSize = 10,varFlag=False, minLen = 15, maxLen = 30,inputNum = 150):

    # 归一化数据
    scaler = MinMaxScaler(feature_range=(0, 1))
    dataset = scaler.fit_transform(dataset)

    # 分割序列为样本,并整理成RNN的输入形式
    train,test = util.divideTrainTest(dataset)

    trainX,trainY = util.createSamples(train,lookBack)
    testX, testY = util.createSamples(test,lookBack)

    # 构建模型并训练
    RNNModel = staRNNs.statefulRNNsModel(inputDim, hiddenNum, outputDim, unit=unit, batchSize=batchSize, lag=lookBack)
    if varFlag:
        vtrainX, vtrainY = util.createVariableDataset(train, minLen, maxLen, inputNum)
        RNNModel.train(vtrainX, vtrainY, epoch, batchSize)
    else:
        RNNModel.train(trainX, trainY, epoch, batchSize)

    # 预测
    trainPred = RNNModel.predict(trainX, batchSize)
    testPred = RNNModel.predict(testX, batchSize)

    # 还原数据
    trainPred = scaler.inverse_transform(trainPred)
    trainY = scaler.inverse_transform(trainY)
    testPred = scaler.inverse_transform(testPred)
    testY = scaler.inverse_transform(testY)
    dataset = scaler.inverse_transform(dataset)

    # 评估指标
    # MAE = eval.calcMAE(trainY, trainPred)
    # print ("train MAE",MAE)
    # MRSE = eval.calcRMSE(trainY, trainPred)
    # print ("train MRSE",MRSE)
    # MAPE = eval.calcMAPE(trainY, trainPred)
    # print ("train MAPE",MAPE)
    MAE = eval.calcMAE(testY,testPred)
    print ("test MAE",MAE)
    MRSE = eval.calcRMSE(testY,testPred)
    print ("test RMSE",MRSE)
    MAPE = eval.calcMAPE(testY,testPred)
    print ("test MAPE",MAPE)
    SMAPE = eval.calcSMAPE(testY, testPred)
    print("test MAPE", SMAPE)

    # util.LBtest(testY-testPred)
    # plt.plot(testY-testPred)
    # plt.show()

    #util.plot(trainPred,trainY,testPred,testY)

    return trainPred, testPred, MAE, MRSE, SMAPE
Ejemplo n.º 2
0
def RNN_forecasting(dataset,
                    lookBack,
                    lr,
                    inputDim=1,
                    hiddenNum=64,
                    outputDim=1,
                    unit="GRU",
                    epoch=20,
                    batchSize=30,
                    varFlag=False,
                    minLen=15,
                    maxLen=30,
                    step=5):

    # 归一化数据
    scaler = MinMaxScaler(feature_range=(0, 1))
    dataset = scaler.fit_transform(dataset)

    # 分割序列为样本,并整理成RNN的输入形式
    train, test = util.divideTrainTest(dataset)

    trainX = None
    trainY = None
    vtrainX = None
    vtrainY = None
    testX = None
    testY = None
    vtestX = None
    vtestY = None

    # 构建模型并训练
    RNNModel = RNNs.RNNsModel(inputDim, hiddenNum, outputDim, unit, lr)
    if varFlag:
        vtrainX, vtrainY = util.createVariableDataset(train, minLen, maxLen,
                                                      step)
        vtestX, vtestY = util.createVariableDataset(test, minLen, maxLen, step)
        print("trainX shape is", vtrainX.shape)
        print("trainY shape is", vtrainY.shape)
        print("testX shape is", vtestX.shape)
        print("testY shape is", vtestY.shape)
        RNNModel.train(vtrainX, vtrainY, epoch, batchSize)
    else:
        trainX, trainY = util.createSamples(train, lookBack)
        testX, testY = util.createSamples(test, lookBack)
        print("trainX shape is", trainX.shape)
        print("trainY shape is", trainY.shape)
        print("testX shape is", testX.shape)
        print("testY shape is", testY.shape)
        RNNModel.train(trainX, trainY, epoch, batchSize)

    # 预测
    if varFlag:
        trainPred = RNNModel.predictVarLen(vtrainX, minLen, maxLen, step)
        testPred = RNNModel.predictVarLen(vtestX, minLen, maxLen, step)
        trainPred = trainPred.reshape(-1, 1)
    else:
        trainPred = RNNModel.predict(trainX)
        testPred = RNNModel.predict(testX)
        trainPred = trainPred.reshape(-1, 1)

    if varFlag:
        # 转化一下test的label
        testY = util.transform_groundTruth(vtestY, minLen, maxLen, step)
        testY = testY.reshape(-1, 1)
        testPred = testPred.reshape(-1, 1)
        print("testY", testY.shape)
        print("testPred", testPred.shape)

    # 还原数据
    testPred = scaler.inverse_transform(testPred)
    testY = scaler.inverse_transform(testY)

    # 评估指标
    MAE = eval.calcMAE(testY, testPred)
    print("test MAE", MAE)
    MRSE = eval.calcRMSE(testY, testPred)
    print("test RMSE", MRSE)
    MAPE = eval.calcMAPE(testY, testPred)
    print("test MAPE", MAPE)
    SMAPE = eval.calcSMAPE(testY, testPred)
    print("test SMAPE", SMAPE)

    #util.plot(trainPred,trainY,testPred,testY)

    return trainPred, testPred, MAE, MRSE, SMAPE
Ejemplo n.º 3
0
def diffLagEnsmble(dataset,
                   minLag,
                   maxLag,
                   step,
                   epoch,
                   batchSize=10,
                   inputDim=1,
                   outputDim=1,
                   hiddenNum=50,
                   unit="GRU"):

    # 归一化数据
    dataset = dataset.reshape(-1, 1)
    scaler = MinMaxScaler()
    dataset = scaler.fit_transform(dataset)

    # 分割序列为样本,并整理成RNN的输入形式
    train, test = util.divideTrainTest(dataset)
    modelList = []

    #在所有lag下独立地训练若干个RNN
    for lag in range(minLag, maxLag + 1, step):

        print("lag is ", lag)

        trainX, trainY = util.createPaddedDataset(train, lag, maxLag)
        #testX, testY = util.createPaddedDataset(test, lag, maxLag)

        RNNModel = RNNs.RNNsModel(inputDim, hiddenNum, outputDim, unit)
        RNNModel.train(trainX, trainY, epoch, batchSize)
        modelList.append(RNNModel)

    print("the number of model is ", len(modelList))

    # 变长分割test数据
    testX, testY = util.createVariableDataset(test, minLag, maxLag, step)
    print("testX", testX.shape)
    print("testY", testY.shape)

    lagContainNum = (maxLag - minLag) // step + 1
    print("lag contains num is ", lagContainNum)

    # 对每个数据点上不同的lag用不同的模型做预测,目前是简单取平均
    testNum = len(testX)
    testPred = []
    for i in range(0, testNum, lagContainNum):
        predList = []
        for j in range(0, lagContainNum):
            singlePred = modelList[j].predict(testX[i + j:i + j + 1, :, :])
            predList.append(singlePred)
        testPred.append(np.mean(predList))

    # 还原数据
    testPred = scaler.inverse_transform(testPred)
    testY = scaler.inverse_transform(testY)

    testY = util.transformGroundTruth(testY, minLag, maxLag, step)
    testPred = np.array(testPred)
    print("testY", testY.shape)
    print("testPred", testPred.shape)

    # 评估
    MAE = eval.calcMAE(testY, testPred)
    print("test MAE", MAE)
    MRSE = eval.calcRMSE(testY, testPred)
    print("test RMSE", MRSE)
    MAPE = eval.calcMAPE(testY, testPred)
    print("test MAPE", MAPE)
    SMAPE = eval.calcSMAPE(testY, testPred)
    print("test SMAPE", SMAPE)

    # plt.plot(testY)
    # plt.plot(testPred)
    # plt.show()

    return testPred, MAE, MRSE, SMAPE