def seasonANNForecasting(ts, dataset, freq, lag): # 序列分解 #ts.index = pd.date_range(start='19960318',periods=len(ts), freq='Q') trend, seasonal, residual = season_decompose.seasonDecompose(ts, freq=freq) # print trend.shape # print seasonal.shape # print residual.shape # 分别预测 trendWin = lag resWin = trendWin t1 = time.time() trTrain, trTest, mae1, mrse1, smape1 = ANNFORECAST.ANNforecasting( trend, inputDim=trendWin, epoch=100, hiddenNum=100) resTrain, resTest, mae2, mrse2, smape2 = ANNFORECAST.ANNforecasting( residual, inputDim=resWin, epoch=100, hiddenNum=100) t2 = time.time() print(t2 - t1) #''' # 数据对齐 trendPred, resPred = util.align(trTrain, trTest, trendWin, resTrain, resTest, resWin) # 获取最终预测结果 finalPred = trendPred + seasonal + resPred trainPred = trTrain + seasonal[trendWin:trendWin + trTrain.shape[0]] + resTrain testPred = trTest + seasonal[2 * resWin + resTrain.shape[0]:] + resTest # 获得ground-truth数据 data = dataset[freq // 2:-(freq // 2)] trainY = data[trendWin:trendWin + trTrain.shape[0]] testY = data[2 * resWin + resTrain.shape[0]:] # 评估指标 # 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 SMAPE", SMAPE) # plt.plot(data) # plt.plot(finalPred) # plt.show() #''' return trainPred, testPred, MAE, MRSE, SMAPE
def decompose_RNN_forecasting(ts, dataset, freq, lag, epoch=20, hidden_num=64, batch_size=32, lr=1e-3, unit="GRU", varFlag=False, maxLen=48, minLen=24, step=8): # 序列分解 trend, seasonal, residual = decompose.ts_decompose(ts, freq) print("trend shape:", trend.shape) print("peroid shape:", seasonal.shape) print("residual shape:", residual.shape) # 分别预测 resWin = trendWin = lag t1 = time.time() trTrain, trTest, MAE1, MRSE1, SMAPE1 = RNN_forecasting(trend, lookBack=lag, epoch=epoch, batchSize=batch_size, hiddenNum=hidden_num, varFlag=varFlag, minLen=minLen, maxLen=maxLen, step=step, unit=unit, lr=lr) resTrain, resTest, MAE2, MRSE2, SMAPE2 = RNN_forecasting(residual, lookBack=lag, epoch=epoch, batchSize=batch_size, hiddenNum=hidden_num, varFlag=varFlag, minLen=minLen, maxLen=maxLen, step=step, unit=unit, lr=lr) t2 = time.time() print(t2-t1) print("trTrain shape:", trTrain.shape) print("resTrain shape:", resTrain.shape) # 数据对齐 trendPred, resPred = util.align(trTrain, trTest, trendWin, resTrain, resTest, resWin) print("trendPred shape is", trendPred.shape) print("resPred shape is", resPred.shape) # 获取最终预测结果 # finalPred = trendPred+seasonal+resPred trainPred = trTrain+seasonal[trendWin:trendWin+trTrain.shape[0]]+resTrain testPred = trTest+seasonal[2*resWin+resTrain.shape[0]:]+resTest # 获得ground-truth数据 data = dataset[freq//2:-(freq//2)] trainY = data[trendWin:trendWin+trTrain.shape[0]] testY = data[2*resWin+resTrain.shape[0]:] # 评估指标 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, label='ground-truth') plt.plot(testPred, label='prediction') plt.xlabel("Time", fontsize=10) plt.ylabel("CPU Utilization(%)", fontsize=10) plt.legend() foo_fig = plt.gcf() foo_fig.savefig('M_1955_CPU.eps', format='eps', dpi=1000, bbox_inches='tight') plt.show() return trainPred, testPred, MAE, MRSE, SMAPE
def decompose_MLP_forecasting(ts, dataset, freq, lag, epoch=20, hidden_num=64, batch_size=32, lr=1e-3): # 序列分解 trend, seasonal, residual = decompose.ts_decompose(ts, freq=freq) print("trend shape:", trend.shape) print("peroid shape:", seasonal.shape) print("residual shape:", residual.shape) # 分别预测 resWin = trendWin = lag t1 = time.time() trTrain, trTest, mae1, mrse1, smape1 = \ ANNFORECAST.MLP_forecasting(trend, inputDim=trendWin, epoch=epoch, hiddenNum=hidden_num, batchSize=batch_size, lr=lr) resTrain, resTest, mae2, mrse2, smape2 = \ ANNFORECAST.MLP_forecasting(residual, inputDim=trendWin, epoch=epoch, hiddenNum=hidden_num, batchSize=batch_size, lr=lr) t2 = time.time() print("time:", t2 - t1) # 数据对齐 # trendPred, resPred = util.align(trTrain, trTest, trendWin, resTrain, resTest, resWin) # 获取最终预测结果 # finalPred = trendPred + seasonal + resPred trainPred = trTrain + seasonal[trendWin:trendWin + trTrain.shape[0]] + resTrain testPred = trTest + seasonal[2 * resWin + resTrain.shape[0]:] + resTest # 获得ground-truth数据 data = dataset[freq // 2:-(freq // 2)] trainY = data[trendWin:trendWin + trTrain.shape[0]] testY = data[2 * resWin + resTrain.shape[0]:] # 评估指标 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(data) # plt.plot(finalPred) # plt.show() return trainPred, testPred, MAE, MRSE, SMAPE
def seasonSVRForecasting(ts, dataset, freq, lag): # 序列分解 trend, seasonal, residual = season_decompose.seasonDecompose(ts, freq=freq) # print trend.shape # print seasonal.shape # print residual.shape # 分别预测 trendWin = lag resWin = trendWin t1 = time.time() trTrain, trTest, mae1, mrse1, mape1 = SVRFORECAST.SVRforecasting( trend, lookBack=trendWin) resTrain, resTest, mae2, mrse2, mape2 = SVRFORECAST.SVRforecasting( residual, lookBack=resWin) t2 = time.time() print(t2 - t1) #''' # 数据对齐 trendPred, resPred = util.align(trTrain, trTest, trendWin, resTrain, resTest, resWin) # 获取最终预测结果 finalPred = trendPred + seasonal + resPred trainPred = trTrain + seasonal[trendWin:trendWin + trTrain.shape[0]] #+resTrain testPred = trTest + seasonal[2 * resWin + resTrain.shape[0]:] #+resTest # 获得ground-truth数据 data = dataset[freq // 2:-(freq // 2)] trainY = data[trendWin:trendWin + trTrain.shape[0]] testY = data[2 * resWin + resTrain.shape[0]:] # 评估指标 # 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 SMAPE", SMAPE) # plt.plot(data) # plt.plot(finalPred) # plt.show() #''' return trainPred, testPred, MAE, MRSE, SMAPE
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
def decompose_SVR_forecasting(ts, dataset, freq, lag, C=0.1, epsilon=0.01): # 序列分解 trend, seasonal, residual = decompose.ts_decompose(ts, freq=freq) print("trend shape:", trend.shape) print("peroid shape:", seasonal.shape) print("residual shape:", residual.shape) # 分别预测 resWin = trendWin = lag t1 = time.time() trTrain, trTest, mae1, mrse1, mape1 = SVR_forecasting(trend, lookBack=lag, C=C, epsilon=epsilon) resTrain, resTest, mae2, mrse2, mape2 = SVR_forecasting(residual, lookBack=lag, C=C, epsilon=epsilon) t2 = time.time() print(t2 - t1) # 数据对齐 trendPred, resPred = util.align(trTrain, trTest, trendWin, resTrain, resTest, resWin) # 获取最终预测结果 finalPred = trendPred + seasonal + resPred trainPred = trTrain + seasonal[trendWin:trendWin + trTrain.shape[0]] + resTrain testPred = trTest + seasonal[2 * resWin + resTrain.shape[0]:] + resTest # 获得ground-truth数据 data = dataset[freq // 2:-(freq // 2)] trainY = data[trendWin:trendWin + trTrain.shape[0]] testY = data[2 * resWin + resTrain.shape[0]:] # 评估指标 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(data) # plt.plot(finalPred) # plt.show() return trainPred, testPred, MAE, MRSE, SMAPE
def SVRforecasting(dataset, lookBack): # 归一化数 #dataset = dataset.reshape(-1, 1) scaler = MinMaxScaler(feature_range=(0, 1)) dataset = scaler.fit_transform(dataset) # 分割序列为样本,此处不整理成RNN形式,采用标准形式 train, test = util.divideTrainTest(dataset) trainX, trainY = util.createSamples(train, lookBack, RNN=False) testX, testY = util.createSamples(test, lookBack, RNN=False) # 构建模型并训练 SVRModel = SVR.SVRModel(C=2, epsilon=0.01) SVRModel.train(trainX, trainY) # 预测 trainPred = SVRModel.predict(trainX) testPred = SVRModel.predict(testX) # 还原数据 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 SMAPE", SMAPE) #util.plot(trainPred,trainY,testPred,testY) return trainPred, testPred, MAE, MRSE, SMAPE
def SVR_forecasting(dataset, lookBack, C=2.0, epsilon=0.01, plot_flag=False): # normalize time series scaler = MinMaxScaler(feature_range=(0, 1)) dataset = scaler.fit_transform(dataset) # divide the series into training/testing samples # NOTE: Not RNN format train, test = util.divideTrainTest(dataset) trainX, trainY = util.createSamples(train, lookBack, RNN=False) testX, testY = util.createSamples(test, lookBack, RNN=False) print("trainX shape is", trainX.shape) print("trainY shape is", trainY.shape) print("testX shape is", testX.shape) print("testY shape is", testY.shape) # buil model and train SVRModel = SVR.SVRModel(C=C, epsilon=epsilon) SVRModel.train(trainX, trainY) # forecasting trainPred = SVRModel.predict(trainX).reshape(-1, 1) testPred = SVRModel.predict(testX).reshape(-1, 1) # reverse the time series trainPred = scaler.inverse_transform(trainPred) trainY = scaler.inverse_transform(trainY) testPred = scaler.inverse_transform(testPred) testY = scaler.inverse_transform(testY) # evaluate 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) if plot_flag: util.plot(trainPred, trainY, testPred, testY) return trainPred, testPred, MAE, MRSE, SMAPE
def run_aram(data, maxar, maxma): train, test = util.divideTrainTest(data) print("train shape is", train.shape) print("test shape is", test.shape) diffn = 0 if stationarity(train) < 0.01: print('平稳,不需要差分') else: diffn = best_diff(train, maxdiff=8) # train = produce_diffed_timeseries(train, diffn) print('差分阶数为' + str(diffn)) print('开始进行ARMA拟合') order = choose_order(train, maxar, maxma) print('模型的阶数为:' + str(order)) diffn = 1 _ar = order[0] _ma = order[1] train = train.flatten() model = pf.ARIMA(data=train, ar=_ar, ma=_ma, integ=diffn, family=pf.Normal()) model.fit("MLE") testPred = model.predict(len(test)) # testPred = predict_recover(test_predict, train, diffn) # 评估指标 MAE = eval.calcMAE(test, testPred) print("test MAE", MAE) MRSE = eval.calcRMSE(test, testPred) print("test RMSE", MRSE) MAPE = eval.calcMAPE(test, testPred) print("test MAPE", MAPE) SMAPE = eval.calcSMAPE(test, testPred) print("test SMAPE", SMAPE)
# autocorrelation_plot(ts) # pyplot.show() X = ts.values X = np.array(X, dtype="float64") size = int(len(X) * 0.9) train, test = X[0:size], X[size:len(X)] history = [x for x in train] predictions = [] for t in range(len(test)): model = ARIMA(history, order=(4, 1, 3)) model_fit = model.fit(disp=0) output = model_fit.forecast() yhat = output[0] predictions.append(yhat) obs = test[t] history.append(obs) print('predicted=%f, expected=%f' % (yhat, obs)) #RMSE = np.sqrt(mean_squared_error(test, predictions)) test = np.array(test) predictions = np.array(predictions).reshape(-1) MAE = eval.calcMAE(test, predictions) RMSE = eval.calcRMSE(test, predictions) MAPE = eval.calcMAPE(test, predictions) print('Test MAE: %.8f' % MAE) print('Test RMSE: %.8f' % RMSE) print('Test MAPE: %.8f' % MAPE) # plot pyplot.plot(test) pyplot.plot(predictions, color='red') pyplot.show()
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
# 分别获得训练集测试集结果 trainPred = trTrain+resTrain+seasonal[trendWin:trendWin+trTrain.shape[0]] testPred = trTest+resTest+seasonal[2*resWin+resTrain.shape[0]:] # 获得ground-truth数据 data = dataset[2:-2] trainY = data[trendWin:trendWin+trTrain.shape[0]] testY = data[2*resWin+resTrain.shape[0]:] # 评估指标 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) plt.plot(data,'r') plt.plot(finalPred,'g') plt.show() #'''
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
def train_single_model(lr_, net_name, origin_data, filename, data_order, Select_num, batch_size, num_epochs, l_forward, l_back, n, train_count, parapath): ''' ######################### ##### load data ##### ######################### ''' split_rate = 1 / 2 T0_train,T1_train,T2_train, \ Forw_train,Pred_train,\ T0_test,T1_test,T2_test,\ Forw_test,Pred_test = load_data(filename =filename ,split_rate = split_rate,train_count =train_count, data_order = data_order,city_path =origin_data,store_seg ="data/seg", week_num = 24,store_path = "data/train",select_num =Select_num,step =4, T = 24 ,n = n,l_back = l_back,m =1,l_forward =l_forward ) # tr_f_dataset = forw_Data(Forw_train, Pred_train) tr_f_dataloader = torch.utils.data.DataLoader(tr_f_dataset, batch_size=batch_size, shuffle=False, sampler=None, batch_sampler=None, num_workers=0) #%% ''' ##################### # model ##################### ''' if net_name == 'short_LSTM': net1 = short_LSTM(input_dim=l_forward, hidden_dim=2, num_layers=1, batch_size=batch_size).cuda() elif net_name == 'BiLSTM': net1 = BiLSTM(input_dim=l_forward, hidden_dim=2, num_layers=1, batch_size=batch_size).cuda() elif net_name == 'conv_LSTM': net1 = conv_LSTM(input_dim=20, hidden_dim=2, num_layers=1, batch_size=batch_size).cuda() elif net_name == 'conv_BiLSTM': net1 = conv_BiLSTM(input_dim=20, hidden_dim=2, num_layers=1, batch_size=batch_size).cuda() # elif net_name == 'LSTM_with_Attention': # net1 = LSTM_with_Attention(input_dim =l_forward, hidden_dim=2, num_layers =1,batch_size= batch_size).cuda() # elif net_name == 'MLP': # net1 = MLP(input_dim = l_forward,common_dim =2).cuda() loss_MSE = torch.nn.MSELoss(size_average=False) loss_MAPE = calcMAPE() optimizer1 = torch.optim.Adam(list(net1.parameters()), lr=lr_) #%% ##################### # Train model ##################### t1 = time.time() net1.train() list_train = [] num = [] for i in range(num_epochs): count = 0 # t3 = time.time() train_loss = 0 for data in (tr_f_dataloader): x = data[0] y = data[1].view(-1, 1, l_back) count += 1 x, y = x.cuda(), y.cuda() result = [] for j in range(l_back): # insert predicted value into window data x0, g_truth = x.view(batch_size, -1, 1).cuda(), (y[:, :, j]).cuda() if j == 0: x_f = x0 else: x_f = torch.cat([x_f, pred_f], dim=2) if len(x_f[0][0]) > l_forward: x_mid = x_f x_f = x_mid[:, :, 1:len(x_f[0][0])] x_f = (torch.tensor(x_f, dtype=torch.float64).cuda()).view( -1, 1, l_forward) #forward preds_f = net1(x_f.cuda()) pred_f = (torch.tensor(preds_f, dtype=torch.float64).cuda()).view( batch_size, -1, 1) #calculate loss g_truth = g_truth.float() loss = loss_MAPE(g_truth, preds_f) #loss = loss_MSE(preds_f,g_truth) optimizer1.zero_grad() #backward loss.backward() #update parameters optimizer1.step() result.append(preds_f) r = torch.cat([s for s in result], 1) train_loss = train_loss + loss_MAPE(y.view(-1, l_back), r.view(-1, l_back)) # t4 = time.time() print("epoch:%i" % i, "loss:", train_loss / num_epochs) list_train.append(train_loss / num_epochs) # print("training time:",t4-t3) num.append(i) df = pd.DataFrame({"num": num, "train_MAPE": list_train}) df.to_csv(parapath + "train_MAPE" + ".csv", index=False, sep=',') torch.save(net1.state_dict(), parapath + '%s.pkl' % "net1") t2 = time.time() print("training time:", t2 - t1)
def seasonRNNForecasting(ts, dataset, freq, lag, unit="GRU"): # 序列分解 #ts.index = pd.date_range(start='19960318',periods=len(ts), freq='Q') trend, seasonal, residual = season_decompose.seasonDecompose(ts, freq) print(trend.shape) print(seasonal.shape) print(residual.shape) # 分别预测 trendWin = lag resWin = trendWin t1 = time.time() trTrain, trTest, MAE1, MRSE1, SMAPE1 = RNNFORECAST.RNNforecasting( trend, lookBack=trendWin, epoch=50, unit=unit) resTrain, resTest, MAE2, MRSE2, SMAPE2 = RNNFORECAST.RNNforecasting( residual, lookBack=resWin, epoch=60, unit=unit, hiddenNum=100) # trTrain, trTest, MAE1, MRSE1, SMAPE1= RNNFORECAST.RNNforecasting(trend, lookBack=resWin, epoch=30, unit=unit, # varFlag=True, minLen=20, maxLen=lag, step=4, # hiddenNum=100) # resTrain, resTest, MAE2, MRSE2, SMAPE2 = RNNFORECAST.RNNforecasting(residual, lookBack=resWin, epoch=30, unit=unit, # varFlag=True, minLen=20, maxLen=lag, step=4, hiddenNum=100) t2 = time.time() print(t2 - t1) print("trTrain shape is", trTrain.shape) print("resTrain shape is", resTrain.shape) #''' # 数据对齐 trendPred, resPred = util.align(trTrain, trTest, trendWin, resTrain, resTest, resWin) print("trendPred shape is", trendPred.shape) print("resPred shape is", resPred.shape) # 获取最终预测结果 finalPred = trendPred + seasonal + resPred trainPred = trTrain + seasonal[trendWin:trendWin + trTrain.shape[0]] + resTrain testPred = trTest + seasonal[2 * resWin + resTrain.shape[0]:] + resTest # 获得ground-truth数据 data = dataset[freq // 2:-(freq // 2)] trainY = data[trendWin:trendWin + trTrain.shape[0]] testY = data[2 * resWin + resTrain.shape[0]:] # 评估指标 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 SMAPE", SMAPE) # plt.plot(data) # plt.plot(finalPred) # plt.show() #''' return trainPred, testPred, MAE, MRSE, SMAPE
def test_single_model(net_name, origin_data, filename, data_order, Select_num, batch_size, l_forward, l_back, n, train_count, parapath, forepath): ######################### ##### load data ######################### T0_train,T1_train,T2_train, \ Forw_train,Pred_train,\ T0_test,T1_test,T2_test,\ Forw_test,Pred_test = load_data(filename =filename ,split_rate = 1/2,train_count =train_count, data_order = data_order,city_path =origin_data,store_seg ="data/seg", week_num = 24,store_path = "data/train",select_num =Select_num,step =4, T = 24 ,n = n,l_back = l_back,m =1,l_forward =l_forward ) te_f_dataset = forw_Data(Forw_test, Pred_test) te_f_dataloader = torch.utils.data.DataLoader(te_f_dataset, batch_size=batch_size, shuffle=False, sampler=None, batch_sampler=None, num_workers=0) #%% ##################### # model ##################### if net_name == 'short_LSTM': net1 = short_LSTM(input_dim=l_forward, hidden_dim=2, num_layers=1, batch_size=batch_size).cuda() elif net_name == 'BiLSTM': net1 = BiLSTM(input_dim=l_forward, hidden_dim=2, num_layers=1, batch_size=batch_size).cuda() elif net_name == 'conv_LSTM': net1 = conv_LSTM(input_dim=20, hidden_dim=2, num_layers=1, batch_size=batch_size).cuda() elif net_name == 'conv_BiLSTM': net1 = conv_BiLSTM(input_dim=20, hidden_dim=2, num_layers=1, batch_size=batch_size).cuda() # elif net_name == 'LSTM_with_Attention': # net1 = LSTM_with_Attention(input_dim =l_forward, hidden_dim=2, num_layers =1,batch_size= batch_size).cuda() # elif net_name == 'conv_LSTM_with_Attention': # net1 = conv_LSTM_with_Attention(input_dim =20, hidden_dim=2, num_layers =1,batch_size= batch_size).cuda() # loss_MAPE = calcMAPE() net1.load_state_dict( torch.load(parapath + '%s.pkl' % "net1", map_location=torch.device('cuda:0'))) net1.eval() #%% ##################### # test model ##################### t3 = time.time() count_fore = 0 result = [] num = [] for data in te_f_dataloader: x = data[0].view(-1, 1, l_forward) y = data[1].view(-1, 1, l_back) count_fore += 1 x, y = x.to(device), y.to(device) result1 = [] for j in range(l_back): #insert predicted value into window data x0, g_truth = x.view(batch_size, -1, 1).cuda(), (y[:, :, j]).cuda() if j == 0: x_f = x0 else: x_f = torch.cat([x_f, pred_f], dim=2) if len(x_f[0][0]) > l_forward: x_mid = x_f x_f = x_mid[:, :, 1:len(x_f[0][0])] x_f = (torch.tensor(x_f, dtype=torch.float64).cuda()).view( -1, 1, l_forward) preds_f = net1(x_f) pred_f = (torch.tensor(preds_f, dtype=torch.float64).cuda()).view( batch_size, -1, 1) #build predicted sequence result1.append(preds_f) r = torch.cat([s for s in result1], 1) #calculate MAPE of predicting setting loss = loss_MAPE(y.view(-1, l_back), r.view(-1, l_back)) # plt.title("%f"%loss+"%") # plt.plot((pd.Series(np.array(list(r.view(l_back,-1))).T)), label="Pred") # plt.plot(pd.Series(np.array(list(y.view(l_back,-1))).T), label="Data") # plt.legend() # plt.savefig(forepath+"/%i.png"%count_fore) # plt.show() #print("Hybrid:","data_order:%i"%count_fore,loss,"%") num.append(count_fore) result.append(loss) num.append("average") result.append(torch.mean(torch.tensor(result))) loss_mean = torch.mean(torch.tensor(result)) t4 = time.time() print(" mean loss |test time (s)") print("%s|%s" % (loss_mean, t4 - t3)) dataframe = pd.DataFrame({'num': num, 'loss': result}) dataframe.to_csv(forepath + "/forecast" + ".csv", index=False, sep=',') # return average MAPE return loss_mean
def test_DMNNM(net_name,loss_type,origin_data,filename,data_order,Select_num,batch_size,l_forward,l_back, n,train_count,parapath,forepath): ##################### # load data ##################### T0_train,T1_train,T2_train, \ Forw_train,Pred_train,\ T0_test,T1_test,T2_test,\ Forw_test,Pred_test = load_data(filename =filename ,split_rate = 1/2,train_count =train_count, data_order = data_order,city_path =origin_data,store_seg ="data/seg", week_num = 24,store_path = "data/train",select_num =Select_num,step =4, T = 24 ,n = n,l_back = l_back,m =1,l_forward =l_forward ) te_f_dataset = forw_Data(Forw_test, Pred_test) te_f_dataloader = torch.utils.data.DataLoader(te_f_dataset, batch_size=batch_size, shuffle=False, sampler=None, batch_sampler=None, num_workers=0) te_p_dataset = period_Data(T0_test,T1_test,T2_test) te_p_dataloader = torch.utils.data.DataLoader(te_p_dataset, batch_size=batch_size, shuffle=False, sampler=None, batch_sampler=None, num_workers=0) #%% ##################### #network selection in predition module ##################### if net_name == 'short_LSTM': net1 = short_LSTM(input_dim =l_forward, hidden_dim=2, num_layers =1,batch_size= batch_size).cuda() elif net_name == 'conv_LSTM': net1 = conv_LSTM(input_dim =20, hidden_dim=2, num_layers =1,batch_size= batch_size).cuda() elif net_name == 'BiLSTM': net1 = BiLSTM(input_dim =l_forward, hidden_dim=2, num_layers =1,batch_size= batch_size).cuda() elif net_name == 'conv_BiLSTM': net1 = conv_BiLSTM(input_dim =l_forward, hidden_dim=2, num_layers =1,batch_size= batch_size).cuda() # elif net_name == 'MLP': # net1 = MLP(input_dim = l_forward,common_dim =2).cuda() # elif net_name == 'LSTM_with_Attention': # net1 = LSTM_with_Attention(input_dim =l_forward, hidden_dim=2, num_layers =1,batch_size= batch_size).cuda() net2 = period_net(input_dim =n, hidden_dim=2, num_layers =1,batch_size= batch_size).cuda() net3 = metrix(in_dim = l_back,n_hidden_1 =2*l_back, n_hidden_2 =2*l_back, out_dim = l_back).cuda() loss_MAPE = calcMAPE() # load model net1.load_state_dict(torch.load(parapath+'%s.pkl'%"net1",map_location=torch.device('cuda:0'))) net2.load_state_dict(torch.load(parapath+'%s.pkl'%"net2",map_location=torch.device('cuda:0'))) net3.load_state_dict(torch.load(parapath+'%s.pkl'%"net3",map_location=torch.device('cuda:0'))) net1.eval() net2.eval() net3.eval() #%% ##################### # test model ##################### t3 = time.time() count_fore = 0 num = [] loss_result = [] #forecast all predictting sets for data1,data2 in (zip(te_f_dataloader,te_p_dataloader)): x = data1[0] y = data1[1].view(-1,1,l_back) t0 = data2[0].view(-1,n,l_back) t1 = data2[1].view(-1,n,l_back) t2 = data2[2].view(-1,n,l_back) x,y = x.cuda(),y.cuda() t0,t1,t2= t0.cuda(),t1.cuda(),t2.cuda() count_fore += 1 result = [] for j in range(l_back): # insert predicted value into window data x0,g_truth = x.view(-1,l_forward,1).cuda(),(y[:,:,j]).cuda() a,b,c, = t0[:,:,j].cuda(),t1[:,:,j].cuda(),t2[:,:,j].cuda() if j ==0: x_f = x0 else: x_f = torch.cat([x_f,pred_f],dim = 2) if len(x_f[0][0]) > l_forward : x_mid = x_f x_f = x_mid[:,:,1:len(x_f[0][0])] x_f = (torch.tensor(x_f,dtype =torch.float64).cuda()).view(-1,1,l_forward) #output of predition module and adjustment module: preds_f and preds_p #dynamic adjust single predicted value preds_p = net2(a,b,c) preds_f = net1(x_f.cuda()) pred_f = (torch.tensor(preds_f,dtype =torch.float64).cuda()).view(-1,1,1) preds_p = preds_p.view(-1,1,1) g_truth =g_truth.float() pred = torch.add(preds_f, preds_p) #build predicted sequence result.append(pred) #refitting predicted sequence result1 = torch.cat([s for s in result], 0) result1 = result1.view(1,-1) r= net3(result1) #calculate MAPE of forecast setting loss = loss_MAPE(y.view(-1,l_back),r.view(-1,l_back)) #draw figure # plt.title("%f"%loss+"%") # plt.plot((pd.Series(np.array(list(r.view(l_back,-1))).T)), label="Pred") # plt.plot((pd.Series(np.array(list(y.view(l_back,-1))).T)), label="Data") # plt.legend() # plt.savefig(forepath+"%i.png"%count_fore) # plt.show() #print("Hybrid:","data_order:%i"%count_fore,loss,"%") num.append(count_fore) loss_result.append(loss) num.append("average") loss_mean = torch.mean(torch.tensor(result)) loss_result.append(loss_mean) t4 = time.time() print(" mean loss |test time (s)") print("%s|%s"%(loss_mean,t4-t3)) dataframe = pd.DataFrame({'num':num,'loss':loss_result}) dataframe.to_csv(forepath+"/forecast"+".csv",index=False,sep=',') # return average MAPE return loss_mean
def train_DMNNM(lr_,net_name,loss_type,origin_data,filename,data_order,num_epochs,Select_num,batch_size, l_forward,l_back,n,train_count,parapath): ''' ######################### ##### load data ##### ######################### ''' T0_train,T1_train,T2_train, \ Forw_train,Pred_train,\ T0_test,T1_test,T2_test,\ Forw_test,Pred_test = load_data(filename = filename,split_rate = 1/2,train_count =train_count,data_order=data_order, city_path =origin_data,store_seg ="data/seg", week_num = 24, store_path = "data/train",select_num =Select_num,step =4,T = 24 ,n = n, l_back = l_back,m =1,l_forward =l_forward ) tr_f_dataset = forw_Data(Forw_train, Pred_train) tr_f_dataloader = torch.utils.data.DataLoader(tr_f_dataset, batch_size=batch_size, shuffle=False, sampler=None, batch_sampler=None, num_workers=0) tr_p_dataset = period_Data(T0_train,T1_train,T2_train) tr_p_dataloader = torch.utils.data.DataLoader(tr_p_dataset, batch_size=batch_size, shuffle=False, sampler=None, batch_sampler=None, num_workers=0) #%% ##################### # model ##################### if net_name == 'short_LSTM': net1 = short_LSTM(input_dim =l_forward, hidden_dim=2, num_layers =1,batch_size= batch_size).cuda() elif net_name == 'conv_LSTM': net1 = conv_LSTM(input_dim =20, hidden_dim=2, num_layers =1,batch_size= batch_size).cuda() elif net_name == 'BiLSTM': net1 = BiLSTM(input_dim =l_forward, hidden_dim=2, num_layers =1,batch_size= batch_size).cuda() elif net_name == 'conv_BiLSTM': net1 = conv_BiLSTM(input_dim =l_forward, hidden_dim=2, num_layers =1,batch_size= batch_size).cuda() # elif net_name == 'LSTM_with_Attention': # net1 = LSTM_with_Attention(input_dim =l_forward, hidden_dim=2, num_layers =1,batch_size= batch_size).cuda() # elif net_name == 'MLP': # net1 = MLP(input_dim = l_forward,common_dim =2).cuda() net2 = period_net(input_dim =n, hidden_dim=2, num_layers =1,batch_size= batch_size).cuda() net3 = metrix(in_dim = l_back,n_hidden_1 =2*l_back, n_hidden_2 =2*l_back, out_dim = l_back).cuda() # Initialize train model loss_MSE = torch.nn.MSELoss(size_average=False) loss_MAPE = calcMAPE() loss_COS = calcCOSine() optimizer1 = torch.optim.Adam(list(net1.parameters()), lr=lr_) optimizer2 = torch.optim.Adam(list(net2.parameters()), lr=lr_) optimizer3 = torch.optim.Adam(list(net3.parameters()), lr=lr_) #%% ##################### # Train model ##################### t1 = time.time() net1.train() net2.train() net3.train() list_train = [] num = [] for i in range(num_epochs): count = 0 t3 = time.time() train_loss = 0 #train all training sets for data1,data2 in (zip(tr_f_dataloader,tr_p_dataloader)): x = data1[0] y = data1[1].view(-1,1,l_back) t0 = data2[0].view(batch_size,n,-1) t1 = data2[1].view(batch_size,n,-1) t2 = data2[2].view(batch_size,n,-1) count = count+ 1 x,y = x.cuda(),y.cuda() t0,t1,t2= t0.cuda(),t1.cuda(),t2.cuda() result = [] for j in range(l_back): # insert predicted value into window data x0,g_truth = x.view(batch_size,-1,1).cuda(),(y[:,:,j]).cuda() a,b,c, = t0[:,:,j].cuda(),t1[:,:,j].cuda(),t2[:,:,j].cuda() if j ==0: x_f = x0 else: x_f = torch.cat([(torch.tensor(x_f,dtype =torch.double)),(torch.tensor(preds_f,dtype =torch.double))],dim = 2) if len(x_f[0][0]) > l_forward : x_mid = x_f x_f = x_mid[:,:,1:len(x_f[0][0])] x_f = (torch.tensor(x_f,dtype =torch.float64).cuda()).view(-1,1,l_forward) #forward #output of predition module and adjustment module: preds_f and preds_p #dynamic adjust single predicted value preds_p = net2(a,b,c).view(-1,1,1) preds_f = net1(x_f.cuda()).view(-1,1,1) #adjust predicted value g_truth =g_truth.float() pred_ = torch.add(preds_f, preds_p) #calculate loss in single point predition phase loss1 = loss_MAPE(g_truth,pred_) #loss1 = loss_MSE(pred_.view(-1,1),g_truth.view(-1,1)) optimizer1.zero_grad() optimizer2.zero_grad() #backward loss1.backward(retain_graph=True) #update parameter optimizer1.step() optimizer2.step() result.append(pred_) result_ = torch.cat([s for s in result], 1) #refitting predicted sequence r = net3(result_.view(-1,l_back)) optimizer3.zero_grad() #choose hybrid loss function with different k if loss_type =="MAPE": loss = loss_MAPE(y.view(-1,l_back),r.view(-1,l_back)) #loss = loss_MSE(r.view(-1,l_back),y.view(-1,l_back)) elif loss_type =="k=0.5": loss = torch.add(loss_MAPE(y.view(-1,l_back),r.view(-1,l_back)),(-0.5)*loss_COS(y.view(-1,l_back),r.view(-1,l_back))) elif loss_type =="k=0.75": loss = torch.add(loss_MAPE(y.view(-1,l_back),r.view(-1,l_back)),(-0.75)*loss_COS(y.view(-1,l_back),r.view(-1,l_back))) elif loss_type =="k=1": loss = torch.add(loss_MAPE(y.view(-1,l_back),r.view(-1,l_back)),(-1)*loss_COS(y.view(-1,l_back),r.view(-1,l_back))) elif loss_type =="k=1.25": loss = torch.add(loss_MAPE(y.view(-1,l_back),r.view(-1,l_back)),(-1.25)*loss_COS(y.view(-1,l_back),r.view(-1,l_back))) elif loss_type =="k=1.5": loss = torch.add(loss_MAPE(y.view(-1,l_back),r.view(-1,l_back)),(-1.5)*loss_COS(y.view(-1,l_back),r.view(-1,l_back))) #backward loss.backward() #update parameter optimizer3.step() train_loss =train_loss + loss_MAPE(y.view(-1,l_back),r.view(-1,l_back)) log.info("Hybrid:","data_order:%i"%count,loss_MAPE(y.view(-1,l_back),r.view(-1,l_back))) log.info(train_loss/num_epochs) print("epoch:%i,"%i,"MAPE_loss",train_loss/num_epochs) list_train.append(train_loss/num_epochs) t4 = time.time() log.info("training time:",t4-t3) #print("training time:",t4-t3) num.append(i) dataframe = pd.DataFrame({"num":num,"train_MAPE":list_train}) dataframe.to_csv(parapath+"train_MAPE"+".csv",index=False,sep=',') torch.save(net1.state_dict(),parapath+'%s.pkl'%"net1") torch.save(net2.state_dict(),parapath+'%s.pkl'%"net2") torch.save(net3.state_dict(),parapath+'%s.pkl'%"net3") t2 = time.time() print("training time:",t2-t1) log.info("training time:",t2-t1)