数据挖掘HeartbeatClassification——基于lightgbm的简单建模

最新推荐文章于 2024-02-03 23:52:30 发布
最新推荐文章于 2024-02-03 23:52:30 发布
阅读量146 收藏
点赞数
文章标签： python 机器学习 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32531505/article/details/115219745
版权

我们首先来梳理一下搭建模型的过程——

  • import相关的包
  • 读取数据，划分数据集
  • 搭建模型，或是导入模型，设置模型相关参数
  • 将数据导入模型，模型训练的相关参数
  • 评估最优模型

目录

1.整体浏览，了解框架

这部分以#####为界，快速浏览，了解搭建框架

import pandas as pd
import numpy as np
from sklearn.metrics import f1_score

import os
import seaborn as sns
import matplotlib.pyplot as plt

import warnings
warnings.filterwarnings("ignore")


def reduce_mem_usage(df):
    start_mem = df.memory_usage().sum() / 1024 ** 2
    print('Memory usage of dataframe is {:.2f} MB'.format(start_mem))

    for col in df.columns:
        col_type = df[col].dtype

        if col_type != object:
            c_min = df[col].min()
            c_max = df[col].max()
            if str(col_type)[:3] == 'int':
                if c_min > np.iinfo(np.int8).min and c_max < np.iinfo(np.int8).max:
                    df[col] = df[col].astype(np.int8)
                elif c_min > np.iinfo(np.int16).min and c_max < np.iinfo(np.int16).max:
                    df[col] = df[col].astype(np.int16)
                elif c_min > np.iinfo(np.int32).min and c_max < np.iinfo(np.int32).max:
                    df[col] = df[col].astype(np.int32)
                elif c_min > np.iinfo(np.int64).min and c_max < np.iinfo(np.int64).max:
                    df[col] = df[col].astype(np.int64)
            else:
                if c_min > np.finfo(np.float16).min and c_max < np.finfo(np.float16).max:
                    df[col] = df[col].astype(np.float16)
                elif c_min > np.finfo(np.float32).min and c_max < np.finfo(np.float32).max:
                    df[col] = df[col].astype(np.float32)
                else:
                    df[col] = df[col].astype(np.float64)
        else:
            df[col] = df[col].astype('category')

    end_mem = df.memory_usage().sum() / 1024 ** 2
    print('Memory usage after optimization is: {:.2f} MB'.format(end_mem))
    print('Decreased by {:.1f}%'.format(100 * (start_mem - end_mem) / start_mem))

    return df

def f1_score_vali(preds, data_vali):
    labels = data_vali.get_label()
    preds = np.argmax(preds.reshape(4, -1), axis=0)
    score_vali = f1_score(y_true=labels, y_pred=preds, average='macro')
    return 'f1_score', score_vali, True

##########################################
# 读取数据
data = pd.read_csv('data/train.csv')
# 简单预处理
data_list = []
for items in data.values:
    data_list.append([items[0]] + [float(i) for i in items[1].split(',')] + [items[2]])

data = pd.DataFrame(np.array(data_list))
data.columns = ['id'] + ['s_'+str(i) for i in range(len(data_list[0])-2)] + ['label']

data = reduce_mem_usage(data)

#############################################
from sklearn.model_selection import KFold
# 分离数据集，方便进行交叉验证
X_train = data.drop(['id','label'], axis=1)
y_train = data['label']

# 5折交叉验证
folds = 5
seed = 2021
kf = KFold(n_splits=folds, shuffle=True, random_state=seed)


"""对训练集数据进行划分，分成训练集和验证集，并进行相应的操作"""
from sklearn.model_selection import train_test_split
import lightgbm as lgb
# 数据集划分
X_train_split, X_val, y_train_split, y_val = train_test_split(X_train, y_train, test_size=0.2)
train_matrix = lgb.Dataset(X_train_split, label=y_train_split)
valid_matrix = lgb.Dataset(X_val, label=y_val)

###############################
params = {
    "learning_rate": 0.1,
    "boosting": 'gbdt',
    "lambda_l2": 0.1,
    "max_depth": -1,
    "num_leaves": 128,
    "bagging_fraction": 0.8,
    "feature_fraction": 0.8,
    "metric": None,
    "objective": "multiclass",
    "num_class": 4,
    "nthread": 10,
    "verbose": -1,
}
###########################################
"""使用训练集数据进行模型训练"""
model = lgb.train(params,
                  train_set=train_matrix,
                  valid_sets=valid_matrix,
                  num_boost_round=2000,
                  verbose_eval=50,
                  early_stopping_rounds=200,
                  feval=f1_score_vali)

val_pre_lgb = model.predict(X_val, num_iteration=model.best_iteration)
preds = np.argmax(val_pre_lgb, axis=1)
score = f1_score(y_true=y_val, y_pred=preds, average='macro')
print('未调参前lightgbm单模型在验证集上的f1：{}'.format(score))

#################################################################

"""使用lightgbm 5折交叉验证进行建模预测"""
cv_scores = []
for i, (train_index, valid_index) in enumerate(kf.split(X_train, y_train)):
    print('************************************ {} ************************************'.format(str(i + 1)))
    X_train_split, y_train_split, X_val, y_val = X_train.iloc[train_index], y_train[train_index], X_train.iloc[
        valid_index], y_train[valid_index]

    train_matrix = lgb.Dataset(X_train_split, label=y_train_split)
    valid_matrix = lgb.Dataset(X_val, label=y_val)

    params = {
        "learning_rate": 0.1,
        "boosting": 'gbdt',
        "lambda_l2": 0.1,
        "max_depth": -1,
        "num_leaves": 128,
        "bagging_fraction": 0.8,
        "feature_fraction": 0.8,
        "metric": None,
        "objective": "multiclass",
        "num_class": 4,
        "nthread": 10,
        "verbose": -1,
    }

    model = lgb.train(params,
                      train_set=train_matrix,
                      valid_sets=valid_matrix,
                      num_boost_round=2000,
                      verbose_eval=100,
                      early_stopping_rounds=200,
                      feval=f1_score_vali)

    val_pred = model.predict(X_val, num_iteration=model.best_iteration)

    val_pred = np.argmax(val_pred, axis=1)
    cv_scores.append(f1_score(y_true=y_val, y_pred=val_pred, average='macro'))
    print(cv_scores)

print("lgb_scotrainre_list:{}".format(cv_scores))
print("lgb_score_mean:{}".format(np.mean(cv_scores)))
print("lgb_score_std:{}".format(np.std(cv_scores)))

2.分步了解

2.1 读取数据，数据预处理

data = pd.read_csv('data/train.csv')
# 简单预处理
data_list = []
for items in data.values:
    data_list.append([items[0]] + [float(i) for i in items[1].split(',')] + [items[2]])

data = pd.DataFrame(np.array(data_list))
data.columns = ['id'] + ['s_'+str(i) for i in range(len(data_list[0])-2)] + ['label']

data = reduce_mem_usage(data)

reduce_mem_usage()这个函数通过限定数据的类型，减少数据的大小，进而提升计算机对数据的读取速度

比如0.8765432101234567直接用0.87654321代替，数据的精度变小

2.2 分离数据，交叉验证

from sklearn.model_selection import KFold
# 分离数据集，方便进行交叉验证
X_train = data.drop(['id','label'], axis=1)
y_train = data['label']

# 5折交叉验证
folds = 5
seed = 2021
kf = KFold(n_splits=folds, shuffle=True, random_state=seed)

"""对训练集数据进行划分，分成训练集和验证集，并进行相应的操作"""
from sklearn.model_selection import train_test_split
import lightgbm as lgb
# 数据集划分
X_train_split, X_val, y_train_split, y_val = train_test_split(X_train, y_train, test_size=0.2)
train_matrix = lgb.Dataset(X_train_split, label=y_train_split)
valid_matrix = lgb.Dataset(X_val, label=y_val)
2.2.1

什么是交叉验证，详见详解交叉验证

了解一下KFold的参数，KFold(n_splits=’warn’, shuffle=False, random_state=None)
参数——

  • n_splits 表示划分为几块（至少是2）
  • shuffle 表示是否打乱划分，默认False，即不打乱
  • random_state 表示是否固定随机起点，Used when shuffle == True.
2.2.2
X_train_split, X_val, y_train_split, y_val 
= train_test_split(X_train, y_train, test_size=0.2)

参数是X数据集，Y标签集，测试集数据分配的比例。比如test_size=0.2，便是数据集中训练集占总数据集的80%。
返回值便是 X训练数据值，X测试数据值，Y训练标签，Y测试标签。

2.3 设置模型参数

params = {
    "learning_rate": 0.1,#学习率
    "boosting": 'gbdt',#梯度提升决策树
    "lambda_l2": 0.1,#
    "max_depth": -1,
    "num_leaves": 128,#叶节点的数目
    "bagging_fraction": 0.8,
    "feature_fraction": 0.8,#使用特征的子抽样的抽样率
    "metric": None,
    "objective": "multiclass",
    "num_class": 4,
    "nthread": 10,
    "verbose": -1,
}

2.4 训练模型，评估结果

import lightgbm as lgb

lightgbm是boosting集合模型中的新进成员，由微软提供，它和XGBoost一样是对GBDT的高效实现，原理上它和GBDT及XGBoost类似，都采用损失函数的负梯度作为当前决策树的残差近似值，去拟合新的决策树。
详见——LightGBM

"""使用训练集数据进行模型训练"""
model = lgb.train(params,
                  train_set=train_matrix,
                  valid_sets=valid_matrix,
                  num_boost_round=2000,
                  verbose_eval=50,
                  early_stopping_rounds=200,
                  feval=f1_score_vali)

val_pre_lgb = model.predict(X_val, num_iteration=model.best_iteration)
preds = np.argmax(val_pre_lgb, axis=1)
score = f1_score(y_true=y_val, y_pred=preds, average='macro')#评估模型性能
print('未调参前lightgbm单模型在验证集上的f1：{}'.format(score))

2.5 交叉验证，减少训练误差

"""使用lightgbm 5折交叉验证进行建模预测"""
cv_scores = []
for i, (train_index, valid_index) in enumerate(kf.split(X_train, y_train)):
    print('************************************ {} ************************************'.format(str(i + 1)))
    X_train_split, y_train_split, X_val, y_val = X_train.iloc[train_index], y_train[train_index], X_train.iloc[
        valid_index], y_train[valid_index]

    train_matrix = lgb.Dataset(X_train_split, label=y_train_split)
    valid_matrix = lgb.Dataset(X_val, label=y_val)

    params = {
        "learning_rate": 0.1,
        "boosting": 'gbdt',
        "lambda_l2": 0.1,
        "max_depth": -1,
        "num_leaves": 128,
        "bagging_fraction": 0.8,
        "feature_fraction": 0.8,
        "metric": None,
        "objective": "multiclass",
        "num_class": 4,
        "nthread": 10,
        "verbose": -1,
    }

    model = lgb.train(params,
                      train_set=train_matrix,
                      valid_sets=valid_matrix,
                      num_boost_round=2000,
                      verbose_eval=100,
                      early_stopping_rounds=200,
                      feval=f1_score_vali)

    val_pred = model.predict(X_val, num_iteration=model.best_iteration)

    val_pred = np.argmax(val_pred, axis=1)
    cv_scores.append(f1_score(y_true=y_val, y_pred=val_pred, average='macro'))
    print(cv_scores)

print("lgb_scotrainre_list:{}".format(cv_scores))
print("lgb_score_mean:{}".format(np.mean(cv_scores)))
print("lgb_score_std:{}".format(np.std(cv_scores)))

这部分的关键点在这里——

folds = 5
seed = 2021
kf = KFold(n_splits=folds, shuffle=True, random_state=seed)

for i, (train_index, valid_index) in enumerate(kf.split(X_train, y_train))

将数据集平均分成5份，其中每次随机取4份为训练集，1份为测试集，每次取的不一样。
比如——

  • 【1，2，3，4】【5】
  • 【2，3，4，5】【1】
  • 【1，3，4，5】【2】
  • 【1，2，4，5】【3】
  • 【1，2，3，5】【4】

3.测试结果如下

3.1 数据的简单处理

Memory usage of dataframe is 157.93 MB
Memory usage after optimization is: 39.67 MB
Decreased by 74.9%

3.2 未调参的训练结果

##########################################
Training until validation scores don't improve for 200 rounds
[50]	valid_0's multi_logloss: 0.0518171	valid_0's f1_score: 0.954613
[100]	valid_0's multi_logloss: 0.0456245	valid_0's f1_score: 0.962268
[150]	valid_0's multi_logloss: 0.0470006	valid_0's f1_score: 0.965291
[200]	valid_0's multi_logloss: 0.0484298	valid_0's f1_score: 0.966406
[250]	valid_0's multi_logloss: 0.0498757	valid_0's f1_score: 0.966886
Early stopping, best iteration is:
[92]	valid_0's multi_logloss: 0.045533	valid_0's f1_score: 0.96131
未调参前lightgbm单模型在验证集上的f1：0.961309560452836

3.3 调参后的训练结果

###########################################################################

************************************ 1 ************************************
Training until validation scores don't improve for 200 rounds
[100]	valid_0's multi_logloss: 0.0408155	valid_0's f1_score: 0.966797
[200]	valid_0's multi_logloss: 0.0437957	valid_0's f1_score: 0.971239
Early stopping, best iteration is:
[96]	valid_0's multi_logloss: 0.0406453	valid_0's f1_score: 0.967452
[0.9674515729721614]
************************************ 2 ************************************
Training until validation scores don't improve for 200 rounds
[100]	valid_0's multi_logloss: 0.0472933	valid_0's f1_score: 0.965828
[200]	valid_0's multi_logloss: 0.0514952	valid_0's f1_score: 0.968138
Early stopping, best iteration is:
[87]	valid_0's multi_logloss: 0.0467472	valid_0's f1_score: 0.96567
[0.9674515729721614, 0.9656700872844327]
************************************ 3 ************************************
Training until validation scores don't improve for 200 rounds
[100]	valid_0's multi_logloss: 0.0378154	valid_0's f1_score: 0.971004
[200]	valid_0's multi_logloss: 0.0405053	valid_0's f1_score: 0.973736
Early stopping, best iteration is:
[93]	valid_0's multi_logloss: 0.037734	valid_0's f1_score: 0.970004
[0.9674515729721614, 0.9656700872844327, 0.9700043639844769]
************************************ 4 ************************************
Training until validation scores don't improve for 200 rounds
[100]	valid_0's multi_logloss: 0.0495142	valid_0's f1_score: 0.967106
[200]	valid_0's multi_logloss: 0.0542324	valid_0's f1_score: 0.969746
Early stopping, best iteration is:
[84]	valid_0's multi_logloss: 0.0490886	valid_0's f1_score: 0.965566
[0.9674515729721614, 0.9656700872844327, 0.9700043639844769, 0.9655663272378014]
************************************ 5 ************************************
Training until validation scores don't improve for 200 rounds
[100]	valid_0's multi_logloss: 0.0412544	valid_0's f1_score: 0.964054
[200]	valid_0's multi_logloss: 0.0443025	valid_0's f1_score: 0.965507
Early stopping, best iteration is:
[96]	valid_0's multi_logloss: 0.0411855	valid_0's f1_score: 0.963114
[0.9674515729721614, 0.9656700872844327, 0.9700043639844769, 0.9655663272378014, 0.9631137190307674]
lgb_scotrainre_list:[0.9674515729721614, 0.9656700872844327, 0.9700043639844769, 0.9655663272378014, 0.9631137190307674]
lgb_score_mean:0.9663612141019279
lgb_score_std:0.0022854824074775683
Kolo_Tong
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
统计行业数据分析与数据挖掘应用——统计建模思想.pdf
07-14
统计行业数据分析与数据挖掘应用——统计建模思想.pdf
k折交叉验证KFold()函数
qq_43653405的博客
07-17 3377
KFold（n_split, shuffle, random_state） 　参数：n_splits:要划分的折数 　　　　shuffle: 每次都进行shuffle，测试集中折数的总和就是训练集的个数 　　　　random_state:随机状态 from sklearn.model_selection import KFold kf = KFold(n_splits=3,random_state=1) for train, test in kf.split(titanic): titanic为X，即要
Kfold,StratifiedKfold,LBO,GroupKFold不同验证方法的实验结果比较
微电子学与固体电子学-俞驰
09-12 1865
# General imports import numpy as np import pandas as pd import os, sys, gc, warnings, random, datetime from sklearn import metrics from sklearn.preprocessing import LabelEncoder from tqdm import t...
第27步 机器学习分类实战：LightGBM建模
qq_30452897的博客
02-28 965
LightGBM建模~
机器学习实战 | LightGBM建模应用详解
ShowMeAI研究中心
03-21 2万+
本篇详细讲解LightGBM的工程应用方法。LightGBM是微软开发的boosting集成模型，和XGBoost一样是对GBDT的优化和高效实现，但它很多方面比XGBoost有着更为优秀的表现。
【项目实战】Python实现LightGBM分类模型(LGBMClassifier算法)项目实战
胖哥真不错的博客
11-06 3万+
说明：这是一个机器学习实战项目（附带数据+代码+文档+代码讲解），如需数据+代码+文档+代码讲解可以直接到文章最后获取。 1.项目背景 如今已是大数据时代，具备大数据思想至关重要，人工智能技术在各行各业的应用已是随处可见。GBDT (Gradient Boosting Decision Tree) 是机器学习中一个长盛不衰的模型，其主要思想是利用弱分类器（决策树）迭代训练以得到最优模型，该模型具有训练效果好、不易过拟合等优点。GBDT不仅在工业界应用广泛，通常被用于多分类、点击率预...
高级工具库xgboost/LightGBM与建模实战
11-01
高级工具库xgboost/LightGBM与建模实战：xgboost应用和实践，LightGBM
西电数据挖掘作业——医院数据处理
03-13
总结来说，“西电数据挖掘作业——医院数据处理”是一个综合性的项目，涉及到数据科学的核心技能，包括数据读取、预处理、特征工程、建模和结果可视化。这个项目不仅提升了参与者对Python3和数据挖掘工具的熟练度，...
数据建模专题培训——大数据挖掘.pptx
11-18
数据建模专题培训——大数据挖掘.pptx
数据挖掘建模过程——思维导图
07-02
用XMIND建立的数据挖掘的思维导图，让大家有一个简单明了的认知，什么是数据挖掘，主要过程是什么
机器学习数据集-心脏病预测
10-13
机器学习数据集
【机器学习】基于LightGBM建模的极简教程
最新发布
fengdu78的博客
02-03 209
作者：Peter编辑：Peter介绍一个简单而不简约的基于LightGBM的实战项目，主要内容包含：数据探索性分析EDA基于LightGBM的建模基于网格搜索的模型优化麻雀虽小，五脏俱全1 导入库In [1]:importpandasaspd importnumpyasnp pd.set_option('display.max_columns',100) fromIPython....
Scikit-learn的K-fold交叉验证类ShuffleSplit、GroupShuffleSplit用法介绍
熊大的博客
04-15 724
https://blog.csdn.net/hurry0808/article/details/80797969
K-Folds交叉验证器
weixin_41798592的博客
09-19 1011
K-Folds交叉验证器 sklearn.model_selection.KFold（n_splits =‘warn’，shuffle = False，random_state = None ）提供训练/测试索引以分割训练/测试集中的数据。将数据集拆分为k个连续折叠（默认情况下不进行混洗）。然后每个折叠使用一次作为验证，而k-1剩余折叠形成训练集。 参数： n_splits ： int，defau...
【机器学习笔记（八）】之Sklearn中交叉验证 KFold简要讲解
开发小鸽
07-04 2049
Sklearn中交叉验证API KFold讲解 一. 交叉验证原理讲解 1. 设置验证集的原因 在机器学习建模过程中，将数据分为训练集和测试集。测试集合训练集是完全分开的两个数据集，完全不参与训练，只是用于模型最终确定后，来测试模型的效果。而训练集又要分出一部分数据用来验证模型的训练效果，即验证集。验证集在每次训练集训练结束后，对模型的效果进行初步地测试。之所以要设置验证集，是因为训练数据会有过拟合的情况出现，即训练数据能够很好地匹配训练数据，但对于训练数据之外的数据效果非常差。验证集不参与训练，可以客观地
机器学习 || k-交叉验证KFold详解
qq_33828738的博客
08-19 8889
微信公众号：龙跃十二 我是小玉，一个平平无奇的小天才！ 在使用机器学习进行训练模型的时候，内行人都知道我们要进行交叉验证，也就是分出一个验证集来确保我们的模型的准确率，最近在看这里的时候，有一些疑问，搞明白了就分享给大家。 基本原理： 在机器学习建模过程中，通行的做法通常是将数据分为训练集和测试集。测试集是与训练独立的数据，完全不参与训练，用于最终模型的评估。在训练过程中，经常会出现过拟合的问题，就是模型可以很好的匹配训练数据，却不能很好在预测训练集外的数据。如果此时就使用测试数据来调整模型参数，就相当.
python风控建模项目_风控——建模调参
weixin_39702480的博客
12-24 395
Bagging与Boosting:集成方法主要包括bagging与boosting，Bagging和Boosting都是将已有的分类或回归算法通过一定方式组合起来，形成一个更加强大的分类。两种方法都是把若干个分类器整合为一个分类器的方法，只是整合的方式不一样，最终得到不一样的效果。常见的基于Baggin思想的集成模型有：随机森林、基于Boosting思想的集成模型有：Adaboost、GBDT、X...
【机器学习】图解机器学习中的 12 种交叉验证技术
fengdu78的博客
09-09 2591
今天我给大家盘点下机器学习中所使用的交叉验证器都有哪些，用最直观的图解方式来帮助大家理解他们是如何工作的。数据集说明数据集来源于kaggle M5 Forecasting - Accura...
sklearn.model_selection.KFold
热门推荐
每天进步一点点2017
07-10 7万+
K折交叉验证：sklearn.model_selection.KFold(n_splits=3, shuffle=False, random_state=None) 思路：将训练/测试数据集划分n_splits个互斥子集，每次用其中一个子集当作验证集，剩下的n_splits-1个作为训练集，进行n_splits训练和测试，得到n_splits个结果 注意点：对于不能均等份的数据集，其前n_sa

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值