Datawhale AI 夏令营(2024.07.20机器学习)

时间序列预测特征提取和分析方法

在进行时间序列分析时，特征提取是一个至关重要的步骤，因为它直接影响到模型的性能。以下是关键特征提取和分析方式的详细介绍：

1. 日期变量：时间序列数据通常包含日期或时间信息。这可以细分为不同的时间尺度，如年、月、周、日、小时、分钟等。在特征提取时，可以将这些日期变量转换为数值型特征，以便于模型处理。

2. 周期性：许多时间序列数据表现出周期性，例如，一天中的小时数、一周中的天数、一年中的月份等。识别并利用这些周期性特征可以帮助模型捕捉数据的内在规律。

3. 趋势性：趋势性是指时间序列数据随时间推移呈现的上升或下降的总体模式。这可以通过诸如移动平均或线性回归等方法来提取，并作为特征输入模型。

4. 距离某天的时间差：这涉及到从特定日期（如产品发布日、重要事件日等）计算时间差。这种特征可以帮助模型了解数据点与特定事件的相对位置。

5. 时间特征组合：将不同的时间单位组合起来（如年和周、月和日）可以提供更丰富的时间上下文信息，有助于揭示数据中的复杂模式。

6. 特殊日期：识别时间序列中的特殊日期或事件（如节假日、促销活动等）并将其作为特征，可以帮助模型解释与这些事件相关的数据波动。

7. 异常点：时间序列中可能存在异常点，这些点与其他数据点显著不同。正确识别并处理这些异常点对于提高预测精度至关重要。

8. 时序相关特征：

   1. 历史平移：将过去的值作为当前值的函数，例如，使用前一天的值来预测后一天的值。

   2. 滑窗统计：使用时间窗口内的统计数据（如平均值、中位数、标准差等）作为特征，这有助于捕捉局部时间范围内的数据特性。

9. 强相关特征：识别与目标变量强烈相关的特征，并利用这些特征来构建预测模型。

这张图片提供了一系列关于时间序列预测中构建关键特征的要点，包括强相关性特征、趋势性特征、周期性特征和异常点特征。以下是对这些特征的详细介绍：

1. 强相关性特征：

   1. 强相关性特征是指与目标变量有明显线性或非线性关系的输入特征。在时间序列中，这些特征可能包括：

      • 滞后特征：使用过去的值作为当前预测的特征，例如，使用前一天的销售数据来预测后一天的销售。

      • 滚动统计特征：计算时间序列的滚动窗口内的统计量，如平均值、最大值、最小值、总和等。

2. 趋势性特征：

   1. 趋势性特征反映了时间序列随时间推移的长期变化方向或速率。

   2. 构建趋势性特征的方法包括：

      • 时间戳转换：将时间戳转换为数值，如从时间戳中提取年份、月份、星期等。

      • 移动平均：使用时间序列的移动平均值来平滑短期波动，突出长期趋势。

      • 多项式拟合：拟合一个多项式模型来捕捉趋势。

3. 周期性特征：

   1. 周期性特征反映了时间序列数据在固定时间间隔内重复出现的模式。

   2. 构建周期性特征的方法包括：

      • 时间戳的周期性转换：将时间戳转换为周期性变量，如一周中的星期几、一月中的日子等。

      • 季节性分解：使用季节性分解方法来识别和提取时间序列的季节性成分。

      • 周期性函数：使用正弦和余弦函数来模拟周期性变化。

4. 异常点特征：

   1. 异常点是指与正常数据模式显著不同的数据点，它们可能由错误、突变或特殊事件引起。

   2. 处理异常点的方法包括：

      • 简单标注：在数据集中标记异常点，以便在分析时考虑。

      • 剔除：从数据集中删除异常点，特别是在它们可能影响模型训练的情况下。

      • 修正：更正异常点，如果它们是由于可识别的错误造成的。

5. 特殊事件特征：

   1. 特殊事件如“双十一”、“618”、“春节”等，会在时间序列中产生显著的峰值。

   2. 构建特殊事件特征的方法包括：

      • 事件指示器：创建一个二进制特征，当时间序列中的点与特殊事件对应时，该特征值为1，否则为0。

      • 事件前后的时间窗口：考虑事件前后的时间窗口，以捕捉事件的影响。

6. 上下时段信息：

   1. 上下时段信息指的是在时间序列中，特定时间段之前或之后的数据点。

   2. 这可以通过创建特征来表示数据点与特定时间段的距离来实现。

7. 存在峰值与峰值距离：

   1. 识别时间序列中的峰值点，并计算其他数据点与这些峰值点的距离，可以作为特征输入模型。

8. 时间尺度特征：

   1. 根据需要预测的时间尺度（如1天、3天、5天等），创建相应的滞后特征和滚动统计特征。

通过结合这些特征，可以构建一个强大的时间序列预测模型。在实际应用中，需要根据具体问题和数据特性来选择和调整特征工程的策略。此外，特征的选择和构建应该与模型的选择和调优过程相结合，以实现最佳的预测性能。

优化方案详解

在提分实践部分，将在原有Baseline基础上做更多优化，一般优化思路，从特征工程与模型中来思考。

优化方法建议：

1. 提取更多特征：在数据挖掘比赛中，特征总是最终制胜法宝，去思考什么信息可以帮助我们提高预测精准度，然后将其转化为特征输入到模型。

2. 尝试不同的模型：模型间存在很大的差异，预测结果也会不一样，比赛的过程就是不断的实验和试错的过程，通过不断的实验寻找最佳模型，同时帮助自身加强模型的理解能力。

特征优化

这里主要构建了历史平移特征、差分特征、和窗口统计特征；每种特征都是有理可据的，具体说明如下：

（1）历史平移特征：通过历史平移获取上个阶段的信息；

（2）差分特征：可以帮助获取相邻阶段的增长差异，描述数据的涨减变化情况。在此基础上还可以构建相邻数据比值变化、二阶差分等；

（3）窗口统计特征：窗口统计可以构建不同的窗口大小，然后基于窗口范围进统计均值、最大值、最小值、中位数、方差的信息，可以反映最近阶段数据的变化情况。

参考代码如下：

# 合并训练数据和测试数据
data = pd.concat([train, test], axis=0).reset_index(drop=True)
data = data.sort_values(['id','dt'], ascending=False).reset_index(drop=True)

# 历史平移
for i in range(10,36):
    data[f'target_shift{i}'] = data.groupby('id')['target'].shift(i)

# 历史平移 + 差分特征
for i in range(1,4):
    data[f'target_shift10_diff{i}'] = data.groupby('id')['target_shift10'].diff(i)
    
# 窗口统计
for win in [15,30,50,70]:
    data[f'target_win{win}_mean'] = data.groupby('id')['target'].rolling(window=win, min_periods=3, closed='left').mean().values
    data[f'target_win{win}_max'] = data.groupby('id')['target'].rolling(window=win, min_periods=3, closed='left').max().values
    data[f'target_win{win}_min'] = data.groupby('id')['target'].rolling(window=win, min_periods=3, closed='left').min().values
    data[f'target_win{win}_std'] = data.groupby('id')['target'].rolling(window=win, min_periods=3, closed='left').std().values

# 历史平移 + 窗口统计
for win in [7,14,28,35,50,70]:
    data[f'target_shift10_win{win}_mean'] = data.groupby('id')['target_shift10'].rolling(window=win, min_periods=3, closed='left').mean().values
    data[f'target_shift10_win{win}_max'] = data.groupby('id')['target_shift10'].rolling(window=win, min_periods=3, closed='left').max().values
    data[f'target_shift10_win{win}_min'] = data.groupby('id')['target_shift10'].rolling(window=win, min_periods=3, closed='left').min().values
    data[f'target_shift10_win{win}_sum'] = data.groupby('id')['target_shift10'].rolling(window=win, min_periods=3, closed='left').sum().values
    data[f'target_shift710win{win}_std'] = data.groupby('id')['target_shift10'].rolling(window=win, min_periods=3, closed='left').std().values

模型融合

进行模型融合的前提是有多个模型的输出结果，比如使用catboost、xgboost和lightgbm三个模型分别输出三个结果，这时就可以将三个结果进行融合，最常见的是将结果直接进行加权平均融合。

下面我们构建了cv_model函数，内部可以选择使用lightgbm、xgboost和catboost模型，可以依次跑完这三个模型，然后将三个模型的结果进行取平均进行融合。

对于每个模型均选择经典的K折交叉验证方法进行离线评估，大体流程如下：

1、K折交叉验证会把样本数据随机的分成K份；

2、每次随机的选择K-1份作为训练集，剩下的1份做验证集；

3、当这一轮完成后，重新随机选择K-1份来训练数据；

4、最后将K折预测结果取平均作为最终提交结果。

from sklearn.model_selection import StratifiedKFold, KFold, GroupKFold
import lightgbm as lgb
import xgboost as xgb
from catboost import CatBoostRegressor
from sklearn.metrics import mean_squared_error, mean_absolute_error
def cv_model(clf, train_x, train_y, test_x, clf_name, seed = 2024):
    '''
    clf：调用模型
    train_x：训练数据
    train_y：训练数据对应标签
    test_x：测试数据
    clf_name：选择使用模型名
    seed：随机种子
    '''
    folds = 5
    kf = KFold(n_splits=folds, shuffle=True, random_state=seed)
    oof = np.zeros(train_x.shape[0])
    test_predict = np.zeros(test_x.shape[0])
    cv_scores = []
    
    for i, (train_index, valid_index) in enumerate(kf.split(train_x, train_y)):
        print('************************************ {} ************************************'.format(str(i+1)))
        trn_x, trn_y, val_x, val_y = train_x.iloc[train_index], train_y[train_index], train_x.iloc[valid_index], train_y[valid_index]
        
        if clf_name == "lgb":
            train_matrix = clf.Dataset(trn_x, label=trn_y)
            valid_matrix = clf.Dataset(val_x, label=val_y)
            params = {
                'boosting_type': 'gbdt',
                'objective': 'regression',
                'metric': 'mae',
                'min_child_weight': 6,
                'num_leaves': 2 ** 6,
                'lambda_l2': 10,
                'feature_fraction': 0.8,
                'bagging_fraction': 0.8,
                'bagging_freq': 4,
                'learning_rate': 0.1,
                'seed': 2023,
                'nthread' : 16,
                'verbose' : -1,
            }
            model = clf.train(params, train_matrix, 1000, valid_sets=[train_matrix, valid_matrix],
                              categorical_feature=[])#, verbose_eval=200, early_stopping_rounds=100
            val_pred = model.predict(val_x, num_iteration=model.best_iteration)
            test_pred = model.predict(test_x, num_iteration=model.best_iteration)
        
        if clf_name == "xgb":
            xgb_params = {
              'booster': 'gbtree', 
              'objective': 'reg:squarederror',
              'eval_metric': 'mae',
              'max_depth': 5,
              'lambda': 10,
              'subsample': 0.7,
              'colsample_bytree': 0.7,
              'colsample_bylevel': 0.7,
              'eta': 0.1,
              'tree_method': 'hist',
              'seed': 520,
              'nthread': 16
              }
            train_matrix = clf.DMatrix(trn_x , label=trn_y)
            valid_matrix = clf.DMatrix(val_x , label=val_y)
            test_matrix = clf.DMatrix(test_x)
            
            watchlist = [(train_matrix, 'train'),(valid_matrix, 'eval')]
            
            model = clf.train(xgb_params, train_matrix, num_boost_round=1000, evals=watchlist, verbose_eval=200, early_stopping_rounds=100)
            val_pred  = model.predict(valid_matrix)
            test_pred = model.predict(test_matrix)
            
        if clf_name == "cat":
            params = {'learning_rate': 0.1, 'depth': 5, 'bootstrap_type':'Bernoulli','random_seed':2023,
                      'od_type': 'Iter', 'od_wait': 100, 'random_seed': 11, 'allow_writing_files': False}
            
            model = clf(iterations=1000, **params)
            model.fit(trn_x, trn_y, eval_set=(val_x, val_y),
                      metric_period=200,
                      use_best_model=True, 
                      cat_features=[],
                      verbose=1)
            
            val_pred  = model.predict(val_x)
            test_pred = model.predict(test_x)
        
        oof[valid_index] = val_pred
        test_predict += test_pred / kf.n_splits
        
        score = mean_absolute_error(val_y, val_pred)
        cv_scores.append(score)
        print(cv_scores)
        
    return oof, test_predict

# 选择lightgbm模型
lgb_oof, lgb_test = cv_model(lgb, train[train_cols], train['target'], test[train_cols], 'lgb')
# 选择xgboost模型
xgb_oof, xgb_test = cv_model(xgb, train[train_cols], train['target'], test[train_cols], 'xgb')
# 选择catboost模型
cat_oof, cat_test = cv_model(CatBoostRegressor, train[train_cols], train['target'], test[train_cols], 'cat')

# 进行取平均融合
final_test = (lgb_test + xgb_test + cat_test) / 3

 获得的结果：

另外一种就是stacking融合，stacking是一种分层模型集成框架。以两层为例，第一层由多个基学习器组成，其输入为原始训练集，第二层的模型则是以第一层基学习器的输出作为特征加入训练集进行再训练，从而得到完整的stacking模型。

第一层：（类比cv_model函数）

1. 划分训练数据为K折（5折为例，每次选择其中四份作为训练集，一份作为验证集）；

2. 针对各个模型RF、ET、GBDT、XGB，分别进行5次训练，每次训练保留一份样本用作训练时的验证，训练完成后分别对Validation set，Test set进行预测，对于Test set一个模型会对应5个预测结果，将这5个结果取平均；对于Validation set一个模型经过5次交叉验证后，所有验证集数据都含有一个标签。此步骤结束后：5个验证集（总数相当于训练集全部）在每个模型下分别有一个预测标签，每行数据共有4个标签（4个算法模型），测试集每行数据也拥有四个标签（4个模型分别预测得到的）

第二层：（类比stack_model函数）

1. 将训练集中的四个标签外加真实标签当作五列新的特征作为新的训练集，选取一个训练模型，根据新的训练集进行训练，然后应用测试集的四个标签组成的测试集进行预测作为最终的result。

Stacking参考代码：

def stack_model(oof_1, oof_2, oof_3, predictions_1, predictions_2, predictions_3, y):
    '''
    输入的oof_1, oof_2, oof_3可以对应lgb_oof，xgb_oof，cat_oof
    predictions_1, predictions_2, predictions_3对应lgb_test，xgb_test，cat_test
    '''
    train_stack = pd.concat([oof_1, oof_2, oof_3], axis=1)
    test_stack = pd.concat([predictions_1, predictions_2, predictions_3], axis=1)
    
    oof = np.zeros((train_stack.shape[0],))
    predictions = np.zeros((test_stack.shape[0],))
    scores = []
    
    from sklearn.model_selection import RepeatedKFold
    from sklearn.linear_model import Ridge
    folds = RepeatedKFold(n_splits=5, n_repeats=2, random_state=2021)
    
    for fold_, (trn_idx, val_idx) in enumerate(folds.split(train_stack, train_stack)): 
        print("fold n°{}".format(fold_+1))
        trn_data, trn_y = train_stack.loc[trn_idx], y[trn_idx]
        val_data, val_y = train_stack.loc[val_idx], y[val_idx]
        
        clf = Ridge(random_state=2021)
        clf.fit(trn_data, trn_y)

        oof[val_idx] = clf.predict(val_data)
        predictions += clf.predict(test_stack) / (5 * 2)
        
        score_single = mean_absolute_error(val_y, oof[val_idx])
        scores.append(score_single)
        print(f'{fold_+1}/{5}', score_single)
    print('mean: ',np.mean(scores))
   
    return oof, predictions
    
stack_oof, stack_pred = stack_model(pd.DataFrame(lgb_oof), pd.DataFrame(xgb_oof), pd.DataFrame(cat_oof), 
                                    pd.DataFrame(lgb_test), pd.DataFrame(xgb_test), pd.DataFrame(cat_test), train['target'])

获得的结果：

深度学习方案尝试

import numpy as np
import pandas as pd
from sklearn.preprocessing import MinMaxScaler
from keras.models import Sequential
from keras.layers import LSTM, Dense, RepeatVector, TimeDistributed
from keras.optimizers import Adam

train = pd.read_csv('../dataset/train.csv')
test = pd.read_csv('../dataset/test.csv')

# 数据预处理
def preprocess_data(df, look_back=100):
    # 将数据按照id进行分组
    grouped = df.groupby('id')
    datasets = {}
    for id, group in grouped:
        datasets[id] = group.values
        
    # 准备训练数据集
    X, Y = [], []
    for id, data in datasets.items():
        for i in range(10, 15): # 每个id构建5个序列
            a = data[i:(i + look_back), 3]
            a = np.append(a, np.array([0]*(100-len(a))))
            X.append(a[::-1])
            Y.append(data[i-10:i, 3][::-1])
    
    # 准备测试数据集
    OOT = []
    for id, data in datasets.items():
        a = data[:100, 3]
        a = np.append(a, np.array([0]*(100-len(a))))
        OOT.append(a[::-1])
    
    return np.array(X, dtype=np.float64), np.array(Y, dtype=np.float64), np.array(OOT, dtype=np.float64)

# 定义模型
def build_model(look_back, n_features, n_output):
    model = Sequential()
    model.add(LSTM(50, input_shape=(look_back, n_features)))
    model.add(RepeatVector(n_output))
    model.add(LSTM(50, return_sequences=True))
    model.add(TimeDistributed(Dense(1)))
    model.compile(loss='mean_squared_error', optimizer=Adam(0.001))
    return model

# 构建和训练模型
look_back = 100  # 序列长度
n_features = 1  # 假设每个时间点只有一个特征
n_output = 10  # 预测未来10个时间单位的值

# 预处理数据
X, Y, OOT = preprocess_data(train, look_back=look_back)

# 构建模型
model = build_model(look_back, n_features, n_output)

# 训练模型
model.fit(X, Y, epochs=10, batch_size=64, verbose=1)

# 进行预测
predicted_values = model.predict(OOT)

# 添加预测结果到测试数据集并保存到CSV文件
test_ids = test['id'].unique()
predicted_df = pd.DataFrame({
    'id': np.repeat(test_ids, n_output),
    'dt': np.tile(range(n_output), len(test_ids)),
    'target': predicted_values.flatten()
})
predicted_df.to_csv('../baseline/submit3.csv', index=None)

print(predicted_values)

获得的结果与分数：

以下是代码的详细解释：

1. 导入库：代码开始处导入了所需的库，包括数据处理库NumPy和Pandas，以及用于构建LSTM模型的Keras库。

2. 读取数据：使用Pandas的read_csv函数读取训练数据集train.csv和测试数据集test.csv。

3. 定义数据预处理函数：

   1. preprocess_data函数用于准备训练和测试数据。

   2. 数据按id列进行分组。

   3. 对于每个id，提取特定列（索引为3的列）的数据作为时间序列。

   4. 创建多个序列，每个序列长度为look_back，默认为100。

   5. 序列被反转，并且如果序列长度不足100，则用0填充。

   6. 训练数据集的标签Y是序列的一部分，同样进行反转。

   7. 测试数据集（OOT，Out-Of-Time）也被反转并用0填充以满足序列长度要求。

4. 定义模型构建函数：

   1. build_model函数用于构建LSTM模型。

   2. 模型包括一个LSTM层，用于学习时间序列数据的特征，以及一个重复向量层RepeatVector，用于复制上一个LSTM层的输出以供下一个LSTM层使用。

   3. 再次使用LSTM层和时间分布的密集层来预测序列的下一个值。

   4. 模型使用均方误差作为损失函数，并使用Adam优化器。

5. 构建和训练模型：

   1. 设置序列长度look_back、特征数n_features和输出时间单位数n_output。

   2. 调用preprocess_data函数预处理训练数据。

   3. 使用build_model函数构建模型。

   4. 使用模型的fit方法训练模型，指定迭代次数（epochs）和批量大小（batch_size）。

6. 进行预测：

   1. 使用训练好的模型对测试数据集进行预测。

   2. 这里需要注意注意自行将预测结果转化为提交格式

这里做了一些改进：

import numpy as np
import pandas as pd
from sklearn.preprocessing import MinMaxScaler
from keras.models import Sequential
from keras.layers import LSTM, Dense, RepeatVector, TimeDistributed, Dropout
from keras.optimizers import Adam
from tensorflow.python.keras.callbacks import EarlyStopping, ReduceLROnPlateau

train = pd.read_csv('../dataset/train.csv')
test = pd.read_csv('../dataset/test.csv')

# 数据预处理
def preprocess_data(df, look_back=100):
    # 将数据按照id进行分组
    grouped = df.groupby('id')
    datasets = {}
    for id, group in grouped:
        datasets[id] = group.values
        
    # 准备训练数据集
    X, Y = [], []
    for id, data in datasets.items():
        for i in range(10, 15): # 每个id构建5个序列
            a = data[i:(i + look_back), 3]
            a = np.append(a, np.array([0]*(100-len(a))))
            X.append(a[::-1])
            Y.append(data[i-10:i, 3][::-1])
    
    # 准备测试数据集
    OOT = []
    for id, data in datasets.items():
        a = data[:100, 3]
        a = np.append(a, np.array([0]*(100-len(a))))
        OOT.append(a[::-1])
    
    return np.array(X, dtype=np.float64), np.array(Y, dtype=np.float64), np.array(OOT, dtype=np.float64)

# 定义模型
def build_model(look_back, n_features, n_output):
    model = Sequential()
    model.add(LSTM(100, input_shape=(look_back, n_features), return_sequences=True))
    model.add(Dropout(0.3))
    model.add(LSTM(100, return_sequences=False))
    model.add(Dropout(0.3))
    model.add(RepeatVector(n_output))
    model.add(LSTM(100, return_sequences=True))
    model.add(Dropout(0.3))
    model.add(TimeDistributed(Dense(1)))
    model.compile(loss='mean_squared_error', optimizer=Adam(0.001))
    return model

# 构建和训练模型
look_back = 100  # 序列长度
n_features = 1  # 假设每个时间点只有一个特征
n_output = 10  # 预测未来10个时间单位的值

# 预处理数据
X, Y, OOT = preprocess_data(train, look_back=look_back)

# 构建模型
model = build_model(look_back, n_features, n_output)

# 训练模型
model.fit(X, Y, epochs=20, batch_size=64, verbose=1)

# 进行预测
predicted_values = model.predict(OOT)

# 添加预测结果到测试数据集并保存到CSV文件
test_ids = test['id'].unique()
predicted_df = pd.DataFrame({
    'id': np.repeat(test_ids, n_output),
    'dt': np.tile(range(n_output), len(test_ids)),
    'target': predicted_values.flatten()
})
predicted_df.to_csv('../baseline/submit4.csv', index=None)

print(predicted_values)

 

获得的结果与分数：

改进的措施：

1.增加了训练轮数；

2.在每个模型的全连接层之前加入丢弃法；

Dropout（丢弃法）作用：防止模型过拟合。

感想：效果依然不好，个人之前做图像分类实验的经历和此次实验的感想：选择深度学习的模型要依据自身可获取算力的大小、需要分析的数据集类型和模式和被选择模型的结构来综合判断，可能一个精密的模型并不适用于一些简单的数据集（容易造成过拟合等一些问题）。

总结

时间序列预测是一个不断发展的领域，随着技术的进步，我们可以期待更多的优化方法和模型的出现。深度学习模型，特别是LSTM和其变体，已经在许多时间序列预测任务中显示出了优越的性能。未来的研究可能会集中在以下几个方面：

• 更复杂的模型结构：如引入注意力机制的LSTM模型，以更好地捕捉时间序列中的长期依赖关系。

• 多模态数据融合：结合时间序列数据和其他类型的数据，如文本或图像，以提供更全面的分析。

• 模型解释性：提高模型的可解释性，以便更好地理解预测结果。

• 自动化特征工程：开发自动化的特征工程工具，以减少手动特征提取的工作量。

• 实时预测：提高模型在实时数据流上的预测能力。

• 模型鲁棒性：提高模型对异常值和噪声的鲁棒性。

随着技术的不断发展，我们可以期待时间序列预测在准确性、效率和应用范围上都会有显著的提升。