​​​​​​​

1. 导入需要用到的相关库

import pandas as pd

import numpy as np

pandas 是一个强大的数据分析库，它提供了快速、灵活和表达性强的数据结构，用于处理结构化数据（类似于Excel表格）。numpy 是一个Python库，用于进行科学计算。它提供了高性能的多维数组对象和一系列用于处理数组的工具。

2. 读取训练集和测试集

train = pd.read_csv('./data/data283931/train.csv')

test = pd.read_csv('./data/data283931/test.csv')

read_csv() 是 pandas 库中的一个函数，用于从CSV文件中读取数据并将其转换为DataFrame对象。DataFrame是 pandas 中的基本数据结构。在这两行代码中，您分别读取了名为 train.csv 和 test.csv 的文件，并将它们存储在 train 和 test 变量中。

3. 计算训练数据最近11-20单位时间内对应id的目标均值

target_mean = train[train['dt']<=20].groupby(['id'])['target'].mean().reset_index()

train[train['dt']<=20]：这是一个条件筛选，它选取了 train DataFrame中 dt 列小于或等于20的所有行。.groupby(['id'])：这是对数据进行分组的方法。在这里，您按照 id 列对数据进行分组。['target'].mean()：在分组之后，这个表达式计算每个组中 target 列的平均值。.reset_index()：这个方法将分组后的索引重置，将 id 从索引转换为列。

4. 将target_mean作为测试集结果进行合并

test = test.merge(target_mean, on=['id'], how='left')code>

merge() 是 pandas 中的函数，用于合并两个DataFrame。on=['id'] 指定了合并的键，即按照 id 列进行合并。how='left'code> 指定了合并的类型，在这里是左连接（left join），这意味着保留左侧DataFrame（这里是 test）的所有行，并根据 id 列将右侧DataFrame（这里是 target_mean）的值合并进来。如果左侧DataFrame中的某些 id 在右侧DataFrame中没有对应的值，则结果中这些 id 对应的 target 列将为NaN。

5. 保存结果文件到本地

test[['id','dt','target']].to_csv('submit.csv', index=None)

[['id','dt','target']]：这是一个列选择操作，它选取了 test DataFrame中的 id、dt 和 target 列。to_csv() 是 pandas 中的函数，用于将DataFrame保存为CSV文件。'submit.csv' 是输出文件的名称。index=None 表示在保存CSV文件时不包括DataFrame的索引列。

这段代码的总体目的是读取训练和测试数据集，计算训练集中每个 id 在最后11-20个时间单位的目标平均值，然后将这些平均值合并到测试集中，并保存结果。这是典型的数据预处理步骤，特别是在需要特征工程的情况下。

<code>specific_id_df = train[train['id'] == '00037f39cf']

plt.figure(figsize=(10, 5))

plt.plot(specific_id_df['dt'], specific_id_df['target'], marker='o', linestyle='-')code>

plt.xlabel('DateTime')

plt.ylabel('Target Value')

plt.title("Line Chart of Target for ID '00037f39cf'")

plt.show()

specific_id_df = train[train['id'] == '00037f39cf']:

从train DataFrame中选择所有行，其中id列的值为’00037f39cf’。结果是一个新的DataFrame，只包含特定ID的数据。plt.figure(figsize=(10, 5)): 创建一个新的图形，并设置图形的大小为宽10英寸、高5英寸。plt.plot(specific_id_df['dt'], specific_id_df['target'], marker='o', linestyle='-')code>:

绘制折线图，其中specific_id_df['dt']是x轴上的时间点，specific_id_df['target']是y轴上的目标值。marker='o'code>表示每个数据点都用圆圈标记。linestyle='-'code>表示数据点之间用实线连接。plt.xlabel('DateTime'): 设置x轴的标签为’DateTime’。plt.ylabel('Target Value'): 设置y轴的标签为’Target Value’。plt.title("Line Chart of Target for ID '00037f39cf'"): 设置图形的标题为"Line Chart of Target for ID ‘00037f39cf’"。plt.show(): 显示绘制的图形。

折线图： 

（3）特征工程

<code>model = lgb.train(lgb_params, train_matrix, 50000, valid_sets=[train_matrix, valid_matrix],

categorical_feature=[], verbose_eval=500, early_stopping_rounds=500)

训练结束后直接运行全部代码

生成submit.csv文件然后去比赛链接提交结果，这时你会发现分数已经降低啦qwq

参考资料

下一站，向冠军冲击！

我的机器学习之路

我的机器学习入门清单及路线！

机器学习神器Scikit-Learn保姆教程！

《Datawhale人工智能培养方案》发布！

《机器学习算法竞赛实战》书籍！

时间序列预测方法总结

《数据竞赛入门讲义》.pdf

双节棍「大师」鱼佬亲传武功秘籍：如何进行一场数据挖掘算法竞赛？

 Task3：进阶优化

特征提取通常涉及以下几个主要方面：

趋势特征：识别数据中的长期趋势，如线性或非线性增长、减少等。

例如，可以通过计算移动平均来提取趋势。

季节性特征：检测数据中的周期性模式，如日、周、月或年的季节性变化。

季节性指数计算可以用来提取季节性特征。

周期性特征：与季节性相似，但周期性不一定与固定的时间间隔相关。

例如，傅立叶变换可以用来识别数据中的不同频率成分。

统计特征：包括均值、中位数、方差、标准差、偏度和峰度等。

这些基础统计量可以提供数据分布的重要信息。

波动特征：如自相关函数（ACF）和偏自相关函数（PACF）来检测数据的自相关性。

这些特征对于建立ARIMA等模型非常重要。

峰谷特征：检测时间序列中的局部最大值和最小值。

可以通过求导和设置阈值来识别峰谷。

形状特征：如波形特征、复杂度、转折点等。

这些特征有助于识别时间序列的形状变化。

频率特征：使用小波变换等方法提取时间序列在不同频率上的特征。

第一次优化：可以加入更多的特征进行优化代码如下

<code># 合并训练数据和测试数据

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().valuescode>

data[f'target_win{win}_max'] = data.groupby('id')['target'].rolling(window=win, min_periods=3, closed='left').max().valuescode>

data[f'target_win{win}_min'] = data.groupby('id')['target'].rolling(window=win, min_periods=3, closed='left').min().valuescode>

data[f'target_win{win}_std'] = data.groupby('id')['target'].rolling(window=win, min_periods=3, closed='left').std().valuescode>

# 历史平移 + 窗口统计

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().valuescode>

data[f'target_shift10_win{win}_max'] = data.groupby('id')['target_shift10'].rolling(window=win, min_periods=3, closed='left').max().valuescode>

data[f'target_shift10_win{win}_min'] = data.groupby('id')['target_shift10'].rolling(window=win, min_periods=3, closed='left').min().valuescode>

data[f'target_shift10_win{win}_sum'] = data.groupby('id')['target_shift10'].rolling(window=win, min_periods=3, closed='left').sum().valuescode>

data[f'target_shift710win{win}_std'] = data.groupby('id')['target_shift10'].rolling(window=win, min_periods=3, closed='left').std().valuescode>

历史平移特征：例如 target_shift10，它表示将 ‘target’ 列的值根据 ‘id’ 分组后向右移动 10 个位置。历史平移 + 差分特征：例如 target_shift10_diff1，它是基于 target_shift10 的差分特征。窗口统计特征：例如 target_win15_mean，它是基于 ‘target’ 列的窗口大小为 15 的移动平均。历史平移 + 窗口统计特征：例如 target_shift10_win7_mean，它是基于 target_shift10 的窗口大小为 7 的移动平均。

提交后没有太大的提升

暂时来到了251分

第二次优化选择了lightgbm、xgboost和catboost模型的融合

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

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

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

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

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

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

最后付一份深度学习优化方案

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('train.csv')

test = pd.read_csv('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))code>

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)

效果貌似并不是很好

之后尝试加入小波算法等