快手-发粉漏丝.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "179E3C64C6D247D2866F1CE7E776D441",
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# 模型1--许景益模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "75A3AD2021FA47AE9011FAC6F5DBEDA6"
   },
   "outputs": [],
   "source": [
    "!mkdir /home/kesci/work/features/\n",
    "!mkdir /home/kesci/work/basic/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "B432DE9ADF29479D8D95E6EFB022DD75"
   },
   "outputs": [],
   "source": [
    "-*- coding:utf-8 -*-\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from sklearn import metrics\n",
    "'''\n",
    "一些基础的工具或环境函数\n",
    "'''\n",
    "\n",
    "def data_path():\n",
    "    return '/mnt/datasets/fusai/'\n",
    "\n",
    "def basic_path():\n",
    "    return '/home/kesci/work/basic/'\n",
    "\n",
    "def features_path():\n",
    "    return '/home/kesci/work/features/'\n",
    "\n",
    "def split_data(data, columns, start_day, end_day):\n",
    "    data = data[(data[columns] >= start_day) & (data[columns] <= end_day)]\n",
    "    return data \n",
    "\n",
    "'''\n",
    "下面返回的lsit说明下：\n",
    "以1-10天为起始特征区间，用于返回需要划多少天\n",
    "例如划1-18，就返回18-10=8，\n",
    "划测试集1-30，就返回30-10=20\n",
    "需要少划几个对应修改就好\n",
    "... 要修改起始特征区间，修改下面的 ups 和 downs 函数\n",
    "''' \n",
    "def features_addday_list():\n",
    "    return [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 20]\n",
    "\n",
    "def ups():\n",
    "    return 1\n",
    "\n",
    "def downs():\n",
    "    return 10\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "35B9D8B1791740D5AD3D7B80D6FDD5D1"
   },
   "outputs": [],
   "source": [
    "'''\n",
    "存放标签数据\n",
    "划几个窗口存几列标签\n",
    "'''\n",
    "launch = pd.read_csv(data_path()+'app_launch_log.txt', sep='\\t', header=None,\n",
    "                  names=['user_id', 'launch_day'],\n",
    "                  dtype={0: np.uint32, 1: np.uint8})\n",
    "register = pd.read_csv(data_path() + 'user_register_log.txt', sep='\\t', header=None,\n",
    "                  names=['user_id', 'register_day', 'register_type', 'device_type'],\n",
    "                  dtype={0: np.uint32, 1: np.uint8, 2: np.uint16, 3: np.uint16})\n",
    "\n",
    "def get_label_list(start_day, end_day):\n",
    "    result = split_data(launch, 'launch_day', start_day, end_day)['user_id'].drop_duplicates()\n",
    "    return pd.Series(result)\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    up = downs()+1\n",
    "    down = downs()+7\n",
    "    data = register.loc[:, ['user_id']]\n",
    "    for label_num in range(len(features_addday_list())-1):\n",
    "        label_list = get_label_list(up + label_num, down + label_num)\n",
    "        label_name = 'label_' + str(label_num)\n",
    "        data[label_name] = data['user_id'].isin(label_list).replace({True: 1, False: 0})\n",
    "    data.to_csv(basic_path()+'data_label.csv', index=None)\n",
    "    print('data_label.csv complete!')\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "908D4C43DB82447F8EFBD15CA341D393"
   },
   "outputs": [],
   "source": [
    "'''\n",
    "注册表特征\n",
    "'''\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    up = ups()\n",
    "    down = downs()\n",
    "\n",
    "    for feature_num in features_addday_list():\n",
    "        # 读数据\n",
    "        register = pd.read_csv(data_path()+'user_register_log.txt', sep='\\t', header=None,\n",
    "                   names=['user_id','register_day','register_type','device_type'],\n",
    "                   dtype={0: np.uint32, 1: np.uint8, 2: np.uint8, 3: np.uint16})\n",
    "\n",
    "        # 基础变量定义\n",
    "        feature_start = up + 0\n",
    "        feature_end = down + feature_num\n",
    "\n",
    "        '''\n",
    "        result_data 是存放特征的结果文件\n",
    "        feature_data 用于存放被提取的原文件\n",
    "        *****_tmp  存放临时特征文件\n",
    "        类似文件后续不再注释\n",
    "        '''\n",
    "        result_data = split_data(register, 'register_day', 1, feature_end)\n",
    "        feature_data = split_data(register, 'register_day', feature_start, feature_end)\n",
    "        del register\n",
    "\n",
    "        # # # # # # # # #\n",
    "        # 提特征(已经包含设备类型、设备类型)\n",
    "        # \n",
    "        # 特征区间最大天数减去注册日期\n",
    "        result_data['maxday_red_registerday'] = max(feature_data['register_day']) - feature_data['register_day']\n",
    "        result_data = result_data.fillna(max(feature_data['register_day']))\n",
    "\n",
    "        del result_data['register_day']\n",
    "\n",
    "        # # # # # # # # #\n",
    "        # 保存结果\n",
    "        result_file_name = 'register_feature_'+str(feature_num)+'.csv'\n",
    "        result_data.to_csv(features_path()+result_file_name, index=None)\n",
    "        print(result_file_name+' complete!')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "7D037E68D37742F79FAA8328D56B16BC"
   },
   "outputs": [],
   "source": [
    "'''\n",
    "视频创建特征\n",
    "'''\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    up = ups()\n",
    "    down = downs()\n",
    "\n",
    "    for feature_num in features_addday_list():\n",
    "        # 读数据\n",
    "        register = pd.read_csv(data_path() + 'user_register_log.txt', sep='\\t', header=None,\n",
    "                               names=['user_id', 'register_day', 'register_type', 'device_type'],\n",
    "                               dtype={0: np.uint32, 1: np.uint8, 2: np.uint16, 3: np.uint16})\n",
    "        create = pd.read_csv(data_path() + 'video_create_log.txt', sep='\\t', header=None,\n",
    "                             names=['user_id', 'create_day'],\n",
    "                             dtype={0: np.uint32, 1: np.uint8})\n",
    "\n",
    "        # 基础变量定义\n",
    "        feature_start = up\n",
    "        feature_end = down + feature_num\n",
    "        result_data = split_data(register, 'register_day', 1, feature_end).loc[:, ['user_id', 'register_day']]\n",
    "        feature_data = split_data(create, 'create_day', feature_start, feature_end)\n",
    "        del register\n",
    "        del create\n",
    "\n",
    "        # # # # # # # # #\n",
    "        # 提特征\n",
    "        #\n",
    "        # 用户创建视频计数\n",
    "        feature_tmp = pd.pivot_table(feature_data, index='user_id', values='create_day',\n",
    "                                     aggfunc='count').reset_index().rename(columns={\"create_day\": 'create_count'})\n",
    "        result_data = pd.merge(result_data, feature_tmp, on='user_id', how='left')\n",
    "        result_data = result_data.fillna(0)\n",
    "\n",
    "        # 用户创建视频的 平均/最大/最小日期 与 注册日期/最大时间 的时间差\n",
    "        feature_tmp = pd.pivot_table(feature_data, index='user_id', values='create_day',\n",
    "                                     aggfunc='mean').reset_index().rename(columns={\"create_day\": 'create_mean'})\n",
    "        result_data = pd.merge(result_data, feature_tmp, on='user_id', how='left')\n",
    "        result_data['createmean_red_register'] = result_data['create_mean'] - result_data['register_day']\n",
    "        result_data['maxday_red_createmean'] = max(result_data['register_day']) - result_data['create_mean']\n",
    "\n",
    "        feature_tmp = pd.pivot_table(feature_data, index='user_id', values='create_day',\n",
    "                                     aggfunc=np.max).reset_index().rename(columns={\"create_day\": 'create_max'})\n",
    "        result_data = pd.merge(result_data, feature_tmp, on='user_id', how='left')\n",
    "        result_data['createmax_red_register'] = result_data['create_max'] - result_data['register_day']\n",
    "        result_data['maxday_red_createmax'] = max(result_data['register_day']) - result_data['create_max']\n",
    "\n",
    "        feature_tmp = pd.pivot_table(feature_data, index='user_id', values='create_day',\n",
    "                                     aggfunc=np.min).reset_index().rename(columns={\"create_day\": 'create_min'})\n",
    "        result_data = pd.merge(result_data, feature_tmp, on='user_id', how='left')\n",
    "        result_data['createmin_red_register'] = result_data['create_min'] - result_data['register_day']\n",
    "        result_data['maxday_red_createmin'] = max(result_data['register_day']) - result_data['create_min']\n",
    "        result_data = result_data.fillna(-1)\n",
    "\n",
    "        # 创建最大间隔\n",
    "        result_data['max_red_min_create'] = result_data['create_max'] - result_data['create_min']\n",
    "\n",
    "        # 最后一天是否有活动\n",
    "        result_data['create_at_lastday'] = pd.Series(\n",
    "            result_data['create_max'] == max(feature_data['create_day'])).replace({True: 1, False: 0})\n",
    "\n",
    "        # 均值/最大/最小 天数处理\n",
    "        result_data['create_mean'] = max(feature_data['create_day']) - result_data['create_mean']\n",
    "        result_data['create_max'] = max(feature_data['create_day']) - result_data['create_max']\n",
    "        result_data['create_min'] = max(feature_data['create_day']) - result_data['create_min']\n",
    "\n",
    "        # 间隔的 方差/均值\n",
    "        feature_data_tmp = feature_data.drop_duplicates(['user_id', 'create_day']).sort_values(\n",
    "            by=['user_id', 'create_day'])\n",
    "        feature_data_tmp['create_gap'] = np.array(feature_data_tmp['create_day']) - np.array(\n",
    "            feature_data_tmp.tail(1).append(feature_data_tmp.head(len(feature_data_tmp) - 1))['create_day'])\n",
    "\n",
    "        feature_tmp = pd.pivot_table(feature_data_tmp, index='user_id', values='create_gap',\n",
    "                                     aggfunc=(lambda a: np.average(a[1:]))).reset_index().rename(\n",
    "            columns={\"create_gap\": 'create_gap_mean'})\n",
    "        result_data = pd.merge(result_data, feature_tmp, on='user_id', how='left')\n",
    "        feature_tmp = pd.pivot_table(feature_data_tmp, index='user_id', values='create_gap',\n",
    "                                     aggfunc=(lambda a: np.var(a[1:]))).reset_index().rename(\n",
    "            columns={\"create_gap\": 'create_gap_var'})\n",
    "        result_data = pd.merge(result_data, feature_tmp, on='user_id', how='left')\n",
    "        result_data = result_data.fillna(0)\n",
    "\n",
    "        # 是否一直连续/连续到结束\n",
    "        result_data['always_create'] = [1 if i == 1 else 0 for i in result_data['create_gap_mean']]\n",
    "        tmp = (result_data['create_at_lastday'] == 1).replace({True: 1, False: 0})\n",
    "        result_data['always_create_atlast'] = tmp * result_data['always_create']\n",
    "        del tmp\n",
    "\n",
    "        # 创建日期的 方差/峰度/偏度\n",
    "        feature_tmp = pd.pivot_table(feature_data, index='user_id', values='create_day',\n",
    "                                     aggfunc=np.var).reset_index().rename(columns={\"create_day\": 'create_var'})\n",
    "        result_data = pd.merge(result_data, feature_tmp, on='user_id', how='left')\n",
    "        feature_tmp = pd.pivot_table(feature_data, index='user_id', values='create_day',\n",
    "                                     aggfunc=pd.Series.kurt).reset_index().rename(columns={\"create_day\": 'create_kurt'})\n",
    "        result_data = pd.merge(result_data, feature_tmp, on='user_id', how='left')\n",
    "        feature_tmp = pd.pivot_table(feature_data, index='user_id', values='create_day',\n",
    "                                     aggfunc=pd.Series.skew).reset_index().rename(columns={\"create_day\": 'create_skew'})\n",
    "        result_data = pd.merge(result_data, feature_tmp, on='user_id', how='left')\n",
    "        result_data = result_data.fillna(0)\n",
    "\n",
    "        # 求一天最大创建数\n",
    "        feature_data['max_create_in_oneday'] = 0\n",
    "        feature_tmp = pd.pivot_table(feature_data, index=['user_id', 'create_day'], values='max_create_in_oneday',\n",
    "                                     aggfunc='count').reset_index()\n",
    "        feature_tmp = pd.DataFrame(feature_tmp.groupby(['user_id'])['max_create_in_oneday'].max()).reset_index()\n",
    "        result_data = pd.merge(result_data, feature_tmp, on='user_id', how='left')\n",
    "        result_data.fillna(0, inplace=True)\n",
    "\n",
    "        del result_data['register_day']\n",
    "\n",
    "        # # # # # # # #\n",
    "        # 保存结果\n",
    "        result_file_name = 'create_feature_' + str(feature_num) + '.csv'\n",
    "        result_data.to_csv(features_path() + result_file_name, index=None)\n",
    "        print(result_file_name + ' complete!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "EB0C0C83E6D84408853D462DE274DAAC"
   },
   "outputs": [],
   "source": [
    "'''\n",
    "登录表特征\n",
    "'''\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    up = ups()\n",
    "    down = downs()\n",
    "\n",
    "    for feature_num in features_addday_list():\n",
    "        # 读数据\n",
    "        register = pd.read_csv(data_path()+'user_register_log.txt', sep='\\t', header=None,\n",
    "                    names=['user_id','register_day','register_type','device_type'],\n",
    "                    dtype={0: np.uint32, 1: np.uint8, 2: np.uint16, 3: np.uint16})\n",
    "        launch = pd.read_csv(data_path() + 'app_launch_log.txt', sep='\\t', header=None,\n",
    "                    names=['user_id', 'launch_day'],\n",
    "                    dtype={0: np.uint32, 1: np.uint8})\n",
    "\n",
    "        # 基础变量定义\n",
    "        feature_start = up\n",
    "        feature_end = down + feature_num\n",
    "        result_data = split_data(register, 'register_day', 1, feature_end).loc[:, ['user_id', 'register_day']]\n",
    "        feature_data = split_data(launch, 'launch_day', feature_start, feature_end)\n",
    "        del register\n",
    "        del launch\n",
    "\n",
    "        # # # # # # # # #\n",
    "        # 提特征\n",
    "        #\n",
    "        # 登录计数/登录率\n",
    "        feature_tmp = pd.pivot_table(feature_data, index='user_id', values='launch_day', \n",
    "                                     aggfunc='count').reset_index().rename(columns={\"launch_day\": 'launch_count'})\n",
    "        result_data = pd.merge(result_data, feature_tmp, on='user_id', how='left')\n",
    "        distance = (max(feature_data['launch_day']) - min(feature_data['launch_day']))\n",
    "        result_data['launch_ratio'] = result_data['launch_count'] * 1.0 / distance\n",
    "        result_data = result_data.fillna(0)\n",
    "\n",
    "        # 登录的 平均/最大/最小日期 与 注册日期/最大时间 的时间差\n",
    "        feature_tmp = pd.pivot_table(feature_data, index='user_id', values='launch_day', \n",
    "                                     aggfunc='mean').reset_index().rename(columns={\"launch_day\": 'launch_mean'})\n",
    "        result_data = pd.merge(result_data, feature_tmp, on='user_id', how='left')\n",
    "        result_data['launchmean_red_register'] = result_data['launch_mean'] - result_data['register_day']\n",
    "        result_data['maxday_red_launchmean'] = max(result_data['register_day']) - result_data['launch_mean']\n",
    "\n",
    "        feature_tmp = pd.pivot_table(feature_data, index='user_id', values='launch_day', \n",
    "                                     aggfunc=np.max).reset_index().rename(columns={\"launch_day\": 'launch_max'})\n",
    "        result_data = pd.merge(result_data, feature_tmp, on='user_id', how='left')\n",
    "        result_data['launchmax_red_register'] = result_data['launch_max'] - result_data['register_day']\n",
    "        result_data['maxday_red_launchmax'] = max(result_data['register_day']) - result_data['launch_max']\n",
    "\n",
    "        feature_tmp = pd.pivot_table(feature_data, index='user_id', values='launch_day',\n",
    "                                     aggfunc=np.min).reset_index().rename(columns={\"launch_day\": 'launch_min'})\n",
    "        result_data = pd.merge(result_data, feature_tmp, on='user_id', how='left')\n",
    "        # result_data['launchmin_red_register'] = result_data['launch_min'] - result_data['register_day']\n",
    "        result_data['maxday_red_launchmin'] = max(result_data['register_day']) - result_data['launch_min']\n",
    "        result_data = result_data.fillna(-1)\n",
    "\n",
    "        # 登录最大与最小差\n",
    "        result_data['max_red_min_launch'] = result_data['launch_max'] - result_data['launch_min']\n",
    "\n",
    "        # 最后一天是否有活动\n",
    "        result_data['launch_at_lastday'] = pd.Series(result_data['launch_max'] == max(feature_data['launch_day'])).replace({True: 1, False: 0})\n",
    "\n",
    "        # 均值/最大/最小 天数处理\n",
    "        result_data['launch_mean'] = max(feature_data['launch_day']) - result_data['launch_mean']\n",
    "        result_data['launch_max'] = max(feature_data['launch_day']) - result_data['launch_max']\n",
    "        result_data['launch_min'] = max(feature_data['launch_day']) - result_data['launch_min']\n",
    "\n",
    "        # 间隔的 方差/均值/最大\n",
    "        feature_data_tmp = feature_data.drop_duplicates(['user_id', 'launch_day']).sort_values(by=['user_id', 'launch_day'])\n",
    "        feature_data_tmp['launch_gap'] = np.array(feature_data_tmp['launch_day']) - np.array(\n",
    "            feature_data_tmp.tail(1).append(feature_data_tmp.head(len(feature_data_tmp) - 1))['launch_day'])\n",
    "\n",
    "        feature_tmp = pd.pivot_table(feature_data_tmp, index='user_id', values='launch_gap',\n",
    "                                     aggfunc=(lambda a: np.average(a[1:]))).reset_index().rename(columns={\"launch_gap\": 'launch_gap_mean'})\n",
    "        result_data = pd.merge(result_data, feature_tmp, on='user_id', how='left')\n",
    "        feature_tmp = pd.pivot_table(feature_data_tmp, index='user_id', values='launch_gap',\n",
    "                                     aggfunc=(lambda a: np.var(a[1:]))).reset_index().rename(columns={\"launch_gap\": 'launch_gap_var'})\n",
    "        result_data = pd.merge(result_data, feature_tmp, on='user_id', how='left')\n",
    "        feature_tmp = pd.pivot_table(feature_data_tmp, index='user_id', values='launch_gap',\n",
    "                                     aggfunc=(lambda a: np.max(a[1:]))).reset_index().rename(columns={\"launch_gap\": 'launch_gap_max'})\n",
    "        result_data = pd.merge(result_data, feature_tmp, on='user_id', how='left')\n",
    "        result_data = result_data.fillna(0)\n",
    "\n",
    "        # 是否一直连续/连续到结束\n",
    "        result_data['always_launch'] = [1 if i == 1 else 0 for i in result_data['launch_gap_mean']]\n",
    "        tmp = (result_data['launch_at_lastday'] == 1).replace({True: 1, False: 0})\n",
    "        result_data['always_launch_atlast'] = tmp * result_data['always_launch']\n",
    "        del tmp\n",
    "\n",
    "        # 登录日期的 方差/峰度/偏度\n",
    "        feature_tmp = pd.pivot_table(feature_data, index='user_id', values='launch_day',\n",
    "                                     aggfunc=np.var).reset_index().rename(columns={\"launch_day\": 'launch_var'})\n",
    "        result_data = pd.merge(result_data, feature_tmp, on='user_id', how='left')\n",
    "        feature_tmp = pd.pivot_table(feature_data, index='user_id', values='launch_day',\n",
    "                                     aggfunc=pd.Series.kurt).reset_index().rename(columns={\"launch_day\": 'launch_kurt'})\n",
    "        result_data = pd.merge(result_data, feature_tmp, on='user_id', how='left')\n",
    "        feature_tmp = pd.pivot_table(feature_data, index='user_id', values='launch_day',\n",
    "                                     aggfunc=pd.Series.skew).reset_index().rename(columns={\"launch_day\": 'launch_skew'})\n",
    "        result_data = pd.merge(result_data, feature_tmp, on='user_id', how='left')\n",
    "        result_data = result_data.fillna(0)\n",
    "\n",
    "        del result_data['register_day']\n",
    "        \n",
    "        # # # # # # # #\n",
    "        # 保存结果\n",
    "        result_file_name = 'launch_feature_' + str(feature_num) + '.csv'\n",
    "        result_data.to_csv(features_path() + result_file_name, index=None)\n",
    "        print(result_file_name + ' complete!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "F8379C27B3F7424689D77A3DF2FEFFDA"
   },
   "outputs": [],
   "source": [
    "'''\n",
    "活动表特征\n",
    "\n",
    "另外\n",
    "\n",
    "这个真的非常慢\n",
    "'''\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    up = ups()\n",
    "    down = downs()\n",
    "\n",
    "    for feature_num in features_addday_list():\n",
    "        # 读数据\n",
    "        register = pd.read_csv(data_path() + 'user_register_log.txt', sep='\\t', header=None,\n",
    "                               names=['user_id', 'register_day', 'register_type', 'device_type'],\n",
    "                               dtype={0: np.uint32, 1: np.uint8, 2: np.uint16, 3: np.uint16})\n",
    "        activity = pd.read_csv(data_path() + 'user_activity_log.txt', sep='\\t', header=None,\n",
    "                               names=['user_id', 'act_day', 'page', 'video_id', 'author_id', 'action_type'],\n",
    "                               dtype={0: np.uint32, 1: np.uint8, 2: np.uint8, 3: np.uint32, 4: np.uint32, 5: np.uint8})\n",
    "\n",
    "        # 基础变量定义\n",
    "        feature_start = up\n",
    "        feature_end = down + feature_num\n",
    "        result_data = split_data(register, 'register_day', 1, feature_end).loc[:, ['user_id', 'register_day']]\n",
    "        feature_data = split_data(activity, 'act_day', feature_start, feature_end)\n",
    "        del register\n",
    "        del activity\n",
    "\n",
    "        # # # # # # # # #\n",
    "        # 提特征\n",
    "        #\n",
    "        # 活动计数\n",
    "        feature_tmp = pd.pivot_table(feature_data, index='user_id', values='act_day',\n",
    "                                     aggfunc='count').reset_index().rename(columns={\"act_day\": 'act_count'})\n",
    "        result_data = pd.merge(result_data, feature_tmp, on='user_id', how='left')\n",
    "        result_data = result_data.fillna(0)\n",
    "\n",
    "        # 活动的 平均/最大/最小日期 与 注册日期/最大时间 的时间差\n",
    "        feature_tmp = pd.pivot_table(feature_data, index='user_id', values='act_day',\n",
    "                                     aggfunc='mean').reset_index().rename(columns={\"act_day\": 'act_mean'})\n",
    "        result_data = pd.merge(result_data, feature_tmp, on='user_id', how='left')\n",
    "        result_data['actmean_red_register'] = result_data['act_mean'] - result_data['register_day']\n",
    "        result_data['maxday_red_actmean'] = max(result_data['register_day']) - result_data['act_mean']\n",
    "\n",
    "        feature_tmp = pd.pivot_table(feature_data, index='user_id', values='act_day',\n",
    "                                     aggfunc=np.max).reset_index().rename(columns={\"act_day\": 'act_max'})\n",
    "        result_data = pd.merge(result_data, feature_tmp, on='user_id', how='left')\n",
    "        result_data['actmax_red_register'] = result_data['act_max'] - result_data['register_day']\n",
    "        result_data['maxday_red_actmax'] = max(result_data['register_day']) - result_data['act_max']\n",
    "\n",
    "        feature_tmp = pd.pivot_table(feature_data, index='user_id', values='act_day',\n",
    "                                     aggfunc=np.min).reset_index().rename(columns={\"act_day\": 'act_min'})\n",
    "        result_data = pd.merge(result_data, feature_tmp, on='user_id', how='left')\n",
    "        result_data['actmin_red_register'] = result_data['act_min'] - result_data['register_day']\n",
    "        result_data['maxday_red_actmin'] = max(result_data['register_day']) - result_data['act_min']\n",
    "        result_data = result_data.fillna(-1)\n",
    "\n",
    "        # 最后一天是否有活动\n",
    "        result_data['act_at_lastday'] = pd.Series(result_data['act_max'] == max(feature_data['act_day'])).replace({True: 1, False: 0})\n",
    "\n",
    "        # 均值/最大/最小 天数处理\n",
    "        result_data['act_mean'] = max(feature_data['act_day']) - result_data['act_mean']\n",
    "        result_data['act_max'] = max(feature_data['act_day']) - result_data['act_max']\n",
    "        result_data['act_min'] = max(feature_data['act_day']) - result_data['act_min']\n",
    "\n",
    "        # 观看自己计数\n",
    "        feature_tmp = pd.pivot_table(feature_data[feature_data['user_id'] == feature_data['author_id']],\n",
    "                                     index='user_id', values='author_id', aggfunc='count').reset_index().rename(columns={\"author_id\": 'act_self_count'})\n",
    "        result_data = pd.merge(result_data, feature_tmp, on='user_id', how='left')\n",
    "        result_data = result_data.fillna(0)\n",
    "\n",
    "        # 活动日期的 方差/峰度/偏度\n",
    "        feature_tmp = pd.pivot_table(feature_data, index='user_id', values='act_day',\n",
    "                                     aggfunc=np.var).reset_index().rename(columns={\"act_day\": 'act_var'})\n",
    "        result_data = pd.merge(result_data, feature_tmp, on='user_id', how='left')\n",
    "        feature_tmp = pd.pivot_table(feature_data, index='user_id', values='act_day',\n",
    "                                     aggfunc=pd.Series.kurt).reset_index().rename(columns={\"act_day\": 'act_kurt'})\n",
    "        result_data = pd.merge(result_data, feature_tmp, on='user_id', how='left')\n",
    "        feature_tmp = pd.pivot_table(feature_data, index='user_id', values='act_day',\n",
    "                                     aggfunc=pd.Series.skew).reset_index().rename(columns={\"act_day\": 'act_skew'})\n",
    "        result_data = pd.merge(result_data, feature_tmp, on='user_id', how='left')\n",
    "        result_data = result_data.fillna(0)\n",
    "\n",
    "        # action 的 计数/率\n",
    "        feature_tmp = feature_data.loc[:, ['user_id', 'action_type', 'act_day']].groupby(['user_id', 'action_type']).count().reset_index().rename(columns={\"act_day\": 'action_count'})\n",
    "        for i in range(6):\n",
    "            fea_name = 'action_' + str(i) + '_count'\n",
    "            action_tmp = feature_tmp[feature_tmp['action_type'] == i].loc[:, ['user_id', 'action_count']].rename(columns={\"action_count\": fea_name})\n",
    "            result_data = pd.merge(result_data, action_tmp, how='left', on='user_id')\n",
    "        result_data = result_data.fillna(0)\n",
    "        result_data['action_all'] = (result_data['action_0_count']+result_data['action_1_count']+\n",
    "                                     result_data['action_2_count']+result_data['action_3_count']+\n",
    "                                     result_data['action_4_count']+result_data['action_5_count']).replace(0, 1)\n",
    "        for i in range(6):\n",
    "            fea_name = 'action_' + str(i) + '_ratio'\n",
    "            fea_name_2 = 'action_' + str(i) + '_count'\n",
    "            result_data[fea_name] = result_data[fea_name_2] / result_data['action_all']\n",
    "\n",
    "        # page 的 计数/率\n",
    "        feature_tmp = feature_data.loc[:, ['user_id', 'page', 'act_day']].groupby(['user_id', 'page']).count().reset_index().rename(columns={\"act_day\": 'page_count'})\n",
    "        for i in range(5):\n",
    "            fea_name = 'page_' + str(i) + '_count'\n",
    "            page_tmp = feature_tmp[feature_tmp['page'] == i].loc[:, ['user_id', 'page_count']].rename(columns={\"page_count\": fea_name})\n",
    "            result_data = pd.merge(result_data, page_tmp, how='left', on='user_id')\n",
    "        result_data = result_data.fillna(0)\n",
    "        result_data['page_all'] = (result_data['page_0_count']+result_data['page_1_count']+\n",
    "                                   result_data['page_2_count']+result_data['page_3_count']+\n",
    "                                   result_data['page_4_count']).replace(0, 1)\n",
    "        for i in range(5):\n",
    "            fea_name = 'page_' + str(i) + '_ratio'\n",
    "            fea_name_2 = 'page_' + str(i) + '_count'\n",
    "            result_data[fea_name] = result_data[fea_name_2] / result_data['page_all']\n",
    "\n",
    "        del result_data['page_all']\n",
    "        del result_data['action_all']\n",
    "        del result_data['register_day']\n",
    "\n",
    "        # # # # # # # #\n",
    "        # 保存结果\n",
    "        result_file_name = 'activity_feature_' + str(feature_num) + '.csv'\n",
    "        result_data.to_csv(features_path() + result_file_name, index=None)\n",
    "        print(result_file_name + ' complete!')'''\n",
    "活动表特征\n",
    "\n",
    "另外\n",
    "\n",
    "这个真的非常慢\n",
    "'''\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    up = ups()\n",
    "    down = downs()\n",
    "\n",
    "    for feature_num in features_addday_list():\n",
    "        # 读数据\n",
    "        register = pd.read_csv(data_path() + 'user_register_log.txt', sep='\\t', header=None,\n",
    "                               names=['user_id', 'register_day', 'register_type', 'device_type'],\n",
    "                               dtype={0: np.uint32, 1: np.uint8, 2: np.uint16, 3: np.uint16})\n",
    "        activity = pd.read_csv(data_path() + 'user_activity_log.txt', sep='\\t', header=None,\n",
    "                               names=['user_id', 'act_day', 'page', 'video_id', 'author_id', 'action_type'],\n",
    "                               dtype={0: np.uint32, 1: np.uint8, 2: np.uint8, 3: np.uint32, 4: np.uint32, 5: np.uint8})\n",
    "\n",
    "        # 基础变量定义\n",
    "        feature_start = up\n",
    "        feature_end = down + feature_num\n",
    "        result_data = split_data(register, 'register_day', 1, feature_end).loc[:, ['user_id', 'register_day']]\n",
    "        feature_data = split_data(activity, 'act_day', feature_start, feature_end)\n",
    "        del register\n",
    "        del activity\n",
    "\n",
    "        # # # # # # # # #\n",
    "        # 提特征\n",
    "        #\n",
    "        # 活动计数\n",
    "        feature_tmp = pd.pivot_table(feature_data, index='user_id', values='act_day',\n",
    "                                     aggfunc='count').reset_index().rename(columns={\"act_day\": 'act_count'})\n",
    "        result_data = pd.merge(result_data, feature_tmp, on='user_id', how='left')\n",
    "        result_data = result_data.fillna(0)\n",
    "\n",
    "        # 活动的 平均/最大/最小日期 与 注册日期/最大时间 的时间差\n",
    "        feature_tmp = pd.pivot_table(feature_data, index='user_id', values='act_day',\n",
    "                                     aggfunc='mean').reset_index().rename(columns={\"act_day\": 'act_mean'})\n",
    "        result_data = pd.merge(result_data, feature_tmp, on='user_id', how='left')\n",
    "        result_data['actmean_red_register'] = result_data['act_mean'] - result_data['register_day']\n",
    "        result_data['maxday_red_actmean'] = max(result_data['register_day']) - result_data['act_mean']\n",
    "\n",
    "        feature_tmp = pd.pivot_table(feature_data, index='user_id', values='act_day',\n",
    "                                     aggfunc=np.max).reset_index().rename(columns={\"act_day\": 'act_max'})\n",
    "        result_data = pd.merge(result_data, feature_tmp, on='user_id', how='left')\n",
    "        result_data['actmax_red_register'] = result_data['act_max'] - result_data['register_day']\n",
    "        result_data['maxday_red_actmax'] = max(result_data['register_day']) - result_data['act_max']\n",
    "\n",
    "        feature_tmp = pd.pivot_table(feature_data, index='user_id', values='act_day',\n",
    "                                     aggfunc=np.min).reset_index().rename(columns={\"act_day\": 'act_min'})\n",
    "        result_data = pd.merge(result_data, feature_tmp, on='user_id', how='left')\n",
    "        result_data['actmin_red_register'] = result_data['act_min'] - result_data['register_day']\n",
    "        result_data['maxday_red_actmin'] = max(result_data['register_day']) - result_data['act_min']\n",
    "        result_data = result_data.fillna(-1)\n",
    "\n",
    "        # 最后一天是否有活动\n",
    "        result_data['act_at_lastday'] = pd.Series(result_data['act_max'] == max(feature_data['act_day'])).replace({True: 1, False: 0})\n",
    "\n",
    "        # 均值/最大/最小 天数处理\n",
    "        result_data['act_mean'] = max(feature_data['act_day']) - result_data['act_mean']\n",
    "        result_data['act_max'] = max(feature_data['act_day']) - result_data['act_max']\n",
    "        result_data['act_min'] = max(feature_data['act_day']) - result_data['act_min']\n",
    "\n",
    "        # 观看自己计数\n",
    "        feature_tmp = pd.pivot_table(feature_data[feature_data['user_id'] == feature_data['author_id']],\n",
    "                                     index='user_id', values='author_id', aggfunc='count').reset_index().rename(columns={\"author_id\": 'act_self_count'})\n",
    "        result_data = pd.merge(result_data, feature_tmp, on='user_id', how='left')\n",
    "        result_data = result_data.fillna(0)\n",
    "\n",
    "        # 活动日期的 方差/峰度/偏度\n",
    "        feature_tmp = pd.pivot_table(feature_data, index='user_id', values='act_day',\n",
    "                                     aggfunc=np.var).reset_index().rename(columns={\"act_day\": 'act_var'})\n",
    "        result_data = pd.merge(result_data, feature_tmp, on='user_id', how='left')\n",
    "        feature_tmp = pd.pivot_table(feature_data, index='user_id', values='act_day',\n",
    "                                     aggfunc=pd.Series.kurt).reset_index().rename(columns={\"act_day\": 'act_kurt'})\n",
    "        result_data = pd.merge(result_data, feature_tmp, on='user_id', how='left')\n",
    "        feature_tmp = pd.pivot_table(feature_data, index='user_id', values='act_day',\n",
    "                                     aggfunc=pd.Series.skew).reset_index().rename(columns={\"act_day\": 'act_skew'})\n",
    "        result_data = pd.merge(result_data, feature_tmp, on='user_id', how='left')\n",
    "        result_data = result_data.fillna(0)\n",
    "\n",
    "        # action 的 计数/率\n",
    "        feature_tmp = feature_data.loc[:, ['user_id', 'action_type', 'act_day']].groupby(['user_id', 'action_type']).count().reset_index().rename(columns={\"act_day\": 'action_count'})\n",
    "        for i in range(6):\n",
    "            fea_name = 'action_' + str(i) + '_count'\n",
    "            action_tmp = feature_tmp[feature_tmp['action_type'] == i].loc[:, ['user_id', 'action_count']].rename(columns={\"action_count\": fea_name})\n",
    "            result_data = pd.merge(result_data, action_tmp, how='left', on='user_id')\n",
    "        result_data = result_data.fillna(0)\n",
    "        result_data['action_all'] = (result_data['action_0_count']+result_data['action_1_count']+\n",
    "                                     result_data['action_2_count']+result_data['action_3_count']+\n",
    "                                     result_data['action_4_count']+result_data['action_5_count']).replace(0, 1)\n",
    "        for i in range(6):\n",
    "            fea_name = 'action_' + str(i) + '_ratio'\n",
    "            fea_name_2 = 'action_' + str(i) + '_count'\n",
    "            result_data[fea_name] = result_data[fea_name_2] / result_data['action_all']\n",
    "\n",
    "        # page 的 计数/率\n",
    "        feature_tmp = feature_data.loc[:, ['user_id', 'page', 'act_day']].groupby(['user_id', 'page']).count().reset_index().rename(columns={\"act_day\": 'page_count'})\n",
    "        for i in range(5):\n",
    "            fea_name = 'page_' + str(i) + '_count'\n",
    "            page_tmp = feature_tmp[feature_tmp['page'] == i].loc[:, ['user_id', 'page_count']].rename(columns={\"page_count\": fea_name})\n",
    "            result_data = pd.merge(result_data, page_tmp, how='left', on='user_id')\n",
    "        result_data = result_data.fillna(0)\n",
    "        result_data['page_all'] = (result_data['page_0_count']+result_data['page_1_count']+\n",
    "                                   result_data['page_2_count']+result_data['page_3_count']+\n",
    "                                   result_data['page_4_count']).replace(0, 1)\n",
    "        for i in range(5):\n",
    "            fea_name = 'page_' + str(i) + '_ratio'\n",
    "            fea_name_2 = 'page_' + str(i) + '_count'\n",
    "            result_data[fea_name] = result_data[fea_name_2] / result_data['page_all']\n",
    "\n",
    "        del result_data['page_all']\n",
    "        del result_data['action_all']\n",
    "        del result_data['register_day']\n",
    "\n",
    "        # # # # # # # #\n",
    "        # 保存结果\n",
    "        result_file_name = 'activity_feature_' + str(feature_num) + '.csv'\n",
    "        result_data.to_csv(features_path() + result_file_name, index=None)\n",
    "        print(result_file_name + ' complete!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "D699409D99294B088F2C0B5F64EA5D88"
   },
   "outputs": [],
   "source": [
    "'''\n",
    "跑模型\n",
    "'''\n",
    "import xgboost as xgb\n",
    "\n",
    "def get_feature(num, data_label=None):\n",
    "    register = pd.read_csv(features_path()+'register_feature_'+str(num)+'.csv')\n",
    "    create = pd.read_csv(features_path()+'create_feature_'+str(num)+'.csv')\n",
    "    launch = pd.read_csv(features_path()+'launch_feature_'+str(num)+'.csv')\n",
    "    activity = pd.read_csv(features_path()+'activity_feature_'+str(num)+'.csv')\n",
    "    feature = pd.merge(register, launch, on='user_id', how='left')\n",
    "    feature = pd.merge(feature, activity, on='user_id', how='left')\n",
    "    feature = pd.merge(feature, create, on='user_id', how='left')\n",
    "    del register\n",
    "    del create\n",
    "    del launch\n",
    "\n",
    "    if data_label is not None:\n",
    "        label_name = 'label_' + str(num)\n",
    "        data_label_tmp = data_label[data_label['user_id'].isin(feature['user_id'])]\n",
    "        data_label_tmp = data_label.loc[:, ['user_id', label_name]]\n",
    "        data_label_tmp.columns = ['user_id', 'label']\n",
    "        feature = pd.merge(feature, data_label_tmp, on='user_id', how='left')\n",
    "    return feature\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    # 读标签数据\n",
    "    data_label = pd.read_csv(basic_path()+'data_label.csv')\n",
    "\n",
    "    # 读特征数据\n",
    "    test_x = get_feature('20')\n",
    "    train_x = get_feature('0', data_label).append(get_feature('1', data_label)).append(\n",
    "        get_feature('2', data_label)).append(get_feature('3', data_label)).append(\n",
    "        get_feature('4', data_label)).append(get_feature('5', data_label)).append(\n",
    "        get_feature('6', data_label)).append(get_feature('7', data_label)).append(\n",
    "        get_feature('8', data_label)).append(get_feature('9', data_label)).append(\n",
    "        get_feature('10', data_label))\n",
    "\n",
    "    train_y = train_x['label']\n",
    "    test_user = test_x['user_id']\n",
    "\n",
    "    del train_x['user_id']\n",
    "    del test_x['user_id']\n",
    "    del train_x['label']\n",
    "   \n",
    "    # XGBOOST 训练\n",
    "    dtrain = xgb.DMatrix(train_x, label=train_y)\n",
    "    dtest = xgb.DMatrix(test_x)\n",
    "    params = {\n",
    "        # 'objective': 'binary:logistic',\n",
    "        'objective': 'rank:pairwise',\n",
    "        'eta': 0.03,\n",
    "        'max_depth': 5,\n",
    "        'colsample_bytree': 0.8,\n",
    "        'subsample': 0.8,\n",
    "        'min_child_weight': 16,\n",
    "        'silent': 1,\n",
    "    }\n",
    "    bst = xgb.train(params, dtrain, 1500, watchlist = [(dtrain, 'train')])\n",
    "    pre_label = bst.predict(dtest)\n",
    "\n",
    "    # 生成结果文件\n",
    "    pd.DataFrame(data={0:test_user, 1:pre_label}).to_csv('/home/kesci/xjy_model.txt', index=None, header=None)\n",
    "\n",
    "\t\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "6F0B9DE3160C4FDB8015EE77B669F2A1"
   },
   "outputs": [],
   "source": [
    "# 模型2--余薇模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "2B195A6ED6EE4A7281DFCE1A53B04CA0"
   },
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "# -*- coding: utf-8 -*-\n",
    "\"\"\"\n",
    "Created on Mon May 28 12:20:47 2018\n",
    "\n",
    "@author: yuwei\n",
    "\"\"\"\n",
    "\n",
    "\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import xgboost as xgb\n",
    "import gc\n",
    "\n",
    "\n",
    "#%%\n",
    "def loadData():\n",
    "    \"读取数据集\"\n",
    "    #覆盖完全注册信息表\n",
    "    app = pd.read_table(r'/mnt/datasets/fusai/app_launch_log.txt',names=['user_id','day'],encoding='utf-8',sep='\\t',)\n",
    "    #覆盖注册信息表43708\n",
    "    user_act = pd.read_table(r'/mnt/datasets/fusai/user_activity_log.txt',names=['user_id','day','page','video_id','author_id','action_type'],encoding='utf-8',sep='\\t')\n",
    "    #注册信息表共计51709\n",
    "    user_reg = pd.read_table(r'/mnt/datasets/fusai/user_register_log.txt',names=['user_id','register_day','register_type','device_type'],encoding='utf-8',sep='\\t')\n",
    "    #仅覆盖7606\n",
    "    vedio = pd.read_table(r'/mnt/datasets/fusai/video_create_log.txt',names=['user_id','day'],encoding='utf-8',sep='\\t')\n",
    "    return app,user_act,user_reg,vedio\n",
    "#%%\n",
    "def makeLabel(app,user_act,user_reg,vedio):\n",
    "    \"打标\"\n",
    "    \n",
    "    \"测试集\"\n",
    "    #10-30号 未来七天31-71\n",
    "    '''\n",
    "    te_app = app[app.day>=10];te_user_act = user_act[user_act.day>=10]\n",
    "    te_user_reg = user_reg[user_reg.register_day>=10];te_vedio = vedio[vedio.day>=10]\n",
    "    te1 = te_app[['user_id']].drop_duplicates()\n",
    "    te2 = te_user_act[['user_id']].drop_duplicates()\n",
    "    te3 = te_user_reg[['user_id']].drop_duplicates()\n",
    "    te4 = te_vedio[['user_id']].drop_duplicates()\n",
    "    te = pd.concat([te1,te2,te3,te4],axis=0)\n",
    "    test = te[['user_id']].drop_duplicates()\n",
    "    '''\n",
    "    test = user_reg[['user_id']].drop_duplicates()\n",
    " \n",
    "    \"验证集-1\"\n",
    "    #3-23号\n",
    "    tr_app = app[(app.day>=1)&(app.day<=23)];tr_user_act = user_act[(user_act.day>=1)&(user_act.day<=23)]\n",
    "    tr_user_reg = user_reg[(user_reg.register_day>=1)&(user_reg.register_day<=23)];tr_vedio = vedio[(vedio.day>=1)&(vedio.day<=23)]\n",
    "    tr1 = tr_app[['user_id']].drop_duplicates()\n",
    "    tr2 = tr_user_act[['user_id']].drop_duplicates()\n",
    "    tr3 = tr_user_reg[['user_id']].drop_duplicates()\n",
    "    tr4 = tr_vedio[['user_id']].drop_duplicates()\n",
    "    tr = pd.concat([tr1,tr2,tr3,tr4],axis=0)\n",
    "    train1 = tr[['user_id']].drop_duplicates()\n",
    "    #未来7天：24-30号\n",
    "    tr_app = app[(app.day>=24)&(app.day<=30)];tr_user_act = user_act[(user_act.day>=24)&(user_act.day<=30)]\n",
    "    tr_user_reg = user_reg[(user_reg.register_day>=24)&(user_reg.register_day<=30)];tr_vedio = vedio[(vedio.day>=24)&(vedio.day<=30)]\n",
    "    tr1 = tr_app[['user_id']].drop_duplicates()\n",
    "    tr2 = tr_user_act[['user_id']].drop_duplicates()\n",
    "    tr3 = tr_user_reg[['user_id']].drop_duplicates()\n",
    "    tr4 = tr_vedio[['user_id']].drop_duplicates()\n",
    "    tr = pd.concat([tr1,tr2,tr3,tr4],axis=0)\n",
    "    train1_true = tr[['user_id']].drop_duplicates()\n",
    "    #左连接打标\n",
    "    train1_true['label'] = 1\n",
    "    train1 = pd.merge(train1,train1_true,on='user_id',how='left')\n",
    "    train1= train1.fillna(0)\n",
    "    del train1_true;gc.collect();\n",
    "\n",
    "    \"训练集-2\"\n",
    "    tr_app = app[(app.day>=1)&(app.day<=22)];tr_user_act = user_act[(user_act.day>=1)&(user_act.day<=22)]\n",
    "    tr_user_reg = user_reg[(user_reg.register_day>=1)&(user_reg.register_day<=22)];tr_vedio = vedio[(vedio.day>=1)&(vedio.day<=22)]\n",
    "    tr1 = tr_app[['user_id']].drop_duplicates()\n",
    "    tr2 = tr_user_act[['user_id']].drop_duplicates()\n",
    "    tr3 = tr_user_reg[['user_id']].drop_duplicates()\n",
    "    tr4 = tr_vedio[['user_id']].drop_duplicates()\n",
    "    tr = pd.concat([tr1,tr2,tr3,tr4],axis=0)\n",
    "    train2 = tr[['user_id']].drop_duplicates()\n",
    "    #未来7天：23-29号\n",
    "    tr_app = app[(app.day>=23)&(app.day<=29)];tr_user_act = user_act[(user_act.day>=23)&(user_act.day<=29)]\n",
    "    tr_user_reg = user_reg[(user_reg.register_day>=23)&(user_reg.register_day<=29)];tr_vedio = vedio[(vedio.day>=23)&(vedio.day<=29)]\n",
    "    tr1 = tr_app[['user_id']].drop_duplicates()\n",
    "    tr2 = tr_user_act[['user_id']].drop_duplicates()\n",
    "    tr3 = tr_user_reg[['user_id']].drop_duplicates()\n",
    "    tr4 = tr_vedio[['user_id']].drop_duplicates()\n",
    "    tr = pd.concat([tr1,tr2,tr3,tr4],axis=0)\n",
    "    train2_true = tr[['user_id']].drop_duplicates()\n",
    "    #左连接打标\n",
    "    train2_true['label'] = 1\n",
    "    train2 = pd.merge(train2,train2_true,on='user_id',how='left')\n",
    "    train2= train2.fillna(0)\n",
    "    del train2_true;gc.collect();\n",
    "\n",
    "    \n",
    "    \"训练集-3\"\n",
    "    tr_app = app[(app.day>=1)&(app.day<=21)];tr_user_act = user_act[(user_act.day>=1)&(user_act.day<=21)]\n",
    "    tr_user_reg = user_reg[(user_reg.register_day>=1)&(user_reg.register_day<=21)];tr_vedio = vedio[(vedio.day>=1)&(vedio.day<=21)]\n",
    "    tr1 = tr_app[['user_id']].drop_duplicates()\n",
    "    tr2 = tr_user_act[['user_id']].drop_duplicates()\n",
    "    tr3 = tr_user_reg[['user_id']].drop_duplicates()\n",
    "    tr4 = tr_vedio[['user_id']].drop_duplicates()\n",
    "    tr = pd.concat([tr1,tr2,tr3,tr4],axis=0)\n",
    "    train3 = tr[['user_id']].drop_duplicates()\n",
    "    #未来7天：22-28号\n",
    "    tr_app = app[(app.day>=22)&(app.day<=28)];tr_user_act = user_act[(user_act.day>=22)&(user_act.day<=28)]\n",
    "    tr_user_reg = user_reg[(user_reg.register_day>=22)&(user_reg.register_day<=28)];tr_vedio = vedio[(vedio.day>=22)&(vedio.day<=28)]\n",
    "    tr1 = tr_app[['user_id']].drop_duplicates()\n",
    "    tr2 = tr_user_act[['user_id']].drop_duplicates()\n",
    "    tr3 = tr_user_reg[['user_id']].drop_duplicates()\n",
    "    tr4 = tr_vedio[['user_id']].drop_duplicates()\n",
    "    tr = pd.concat([tr1,tr2,tr3,tr4],axis=0)\n",
    "    train3_true = tr[['user_id']].drop_duplicates()\n",
    "    #左连接打标\n",
    "    train3_true['label'] = 1\n",
    "    train3 = pd.merge(train3,train3_true,on='user_id',how='left')\n",
    "    train3= train3.fillna(0)\n",
    "    del train3_true;gc.collect();\n",
    "\n",
    "    \"训练集-4\"\n",
    "    tr_app = app[(app.day>=1)&(app.day<=20)];tr_user_act = user_act[(user_act.day>=1)&(user_act.day<=20)]\n",
    "    tr_user_reg = user_reg[(user_reg.register_day>=1)&(user_reg.register_day<=20)];tr_vedio = vedio[(vedio.day>=1)&(vedio.day<=20)]\n",
    "    tr1 = tr_app[['user_id']].drop_duplicates()\n",
    "    tr2 = tr_user_act[['user_id']].drop_duplicates()\n",
    "    tr3 = tr_user_reg[['user_id']].drop_duplicates()\n",
    "    tr4 = tr_vedio[['user_id']].drop_duplicates()\n",
    "    tr = pd.concat([tr1,tr2,tr3,tr4],axis=0)\n",
    "    train4 = tr[['user_id']].drop_duplicates()\n",
    "    #未来7天：21-27号\n",
    "    tr_app = app[(app.day>=21)&(app.day<=27)];tr_user_act = user_act[(user_act.day>=21)&(user_act.day<=27)]\n",
    "    tr_user_reg = user_reg[(user_reg.register_day>=21)&(user_reg.register_day<=27)];tr_vedio = vedio[(vedio.day>=21)&(vedio.day<=27)]\n",
    "    tr1 = tr_app[['user_id']].drop_duplicates()\n",
    "    tr2 = tr_user_act[['user_id']].drop_duplicates()\n",
    "    tr3 = tr_user_reg[['user_id']].drop_duplicates()\n",
    "    tr4 = tr_vedio[['user_id']].drop_duplicates()\n",
    "    tr = pd.concat([tr1,tr2,tr3,tr4],axis=0)\n",
    "    train4_true = tr[['user_id']].drop_duplicates()\n",
    "    #左连接打标\n",
    "    train4_true['label'] = 1\n",
    "    train4 = pd.merge(train4,train4_true,on='user_id',how='left')\n",
    "    train4= train4.fillna(0)\n",
    "    del train4_true;gc.collect();\n",
    "    \n",
    "    \"训练集-5\"\n",
    "    tr_app = app[(app.day>=1)&(app.day<=19)];tr_user_act = user_act[(user_act.day>=1)&(user_act.day<=19)]\n",
    "    tr_user_reg = user_reg[(user_reg.register_day>=1)&(user_reg.register_day<=19)];tr_vedio = vedio[(vedio.day>=1)&(vedio.day<=19)]\n",
    "    tr1 = tr_app[['user_id']].drop_duplicates()\n",
    "    tr2 = tr_user_act[['user_id']].drop_duplicates()\n",
    "    tr3 = tr_user_reg[['user_id']].drop_duplicates()\n",
    "    tr4 = tr_vedio[['user_id']].drop_duplicates()\n",
    "    tr = pd.concat([tr1,tr2,tr3,tr4],axis=0)\n",
    "    train5 = tr[['user_id']].drop_duplicates()\n",
    "    #未来7天：21-27号\n",
    "    tr_app = app[(app.day>=20)&(app.day<=26)];tr_user_act = user_act[(user_act.day>=20)&(user_act.day<=26)]\n",
    "    tr_user_reg = user_reg[(user_reg.register_day>=20)&(user_reg.register_day<=26)];tr_vedio = vedio[(vedio.day>=20)&(vedio.day<=26)]\n",
    "    tr1 = tr_app[['user_id']].drop_duplicates()\n",
    "    tr2 = tr_user_act[['user_id']].drop_duplicates()\n",
    "    tr3 = tr_user_reg[['user_id']].drop_duplicates()\n",
    "    tr4 = tr_vedio[['user_id']].drop_duplicates()\n",
    "    tr = pd.concat([tr1,tr2,tr3,tr4],axis=0)\n",
    "    train5_true = tr[['user_id']].drop_duplicates()\n",
    "    #左连接打标\n",
    "    train5_true['label'] = 1\n",
    "    train5 = pd.merge(train5,train5_true,on='user_id',how='left')\n",
    "    train5 = train5.fillna(0)\n",
    "    del train5_true;gc.collect();    \n",
    "\n",
    "    \"训练集-6\"\n",
    "    tr_app = app[(app.day>=1)&(app.day<=18)];tr_user_act = user_act[(user_act.day>=1)&(user_act.day<=18)]\n",
    "    tr_user_reg = user_reg[(user_reg.register_day>=1)&(user_reg.register_day<=18)];tr_vedio = vedio[(vedio.day>=1)&(vedio.day<=18)]\n",
    "    tr1 = tr_app[['user_id']].drop_duplicates()\n",
    "    tr2 = tr_user_act[['user_id']].drop_duplicates()\n",
    "    tr3 = tr_user_reg[['user_id']].drop_duplicates()\n",
    "    tr4 = tr_vedio[['user_id']].drop_duplicates()\n",
    "    tr = pd.concat([tr1,tr2,tr3,tr4],axis=0)\n",
    "    train6 = tr[['user_id']].drop_duplicates()\n",
    "    #未来7天：21-27号\n",
    "    tr_app = app[(app.day>=19)&(app.day<=25)];tr_user_act = user_act[(user_act.day>=19)&(user_act.day<=25)]\n",
    "    tr_user_reg = user_reg[(user_reg.register_day>=19)&(user_reg.register_day<=25)];tr_vedio = vedio[(vedio.day>=19)&(vedio.day<=25)]\n",
    "    tr1 = tr_app[['user_id']].drop_duplicates()\n",
    "    tr2 = tr_user_act[['user_id']].drop_duplicates()\n",
    "    tr3 = tr_user_reg[['user_id']].drop_duplicates()\n",
    "    tr4 = tr_vedio[['user_id']].drop_duplicates()\n",
    "    tr = pd.concat([tr1,tr2,tr3,tr4],axis=0)\n",
    "    train6_true = tr[['user_id']].drop_duplicates()\n",
    "    #左连接打标\n",
    "    train6_true['label'] = 1\n",
    "    train6 = pd.merge(train6,train6_true,on='user_id',how='left')\n",
    "    train6 = train6.fillna(0)\n",
    "    del train6_true;gc.collect();\n",
    "    \n",
    "    \"训练集-7\"\n",
    "    tr_app = app[(app.day>=1)&(app.day<=17)];tr_user_act = user_act[(user_act.day>=1)&(user_act.day<=17)]\n",
    "    tr_user_reg = user_reg[(user_reg.register_day>=1)&(user_reg.register_day<=17)];tr_vedio = vedio[(vedio.day>=1)&(vedio.day<=17)]\n",
    "    tr1 = tr_app[['user_id']].drop_duplicates()\n",
    "    tr2 = tr_user_act[['user_id']].drop_duplicates()\n",
    "    tr3 = tr_user_reg[['user_id']].drop_duplicates()\n",
    "    tr4 = tr_vedio[['user_id']].drop_duplicates()\n",
    "    tr = pd.concat([tr1,tr2,tr3,tr4],axis=0)\n",
    "    train7 = tr[['user_id']].drop_duplicates()\n",
    "    #未来7天：21-27号\n",
    "    tr_app = app[(app.day>=18)&(app.day<=24)];tr_user_act = user_act[(user_act.day>=18)&(user_act.day<=24)]\n",
    "    tr_user_reg = user_reg[(user_reg.register_day>=18)&(user_reg.register_day<=24)];tr_vedio = vedio[(vedio.day>=18)&(vedio.day<=24)]\n",
    "    tr1 = tr_app[['user_id']].drop_duplicates()\n",
    "    tr2 = tr_user_act[['user_id']].drop_duplicates()\n",
    "    tr3 = tr_user_reg[['user_id']].drop_duplicates()\n",
    "    tr4 = tr_vedio[['user_id']].drop_duplicates()\n",
    "    tr = pd.concat([tr1,tr2,tr3,tr4],axis=0)\n",
    "    train7_true = tr[['user_id']].drop_duplicates()\n",
    "    #左连接打标\n",
    "    train7_true['label'] = 1\n",
    "    train7 = pd.merge(train7,train7_true,on='user_id',how='left')\n",
    "    train7 = train7.fillna(0)\n",
    "    del train7_true;gc.collect();\n",
    "    \n",
    "    \"训练集-8\"\n",
    "    tr_app = app[(app.day>=1)&(app.day<=16)];tr_user_act = user_act[(user_act.day>=1)&(user_act.day<=16)]\n",
    "    tr_user_reg = user_reg[(user_reg.register_day>=1)&(user_reg.register_day<=16)];tr_vedio = vedio[(vedio.day>=1)&(vedio.day<=16)]\n",
    "    tr1 = tr_app[['user_id']].drop_duplicates()\n",
    "    tr2 = tr_user_act[['user_id']].drop_duplicates()\n",
    "    tr3 = tr_user_reg[['user_id']].drop_duplicates()\n",
    "    tr4 = tr_vedio[['user_id']].drop_duplicates()\n",
    "    tr = pd.concat([tr1,tr2,tr3,tr4],axis=0)\n",
    "    train8 = tr[['user_id']].drop_duplicates()\n",
    "    #未来7天：21-27号\n",
    "    tr_app = app[(app.day>=17)&(app.day<=23)];tr_user_act = user_act[(user_act.day>=17)&(user_act.day<=23)]\n",
    "    tr_user_reg = user_reg[(user_reg.register_day>=17)&(user_reg.register_day<=23)];tr_vedio = vedio[(vedio.day>=17)&(vedio.day<=23)]\n",
    "    tr1 = tr_app[['user_id']].drop_duplicates()\n",
    "    tr2 = tr_user_act[['user_id']].drop_duplicates()\n",
    "    tr3 = tr_user_reg[['user_id']].drop_duplicates()\n",
    "    tr4 = tr_vedio[['user_id']].drop_duplicates()\n",
    "    tr = pd.concat([tr1,tr2,tr3,tr4],axis=0)\n",
    "    train8_true = tr[['user_id']].drop_duplicates()\n",
    "    #左连接打标\n",
    "    train8_true['label'] = 1\n",
    "    train8 = pd.merge(train8,train8_true,on='user_id',how='left')\n",
    "    train8 = train8.fillna(0)\n",
    "    del train8_true;gc.collect();\n",
    "    \n",
    "    \"训练集-9\"\n",
    "    tr_app = app[(app.day>=1)&(app.day<=15)];tr_user_act = user_act[(user_act.day>=1)&(user_act.day<=15)]\n",
    "    tr_user_reg = user_reg[(user_reg.register_day>=1)&(user_reg.register_day<=15)];tr_vedio = vedio[(vedio.day>=1)&(vedio.day<=15)]\n",
    "    tr1 = tr_app[['user_id']].drop_duplicates()\n",
    "    tr2 = tr_user_act[['user_id']].drop_duplicates()\n",
    "    tr3 = tr_user_reg[['user_id']].drop_duplicates()\n",
    "    tr4 = tr_vedio[['user_id']].drop_duplicates()\n",
    "    tr = pd.concat([tr1,tr2,tr3,tr4],axis=0)\n",
    "    train9 = tr[['user_id']].drop_duplicates()\n",
    "    #未来7天：21-27号\n",
    "    tr_app = app[(app.day>=16)&(app.day<=22)];tr_user_act = user_act[(user_act.day>=16)&(user_act.day<=22)]\n",
    "    tr_user_reg = user_reg[(user_reg.register_day>=16)&(user_reg.register_day<=22)];tr_vedio = vedio[(vedio.day>=16)&(vedio.day<=22)]\n",
    "    tr1 = tr_app[['user_id']].drop_duplicates()\n",
    "    tr2 = tr_user_act[['user_id']].drop_duplicates()\n",
    "    tr3 = tr_user_reg[['user_id']].drop_duplicates()\n",
    "    tr4 = tr_vedio[['user_id']].drop_duplicates()\n",
    "    tr = pd.concat([tr1,tr2,tr3,tr4],axis=0)\n",
    "    train9_true = tr[['user_id']].drop_duplicates()\n",
    "    #左连接打标\n",
    "    train9_true['label'] = 1\n",
    "    train9 = pd.merge(train9,train9_true,on='user_id',how='left')\n",
    "    train9 = train9.fillna(0)\n",
    "    del train9_true;gc.collect();\n",
    "    \n",
    "    \"训练集-10\"\n",
    "    tr_app = app[(app.day>=1)&(app.day<=14)];tr_user_act = user_act[(user_act.day>=1)&(user_act.day<=14)]\n",
    "    tr_user_reg = user_reg[(user_reg.register_day>=1)&(user_reg.register_day<=14)];tr_vedio = vedio[(vedio.day>=1)&(vedio.day<=14)]\n",
    "    tr1 = tr_app[['user_id']].drop_duplicates()\n",
    "    tr2 = tr_user_act[['user_id']].drop_duplicates()\n",
    "    tr3 = tr_user_reg[['user_id']].drop_duplicates()\n",
    "    tr4 = tr_vedio[['user_id']].drop_duplicates()\n",
    "    tr = pd.concat([tr1,tr2,tr3,tr4],axis=0)\n",
    "    train10 = tr[['user_id']].drop_duplicates()\n",
    "    #未来7天：21-27号\n",
    "    tr_app = app[(app.day>=15)&(app.day<=21)];tr_user_act = user_act[(user_act.day>=15)&(user_act.day<=21)]\n",
    "    tr_user_reg = user_reg[(user_reg.register_day>=15)&(user_reg.register_day<=21)];tr_vedio = vedio[(vedio.day>=15)&(vedio.day<=21)]\n",
    "    tr1 = tr_app[['user_id']].drop_duplicates()\n",
    "    tr2 = tr_user_act[['user_id']].drop_duplicates()\n",
    "    tr3 = tr_user_reg[['user_id']].drop_duplicates()\n",
    "    tr4 = tr_vedio[['user_id']].drop_duplicates()\n",
    "    tr = pd.concat([tr1,tr2,tr3,tr4],axis=0)\n",
    "    train10_true = tr[['user_id']].drop_duplicates()\n",
    "    #左连接打标\n",
    "    train10_true['label'] = 1\n",
    "    train10 = pd.merge(train10,train10_true,on='user_id',how='left')\n",
    "    train10 = train10.fillna(0)\n",
    "    del train10_true;gc.collect();    \n",
    "    \n",
    "    \"训练集-11\"\n",
    "    tr_app = app[(app.day>=1)&(app.day<=13)];tr_user_act = user_act[(user_act.day>=1)&(user_act.day<=13)]\n",
    "    tr_user_reg = user_reg[(user_reg.register_day>=1)&(user_reg.register_day<=13)];tr_vedio = vedio[(vedio.day>=1)&(vedio.day<=13)]\n",
    "    tr1 = tr_app[['user_id']].drop_duplicates()\n",
    "    tr2 = tr_user_act[['user_id']].drop_duplicates()\n",
    "    tr3 = tr_user_reg[['user_id']].drop_duplicates()\n",
    "    tr4 = tr_vedio[['user_id']].drop_duplicates()\n",
    "    tr = pd.concat([tr1,tr2,tr3,tr4],axis=0)\n",
    "    train11 = tr[['user_id']].drop_duplicates()\n",
    "    #未来7天：21-27号\n",
    "    tr_app = app[(app.day>=14)&(app.day<=20)];tr_user_act = user_act[(user_act.day>=14)&(user_act.day<=20)]\n",
    "    tr_user_reg = user_reg[(user_reg.register_day>=14)&(user_reg.register_day<=20)];tr_vedio = vedio[(vedio.day>=14)&(vedio.day<=20)]\n",
    "    tr1 = tr_app[['user_id']].drop_duplicates()\n",
    "    tr2 = tr_user_act[['user_id']].drop_duplicates()\n",
    "    tr3 = tr_user_reg[['user_id']].drop_duplicates()\n",
    "    tr4 = tr_vedio[['user_id']].drop_duplicates()\n",
    "    tr = pd.concat([tr1,tr2,tr3,tr4],axis=0)\n",
    "    train11_true = tr[['user_id']].drop_duplicates()\n",
    "    #左连接打标\n",
    "    train11_true['label'] = 1\n",
    "    train11 = pd.merge(train11,train11_true,on='user_id',how='left')\n",
    "    train11 = train11.fillna(0)\n",
    "    del train11_true;gc.collect();\n",
    "    \n",
    "    \"训练集-12\"\n",
    "    tr_app = app[(app.day>=1)&(app.day<=12)];tr_user_act = user_act[(user_act.day>=1)&(user_act.day<=12)]\n",
    "    tr_user_reg = user_reg[(user_reg.register_day>=1)&(user_reg.register_day<=12)];tr_vedio = vedio[(vedio.day>=1)&(vedio.day<=12)]\n",
    "    tr1 = tr_app[['user_id']].drop_duplicates()\n",
    "    tr2 = tr_user_act[['user_id']].drop_duplicates()\n",
    "    tr3 = tr_user_reg[['user_id']].drop_duplicates()\n",
    "    tr4 = tr_vedio[['user_id']].drop_duplicates()\n",
    "    tr = pd.concat([tr1,tr2,tr3,tr4],axis=0)\n",
    "    train12 = tr[['user_id']].drop_duplicates()\n",
    "    #未来7天：21-27号\n",
    "    tr_app = app[(app.day>=13)&(app.day<=19)];tr_user_act = user_act[(user_act.day>=13)&(user_act.day<=19)]\n",
    "    tr_user_reg = user_reg[(user_reg.register_day>=13)&(user_reg.register_day<=19)];tr_vedio = vedio[(vedio.day>=13)&(vedio.day<=19)]\n",
    "    tr1 = tr_app[['user_id']].drop_duplicates()\n",
    "    tr2 = tr_user_act[['user_id']].drop_duplicates()\n",
    "    tr3 = tr_user_reg[['user_id']].drop_duplicates()\n",
    "    tr4 = tr_vedio[['user_id']].drop_duplicates()\n",
    "    tr = pd.concat([tr1,tr2,tr3,tr4],axis=0)\n",
    "    train12_true = tr[['user_id']].drop_duplicates()\n",
    "    #左连接打标\n",
    "    train12_true['label'] = 1\n",
    "    train12 = pd.merge(train12,train12_true,on='user_id',how='left')\n",
    "    train12 = train12.fillna(0)\n",
    "    del train12_true;gc.collect();\n",
    "    \n",
    "    \"训练集-13\"\n",
    "    tr_app = app[(app.day>=1)&(app.day<=11)];tr_user_act = user_act[(user_act.day>=1)&(user_act.day<=11)]\n",
    "    tr_user_reg = user_reg[(user_reg.register_day>=1)&(user_reg.register_day<=11)];tr_vedio = vedio[(vedio.day>=1)&(vedio.day<=11)]\n",
    "    tr1 = tr_app[['user_id']].drop_duplicates()\n",
    "    tr2 = tr_user_act[['user_id']].drop_duplicates()\n",
    "    tr3 = tr_user_reg[['user_id']].drop_duplicates()\n",
    "    tr4 = tr_vedio[['user_id']].drop_duplicates()\n",
    "    tr = pd.concat([tr1,tr2,tr3,tr4],axis=0)\n",
    "    train13 = tr[['user_id']].drop_duplicates()\n",
    "    #未来7天：21-27号\n",
    "    tr_app = app[(app.day>=12)&(app.day<=18)];tr_user_act = user_act[(user_act.day>=12)&(user_act.day<=18)]\n",
    "    tr_user_reg = user_reg[(user_reg.register_day>=12)&(user_reg.register_day<=18)];tr_vedio = vedio[(vedio.day>=12)&(vedio.day<=18)]\n",
    "    tr1 = tr_app[['user_id']].drop_duplicates()\n",
    "    tr2 = tr_user_act[['user_id']].drop_duplicates()\n",
    "    tr3 = tr_user_reg[['user_id']].drop_duplicates()\n",
    "    tr4 = tr_vedio[['user_id']].drop_duplicates()\n",
    "    tr = pd.concat([tr1,tr2,tr3,tr4],axis=0)\n",
    "    train13_true = tr[['user_id']].drop_duplicates()\n",
    "    #左连接打标\n",
    "    train13_true['label'] = 1\n",
    "    train13 = pd.merge(train13,train13_true,on='user_id',how='left')\n",
    "    train13 = train13.fillna(0)\n",
    "    del train13_true;gc.collect();\n",
    "    \n",
    "    \"训练集-14\"\n",
    "    tr_app = app[(app.day>=1)&(app.day<=10)];tr_user_act = user_act[(user_act.day>=1)&(user_act.day<=10)]\n",
    "    tr_user_reg = user_reg[(user_reg.register_day>=1)&(user_reg.register_day<=10)];tr_vedio = vedio[(vedio.day>=1)&(vedio.day<=10)]\n",
    "    tr1 = tr_app[['user_id']].drop_duplicates()\n",
    "    tr2 = tr_user_act[['user_id']].drop_duplicates()\n",
    "    tr3 = tr_user_reg[['user_id']].drop_duplicates()\n",
    "    tr4 = tr_vedio[['user_id']].drop_duplicates()\n",
    "    tr = pd.concat([tr1,tr2,tr3,tr4],axis=0)\n",
    "    train14 = tr[['user_id']].drop_duplicates()\n",
    "    #未来7天：21-27号\n",
    "    tr_app = app[(app.day>=11)&(app.day<=17)];tr_user_act = user_act[(user_act.day>=11)&(user_act.day<=17)]\n",
    "    tr_user_reg = user_reg[(user_reg.register_day>=11)&(user_reg.register_day<=17)];tr_vedio = vedio[(vedio.day>=11)&(vedio.day<=17)]\n",
    "    tr1 = tr_app[['user_id']].drop_duplicates()\n",
    "    tr2 = tr_user_act[['user_id']].drop_duplicates()\n",
    "    tr3 = tr_user_reg[['user_id']].drop_duplicates()\n",
    "    tr4 = tr_vedio[['user_id']].drop_duplicates()\n",
    "    tr = pd.concat([tr1,tr2,tr3,tr4],axis=0)\n",
    "    train14_true = tr[['user_id']].drop_duplicates()\n",
    "    #左连接打标\n",
    "    train14_true['label'] = 1\n",
    "    train14 = pd.merge(train14,train14_true,on='user_id',how='left')\n",
    "    train14 = train14.fillna(0)\n",
    "    del train14_true;gc.collect();\n",
    "    \n",
    "    del tr1;gc.collect();\n",
    "    del tr2;gc.collect();\n",
    "    del tr3;gc.collect();\n",
    "    del tr4;gc.collect();\n",
    "    del tr;gc.collect();\n",
    "    del tr_app;gc.collect();\n",
    "    del tr_user_reg;gc.collect();\n",
    "    del tr_vedio;gc.collect();\n",
    "    \n",
    "    \n",
    "    return test,train1,train2,train3,train4,train5,train6,train7,train8,train9,train10,train11,train12,train13,train14\n",
    "\n",
    "#%%\n",
    "def culContinuousMeanLaunchDay(s,day_min):\n",
    "        f_start = day_min - 21\n",
    "        launch_day = [int(x) for x in list(set(s.split(':')))]\n",
    "        launch_day.sort()\n",
    "\n",
    "        continuous_day_count = []\n",
    "        count = 0\n",
    "        for i in range(len(launch_day) - 1):\n",
    "            if ((int(launch_day[i + 1]) - int(launch_day[i]) == 1)):\n",
    "                if (i == len(launch_day) - 2):\n",
    "                    count += (int(launch_day[i]) - f_start + 1)\n",
    "                    continuous_day_count.append(\n",
    "                        count + (int(launch_day[i + 1]) - f_start + 1))\n",
    "                else:\n",
    "                    count += (int(launch_day[i]) - f_start + 1)\n",
    "            else:\n",
    "                if (count != 0):\n",
    "                    continuous_day_count.append(\n",
    "                        count + (int(launch_day[i + 1]) - f_start + 1))\n",
    "                    count = 0\n",
    "\n",
    "        if (len(continuous_day_count) > 0):\n",
    "            continuous_day_count = np.array(continuous_day_count)\n",
    "        else:\n",
    "            continuous_day_count.append(0)\n",
    "            continuous_day_count = np.array(continuous_day_count)\n",
    "\n",
    "        return np.mean(continuous_day_count)\n",
    "\n",
    "#%%\n",
    "def culContinuousMaxLaunchDay(s,day_min):\n",
    "        f_start = day_min - 21\n",
    "        launch_day = [int(x) for x in list(set(s.split(':')))]\n",
    "        launch_day.sort()\n",
    "\n",
    "        continuous_day_count = []\n",
    "        count = 0\n",
    "        for i in range(len(launch_day) - 1):\n",
    "            if ((int(launch_day[i + 1]) - int(launch_day[i]) == 1)):\n",
    "                if (i == len(launch_day) - 2):\n",
    "                    count += (int(launch_day[i]) - f_start + 1)\n",
    "                    continuous_day_count.append(\n",
    "                        count + (int(launch_day[i + 1]) - f_start + 1))\n",
    "                else:\n",
    "                    count += (int(launch_day[i]) - f_start + 1)\n",
    "            else:\n",
    "                if (count != 0):\n",
    "                    continuous_day_count.append(\n",
    "                        count + (int(launch_day[i + 1]) - f_start + 1))\n",
    "                    count = 0\n",
    "\n",
    "        if (len(continuous_day_count) > 0):\n",
    "            continuous_day_count = np.array(continuous_day_count)\n",
    "        else:\n",
    "            continuous_day_count.append(0)\n",
    "            continuous_day_count = np.array(continuous_day_count)\n",
    "\n",
    "        return np.max(continuous_day_count)\n",
    "    \n",
    "#%%\n",
    "def culContinuousMinLaunchDay(s,day_min):\n",
    "        f_start = day_min - 21\n",
    "        launch_day = [int(x) for x in list(set(s.split(':')))]\n",
    "        launch_day.sort()\n",
    "\n",
    "        continuous_day_count = []\n",
    "        count = 0\n",
    "        for i in range(len(launch_day) - 1):\n",
    "            if ((int(launch_day[i + 1]) - int(launch_day[i]) == 1)):\n",
    "                if (i == len(launch_day) - 2):\n",
    "                    count += (int(launch_day[i]) - f_start + 1)\n",
    "                    continuous_day_count.append(\n",
    "                        count + (int(launch_day[i + 1]) - f_start + 1))\n",
    "                else:\n",
    "                    count += (int(launch_day[i]) - f_start + 1)\n",
    "            else:\n",
    "                if (count != 0):\n",
    "                    continuous_day_count.append(\n",
    "                        count + (int(launch_day[i + 1]) - f_start + 1))\n",
    "                    count = 0\n",
    "\n",
    "        if (len(continuous_day_count) > 0):\n",
    "            continuous_day_count = np.array(continuous_day_count)\n",
    "        else:\n",
    "            continuous_day_count.append(0)\n",
    "            continuous_day_count = np.array(continuous_day_count)\n",
    "\n",
    "        return np.min(continuous_day_count)\n",
    "   \n",
    "#%%\n",
    "\n",
    "def genFeature(day_min,day_max,data,app,user_act,user_reg,vedio):\n",
    "    \"特征提取\"\n",
    "    #保存原始表\n",
    "    ans = data.copy()\n",
    "    \n",
    "    #计算最大最小平均使用时间\n",
    "    app = app[(app.day>=day_min-21)&(app.day<=day_max-7)]\n",
    "    vedio = vedio[(vedio.day>=day_min-21)&(vedio.day<=day_max-7)]\n",
    "    user_act = user_act[(user_act.day>=day_min-21)&(user_act.day<=day_max-7)]\n",
    "\n",
    "    a = app.copy()\n",
    "    a['s'] = a.day\n",
    "    a['s'] = a.s.astype('str')\n",
    "    a = a.groupby(['user_id'])['s'].agg(lambda x:':'.join(x)).reset_index()\n",
    "    print(1)\n",
    "    a['s_mean_day'] = a.s.apply(lambda x:culContinuousMeanLaunchDay(x,day_min))\n",
    "    print(2)\n",
    "    a['s_max_day'] = a.s.apply(lambda x:culContinuousMaxLaunchDay(x,day_min))\n",
    "    print(3)\n",
    "    a = a[['user_id','s_mean_day','s_max_day']]\n",
    "    ans = pd.merge(ans,a,on='user_id',how='left')\n",
    "    del a;gc.collect();\n",
    "    \n",
    "    a = vedio.copy()\n",
    "    a['s'] = a.day\n",
    "    a['s'] = a.s.astype('str')\n",
    "    a = a.groupby(['user_id'])['s'].agg(lambda x:':'.join(x)).reset_index()\n",
    "    print(1)\n",
    "    a['s_mean_day_1'] = a.s.apply(lambda x:culContinuousMeanLaunchDay(x,day_min))\n",
    "    print(2)\n",
    "    a['s_max_day_1'] = a.s.apply(lambda x:culContinuousMaxLaunchDay(x,day_min))\n",
    "    print(3)\n",
    "    a = a[['user_id','s_mean_day_1','s_max_day_1']]\n",
    "    ans = pd.merge(ans,a,on='user_id',how='left')\n",
    "    del a;gc.collect();\n",
    "    \n",
    "    a = user_act.copy()\n",
    "    a['s'] = a.day\n",
    "    a['s'] = a.s.astype('str')\n",
    "    a = a.groupby(['user_id'])['s'].agg(lambda x:':'.join(x)).reset_index()\n",
    "    print(1)\n",
    "    a['s_mean_day_2'] = a.s.apply(lambda x:culContinuousMeanLaunchDay(x,day_min))\n",
    "    print(2)\n",
    "    a['s_max_day_2'] = a.s.apply(lambda x:culContinuousMaxLaunchDay(x,day_min))\n",
    "    print(3)\n",
    "    a = a[['user_id','s_mean_day_2','s_max_day_2']]\n",
    "    ans = pd.merge(ans,a,on='user_id',how='left')\n",
    "    del a;gc.collect();\n",
    "     \n",
    "#%%\n",
    "    \"提取 注册信息表 特征\"\n",
    "    ans = pd.merge(ans,user_reg,on='user_id',how='left')\n",
    "    #注册日期距离最小/最大日期距离\n",
    "    ans['register_sub_min'] = day_min - ans['register_day']\n",
    "    ans['register_sub_max'] = day_max - ans['register_day']\n",
    "    #离散注册类型\n",
    "    register_type_df = pd.get_dummies(ans['register_type'],prefix = 'register_type')\n",
    "    ans = pd.concat([ans,register_type_df],axis=1)\n",
    "    del ans['register_type']\n",
    "    del register_type_df;gc.collect();\n",
    "#%% \n",
    "    \"添加时间差\"\n",
    "    ans['day_median_sub'] = day_min - ans['register_day']\n",
    "#%%\n",
    "    \"提取 app 特征\"\n",
    "    app = app[(app.day>=day_min-21)&(app.day<=day_max-7)]\n",
    "    #统计用户在前21天启用app多少次\n",
    "    app['app_count'] = app['user_id']\n",
    "    feat = pd.pivot_table(app,index=['user_id'],values='app_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    ans['app_count'] = ans['app_count']/ans['day_median_sub']\n",
    "    \n",
    "    #统计用户最近一次使用app距离最小/最大日期距离\n",
    "    #最小使用app时间\n",
    "    app['app_day_min'] = app['day']\n",
    "    feat = pd.pivot_table(app,index=['user_id'],values='app_day_min',aggfunc='min').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    #最大使用app时间\n",
    "    app['app_day_max'] = app['day']\n",
    "    feat = pd.pivot_table(app,index=['user_id'],values='app_day_max',aggfunc='max').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    ans['appmin_sub_day_min'] = day_min - ans['app_day_min']\n",
    "    ans['appmax_sub_day_min'] = day_min - ans['app_day_max']\n",
    "    ans['appmin_sub_day_max'] = day_max - ans['app_day_min']\n",
    "    ans['appmax_sub_day_max'] = day_max - ans['app_day_max']\n",
    "    del ans['app_day_min'];del ans['app_day_max']\n",
    "\n",
    "    \"划分粒度\"\n",
    "    #统计用户在前14天启用app多少次\n",
    "    app = app[(app.day>=day_min-14)&(app.day<=day_max-7)]\n",
    "    app['app_count_14'] = app['user_id']\n",
    "    feat = pd.pivot_table(app,index=['user_id'],values='app_count_14',aggfunc='count').reset_index()    \n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    ans['app_count_14'] = ans['app_count_14']/ans['day_median_sub']\n",
    "    #统计用户在前10天启用app多少次\n",
    "    app = app[(app.day>=day_min-10)&(app.day<=day_max-7)]\n",
    "    app['app_count_10'] = app['user_id']\n",
    "    feat = pd.pivot_table(app,index=['user_id'],values='app_count_10',aggfunc='count').reset_index()    \n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    ans['app_count_10'] = ans['app_count_10']/ans['day_median_sub']\n",
    "    #统计用户在前7天启用app多少次\n",
    "    app = app[(app.day>=day_min-7)&(app.day<=day_max-7)]\n",
    "    app['app_count_7'] = app['user_id']\n",
    "    feat = pd.pivot_table(app,index=['user_id'],values='app_count_7',aggfunc='count').reset_index()    \n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    ans['app_count_7'] = ans['app_count_7']/ans['day_median_sub']\n",
    "    #统计用户在前5天启用app多少次\n",
    "    app = app[(app.day>=day_min-5)&(app.day<=day_max-7)]\n",
    "    app['app_count_5'] = app['user_id']\n",
    "    feat = pd.pivot_table(app,index=['user_id'],values='app_count_5',aggfunc='count').reset_index()    \n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    #统计用户在前4天启用app多少次\n",
    "    app = app[(app.day>=day_min-4)&(app.day<=day_max-7)]\n",
    "    app['app_count_4'] = app['user_id']\n",
    "    feat = pd.pivot_table(app,index=['user_id'],values='app_count_4',aggfunc='count').reset_index()    \n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    #统计用户在前3天启用app多少次\n",
    "    app = app[(app.day>=day_min-3)&(app.day<=day_max-7)]\n",
    "    app['app_count_3'] = app['user_id']\n",
    "    feat = pd.pivot_table(app,index=['user_id'],values='app_count_3',aggfunc='count').reset_index()    \n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    #统计用户在前2天启用app多少次\n",
    "    app = app[(app.day>=day_min-2)&(app.day<=day_max-7)]\n",
    "    app['app_count_2'] = app['user_id']\n",
    "    feat = pd.pivot_table(app,index=['user_id'],values='app_count_2',aggfunc='count').reset_index()    \n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    #统计用户在前1天启用app多少次\n",
    "    app = app[(app.day>=day_min-1)&(app.day<=day_max-7)]\n",
    "    app['app_count_1'] = app['user_id']\n",
    "    feat = pd.pivot_table(app,index=['user_id'],values='app_count_1',aggfunc='count').reset_index()    \n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    \n",
    "#%%\n",
    "    \"提取 vedio 表特征\"\n",
    "    vedio = vedio[(vedio.day>=day_min-21)&(vedio.day<=day_max-7)]\n",
    "    #统计用户在前21天拍摄视频多少次\n",
    "    vedio['vedio_count'] = vedio['user_id']\n",
    "    feat = pd.pivot_table(vedio,index=['user_id'],values='vedio_count',aggfunc='count').reset_index()    \n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    ans['vedio_count'] = ans['vedio_count']/ans['day_median_sub']\n",
    "    #统计用户最近一次拍摄视频距离最小/最大日期距离\n",
    "    #最小使用vedio时间\n",
    "    vedio['vedio_day_min'] = vedio['day']\n",
    "    feat = pd.pivot_table(vedio,index=['user_id'],values='vedio_day_min',aggfunc='min').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    #最大使用vedio时间\n",
    "    vedio['vedio_day_max'] = vedio['day']\n",
    "    feat = pd.pivot_table(vedio,index=['user_id'],values='vedio_day_max',aggfunc='max').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    ans['vediomin_sub_day_min'] = day_min - ans['vedio_day_min']\n",
    "    ans['vediomax_sub_day_min'] = day_min - ans['vedio_day_max']\n",
    "    ans['vediomin_sub_day_max'] = day_max - ans['vedio_day_min']\n",
    "    ans['vediomax_sub_day_max'] = day_max - ans['vedio_day_max']\n",
    "    del ans['vedio_day_min'];del ans['vedio_day_max']\n",
    "    \n",
    "    \"划分粒度\"\n",
    "    #统计用户在前14天拍摄视频多少次\n",
    "    vedio = vedio[(vedio.day>=day_min-14)&(vedio.day<=day_max-7)]\n",
    "    vedio['vedio_count_14'] = vedio['user_id']\n",
    "    feat = pd.pivot_table(vedio,index=['user_id'],values='vedio_count_14',aggfunc='count').reset_index()    \n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    ans['vedio_count_14'] = ans['vedio_count_14']/ans['day_median_sub']\n",
    "    #统计用户在前10天拍摄视频多少次\n",
    "    vedio = vedio[(vedio.day>=day_min-10)&(vedio.day<=day_max-7)]\n",
    "    vedio['vedio_count_10'] = vedio['user_id']\n",
    "    feat = pd.pivot_table(vedio,index=['user_id'],values='vedio_count_10',aggfunc='count').reset_index()    \n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    ans['vedio_count_10'] = ans['vedio_count_10']/ans['day_median_sub']\n",
    "    #统计用户在前7天拍摄视频多少次\n",
    "    vedio = vedio[(vedio.day>=day_min-7)&(vedio.day<=day_max-7)]\n",
    "    vedio['vedio_count_7'] = vedio['user_id']\n",
    "    feat = pd.pivot_table(vedio,index=['user_id'],values='vedio_count_7',aggfunc='count').reset_index()    \n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    ans['vedio_count_7'] = ans['vedio_count_7']/ans['day_median_sub']\n",
    "    #统计用户在前5天拍摄视频多少次\n",
    "    vedio = vedio[(vedio.day>=day_min-5)&(vedio.day<=day_max-7)]\n",
    "    vedio['vedio_count_5'] = vedio['user_id']\n",
    "    feat = pd.pivot_table(vedio,index=['user_id'],values='vedio_count_5',aggfunc='count').reset_index()    \n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    #统计用户在前4天拍摄视频多少次\n",
    "    vedio = vedio[(vedio.day>=day_min-4)&(vedio.day<=day_max-7)]\n",
    "    vedio['vedio_count_4'] = vedio['user_id']\n",
    "    feat = pd.pivot_table(vedio,index=['user_id'],values='vedio_count_4',aggfunc='count').reset_index()    \n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    #统计用户在前3天拍摄视频多少次\n",
    "    vedio = vedio[(vedio.day>=day_min-3)&(vedio.day<=day_max-7)]\n",
    "    vedio['vedio_count_3'] = vedio['user_id']\n",
    "    feat = pd.pivot_table(vedio,index=['user_id'],values='vedio_count_3',aggfunc='count').reset_index()    \n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    #统计用户在前2天拍摄视频多少次\n",
    "    vedio = vedio[(vedio.day>=day_min-2)&(vedio.day<=day_max-7)]\n",
    "    vedio['vedio_count_2'] = vedio['user_id']\n",
    "    feat = pd.pivot_table(vedio,index=['user_id'],values='vedio_count_2',aggfunc='count').reset_index()    \n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    #统计用户在前1天拍摄视频多少次\n",
    "    vedio = vedio[(vedio.day>=day_min-1)&(vedio.day<=day_max-7)]\n",
    "    vedio['vedio_count_1'] = vedio['user_id']\n",
    "    feat = pd.pivot_table(vedio,index=['user_id'],values='vedio_count_1',aggfunc='count').reset_index()    \n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    \n",
    "    \n",
    "#%%\n",
    "    \"提取 activity 表特征\"\n",
    "    user_act = user_act[(user_act.day>=day_min-21)&(user_act.day<=day_max-7)]\n",
    "    #统计前21天共活跃多少次\n",
    "    user_act['user_act_count'] = user_act['user_id']\n",
    "    feat = pd.pivot_table(user_act,index=['user_id'],values='user_act_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    ans['user_act_count'] = ans['user_act_count']/ans['day_median_sub']\n",
    "\n",
    "#%%\n",
    "    \"划分粒度\"\n",
    "#%% 前18天\n",
    "    '''\n",
    "    user_act = user_act[(user_act.day>=day_min-18)&(user_act.day<=day_max-7)]\n",
    "    #统计前18天共活跃多少次\n",
    "    user_act['user_act_count_18'] = user_act['user_id']\n",
    "    feat = pd.pivot_table(user_act,index=['user_id'],values='user_act_count_18',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    ans['user_act_count_18'] = ans['user_act_count_18']/ans['day_median_sub']\n",
    "    '''\n",
    "    \n",
    "#%% 前14天\n",
    "    user_act = user_act[(user_act.day>=day_min-14)&(user_act.day<=day_max-7)]\n",
    "    #统计前14天共活跃多少次\n",
    "    user_act['user_act_count_14'] = user_act['user_id']\n",
    "    feat = pd.pivot_table(user_act,index=['user_id'],values='user_act_count_14',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    ans['user_act_count_14'] = ans['user_act_count_14']/ans['day_median_sub']\n",
    "    \n",
    "    \"对page类别统计\"\n",
    "    #统计page为0的次数\n",
    "    page_0_14 = user_act[user_act.page==0]\n",
    "    page_0_14['page_0_14_count'] = page_0_14['user_id']\n",
    "    feat = pd.pivot_table(page_0_14,index=['user_id'],values='page_0_14_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    ans['page_0_14_count'] = ans['page_0_14_count']/ans['day_median_sub']\n",
    "    del page_0_14;gc.collect();\n",
    "    #统计page为1的次数\n",
    "    page_1_14 = user_act[user_act.page==1]\n",
    "    page_1_14['page_1_14_count'] = page_1_14['user_id']\n",
    "    feat = pd.pivot_table(page_1_14,index=['user_id'],values='page_1_14_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    ans['page_1_14_count'] = ans['page_1_14_count']/ans['day_median_sub']\n",
    "    del page_1_14;gc.collect();\n",
    "    #统计page为2的次数\n",
    "    page_2_14 = user_act[user_act.page==2]\n",
    "    page_2_14['page_2_14_count'] = page_2_14['user_id']\n",
    "    feat = pd.pivot_table(page_2_14,index=['user_id'],values='page_2_14_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    ans['page_2_14_count'] = ans['page_2_14_count']/ans['day_median_sub']\n",
    "    del page_2_14;gc.collect();\n",
    "    #统计page为3的次数\n",
    "    page_3_14 = user_act[user_act.page==3]\n",
    "    page_3_14['page_3_14_count'] = page_3_14['user_id']\n",
    "    feat = pd.pivot_table(page_3_14,index=['user_id'],values='page_3_14_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    ans['page_3_14_count'] = ans['page_3_14_count']/ans['day_median_sub']\n",
    "    del page_3_14;gc.collect();\n",
    "    #统计page为4的次数\n",
    "    page_4_14 = user_act[user_act.page==4]\n",
    "    page_4_14['page_4_14_count'] = page_4_14['user_id']\n",
    "    feat = pd.pivot_table(page_4_14,index=['user_id'],values='page_4_14_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    ans['page_4_14_count'] = ans['page_4_14_count']/ans['day_median_sub']\n",
    "    del page_4_14;gc.collect();\n",
    "    \n",
    "    \"对action_type进行统计\"\n",
    "    #统计action_type为0的次数\n",
    "    user_act_0_14 = user_act[user_act.action_type==0]\n",
    "    user_act_0_14['user_act_0_14_count'] = user_act_0_14['user_id']\n",
    "    feat = pd.pivot_table(user_act_0_14,index=['user_id'],values='user_act_0_14_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    ans['user_act_0_14_count'] = ans['user_act_0_14_count']/ans['day_median_sub']\n",
    "    del user_act_0_14;gc.collect();\n",
    "    #统计action_type为1的次数\n",
    "    user_act_1_14 = user_act[user_act.action_type==1]\n",
    "    user_act_1_14['user_act_1_14_count'] = user_act_1_14['user_id']\n",
    "    feat = pd.pivot_table(user_act_1_14,index=['user_id'],values='user_act_1_14_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    ans['user_act_1_14_count'] = ans['user_act_1_14_count']/ans['day_median_sub']\n",
    "    del user_act_1_14;gc.collect(); \n",
    "    #统计action_type为2的次数\n",
    "    user_act_2_14 = user_act[user_act.action_type==2]\n",
    "    user_act_2_14['user_act_2_14_count'] = user_act_2_14['user_id']\n",
    "    feat = pd.pivot_table(user_act_2_14,index=['user_id'],values='user_act_2_14_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    ans['user_act_2_14_count'] = ans['user_act_2_14_count']/ans['day_median_sub']\n",
    "    del user_act_2_14;gc.collect();    \n",
    "    #统计action_type为3的次数\n",
    "    user_act_3_14 = user_act[user_act.action_type==3]\n",
    "    user_act_3_14['user_act_3_14_count'] = user_act_3_14['user_id']\n",
    "    feat = pd.pivot_table(user_act_3_14,index=['user_id'],values='user_act_3_14_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    ans['user_act_3_14_count'] = ans['user_act_3_14_count']/ans['day_median_sub']\n",
    "    del user_act_3_14;gc.collect();  \n",
    "    #统计action_type为4的次数\n",
    "    user_act_4_14 = user_act[user_act.action_type==4]\n",
    "    user_act_4_14['user_act_4_14_count'] = user_act_4_14['user_id']\n",
    "    feat = pd.pivot_table(user_act_4_14,index=['user_id'],values='user_act_4_14_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    ans['user_act_4_14_count'] = ans['user_act_4_14_count']/ans['day_median_sub']\n",
    "    del user_act_4_14;gc.collect(); \n",
    "    #统计action_type为5的次数\n",
    "    user_act_5_14 = user_act[user_act.action_type==5]\n",
    "    user_act_5_14['user_act_5_14_count'] = user_act_5_14['user_id']\n",
    "    feat = pd.pivot_table(user_act_5_14,index=['user_id'],values='user_act_5_14_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    ans['user_act_5_14_count'] = ans['user_act_5_14_count']/ans['day_median_sub']\n",
    "    del user_act_5_14;gc.collect();\n",
    "\n",
    "#%% 前10天\n",
    "    user_act = user_act[(user_act.day>=day_min-10)&(user_act.day<=day_max-7)]\n",
    "    #统计前10天共活跃多少次\n",
    "    user_act['user_act_count_10'] = user_act['user_id']\n",
    "    feat = pd.pivot_table(user_act,index=['user_id'],values='user_act_count_10',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    ans['user_act_count_10'] = ans['user_act_count_10']/ans['day_median_sub']\n",
    "    \n",
    "    \"对page类别统计\"\n",
    "    #统计page为0的次数\n",
    "    page_0_10 = user_act[user_act.page==0]\n",
    "    page_0_10['page_0_10_count'] = page_0_10['user_id']\n",
    "    feat = pd.pivot_table(page_0_10,index=['user_id'],values='page_0_10_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    ans['page_0_10_count'] = ans['page_0_10_count']/ans['day_median_sub']\n",
    "    del page_0_10;gc.collect();\n",
    "    #统计page为1的次数\n",
    "    page_1_10 = user_act[user_act.page==1]\n",
    "    page_1_10['page_1_10_count'] = page_1_10['user_id']\n",
    "    feat = pd.pivot_table(page_1_10,index=['user_id'],values='page_1_10_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    ans['page_1_10_count'] = ans['page_1_10_count']/ans['day_median_sub']\n",
    "    del page_1_10;gc.collect();\n",
    "    #统计page为2的次数\n",
    "    page_2_10 = user_act[user_act.page==2]\n",
    "    page_2_10['page_2_10_count'] = page_2_10['user_id']\n",
    "    feat = pd.pivot_table(page_2_10,index=['user_id'],values='page_2_10_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    ans['page_2_10_count'] = ans['page_2_10_count']/ans['day_median_sub']\n",
    "    del page_2_10;gc.collect();\n",
    "    #统计page为3的次数\n",
    "    page_3_10 = user_act[user_act.page==3]\n",
    "    page_3_10['page_3_10_count'] = page_3_10['user_id']\n",
    "    feat = pd.pivot_table(page_3_10,index=['user_id'],values='page_3_10_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    ans['page_3_10_count'] = ans['page_3_10_count']/ans['day_median_sub']\n",
    "    del page_3_10;gc.collect();\n",
    "    #统计page为4的次数\n",
    "    page_4_10 = user_act[user_act.page==4]\n",
    "    page_4_10['page_4_10_count'] = page_4_10['user_id']\n",
    "    feat = pd.pivot_table(page_4_10,index=['user_id'],values='page_4_10_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    ans['page_4_10_count'] = ans['page_4_10_count']/ans['day_median_sub']\n",
    "    del page_4_10;gc.collect();\n",
    "    \n",
    "    \"对action_type进行统计\"\n",
    "    #统计action_type为0的次数\n",
    "    user_act_0_10 = user_act[user_act.action_type==0]\n",
    "    user_act_0_10['user_act_0_10_count'] = user_act_0_10['user_id']\n",
    "    feat = pd.pivot_table(user_act_0_10,index=['user_id'],values='user_act_0_10_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    ans['user_act_0_10_count'] = ans['user_act_0_10_count']/ans['day_median_sub']\n",
    "    del user_act_0_10;gc.collect();\n",
    "    #统计action_type为1的次数\n",
    "    user_act_1_10 = user_act[user_act.action_type==1]\n",
    "    user_act_1_10['user_act_1_10_count'] = user_act_1_10['user_id']\n",
    "    feat = pd.pivot_table(user_act_1_10,index=['user_id'],values='user_act_1_10_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    ans['user_act_1_10_count'] = ans['user_act_1_10_count']/ans['day_median_sub']\n",
    "    del user_act_1_10 ;gc.collect();\n",
    "    #统计action_type为2的次数\n",
    "    user_act_2_10 = user_act[user_act.action_type==2]\n",
    "    user_act_2_10['user_act_2_10_count'] = user_act_2_10['user_id']\n",
    "    feat = pd.pivot_table(user_act_2_10,index=['user_id'],values='user_act_2_10_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    ans['user_act_2_10_count'] = ans['user_act_2_10_count']/ans['day_median_sub']\n",
    "    del user_act_2_10  ;gc.collect();   \n",
    "    #统计action_type为3的次数\n",
    "    user_act_3_10 = user_act[user_act.action_type==3]\n",
    "    user_act_3_10['user_act_3_10_count'] = user_act_3_10['user_id']\n",
    "    feat = pd.pivot_table(user_act_3_10,index=['user_id'],values='user_act_3_10_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    ans['user_act_3_10_count'] = ans['user_act_3_10_count']/ans['day_median_sub']\n",
    "    del user_act_3_10 ;gc.collect(); \n",
    "    #统计action_type为4的次数\n",
    "    user_act_4_10 = user_act[user_act.action_type==4]\n",
    "    user_act_4_10['user_act_4_10_count'] = user_act_4_10['user_id']\n",
    "    feat = pd.pivot_table(user_act_4_10,index=['user_id'],values='user_act_4_10_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    ans['user_act_4_10_count'] = ans['user_act_4_10_count']/ans['day_median_sub']\n",
    "    del user_act_4_10 ;gc.collect();\n",
    "    #统计action_type为5的次数\n",
    "    user_act_5_10 = user_act[user_act.action_type==5]\n",
    "    user_act_5_10['user_act_5_10_count'] = user_act_5_10['user_id']\n",
    "    feat = pd.pivot_table(user_act_5_10,index=['user_id'],values='user_act_5_10_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    ans['user_act_5_10_count'] = ans['user_act_5_10_count']/ans['day_median_sub']\n",
    "    del user_act_5_10;gc.collect();\n",
    "#%% 前7天\n",
    "    user_act = user_act[(user_act.day>=day_min-7)&(user_act.day<=day_max-7)]\n",
    "    #统计前7天共活跃多少次\n",
    "    user_act['user_act_count_7'] = user_act['user_id']\n",
    "    feat = pd.pivot_table(user_act,index=['user_id'],values='user_act_count_7',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    ans['user_act_count_7'] = ans['user_act_count_7']/ans['day_median_sub']\n",
    "    \n",
    "    \"对page每种进行统计\"\n",
    "    #统计page为0的次数\n",
    "    page_0_7 = user_act[user_act.page==0]\n",
    "    page_0_7['page_0_7_count'] = page_0_7['user_id']\n",
    "    feat = pd.pivot_table(page_0_7,index=['user_id'],values='page_0_7_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    ans['page_0_7_count'] = ans['page_0_7_count']/ans['day_median_sub']\n",
    "    del page_0_7;gc.collect();\n",
    "    #统计page为1的次数\n",
    "    page_1_7 = user_act[user_act.page==1]\n",
    "    page_1_7['page_1_7_count'] = page_1_7['user_id']\n",
    "    feat = pd.pivot_table(page_1_7,index=['user_id'],values='page_1_7_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    ans['page_1_7_count'] = ans['page_1_7_count']/ans['day_median_sub']\n",
    "    del page_1_7;gc.collect();\n",
    "    #统计page为2的次数\n",
    "    page_2_7 = user_act[user_act.page==2]\n",
    "    page_2_7['page_2_7_count'] = page_2_7['user_id']\n",
    "    feat = pd.pivot_table(page_2_7,index=['user_id'],values='page_2_7_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    ans['page_2_7_count'] = ans['page_2_7_count']/ans['day_median_sub']\n",
    "    del page_2_7;gc.collect();\n",
    "    #统计page为3的次数\n",
    "    page_3_7 = user_act[user_act.page==3]\n",
    "    page_3_7['page_3_7_count'] = page_3_7['user_id']\n",
    "    feat = pd.pivot_table(page_3_7,index=['user_id'],values='page_3_7_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    ans['page_3_7_count'] = ans['page_3_7_count']/ans['day_median_sub']\n",
    "    del page_3_7;gc.collect();\n",
    "    #统计page为4的次数\n",
    "    page_4_7 = user_act[user_act.page==4]\n",
    "    page_4_7['page_4_7_count'] = page_4_7['user_id']\n",
    "    feat = pd.pivot_table(page_4_7,index=['user_id'],values='page_4_7_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    ans['page_4_7_count'] = ans['page_4_7_count']/ans['day_median_sub']\n",
    "    del page_4_7;gc.collect();\n",
    "    \n",
    "    \"对action_type进行统计\"\n",
    "    #统计action_type为0的次数\n",
    "    user_act_0_7 = user_act[user_act.action_type==0]\n",
    "    user_act_0_7['user_act_0_7_count'] = user_act_0_7['user_id']\n",
    "    feat = pd.pivot_table(user_act_0_7,index=['user_id'],values='user_act_0_7_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    ans['user_act_0_7_count'] = ans['user_act_0_7_count']/ans['day_median_sub']\n",
    "    del user_act_0_7;gc.collect();\n",
    "    #统计action_type为1的次数\n",
    "    user_act_1_7 = user_act[user_act.action_type==1]\n",
    "    user_act_1_7['user_act_1_7_count'] = user_act_1_7['user_id']\n",
    "    feat = pd.pivot_table(user_act_1_7,index=['user_id'],values='user_act_1_7_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    ans['user_act_1_7_count'] = ans['user_act_1_7_count']/ans['day_median_sub']\n",
    "    del user_act_1_7;gc.collect(); \n",
    "    #统计action_type为2的次数\n",
    "    user_act_2_7 = user_act[user_act.action_type==2]\n",
    "    user_act_2_7['user_act_2_7_count'] = user_act_2_7['user_id']\n",
    "    feat = pd.pivot_table(user_act_2_7,index=['user_id'],values='user_act_2_7_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    ans['user_act_2_7_count'] = ans['user_act_2_7_count']/ans['day_median_sub']\n",
    "    del user_act_2_7;gc.collect();     \n",
    "    #统计action_type为3的次数\n",
    "    user_act_3_7 = user_act[user_act.action_type==3]\n",
    "    user_act_3_7['user_act_3_7_count'] = user_act_3_7['user_id']\n",
    "    feat = pd.pivot_table(user_act_3_7,index=['user_id'],values='user_act_3_7_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    ans['user_act_3_7_count'] = ans['user_act_3_7_count']/ans['day_median_sub']\n",
    "    del user_act_3_7;gc.collect(); \n",
    "    #统计action_type为4的次数\n",
    "    user_act_4_7 = user_act[user_act.action_type==4]\n",
    "    user_act_4_7['user_act_4_7_count'] = user_act_4_7['user_id']\n",
    "    feat = pd.pivot_table(user_act_4_7,index=['user_id'],values='user_act_4_7_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    ans['user_act_4_7_count'] = ans['user_act_4_7_count']/ans['day_median_sub']\n",
    "    del user_act_4_7;gc.collect(); \n",
    "    #统计action_type为5的次数\n",
    "    user_act_5_7 = user_act[user_act.action_type==5]\n",
    "    user_act_5_7['user_act_5_7_count'] = user_act_5_7['user_id']\n",
    "    feat = pd.pivot_table(user_act_5_7,index=['user_id'],values='user_act_5_7_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    ans['user_act_5_7_count'] = ans['user_act_5_7_count']/ans['day_median_sub']\n",
    "    del user_act_5_7;gc.collect();\n",
    "    \n",
    "#%% 前5天\n",
    "    user_act = user_act[(user_act.day>=day_min-5)&(user_act.day<=day_max-7)]\n",
    "    #统计前5天共活跃多少次\n",
    "    user_act['user_act_count_5'] = user_act['user_id']\n",
    "    feat = pd.pivot_table(user_act,index=['user_id'],values='user_act_count_5',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    \n",
    "    \"对page每种进行统计\"\n",
    "    #统计page为0的次数\n",
    "    page_0_5 = user_act[user_act.page==0]\n",
    "    page_0_5['page_0_5_count'] = page_0_5['user_id']\n",
    "    feat = pd.pivot_table(page_0_5,index=['user_id'],values='page_0_5_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del page_0_5;gc.collect();\n",
    "    #统计page为1的次数\n",
    "    page_1_5 = user_act[user_act.page==1]\n",
    "    page_1_5['page_1_5_count'] = page_1_5['user_id']\n",
    "    feat = pd.pivot_table(page_1_5,index=['user_id'],values='page_1_5_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del page_1_5;gc.collect();\n",
    "    #统计page为2的次数\n",
    "    page_2_5 = user_act[user_act.page==2]\n",
    "    page_2_5['page_2_5_count'] = page_2_5['user_id']\n",
    "    feat = pd.pivot_table(page_2_5,index=['user_id'],values='page_2_5_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del page_2_5;gc.collect();\n",
    "    #统计page为3的次数\n",
    "    page_3_5 = user_act[user_act.page==3]\n",
    "    page_3_5['page_3_5_count'] = page_3_5['user_id']\n",
    "    feat = pd.pivot_table(page_3_5,index=['user_id'],values='page_3_5_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del page_3_5;gc.collect();\n",
    "    #统计page为4的次数\n",
    "    page_4_5 = user_act[user_act.page==4]\n",
    "    page_4_5['page_4_5_count'] = page_4_5['user_id']\n",
    "    feat = pd.pivot_table(page_4_5,index=['user_id'],values='page_4_5_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del page_4_5;gc.collect();\n",
    "    \n",
    "    \"对action_type进行统计\"\n",
    "    #统计action_type为0的次数\n",
    "    user_act_0_5 = user_act[user_act.action_type==0]\n",
    "    user_act_0_5['user_act_0_5_count'] = user_act_0_5['user_id']\n",
    "    feat = pd.pivot_table(user_act_0_5,index=['user_id'],values='user_act_0_5_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del user_act_0_5;gc.collect();\n",
    "    #统计action_type为1的次数\n",
    "    user_act_1_5 = user_act[user_act.action_type==1]\n",
    "    user_act_1_5['user_act_1_5_count'] = user_act_1_5['user_id']\n",
    "    feat = pd.pivot_table(user_act_1_5,index=['user_id'],values='user_act_1_5_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del user_act_1_5 ;gc.collect();\n",
    "    #统计action_type为2的次数\n",
    "    user_act_2_5 = user_act[user_act.action_type==2]\n",
    "    user_act_2_5['user_act_2_5_count'] = user_act_2_5['user_id']\n",
    "    feat = pd.pivot_table(user_act_2_5,index=['user_id'],values='user_act_2_5_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del user_act_2_5   ;gc.collect();  \n",
    "    #统计action_type为3的次数\n",
    "    user_act_3_5 = user_act[user_act.action_type==3]\n",
    "    user_act_3_5['user_act_3_5_count'] = user_act_3_5['user_id']\n",
    "    feat = pd.pivot_table(user_act_3_5,index=['user_id'],values='user_act_3_5_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del user_act_3_5  ;gc.collect();\n",
    "    #统计action_type为4的次数\n",
    "    user_act_4_5 = user_act[user_act.action_type==4]\n",
    "    user_act_4_5['user_act_4_5_count'] = user_act_4_5['user_id']\n",
    "    feat = pd.pivot_table(user_act_4_5,index=['user_id'],values='user_act_4_5_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del user_act_4_5 ;gc.collect();\n",
    "    #统计action_type为5的次数\n",
    "    user_act_5_5 = user_act[user_act.action_type==5]\n",
    "    user_act_5_5['user_act_5_5_count'] = user_act_5_5['user_id']\n",
    "    feat = pd.pivot_table(user_act_5_5,index=['user_id'],values='user_act_5_5_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del user_act_5_5;gc.collect();\n",
    "#%% 前4天\n",
    "    user_act = user_act[(user_act.day>=day_min-4)&(user_act.day<=day_max-7)]\n",
    "    #统计前4天共活跃多少次\n",
    "    user_act['user_act_count_4'] = user_act['user_id']\n",
    "    feat = pd.pivot_table(user_act,index=['user_id'],values='user_act_count_4',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    \n",
    "    \"对page每种进行统计\"\n",
    "    #统计page为0的次数\n",
    "    page_0_4 = user_act[user_act.page==0]\n",
    "    page_0_4['page_0_4_count'] = page_0_4['user_id']\n",
    "    feat = pd.pivot_table(page_0_4,index=['user_id'],values='page_0_4_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del page_0_4;gc.collect();\n",
    "    #统计page为1的次数\n",
    "    page_1_4 = user_act[user_act.page==1]\n",
    "    page_1_4['page_1_4_count'] = page_1_4['user_id']\n",
    "    feat = pd.pivot_table(page_1_4,index=['user_id'],values='page_1_4_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del page_1_4;gc.collect();\n",
    "    #统计page为2的次数\n",
    "    page_2_4 = user_act[user_act.page==2]\n",
    "    page_2_4['page_2_4_count'] = page_2_4['user_id']\n",
    "    feat = pd.pivot_table(page_2_4,index=['user_id'],values='page_2_4_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del page_2_4;gc.collect();\n",
    "    #统计page为3的次数\n",
    "    page_3_4 = user_act[user_act.page==3]\n",
    "    page_3_4['page_3_4_count'] = page_3_4['user_id']\n",
    "    feat = pd.pivot_table(page_3_4,index=['user_id'],values='page_3_4_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del page_3_4;gc.collect();\n",
    "    #统计page为4的次数\n",
    "    page_4_4 = user_act[user_act.page==4]\n",
    "    page_4_4['page_4_4_count'] = page_4_4['user_id']\n",
    "    feat = pd.pivot_table(page_4_4,index=['user_id'],values='page_4_4_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del page_4_4;gc.collect();\n",
    "    \n",
    "    \"对action_type进行统计\"\n",
    "    #统计action_type为0的次数\n",
    "    user_act_0_4 = user_act[user_act.action_type==0]\n",
    "    user_act_0_4['user_act_0_4_count'] = user_act_0_4['user_id']\n",
    "    feat = pd.pivot_table(user_act_0_4,index=['user_id'],values='user_act_0_4_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del user_act_0_4;gc.collect();\n",
    "    #统计action_type为1的次数\n",
    "    user_act_1_4 = user_act[user_act.action_type==1]\n",
    "    user_act_1_4['user_act_1_5_count'] = user_act_1_4['user_id']\n",
    "    feat = pd.pivot_table(user_act_1_4,index=['user_id'],values='user_act_1_5_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del user_act_1_4 ;gc.collect();\n",
    "    #统计action_type为2的次数\n",
    "    user_act_2_4 = user_act[user_act.action_type==2]\n",
    "    user_act_2_4['user_act_2_4_count'] = user_act_2_4['user_id']\n",
    "    feat = pd.pivot_table(user_act_2_4,index=['user_id'],values='user_act_2_4_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del user_act_2_4 ;gc.collect();    \n",
    "    #统计action_type为3的次数\n",
    "    user_act_3_4 = user_act[user_act.action_type==3]\n",
    "    user_act_3_4['user_act_3_4_count'] = user_act_3_4['user_id']\n",
    "    feat = pd.pivot_table(user_act_3_4,index=['user_id'],values='user_act_3_4_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del user_act_3_4 ;gc.collect(); \n",
    "    #统计action_type为4的次数\n",
    "    user_act_4_4 = user_act[user_act.action_type==4]\n",
    "    user_act_4_4['user_act_4_4_count'] = user_act_4_4['user_id']\n",
    "    feat = pd.pivot_table(user_act_4_4,index=['user_id'],values='user_act_4_4_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del user_act_4_4;gc.collect();\n",
    "    #统计action_type为5的次数\n",
    "    user_act_5_4 = user_act[user_act.action_type==5]\n",
    "    user_act_5_4['user_act_5_4_count'] = user_act_5_4['user_id']\n",
    "    feat = pd.pivot_table(user_act_5_4,index=['user_id'],values='user_act_5_4_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del user_act_5_4  ;gc.collect();  \n",
    "#%% 前3天\n",
    "    user_act = user_act[(user_act.day>=day_min-3)&(user_act.day<=day_max-7)]\n",
    "    #统计前3天共活跃多少次\n",
    "    user_act['user_act_count_3'] = user_act['user_id']\n",
    "    feat = pd.pivot_table(user_act,index=['user_id'],values='user_act_count_3',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    \n",
    "    \"对page每种进行统计\"\n",
    "    #统计page为0的次数\n",
    "    page_0_3 = user_act[user_act.page==0]\n",
    "    page_0_3['page_0_3_count'] = page_0_3['user_id']\n",
    "    feat = pd.pivot_table(page_0_3,index=['user_id'],values='page_0_3_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del page_0_3;gc.collect();\n",
    "    #统计page为1的次数\n",
    "    page_1_3 = user_act[user_act.page==1]\n",
    "    page_1_3['page_1_3_count'] = page_1_3['user_id']\n",
    "    feat = pd.pivot_table(page_1_3,index=['user_id'],values='page_1_3_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del page_1_3;gc.collect();\n",
    "    #统计page为2的次数\n",
    "    page_2_3 = user_act[user_act.page==2]\n",
    "    page_2_3['page_2_3_count'] = page_2_3['user_id']\n",
    "    feat = pd.pivot_table(page_2_3,index=['user_id'],values='page_2_3_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del page_2_3;gc.collect();\n",
    "    #统计page为3的次数\n",
    "    page_3_3 = user_act[user_act.page==3]\n",
    "    page_3_3['page_3_3_count'] = page_3_3['user_id']\n",
    "    feat = pd.pivot_table(page_3_3,index=['user_id'],values='page_3_3_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del page_3_3;gc.collect();\n",
    "    #统计page为4的次数\n",
    "    page_4_3 = user_act[user_act.page==4]\n",
    "    page_4_3['page_4_3_count'] = page_4_3['user_id']\n",
    "    feat = pd.pivot_table(page_4_3,index=['user_id'],values='page_4_3_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del page_4_3;gc.collect();\n",
    "    \n",
    "    \"对action_type进行统计\"\n",
    "    #统计action_type为0的次数\n",
    "    user_act_0_3 = user_act[user_act.action_type==0]\n",
    "    user_act_0_3['user_act_0_3_count'] = user_act_0_3['user_id']\n",
    "    feat = pd.pivot_table(user_act_0_3,index=['user_id'],values='user_act_0_3_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del user_act_0_3;gc.collect();\n",
    "    #统计action_type为1的次数\n",
    "    user_act_1_3 = user_act[user_act.action_type==1]\n",
    "    user_act_1_3['user_act_1_3_count'] = user_act_1_3['user_id']\n",
    "    feat = pd.pivot_table(user_act_1_3,index=['user_id'],values='user_act_1_3_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del user_act_1_3;gc.collect();\n",
    "    #统计action_type为2的次数\n",
    "    user_act_2_3 = user_act[user_act.action_type==2]\n",
    "    user_act_2_3['user_act_2_3_count'] = user_act_2_3['user_id']\n",
    "    feat = pd.pivot_table(user_act_2_3,index=['user_id'],values='user_act_2_3_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del user_act_2_3;gc.collect();     \n",
    "    #统计action_type为3的次数\n",
    "    user_act_3_3 = user_act[user_act.action_type==3]\n",
    "    user_act_3_3['user_act_3_3_count'] = user_act_3_3['user_id']\n",
    "    feat = pd.pivot_table(user_act_3_3,index=['user_id'],values='user_act_3_3_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del user_act_3_3;gc.collect();  \n",
    "    #统计action_type为4的次数\n",
    "    user_act_4_3 = user_act[user_act.action_type==4]\n",
    "    user_act_4_3['user_act_4_3_count'] = user_act_4_3['user_id']\n",
    "    feat = pd.pivot_table(user_act_4_3,index=['user_id'],values='user_act_4_3_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del user_act_4_3;gc.collect(); \n",
    "    #统计action_type为5的次数\n",
    "    user_act_5_3 = user_act[user_act.action_type==5]\n",
    "    user_act_5_3['user_act_5_3_count'] = user_act_5_3['user_id']\n",
    "    feat = pd.pivot_table(user_act_5_3,index=['user_id'],values='user_act_5_3_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del user_act_5_3;gc.collect();\n",
    "    \n",
    "#%% 前2天\n",
    "    user_act = user_act[(user_act.day>=day_min-2)&(user_act.day<=day_max-7)]\n",
    "    #统计前2天共活跃多少次\n",
    "    user_act['user_act_count_2'] = user_act['user_id']\n",
    "    feat = pd.pivot_table(user_act,index=['user_id'],values='user_act_count_2',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    \n",
    "    \"对page每种进行统计\"\n",
    "    #统计page为0的次数\n",
    "    page_0_2 = user_act[user_act.page==0]\n",
    "    page_0_2['page_0_2_count'] = page_0_2['user_id']\n",
    "    feat = pd.pivot_table(page_0_2,index=['user_id'],values='page_0_2_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del page_0_2;gc.collect();\n",
    "    #统计page为1的次数\n",
    "    page_1_2 = user_act[user_act.page==1]\n",
    "    page_1_2['page_1_2_count'] = page_1_2['user_id']\n",
    "    feat = pd.pivot_table(page_1_2,index=['user_id'],values='page_1_2_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del page_1_2;gc.collect();\n",
    "    #统计page为2的次数\n",
    "    page_2_2 = user_act[user_act.page==2]\n",
    "    page_2_2['page_2_2_count'] = page_2_2['user_id']\n",
    "    feat = pd.pivot_table(page_2_2,index=['user_id'],values='page_2_2_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del page_2_2;gc.collect();\n",
    "    #统计page为3的次数\n",
    "    page_3_2 = user_act[user_act.page==3]\n",
    "    page_3_2['page_3_2_count'] = page_3_2['user_id']\n",
    "    feat = pd.pivot_table(page_3_2,index=['user_id'],values='page_3_2_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del page_3_2;gc.collect();\n",
    "    #统计page为4的次数\n",
    "    page_4_2 = user_act[user_act.page==4]\n",
    "    page_4_2['page_4_2_count'] = page_4_2['user_id']\n",
    "    feat = pd.pivot_table(page_4_2,index=['user_id'],values='page_4_2_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del page_4_2;gc.collect();\n",
    "    \n",
    "    \"对action_type进行统计\"\n",
    "    #统计action_type为0的次数\n",
    "    user_act_0_2 = user_act[user_act.action_type==0]\n",
    "    user_act_0_2['user_act_0_2_count'] = user_act_0_2['user_id']\n",
    "    feat = pd.pivot_table(user_act_0_2,index=['user_id'],values='user_act_0_2_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del user_act_0_2;gc.collect();\n",
    "    #统计action_type为1的次数\n",
    "    user_act_1_2 = user_act[user_act.action_type==1]\n",
    "    user_act_1_2['user_act_1_2_count'] = user_act_1_2['user_id']\n",
    "    feat = pd.pivot_table(user_act_1_2,index=['user_id'],values='user_act_1_2_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del user_act_1_2;gc.collect();\n",
    "    #统计action_type为2的次数\n",
    "    user_act_2_2 = user_act[user_act.action_type==2]\n",
    "    user_act_2_2['user_act_2_2_count'] = user_act_2_2['user_id']\n",
    "    feat = pd.pivot_table(user_act_2_2,index=['user_id'],values='user_act_2_2_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del user_act_2_2 ;gc.collect();    \n",
    "    #统计action_type为3的次数\n",
    "    user_act_3_2 = user_act[user_act.action_type==3]\n",
    "    user_act_3_2['user_act_3_2_count'] = user_act_3_2['user_id']\n",
    "    feat = pd.pivot_table(user_act_3_2,index=['user_id'],values='user_act_3_2_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del user_act_3_2 ;gc.collect(); \n",
    "    #统计action_type为4的次数\n",
    "    user_act_4_2 = user_act[user_act.action_type==4]\n",
    "    user_act_4_2['user_act_4_2_count'] = user_act_4_2['user_id']\n",
    "    feat = pd.pivot_table(user_act_4_2,index=['user_id'],values='user_act_4_2_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del user_act_4_2 ;gc.collect();\n",
    "    #统计action_type为5的次数\n",
    "    user_act_5_2 = user_act[user_act.action_type==5]\n",
    "    user_act_5_2['user_act_5_2_count'] = user_act_5_2['user_id']\n",
    "    feat = pd.pivot_table(user_act_5_2,index=['user_id'],values='user_act_5_2_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del user_act_5_2;gc.collect();\n",
    "    \n",
    "#%% 前1天\n",
    "    user_act = user_act[(user_act.day>=day_min-1)&(user_act.day<=day_max-7)]\n",
    "    #统计前1天共活跃多少次\n",
    "    user_act['user_act_count_1'] = user_act['user_id']\n",
    "    feat = pd.pivot_table(user_act,index=['user_id'],values='user_act_count_1',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    \n",
    "    \"对page每种进行统计\"\n",
    "    #统计page为0的次数\n",
    "    page_0_1 = user_act[user_act.page==0]\n",
    "    page_0_1['page_0_1_count'] = page_0_1['user_id']\n",
    "    feat = pd.pivot_table(page_0_1,index=['user_id'],values='page_0_1_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del page_0_1;gc.collect();\n",
    "    #统计page为1的次数\n",
    "    page_1_1 = user_act[user_act.page==1]\n",
    "    page_1_1['page_1_1_count'] = page_1_1['user_id']\n",
    "    feat = pd.pivot_table(page_1_1,index=['user_id'],values='page_1_1_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del page_1_1;gc.collect();\n",
    "    #统计page为2的次数\n",
    "    page_2_1 = user_act[user_act.page==2]\n",
    "    page_2_1['page_2_1_count'] = page_2_1['user_id']\n",
    "    feat = pd.pivot_table(page_2_1,index=['user_id'],values='page_2_1_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del page_2_1;gc.collect();\n",
    "    #统计page为3的次数\n",
    "    page_3_1 = user_act[user_act.page==3]\n",
    "    page_3_1['page_3_1_count'] = page_3_1['user_id']\n",
    "    feat = pd.pivot_table(page_3_1,index=['user_id'],values='page_3_1_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del page_3_1;gc.collect();\n",
    "    #统计page为4的次数\n",
    "    page_4_1 = user_act[user_act.page==4]\n",
    "    page_4_1['page_4_1_count'] = page_4_1['user_id']\n",
    "    feat = pd.pivot_table(page_4_1,index=['user_id'],values='page_4_1_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del page_4_1;gc.collect();\n",
    "    \n",
    "    \"对action_type进行统计\"\n",
    "    #统计action_type为0的次数\n",
    "    user_act_0_1 = user_act[user_act.action_type==0]\n",
    "    user_act_0_1['user_act_0_1_count'] = user_act_0_1['user_id']\n",
    "    feat = pd.pivot_table(user_act_0_1,index=['user_id'],values='user_act_0_1_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del user_act_0_1;gc.collect();\n",
    "    #统计action_type为1的次数\n",
    "    user_act_1_1 = user_act[user_act.action_type==1]\n",
    "    user_act_1_1['user_act_1_1_count'] = user_act_1_1['user_id']\n",
    "    feat = pd.pivot_table(user_act_1_1,index=['user_id'],values='user_act_1_1_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del user_act_1_1;gc.collect();\n",
    "    #统计action_type为2的次数\n",
    "    user_act_2_1 = user_act[user_act.action_type==2]\n",
    "    user_act_2_1['user_act_2_1_count'] = user_act_2_1['user_id']\n",
    "    feat = pd.pivot_table(user_act_2_1,index=['user_id'],values='user_act_2_1_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del user_act_2_1;gc.collect();    \n",
    "    #统计action_type为3的次数\n",
    "    user_act_3_1 = user_act[user_act.action_type==3]\n",
    "    user_act_3_1['user_act_3_1_count'] = user_act_3_1['user_id']\n",
    "    feat = pd.pivot_table(user_act_3_1,index=['user_id'],values='user_act_3_1_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del user_act_3_1;gc.collect();  \n",
    "    #统计action_type为4的次数\n",
    "    user_act_4_1 = user_act[user_act.action_type==4]\n",
    "    user_act_4_1['user_act_4_1_count'] = user_act_4_1['user_id']\n",
    "    feat = pd.pivot_table(user_act_4_1,index=['user_id'],values='user_act_4_1_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del user_act_4_1;gc.collect(); \n",
    "    #统计action_type为5的次数\n",
    "    user_act_5_1 = user_act[user_act.action_type==5]\n",
    "    user_act_5_1['user_act_5_1_count'] = user_act_5_1['user_id']\n",
    "    feat = pd.pivot_table(user_act_5_1,index=['user_id'],values='user_act_5_1_count',aggfunc='count').reset_index()\n",
    "    ans = pd.merge(ans,feat,on='user_id',how='left')\n",
    "    del user_act_5_1;gc.collect();\n",
    "    del feat;gc.collect();\n",
    "    del day_min;gc.collect();\n",
    "    del day_max;gc.collect();\n",
    "    del data;gc.collect();\n",
    "    del app;gc.collect();\n",
    "    del user_act;gc.collect();\n",
    "    del user_reg;gc.collect();\n",
    "    del vedio;gc.collect();\n",
    "    \n",
    "    return ans\n",
    "\n",
    "#%%\n",
    "\n",
    "def modelXgb(train,test):\n",
    "    \"xgb模型\"\n",
    "    train_y = train['label'].values\n",
    "                         \n",
    "    train_x = train.drop(['user_id','register_day','label'],axis=1).values\n",
    "    test_x = test.drop(['user_id','register_day'],axis=1).values        \n",
    "                    \n",
    "    dtrain = xgb.DMatrix(train_x, label=train_y)\n",
    "    dtest = xgb.DMatrix(test_x)\n",
    "    \n",
    "    del train_x;gc.collect();\n",
    "    del test_x;gc.collect();\n",
    "    \n",
    "    # 模型参数\n",
    "    params = {'booster': 'gbtree',\n",
    "              'objective':'binary:logistic',\n",
    "              'eval_metric':'auc',\n",
    "              'eta': 0.03,\n",
    "              'max_depth': 5,  # 6\n",
    "              'colsample_bytree': 0.9,#0.8\n",
    "              'subsample': 0.9,\n",
    "              'scale_pos_weight': 1,\n",
    "              'min_child_weight': 18  # 2\n",
    "              }\n",
    "    # 训练\n",
    "    watchlist = [(dtrain,'train')]\n",
    "    bst = xgb.train(params, dtrain, num_boost_round=1500,evals=watchlist)\n",
    "    # 预测\n",
    "    predict = bst.predict(dtest)\n",
    "    \n",
    "    del dtrain;gc.collect();\n",
    "    del dtest;gc.collect();\n",
    "    \n",
    "    test_xy = test[['user_id']]\n",
    "    test_xy['predicted_score'] = predict\n",
    "    test_xy = test_xy.sort_values('predicted_score', ascending=False)\n",
    "    \n",
    "    del predict;gc.collect();\n",
    "    \n",
    "    return test_xy\n",
    "\n",
    "#%%\n",
    "def main():\n",
    "    \"训练模型\"\n",
    "    print('下载数据...')\n",
    "    app,user_act,user_reg,vedio = loadData()\n",
    "    print('打标数据...')\n",
    "    test,train1,train2,train3,train4,train5,train6,train7,train8,train9,train10,train11,train12,train13,train14 = makeLabel(app,user_act,user_reg,vedio)\n",
    "    \n",
    "    print('提取te特征...')\n",
    "    te = genFeature(31,37,test,app,user_act,user_reg,vedio)\n",
    "    del test;gc.collect();\n",
    "    print('测试集提取完成...')\n",
    "\n",
    "    #训练集提取特征\n",
    "    print('提取tr1特征...')\n",
    "    tr1 = genFeature(24,30,train1,app,user_act,user_reg,vedio)\n",
    "    del train1;gc.collect();\n",
    "    print('提取tr2特征...')\n",
    "    tr2 = genFeature(23,29,train2,app,user_act,user_reg,vedio)\n",
    "    del train2;gc.collect();\n",
    "    print('提取tr3特征...')\n",
    "    tr3 = genFeature(22,28,train3,app,user_act,user_reg,vedio)\n",
    "    del train3;gc.collect();\n",
    "    print('提取tr4特征...')\n",
    "    tr4 = genFeature(21,27,train4,app,user_act,user_reg,vedio)\n",
    "    del train4;gc.collect();\n",
    "    print('提取tr5特征...')\n",
    "    tr5 = genFeature(20,26,train5,app,user_act,user_reg,vedio)\n",
    "    del train5;gc.collect();  \n",
    "    print('提取tr6特征...')\n",
    "    tr6 = genFeature(19,25,train6,app,user_act,user_reg,vedio)\n",
    "    del train6;gc.collect();  \n",
    "    print('提取tr7特征...')\n",
    "    tr7 = genFeature(18,24,train7,app,user_act,user_reg,vedio)\n",
    "    del train7;gc.collect(); \n",
    "    print('提取tr8特征...')\n",
    "    tr8 = genFeature(17,23,train8,app,user_act,user_reg,vedio)\n",
    "    del train8;gc.collect(); \n",
    "    print('提取tr9特征...')\n",
    "    tr9 = genFeature(16,22,train9,app,user_act,user_reg,vedio)\n",
    "    del train9;gc.collect(); \n",
    "    print('提取tr10特征...')\n",
    "    tr10 = genFeature(15,21,train10,app,user_act,user_reg,vedio)\n",
    "    del train10;gc.collect(); \n",
    "    print('提取tr11特征...')\n",
    "    tr11 = genFeature(14,20,train11,app,user_act,user_reg,vedio)\n",
    "    del train11;gc.collect(); \n",
    "    print('提取tr12特征...')\n",
    "    tr12 = genFeature(13,19,train12,app,user_act,user_reg,vedio)\n",
    "    del train12;gc.collect();\n",
    "    print('提取tr13特征...')\n",
    "    tr13 = genFeature(12,18,train13,app,user_act,user_reg,vedio)\n",
    "    del train13;gc.collect();\n",
    "    print('提取tr14特征...')\n",
    "    tr14 = genFeature(11,17,train14,app,user_act,user_reg,vedio)\n",
    "    del train14;gc.collect();\n",
    "    \n",
    "    del app;gc.collect();\n",
    "    del user_act;gc.collect();\n",
    "    del user_reg;gc.collect();\n",
    "    del vedio;gc.collect();\n",
    "    \n",
    "    #合并训练集\n",
    "    tr = pd.concat([tr1,tr2,tr3,tr4,tr5,tr6,tr7,tr8,tr9,tr10,tr11,tr12,tr13,tr14],axis=0)\n",
    "    del tr1;gc.collect();\n",
    "    del tr2;gc.collect();\n",
    "    del tr3;gc.collect();\n",
    "    del tr4;gc.collect();\n",
    "    del tr5;gc.collect();\n",
    "    del tr6;gc.collect();\n",
    "    del tr7;gc.collect();\n",
    "    del tr8;gc.collect();\n",
    "    del tr9;gc.collect();\n",
    "    del tr10;gc.collect();\n",
    "    del tr11;gc.collect();\n",
    "    del tr12;gc.collect();\n",
    "    del tr13;gc.collect();\n",
    "    del tr14;gc.collect();\n",
    "    \n",
    "    print('开始训练模型...')\n",
    "    #训练模型\n",
    "    answer = modelXgb(tr,te)\n",
    "    print('结束训练模型...')\n",
    "    #导出结果\n",
    "    answer.to_csv('/home/kesci/work/yw_model.txt',index=False, header=None)\n",
    "    #提交文件my_submission.txt进行评审；温馨提示:本次比赛提交文件的格式为txt\n",
    "    #!./kesci_submit -token 61c8c5af49a7abd0 -file ans_0723_2.txt    \n",
    "  \n",
    "#%%\n",
    "if __name__ == '__main__':\n",
    "   \"主函数入口\"\n",
    "\n",
    "   main()\n",
    "\n",
    "#%%\n",
    "   \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "0DB0B92AC4BC49A79FFCB4AAD1323449"
   },
   "outputs": [],
   "source": [
    "# 模型3--闵子剑模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "7527B085E8664D25AB6B22E8BEFFD400"
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import xgboost as xgb\n",
    "\n",
    "def readData():\n",
    "    print('reading...')\n",
    "    print('app launch')\n",
    "    user_launch = pd.read_csv(r'/mnt/datasets/fusai/app_launch_log.txt', sep='\\t', header=None)\n",
    "    user_launch.columns = ['user_id', 'day']\n",
    "\n",
    "    print('user register')\n",
    "    user_register = pd.read_csv(r'/mnt/datasets/fusai/user_register_log.txt', sep='\\t', header=None)\n",
    "    user_register.columns = ['user_id', 'register_day', 'register_type', 'device_type']\n",
    "\n",
    "    print('video create')\n",
    "    video_create = pd.read_csv(r'/mnt/datasets/fusai/video_create_log.txt', sep='\\t', header=None)\n",
    "    video_create.columns = ['user_id', 'day']\n",
    "\n",
    "    print('user activity')\n",
    "    user_activity = pd.read_csv(r'/mnt/datasets/fusai/user_activity_log.txt', sep='\\t', header=None)\n",
    "    user_activity.columns = ['user_id', 'day', 'page', 'video_id', 'author_id', 'action_type']\n",
    "    print('reading have finished!')\n",
    "\n",
    "    return user_launch, user_register, video_create, user_activity\n",
    "\n",
    "def labelRegister(user_launch, user_register, video_create, user_activity, f_start, f_end):\n",
    "    print('labeling...')\n",
    "    act_user = pd.concat([user_launch, video_create]).reset_index(drop = True)\n",
    "    act_user = pd.concat([act_user, user_activity[['user_id', 'day']]]).reset_index(drop = True)\n",
    "    act_user = act_user[(act_user.day >= f_start) & (act_user.day <= f_end)]\n",
    "    act_user = act_user[['user_id']]\n",
    "    act_user.drop_duplicates(inplace = True)\n",
    "    act_user['label'] = 1\n",
    "\n",
    "    user_register = user_register[user_register.register_day <= (f_start - 1)]\n",
    "    user_register = pd.merge(user_register, act_user, on = ['user_id'], how = 'left')\n",
    "    user_register.fillna(0, inplace = True)\n",
    "    print('labeling have finished!')\n",
    "    return user_register\n",
    "\n",
    "def getMaxMinNormalization(feature):\n",
    "    max = np.max(feature)\n",
    "    min = np.min(feature)\n",
    "\n",
    "    return (feature - min) / (max - min)\n",
    "\n",
    "def getLabel(user_launch, user_register, video_create, user_activity):\n",
    "    print('label1...')\n",
    "    register_have_label1 = labelRegister(user_launch, user_register, video_create, user_activity, 24, 30)\n",
    "    print('label2...')\n",
    "    register_have_label2 = labelRegister(user_launch, user_register, video_create, user_activity, 17, 23)\n",
    "\n",
    "    return register_have_label1, register_have_label2\n",
    "\n",
    "def getLastDayFeature(user_launch, user_register, video_create, user_activity, f_start, f_end):\n",
    "    print('get last day feature...')\n",
    "    t1 = user_launch[(user_launch.day >= f_start) &\n",
    "                     (user_launch.day <= f_end)][['user_id']]\n",
    "    t1['user_%d_before_launch_count' % (f_end - f_start + 1)] = 1\n",
    "    feat = pd.pivot_table(t1, index=['user_id'],\n",
    "                          values='user_%d_before_launch_count' % (f_end - f_start + 1),\n",
    "                          aggfunc='sum').reset_index()\n",
    "\n",
    "    t1_1 = pd.merge(feat, user_register[['user_id', 'register_type', 'device_type']], on=['user_id'], how='left')\n",
    "    t1_1 = t1_1[['register_type', 'device_type', 'user_%d_before_launch_count' % (f_end - f_start + 1)]]\n",
    "    feat1 = pd.pivot_table(t1_1, index=['register_type', 'device_type'],\n",
    "                           values='user_%d_before_launch_count' % (f_end - f_start + 1),\n",
    "                           aggfunc='sum').reset_index()\n",
    "    feat1.rename(columns={'user_%d_before_launch_count' % (f_end - f_start + 1):\n",
    "                              'device_register_type_%d_before_launch_count'\n",
    "                              % (f_end - f_start + 1)}, inplace=True)\n",
    "    feat1['device_register_type_%d_before_launch_count' %\n",
    "          (f_end - f_start + 1)] = \\\n",
    "        getMaxMinNormalization(feat1['device_register_type_%d_before_launch_count' %\n",
    "                                     (f_end - f_start + 1)])\n",
    "    feat2 = pd.pivot_table(t1_1, index=['device_type'],\n",
    "                           values='user_%d_before_launch_count' % (f_end - f_start + 1),\n",
    "                           aggfunc='sum').reset_index()\n",
    "    feat2.rename(columns={'user_%d_before_launch_count' % (f_end - f_start + 1):\n",
    "                              'device_type_%d_before_launch_count' % (f_end - f_start + 1)}, inplace=True)\n",
    "    feat2['device_type_%d_before_launch_count' %\n",
    "          (f_end - f_start + 1)] = \\\n",
    "        getMaxMinNormalization(feat2['device_type_%d_before_launch_count' %\n",
    "                                     (f_end - f_start + 1)])\n",
    "    feat3 = pd.pivot_table(t1_1, index=['register_type'],\n",
    "                           values='user_%d_before_launch_count' % (f_end - f_start + 1),\n",
    "                           aggfunc='sum').reset_index()\n",
    "    feat3.rename(columns={'user_%d_before_launch_count' % (f_end - f_start + 1):\n",
    "                              'register_type_%d_before_launch_count'\n",
    "                              % (f_end - f_start + 1)}, inplace=True)\n",
    "    feat3['register_type_%d_before_launch_count' %\n",
    "          (f_end - f_start + 1)] = \\\n",
    "        getMaxMinNormalization(feat3['register_type_%d_before_launch_count' %\n",
    "                                     (f_end - f_start + 1)])\n",
    "\n",
    "    t1 = pd.pivot_table(t1, index=['user_id'],\n",
    "                        values='user_%d_before_launch_count' % (f_end - f_start + 1),\n",
    "                        aggfunc='sum').reset_index()\n",
    "    t1['user_%d_before_launch_count' % (f_end - f_start + 1)] = \\\n",
    "        getMaxMinNormalization(t1['user_%d_before_launch_count' % (f_end - f_start + 1)])\n",
    "    user_register = pd.merge(user_register, t1, on=['user_id'], how='left')\n",
    "    user_register = pd.merge(user_register, feat1, on=['register_type', 'device_type'], how='left')\n",
    "    user_register = pd.merge(user_register, feat2, on=['device_type'], how='left')\n",
    "    user_register = pd.merge(user_register, feat3, on=['register_type'], how='left')\n",
    "    user_register.fillna(0, inplace=True)\n",
    "\n",
    "    t2 = video_create[(video_create.day >= f_start) &\n",
    "                      (video_create.day <= f_end)][['user_id']]\n",
    "    t2['user_%d_before_video_create_count' % (f_end - f_start + 1)] = 1\n",
    "    feat = pd.pivot_table(t2, index=['user_id'],\n",
    "                          values='user_%d_before_video_create_count' % (f_end - f_start + 1),\n",
    "                          aggfunc='sum').reset_index()\n",
    "    t2_1 = pd.merge(feat, user_register[['user_id', 'register_type', 'device_type']], on=['user_id'], how='left')\n",
    "    t2_1 = t2_1[['register_type', 'device_type', 'user_%d_before_video_create_count' % (f_end - f_start + 1)]]\n",
    "    feat1 = pd.pivot_table(t2_1, index=['register_type', 'device_type'],\n",
    "                           values='user_%d_before_video_create_count' % (f_end - f_start + 1),\n",
    "                           aggfunc='sum').reset_index()\n",
    "    feat1.rename(columns={'user_%d_before_video_create_count' % (f_end - f_start + 1):\n",
    "                              'device_register_type_%d_before_video_create_count'\n",
    "                              % (f_end - f_start + 1)}, inplace=True)\n",
    "    feat1['device_register_type_%d_before_video_create_count' %\n",
    "          (f_end - f_start + 1)] = \\\n",
    "        getMaxMinNormalization(feat1['device_register_type_%d_before_video_create_count' %\n",
    "                                     (f_end - f_start + 1)])\n",
    "    feat2 = pd.pivot_table(t2_1, index=['device_type'],\n",
    "                           values='user_%d_before_video_create_count' % (f_end - f_start + 1),\n",
    "                           aggfunc='sum').reset_index()\n",
    "    feat2.rename(columns={'user_%d_before_video_create_count' % (f_end - f_start + 1):\n",
    "                              'device_type_%d_before_video_create_count' % (f_end - f_start + 1)}, inplace=True)\n",
    "    feat2['device_type_%d_before_video_create_count' %\n",
    "          (f_end - f_start + 1)] = \\\n",
    "        getMaxMinNormalization(feat2['device_type_%d_before_video_create_count' %\n",
    "                                     (f_end - f_start + 1)])\n",
    "\n",
    "    feat3 = pd.pivot_table(t2_1, index=['register_type'],\n",
    "                           values='user_%d_before_video_create_count' % (f_end - f_start + 1),\n",
    "                           aggfunc='sum').reset_index()\n",
    "    feat3.rename(columns={'user_%d_before_video_create_count' % (f_end - f_start + 1):\n",
    "                              'register_type_%d_before_video_create_count' % (f_end - f_start + 1)}, inplace=True)\n",
    "    feat3['register_type_%d_before_video_create_count' %\n",
    "          (f_end - f_start + 1)] = \\\n",
    "        getMaxMinNormalization(feat3['register_type_%d_before_video_create_count' %\n",
    "                                     (f_end - f_start + 1)])\n",
    "    t2 = pd.pivot_table(t2, index=['user_id'],\n",
    "                        values='user_%d_before_video_create_count' % (f_end - f_start + 1),\n",
    "                        aggfunc='sum').reset_index()\n",
    "    t2['user_%d_before_video_create_count' % (f_end - f_start + 1)] = \\\n",
    "        getMaxMinNormalization(t2['user_%d_before_video_create_count'\n",
    "                                  % (f_end - f_start + 1)])\n",
    "    user_register = pd.merge(user_register, t2, on=['user_id'], how='left')\n",
    "    user_register = pd.merge(user_register, feat1, on=['register_type', 'device_type'], how='left')\n",
    "    user_register = pd.merge(user_register, feat2, on=['device_type'], how='left')\n",
    "    user_register = pd.merge(user_register, feat3, on=['register_type'], how='left')\n",
    "    user_register.fillna(0, inplace=True)\n",
    "\n",
    "    for i in range(5):\n",
    "        t3 = user_activity[(user_activity.day >= f_start) &\n",
    "                           (user_activity.day <= f_end) &\n",
    "                           (user_activity.page == i)][['user_id']]\n",
    "        t3['user_%d_before_page_count_%d' % (f_end - f_start + 1, i)] = 1\n",
    "        t3 = pd.pivot_table(t3, index=['user_id'],\n",
    "                            values='user_%d_before_page_count_%d' % (f_end - f_start + 1, i),\n",
    "                            aggfunc='sum').reset_index()\n",
    "        t3['user_%d_before_page_count_%d' % (f_end - f_start + 1, i)] = \\\n",
    "            getMaxMinNormalization(t3['user_%d_before_page_count_%d'\n",
    "                                      % (f_end - f_start + 1, i)])\n",
    "        user_register = pd.merge(user_register, t3, on=['user_id'], how='left')\n",
    "        user_register.fillna(0, inplace=True)\n",
    "\n",
    "    for j in range(6):\n",
    "        t4 = user_activity[(user_activity.day >= f_start) &\n",
    "                           (user_activity.day <= f_end) &\n",
    "                           (user_activity.action_type == j)][['user_id']]\n",
    "        t4['user_%d_before_action_type_count_%d' % (f_end - f_start + 1, j)] = 1\n",
    "        t4 = pd.pivot_table(t4, index=['user_id'],\n",
    "                            values='user_%d_before_action_type_count_%d' % (f_end - f_start + 1, j),\n",
    "                            aggfunc='sum').reset_index()\n",
    "        t4['user_%d_before_action_type_count_%d' % (f_end - f_start + 1, j)] = \\\n",
    "            getMaxMinNormalization(t4['user_%d_before_action_type_count_%d'\n",
    "                                      % (f_end - f_start + 1, j)])\n",
    "        user_register = pd.merge(user_register, t4, on=['user_id'], how='left')\n",
    "        user_register.fillna(0, inplace=True)\n",
    "\n",
    "    t5 = user_activity[(user_activity.day >= f_start) &\n",
    "                       (user_activity.day <= f_end)][['user_id', 'video_id']]\n",
    "    t5.drop_duplicates(inplace = True)\n",
    "    t5['video_id'] = 1\n",
    "    t5 = pd.pivot_table(t5, index=['user_id'],\n",
    "                        values='video_id',\n",
    "                        aggfunc='sum').reset_index()\n",
    "    t5['video_id'] = getMaxMinNormalization(t5['video_id'])\n",
    "    t5.rename(columns={'video_id': 'user_%d_before_watch_video_type_count'\n",
    "                                   % (f_end - f_start + 1)}, inplace=True)\n",
    "    user_register = pd.merge(user_register, t5, on=['user_id'], how='left')\n",
    "    user_register.fillna(0, inplace=True)\n",
    "\n",
    "    t6 = user_activity[(user_activity.day >= f_start) &\n",
    "                       (user_activity.day <= f_end)][['user_id', 'author_id']]\n",
    "    t6.drop_duplicates(inplace = True)\n",
    "    t6['author_id'] = 1\n",
    "    t6 = pd.pivot_table(t6, index=['user_id'],\n",
    "                        values='author_id',\n",
    "                        aggfunc='sum').reset_index()\n",
    "    t6['author_id'] = getMaxMinNormalization(t6['author_id'])\n",
    "    t6.rename(columns={'author_id': 'user_%d_before_watch_video_author_type_count'\n",
    "                                    % (f_end - f_start + 1)}, inplace=True)\n",
    "    user_register = pd.merge(user_register, t6, on=['user_id'], how='left')\n",
    "    user_register.fillna(0, inplace=True)\n",
    "\n",
    "    t7 = user_activity[(user_activity.day >= f_start) &\n",
    "                       (user_activity.day <= f_end)][['user_id']]\n",
    "    t7['user_%d_before_activity_count' % (f_end - f_start + 1)] = 1\n",
    "    feat = pd.pivot_table(t7, index=['user_id'],\n",
    "                          values='user_%d_before_activity_count' % (f_end - f_start + 1),\n",
    "                          aggfunc='sum').reset_index()\n",
    "\n",
    "    t7_1 = pd.merge(feat, user_register[['user_id', 'register_type', 'device_type']], on=['user_id'], how='left')\n",
    "    t7_1 = t7_1[['register_type', 'device_type', 'user_%d_before_activity_count' % (f_end - f_start + 1)]]\n",
    "    feat1 = pd.pivot_table(t7_1, index=['register_type', 'device_type'],\n",
    "                           values='user_%d_before_activity_count' % (f_end - f_start + 1),\n",
    "                           aggfunc='sum').reset_index()\n",
    "    feat2 = pd.pivot_table(t7_1, index=['device_type'],\n",
    "                           values='user_%d_before_activity_count' % (f_end - f_start + 1),\n",
    "                           aggfunc='sum').reset_index()\n",
    "    feat3 = pd.pivot_table(t7_1, index=['register_type'],\n",
    "                           values='user_%d_before_activity_count' % (f_end - f_start + 1),\n",
    "                           aggfunc='sum').reset_index()\n",
    "    feat1.rename(columns={'user_%d_before_activity_count' % (f_end - f_start + 1):\n",
    "                              'device_register_type_%d_before_activity_count' % (f_end - f_start + 1)}, inplace=True)\n",
    "    feat2.rename(columns={'user_%d_before_activity_count' % (f_end - f_start + 1):\n",
    "                              'device_type_%d_before_activity_count' % (f_end - f_start + 1)}, inplace=True)\n",
    "    feat3.rename(columns={'user_%d_before_activity_count' % (f_end - f_start + 1):\n",
    "                              'register_type_%d_before_activity_count' % (f_end - f_start + 1)}, inplace=True)\n",
    "    feat1['device_register_type_%d_before_activity_count'\n",
    "          % (f_end - f_start + 1)] = \\\n",
    "        getMaxMinNormalization(feat1['device_register_type_%d_before_activity_count'\n",
    "                                     % (f_end - f_start + 1)])\n",
    "    feat2['device_type_%d_before_activity_count'\n",
    "          % (f_end - f_start + 1)] = \\\n",
    "        getMaxMinNormalization(feat2['device_type_%d_before_activity_count'\n",
    "                                     % (f_end - f_start + 1)])\n",
    "    feat3['register_type_%d_before_activity_count'\n",
    "          % (f_end - f_start + 1)] = \\\n",
    "        getMaxMinNormalization(feat3['register_type_%d_before_activity_count'\n",
    "                                     % (f_end - f_start + 1)])\n",
    "\n",
    "    user_register = pd.merge(user_register, feat1, on=['register_type', 'device_type'], how='left')\n",
    "    user_register = pd.merge(user_register, feat2, on=['device_type'], how='left')\n",
    "    user_register = pd.merge(user_register, feat3, on=['register_type'], how='left')\n",
    "    user_register.fillna(0, inplace=True)\n",
    "\n",
    "    for i in range(6):\n",
    "        t8 = user_activity[(user_activity.day >= f_start) &\n",
    "                           (user_activity.day <= f_end) &\n",
    "                           (user_activity.action_type == i)][['author_id']]\n",
    "        t8['author_%d_before_action_type_%d_showed_count'\n",
    "           % (f_end - f_start + 1, i)] = 1\n",
    "        t8 = pd.pivot_table(t8, index=['author_id'],\n",
    "                             values='author_%d_before_action_type_%d_showed_count' % (f_end - f_start + 1, i),\n",
    "                             aggfunc='sum').reset_index()\n",
    "        t8['author_%d_before_action_type_%d_showed_count'\n",
    "           % (f_end - f_start + 1, i)] = \\\n",
    "            getMaxMinNormalization(t8['author_%d_before_action_type_%d_showed_count'\n",
    "                                      % (f_end - f_start + 1, i)])\n",
    "        t8.rename(columns={'author_id': 'user_id'}, inplace=True)\n",
    "        user_register = pd.merge(user_register, t8, on=['user_id'], how='left')\n",
    "        user_register.fillna(0, inplace=True)\n",
    "\n",
    "    print('get last day feature have finished!')\n",
    "    return user_register\n",
    "\n",
    "def getAllTimeFeature(user_launch, user_register, video_create, user_activity, f_start, f_end):\n",
    "    print('get all time feature...')\n",
    "    t1 = user_launch[(user_launch.day >= f_start) &\n",
    "                     (user_launch.day <= f_end)][['user_id', 'day']]\n",
    "    t1['user_%d_before_launch_count' % (f_end - f_start + 1)] = 1\n",
    "    feat = pd.pivot_table(t1, index=['user_id'],\n",
    "                          values='user_%d_before_launch_count' % (f_end - f_start + 1),\n",
    "                          aggfunc='sum').reset_index()\n",
    "\n",
    "    t1_1 = pd.merge(feat, user_register[['user_id', 'register_type', 'device_type']], on=['user_id'], how='left')\n",
    "    t1_1 = t1_1[['register_type', 'device_type', 'user_%d_before_launch_count' % (f_end - f_start + 1)]]\n",
    "    feat1 = pd.pivot_table(t1_1, index=['register_type', 'device_type'],\n",
    "                           values='user_%d_before_launch_count' % (f_end - f_start + 1),\n",
    "                           aggfunc='sum').reset_index()\n",
    "    feat1.rename(columns={'user_%d_before_launch_count' % (f_end - f_start + 1):\n",
    "                              'device_register_type_%d_before_launch_count' % (f_end - f_start + 1)}, inplace=True)\n",
    "    feat1['device_register_type_%d_before_launch_count' %\n",
    "          (f_end - f_start + 1)] = \\\n",
    "        getMaxMinNormalization(feat1['device_register_type_%d_before_launch_count' %\n",
    "                                     (f_end - f_start + 1)])\n",
    "    feat2 = pd.pivot_table(t1_1, index=['device_type'],\n",
    "                           values='user_%d_before_launch_count' % (f_end - f_start + 1),\n",
    "                           aggfunc='sum').reset_index()\n",
    "    feat2.rename(columns={'user_%d_before_launch_count' % (f_end - f_start + 1):\n",
    "                              'device_type_%d_before_launch_count' % (f_end - f_start + 1)}, inplace=True)\n",
    "    feat2['device_type_%d_before_launch_count' %\n",
    "          (f_end - f_start + 1)] = \\\n",
    "        getMaxMinNormalization(feat2['device_type_%d_before_launch_count' %\n",
    "                                     (f_end - f_start + 1)])\n",
    "\n",
    "    feat3 = pd.pivot_table(t1_1, index=['register_type'],\n",
    "                           values='user_%d_before_launch_count' % (f_end - f_start + 1),\n",
    "                           aggfunc='sum').reset_index()\n",
    "    feat3.rename(columns={'user_%d_before_launch_count' % (f_end - f_start + 1):\n",
    "                              'register_type_%d_before_launch_count' % (f_end - f_start + 1)}, inplace=True)\n",
    "    feat3['register_type_%d_before_launch_count' %\n",
    "          (f_end - f_start + 1)] = \\\n",
    "        getMaxMinNormalization(feat3['register_type_%d_before_launch_count' %\n",
    "                                     (f_end - f_start + 1)])\n",
    "\n",
    "    t1['user_%d_before_launch_count' % (f_end - f_start + 1)] = \\\n",
    "        (t1['day'] - f_start) / (f_end - f_start)\n",
    "    t1 = pd.pivot_table(t1, index=['user_id'],\n",
    "                        values='user_%d_before_launch_count' % (f_end - f_start + 1),\n",
    "                        aggfunc='sum').reset_index()\n",
    "    t1['user_%d_before_launch_count' % (f_end - f_start + 1)] = \\\n",
    "        getMaxMinNormalization(t1['user_%d_before_launch_count' % (f_end - f_start + 1)])\n",
    "    user_register = pd.merge(user_register, t1, on=['user_id'], how='left')\n",
    "    user_register = pd.merge(user_register, feat1, on=['register_type', 'device_type'], how='left')\n",
    "    user_register = pd.merge(user_register, feat2, on=['device_type'], how='left')\n",
    "    user_register = pd.merge(user_register, feat3, on=['register_type'], how='left')\n",
    "    user_register.fillna(0, inplace=True)\n",
    "\n",
    "    t2 = video_create[(video_create.day >= f_start) &\n",
    "                      (video_create.day <= f_end)][['user_id', 'day']]\n",
    "    t2['user_%d_before_video_create_count' % (f_end - f_start + 1)] = 1\n",
    "    feat = pd.pivot_table(t2, index=['user_id'],\n",
    "                          values='user_%d_before_video_create_count' % (f_end - f_start + 1),\n",
    "                          aggfunc='sum').reset_index()\n",
    "\n",
    "    t2_1 = pd.merge(feat, user_register[['user_id', 'register_type', 'device_type']], on=['user_id'], how='left')\n",
    "    t2_1 = t2_1[['register_type', 'device_type', 'user_%d_before_video_create_count' % (f_end - f_start + 1)]]\n",
    "    feat1 = pd.pivot_table(t2_1, index=['register_type', 'device_type'],\n",
    "                           values='user_%d_before_video_create_count' % (f_end - f_start + 1),\n",
    "                           aggfunc='sum').reset_index()\n",
    "    feat1.rename(columns={'user_%d_before_video_create_count' % (f_end - f_start + 1):\n",
    "                              'device_register_type_%d_before_video_create_count'\n",
    "                              % (f_end - f_start + 1)}, inplace=True)\n",
    "    feat1['device_register_type_%d_before_video_create_count' %\n",
    "          (f_end - f_start + 1)] = \\\n",
    "        getMaxMinNormalization(feat1['device_register_type_%d_before_video_create_count' %\n",
    "                                     (f_end - f_start + 1)])\n",
    "    feat2 = pd.pivot_table(t2_1, index=['device_type'],\n",
    "                           values='user_%d_before_video_create_count' % (f_end - f_start + 1),\n",
    "                           aggfunc='sum').reset_index()\n",
    "    feat2.rename(columns={'user_%d_before_video_create_count' % (f_end - f_start + 1):\n",
    "                              'device_type_%d_before_video_create_count' % (f_end - f_start + 1)}, inplace=True)\n",
    "    feat2['device_type_%d_before_video_create_count' %\n",
    "          (f_end - f_start + 1)] = \\\n",
    "        getMaxMinNormalization(feat2['device_type_%d_before_video_create_count' %\n",
    "                                     (f_end - f_start + 1)])\n",
    "\n",
    "    feat3 = pd.pivot_table(t2_1, index=['register_type'],\n",
    "                           values='user_%d_before_video_create_count' % (f_end - f_start + 1),\n",
    "                           aggfunc='sum').reset_index()\n",
    "    feat3.rename(columns={'user_%d_before_video_create_count' % (f_end - f_start + 1):\n",
    "                              'register_type_%d_before_video_create_count' % (f_end - f_start + 1)}, inplace=True)\n",
    "    feat3['register_type_%d_before_video_create_count' %\n",
    "          (f_end - f_start + 1)] = \\\n",
    "        getMaxMinNormalization(feat3['register_type_%d_before_video_create_count' %\n",
    "                                     (f_end - f_start + 1)])\n",
    "\n",
    "    t2['user_%d_before_video_create_count' % (f_end - f_start + 1)] = \\\n",
    "        (t2['day'] - f_start) / (f_end - f_start)\n",
    "    t2 = pd.pivot_table(t2, index=['user_id'],\n",
    "                        values='user_%d_before_video_create_count' % (f_end - f_start + 1),\n",
    "                        aggfunc='sum').reset_index()\n",
    "    t2['user_%d_before_video_create_count' % (f_end - f_start + 1)] = \\\n",
    "        getMaxMinNormalization(t2['user_%d_before_video_create_count'\n",
    "                                  % (f_end - f_start + 1)])\n",
    "    user_register = pd.merge(user_register, t2, on=['user_id'], how='left')\n",
    "    user_register = pd.merge(user_register, feat1, on=['register_type', 'device_type'], how='left')\n",
    "    user_register = pd.merge(user_register, feat2, on=['device_type'], how='left')\n",
    "    user_register = pd.merge(user_register, feat3, on=['register_type'], how='left')\n",
    "    user_register.fillna(0, inplace=True)\n",
    "\n",
    "    for i in range(5):\n",
    "        t3 = user_activity[(user_activity.day >= f_start) &\n",
    "                           (user_activity.day <= f_end) &\n",
    "                           (user_activity.page == i)][['user_id', 'day']]\n",
    "        t3['user_%d_before_page_count_%d' % (f_end - f_start + 1, i)] \\\n",
    "            = (t3['day'] - f_start) / (f_end - f_start)\n",
    "        t3 = pd.pivot_table(t3, index=['user_id'],\n",
    "                            values='user_%d_before_page_count_%d' % (f_end - f_start + 1, i),\n",
    "                            aggfunc='sum').reset_index()\n",
    "        t3['user_%d_before_page_count_%d' % (f_end - f_start + 1, i)] = \\\n",
    "            getMaxMinNormalization(t3['user_%d_before_page_count_%d'\n",
    "                                      % (f_end - f_start + 1, i)])\n",
    "        user_register = pd.merge(user_register, t3, on=['user_id'], how='left')\n",
    "        user_register.fillna(0, inplace=True)\n",
    "\n",
    "    for j in range(6):\n",
    "        t4 = user_activity[(user_activity.day >= f_start) &\n",
    "                           (user_activity.day <= f_end) &\n",
    "                           (user_activity.action_type == j)][['user_id', 'day']]\n",
    "        t4['user_%d_before_action_type_count_%d' % (f_end - f_start + 1, j)] = \\\n",
    "            (t4['day'] - f_start) / (f_end - f_start)\n",
    "        t4 = pd.pivot_table(t4, index=['user_id'],\n",
    "                            values='user_%d_before_action_type_count_%d' % (f_end - f_start + 1, j),\n",
    "                            aggfunc='sum').reset_index()\n",
    "        t4['user_%d_before_action_type_count_%d' % (f_end - f_start + 1, j)] = \\\n",
    "            getMaxMinNormalization(t4['user_%d_before_action_type_count_%d'\n",
    "                                      % (f_end - f_start + 1, j)])\n",
    "        user_register = pd.merge(user_register, t4, on=['user_id'], how='left')\n",
    "        user_register.fillna(0, inplace=True)\n",
    "\n",
    "    t5 = user_activity[(user_activity.day >= f_start) &\n",
    "                       (user_activity.day <= f_end)][['user_id', 'video_id', 'day']]\n",
    "    t5 = t5.groupby(['user_id', 'video_id']).agg('max').reset_index()\n",
    "    t5['video_id'] = (t5['day'] - f_start) / (f_end - f_start)\n",
    "    t5 = pd.pivot_table(t5, index=['user_id'],\n",
    "                        values='video_id',\n",
    "                        aggfunc='sum').reset_index()\n",
    "    t5['video_id'] = getMaxMinNormalization(t5['video_id'])\n",
    "    t5.rename(columns={'video_id': 'user_%d_before_watch_video_type_count'\n",
    "                                   % (f_end - f_start + 1)}, inplace=True)\n",
    "    user_register = pd.merge(user_register, t5, on=['user_id'], how='left')\n",
    "    user_register.fillna(0, inplace=True)\n",
    "\n",
    "    t6 = user_activity[(user_activity.day >= f_start) &\n",
    "                       (user_activity.day <= f_end)][['user_id', 'author_id', 'day']]\n",
    "    t6 = t6.groupby(['user_id', 'author_id']).agg('max').reset_index()\n",
    "    t6['author_id'] = (t6['day'] - f_start) / (f_end - f_start)\n",
    "    t6 = pd.pivot_table(t6, index=['user_id'],\n",
    "                        values='author_id',\n",
    "                        aggfunc='sum').reset_index()\n",
    "    t6['author_id'] = getMaxMinNormalization(t6['author_id'])\n",
    "    t6.rename(columns={'author_id': 'user_%d_before_watch_video_author_type_count'\n",
    "                                    % (f_end - f_start + 1)}, inplace=True)\n",
    "    user_register = pd.merge(user_register, t6, on=['user_id'], how='left')\n",
    "    user_register.fillna(0, inplace=True)\n",
    "\n",
    "    t7 = user_activity[(user_activity.day >= f_start) &\n",
    "                       (user_activity.day <= f_end)][['user_id', 'day']]\n",
    "    t7['user_%d_before_activity_count' % (f_end - f_start + 1)] = 1\n",
    "    feat = pd.pivot_table(t7, index=['user_id'],\n",
    "                          values='user_%d_before_activity_count' % (f_end - f_start + 1),\n",
    "                          aggfunc='sum').reset_index()\n",
    "\n",
    "    t7_1 = pd.merge(feat, user_register[['user_id', 'register_type', 'device_type']], on=['user_id'], how='left')\n",
    "    t7_1 = t7_1[['register_type', 'device_type', 'user_%d_before_activity_count' % (f_end - f_start + 1)]]\n",
    "    feat1 = pd.pivot_table(t7_1, index=['register_type', 'device_type'],\n",
    "                           values='user_%d_before_activity_count' % (f_end - f_start + 1),\n",
    "                           aggfunc='sum').reset_index()\n",
    "    feat2 = pd.pivot_table(t7_1, index=['device_type'],\n",
    "                           values='user_%d_before_activity_count' % (f_end - f_start + 1),\n",
    "                           aggfunc='sum').reset_index()\n",
    "    feat3 = pd.pivot_table(t7_1, index=['register_type'],\n",
    "                           values='user_%d_before_activity_count' % (f_end - f_start + 1),\n",
    "                           aggfunc='sum').reset_index()\n",
    "    feat1.rename(columns={'user_%d_before_activity_count' % (f_end - f_start + 1):\n",
    "                              'device_register_type_%d_before_activity_count' % (f_end - f_start + 1)}, inplace=True)\n",
    "    feat1['device_register_type_%d_before_activity_count' % (f_end - f_start + 1)] = \\\n",
    "        feat1['device_register_type_%d_before_activity_count' % (f_end - f_start + 1)] / (f_end - f_start + 1)\n",
    "    feat2.rename(columns={'user_%d_before_activity_count' % (f_end - f_start + 1):\n",
    "                              'device_type_%d_before_activity_count' % (f_end - f_start + 1)}, inplace=True)\n",
    "    feat2['device_type_%d_before_activity_count' % (f_end - f_start + 1)] = \\\n",
    "        feat2['device_type_%d_before_activity_count' % (f_end - f_start + 1)] / (f_end - f_start + 1)\n",
    "    feat3.rename(columns={'user_%d_before_activity_count' % (f_end - f_start + 1):\n",
    "                              'register_type_%d_before_activity_count' % (f_end - f_start + 1)}, inplace=True)\n",
    "    feat3['register_type_%d_before_activity_count' % (f_end - f_start + 1)] = \\\n",
    "        feat3['register_type_%d_before_activity_count' % (f_end - f_start + 1)] / (f_end - f_start + 1)\n",
    "\n",
    "    feat1['device_register_type_%d_before_activity_count'\n",
    "          % (f_end - f_start + 1)] = \\\n",
    "        getMaxMinNormalization(feat1['device_register_type_%d_before_activity_count'\n",
    "                                     % (f_end - f_start + 1)])\n",
    "    feat2['device_type_%d_before_activity_count'\n",
    "          % (f_end - f_start + 1)] = \\\n",
    "        getMaxMinNormalization(feat2['device_type_%d_before_activity_count'\n",
    "                                     % (f_end - f_start + 1)])\n",
    "    feat3['register_type_%d_before_activity_count'\n",
    "          % (f_end - f_start + 1)] = \\\n",
    "        getMaxMinNormalization(feat3['register_type_%d_before_activity_count'\n",
    "                                     % (f_end - f_start + 1)])\n",
    "\n",
    "    user_register = pd.merge(user_register, feat1, on=['register_type', 'device_type'], how='left')\n",
    "    user_register = pd.merge(user_register, feat2, on=['device_type'], how='left')\n",
    "    user_register = pd.merge(user_register, feat3, on=['register_type'], how='left')\n",
    "    user_register.fillna(0, inplace=True)\n",
    "\n",
    "    t8_1 = user_launch[(user_launch.day >= f_start) &\n",
    "                       (user_launch.day <= f_end)][['user_id', 'day']]\n",
    "    t8_1 = t8_1.groupby(['user_id']).agg('max').reset_index()\n",
    "    t8_1.rename(columns={'day': 'max_day'}, inplace=True)\n",
    "\n",
    "    t8_2 = user_launch[(user_launch.day >= f_start) &\n",
    "                       (user_launch.day <= f_end)][['user_id', 'day']]\n",
    "    t8_2.drop_duplicates(inplace=True)\n",
    "    t8_2['day'] = 1\n",
    "    t8_2 = t8_2.groupby(['user_id']).agg('sum').reset_index()\n",
    "    t8_2.rename(columns={'day': 'user_%d_before_launch_day_distance'\n",
    "                                % (f_end - f_start + 1)}, inplace=True)\n",
    "\n",
    "    t8 = pd.merge(t8_1, t8_2, on=['user_id'], how='left')\n",
    "    t8['user_%d_before_launch_day_distance' % (f_end - f_start + 1)] = \\\n",
    "        (t8['user_%d_before_launch_day_distance' % (f_end - f_start + 1)] /\n",
    "         (f_end - f_start + 1)) * (t8['max_day'] - f_start + 1)\n",
    "    t8 = t8[['user_id', 'user_%d_before_launch_day_distance' % (f_end - f_start + 1)]]\n",
    "    user_register = pd.merge(user_register, t8, on=['user_id'], how='left')\n",
    "    user_register.fillna(0, inplace=True)\n",
    "\n",
    "    t9_1 = video_create[(video_create.day >= f_start) &\n",
    "                        (video_create.day <= f_end)][['user_id', 'day']]\n",
    "    t9_1 = t9_1.groupby(['user_id']).agg('max').reset_index()\n",
    "    t9_1.rename(columns={'day': 'max_day'}, inplace=True)\n",
    "\n",
    "    t9_2 = video_create[(video_create.day >= f_start) &\n",
    "                        (video_create.day <= f_end)][['user_id', 'day']]\n",
    "    t9_2.drop_duplicates(inplace=True)\n",
    "    t9_2['day'] = 1\n",
    "    t9_2 = t9_2.groupby(['user_id']).agg('sum').reset_index()\n",
    "    t9_2.rename(columns={'day': 'user_%d_before_video_create_day_distance'\n",
    "                                % (f_end - f_start + 1)}, inplace=True)\n",
    "\n",
    "    t9 = pd.merge(t9_1, t9_2, on=['user_id'], how='left')\n",
    "    t9['user_%d_before_video_create_day_distance' % (f_end - f_start + 1)] = \\\n",
    "        (t9['user_%d_before_video_create_day_distance' % (f_end - f_start + 1)] /\n",
    "         (f_end - f_start + 1)) * (t9['max_day'] - f_start + 1)\n",
    "    t9 = t9[['user_id', 'user_%d_before_video_create_day_distance' % (f_end - f_start + 1)]]\n",
    "    user_register = pd.merge(user_register, t9, on=['user_id'], how='left')\n",
    "    user_register.fillna(0, inplace=True)\n",
    "\n",
    "    t10_1 = user_activity[(user_activity.day >= f_start) &\n",
    "                          (user_activity.day <= f_end)][['user_id', 'day']]\n",
    "    t10_1 = t10_1.groupby(['user_id']).agg('max').reset_index()\n",
    "    t10_1.rename(columns={'day': 'max_day'}, inplace=True)\n",
    "\n",
    "    t10_2 = user_activity[(user_activity.day >= f_start) &\n",
    "                          (user_activity.day <= f_end)][['user_id', 'day']]\n",
    "    t10_2.drop_duplicates(inplace=True)\n",
    "    t10_2['day'] = 1\n",
    "    t10_2 = t10_2.groupby(['user_id']).agg('sum').reset_index()\n",
    "    t10_2.rename(columns={'day': 'user_%d_before_activity_day_distance'\n",
    "                                 % (f_end - f_start + 1)}, inplace=True)\n",
    "\n",
    "    t10 = pd.merge(t10_1, t10_2, on=['user_id'], how='left')\n",
    "    t10['user_%d_before_activity_day_distance' % (f_end - f_start + 1)] = \\\n",
    "        (t10['user_%d_before_activity_day_distance' % (f_end - f_start + 1)] /\n",
    "         (f_end - f_start + 1)) * (t10['max_day'] - f_start + 1)\n",
    "    t10 = t10[['user_id', 'user_%d_before_activity_day_distance' % (f_end - f_start + 1)]]\n",
    "    user_register = pd.merge(user_register, t10, on=['user_id'], how='left')\n",
    "    user_register.fillna(0, inplace=True)\n",
    "\n",
    "    for i in range(4):\n",
    "        t13 = user_activity[(user_activity.day >= f_start) & (user_activity.day <= f_end)\n",
    "                            & (user_activity.action_type == i)][['author_id', 'day']]\n",
    "        t13['author_%d_before_action_type_%d_showed_count' % (f_end - f_start + 1, i)] = \\\n",
    "            (t13['day'] - f_start) / (f_end - f_start)\n",
    "        t13 = pd.pivot_table(t13, index=['author_id'],\n",
    "                             values='author_%d_before_action_type_%d_showed_count'\n",
    "                                    % (f_end - f_start + 1, i),\n",
    "                             aggfunc='sum').reset_index()\n",
    "        t13['author_%d_before_action_type_%d_showed_count'\n",
    "            % (f_end - f_start + 1, i)] = getMaxMinNormalization(t13['author_%d_before_action_type_%d_showed_count'\n",
    "            % (f_end - f_start + 1, i)])\n",
    "        t13.rename(columns={'author_id': 'user_id'}, inplace=True)\n",
    "        user_register = pd.merge(user_register, t13, on=['user_id'], how='left')\n",
    "        user_register.fillna(0, inplace=True)\n",
    "\n",
    "    t15 = user_launch[(user_launch.day <= f_end) &\n",
    "                     (user_launch.day >= f_start)][['user_id', 'day']]\n",
    "    t15 = t15.groupby(['user_id']).agg('max').reset_index()\n",
    "    t15.columns = ['user_id', 'max_day']\n",
    "    user_register = pd.merge(user_register, t15, on=['user_id'], how='left')\n",
    "    user_register['user_launch_max_day_distance'] = f_end - user_register['max_day'] + 1\n",
    "    user_register.fillna(999, inplace=True)\n",
    "    user_register.drop(['max_day'], axis=1, inplace=True)\n",
    "\n",
    "    t16 = video_create[(video_create.day <= f_end) &\n",
    "                      (video_create.day >= f_start)][['user_id', 'day']]\n",
    "    t16 = t16.groupby(['user_id']).agg('max').reset_index()\n",
    "    t16.columns = ['user_id', 'max_day']\n",
    "    user_register = pd.merge(user_register, t16, on=['user_id'], how='left')\n",
    "    user_register['user_video_create_max_day_distance'] = f_end - user_register['max_day'] + 1\n",
    "    user_register.fillna(999, inplace=True)\n",
    "    user_register.drop(['max_day'], axis=1, inplace=True)\n",
    "\n",
    "    for i in range(4):\n",
    "        t17 = user_activity[(user_activity.day <= f_end) &\n",
    "                           (user_activity.day >= f_start) &\n",
    "                           (user_activity.action_type == i)][['user_id', 'day']]\n",
    "        t17 = t17.groupby(['user_id']).agg('max').reset_index()\n",
    "        t17.columns = ['user_id', 'max_day']\n",
    "        user_register = pd.merge(user_register, t17, on=['user_id'], how='left')\n",
    "        user_register['user_activity_action_type_%d_max_day_distance' % (i)] \\\n",
    "            = f_end - user_register['max_day'] + 1\n",
    "        user_register.fillna(999, inplace=True)\n",
    "        user_register.drop(['max_day'], axis=1, inplace=True)\n",
    "\n",
    "    t18 = user_launch[(user_launch.day >= f_start) &\n",
    "                     (user_launch.day <= f_end)][['user_id', 'day']]\n",
    "    t18['day'] = t18['day'].astype('str')\n",
    "    t18 = t18.groupby(['user_id']).agg(lambda x: ':'.join(x)).reset_index()\n",
    "    t18['user_launch_number'] = t18['day'].apply(lambda x: len(x.split(':')))\n",
    "    t18 = t18[t18.user_launch_number >= 1]\n",
    "    t18 = t18[['user_id', 'day']]\n",
    "\n",
    "    def culContinuousMeanLaunchDay(s):\n",
    "        launch_day = [int(x) for x in list(set(s.split(':')))]\n",
    "        launch_day.sort()\n",
    "\n",
    "        continuous_day_count = []\n",
    "        if (len(launch_day) == 1):\n",
    "            continuous_day_count.append(int(launch_day[0]) - f_start + 1)\n",
    "        else:\n",
    "            count = 0\n",
    "            for i in range(len(launch_day) - 1):\n",
    "                if ((int(launch_day[i + 1]) - int(launch_day[i]) == 1)):\n",
    "                    if (i == len(launch_day) - 2):\n",
    "                        count += (int(launch_day[i]) - f_start + 1)\n",
    "                        continuous_day_count.append(\n",
    "                            count + (int(launch_day[i + 1]) - f_start + 1))\n",
    "                    else:\n",
    "                        count += (int(launch_day[i]) - f_start + 1)\n",
    "                else:\n",
    "                    if (i == len(launch_day) - 2):\n",
    "                        continuous_day_count.append(\n",
    "                            count + (int(launch_day[i]) - f_start + 1))\n",
    "                        count = 0\n",
    "                        continuous_day_count.append(\n",
    "                            count + (int(launch_day[i + 1]) - f_start + 1))\n",
    "                    else:\n",
    "                        continuous_day_count.append(\n",
    "                            count + (int(launch_day[i]) - f_start + 1))\n",
    "                        count = 0\n",
    "\n",
    "        continuous_day_count = np.array(continuous_day_count)\n",
    "\n",
    "        return np.mean(continuous_day_count)\n",
    "\n",
    "    t18['user_%d_before_continuous_mean_launch_day' % (f_end - f_start + 1)] \\\n",
    "        = t18.day.apply(culContinuousMeanLaunchDay)\n",
    "    t18 = t18[['user_id', 'user_%d_before_continuous_mean_launch_day' % (f_end - f_start + 1)]]\n",
    "    user_register = pd.merge(user_register, t18, on=['user_id'], how='left')\n",
    "    user_register.fillna(0, inplace=True)\n",
    "\n",
    "    t19 = video_create[(video_create.day >= f_start) &\n",
    "                      (video_create.day <= f_end)][['user_id', 'day']]\n",
    "    t19['day'] = t19['day'].astype('str')\n",
    "    t19 = t19.groupby(['user_id']).agg(lambda x: ':'.join(x)).reset_index()\n",
    "    t19['user_create_video_number'] = t19['day'].apply(lambda x: len(x.split(':')))\n",
    "    t19 = t19[t19.user_create_video_number >= 1]\n",
    "    t19 = t19[['user_id', 'day']]\n",
    "\n",
    "    def culContinuousMeanVideoCreateDay(s):\n",
    "        video_create_day = [int(x) for x in list(set(s.split(':')))]\n",
    "        video_create_day.sort()\n",
    "\n",
    "        continuous_day_count = []\n",
    "        if(len(video_create_day) == 1):\n",
    "            continuous_day_count.append(int(video_create_day[0] - f_start + 1))\n",
    "        else:\n",
    "            count = 0\n",
    "            for i in range(len(video_create_day) - 1):\n",
    "                if ((int(video_create_day[i + 1]) - int(video_create_day[i]) == 1)):\n",
    "                    if (i == len(video_create_day) - 2):\n",
    "                        count += (int(video_create_day[i]) - f_start + 1)\n",
    "                        continuous_day_count.append(\n",
    "                            count + (int(video_create_day[i + 1]) - f_start + 1))\n",
    "                    else:\n",
    "                        count += (int(video_create_day[i]) - f_start + 1)\n",
    "                else:\n",
    "                    if (i == len(video_create_day) - 2):\n",
    "                        continuous_day_count.append(\n",
    "                            count + (int(video_create_day[i]) - f_start + 1))\n",
    "                        count = 0\n",
    "                        continuous_day_count.append(\n",
    "                            count + (int(video_create_day[i + 1]) - f_start + 1))\n",
    "                    else:\n",
    "                        continuous_day_count.append(\n",
    "                            count + (int(video_create_day[i]) - f_start + 1))\n",
    "                        count = 0\n",
    "\n",
    "        continuous_day_count = np.array(continuous_day_count)\n",
    "\n",
    "        return np.mean(continuous_day_count)\n",
    "\n",
    "    t19['user_%d_before_continuous_mean_create_video_day' % (f_end - f_start + 1)] \\\n",
    "        = t19.day.apply(culContinuousMeanVideoCreateDay)\n",
    "    t19 = t19[['user_id', 'user_%d_before_continuous_mean_create_video_day' % (f_end - f_start + 1)]]\n",
    "    user_register = pd.merge(user_register, t19, on=['user_id'], how='left')\n",
    "    user_register.fillna(0, inplace=True)\n",
    "\n",
    "    t20 = user_activity[(user_activity.day >= f_start) &\n",
    "                       (user_activity.day <= f_end)][['user_id', 'day']]\n",
    "    t20['day'] = t20['day'].astype('str')\n",
    "    t20 = t20.groupby(['user_id']).agg(lambda x: ':'.join(x)).reset_index()\n",
    "    t20['user_activity_number'] = t20['day'].apply(lambda x: len(x.split(':')))\n",
    "    t20 = t20[t20.user_activity_number >= 1]\n",
    "    t20 = t20[['user_id', 'day']]\n",
    "\n",
    "    def culContinuousMeanUserActivityDay(s):\n",
    "        user_activity_day = [int(x) for x in list(set(s.split(':')))]\n",
    "        user_activity_day.sort()\n",
    "\n",
    "        continuous_day_count = []\n",
    "        if(len(user_activity_day) == 1):\n",
    "            continuous_day_count.append(int(user_activity_day[0]) - f_start + 1)\n",
    "        else:\n",
    "            count = 0\n",
    "            for i in range(len(user_activity_day) - 1):\n",
    "                if ((int(user_activity_day[i + 1]) - int(user_activity_day[i]) == 1)):\n",
    "                    if (i == len(user_activity_day) - 2):\n",
    "                        count += (int(user_activity_day[i]) - f_start + 1)\n",
    "                        continuous_day_count.append(\n",
    "                            count + (int(user_activity_day[i + 1]) - f_start + 1))\n",
    "                    else:\n",
    "                        count += (int(user_activity_day[i]) - f_start + 1)\n",
    "                else:\n",
    "                    if (i == len(user_activity_day) - 2):\n",
    "                        continuous_day_count.append(\n",
    "                            count + (int(user_activity_day[i]) - f_start + 1))\n",
    "                        count = 0\n",
    "                        continuous_day_count.append(\n",
    "                            count + (int(user_activity_day[i + 1]) - f_start + 1))\n",
    "                    else:\n",
    "                        continuous_day_count.append(\n",
    "                            count + (int(user_activity_day[i]) - f_start + 1))\n",
    "                        count = 0\n",
    "\n",
    "        continuous_day_count = np.array(continuous_day_count)\n",
    "\n",
    "        return np.mean(continuous_day_count)\n",
    "\n",
    "    t20['user_%d_before_continuous_mean_user_activity_day' % (f_end - f_start + 1)] \\\n",
    "        = t20.day.apply(culContinuousMeanUserActivityDay)\n",
    "    t20 = t20[['user_id', 'user_%d_before_continuous_mean_user_activity_day' % (f_end - f_start + 1)]]\n",
    "    user_register = pd.merge(user_register, t20, on=['user_id'], how='left')\n",
    "    user_register.fillna(0, inplace=True)\n",
    "\n",
    "    t24_1 = user_launch[(user_launch.day >= f_start) &\n",
    "                        (user_launch.day <= f_end)][['user_id', 'day']]\n",
    "    t24_1.drop_duplicates(inplace=True)\n",
    "    t24_1['day'] = t24_1['day'].astype('str')\n",
    "    t24_1 = t24_1.groupby(['user_id'])['day'].agg(lambda x: ':'.join(x)).reset_index()\n",
    "    t24_1['user_launch_number'] = t24_1['day'].apply(lambda x: len(x.split(':')))\n",
    "    t24_1 = t24_1[t24_1.user_launch_number >= 1]\n",
    "    t24_1 = t24_1[['user_id', 'day']]\n",
    "    t24_1.columns = ['user_id', 'launch_day']\n",
    "\n",
    "    t24_2 = video_create[(video_create.day >= f_start) &\n",
    "                         (video_create.day <= f_end)][['user_id', 'day']]\n",
    "    t24_2['day'] = t24_2['day'].astype('str')\n",
    "    t24_2 = t24_2.groupby(['user_id'])['day'].agg(lambda x: ':'.join(x)).reset_index()\n",
    "    t24_2['user_video_number'] = t24_2['day'].apply(lambda x: len(x.split(':')))\n",
    "    t24_2 = t24_2[t24_2.user_video_number >= 1]\n",
    "    t24_2 = t24_2[['user_id', 'day']]\n",
    "    t24_2.columns = ['user_id', 'video_day']\n",
    "\n",
    "    t24 = pd.merge(t24_1, t24_2, on=['user_id'], how='right')\n",
    "    t24['day'] = t24['launch_day'] + ',' + t24['video_day']\n",
    "    t24 = t24[t24.day.notnull()]\n",
    "    t24 = t24[['user_id', 'day']]\n",
    "\n",
    "    def videoCreateFrequencyAfterLaunch(s):\n",
    "        launch, video = s.split(',')\n",
    "        launch_day = [int(x) for x in list(set(launch.split(':')))]\n",
    "        video_day = [int(x) for x in video.split(':')]\n",
    "        launch_day.sort()\n",
    "        video_day.sort()\n",
    "        gap_list = []\n",
    "        for i in range(len(launch_day) - 1):\n",
    "            gap = 0\n",
    "            for j in range(len(video_day)):\n",
    "                if ((int(video_day[j]) >= int(launch_day[i])) &\n",
    "                        (int(video_day[j]) < int(launch_day[i + 1]))):\n",
    "                    gap += (int(video_day[j]) - f_start + 1)\n",
    "            gap_list.append(gap)\n",
    "        gap = 0\n",
    "        for j in range(len(video_day)):\n",
    "            if (int(video_day[j]) >= int(launch_day[len(launch_day) - 1])):\n",
    "                gap += (int(video_day[j]) - f_start + 1)\n",
    "        gap_list.append(gap)\n",
    "        gap_array = np.array(gap_list)\n",
    "\n",
    "        return np.mean(gap_array)\n",
    "\n",
    "    t24['user_%d_before_create_video_after_launch_frequency' % (f_end - f_start + 1)] = \\\n",
    "        t24.day.apply(videoCreateFrequencyAfterLaunch)\n",
    "    t24 = t24[['user_id', 'user_%d_before_create_video_after_launch_frequency' % (f_end - f_start + 1)]]\n",
    "    user_register = pd.merge(user_register, t24, on=['user_id'], how='left')\n",
    "    user_register.fillna(0, inplace=True)\n",
    "\n",
    "    t25_1 = user_launch[(user_launch.day >= f_start) &\n",
    "                        (user_launch.day <= f_end)][['user_id', 'day']]\n",
    "    t25_1.drop_duplicates(inplace=True)\n",
    "    t25_1['day'] = t25_1['day'].astype('str')\n",
    "    t25_1 = t25_1.groupby(['user_id'])['day'].agg(lambda x: ':'.join(x)).reset_index()\n",
    "    t25_1['user_launch_number'] = t25_1['day'].apply(lambda x: len(x.split(':')))\n",
    "    t25_1 = t25_1[t25_1.user_launch_number >= 1]\n",
    "    t25_1 = t25_1[['user_id', 'day']]\n",
    "    t25_1.columns = ['user_id', 'launch_day']\n",
    "\n",
    "    t25_2 = user_activity[(user_activity.day >= f_start) &\n",
    "                          (user_activity.day <= f_end)][['user_id', 'day']]\n",
    "    t25_2['day'] = t25_2['day'].astype('str')\n",
    "    t25_2 = t25_2.groupby(['user_id'])['day'].agg(lambda x: ':'.join(x)).reset_index()\n",
    "    t25_2['user_activity_number'] = t25_2['day'].apply(lambda x: len(x.split(':')))\n",
    "    t25_2 = t25_2[t25_2.user_activity_number >= 1]\n",
    "    t25_2 = t25_2[['user_id', 'day']]\n",
    "    t25_2.columns = ['user_id', 'activity_day']\n",
    "\n",
    "    t25 = pd.merge(t25_1, t25_2, on=['user_id'], how='right')\n",
    "    t25['day'] = t25['launch_day'] + ',' + t25['activity_day']\n",
    "    t25 = t25[t25.day.notnull()]\n",
    "    t25 = t25[['user_id', 'day']]\n",
    "\n",
    "    def activityFrequencyAfterLaunch(s):\n",
    "        launch, activity = s.split(',')\n",
    "        launch_day = [int(x) for x in list(set(launch.split(':')))]\n",
    "        activity_day = [int(x) for x in activity.split(':')]\n",
    "        launch_day.sort()\n",
    "        activity_day.sort()\n",
    "        gap_list = []\n",
    "        for i in range(len(launch_day) - 1):\n",
    "            gap = 0\n",
    "            for j in range(len(activity_day)):\n",
    "                if ((int(activity_day[j]) >= int(launch_day[i])) &\n",
    "                        (int(activity_day[j]) < int(launch_day[i + 1]))):\n",
    "                    gap += (int(activity_day[j]) - f_start + 1)\n",
    "            gap_list.append(gap)\n",
    "        gap = 0\n",
    "        for j in range(len(activity_day)):\n",
    "            if (int(activity_day[j]) >= int(launch_day[len(launch_day) - 1])):\n",
    "                gap += (int(activity_day[j]) - f_start + 1)\n",
    "        gap_list.append(gap)\n",
    "        gap_array = np.array(gap_list)\n",
    "\n",
    "        return np.mean(gap_array)\n",
    "\n",
    "    t25['user_%d_before_activity_after_launch_frequency' % (f_end - f_start + 1)] = \\\n",
    "        t25.day.apply(activityFrequencyAfterLaunch)\n",
    "    t25 = t25[['user_id', 'user_%d_before_activity_after_launch_frequency' % (f_end - f_start + 1)]]\n",
    "    user_register = pd.merge(user_register, t25, on=['user_id'], how='left')\n",
    "    user_register.fillna(0, inplace=True)\n",
    "\n",
    "    t26 = user_activity[(user_activity.day <= f_end) &\n",
    "                        (user_activity.day >= f_start)][['user_id', 'day']]\n",
    "    t26['user_day_count'] = 1\n",
    "    t26 = t26.groupby(['user_id', 'day']).agg('sum').reset_index()\n",
    "    t26['day'] = t26['day'].astype('str')\n",
    "    t26['user_day_count'] = t26['user_day_count'].astype('str')\n",
    "    t26['user_day_and_day_count'] = t26['day'] + ':' + t26['user_day_count']\n",
    "    t26 = t26[['user_id', 'user_day_and_day_count']]\n",
    "    t26 = t26.groupby(['user_id'])['user_day_and_day_count'].agg(lambda x: ','.join(x)).reset_index()\n",
    "    t26['user_day_number'] = t26.user_day_and_day_count.apply(lambda x: len(x.split(',')))\n",
    "    t26 = t26[t26.user_day_number > 1]\n",
    "    t26 = t26[['user_id', 'user_day_and_day_count']]\n",
    "\n",
    "    def calculateAcceleration(s):\n",
    "        day_and_day_count = [x for x in s.split(',')]\n",
    "        day_list = [int(x.split(':')[0]) for x in day_and_day_count]\n",
    "        day_list.sort()\n",
    "        dc_dict = {}\n",
    "        for dc in day_and_day_count:\n",
    "            dc_dict[int(dc.split(':')[0])] = int(dc.split(':')[1])\n",
    "        gap = []\n",
    "        for i in range(len(day_list) - 1):\n",
    "            gap.append((dc_dict[day_list[i + 1]] - dc_dict[day_list[i]]) /\n",
    "                       (day_list[i + 1] - day_list[i]))\n",
    "        gap = np.array(gap)\n",
    "        return np.mean(gap)\n",
    "\n",
    "    t26['user_whole_day_activity_acceleration'] = \\\n",
    "        t26.user_day_and_day_count.apply(calculateAcceleration)\n",
    "    t26 = t26[['user_id', 'user_whole_day_activity_acceleration']]\n",
    "    user_register = pd.merge(user_register, t26, on=['user_id'], how='left')\n",
    "    user_register.fillna(0, inplace=True)\n",
    "\n",
    "    t29 = user_launch[(user_launch.day >= f_start) &\n",
    "                      (user_launch.day <= f_end)][['user_id', 'day']]\n",
    "    t29['day'] = t29['day'].astype('str')\n",
    "    t29 = t29.groupby(['user_id'])['day'].agg(lambda x: '-'.join(x)).reset_index()\n",
    "    t29['user_day_number'] = t29.day.apply(lambda x: len(x.split('-')))\n",
    "    t29 = t29[t29.user_day_number > 1]\n",
    "    t29 = t29[['user_id', 'day']]\n",
    "\n",
    "    def culculateFrequncy(s):\n",
    "        day_list = [int(x) for x in s.split('-')]\n",
    "        day_list.sort()\n",
    "        day_array= np.array(day_list)\n",
    "        gap = np.diff(day_array)\n",
    "        return np.mean(gap)\n",
    "\n",
    "    t29['user_%d_before_launch_day_mean_frequncy' % (f_end - f_start + 1)] = t29.day.apply(culculateFrequncy)\n",
    "    t29 = t29[['user_id', 'user_%d_before_launch_day_mean_frequncy' % (f_end - f_start + 1)]]\n",
    "    user_register = pd.merge(user_register, t29, on=['user_id'], how='left')\n",
    "    user_register.fillna(0, inplace=True)\n",
    "\n",
    "    t30 = video_create[(video_create.day >= f_start) &\n",
    "                       (video_create.day <= f_end)][['user_id', 'day']]\n",
    "    t30['day'] = t30['day'].astype('str')\n",
    "    t30 = t30.groupby(['user_id'])['day'].agg(lambda x : '-'.join(x)).reset_index()\n",
    "    t30['user_day_number'] = t30.day.apply(lambda x: len(x.split('-')))\n",
    "    t30 = t30[t30.user_day_number > 1]\n",
    "    t30 = t30[['user_id', 'day']]\n",
    "\n",
    "    def culculateFrequncy(s):\n",
    "        day_list = [int(x) for x in s.split('-')]\n",
    "        day_list.sort()\n",
    "        day_array= np.array(day_list)\n",
    "        gap = np.diff(day_array)\n",
    "        return np.mean(gap)\n",
    "\n",
    "    t30['user_%d_before_video_create_day_mean_frequncy' % (f_end - f_start + 1)] = t30.day.apply(culculateFrequncy)\n",
    "    t30 = t30[['user_id', 'user_%d_before_video_create_day_mean_frequncy' % (f_end - f_start + 1)]]\n",
    "    user_register = pd.merge(user_register, t30, on=['user_id'], how='left')\n",
    "    user_register.fillna(0, inplace=True)\n",
    "\n",
    "    t31 = user_activity[(user_activity.day >= f_start) &\n",
    "                        (user_activity.day <= f_end)][['user_id', 'day']]\n",
    "    t31['day'] = t31['day'].astype('str')\n",
    "    t31 = t31.groupby(['user_id'])['day'].agg(lambda x: '-'.join(x)).reset_index()\n",
    "    t31['user_day_number'] = t31.day.apply(lambda x: len(x.split('-')))\n",
    "    t31 = t31[t31.user_day_number > 1]\n",
    "    t31 = t31[['user_id', 'day']]\n",
    "\n",
    "    def culculateFrequncy(s):\n",
    "        day_list = [int(x) for x in s.split('-')]\n",
    "        day_list.sort()\n",
    "        day_array= np.array(day_list)\n",
    "        gap = np.diff(day_array)\n",
    "        return np.mean(gap)\n",
    "\n",
    "    t31['user_%d_before_activity_day_mean_frequncy' % (f_end - f_start + 1)] = t31.day.apply(culculateFrequncy)\n",
    "    t31 = t31[['user_id', 'user_%d_before_activity_day_mean_frequncy' % (f_end - f_start + 1)]]\n",
    "    user_register = pd.merge(user_register, t31, on=['user_id'], how='left')\n",
    "    user_register.fillna(0, inplace=True)\n",
    "\n",
    "    t9_1 = video_create[(video_create.day >= f_start) &\n",
    "                        (video_create.day <= f_end)][['user_id', 'day']]\n",
    "    t9_1 = t9_1.groupby(['user_id']).agg('max').reset_index()\n",
    "    t9_1.rename(columns={'day': 'max_day'}, inplace=True)\n",
    "\n",
    "    t9_2 = video_create[(video_create.day >= f_start) &\n",
    "                        (video_create.day <= f_end)][['user_id', 'day']]\n",
    "    t9_2 = t9_2.groupby(['user_id']).agg('min').reset_index()\n",
    "    t9_2.rename(columns={'day': 'min_day'}, inplace=True)\n",
    "\n",
    "    t9 = pd.merge(t9_1, t9_2, on=['user_id'], how='left')\n",
    "    t9['user_%d_before_video_create_day_distance2' % (f_end - f_start + 1)] = t9['max_day'] - t9['min_day']\n",
    "    t9['user_%d_before_video_create_day_distance2' % (f_end - f_start + 1)] = \\\n",
    "        (t9['user_%d_before_video_create_day_distance2' % (f_end - f_start + 1)] /\n",
    "         (f_end - f_start + 1)) * (t9['max_day'] - f_start)\n",
    "    t9 = t9[['user_id', 'user_%d_before_video_create_day_distance2' % (f_end - f_start + 1)]]\n",
    "    user_register = pd.merge(user_register, t9, on=['user_id'], how='left')\n",
    "    user_register.fillna(0, inplace=True)\n",
    "\n",
    "    t10_1 = user_activity[(user_activity.day >= f_start) &\n",
    "                          (user_activity.day <= f_end)][['user_id', 'day']]\n",
    "    t10_1 = t10_1.groupby(['user_id']).agg('max').reset_index()\n",
    "    t10_1.rename(columns={'day': 'max_day'}, inplace=True)\n",
    "\n",
    "    t10_2 = user_activity[(user_activity.day >= f_start) &\n",
    "                          (user_activity.day <= f_end)][['user_id', 'day']]\n",
    "    t10_2 = t10_2.groupby(['user_id']).agg('min').reset_index()\n",
    "    t10_2.rename(columns={'day': 'min_day'}, inplace=True)\n",
    "\n",
    "    t10 = pd.merge(t10_1, t10_2, on=['user_id'], how='left')\n",
    "    t10['user_%d_before_activity_day_distance2' % (f_end - f_start + 1)] = t10['max_day'] - t10['min_day']\n",
    "    t10['user_%d_before_activity_day_distance2' % (f_end - f_start + 1)] = \\\n",
    "        (t10['user_%d_before_activity_day_distance2' % (f_end - f_start + 1)] /\n",
    "         (f_end - f_start + 1)) * (t10['max_day'] - f_start)\n",
    "    t10 = t10[['user_id', 'user_%d_before_activity_day_distance2' % (f_end - f_start + 1)]]\n",
    "    user_register = pd.merge(user_register, t10, on=['user_id'], how='left')\n",
    "    user_register.fillna(0, inplace=True)\n",
    "\n",
    "    t8_1 = user_launch[(user_launch.day >= f_start) &\n",
    "                       (user_launch.day <= f_end)][['user_id', 'day']]\n",
    "    t8_1 = t8_1.groupby(['user_id']).agg('max').reset_index()\n",
    "    t8_1.rename(columns={'day': 'max_day'}, inplace=True)\n",
    "\n",
    "    user_register = pd.merge(user_register, t8_1, on=['user_id'], how='left')\n",
    "    user_register['user_launch_max_day_register_day_distance'] = \\\n",
    "        (user_register['max_day'] - user_register['register_day'] + 1)\n",
    "    user_register.drop(['max_day'], axis=1, inplace=True)\n",
    "    user_register.fillna(0, inplace = True)\n",
    "\n",
    "    t9_1 = video_create[(video_create.day >= f_start) &\n",
    "                        (video_create.day <= f_end)][['user_id', 'day']]\n",
    "    t9_1 = t9_1.groupby(['user_id']).agg('max').reset_index()\n",
    "    t9_1.rename(columns={'day': 'max_day'}, inplace=True)\n",
    "    user_register = pd.merge(user_register, t9_1, on=['user_id'], how='left')\n",
    "    user_register['user_video_max_day_register_day_distance'] = \\\n",
    "        (user_register['max_day'] - user_register['register_day'] + 1)\n",
    "    user_register.drop(['max_day'], axis=1, inplace=True)\n",
    "    user_register.fillna(0, inplace = True)\n",
    "\n",
    "    t10_1 = user_activity[(user_activity.day >= f_start) &\n",
    "                          (user_activity.day <= f_end)][['user_id', 'day']]\n",
    "    t10_1 = t10_1.groupby(['user_id']).agg('max').reset_index()\n",
    "    t10_1.rename(columns={'day': 'max_day'}, inplace=True)\n",
    "\n",
    "    user_register = pd.merge(user_register, t10_1, on=['user_id'], how='left')\n",
    "    user_register['user_activity_max_day_register_day_distance'] = \\\n",
    "        (user_register['max_day'] - user_register['register_day'] + 1)\n",
    "    user_register.drop(['max_day'], axis=1, inplace=True)\n",
    "    user_register.fillna(0, inplace = True)\n",
    "\n",
    "    t32 = user_launch[(user_launch.day >= f_start) &\n",
    "                      (user_launch.day <= f_end)][['user_id', 'day']]\n",
    "    t32 = pd.merge(t32, user_register[['user_id', 'register_day']], on = ['user_id'], how = 'left')\n",
    "    t32['user_launch_count_concerned_register_day'] = t32['day'] - t32['register_day'] + 1\n",
    "    t32 = pd.pivot_table(t32, values = 'user_launch_count_concerned_register_day',\n",
    "                         index = 'user_id', aggfunc = 'sum').reset_index()\n",
    "    user_register = pd.merge(user_register, t32, on = ['user_id'], how = 'left')\n",
    "    user_register.fillna(0, inplace = True)\n",
    "\n",
    "    t33 = video_create[(video_create.day >= f_start) &\n",
    "                      (video_create.day <= f_end)][['user_id', 'day']]\n",
    "    t33 = pd.merge(t33, user_register[['user_id', 'register_day']], on = ['user_id'], how = 'left')\n",
    "    t33['user_video_create_count_concerned_register_day'] = t33['day'] - t33['register_day'] + 1\n",
    "    t33 = pd.pivot_table(t33, values = 'user_video_create_count_concerned_register_day',\n",
    "                         index = 'user_id', aggfunc = 'sum').reset_index()\n",
    "    user_register = pd.merge(user_register, t33, on = ['user_id'], how = 'left')\n",
    "    user_register.fillna(0, inplace = True)\n",
    "\n",
    "    for i in range(4):\n",
    "        t33 = user_activity[(user_activity.day >= f_start) &\n",
    "                      (user_activity.day <= f_end) &\n",
    "                      (user_activity.action_type == i)][['user_id', 'day']]\n",
    "        t33 = pd.merge(t33, user_register[['user_id', 'register_day']], on = ['user_id'], how = 'left')\n",
    "        t33['user_activity_action_type_%d_count_concerned_register_day'%(i)] = \\\n",
    "            t33['day'] - t33['register_day'] + 1\n",
    "        t33 = pd.pivot_table(t33, values = 'user_activity_action_type_%d_count_concerned_register_day'%(i),\n",
    "                             index = 'user_id', aggfunc = 'sum').reset_index()\n",
    "        user_register = pd.merge(user_register, t33, on = ['user_id'], how = 'left')\n",
    "        user_register.fillna(0, inplace = True)\n",
    "\n",
    "    t35 = user_activity[(user_activity.day >= f_start) &\n",
    "                        (user_activity.day <= f_end)][['user_id', 'author_id', 'day']]\n",
    "    t35 = pd.pivot_table(t35, values = 'day',\n",
    "                         index = ['user_id', 'author_id'],\n",
    "                         aggfunc = np.max).reset_index()\n",
    "    t35 = pd.merge(t35, user_register[['user_id', 'register_day']], on = ['user_id'], how = 'left')\n",
    "    t35['author_id'] = t35['day'] - t35['register_day'] + 1\n",
    "    t35 = pd.pivot_table(t35, values = 'author_id',\n",
    "                         index = ['user_id'],\n",
    "                         aggfunc = 'sum').reset_index()\\\n",
    "        .rename(columns = {'author_id' : 'user_author_type_count_concerned_register_day'})\n",
    "    user_register = pd.merge(user_register, t35, on=['user_id'], how='left')\n",
    "    user_register.fillna(0, inplace=True)\n",
    "\n",
    "    t36 = user_activity[(user_activity.day >= f_start) &\n",
    "                        (user_activity.day <= f_end)][['user_id', 'author_id', 'day']]\n",
    "    t36 = pd.pivot_table(t36, values = 'day',\n",
    "                         index = ['user_id', 'author_id'],\n",
    "                         aggfunc = np.mean).reset_index()\n",
    "    t36 = pd.merge(t36, user_register[['user_id', 'register_day']], on=['user_id'], how='left')\n",
    "    t36['user_id'] = t36['day'] - t36['register_day'] + 1\n",
    "    t36 = pd.pivot_table(t36, values='user_id',\n",
    "                         index=['author_id'],\n",
    "                         aggfunc='sum').reset_index() \\\n",
    "        .rename(columns={'user_id': 'author_user_type_mean_count_concerned_register_day'})\n",
    "    t36.rename(columns = {'author_id' : 'user_id'}, inplace = True)\n",
    "    user_register = pd.merge(user_register, t36, on=['user_id'], how='left')\n",
    "    user_register.fillna(0, inplace = True)\n",
    "\n",
    "    t8_1 = user_launch[(user_launch.day >= f_start) &\n",
    "                       (user_launch.day <= f_end)][['user_id', 'day']]\n",
    "    t8_1 = t8_1.groupby(['user_id']).agg('mean').reset_index()\n",
    "    t8_1.rename(columns={'day': 'mean_day'}, inplace=True)\n",
    "\n",
    "    user_register = pd.merge(user_register, t8_1, on=['user_id'], how='left')\n",
    "    user_register['user_launch_mean_day_register_day_distance'] = \\\n",
    "        (user_register['mean_day'] - user_register['register_day'] + 1) / \\\n",
    "        (f_end - user_register['register_day'] + 1)\n",
    "    user_register.drop(['mean_day'], axis=1, inplace=True)\n",
    "    user_register.fillna(0, inplace=True)\n",
    "\n",
    "    t9_1 = video_create[(video_create.day >= f_start) &\n",
    "                        (video_create.day <= f_end)][['user_id', 'day']]\n",
    "    t9_1 = t9_1.groupby(['user_id']).agg('mean').reset_index()\n",
    "    t9_1.rename(columns={'day': 'mean_day'}, inplace=True)\n",
    "    user_register = pd.merge(user_register, t9_1, on=['user_id'], how='left')\n",
    "    user_register['user_video_mean_day_register_day_distance'] = \\\n",
    "        (user_register['mean_day'] - user_register['register_day'] + 1) / \\\n",
    "        (f_end - user_register['register_day'] + 1)\n",
    "    user_register.drop(['mean_day'], axis=1, inplace=True)\n",
    "    user_register.fillna(0, inplace=True)\n",
    "\n",
    "    t10_1 = user_activity[(user_activity.day >= f_start) &\n",
    "                          (user_activity.day <= f_end)][['user_id', 'day']]\n",
    "    t10_1 = t10_1.groupby(['user_id']).agg('mean').reset_index()\n",
    "    t10_1.rename(columns={'day': 'mean_day'}, inplace=True)\n",
    "\n",
    "    user_register = pd.merge(user_register, t10_1, on=['user_id'], how='left')\n",
    "    user_register['user_activity_mean_day_register_day_distance'] = \\\n",
    "        (user_register['mean_day'] - user_register['register_day'] + 1) / \\\n",
    "        (f_end - user_register['register_day'] + 1)\n",
    "    user_register.drop(['mean_day'], axis=1, inplace=True)\n",
    "    user_register.fillna(0, inplace=True)\n",
    "\n",
    "    t8_1 = user_launch[(user_launch.day >= f_start) &\n",
    "                       (user_launch.day <= f_end)][['user_id', 'day']]\n",
    "    t8_1 = t8_1.groupby(['user_id']).agg('median').reset_index()\n",
    "    t8_1.rename(columns={'day': 'median_day'}, inplace=True)\n",
    "\n",
    "    user_register = pd.merge(user_register, t8_1, on=['user_id'], how='left')\n",
    "    user_register['user_launch_median_day_register_day_distance'] = \\\n",
    "        (user_register['median_day'] - user_register['register_day'] + 1)\n",
    "    user_register.drop(['median_day'], axis=1, inplace=True)\n",
    "    user_register.fillna(0, inplace=True)\n",
    "\n",
    "    t9_1 = video_create[(video_create.day >= f_start) &\n",
    "                        (video_create.day <= f_end)][['user_id', 'day']]\n",
    "    t9_1 = t9_1.groupby(['user_id']).agg('median').reset_index()\n",
    "    t9_1.rename(columns={'day': 'median_day'}, inplace=True)\n",
    "    user_register = pd.merge(user_register, t9_1, on=['user_id'], how='left')\n",
    "    user_register['user_video_median_day_register_day_distance'] = \\\n",
    "        (user_register['median_day'] - user_register['register_day'] + 1)\n",
    "    user_register.drop(['median_day'], axis=1, inplace=True)\n",
    "    user_register.fillna(0, inplace=True)\n",
    "\n",
    "    t10_1 = user_activity[(user_activity.day >= f_start) &\n",
    "                          (user_activity.day <= f_end)][['user_id', 'day']]\n",
    "    t10_1 = t10_1.groupby(['user_id']).agg('median').reset_index()\n",
    "    t10_1.rename(columns={'day': 'median_day'}, inplace=True)\n",
    "\n",
    "    user_register = pd.merge(user_register, t10_1, on=['user_id'], how='left')\n",
    "    user_register['user_activity_median_day_register_day_distance'] = \\\n",
    "        (user_register['median_day'] - user_register['register_day'] + 1)\n",
    "    user_register.drop(['median_day'], axis=1, inplace=True)\n",
    "    user_register.fillna(0, inplace=True)\n",
    "\n",
    "    for i in range(6):\n",
    "        t40_1 = user_activity[(user_activity.day >= f_start) &\n",
    "                              (user_activity.day <= f_end) &\n",
    "                              (user_activity.action_type == i)][['user_id']]\n",
    "        t40_1['count1'] = 1\n",
    "        t40_1 = pd.pivot_table(t40_1, index=['user_id'],\n",
    "                               values=['count1'], aggfunc = 'sum').reset_index()\n",
    "\n",
    "        t40_2 = user_activity[(user_activity.day >= f_start)\n",
    "                              & (user_activity.day <= f_end)][['user_id']]\n",
    "        t40_2['count2'] = 1\n",
    "        t40_2 = pd.pivot_table(t40_2, index = ['user_id'],\n",
    "                               values = ['count2'], aggfunc = 'sum').reset_index()\n",
    "        t40 = pd.merge(t40_2, t40_1, on = ['user_id'], how = 'left')\n",
    "        t40.fillna(0, inplace = True)\n",
    "\n",
    "        t40['user_%d_before_activity_action_type_%d_rate'\n",
    "            %(f_end - f_start + 1, i)] = t40['count1'] / t40['count2']\n",
    "        t40 = t40[['user_id', 'user_%d_before_activity_action_type_%d_rate'\n",
    "            %(f_end - f_start + 1, i)]]\n",
    "        user_register = pd.merge(user_register, t40, on=['user_id'], how='left')\n",
    "        user_register.fillna(0, inplace=True)\n",
    "\n",
    "    for i in range(5):\n",
    "        t40_1 = user_activity[(user_activity.day >= f_start) &\n",
    "                              (user_activity.day <= f_end) &\n",
    "                              (user_activity.page == i)][['user_id']]\n",
    "        t40_1['count1'] = 1\n",
    "        t40_1 = pd.pivot_table(t40_1, index=['user_id'],\n",
    "                               values=['count1'], aggfunc='sum').reset_index()\n",
    "\n",
    "        t40_2 = user_activity[(user_activity.day >= f_start)\n",
    "                              & (user_activity.day <= f_end)][['user_id']]\n",
    "        t40_2['count2'] = 1\n",
    "        t40_2 = pd.pivot_table(t40_2, index=['user_id'],\n",
    "                               values=['count2'], aggfunc='sum').reset_index()\n",
    "\n",
    "        t40 = pd.merge(t40_2, t40_1, on=['user_id'], how='left')\n",
    "        t40.fillna(0, inplace=True)\n",
    "\n",
    "        t40['user_%d_before_activity_page_%d_rate'\n",
    "            % (f_end - f_start + 1, i)] = t40['count1'] / t40['count2']\n",
    "        t40 = t40[['user_id', 'user_%d_before_activity_page_%d_rate'\n",
    "                   % (f_end - f_start + 1, i)]]\n",
    "        user_register = pd.merge(user_register, t40, on=['user_id'], how='left')\n",
    "        user_register.fillna(0, inplace=True)\n",
    "\n",
    "    print('get all time feature have finished!')\n",
    "\n",
    "    return user_register\n",
    "\n",
    "def getSlideJoin(user_launch, register_have_label, video_create, user_activity, end):\n",
    "    register_have_feature = getLastDayFeature(user_launch, register_have_label,\n",
    "                                            video_create, user_activity, end, end)\n",
    "\n",
    "    register_have_feature = getAllTimeFeature(user_launch, register_have_feature,\n",
    "                                              video_create, user_activity, end - 15, end)\n",
    "\n",
    "    return register_have_feature\n",
    "\n",
    "def getDummiesFeature(user_register):\n",
    "    register_type_df = pd.get_dummies(user_register['register_type'], prefix='register_type')\n",
    "    user_register = pd.concat([user_register, register_type_df], axis=1)\n",
    "\n",
    "    return user_register[user_register['flag'].notnull()].reset_index(drop=True), \\\n",
    "           user_register[user_register['flag'].isnull()].reset_index(drop=True)\n",
    "\n",
    "def getFeature(user_launch, user_register, video_create, user_activity,\n",
    "               register_have_label1, register_have_label2):\n",
    "    print('train1')\n",
    "    register_have_feature_train1 = getSlideJoin(user_launch, register_have_label1,\n",
    "                                                video_create, user_activity, 23)\n",
    "    print(register_have_feature_train1.shape)\n",
    "\n",
    "    print('train2')\n",
    "    register_have_feature_train2 = getSlideJoin(user_launch, register_have_label2,\n",
    "                                                video_create, user_activity, 16)\n",
    "    print(register_have_feature_train2.shape)\n",
    "\n",
    "    register_have_feature_train = pd.concat([register_have_feature_train1,\n",
    "                                             register_have_feature_train2]).reset_index(drop=True)\n",
    "\n",
    "    print('test')\n",
    "    register_have_feature_test = getSlideJoin(user_launch, user_register,\n",
    "                                              video_create, user_activity, 30)\n",
    "    print(register_have_feature_test.shape)\n",
    "\n",
    "    register_have_feature_train['flag'] = 1\n",
    "    register_have_feature_train, register_have_feature_test = \\\n",
    "        getDummiesFeature(pd.concat([register_have_feature_train,\n",
    "                                     register_have_feature_test]).reset_index(drop=True))\n",
    "    print(register_have_feature_train.shape)\n",
    "    print(register_have_feature_test.shape)\n",
    "    register_have_feature_train.drop(['user_id', 'register_day', 'flag'], axis=1, inplace=True)\n",
    "    register_have_feature_test.drop(['register_day', 'flag'], axis=1, inplace=True)\n",
    "    return register_have_feature_train, register_have_feature_test\n",
    "\n",
    "def runXGBoost(train, test):\n",
    "    print('run xgboost...')\n",
    "    train_feat = [x for x in train.columns if x != 'label']\n",
    "    test_feat = [x for x in test.columns if x != 'user_id']\n",
    "    feat = [x for x in train_feat if x in test_feat]\n",
    "    print('feat:', len(feat))\n",
    "    train_x = train[feat]\n",
    "    train_y = train[['label']]\n",
    "    test_x = test[feat]\n",
    "    test_pre = test[['user_id']]\n",
    "\n",
    "    train_xgb = xgb.DMatrix(train_x, label=train_y)\n",
    "    test_xgb = xgb.DMatrix(test_x)\n",
    "\n",
    "    params = {\n",
    "        'booster': 'gbtree',\n",
    "        'objective': 'rank:pairwise',\n",
    "        'eval_metric': 'auc',\n",
    "        'gamma': 0.1,\n",
    "        'min_child_weight': 1.5,\n",
    "        'max_depth': 5,\n",
    "        'lambda': 10,\n",
    "        'subsample': 0.7,\n",
    "        'colsample_bytree': 0.7,\n",
    "        'colsample_bylevel': 0.7,\n",
    "        'eta': 0.03,\n",
    "        'tree_method': 'exact',\n",
    "        'seed': 0,\n",
    "        'nthread': 12\n",
    "    }\n",
    "\n",
    "    # train on dataset2, evaluate on dataset1\n",
    "    watchlist = [(train_xgb, 'train'), (train_xgb, 'val')]\n",
    "    model = xgb.train(params, train_xgb, num_boost_round=700, evals=watchlist)\n",
    "    test_pre['predicted_pro'] = model.predict(test_xgb)\n",
    "    min_pro = np.min(test_pre.predicted_pro)\n",
    "    max_pro = np.max(test_pre.predicted_pro)\n",
    "    test_pre.predicted_pro = \\\n",
    "        (test_pre.predicted_pro - min_pro) / (max_pro - min_pro)\n",
    "    result = test_pre.sort_index(by=['predicted_pro'], ascending=False).reset_index(drop=True)\n",
    "    print('run xgboost have finished!')\n",
    "    return result\n",
    "\n",
    "def main():\n",
    "    # read pure txt\n",
    "    user_launch, user_register, video_create, user_activity = readData()\n",
    "\n",
    "    # labeling register log\n",
    "    print('get label...')\n",
    "    register_have_label1, register_have_label2 =\\\n",
    "        getLabel(user_launch, user_register, video_create, user_activity)\n",
    "    print('get label have finished!')\n",
    "\n",
    "    # get feature\n",
    "    print('get feature...')\n",
    "    train, test = \\\n",
    "        getFeature(user_launch, user_register, video_create, user_activity,\n",
    "                   register_have_label1, register_have_label2)\n",
    "    print('get feature have finished!')\n",
    "\n",
    "    # run xgboost\n",
    "    result_10_cv = test[['user_id']]\n",
    "    result_10_cv['predicted_pro'] = 0\n",
    "    for i in range(10):\n",
    "        train_sample = train.sample(frac=0.9)\n",
    "        result = runXGBoost(train_sample, test)\n",
    "        result.rename(columns={'predicted_pro': 'predicted_pro_%d' % (i)}, inplace=True)\n",
    "        result_10_cv = pd.merge(result_10_cv, result, on=['user_id'], how='left')\n",
    "        result_10_cv['predicted_pro'] = result_10_cv['predicted_pro'] +\\\n",
    "                                        0.1 * result_10_cv['predicted_pro_%d' % (i)]\n",
    "        result_10_cv = result_10_cv[['user_id', 'predicted_pro']]\n",
    "\n",
    "    result = runXGBoost(train, test)\n",
    "    result.rename(columns={'predicted_pro': 'predicted_pro_all'}, inplace=True)\n",
    "    result_10_cv = pd.merge(result_10_cv, result, on=['user_id'], how='left')\n",
    "    result_10_cv['predicted_pro'] = 0.5 * result_10_cv['predicted_pro'] + 0.5 * result_10_cv['predicted_pro_all']\n",
    "    result_10_cv = result_10_cv[['user_id', 'predicted_pro']]\n",
    "\n",
    "    result_10_cv.to_csv(\"mzj_model.csv\", encoding='utf-8', index=None, header=None)\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "BB692C648EA6491E9CC66DD1E70DB453"
   },
   "outputs": [],
   "source": [
    "# 模型融合"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "64FFD5D52D4D47198E388E229A64A076"
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "def getMaxMinNormalization(feature):\n",
    "    max = np.max(feature)\n",
    "    min = np.min(feature)\n",
    "\n",
    "    return (feature - min) / (max - min)\n",
    "\n",
    "r1 = pd.read_csv(r'yw_model.txt', header = None)\n",
    "r1.columns = ['user_id', 'label1']\n",
    "r2 = pd.read_csv(r'xjy_model.txt', header = None)\n",
    "r2.columns = ['user_id', 'label2']\n",
    "r2['label2'] = getMaxMinNormalization(r2['label2'])\n",
    "r3 = pd.read_csv(r'mzj_model.csv', header = None)\n",
    "r3.columns = ['user_id', 'label3']\n",
    "print(r1.shape)\n",
    "print(r2.shape)\n",
    "print(r3.shape)\n",
    "result = pd.merge(r1, r2, on = ['user_id'], how = 'left')\n",
    "result = pd.merge(result, r3, on = ['user_id'], how = 'left')\n",
    "result['label'] = 0.3 * result['label1'] + 0.4 * result['label2'] + 0.3 * result['label3']\n",
    "\n",
    "result = result[['user_id', 'label']]\n",
    "result = result.sort_index(by=['label'], ascending=False).reset_index(drop=True)\n",
    "print(result.shape)\n",
    "result.to_csv(\"fafenlousi_result.csv\", encoding='utf-8', index=None, header = None)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}