devbox
笔触狂放9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【Datawhale AI夏令营】|从零入门机器学习竞赛笔记_datawhale ai 夏令营

作者：笔触狂放9 | 2024-08-14 05:12:35

赞

踩

datawhale ai 夏令营

一、使用lightbgm

一、什么是lightbgm

        （1）lightbgm简介

        LightGBM（Light Gradient Boosting Machine）是一款基于决策树算法的分布式梯度提升框架，旨在提供快速高效、低内存占用、高准确率的模型训练工具。它通过多种优化手段，解决了传统GBDT在面对海量数据时遇到的效率和内存瓶颈问题，使其更适用于工业级应用。

        （2）lightbgm基本原理

        基于直方图的决策树算法：LightGBM使用直方图优化技术，将连续的特征值离散化成特定的bin（即直方图的桶），减少了在节点分裂时需要计算的数据量。这种方法可以在减少内存使用的同时，提高计算速度。

        带深度限制的leaf-wise树生长策略：与传统的水平分割不同，leaf-wise的生长策略是每次从当前所有叶子节点中选择分裂收益最大的节点进行分裂。这种策略可以使得决策树更加侧重于数据中的异常部分，通常可以得到更好的精度。

        单边梯度采样：对于数据集中的大梯度样本，只保留数据的一部分（通常是大梯度的样本），减少计算量同时保证不会损失太多的信息。这种方法可以在不显著损失精度的情况下加快训练速度。

        互斥特征捆绑：EFB是一种减少特征数量、提高计算效率的技术，它将互斥的特征进行合并，以减少特征维度。

        （3）lightbgm的优缺点

        优点：

        高效性：通过直方图优化和leaf-wise生长策略，LightGBM在保证精度的同时大幅提升了训练速度。

        内存使用少：相比于其他GBM实现，LightGBM需要的内存更少，这使得它能够处理更大的数据集。

        可扩展性：支持多线程和分布式计算，可以利用现代硬件的计算能力。

        易用性：提供了丰富的参数选项，方便用户根据具体问题进行调整。

        缺点：

        对噪声敏感：leaf-wise的生长策略容易受到数据中噪声的影响，可能导致过拟合。

        调参复杂：虽然LightGBM提供了丰富的参数选项，但这也使得模型调参变得相对复杂，需要一定的经验和实验来确定最优参数。

二、使用lightbgm

        （1）导入模块

  1. import numpy as np
  2. import pandas as pd
  3. import lightgbm as lgb
  4. from sklearn.metrics import mean_squared_error
  5. import sys
  6. import os
  7. import gc
  8. import argparse
  9. import warnings

        （2）读取数据

  1. train = pd.read_csv('../data/train.csv')
  2. test = pd.read_csv('../data/test.csv')

        （3）构建特征

        1、历史平移特征

        历史平移特征是一种在时间序列分析中常用的特征工程方法，它通过将历史数据作为新特征加入模型中，以提升模型的预测能力。主要作用是捕捉时间序列数据中的历史信息，这些信息对于预测未来的值可能具有重要作用。在时间序列分析中，一个观测点的值往往与其历史上的值密切相关。例如，在金融市场中，股票的今日价格往往与昨天、上周甚至是去年同一天的价格有关；在销售预测中，本月的销售额往往受到前几个月销售情况的影响。因此，通过在模型中加入这些历史数据作为特征，可以帮助模型学习到数据中的时间依赖关系，从而提高预测的准确性。

相关代码如下：

  1. # 历史平移
  2. for i in range(10, 30):
  3.     data[f'last{i}_target'] = data.groupby(['id'])['target'].shift(i)
        2、窗口统计特征

        窗口统计特征是基于时间序列数据在滑动窗口内计算的一系列统计量，用于捕捉数据的局部行为和动态变化。这些统计量通常包括平均值、中位数、标准偏差、最小值和最大值等，有助于揭示时间序列在不同时间段内的行为变化。其主要目的是通过在数据上滑动固定大小的窗口并计算该窗口内数据的统计量，从而提取有意义的信息。这种方法特别适用于那些具有局部相似性和时间依赖性的数据。例如，在金融市场分析中，股票价格的移动平均线可以通过计算特定时间窗口内的平均值来得到，这有助于平滑短期波动并突出长期趋势。

相关代码如下：

  1. # 窗口统计
  2. data[f'win3_mean_target'] = (data['last10_target'] + data['last11_target'] + data['last12_target']) / 3

        （4）处理数据

        在正式开始模型训练与测试集预测前，我们需要对数据进行切分和对特征的确认。这两个步骤在机器学习和数据分析中至关重要，因为它们直接影响模型的训练效果和预测能力。

        数据集切分的目的是将原始数据分为不同的子集，以便在不同的阶段使用。训练集用于模型学习，测试集用于初步评估模型性能，而验证集则用于优化模型超参数。特征确认旨在识别和选择对模型预测最有用和最具代表性的特征，以提高模型的性能和泛化能力。

  1. # 进行数据切分
  2. train = data[data.target.notnull()].reset_index(drop=True)
  3. test = data[data.target.isnull()].reset_index(drop=True)
  4.  
  5. # 确定输入特征
  6. train_cols = [f for f in data.columns if f not in ['id', 'target']]

        （5）训练模型

        使用训练数据集对模型进行训练。这一过程中，LightGBM会自动进行多线程或分布式计算，大幅度提高训练速度。

  1. def time_model(lgb,train_df, test_df, cols):
  2.     # 训练集和验证集切分
  3.     trn_x, trn_y = train_df[train_df.dt >= 31][cols], train_df[train_df.dt >= 31]['target']
  4.     val_x, val_y = train_df[train_df.dt <= 30][cols], train_df[train_df.dt <= 30]['target']
  5.     # 构建模型输入数据
  6.     train_matrix = lgb.Dataset(trn_x, label=trn_y)
  7.     valid_matrix = lgb.Dataset(val_x, label=val_y)
  8.     # lightgbm参数
  9.     lgb_params = {
  10.         'boosting_type': 'gbdt',
  11.         'objective': 'regression',
  12.         'metric': 'mse',
  13.         'min_child_weight': 5,
  14.         'num_leaves': 2 ** 5,
  15.         'lambda_l2': 10,
  16.         'feature_fraction': 0.8,
  17.         'bagging_fraction': 0.8,
  18.         'bagging_freq': 4,
  19.         'learning_rate': 0.05,
  20.         'seed': 2024,
  21.         'nthread': 16,
  22.         'verbose': -1,
  23.     }
  24.     # 训练模型
  25.     model = lgb.train(lgb_params, train_matrix, 10000, valid_sets=[train_matrix, valid_matrix],
  26.                       categorical_feature=[])
  27.     # 验证集和测试集结果预测
  28.     val_pred = model.predict(val_x, num_iteration=model.best_iteration)
  29.     test_pred = model.predict(test_df[cols], num_iteration=model.best_iteration)
  30.     # 离线分数评估
  31.     score = mean_squared_error(val_pred, val_y)
  32.     print(score)
  33.  
  34.     return val_pred, test_pred
  35.  
  36.  
  37. lgb_oof, lgb_test = time_model(lgb, train, test, train_cols)
  38.  
  39. # 保存结果文件到本地
  40. test['target'] = lgb_test
  41. test[['id', 'dt', 'target']].to_csv('../data/submit.csv', index=None)

二、多个模型融合

        首先，我们需要导入所需的库，并定义一个函数cv_model，该函数将根据传入的参数选择使用lightgbm、xgboost或catboost模型。然后，我们将使用K折交叉验证方法对每个模型进行评估，并将三个模型的结果取平均进行融合。

一、导入所需库

  1. import numpy as np
  2. import pandas as pd
  3. import lightgbm as lgb
  4. from sklearn.linear_model import Ridge
  5. from sklearn.metrics import mean_squared_log_error, mean_absolute_error, mean_squared_error
  6. from sklearn.model_selection import StratifiedKFold, KFold, GroupKFold
  7. import xgboost as xgb
  8. from catboost import CatBoostRegressor
  9. import warnings

二、定义cv_model函数

  1. def cv_model(clf, train_x, train_y, test_x, clf_name, seed=2024):
  2.     """
  3.     clf：调用模型
  4.     train_x：训练数据
  5.     train_y：训练数据对应标签
  6.     test_x：测试数据
  7.     clf_name：选择使用模型名
  8.     seed：随机种子
  9.     """
  10.     folds = 5
  11.     kf = KFold(n_splits=folds, shuffle=True, random_state=seed)
  12.     oof = np.zeros(train_x.shape[0])
  13.     test_predict = np.zeros(test_x.shape[0])
  14.     cv_scores = []
  15.  
  16.     for i, (train_index, valid_index) in enumerate(kf.split(train_x, train_y)):
  17.         print('************************************ {} ************************************'.format(str(i + 1)))
  18.         trn_x, trn_y, val_x, val_y = train_x.iloc[train_index], train_y[train_index], train_x.iloc[valid_index], \
  19.         train_y[valid_index]
  20.  
  21.         if clf_name == "lgb":
  22.             train_matrix = clf.Dataset(trn_x, label=trn_y)
  23.             valid_matrix = clf.Dataset(val_x, label=val_y)
  24.             params = {
  25.                 'boosting_type': 'gbdt',
  26.                 'objective': 'regression',
  27.                 'metric': 'mae',
  28.                 'min_child_weight': 6,
  29.                 'num_leaves': 2 ** 6,
  30.                 'lambda_l2': 10,
  31.                 'feature_fraction': 0.8,
  32.                 'bagging_fraction': 0.8,
  33.                 'bagging_freq': 4,
  34.                 'learning_rate': 0.1,
  35.                 'seed': 2023,
  36.                 'nthread': 16,
  37.                 'verbose': -1,
  38.             }
  39.             model = clf.train(params, train_matrix, 1000, valid_sets=[train_matrix, valid_matrix],categorical_feature=[])
  40.             val_pred = model.predict(val_x, num_iteration=model.best_iteration)
  41.             test_pred = model.predict(test_x, num_iteration=model.best_iteration)
  42.  
  43.         if clf_name == "xgb":
  44.             xgb_params = {
  45.                 'booster': 'gbtree',
  46.                 'objective': 'reg:squarederror',
  47.                 'eval_metric': 'mae',
  48.                 'max_depth': 5,
  49.                 'lambda': 10,
  50.                 'subsample': 0.7,
  51.                 'colsample_bytree': 0.7,
  52.                 'colsample_bylevel': 0.7,
  53.                 'eta': 0.1,
  54.                 'tree_method': 'hist',
  55.                 'seed': 520,
  56.                 'nthread': 16
  57.             }
  58.             train_matrix = clf.DMatrix(trn_x, label=trn_y)
  59.             valid_matrix = clf.DMatrix(val_x, label=val_y)
  60.             test_matrix = clf.DMatrix(test_x)
  61.  
  62.             watchlist = [(train_matrix, 'train'), (valid_matrix, 'eval')]
  63.  
  64.             model = clf.train(xgb_params, train_matrix, num_boost_round=1000, evals=watchlist)
  65.             val_pred = model.predict(valid_matrix)
  66.             test_pred = model.predict(test_matrix)
  67.  
  68.         if clf_name == "cat":
  69.             params = {'learning_rate': 0.1, 'depth': 5, 'bootstrap_type': 'Bernoulli', 'random_seed': 2023,
  70.                       'od_type': 'Iter', 'od_wait': 100,'allow_writing_files': False}
  71.  
  72.             model = clf(iterations=1000, **params)
  73.             model.fit(trn_x, trn_y, eval_set=(val_x, val_y),
  74.                       metric_period=200,
  75.                       use_best_model=True,
  76.                       cat_features=[],
  77.                       verbose=1)
  78.  
  79.             val_pred = model.predict(val_x)
  80.             test_pred = model.predict(test_x)
  81.  
  82.         oof[valid_index] = val_pred
  83.         test_predict += test_pred / kf.n_splits
  84.  
  85.         score = mean_absolute_error(val_y, val_pred)
  86.         cv_scores.append(score)
  87.         print(cv_scores)
  88.  
  89.     return oof, test_predict

        这里使用了lightgbm、xgboost和catboost三个模型，并使用K折交叉验证来评估模型的性能。 函数首先初始化K折交叉验证，对于每个交叉验证的循环，将训练数据划分为训练集和验证集；再根据选择的模型名，使用相应的库（lightgbm、xgboost或catboost）来训练模型，使用训练好的模型对验证集进行预测，并将预测结果保存到oof数组中，再将预测结果累加到test_predict数组中，以计算测试数据的平均预测结果；然后将计算验证集的均方误差（mean absolute error，mae），并将结果保存到cv_scores列表中；最后打印和返回相关数据。

三、将三个模型的结果取平均进行融合

  1. # 选择lightgbm模型
  2. lgb_oof, lgb_test = cv_model(lgb, train[train_cols], train['target'], test[train_cols], 'lgb')
  3. # 选择xgboost模型
  4. xgb_oof, xgb_test = cv_model(xgb, train[train_cols], train['target'], test[train_cols], 'xgb')
  5. # 选择catboost模型
  6. cat_oof, cat_test = cv_model(CatBoostRegressor, train[train_cols], train['target'], test[train_cols], 'cat')
  7.  
  8. # 进行取平均融合
  9. final_test = (lgb_test + xgb_test + cat_test) / 3

        另外需要注意的是虽然模型融合能显著提高预测性能，但会增加计算复杂度。需要权衡模型复杂度和准确度，避免过度堆砌模型。

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号