1、目前分数是融的，前排大佬们不要担心了。

2、目前树模型单模0.675左右，跟前排0.68的单模还是有一定的差距，很佩服单模那么高分的。

3、个人认为树模型在复赛很难搞，没有很深的树模型相关经验的选手，建议集中注意力研究神经网络。

4、对于我这边的树模型来说，最有用的只有userid、feedid、authorid三个id列，估计80%以上的收益都来自这三列，bgm只有一丁点用，诸如descriptionn、ocr等文本信息几乎没啥用，keyword、tag等信息有一点点用，认真研究三个主要id才能拿下这个数据里面绝大部分收益。当然那些没啥用的字段也可能是我没找对用的方法，希望会用的大佬可以透露点信息。

5、树模型的特征具体怎么做，我也不多说废话了，其实大佬们已经说的够多了，随便找以前比赛的树模型开源方案看看也会做了，但是我估计真的去找来看的也没几个，大部分人也只会在群里呻吟：onehot没效果、labelencode没效果之类的话。我在这里开源一份lightgbm的baseline，里面包含一些简单的特征，希望可以启发一下新手们吧。

## lightgbm baseline（注：此份开源是经主办方同意的，未经主办方同意，不能擅自开源） ##

## 线上分数0.645左右 ##

## 此份baseline只适用于新手，不适用于有经验的选手 ##

import pandas as pd

import numpy as np

from tqdm import tqdm

from sklearn.metrics import roc_auc_score

from lightgbm.sklearn import LGBMClassifier

from collections import defaultdict

import gc

import time

pd.set_option('display.max_columns', None)

def reduce_mem(df, cols):

    start_mem = df.memory_usage().sum() / 1024 ** 2

    for col in tqdm(cols):

        col_type = df[col].dtypes

        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)

    end_mem = df.memory_usage().sum() / 1024 ** 2

    print('{:.2f} Mb, {:.2f} Mb ({:.2f} %)'.format(start_mem, end_mem, 100 * (start_mem - end_mem) / start_mem))

    gc.collect()

    return df

## 从官方baseline里面抽出来的评测函数

def uAUC(labels, preds, user_id_list):

    """Calculate user AUC"""

    user_pred = defaultdict(lambda: [])

    user_truth = defaultdict(lambda: [])

    for idx, truth in enumerate(labels):

        user_id = user_id_list[idx]

        pred = preds[idx]

        truth = labels[idx]

        user_pred[user_id].append(pred)

        user_truth[user_id].append(truth)

    user_flag = defaultdict(lambda: False)

    for user_id in set(user_id_list):

        truths = user_truth[user_id]

        flag = False

        # 若全是正样本或全是负样本，则flag为False

        for i in range(len(truths) - 1):

            if truths[i] != truths[i + 1]:

                flag = True

                break

        user_flag[user_id] = flag

    total_auc = 0.0

    size = 0.0

    for user_id in user_flag:

        if user_flag[user_id]:

            auc = roc_auc_score(np.asarray(user_truth[user_id]), np.asarray(user_pred[user_id]))

            total_auc += auc 

            size += 1.0

    user_auc = float(total_auc)/size

    return user_auc

y_list = ['read_comment', 'like', 'click_avatar', 'forward', 'favorite', 'comment', 'follow']

max_day = 15

## 读取训练集

train = pd.read_csv('data/user_action.csv')

print(train.shape)

for y in y_list:

    print(y, train[y].mean())

## 读取测试集

test = pd.read_csv('data/test_a.csv')

test['date_'] = max_day

print(test.shape)

## 合并处理

df = pd.concat([train, test], axis=0, ignore_index=True)

print(df.head(3))

## 读取视频信息表

feed_info = pd.read_csv('data/feed_info.csv')

## 此份baseline只保留这三列

feed_info = feed_info[[

    'feedid', 'authorid', 'videoplayseconds'

]]

df = df.merge(feed_info, on='feedid', how='left')

## 视频时长是秒，转换成毫秒，才能与play、stay做运算

df['videoplayseconds'] *= 1000

## 是否观看完视频（其实不用严格按大于关系，也可以按比例，比如观看比例超过0.9就算看完）

df['is_finish'] = (df['play'] >= df['videoplayseconds']).astype('int8')

df['play_times'] = df['play'] / df['videoplayseconds']

play_cols = [

    'is_finish', 'play_times', 'play', 'stay'

]

## 统计历史5天的曝光、转化、视频观看等情况（此处的转化率统计其实就是target encoding）

n_day = 5

for stat_cols in tqdm([

    ['userid'],

    ['feedid'],

    ['authorid'],

    ['userid', 'authorid']

]):

    f = '_'.join(stat_cols)

    stat_df = pd.DataFrame()

    for target_day in range(2, max_day + 1):

        left, right = max(target_day - n_day, 1), target_day - 1

        tmp = df[((df['date_'] >= left) & (df['date_'] <= right))].reset_index(drop=True)

        tmp['date_'] = target_day

        tmp['{}_{}day_count'.format(f, n_day)] = tmp.groupby(stat_cols)['date_'].transform('count')

        g = tmp.groupby(stat_cols)

        tmp['{}_{}day_finish_rate'.format(f, n_day)] = g[play_cols[0]].transform('mean')

        feats = ['{}_{}day_count'.format(f, n_day), '{}_{}day_finish_rate'.format(f, n_day)]

        for x in play_cols[1:]:

            for stat in ['max', 'mean']:

                tmp['{}_{}day_{}_{}'.format(f, n_day, x, stat)] = g[x].transform(stat)

                feats.append('{}_{}day_{}_{}'.format(f, n_day, x, stat))

        for y in y_list[:4]:

            tmp['{}_{}day_{}_sum'.format(f, n_day, y)] = g[y].transform('sum')

            tmp['{}_{}day_{}_mean'.format(f, n_day, y)] = g[y].transform('mean')

            feats.extend(['{}_{}day_{}_sum'.format(f, n_day, y), '{}_{}day_{}_mean'.format(f, n_day, y)])

        tmp = tmp[stat_cols + feats + ['date_']].drop_duplicates(stat_cols + ['date_']).reset_index(drop=True)

        stat_df = pd.concat([stat_df, tmp], axis=0, ignore_index=True)

        del g, tmp

    df = df.merge(stat_df, on=stat_cols + ['date_'], how='left')

    del stat_df

    gc.collect()

## 全局信息统计，包括曝光、偏好等，略有穿越，但问题不大，可以上分，只要注意不要对userid-feedid做组合统计就行

for f in tqdm(['userid', 'feedid', 'authorid']):

    df[f + '_count'] = df[f].map(df[f].value_counts())

for f1, f2 in tqdm([

    ['userid', 'feedid'],

    ['userid', 'authorid']

]):

    df['{}_in_{}_nunique'.format(f1, f2)] = df.groupby(f2)[f1].transform('nunique')

    df['{}_in_{}_nunique'.format(f2, f1)] = df.groupby(f1)[f2].transform('nunique')

for f1, f2 in tqdm([

    ['userid', 'authorid']

]):

    df['{}_{}_count'.format(f1, f2)] = df.groupby([f1, f2])['date_'].transform('count')

    df['{}_in_{}_count_prop'.format(f1, f2)] = df['{}_{}_count'.format(f1, f2)] / (df[f2 + '_count'] + 1)

    df['{}_in_{}_count_prop'.format(f2, f1)] = df['{}_{}_count'.format(f1, f2)] / (df[f1 + '_count'] + 1)

df['videoplayseconds_in_userid_mean'] = df.groupby('userid')['videoplayseconds'].transform('mean')

df['videoplayseconds_in_authorid_mean'] = df.groupby('authorid')['videoplayseconds'].transform('mean')

df['feedid_in_authorid_nunique'] = df.groupby('authorid')['feedid'].transform('nunique')

## 内存够用的不需要做这一步

df = reduce_mem(df, [f for f in df.columns if f not in ['date_'] + play_cols + y_list])

train = df[~df['read_comment'].isna()].reset_index(drop=True)

test = df[df['read_comment'].isna()].reset_index(drop=True)

cols = [f for f in df.columns if f not in ['date_'] + play_cols + y_list]

print(train[cols].shape)

trn_x = train[train['date_'] < 14].reset_index(drop=True)

val_x = train[train['date_'] == 14].reset_index(drop=True)

##################### 线下验证 #####################

uauc_list = []

r_list = []

for y in y_list[:4]:

    print('=========', y, '=========')

    t = time.time()

    clf = LGBMClassifier(

        learning_rate=0.05,

        n_estimators=5000,

        num_leaves=63,

        subsample=0.8,

        colsample_bytree=0.8,

        random_state=2021,

        metric='None'

    )

    clf.fit(

        trn_x[cols], trn_x[y],

        eval_set=[(val_x[cols], val_x[y])],

        eval_metric='auc',

        early_stopping_rounds=100,

        verbose=50

    )

    val_x[y + '_score'] = clf.predict_proba(val_x[cols])[:, 1]

    val_uauc = uAUC(val_x[y], val_x[y + '_score'], val_x['userid'])

    uauc_list.append(val_uauc)

    print(val_uauc)

    r_list.append(clf.best_iteration_)

    print('runtime: {}\n'.format(time.time() - t))

weighted_uauc = 0.4 * uauc_list[0] + 0.3 * uauc_list[1] + 0.2 * uauc_list[2] + 0.1 * uauc_list[3]

print(uauc_list)

print(weighted_uauc)

##################### 全量训练 #####################

r_dict = dict(zip(y_list[:4], r_list))

for y in y_list[:4]:

    print('=========', y, '=========')

    t = time.time()

    clf = LGBMClassifier(

        learning_rate=0.05,

        n_estimators=r_dict[y],

        num_leaves=63,

        subsample=0.8,

        colsample_bytree=0.8,

        random_state=2021

    )

    clf.fit(

        train[cols], train[y],

        eval_set=[(train[cols], train[y])],

        early_stopping_rounds=r_dict[y],

        verbose=100

    )

    test[y] = clf.predict_proba(test[cols])[:, 1]

    print('runtime: {}\n'.format(time.time() - t))

test[['userid', 'feedid'] + y_list[:4]].to_csv(

    'sub_%.6f_%.6f_%.6f_%.6f_%.6f.csv' % (weighted_uauc, uauc_list[0], uauc_list[1], uauc_list[2], uauc_list[3]),

    index=False

)

最后祝大家都能取得好成绩！