06_Ensemble-Learning.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "7237e24c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Most Important \n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import seaborn as sns\n",
    "from scipy import stats\n",
    "\n",
    "# other\n",
    "import missingno as msno\n",
    "import joblib\n",
    "import tarfile\n",
    "import os\n",
    "import urllib\n",
    "\n",
    "### Scikit-learn\n",
    "\n",
    "from sklearn import datasets\n",
    "from sklearn import utils\n",
    "\n",
    "# Metrics\n",
    "from sklearn.metrics import mean_squared_error, mean_squared_log_error\n",
    "from sklearn.metrics import accuracy_score, r2_score\n",
    "from sklearn.metrics import confusion_matrix, classification_report\n",
    "from sklearn.metrics import precision_score, recall_score\n",
    "from sklearn.metrics import roc_auc_score, roc_curve, precision_recall_curve\n",
    "\n",
    "# Preprocessing & Imputing\n",
    "from sklearn.preprocessing import StandardScaler, MinMaxScaler, LabelEncoder, OneHotEncoder\n",
    "from sklearn.preprocessing import PolynomialFeatures\n",
    "from sklearn.impute import SimpleImputer\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.compose import ColumnTransformer\n",
    "\n",
    "# Validating and Tuning\n",
    "from sklearn.model_selection import train_test_split, StratifiedShuffleSplit\n",
    "from sklearn.model_selection import cross_val_score, cross_val_predict\n",
    "from sklearn.model_selection import GridSearchCV, RandomizedSearchCV\n",
    "\n",
    "# Algorithms\n",
    "import xgboost as xgb\n",
    "\n",
    "from sklearn.linear_model import LinearRegression, SGDClassifier, SGDRegressor\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.neighbors import KNeighborsClassifier, KNeighborsRegressor\n",
    "from sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor\n",
    "from sklearn.svm import SVC, SVR\n",
    "\n",
    "from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor\n",
    "from sklearn.ensemble import VotingClassifier, VotingRegressor\n",
    "from sklearn.ensemble import BaggingClassifier, BaggingRegressor\n",
    "from sklearn.ensemble import AdaBoostClassifier, AdaBoostRegressor\n",
    "from sklearn.ensemble import GradientBoostingClassifier, GradientBoostingRegressor"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84e759d4",
   "metadata": {},
   "source": [
    "## Voting Classifiers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "f2f24c3f",
   "metadata": {},
   "outputs": [],
   "source": [
    "iris = datasets.load_iris()\n",
    "df_iris = pd.DataFrame(np.c_[iris.data, iris.target], columns=iris.feature_names+['target'])\n",
    "\n",
    "# shuffle the data\n",
    "df_iris = utils.shuffle(df_iris)\n",
    "\n",
    "X = df_iris.drop(columns=['target'], axis=1).astype(np.float64)\n",
    "y = df_iris['target'].astype(np.float64)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "1a696031",
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_val, y_train, y_val = train_test_split(X, y, \n",
    "                                                  test_size=0.2, random_state=42, shuffle=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "ffba54f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "log_clf = LogisticRegression(max_iter=10000)\n",
    "forest_clf = RandomForestClassifier()\n",
    "svc_clf = SVC(probability=True, max_iter=10000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "d064b0c3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "VotingClassifier(estimators=[('lr', LogisticRegression(max_iter=10000)),\n",
       "                             ('forest', RandomForestClassifier()),\n",
       "                             ('svc', SVC(max_iter=10000, probability=True))],\n",
       "                 n_jobs=-1, voting='soft')"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vote_clf = VotingClassifier(estimators=[('lr', log_clf), \n",
    "                                        ('forest', forest_clf), \n",
    "                                        ('svc', svc_clf)], \n",
    "                            voting='soft', n_jobs=-1)   ## tou can try both (hard and soft voting)\n",
    "\n",
    "vote_clf.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "4a9cb2f7",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LogisticRegression 0.9333333333333333\n",
      "==============================\n",
      "RandomForestClassifier 0.9333333333333333\n",
      "==============================\n",
      "SVC 0.9\n",
      "==============================\n",
      "VotingClassifier 0.9\n",
      "==============================\n"
     ]
    }
   ],
   "source": [
    "classifiers = [log_clf, forest_clf, svc_clf, vote_clf]\n",
    "\n",
    "for alg in classifiers:\n",
    "    \n",
    "    alg.fit(X_train, y_train)\n",
    "    y_predict = alg.predict(X_val)\n",
    "    \n",
    "    print(alg.__class__.__name__, accuracy_score(y_val, y_predict))\n",
    "    print('==='*10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0db9e1fa",
   "metadata": {},
   "source": [
    "### Bagging and Pasing\n",
    "\n",
    "**Bagging is an ensemble Method stands for (BOOSTSTRAP AGGREGATION)**  <br />\n",
    "* Bagging is parallel method and with replacement in dataset <br />\n",
    "* Bagging is parallel method and without replacement in dataset for the same predictor\n",
    "\n",
    "* if you set (bootstrap=True => 'bagging' , bootstrap=False => 'pasting') "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83f9ece2",
   "metadata": {},
   "source": [
    "####  BaggingClassifier for DT or you cam use RandomForest\n",
    "* i will show both Methods"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e4325fab",
   "metadata": {},
   "source": [
    "#### 1. Bagging"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "873c3263",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Out of bag scores => 0.9583333333333334\n",
      "score_bagging_testing => 0.9\n"
     ]
    }
   ],
   "source": [
    "## Bagging\n",
    "\n",
    "bag_clf = BaggingClassifier(base_estimator=DecisionTreeClassifier(max_depth=3),\n",
    "                            n_estimators=300, \n",
    "                            bootstrap=True, \n",
    "                            max_samples=1.0, n_jobs=-1, oob_score=True)  \n",
    "# max_samples=1.0 >> size of each = size of whole data\n",
    "## bootstrap and max_samples for instances\n",
    "## bootstrap_features and max_features are for features\n",
    "## you can make sampling subsets in both directions or both\n",
    "\n",
    "bag_clf.fit(X_train, y_train)\n",
    "\n",
    "## score of OOB (out of bag scores)\n",
    "print('Out of bag scores =>', bag_clf.oob_score_)\n",
    "\n",
    "## predcict and get the score\n",
    "y_pred_bag = bag_clf.predict(X_val)\n",
    "\n",
    "score_bagging = accuracy_score(y_val, y_pred_bag)\n",
    "print('score_bagging_testing =>', score_bagging)  \n",
    "\n",
    "### data is too small and it is very very simple (just for illustration)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "4b42f928",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\moham\\anaconda3\\lib\\site-packages\\sklearn\\model_selection\\_search.py:918: UserWarning: One or more of the test scores are non-finite: [       nan        nan        nan 0.96666667 0.96666667 0.96666667]\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score_bag_past => 0.9\n"
     ]
    }
   ],
   "source": [
    "### make grid search for both (bagging and pasting)\n",
    "\n",
    "\n",
    "best_params = {'bootstrap': [False, True], \n",
    "               'n_estimators': np.arange(200,500,100)}\n",
    "\n",
    "\n",
    "grid_search_bag_past = GridSearchCV(bag_clf, \n",
    "                                    param_grid=best_params, cv=5, \n",
    "                                    n_jobs=-1, scoring='accuracy')\n",
    "\n",
    "grid_search_bag_past.fit(X_train, y_train)\n",
    "\n",
    "\n",
    "## best model\n",
    "best_bag_past = grid_search_bag_past.best_estimator_\n",
    "\n",
    "print('score_bag_past =>', accuracy_score(y_val, best_bag_past.predict(X_val)))\n",
    "### data is too small and it is very very simple (just for illustration)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "758840e1",
   "metadata": {},
   "source": [
    "#### 1. RandomForest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "4c9adbd8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score_forest => 0.9333333333333333\n",
      "bag_forest => 0.9333333333333333\n"
     ]
    }
   ],
   "source": [
    "#### forest\n",
    "\n",
    "rnd_clf = RandomForestClassifier(n_estimators=300, max_depth=3, n_jobs=-1)\n",
    "rnd_clf.fit(X_train, y_train)\n",
    "\n",
    "print('score_forest =>', accuracy_score(y_val, rnd_clf.predict(X_val)))\n",
    "### data is too small and it is very very simple (just for illustration)\n",
    "\n",
    "\n",
    "## get the same code of above RandomForest using BaggingClassifier\n",
    "\n",
    "bag_forest = BaggingClassifier(DecisionTreeClassifier(max_depth=3, splitter='random'), \n",
    "                               n_estimators=300,\n",
    "                               max_samples=1.0,  \n",
    "                               bootstrap=True, n_jobs=-1)\n",
    "\n",
    "## (max_samples=1.0) => should be float number (1.0 the same size of whole data)\n",
    "bag_forest.fit(X_train, y_train)\n",
    "\n",
    "print('bag_forest =>', accuracy_score(y_val, bag_forest.predict(X_val)))\n",
    "### data is too small and it is very very simple (just for illustration)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08133289",
   "metadata": {},
   "source": [
    "#### Feature impoertances"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "f5a8f557",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   index              Names  importances\n",
      "0      2  petal length (cm)     0.486378\n",
      "1      3   petal width (cm)     0.416757\n",
      "2      0  sepal length (cm)     0.083799\n",
      "3      1   sepal width (cm)     0.013065\n",
      "============================================================\n",
      "sepal length (cm) => 0.08379910887995216\n",
      "sepal width (cm) => 0.01306507819867732\n",
      "petal length (cm) => 0.48637833945828274\n",
      "petal width (cm) => 0.41675747346308784\n"
     ]
    }
   ],
   "source": [
    "col_names = list(X_train.columns)\n",
    "\n",
    "impotances = rnd_clf.feature_importances_\n",
    "\n",
    "df_importances = pd.DataFrame({'Names': col_names, 'importances':impotances})\n",
    "df_importances = df_importances.sort_values('importances', ascending=False).reset_index()\n",
    "\n",
    "print(df_importances)\n",
    "\n",
    "print('==='*20)\n",
    "################### Another Method ####################\n",
    "\n",
    "for name, score in zip(iris.feature_names, rnd_clf.feature_importances_):\n",
    "    print(name, '=>', score)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "595f382b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "a0812da1",
   "metadata": {},
   "source": [
    "### Boosting\n",
    "\n",
    "* Boosting is sequential method and with  <br />\n",
    "* some techniques of Boosting are (AdaBoost, GradientBoosting)\n",
    "     * AdaBoost tries to solve the missclassified instances sequentially by giving more weights to it and try to solve again and so on until estimating for all predictors\n",
    "     \n",
    "     * GradientBoosting tries to solve the residual errors of instances sequentially and the total prediction is the sum af all trials to solve this errors\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43198edb",
   "metadata": {},
   "source": [
    "### AdaBoost\n",
    "\n",
    "* scikit-learn uses a multiclass version of Adaboost called SAMME so use Algorithm (SAMME.R)\n",
    "* algorithm='SAMME.R' \n",
    "* learning_rate , which is used to get (predictor weights) , default=1.0\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "33874e55",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ada_clf => 0.9\n"
     ]
    }
   ],
   "source": [
    "### AdaBoost Classifiers\n",
    "\n",
    "ada_clf = AdaBoostClassifier(DecisionTreeClassifier(max_depth=3), \n",
    "                             n_estimators=300, algorithm='SAMME.R', \n",
    "                             learning_rate=0.5)\n",
    "\n",
    "ada_clf.fit(X_train, y_train)\n",
    "\n",
    "print('ada_clf =>', accuracy_score(y_val, ada_clf.predict(X_val)))\n",
    "### data is too small and it is very very simple (just for illustration)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "059d08c5",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "4533de5f",
   "metadata": {},
   "source": [
    "### GradientBoosting\n",
    "\n",
    "* GradientBoosting tries to solve the residual errors of instances sequentially and the total prediction is the sum af all trials to solve this errors\n",
    "\n",
    "* learning_rate here is used to sacle the contribution of each tree\n",
    "\n",
    "    * `if you think your Model is Overfitting , you can regularize the Model using learning_rate ` <br />\n",
    "    * ` this technique of Regularization is called (Shrinkage)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "645d105e",
   "metadata": {},
   "outputs": [],
   "source": [
    "X = 6 * np.random.rand(100, 1) - 3\n",
    "y = np.squeeze(0.5 * X**2 + X + 2 + np.random.rand(100, 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c59f3a0",
   "metadata": {},
   "source": [
    "#### Manually"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "3eebc184",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEWCAYAAABhffzLAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAnrklEQVR4nO3deZRU9Zn/8fcjNDQqgiIqBhEm41EQsMWeBCUKo7JITBzjOMFJ+AWNYjQu8efGTBYafybHLZGMWU5IFIkaNRFNHKMGXHCJEm2wRQR3QUgUEG0EgaaB5/dH3equrq7qrqquqltV9/M6p04td6nnVsNT33ru936/5u6IiEh07BF2ACIiUlxK/CIiEaPELyISMUr8IiIRo8QvIhIxSvwiIhGjxC9S5sxskZmdGzyeZmbPhh2TlDYlfikpZjbFzP5mZp+a2frg8YVmZsHy281sh5ltMbPNZrbEzMYmbD/NzHYFyz8xs5fN7FQzGxS8Fr958B7x58eHd9QixaXELyXDzC4HfgrcCBwEHAh8CxgD9EhY9QZ33xvoA/wSuN/MuiUsfz5Y3hf4BXAP8Im77x2/BesdlfDaM4U8NpFSosQvJcHM+gDXABe6+33uvtljXnL3r7l7U/I27r4b+B2wH7EviVTL7wD2Ag7LIaZFZnatmT0X/Cr4XzPrZ2Z3Bb8mXjSzwQnr/9TM1gTLliT+ijCzOjP7vZn9Nvil8qqZ1SYsdzP754Tnt5vZtcHjfc3sITPbYGYfB48HZhD/z83sx0mv/a+ZfSfbz0IqixK/lIpjgZ7AnzLdIGjl/x/gXWBdmuVnA83A6hzjmgJMBT4DfBZ4HphL7MtmJTAzYd0XgZpg2e+AP5hZdcLyLxP79dEXeBD4WYYx7BG856HAIGBbhtvOA84ysz0AzGx/4CTg7gzfVyqUEr+Uiv2BD919Z/yFoKXdaGbbzOyEhHWvMLNG4FNgNvB9d9+VsHx0sHw7cBPwdXdfn2Ncc939bXffBDwCvO3ujwVx/gE4Or6iu9/p7hvdfae7/5jYF9nhCft61t0fDmK9AzgqkwCCfc53963uvhn4ITA2g+1eADYRS/YQ+xJb5O7tviQlWpT4pVRsBPY3s+7xF9z9OHfvGyxL/Ld6U/B6L6AWuNHMTklYvjhYvi+xlnVXTtwmJsltKZ7HzxdgZpeb2Uoz2xR88fQh9oUW90HC461AdeLxpmNme5rZr8xstZl9AjwN9E06r5HOPODrweOvE/vCkYhT4pdS8TzQBJyW6QbBOYDlwF+BL6ZYvgW4EJhqZkcnL8+noJ5/NfAfwL7BF88mwDLcxVZgz4TnByU8vpzYL4fPu/s+QPzXTyb7vhM4zcyOAoYCf8wwHqlgSvxSEty9EZgF/MLM/t3M9jazPcyshtjJ2ZTM7AjgC8Crafa7EfgN8IO8B91Wb2AnsAHobmY/APbJYvsG4D/NrJuZTaJtKac3sV8XjWa2H23PK3TI3dcSO/dwBzDf3bdlEZNUKCV+KRnufgPwf4GrgPXEyiq/ItaSfi5h1auCXjafAguInfj8VQe7ng1MNrORhYg78Bdi5wDeIHYieTuwJovtLwW+BDQCX6Nty3w2sbLWh8Bi4NEsY5sHjEBlHgmYJmIRqWzBifE7gcFBF1eJOLX4RSqYmVUR+zXxGyV9iVPiF6lQZjaUWOloALFykQigUo+ISOQUrMVvZrcFg2wtT3htPzNbaGZvBvf7Fur9RUQktYK1+IMTSluA37r78OC1G4CP3P06M5tBrL/z1Z3ta//99/fBgwcXJE4RkUq1ZMmSD929f/LrnV41mCt3fzpxAKvAacC44PE8YBGxrnodGjx4MPX19fkMT0Sk4plZyjGqin1y90B3fx8guD8g3YpmNt3M6s2sfsOGDUULUESk0pVsrx53n+Pute5e279/u18qIiKSo2In/nVmNgAguM91xEQREclRwWr8aTwIfAO4LrjPeOz1ZM3Nzaxdu5bt27fnK7bIqq6uZuDAgVRVVYUdiogUQcESv5ndTexE7v5mtpbYwFLXAb83s28C7wFn5rr/tWvX0rt3bwYPHkwwHavkwN3ZuHEja9euZciQIWGHIyJFULBSj7uf5e4D3L3K3Qe6+63BhBInufthwf1Hue5/+/bt9OvXT0m/i8yMfv366ZeTSLHV1YX21iV7cjcTSvr5oc9RJASzZoX21mWd+EVEJHtK/Dlas2YNQ4YM4aOPYtWqjz/+mCFDhrB6da5zends1apVDB8+vCD7FpEiqasDs9gNWh8XuewTvcSfpw/4kEMO4YILLmDGjBkAzJgxg+nTp3PooYfmZf8iUoHq6sA9doPWx0r8BZbHutpll13G4sWLmT17Ns8++yyXX345AFOnTuVPf2rtqfq1r32NBx98sM22X/3qV3n44Ydbnk+bNo358+ezatUqjj/+eEaNGsWoUaN47rnnSHb77bdz0UUXtTw/9dRTWbRoEQALFizg2GOPZdSoUZx55pls2bIFiH0xDRs2jJEjR3LFFVfk7TMQkfITvcSfR1VVVdx4441cdtllzJ49mx49egBw7rnnMnfuXAA2bdrEc889x+TJk9tsO2XKFO69914AduzYweOPP87kyZM54IADWLhwIUuXLuXee+/lkksuyTieDz/8kGuvvZbHHnuMpUuXUltby09+8hM++ugjHnjgAV599VWWLVvG9773vTx9AiKSs5kZT52cd9FI/AWsqz3yyCMMGDCA5ctbRp9m7NixvPXWW6xfv567776bM844g+7d214yccopp/DEE0/Q1NTEI488wgknnECvXr1obm7mvPPOY8SIEZx55pmsWLEi41gWL17MihUrGDNmDDU1NcybN4/Vq1ezzz77UF1dzbnnnsv999/Pnnvu2eXjFpEuUnfOAitQXa2hoYGFCxeyePFibr75Zt5///2WZVOnTuWuu+5i7ty5nH322e22ra6uZty4cfzlL3/h3nvvZcqUKQDcfPPNHHjggbz88svU19ezY8eOdtt2796d3btbZ9GL98F3d8aPH09DQwMNDQ2sWLGCW2+9le7du/PCCy9wxhln8Mc//pFJkyZ16bhFpAtCTPhx0Uj8BeDuXHDBBcyePZtBgwZx5ZVXtqmdT5s2jdmzZwNw5JFHptzHlClTmDt3Ls888wwTJ04EYqWhAQMGsMcee3DHHXewa9eudtsNHjyYhoYGdu/ezZo1a3jhhRcAGD16NH/961956623ANi6dStvvPEGW7ZsYdOmTUyePJnZs2fT0NCQx09CRLISYv/9uOgl/jzV1X79618zaNAgxo8fD8CFF17Ia6+9xlNPPQXAgQceyNChQ1O29uMmTJjA008/zcknn9xyfuDCCy9k3rx5jB49mjfeeIO99tqr3XZjxoxhyJAhjBgxgiuuuIJRo0YB0L9/f26//XbOOussRo4cyejRo3nttdfYvHkzp556KiNHjmTs2LHcfPPNefkMRKQ8lcWcu7W1tZ48EcvKlSsZOnRoSBF1buvWrYwYMYKlS5fSp0+fsMPpVKl/niJlra4udUt/5syCln7MbIm71ya/Hr0WfxE89thjHHHEEVx88cVlkfRFpMBKpP9+XLGHZY6Ek08+mffeey/sMEREUlLiFxEpgF27YP58WLcueclFcEvm+znmGDjuuHxGpsQvIlIQTz4JX/1qqiW3QObXZXL11RWS+M3sUuA8wIBfu/vsMOIQESmUeEv/sMNg4ptpmvgHfwa+8pUO93PssXkOjBASv5kNJ5b0PwfsAB41sz+7+5vFjkVEpFCammL3xx0Ht7x5SeuJXbO2j28pfs/KMHr1DAUWu/tWd98JPAWcHkIcXdatWzdqamoYPnw4X/rSl2hsbAQyG0J5w4YNfP7zn+foo4/mmWeeYfLkyTQ2NtLY2MgvfvGLlvVWrVrF7373u6xjmzZtGvfdd1/W24lIfjTNfwiAnvN+FXshcdiYkIWR+JcDJ5hZPzPbE5gMHBJCHF3Wq1cvGhoaWL58Ofvttx8///nPM9728ccf54gjjuCll17i+OOP5+GHH6Zv3755S/wiEq4dE04FoOfF58deiHfhHDs29DH5i17qcfeVZnY9sBDYArwM7Exez8ymA9MBBg0aVNQYc3HssceybNmyjNZtaGjgqquuYtu2bdTU1PD8888zdOhQ6uvrmTFjBm+//TY1NTWMHz+eZ555hpUrV1JTU8M3vvENLrnkEmbMmMGiRYtoamri29/+Nueffz7uzsUXX8wTTzzBkCFDKIcL80QqWbzUE1yU3yoYQh1oW/YpolBO7rr7rcCtAGb2I2BtinXmAHMgduVuR/sr1K+nTP8eu3bt4vHHH+eb3/xmRuvX1NRwzTXXUF9fz89+9rM2y6677jqWL1/eMp7OokWLuOmmm3joodjPxjlz5tCnTx9efPFFmpqaGDNmDBMmTOCll17i9ddf55VXXmHdunUMGzaMc845J+NjFZH8io+v2LMnoQ7BnEpYvXoOcPf1ZjYI+ApQgPPWhRdvsa9atYpjjjmmZdyeQlqwYAHLli1rqd9v2rSJN998k6effpqzzjqLbt26cfDBB3PiiScWPBYRSS/e4u/ZE/hBXeqVQvpCCGvIhvlmtgL4X+Db7v5xV3YWL53l+9aZeI1/9erV7NixI6saf+7H6txyyy0tQy+/++67TJgwAQArkRNHIpKU+BMl1vJDGrIhlMTv7se7+zB3P8rdHw8jhnzq06cP//M//8NNN91Ec3Nzl/bVu3dvNm/enPb5xIkT+eUvf9nyPm+88QaffvopJ5xwAvfccw+7du3i/fff58knn+xSHCLSNfFST7sav4ZlrhxHH300Rx11FPfccw8Ar7/+OgMHDmy5/eEPf8hoP/369WPMmDEMHz6cK6+8kpEjR9K9e3eOOuoobr75Zs4991yGDRvGqFGjGD58OOeffz47d+7k9NNP57DDDmPEiBFccMEFjB07tpCHKyKdSNviLwEallkAfZ4iXVZX16Z0c845MHcu/OY38M01dRqWWUSk4iQl9h31se7dPXpQcsMyK/GLiBRA0yuvA6VZ6inrxF8OZapyoM9RJEd1dWmvwm0ilvHbJf4S6NNftom/urqajRs3Kml1kbuzceNGqqurww5FpPwkl3DiSX3WLHYQ687T898mlUQXzkRlOx7/wIEDWbt2LRs2bAg7lLJXXV3NwIEDww5DpPwlnOBtsliX6h6PPwoldj1l2Sb+qqoqhgwZEnYYIhIlST132kgq4aQt9ZSAsi31iIgUXaoumfEvgqQvhB0DBgNK/CIilSfNlbhN/Q4GUly5WwKU+EVEOtJBz52OlPKVu0r8IiIdSXXx1cyZsZZ+B18GO9Y3AqWZ+Mv25K6ISL5s3QoJYyF24ABYB1xQF7sBHHQgfLCudZXg4bZNsSa/Er+ISIl5910YMQI+/TSTtdfBQZm8BnAgUJo1fiV+EYm05ctjSb9HD+jbN4MN1q+DAw5svf90C+y1d2zZp1vafIOM4a/st/8ZBR+MLVtK/CISafEpNCZPhgceyGADOwjWees9eycs3Lv1ect8uqU3ukAoJ3fN7DIze9XMlpvZ3Wam8QJEJBRpJ0xJlKpnT/w+gx4+paboid/MPgNcAtS6+3CgGzCl2HGIiEBri7+qqoOVUvXsid+nG165BAZjSyes7pzdgV5m1h3YE/hHSHGISMRllPhzUcK/Aoqe+N3978BNwHvA+8Amd1+QvJ6ZTTezejOr10BsIlIo8VJPxok/3pIv4RZ9Z8Io9ewLnAYMAQ4G9jKzryev5+5z3L3W3Wv79+9f7DBFJCLiLf6Mu12mGZunnIRR6jkZeNfdN7h7M3A/cFwIcYiIFK7UU8LCSPzvAaPNbE8zM+AkYGUIcYiIKPEXg7v/DbgPWAq8EsQwp9hxiIhAht05K0woF3C5+0ygfM+MiEjFUItfRCRilPhFRCImiqUeJX4RiTS1+EVEIkaJX0QkYpT4RUQqXdIVt6rxi4hUulmz2jxVi19EJGLSJv4yHounM0r8IlL5Uk2kEkygkrbUk/TLoJIo8YtI5Us1kUowgYpKPSIiEdMm8Xfwy6CSaLJ1EYmWpAlU2kzEUlfXmuRbJkuvPGrxi0i0JLXes56IpQIo8YtIpKWt8Zfx1IqdUeIXkUhTd04RkYjRlbtFYGaHm1lDwu0TM/tOseMQEYFoXrlb9F497v46UANgZt2AvwMPFDsOEal8H38MN9wAjY3p11m3LnavxF88JwFvu/vqkOMQkQp0771w3XWdr1dVBX37FjyckhF24p8C3J1qgZlNB6YDDBo0qJgxiUiF+OST2P348XD66enXGzFCib8ozKwH8GXgv1Itd/c5wByA2trayryKQkQKKl6//5d/gQsuCDeWUhJmr55TgKXuvi7EGESkgkWxx04mwkz8Z5GmzCMikg9thmOQFqEkfjPbExgP3B/G+4tINERxOIZMhFLjd/etQL8w3ltEokMt/tR05a6IVCy1+FNT4heRipW2xV/B4/BkQolfRCpW2hZ/BU+rmAklfhGpWKrxp6bELyIVq00//ohMq5iJsIdsEBEpmDalnohMq5gJtfhFpGKp1JOaEr+IVJaE0k3ak7sVPK1iJpT4RaSyJPTYUXfO1JT4RaRi6QKu1JT4RaT8pemxs+O99wHV+JMp8YtI+auri/XSiffUCR439xsAqMWfTIlfRCpPUMNXr57UlPhFpLyNG9f2+cyZLSd4NRFLakr8IlLennqq7fMU3TnV4m9LiV9Eyku6rpgpTvDu+McGQC3+ZGHNwNXXzO4zs9fMbKWZHRtGHCJShmbNipV3knvxzJoFY8e2OcHb3Kc/oBZ/srDG6vkp8Ki7/7uZ9QD2DCkOESlHixa1Pu5g3B3V+FMreovfzPYBTgBuBXD3He7eWOw4RKSMZDuyZjAkg2r8qZkXeYQ6M6sB5gArgKOAJcCl7v5p0nrTgekAgwYNOmb16tVFjVNESlA88SfmrXHj2v4CCOzeDd26tT6ObxolZrbE3WuTXw+j1NMdGAVc7O5/M7OfAjOA7yeu5O5ziH1BUFtbG93xU0WEhQth6VKAq2IvXJ+w8JRFbZ8Hdu2K3XfvHs2k35EwEv9aYK27/y14fh+xxC8i0s7m//oRX7zuCprpQUuGzyJj9O1biKjKW9ETv7t/YGZrzOxwd38dOIlY2UdEpJ2N5/83zdfBPvvAtz65Hq66Oqvtx48vUGBlLKxePRcDdwU9et4Bzg4pDhEpcZs3x+4HDoTrV8yA67NL/NJeKInf3RuAdiccRESA1t46dXUtib93byI/gUq+6MpdESk9s2a1jLezZUvspd69ifwEKvnSaeI3s4vMbN9iBCMikqxNi1/yIpMW/0HAi2b2ezObZKaOUSJSAMkXaQGYsfnfpwFK/PnUaeJ39+8BhxG70nYa8KaZ/cjMPlvg2EQkSpInUwFwZ/Ok/wCU+PMpoxq/xy7v/SC47QT2Be4zsxsKGJuIVIou1OY3P/osAHvvnadYJKMa/yVmtgS4AfgrMMLdLwCOAc4ocHwiUgmCE7UZfwHMnNnSg2cLsYyvFn/+ZNLi3x/4irtPdPc/uHszgLvvBk4taHQiUlniXwCZrmvGZmIZv/f3LlGvnjwp+iBtuaitrfX6+vqwwxCJpPffh1deyWHDO+6AO+9o//rXp8LUqem3SVr244l/YQETue02OFuXemallAZpE5EysXs3jBoFH3yQy9ZTg1uSO4Nbum3aLZsIQJ8+ucQgqSjxi0haO3e2Jv0ujXmzcAGMn9B6n/x6uucAb7/NQWM+qzF38kiJX0TS2rkzdl9dDQsWdGFHdc9B3QSwibAgobxsE+G4mW1r/wuD+5kzg5q+eo7nm2r8IpLW5s2xUTH32qt16IQuiZ+cTXWSd2bwBVAGOalcpKvxK/GLSFoffwz77Rerrzc2FuANkufL7WD+XMleusSvQdpEJK34LFbxKQy7JF1XzMTXNfpmUSjxi0ha8Rp/93ycDeyovBOnfvpFocQvImnltcWfihJ9KEJJ/Ga2ysxeMbMGM1PxXqREdbnFnzziZvzxuHGpX9cXQVGE2Z3zX939wxDfX0Q60eUWf11dazJPd+JWJ3SLTqUeEUkrnvgzbvGrxV4Wwkr8DiwwsyVmNj3VCmY23czqzax+w4YNRQ5PRKC11JNxi7+jQdjS9dhRT56iCyvxj3H3UcApwLfN7ITkFdx9jrvXuntt//79ix+hiKRu8Wfbqk+YOL3D5VI0oSR+d/9HcL8eeAD4XBhxiEjHUrb4k1v16U7gdnSVrpJ9qIqe+M1sLzPrHX8MTACWFzsOEelcRid3k6dMjD9OTu6Jz7MZl1/yLowW/4HAs2b2MvAC8Gd3fzSEOESkEy3dOdf9Pbvul6l+BcyapZZ+iSh64nf3d9z9qOB2pLv/sNgxiEhmWlr8gz6TWas+fqI21a8AaJlVC1Df/RBpWGYRSSvrC7jSlXfiyT6R+u6HRv34RSStlDX+bLpf1tXF1k/+pSChUuIXkbTy2p0zkfruh0qJX0TSyvoCro4kJnvV9UOlxC8iaWU9ZENHlOxLhhK/iKSV1xa/lAwlfhFJK68tfikZSvwikpZa/JVJiV9E0lKLvzIp8YtIWmrxV6ZoJH71JhDJiVr8lSkaiV8jAYrkpOCTrUsoopH4RSS1Tn4Nq9RTmSo38Xc2OYSIdPprWKWeylTZiT+TYWRFoq6D/xNq8Vemyk38IpJa8q/h+Bj5Kb4A1OKvTKH9Oc2sG1AP/N3dTy3EeyxdClu3AmffCs+2vn744aD52yWy6uraj5Ofaqjkujp27hVbTy3+yhJmi/9SYGUh32DqVDj+eDh+7jmx++B25JHQ3FzIdxYpcfFWf1yqc2CzZqnFX6FCSfxmNhD4IvCbQr7P0UfDmDFtb926wYYNsHlzId9ZpMTFz4HFh0pOcw5MNf7KFFaLfzZwFbA73QpmNt3M6s2sfsOGDTm9yZ13wrPPtr3FSzzbt+e0S5HKkmqqxIT6/67vx74Yuj+7qKhhSWEVPfGb2anAendf0tF67j7H3WvdvbZ/HgvyvXrF7pX4RQLJE6Qk9Ibb9f1Yd89uJ40rflxSMGG0+McAXzazVcA9wIlmdmex3ry6OnavxC8SyKA7p2r8laXoid/d/8vdB7r7YGAK8IS7f71Y76/EL5KhmTM1ZEOFilw/fiV+kQzV1anFX6FCTfzuvqhQffjbCU5aVT//BADbxpykIRxEOqEWf2WKTos/OGlVfcqJAGx/6HEN4SCVJ8//ntXir0zRSfyBrHr16EtByk2ehyBXi78yRe57PKsa/6xZSv4Smi1bYP36bLcaAu/kL4aPP47dK/FXFiV+kRLU2AhDBmyjcXuvLLd8Bz6b/3hU6qkskftzdpr46+ra/lyOj2cyc6Za/1I0q1dD4/ZeVFXBwIFZbPjuOzDkn/K67v77w0knZRGDlDwl/mTx5B6/dD3VqIUiBbZjR+x+5Eior89iQ/ssvJPhv9ls1pWKErmTuy2J/8+Pp19Jc/RKWIIGR/PnjgOgasnz2XU7Thx+oYP9a2a6aItc4m/p1fPkc52v3Nl/IpF8C7odNy+K/fusOv7Y7Lodd7aeZqYTIpj44y3+bSSdNEvVEkrXq0f/SaTA4qWeHj3CjUMqU7QSf10d1VdeBMB2qtv+zM2mJRQvBeWrFSaSJD5RUFVVAd9Ev2gjK1ond+vqqB4InAdb2JttWxNObG1LXLE66XmyYPms6+Hquk7ftuesa9gjOfmPGweLFmUStURQURK/GiSRFa3ET2upZx7TmLdnurW2Qdplics7Wy9mGK/Q0Jz0n/ippzKIVqJKpR4ppGiVeoDjjoNBg6C6ezPV1WR/695MNdva35L3F6wHsIIj+UePQ9V7QjJWlBa/RFbkEv8//VPs4phtzVVs20b2t+YqtrEn27xX7D7+OHl/zVVs8178M28C0PT6ahg7NnZ+ILkr3bhx4X0gUpLiLX4lfimEyCX+vBg7tjV5Q/u+0Ak9hKqJXSm2/fCRsQSf6gSyav2SJN7iV6lHCiGMOXerzewFM3vZzF41s/K7WmrRoljCjveKSO4BlNBDqCdNADS9sExlnijK8W+uUo8UUhgt/ibgRHc/CqgBJpnZ6BDi6LoM/lPHE3+7ISLGjs1/PFJ6Mr0KPOnfkko9UkhhzLnr7r4leFoV3Mp3wJBO+kJXDxkAQFNT0gKVdyRR0heESj1SSKHU+M2sm5k1AOuBhe7+tzDiyIt0rf6gzt/z3dcAaBr/xbYXi3V1/1K68jAejko9UkihJH533+XuNcBA4HNmNjx5HTObbmb1Zla/YcOGosfYZfGpHk+fDMD2+/7ceh4gm0HgNGBc+cn0KvAOviDUj18KKezJ1huBRcCkFMvmuHutu9f279+/2KF1LsPWW8+esft2pZ4s95MR/TooLx18QajFL4UURq+e/mbWN3jcCzgZeK3YcXRZhi3xeOLffu+fUrfuUu0n11KBfh2UnmzHw4kPy/yjGwCo+v7VuvBP8i6MFv8A4EkzWwa8SKzG/1AIcRRFfIiIpkmnpW7dpZJNqUBKW7bj6Ad/+x2XXgVAj59cr2GTJe/C6NWzzN2PdveR7j7c3a8pdgw5y6El3tLiT+7OmY/JMOLDRmtijfLQ0d8kaZlKPVJIunI3GzlMYtHS4k+s8c+cmfl+MplRSRNrlIcsSnFK/FJISvwFlvLkbiazJKVbVy38cBXpc1avHikkJf5cZXjSrtPJ3WfObJ9MOmoZdtTC18QahZftCfQcv6jV4pdCUuLPVS7dOVNdvJVtv/48xFTwfUirHEtxGrJBCkmJv8DanNydNSt9ks+lZZjq10JXlVqX0FL4IgqhvNb8SqyHs0o9UghK/AWW8uQutE8m8YSbbsTPVPL5a6FUlfPxJf/tsijFNb/+NqAWvxSGEn+B9fzz/QA03XZn64vxC7fivXsgdaIvVmu3WC3aUmi95yLXnlPJX1pZHP8OYk19JX4pBCX+Aqv+z68AsJ3q1hc7SxzxlmE+y0IdiZ8Yzjax5XLdQabxdHR85foFkkryF31wrM3EMn6PSf9aWccrJcE83dWjJaS2ttbr6+vDDiMnDz4Ip50Gxm56EJyx61nddqWdO6F7innvm7a3XzeXdTIR3082+8v2vXOJNdU2+TrmXKT7WyUu37Wz/evdumf1N46XBp95Br7whRxjlcgzsyXuXpv8egf/gqXL6uoYNes37M9LfEh/muKt/nYDtnWHXal2UJ1i3VzWyUR8P9nsL9v3ziXWVNvk65hzke5vlbA81X+rXWT9Nz74YBg2LNv4RDqnUk8h1dUx0Nfywc7+bKM6s8ncv3ttbN3k23evbb9uutczvWXzXl3ZJjHeXGLs6vuGdUt3vJkcy3ev5b33YL/9wv5HLJVIpZ5iMUs/KFtn26TbNpd9ZvsemWxbqPXzsZ9sJ77Jp0zeO1+fiUgK6Uo9avEXSy7D80L7E5zjxnX9xG6qk6eJ71komXwGlXRdgk7KSqly95K/HXPMMR5JM2fG7lumKk6S7vVsxPcRf69s5LJNZzI5pmzeNx+fUSEV4jMUCQD1niKnqsVfyrIYxrfL+81lf2GWUDpbnu2volI9FpECUOIvB6lKJPELwHKRWP4ohYHdCnFdQrYXXJXzFcIiWSr6yV0zOwT4LXAQsBuY4+4/7Wibiji5m29dOSlYyicU8x1bpvsr5c9EJEeldHJ3J3C5uw8FRgPfNjP1Vs5EV1rG+WxVl1N5oqNfNJrbQCIq9O6cZvYn4GfuvjDdOmrxp5BrCzWe5Lrydy9k6zjX7pdd7bapFr9UoHQt/lATv5kNBp4Ghrv7J0nLpgPTAQYNGnTM6tWrix9gKavUxJ+rrsZUisck0kWlVOoBwMz2BuYD30lO+gDuPsfda929tn///sUPsNRlc1I2uaQB+en7X0llkVI4yS1SJKG0+M2sCngI+Iu7/6Sz9VXqyVJHZY98Xu1bKJmWbdLNR1CICWpEylDJlHrMzIB5wEfu/p1MtlHiz1JHibkcEn8m+0/+clCpRqSdUir1jAGmAieaWUNwmxxCHNGUj5JGtmWmQlC/e5GcFT3xu/uz7m7uPtLda4Lbw8WOo+JkWoMv9oTs+Zp8pTOq0YtkLPTunJlQqSdLpVT2yOeopKrpi2SllEo9UukK1QMo17lvRaQNJf5KFHbZoysJOt1w1EruInmjUo8UVqHGFApzghWRMqFSj4SjUL8+lPRFcqbEL4XVlQQddslKpEIp8UvpUqtepCCU+EVEIkaJX0QkYpT4RUQiRolfRCRilPhFRCKmLC7gMrMNQK5TcO0PfJjHcMKkYyk9lXIcoGMpVV05lkPdvd1MVmWR+LvCzOpTXblWjnQspadSjgN0LKWqEMeiUo+ISMQo8YuIREwUEv+csAPIIx1L6amU4wAdS6nK+7FUfI1fRETaikKLX0REEijxi4hETCQSv5n9PzNbZmYNZrbAzA4OO6ZcmdmNZvZacDwPmFnfsGPKhZmdaWavmtluMyvLbndmNsnMXjezt8xsRtjx5MrMbjOz9Wa2POxYusLMDjGzJ81sZfBv69KwY8qVmVWb2Qtm9nJwLCkmm+7C/qNQ4zezfdz9k+DxJcAwd/9WyGHlxMwmAE+4+04zux7A3a8OOaysmdlQYDfwK+AKdy+rKdbMrBvwBjAeWAu8CJzl7itCDSwHZnYCsAX4rbsPDzueXJnZAGCAuy81s97AEuDfyvRvYsBe7r7FzKqAZ4FL3X1xPvYfiRZ/POkH9gLK9tvO3Re4+87g6WJgYJjx5MrdV7r762HH0QWfA95y93fcfQdwD3BayDHlxN2fBj4KO46ucvf33X1p8HgzsBL4TLhR5cZjtgRPq4Jb3vJWJBI/gJn90MzWAF8DfhB2PHlyDvBI2EFE1GeANQnP11KmSaYSmdlg4GjgbyGHkjMz62ZmDcB6YKG75+1YKibxm9ljZrY8xe00AHf/rrsfAtwFXBRutB3r7FiCdb4L7CR2PCUpk+MoY5bitbL9JVlJzGxvYD7wnaRf+2XF3Xe5ew2xX/WfM7O8leG652tHYXP3kzNc9XfAn4GSndC1s2Mxs28ApwIneQmfpMnib1KO1gKHJDwfCPwjpFgkENTD5wN3ufv9YceTD+7eaGaLgElAXk7AV0yLvyNmdljC0y8Dr4UVS1eZ2STgauDL7r417Hgi7EXgMDMbYmY9gCnAgyHHFGnBCdFbgZXu/pOw4+kKM+sf77FnZr2Ak8lj3opKr575wOHEepGsBr7l7n8PN6rcmNlbQE9gY/DS4nLsoWRmpwO3AP2BRqDB3SeGGlSWzGwyMBvoBtzm7j8MN6LcmNndwDhiw/+uA2a6+62hBpUDM/sC8AzwCrH/6wD/7e4PhxdVbsxsJDCP2L+tPYDfu/s1edt/FBK/iIi0ikSpR0REWinxi4hEjBK/iEjEKPGLiESMEr+ISMQo8YtkKRgF8l0z2y94vm/w/NCwYxPJhBK/SJbcfQ3wS+C64KXrgDnuvjq8qEQyp378IjkIhgZYAtwGnAccHYzSKVLyKmasHpFicvdmM7sSeBSYoKQv5USlHpHcnQK8D5Tt5CUSTUr8Ijkwsxpis2+NBi4LZn8SKQtK/CJZCkaB/CWx8d7fA24Ebgo3KpHMKfGLZO884D13Xxg8/wVwhJmNDTEmkYypV4+ISMSoxS8iEjFK/CIiEaPELyISMUr8IiIRo8QvIhIxSvwiIhGjxC8iEjH/H+BexcG+P09EAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "### try GradientBoosting Manually\n",
    "## Using Decision Trees\n",
    "\n",
    "tree_reg1 = DecisionTreeRegressor(max_depth=2)\n",
    "tree_reg1.fit(X, y)\n",
    "\n",
    "##\n",
    "\n",
    "y2 = y - tree_reg1.predict(X)\n",
    "tree_reg2 = DecisionTreeRegressor(max_depth=2)\n",
    "tree_reg2.fit(X, y2)\n",
    "\n",
    "### \n",
    "y3 = y2 - tree_reg2.predict(X)\n",
    "tree_reg3 = DecisionTreeRegressor(max_depth=2)\n",
    "tree_reg3.fit(X, y3)\n",
    "\n",
    "\n",
    "#### final Prediction\n",
    "X_new = np.linspace(-3,3,500).reshape(-1,1)\n",
    "y_pred_manually = sum(tree.predict(X_new) for tree in (tree_reg1, tree_reg2, tree_reg3))\n",
    "\n",
    "## Plotting\n",
    "plt.plot(X, y, 'r+', label='Xy values')\n",
    "plt.plot(X_new, y_pred_manually, linewidth=2, c='b', label='RL fitted')\n",
    "plt.title('GBRT manually')\n",
    "plt.xlabel('X')\n",
    "plt.ylabel('y')\n",
    "plt.legend();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c7105f4",
   "metadata": {},
   "source": [
    "#### Using GradientBoosting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "e81d5f90",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "### (n_estimators=3) just for example as i did above\n",
    "# if you think your Model is Overfitting , you can regularize the Model using learning_rate \n",
    "# this technique of Regularization is called (Shrinkage)\n",
    "\n",
    "gbrt = GradientBoostingRegressor( n_estimators=3, \n",
    "                                 learning_rate=1, random_state=42,loss='ls') \n",
    "## ls refers to leat squares\n",
    "\n",
    "gbrt.fit(X, y)\n",
    "\n",
    "#### final Prediction\n",
    "X_new = np.linspace(-3,3,500).reshape(-1,1)\n",
    "y_pred_gbrt = gbrt.predict(X_new)\n",
    "\n",
    "## Plotting\n",
    "plt.plot(X, y, 'r+', label='Xy values')\n",
    "plt.plot(X_new, y_pred_gbrt, linewidth=2, c='b', label='RL fitted')\n",
    "plt.title('GBRT API')\n",
    "plt.xlabel('X')\n",
    "plt.ylabel('y')\n",
    "plt.legend();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d925548",
   "metadata": {},
   "source": [
    "#### trade-off between (learning_rate & n_estimators)\n",
    "` Reducing of learning_rate requires incresing n_estimators, it will need more trees to fit`<br />\n",
    "\n",
    "\n",
    "` Low learning_rate >>> High n_estimators`  <br />\n",
    "` High learning_rate >>> Low n_estimators`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "f4776ed8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x216 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "gbrt1 = GradientBoostingRegressor(n_estimators=100, learning_rate=0.1, criterion='mse')\n",
    "gbrt2 = GradientBoostingRegressor(n_estimators=3, learning_rate=1, criterion='mse')\n",
    "\n",
    "gbrt1.fit(X, y)\n",
    "gbrt2.fit(X, y)\n",
    "\n",
    "#### final Prediction\n",
    "X_new = np.linspace(-3,3,500).reshape(-1,1)\n",
    "y_pred_gbrt1 = gbrt1.predict(X_new)\n",
    "y_pred_gbrt2 = gbrt2.predict(X_new)\n",
    "\n",
    "\n",
    "### plotting\n",
    "\n",
    "fig, axes = plt.subplots(ncols=2, sharey=True, figsize=(10,3))\n",
    "\n",
    "plt.sca(axes[0])\n",
    "plt.plot(X, y, 'r+', label='Xy values')\n",
    "plt.plot(X_new, y_pred_gbrt1, linewidth=2, c='b', label='RL GBRT')\n",
    "plt.title(f'n_estimators={gbrt1.n_estimators_} ,eta ={gbrt1.learning_rate}')\n",
    "plt.xlabel('X')\n",
    "plt.ylabel('y')\n",
    "plt.legend()\n",
    "\n",
    "plt.sca(axes[1])\n",
    "plt.plot(X, y, 'r+', label='Xy values')\n",
    "plt.plot(X_new, y_pred_gbrt2, linewidth=2, c='b', label='RL GBRT')\n",
    "plt.title(f'n_estimators={gbrt2.n_estimators_} ,eta ={gbrt2.learning_rate}')\n",
    "plt.xlabel('X')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf50d6bd",
   "metadata": {},
   "source": [
    "#### early stopping method \n",
    "\n",
    "`using (staged_predcit) Method for early stopping`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "6ae4821c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "errors shape = (n_estimators[1....150]) ===> 150\n",
      "n_best_estimator => 33\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "### split the data\n",
    "X_train, X_val, y_train, y_val = train_test_split(X, y, \n",
    "                                                  test_size=0.2, \n",
    "                                                  random_state=42, shuffle=True)\n",
    "\n",
    "### for each n_estimators it will iterate from 1 to 150 and each time get the model fitted\n",
    "### and each time predict  get error and so on\n",
    "### you can get the argmin where the minimum is minmized as possible as it is before it returns up\n",
    "### get this index from n_estimators , then this n_estimators is the best \n",
    "### under other conditions of learning_rate and max_depth\n",
    "gbrt_new = GradientBoostingRegressor(n_estimators=150, learning_rate=1.0, max_depth=2)\n",
    "gbrt_new.fit(X_train, y_train)\n",
    "\n",
    "\n",
    "errors = [mean_squared_error(y_val, y_pred) for y_pred in gbrt_new.staged_predict(X_val)]\n",
    "\n",
    "print('errors shape = (n_estimators[1....150]) ===>', len(errors))\n",
    "\n",
    "### get argmin\n",
    "\n",
    "### increse one as n_estimators starts from 1 \n",
    "### and argmin starts from 0\n",
    "n_best_estimator = np.argmin(errors) + 1 \n",
    "print('n_best_estimator =>', n_best_estimator)\n",
    "\n",
    "\n",
    "\n",
    "### some plottings\n",
    "\n",
    "estimators = np.arange(1, 151)\n",
    "plt.plot(estimators, errors, 'b', label='Errors')\n",
    "\n",
    "plt.vlines(x=33, ymin=0.1, ymax=0.45, colors='gray', label='n_estimators=33')\n",
    "\n",
    "plt.xlabel('n_estimators')\n",
    "plt.ylabel('Error (MSE)')\n",
    "plt.legend()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "20d02370",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "### modify the n_estimators to be 11\n",
    "\n",
    "gbrt_final = GradientBoostingRegressor(n_estimators=33, learning_rate=1.0, max_depth=2)\n",
    "gbrt_final.fit(X_train, y_train)\n",
    "\n",
    "#### final Prediction\n",
    "X_new = np.linspace(-3, 3, 500).reshape(-1,1)\n",
    "y_pred_final = gbrt_final.predict(X_new)\n",
    "\n",
    "plt.plot(X, y, 'r+', label='Xy values')\n",
    "plt.plot(X_new, y_pred_final, linewidth=2, c='b', label='RL GBRT')\n",
    "plt.text(-3, 6, 'Best Model', fontsize=20, c='g')\n",
    "plt.text(0, 7, 'AGOOR', fontsize=20, c='k')\n",
    "plt.title(f'n_estimators={gbrt_final.n_estimators_}, eta ={gbrt_final.learning_rate}')\n",
    "plt.xlabel('X', fontsize=12)\n",
    "plt.ylabel('y', fontsize=12)\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c41a8d18",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "9a739746",
   "metadata": {},
   "source": [
    "## XGBoost \n",
    "`Extreme Gradient Boosting`  <br />\n",
    "`XgBoost is very powerfull API and also offers several nice features such as (early stopping)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "d9188335",
   "metadata": {},
   "outputs": [],
   "source": [
    "xgb_reg = xgb.XGBRegressor()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "35cd5a57",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "XGBRegressor(base_score=0.5, booster='gbtree', colsample_bylevel=1,\n",
       "             colsample_bynode=1, colsample_bytree=1, gamma=0, gpu_id=-1,\n",
       "             importance_type='gain', interaction_constraints='',\n",
       "             learning_rate=0.300000012, max_delta_step=0, max_depth=6,\n",
       "             min_child_weight=1, missing=nan, monotone_constraints='()',\n",
       "             n_estimators=100, n_jobs=8, num_parallel_tree=1, random_state=0,\n",
       "             reg_alpha=0, reg_lambda=1, scale_pos_weight=1, subsample=1,\n",
       "             tree_method='exact', validate_parameters=1, verbosity=None)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "xgb_reg.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "3ee01da1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "rmse_logError => 0.1129976878550634\n"
     ]
    }
   ],
   "source": [
    "rmse_logError = (mean_squared_log_error(y_val, xgb_reg.predict(X_val)))**0.5\n",
    "\n",
    "print('rmse_logError =>', rmse_logError)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6aa27b38",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "16756f9b",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}