basic_tecnhiques.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "fd774be7",
   "metadata": {},
   "source": [
    "# Hyperparameter optimization\n",
    "\n",
    "Hyperparameter optimization in machine learning intends to find the hyperparameters of a given machine learning algorithm that deliver the best performance as measured on a validation set.\n",
    "\n",
    "While model parameters are learned during training — such as the slope and intercept in a linear regression — hyperparameters must be set by the data scientist before training. \n",
    "\n",
    "\n",
    "The core algorithms for hyperparameter optimization, found in the Scikit-learn package, are __grid search and random search__. Recently, the Scikit-learn contributors have also added the halving algorithm to improve the performances of both grid search and random search strategies.\n",
    "\n",
    "Hyperparameters can have a direct impact on the training of machine learning algorithms. Thus, to achieve maximal performance, it is important to understand how to optimize them. Here we will use basic strategies for optimizing hyperparameters:\n",
    "\n",
    "*__1. Grid search__*\n",
    "\n",
    "*__2. Random search__*\n",
    "\n",
    "*__3. Halving random search__*\n",
    "\n",
    "*__4. Halving grid search__*\n",
    "\n",
    "*__5. Comparision__*"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "089ff0bb",
   "metadata": {},
   "source": [
    "## Import libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 268,
   "id": "f7419c6b",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.datasets import make_classification\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn import svm\n",
    "import scipy.stats as stats\n",
    "from sklearn.utils.fixes import loguniform\n",
    "from sklearn import model_selection\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.model_selection import RandomizedSearchCV\n",
    "from sklearn.experimental import enable_halving_search_cv\n",
    "from sklearn.model_selection import HalvingRandomSearchCV\n",
    "from sklearn.model_selection import HalvingGridSearchCV\n",
    "from time import time\n",
    "from tqdm import tqdm\n",
    "import matplotlib.pyplot as plt \n",
    "import itertools\n",
    "import seaborn as sns\n",
    "import scipy\n",
    "from sklearn.metrics import confusion_matrix\n",
    "import pandas as pd\n",
    "import warnings\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "import numpy as np\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "edd50cdd",
   "metadata": {},
   "source": [
    "Generate a random dataset for classification problem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "id": "e664011d",
   "metadata": {},
   "outputs": [],
   "source": [
    "X, y = make_classification(n_samples=100, n_features=50,\n",
    "                           n_informative=10,\n",
    "                           n_redundant=25, n_repeated=15,\n",
    "                           n_clusters_per_class=5,\n",
    "                           flip_y=0.05, class_sep=0.1,\n",
    "                           random_state=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bfe1a3bf",
   "metadata": {},
   "source": [
    "## Grid Search\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e894118c",
   "metadata": {},
   "source": [
    "Grid search is a tuning technique that attempts to compute the optimum values of hyperparameters. It is an exhaustive search that is performed on a the specific parameter values of a model. The model is also known as an estimator.\n",
    "\n",
    "Basically, we divide the domain of the hyperparameters into a discrete grid. Then, we try every combination of values of this grid, calculating some performance metrics using cross-validation. The point of the grid that maximizes the average value in cross-validation, is the optimal combination of values for the hyperparameters.\n",
    "\n",
    "\n",
    "\n",
    "![alt text](https://www.yourdatateacher.com/wp-content/uploads/2021/03/image-6.png)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "78e4c4e7",
   "metadata": {},
   "outputs": [],
   "source": [
    "svc = svm.SVC()\n",
    "svc = svm.SVC(probability=True, random_state=1)\n",
    "\n",
    "search_grid = [\n",
    "               {'C': [1, 10, 100, 1000], 'kernel': ['linear']},\n",
    "               {'C': [1, 10, 100, 1000], 'gamma': [0.001, 0.0001],\n",
    "               'kernel': ['rbf']}\n",
    "               ]\n",
    "scorer = 'accuracy'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "90d07dbe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'C': 10, 'gamma': 0.001, 'kernel': 'rbf'}\n",
      "0.7\n"
     ]
    }
   ],
   "source": [
    "search_func = GridSearchCV(estimator=svc, param_grid=search_grid, scoring=scorer, n_jobs=-1, cv=5)\n",
    "search_func.fit(X, y)\n",
    "\n",
    "print(search_func.best_params_)\n",
    "print(search_func.best_score_)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8e8ce9e",
   "metadata": {},
   "source": [
    "## Random Search\n",
    "\n",
    "Random search is similar to grid search, but instead of using all the points in the grid, it tests only a randomly selected subset of these points. The smaller this subset, the faster but less accurate the optimization. The larger this dataset, the more accurate the optimization but the closer to a grid search.\n",
    "\n",
    "Random search is a very useful option when you have several hyperparameters with a fine-grained grid of values. Using a subset made by 5-100 randomly selected points, we are able to get a reasonably good set of values of the hyperparameters. It will not likely be the best point, but it can still be a good set of values that gives us a good model.\n",
    "\n",
    "\n",
    "![alt text](https://www.yourdatateacher.com/wp-content/uploads/2021/03/image-7.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "e426ea82",
   "metadata": {},
   "outputs": [],
   "source": [
    "search_dict = {'kernel': ['linear', 'rbf'],\n",
    "               'C': loguniform(1, 1000),'gamma': loguniform(0.0001, 0.1)\n",
    "               }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "f642a5b4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'RandomizedSearchCV'"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "search_func = RandomizedSearchCV(estimator=svc,\n",
    "                                                 param_distributions=search_dict,\n",
    "                                                 n_iter=6,\n",
    "                                                 scoring=scorer,\n",
    "                                                 n_jobs=-1,\n",
    "                                                 cv=5\n",
    "                                                 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "097e6986",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'C': 283.5142995458433, 'gamma': 0.00011814677561970462, 'kernel': 'rbf'}\n",
      "0.6966666666666667\n"
     ]
    }
   ],
   "source": [
    "search_func = RandomizedSearchCV(estimator=svc,\n",
    "                                                 param_distributions=search_dict,\n",
    "                                                 n_iter=6,\n",
    "                                                 scoring=scorer,\n",
    "                                                 n_jobs=-1,\n",
    "                                                 cv=5\n",
    "                                                 )\n",
    "    \n",
    "search_func.fit(X, y)\n",
    "\n",
    "print(search_func.best_params_)\n",
    "print(search_func.best_score_)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73ee6ddb",
   "metadata": {},
   "source": [
    "# Halving grid search\n",
    "\n",
    "\n",
    "Halving Grid Search, a new class of successive Halving, where training is performed on the subsets of data, rather than on all the data. The worst performing data are filtered out by training them on a small subset of data. After N number iterations select the best data/candidates leading to a faster evaluation time.\n",
    "\n",
    "The search strategy starts evaluating all the candidates with a small amount of resources and iteratively selects the best candidates, using more and more resources."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "id": "d7f79930",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'C': 1000, 'kernel': 'linear'}\n",
      "0.6166666666666667\n"
     ]
    }
   ],
   "source": [
    "search_func = HalvingGridSearchCV(estimator=svc, param_grid=search_grid,\n",
    "                                    resource='n_samples',\n",
    "                                    max_resources=100,\n",
    "                                    aggressive_elimination=True,\n",
    "                                    scoring=scorer,\n",
    "                                    n_jobs=-1,\n",
    "                                    cv=5,\n",
    "                                    random_state=0)\n",
    "\n",
    "search_func.fit(X, y)\n",
    "print(search_func.best_params_)\n",
    "print(search_func.best_score_)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f90b31e",
   "metadata": {},
   "source": [
    "# Halving random search\n",
    "\n",
    "As we mentioned, both grid search and random search work in an uninformed way: if some tests find out that certain hyperparameters do not impact the result or that certain value intervals are ineffective, the information is not propagated to the following searches.\n",
    "\n",
    "For this reason, Scikit-learn has recently introduced the HalvingGridSearchCV and HalvingRandomSearchCV estimators, which can be\n",
    "used to search a parameter space using successive halving applied to the grid search and random search tuning strategies.\n",
    "\n",
    "\n",
    "Halving randomized search also uses the same successive halving approach. Unlike halving grid search, it trains just randomly selected combinations of parameters on a portion of the training data.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "0b0edf8c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'C': 86.63279761354555, 'gamma': 0.002054762512591133, 'kernel': 'linear'}\n",
      "0.6166666666666667\n"
     ]
    }
   ],
   "source": [
    "search_func = HalvingRandomSearchCV(estimator=svc, param_distributions=search_dict,\n",
    "                                    resource='n_samples',\n",
    "                                    max_resources=100,\n",
    "                                    aggressive_elimination=True,\n",
    "                                    scoring=scorer,\n",
    "                                    n_jobs=-1,\n",
    "                                    cv=5,\n",
    "                                    random_state=0)\n",
    "\n",
    "search_func.fit(X, y)\n",
    "\n",
    "print(search_func.best_params_)\n",
    "print(search_func.best_score_)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a0905a98",
   "metadata": {},
   "source": [
    "# Comparision"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "91b5dab9",
   "metadata": {},
   "source": [
    "Here, I have written a class where we should input X, y, paramater space and metric score which hyperparamater optimization strategy should maximize.\n",
    "\n",
    "Class has two methods:\n",
    "\n",
    "1. show_confusion_matrix() - run all strategies and evaluate models. Then show confusion matrix for each strategy.\n",
    "\n",
    "2. run_and_show_results() - runs all strageties and return dataframe that has following features: name, best_params,\tbest_score,\trun_time\n",
    "\n",
    "We can change:\n",
    "\n",
    "1. estimator - select your favorite estimator for modeling. :)\n",
    "\n",
    "2. p_space - if you dont mind estimator, but want to change paramater space, just define a dictionary and write down your own space. ps: if you have changed estimator, dont forget to change p_space as well. \n",
    "\n",
    "3. metric - Not sure about accuracy? No problem. Evaluate your strategies with roc_auc, f1_score, and etc.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 269,
   "id": "057e93c7",
   "metadata": {},
   "outputs": [],
   "source": [
    "class CompareSearchMethods:\n",
    "    \n",
    "    \"\"\"\n",
    "    This is a class for tuning hyperparameters using search methods.\n",
    "    Methods must be GridSearchCV HalvingGridSearchCV, GridSearchCV and RandomizedSearchCV.\n",
    "    \n",
    "    Inputs:\n",
    "        X, y: dataset\n",
    "        estimator: Logistic regression, SVM, KNN, etc\n",
    "        p_space: parameter space\n",
    "        metric_score: evaluation metric\n",
    "        \n",
    "    Output:\n",
    "    \n",
    "        Returns the metric of estimator instance\n",
    "    \n",
    "    \"\"\"   \n",
    "    def __init__(self, X, y, estimator = svm.SVC(probability=True, random_state=1), random_p_space = {}, grid_p_space = {}, metric_score = 'accuracy'):\n",
    "        \n",
    "        self.X = X\n",
    "        self.y = y\n",
    "        self.estimator = estimator\n",
    "        self.random_p_space = random_p_space\n",
    "        self.grid_p_space = grid_p_space\n",
    "        self.metric_score = metric_score\n",
    "        \n",
    "    def _methods_with_parameters(self):\n",
    "        \n",
    "        self.grid_p = [\n",
    "                   {'C': [1, 10,100], 'kernel': ['linear']},\n",
    "                   {'C': [1, 10,100], 'gamma': [0.001, 0.01],'kernel': ['rbf']} ]\n",
    "            \n",
    "        self.random_p = {'kernel': ['linear', 'rbf'], 'C': loguniform(1, 100),'gamma': loguniform(0.01, 0.1)}\n",
    "                           \n",
    "        self.grid_search = GridSearchCV(estimator=self.estimator, param_grid=self.grid_p , scoring=self.metric_score, n_jobs=-1, cv=5)\n",
    "        self.rand_search = RandomizedSearchCV(estimator=self.estimator, param_distributions=self.random_p, n_iter=6, scoring=self.metric_score, n_jobs=-1, cv=5)\n",
    "        self.halving_rand_search = HalvingRandomSearchCV(estimator=self.estimator, param_distributions=self.random_p, resource='n_samples', max_resources=100, aggressive_elimination=True, scoring=self.metric_score, n_jobs=-1, cv=5, random_state=0)\n",
    "        self.halving_grid_search = HalvingGridSearchCV(estimator=self.estimator, param_grid=self.grid_p, resource='n_samples', max_resources=100, aggressive_elimination=True, scoring=self.metric_score,n_jobs=-1,cv=5,random_state=0)\n",
    "        \n",
    "        return [self.grid_search, self.rand_search, self.halving_rand_search, self.halving_grid_search]\n",
    "\n",
    "    \n",
    "    def _model_fit(self, X, y, method):\n",
    "        tic = time()\n",
    "        \n",
    "        method.fit(X, y)\n",
    "        name = str(method).split('(')[0]\n",
    "        best_params = method.best_params_\n",
    "        best_score = method.best_score_\n",
    "        run_time = time() - tic\n",
    "        \n",
    "        func_result = {'name':name, 'best_params': method.best_params_, 'best_score':method.best_score_, 'run_time':run_time}\n",
    "        self.cfmatrixes = confusion_matrix(y_true=y, y_pred=method.predict(X))        \n",
    "        return func_result\n",
    "        \n",
    "    def _search_funct_fit_evaluate(self):\n",
    "        \n",
    "        \n",
    "        self.conf_matrix_list = []\n",
    "        self.search_functions_results = []\n",
    "        self.search_methods = self._methods_with_parameters()\n",
    "        \n",
    "        if len(self.grid_p_space)==0:\n",
    "            \n",
    "            for method in tqdm(self.search_methods):\n",
    "                self.search_functions_results.append(self._model_fit(self.X, self.y, method))\n",
    "                self.conf_matrix_list.append(self.cfmatrixes)\n",
    "            \n",
    "            return self.search_functions_results\n",
    "        \n",
    "        else:\n",
    "            \n",
    "            for method in tqdm(self.search_methods):\n",
    "                method.param_grid = self.grid_p_space\n",
    "                method.param_distributions = self.random_p_space\n",
    "                self.search_functions_results.append(self._model_fit(self.X, self.y, method))\n",
    "                self.conf_matrix_list.append(self.cfmatrixes)\n",
    "            return self.search_functions_results\n",
    "    \n",
    "            \n",
    "    def show_confusion_matrix(self):\n",
    "        for i, k in zip(self.conf_matrix_list, self.search_methods):\n",
    "            \n",
    "            ax = sns.heatmap(i, annot=True, cmap='Blues')\n",
    "\n",
    "            ax.set_title(str(k).split('(')[0]);\n",
    "            ax.set_xlabel('\\nPredicted Values')\n",
    "            ax.set_ylabel('Actual Values ');\n",
    "\n",
    "            ax.xaxis.set_ticklabels(['False','True'])\n",
    "            ax.yaxis.set_ticklabels(['False','True'])\n",
    "\n",
    "            plt.show()\n",
    "            \n",
    "    def run_and_show_results(self):\n",
    "        \n",
    "        self.search_functions_results = self._search_funct_fit_evaluate()\n",
    "        result_df = pd.DataFrame(self.search_functions_results).sort_values('best_score', ascending = False)\n",
    "        return result_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 270,
   "id": "fa06ca4b",
   "metadata": {},
   "outputs": [],
   "source": [
    "comparing = CompareSearchMethods(X,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 271,
   "id": "098c40b9",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████| 4/4 [00:09<00:00,  2.45s/it]\n"
     ]
    }
   ],
   "source": [
    "result_df = comparing.run_and_show_results()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 272,
   "id": "d42a6af0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXIAAAEiCAYAAADkqln+AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAok0lEQVR4nO3debxd0/3/8df73iRCjCGGSMy0UiWm0BpqqkZqLK0Yq1NQ8SulRWlRbb9a1aKUJsTQpmZa1ZRE0OBrSBASYkg1iIRQMkpl+vz+2Ot+ndzce865yTn3nH29nx77cc8e1lqfe3J9zjprr723IgIzM8uvhloHYGZmK8aJ3Mws55zIzcxyzonczCznnMjNzHLOidzMLOecyG0Zki6Q9Kcq1LuRpLmSGitc7xRJ+1WyzhVVjzFZx+VEniMpOcxPyfBtSTdIWrXWcZUrIt6IiFUjYnG12pC0pqRh6f2ZI+kVSWdVq73lJWl1SZdJeiP9e05O6+tIul/ST1soc0j6vTrVImarX07k+XNQRKwK9AW2B86pbTh157fAqsDWwBrAwcC/Kt3IiiRTSV2A0cBngP7A6sDngf8A/YAbgOMkqVnR44DhEbFoedu2jsmJPKci4m3gfrKEjqSzJf0r9UJflHRY07GSTpD0qKRfS/pA0r8lHVCwf1NJ/0xlRwHrFLYl6WBJL0iaKelhSVsX7Jsi6QeSnpc0T9J1ktaT9I9U3wOS1krHbiIpJHWS9LnUE21a/itpSjquoeD3+Y+k2yR1L2jzOEmvp33nNntrdgb+HBEfRMSSiHgpIu4oKPtpSaMkvS/pZUlfK9j3ZUnPSpot6U1JFxTsa4r9W5LeAB5M278jaVLB+75DQSx90/syS9Ktkrqm7ccDGwGHRcSLKc4ZEXFRRIwA/gJ0B/YoaH8t4EDgphb/IOyTLSK85GQBpgD7pde9gAnA5Wn9q0BPsg/nI4F5wAZp3wnAQuA7QCNwMjANUNr/OPAbYCVgT2AO8Ke0b6tU1xeBzsAPgclAl4KYngDWAzYEZgDPkH1bWIks4Z2fjt0ECKBTs9+rM/Aw8D9p/bRUZ69Uxx+Am9O+PsDcFOdKKe5FBe/LtcALwDeALZu10w14M+3rBOwAvAd8Ju3fC/hseg+3Bd4BDm0W+02pnpXTe/4W2YeHgC2AjQvel6fSv0l3YBJwUtp3C3BjiX/rocC1BesnAuNr/TfopT6XmgfgpQ3/WFlymJsSbZB9PV+zlWPHA4ek1ycAkwv2rZLKr0/WM1wEdCvY/+eCRP5j4LaCfQ0pee1VENMxBfvvBK4uWD8V+Et63Voivxr4O9CQ1icB+xbs34Dsg6gT8BPgloJ93YAFBYl8ZeBHwNOpzGTggLTvSOCRZm3/gfRB08J7eBnw22axb1aw/37ge0X+rY4tWP8VcE16PQq4uMS/9e7ALGDltP4YcHqt/wa91OfioZX8OTQiViPrPX6aNAwi6XhJ49Pwx0xgG5YeInm76UVEfJherkrWY/wgIuYVHPt6weuehesRsYSsV7thwTHvFLye38J6qydkJZ2YfpejU90AGwN3F/wuk4DFZL3+nqn9pnjmkY0tN63Pj4hfRMSOwNrAbcDtaWhmY2CXpnpT3ceQfaAhaRdJD0l6V9Is4CSaDTMVtg30pvj4+9sFrz8seB/+Q/bh1KqIeBR4FzhE0makIaNiZeyTy4k8pyLin2QnxX4taWOyr+KDgbUjYk1gItnX/VKmA2tJ6lawbaOC19PIEiAA6QRcb7Je+QqRtAdwEdk3h1kFu94k60WvWbB0jYi3Ury9C+pYhSxhLyMiZgO/IOu1b5rq/WezeleNiJNTkT8D9wC9I2IN4BqWfQ8Lbxf6JrD5cvzqDwBfavaet+QmsvH044CREfFOiePtE8qJPN8uIxu73pAswbwLIOkbZD3ykiLidWAccKGkLpJ2Bw4qOOQ24MuS9pXUGTgD+Aj43xUJXFJv4Fbg+Ih4pdnua4Cfpw8oJPWQdEjadwdwoKTd0+yPn1Lwdyzpx5J2Tr9LV+B7wEzgZeBeYKt0srRzWnYuOHm7GvB+RPxXUj/g6BK/xrXAmZJ2VGaLpphL+CPZh8Cd6eRrg6S1Jf1I0oCC424C9iM7t3FjGfXaJ5QTeY5FxLtk/7OfAVxKdtLyHbITdo+1oaqjgV2A94HzKZgZEREvA8cCvyM7MXgQ2RTIBSsY/r5kQxp3FMxceSHtu5ysZzxS0hyyE5+7pHheAE4h6z1PBz4AphbUG8D1KdZpZB90X46IuRExB9gfGJj2vQ38kuykKcB3gZ+mNn9C9iHWqoi4Hfh5imUOH882KSoiPiJL0C+RjZfPJjsxug7wZMFxU8g+MLul98OsRU2zFszMLKfcIzczyzkncjOzCpLUVdJTkp5LF9JdmLZfIOmtNLtsfLPzIYXl+6eL1SZLOrusNj20YmZWOWlmV7eImJsmCDxKdtK9PzA3In5dpGwj8ArZuZ2pwFjgqIh4sVib7pGbmVVQZOam1c5pKbfH3I/s4r3X0oSCW4BDSpRxIjczqzRJjZLGk92yYlRENM1GGpzuvzMs3T+nuQ1Z+qKzqSx98V2L6vZ2mKsPvMljPraMcZcfUesQrA5ttd4q5Vz8VtTK2w8uO+f8d/xVJwKDCjYNiYghTSuR3aq5r6Q1ya5S3obsVhQXkfXOLyKbMvzNZlW39HuUjKtuE7mZWbtqKP95JylpDynjuJmSHgb6F46NSxpKdoFac1MpuHKZ7MZx00q146EVMzMANZS/FKsmuxJ5zfR6ZdLFX5IK769zGNltNJobC2yp7NbSXcguXit5MZh75GZmAMs8x2O5bQDcmGagNJDdPfReSX+U1JdsqGQK2a2JkdST7JbFAyJikaTBZHfWbASGpauZi3IiNzODkj3tckXE82T342++/bhWjp8GDChYHwGMaEubTuRmZlDJHnm7cyI3M4OK9chrwYnczAzaNGul3jiRm5mBh1bMzHLPQytmZjnnHrmZWc65R25mlnNO5GZmOdfoWStmZvnmMXIzs5zz0IqZWc65R25mlnPukZuZ5Zwv0TczyzkPrZiZ5ZyHVszMcs49cjOznHOP3Mws5yqUyCV1BcYAK5Hl2Dsi4nxJlwAHAQuAfwHfiIiZLZSfAswBFgOLImKnUm3m9yPIzKySGhrLX4r7CNgnIrYD+gL9Je0KjAK2iYhtgVeAc4rUsXdE9C0niYMTuZlZRip/KSIyc9Nq57RERIyMiEVp+xNAr0qF7kRuZgbZ0Eq5S6mqpEZJ44EZwKiIeLLZId8E/tFK8QBGSnpa0qByQnciNzODNvXIJQ2SNK5gWSrhRsTiiOhL1uvuJ2mbj5vRucAiYHgrkewWETsABwCnSNqzVOg+2WlmBqgN0w8jYggwpIzjZkp6GOgPTJT0deBAYN+IiFbKTEs/Z0i6G+hHdvK0Ve6Rm5kBalDZS9F6pB6S1kyvVwb2A16S1B84Czg4Ij5spWw3Sas1vQb2ByaWit09cjMz2tYjL2ED4EZJjWSd5dsi4l5Jk8mmJI5KbT0RESdJ6glcGxEDgPWAu9P+TsCfI+K+Ug06kZuZUblEHhHPA9u3sH2LVo6fBgxIr18Dtmtrm07kZmZUtEfe7pzIzcxwIjczy7/85nEncjMzgIaG/E7icyI3M8NDK2ZmuedEbmaWd/nN407kZmbgHrmZWe45kZuZ5Vype6jUMydyMzPcIzczy708J/KqzoCXtIqkH0samta3lHRgNds0M1seyh4YUdZSb6p9KdP1ZA8i/Vxanwr8rMptmpm1mRN56zaPiF8BCwEiYj65nq1pZh1VpR4sUQvVHiNfkJ6QEQCSNifroZuZ1ZV67GmXq9qJ/HzgPqC3pOHAbsAJVW7TzKzNnMhbERGjJD0D7Eo2pPK9iHivmm2amS2X/Obx6iZySbsB4yPi75KOBX4k6fKIeL2a7ebZSp0buO/8/nTp3ECnhgb++uTr/OKO57jomB05YIdeLFi0hH+/M4fvXvMYsz5cWOtwrZ1cfvEFjP3fMayxVneuuvEOAF579WV+f+nPWbDgIxobGzn59B+xVZ9tahxpfuW5R17tk51XAx9K2g74AfA6cFOV28y1jxYu4cCLRrLbWfey29l/Y7++Pdl5i3V4aMI0dvnBPXz+rL8x+e3ZfP/Qz9Y6VGtH+/Y/iAsuuWqpbddffRkDTxjEFcNu5Zhvnsz111xWm+A6iErNWpHUVdJTkp6T9IKkC9P27pJGSXo1/VyrlfL9Jb0sabKks8uJvdqJfFFEBHAIcEVEXA6sVuU2c2/eR4sA6NzYQKfGBgJ48PnpLF4SAIx99V027L5KDSO09rZN3x1ZbfU1ltomifnz5gEwb95cuq/ToxahdRgNDQ1lLyV8BOwTEdsBfYH+knYFzgZGR8SWwOi0vhRJjcBVwAFAH+AoSX1KNVjtk51zJJ0DHAvsmYLsXOU2c69BYsz/fJnN1l+NoSNfZtzkpU8rHLfXFtz1+JTaBGd14zunnslPzjyFYb//LUtiCZf8/oZah5RvFRpZSZ3XuWm1c1qaOrR7pe03Ag8DZzUr3g+YHBGvAUi6JZV7sVib1e6RH0n26fStiHgb2BC4pLWDJQ2SNE7SuAX/eqjKodWvJRHsfva9bP3dO9hx83XYutea/7fvzEM/y6LFwa2P/rt2AVpdGPHX2/n24DO4/s77+PbgM7nilxfWOqRca8vQSmGuSsugZnU1ShoPzABGRcSTwHoRMR0g/Vy3hTA2BN4sWJ+athVV1UQeEW9HxG8i4pG0/kZEtDpGHhFDImKniNipy+Z7VzO0XJj14UIeffFt9uvbE4Cj99yM/jv04ttXPlLjyKwePHjfvXz+C/sCsPveX+SVSS/UOKJ8a0siL8xVaRlSWFdELI6IvkAvoJ+kcs9Ct/S9IEoVqkoilzRH0uwWljmSZlejzY5i7dVWYo1VstGnrp0b2euzG/DqtFnst11PTjt4G4685EHmL1hc4yitHnRfuwcTxz8NwPPPPEXPXhvVOKJ8k8pfyhURM8mGUPoD70jaIGtLG5D11pubCvQuWO8FTCvVTlXGyCPCJzSX0/prrcw1J+9OY4NoaIC7H3+d+555i/GXHUqXzo389dwvAtkJz9Ove7LG0Vp7ueTCs5nw7NPMnjWTEw7/Ekd/4yQG//DHDL3iEhYvXkSXLisx+Afn1TrMXKvU9ENJPYCFETEzXdm+H/BL4B7g68DF6edfWyg+FthS0qbAW8BA4OiSbWbj8tUlaV2ga9N6RLxRqszqA2+qfmCWO+MuP6LWIVgd2mq9VVY4C3/qrPvLzjkv//JLrbYnaVuyk5mNZKMet0XETyWtDdwGbAS8AXw1It6X1BO4NiIGpPIDgMtS+WER8fNS8VT7gqCDgUuBnmRfIzYGJgGfqWa7ZmZtVanrgSLieWD7Frb/B9i3he3TgAEF6yOAEW1ps9qzVi4iuzz/lYjYlOyXeKzKbZqZtVlDg8pe6k21E/nC9CnUIKkhIh4imyBvZlZXqnGys71U+4KgmZJWBcYAwyXNABZVuU0zszbzvVaakdQ0D+oQ4EPgdLLb2f4LOKgabZqZrYg8D61Uq0f+F2CHiJgn6c6IOJzsLK6ZWV3Kc4+8Wom88B3ZrEptmJlVTI7zeNUSebTy2sysLrlHvqzt0qX4AlYuuCxfZDcHW71K7ZqZLZcc5/GqXaLfWI16zcyqxT1yM7Ocq8fZKOVyIjczw0MrZma556EVM7Ocy3EedyI3MwP3yM3Mci/HedyJ3MwMPGvFzCz3PLRiZpZzeU7kJW9jK+lXklaX1FnSaEnvSTq2PYIzM2svlXqwhKTekh6SNEnSC5K+l7bfKml8WqZIGt9K+SmSJqTjxpUTezk98v0j4oeSDgOmAl8FHgL+VE4DZmZ5UMEe+SLgjIh4RtJqwNOSRkXEkQVtXQrMKlLH3hHxXrkNlpPIO6efA4Cb01Ofy63fzCwXKnWyMyKmA9PT6zmSJgEbAi8CKEugXwP2qUiDlPeEoL9JegnYCRgtqQfw30oFYGZWD9oytCJpkKRxBcugluvUJsD2wJMFm/cA3omIV1sJJYCRkp5urd7mSvbII+JsSb8EZkfEYkkfkj3Czcysw2how0hDRAwBhhQ7Jj2v+E7gtIiYXbDrKODmIkV3i4hpktYFRkl6KSLGFGurnJOdqwCnAFenTT3JeudmZh1GpU52ZnWpM1kSHx4RdxVs7wR8Bbi1tbIRMS39nAHcDfQr1V45QyvXAwuAz6f1qcDPyihnZpYbkspeStQj4DpgUkT8ptnu/YCXImJqK2W7pROkSOoG7A9MLBV7OYl884j4FbAQICLms/QzOc3Mcq9B5S8l7AYcB+xTMN1wQNo3kGbDKpJ6ShqRVtcDHpX0HPAU8PeIuK9Ug+XMWlkgaWXSszclbQ58VEY5M7PcqOCslUdppbMbESe0sG0a2axAIuI1YLu2tllOIj8fuA/oLWk42afNMsGYmeWZcjzQUM6slVGSngF2JfuU+V5bJqqbmeVBju+ZVTqRS9ozvZyTfvaRRKnpMGZmeZLnCx3LGVr5QcHrrmRTYZ6mglclmZnVWo7zeFlDKwcVrkvqDfyqahGZmdVAY47HVpbnNrZTgW0qHYiZWS116KEVSb8jTT0km3feF3iuijGZmbW7HOfxsnrkhffDXUR2B8THqhSPmVlNtOVeK/WmnDHyG9sjEDOzWspvGi+SyCVN4OMhlaV2ARER21YtKjOzdtZRx8gPbLcozMxqrEPOWomI19szEDOzWspxh7ys+5HvKmmspLmSFkhaLGl2qXJmZnlSqdvY1kI5s1auJLv14u1kD5Q4HtiimkGZmbW3HI+slHdBUERMltQYEYuB6yX9b5XjMjNrV/XY0y5XOYn8Q0ldgPGSfkX2dOhu1Q3LzKx95TeNFxkjl9T0XM7j0nGDgXlAb+Dw6odmZtZ+GhtU9lJvivXIh6anQN8M3BIRLwIXtk9YZmbtK89DK632yCNie7K55IuBO9Jz586StHG7RWdm1k6k8pfi9ai3pIckTZL0gqTvpe0XSHqrhed4Ni/fX9LLkiZLOruc2ItOP4yIlyPiwojoA3wdWBN4UJLvtWJmHUqDVPZSwiLgjIjYmuzJaqdI6pP2/TYi+qZlRPOCkhqBq4ADgD7AUQVlW1XWrBVJDcC6ZE947ga8W045M7O8qNTISkRMJ5sUQkTMkTQJ2LDM4v2AyekhzEi6BTgEeLFYoaKJXNIewFHAocBE4Bbg9IiYVWZQy23Gn46vdhOWQ2vtPLjWIVgdmv/slStcR2MbMrmkQcCggk1DImJIC8dtAmwPPEn24PrBko4nu6vsGRHxQbMiGwJvFqxPBXYpFU+xm2a9CbxBlrwvjIh3SlVmZpZXbTnZmZL2Mom7WX2rAncCp0XEbElXAxeR3YzwIuBS4JvNi7XUXKl4ivXId/f9Vszsk6KSswoldSZL4sMj4i6Aws6wpKHAvS0UnUo2xbtJL2BaqfaKzVpxEjezT4wGlb8Uo6xrfx0wKSJ+U7B9g4LDDiMbrm5uLLClpE3ThZgDgXtKxb48z+w0M+twKjiPfDeyCyknSBqftv2IbAZKX7KhkinAiandnsC1ETEgIhZJGgzcDzQCwyLihVINOpGbmVG5oZWIeJSWx7qXmW6Yjp8GDChYH9Hasa0pdrKz8KHLLTX+/9rSkJlZPavHS+/LVaxHPq7IPjOzDqXkwxnqWLEnBPmhy2b2iZHjW62UHiOX1AM4i+xy0a5N2yNinyrGZWbWrsq49L5ulfNtYjgwCdiU7O6HU8imyJiZdRiVumlWLZSTyNeOiOuAhRHxz4j4JtmNYMzMOoxKzSOvhXKmHy5MP6dL+jLZVUa9qheSmVn766izVpr8TNIawBnA74DVgdOrGpWZWTvLcR4vncgjoul+ALOAvasbjplZbSjHT+0sZ9bK9bRwYVAaKzcz6xA6dI+cpe/Q1ZXsZi8l78ZlZpYnHTqRR8SdheuSbgYeqFpEZmY10NFPdja3JbBRpQMxM6ulepwfXq5yxsjnsPQY+dtkV3qamXUYeb6ys5yhldXaIxAzs1rK8chK6Ss7JY0uZ5uZWZ7l+RL9Yvcj7wqsAqwjaS0+vlH66kDPdojNzKzdNHTQeeQnAqeRJe2n+TiRzwauqm5YZmbtqzHHNyQvdj/yy4HLJZ0aEb9rx5jMzNpdpU52SuoN3ASsDywBhkTE5ZIuAQ4CFgD/Ar4RETNbKD8FmAMsBhZFxE4lYy8jriWS1ixoZC1J3y2jnJlZblRwjHwRcEZEbE12p9hTJPUBRgHbRMS2wCvAOUXq2Dsi+paTxKG8RP6dwk+NiPgA+E45lZuZ5UWDVPZSTERMj4hn0us5ZM9z2DAiRkbEonTYE1TwLrLlJPIG6ePIJTUCXSoVgJlZPajGrBVJmwDbA0822/VN4B+tFAtgpKSnJQ0qp51yruy8H7hN0jWpgZOA+8qp3MwsL9pyrjMl2MIkOyQihjQ7ZlXgTuC0iJhdsP1csuGX4a1Uv1tETJO0LjBK0ksRMaZYPOUk8rNSwCeTzVwZCQwto5yZWW605WRnStpDWtsvqTNZEh8eEXcVbP86cCCwb0Qsc1fZVPe09HOGpLuBfkDRRF7yQygilkTENRFxREQcDrxA9oAJM7MOo1Jj5Gko+jpgUkT8pmB7f7KO8cER8WErZbtJWq3pNbA/MLFU7GXdNEtSX+Ao4Ejg38BdRQuYmeVMBS8H2g04DpggaXza9iPgCmAlsuESgCci4iRJPYFrI2IAsB5wd9rfCfhzRJQcyi52ZedWwECyBP4f4FZAEeGnBJlZh1OpS+8j4lFa/lwY0crx04AB6fVrwHZtbbNYj/wl4BHgoIiYDCDJz+o0sw5JlcrkNVBsjPxwslvWPiRpqKR9qei3DzOz+tEolb3Um1YTeUTcHRFHAp8GHgZOB9aTdLWk/dspPjOzdqE2LPWmnFkr8yJieEQcSHYl0njg7GoHZmbWniSVvdSbNt3vKyLej4g/RMQ+1QrIzKwWGtqw1JvleWanmVmHU4897XI5kZuZUZ9j3+VyIjczg7qcjVIuJ3IzM+rzWZzlciI3MwOU48EVJ3IzM9wjNzPLvQb3yM3M8q2hHieIl6lqoStzrKSfpPWNJPWrVntmZitCbfiv3lTzM+j3wOfIboMLMAe4qortmZkttwaVv9Sbag6t7BIRO0h6FiAiPpDkhzabWV2qx552uaqZyBdKaiR7YDOSegBLqtiemdly86yVll0B3A2sK+nnwBHAeVVsr0P4yXnnMOafD9O9+9rc9dd7Abj6qt9x5x230X2t7gCcetr32WPPL9QyTGtHK3XpxAPXnUaXLp3o1NjI3Q88y8+uGcG5Jw7gm1/5PO9+MBeA86+8h/sffbHG0eaXe+QtiIjhkp4Gmh5IcWhETKpWex3FIYd+haOOPpZzzzlrqe3HHX8CX//Gt2oUldXSRwsW0X/QFcybv4BOnRp4cNj3GflYlrB/96eHuOyPo2scYcdQqUv0JfUGbgLWJxuFGBIRl0vqTvbIzE2AKcDXIuKDFsr3By4HGsme5XlxqTarOWtlI+BD4G/APcC8tM2K2HGnnVl9jTVqHYbVmXnzFwDQuVMjnTo1EhE1jqjjkcpfSlgEnBERWwO7AqdI6kP2HIfREbElMJoWnuuQhqOvAg4A+gBHpbJFVXPWyt+Be9PP0cBrwD+q2F6Hdsufh3PEYQfxk/POYfasWbUOx9pZQ4N44pazeWP0xTz4xEuMnfg6ACcN3JOnbj2Ha84/hjVXW7nGUeZbpZ4QFBHTI+KZ9HoOMAnYEDgEuDEddiNwaAvF+wGTI+K1iFgA3JLKFVW1RB4Rn42IbdPPLVOAj1arvY7sa0cexb33jeK2O/9Kjx7r8utLSn7Tsg5myZJg14EXs8WXzmOnbTamz+YbMPT2R+hz0AXsMvBi3n5vNhd//yu1DjPXGqSyl3JJ2gTYHngSWC8ipkOW7IF1WyiyIfBmwfrUtK147GVHtILSJ9TOxY6RNEjSOEnjrhs6pJ0iq39rr7MOjY2NNDQ08JUjvsrECRNqHZLVyKy58xkz7lX2/3wfZrw/hyVLgohg2F2PsdM2G9c6vFxrS4+8MFelZdAy9UmrAncCp0XE7DaE0VzJcbSqneyU9P2C1QZgB+DdYmUiYggwBOC/i0oH/0nx7rsz6NEj+/B+8IEH2GLLLWsckbWnddZalYULFzNr7ny6rtSZfXb5FJfe8ADrr7M6b7+X5YdD9tmOF/81vcaR5lwbznUW5qoWq5I6kyXx4RFxV9r8jqQNImK6pA2AGS0UnQr0LljvBUwrFU81px+uVvB6EdlY+Z1VbK9DOOvM7zNu7FPMnPkBX9xnT04+5VTGjX2Kl196CQl69tyQH1/w01qHae1o/XVWZ+hPj6OxoYGGBnHnqGf4xyMTue6i49n2U72ICF6f/j6n/uzmWoeaa20ZMilG2TPjrgMmRcRvCnbdA3wduDj9/GsLxccCW0raFHgLGAgcXbLNapz9TmdeL46IHyxvHe6RW0vW2nlwrUOwOjT/2StXOAuPfW1W2Tln583WaLU9SbsDjwAT+PgiyB+RjZPfBmwEvAF8NSLel9STbJrhgFR+AHAZ2fTDYRHx81LxVLxHLqlTRCyStEOl6zYzq5oKXQ8UEY8WqW3fFo6fBgwoWB8BjGhLm9UYWnmKbDx8vKR7gNuBeU07C8aLzMzqhq/sbFl34D/APmRnXZV+OpGbWd3xvVaWtm6asTKRjxN4E497m1ldciJfWiOwKss5H9LMrBY8tLK06RHh+XFmlivukS8tx2+HmX1S5TlxVSORLzO9xsys7uU4k1c8kUfE+5Wu08ys2jxGbmaWc/X4UOVyOZGbmYGHVszM8s5DK2ZmOefph2ZmOZfjPO5EbmYG5DqTO5GbmVG5B0vUghO5mRm57pA7kZuZAbnO5E7kZmZ4+qGZWe5Vcohc0jDgQGBGRGyTtt0KfCodsiYwMyL6tlB2CjAHWAwsioidSrXnRG5mRsXnkd8AXAnc1LQhIo78uC1dCswqUn7viHiv3MacyM3MqOzQSkSMkbRJi+1IAr5G9hjMimioVEVmZnkmlb+soD2AdyLi1Vb2BzBS0tOSBpVToXvkZma0bdJKSrCFSXZIRAwps/hRwM1F9u8WEdMkrQuMkvRSRIwpVqETuZkZtCmTp6RdbuL+uAmpE/AVYMcidU9LP2dIuhvoBxRN5B5aMTMjGyMv978VsB/wUkRMbTEGqZuk1ZpeA/sDE0tV6kRuZkb2YIlyl1Ik3Qw8DnxK0lRJ30q7BtJsWEVST0kj0up6wKOSngOeAv4eEfeVas9DK2ZmVHb6YUQc1cr2E1rYNg0YkF6/BmzX1vacyM3MgDxfo+9EbmaGHyxhZpZ7Oc7jTuRmZuAeuZlZ7inHmdyJ3MwMD62YmeVejjvkTuRmZuAHS5iZ5V9+87gTuZkZlHfpfb1yIjczw0MrZma5l+eTnb77oZlZzrlHbmZGvnvkTuRmZniM3Mws9zxrxcws75zIzczyzUMrZmY5l+eTnZ5+aGZGNrJS7lKyLmmYpBmSJhZsu0DSW5LGp2VAK2X7S3pZ0mRJZ5cTuxO5mRlUNpPDDUD/Frb/NiL6pmXEMiFIjcBVwAFAH+AoSX1KNeZEbmYGNEhlL6VExBjg/eUIox8wOSJei4gFwC3AIaUK1e0YeddOOT7zUGGSBkXEkFrHUQ/mP3tlrUOoG/67qKy25BxJg4BBBZuGlPlvMVjS8cA44IyI+KDZ/g2BNwvWpwK7lKrUPfJ8GFT6EPsE8t9FjUTEkIjYqWApJ4lfDWwO9AWmA5e2cExLHyZRqmIncjOzdhAR70TE4ohYAgwlG0ZpbirQu2C9FzCtVN1O5GZm7UDSBgWrhwETWzhsLLClpE0ldQEGAveUqrtux8htKR4HtZb476JOSboZ2AtYR9JU4HxgL0l9yYZKpgAnpmN7AtdGxICIWCRpMHA/0AgMi4gXSrYXUXL4xczM6piHVszMcs6J3Mws5zxGXiOSFgMTCjYdGhFTWjl2bkSs2i6BWU1JWhsYnVbXBxYD76b1fukiEbOleIy8RtqSnJ3IP5kkXQDMjYhfF2zrFBGLaheV1SMPrdQJSatKGi3pGUkTJC1zWa6kDSSNSTfcmShpj7R9f0mPp7K3S3LS70Ak3SDpN5IeAn6Zbr50ZsH+iZI2Sa+PlfRU+hv5Q7p3h3VwTuS1s3LBXdDuBv4LHBYROwB7A5dKy9zU4Wjg/ojoC2wHjJe0DnAesF8qOw74frv9FtZetiL7Nz6jtQMkbQ0cCeyW/kYWA8e0T3hWSx4jr5356X82ACR1Bn4haU9gCdk9F9YD3i4oMxYYlo79S0SMl/QFsrukPZbyfhfg8fb5Fawd3R4Ri0scsy+wIzA2/S2sDMyodmBWe07k9eMYoAewY0QslDQF6Fp4QESMSYn+y8AfJV0CfACMioij2jtga1fzCl4vYulv001/JwJujIhz2i0qqwseWqkfawAzUhLfG9i4+QGSNk7HDAWuA3YAngB2k7RFOmYVSVu1Y9zW/qaQ/dsjaQdg07R9NHCEpHXTvu7pb8Y6OPfI68dw4G+SxgHjgZdaOGYv4AeSFgJzgeMj4l1JJwA3S1opHXce8ErVI7ZauRM4XtJ4suG2VwAi4kVJ5wEjJTUAC4FTgNdrFai1D08/NDPLOQ+tmJnlnBO5mVnOOZGbmeWcE7mZWc45kZuZ5ZwTuZlZzjmRm5nlnBO5mVnOOZGbmeWcE7mZWc45kZuZ5ZwTuZlZzjmRm5nlnBO5mVnOOZGbmeWcE7mZWc45kdtSJC2WNF7SREm3S1plBeq6QdIR6fW1kvoUOXYvSZ9fjjamSFqnhXZPbLbtUEkjyonVLG+cyK25+RHRNyK2ARYAJxXulNS4PJVGxLcj4sUih+wFtDmRt+JmYGCzbQPTdrMOx4ncinkE2CL1lh+S9GdggqRGSZdIGivp+aberzJXSnpR0t+BdZsqkvSwpJ3S6/6SnpH0nKTRkjYh+8A4PX0b2ENSD0l3pjbGStotlV1b0khJz0r6A9mT45t7APi0pA1SmVWA/YC/SPpJqm+ipCGSlilf2MuXtJOkh9PrbpKGpfLPSjokbf+MpKdS7M9L2rISb75ZuZzIrUWSOgEHABPSpn7AuRHRB/gWMCsidgZ2Br4jaVPgMOBTwGeB79BCD1tSD2AocHhEbAd8NSKmANcAv03fBh4BLk/rOwOHA9emKs4HHo2I7YF7gI2atxERi4G7gK+lTQcDD0XEHODKiNg5feNYGTiwDW/LucCDKaa9gUskdSP7ELo8IvoCOwFT21Cn2QrrVOsArO6snJ7ODlmP/DqyhPxURPw7bd8f2LZgTHkNYEtgT+DmlEinSXqwhfp3BcY01RUR77cSx35An4IO8+qSVkttfCWV/bukD1opfzNwCdkHwkDgprR9b0k/BFYBugMvAH9rpY7m9gcOlnRmWu9K9kHyOHCupF7AXRHxapn1mVWEE7k1Nz/1LP9PSqbzCjcBp0bE/c2OGwBEifpVxjGQfVv8XETMbyGWcso/BmwgaTuyD6KBkroCvwd2iog3JV1AloybW8TH31YL94vsm8TLzY6fJOlJ4MvA/ZK+HREtfYiZVYWHVmx53A+cLKkzgKSt0hDDGLKE2ZjGp/duoezjwBfSUAySuqftc4DVCo4bCQxuWpHUN70cAxyTth0ArNVSgBERwG3AjcCIiPgvHyfl9yStCrQ2S2UKsGN6fXiz3/vUpnF1Sdunn5sBr0XEFWTDPdu2Uq9ZVTiR2/K4FngReEbSROAPZN/u7gZeJRtXvxr4Z/OCEfEuMAi4S9JzwK1p19+Aw5pOdgL/D9gpnTx8kY9nz1wI7CnpGbKhjjeKxHkzsB1wS2p7Jtn4/ATgL8DYVspdCFwu6RFgccH2i4DOwPPp974obT8SmJiGpD7Nx8M4Zu1CWcfFzMzyyj1yM7OccyI3M8s5J3Izs5xzIjczyzkncjOznHMiNzPLOSdyM7OccyI3M8u5/w/xGI3T6IfwMgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "comparing.show_confusion_matrix()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7be5ed7",
   "metadata": {},
   "source": [
    "### Custom search parameter dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44dbb72c",
   "metadata": {},
   "source": [
    "We can change search parameter dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "id": "e5df36e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "random_search_dict = {'kernel': ['linear', 'rbf'],\n",
    "               'C': loguniform(1, 100),'gamma': loguniform(0.001, 0.01)\n",
    "               }\n",
    "\n",
    "search_grid = [\n",
    "               {'C': [1, 10], 'kernel': ['linear']},\n",
    "               {'C': [1, 10], 'gamma': [0.01, 0.001],\n",
    "               'kernel': ['rbf']}\n",
    "               ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "id": "5a235f20",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████| 4/4 [00:31<00:00,  7.88s/it]\n"
     ]
    },
    {
     "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>name</th>\n",
       "      <th>best_params</th>\n",
       "      <th>best_score</th>\n",
       "      <th>run_time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>GridSearchCV</td>\n",
       "      <td>{'C': 10, 'gamma': 0.001, 'kernel': 'rbf'}</td>\n",
       "      <td>0.700000</td>\n",
       "      <td>2.716724</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>RandomizedSearchCV</td>\n",
       "      <td>{'C': 46.34072232727819, 'gamma': 0.0133929499...</td>\n",
       "      <td>0.666667</td>\n",
       "      <td>22.461593</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>HalvingRandomSearchCV</td>\n",
       "      <td>{'C': 19.578897201212996, 'gamma': 0.027389695...</td>\n",
       "      <td>0.616667</td>\n",
       "      <td>6.238736</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>HalvingGridSearchCV</td>\n",
       "      <td>{'C': 10, 'gamma': 0.01, 'kernel': 'rbf'}</td>\n",
       "      <td>0.694737</td>\n",
       "      <td>0.115067</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                    name                                        best_params  \\\n",
       "0           GridSearchCV         {'C': 10, 'gamma': 0.001, 'kernel': 'rbf'}   \n",
       "1     RandomizedSearchCV  {'C': 46.34072232727819, 'gamma': 0.0133929499...   \n",
       "2  HalvingRandomSearchCV  {'C': 19.578897201212996, 'gamma': 0.027389695...   \n",
       "3    HalvingGridSearchCV          {'C': 10, 'gamma': 0.01, 'kernel': 'rbf'}   \n",
       "\n",
       "   best_score   run_time  \n",
       "0    0.700000   2.716724  \n",
       "1    0.666667  22.461593  \n",
       "2    0.616667   6.238736  \n",
       "3    0.694737   0.115067  "
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "comparing_with_custom_space = CompareSearchMethods(X,y, random_p_space = random_search_dict, grid_p_space = search_grid)\n",
    "\n",
    "result_df_with_custom_space = comparing_with_custom_space.run_and_show_results()\n",
    "result_df_with_custom_space"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5fc2b31a",
   "metadata": {},
   "source": [
    "### Custom metric"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "id": "960cf7f3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['accuracy',\n",
       " 'adjusted_mutual_info_score',\n",
       " 'adjusted_rand_score',\n",
       " 'average_precision',\n",
       " 'balanced_accuracy',\n",
       " 'completeness_score',\n",
       " 'explained_variance',\n",
       " 'f1',\n",
       " 'f1_macro',\n",
       " 'f1_micro',\n",
       " 'f1_samples',\n",
       " 'f1_weighted',\n",
       " 'fowlkes_mallows_score',\n",
       " 'homogeneity_score',\n",
       " 'jaccard',\n",
       " 'jaccard_macro',\n",
       " 'jaccard_micro',\n",
       " 'jaccard_samples',\n",
       " 'jaccard_weighted',\n",
       " 'max_error',\n",
       " 'mutual_info_score',\n",
       " 'neg_brier_score',\n",
       " 'neg_log_loss',\n",
       " 'neg_mean_absolute_error',\n",
       " 'neg_mean_absolute_percentage_error',\n",
       " 'neg_mean_gamma_deviance',\n",
       " 'neg_mean_poisson_deviance',\n",
       " 'neg_mean_squared_error',\n",
       " 'neg_mean_squared_log_error',\n",
       " 'neg_median_absolute_error',\n",
       " 'neg_root_mean_squared_error',\n",
       " 'normalized_mutual_info_score',\n",
       " 'precision',\n",
       " 'precision_macro',\n",
       " 'precision_micro',\n",
       " 'precision_samples',\n",
       " 'precision_weighted',\n",
       " 'r2',\n",
       " 'rand_score',\n",
       " 'recall',\n",
       " 'recall_macro',\n",
       " 'recall_micro',\n",
       " 'recall_samples',\n",
       " 'recall_weighted',\n",
       " 'roc_auc',\n",
       " 'roc_auc_ovo',\n",
       " 'roc_auc_ovo_weighted',\n",
       " 'roc_auc_ovr',\n",
       " 'roc_auc_ovr_weighted',\n",
       " 'top_k_accuracy',\n",
       " 'v_measure_score']"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(sklearn.metrics.SCORERS.keys())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6719a6a",
   "metadata": {},
   "source": [
    "We can change metric score that stragety should maximize. It accepts all possible metrics that occurs in scklearn library."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "id": "d34f92f4",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████| 4/4 [00:18<00:00,  4.68s/it]\n"
     ]
    },
    {
     "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>name</th>\n",
       "      <th>best_params</th>\n",
       "      <th>best_score</th>\n",
       "      <th>run_time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>GridSearchCV</td>\n",
       "      <td>{'C': 1, 'gamma': 0.01, 'kernel': 'rbf'}</td>\n",
       "      <td>0.682000</td>\n",
       "      <td>7.371120</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>RandomizedSearchCV</td>\n",
       "      <td>{'C': 64.96847871354835, 'gamma': 0.0121961641...</td>\n",
       "      <td>0.620000</td>\n",
       "      <td>8.891215</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>HalvingRandomSearchCV</td>\n",
       "      <td>{'C': 19.578897201212996, 'gamma': 0.027389695...</td>\n",
       "      <td>0.542579</td>\n",
       "      <td>2.354873</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>HalvingGridSearchCV</td>\n",
       "      <td>{'C': 1, 'gamma': 0.001, 'kernel': 'rbf'}</td>\n",
       "      <td>0.617024</td>\n",
       "      <td>0.089458</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                    name                                        best_params  \\\n",
       "0           GridSearchCV           {'C': 1, 'gamma': 0.01, 'kernel': 'rbf'}   \n",
       "1     RandomizedSearchCV  {'C': 64.96847871354835, 'gamma': 0.0121961641...   \n",
       "2  HalvingRandomSearchCV  {'C': 19.578897201212996, 'gamma': 0.027389695...   \n",
       "3    HalvingGridSearchCV          {'C': 1, 'gamma': 0.001, 'kernel': 'rbf'}   \n",
       "\n",
       "   best_score  run_time  \n",
       "0    0.682000  7.371120  \n",
       "1    0.620000  8.891215  \n",
       "2    0.542579  2.354873  \n",
       "3    0.617024  0.089458  "
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "comparing_with_custom_metric = CompareSearchMethods(X,y,metric_score = 'roc_auc')\n",
    "\n",
    "comparing_with_custom_metric = comparing_with_custom_metric.run_and_show_results()\n",
    "comparing_with_custom_metric"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4aa3e513",
   "metadata": {},
   "source": [
    "### Custom estimator\n",
    "\n",
    "Default estimator is SVM, but you can change it as well. Just be sure that you have also changed parameter spaces."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "id": "70a425f2",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████| 4/4 [00:11<00:00,  2.80s/it]\n"
     ]
    },
    {
     "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>name</th>\n",
       "      <th>best_params</th>\n",
       "      <th>best_score</th>\n",
       "      <th>run_time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>GridSearchCV</td>\n",
       "      <td>{'bootstrap': True, 'max_depth': 110, 'max_fea...</td>\n",
       "      <td>0.640000</td>\n",
       "      <td>4.204950</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>RandomizedSearchCV</td>\n",
       "      <td>{'n_estimators': 400, 'min_samples_leaf': 4, '...</td>\n",
       "      <td>0.640000</td>\n",
       "      <td>1.790703</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>HalvingRandomSearchCV</td>\n",
       "      <td>{'n_estimators': 200, 'min_samples_leaf': 4, '...</td>\n",
       "      <td>0.633333</td>\n",
       "      <td>1.173431</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>HalvingGridSearchCV</td>\n",
       "      <td>{'bootstrap': True, 'max_depth': 110, 'max_fea...</td>\n",
       "      <td>0.666667</td>\n",
       "      <td>4.011535</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                    name                                        best_params  \\\n",
       "0           GridSearchCV  {'bootstrap': True, 'max_depth': 110, 'max_fea...   \n",
       "1     RandomizedSearchCV  {'n_estimators': 400, 'min_samples_leaf': 4, '...   \n",
       "2  HalvingRandomSearchCV  {'n_estimators': 200, 'min_samples_leaf': 4, '...   \n",
       "3    HalvingGridSearchCV  {'bootstrap': True, 'max_depth': 110, 'max_fea...   \n",
       "\n",
       "   best_score  run_time  \n",
       "0    0.640000  4.204950  \n",
       "1    0.640000  1.790703  \n",
       "2    0.633333  1.173431  \n",
       "3    0.666667  4.011535  "
      ]
     },
     "execution_count": 173,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random_grid = {'bootstrap': [False],\n",
    " 'max_depth': [10, 20,  None],\n",
    " 'max_features': ['auto', 'sqrt'],\n",
    " 'min_samples_leaf': [1,4],\n",
    " 'n_estimators': [200, 400]}\n",
    "\n",
    "param_grid = {\n",
    "    'bootstrap': [True],\n",
    "    'max_depth': [80, 110],\n",
    "    'max_features': [2, 3],\n",
    "    'min_samples_split': [8, 10, 12],\n",
    "    'n_estimators': [100, 200]\n",
    "}\n",
    "\n",
    "comparing_with_custom_estr = CompareSearchMethods(X, y, estimator = RandomForestClassifier(), random_p_space = random_grid, grid_p_space = param_grid)\n",
    "\n",
    "result_df_with_custom_estr  = comparing_with_custom_estr.run_and_show_results()\n",
    "result_df_with_custom_estr"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62637c08",
   "metadata": {},
   "source": [
    "# Conclusion"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6acc8934",
   "metadata": {},
   "source": [
    "I think that, among the four approaches, HalvingRandomSearchCV is very useful because it’s faster and, since it doesn’t reach the best point in the grid, it avoids overfitting and is more able to generalize. However, for small grids (i.e. less than 200 points) I suggest using HalvingGridSearchCV if the training phase is not too slow. For the general-purpose cases, the random search may increase training speed and reach a reasonably good solution for our model.\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}