心电图分类预测 Task4

Task4主要知识点是——模型的构建和调参

首先是数据的读取

因为数据量量比较大,用reduce_men_usage可以有效节省内存(大致思想是:通过将int(float) 64类型的数据改用int(float) 32/16/8存储可以降低对内存的损耗,膜拜大佬的干货
> 用pandas处理大数据———减少90%内存消耗的小贴士

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

下面是建模前对数据的初步处理

image
image

使用Lightgbm进行建模

首先奉上Lightgbm中文文档 https://lightgbm.cn/docs/2/ ,之前没接触过Lightgbm,所以趁这次看了一些博客简单入了个门(还是太菜了 :lemon:)
LigthGBM(轻量级(Light)的梯度提升机(GBM))和XGBoost一样是对GBDT的高效实现,相对于XGboost运行速度快,占用内存少,原理是采用损失函数的负梯度作为当前决策树的残差近似值,去拟合新的决策树。

task: 默认值=train,可选项=train,prediction;指定我们希望执行的任务,该任务有两种类型:训练 和 预测;
application: 默认值=regression,type=enum,options=options;
regression: 执行回归任务;
binary:二分类;
multiclass:多分类;
lambdarank:lambrank应用;
data: type=string;training data,LightGBM将从这些数据中进行训练;
num_iterations: 默认值为100,类型为int。表示提升迭代次数,也就是提升树的棵树;
num_leaves: 每个树上的叶子数,默认值为31,类型为int;
device: 默认值=cpu;可选项:cpu,gpu。也就是我们使用什么类型的设备去训练我们的模型。选择GPU会使得训练过程更快;
mindatain_leaf: 每个叶子上的最少数据;
feature_fraction: 默认值为1;指定每次迭代所需要的特征部分;
bagging_fraction: 默认值为1;指定每次迭代所需要的数据部分,并且它通常是被用来提升训练速度和避免过拟合的。
mingainto_split: 默认值为1;执行分裂的最小的信息增益;
max_bin: 最大的桶的数量,用来装数值的;
mindatain_bin: 每个桶内最少的数据量;
numthreads: 默认值为OpenMPdefault,类型为int。指定LightGBM算法运行时线程的数量;
label: 类型为string;指定标签列;
categorical_feature: 类型为string;指定我们想要进行模型训练所使用的特征类别;
num_class: 默认值为1,类型为int;仅仅需要在多分类的场合。

附上代码及注释:

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
"""对训练集数据进行划分,分成训练集和验证集,并进行相应的操作"""
from sklearn.model_selection import train_test_split
import lightgbm as lgb
# 数据集划分,切分比例为 8:2
X_train_split, X_val, y_train_split, y_val = train_test_split(X_train, y_train, test_size=0.2)
#转换为Dataset数据格式
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,# <0 显示致命的, =0 显示错误 (警告), >0 显示信息
}

#调用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)



然后是模型的评分,通过采用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)))

附上运行结果(跑了很久www)

最后是模型调参

三种方法:贪心调参、网格搜索、贝叶斯调参
参考Task4文档中代码结果一直报错,所以就没有运行成功,只能继续学习后面再尝试自己撸代码 :cold_face:


总结:看到了很多以前没有涉及的盲点知识,奇怪的知识又增加了 :star_struck: