business_volume_forecast.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "from tqdm import tqdm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "train2=pd.read_csv('train_v2.csv')\n",
    "wkd=pd.read_csv('wkd_v1 (1).csv')\n",
    "test2=pd.read_csv('test_v2_day.csv')\n",
    "test2_periods=pd.read_csv('test_v2_periods.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "wkd.ORIG_DT=pd.to_datetime(wkd.ORIG_DT)\n",
    "wkd=wkd.rename(columns={'ORIG_DT':'date'})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "#构建新特征 shift\n",
    "'''\n",
    "1.前一天是否为周末 且 当前是工作日\n",
    "2.前一天为法定假日 且 当前是工作日\n",
    "3.前一天为工作日调休 且 当前是工作日\n",
    "4.前一天为假期调为工作日，且 当前是工作日\n",
    "5.前7天中法定假日的比例\n",
    "6.前14天中法定假日的比例\n",
    "7.前7天中工作日调休的比例\n",
    "8.前14天中工作日调休的比例\n",
    "9.前7天中假期调为工作日的比例\n",
    "10.前14天中假期调为工作日的比例\n",
    "'''\n",
    "#为了构建新特征，这里使用shift函数来实现第前n天的type\n",
    "#因为数据集前14行均有部分数据的缺失，因此在构建训练集时这部分[:14]数据需要舍弃\n",
    "for i in range(1,15):\n",
    "    wkd[f'last_{i}']=wkd['WKD_TYP_CD'].shift(i)\n",
    "\n",
    "wkd=wkd.iloc[14:,:].reset_index(drop=True)\n",
    "\n",
    "wkd['last_7days']=wkd['last_1']+' '+wkd['last_2']+' '+wkd['last_3']+' '+wkd['last_4']+' '+\\\n",
    "wkd['last_5']+' '+wkd['last_6']+' '+wkd['last_7']\n",
    "\n",
    "wkd['last_7days']=wkd['last_7days'].apply(lambda x:x.split(' '))\n",
    "\n",
    "wkd['last_14days']=wkd['last_1']+' '+wkd['last_2']+' '+wkd['last_3']+' '+wkd['last_4']+' '+\\\n",
    "wkd['last_5']+' '+wkd['last_6']+' '+wkd['last_7']+' '+wkd['last_8']+' '+wkd['last_9']+' '+\\\n",
    "wkd['last_10']+' '+wkd['last_11']+' '+wkd['last_12']+' '+wkd['last_13']+' '+wkd['last_14']\n",
    "\n",
    "wkd['last_14days']=wkd['last_14days'].apply(lambda x:x.split(' '))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "wkd['new1']=wkd['WKD_TYP_CD'].apply(lambda x:x=='WN')&wkd['last_1'].apply(lambda x:x=='SN')\n",
    "wkd['new1']=wkd['new1'].astype(int)\n",
    "wkd['afterhod']=wkd['WKD_TYP_CD'].apply(lambda x:x=='WN')&wkd['last_1'].apply(lambda x:x=='NH')\n",
    "wkd['afterhod']=wkd['afterhod'].astype(int)\n",
    "wkd['afterwkdch']=wkd['WKD_TYP_CD'].apply(lambda x:x=='WN')&wkd['last_1'].apply(lambda x:x=='SS')\n",
    "wkd['afterwkdch']=wkd['afterwkdch'].astype(int)\n",
    "wkd['afterhodch']=wkd['WKD_TYP_CD'].apply(lambda x:x=='WN')&wkd['last_1'].apply(lambda x:x=='WS')\n",
    "wkd['afterhodch']=wkd['afterhodch'].astype(int)\n",
    "wkd['hodratio7']=wkd['last_7days'].apply(lambda x:x.count('NH')/len(x))\n",
    "wkd['hodratio14']=wkd['last_14days'].apply(lambda x:x.count('NH')/len(x))\n",
    "wkd['wkdchratio7']=wkd['last_7days'].apply(lambda x:x.count('SS')/len(x))\n",
    "wkd['wkdchratio14']=wkd['last_14days'].apply(lambda x:x.count('SS')/len(x))\n",
    "wkd['hodchratio7']=wkd['last_7days'].apply(lambda x:x.count('WS')/len(x))\n",
    "wkd['hodchratio14']=wkd['last_14days'].apply(lambda x:x.count('WS')/len(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TRAIN\n",
    "pos_a=train2[train2.post_id=='A']\n",
    "pos_b=train2[train2.post_id=='B'].reset_index(drop=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "pos_a.date=pd.to_datetime(pos_a.date)\n",
    "pos_b.date=pd.to_datetime(pos_b.date)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TEST\n",
    "pos_a_test=test2[test2.post_id=='A']\n",
    "pos_b_test=test2[test2.post_id=='B']\n",
    "pos_a_test.date=pd.to_datetime(pos_a_test.date)\n",
    "pos_b_test.date=pd.to_datetime(pos_b_test.date)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "pos_a_test=pos_a_test.set_index('date',drop=True)\n",
    "pos_b_test=pos_b_test.set_index('date',drop=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 评估准则"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mape(prediction,target):\n",
    "    assert len(prediction)==len(target)\n",
    "    duration=len(target)\n",
    "    error_sum=0\n",
    "    for i in range(duration):\n",
    "        error_sum+=abs((prediction[i]-target[i])/(target[i]+1))\n",
    "    return error_sum/duration\n",
    "#for task 1\n",
    "def plot(df):\n",
    "    plt.figure(figsize=(20,15))\n",
    "    plt.plot(df.index,df.amount)\n",
    "    plt.show()\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# TASK1 天粒度"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "pos_as=['A{}'.format(i) for i in range(1,14)]\n",
    "train_sub={}\n",
    "for ai in pos_as:\n",
    "    train_sub[ai]=pos_a[pos_a.biz_type==ai].groupby('date')[['amount']].sum()\n",
    "    train_sub[ai].index=pd.DatetimeIndex(train_sub[ai].index.values,freq='D')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "pos_b_day=pos_b.groupby('date')[['amount']].sum()\n",
    "pos_b_day.index=pd.DatetimeIndex(pos_b_day.index.values,freq='D')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "def normalization(df,col):\n",
    "    max_=max(df[col].unique())\n",
    "    min_=min(df[col].unique())\n",
    "    df[col]=df[col].apply(lambda x:(x-min_)/(max_-min_))\n",
    "\n",
    "def feature_construct(time_series,train=True): #time_series include the date(index) and amount\n",
    "    X=pd.DataFrame()\n",
    "    if train:\n",
    "        X['amount']=time_series.amount\n",
    "    X['date']=time_series.index\n",
    "    X['year']=time_series.index.year\n",
    "    X['month']=time_series.index.month\n",
    "    X['day']=time_series.index.day\n",
    "\n",
    "    X=pd.merge(X,wkd,on='date',how='left')\n",
    "    for i in ['WN','SN','NH','SS','WS']:\n",
    "        X[i]=X['WKD_TYP_CD'].apply(lambda x:x==i).astype(int)\n",
    "    \n",
    "    if train:\n",
    "        X=X.iloc[14:,:].reset_index(drop=True)\n",
    "    #新冠肺炎\n",
    "    X['xg']=0\n",
    "    for i in range(X.shape[0]):\n",
    "        if X.year[i]==2020 and X.month[i] in (1,2,3):\n",
    "                X['xg'][i]=1\n",
    "    \n",
    "    \n",
    "    if train:\n",
    "        output=X[['amount','year','month','day','WN','SN','NH','SS','WS',\\\n",
    "                    'new1',\n",
    "                    'afterhod',\n",
    "                    'afterwkdch',\n",
    "                    'afterhodch',\n",
    "                    'hodratio7',\n",
    "                    'hodratio14',\n",
    "                    'wkdchratio7',\n",
    "                    'wkdchratio14',\n",
    "                    'hodchratio7',\n",
    "                    'hodchratio14',\n",
    "                    'xg']]\n",
    "        for i in ('year','month','day'):\n",
    "            normalization(output,i)\n",
    "    else:\n",
    "        output=X[['year','month','day','WN','SN','NH','SS','WS',\\\n",
    "                   'new1',\n",
    "                   'afterhod',\n",
    "                   'afterwkdch',\n",
    "                   'afterhodch',\n",
    "                    'hodratio7',\n",
    "                    'hodratio14',\n",
    "                    'wkdchratio7',\n",
    "                    'wkdchratio14',\n",
    "                    'hodchratio7',\n",
    "                    'hodchratio14',\n",
    "                    'xg']] #test\n",
    "        output['year']=output['year'].apply(lambda x:(x-2018)/(2020-2018))\n",
    "        output['month']=output['month'].apply(lambda x:(x-1)/(12-1))\n",
    "        output['day']=output['day'].apply(lambda x:(x-1)/(31-1))\n",
    "    \n",
    "    return output  \n",
    "\n",
    "from sklearn.ensemble import RandomForestRegressor\n",
    "from sklearn.ensemble import GradientBoostingRegressor\n",
    "from xgboost import XGBRegressor\n",
    "from numpy import array\n",
    "def models_train_predict(x,y,test_x):\n",
    "    train_x_complete,train_y_complete=x,y\n",
    "    train_x,valid_x=train_x_complete[:-30],train_x_complete[-30:]\n",
    "    train_y,valid_y=train_y_complete[:-30],train_y_complete[-30:]\n",
    "    \n",
    "    min_valid_error=100\n",
    "    best_model=None\n",
    "    preds=[]\n",
    "    model1=RandomForestRegressor(n_estimators=1000,\n",
    "                         criterion='mae',\n",
    "                         #max_depth=10\n",
    "                        )\n",
    "    model2=GradientBoostingRegressor(n_estimators=300,criterion='mae')\n",
    "    model3=XGBRegressor(learning_rate=0.1,\n",
    "                n_estimators=400,\n",
    "                 objective='reg:squarederror',\n",
    "                booster='gblinear')\n",
    "    models=[model1,model2,model3]\n",
    "    \n",
    "    for model in models:\n",
    "        model.fit(train_x,train_y)\n",
    "        pred=model.predict(valid_x)\n",
    "        preds.append(pred)\n",
    "        valid_error=mape(pred.tolist(),valid_y.tolist())\n",
    "        if valid_error<min_valid_error:\n",
    "            min_valid_error=valid_error\n",
    "            best_model=model\n",
    "    \n",
    "    #compare the performance between model average and best model\n",
    "    avg_preds=model_avg(preds[0],preds[1],preds[2])\n",
    "    avg_preds_error=mape(avg_preds.tolist(),valid_y.tolist())\n",
    "    if avg_preds_error<min_valid_error:\n",
    "        final_preds=[]\n",
    "        for model in models:\n",
    "            model.fit(train_x_complete,train_y_complete)\n",
    "            pred=model.predict(test_x)\n",
    "            final_preds.append(pred)\n",
    "        return model_avg(final_preds[0],final_preds[1],final_preds[2])\n",
    "        \n",
    "    \n",
    "    best_model.fit(train_x_complete,train_y_complete)\n",
    "    prediction=best_model.predict(test_x)\n",
    "    return array(prediction)\n",
    "\n",
    "\n",
    "def model_avg(pred1,pred2,pred3):\n",
    "    pred1_adj=[i if i>=0 else 0 for i in pred1.tolist()]\n",
    "    pred2_adj=[i if i>=0 else 0 for i in pred2.tolist()]\n",
    "    pred3_adj=[i if i>=0 else 0 for i in pred3.tolist()]\n",
    "    pred_avg=[]\n",
    "    for i in range(len(pred1_adj)):\n",
    "        pred_avg.append((pred1_adj[i]+pred2_adj[i]+pred3_adj[i])/3)\n",
    "    return array(pred_avg)\n",
    "\n",
    "def predict_a(type_a):\n",
    "    sub_a=train_sub[type_a]\n",
    "    sub_a_train=feature_construct(sub_a,train=True)\n",
    "    sub_a_test=feature_construct(pos_a_test,train=False)\n",
    "\n",
    "    sub_a_train_y,sub_a_train_x=sub_a_train.iloc[:,0],sub_a_train.iloc[:,1:]\n",
    "    \n",
    "    prediction=models_train_predict(sub_a_train_x,sub_a_train_y,sub_a_test)\n",
    "    prediction_adj=[i if i>=0 else 0 for i in prediction.tolist()]\n",
    "    return array(prediction_adj)\n",
    "\n",
    "#same story for b(write again just for clearity)\n",
    "def predict_b():\n",
    "    b_train=feature_construct(pos_b_day,train=True)\n",
    "    b_test=feature_construct(pos_b_test,train=False)\n",
    "\n",
    "    b_train_y,b_train_x=b_train.iloc[:,0],b_train.iloc[:,1:]\n",
    "    \n",
    "    prediction=models_train_predict(b_train_x,b_train_y,b_test)\n",
    "    prediction_adj=[i if i>=0 else 0 for i in prediction.tolist()]\n",
    "    return array(prediction_adj)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 传统时间序列方法建模"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "#acf and pacf\n",
    "from statsmodels.tsa.stattools import acf, pacf\n",
    "from statsmodels.graphics.tsaplots import plot_acf, plot_pacf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "ARIMA\n",
    "use classical time-series model:ARIMA\n",
    "from statsmodels.tsa.arima_model import ARIMA\n",
    "#parameter order=(p,d,q)\n",
    "#where p: periods taken for autoregressive model\n",
    "#      d: Integrated order, differnce\n",
    "#      q: periods in moving average model\n",
    "def arima_forecast(train_set,valid_set,d,p,q):\n",
    "    model_arima=ARIMA(train_set,order=(d,p,q))\n",
    "    model_arima_fit=model_arima.fit()\n",
    "    \n",
    "    print(model_arima_fit.aic) #check performance\n",
    "    predictions=model_arima_fit.forecast(steps=31)[0]\n",
    "    plt.plot(valid_set.tolist(),color='red')\n",
    "    plt.plot(predictions,color='blue')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "#position A1 as example\n",
    "train_a1,valid_a1=train_valid_split(res_sub['A1'])\n",
    "\n",
    "fig, axes = plt.subplots(1,2,figsize=(16,3), dpi= 100)\n",
    "plot_acf(train_a1.tolist(),lags=30,ax=axes[0])\n",
    "plot_pacf(train_a1.tolist(),lags=30,ax=axes[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "arima_forecast(train_a1,valid_a1,15,1,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 深度学习方法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "feature\n",
    "import numpy as np\n",
    "def split_sequence(sequence,n_steps):\n",
    "    X,y=list(),list()\n",
    "    for i in range(len(sequence)):\n",
    "        end_ix=i+n_steps\n",
    "        if end_ix>len(sequence)-1:\n",
    "            break\n",
    "        \n",
    "        seq_x,seq_y=sequence[i:end_ix],sequence[end_ix]\n",
    "        X.append(seq_x)\n",
    "        y.append(seq_y)\n",
    "    return np.array(X),np.array(y)\n",
    "\n",
    "\n",
    "#take a1 as an example\n",
    "a1_list=res_sub['A1']['amount'].tolist()\n",
    "n_steps=60\n",
    "X,y=split_sequence(sequence=a1_list,n_steps=n_steps)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train/valid split\n",
    "X=X.reshape(X.shape[0],1,X.shape[1])\n",
    "X_train,y_train=X[:-31],y[:-31]\n",
    "X_valid,y_valid=X[-31:],y[-31:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vanilla lstm\n",
    "from tensorflow import keras\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import LSTM,Dense\n",
    "from tensorflow.keras.callbacks import ModelCheckpoint\n",
    "\n",
    "model = Sequential()\n",
    "model.add(LSTM(32, activation='relu', input_shape=(1,n_steps)))\n",
    "model.add(Dense(1))\n",
    "model.compile(optimizer='adam', loss='mse')\n",
    "\n",
    "\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "checkpoint = ModelCheckpoint(filepath='lstm.ckpt',monitor='val_loss',mode='auto',save_best_only='True')\n",
    "model.fit(X_train,y_train,epochs=100,verbose=1,validation_split=0.1,callbacks=[checkpoint])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.models import load_model\n",
    "lstm_star=load_model('lstm.ckpt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "prediction_lstm=lstm_star.predict(X_valid)\n",
    "plt.plot([i for i in range(31)],prediction_lstm,color='blue')\n",
    "plt.plot([i for i in range(31)],y_valid,color='red')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 机器学习方法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "#position A1 as example\n",
    "a1=train_sub['A1']\n",
    "a1_featured=feature_construct(a1)\n",
    "train_a1_featured,valid_a1_featured=a1_featured[:-30],a1_featured[-30:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_a1_x,valid_a1_x=train_a1_featured.iloc[:,1:],valid_a1_featured.iloc[:,1:]\n",
    "train_a1_y,valid_a1_y=train_a1_featured.iloc[:,0],valid_a1_featured.iloc[:,0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "#random forest\n",
    "from sklearn.ensemble import RandomForestRegressor\n",
    "rf=RandomForestRegressor(n_estimators=1000,\n",
    "                         criterion='mae',\n",
    "                         #max_depth=10\n",
    "                        )\n",
    "rf.fit(train_a1_x,train_a1_y)\n",
    "rf_pred=rf.predict(valid_a1_x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.23184540393131156"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mape(prediction=rf_pred.tolist(),target=valid_a1_y.tolist())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot([i for i in range(30)],rf_pred,color='blue')\n",
    "plt.plot([i for i in range(30)],valid_a1_y,color='red')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "#gbdt\n",
    "from sklearn.ensemble import GradientBoostingRegressor\n",
    "gbdt=GradientBoostingRegressor(n_estimators=350,criterion='mae')\n",
    "gbdt.fit(train_a1_x,train_a1_y)\n",
    "gbdt_pred=gbdt.predict(valid_a1_x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 601,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.08484369175454237"
      ]
     },
     "execution_count": 601,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mape(prediction=gbdt_pred.tolist(),target=valid_a1_y.tolist())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot([i for i in range(30)],gbdt_pred,color='blue')\n",
    "plt.plot([i for i in range(30)],valid_a1_y,color='red')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "#xgboost\n",
    "from xgboost import XGBRegressor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [],
   "source": [
    "xgb=XGBRegressor(learning_rate=0.1,\n",
    "                n_estimators=10,\n",
    "                 objective='reg:squarederror',\n",
    "                booster='dart')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [],
   "source": [
    "xgb.fit(train_a1_x,train_a1_y,eval_metric='mae')\n",
    "xgb_pred=xgb.predict(valid_a1_x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [],
   "source": [
    "xgb_pred_adj=[i if i>=0 else 0 for i in xgb_pred.tolist()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot([i for i in range(30)],xgb_pred_adj,color='blue')\n",
    "plt.plot([i for i in range(30)],valid_a1_y,color='red')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.2657992097959018"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mape(prediction=xgb_pred_adj,target=valid_a1_y.tolist())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "#avg of 3 models\n",
    "def model_avg(pred1,pred2,pred3):\n",
    "    pred1_adj=[i if i>=0 else 0 for i in pred1.tolist()]\n",
    "    pred2_adj=[i if i>=0 else 0 for i in pred2.tolist()]\n",
    "    pred3_adj=[i if i>=0 else 0 for i in pred3.tolist()]\n",
    "    pred_avg=[]\n",
    "    for i in range(len(pred1_adj)):\n",
    "        pred_avg.append((pred1_adj[i]+pred2_adj[i]+pred3_adj[i])/3)\n",
    "    return pred_avg\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pred_avg=model_avg(rf_pred,gbdt_pred,xgb_pred)\n",
    "plt.plot([i for i in range(30)],pred_avg,color='blue')\n",
    "plt.plot([i for i in range(30)],valid_a1_y,color='red')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.17251863300121115"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mape(prediction=pred_avg,target=valid_a1_y.tolist())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "#stacking of 3 models\n",
    "# from sklearn.ensemble import StackingRegressor\n",
    "# from sklearn import linear_model\n",
    "# final_estimator=linear_model.LinearRegression()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# estimators=[('rf',rf),('gbdt',gbdt),('xgboost',xgb)]\n",
    "# stackreg=StackingRegressor(estimators=estimators,\n",
    "#                            cv=10,\n",
    "#                            final_estimator=final_estimator)\n",
    "# stackreg.fit(train_a1_x,train_a1_y)\n",
    "# stack_pred=stackreg.predict(valid_a1_x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plt.plot([i for i in range(30)],stack_pred,color='blue')\n",
    "# plt.plot([i for i in range(30)],valid_a1_y,color='red')\n",
    "# plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "# mape(stack_pred.tolist(),valid_a1_y.tolist())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Task 1完整预测"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 675,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "\n",
      "  0%|          | 0/13 [00:00<?, ?it/s]\u001b[A\u001b[A\u001b[A\n",
      "\n",
      "\n",
      "  8%|▊         | 1/13 [01:35<19:06, 95.51s/it]\u001b[A\u001b[A\u001b[A\n",
      "\n",
      "\n",
      " 15%|█▌        | 2/13 [02:48<15:24, 84.07s/it]\u001b[A\u001b[A\u001b[A\n",
      "\n",
      "\n",
      " 23%|██▎       | 3/13 [04:11<13:57, 83.80s/it]\u001b[A\u001b[A\u001b[A\n",
      "\n",
      "\n",
      " 31%|███       | 4/13 [06:36<14:51, 99.05s/it]\u001b[A\u001b[A\u001b[A\n",
      "\n",
      "\n",
      " 38%|███▊      | 5/13 [07:51<12:34, 94.31s/it]\u001b[A\u001b[A\u001b[A\n",
      "\n",
      "\n",
      " 46%|████▌     | 6/13 [09:27<11:02, 94.67s/it]\u001b[A\u001b[A\u001b[A\n",
      "\n",
      "\n",
      " 54%|█████▍    | 7/13 [11:15<09:38, 96.50s/it]\u001b[A\u001b[A\u001b[A\n",
      "\n",
      "\n",
      " 62%|██████▏   | 8/13 [12:35<07:52, 94.41s/it]\u001b[A\u001b[A\u001b[A\n",
      "\n",
      "\n",
      " 69%|██████▉   | 9/13 [13:54<06:11, 92.76s/it]\u001b[A\u001b[A\u001b[A\n",
      "\n",
      "\n",
      " 77%|███████▋  | 10/13 [15:32<04:39, 93.28s/it]\u001b[A\u001b[A\u001b[A\n",
      "\n",
      "\n",
      " 85%|████████▍ | 11/13 [17:08<03:07, 93.51s/it]\u001b[A\u001b[A\u001b[A\n",
      "\n",
      "\n",
      " 92%|█████████▏| 12/13 [18:42<01:33, 93.56s/it]\u001b[A\u001b[A\u001b[A\n",
      "\n",
      "\n",
      "100%|██████████| 13/13 [20:16<00:00, 93.59s/it]\u001b[A\u001b[A\u001b[A\n",
      "\n",
      "\n",
      "\u001b[A\u001b[A\u001b[A"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "position A DONE!\n"
     ]
    }
   ],
   "source": [
    "#完整预测 a1,a2,a3....a13\n",
    "test_steps=pos_a_test.shape[0]\n",
    "pred_sum_a=array([0 for i in range(test_steps)],dtype=float)\n",
    "\n",
    "for i in tqdm(pos_as):\n",
    "    sub_pred=predict_a(i)\n",
    "    pred_sum_a+=sub_pred\n",
    "print('position A DONE!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 676,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "position B DONE!\n"
     ]
    }
   ],
   "source": [
    "#预测b1\n",
    "pred_b=predict_b()\n",
    "print('position B DONE!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 677,
   "metadata": {},
   "outputs": [],
   "source": [
    "#submit\n",
    "final_prediction=[]\n",
    "for i in range(test_steps):\n",
    "    final_prediction.append(pred_sum_a[i])\n",
    "    final_prediction.append(pred_b[i])\n",
    "\n",
    "test2['amount']=final_prediction\n",
    "test2.amount=test2.amount.apply(lambda x:round(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 678,
   "metadata": {},
   "outputs": [],
   "source": [
    "test2.to_csv('task1_pred2_2.txt',index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Task2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "#train a2\n",
    "pos_as=['A{}'.format(i) for i in range(1,14)]\n",
    "train_sub2={}\n",
    "for i in pos_as:\n",
    "    train_sub2[i]=pos_a[pos_a.biz_type==i][['date','periods','amount']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "#train b2\n",
    "pos_b_hour=pos_b[['date','periods','amount']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "#test2\n",
    "pos_a_test2=test2_periods[test2_periods['post_id']=='A'][['date','periods']]\n",
    "pos_a_test2['date']=pd.to_datetime(pos_a_test2['date'])\n",
    "\n",
    "pos_b_test2=test2_periods[test2_periods['post_id']=='B'][['date','periods']]\n",
    "pos_b_test2['date']=pd.to_datetime(pos_b_test2['date'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 272,
   "metadata": {},
   "outputs": [],
   "source": [
    "#对于periods做聚合来看一下构建其余特征的可能性\n",
    "# a1=train_sub2['A1']\n",
    "# a1.groupby('periods')[['amount']].sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "def feature_construct2(time_series,train=True): #time_series include the date(index) and amount\n",
    "    X=pd.DataFrame()\n",
    "    if train:\n",
    "        X['amount']=time_series.amount\n",
    "    X['date']=time_series.date\n",
    "    X['year']=time_series.date.apply(lambda x:x.year)\n",
    "    X['month']=time_series.date.apply(lambda x:x.month)\n",
    "    X['day']=time_series.date.apply(lambda x:x.day)\n",
    "    X['period']=time_series.periods\n",
    "    X['morning']=0\n",
    "    X['morning']=X['period'].apply(lambda x:x in [i for i in range(18,26)]).astype(int)\n",
    "    X['afternoon']=0\n",
    "    X['afternoon']=X['period'].apply(lambda x:x in [i for i in range(26,37)]).astype(int)\n",
    "\n",
    "    X=pd.merge(X,wkd,on='date',how='left')\n",
    "    \n",
    "    for i in ['WN','SN','NH','SS','WS']:\n",
    "        X[i]=X['WKD_TYP_CD'].apply(lambda x:x==i).astype(int)\n",
    "    \n",
    "    if train:\n",
    "        X=X.iloc[48*14:,:].reset_index(drop=True)\n",
    "    \n",
    "    #新冠肺炎\n",
    "    X['xg']=0\n",
    "    for i in range(X.shape[0]):\n",
    "        if X.year[i]==2020 and X.month[i] in (1,2,3):\n",
    "                X['xg'][i]=1\n",
    "    if train:\n",
    "        output=X[['amount','year','month','day','period','morning','afternoon','WN','SN','NH','SS','WS',\\\n",
    "                  'new1',\n",
    "                  'afterhod',\n",
    "                  'afterwkdch',\n",
    "                  'afterhodch',\n",
    "                  'hodratio7',\n",
    "                  'hodratio14',\n",
    "                  'wkdchratio7',\n",
    "                  'wkdchratio14',\n",
    "                  'hodchratio7',\n",
    "                  'hodchratio14',\n",
    "                  'xg']]\n",
    "        for i in ('year','month','day','period'):\n",
    "            normalization(output,i)\n",
    "    else:\n",
    "        output=X[['year','month','day','period','morning','afternoon','WN','SN','NH','SS','WS',\n",
    "                  'new1',\n",
    "                  'afterhod',\n",
    "                  'afterwkdch',\n",
    "                  'afterhodch',\n",
    "                  'hodratio7',\n",
    "                  'hodratio14',\n",
    "                  'wkdchratio7',\n",
    "                  'wkdchratio14',\n",
    "                  'hodchratio7',\n",
    "                  'hodchratio14',\n",
    "                  'xg']] #test\n",
    "        output['year']=output['year'].apply(lambda x:(x-2018)/(2020-2018))\n",
    "        output['month']=output['month'].apply(lambda x:(x-1)/(12-1))\n",
    "        output['day']=output['day'].apply(lambda x:(x-1)/(31-1))\n",
    "        output['period']=output['period'].apply(lambda x:(x-1)/(48-1))\n",
    "    \n",
    "    return output "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "#take a1 as example\n",
    "a1_2=train_sub2['A1']\n",
    "a1_featured2=feature_construct2(a1_2)\n",
    "train_a1_featured2,valid_a1_featured2=a1_featured2[:-30*48],a1_featured2[-30*48:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_a1_x2,valid_a1_x2=train_a1_featured2.iloc[:,1:],valid_a1_featured2.iloc[:,1:]\n",
    "train_a1_y2,valid_a1_y2=train_a1_featured2.iloc[:,0],valid_a1_featured2.iloc[:,0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "training use 1182.4787480831146 seconds\n"
     ]
    }
   ],
   "source": [
    "rf2=RandomForestRegressor(n_estimators=100,\n",
    "                         criterion='mae',\n",
    "                         max_depth=5,\n",
    "                         min_samples_split=30,\n",
    "                         min_samples_leaf=5,\n",
    "                        max_features='sqrt')\n",
    "start=time.time()\n",
    "rf2.fit(train_a1_x2,train_a1_y2)\n",
    "print(f'training use {time.time()-start} seconds')\n",
    "rf_pred=rf2.predict(valid_a1_x2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot([i for i in range(30*48)],rf_pred,color='blue')\n",
    "plt.plot([i for i in range(30*48)],valid_a1_y2,color='red')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.1966457900816051"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mape(prediction=rf_pred.tolist(),target=valid_a1_y2.tolist())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "model1=XGBRegressor(learning_rate=0.1,\n",
    "                n_estimators=300,\n",
    "                 objective='reg:squarederror')\n",
    "model1.fit(train_a1_x2,train_a1_y2)\n",
    "pred_xgb_a1=model1.predict(valid_a1_x2)\n",
    "pred_xgb_a1_adj=[i if i>=0 else 0 for i in pred_xgb_a1.tolist()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot([i for i in range(30*48)],pred_xgb_a1_adj,color='blue')\n",
    "plt.plot([i for i in range(30*48)],valid_a1_y2,color='red')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.23385117194584407"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mape(prediction=pred_xgb_a1_adj,target=valid_a1_y2.tolist())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Task 2完整预测"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 671,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "\n",
      "  0%|          | 0/13 [00:00<?, ?it/s]\u001b[A\u001b[A\u001b[A\n",
      "\n",
      "\n",
      "  8%|▊         | 1/13 [00:08<01:38,  8.19s/it]\u001b[A\u001b[A\u001b[A\n",
      "\n",
      "\n",
      " 15%|█▌        | 2/13 [00:17<01:34,  8.59s/it]\u001b[A\u001b[A\u001b[A\n",
      "\n",
      "\n",
      " 23%|██▎       | 3/13 [00:26<01:27,  8.77s/it]\u001b[A\u001b[A\u001b[A\n",
      "\n",
      "\n",
      " 31%|███       | 4/13 [00:34<01:18,  8.67s/it]\u001b[A\u001b[A\u001b[A\n",
      "\n",
      "\n",
      " 38%|███▊      | 5/13 [00:43<01:09,  8.73s/it]\u001b[A\u001b[A\u001b[A\n",
      "\n",
      "\n",
      " 46%|████▌     | 6/13 [00:52<01:01,  8.72s/it]\u001b[A\u001b[A\u001b[A\n",
      "\n",
      "\n",
      " 54%|█████▍    | 7/13 [01:00<00:51,  8.63s/it]\u001b[A\u001b[A\u001b[A\n",
      "\n",
      "\n",
      " 62%|██████▏   | 8/13 [01:08<00:42,  8.56s/it]\u001b[A\u001b[A\u001b[A\n",
      "\n",
      "\n",
      " 69%|██████▉   | 9/13 [01:16<00:33,  8.49s/it]\u001b[A\u001b[A\u001b[A\n",
      "\n",
      "\n",
      " 77%|███████▋  | 10/13 [01:24<00:25,  8.43s/it]\u001b[A\u001b[A\u001b[A\n",
      "\n",
      "\n",
      " 85%|████████▍ | 11/13 [01:32<00:16,  8.40s/it]\u001b[A\u001b[A\u001b[A\n",
      "\n",
      "\n",
      " 92%|█████████▏| 12/13 [01:40<00:08,  8.41s/it]\u001b[A\u001b[A\u001b[A\n",
      "\n",
      "\n",
      "100%|██████████| 13/13 [01:52<00:00,  8.62s/it]\u001b[A\u001b[A\u001b[A\n",
      "\n",
      "\n",
      "\u001b[A\u001b[A\u001b[A"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Done\n"
     ]
    }
   ],
   "source": [
    "#predict for a1,a2...a13\n",
    "test_steps2=pos_a_test2.shape[0]\n",
    "pred_a_sum2=array([0 for i in range(test_steps2)],dtype=float)\n",
    "\n",
    "for i in tqdm(pos_as):\n",
    "    sub_a2=train_sub2[i]\n",
    "    sub_a2_train=feature_construct2(sub_a2)\n",
    "    a2_test=feature_construct2(pos_a_test2,train=False)\n",
    "    \n",
    "    sub_a2_train_x,sub_a2_train_y=sub_a2_train.iloc[:,1:],sub_a2_train.iloc[:,0]\n",
    "    model=XGBRegressor(learning_rate=0.1,\n",
    "                n_estimators=200,\n",
    "                 objective='reg:squarederror')\n",
    "    model.fit(sub_a2_train_x,sub_a2_train_y)\n",
    "    pred=model.predict(a2_test)\n",
    "    pred_adj=[i if i>=0 else 0 for i in pred.tolist()]\n",
    "    pred_adj=array(pred_adj)\n",
    "    pred_a_sum2+=pred_adj\n",
    "print('Done')  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 672,
   "metadata": {},
   "outputs": [],
   "source": [
    "#predict for b\n",
    "train_b2=feature_construct2(pos_b_hour)\n",
    "test_b2=feature_construct2(pos_b_test2,train=False)\n",
    "train_b2_y,train_b2_x=train_b2.iloc[:,0],train_b2.iloc[:,1:]\n",
    "\n",
    "model2=XGBRegressor(learning_rate=0.1,\n",
    "                  n_estimators=200,\n",
    "                  objective='reg:squarederror')\n",
    "    \n",
    "model2.fit(train_b2_x,train_b2_y)\n",
    "pred_b2=model2.predict(test_b2)\n",
    "pred_b2_adj=[i if i>=0 else 0 for i in pred_b2.tolist()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 673,
   "metadata": {},
   "outputs": [],
   "source": [
    "#submit\n",
    "final_prediction2=[]\n",
    "pred_a2=pred_a_sum2.tolist()\n",
    "pred_b2=pred_b2_adj\n",
    "#dec has 31 days\n",
    "for i in range(31):\n",
    "    final_prediction2+=pred_a2[i*48:(i+1)*48]\n",
    "    final_prediction2+=pred_b2[i*48:(i+1)*48]\n",
    "\n",
    "test2_periods['amount']=final_prediction2\n",
    "test2_periods.amount=test2_periods.amount.apply(lambda x:round(x))\n",
    "\n",
    "test2_periods.to_csv('task2_pred2.txt',index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}