Task01赛题理解_零心跳信号分类预测

1、赛题理解

1.1 赛题背景

本次新人赛是Datawhale与天池联合发起的0基础入门系列赛事 —— 心跳信号分类预测。
赛题以心电图心跳信号数据为背景，要求选手根据心电图感应数据预测心跳信号所属类别，其中心跳信号对应正常病例以及受不同心律不齐和心肌梗塞影响的病例，这是一个多分类的问题。通过这道赛题来引导大家了解医疗大数据的应用，帮助竞赛新人进行自我练习、自我提高。
比赛地址：https://tianchi.aliyun.com/competition/entrance/531883/introduction

1.2 赛制说明

本次赛事分为两个阶段，分别为正式赛及长期赛。
正式赛（3月12日 - 5月12日）
报名成功后，参赛队伍通过天池平台下载数据，本地调试算法，在线提交结果。若参赛队伍在一天内多次提交结果，新结果版本将覆盖旧版本。
第一阶段（3月15日-5月11日）3月15日16:00提供评测，每天提供2次评测机会，提交后将进行实时评测；排行榜每小时更新，按照评测指标得分从高到低排序；（排行榜将选择选手在本阶段的历史最优成绩进行排名展示，不做最终排名计算）。
5月11日12:00第一阶段提交截止，未产出成绩队伍或未按要求完成实名认证队伍，将被取消第二阶段的参赛资格。
第二阶段（5月12日19:00-22:00）系统将在5月12日19:00提供测试数据，参赛队伍需要再次下载数据文件，本阶段提供2次评测机会，提交截止时间5月12日22:00，赛程期间系统实时评测、整点排名。排行榜将选择参赛队伍在本阶段的历史最优成绩进行排名展示。
正式赛结束后，以榜单成绩作为比赛算法提交成绩依照，TOP15团队提交代码审核，规范详见“代码规范”文档（所提交的代码能够在天池实验室（PAI-DSW探索者版）环境下复现最优成绩），代码提交截止时间5月17日12:00。组委会将审核并剔除只靠人工标注而没有算法贡献或无法通过天池实验室复现最优成绩的队伍，获奖空缺名额后补。

2、赛题概况

2.1 赛题数据

比赛要求参赛选手根据给定的数据集，建立模型，预测不同的心跳信号。赛题以预测心电图心跳信号类别为任务，数据集报名后可见并可下载，该该数据来自某平台心电图数据记录，总数据量超过20万，主要为1列心跳信号序列数据，其中每个样本的信号序列采样频次一致，长度相等。为了保证比赛的公平性，将会从中抽取10万条作为训练集，2万条作为测试集A，2万条作为测试集B，同时会对心跳信号类别（label）信息进行脱敏。
train.csv

• id 为心跳信号分配的唯一标识
• heartbeat_signals 心跳信号序列(数据之间采用“,”进行分隔)
• label 心跳信号类别（0、1、2、3）

testA.csv

• id 心跳信号分配的唯一标识
• heartbeat_signals 心跳信号序列(数据之间采用“,”进行分隔)

2.2 预测指标

选手需提交4种不同心跳信号预测的概率，选手提交结果与实际心跳类型结果进行对比，求预测的概率与真实值差值的绝对值。
具体计算公式如下：
总共有n个病例，针对某一个信号，若真实值为[y1,y2,y3,y4],模型预测概率值为[a1,a2,a3,a4],那么该模型的评价指标abs-sum为 $$abs-sum=\sum _{j=1}^n\sum _{i=1}^4\left|y{}_i-a{}_i\right|$$ 例如，某心跳信号类别为1，通过编码转成[0,1,0,0]，预测不同心跳信号概率为[0.1,0.7,0.1,0.1]，那么这个信号预测结果的abs-sum为 $$abs-sum=\left|0.1-0\right|+\left|0.7-1\right|+\left|0.1-0\right|+\left|0.1-0\right|=0.6$$
多分类算法常见的评估指标如下：
其实多分类的评价指标的计算方式与二分类完全一样，只不过我们计算的是针对于每一类来说的召回率、精确度、准确率和 F1分数。

2.2.1 混淆矩阵（Confuse Matrix）

（1）若一个实例是正类，并且被预测为正类，即为真正类TP(True Positive )
（2）若一个实例是正类，但是被预测为负类，即为假负类FN(False Negative )
（3）若一个实例是负类，但是被预测为正类，即为假正类FP(False Positive )
（4）若一个实例是负类，并且被预测为负类，即为真负类TN(True Negative ）
第一个字母T/F，表示预测的正确与否；第二个字母P/N，表示预测的结果为正例或者负例。如TP就表示预测对了，预测的结果是正例，那它的意思就是把正例预测为了正例。

2.2.2 准确率（Accuracy）

准确率是常用的一个评价指标，但是不适合样本不均衡的情况，医疗数据大部分都是样本不均衡数据。 $$Accuracy=\frac{Correct}{Total}Accuracy=\frac{TP+TN}{TP+TN+FP+FN}$$

2.2.3 精确率（Precision）也叫查准率简写为P

精确率(Precision)是针对预测结果而言的，其含义是在被所有预测为正的样本中实际为正样本的概率在被所有预测为正的样本中实际为正样本的概率，精确率和准确率看上去有些类似，但是是两个完全不同的概念。精确率代表对正样本结果中的预测准确程度，准确率则代表整体的预测准确程度，包括正样本和负样本。 $$Precision=\frac{TP}{TP+FP}$$

2.2.4 召回率（Recall） 也叫查全率 简写为R

召回率(Recall)是针对原样本而言的，其含义是在实际为正的样本中被预测为正样本的概率。 $$Recall=\frac{TP}{TP+FN}$$
下面我们通过一个简单例子来看看精确率和召回率。假设一共有10篇文章，里面4篇是你要找的。根据你的算法模型，你找到了5篇，但实际上在这5篇之中，只有3篇是你真正要找的。
那么算法的精确率是3/5=60%，也就是你找的这5篇，有3篇是真正对的。算法的召回率是3/4=75%，也就是需要找的4篇文章，你找到了其中三篇。以精确率还是以召回率作为评价指标，需要根据具体问题而定。

2.2.5 宏查准率（macro-P）

计算每个样本的精确率然后求平均值 $$macroP=\frac{1}{n}\sum _1^{n}p{}_i$$

2.2.6 宏查全率（macro-R）

计算每个样本的召回率然后求平均值 $$macroR=\frac{1}{n}\sum _1^{n}R{}_i$$

2.2.7 宏F1（macro-F1）

$$macroF1=\frac{2\times macroP\times macroR}{macroP+macroR}$$ 与上面的宏不同，微查准查全，先将多个混淆矩阵的TP,FP,TN,FN对应位置求平均，然后按照P和R的公式求得micro-P和micro-R，最后根据micro-P和micro-R求得micro-F1

2.2.8 微查准率（micro-P）

$$microP=\frac{\overline{TP}}{\overline{TP}\times \overline{FP}}$$

2.2.9 微查全率（micro-R）

$$microR=\frac{\overline{TP}}{\overline{TP}\times \overline{FN}}$$

2.2.10 微F1（micro-F1）

$$microF1=\frac{2\times microP\times microR}{microP+microR}$$

2.3 参赛规则

报名成功后，选手下载数据，在本地调试算法，每天可提交3次结果；
提交后将进行实时评测；每天排行榜更新时间为12:00和20:00，按照评测指标得分从高到低排序；排行榜将选择历史最优成绩进行展示；

2.4 赛题分析

本题为传统的数据挖掘问题，通过数据科学以及机器学习深度学习的办法来进行建模得到结果。
本题为典型的多分类问题，心跳信号一共有4个不同的类别
主要应用xgb、lgb、catboost，以及pandas、numpy、matplotlib、seabon、sklearn、keras等等数据挖掘常用库或者框架来进行数据挖掘任务。

3、代码

import pandas as pd
import numpy as np
import lightgbm as lgb
from sklearn.model_selection import KFold
from sklearn.preprocessing import OneHotEncoder
import warnings

warnings.filterwarnings('ignore')

#数据读取
train = pd.read_csv('./data/train.csv')
test = pd.read_csv('./data/testA.csv')
train.head()



#减少内存使用
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

# 简单预处理
#训练集数据处理
train_list = []


for items in train.values:
    train_list.append([items[0]] + [float(i) for i in items[1].split(',')] + [items[2]])
#pd和np结合使用处理数据
train = pd.DataFrame(np.array(train_list))
#头栏位数据添加
train.columns = ['id'] + ['s_'+str(i) for i in range(len(train_list[0])-2)] + ['label']
train = reduce_mem_usage(train)

test_list=[]
for items in test.values:
    test_list.append([items[0]] + [float(i) for i in items[1].split(',')])

test = pd.DataFrame(np.array(test_list))
test.columns = ['id'] + ['s_'+str(i) for i in range(len(test_list[0])-1)]
test = reduce_mem_usage(test)


# 训练数据/测试数据准备
x_train = train.drop(['id','label'], axis=1)
y_train = train['label']
x_test=test.drop(['id'], axis=1)


# 模型训练结果处理
def abs_sum(y_pre,y_tru):
    y_pre=np.array(y_pre)
    y_tru=np.array(y_tru)
    loss=sum(sum(abs(y_pre-y_tru)))
    return loss

#lgb模型训练
def cv_model(clf, train_x, train_y, test_x, clf_name):
    folds = 5
    seed = 2021
    kf = KFold(n_splits=folds, shuffle=True, random_state=seed)
    test = np.zeros((test_x.shape[0], 4))

    cv_scores = []
    onehot_encoder = OneHotEncoder(sparse=False)
    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': 'multiclass',
                'num_class': 4,
                'num_leaves': 2 ** 5,
                'feature_fraction': 0.8,
                'bagging_fraction': 0.8,
                'bagging_freq': 4,
                'learning_rate': 0.1,
                'seed': seed,
                'nthread': 28,
                'n_jobs': 24,
                'verbose': -1,
            }

            model = clf.train(params,
                              train_set=train_matrix,
                              valid_sets=valid_matrix,
                              num_boost_round=2000,
                              verbose_eval=100,
                              early_stopping_rounds=200)
            val_pred = model.predict(val_x, num_iteration=model.best_iteration)
            test_pred = model.predict(test_x, num_iteration=model.best_iteration)

        val_y = np.array(val_y).reshape(-1, 1)
        val_y = onehot_encoder.fit_transform(val_y)
        print('预测的概率矩阵为：')
        print(test_pred)
        test += test_pred
        score = abs_sum(val_y, val_pred)
        cv_scores.append(score)
        print(cv_scores)
    print("%s_scotrainre_list:" % clf_name, cv_scores)
    print("%s_score_mean:" % clf_name, np.mean(cv_scores))
    print("%s_score_std:" % clf_name, np.std(cv_scores))
    test = test / kf.n_splits

    return test
#lgb函数调用以及返回值
def lgb_model(x_train, y_train, x_test):
    lgb_test = cv_model(lgb, x_train, y_train, x_test, "lgb")
#     return lgb_train, lgb_test
    return  lgb_test
lgb_test = lgb_model(x_train, y_train, x_test)


#按提交格式输出结果数据
temp=pd.DataFrame(lgb_test)
result=pd.read_csv('./data/sample_submit.csv')
result['label_0']=temp[0]
result['label_1']=temp[1]
result['label_2']=temp[2]
result['label_3']=temp[3]
result.to_csv('submit.csv',index=False)

4、任务提交