组队学习第四天：心跳信号分类之建模与调参

原题目地址：零基础入门数据挖掘-心跳信号分类预测
本文是鸣鹤星空小组组队学习的集体成果。
id:李由，一只小呆
源地址：组队学习

1 学习目标

• 学习机器学习模型的建模过程与调参流程
• 完成相应学习打卡任务

2 内容介绍

• 逻辑回归模型：

  • 理解逻辑回归模型；
  • 逻辑回归模型的应用；
  • 逻辑回归的优缺点；

• 树模型：

  • 理解树模型；
  • 树模型的应用；
  • 树模型的优缺点；

• 集成模型

  • 基于bagging思想的集成模型
    • 随机森林模型
  • 基于boosting思想的集成模型
    • XGBoost模型
    • LightGBM模型
    • CatBoost模型

• 模型对比与性能评估：

  • 回归模型/树模型/集成模型；
  • 模型评估方法；
  • 模型评价结果；

• 模型调参：

  • 贪心调参方法；

  • 网格调参方法；

  • 贝叶斯调参方法；

3 模型对比与性能评估

3.1 逻辑回归

• 优点

  • 训练速度较快，分类的时候，计算量仅仅只和特征的数目相关；
  • 简单易理解，模型的可解释性非常好，从特征的权重可以看到不同的特征对最后结果的影响；
  • 适合二分类问题，不需要缩放输入特征；
  • 内存资源占用小，只需要存储各个维度的特征值；

• 缺点

  • 逻辑回归需要预先处理缺失值和异常值【可参考task3特征工程】；

  • 不能用Logistic回归去解决非线性问题，因为Logistic的决策面是线性的；

  • 对多重共线性数据较为敏感，且很难处理数据不平衡的问题；

  • 准确率并不是很高，因为形式非常简单，很难去拟合数据的真实分布；

3.2 决策树模型

• 优点
  • 简单直观，生成的决策树可以可视化展示
  • 数据不需要预处理，不需要归一化，不需要处理缺失数据
  • 既可以处理离散值，也可以处理连续值
• 缺点
  • 决策树算法非常容易过拟合，导致泛化能力不强（可进行适当的剪枝）
  • 采用的是贪心算法，容易得到局部最优解

3.3 集成模型集成方法（ensemble method）

通过组合多个学习器来完成学习任务，通过集成方法，可以将多个弱学习器组合成一个强分类器，因此集成学习的泛化能力一般比单一分类器要好。

集成方法主要包括Bagging和Boosting，Bagging和Boosting都是将已有的分类或回归算法通过一定方式组合起来，形成一个更加强大的分类。两种方法都是把若干个分类器整合为一个分类器的方法，只是整合的方式不一样，最终得到不一样的效果。常见的基于Baggin思想的集成模型有：随机森林、基于Boosting思想的集成模型有：Adaboost、GBDT、XgBoost、LightGBM等。

Baggin和Boosting的区别总结如下：

• 样本选择上： Bagging方法的训练集是从原始集中有放回的选取，所以从原始集中选出的各轮训练集之间是独立的；而Boosting方法需要每一轮的训练集不变，只是训练集中每个样本在分类器中的权重发生变化。而权值是根据上一轮的分类结果进行调整
• 样例权重上： Bagging方法使用均匀取样，所以每个样本的权重相等；而Boosting方法根据错误率不断调整样本的权值，错误率越大则权重越大
• 预测函数上： Bagging方法中所有预测函数的权重相等；而Boosting方法中每个弱分类器都有相应的权重，对于分类误差小的分类器会有更大的权重
• 并行计算上： Bagging方法中各个预测函数可以并行生成；而Boosting方法各个预测函数只能顺序生成，因为后一个模型参数需要前一轮模型的结果。

3.4 模型评估方法

对于模型来说，其在训练集上面的误差我们称之为训练误差或者经验误差，而在测试集上的误差称之为测试误差。

对于我们来说，我们更关心的是模型对于新样本的学习能力，即我们希望通过对已有样本的学习，尽可能的将所有潜在样本的普遍规律学到手，而如果模型对训练样本学的太好，则有可能把训练样本自身所具有的一些特点当做所有潜在样本的普遍特点，这时候我们就会出现过拟合的问题。

因此我们通常将已有的数据集划分为训练集和测试集两部分，其中训练集用来训练模型，而测试集则是用来评估模型对于新样本的判别能力。

对于数据集的划分，我们通常要保证满足以下两个条件：

• 训练集和测试集的分布要与样本真实分布一致，即训练集和测试集都要保证是从样本真实分布中独立同分布采样而得；
• 训练集和测试集要互斥

对于数据集的划分有三种方法：留出法，交叉验证法和自助法，下面挨个介绍：

• ①留出法

  留出法是直接将数据集D划分为两个互斥的集合，其中一个集合作为训练集S，另一个作为测试集T。需要注意的是在划分的时候要尽可能保证数据分布的一致性，即避免因数据划分过程引入额外的偏差而对最终结果产生影响。为了保证数据分布的一致性，通常我们采用分层采样的方式来对数据进行采样。

  Tips： 通常，会将数据集D中大约2/3~4/5的样本作为训练集，其余的作为测试集。

• ②交叉验证法

  k折交叉验证通常将数据集D分为k份，其中k-1份作为训练集，剩余的一份作为测试集，这样就可以获得k组训练/测试集，可以进行k次训练与测试，最终返回的是k个测试结果的均值。交叉验证中数据集的划分依然是依据分层采样的方式来进行。

  对于交叉验证法，其k值的选取往往决定了评估结果的稳定性和保真性，通常k值选取10。

  当k=1的时候，我们称之为留一法

• ③自助法

  我们每次从数据集D中取一个样本作为训练集中的元素，然后把该样本放回，重复该行为m次，这样我们就可以得到大小为m的训练集，在这里面有的样本重复出现，有的样本则没有出现过，我们把那些没有出现过的样本作为测试集。

  进行这样采样的原因是因为在D中约有36.8%的数据没有在训练集中出现过。留出法与交叉验证法都是使用分层采样的方式进行数据采样与划分，而自助法则是使用有放回重复采样的方式进行数据采样

数据集划分总结

• 对于数据量充足的时候，通常采用留出法或者k折交叉验证法来进行训练/测试集的划分；
• 对于数据集小且难以有效划分训练/测试集时使用自助法；
• 对于数据集小且可有效划分的时候最好使用留一法来进行划分，因为这种方法最为准确

3.5 模型评价标准

对于本次比赛，我们选用自定义的abs-sum作为模型评价标准。

4 代码示例及注释

# 导入基本包
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")

# reduce_mem_usage函数读取数据，同上上次任务，通过判断值的类型，调整至最小有效的数据类型，以减少数据在内存中占用的空间
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

# 读入csv文件，将信号字符串列通过逗号拆开，组成新的dataframe，预处理完成
# 读取数据
data = pd.read_csv('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)

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

# 提取信号值放于X_train中，提取信号对应标签放入y_train中，并使用上次task中的KFold交叉验证
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)

# 自定义F1参数的计算函数，使用了基本的f1_score函数，以nparray的类型返回f1值
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

# 使用LightGBM算法，获取分类器
"""对训练集数据进行划分，分成训练集和验证集，并进行相应的操作"""
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)

Training until validation scores don't improve for 200 rounds
[50]	valid_0's multi_logloss: 0.0471611	valid_0's f1_score: 0.958932
[100]	valid_0's multi_logloss: 0.041015	valid_0's f1_score: 0.965173
[150]	valid_0's multi_logloss: 0.0425786	valid_0's f1_score: 0.967822
[200]	valid_0's multi_logloss: 0.0442567	valid_0's f1_score: 0.96842
[250]	valid_0's multi_logloss: 0.0456278	valid_0's f1_score: 0.968617
Early stopping, best iteration is:
[91]	valid_0's multi_logloss: 0.0408773	valid_0's f1_score: 0.96458

# 将验证集 X_val扔进训练好的分类器，输出f1_score
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单模型在验证集上的f1：0.9645798305722377

# 将train换成五折交叉后的dataframe
"""使用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)))

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

def LGB(dep,num):
    # 数据集划分
    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": dep,
        "num_leaves": num,          # 叶子节点数
        "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)

from sklearn.model_selection import cross_val_score
import math
num_leaves = [64,128,256]
# num_leaves
best_leaves = dict()
for leaves in num_leaves:
    model = LGB(dep=min(best_obj.items(), key=lambda x:x[1])[0], num=leaves)
    # 预测并计算roc的相关指标
    score = cross_val_score(model, X_train, y_train, cv=5, scoring='f1').mean()
    best_leaves[leaves] = score

    max_depth = [-1,1,5,10]
# max_depth
best_depth = dict()
for depth in max_depth:
    model = LGB(dep=min(num=min(best_leaves.items(), key=lambda x:x[1])[0],dep=depth))
    # 预测并计算roc的相关指标
    score = cross_val_score(model, X_train, y_train, cv=5, scoring='f1').mean()
    best_depth[depth] = score

"""
可依次将模型的参数通过上面的方式进行调整优化，并且通过可视化观察在每一个最优参数下模型的得分情况
"""

---------------------------------------------------------------------------

ValueError                                Traceback (most recent call last)

<ipython-input-22-3c10de794ef6> in <module>
      5 best_leaves = dict()
      6 for leaves in num_leaves:
----> 7     model = LGB(dep=min(best_obj.items(), key=lambda x:x[1])[0], num=leaves)
      8     # 预测并计算roc的相关指标
      9     score = cross_val_score(model, X_train, y_train, cv=5, scoring='f1').mean()


ValueError: min() arg is an empty sequence

5 遇到的问题

正如上面所述，在代码运行时遇到了’objective’ is not defined的问题。
这个objective是参数中的类名，但是经过尝试，仍然未能成功运行。
所以在此处暂时存疑，待之后再深究。
把所有的代码自己跑一遍，对比示例给出的成果，对于学习和理解代码运行的逻辑很有帮助。