Model.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Models"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Firstly, we need to import the libraries we will use."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import lightgbm as lgb\n",
    "import xgboost as xgb\n",
    "import catboost as cat\n",
    "from sklearn.model_selection import KFold\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.model_selection import cross_val_score\n",
    "from sklearn.ensemble import RandomForestRegressor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Secondly, we need to load the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "train = pd.read_csv('data/train_engineered.csv')\n",
    "test = pd.read_csv('data/test_engineered.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the following models, we will predict the log revenue and then convert to the revenue.\n",
    "Because based on the previous trials, these method will have better score than dirctly predict revenue."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create log features and log revenue as target\n",
    "train['log_budget']=np.log1p(train['original_budget'])\n",
    "test['log_budget']=np.log1p(test['original_budget'])\n",
    "train['log_budget_p'] = np.log1p(train['budget_processed'])\n",
    "test['log_budget_p'] = np.log1p(test['budget_processed'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These are the features we engineered and will used in the following models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Unnamed: 0' 'id' 'belongs_to_collection' 'original_budget'\n",
      " 'budget_processed' 'genre_rank' 'num_genres' 'genre_mean_rev'\n",
      " 'has_homepage' 'originally_english' 'language_mean_rev' 'topStudio'\n",
      " 'numTopStudios' 'num_studios' 'studioRank' 'studio_mean_rev'\n",
      " 'num_production_countries' 'topCountry' 'countryRank' 'usa_produced'\n",
      " '1960s' '1970s' '1980s' '1990s' '2000s' '2010s' 'mondayRelease'\n",
      " 'tuesdayRelease' 'wednesdayRelease' 'thursdayRelease' 'fridayRelease'\n",
      " 'saturdayRelease' 'sundayRelease' 'Winter' 'Fall' 'Spring' 'Summer'\n",
      " 'season' 'day' 'month' 'year' 'day_of_week' 'week_of_year'\n",
      " 'runtime_processed' 'spoken_english' 'num_languages' 'has_tagline'\n",
      " 'num_keywords' 'numTopKeywords' 'keywordRank' 'cast_num' 'topLeadActor'\n",
      " 'numTopActors' 'actorRanks' 'topActorRank' 'actor_mean_rev' 'crew_num'\n",
      " 'topLeadDirector' 'numTopDirectors' 'directorsRank' 'director_mean_rev'\n",
      " 'topLeadExecProd' 'numTopExecProd' 'execProdRank' 'prod_mean_rev'\n",
      " 'topLeadProducer' 'numTopProducers' 'producersRank' 'producer_mean_rev'\n",
      " 'topLeadComposer' 'numTopComposers' 'composersRank'\n",
      " 'topLeadDirectorPhoto' 'numTopDirectorsPhoto' 'directorsPhotoRank'\n",
      " 'topLeadEditor' 'numTopEditors' 'editorsRank' 'editor_mean_rev'\n",
      " 'budget_to_year_ratio' 'runtime_to_year_ratio' 'inflationBudget'\n",
      " 'log_budget' 'popularity' 'popularity_year_ratio' '_budget_runtime_ratio'\n",
      " '_budget_popularity_ratio' 'tagline' 'title' 'overview' 'imdb_id'\n",
      " 'log_revenue' 'revenue' 'log_budget_p']\n"
     ]
    }
   ],
   "source": [
    "# print the title of each column of the train dataset\n",
    "print(train.columns.values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Unnamed: 0' 'id' 'belongs_to_collection' 'original_budget'\n",
      " 'budget_processed' 'genre_rank' 'num_genres' 'genre_mean_rev'\n",
      " 'has_homepage' 'originally_english' 'language_mean_rev' 'topStudio'\n",
      " 'numTopStudios' 'num_studios' 'studioRank' 'studio_mean_rev'\n",
      " 'num_production_countries' 'topCountry' 'countryRank' 'usa_produced'\n",
      " '1960s' '1970s' '1980s' '1990s' '2000s' '2010s' 'mondayRelease'\n",
      " 'tuesdayRelease' 'wednesdayRelease' 'thursdayRelease' 'fridayRelease'\n",
      " 'saturdayRelease' 'sundayRelease' 'Winter' 'Fall' 'Spring' 'Summer'\n",
      " 'season' 'day' 'month' 'year' 'day_of_week' 'week_of_year'\n",
      " 'runtime_processed' 'spoken_english' 'num_languages' 'has_tagline'\n",
      " 'num_keywords' 'numTopKeywords' 'keywordRank' 'cast_num' 'topLeadActor'\n",
      " 'numTopActors' 'actorRanks' 'topActorRank' 'actor_mean_rev' 'crew_num'\n",
      " 'topLeadDirector' 'numTopDirectors' 'directorsRank' 'director_mean_rev'\n",
      " 'topLeadExecProd' 'numTopExecProd' 'execProdRank' 'prod_mean_rev'\n",
      " 'topLeadProducer' 'numTopProducers' 'producersRank' 'producer_mean_rev'\n",
      " 'topLeadComposer' 'numTopComposers' 'composersRank'\n",
      " 'topLeadDirectorPhoto' 'numTopDirectorsPhoto' 'directorsPhotoRank'\n",
      " 'topLeadEditor' 'numTopEditors' 'editorsRank' 'editor_mean_rev'\n",
      " 'budget_to_year_ratio' 'runtime_to_year_ratio' 'inflationBudget'\n",
      " 'log_budget' 'popularity' 'popularity_year_ratio' '_budget_runtime_ratio'\n",
      " '_budget_popularity_ratio' 'tagline' 'title' 'overview' 'imdb_id'\n",
      " 'log_budget_p']\n"
     ]
    }
   ],
   "source": [
    "# print the title of each column of the test dataset\n",
    "print(test.columns.values)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These is features we selected to use."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Model training, based on correlations extracted at DataAnalysis part\n",
    "feature_regression = ['belongs_to_collection', 'original_budget',\n",
    "                       'budget_processed', 'genre_rank', 'num_genres', 'genre_mean_rev',\n",
    "                          'has_homepage', 'originally_english', 'language_mean_rev', 'topStudio',\n",
    "                                'numTopStudios', 'num_studios', 'studioRank', 'studio_mean_rev',\n",
    "                                        'num_production_countries', 'topCountry', 'countryRank', 'usa_produced',\n",
    "                                        '1960s', '1970s', '1980s', '1990s', '2000s', '2010s', 'mondayRelease',\n",
    "                                        'tuesdayRelease', 'wednesdayRelease', 'thursdayRelease', 'fridayRelease',\n",
    "                                                'saturdayRelease', 'sundayRelease', 'Winter', 'Fall', 'Spring', 'Summer',\n",
    "                                                'season', 'day', 'month', 'year', 'day_of_week', 'week_of_year',\n",
    "                                                'runtime_processed', 'spoken_english', 'num_languages', 'has_tagline',\n",
    "                                                'num_keywords', 'numTopKeywords', 'keywordRank', 'cast_num', 'topLeadActor',\n",
    "                                                        'numTopActors', 'actorRanks', 'topActorRank', 'actor_mean_rev', 'crew_num',\n",
    "                                                        'topLeadDirector', 'numTopDirectors', 'directorsRank', 'director_mean_rev',\n",
    "                                                        'topLeadExecProd', 'numTopExecProd', 'execProdRank', 'prod_mean_rev',\n",
    "                                                        'topLeadProducer', 'numTopProducers', 'producersRank', 'producer_mean_rev',\n",
    "                                                                'topLeadComposer', 'numTopComposers', 'composersRank',\n",
    "                                                                'topLeadDirectorPhoto', 'numTopDirectorsPhoto', 'directorsPhotoRank',\n",
    "                                                                'topLeadEditor', 'numTopEditors', 'editorsRank', 'editor_mean_rev',\n",
    "                                                                'budget_to_year_ratio', 'runtime_to_year_ratio', 'inflationBudget',\n",
    "                                                                        'log_budget', 'popularity', 'popularity_year_ratio', '_budget_runtime_ratio',\n",
    "                                                                        '_budget_popularity_ratio', 'log_budget_p']\n",
    "target = 'log_revenue'\n",
    "Y_train = train[target].values\n",
    "X_train = train[feature_regression].values\n",
    "X_test= test[feature_regression].values\n",
    "X_test = np.nan_to_num(X_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Linear Regression Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.6121979632616126\n"
     ]
    }
   ],
   "source": [
    "#carry out leaner regression\n",
    "LR = LinearRegression()\n",
    "\n",
    "# measure the performance of the model using cross validation\n",
    "scores = cross_val_score(LR, X_train, Y_train, scoring=\"neg_mean_squared_error\", cv = 8)\n",
    "rmse_scores = np.sqrt(-scores)\n",
    "print(rmse_scores.mean())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# fit the model\n",
    "LR.fit(X_train,Y_train)\n",
    "\n",
    "# predict the log_revenue and convert it back to revenue\n",
    "y_pred_LR_logbudget = LR.predict(X_test)\n",
    "y_pred_LR_logbudget = np.expm1(y_pred_LR_logbudget)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_LR = pd.DataFrame({'id': test['id'], 'revenue': y_pred_LR_logbudget})\n",
    "df_LR.to_csv('submission_LR_logbudget.csv', index=False)\n",
    "#2.0652"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Random Forest Model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this section, we will use Random Forest Model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "#carry out random forest regression\n",
    "#with tuned parameters\n",
    "#the result was improved from 3.1 to 2.3\n",
    "\n",
    "# initial the Random Forest Regressor\n",
    "RF = RandomForestRegressor(max_depth=200, min_samples_split=5,n_estimators=200)\n",
    "\n",
    "# fit the model\n",
    "RF.fit(X_train,Y_train)\n",
    "\n",
    "# predict the log_revenue and convert it back to revenue\n",
    "y_pred_RF = RF.predict(X_test)\n",
    "y_pred_RF = np.expm1(y_pred_RF)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_RF = pd.DataFrame({'id': test['id'], 'revenue': y_pred_RF})\n",
    "df_RF.to_csv('submission_RF.csv', index=False)\n",
    "#2.14405"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Error Detection Models"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "According to the presentation in the lecture. We know that the ground truth revenue will only get a score of 2.3 because of the error in the Kaggle test set. To further improve the score. We will use error detection model\n",
    "\n",
    "Error Detection Models are used to detect errors in the dataset. It is a classier that classifies the data into two classes: error and non-error. By learning from the feature of error in the train set. We will be able to recoginize the errors in the test set. After that, we can learn from the error data and non-error data and predict seperately.\n",
    "\n",
    "We will use lightgbm as our error detection model and lightgbm + xgboost + catboost for regression."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Error identifier"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1. data preparation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Firstly, we need to prepare the data for trainning the error detection model.\n",
    "\n",
    " We will use the data from the previous notebook. By plotting the distribution of the data, we can see seperation between the error and non-error data by recognizing the outliers and abnormal data.\n",
    "\n",
    " Here are plots to help recognize errors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\zjy\\AppData\\Local\\Temp\\ipykernel_11340\\4229348723.py:2: UserWarning: \n",
      "\n",
      "`distplot` is a deprecated function and will be removed in seaborn v0.14.0.\n",
      "\n",
      "Please adapt your code to use either `displot` (a figure-level function with\n",
      "similar flexibility) or `histplot` (an axes-level function for histograms).\n",
      "\n",
      "For a guide to updating your code to use the new functions, please see\n",
      "https://gist.github.com/mwaskom/de44147ed2974457ad6372750bbe5751\n",
      "\n",
      "  sns.distplot(train['revenue'], kde=False)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#plot the distribution of the revenue in the training set\n",
    "sns.distplot(train['revenue'], kde=False)\n",
    "plt.title('Distribution of revenue')\n",
    "plt.xlabel('Revenue')\n",
    "plt.ylabel('Frequency')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\zjy\\AppData\\Local\\Temp\\ipykernel_11340\\1025018483.py:2: UserWarning: \n",
      "\n",
      "`distplot` is a deprecated function and will be removed in seaborn v0.14.0.\n",
      "\n",
      "Please adapt your code to use either `displot` (a figure-level function with\n",
      "similar flexibility) or `histplot` (an axes-level function for histograms).\n",
      "\n",
      "For a guide to updating your code to use the new functions, please see\n",
      "https://gist.github.com/mwaskom/de44147ed2974457ad6372750bbe5751\n",
      "\n",
      "  sns.distplot(train['original_budget'], kde=False)\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkQAAAHFCAYAAAAT5Oa6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA+AUlEQVR4nO3de1hVdd7//9cOZYsIWwFhw4hoKqbhIbVBLFNTUcuzpQ0zpIVmt2YyymVj3XdpmaROWjOOZk1pea5Gq0kjMU85qHmITDNzymOCmOHmoIHi+v7Rj/VziwcgdIPr+biufV2uz3rvz3ovdsbLddo2wzAMAQAAWNgtnm4AAADA0whEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEQCW2YMEC2Ww281WjRg05nU516dJFycnJysrKKvGeSZMmyWazlWk7Z86c0aRJk7Rhw4Yyve9y22rQoIF69+5dpnmuZcmSJXrllVcuu85ms2nSpEkVur2K9tlnn6ldu3by9fWVzWbTBx98cNm6DRs2yGaz6f3337/uPR06dEg2m00LFiy4rtuZM2fOdd8GUBGqeboBANc2f/583XbbbTp37pyysrK0efNmTZs2TX/961+1fPlydevWzawdPny4evbsWab5z5w5o8mTJ0uSOnfuXOr3lWdb5bFkyRLt2bNHiYmJJdZt2bJF9erVu+49lJdhGBo8eLAiIyP10UcfydfXV02bNvV0WzfMnDlzFBQUpGHDhnm6FeCqCERAFRAVFaV27dqZy4MGDdKf//xn3X333Ro4cKAOHDigkJAQSVK9evWue0A4c+aMataseUO2dS3t27f36Pav5fjx4/r55581YMAAde3a1dPtALgCTpkBVVT9+vX18ssvKzc3V/PmzTPHL3caa926dercubMCAwPl4+Oj+vXra9CgQTpz5owOHTqkunXrSpImT55snp4r/hd98Xy7du3SAw88oDp16qhRo0ZX3FaxlStXqmXLlqpRo4ZuvfVW/e1vf3NbX3w68NChQ27jxaeNik/fde7cWatWrdLhw4fdTh8Wu9wpsz179qhfv36qU6eOatSoodatW+vtt9++7HaWLl2qZ555RmFhYfL391e3bt20f//+K//gL7J582Z17dpVfn5+qlmzpjp06KBVq1aZ6ydNmmQGxqeeeko2m00NGjS45ry//PKLxo0bJ6fTKR8fH3Xq1ElffvmlW03nzp0vezRv2LBhJbZx/PhxDR48WH5+fnI4HBoyZIgyMzMvu+033nhDkZGRstvtat68uZYsWXLZOQsLCzVlyhTddtttstvtqlu3rh555BGdPHnSrGnQoIH27t2rjRs3mp9bafYf8ASOEAFV2H333ScvLy9t2rTpijWHDh3S/fffr44dO+qtt95S7dq19eOPPyolJUWFhYUKDQ1VSkqKevbsqYSEBA0fPlySzJBUbODAgXrooYf0+OOPKz8//6p9paenKzExUZMmTZLT6dTixYs1duxYFRYWKikpqUz7OGfOHD322GP6/vvvtXLlymvW79+/Xx06dFBwcLD+9re/KTAwUIsWLdKwYcN04sQJTZgwwa3+6aef1l133aV//vOfysnJ0VNPPaU+ffpo37598vLyuuJ2Nm7cqO7du6tly5Z68803ZbfbNWfOHPXp00dLly7VkCFDNHz4cLVq1UoDBw7UmDFjFBcXJ7vdfs19ePrpp9WmTRv985//lMvl0qRJk9S5c2d9+eWXuvXWW6/9Q7vI2bNn1a1bNx0/flzJycmKjIzUqlWrNGTIkBK1r7/+ukaOHKlBgwZp1qxZcrlcmjx5sgoKCtzqLly4oH79+unzzz/XhAkT1KFDBx0+fFjPPfecOnfurB07dsjHx0crV67UAw88IIfDoTlz5khSqfYf8AgDQKU1f/58Q5Kxffv2K9aEhIQYzZo1M5efe+454+K/2u+//74hyUhPT7/iHCdPnjQkGc8991yJdcXzPfvss1dcd7GIiAjDZrOV2F737t0Nf39/Iz8/323fDh486Fa3fv16Q5Kxfv16c+z+++83IiIiLtv7pX0/9NBDht1uN44cOeJW16tXL6NmzZrG6dOn3bZz3333udW9++67hiRjy5Ytl91esfbt2xvBwcFGbm6uOXb+/HkjKirKqFevnnHhwgXDMAzj4MGDhiRjxowZV53v4p7atGljvt8wDOPQoUNG9erVjeHDh5tjnTp1Mjp16lRijqFDh7r9rObOnWtIMj788EO3uhEjRhiSjPnz5xuGYRhFRUWG0+k0oqOj3eoOHz5sVK9e3W3OpUuXGpKMf/3rX26127dvNyQZc+bMMcduv/32y/YJVDacMgOqOMMwrrq+devW8vb21mOPPaa3335bP/zwQ7m2M2jQoFLX3n777WrVqpXbWFxcnHJycrRr165ybb+01q1bp65duyo8PNxtfNiwYTpz5oy2bNniNt63b1+35ZYtW0qSDh8+fMVt5Ofna9u2bXrggQdUq1Ytc9zLy0vx8fE6duxYqU+7XU5cXJzbacGIiAh16NBB69evL/Nc69evl5+fX4n9jIuLc1vev3+/MjMzNXjwYLfx+vXr66677nIb+/jjj1W7dm316dNH58+fN1+tW7eW0+ks892KQGVAIAKqsPz8fJ06dUphYWFXrGnUqJHWrl2r4OBgjR49Wo0aNVKjRo306quvlmlboaGhpa51Op1XHDt16lSZtltWp06dumyvxT+jS7cfGBjotlx8Sufs2bNX3EZ2drYMwyjTdsriSj+/8sx56tQp84L7q22jeO7L1V46duLECZ0+fVre3t6qXr262yszM1M//fRTmfsEPI1riIAqbNWqVSoqKrrmrfIdO3ZUx44dVVRUpB07dujvf/+7EhMTFRISooceeqhU2yrLs40ud8Fu8VhxAKlRo4Yklbg+5bf+Mg0MDFRGRkaJ8ePHj0uSgoKCftP8klSnTh3dcsst1207V/r5XRzeatSoIZfLVaLu0p9fYGCgvvjii2tuo3juEydOXLM2KChIgYGBSklJuWz/fn5+lx0HKjOOEAFV1JEjR5SUlCSHw6GRI0eW6j1eXl6Kjo7WP/7xD0kyT1+V5qhIWezdu1dfffWV29iSJUvk5+enNm3aSJJ5t9Hu3bvd6j766KMS89nt9lL31rVrV61bt84MJsXeeecd1axZs0Ju0/f19VV0dLRWrFjh1teFCxe0aNEi1atXT5GRkeWef+nSpW6nQg8fPqy0tDS34NugQQN99913boHy1KlTSktLc5urS5cuys3NLfFzXbJkidty06ZN5XQ69e6777qNHzlypMScvXv31qlTp1RUVKR27dqVeF38nKWyfHaAJ3GECKgC9uzZY16nkZWVpc8//1zz58+Xl5eXVq5cWeKOsIu99tprWrdune6//37Vr19fv/zyi9566y1JMh/o6Ofnp4iICH344Yfq2rWrAgICFBQUVO5bpMPCwtS3b19NmjRJoaGhWrRokVJTUzVt2jTVrFlTknTnnXeqadOmSkpK0vnz51WnTh2tXLlSmzdvLjFfixYttGLFCs2dO1dt27bVLbfc4vZcpos999xz+vjjj9WlSxc9++yzCggI0OLFi7Vq1SpNnz5dDoejXPt0qeTkZHXv3l1dunRRUlKSvL29NWfOHO3Zs0dLly4t89PCL5aVlaUBAwZoxIgRcrlceu6551SjRg1NnDjRrImPj9e8efP0pz/9SSNGjNCpU6c0ffp0+fv7u8318MMPa9asWXr44Yf14osvqkmTJlq9erU+/fRTt7pbbrlFkydP1siRI/XAAw/o0Ucf1enTpzV58mSFhobqllv+/38/P/TQQ1q8eLHuu+8+jR07Vr///e9VvXp1HTt2TOvXr1e/fv00YMAASb9+dsuWLdPy5ct16623qkaNGmrRokW5fzbAdePhi7oBXEXxnVjFL29vbyM4ONjo1KmTMXXqVCMrK6vEey6982vLli3GgAEDjIiICMNutxuBgYFGp06djI8++sjtfWvXrjXuuOMOw263G5KMoUOHus138uTJa27LMH69y+z+++833n//feP22283vL29jQYNGhgzZ84s8f7vvvvOiI2NNfz9/Y26desaY8aMMVatWlXiLrOff/7ZeOCBB4zatWsbNpvNbZu6zN1xX3/9tdGnTx/D4XAY3t7eRqtWrcy7qYoV39H13nvvuY0X3xV2af3lfP7558a9995r+Pr6Gj4+Pkb79u2Nf//735edryx3mS1cuNB48sknjbp16xp2u93o2LGjsWPHjhL1b7/9ttGsWTOjRo0aRvPmzY3ly5eXuMvMMAzj2LFjxqBBg4xatWoZfn5+xqBBg4y0tLTL7ufrr79uNG7c2PD29jYiIyONt956y+jXr59xxx13uNWdO3fO+Otf/2q0atXKqFGjhlGrVi3jtttuM0aOHGkcOHDArDt06JARGxtr+Pn5GZKueLcg4Gk2w7jGLSoAAMs6ffq0IiMj1b9/f73++uuebge4bjhlBgCQ9OvF0y+++KK6dOmiwMBAHT58WLNmzVJubq7Gjh3r6faA64pABACQ9OsF0IcOHdKoUaP0888/mxehv/baa7r99ts93R5wXXHKDAAAWB633QMAAMsjEAEAAMsjEAEAAMvjoupSunDhgo4fPy4/P7/f9MA1AABw4xiGodzcXIWFhbk9YPRSBKJSOn78eIlvzwYAAFXD0aNHVa9evSuuJxCVUvGXFR49erTEo/EBAEDllJOTo/Dw8Gt+6TCBqJSKT5P5+/sTiAAAqGKudbkLF1UDAADLIxABAADLIxABAADLIxABAADLIxABAADLIxABAADLIxABAADLIxABAADLIxABAADLIxABAADLIxABAADLIxABAADLIxABAADLIxABAADLIxABAADLq+bpBiAt2XbkmjVx0fVvQCcAAFgTR4gAAIDlEYgAAIDlEYgAAIDlEYgAAIDlEYgAAIDlEYgAAIDlEYgAAIDlEYgAAIDlEYgAAIDlEYgAAIDlEYgAAIDlEYgAAIDlEYgAAIDlEYgAAIDlEYgAAIDlEYgAAIDlEYgAAIDlEYgAAIDlEYgAAIDlEYgAAIDlEYgAAIDlEYgAAIDlEYgAAIDlEYgAAIDlEYgAAIDlEYgAAIDlEYgAAIDleTQQzZ07Vy1btpS/v7/8/f0VExOjTz75xFxvGIYmTZqksLAw+fj4qHPnztq7d6/bHAUFBRozZoyCgoLk6+urvn376tixY2412dnZio+Pl8PhkMPhUHx8vE6fPn0jdhEAAFQBHg1E9erV00svvaQdO3Zox44duvfee9WvXz8z9EyfPl0zZ87U7NmztX37djmdTnXv3l25ubnmHImJiVq5cqWWLVumzZs3Ky8vT71791ZRUZFZExcXp/T0dKWkpCglJUXp6emKj4+/4fsLAAAqJ5thGIanm7hYQECAZsyYoUcffVRhYWFKTEzUU089JenXo0EhISGaNm2aRo4cKZfLpbp162rhwoUaMmSIJOn48eMKDw/X6tWr1aNHD+3bt0/NmzfX1q1bFR0dLUnaunWrYmJi9O2336pp06al6isnJ0cOh0Mul0v+/v4Vus9Lth25Zk1cdP0K3SYAAFZQ2t/fleYaoqKiIi1btkz5+fmKiYnRwYMHlZmZqdjYWLPGbrerU6dOSktLkyTt3LlT586dc6sJCwtTVFSUWbNlyxY5HA4zDElS+/bt5XA4zJrLKSgoUE5OjtsLAADcnDweiL7++mvVqlVLdrtdjz/+uFauXKnmzZsrMzNTkhQSEuJWHxISYq7LzMyUt7e36tSpc9Wa4ODgEtsNDg42ay4nOTnZvObI4XAoPDz8N+0nAACovDweiJo2bar09HRt3bpV//M//6OhQ4fqm2++MdfbbDa3esMwSoxd6tKay9Vfa56JEyfK5XKZr6NHj5Z2lwAAQBXj8UDk7e2txo0bq127dkpOTlarVq306quvyul0SlKJozhZWVnmUSOn06nCwkJlZ2dftebEiRMltnvy5MkSR58uZrfbzbvfil8AAODm5PFAdCnDMFRQUKCGDRvK6XQqNTXVXFdYWKiNGzeqQ4cOkqS2bduqevXqbjUZGRnas2ePWRMTEyOXy6UvvvjCrNm2bZtcLpdZAwAArK2aJzf+9NNPq1evXgoPD1dubq6WLVumDRs2KCUlRTabTYmJiZo6daqaNGmiJk2aaOrUqapZs6bi4uIkSQ6HQwkJCRo/frwCAwMVEBCgpKQktWjRQt26dZMkNWvWTD179tSIESM0b948SdJjjz2m3r17l/oOMwAAcHPzaCA6ceKE4uPjlZGRIYfDoZYtWyolJUXdu3eXJE2YMEFnz57VqFGjlJ2drejoaK1Zs0Z+fn7mHLNmzVK1atU0ePBgnT17Vl27dtWCBQvk5eVl1ixevFhPPvmkeTda3759NXv27Bu7swAAoNKqdM8hqqx4DhEAAFVPlXsOEQAAgKcQiAAAgOURiAAAgOURiAAAgOURiAAAgOURiAAAgOURiAAAgOURiAAAgOURiAAAgOURiAAAgOURiAAAgOURiAAAgOURiAAAgOURiAAAgOURiAAAgOURiAAAgOURiAAAgOURiAAAgOURiAAAgOURiAAAgOURiAAAgOURiAAAgOURiAAAgOURiAAAgOURiAAAgOURiAAAgOURiAAAgOURiAAAgOURiAAAgOURiAAAgOURiAAAgOURiAAAgOURiAAAgOURiAAAgOURiAAAgOURiAAAgOURiAAAgOURiAAAgOURiAAAgOURiAAAgOURiAAAgOURiAAAgOV5NBAlJyfrzjvvlJ+fn4KDg9W/f3/t37/frWbYsGGy2Wxur/bt27vVFBQUaMyYMQoKCpKvr6/69u2rY8eOudVkZ2crPj5eDodDDodD8fHxOn369PXeRQAAUAV4NBBt3LhRo0eP1tatW5Wamqrz588rNjZW+fn5bnU9e/ZURkaG+Vq9erXb+sTERK1cuVLLli3T5s2blZeXp969e6uoqMisiYuLU3p6ulJSUpSSkqL09HTFx8ffkP0EAACVWzVPbjwlJcVtef78+QoODtbOnTt1zz33mON2u11Op/Oyc7hcLr355ptauHChunXrJklatGiRwsPDtXbtWvXo0UP79u1TSkqKtm7dqujoaEnSG2+8oZiYGO3fv19Nmza9TnsIAACqgkp1DZHL5ZIkBQQEuI1v2LBBwcHBioyM1IgRI5SVlWWu27lzp86dO6fY2FhzLCwsTFFRUUpLS5MkbdmyRQ6HwwxDktS+fXs5HA6zBgAAWJdHjxBdzDAMjRs3TnfffbeioqLM8V69eunBBx9URESEDh48qP/7v//Tvffeq507d8putyszM1Pe3t6qU6eO23whISHKzMyUJGVmZio4OLjENoODg82aSxUUFKigoMBczsnJqYjdBAAAlVClCURPPPGEdu/erc2bN7uNDxkyxPxzVFSU2rVrp4iICK1atUoDBw684nyGYchms5nLF//5SjUXS05O1uTJk8u6GwAAoAqqFKfMxowZo48++kjr169XvXr1rlobGhqqiIgIHThwQJLkdDpVWFio7Oxst7qsrCyFhISYNSdOnCgx18mTJ82aS02cOFEul8t8HT16tDy7BgAAqgCPBiLDMPTEE09oxYoVWrdunRo2bHjN95w6dUpHjx5VaGioJKlt27aqXr26UlNTzZqMjAzt2bNHHTp0kCTFxMTI5XLpiy++MGu2bdsml8tl1lzKbrfL39/f7QUAAG5OHj1lNnr0aC1ZskQffvih/Pz8zOt5HA6HfHx8lJeXp0mTJmnQoEEKDQ3VoUOH9PTTTysoKEgDBgwwaxMSEjR+/HgFBgYqICBASUlJatGihXnXWbNmzdSzZ0+NGDFC8+bNkyQ99thj6t27N3eYAQAAzwaiuXPnSpI6d+7sNj5//nwNGzZMXl5e+vrrr/XOO+/o9OnTCg0NVZcuXbR8+XL5+fmZ9bNmzVK1atU0ePBgnT17Vl27dtWCBQvk5eVl1ixevFhPPvmkeTda3759NXv27Ou/kwAAoNKzGYZheLqJqiAnJ0cOh0Mul6vCT58t2XbkmjVx0fUrdJsAAFhBaX9/V4qLqgEAADyJQAQAACyPQAQAACyPQAQAACyPQAQAACyPQAQAACyPQAQAACyPQAQAACyPQAQAACyPQAQAACyPQAQAACyPQAQAACyPQAQAACyPQAQAACyPQAQAACyPQAQAACyPQAQAACyPQAQAACyPQAQAACyPQAQAACyPQAQAACyPQAQAACyPQAQAACyPQAQAACyPQAQAACyPQAQAACyPQAQAACyPQAQAACyPQAQAACyPQAQAACyPQAQAACyPQAQAACyPQAQAACyPQAQAACyPQAQAACyPQAQAACyPQAQAACyPQAQAACyPQAQAACyPQAQAACyPQAQAACyPQAQAACyvXIHo4MGDFd0HAACAx5QrEDVu3FhdunTRokWL9Msvv5R748nJybrzzjvl5+en4OBg9e/fX/v373erMQxDkyZNUlhYmHx8fNS5c2ft3bvXraagoEBjxoxRUFCQfH191bdvXx07dsytJjs7W/Hx8XI4HHI4HIqPj9fp06fL3TsAALh5lCsQffXVV7rjjjs0fvx4OZ1OjRw5Ul988UWZ59m4caNGjx6trVu3KjU1VefPn1dsbKzy8/PNmunTp2vmzJmaPXu2tm/fLqfTqe7duys3N9esSUxM1MqVK7Vs2TJt3rxZeXl56t27t4qKisyauLg4paenKyUlRSkpKUpPT1d8fHx5dh8AANxkbIZhGOV98/nz5/Xvf/9bCxYs0CeffKImTZooISFB8fHxqlu3bpnnO3nypIKDg7Vx40bdc889MgxDYWFhSkxM1FNPPSXp16NBISEhmjZtmkaOHCmXy6W6detq4cKFGjJkiCTp+PHjCg8P1+rVq9WjRw/t27dPzZs319atWxUdHS1J2rp1q2JiYvTtt9+qadOm1+wtJydHDodDLpdL/v7+Zd63q1my7cg1a+Ki61foNgEAsILS/v7+TRdVV6tWTQMGDNC7776radOm6fvvv1dSUpLq1aunhx9+WBkZGWWaz+VySZICAgIk/XqtUmZmpmJjY80au92uTp06KS0tTZK0c+dOnTt3zq0mLCxMUVFRZs2WLVvkcDjMMCRJ7du3l8PhMGsuVVBQoJycHLcXAAC4Of2mQLRjxw6NGjVKoaGhmjlzppKSkvT9999r3bp1+vHHH9WvX79Sz2UYhsaNG6e7775bUVFRkqTMzExJUkhIiFttSEiIuS4zM1Pe3t6qU6fOVWuCg4NLbDM4ONisuVRycrJ5vZHD4VB4eHip9wUAAFQt1crzppkzZ2r+/Pnav3+/7rvvPr3zzju67777dMstv+arhg0bat68ebrttttKPecTTzyh3bt3a/PmzSXW2Ww2t2XDMEqMXerSmsvVX22eiRMnaty4ceZyTk4OoQgAgJtUuQLR3Llz9eijj+qRRx6R0+m8bE39+vX15ptvlmq+MWPG6KOPPtKmTZtUr149c7x47szMTIWGhprjWVlZ5lEjp9OpwsJCZWdnux0lysrKUocOHcyaEydOlNjuyZMnSxx9Kma322W320vVPwAAqNrKdcrswIEDmjhx4hXDkCR5e3tr6NChV53HMAw98cQTWrFihdatW6eGDRu6rW/YsKGcTqdSU1PNscLCQm3cuNEMO23btlX16tXdajIyMrRnzx6zJiYmRi6Xy+1OuG3btsnlcpk1AADAusp1hGj+/PmqVauWHnzwQbfx9957T2fOnLlmECo2evRoLVmyRB9++KH8/PzM63kcDod8fHxks9mUmJioqVOnqkmTJmrSpImmTp2qmjVrKi4uzqxNSEjQ+PHjFRgYqICAACUlJalFixbq1q2bJKlZs2bq2bOnRowYoXnz5kmSHnvsMfXu3btUd5gBAICbW7mOEL300ksKCgoqMR4cHKypU6eWep65c+fK5XKpc+fOCg0NNV/Lly83ayZMmKDExESNGjVK7dq1048//qg1a9bIz8/PrJk1a5b69++vwYMH66677lLNmjX173//W15eXmbN4sWL1aJFC8XGxio2NlYtW7bUwoULy7P7AADgJlOu5xDVqFFD3377rRo0aOA2fujQITVr1kxnz56tqP4qDZ5DBABA1XNdn0MUHBys3bt3lxj/6quvFBgYWJ4pAQAAPKZcgeihhx7Sk08+qfXr16uoqEhFRUVat26dxo4dq4ceeqiiewQAALiuynVR9ZQpU3T48GF17dpV1ar9OsWFCxf08MMPl+kaIgAAgMqgXIHI29tby5cv1wsvvKCvvvpKPj4+atGihSIiIiq6PwAAgOuuXIGoWGRkpCIjIyuqFwAAAI8oVyAqKirSggUL9NlnnykrK0sXLlxwW79u3boKaQ4AAOBGKFcgGjt2rBYsWKD7779fUVFR1/xeMQAAgMqsXIFo2bJlevfdd3XfffdVdD8AAAA3XLluu/f29lbjxo0ruhcAAACPKFcgGj9+vF599VWV4yHXAAAAlU65Tplt3rxZ69ev1yeffKLbb79d1atXd1u/YsWKCmkOAADgRihXIKpdu7YGDBhQ0b0AAAB4RLkC0fz58yu6DwAAAI8p1zVEknT+/HmtXbtW8+bNU25uriTp+PHjysvLq7DmAAAAboRyHSE6fPiwevbsqSNHjqigoEDdu3eXn5+fpk+frl9++UWvvfZaRfcJAABw3ZTrCNHYsWPVrl07ZWdny8fHxxwfMGCAPvvsswprDgAA4EYo911m//nPf+Tt7e02HhERoR9//LFCGgMAALhRynWE6MKFCyoqKioxfuzYMfn5+f3mpgAAAG6kcgWi7t2765VXXjGXbTab8vLy9Nxzz/F1HgAAoMop1ymzWbNmqUuXLmrevLl++eUXxcXF6cCBAwoKCtLSpUsrukcAAIDrqlyBKCwsTOnp6Vq6dKl27dqlCxcuKCEhQX/84x/dLrIGAACoCsoViCTJx8dHjz76qB599NGK7AcAAOCGK1cgeuedd666/uGHHy5XMwAAAJ5QrkA0duxYt+Vz587pzJkz8vb2Vs2aNQlEAACgSinXXWbZ2dlur7y8PO3fv1933303F1UDAIAqp9zfZXapJk2a6KWXXipx9AgAAKCyq7BAJEleXl46fvx4RU4JAABw3ZXrGqKPPvrIbdkwDGVkZGj27Nm66667KqQxAACAG6Vcgah///5uyzabTXXr1tW9996rl19+uSL6AgAAuGHKFYguXLhQ0X0AAAB4TIVeQwQAAFAVlesI0bhx40pdO3PmzPJsAgAA4IYpVyD68ssvtWvXLp0/f15NmzaVJH333Xfy8vJSmzZtzDqbzVYxXQIAAFxH5QpEffr0kZ+fn95++23VqVNH0q8Pa3zkkUfUsWNHjR8/vkKbBAAAuJ7KdQ3Ryy+/rOTkZDMMSVKdOnU0ZcoU7jIDAABVTrkCUU5Ojk6cOFFiPCsrS7m5ub+5KQAAgBupXIFowIABeuSRR/T+++/r2LFjOnbsmN5//30lJCRo4MCBFd0jAADAdVWua4hee+01JSUl6U9/+pPOnTv360TVqikhIUEzZsyo0AYBAACut3IFopo1a2rOnDmaMWOGvv/+exmGocaNG8vX17ei+wMAALjuftODGTMyMpSRkaHIyEj5+vrKMIyK6gsAAOCGKVcgOnXqlLp27arIyEjdd999ysjIkCQNHz6cW+4BAECVU65A9Oc//1nVq1fXkSNHVLNmTXN8yJAhSklJqbDmAAAAboRyBaI1a9Zo2rRpqlevntt4kyZNdPjw4VLPs2nTJvXp00dhYWGy2Wz64IMP3NYPGzZMNpvN7dW+fXu3moKCAo0ZM0ZBQUHy9fVV3759dezYMbea7OxsxcfHy+FwyOFwKD4+XqdPny7TPgMAgJtXuQJRfn6+25GhYj/99JPsdnuZ5mnVqpVmz559xZqePXua1yplZGRo9erVbusTExO1cuVKLVu2TJs3b1ZeXp569+6toqIisyYuLk7p6elKSUlRSkqK0tPTFR8fX+o+AQDAza1cd5ndc889euedd/TCCy9I+vU7yy5cuKAZM2aoS5cupZ6nV69e6tWr11Vr7Ha7nE7nZde5XC69+eabWrhwobp16yZJWrRokcLDw7V27Vr16NFD+/btU0pKirZu3aro6GhJ0htvvKGYmBjt37/f/C42AABgXeUKRDNmzFDnzp21Y8cOFRYWasKECdq7d69+/vln/ec//6nQBjds2KDg4GDVrl1bnTp10osvvqjg4GBJ0s6dO3Xu3DnFxsaa9WFhYYqKilJaWpp69OihLVu2yOFwmGFIktq3by+Hw6G0tLQrBqKCggIVFBSYyzk5ORW6XwAAoPIo1ymz5s2ba/fu3fr973+v7t27Kz8/XwMHDtSXX36pRo0aVVhzvXr10uLFi7Vu3Tq9/PLL2r59u+69914zqGRmZsrb29vtO9UkKSQkRJmZmWZNcYC6WHBwsFlzOcnJyeY1Rw6HQ+Hh4RW2XwAAoHIp8xGi4iMy8+bN0+TJk69HT6YhQ4aYf46KilK7du0UERGhVatWXfUrQgzDkM1mM5cv/vOVai41ceJEjRs3zlzOyckhFAEAcJMq8xGi6tWra8+ePVcNE9dLaGioIiIidODAAUmS0+lUYWGhsrOz3eqysrIUEhJi1lzui2hPnjxp1lyO3W6Xv7+/2wsAANycynXK7OGHH9abb75Z0b1c06lTp3T06FGFhoZKktq2bavq1asrNTXVrMnIyNCePXvUoUMHSVJMTIxcLpe++OILs2bbtm1yuVxmDQAAsLZyXVRdWFiof/7zn0pNTVW7du1KfIfZzJkzSzVPXl6e/vvf/5rLBw8eVHp6ugICAhQQEKBJkyZp0KBBCg0N1aFDh/T0008rKChIAwYMkCQ5HA4lJCRo/PjxCgwMVEBAgJKSktSiRQvzrrNmzZqpZ8+eGjFihObNmydJeuyxx9S7d2/uMAMAAJLKGIh++OEHNWjQQHv27FGbNm0kSd99951bTVlOpe3YscPtNv3ia3aGDh2quXPn6uuvv9Y777yj06dPKzQ0VF26dNHy5cvl5+dnvmfWrFmqVq2aBg8erLNnz6pr165asGCBvLy8zJrFixfrySefNO9G69u371WffQQAAKzFZpThG1m9vLyUkZFh3rU1ZMgQ/e1vf7vqtTg3i5ycHDkcDrlcrgq/nmjJtiPXrImLrl+h2wQAwApK+/u7TNcQXZqdPvnkE+Xn55evQwAAgEqiXBdVFyvDwSUAAIBKq0yBqPgLVi8dAwAAqMrKdFG1YRgaNmyY+QWuv/zyix5//PESd5mtWLGi4joEAAC4zsoUiIYOHeq2/Kc//alCmwEAAPCEMgWi+fPnX68+AAAAPOY3XVQNAABwMyAQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAyyMQAQAAy/NoINq0aZP69OmjsLAw2Ww2ffDBB27rDcPQpEmTFBYWJh8fH3Xu3Fl79+51qykoKNCYMWMUFBQkX19f9e3bV8eOHXOryc7OVnx8vBwOhxwOh+Lj43X69OnrvHcAAKCq8Gggys/PV6tWrTR79uzLrp8+fbpmzpyp2bNna/v27XI6nerevbtyc3PNmsTERK1cuVLLli3T5s2blZeXp969e6uoqMisiYuLU3p6ulJSUpSSkqL09HTFx8df9/0DAABVg80wDMPTTUiSzWbTypUr1b9/f0m/Hh0KCwtTYmKinnrqKUm/Hg0KCQnRtGnTNHLkSLlcLtWtW1cLFy7UkCFDJEnHjx9XeHi4Vq9erR49emjfvn1q3ry5tm7dqujoaEnS1q1bFRMTo2+//VZNmzYtVX85OTlyOBxyuVzy9/ev0H1fsu3INWvioutX6DYBALCC0v7+rnYDeyqTgwcPKjMzU7GxseaY3W5Xp06dlJaWppEjR2rnzp06d+6cW01YWJiioqKUlpamHj16aMuWLXI4HGYYkqT27dvL4XAoLS3tioGooKBABQUF5nJOTs512MvSIzQBAHD9VNqLqjMzMyVJISEhbuMhISHmuszMTHl7e6tOnTpXrQkODi4xf3BwsFlzOcnJyeY1Rw6HQ+Hh4b9pfwAAQOVVaQNRMZvN5rZsGEaJsUtdWnO5+mvNM3HiRLlcLvN19OjRMnYOAACqikobiJxOpySVOIqTlZVlHjVyOp0qLCxUdnb2VWtOnDhRYv6TJ0+WOPp0MbvdLn9/f7cXAAC4OVXaQNSwYUM5nU6lpqaaY4WFhdq4caM6dOggSWrbtq2qV6/uVpORkaE9e/aYNTExMXK5XPriiy/Mmm3btsnlcpk1AADA2jx6UXVeXp7++9//mssHDx5Uenq6AgICVL9+fSUmJmrq1Klq0qSJmjRpoqlTp6pmzZqKi4uTJDkcDiUkJGj8+PEKDAxUQECAkpKS1KJFC3Xr1k2S1KxZM/Xs2VMjRozQvHnzJEmPPfaYevfuXeo7zAAAwM3No4Fox44d6tKli7k8btw4SdLQoUO1YMECTZgwQWfPntWoUaOUnZ2t6OhorVmzRn5+fuZ7Zs2apWrVqmnw4ME6e/asunbtqgULFsjLy8usWbx4sZ588knzbrS+ffte8dlHAADAeirNc4gqO08/h6g0uO0eAAB3pf39XWmvIQIAALhRCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyCEQAAMDyqnm6AVScJduOXLMmLrr+DegEAICqhSNEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ghEAADA8ip1IJo0aZJsNpvby+l0musNw9CkSZMUFhYmHx8fde7cWXv37nWbo6CgQGPGjFFQUJB8fX3Vt29fHTt27EbvCgAAqMQqdSCSpNtvv10ZGRnm6+uvvzbXTZ8+XTNnztTs2bO1fft2OZ1Ode/eXbm5uWZNYmKiVq5cqWXLlmnz5s3Ky8tT7969VVRU5IndAQAAlVA1TzdwLdWqVXM7KlTMMAy98soreuaZZzRw4EBJ0ttvv62QkBAtWbJEI0eOlMvl0ptvvqmFCxeqW7dukqRFixYpPDxca9euVY8ePW7ovgAAgMqp0geiAwcOKCwsTHa7XdHR0Zo6dapuvfVWHTx4UJmZmYqNjTVr7Xa7OnXqpLS0NI0cOVI7d+7UuXPn3GrCwsIUFRWltLQ0SwaiJduOXLMmLrr+DegEAIDKo1IHoujoaL3zzjuKjIzUiRMnNGXKFHXo0EF79+5VZmamJCkkJMTtPSEhITp8+LAkKTMzU97e3qpTp06JmuL3X0lBQYEKCgrM5ZycnIrYJQAAUAlV6kDUq1cv888tWrRQTEyMGjVqpLffflvt27eXJNlsNrf3GIZRYuxSpalJTk7W5MmTy9k5AACoSir9RdUX8/X1VYsWLXTgwAHzuqJLj/RkZWWZR42cTqcKCwuVnZ19xZormThxolwul/k6evRoBe4JAACoTKpUICooKNC+ffsUGhqqhg0byul0KjU11VxfWFiojRs3qkOHDpKktm3bqnr16m41GRkZ2rNnj1lzJXa7Xf7+/m4vAABwc6rUp8ySkpLUp08f1a9fX1lZWZoyZYpycnI0dOhQ2Ww2JSYmaurUqWrSpImaNGmiqVOnqmbNmoqLi5MkORwOJSQkaPz48QoMDFRAQICSkpLUokUL864zAACASh2Ijh07pj/84Q/66aefVLduXbVv315bt25VRESEJGnChAk6e/asRo0apezsbEVHR2vNmjXy8/Mz55g1a5aqVaumwYMH6+zZs+ratasWLFggLy8vT+0WAACoZGyGYRiebqIqyMnJkcPhkMvlqvDTZ6W5Ff5G4rZ7AMDNorS/v6vUNUQAAADXA4EIAABYHoEIAABYHoEIAABYHoEIAABYHoEIAABYHoEIAABYHoEIAABYHoEIAABYXqX+6g54RmmenM3TrAEANxOOEAEAAMsjEAEAAMsjEAEAAMsjEAEAAMsjEAEAAMsjEAEAAMsjEAEAAMsjEAEAAMvjwYwoFx7eCAC4mXCECAAAWB6BCAAAWB6BCAAAWB6BCAAAWB6BCAAAWB6BCAAAWB6BCAAAWB6BCAAAWB6BCAAAWB6BCAAAWB5f3YHrhq/3AABUFQQiVHoEKwDA9UYggkeVJuwAAHC9cQ0RAACwPAIRAACwPAIRAACwPAIRAACwPC6qxk2htBdnczcaAOByCESwFG7hBwBcDqfMAACA5RGIAACA5XHKDLgJcCoQAH4bAhFwCcLFjcHPGUBlYqlANGfOHM2YMUMZGRm6/fbb9corr6hjx46ebgs3qYr6WhJCAQBcf5YJRMuXL1diYqLmzJmju+66S/PmzVOvXr30zTffqH59fuEApcWRHQA3I8sEopkzZyohIUHDhw+XJL3yyiv69NNPNXfuXCUnJ3u4O+DKKupIE0EGAK7MEoGosLBQO3fu1F/+8he38djYWKWlpXmoK1RlFRVSKpsbGb5uVgRPoGqyRCD66aefVFRUpJCQELfxkJAQZWZmXvY9BQUFKigoMJddLpckKScnp8L7O5OfW+FzAjeDf67be8O2NbhdeIXMU5q/z6XZr4rqpzTe3XH0mjU3sh+gIhX/3jYM46p1lghExWw2m9uyYRglxoolJydr8uTJJcbDw/mfAnAzGuHpBi5BP0DFys3NlcPhuOJ6SwSioKAgeXl5lTgalJWVVeKoUbGJEydq3Lhx5vKFCxf0888/KzAw8IohqjxycnIUHh6uo0ePyt/fv8LmRdnwOVQOfA6VA59D5cDnUDEMw1Bubq7CwsKuWmeJQOTt7a22bdsqNTVVAwYMMMdTU1PVr1+/y77HbrfLbre7jdWuXfu69ejv789/8JUAn0PlwOdQOfA5VA58Dr/d1Y4MFbNEIJKkcePGKT4+Xu3atVNMTIxef/11HTlyRI8//rinWwMAAB5mmUA0ZMgQnTp1Ss8//7wyMjIUFRWl1atXKyIiwtOtAQAAD7NMIJKkUaNGadSoUZ5uw43dbtdzzz1X4vQcbiw+h8qBz6Fy4HOoHPgcbiybca370AAAAG5yt3i6AQAAAE8jEAEAAMsjEAEAAMsjEAEAAMsjEHnYnDlz1LBhQ9WoUUNt27bV559/7umWLGXTpk3q06ePwsLCZLPZ9MEHH3i6JUtKTk7WnXfeKT8/PwUHB6t///7av3+/p9uynLlz56ply5bmgwBjYmL0ySefeLoty0tOTpbNZlNiYqKnW7mpEYg8aPny5UpMTNQzzzyjL7/8Uh07dlSvXr105Ih1vyn8RsvPz1erVq00e/ZsT7diaRs3btTo0aO1detWpaam6vz584qNjVV+fr6nW7OUevXq6aWXXtKOHTu0Y8cO3XvvverXr5/27r1xX7ILd9u3b9frr7+uli1berqVmx633XtQdHS02rRpo7lz55pjzZo1U//+/ZWcnOzBzqzJZrNp5cqV6t+/v6dbsbyTJ08qODhYGzdu1D333OPpdiwtICBAM2bMUEJCgqdbsZy8vDy1adNGc+bM0ZQpU9S6dWu98sornm7rpsURIg8pLCzUzp07FRsb6zYeGxurtLQ0D3UFVA4ul0vSr7+M4RlFRUVatmyZ8vPzFRMT4+l2LGn06NG6//771a1bN0+3YgmWelJ1ZfLTTz+pqKhIISEhbuMhISHKzMz0UFeA5xmGoXHjxunuu+9WVFSUp9uxnK+//loxMTH65ZdfVKtWLa1cuVLNmzf3dFuWs2zZMu3atUvbt2/3dCuWQSDyMJvN5rZsGEaJMcBKnnjiCe3evVubN2/2dCuW1LRpU6Wnp+v06dP617/+paFDh2rjxo2Eohvo6NGjGjt2rNasWaMaNWp4uh3LIBB5SFBQkLy8vEocDcrKyipx1AiwijFjxuijjz7Spk2bVK9ePU+3Y0ne3t5q3LixJKldu3bavn27Xn31Vc2bN8/DnVnHzp07lZWVpbZt25pjRUVF2rRpk2bPnq2CggJ5eXl5sMObE9cQeYi3t7fatm2r1NRUt/HU1FR16NDBQ10BnmEYhp544gmtWLFC69atU8OGDT3dEv4/hmGooKDA021YSteuXfX1118rPT3dfLVr105//OMflZ6eThi6TjhC5EHjxo1TfHy82rVrp5iYGL3++us6cuSIHn/8cU+3Zhl5eXn673//ay4fPHhQ6enpCggIUP369T3YmbWMHj1aS5Ys0Ycffig/Pz/zyKnD4ZCPj4+Hu7OOp59+Wr169VJ4eLhyc3O1bNkybdiwQSkpKZ5uzVL8/PxKXD/n6+urwMBArqu7jghEHjRkyBCdOnVKzz//vDIyMhQVFaXVq1crIiLC061Zxo4dO9SlSxdzedy4cZKkoUOHasGCBR7qynqKHz3RuXNnt/H58+dr2LBhN74hizpx4oTi4+OVkZEhh8Ohli1bKiUlRd27d/d0a8B1x3OIAACA5XENEQAAsDwCEQAAsDwCEQAAsDwCEQAAsDwCEQAAsDwCEQAAsDwCEQAAsDwCEQBLW7BggWrXru3pNgDL2rRpk/r06aOwsDDZbDZ98MEHZZ7j008/Vfv27eXn56e6detq0KBBOnjwYJnmIBABqBKGDRsmm81mvgIDA9WzZ0/t3r3b062VcOjQIdlsNqWnp3u6FaDSy8/PV6tWrTR79uxyvf+HH35Qv379dO+99yo9PV2ffvqpfvrpJw0cOLBM8xCIAFQZPXv2VEZGhjIyMvTZZ5+pWrVq6t27t6fbAvAb9OrVS1OmTLligCksLNSECRP0u9/9Tr6+voqOjtaGDRvM9bt27VJRUZGmTJmiRo0aqU2bNkpKStJXX32lc+fOlboPAhGAKsNut8vpdMrpdKp169Z66qmndPToUZ08eVIbNmyQzWbT6dOnzfr09HTZbDYdOnTIHFuwYIHq16+vmjVrasCAATp16lSJ7UyZMkXBwcHy8/PT8OHD9Ze//EWtW7d2q5k/f76aNWumGjVq6LbbbtOcOXPMdQ0bNpQk3XHHHbLZbCW+ow1A6T3yyCP6z3/+o2XLlmn37t168MEH1bNnTx04cECS1K5dO3l5eWn+/PkqKiqSy+XSwoULFRsbq+rVq5d6OwQiAFVSXl6eFi9erMaNGyswMLBU79m2bZseffRRjRo1Sunp6erSpYumTJniVrN48WK9+OKLmjZtmnbu3Kn69eubXz5b7I033tAzzzyjF198Ufv27dPUqVP1f//3f3r77bclSV988YUkae3atcrIyNCKFSsqYI8B6/n++++1dOlSvffee+rYsaMaNWqkpKQk3X333Zo/f74kqUGDBlqzZo2efvpp2e121a5dW8eOHdOyZcvKtC2+7R5AlfHxxx+rVq1akn697iA0NFQff/yxbrmldP+2e/XVV9WjRw/95S9/kSRFRkYqLS1NKSkpZs3f//53JSQk6JFHHpEkPfvss1qzZo3y8vLMmhdeeEEvv/yyeYi/YcOG+uabbzRv3jwNHTpUdevWlSQFBgbK6XT+9h0HLGrXrl0yDEORkZFu4wUFBeY/hDIzMzV8+HANHTpUf/jDH5Sbm6tnn31WDzzwgFJTU2Wz2Uq1LQIRgCqjS5cu5tGan3/+WXPmzFGvXr3MIzLXsm/fPg0YMMBtLCYmxi0Q7d+/X6NGjXKr+f3vf69169ZJkk6ePKmjR48qISFBI0aMMGvOnz8vh8NRrv0CcHkXLlyQl5eXdu7cKS8vL7d1xf84+sc//iF/f39Nnz7dXLdo0SKFh4dr27Ztat++fam2RSACUGX4+vqqcePG5nLbtm3lcDj0xhtvKDY2VpJkGIa5/tILKi9edzWX/ovy4vdduHBB0q+nzaKjo93qLv0fNoDf5o477lBRUZGysrLUsWPHy9acOXOmxN+94uXiv6+lwTVEAKosm82mW265RWfPnjVPU2VkZJjrL73tvXnz5tq6davb2KXLTZs2LXHEaceOHeafQ0JC9Lvf/U4//PCDGjdu7PYqvpja29tbklRUVPTbdhCwgLy8PKWnp5t/Xw8ePKj09HQdOXJEkZGR+uMf/6iHH35YK1as0MGDB7V9+3ZNmzZNq1evliTdf//92r59u55//nkdOHBAu3bt0iOPPKKIiAjdcccdpW/EAIAqYOjQoUbPnj2NjIwMIyMjw/jmm2+MUaNGGTabzVi/fr1RWFhohIeHGw8++KCxf/9+4+OPPzaaNm1qSDIOHjxoGIZhbNmyxbDZbMa0adOM/fv3G3//+9+N2rVrGw6Hw9zOokWLDB8fH2PBggXGd999Z7zwwguGv7+/0bp1a7PmjTfeMHx8fIxXXnnF2L9/v7F7927jrbfeMl5++WXDMAzj3Llzho+PjzFlyhQjMzPTOH369I38UQFVyvr16w1JJV5Dhw41DMMwCgsLjWeffdZo0KCBUb16dcPpdBoDBgwwdu/ebc6xdOlS44477jB8fX2NunXrGn379jX27dtXpj4IRACqhKFDh7r9z9LPz8+48847jffff9+s2bx5s9GiRQujRo0aRseOHY333nvPLRAZhmG8+eabRr169QwfHx+jT58+xl//+le3QGQYhvH8888bQUFBRq1atYxHH33UePLJJ4327du71SxevNho3bq14e3tbdSpU8e45557jBUrVpjr33jjDSM8PNy45ZZbjE6dOl2PHwmACmQzjFKeVAcAi+revbucTqcWLlzo6VYAXCdcVA0AFzlz5oxee+019ejRQ15eXlq6dKnWrl2r1NRUT7cG4DriCBEAXOTs2bPq06ePdu3apYKCAjVt2lT/+7//W+bvRQJQtRCIAACA5XHbPQAAsDwCEQAAsDwCEQAAsDwCEQAAsDwCEQAAsDwCEQAAsDwCEQAAsDwCEQAAsDwCEQAAsLz/BzIdaK1G1eZbAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#plot the distribution of the budget in the training set\n",
    "sns.distplot(train['original_budget'], kde=False)\n",
    "plt.title('Distribution of budget')\n",
    "plt.xlabel('Budget')\n",
    "plt.ylabel('Frequency')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\zjy\\AppData\\Local\\Temp\\ipykernel_11340\\668996526.py:2: UserWarning: \n",
      "\n",
      "`distplot` is a deprecated function and will be removed in seaborn v0.14.0.\n",
      "\n",
      "Please adapt your code to use either `displot` (a figure-level function with\n",
      "similar flexibility) or `histplot` (an axes-level function for histograms).\n",
      "\n",
      "For a guide to updating your code to use the new functions, please see\n",
      "https://gist.github.com/mwaskom/de44147ed2974457ad6372750bbe5751\n",
      "\n",
      "  sns.distplot(train['log_revenue'], kde=False)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot the distribution of the log of the revenue in the training set\n",
    "sns.distplot(train['log_revenue'], kde=False)\n",
    "plt.title('Distribution of log of revenue')\n",
    "plt.xlabel('Log of revenue')\n",
    "plt.ylabel('Frequency')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\zjy\\AppData\\Local\\Temp\\ipykernel_11340\\3171513416.py:2: UserWarning: \n",
      "\n",
      "`distplot` is a deprecated function and will be removed in seaborn v0.14.0.\n",
      "\n",
      "Please adapt your code to use either `displot` (a figure-level function with\n",
      "similar flexibility) or `histplot` (an axes-level function for histograms).\n",
      "\n",
      "For a guide to updating your code to use the new functions, please see\n",
      "https://gist.github.com/mwaskom/de44147ed2974457ad6372750bbe5751\n",
      "\n",
      "  sns.distplot(train['log_budget'], kde=False)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot the distribution of the log of the budget in the training set\n",
    "sns.distplot(train['log_budget'], kde=False)\n",
    "plt.title('Distribution of log of budget')\n",
    "plt.xlabel('Log of budget')\n",
    "plt.ylabel('Frequency')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By observing the plots above, we will divide the data into two parts: error and non-error and label them as 1 and 0 respectively. We will use these labels to train the error detection model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "#store all the data that is zero in budget or revenue in a new dataframe called error\n",
    "#store all the data that is not zero in budget or revenue in a new dataframe called non_error_train\n",
    "error_train = train[(train['revenue'] == 0) | (train['original_budget'] == 0)]\n",
    "non_error_train = train[(train['original_budget'] != 0) & (train['revenue'] != 0)]\n",
    "\n",
    "#move all the data whose log_budegt is less than 10 in non-error to the error dataframe\n",
    "temp = non_error_train[non_error_train['log_budget'] < 8]\n",
    "error_train = error_train._append(temp, ignore_index=True)\n",
    "non_error_train = non_error_train[non_error_train['log_budget'] >= 8]\n",
    "\n",
    "#move all the data whose log_revenue is less than 7.5 in non-error to the error dataframe\n",
    "temp = non_error_train[non_error_train['log_revenue'] < 7.5]\n",
    "error_train = error_train._append(temp, ignore_index=True)\n",
    "non_error_train = non_error_train[non_error_train['log_revenue'] >= 7.5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These plots shows the distribution of the errors and non-errors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#plot the distribution of the log_budegt against the log_revenue in the error set\n",
    "sns.scatterplot(x='log_budget', y='log_revenue', data=error_train)\n",
    "plt.title('Log_budget vs Log_revenue')\n",
    "plt.xlabel('Log_budget')\n",
    "plt.ylabel('Log_revenue')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#plot the distribution of the log_budegt against the log_revenue in the non-error set\n",
    "sns.scatterplot(x='log_budget', y='log_revenue', data=non_error_train)\n",
    "plt.title('Log_budget vs Log_revenue')\n",
    "plt.xlabel('Log_budget')\n",
    "plt.ylabel('Log_revenue')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see than the log_budget and log_revenue has strong correlation in the non-errors and have weaker correlations in the errors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "#label the error set as 1 and the non-error set as 0\n",
    "error_train['error'] = 1\n",
    "non_error_train['error'] = 0\n",
    "#combine the error and non-error set\n",
    "train_labeled = error_train._append(non_error_train, ignore_index=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# split the training set into training and validation set, with a evenly distributed error and non-error set\n",
    "train_labeled, val_labeled = train_test_split(train_labeled, test_size=0.2, random_state=42, stratify=train_labeled['error'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2. training\n",
    "\n",
    "In this part, we will train the classifer by the trainning dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n",
      "1.0\n",
      "1.0\n",
      "1.0\n"
     ]
    }
   ],
   "source": [
    "# feature_classification selection\n",
    "feature_classification = [ 'original_budget', 'budget_processed', 'genre_rank',\n",
    "                            'inflationBudget', 'popularity_year_ratio']\n",
    "# target\n",
    "target = 'error'\n",
    "\n",
    "# split the feature_classification and target in the training set\n",
    "X_train = train_labeled[feature_classification]\n",
    "y_train = train_labeled[target]\n",
    "# split the feature_classification and target in the validation set\n",
    "X_val = val_labeled[feature_classification]\n",
    "y_val = val_labeled[target]\n",
    "\n",
    "# create a lgb dataset for training\n",
    "train_data = lgb.Dataset(X_train, label=y_train)\n",
    "# create a lgb dataset for validation\n",
    "val_data = lgb.Dataset(X_val, label=y_val)\n",
    "\n",
    "# set the parameters for the lgb model\n",
    "param = {'num_leaves': 30,\n",
    "          'objective': 'binary',\n",
    "          'metric': 'auc',\n",
    "          'max_depth': 5,\n",
    "          'learning_rate': 0.1,\n",
    "          'feature_fraction': 0.9,\n",
    "          'min_data_in_leaf': 5,\n",
    "          'bagging_fraction': 0.9,\n",
    "          'bagging_freq': 1,\n",
    "          'lambda_l1': 1,\n",
    "          'lambda_l2': 1,\n",
    "          'verbose': -1}\n",
    "# train the lgb model\n",
    "lgb_error_detection = lgb.train(param, train_data, valid_sets=[val_data])\n",
    "\n",
    "# predict the validation set\n",
    "y_pred = lgb_error_detection.predict(X_val, num_iteration=lgb_error_detection.best_iteration)\n",
    "# convert the prediction to binary\n",
    "for i in range(len(y_pred)):\n",
    "    if y_pred[i] >= 0.5:\n",
    "        y_pred[i] = 1\n",
    "    else:\n",
    "        y_pred[i] = 0\n",
    "\n",
    "# calculate the accuracy, precision, recall and f1 score\n",
    "accuracy = sum(y_pred == y_val) / len(y_val)\n",
    "print(accuracy)\n",
    "precision = sum((y_pred == 1) & (y_val == 1)) / sum(y_pred == 1)\n",
    "print(precision)\n",
    "recall = sum((y_pred == 1) & (y_val == 1)) / sum(y_val == 1)\n",
    "print(recall)\n",
    "f1 = 2 * precision * recall / (precision + recall)\n",
    "print(f1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3. save the model\n",
    "\n",
    "In this part, we will save the model in case furtuer usage."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<lightgbm.basic.Booster at 0x1c6a8aade90>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# save the model\n",
    "lgb_error_detection.save_model('model/lgb_error_detection.pkl')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4. prediction\n",
    "\n",
    "In this part, we will use the classifier to identify the errors in the test dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# predict the test set\n",
    "y_pred = lgb_error_detection.predict(test[feature_classification], num_iteration=lgb_error_detection.best_iteration)\n",
    "# convert the prediction to binary\n",
    "for i in range(len(y_pred)):\n",
    "    if y_pred[i] >= 0.5:\n",
    "        y_pred[i] = 1\n",
    "    else:\n",
    "        y_pred[i] = 0\n",
    "test['error'] = y_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# predict the error set using the error detection model\n",
    "y_pred = lgb_error_detection.predict(error_train[feature_classification], num_iteration=lgb_error_detection.best_iteration)\n",
    "# convert the prediction to binary\n",
    "for i in range(len(y_pred)):\n",
    "    if y_pred[i] >= 0.5:\n",
    "        y_pred[i] = 1\n",
    "    else:\n",
    "        y_pred[i] = 0\n",
    "error_train['error'] = y_pred\n",
    "\n",
    "# split the test set into error and non-error set\n",
    "error_test = test[test['error'] == 1]\n",
    "non_error_test = test[test['error'] == 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1245, 93)\n",
      "(3153, 93)\n"
     ]
    }
   ],
   "source": [
    "print(error_test.shape)\n",
    "print(non_error_test.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Models for revenue prediction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this part, we will use 3 models: lightgbm, xgboost, and catboost. Then we will use the average of the predictions of these models as our final prediction."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use Five-Fold Cross Validation to Evaluate the Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# split the training set into training and validation set, use Five-Fold Cross Validation\n",
    "kf = KFold(n_splits=5, shuffle=True, random_state=42)\n",
    "\n",
    "# we will use log_revenue as the target\n",
    "target = 'log_revenue'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1. Model for error-free data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.3814759809073343\n",
      "1.242805858398665\n",
      "1.1873563793214856\n",
      "1.279023591575888\n",
      "1.1674559795545394\n"
     ]
    }
   ],
   "source": [
    "# lightgbm\n",
    "# set the parameters for the lgb model\n",
    "param = {'num_leaves': 500,\n",
    "          'objective': 'regression',\n",
    "          'metric': 'rmse',\n",
    "          'max_depth': 12,\n",
    "          'learning_rate': 0.1,\n",
    "          'feature_fraction': 0.9,\n",
    "          'min_data_in_leaf': 5,\n",
    "          'bagging_fraction': 0.9,\n",
    "          'bagging_freq': 1,\n",
    "          'lambda_l1': 0.2,\n",
    "          'lambda_l2': 1,\n",
    "          'verbose': -1}\n",
    "# train the lgb model\n",
    "lgb_model_non_error = []\n",
    "lgb_prediction = []\n",
    "for train_index, val_index in kf.split(non_error_train):\n",
    "    X_train, X_val = non_error_train.iloc[train_index][feature_regression], non_error_train.iloc[val_index][feature_regression]\n",
    "    y_train, y_val = non_error_train.iloc[train_index][target], non_error_train.iloc[val_index][target]\n",
    "    train_data = lgb.Dataset(X_train, label=y_train)\n",
    "    val_data = lgb.Dataset(X_val, label=y_val)\n",
    "    lgb_model = lgb.train(param, train_data, valid_sets=[val_data])\n",
    "    lgb_model_non_error.append(lgb_model)\n",
    "    # evaluate the model\n",
    "    y_pred = lgb_model.predict(X_val, num_iteration=lgb_model.best_iteration)\n",
    "    lgb_prediction.append(y_pred)\n",
    "    # calculate the loss\n",
    "    loss = np.sqrt(sum((y_pred - y_val) ** 2) / len(y_val))\n",
    "    print(loss)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[15:40:43] WARNING: D:\\bld\\xgboost-split_1700181111005\\work\\src\\learner.cc:767: \n",
      "Parameters: { \"verbose\" } are not used.\n",
      "\n",
      "[0]\tvalidation-rmse:16.10997\n",
      "[1]\tvalidation-rmse:15.54852\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2]\tvalidation-rmse:15.00642\n",
      "[3]\tvalidation-rmse:14.48443\n",
      "[4]\tvalidation-rmse:13.97957\n",
      "[5]\tvalidation-rmse:13.49243\n",
      "[6]\tvalidation-rmse:13.02224\n",
      "[7]\tvalidation-rmse:12.56951\n",
      "[8]\tvalidation-rmse:12.13368\n",
      "[9]\tvalidation-rmse:11.71363\n",
      "11.713629408790844\n",
      "[15:40:44] WARNING: D:\\bld\\xgboost-split_1700181111005\\work\\src\\learner.cc:767: \n",
      "Parameters: { \"verbose\" } are not used.\n",
      "\n",
      "[0]\tvalidation-rmse:16.19525\n",
      "[1]\tvalidation-rmse:15.63177\n",
      "[2]\tvalidation-rmse:15.08962\n",
      "[3]\tvalidation-rmse:14.56637\n",
      "[4]\tvalidation-rmse:14.06207\n",
      "[5]\tvalidation-rmse:13.57453\n",
      "[6]\tvalidation-rmse:13.10497\n",
      "[7]\tvalidation-rmse:12.65140\n",
      "[8]\tvalidation-rmse:12.21573\n",
      "[9]\tvalidation-rmse:11.79349\n",
      "11.793490852093388\n",
      "[15:40:44] WARNING: D:\\bld\\xgboost-split_1700181111005\\work\\src\\learner.cc:767: \n",
      "Parameters: { \"verbose\" } are not used.\n",
      "\n",
      "[0]\tvalidation-rmse:16.27389\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1]\tvalidation-rmse:15.71194\n",
      "[2]\tvalidation-rmse:15.17071\n",
      "[3]\tvalidation-rmse:14.64876\n",
      "[4]\tvalidation-rmse:14.14485\n",
      "[5]\tvalidation-rmse:13.65720\n",
      "[6]\tvalidation-rmse:13.18872\n",
      "[7]\tvalidation-rmse:12.73584\n",
      "[8]\tvalidation-rmse:12.29877\n",
      "[9]\tvalidation-rmse:11.87677\n",
      "11.876771715423239\n",
      "[15:40:44] WARNING: D:\\bld\\xgboost-split_1700181111005\\work\\src\\learner.cc:767: \n",
      "Parameters: { \"verbose\" } are not used.\n",
      "\n",
      "[0]\tvalidation-rmse:16.23239\n",
      "[1]\tvalidation-rmse:15.67060\n",
      "[2]\tvalidation-rmse:15.12920\n",
      "[3]\tvalidation-rmse:14.60582\n",
      "[4]\tvalidation-rmse:14.10174\n",
      "[5]\tvalidation-rmse:13.61580\n",
      "[6]\tvalidation-rmse:13.14694\n",
      "[7]\tvalidation-rmse:12.69259\n",
      "[8]\tvalidation-rmse:12.25705\n",
      "[9]\tvalidation-rmse:11.83535\n",
      "11.835351641529346\n",
      "[15:40:44] WARNING: D:\\bld\\xgboost-split_1700181111005\\work\\src\\learner.cc:767: \n",
      "Parameters: { \"verbose\" } are not used.\n",
      "\n",
      "[0]\tvalidation-rmse:16.39811\n",
      "[1]\tvalidation-rmse:15.83362\n",
      "[2]\tvalidation-rmse:15.28935\n",
      "[3]\tvalidation-rmse:14.76323\n",
      "[4]\tvalidation-rmse:14.25739\n",
      "[5]\tvalidation-rmse:13.76780\n",
      "[6]\tvalidation-rmse:13.29524\n",
      "[7]\tvalidation-rmse:12.84070\n",
      "[8]\tvalidation-rmse:12.40214\n",
      "[9]\tvalidation-rmse:11.97815\n",
      "11.978154252625838\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n"
     ]
    }
   ],
   "source": [
    "# xgboost\n",
    "# set the parameters for the xgb model\n",
    "param = {'objective': 'reg:squarederror', \n",
    "              'eta': 0.035, \n",
    "              'max_depth': 17, \n",
    "              'subsample': 0.6, \n",
    "              'colsample_bytree': 0.7,  \n",
    "              'eval_metric': 'rmse', \n",
    "              'verbose': False\n",
    "}\n",
    "# train the xgb model\n",
    "xgb_model_non_error = []\n",
    "xgb_prediction = []\n",
    "for train_index, val_index in kf.split(non_error_train):\n",
    "    X_train, X_val = non_error_train.iloc[train_index][feature_regression], non_error_train.iloc[val_index][feature_regression]\n",
    "    y_train, y_val = non_error_train.iloc[train_index][target], non_error_train.iloc[val_index][target]\n",
    "    train_data = xgb.DMatrix(X_train, label=y_train)\n",
    "    val_data = xgb.DMatrix(X_val, label=y_val)\n",
    "    xgb_model = xgb.train(param, train_data, evals=[(val_data, 'validation')])\n",
    "    xgb_model_non_error.append(xgb_model)\n",
    "    # evaluate the model\n",
    "    y_pred = xgb_model.predict(val_data)\n",
    "    xgb_prediction.append(y_pred)\n",
    "    # calculate the loss\n",
    "    loss = np.sqrt(sum((y_pred - y_val) ** 2) / len(y_val))\n",
    "    print(loss)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.3667887500756426\n",
      "1.2075177081488002\n",
      "1.1822322419863094\n",
      "1.2734291924148988\n",
      "1.1303058986884154\n"
     ]
    }
   ],
   "source": [
    "# catboost\n",
    "# set the parameters for the cat model\n",
    "param = {'iterations' : 2000,\n",
    "        'learning_rate':0.07,\n",
    "        'depth':12,\n",
    "        'eval_metric':'RMSE',\n",
    "        'colsample_bylevel':0.8,\n",
    "        'bagging_temperature' : 0.4,\n",
    "        'metric_period' : None,\n",
    "        'early_stopping_rounds':200,\n",
    "        'verbose': False\n",
    "}\n",
    "# train the cat model\n",
    "cat_model_non_error = []\n",
    "cat_prediction = []\n",
    "for train_index, val_index in kf.split(non_error_train):\n",
    "    X_train, X_val = non_error_train.iloc[train_index][feature_regression], non_error_train.iloc[val_index][feature_regression]\n",
    "    y_train, y_val = non_error_train.iloc[train_index][target], non_error_train.iloc[val_index][target]\n",
    "    train_data = cat.Pool(X_train, label=y_train)\n",
    "    val_data = cat.Pool(X_val, label=y_val)\n",
    "    cat_model = cat.CatBoostRegressor(**param)\n",
    "    cat_model.fit(train_data, eval_set=val_data)\n",
    "    cat_model_non_error.append(cat_model)\n",
    "    # evaluate the model\n",
    "    y_pred = cat_model.predict(val_data)\n",
    "    cat_prediction.append(y_pred)\n",
    "    # calculate the loss\n",
    "    loss = np.sqrt(sum((y_pred - y_val) ** 2) / len(y_val))\n",
    "    print(loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# predict function\n",
    "def prediction(model, data):\n",
    "    pred = []\n",
    "    for i in range(len(model)):\n",
    "        pred.append(model[i].predict(data))\n",
    "    pred = np.array(pred)\n",
    "    pred = np.mean(pred, axis=0)\n",
    "    return pred"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To combine these 3 types of models, we use linear regression to find the best weight."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<style>#sk-container-id-1 {color: black;}#sk-container-id-1 pre{padding: 0;}#sk-container-id-1 div.sk-toggleable {background-color: white;}#sk-container-id-1 label.sk-toggleable__label {cursor: pointer;display: block;width: 100%;margin-bottom: 0;padding: 0.3em;box-sizing: border-box;text-align: center;}#sk-container-id-1 label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-1 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-1 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-1 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-1 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-1 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-1 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-container-id-1 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 input.sk-hidden--visually {border: 0;clip: rect(1px 1px 1px 1px);clip: rect(1px, 1px, 1px, 1px);height: 1px;margin: -1px;overflow: hidden;padding: 0;position: absolute;width: 1px;}#sk-container-id-1 div.sk-estimator {font-family: monospace;background-color: #f0f8ff;border: 1px dotted black;border-radius: 0.25em;box-sizing: border-box;margin-bottom: 0.5em;}#sk-container-id-1 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-1 div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-1 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-serial::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: 0;}#sk-container-id-1 div.sk-serial {display: flex;flex-direction: column;align-items: center;background-color: white;padding-right: 0.2em;padding-left: 0.2em;position: relative;}#sk-container-id-1 div.sk-item {position: relative;z-index: 1;}#sk-container-id-1 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-1 div.sk-item::before, #sk-container-id-1 div.sk-parallel-item::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: -1;}#sk-container-id-1 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-1 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-1 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-1 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-1 div.sk-dashed-wrapped {border: 1px dashed gray;margin: 0 0.4em 0.5em 0.4em;box-sizing: border-box;padding-bottom: 0.4em;background-color: white;}#sk-container-id-1 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-1 div.sk-label-container {text-align: center;}#sk-container-id-1 div.sk-container {/* jupyter's `normalize.less` sets `[hidden] { display: none; }` but bootstrap.min.css set `[hidden] { display: none !important; }` so we also need the `!important` here to be able to override the default hidden behavior on the sphinx rendered scikit-learn.org. See: https://github.com/scikit-learn/scikit-learn/issues/21755 */display: inline-block !important;position: relative;}#sk-container-id-1 div.sk-text-repr-fallback {display: none;}</style><div id=\"sk-container-id-1\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>LinearRegression()</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-1\" type=\"checkbox\" checked><label for=\"sk-estimator-id-1\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">LinearRegression</label><div class=\"sk-toggleable__content\"><pre>LinearRegression()</pre></div></div></div></div></div>"
      ],
      "text/plain": [
       "LinearRegression()"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# # train a linear regression model to adjust the prediction of the three models\n",
    "\n",
    "# predict the training set using the three models\n",
    "lgb_train = prediction(lgb_model_non_error, non_error_train[feature_regression])\n",
    "xgb_train = prediction(xgb_model_non_error, xgb.DMatrix(non_error_train[feature_regression]))\n",
    "cat_train = prediction(cat_model_non_error, cat.Pool(non_error_train[feature_regression]))\n",
    "\n",
    "# combine the prediction of the three models\n",
    "train_pred = np.array([lgb_train, xgb_train, cat_train])\n",
    "train_pred = np.transpose(train_pred)\n",
    "# train a linear regression model\n",
    "lr_non_error = LinearRegression()\n",
    "lr_non_error.fit(train_pred, non_error_train[target])\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2. Model for error data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.8395147861273193\n",
      "1.7722976423422812\n",
      "1.9873548898623883\n",
      "1.5083632230312074\n",
      "1.6643270992594346\n"
     ]
    }
   ],
   "source": [
    "# lightgbm\n",
    "# set the parameters for the lgb model\n",
    "param = {'num_leaves': 500,\n",
    "          'objective': 'regression',\n",
    "          'metric': 'rmse',\n",
    "          'max_depth': 12,\n",
    "          'learning_rate': 0.1,\n",
    "          'feature_fraction': 0.95,\n",
    "          'min_data_in_leaf': 5,\n",
    "          'bagging_fraction': 0.9,\n",
    "          'bagging_freq': 1,\n",
    "          'lambda_l1': 0.2,\n",
    "          'lambda_l2': 1,\n",
    "          'verbose': -1}\n",
    "\n",
    "# train the lgb model\n",
    "lgb_model_error = []\n",
    "lgb_prediction = []\n",
    "for train_index, val_index in kf.split(error_train):\n",
    "    X_train, X_val = error_train.iloc[train_index][feature_regression], error_train.iloc[val_index][feature_regression]\n",
    "    y_train, y_val = error_train.iloc[train_index][target], error_train.iloc[val_index][target]\n",
    "    train_data = lgb.Dataset(X_train, label=y_train)\n",
    "    val_data = lgb.Dataset(X_val, label=y_val)\n",
    "    lgb_model = lgb.train(param, train_data, valid_sets=[val_data])\n",
    "    lgb_model_error.append(lgb_model)\n",
    "    # evaluate the model\n",
    "    y_pred = lgb_model.predict(X_val, num_iteration=lgb_model.best_iteration)\n",
    "    lgb_prediction.append(y_pred)\n",
    "    # calculate the loss\n",
    "    loss = np.sqrt(sum((y_pred - y_val) ** 2) / len(y_val))\n",
    "    print(loss)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[15:52:42] WARNING: D:\\bld\\xgboost-split_1700181111005\\work\\src\\learner.cc:767: \n",
      "Parameters: { \"verbose\" } are not used.\n",
      "\n",
      "[0]\tvalidation-rmse:14.17939\n",
      "[1]\tvalidation-rmse:13.69933\n",
      "[2]\tvalidation-rmse:13.23678\n",
      "[3]\tvalidation-rmse:12.78987\n",
      "[4]\tvalidation-rmse:12.35741\n",
      "[5]\tvalidation-rmse:11.94149\n",
      "[6]\tvalidation-rmse:11.54022\n",
      "[7]\tvalidation-rmse:11.15426\n",
      "[8]\tvalidation-rmse:10.78788\n",
      "[9]\tvalidation-rmse:10.42794\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10.427940303342178\n",
      "[15:52:42] WARNING: D:\\bld\\xgboost-split_1700181111005\\work\\src\\learner.cc:767: \n",
      "Parameters: { \"verbose\" } are not used.\n",
      "\n",
      "[0]\tvalidation-rmse:13.99643\n",
      "[1]\tvalidation-rmse:13.51920\n",
      "[2]\tvalidation-rmse:13.05720\n",
      "[3]\tvalidation-rmse:12.61201\n",
      "[4]\tvalidation-rmse:12.18274\n",
      "[5]\tvalidation-rmse:11.77073\n",
      "[6]\tvalidation-rmse:11.37720\n",
      "[7]\tvalidation-rmse:10.99778\n",
      "[8]\tvalidation-rmse:10.62727\n",
      "[9]\tvalidation-rmse:10.27122\n",
      "10.271222698955798\n",
      "[15:52:42] WARNING: D:\\bld\\xgboost-split_1700181111005\\work\\src\\learner.cc:767: \n",
      "Parameters: { \"verbose\" } are not used.\n",
      "\n",
      "[0]\tvalidation-rmse:13.89288\n",
      "[1]\tvalidation-rmse:13.41530\n",
      "[2]\tvalidation-rmse:12.95557\n",
      "[3]\tvalidation-rmse:12.51046\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4]\tvalidation-rmse:12.08540\n",
      "[5]\tvalidation-rmse:11.67483\n",
      "[6]\tvalidation-rmse:11.27853\n",
      "[7]\tvalidation-rmse:10.89674\n",
      "[8]\tvalidation-rmse:10.52390\n",
      "[9]\tvalidation-rmse:10.17077\n",
      "10.17077124031282\n",
      "[15:52:42] WARNING: D:\\bld\\xgboost-split_1700181111005\\work\\src\\learner.cc:767: \n",
      "Parameters: { \"verbose\" } are not used.\n",
      "\n",
      "[0]\tvalidation-rmse:13.97490\n",
      "[1]\tvalidation-rmse:13.49068\n",
      "[2]\tvalidation-rmse:13.02203\n",
      "[3]\tvalidation-rmse:12.57192\n",
      "[4]\tvalidation-rmse:12.14424\n",
      "[5]\tvalidation-rmse:11.73176\n",
      "[6]\tvalidation-rmse:11.32987\n",
      "[7]\tvalidation-rmse:10.94136\n",
      "[8]\tvalidation-rmse:10.56648\n",
      "[9]\tvalidation-rmse:10.20677\n",
      "10.206774657149067\n",
      "[15:52:42] WARNING: D:\\bld\\xgboost-split_1700181111005\\work\\src\\learner.cc:767: \n",
      "Parameters: { \"verbose\" } are not used.\n",
      "\n",
      "[0]\tvalidation-rmse:14.08096\n",
      "[1]\tvalidation-rmse:13.59926\n",
      "[2]\tvalidation-rmse:13.14073\n",
      "[3]\tvalidation-rmse:12.69542\n",
      "[4]\tvalidation-rmse:12.26451\n",
      "[5]\tvalidation-rmse:11.84913\n",
      "[6]\tvalidation-rmse:11.45232\n",
      "[7]\tvalidation-rmse:11.06618\n",
      "[8]\tvalidation-rmse:10.70017\n",
      "[9]\tvalidation-rmse:10.34168\n",
      "10.341679534294322\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n"
     ]
    }
   ],
   "source": [
    "# xgboost\n",
    "# set the parameters for the xgb model\n",
    "param = {'objective': 'reg:squarederror', \n",
    "              'eta': 0.035, \n",
    "              'max_depth': 17, \n",
    "              'subsample': 0.6, \n",
    "              'colsample_bytree': 0.7,  \n",
    "              'eval_metric': 'rmse', \n",
    "              'verbose': False\n",
    "}\n",
    "# train the xgb model\n",
    "xgb_model_error = []\n",
    "xgb_prediction = []\n",
    "for train_index, val_index in kf.split(error_train):\n",
    "    X_train, X_val = error_train.iloc[train_index][feature_regression], error_train.iloc[val_index][feature_regression]\n",
    "    y_train, y_val = error_train.iloc[train_index][target], error_train.iloc[val_index][target]\n",
    "    train_data = xgb.DMatrix(X_train, label=y_train)\n",
    "    val_data = xgb.DMatrix(X_val, label=y_val)\n",
    "    xgb_model = xgb.train(param, train_data, evals=[(val_data, 'validation')])\n",
    "    xgb_model_error.append(xgb_model)\n",
    "    # evaluate the model\n",
    "    y_pred = xgb_model.predict(val_data)\n",
    "    xgb_prediction.append(y_pred)\n",
    "    # calculate the loss\n",
    "    loss = np.sqrt(sum((y_pred - y_val) ** 2) / len(y_val))\n",
    "    print(loss)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.715929782301726\n",
      "1.7385629991662581\n",
      "2.046242787691966\n",
      "1.512389004237424\n",
      "1.6134445904344314\n"
     ]
    }
   ],
   "source": [
    "# catboost\n",
    "# set the parameters for the cat model\n",
    "param = {'iterations' : 2000,\n",
    "        'learning_rate':0.07,\n",
    "        'depth':12,\n",
    "        'eval_metric':'RMSE',\n",
    "        'colsample_bylevel':0.8,\n",
    "        'bagging_temperature' : 0.4,\n",
    "        'metric_period' : None,\n",
    "        'early_stopping_rounds':200,\n",
    "        'verbose': False\n",
    "}\n",
    "# train the cat model\n",
    "cat_model_error = []\n",
    "cat_prediction = []\n",
    "for train_index, val_index in kf.split(error_train):\n",
    "    X_train, X_val = error_train.iloc[train_index][feature_regression], error_train.iloc[val_index][feature_regression]\n",
    "    y_train, y_val = error_train.iloc[train_index][target], error_train.iloc[val_index][target]\n",
    "    train_data = cat.Pool(X_train, label=y_train)\n",
    "    val_data = cat.Pool(X_val, label=y_val)\n",
    "    cat_model = cat.CatBoostRegressor(**param)\n",
    "    cat_model.fit(train_data, eval_set=val_data)\n",
    "    cat_model_error.append(cat_model)\n",
    "    # evaluate the model\n",
    "    y_pred = cat_model.predict(val_data)\n",
    "    cat_prediction.append(y_pred)\n",
    "    # calculate the loss\n",
    "    loss = np.sqrt(sum((y_pred - y_val) ** 2) / len(y_val))\n",
    "    print(loss)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To combine these 3 types of models, we use linear regression to find the best weight."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<style>#sk-container-id-2 {color: black;}#sk-container-id-2 pre{padding: 0;}#sk-container-id-2 div.sk-toggleable {background-color: white;}#sk-container-id-2 label.sk-toggleable__label {cursor: pointer;display: block;width: 100%;margin-bottom: 0;padding: 0.3em;box-sizing: border-box;text-align: center;}#sk-container-id-2 label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-2 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-2 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-2 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-2 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-2 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-2 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-container-id-2 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-2 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-2 input.sk-hidden--visually {border: 0;clip: rect(1px 1px 1px 1px);clip: rect(1px, 1px, 1px, 1px);height: 1px;margin: -1px;overflow: hidden;padding: 0;position: absolute;width: 1px;}#sk-container-id-2 div.sk-estimator {font-family: monospace;background-color: #f0f8ff;border: 1px dotted black;border-radius: 0.25em;box-sizing: border-box;margin-bottom: 0.5em;}#sk-container-id-2 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-2 div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-2 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-2 div.sk-serial::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: 0;}#sk-container-id-2 div.sk-serial {display: flex;flex-direction: column;align-items: center;background-color: white;padding-right: 0.2em;padding-left: 0.2em;position: relative;}#sk-container-id-2 div.sk-item {position: relative;z-index: 1;}#sk-container-id-2 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-2 div.sk-item::before, #sk-container-id-2 div.sk-parallel-item::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: -1;}#sk-container-id-2 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-2 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-2 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-2 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-2 div.sk-dashed-wrapped {border: 1px dashed gray;margin: 0 0.4em 0.5em 0.4em;box-sizing: border-box;padding-bottom: 0.4em;background-color: white;}#sk-container-id-2 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-2 div.sk-label-container {text-align: center;}#sk-container-id-2 div.sk-container {/* jupyter's `normalize.less` sets `[hidden] { display: none; }` but bootstrap.min.css set `[hidden] { display: none !important; }` so we also need the `!important` here to be able to override the default hidden behavior on the sphinx rendered scikit-learn.org. See: https://github.com/scikit-learn/scikit-learn/issues/21755 */display: inline-block !important;position: relative;}#sk-container-id-2 div.sk-text-repr-fallback {display: none;}</style><div id=\"sk-container-id-2\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>LinearRegression()</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-2\" type=\"checkbox\" checked><label for=\"sk-estimator-id-2\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">LinearRegression</label><div class=\"sk-toggleable__content\"><pre>LinearRegression()</pre></div></div></div></div></div>"
      ],
      "text/plain": [
       "LinearRegression()"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# train a linear regression model to adjust the prediction of the three models\n",
    "\n",
    "lgb_train = prediction(lgb_model_error, error_train[feature_regression])\n",
    "# data = xgb.DMatrix(error_train[feature_regression], label=error_train[target])\n",
    "xgb_train = prediction(xgb_model_error, xgb.DMatrix(error_train[feature_regression]))\n",
    "cat_train = prediction(cat_model_error, cat.Pool(error_train[feature_regression]))\n",
    "\n",
    "# combine the prediction of the three models\n",
    "train_pred = np.array([lgb_train, xgb_train, cat_train])\n",
    "train_pred = np.transpose(train_pred)\n",
    "# train a linear regression model\n",
    "lr_error = LinearRegression()\n",
    "lr_error.fit(train_pred, error_train[target])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Prediction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this part, we will use model for error-free data and model for error data to predict."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.75087709 -0.78011142  0.51168453]\n",
      "[ 0.107144   -0.74068552  1.09894808]\n"
     ]
    }
   ],
   "source": [
    "# print the coefficients of the linear regression model for the error set and non-error set\n",
    "print(lr_error.coef_)\n",
    "print(lr_non_error.coef_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Based on the kaggle score, we find that the predict result of linear regression combination is not satisfing. So we set the coefficient by ourselves."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3153, 94)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "d:\\anaconda3\\envs\\F30\\Lib\\site-packages\\xgboost\\data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n"
     ]
    }
   ],
   "source": [
    "#lgb: 2.10563\n",
    "#xgb: 11.08543\n",
    "#cat: 2.13359\n",
    "coef = [0.483, 0.034, 0.483]\n",
    "\n",
    "# predict the non-error set using the three models\n",
    "lgb_non_error = prediction(lgb_model_non_error, non_error_test[feature_regression])\n",
    "xgb_non_error = prediction(xgb_model_non_error, xgb.DMatrix(non_error_test[feature_regression]))\n",
    "cat_non_error = prediction(cat_model_non_error, cat.Pool(non_error_test[feature_regression]))\n",
    "\n",
    "# predict the non-error set using the linear regression model\n",
    "#y_pred = np.mean([lgb_non_error, xgb_non_error, cat_non_error], axis=0)\n",
    "#y_pred = lr_non_error.predict(np.array([lgb_non_error, xgb_non_error, cat_non_error]).T)\n",
    "\n",
    "# use the coefficients calculated above to adjust the prediction\n",
    "y_pred = np.dot(np.array([lgb_non_error, xgb_non_error, cat_non_error]).T, coef)\n",
    "\n",
    "\n",
    "non_error_test['revenue'] = np.expm1(y_pred)\n",
    "\n",
    "print(non_error_test.shape)\n",
    "# predict the error set using the three models\n",
    "lgb_error = prediction(lgb_model_error, error_test[feature_regression])\n",
    "xgb_error = prediction(xgb_model_error, xgb.DMatrix(error_test[feature_regression]))\n",
    "cat_error = prediction(cat_model_error, cat.Pool(error_test[feature_regression]))\n",
    "\n",
    "# predict the error set using the linear regression model\n",
    "#y_pred = lr_error.predict(np.array([lgb_error, xgb_error, cat_error]).T)\n",
    "\n",
    "# use the coefficients calculated above to adjust the predictionS\n",
    "y_pred = np.dot(np.array([lgb_error, xgb_error, cat_error]).T, coef)\n",
    "\n",
    "error_test['revenue'] = np.expm1(y_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Unnamed: 0</th>\n",
       "      <th>id</th>\n",
       "      <th>belongs_to_collection</th>\n",
       "      <th>original_budget</th>\n",
       "      <th>budget_processed</th>\n",
       "      <th>genre_rank</th>\n",
       "      <th>num_genres</th>\n",
       "      <th>genre_mean_rev</th>\n",
       "      <th>has_homepage</th>\n",
       "      <th>originally_english</th>\n",
       "      <th>...</th>\n",
       "      <th>popularity_year_ratio</th>\n",
       "      <th>_budget_runtime_ratio</th>\n",
       "      <th>_budget_popularity_ratio</th>\n",
       "      <th>tagline</th>\n",
       "      <th>title</th>\n",
       "      <th>overview</th>\n",
       "      <th>imdb_id</th>\n",
       "      <th>log_budget_p</th>\n",
       "      <th>error</th>\n",
       "      <th>revenue</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>3001</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1.200000e+07</td>\n",
       "      <td>17.25</td>\n",
       "      <td>4</td>\n",
       "      <td>1.600457e+08</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.480846</td>\n",
       "      <td>133333.333333</td>\n",
       "      <td>3.115642e+06</td>\n",
       "      <td>Somewhere Between Time &amp; Space... A Legend Is ...</td>\n",
       "      <td>Pokémon: The Rise of Darkrai</td>\n",
       "      <td>Ash and friends (this time accompanied by newc...</td>\n",
       "      <td>tt1226251</td>\n",
       "      <td>16.300417</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.056229e+06</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "      <td>3003</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>4.818003e+07</td>\n",
       "      <td>9.50</td>\n",
       "      <td>2</td>\n",
       "      <td>5.994296e+07</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>...</td>\n",
       "      <td>1.202000</td>\n",
       "      <td>481800.291667</td>\n",
       "      <td>5.959044e+06</td>\n",
       "      <td>A Comedy About Lost Loves And Last Laughs</td>\n",
       "      <td>Addicted to Love</td>\n",
       "      <td>Good-natured astronomer Sam is devastated when...</td>\n",
       "      <td>tt0118556</td>\n",
       "      <td>17.690455</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.627597e+07</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>5</td>\n",
       "      <td>3006</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>2.882751e+07</td>\n",
       "      <td>7.50</td>\n",
       "      <td>2</td>\n",
       "      <td>5.501053e+07</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>...</td>\n",
       "      <td>1.133083</td>\n",
       "      <td>238243.869835</td>\n",
       "      <td>3.321390e+06</td>\n",
       "      <td>NaN</td>\n",
       "      <td>SubUrbia</td>\n",
       "      <td>A group of suburban teenagers try to support e...</td>\n",
       "      <td>tt0120238</td>\n",
       "      <td>17.176841</td>\n",
       "      <td>1.0</td>\n",
       "      <td>8.185215e+06</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>6</td>\n",
       "      <td>3007</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>5.775155e+07</td>\n",
       "      <td>8.00</td>\n",
       "      <td>3</td>\n",
       "      <td>5.537510e+07</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.635041</td>\n",
       "      <td>485307.107143</td>\n",
       "      <td>1.178872e+07</td>\n",
       "      <td>Imagine the possibilities.</td>\n",
       "      <td>Three</td>\n",
       "      <td>Hanna and Simon are in a 20 year marriage with...</td>\n",
       "      <td>tt1517177</td>\n",
       "      <td>17.871661</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.285154e+07</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>11</td>\n",
       "      <td>3012</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>5.140572e+06</td>\n",
       "      <td>5.00</td>\n",
       "      <td>1</td>\n",
       "      <td>4.623936e+07</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.318406</td>\n",
       "      <td>45897.967634</td>\n",
       "      <td>1.218053e+06</td>\n",
       "      <td>NaN</td>\n",
       "      <td>Girlhood</td>\n",
       "      <td>Oppressed by her family setting, dead-end scho...</td>\n",
       "      <td>tt3655522</td>\n",
       "      <td>15.452675</td>\n",
       "      <td>1.0</td>\n",
       "      <td>6.356783e+05</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4393</th>\n",
       "      <td>4393</td>\n",
       "      <td>7394</td>\n",
       "      <td>0</td>\n",
       "      <td>42000000</td>\n",
       "      <td>4.200000e+07</td>\n",
       "      <td>8.00</td>\n",
       "      <td>1</td>\n",
       "      <td>5.488300e+07</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>...</td>\n",
       "      <td>1.144704</td>\n",
       "      <td>355932.203390</td>\n",
       "      <td>4.212486e+06</td>\n",
       "      <td>This is not a love story - it's a story about ...</td>\n",
       "      <td>Original Sin</td>\n",
       "      <td>A young man is plunged into a life of subterfu...</td>\n",
       "      <td>tt0218922</td>\n",
       "      <td>17.553180</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.904157e+07</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4394</th>\n",
       "      <td>4394</td>\n",
       "      <td>7395</td>\n",
       "      <td>1</td>\n",
       "      <td>19000000</td>\n",
       "      <td>1.900000e+07</td>\n",
       "      <td>12.75</td>\n",
       "      <td>4</td>\n",
       "      <td>1.121492e+08</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>...</td>\n",
       "      <td>0.698318</td>\n",
       "      <td>200000.000000</td>\n",
       "      <td>3.142305e+06</td>\n",
       "      <td>The call of the wild, the thrill of adventure....</td>\n",
       "      <td>Without a Paddle</td>\n",
       "      <td>Three friends, whose lives have been drifting ...</td>\n",
       "      <td>tt0364751</td>\n",
       "      <td>16.759950</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.827030e+07</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4395</th>\n",
       "      <td>4395</td>\n",
       "      <td>7396</td>\n",
       "      <td>0</td>\n",
       "      <td>16000000</td>\n",
       "      <td>1.600000e+07</td>\n",
       "      <td>5.00</td>\n",
       "      <td>1</td>\n",
       "      <td>4.623936e+07</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>...</td>\n",
       "      <td>1.128506</td>\n",
       "      <td>124031.007752</td>\n",
       "      <td>1.667208e+06</td>\n",
       "      <td>The doctors want to settle, the Church wants t...</td>\n",
       "      <td>The Verdict</td>\n",
       "      <td>Frank Galvin is a down-on-his luck lawyer, red...</td>\n",
       "      <td>tt0084855</td>\n",
       "      <td>16.588099</td>\n",
       "      <td>0.0</td>\n",
       "      <td>3.002175e+07</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4396</th>\n",
       "      <td>4396</td>\n",
       "      <td>7397</td>\n",
       "      <td>0</td>\n",
       "      <td>2000000</td>\n",
       "      <td>2.000000e+06</td>\n",
       "      <td>7.50</td>\n",
       "      <td>2</td>\n",
       "      <td>5.226169e+07</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>...</td>\n",
       "      <td>1.667758</td>\n",
       "      <td>20000.000000</td>\n",
       "      <td>9.823503e+04</td>\n",
       "      <td>It doesn't think, it doesn't feel, it doesn't ...</td>\n",
       "      <td>It Follows</td>\n",
       "      <td>For 19-year-old Jay, fall should be about scho...</td>\n",
       "      <td>tt3235888</td>\n",
       "      <td>14.508658</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.325229e+06</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4397</th>\n",
       "      <td>4397</td>\n",
       "      <td>7398</td>\n",
       "      <td>0</td>\n",
       "      <td>64000</td>\n",
       "      <td>6.400000e+04</td>\n",
       "      <td>5.00</td>\n",
       "      <td>1</td>\n",
       "      <td>4.623936e+07</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>1.432257</td>\n",
       "      <td>752.941176</td>\n",
       "      <td>5.660756e+03</td>\n",
       "      <td>The many faces of a woman trying to find herse...</td>\n",
       "      <td>Vivre Sa Vie</td>\n",
       "      <td>Twelve episodic tales in the life of a Parisia...</td>\n",
       "      <td>tt0056663</td>\n",
       "      <td>11.066654</td>\n",
       "      <td>0.0</td>\n",
       "      <td>4.299472e+05</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>4398 rows × 94 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "      Unnamed: 0    id  belongs_to_collection  original_budget  \\\n",
       "0              0  3001                      1                0   \n",
       "2              2  3003                      0                0   \n",
       "5              5  3006                      0                0   \n",
       "6              6  3007                      0                0   \n",
       "11            11  3012                      0                0   \n",
       "...          ...   ...                    ...              ...   \n",
       "4393        4393  7394                      0         42000000   \n",
       "4394        4394  7395                      1         19000000   \n",
       "4395        4395  7396                      0         16000000   \n",
       "4396        4396  7397                      0          2000000   \n",
       "4397        4397  7398                      0            64000   \n",
       "\n",
       "      budget_processed  genre_rank  num_genres  genre_mean_rev  has_homepage  \\\n",
       "0         1.200000e+07       17.25           4    1.600457e+08             1   \n",
       "2         4.818003e+07        9.50           2    5.994296e+07             0   \n",
       "5         2.882751e+07        7.50           2    5.501053e+07             0   \n",
       "6         5.775155e+07        8.00           3    5.537510e+07             0   \n",
       "11        5.140572e+06        5.00           1    4.623936e+07             0   \n",
       "...                ...         ...         ...             ...           ...   \n",
       "4393      4.200000e+07        8.00           1    5.488300e+07             0   \n",
       "4394      1.900000e+07       12.75           4    1.121492e+08             0   \n",
       "4395      1.600000e+07        5.00           1    4.623936e+07             0   \n",
       "4396      2.000000e+06        7.50           2    5.226169e+07             0   \n",
       "4397      6.400000e+04        5.00           1    4.623936e+07             0   \n",
       "\n",
       "      originally_english  ...  popularity_year_ratio  _budget_runtime_ratio  \\\n",
       "0                      0  ...               0.480846          133333.333333   \n",
       "2                      1  ...               1.202000          481800.291667   \n",
       "5                      1  ...               1.133083          238243.869835   \n",
       "6                      0  ...               0.635041          485307.107143   \n",
       "11                     0  ...               0.318406           45897.967634   \n",
       "...                  ...  ...                    ...                    ...   \n",
       "4393                   1  ...               1.144704          355932.203390   \n",
       "4394                   1  ...               0.698318          200000.000000   \n",
       "4395                   1  ...               1.128506          124031.007752   \n",
       "4396                   1  ...               1.667758           20000.000000   \n",
       "4397                   0  ...               1.432257             752.941176   \n",
       "\n",
       "      _budget_popularity_ratio  \\\n",
       "0                 3.115642e+06   \n",
       "2                 5.959044e+06   \n",
       "5                 3.321390e+06   \n",
       "6                 1.178872e+07   \n",
       "11                1.218053e+06   \n",
       "...                        ...   \n",
       "4393              4.212486e+06   \n",
       "4394              3.142305e+06   \n",
       "4395              1.667208e+06   \n",
       "4396              9.823503e+04   \n",
       "4397              5.660756e+03   \n",
       "\n",
       "                                                tagline  \\\n",
       "0     Somewhere Between Time & Space... A Legend Is ...   \n",
       "2             A Comedy About Lost Loves And Last Laughs   \n",
       "5                                                   NaN   \n",
       "6                            Imagine the possibilities.   \n",
       "11                                                  NaN   \n",
       "...                                                 ...   \n",
       "4393  This is not a love story - it's a story about ...   \n",
       "4394  The call of the wild, the thrill of adventure....   \n",
       "4395  The doctors want to settle, the Church wants t...   \n",
       "4396  It doesn't think, it doesn't feel, it doesn't ...   \n",
       "4397  The many faces of a woman trying to find herse...   \n",
       "\n",
       "                             title  \\\n",
       "0     Pokémon: The Rise of Darkrai   \n",
       "2                 Addicted to Love   \n",
       "5                         SubUrbia   \n",
       "6                            Three   \n",
       "11                        Girlhood   \n",
       "...                            ...   \n",
       "4393                  Original Sin   \n",
       "4394              Without a Paddle   \n",
       "4395                   The Verdict   \n",
       "4396                    It Follows   \n",
       "4397                  Vivre Sa Vie   \n",
       "\n",
       "                                               overview    imdb_id  \\\n",
       "0     Ash and friends (this time accompanied by newc...  tt1226251   \n",
       "2     Good-natured astronomer Sam is devastated when...  tt0118556   \n",
       "5     A group of suburban teenagers try to support e...  tt0120238   \n",
       "6     Hanna and Simon are in a 20 year marriage with...  tt1517177   \n",
       "11    Oppressed by her family setting, dead-end scho...  tt3655522   \n",
       "...                                                 ...        ...   \n",
       "4393  A young man is plunged into a life of subterfu...  tt0218922   \n",
       "4394  Three friends, whose lives have been drifting ...  tt0364751   \n",
       "4395  Frank Galvin is a down-on-his luck lawyer, red...  tt0084855   \n",
       "4396  For 19-year-old Jay, fall should be about scho...  tt3235888   \n",
       "4397  Twelve episodic tales in the life of a Parisia...  tt0056663   \n",
       "\n",
       "      log_budget_p  error       revenue  \n",
       "0        16.300417    1.0  1.056229e+06  \n",
       "2        17.690455    1.0  1.627597e+07  \n",
       "5        17.176841    1.0  8.185215e+06  \n",
       "6        17.871661    1.0  1.285154e+07  \n",
       "11       15.452675    1.0  6.356783e+05  \n",
       "...            ...    ...           ...  \n",
       "4393     17.553180    0.0  1.904157e+07  \n",
       "4394     16.759950    0.0  2.827030e+07  \n",
       "4395     16.588099    0.0  3.002175e+07  \n",
       "4396     14.508658    0.0  2.325229e+06  \n",
       "4397     11.066654    0.0  4.299472e+05  \n",
       "\n",
       "[4398 rows x 94 columns]"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# combine the error and non-error set\n",
    "test = error_test._append(non_error_test, ignore_index=False)\n",
    "test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_LXC = pd.DataFrame()\n",
    "sub= ['id','revenue']\n",
    "df_LXC[sub]=test[sub]\n",
    "df_LXC.sort_values(by='id', inplace=True)\n",
    "df_LXC.to_csv(\"submission_LXC.csv\", index=False)\n",
    "# 2.07727"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Aggregation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "# df_LR, df_RF, df_LXC\n",
    "# merge by id\n",
    "df_aggregate = pd.merge(df_LR, df_RF, on='id')\n",
    "df_aggregate = pd.merge(df_aggregate, df_LXC, on='id')\n",
    "\n",
    "# set the weight of each model\n",
    "weight = [0.999, 0.0005, 0.0005]\n",
    "\n",
    "# calculate the weighted average\n",
    "df_aggregate['revenue'] = weight[0] * df_aggregate['revenue_x'] + weight[1] * df_aggregate['revenue_y'] + weight[2] * df_aggregate['revenue']\n",
    "# drop the columns that are not needed\n",
    "df_aggregate = df_aggregate.drop(['revenue_x', 'revenue_y'], axis=1)\n",
    "\n",
    "# save the result\n",
    "df_aggregate.to_csv('submission_aggregate.csv', index=False)\n",
    "\n",
    "# 1.92684"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "F30",
   "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.8.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}