Beispiel #1
0
def arima(maxlag=10):
    bic, p, q, model = select_arma_model(data_tf[:-test_num], maxlag=maxlag)
    pr = arma_pre(model.params[0], model.arparams, model.maparams,
                  data_tf[-maxlag - test_num:])[-test_num:]
    restore_value = restore_data(pr, data[-test_num - 1:-1])  # 还原预测值
    mape_, mae_, mse_, rmse_ = loss_function(restore_value, data[-test_num:])

    pre_data_tf_result = pd.DataFrame(pr,
                                      columns=['data_pre_value'])  # 变换数据的预测值
    real_result = pd.DataFrame(restore_value,
                               columns=['restore_value'])  # 预测重构值
    pre_data_tf_result.to_csv('../' + ada_result + '/' + name_data +
                              '/arima_data_tf_result.csv')
    real_result.to_csv('../' + ada_result + '/' + name_data +
                       '/arima_real_result.csv')

    result_evaluation = {
        'p': int(p),
        'q': int(q),
        'mape': mape_,
        'mae': mae_,
        'mse': mse_,
        'rmse': rmse_
    }
    fw = open(
        '../' + ada_result + '/' + name_data + '/arima_result_evaluation.json',
        'a')
    fw.write(json.dumps(result_evaluation) + '\n')
    fw.close()
Beispiel #2
0
def multi_emd_ann(lag=3, num_trial=20, hidden=128, epochs=20):

    pre_data_tf_result = pd.DataFrame()  # 百分比结果
    real_result = pd.DataFrame()  # 预测重构值
    time_ = []  # 时间
    mape, mae, mse, rmse = [], [], [], []
    for j in range(num_trial):
        pr = None
        start_time = time.time()
        for i in range(len(imfs)):
            d = seq_tf_matrix(imfs[i], n=lag+1)
            x = d[:, :-1]
            y = d[:, -1]
            if pr is None:  # 预测的值,子序列预测结果
                pr = ann(x, y, test_num=test_num, hidden=hidden, batch_size=batch_size, epochs=epochs)
            else:  # 预测的值,子序列结果直接相加
                pr = pr + ann(x, y, test_num=test_num, hidden=hidden, batch_size=batch_size, epochs=epochs)
        end_time = time.time()
        t = (end_time - start_time)
        restore_value = restore_data(pr, data[-test_num - 1:-1])  # 还原预测值
        mape_, mae_, mse_, rmse_ = loss_function(restore_value, data[-test_num:])

        pre_data_tf_result[str(j + 1) + '_times_lag' + str(lag)] = pr
        real_result[str(j + 1) + '_times_lag' + str(lag)] = restore_value

        time_.append(t / 60)  # 分钟
        mape.append(mape_)
        mae.append(mae_)
        mse.append(mse_)
        rmse.append(rmse_)
    # 预测结果
    pre_data_tf_result['test_percentage'] = data_tf[-test_num:]  # 把真实的需要预测的百分比值加入
    real_result['test_value'] = data[-test_num:]  # 把真实的需要预测的原值加入
    pre_data_tf_result.to_csv('../result/' + name_data + '/data_tf_result/lag_' + str(lag) + '_multi_emd_ann_data_tf_result.csv')
    real_result.to_csv('../result/' + name_data + '/real_result/lag_' + str(lag) + '_multi_emd_ann_real_result.csv')
    # 预测结果评价指标
    result_evaluation = {'lag': lag, 'num_sub_sequences': len(imfs), 'time': time_, 'mape': mape,
                         'mae': mae, 'mse': mse, 'rmse': rmse}

    fw = open('../result/' + name_data + '/multi_emd_ann_result_evaluation.json', 'a')
    fw.write(json.dumps(result_evaluation) + '\n')
    fw.close()


# arima(15)
# lag = [3, 4, 5, 6, 7, 8, 9]
# for lag in lag:
#     only_ann(lag, 2)
#     only_lstm(lag, 2)
#     single_emd_ann(lag, 2)
#     single_emd_lstm(lag, 2)
#     multi_emd_ann(lag, 2)
#     multi_emd_lstm(lag, 2)
# single_emd_lstm(3, 2, epochs=20)
# single_emd_lstm(3, 5, epochs=30)
# single_emd_ann(3, 1)
Beispiel #3
0
def only_lstm(lag=3, num_trial=20, hidden=128, epochs=20):
    x = seq_tf_matrix(data_tf, n=lag + 1)  # 转换序列成矩阵,n-1个滞后项,共n列
    x = x[:, :-1]
    x = np.reshape(x, (x.shape[0], x.shape[1], 1))  # 转化成输入格式
    y = x[:, -1]

    pre_data_tf_result = pd.DataFrame()  # 变换数据预测结果
    real_result = pd.DataFrame()  # 变换数据预测结果重构值
    time_ = []  # 时间
    mape, mae, mse, rmse = [], [], [], []

    for i in range(num_trial):
        start_time = time.time()
        pr = lstm(x,
                  y,
                  test_num=test_num,
                  batch_size=batch_size,
                  epochs=epochs,
                  hidden=hidden)
        end_time = time.time()
        restore_value = restore_data(pr, data[-test_num - 1:-1])  # 还原预测值
        mape_, mae_, mse_, rmse_ = loss_function(restore_value,
                                                 data[-test_num:])
        pre_data_tf_result[str(i + 1) + '_times_lag' + str(lag)] = pr
        real_result[str(i + 1) + '_times_lag' + str(lag)] = restore_value
        # 保存第i次的评估指标
        time_.append((end_time - start_time) / 60)  # 分钟
        mape.append(mape_)
        mae.append(mae_)
        mse.append(mse_)
        rmse.append(rmse_)
        # 预测结果
    pre_data_tf_result['test_percentage'] = data_tf[
        -test_num:]  # 把真实的需要预测的百分比值加入
    real_result['test_value'] = data[-test_num:]  # 把真实的需要预测的原值加入
    pre_data_tf_result.to_csv('../' + ada_result + '/' + name_data +
                              '/data_tf_result/lag_' + str(lag) +
                              '_only_lstm_data_tf_result.csv')
    real_result.to_csv('../' + ada_result + '/' + name_data +
                       '/real_result/lag_' + str(lag) +
                       '_only_lstm_real_result.csv')
    # 预测结果评价指标
    result_evaluation = {
        'lag': lag,
        'time': time_,
        'mape': mape,
        'mae': mae,
        'mse': mse,
        'rmse': rmse
    }

    fw = open(
        '../' + ada_result + '/' + name_data +
        '/only_lstm_result_evaluation.json', 'a')
    fw.write(json.dumps(result_evaluation) + '\n')
    fw.close()
Beispiel #4
0
def single_emd_ann(lag=3, num_trial=20,  hidden=256, epochs=20):

    x = seq_tf_matrix(imfs.T, n=lag+1)  # 转换序列成矩阵,n-1个滞后项,共n列
    x = x[:, :-1, :]
    x = np.reshape(x, (x.shape[0], x.shape[1]*x.shape[2]))
    y = data_tf[-len(x):]

    pre_data_tf_result = pd.DataFrame()  # 百分比结果
    real_result = pd.DataFrame()  # 预测重构值
    time_ = []  # 时间
    mape, mae, mse, rmse = [], [], [], []
    for i in range(num_trial):
        start_time = time.time()
        pr = ann(x, y, test_num=test_num, hidden=hidden, batch_size=batch_size, epochs=epochs)  # 预测的值
        end_time = time.time()
        restore_value = restore_data(pr, data[-test_num - 1:-1])  # 还原预测值
        mape_, mae_, mse_, rmse_ = loss_function(restore_value, data[-test_num:])
        # 保存第i次的结果
        pre_data_tf_result[str(i+1)+'_times_lag'+str(lag)] = pr
        real_result[str(i+1)+'_times_lag'+str(lag)] = restore_value
        # 保存第i次的评估指标
        time_.append((end_time - start_time) / 60)  # 分钟
        mape.append(mape_)
        mae.append(mae_)
        mse.append(mse_)
        rmse.append(rmse_)
    # 预测结果
    pre_data_tf_result['test_percentage'] = data_tf[-test_num:]  # 把真实的需要预测的百分比值加入
    real_result['test_value'] = data[-test_num:]  # 把真实的需要预测的原值加入
    pre_data_tf_result.to_csv('../result/'+name_data+'/data_tf_result/lag_'+str(lag)+'_single_emd_ann_data_tf_result.csv')
    real_result.to_csv('../result/'+name_data+'/real_result/lag_'+str(lag)+'_single_emd_ann_real_result.csv')
    # 预测结果评价指标
    result_evaluation = {'lag': lag, 'num_sub_sequences': len(imfs), 'time': time_, 'mape': mape,
                         'mae': mae, 'mse': mse, 'rmse': rmse}

    fw = open('../result/'+name_data+'/single_emd_ann_result_evaluation.json', 'a')
    fw.write(json.dumps(result_evaluation) + '\n')
    fw.close()
Beispiel #5
0
def multi_emd_aann(lag=3, num_trial=2, hidden=128, epochs=20, ignore=ignore):
    pre_data_tf_result = pd.DataFrame()  # 百分比结果
    real_result = pd.DataFrame()  # 预测重构值
    time_ = []  # 时间
    mape, mae, mse, rmse = [], [], [], []
    for j in range(num_trial):
        result = []
        start_time = time.time()
        # 100(test_num)个测试样本
        for k in range(test_num):
            decomposer = EMD(data_tf[:-test_num + k])  # 最后一项不参与分解
            imfs = decomposer.decompose()  # 包括m个imf和一个res项
            pr = None
            for i in range(len(imfs)):
                d = seq_tf_matrix(np.hstack((imfs[i], [0])),
                                  n=lag + 1)  # 给imfs[i]加上一个值作为最后一项的真实值,只占个位子
                x = d[:, :-1]
                if ignore:
                    x = x[:, :-ignore]  # 忽略与预测值最近的ignore项
                y = d[:, -1]
                if pr is None:
                    pr = ann(x,
                             y,
                             test_num=1,
                             batch_size=batch_size,
                             hidden=hidden,
                             epochs=epochs)  # 预测的值,子序列预测结果
                else:
                    pr = pr + ann(x,
                                  y,
                                  test_num=1,
                                  batch_size=batch_size,
                                  hidden=hidden,
                                  epochs=epochs)  # 预测的值,子序列结果直接相加
            result.append(pr[0])
        end_time = time.time()
        pr = np.array(result)
        restore_value = restore_data(pr, data[-test_num - 1:-1])  # 还原预测值
        mape_, mae_, mse_, rmse_ = loss_function(restore_value,
                                                 data[-test_num:])
        # 保存第i次的结果
        pre_data_tf_result[str(j + 1) + '_times_lag' + str(lag)] = pr
        real_result[str(j + 1) + '_times_lag' + str(lag)] = restore_value
        # 保存第i次的评估指标
        time_.append((end_time - start_time) / 60)  # 分钟
        mape.append(mape_)
        mae.append(mae_)
        mse.append(mse_)
        rmse.append(rmse_)
        # 预测结果
    pre_data_tf_result['test_percentage'] = data_tf[
        -test_num:]  # 把真实的,需要预测的百分比值加入
    real_result['test_value'] = data[-test_num:]  # 把真实的需要预测的原值加入
    pre_data_tf_result.to_csv('../' + ada_result + '/' + name_data +
                              '/data_tf_result/lag_' + str(lag) +
                              '_multi_emd_aann_data_tf_result.csv')
    real_result.to_csv('../' + ada_result + '/' + name_data +
                       '/real_result/lag_' + str(lag) +
                       '_multi_emd_aann_real_result.csv')
    # 预测结果评价指标
    result_evaluation = {
        'lag': lag,
        'time': time_,
        'mape': mape,
        'mae': mae,
        'mse': mse,
        'rmse': rmse
    }

    fw = open(
        '../' + ada_result + '/' + name_data +
        '/multi_emd_aann_result_evaluation.json', 'a')
    fw.write(json.dumps(result_evaluation) + '\n')
    fw.close()
Beispiel #6
0
def single_emd_aann(lag=3, num_trial=2, hidden=256, epochs=20, ignore=ignore):
    pre_data_tf_result = pd.DataFrame()  # 百分比结果
    real_result = pd.DataFrame()  # 预测重构值
    time_ = []  # 时间
    mape, mae, mse, rmse = [], [], [], []
    for i in range(num_trial):
        result = []
        start_time = time.time()
        # 100(test_num)个测试样本
        for j in range(test_num):
            if j == (test_num - 1):
                x, y = get_data(data_tf)
            else:
                x, y = get_data(data_tf[:-test_num + 1 + j])
            if ignore:
                x = x[:, :-ignore, :]  # 忽略与预测值最近的ignore项
            x = np.reshape(x, (x.shape[0], x.shape[1] * x.shape[2]))
            pre = ann(x,
                      y,
                      1,
                      hidden=hidden,
                      batch_size=batch_size,
                      epochs=epochs)
            result.append(pre[0])
        end_time = time.time()
        pr = np.array(result)
        restore_value = restore_data(pr, data[-test_num - 1:-1])  # 还原预测值
        mape_, mae_, mse_, rmse_ = loss_function(restore_value,
                                                 data[-test_num:])
        # 保存第i次的结果
        pre_data_tf_result[str(i + 1) + '_times_lag' + str(lag)] = pr
        real_result[str(i + 1) + '_times_lag' + str(lag)] = restore_value
        # 保存第i次的评估指标
        time_.append((end_time - start_time) / 60)  # 分钟
        mape.append(mape_)
        mae.append(mae_)
        mse.append(mse_)
        rmse.append(rmse_)
        # 预测结果
    pre_data_tf_result['test_percentage'] = data_tf[
        -test_num:]  # 把真实的,需要预测的百分比值加入
    real_result['test_value'] = data[-test_num:]  # 把真实的需要预测的原值加入
    pre_data_tf_result.to_csv('../' + ada_result + '/' + name_data +
                              '/data_tf_result/lag_' + str(lag) +
                              '_single_emd_aann_data_tf_result.csv')
    real_result.to_csv('../' + ada_result + '/' + name_data +
                       '/real_result/lag_' + str(lag) +
                       '_single_emd_aann_real_result.csv')
    # 预测结果评价指标
    result_evaluation = {
        'lag': lag,
        'time': time_,
        'mape': mape,
        'mae': mae,
        'mse': mse,
        'rmse': rmse
    }

    fw = open(
        '../' + ada_result + '/' + name_data +
        '/single_emd_aann_result_evaluation.json', 'a')
    fw.write(json.dumps(result_evaluation) + '\n')
    fw.close()